首页 技术 正文

SSD框架训练自己的数据集

技术 2022年11月16日
0 收藏 691 点赞 4,611 浏览 144385 个字

<!–
pre.cjk { font-family: “Droid Sans Fallback”,monospace; }p { margin-bottom: 0.25cm; line-height: 120%; }a:link { }
–>

SSD demo中详细介绍了如何在VOC数据集上使用SSD进行物体检测的训练和验证。
本文介绍如何使用SSD实现对自己数据集的训练和验证过程，内容包括：
1 数据集的标注
2 数据集的转换
3 使用SSD如何训练
4 使用SSD如何测试1 数据集的标注　　　数据的标注使用BBox-Label-Tool工具，该工具使用python实现，使用简单方便。修改后的工具支持多label的标签标注。
该工具生成的标签格式是:
object_number
className x1min y1min x1max y1max
classname x2min y2min x2max y2max
...
1.1 labelTool工具的使用说明
　　BBox-Label-Tool工具实现较简单，原始的git版本使用起来有一些小问题，进行了简单的修改，修改后的版本
#-------------------------------------------------------------------------------
# Name:        Object bounding box label tool
# Purpose:     Label object bboxes for ImageNet Detection data
# Author:      Qiushi
# Created:     06/06/2014#
#-------------------------------------------------------------------------------
from __future__ import division
from Tkinter import *
import tkMessageBox
from PIL import Image, ImageTk
import os
import glob
import random# colors for the bboxes
COLORS = ['red', 'blue', 'yellow', 'pink', 'cyan', 'green', 'black']
# image sizes for the examples
SIZE = 256, 256classLabels=['mat', 'door', 'sofa', 'chair', 'table', 'bed', 'ashcan', 'shoe']class LabelTool():
    def __init__(self, master):
        # set up the main frame
        self.parent = master
        self.parent.title("LabelTool")
        self.frame = Frame(self.parent)
        self.frame.pack(fill=BOTH, expand=1)
        self.parent.resizable(width = False, height = False)        # initialize global state
        self.imageDir = ''
        self.imageList= []
        self.egDir = ''
        self.egList = []
        self.outDir = ''
        self.cur = 0
        self.total = 0
        self.category = 0
        self.imagename = ''
        self.labelfilename = ''
        self.tkimg = None        # initialize mouse state
        self.STATE = {}
        self.STATE['click'] = 0
        self.STATE['x'], self.STATE['y'] = 0, 0        # reference to bbox
        self.bboxIdList = []
        self.bboxId = None
        self.bboxList = []
        self.hl = None
        self.vl = None
        self.currentClass = ''        # ----------------- GUI stuff ---------------------
        # dir entry & load
        self.label = Label(self.frame, text = "Image Dir:")
        self.label.grid(row = 0, column = 0, sticky = E)
        self.entry = Entry(self.frame)
        self.entry.grid(row = 0, column = 1, sticky = W+E)
        self.ldBtn = Button(self.frame, text = "Load", command = self.loadDir)
        self.ldBtn.grid(row = 0, column = 2, sticky = W+E)        # main panel for labeling
        self.mainPanel = Canvas(self.frame, cursor='tcross')
        self.mainPanel.bind("<Button-1>", self.mouseClick)
        self.mainPanel.bind("<Motion>", self.mouseMove)
        self.parent.bind("<Escape>", self.cancelBBox)  # press <Espace> to cancel current bbox
        self.parent.bind("s", self.cancelBBox)
        self.parent.bind("a", self.prevImage) # press 'a' to go backforward
        self.parent.bind("d", self.nextImage) # press 'd' to go forward
        self.mainPanel.grid(row = 1, column = 1, rowspan = 4, sticky = W+N)        # showing bbox info & delete bbox
        self.lb1 = Label(self.frame, text = 'Bounding boxes:')
        self.lb1.grid(row = 1, column = 2,  sticky = W+N)
        self.listbox = Listbox(self.frame, width = 22, height = 12)
        self.listbox.grid(row = 2, column = 2, sticky = N)
        self.btnDel = Button(self.frame, text = 'Delete', command = self.delBBox)
        self.btnDel.grid(row = 3, column = 2, sticky = W+E+N)
        self.btnClear = Button(self.frame, text = 'ClearAll', command = self.clearBBox)
        self.btnClear.grid(row = 4, column = 2, sticky = W+E+N)        #select class type
        self.classPanel = Frame(self.frame)
        self.classPanel.grid(row = 5, column = 1, columnspan = 10, sticky = W+E)
        label = Label(self.classPanel, text = 'class:')
        label.grid(row = 5, column = 1,  sticky = W+N)        self.classbox = Listbox(self.classPanel,  width = 4, height = 2)
        self.classbox.grid(row = 5,column = 2)
        for each in range(len(classLabels)):
            function = 'select' + classLabels[each]
            print classLabels[each]
            btnMat = Button(self.classPanel, text = classLabels[each], command = getattr(self, function))
            btnMat.grid(row = 5, column = each + 3)        # control panel for image navigation
        self.ctrPanel = Frame(self.frame)
        self.ctrPanel.grid(row = 6, column = 1, columnspan = 2, sticky = W+E)
        self.prevBtn = Button(self.ctrPanel, text='<< Prev', width = 10, command = self.prevImage)
        self.prevBtn.pack(side = LEFT, padx = 5, pady = 3)
        self.nextBtn = Button(self.ctrPanel, text='Next >>', width = 10, command = self.nextImage)
        self.nextBtn.pack(side = LEFT, padx = 5, pady = 3)
        self.progLabel = Label(self.ctrPanel, text = "Progress:     /    ")
        self.progLabel.pack(side = LEFT, padx = 5)
        self.tmpLabel = Label(self.ctrPanel, text = "Go to Image No.")
        self.tmpLabel.pack(side = LEFT, padx = 5)
        self.idxEntry = Entry(self.ctrPanel, width = 5)
        self.idxEntry.pack(side = LEFT)
        self.goBtn = Button(self.ctrPanel, text = 'Go', command = self.gotoImage)
        self.goBtn.pack(side = LEFT)        # example pannel for illustration
        self.egPanel = Frame(self.frame, border = 10)
        self.egPanel.grid(row = 1, column = 0, rowspan = 5, sticky = N)
        self.tmpLabel2 = Label(self.egPanel, text = "Examples:")
        self.tmpLabel2.pack(side = TOP, pady = 5)
        self.egLabels = []
        for i in range(3):
            self.egLabels.append(Label(self.egPanel))
            self.egLabels[-1].pack(side = TOP)        # display mouse position
        self.disp = Label(self.ctrPanel, text='')
        self.disp.pack(side = RIGHT)        self.frame.columnconfigure(1, weight = 1)
        self.frame.rowconfigure(10, weight = 1)        # for debugging
##        self.setImage()
##        self.loadDir()    def loadDir(self, dbg = False):
        if not dbg:
            s = self.entry.get()
            self.parent.focus()
            self.category = int(s)
        else:
            s = r'D:\workspace\python\labelGUI'
##        if not os.path.isdir(s):
##            tkMessageBox.showerror("Error!", message = "The specified dir doesn't exist!")
##            return
        # get image list
        self.imageDir = os.path.join(r'./Images', '%d' %(self.category))
        self.imageList = glob.glob(os.path.join(self.imageDir, '*.jpg'))
        if len(self.imageList) == 0:
            print 'No .JPEG images found in the specified dir!'
            return         # set up output dir
        self.outDir = os.path.join(r'./Labels', '%d' %(self.category))
        if not os.path.exists(self.outDir):
            os.mkdir(self.outDir)        labeledPicList = glob.glob(os.path.join(self.outDir, '*.txt'))        for label in labeledPicList:
            data = open(label, 'r')
            if '0\n' == data.read():
                data.close()
                continue
            data.close()
            picture = label.replace('Labels', 'Images').replace('.txt', '.jpg')
            if picture in self.imageList:
                self.imageList.remove(picture)
        # default to the 1st image in the collection
        self.cur = 1
        self.total = len(self.imageList)
        self.loadImage()
        print '%d images loaded from %s' %(self.total, s)    def loadImage(self):
        # load image
        imagepath = self.imageList[self.cur - 1]
        self.img = Image.open(imagepath)
        self.imgSize = self.img.size
        self.tkimg = ImageTk.PhotoImage(self.img)
        self.mainPanel.config(width = max(self.tkimg.width(), 400), height = max(self.tkimg.height(), 400))
        self.mainPanel.create_image(0, 0, image = self.tkimg, anchor=NW)
        self.progLabel.config(text = "%04d/%04d" %(self.cur, self.total))        # load labels
        self.clearBBox()
        self.imagename = os.path.split(imagepath)[-1].split('.')[0]
        labelname = self.imagename + '.txt'
        self.labelfilename = os.path.join(self.outDir, labelname)
        bbox_cnt = 0
        if os.path.exists(self.labelfilename):
            with open(self.labelfilename) as f:
                for (i, line) in enumerate(f):
                    if i == 0:
                        bbox_cnt = int(line.strip())
                        continue
                    tmp = [int(t.strip()) for t in line.split()]
##                    print tmp
                    self.bboxList.append(tuple(tmp))
                    tmpId = self.mainPanel.create_rectangle(tmp[0], tmp[1], \
                                                            tmp[2], tmp[3], \
                                                            width = 2, \
                                                            outline = COLORS[(len(self.bboxList)-1) % len(COLORS)])
                    self.bboxIdList.append(tmpId)
                    self.listbox.insert(END, '(%d, %d) -> (%d, %d)' %(tmp[0], tmp[1], tmp[2], tmp[3]))
                    self.listbox.itemconfig(len(self.bboxIdList) - 1, fg = COLORS[(len(self.bboxIdList) - 1) % len(COLORS)])    def saveImage(self):
        with open(self.labelfilename, 'w') as f:
            f.write('%d\n' %len(self.bboxList))
            for bbox in self.bboxList:
                f.write(' '.join(map(str, bbox)) + '\n')
        print 'Image No. %d saved' %(self.cur)    def mouseClick(self, event):
        if self.STATE['click'] == 0:
            self.STATE['x'], self.STATE['y'] = event.x, event.y
            #self.STATE['x'], self.STATE['y'] = self.imgSize[0], self.imgSize[1]
        else:
            x1, x2 = min(self.STATE['x'], event.x), max(self.STATE['x'], event.x)
            y1, y2 = min(self.STATE['y'], event.y), max(self.STATE['y'], event.y)
            if x2 > self.imgSize[0]:
                x2 = self.imgSize[0]
            if y2 > self.imgSize[1]:
                y2 = self.imgSize[1]
            self.bboxList.append((self.currentClass, x1, y1, x2, y2))
            self.bboxIdList.append(self.bboxId)
            self.bboxId = None
            self.listbox.insert(END, '(%d, %d) -> (%d, %d)' %(x1, y1, x2, y2))
            self.listbox.itemconfig(len(self.bboxIdList) - 1, fg = COLORS[(len(self.bboxIdList) - 1) % len(COLORS)])
        self.STATE['click'] = 1 - self.STATE['click']    def mouseMove(self, event):
        self.disp.config(text = 'x: %d, y: %d' %(event.x, event.y))
        if self.tkimg:
            if self.hl:
                self.mainPanel.delete(self.hl)
            self.hl = self.mainPanel.create_line(0, event.y, self.tkimg.width(), event.y, width = 2)
            if self.vl:
                self.mainPanel.delete(self.vl)
            self.vl = self.mainPanel.create_line(event.x, 0, event.x, self.tkimg.height(), width = 2)
        if 1 == self.STATE['click']:
            if self.bboxId:
                self.mainPanel.delete(self.bboxId)
            self.bboxId = self.mainPanel.create_rectangle(self.STATE['x'], self.STATE['y'], \
                                                            event.x, event.y, \
                                                            width = 2, \
                                                            outline = COLORS[len(self.bboxList) % len(COLORS)])    def cancelBBox(self, event):
        if 1 == self.STATE['click']:
            if self.bboxId:
                self.mainPanel.delete(self.bboxId)
                self.bboxId = None
                self.STATE['click'] = 0    def delBBox(self):
        sel = self.listbox.curselection()
        if len(sel) != 1 :
            return
        idx = int(sel[0])
        self.mainPanel.delete(self.bboxIdList[idx])
        self.bboxIdList.pop(idx)
        self.bboxList.pop(idx)
        self.listbox.delete(idx)    def clearBBox(self):
        for idx in range(len(self.bboxIdList)):
            self.mainPanel.delete(self.bboxIdList[idx])
        self.listbox.delete(0, len(self.bboxList))
        self.bboxIdList = []
        self.bboxList = []    def selectmat(self):
        self.currentClass = 'mat'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'mat')
        self.classbox.itemconfig(0,fg = COLORS[0])    def selectdoor(self):
        self.currentClass = 'door'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'door')
        self.classbox.itemconfig(0,fg = COLORS[0])    def selectsofa(self):
        self.currentClass = 'sofa'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'sofa')
        self.classbox.itemconfig(0,fg = COLORS[0])    def selectchair(self):
        self.currentClass = 'chair'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'chair')
        self.classbox.itemconfig(0,fg = COLORS[0])    def selecttable(self):
        self.currentClass = 'table'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'table')
        self.classbox.itemconfig(0,fg = COLORS[0])    def selectbed(self):
        self.currentClass = 'bed'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'bed')
        self.classbox.itemconfig(0,fg = COLORS[0])    def selectashcan(self):
        self.currentClass = 'ashcan'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'ashcan')
        self.classbox.itemconfig(0,fg = COLORS[0])    def selectshoe(self):
        self.currentClass = 'shoe'
        self.classbox.delete(0,END)
        self.classbox.insert(0, 'shoe')
        self.classbox.itemconfig(0,fg = COLORS[0])        def prevImage(self, event = None):
        self.saveImage()
        if self.cur > 1:
            self.cur -= 1
            self.loadImage()    def nextImage(self, event = None):
        self.saveImage()
        if self.cur < self.total:
            self.cur += 1
            self.loadImage()    def gotoImage(self):
        idx = int(self.idxEntry.get())
        if 1 <= idx and idx <= self.total:
            self.saveImage()
            self.cur = idx
            self.loadImage()##    def setImage(self, imagepath = r'test2.png'):
##        self.img = Image.open(imagepath)
##        self.tkimg = ImageTk.PhotoImage(self.img)
##        self.mainPanel.config(width = self.tkimg.width())
##        self.mainPanel.config(height = self.tkimg.height())
##        self.mainPanel.create_image(0, 0, image = self.tkimg, anchor=NW)if __name__ == '__main__':
    root = Tk()
    tool = LabelTool(root)
    root.mainloop()

main.py



　　使用方法：


　　　　 (1) 在BBox-Label-Tool/Images目录下创建保存图片的目录， 目录以数字命名(BBox-Label-Tool/Images/1), 然后将待标注的图片copy到1这个目录下;


　　　　 (2) 在BBox-Label-Tool目录下执行命令   python main.py


　　　　 (3) 在工具界面上, Image Dir 框中输入需要标记的目录名(比如 1), 然后点击load按钮, 工具自动将Images/1目录下的图片加载进来;


　　　　　　需要说明一下, 如果目录中的图片已经标注过,点击load时不会被重新加载进来.


　　　　 (4) 该工具支持多类别标注, 画bounding boxs框标定之前,需要先选定类别,然后再画框.


　　　　 (5) 一张图片标注完后, 点击Next>>按钮, 标注下一张图片,  图片label成功后,会在BBox-Label-Tool/Labels对应的目录下生成与图片文件名对应的label文件.


2 数据集的转换


　　caffe训练使用LMDB格式的数据，ssd框架中提供了voc数据格式转换成LMDB格式的脚本。
所以实践中先将BBox-Label-Tool标注的数据转换成voc数据格式，然后再转换成LMDB格式。2.1 voc数据格式


aaarticlea/png;base64,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” alt=”” name=”Image1″ width=”532″ height=”72″ align=”left” border=”0″ />




(1)Annotations中保存的是xml格式的label信息


<?xml version="1.0" ?>
<annotation>
    <folder>VOC2007</folder>
    <filename>1.jpg</filename>
    <source>
        <database>My Database</database>
        <annotation>VOC2007</annotation>
        <image>flickr</image>
        <flickrid>NULL</flickrid>
    </source>
    <owner>
        <flickrid>NULL</flickrid>
        <name>idaneel</name>
    </owner>
    <size>
        <width>320</width>
        <height>240</height>
        <depth>3</depth>
    </size>
    <segmented>0</segmented>
    <object>
        <name>door</name>
        <pose>Unspecified</pose>
        <truncated>0</truncated>
        <difficult>0</difficult>
        <bndbox>
            <xmin>109</xmin>
            <ymin>3</ymin>
            <xmax>199</xmax>
            <ymax>204</ymax>
        </bndbox>
    </object>
</annotation>


VOC XML内容信息




aaarticlea/png;base64,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” alt=”” name=”Image3″ width=”331″ height=”171″ align=”left” border=”0″ />






(2)ImageSet目录下的Main目录里存放的是用于表示训练的图片集和测试的图片集


aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAASgAAACICAIAAADbDuEUAAApLklEQVR4nO2dB1wURxuHt10vcCcoXRAVBeyx99hi76LRRE3U+KWpsWtUNPZEE3uJGntXsMeuqKgYFRuKAiJF6lGut939Zu/ocAh4eHewz09h2d2ZeXfe/c+8M7N3i/Xq2QWqBmRkZnt6uKSmZVjakA+jVKltxdRKBdQD+AnDsAVtIElST4E7OohxHDdjzpgZ87J+LOvFcmFDplZ1YCA/BEUJgjBjptVLeKASLW1A2bEhUysRi9cCQlkAWkHYvLZUL+HZUC9iQ6ZWB2DYzCEIBpHmzK5UcLVMocF4dhy0vAmVmdlKTFhDgH3ktZuj8giNQqnFuAIW8tFZlQYdaloDsBGIRBAzK+8T9ngwv373Xp7pd29FK8ondtiuxbhJrdJP7buTXijKJnUZyRIVW+wsYiJgEKzV6BEmi4GUUj1FD5H67PQsNcvOUcgoq4xgfsMefbzSbl1/U86rKCdVQXYkiet0egRjYqU55UNYvCZg43/z2oEp0pIkOm4tZztmgYxJTfb7NBXLoaYDm7ohSUKvlMvkCo0WBzcbwmCx+UIBv0CTD05QyWQypfEEGGOyuEKhHbtwz4Y5tB48oOGl8HILD+F6NGtS/9G/oLxC80pMr2+3rm8RsXHJsbcaGOU4eTsQKUnZ+tIyL9JoMetM2Dq9xYsNi45Ea8poDMOxzRBwFY9uRCkrN1Yw1b6SuEIiyYaFTjXYldvnlli4VpUtU6i0BOVmoCgu317ANBnAwBjP1dMRT07I1H66uOqDEDqFVK4iQdDC55Y9hKJGeWbt8TotPjzR9caC2UGp+fmSsOtX+3d2jNmyaPszBYFrpApBi0HjBn/etK6YCeGy+Kd3Th0+EZLCEHGpOicJrUzGazZ43NBuzbxFDAhSp0c/CzkbfClSaqK6K+YFsmhCUi9LS0mVA6eSENNjxPxfPM8ErrgpKWXSt1i0gEsNOZQjsMs50ewxf/FyTGSPiLut3jpBu23K+meVLP2ikLhW69hh8uyBHRrUYEOQLivh+e1T+8+/lJqa7WPWDpg/3fP0omU3SnNKBSA00gy5HoJQrr0dN0/3pF6RJVUREMIWingmJQXzfL5dMXtQjde7Av+6lFxmu8ztcOxlSIR2cuuurqcPJRE5LSiB1Orcyl7x9GYU6JoIPek55vd5/WqlPrl25p/YLILv1qhDtx9XtW2yZuGuNzgTgXS4a8CqhYPcMl5cP783Jk3NsHetW9eRS5kJAkBFtjRbQXWEKL8GXvBGIXGVVJql0OgJGGWwBSIhn0lqJGlpOq5TLQGDukZSL5ckZaMObrXyExHa7NRMOSpwcuBiuvhjC6cpWTWcRYycKlFnxCdQdcmqUasmp4RqKlp1+vjjC6ftZYmd7EEOhDIL+E2nN9xGoFsX2NnxWbDREKVUlnsVDsarMM5zGQausiyZBvSzCMbi2wuF+YGAqUOEKlsqVWl1huiALXJw4JbQdZn0Mpx/Qo7Nar3eYBPK5Ao4kEapVusIEsbYfIFYwDQGeTp5ZrrUGI6gLJ5AZMfKHWMQGmCkQmMwBkEZDL7Ijqp94B2ZLFsOjIepqrAH3oFRftMpv33TPOO/M/uCExSwwMnLE1aBZs/g6RLOz7kETWbi+xTKKeKajmxIq5BmyoCBlCVsO5EDr7wDfso5wk4rjv5cH4Li9/y04HyGsRySgD2+2btssAMkObdoysE4vYnEqLhRa08mBPm3rye4kpxVxiUC2NzTXZgy6vYTdaPWXVyOHkggDTcAgTp/3looC7/zVkWdUDvgx3614oJXrfs33hgwhIfdDYv+fs6oH76+N2v3Gz3iPmzKILfE86vXnY5VGZX18N5N6hdJaJScpqN/HtezoQMDz4yN0Qmh3OoAh5D6Q2dN6NPYiU3IYu8d3rz3jlTYfNbaKW7/zl18xbh4LOy0fOfXik0LTuUkIvUqrcuojVt6y0+u2HQziXAduXVLp0crF51O1BmOu49df2YstfF626w1T1QlVV/hysPcRm7dSuVwKlEHi1p+O2V4Sy8XO+AVUh4XdnTznluZCBMmNCpu09FTCl+FMfIgNXLYq9+0CQNauHMhRcJ/wTt2nouHBFTUbvoQLGw0YuKITr6eYhYEKV/sWbXxXkZx9xc1tdChnBNgo82t6rgIQaBBZEZcORaq/6xXx8buAkyd8t/JbZuvp6JU04+69Z23ZogfiFcgTfqT8/9sPBsLUZIktTLCtdf3gYNaewkQoOLU2Igre/bfTNVplKhPEe9kM4SuzX1Z0qvbd59Ogqlcnzy+YzAEprxZwvksg6UFnfLHfzJxx0kLR7WvA4rTSB4d3bgjNL38nSFq52JvdPiIkQ0vb3qlp+qb4LUaNcCB2itys2dAQHikTiED7R5huClRBovD5bIxWP/+wtotcEfR20t3swjQXsgVaj2OG06igmcOl88uobeE81paM4GRipiQh7KWn3VxP7wvjqCuAHHt3JKfGXorTgNiOIZ3nw5C+b3d1+IKhOna1NDgW71md+3ne/TPCOe+XexU9/deAqorEgkSjDpjF83oqrkftPvQe72oXtt+ngbhgWxJ1D1g4a+fZ104uP5JJs+/z5cTF5Fps4+8exiDt2jizbksUcIwyXRt6UG8PfBOSbpQ+RFKObfjrDkD4Ot/bgtJ0oK6zCspJwhNvbR1x4MsPbgP0tUlx7OwiT+pm5Pj0dhHHH9q2/5ELbNmk96Dv1mAJ889FKstcBVJelHd3KsAty0JuwxbtHggGha082QC5NZm0OjAhex5yy5kQYjpQyjKr9eumXPyme0HYxUIG06UEiU69EM9HrWBGGyOC956LV7D8/p8ZL9JDd7fDj6xNVhj17jf6C+njopecCwJZE/Io28f/ftKtgIWNew2evCUSbHzdrzRQARUa8ii5UO4T88d2BgthcVNAsa08xUdupFKuI80eOfQ+icZud6ZczhBkZIBtWnewfvwtgdpGEfA57AwY1yDlnj+O7iwUyRqzLXPrEmtMk7v+v1lFiysyU+T4hW5mRG+k9C4xWkf0Plg4JUsGEKceo/0N94RiJ0jD4FUJLfRhHk/dK1L/QGpk5/fPLDl0L1MCGV7j5g4sCWWzXwxc3dcrQEzv+nl7+EqYgNDdJLXN47u+PtmKowWM8vcsysg4lDHhtyXtO/Uw+vQ31GgHlDPbs15yVdDE6heBBW6OrOg9y+Si8w9aFNexhOfu3mJ2Anuriwo8UWSutiNDvN8h3Wxizu+ZM+1NKpVe53p3NavofEQx3dEL9HT9fM2Xc8Ejf3tSMRv++hunkG7oh9EEWPa12WHPdGQmFvHBnDs8SgZyTQkYjf9buEE18fbV51+bWJwo8lITkgozxgvd7wG5QbwisRXzyIS9dCr1+l2vnPbtnE+HpfegLqKE7/tvW64ijeGqzCkQNgNRvSr9f7U8r1XkoEUX0alYu5zBwxvELLjtaaUQ4aC5PERT18m6ku0yvTOHGtzT8i1OfJ5JMgqRmLfvFG/xNBbj2JAq/RWW7/VT36+4pPJEtDQyaLvXpaqqbmvsDhhyz++aOTAjHqv5TYY0d859cLqv89TzoYF/F5QO6rd55rwztuQnQfdJo+ctrND0uNrF4NPX3+ezalhxzR5foLBKZnJie8zjE5h2dUUQvKw0DuhsbBA8JbLRCsycIIxgRiMMSFchqMCz6F93a/ti8caDu7vBEEqLcRhQgIxtWKlI2A7pxpMjSwbZ9vxnfx7TQ/UTZ9+IrFgVpi4cdv6bkAEhFYNMdk16vf43wIkefrfUbri7jDzGA/cwprEuzfedx/Us/7u1xFapnev5qzYoAdJuKHPQFGECvGogU/BYsEe0L/B4CBKDSJIPfUcWxG7GA51XZCs+6+zikTbJDXBWd8NRUXTtp+dVuDaarKhmMjbb6Bxneoywp/hLu0aMWKPv8jCoZrgaI2ev/yMpJ2ctetuNpNVeHa64KxLsRmYQhSLFuC8/XChbQjPTMiAODV4KBM2XEUkGAwYKz5frEzHhrXRrAcRQOqGQ/r0FxHSgU19HBlvUk0fSiQKFVRmU4vYDBezmVCkySGWvRD0QkB4uCJVBtUTcDAI1mk1qM+QuaM6+bvas3CVlgnpXjMQYH+NBp4M6eMnKYbIOX/wyKzhU5J3OGiMNPnO3sUPzno3b9Ox0/DFvUe9OrZqzZV0k+cnFDSVQht34+KbJoNXrve9dTEo+N97KQwHoFvTlVDARQVAOGI+9Tv6TBA5cphPt0H+x3fbBbThQJnXTzxvOqajiCemOjlY9fSvb3urEZ5IyK/Rfv66cT6Ojf3FwYnyAjnnZJ79byDo/US9Fqwa7y1o3bX2nugoLVToNPOHmtQPPO3+lTeDvurVhPP8SYNeTeGXux7njDpweXKqDvJuYIc/VGGM3EQkrufVc0MhSUK2VpYq0UNedYX6BwpGkdgYoa6e0FHz+0VNpuSqvLtl3b9pZO4hQpMlI0ny5e3XxPgu9ZkvpZ0bM6OCnmeTxsTKyPtx7q0H/dj/v0Wnk1hsRomVQBKlz/MVvdNhE8qjns/DCXABYBtFqavQ48BQBCo8t2FYnsK1eE4+JKGlmh8ULf1Q4YLKamoxm4sqj5onB1XNQtAcrYMSERQGdmDOvefO7gffPrbjaJwUqtF2/DctDckRBgOFcI2GKNiiUFkxYMo7W9dfSidzVUFqsuU5Resyou+fjw67drX7D3OH/69fxIprJs8XG66dzL9S3fvL6xc99W3TrWevmWuGRB1dsiYks9y3M8oWc6m8suPvXQvrM7tNi69Ga7k+MPTu0vmXTB8wxmMLOShJ4pzGX8+dNrCBMD8li1eKzPUZr15lQN5iviMP3OnawgfNvZpACY/qJLKfXHs84rsBXerbt/RRPdzwPG+GWBVz46G8aeeATkG/nZWgbBAb4DqVVtj1++4O2hfBL6WEOubWU1XjLsPbBy39NwOjTiAJatkU5YoyY97jXZr6cva8SWeyUNCbG2RBFafPjEslunjVzI68nWY4hOtIjMehFr9lETeeaif2bt00uzn6Yu+zbJDGELmr3l3bcihq/OzRgb+kTVlzX8/Jk56hkwN3thZic/RKFQjlcD3K4jJLWrQtGmrmz1MU2s47BMP6rNgkvHPThuy9URI2GwN3d464waHM2Pd4Z39vxv4YGZNJ6jR27f2E+qR3mXhphyCkcEGm+ECoWaLNUO6fBZLDMMfN1xWKWXfoergWQdBsNznU0pAWlyZIoE6+teH9bzUsBkTAxmE8uOSENOAdx6xXtyUsDgZaHR3B4POYsE6WLoNYLKBXhCQUz0Ofpg/s4+3IvJRY8vkIE6KcwtbLVVoY0uMoh4tq5WqN+vHl3Y9vXhuycGG/3t73D8UUuceLXG4Ju9hCKtJUS1WyiPMh6W2+8OjWFujwyZm7yfLmhjERR8hGefUmzhnYgIW/u3bkWqTWpffYXp5w0QyLbOMaY3BGdQswWfgcs6/jGX+RyshLtzLmDZ4SAKWe/SdalR+6KV+d3B9Sb/K4P5fXD7pwK1KC29dp23tA1zrax3uOPKQW6hTPjh99WH/shLXLfYIuhL6RqBC+a31f94zrwY8jzlxPnT1i/mz04OnwFB2vrjMHgg23HSl7fi40a9rQOTPIw+efpuo4tbwcJOGP34OBIqmMuvpAMWvMeDAW+DOy0FK7Pu3eri2Oc2Z8M7dP9K+Xswutz+szYpPxbt2Hfv7qQjRcs5b69dNkdfGrNTWLkRd0wIX/pJC9PHczbcaIebOwg6cfg6uo48KhYmwqwJa/vHArffqYGZP0+y7FwN49vx7tknb10CtqBGr6EFys0BIpi5NN2QwX/qnLipdAXQf1bya5EZuN24s5OSNIUhpxJVw96etp47SHrseRbm27eIDhKHXJERfuZv9s8M45o3ccM589TSJrD57WnngR/iYhU40Iarcd+oUDGX8tTWfi/GQtaF9T8M+7D+5idIouKlLp87mH+k10uorhWL82H1Ir9GSZrrQQCMue6vH0Kh2pTbh+LuaLsXUgSBp6OjybYCoNKmYJWQx7DycW2Hx7YdeRyxJmI7+RvTzZ5S2pUFWbtcPLf1YThN9XYruPcI++fCtJX3CcREifH1i6Mrp33+49xs4eBhpGRfLrB4fWnLv5RmbsFomMBzt+y4rq37tLv287UktSenlKTPgVFkpkRp/860/Z0CHdJywailH7U2MepmoMXZTy5eG1m6TDBn0xaeEwBCLkiQ9OvDYIj5rsuXEntWNvNPR67sMhKOgUURYGk6Q66sL2U76BI34eGbUq+H3efuomenTosO/EIePmtIDwrIjgTRFJScVXcoqOjxEGGIWjbAYY4xMFt6kBPJMJfrJAbKiOPb1xg2LQwO4TFw0BWtcr0t4+lmgNY23N21ObtmqGDQqY0ZkDqZKfn9967OI743K86UOFCzKF6QV0jENNNhnmJQpnhYJuC8I4IMqFqaVD0D2DQ+APbeKVnSfsR/WcuOQLKtDSKSQxWXpDAYpnBzcd0QztMXZWT5YuIz6VhAiSalNUr0+s3yYb3L93jnfePwx++zxVzVQTTh0Dvh9ILV5Aasnb8OCNp29LCBPnp2QSsifHjoWNH2h0yqsz2+LfNug8qvM3dhg1M5LwNGjP1UR9uecsEAbXsPCpUwMH4+l3jl9uPqS2/M6/r9UQgWgMsyJsIYvIin0nh1z5dSdv3tgtXsn1NqgOqejDPpUyuWIEl4Qs+19IiSeRqoTQk9tCT5rMRZ/95sp+8K/YAUIacfGfiIslpskIP709/HQJR3SJ5+ZPPlfgzMSg+T8G5R28sHLiBeN2wf2QNuXurqV3d5m00UCRusOTziz55Yxxf8FtcMmKx2unPM5JQsoir+xbfaWkrIjs5+d3Pj9fUhGmDhUuqKym5kFm3/njF+MCWpGsVM+3/DQlNy2ecn7pL+dzDmniQg6sCjlQLH9SI3l1bvuqSxhQi04j7Ll6TY9s44o4nvnswq5nFwoXHX/38Oa7h0u0s4TzqYhXlxa2d3XY3vyd5/5ceK6E5OWCI+IZijQsvhGypweXP809RILBODUIFHFRVcTBPw6h4/p+5ulezw8c0kiTYl++V4FRN2YI82CGYSyevw3EYHxiFyvpqRe4Qqaahv5YkJXyKUwlMcfPurqr4uNS5aTQs1PAQJfMe0eSdVZWS0WtIVIvzxpzueSjqmerxn6T91fkuW1zz20rluHz1eO+KWkbendk1qgjxbOltitjcqUaYd4Z4UrlU5iK8mo37jC8hZuITT22khIZunvLhVitlenOOqic5YRqgw3dU5+kx5O9OL7uxfEiBdtO4/RJoCYQSBihPpBnzmyxin5WwDahlUdTHkigOcOnYBEUMfcYr1rpznZacxsytWpjfAK5Eh6SNmNmVo8N9SI2ZGpVBwYdHj258lHY0BeZ2JCplYvFqwEmUQwx/zqeGfOyASzuxbJjQ6ZWacAwj8NhUd9yQPd4FcaGBk42ZGqlYsFaIA3o9YRYJML1hJnHeEKB8MNn2T4wggoEAuIDn16wCuzkKlsxtVIB9ZCVlfXJ6oF6Qin/o9wk9VgMSYAdInuBUChQKZVmDjUTEt+bMTtr5llWtqVNKCs2ZGqlotPp9HDRz6RWBjlTlzBMkjmfi2YwGKCjE4nsmQxMSanOzCVitT1czJwlDY2Z4PMFn6Yg0LsZF8iNCiQNX0+CG1AolIZTzKw8jJ48o7FaFAqZpU2orHUdTJJBRzU0NJ8abPXK1cbZG0tbQvPR5I5UCv1ZvZ4JtBmwRk2awdTCPB1x0tB8OjDDdK15v2CbhobmA1SvBXQaGiuBFh4NjQWghUdDYwFo4dHQWABaeDQ0FsDKhKd5s2tm4AO/eWu+8+Na2hYamsrD/MJT/Lfs29XRbees/7k5v8DioDb26OyZx5Gv16/q72S6UITt6OLq6sizsvaAhsbMmP0Ox+UpmTgkv73n7ED/kZ7MnL2EJHTPqUQIEqcrSn0FJ8O9/5zV/c1tEw2NtVEZwpNBTEdB0vnDD7+Y3dbe0Ompo04dec5w4uky0+XGxXr9+/OrlxwMl2ghiOXo33Pcj6Na1gC26OIOTZtxvfmKjd94M/H0OzvWHXkQmyTVQBDMd281aNJ3A3z49CM2NFUA8wtPkaGEPb6c6Bn85+GLcS0CajNBd3fv4DV503HfcfdvSKe+IpwDQ6id3xfjZwwS88j0J6e2H123vf7mOa2FhURFKOOeRWZ6jPxlgDdb/f7Bib37V2Aem35uxqOlR2PzmFt4pE6WrUH4tRoNGlr3xqGTL/pObcZ8d+lEhKD7ijYud05AsVSXZ4dBMK9289a1qRT1PIVxIdMvP03RthayiuXHcWvSoqk3E2riVzP10ZyboXGaZg0/4qUvNDTWgbmFR6gyVRC7Fhtz7BDQ7vCKo7dT6tQ8eTHD56u+nmztUzakylIZBnna5LtHd5+4/TIxQ4VymVqI4aMr/SF6hqi2GFJmKEsdItLQ2AhmF55aqoaYPBYCc/0G9nGacXLvPv4jrP38tjVQJIPPIjVSNUEN5YJW/HkG6TZx6nd1RVDixbXr7n0wZxRDPvjGVxoaG8H8wpOpIRaPel0r5tptiP/JDSFZbgHTGnJhiGRyGRA4jFMv3op4D9X9IaBbM3sYwjmuPDNbQUNj5ZhdeBoZiBs5TGoCBBG1GjO623l5mx6uVDEwyuaghFymJSGeUz1H6OzZ41ftOnrZIekpKjNbQUNj5Zh9ckWr1EAMrvENfxDbq+/kH/KOIUwOE0qXgi5P5DlkxvjMrSd2Lr9ErS4w+bV8nPkVfVknDY3tYW7hcT9beOSoiWPsRtP2HMs9r07vn1b3/qnoKQyPURuPjiq+DfpLYYelRzuY2VoaGgtBP5tFQ2MBaOHR0FgAWng0NBaAFh4NjQWghUdDYwFo4dHQWABaeDQ0FoAWHg2NBaCFR0NjATA2h2NpG2hoqh10j0dDYwFo4dHQWABaeDQ0FoAWHg2NBaCFR0NjAWjh0dBYAFp4NDQWwPaE9+DBAwT5qJe2EwSBoiiO446Ojm5ubmDbjObRlJfq6VDbEx6o36ZNm1Y4OXASyCEhIcHe3l4mk4WHh3t7e4NtM1pIUy6qp0NtT3gkSX23plqtLm9CY5sKnKTT6fh8AXAYcA+DwYiOjnZwcPDw8PiYRpemwlRPh9qk8IyUNyFwgzEVacwGgplMJnCbWCyWSqUvXrzw8fEBbjO7wTSlUz0danvC+3iMzaBep2OxWMZABfhPq9U+e/bM19eXzabfzWBj2KJDbU94FW4gc1pHw0/QWBIkCZpD3IDRWxwO58mTJw0bNhQKhea3m8YE1dOhNik844Y2asfPix9xa3FZtYfM/KGduMxfiAsbQAyBSl4bafQWcFVERESDBg2sf3ReZciXnPLZtvm/X4x1mLzjj541yvH9xrboUJsUXi5Yza5T5o+vz8zZ/YGEwBPGaWvKSQZAGvATuCqvjQSAyOTVq1f+/v58Pv8TXA5Nfo/H8h6+aLXX7+vL2AHatENtT3gFwNNub5jzVFhv8M8TOtUq+yDa6CfgmLCwMB1Ar8dQjMViAg+BBhJFUbABhubNmze32qF51QThiARqOGeypBzYokNtT3j5/Z3HiN+3jmMrw7cu/PtBk3lthR+eOwa+yWsagb/AhlgsBmMD4BvQPKpU6qzsbLVK5ehYE7jq9evXfn5+n+CKqjmFxnh547ayDfls16E2LDwI41IfnhfUb+186FWGro3gw40ZSGVc2wEe4nI5Xl5eer2+wHiAK4JERvmqVCqJRFK5V0JjoIjwoIJ/liGtjTrU9oSXC6lXq0gWl6FLiUzluAjL+pRQnqtAo2jcMA4RgJ8Mr73MmSLj8XiZmZmVZz2NubBRh9qe8HIbRCLr3volx5NhiKjZfepgO7iMbSRoC41DAsjQTGIYZvASaCCpPI3ngBPAQBx4rhIvgyaX/B5PG3Nk9aYrL+OgpUvTf5g90ptZluQ26lCbFJ7hN1Kj8+x1nSuYg7GZNDrM8ACEoYHMla5xfwVWlmgqQH49M+sE/LomoEI52JxDbU94UG5Ff0wOxploozPyApWCJ1jzY35Vj2roUNsTnrnaLWOLWNBVlVQQTelUT4fapPByGkhC+mT/mj1PlKxanb7/pb97+S+FGgQQRF4cYhwnGN1WMFChqVTyHKqO3Ldsy0MZSYrbfT99hA+v/F2UDTnUJoVn3NDFnglSDVnyRxP+xwURIEMQqECGJhPKfeYdjNGtyk9VmLx6Rp27/7J6jAiJPzxv98Nev3ayL8dTY0UytH6H2p7woJw2Es98/Uanz1i38BjqF/D9cH9BBd1UQuaQlYUlVZ6cJyIETvZgW4dgYHyGmM0F1ulQ2xNebmCCq7IkSYov1i7wfrRq7YWExcMrEGt+qBQzZkhjikIL6BCR/ejkQ89+83hmloq1OdQmhWf4DTO5fGd/Lz4m9PAkH0t0kFmFB1lfG1lVKVjP+tSQneftRs/0r8AAr1wFWRzbEx6U03ohQk9X/b10DcGWpEAObVGzN5BmzI2mdHK6PM3bU9vuN5gwrSHX/PVvbQ61PeHlxQxsn0FdL61f/CsBOfWd5m7mp86tLTKpwuRWNZF5d+eJN3KPzYG3MZdeP07u5GjOLwuzNofaqvCoSkSduk9d3j1/t/lLMWeONCbI9Scs6vzb/s6F9pu9FDNm+JHYnvBoaKoAtie8wpNglVtKpRZBY6R6OtR2hafPCN2x4UKCntRnJag7/PZ7AL2cYJvkCU8TfWjF1sdKkrBvM2nq0Ppcs05sWptDbVV4EISK2323qB0EqV/tWPnfZ7XMv5ZgVX6qwuRVNdNzyK+rR2F4wonA/eE9Z7crw1cKVKAUK8H2hAcVrkRN7O14z06uDPNPrpgzO5pSyXEowkQhktAqlCSLae4P8VibQ21PeIVrUPPubrx7Ww9WpRdEU1kUqGc84+6OtfvD8M7zh1fCCrpVOdQmhZf/pLnmXehblzYjmGavU2t7mL0KU8ChiKjNpN8+G3B5ze6QtJndHcy5jmdtDrU94RVEm3DvrVPbERxL20FjDnCtDmYyEITDRxVxCgIyq/CsDdsTXoHZZ238vTcObYayK6Eps7axeBUmb5o68/629f+m4HolXGfIFFczf4rH2hxqk8LLDRsYXqMCv6+c2N3aIpMqTK5DEXH77wPbF9xtzlKszaG2JzwamiqA7Qmvej7oUIWpng61VeFRW6qXe1duvhkn/mrNoi5iBNKn3ty28WISIWw2dsqQepyP/j4Iq/JTFaZwVevjj89ZEjV6/Zxm5p0yszaH2qrwqEpkeg6YvqD2ph1EzgNH564xhs9f5Hhj5d4HXaZ3LPtru0yXYi6baUqhYI9Hyl9cjRHaYeavfWtzqO0JLx+EbcdT53ZsuPRtAsd3MAdj13NX3krTdRRXxqI6TaWCp4bd5bTzFYZZ2pDKx/aEV2gB3fDL8J4LQqPUY8xHG5YlN3YnVZqPncKytkmwKky+QzVR1195d+yvfBVm/u7J2hxqk8LLDxvIvLc6QQwOpmc0mvRT84STkdGMj52NtrbIpAqT6088879r8lZfOiA3QVNqdpVYm0NtT3hQyUs8qLC2s+pOEtzK4W0i17vmx34ThFU5qcpjqG1dxru02KgNq3Spb1MEh//zHPdZRb9Y02QRVoTtCS+/x9PGnd78T8jrBOivdZnjvh9Yp3enq1tWLCH4Tcb8WOaXB5VekFkMpimdXH8y64ycvxiC9ElnVx11C2hhDhcWK8is+X0UNiY8rVYL5dUg02PA1EUD8g/W6vy/wAq9PqgEjEXodDrreXlvlaSQQw1gzv3mTzF/QdbmUBsTnkajQVH08ePHn6AsUBAozkr8VFWptg61MeEJBIK+ffvK5XLjl+NXHhiG8Xg8Fotek6hcqq1DbUx4AJYBS1tBYzaqp0NtT3g0NFUAWng0NBaAFh4NjQWghUdDYwFo4dFURfTJVzdtuFv7u9mDPKxi9aAY1i08Qpnw7FGCoFmrOryKPD1UevKyZ/6RZlQTPqaW1C/+GvfT7eZr9sxqxjOLMXjWi5shj7uNLfqsitU43bqFp4ncNXvu668O7q7YxZeevOyZf6QZ1YSPqSWU5+Th6eHEr/Tb0Wqcbt3Co6kmMDxHrt410tJWfEpsQHjvtn7ZdSu10eS38xu7CCBdUsjONVuC7icoEbt6Xb+ePn2YnwAhFJFBa1f9c+VNNgGxnTr8vO63/i5YiclNZn52Cfn76IUve27YO7UpD9a+3Td5/AHHefuW93QsQz40RgrVUkftnW0r/74SHp2mhiBByzn//N5XnHhsztRtYWkaCLip+eApv07q4Aj8pIvePnrchXbbD09tyMJTrv4RuONOVEImSAUL63QaPWPWyEZI2PzBM98M/+fApLrUoI1IDpo4fKN4+cnltS+VlGFZjbSY021AeE7DVizt54xBMNeJB5GK8A0/zb/oNGbG+o41s+/9s3LDjD/cjwR+lnpg4V8htcYv3tSuFimJz3ITYyUmLy1zgZgzbWan0YuW7ei2+392p5b/8771nFXd8l5LWno+NEYK1RKR+uLGvUS3bwPnNLbHFZC3GIVQcbOhU5Z97SAgUsP2/74z8Hff4yu7FP74DyGPfvg83WvikvkNOKr423s2bpm1ts7RhQ26+WMhd8PTv63rjEKkNOJmDNJgmK8AZX0ww9KMtJjTbUB4LIfa3t457+AiMkJ3nZE0m7NtYo8aoHJ9ZqWFBGw/80rZjJkihQRtW7Rs1IAHQw1NJS89cwiq0WXazA5jAhcvk/Lvxbecs7xbgbcBl54PjZFCtaSjfvDrtO7QqmHeI2H8uu0616U2/OrZxfw79vTDRG0Xe3axfPheLdu1BqlaNXN+Hzrh32sx2laNe/ohK68+yhjS1xGWv7j8gqj/QzN7BEHLlqFJIy3kdBu7kbRJT9/p9RlLB3Vemr+TmaZidvvyq6a3t/wYENFzyLBhgz9vKKrYhSEOXX+Zem7kskvp/jNWdTPrS7hpKDQJ13eu33Pl6bs0FcpjaiBGI33pCRgOdR0hebocR8Qt+zWCV154lNm7F/vlxcdan/+1rYmWP8PiWMTpNiY8iJoe5nX6dd1En7w2FGY7ihC2w5frgjrcP3vkwP7fJu09MnbLhm8bciuQPyF98yBKC8FQ5MXbSX2GuVnnIpCtooveN2vhEaT/L4tn+dYg404uCLzxoSQwiiEQiVNvNBG3GtgUWXYmTNJGfDZM6/9TO0ekAhmWgCWcbt3Cgxk8FqTOVhG5O5jOfu5I8Ju3sHMvz6IPtCNcj7YjZrbp2/Ovr348fvTV6EXNiyUvPXPggczQdcuvir7Zupr51+TNS4NabxjhzijxTJpilKGWlHHh8VCDeRP6txYjEM7zLN9sBSJqPbwta97J85dF9/EWc9uDwYas1AxJgii6jmc1Trdu4TFdGnliwed2HvUdWg9KzXDo2Muv/bi+jtMOzFqATBjQzJmpTIrN8urd34+dciP4PlSnXi2uLvm/aBnEd+CDiAErmryHy+PF4wIj2v2+e3ZLQbHMe3i82rL6qvDLv0f5+aDzJ1wdu3Xl2Q7rBrtgxc3wt6MX9IpSvJZ8ip7CcfV1go4c/uesqGc9EZKSqCxfCbCw2YjP7X7csQ6y67m2JeUCkxmi4A6A0sKu3H/n3k7woBSn97SQ061beIi4y/QZDxZu3LYgFGI4tpzk393f87Npm1eI1/0d/MfcfTiE2tXp9nPnfn6YJPL6niPr08FwHhPV6/RD4Nd1mSB90eSfuxi+AoAsMfP6te/8eQHq89eX9amhueew6cOCJ2/bfLfrko72xc2ghVeM4s4qJjxmvbFLp0pW71k7M5j62CvLzsXfg1+emuT6Dh/odna3vk9AE8ObK01miLl8MXnYzeUn1x3v8tn4Upxez8NCTrdu4VHfq9J3/u6+8wvuYjh1mLCiw4TC5/l/tznouzIk91x65qbpo4dv5efB9vvp+K2fTJtBU4zitTTp6K1JBc+AeT5DF+wcuqBoSoZ3/pkFt0EK+x5bbvXIP7HOt4duffvhDIHC2k3Zdjbny1us0OnWLjwamioJLTwaGgtAC4+GxgL8HwMqvpqz7R5XAAAAAElFTkSuQmCC” alt=”” name=”Image2″ width=”331″ height=”142″ align=”left” border=”0″ />








(3)JPEGImages目录下存放所有图片集


aaarticlea/png;base64,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” alt=”” name=”Image4″ width=”348″ height=”243″ align=”left” border=”0″ />










(4)label目录下保存的是BBox-Label-Tool工具标注好的bounding box坐标文件，
该目录下的文件就是待转换的label标签文件。


aaarticlea/png;base64,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” alt=”” name=”Image5″ width=”386″ height=”193″ align=”left” border=”0″ />










2.2 Label转换成VOC数据格式


BBox-Label-Tool工具标注好的bounding box坐标文件转换成VOC数据格式的形式.
具体的转换过程包括了两个步骤：
（1）将BBox-Label-Tool下的txt格式保存的bounding box信息转换成VOC数据格式下以xml方式表示；
（2）生成用于训练的数据集和用于测试的数据集。
用python实现了上述两个步骤的换转。
createXml.py  完成txt到xml的转换；  执行脚本./createXml.py


#!/usr/bin/env pythonimport os
import sys
import cv2
from itertools import islice
from xml.dom.minidom import Documentlabels='label'
imgpath='JPEGImages/'
xmlpath_new='Annotations/'
foldername='VOC2007'def insertObject(doc, datas):
    obj = doc.createElement('object')
    name = doc.createElement('name')
    name.appendChild(doc.createTextNode(datas[0]))
    obj.appendChild(name)
    pose = doc.createElement('pose')
    pose.appendChild(doc.createTextNode('Unspecified'))
    obj.appendChild(pose)
    truncated = doc.createElement('truncated')
    truncated.appendChild(doc.createTextNode(str(0)))
    obj.appendChild(truncated)
    difficult = doc.createElement('difficult')
    difficult.appendChild(doc.createTextNode(str(0)))
    obj.appendChild(difficult)
    bndbox = doc.createElement('bndbox')    xmin = doc.createElement('xmin')
    xmin.appendChild(doc.createTextNode(str(datas[1])))
    bndbox.appendChild(xmin)    ymin = doc.createElement('ymin')
    ymin.appendChild(doc.createTextNode(str(datas[2])))
    bndbox.appendChild(ymin)
    xmax = doc.createElement('xmax')
    xmax.appendChild(doc.createTextNode(str(datas[3])))
    bndbox.appendChild(xmax)
    ymax = doc.createElement('ymax')
    if  '\r' == str(datas[4])[-1] or '\n' == str(datas[4])[-1]:
        data = str(datas[4])[0:-1]
    else:
        data = str(datas[4])
    ymax.appendChild(doc.createTextNode(data))
    bndbox.appendChild(ymax)
    obj.appendChild(bndbox)
    return objdef create():
    for walk in os.walk(labels):
        for each in walk[2]:
            fidin=open(walk[0] + '/'+ each,'r')
            objIndex = 0
            for data in islice(fidin, 1, None):
                objIndex += 1
                data=data.strip('\n')
                datas = data.split(' ')
                if 5 != len(datas):
                    print 'bounding box information error'
                    continue
                pictureName = each.replace('.txt', '.jpg')
                imageFile = imgpath + pictureName
                img = cv2.imread(imageFile)
                imgSize = img.shape
                if 1 == objIndex:
                    xmlName = each.replace('.txt', '.xml')
                    f = open(xmlpath_new + xmlName, "w")
                    doc = Document()
                    annotation = doc.createElement('annotation')
                    doc.appendChild(annotation)                    folder = doc.createElement('folder')
                    folder.appendChild(doc.createTextNode(foldername))
                    annotation.appendChild(folder)                    filename = doc.createElement('filename')
                    filename.appendChild(doc.createTextNode(pictureName))
                    annotation.appendChild(filename)                    source = doc.createElement('source')
                    database = doc.createElement('database')
                    database.appendChild(doc.createTextNode('My Database'))
                    source.appendChild(database)
                    source_annotation = doc.createElement('annotation')
                    source_annotation.appendChild(doc.createTextNode(foldername))
                    source.appendChild(source_annotation)
                    image = doc.createElement('image')
                    image.appendChild(doc.createTextNode('flickr'))
                    source.appendChild(image)
                    flickrid = doc.createElement('flickrid')
                    flickrid.appendChild(doc.createTextNode('NULL'))
                    source.appendChild(flickrid)
                    annotation.appendChild(source)                    owner = doc.createElement('owner')
                    flickrid = doc.createElement('flickrid')
                    flickrid.appendChild(doc.createTextNode('NULL'))
                    owner.appendChild(flickrid)
                    name = doc.createElement('name')
                    name.appendChild(doc.createTextNode('idaneel'))
                    owner.appendChild(name)
                    annotation.appendChild(owner)                    size = doc.createElement('size')
                    width = doc.createElement('width')
                    width.appendChild(doc.createTextNode(str(imgSize[1])))
                    size.appendChild(width)
                    height = doc.createElement('height')
                    height.appendChild(doc.createTextNode(str(imgSize[0])))
                    size.appendChild(height)
                    depth = doc.createElement('depth')
                    depth.appendChild(doc.createTextNode(str(imgSize[2])))
                    size.appendChild(depth)
                    annotation.appendChild(size)                    segmented = doc.createElement('segmented')
                    segmented.appendChild(doc.createTextNode(str(0)))
                    annotation.appendChild(segmented)
                    annotation.appendChild(insertObject(doc, datas))
                else:
                    annotation.appendChild(insertObject(doc, datas))
            try:
                f.write(doc.toprettyxml(indent = '    '))
                f.close()
                fidin.close()
            except:
                passif __name__ == '__main__':
    create()


createXml.py


createTest.py 生成训练集和测试集标识文件； 执行脚本


./createTest.py %startID% %endID% %testNumber%




#!/usr/bin/env pythonimport os
import sys
import randomtry:
    start = int(sys.argv[1])
    end = int(sys.argv[2])
    test = int(sys.argv[3])
    allNum = end-start+1
except:
    print 'Please input picture range'
    print './createTest.py 1 1500 500'
    os._exit(0)b_list = range(start,end)
blist_webId = random.sample(b_list, test)
blist_webId = sorted(blist_webId)
allFile = []testFile = open('ImageSets/Main/test.txt', 'w')
trainFile = open('ImageSets/Main/trainval.txt', 'w')for i in range(allNum):
    allFile.append(i+1)for test in blist_webId:
    allFile.remove(test)
    testFile.write(str(test) + '\n')for train in allFile:
    trainFile.write(str(train) + '\n')
testFile.close()
trainFile.close()


createTest.py




说明： 由于BBox-Label-Tool实现相对简单，该工具每次只能对一个类别进行打标签，所以转换脚本


每一次也是对一个类别进行数据的转换，这个问题后续需要优化改进。


优化后的BBox-Label-Tool工具，支持多类别标定，生成的label文件中增加了类别名称信息。


使用时修改classLabels，改写成自己的类别, 修改后的工具代码参见1.1中的main.py


2.3  VOC数据转换成LMDB数据


　　SSD提供了VOC数据到LMDB数据的转换脚本 data/VOC0712/create_list.sh 和 ./data/VOC0712/create_data.sh，这两个脚本是完全针对VOC0712目录下的数据进行的转换。
　　实现中为了不破坏VOC0712目录下的数据内容，针对我们自己的数据集，修改了上面这两个脚本，
将脚本中涉及到VOC0712的信息替换成我们自己的目录信息。
在处理我们的数据集时，将VOC0712替换成indoor。
具体的步骤如下：
　　(1) 在 $HOME/data/VOCdevkit目录下创建indoor目录，该目录中存放自己转换完成的VOC数据集；
　　(2) $CAFFE_ROOT/examples目录下创建indoor目录；
        (3) $CAFFE_ROOT/data目录下创建indoor目录，同时将data/VOC0712下的create_list.sh,create_data.sh,labelmap_voc.prototxt
这三个文件copy到indoor目录下，分别重命名为create_list_indoor.sh,create_data_indoor.sh, labelmap_indoor.prototxt
　　(4)对上面新生成的两个create文件进行修改，主要修改是将VOC0712相关的信息替换成indoor
　　修改后的这两个文件分别为：　　


#!/bin/bashroot_dir=$HOME/data/VOCdevkit/
sub_dir=ImageSets/Main
bash_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"for dataset in trainval test
do
  dst_file=$bash_dir/$dataset.txt
  if [ -f $dst_file ]
  then
    rm -f $dst_file
  fi
  for name in indoor
  do
    if [[ $dataset == "test" && $name == "VOC2012" ]]
    then
      continue
    fi
    echo "Create list for $name $dataset..."
    dataset_file=$root_dir/$name/$sub_dir/$dataset.txt    img_file=$bash_dir/$dataset"_img.txt"
    cp $dataset_file $img_file
    sed -i "s/^/$name\/JPEGImages\//g" $img_file
    sed -i "s/$/.jpg/g" $img_file    label_file=$bash_dir/$dataset"_label.txt"
    cp $dataset_file $label_file
    sed -i "s/^/$name\/Annotations\//g" $label_file
    sed -i "s/$/.xml/g" $label_file    paste -d' ' $img_file $label_file >> $dst_file    rm -f $label_file
    rm -f $img_file
  done
  # Generate image name and size infomation.
  if [ $dataset == "test" ]
  then
    $bash_dir/../../build/tools/get_image_size $root_dir $dst_file $bash_dir/$dataset"_name_size.txt"
  fi  # Shuffle trainval file.
  if [ $dataset == "trainval" ]
  then
    rand_file=$dst_file.random
    cat $dst_file | perl -MList::Util=shuffle -e 'print shuffle(<STDIN>);' > $rand_file
    mv $rand_file $dst_file
  fi
done


create_list_indoor.sh




cur_dir=$(cd $( dirname ${BASH_SOURCE[]} ) && pwd )
root_dir=$cur_dir/../..cd $root_dirredo=
data_root_dir="$HOME/data/VOCdevkit"
dataset_name="indoor"
mapfile="$root_dir/data/$dataset_name/labelmap_indoor.prototxt"
anno_type="detection"
db="lmdb"
min_dim=
max_dim=
width=
height=extra_cmd="--encode-type=jpg --encoded"
if [ $redo ]
then
  extra_cmd="$extra_cmd --redo"
fi
for subset in test trainval
do
  python $root_dir/scripts/create_annoset.py --anno-type=$anno_type --label-map-file=$mapfile --min-dim=$min_dim --max-dim=$max_dim --resize-width=$width --resize-height=$height --check-label $extra_cmd $data_root_dir $root_dir/data/$dataset_name/$subset.txt $data_root_dir/$dataset_name/$db/$dataset_name"_"$subset"_"$db examples/$dataset_name
done


create_data_indoor.sh


        (5)修改labelmap_indoor.prototxt，将该文件中的类别修改成和自己的数据集相匹配，注意需要保留一个label 0 , background类别


item {
  name: "none_of_the_above"
  label: 0
  display_name: "background"
}
item {
  name: "door"
  label: 1
  display_name: "door"
}


labelmap_indoor.prototxt




　　完成上面步骤的修改后，可以开始LMDB数据数据的制作，在$CAFFE_ROOT目录下分别运行：


　　./data/indoor/create_list_indoor.sh


　　./data/indoor/create_data_indoor.sh


　　命令执行完毕后，可以在$CAFFE_ROOT/indoor目录下查看转换完成的LMDB数据数据。


3 使用SSD进行自己数据集的训练训练时使用ssd demo中提供的预训练好的VGGnet model : VGG_ILSVRC_16_layers_fc_reduced.caffemodel
将该模型保存到$CAFFE_ROOT/models/VGGNet下。
将ssd_pascal.py copy一份 ssd_pascal_indoor.py文件， 根据自己的数据集修改ssd_pascal_indoor.py
主要修改点：
 （1）train_data和test_data修改成指向自己的数据集LMDB
　　　train_data = "examples/indoor/indoor_trainval_lmdb"
            test_data = "examples/indoor/indoor_test_lmdb"
（2） num_test_image该变量修改成自己数据集中测试数据的数量
（3）num_classes 该变量修改成自己数据集中 标签类别数量数 + 1针对我的数据集，ssd_pascal_indoor.py的内容为：


from __future__ import print_function
import caffe
from caffe.model_libs import *
from google.protobuf import text_formatimport math
import os
import shutil
import stat
import subprocess
import sys# Add extra layers on top of a "base" network (e.g. VGGNet or Inception).
def AddExtraLayers(net, use_batchnorm=True):
    use_relu = True    # Add additional convolutional layers.
    from_layer = net.keys()[-1]
    # TODO(weiliu89): Construct the name using the last layer to avoid duplication.
    out_layer = "conv6_1"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 1, 0, 1)    from_layer = out_layer
    out_layer = "conv6_2"
    ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 512, 3, 1, 2)    for i in xrange(7, 9):
      from_layer = out_layer
      out_layer = "conv{}_1".format(i)
      ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 128, 1, 0, 1)      from_layer = out_layer
      out_layer = "conv{}_2".format(i)
      ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 3, 1, 2)    # Add global pooling layer.
    name = net.keys()[-1]
    net.pool6 = L.Pooling(net[name], pool=P.Pooling.AVE, global_pooling=True)    return net### Modify the following parameters accordingly ###
# The directory which contains the caffe code.
# We assume you are running the script at the CAFFE_ROOT.
caffe_root = os.getcwd()# Set true if you want to start training right after generating all files.
run_soon = True
# Set true if you want to load from most recently saved snapshot.
# Otherwise, we will load from the pretrain_model defined below.
resume_training = True
# If true, Remove old model files.
remove_old_models = False# The database file for training data. Created by data/VOC0712/create_data.sh
train_data = "examples/indoor/indoor_trainval_lmdb"
# The database file for testing data. Created by data/VOC0712/create_data.sh
test_data = "examples/indoor/indoor_test_lmdb"
# Specify the batch sampler.
resize_width = 300
resize_height = 300
resize = "{}x{}".format(resize_width, resize_height)
batch_sampler = [
        {
                'sampler': {
                        },
                'max_trials': 1,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.1,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.3,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.5,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.7,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'min_jaccard_overlap': 0.9,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        {
                'sampler': {
                        'min_scale': 0.3,
                        'max_scale': 1.0,
                        'min_aspect_ratio': 0.5,
                        'max_aspect_ratio': 2.0,
                        },
                'sample_constraint': {
                        'max_jaccard_overlap': 1.0,
                        },
                'max_trials': 50,
                'max_sample': 1,
        },
        ]
train_transform_param = {
        'mirror': True,
        'mean_value': [104, 117, 123],
        'resize_param': {
                'prob': 1,
                'resize_mode': P.Resize.WARP,
                'height': resize_height,
                'width': resize_width,
                'interp_mode': [
                        P.Resize.LINEAR,
                        P.Resize.AREA,
                        P.Resize.NEAREST,
                        P.Resize.CUBIC,
                        P.Resize.LANCZOS4,
                        ],
                },
        'emit_constraint': {
            'emit_type': caffe_pb2.EmitConstraint.CENTER,
            }
        }
test_transform_param = {
        'mean_value': [104, 117, 123],
        'resize_param': {
                'prob': 1,
                'resize_mode': P.Resize.WARP,
                'height': resize_height,
                'width': resize_width,
                'interp_mode': [P.Resize.LINEAR],
                },
        }# If true, use batch norm for all newly added layers.
# Currently only the non batch norm version has been tested.
use_batchnorm = False
# Use different initial learning rate.
if use_batchnorm:
    base_lr = 0.0004
else:
    # A learning rate for batch_size = 1, num_gpus = 1.
    base_lr = 0.00004# Modify the job name if you want.
job_name = "SSD_{}".format(resize)
# The name of the model. Modify it if you want.
model_name = "VGG_VOC0712_{}".format(job_name)# Directory which stores the model .prototxt file.
save_dir = "models/VGGNet/VOC0712/{}".format(job_name)
# Directory which stores the snapshot of models.
snapshot_dir = "models/VGGNet/VOC0712/{}".format(job_name)
# Directory which stores the job script and log file.
job_dir = "jobs/VGGNet/VOC0712/{}".format(job_name)
# Directory which stores the detection results.
output_result_dir = "{}/data/VOCdevkit/results/VOC2007/{}/Main".format(os.environ['HOME'], job_name)# model definition files.
train_net_file = "{}/train.prototxt".format(save_dir)
test_net_file = "{}/test.prototxt".format(save_dir)
deploy_net_file = "{}/deploy.prototxt".format(save_dir)
solver_file = "{}/solver.prototxt".format(save_dir)
# snapshot prefix.
snapshot_prefix = "{}/{}".format(snapshot_dir, model_name)
# job script path.
job_file = "{}/{}.sh".format(job_dir, model_name)# Stores the test image names and sizes. Created by data/VOC0712/create_list.sh
name_size_file = "data/indoor/test_name_size.txt"
# The pretrained model. We use the Fully convolutional reduced (atrous) VGGNet.
pretrain_model = "models/VGGNet/VGG_ILSVRC_16_layers_fc_reduced.caffemodel"
# Stores LabelMapItem.
label_map_file = "data/indoor/labelmap_indoor.prototxt"# MultiBoxLoss parameters.
num_classes = 2
share_location = True
background_label_id=0
train_on_diff_gt = True
normalization_mode = P.Loss.VALID
code_type = P.PriorBox.CENTER_SIZE
neg_pos_ratio = 3.
loc_weight = (neg_pos_ratio + 1.) / 4.
multibox_loss_param = {
    'loc_loss_type': P.MultiBoxLoss.SMOOTH_L1,
    'conf_loss_type': P.MultiBoxLoss.SOFTMAX,
    'loc_weight': loc_weight,
    'num_classes': num_classes,
    'share_location': share_location,
    'match_type': P.MultiBoxLoss.PER_PREDICTION,
    'overlap_threshold': 0.5,
    'use_prior_for_matching': True,
    'background_label_id': background_label_id,
    'use_difficult_gt': train_on_diff_gt,
    'do_neg_mining': True,
    'neg_pos_ratio': neg_pos_ratio,
    'neg_overlap': 0.5,
    'code_type': code_type,
    }
loss_param = {
    'normalization': normalization_mode,
    }# parameters for generating priors.
# minimum dimension of input image
min_dim = 300
# conv4_3 ==> 38 x 38
# fc7 ==> 19 x 19
# conv6_2 ==> 10 x 10
# conv7_2 ==> 5 x 5
# conv8_2 ==> 3 x 3
# pool6 ==> 1 x 1
mbox_source_layers = ['conv4_3', 'fc7', 'conv6_2', 'conv7_2', 'conv8_2', 'pool6']
# in percent %
min_ratio = 20
max_ratio = 95
step = int(math.floor((max_ratio - min_ratio) / (len(mbox_source_layers) - 2)))
min_sizes = []
max_sizes = []
for ratio in xrange(min_ratio, max_ratio + 1, step):
  min_sizes.append(min_dim * ratio / 100.)
  max_sizes.append(min_dim * (ratio + step) / 100.)
min_sizes = [min_dim * 10 / 100.] + min_sizes
max_sizes = [[]] + max_sizes
aspect_ratios = [[2], [2, 3], [2, 3], [2, 3], [2, 3], [2, 3]]
# L2 normalize conv4_3.
normalizations = [20, -1, -1, -1, -1, -1]
# variance used to encode/decode prior bboxes.
if code_type == P.PriorBox.CENTER_SIZE:
  prior_variance = [0.1, 0.1, 0.2, 0.2]
else:
  prior_variance = [0.1]
flip = True
clip = True# Solver parameters.
# Defining which GPUs to use.
gpus = ""
gpulist = gpus.split(",")
num_gpus = len(gpulist)# Divide the mini-batch to different GPUs.
batch_size = 4
accum_batch_size = 32
iter_size = accum_batch_size / batch_size
solver_mode = P.Solver.CPU
device_id = 0
batch_size_per_device = batch_size
if num_gpus > 0:
  batch_size_per_device = int(math.ceil(float(batch_size) / num_gpus))
  iter_size = int(math.ceil(float(accum_batch_size) / (batch_size_per_device * num_gpus)))
  solver_mode = P.Solver.GPU
  device_id = int(gpulist[0])if normalization_mode == P.Loss.NONE:
  base_lr /= batch_size_per_device
elif normalization_mode == P.Loss.VALID:
  base_lr *= 25. / loc_weight
elif normalization_mode == P.Loss.FULL:
  # Roughly there are 2000 prior bboxes per image.
  # TODO(weiliu89): Estimate the exact # of priors.
  base_lr *= 2000.# Which layers to freeze (no backward) during training.
freeze_layers = ['conv1_1', 'conv1_2', 'conv2_1', 'conv2_2']# Evaluate on whole test set.
num_test_image = 800
test_batch_size = 1
test_iter = num_test_image / test_batch_sizesolver_param = {
    # Train parameters
    'base_lr': base_lr,
    'weight_decay': 0.0005,
    'lr_policy': "step",
    'stepsize': 40000,
    'gamma': 0.1,
    'momentum': 0.9,
    'iter_size': iter_size,
    'max_iter': 60000,
    'snapshot': 40000,
    'display': 10,
    'average_loss': 10,
    'type': "SGD",
    'solver_mode': solver_mode,
    'device_id': device_id,
    'debug_info': False,
    'snapshot_after_train': True,
    # Test parameters
    'test_iter': [test_iter],
    'test_interval': 10000,
    'eval_type': "detection",
    'ap_version': "11point",
    'test_initialization': False,
    }# parameters for generating detection output.
det_out_param = {
    'num_classes': num_classes,
    'share_location': share_location,
    'background_label_id': background_label_id,
    'nms_param': {'nms_threshold': 0.45, 'top_k': 400},
    'save_output_param': {
        'output_directory': output_result_dir,
        'output_name_prefix': "comp4_det_test_",
        'output_format': "VOC",
        'label_map_file': label_map_file,
        'name_size_file': name_size_file,
        'num_test_image': num_test_image,
        },
    'keep_top_k': 200,
    'confidence_threshold': 0.01,
    'code_type': code_type,
    }# parameters for evaluating detection results.
det_eval_param = {
    'num_classes': num_classes,
    'background_label_id': background_label_id,
    'overlap_threshold': 0.5,
    'evaluate_difficult_gt': False,
    'name_size_file': name_size_file,
    }### Hopefully you don't need to change the following ###
# Check file.
check_if_exist(train_data)
check_if_exist(test_data)
check_if_exist(label_map_file)
check_if_exist(pretrain_model)
make_if_not_exist(save_dir)
make_if_not_exist(job_dir)
make_if_not_exist(snapshot_dir)# Create train net.
net = caffe.NetSpec()
net.data, net.label = CreateAnnotatedDataLayer(train_data, batch_size=batch_size_per_device,
        train=True, output_label=True, label_map_file=label_map_file,
        transform_param=train_transform_param, batch_sampler=batch_sampler)VGGNetBody(net, from_layer='data', fully_conv=True, reduced=True, dilated=True,
    dropout=False, freeze_layers=freeze_layers)AddExtraLayers(net, use_batchnorm)mbox_layers = CreateMultiBoxHead(net, data_layer='data', from_layers=mbox_source_layers,
        use_batchnorm=use_batchnorm, min_sizes=min_sizes, max_sizes=max_sizes,
        aspect_ratios=aspect_ratios, normalizations=normalizations,
        num_classes=num_classes, share_location=share_location, flip=flip, clip=clip,
        prior_variance=prior_variance, kernel_size=3, pad=1)# Create the MultiBoxLossLayer.
name = "mbox_loss"
mbox_layers.append(net.label)
net[name] = L.MultiBoxLoss(*mbox_layers, multibox_loss_param=multibox_loss_param,
        loss_param=loss_param, include=dict(phase=caffe_pb2.Phase.Value('TRAIN')),
        propagate_down=[True, True, False, False])with open(train_net_file, 'w') as f:
    print('name: "{}_train"'.format(model_name), file=f)
    print(net.to_proto(), file=f)
shutil.copy(train_net_file, job_dir)# Create test net.
net = caffe.NetSpec()
net.data, net.label = CreateAnnotatedDataLayer(test_data, batch_size=test_batch_size,
        train=False, output_label=True, label_map_file=label_map_file,
        transform_param=test_transform_param)VGGNetBody(net, from_layer='data', fully_conv=True, reduced=True, dilated=True,
    dropout=False, freeze_layers=freeze_layers)AddExtraLayers(net, use_batchnorm)mbox_layers = CreateMultiBoxHead(net, data_layer='data', from_layers=mbox_source_layers,
        use_batchnorm=use_batchnorm, min_sizes=min_sizes, max_sizes=max_sizes,
        aspect_ratios=aspect_ratios, normalizations=normalizations,
        num_classes=num_classes, share_location=share_location, flip=flip, clip=clip,
        prior_variance=prior_variance, kernel_size=3, pad=1)conf_name = "mbox_conf"
if multibox_loss_param["conf_loss_type"] == P.MultiBoxLoss.SOFTMAX:
  reshape_name = "{}_reshape".format(conf_name)
  net[reshape_name] = L.Reshape(net[conf_name], shape=dict(dim=[0, -1, num_classes]))
  softmax_name = "{}_softmax".format(conf_name)
  net[softmax_name] = L.Softmax(net[reshape_name], axis=2)
  flatten_name = "{}_flatten".format(conf_name)
  net[flatten_name] = L.Flatten(net[softmax_name], axis=1)
  mbox_layers[1] = net[flatten_name]
elif multibox_loss_param["conf_loss_type"] == P.MultiBoxLoss.LOGISTIC:
  sigmoid_name = "{}_sigmoid".format(conf_name)
  net[sigmoid_name] = L.Sigmoid(net[conf_name])
  mbox_layers[1] = net[sigmoid_name]net.detection_out = L.DetectionOutput(*mbox_layers,
    detection_output_param=det_out_param,
    include=dict(phase=caffe_pb2.Phase.Value('TEST')))
net.detection_eval = L.DetectionEvaluate(net.detection_out, net.label,
    detection_evaluate_param=det_eval_param,
    include=dict(phase=caffe_pb2.Phase.Value('TEST')))with open(test_net_file, 'w') as f:
    print('name: "{}_test"'.format(model_name), file=f)
    print(net.to_proto(), file=f)
shutil.copy(test_net_file, job_dir)# Create deploy net.
# Remove the first and last layer from test net.
deploy_net = net
with open(deploy_net_file, 'w') as f:
    net_param = deploy_net.to_proto()
    # Remove the first (AnnotatedData) and last (DetectionEvaluate) layer from test net.
    del net_param.layer[0]
    del net_param.layer[-1]
    net_param.name = '{}_deploy'.format(model_name)
    net_param.input.extend(['data'])
    net_param.input_shape.extend([
        caffe_pb2.BlobShape(dim=[1, 3, resize_height, resize_width])])
    print(net_param, file=f)
shutil.copy(deploy_net_file, job_dir)# Create solver.
solver = caffe_pb2.SolverParameter(
        train_net=train_net_file,
        test_net=[test_net_file],
        snapshot_prefix=snapshot_prefix,
        **solver_param)with open(solver_file, 'w') as f:
    print(solver, file=f)
shutil.copy(solver_file, job_dir)max_iter = 0
# Find most recent snapshot.
for file in os.listdir(snapshot_dir):
  if file.endswith(".solverstate"):
    basename = os.path.splitext(file)[0]
    iter = int(basename.split("{}_iter_".format(model_name))[1])
    if iter > max_iter:
      max_iter = itertrain_src_param = '--weights="{}" \\\n'.format(pretrain_model)
if resume_training:
  if max_iter > 0:
    train_src_param = '--snapshot="{}_iter_{}.solverstate" \\\n'.format(snapshot_prefix, max_iter)if remove_old_models:
  # Remove any snapshots smaller than max_iter.
  for file in os.listdir(snapshot_dir):
    if file.endswith(".solverstate"):
      basename = os.path.splitext(file)[0]
      iter = int(basename.split("{}_iter_".format(model_name))[1])
      if max_iter > iter:
        os.remove("{}/{}".format(snapshot_dir, file))
    if file.endswith(".caffemodel"):
      basename = os.path.splitext(file)[0]
      iter = int(basename.split("{}_iter_".format(model_name))[1])
      if max_iter > iter:
        os.remove("{}/{}".format(snapshot_dir, file))# Create job file.
with open(job_file, 'w') as f:
  f.write('cd {}\n'.format(caffe_root))
  f.write('./build/tools/caffe train \\\n')
  f.write('--solver="{}" \\\n'.format(solver_file))
  f.write(train_src_param)
  if solver_param['solver_mode'] == P.Solver.GPU:
    f.write('--gpu {} 2>&1 | tee {}/{}.log\n'.format(gpus, job_dir, model_name))
  else:
    f.write('2>&1 | tee {}/{}.log\n'.format(job_dir, model_name))# Copy the python script to job_dir.
py_file = os.path.abspath(__file__)
shutil.copy(py_file, job_dir)# Run the job.
os.chmod(job_file, stat.S_IRWXU)
if run_soon:
  subprocess.call(job_file, shell=True)


ssd_pascal_indoor.py


训练命令：
python examples/ssd/ssd_pascal_indoor.py4 测试SSD框架中提供了测试代码，有C++版本和python版本


 4.1 c++版本


编译完SSD后，C++版本的的可执行文件存放目录： .build_release/examples/ssd/ssd_detect.bin测试命令  ./.build_release/examples/ssd/ssd_detect.bin models/VGGNet/indoor/deploy.prototxt   models/VGGNet/indoor/VGG_VOC0712_SSD_300x300_iter_60000.caffemodel pictures.txt其中pictures.txt中保存的是待测试图片的list


 4.2 python版本


python 版本的测试过程参见examples/detection.ipynb


参考：
　1 将数据集做成VOC2007格式用于Faster-RCNN训练
    2 SSD的配置安装与测试

    					

    				

    								    
				        				
    				

    				                    	                    	                    	    

                            点赞 691                        

                                            


    				
    				    				
    				

    				    

    					    					

    				

    				
    				
    				

    				    

        					        					
        					
贡献者

    					


                		
    				

				


    			

	

		        

            

            	上一篇：
                一键生成APP官网
            

        

			

	

				

            

            	下一篇：
            	ASP.NET Aries JSAPI 文档说明：AR.Utility
            

        

	    	



    			
    			
                                    			
                    			

	

		相关推荐
	

		

	

		

			
			            		python开发_常用的python模块及安装方法
        					
		

		

			
    		                                    python开发_常用的python模块及安装方法            
			
adodb：我们领导推荐的数据库连接组件bsddb3：BerkeleyDB的连接组件Cheetah-1.0：我比较喜欢这个版本的cheeta…

			

    

        

    		            

    		    		

    		    		    		
    		        	            技术                	

    	

                    	日期：2022-11-24
        	        	        	点赞：878
        	        	        	阅读：9,082
        	        	        	        	    	

    


		

	








    	

	

		

			
			            		Educational Codeforces Round 11 C. Hard Process 二分
        					
		

		

			
    		                                    Educational Codeforces Round 11 C. Hard Process 二分            
			
C. Hard Process题目连接：http://www.codeforces.com/contest/660/problem/CDes…

			

    

        

    		            

    		    		

    		    		    		
    		        	            技术                	

    	

                    	日期：2022-11-24
        	        	        	点赞：807
        	        	        	阅读：5,556
        	        	        	        	    	

    


		

	








    	

	

		

			
			            		下载Ubuntn 17.04 内核源代码
        					
		

		

			
    		                                    下载Ubuntn 17.04 内核源代码            
			
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…

			

    

        

    		            

    		    		

    		    		    		
    		        	            技术                	

    	

                    	日期：2022-11-24
        	        	        	点赞：569
        	        	        	阅读：6,406
        	        	        	        	    	

    


		

	








    	

	

		

			
			            		可用Active Desktop Calendar V7.86 注册码序列号
        					
		

		

			
    		                                    可用Active Desktop Calendar V7.86 注册码序列号            
			
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…

			

    

        

    		            

    		    		

    		    		    		
    		        	            技术                	

    	

                    	日期：2022-11-24
        	        	        	点赞：733
        	        	        	阅读：6,179
        	        	        	        	    	

    


		

	








    	

	

		

			
			            		Android调用系统相机、自定义相机、处理大图片
        					
		

		

			
    		                                    Android调用系统相机、自定义相机、处理大图片            
			
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式，并且由于涉及到要把拍到的照片显…

			

    

        

    		            

    		    		

    		    		    		
    		        	            技术                	

    	

                    	日期：2022-11-24
        	        	        	点赞：512
        	        	        	阅读：7,815
        	        	        	        	    	

    


		

	








    	

	

		

			
			            		Struts的使用
        					
		

		

			
    		                                    Struts的使用            
			
一、Struts2的获取　　Struts的官方网站为：http://struts.apache.org/　　下载完Struts2的jar包,…

			

    

        

    		            

    		    		

    		    		    		
    		        	            技术                	

    	

                    	日期：2022-11-24
        	        	        	点赞：671
        	        	        	阅读：4,898
        	        	        	        	    	

    


		

	








    

    			
    			
			

		

		

	

		



    

        

            Lomu
        

		

		    

    			                			

		

	    

		    

		    
贡献者

		    

		    这家伙很懒，只想把你留下。		    

	    

	

		

		

			

				文章
				
56

			

			

				收藏
				
0

			

			

				人气
				
192,045

			

            

				粉丝
				

			

		

	

			

        

            
            

                进主页
            

        

    

    




    

        

            文章展示        

        
    

    

                
  • 
            
    
                [ 技术 ]                python开发_常用的python模块及安装方法
            
    
        
    • 
                
  • 
            
    
                [ 技术 ]                Educational Codeforces Round 11 C. Hard Process 二分
            
    
        
    • 
                
  • 
            
    
                [ 技术 ]                下载Ubuntn 17.04 内核源代码
            
    
        
    • 
                
  • 
            
    
                [ 技术 ]                可用Active Desktop Calendar V7.86 注册码序列号
            
    
        
    • 
                
  • 
            
    
                [ 技术 ]                Android调用系统相机、自定义相机、处理大图片
            
    
        
    • 
                
  • 
            
    
                [ 技术 ]                Struts的使用
            
    
        
    • 
            
    

    	
    

    	
    

    


		
    
		    
		    		    
		    
    
	
	
	
    
    	
    
        	
    个人收藏笔记记录
    
            我的笔记
        
    
    
    

    
			
			
    
    
        
    

    			
			
		
    
		


    
    
    
        
            
        
        
    
    

    


						
    
    
        
            
        
        首页
    
    
        
            
        
        首页
    
    
        
            
        
        菜单
    
    
        
            
        
        首页
    
    
        
            
        
        首页