Caffe代码理解-卷积层conv_layer

带下采样的卷积

输入图像X+ 卷积核 K ->卷积操作->输出特征图Y
其中，输入图像和输出特征图都是三维张量，卷积核是四维张量。
（1）
CNN里的卷积不是信号处理里严格的卷积。卷积核是可以不翻转的，《深度学习》书里把互相关和卷积统称为卷积。
直观来讲，卷积可以视为一种局部的线性回归。
i输出特征图通道，jk输出特征图上坐标，l输入图像通道，s步幅，b偏置标量。
输出特征图Y上的元素Y_ijk，对应输入图像X上的一个block，block的左上角左边为[(j-1)s, (k-1)s]，宽高为卷积核尺寸，即m/n的最大值。
该block与卷积核做点积，即为Y_ijk的值。所以其实还是个局部线性回归，所谓的参数共享其实就是各个位置的回归权重参数相同，不用每个位置都用一个权重矩阵。
由于图像和特征图是多通道的，所以Y_ijk的计算涉及了多通道上的同一block。
步幅s代表了采样间隔，如果s>1，可视为下采样。

Caffe中矩阵形式的卷积运算

还是要用这张经典的图示

为了加速运算，用空间换时间。
利用im2col函数把多通道输入图像整理为一个单通道矩阵，为什么叫im2col，因为相当于图像中的每一个block都被拉伸为一个column，由于输入是多通道的，所以每个block对应三个串在一起的columns。
如图例所示，input feature matrix的每一行都包含了第一个block的三通道的columns的转置。总共有四行，是因为有四个block参与，即卷积在4个位置上进行了运算。
多通道的卷积核，也是被整理为一个Kernel matrix，每一列由三通道kernel展开成的colums串在一起形成。总共有两列是因为输出是2通道的。
所以，卷积运算就可以表达为矩阵相乘的形式，GEMM (general matrix multiply)
（2）
这里的输入特征图已经是有冗余的了，但是计算更快。

Caffe中conv_layer

由BaseConvolutionLayer继承而来，主要看一下forward和backward计算。

前向计算，由bottom计算top

void ConvolutionLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  const Dtype* weight = this->blobs_[0]->cpu_data();
  for (int i = 0; i < bottom.size(); ++i) {
    const Dtype* bottom_data = bottom[i]->cpu_data();
    Dtype* top_data = top[i]->mutable_cpu_data();
    for (int n = 0; n < this->num_; ++n) {//num_ is batch_size
      this->forward_cpu_gemm(bottom_data + n * this->bottom_dim_, weight,
          top_data + n * this->top_dim_);
      if (this->bias_term_) {
        const Dtype* bias = this->blobs_[1]->cpu_data();
        this->forward_cpu_bias(top_data + n * this->top_dim_, bias);
      }
    }
  }
}

1. forward_cpu_gemm： 针对batch中的每张图像，调用基类的函数 forward_cpu_gemm，该函数其实先用im2col把输入转换为

multiplier

col_buffer_，然后进行矩阵相乘，

caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, conv_out_channels_ /
    group_, conv_out_spatial_dim_, kernel_dim_,
    (Dtype)1., weights + weight_offset_ * g, col_buff + col_offset_ * g,
    (Dtype)0., output + output_offset_ * g);

即weights*col_buffer_=output。这里的weights应该是公式（2）中W的转置， col_buffer_是x的转置，output是Y的转置。
2. foward_cpu_bias: 即 bias*全1矩阵bias_multiplier+output -> output。其中，bias是长度为输出特征图通道数的向量，也就是每一个通道对应一个偏置标量。bias_multiplier是长度为输出特征图尺寸的向量的转置，bias与其相乘后便成为一个每一列元素是一个通道偏置的矩阵。

caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num_output_,
    out_spatial_dim_, 1, (Dtype)1., bias, bias_multiplier_.cpu_data(),
    (Dtype)1., output);

反向计算，由top计算bottom_diff, weight_diff, bias_diff

void ConvolutionLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  const Dtype* weight = this->blobs_[0]->cpu_data();//weight belong to this layer
  Dtype* weight_diff = this->blobs_[0]->mutable_cpu_diff();//to be updated
  for (int i = 0; i < top.size(); ++i) {
    const Dtype* top_diff = top[i]->cpu_diff();//propagated from upper layer
    const Dtype* bottom_data = bottom[i]->cpu_data();
    Dtype* bottom_diff = bottom[i]->mutable_cpu_diff();//to be updated
    // Bias gradient, if necessary. Accumulate diffs in a batch
    if (this->bias_term_ && this->param_propagate_down_[1]) {
      Dtype* bias_diff = this->blobs_[1]->mutable_cpu_diff();
      for (int n = 0; n < this->num_; ++n) {
        this->backward_cpu_bias(bias_diff, top_diff + n * this->top_dim_);
      }
    }
    if (this->param_propagate_down_[0] || propagate_down[i]) {
      for (int n = 0; n < this->num_; ++n) {
        // gradient w.r.t. weight. Note that we will accumulate diffs in a batch.
        if (this->param_propagate_down_[0]) {
          this->weight_cpu_gemm(bottom_data + n * this->bottom_dim_,
              top_diff + n * this->top_dim_, weight_diff);
        }
        // gradient w.r.t. bottom data, if necessary.
        if (propagate_down[i]) {
          this->backward_cpu_gemm(top_diff + n * this->top_dim_, weight,
              bottom_diff + n * this->bottom_dim_);
        }
      }
    }
  }
}

计算偏置的偏导数： bias_diff = top_diff*bias_multiplier_+bias_diff，注意最后还加了bias_diff，说明计算bias梯度时，累加了batch中的各个图像所产生的结果。 每一个通道中的top_diff累加，得到该通道中的偏置的导数。

void BaseConvolutionLayer<Dtype>::backward_cpu_bias(Dtype* bias,
    const Dtype* input) {
  caffe_cpu_gemv<Dtype>(CblasNoTrans, num_output_, out_spatial_dim_, 1.,
      input, bias_multiplier_.cpu_data(), 1., bias);
}

计算权重的梯度：weights=top_diff*col_buff.transpose()+weights。注意，1，权重的梯度也是由一个batch累加的。2，这里的weights是公式（2）的转置，所以上一行的公式其实是W=X.transpose*dY的转置

void BaseConvolutionLayer<Dtype>::weight_cpu_gemm(const Dtype* input,
    const Dtype* output, Dtype* weights) {
  const Dtype* col_buff = input;
  if (!is_1x1_) {
    conv_im2col_cpu(input, col_buffer_.mutable_cpu_data());
    col_buff = col_buffer_.cpu_data();
  }
  for (int g = 0; g < group_; ++g) {
    caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasTrans, conv_out_channels_ / group_,
        kernel_dim_, conv_out_spatial_dim_,
        (Dtype)1., output + output_offset_ * g, col_buff + col_offset_ * g,
        (Dtype)1., weights + weight_offset_ * g);
  }
}

计算输入数据的梯度： bottom_diff = weights.transpose()*top_diff。完成一次反传

void BaseConvolutionLayer<Dtype>::backward_cpu_gemm(const Dtype* output,
    const Dtype* weights, Dtype* input) {
  Dtype* col_buff = col_buffer_.mutable_cpu_data();
  if (is_1x1_) {
    col_buff = input;
  }
  for (int g = 0; g < group_; ++g) {
    caffe_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans, kernel_dim_,
        conv_out_spatial_dim_, conv_out_channels_ / group_,
        (Dtype)1., weights + weight_offset_ * g, output + output_offset_ * g,
        (Dtype)0., col_buff + col_offset_ * g);
  }
  if (!is_1x1_) {
    conv_col2im_cpu(col_buff, input);
  }
}