Caffe Scale层解析

前段时间做了caffe的batchnormalization层的解析，由于整体的BN层实现在Caffe是分段实现的，因此今天抽时间总结下Scale层次，也会后续两个层做合并做下铺垫。

基本公式梳理

Scale层主要完成 \(top = alpha*bottom+ beta\)的过程，则层中主要有两个参数\(alpha\)与\(beta\),

求导会比较简单。

\[\frac{\partial y}{\partial x} = alpha ;\quad \frac{\partial y}{\partial alpha} = x;\quad \frac{\partial y}{\partial beta} = 1
\]

需要注意的是\(alpha\)与\(beta\)均为向量，针对输入的\(channels\)进行的处理，因此不能简单的认定为一个\(float\)的实数。

具体实现

该部分将结合源码实现解析\(scale\)层:

在Caffe proto中ScaleParameter中对Scale有如下几个参数：

  axis [default = 1] ; 默认的处理维度

  num_axes [default = 1] ; //在BN中可以忽略，主要决定第二个bottom

  FillerParameter filler ; //两个FillerParameter即决定初始alpha和beta的填充方式。

  //决定是否学习bias，如果不学习，则可以简化为alpha*x = y

  optional bool bias_term = 4 [default = false];

  FillerParameter bias_filler;

基本成员变量

  // caffe的scale层实现+beta调用了bias层。。。。。。。。。。

  shared_ptr<Layer<Dtype>> bias_layer_; /

  vector<Blob<Dtype>*>bias_bottom_vec_;

  vector<bool> bias_propagate_down_;

  int bias_param_id_;

  Blob<Dtype> sum_multiplier_;

  Blob<Dtype>sum_result_;

  Blob<Dtype> temp_;

  int axis_;

  int outer_dim_,inner_dim_,scale_dim_;

基本成员变量主要包含了Bias层的参数以及Scale层完成对应通道的标注工作。

基本成员函数

主要包含了LayerSetup,Reshape ,Forward和Backward ，内部调用的时候bias_term为true的时候会调用biasLayer的相关函数.

LayerSetup,层次的建立

 template <typename Dtype>

 void ScaleLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,

     const vector<Blob<Dtype>*>& top) {

     const ScaleParameter param = this->layer_param_->scale_param();

     if (bottom.size() == 1 && this->blobs_.size() > 0) {

       //区分测试与训练，测试时 blobs-已经有值

     }

     else if(bottom.size() == 1){

        // 考虑BN的scale 不需要考虑axes

        axis_ = bottom[0]->CanonicalAxisIndex(param.axis());// 1 通道

        const int num_axes = param.num_axes(); // 1

        this->blobs_.resize(1);// alpha;

        //这么大一串，实际就是blobs_[0].reset(new Blob<Dtype>(vector<int>(C)));

        const vector<int>::const_iterator& shape_start =

        bottom[0]->shape().begin() + axis_;

        const vector<int>::const_iterator& shape_end =

        (num_axes == -1) ? bottom[0]->shape().end() : (shape_start + num_axes);

        vector<int>scale_shape(shape_start, shape_end);

        this->blobs_[0].reset(new Blob<Dtype>(scale_shape));

        FillerParameter filler_param(param.filler());

        if (!param.has_filler()) { //没写明填充模式

          filler_param.set_type("constant");

          filler_param.set_value(1);

        }

        shared_ptr<Filler<Dtype>>filler(GetFiller<Dtype>(filler_param));

        filler->Fill(this->blobs_[0].get());

     }

     // 处理需不需要bias

     if (param.bias_term()) {

       LayerParameter layer_param(this->layer_param_);

       layer_param.set_type("Bias");

       BiasParameter* bias_param = layer_param_.mutable_bias_param();

       bias_param->set_axis(param.aixs());

       if (bottom.size() > 1) {

          bias_param->set_num_axes(bottom[1]->num_axes());

       }

       else{

         bias_param->set_num_axes(param.num_axes());//bn层走下面

       }

       bias_param->mutable_filler()->CopyFrom(param.bias_filler());

       bias_layer_ = LayerRegistry<Dtype>::CreateLayer(layer_param);

       bias_bottom_vec_.resize(1);

       bias_bottom_vec_[0] = bottom[0];

       bias_layer_->Setup(bias_bottom_vec_,top);

       bias_param_id = this->blobs_.size(); //1 alpha 此处增加个beta

       this->blobs_.resize(bias_param_id_+1); // 2

       this->blobs_[bias_param_id] = bias_layer_->blobs()[0];

       bias_propagate_down_.resize(1,false);

     }

     this->param_propagate_down_.resize(this->blobs_.size(),true);

 }

Scale层的一部分在完整BN中是不需要考虑的，完整BN中bottomSize为1，num_axes默认为1，blobs_[0]为长度为C的向量，bias需要调用caffe的bias层，所以会看着比较麻烦。

Reshape 调整输入输出与中间变量

Reshape层完成许多中间变量的size初始化

//Reshape操作

template <typename Dtype>

void ScaleLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,

    const vector<Blob<Dtype>*>& top) {

    const ScaleParameter param = this->layer_param_->scale_param();

    Blob<Dtype>* scale = (bottom.size() > 1)?bottom[1]:this->blobs_[0].get();

    axis_=(scale->num_axes()==0)?0:botom[0]->CanonicalAxisIndex(param.axis());

    //这里做了下比较 bottom的NCHW axis_ = 1 则 C == C

    CHECK_EQ(bottom[0]->shape(axis_) = scale->shape(0));

    outer_dim_ = bottom[0]->count(0,axis_);// n

    scale_dim = scale->count(); //c

    inner_dim_ = bottom[0]->count(axis+1);// hw

    if (bottom[0] == top[0]) {

      // Layer得top和bottom同名 in-place computation

      const bool scale_param = (bottom.size() == 1); //true

      if (!scale_param || (scale_param && this->param_propagate_down_[0]) {

        // 后面一个条件成立，需要backward

        //防止修改top时，bottom改变，做临时,因为求导要用到原始的bottom-data

        temp_.ReshapeLike(*bottom[0]);

      }

    }

    else{

      top[0]->ReshapeLike(*bottom[0]);//

    }

    //类似于bn的num-by—tran 保存中间的NC结果 NC*1*1*1

    sum_result_.Reshape(vector<int>(1,outer_dim_*scale_dim_));

    const int sum_mult_size = std::max(outer_dim_,inner_dim_);

    // 为什么不类似于BN做两个temp vector呢

    sum_multiplier_.Reshape(vector<int>(1,sum_mult_size));

    if (sum_multiplier_.cpu_data()[sum_mult_size-1] != Dtype(1)) {

      caffe_set(sum_mult_size,Dtype(1),sum_multiplier_.mutable_cpu_data());

    }

    if (bias_layer_) {

      bias_bottom_vec_[0] = top[0];

      bias_layer_->Reshape(bias_bottom_vec_,top);

    }

}

Reshape操作同BN的基本相似，只不过此处只是新建了两个中间变量，sum_multiplier_和sum_result_.

Forward 前向计算

前向计算，在BN中国紧跟着BN的归一化输出，完成乘以alpha与+bias的操作，由于alpha与bias均为C的向量，因此需要先进行广播。

template <typename Dtype>

void ScaleLayer<Dtype>::Forward_cpu(

    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {

  const Dtype* bottom_data = bottom[0]->cpu_data();

  if (bottom[0] == top[0]) {

     // 先进行一次临时拷贝复制

     caffe_copy(bottom[0]->count(),bottom_data,temp_.mutable_cpu_data());

  }

  const Dtype* scale_data = (bottom.size() > 1)?bottom[1]:

                      this->blios_[0]->cpu_data();

  Dtype* top_data = top[0]->mutable_cpu_data();

  // 这里的遍历实际上和广播的类似，一种是每次操作inner_dim个元素，一种是讲alpha

  // 广播到整个feature_map，然后再调用一次cpu_scale

  for (size_t n = 0; n < outer_dim_; n++) { // n

    for (size_t d = 0; d < scale_dim_; d++) { //c

       const Dtype factory = scale_data[d];// 取某一个通道的值

       caffe_cpu_scale(inner_dim,factory,bottom_data,top_data);

       top_data += inner_dim_;

       bottom_data += inner_dim;

    }

  }

  if (bias_layer_) {

     bias_layer_->Forward(bias_bottom_vec_,top);

  }

}

Backward 反向计算

主要求解三个梯度，对alpha 、beta和输入的bottom(此处的temp)

  template <typename Dtype>

  void ScaleLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,

  	const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {

    if (bias_layer_ &&  // 默认false

      this->param_propagate_down_[this->param_propagate_down_.size()-1]) {

      bias_layer_->Backward(top,bias_propagate_down_,bias_bottom_vec_);

    }

    const scale_param = (bottom.size() == 1);

    Blob<Dtype>* scale = scale_param? this->blobs_[0].get(),bottom[1];

    if ((!scale_param && propagate_down[1])|| //bottomsize大于1的时候判断

      (scale_param&&this->param_propagate_down_[0])) {// 1个输入是判断alpha

      const Dtype* top_diff = top[0]->cpu_diff();

      Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();

      const in_place = (bottom[0] == top[0]);

      // 需要做备份 如果输入输出同名，需要注意用原来临时的temp

      const Dtype* bottom_data =in_place?temp_.cpu_data():bottom[0]->cpu_data();

      // BN中输入是NCHW,而alpha和beta仅仅针对C

      const bool is_eltwise = (bottom[0]->count() == scale->count());//不相等的

      Dtype* product= is_eltwise?scale_.mutable_cpu_diff():

      (in_place?temp_.mutable_cpu_data():bottom[0]->mutable_cpu_diff());

      caffe_mul(top[0]->count(),top_diff,bottom_data,product);

      if (!is_eltwise) { // blobs_与输入对不上

        Dtype* sum_result_ = NULL;

        if (inner_dim_ == 1) {

          //H*W == 1;

          sum_result_ = product;

        }

        else if(sum_result_.count() == 1){ // 1*1*1*1

          const Dtype* sum_mult_  = sum_multiplier_.cpu_data();

          Dtype* scale_diff = scale->mutable_cpu_diff();

          if (scale_param) { //true

            Dtype result = caffe_cpu_dot(inner_dim,product,sum_mult);

            *scale_diff += result; //H*W的相乘

          }

          else{

            *scale_diff = caffe_cpu_dot(inner_dim_,product,sum_mult);

          }

        }

        else{

          const Dtype* sum_mult = sum_multiplier_.mutable_cpu_data();

          sum_result = (outer_dim_ == 1)? // nc如果n==1就直接幅值C

          scale_.mutable_cpu_diff():sum_result_.mutable_cpu_data();

          //NC HW  * HW*1 = NC*1 HW全1

          caffe_cpu_gemv<Dtype>(CblasNoTrans,sum_result.count(),inner_dim,

          Dtype(1),product,sum_mult,Dtype(0),Dtype(0),sum_result);

        }

        if (out_dim_ != 1) {

           const Dtype* sum_mult  = sum_multiplier_.cpu_data();

           Dtype* scale_diff = scale->mutable_cpu_diff();

           if (scale_dim_ ==1) {

             if (scale_param) { // C==1直接计算 NC*NC

                Dtype result = caffe_cpu_dot(outer_dim_,sum_mult_,sum_result);

                *scale_diff += result;

             }

             else{

               *scale_diff =  caffe_cpu_dot(outer_dim_,sum_mult_,sum_result);

             }

           }

           else{  //如果C != 1 需要gemv,(num * channels)^t * 1 *num*1

             caffe_cpu_gemv<Dtype>(CblasTrans,outer_dim_,scale_dim,

             Dtype(1),sum_result,sum_mult,Dtype(scale_param),scale_diff);

           }

        }

    }

  }

  if (propagate_down[0]) { //x求导

     const Dtype* top_diff = top[0]->cpu_diff();

     const Dtype* scale_data = scale->cpu_data();

     Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();

     for (size_t n = 0; n < outer_dim_; n++) {

       for (size_t d = 0; d < inner_dim_; d++) {

          const Dtype factory = scale_data[d];

          caffe_cpu_scale(inner_dim_,factory,top_diff,bottom_diff);

          bottom_diff += inner_dim_;

          top_diff += inner_dim_;

       }

     }

  }

}

Caffe中的Scale层由于不仅仅作为BN的后续层，因此看着会比较绕，实际去上去掉很多if else 后会清晰很多

本文作者：张峰

本文链接：http://www.enjoyai.site/2017/11/09

版权声明：本博客所有文章，均采用CC BY-NC-SA 3.0 许可协议。转载请注明出处！