pytorch 实现模型不同层设置不同的学习率方式

要实现模型不同层设置不同学习率的方式，我们需要了解 PyTorch 中的参数组（Parameter Group）和优化器（Optimizer）两个概念。

PyTorch 中的参数组是一组参数，用于进行不同的学习率设置。而优化器则是一个用于执行梯度下降，更新模型参数的工具。PyTorch 中提供了多种优化器，包括 SGD、Adam、Adagrad 等。下面就是详细讲解 PyTorch 实现模型不同层设置不同学习率的完整攻略：

1. 创建参数组

首先，我们需要创建多个参数组，用于对不同层的参数进行不同的学习率设置。创建参数组可以通过 nn.Module 的 parameters() 方法来实现，例如：

from torch import nn

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu1 = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.relu2 = nn.ReLU(inplace=True)
        self.maxpool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.bn3 = nn.BatchNorm2d(128)
        self.relu3 = nn.ReLU(inplace=True)
        self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1)
        self.bn4 = nn.BatchNorm2d(128)
        self.relu4 = nn.ReLU(inplace=True)
        self.maxpool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv5 = nn.Conv2d(128, 256, kernel_size=3, padding=1)
        self.bn5 = nn.BatchNorm2d(256)
        self.relu5 = nn.ReLU(inplace=True)
        self.conv6 = nn.Conv2d(256, 256, kernel_size=3, padding=1)
        self.bn6 = nn.BatchNorm2d(256)
        self.relu6 = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu1(x)
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu2(x)
        x = self.maxpool1(x)
        x = self.conv3(x)
        x = self.bn3(x)
        x = self.relu3(x)
        x = self.conv4(x)
        x = self.bn4(x)
        x = self.relu4(x)
        x = self.maxpool2(x)
        x = self.conv5(x)
        x = self.bn5(x)
        x = self.relu5(x)
        x = self.conv6(x)
        x = self.bn6(x)
        x = self.relu6(x)
        return x

model = MyModel()
optimizer = optim.SGD([
            {'params': model.conv1.parameters()},
            {'params': model.bn1.parameters()},
            {'params': model.conv2.parameters()},
            {'params': model.bn2.parameters()},
            {'params': model.conv3.parameters(), 'lr': 0.1},
            {'params': model.bn3.parameters(), 'lr': 0.1},
            {'params': model.conv4.parameters(), 'lr': 0.1},
            {'params': model.bn4.parameters(), 'lr': 0.1},
            {'params': model.conv5.parameters(), 'lr': 0.01},
            {'params': model.bn5.parameters(), 'lr': 0.01},
            {'params': model.conv6.parameters(), 'lr': 0.01},
            {'params': model.bn6.parameters(), 'lr': 0.01},
        ], lr=0.001, momentum=0.9)

我们在创建参数组时，使用字典的方式为每个参数组指定其学习率。注意，如果不指定学习率，将会使用默认的学习率。在这个例子中，前两个参数组（即 self.conv1.parameters() 和 self.bn1.parameters()）使用默认学习率，后续的参数组则分别指定了不同的学习率。

2. 使用优化器

然后，我们需要使用优化器来更新模型中的参数。在 PyTorch 中，我们可以使用 optim 包提供的优化器。例如：

import torch.optim as optim

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 训练网络
for epoch in range(10):
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader, 0):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

在这个例子中，我们使用了 SGD 优化器，并将学习率设置为 0.001，动量设置为 0.9。在每次训练中，我们调用了 optimizer.zero_grad() 来清空梯度，然后使用 optimizer.step() 来更新参数。

注意，在第 1 步中，我们创建的优化器是由多个参数组组成的。在训练中，优化器会将不同参数组的梯度分别计算，并使用各自的学习率更新对应的参数。

综上所述，我们可以在 PyTorch 中通过创建不同的参数组和使用不同的优化器来实现模型不同层设置不同学习率的目的。