Tutorial sull'ottimizzatore AdamW in PyTorch

Gli algoritmi di ottimizzazione giocano un ruolo cruciale nel deep learning: regolano finemente i pesi del modello per minimizzare le funzioni di perdita durante l’addestramento. Uno di questi algoritmi è l’ottimizzatore Adam.

Adam è diventato estremamente popolare nel deep learning grazie alla sua capacità di combinare i vantaggi del momentum e dei tassi di apprendimento adattivi. Questo lo ha reso altamente efficiente nell’addestramento di reti neurali profonde. Inoltre richiede una minima regolazione degli iperparametri, risultando quindi ampiamente accessibile ed efficace in vari compiti.

Nel 2017, Ilya Loshchilov e Frank Hutter hanno introdotto una versione più avanzata del popolare algoritmo Adam nel loro paper "Decoupled Weight Decay Regularization." L’hanno chiamata AdamW, che si distingue per il fatto di separare il weight decay dal processo di aggiornamento del gradiente. Questa separazione è un miglioramento cruciale rispetto ad Adam e aiuta una migliore generalizzazione del modello.

AdamW è diventato sempre più importante nelle applicazioni moderne di deep learning, in particolare nella gestione di modelli su larga scala. La sua superiore capacità di regolare gli aggiornamenti dei pesi ha contribuito alla sua adozione in compiti che richiedono alte prestazioni e stabilità. 

In questo tutorial vedremo le differenze chiave tra Adam e AdamW, i diversi casi d’uso e implementeremo una guida passo passo per utilizzare AdamW in PyTorch. 

Adam vs AdamW

Adam e AdamW sono entrambi ottimizzatori adattivi ampiamente utilizzati nel deep learning. La grande differenza tra loro è come gestiscono la regolarizzazione dei pesi, il che influisce sulla loro efficacia in scenari diversi. 

Mentre Adam combina momentum e tassi di apprendimento adattivi per offrire un’ottimizzazione efficiente, incorpora la regolarizzazione L2 in un modo che può ostacolare le prestazioni. AdamW affronta questo problema separando il weight decay dall’aggiornamento del tasso di apprendimento, offrendo un approccio più efficace per i modelli di grandi dimensioni e migliorando la generalizzazione. Il weight decay, una forma di regolarizzazione L2, penalizza i pesi elevati nel modello. Adam incorpora il weight decay nel processo di aggiornamento del gradiente, mentre AdamW lo applica separatamente dopo l’aggiornamento del gradiente

Ecco altri modi in cui differiscono: 

Differenze chiave tra Adam e AdamW

Sebbene entrambi gli ottimizzatori siano progettati per gestire il momentum e regolare dinamicamente i tassi di apprendimento, differiscono in modo fondamentale nel trattamento del weight decay. 

In Adam, il weight decay è applicato indirettamente come parte dell’aggiornamento del gradiente, il che può modificare involontariamente le dinamiche di apprendimento e interferire con il processo di ottimizzazione. AdamW, invece, separa il weight decay dallo step del gradiente, garantendo che la regolarizzazione influisca direttamente sui parametri senza alterare il meccanismo di apprendimento adattivo. 

Questo design porta a una regolarizzazione più precisa, aiutando i modelli a generalizzare meglio, in particolare in compiti che coinvolgono dataset grandi e complessi. Di conseguenza, i due ottimizzatori hanno spesso casi d’uso molto diversi.  

Casi d’uso per Adam

Adam rende meglio in compiti in cui la regolarizzazione è meno critica o quando l’efficienza computazionale è prioritaria rispetto alla generalizzazione. Esempi:

• Reti neurali più piccole. Per compiti come la classificazione di immagini di base usando piccole CNN (Convolutional Neural Networks) su dataset come MNIST o CIFAR-10, dove la complessità del modello è bassa, Adam può ottimizzare in modo efficiente senza richiedere un’ampia regolarizzazione.
• Problemi di regressione semplici. In compiti di regressione lineare con set di feature limitati, come la previsione dei prezzi delle case usando un modello di regressione lineare, Adam può convergere rapidamente senza necessità di tecniche di regolarizzazione avanzate.
• Prototipazione nelle fasi iniziali. Nelle prime fasi di sviluppo del modello, quando servono esperimenti rapidi, Adam consente iterazioni veloci su architetture semplici, permettendo ai ricercatori di individuare potenziali problemi senza l’onere della messa a punto dei parametri di regolarizzazione.
• Dati poco rumorosi. Quando si lavora con dataset puliti con rumore minimo, come testi ben curati per l’analisi del sentiment, Adam può apprendere efficacemente i pattern senza il rischio di overfitting che potrebbe richiedere una regolarizzazione più pesante.
• Cicli di training brevi. In scenari con vincoli di tempo, come la rapida messa in produzione di modelli per applicazioni in tempo reale, l’ottimizzazione efficiente di Adam può aiutare a ottenere rapidamente risultati soddisfacenti, anche se potrebbero non essere ottimizzati al massimo per la generalizzazione.

Casi d’uso per AdamW

AdamW eccelle negli scenari in cui l’overfitting è una preoccupazione e la dimensione del modello è significativa. Ad esempio: 

• Transformer su larga scala. Nei compiti di elaborazione del linguaggio naturale, come il fine-tuning di modelli tipo GPT su ampi corpora di testo, la capacità di AdamW di gestire efficacemente il weight decay previene l’overfitting, garantendo una migliore generalizzazione.
• Modelli di computer vision complessi. Per compiti che coinvolgono reti neurali convoluzionali profonde (CNN) addestrate su grandi dataset come ImageNet, AdamW aiuta a mantenere stabilità e prestazioni del modello separando il weight decay, cruciale per ottenere alta accuratezza.
• Apprendimento multi-task. In scenari in cui un modello è addestrato su più compiti contemporaneamente, AdamW offre la flessibilità per gestire dataset eterogenei e prevenire l’overfitting su un singolo task.
• Modelli generativi. Per l’addestramento di GAN, dove è fondamentale mantenere l’equilibrio tra generatore e discriminatore, la migliore regolarizzazione di AdamW può aiutare a stabilizzare il training e migliorare la qualità degli output generati.
• Reinforcement learning. Nelle applicazioni di apprendimento per rinforzo, dove i modelli devono adattarsi a ambienti complessi e apprendere policy robuste, AdamW aiuta a mitigare l’overfitting a stati o azioni specifiche, migliorando le prestazioni generali del modello in situazioni varie.

Vantaggi di AdamW rispetto ad Adam

Ma perché qualcuno dovrebbe usare AdamW invece di Adam? Semplice. AdamW offre diversi vantaggi chiave che ne migliorano le prestazioni, soprattutto in scenari di modellazione complessi. 

Affronta alcune delle limitazioni riscontrate nell’ottimizzatore Adam, risultando più efficace nell’ottimizzazione e contribuendo a migliorare l’addestramento e la robustezza del modello. 

Ecco altri vantaggi di rilievo:

• Weight decay disaccoppiato. Separando il weight decay dagli aggiornamenti del gradiente, AdamW consente un controllo più preciso sulla regolarizzazione, portando a una migliore generalizzazione del modello.
• Migliore generalizzazione. AdamW riduce il rischio di overfitting, soprattutto nei modelli su larga scala, rendendolo adatto a compiti con dataset estesi e architetture articolate.
• Stabilità durante l’addestramento. Il design di AdamW aiuta a mantenere la stabilità durante tutto il processo di training, fondamentale per i modelli che richiedono un’attenta messa a punto degli iperparametri.
• Scalabilità. AdamW è particolarmente efficace nel fare scaling dei modelli, poiché può gestire la maggiore complessità delle reti profonde senza sacrificare le prestazioni, permettendo l’applicazione in architetture all’avanguardia.

Come funziona AdamW

La forza principale di AdamW risiede nel suo approccio al weight decay, che è disaccoppiato dagli aggiornamenti adattivi del gradiente tipici di Adam. Questa modifica garantisce che la regolarizzazione sia applicata direttamente ai pesi del modello, migliorando la generalizzazione senza influire negativamente sulle dinamiche del tasso di apprendimento.

L’ottimizzatore si basa sulla natura adattiva di Adam, mantenendo i benefici del momentum e degli aggiustamenti del tasso di apprendimento per parametro. Applicare il weight decay in modo indipendente affronta una delle principali carenze di Adam: la tendenza a influenzare gli aggiornamenti del gradiente durante la regolarizzazione. Questa separazione consente ad AdamW di mantenere un apprendimento stabile, anche in modelli complessi e su larga scala, tenendo sotto controllo l’overfitting.

Nelle sezioni seguenti, esploreremo la teoria dietro il weight decay e la regolarizzazione e la matematica alla base del processo di ottimizzazione di AdamW.

Teoria del weight decay e della regolarizzazione L2

La regolarizzazione L2 è una tecnica usata per prevenire l’overfitting. Raggiunge questo obiettivo aggiungendo un termine di penalità alla funzione di perdita, scoraggiando valori di peso elevati. Questa tecnica aiuta a creare modelli più semplici che generalizzano meglio a nuovi dati. 

Negli ottimizzatori tradizionali, come Adam, il weight decay viene applicato come parte dell’aggiornamento del gradiente, influenzando involontariamente i tassi di apprendimento e portando a prestazioni subottimali.

AdamW migliora questo aspetto separando il weight decay dal calcolo del gradiente. In altre parole, invece di applicare il weight decay durante l’aggiornamento del gradiente, AdamW lo tratta come uno step separato, applicandolo direttamente ai pesi dopo l’aggiornamento del gradiente. Ciò impedisce al weight decay di interferire con il processo di ottimizzazione, portando a un training più stabile e a una migliore generalizzazione.

Fondamenti matematici di AdamW

AdamW modifica l’ottimizzatore Adam tradizionale cambiando il modo in cui viene applicato il weight decay. Le equazioni di base per AdamW possono essere rappresentate come segue:

1. Momentum e tasso di apprendimento adattivo: Analogamente ad Adam, AdamW usa momentum e tassi di apprendimento adattivi per calcolare gli aggiornamenti dei parametri basati sulle medie mobili dei gradienti e dei gradienti al quadrato.

L’equazione per momentum e tasso di apprendimento adattivo

2. Stime corrette dal bias:Le stime del primo e del secondo momento vengono corrette dal bias come segue:

La formula per le stime corrette dal bias

3. Aggiornamento dei parametri con weight decay disaccoppiato: In AdamW, il weight decay è applicato direttamente ai parametri dopo l’aggiornamento del gradiente. La regola di aggiornamento è:

Aggiornamento dei parametri con weight decay disaccoppiato

Qui, η è il learning rate, λ è il fattore di weight decay e θt​ rappresenta i parametri. Questo termine di weight decay disaccoppiato λθt​ garantisce che la regolarizzazione sia applicata in modo indipendente dall’aggiornamento del gradiente, che è la differenza chiave rispetto ad Adam.

Implementazione di AdamW in PyTorch

Implementare AdamW in PyTorch è semplice; questa sezione fornisce una guida completa alla configurazione. Segui questi passaggi per imparare a fare fine-tuning dei modelli in modo efficace con l’ottimizzatore Adam. 

Guida passo passo ad AdamW in PyTorch

Nota: questo tutorial presume che tu abbia già installato PyTorch. Fai riferimento alla documentazione per qualsiasi guida. 

Passaggio 1: importa le librerie necessarie

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

Passaggio 2: definisci il modello

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) 
Offerto da

Passaggio 3: imposta gli iperparametri 

learning_rate = 1e-4
weight_decay = 1e-2
num_epochs = 10 # number of epochsOfferto da

Passaggio 4: inizializza l’ottimizzatore AdamW e configura la funzione di perdita

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

Voilà! 

Ora sei pronto per iniziare ad addestrare il tuo modello CNN, ed è quello che faremo nella prossima sezione. 

Esempio pratico: fine-tuning di un modello con AdamW

Sopra abbiamo definito il modello, impostato gli iperparametri, inizializzato l’ottimizzatore (AdamW) e configurato la funzione di perdita. 

Per addestrare il modello, dobbiamo importare ancora alcuni moduli; 

from torch.utils.data import DataLoader # provides an iterable of the dataset
import torchvision
import torchvision.transforms as transformsOfferto da

Successivamente, definisci il dataset e i dataloader. Per questo esempio useremo il dataset CIFAR-10: 

# Define transformations for the training set
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
# Load CIFAR-10 dataset
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)
# Create data loaders
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)Offerto da

Dato che abbiamo già definito il nostro modello, il passo successivo è implementare il training loop per ottimizzarlo usando AdamW. 

Ecco come appare: 

for epoch in range(num_epochs):
    model.train()  # Set the model to training mode
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()  # Clear gradients
        outputs = model(inputs)  # Forward pass
        loss = criterion(outputs, labels)  # Calculate loss
        loss.backward()  # Backward pass
        optimizer.step()  # Update weights
        running_loss += loss.item()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}')Offerto da

L’ultimo passo è validare le prestazioni del modello sul dataset di validazione che abbiamo creato in precedenza. 

Ecco il codice: 

model.eval()  # Set the model to evaluation mode
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in val_loader:
        outputs = model(inputs)  # Forward pass
        _, predicted = torch.max(outputs.data, 1)  # Get predicted class
        total += labels.size(0)  # Update total samples
        correct += (predicted == labels).sum().item()  # Update correct predictions
accuracy = 100 * correct / total
print(f'Validation Accuracy: {accuracy:.2f}%')Offerto da

Ed ecco fatto. 

Ora sai come implementare AdamW in PyTorch. 

Casi d’uso comuni per AdamW

Ok, abbiamo stabilito che AdamW ha guadagnato popolarità grazie alla gestione più efficace del weight decay rispetto al suo predecessore, Adam. 

Ma quali sono alcuni casi d’uso comuni per questo ottimizzatore? 

Lo vedremo in questa sezione… 

Modelli di deep learning su larga scala

AdamW è particolarmente utile nell’addestramento di grandi modelli come BERT, GPT e altre architetture transformer. Tali modelli hanno in genere milioni o addirittura miliardi di parametri, il che spesso significa che richiedono algoritmi di ottimizzazione efficienti in grado di gestire aggiornamenti dei pesi complessi e sfide di generalizzazione.

Compiti di computer vision e NLP

AdamW è diventato l’ottimizzatore di riferimento nei compiti di computer vision che coinvolgono CNN e nei compiti di NLP che coinvolgono transformer. La sua capacità di prevenire l’overfitting lo rende ideale per compiti con dataset ampi e architetture complesse. Il disaccoppiamento del weight decay fa sì che AdamW eviti i problemi riscontrati da Adam nel sovra-regolarizzare i modelli.

Tuning degli iperparametri in AdamW

Il tuning degli iperparametri è il processo di selezione dei valori migliori per i parametri che governano l’addestramento di un modello di machine learning ma che non vengono appresi dai dati stessi. Questi parametri influenzano direttamente come il modello si ottimizza e converge. 

Una corretta regolazione di questi iperparametri in AdamW è essenziale per ottenere un addestramento efficiente, evitare l’overfitting e garantire che il modello generalizzi bene a dati mai visti. 

In questa sezione, vedremo come ottimizzare i principali iperparametri di AdamW per prestazioni ottimali.

Best practice per scegliere learning rate e weight decay

Il learning rate è un iperparametro che controlla di quanto modificare i pesi del modello rispetto al gradiente della perdita a ogni step di training. Un learning rate più alto accelera il training ma può far superare i pesi ottimali; un tasso più basso consente aggiustamenti più fini ma può rallentare l’addestramento o farlo rimanere bloccato in minimi locali.

Il weight decay, invece, è una tecnica di regolarizzazione usata per prevenire l’overfitting penalizzando i pesi elevati nel modello. In pratica, il weight decay aggiunge una piccola penalità proporzionale alla dimensione dei pesi del modello durante l’addestramento, aiutando a ridurre la complessità del modello e a migliorare la generalizzazione a nuovi dati.

Per scegliere learning rate e weight decay ottimali per AdamW: 

1. Parti da un learning rate moderato – Per AdamW, un learning rate intorno a 1e-3 è spesso un buon punto di partenza. Puoi regolarlo in base a come il modello converge, abbassandolo se fatica a convergere o aumentandolo se il training è troppo lento.
2. Sperimenta con il weight decay. Parti da un valore tra 1e-2 e 1e-4, a seconda della dimensione del modello e del dataset. Un weight decay leggermente più alto può aiutare a prevenire l’overfitting per modelli grandi e complessi, mentre modelli più piccoli possono richiedere meno regolarizzazione.
3. Usa il scheduling del learning rate. Implementa dei schedule del learning rate (come step decay o cosine annealing) per ridurlo dinamicamente man mano che l’addestramento procede, aiutando il modello a rifinire i parametri quando si avvicina alla convergenza.
4. Monitora le prestazioni. Tieni traccia continuamente delle prestazioni del modello sul set di validazione. Se osservi overfitting, valuta di aumentare il weight decay; se la loss di training va in stallo, riduci il learning rate per un’ottimizzazione migliore.

Considerazioni finali

AdamW è emerso come uno degli ottimizzatori più efficaci nel deep learning, soprattutto per modelli su larga scala. Ciò è dovuto alla sua capacità di disaccoppiare il weight decay dagli aggiornamenti del gradiente. In sostanza, il design di AdamW migliora la regolarizzazione e aiuta i modelli a generalizzare meglio, in particolare quando si affrontano architetture complesse e dataset estesi. 

Come mostrato in questo tutorial, implementare AdamW in PyTorch è semplice: richiede solo pochi aggiustamenti rispetto ad Adam. Tuttavia, il tuning degli iperparametri resta un passaggio cruciale per massimizzare l’efficacia di AdamW. Trovare il giusto equilibrio tra learning rate e weight decay è essenziale per garantire che l’ottimizzatore lavori in modo efficiente senza overfitting o underfitting del modello.

Ora sai abbastanza per implementare AdamW nei tuoi modelli. Per continuare a imparare, dai un’occhiata a queste risorse: 

• Keras Cheat Sheet: Reti neurali in Python
• Gradient Descent nel Machine Learning: un approfondimento
• Guida alle certificazioni e ai certificati PyTorch
• Deep learning intermedio con PyTorch