HLS学习练习1——卷积层（Convolution layer）

0、先验知识

首先，下图所采用得卷积操作，是对边界补0得情况下得到的，卷积的核心在于乘加操作，
关于卷积操作的计算量，可参考此篇文章进行学习
下图的计算量为：输入通道数x输出通道数x卷积核大小x输出图像的长x输出图像的宽
即：RCKKCHout*CHin

1、设置流程

在综合前，需要先进行以下流程的设置
project——》project setting——》synthesis——》Top Function
选择对应的函数
C synthesis

2、卷积的软件实现

优化前的solution1

#define CHin 4
#define CHout 4
#define R 14
#define C 14
#define Rin 16
#define Cin 16
#define K 3

void test()
{
	float In[CHin][Rin][Cin];
	float Out[CHout][R][C];
	//weight array
	float W[CHout][CHin][K][K];

	Output_Channel:
	for(int cho=0;cho<CHout;cho++)
	{
		Input_Channel:
		for(int chi=0;chi<CHin;chi++)
		{
			Row:
			for(int r=0;r<R;r++)
			{
				Column:
				for(int c=0;c<C;c++)
				{
					Kernel_Row:
					for(int kr=0;kr<K;kr++)
					{
						Kernel_Column:
						for(int kc=0;kc<K;kc++)
						{
							Out[cho][r][c]+=In[chi][r+kr][c+kc]*W[cho][chi][kr][kc];
						}
					}
				}

			}
		}
	}
}

查看综合报告

资源开销

3、优化设计

为了对比优化效果，我们新建solution，同时由于该运算满足结合律，我们可以自由调整for循环的位置，使其提高运算效率
首先我们采用Unroll方法进行优化

void test()
{
	float In[CHin][Rin][Cin];
#pragma HLS array_partition variable=In complete dim=1
	float Out[CHout][R][C];
#pragma HLS array_partition variable=Out complete dim=1
	//weight array
	float W[CHout][CHin][K][K];
#pragma HLS array_partition variable=W complete dim=1
#pragma HLS array_partition variable=W complete dim=2


			Row:
			for(int r=0;r<R;r++)
			{
				Column:
				for(int c=0;c<C;c++)
				{
					Kernel_Row:
					for(int kr=0;kr<K;kr++)
					{
						Kernel_Column:
						for(int kc=0;kc<K;kc++)
						{
							Output_Channel:
							for(int cho=0;cho<CHout;cho++)
							{
#pragma HLS UNROLL
								Input_Channel:
								for(int chi=0;chi<CHin;chi++)
								{
#pragma HLS UNROLL
									Out[cho][r][c]+=In[chi][r+kr][c+kc]*W[cho][chi][kr][kc];
}}}}}}}

性能估计与资源开销

4、结果对比

选择Compare Reports——》两个solution进行对比

5、Pipeline设计

然后我们采用pipeline方法进行流水化
优化分析：由于之前的代码具有较强的前后关联性，所以pipeline后II依旧无法等于1，我们将循环顺序调整后，整个的II变为了1。

void test()
{
	float In[CHin][Rin][Cin];
#pragma HLS array_partition variable=In complete dim=1
	float Out[CHout][R][C];
#pragma HLS array_partition variable=Out complete dim=1
	//weight array
	float W[CHout][CHin][K][K];
#pragma HLS array_partition variable=W complete dim=1
#pragma HLS array_partition variable=W complete dim=2

	Kernel_Row:
	for(int kr=0;kr<K;kr++)
    {
		Kernel_Column:
		for(int kc=0;kc<K;kc++)
		{
			Row:
			for(int r=0;r<R;r++)
			{
				Column:
				for(int c=0;c<C;c++)
				{
#pragma HLS PIPELINE
							Output_Channel:
							for(int cho=0;cho<CHout;cho++)
							{
								Input_Channel:
								for(int chi=0;chi<CHin;chi++)
								{
									Out[cho][r][c]+=In[chi][r+kr][c+kc]*W[cho][chi][kr][kc];
						}
					}
				}
			}
		}
	}
}

可以看到目前II为1，同时整个系统流水起来了，但同时资源开销也变大了

6、固定循环卷积加速器（留坑）

资源有限的情况下，我们可以实现一种固定的硬件加速器。

针对更大规模的情况，我们可以采用循环分块的方法来进行（分辨率不变的情况下）
8X8=64
4X4=14
所以需要进行四次