Condivisione della tecnologia

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

Compilazione di punti di conoscenza della potatura del modello

La potatura lo èmodello di apprendimento profondoDue tecniche comuni di ottimizzazione vengono utilizzate per ridurre la complessità del modello e migliorare la velocità di inferenza e sono adatte per ambienti con risorse limitate.

Potatura

La potatura è un metodo per ridurre le dimensioni del modello e lo sforzo computazionale rimuovendo parametri non importanti o ridondanti nel modello. La potatura viene solitamente suddivisa nelle seguenti tipologie:

1. Potatura ponderata

L'eliminazione del peso riduce il numero di parametri del modello rimuovendo elementi prossimi allo zero nella matrice del peso. I metodi comuni sono:

• Potatura non strutturata: Rimuovere i pesi piccoli nella matrice dei pesi uno per uno.
• Potatura strutturata: rimuove i pesi in base a una struttura specifica (ad esempio intere righe o intere colonne).

Esempio:

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. Potatura dei canali

La potatura del canale viene utilizzata principalmente perrete neurale convoluzionale , riducendo la quantità di calcolo rimuovendo i canali non importanti nello strato convoluzionale. I metodi comuni sono:

• Punteggio basato sull'importanza: calcola il punteggio di importanza di ciascun canale e rimuove i canali con punteggi inferiori.
• Basato sulla scarsità: Aggiungendo termini di regolarizzazione sparsi, alcuni canali saranno naturalmente sparsi durante il processo di formazione e quindi potati.

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. Potatura a strati

L'eliminazione dei livelli rimuove interi livelli di rete per ridurre la profondità computazionale del modello. Questo approccio è più radicale e viene spesso utilizzato insieme a 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