1. 首先是入口檔案trian_net.py，真正處理資料的檔案都在lib檔案裡，包括資料集製作的檔案在lib/datasets下，網路訓練測試的檔案在lib/fast_rcnn下，lib/roi_data_layer是用python實現的網路的輸入層。

parse_args函式解析輸入引數：網路引數定義，初始化模型（這兩項沒有預設值必須自己指定），顯示卡號，最大迭代次數，訓練資料位置等。
def parse_args():
    """
    Parse input arguments
    """
    parser = argparse.ArgumentParser(description='Train a Fast R-CNN network'
 
)
    parser.add_argument('--gpu', dest='gpu_id',
                        help='GPU device id to use [0]',
                        default=0, type=int)
    parser.add_argument('--solver', dest='solver',
                        help='solver prototxt',
                        default=None, type=str)
    parser.add_argument('--iters'
 
, dest='max_iters',
                        help='number of iterations to train',
                        default=40000, type=int)
    parser.add_argument('--weights', dest='pretrained_model',
                        help='initialize with pretrained model weights',
                        default=None, type=str)
    parser.add_argument('--cfg'
 
, dest='cfg_file',
                        help='optional config file',
                        default=None, type=str)
    parser.add_argument('--imdb', dest='imdb_name',
                        help='dataset to train on',
                        default='voc_2007_trainval', type=str)
    parser.add_argument('--rand', dest='randomize',
                        help='randomize (do not use a fixed seed)',
                        action='store_true')
    parser.add_argument('--set', dest='set_cfgs',
                        help='set config keys', default=None,
                        nargs=argparse.REMAINDER)

    if len(sys.argv) == 1:
        parser.print_help()
        sys.exit(1)

    args = parser.parse_args()
    return args
程式入口，可以看做main函式
if __name__ == '__main__':
    args = parse_args()#解析輸入引數，存入args

    print('Called with args:')
    print(args)

    if args.cfg_file is not None:
        cfg_from_file(args.cfg_file)
    if args.set_cfgs is not None:
        cfg_from_list(args.set_cfgs)

    print('Using config:')
    pprint.pprint(cfg)
#設定caffe
    if not args.randomize:
        # 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()
    if args.gpu_id is not None:
        caffe.set_device(args.gpu_id)
#讀取訓練資料，包括訓練圖片的位置，物體gt(外接框)座標，selective search方法產生的proposal(候選框)。呼叫的是lib/datasets/factory.py中的get_imdb函式
    imdb = get_imdb(args.imdb_name)
    print 'Loaded dataset `{:s}` for training'.format(imdb.name)
    #上步得到的資料imdb進一步製作成訓練時的資料，主要是把圖片翻轉，擴充訓練樣本.
    roidb = get_training_roidb(imdb)

    output_dir = get_output_dir(imdb, None)
    print 'Output will be saved to `{:s}`'.format(output_dir)
#真正的訓練函式，呼叫lib/fast_rcnn/train.py中的train_net函式
    train_net(args.solver, roidb, output_dir,
              pretrained_model=args.pretrained_model,
              max_iters=args.max_iters)

2.訓練資料讀取主函式是imdb=get_imdb(args.imdb_name)函式，在下面前輩的部落格中已經很清楚了，請參考。
http://www.cnblogs.com/louyihang-loves-baiyan/archive/2015/10/16/4885659.html
將訓練資料讀取到imdb變數中只是簡單的將資料讀入，並沒有將樣本標註為正負類，資料擴充等操作。緊接著呼叫 roidb = get_training_roidb(imdb)製作訓練資料集，實現在lib/fast_rcnn/train.py中

def get_training_roidb(imdb):
    """Returns a roidb (Region of Interest database) for use in training."""
    if cfg.TRAIN.USE_FLIPPED:
        print 'Appending horizontally-flipped training examples...'
        imdb.append_flipped_images()#資料翻轉操作，擴充訓練資料集
        print 'done'

    print 'Preparing training data...'
    rdl_roidb.prepare_roidb(imdb)#prepare_roidb函式中max_classes是每個proposal重合度最大的物體gt的類別，max_overlaps是最大重合度。
    print 'done'

    return imdb.roidb

3.lib/roi_data_layer下的網輸入層
caffe提供了python，也就是說可以用python實現某一個層，fast_rcnn就用python實現了網路的輸入層。
fast_rcnn中實現caffe支援python主要設定了兩個檔案：fast-rcnn/caffe-fast-rcnn/src/caffe.proto和fast-rcnn/caffe-fast-rcnn/include/caffe/python_layer.hpp檔案
. caffe.proto中註冊Python層引數：

  optional PythonParameter python_param = 130;
........
// Message that stores parameters used by PythonLayer
message PythonParameter {
  optional string module = 1;
  optional string layer = 2;
  // This value is set to the attribute `param_str_` of your custom
  // `PythonLayer` object in Python before calling `setup()` method. This could
  // be a number, a string, a dictionary in Python dict format or JSON etc. You
  // may parse this string in `setup` method and use them in `forward` and
  // `backward`.
  optional string param_str = 3 [default = ''];
}

. python_layer.hpp標頭檔案定義了需要python實現的幾個輸入層的重要函式：setup函式，reshape函式，forward函式，backward函式。

#ifndef CAFFE_PYTHON_LAYER_HPP_
#define CAFFE_PYTHON_LAYER_HPP_

#include <boost/python.hpp>

#include <string>
#include <vector>

#include "caffe/layer.hpp"

namespace bp = boost::python;

namespace caffe {

#define PYTHON_LAYER_ERROR() { \
  PyObject *petype, *pevalue, *petrace; \
  PyErr_Fetch(&petype, &pevalue, &petrace); \
  bp::object etype(bp::handle<>(bp::borrowed(petype))); \
  bp::object evalue(bp::handle<>(bp::borrowed(bp::allow_null(pevalue)))); \
  bp::object etrace(bp::handle<>(bp::borrowed(bp::allow_null(petrace)))); \
  bp::object sio(bp::import("StringIO").attr("StringIO")()); \
  bp::import("traceback").attr("print_exception")( \
    etype, evalue, etrace, bp::object(), sio); \
  LOG(INFO) << bp::extract<string>(sio.attr("getvalue")())(); \
  PyErr_Restore(petype, pevalue, petrace); \
  throw; \
}

template <typename Dtype>
class PythonLayer : public Layer<Dtype> {
 public:
  PythonLayer(PyObject* self, const LayerParameter& param)
      : Layer<Dtype>(param), self_(bp::handle<>(bp::borrowed(self))) { }

  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
    try {
      self_.attr("param_str_") = bp::str(
        this->layer_param_.python_param().param_str());
        #LayerSetUp函式呼叫setup函式，具體實現在lib/roi_data_layer/layer.py中的setup函式。下面reshape，forward，backward函式同理
      self_.attr("setup")(bottom, top);
    } catch (bp::error_already_set) {
      PYTHON_LAYER_ERROR();
    }
  }

  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
    try {
      self_.attr("reshape")(bottom, top);
    } catch (bp::error_already_set) {
      PYTHON_LAYER_ERROR();
    }
  }

  virtual inline const char* type() const { return "Python"; }

 protected:
  virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
    try {
    #forward函式的實現在lib/roi_data_layer/layer.py中
      self_.attr("forward")(bottom, top);
    } catch (bp::error_already_set) {
      PYTHON_LAYER_ERROR();
    }
  }
  virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
    try {
    #backward函式的實現在lib/roi_data_layer/layer.py中
      self_.attr("backward")(top, propagate_down, bottom);
    } catch (bp::error_already_set) {
      PYTHON_LAYER_ERROR();
    }
  }

 private:
  bp::object self_;
};

}  // namespace caffe

#endif