@(Caffe源码-im2col操作)

im2col简介

caffe的卷积操作中使用im2col来加速，im2col将卷积核中的每个点在图像上的对应点全都提取出来按行排列，得到一个矩阵，这样就将卷积操作转化为矩阵进行操作。

如上图所示的，假设输入图像的形状为channels=1, height=width=5，并且pad_w=pad_h=1, kernel_h=kernel_w=3, stride_h=stride_w=2, dilation_w=dilation_h=1。左侧图中蓝色为padding补充的边界，值均为0，绿色为实际图像的数据。其中卷积核中\(k_{00}\)位置在整个卷积操作中共计算了output_h*output_w=9次，每次的位置在左侧图中用黑色实心圆标注出来。而im2col操作即是将卷积核上的每个点的这些对应位置上的值都提取出来，按照右侧黄色方格的形式存放起来。这样卷积操作可简单地通过将卷积核（中间的红色方格）展成一个向量，然后与右侧的黄色方格矩阵中的每一列点乘来实现。更详细的说明可查看后面列出来的参考博客。
与im2col对应的是col2im操作，即是将矩阵还原成卷积前的图像的形状，不过caffe代码中的col2im_cpu()函数还稍微有些改动。

im2col.cpp源码

// Function uses casting from int to unsigned to compare if value of
// parameter a is greater or equal to zero and lower than value of
// parameter b. The b parameter is of type signed and is always positive,
// therefore its value is always lower than 0x800... where casting
// negative value of a parameter converts it to value higher than 0x800...
// The casting allows to use one condition instead of two.
inline bool is_a_ge_zero_and_a_lt_b(int a, int b) {
  return static_cast<unsigned>(a) < static_cast<unsigned>(b);
}

// data_im为输入的图像数据,单个图像数据,num=1, data_col为转化后的矩阵
// channels/height/width为图像的通道数/高度/宽度
// kernel_h/kernel_w为卷积核的高度/宽度
// pad_h/pad_w为卷积时图像的高度和宽度方向的边界补充大小
// stride_h/stride_w为卷积时高度和宽度方向的步进大小
// dilation_h/dilation_w为卷积时卷积核的空洞系数
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) {
  //(dilation_h * (kernel_h - 1) + 1)和(dilation_w * (kernel_w - 1) + 1)为带上空洞系数的卷积核的尺寸 
  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;    //输入图像的每个通道的大小
  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++) {   //处理卷积核的每列
        //开始计算卷积核的(kernel_row, kernel_col)点在输入图像的所有对应位置(input_row, input_col),
        //并将输入图像该位置的值存入data_col中,如果(kernel_row, kernel_col)点对应输入图像的padding位置,则存入0
        //卷积核上的每个点都有 output_h * output_w 个对应位置,输入图像的每行有output_w个对应位置,共output_h行

        int input_row = -pad_h + kernel_row * dilation_h;   //第一次卷积时卷积核的该点对应输入图像的第input_row行
        // output_rows在循环体中并没有使用,所以此处是从output_h减至0还是从0增至output_h的效果是一样的
        for (int output_rows = output_h; output_rows; output_rows--) {  //处理该点在输入图像每一行的对应位置
          //不满足0 ≤ input_row < height,则在此处卷积时卷积核的第kernel_row行对应着输入图像的边界之外的第input_row行
          if (!is_a_ge_zero_and_a_lt_b(input_row, height)) {
            //卷积核的该点对应输入图像的边界外的行,则计算输出图像时,整行的对应位置都应在边界外,整行一共有output_w个对应位置
            for (int output_cols = output_w; output_cols; output_cols--) {
              *(data_col++) = 0;    //全部置为0
            }
          } else {    //卷积核的该点在图像内部
            int input_col = -pad_w + kernel_col * dilation_w; //第一次卷积时卷积核的该点对应输入图像的第input_col列
            for (int output_col = output_w; output_col; output_col--) { //处理该点在输入图像每一列的对应位置
              if (is_a_ge_zero_and_a_lt_b(input_col, width)) {    //同样判断对应位置的列是否在图像边界外
                *(data_col++) = data_im[input_row * width + input_col]; //图像内部,则将输入图像(input_row, input_col)处的值存入
              } else {
                *(data_col++) = 0;    //(input_row, input_col)在图像外,存入0
              }
              input_col += stride_w;  //循环,宽度方向上的移动,卷积核的该点每次对应输入图像的(input_row, input_col)位置
            }
          }
          input_row += stride_h;      //循环,高度方向上的移动,每次对应输入图像的(input_row, input_col)位置
        }
      }
    }
  }
}

// Explicit instantiation
template void im2col_cpu<float>(const float* 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,
    float* data_col);
template void im2col_cpu<double>(const double* 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,
    double* data_col);

//col_shape的值为[k_dim0*k_dim1*...*channel_in, col_dim0, col_dim1, ...]
//[col_dim0, col_dim1, ...]为卷积操作之后的图像的各个维度的大小
template <typename Dtype>
inline void im2col_nd_core_cpu(const Dtype* data_input, const bool im2col,
    const int num_spatial_axes, const int* im_shape, const int* col_shape,
    const int* kernel_shape, const int* pad, const int* stride,
    const int* dilation, Dtype* data_output) {
  //*_dim0表示第0维的大小,dim0_?表示第0维上的位置?
  if (!im2col) {    //不是image to column,则是column to image
    int im_size = im_shape[0];
    for (int i = 0; i < num_spatial_axes; ++i) {
      im_size *= im_shape[1 + i];   //计算图像的大小,im_dim0*im_dim1*...
    }
    caffe_set(im_size, Dtype(0), data_output);    //数据先清空
  }
  //kernel_shape中存放着卷积核中参与卷积的各个维度的值[k_dim0,k_dim1,...]
  //在2Dconv中, num_spatial_axes=2, H*W维度参与卷积, 卷积核在C维度上累加, 则kernel_shape为H*W
  int kernel_size = 1;
  for (int i = 0; i < num_spatial_axes; ++i) {
    kernel_size *= kernel_shape[i]; //单个通道的卷积核的大小k_dim0*k_dim1*...
  }
  //col_buf中的第0维等于卷积核的大小乘上输入图像的通道数,后面几维为输出图像参与卷积的那几维的大小
  const int channels_col = col_shape[0];      //col_buf的第0维的大小col_dim0
  //col_buf中的(c_col, out_dim0?, out_dim1?, ...)的位置存放着卷积核的(out_num?, im_channel?, d_offset[0], d_offset[1], ...)点对应的所有输入图像的值
  vector<int> d_offset(num_spatial_axes, 0);  //num_spatial_axes大小的向量,初始为0
  vector<int> d_iter(num_spatial_axes, 0);
  for (int c_col = 0; c_col < channels_col; ++c_col) {      //c_col即为单个卷积核上的每一个点
    // Loop over spatial axes in reverse order to compute a per-axis offset.
    int offset = c_col;
    for (int d_i = num_spatial_axes - 1; d_i >= 0; --d_i) { //从末尾维(如2D卷积的W维)开始计算
      if (d_i < num_spatial_axes - 1) {
        offset /= kernel_shape[d_i + 1];  //除以第d_i + 1维的大小,得到点c_col在第0维到第d_i维之间的索引
      }
      d_offset[d_i] = offset % kernel_shape[d_i]; //得到点c_col在第d_i维的位置,存入d_offset中
    }
    //卷积核的(out_num?, im_channel?, d_offset[0], d_offset[1], ...)点对应卷积核的点c_col,
    //但是此处还只是计算了参与卷积的几个维度d_offset[...], 点c_col中还包含了在卷积核累加的维度上的索引im_channel?
    for (bool incremented = true; incremented; ) {
      // Loop over spatial axes in forward order to compute the indices in the
      // image and column, and whether the index lies in the padding.
      int index_col = c_col;
      //判断index_col的含义时可将下面的代码单独抽离出来, index_col = (...((c_col * col_dim1 + d0) * col_dim2 + d1) * ... + ...)
      // for (int d_i = 0; d_i < num_spatial_axes; ++d_i) {
      //   const int d = d_iter[d_i];
      //   index_col *= col_shape[d_i + 1];
      //   index_col += d;
      // }

      int index_im = c_col / kernel_size;   //得到点c_col中在卷积核累加的维度上的索引im_channel的确切值
      bool is_padding = false;
      for (int d_i = 0; d_i < num_spatial_axes; ++d_i) {
        const int d = d_iter[d_i];          //整个卷积核在第d_i维度的移动位置
        //得到点c_col在卷积输入图像中第d_i维度上的索引d_im
        const int d_im = d * stride[d_i] - pad[d_i] + d_offset[d_i] * dilation[d_i];
        is_padding |= d_im < 0 || d_im >= im_shape[d_i + 1];  //存在任何超出边界的点,则is_padding为true
        index_col *= col_shape[d_i + 1];  //col_shape[1],col_shape[2]...为col_buf中图像的维度的大小
        index_col += d;                   //再加上位置,最终index_col为在d_iter表示的图像位置卷积时卷积核上的点c_col在col_buf中的索引
        index_im *= im_shape[d_i + 1];
        index_im += d_im;   //最终index_im为在d_iter表示的图像位置卷积时卷积核上的点c_col对应的图像点的索引
      }
      if (im2col) {         //图像转矩阵
        if (is_padding) {
          data_output[index_col] = 0;   //点c_col此次卷积时超出图像,则col_buf中置为0
        } else {
          data_output[index_col] = data_input[index_im];  //设置col_buf的值
        }
      } else if (!is_padding) {  // col2im  //矩阵转图像,并且未在图像边界外,则设置im_buf的值
        data_output[index_im] += data_input[index_col];
      }
      // Loop over spatial axes in reverse order to choose an index, like counting.
      incremented = false;
      //判断下一次卷积位置在各维度中的值,即d_iter中的值.如果卷积位置到了某一维度的末尾,则重新置为0,并且在下一维度上的值自增.
      //如果下一维度同样已经到了末尾,则在下下一维自增,如此重复,直至最终某一维位置自增了.
      //如果所有的维度都已经到了末尾位置,则自增标志incremented为false,则说明点c_col对应的各个图像位置都已经判断完毕
      for (int d_i = num_spatial_axes - 1; d_i >= 0; --d_i) {
        const int d_max = col_shape[d_i + 1];   //col_shape的第d_i + 1维对应卷积输出图像的第d_i维的大小
        //d_iter是卷积核在第d_i维度的移动位置,每个位置也即是输出图像上的一个点
        DCHECK_LT(d_iter[d_i], d_max);    //小于该维度的最大值
        if (d_iter[d_i] == d_max - 1) {
          d_iter[d_i] = 0;                //到了末尾,则该维度重新置为0
        } else {  // d_iter[d_i] < d_max - 1
          ++d_iter[d_i];                  //该维度不在末尾,则该维度自增
          incremented = true;             //设置标志,已自增.如果
          break;                          //退出
        }
      }
    }  // while(incremented) {
  }  // for (int c = 0; c < channels_col; ++c) {
}

template <typename Dtype>
void im2col_nd_cpu(const Dtype* data_im, const int num_spatial_axes,
    const int* im_shape, const int* col_shape,
    const int* kernel_shape, const int* pad, const int* stride,
    const int* dilation, Dtype* data_col) {
  const bool kIm2Col = true;
  im2col_nd_core_cpu(data_im, kIm2Col, num_spatial_axes, im_shape, col_shape,
                  kernel_shape, pad, stride, dilation, data_col);
}

// Explicit instantiation
template void im2col_nd_cpu<float>(const float* data_im,
    const int num_spatial_axes,
    const int* im_shape, const int* col_shape,
    const int* kernel_shape, const int* pad, const int* stride,
    const int* dilation, float* data_col);
template void im2col_nd_cpu<double>(const double* data_im,
    const int num_spatial_axes,
    const int* im_shape, const int* col_shape,
    const int* kernel_shape, const int* pad, const int* stride,
    const int* dilation, double* data_col);

//矩阵转图像,data_col为矩阵,形状为[kernel_h*kernel_w*channels, output_h*output_w]
//data_im为卷积前的图像,形状为[channels, height, width]
template <typename Dtype>
void col2im_cpu(const Dtype* data_col, 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_im) {
  caffe_set(height * width * channels, Dtype(0), data_im);    //先将图像数据清零
  //计算卷积后的图像的宽高
  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;    //卷积前图像的单个通道的大小
  
  for (int channel = channels; channel--; data_im += channel_size) {    //处理每个通道
    for (int kernel_row = 0; kernel_row < kernel_h; kernel_row++) {     //处理卷积核的第kernel_row行
      for (int kernel_col = 0; kernel_col < kernel_w; kernel_col++) {   //处理卷积核的第kernel_col列
        //data_col的第0维的大小维kernel_h*kernel_w*channels,所以此处的三个循环相当于是处理data_col的第0维的每个数据
        //假设是处理data_col的第0维的第kernel_idx个数据, kernel_idx = (channel * kernel_h + kernel_row) * kernel_w + kernel_col
        //同时第kernel_idx个数据也对应卷积核中的点(1, channel, kernel_row, kernel_col)点
        int input_row = -pad_h + kernel_row * dilation_h;   //卷积核的该点在初次卷积时对应卷积前图像的第input_row行
        for (int output_rows = output_h; output_rows; output_rows--) {
          if (!is_a_ge_zero_and_a_lt_b(input_row, height)) {  //input_row不在[0,height)之间,即对应图像的padding位置
            data_col += output_w;   //则一整列都会在图像边界外,直接跳过整行的数据
          } else {
            int input_col = -pad_w + kernel_col * dilation_w; //卷积核的该点在初次卷积时对应卷积前图像的第input_col列
            for (int output_col = output_w; output_col; output_col--) {
              if (is_a_ge_zero_and_a_lt_b(input_col, width)) {  //input_col不在[0,width)之间,直接跳过,否则将
                //注意,此处是累加.所以如果卷积前图像的某个点被多次用于卷积操作时,其数值是会累加的
                data_im[input_row * width + input_col] += *data_col;
              }
              data_col++;   //下一个
              input_col += stride_w;  //卷积核的该点在下一次卷积时的图像位置
            }
          }
          input_row += stride_h;  //卷积核的该点在下一次卷积时的图像位置
        }
      }
    }
  }
}

// Explicit instantiation
template void col2im_cpu<float>(const float* data_col, 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,
    float* data_im);
template void col2im_cpu<double>(const double* data_col, 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,
    double* data_im);

template <typename Dtype>
void col2im_nd_cpu(const Dtype* data_col, const int num_spatial_axes,
    const int* im_shape, const int* col_shape,
    const int* kernel_shape, const int* pad, const int* stride,
    const int* dilation, Dtype* data_im) {
  const bool kIm2Col = false;
  im2col_nd_core_cpu(data_col, kIm2Col, num_spatial_axes, im_shape, col_shape,
                     kernel_shape, pad, stride, dilation, data_im);
}

// Explicit instantiation
template void col2im_nd_cpu<float>(const float* data_col,
    const int num_spatial_axes,
    const int* im_shape, const int* col_shape,
    const int* kernel_shape, const int* pad, const int* stride,
    const int* dilation, float* data_im);
template void col2im_nd_cpu<double>(const double* data_col,
    const int num_spatial_axes,
    const int* im_shape, const int* col_shape,
    const int* kernel_shape, const int* pad, const int* stride,
    const int* dilation, double* data_im);

小结

注意代码中col2im_cpu()函数与im2col_cpu()函数不是严格的逆操作。如果图像的某个点在卷积时被多次使用过，那么在矩阵转为图像时该位置的图像值同样会被多次累加（应该是为了方便计算卷积层反传时的梯度，不过笔者还未看这部分），所以还原的图像并不是真实的卷积前的图像。im2col_nd_core_cpu()函数中也是如此。
im2col_nd_core_cpu()函数实现了高维卷积的数据转矩阵操作，高维卷积中除了用于计算卷积值的那几个维度（卷积核也在这些维度上移动），还有一个更高维的维度用于累加卷积核，类似于2维卷积中的channel维度。
im2col.cpp文件中的这几个函数与caffe关联较少，可自己写个demo测试各个函数的功能以及单步调试，方便理解。