Salta al contenuto principale

04 - Ottimizzazione: Gradient Descent, SGD, Adam e Learning Rate Scheduling

Perché lo stesso modello converge con un passo e diverge con un altro: gradient descent, SGD, momentum, Adam e calendari del passo su funzioni semplici.

Cosa ne pensi di questo articolo?

04 - Ottimizzazione: Gradient Descent, SGD, Adam e Learning Rate Scheduling
Math for AIFoto:Tara WinsteadPexels

In Breve

Perché lo stesso modello converge con un passo e diverge con un altro: gradient descent, SGD, momentum, Adam e calendari del passo su funzioni semplici.

Perché lo stesso modello converge con un passo e diverge con un altro

Addestrare un modello è risolvere \min_\theta L(\theta), e il gradiente dice solo in che direzione scendere, non di quanto. Il passo \eta (learning rate) decide se la discesa converge, oscilla all'infinito o esplode, e le varianti dell'algoritmo (SGD, momentum, Adam, calendari del passo) sono modi diversi di scegliere o correggere quel passo. In questo articolo ogni variante viene provata sulla stessa funzione semplice, così che ogni comportamento si possa spiegare con un conto a mano. Il gradiente arriva dall'articolo sul calcolo differenziale, la funzione da minimizzare, nei problemi di classificazione, è la log-verosimiglianza negativa vista nell'articolo su probabilità e statistica. Notazione: \theta sono i parametri, \eta il passo, g_t = \nabla_\theta L(\theta_t) il gradiente al passo t.

Discesa del gradiente: il passo giusto, troppo piccolo, troppo grande

La regola è \theta_{t+1} = \theta_t - \eta\,g_t. Con tutti i dati nel calcolo del gradiente si parla di batch gradient descent. Prova su f(x) = x^4 - 3x^2 + 2, che ha due minimi in x = \pm\sqrt{1{,}5} \approx \pm 1{,}2247, dove f = -0{,}25, e un massimo locale in x = 0. Il gradiente è f'(x) = 4x^3 - 6x e in x = 2 vale 32 - 12 = 20. Con \eta = 0{,}1 il primo passo porta esattamente a 2 - 0{,}1 \cdot 20 = 0, cioè sul massimo, dove il gradiente è nullo e il metodo si ferma. Con \eta = 0{,}2 il primo passo porta a -2, dove il gradiente vale -20, e il secondo di nuovo a 2: un ciclo.

import numpy as np

f = lambda x: x ** 4 - 3 * x ** 2 + 2           # due minimi in x = +-sqrt(1.5) = +-1.2247, f = -0.25
g = lambda x: 4 * x ** 3 - 6 * x

print("gradiente in x = 2:", g(2.0), " -> con lr = 0.1 il primo passo porta a", 2.0 - 0.1 * g(2.0))
for lr in (0.01, 0.05, 0.1, 0.2, 0.3):
    x = 2.0
    traj = [x]
    for _ in range(100):
        x = x - lr * g(x)
        traj.append(x)
        if abs(x) > 1e6:
            break
    tail = ", ".join(f"{v:.4g}" for v in traj[-3:])
    print(f"lr = {lr:4}: ultimi punti {tail}   f = {f(x):.4g}")

# Output:
# gradiente in x = 2: 20.0  -> con lr = 0.1 il primo passo porta a 0.0
# lr = 0.01: ultimi punti 1.225, 1.225, 1.225   f = -0.25
# lr = 0.05: ultimi punti 1.225, 1.225, 1.225   f = -0.25
# lr =  0.1: ultimi punti 0, 0, 0   f = 2
# lr =  0.2: ultimi punti 2, -2, 2   f = 6
# lr =  0.3: ultimi punti 65.6, -3.386e+05, 4.658e+16   f = 4.706e+66

Le righe del listato mostrano quattro regimi per lo stesso punto di partenza: con \eta = 0{,}01 e 0{,}05 si arriva a 1{,}225, il minimo; con 0{,}1 si resta fermi sul massimo, con 0{,}2 si rimbalza per sempre fra \pm 2, con 0{,}3 la sequenza esplode. Due lezioni. La prima è che un passo troppo grande non rende solo la convergenza instabile: può portare a un punto stazionario che non è un minimo. La seconda è che il passo massimo accettabile dipende dalla curvatura: la funzione è più ripida lontano dall'origine, e un passo che va bene vicino al minimo può essere troppo grande all'inizio. Il fatto che \eta = 0{,}01 e 0{,}05 finiscano nello stesso minimo non significa che siano equivalenti: il secondo arriva molto prima.

SGD e mini-batch: un gradiente stimato è meno costoso e rumoroso

Calcolare il gradiente su milioni di campioni a ogni passo è costoso. La discesa stocastica lo stima su un sottoinsieme B (mini-batch):

\theta_{t+1} = \theta_t - \eta\,\frac{1}{|B|}\sum_{i \in B}\nabla_\theta L(\theta_t; x_i, y_i)

La stima è non distorta, perché il suo valore atteso è il gradiente completo, ma rumorosa: la sua deviazione standard scende come 1/\sqrt{|B|}, quindi per dimezzare il rumore occorre quadruplicare il batch. Il listato lo misura su una regressione y = 3x + 1 + \text{rumore} con 10000 campioni, valutando il gradiente nel punto (w, b) = (0, 0), dove il valore vero è circa (-6, -2) (per il modello y \approx wx + b con x standardizzato, \partial L/\partial w = -2\,\mathbb{E}[xy] = -6 e \partial L/\partial b = -2\,\mathbb{E}[y] = -2).

import numpy as np

rng = np.random.default_rng(0)
N = 10_000
x = rng.normal(size=N)
y = 3 * x + 1 + rng.normal(scale=0.5, size=N)     # dati: y = 3x + 1 + rumore
w, b = 0.0, 0.0

def grad(idx):                                     # gradiente dell'errore quadratico medio su idx
    err = (w * x[idx] + b) - y[idx]
    return np.array([2 * np.mean(err * x[idx]), 2 * np.mean(err)])

full = grad(np.arange(N))
print("gradiente completo (N = 10000):", np.round(full, 3), " atteso circa (-6, -2)")
for B in (1, 4, 16, 64, 256):
    est = np.array([grad(rng.integers(0, N, size=B)) for _ in range(4000)])
    print(f"B = {B:3d}: media delle stime {np.round(est.mean(axis=0), 2)}   dev. std. di dL/dw = {est[:, 0].std():.3f}")

# Output:
# gradiente completo (N = 10000): [-5.975 -2.041]  atteso circa (-6, -2)
# B =   1: media delle stime [-5.87 -2.04]   dev. std. di dL/dw = 8.512
# B =   4: media delle stime [-6.08 -1.98]   dev. std. di dL/dw = 4.321
# B =  16: media delle stime [-5.97 -2.07]   dev. std. di dL/dw = 2.178
# B =  64: media delle stime [-5.98 -2.04]   dev. std. di dL/dw = 1.076
# B = 256: media delle stime [-5.96 -2.03]   dev. std. di dL/dw = 0.531

Le medie delle stime restano vicine a (-6, -2) per ogni B: nessuna distorsione. La deviazione standard della prima componente scende da 8{,}5 con B = 1 a 4{,}3 con B = 4, 2{,}2 con B = 16, 1{,}1 con B = 64 e 0{,}53 con B = 256: a ogni quadruplicazione del batch, dimezza, come previsto. Nella pratica si scelgono batch di decine o centinaia di campioni (Ruder indica che di solito vanno da 50 a 256, con variazioni per applicazione), un compromesso fra costo e rumore. Il rumore non è solo un difetto: dà un po' di movimento casuale che aiuta a lasciare i punti stazionari, ma un passo troppo grande lo trasforma in instabilità.

Momentum: ricordare la direzione ripetuta

Su una funzione stretta in una direzione e larga nell'altra, come una valle allungata, il gradiente oscilla sulle pareti ripide e avanza lentamente lungo il fondo. Il momentum accumula i gradienti passati in una «velocità»: v_t = \beta v_{t-1} + g_t, \theta_{t+1} = \theta_t - \eta\,v_t, con \beta tipicamente 0{,}9 (Ruder). Le componenti che cambiano segno a ogni passo si cancellano nella somma, quelle che puntano sempre nello stesso verso si sommano. Un'altra convenzione, v_t = \beta v_{t-1} + (1-\beta)g_t, differisce solo per un fattore 1 - \beta assorbito nel passo. Nesterov (NAG) calcola il gradiente nel punto già spostato dalla velocità, \nabla L(\theta_t - \eta\beta v_{t-1}), per correggere in anticipo la direzione.

Il banco di prova è f(x, y) = x^2 + 10y^2, con gradiente (2x, 20y): le curvature sono 2 e 20. Un passo della discesa moltiplica y per 1 - 20\eta e x per 1 - 2\eta. Per convergere servono |1 - 20\eta| < 1, cioè \eta < 0{,}1, e il valore ottimale per la discesa semplice, 2/(L + \mu) = 2/22 \approx 0{,}0909, dà un fattore per passo (L-\mu)/(L+\mu) = 18/22 \approx 0{,}818. Per il momentum su una funzione quadratica i valori ottimi (risultato classico della «palla pesante» di Polyak, che qui non verifico in una fonte: il listato ne misura l'effetto) sono un passo \eta = 4/(\sqrt{L}+\sqrt{\mu})^2 e \beta = \left(\frac{\sqrt{L/\mu}-1}{\sqrt{L/\mu}+1}\right)^2, con fattore per passo circa 0{,}52.

import numpy as np

f = lambda p: p[0] ** 2 + 10 * p[1] ** 2           # curvature 2 e 20: valle stretta
g = lambda p: np.array([2 * p[0], 20 * p[1]])
p0 = np.array([5.0, 5.0])

def gd(lr, steps):
    p = p0.copy()
    for _ in range(steps):
        p = p - lr * g(p)
    return f(p)

def momentum(lr, beta, steps):                      # v <- beta*v + g ;  p <- p - lr*v
    p, v = p0.copy(), np.zeros(2)
    for _ in range(steps):
        v = beta * v + g(p)
        p = p - lr * v
    return f(p)

print("coefficiente di contrazione su y per passo: |1 - 20*lr|")
for lr in (0.09, 0.099, 0.1, 0.105):
    print(f"  lr = {lr:5}: |1 - 20*lr| = {abs(1 - 20 * lr):.3f}   f dopo 100 passi = {gd(lr, 100):.3e}")
print("a lr fisso 0.09:  f dopo 10 / 50 / 100 passi =", [f"{gd(0.09, s):.2e}" for s in (10, 50, 100)])
print("momentum beta = 0.9, lr = 0.02:    f dopo 10 / 50 / 100 passi =", [f"{momentum(0.02, 0.9, s):.2e}" for s in (10, 50, 100)])
L, mu = 20.0, 2.0                                   # curvature massima e minima
lr_t = 4 / (np.sqrt(L) + np.sqrt(mu)) ** 2
beta_t = ((np.sqrt(L / mu) - 1) / (np.sqrt(L / mu) + 1)) ** 2
print(f"momentum accordato (lr = {lr_t:.4f}, beta = {beta_t:.4f}): f dopo 10 / 50 / 100 passi =", [f"{momentum(lr_t, beta_t, s):.2e}" for s in (10, 50, 100)])

# Output:
# coefficiente di contrazione su y per passo: |1 - 20*lr|
#   lr =  0.09: |1 - 20*lr| = 0.800   f dopo 100 passi = 1.552e-16
#   lr = 0.099: |1 - 20*lr| = 0.980   f dopo 100 passi = 4.397e+00
#   lr =   0.1: |1 - 20*lr| = 1.000   f dopo 100 passi = 2.500e+02
#   lr = 0.105: |1 - 20*lr| = 1.100   f dopo 100 passi = 4.748e+10
# a lr fisso 0.09:  f dopo 10 / 50 / 100 passi = ['3.35e+00', '1.11e-07', '1.55e-16']
# momentum beta = 0.9, lr = 0.02:    f dopo 10 / 50 / 100 passi = ['6.73e+01', '1.81e-01', '7.13e-03']
# momentum accordato (lr = 0.1154, beta = 0.2699): f dopo 10 / 50 / 100 passi = ['1.36e-01', '5.41e-23', '7.72e-51']

Le prime quattro righe verificano la soglia di stabilità: a \eta = 0{,}1 il coefficiente di contrazione su y vale esattamente 1 e la perdita resta a 250 (il termine 10y^2 con y = \pm 5), sopra la soglia esplode. Poi il confronto. Con \eta = 0{,}09 la discesa semplice arriva a 10^{-16} in cento passi. Il momentum con i valori «classici» \beta = 0{,}9, \eta = 0{,}02 è più lento (7 \cdot 10^{-3}), perché la velocità accumulata supera il bersaglio e deve riassorbirsi. Solo con i parametri accordati alle curvature il momentum vince, arrivando a 10^{-51}. Il guadagno è reale ma richiede di scegliere insieme \eta e \beta; su una valle poco allungata come questa (rapporto di curvature 10) il vantaggio sulla discesa ben regolata c'è, ma è ottenuto con una taratura che nei problemi veri non si conosce.

RMSprop e Adam: un passo diverso per ogni parametro

Se le curvature sono molto diverse fra parametri, un solo \eta è scomodo: deve stare sotto la soglia della direzione più ripida. RMSprop (proposto da Hinton in una lezione, non in un articolo) divide il gradiente per la radice di una media mobile dei suoi quadrati, s_t = \beta s_{t-1} + (1-\beta)g_t^2, \theta_{t+1} = \theta_t - \eta\,g_t/(\sqrt{s_t} + \epsilon): i parametri con gradienti grandi fanno passi più piccoli e viceversa. Adam (Kingma e Ba, 2015) combina questa normalizzazione con una media mobile del gradiente, che fa da momentum:

m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t \qquad v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2
\hat m_t = \frac{m_t}{1-\beta_1^t} \qquad \hat v_t = \frac{v_t}{1-\beta_2^t} \qquad \theta_{t+1} = \theta_t - \eta\,\frac{\hat m_t}{\sqrt{\hat v_t} + \epsilon}

Gli iperparametri proposti dall'articolo sono \eta = 0{,}001, \beta_1 = 0{,}9, \beta_2 = 0{,}999 e \epsilon = 10^{-8}.

La correzione del bias serve perché m e v partono da zero. Al primo passo, con gradiente g, si ha m_1 = (1-\beta_1)g = 0{,}1g e v_1 = 0{,}001g^2; senza correzione il passo vale \eta \cdot 0{,}1g / (0{,}0316|g|) \approx 3{,}16\,\eta, con correzione \hat m_1 = g, \hat v_1 = g^2 e il passo è \eta\,g/|g| = \eta: ogni parametro fa un primo passo di ampiezza \eta, qualunque sia la scala del suo gradiente.

import numpy as np

def adam_step(state, p, grad, lr=0.1, b1=0.9, b2=0.999, eps=1e-8, correct=True):
    t, m, v = state
    t += 1
    m = b1 * m + (1 - b1) * grad                    # media mobile del gradiente
    v = b2 * v + (1 - b2) * grad ** 2               # media mobile del gradiente al quadrato
    m_hat = m / (1 - b1 ** t) if correct else m     # correzione del bias dovuta all'inizio a zero
    v_hat = v / (1 - b2 ** t) if correct else v
    return (t, m, v), p - lr * m_hat / (np.sqrt(v_hat) + eps)

f = lambda p: p[0] ** 2 + 10 * p[1] ** 2
g = lambda p: np.array([2 * p[0], 20 * p[1]])
p0 = np.array([5.0, 5.0])

for correct in (True, False):
    _, p1 = adam_step((0, np.zeros(2), np.zeros(2)), p0, g(p0), correct=correct)
    print(f"gradiente {g(p0)}, correzione del bias {correct!s:5}: primo passo = {np.round(p0 - p1, 4)}")

state, pa = (0, np.zeros(2), np.zeros(2)), p0.copy()
for _ in range(100):
    state, pa = adam_step(state, pa, g(pa))
print(f"x^2 + 10 y^2, Adam (lr 0.1) dopo 100 passi: f = {f(pa):.3e}")

# scale molto diverse: f = x^2 + 1000 y^2 (curvature 2 e 2000)
f2 = lambda p: p[0] ** 2 + 1000 * p[1] ** 2
g2 = lambda p: np.array([2 * p[0], 2000 * p[1]])
pg = p0.copy()
for _ in range(200):
    pg = pg - 0.0009 * g2(pg)                       # il massimo lr stabile per il GD e' 2/2000 = 0.001
state, pa = (0, np.zeros(2), np.zeros(2)), p0.copy()
for _ in range(200):
    state, pa = adam_step(state, pa, g2(pa))
print(f"dopo 200 passi: GD (lr 0.0009) f = {f2(pg):.3e}   Adam (lr 0.1) f = {f2(pa):.3e}")

# Output:
# gradiente [ 10. 100.], correzione del bias True : primo passo = [0.1 0.1]
# gradiente [ 10. 100.], correzione del bias False: primo passo = [0.3162 0.3162]
# x^2 + 10 y^2, Adam (lr 0.1) dopo 100 passi: f = 1.673e-02
# dopo 200 passi: GD (lr 0.0009) f = 1.216e+01   Adam (lr 0.1) f = 1.201e-05

Il primo confronto del listato verifica il conto a mano: con gradiente (10, 100) i due parametri si muovono entrambi di 0{,}1 con la correzione e di 0{,}316 senza, il fattore \sqrt{10} previsto. Nel secondo, la funzione x^2 + 1000y^2 ha curvature 2 e 2000: la discesa semplice deve usare \eta < 0{,}001 per non divergere, e con 0{,}0009 dopo 200 passi x si è mosso poco (f = 12{,}2); Adam con \eta = 0{,}1, senza accordare nulla, arriva a 1{,}2 \cdot 10^{-5}. Questo è il suo vantaggio: robustezza alla scala. Non è un vantaggio universale, perché sulla funzione precedente, ben condizionata e con \eta accordato, la discesa semplice batteva Adam (a 100 passi: f \approx 0{,}017 per Adam contro 1{,}6 \cdot 10^{-16} del listato precedente), e Adam con passo fisso oscilla attorno al minimo con ampiezza dell'ordine di \eta.

Calendari del passo: warmup, decadimento a gradini e coseno

Un passo costante è un compromesso: abbastanza grande per procedere all'inizio, troppo grande per fermarsi vicino al minimo. Un calendario lo riduce nel tempo. Il decadimento a gradini moltiplica \eta per \gamma ogni s passi, \eta_t = \eta_0\gamma^{\lfloor t/s\rfloor}. Il cosine annealing segue mezzo periodo di coseno, \eta_t = \eta_{\min} + \frac{1}{2}(\eta_{\max} - \eta_{\min})(1 + \cos(\pi t/T)) (Loshchilov e Hutter, 2017, nell'articolo SGDR dove è combinato con riavvii periodici). Il warmup fa crescere linearmente il passo da zero per i primi passi: si usa quando un passo pieno fin dall'inizio destabilizza l'addestramento, per esempio perché le stime dei momenti di Adam poggiano ancora su pochi gradienti (una spiegazione frequente che qui non viene verificata). Nel Transformer originale (Vaswani e altri, 2017) il passo cresce linearmente per 4000 passi e poi decresce come l'inverso della radice del passo: non è una curva a coseno.

import numpy as np

def step_decay(t, eta0=1e-3, gamma=0.1, s=300):
    return eta0 * gamma ** (t // s)

def cosine(t, T, eta_min=1e-6, eta_max=1e-3):
    return eta_min + 0.5 * (eta_max - eta_min) * (1 + np.cos(np.pi * t / T))

def warmup_cosine(t, warm, T, eta_max=1e-3):
    if t < warm:
        return eta_max * t / warm
    return eta_max * 0.5 * (1 + np.cos(np.pi * (t - warm) / (T - warm)))

def transformer(step, d_model=512, warm=4000):      # formula (3) di Vaswani et al.
    step = max(step, 1)
    return d_model ** -0.5 * min(step ** -0.5, step * warm ** -1.5)

T = 1000
print(" t   step_decay   cosine   warmup+cosine")
for t in (0, 100, 300, 500, 600, 900, 1000):
    print(f"{t:4d}  {step_decay(t):.2e}  {cosine(t, T):.2e}  {warmup_cosine(t, 100, T):.2e}")
print("cosine a meta' percorso:", cosine(500, T), " (eta_min + eta_max)/2 =", (1e-6 + 1e-3) / 2)
print("schedule del Transformer: picco a step 4000 =", f"{transformer(4000):.3e}", " a step 16000 =", f"{transformer(16000):.3e}")

# Output:
#  t   step_decay   cosine   warmup+cosine
#    0  1.00e-03  1.00e-03  0.00e+00
#  100  1.00e-03  9.76e-04  1.00e-03
#  300  1.00e-04  7.94e-04  8.83e-04
#  500  1.00e-04  5.01e-04  5.87e-04
#  600  1.00e-05  3.46e-04  4.13e-04
#  900  1.00e-06  2.54e-05  3.02e-05
# 1000  1.00e-06  1.00e-06  0.00e+00
# cosine a meta' percorso: 0.0005005000000000001  (eta_min + eta_max)/2 = 0.0005005
# schedule del Transformer: picco a step 4000 = 6.988e-04  a step 16000 = 3.494e-04

Il listato implementa le quattro curve e ne stampa i valori. Un controllo a mano: a metà percorso il coseno vale la media dei due estremi, (10^{-6} + 10^{-3})/2 = 5{,}005 \cdot 10^{-4}, e il listato dà esattamente quel valore. Il calendario del Transformer, con d_{\text{model}} = 512, ha un picco 512^{-0{,}5} \cdot 4000^{-0{,}5} \approx 7 \cdot 10^{-4} a passo 4000 e poi scende: a 16000 vale la metà, perché \sqrt{4}=2. Il warmup seguito da un coseno è una combinazione frequente nella pratica, ma nessuna delle fonti citate qui la presenta come regola, e un calendario va scelto guardando la curva della perdita.

Punti di sella: il rumore e la curvatura negativa

Nei problemi con moltissimi parametri la difficoltà tipica non sono i minimi locali ma i punti di sella e gli altopiani che li circondano, come argomentano Dauphin e colleghi (2014), già visti nell'articolo sul calcolo differenziale. Su un punto di sella il gradiente è nullo, e la discesa si ferma se parte esattamente lì. Il caso più semplice è f(x, y) = x^2 - y^2, con gradiente (2x, -2y): la coordinata y viene moltiplicata a ogni passo per 1 + 2\eta, quindi un piccolo scostamento cresce in modo esponenziale. Con \eta = 0{,}1 il fattore è 1{,}2 e passare da 10^{-6} a 1 richiede \ln(10^6)/\ln(1{,}2) \approx 75{,}8 passi.

import numpy as np

# f(x, y) = x^2 - y^2: sella in (0,0). Gradiente (2x, -2y). Da (1, y0) la discesa del gradiente...
lr = 0.1
for y0 in (0.0, 1e-6):
    p = np.array([1.0, y0])
    steps = 0
    while abs(p[1]) < 1.0 and steps < 1000:
        p = p - lr * np.array([2 * p[0], -2 * p[1]])
        steps += 1
    print(f"y0 = {y0:g}: dopo {steps} passi |y| = {abs(p[1]):.3g}, x = {p[0]:.2e}")
print("fattore di crescita di y per passo: 1 + 2*lr =", 1 + 2 * lr, "; passi attesi per 1e-6 -> 1:", round(np.log(1e6) / np.log(1.2), 1))

# Output:
# y0 = 0: dopo 1000 passi |y| = 0, x = 1.23e-97
# y0 = 1e-06: dopo 76 passi |y| = 1.04, x = 4.31e-08
# fattore di crescita di y per passo: 1 + 2*lr = 1.2 ; passi attesi per 1e-6 -> 1: 75.8

Il listato conferma il conto: partendo da y = 10^{-6} si esce dalla sella in 76 passi, mentre da y = 0 esatto non si esce mai (dopo mille passi y è ancora zero). Nella pratica un punto di partenza esattamente simmetrico non capita e il rumore del mini-batch dà comunque un piccolo spostamento, ma il tempo per uscire cresce solo con il logaritmo della distanza iniziale dalla direzione di fuga (76 passi per sei ordini di grandezza). Dove la curvatura negativa è debole il fattore di crescita è vicino a 1 e i passi necessari diventano molti di più: è l'altopiano di cui parlano Dauphin e colleghi.

Che cosa sai fare adesso

Sai calcolare a mano la soglia di stabilità del passo per una funzione quadratica, prevedere se una scelta di \eta converge, oscilla o diverge, e capire perché Adam fa un primo passo di ampiezza \eta. Sai stimare il rumore di un mini-batch e decidere se vale la pena aumentarlo, e sai riconoscere che momentum e Adam aiutano quando le curvature sono molto diverse ma non sono sempre più veloci della discesa semplice ben tarata. Il passo successivo è chiedersi che cosa si sta minimizzando: l'articolo sulla teoria dell'informazione definisce entropia e cross-entropy, che sono la perdita più usata nella classificazione.

Fonti

Prova Questi Strumenti

Strumenti gratuiti correlati a questo argomento.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti