caffe 代码阅读笔记1

首先查看caffe.cpp里的train函数：

 // Train / Finetune a model.
 //训练，微调一个网络模型
 int train() {
   // google的glog库，检查--solver、--snapshot和--weight并输出消息；必须有指定solver，snapshot和weight两者指定其一；
   CHECK_GT(FLAGS_solver.size(), ) << "Need a solver definition to train.";
   CHECK(!FLAGS_snapshot.size() || !FLAGS_weights.size())
       << "Give a snapshot to resume training or weights to finetune "
       "but not both.";  

   caffe::SolverParameter solver_param;  //实例化SolverParameter类，该类保存solver参数和相应的方法
   caffe::ReadSolverParamsFromTextFileOrDie(FLAGS_solver, &solver_param); //将-solver指定solver.prototxt文件内容解析到solver_param中  

   // If the gpus flag is not provided, allow the mode and device to be set
   // in the solver prototxt.
   // 根据命令参数-gpu或者solver.prototxt提供的信息设置GPU
   if (FLAGS_gpu.size() ==
       && solver_param.solver_mode() == caffe::SolverParameter_SolverMode_GPU) {
       if (solver_param.has_device_id()) {
           FLAGS_gpu = "" +
               boost::lexical_cast<string>(solver_param.device_id());
       } else {  // Set default GPU if unspecified
           FLAGS_gpu = "" + boost::lexical_cast<string>();  // boost::lexical_cast(0)是将数值0转换为字符串'“0”；
       }
   }  

   // 多GPU下，将GPU编号存入vector容器中（get_gpus()函数通过FLAGS_gpu获取）；
   vector<int> gpus;
   get_gpus(&gpus);
   if (gpus.size() == ) {
     LOG(INFO) << "Use CPU.";
     Caffe::set_mode(Caffe::CPU);
   } else {
     ostringstream s;
     for (int i = ; i < gpus.size(); ++i) {
       s << (i ? ", " : "") << gpus[i];
     }
     LOG(INFO) << "Using GPUs " << s.str();
 #ifndef CPU_ONLY
     cudaDeviceProp device_prop;
     for (int i = ; i < gpus.size(); ++i) {
       cudaGetDeviceProperties(&device_prop, gpus[i]);
       LOG(INFO) << "GPU " << gpus[i] << ": " << device_prop.name;
     }
 #endif
     solver_param.set_device_id(gpus[]);
     Caffe::SetDevice(gpus[]);
     Caffe::set_mode(Caffe::GPU);
     Caffe::set_solver_count(gpus.size());
   }  

   // 处理snapshot, stop or none信号，其声明在include/caffe/util/signal_Handler.h中；
   // GetRequestedAction在caffe.cpp中，将‘stop’，‘snapshot’，‘none’转换为标准信号，即解析；
   caffe::SignalHandler signal_handler(
         GetRequestedAction(FLAGS_sigint_effect),
         GetRequestedAction(FLAGS_sighup_effect));  

   //指向caffe::Solver对象，该对象由CreateSolver创建
   shared_ptr<caffe::Solver<float> >
       solver(caffe::SolverRegistry<float>::CreateSolver(solver_param));  

   //solver设置操作函数
   solver->SetActionFunction(signal_handler.GetActionFunction());  

   // 从snapshot或caffemodel中恢复train；
   if (FLAGS_snapshot.size()) {
     LOG(INFO) << "Resuming from " << FLAGS_snapshot;
     solver->Restore(FLAGS_snapshot.c_str());
   } else if (FLAGS_weights.size()) {
     CopyLayers(solver.get(), FLAGS_weights);
   }  

   if (gpus.size() > ) {
     caffe::P2PSync<float> sync(solver, NULL, solver->param());
     sync.Run(gpus);
   } else {
     LOG(INFO) << "Starting Optimization";
     solver->Solve();   // // 初始化完成，开始优化网络
   }
   LOG(INFO) << "Optimization Done.";
   return ;
 }
 RegisterBrewFunction(train);
   

// Test: score a model.
//测试网络模型
int test() {
  CHECK_GT(FLAGS_model.size(), ) << "Need a model definition to score.";
  CHECK_GT(FLAGS_weights.size(), ) << "Need model weights to score.";  

  // Set device id and mode
  vector<int> gpus;
  get_gpus(&gpus);
  if (gpus.size() != ) {
    LOG(INFO) << "Use GPU with device ID " << gpus[];
#ifndef CPU_ONLY
    cudaDeviceProp device_prop;
    cudaGetDeviceProperties(&device_prop, gpus[]);
    LOG(INFO) << "GPU device name: " << device_prop.name;
#endif
    Caffe::SetDevice(gpus[]);
    Caffe::set_mode(Caffe::GPU);
  } else {
    LOG(INFO) << "Use CPU.";
    Caffe::set_mode(Caffe::CPU);
  }
  // Instantiate the caffe net.
  //实例化caffe网络
  Net<float> caffe_net(FLAGS_model, caffe::TEST);
  caffe_net.CopyTrainedLayersFrom(FLAGS_weights);
  LOG(INFO) << "Running for " << FLAGS_iterations << " iterations.";  

  vector<int> test_score_output_id;
  vector<float> test_score;
  float loss = ;
  for (int i = ; i < FLAGS_iterations; ++i) {
    float iter_loss;
    const vector<Blob<float>*>& result =
        caffe_net.Forward(&iter_loss);
    loss += iter_loss;
    int idx = ;
    for (int j = ; j < result.size(); ++j) {
      const float* result_vec = result[j]->cpu_data();
      for (int k = ; k < result[j]->count(); ++k, ++idx) {
        const float score = result_vec[k];
        if (i == ) {
          test_score.push_back(score);
          test_score_output_id.push_back(j);
        } else {
          test_score[idx] += score;
        }
        const std::string& output_name = caffe_net.blob_names()[
            caffe_net.output_blob_indices()[j]];
        LOG(INFO) << "Batch " << i << ", " << output_name << " = " << score;
      }
    }
  }
  loss /= FLAGS_iterations;
  LOG(INFO) << "Loss: " << loss;
  for (int i = ; i < test_score.size(); ++i) {
    const std::string& output_name = caffe_net.blob_names()[
        caffe_net.output_blob_indices()[test_score_output_id[i]]];
    const float loss_weight = caffe_net.blob_loss_weights()[
        caffe_net.output_blob_indices()[test_score_output_id[i]]];
    std::ostringstream loss_msg_stream;
    const float mean_score = test_score[i] / FLAGS_iterations;
    if (loss_weight) {
      loss_msg_stream << " (* " << loss_weight
                      << " = " << loss_weight * mean_score << " loss)";
    }
    LOG(INFO) << output_name << " = " << mean_score << loss_msg_stream.str();
  }  

  return ;
}
RegisterBrewFunction(test);