Partage de technologie

Introduction à l'élagage de modèles

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Réf. :https://www.cnblogs.com/the-art-of-ai/p/17500399.html

1. Introduction générale

Les modèles d'apprentissage profond ont obtenu des résultats remarquables dans les domaines de la reconnaissance d'images, du traitement du langage naturel, de la reconnaissance vocale et dans d'autres domaines, mais ces modèles nécessitent souvent une grande quantité de ressources informatiques et d'espace de stockage. En particulier dans les environnements aux ressources limitées tels que les appareils mobiles et les systèmes embarqués, la taille et la complexité informatique de ces modèles deviennent souvent des goulots d'étranglement qui limitent leur application. Par conséquent, la manière de réduire autant que possible la taille et la complexité informatique du modèle tout en maintenant la précision du modèle est devenue une direction de recherche importante.

La technologie d’élagage modèle est une méthode efficace pour résoudre ce problème.En optimisant la structure et en réduisant les paramètres du modèle d'apprentissage profond, le modèle a une taille plus petite et une vitesse d'exécution plus rapide tout en conservant la précision, s'adaptant ainsi mieux aux différentes tâches et environnements.。

2. Principes de base

        La technologie d'élagage de modèles fait référence à une technologie d'optimisation structurelle et de réduction des paramètres des modèles d'apprentissage en profondeur. .La technologie d'élagage peut être divisée enTaille structurelleetÉlagage des paramètresDeux formes.

L'élagage structurel consiste à supprimer certainsunité structurelle inutile , tels que les neurones, les noyaux de convolution, les couches, etc., pour réduire la complexité informatique et l'espace de stockage du modèle. Les méthodes courantes d'élagage structurel comprennent : l'élagage des canaux, l'élagage des couches, l'élagage des nœuds, l'élagage des filtres, etc.

L'élagage des paramètres fait référence à l'extraction de données à partir de modèles d'apprentissage en profondeurSupprimez certains paramètres de poids inutiles , pour réduire l'espace de stockage et la complexité de calcul du modèle tout en conservant la précision du modèle. Les méthodes courantes d'élagage des paramètres comprennent : la régularisation L1, la régularisation L2, l'élagage de tri, l'élagage de hachage sensible à la localité, etc.

3. Principes techniques

        L'idée principale de la technologie d'élagage de modèle est de réduire autant que possible l'espace de stockage et la complexité de calcul du modèle tout en maintenant la précision du modèle.Étant donné que les unités structurelles et les paramètres tels que les neurones, les noyaux de convolution et les paramètres de poids dans les modèles d'apprentissage profond comportent souvent des parties redondantes et inutiles, la technologie d'élagage peut être utilisée pour réduire ces parties redondantes, réduisant ainsi le volume du modèle et l'effet de la complexité informatique.

Plus précisément, la mise en œuvre de la technologie d’élagage des modèles peut être divisée en les étapes suivantes :

(1) Initialisez le modèle ; commencez par initialiser un modèle d'apprentissage en profondeur et entraînez-le pour obtenir un modèle de référence ;

(2) Sélectionner des méthodes et des stratégies de quantification d'élagage ; sélectionner des méthodes et des stratégies d'élagage appropriées en fonction de scénarios d'application et de besoins spécifiques, notamment :Élagage structurel et élagage paramétriqueLes stratégies courantes comprennent : l’élagage global et l’élagage itératif ;

(3) Modèle d'élagage ; sur la base de la méthode et de la stratégie d'élagage sélectionnées, effectuer des opérations d'élagage sur le modèle d'apprentissage en profondeur ; supprimer certaines unités structurelles et paramètres de poids inutiles, ou les définir sur 0 ou sur des valeurs très faibles ;

(4) Recycler le modèle ; les opérations d'élagage peuvent entraîner une diminution de la précision du modèle ; par conséquent, le modèle élagué doit être recyclé pour restaurer la précision du modèle ;

(5) Affiner le modèle ; après le recyclage, affiner le modèle ;

Code:

  1. import torch
  2. import torch.nn as nn
  3. import torch.optim as optim
  4. import torch.nn.functional as F
  5. from torchvision import datasets, transforms
  6.  
  7. # 定义一个简单的卷积神经网络
  8. class SimpleCNN(nn.Module):
  9.     def __init__(self):
  10.         super(SimpleCNN, self).__init__()
  11.         self.conv1 = nn.Conv2d(1, 4, kernel_size=3, padding=1)  # 4个输出通道
  12.         self.conv2 = nn.Conv2d(4, 8, kernel_size=3, padding=1)  # 8个输出通道
  13.         self.fc1 = nn.Linear(8 * 7 * 7, 64)
  14.         self.fc2 = nn.Linear(64, 10)
  15.  
  16.     def forward(self, x):
  17.         x = F.relu(self.conv1(x))  # 卷积层1 + ReLU激活函数
  18.         x = F.max_pool2d(x, 2)  # 最大池化层，池化核大小为2x2
  19.         x = F.relu(self.conv2(x))  # 卷积层2 + ReLU激活函数
  20.         x = F.max_pool2d(x, 2)  # 最大池化层，池化核大小为2x2
  21.         x = x.view(x.size(0), -1)  # 展平操作，将多维张量展平成一维
  22.         x = F.relu(self.fc1(x))  # 全连接层1 + ReLU激活函数
  23.         x = self.fc2(x)  # 全连接层2，输出10个类别
  24.         return x
  25.  
  26. # 实例化模型
  27. model = SimpleCNN()
  28.  
  29. # 打印剪枝前的模型结构
  30. print("Model before pruning:")
  31. print(model)
  32.  
  33. # 加载数据
  34. transform = transforms.Compose([
  35.     transforms.ToTensor(),  # 转换为张量
  36.     transforms.Normalize((0.1307,), (0.3081,))  # 归一化
  37. ])
  38. train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)  # 加载训练数据集
  39. train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)  # 创建数据加载器
  40.  
  41. # 定义损失函数和优化器
  42. criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
  43. optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器
  44.  
  45. # 训练模型
  46. model.train()  # 将模型设置为训练模式
  47. for epoch in range(1):  # 训练一个epoch
  48.     running_loss = 0.0
  49.     for data, target in train_loader:
  50.         optimizer.zero_grad()  # 清零梯度
  51.         outputs = model(data)  # 前向传播
  52.         loss = criterion(outputs, target)  # 计算损失
  53.         loss.backward()  # 反向传播
  54.         optimizer.step()  # 更新参数
  55.         running_loss += loss.item() * data.size(0)  # 累加损失
  56.  
  57.     epoch_loss = running_loss / len(train_loader.dataset)  # 计算平均损失
  58.     print(f'Epoch {epoch + 1}, Loss: {epoch_loss:.4f}')
  59.  
  60. # 通道剪枝
  61. # 获取卷积层的权重
  62. conv1_weights = model.conv1.weight.data.abs().sum(dim=[1, 2, 3])  # 计算每个通道的L1范数
  63.  
  64. # 按照L1范数对通道进行排序
  65. sorted_channels = torch.argsort(conv1_weights)
  66.  
  67. # 选择需要删除的通道
  68. num_prune = 2  # 假设我们要删除2个通道
  69. channels_to_prune = sorted_channels[:num_prune]
  70.  
  71. print("Channels to prune:", channels_to_prune)
  72.  
  73. # 删除指定通道的权重和偏置
  74. pruned_weights = torch.index_select(model.conv1.weight.data, 0, sorted_channels[num_prune:])  # 获取保留的权重
  75. pruned_bias = torch.index_select(model.conv1.bias.data, 0, sorted_channels[num_prune:])  # 获取保留的偏置
  76.  
  77. # 创建一个新的卷积层，并将剪枝后的权重和偏置赋值给它
  78. model.conv1 = nn.Conv2d(in_channels=1, out_channels=4 - num_prune, kernel_size=3, padding=1)
  79. model.conv1.weight.data = pruned_weights
  80. model.conv1.bias.data = pruned_bias
  81.  
  82. # 同时我们还需要调整conv2层的输入通道
  83. # 获取conv2层的权重并调整其输入通道
  84. conv2_weights = model.conv2.weight.data[:, sorted_channels[num_prune:], :, :]  # 调整输入通道的权重
  85.  
  86. # 创建一个新的卷积层，并将剪枝后的权重赋值给它
  87. model.conv2 = nn.Conv2d(in_channels=4 - num_prune, out_channels=8, kernel_size=3, padding=1)
  88. model.conv2.weight.data = conv2_weights
  89.  
  90. # 打印剪枝后的模型结构
  91. print("Model after pruning:")
  92. print(model)
  93.  
  94. # 定义新的优化器
  95. optimizer = optim.Adam(model.parameters(), lr=0.001)
  96.  
  97. # 重新训练模型
  98. model.train()  # 将模型设置为训练模式
  99. for epoch in range(1):  # 训练一个epoch
  100.     running_loss = 0.0
  101.     for data, target in train_loader:
  102.         optimizer.zero_grad()  # 清零梯度
  103.         outputs = model(data)  # 前向传播
  104.         loss = criterion(outputs, target)  # 计算损失
  105.         loss.backward()  # 反向传播
  106.         optimizer.step()  # 更新参数
  107.         running_loss += loss.item() * data.size(0)  # 累加损失
  108.  
  109.     epoch_loss = running_loss / len(train_loader.dataset)  # 计算平均损失
  110.     print(f'Epoch {epoch + 1}, Loss: {epoch_loss:.4f}')
  111.  
  112. # 加载测试数据
  113. test_dataset = datasets.MNIST('./data', train=False, transform=transform)  # 加载测试数据集
  114. test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False)  # 创建数据加载器
  115.  
  116. # 评估模型
  117. model.eval()  # 将模型设置为评估模式
  118. correct = 0
  119. total = 0
  120. with torch.no_grad():  # 关闭梯度计算
  121.     for data, target in test_loader:
  122.         outputs = model(data)  # 前向传播
  123.         _, predicted = torch.max(outputs.data, 1)  # 获取预测结果
  124.         total += target.size(0)  # 总样本数
  125.         correct += (predicted == target).sum().item()  # 正确预测的样本数
  126.  
  127. print(f'Accuracy: {100 * correct / total}%')  # 打印准确率

Afin d'améliorer les performances et l'efficacité de la technologie d'élagage, les aspects d'optimisation suivants peuvent être pris en compte :

  • Choisissez des stratégies d'élagage et des algorithmes d'élagage appropriés pour améliorer l'effet et la précision de l'élagage.

  • Affinez ou apprenez progressivement le modèle élagué pour améliorer encore la précision et les performances du modèle.

  • Utilisez l’informatique parallèle et la technologie informatique distribuée pour accélérer le processus d’élagage et de formation.

Profil personnel

Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.

mes coordonnées

Mail