CAFFE源码学习笔记之七-layer_factory以及layer基类

一、前言
caffe的几大基本模块中之一——Blob已经梳理完毕，现在该轮到Layer了。这一章先梳理layer基类和工厂类，为data_layer做一下铺垫。

Layer定义了layer的初始化，前向传播，后向传播。前向传播可以计算loss，后向传播计算梯度信息。

layer类是caffe中最为庞大的一类，所以作者使用工厂模式，这样当我们使用caffe中已经有的层或者自己定义的层时只需要注册就行了。

在运行期间，可以通过将LayerParameter protobuf参数传入函数就可以调用该层：

LayerRegistry<Dtype>::CreateLayer(param);

注册层的方式有两种：
其一、如果新建层是由其自身的构造函数创建的，注册如下：

REGISTER_LAYER_CLASS(layername);

其二、如果新建层由其他ctreator函数创建，形如：

  template <typename Dtype>
  Layer<Dtype*> GetlayernameLayer(const LayerParameter& param) {
  // your implementation
  }

那么可以通过如下方式注册：

REGISTER_LAYER_CREATOR(layername, GetlayernameLayer)

注意：每层只能注册一次。
二、源码分析
1、layer类
(1)成员变量

  /**  protobuf 中存储的层参数*/
  LayerParameter layer_param_;
  /** 状态: TRAIN or TEST */
  Phase phase_;
  /** 学习参数 */
  vector<shared_ptr<Blob<Dtype> > > blobs_;
  /** 是否进行后向传播的标志，数据层等都不进行后向传播 */
  vector<bool> param_propagate_down_;

  /** loss权重，一般只有最后一层权重不为0，其余层都不计算loss */
  vector<Dtype> loss_;

(2)层的构造
构造函数完成层参数的传入，包括该层用于训练还是测试，层中存储权值的blob_。

注意构造函数不能是虚函数。

  explicit Layer(const LayerParameter& param)
    : layer_param_(param) {
      phase_ = param.phase();
      if (layer_param_.blobs_size() > 0) {
        blobs_.resize(layer_param_.blobs_size());//通常blob_[0]是w，blob_[1]是b
        for (int i = 0; i < layer_param_.blobs_size(); ++i) {
          blobs_[i].reset(new Blob<Dtype>());
          blobs_[i]->FromProto(layer_param_.blobs(i));
        }
      }
    }

SetUp函数是自定义层的“构造函数”，主要做：
第一、检查输入和输出的数量;
第二、真正的setup layer;
第三、根据输入和内部结构重构输出的维度;
第四、设置loss权重;

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

下面是每个函数的详解：

  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {}//bottom是输入数据，也就是上一层的输出;
      //top是输出，但是这个输出没有经过reshape;
      //该函数主要完成的是读入层参数完成层的搭建。

  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) = 0;
      //根据输入数据的维度修改输出和中间buffer的维度信息

检查输入输出的个数，有些层需要多个输入或者输出

virtual void CheckBlobCounts(const vector<Blob<Dtype>*>& bottom,
                               const vector<Blob<Dtype>*>& top) 

设置每层的loss权重

inline void SetLossWeights(const vector<Blob<Dtype>*>& top) {
    const int num_loss_weights = layer_param_.loss_weight_size();
    if (num_loss_weights) {
      CHECK_EQ(top.size(), num_loss_weights) << "loss_weight must be "
          "unspecified or specified once per top blob.";
      for (int top_id = 0; top_id < top.size(); ++top_id) {
        const Dtype loss_weight = layer_param_.loss_weight(top_id);
        if (loss_weight == Dtype(0)) { continue; }//如果权重为0，直接跳过
        this->set_loss(top_id, loss_weight);
        const int count = top[top_id]->count();
        Dtype* loss_multiplier = top[top_id]->mutable_cpu_diff();
        caffe_set(count, loss_weight, loss_multiplier);//将权重信息存在diff_blob中。
      }
    }
  }

(3)前向传播
在前向传播之前需要保证reshape函数已经将top修正到合适的维度。
前向传播可以计算loss，具体的前向计算在具体的层中不一样，所以后面单独讲。
(4)后向传播
后向传播不是每次一层都需要的。

  inline bool param_propagate_down(const int param_id) {
    return (param_propagate_down_.size() > param_id) ?
        param_propagate_down_[param_id] : false;
  }
  /**
   * @brief Sets whether the layer should compute gradients w.r.t. a
   *        parameter at a particular index given by param_id.
   */
  inline void set_param_propagate_down(const int param_id, const bool value) {
    if (param_propagate_down_.size() <= param_id) {
      param_propagate_down_.resize(param_id + 1, true);
    }
    param_propagate_down_[param_id] = value;
  }

二、layer_factory
1、创建层注册表：

typedef shared_ptr<Layer<Dtype> > (*Creator)(const LayerParameter&);
  typedef std::map<string, Creator> CreatorRegistry;

  static CreatorRegistry& Registry() {
    static CreatorRegistry* g_registry_ = new CreatorRegistry();
    return *g_registry_;
  }

2、注册creator：

static void AddCreator(const string& type, Creator creator) {
    CreatorRegistry& registry = Registry();
    CHECK_EQ(registry.count(type), 0)
        << "Layer type " << type << " already registered.";
    registry[type] = creator;
  }

3、根据参数调用层：

  static shared_ptr<Layer<Dtype> > CreateLayer(const LayerParameter& param) {
    if (Caffe::root_solver()) {
      LOG(INFO) << "Creating layer " << param.name();
    }
    const string& type = param.type();
    CreatorRegistry& registry = Registry();
    CHECK_EQ(registry.count(type), 1) << "Unknown layer type: " << type
        << " (known types: " << LayerTypeListString() << ")";
    return registry[type](param);//regisry[type]是函数指针

该类不能被实例化，怎么做？将构造函数置于private域中。
在c++11中，可以直接跟“=delete”

private：
  LayerRegistry() {}

最后，作者将注册写成了宏：

#define REGISTER_LAYER_CREATOR(type, creator)                                  \
  static LayerRegisterer<float> g_creator_f_##type(#type, creator<float>);     \
  static LayerRegisterer<double> g_creator_d_##type(#type, creator<double>)    \

#define REGISTER_LAYER_CLASS(type)                                             \
  template <typename Dtype>                                                    \
  shared_ptr<Layer<Dtype> > Creator_##type##Layer(const LayerParameter& param) \
  {                                                                            \
    return shared_ptr<Layer<Dtype> >(new type##Layer<Dtype>(param));           \
  }                                                                            \
  REGISTER_LAYER_CREATOR(type, Creator_##type##Layer)

}  // namespace caffe