【caffe源代码的梳理之五】Layer

1、Layer数据结构

layer是caffe的基本单元，至少有一个Blob的输入和一个Blob的输出。部分的Layer带有权值（Weight）和偏置项（Bias），有两个运算的方向：前向传播（Forward）和反向传播（Backward）。其中前向传播会对输入的Blob进行某种处理，得到输出的Blob；而反向传播计算则对输出的Blob的diff进行某种处理，得到输入Blob的diff。

Layer是Caffe模型的本质内容和执行计算的基本单元。Layer可以进行很多运算，如convolve(卷积)、pool(池化)、inner product(内积)，rectified-linear和sigmoid等非线性运算，元素级的数据变换，normalize(归一化)、load data(数据加载)、softmax和hinge等losses(损失计算)。

一个layer通过bottom(底部) 连接层接收blobs数据，通过top(顶部)连接层输出blobs数据。Caffe中每种类型layer的参数说明定义在caffe.proto文件中，具体的layer参数值则定义在具体应用的prototxt网络结构说明文件中。

Layer是网络的基本单元，由此派生出了各种层类。在Layer中input data用bottom表示，output data用top表示。由于Caffe网络的组合性和其代码的模块化，自定义layer是很容易的。只要定义好layer的setup(初始化设置)、forward(前向传播，根据input计算output)和backward(反向传播，根据output计算input的梯度)，就可将layer纳入到网络中。

前传(forward)过程为给定的待推断的输入计算输出。在前传过程中，Caffe组合每一层的计算以得到整个模型的计算”函数”。本过程自底向上进行。

反传(backward)过程根据损失来计算梯度从而进行学习。在反传过程中，Caffe通过自动求导并反向组合每一层的梯度来计算整个网络的梯度。这就是反传过程的本质。本过程自顶向下进行。

反传过程以损失开始，然后根据输出计算梯度。根据链式准则，逐层计算出模型其余部分的梯度。有参数的层，会在反传过程中根据参数计算梯度。

与大多数的机器学习模型一样，在Caffe中，学习是由一个损失函数驱动的(通常也被称为误差、代价或者目标函数)。一个损失函数通过将参数集(即当前的网络权值)映射到一个可以标识这些参数”不良程度”的标量值来学习目标。因此，学习的目的是找到一个网络权重的集合，使得损失函数最小。

在Caffe中，损失是通过网络的前向计算得到的。每一层由一系列的输入blobs(bottom)，然后产生一系列的输出blobs(top)。这些层的某些输出可以用来作为损失函数。典型的一对多分类任务的损失函数是softMaxWithLoss函数。

Caffe中每种类型layer的参数说明定义在caffe.proto文件中，具体的layer参数值则定义在具体应用的protobuf网络结构说明文件中。

2、Layer的消息格式

在Caffe中，一个网络的大部分功能都是以layer的形式去展开的。在创建一个Caffe模型的时候，也是以layer为基础进行的，需按照caffe.proto中定义的网络及参数格式定义网络prototxt文件。在.prototxt文件中会有很多个layer { } 字段。

//注意，如果增加了一个新的LayerParameter域，更新下一个可用的ID为147（最后的更新：recurrent_param）
message LayerParameter {
  optional string name = 1; // the layer name
  optional string type = 2; // the layer type
  repeated string bottom = 3; // the name of each bottom blob
  repeated string top = 4; // the name of each top blob

  //当前的计算阶段（训练／测试）
  optional Phase phase = 10;

  //为每个TopBlob分配对损失函数的权重，每个Layer都有默认值，要么0，表示不参与目标函数的计算，要么为1表示参与损失函数的计算
  repeated float loss_weight = 5;

  //指定训练参数
  repeated ParamSpec param = 6;

  //包含了该层数值参数的Blob
  repeated BlobProto blobs = 7;

  //是否对Bottom Blob进行反向传播过程，该字段的长度应该与Bottom Blob一致
  repeated bool propagate_down = 11;

  //控制某个层的某个时刻是否包含在网络中，基于当前的NetState，你可以为include／exclude（不要同时）指定非零值，如果没有任何规则，该层一致包含在网络中，如果当前的NetState满足任何一个指定的额规则，那么该层会被包含或者排斥。
  repeated NetStateRule include = 8;
  repeated NetStateRule exclude = 9;

  //数据预处理参数
  optional TransformationParameter transform_param = 100;

  //所有的损失层共享的参数
  optional LossParameter loss_param = 101;

  //特定类型层的参数，注意一些层实现时可能有多于一种的计算引擎，这些层包含一个引擎类型和引擎参数来选择实现，默认的引擎是在编译阶段由引擎开关设置的。
  optional AccuracyParameter accuracy_param = 102;
  optional ArgMaxParameter argmax_param = 103;
  optional BatchNormParameter batch_norm_param = 139;
  optional BiasParameter bias_param = 141;
  optional ConcatParameter concat_param = 104;
  optional ContrastiveLossParameter contrastive_loss_param = 105;
  optional ConvolutionParameter convolution_param = 106;
  optional CropParameter crop_param = 144;
  optional DataParameter data_param = 107;
  optional DropoutParameter dropout_param = 108;
  optional DummyDataParameter dummy_data_param = 109;
  optional EltwiseParameter eltwise_param = 110;
  optional ELUParameter elu_param = 140;
  optional EmbedParameter embed_param = 137;
  optional ExpParameter exp_param = 111;
  optional FlattenParameter flatten_param = 135;
  optional HDF5DataParameter hdf5_data_param = 112;
  optional HDF5OutputParameter hdf5_output_param = 113;
  optional HingeLossParameter hinge_loss_param = 114;
  optional ImageDataParameter image_data_param = 115;
  optional InfogainLossParameter infogain_loss_param = 116;
  optional InnerProductParameter inner_product_param = 117;
  optional InputParameter input_param = 143;
  optional LogParameter log_param = 134;
  optional LRNParameter lrn_param = 118;
  optional MemoryDataParameter memory_data_param = 119;
  optional MVNParameter mvn_param = 120;
  optional ParameterParameter parameter_param = 145;
  optional PoolingParameter pooling_param = 121;
  optional PowerParameter power_param = 122;
  optional PReLUParameter prelu_param = 131;
  optional PythonParameter python_param = 130;
  optional RecurrentParameter recurrent_param = 146;
  optional ReductionParameter reduction_param = 136;
  optional ReLUParameter relu_param = 123;
  optional ReshapeParameter reshape_param = 133;
  optional ScaleParameter scale_param = 142;
  optional SigmoidParameter sigmoid_param = 124;
  optional SoftmaxParameter softmax_param = 125;
  optional SPPParameter spp_param = 132;
  optional SliceParameter slice_param = 126;
  optional TanHParameter tanh_param = 127;
  optional ThresholdParameter threshold_param = 128;
  optional TileParameter tile_param = 138;
  optional WindowDataParameter window_data_param = 129;
}

3、Layer模版类分析

每一个layer都定义了3种重要的运算：setup(初始化设置)，forward(前向传播)，backward(反向传播)。

(1)、setup：在模型初始化时重置layers及其相互之间的连接；

(2)、forward：从bottom层中接收数据，进行计算后将输出送人到top层中；

(3)、backward：给定相对于top层输出的梯度，计算其相对于输入的梯度，并传递到bottom层。一个有参数的layer需要计算相对于各个参数的梯度值并存储在内部。

特别地，forward和backward函数分别有CPU和GPU两张实现方式。如果没有实现GPU版本，那么layer将转向作为备用选项的CPU方式。这样会增加额外的数据传送成本(输入数据由GPU上复制到CPU，之后输出数据从CPU又复制回到GPU)。

总的来说，Layer承担了网络的两个核心操作：forward pass(前向传播)—-接收输入并计算输出；backward pass(反向传播)—-接收关于输出的梯度，计算相对于参数和输入的梯度并反向传播给在它前面的层。由此组成了每个layer的前向和反向传播。
位置：

include/caffe/layer.hpp
src/caffe/layer.cpp

3.1、主要的依赖文件

#include "caffe/blob.hpp"                   //Blob数据结构定义
#include "caffe/common.hpp"                 //生成随机数以及CPU／GPU选项
#include "caffe/layer_factory.hpp"          //layer内部的注册机制
#include "caffe/proto/caffe.pb.h"           //由caffe.proto生成的头文件
#include "caffe/util/math_functions.hpp"    //主要是矩阵计算的加速库

3.2、主要的私有成员

bool is_shared_;  //标志当前layer是否被其他的layer共享
shared_ptr<boots::mutex> forward_mutex_;    //声明boost::mutex对象,互斥锁变量
void InitMutex();           //初始化互斥锁
void Lock();                //如果layer是共享的则加锁
void Unlock();              //如果layer是共享的则解锁
DISABLE_COPY_AND_ASSIGN(Layer);  //禁止使用Layer类的拷贝和赋值操作

3.3、主要受保护的成员

//配置的layer参数，创建layer对象时，通过调用构造函数从上层传入,关于LayerParameter类的具体参数可参考caffe.proto中的message LayerParameter  
LayerParameter layer_param_; 

//layer的状态：指定参与网络是train还是test           
Phase phase_;           

//用于存储layer的学习的参数如权值和偏置             
vector<shared_ptr<Blob<Dtype> > > blobs_;  

//标志是否为layer指定的blob计算梯度值 
vector<bool> param_propagate_down_;     

//标志layer指定的top blob是否有一个非0权值   
vector<Dtype> loss_;                

//CPU实现layer的前向传播   
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) = 0;       

//GPU实现layer的前向传播
virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {  
    // LOG(WARNING) << "Using CPU code as backup.";  
    return Forward_cpu(bottom, top);  
}  

//CPU实现layer的反向传播  
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,const vector<bool>& propagate_down,const vector<Blob<Dtype>*>& bottom) = 0; 

// GPU实现layer的反向传播  
virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,const vector<bool>& propagate_down,const vector<Blob<Dtype>*>& bottom) {    // LOG(WARNING) << "Using CPU code as backup.";  
    Backward_cpu(top, propagate_down, bottom);  
}  

//检查bottom和top blob是个数是否匹配
virtual void CheckBlobCounts(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {}

//设置top blobs中的diff值
inline void SetLossWeights(const vector<Blob<Dtype>*>& top){}

3.4、主要的成员函数

3.4.1、构造函数

// 显式构造函数，不需要重写，获得成员变量layer_param_、phase_、blobs_的值  
explicit Layer(const LayerParameter& param)  : layer_param_(param), is_shared_(false) {  
    // Set phase and copy blobs (if there are any).  
    phase_ = param.phase();  
    if (layer_param_.blobs_size() > 0) {  
      blobs_.resize(layer_param_.blobs_size());  
      for (int i = 0; i < layer_param_.blobs_size(); ++i) {  
        blobs_[i].reset(new Blob<Dtype>());  
        blobs_[i]->FromProto(layer_param_.blobs(i));  
      }  
    }  
}  

3.4.2、层的设置和共享

// layer初始化,此方法不需要重写，实现常用层配置接口，不可被覆盖  
void SetUp(const vector<Blob<Dtype>*>& bottom,  
    const vector<Blob<Dtype>*>& top) {  
    InitMutex();  
    CheckBlobCounts(bottom, top);  //检查Blob
    LayerSetUp(bottom, top);       //与层类型相关的配置过程
    Reshape(bottom, top);          //对Top Blob变形
    SetLossWeights(top);           //设置损失权值因子
 }  

// 配置层虚函数通过Layer参数即LayerParameter类设置layer中某些成员变量的值  
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
    const vector<Blob<Dtype>*>& top) {}  

// 获得layer data共享状态:一个layer的data是否被多个net共享，默认情况下只有数据读取层才能被Net共享
virtual inline bool ShareInParallel() const { return false; }  

//获得layer是否被其它net共享
inline bool IsShared() const { return is_shared_; }  

// 设置layer是否被其它net共享 
inline void SetShared(bool is_shared) {  
    CHECK(ShareInParallel() || !is_shared)  
        << type() << "Layer does not support sharing.";  
    is_shared_ = is_shared;  
}   

// 调整top blobs的shape  
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
      const vector<Blob<Dtype>*>& top) = 0;

3.4.3、前向传播和反向传播

// 前向传播，通过输入bottom blobs，计算输出top blobs和返回loss
inline Dtype Forward(const vector<Blob<Dtype>*>& bottom,  
      const vector<Blob<Dtype>*>& top)
//具体实现：
template <typename Dtype>  
inline Dtype Layer<Dtype>::Forward(const vector<Blob<Dtype>*>& bottom,  
    const vector<Blob<Dtype>*>& top) {  
  // Lock during forward to ensure sequential forward  
  Lock();  
  Dtype loss = 0;  
  Reshape(bottom, top);  
  switch (Caffe::mode()) {  
  case Caffe::CPU:  
    Forward_cpu(bottom, top);  
    for (int top_id = 0; top_id < top.size(); ++top_id) {  
      if (!this->loss(top_id)) { continue; }  
      const int count = top[top_id]->count();  
      const Dtype* data = top[top_id]->cpu_data();  
      const Dtype* loss_weights = top[top_id]->cpu_diff();  
      loss += caffe_cpu_dot(count, data, loss_weights);  
    }  
    break;  
  case Caffe::GPU:  
    Forward_gpu(bottom, top);  
#ifndef CPU_ONLY  
    for (int top_id = 0; top_id < top.size(); ++top_id) {  
      if (!this->loss(top_id)) { continue; }  
      const int count = top[top_id]->count();  
      const Dtype* data = top[top_id]->gpu_data();  
      const Dtype* loss_weights = top[top_id]->gpu_diff();  
      Dtype blob_loss = 0;  
      caffe_gpu_dot(count, data, loss_weights, &blob_loss);  
      loss += blob_loss;  
    }  
#endif  
    break;  
  default:  
    LOG(FATAL) << "Unknown caffe mode.";  
  }  
  Unlock();  
  return loss;  
}  
// CPU实现layer的前向传播  
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
    const vector<Blob<Dtype>*>& top) = 0;   
// GPU实现layer的前向传播  
virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
    const vector<Blob<Dtype>*>& top) {  
    // LOG(WARNING) << "Using CPU code as backup.";  
    return Forward_cpu(bottom, top);  
}  



// 反向传播，通过给定top blob误差梯度，计算bottom blob误差梯度  
inline void Backward(const vector<Blob<Dtype>*>& top,  
      const vector<bool>& propagate_down,  
      const vector<Blob<Dtype>*>& bottom);
//具体实现：
// 反向传播，通过给定top blob误差梯度，计算bottom blob误差梯度  
template <typename Dtype>  
inline void Layer<Dtype>::Backward(const vector<Blob<Dtype>*>& top,  
    const vector<bool>& propagate_down,  
    const vector<Blob<Dtype>*>& bottom) {  
  switch (Caffe::mode()) {  
  case Caffe::CPU:  
    Backward_cpu(top, propagate_down, bottom);  
    break;  
  case Caffe::GPU:  
    Backward_gpu(top, propagate_down, bottom);  
    break;  
  default:  
    LOG(FATAL) << "Unknown caffe mode.";  
  }  
}  

// CPU实现layer的反向传播  
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
    const vector<bool>& propagate_down,  
    const vector<Blob<Dtype>*>& bottom) = 0;  
// GPU实现layer的反向传播  
virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
    const vector<bool>& propagate_down,  
    const vector<Blob<Dtype>*>& bottom) {  
  // LOG(WARNING) << "Using CPU code as backup.";  
  Backward_cpu(top, propagate_down, bottom);  

3.4.4、一些其他关于层的操作（主要是具体层各自要实现的虚函数）

// 获得layer的权值、偏置等 
vector<shared_ptr<Blob<Dtype> > >& blobs() {  
    return blobs_;  
  }  
// 获得layer的配置参数  
const LayerParameter& layer_param() const { return layer_param_; }  

// 序列化函数，将layer参数写入protobuf文件 
virtual void ToProto(LayerParameter* param, bool write_diff = false);

// 获得top blob指定index的loss值  
inline Dtype loss(const int top_index) const {  
    return (loss_.size() > top_index) ? loss_[top_index] : Dtype(0);  
  }  
// 设置top blob指定index的loss值 
inline void set_loss(const int top_index, const Dtype value) {  
    if (loss_.size() <= top_index) {  
      loss_.resize(top_index + 1, Dtype(0));  
    }  
    loss_[top_index] = value;  
  }  
// 获得layer的类型  
virtual inline const char* type() const { return ""; }  
// 获得layer所需的bottom blobs的个数  
virtual inline int ExactNumBottomBlobs() const { return -1; }  
// 获得layer所需的bottom blobs的最少个数  
virtual inline int MinBottomBlobs() const { return -1; }  
// 获得layer所需的bottom blobs的最多个数
virtual inline int MaxBottomBlobs() const { return -1; }  
// 获得layer所需的top blobs的个数  
virtual inline int ExactNumTopBlobs() const { return -1; }  
// 获得layer所需的top blobs的最少个数  
virtual inline int MinTopBlobs() const { return -1; }  
// 获得layer所需的top blobs的最多个数  
virtual inline int MaxTopBlobs() const { return -1; } 
// 判断layer所需的bottom blobs和top blobs的个数是否相等 
virtual inline bool EqualNumBottomTopBlobs() const { return false; }  

// 判断layer所需的的top blobs是否需要由Net::Init来创建 
virtual inline bool AutoTopBlobs() const { return false; }
// 判断layer指定的bottom blob是否需要强制梯度返回，因为有些layer其实不需要梯度信息 
virtual inline bool AllowForceBackward(const int bottom_index) const { return true; } 

// 判断layer指定的blob是否应该计算梯度  
inline bool param_propagate_down(const int param_id) {  
  return (param_propagate_down_.size() > param_id) ?  
      param_propagate_down_[param_id] : false;  
}  

// 设置layer指定的blob是否应该计算梯度  
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;  
}