Berbagi teknologi

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

Kompilasi poin pengetahuan pemangkasan model

Pemangkasan adalahmodel pembelajaran mendalamDua teknik umum untuk pengoptimalan digunakan untuk mengurangi kompleksitas model dan meningkatkan kecepatan inferensi, dan cocok untuk lingkungan dengan sumber daya terbatas.

Pemangkasan

Pemangkasan adalah metode mengurangi ukuran model dan upaya komputasi dengan menghilangkan parameter yang tidak penting atau berlebihan dalam model. Pemangkasan secara umum dibagi menjadi beberapa jenis berikut:

1. Pemangkasan Berat Badan

Pemangkasan bobot mengurangi jumlah parameter model dengan menghilangkan elemen yang mendekati nol dalam matriks bobot. Metode yang umum adalah:

• Pemangkasan Tidak Terstruktur: Menghapus bobot kecil pada matriks bobot satu per satu.
• Pemangkasan Terstruktur: Menghapus bobot berdasarkan struktur tertentu (misalnya seluruh baris atau seluruh kolom).

Contoh:

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. Pemangkasan Saluran

Pemangkasan saluran terutama digunakan untukjaringan saraf konvolusional , mengurangi jumlah komputasi dengan menghapus saluran yang tidak penting di lapisan konvolusional. Metode yang umum adalah:

• Skor berdasarkan kepentingan: Hitung skor pentingnya setiap saluran dan hapus saluran dengan skor lebih rendah.
• Berdasarkan ketersebaran: Dengan menambahkan istilah regularisasi renggang, beberapa saluran secara alami akan menjadi renggang selama proses pelatihan dan kemudian dipangkas.

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. Pemangkasan Lapisan

Pemangkasan lapisan menghilangkan seluruh lapisan jaringan untuk mengurangi kedalaman komputasi model. Pendekatan ini lebih radikal dan sering digunakan bersama dengan 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