FaceNet在FPGA等硬件平台上的实现

布满荆棘的人生 2021-11-19 11:16 268阅读 0赞

本文主要介绍将训练好的网络模型，移植到FPGA等硬件平台上所必须的准备工作。  
不涉及具体的用C语言重新编写卷积操作、RAM存储等设计，本人做的只是辅助工作=-=。

## 项目简介 ##

**论文地址**：[FaceNet: A Unified Embedding for Face Recognition and Clustering][FaceNet_ A Unified Embedding for Face Recognition and Clustering]

将在服务器上训练好的FaceNet模型移植到FPGA等硬件平台上，实现人脸的检测推断过程。要想实现上述操作，必须先进行下面2个操作：

1.  **模型参数的提取**：解析 FaceNet 的网络结构， Restore 训练好的模型，提取各网络层参数。
2.  **参数的量化压缩**：模型参数量巨大(浮点)，为了节省空间及方便计算，将参数量化为 8 位的  
    定点数。

### 参数的提取 ###

在提取参数前，我们先通过可视化工具`Tensorboard`解析了一下FaceNet的网络结构，它主要包含5个大模块：

#### block35 ####

1.  **Branch\_0**：32个 1 × 1 1 \\times 1 1×1卷积
2.  **Branch\_1**：32个 1 × 1 1 \\times 1 1×1卷积、32个 3 × 3 3 \\times 3 3×3卷积
3.  **Branch\_2**：32个 1 × 1 1 \\times 1 1×1卷积、32个 3 × 3 3 \\times 3 3×3卷积、32个 3 × 3 3 \\times 3 3×3卷积
4.  **Mixed**：将Branch\_0、Branch\_1和Branch\_2连接起来
5.  **Conv**：32个 1 × 1 1 \\times 1 1×1卷积

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70]

#### block17 ####

1.  **Branch\_0**：128个 1 × 1 1 \\times 1 1×1卷积
2.  **Branch\_1**：128个 1 × 1 1 \\times 1 1×1卷积、128个 1 × 7 1 \\times 7 1×7卷积、128个 7 × 1 7 \\times 1 7×1卷积
3.  **Mixed**：将Branch\_0和Branch\_1连接起来
4.  **Conv**：128个 1 × 1 1 \\times 1 1×1卷积

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 1]

#### block8 ####

1.  **Branch\_0**：192个 1 × 1 1 \\times 1 1×1卷积
2.  **Branch\_1**：192个 1 × 1 1 \\times 1 1×1卷积、192个 1 × 3 1 \\times 3 1×3卷积、192个 3 × 1 3 \\times 1 3×1卷积
3.  **Mixed**：将Branch\_0和Branch\_1连接起来
4.  **Conv**：192个 1 × 1 1 \\times 1 1×1卷积

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 2]

#### reduction\_a ####

1.  **Branch\_0**：192个 3 × 3 3 \\times 3 3×3（stride=2）卷积
2.  **Branch\_1**：192个 1 × 1 1 \\times 1 1×1卷积、256个 3 × 3 3 \\times 3 3×3卷积、384个 3 × 3 3 \\times 3 3×3（stride=2）卷积
3.  **Branch\_2**： 3 × 3 3 \\times 3 3×3，步长为2的最大池化
4.  **Mixed**：将Branch\_0、Branch\_1和Branch\_2连接起来

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 3]

#### reduction\_b ####

1.  **Branch\_0**：256个 1 × 1 1 \\times 1 1×1卷积、384个 3 × 3 3 \\times 3 3×3（stride=2）卷积
2.  **Branch\_1**：256个 1 × 1 1 \\times 1 1×1卷积、256个 3 × 3 3 \\times 3 3×3（stride=2）卷积
3.  **Branch\_2**：256个 1 × 1 1 \\times 1 1×1卷积、256个 3 × 3 3 \\times 3 3×3卷积、256个 3 × 3 3 \\times 3 3×3（stride=2）卷积
4.  **Branch\_3**： 3 × 3 3 \\times 3 3×3，步长为2的最大池化
5.  **Mixed**：将Branch\_0、Branch\_1、Branch\_2和Branch\_3连接起来

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 4]

**总的网络结构如下所示**：

1.  **Conv2d\_1a**：32个 3 × 3 3 \\times 3 3×3，stride=2的卷积
2.  **Conv2d\_2a**：32个 3 × 3 3 \\times 3 3×3的卷积
3.  **Conv2d\_2b**：64个 3 × 3 3 \\times 3 3×3的卷积
4.  **MaxPool\_3a**： 3 × 3 3 \\times 3 3×3，stride=2的最大池化
5.  **Conv2d\_3b**：80个 1 × 1 1 \\times 1 1×1的卷积
6.  **Conv2d\_4a**：192个 3 × 3 3 \\times 3 3×3的卷积
7.  **Conv2d\_4b**：256个 3 × 3 3 \\times 3 3×3，stride=2的卷积
8.  **repeat**：5个**block35**模块
9.  **Mixed\_6a**：1个**reduction\_a**模块
10. **repeat1**：10个**block17**模块
11. **Mixed\_7a**：1个**reduction\_b**模块
12. **repeat2**：5个**block8**模块
13. **block8**：1个**block8**模块
14. **Logits**：平均池化、flatten、Dropout

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 5]

#### 代码实现 ####

代码中会用到`float_to_bin()`这一个量化函数，下面会有所介绍

import os
    from tensorflow.python import pywrap_tensorflow
    import  numpy as np
    import math
    import float_bin
    import xiaoshu_bin
    Max = 35.004695892333984          #参数的最大值
    Min = -11.588409423828125         #参数最小值
    Mean = -0.0007627065894155365     #参数均值
    
    #导入模型
    checkpoint_path = os.path.join('facenet_lmq/20170512-110547', "model-20170512-110547.ckpt-250000")
    #读取模型参数
    reader = pywrap_tensorflow.NewCheckpointReader(checkpoint_path)
    #获取参数中所有的key、value值
    var_to_shape_map = reader.get_variable_to_shape_map()
    
    #循环存储每一个key（tensor名字）对应的value
    for key in var_to_shape_map:
        par_name=str(key)
        par_final_name =par_name.replace('/','_') #特殊字符替换
        file_path = 'D:/PycharmProjects/faceface/bb/'+par_final_name+'.txt' #创建存储路径
        par_shape=reader.get_tensor(key).shape         # Tensor维度
        par_value=reader.get_tensor(key).flatten()     #value拉平，方便下面的量化操作
        # print(type(par_value))
        # print(par_value.shape)
        list =[]
        for index in range(len(par_value)):  #对每一个tensor的value量化
            par_value[index] =(par_value[index]-Mean)/(Max-Min) #归一化
            if ('moving_variance' in par_name):       # 特殊的tensor需要进行一些处理（BN）
                # for index in range(len(par_value)):
                par_value[index] = 1/(math.sqrt(par_value[index]))
            list.append(float_bin.float_to_bin(par_value[index]))  #调用量化函数float_to_bin（）
        np.savetxt(file_path,np.array(list),fmt='%s',header=str(par_shape))  #存储量化后的参数
        print('done')
        #print(type(par_value))

### 参数的量化压缩 ###

训练得到的模型参数都是浮点型的，为了节省在硬件上的存储空间并加速计算，我们将参数量化到了8位的定点数。主要包含2个函数：`float_to_bin()`和`xiaoshu_bin()`。

1.  **float\_to\_bin()**

import numpy as np
    import xiaoshu_bin
    import math
    def float_to_bin(innum,n):
        global innum_abs,res_nint_array
        list = []
        min = 2**(-n)              #小数位取n位后，8位定点数能表示的最小值
        max = 2**(7-n)-min         #小数位取n位后，8位定点数能表示的最大值
        innum_abs = abs(innum)     #不管正负，都按正数处理
        if (innum_abs<min):        #如果表示的数小于最小，按最小处理
            innum_abs = min
        if (innum_abs>max):        #如果表示的数大于最大，按最大处理
            innum_abs =max
        nint = math.floor(innum_abs)     #取整，分割小数部分和整数部分
        nf = innum_abs-nint              #小数部分
        res_nint = bin(int(nint)).replace('0b','')   #整数部分直接调用bin函数处理
        nint_num = len(res_nint)                     #整数部分的二进制表示占的位数长度
        res_nint_array =np.zeros(nint_num)           #创建矩阵
        #print(nint_num)
        res_nf = xiaoshu_bin.xiaoshu(nf,n)           #小数部分调用xiaoshu_bin()函数
        if (innum>=0):                               #原数为正数，二进制第一位为0
            c =0
            num_add =8-n-nint_num                    #除去小数位和整数位占的二进制位数后，还剩几位
            num_add =np.zeros(num_add)               #补0
            for value in res_nint:
                res_nint_array[c] =int(value)        #整数部分二进制
                c= c+1
            #@final =[num_add,res_nint_array,n,res_nf]
        else:                                            #原数为负数，二进制第一位为1
            d =0
            num_add = 8-n-nint_num
            num_add = np.zeros(num_add)
            num_add[0] =1
            for value in res_nint:
                res_nint_array[d] =int(value)
                d= d+1
            #final = [num_add,res_nint_array,n,res_nf]
        final_bin =np.hstack((num_add,res_nint_array,res_nf))  #最终表示
        for bin_value in final_bin:
            list.append(str(int(bin_value)))                 #字符串输出
        final_bin_value =''.join(list)
        return final_bin_value
    #print(float_to_bin(-4.5，3))

1.  **xiaoshu\_bin()**

import numpy as np
    def xiaoshu(innum, n):
        global N
        N =n                       #小数部分占的位数
        count =0
        temp = innum
        reco =np.zeros(N)        #创建全0矩阵
    
        if (innum>1) or (N==0):   #不是小数
            print('Error!')
            return
        while(N):                #未超过小数部分的位数
            count =count+1
            if (count>N):
                N = 0
                return reco
            temp =temp*2              #小数部分不断的乘2
            if (temp>1):
                reco[count-1] =1
                temp = temp-1
            elif (temp==1):
                reco[count-1] =1
                N =0
            else:
                reco[count-1] =0
    
        return (reco)
    #print(xiaoshu(0.0525,4))

### 量化结果展示 ###

以`InceptionResnetV1/Block8/Branch_0/Conv2d_1x1/BatchNorm_beta`这一tensor为例：

**量化前后对比**：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 6]

[FaceNet_ A Unified Embedding for Face Recognition and Clustering]: https://arxiv.org/abs/1503.03832
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70]: /images/20211119/56f8573874964673876f83dad760f26b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 1]: /images/20211119/1236d09189ad445386bb42426766d30d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 2]: /images/20211119/d0ee5fffbe9d4104b4a133808c27dcf3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 3]: /images/20211119/68e50c9f464c49618e61996b0cc611b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 4]: /images/20211119/ff4ab7473bf1493f8a6e68ff1fe5fa15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 5]: /images/20211119/c80bfc55ac2349faa6dd2b7110b7cb77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JsdWVzbGl1Zg_size_16_color_FFFFFF_t_70 6]: /images/20211119/f55ba303c0394092a61c41d322e31b56.png