devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

模型剪枝初级方法_halcon中的pruned model

作者：我家自动化 | 2024-03-05 11:38:44

赞

踩

halcon中的pruned model

信息源：https://www.bilibili.com/video/BV147411W7am/?spm_id_from=333.788.recommend_more_video.2&vd_source=3969f30b089463e19db0cc5e8fe4583a

1、剪枝的含义

把不重要的参数去掉，计算就更快了，模型的大小就变小了（本文涉及的剪枝方式没有这个功能）。

2、全连接层的剪枝

上述剪枝就是把一些weight置为0，这样计算就更快了。

计算掩码矩阵的过程：

 接下来要做的：

（1）给每一层增加一个变量，用于存储mask

（2）设计一个函数，用于计算mask

3、卷积层剪枝

 假如有4个卷积核，计算每个卷积核的L2范数，哪个卷积核的范数值最小则对应的mask全部置为0.如上图灰色的部分。

4、代码部分

GitHub - mepeichun/Efficient-Neural-Network-Bilibili: B站Efficient-Neural-Network学习分享的配套代码

5、全连接层剪枝

（1）剪枝思路

假设剪枝的比例为50%。

找到每一个linear的layer，然后取参数的50%分位数，接着构造mask，所有大于50%分位数的mask位置置为1，所有小于等于50%分位数的mask位置置为0。

最后weight * mask得到新的weight。

（2）剪枝代码

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4. from torchvision import datasets, transforms
  5. import torch.utils.data
  6. import numpy as np
  7. import math
  8. from copy import deepcopy
  9.  
  10. def to_var(x, requires_grad=False):
  11.     if torch.cuda.is_available():
  12.         x = x.cuda()
  13.  
  14.     return x.clone().detach().requires_grad_(requires_grad)
  15.  
  16. class MaskedLinear(nn.Linear):
  17.     def __init__(self, in_features, out_features, bias=True):
  18.         super(MaskedLinear, self).__init__(in_features, out_features, bias)
  19.         self.mask_flag = False
  20.         self.mask = None
  21.  
  22.     def set_mask(self, mask):
  23.         self.mask = to_var(mask, requires_grad=False)
  24.         self.weight.data = self.weight.data * self.mask.data
  25.         self.mask_flag = True
  26.  
  27.     def get_mask(self):
  28.         print(self.mask_flag)
  29.         return self.mask
  30.  
  31.     def forward(self, x):
  32.         # 以下代码与set_mask中的self.weight.data = self.weight.data * self.mask.data重复了
  33.         # if self.mask_flag:
  34.         #     weight = self.weight * self.mask
  35.         #     return F.linear(x, weight, self.bias)
  36.         # else:
  37.         #     return F.linear(x, self.weight, self.bias)
  38.         return F.linear(x, self.weight, self.bias)
  39.  
  40. class MLP(nn.Module):
  41.     def __init__(self):
  42.         super(MLP, self).__init__()
  43.         self.linear1 = MaskedLinear(28*28, 200)
  44.         self.relu1 = nn.ReLU(inplace=True)
  45.         self.linear2 = MaskedLinear(200, 200)
  46.         self.relu2 = nn.ReLU(inplace=True)
  47.         self.linear3 = MaskedLinear(200, 10)
  48.  
  49.     def forward(self, x):
  50.         out = x.view(x.size(0), -1)
  51.         out = self.relu1(self.linear1(out))
  52.         out = self.relu2(self.linear2(out))
  53.         out = self.linear3(out)
  54.         return out
  55.  
  56.     def set_masks(self, masks):
  57.         self.linear1.set_mask(masks[0])
  58.         self.linear2.set_mask(masks[1])
  59.         self.linear3.set_mask(masks[2])
  60.  
  61. def train(model, device, train_loader, optimizer, epoch):
  62.     model.train()
  63.     total = 0
  64.     for batch_idx, (data, target) in enumerate(train_loader):
  65.         data, target = data.to(device), target.to(device)
  66.         optimizer.zero_grad()
  67.         output = model(data)
  68.         loss = F.cross_entropy(output, target)
  69.         loss.backward()
  70.         optimizer.step()
  71.  
  72.         total += len(data)
  73.         progress = math.ceil(batch_idx / len(train_loader) * 50)
  74.         print("\rTrain epoch %d: %d/%d, [%-51s] %d%%" %
  75.               (epoch, total, len(train_loader.dataset),
  76.                '-' * progress + '>', progress * 2), end='')
  77.  
  78. def test(model, device, test_loader):
  79.     model.eval()
  80.     test_loss = 0
  81.     correct = 0
  82.     with torch.no_grad():
  83.         for data, target in test_loader:
  84.             data, target = data.to(device), target.to(device)
  85.             output = model(data)
  86.             test_loss += F.cross_entropy(output, target, reduction='sum').item()
  87.             pred = output.argmax(dim=1, keepdim=True)
  88.             correct += pred.eq(target.view_as(pred)).sum().item()
  89.  
  90.     test_loss /= len(test_loader.dataset)
  91.     print('\nTest: average loss: {:.4f}, accuracy: {}/{} ({:.0f}%)'.format(
  92.         test_loss, correct, len(test_loader.dataset),
  93.         100. * correct / len(test_loader.dataset)))
  94.     return test_loss, correct / len(test_loader.dataset)
  95.  
  96. def weight_prune(model, pruning_perc):
  97.     threshold_list = []
  98.     for p in model.parameters():
  99.         if len(p.data.size()) != 1: # bias
  100.             weight = p.cpu().data.abs().numpy().flatten()
  101.             threshold = np.percentile(weight, pruning_perc)
  102.             threshold_list.append(threshold)
  103.  
  104.     # generate mask
  105.     masks = []
  106.     idx = 0
  107.     for p in model.parameters():
  108.         if len(p.data.size()) != 1:
  109.             pruned_inds = p.data.abs() > threshold_list[idx]
  110.             masks.append(pruned_inds.float())
  111.             idx += 1
  112.     return masks
  113.  
  114. def main():
  115.     epochs = 2
  116.     batch_size = 64
  117.     torch.manual_seed(0)
  118.  
  119.     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  120.     train_loader = torch.utils.data.DataLoader(
  121.         datasets.MNIST('D:/ai_data/mnist_dataset', train=True, download=False,
  122.                        transform=transforms.Compose([
  123.                            transforms.ToTensor(),
  124.                            transforms.Normalize((0.1307,), (0.3081,))
  125.                        ])),
  126.         batch_size=batch_size, shuffle=True)
  127.     test_loader = torch.utils.data.DataLoader(
  128.         datasets.MNIST('D:/ai_data/mnist_dataset', train=False, download=False, transform=transforms.Compose([
  129.             transforms.ToTensor(),
  130.             transforms.Normalize((0.1307,), (0.3081,))
  131.         ])),
  132.         batch_size=1000, shuffle=True)
  133.  
  134.     model = MLP().to(device)
  135.     optimizer = torch.optim.Adadelta(model.parameters())
  136.  
  137.     for epoch in range(1, epochs + 1):
  138.         train(model, device, train_loader, optimizer, epoch)
  139.         _, acc = test(model, device, test_loader)
  140.  
  141.     print("\n=====Pruning 60%=======\n")
  142.     pruned_model = deepcopy(model)
  143.     mask = weight_prune(pruned_model, 60)
  144.     pruned_model.set_masks(mask)
  145.     test(pruned_model, device, test_loader)
  146.  
  147.     return model, pruned_model
  148.  
  149. model, pruned_model = main()
  150. torch.save(model.state_dict(), ".model.pth")
  151. torch.save(pruned_model.state_dict(), ".pruned_model.pth")
  152.  
  153. from matplotlib import pyplot as plt
  154.  
  155. def plot_weights(model):
  156.     modules = [module for module in model.modules()]
  157.     num_sub_plot = 0
  158.     for i, layer in enumerate(modules):
  159.         if hasattr(layer, 'weight'):
  160.             plt.subplot(131+num_sub_plot)
  161.             w = layer.weight.data
  162.             w_one_dim = w.cpu().numpy().flatten()
  163.             plt.hist(w_one_dim[w_one_dim != 0], bins=50)
  164.             num_sub_plot += 1
  165.     plt.show()
  166.  
  167. model = MLP()
  168. pruned_model = MLP()
  169. model.load_state_dict(torch.load('.model.pth'))
  170. pruned_model.load_state_dict(torch.load('.pruned_model.pth'))
  171. plot_weights(model)
  172. plot_weights(pruned_model)

（3）剪枝前后精确度信息

Train epoch 1: 60000/60000, [-------------------------------------------------->]

100%

Test: average loss: 0.1391, accuracy: 9562/10000 (96%)

Train epoch 2: 60000/60000, [-------------------------------------------------->]

100%

Test: average loss: 0.0870, accuracy: 9741/10000 (97%)  

=====Pruning 60%=======

Test: average loss: 0.0977, accuracy: 9719/10000 (97%)

通过数据，可以发现剪枝前后准确率并未下降太多。

（4）剪枝前后模型参数数据分布

剪枝前的分布：

剪枝后的分布：

6、卷积层剪枝

（1）剪枝思路

假设剪枝的比例为50%。

  • 对于每一个layer的cnn卷积层，计算其参数的L2范数值，
  • 然后将数值通过sum()操作聚合到channel维度上，接着将该值在channel维度上归一化，取非零值中的最小值和对应的channel索引值。
  • 多个layer比较各自的最小值，取最小的值及对应的channel索引值对应的mask置为0
  • 计算所有参数中零值的比例，一直重复以上3步直到零值的比例达到剪枝的比例。

每一个layer的weight * mask就得到了新的weight。

（2）剪枝代码

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4. from torchvision import datasets, transforms
  5. import torch.utils.data
  6. import numpy as np
  7. import math
  8.  
  9. def to_var(x, requires_grad=False):
  10.     if torch.cuda.is_available():
  11.         x = x.cuda()
  12.  
  13.     return x.clone().detach().requires_grad_(requires_grad)
  14.  
  15. class MaskedConv2d(nn.Conv2d):
  16.     def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True):
  17.         super(MaskedConv2d, self).__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
  18.         self.mask_flag = False
  19.  
  20.     def set_mask(self, mask):
  21.         self.mask = to_var(mask, requires_grad=False)
  22.         self.weight.data = self.weight.data * self.mask.data
  23.         self.mask_flag = True
  24.  
  25.     def get_mask(self):
  26.         print(self.mask_flag)
  27.         return self.mask
  28.  
  29.     def forward(self, x):
  30.         # 以下部分与set_mask的self.weight.data = self.weight.data * self.mask.data重合
  31.         # if self.mask_flag == True:
  32.         #     weight = self.weight * self.mask
  33.         #     return F.conv2d(x, weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
  34.         # else:
  35.         #     return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
  36.         return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
  37.  
  38. class ConvNet(nn.Module):
  39.     def __init__(self):
  40.         super(ConvNet, self).__init__()
  41.  
  42.         self.conv1 = MaskedConv2d(1, 32, kernel_size=3, padding=1, stride=1)
  43.         self.relu1 = nn.ReLU(inplace=True)
  44.         self.maxpool1 = nn.MaxPool2d(2)
  45.  
  46.         self.conv2 = MaskedConv2d(32, 64, kernel_size=3, padding=1, stride=1)
  47.         self.relu2 = nn.ReLU(inplace=True)
  48.         self.maxpool2 = nn.MaxPool2d(2)
  49.  
  50.         self.conv3 = MaskedConv2d(64, 64, kernel_size=3, padding=1, stride=1)
  51.         self.relu3 = nn.ReLU(inplace=True)
  52.  
  53.         self.linear1 = nn.Linear(7*7*64, 10)
  54.  
  55.     def forward(self, x):
  56.         out = self.maxpool1(self.relu1(self.conv1(x)))
  57.         out = self.maxpool2(self.relu2(self.conv2(out)))
  58.         out = self.relu3(self.conv3(out))
  59.         out = out.view(out.size(0), -1)
  60.         out = self.linear1(out)
  61.         return out
  62.  
  63.     def set_masks(self, masks):
  64.         self.conv1.set_mask(torch.from_numpy(masks[0]))
  65.         self.conv2.set_mask(torch.from_numpy(masks[1]))
  66.         self.conv3.set_mask(torch.from_numpy(masks[2]))
  67.  
  68. def train(model, device, train_loader, optimizer, epoch):
  69.     model.train()
  70.     total = 0
  71.     for batch_idx, (data, target) in enumerate(train_loader):
  72.         data, target = data.to(device), target.to(device)
  73.         optimizer.zero_grad()
  74.         output = model(data)
  75.         loss = F.cross_entropy(output, target)
  76.         loss.backward()
  77.         optimizer.step()
  78.  
  79.         total += len(data)
  80.         progress = math.ceil(batch_idx / len(train_loader) * 50)
  81.         print("\rTrain epoch %d: %d/%d, [%-51s] %d%%" %
  82.               (epoch, total, len(train_loader.dataset),
  83.                '-' * progress + '>', progress * 2), end='')
  84.  
  85. def test(model, device, test_loader):
  86.     model.eval()
  87.     test_loss = 0
  88.     correct = 0
  89.     with torch.no_grad():
  90.         for data, target in test_loader:
  91.             data, target = data.to(device), target.to(device)
  92.             output = model(data)
  93.             test_loss += F.cross_entropy(output, target, reduction='sum').item()
  94.             pred = output.argmax(dim=1, keepdim=True)
  95.             correct += pred.eq(target.view_as(pred)).sum().item()
  96.  
  97.     test_loss /= len(test_loader.dataset)
  98.     print('\nTest: average loss: {:.4f}, accuracy: {}/{} ({:.0f}%)'.format(
  99.         test_loss, correct, len(test_loader.dataset),
  100.         100. * correct / len(test_loader.dataset)))
  101.     return test_loss, correct / len(test_loader.dataset)
  102.  
  103. def prune_rate(model, verbose=False):
  104.     """
  105.     计算模型的裁剪比例
  106.     :param model:
  107.     :param verbose:
  108.     :return:
  109.     """
  110.     total_nb_param = 0
  111.     nb_zero_param = 0
  112.     layer_id = 0
  113.  
  114.     for parameter in model.parameters():
  115.         param_this_layer = 1
  116.         for dim in parameter.data.size():
  117.             param_this_layer *= dim
  118.         total_nb_param += param_this_layer
  119.  
  120.         # only pruning linear and conv layers
  121.         if len(parameter.data.size()) != 1:
  122.             layer_id += 1
  123.             zero_param_this_layer = np.count_nonzero(parameter.cpu().data.numpy() == 0)
  124.             nb_zero_param += zero_param_this_layer
  125.  
  126.             if verbose:
  127.                 print("Layer {} | {} layer | {:.2f}% parameters pruned" \
  128.                     .format(
  129.                     layer_id,
  130.                     'Conv' if len(parameter.data.size()) == 4 \
  131.                         else 'Linear',
  132.                     100. * zero_param_this_layer / param_this_layer,
  133.                 ))
  134.     pruning_perc = 100. * nb_zero_param / total_nb_param
  135.     if verbose:
  136.         print("Final pruning rate: {:.2f}%".format(pruning_perc))
  137.     return pruning_perc
  138.  
  139. def arg_nonzero_min(a):
  140.     """
  141.     获取非零值中的最小值及其下标值
  142.     :param a:
  143.     :return:
  144.     """
  145.     if not a:
  146.         return
  147.  
  148.     min_ix, min_v = None, None
  149.     # 查看是否所有值都为0
  150.     for i, e in enumerate(a):
  151.         if e != 0:
  152.             min_ix = i
  153.             min_v = e
  154.             break
  155.     if min_ix is None:
  156.         print('Warning: all zero')
  157.         return np.inf, np.inf
  158.  
  159.     # search for the smallest nonzero
  160.     for i, e in enumerate(a):
  161.         if e < min_v and e != 0:
  162.             min_v = e
  163.             min_ix = i
  164.  
  165.     return min_v, min_ix
  166.  
  167. def prune_one_filter(model, masks):
  168.     """
  169.     pruning one least import feature map by the scaled l2norm of kernel weights
  170.     用缩放的核权重l2范数修剪最小输入特征图
  171.     :param model:
  172.     :param masks:
  173.     :return:
  174.     """
  175.     NO_MASKS = False
  176.     # construct masks if there is not yet
  177.     if not masks:
  178.         masks = []
  179.         NO_MASKS = True
  180.  
  181.     values = []
  182.     for p in model.parameters():
  183.         if len(p.data.size()) == 4:
  184.             p_np = p.data.cpu().numpy()
  185.  
  186.             # construct masks if there is not
  187.             if NO_MASKS:
  188.                 masks.append(np.ones(p_np.shape).astype('float32'))
  189.  
  190.             # find the scaled l2 norm for each filter this layer
  191.             value_this_layer = np.square(p_np).sum(axis=1).sum(axis=1).sum(axis=1) / (p_np.shape[1] * p_np.shape[2] * p_np.shape[3])
  192.  
  193.             # normalization(important)
  194.             value_this_layer = value_this_layer / np.sqrt(np.square(value_this_layer).sum())
  195.             min_value, min_ind = arg_nonzero_min(list(value_this_layer))
  196.             values.append([min_value, min_ind])
  197.  
  198.     assert len(masks) == len(values), "something wrong here"
  199.  
  200.     values = np.array(values)  # [[min_value, min_ind], [min_value, min_ind], [min_value, min_ind]]
  201.  
  202.     # set mask corresponding to the filter to prune
  203.     to_prune_layer_ind = np.argmin(values[:, 0])
  204.     to_prune_filter_ind = int(values[to_prune_layer_ind, 1])
  205.     masks[to_prune_layer_ind][to_prune_filter_ind] = 0.
  206.  
  207.     return masks
  208.  
  209. def filter_prune(model, pruning_perc):
  210.     """
  211.     剪枝主流程，不停剪枝直到裁剪比例达到要求
  212.     :param model:
  213.     :param pruning_perc:
  214.     :return:
  215.     """
  216.     masks = []
  217.     current_pruning_perc = 0
  218.  
  219.     while current_pruning_perc < pruning_perc:
  220.         masks = prune_one_filter(model, masks)
  221.         model.set_masks(masks)
  222.         current_pruning_perc = prune_rate(model, verbose=False)
  223.         print('{:.2f} pruned'.format(current_pruning_perc))
  224.  
  225.     return masks
  226.  
  227. def main():
  228.     epochs = 2
  229.     batch_size = 64
  230.     torch.manual_seed(0)
  231.  
  232.     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  233.     train_loader = torch.utils.data.DataLoader(
  234.         datasets.MNIST('D:/ai_data/mnist_dataset', train=True, download=False,
  235.                        transform=transforms.Compose([
  236.                            transforms.ToTensor(),
  237.                            transforms.Normalize((0.1307,), (0.3081,))
  238.                        ])),
  239.         batch_size=batch_size, shuffle=True)
  240.     test_loader = torch.utils.data.DataLoader(
  241.         datasets.MNIST('D:/ai_data/mnist_dataset', train=False, download=False, transform=transforms.Compose([
  242.             transforms.ToTensor(),
  243.             transforms.Normalize((0.1307,), (0.3081,))
  244.         ])),
  245.         batch_size=1000, shuffle=True)
  246.  
  247.     model = ConvNet().to(device)
  248.     optimizer = torch.optim.Adadelta(model.parameters())
  249.  
  250.     for epoch in range(1, epochs + 1):
  251.         train(model, device, train_loader, optimizer, epoch)
  252.         _, acc = test(model, device, test_loader)
  253.  
  254.     print('\npruning 50%')
  255.     mask = filter_prune(model, 50)
  256.     model.set_masks(mask)
  257.     _, acc = test(model, device, test_loader)
  258.  
  259.     # finetune
  260.     print('\nfinetune')
  261.     train(model, device, train_loader, optimizer, epoch)
  262.     _, acc = test(model, device, test_loader)
  263.  
  264. main()

 （3）精确度及剪枝比例信息：

  1. Train epoch 1: 60000/60000, [-------------------------------------------------->] 100%
  2. Test: average loss: 0.0505, accuracy: 9833/10000 (98%)
  3. Train epoch 2: 60000/60000, [-------------------------------------------------->] 100%
  4. Test: average loss: 0.0311, accuracy: 9893/10000 (99%)
  5.  
  6. pruning 50%
  7. 0.66 pruned
  8. 1.32 pruned
  9. 1.65 pruned
  10. 1.98 pruned
  11. 2.31 pruned
  12. 2.64 pruned
  13. 2.98 pruned
  14. 3.64 pruned
  15. 3.97 pruned
  16. 4.63 pruned
  17. 4.64 pruned
  18. 4.65 pruned
  19. 4.98 pruned
  20. 5.31 pruned
  21. 5.32 pruned
  22. 5.65 pruned
  23. 6.31 pruned
  24. 6.97 pruned
  25. 7.30 pruned
  26. 7.63 pruned
  27. 8.30 pruned
  28. 8.31 pruned
  29. 8.97 pruned
  30. 9.30 pruned
  31. 9.96 pruned
  32. 10.29 pruned
  33. 10.95 pruned
  34. 11.61 pruned
  35. 11.94 pruned
  36. 12.60 pruned
  37. 13.27 pruned
  38. 13.93 pruned
  39. 14.26 pruned
  40. 14.92 pruned
  41. 15.25 pruned
  42. 15.26 pruned
  43. 15.59 pruned
  44. 16.25 pruned
  45. 16.91 pruned
  46. 17.57 pruned
  47. 17.90 pruned
  48. 18.23 pruned
  49. 18.90 pruned
  50. 19.56 pruned
  51. 19.89 pruned
  52. 20.55 pruned
  53. 20.88 pruned
  54. 21.54 pruned
  55. 21.87 pruned
  56. 21.88 pruned
  57. 22.54 pruned
  58. 22.87 pruned
  59. 23.53 pruned
  60. 24.20 pruned
  61. 24.21 pruned
  62. 24.87 pruned
  63. 25.20 pruned
  64. 25.86 pruned
  65. 26.19 pruned
  66. 26.20 pruned
  67. 26.86 pruned
  68. 27.19 pruned
  69. 27.52 pruned
  70. 28.18 pruned
  71. 28.51 pruned
  72. 29.18 pruned
  73. 29.51 pruned
  74. 29.52 pruned
  75. 29.85 pruned
  76. 29.86 pruned
  77. 30.52 pruned
  78. 30.85 pruned
  79. 31.51 pruned
  80. 32.17 pruned
  81. 32.83 pruned
  82. 33.16 pruned
  83. 33.82 pruned
  84. 34.16 pruned
  85. 34.82 pruned
  86. 35.15 pruned
  87. 35.48 pruned
  88. 36.14 pruned
  89. 36.47 pruned
  90. 37.13 pruned
  91. 37.79 pruned
  92. 37.80 pruned
  93. 38.13 pruned
  94. 38.79 pruned
  95. 38.80 pruned
  96. 39.13 pruned
  97. 39.15 pruned
  98. 39.81 pruned
  99. 40.14 pruned
  100. 40.47 pruned
  101. 40.48 pruned
  102. 41.14 pruned
  103. 41.47 pruned
  104. 41.80 pruned
  105. 41.81 pruned
  106. 42.47 pruned
  107. 43.13 pruned
  108. 43.46 pruned
  109. 43.79 pruned
  110. 44.46 pruned
  111. 44.79 pruned
  112. 44.80 pruned
  113. 45.46 pruned
  114. 45.79 pruned
  115. 45.80 pruned
  116. 46.46 pruned
  117. 46.79 pruned
  118. 47.12 pruned
  119. 47.78 pruned
  120. 47.79 pruned
  121. 47.80 pruned
  122. 48.13 pruned
  123. 48.79 pruned
  124. 49.13 pruned
  125. 49.79 pruned
  126. 49.80 pruned
  127. 50.46 pruned
  128.  
  129. Test: average loss: 1.6824, accuracy: 6513/10000 (65%)
  130.  
  131. finetune
  132. Train epoch 2: 60000/60000, [-------------------------------------------------->] 100%
  133. Test: average loss: 0.0324, accuracy: 9889/10000 (99%)

可以看到，剪枝完成后直接测试准确率只有65%非常低，重新对weight中的非零参数训练一次后立马接近之前的准确率。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号