pytorch实现模型剪枝的操作方法

岭南综艺电影

一，剪枝分类

所谓模型剪枝，其实是一种从神经网络中移除"不必要"权重或偏差（weigths/bias）的模型压缩技术。关于什么参数才是“不必要的”，这是一个目前依然在研究的领域。

1.1，非结构化剪枝

非结构化剪枝（Unstructured Puning）是指修剪参数的单个元素，比如全连接层中的单个权重、卷积层中的单个卷积核参数元素或者自定义层中的浮点数（scaling floats）。其重点在于，剪枝权重对象是随机的，没有特定结构，因此被称为非结构化剪枝。

1.2，结构化剪枝

与非结构化剪枝相反，结构化剪枝会剪枝整个参数结构。比如，丢弃整行或整列的权重，或者在卷积层中丢弃整个过滤器（

1. Filter

复制代码

）。

1.3，本地与全局修剪

剪枝可以在每层（局部）或多层/所有层（全局）上进行。

二，PyTorch 的剪枝

目前 PyTorch 框架支持的权重剪枝方法有:

• Random: 简单地修剪随机参数。
  
• Magnitude: 修剪权重最小的参数（例如它们的 L2 范数）
  

以上两种方法实现简单、计算容易，且可以在没有任何数据的情况下应用。

2.1，pytorch 剪枝工作原理

剪枝功能在

1. torch.nn.utils.prune

复制代码

类中实现，代码在文件 torch/nn/utils/prune.py 中，主要剪枝类如下图所示。

剪枝原理是基于张量（Tensor）的掩码（Mask）实现。掩码是一个与张量形状相同的布尔类型的张量，掩码的值为 True 表示相应位置的权重需要保留，掩码的值为 False 表示相应位置的权重可以被删除。
Pytorch 将原始参数

1. <param>

复制代码

复制到名为

1. <param>_original

复制代码

的参数中，并创建一个缓冲区来存储剪枝掩码

1. <param>_mask

复制代码

。同时，其也会创建一个模块级的 forward_pre_hook 回调函数（在模型前向传播之前会被调用的回调函数），将剪枝掩码应用于原始权重。
pytorch 剪枝的

1. api

复制代码

和教程比较混乱，我个人将做了如下表格，希望能将 api 和剪枝方法及分类总结好。

pytorch 中进行模型剪枝的工作流程如下：

• 选择剪枝方法（或者子类化 BasePruningMethod 实现自己的剪枝方法）。
  
• 指定剪枝模块和参数名称。
  
• 设置剪枝方法的参数，比如剪枝比例等。
  

2.2，局部剪枝

Pytorch 框架中的局部剪枝有非结构化和结构化剪枝两种类型，值得注意的是结构化剪枝只支持局部不支持全局。

2.2.1，局部非结构化剪枝

1，局部非结构化剪枝（Locall Unstructured Pruning）对应函数原型如下：

1. def random_unstructured(module, name, amount)

复制代码

1，函数功能：
用于对权重参数张量进行非结构化剪枝。该方法会在张量中随机选择一些权重或连接进行剪枝，剪枝率由用户指定。
2，函数参数定义：

• 1. module

  复制代码
  (nn.Module): 需要剪枝的网络层/模块，例如 nn.Conv2d() 和 nn.Linear()。
  
• 1. name 

  复制代码
  (str): 要剪枝的参数名称，比如 "weight" 或 "bias"。
  
• 1. amount

  复制代码
  (int or float): 指定要剪枝的数量，如果是 0~1 之间的小数，则表示剪枝比例；如果是证书，则直接剪去参数的绝对数量。比如
  1. amount=0.2

  复制代码
  ，表示将随机选择 20% 的元素进行剪枝。
  

3，下面是

1. random_unstructured

复制代码

函数的使用示例。

1. import torch
   
2. import torch.nn.utils.prune as prune
   
3. conv = torch.nn.Conv2d(1, 1, 4)
   
4. prune.random_unstructured(conv, name="weight", amount=0.5)
   
5. conv.weight
   
6. """
   
7. tensor([[[[-0.1703,  0.0000, -0.0000,  0.0690],
   
8.           [ 0.1411,  0.0000, -0.0000, -0.1031],
   
9.           [-0.0527,  0.0000,  0.0640,  0.1666],
   
10.           [ 0.0000, -0.0000, -0.0000,  0.2281]]]], grad_fn=<MulBackward0>)
    
11. """

复制代码

可以看书输出的 conv 层中权重值有一半比例为

1. 0

复制代码

。

2.2.2，局部结构化剪枝

局部结构化剪枝（Locall Structured Pruning）有两种函数，对应函数原型如下：

1. def random_structured(module, name, amount, dim)
   
2. def ln_structured(module, name, amount, n, dim, importance_scores=None)

复制代码

1，函数功能
与非结构化移除的是连接权重不同，结构化剪枝移除的是整个通道权重。
2，参数定义
与局部非结构化函数非常相似，唯一的区别是您必须定义 dim 参数(ln_structured 函数多了

1. n

复制代码

参数)。

1. n

复制代码

表示剪枝的范数，

1. dim

复制代码

表示剪枝的维度。
对于 torch.nn.Linear：

• 1. dim = 0

  复制代码
  ： 移除一个神经元。
  
• 1. dim = 1

  复制代码
  ：移除与一个输入的所有连接。
  

对于 torch.nn.Conv2d：

• 1. dim = 0

  复制代码
  (Channels) : 通道 channels 剪枝/过滤器 filters 剪枝
  
• 1. dim = 1

  复制代码
  （Neurons）: 二维卷积核 kernel 剪枝，即与输入通道相连接的 kernel
  

2.2.3，局部结构化剪枝示例代码

在写示例代码之前，我们先需要理解

1. Conv2d

复制代码

函数参数、卷积核 shape、轴以及张量的关系。
首先，Conv2d 函数原型如下;

1. class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

复制代码

而 pytorch 中常规卷积的卷积核权重

1. shape

复制代码

都为（

1. C_out, C_in, kernel_height, kernel_width

复制代码

），所以在代码中卷积层权重

1. shape

复制代码

为

1. [3, 2, 3, 3]

复制代码

，dim = 0 对应的是 shape [3, 2, 3, 3] 中的

1. 3

复制代码

。这里我们 dim 设定了哪个轴，那自然剪枝之后权重张量对应的轴机会发生变换。

理解了前面的关键概念，下面就可以实际使用了，

1. dim=0

复制代码

的示例如下所示。

1. conv = torch.nn.Conv2d(2, 3, 3)
   
2. norm1 = torch.norm(conv.weight, p=1, dim=[1,2,3])
   
3. print(norm1)
   
4. """
   
5. tensor([1.9384, 2.3780, 1.8638], grad_fn=<NormBackward1>)
   
6. """
   
7. prune.ln_structured(conv, name="weight", amount=1, n=2, dim=0)
   
8. print(conv.weight)
   
9. """
   
10. tensor([[[[-0.0005,  0.1039,  0.0306],
    
11.           [ 0.1233,  0.1517,  0.0628],
    
12.           [ 0.1075, -0.0606,  0.1140]],
    
13. 
    
14.          [[ 0.2263, -0.0199,  0.1275],
    
15.           [-0.0455, -0.0639, -0.2153],
    
16.           [ 0.1587, -0.1928,  0.1338]]],
    
17. 
    
18. 
    
19.         [[[-0.2023,  0.0012,  0.1617],
    
20.           [-0.1089,  0.2102, -0.2222],
    
21.           [ 0.0645, -0.2333, -0.1211]],
    
22. 
    
23.          [[ 0.2138, -0.0325,  0.0246],
    
24.           [-0.0507,  0.1812, -0.2268],
    
25.           [-0.1902,  0.0798,  0.0531]]],
    
26. 
    
27. 
    
28.         [[[ 0.0000, -0.0000, -0.0000],
    
29.           [ 0.0000, -0.0000, -0.0000],
    
30.           [ 0.0000, -0.0000,  0.0000]],
    
31. 
    
32.          [[ 0.0000,  0.0000,  0.0000],
    
33.           [-0.0000,  0.0000,  0.0000],
    
34.           [-0.0000, -0.0000, -0.0000]]]], grad_fn=<MulBackward0>)
    
35. """

复制代码

从运行结果可以明显看出，卷积层参数的最后一个通道参数张量被移除了（为

1. 0

复制代码

张量），其解释参见下图。

1. dim = 1

复制代码

的情况：

1. conv = torch.nn.Conv2d(2, 3, 3)
   
2. norm1 = torch.norm(conv.weight, p=1, dim=[0, 2,3])
   
3. print(norm1)
   
4. """
   
5. tensor([3.1487, 3.9088], grad_fn=<NormBackward1>)
   
6. """
   
7. prune.ln_structured(conv, name="weight", amount=1, n=2, dim=1)
   
8. print(conv.weight)
   
9. """
   
10. tensor([[[[ 0.0000, -0.0000, -0.0000],
    
11.           [-0.0000,  0.0000,  0.0000],
    
12.           [-0.0000,  0.0000, -0.0000]],
    
13. 
    
14.          [[-0.2140,  0.1038,  0.1660],
    
15.           [ 0.1265, -0.1650, -0.2183],
    
16.           [-0.0680,  0.2280,  0.2128]]],
    
17. 
    
18. 
    
19.         [[[-0.0000,  0.0000,  0.0000],
    
20.           [ 0.0000,  0.0000, -0.0000],
    
21.           [-0.0000, -0.0000, -0.0000]],
    
22. 
    
23.          [[-0.2087,  0.1275,  0.0228],
    
24.           [-0.1888, -0.1345,  0.1826],
    
25.           [-0.2312, -0.1456, -0.1085]]],
    
26. 
    
27. 
    
28.         [[[-0.0000,  0.0000,  0.0000],
    
29.           [ 0.0000, -0.0000,  0.0000],
    
30.           [ 0.0000, -0.0000,  0.0000]],
    
31. 
    
32.          [[-0.0891,  0.0946, -0.1724],
    
33.           [-0.2068,  0.0823,  0.0272],
    
34.           [-0.2256, -0.1260, -0.0323]]]], grad_fn=<MulBackward0>)
    
35. """

复制代码

很明显，对于

1. dim=1

复制代码

的维度，其第一个张量的 L2 范数更小，所以shape 为 [2, 3, 3] 的张量中，第一个 [3, 3] 张量参数会被移除（即张量为 0 矩阵） 。

2.3，全局非结构化剪枝

前文的 local 剪枝的对象是特定网络层，而 global 剪枝是将模型看作一个整体去移除指定比例（数量）的参数，同时 global 剪枝结果会导致模型中每层的稀疏比例是不一样的。
全局非结构化剪枝函数原型如下：

1. # v1.4.0 版本
   
2. def global_unstructured(parameters, pruning_method, **kwargs)
   
3. # v2.0.0-rc2版本
   
4. def global_unstructured(parameters, pruning_method, importance_scores=None, **kwargs):

复制代码

1，函数功能：
随机选择全局所有参数（包括权重和偏置）的一部分进行剪枝，而不管它们属于哪个层。
2，参数定义：

• 1. parameters

  复制代码
  （(Iterable of (module, name) tuples)）: 修剪模型的参数列表，列表中的元素是 (module, name)。
  
• 1. pruning_method

  复制代码
  （function）: 目前好像官方只支持 pruning_method=prune.L1Unstuctured，另外也可以是自己实现的非结构化剪枝方法函数。
  
• 1. importance_scores

  复制代码
  : 表示每个参数的重要性得分，如果为 None，则使用默认得分。
  
• 1. **kwargs

  复制代码
  : 表示传递给特定剪枝方法的额外参数。比如
  1. amount

  复制代码
  指定要剪枝的数量。
  

3，

1. global_unstructured

复制代码

函数的示例代码如下所示。

1. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
   
2. 
   
3. class LeNet(nn.Module):
   
4.     def __init__(self):
   
5.         super(LeNet, self).__init__()
   
6.         # 1 input image channel, 6 output channels, 3x3 square conv kernel
   
7.         self.conv1 = nn.Conv2d(1, 6, 3)
   
8.         self.conv2 = nn.Conv2d(6, 16, 3)
   
9.         self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 5x5 image dimension
   
10.         self.fc2 = nn.Linear(120, 84)
    
11.         self.fc3 = nn.Linear(84, 10)
    
12. 
    
13.     def forward(self, x):
    
14.         x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
    
15.         x = F.max_pool2d(F.relu(self.conv2(x)), 2)
    
16.         x = x.view(-1, int(x.nelement() / x.shape[0]))
    
17.         x = F.relu(self.fc1(x))
    
18.         x = F.relu(self.fc2(x))
    
19.         x = self.fc3(x)
    
20.         return x
    
21. 
    
22. model = LeNet().to(device=device)
    
23. 
    
24. model = LeNet()
    
25. 
    
26. parameters_to_prune = (
    
27.     (model.conv1, 'weight'),
    
28.     (model.conv2, 'weight'),
    
29.     (model.fc1, 'weight'),
    
30.     (model.fc2, 'weight'),
    
31.     (model.fc3, 'weight'),
    
32. )
    
33. 
    
34. prune.global_unstructured(
    
35.     parameters_to_prune,
    
36.     pruning_method=prune.L1Unstructured,
    
37.     amount=0.2,
    
38. )
    
39. # 计算卷积层和整个模型的稀疏度
    
40. # 其实调用的是 Tensor.numel 内内函数，返回输入张量中元素的总数
    
41. print(
    
42.     "Sparsity in conv1.weight: {:.2f}%".format(
    
43.         100. * float(torch.sum(model.conv1.weight == 0))
    
44.         / float(model.conv1.weight.nelement())
    
45.     )
    
46. )
    
47. print(
    
48.     "Global sparsity: {:.2f}%".format(
    
49.         100. * float(
    
50.             torch.sum(model.conv1.weight == 0)
    
51.             + torch.sum(model.conv2.weight == 0)
    
52.             + torch.sum(model.fc1.weight == 0)
    
53.             + torch.sum(model.fc2.weight == 0)
    
54.             + torch.sum(model.fc3.weight == 0)
    
55.         )
    
56.         / float(
    
57.             model.conv1.weight.nelement()
    
58.             + model.conv2.weight.nelement()
    
59.             + model.fc1.weight.nelement()
    
60.             + model.fc2.weight.nelement()
    
61.             + model.fc3.weight.nelement()
    
62.         )
    
63.     )
    
64. )
    
65. # 程序运行结果
    
66. """
    
67. Sparsity in conv1.weight: 3.70%
    
68. Global sparsity: 20.00%
    
69. """

复制代码

运行结果表明，虽然模型整体（全局）的稀疏度是

1. 20%

复制代码

，但每个网络层的稀疏度不一定是 20%。

三，总结

另外，pytorch 框架还提供了一些帮助函数:

• torch.nn.utils.prune.is_pruned(module): 判断模块 是否被剪枝。
  
• torch.nn.utils.prune.remove(module, name)： 用于将指定模块中指定参数上的剪枝操作移除，从而恢复该参数的原始形状和数值。
  

虽然 PyTorch 提供了内置剪枝

1. API

复制代码

，也支持了一些非结构化和结构化剪枝方法，但是

1. API

复制代码

比较混乱，对应文档描述也不清晰，所以后面我还会结合微软的开源

1. nni

复制代码

工具来实现模型剪枝功能。

参考资料

• How to Prune Neural Networks with PyTorch
  
• PRUNING TUTORIAL
  
• PyTorch Pruning
  

到此这篇关于pytorch实现模型剪枝的文章就介绍到这了,更多相关pytorch模型剪枝内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源:https://www.jb51.net/article/276374.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！