外链是不是把自己的网站信息发布到别人的网站上?,wordpress文章引用格式,网页图片提取工具,建设网站的难点1.引言
模型剪枝本质上是一种利用稀疏性来减少模型大小和计算量#xff0c;从而提高训练和推理效率的技术。它为何会有效呢#xff1f; 理论依据#xff1a;有研究发现#xff0c;在许多深度神经网络中#xff0c;大部分参数是接近于0的#xff0c;这些参数对模型最终的…1.引言
模型剪枝本质上是一种利用稀疏性来减少模型大小和计算量从而提高训练和推理效率的技术。它为何会有效呢 理论依据有研究发现在许多深度神经网络中大部分参数是接近于0的这些参数对模型最终的性能贡献较小。这也就意味着识别并移除那些对模型性能影响较小的参数可以减少模型的复杂度和计算成本并且不会影响到模型的准确性。 根据粒度不同剪枝可以有不同的方法并且不同的模型由于内部结构不同剪枝方法也有所区别。就像卷积神经网络中可以对卷积核剪枝和通道进行剪枝而transformer模型中则可以针对不活跃的自注意力头进行剪枝。
但是不论哪种模型以下三种粒度的剪枝是都适用的
权重级剪枝基于模式剪枝向量级剪枝
本文将以一个二维矩阵为例来分别介绍这三种基本粒度的剪枝为了方便观察我们先来讨论下矩阵的可视化。
2.矩阵可视化
首先用随机数创建一个二维权重矩阵。import torch
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3Dweight torch.rand(8, 8)封装一个可视化函数来直观的显示二维权重矩阵。 注为了后面剪枝的可视化需要我们会在显示时将0值元素与其它元素区分开。 def plot_tensor(tensor, title):fig, ax plt.subplots()# 将矩阵转换为0和非0两个类别并设置两个类别的颜色映射为tab20cax.imshow(tensor.cpu().numpy() 0, vmin0, vmax1, cmaptab20c)ax.set_title(title)ax.set_yticklabels([])ax.set_xticklabels([])# 遍历矩阵为每个文本元素添加文本标签rows, cols tensor.shapefor i in range(rows):for j in range(cols):ax.text(i, j, f{tensor[j, i].item():.2f}, hacenter, vacenter, colork)plt.show()plot_tensor(weight, weight)3.权重级剪枝
权重级剪枝又称为细粒度剪枝以单个权重为剪枝单位在具体操作时一般会定义一个规则来决定移除哪些值。
在下面这个方法中会通过目标张量与掩码相乘的方式将小于threshold阀值的权重都置为0。
def weight_level_pruning(tensor, threshold: float) - torch.Tensor:mask torch.ge(tensor, threshold)return tensor.mul(mask)注1torch.ge函数的作用是对张量中的每个权重值与给定阀值threshold进行逐元素比较大于阀值的会置为True反之则置为False函数运算结果是一个0False)和1(True)组成的掩码。 注2mul 用于对张量进行按元素乘法要求两个矩阵的形状完全相同请与矩阵乘法运算符区分开。 以threshold0.2为例进行剪枝剪枝后的结果如下所示。
pruned_weight weight_level_pruning(weight, 0.2)
plot_tensor(pruned_weight, pruned_weight)权重级剪枝不关心权重在网络中的位置灵活度最高可实现高压缩比。但是它破坏了原有模型的结构现有硬件架构的计算方式通常无法对它进行加速需要特殊的硬件或软件才能利用剪枝后模型的稀疏性所以在目前通用的硬件上运行时速度并不能得到提升。
4.基于模式剪枝
基于模式剪枝通常是基于非常规则的N:M稀疏性进行剪枝它要求在M个连续权重中固定有N个非零值而其余元素均置为0。
下面我们将以2:4稀疏性为例子一步一步说明如何实现N:M稀疏性。
4.1 稀疏模式计算
首先创建一个长度为 4 的一维张量 sequence 并初始化为 0表示总共有4个元素。
sequence torch.zeros(4)
sequencetensor([0., 0., 0., 0.])对张量 patterns 的前 2 个元素设置为 1表示4个元素中固定有2个非零值。
sequence[:2] 1
sequencetensor([1., 1., 0., 0.])用permutations函数生成patterns列表的所有可能排列并用set去重。
from itertools import permutations
patterns set(permutations(sequence.tolist()))
list(patterns)[(0.0, 1.0, 0.0, 1.0),(1.0, 1.0, 0.0, 0.0),(0.0, 1.0, 1.0, 0.0),(1.0, 0.0, 1.0, 0.0),(1.0, 0.0, 0.0, 1.0),(0.0, 0.0, 1.0, 1.0)]这个patterns中包含了长度为4恰好有两个1的所有可能排列模式。
为了方便复数将上面的计算过程封装成一个函数。
def compute_valid_1d_patterns(m, n):patterns torch.zeros(m)patterns[:n] 1# permutations: 用于生成给定序列的所有可能排列valid_patterns torch.Tensor(list(set(permutations(patterns.tolist()))))return valid_patternspatterns compute_valid_1d_patterns(4,2)
patternstensor([[0., 1., 0., 1.],[1., 1., 0., 0.],[0., 1., 1., 0.],[1., 0., 1., 0.],[1., 0., 0., 1.],[0., 0., 1., 1.]])4.2 生成掩码
计算掩码的目的是为了找到每个权重分组每M个连续权重为一组的最佳稀疏模式。
首先生成一个初始掩码它与权重矩阵的形状相同并用 1 填充。然后将其视图更改为形状 (-1, 4)以便我们可以处理每 4 个权重一组。
tensor weight
mask torch.IntTensor(tensor.shape).fill_(1).view(-1, 4)
masktensor([[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1],[1, 1, 1, 1]], dtypetorch.int32)重塑权重矩阵使其形状与掩码一致。
mat tensor.view(-1, 4)
mattensor([[0.6689, 0.4118, 0.9726, 0.9845],[0.8126, 0.4900, 0.8162, 0.0835],[0.5984, 0.1732, 0.7412, 0.2995],[0.7361, 0.1535, 0.9121, 0.1895],[0.8570, 0.1778, 0.1318, 0.5525],[0.0492, 0.5464, 0.4381, 0.2630],[0.9935, 0.0955, 0.6935, 0.7049],[0.1594, 0.5785, 0.9095, 0.8378],[0.0899, 0.0569, 0.7214, 0.3372],[0.3512, 0.9062, 0.0120, 0.7077],[0.1819, 0.6778, 0.7691, 0.5124],[0.3399, 0.4008, 0.2745, 0.2768],[0.9185, 0.1250, 0.9466, 0.5318],[0.9118, 0.1470, 0.6657, 0.6492],[0.1116, 0.8223, 0.7062, 0.2872],[0.1826, 0.4946, 0.5415, 0.8882]])对于每一行权重我们计算其绝对值与所有稀疏模式的点积得到每一行权重在每一种稀疏模式下的加权和。mat_patterns torch.matmul(mat.abs(), patterns.t())
mat_patternstensor([[1.3963, 1.0807, 1.3844, 1.6415, 1.6534, 1.9571],[0.5735, 1.3027, 1.3062, 1.6288, 0.8961, 0.8997],[0.4727, 0.7716, 0.9144, 1.3396, 0.8979, 1.0406],[0.3429, 0.8896, 1.0656, 1.6481, 0.9255, 1.1015],[0.7304, 1.0348, 0.3096, 0.9888, 1.4095, 0.6843],[0.8095, 0.5956, 0.9845, 0.4873, 0.3122, 0.7012],[0.8005, 1.0890, 0.7891, 1.6870, 1.6984, 1.3985],[1.4162, 0.7379, 1.4880, 1.0689, 0.9972, 1.7473],[0.3941, 0.1468, 0.7783, 0.8113, 0.4271, 1.0585],[1.6139, 1.2574, 0.9183, 0.3632, 1.0589, 0.7197],[1.1902, 0.8597, 1.4469, 0.9510, 0.6943, 1.2815],[0.6776, 0.7407, 0.6752, 0.6144, 0.6167, 0.5513],[0.6569, 1.0435, 1.0717, 1.8651, 1.4503, 1.4785],[0.7962, 1.0587, 0.8126, 1.5774, 1.5610, 1.3149],[1.1095, 0.9339, 1.5285, 0.8177, 0.3988, 0.9934],[1.3828, 0.6772, 1.0361, 0.7240, 1.0708, 1.4296]])我们只需要保留加权和最大的模式即可为每一行权重选择加权和最大的模式索引
pmax torch.argmax(mat_patterns, dim1)
pmaxtensor([5, 3, 3, 3, 4, 2, 4, 5, 5, 0, 2, 1, 3, 3, 2, 5])使用 pmax 索引从稀疏模式中为每一行权重选择相应的模式然后将其赋值给掩码
mask[:] patterns[pmax[:]]
masktensor([[0, 0, 1, 1],[1, 0, 1, 0],[1, 0, 1, 0],[1, 0, 1, 0],[1, 0, 0, 1],[0, 1, 1, 0],[1, 0, 0, 1],[0, 0, 1, 1],[0, 0, 1, 1],[0, 1, 0, 1],[0, 1, 1, 0],[1, 1, 0, 0],[1, 0, 1, 0],[1, 0, 1, 0],[0, 1, 1, 0],[0, 0, 1, 1]], dtypetorch.int32)最后将掩码视图重塑回原始权重的形状。
mask mask.view(tensor.shape)
masktensor([[0, 0, 1, 1, 1, 0, 1, 0],[1, 0, 1, 0, 1, 0, 1, 0],[1, 0, 0, 1, 0, 1, 1, 0],[1, 0, 0, 1, 0, 0, 1, 1],[0, 0, 1, 1, 0, 1, 0, 1],[0, 1, 1, 0, 1, 1, 0, 0],[1, 0, 1, 0, 1, 0, 1, 0],[0, 1, 1, 0, 0, 0, 1, 1]], dtypetorch.int32)同样将上面计算掩码的过程封装为一个函数。
def compute_mask(tensor, m, n):# 计算所有可能的模式patterns compute_valid_1d_patterns(m,n) # m中取n所有可能的模式N行4列# 生成初始掩码mask torch.IntTensor(tensor.shape).fill_(1).view(-1,m) # 将张量转换成列为m的格式若不能整除m则填充0if tensor.shape[1] % m 0:mat torch.FloatTensor(tensor.shape[0], tensor.shape[1] (m - tensor.shape[1] % m)).fill_(0)mat[:, : tensor.shape[1]] tensormat mat.view(-1, m)else:mat tensor.view(-1, m) pmax torch.argmax(torch.matmul(mat.abs(), patterns.t()), dim1) # 16行N列每一行的点积操作都得到N种可能取点积最大值的元素下标mask[:] patterns[pmax[:]] # 找到最大下标对应的排列mask mask.view(tensor.shape) # 再转换成tensor的形状return maskmask compute_mask(weight, 4, 2)
masktensor([[0, 0, 1, 1, 1, 0, 1, 0],[1, 0, 1, 0, 1, 0, 1, 0],[1, 0, 0, 1, 0, 1, 1, 0],[1, 0, 0, 1, 0, 0, 1, 1],[0, 0, 1, 1, 0, 1, 0, 1],[0, 1, 1, 0, 1, 1, 0, 0],[1, 0, 1, 0, 1, 0, 1, 0],[0, 1, 1, 0, 0, 0, 1, 1]], dtypetorch.int32)4.3 用掩码剪枝
pruned_pattern tensor.mul(mask)
plot_tensor(pruned_pattern, pruned_pattern)可以看到2:4稀疏性将一半权重都置为了0每4个权重中保留了两个非0权重我们成功地在权重矩阵上应用了 2:4 稀疏性。 虽然都属于非结构化索引但与前面基于权重的索引不同的是2:4结构的稀疏性可以被英伟达的稀疏张量核心加速。在运算时稀疏矩阵W首先会被压缩压缩后的矩阵存储着非零的数据值而metadata则存储着对应非零元素在原矩阵W中的索引信息。 具体来说metadata会将W中非零元素的行号和列号压缩成两个独立的一维数组这两个数组就是metadata中存储的索引信息。 注N:M 稀疏性是一种有效的稀疏技术这种稀疏模式不仅减少了模型大小还提高了计算效率特别适用于硬件加速器如 GPU 和 TPU从而加速深度学习模型的训练和推理过程。 5.向量级剪枝
向量级剪枝以行或列为单位对权重进行裁剪。
def vector_pruning(tensor, point):rows, cols pointprune_weight tensor.clone()prune_weight[rows, :] 0prune_weight[:, cols] 0return prune_weightpoint (2,3)
pruned_vector vector_pruning(weight, point)
plot_tensor(pruned_vector, pruned_vector)经过上面的向量级剪枝后可以直接去掉一行一列整个权重矩阵的形状可以直接由[8,8]变为[7,7], 因此向量级剪枝属于结构化剪枝。
通常在进行向量级别的剪枝时需要对模型的所有层统一进行剪枝其目的是在整个模型中保持一致的稀疏结构以确保上下游各层中结构和计算的一致性。因此这种方法被称为“全局剪枝”或“统一剪枝”。
小结本文主要介绍了权重级剪枝、基于模式剪枝和向量级剪枝三种不同粒度的剪枝方法并结合可视化的方式一步一步详细演示了每种剪枝方法的运算过程和剪枝前后权重矩阵的变化。在实际场景中基于模式的剪枝越来越受到青睐因为其规则的稀疏模式可以充分利用硬件加速器的计算能力从而显著提高计算效率。
参考阅读
模型压缩概览Awesome Compression
