模型剪枝：让深度学习模型更加易于维护和更新

    import torch
    import torch.nn as nn
    import torch.optim as optim
    
    # 定义一个简单的神经网络
    class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        self.fc1 = nn.Linear(16 * 6 * 6, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    
    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = x.view(-1, 16 * 6 * 6)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x
    
    # 模型剪枝的配置
    cutoff = 0.8
    
    # 定义训练函数
    def train(model,criterion,optimizer,device,num_epochs,train_loader,test_loader,num_classes):
    model = model.cpu().numpy()
    criterion = criterion.numpy()
    optimizer = optimizer.numpy()
    
    for epoch in range(num_epochs):
        running_loss = 0.0
        for i, data in enumerate(train_loader, 0):
            inputs, labels = data
            inputs = inputs.to(device)
            labels = labels.to(device)
            optimizer = optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
        print('Epoch {} | Running Loss: {:.4f}'.format(epoch+1, running_loss/len(train_loader)))
    
        running_loss = 0.0
        with torch.no_grad():
            for data in test_loader:
                images, labels = data
                images = images.to(device)
                labels = labels.to(device)
                outputs = model(images)
                loss = criterion(outputs, labels)
                running_loss += loss.item()
        print('Test Accuracy: {:.2%}'.format(running_loss/len(test_loader)))
    
    # 训练函数的实现
    def main():
    # 设置深度学习框架
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    # 定义训练数据集
    train_dataset = torchvision.datasets.ImageFolder(root='path/to/train/data', transform=torchvision.transforms.ToTensor())
    test_dataset = torchvision.datasets.ImageFolder(root='path/to/test/data', transform=torchvision.transforms.ToTensor())
    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=True)
    
    # 定义模型
    model = SimpleNet().to(device)
    
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.01)
    
    # 训练函数
    train(model, criterion, optimizer, device, num_epochs, train_loader, test_loader, num_classes)
    
    if __name__ == '__main__':
    main()
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读