La perdita decide che cosa significa «sbagliare»
Il modello non sa che cosa vuoi: sa solo ridurre il numero che gli dai. Se la perdita tratta allo stesso modo un errore di un euro e uno di mille, il modello non distingue un arrotondamento da un disastro; se pesa quanto un caso raro e quanto uno comune, nei dati sbilanciati vince il comune. Per questo la scelta della perdita non è un dettaglio dell'implementazione: definisce il problema che il modello sta risolvendo davvero. L'articolo percorre le perdite che servono più spesso, ognuna con la formula, un conto svolto a mano e una verifica in NumPy, e termina con il modo di scriverne una propria senza sbagliare il gradiente.
Notazione: y è il valore o la classe vera, \hat y la predizione, z il logit (il numero prima della sigmoide o della softmax), n il numero di campioni. Il collegamento con quanto visto prima è stretto: la cross-entropy è la perdita derivata nell'articolo sulla teoria dell'informazione, la sua relazione con la massima verosimiglianza è nell'articolo su probabilità e statistica, e i gradienti sono quelli del calcolo differenziale.
Regressione: MSE, MAE e Huber
L'errore quadratico medio L_{\text{MSE}} = \frac{1}{n}\sum_i (y_i - \hat y_i)^2 penalizza in modo quadratico, e la sua derivata rispetto alla predizione, \frac{2}{n}(\hat y_i - y_i), è proporzionale all'errore: più sbagli, più il gradiente spinge. L'errore assoluto medio L_{\text{MAE}} = \frac{1}{n}\sum_i |y_i - \hat y_i| ha gradiente di modulo costante (non rallenta avvicinandosi al minimo) e non è derivabile in zero. La perdita di Huber con soglia \delta è quadratica per errori piccoli e lineare per errori grandi: \frac{1}{2}e^2 se |e| \leq \delta, altrimenti \delta|e| - \frac{1}{2}\delta^2. I due rami si raccordano in |e| = \delta con lo stesso valore e la stessa pendenza.
Conto a mano su cinque punti con errori 0{,}1; 0{,}2; 0{,}2; 0{,}1; 0{,}1: MSE = (0{,}01 + 0{,}04 + 0{,}04 + 0{,}01 + 0{,}01)/5 = 0{,}022, MAE = 0{,}7/5 = 0{,}14, Huber con \delta = 1 uguale a metà dell'MSE, 0{,}011, perché tutti gli errori stanno nel ramo quadratico. Aggiungendo un sesto punto con errore 14: MSE = (0{,}11 + 196)/6 \approx 32{,}685, MAE = (0{,}7 + 14)/6 = 2{,}45, Huber = (0{,}055 + 13{,}5)/6 \approx 2{,}259, dove 13{,}5 = 1 \cdot 14 - \tfrac{1}{2}.
import numpy as np
mse = lambda y, p: np.mean((y - p) ** 2)
mae = lambda y, p: np.mean(np.abs(y - p))
def huber(y, p, delta=1.0):
e = np.abs(y - p)
return np.mean(np.where(e <= delta, 0.5 * e ** 2, delta * e - 0.5 * delta ** 2))
y = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
p = np.array([1.1, 2.2, 2.8, 4.1, 4.9]) # errori 0.1, 0.2, 0.2, 0.1, 0.1
print(f"senza outlier: MSE {mse(y, p):.4f} MAE {mae(y, p):.4f} Huber {huber(y, p):.4f}")
y2, p2 = np.append(y, 6.0), np.append(p, 20.0) # un errore di 14
print(f"con outlier: MSE {mse(y2, p2):.4f} MAE {mae(y2, p2):.4f} Huber {huber(y2, p2):.4f}")
# quale costante minimizza ciascuna perdita? (dati con un valore anomalo)
d = np.array([1.0, 2.0, 3.0, 4.0, 100.0])
cs = np.linspace(0, 110, 1101)
best_mse = cs[np.argmin([mse(d, c) for c in cs])]
best_mae = cs[np.argmin([mae(d, c) for c in cs])]
print(f"minimo MSE in c = {best_mse:.1f} (media = {d.mean()}); minimo MAE in c = {best_mae:.1f} (mediana = {np.median(d)})")
# Output:
# senza outlier: MSE 0.0220 MAE 0.1400 Huber 0.0110
# con outlier: MSE 32.6850 MAE 2.4500 Huber 2.2592
# minimo MSE in c = 22.0 (media = 22.0); minimo MAE in c = 3.0 (mediana = 3.0)
Il listato conferma i tre conti. Un solo errore grande fa salire l'MSE di tre ordini di grandezza (da 0{,}022 a 32{,}7) e lascia l'MAE e Huber di un ordine solo: l'MSE è dominata dagli outlier. L'ultima parte mostra il significato statistico della scelta: fra tutti i valori costanti c che si possono predire per cinque dati con un valore anomalo (1, 2, 3, 4, 100), l'MSE è minima nella media, 22, l'MAE nella mediana, 3. Con MSE il modello stima quanto vale in media la risposta; con MAE, quanto vale tipicamente. Se gli outlier sono errori di misura, la mediana è più giusta; se sono casi veri e costosi, la media è quello che interessa. L'MSE è la log-verosimiglianza negativa di un modello con rumore gaussiano, come mostrano Deisenroth e colleghi nel capitolo 9 per la regressione lineare.
Classificazione: cross-entropy binaria e multiclasse
Con una sigmoide \hat y = \sigma(z), la cross-entropy binaria è L = -[y\ln\hat y + (1-y)\ln(1-\hat y)]. Il suo gradiente rispetto al logit si semplifica in \partial L/\partial z = \hat y - y: la sigmoide e il logaritmo si cancellano, e il segnale non si spegne quando il modello è sicuro e sbagliato. È la differenza con l'errore quadratico su una sigmoide, il cui gradiente porta il fattore \sigma'(z) che si annulla a saturazione, come nell'articolo sul calcolo differenziale. Il caso multiclasse con softmax è identico: con un'etichetta one-hot, L = -\ln\hat y_c e il gradiente rispetto ai logit è \hat{\mathbf y} - \mathbf y, come si vede nell'articolo sulla teoria dell'informazione. A mano, con z = 0{,}8 e y = 1: \hat y = \sigma(0{,}8) \approx 0{,}69, L = -\ln 0{,}69 \approx 0{,}371 e gradiente 0{,}69 - 1 = -0{,}31.
import numpy as np
sigmoid = lambda z: 1 / (1 + np.exp(-z))
def bce_logit(z, y): # stabile: max(z,0) - z*y + log(1 + exp(-|z|))
return np.maximum(z, 0) - z * y + np.log1p(np.exp(-np.abs(z)))
z, y = 0.8, 1.0
q = sigmoid(z)
print(f"y_hat = {q:.4f} perdita = {-np.log(q):.4f} (stabile: {bce_logit(z, y):.4f})")
e = 1e-6
print(f"dL/dz numerico = {(bce_logit(z + e, y) - bce_logit(z - e, y)) / (2 * e):.5f} y_hat - y = {q - y:.5f}")
zz = 40.0 # un logit grande, y = 0: previsione sbagliata e sicura
with np.errstate(divide="ignore"):
naive = -(0 * np.log(sigmoid(zz)) + 1 * np.log(1 - sigmoid(zz)))
print(f"y = 0, z = 40: forma ingenua = {naive} forma stabile = {bce_logit(zz, 0.0):.1f} (z - 0 = {zz})")
# Output:
# y_hat = 0.6900 perdita = 0.3711 (stabile: 0.3711)
# dL/dz numerico = -0.31003 y_hat - y = -0.31003
# y = 0, z = 40: forma ingenua = inf forma stabile = 40.0 (z - 0 = 40.0)
Il listato verifica due cose. Il gradiente calcolato con differenze finite coincide con \hat y - y alla quinta cifra. E mostra un problema che i tutorial spesso nascondono: con un logit di 40 e y = 0 (una previsione sicura e sbagliata) la forma ingenua -log(1 - sigmoid(z)) dà inf, perché \sigma(40) in virgola mobile vale esattamente 1. La forma stabile, \max(z, 0) - zy + \ln(1 + e^{-|z|}), non passa mai dalla sigmoide e restituisce 40, il valore corretto (la perdita cresce linearmente con il logit, non esplode). Per questo le librerie offrono una versione della perdita che prende i logit, e non le probabilità, come argomento.
Dati sbilanciati: focal loss
In un problema con pochissimi positivi e moltissimi negativi facili, la somma delle perdite è dominata dai negativi: ciascuno contribuisce poco, ma sono tanti. La focal loss (Lin e altri, 2017) moltiplica la cross-entropy per (1 - p_t)^\gamma, dove p_t è la probabilità assegnata alla classe vera: L_{\text{FL}} = -(1 - p_t)^\gamma\ln p_t. Per \gamma = 2 un esempio con p_t = 0{,}9 viene pesato 0{,}1^2 = 0{,}01 (cento volte meno), uno con p_t = 0{,}5 viene pesato 0{,}25, uno con p_t = 0{,}1 viene pesato 0{,}81. Con \gamma = 0 si ritrova la cross-entropy. Nell'articolo originale, sul riconoscimento di oggetti, \gamma = 2 funziona meglio nei loro esperimenti, e il fattore di bilanciamento \alpha ottimale era 0{,}25 con \gamma = 2: valori specifici di quel problema, non universali.
import numpy as np
gamma = 2.0
for pt in (0.9, 0.5, 0.1):
w = (1 - pt) ** gamma
print(f"p_t = {pt}: CE = {-np.log(pt):.4f} fattore (1-p_t)^2 = {w:.2f} focal = {w * -np.log(pt):.4f}")
# 1000 negativi facili (p_t = 0.95) e 10 positivi difficili (p_t = 0.1)
pt = np.concatenate([np.full(1000, 0.95), np.full(10, 0.1)])
ce = -np.log(pt)
fl = (1 - pt) ** gamma * ce
for name, l in (("cross-entropy", ce), ("focal gamma=2", fl)):
print(f"{name:14s} totale = {l.sum():7.3f} quota dei 1000 facili = {l[:1000].sum() / l.sum():.1%} quota dei 10 difficili = {l[1000:].sum() / l.sum():.1%}")
# controllo: con gamma = 0 la focal loss coincide con la cross-entropy
print("gamma = 0 -> identica alla CE:", np.allclose((1 - pt) ** 0 * ce, ce))
# Output:
# p_t = 0.9: CE = 0.1054 fattore (1-p_t)^2 = 0.01 focal = 0.0011
# p_t = 0.5: CE = 0.6931 fattore (1-p_t)^2 = 0.25 focal = 0.1733
# p_t = 0.1: CE = 2.3026 fattore (1-p_t)^2 = 0.81 focal = 1.8651
# cross-entropy totale = 74.319 quota dei 1000 facili = 69.0% quota dei 10 difficili = 31.0%
# focal gamma=2 totale = 18.779 quota dei 1000 facili = 0.7% quota dei 10 difficili = 99.3%
# gamma = 0 -> identica alla CE: True
Il listato simula il caso tipico, con 1000 negativi facili (p_t = 0{,}95) e 10 positivi difficili (p_t = 0{,}1). Con la cross-entropy, i mille facili pesano il 69{,}0\% della perdita totale e i dieci difficili il 31{,}0\%: il gradiente è guidato dai casi che il modello già sa risolvere. Con la focal loss i facili scendono allo 0{,}7\% e i difficili salgono al 99{,}3\%. La conseguenza pratica è che la perdita non è più la log-verosimiglianza negativa dei dati; in alternativa, per correggere lo sbilanciamento esistono i pesi per classe nella cross-entropy, che non cambiano la forma della perdita, e la scelta fra le due strade va fatta con una metrica sul problema (precision, recall) e non con la perdita stessa.
Perdite a margine e per gli embedding: hinge, contrastive e triplet
Alcune perdite non misurano la probabilità ma una distanza o un margine. La hinge loss delle SVM, \max(0, 1 - yf(x)) con y \in \{-1, +1\}, vale zero quando il punto è classificato correttamente con margine almeno 1: per y = +1 e punteggio 1{,}5 la perdita è 0, per 0{,}3 è 0{,}7, per -0{,}5 è 1{,}5. La contrastive loss lavora su coppie di embedding con distanza d: per coppie simili vale \frac{1}{2}d^2 (le avvicina), per coppie diverse \frac{1}{2}\max(0, m - d)^2 (le allontana fino al margine m). La triplet loss usa triplette (ancora, positivo, negativo): \max(0, \|f(a) - f(p)\|^2 - \|f(a) - f(n)\|^2 + m) chiede che il positivo sia più vicino dell'ancora del negativo di almeno m in distanza quadratica.
import numpy as np
hinge = lambda y, f: np.maximum(0, 1 - y * f)
print("hinge, y = +1:", {f: float(hinge(1, f)) for f in (1.5, 0.3, -0.5)})
def contrastive(d, similar, m=1.0): # similar: 1 se la coppia e' simile
return 0.5 * d ** 2 if similar else 0.5 * np.maximum(0, m - d) ** 2
print("contrastive, coppia simile d = 0.4:", contrastive(0.4, True))
print("contrastive, coppia diversa d = 0.4 / d = 1.2 (m = 1):", contrastive(0.4, False), contrastive(1.2, False))
def triplet(a, p, n, m=1.0):
return max(0.0, np.sum((a - p) ** 2) - np.sum((a - n) ** 2) + m)
a, p = np.array([0.0, 0.0]), np.array([1.0, 0.0])
print("triplet, negativo lontano (0, 2):", triplet(a, p, np.array([0.0, 2.0])))
print("triplet, negativo vicino (0, 1):", triplet(a, p, np.array([0.0, 1.0])))
# Output:
# hinge, y = +1: {1.5: 0.0, 0.3: 0.7, -0.5: 1.5}
# contrastive, coppia simile d = 0.4: 0.08000000000000002
# contrastive, coppia diversa d = 0.4 / d = 1.2 (m = 1): 0.18 0.0
# triplet, negativo lontano (0, 2): 0.0
# triplet, negativo vicino (0, 1): 1.0
I valori del listato si controllano a mano. Contrastive con margine 1 e d = 0{,}4: coppia simile \frac{1}{2}\cdot 0{,}16 = 0{,}08; coppia diversa \frac{1}{2}(1 - 0{,}4)^2 = 0{,}18; con d = 1{,}2 la coppia diversa è già oltre il margine e costa zero. Triplet con ancora (0,0), positivo (1,0) e negativo (0,2): 1 - 4 + 1 = -2, quindi perdita 0 (la tripletta è già soddisfatta); con negativo (0,1): 1 - 1 + 1 = 1. Il fatto che molte triplette contribuiscano zero è il motivo per cui nei sistemi reali conta la scelta delle triplette difficili da cui imparare.
Temperatura: cambiare la fiducia senza cambiare la risposta
Dividere i logit per una temperatura T > 0 prima della softmax, \text{softmax}(z_k/T), non cambia quale classe ha la probabilità massima, ma ne cambia la fiducia: T > 1 appiattisce la distribuzione, T < 1 la rende più netta. Per z = (2, 1, 0{,}1) la classe 0 ottiene 0{,}864 con T = 0{,}5, 0{,}659 con T = 1, 0{,}502 con T = 2. Guo e colleghi (2017) mostrano che le reti profonde moderne sono spesso mal calibrate, cioè troppo sicure, e che il temperature scaling, una variante a un solo parametro della scalatura di Platt, è sorprendentemente efficace per correggerlo. Il parametro T si cerca su un insieme di validazione minimizzando la log-verosimiglianza negativa, e non cambia l'accuratezza.
import numpy as np
softmax = lambda z, T=1.0: np.exp(z / T) / np.exp(z / T).sum()
z = np.array([2.0, 1.0, 0.1])
for T in (0.5, 1.0, 2.0):
print(f"T = {T}: {np.round(softmax(z, T), 4)} classe prevista {softmax(z, T).argmax()}")
# calibrazione: dati sintetici con un classificatore troppo sicuro di se'
rng = np.random.default_rng(0)
n, K = 5000, 3
y = rng.integers(0, K, n)
signal = np.eye(K)[y] * 1.5 + rng.normal(0, 1.0, (n, K)) # indizio debole sulla classe vera
logits = 4.0 * signal # logit gonfiati: troppo sicuro
def probs(T):
s = logits / T
e = np.exp(s - s.max(axis=1, keepdims=True))
return e / e.sum(axis=1, keepdims=True)
nll = lambda T: -np.mean(np.log(probs(T)[np.arange(n), y]))
conf = lambda T: probs(T).max(axis=1).mean()
acc = np.mean(logits.argmax(1) == y)
Ts = np.linspace(0.5, 10, 951)
T_best = Ts[np.argmin([nll(T) for T in Ts])]
print(f"accuratezza = {acc:.3f} (non dipende da T)")
print(f"T = 1.00: NLL = {nll(1.0):.3f} confidenza media = {conf(1.0):.3f}")
print(f"T = {T_best:.2f}: NLL = {nll(T_best):.3f} confidenza media = {conf(T_best):.3f}")
# Output:
# T = 0.5: [0.8638 0.1169 0.0193] classe prevista 0
# T = 1.0: [0.659 0.2424 0.0986] classe prevista 0
# T = 2.0: [0.5017 0.3043 0.194 ] classe prevista 0
# accuratezza = 0.766 (non dipende da T)
# T = 1.00: NLL = 0.834 confidenza media = 0.906
# T = 2.64: NLL = 0.571 confidenza media = 0.763
La seconda parte del listato è sintetica: genera un classificatore a tre classi con logit gonfiati, che indovina la classe nel 76,6% dei casi ma dichiara una confidenza media del 90,6%. La ricerca di T che minimizza la log-verosimiglianza negativa trova T \approx 2{,}64, per cui la perdita scende da 0{,}834 a 0{,}571 e la confidenza media da 0{,}906 a 0{,}763, quasi uguale all'accuratezza. Il risultato dipende dal modo in cui sono stati costruiti i dati, non è una misura di una rete reale; mostra però il meccanismo: la calibrazione è un problema di scala dei logit, non di classificazione, e va fatta su dati non usati per l'addestramento.
Scrivere una perdita propria, e verificarne il gradiente
Quando le perdite standard non rappresentano il costo reale, per esempio perché sottostimare una domanda costa più che sovrastimarla, se ne scrive una propria. Il rischio è il gradiente: con un framework a differenziazione automatica lo si ottiene gratis, ma se lo si scrive a mano (o si usa una perdita non derivabile in qualche punto) basta un segno sbagliato per addestrare nella direzione opposta. L'esempio è un errore quadratico che pesa k = 3 volte di più le sottostime, e = \hat y - y < 0: L = \frac{1}{n}\sum w_i e_i^2 con w_i = 3 se e_i < 0 e 1 altrimenti. Il gradiente è \partial L/\partial\hat y_i = \frac{2}{n}w_i e_i. Con y = (10, 12, 9, 15) e \hat y = (11, 9, 9{,}5, 14) gli errori sono (1, -3, 0{,}5, -1) e la perdita vale (1 + 27 + 0{,}25 + 3)/4 = 7{,}8125, contro 2{,}8125 dell'MSE ordinaria.
import numpy as np
# Perdita personalizzata: errore quadratico che penalizza 3 volte di piu' chi sottostima (y_hat < y)
def asym_mse(y, y_hat, k=3.0):
e = y_hat - y
return np.mean(np.where(e < 0, k, 1.0) * e ** 2)
def asym_mse_grad(y, y_hat, k=3.0): # derivata analitica rispetto a y_hat
e = y_hat - y
return 2 * np.where(e < 0, k, 1.0) * e / len(y)
y = np.array([10.0, 12.0, 9.0, 15.0])
y_hat = np.array([11.0, 9.0, 9.5, 14.0])
print("perdita:", round(asym_mse(y, y_hat), 4), " MSE normale:", round(np.mean((y - y_hat) ** 2), 4))
g = asym_mse_grad(y, y_hat)
eps = 1e-6
num = np.array([(asym_mse(y, y_hat + eps * np.eye(4)[i]) - asym_mse(y, y_hat - eps * np.eye(4)[i])) / (2 * eps) for i in range(4)])
print("gradiente analitico :", np.round(g, 4))
print("gradiente numerico :", np.round(num, 4))
print("scarto massimo:", f"{np.abs(g - num).max():.1e}")
# Output:
# perdita: 7.8125 MSE normale: 2.8125
# gradiente analitico : [ 0.5 -4.5 0.25 -1.5 ]
# gradiente numerico : [ 0.5 -4.5 0.25 -1.5 ]
# scarto massimo: 3.4e-09
Il controllo è lo stesso del calcolo differenziale: confrontare il gradiente analitico con le differenze finite centrate. Qui lo scarto massimo è dell'ordine di 10^{-9}, quindi la derivata è giusta. Un segno invertito o un fattore 2 dimenticato darebbero uno scarto dello stesso ordine del gradiente. La verifica si fa su un piccolo esempio, una volta, e richiede poche righe: costa meno di un addestramento che non converge.
Come scegliere
Non esiste una perdita migliore in assoluto; si parte dal tipo di uscita e si corregge in base ai dati. Le indicazioni che seguono sono un punto di partenza, non regole:
- regressione: MSE se gli errori grandi devono pesare molto e i dati sono puliti, MAE o Huber se ci sono outlier che non vuoi inseguire (con Huber \delta va scelto sulla scala degli errori)
- classificazione binaria o multiclasse: cross-entropy, preferibilmente calcolata sui logit
- classi molto sbilanciate: cross-entropy con pesi per classe oppure focal loss, valutando con precision e recall
- embedding e somiglianza: contrastive o triplet, con attenzione alla scelta delle coppie e delle triplette
Le prime due righe sono il caso base, le altre si usano quando una proprietà dei dati (sbilanciamento) o dell'obiettivo (somiglianza anziché etichetta) rende standard la perdita sbagliata. Qualunque sia la scelta, la perdita va scelta insieme alla metrica di valutazione, perché minimizzare una e giudicare con l'altra può portare a ottimi punteggi sulla perdita e risultati deludenti sul compito.
Che cosa sai fare adesso
Sai dire che cosa stima ciascuna perdita (la media con MSE, la mediana con MAE), perché il gradiente della cross-entropy sui logit è \hat y - y, e come la focal loss sposta il peso sui casi difficili, misurando quanto. Sai evitare le due trappole numeriche delle implementazioni ingenue, e sai scrivere una perdita personalizzata verificandone il gradiente. Il passo successivo guarda al risultato di un addestramento: l'articolo sulla statistica inferenziale mostra come stabilire se una differenza fra due modelli o due varianti è reale o solo rumore.
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
- Lin, Goyal, Girshick, He, Dollár, Focal Loss for Dense Object Detection (arXiv 1708.02002) - definizione della focal loss, effetto del fattore (1-p_t)^gamma, valori gamma = 2 e alpha = 0.25 nei loro esperimenti; PDF letto, consultata il 2026-11-12
- Guo, Pleiss, Sun, Weinberger, On Calibration of Modern Neural Networks (arXiv 1706.04599) - temperature scaling, parametro ottimizzato su un insieme di validazione, accuratezza invariata; PDF letto, consultata il 2026-11-12
- Goodfellow, Bengio, Courville, Deep Learning, capitoli 3 e 6 - cross-entropy come perdita e legame con la massima verosimiglianza, consultata il 2026-11-12
- Deisenroth, Faisal, Ong, Mathematics for Machine Learning (2020), capitolo 9 - la perdita quadratica come log-verosimiglianza negativa con rumore gaussiano; PDF letto, consultata il 2026-11-12

Commenti
Caricamento commenti...
Accedi per commentare