Esercizio - Curva ROC e AUC di una foresta casuale e di un albero
Questa pagina non ha ancora la versione ripasso: qui sotto c'è il testo completo.
In questa pagina 5
Testo (simulazione d'esame, esercizi 5 e 7). Sul dataset Titanic (712 passeggeri senza valori mancanti, target Survived, divisione stratificata , test di 143 passeggeri: 58 sopravvissuti e 85 non sopravvissuti):
- addestrare una foresta casuale con 100 alberi (campioni bootstrap e feature bagging), ottenere per ogni campione di test la confidenza (frazione di alberi che votano per la classe vincente) e trasformarla in punteggio per la classe 1;
- per soglie diverse calcolare TPR e FPR, tracciare la curva ROC e calcolare l'AUC;
- rendere probabilistico l'albero singolo (probabilità frazione di campioni di classe 1 nella foglia) e ripetere ROC e AUC;
- confrontare i due modelli.
Teoria usata: Metriche di classificazioneIn classificazione binaria ogni previsione è vero positivo (TP), vero negativo (TN), falso positivo (FP, errore di tipo I) o falso negativo (FN, errore di tipo II). Da queste quattro quantità: accuracy $=\frac{TP+TN}{TP+TN+FP+FN}$, specificità $=\frac{TN}{TN+FP}$, precision $=\frac{TP}{TP+FP}$, recall $=\frac{TP}{TP+FN}$, e la loro media armonica $F_1=\frac{2PR}{P+R}$. Con dati sbilanciati l'accuracy inganna (un modello che predice sempre la classe maggioritaria ha 99%): si usano precision, recall, F1, ROC-AUC, la cross-validation stratificata e il riequilibrio con undersampling o oversampling (non SMOTE). Cambiando la soglia sulla probabilità si ottiene la curva ROC (TPR contro FPR) e l'area AUC. Approfondimento: non nel programma di Telecomunicazioni.Metriche di classificazione → (TPR, FPR, ROC, AUC); Metodi ensemble - bagging, random forest e boostingUn albero da solo ha varianza alta; un ensemble combina molti modelli deboli. Bagging: ogni albero è addestrato su un campione bootstrap (n estrazioni con rimpiazzo, circa il 63% di campioni distinti) e si vota o si fa la media: riduce la varianza, perché la media di $T$ stimatori con varianza $\sigma^2$ e correlazione $\rho$ ha varianza $\rho\sigma^2+(1-\rho)\sigma^2/T$. Random forest = bagging + a ogni split solo $\sqrt p$ feature casuali (alberi meno correlati); l'importanza di una feature è la somma delle riduzioni di Gini pesate sui nodi in cui è usata. Boosting: alberi in sequenza, ciascuno corregge gli errori dei precedenti, e si riduce il bias. Gradient boosting: $F\leftarrow F+\eta h$ con $h$ albero sui residui (gradiente negativo della perdita), $\eta$ piccolo; AdaBoost: stump e pesi sui campioni sbagliati; XGBoost: similarity score $\frac{(\sum r)^2}{N+\lambda}$, gain, potatura con $\gamma$, output $\frac{\sum r}{N+\lambda}$. Programma di Telecomunicazioni: Random Forests; boosting come approfondimento.Metodi ensemble - bagging, random forest e boosting → (bagging, confidenza del voto); Alberi di decisioneUn albero di decisione partiziona i dati con una sequenza di regole su una sola variabile alla volta (nodi interni = regole, foglie = predizioni: classe più frequente, oppure media del target in regressione). Si costruisce in modo ricorsivo scegliendo a ogni nodo la divisione che rende i figli più «puri»: con l'entropia $H=-\sum p_i\log_2p_i$ e il guadagno d'informazione $IG=H(S)-\sum\frac{|S_v|}{|S|}H(S_v)$ (ID3), oppure con l'indice di Gini $1-\sum p_i^2$ e soglie $x\le t$ su variabili numeriche (CART); in regressione con MSE o riduzione di varianza. Un albero pienamente sviluppato fa overfitting (varianza alta): si limita con la profondità massima (pre-potatura) o con la potatura a costo-complessità $R_\alpha(T)=R(T)+\alpha|T|$ (post-potatura). Pro: interpretabile, niente normalizzazione, predizione immediata; contro: varianza alta, da cui le foreste. Programma di Telecomunicazioni: Decision Trees e Random Forests.Alberi di decisione → (ID3, foglie).
1. Punteggio della foresta
predict_bagging restituisce la classe di maggioranza e la confidenza . Il punteggio per la classe è
cioè la frazione di alberi che votano per «sopravvissuto». Con 100 alberi lo score assume valori multipli di .
Esempio. Se alberi su dicono : classe , conf , score (equivalente a voti per la classe ).
2. ROC: dalla soglia a TPR e FPR
Per ogni soglia (da a ) si prevede positivo se e si calcolano Soglie alte pochi positivi previsti (punto in basso a sinistra); soglie basse molti (alto a destra). Per alcuni valori (foresta con 100 alberi):
| soglia | TPR | FPR |
|---|---|---|
Con : , : la foresta trova sopravvissuti su sbagliando su non sopravvissuti su .
AUC. L'area sotto la curva si calcola con la regola dei trapezi sui punti ordinati per FPR, oppure in modo esatto come probabilità che un positivo preso a caso abbia punteggio maggiore di un negativo preso a caso (con per i pareggi). Per questa foresta (con un'altra realizzazione casuale delle foreste: nel notebook ufficiale; la differenza è dovuta ai campioni bootstrap). L'AUC dice che, nel delle coppie (positivo, negativo), la foresta assegna un punteggio più alto al positivo.
3. L'albero singolo con probabilità
Per ottenere un punteggio da un solo albero ID3 si memorizza in ogni nodo la probabilità (del training) e si usa quella della foglia in cui cade il campione (se la foglia è vuota si usa la probabilità del genitore: la classe prevista è già quella del genitore). Un albero ha pochi punteggi distinti (qui ): la curva ROC è fatta di pochi gradini. Risultati sul test: accuracy , .
| soglia | TPR | FPR |
|---|---|---|
(Il valore coincide con l'AUC esatta di scikit-learn nel notebook; l'integrazione per trapezi su una griglia di soglie dà : la differenza viene dalla discretizzazione.)
4. Confronto
La foresta ha AUC più alta ( contro ): con un punteggio più fine (101 livelli) e meno varianza ordina meglio i passeggeri. A parità di soglia l'albero singolo ha accuracy più alta su questo test ( contro della foresta): su 143 campioni una differenza di due casi non è significativa; l'AUC, che usa tutte le soglie, è una misura più stabile. Una soglia più bassa sposta il compromesso a favore del recall: per esempio con la foresta trova l' dei sopravvissuti con di falsi allarmi. In un'applicazione in cui perdere un positivo costa molto si abbassa la soglia.
Codice
scores = np.where(y_pred == 1, confidences, 1 - confidences) # punteggio per la classe 1
P, N = (y_test == 1).sum(), (y_test == 0).sum()
fpr, tpr = [], []
for t in np.linspace(0, 1, 101):
pred = scores >= t
tpr.append((pred & (y_test == 1)).sum() / P); fpr.append((pred & (y_test == 0)).sum() / N)
auc = np.trapz(tpr[::-1], fpr[::-1]) # regola dei trapezi (ordine per FPR crescente)
# esatta: media su tutte le coppie (positivo, negativo) di [s_pos > s_neg] + 0.5 [s_pos == s_neg]
# scikit-learn: roc_curve(y_test, scores), roc_auc_score(y_test, scores)