Salta al contenuto principale

07 - Funzioni di Perdita: MSE, Cross-Entropy, Focal Loss e Custom Loss

MSE, MAE, Huber, cross-entropy, focal loss e temperatura, con conti a mano e il gradiente di una perdita personalizzata verificato numericamente.

Cosa ne pensi di questo articolo?

07 - Funzioni di Perdita: MSE, Cross-Entropy, Focal Loss e Custom Loss
Math for AIFoto:Pavel DanilyukPexels

In Breve

MSE, MAE, Huber, cross-entropy, focal loss e temperatura, con conti a mano e il gradiente di una perdita personalizzata verificato numericamente.

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

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