caffe源码分析-layer

忘是亡心i 2022-05-09 11:22 254阅读 0赞

本文主要分析`caffe` `layer`层，主要内容如下：

1.  从整体上说明下`caffe`的layer层的类别，以及作用
2.  通过proto定义与类Layer简要说明下Layer的核心成员变量;
3.  Layer类的核心成员函数

--------------------

### 1. 类Layer overview ###

caffe中的Layer主要分为如下几个模块：

1.  输入层Data Layers

Data Layers定义了caffe中网络的输入，依赖于高效的数据库，例如(LevelDB or LMDB)。并且可以对数据做预处理，例如mean subtraction, scaling, random cropping, mirroring。  
常用的有：Input, ImageData.

1.  Vision Layers层(卷积相关)例如，卷积层Convolution Layer, 池化层Pooling Layer等
2.  循环网络层Recurrent Layers 例如，LSTM, RNN等。
3.  Common Layers例如，Inner Product 全连接层，Dropout弃权层，等。
4.  Normalization Layers（归一化层）例如Local Response Normalization (LRN), Batch Normalization 。
5.  Activation / Neuron Layers（激活层）,例如ReLU, Sigmoid等。
6.  Utility Layers, 例如Flatten, Reshape等。
7.  Loss Layers, 例如Sigmoid Cross-Entropy Loss, Sum-of-Squares / Euclidean等。

**layer.hpp**: 父类Layer，定义所有layer的基本接口。

**data\_layers.hpp**: 继承自父类Layer，定义与输入数据操作相关的子Layer，例如DataLayer，HDF5DataLayer和ImageDataLayer等。

**vision\_layers.hpp**: 继承自父类Layer，定义与特征表达相关的子Layer，例如ConvolutionLayer，PoolingLayer和LRNLayer等。

**neuron\_layers.hpp**: 继承自父类Layer，定义与非线性变换相关的子Layer，例如ReLULayer，TanHLayer和SigmoidLayer等。

**loss\_layers.hpp**: 继承自父类Layer，定义与输出误差计算相关的子Layer，例如EuclideanLossLayer，SoftmaxWithLossLayer和HingeLossLayer等。

**common\_layers.hpp**: 继承自父类Layer，定义与中间结果数据变形、逐元素操作相关的子Layer，例如ConcatLayer，InnerProductLayer和SoftmaxLayer等。

**layer\_factory.hpp**: Layer工厂模式类，负责维护现有可用layer和相应layer构造方法的映射表。

每个Layer根据自身需求的不同，会定义CPU或GPU版本的实现，例如ConvolutionLayer的CPU和GPU实现就定义在了两个文件中conv\_layer.cpp, conv\_layer.cu.

--------------------

### 2. 通过proto定义与类Layer简要说明下Layer的核心成员变量 ###

proto的LayerParameter核心参数如下，除了基础的参数外还有其他的继承类如：ConvolutionParameter额外参数。

// LayerParameter next available layer-specific ID: 145 (last added: crop_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
    
      // The train / test phase for computation.
      optional Phase phase = 10;
    
      repeated float loss_weight = 5;
      // The blobs containing the numeric parameters of the layer.
    // Specifies training parameters (multipliers on global learning constants,
    // and the name and other settings used for weight sharing).
      repeated ParamSpec param = 6;
    
      repeated BlobProto blobs = 7;
    
      // The size must be either 0 or equal to the number of bottoms.
      repeated bool propagate_down = 11;
    
      // Parameters for data pre-processing.
      optional TransformationParameter transform_param = 100;
    
      // Parameters shared by loss layers.
      optional LossParameter loss_param = 101;
    
      // Layer type-specific parameters.
      optional ConvolutionParameter convolution_param = 106;
      optional InnerProductParameter inner_product_param = 117;
    }

上面的参数，我们重点关注下，ParamSpec，定义如下：

// Specifies training parameters (multipliers on global learning constants,
    // and the name and other settings used for weight sharing).
    message ParamSpec {
      // The names of the parameter blobs -- useful for sharing parameters among
      // layers, but never required otherwise.  To share a parameter between two
      // layers, give it a (non-empty) name.
      optional string name = 1;
      //......
      // The multiplier on the global learning rate for this parameter.
      optional float lr_mult = 3 [default = 1.0];
    
      // The multiplier on the global weight decay for this parameter.
      optional float decay_mult = 4 [default = 1.0];
    }

此参数定义了反向传播过程的参数更新的学习率(结合solve中的base\_lr)，由于参数有weight和bias因此是repeated，使用的示例如下：

layer {
      name: "ip1"
      type: "InnerProduct"
      param { lr_mult: 1 }  // for weight
      param { lr_mult: 2 }  // for bias
      inner_product_param {
        num_output: 500
        weight_filler {
          type: "xavier"
        }
        bias_filler {
          type: "constant"
        }
      }
      bottom: "pool2"
      top: "ip1"
    }

在solver.prototxt中我们定义了base\_lr: 0.01，因此weight的学习率是0.01， bias的学习率是0.01\*2.

--------------------

### 3. Layer类的核心成员函数 ###

template<typename Dtype>
    class Layer{
    protected:
      //protobuf文件中存储的layer参数,从protocal buffers格式的网络结构说明文件中读取
        //protected类成员，构造函数中初始化
        LayerParameter layer_param_;
        //层状态，参与网络的训练还是测试
        Phase phase_;
        // 可学习参数层权值和偏置参数，使用向量是因为权值参数和偏置是分开保存在两个blob中的
        // 在基类layer中初始化(只是在描述文件定义了的情况下)
        vector<shared_ptr<Blob<Dtype> > > blobs_;
        // 标志每个可学习参数blob是否需要计算反向传递的梯度值
        vector<bool> param_propagate_down_;
        // 非LossLayer为零，LossLayer中表示每个top blob计算的loss的权重
        vector<Dtype> loss_;
    private:
        /** Whether this layer is actually shared by other nets*/
        bool is_shared_;
        // 若该layer被shared，则需要这个mutex序列保持forward过程的正常运行
        shared_ptr<boost::mutex> forward_mutex_;
    }

Layer的核心函数在于Forward，Backward,这两个函数调用Forward\_cpu、Forward\_gpu以及Backward\_cpu，Backward\_gpu（这四个函数子类需要实现）。

inline Dtype Forward(const vector<Blob<Dtype>*>& bottom,
                         const vector<Blob<Dtype>*>& top);
    //给定相对于 top 层输出的梯度，计算其相对于输入的梯度，并传递到 bottom
     层。一个有参数的 layer 需要计算相对于各个参数的梯度值并存储在内部。
    inline void Backward(const vector<Blob<Dtype>*>& top,
                         const vector<bool>& propagate_down,
                         const vector<Blob<Dtype>*>& bottom);
    
    protected:
    //纯虚函数，子类必须实现，使用cpu经行前向计算
    virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
                             const vector<Blob<Dtype>*>& top) = 0;
    //使用gpu经行前向计算, 如果gpu没有实现则使用默认的CPU版本
    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);
    }
    //纯虚函数，派生类必须实现
    virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
                              const vector<bool>& propagate_down,
                              const vector<Blob<Dtype>*>& bottom) = 0;
    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);
    }

例如Backward仅仅在Backward\_cpu，Backward\_gpu做了一层包装：

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.";
        }
    }

Forward同理：

// 前向传播和反向传播接口。 每个Layer的派生类都应该实现Forward_cpu()
    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);// we may change input data size(num)
        switch (Caffe::mode()) {
            case Caffe::CPU:
                Forward_cpu(bottom, top);
                // .......
                break;
            case Caffe::GPU:
                Forward_gpu(bottom, top);
    #ifndef CPU_ONLY
                // gpu realize, omitted
    #endif
                break;
            default:
                LOG(FATAL) << "Unknown caffe mode.";
        }
        Unlock();
        return loss;
    }

--------------------

### `caffe`系列源码分析介绍 ###

本系列深度学习框架`caffe` 源码分析主要内容如下：

##### 1. [caffe源码分析-cmake 工程构建][caffe_-cmake]: #####

[caffe源码分析-cmake 工程构建][caffe_-cmake]主要内容:

> 自己从头构建一遍工程，这样能让我更好的了解大型的项目的构建。当然原始的caffe的构建感觉还是比较复杂(主要是cmake)，我这里仅仅使用cmake构建，而且简化点，当然最重要的是支持CLion直接运行调试（如果需要这个工程可以评论留下你的邮箱，我给你发送过去）。

![这里写图片描述][70]

##### 2. caffe的数据内存分配类`SyncedMemory`， 以及类`Blob`数据传输的媒介. #####

主要内容：  
[caffe源码分析-SyncedMemory][caffe_-SyncedMemory]  
[caffe源码分析-Blob][caffe_-Blob]  
其中`Blob`分析给出了其直接与opencv的图片相互转化以及操作，可以使得我们更好的理解`Blob`.

##### 3. caffe `layer`的源码分析，包括从整体上说明了`layer`类别以及其proto定义与核心函数. #####

内容如下：  
[caffe源码分析-layer][caffe_-layer]  
[caffe源码分析-ReLULayer][caffe_-ReLULayer]  
[caffe源码分析-inner\_product\_layer][caffe_-inner_product_layer]  
[caffe源码分析-layer\_factory][caffe_-layer_factory]

首先分析了最简单的`layer` `Relu`，然后在是`inner_product_layer全连接层`， 最后是`layer_factory`caffe中 以此工厂模式create各种Layer.

##### 4. 数据输入层，主要是多线程+BlockingQueue的方式读取数据训练： #####

内容如下：  
[caffe源码分析-BlockingQueue][caffe_-BlockingQueue]  
[caffe源码分析-InternalThread][caffe_-InternalThread]  
[caffe源码分析-DataReader][caffe_-DataReader]

##### 5. IO处理例如读取proto文件转化为网络，以及网络参数的序列化 #####

内容如下：  
[caffe源码分析-DataTransformer][caffe_-DataTransformer]  
[caffe源码分析-db, io][caffe_-db_ io]

##### 6. 最后给出了使用纯C++结合多层感知机网络训练mnist的示例 #####

内容如下：

[caffe c++示例（mnist 多层感知机c++训练，测试）][caffe c_mnist _c]

类似与`caffe`一样按照`layer、solver、loss、net`等模块构建的神经网络实现可以见下面这篇blog，相信看懂了这个python的代码理解caffe框架会更简单点.

[神经网络python实现][python]

--------------------

**最后如果需要`cmake` \+ `CLion`直接运行调试`caffe`的代码工程，可以评论留下你的邮箱，我给你发送过去.**

参考：  
[http://caffe.berkeleyvision.org/tutorial/layers.html][http_caffe.berkeleyvision.org_tutorial_layers.html]  
[https://imbinwang.github.io/research/inside-caffe-code-layer][https_imbinwang.github.io_research_inside-caffe-code-layer]

[caffe_-cmake]: https://blog.csdn.net/haluoluo211/article/details/82668188
[70]: /images/20220509/d285362123d94fe696d0a70b8941159a.png
[caffe_-SyncedMemory]: https://blog.csdn.net/haluoluo211/article/details/82668358
[caffe_-Blob]: https://blog.csdn.net/haluoluo211/article/details/82668678
[caffe_-layer]: https://blog.csdn.net/haluoluo211/article/details/82956105
[caffe_-ReLULayer]: https://blog.csdn.net/haluoluo211/article/details/82956157
[caffe_-inner_product_layer]: https://blog.csdn.net/haluoluo211/article/details/82956259
[caffe_-layer_factory]: https://blog.csdn.net/haluoluo211/article/details/82956378
[caffe_-BlockingQueue]: https://blog.csdn.net/haluoluo211/article/details/82956464
[caffe_-InternalThread]: https://blog.csdn.net/haluoluo211/article/details/82956589
[caffe_-DataReader]: https://blog.csdn.net/haluoluo211/article/details/82956624
[caffe_-DataTransformer]: https://blog.csdn.net/haluoluo211/article/details/82956728
[caffe_-db_ io]: https://blog.csdn.net/haluoluo211/article/details/82956800
[caffe c_mnist _c]: https://blog.csdn.net/haluoluo211/article/details/82958604
[python]: https://blog.csdn.net/haluoluo211/article/details/81158209
[http_caffe.berkeleyvision.org_tutorial_layers.html]: http://caffe.berkeleyvision.org/tutorial/layers.html
[https_imbinwang.github.io_research_inside-caffe-code-layer]: https://imbinwang.github.io/research/inside-caffe-code-layer