【darknet】源码阅读理解（三）——CNN前向传播

这里以Code，原理相结合的方式

1. darknet中CNN关键代码

1. 
    int m = l.n/l.groups;                               // 输出通道
    int k = l.size*l.size*l.c/l.groups;                 // img2col后图像矩阵的行数
    int n = l.out_w*l.out_h;                            // img2col后图像矩阵的列数
    for(i = 0; i < l.batch; ++i){                       // batch最外层循环， 一张图片一张图片的计算
        for(j = 0; j < l.groups; ++j){
            float *a = l.weights + j*l.nweights/l.groups;   // 卷积核的参数：fread(l.weights, sizeof(float), num, fp);
            float *b = net.workspace;
            float *c = l.output + (i*l.groups + j)*n*m;     // c作为单层layer的输出
            float *im =  net.input + (i*l.groups + j)*l.c/l.groups*l.h*l.w;     // net->input = input，就是图像数据

            if (l.size == 1) {
                b = im;
            } else {
                im2col_cpu(im, l.c/l.groups, l.h, l.w, l.size, l.stride, l.pad, b);     // b作为img2col的容器//img转成矩阵
            }
            gemm(0,0,m,n,k,1,a,k,b,n,1,c,n);                // c作为输出结果的容器，图像矩阵和卷积核矩阵的乘法，第一个conv为：32*27（卷积核）* 27*369664（图像）的矩阵乘法=32*369664
        }
    }



2. 
void im2col_cpu(float* data_im,
     int channels,  int height,  int width,
     int ksize,  int stride, int pad, float* data_col) 
{
    int c,h,w;          //输入特征图转化得到的矩阵尺度 = (卷积组输入通道数*卷积核高*卷积核宽) * (卷积层输出单通道特征图高 * 卷积层输出单通道特征图宽)
    int height_col = (height + 2*pad - ksize) / stride + 1;         // 高度方向计算几次卷积
    int width_col = (width + 2*pad - ksize) / stride + 1;           // 宽度方向计算几次卷积

    int channels_col = channels * ksize * ksize;            // 输入矩阵展开//卷积核大小和通道数
    for (c = 0; c < channels_col; ++c) {                    // 输出为：（输入通道*kh*kw）*卷积滑动的次数//多通道img2col的第一行
        int w_offset = c % ksize;                           // 卷积核的索引            // 卷积核的宽度方向index
        int h_offset = (c / ksize) % ksize;                 // 多通道img2col          // 卷积核的高度方向index
        int c_im = c / ksize / ksize;                       // 图像上的第index个通道   // 卷积核的通道方向的index
        for (h = 0; h < height_col; ++h) {                  // 高度方向计算几次卷积  和卷积的计算方式，只是值相同，无任何相关意义
            for (w = 0; w < width_col; ++w) {               // 宽度方向计算几次卷积
                int im_row = h_offset + h * stride;         // 第几次卷积所需要的图像数据索引，行方向
                int im_col = w_offset + w * stride;         // 列方向
                int col_index = (c * height_col + h) * width_col + w;       // img2col之后，列项的索引
                data_col[col_index] = im2col_get_pixel(data_im, height, width, channels,
                        im_row, im_col, c_im, pad);
            }
        }
    }
}


3.
void gemm_nn(int M, int N, int K, float ALPHA, 
        float *A, int lda,      // A卷积核32*27
        float *B, int ldb,      // B图像27*369664
        float *C, int ldc)      // C输出结果32*369664
{
    int i,j,k;
    #pragma omp parallel for                // 多线程，每次循环互不相干，循环中，不存在结果的相互依赖关系
    for(i = 0; i < M; ++i){
        for(k = 0; k < K; ++k){
            register float A_PART = ALPHA*A[i*lda+k];       // 声明寄存器变量，理论上可以提速，但是register * auto会比 auto*auto快吗？
            for(j = 0; j < N; ++j){                         // 常规数学中的矩阵乘法，for i:M; for j:N ; for k:K
                C[i*ldc+j] += A_PART*B[k*ldb+j];            // c(0,:) = a(0,0)*b(0,:)+a(0,1)*b(1,:)+...
            }                                               // 这里有依赖关系，有累加的，但是只是要总和，所以谁先计算都没有关系
        }
    }
}

2. 整体流程

1. 辅助操作，计算一些参数
2. img2col操作
3. 矩阵乘法：卷积核矩阵*图像矩阵

---

3. img2col

img2col关键是根据卷积步长和卷积核的尺寸将featuremap(3D)按原图的位置依次转化成 由多个宽为kkC_{k}的行向量（col），这些col拼成了特征图矩阵

3.1 原理

原图来自:https://www.dazhuanlan.com/2019/12/11/5df10f768c5da/

• 单通道图像img2col
  
• 多通道图片img2col
  
  输入特征图转化得到的矩阵尺度 = (卷积组输入通道数卷积核高卷积核宽) * (卷积层输出单通道特征图高 * 卷积层输出单通道特征图宽)

上面就是主要的原理。
darknet中代码的具体实现是按下图（来自here）来的：

Code

    for (c = 0; c < channels_col; ++c) {                    // 输出为：（输入通道*kh*kw）*卷积滑动的次数//多通道img2col的第一行
        int w_offset = c % ksize;                           // 卷积核的索引            // 卷积核的宽度方向index
        int h_offset = (c / ksize) % ksize;                 // 多通道img2col          // 卷积核的高度方向index
        int c_im = c / ksize / ksize;                       // 图像上的第index个通道   // 卷积核的通道方向的index
        for (h = 0; h < height_col; ++h) {                  // 高度方向计算几次卷积  和卷积的计算方式，只是值相同，无任何相关意义
            for (w = 0; w < width_col; ++w) {               // 宽度方向计算几次卷积
                int im_row = h_offset + h * stride;         // 第几次卷积所需要的图像数据索引，行方向
                int im_col = w_offset + w * stride;         // 列方向
                int col_index = (c * height_col + h) * width_col + w;       // img2col之后，列项的索引
                data_col[col_index] = im2col_get_pixel(data_im, height, width, channels,
                        im_row, im_col, c_im, pad);
            }
        }
    }

• 整个其实就是两个for循环，外层是img2col 输出feature的行数，内层的for h:height_col和for w:width_col其实就是输出featuer的列数
• 这里通过输出feature的位置，反推到img上所需要的数据

3.2 卷积核转矩阵

将一个卷积核拉伸为一个横行，作为左乘矩阵：(为什么要拉伸为横行，在于对应的卷积区域拉伸为竖行，这样才能与之相对应，进行矩阵乘法)
权值矩阵尺度 = (输出层通道数) * (卷积输入通道数卷积核高卷积核宽)

3.3 矩阵乘法

卷积层输出尺度 = (卷积层输出通道数) * (卷积层输出单通道特征图高 * 卷积层输出单通道特征图宽)

4. 矩阵乘法GEMM

Code

void gemm_nn(int M, int N, int K, float ALPHA, 
        float *A, int lda,      // A卷积核32*27
        float *B, int ldb,      // B图像27*369664
        float *C, int ldc)      // C输出结果32*369664
{
    int i,j,k;
    #pragma omp parallel for                // 多线程，每次循环互不相干，循环中，不存在结果的相互依赖关系
    for(i = 0; i < M; ++i){
        for(k = 0; k < K; ++k){
            register float A_PART = ALPHA*A[i*lda+k];       // 声明寄存器变量，理论上可以提速，但是register * auto会比 auto*auto快吗？
            for(j = 0; j < N; ++j){                         // 常规数学中的矩阵乘法，for i:M; for j:N ; for k:K
                C[i*ldc+j] += A_PART*B[k*ldb+j];            // c(0,:) = a(0,0)*b(0,:)+a(0,1)*b(1,:)+...
            }                                               // 这里有依赖关系，有累加的，但是只是要总和，所以谁先计算都没有关系
        }
    }
}

• 这里用#pragma omp parallel for实现多线程计算，后面有相互关系，但是只是要和，所以是没有关系的
• 这里和高数中计算矩阵相乘的方式不同，高数中，应该是M，N是最外层循环
• 引入了一个register变量，并将register变量和最大维度进行运算提高速度。
• 这里#pragma omp parallel for多线程和for循环之间还有点问题

---

reference

1. https://www.dazhuanlan.com/2019/12/11/5df10f768c5da/
2. https://www.jianshu.com/p/4907e6c93452