您当前的位置： 首页 >  网络

FPGA硅农

暂无认证

  • 4浏览

    0关注

    277博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

基于FPGA的MobileNet V2卷积神经网络加速器

FPGA硅农 发布时间：2021-09-08 21:15:58 ，浏览量：4

MobileNet V2介绍

MobileNetV2是在V1基础之上的改进。V1主要思想就是深度可分离卷积。而V2则在V1的基础上，引入了Linear Bottleneck 和 Inverted Residuals。下图是MobileNet V2中的一个基本模块 在这里插入图片描述 可以看到，该模块由三个卷积组成，第一第三个卷积是标准的1x1卷积，起到升维和降维的作用，而中间的是一个depthwise卷积，每一个卷积层之后，都紧接着一个BN层，以加速网络的收敛。 同时，我们观察到，该模块的输入和输出有一个残差连接，即输入和最终的输出求和，这就是MobileNet V2中的Inverted Residuals，同时，我们注意到，第三个卷积层之后，并没有跟着一个激活函数，这就是上面所说的Linear Bottleneck，因为从高维向低维转换时，使用ReLU激活函数可能会造成信息丢失或破坏（不使用非线性激活数数）。所以在最后一个卷积之后，我们不再使用ReLU激活函数而是使用线性激活函数。 有了上边的基础，整体的网络结构就很好理解了，如下图所示 在这里插入图片描述下图则是MobileNet V2和其他网络在参数量、计算复杂度方面的对比，可以看到，MobileNet V2的参数数目为3.4M，乘累加数目为300M. 在这里插入图片描述

模型训练以及参数预处理

模型训练，我们采用的是一个有5种花卉类别的数据集，输入图像的尺寸为3x224x224,我们仅修改网络的最后一层(即将输出向量维度由1000改为5) 以下是训练代码:

import os
import torchvision.transforms as transforms
from torchvision import datasets
import torch.utils.data as data
import torch
import numpy as np
import matplotlib.pyplot as plt
import torchvision.models as models
#模型加载
model = models.mobilenet_v2(pretrained=True)
model.classifier = torch.nn.Sequential(torch.nn.Dropout(p=0.5),
                                     torch.nn.Linear(1280, 5))
print(model)
model.load_state_dict(torch.load('model.pkl'))                #在训练过的参数的基础上再进行训练
#参数
BATCH_SIZE=32
DEVICE='cuda'
#数据集加载
path='F:\\data\\flower_photos\\flower_photos'
flower_class=['daisy','dandelion','roses','sunflowers','tulips']

transform = {
    "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                 transforms.RandomHorizontalFlip(),
                                 transforms.ToTensor(),
                                 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    "val": transforms.Compose([transforms.Resize((224, 224)),
                               transforms.ToTensor(),
                               transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
}
image_path = path
trainset = datasets.ImageFolder(root=image_path,
                                transform=transform["train"])
trainloader = data.DataLoader(trainset, BATCH_SIZE, shuffle=True)

print(trainset.classes)  #根据分的文件夹的名字来确定的类别
print(trainset.class_to_idx) #按顺序为这些类别定义索引为0,1...
# print(trainset.imgs) #返回从所有文件夹中得到的图片的路径以及其类别

def imshow(image):
    for i in range(image.size(0)):
        img = image[i]  # plt.imshow()只能接受3-D Tensor，所以也要用image[0]消去batch那一维
        img = img.numpy()  # FloatTensor转为ndarray
        img = np.transpose(img, (1, 2, 0))  # 把channel那一维放到最后
        # 显示图片
        plt.imshow(img)
        plt.show()

#损失函数和优化器
loss_f = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.00001)
# 模型训练和参数优化
epoch_n = 10
torch.cuda.empty_cache()
model=model.to(DEVICE)
for epoch in range(epoch_n):
    print("Epoch {}/{}".format(epoch + 1, epoch_n))
    print("-" * 10)
    # 设置为True，会进行Dropout并使用batch mean和batch var
    model.train(True)
    running_loss = 0.0
    running_corrects = 0
    # enuerate(),返回的是索引和元素
    for batch, data in enumerate(trainloader):
        X, y = data
        X=X.to(DEVICE)
        y=y.to(DEVICE)
        y_pred = model(X)
        # pred，概率较大值对应的索引值，可看做预测结果
        _, pred = torch.max(y_pred.data, 1)
        # 梯度归零
        optimizer.zero_grad()
        # 计算损失
        loss = loss_f(y_pred, y)
        loss.backward()
        optimizer.step()
        # 计算损失和
        running_loss += float(loss)
        # 统计预测正确的图片数
        running_corrects += torch.sum(pred == y.data)
        if batch%10==9:
            print("loss=",running_loss/(BATCH_SIZE*10))
            print("acc is {}%".format(running_corrects.item()/(BATCH_SIZE*10)*100.0))
            running_loss=0
            running_corrects=0

    torch.save(model.state_dict(),'model.pkl')

训练完成后，为了加快推理速度，我们首先进行了一个BN融合，即将BN层参数和卷积层参数融合在一起，这样在推理时就可省去BN层的计算。 以下就是进行参数BN融合以及保存的代码

import torchvision.transforms as transforms
from torchvision import datasets
import torch.utils.data as data
import torch
import torchvision.models as models

#数据
path='F:\\data\\flower_photos\\flower_photos'

transform = {
    "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                 transforms.RandomHorizontalFlip(),
                                 transforms.ToTensor(),
                                 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    "val": transforms.Compose([transforms.Resize((224, 224)),
                               transforms.ToTensor(),
                               transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
}

trainset = datasets.ImageFolder(root=path,transform=transform["train"])
trainloader = data.DataLoader(trainset,100, shuffle=True)
image=torch.zeros((3670,3,224,224))
label=torch.zeros((3670,))
for batch,data in enumerate(trainloader):
    X,y=data
    image[batch*100:batch*100+y.size(0),:,:,:]=X
    label[batch*100:batch*100+y.size(0)]=y

image.numpy().tofile("image.bin")
label.numpy().tofile("label.bin")

model = models.mobilenet_v2(pretrained=False)
model.classifier = torch.nn.Sequential(torch.nn.Dropout(p=0.5),
                                     torch.nn.Linear(1280, 5))
print(model)
model.load_state_dict(torch.load('model.pkl'))
model=model.eval()

def SaveFoldedInvertedResidualParam(param_dict,i):
    #
    Wc1=(param_dict['conv.0.1.weight']/(torch.sqrt(param_dict['conv.0.1.running_var']+0.00001))).view(-1,1,1,1)*\
        param_dict['conv.0.0.weight']
    bc1=param_dict['conv.0.1.bias']-param_dict['conv.0.1.weight']*param_dict['conv.0.1.running_mean']/torch.sqrt(
        param_dict['conv.0.1.running_var']+0.00001)
    Wc2=(param_dict['conv.1.1.weight'] / (torch.sqrt(param_dict['conv.1.1.running_var'] + 0.00001))).view(-1,1,1,1) * param_dict[
        'conv.1.0.weight']
    bc2 =param_dict['conv.1.1.bias']-param_dict['conv.1.1.weight'] * param_dict['conv.1.1.running_mean'] / torch.sqrt(
        param_dict['conv.1.1.running_var'] + 0.00001)
    Wc3 = (param_dict['conv.3.weight'] / (torch.sqrt(param_dict['conv.3.running_var'] + 0.00001))).view(-1,1,1,1)* param_dict[
        'conv.2.weight']
    bc3 = param_dict['conv.3.bias']-param_dict['conv.3.weight'] * param_dict['conv.3.running_mean'] / torch.sqrt(
        param_dict['conv.3.running_var'] + 0.00001)
    #保存参数
    Wc1.numpy().tofile("FoldedInvertedResidual.{}.Wc1.bin".format(i))
    bc1.numpy().tofile("FoldedInvertedResidual.{}.bc1.bin".format(i))
    Wc2.numpy().tofile("FoldedInvertedResidual.{}.Wc2.bin".format(i))
    bc2.numpy().tofile("FoldedInvertedResidual.{}.bc2.bin".format(i))
    Wc3.numpy().tofile("FoldedInvertedResidual.{}.Wc3.bin".format(i))
    bc3.numpy().tofile("FoldedInvertedResidual.{}.bc3.bin".format(i))

def SaveFoldedHeadParam(param_dict1,param_dict2):
    Wc1=(param_dict1['1.weight']/torch.sqrt(param_dict1['1.running_var']+0.00001)).view(-1,1,1,1)*param_dict1['0.weight']
    bc1=param_dict1['1.bias']-param_dict1['1.weight']*param_dict1['1.running_mean']/torch.sqrt(param_dict1['1.running_var']+0.00001)
    Wc1.numpy().tofile("Head.Wc1.bin")
    bc1.numpy().tofile("Head.bc1.bin")
    #
    Wc2=(param_dict2['conv.0.1.weight']/torch.sqrt(param_dict2['conv.0.1.running_var']+0.00001)).view(-1,1,1,1)*param_dict2['conv.0.0.weight']
    bc2=param_dict2['conv.0.1.bias']-param_dict2['conv.0.1.weight']*param_dict2['conv.0.1.running_mean']/torch.sqrt(0.00001+param_dict2['conv.0.1.running_var'])
    Wc2.numpy().tofile("Head.Wc2.bin")
    bc2.numpy().tofile("Head.bc2.bin")
    #
    Wc3=(param_dict2['conv.2.weight']/torch.sqrt(0.00001+param_dict2['conv.2.running_var'])).view(-1,1,1,1)*param_dict2['conv.1.weight']
    bc3=param_dict2['conv.2.bias']-param_dict2['conv.2.weight']*param_dict2['conv.2.running_mean']/torch.sqrt(0.00001+param_dict2['conv.2.running_var'])
    Wc3.numpy().tofile("Head.Wc3.bin")
    bc3.numpy().tofile("Head.bc3.bin")

def SaveFoldedTailParam(param_dict1,param_dict2):
    Wc1=(param_dict1['1.weight']/torch.sqrt(param_dict1['1.running_var']+0.00001)).view(-1,1,1,1)*param_dict1['0.weight']
    bc1=param_dict1['1.bias']-param_dict1['1.weight']*param_dict1['1.running_mean']/torch.sqrt(0.00001+param_dict1['1.running_var'])
    Wc1.numpy().tofile("Tail.Wc1.bin")
    bc1.numpy().tofile("Tail.bc1.bin")
    #
    param_dict2['1.weight'].numpy().tofile("Tail.Wf1.bin")
    param_dict2['1.bias'].numpy().tofile('Tail.bf1.bin')

def folded_param_save(model):
    SaveFoldedHeadParam(model.features[0].state_dict(),model.features[1].state_dict())
    #feature2,16-->96-->24
    SaveFoldedInvertedResidualParam(param_dict=model.features[2].state_dict(),i=0)
    # feature3,24-->144-->24
    SaveFoldedInvertedResidualParam(param_dict=model.features[3].state_dict(),i=1)
    # feature4,24-->144-->32
    SaveFoldedInvertedResidualParam(param_dict=model.features[4].state_dict(),i=2)
    # feature5,32-->192-->32
    SaveFoldedInvertedResidualParam(param_dict=model.features[5].state_dict(),i=3)
    # feature6,32-->192-->32
    SaveFoldedInvertedResidualParam(param_dict=model.features[6].state_dict(),i=4)
    # feature7,32-->192-->64
    SaveFoldedInvertedResidualParam(param_dict=model.features[7].state_dict(),i=5)
    # feature8,64-->384-->64
    SaveFoldedInvertedResidualParam(param_dict=model.features[8].state_dict(),i=6)
    # feature9,64-->384-->64
    SaveFoldedInvertedResidualParam(param_dict=model.features[9].state_dict(),i=7)
    # feature10,64-->384-->64
    SaveFoldedInvertedResidualParam(param_dict=model.features[10].state_dict(),i=8)
    # feature11,64-->384-->96
    SaveFoldedInvertedResidualParam(param_dict=model.features[11].state_dict(),i=9)
    # feature12,96-->576-->96
    SaveFoldedInvertedResidualParam(param_dict=model.features[12].state_dict(),i=10)
    # feature13,96-->576-->96
    SaveFoldedInvertedResidualParam(param_dict=model.features[13].state_dict(),i=11)
    # feature14,96-->576-->160
    SaveFoldedInvertedResidualParam(param_dict=model.features[14].state_dict(),i=12)
    # feature15,160-->960-->160
    SaveFoldedInvertedResidualParam(param_dict=model.features[15].state_dict(),i=13)
    # feature16,160-->960-->160
    SaveFoldedInvertedResidualParam(param_dict=model.features[16].state_dict(),i=14)
    # feature17,160-->960-->320
    SaveFoldedInvertedResidualParam(param_dict=model.features[17].state_dict(),i=15)
    #Tail
    SaveFoldedTailParam(param_dict1=model.features[18].state_dict(),param_dict2=model.classifier.state_dict())

folded_param_save(model)

保存得到的权重参数以及数据集： 在这里插入图片描述

加速器HLS设计

由于MobileNet V2由多个计算构成，因此我们设计了多个IP，分别加速不同的运算，主要有: pwconv:加速point-wise卷积 dwconv:加速depth-wise卷积 conv:加速网络第一层的标准3x3s2卷积（网络第一层计算量也很大，因此也得加速，很无奈) fc:加速全局平均池化层和全连接层 工程代码如下: 在这里插入图片描述这里，我们着重看dwconv和pwconv的设计。

dwconv

dwconv，depth-wise卷积，一个通道对应一个卷积核，因此没有标准卷积中的通道求和操作，如下图所示 在这里插入图片描述我们将该卷积过程分为三个阶段:加载数据、计算卷积以及写回结果，为了掩盖数据的传输时间，我们进行了粗粒度流水线，即乒乓(双缓冲)操作，部分代码如下:

//
	bool pp=true;
	BlockID load_block,com_block,store_block;
	//阶段1
	load_block.ch=0;
	load_block.row=0;
	load_block.col=0;
	load_wrapper(in1,in2,weight,wt_buff1,fm_in_buff1,fm_size,load_block,stride);
	//阶段2
	update_block(o_fm_size,load_block);
	com_block.ch=0;
	com_block.row=0;
	com_block.col=0;
	compute(fm_in_buff1,wt_buff1,bias_buff[com_block.ch/Tm],fm_out_buff1,stride);
	load_wrapper(in1,in2,weight,wt_buff2,fm_in_buff2,fm_size,load_block,stride);
	//
	update_block(o_fm_size,load_block);
	update_block(o_fm_size,com_block);
	store_block.ch=0;
	store_block.row=0;
	store_block.col=0;
	while(1){
#pragma HLS LOOP_TRIPCOUNT min=62 max=62 avg=62
		if(load_block.ch+Tm>channel)
			break;
		if(pp){
			load_wrapper(in1,in2,weight,wt_buff1,fm_in_buff1,fm_size,load_block,stride);
			compute(fm_in_buff2,wt_buff2,bias_buff[com_block.ch/Tm],fm_out_buff2,stride);
			store_output(out1,out2,fm_out_buff1,fm_size,store_block,stride);
		    pp=false;
		}
		else{
			load_wrapper(in1,in2,weight,wt_buff2,fm_in_buff2,fm_size,load_block,stride);
			compute(fm_in_buff1,wt_buff1,bias_buff[com_block.ch/Tm],fm_out_buff1,stride);
			store_output(out1,out2,fm_out_buff2,fm_size,store_block,stride);
			pp=true;
		}
		update_three_block(o_fm_size,load_block,com_block,store_block);
	}
    if(pp){
    	compute(fm_in_buff2,wt_buff2,bias_buff[com_block.ch/Tm],fm_out_buff2,stride);
    	store_output(out1,out2,fm_out_buff1,fm_size,store_block,stride);
    	//
    	update_three_block(o_fm_size,load_block,com_block,store_block);
    	store_output(out1,out2,fm_out_buff2,fm_size,store_block,stride);
    }
    else{
    	compute(fm_in_buff1,wt_buff1,bias_buff[com_block.ch/Tm],fm_out_buff1,stride);
    	store_output(out1,out2,fm_out_buff2,fm_size,store_block,stride);
        //
    	update_three_block(o_fm_size,load_block,com_block,store_block);
    	store_output(out1,out2,fm_out_buff1,fm_size,store_block,stride);
    }

这里我们并没有直接使用DATAFLOW指令，而是通过显示的if-else加乒乓变量实现，综合结果表明，乒乓操作生效了，如下图所示

在这里插入图片描述 同时，为了加快数据传输，我们将接口位宽增大为64bit，可一次性传输4个16bit的定点数，此外，我们还是用了多个传输接口，以进一步增大数据传输的带宽 在这里插入图片描述

pwconv

pwconv,即1x1的标准卷积，它不改变特征图的大小，只改变特征图的通道数，在MobileNet V2中，它起着升维和降维的作用，此外，mobilenet v2的主要计算量都集中在pwconv，因此，加速pwconv是最重要的。 然而，不同于3x3标准卷积，pwconv实际上就是一个矩阵乘法，其计算/访存比较低，是memory-bounded的，因此，设计的思路主要就是增大数据传输的带宽，包括增大接口位宽、增大突发传输长度以及增加接口数目等。 下面是加载输入特征的代码：

void load_input(data_t fm_in_buff[Tn][Tp],data_pack_t* in1,data_pack_t* in2,unsigned short n,unsigned short basePixAddr,unsigned short fm_size,bool flag){
//load input tile In[n:n+Tn][basePixAddr:basePixAddr+Tp]
//load In_interleave[n/4:n/4+1][basePixAddr:basePixAddr+Tp][:]
    unsigned short nn;
    unsigned short i;
    int length;
    if(flag){
    	length=49;
    }
    else{
    	length=Tp;
    }
    for(i=0;i
关注
打赏
1656680865
查看更多评论

最近更新

热门博客

[ 申请 ]友情链接：

搜外友链 笔趣阁 爱思助手 ClashX教程 绘画宝宝 配音宝宝
0.0547s