Tutorial do AdamW Optimizer em PyTorch

Tutoriais
Python

Algoritmos de otimização desempenham um papel crucial em aprendizagem profunda: eles ajustam os pesos do modelo para minimizar as funções de perda durante o treinamento. Tal algoritmo é o Otimizador Adam.

O Adam tornou-se extremamente popular em aprendizagem profunda devido à sua capacidade de combinar as vantagens de momento e taxas de aprendizagem adaptativas. Isso o tornou altamente eficiente para o treinamento de redes neurais profundas. Além disso, ele exige o mínimo de ajuste de parâmetros de hipermercado, tornando-o amplamente acessível e eficaz em várias tarefas.

Em 2017, Ilya Loshchilov e Frank Hutter apresentaram uma versão mais avançada do popular algoritmo Adam em seu artigo “Decoupled Weight Decay Regularization.” Eles o chamaram de AdamW, que se destaca por desacoplar a decaimento de pesos da atualização da gradiente. Essa separação é uma melhoria crucial sobre o Adam e ajuda com a melhor generalização do modelo.

O AdamW tornou-se cada vez mais importante em aplicações de aprendizagem profunda modernas, particularmente na manipulação de modelos em escala grande. Sua capacidade superior de regular atualizações de peso contribuiu para sua adoção em tarefas que exigem alta performance e estabilidade.

Neste tutorial, vamos abordar as principais diferenças entre o Adam e o AdamW, e os diferentes casos de uso, e vamos implementar um guia passo a passo para a implementação do AdamW emPyTorch.

Adam vs AdamW

Adam e AdamW são ambos optimizadores adaptativos amplamente usados em aprendizagem profunda. A grande diferença entre eles é a forma como eles lidam com regularização de peso, que impacta sua eficácia em diferentes cenários.

Enquanto o Adam combina momento e taxas de aprendizagem adaptativas para oferecer uma otimização eficiente, ele incorpora regularização L2 de uma maneira que pode impedir o desempenho. O AdamW resolve isso desacoplando a decréscimo de peso da atualização da taxa de aprendizagem, oferecendo uma abordagem mais eficaz para modelos grandes e melhorando a generalização. A decréscimo de peso, uma forma de regularização L2, penaliza pesos grandes no modelo. O Adam incorpora a decréscimo de peso no processo de atualização da gradiente, enquanto o AdamW a aplica separadamente após a atualização da gradiente

Aqui estão algumas outras formas de diferenças entre o Adam e o AdamW:

Principais diferenças entre o Adam e o AdamW

Embora ambos os otimizadores sejam projetados para gerenciar momento e ajustar taxas de aprendizagem dinamicamente, eles diferem fundamentalmente no seu tratamento da decaimento de peso.

No Adam, o decaimento de peso é aplicado de forma indireta como parte do atualização de gradiente, o que pode modificar acidentalmente as dinâmicas de aprendizagem e interferir no processo de otimização. No entanto, o AdamW separa o decaimento de peso da etapa de gradiente, garantindo que a regularização impacte diretamente os parâmetros sem alterar o mecanismo de aprendizagem adaptativo.

Este design leva a regularização mais precisa, ajudando os modelos a generalizar melhor, particularmente em tarefas que envolvem grandes e complexos conjuntos de dados. Como resultado, os dois otimizadores frequentemente têm casos de uso muito diferentes.

Casos de uso para Adam

O Adam funciona melhor em tarefas onde a regularização é menos crítica ou quando a eficiência computacional é priorizada sobre a generalização. Exemplos incluem:

  • Redutores de Redes Neurais. Para tarefas como classificação básica de imagens usando pequenas CNNs (Convoluções Neurais) em conjuntos de dados como MNIST ou CIFAR-10, onde a complexidade do modelo é baixa, o Adam pode otimizar eficientemente sem a necessidade de regularização extensiva.
  • Problemas de regressão simples. Em tarefas de regressão simples com conjuntos de características limitados, como previsão de preços de casas usando um modelo de regressão linear, o Adam pode convergir rapidamente sem a necessidade de técnicas de regularização avançadas.
  • Protótipos de estágios iniciais. Durante as primeiras fases do desenvolvimento do modelo, onde é necessária uma experiência rápida, o Adam permite rápidas iterações em arquiteturas mais simples, permitindo que pesquisadores identifiquem problemas sem o overhead de ajustar parâmetros de regularização.
  • Dados menos ruídosos. Quando trabalhando com conjuntos de dados limpos com ruído mínimo, como dados de texto bem curados para análise de sentimento, o Adam pode aprender padrões efetivamente sem o risco de overfitting que poderia exigir regularização mais pesada.
  • Ciclos de treinamento curtos. Em situações com limitações de tempo, como implantação rápida de modelos para aplicações em tempo real, a otimização eficiente do Adam pode ajudar a entregar resultados satisfatórios rapidamente, mesmo que eles não sejam totalmente otimizados para generalização.

Casos de uso para AdamW

O AdamW se destaca em cenários onde o overfitting é um problema e o tamanho do modelo é substancial. Por exemplo:

  • Transformadores em escala large. Em tarefas de processamento de linguagem natural, como a finetuning de modelos como o GPT the grandes corpora de texto, a habilidade do AdamW de gerenciar o decaimento de peso efetivamente previne o overfitting, garantindo melhor generalização.
  • Modelos de visão computacional complexos. Para tarefas que envolvem redes neurais convolucionais profundas (CNNs) treinadas em grandes conjuntos de dados como ImageNet, o AdamW ajuda a manter a estabilidade e o desempenho do modelo desacoplando o decaimento de peso, o que é crucial para alcançar alta precisão.
  • Aprendizado multi-tarefa. Em cenários onde um modelo é treinado simultaneamente em várias tarefas, o AdamW oferece flexibilidade em lidar com dados de dataset diversos e evita o overfitting em qualquer tarefa única.
  • Modelos geradores. Para treinar redes adversárias generativas (GANs), onde manter o equilíbrio entre o gerador e o discriminador é crítico, a melhor regularização do AdamW pode ajudar a estabilizar o treinamento e melhorar a qualidade das saídas geradas.
  • Aprendizado por reforço. Em aplicações de aprendizado por reforço onde os modelos têm que se adaptar a ambientes complexos e aprender políticas robustas, o AdamW ajuda a mitigar o overfitting the estados ou ações específicos, melhorando a performance geral do modelo em situações variadas.

Vantagens do AdamW sobre o Adam

Mas por que alguém faria uso do AdamW ao invés do Adam? Simples. O AdamW oferece vários benefícios chave que melhoram seu desempenho, particularmente em cenários de modelagem complexa.

Ele aborda algumas das limitações encontradas no otimizador Adam, tornando-o mais eficaz em optimizações e contribuindo para melhorias no treinamento de modelos e na robustez.

Aqui estão algumas das vantagens destacadas:

  • Decuplação do decréscimo de peso.Ao separar o decréscimo de peso das atualizações de gradiente, o AdamW permite um controle mais preciso sobre a regularização, levando a melhor generalização do modelo.
  • Generalização aprimorada. O AdamW reduce o risco de overfitting, especialmente em modelos em larga escala, fazendo dele adequado para tarefas que envolvem conjuntos de dados extensos e arquiteturas complexas.
  • Estabilidade durante o treinamento. O design do AdamW ajuda a manter a estabilidade ao longo do processo de treinamento, o que é essencial para modelos que requerem cuidadoso ajuste de seus hiperparâmetros.
  • Escalabilidade.O AdamW é particularmente eficaz para dimensionar modelos, pois consegue lidar com a complexidade aumentada de redes profundas sem sacrificar desempenho, permitindo-o ser aplicado em arquiteturas de ponta.

Como o AdamW Funciona

A principal força do AdamW está em sua abordagem à decaimento de peso, que está desacopulado das atualizações adaptativas de gradiente típicas do Adam. Essajustificativa garante que a regularização é aplicada diretamente aos pesos do modelo, melhorando a generalização sem afetar negativamente as dinâmicas da taxa de aprendizagem.

O otimizador se baseia na natureza adaptativa de Adam, mantendo os benefícios da aceleração de momento e ajustes de taxa de aprendizagem por parâmetro. A aplicação de decomposição independente resolve uma das principais limitações de Adam: sua tendência de afetar as atualizações de gradiente durante a regularização. Essa separação permite que AdamW mantenha um aprendizagem estável, mesmo em modelos complexos e em escala grande, enquanto controle o overfitting.

Nas seções seguintes, exploraremos a teoria por trás da decomposição de peso e da regularização e a matemática que subsidiaria o processo de otimização de AdamW.

Teoria por Trás da Decomposição de Peso e da Regularização L2

A regularização L2 é uma técnica usada para evitar o overfitting. Ela alcança esse objetivo adicionando uma penalidade à função de perda, desencorajando valores de peso grandes. Esta técnica ajuda a criar modelos mais simples que generalizam melhor para novos dados.

Em optimizadores tradicionais, como o Adam, a decréscimo de peso é aplicada como parte da atualização de gradientes, o que acidentalmente afeta as taxas de aprendizagem e pode levar a desempenho subótimo.

O AdamW melhora isso decouplando a decréscimo de peso da computação de gradientes. Em outras palavras, em vez de aplicar a decréscimo de peso durante a atualização de gradientes, o AdamW o trata como um passo separado, aplicando-o diretamente aos pesos após a atualização de gradientes. Isso evita que a decréscimo de peso interfira no processo de otimização, levando a treinamentos mais estáveis e melhores generalizações.

Fundamento Matemático do AdamW

O AdamW modifica o optimizador Adam tradicional alterando a forma como a decréscimo de peso é aplicada. As equações centrais para o AdamW podem ser representadas da seguinte forma:

  1. Momentum e taxa de aprendizagem adaptativa:Como o Adam, o AdamW usa momentum e taxas de aprendizagem adaptativas para calcular atualizações de parâmetros com base nas médias移动 de gradientes e gradientes quadrados.

A equação para momentum e taxa de aprendizagem adaptativa

  1. Estimativas corretas de viés:As primeiras e segundas estimativas de momento são corrigidas para o viés usando o seguinte:

A fórmula para estimativas corretas de viés

  1. Atualização de parâmetro com decaimento de peso desacoplando:No AdamW, o decaimento de peso é aplicado diretamente aos parâmetros após a atualização da gradiente. A regra de atualização é:

Atualização de parâmetro com decaimento de peso desacoplando

Aqui, η é a taxa de aprendizagem, λ é o fator de decaimento de peso, e θt representa os parâmetros. Este termo de decaimento de peso desacoplando λθt garante que a regularização é aplicada independentemente da atualização da gradiente, que é a diferença chave em relação ao Adam.

Implementação do AdamW em PyTorch

Implementar o AdamW em PyTorch é simples; este tópico fornece um guia completo para configurá-lo. Siga com estas etapas para aprender a ajustar modelos com eficiência o Otimizador Adam.

Um guia passo a passo para o AdamW no PyTorch

Nota: este tutorial pressupõe que você já instalou o PyTorch. Consulte a Documentação para obter orientações.

Passo 1: Importar as bibliotecas necessárias

import torch
import torch.nn as nn
import torch.optim as optim
Import torch.nn.functional as F

Passo 2:Definir o modelo

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0) 
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1) 
        self.fc1 = nn.Linear(64 * 8 * 8, 128) 
        self.fc2 = nn.Linear(128, 10) 

    def forward(self, x): 
        x = self.pool(F.relu(self.conv1(x))) 
        x = self.pool(F.relu(self.conv2(x))) 
        x = x.view(-1, 64 * 8 * 8) 
        x = F.relu(self.fc1(x)) 
        x = self.fc2(x)

Passo 3: Configurar os hiperparâmetros

learning_rate = 1e-4
weight_decay = 1e-2
num_epochs = 10 # número de épocas

Passo 4:Inicializar o otimizador AdamW e configurar a função de perda

optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=weight_decay) 
criterion = nn.CrossEntropyLoss()

Voilà!

Agora, você está pronto para começar a treinar o seu modelo de CNN, e é isso que faremos na próxima seção.

Exemplo Prático: Ajustando um Modelo Usando AdamW

Acima, definimos o modelo, definimos os hiperparâmetros, inicializamos o otimizador (AdamW), e configuramos a função de perda.

Para treinar o modelo, precisaremos de importar alguns módulos adicionais;

from torch.utils.data import DataLoader # fornece uma iteração do conjunto de dados
import torchvision
import torchvision.transforms as transforms

A seguir, defina o conjunto de dados e os dataloaders. Para este exemplo, usaremos o conjunto de dados CIFAR-10:

# Define as transformações para o conjunto de treinamento
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
# Carregar o conjunto de dados CIFAR-10
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
val_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
# Criar carregadores de dados
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

Como já definimos o nosso modelo, a próxima etapa é implementar o loop de treinamento para otimizar o modelo usando AdamW.

Eis como isso se parece:

for epoch in range(num_epochs):
    model.train()  # Defina o modelo para o modo de treinamento
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()  # Limpar gradientes
        outputs = model(inputs)  # Passo de frente
        loss = criterion(outputs, labels)  # Calcular perda
        loss.backward()  # Passo de trás
        optimizer.step()  # Atualizar pesos
        running_loss += loss.item()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}')

A última etapa é validar o desempenho do modelo no conjunto de dados de validação que criamos anteriormente.

Aqui está o código: 

model.eval()  # Define o modelo em modo de avaliação
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in val_loader:
        outputs = model(inputs)  # Passo de encontro
        _, predicted = torch.max(outputs.data, 1)  # Obtém a classe predita
        total += labels.size(0)  # Atualiza o total de amostras
        correct += (predicted == labels).sum().item()  # Atualiza as predições corretas
accuracy = 100 * correct / total
print(f'Validation Accuracy: {accuracy:.2f}%')

E pronto.

Agora você sabe como implementar AdamW no PyTorch.

Casos de Uso Comuns para AdamW

Ok, então nós estabelecemos que AdamW ganhou popularidade devido a seu gerenciamento mais eficaz de decaimento de peso do que seu predecessor, Adam.

Mas qual são alguns casos de uso comuns para este otimizador? 

Nós entraremos nisto na seção…

Modelos de Aprendizagem Profunda em Scala

O AdamW é particularmente benéfico na treinagem de modelos grandes, como o BERT, GPT e outras arquiteturas de transformador. Esses modelos normalmente têm milhões ou até biliões de parâmetros, o que muitas vezes significa que exigem algoritmos de otimização eficientes que gerem atualizações de peso complexas e desafios de generalização.

Tarefas de Visão Computacional e Pesquisa por Texto

O AdamW tornou-se o otimizador de escolha em tarefas de visão computacional envolvendo CNNs e tarefas de pesquisa por texto envolvendo transformadores. Sua capacidade de prevenir overfitting o torna ideal para tarefas envolvendo grandes conjuntos de dados e arquiteturas complexas. A desacoplação da decaimento de peso significa que o AdamW evita os problemas encontrados por Adam na over-regularização de modelos.

Ajuste de Hiperparâmetros no AdamW

Ajuste de hiperparâmetros é o processo de selecionar as melhores configurações para parâmetros que controlam o treinamento de um modelo de aprendizagem automática, mas que não são aprendidos a partir dos dados em questão. Estes parâmetros influenciam diretamente como o modelo otimiza e converge.

O ajuste adequado destes hiperparâmetros no AdamW é essencial para alcançar treinamento eficiente, evitar sobreajuste e garantir que o modelo generaliza bem a dados não vistos.

Nesta seção, nós exploraremos como realizar o refinamento dos hiperparâmetros chave do AdamW para obter desempenho ótimo.

Práticas recomendadas para escolha das taxas de aprendizagem e decaimento de peso

A taxa de aprendizagem é um hiperparâmetro que controla quanto ajustar os pesos do modelo em relação à gradiente de perda durante cada passo de treinamento. Uma taxa de aprendizagem mais alta acelera o treinamento, mas pode causar o modelo a ultrapassar os pesos ótimos, enquanto uma taxa mais baixa permite ajustes mais finos mas pode tornar o treinamento mais lento ou ocorrer um estouro local.

Decaimento de peso, por outro lado, é uma técnica de regularização usada para evitar sobreajuste penalizando pesos grandes no modelo. Na verdade, o decaimento de peso adiciona uma pequena penalidade proporcional ao tamanho dos pesos do modelo durante o treinamento, ajudando a reduzir a complexidade do modelo e melhorar a generalização para novos dados.

Para escolher taxas de aprendizagem e valores de decaimento de peso ótimos para o AdamW:

  1. Comece com uma taxa de aprendizagem moderada – Para o AdamW, uma taxa de aprendizagem em torno de 1e-3 muitas vezes é um bom ponto de partida. Você pode ajustá-la com base em como o modelo se ajusta, abaixando-a se o modelo tiver dificuldade em se ajustar ou aumentando-a se o treinamento for muito lento.
  2. Experimentar com decaimento de peso. Comece com um valor em torno de 1e-2 a 1e-4, dependendo do tamanho do modelo e do conjunto de dados. Um decaimento de peso ligeiramente maior pode ajudar a prevenir overfitting the maiores, modelos complexos, enquanto modelos menores podem precisar de menos regularização.
  3. Usar programação de taxa de aprendizagem. Implementar programações de taxa de aprendizagem (como decaimento de passo ou anelhamento cosseno) para reduzir dinamicamente a taxa de aprendizagem conforme o treinamento progrede, ajudando o modelo a finetune seus parâmetros conforme se aproxima da convergência.
  4. Monitorar desempenho. Continuamente monitorar o desempenho do modelo no conjunto de validação. Se você observar overfitting, considere aumentar o decaimento de peso, ou se o erro de treinamento estiver platônico, reduzir a taxa de aprendizagem para melhor otimização.

Pensamentos finais

AdamW tornou-se um dos melhores otimizadores para aprendizagem profunda, especialmente para modelos em escala grande. Isto é devido à sua capacidade de desacoplar a decaimento de peso de atualizações de gradiente. Em outras palavras, o design do AdamW melhora a regularização e ajuda os modelos a generalizar melhor, particularmente quando se trata de arquiteturas complexas e conjuntos de dados extensos.

Como demonstrado neste tutorial, a implementação do AdamW em PyTorch é fácil – só requer algumas mudanças do Adam. No entanto, a configuração de hiperparâmetros permanece um passo crucial para maximizar a eficácia do AdamW. Encontrar o equilíbrio certo entre a taxa de aprendizagem e o decaimento de peso é essencial para garantir que o otimizador funcione eficientemente sem sobrelógica ou sobreajuste do modelo.

Agora você sabe o suficiente para implementar o AdamW em seus próprios modelos. Para continuar seu aprendizado, verifique algumas dessas fontes:

Source:
https://www.datacamp.com/tutorial/adamw-optimizer-in-pytorch