輸入命令./experiments/scripts/faster_rcnn_alt_opt.sh 0 ZF pascal_voc

faster_rcnn_alt_opt.sh的訓練程式碼如下：

time ./tools/train_faster_rcnn_alt_opt.py --gpu ${GPU_ID} \

  --net_name ${NET} \
  --weights data/imagenet_models/${NET}.v2.caffemodel \
  --imdb ${TRAIN_IMDB} \
  --cfg experiments/cfgs/faster_rcnn_alt_opt.yml \

  ${EXTRA_ARGS}

引數賦值：${GPU_ID} =0、${NET} =ZF、${TRAIN_IMDB} =pascal_voc

呼叫./tools/train_faster_rcnn_alt_opt.py檔案

1、初始化引數

（1）args = parse_args()，

包括--gpu：這個引數指定訓練使用的GPU裝置，我的電腦只有一枚GPU，預設情況下自動開啟，其gpu_id為0；

--net_name：訓練的網路型別

--weights：這個引數指定了finetune的初始引數，我的電腦GPU不怎麼高階，只能使用caffenet進行finetune；

--cfg：

--imdb：這個引數指定了訓練所需要的訓練資料，如果你需要訓練自己的資料，那麼這個引數是必須要指定的；

--set：

（2）rpn_test_prototxt = get_solvers(args.net_name)

在models/pascal_voc/netname/faster_rcnn_alt_opt資料夾下有stage1_rpn_solver60k80k.pt等不同階段所對應的solver檔案，並定義了各個階段最大迭代次數，這裡支援的net_name有VGG16、VGG_CNN_M_1024、ZF三種

def get_solvers(net_name):
    # Faster R-CNN Alternating Optimization
    n = 'faster_rcnn_alt_opt'
    # Solver for each training stage
    solvers = [[net_name, n, 'stage1_rpn_solver60k80k.pt'],
               [net_name, n, 'stage1_fast_rcnn_solver30k40k.pt'],
               [net_name, n, 'stage2_rpn_solver60k80k.pt'],
               [net_name, n, 'stage2_fast_rcnn_solver30k40k.pt']]
    solvers = [os.path.join(cfg.MODELS_DIR, *s) for s in solvers]
    # Iterations for each training stage
    #每一輪訓練的最大迭代次數，建議測試時都設定為100
    max_iters = [80000, 40000, 80000, 40000]
    # max_iters = [100, 100, 100, 100]
    # Test prototxt for the RPN
    rpn_test_prototxt = os.path.join(
        cfg.MODELS_DIR, net_name, n, 'rpn_test.pt')
    return solvers, max_iters, rpn_test_prototxt
 

2、train_rpn函式

（1）_init_caffe：該函式作用便是初始化caffe物件，僅做了兩步操作，第一步是初始化隨機種子，第二步是設定GPU。

def _init_caffe(cfg):
    """Initialize pycaffe in a training process.
    """

    import caffe
    # fix the random seeds (numpy and caffe) for reproducibility
    np.random.seed(cfg.RNG_SEED)
    caffe.set_random_seed(cfg.RNG_SEED)
    # set up caffe
    caffe.set_mode_gpu()
    caffe.set_device(cfg.GPU_ID)

（2）roidb, imdb = get_roidb(imdb_name)  

->imdb = get_imdb(imdb_name)

imdb根據imdb_name(預設是“voc_2007_trainval)來獲取，這裡的imdb物件的獲取採用了工廠模式，由\lib\datasets\factory.py生成，根據年份(2007)與切分的資料集(trainval)返回pascal_voc物件，pascal_voc與coco都繼承於imdb物件。(\lib\datasets\pascal_voc.py+coco.py)

->imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)

設定gt方法。首先這裡初始化了一些配置，比較容易忽略的的是PROPOSAL_METHOD設定成了’gt’，值得一提。這個設定是從get_roidb然後追溯到底層資料類pascal-voc得到體現，可以看到imdb(pascal_voc的父類)通過roidb_handler來決定用什麼方式生成roidb，預設為selective_search，這裡用了gt_roidb。 

->output_dir = get_output_dir(imdb)

確定路徑

->roidb = get_training_roidb(imdb)

roidb是通過lib\fast_rcnn\train.py中的get_training_roidb來獲取的,這個roidb是一個imdb的成員變數，包含了訓練集圖片中框出的每個區域。這個函式做了兩件事情，一是將原有的roidb中的每張圖片進行水平翻轉然後添加回roidb中，第二件事是做一些準備工作(有一些讓我很無語……)，詳細的將在相應的檔案進行介紹

（3）model_paths = train_net(solver, roidb, output_dir, pretrained_model=init_model, max_iters=max_iters)

而這個 train_net() 函式是從 lib/fast_rcnn 資料夾中的 train.py 中 import 進來的。train.py主要由一個類SolverWrapper和兩個函式get_training_roidb()和train_net()組成。 

def train_net(solver_prototxt, roidb, output_dir,
              pretrained_model=None, max_iters=40000):
    """Train a Fast R-CNN network."""

    roidb = filter_roidb(roidb)
    sw = SolverWrapper(solver_prototxt, roidb, output_dir,
                       pretrained_model=pretrained_model)

    print 'Solving...'
    model_paths = sw.train_model(max_iters)
    print 'done solving'
    return model_paths

可以發現，該函式是通過呼叫類SolverWrapper來實現其主要功能的，類SolverWrapper初始化完成後，就是要呼叫train_model函式來進行網路訓練。

3、rpn_generate函式

該函式的作用就是根據輸入的資料與模型與prototxt產生proposal，可作為下一步的訓練所用，也可作為測試。 該函式最最核心的一句程式碼是rpn_proposals = imdb_proposals(rpn_net, imdb)，其他的都是作為引數準備，與輸出的一些工作。如果僅僅淺嘗輒止的讀者，知道這個函式的功能就是對每張圖片產生最多2000個roi proposal 與對應的scores然後快取到某個資料夾即可。 希望打破砂鍋問到底的讀者，可以追到函式裡以及prototxt檔案去讀其實現細節。其中proposal_layer我也會單獨開一個篇章來討論實現中的一些重要工作。

def rpn_generate(queue=None, imdb_name=None, rpn_model_path=None, cfg=None,
                 rpn_test_prototxt=None):
    """Use a trained RPN to generate proposals.
    """
    # 設定cfg檔案
    cfg.TEST.RPN_PRE_NMS_TOP_N = -1     # no pre NMS filtering
    cfg.TEST.RPN_POST_NMS_TOP_N = 2000  # limit top boxes after NMS
    print 'RPN model: {}'.format(rpn_model_path)
    print('Using config:')
    pprint.pprint(cfg)

    import caffe
    _init_caffe(cfg)

    # NOTE: the matlab implementation computes proposals on flipped images, too.
    # We compute them on the image once and then flip the already computed
    # proposals. This might cause a minor loss in mAP (less proposal jittering).
    imdb = get_imdb(imdb_name)
    print 'Loaded dataset `{:s}` for proposal generation'.format(imdb.name)

    # Load RPN and configure output directory
    # 建立一個Net例項物件，以下為個人觀點，對boost庫以及wraper不熟，只說說個人理解，如有錯誤，後續更正，歡迎指正： 
    #a)會呼叫_caffe.cpp裡面的Net_Init_Load函式，_caffe.cpp裡面`.def("__init__", bp::make_constructor(&Net_Init_Load))`，
    #應該是將Net_Init_Load與__init__構造器繫結，所以在建立caffe.Net物件的時候，會呼叫Net_Init_Load，
    #終端上就會輸出網路的初始化資訊同時從pretrainedmodel上copy source layers
    rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST)
    output_dir = get_output_dir(imdb)
    print 'Output will be saved to `{:s}`'.format(output_dir)
    # Generate RPN proposals on all images in an imdb.
    #imdb_proposals函式在generate.py檔案中
    #rpn_proposals是一個列表的列表，每個子列表
    rpn_proposals = imdb_proposals(rpn_net, imdb)#核心
    # Write proposals to disk and send the proposal file path through the
    # multiprocessing queue
    # splitext函式分離檔案的檔名和拓展名
    rpn_net_name = os.path.splitext(os.path.basename(rpn_model_path))[0]
    rpn_proposals_path = os.path.join(
        output_dir, rpn_net_name + '_proposals.pkl')
    with open(rpn_proposals_path, 'wb') as f:
        cPickle.dump(rpn_proposals, f, cPickle.HIGHEST_PROTOCOL)
        # 將python專有的資料結構（比如rpn_proposals是一個列表）序列化，儲存在磁碟中
    print 'Wrote RPN proposals to {}'.format(rpn_proposals_path)
    #返回生成的rpn proposal的儲存地址。
    queue.put({'proposal_path': rpn_proposals_path})

4、train_fast_rcnn函式

這個函式就是訓練fast-rcnn的部分，首先它將產生roidb的方法設定成rpn_roidb，工廠模式的獲取roidb思想，在上文已提。 接下來就是準備一些引數、路徑等等，用於送入網路訓練，最後儲存模型。具體的訓練細節，需要閱讀prototxt檔案才能把它的過程弄得水落石出。

def train_fast_rcnn(queue=None, imdb_name=None, init_model=None, solver=None,
                    max_iters=None, cfg=None, rpn_file=None):
    """Train a Fast R-CNN using proposals generated by an RPN.
    """

    #這個引數的設定是為了提高程式碼的重用性。可以看到其他檔案中，train_rpn和train_fast_rcnn的過程在實現時，會有重複程式碼，故設定該變數將其合併。
    #conv5後面現在接的是fast-rcnn
    cfg.TRAIN.HAS_RPN = False           # not generating prosals on-the-fly
    #roidb由剛剛訓練完的RPN產生
    cfg.TRAIN.PROPOSAL_METHOD = 'rpn'   # use pre-computed RPN proposals instead
    #每個mini-batch包含兩張圖片，以及他們proposal的roi區域
    #每次訓練fast-rcnn使用兩張圖片
    cfg.TRAIN.IMS_PER_BATCH = 2
    print 'Init model: {}'.format(init_model)
    print 'RPN proposals: {}'.format(rpn_file)
    print('Using config:')
    pprint.pprint(cfg)

    import caffe
    _init_caffe(cfg)

    roidb, imdb = get_roidb(imdb_name, rpn_file=rpn_file)
    output_dir = get_output_dir(imdb)
    print 'Output will be saved to `{:s}`'.format(output_dir)
    # Train Fast R-CNN
    model_paths = train_net(solver, roidb, output_dir,
                            pretrained_model=init_model,
                            max_iters=max_iters)
    # Cleanup all but the final model
    for i in model_paths[:-1]:
        os.remove(i)
    fast_rcnn_model_path = model_paths[-1]
    # Send Fast R-CNN model path over the multiprocessing queue
    queue.put({'model_path': fast_rcnn_model_path})

5、資料準備

不過，關於Fast-RCNN的重頭戲我們其實還沒開始——那就是如何準備訓練資料。

在上面介紹訓練的流程中，與此相關的函式是：imdb= get_imdb(args.imdb_name)

這個函式是從從lib/datasets/資料夾中的factory.py中import進來的，我們來看一下這個函式：

def get_imdb(name):
    """Get an imdb (image database) by name."""
    if not __sets.has_key(name):
        raise KeyError('Unknown dataset: {}'.format(name))
    return __sets[name]()

這個函式很簡單，其實就是根據字典的key來取得訓練資料。 那麼這個字典是怎麼形成的呢？看下面：

for year in ['2007', '2012']:
    for split in ['train', 'val', 'trainval', 'test']:
        name = 'voc_{}_{}'.format(year, split)
        __sets[name] = (lambda split=split, year=year: pascal_voc(split, year))

它本質上是通過lib/datasets/資料夾下面的pascal_voc.py引入的。所以，現在我們就得開始進入pascal_voc.py：

def __init__(self, image_set, year, devkit_path=None):
        imdb.__init__(self, 'voc_' + year + '_' + image_set)
        self._year = year
        self._image_set = image_set
        self._devkit_path = self._get_default_path() if devkit_path is None \
                            else devkit_path
        self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
        self._classes = ('__background__', # always index 0
                         'aeroplane', 'bicycle', 'bird', 'boat',
                         'bottle', 'bus', 'car', 'cat', 'chair',
                         'cow', 'diningtable', 'dog', 'horse',
                         'motorbike', 'person', 'pottedplant',
                         'sheep', 'sofa', 'train', 'tvmonitor')
        self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
        self._image_ext = '.jpg'
        self._image_index = self._load_image_set_index()
        # Default to roidb handler
        # self.selective_search_roidb是一個函式物件，把這個函式物件付給_roidb_handler屬性
        self._roidb_handler = self.selective_search_roidb
        self._salt = str(uuid.uuid4())
        self._comp_id = 'comp4'

        # PASCAL specific config options
        self.config = {'cleanup'     : True,
                       'use_salt'    : True,
                       'use_diff'    : False,
                       'matlab_eval' : False,
                       'rpn_file'    : None,
                       'min_size'    : 2}

        assert os.path.exists(self._devkit_path), \
                'VOCdevkit path does not exist: {}'.format(self._devkit_path)
        assert os.path.exists(self._data_path), \
                'Path does not exist: {}'.format(self._data_path)

在初始化自身的同時，先呼叫了父類的初始化方法，將imdb_name傳入，例如(‘voc_2007_trainval’)
下面是成員變數的初始化：
{
    year:’2007’
    image _set:’trainval’
    devkit _path:’data/VOCdevkit2007’
    data _path:’data /VOCdevkit2007/VOC2007’
    classes:(…)_如果想要訓練自己的資料，需要修改這裡_
    class _to _ind:{…} _一個將類名轉換成下標的字典 _
    image _ext:’.jpg’
    image _index: [‘000001’,’000003’,……]_根據trainval.txt獲取到的image索引_
    roidb _handler: <Method gt_roidb >
    salt:  <Object uuid >
    comp _id:’comp4’
    config:{…}
}

類 init 構造完成後，會呼叫函式 roidb，這個函式是從類 imdb 中繼承過來的，這個函式會呼叫 _roidb_handler 來處理，其中 _roidb_handler=self.selective_search_roidb，下面我們來看看這個函式：

    def selective_search_roidb(self):
        """
        Return the database of selective search regions of interest.
        Ground-truth ROIs are also included.

        This function loads/saves from/to a cache file to speed up future calls.
        """
        cache_file = os.path.join(self.cache_path,
                                  self.name + '_selective_search_roidb.pkl')

        if os.path.exists(cache_file):
            with open(cache_file, 'rb') as fid:
                roidb = cPickle.load(fid)
            print '{} ss roidb loaded from {}'.format(self.name, cache_file)
            return roidb

        if int(self._year) == 2007 or self._image_set != 'test':
            gt_roidb = self.gt_roidb()
            ss_roidb = self._load_selective_search_roidb(gt_roidb)
            roidb = imdb.merge_roidbs(gt_roidb, ss_roidb)
        else:
            roidb = self._load_selective_search_roidb(None)
        with open(cache_file, 'wb') as fid:
            cPickle.dump(roidb, fid, cPickle.HIGHEST_PROTOCOL)
        print 'wrote ss roidb to {}'.format(cache_file)

        return roidb

這個函式在訓練階段會首先呼叫get_roidb() 函式：

def rpn_roidb(self):
        if int(self._year) == 2007 or self._image_set != 'test':
            gt_roidb = self.gt_roidb()
            # 求取rpn_roidb需要以gt_roidb作為引數才能得到
            rpn_roidb = self._load_rpn_roidb(gt_roidb)
            roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb)
        else:
            roidb = self._load_rpn_roidb(None)

        return roidb

如果存在cache_file，那麼get_roidb()就會直接從cache_file中讀取資訊；如果不存在cache_file，那麼會呼叫_load_pascal_annotation()來取得標註資訊。_load_pascal_annotation函式如下所示：

 def _load_pascal_annotation(self, index):
        """
        Load image and bounding boxes info from XML file in the PASCAL VOC
        format.
        """
        filename = os.path.join(self._data_path, 'Annotations', index + '.xml')
        tree = ET.parse(filename)
        objs = tree.findall('object')
        if not self.config['use_diff']:
            # Exclude the samples labeled as difficult
            non_diff_objs = [
                obj for obj in objs if int(obj.find('difficult').text) == 0]
            # if len(non_diff_objs) != len(objs):
            #     print 'Removed {} difficult objects'.format(
            #         len(objs) - len(non_diff_objs))
            objs = non_diff_objs
        num_objs = len(objs)

        boxes = np.zeros((num_objs, 4), dtype=np.uint16)
        gt_classes = np.zeros((num_objs), dtype=np.int32)
        overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)
        # "Seg" area for pascal is just the box area
        seg_areas = np.zeros((num_objs), dtype=np.float32)

        # Load object bounding boxes into a data frame.
        for ix, obj in enumerate(objs):
            bbox = obj.find('bndbox')
            # Make pixel indexes 0-based
            x1 = float(bbox.find('xmin').text) - 1
            y1 = float(bbox.find('ymin').text) - 1
            x2 = float(bbox.find('xmax').text) - 1
            y2 = float(bbox.find('ymax').text) - 1
            cls = self._class_to_ind[obj.find('name').text.lower().strip()]
            boxes[ix, :] = [x1, y1, x2, y2]
            gt_classes[ix] = cls
            # 從anatation直接載入影象的資訊，因為本身就是ground-truth , 所以overlap直接設為1
            overlaps[ix, cls] = 1.0
            seg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)
        # overlaps為 num_objs * K 的陣列， K表示總共的類別數， num_objs表示當前這張圖片中box的個數
        overlaps = scipy.sparse.csr_matrix(overlaps)

        return {'boxes' : boxes,
                'gt_classes': gt_classes,
                'gt_overlaps' : overlaps,
                'flipped' : False,
                'seg_areas' : seg_areas}

當處理完標註的資料後，接下來就要載入SS階段獲得的資料，通過如下函式完成：

    def _load_selective_search_roidb(self, gt_roidb):
        filename = os.path.abspath(os.path.join(cfg.DATA_DIR,
                                                'selective_search_data',
                                                self.name + '.mat'))
        assert os.path.exists(filename), \
               'Selective search data not found at: {}'.format(filename)
        raw_data = sio.loadmat(filename)['boxes'].ravel()

        box_list = []
        for i in xrange(raw_data.shape[0]):
            boxes = raw_data[i][:, (1, 0, 3, 2)] - 1
            keep = ds_utils.unique_boxes(boxes)
            boxes = boxes[keep, :]
            keep = ds_utils.filter_small_boxes(boxes, self.config['min_size'])
            boxes = boxes[keep, :]
            box_list.append(boxes)

        return self.create_roidb_from_box_list(box_list, gt_roidb)
    # 從XML檔案載入影象資訊，而且是ground-truth資訊，比如boxes   

有一點需要注意的是，ss中獲得的box的值，和fast-rcnn中認為的box值有點差別，那就是你需要交換box的x和y座標。