Come impara una rete: la derivata dice in che direzione muovere ogni peso
Un modello impara cambiando i propri parametri \theta in modo da far scendere una perdita L(\theta). Per sapere quanto cambiare ciascun parametro serve il gradiente \nabla_\theta L, cioè quanto la perdita varia al variare di ognuno. La regola di aggiornamento è una sola, \theta \leftarrow \theta - \eta\,\nabla_\theta L con \eta il passo di apprendimento, e tutto il resto dell'articolo serve a calcolare quel gradiente senza sbagliare: la regola della catena per scomporlo, la backpropagation per calcolarlo in un'unica passata all'indietro e il controllo con le differenze finite per verificarlo. Chi viene dall'articolo sull'algebra lineare ritroverà gli stessi prodotti di matrici, questa volta derivati.
La derivata come pendenza, e perché si può calcolare numericamente
La derivata di f in un punto è la pendenza della tangente: di quanto cambia f per un piccolo spostamento di x.
Se è positiva la funzione sale, se è negativa scende, se è zero il punto è stazionario (minimo, massimo o sella). Prendi f(x) = x^3 in x = 3: la regola delle potenze dà f'(3) = 3 \cdot 3^2 = 27. La definizione suggerisce anche un calcolo approssimato, con h piccolo ma non nullo. Con h = 0{,}1 il rapporto incrementale in avanti vale (3{,}1^3 - 27)/0{,}1 = 27{,}91, con errore 0{,}91; il rapporto centrato, (f(x+h) - f(x-h))/(2h), vale 27{,}01, con errore 0{,}01.
import numpy as np
f = lambda x: x ** 3
x0 = 3.0 # derivata vera: 3 * 3**2 = 27
print(f"{'h':>8} {'errore in avanti':>18} {'errore centrato':>16}")
for h in [1e-1, 1e-3, 1e-5, 1e-8, 1e-11, 1e-14]:
fwd = (f(x0 + h) - f(x0)) / h
ctr = (f(x0 + h) - f(x0 - h)) / (2 * h)
print(f"{h:8.0e} {abs(fwd - 27):18.2e} {abs(ctr - 27):16.2e}")
# Output:
# h errore in avanti errore centrato
# 1e-01 9.10e-01 1.00e-02
# 1e-03 9.00e-03 1.00e-06
# 1e-05 9.00e-05 2.21e-10
# 1e-08 1.02e-07 7.53e-08
# 1e-11 8.66e-05 8.66e-05
# 1e-14 7.11e-01 7.11e-01
La tabella misura l'ordine dell'errore. In avanti l'errore dimezza insieme a h (è circa 9h, cioè proporzionale a h); centrato scende col quadrato di h (h^2: da 10^{-2} a 10^{-6} quando h passa da 10^{-1} a 10^{-3}). Ma a un certo punto smette di migliorare e peggiora: sotto h \approx 10^{-8} si sottraggono due numeri quasi uguali, e le cifre significative perse nel calcolo in virgola mobile (circa 16 per un float64) dominano l'errore. È per questo che nel controllo dei gradienti si usa un passo dell'ordine di 10^{-5} o 10^{-6} e non il più piccolo possibile.
Le derivate delle attivazioni e il gradiente che svanisce
Le funzioni di attivazione compaiono in ogni layer, quindi le loro derivate compaiono in ogni passo all'indietro. Per la ReLU f(x) = \max(0, x) la derivata è 1 per x > 0 e 0 per x < 0 (in x = 0 non esiste, e per convenzione si prende 0). Per la sigmoide \sigma(x) = 1/(1+e^{-x}) è \sigma'(x) = \sigma(x)(1 - \sigma(x)), per la tangente iperbolica \tanh'(x) = 1 - \tanh^2(x). Il listato le verifica contro le differenze finite centrate: lo scarto massimo è dell'ordine di 10^{-11}, quindi le formule sono giuste.
import numpy as np
sigmoid = lambda x: 1 / (1 + np.exp(-x))
d_sigmoid = lambda x: sigmoid(x) * (1 - sigmoid(x))
d_tanh = lambda x: 1 - np.tanh(x) ** 2
d_relu = lambda x: (x > 0).astype(float) # per x = 0 scegliamo 0
x = np.array([-2.0, -0.5, 0.0, 0.5, 2.0])
h = 1e-6
for name, f, df in [("sigmoid", sigmoid, d_sigmoid), ("tanh", np.tanh, d_tanh),
("relu", lambda t: np.maximum(0, t), d_relu)]:
num = (f(x + h) - f(x - h)) / (2 * h)
print(f"{name:8} formula = {np.round(df(x), 4)} scarto massimo dal numerico = {np.abs(df(x) - num)[x != 0].max():.1e}")
print("massimo di sigmoid'(x):", d_sigmoid(0.0))
for depth in (1, 5, 10, 20):
print(f"{depth:2d} layer sigmoid, caso migliore: fattore {0.25 ** depth:.2e}")
# Output:
# sigmoid formula = [0.105 0.235 0.25 0.235 0.105] scarto massimo dal numerico = 2.2e-11
# tanh formula = [0.0707 0.7864 1. 0.7864 0.0707] scarto massimo dal numerico = 4.0e-12
# relu formula = [0. 0. 0. 1. 1.] scarto massimo dal numerico = 2.9e-11
# massimo di sigmoid'(x): 0.25
# 1 layer sigmoid, caso migliore: fattore 2.50e-01
# 5 layer sigmoid, caso migliore: fattore 9.77e-04
# 10 layer sigmoid, caso migliore: fattore 9.54e-07
# 20 layer sigmoid, caso migliore: fattore 9.09e-13
La sigmoide ha derivata massima 0,25, in x = 0 (a mano: \sigma(0) = 0{,}5, quindi 0{,}5 \cdot 0{,}5). Per la regola della catena, il gradiente che attraversa n layer sigmoidei viene moltiplicato per un fattore al più 0{,}25^n: 0{,}25^5 \approx 10^{-3}, 0{,}25^{10} \approx 10^{-6}, e le ultime due righe del listato lo confermano. Nel caso migliore, perché con pre-attivazioni lontane da zero la derivata è molto minore. È il gradiente che svanisce: i layer vicini all'ingresso ricevono un segnale quasi nullo e imparano lentamente. La ReLU lo attenua perché per x > 0 lascia passare il gradiente invariato, ma introduce un altro problema: un neurone con ingresso sempre negativo ha derivata zero e non impara più (neurone «morto»). Nessuna attivazione è priva di costi.
Derivate parziali, gradiente e discesa del gradiente
Quando la funzione dipende da più variabili, come una perdita che dipende da tutti i pesi, si calcola una derivata parziale per variabile, tenendo ferme le altre. Il vettore di tutte le derivate parziali è il gradiente:
Punta nella direzione di massima crescita di f, quindi per far scendere la perdita ci si muove nel verso opposto. Prendi f_1(x, y) = x^2 + xy + y^2, con gradiente (2x + y,\ x + 2y). In (3, 2) vale f_1 = 9 + 6 + 4 = 19 e il gradiente è (8, 7). Con \eta = 0{,}1 un passo porta in (3 - 0{,}8,\ 2 - 0{,}7) = (2{,}2;\ 1{,}3), dove f_1 = 4{,}84 + 2{,}86 + 1{,}69 = 9{,}39: la funzione è più che dimezzata.
Ora la stessa cosa con una funzione in apparenza simile, f_2(x, y) = x^2 + 3xy + y^2. Il listato confronta le due. La differenza sta nella matrice delle derivate seconde, l'Hessiana, che per f_1 vale \begin{pmatrix} 2 & 1 \\ 1 & 2 \end{pmatrix} e per f_2 vale \begin{pmatrix} 2 & 3 \\ 3 & 2 \end{pmatrix}.
import numpy as np
def descend(grad, start, lr, steps):
p = np.array(start, dtype=float)
for _ in range(steps):
p = p - lr * grad(p)
return p
# f1 = x^2 + x*y + y^2 (Hessiana [[2,1],[1,2]]) f2 = x^2 + 3*x*y + y^2 (Hessiana [[2,3],[3,2]])
f1 = lambda p: p[0] ** 2 + p[0] * p[1] + p[1] ** 2
g1 = lambda p: np.array([2 * p[0] + p[1], p[0] + 2 * p[1]])
f2 = lambda p: p[0] ** 2 + 3 * p[0] * p[1] + p[1] ** 2
g2 = lambda p: np.array([2 * p[0] + 3 * p[1], 3 * p[0] + 2 * p[1]])
p0 = [3.0, 2.0]
print("f1(3,2) =", f1(p0), " gradiente =", g1(np.array(p0)))
p1 = descend(g1, p0, 0.1, 1)
print("dopo 1 passo:", np.round(p1, 4), " f1 =", round(f1(p1), 4))
p = descend(g1, p0, 0.1, 100)
print("dopo 100 passi:", np.round(p, 6), " f1 =", f"{f1(p):.2e}")
print("autovalori Hessiana f1:", np.linalg.eigvalsh([[2, 1], [1, 2]]))
print("autovalori Hessiana f2:", np.linalg.eigvalsh([[2, 3], [3, 2]]))
p = descend(g2, p0, 0.1, 30)
print("f2 dopo 30 passi:", np.round(p, 2), " f2 =", round(f2(p), 1))
print("f2 lungo (1, -1) a distanza t = 5:", f2(np.array([5.0, -5.0])))
# Output:
# f1(3,2) = 19.0 gradiente = [8. 7.]
# dopo 1 passo: [2.2 1.3] f1 = 9.39
# dopo 100 passi: [ 1.3e-05 -1.3e-05] f1 = 1.76e-10
# autovalori Hessiana f1: [1. 3.]
# autovalori Hessiana f2: [-1. 5.]
# f2 dopo 30 passi: [ 8.72 -8.72] f2 = -76.1
# f2 lungo (1, -1) a distanza t = 5: -25.0
Il primo passo riproduce il conto a mano, e in cento passi f_1 arriva a 10^{-10} vicino al minimo in (0, 0). La seconda funzione non ha minimo. Gli autovalori della sua Hessiana sono 2 \pm 3 = 5 e -1: positivo in una direzione, negativo nell'altra, il segno di un punto di sella. Lungo (1, -1) vale f_2(t, -t) = t^2 - 3t^2 + t^2 = -t^2, che scende senza limite, e la discesa del gradiente lo segue: dopo 30 passi f_2 = -76{,}1 e continua. La regola pratica è che il segno degli autovalori dell'Hessiana classifica un punto critico: tutti positivi, minimo; tutti negativi, massimo; misti, sella. In reti profonde i punti di sella sono molto frequenti: Dauphin e colleghi (2014) sostengono che, in spazi di grande dimensione, la difficoltà principale è la proliferazione dei punti di sella e non dei minimi locali, e che attorno ad essi ci sono altopiani che rallentano l'apprendimento.
La regola della catena su un neurone, con i numeri
Se y = f(g(x)) allora \dfrac{dy}{dx} = f'(g(x))\,g'(x): la sensibilità di una composizione è il prodotto delle sensibilità dei suoi pezzi. Una rete è una composizione di molti pezzi, e la perdita dipende da ogni peso attraverso una catena. Per un neurone con z = wx + b, \hat{y} = \sigma(z) e L = (y - \hat{y})^2 la catena ha tre anelli:
con \partial L/\partial b uguale ma con 1 al posto di x. Numeri: x = 2, y = 1, w = 0{,}5, b = 0{,}1. Allora z = 1{,}1, \hat{y} = \sigma(1{,}1) \approx 0{,}7503 e L \approx 0{,}0624. I tre anelli valgono 2(0{,}7503 - 1) \approx -0{,}4995, \sigma'(z) = 0{,}7503 \cdot 0{,}2497 \approx 0{,}1874 e x = 2, quindi \partial L/\partial w \approx -0{,}1872 e \partial L/\partial b \approx -0{,}0936. Il segno negativo dice che aumentare w e b abbassa la perdita.
import numpy as np
sigmoid = lambda t: 1 / (1 + np.exp(-t))
x, y, w, b = 2.0, 1.0, 0.5, 0.1
def loss(w, b):
return (y - sigmoid(w * x + b)) ** 2
z = w * x + b
y_hat = sigmoid(z)
dL_dyhat = 2 * (y_hat - y) # derivata dell'errore quadratico
dyhat_dz = y_hat * (1 - y_hat) # derivata della sigmoide
dz_dw, dz_db = x, 1.0
dL_dw = dL_dyhat * dyhat_dz * dz_dw
dL_db = dL_dyhat * dyhat_dz * dz_db
print(f"z = {z:.4f} y_hat = {y_hat:.4f} loss = {loss(w, b):.5f}")
print(f"dL/dy_hat = {dL_dyhat:.4f} dy_hat/dz = {dyhat_dz:.5f} dL/dw = {dL_dw:.5f} dL/db = {dL_db:.5f}")
e = 1e-6
print(f"differenze finite: dL/dw = {(loss(w + e, b) - loss(w - e, b)) / (2 * e):.5f} dL/db = {(loss(w, b + e) - loss(w, b - e)) / (2 * e):.5f}")
lr = 0.5
for epoch in range(2001):
y_hat = sigmoid(w * x + b)
g = 2 * (y_hat - y) * y_hat * (1 - y_hat)
w, b = w - lr * g * x, b - lr * g
if epoch in (0, 10, 100, 500, 2000):
print(f"epoca {epoch:4d}: loss = {loss(w, b):.5f} w = {w:.3f} b = {b:.3f}")
# Output:
# z = 1.1000 y_hat = 0.7503 loss = 0.06237
# dL/dy_hat = -0.4995 dy_hat/dz = 0.18737 dL/dw = -0.18717 dL/db = -0.09359
# differenze finite: dL/dw = -0.18717 dL/db = -0.09359
# epoca 0: loss = 0.04347 w = 0.594 b = 0.147
# epoca 10: loss = 0.00969 w = 0.946 b = 0.323
# epoca 100: loss = 0.00108 w = 1.413 b = 0.556
# epoca 500: loss = 0.00021 w = 1.748 b = 0.724
# epoca 2000: loss = 0.00005 w = 2.033 b = 0.866
Il blocco calcola i tre anelli separatamente (dL_dyhat, dyhat_dz, dz_dw), li moltiplica e confronta il risultato con le differenze finite: le due righe coincidono con il conto a mano. Il ciclo che segue applica la discesa del gradiente, e le righe di epoca stampano la perdita dopo l'aggiornamento. Si nota che la perdita scende veloce all'inizio e poi sempre più piano: man mano che \hat{y} si avvicina a 1 la sigmoide si satura, \sigma'(z) tende a zero e il gradiente di questa perdita si spegne proprio quando servirebbe ancora. Combinare sigmoide ed errore quadratico è una scelta che rallenta l'apprendimento; l'articolo sulle funzioni di perdita mostra come la cross-entropy elimini il fattore \sigma'.
Il grafo computazionale: perché la passata all'indietro costa poco
Calcolare il gradiente scrivendo la formula completa di una rete a mano è impraticabile: il testo di Deisenroth e colleghi nota che l'espressione esplicita può diventare lunghissima e più costosa da valutare della funzione stessa. Un grafo computazionale scompone la funzione in operazioni elementari; nel passo in avanti ogni nodo calcola il proprio valore, e nel passo all'indietro ogni nodo riceve il gradiente della perdita rispetto alla propria uscita, lo moltiplica per la propria derivata locale e lo passa ai nodi da cui dipende. Ciascun nodo viene visitato una volta per direzione, quindi il costo del gradiente è dello stesso ordine di quello del calcolo della perdita, qualunque sia il numero di parametri. È la backpropagation (Rumelhart, Hinton e Williams, 1986) ed è ciò che PyTorch e TensorFlow automatizzano con la differenziazione automatica.
Per un layer vettoriale compaiono due matrici nuove. Il Jacobiano di \mathbf{f}: \mathbb{R}^n \to \mathbb{R}^m è la matrice m \times n con elemento J_{ij} = \partial f_i / \partial x_j: generalizza il gradiente a funzioni con più uscite, ed è il «coefficiente locale» del passo all'indietro. L'Hessiana, già incontrata, raccoglie le derivate seconde. Nel codice che segue il Jacobiano non viene mai costruito: ci si limita a moltiplicare il gradiente a valle per la sua trasposta, e per questo le formule contengono trasposte di matrici di pesi.
Backpropagation su una rete a due layer, con il controllo dei gradienti
Mettiamo tutto insieme su XOR, il problema classico che nessun modello lineare risolve: due ingressi, uscita 1 solo se sono diversi. La rete ha 2 ingressi, 4 neuroni nascosti sigmoidei e un'uscita sigmoidea, cioè 17 parametri. Con la perdita L = \frac{1}{N}\sum (a_2 - y)^2 la passata all'indietro, in forma matriciale, segue quattro passi, nell'ordine in cui il gradiente fluisce:
- \delta_2 = \dfrac{2}{N}(a_2 - y) \odot a_2(1 - a_2): l'errore dell'uscita moltiplicato per la derivata della sigmoide, elemento per elemento
- \nabla_{\mathbf{W}_2} = a_1^T \delta_2 e \nabla_{\mathbf{b}_2} = \sum \delta_2: i gradienti dello strato di uscita
- \delta_1 = (\delta_2 \mathbf{W}_2^T) \odot a_1(1 - a_1): l'errore riportato indietro attraverso i pesi, poi moltiplicato per la derivata del primo strato
- \nabla_{\mathbf{W}_1} = \mathbf{X}^T \delta_1 e \nabla_{\mathbf{b}_1} = \sum \delta_1: i gradienti dello strato nascosto
L'ordine non è modificabile, perché \delta_1 si calcola da \delta_2 attraverso \mathbf{W}_2^T: è la regola della catena in forma matriciale, e la trasposta compare perché l'errore viaggia dalle uscite verso gli ingressi. Il prodotto \odot è elemento per elemento, come il * di NumPy, mentre \delta_2 \mathbf{W}_2^T è un vero prodotto di matrici.
import numpy as np
sigmoid = lambda t: 1 / (1 + np.exp(-t))
X = np.array([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
y = np.array([[0.0], [1.0], [1.0], [0.0]]) # XOR
rng = np.random.default_rng(1)
params = {"W1": rng.normal(0, 1, (2, 4)), "b1": np.zeros((1, 4)),
"W2": rng.normal(0, 1, (4, 1)), "b2": np.zeros((1, 1))}
def forward(p):
a1 = sigmoid(X @ p["W1"] + p["b1"])
a2 = sigmoid(a1 @ p["W2"] + p["b2"])
return a1, a2
def loss(p):
return np.mean((forward(p)[1] - y) ** 2)
def gradients(p):
a1, a2 = forward(p)
dz2 = 2 * (a2 - y) / len(X) * a2 * (1 - a2) # (4,1)
dz1 = (dz2 @ p["W2"].T) * a1 * (1 - a1) # (4,4)
return {"W2": a1.T @ dz2, "b2": dz2.sum(0, keepdims=True),
"W1": X.T @ dz1, "b1": dz1.sum(0, keepdims=True)}
# 1) controllo: backpropagation contro differenze finite centrate, su ogni parametro
g = gradients(params)
eps, worst = 1e-6, 0.0
for name, arr in params.items():
for idx in np.ndindex(arr.shape):
old = arr[idx]
arr[idx] = old + eps; lp = loss(params)
arr[idx] = old - eps; lm = loss(params)
arr[idx] = old
num = (lp - lm) / (2 * eps)
rel = abs(g[name][idx] - num) / max(abs(g[name][idx]) + abs(num), 1e-12)
worst = max(worst, rel)
print(f"parametri controllati: {sum(a.size for a in params.values())}, errore relativo massimo: {worst:.1e}")
# 2) addestramento
lr = 2.0
for epoch in range(20001):
g = gradients(params)
for k in params:
params[k] = params[k] - lr * g[k]
if epoch in (0, 1000, 5000, 20000):
print(f"epoca {epoch:5d}: loss = {loss(params):.5f}")
print("previsioni:", np.round(forward(params)[1].ravel(), 3), " target:", y.ravel())
# Output:
# parametri controllati: 17, errore relativo massimo: 1.8e-08
# epoca 0: loss = 0.25626
# epoca 1000: loss = 0.00231
# epoca 5000: loss = 0.00025
# epoca 20000: loss = 0.00005
# previsioni: [0.005 0.992 0.994 0.009] target: [0. 1. 1. 0.]
Il blocco fa due cose, in questo ordine. Prima verifica la backpropagation: per ognuno dei 17 parametri calcola la derivata con differenze finite centrate (\varepsilon = 10^{-6}) e la confronta con quella analitica, con errore relativo |g_a - g_n| / (|g_a| + |g_n|). Il massimo trovato è 1{,}8 \cdot 10^{-8}. Non esiste una soglia universale: conta l'ordine di grandezza, e 10^{-8} è lontanissimo dai valori che produce un gradiente sbagliato, quindi i gradienti sono giusti. Provando due implementazioni sbagliate sulla stessa rete, il fattore 2 dimenticato in \delta_2 dà un errore relativo massimo di 0{,}33, e i pesi \mathbf{W}_2 ignorati nel calcolo di \delta_1 danno 0{,}94. Poi addestra: la perdita scende da 0{,}256 a 5 \cdot 10^{-5} e le previsioni sono quasi (0, 1, 1, 0).
Tre avvertenze. Il controllo con differenze finite costa due valutazioni della perdita per parametro: va fatto una volta, su una rete piccola, non durante l'addestramento. Il seme fissa i pesi iniziali: provando i semi da 0 a 7 con lo stesso codice, la perdita dopo 20000 epoche sta fra 4 \cdot 10^{-5} e 7 \cdot 10^{-5}, quindi qui l'addestramento non è fragile, ma i valori a una data epoca cambiano da un seme all'altro. Infine, la perdita quadratica più il passo \eta = 2 sono scelte che funzionano su questo problema giocattolo, non una ricetta: l'articolo sull'ottimizzazione spiega come si sceglie il passo.
Che cosa sai fare adesso
Sai calcolare a mano la derivata di una perdita rispetto ai pesi di un neurone moltiplicando tre fattori, scrivere in forma matriciale la passata all'indietro di una rete a due layer e verificarla con le differenze finite prima di fidarti dell'addestramento. Sai anche leggere i sintomi: un gradiente che svanisce attraverso una pila di sigmoidi, una discesa che non converge perché il punto è di sella e non un minimo, un controllo dei gradienti che sballa di ordini di grandezza. Per capire come la direzione del gradiente viene poi trasformata in un passo, il passo successivo è quello sulla probabilità, che dà alla perdita il suo significato statistico.
Come ho verificato i listati: li ho eseguiti il 2026-11-21, ciascuno da solo, con Python 3.14.4, NumPy 2.3.5, e le cifre decimali riportate nel testo coincidono con quelle prodotte. Con versioni diverse delle librerie le ultime cifre possono cambiare.
Fonti
- Deisenroth, Faisal, Ong, Mathematics for Machine Learning (2020), capitolo 5 Vector Calculus - gradienti, regola della catena e §5.6 su backpropagation e differenziazione automatica; PDF letto, consultata il 2026-11-12
- Rumelhart, Hinton, Williams, Learning representations by back-propagating errors, Nature 323, 1986 - l'articolo originale della backpropagation, pagina raggiunta, consultata il 2026-11-12
- Dauphin e altri, Identifying and attacking the saddle point problem in high-dimensional non-convex optimization, arXiv 2014 - l'affermazione sulla proliferazione dei punti di sella in alta dimensione; abstract letto, consultata il 2026-11-12
- Goodfellow, Bengio, Courville, Deep Learning, capitoli 4 e 6 - riferimento per Hessiana, discesa del gradiente e backpropagation, pagina raggiunta, consultata il 2026-11-12

Commenti
Caricamento commenti...
Accedi per commentare