WebRobot

Lezione 1 · Backpropagation

Come impara una rete: l’errore torna indietro

Una rete non sa quali dei suoi pesi hanno causato un errore. La backpropagation lo calcola con un solo passaggio dall’uscita all’ingresso, moltiplicando pochi rapporti locali lungo la strada. Seguila qui, sulla rete più piccola che la mostra per intero.

Usa Avanti, oppure i tasti ← →. Ogni numero è calcolato dal vivo nel tuo browser.

Cosa portarsi a casa

Le regole di derivazione, tutte insieme

Tutta la lezione nasce da queste nove regole. Il pannello qui sopra mostra quelle che usa ogni passo.

Cos’è una derivataf′(a) ≈ [ f(a + ε) − f(a) ] / εSposta a di una quantità piccolissima ε e guarda quanto si sposta f: il rapporto è la pendenza di f in quel punto.f(a) = a², a = 3: (3.01² − 9) / 0.01 = 6.01 ≈ 6
Derivata parziale: ∂∂f/∂a = derivata tenendo fermo tutto tranne aCon più variabili se ne muove una alla volta. Il simbolo ∂ dice che le altre valgono come semplici numeri.f = a·b: ∂f/∂a = b e ∂f/∂b = a
Costante(c)′ = 0Ciò che non dipende dalla variabile non si muove quando la variabile si muove.∂(7)/∂a = 0
Costante per variabile(c·a)′ = cÈ una retta: la sua pendenza è il numero che moltiplica la variabile.(3·a)′ = 3
Somma(f + g)′ = f′ + g′Ogni termine si deriva per conto suo e i risultati si sommano. Lo stesso vale per una differenza.(3·a + 7)′ = 3 + 0 = 3
Potenza(a²)′ = 2·aL’esponente scende davanti e la potenza cala di uno.con a = 3: 2·3 = 6, come misurato nella prima regola
Regola della catena[ f(g(a)) ]′ = f′(g(a)) · g′(a)Se a agisce su f solo attraverso g, gli effetti si moltiplicano: quanto si muove g se si muove a, per quanto si muove f se si muove g.(3·a + 1)²: 2·(3·a + 1) · 3; con a = 1 dà 24
Quoziente(f / g)′ = (f′·g − f·g′) / g²La regola per derivare un rapporto tra due funzioni.( a / (a + 1) )′ = (1·(a + 1) − a·1) / (a + 1)² = 1 / (a + 1)²
sinh e coshsinh′ = cosh, cosh′ = sinhsinh z = (eᶻ − e⁻ᶻ) / 2 e cosh z = (eᶻ + e⁻ᶻ) / 2. Poiché (eᶻ)′ = eᶻ e, per la regola della catena, (e⁻ᶻ)′ = −e⁻ᶻ, l’una diventa l’altra.sinh′ z = (eᶻ + e⁻ᶻ) / 2 = cosh z

La stessa cosa in meno di 30 righe

Nessuna libreria: questo è l’intero algoritmo, con gli stessi pesi da cui sei partito qui sopra.

import math

x, y = 1.0, 1.0
w1, w2, v1, v2 = 0.6, -0.4, 0.5, -0.3
lr = 0.5

for _ in range(30):
    # forward
    h1 = math.tanh(w1 * x)
    h2 = math.tanh(w2 * x)
    y_hat = v1 * h1 + v2 * h2
    loss = 0.5 * (y_hat - y) ** 2

    # backward: the same path, in reverse
    d_yhat = y_hat - y
    d_v1, d_v2 = d_yhat * h1, d_yhat * h2
    d_h1, d_h2 = d_yhat * v1, d_yhat * v2
    d_w1 = d_h1 * (1 - h1 ** 2) * x
    d_w2 = d_h2 * (1 - h2 ** 2) * x

    # update
    w1 -= lr * d_w1
    w2 -= lr * d_w2
    v1 -= lr * d_v1
    v2 -= lr * d_v2

print(loss)

Per tenere leggibile l’aritmetica, questa rete non ha bias e vede un solo esempio. Le reti vere usano batch e tensori, ma la regola è esattamente questa.

Prossima lezione

Nella lezione 2 aggiungiamo l’attenzione a questa stessa rete: sono altri pesi e altre moltiplicazioni, e il gradiente li attraversa allo stesso modo.

← Tutto il percorso