CNN中的卷積

很多文章都介紹過卷積的操作：用一個小的卷積核在影象上滑動，每次滑動計算出一個值，比如用3*3的卷積核卷積一個5*5的矩陣（不考慮擴充套件邊緣），過程如下：

卷積操作在二維平面上很好理解，但是在CNN中，被卷積的矩陣是有深度的：

這個深度可以類比三通道的RGB影象想象。所以被卷積的矩陣的維度是depth*height*width，那麼針對這樣的矩陣，卷積操作是如何進行的呢？一次卷積涉及到的引數量又是多少呢？

斯坦福的教程裡說：

Every filter is small spatially (along width and height), but extends through the full depth of the input volume.

大致意思就是，每次卷積的操作是在“一小塊兒面積，但是全部深度”上進行的。假如這一層輸入的維度是32*32*3，卷積核的維度是5*5*3（這裡，5*5兩個維度可以隨意設計，但是3是固定的，因為輸入資料的第三維度的值是3），那麼得到的輸入應該是28*28*1的。問題來了，怎麼把立體的卷積成平面了呢？
上邊的操作只使用了一個卷積核，如果使用多個卷積核呢，比如12個？那得到的輸入就是立體的了28*28*12。沒錯，CNN中就是這麼操作的，但是請注意兩個名詞區域性連線和權值共享，關於這兩個詞有很多解釋，這裡不再贅述。

然後來計算一下引數量
還是上邊的例子:32*32*3的輸入，5*5*3的卷積核，需要的引數個數是5*5*3=75.
該層使用12個卷積核的話，總引數個數（沒有算偏置項）5*5*3*12=900.

可以看一下caffe中conv的原始碼：

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

上邊呼叫的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;
  if (!is_1x1_) {
    if (!skip_im2col) {
      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, CblasNoTrans, conv_out_channels_ /
        group_, conv_out_spatial_dim_, kernel_dim_ / group_,
        (Dtype)1., weights + weight_offset_ * g, col_buff + col_offset_ * g,
        (Dtype)0., output + output_offset_ * g);
  }
}

conv_im2col_cpu:貼過來：

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,
    Dtype* data_col) {
  int height_col = (height + 2 * pad_h - kernel_h) / stride_h + 1;
  int width_col = (width + 2 * pad_w - kernel_w) / stride_w + 1;
  int channels_col = channels * kernel_h * kernel_w;
  for (int c = 0; c < channels_col; ++c) {
    int w_offset = c % kernel_w;
    int h_offset = (c / kernel_w) % kernel_h;
    int c_im = c / kernel_h / kernel_w;
    for (int h = 0; h < height_col; ++h) {
      for (int w = 0; w < width_col; ++w) {
        int h_pad = h * stride_h - pad_h + h_offset;
        int w_pad = w * stride_w - pad_w + w_offset;
        if (h_pad >= 0 && h_pad < height && w_pad >= 0 && w_pad < width)
          data_col[(c * height_col + h) * width_col + w] =
            data_im[(c_im * height + h_pad) * width + w_pad];
        else
          data_col[(c * height_col + h) * width_col + w] = 0;
      }
    }
  }
}

`caffe_cpu_gemm“貼過來：

template<>
void caffe_cpu_gemm<double>(const CBLAS_TRANSPOSE TransA,
    const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,
    const double alpha, const double* A, const double* B, const double beta,
    double* C) {
  int lda = (TransA == CblasNoTrans) ? K : M;
  int ldb = (TransB == CblasNoTrans) ? N : K;
  cblas_dgemm(CblasRowMajor, TransA, TransB, M, N, K, alpha, A, lda, B,
      ldb, beta, C, N);
}