• 模型剪枝初级方法

    信息源：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中的非零参数训练一次后立马接近之前的准确率。

  • 相关阅读:
    GAT网络为什么占用那么多的显存
    Redis基础
    Office登录一直转圈Win10怎么解决？
    ps插件：alpaca增效工具 (完美替代AI创成式填充) 2.8.1 中文版
    【另类加法】
    6、STL、迭代器、容器
    vue3.0+ts+element ui中如何使用svg图片
    JavaScript中如何确定this的值？如何指定this的值？
    Linux如何安装Maven？
    03. 01- 代理模式(Proxy)
  • 原文地址：https://blog.csdn.net/benben044/article/details/127848606