for w in 1..Wfor h in 1..Hfor x in 1..Kfor y in 1..Kfor m in 1..Mfor d in 1..Doutput(w, h, m) += input(w+x, h+y, d) * filter(m, x, y, d)endendendendend
end

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) {//输入为data_im，kernel_h，kernel_w以及各类卷积参数，输出就是data_col。//out_put_h，out_put_w，是输出的图像尺寸。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;//外层channel循环不管for (int channel = channels; channel--; data_im += channel_size) {//这是一个关于kernel_row和kernel_col的2层循环 for (int kernel_row = 0; kernel_row < kernel_h; kernel_row++) {
for (int kernel_col = 0; kernel_col < kernel_w; kernel_col++) {int input_row = -pad_h + kernel_row * dilation_h;//这是一个关于output_h和output_w的循环，这实际上就是上图例子中每一行的数据 for (int output_rows = output_h; output_rows; output_rows--) {//边界条件属特殊情况，可以细下推敲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 {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)) {
//这就是核心的赋值语句，按照循环的顺序，我们可以知道是按照输出output_col*output_h的尺寸，一截一截地串接成了一个col。*(data_col++) = data_im[input_row * width + input_col];} else {*(data_col++) = 0;}input_col += stride_w;}}input_row += stride_h;}}}}
}

/// @brief The spatial dimensions of a filter kernel.
Blob<int> kernel_shape_;/// @brief The spatial dimensions of the stride.Blob<int> stride_;/// @brief The spatial dimensions of the padding.Blob<int> pad_;/// @brief The spatial dimensions of the dilation.Blob<int> dilation_;/// @brief The spatial dimensions of the convolution input.Blob<int> conv_input_shape_;/// @brief The spatial dimensions of the col_buffer.vector<int> col_buffer_shape_;/// @brief The spatial dimensions of the output.
vector<int> output_shape_;const vector<int>* bottom_shape_;int num_spatial_axes_;int bottom_dim_;int top_dim_;int channel_axis_;int num_;int channels_;int group_;int out_spatial_dim_;int weight_offset_;int num_output_;bool bias_term_;bool is_1x1_;bool force_nd_im2col_;int num_kernels_im2col_;int num_kernels_col2im_;int conv_out_channels_;int conv_in_channels_;int conv_out_spatial_dim_;int kernel_dim_;int col_offset_;int output_offset_;Blob<Dtype> col_buffer_;Blob<Dtype> bias_multiplier_;

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 axisconst 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);}
}

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);}}}
}

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=kernel_dim_的    // width = 卷积后图像heght*卷积后图像width   conv_im2col_cpu(input, col_buffer_.mutable_cpu_data());}col_buff = col_buffer_.cpu_data();}// 使用caffe的cpu_gemm来进行计算  // 假设输入是20个feature map，输出是10个feature map，group_=2// 那么他就会把这个训练网络分解成两个10->5的网络，由于两个网络结构是// 一模一样的，那么就可以利用多个GPU完成训练加快训练速度for (int g = 0; g < group_; ++g) {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 <--- blobs_[0]->cpu_data()。类比全连接层，//weights为权重，col_buff相当与数据，矩阵相乘weights×col_buff. //其中，weights的维度为(conv_out_channels_ /group_) x kernel_dim_，//col_buff的维度为kernel_dim_ x conv_out_spatial_dim_， //output的维度为(conv_out_channels_ /group_) x conv_out_spatial_dim_.}
}

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_);}}}}

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();if (is_1x1_) {col_buff = input;}for (int g = 0; g < group_; ++g) {caffe_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans, kernel_dim_ / group_,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);

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

template <typename Dtype>
void DeconvolutionLayer<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->backward_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);}}}
}

template <typename Dtype>
void DeconvolutionLayer<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(top_diff + n * this->top_dim_,bottom_data + n * this->bottom_dim_, weight_diff);}// Gradient w.r.t. bottom data, if necessary, reusing the column buffer// we might have just computed above.if (propagate_down[i]) {this->forward_cpu_gemm(top_diff + n * this->top_dim_, weight,bottom_diff + n * this->bottom_dim_,this->param_propagate_down_[0]);}}}

const int num_output = this->layer_param_.inner_product_param().num_output();
K_ = bottom[0]->count(axis);// Initialize the weightsvector<int> weight_shape(2);if (transpose_) {weight_shape[0] = K_;weight_shape[1] = N_;} else {weight_shape[0] = N_;weight_shape[1] = K_;}