Condivisione della tecnologia

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

Rif:https://www.cnblogs.com/the-art-of-ai/p/17500399.html

1. Introduzione di base

I modelli di deep learning hanno ottenuto risultati notevoli nel riconoscimento delle immagini, nell’elaborazione del linguaggio naturale, nel riconoscimento vocale e in altri campi, ma questi modelli spesso richiedono una grande quantità di risorse informatiche e spazio di archiviazione. Soprattutto in ambienti con risorse limitate come i dispositivi mobili e i sistemi integrati, le dimensioni e la complessità computazionale di questi modelli spesso diventano colli di bottiglia che ne limitano l’applicazione. Pertanto, come ridurre il più possibile le dimensioni e la complessità computazionale del modello mantenendo l’accuratezza del modello è diventata un’importante direzione di ricerca.

La tecnologia di potatura del modello è un metodo efficace per risolvere questo problema.Ottimizzando la struttura e riducendo i parametri del modello di deep learning, il modello ha dimensioni più piccole e una velocità di esecuzione più elevata pur mantenendo la precisione, adattandosi così meglio a diversi compiti e ambienti.。

2. Principi fondamentali

        La tecnologia di potatura dei modelli si riferisce a una tecnologia per l'ottimizzazione strutturale e la riduzione dei parametri dei modelli di deep learning. .La tecnologia di potatura può essere suddivisa inpotatura strutturaleEPotatura dei parametriDue forme.

La potatura strutturale si riferisce alla rimozione di alcuniunità strutturale non necessaria , come neuroni, nuclei di convoluzione, strati, ecc., per ridurre la complessità computazionale e lo spazio di archiviazione del modello. I metodi di potatura strutturale comuni includono: potatura del canale, potatura dello strato, potatura del nodo, potatura del filtro, ecc.

La potatura dei parametri si riferisce all'estrazione di dati da modelli di deep learningRimuovere alcuni parametri di peso non necessari , per ridurre lo spazio di archiviazione e la complessità computazionale del modello mantenendo l'accuratezza del modello. I metodi comuni di potatura dei parametri includono: regolarizzazione L1, regolarizzazione L2, potatura di ordinamento, potatura dell'hash sensibile alla località, ecc.

3. Principi tecnici

        L'idea centrale della tecnologia di potatura del modello è ridurre il più possibile lo spazio di archiviazione e la complessità computazionale del modello mantenendo la precisione del modello.Poiché le unità strutturali e i parametri come neuroni, nuclei di convoluzione e parametri di peso nei modelli di deep learning spesso hanno parti ridondanti e non necessarie, la tecnologia di potatura può essere utilizzata per ridurre queste parti ridondanti, riducendo così il volume del modello e l'effetto della complessità computazionale.

Nello specifico, l’implementazione della tecnologia di model pruning può essere suddivisa nei seguenti passaggi:

(1) Inizializzare il modello; innanzitutto, inizializzare un modello di deep learning e addestrarlo per ottenere un modello di base;

(2) Selezionare metodi e strategie di quantificazione della potatura; selezionare metodi e strategie di potatura adeguati in base a specifici scenari applicativi e metodi semplici comuni includono:Potatura strutturale e potatura parametrica;Le strategie comuni includono: potatura globale e potatura iterativa;

(3) Modello di potatura; in base al metodo e alla strategia di potatura selezionati, eseguire operazioni di potatura in modo specifico sul modello di deep learning, eliminare alcune unità strutturali e parametri di peso non necessari o impostarli su 0 o valori molto piccoli;

(4) Riqualificare il modello; le operazioni di potatura possono causare una diminuzione dell'accuratezza del modello, pertanto, il modello ridotto deve essere riqualificato per ripristinare l'accuratezza del modello;

(5) Mettere a punto il modello; dopo la riqualificazione, perfezionare ulteriormente la precisione del modello;

Codice:

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import datasets, transforms
 
# 定义一个简单的卷积神经网络
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 4, kernel_size=3, padding=1)  # 4个输出通道
        self.conv2 = nn.Conv2d(4, 8, kernel_size=3, padding=1)  # 8个输出通道
        self.fc1 = nn.Linear(8 * 7 * 7, 64)
        self.fc2 = nn.Linear(64, 10)
 
    def forward(self, x):
        x = F.relu(self.conv1(x))  # 卷积层1 + ReLU激活函数
        x = F.max_pool2d(x, 2)  # 最大池化层，池化核大小为2x2
        x = F.relu(self.conv2(x))  # 卷积层2 + ReLU激活函数
        x = F.max_pool2d(x, 2)  # 最大池化层，池化核大小为2x2
        x = x.view(x.size(0), -1)  # 展平操作，将多维张量展平成一维
        x = F.relu(self.fc1(x))  # 全连接层1 + ReLU激活函数
        x = self.fc2(x)  # 全连接层2，输出10个类别
        return x
 
# 实例化模型
model = SimpleCNN()
 
# 打印剪枝前的模型结构
print("Model before pruning:")
print(model)
 
# 加载数据
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量
    transforms.Normalize((0.1307,), (0.3081,))  # 归一化
])
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)  # 加载训练数据集
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)  # 创建数据加载器
 
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器
 
# 训练模型
model.train()  # 将模型设置为训练模式
for epoch in range(1):  # 训练一个epoch
    running_loss = 0.0
    for data, target in train_loader:
        optimizer.zero_grad()  # 清零梯度
        outputs = model(data)  # 前向传播
        loss = criterion(outputs, target)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数
        running_loss += loss.item() * data.size(0)  # 累加损失
 
    epoch_loss = running_loss / len(train_loader.dataset)  # 计算平均损失
    print(f'Epoch {epoch + 1}, Loss: {epoch_loss:.4f}')
 
# 通道剪枝
# 获取卷积层的权重
conv1_weights = model.conv1.weight.data.abs().sum(dim=[1, 2, 3])  # 计算每个通道的L1范数
 
# 按照L1范数对通道进行排序
sorted_channels = torch.argsort(conv1_weights)
 
# 选择需要删除的通道
num_prune = 2  # 假设我们要删除2个通道
channels_to_prune = sorted_channels[:num_prune]
 
print("Channels to prune:", channels_to_prune)
 
# 删除指定通道的权重和偏置
pruned_weights = torch.index_select(model.conv1.weight.data, 0, sorted_channels[num_prune:])  # 获取保留的权重
pruned_bias = torch.index_select(model.conv1.bias.data, 0, sorted_channels[num_prune:])  # 获取保留的偏置
 
# 创建一个新的卷积层，并将剪枝后的权重和偏置赋值给它
model.conv1 = nn.Conv2d(in_channels=1, out_channels=4 - num_prune, kernel_size=3, padding=1)
model.conv1.weight.data = pruned_weights
model.conv1.bias.data = pruned_bias
 
# 同时我们还需要调整conv2层的输入通道
# 获取conv2层的权重并调整其输入通道
conv2_weights = model.conv2.weight.data[:, sorted_channels[num_prune:], :, :]  # 调整输入通道的权重
 
# 创建一个新的卷积层，并将剪枝后的权重赋值给它
model.conv2 = nn.Conv2d(in_channels=4 - num_prune, out_channels=8, kernel_size=3, padding=1)
model.conv2.weight.data = conv2_weights
 
# 打印剪枝后的模型结构
print("Model after pruning:")
print(model)
 
# 定义新的优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
 
# 重新训练模型
model.train()  # 将模型设置为训练模式
for epoch in range(1):  # 训练一个epoch
    running_loss = 0.0
    for data, target in train_loader:
        optimizer.zero_grad()  # 清零梯度
        outputs = model(data)  # 前向传播
        loss = criterion(outputs, target)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数
        running_loss += loss.item() * data.size(0)  # 累加损失
 
    epoch_loss = running_loss / len(train_loader.dataset)  # 计算平均损失
    print(f'Epoch {epoch + 1}, Loss: {epoch_loss:.4f}')
 
# 加载测试数据
test_dataset = datasets.MNIST('./data', train=False, transform=transform)  # 加载测试数据集
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False)  # 创建数据加载器
 
# 评估模型
model.eval()  # 将模型设置为评估模式
correct = 0
total = 0
with torch.no_grad():  # 关闭梯度计算
    for data, target in test_loader:
        outputs = model(data)  # 前向传播
        _, predicted = torch.max(outputs.data, 1)  # 获取预测结果
        total += target.size(0)  # 总样本数
        correct += (predicted == target).sum().item()  # 正确预测的样本数
 
print(f'Accuracy: {100 * correct / total}%')  # 打印准确率

Al fine di migliorare le prestazioni e l’efficienza della tecnologia di potatura si possono considerare i seguenti aspetti di ottimizzazione:

• Scegliere strategie e algoritmi di potatura appropriati per migliorare l'effetto e la precisione della potatura.

• Ottimizza o apprendi in modo incrementale il modello eliminato per migliorare ulteriormente la precisione e le prestazioni del modello.

• Utilizzare la tecnologia di elaborazione parallela e di elaborazione distribuita per accelerare il processo di potatura e formazione.