Stochastic Gradient Descent (SGD)

La discesa stocastica del gradiente (SGD) è un algoritmo di ottimizzazione che addestra un modello aggiornandone ripetutamente i pesi con il gradiente della perdita calcolato su un piccolo campione casuale dei dati di addestramento, anziché sull'intero dataset. Il gradiente di ciascun campione è una stima rumorosa ma non distorta del gradiente calcolato sull'intero dataset, quindi SGD esegue molti aggiornamenti economici nel tempo che la discesa del gradiente a batch completo impiegherebbe per un singolo aggiornamento costoso. Il metodo discende dal metodo di approssimazione stocastica di Robbins e Monro del 1951 e, con il momentum, resta un ottimizzatore standard per le reti neurali convoluzionali (CNN).

Come funziona SGD#

A ogni passo, SGD prende un mini-batch B, calcola con la retropropagazione il gradiente della perdita su quel mini-batch e aggiorna ogni peso con un piccolo passo nella direzione opposta al gradiente: w ← w − η·∇L_B(w), dove η è il tasso di apprendimento. In senso stretto, SGD usa un solo esempio per passo, ma i framework di apprendimento profondo lo applicano a mini-batch da decine a migliaia di esempi; nella pratica, "SGD" e "discesa del gradiente mini-batch" sono sinonimi. Una dimensione del batch maggiore produce un gradiente meno rumoroso e un utilizzo migliore dell'hardware, ma comporta meno aggiornamenti per epoca.

All'inizio di ogni epoca, l'addestramento mescola i dati, li scorre in mini-batch ed esegue un aggiornamento per batch. L'adattamento di una retta a 1.000 punti rumorosi mostra l'intera procedura:

import torch

torch.manual_seed(0)

# 1,000 noisy samples of y = 3x + 2
x = torch.randn(1000, 1)
y = 3 * x + 2 + 0.1 * torch.randn(1000, 1)

model = torch.nn.Linear(1, 1)
optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.9)

for epoch in range(5):
    # Reshuffle every epoch, then update the weights once per 32-sample mini-batch
    for idx in torch.randperm(1000).split(32):
        loss = torch.nn.functional.mse_loss(model(x[idx]), y[idx])
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f"epoch {epoch}: w = {model.weight.item():.3f}, b = {model.bias.item():.3f}, loss = {loss.item():.4f}")

Dopo due epoche, per un totale di 64 aggiornamenti, il peso raggiunge 3.081 e il bias 2.012. Nelle tre epoche successive, il peso continua a oscillare tra 2.967 e 3.003 invece di stabilizzarsi, perché ogni gradiente calcolato su un mini-batch contiene rumore di campionamento; la perdita sull'ultimo batch resta vicina a 0.01, la varianza del rumore aggiunto a y.

Tasso di apprendimento, rumore e dimensione del batch#

Con un tasso di apprendimento costante, SGD oscilla in una regione attorno al minimo, la cui ampiezza aumenta con il tasso di apprendimento e il rumore del gradiente. La teoria dell’approssimazione stocastica garantisce la convergenza solo quando il tasso di apprendimento tende a zero, quindi nell’addestramento pratico lo si riduce nel tempo con una pianificazione a gradini o coseno, di solito dopo un breve riscaldamento. Il rumore del gradiente dei batch piccoli spinge inoltre SGD verso minimi piatti, che generalizzano meglio dei minimi ripidi che l’addestramento con batch grandi tende a trovare, una forma implicita di regolarizzazione.

La dimensione del batch e il tasso di apprendimento interagiscono. Aumentare il tasso di apprendimento in proporzione alla dimensione del batch, con un riscaldamento di cinque epoche, ha permesso a ResNet-50 di addestrarsi su ImageNet in un’ora con mini-batch di 8.192 immagini, senza perdita di accuratezza.

Momentum e momentum di Nesterov#

In una valle lunga e stretta della superficie di perdita, il gradiente punta perlopiù attraverso la valle, quindi SGD semplice zigzaga tra le pareti e avanza lentamente lungo il fondo. Momentum mantiene una velocità cumulativa, v ← μ·v + g, e procede lungo di essa, w ← w − η·v, così le direzioni coerenti del gradiente accumulano velocità e quelle oscillanti si annullano. Un coefficiente μ = 0.9 è il valore predefinito abituale. Il momentum di Nesterov valuta il gradiente dopo un passo anticipato lungo la velocità, attenuando ulteriormente il superamento del minimo. SGD di PyTorch implementa entrambi e applica weight_decay aggiungendo λ·w al gradiente, operazione equivalente per SGD a una penalità L2 sui pesi.

SGD e altri ottimizzatori#

• Discesa del gradiente a batch: calcola il gradiente esatto sull’intero dataset a ogni aggiornamento, quindi ogni epoca produce un solo passo e il fabbisogno di memoria cresce con il dataset.
• Adam: assegna a ogni parametro una propria dimensione del passo, ricavata dalle medie mobili dei gradienti e dei gradienti al quadrato, e memorizza due valori di stato per parametro, rispetto a uno per SGD con momentum. Adam avanza più rapidamente nelle fasi iniziali ed è meno sensibile al tasso di apprendimento, mentre SGD con momentum ben ottimizzato spesso eguaglia o supera la sua accuratezza finale sulle CNN. AdamW, la sua variante con decadimento dei pesi disaccoppiato, è l’ottimizzatore standard per i Transformer.
• Muon: ortogonalizza l’aggiornamento del momentum di ciascuna matrice dei pesi nel suo complesso ed è stato scalato per l’addestramento di modelli linguistici di grandi dimensioni.

L'addestramento di Ultralytics YOLO crea SGD PyTorch con momentum Nesterov quando è impostato optimizer="SGD", usando lr0=0.01 e momentum=0.937 per impostazione predefinita. Il valore predefinito di optimizer="auto" ignora lr0 e seleziona MuSGD, un metodo ibrido che combina gli aggiornamenti SGD e Muon, per le esecuzioni di oltre 10.000 iterazioni; per quelle più brevi usa AdamW.

Dove si usa SGD#

SGD con momentum ha addestrato la maggior parte delle CNN di riferimento di ImageNet. I modelli ResNet originali usavano momentum 0.9, decadimento dei pesi 0.0001 e mini-batch di 256 immagini, con un tasso di apprendimento iniziale di 0.1, diviso per 10 ogni volta che l’errore si stabilizzava. Al di fuori del deep learning, SGDClassifier e SGDRegressor di scikit-learn addestrano con SGD modelli lineari come la regressione logistica e le macchine a vettori di supporto lineari; il loro metodo partial_fit addestra inoltre i modelli su dataset troppo grandi per essere caricati in memoria, un blocco alla volta.