2D卷积C/C++实现（高级综合HLS）

最新推荐文章于 2024-03-03 11:08:21 发布
最新推荐文章于 2024-03-03 11:08:21 发布
阅读量3.4k 收藏 34
点赞数 11
分类专栏： FPGA 文章标签： 2D卷积 HLS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43134018/article/details/94577896
版权

2D卷积C/C++实现

void _2DConv(int8_t *in，int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
/* 
in:输入图像
out：输出图像
filter：滤波器
nrows：输出图像的行数
ncols：输出图像的列数
k:滤波器大小（k*k）
stride:滤波窗口步进长度
 */

{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

for(r=0;r<nrows;r++)
	{
	for(c=0;c<=ncols;c++)
		{
		for(i=0;i<k;i++)
			{
			for(j=0;j<k;j++)
				{
				uint32_t offset=(r*stride+i)*ncols_i+(c*stride+j);
				int32_t in_tmp=*(in+offset);
				int32_t filter_tmp=*(filter+i*k+j);
				*(out+r*ncols+c)+=in_tmp *filter_tmp;
				}
			}
		}
	}

}

把代码封装成基于AXI4的形式

void HW_2DConv_Mmap_1(int8_t *pixel_in,int8_t *pixel_out,int32_t addr_reserved)
{
	/*
	AXI4数据总线（m_axi）:
	pixel_in用于FPGA加速器主动读取DDR的输入图像和滤波器
	pixel_out用于FPGA加速器主动写入输出结果到DDR中
		
	AXI4Lite控制总线（s_axilite):
		用于输入输出图像访存基地址
	*/
	#pragma HLS INTERFACE m_axi depth =482*272+3*3 port=pixel_in offset=slave bundle=user_axi_in register 
	#pragma HLS INTERFACE m_axi depth =482*270     port=pixel_out offset=slave bundle=user_axi_out register
	
	#pragma HLS INTERFACE s_axilite port=pixel_in bundle=user_axi4lite_config register
	#pragma HLS INTERFACE s_axilite port=pixel_out bundle=user_axi4lite_config register
	#pragma HLS INTERFACE s_axilite port=addr_reserved offset=0xFFF0  bundle=user_axi4lite_config register
	#pragma HLS INTERFACE s_axilite port=return  bundle=user_axi4lite_config register
	
	
	int8_t *filter_base=pixel_in+ROWS_I*COLS_I;
	
	_2DConv(pixel_in,pixel_out,filter_base,ROWS_O,COLS_O,FILTER_SIZE,STRIDE);
}

实现结果的时间和资源

  • 时间(latency)：21.25M clock cycles
  • 主要资源开销：1个dsp 84个乘法器
  • 瓶颈：四层迭代 串行运行

里面的两层迭代需要展开
外面的两层迭代需要流水

迭代优化

void _2DConv(int8_t *in，int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

for(r=0;r<nrows;r++)
	{
	for(c=0;c<=ncols;c++)
		{
		#pragma HLS PIPELINE II=1//流水
		for(i=0;i<k;i++)
			{
			for(j=0;j<k;j++)
				{
				uint32_t offset=(r*stride+i)*ncols_i+(c*stride+j);
				int32_t in_tmp=*(in+offset);
				int32_t filter_tmp=*(filter+i*k+j);
				*(out+r*ncols+c)+=in_tmp *filter_tmp;
				}
			}
		}
	}

}

实现结果的时间和资源

  • 时间(latency)：2.33M clock cycles 提高了9倍多
  • 主要资源开销：6个dsp 365个乘法器
  • 瓶颈：目标流水线是1个clock cycles ，但是目前只能达到18个clock cycles，访存瓶颈

访存及核心计算优化

void _2DConv——Op(int8_t *in，int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

int8_t *filter_based=in+ROWS_I*COLS_I;

int8_t filter_buffer[FILTER_SIZE][FILTER_SIZE]
//*pragma HLS ARRAY_PARTITION variable=filter_buffer complete dim=0
memcpy (&filter_buffer[0][0],filter_base,FILTER_SIZE*FILTER_SIZE*sizeof(int8_t));//提前将卷积核放到片上


for(r=0;r<nrows;r++)
	{
	for(c=0;c<=ncols;c++)
		{
		#pragma HLS PIPELINE II=1
		int8_t store_data=0;
		for(i=0;i<k;i++)
			{
			for(j=0;j<k;j++)
				{
				uint32_t offset=(r*stride+i)*ncols_i+(c*stride+j);
				int8_t val=*(in+offset);
				int8_t res=0;
				
				if(filter_buffer[i][j]==0)//针对二值卷积核进行优化
					res=0;
				else if(filter_buffer[i][j]==1)
					res=val;
				else if(filter_buffer[i][j]==-1)
					res=-val;
				
				store_data+=res
				*(out+r*ncols+c)+=store_data;
				}
			}
		}
	}

}

卷积核缓存到片上ram

实现结果的时间和资源

  • 时间：1.16M clock cycles 提高了18倍多
  • 主要资源开销：0个dsp 365个乘法器
  • 瓶颈：目标流水线是1个clock cycles ，但是目前只能达到9个clock cycles，图片还是从ddr读的

2D卷积操作必须对k*k大小的窗口内的所有像素点进行计算
字节从DDR中取像素进行计算的话，访存延迟大，访存周期不确定，无法实现高效的流水处理

图片数据缓冲到片上

行缓冲（line buffer）
窗口缓冲（windows buffer）
在这里插入图片描述

算法硬件结构优化：行缓冲

  • 由于DEMO中filter大小为3*3，因此，建立一个3行的行缓冲，用于缓存当前滤波窗口正在处理的三行像素
  • 行缓冲通过ARRAY_PARTITION指示对二维数组的第一维（行）进行展开，每一维通过独立的片上BRAM实现，支持同时访问不同行中的像素点
template<typename T,int LROW,int LCOL>
class ap_linebuffer{
   public:
   	TM[LROW][LCOL];
   	#pragma AP ARRAY_PARTITION variable=M dim=1 complete
   	ap_linebuffer(){
   		};
}

算法硬件结构优化：窗口缓冲

  • 建立一个3*3的窗口缓存，通过ARRAY_PARTITION对所有维度进行全部展开，窗口缓存中所有9个元素都由LUT实现，支持同时对所有元素并发访问
  • 算法从DDR读取下一个像素，添加到行缓冲中。同时，行缓冲已经缓存了前两行的像素。通过访问行缓存，正好可以得到当前滤波窗口所在位置的所有像素点，这些像素点存入窗口缓存中，并送到流水线中进行处理。
template<typename T,int LROW,int LCOL>
class ap_window{
   public:
   	TM[LROW][LCOL];
   	#pragma AP ARRAY_PARTITION variable=M dim=1 complete
   	ap_window(){
   		};
}

完整代码

void _2DConv_Op(int8_t *in，int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride)
{
uint16_t r,c,i,j;
uint32_t nrows_i=nrows*stride+k-1;//输入图像的行数
uint32_t ncols_i=ncols*stride+k-1;//输入图像的列数

int8_t *filter_based=in+ROWS_I*COLS_I;

int8_t filter_buffer[FILTER_SIZE][FILTER_SIZE]
//*pragma HLS ARRAY_PARTITION variable=filter_buffer complete dim=0
memcpy (&filter_buffer[0][0],filter_base,FILTER_SIZE*FILTER_SIZE*sizeof(int8_t));//提前将FILTER_SIZE*FILTER_SIZE个像素放到片上

ap_linebuffer<int8_t,FILTER_SIZE,COLS_I> line_buffer;

ROW_LOOP:for(r=0;r<ROWS_I;r++)
	{
	ap_window<int8_t,FILTER_SIZE,FILTER_SIZE> window_buffer;
	
	//fill the line buffer
	COL_LOOP:for(c=0;c<=COLS_I;c++)
		{
#pragma HLS PIPELINE II=1
		int8_t store_data=0;
		int8_t load_data=*(in_base+r*COLS_I+c);
		
		line_buffer.shift_up(c);
		line_buffer.insert_bottom(load_data,c);//行缓冲，保证数据从DDR里面流水的取出
		
		if(r>=2)
			{
			window_buffer.shift_right();
			window_buffer,insert(line_buffer.getval(2,c),0,2);
			window_buffer,insert(line_buffer.getval(1,c),1,2);
			window_buffer,insert(line_buffer.getval(0,c),2,2);
			}//从行缓冲中获取数据，构建卷积计算的窗口缓冲
		
		if(r>=2&&c>=2)
			{
			for(i=0;i<FILTER_SIZE;i++)
				{
				for(j=0;j<FILTER_SIZE;j++)
					{
					int8_t res=0;
					int8_t val=window_buffer.getval(i,j);//从窗口中获取像素值，进行卷积计算									
					
					if(filter_buffer[i][j]==0)//针对二值卷积核进行优化
						res=0;
					else if(filter_buffer[i][j]==1)
						res=val;
					else if(filter_buffer[i][j]==-1)
						res=-val;
					
					store_data+=res
					
					}
				}
			*(out_base+(r-2)*COLS_O+c(c-2))+=store_data;
			}
		}

	}
	
}

实现结果的时间和资源

  • 时间(latency)：131k clock cycles 提高了164倍多
  • 综合后流水线达到目标流水线要求，1个clock cycles
  • latency 降低到1311143个时钟周期，比优化前降低了约99.5%
  • 理论分析，实现COL_LOOP全流水后，每个时钟周期能完成一个滤波窗口的计算。理论上，总的时钟周期开销约为270*480=129600.最终优化后的131143仅与理论值相差1.1%。
Diesel8
关注
  • 11
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C/C++ 卷积算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-08 78
卷积算法的核心思想是通过卷积操作来提取输入数据中的特征。具体而言，它将卷积核与输入数据进行逐点相乘，然后将乘积累加得到输出结果的对应位置的值。这个过程可以看作是在输入数据的局部区域进行加权求和，从而达到提取特征的目的。卷积算法是一种常用的信号处理技术，用于图像处理、音频处理、自然语言处理等领域。简而言之，卷积算法将两个函数进行运算，其中一个函数作为输入，另一个函数通常称为卷积核或滤波器。
2D-CNN-Forward-Propagation:在Vitis HLS中使用C ++实现2D卷积神经网络
04-13
2D-CNN向前传播 在Vitis HLS中使用C ++实现2D卷积神经网络 CNN-使用-HLS 目录结构： 该软件包包含以下目录： modules /-用于开发和测试用于CNN实施的单个HLS功能的目录 neuronetwork_stream /-包含C ++源代码和测试平台的目录 py /-包含用于训练神经网络的python代码的目录 使用的软件： 操作系统：Windows Vivado HLS 2020.2-仿真结果与综合 Python库 numpy-版本1.18.0 tensorflow-版本2.1.0 sklearn-版本0.24.1 scipy-版本1.6.2
基于HLS的高效深度学习卷积神经网络FPGA实现方法项目全部数据.zip
11-30
基于HLS的高效深度学习卷积神经网络FPGA实现方法项目全部数据.zip本文通过对现有相关研究的分析、总结和改进，给出了一系列在软件层面上如何构建和训练小巧高效且利于硬件加速的网络方法，在FPGA实现时如何减少资源、降低功耗及提高速度的方法，以及在HLS中如何增加设计灵活性、可移植性和可扩展性的方法，具有很好的实用价值。并结合这些方法构建和训练了一个网络，命名为EfficientNet，使用HLS在FPGA上对其进行了推断加速。通过与其他网络和平台的对比，验证了这些方法的有效性。本文的主要工作和贡献如下： 设计实现了一种轻量化的深度学习网络EfficientNet。针对传统网络参数量及计算量大且不利于硬件加速的问题，本文在保证精度的前提下，分析了以深度可分离卷积代替标准卷积、以步进代替池化、以平均池化代替全连接的方法，提出了尺寸不变通道增减交替的方法，并对这些方法进行了集成，从而构建了一个低复杂度的DCNN网络，并命名为EfficientNet。实验结果表明EfficientNet在公开的Flower_photos数据集上的分类精度为89.3%，相比Inception-v3，在参数量
实时手势识别(C++与python都可实现)
热门推荐
礼乐的博客
02-28 2万+
实时手势识别，label[0,1,2,3,4,5]，python，C++均可实现
Conv2d 实现 by C++
alexandsunny的博客
12-29 2298
Conv2d 实现 by C++ 明天补 一张对理解多通道卷积操作很有帮助的图 代码 #include<iostream> #include<vector> #include<algorithm> #include<math.h> using namespace std; /* kernel的维度（order,k_c,k_h,k_w） order代表有几个kernel，和kernel_num相同 输入feature map的维度（f_c,f_h,f_w
利用C++实现简单二维图像的卷积
Aven
12-05 5454
这个小项目是本人大学科研小组的一个小比赛，用c++实现对二维图像的卷积，本文为原创文章。希望能对有提升c++编程能力想法的你有些许帮助，衷心感谢在完成这个项目过程中师兄和ta给予的指点和帮助。因本人水平有限，如有错误欢迎指正。
维特比译码+卷积码编码程序C/C++实现
01-14
卷积码的编码和维特比译码程序，使用C/C++编写，可在Ubuntu和Windows操作系统上运行，经过修改可在嵌入式系统中运行。适合新手学习卷积码编码和维特比译码算法，也可供工程师参考。
卷积神经网络-C/C++开发
05-26
Darknet Darknet是一个用C和CUDA编写的开源神经网络框架。 它快速，易于安装，并支持CPU和GPU计算。 Yolo v4论文：https://arxiv.org/abs/2004.10934 Yolo v4源代码：https：/ Darknet Darknet是一个用C和CUDA编写的...
卷积.zip_C/C++_
08-10
可以进行卷积计算图像处理可用 卷积神经网络
juanji.rar_c++卷积_卷积_卷积 c++ _卷积 实现
09-24
卷积函数，实现线形卷积的计算，卷积函数，实现线形卷积的计算，
C++实现对图像进行卷积，自定义卷积和
04-02
一段对图像进行卷积的程序代码自定义卷积和，可自定义区域处理方法进行卷积操作，自定义卷积和。
二维矩阵 卷积运算 C++实现
01-26
C++实现的二维矩阵卷积运算 主要是一个卷积的算法，矩阵保存在一个二维矩阵中。接口可以根据需要自行修改。提供了2种卷积的算法，被注释掉的那部分执行效率比较低下，对于大矩阵容易造成程序死掉的情况。所以进行了算法优化。 如果不想自行修改接口的话，或者对修改接口有困难的话，请不要下载本资源。谢谢~ 环境：XP SP3
HLS：卷积神经网络LeNet5的实现与测试
光年之外
05-27 1万+
目录一、引言二、LeNet5的学习三、数学知识补充四、HLS代码设计引言引言 一、引言 1、开发环境。 Windows10、Vivado2018.2、Vivado HLS与Xilinx SDK。 2、LeNet5概述。 1994年，CNN网络，手写字符识别与分类，确立了CNN结构，适合入门。 LeNet5共分为7层： C1，卷积层 S2，池化层 C3，卷积层 S4，池化层 C5，卷积层 F6，全连接层 OUTPUT，全连接层 二、LeNet5的学习 LeNet5每层结构内容的学习。 1°输入层INPU
【源码+文档】基于HLS的高效深度卷积神经网络FPGA实现方法
yuxibdd的博客
07-12 609
相反，当 g 的导数值大于 1 时，则会带来梯度爆炸现象，使得权重参数异常巨大或接近零值，以至超出所使用数据类型的表示范围而出现大量的 NAN 值，给网络带来很大的不稳定性。而观察发现大多数激活函数，如 Sigmod 函数、Tanh 函数或 ReLu 函数等为单调递增函数，则卷积所得的结果经过上述激活函数后，并不会改变彼此之间的大小关系，因此当采用最大池化时，可以将激活与池化的操作顺序颠倒，利用池化降维的功效大大减少激活函数的非线性运算量，并带来速度的提升（当然，此种技巧并不适用于平均池化）。
C++实现conv2D 卷积运算
最新发布
xiangxianghehe的博客
03-03 394
具体来说，代码首先计算输出矩阵的大小，即输入矩阵的大小减去卷积核的大小再加一。然后，代码初始化输出矩阵，将其所有元素设置为零。接着，代码遍历输入矩阵，对于每个位置，计算卷积核在输入矩阵上的位置，然后遍历卷积核，计算卷积核和输入矩阵对应元素的乘积，并将结果累加到输出矩阵的对应位置上。最后，代码返回输出矩阵。代码首先计算输出矩阵的大小，然后初始化输出矩阵。接着，代码遍历输入矩阵，对于每个位置，计算卷积核在输入矩阵上的位置，然后遍历卷积核，计算卷积核和输入矩阵对应元素的乘积，并将结果累加到输出矩阵的对应位置上。
C++性能优化系列——3D高斯核卷积计算(四)Intrinsic实现一维卷积与循环展开
yan31415的博客
09-17 773
基于 性能优化系列(CPU)——3D高斯核卷积计算(三)FMA向量化计算一维卷积 中实现，本文用Intrinsic实现向量化的一维卷积计算。 代码实现 void Conv1D_Ins_Cmb(float* pSrcLine, int iLength, float* pKernel, int kernelSize, float* pDst,float* pSimdKernel) { int iConvSize = iLength - kernelSize + 1; float* pDstTemp
变形卷积核、可分离卷积？卷积神经网络中十大拍案叫绝的操作。
mmc2015的专栏
08-31 2万+
总结的非常好，故转来，如果侵权，请告知，会及时删掉。 大家还是去看原文好，作者的文章都不错： https://zhuanlan.zhihu.com/p/28749411 https://www.zhihu.com/people/professor-ho/posts 写文章 变形卷积核、可分
libtorch (pytorch c++) 教程（三）
浩瀚之水的专栏
05-12 677
基本模块搭建 模块化编程的思想非常重要，通过模块化编程可以大幅减少重复的敲代码过程，同时代码可读性也会增加。本章将讲述如何使用libtorch搭建一些MLP和CNN的基本模块。 MLP基本单元 首先是线性层的声明和定义，包括初始化和前向传播函数。代码如下： class LinearBnReluImpl : public torch::nn::Module{ public: LinearBnReluImpl(int intput_features, int output_features);
关于图像的二维卷积各种版本的实现（C++，Cuda和mex）
AIGC | 智能洞察，创造未来
03-14 9132
二维卷积各个版本的代码；CUDA，mex，C++，Matlab
HLS用C/C++实现F.conv2d
05-19
HLS（High-Level Synthesis）是一种将高级语言（如C/C++）转换为硬件描述语言（如Verilog和VHDL）的技术，以方便进行FPGA设计。在HLS中实现F.conv2d（二维卷积运算）的方法如下： 1. 定义输入和输出数据类型：首先需要定义输入和输出数据类型。假设输入数据为3通道的图像，每个通道有16位的像素值，输出数据也是16位。则可以使用以下代码定义数据类型： ```c++ typedef short data_t; typedef struct { data_t data[3][H][W]; } input_t; typedef struct { data_t data[H][W]; } output_t; ``` 其中，H和W分别表示图像的高度和宽度。 2. 实现卷积核：卷积核是一个3维数组，用于对输入图像进行卷积运算。可以使用以下代码定义卷积核： ```c++ typedef struct { data_t data[K][K][C][F]; } weight_t; ``` 其中，K表示卷积核的大小，C表示输入图像的通道数，F表示输出图像的通道数。 3. 编写卷积函数：卷积函数的输入包括输入图像、卷积核和偏置项（可选），输出为卷积后的图像。可以使用以下代码实现卷积函数： ```c++ void conv2d(input_t input, weight_t weight, data_t bias, output_t output) { for (int i = 0; i < H-K+1; i++) { for (int j = 0; j < W-K+1; j++) { for (int f = 0; f < F; f++) { data_t sum = 0; for (int c = 0; c < C; c++) { for (int ii = 0; ii < K; ii++) { for (int jj = 0; jj < K; jj++) { sum += input.data[c][i+ii][j+jj] * weight.data[ii][jj][c][f]; } } } sum += bias; output.data[i][j][f] = sum; } } } } ``` 该函数使用4层循环，分别遍历输出图像的每个像素、每个通道和卷积核的每个参数。 4. 使用HLS编译器生成硬件描述语言：使用HLS编译器将C/C++代码转换为硬件描述语言（如Verilog或VHDL），并在FPGA上实现卷积运算。 以上是使用HLS实现F.conv2d的一般流程，具体实现可能因不同的HLS工具和FPGA平台而有所不同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值