Partage de technologie

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

Compilation de points de connaissance sur l'élagage du modèle

La taille estmodèle d'apprentissage profondDeux techniques d'optimisation courantes sont utilisées pour réduire la complexité du modèle et améliorer la vitesse d'inférence, et conviennent aux environnements aux ressources limitées.

Taille

L'élagage est une méthode permettant de réduire la taille du modèle et l'effort de calcul en supprimant les paramètres sans importance ou redondants du modèle. La taille est généralement divisée selon les types suivants :

1. Taille au poids

L'élagage des poids réduit le nombre de paramètres du modèle en supprimant les éléments proches de zéro dans la matrice de poids. Les méthodes courantes sont :

• Taille non structurée: Supprimez les petits poids de la matrice de poids un par un.
• Taille structurée : Supprimez les pondérations selon une structure spécifique (telle que des lignes entières ou des colonnes entières).

Exemple:

import torch

# 假设有一个全连接层
fc = torch.nn.Linear(100, 100)

# 获取权重矩阵
weights = fc.weight.data.abs()

# 设定剪枝阈值
threshold = 0.01

# 应用剪枝
mask = weights > threshold
fc.weight.data *= mask
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. Élagage des canaux

L'élagage des canaux est principalement utilisé pourréseau neuronal convolutif , réduisant la quantité de calcul en supprimant les canaux sans importance dans la couche convolutive. Les méthodes courantes sont :

• Score basé sur l'importance: calculez le score d'importance de chaque canal et supprimez les canaux avec des scores inférieurs.
• Basé sur la parcimonie: En ajoutant des termes de régularisation clairsemés, certains canaux seront naturellement clairsemés pendant le processus de formation puis élagués.

import torch
import torch.nn as nn

class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        return x

model = ConvNet()

# 获取卷积层的权重
weights = model.conv1.weight.data.abs()

# 计算每个通道的L1范数
channel_importance = torch.sum(weights, dim=[1, 2, 3])

# 设定剪枝阈值
threshold = torch.topk(channel_importance, k=32, largest=True).values[-1]

# 应用剪枝
mask = channel_importance > threshold
model.conv1.weight.data *= mask.view(-1, 1, 1, 1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3. Taille des couches

L'élagage des couches supprime des couches entières du réseau pour réduire la profondeur de calcul du modèle. Cette approche est plus radicale et est souvent utilisée en conjonction avec Model Architecture Search (NAS).

import torch.nn as nn

class LayerPrunedNet(nn.Module):
    def __init__(self, use_layer=True):
        super(LayerPrunedNet, self).__init__()
        self.use_layer = use_layer
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
    
    def forward(self, x):
        x = self.conv1(x)
        if self.use_layer:
            x = self.conv2(x)
        return x

# 初始化网络，选择是否使用第二层
model = LayerPrunedNet(use_layer=False)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18