Caffe：深入分析(怎么训练)

main()　

　　首先入口函数caffe.cpp

int main(int argc, char** argv) {
  ......
  if (argc == 2) {
#ifdef WITH_PYTHON_LAYER
    try {
#endif
      return GetBrewFunction(caffe::string(argv[1]))(); //根据输入参数确定是train还是test，采用string到函数指针的映射实现，非常巧妙
#ifdef WITH_PYTHON_LAYER
    } catch (bp::error_already_set) {
      PyErr_Print();
      return 1;
    }
#endif
  } else {
    gflags::ShowUsageWithFlagsRestrict(argv[0], "tools/caffe");
  }
}

　　在main函数中GetBrewFunction函数调用了通过工厂模式生成的由string到函数指针的map

typedef int (*BrewFunction)();
typedef std::map<caffe::string, BrewFunction> BrewMap;
BrewMap g_brew_map;

　　在train、test、device_query、time函数后面都可以看到对这些函数的register，相当于这些函数指针已经在map中存在了

RegisterBrewFunction(train);
RegisterBrewFunction(test);
RegisterBrewFunction(device_query);
RegisterBrewFunction(time);

train()

　　接着是train过程

// Train / Finetune a model.
int train() {
  ......
  caffe::SolverParameter solver_param;
  caffe::ReadSolverParamsFromTextFileOrDie(FLAGS_solver, &solver_param);//从-solver参数读取solver_param
  ......
  shared_ptr<caffe::Solver<float> >
      solver(caffe::SolverRegistry<float>::CreateSolver(solver_param));//从参数创建solver，同样采用string到函数指针的映射实现，用到了工厂模式

  if (FLAGS_snapshot.size()) {//迭代snapshot次后保存模型一次
    LOG(INFO) << "Resuming from " << FLAGS_snapshot;
    solver->Restore(FLAGS_snapshot.c_str());
  } else if (FLAGS_weights.size()) {//若采用finetuning，则拷贝weight到指定模型
    CopyLayers(solver.get(), FLAGS_weights);
  }

  if (gpus.size() > 1) {
    caffe::P2PSync<float> sync(solver, NULL, solver->param());
    sync.Run(gpus);
  } else {
    LOG(INFO) << "Starting Optimization";
    solver->Solve();//开始训练网络
  }
  LOG(INFO) << "Optimization Done.";
  return 0;
}

Solver()

　　看CreateSolver函数是如何构建solver和net的，CreateSolver定义在solver_factory.hpp中，首先需要知道的是solver是一个基类，继承自它的类有SGD等，下面的实现就可以根据param的type构造一个指向特定solver的指针，比如SGD。

static Solver<Dtype>* CreateSolver(const SolverParameter& param) {
    const string& type = param.type();
    CreatorRegistry& registry = Registry();
    CHECK_EQ(registry.count(type), 1) << "Unknown solver type: " << type
        << " (known types: " << SolverTypeListString() << ")";
    return registry[type](param);
  }

　　关键之处在于上面代码最后一行语句，它的作用是根据配置文件创建对应的Solver对象（默认为SGDSolver子类对象）。此处工厂模式和一个关键的宏REGISTER_SOLVER_CLASS(SGD)发挥了重要作用。

#define REGISTER_SOLVER_CLASS(type)                                              
  template <typename Dtype>                                                      
  Solver<Dtype>* Creator_##type##Solver(                                         
      const SolverParameter& param)                                              
  {                                                                              
    return new type##Solver<Dtype>(param);                                       
  }                                                                              
  REGISTER_SOLVER_CREATOR(type, Creator_##type##Solver)    
}   

　　这样一个SGDSolver对象就调用其构造函数被构造出来了。

explicit SGDSolver(const SolverParameter& param)
      : Solver<Dtype>(param) { PreSolve(); }

　　同时，Solver这个基类也被构造出来了，在solver.hpp里

explicit Solver(const SolverParameter& param,
      const Solver* root_solver = NULL);

　　Solver构造函数又会调用Init进行训练网络和测试网络的初始化，Init函数没有被声明为虚函数，不能被覆写，也就是说所有的solver都调用这个函数进行初始化。

template <typename Dtype>
void Solver<Dtype>::Init(const SolverParameter& param) {
  ......
  // Scaffolding code
  InitTrainNet();//初始化训练网络
  if (Caffe::root_solver()) {
    InitTestNets();//初始化测试网络
    LOG(INFO) << "Solver scaffolding done.";
  }
  iter_ = 0;//迭代次数设为0
  current_step_ = 0;
}

InitTrainNet()

　　接下来看训练网络初始化函数InitTrainNet，具体的内容见Net的网络层的构建(源码分析)

　　caffe是如何来solve的：在成员函数Solve()内部，

template <typename Dtype>
void Solver<Dtype>::Solve(const char* resume_file) {
  ......
  // For a network that is trained by the solver, no bottom or top vecs
  // should be given, and we will just provide dummy vecs.
  int start_iter = iter_;
  //开始迭代
  Step(param_.max_iter() - iter_);
  ......
}

Step()

　　下面我们看一下Solver::Step()函数内部实现情况，具体的一次迭代过程。见Caffe参数交换源码分析

　　这就是整个网络的训练过程。