pytorch 中的 ReduceLrOnPlateau 调度程序可以使用测试集度量来降低学习率吗？

Question

您好，我目前正在学习调度程序在pytroch深度学习中的使用。我遇到了以下代码：

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision.datasets as dsets

# Set seed
torch.manual_seed(0)

# Where to add a new import
from torch.optim.lr_scheduler import ReduceLROnPlateau

'''
STEP 1: LOADING DATASET
'''

train_dataset = dsets.MNIST(root='./data', 
                            train=True, 
                            transform=transforms.ToTensor(),
                            download=True)

test_dataset = dsets.MNIST(root='./data', 
                           train=False, 
                           transform=transforms.ToTensor())

'''
STEP 2: MAKING DATASET ITERABLE
'''

batch_size = 100
n_iters = 6000
num_epochs = n_iters / (len(train_dataset) / batch_size)
num_epochs = int(num_epochs)

train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=batch_size, 
                                          shuffle=False)

'''
STEP 3: CREATE MODEL CLASS
'''
class FeedforwardNeuralNetModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(FeedforwardNeuralNetModel, self).__init__()
        # Linear function
        self.fc1 = nn.Linear(input_dim, hidden_dim) 
        # Non-linearity
        self.relu = nn.ReLU()
        # Linear function (readout)
        self.fc2 = nn.Linear(hidden_dim, output_dim)  

    def forward(self, x):
        # Linear function
        out = self.fc1(x)
        # Non-linearity
        out = self.relu(out)
        # Linear function (readout)
        out = self.fc2(out)
        return out
'''
STEP 4: INSTANTIATE MODEL CLASS
'''
input_dim = 28*28
hidden_dim = 100
output_dim = 10

model = FeedforwardNeuralNetModel(input_dim, hidden_dim, output_dim)

'''
STEP 5: INSTANTIATE LOSS CLASS
'''
criterion = nn.CrossEntropyLoss()


'''
STEP 6: INSTANTIATE OPTIMIZER CLASS
'''
learning_rate = 0.1

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, nesterov=True)

'''
STEP 7: INSTANTIATE STEP LEARNING SCHEDULER CLASS
'''
# lr = lr * factor 
# mode='max': look for the maximum validation accuracy to track
# patience: number of epochs - 1 where loss plateaus before decreasing LR
        # patience = 0, after 1 bad epoch, reduce LR
# factor = decaying factor
scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.1, patience=0, verbose=True)

'''
STEP 7: TRAIN THE MODEL
'''
iter = 0
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        # Load images as Variable
        images = images.view(-1, 28*28).requires_grad_()

        # Clear gradients w.r.t. parameters
        optimizer.zero_grad()

        # Forward pass to get output/logits
        outputs = model(images)

        # Calculate Loss: softmax --> cross entropy loss
        loss = criterion(outputs, labels)

        # Getting gradients w.r.t. parameters
        loss.backward()

        # Updating parameters
        optimizer.step()

        iter += 1

        if iter % 500 == 0:
            # Calculate Accuracy         
            correct = 0
            total = 0
            # Iterate through test dataset
            for images, labels in test_loader:
                # Load images to a Torch Variable
                images = images.view(-1, 28*28)

                # Forward pass only to get logits/output
                outputs = model(images)

                # Get predictions from the maximum value
                _, predicted = torch.max(outputs.data, 1)

                # Total number of labels
                total += labels.size(0)

                # Total correct predictions
                # Without .item(), it is a uint8 tensor which will not work when you pass this number to the scheduler
                correct += (predicted == labels).sum().item()

            accuracy = 100 * correct / total

            # Print Loss
            # print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.data[0], accuracy))

    # Decay Learning Rate, pass validation accuracy for tracking at every epoch
    print('Epoch {} completed'.format(epoch))
    print('Loss: {}. Accuracy: {}'.format(loss.item(), accuracy))
    print('-'*20)
    scheduler.step(accuracy)

我正在使用上述策略。我唯一无法理解的是，他们如何使用测试数据来提高准确性并在此基础上通过调度程序降低学习率？这是代码的最后一行。我们可以在训练期间向调度程序显示测试准确性并要求它降低学习率吗？我在 github resnet main.py 上发现了类似的东西也。有人可以澄清一下吗？

Answer 1

我认为这里的 test 一词可能有些混淆。

测试和验证数据之间的差异

测试实际指代的代码是验证集，而不是实际的测试集。不同之处在于，在训练期间使用验证集来查看模型的泛化能力。通常人们只是切掉一部分训练数据并将其用于验证。在我看来，您的代码似乎使用相同的数据进行训练和验证，但这只是我的假设，因为我不知道 ./data 是什么样子。

要以严格科学的方式工作，您的模型在训练期间不应该看到实际的测试数据，而只能看到训练和验证。这样我们就可以评估模型在训练后对未见数据进行归纳的实际能力。

根据验证准确性降低学习率

您使用验证数据（在您的案例中称为测试数据）来降低学习率的原因可能是因为如果您使用实际训练数据和训练准确性来执行此操作，则模型更有可能过度拟合。为什么？当您处于训练准确性的稳定状态时，并不一定意味着它是验证准确性的稳定状态，反之亦然。这意味着您可能正朝着验证准确性方面的一个有希望的方向前进（因此朝着泛化良好的参数方向），突然间您降低或提高了学习率，因为训练准确性存在平台期（或非平台期）。

pytorch 中的 ReduceLrOnPlateau 调度程序可以使用测试集度量来降低学习率吗？

Can ReduceLrOnPlateau scheduler in pytorch use test set metric for decreasing learning rate?

python

scheduler

deep-learning

pytorch