1.头文件
先看头文件中,主要是一些声明和变量的定义:
#ifndef CAFFE_BASE_CONVOLUTION_LAYER_HPP_
#define CAFFE_BASE_CONVOLUTION_LAYER_HPP_
#include <vector>
#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/im2col.hpp"
namespace caffe {
/**
* @brief Abstract base class that factors out the BLAS code common to
* ConvolutionLayer and DeconvolutionLayer.
*/
template <typename Dtype>
class BaseConvolutionLayer : public Layer<Dtype> {
public:
explicit BaseConvolutionLayer(const LayerParameter& param)
: Layer<Dtype>(param) {}
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
virtual inline int MinBottomBlobs() const { return 1; }
virtual inline int MinTopBlobs() const { return 1; }
virtual inline bool EqualNumBottomTopBlobs() const { return true; }
protected:
// Helper functions that abstract away the column buffer and gemm arguments.
// The last argument in forward_cpu_gemm is so that we can skip the im2col if
// we just called weight_cpu_gemm with the same input.
void forward_cpu_gemm(const Dtype* input, const Dtype* weights,
Dtype* output, bool skip_im2col = false);
void forward_cpu_bias(Dtype* output, const Dtype* bias);
void backward_cpu_gemm(const Dtype* input, const Dtype* weights,
Dtype* output);
void weight_cpu_gemm(const Dtype* input, const Dtype* output, Dtype*
weights);
void backward_cpu_bias(Dtype* bias, const Dtype* input);
#ifndef CPU_ONLY
void forward_gpu_gemm(const Dtype* col_input, const Dtype* weights,
Dtype* output, bool skip_im2col = false);
void forward_gpu_bias(Dtype* output, const Dtype* bias);
void backward_gpu_gemm(const Dtype* input, const Dtype* weights,
Dtype* col_output);
void weight_gpu_gemm(const Dtype* col_input, const Dtype* output, Dtype*
weights);
void backward_gpu_bias(Dtype* bias, const Dtype* input);
#endif
/// @brief The spatial dimensions of the input.输入的空间维度。
inline int input_shape(int i) {
return (*bottom_shape_)[channel_axis_ + i];
}
// reverse_dimensions should return true iff we are implementing deconv, so
// that conv helpers know which dimensions are which.
virtual bool reverse_dimensions() = 0;
// Compute height_out_ and width_out_ from other parameters.
virtual void compute_output_shape() = 0;
/// @brief The spatial dimensions of a filter kernel.
// 卷积核的形状[kernel_h, kernel_w]
Blob<int> kernel_shape_;
/// @brief The spatial dimensions of the stride.
// 步长形状[stride_h, stride_w]
Blob<int> stride_;
/// @brief The spatial dimensions of the padding.
// padding形状[pad_h, pad_w]
Blob<int> pad_;
/// @brief The spatial dimensions of the dilation.
// 扩张卷积的形状,就是镂空式的卷积
Blob<int> dilation_;
/// @brief The spatial dimensions of the convolution input.
// 卷积的输入形状 = [输入图像通道数, 输入图像h, 输入图像w]
Blob<int> conv_input_shape_;
/// @brief The spatial dimensions of the col_buffer.
// col_buffer的形状 = [kernel_dim_, conv_out_spatial_dim_ ]
// 即将图像转化成利于卷积的展开体col形式(具体参考src/utils/im2col.cpp),存于col_buffer,将 卷积核权值×col_buffer=卷积输出,所以其形状为上述样子。
vector<int> col_buffer_shape_;
/// @brief The spatial dimensions of the output.层输出的形状,存在vector里
vector<int> output_shape_;
// 层输入的形状,存在vector里,返回指针,因为是别的层的输出,直接用指针指向之前已经存在的上一层的output_shape_。
const vector<int>* bottom_shape_;
// 空间轴个数,就是输入是几维图像
int num_spatial_axes_;
// 输入度维度 = 输入通道数*输入图像的h*输入图像的w
int bottom_dim_;
// 输出维度 = 输出通道数*输出图像的h*输出图像的w
int top_dim_;
// 输入图像的哪个axis是channel,一般是第二个维度
int channel_axis_;
// 堆大小
int num_;
// 通道数
int channels_;
// 卷积组的大小
int group_;
// 输出空间维度 = 卷积之后的图像长*卷积之后图像的宽
int out_spatial_dim_;
// 使用卷积组用到的权值偏置
int weight_offset_;
// 卷积后的图像的通道数
int num_output_;
// 是否启用偏置
bool bias_term_;
// 是否是1x1卷积
bool is_1x1_;
// 强制使用n维通用卷积,即im2col的n维形式,而不是更常用的二维形式。
bool force_nd_im2col_;
private:
// wrap im2col/col2im so we don't have to remember the (long) argument lists
// 将im2col/col2im封装,就不用自己来输入这么长的输入列表了。
//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)
inline void conv_im2col_cpu(const Dtype* data, Dtype* col_buff) {
if (!force_nd_im2col_ && num_spatial_axes_ == 2) {
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);
}
}
inline void conv_col2im_cpu(const Dtype* col_buff, Dtype* data) {
if (!force_nd_im2col_ && num_spatial_axes_ == 2) {
col2im_cpu(col_buff, 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], data);
} else {
col2im_nd_cpu(col_buff, 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(), data);
}
}
#ifndef CPU_ONLY
inline void conv_im2col_gpu(const Dtype* data, Dtype* col_buff) {
if (!force_nd_im2col_ && num_spatial_axes_ == 2) {
im2col_gpu(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_gpu(data, num_spatial_axes_, num_kernels_im2col_,
conv_input_shape_.gpu_data(), col_buffer_.gpu_shape(),
kernel_shape_.gpu_data(), pad_.gpu_data(),
stride_.gpu_data(), dilation_.gpu_data(), col_buff);
}
}
inline void conv_col2im_gpu(const Dtype* col_buff, Dtype* data) {
if (!force_nd_im2col_ && num_spatial_axes_ == 2) {
col2im_gpu(col_buff, 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], data);
} else {
col2im_nd_gpu(col_buff, num_spatial_axes_, num_kernels_col2im_,
conv_input_shape_.gpu_data(), col_buffer_.gpu_shape(),
kernel_shape_.gpu_data(), pad_.gpu_data(), stride_.gpu_data(),
dilation_.gpu_data(), data);
}
}
#endif
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_;
};
} // namespace caffe
#endif // CAFFE_BASE_CONVOLUTION_LAYER_HPP_
这里着重介绍了变量的意义,便于后面cpp的阅读,这里着重介绍一下比较陌生的caffe group参数:
caffe Convolution层的convolution_param参数字典中有一个group参数,其意思是将输入channel和该层卷积核进行分组,每个group中的卷积核只对本group对应channel的特征图进行卷积操作:
比如输入数据大小为128x32x100x100,其中128是batchsize,100x100是图像高、宽,32是channel数量,要经过一个3x3x48的卷积,group默认是1,就是48个卷积滤波器都直接在32个通道上操作,即每个滤波器的权值是3x3x32。
但当group>1,那么限制每个滤波器只与输入的子集连接,比如说,group是2时,也就是将输入的32个通道分成2个16的通道,将输出的48个通道分成2个24的通道,并且第一组24个卷积滤波器与输入的第一个16通道进行卷积,同样第二组24个卷积滤波器与输入的第一个16通道进行卷积,也就是说这时每个滤波器权值为3x3x16。
If g > 1, we restrict the connectivity of each filter to a subset of the input. Specifically, the input and output channels are separated into g groups, and the i-th output group channels will be only connected to the i-th input group channels.
2.im2col
此外,这里简要解释一下caffe的im2col方法,将图像矩阵的卷积运算通过im2col转化为高效的矩阵乘法运算。
简单来讲,图像的卷积操作,就是滤波器算子逐个区域扫描图像的过程,在每个区域内都是滤波器权值和图像块像素值之间的简单的数乘,因此,可以把每个图像块展成一列,将滤波器展成一行,进行矩阵乘法,实现卷积操作,如下图所示:
基本上就是Filter Matrix乘以Feature Matrix的转置,得到输出矩阵Cout x (H x W),就可以解释为输出的三维Blob(Cout x H x W)
这张图可能更清楚:
上图中,三通道的input featurs的每个被卷积的图像块按照卷积扫描顺序,展开成一个矩阵,通用,卷积核滤波器也是如此,然后进行矩阵乘法,得到输出特征图。
3.LayerSetup
#include <algorithm>
#include <vector>
#include "caffe/filler.hpp"
#include "caffe/layers/base_conv_layer.hpp"
#include "caffe/util/im2col.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void BaseConvolutionLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
// Configure the kernel size, padding, stride, and inputs.
// 根据protobuf中的层参数设置,配置卷积核的大小,padding,步长和输入等等。
ConvolutionParameter conv_param = this->layer_param_.convolution_param();
force_nd_im2col_ = conv_param.force_nd_im2col();//根据层参数设置设置是否强制进行n维im2col
//下面的函数定义于blob.hpp,用于检查输入index是否在范围内,并支持输入负数反向索引,输出正数正向索引,
//确定哪个维度是channel,一般是,batch*channel*height*width,第二个维度。
channel_axis_ = bottom[0]->CanonicalAxisIndex(conv_param.axis());
//channel后紧跟的就是图像高、宽这种空间轴,第一个空间轴是第几维自然就是+1
const int first_spatial_axis = channel_axis_ + 1;
const int num_axes = bottom[0]->num_axes();//数据的axis数量
num_spatial_axes_ = num_axes - first_spatial_axis;//图像空间轴(h,w)的个数,即是几维图像
CHECK_GE(num_spatial_axes_, 0);
//当num_spatial_axes_==2时,spatial_dim_blob_shape这个vector只包含一个元素且值为2
vector<int> spatial_dim_blob_shape(1, std::max(num_spatial_axes_, 1));
// Setup filter kernel dimensions (kernel_shape_).
// 调用blob.cpp里的 void Blob<Dtype>::Reshape(const vector<int>& shape)
//以spatial_dim_blob_shape为参数来构造一个Blob,即kernel_shape_,则这个Blob的维度信息只包含一个维度,值为2,
//也就是说这个Blob的count_==2。尽管这个Blob的维度信息只包含一个维度,只有两个数。
//因为在后续的计算(Im2col)中,我只关心这个Blob中的数据的值,而不关心这个Blob的shape信息.
//例如在Im2col()中,只要取出相应数值即可kernel_shape_.cpu_data()[0], kernel_shape_.cpu_data()[1]。
kernel_shape_.Reshape(spatial_dim_blob_shape);
int* kernel_shape_data = kernel_shape_.mutable_cpu_data();
// 若层参数中有定义卷积核宽或高,则将其存入kernel_shape_data这一blob中
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.";
kernel_shape_data[0] = conv_param.kernel_h();
kernel_shape_data[1] = conv_param.kernel_w();
} else {
// 若层参数中没有定义卷积核宽和高,则根据卷积核的维度数来确定。哪一维核大小就附几
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_,pad_,dilation_这些blob的设定也类似。
// Setup stride dimensions (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.";
}
}
// Setup pad dimensions (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);
}
}
// Setup dilation dimensions (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);
}
// Special case: im2col is the identity for 1x1 convolution with stride 1
// and no padding, so flag for skipping the buffer and transformation.
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; }
}
// Configure output channels and groups.
channels_ = bottom[0]->shape(channel_axis_);//根据channel的维度索引找数据blob的channel数。
num_output_ = this->layer_param_.convolution_param().num_output();
CHECK_GT(num_output_, 0);
group_ = this->layer_param_.convolution_param().group();
//输入、输出 channel 个数必须为group的整数倍,每个group中的卷积核只对本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] holds the filter weights
// - blobs_[1] holds the biases (optional)
//权值形状:(conv_out_channels_,conv_in_channels_ / group_,kernel_h, kernel_w),如:256*256*3*3
vector<int> weight_shape(2);
weight_shape[0] = conv_out_channels_;
//每个group中的卷积核只对本group对应频道的特征图进行卷积操作,即上文中描述的3x3x32和3x3x16的区别(group的影响)
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);
}
// Initialize and fill the weights:
// output channels x input channels per-group x kernel height x kernel width
// 按照获取的形状初始化并填入权值,形状:输出通道数×每组输入通道数×卷积核高度×卷积核宽度
this->blobs_[0].reset(new Blob<Dtype>(weight_shape));
// 根据protobuf里设置的滤波器权值初始方法(constant,xavier等)进行初始化。
shared_ptr<Filler<Dtype> > weight_filler(GetFiller<Dtype>(
this->layer_param_.convolution_param().weight_filler()));
weight_filler->Fill(this->blobs_[0].get());//将blob_中的参数填入weight_filler
// If necessary, initialize and fill the biases.
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_;//写成(conv_out_channels_ / group_) * kernel_dim_更直观。
// Propagate gradients to the parameters (as directed by backward pass).
this->param_propagate_down_.resize(this->blobs_.size(), true);
}
这个函数主要是根据protobuf中的层参数设置,配置卷积核的大小,padding,步长和输入、权值参数初始化等等。是层建立的基础,是大多层建立的第一步,层参数设置及初始化。
5.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;
CHECK_EQ(bottom[0]->num_axes(), first_spatial_axis + num_spatial_axes_)
<< "bottom num_axes may not change.";
num_ = bottom[0]->count(0, channel_axis_);//统计输入特征图数量batch_size*channel_num
CHECK_EQ(bottom[0]->shape(channel_axis_), channels_)
<< "Input size incompatible with convolution kernel.";
// TODO: generalize to handle inputs of different shapes.一般化来适应不同形状的输入。
// 检查所有bottom blob形状一致
for (int bottom_id = 1; bottom_id < bottom.size(); ++bottom_id) {
CHECK(bottom[0]->shape() == bottom[bottom_id]->shape())
<< "shape mismatch - bottom[0]: " << bottom[0]->shape_string()
<< " vs. bottom[" << bottom_id << "]: "
<< bottom[bottom_id]->shape_string();
}
// Shape the tops.根据bottom形状,计算输出top blob形状(batch_size, channel_out, out_h, out_w,...)
bottom_shape_ = &bottom[0]->shape();
compute_output_shape();//虚函数,需要重写来确定具体输出形状
//复制[begin,end)区间内另一个数组(描述bottom形状)的元素到该vector中,左闭右开,如果是blob是b*c*h*w,就只复制过来了b。
vector<int> top_shape(bottom[0]->shape().begin(),
bottom[0]->shape().begin() + channel_axis_);
top_shape.push_back(num_output_);
for (int i = 0; i < num_spatial_axes_; ++i) {
top_shape.push_back(output_shape_[i]);
}
// 按得到的top_shape创建top blob,并调整其形状,为其开辟空间等。
for (int top_id = 0; top_id < top.size(); ++top_id) {
top[top_id]->Reshape(top_shape);
}
// 从channel后开始统计输出特征图大小,h*w*...
if (reverse_dimensions()) {
conv_out_spatial_dim_ = bottom[0]->count(first_spatial_axis);
} else {
conv_out_spatial_dim_ = top[0]->count(first_spatial_axis);
}
//卷积窗口在输入“图像”上按步长滑动,形成了多个子图;然后将所有子图拉成一列,列的长度就是col_offset_。
//col_offset_与im2col_cpu()函数中channels_col的计算是相似的,但是值并不相等,
//原因在于:channels_col是将卷积层输入的通道数conv_in_channels_用于相乘,
//但kernel_dim_只用到了一部分channel,即conv_in_channels_/group_ 。
col_offset_ = kernel_dim_ * conv_out_spatial_dim_;
//卷积层的输出特征图也要分组,当然group_默认为1。写成(conv_out_channels_ / group_) * 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);//获取每个图的维度数,二维图有三个维度:channel,h,w
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);
}
}
// The im2col result buffer will only hold one image at a time to avoid
// overly large memory usage. In the special case of 1x1 convolution
// it goes lazily unused to save memory.
// 每次只im2col转化一张图。
col_buffer_shape_.clear();//col_buffer_shape_是一个vector
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_内所存储的数据的维度为:(kernel_dim_ * group_) × H × W.
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_;
// Set up the all ones "bias multiplier" for adding biases by BLAS
out_spatial_dim_ = top[0]->count(first_spatial_axis);
if (bias_term_) {
vector<int> bias_multiplier_shape(1, out_spatial_dim_);
//bias_multiplier_这个Blob的count_为out_spatial_dim_,是输出特征图的H×W
bias_multiplier_.Reshape(bias_multiplier_shape);
caffe_set(bias_multiplier_.count(), Dtype(1),
bias_multiplier_.mutable_cpu_data());
}
}
reshape函数主要是:根据bottom形状,计算输出top blob形状;计算im2col及反向的一些参数。
5.forward_cpu_gemm
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;
// 如果没有1x1卷积,也没有skip_im2col
// 则使用conv_im2col_cpu对使用卷积核滑动过程中的每一个kernel大小的图像块
// 变成一个列向量,形成一个height=kernel_dim_的
// width = 卷积后图像height*卷积后图像width
if (!is_1x1_) {
if (!skip_im2col) {
conv_im2col_cpu(input, col_buffer_.mutable_cpu_data());
}
col_buff = col_buffer_.cpu_data();
}
// caffe_cpu_gemm就是调用cblas_sgemm函数进行矩阵乘法运算
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_channels_ /group_) x kernel_dim_
// weights的形状是 [conv_out_channel x kernel_dim_]
// col_buff相当于数据,它的形状是[kernel_dim_ x (卷积后图像高度*卷积后图像宽度)]=
// kernel_dim_ x conv_out_spatial_dim_
// 所以output的形状自然就是conv_out_channel X (卷积后图像高度*卷积后图像宽度)=
// (conv_out_channels_ /group_) x conv_out_spatial_dim_
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);
}
}
前向、反向传播计算大致就两步:用im2col函数展成矩阵,调用cblas_sgemm函数进行矩阵乘法运算。
之前的所有都是准备参数,用于输出这两个函数的。这里仅仅用一个做例子,其他都类似。