Caffe深入分析(源碼)

Caffe的整體流程圖：

程序入口：main()

int main(int argc, char** argv) {
      .....
      return GetBrewFunction(caffe::string(argv[1]))();
      ....
}

 

g_brew_map實現過程，首先通過 typedef定義函數指針 typedef int (*BrewFunction)(); 這個是用typedef定義函數指針方法。這個程序定義一個BrewFunction函數指針類型，在caffe.cpp 中 BrewFunction 作為GetBrewFunction()函數的返回類型，可以是 train()，test()，device_query()，time() 這四個函數指針的其中一個。在train()，test()，中可以調用solver類的函數，從而進入到net，進入到每一層，運行整個caffe程序。然后對每個函數注冊。

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

• train: 訓練或者調整一個模型
• test : 在測試集上測試一個模型
• device_query : 打印GPU的調試信息
• time: 壓測一個模型的執行時間

如果需要，可以增加其他的方式，然后通過RegisterBrewFunction()函數注冊一下即可。

 

接着調用train()函數，train函數中主要有三個方法ReadSolverParamsFromTextFileOrDie、CreateSolver、Solve。

// 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;
}

 

ReadSolverParamsFromTextFileOrDie

caffe::ReadSolverParamsFromTextFileOrDie(FLAGS_solver, &solver_param)解析-solver指定的solver.prototxt的文件內容到solver_param中

 

CreateSolver

CreateSolver函數構建solver和net，該函數是初始化的入口，會通過執行Solver的構造函數，調用 void Solver<Dtype>::Init(const SolverParameter& param)，該函數內有InitTrainNet()、InitTestNets()。對於InitTrainNet函數：

......
net_.reset(new Net<Dtype>(net_param));

 

調用Net類的構造函數，然后執行Init()操作，該函數具體的內容如下圖和源碼所示：

template <typename Dtype>
void Net<Dtype>::Init(const NetParameter& in_param) {
  ........//過濾校驗參數FilterNet
  FilterNet(in_param, &filtered_param);
  .........//插入Splits層
  InsertSplits(filtered_param, &param);
  .......// 構建網絡中輸入輸出存儲結構
  bottom_vecs_.resize(param.layer_size());
  top_vecs_.resize(param.layer_size());
  bottom_id_vecs_.resize(param.layer_size());
  param_id_vecs_.resize(param.layer_size());
  top_id_vecs_.resize(param.layer_size());
  bottom_need_backward_.resize(param.layer_size());

  for (int layer_id = 0; layer_id < param.layer_size(); ++layer_id) {
   ...//創建層
 layers_.push_back(LayerRegistry<Dtype>::CreateLayer(layer_param));
    layer_names_.push_back(layer_param.name());
    LOG_IF(INFO, Caffe::root_solver())
        << "Creating Layer " << layer_param.name();
    bool need_backward = false;

    // Figure out this layer's input and output
    for (int bottom_id = 0; bottom_id < layer_param.bottom_size();
         ++bottom_id) {
      const int blob_id = AppendBottom(param, layer_id, bottom_id,
                                       &available_blobs, &blob_name_to_idx);


   ........//創建相關blob
    // If the layer specifies that AutoTopBlobs() -> true and the LayerParameter
    // specified fewer than the required number (as specified by
    // ExactNumTopBlobs() or MinTopBlobs()), allocate them here.
    Layer<Dtype>* layer = layers_[layer_id].get();
    if (layer->AutoTopBlobs()) {
      const int needed_num_top =
          std::max(layer->MinTopBlobs(), layer->ExactNumTopBlobs());
      for (; num_top < needed_num_top; ++num_top) {
        // Add "anonymous" top blobs -- do not modify available_blobs or
        // blob_name_to_idx as we don't want these blobs to be usable as input
        // to other layers.
        AppendTop(param, layer_id, num_top, NULL, NULL);
      }
    }


    .....//執行SetUp()
    // After this layer is connected, set it up.
    layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]);
    LOG_IF(INFO, Caffe::root_solver())
        << "Setting up " << layer_names_[layer_id];
    for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) {
      if (blob_loss_weights_.size() <= top_id_vecs_[layer_id][top_id]) {
        blob_loss_weights_.resize(top_id_vecs_[layer_id][top_id] + 1, Dtype(0));
      }
      blob_loss_weights_[top_id_vecs_[layer_id][top_id]] = layer->loss(top_id);
      LOG_IF(INFO, Caffe::root_solver())
          << "Top shape: " << top_vecs_[layer_id][top_id]->shape_string();
      if (layer->loss(top_id)) {
        LOG_IF(INFO, Caffe::root_solver())
            << "    with loss weight " << layer->loss(top_id);
      }
      memory_used_ += top_vecs_[layer_id][top_id]->count();
    }
    LOG_IF(INFO, Caffe::root_solver())
        << "Memory required for data: " << memory_used_ * sizeof(Dtype);
    const int param_size = layer_param.param_size();
    const int num_param_blobs = layers_[layer_id]->blobs().size();
    CHECK_LE(param_size, num_param_blobs)
        << "Too many params specified for layer " << 

 SetUp是怎么構建的呢？

virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {}

 void SetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
    InitMutex();
    CheckBlobCounts(bottom, top);
    LayerSetUp(bottom, top);
    Reshape(bottom, top);
    SetLossWeights(top);
  }

 

 初始化的總體流程大概就是新建一個Solver對象，然后調用Solver類的構造函數，然后在Solver的構造函數中又會新建Net類實例，在Net類的構造函數中又會新建各個layer的實例，一直具體到設置每個Blob，大概就完成了網絡初始化的工作了。

 

Solve

train函數中CreateSolver()執行完成后，接下來是具體訓練過程，執行Solve()函數---->Step()--->結束

Solve的具體內容和代碼：

template <typename Dtype>
void Solver<Dtype>::Solve(const char* resume_file) {
  CHECK(Caffe::root_solver());
  LOG(INFO) << "Solving " << net_->name();
  LOG(INFO) << "Learning Rate Policy: " << param_.lr_policy();

  // 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_);
  
  // overridden by setting snapshot_after_train := false
  if (param_.snapshot_after_train()
      && (!param_.snapshot() || iter_ % param_.snapshot() != 0)) {
    Snapshot();
  }
 
  // display loss
  if (param_.display() && iter_ % param_.display() == 0) {
    int average_loss = this->param_.average_loss();
    Dtype loss;
    net_->Forward(&loss);

    UpdateSmoothedLoss(loss, start_iter, average_loss);

    
  if (param_.test_interval() && iter_ % param_.test_interval() == 0) {
    TestAll();
  }
}

 

然后開始執行Step函數，具體內容和代碼：

template <typename Dtype>  
void Solver<Dtype>::Step(int iters)  
{  
    // 起始迭代步數  
    const int start_iter = iter_;  
    // 終止迭代步數  
    const int stop_iter = iter_ + iters;  

    // 判斷是否已經完成設定步數  
    while (iter_ < stop_iter)  
    {  
        // 將net_中的Bolb梯度參數置為零  
        net_->ClearParamDiffs();  

        ...  

        // accumulate the loss and gradient  
        Dtype loss = 0;  
        for (int i = 0; i < param_.iter_size(); ++i)  
        {  
            // 正向傳導和反向傳導，並計算loss  
            loss += net_->ForwardBackward();  
        }  
        loss /= param_.iter_size();  

        // 為了輸出結果平滑，將臨近的average_loss個loss數值進行平均，存儲在成員變量smoothed_loss_中  
        UpdateSmoothedLoss(loss, start_iter, average_loss);  

        // BP算法更新權重  
        ApplyUpdate();  

        // Increment the internal iter_ counter -- its value should always indicate  
        // the number of times the weights have been updated.  
        ++iter_;  
    }  
}  

while循環中先調用了網絡類Net::ForwardBackward()成員函數進行正向傳導和反向傳導，並計算loss

Dtype ForwardBackward() {
    Dtype loss;
    //正向傳導
    Forward(&loss);
    //反向傳導
    Backward();
    return loss;
  }

而Fordward函數中調用了ForwardFromTo，而FordwardFromTo又調用了每個layer的Fordward。反向傳導函數Backward()調用了BackwardFromTo(int start, int end)函數。正向傳導和反向傳導結束后，再調用SGDSolver::ApplyUpdate()成員函數進行權重更新。

• ForwardBackward：按順序調用了Forward和Backward。
• ForwardFromTo(int start, int end)：執行從start層到end層的前向傳遞，采用簡單的for循環調用。，forward只要計算損失loss
• BackwardFromTo(int start, int end)：和前面的ForwardFromTo函數類似，調用從start層到end層的反向傳遞。backward主要根據loss來計算梯度，caffe通過自動求導並反向組合每一層的梯度來計算整個網絡的梯度。
• ToProto函數完成網絡的序列化到文件，循環調用了每個層的ToProto函數

template <typename Dtype>  
void SGDSolver<Dtype>::ApplyUpdate()  
{  
    // 獲取當前學習速率  
    Dtype rate = GetLearningRate();  
    if (this->param_.display() && this->iter_ % this->param_.display() == 0)  
    {  
        LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate;  
    }  

    // 在計算當前梯度的時候，如果該值超過了閾值clip_gradients，則將梯度直接設置為該閾值  
    // 此處閾值設為-1，即不起作用  
    ClipGradients();  

    // 逐層更新網絡中的可學習層  
    for (int param_id = 0; param_id < this->net_->learnable_params().size();  
       ++param_id)  
    {  
        // 歸一化  
        Normalize(param_id);  
        // L2范數正則化添加衰減權重  
        Regularize(param_id);  
        // 隨機梯度下降法計算更新值  
        ComputeUpdateValue(param_id, rate);  
    }  
    // 更新權重  
    this->net_->Update();  
} 

最后將迭代次數++iter_，繼續while循環，直到迭代次數完成。 這就是整個網絡的訓練過程。