Ottimizzatori per reti neurali: SGD, Momentum e Adam in Python

Il concetto in parole semplici

Un ottimizzatore è la regola che trasforma i gradienti in aggiornamenti dei pesi. La discesa del gradiente semplice usa solo il gradiente attuale; il momentum ricorda le direzioni passate e Adam adatta anche la lunghezza del passo per ogni peso.

Confronta la discesa del gradiente semplice, il momentum e Adam minimizzando passo dopo passo la stessa funzione.

Idee chiave

Il momentum mantiene una velocità, così supera zone piatte e piccole irregolarità.
Adam tiene medie mobili del gradiente e del gradiente al quadrato.
La correzione del bias (dividere per 1 − βᵗ) sistema quelle medie nei primi passi.
Una buona inizializzazione dei pesi e i mini-batch rendono l'addestramento anche più veloce e stabile.

Quando si usa?

Capire cosa succede dentro le reti neurali e le librerie di IA.
Imparare l'idea prima di implementarla nelle sfide corrispondenti.
Prepararti a corsi di machine learning, colloqui e progetti.

Guardalo in azione

Premi Avvia per far gareggiare tre ottimizzatori lungo la stessa valle irregolare. Prova un learning rate più alto per vedere il momentum superare il minimo.

Codice di esempio

Esegui codice →

main.py

import math

# Minimise f(x) = (x - 3)² with three optimizers. The gradient is 2(x - 3).
grad = lambda x: 2 * (x - 3)

def sgd(steps, lr=0.1):
    x = 0.0
    for _ in range(steps):
        x -= lr * grad(x)
    return x

def momentum(steps, lr=0.1, beta=0.9):
    x, v = 0.0, 0.0
    for _ in range(steps):
        v = beta * v + grad(x)        # remember the direction we were going
        x -= lr * v
    return x

def adam(steps, lr=0.3, b1=0.9, b2=0.999, eps=1e-8):
    x, m, v = 0.0, 0.0, 0.0
    for t in range(1, steps + 1):
        g = grad(x)
        m = b1 * m + (1 - b1) * g     # running mean of gradients
        v = b2 * v + (1 - b2) * g * g # running mean of squared gradients
        m_hat, v_hat = m / (1 - b1 ** t), v / (1 - b2 ** t)
        x -= lr * m_hat / (math.sqrt(v_hat) + eps)
    return x

for steps in (5, 20, 50):
    print(f"{steps:>2} steps  sgd={sgd(steps):.3f}  momentum={momentum(steps):.3f}  adam={adam(steps):.3f}")

Output previsto

5 steps  sgd=2.017  momentum=4.741  adam=1.476
20 steps  sgd=2.965  momentum=4.048  adam=3.813
50 steps  sgd=3.000  momentum=3.091  adam=3.014

Come funziona

Tutti e tre minimizzano (x − 3)², il cui punto più basso è x = 3. SGD avanza in modo costante, il momentum prende velocità e supera il minimo prima di assestarsi, e Adam regola ogni passo con medie mobili del gradiente e del suo quadrato. Dopo 50 passi tutti e tre sono vicini a 3.

Modifica i valori ed esegui il programma nel compilatore Python online CodeUtility senza installare Python.

Esercizi pratici

Modifica gli input e verifica i casi limite prima di usare dataset più grandi.

Cambia gli input o i pesi e prevedi l'output prima di eseguire.
Stampa i valori intermedi per seguire ogni passo del calcolo.
Risolvi le sfide collegate qui sotto per implementare l'idea da solo.

Esegui nell’IDE Python →

Esercitati con una sfida

Usa ciò che questa lezione spiega per risolvere un problema reale. Ogni sfida gira nel browser, con test immediati e una revisione dell'IA.

Tutte le sfide