第八周【任务1】神经网络推理加速(笔记)

推理加速主要针对串行加速

1. SVD分解

$$A_{m\times n}=V_{m\times m}^T\left(\begin{array}{ccccc}{\lambda }_1^{\frac{1}{2}}& & & & \\ & & {\lambda }_2^{\frac{1}{2}}& & \\ & & & \ddots & \\ & & & & \end{array}\right)U_{n\times n}$$

SVD分解进行加速主要分两步

1. Pretrain. 先对一个大的神经网络进行训练，训练个几轮之后，得到一个初步的精度结果。
2. SVD + fine tuning。然后对训练好的大神经网络进行SVD，然后对SVD后的神经网络进行训练，得到一个更好的精度结果。

比如说，原来的大神经网络是一个两层1000个神经元的网络，做了SVD之后，变成了1000，256，1000的三层神经网络，参数量由原来的$1000\times 1000$变为了$1000\times 256+256\times 1000$，参数量就从1000000降到了差不多一半。

有人会问，为何不直接训练1000,256,1000的三层神经网络呢？因为如果直接训练这个参数少的矩阵，很有可能会得到一个性能下降很厉害的结果。而先训练两层网络得到一个大的参数矩阵$W$之后，再做SVD得到两个参数矩阵$W_1,W_2$，这两个矩阵其实尽量保留了$W$的信息。再做fine tuning就能更快的得到更好的结果。

也就是说

1. 直接训练三层网络，得到的最优结果可能准确率也就85%
2. 先训练两层网络，先得到一个95%准确率的优化结果，但是参数太多；做SVD，直接预测，得到一个90%准确率的结果。这依然比直接训练3层网络得到的准确率高。再训练几轮微调，可能又得到95%的准确率结果。

因为第1种方案的初始参数是随机生成的参数，没有什么先验信息。而第2中方案的三层网络是由训练好的两层网络得到的，已经把相当一部分信息参数带过来了。

2. Hidden Node prune

还是假设我们有一个1000*1000的两层神经网络，经过训练之后，有了一个参数矩阵

我们对第二层每个神经元与前一层神经元链接的参数做一个求和，比如我们这里有${\sum }_i\left|w_{i1}\right|$,和${\sum }_i\left|w_{i2}\right|$, 如果第一个神经元连接的参数和比较大，说明这个神经元比较重要，我们要予以保留。但是如果第二个神经元连接的参数和比较小，比如只有0.1，那么说明这个神经元起的作用不大，我们可裁剪权重和的值比较小的这个隐藏层结点。

具体到所有结点，我们可以把每个结点的权重和做一个排序，比如只保留前面最大的60%的结点，剩下的40%的结点都裁剪掉。这样显然会有精度下降，因此我们还是要再做一次fine tuning.

1. pretrain
2. Hidden node prune + fine tuning.

我们既可以考虑前面到某个神经元结点的权重，也可以考虑从某个神经元结点到后面的权重。

3. 知识蒸馏

就是从一个已经训练好的大模型“教”一个小模型。

3.1 KL距离

KL距离，是kullback-leibler差异的简称，也称为相对熵。它衡量的是相同事件空间里的两个概率分布的差异情况。物理意义是：在相同事件空间里，概率分布$P(x)$对应的每个事件，若用概率分布$Q(x)$编码时，平均每个基本事件（符号）编码长度增加了多少比特。
$$D(P\Vert Q)=\sum _{N\in X}P(x)\log \frac{P(x)}{Q(x)}$$
当两个概率分布完全相同时，也就是$P(X)=Q(X)$,其相对熵是0.

我们知道，概率分布$P(X)$的信息熵为
$$H(p)=\sum p(x)\log \frac{1}{p(x)}$$
如果用一个新的非真实分布$Q(X)$来表示来自真实分布$P(X)$的平均编码长度，就是
$$H(p,q)=\sum p(x)\log \frac{1}{q(x)}$$
这时$H(p,q)$就是交叉熵。比如我们有一个含有4个字母（A, B, C, D）标记的数据集中，真实标签分布是$p=(1/2,1/2,0,0)$，也即是A和B出现的概率均为1/2， C和D出现的概率为0.$H(p)=\log 2=1$,也就是只需1位编码就能识别A和B。如果使用分布$q=(1/4,1/4,1/4,1/4)$来编码，$H(p,q)=\log 4=2$，也就是需要2位编码来识别A和B。（这里C和D在真实分布中不会出现）

可见
$$D(P\Vert Q)=H(P,Q)-H(P)=\sum _{x}P(x)\log \frac{P(x)}{Q(x)}$$
因此通常“相对熵”也可称为“交叉熵”，虽然公式上看相对熵=交叉熵-信息熵，但由于真实分布$P$是固定的，$D(P\Vert Q)$由$H(P,Q)$决定。

【注意这里是针对一个样本，针对输出层每个分类结点的加和】

3.2 软标签vs硬标签

知识蒸馏的思想就是用大模型得到软标签，然后用作小模型的标注。

硬标签是通常我们人工标注出来的分类标签，比如下图中的绿色标签，5个分类只有一个分类输出结点是1，其他是0。但是这种分类标签其实留下的“余地”较小。但是如果一个新的样本有点像第4个结点，也有点像第5个结点。比如说一张图片有点像狗又有点像猫，那么用硬标签来训练可能效果就不太好。另外也要考虑到人工标注的错标记问题。因此我们引入软标签，也就是不要让分类标签那么绝对，分配一定的概率在不同标记上，如第二个绿色标签所示。

那么我们怎么得到软标签呢？就是先利用一个大的模型训练得到一批相对比较精确的预测结果，用这些预测结果作为软标签，就是图中的蓝色标签。然后用训练出来的软标签作为真实值去训练下方的小模型。假设这里小模型采用了softmax，那么根据小模型的预测和软标签的不同分布自然得到了相对熵损失函数
$$D(y\Vert S)=\sum y\log y-\sum y\log S$$
又因为只有第二项与小模型训练有关，因此损失函数简化为

$$\begin{array}{rl}L& =-\sum _{i=0}^{n-1}{y}_i\log S_i\\ & =-\sum _{i=0}^{n-1}{y}_i\log \frac{e^{z_i}}{{\sum }_{j=0}^{n-1}{e}^{z_j}}\\ & =-\sum _{i=0}^{n-1}{y}_i(\log e^{z_i}-\log \sum _{j=0}^{n-1}{e}^{z_j})\\ & =-\sum _{i=0}^{n-1}{y}_i{z}_i+\sum _{i=0}^{n-1}{y}_i\log \sum _{j=0}^{n-1}{e}^{z_j}\end{array}$$
所以在做反向传播的时候，对某一个输出结点$z_k$做求导：
$$\begin{array}{rl}\frac{\partial L}{\partial z_k}& =-y_k+\sum _{i=0}^{n-1}{y}_i\frac{e^{z_k}}{{\sum }_{j=0}^{n-1}{e}^{z_j}}\\ & =-y_k+\sum _{i=0}^{n-1}{y}_i{S}_k\\ & =-y_k+S_k\left(\sum _{i=0}^{n-1}{y}_i\right)\\ & =S_k-y_k\end{array}$$
所以写成向量形式就是$\frac{\partial L}{\partial z}=S-y$。

1. pretrain大模型，得到精度95%
2. 直接训练小模型，得到的精度可能只有80%
3. 用大模型TS训练小模型，得到的精读可能是94%

4. LSTM为例子的内部参数共享

这个用的很少，只有少数paper提到这样的方法。也就是把LSTM中输入与四个门之间的四个参数矩阵，彼此之间用一个比例系数相互关联，同时一起训练
$$W_{cx}={\alpha }_1{W}_{ix}={\alpha }_2{W}_{fx}={\alpha }_3{W}_{ox}$$
这里的三个系数也是要训练出来的。

5. 神经网络的量化

在用L1，L2正则化进行训练时，参数w很容易接近于零。我们可以限制w的取值范围是[-10, 10]

这时w是浮点数，我们可以
$$w_1^{\prime }=\frac{\left[w_1\times 2^{32}\right]}{2^{32}}$$
这里的分子进行了取整操作，就意味着，原来的$\frac{w_1\times 2^{32}}{2^{32}}$与$\frac{\left[w_1\times 2^{32}\right]}{2^{32}}$顶多相差$\frac{1}{2^{32}}$.

假设我们神经网络中有两个参数w1, w2，都在[0,1]之间，都进行了这样的处理得到$w_1^{\prime },w_2^{\prime }$，$w_1^{\prime }$与$w_1$相差最多只有$\frac{1}{2^{32}}$.

如果这两个参数要相乘，$w_1^{\prime }\times w_2^{\prime }$那么分母就是$2^{64}$, 只要进行移位操作即可，分子是两个整数相乘，计算也相对容易。

这就是神经网络量化的核心思想：把浮点运算转化为正数运算，比如32bit, 16bit, 8bit。现在用的比较多的是8比特。还使用上面的两个参数作为例子
$$\begin{gathered} w_1^{\prime }=\frac{\left[w_1\times 2^8\right]}{2^8} \\ {w}_2^{\prime }=\frac{\left[w_1\times 2^8\right]}{2^8} \end{gathered}$$
那这样，分母上都是一个移位的操作，分子上都是8位的整数相乘。

运用intel的sse扩张指令集或者arm的neon进行加速运算（也就是硬件直接运算）

这样一次能同时运算多条乘法。一个寄存器有128位，如果我们都是8位的整数运算，就意味着同时能进行16个8位的乘法计算。一个寄存器就能加载16个权重参数。当然也可以转为8个16位的运算。

训练的时候前向后向传播算法也可以利用这种技巧进行微调。比如说某一个参数$w_i$，通过8位量化，就映射到了集合 { i 2 8 } \{\dfrac{i}{2^{8}}\} {28i​}中。因为小数8位量化取整后，分辨率就变成了$\frac{1}{2^8}$，比如$w_i$这个小数本来处于$[\frac{1}{2^8},\frac{2}{2^8}]$之间，它离两端谁更近，它就转化为这个分数。就是把隐层结点参数都映射到集合 { i 2 8 } \{\dfrac{i}{2^{8}}\} {28i​}中，权重更新后，又把更新后的小数映射到集合中的某一个分数。

6. binary net二值化网络

参数就只有-1，1两个参数，放入8位单元中

采用位运算进行加速。

训练时候前向后向传播算法的微调

前向的时候
$$y=\{\begin{array}{ll}1& x>0\\ -1& x<0\end{array}$$
后向传播$\frac{\partial J}{\partial x}=\frac{\partial J}{\partial y}\frac{\partial y}{\partial x}$
$$y=\{\begin{array}{ll}0& x>1\\ 1& -1<x<1\\ 0& x<-1\end{array}$$
但是性能下降太快，用得不是很多

7. 基于FFT的循环矩阵

假设我们先初始化一个结点的参数
$$\left(\begin{array}{lllc}{a}_1,& a_2,& a_3\cdots \cdots & a_n\end{array}\right)=\mathrm{C}$$
然后我们把这一层的结点的参数矩阵写为
$$\left(\begin{array}{cccc}{a}_1,& a_2,& a_3\cdots \cdots & a_n\\ a_{n,}& a_1,& a_2\cdots \cdots & a_{n-1}\\ a_{n-1},& a_n,& a_1\cdots \cdots & a_{n-2}\\ a_2& \cdots & & a_1\end{array}\right)=w$$
这样
$$x=\left(\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right)$$

$$wx=\left(\begin{array}{c}{a}_1{x}_1+\cdots a_n{x}_n\\ a_n{x}_1+\cdots u_{n-1}{x}_n\\ ⋮\\ ⋮\end{array}\right)=c\ast x$$

这就是c和x之间的卷积操作。根据傅里叶变换有
$$\begin{gathered} FFT(c\ast x)=FFT(c)\cdot FFT(x) \\ c\ast x=FF{T}^{-1}\left[FFT(c)\cdot FFT(x)\right] \end{gathered}$$
也就是说为了得到$wx=c\ast x$，可以先算c和x的傅里叶变换，然后相乘，然后再做乘积的傅里叶逆变换。这个傅里叶变换计算速度非常快。