CAFFE源码学习笔记之十一-卷积层conv_layer

一、前言

vison layer主要是处理图像相关，以图像数据为输入，输出为经过卷积或者pooling后的特征图。该大类包含Convolution(conv_layer.hpp)、Pooling(pooling_layer.hpp)、Local Response Normalization(LRN)(lrn_layer.hpp)、im2col等。
在大多数深度学习模型中，数据经过数据层后，一些分割层后，马上进入的就是卷积层。下面就看看卷积层的源码，同时复习一下卷积的知识。

注意：CAFFE中的Blob是按照行优先的方式存储在线性内存中的，而CUDA则是按照列优先存储的，所以后面会涉及大量的转置操作。

二、conv_layer源码分析
1、base_conv_layer类
由于base_conv_layer类是conv_layer的基类，而且大部分内容都是由该类负责的。
a、成员变量

  /// 卷积核的尺寸，一般为3×3，5×5，1×1等：kernel的形状 = [kernel_h, kernel_w]  ，仅表示二维  Blob<int> kernel_shape_;  ///卷积核移动的步长，分为长宽两个维度：步长形状 = [stride_h, stride_w]  仅表示二维  Blob<int> stride_;  ///是否对原图像数据在边缘进行填充：pad的形状 = [pad_h, pad_w]  仅表示二维  Blob<int> pad_;  /// 数据扩充，仅表示二维，一般默认为1  Blob<int> dilation_;  /// 输入的维度：卷积的输入形状 = [输入图像通道数, 输入图像h,输入图像w]    Blob<int> conv_input_shape_;  /// 图像变为列之后的形状，col_buffer的形状 = [kernel_dim_, conv_out_spatial_dim_ ]  vector<int> col_buffer_shape_;  /// 输出的维度  vector<int> output_shape_;  const vector<int>* bottom_shape_;//输入维度信息。const表示只读  int num_spatial_axes_;//图像轴的个数，就是图像数据的维度，2d或者3d的图像之类  int bottom_dim_;//输入维度= 输入图像通道数*输入图像的h*输入图像w    int top_dim_;//输出维度= 输出通道数*输出h*输出w    int channel_axis_;//输入图像的第几个轴是通道，一般为1    int num_;//batchsize   int channels_;//输入图像的通道数  int group_;//卷积组的大小    int out_spatial_dim_;//输出图像数据的空间维度 = 卷积之后的图像长*卷积之后图像的宽，通过compute_output_shape计算的  int weight_offset_;//分组时需要的位移偏量  int num_output_;//输出特征图个数  bool bias_term_;//是否需要偏置项  bool is_1x1_;//是否是1×1的卷积核  bool force_nd_im2col_;//是否强制使用n维通用卷积  int num_kernels_im2col_;//conv_in_channels_ * conv_out_spatial_dim_  int num_kernels_col2im_;//num_kernels_col2im_ = reverse_dimensions() ? top_dim_ : bottom_dim_    int conv_out_channels_;//卷积输出通道数  int conv_in_channels_;//卷积输入通道数  int conv_out_spatial_dim_;//卷积后输出的图像维度  int kernel_dim_;//kernel_h*kernel_w  int col_offset_;//列下的偏移量  int output_offset_;  Blob<Dtype> col_buffer_;//列的缓存  Blob<Dtype> bias_multiplier_;

b、LayerSetUp函数
关于channel轴，在convolutionParameter中有介绍：

With (N, C, H, W) inputs, and axis == 1 (the default), we perform  // N independent 2D convolutions, sliding C-channel (or (C/g)-channels, for  // groups g>1) filters across the spatial axes (H, W) of the input.  // With (N, C, D, H, W) inputs, and axis == 1, we perform  // N independent 3D convolutions, sliding (C/g)-channels  // filters across the spatial axes (D, H, W) of the input.  翻译：对于一个维度为(N, C, H, W)的输入，axis==1，其意义为N个H×W的2维卷积核，在c/g通道数上滑动  对于一个维度为(N, C, D, H, W) 的输入，axis==1，其表示为N个3d(D, H, W)的卷积核在c/g通道数上滑动。

此函数的关键是卷积层的权重weight_Blob的形状和初始化：

weight的维度为：conv_out_channels_ x conv_in_channels_ / group_x kernel height x kernel widthconv_out_channels_ = num_output_;//正常情况，输出通道数为输出的个数conv_in_channels_ = channels_;//卷积核的通道数和输入是相同的，计算将互相消除。

每个层的layersetup函数需要自己定义：

template <typename Dtype>void BaseConvolutionLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,      const vector<Blob<Dtype>*>& top) {  ConvolutionParameter conv_param = this->layer_param_.convolution_param();//卷积核的参数：卷积核大小，步长，填充，扩展  force_nd_im2col_ = conv_param.force_nd_im2col();//是否使用n维im2col方法计算  channel_axis_ = bottom[0]->CanonicalAxisIndex(conv_param.axis());//轴大于0就直接返回，小于0换算成大于0的。一般默认为1  const int first_spatial_axis = channel_axis_ + 1;//1+1=2  const int num_axes = bottom[0]->num_axes();//根据输入判断4或者5，对应2维或者3维  num_spatial_axes_ = num_axes - first_spatial_axis;//图像的维度 确定用2维或者3维卷积核  CHECK_GE(num_spatial_axes_, 0);  vector<int> bottom_dim_blob_shape(1, num_spatial_axes_ + 1);//输入维度  vector<int> spatial_dim_blob_shape(1, std::max(num_spatial_axes_, 1));  // Setup filter kernel dimensions (kernel_shape_).  kernel_shape_.Reshape(spatial_dim_blob_shape);//根据输入图像的空间维度初始化kernel维度信息  int* kernel_shape_data = kernel_shape_.mutable_cpu_data();  if (conv_param.has_kernel_h() || conv_param.has_kernel_w()) {//如果参数设定了核大小    CHECK_EQ(num_spatial_axes_, 2)        << "kernel_h & kernel_w can only be used for 2D convolution.";    CHECK_EQ(0, conv_param.kernel_size_size())        << "Either kernel_size or kernel_h/w should be specified; not both.";        //初始化尺寸3×3或者n×n，kernel_h & kernel_w只能表示二维    kernel_shape_data[0] = conv_param.kernel_h();    kernel_shape_data[1] = conv_param.kernel_w();  } else {//2维以上的情况    const int num_kernel_dims = conv_param.kernel_size_size();    CHECK(num_kernel_dims == 1 || num_kernel_dims == num_spatial_axes_)        << "kernel_size must be specified once, or once per spatial dimension "        << "(kernel_size specified " << num_kernel_dims << " times; "        << num_spatial_axes_ << " spatial dims).";      for (int i = 0; i < num_spatial_axes_; ++i) {        kernel_shape_data[i] =            conv_param.kernel_size((num_kernel_dims == 1) ? 0 : i);//三维时的维度信息      }  }  for (int i = 0; i < num_spatial_axes_; ++i) {    CHECK_GT(kernel_shape_data[i], 0) << "Filter dimensions must be nonzero.";  }  //步长(stride_).  stride_.Reshape(spatial_dim_blob_shape);  int* stride_data = stride_.mutable_cpu_data();  if (conv_param.has_stride_h() || conv_param.has_stride_w()) {    CHECK_EQ(num_spatial_axes_, 2)        << "stride_h & stride_w can only be used for 2D convolution.";    CHECK_EQ(0, conv_param.stride_size())        << "Either stride or stride_h/w should be specified; not both.";    stride_data[0] = conv_param.stride_h();    stride_data[1] = conv_param.stride_w();  } else {    const int num_stride_dims = conv_param.stride_size();    CHECK(num_stride_dims == 0 || num_stride_dims == 1 ||          num_stride_dims == num_spatial_axes_)        << "stride must be specified once, or once per spatial dimension "        << "(stride specified " << num_stride_dims << " times; "        << num_spatial_axes_ << " spatial dims).";    const int kDefaultStride = 1;    for (int i = 0; i < num_spatial_axes_; ++i) {      stride_data[i] = (num_stride_dims == 0) ? kDefaultStride :          conv_param.stride((num_stride_dims == 1) ? 0 : i);      CHECK_GT(stride_data[i], 0) << "Stride dimensions must be nonzero.";    }  }  // 填充(pad_).  pad_.Reshape(spatial_dim_blob_shape);  int* pad_data = pad_.mutable_cpu_data();  if (conv_param.has_pad_h() || conv_param.has_pad_w()) {    CHECK_EQ(num_spatial_axes_, 2)        << "pad_h & pad_w can only be used for 2D convolution.";    CHECK_EQ(0, conv_param.pad_size())        << "Either pad or pad_h/w should be specified; not both.";    pad_data[0] = conv_param.pad_h();    pad_data[1] = conv_param.pad_w();  } else {    const int num_pad_dims = conv_param.pad_size();    CHECK(num_pad_dims == 0 || num_pad_dims == 1 ||          num_pad_dims == num_spatial_axes_)        << "pad must be specified once, or once per spatial dimension "        << "(pad specified " << num_pad_dims << " times; "        << num_spatial_axes_ << " spatial dims).";    const int kDefaultPad = 0;    for (int i = 0; i < num_spatial_axes_; ++i) {      pad_data[i] = (num_pad_dims == 0) ? kDefaultPad :          conv_param.pad((num_pad_dims == 1) ? 0 : i);    }  }  // 扩展(dilation_).  dilation_.Reshape(spatial_dim_blob_shape);  int* dilation_data = dilation_.mutable_cpu_data();  const int num_dilation_dims = conv_param.dilation_size();  CHECK(num_dilation_dims == 0 || num_dilation_dims == 1 ||        num_dilation_dims == num_spatial_axes_)      << "dilation must be specified once, or once per spatial dimension "      << "(dilation specified " << num_dilation_dims << " times; "      << num_spatial_axes_ << " spatial dims).";  const int kDefaultDilation = 1;  for (int i = 0; i < num_spatial_axes_; ++i) {    dilation_data[i] = (num_dilation_dims == 0) ? kDefaultDilation :                       conv_param.dilation((num_dilation_dims == 1) ? 0 : i);  }  //对于1×1的卷积核默认步长为1，没有填充  is_1x1_ = true;  for (int i = 0; i < num_spatial_axes_; ++i) {    is_1x1_ &=        kernel_shape_data[i] == 1 && stride_data[i] == 1 && pad_data[i] == 0;    if (!is_1x1_) { break; }  }  // 配置输出通道和组别信息  channels_ = bottom[0]->shape(channel_axis_);//输入通道数  num_output_ = this->layer_param_.convolution_param().num_output();//输出个数   CHECK_GT(num_output_, 0);  group_ = this->layer_param_.convolution_param().group();//分组情况  CHECK_EQ(channels_ % group_, 0);  CHECK_EQ(num_output_ % group_, 0)      << "Number of output should be multiples of group.";  if (reverse_dimensions()) {    conv_out_channels_ = channels_;    conv_in_channels_ = num_output_;  } else {    conv_out_channels_ = num_output_;//正常情况，输出通道数为输出的个数    conv_in_channels_ = channels_;//卷积核的通道数和输入是相同的，计算将互相消除。  }  // Handle the parameters: weights and biases.  // - blobs_[0] 卷积核的权值  // - blobs_[1] 偏置(optional)  vector<int> weight_shape(2);  //后面计算的时候weight是个conv_out_channels_*（conv_in_channels_ / group_*kernel_h*kernel_w）的矩阵  weight_shape[0] = conv_out_channels_;// num_output_  weight_shape[1] = conv_in_channels_ / group_;  for (int i = 0; i < num_spatial_axes_; ++i) {    weight_shape.push_back(kernel_shape_data[i]);  }  bias_term_ = this->layer_param_.convolution_param().bias_term();  vector<int> bias_shape(bias_term_, num_output_);  if (this->blobs_.size() > 0) {    CHECK_EQ(1 + bias_term_, this->blobs_.size())        << "Incorrect number of weight blobs.";    if (weight_shape != this->blobs_[0]->shape()) {      Blob<Dtype> weight_shaped_blob(weight_shape);      LOG(FATAL) << "Incorrect weight shape: expected shape "          << weight_shaped_blob.shape_string() << "; instead, shape was "          << this->blobs_[0]->shape_string();    }    if (bias_term_ && bias_shape != this->blobs_[1]->shape()) {      Blob<Dtype> bias_shaped_blob(bias_shape);      LOG(FATAL) << "Incorrect bias shape: expected shape "          << bias_shaped_blob.shape_string() << "; instead, shape was "          << this->blobs_[1]->shape_string();    }    LOG(INFO) << "Skipping parameter initialization";  } else {    if (bias_term_) {      this->blobs_.resize(2);    } else {      this->blobs_.resize(1);    }    // 初始化权重矩阵:    // output channels x input channels per-group x kernel height x kernel width    this->blobs_[0].reset(new Blob<Dtype>(weight_shape));    shared_ptr<Filler<Dtype> > weight_filler(GetFiller<Dtype>(        this->layer_param_.convolution_param().weight_filler()));    weight_filler->Fill(this->blobs_[0].get());    // 如果设置了偏置项，则初始化    if (bias_term_) {      this->blobs_[1].reset(new Blob<Dtype>(bias_shape));      shared_ptr<Filler<Dtype> > bias_filler(GetFiller<Dtype>(          this->layer_param_.convolution_param().bias_filler()));      bias_filler->Fill(this->blobs_[1].get());    }  }  kernel_dim_ = this->blobs_[0]->count(1);  weight_offset_ = conv_out_channels_ * kernel_dim_ / group_;//分组偏移量  // Propagate gradients to the parameters (as directed by backward pass).  this->param_propagate_down_.resize(this->blobs_.size(), true);}

c、reshape函数
根据输入重塑输出的形状

template <typename Dtype>void BaseConvolutionLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,      const vector<Blob<Dtype>*>& top) {  const int first_spatial_axis = channel_axis_ + 1;//数据的维度：2d或者3d  CHECK_EQ(bottom[0]->num_axes(), first_spatial_axis + num_spatial_axes_)      << "bottom num_axes may not change.";      //num = batch_size  num_ = bottom[0]->count(0, channel_axis_);  CHECK_EQ(bottom[0]->shape(channel_axis_), channels_)      << "Input size incompatible with convolution kernel.";  // TODO: generalize to handle inputs of different shapes.  for (int bottom_id = 1; bottom_id < bottom.size(); ++bottom_id) {    CHECK(bottom[0]->shape() == bottom[bottom_id]->shape())//所有的输入都必须有一样的维度        << "All inputs must have the same shape.";  }  // Shape the tops.  //top_shape=（batch_size，num_output_，kernel_h,kernel_w）  bottom_shape_ = &bottom[0]->shape();//获得输入的shape_容器  compute_output_shape();  vector<int> top_shape(bottom[0]->shape().begin(),      bottom[0]->shape().begin() + channel_axis_);//top_shape=(batch_size)  top_shape.push_back(num_output_);//top_shape=(batch_size,num_output)  for (int i = 0; i < num_spatial_axes_; ++i) {    top_shape.push_back(output_shape_[i]);    //top_shape=(batch_size,num_output,top_spatil[0],top_spatil[1]...top_spatil[i])  }  for (int top_id = 0; top_id < top.size(); ++top_id) {    top[top_id]->Reshape(top_shape);  }//多个输出的情况  if (reverse_dimensions()) {    conv_out_spatial_dim_ = bottom[0]->count(first_spatial_axis);//输入图像H×输入图像W  } else {    conv_out_spatial_dim_ = top[0]->count(first_spatial_axis);//输出图像H×输出图像W  }  //img2col是针对单独的一个图像数据的操作  col_offset_ = kernel_dim_ * conv_out_spatial_dim_;  output_offset_ = conv_out_channels_ * conv_out_spatial_dim_ / group_;  // Setup input dimensions (conv_input_shape_).  vector<int> bottom_dim_blob_shape(1, num_spatial_axes_ + 1);  conv_input_shape_.Reshape(bottom_dim_blob_shape);  int* conv_input_shape_data = conv_input_shape_.mutable_cpu_data();  for (int i = 0; i < num_spatial_axes_ + 1; ++i) {    if (reverse_dimensions()) {      conv_input_shape_data[i] = top[0]->shape(channel_axis_ + i);    } else {      conv_input_shape_data[i] = bottom[0]->shape(channel_axis_ + i);    }  }  col_buffer_shape_.clear();  col_buffer_shape_.push_back(kernel_dim_ * group_);  for (int i = 0; i < num_spatial_axes_; ++i) {    if (reverse_dimensions()) {      col_buffer_shape_.push_back(input_shape(i + 1));    } else {      col_buffer_shape_.push_back(output_shape_[i]);    }  }  col_buffer_.Reshape(col_buffer_shape_);  bottom_dim_ = bottom[0]->count(channel_axis_);  top_dim_ = top[0]->count(channel_axis_);  num_kernels_im2col_ = conv_in_channels_ * conv_out_spatial_dim_;  num_kernels_col2im_ = reverse_dimensions() ? top_dim_ : bottom_dim_;  out_spatial_dim_ = top[0]->count(first_spatial_axis);  if (bias_term_) {    vector<int> bias_multiplier_shape(1, out_spatial_dim_);    bias_multiplier_.Reshape(bias_multiplier_shape);    caffe_set(bias_multiplier_.count(), Dtype(1),        bias_multiplier_.mutable_cpu_data());  }}

d、前向计算
卷积层的前向计算大体如下：

其中最重要的是函数conv_im2col_gpu。

转换成矩阵后就调用cblas函caffe_gpu_gemm

所以，卷积的具体实现就是：

1、使用im2col分别将featrue maps 以及卷积核转换成矩阵2、调用GEMM（GEneralized Matrix Multiplication）对两矩阵内积。

输入图像为（C通道数，H图像高度，W图像宽度）
转换为列表示：
每一单列为：C×K×K

列的行数就是卷积核在图像上的滑动次数(输出图像高×输出图像宽)

卷积核的表示：
Cout×C×K×K转换后变为Cout个C×K×K列

两者做内积，最后得到输出为：
Cout×（输出图像高，输出图像宽）的矩阵

img2col的具体实现：
按照channel*kernel_h*kernel_w一列，将一个channel x kernel_h x kernel_w 大小的图像块变成一个列。
有多少个这样的列呢，这就可以用公式进行计算
列数 = [(图像高度+2*填充高度-kernel高度)/stride高度+1] * [(图像宽度+2*填充宽度-kernel宽度)/stride宽度+1]
这个行数就是一个kernel大小的图像块的维度
这个列数实际上就是kernel在图像上滑动的次数

template <typename Dtype>__global__ void im2col_gpu_kernel(const int n, const Dtype* data_im,    const int height, const int width, const int kernel_h, const int kernel_w,    const int pad_h, const int pad_w,    const int stride_h, const int stride_w,    const int dilation_h, const int dilation_w,    const int height_col, const int width_col,    Dtype* data_col) {  CUDA_KERNEL_LOOP(index, n) {//CUDA循环，主要是保证每次循环每个线程都参与计算    const int h_index = index / width_col;    const int h_col = h_index % height_col;//原图像的高变为列后的对应的坐标    const int w_col = index % width_col;//原图像的宽变为列后的对应的坐标，谨记是行优先    const int c_im = h_index / height_col;//原图像对应通道    const int c_col = c_im * kernel_h * kernel_w;//变换后的列的长度    const int h_offset = h_col * stride_h - pad_h;//对应原图像中的高    const int w_offset = w_col * stride_w - pad_w;//对应原图像的宽    Dtype* data_col_ptr = data_col;//数据缓存    data_col_ptr += (c_col * height_col + h_col) * width_col + w_col;//列的内存地址计算    const Dtype* data_im_ptr = data_im;    data_im_ptr += (c_im * height + h_offset) * width + w_offset;//原图像的内存地址计算// 卷积之后的图像与卷积之前的图像像素所对应的位置          // 卷积之后的像素为h和w那么所对应的原图像的位置为 [h * stride_h - pad_h,   h * stride_h - pad_h+kernel_h]以及          // [w * stride_w - pad_w,   w * stride_w - pad_w+kernel_w]     for (int i = 0; i < kernel_h; ++i) {      for (int j = 0; j < kernel_w; ++j) {        int h_im = h_offset + i * dilation_h;        int w_im = w_offset + j * dilation_w;        *data_col_ptr =            (h_im >= 0 && w_im >= 0 && h_im < height && w_im < width) ?            data_im_ptr[i * dilation_h * width + j * dilation_w] : 0;//图像和列之间的数据转换，超出图像的区域直接记为0        data_col_ptr += height_col * width_col;//一列完毕就跳到下一列      }    }  }}

完成转换之后就直接调用gemm函数进行矩阵的内积
首先是卷积核与输入的计算：

template <typename Dtype>void BaseConvolutionLayer<Dtype>::forward_gpu_gemm(const Dtype* input,    const Dtype* weights, Dtype* output, bool skip_im2col) {  const Dtype* col_buff = input;//输入缓存  if (!is_1x1_) {//1*1卷积不需要转换    if (!skip_im2col) {      conv_im2col_gpu(input, col_buffer_.mutable_gpu_data());//将二维或者三维图像转换为列    }    col_buff = col_buffer_.gpu_data();  }  for (int g = 0; g < group_; ++g) {  //conv_out_channels_ / group_是每个卷积组的输出的channel    //kernel_dim_ = input channels per-group x kernel height x kernel width    //计算的是output[output_offset_ * g] =        // weights[weight_offset_ * g] X col_buff[col_offset_ * g]        // weights的形状是 [conv_out_channel x kernel_dim_]        // col_buff的形状是[kernel_dim_ x (卷积后图像高度乘以卷积后图像宽度)]        // 所以output的形状自然就是conv_out_channel X (卷积后图像高度乘以卷积后图像宽度)     caffe_gpu_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);          }}

如果需要加上偏置项：

template <typename Dtype>void BaseConvolutionLayer<Dtype>::forward_gpu_bias(Dtype* output,    const Dtype* bias) {  caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num_output_,      out_spatial_dim_, 1, (Dtype)1., bias, bias_multiplier_.gpu_data(),      (Dtype)1., output);}

e、后向计算
后向计算同样是矩阵的内积，只是输入和输出倒置

template <typename Dtype>void BaseConvolutionLayer<Dtype>::backward_gpu_gemm(const Dtype* output,    const Dtype* weights, Dtype* input) {  Dtype* col_buff = col_buffer_.mutable_gpu_data();  if (is_1x1_) {    col_buff = input;  }  for (int g = 0; g < group_; ++g) {    caffe_gpu_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_gpu(col_buff, input);  }}

三、conv_layer
conv_layer继承自base_conv_layer，需要自己实现的函数只有三个。一个是base_conv_layer的纯虚函数compute_output_shape()，一个是前向计算函数，最后是后向计算函数。

compute_output_shape()

template <typename Dtype>void ConvolutionLayer<Dtype>::compute_output_shape() {  const int* kernel_shape_data = this->kernel_shape_.cpu_data();  const int* stride_data = this->stride_.cpu_data();  const int* pad_data = this->pad_.cpu_data();  const int* dilation_data = this->dilation_.cpu_data();  this->output_shape_.clear();  for (int i = 0; i < this->num_spatial_axes_; ++i) {    // i + 1 to skip channel axis    //卷积后的图像数据的维度=(input_dim + 2 * pad_data[i] - （dilation_data[i] * (kernel_shape_data[i] - 1) + 1）)    const int input_dim = this->input_shape(i + 1);    const int kernel_extent = dilation_data[i] * (kernel_shape_data[i] - 1) + 1;    const int output_dim = (input_dim + 2 * pad_data[i] - kernel_extent)        / stride_data[i] + 1;//    this->output_shape_.push_back(output_dim);  }}

cpu模式下的前向计算(就是调用基类的forward_cpu_gemm，没啥可说的)

template <typename Dtype>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) {      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);      }    }  }}

cpu模式下的后向计算

template <typename Dtype>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();  Dtype* weight_diff = this->blobs_[0]->mutable_cpu_diff();  for (int i = 0; i < top.size(); ++i) {    const Dtype* top_diff = top[i]->cpu_diff();    const Dtype* bottom_data = bottom[i]->cpu_data();    Dtype* bottom_diff = bottom[i]->mutable_cpu_diff();    // Bias gradient, if necessary.    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.        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_);        }      }    }  }}

四、总结
借助对卷积层的分析，理解了作者的一个实现技巧，同时也是对输入输出，卷积核的维度信息有了更深刻的理解。