【caffe】卷积层代码解析

1.Forward_cpu

conv_layer.cpp

template <typename Dtype>
void ConvolutionLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
	// blobs_声明在 layer.hpp 中，vector<shared_ptr<Blob<Dtype> > > blobs_;
	// 用于存放学习得到的参数权值 weight 和偏置参数 bias
	// weight(blobs_[0])和bias(blobs_[1])分别存放在两个blob中
  const Dtype* weight = this->blobs_[0]->cpu_data();

  // 对bottom中所有blob进行前向卷积运算
  for (int i = 0; i < bottom.size(); ++i) {
    const Dtype* bottom_data = bottom[i]->cpu_data();
    Dtype* top_data = top[i]->mutable_cpu_data();

    // 对一个Batch的每一张图片进行前向计算
    // num_定义在caffe.proto中，即在caffe.pb.h中,为BatchSize大小
    for (int n = 0; n < this->num_; ++n) {

        // 基类的forward_cpu_gemm函数 base_conv_layer.cpp
        // 计算的是top_data[n * this->top_dim_] =
        // weights * bottom_data[n * this->bottom_dim_]

    	// bottom_dim_, bias_term和top_dim定义在base_conv_layer.hpp中，
    	// int bottom_dim_; 大小默认为 C_in*H_in*W_in
    	// int top_dim_; 大小默认为 C_out*H_out*W_out
    	// bool bias_term_; 是否使用偏置项
      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);
      }
    }
  }
}

base_conv_layer.cpp

template <typename Dtype>
void BaseConvolutionLayer<Dtype>::forward_cpu_gemm(const Dtype* input,
    const Dtype* weights, Dtype* output, bool skip_im2col) {

  const Dtype* col_buff = input;
  if (!is_1x1_) {
    if (!skip_im2col) {
        // 如果没有1x1卷积，也没有skip_im2col
        // 则使用conv_im2col_cpu对使用卷积核滑动过程中的
        // 每一个kernel大小的三维图像块
        // 变成一个列向量，形成一个
        // height = C_in * kernel_h * kernel_w
        // width = output_h * output_w 的矩阵
      conv_im2col_cpu(input, col_buffer_.mutable_cpu_data());
    }
    // 获取im2col后得到的矩阵。注意col_buff和col_buffer_不同
    col_buff = col_buffer_.cpu_data();
  }

  // 使用caffe的cpu_gemm来进行计算
  for (int g = 0; g < group_; ++g) {
	  //  g=0,group_=1,所以传递的参数为：
	  //  conv_out_channels_ ：卷积层的输出通道
	  //  conv_out_spatial_dim_: H_out*W_out
	  //  kernel_dim_: C_in*H_k*W_k
	  //  weight: 卷积核参数指针
	  //  col_offset：图片展成的列向量
	  //  output: 输出
	  /*
	  功能： C = alpha*A*B+beta*C
	  A,B,C 是输入矩阵（一维数组格式）
	  所以为：output = 1.*weights*col_buff+0*output
	  其中weights矩阵的维数为 [C_out,C_in*H_k*W_k]
	  col_buff矩阵的维数为 [C_in*H_k*W_K, H_out*W_out]
	  所以得到的结果output的维数为 [C_out, H_out*W_out]
      */

	  /*
	   * 滤波器权值没有经行相应的转换是因为，权值和数据都是一维数组存储的
	   * 但数据是按行存储的，所以需要im2col，而滤波器权值本来就是那样存放的
	   * 区别在于滤波器权值是学习得到的，而图像是给定的
	   */
    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);
  }
}

　　

base_conv_layer.hpp

  inline void conv_im2col_cpu(const Dtype* data, Dtype* col_buff) {
  	if (!force_nd_im2col_ && num_spatial_axes_ == 2) {
  		// 如果不是计算n维通用卷积且计算的是二维卷积
  		// num_spatial_axes定义在base_conv_layer.hpp中
  		// 含义是计算二维卷积还是三维卷积，
  		// 对于(N, C, H, W)的输入结果为2
  		// 对于(N, C, D, H, W)的输入，结果为3
    	im2col_cpu(data, conv_in_channels_,
          	conv_input_shape_.cpu_data()[1], conv_input_shape_.cpu_data()[2],
          	kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1],
          	pad_.cpu_data()[0], pad_.cpu_data()[1],
          	stride_.cpu_data()[0], stride_.cpu_data()[1],
          	dilation_.cpu_data()[0], dilation_.cpu_data()[1], col_buff);
    } else {
     	im2col_nd_cpu(data, num_spatial_axes_, conv_input_shape_.cpu_data(),
        	col_buffer_shape_.data(), kernel_shape_.cpu_data(),
          	pad_.cpu_data(), stride_.cpu_data(), dilation_.cpu_data(), col_buff);
    }
  }

　　

im2col.cpp

template <typename Dtype>
void im2col_cpu(const Dtype* data_im, const int channels,
    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,
    Dtype* data_col) {
  // 通用公式，其中包含了卷积核的膨胀操作
  const int output_h = (height + 2 * pad_h -
    (dilation_h * (kernel_h - 1) + 1)) / stride_h + 1;
  const int output_w = (width + 2 * pad_w -
    (dilation_w * (kernel_w - 1) + 1)) / stride_w + 1;
  const int channel_size = height * width;
  // 先遍历每一个通道的图像矩阵（不是顺序遍历像素）
  // 然后遍历每一个kernel（遍历kernel，而不是遍历kernel内的元素）
  // 不是依次遍历kernel中的所有元素，而是每次只取kernel中某一个位置的元素
  // 需要遍历多次所有的kernel，每遍历一次所有的kernel
  // 所有kernel中的某个位置的元素被遍历，假如kernel大小为3*3，
  // 那么需要遍历9次所有的kernel才能遍历完图像矩阵的所有像素
  // 因为kernel有9个元素，每次kernel的遍历只取一个位置，
  // 那么如果遍历某个kernel中的所有元素，那么就需要9次遍历
  for (int channel = channels; channel--; data_im += channel_size) {
    for (int kernel_row = 0; kernel_row < kernel_h; kernel_row++) {
      for (int kernel_col = 0; kernel_col < kernel_w; kernel_col++) {
        // 计算将要访问的元素在输入矩阵中的行数（此矩阵为pad操作后的矩阵）
        int input_row = -pad_h + kernel_row * dilation_h;
        for (int output_rows = output_h; output_rows; output_rows--) {
          // is_a_ge_zero_and_a_lt_b(a, b) 含义为
          // 判断 0<= a < b 是否成立
          // 如果input_row和height不满足条件，说明input_row位于pad行
          if (!is_a_ge_zero_and_a_lt_b(input_row, height)) {
            for (int output_cols = output_w; output_cols; output_cols--) {
              *(data_col++) = 0;
            }
          } else {
            // 计算将要访问的元素在输入矩阵中的列数（此矩阵为pad操作后的矩阵）
            int input_col = -pad_w + kernel_col * dilation_w;
            for (int output_col = output_w; output_col; output_col--) {
              if (is_a_ge_zero_and_a_lt_b(input_col, width)) {
                // 依次复制该行所有kernel中的固定位置的元素
                *(data_col++) = data_im[input_row * width + input_col];
              } else {
                // 如果input_col和width不满足条件，说明input_col位于pad列
                *(data_col++) = 0;
              }
              // 依次遍历input_row行中所有kernel
              input_col += stride_w;
            }
          }
          // 遍历下一行的kernel组
          input_row += stride_h;
        }
      }
    }
  }
}

　　

math_functions.cpp

/*
功能： C=alpha*A*B+beta*C
A,B,C 是输入矩阵（一维数组格式）

CblasRowMajor :数据是行主序的（二维数据也是用一维数组储存的）
TransA, TransB：是否要对A和B做转置操作（CblasTrans CblasNoTrans）
M： A、C 的行数
N： B、C 的列数
K： A 的列数， B 的行数
lda ： A的列数（不做转置）行数（做转置）
ldb： B的列数（不做转置）行数（做转置）
A:[M,K]
B:[K,N]
 */
template<>
void caffe_cpu_gemm<float>(const CBLAS_TRANSPOSE TransA,
    const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
    const float alpha, const float* A, const float* B, const float beta,
    float* C) {
  int lda = (TransA == CblasNoTrans) ? K : M;
  int ldb = (TransB == CblasNoTrans) ? N : K;
  cblas_sgemm(CblasRowMajor, TransA, TransB, M, N, K, alpha, A, lda, B,
      ldb, beta, C, N);
}

　　

cblas

void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,
	const enum CBLAS_TRANSPOSE TransB, const int M, const int N,
	const int K, const float alpha, const float  *A,
	const int lda, const float  *B, const int ldb,
	const float beta, float  *C, const int ldc)
/*
 * 功能为计算 C = alpha*op(A)*op(B) + beta*C
 *
 * const enum CBLAS_ORDER Order，这是指的数据的存储形式，
 * 在CBLAS的函数中无论一维还是二维数据都是用一维数组存储，
 * 这就要涉及是行主序还是列主序，在C语言中数组是用行主序，fortran中是列主序
 *
 * CblasNoTrans表示矩阵是否转置
 * 不转置则 op(A) = A
 * 转置则   op(A) = A'
 *
 * const int M，矩阵A的行，矩阵C的行
 * const int N，矩阵B的列，矩阵C的列
 * const int K，矩阵A的列，矩阵B的行
 *
 * const float alpha，const float beta，计算公式中的两个参数值
 *
 * const float* A， const float* B， const float* C，矩阵A、B、C的数据
 *
 * const int lda， const int ldb， const int ldc
 * 不转置 ld* = max(1, 列数)
 * 转置   ld* = max(1, 行数)
 */

　　

2.Backward_cpu

conv_layer.cpp

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项，计算Bias导数
    	if (this->bias_term_ && this->param_propagate_down_[1]) {
    		for (int n = 0; n < this->num_; ++n) {
    			this->Backward_cpu_bias(bias_diff, top_diff + n * this->top_dim_);
    		}
    	}

    	// 计算weight
    	// param_propagate_down_定义在layer.hpp中，vector<bool> param_propagate_down_;
    	// 标志该层每个可学习参数blob是否需要计算反向传递的梯度值
    	// param_propagate_down_[0] - weight； param_propagate_down_[1] - bias

    	if (this->param_propagate_down_[0] || propagate_down[i]) {
    		for (int n = 0; n < this->num_; ++n) {
    			// 计算对于权值的梯度
    			if (this->param_propagate_down_[0]) {
    				// weight_diff = bottom_data * top_diff
    				this->weight_cpu_gemm(bottom_data + n * this->bottom_dim_,
    					top_diff + n * this->top_dim_, weight_diff);
    			}
    			// 计算传播到下一层的梯度，即对于下一层来说是top_diff
    			// 对于这个层来说是 bottom_diff
    			if (propagate_down[i]) {
    				// bottom_diff = top_diff * weight
    				// bottom_diff [C_in*H_k*W_k, H_out*W_out]
    				// top_diff    [C_out, H_out*W_out]
    				// weight      [C_out, C_in*H_k*W_K]
    				this->backward_cpu_gemm(top_diff + n * this->top_dim_, weight,
    					bottom_diff _ n * this->bottom_dim_);
    			}
    		}
    	}
    }
}

　　

base_conv_layer.cpp

template <typename Dtype>
void BaseConvolutionLayer<Dtype>::weight_cpu_gemm(const Dtype* input,
    const Dtype* output, Dtype* weights) {
  const Dtype* col_buff = input;

  // 不使用 1*1 卷积
  if (!is_1x1_) {
  	// 矩阵转换
    conv_im2col_cpu(input, col_buffer_.mutable_cpu_data());
    col_buff = col_buffer_.cpu_data();
  }
  // 前向：output = weights * col_buff
  // 反向：weights = output * col_buff^T
  // 这是对滤波器权值求导
  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);
  }
}

　　

base_conv_layer.cpp

template <typename Dtype>
void BaseConvolutionLayer<Dtype>::backward_cpu_gemm(const Dtype* output,
    const Dtype* weights, Dtype* input) {
  Dtype* col_buff = col_buffer_.mutable_cpu_data();

  // 使用1*1卷积
  if (is_1x1_) {
    col_buff = input;
  }

  // 前向：output = weights * col_buff
  // 反向：col_buff = weights^T * output
  // 这是对bottom_data即输入数据求梯度
  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_) {
	// Blob中数据是row-major存储的，W（列）是变化最快的维度
    conv_col2im_cpu(col_buff, input);
  }
}