MTCNN（七）卷积更改为嵌套for循环格式

淩亂°似流年 2022-05-10 13:16 142阅读 0赞

**背景：**将MTCNN部署在FPGA上需要将其代码设计为C代码，c代码中的相乘相加依赖于openBLAS库。改为zynqNet的方式需要将卷积拆分为3\*3的卷积，不能采用gemm的形式。

**目的：**将卷积与全连接去掉对openBLAS库的依赖，改为与zynqNet一致的嵌套for循环形式实现卷积，以便并行化。

**目录**

一、gemm

1.1 关于卷积的gemm的理解

1.2 替换掉cblas\_sgemm为gemm

二、全连接层的cblas\_sgemv

2.1 MTCNN中的sgem

2.2 YOLO中的sgemv

2.3 直接用gemm实现sgemv

三、去除对openCV的依赖

3.1 zynqNet中对图片的读取

3.2 MTCNN中引用了两个图像库

四、卷积改为嵌套for循环形式

4.1 YOLO中im2col函数

4.2 YOLO中的嵌套for循环

4.3 卷积的编写

4.4 一个bug的调通

4.5 全连接层的编写

--------------------

# 一、gemm #

## 1.1 关于卷积的gemm的理解 ##

关于im2col的过程：[https://blog.csdn.net/lanchunhui/article/details/74838635][https_blog.csdn.net_lanchunhui_article_details_74838635]

卷积中，将feature提取为矩阵形式，然后与权重矩阵相乘是常见的形式。

参考内容：

*  MTCNN（六）c代码网络结构的更改 [4.3 convolution][]
 *  YOLOv3：Darknet代码解析（三）卷积操作 [https://blog.csdn.net/weixin\_36474809/article/details/81296612][https_blog.csdn.net_weixin_36474809_article_details_81296612]

cblas\_segmm的参数 [https://blog.csdn.net/u012235274/article/details/52769682][https_blog.csdn.net_u012235274_article_details_52769682]

cblas\_sgemm(order, transA, transB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDA);

第一个参数的函数是存储的有限性，有行优先和列优先(c语言是行优先)  
第二个参数和第三个参数是是否转置  
A矩阵经过transA之后的维度是M×K  
B矩阵经过transB之后的维度是K×N  
C矩阵的维度是M×N  
LDA和LDB是对应矩阵还没变换之前，在主维度方向的维度。（如果是行优先就是列数）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjQ3NDgwOQ_size_16_color_FFFFFF_t_70][]

## 1.2 替换掉cblas\_sgemm为gemm ##

// -------------convulution in 2D matrix format-------------------
    // input kernel matrix  *  input feature matrix(Trans) = output feature matrix
    // height (outChannels)    height (3D_KernelSize)        height (outChannels)
    // width  (3D_KernelSize)  width  (outFeatureSize)       width  (outFeatureSize)
    
    //C=αAB + βC :   outpBox=weightIn*matrixIn(T)
    	//       A_transpose       B_transpose
    	gemm_cpu(0,                1,            \
    	//A row C row             B col C col        A col B row        alpha
    	weightIn->out_ChannelNum, matrixIn->height,  matrixIn->width,   1,   \
    	//A*            A'col           B*              B'col             beta
    	weightIn->pdata,matrixIn->width,matrixIn->pdata,matrixIn->width,  0, \
    	//C*             C'col
    	outpBox->pdata,  matrixIn->height);

替换之后程序正常运行

# 二、全连接层的cblas\_sgemv #

## 2.1 MTCNN中的sgem ##

openBLAS中的sgem  [https://blog.csdn.net/chenlanjie842179335/article/details/8043925][https_blog.csdn.net_chenlanjie842179335_article_details_8043925]

运算式：C=alpha\*A\*b+beta\*C

一般取alpha=1.0，beta=0.0 即计算式：C=A\*b

cblas\_sgemv(CblasRowMajor, CblasNoTrans,A的行数,A的列数,alpha,A,A的列数,b,1,beta,C,1)

//Y=αAX + βY    β must be 0(zero)  cblas_sgemv:Multiplies a matrix by a vector (single precision)
    	//          row_Major      no_trans      A hight                 A width               alpha
    	cblas_sgemv(CblasRowMajor, CblasNoTrans, weight->out_ChannelNum, weight->in_ChannelNum,1,   \
    	//A*           A width                x               1   beta  C*              1
    	weight->pdata, weight->in_ChannelNum, Inpbox->pdata,  1,  0,    outpBox->pdata, 1);

## 2.2 YOLO中的sgemv ##

int m = l.batch;
        int k = l.inputs;
        int n = l.outputs;
        float *a = net.input;//input
        float *b = l.weights;//weight
        float *c = l.output;//output
        gemm(0,1,m,n,k,1,a,k,b,k,1,c,n);

但是YOLO中是input在左，weight在右，我们需要weight在左，input在右的格式。

## 2.3 直接用gemm实现sgemv ##

//C=αAB + βC :   outpBox=weightIn*matrixIn(T)
    	//       A_transpose       B_transpose
    	gemm_cpu(0,                0,            \
    	//A hight C hight         B width C width   A width B hight          alpha
    	weight->out_ChannelNum, 1,                weight->in_ChannelNum,   1,   \
    	//A*             A'width                B*              B'width   beta
    	weight->pdata,   weight->in_ChannelNum, Inpbox->pdata,  1,        0, \
    	//C*             C'width
    	outpBox->pdata,  1);

经过验证，我们可以直接将openBLAS的程序全部变为自己的代码实现。可以去除掉对openBLAS库的依赖。

# 三、去除对openCV的依赖 #

## 3.1 zynqNet中对图片的读取 ##

zynqNet直接将图片转换为二进制格式的文件方便读取。

## 3.2 MTCNN中引用了两个图像库 ##

都在network.h之中，

\#include "opencv2/imgproc/imgproc.hpp"  
\#include "opencv2/highgui/highgui.hpp"

using namespace cv;

openCV库对调试暂时较为重要，后续部署FPGA阶段再回来探讨此内内容。

见 **MTCNN（九）去除openCV依赖库  ** [https://blog.csdn.net/weixin\_36474809/article/details/83343514][https_blog.csdn.net_weixin_36474809_article_details_83343514]

# 四、卷积改为嵌套for循环形式 #

嵌套更改之前，需要从四个方面理解程序。

*  YOLO中im2col的模式
 *  YOLO中嵌套for循环卷积模式
 *  MTCNN中im2col的模式

## 4.1 YOLO中im2col函数 ##

//YOLO  additionally.c  
    float im2col_get_pixel(float *im, int height, int width, int channels,
        int row, int col, int channel, int pad){
    		
        row -= pad;
        col -= pad;
    
        if (row < 0 || col < 0 ||
            row >= height || col >= width) return 0;
        return im[col + width*(row + height*channel)];
    }

此函数为根据当前height，width，channel，row，col得到相应的pad之后的像素。

// im2col_CPU.c
    //left matrix weight,right matrix data_col
    //data_col  height (3D_kernelSize), width (Out_featureSize)
    int channels_col = channels * ksize * ksize;//3D_kernelSize
    for (c = 0; c < channels_col; ++c) {
    	int w_offset = c % ksize;
    	int h_offset = (c / ksize) % ksize;
    	int c_im = c / ksize / ksize;
    	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;
    			data_col[col_index] = im2col_get_pixel(data_im, height, width, channels,
    				im_row, im_col, c_im, pad);
    		}
    	}
    }

## 4.2 YOLO中的嵌套for循环 ##

for (fil = 0; fil < l.n; ++fil) {//channels out
    int chan, y, x, f_y, f_x;
    // channel index
    for (chan = 0; chan < l.c; ++chan)//channels in
    // input - y
    for (y = 0; y < l.h; ++y)
    // input - x
    for (x = 0; x < l.w; ++x){
    	
    	//for channels out,for channels in,for row,for col
    	int const output_index = fil*l.w*l.h + y*l.w + x;
    	int const weights_pre_index = fil*l.c*l.size*l.size + chan*l.size*l.size;
    	int const input_pre_index = chan*l.w*l.h;
    	float sum = 0;
    
    	// filter - y
    	for (f_y = 0; f_y < l.size; ++f_y)
    	{
    		int input_y = y + f_y - l.pad;
    		// filter - x
    		for (f_x = 0; f_x < l.size; ++f_x)
    		{
    			int input_x = x + f_x - l.pad;
    			if (input_y < 0 || input_x < 0 || input_y >= l.h || input_x >= l.w) continue;
    
    			int input_index = input_pre_index + input_y*l.w + input_x;
    			int weights_index = weights_pre_index + f_y*l.size + f_x;
    
    			sum += state.input[input_index] * l.weights[weights_index];
    		}
    	}
    	// l.output[filters][width][height] +=
    	//        state.input[channels][width][height] *
    	//        l.weights[filters][channels][filter_width][filter_height];
    	l.output[output_index] += sum;
    }
    }

在每一个for chanel\_out, for channel\_In, for out\_height, for out\_width中计算偏移地址，

然后在当前输出piexl下计算每一个卷积核的累乘相加。

## 4.3 卷积的编写 ##

//set the output value to 0
    for(cur_col_out=0;cur_col_out<out_featureSize;cur_col_out++)
    	output_ptr[cur_col_out]=0;
    
    #pragma omp parallel for
    for(cur_channel_out=0; cur_channel_out<out_ChannelNum; cur_channel_out++){//out_channel
     for(cur_channel_in=0;cur_channel_in<in_ChannelNum;cur_channel_in++){//in_channel
      for(cur_row_out=0;cur_row_out<out_height;cur_row_out++){//out_row,out_height
    	for(cur_col_out=0;cur_col_out<out_width;cur_col_out++){//out_col,out_width
    		output_loc=cur_channel_out*out_height*out_width+cur_row_out*out_width+cur_col_out;
    		weight_pre_loc=cur_channel_out*in_ChannelNum*kernelSize_2D + cur_channel_in*kernelSize_2D;
    		input_pre_loc=cur_channel_in*in_width*in_height  \
    								+ cur_row_out*stride*in_width+stride*cur_col_out;
    		sum=0;
    // outpBox [out_ChannelNum][out_height][out_width] +=
    //		weightIn[out_ChannelNum][in_ChannelNum][kernelWidth][kernelHeight] *
    //		pboxIn[in_ChannelNum][width][height] 
    		for (filter_row=0;filter_row<kernelSize;filter_row++){
    		  for(filter_col=0;filter_col<kernelSize;filter_col++){
    			weight_loc=weight_pre_loc+filter_row*kernelSize+filter_col;
    			input_loc=input_pre_loc+filter_row*in_width+filter_col;
    			sum+=weight_ptr[weight_loc]*input_ptr[input_loc];
    		  }
    		}
    		output_ptr[output_loc]+=sum;
    	}
      }
     }
    }

我们将卷积改为嵌套for循环的形式，验证通过了程序。至此，我们可以开始参照zynqNet的模式将MTCNN一步一步向zynqNet上实现。

## 4.4 一个bug的调通 ##

最初编写好嵌套卷积的时候，并未出现与gemm形式一致的结果，后面查找相应gemm的程序，发现最初有一个对卷积前的输出矩阵置零的步骤。

void gemm_cpu(int TA, int TB, int M, int N, int K,  
            float *A, int lda, 
            float *B, int ldb,
            float *C, int ldc)
    {
    	int i,j;
    	for(i = 0; i < M; ++i){
            for(j = 0; j < N; ++j){
                C[i*ldc + j] = 0;
            }
        }
    ...

开始我们认为在convolutionInit函数之中已经运用memset将程序置零，但是后续验证发现，pnet是开辟了多个存储空间（金字塔缩放，每个feature的大小不固定），但是Rnet与Onet的内存结构是固定的，每次运行重复运用了很多次开辟的空间，空间一次性在网络初始化时开辟好。所以，必须在卷积之前将output的值置为0，否则值会累加之前的值。我们打出每次卷积之前与之后的信息。

Start run Pnet
    Pnet buffer init
    just memset 0 :0.000000
    after =0 : 0.000000
    just memset 0 :0.000000
    after =0 : 0.000000
    just memset 0 :0.000000
    after =0 : 0.000000
    just memset 0 :0.000000
    after =0 : 0.000000
    just memset 0 :0.000000
    after =0 : 0.000000
    Start Pnet generate Bbox
    Done Pnet generate Bbox
    Done run Pnet
    Run nms
    ...
    Rnet run
    just memset 0 :0.000000
    after =0 : 0.000000
    just memset 0 :0.000000
    after =0 : 0.000000
    just memset 0 :0.000000
    after =0 : 0.000000
    Rnet run
    just memset 0 :0.518421
    after =0 : 0.000000
    just memset 0 :0.212925
    after =0 : 0.000000
    just memset 0 :0.009512
    after =0 : 0.000000
    Rnet run

Pnet所有的运行空间均为新开辟的空间，而Rnet与Onet重复运用了相同的内存空间运行了多次。所以第一次运行时初始值为0，但后续边为上次的值。解决了此bug，我们已经将此结构改为了与之对应的nestedloop的格式。

## 4.5 全连接层的编写 ##

//--------------------fc layer	in nested loop format--------------
    //loop variables
    int cur_outChannel,cur_inChannel;
    int out_ChannelNum=weight->out_ChannelNum, in_ChannelNum=weight->in_ChannelNum;
    //loaction variables
    int weight_loc_pre,weight_loc;
    //variable pointer
    float sum;
    for(cur_outChannel=0;cur_outChannel<out_ChannelNum;cur_outChannel++){
    	sum=0;
    	weight_loc_pre=cur_outChannel*in_ChannelNum;
    	for(cur_inChannel=0;cur_inChannel<in_ChannelNum;cur_inChannel++){
    		weight_loc=weight_loc_pre+cur_inChannel;
    		sum+=weight->pdata[weight_loc]*Inpbox->pdata[cur_inChannel];
    	}
    	outpBox->pdata[cur_outChannel]=sum;
    }

至此，我们摆脱了对openBLAS库的依赖，并且根据嵌套for循环将程序改为了zynqNet的模式。

[https_blog.csdn.net_lanchunhui_article_details_74838635]: https://blog.csdn.net/lanchunhui/article/details/74838635
[4.3 convolution]: https://blog.csdn.net/weixin_36474809/article/details/83056795#4.3%20convolution
[https_blog.csdn.net_weixin_36474809_article_details_81296612]: https://blog.csdn.net/weixin_36474809/article/details/81296612
[https_blog.csdn.net_u012235274_article_details_52769682]: https://blog.csdn.net/u012235274/article/details/52769682
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNjQ3NDgwOQ_size_16_color_FFFFFF_t_70]: /images/20220505/b41075fd081e4d7a8909c3eac8b59381.png
[https_blog.csdn.net_chenlanjie842179335_article_details_8043925]: https://blog.csdn.net/chenlanjie842179335/article/details/8043925
[https_blog.csdn.net_weixin_36474809_article_details_83343514]: https://blog.csdn.net/weixin_36474809/article/details/83343514

发表评论取消回复

表情：

评论列表（有 0 条评论，142人围观）

还没有评论，来说两句吧...

相关阅读

相关提高卷积效率，空间分组卷积让卷积更快！

提高卷积效率，空间分组卷积让卷积更快！在深度学习模型中，卷积层是常用的网络层之一。但是针对一些庞大的模型，卷积运算需要消耗大量时间和计算资源，这就限制了模型的性能和可扩展性

谁践踏了优雅/ 2024年03月25日 23:48/ 0 赞/ 80 阅读

相关 Java for循环嵌套

和其他编程语言一样，[Java][] 允许循环嵌套。如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环。嵌套循环既可以是 for循环嵌套 while 循环，也

野性酷女/ 2023年10月03日 22:36/ 0 赞/ 9 阅读

相关数字信号处理实验（一） —— 线性卷积与循环卷积

前言其实卷积可以说是DSP 数字信号处理的入门操作，基本思路：我们想测试一个系统的性能，得到这个系统的传递函数，得到你信号的响应（response），说白了就是往系

约定不等于承诺〃/ 2023年02月15日 03:33/ 0 赞/ 2 阅读

相关 for循环嵌套，C语言for循环嵌套详解！编程使我快乐！

虽说是多层，事实上 for 循环嵌套的层数也不能太多。通常为两个 for 循环的嵌套，超过两个的极少使用。与单个 for 循环相比，多个 for 循环的嵌套在逻辑上更复杂一

末蓝、/ 2023年01月16日 06:28/ 0 赞/ 211 阅读

相关 caffe：为什么有时Depthwise 卷积比正常卷积更耗时

原因：一、从计算量和内存占用量分析作者：cs sun 链接：[https://www.zhihu.com/question/265434464/answer/306

偏执的太偏执、/ 2022年10月02日 11:44/ 0 赞/ 235 阅读

相关 for 循环嵌套性能

比较两个方法t1和t2的运行速度 include include u

矫情吗；*/ 2022年06月14日 06:06/ 0 赞/ 369 阅读

相关循环卷积（转）

循环卷积（转）循环卷积我理解是使用DFT(FFT)计算线性卷积时的衍生品。首先连续时间没有循环卷积概念。离散时间时，不妨假设x(n)为L

淩亂°似流年/ 2022年06月04日 04:06/ 0 赞/ 358 阅读

相关 MTCNN（七）卷积更改为嵌套for循环格式

背景：将MTCNN部署在FPGA上需要将其代码设计为C代码，c代码中的相乘相加依赖于openBLAS库。改为zynqNet的方式需要将卷积拆分为3\3的卷积，不能采用gemm的

淩亂°似流年/ 2022年05月10日 13:16/ 0 赞/ 143 阅读

相关 python九九乘法表（while嵌套，for嵌套，while,for 循环）

目前以我的能力只能做出这三种。晚上的时候我有突然想到，能不能用一个for循环加上if判断写出来九九乘法表。自己想了一晚上没有想出来。- - ！ while嵌套：

骑猪看日落/ 2022年03月14日 15:46/ 0 赞/ 307 阅读

相关 Vue v-for嵌套循环

<div v-for="data in list"> <div v-for="detail in data.details">

港控/mmm°/ 2021年09月27日 13:42/ 0 赞/ 490 阅读