梳理caffe代码net(四)

 梳理caffe代码net(四)

net定义网络， 整个网络中含有很多layers， net.cpp负责计算整个网络在训练中的forward, backward过程， 即计算forward/backward 时各layer的gradient。

看一下官网的英文描述：

 

The forward and backward passes are the essential computations of a Net.

Forward and Backward

Let’s consider a simple logistic regression classifier.

The forward pass computes the output given the input for inference.In forward Caffe composes the computation of each layer to compute the “function” represented by the model.This pass goes from bottom to top.

Forward pass

The data x is passed through an inner product layer for g(x) then through a softmax for h(g(x)) and softmax loss to give fW(x).

The backward pass computes the gradient given the loss for learning.In backward Caffe reverse-composes the gradient of each layer to compute the gradient of the whole model by automatic differentiation.This is back-propagation.This pass goes from top to bottom.

Backward pass

The backward pass begins with the loss and computes the gradient with respect to the output∂fW∂h. The gradient with respect to the rest of the model is computed layer-by-layer through the chain rule. Layers with parameters, like theINNER_PRODUCT layer, compute the gradient with respect to their parameters∂fW∂Wip during the backward step.

These computations follow immediately from defining the model: Caffe plans and carries out the forward and backward passes for you.

  • The Net::Forward() and Net::Backward() methods carry out the respective passes while Layer::Forward() and Layer::Backward() compute each step.
  • Every layer type has forward_{cpu,gpu}() andbackward_{cpu,gpu}() methods to compute its steps according to the mode of computation. A layer may only implement CPU or GPU mode due to constraints or convenience.

The Solver optimizes a model by first calling forward to yield the output and loss, then calling backward to generate the gradient of the model, and then incorporating the gradient into a weight update that attempts to minimize the loss. Division of labor between the Solver, Net, and Layer keep Caffe modular and open to development.

net的实现：

 

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <algorithm>  
  2. #include <map>  
  3. #include <set>  
  4. #include <string>  
  5. #include <utility>  
  6. #include <vector>  
  7.   
  8. #include "caffe/common.hpp"  
  9. #include "caffe/layer.hpp"  
  10. #include "caffe/net.hpp"  
  11. #include "caffe/proto/caffe.pb.h"  
  12. #include "caffe/util/insert_splits.hpp"  
  13. #include "caffe/util/io.hpp"  
  14. #include "caffe/util/math_functions.hpp"  
  15. #include "caffe/util/upgrade_proto.hpp"  
  16.   
  17. #include "caffe/util/channel.hpp"  
  18. #include "caffe/util/mpi_functions.hpp"  
  19.   
  20. #include "caffe/test/test_caffe_main.hpp"  
  21. #include "caffe/vision_layers.hpp"  
  22.   
  23. namespace caffe {  
  24. /* 
  25. 功能：调用Init函数初始化网络 
  26. 输入：NetParameter& param 
  27. 输出：无 
  28. */  
  29. template <typename Dtype>  
  30. Net<Dtype>::Net(const NetParameter& param) {  
  31.   Init(param);  
  32. }  
  33. /* 
  34. 功能：调用Init函数初始化网络 
  35. 输入：string& param_file 
  36. 输出：无 
  37. */  
  38. template <typename Dtype>  
  39. Net<Dtype>::Net(const string& param_file, Phase phase) {  
  40.   NetParameter param;  
  41.   ReadNetParamsFromTextFileOrDie(param_file, ¶m);  
  42.   param.mutable_state()->set_phase(phase);  
  43.   Init(param);  
  44. }  
  45. /* 
  46. 功能：初始化网络 
  47. 输入：NetParameter& in_param 
  48. 输出：无 
  49. 步骤： 
  50. <1> 调用InsertSplits()函数从in_param读入新网络到param 
  51. <2> 定义name_，blob_name_to_idx，available_blobs，num_layers 
  52. <3> param.input_size()返回输入层blob的个数; 
  53.     param.input(i)表示第i个blob的名字; 
  54.     param.layers_size()返回网络的层数。 
  55. <4> 对每一个输入层的blob： 
  56.     产生一块和当前blob一样大的空间 e.g. imput_dim=[12 55 66 39 20 24 48 64]表示第一个blob的四个维数为 12 55 66 39，第二个为 20 24 48 64 接着blob_pointer指向这块空间 
  57.     blob_pointer压到blobs_中 vector<shared_ptr<Blob<Dtype>>> blobs_ 
  58.     blob_name压到blob_names_中 vector<string> blob_names_ 
  59.     param.force_backward()压到blob_need_backward_中vector<bool> blob_need_backward_ 
  60.     i 压到 net_input_blob_indices_中 net_input_blob_indices_ -> vector 
  61.     blob_pointer.get() 压到 net_input_blobs_中 
  62.     注意与blobs_的区别 
  63.     vector<shared_ptr<Blob<Dtype>>> blobs_ 
  64.     vector<Blob<Dtype>*> net_input_blobs_ 
  65.     shared_ptr类型的参数调用.get()则得到Blob*类型 
  66.     map<string, int> blob_name_to_idx 
  67.     初始化为输入层的每个blob的名字 set<string> available_blobs 
  68.     计算所需内存 memory_used += blob_pointer->count() 
  69.  
  70. <5> 存每一层的输入blob指针 vector<vector<Blob<Dtype>*> > bottom_vecs_ 
  71.     存每一层输入(bottom)的id vector<vector<int> > bottom_id_vecs_ 
  72.     存每一层输出(top)的blob vector<vector<Blob<Dtype>*> > top_vecs_ 
  73.     用网络的层数param.layers_size()去初始化上面四个变量 
  74.     vector<vector<int> > top_id_vecs_ 
  75. <6> 对第i层（很大的一个for循环）： 
  76.     param.layers(i)返回的是关于第当前层的参数： 
  77.     layer_param = param.layers(i) 
  78.     把当前层的参数转换为shared_ptr<Layer<Dtype>>，并压入到layers_中 
  79.     把当前层的名字压入到layer_names_：vector<string> layer_names_ 
  80.     判断当前层是否需要反馈 need_backward = param.force_backward() 
  81.  
  82.     下面开始产生当前层：分为处理bottom的blob和top的blob两个步骤 
  83.     对第j个bottom的blob： 
  84.         layer_param.bottom_size()存的是当前层的输入blob数量 
  85.         layer_param.bottom(j)存的是第j个输入blob的名字 
  86.         读取当前blob的id，其中blob_name_to_idx在输入层初始化过了 
  87.         blob_name_to_idx[blob_name] = i 
  88.         输出当前blob的名字 
  89.         存入第j个输入blob的指针bottom_vecs_[i].push_back(blobs_[blob_id].get()) 
  90.         存入第j个输入blob的id bottom_id_vecs_[i].push_back(blob_id) 
  91.         更新need_backward 
  92.         从available_blobs中删除第j个blob的名字 
  93.  
  94.     对第j个top的blob： 
  95.         layer_param.top_size()存的是当前层的输出blob数量 
  96.         layer_param.top(j)存的是第j个输出blob的名字 
  97.         判断是否进行同址计算 
  98.         输出当前blob的名字 
  99.         定义一块新的blob空间，用blob_pointer指向这块空间 
  100.         把这个指针存入到blobs_中 
  101.         把blob_name、force_backward、idx存入对应的容器中 
  102.         向available_blobs插入当前blob的名字 
  103.         top_vecs_[i]对于第i层，插入当前blob的指针 
  104.         top_id_vecs_[i]对于第i层，插入当前blob的id 
  105.     输出当前层位于top的blob的信息 
  106.     计算所需内存 
  107.     判断当前层i是否需要backward 
  108.  
  109. <7> 所有名字在available_blobs中的blob为当前层的输出blob，存入net_output_blobs_中 
  110. <8> 建立每个blob的name和index的对应关系map：blob_names_index_ 
  111. <9> 建立每个层的name和index的对应关系map：layer_names_index_ 
  112. <10> 调用GetLearningRateAndWeightDecay函数 
  113. */  
  114. template <typename Dtype>  
  115. void Net<Dtype>::Init(const NetParameter& in_param) {  
  116.   // Set phase from the state.  
  117.   phase_ = in_param.state().phase();  
  118.   // Filter layers based on their include/exclude rules and  
  119.   // the current NetState.  
  120.   NetParameter filtered_param;  
  121.   FilterNet(in_param, &filtered_param);  
  122.   LOG(INFO) << "Initializing net from parameters: " << std::endl  
  123.             << filtered_param.DebugString();  
  124.   // Create a copy of filtered_param with splits added where necessary.  
  125.   NetParameter param;  
  126.   InsertSplits(filtered_param, ¶m);  
  127.   // Basically, build all the layers and set up their connections.  
  128.   name_ = param.name();  
  129.   map<string, int> blob_name_to_idx;//blob_name_to_idx是一个map,其关键字是不重复的  
  130.   set<string> available_blobs;//available_blobs是一个set,其关键字是不重复的  
  131.   CHECK(param.input_dim_size() == 0 || param.input_shape_size() == 0)  
  132.       << "Must specify either input_shape OR deprecated input_dim, not both.";  
  133.   if (param.input_dim_size() > 0) {  
  134.     // Deprecated 4D dimensions.  
  135.     CHECK_EQ(param.input_size() * 4, param.input_dim_size())  
  136.         << "Incorrect input blob dimension specifications.";  
  137.   } else {  
  138.     CHECK_EQ(param.input_size(), param.input_shape_size())  
  139.         << "Exactly one input_shape must be specified per input.";  
  140.   }  
  141.   memory_used_ = 0;  
  142.   // set the input blobs  
  143.   for (int input_id = 0; input_id < param.input_size(); ++input_id) {  
  144.     const int layer_id = -1;  // inputs have fake layer ID -1  
  145.     AppendTop(param, layer_id, input_id, &available_blobs, &blob_name_to_idx);  
  146.   }  
  147.   DLOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype);  
  148.   // For each layer, set up its input and output  
  149.   bottom_vecs_.resize(param.layer_size());  
  150.   top_vecs_.resize(param.layer_size());  
  151.   bottom_id_vecs_.resize(param.layer_size());  
  152.   param_id_vecs_.resize(param.layer_size());  
  153.   top_id_vecs_.resize(param.layer_size());  
  154.   bottom_need_backward_.resize(param.layer_size());  
  155.   
  156.   for (int layer_id = 0; layer_id < param.layer_size(); ++layer_id) {  
  157.     // Inherit phase from net if unset.  
  158.     if (!param.layer(layer_id).has_phase()) {  
  159.       param.mutable_layer(layer_id)->set_phase(phase_);//实参phase_是网络的phase,为模板类layer设置shape_属性    
  160.     }  
  161.     // Setup BN params implicitly.  
  162.     if (param.layer(layer_id).type() == "BN") {  
  163.       LayerParameter* layer_param = param.mutable_layer(layer_id);  
  164.       if (layer_param->param_size() > 2) {  
  165.         LOG(FATAL) << "Layer " << layer_param->name()  
  166.                    << " must have no more than two specified params";  
  167.       }  
  168.       while (layer_param->param_size() < 4) {  
  169.         ParamSpec* param = layer_param->add_param();  
  170.         if (layer_param->param_size() <= 2) {  
  171.           param->set_lr_mult(1);  
  172.           param->set_decay_mult(0);  
  173.         } else {  
  174.           param->set_lr_mult(0);  
  175.           param->set_decay_mult(0);  
  176.         }  
  177.       }  
  178.     }  
  179.     // Setup layer.  
  180.     const LayerParameter& layer_param = param.layer(layer_id);  
  181.  //检查LayerParameter类型propagate_down成员的个数师傅达标   
  182.     if (layer_param.propagate_down_size() > 0) {  
  183.       CHECK_EQ(layer_param.propagate_down_size(),  
  184.           layer_param.bottom_size())  
  185.           << "propagate_down param must be specified "  
  186.           << "either 0 or bottom_size times ";  
  187.     }  
  188.     layers_.push_back(LayerRegistry<Dtype>::CreateLayer(layer_param));  
  189.     layer_names_.push_back(layer_param.name());  
  190.     LOG(INFO) << "Creating Layer " << layer_param.name();  
  191.     bool need_backward = false;  
  192.   
  193.     // Figure out this layer's input and output  
  194.     #ifdef USE_MPI  
  195.     vector<bool> source_layer_need_sync;  
  196.     for (int bottom_id = 0; bottom_id < layer_param.bottom_size();  
  197.          ++bottom_id) {  
  198.   
  199.       const int blob_id = AppendBottom(param, layer_id, bottom_id,  
  200.                                        &available_blobs, &blob_name_to_idx);  
  201.       int src_layer_id = top_layer_indices_[blob_id].first;  
  202.       if (src_layer_id>=0) source_layer_need_sync.push_back(layers_[src_layer_id]->need_sync());  
  203.       if (source_layer_need_sync.size()>0){  
  204.         CHECK_EQ(source_layer_need_sync.back(), source_layer_need_sync[0])  
  205.           <<" blob "<<layer_param.bottom(0)  
  206.           <<" and blob "<< layer_param.bottom(bottom_id)  
  207.           <<" are from layers with different paralle mode. This is not supported.";  
  208.       }  
  209.       // If a blob needs backward, this layer should provide it.  
  210. /*blob_need_backward_,整个网络中，所有非参数blob，是否需要backward。注意，这里所说的所有非参数blob其实指的是AppendTop函数中遍历的所有top blob,并不是每一层的top+bottom,因为这一层的top就是下一层的bottom,网络是一层一层堆起来的。  
  211. */  
  212.       need_backward |= blob_need_backward_[blob_id];  
  213.     }  
  214.   
  215.     if (layers_[layer_id]->is_gathering()){  
  216.       layers_[layer_id]->set_need_sync(false);  
  217.     } else {  
  218.       if(layers_[layer_id]->is_scattering()){  
  219.         layers_[layer_id]->set_need_sync(true);  
  220.       } else {  
  221.         if ((source_layer_need_sync.size() > 0)) {  
  222.           layers_[layer_id]->set_need_sync(source_layer_need_sync[0]);  
  223.           LOG(INFO) << "This layer is inheriting previous layer's sync mode: " << source_layer_need_sync[0];  
  224.         }  
  225.       }  
  226.     }  
  227.     #else  
  228.     for (int bottom_id = 0; bottom_id < layer_param.bottom_size();  
  229.          ++bottom_id) {  
  230.       const int blob_id = AppendBottom(param, layer_id, bottom_id,  
  231.                                        &available_blobs, &blob_name_to_idx);  
  232.       // If a blob needs backward, this layer should provide it.  
  233.       need_backward |= blob_need_backward_[blob_id];  
  234.     }  
  235.     #endif  
  236.   
  237.     int num_top = layer_param.top_size();  
  238.     for (int top_id = 0; top_id < num_top; ++top_id) {  
  239.       AppendTop(param, layer_id, top_id, &available_blobs, &blob_name_to_idx);  
  240.     }  
  241.     // If the layer specifies that AutoTopBlobs() -> true and the LayerParameter  
  242.     // specified fewer than the required number (as specified by  
  243.     // ExactNumTopBlobs() or MinTopBlobs()), allocate them here.  
  244.     Layer<Dtype>* layer = layers_[layer_id].get();  
  245.     if (layer->AutoTopBlobs()) {  
  246.       const int needed_num_top =  
  247.           std::max(layer->MinTopBlobs(), layer->ExactNumTopBlobs());  
  248.       for (; num_top < needed_num_top; ++num_top) {  
  249.         // Add "anonymous" top blobs -- do not modify available_blobs or  
  250.         // blob_name_to_idx as we don't want these blobs to be usable as input  
  251.         // to other layers.  
  252.         AppendTop(param, layer_id, num_top, NULL, NULL);  
  253.       }  
  254.     }  
  255.     // After this layer is connected, set it up.  
  256.     LOG(INFO) << "Setting up " << layer_names_[layer_id];  
  257. //每次循环，都会更新向量blob_loss_weights    
  258.     layers_[layer_id]->SetUp(bottom_vecs_[layer_id], top_vecs_[layer_id]);  
  259.     for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) {  
  260. //blob_loss_weights_,每次遍历一个layer的时候，都会resize blob_loss_weights_, 然后调用模板类layer的loss函数返回loss_weight   
  261.       if (blob_loss_weights_.size() <= top_id_vecs_[layer_id][top_id]) {  
  262.         blob_loss_weights_.resize(top_id_vecs_[layer_id][top_id] + 1, Dtype(0));  
  263.       }  
  264. //top_id_vecs_中存储的最基本元素是blob_id ——> 每一个新的blob都会赋予其一个blob_id，但是这个blob_id可能是会有重复的   
  265.       blob_loss_weights_[top_id_vecs_[layer_id][top_id]] = layer->loss(top_id);  
  266. //loss函数返回loss_weight ——> 在模板类的SetUp方法中会调用SetLossWeights来设置其私有数据成员loss_,里面存储的其实是loss_weight    
  267.       LOG(INFO) << "Top shape: " << top_vecs_[layer_id][top_id]->shape_string();  
  268.       if (layer->loss(top_id)) {  
  269.         LOG(INFO) << "    with loss weight " << layer->loss(top_id);  
  270.       }  
  271.       memory_used_ += top_vecs_[layer_id][top_id]->count();  
  272.     }  
  273.     DLOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype);  
  274.     const int param_size = layer_param.param_size();  
  275.     const int num_param_blobs = layers_[layer_id]->blobs().size();  
  276. //param_size是Layermeter类型对象layer_param中ParamSpec param成员的个数, num_param_blobs是一  
  277. //个Layer中learnable parameter blob的个数，param_size <= num_param_blobs    
  278.     CHECK_LE(param_size, num_param_blobs)  
  279.         << "Too many params specified for layer " << layer_param.name();  
  280.     ParamSpec default_param_spec;  
  281.     for (int param_id = 0; param_id < num_param_blobs; ++param_id) {  
  282.       const ParamSpec* param_spec = (param_id < param_size) ?  
  283.           &layer_param.param(param_id) : &default_param_spec;  
  284.       const bool param_need_backward = param_spec->lr_mult() > 0;//need backward 则为真。  
  285.       need_backward |= param_need_backward;  
  286. //由param_need_backward来决定need_backward是否为真，并且，只要有一次遍历使得need_backward为真，则这个for循环结束后，need_backward也为真  
  287.       layers_[layer_id]->set_param_propagate_down(param_id,  
  288.                                                   param_need_backward);  
  289. //设定一个Layer的parameter blob 是否需要计算diff backward--->set_param_propagate_down是模板类Layer的方法。    
  290.     }  
  291.     for (int param_id = 0; param_id < num_param_blobs; ++param_id) {  
  292.  //添加parameter blob,如果当前layer没有parameter blob(num_param_blobs==0),比如RELU，那么就不进入循环，不添加parameter blob    
  293.  //AppendParam只是执行为当前layer添加parameter blob的相关工作，并不会修改与backward的相关属性    
  294.       AppendParam(param, layer_id, param_id);  
  295.     }  
  296.     // Finally, set the backward flag  
  297.     layer_need_backward_.push_back(need_backward);  
  298. //在上述的AppendTop函数中，在遍历当前层的每一个top blob的时候都会将一个false（默认值）压入向量blob_need_backward_。在下面的代码中，如果这个layer need backward，则会更新blob_need_backward_  
  299.     if (need_backward) {  
  300.       for (int top_id = 0; top_id < top_id_vecs_[layer_id].size(); ++top_id) {  
  301.         blob_need_backward_[top_id_vecs_[layer_id][top_id]] = true;  
  302.   
  303.         //special treatment for "Gather" layer  
  304.         //This layer should be transparent to bp inferring.  
  305.         if (strcmp(layers_[layer_id]->type(), "Gather")==0){  
  306.           blob_need_backward_[top_id_vecs_[layer_id][top_id]]  
  307.               = blob_need_backward_[bottom_id_vecs_[layer_id][top_id]];  
  308.         }  
  309.       }  
  310.     }  
  311.   }  
  312.   // Go through the net backwards to determine which blobs contribute to the  
  313.   // loss.  We can skip backward computation for blobs that don't contribute  
  314.   // to the loss.  
  315.   // Also checks if all bottom blobs don't need backward computation (possible  
  316.   // because the skip_propagate_down param) and so we can skip backward  
  317.   // computation for the entire layer  
  318. // 需要注意的是，上述代码中关于backward设置的部分，是按照前向的顺序设置的，而下面的代码是按后向顺序修正前向设置的结果。    
  319. // 一个layer是否需要backward computation，主要依据两个方面：(1)该layer的top blob 是否参与loss的计算；(2):该layer的bottom blob 是否需要backward computation，比如Data层一般就不需要backward computation    
  320.   set<string> blobs_under_loss;  
  321.   set<string> blobs_skip_backp;  
  322.   for (int layer_id = layers_.size() - 1; layer_id >= 0; --layer_id) {  
  323.     bool layer_contributes_loss = false;  
  324.     bool layer_skip_propagate_down = true;  
  325. //为true，则表示当前layer的bottom blob不需要backward computation，即该层不需要backward computation。    
  326. //这个局部变量所表示的意义与caffe.proto里message Layerparameter的propagate_down的定义恰好相反。    
  327.     for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) {  
  328.       //blob_names_整个网络中，所有非参数blob的name  
  329.       const string& blob_name = blob_names_[top_id_vecs_[layer_id][top_id]];  
  330.       if (layers_[layer_id]->loss(top_id) ||  
  331.           (blobs_under_loss.find(blob_name) != blobs_under_loss.end())) {  
  332.         layer_contributes_loss = true;  
  333.       }  
  334.       if (blobs_skip_backp.find(blob_name) == blobs_skip_backp.end()) {  
  335.         layer_skip_propagate_down = false;  
  336.       }  
  337.       if (layer_contributes_loss && !layer_skip_propagate_down)  
  338.         break;//只是跳出当前if语句   
  339.     }  
  340.     // If this layer can skip backward computation, also all his bottom blobs  
  341.     // don't need backpropagation  
  342.     if (layer_need_backward_[layer_id] && layer_skip_propagate_down) {  
  343.       layer_need_backward_[layer_id] = false;  
  344.       for (int bottom_id = 0; bottom_id < bottom_vecs_[layer_id].size();  
  345.                ++bottom_id) {  
  346. //bottom_need_backward_,整个网络所有网络层的bottom blob是否需要backward  
  347.         bottom_need_backward_[layer_id][bottom_id] = false;  
  348.       }  
  349.     }  
  350.     if (!layer_contributes_loss) { layer_need_backward_[layer_id] = false; }  
  351.     if (layer_need_backward_[layer_id]) {  
  352.       LOG(INFO) << layer_names_[layer_id] << " needs backward computation.";  
  353.     } else {  
  354.       LOG(INFO) << layer_names_[layer_id]  
  355.                 << " does not need backward computation.";  
  356.     }  
  357.     for (int bottom_id = 0; bottom_id < bottom_vecs_[layer_id].size();//修正前向设置的结果  
  358.          ++bottom_id) {  
  359.       if (layer_contributes_loss) {  
  360.         const string& blob_name =  
  361.             blob_names_[bottom_id_vecs_[layer_id][bottom_id]];  
  362.         blobs_under_loss.insert(blob_name);//为blobs_under_loss添加新元素  
  363.       } else {  
  364.         bottom_need_backward_[layer_id][bottom_id] = false;  
  365.       }  
  366.       if (!bottom_need_backward_[layer_id][bottom_id]) {  
  367.         const string& blob_name =  
  368.                    blob_names_[bottom_id_vecs_[layer_id][bottom_id]];  
  369.         blobs_skip_backp.insert(blob_name);//为blobs_skip_backp添加新元素  
  370.       }  
  371.     }  
  372.   }  
  373.   //Handle force_backward if needed.Netparameter类型的force_backward方法    
  374.   if (param.force_backward()) {  
  375.     for (int layer_id = 0; layer_id < layers_.size(); ++layer_id) {  
  376.       layer_need_backward_[layer_id] = true;  
  377.       for (int bottom_id = 0;  
  378.            bottom_id < bottom_need_backward_[layer_id].size(); ++bottom_id) {  
  379.         bottom_need_backward_[layer_id][bottom_id] =  
  380.             bottom_need_backward_[layer_id][bottom_id] ||  
  381.             layers_[layer_id]->AllowForceBackward(bottom_id);  
  382.         blob_need_backward_[bottom_id_vecs_[layer_id][bottom_id]] =  
  383.             blob_need_backward_[bottom_id_vecs_[layer_id][bottom_id]] ||  
  384.             bottom_need_backward_[layer_id][bottom_id];  
  385.       }  
  386.       for (int param_id = 0; param_id < layers_[layer_id]->blobs().size();  
  387.            ++param_id) {  
  388.         layers_[layer_id]->set_param_propagate_down(param_id, true);  
  389.       }  
  390.     }  
  391.   }  
  392.   // In the end, all remaining blobs are considered output blobs.  
  393.   for (set<string>::iterator it = available_blobs.begin();  
  394.       it != available_blobs.end(); ++it) {  
  395.     LOG(INFO) << "This network produces output " << *it;  
  396.     net_output_blobs_.push_back(blobs_[blob_name_to_idx[*it]].get());  
  397.     net_output_blob_indices_.push_back(blob_name_to_idx[*it]);  
  398.   }  
  399.   for (size_t blob_id = 0; blob_id < blob_names_.size(); ++blob_id) {  
  400.     blob_names_index_[blob_names_[blob_id]] = blob_id;  
  401. //第一次使用向量blob_names_index_,逐一添加元素，是一个map    
  402.   }  
  403.   for (size_t layer_id = 0; layer_id < layer_names_.size(); ++layer_id) {  
  404.     layer_names_index_[layer_names_[layer_id]] = layer_id;  
  405. //第一次使用向量layer_names_index_，逐一添加元素，是一个map    
  406.   }  
  407.   GetLearningRateAndWeightDecay();  
  408.   debug_info_ = param.debug_info();  
  409.   LOG(INFO) << "Network initialization done.";  
  410.   LOG(INFO) << "Memory required for data: " << memory_used_ * sizeof(Dtype);  
  411. }  
  412. //FilterNet()给定当前phase/level/stage，移除指定层   
  413. template <typename Dtype>  
  414. void Net<Dtype>::FilterNet(const NetParameter& param,  
  415.     NetParameter* param_filtered) {  
  416.   NetState net_state(param.state());  
  417.   param_filtered->CopyFrom(param);  
  418.   param_filtered->clear_layer();  
  419.   for (int i = 0; i < param.layer_size(); ++i) {  
  420.     const LayerParameter& layer_param = param.layer(i);  
  421.     const string& layer_name = layer_param.name();  
  422.     CHECK(layer_param.include_size() == 0 || layer_param.exclude_size() == 0)  
  423.           << "Specify either include rules or exclude rules; not both.";  
  424.     // If no include rules are specified, the layer is included by default and  
  425.     // only excluded if it meets one of the exclude rules.  
  426.     bool layer_included = (layer_param.include_size() == 0);  
  427.     for (int j = 0; layer_included && j < layer_param.exclude_size(); ++j) {  
  428.       if (StateMeetsRule(net_state, layer_param.exclude(j), layer_name)) {  
  429.         layer_included = false;//如果不包含include，只要meet一个include_size(idx)即可  
  430.       }  
  431.     }  
  432.     for (int j = 0; !layer_included && j < layer_param.include_size(); ++j) {  
  433.       if (StateMeetsRule(net_state, layer_param.include(j), layer_name)) {  
  434.         layer_included = true;//如果包含include，只要符合一个include_size(idx)即可  
  435.       }  
  436.     }  
  437.     if (layer_included) {  
  438.       param_filtered->add_layer()->CopyFrom(layer_param);  
  439.     }  
  440.   }  
  441. }  
  442. //StateMeetsRule()中net的state是否满足NetStaterule    
  443. template <typename Dtype>  
  444. bool Net<Dtype>::StateMeetsRule(const NetState& state,  
  445.     const NetStateRule& rule, const string& layer_name) {  
  446.   // Check whether the rule is broken due to phase.  
  447.   if (rule.has_phase()) {  
  448.       if (rule.phase() != state.phase()) {  
  449.         LOG(INFO) << "The NetState phase (" << state.phase()  
  450.           << ") differed from the phase (" << rule.phase()  
  451.           << ") specified by a rule in layer " << layer_name;  
  452.         return false;  
  453.       }  
  454.   }  
  455.   // Check whether the rule is broken due to min level.  
  456.   if (rule.has_min_level()) {  
  457.     if (state.level() < rule.min_level()) {  
  458.       LOG(INFO) << "The NetState level (" << state.level()  
  459.           << ") is above the min_level (" << rule.min_level()  
  460.           << ") specified by a rule in layer " << layer_name;  
  461.       return false;  
  462.     }  
  463.   }  
  464.   // Check whether the rule is broken due to max level.  
  465.   if (rule.has_max_level()) {  
  466.     if (state.level() > rule.max_level()) {  
  467.       LOG(INFO) << "The NetState level (" << state.level()  
  468.           << ") is above the max_level (" << rule.max_level()  
  469.           << ") specified by a rule in layer " << layer_name;  
  470.       return false;  
  471.     }  
  472.   }  
  473.   // Check whether the rule is broken due to stage. The NetState must  
  474.   // contain ALL of the rule's stages to meet it.  
  475.   for (int i = 0; i < rule.stage_size(); ++i) {  
  476.     // Check that the NetState contains the rule's ith stage.  
  477.     bool has_stage = false;  
  478.     for (int j = 0; !has_stage && j < state.stage_size(); ++j) {  
  479.       if (rule.stage(i) == state.stage(j)) { has_stage = true; }  
  480.     }  
  481.     if (!has_stage) {  
  482.       LOG(INFO) << "The NetState did not contain stage '" << rule.stage(i)  
  483.                 << "' specified by a rule in layer " << layer_name;  
  484.       return false;  
  485.     }  
  486.   }  
  487.   // Check whether the rule is broken due to not_stage. The NetState must  
  488.   // contain NONE of the rule's not_stages to meet it.  
  489.   for (int i = 0; i < rule.not_stage_size(); ++i) {  
  490.     // Check that the NetState contains the rule's ith not_stage.  
  491.     bool has_stage = false;  
  492.     for (int j = 0; !has_stage && j < state.stage_size(); ++j) {  
  493.       if (rule.not_stage(i) == state.stage(j)) { has_stage = true; }  
  494.     }  
  495.     if (has_stage) {  
  496.       LOG(INFO) << "The NetState contained a not_stage '" << rule.not_stage(i)  
  497.                 << "' specified by a rule in layer " << layer_name;  
  498.       return false;  
  499.     }  
  500.   }  
  501.   return true;  
  502. }  
  503.   
  504. // Helper for Net::Init: add a new input or top blob to the net.  (Inputs have  
  505. // layer_id == -1, tops have layer_id >= 0.)  
  506. template <typename Dtype>  
  507. void Net<Dtype>::AppendTop(const NetParameter& param, const int layer_id,  
  508.                            const int top_id, set<string>* available_blobs,  
  509.                            map<string, int>* blob_name_to_idx) {  
  510.   shared_ptr<LayerParameter> layer_param((layer_id >= 0) ?  
  511.     (new LayerParameter(param.layer(layer_id))) : NULL);  
  512.   const string& blob_name = layer_param ?  
  513.       (layer_param->top_size() > top_id ?  
  514.           layer_param->top(top_id) : "(automatic)") : param.input(top_id);  
  515.   // Check if we are doing in-place computation  
  516.   if (blob_name_to_idx && layer_param && layer_param->bottom_size() > top_id &&  
  517.       blob_name == layer_param->bottom(top_id)) {  
  518.     // In-place computation  
  519.     LOG(INFO) << layer_param->name() << " -> " << blob_name << " (in-place)";  
  520.     top_vecs_[layer_id].push_back(blobs_[(*blob_name_to_idx)[blob_name]].get());  
  521.     top_id_vecs_[layer_id].push_back((*blob_name_to_idx)[blob_name]);  
  522.   } else if (blob_name_to_idx &&  
  523.              blob_name_to_idx->find(blob_name) != blob_name_to_idx->end()) {  
  524.     // If we are not doing in-place computation but have duplicated blobs,  
  525.     // raise an error.  
  526.     LOG(FATAL) << "Duplicate blobs produced by multiple sources.";  
  527.   } else {  
  528.     // Normal output.  
  529.     if (layer_param) {  
  530.       LOG(INFO) << layer_param->name() << " -> " << blob_name;  
  531.     } else {  
  532.       LOG(INFO) << "Input " << top_id << " -> " << blob_name;  
  533.     }  
  534.     shared_ptr<Blob<Dtype> > blob_pointer(new Blob<Dtype>());  
  535. //blobs只是存储中间结果；每次遍历到一个top blob都会更新blob_id    
  536.     const int blob_id = blobs_.size();  
  537.     blobs_.push_back(blob_pointer);  
  538.     blob_names_.push_back(blob_name);  
  539.     blob_need_backward_.push_back(false);  
  540.     top_layer_indices_.push_back(make_pair(layer_id, blob_id));  
  541. /* 
  542. blob_name_to_idx是一个局部变量，其实它是在当前layer的top blob 和下一层的bottom blob间起着一个桥梁作用。   
  543. blob_name_to_idx中元素的pair是从网络最开始一层一层搭建的过程中压入map的，其中的name和id都是不重复的。name是关键字——不重复是map数据结构的必然要求，id也是不重复的——0,1,2...   
  544. blob_name_to_idx和blobs_一样，在"Normal output"的情形下，每次遍历到一个top blob的时候都会更新   
  545. */  
  546. //添加新元素-->map可以通过下标访问符为（关联）容器添加新元素   
  547.     if (blob_name_to_idx) { (*blob_name_to_idx)[blob_name] = blob_id; }  
  548.     if (layer_id == -1) {  
  549.       // Set the (explicitly specified) dimensions of the input blob.  
  550.       if (param.input_dim_size() > 0) {  
  551.         blob_pointer->Reshape(param.input_dim(top_id * 4),  
  552.                               param.input_dim(top_id * 4 + 1),  
  553.                               param.input_dim(top_id * 4 + 2),  
  554.                               param.input_dim(top_id * 4 + 3));  
  555.       } else {  
  556.         blob_pointer->Reshape(param.input_shape(top_id));  
  557.       }  
  558.       net_input_blob_indices_.push_back(blob_id);  
  559. //当layer_id==-1时，即当前层为输入层的时候，会向net_input_blob_indices_里添加新元素,即add new input blob   
  560.       net_input_blobs_.push_back(blob_pointer.get());  
  561.     } else {  
  562.       top_id_vecs_[layer_id].push_back(blob_id);  
  563. //当layer_id ！=-1时，即当前层不是输入层的时候，会向net_input_blob_indices_里添加新元素,即add new top blob   
  564.       top_vecs_[layer_id].push_back(blob_pointer.get());  
  565.     }  
  566.   
  567.   }  
  568.   if (available_blobs) { available_blobs->insert(blob_name); }  
  569. }  
  570.   
  571. // Helper for Net::Init: add a new bottom blob to the net.  
  572. template <typename Dtype>  
  573. int Net<Dtype>::AppendBottom(const NetParameter& param, const int layer_id,  
  574.     const int bottom_id, set<string>* available_blobs,  
  575.     map<string, int>* blob_name_to_idx) {  
  576.   const LayerParameter& layer_param = param.layer(layer_id);  
  577.   const string& blob_name = layer_param.bottom(bottom_id);  
  578.   if (available_blobs->find(blob_name) == available_blobs->end()) {  
  579.     LOG(FATAL) << "Unknown blob input " << blob_name  
  580.                << " (at index " << bottom_id << ") to layer " << layer_id;  
  581.   }  
  582. //blob_name_to_idx是一个map,其关键字是不重复的。blob_name_to_idx在输入层初始化  
  583. //过了-->*blob_name_to_idx)[blob_name] = blob_id  
  584.   const int blob_id = (*blob_name_to_idx)[blob_name];  
  585.   LOG(INFO) << layer_names_[layer_id] << " <- " << blob_name;  
  586. //存储整个网络所有网络层的bottom blob指针,实际上存储的是前一层的top，因为网络是一层一层堆起来的  
  587.   bottom_vecs_[layer_id].push_back(blobs_[blob_id].get());//调用shared_ptr类的get()方法提取存储在blobs_中的中间变量  
  588.   bottom_id_vecs_[layer_id].push_back(blob_id);  
  589.   available_blobs->erase(blob_name);  
  590.   bool propagate_down = true;  
  591.   // Check if the backpropagation on bottom_id should be skipped  
  592.   if (layer_param.propagate_down_size() > 0)  
  593.     propagate_down = layer_param.propagate_down(bottom_id);  
  594.   const bool need_backward = blob_need_backward_[blob_id] &&  
  595.                           propagate_down;//propagate_down为true,则表示参与BP;否则，skip bp  
  596.   bottom_need_backward_[layer_id].push_back(need_backward);  
  597.   return blob_id;  
  598. }  
  599.   
  600. template <typename Dtype>  
  601. void Net<Dtype>::AppendParam(const NetParameter& param, const int layer_id,  
  602.                              const int param_id) {  
  603. //模板类Layer的layer_param方法，返回Layerparameter类型成员  
  604.   const LayerParameter& layer_param = layers_[layer_id]->layer_param();  
  605.   const int param_size = layer_param.param_size();  
  606.   string param_name =  
  607.       (param_size > param_id) ? layer_param.param(param_id).name() : "";  
  608.   if (param_name.size()) {  
  609. //vector<string> param_display_names_ 这里param_name获取的是PaParamSpec类型中的name成员，如果有name且非空,就把name压入该向量，否则就压入param_id    
  610.     param_display_names_.push_back(param_name);  
  611.   } else {  
  612.     ostringstream param_display_name;  
  613.     param_display_name << param_id;  
  614.     param_display_names_.push_back(param_display_name.str());  
  615.   }  
  616. //params_,整个网络的参数blob。 不管这个参数有没有non-emty name，是否参与share!!!    
  617.   const int net_param_id = params_.size(); //Append 参数blob 每一次循环，net_param_id和param_id_vecs_都会更新    
  618.   params_.push_back(layers_[layer_id]->blobs()[param_id]);  
  619. //param_id_vecs_,存储的基本元素是net_param_id，每遍历一个参数blob,net_param_id和param_id_vecs_都会更新  
  620.   param_id_vecs_[layer_id].push_back(net_param_id);  
  621. //param_layer_indices_其元素为当layer_id 与当前param_id 组成的pair.vector<pair<int, int> > param_layer_indices_  
  622.   param_layer_indices_.push_back(make_pair(layer_id, param_id));  
  623.   if (!param_size || !param_name.size() || (param_name.size() &&  
  624.       param_names_index_.find(param_name) == param_names_index_.end())) {  
  625.     // This layer "owns" this parameter blob -- it is either anonymous  
  626.     // (i.e., not given a param_name) or explicitly given a name that we  
  627.     // haven't already seen.  
  628. /*param_owners_ 是一个存储parameter "onwer"的一个向量  ——> -1 表示当前Layer就是该parameter的"owner" , 
  629. 如果param_name不为空，而且能够在param_names_index_中找到，说明这个parameter已经存在于之前的某个或者某 
  630. 些网络层里，说明这个parameter是共享于多个layer。 在caffe.proto的message ParamSpec里关于name的 
  631. 注释——>To share a parameter between two layers, give it a (non-empty) name, 可见，如果一个parameter是 
  632. 共享与多个网络层，那么它会有一个非空的name。 
  633. */  
  634.     param_owners_.push_back(-1);  
  635. //添加param_name   
  636.     if (param_name.size()) {  
  637. /* 
  638. map<string, int> param_names_index_是整个网络的参数non-empty name与index的映射。  注意，这个name是ParamSpec 类 
  639. 型中的name,而且，""To share a parameter between two layers, give it a (non-empty) name"",所以说这个map中存 
  640. 储的pair是<会被share的parameter_name, 其对应index>  
  641. */  
  642.       param_names_index_[param_name] = net_param_id;  
  643. /* 
  644. map<string, int> param_names_index_ 。虽然每一次循环，net_param_id都会更新，但 
  645. 是net_param_id只有当param_name.size()>0时才会被压入向量param_names_index_  
  646. */  
  647.     }  
  648.   } else {  
  649.     // Named param blob with name we've seen before: share params  
  650. //因为"To share a parameter between two layers, give it a (non-empty) name",所以这句代码就是获取shared parameter的"owner" net_param_id    
  651.     const int owner_net_param_id = param_names_index_[param_name];  
  652.     param_owners_.push_back(owner_net_param_id);  
  653. /只获取了那些shared的parameter,即具有non-empty name的parameter的pair<layer_id, param_id>    
  654.     const pair<int, int>& owner_index =  
  655.         param_layer_indices_[owner_net_param_id];  
  656.     const int owner_layer_id = owner_index.first;  
  657.     const int owner_param_id = owner_index.second;  
  658.     LOG(INFO) << "Sharing parameters '" << param_name << "' owned by "  
  659.               << "layer '" << layer_names_[owner_layer_id] << "', param "  
  660.               << "index " << owner_param_id;  
  661. //获取当前层的当前参数Blob    
  662.     Blob<Dtype>* this_blob = layers_[layer_id]->blobs()[param_id].get();  
  663. //获取owner layer的对应的参数blob  
  664.     Blob<Dtype>* owner_blob =  
  665.         layers_[owner_layer_id]->blobs()[owner_param_id].get();  
  666.     const int param_size = layer_param.param_size();  
  667.     if (param_size > param_id && (layer_param.param(param_id).share_mode() ==  
  668.                                   ParamSpec_DimCheckMode_PERMISSIVE)) {  
  669.       // Permissive dimension checking -- only check counts are the same.  
  670.       CHECK_EQ(this_blob->count(), owner_blob->count())  
  671.           << "Shared parameter blobs must have the same count.";  
  672.     } else {  
  673.       // Strict dimension checking -- all dims must be the same.  
  674.       CHECK(this_blob->shape() == owner_blob->shape());  
  675.     }  
  676.     layers_[layer_id]->blobs()[param_id]->ShareData(  
  677.         *layers_[owner_layer_id]->blobs()[owner_param_id]);  
  678.   }  
  679. }  
  680. /* 
  681. 功能：收集学习速率和权重衰减，即更新params_、params_lr_和params_weight_decay_ 
  682. 输入：无 
  683. 输出：无 
  684. 步骤：对每一层 
  685. 1. 把当前层的所有blob存入params_中 
  686. params_// The parameters in the network 
  687. 2. 如果有lr, 则把当前层的所有blob的lr存入params_lr_中; 否则, lr默认为1 
  688. 3. 如果有 weight_decay，则把当前层的所有 blob 的 weight_decay存入 params_weight_decay_ 中 
  689. 4. 否则，weight_decay 默认为1 
  690. */  
  691. template <typename Dtype>  
  692. void Net<Dtype>::GetLearningRateAndWeightDecay() {  
  693.   LOG(INFO) << "Collecting Learning Rate and Weight Decay.";  
  694.   ParamSpec default_param_spec;  
  695.   for (int i = 0; i < layers_.size(); ++i) {  
  696.     vector<shared_ptr<Blob<Dtype> > >& layer_blobs = layers_[i]->blobs();  
  697.     for (int j = 0; j < layer_blobs.size(); ++j) {  
  698.       const ParamSpec* param_spec =  
  699.           (layers_[i]->layer_param().param_size() > j) ?  
  700.           &layers_[i]->layer_param().param(j) : &default_param_spec;  
  701.       params_lr_.push_back(param_spec->lr_mult());  
  702.       params_weight_decay_.push_back(param_spec->decay_mult());  
  703.     }  
  704.   }  
  705. }  
  706.   
  707. template <typename Dtype>  
  708. Dtype Net<Dtype>::ForwardFromTo(int start, int end) {  
  709.   CHECK_GE(start, 0);  
  710.   CHECK_LT(end, layers_.size());  
  711.   Dtype loss = 0;  
  712.   if (debug_info_) {  
  713.     for (int i = 0; i < net_input_blobs_.size(); ++i) {  
  714.       InputDebugInfo(i);  
  715.     }  
  716.   }  
  717.   for (int i = start; i <= end; ++i) {  
  718.     // LOG(ERROR) << "Forwarding " << layer_names_[i];  
  719.     Dtype layer_loss = layers_[i]->Forward(bottom_vecs_[i], top_vecs_[i]);  
  720.     loss += layer_loss;  
  721.     if (debug_info_) { ForwardDebugInfo(i); }  
  722.   }  
  723.   
  724. #ifdef USE_CUDNN  
  725.   if (Caffe::mode() == Caffe::GPU)  
  726.     CuDNNConvolutionLayer<Dtype>::RuntimeOptimize(1000);  
  727. #endif  
  728.   return loss;  
  729. }  
  730.   
  731. template <typename Dtype>  
  732. Dtype Net<Dtype>::ForwardFrom(int start) {  
  733.   return ForwardFromTo(start, layers_.size() - 1);  
  734. }  
  735.   
  736. template <typename Dtype>  
  737. Dtype Net<Dtype>::ForwardTo(int end) {  
  738.   return ForwardFromTo(0, end);  
  739. }  
  740. /* 
  741. 功能：前馈预先填满，即预先进行一次前馈 
  742. 输入：Dtype* loss 
  743. 输出：net_output_blobs_，前馈后的输出层blob：vector 
  744. */  
  745. template <typename Dtype>  
  746. const vector<Blob<Dtype>*>& Net<Dtype>::ForwardPrefilled(Dtype* loss) {  
  747.   if (loss != NULL) {  
  748.     *loss = ForwardFromTo(0, layers_.size() - 1);  
  749.   } else {  
  750.     ForwardFromTo(0, layers_.size() - 1);  
  751.   }  
  752.   return net_output_blobs_;  
  753. }  
  754. /* 
  755. 功能：把网络输入层的blob读到net_input_blobs_，然后进行前馈，计算出loss 
  756. 输入：整个网络输入层的blob 
  757. 输出：整个网络输出层的blob 
  758. */  
  759. template <typename Dtype>  
  760. const vector<Blob<Dtype>*>& Net<Dtype>::Forward(  
  761.     const vector<Blob<Dtype>*> & bottom, Dtype* loss) {  
  762.   // Copy bottom to internal bottom  
  763.   for (int i = 0; i < bottom.size(); ++i) {  
  764.     net_input_blobs_[i]->CopyFrom(*bottom[i]);  
  765.   }  
  766.   return ForwardPrefilled(loss);  
  767. }  
  768. /* 
  769. 功能：Forward的重载，只是输入层的blob以string的格式传入 
  770. */  
  771. template <typename Dtype>  
  772. string Net<Dtype>::Forward(const string& input_blob_protos, Dtype* loss) {  
  773.   BlobProtoVector blob_proto_vec;  
  774.   if (net_input_blobs_.size()) {  
  775.     blob_proto_vec.ParseFromString(input_blob_protos);  
  776.     CHECK_EQ(blob_proto_vec.blobs_size(), net_input_blobs_.size())  
  777.         << "Incorrect input size.";  
  778.     for (int i = 0; i < blob_proto_vec.blobs_size(); ++i) {  
  779.       net_input_blobs_[i]->FromProto(blob_proto_vec.blobs(i));  
  780.     }  
  781.   }  
  782.   ForwardPrefilled(loss);  
  783.   blob_proto_vec.Clear();  
  784.   for (int i = 0; i < net_output_blobs_.size(); ++i) {  
  785.     net_output_blobs_[i]->ToProto(blob_proto_vec.add_blobs());  
  786.   }  
  787.   string output;  
  788.   blob_proto_vec.SerializeToString(&output);  
  789.   return output;  
  790. }  
  791.   
  792. template <typename Dtype>  
  793. void Net<Dtype>::BackwardFromTo(int start, int end) {  
  794.   CHECK_GE(end, 0);  
  795.   CHECK_LT(start, layers_.size());  
  796.   
  797.   for (int i = start; i >= end; --i) {  
  798.     if (layer_need_backward_[i]) {  
  799.       layers_[i]->Backward(  
  800.           top_vecs_[i], bottom_need_backward_[i], bottom_vecs_[i]);  
  801.       if (debug_info_) { BackwardDebugInfo(i); }  
  802.   
  803. #ifdef USE_MPI  
  804.       if ((Caffe::parallel_mode() == Caffe::MPI) && (Caffe::remaining_sub_iter() == 0)) {  
  805.         for (int n = 0; n < param_layer_indices_.size(); ++n) {  
  806.           bool ready_for_sync = false;  
  807.   
  808.           //decide whether we need to sync the gradient of this blob  
  809.           if ((param_layer_indices_[n].first == i)) {  
  810.             if (param_owners_[n] == -1) {  
  811.               ready_for_sync = true;  
  812.             } else {  
  813.               // this blob is a shared one, we need to make sure no more gradients will be  
  814.               // accumulated to it before transmission  
  815.               int owner_id = param_owners_[n];  
  816.               ready_for_sync = true;  
  817.               for (int m = n - 1; m >= 0; --m) {  
  818.                 if ((param_owners_[m] == owner_id) && (param_layer_indices_[m].first >= end)) {  
  819.                   // there are still layers holding this shared blob,  
  820.                   // not secure the do the transmission  
  821.                   ready_for_sync = false;  
  822.                   break;  
  823.                 }  
  824.               }  
  825.             }  
  826.           }  
  827.           //sync gradient  
  828.           if (ready_for_sync && layers_[i]->need_sync())  
  829.             caffe_iallreduce(  
  830.                 this->params_[n]->mutable_cpu_diff(),  
  831.                 this->params_[n]->count()  
  832.             );  
  833.         }  
  834.       }  
  835. #endif //USE_MPI  
  836.   
  837.     }  
  838.   }  
  839. }  
  840.   
  841. template <typename Dtype>  
  842. void Net<Dtype>::InputDebugInfo(const int input_id) {  
  843.   const Blob<Dtype>& blob = *net_input_blobs_[input_id];  
  844.   const string& blob_name = blob_names_[net_input_blob_indices_[input_id]];  
  845.   const Dtype data_abs_val_mean = blob.asum_data() / blob.count();  
  846.   LOG(INFO) << "    [Forward] "  
  847.      << "Input " << blob_name << " data: " << data_abs_val_mean;  
  848. }  
  849.   
  850. template <typename Dtype>  
  851. void Net<Dtype>::ForwardDebugInfo(const int layer_id) {  
  852.   for (int top_id = 0; top_id < top_vecs_[layer_id].size(); ++top_id) {  
  853.     const Blob<Dtype>& blob = *top_vecs_[layer_id][top_id];  
  854.     const string& blob_name = blob_names_[top_id_vecs_[layer_id][top_id]];  
  855.     const Dtype data_abs_val_mean = blob.asum_data() / blob.count();  
  856.     LOG(INFO) << "    [Forward] "  
  857.        << "Layer " << layer_names_[layer_id] << ", top blob " << blob_name  
  858.        << " data: " << data_abs_val_mean;  
  859.   }  
  860.   for (int param_id = 0; param_id < layers_[layer_id]->blobs().size();  
  861.        ++param_id) {  
  862.     const Blob<Dtype>& blob = *layers_[layer_id]->blobs()[param_id];  
  863.     const int net_param_id = param_id_vecs_[layer_id][param_id];  
  864.     const string& blob_name = param_display_names_[net_param_id];  
  865.     const Dtype data_abs_val_mean = blob.asum_data() / blob.count();  
  866.     LOG(INFO) << "    [Forward] "  
  867.        << "Layer " << layer_names_[layer_id] << ", param blob " << blob_name  
  868.        << " data: " << data_abs_val_mean;  
  869.   }  
  870. }  
  871.   
  872. template <typename Dtype>  
  873. void Net<Dtype>::BackwardDebugInfo(const int layer_id) {  
  874.   const vector<Blob<Dtype>*>& bottom_vec = bottom_vecs_[layer_id];  
  875.   for (int bottom_id = 0; bottom_id < bottom_vec.size(); ++bottom_id) {  
  876.     if (!bottom_need_backward_[layer_id][bottom_id]) { continue; }  
  877.     const Blob<Dtype>& blob = *bottom_vec[bottom_id];  
  878.     const string& blob_name = blob_names_[bottom_id_vecs_[layer_id][bottom_id]];  
  879.     const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count();  
  880.     LOG(INFO) << "    [Backward] "  
  881.         << "Layer " << layer_names_[layer_id] << ", bottom blob " << blob_name  
  882.         << " diff: " << diff_abs_val_mean;  
  883.   }  
  884.   for (int param_id = 0; param_id < layers_[layer_id]->blobs().size();  
  885.        ++param_id) {  
  886.     if (!layers_[layer_id]->param_propagate_down(param_id)) { continue; }  
  887.     const Blob<Dtype>& blob = *layers_[layer_id]->blobs()[param_id];  
  888.     const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count();  
  889.     LOG(INFO) << "    [Backward] "  
  890.         << "Layer " << layer_names_[layer_id] << ", param blob " << param_id  
  891.         << " diff: " << diff_abs_val_mean;  
  892.   }  
  893. }  
  894.   
  895. template <typename Dtype>  
  896. void Net<Dtype>::UpdateDebugInfo(const int param_id) {  
  897.   const Blob<Dtype>& blob = *params_[param_id];  
  898.   const int param_owner = param_owners_[param_id];  
  899.   const string& layer_name = layer_names_[param_layer_indices_[param_id].first];  
  900.   const string& param_display_name = param_display_names_[param_id];  
  901.   const Dtype diff_abs_val_mean = blob.asum_diff() / blob.count();  
  902.   if (param_owner < 0) {  
  903.     const Dtype data_abs_val_mean = blob.asum_data() / blob.count();  
  904.     LOG(INFO) << "    [Update] Layer " << layer_name  
  905.         << ", param " << param_display_name  
  906.         << " data: " << data_abs_val_mean << "; diff: " << diff_abs_val_mean;  
  907.   } else {  
  908.     const string& owner_layer_name =  
  909.         layer_names_[param_layer_indices_[param_owner].first];  
  910.     LOG(INFO) << "    [Update] Layer " << layer_name  
  911.         << ", param blob " << param_display_name  
  912.         << " (owned by layer " << owner_layer_name << ", "  
  913.         << "param " << param_display_names_[param_owners_[param_id]] << ")"  
  914.         << " diff: " << diff_abs_val_mean;  
  915.   }  
  916. }  
  917. /* 
  918. 功能：从Other网络复制某些层 
  919. 步骤：对Other网络的第i层（源层）： 
  920. 1. 定义一个Layer的指针指向第i层 
  921. 2. 读取第i层（源层）的名字 
  922. 3. 找通过名字来找目标层如果没找到，即target_layer_id == layer_names_.size()则忽略Other的第i层，即Other的第i层不需要share给网络 
  923. 4. 如果找到了，即other的第i层需要share给网络，则把目标层的所有blob读到target_blobs中 
  924.     1判断目标层和源层的blob数量是否相等 
  925.     2判断每个blob大小是否相等 
  926.     3调用ShareData函数把源层的blob赋给目标层的blob 
  927.  
  928. */  
  929. template <typename Dtype>  
  930. void Net<Dtype>::ShareTrainedLayersWith(const Net* other) {  
  931.   int num_source_layers = other->layers().size();  
  932.   for (int i = 0; i < num_source_layers; ++i) {  
  933.     Layer<Dtype>* source_layer = other->layers()[i].get();  
  934.     const string& source_layer_name = other->layer_names()[i];  
  935.     int target_layer_id = 0;  
  936.     while (target_layer_id != layer_names_.size() &&  
  937.         layer_names_[target_layer_id] != source_layer_name) {  
  938.       ++target_layer_id;  
  939.     }  
  940.     if (target_layer_id == layer_names_.size()) {  
  941.       DLOG(INFO) << "Ignoring source layer " << source_layer_name;  
  942.       continue;  
  943.     }  
  944.     DLOG(INFO) << "Copying source layer " << source_layer_name;  
  945.     vector<shared_ptr<Blob<Dtype> > >& target_blobs =  
  946.         layers_[target_layer_id]->blobs();  
  947.     CHECK_EQ(target_blobs.size(), source_layer->blobs().size())  
  948.         << "Incompatible number of blobs for layer " << source_layer_name;  
  949.     for (int j = 0; j < target_blobs.size(); ++j) {  
  950.       Blob<Dtype>* source_blob = source_layer->blobs()[j].get();  
  951.       CHECK(target_blobs[j]->shape() == source_blob->shape());  
  952.       target_blobs[j]->ShareData(*source_blob);  
  953.     }  
  954.   }  
  955. }  
  956.   
  957. template <typename Dtype>  
  958. void Net<Dtype>::BackwardFrom(int start) {  
  959.   BackwardFromTo(start, 0);  
  960. }  
  961.   
  962. template <typename Dtype>  
  963. void Net<Dtype>::BackwardTo(int end) {  
  964.   BackwardFromTo(layers_.size() - 1, end);  
  965. }  
  966. /* 
  967. 功能：对整个网络进行反向传播 
  968. */  
  969. template <typename Dtype>  
  970. void Net<Dtype>::Backward() {  
  971.   BackwardFromTo(layers_.size() - 1, 0);  
  972.   if (debug_info_) {  
  973.     Dtype asum_data = 0, asum_diff = 0, sumsq_data = 0, sumsq_diff = 0;  
  974.     for (int i = 0; i < params_.size(); ++i) {  
  975.       if (param_owners_[i] >= 0) { continue; }  
  976.       asum_data += params_[i]->asum_data();  
  977.       asum_diff += params_[i]->asum_diff();  
  978.       sumsq_data += params_[i]->sumsq_data();  
  979.       sumsq_diff += params_[i]->sumsq_diff();  
  980.     }  
  981.     const Dtype l2norm_data = std::sqrt(sumsq_data);  
  982.     const Dtype l2norm_diff = std::sqrt(sumsq_diff);  
  983.     LOG(ERROR) << "    [Backward] All net params (data, diff): "  
  984.         << "L1 norm = (" << asum_data << ", " << asum_diff << "); "  
  985.         << "L2 norm = (" << l2norm_data << ", " << l2norm_diff << ")";  
  986.   }  
  987. }  
  988.   
  989. template <typename Dtype>  
  990. void Net<Dtype>::Reshape() {  
  991.   for (int i = 0; i < layers_.size(); ++i) {  
  992.     layers_[i]->Reshape(bottom_vecs_[i], top_vecs_[i]);  
  993.   }  
  994.   
  995. #ifdef USE_CUDNN  
  996.   if (Caffe::mode() == Caffe::GPU)  
  997.     CuDNNConvolutionLayer<Dtype>::RuntimeOptimize(1000);  
  998. #endif  
  999. }  
  1000. /* 
  1001. 功能：和ShareTrainedLayersWith一样 
  1002. 步骤：不同的是调用FromProto函数把源层的blob赋给目标层的blob 
  1003. */  
  1004. template <typename Dtype>  
  1005. void Net<Dtype>::CopyTrainedLayersFrom(const NetParameter& param) {  
  1006.   int num_source_layers = param.layer_size();  
  1007.   for (int i = 0; i < num_source_layers; ++i) {  
  1008.     const LayerParameter& source_layer = param.layer(i);  
  1009.     const string& source_layer_name = source_layer.name();  
  1010.     int target_layer_id = 0;  
  1011.     while (target_layer_id != layer_names_.size() &&  
  1012.         layer_names_[target_layer_id] != source_layer_name) {  
  1013.       ++target_layer_id;  
  1014.     }  
  1015.     if (target_layer_id == layer_names_.size()) {  
  1016.       DLOG(INFO) << "Ignoring source layer " << source_layer_name;  
  1017.       continue;  
  1018.     }  
  1019.     DLOG(INFO) << "Copying source layer " << source_layer_name;  
  1020.     vector<shared_ptr<Blob<Dtype> > >& target_blobs =  
  1021.         layers_[target_layer_id]->blobs();  
  1022.     CHECK_EQ(target_blobs.size(), source_layer.blobs_size())  
  1023.         << "Incompatible number of blobs for layer " << source_layer_name;  
  1024.     for (int j = 0; j < target_blobs.size(); ++j) {  
  1025.       const bool kReshape = false;  
  1026.       target_blobs[j]->FromProto(source_layer.blobs(j), kReshape);  
  1027.     }  
  1028.   }  
  1029. }  
  1030. /* 
  1031. 功能：从文件中读入NetParameter param，然后调用CopyTrainedLayersFrom() 
  1032. */  
  1033. template <typename Dtype>  
  1034. void Net<Dtype>::CopyTrainedLayersFrom(const string trained_filename) {  
  1035.   NetParameter param;  
  1036.   ReadNetParamsFromBinaryFileOrDie(trained_filename, ¶m);  
  1037.   CopyTrainedLayersFrom(param);  
  1038. }  
  1039. /* 
  1040. 功能：把网络的参数存入prototxt中 
  1041. 步骤： 
  1042. 1. 设置网络的名字：param->set_name(name_) 
  1043. 2. 加入输入层blob的名字 
  1044. 3. 对于第i层： 
  1045.     1加入bottom的blob的名字 
  1046.     2加入top的blob的名字 
  1047.     3写到proto中 
  1048.  
  1049. */  
  1050. template <typename Dtype>  
  1051. void Net<Dtype>::ToProto(NetParameter* param, bool write_diff) const {  
  1052.   param->Clear();  
  1053.   param->set_name(name_);  
  1054.   // Add bottom and top  
  1055.   for (int i = 0; i < net_input_blob_indices_.size(); ++i) {  
  1056.     param->add_input(blob_names_[net_input_blob_indices_[i]]);  
  1057.   }  
  1058.   DLOG(INFO) << "Serializing " << layers_.size() << " layers";  
  1059.   for (int i = 0; i < layers_.size(); ++i) {  
  1060.     LayerParameter* layer_param = param->add_layer();  
  1061. //bottom_id_vecs_存储整个网络所有网络层的bottom blob的ID  
  1062.     for (int j = 0; j < bottom_id_vecs_[i].size(); ++j) {  
  1063.       layer_param->add_bottom(blob_names_[bottom_id_vecs_[i][j]]);  
  1064.     }  
  1065.     for (int j = 0; j < top_id_vecs_[i].size(); ++j) {  
  1066.       layer_param->add_top(blob_names_[top_id_vecs_[i][j]]);  
  1067.     }  
  1068.     layers_[i]->ToProto(layer_param, write_diff);  
  1069.   }  
  1070. }  
  1071. /* 
  1072. 功能：更新params_中blob的值 
  1073. */  
  1074. template <typename Dtype>  
  1075. void Net<Dtype>::Update() {  
  1076.   // First, accumulate the diffs of any shared parameters into their owner's  
  1077.   // diff. (Assumes that the learning rate, weight decay, etc. have already been  
  1078.   // accounted for in the current diff.)  
  1079.   for (int i = 0; i < params_.size(); ++i) {  
  1080.     if (param_owners_[i] < 0) { continue; }  
  1081.     if (debug_info_) { UpdateDebugInfo(i); }  
  1082.     const int count = params_[i]->count();  
  1083.     const Dtype* this_diff;  
  1084.     Dtype* owner_diff;  
  1085.     switch (Caffe::mode()) {  
  1086.     case Caffe::CPU:  
  1087.       this_diff = params_[i]->cpu_diff();  
  1088.       owner_diff = params_[param_owners_[i]]->mutable_cpu_diff();  
  1089.       caffe_add(count, this_diff, owner_diff, owner_diff);  
  1090.       break;  
  1091.     case Caffe::GPU:  
  1092. #ifndef CPU_ONLY  
  1093.       this_diff = params_[i]->gpu_diff();  
  1094.       owner_diff = params_[param_owners_[i]]->mutable_gpu_diff();  
  1095.       caffe_gpu_add(count, this_diff, owner_diff, owner_diff);  
  1096. #else  
  1097.       NO_GPU;  
  1098. #endif  
  1099.       break;  
  1100.     default:  
  1101.       LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode();  
  1102.     }  
  1103.   }  
  1104.   // Now, update the owned parameters.  
  1105.   for (int i = 0; i < params_.size(); ++i) {  
  1106.     if (param_owners_[i] >= 0) { continue; }  
  1107.     if (debug_info_) { UpdateDebugInfo(i); }  
  1108.     params_[i]->Update();  
  1109.   }  
  1110. }  
  1111. /* 
  1112. 功能：判断是否存在名字为blob_name的blob 
  1113. */  
  1114. template <typename Dtype>  
  1115. bool Net<Dtype>::has_blob(const string& blob_name) const {  
  1116.   return blob_names_index_.find(blob_name) != blob_names_index_.end();  
  1117. }  
  1118. /* 
  1119. 功能：给一个blob的名字，返回这个blob的指针 
  1120. */  
  1121. template <typename Dtype>  
  1122. const shared_ptr<Blob<Dtype> > Net<Dtype>::blob_by_name(  
  1123.     const string& blob_name) const {  
  1124.   shared_ptr<Blob<Dtype> > blob_ptr;  
  1125.   if (has_blob(blob_name)) {  
  1126.     blob_ptr = blobs_[blob_names_index_.find(blob_name)->second];  
  1127.   } else {  
  1128.     blob_ptr.reset((Blob<Dtype>*)(NULL));  
  1129.     LOG(WARNING) << "Unknown blob name " << blob_name;  
  1130.   }  
  1131.   return blob_ptr;  
  1132. }  
  1133. /* 
  1134. 功能：判断是否存在名字为layer_name的layer 
  1135. */  
  1136. template <typename Dtype>  
  1137. bool Net<Dtype>::has_layer(const string& layer_name) const {  
  1138.   return layer_names_index_.find(layer_name) != layer_names_index_.end();  
  1139. }  
  1140.   
  1141. /* 
  1142. 功能：给一个layer的名字，返回这个layer的指针 
  1143. */  
  1144. template <typename Dtype>  
  1145. const shared_ptr<Layer<Dtype> > Net<Dtype>::layer_by_name(  
  1146.     const string& layer_name) const {  
  1147.   shared_ptr<Layer<Dtype> > layer_ptr;  
  1148.   if (has_layer(layer_name)) {  
  1149.     layer_ptr = layers_[layer_names_index_.find(layer_name)->second];  
  1150.   } else {  
  1151.     layer_ptr.reset((Layer<Dtype>*)(NULL));  
  1152.     LOG(WARNING) << "Unknown layer name " << layer_name;  
  1153.   }  
  1154.   return layer_ptr;  
  1155. }  
  1156.   
  1157. INSTANTIATE_CLASS(Net);  
  1158.   
  1159. }  // namespace caffe  

 

posted @ 2017-05-02 10:03  菜鸡一枚  阅读(628)  评论(0)  编辑  收藏  举报