Laboratorio 2 – Confronto fra modelli di regressione logistica
Corso di Modelli Statistici – Gruppo E
Authors
Salvatore Spinelli
Rebecca Tumolo
Ludovica Zacheo
Published
November 24, 2026
1 Confronto fra modelli di regressione logistica
Si considerano dati per la valutazione del rischio di credito. L’obiettivo è confrontare le performance di classificazione di modelli di regressione logistica ottenuti tramite regolarizzazione (Ridge, LASSO, Elastic Net), usando come riferimento la regressione logistica classica. Per valutare la qualità predittiva i dati sono divisi in training set (stima dei modelli) e test set (valutazione). Come richiesto dal professore, nell’ultima parte i modelli vengono confrontati su due specificazioni: la versione standard (le variabili originali) e la versione ampliata, con termini quadratici e interazioni (anche con gender).
La variabile risposta è credit_risk (1 = cliente a rischio, 0 = cliente non a rischio).
2 Sistemazione dati
library(glmnet)
Warning: il pacchetto 'glmnet' è stato creato con R versione 4.5.3
Caricamento del pacchetto richiesto: Matrix
Loaded glmnet 5.2
library(pROC)
Warning: il pacchetto 'pROC' è stato creato con R versione 4.5.3
Type 'citation("pROC")' for a citation.
Caricamento pacchetto: 'pROC'
I seguenti oggetti sono mascherati da 'package:stats':
cov, smooth, var
library(knitr)# glmnet: stima di Ridge, LASSO ed Elastic Net (e scelta di lambda con la cross-validation)# pROC: curve ROC e AUC# knitr: per mostrare le tabelle in modo ordinato nel documentodati <-read.csv("pension_credit_risk_dataset.csv", stringsAsFactors =TRUE)# stringsAsFactors = TRUE: le variabili di testo (gender, education_level, ...), diventano "fattori", cioè variabili qualitative. R le trasformerà in dummy da solo.dati$customer_id <-NULL# customer_id è solo un codice identificativo: non spiega il rischio, quindi lo tolgo.dati$annual_savings <-NULL# annual_savings è esattamente 12 volte monthly_savings (correlazione = 1): è la stessa informazione ripetuta, quindi si tiene una sola delle due.
Commento
Dal dataset sono state rimosse due colonne: customer_id, che è solo un codice identificativo e non spiega il rischio, e annual_savings, che è esattamente 12 volte monthly_savings e quindi contiene la stessa informazione.
2.0.1 Spiegazione codice:
library(glmnet), library(pROC), library(knitr): caricano i tre pacchetti che servono. glmnet stima Ridge, LASSO ed Elastic Net, pROC calcola curve ROC e AUC, knitr mostra le tabelle in modo ordinato.
dati <- read.csv("pension_credit_risk_dataset.csv", stringsAsFactors = TRUE): legge il file CSV e lo salva nell’oggetto dati. Con stringsAsFactors = TRUE le variabili di testo (come gender) diventano fattori, cioè variabili qualitative, che R trasformerà in dummy.
dati$customer_id <- NULL: elimina la colonna customer_id, che è solo un codice e non spiega il rischio.
dati$annual_savings <- NULL: elimina annual_savings, perché è 12 volte monthly_savings e quindi ripete la stessa informazione.
3 Esplorazione dati
cat("Righe e colonne:", dim(dati), "\n")
Righe e colonne: 50000 45
cat("Valori mancanti:", sum(is.na(dati)), "\n")
Valori mancanti: 0
# Quanti clienti ci sono in ciascuna classe? Se fossero molto sbilanciate,# l'accuratezza da sola sarebbe ingannevole.kable(data.frame(classe =c("0 (non a rischio)", "1 (a rischio)"),n =as.vector(table(dati$credit_risk)),percentuale =round(100*as.vector(prop.table(table(dati$credit_risk))), 1)))
classe
n
percentuale
0 (non a rischio)
25000
50
1 (a rischio)
25000
50
# Le due classi sono perfettamente bilanciate e non ci sono valori mancanti.num <- dati[sapply(dati, is.numeric)]cm <-cor(num)cm[upper.tri(cm, diag =TRUE)] <-NA# tengo solo metà matrice (ogni coppia una volta)coppie <-which(abs(cm) >0.8, arr.ind =TRUE)kable(data.frame(variabile_1 =rownames(cm)[coppie[, 1]],variabile_2 =colnames(cm)[coppie[, 2]],correlazione =round(cm[coppie], 3)))
variabile_1
variabile_2
correlazione
years_employed
age
0.925
credit_history_years
age
0.902
credit_history_years
years_employed
0.843
monthly_income
annual_income
0.989
emergency_fund_months
savings_ratio
0.884
loan_to_income_ratio
loan_amount
0.809
monthly_transaction_volume
transaction_amount
0.894
max_transaction
transaction_amount
0.869
# Coppie di variabili numeriche molto correlate (|r| > 0.8): segnale di multicollinearità.# Quando due variabili sono quasi uguali, la logistica classica non sa a quale attribuire l’effetto e i coefficienti diventano instabili. È uno dei motivi per cui ha senso provare Ridge e LASSO, che penalizzano i coefficienti troppo grandi.{# conta quanti clienti ci sono nelle due classi (0 = non a rischio, 1 = a rischio) conteggi <-table(dati$credit_risk) b <-barplot(conteggi, col =c("#477f89", "#8e1247"), border =NA,names.arg =c("0 (non a rischio)", "1 (a rischio)"),ylab ="Numero di clienti", main ="Distribuzione di credit_risk",ylim =c(0, max(conteggi) *1.15))# scrive il numero sopra ogni barratext(b, conteggi, labels =format(conteggi, big.mark =".", decimal.mark =","), pos =3)}
Commento
Il dataset contiene 50.000 clienti e 45 variabili e non presenta valori mancanti. Le due classi della variabile risposta sono perfettamente bilanciate (25.000 clienti ciascuna, 50%): per questo l’accuratezza è una misura appropriata per valutare i modelli, perché non c’è il rischio che una classe rara venga trascurata.
Otto coppie di variabili hanno una correlazione superiore a 0,8 in valore assoluto, ad esempio monthly_income e annual_income (0,989) e age e years_employed (0,925). Quando due variabili contengono informazioni quasi uguali, la regressione logistica classica non riesce ad attribuire l’effetto all’una o all’altra e i coefficienti diventano instabili (multicollinearità). È uno dei motivi per cui ha senso confrontare la logistica con Ridge e LASSO, che penalizzano i coefficienti troppo grandi.
3.0.1 Spiegazione codice:
cat("Righe e colonne:", dim(dati), "\n"): stampa il numero di righe e di colonne del dataset (dim restituisce i due numeri).
cat("Valori mancanti:", sum(is.na(dati)), "\n"): conta le celle vuote. is.na(dati) dà VERO per ogni cella vuota e sum le somma.
kable(data.frame(classe = ..., n = as.vector(table(dati$credit_risk)), percentuale = ...)): costruisce la tabella con il numero di clienti in ciascuna classe. table conta i clienti, prop.table calcola le proporzioni, che poi si moltiplicano per 100 e si arrotondano.
num <- dati[sapply(dati, is.numeric)]: tiene solo le colonne numeriche, perché la correlazione si calcola solo tra numeri.
cm <- cor(num): calcola la correlazione tra ogni coppia di variabili numeriche. Un valore vicino a 1 (o a -1) significa che le due variabili sono quasi la stessa informazione.
cm[upper.tri(cm, diag = TRUE)] <- NA: cancella la metà superiore della matrice e la diagonale, così ogni coppia compare una volta sola e non c’è la correlazione di una variabile con se stessa.
coppie <- which(abs(cm) > 0.8, arr.ind = TRUE): trova le coppie con correlazione, in valore assoluto, sopra 0,8. arr.ind = TRUE restituisce la riga e la colonna di ciascuna.
kable(data.frame(variabile_1 = ..., variabile_2 = ..., correlazione = ...)): mostra le coppie trovate con la loro correlazione.
Il blocco tra parentesi graffe: barplot(conteggi, ...) disegna una barra per ciascuna classe e text(b, conteggi, labels = ..., pos = 3) scrive il numero di clienti sopra ogni barra (b contiene le posizioni delle barre).
4 Divisione in training e test
set.seed(123) # rende la divisione riproducibile: stesso seed = stesso risultato# Divisione "stratificata": 70% dei clienti di ogni classe nel training, il resto nel test,# così le proporzioni 0/1 restano uguali nei due insiemi.i1 <-which(dati$credit_risk ==1)i0 <-which(dati$credit_risk ==0)idx_train <-c(sample(i1, round(0.7*length(i1))),sample(i0, round(0.7*length(i0))))train <- dati[idx_train, ]test <- dati[-idx_train, ]# glmnet non legge i data frame: vuole una matrice di numeri.# model.matrix trasforma le variabili qualitative in dummy (0/1).x_all <-model.matrix(credit_risk ~ ., data = dati)[, -1] # [, -1] toglie l'intercettax_train <- x_all[idx_train, ]x_test <- x_all[-idx_train, ]y_train <- train$credit_risky_test <- test$credit_riskcat("Training:", nrow(train), "clienti | Test:", nrow(test), "clienti\n")
Training: 35000 clienti | Test: 15000 clienti
Commento
I dati sono stati divisi in modo stratificato: 35.000 clienti (70%) nel training set e 15.000 (30%) nel test set, mantenendo in entrambi la stessa proporzione di clienti a rischio. Il training set è usato per stimare i modelli e per scegliere il parametro di penalizzazione; il test set non viene mai usato in queste fasi e serve soltanto a valutare le previsioni su clienti non osservati in fase di stima. Il seed è fissato (123) per rendere i risultati riproducibili.
4.0.1 Spiegazione codice:
4.0.2 Parte 1: scegliere chi va nel training
set.seed(123) Il computer pesca clienti “a caso”, ma il caso dipende da un numero di partenza (il seed). Fissandolo a 123, ogni volta che rilanci ottieni la stessa divisione. Senza, i risultati cambierebbero a ogni esecuzione.
i1 <- which(dati$credit_risk == 1) e i0 <- ...== 0which restituisce i numeri di riga. i1 contiene le righe dei clienti a rischio, i0 quelle dei non a rischio.
idx_train <- c(sample(i1, ...), sample(i0, ...))
sample(i1, round(0.7 * length(i1))) pesca a caso il 70% dei clienti a rischio.
Lo stesso per i non a rischio.
c(...) unisce le due liste.
Pescare separatamente da ogni classe si chiama divisione stratificata: serve a mantenere la stessa proporzione 50/50 sia nel training sia nel test.
train <- dati[idx_train, ] e test <- dati[-idx_train, ] Il training è l’insieme delle righe scelte. Il test è tutte le altre: il trattino davanti (-) significa “tutto tranne questi”.
4.0.3 Parte 2: preparare le matrici per glmnet
glmnet (il pacchetto per Ridge e LASSO) non legge i data frame, vuole una matrice di soli numeri.
model.matrix(credit_risk ~ ., data = dati) Costruisce quella matrice con tutte le variabili. Le variabili qualitative (come gender) vengono trasformate in dummy, cioè colonne 0/1.
[, -1] Toglie la prima colonna, che è l’intercetta (una colonna di tutti 1), perché glmnet la aggiunge da solo.
x_train e x_test Sono le stesse righe del training e del test, ma già in forma di matrice. Con x_all[idx_train, ] prendi le righe del training, con x_all[-idx_train, ] le altre.
y_train e y_test Sono le risposte vere (0 o 1) dei clienti del training e del test, cioè quello che i modelli dovranno prevedere.
5 Modello di riferimento: regressione logistica classica
# glm con family = binomial = regressione logistica, stimata per massima verosimiglianza.# credit_risk ~ . significa "credit_risk spiegato da tutte le altre variabili"m_glm <-glm(credit_risk ~ ., data = train, family = binomial)# Tabella dei coefficienti: le 10 variabili più importanti (z più alto in valore assoluto).cf <-coef(summary(m_glm))[-1, ]top <- cf[order(-abs(cf[, "z value"])), ][1:10, ]kable(round(data.frame(coefficiente = top[, "Estimate"],odds_ratio =exp(top[, "Estimate"]), # exp(beta) = odds ratioz = top[, "z value"],p_value = top[, "Pr(>|z|)"]), 4))
coefficiente
odds_ratio
z
p_value
credit_score
-0.0252
0.9751
-68.0418
0.0000
debt_to_income_ratio
9.9459
20866.8385
58.6711
0.0000
repayment_history_score
-0.0932
0.9110
-23.0713
0.0000
missed_payment_count
0.7470
2.1106
21.1340
0.0000
loan_to_income_ratio
0.5350
1.7074
15.3986
0.0000
fraud_risk_score
0.0446
1.0456
10.8287
0.0000
financial_stability_score
-4.8312
0.0080
-10.7344
0.0000
late_payment_count
0.1485
1.1601
9.5531
0.0000
payment_delay_days
0.0275
1.0279
7.7940
0.0000
emergency_fund_months
0.1451
1.1562
3.2083
0.0013
Commento
La regressione logistica classica, stimata sul training set, è il modello di riferimento. Delle 51 variabili (incluse le dummy), 17 risultano significative al 5%. Le più rilevanti sono credit_score (odds ratio 0,975: più alto è il punteggio, minore è il rischio), debt_to_income_ratio, repayment_history_score, missed_payment_count (odds ratio 2,11: ogni pagamento mancato in più circa raddoppia le odds di rischio) e loan_to_income_ratio.
Gli odds ratio si riferiscono a una variazione di un’unità della variabile, quindi dipendono dalla scala: debt_to_income_ratio varia solo tra 0,15 e 0,90, per cui il suo odds ratio per un’unità (circa 20.000) non è intuitivo; per un aumento di 0,1 le odds di rischio si moltiplicano per circa 2,7. Odds ratio e p-value hanno questa interpretazione solo per la logistica classica: per Ridge e LASSO i coefficienti sono volutamente ridotti dalla penalizzazione.
5.0.1 Spiegazione codice:
5.0.2 Il modello
m_glm <- glm(credit_risk ~ ., data = train, family = binomial)
glm sta per modello lineare generalizzato. Con family = binomial diventa una regressione logistica.
credit_risk ~ . si legge: “credit_risk spiegato da tutte le altre variabili”. Il punto significa “tutte le altre”.
data = train: usa solo il training, mai il test.
Il modello viene salvato in m_glm. R trova i coefficienti per massima verosimiglianza (cioè quelli che rendono più probabili i dati osservati), al posto dei minimi quadrati del lineare.
5.0.3 La tabella dei coefficienti
cf <- coef(summary(m_glm))[-1, ] Prende la tabella dei risultati del modello (un coefficiente per ogni variabile, con errore standard, z e p-value). Il [-1, ] toglie la prima riga, cioè l’intercetta, perché non è una variabile.
top <- cf[order(-abs(cf[, "z value"])), ][1:10, ] Ordina le variabili per valore assoluto della statistica z, dalla più alta alla più bassa, e tiene le prime 10. Una z grande (in valore assoluto) significa che quella variabile ha un effetto forte e ben stimato sul rischio.
kable(round(data.frame(...), 4)) Costruisce la tabella finale con quattro colonne e la arrotonda a 4 decimali:
coefficiente: l’effetto della variabile sul logit del rischio.
odds_ratio:exp(coefficiente). Si legge così: sopra 1 la variabile aumenta le odds di essere a rischio, sotto 1 le riduce. Per esempio 1.5 significa +50% di odds per ogni unità in più.
z: coefficiente diviso il suo errore standard. È il test di Wald.
p_value: la probabilità di vedere un effetto così forte se in realtà fosse nullo. Un p-value molto piccolo (sotto 0.05) indica un effetto significativo.
6 Modelli regolarizzati: Ridge, LASSO, Elastic Net
La regolarizzazione aggiunge alla stima una penalità che tiene piccoli i coefficienti. La forza della penalità è \(\lambda\); il parametro \(\alpha\) decide il tipo:
Modello
\(\alpha\)
Effetto
Ridge
0
riduce tutti i coefficienti, non ne azzera nessuno
LASSO
1
può azzerare alcuni coefficienti (selezione delle variabili)
Elastic Net
0,5
combina i due effetti
set.seed(123)# cv.glmnet: stima il modello per tanti valori di lambda e sceglie quello migliore con una# cross-validation a 10 parti FATTA SOLO SUL TRAINING.# family = "binomial": è una logistica. type.measure = "auc": si sceglie il lambda con AUC migliore.# (glmnet standardizza le variabili da solo.)cv_ridge <-cv.glmnet(x_train, y_train, family ="binomial", alpha =0, type.measure ="auc",lambda.min.ratio =1e-7) # griglia di lambda più ampia: il Ridge sceglie valori molto piccolicv_lasso <-cv.glmnet(x_train, y_train, family ="binomial", alpha =1, type.measure ="auc")cv_enet <-cv.glmnet(x_train, y_train, family ="binomial", alpha =0.5, type.measure ="auc")
6.0.1 Spiegazione codice
La regolarizzazione è una logistica a cui si aggiunge un freno ai coefficienti. Due numeri la controllano:
λ (lambda): quanto è forte il freno. λ vicino a 0 significa quasi nessun freno, cioè quasi la logistica classica. λ grande significa coefficienti molto ridotti.
α (alpha): che tipo di freno. alpha = 0 è Ridge (riduce tutti i coefficienti), alpha = 1 è LASSO (può azzerarne alcuni), alpha = 0.5 è Elastic Net (un misto dei due).
Il problema è che λ non lo conosci. Lo scegli con la cross-validation, ed è quello che fa cv.glmnet.
Riga per riga:
set.seed(123) La cross-validation divide il training in parti scelte a caso. Il seed fissa il caso, così rilanciando ottieni lo stesso risultato.
cv.glmnet(x_train, y_train, ...) Prende la matrice delle variabili (x_train) e le risposte vere (y_train) del solo training. Per tanti valori di λ fa questo:
divide il training in 10 parti (fold);
stima il modello su 9 parti e lo prova sulla decima;
ripete ruotando la parte di prova, 10 volte;
calcola la prestazione media per ogni λ. Alla fine scegli il λ con la prestazione migliore. Il test set non viene mai toccato.
family = "binomial" Dice a R che la risposta è 0/1, quindi è una regressione logistica.
alpha = 0, 1, 0.5 Sono le tre versioni: Ridge, LASSO, Elastic Net.
lambda.min.ratio = 1e-7 (solo per il Ridge) cv.glmnet prova una griglia di valori di λ, per default 100, dal più grande a uno molto piccolo. Con le impostazioni di default il Ridge sceglieva proprio l’ultimo valore della griglia: il migliore possibile era ancora più piccolo e non era stato provato. Con lambda.min.ratio = 1e-7 la griglia arriva a valori molto più piccoli e il Ridge trova il suo vero minimo (λ circa 0,0003). Per LASSO ed Elastic Net non serve, perché il loro minimo cade dentro la griglia.
type.measure = "auc" Dice con quale misura confrontare i λ. Qui è l’AUC, cioè la capacità del modello di distinguere i clienti a rischio da quelli non a rischio. Si sceglie il λ con l’AUC più alta.
Standardizzazioneglmnet porta tutte le variabili sulla stessa scala prima di stimare, perché la penalità dipende dalla scala. Senza, le variabili con numeri grandi (come il reddito) verrebbero penalizzate in modo diverso da quelle con numeri piccoli. Lo fa da solo.
Cosa contengono gli oggetti:
Ogni cv_... contiene due valori di λ già scelti:
lambda.min: quello con l’AUC migliore in assoluto.
lambda.1se: il λ più forte la cui prestazione è ancora entro un errore standard dal migliore, quindi un modello più semplice con prestazioni quasi uguali.
6.1 Grafico della cross-validation
{# funzione che disegna la curva di cross-validation (AUC) di un modello disegna_cv <-function(cv, titolo, pos ="bottomright") { x <--log(cv$lambda) # a destra la penalizzazione diminuisce i_min <-match(cv$lambda.min, cv$lambda) # posizione di lambda.min i_1se <-match(cv$lambda.1se, cv$lambda) # posizione di lambda.1seplot(NA, xlim =range(x), ylim =c(0.88, 0.93),xlab =expression(-log(lambda)),ylab ="AUC (cross-validation)", main = titolo)# fascia grigia = errore standard della cross-validationpolygon(c(x, rev(x)), c(cv$cvlo, rev(cv$cvup)), col ="#d9d9d9", border =NA)lines(x, cv$cvm, lwd =2.5, col ="#c0392b") # AUC media per ogni lambda# le due scelte di lambdaabline(v = x[i_1se], lty =2, lwd =2, col ="#24798C")abline(v = x[i_min], lty =2, lwd =2, col ="#2c3e50")legend(pos, bty ="n", cex =0.85, lwd =2, lty =2,col =c("#24798C", "#2c3e50"),legend =c(sprintf("lambda.1se: %d variabili", cv$nzero[i_1se]),sprintf("lambda.min: %d variabili", cv$nzero[i_min]))) } op <-par(mfrow =c(1, 3), mar =c(4.5, 4.5, 3, 1))disegna_cv(cv_ridge, "Ridge", pos ="topleft")disegna_cv(cv_lasso, "LASSO")disegna_cv(cv_enet, "Elastic Net")par(op)}
Commento
Le curve mostrano l’AUC media ottenuta in cross-validation al variare della penalizzazione. Nel LASSO e nell’Elastic Net l’AUC aumenta rapidamente e poi si stabilizza: oltre un certo punto ridurre la penalizzazione non migliora la capacità previsiva. Per questo con lambda.1se si ottengono modelli molto più semplici (10 variabili nel LASSO, 11 nell’Elastic Net) con un’AUC quasi uguale a quella di lambda.min (35 e 34 variabili). Nel Ridge nessuna variabile viene azzerata, quindi il numero di variabili resta 51.
6.1.1 Spiegazione codice:
Il grafico è lo stesso che si ottiene con plot(cv_ridge), ma costruito a mano per renderlo più leggibile: l’asse y è ristretto alla zona che conta e le due scelte di λ sono colorate.
disegna_cv <- function(cv, titolo, pos = "bottomright") {: crea una funzione che disegna la curva di cross-validation di un modello. Si scrive una volta e si riusa per i tre modelli. pos decide dove sta la legenda.
x <- -log(cv$lambda): i valori di λ provati da cv.glmnet sono dentro l’oggetto (cv$lambda). Si usa −log(λ) così che a destra la penalizzazione diminuisca.
i_min <- match(cv$lambda.min, cv$lambda) e i_1se <- ...: trovano la posizione di lambda.min e lambda.1se nell’elenco di tutti i λ, per sapere dove disegnare le linee e quante variabili restano.
plot(NA, xlim = range(x), ylim = c(0.88, 0.93), ...): crea un grafico vuoto con gli assi. L’asse y va da 0,88 a 0,93 ed è uguale nei tre grafici. I primi punti, con λ altissimo e nessuna variabile, hanno un’AUC molto bassa e restano fuori scala: se li includessi schiaccerebbero tutto il resto.
polygon(c(x, rev(x)), c(cv$cvlo, rev(cv$cvup)), col = "#d9d9d9", border = NA): disegna la fascia grigia, cioè l’errore standard della cross-validation (cvlo e cvup sono il limite inferiore e superiore).
lines(x, cv$cvm, lwd = 2.5, col = "#c0392b"): la linea rossa è l’AUC media (cvm) per ogni valore di λ.
abline(v = x[i_1se], lty = 2, ...) e abline(v = x[i_min], ...): le due linee verticali tratteggiate. Azzurra per lambda.1se, scura per lambda.min.
legend(pos, ..., legend = c(sprintf("lambda.1se: %d variabili", cv$nzero[i_1se]), ...)): la legenda scrive quante variabili restano in ciascun punto (cv$nzero). sprintf inserisce il numero dentro il testo.
par(mfrow = c(1, 3), mar = c(4.5, 4.5, 3, 1)): mette i tre grafici affiancati (1 riga, 3 colonne) e fissa i margini.
disegna_cv(cv_ridge, "Ridge", pos = "topleft") e le due righe dopo: applicano la funzione ai tre modelli. Nel Ridge la legenda va in alto a sinistra perché in basso a destra coprirebbe le linee.
par(op): ripristina le impostazioni grafiche di prima.
Come si legge:
Asse x (−log λ): verso sinistra la penalizzazione è forte (pochi coefficienti), verso destra si indebolisce e il modello si avvicina alla logistica classica.
Asse y (AUC): più è alta, meglio il modello distingue i clienti a rischio. La linea rossa è la media sulle 10 parti della cross-validation, la fascia grigia l’incertezza.
Linea azzurra (lambda.1se): il modello più semplice con AUC ancora entro un errore standard dal massimo. Linea scura (lambda.min): il λ con l’AUC migliore in assoluto.
Cosa notare: nel LASSO e nell’Elastic Net la curva diventa piatta, quindi aggiungere variabili oltre la linea azzurra non serve. Anche nel Ridge la curva diventa piatta, ma più lentamente, e il modello tiene sempre tutte le 51 variabili: la penalità riduce i coefficienti senza mai azzerarli.
6.2 Controllo: λ scelto con la devianza
Come verifica, ripetiamo la scelta di λ usando la devianza binomiale, che è la misura di default di cv.glmnet (e quella usata nell’esempio del professore), al posto dell’AUC.
{set.seed(123)# stessi tre modelli, ma lambda scelto con la devianza (misura di default di glmnet) cvd_ridge <-cv.glmnet(x_train, y_train, family ="binomial", alpha =0, type.measure ="deviance",lambda.min.ratio =1e-7) cvd_lasso <-cv.glmnet(x_train, y_train, family ="binomial", alpha =1, type.measure ="deviance") cvd_enet <-cv.glmnet(x_train, y_train, family ="binomial", alpha =0.5, type.measure ="deviance") disegna_cv_dev <-function(cv, titolo) {# curva di cross-validation: a destra la penalizzazione diminuisceplot(cv, sign.lambda =-1, main ="", ylab ="Devianza binomiale", xlab =expression(-log(lambda)))title(titolo, line =3.5) x_1se <--log(cv$lambda.1se) x_min <--log(cv$lambda.min) lim <-par("usr") # limiti del grafico, per posizionare le scritte amp_y <- lim[4] - lim[3]# due linee verticali colorate: lambda.1se (azzurra) e lambda.min (rosa)abline(v = x_1se, col ="#24798C", lty =2, lwd =2.5)abline(v = x_min, col ="#C2185B", lty =2, lwd =2.5)# se una linea è vicina al bordo destro, la scritta va a sinistra per non uscire dal grafico vicino_bordo <-function(x) x > lim[1] +0.88* (lim[2] - lim[1])text(x_1se, lim[3] +0.82* amp_y, labels =expression(lambda["1se"]),pos =if (vicino_bordo(x_1se)) 2else4, offset =0.7, col ="#24798C", font =2, cex =1.35)text(x_min, lim[3] +0.70* amp_y, labels =expression(lambda[min]),pos =2, offset =0.7, col ="#C2185B", font =2, cex =1.35) } op <-par(mfrow =c(1, 3), mar =c(4.5, 4.5, 5, 1))disegna_cv_dev(cvd_ridge, "Ridge")disegna_cv_dev(cvd_lasso, "LASSO")disegna_cv_dev(cvd_enet, "Elastic Net")par(op)}
Commento
Le curve mostrano la devianza binomiale media ottenuta in cross-validation al variare della penalizzazione (valori più bassi indicano un modello migliore). Nel LASSO e nell’Elastic Net la devianza diminuisce rapidamente e poi si stabilizza: oltre un certo punto ridurre la penalizzazione non migliora il modello. La linea azzurra (λ₁ₛₑ) indica il modello più semplice con prestazioni entro un errore standard dal migliore, quella rosa (λₘᵢₙ) il modello con devianza minima. Nel Ridge nessuna variabile viene azzerata, quindi le variabili restano 51. Il confronto con la scelta basata sull’AUC è riportato nella tabella più avanti.
6.2.1 Spiegazione codice:
set.seed(123): fissa il caso della cross-validation, così rilanciando ottieni gli stessi risultati.
cvd_ridge <- cv.glmnet(..., type.measure = "deviance") (e le due righe dopo): sono gli stessi tre modelli di prima (alpha = 0, 1, 0.5, con la stessa griglia più ampia per il Ridge), ma il λ migliore viene scelto con la devianza invece che con l’AUC. I nomi iniziano con cvd_ (d = devianza) per non confonderli con i precedenti.
disegna_cv_dev <- function(cv, titolo) {: crea una funzione che disegna la curva di un modello, riusabile per i tre.
plot(cv, sign.lambda = -1, main = "", ...): disegna la curva di cross-validation. sign.lambda = -1 mette sull’asse x −log(λ) (penalizzazione più debole a destra). ylab e xlab cambiano le etichette degli assi in italiano.
title(titolo, line = 3.5): scrive il titolo, un po’ più in alto perché sopra il grafico ci sono i numeri delle variabili.
x_1se <- -log(cv$lambda.1se) e x_min <- -log(cv$lambda.min): calcolano dove cadono i due λ sull’asse x.
lim <- par("usr") e amp_y <- lim[4] - lim[3]: leggono i limiti del grafico appena disegnato, per posizionare le scritte a una certa altezza.
abline(v = x_1se, col = "#24798C", lty = 2, lwd = 2.5) e la riga dopo: disegnano le due linee verticali tratteggiate, azzurra per lambda.1se e rosa per lambda.min.
vicino_bordo <- function(x) x > lim[1] + 0.88 * (lim[2] - lim[1]): controlla se una linea è nell’ultimo 12% del grafico, a destra. Serve nel Ridge, dove le linee sono vicinissime al bordo.
text(x_1se, ..., labels = expression(lambda["1se"]), pos = ...) e la riga dopo: scrivono accanto a ogni linea la sua etichetta (λ₁ₛₑ e λₘᵢₙ). pos decide da che lato sta la scritta: a sinistra se la linea è vicina al bordo, altrimenti a destra.
par(mfrow = c(1, 3), mar = c(4.5, 4.5, 5, 1)) e le tre chiamate finali: mettono i grafici affiancati e li disegnano per Ridge, LASSO ed Elastic Net.
Come si legge:
Asse y (devianza binomiale): è una misura dell’errore del modello, più è bassa meglio è. Il valore iniziale di circa 1,39 è quello di un modello senza variabili, che prevede sempre lo stesso.
Punti rossi e barrette grigie: la devianza media in cross-validation per ogni λ e il suo errore standard (qui molto piccolo).
Numeri in alto: quante variabili restano nel modello in quel punto. Nel LASSO si va da 0 a circa 40, nel Ridge sono sempre 51.
Linea rosa (λₘᵢₙ) e linea azzurra (λ₁ₛₑ): la devianza minima in assoluto e il modello più semplice entro un errore standard da essa.
7 Lambda scelti e numero di variabili
# Quanti coefficienti restano diversi da zero (su tutte le variabili)?n_var <-function(cv, s) sum(coef(cv, s = s)[-1] !=0)kable(data.frame(modello =c("Ridge", "LASSO", "Elastic Net"),lambda_min =c(cv_ridge$lambda.min, cv_lasso$lambda.min, cv_enet$lambda.min),var_lambda_min =c(n_var(cv_ridge, "lambda.min"), n_var(cv_lasso, "lambda.min"), n_var(cv_enet, "lambda.min")),lambda_1se =c(cv_ridge$lambda.1se, cv_lasso$lambda.1se, cv_enet$lambda.1se),var_lambda_1se =c(n_var(cv_ridge, "lambda.1se"), n_var(cv_lasso, "lambda.1se"), n_var(cv_enet, "lambda.1se"))),digits =4)
modello
lambda_min
var_lambda_min
lambda_1se
var_lambda_1se
Ridge
0.0003
51
0.0224
51
LASSO
0.0006
35
0.0114
10
Elastic Net
0.0017
34
0.0228
11
Commento
La tabella riporta, per ogni modello, il valore di λ scelto con la cross-validation e il numero di variabili che restano. Il Ridge mantiene sempre tutte le 51 variabili, perché riduce i coefficienti ma non li azzera. Il LASSO e l’Elastic Net effettuano invece una selezione: con lambda.min restano 35 e 34 variabili, con lambda.1se solo 10 e 11, perché in quel caso λ è molto più grande (per il LASSO 0,0114 contro 0,0006). Nel Ridge il lambda.min è molto piccolo (circa 0,0003): con tanti dati la penalità ottimale è quasi nulla e il modello è vicino alla logistica classica.
7.1 Spiegazione codice
n_var <- function(cv, s) sum(coef(cv, s = s)[-1] != 0) Crea una piccola funzione, cioè una “ricetta” riutilizzabile, che conta quante variabili restano nel modello. Funziona così:
coef(cv, s = s) prende i coefficienti del modello al λ scelto (s può essere "lambda.min" o "lambda.1se"): sono 52 numeri, l’intercetta più le 51 variabili.
[-1] toglie l’intercetta, perché non è una variabile.
!= 0 controlla per ogni coefficiente se è diverso da zero (vero o falso).
sum(...) conta quanti sono veri, cioè quante variabili il modello ha davvero tenuto.
kable(data.frame(...), digits = 4) Costruisce una tabella con una riga per modello e cinque colonne:
lambda_min: il valore di λ con l’AUC migliore, preso con cv_ridge$lambda.min (il $ prende un pezzo dell’oggetto).
var_lambda_min: quante variabili restano con quel λ.
lambda_1se e var_lambda_1se: lo stesso per il λ più forte.
digits = 4 arrotonda i numeri a quattro cifre. I λ molto piccoli (come 0,0006) possono comparire in notazione scientifica, ed è normale.
Come si collega al grafico di prima:
Nel grafico di prima ogni modello aveva due linee tratteggiate e l’indicazione di quante variabili restavano. Questa tabella ti dà gli stessi dati in forma esatta:
Nel grafico
Nella tabella
Linea tratteggiata a sinistra (penalità più forte)
lambda_1se e var_lambda_1se
Linea tratteggiata a destra (penalità più debole)
lambda_min e var_lambda_min
Numero di variabili scritto nella legenda (o in alto, nel grafico con la devianza)
Numero di variabili (var_...)
L’asse x del grafico è −log(λ), quindi un λ piccolo sta a destra. Per esempio, λ = 0,0114 corrisponde a x ≈ 4,5. Per questo la linea di destra (lambda.min) ha λ più piccolo e più variabili.
Questi λ non servono solo per la tabella: sono quelli usati nel passaggio successivo per calcolare le previsioni sul test, con s = "lambda.min" e s = "lambda.1se".
Cosa aspettarsi:
Il Ridge ha 51 variabili in entrambe le colonne, perché non azzera mai niente. LASSO ed Elastic Net con lambda.min ne tengono circa 30-35, con lambda.1se circa 10-13. Il lambda.min del Ridge (circa 0,0003) è molto più piccolo del suo lambda.1se (circa 0,022): con un campione grande il Ridge sceglie una penalità quasi nulla, cioè un modello molto vicino alla logistica classica.
8 Le variabili che il LASSO ha tenuto
# Variabili tenute dal LASSO con lambda.1se, ordinate per grandezza del coefficiente.cf_lasso <-coef(cv_lasso, s ="lambda.1se")tenute <- cf_lasso[cf_lasso[, 1] !=0, , drop =FALSE]tenute <- tenute[rownames(tenute) !="(Intercept)", , drop =FALSE]kable(data.frame(variabile =rownames(tenute), coefficiente =round(tenute[, 1], 4))[order(-abs(tenute[, 1])), ],row.names =FALSE)
variabile
coefficiente
debt_to_income_ratio
7.3097
financial_stability_score
-4.7308
missed_payment_count
0.4081
loan_to_income_ratio
0.3686
repayment_history_score
-0.0853
late_payment_count
0.0335
fraud_risk_score
0.0249
credit_score
-0.0191
payment_delay_days
0.0021
transaction_amount
0.0000
Commento
Con lambda.1se il LASSO mantiene 10 variabili su 51. Le più rilevanti sono debt_to_income_ratio, financial_stability_score, missed_payment_count, loan_to_income_ratio e repayment_history_score, tutte legate al livello di indebitamento e allo storico dei pagamenti, e in gran parte coincidono con quelle più significative della logistica classica. I coefficienti non vanno confrontati per grandezza, perché le variabili hanno scale molto diverse.
8.0.1 Spiegazione codice
Risponde alla domanda: “quali sono le variabili che il LASSO ha scelto di tenere con lambda.1se, e con quale coefficiente?”.
cf_lasso <- coef(cv_lasso, s = "lambda.1se"): prende i 52 coefficienti del LASSO (intercetta più 51 variabili) al λ più forte. Quasi tutti sono zero.
tenute <- cf_lasso[cf_lasso[, 1] != 0, , drop = FALSE]: tiene solo le righe con coefficiente diverso da zero. [, 1] è l’unica colonna della matrice. drop = FALSE serve a mantenere la forma di tabella e i nomi delle variabili, altrimenti R li perderebbe.
tenute <- tenute[rownames(tenute) != "(Intercept)", , drop = FALSE]: toglie l’intercetta, che non è una variabile.
kable(data.frame(...)[order(-abs(...)), ], row.names = FALSE): costruisce una tabella con nome e coefficiente (arrotondato a 4 decimali), la ordina dal coefficiente più grande al più piccolo in valore assoluto (order(-abs(...))) e la mostra senza i numeri di riga.
Attenzione: l’ordine per grandezza del coefficiente non è l’ordine di importanza. Le variabili hanno scale diverse: debt_to_income_ratio va da 0,15 a 0,9 e credit_score da 350 a 850, quindi il primo avrà per forza un coefficiente enorme e il secondo minuscolo. Per questo non si può dire quale variabile sia più importante guardando questa colonna.
9 Le probabilità previste sul test set
# Probabilità previste sul TEST dai modelli regolarizzati (due scelte di lambda ciascuno).prev <-function(cv, s) as.numeric(predict(cv, newx = x_test, s = s, type ="response"))p_ridge_min <-prev(cv_ridge, "lambda.min"); p_ridge_1se <-prev(cv_ridge, "lambda.1se")p_lasso_min <-prev(cv_lasso, "lambda.min"); p_lasso_1se <-prev(cv_lasso, "lambda.1se")p_enet_min <-prev(cv_enet, "lambda.min"); p_enet_1se <-prev(cv_enet, "lambda.1se")
9.0.1 Spiegazione codice
Qui per la prima volta i modelli regolarizzati “guardano” il test set, ma solo per fare previsioni: non si sceglie nulla.
prev <- function(cv, s) as.numeric(predict(cv, newx = x_test, s = s, type = "response")): crea una funzione che, dato un modello e la scelta del λ, calcola la probabilità di rischio per ogni cliente del test.
newx = x_test indica i nuovi dati su cui prevedere.
s = s indica quale λ usare (lambda.min o lambda.1se).
type = "response" chiede la probabilità (0-1) e non il logit.
as.numeric trasforma il risultato in un semplice elenco di numeri.
Le sei righe sotto applicano la funzione a Ridge, LASSO ed Elastic Net, ciascuno con i due λ. Il ; permette di mettere due comandi nella stessa riga. Ogni risultato (per esempio p_lasso_min) è un vettore di 15.000 probabilità, una per cliente del test.
9.1 Controllo di robustezza: λ scelto con AUC o con devianza
# confronto dei due criteri: variabili tenute e AUC sul test setauc_test <-function(cv, s) as.numeric(auc(roc(y_test, prev(cv, s), quiet =TRUE)))coppie_cv <-list("Ridge"=list(cv_ridge, cvd_ridge), "LASSO"=list(cv_lasso, cvd_lasso),"Elastic Net"=list(cv_enet, cvd_enet))tab_crit <-do.call(rbind, lapply(names(coppie_cv), function(nome) {do.call(rbind, lapply(c("lambda.min", "lambda.1se"), function(s) {data.frame(Modello = nome, Lambda = s,Variabili_AUC =n_var(coppie_cv[[nome]][[1]], s),AUC_test_AUC =round(auc_test(coppie_cv[[nome]][[1]], s), 4),Variabili_devianza =n_var(coppie_cv[[nome]][[2]], s),AUC_test_devianza =round(auc_test(coppie_cv[[nome]][[2]], s), 4)) }))}))kable(tab_crit)
Modello
Lambda
Variabili_AUC
AUC_test_AUC
Variabili_devianza
AUC_test_devianza
Ridge
lambda.min
51
0.9229
51
0.9229
Ridge
lambda.1se
51
0.9216
51
0.9227
LASSO
lambda.min
35
0.9229
38
0.9229
LASSO
lambda.1se
10
0.9209
13
0.9224
Elastic Net
lambda.min
34
0.9229
41
0.9229
Elastic Net
lambda.1se
11
0.9212
18
0.9228
Commento
Come verifica, il parametro di penalizzazione è stato scelto anche con la devianza binomiale, il criterio di default di glmnet. Con lambda.min i risultati sono praticamente identici (AUC 0,9229 per Ridge, LASSO ed Elastic Net). Con lambda.1se la devianza porta a modelli un po’ meno semplici (13 variabili nel LASSO contro 10) e a un’AUC leggermente più alta (0,9224 contro 0,9209). In ogni caso le differenze sono piccole e la conclusione non cambia: la regolarizzazione non migliora la capacità previsiva, ma permette di ottenere le stesse prestazioni con meno variabili.
9.1.1 Spiegazione codice
auc_test <- function(cv, s) as.numeric(auc(roc(y_test, prev(cv, s), quiet = TRUE))): crea una funzione che, dato un modello e la scelta di λ, calcola le probabilità sul test set (con prev) e ne ricava l’AUC.
coppie_cv <- list("Ridge" = list(cv_ridge, cvd_ridge), ...): per ogni modello raccoglie le due versioni: quella con λ scelto tramite AUC (cv_...) e quella tramite devianza (cvd_...).
tab_crit <- do.call(rbind, lapply(names(coppie_cv), function(nome) {...})): costruisce la tabella. lapply ripete le istruzioni per ciascun modello, e dentro, per lambda.min e lambda.1se; per ognuno crea una riga con il numero di variabili (n_var) e l’AUC sul test per i due criteri. do.call(rbind, ...) incolla tutte le righe una sotto l’altra.
kable(tab_crit): mostra la tabella.
10 Confronto delle performance sul test set
p_glm <-predict(m_glm, newdata = test, type ="response")soglia <-0.5# se la probabilità è > 0.5 il cliente viene classificato "a rischio"valuta <-function(p, y, soglia =0.5) { pred <-as.integer(p > soglia) TP <-sum(pred ==1& y ==1) # a rischio, previsti a rischio TN <-sum(pred ==0& y ==0) # non a rischio, previsti non a rischio FP <-sum(pred ==1& y ==0) # non a rischio, previsti a rischio (falso allarme) FN <-sum(pred ==0& y ==1) # a rischio, previsti non a rischio (errore più costoso) prec <- TP / (TP + FP) # precisione rec <- TP / (TP + FN) # sensibilità (recall)c(Accuratezza = (TP + TN) /length(y), # quota di previsioni corretteSensibilita = rec, # a rischio veri: quanti ne trovoSpecificita = TN / (TN + FP), # non a rischio veri: quanti li riconoscoPrecisione = prec, # tra i "a rischio" previsti, quanti lo sono davveroF1 =2* prec * rec / (prec + rec), # media tra precisione e sensibilitàAUC =as.numeric(auc(roc(y, p, quiet =TRUE)))) # capacità di distinguere, indipendente dalla soglia}modelli <-list("Logistica classica"= p_glm,"Ridge (lambda.min)"= p_ridge_min,"Ridge (lambda.1se)"= p_ridge_1se,"LASSO (lambda.min)"= p_lasso_min,"LASSO (lambda.1se)"= p_lasso_1se,"Elastic Net (lambda.min)"= p_enet_min,"Elastic Net (lambda.1se)"= p_enet_1se)tabella <-t(sapply(modelli, valuta, y = y_test, soglia = soglia))kable(round(tabella, 4))
Accuratezza
Sensibilita
Specificita
Precisione
F1
AUC
Logistica classica
0.8370
0.8411
0.8329
0.8343
0.8377
0.9228
Ridge (lambda.min)
0.8373
0.8416
0.8331
0.8345
0.8380
0.9229
Ridge (lambda.1se)
0.8341
0.8396
0.8287
0.8305
0.8350
0.9216
LASSO (lambda.min)
0.8363
0.8408
0.8317
0.8332
0.8370
0.9229
LASSO (lambda.1se)
0.8353
0.8421
0.8285
0.8308
0.8364
0.9209
Elastic Net (lambda.min)
0.8363
0.8416
0.8311
0.8328
0.8372
0.9229
Elastic Net (lambda.1se)
0.8355
0.8432
0.8277
0.8304
0.8367
0.9212
Commento
Sul test set tutti i modelli mostrano prestazioni molto simili: l’accuratezza è circa 0,83-0,84 e l’AUC circa 0,92. Ridge, LASSO ed Elastic Net con lambda.min ottengono l’AUC più alta (0,9229), ma la differenza rispetto alla logistica classica (0,9228) è trascurabile. Sensibilità e specificità sono bilanciate, intorno a 0,84 e 0,83, e anche l’F1 è stabile intorno a 0,84. La regolarizzazione non migliora quindi la capacità previsiva, perché il numero di osservazioni è molto elevato rispetto al numero di variabili e il rischio di overfitting è contenuto. Il vantaggio dei modelli regolarizzati sta nella parsimonia: il LASSO raggiunge le stesse prestazioni con un numero molto inferiore di variabili.
10.0.1 Spiegazione codice
1. La soglia
soglia <- 0.5: fissa la soglia di decisione. Se la probabilità di rischio di un cliente è sopra 0,5, lo classifichiamo “a rischio”, altrimenti “non a rischio”.
2. La funzione valuta
valuta <- function(p, y, soglia = 0.5) {: crea una funzione che, date le probabilità previste p e i valori reali y, calcola le metriche. È una “macchinetta” che useremo per ogni modello.
pred <- as.integer(p > soglia): trasforma ogni probabilità in una decisione. p > soglia dà VERO o FALSO, e as.integer lo converte in 1 (a rischio) o 0 (non a rischio).
TP <- sum(pred == 1 & y == 1): conta i clienti a rischio che il modello ha previsto a rischio (previsione giusta).
TN <- sum(pred == 0 & y == 0): conta i clienti non a rischio che il modello ha previsto non a rischio (previsione giusta).
FP <- sum(pred == 1 & y == 0): conta i clienti non a rischio che il modello ha segnalato a rischio (falso allarme).
FN <- sum(pred == 0 & y == 1): conta i clienti a rischio che il modello ha lasciato passare (l’errore più grave).
prec <- TP / (TP + FP): calcola la precisione, cioè tra quelli segnalati a rischio, la quota che lo è davvero. La salviamo perché serve anche per l’F1.
rec <- TP / (TP + FN): calcola la sensibilità, cioè tra i clienti davvero a rischio, la quota che il modello trova. Serve anche per l’F1.
c(Accuratezza = (TP + TN) / length(y),: l’accuratezza è la quota di previsioni giuste su tutti i clienti. c(...) raccoglie tutte le metriche in un unico elenco con i loro nomi.
Sensibilita = rec,: inserisce la sensibilità appena calcolata.
Specificita = TN / (TN + FP),: tra i clienti davvero non a rischio, la quota che il modello riconosce.
Precisione = prec,: inserisce la precisione appena calcolata.
F1 = 2 * prec * rec / (prec + rec),: una media tra precisione e sensibilità, alta solo se sono alte entrambe.
AUC = as.numeric(auc(roc(y, p, quiet = TRUE)))): roc costruisce la curva ROC, auc ne calcola l’area e as.numeric la rende un numero semplice. Misura quanto bene il modello ordina i clienti dal meno al più rischioso, senza usare la soglia. quiet = TRUE evita messaggi inutili.
3. La lista dei modelli
modelli <- list("Logistica classica" = p_glm, ...): raccoglie in un unico contenitore le probabilità previste dai 7 modelli sul test set. Il nome a sinistra sarà l’etichetta della riga nella tabella.
4. La tabella di confronto
tabella <- t(sapply(modelli, valuta, y = y_test, soglia = soglia)): applica valuta a ciascun modello con gli stessi clienti di test e la stessa soglia. t(...) scambia righe e colonne, così hai un modello per riga e una metrica per colonna.
kable(round(tabella, 4)): arrotonda i numeri a 4 decimali e li mostra come tabella ordinata nel documento.
# Matrici di confusione (righe = realtà, colonne = previsione) per i modelli principali.for (nome inc("Logistica classica", "Ridge (lambda.min)", "LASSO (lambda.min)", "Elastic Net (lambda.min)")) {cat("\n", nome, "\n")print(table(Osservato = y_test,Previsto =factor(as.integer(modelli[[nome]] > soglia), levels =c(0, 1))))}
Le matrici di confusione mostrano il dettaglio degli errori. La logistica classica classifica correttamente 12.555 clienti su 15.000 (83,7%): sbaglia 1.253 volte segnalando come a rischio un cliente sicuro (falso allarme) e 1.192 volte non individuando un cliente a rischio (falso negativo). Ridge, LASSO ed Elastic Net danno risultati quasi identici (rispettivamente 1.252 e 1.188 errori dei due tipi per il Ridge, 1.262 e 1.194 per il LASSO, 1.267 e 1.188 per l’Elastic Net), con differenze di poche decine di clienti. I due tipi di errore sono simili per numero, coerentemente con sensibilità e specificità bilanciate.
Questo blocco stampa la matrice di confusione per quattro modelli: la logistica classica, il Ridge, il LASSO e l’Elastic Net, tutti con lambda.min. Per ogni modello ti mostra una tabella 2×2 con le previsioni giuste e sbagliate.
Il ciclo
for (nome in c("Logistica classica", "Ridge (lambda.min)", "LASSO (lambda.min)", "Elastic Net (lambda.min)")) {: ripete le istruzioni che seguono una volta per ciascuno di questi quattro nomi. A ogni giro la variabile nome vale il nome del modello corrente, così non devi riscrivere lo stesso codice quattro volte.
cat("\n", nome, "\n"): stampa il nome del modello su una riga a sé, preceduto da una riga vuota, per capire a quale tabella ti riferisci.
La matrice
modelli[[nome]]: prende dalla lista modelli (quella creata nel blocco prima) le probabilità previste dal modello corrente. Le doppie parentesi quadre pescano l’elemento con quel nome.
modelli[[nome]] > soglia: confronta ogni probabilità con 0,5 e dà VERO o FALSO per ciascun cliente.
as.integer(...): trasforma VERO/FALSO in 1/0, cioè la decisione del modello: 1 = a rischio, 0 = non a rischio.
factor(..., levels = c(0, 1)): dichiara che le previsioni possono valere solo 0 o 1. Serve perché, se un modello non prevedesse mai uno dei due valori, la tabella avrebbe comunque entrambe le colonne.
table(Osservato = y_test, Previsto = ...): incrocia la realtà (y_test) con la previsione e conta quanti clienti cadono in ciascuna combinazione. Osservato e Previsto sono solo le etichette scritte nella tabella.
print(...): la mostra a schermo. Dentro un ciclo for serve print, altrimenti R non stampa il risultato.
Come leggere la tabella:
Previsto 0
Previsto 1
Osservato 0
TN (giusto)
FP (falso allarme)
Osservato 1
FN (cliente rischioso non visto)
TP (giusto)
La diagonale (in alto a sinistra e in basso a destra) contiene le previsioni giuste.
Le altre due caselle sono gli errori. FN è quello più grave: un cliente a rischio che il modello lascia passare.
Sono gli stessi quattro numeri che la funzione valuta usa per calcolare accuratezza, sensibilità e specificità. Per esempio la sensibilità è TP / (TP + FN), cioè la casella in basso a destra divisa per la riga in basso.
10.1 Matrici di confusione in forma grafica
{ disegna_matrice <-function(nome) { pred <-factor(as.integer(modelli[[nome]] > soglia), levels =c(0, 1)) z <-table(Osservato = y_test, Previsto = pred)plot.new()plot.window(xlim =c(0.5, 2.5), ylim =c(0.5, 2.5))for (i in1:2) {for (j in1:2) {# le caselle sulla diagonale (previsioni giuste) sono verdi, le altre rosarect(j -0.47, 3- i -0.47, j +0.47, 3- i +0.47,col =if (i == j) "#d4eae3"else"#f8dfd4", border ="white", lwd =3)text(j, 3- i, labels =format(z[i, j], big.mark =".", decimal.mark =","), cex =1.6, font =2) } }axis(1, at =c(1, 2), labels =c("0", "1"), tick =FALSE)axis(2, at =c(2, 1), labels =c("0", "1"), las =1, tick =FALSE)title(xlab ="Previsto", ylab ="Osservato", main = nome) } op <-par(mfrow =c(2, 2), mar =c(4.5, 4.5, 3, 1))for (nome inc("Logistica classica", "Ridge (lambda.min)", "LASSO (lambda.min)", "Elastic Net (lambda.min)")) {disegna_matrice(nome) }par(op)}
Commento
Le stesse matrici in forma grafica: le caselle verdi sulla diagonale sono le previsioni corrette, quelle rosa gli errori. I quattro modelli sono praticamente indistinguibili.
10.1.1 Spiegazione codice
disegna_matrice <- function(nome) {: crea una funzione che disegna la matrice di confusione del modello chiamato nome.
pred <- factor(as.integer(modelli[[nome]] > soglia), levels = c(0, 1)): trasforma le probabilità del modello in decisioni 0/1, come nel blocco precedente.
z <- table(Osservato = y_test, Previsto = pred): la matrice 2×2 con i conteggi dei clienti.
plot.new() e plot.window(xlim = c(0.5, 2.5), ylim = c(0.5, 2.5)): preparano un foglio vuoto con coordinate da 0,5 a 2,5, così le quattro caselle si dispongono in una griglia 2×2.
for (i in 1:2) { for (j in 1:2) {...} }: un doppio ciclo che passa sulle quattro caselle (riga i, colonna j).
rect(j - 0.47, 3 - i - 0.47, j + 0.47, 3 - i + 0.47, col = if (i == j) "#d4eae3" else "#f8dfd4", ...): disegna un quadrato per la casella. Se i == j la casella è sulla diagonale, cioè una previsione corretta, e va in verde; altrimenti in rosa. 3 - i serve per mettere la prima riga in alto.
text(j, 3 - i, labels = format(z[i, j], big.mark = ".", decimal.mark = ","), ...): scrive dentro la casella il numero di clienti, con il punto per le migliaia.
axis(1, ...), axis(2, ...) e title(...): aggiungono le etichette 0 e 1 sugli assi e il titolo con il nome del modello.
par(mfrow = c(2, 2), ...) e for (nome in c(...)) { disegna_matrice(nome) }: mettono i quattro grafici in una griglia 2×2 e disegnano la matrice per logistica, Ridge, LASSO ed Elastic Net.
# Curve ROC: per ogni soglia, quanti a rischio veri trovo (sensibilità) contro quanti# non a rischio classifico male (1 - specificità). Più la curva è vicina all'angolo in alto# a sinistra, meglio il modello distingue le due classi.{plot(roc(y_test, p_glm, quiet =TRUE), col ="black", lwd =2, legacy.axes =TRUE,main ="Curve ROC sul test set")plot(roc(y_test, p_ridge_min, quiet =TRUE), col ="blue", lwd =2, lty =2, add =TRUE)plot(roc(y_test, p_lasso_min, quiet =TRUE), col ="red", lwd =2, lty =3, add =TRUE)plot(roc(y_test, p_enet_min, quiet =TRUE), col ="darkgreen", lwd =2, lty =4, add =TRUE)legend("bottomright", c("Logistica", "Ridge", "LASSO", "Elastic Net"),col =c("black", "blue", "red", "darkgreen"), lwd =2, lty =c(1, 2, 3, 4))}
Commento
Le curve ROC dei quattro modelli sono quasi sovrapposte e si trovano vicine all’angolo in alto a sinistra, coerentemente con un’AUC di circa 0,92. Questo conferma che la logistica classica, il Ridge, il LASSO e l’Elastic Net distinguono i clienti a rischio da quelli non a rischio con la stessa capacità.
Questo blocco disegna un unico grafico con le curve ROC di quattro modelli: logistica, Ridge, LASSO ed Elastic Net.
L’idea della curva ROC: Il modello dà a ogni cliente una probabilità di rischio. Se cambi la soglia (0,1, 0,2, … 0,9), cambiano i risultati. Con una soglia bassa segnali molti clienti come a rischio: ne trovi di più, ma fai anche più falsi allarmi. Con una soglia alta succede il contrario. La curva ROC riporta tutti questi compromessi in un solo grafico:
asse y: la sensibilità, cioè la quota di clienti a rischio che trovi.
asse x: 1 − specificità, cioè la quota di clienti sicuri che classifichi male come a rischio.
Un modello migliore ha una curva più vicina all’angolo in alto a sinistra: trova molti clienti a rischio con pochi falsi allarmi.
La diagonale rappresenta un modello che tira a caso (AUC 0,5).
Le righe
{ ... }: le parentesi graffe tengono insieme tutte le righe, così R le esegue come un unico blocco.
roc(y_test, p_glm, quiet = TRUE): calcola la curva ROC confrontando la realtà (y_test) con le probabilità della logistica (p_glm). quiet = TRUE evita messaggi inutili.
plot(...): disegna la curva.
col = "black": colore della linea.
lwd = 2: spessore della linea.
legacy.axes = TRUE: mette sull’asse x 1 − specificità, da 0 a 1 in modo crescente. È il formato che si usa di solito.
main = "Curve ROC sul test set": il titolo del grafico.
plot(roc(y_test, p_ridge_min, ...), col = "blue", lwd = 2, lty = 2, add = TRUE): disegna la curva del Ridge sopra il grafico già creato. add = TRUE significa “aggiungi, non fare un nuovo grafico”. lty = 2 rende la linea tratteggiata, così si distingue dalle altre.
plot(roc(y_test, p_lasso_min, ...), col = "red", lwd = 2, lty = 3, add = TRUE): lo stesso per il LASSO, in rosso e con la linea a puntini (lty = 3).
plot(roc(y_test, p_enet_min, ...), col = "darkgreen", lwd = 2, lty = 4, add = TRUE): lo stesso per l’Elastic Net, in verde e con la linea a trattini e punti (lty = 4).
legend("bottomright", c("Logistica", "Ridge", "LASSO", "Elastic Net"), ...): aggiunge la legenda in basso a destra, dove non copre le curve.
col = c("black", "blue", "red", "darkgreen"): i colori nella legenda, nello stesso ordine dei nomi.
lwd = 2, lty = c(1, 2, 3, 4): lo spessore e il tipo di linea (continua, tratteggiata, a puntini, a trattini e punti), uguali a quelli delle curve.
Cosa aspettarti: Le quattro curve saranno praticamente sovrapposte, e la linea nera potrebbe risultare quasi coperta da quelle colorate. È normale: ha lo stesso significato dell’AUC di circa 0,92 che vedi in tabella per tutti i modelli.
10.2 Dettaglio delle curve ROC
# le quattro curve ROC principali, calcolate sullo stesso test setprincipali <-c("Logistica classica", "Ridge (lambda.min)","LASSO (lambda.min)", "Elastic Net (lambda.min)")rocs <-lapply(modelli[principali], function(p)roc(y_test, p, levels =c(0, 1), direction ="<", quiet =TRUE))colori_roc <-c("#24798C", "#B01858", "#D08B18", "#5872B4")
{# zoom sulla zona con pochi falsi allarmi (FPR tra 0 e 0.25)plot(NA, xlim =c(0, 0.25), ylim =c(0.45, 0.95),xlab ="1 - Specificità (FPR)", ylab ="Sensibilità (TPR)",main ="Zoom delle curve ROC")grid(col ="#E5E5E5")for (i inseq_along(rocs)) {lines(1- rocs[[i]]$specificities, rocs[[i]]$sensitivities,col = colori_roc[i], lwd =2.5, lty = i) }legend("bottomright", bty ="n", lwd =2.5, lty =seq_along(rocs), col = colori_roc,legend =sprintf("%s (AUC %.4f)", names(rocs),sapply(rocs, function(r) as.numeric(auc(r)))))}
Commento
Lo zoom sulla zona con pochi falsi allarmi (FPR fino a 0,25) è dove le curve avrebbero più spazio per differenziarsi, ma restano sovrapposte: anche qui i modelli regolarizzati non fanno meglio della logistica classica.
10.2.1 Spiegazione codice
principali <- c("Logistica classica", "Ridge (lambda.min)", ...): l’elenco dei quattro modelli da mostrare nel grafico (quelli con lambda.min).
rocs <- lapply(modelli[principali], function(p) roc(y_test, p, levels = c(0, 1), direction = "<", quiet = TRUE)): calcola la curva ROC di ciascun modello. lapply ripete il calcolo per ogni elemento. levels = c(0, 1) e direction = "<" dicono a roc che 0 è la classe negativa, 1 quella positiva e che probabilità più alte indicano più rischio.
colori_roc <- c(...): un colore per ogni modello.
plot(NA, xlim = c(0, 0.25), ylim = c(0.45, 0.95), ...): crea un grafico vuoto che mostra solo una parte: falsi allarmi fino al 25% e sensibilità tra 0,45 e 0,95. È lo “zoom”.
grid(col = "#E5E5E5"): aggiunge una griglia chiara di sfondo.
for (i in seq_along(rocs)) { lines(1 - rocs[[i]]$specificities, rocs[[i]]$sensitivities, ...) }: per ogni modello disegna la curva, con x = 1 − specificità e y = sensibilità. lty = i cambia il tipo di linea a ogni modello, così si distinguono anche se sovrapposte.
legend("bottomright", ..., legend = sprintf("%s (AUC %.4f)", names(rocs), sapply(rocs, function(r) as.numeric(auc(r))))): la legenda scrive per ogni modello il nome e la sua AUC con 4 decimali.
10.3 Differenza di sensibilità rispetto alla logistica
{# sensibilità di ogni modello per falsi allarmi (FPR) tra 1% e 25% fpr <-seq(0.01, 0.25, by =0.005) sens <-sapply(rocs, function(r)as.numeric(unlist(coords(r, x =1- fpr, input ="specificity", ret ="sensitivity"))))# differenza rispetto alla logistica classica, in punti percentuali altri <-setdiff(names(rocs), "Logistica classica") diff_pp <-sweep(sens[, altri, drop =FALSE], 1, sens[, "Logistica classica"], "-") *100matplot(fpr, diff_pp, type ="l", lwd =2, lty =seq_along(altri), col = colori_roc[-1],xlab ="1 - Specificità (FPR)", ylab ="Differenza di sensibilità (punti percentuali)",main ="Differenza rispetto alla logistica classica")abline(h =0, lty =2, col ="gray40") # zero = prestazioni uguali alla logisticalegend("topright", legend = altri, col = colori_roc[-1], lty =seq_along(altri), lwd =2, bty ="n")}
Commento
Il grafico mostra, per ogni livello di falsi allarmi (1 − specificità, fino al 25%), di quanti punti percentuali la sensibilità di Ridge, LASSO ed Elastic Net differisce da quella della logistica classica: sopra lo zero il modello trova più clienti a rischio, sotto lo zero ne trova meno. Ridge, LASSO ed Elastic Net oscillano tutti intorno allo zero: il Ridge resta entro circa un quarto di punto percentuale, il LASSO e l’Elastic Net entro circa tre quarti di punto (e solo nel primo tratto, con pochissimi falsi allarmi). Si tratta di frazioni di punto percentuale, cioè al massimo qualche decina di clienti su 7.500 a rischio. L’andamento irregolare delle curve è tipico del rumore campionario: senza intervalli di confidenza queste differenze non sono distinguibili dal caso. Il grafico conferma quindi quanto emerso dalle curve ROC: nella zona con pochi falsi allarmi i modelli regolarizzati non fanno meglio della logistica classica.
10.3.1 Spiegazione codice
fpr <- seq(0.01, 0.25, by = 0.005): crea la griglia dei livelli di falsi allarmi, da 1% a 25% a passi di 0,5%.
sens <- sapply(rocs, function(r) ... coords(r, x = 1 - fpr, input = "specificity", ret = "sensitivity")): per ogni modello legge dalla sua curva ROC la sensibilità in corrispondenza di ciascun livello di falsi allarmi. 1 - fpr serve perché la funzione vuole la specificità. unlist e as.numeric trasformano il risultato in numeri semplici.
altri <- setdiff(names(rocs), "Logistica classica"): l’elenco dei modelli da confrontare, cioè tutti tranne la logistica.
diff_pp <- sweep(sens[, altri, drop = FALSE], 1, sens[, "Logistica classica"], "-") * 100: sottrae a ogni modello la sensibilità della logistica, riga per riga. Moltiplicato per 100 dà punti percentuali: +0,5 significa che quel modello trova lo 0,5% in più di clienti a rischio, a parità di falsi allarmi.
matplot(fpr, diff_pp, type = "l", ...): disegna in un colpo solo una linea per modello. lty e col danno a ciascuno tipo di linea e colore diversi.
abline(h = 0, lty = 2, col = "gray40"): la linea tratteggiata a zero, cioè “prestazioni uguali alla logistica”.
legend("topright", ...): la legenda in alto a destra.
Come si legge: sopra lo zero il modello è meglio della logistica, sotto è peggio. Attenzione alla scala dell’asse y: l’asse è molto ingrandito, quindi le oscillazioni sembrano grandi ma sono frazioni di punto percentuale.
11 Quadrati e interazioni: scenario standard e scenario ampliato
Su indicazione del professore il modello viene reso più complesso, aggiungendo termini quadratici e interazioni tra variabili, comprese quelle con gender. Si confrontano quindi due specificazioni con gli stessi quattro metodi (logistica classica, Ridge, LASSO, Elastic Net), per un totale di otto modelli:
Standard: le 51 variabili originali (dummy incluse), cioè quelle usate finora.
Ampliata: le stesse variabili più quattro termini quadratici e sette interazioni.
La domanda è: i termini aggiunti migliorano la classificazione del rischio, e la regolarizzazione riesce a gestire meglio la maggiore complessità? Usiamo lo stesso training e lo stesso test per entrambe le specificazioni, così il confronto è corretto. Le interazioni con gender sono studiate solo a scopo statistico: non indicano rapporti di causa-effetto e non giustificano l’uso del genere in decisioni di credito reali.
11.1 Analisi preliminare delle variabili (solo training)
Prima di costruire i termini nuovi guardiamo, una per una, le variabili del training set. È un controllo descrittivo: non sceglie nessun modello e non usa il test.
# Tutta l'esplorazione della risposta è limitata al training.nomi_numerici <-setdiff(names(train)[vapply(train, is.numeric, logical(1))], "credit_risk")esplorazione_numeriche <-do.call(rbind, lapply(nomi_numerici, function(v) { x <- train[[v]] corr_x <-if (sd(x, na.rm =TRUE) >0) cor(x, y_train, use ="complete.obs") elseNA_real_data.frame(Variabile = v, Media =mean(x, na.rm =TRUE),Dev_standard =sd(x, na.rm =TRUE),Correlazione_con_rischio = corr_x,Pct_al_massimo =100*mean(x ==max(x, na.rm =TRUE), na.rm =TRUE) )}))esplorazione_numeriche <- esplorazione_numeriche[order(-abs(esplorazione_numeriche$Correlazione_con_rischio)), ]rownames(esplorazione_numeriche) <-NULLkable(esplorazione_numeriche, digits =3,caption ="Variabili numeriche (solo training)")
Le variabili più legate al rischio sono credit_score (correlazione −0,45), debt_to_income_ratio (+0,37), financial_stability_score (−0,34), repayment_history_score (−0,29) e missed_payment_count (+0,25): punteggio creditizio, indebitamento, stabilità finanziaria e storia dei rimborsi. Quasi tutte le altre hanno correlazioni vicine a zero. Tra le categoriche (genere, stato civile, istruzione, occupazione) la quota di clienti a rischio resta sempre intorno al 50% in ogni livello, quindi da sole non distinguono i clienti. Sono statistiche descrittive: una correlazione debole non esclude un’interazione utile, e una forte non garantisce che un’interazione migliori le previsioni.
11.1.1 Spiegazione codice
nomi_numerici <- setdiff(names(train)[vapply(train, is.numeric, logical(1))], "credit_risk"): costruisce l’elenco delle variabili numeriche del training, escludendo la risposta credit_risk. vapply(train, is.numeric, logical(1)) chiede, per ogni colonna, se è numerica (VERO o FALSO); setdiff toglie credit_risk dall’elenco.
esplorazione_numeriche <- do.call(rbind, lapply(nomi_numerici, function(v) {...})): per ogni variabile numerica calcola alcune statistiche e le incolla una sotto l’altra in una tabella. lapply ripete il blocco per ogni variabile, do.call(rbind, ...) unisce le righe.
x <- train[[v]]: prende la colonna corrente.
corr_x <- if (sd(x, na.rm = TRUE) > 0) cor(x, y_train, use = "complete.obs") else NA_real_: calcola la correlazione tra la variabile e il rischio. Se la variabile è costante (deviazione standard zero) la correlazione non esiste e si scrive NA.
data.frame(Variabile = v, Media = mean(x), Dev_standard = sd(x), Correlazione_con_rischio = r, Pct_al_massimo = ...): la riga della tabella. Pct_al_massimo è la percentuale di clienti che ha il valore massimo della variabile: serve a vedere se ci sono variabili “schiacciate” sul tetto (per esempio debt_to_income_ratio).
esplorazione_numeriche[order(-abs(...Correlazione_con_rischio)), ]: ordina le variabili dalla correlazione più forte (in valore assoluto) alla più debole.
rownames(esplorazione_numeriche) <- NULL: azzera i numeri di riga dopo l’ordinamento.
kable(esplorazione_numeriche, digits = 3, caption = ...): mostra la tabella con 3 decimali e un titolo.
nomi_categoriche <- names(train)[vapply(train, is.factor, logical(1))]: l’elenco delle variabili qualitative (fattori).
esplorazione_categoriche <- do.call(rbind, lapply(nomi_categoriche, function(v) do.call(rbind, lapply(levels(train[[v]]), function(liv) {...})))): due cicli uno dentro l’altro: per ogni variabile qualitativa e per ogni suo livello (per esempio Male e Female) costruisce una riga.
presenti <- !is.na(train[[v]]) & train[[v]] == liv: VERO per i clienti che hanno quel livello.
Clienti = sum(presenti) e Pct_rischio = 100 * mean(y_train[presenti] == 1): quanti clienti hanno quel livello e quale percentuale di essi è a rischio.
Come si legge: le correlazioni sono esplorative: una correlazione debole non esclude che un’interazione sia utile, e una correlazione forte non dimostra che lo sia.
Per rendere più intuitive le associazioni, rappresentiamo la quota di clienti a rischio nelle fasce di quattro variabili legate alla solvibilità.
{ rischio_per_fasce <-function(v, titolo) { x <- train[[v]] tagli <-unique(as.numeric(quantile(x, seq(0, 1, length.out =7), na.rm =TRUE)))if (length(tagli) <3) { valori <-tapply(y_train, x, mean)barplot(100* valori, col ="#3C8196", border =NA,las =2, main = titolo, ylab ="Clienti a rischio (%)") } else { fasce <-cut(x, breaks = tagli, include.lowest =TRUE) valori <-tapply(y_train, fasce, mean)barplot(100* valori, col ="#3C8196", border =NA,las =2, cex.names =0.7, main = titolo,ylab ="Clienti a rischio (%)") } } op <-par(mfrow =c(2, 2), mar =c(7, 4, 3, 1))for (v inc("credit_score", "financial_stability_score","repayment_history_score", "missed_payment_count")) {rischio_per_fasce(v, v) }par(op)}
Commento
Il rischio cala in modo regolare al crescere di credit_score, financial_stability_score e repayment_history_score: per il credit score passa da circa l’83% nella fascia più bassa a circa il 16% in quella più alta. Con missed_payment_count si passa dal 46% al 75% di clienti a rischio tra chi ha pochi e chi ha molti pagamenti mancati. L’andamento è sempre monotono e molto simile a una retta: questo anticipa che i quadrati, che servono a catturare una curvatura, potrebbero non aggiungere molto. Queste sono le variabili che usiamo per costruire le interazioni.
11.1.2 Spiegazione codice
rischio_per_fasce <- function(v, titolo) {: crea una funzione che, data una variabile v, disegna la percentuale di clienti a rischio in ciascuna fascia di valori.
tagli <- unique(as.numeric(quantile(x, seq(0, 1, length.out = 7), na.rm = TRUE))): calcola i valori che dividono i clienti in 6 gruppi di uguale numerosità (i quantili). unique elimina i tagli ripetuti, che capitano quando molti clienti hanno lo stesso valore.
if (length(tagli) < 3) {...} else {...}: se i tagli sono troppo pochi (variabile con pochissimi valori diversi, come missed_payment_count) si calcola la quota di rischio per ogni valore; altrimenti si dividono i clienti in fasce.
fasce <- cut(x, breaks = tagli, include.lowest = TRUE): assegna ogni cliente alla sua fascia.
valori <- tapply(y_train, fasce, mean): per ogni fascia calcola la media di y_train, cioè la proporzione di clienti a rischio (essendo 0/1, la media è una proporzione).
barplot(100 * valori, ...): disegna una barra per fascia; il 100 * trasforma la proporzione in percentuale. las = 2 ruota le etichette e cex.names le rimpicciolisce.
par(mfrow = c(2, 2), mar = c(7, 4, 3, 1)) e il ciclo for (v in c(...)): mettono i quattro grafici in una griglia 2×2 e li disegnano uno per variabile.
Come scegliamo i termini nuovi. I termini sono fissati prima di guardare il test, in base al ruolo economico delle variabili (solvibilità, indebitamento, storico dei pagamenti) e alle indicazioni del professore: la correlazione semplice serve solo a contestualizzare, non a selezionare. Non cambieremo i termini dopo aver visto i risultati sul test.
11.2 Costruzione delle due specificazioni
model.matrix() trasforma le variabili qualitative in colonne 0/1 (dummy). Per le due specificazioni usiamo gli stessi livelli e la stessa codifica.
crea_matrici <-function(formula, dati_train, dati_test) { m_train <-model.matrix(formula, data = dati_train) m_test <-model.matrix(formula, data = dati_test,contrasts.arg =attr(m_train, "contrasts")) x_train <- m_train[, -1, drop =FALSE] # intercetta esclusa: glmnet la gestisce da sé x_test <- m_test[, -1, drop =FALSE]stopifnot(identical(colnames(x_train), colnames(x_test)))list(train = x_train, test = x_test)}formula_standard <- credit_risk ~ .mat_standard <-crea_matrici(formula_standard, train, test)
11.2.1 Spiegazione codice
crea_matrici <- function(formula, dati_train, dati_test) {: crea una funzione che costruisce le matrici per glmnet a partire da una formula, per training e test insieme.
m_train <- model.matrix(formula, data = dati_train): matrice del training, con le dummy.
m_test <- model.matrix(formula, data = dati_test, contrasts.arg = attr(m_train, "contrasts")): matrice del test costruita con la stessa codifica del training. contrasts.arg evita che una categoria venga codificata in modo diverso nei due insiemi.
x_train <- m_train[, -1, drop = FALSE] e x_test <- m_test[, -1, drop = FALSE]: tolgono la prima colonna, cioè l’intercetta, perché glmnet la aggiunge da solo.
stopifnot(identical(colnames(x_train), colnames(x_test))): controllo di sicurezza: si ferma con un errore se training e test non hanno le stesse colonne nello stesso ordine.
list(train = x_train, test = x_test): restituisce le due matrici.
formula_standard <- credit_risk ~ .: la formula “tutte le variabili”, cioè lo scenario standard.
mat_standard <- crea_matrici(formula_standard, train, test): applica la funzione e salva il risultato.
11.3 Variabili della specificazione ampliata
Manteniamo tutti i predittori della specificazione standard e aggiungiamo quattro termini quadratici e sette interazioni. La specificazione è più flessibile ma ha più coefficienti da stimare.
Nuovo termine
Domanda statistica
I(age^2)
L’età ha una relazione curva con il logit del rischio?
I(credit_score^2)
La relazione del punteggio creditizio con il rischio è curva?
I(debt_to_income_ratio^2)
L’indebitamento relativo ha una relazione non lineare?
I(financial_stability_score^2)
La stabilità finanziaria ha una relazione non lineare?
credit_score:missed_payment_count
L’effetto del credit score cambia con i pagamenti mancati?
financial_stability_score:debt_to_income_ratio
Stabilità e indebitamento hanno un effetto combinato?
credit_score:repayment_history_score
L’effetto del credit score cambia con la storia dei rimborsi?
credit_score:debt_to_income_ratio
L’effetto del credit score cambia con il rapporto debito/reddito?
gender:credit_score
L’effetto del credit score sul rischio cambia con il genere?
gender:annual_income
L’effetto del reddito sul rischio cambia con il genere?
gender:debt_to_income_ratio
L’effetto dell’indebitamento sul rischio cambia con il genere?
Le variabili numeriche coinvolte vengono standardizzate con media e deviazione standard del solo training; sul test si riusano gli stessi parametri. In questo modo quadrati e prodotti sono calcolati su scale confrontabili e non c’è data leakage. glmnet applica poi la propria standardizzazione interna.
Stessi clienti, specificazioni con complessità diversa
Specificazione
Clienti_training
Clienti_test
Colonne_predittive
Standard
35000
15000
51
Ampliata
35000
15000
62
Commento
Il numero di clienti resta lo stesso (35.000 nel training, 15.000 nel test): cambia solo il numero di colonne, che passa da 51 a 62 (11 termini aggiunti). L’operatore : crea il prodotto tra due variabili e I(x^2) il quadrato. Gli effetti principali restano nel modello grazie a credit_risk ~ .. Le variabili sono standardizzate con media e deviazione standard del solo training, e gli stessi valori sono applicati al test, così non ci sono informazioni del test nella stima. L’ampliamento non è scelto per ottenere un’AUC più alta: viene sottoposto a verifica.
11.3.1 Spiegazione codice
variabili_z <- c("age", "annual_income", ...): l’elenco delle variabili numeriche che entrano nei termini nuovi e che quindi si standardizzano.
stopifnot(all(variabili_z %in% names(train)), all(vapply(train[variabili_z], is.numeric, logical(1)))): controllo di sicurezza: si ferma se qualche nome non esiste o non è numerico.
medie <- vapply(train[variabili_z], mean, numeric(1)) e deviazioni <- vapply(train[variabili_z], sd, numeric(1)): media e deviazione standard di ciascuna variabile, calcolate solo sul training.
stopifnot(all(is.finite(deviazioni)), all(deviazioni > 0)): si ferma se una deviazione standard è zero (non si può dividere per zero).
prepara_ampliata <- function(df) {...}: crea una funzione che standardizza le variabili di un data frame con la formula (valore - media) / deviazione standard, usando le medie e le deviazioni del training.
train_amp <- prepara_ampliata(train) e test_amp <- prepara_ampliata(test): applicano la stessa trasformazione a training e test. Il test non ricalcola le proprie medie.
formula_ampliata <- credit_risk ~ . + I(age^2) + ...: la formula “tutte le variabili” più i termini nuovi. I(x^2) dice a R di calcolare davvero il quadrato; l’operatore : costruisce il prodotto tra due variabili (interazione). Gli effetti principali restano nel modello grazie al ..
mat_ampliata <- crea_matrici(formula_ampliata, train_amp, test_amp): costruisce le matrici della specificazione ampliata.
matrici <- list(Standard = mat_standard, Ampliata = mat_ampliata): le raccoglie in un’unica lista, per poterle scorrere con un ciclo.
kable(data.frame(Specificazione = names(matrici), Clienti_training = ..., Colonne_predittive = ...)): tabella con il numero di clienti e di colonne di ciascuna specificazione.
11.4 Stima degli otto modelli
La logistica classica stima i coefficienti senza penalità. Ridge li contrae, LASSO può azzerarne alcuni, Elastic Net (alpha = 0.5) combina i due effetti. Per i modelli penalizzati scegliamo \(\lambda\) con una cross-validation a 10 parti sul training. I fold sono stratificati e identici per tutti i modelli e per le due specificazioni, così le differenze non dipendono da una diversa suddivisione interna.
set.seed(123)foldid <-integer(length(y_train))for (classe inc(0, 1)) { ind <-which(y_train == classe) foldid[ind] <-sample(rep(1:10, length.out =length(ind)))}stima_penalizzati <-function(x, y) { tipi <-c(Ridge =0, LASSO =1, `Elastic Net`=0.5)lapply(tipi, function(alpha_val) {cv.glmnet(x, y, family ="binomial", alpha = alpha_val,foldid = foldid, type.measure ="auc",lambda.min.ratio =if (alpha_val ==0) 1e-7else1e-4) })}modelli_glm <-list(Standard =glm(formula_standard, data = train, family =binomial()),Ampliata =glm(formula_ampliata, data = train_amp, family =binomial()))modelli_cv <-list(Standard =stima_penalizzati(mat_standard$train, y_train),Ampliata =stima_penalizzati(mat_ampliata$train, y_train))
Commento
Non c’è nessun risultato da leggere in questo blocco: stima i modelli, che usiamo nelle sezioni successive. I fold della cross-validation sono stratificati e identici per tutti i modelli e per le due specificazioni, quindi le differenze non dipendono da una diversa suddivisione dei dati. lambda.min è il λ con la migliore AUC media in cross-validation; lambda.1se penalizza di più e dà modelli più semplici, purché l’AUC resti entro un errore standard dalla migliore.
11.4.1 Spiegazione codice
set.seed(123): fissa il caso, così i fold sono sempre gli stessi.
foldid <- integer(length(y_train)): prepara un vettore vuoto, lungo quanto il training, che conterrà per ogni cliente il numero del suo fold (da 1 a 10).
for (classe in c(0, 1)) {...}: ripete le istruzioni una volta per classe.
ind <- which(y_train == classe): le posizioni dei clienti di quella classe.
foldid[ind] <- sample(rep(1:10, length.out = length(ind))): assegna ai clienti di quella classe i numeri da 1 a 10, ripetuti in modo equilibrato e mescolati a caso (rep ripete, sample mescola). Facendolo separatamente per classe, ogni fold ha circa la stessa proporzione di clienti a rischio: è una cross-validation stratificata.
stima_penalizzati <- function(x, y) {...}: funzione che stima Ridge, LASSO ed Elastic Net su una matrice x con risposte y.
tipi <- c(Ridge = 0, LASSO = 1,Elastic Net= 0.5): i tre valori di alpha, con il nome del modello.
lapply(tipi, function(alpha_val) {cv.glmnet(...)}): stima un modello per ciascun alpha.
cv.glmnet(x, y, family = "binomial", alpha = alpha_val, foldid = foldid, type.measure = "auc", ...): come nelle sezioni precedenti, ma con foldid, che dice a glmnet di usare i nostri fold invece di crearne di casuali.
lambda.min.ratio = if (alpha_val == 0) 1e-7 else 1e-4: per il Ridge allarga la griglia dei \(\lambda\) verso valori molto piccoli, perché il Ridge sceglie penalizzazioni minuscole che altrimenti cadrebbero sul bordo della griglia. Per LASSO ed Elastic Net è il valore di default.
modelli_glm <- list(Standard = glm(formula_standard, data = train, family = binomial()), Ampliata = glm(formula_ampliata, data = train_amp, family = binomial())): stima le due logistiche classiche, una per specificazione. La seconda usa train_amp, cioè il training standardizzato.
modelli_cv <- list(Standard = stima_penalizzati(...), Ampliata = stima_penalizzati(...)): stima i sei modelli penalizzati (tre per specificazione).
Che cosa sono i due\(\lambda\)? lambda.min è quello con la migliore AUC media in cross-validation. lambda.1se usa una penalizzazione più forte, purché la prestazione resti entro un errore standard dalla migliore: favorisce modelli più semplici.
Nota: i modelli della specificazione standard sono gli stessi delle sezioni precedenti, ristimati con questi fold fissi. I risultati sono praticamente identici, e ora il confronto con la specificazione ampliata avviene a parità di fold.
11.5 Cross-validation: grafici delle due specificazioni
# Funzione comune per rappresentare i tre modelli penalizzati.disegna_cv_leggibile <-function(spec) { op <-par(mfrow =c(1, 3), mar =c(4.3, 4.1, 2.7, 0.8),oma =c(0, 0, 2.0, 0))for (nome innames(modelli_cv[[spec]])) { cv <- modelli_cv[[spec]][[nome]] x <--log(cv$lambda) ordinati <-order(x) lim_y <-range(c(cv$cvlo, cv$cvup), finite =TRUE) estensione <-max(0.015, diff(lim_y) *0.06) lim_y <-c(max(0, lim_y[1] - estensione),min(1, lim_y[2] + estensione))plot(x, cv$cvm, type ="n", ylim = lim_y,xlab =expression(-log(lambda)), ylab ="AUC media (CV)",main = nome, cex.main =1.05, cex.lab =0.9)polygon(c(x[ordinati], rev(x[ordinati])),c(cv$cvlo[ordinati], rev(cv$cvup[ordinati])),col = grDevices::adjustcolor("#B3C6CC", alpha.f =0.40), border =NA)lines(x[ordinati], cv$cvm[ordinati], col ="#B13F47", lwd =2.3)abline(v =-log(cv$lambda.min), lty =2, lwd =2, col ="#213E5B")abline(v =-log(cv$lambda.1se), lty =3, lwd =2, col ="#168C83") }mtext(paste("Cross-validation —", spec), outer =TRUE,side =3, line =0.3, cex =1.12, font =2)par(op)}
disegna_cv_leggibile("Standard")
disegna_cv_leggibile("Ampliata")
Commento
La linea rossa è l’AUC media in cross-validation, la fascia grigia ne rappresenta l’incertezza. Sull’asse orizzontale c’è −log(λ): andando verso destra λ diminuisce e la penalizzazione si indebolisce. La curva sale subito e poi diventa piatta, sia nella versione standard sia in quella ampliata: oltre un certo punto aggiungere flessibilità non migliora la previsione. Le linee tratteggiata e punteggiata indicano lambda.min e lambda.1se; la differenza di AUC tra i due punti è molto piccola.
11.5.1 Spiegazione codice
disegna_cv_leggibile <- function(spec) {: crea una funzione che disegna, per una specificazione ("Standard" o "Ampliata"), la curva di cross-validation dei tre modelli penalizzati.
par(mfrow = c(1, 3), mar = ..., oma = c(0, 0, 2.0, 0)): mette i tre grafici in una riga e lascia uno spazio in alto per il titolo comune. op salva le impostazioni di prima.
for (nome in names(modelli_cv[[spec]])) {...}: ripete il disegno per Ridge, LASSO ed Elastic Net.
x <- -log(cv$lambda) e ordinati <- order(x): calcola l’asse orizzontale come \(-\log(\lambda)\) (a destra la penalizzazione diminuisce) e l’ordine per disegnare le linee senza intrecci.
lim_y <- range(c(cv$cvlo, cv$cvup), finite = TRUE) e le due righe dopo: calcolano i limiti dell’asse verticale in base ai valori reali di ciascun grafico, con un piccolo margine, in modo che la curva sia ben leggibile.
plot(x, cv$cvm, type = "n", ...): crea il grafico vuoto con gli assi e il titolo (il nome del modello).
polygon(...): la fascia grigia, cioè l’errore standard della cross-validation (cvlo e cvup sono il limite inferiore e superiore).
lines(x[ordinati], cv$cvm[ordinati], ...): la linea rossa con l’AUC media per ogni \(\lambda\).
abline(v = -log(cv$lambda.min), lty = 2, ...) e abline(v = -log(cv$lambda.1se), lty = 3, ...): le due linee verticali per lambda.min (blu scuro, tratteggio lungo) e lambda.1se (verde, a puntini).
mtext(paste("Cross-validation —", spec), outer = TRUE, ...): il titolo comune sopra i tre grafici.
disegna_cv_leggibile("Standard") e disegna_cv_leggibile("Ampliata"): disegnano le due figure.
Come si legge: la linea rossa è l’AUC media in cross-validation e la fascia grigia l’incertezza. Verso destra \(\lambda\) diminuisce e la penalizzazione si indebolisce. Le due linee verticali indicano lambda.min e lambda.1se; il numero di coefficienti non nulli è nella tabella successiva.
# Confronto visivo della selezione: lambda.1se.selezione <-xtabs(Coeff_1se ~ Specificazione + Modello, data = tabella_lambda)barplot(selezione, beside =TRUE, col =c("#3C8196", "#B75B75"),las =2, ylab ="Coefficienti non nulli (lambda.1se)",main ="Semplificazione dei modelli", legend.text =rownames(selezione),args.legend =list(x ="topright", bty ="n"))
Commento
Il Ridge mantiene sempre tutte le variabili (51 nella standard, 62 nell’ampliata), perché riduce i coefficienti senza azzerarli. Il LASSO con lambda.min ne tiene 34 (standard) e 36 (ampliata), con lambda.1se solo 10 in entrambe. L’Elastic Net ne tiene 37 e 42 con lambda.min, 11 e 16 con lambda.1se. Quindi, pur avendo 11 colonne in più, il LASSO con lambda.1se usa lo stesso numero di variabili (10): la regolarizzazione tiene sotto controllo la maggiore complessità.
11.6.1 Spiegazione codice
coefficienti_non_nulli <- function(modello, lambda) { sum(as.matrix(coef(modello, s = lambda))[-1, 1] != 0) }: funzione che conta i coefficienti diversi da zero. coef(modello, s = lambda) prende i coefficienti al \(\lambda\) scelto, [-1, 1] toglie l’intercetta, != 0 controlla quali sono diversi da zero e sum li conta.
tabella_lambda <- do.call(rbind, lapply(names(modelli_cv), function(spec) {...})): costruisce la tabella ripetendo il calcolo per ogni specificazione e, dentro, per ogni modello.
data.frame(Specificazione = spec, Modello = nome, Lambda_min = cv$lambda.min, Coeff_min = ..., Lambda_1se = cv$lambda.1se, Coeff_1se = ..., Predittori_totali = ...): una riga per modello con i due \(\lambda\), quanti coefficienti restano con ciascuno e quanti predittori c’erano in tutto.
kable(tabella_lambda, digits = 4, caption = ...): mostra la tabella.
selezione <- xtabs(Coeff_1se ~ Specificazione + Modello, data = tabella_lambda): riorganizza i numeri di Coeff_1se in una tabella con le specificazioni sulle righe e i modelli sulle colonne, pronta per il grafico.
barplot(selezione, beside = TRUE, ...): disegna, per ogni modello, due barre affiancate (una per specificazione) con i coefficienti rimasti con lambda.1se. legend.text e args.legend aggiungono la legenda in alto a destra.
11.7 Quali termini quadratici e interazioni conservano LASSO ed Elastic Net?
Il conteggio dice quanto è complesso il modello, ma non quali nuovi termini siano usati. Guardiamo quindi, per i soli termini aggiunti, se LASSO ed Elastic Net li tengono (coefficiente diverso da zero) con lambda.min e con lambda.1se.
Termini aggiunti selezionati nei modelli penalizzati (specificazione ampliata)
Termine
Tipo
LASSO_min
LASSO_1se
ElasticNet_min
ElasticNet_1se
I(age^2)
Quadratico
No
No
Sì
No
I(credit_score^2)
Quadratico
No
No
No
No
I(debt_to_income_ratio^2)
Quadratico
No
No
Sì
Sì
I(financial_stability_score^2)
Quadratico
Sì
No
Sì
No
credit_score:missed_payment_count
Altra interazione
No
No
No
No
debt_to_income_ratio:financial_stability_score
Altra interazione
No
No
No
No
credit_score:repayment_history_score
Altra interazione
No
No
No
No
credit_score:debt_to_income_ratio
Altra interazione
Sì
No
Sì
Sì
genderMale:credit_score
Interazione con gender
Sì
No
Sì
Sì
genderMale:annual_income
Interazione con gender
No
No
No
No
genderMale:debt_to_income_ratio
Interazione con gender
No
No
No
Sì
riepilogo_termini <-data.frame(Configurazione =c("LASSO — lambda.min", "LASSO — lambda.1se","Elastic Net — lambda.min", "Elastic Net — lambda.1se"),Termini_aggiunti_mantenuti =c(sum(beta_lasso_min !=0), sum(beta_lasso_1se !=0),sum(beta_enet_min !=0), sum(beta_enet_1se !=0)),Termini_aggiunti_totali =length(nuove_colonne))kable(riepilogo_termini,caption ="Quanti termini aggiuntivi rimangono dopo la penalizzazione?")
Quanti termini aggiuntivi rimangono dopo la penalizzazione?
Configurazione
Termini_aggiunti_mantenuti
Termini_aggiunti_totali
LASSO — lambda.min
3
11
LASSO — lambda.1se
0
11
Elastic Net — lambda.min
5
11
Elastic Net — lambda.1se
4
11
barplot(riepilogo_termini$Termini_aggiunti_mantenuti,names.arg = riepilogo_termini$Configurazione,col =c("#3C8196", "#3C8196", "#B75B75", "#B75B75"),border =NA, las =2, cex.names =0.75,ylim =c(0, max(2, length(nuove_colonne))),ylab ="Nuovi termini con coefficiente non nullo",main ="Selezione di quadrati e interazioni")
Commento
Sì indica che il coefficiente del termine aggiunto è diverso da zero. Con lambda.1se il LASSO elimina tutti gli 11 termini aggiunti; con lambda.min ne tiene 3 (I(financial_stability_score^2), credit_score:debt_to_income_ratio e genderMale:credit_score). L’Elastic Net, più permissivo, ne tiene 5 con lambda.min e 4 con lambda.1se. I termini che sopravvivono sono pochi e cambiano da un metodo all’altro, segno che non portano un’informazione stabile. La selezione è un risultato del modello e non prova causalità né assenza assoluta di relazione; può cambiare con campioni diversi.
11.7.1 Spiegazione codice
nuove_colonne <- setdiff(colnames(mat_ampliata$train), colnames(mat_standard$train)): l’elenco dei nomi delle colonne presenti nella specificazione ampliata e assenti nella standard, cioè i termini nuovi.
estrai_beta <- function(nome, scelta) {...}: funzione che, dato un modello ("LASSO" o "Elastic Net") e la scelta di \(\lambda\), restituisce i coefficienti dei soli termini nuovi.
beta <- as.matrix(coef(modelli_cv$Ampliata[[nome]], s = scelta)): tutti i coefficienti del modello ampliato a quel \(\lambda\).
stopifnot(all(nuove_colonne %in% rownames(beta))): controllo di sicurezza: si ferma se un termine nuovo non compare tra i coefficienti.
as.numeric(beta[nuove_colonne, 1]): prende solo le righe dei termini nuovi, come semplice elenco di numeri.
beta_lasso_min <- estrai_beta("LASSO", "lambda.min") e le tre righe dopo: i coefficienti dei termini nuovi per LASSO ed Elastic Net, con i due \(\lambda\).
tipo_termini <- ifelse(grepl("^I\\(", nuove_colonne), "Quadratico", ifelse(grepl("gender", ...), "Interazione con gender", "Altra interazione")): classifica ogni termine. I nomi che iniziano con I( sono quadrati; quelli che contengono gender sono interazioni con il genere; gli altri sono le interazioni tra variabili di credito. grepl cerca un pezzo di testo dentro un nome.
tabella_selezione <- data.frame(Termine = ..., Tipo = ..., LASSO_min = ifelse(beta_lasso_min != 0, "Sì", "No"), ...): per ogni termine scrive Sì se il coefficiente è diverso da zero (il termine è tenuto) e No se è stato azzerato.
riepilogo_termini <- data.frame(Configurazione = ..., Termini_aggiunti_mantenuti = c(sum(beta_lasso_min != 0), ...), Termini_aggiunti_totali = length(nuove_colonne)): conta quanti termini nuovi restano in ciascuna configurazione.
barplot(riepilogo_termini$Termini_aggiunti_mantenuti, names.arg = ..., ...): disegna il conteggio come grafico a barre.
Attenzione: un coefficiente diverso da zero non prova che il termine sia importante, e la selezione può cambiare con un altro campione. I coefficienti di LASSO ed Elastic Net non hanno i p-value della logistica classica, perché sono stimati con un criterio diverso.
11.8 P-value dei termini nuovi nella logistica ampliata
La logistica classica stima i coefficienti per massima verosimiglianza. summary(glm(...)) dà per ogni coefficiente la stima, l’errore standard, la statistica \(z\) e il p-value di Wald. Per ogni termine nuovo ci chiediamo: il coefficiente è diverso da zero, una volta considerate le altre variabili? Usiamo il livello del 5%.
# Nomi delle nuove colonne prodotte da model.matrix: stessi nomi nel GLM.coefficienti_glm <-summary(modelli_glm$Ampliata)$coefficients# Se qualche coefficiente non è stimabile per collinearità perfetta,# lo manteniamo nella tabella con NA anziché interrompere il rendering.valori_nuovi <-matrix(NA_real_, nrow =length(nuove_colonne),ncol =ncol(coefficienti_glm),dimnames =list(nuove_colonne, colnames(coefficienti_glm)))presenti <-intersect(nuove_colonne, rownames(coefficienti_glm))valori_nuovi[presenti, ] <- coefficienti_glm[presenti, , drop =FALSE]p_nuovi <- valori_nuovi[, "Pr(>|z|)"]pvalue_nuovi <-data.frame(Termine = nuove_colonne,Tipo = tipo_termini,Beta_stimato = valori_nuovi[, "Estimate"],Errore_standard = valori_nuovi[, "Std. Error"],Statistica_z = valori_nuovi[, "z value"],P_value = p_nuovi,Significativo_5pct =ifelse(is.na(p_nuovi), "Non valutabile", ifelse(p_nuovi <0.05, "Sì", "No") ),row.names =NULL)kable(pvalue_nuovi, digits =4,caption ="Regressione logistica ampliata: coefficienti e p-value dei termini aggiunti")
Regressione logistica ampliata: coefficienti e p-value dei termini aggiunti
Termine
Tipo
Beta_stimato
Errore_standard
Statistica_z
P_value
Significativo_5pct
I(age^2)
Quadratico
0.0090
0.0133
0.6766
0.4987
No
I(credit_score^2)
Quadratico
0.0021
0.0221
0.0948
0.9245
No
I(debt_to_income_ratio^2)
Quadratico
-0.0093
0.0331
-0.2813
0.7784
No
I(financial_stability_score^2)
Quadratico
0.0367
0.0165
2.2216
0.0263
Sì
credit_score:missed_payment_count
Altra interazione
-0.0076
0.0299
-0.2549
0.7988
No
debt_to_income_ratio:financial_stability_score
Altra interazione
0.0071
0.0301
0.2352
0.8141
No
credit_score:repayment_history_score
Altra interazione
0.0124
0.0308
0.4021
0.6876
No
credit_score:debt_to_income_ratio
Altra interazione
-0.0090
0.0354
-0.2549
0.7988
No
genderMale:credit_score
Interazione con gender
-0.0165
0.0419
-0.3933
0.6941
No
genderMale:annual_income
Interazione con gender
0.0050
0.0324
0.1549
0.8769
No
genderMale:debt_to_income_ratio
Interazione con gender
-0.0586
0.0523
-1.1212
0.2622
No
kable(data.frame(Termini_aggiunti =nrow(pvalue_nuovi),Significativi_al_5pct =sum(pvalue_nuovi$Significativo_5pct =="Sì"),Non_significativi =sum(pvalue_nuovi$Significativo_5pct =="No")), caption ="Sintesi della significatività dei termini aggiunti")
Sintesi della significatività dei termini aggiunti
Termini_aggiunti
Significativi_al_5pct
Non_significativi
11
1
10
# Test del rapporto di verosimiglianza: i termini aggiunti, insieme, migliorano il modello?confronto_AB <-anova(modelli_glm$Standard, modelli_glm$Ampliata, test ="Chisq")
Commento
Su 11 termini aggiunti, solo I(financial_stability_score^2) ha un p-value sotto 0,05 (0,026), con un coefficiente positivo. Gli altri 10 hanno p-value tra 0,26 e 0,92, anche le tre interazioni con gender. Con 11 test, trovare un p-value appena sotto 0,05 per puro caso è plausibile (con 11 test indipendenti la probabilità di almeno uno sotto 0,05 è circa il 43%), quindi questo risultato va letto con prudenza e non come prova di una vera curvatura. Il coefficiente è sul logit, non sulla probabilità. I p-value valgono solo per la logistica: non si attribuiscono a LASSO ed Elastic Net, che stimano i coefficienti con un criterio diverso.
11.8.1 Spiegazione codice
coefficienti_glm <- summary(modelli_glm$Ampliata)$coefficients: la tabella dei coefficienti della logistica ampliata (stima, errore standard, \(z\), p-value).
valori_nuovi <- matrix(NA_real_, nrow = length(nuove_colonne), ncol = ncol(coefficienti_glm), dimnames = ...): prepara una tabella vuota (piena di NA) con una riga per termine nuovo. Serve perché, se per collinearità perfetta R non riuscisse a stimare un coefficiente, il documento non si interrompe e il termine compare con NA.
presenti <- intersect(nuove_colonne, rownames(coefficienti_glm)): i termini nuovi effettivamente stimati.
valori_nuovi[presenti, ] <- coefficienti_glm[presenti, , drop = FALSE]: copia nella tabella vuota i valori dei termini stimati.
p_nuovi <- valori_nuovi[, "Pr(>|z|)"]: estrae la colonna dei p-value.
pvalue_nuovi <- data.frame(Termine = ..., Tipo = ..., Beta_stimato = ..., Errore_standard = ..., Statistica_z = ..., P_value = p_nuovi, Significativo_5pct = ifelse(...)): costruisce la tabella finale. L’ultima colonna scrive Sì se il p-value è sotto 0,05, No se è sopra, Non valutabile se manca.
kable(data.frame(Termini_aggiunti = ..., Significativi_al_5pct = sum(... == "Sì"), Non_significativi = sum(... == "No"))): riassume quanti termini sono significativi.
confronto_AB <- anova(modelli_glm$Standard, modelli_glm$Ampliata, test = "Chisq"): test del rapporto di verosimiglianza. Confronta la logistica standard con quella ampliata (una è contenuta nell’altra) e chiede se la devianza scende abbastanza da giustificare i parametri in più. È un test unico sull’insieme dei termini aggiunti, più adatto dei singoli p-value quando i termini sono molti.
Come si legge:Beta_stimato è il coefficiente sul logit, non una variazione diretta della probabilità. Con più termini testati, qualche p-value appena sotto 0,05 può comparire per caso (con 11 termini, uno ogni tanto è atteso): va letto con prudenza.
11.9 Valutazione sul test set
Confrontiamo gli otto modelli (quattro metodi × due specificazioni) con lambda.min per i modelli penalizzati. La soglia è 0,50; l’AUC non dipende dalla soglia.
# Probabilità per ogni cliente del test; nessun modello è riaddestrato sul test.previsioni <-list()for (spec innames(matrici)) { dati_test <-if (spec =="Standard") test else test_amp p <-list(Logistica =as.numeric(predict(modelli_glm[[spec]],newdata = dati_test, type ="response")))for (nome innames(modelli_cv[[spec]])) { p[[nome]] <-as.numeric(predict(modelli_cv[[spec]][[nome]],newx = matrici[[spec]]$test,s ="lambda.min", type ="response")) } previsioni[[spec]] <- p}valuta8 <-function(p, y = y_test, soglia =0.50) { pred <-as.integer(p > soglia) TP <-sum(y ==1& pred ==1); TN <-sum(y ==0& pred ==0) FP <-sum(y ==0& pred ==1); FN <-sum(y ==1& pred ==0) precisione <-if ((TP + FP) >0) TP / (TP + FP) else0 recall <-if ((TP + FN) >0) TP / (TP + FN) else0 f1 <-if ((precisione + recall) >0) {2* precisione * recall / (precisione + recall) } else0c(Accuratezza = (TP + TN) /length(y),Recall = recall, Specificita = TN / (TN + FP),Precisione = precisione, F1 = f1,AUC =as.numeric(auc(roc(y, p, levels =c(0, 1),direction ="<", quiet =TRUE))))}tabella_performance <-do.call(rbind, lapply(names(previsioni), function(spec) {do.call(rbind, lapply(names(previsioni[[spec]]), function(nome) {data.frame(Specificazione = spec, Modello = nome,as.list(valuta8(previsioni[[spec]][[nome]])), check.names =FALSE) }))}))rownames(tabella_performance) <-NULLkable(tabella_performance, digits =4,caption ="Performance finali su 15.000 clienti del test set")
Performance finali su 15.000 clienti del test set
Specificazione
Modello
Accuratezza
Recall
Specificita
Precisione
F1
AUC
Standard
Logistica
0.8370
0.8411
0.8329
0.8343
0.8377
0.9228
Standard
Ridge
0.8374
0.8416
0.8332
0.8346
0.8381
0.9229
Standard
LASSO
0.8363
0.8411
0.8315
0.8331
0.8370
0.9229
Standard
Elastic Net
0.8361
0.8411
0.8311
0.8327
0.8369
0.9229
Ampliata
Logistica
0.8357
0.8396
0.8319
0.8332
0.8364
0.9228
Ampliata
Ridge
0.8361
0.8401
0.8321
0.8335
0.8368
0.9228
Ampliata
LASSO
0.8363
0.8408
0.8319
0.8334
0.8371
0.9228
Ampliata
Elastic Net
0.8360
0.8401
0.8319
0.8332
0.8367
0.9228
Commento
Le otto AUC sono praticamente uguali: 0,9228 per la logistica, 0,9229 per gli altri tre metodi nella versione standard, 0,9228 per tutti i modelli nella versione ampliata. Anche accuratezza (tra 0,836 e 0,837), recall, specificità, precisione e F1 sono quasi identiche. Con soglia 0,5 la versione ampliata ha addirittura accuratezza e F1 leggermente più bassi (0,836 contro 0,837). Quindi quadrati e interazioni non migliorano la classificazione e anche la regolarizzazione cambia pochissimo, perché 35.000 clienti sono tanti rispetto alle variabili.
11.9.1 Spiegazione codice
previsioni <- list(): crea un contenitore vuoto per le probabilità di tutti i modelli.
for (spec in names(matrici)) {...}: ripete le istruzioni per le due specificazioni.
dati_test <- if (spec == "Standard") test else test_amp: sceglie il test giusto: quello originale per la standard, quello standardizzato per l’ampliata.
p <- list(Logistica = as.numeric(predict(modelli_glm[[spec]], newdata = dati_test, type = "response"))): calcola le probabilità previste dalla logistica classica sul test. type = "response" chiede probabilità tra 0 e 1.
for (nome in names(modelli_cv[[spec]])) { p[[nome]] <- as.numeric(predict(modelli_cv[[spec]][[nome]], newx = matrici[[spec]]$test, s = "lambda.min", type = "response")) }: lo stesso per Ridge, LASSO ed Elastic Net, usando lambda.min.
previsioni[[spec]] <- p: salva le previsioni della specificazione.
valuta8 <- function(p, y = y_test, soglia = 0.50) {...}: funzione che, date le probabilità, calcola le metriche di classificazione. È la stessa idea della funzione valuta vista prima, qui con il nome Recall al posto di Sensibilita.
pred <- as.integer(p > soglia): trasforma le probabilità in decisioni 0/1.
TP <- ...; TN <- ...; FP <- ...; FN <- ...: contano le quattro caselle della matrice di confusione (veri positivi, veri negativi, falsi positivi, falsi negativi).
precisione <- if ((TP + FP) > 0) TP / (TP + FP) else 0 e recall <- if ((TP + FN) > 0) TP / (TP + FN) else 0: precisione e recall, con una protezione contro la divisione per zero.
f1 <- ...: media armonica di precisione e recall, alta solo se lo sono entrambe.
c(Accuratezza = ..., Recall = ..., Specificita = ..., Precisione = ..., F1 = ..., AUC = ...): raccoglie tutte le metriche. L’AUC si calcola con roc e auc e non dipende dalla soglia.
tabella_performance <- do.call(rbind, lapply(names(previsioni), function(spec) {...})): applica valuta8 a ciascuno degli otto modelli e incolla le righe una sotto l’altra.
Le metriche in parole semplici: accuratezza = quota di classificazioni corrette; recall = quota di clienti a rischio riconosciuti; specificità = quota di clienti non a rischio riconosciuti; precisione = tra i segnalati a rischio, quanti lo sono davvero; F1 = sintesi di recall e precisione; AUC = capacità di distinguere le due classi considerando tutte le soglie.
11.9.2 Verifica della parsimonia: lambda.min contro lambda.1se
Nei grafici e nella tabella dei coefficienti lambda.1se rende LASSO ed Elastic Net più semplici, ma la tabella precedente valuta solo lambda.min. Per capire quanto si perde in capacità previsiva con il modello più semplice, calcoliamo le previsioni sullo stesso test anche con lambda.1se. Non si ristima nulla e non si cambia\(\lambda\) guardando il test: entrambi i valori sono già stati scelti con la cross-validation sul training.
# Confronto sul test di lambda.min e lambda.1se per ciascun metodo penalizzato.confronto_lambda <-do.call(rbind, lapply(names(modelli_cv), function(spec) {do.call(rbind, lapply(names(modelli_cv[[spec]]), function(nome) { cv <- modelli_cv[[spec]][[nome]] x_te <- matrici[[spec]]$test# Due previsioni sullo STESSO test, usando lo STESSO modello stimato. p_min <-as.numeric(predict(cv, newx = x_te, s ="lambda.min", type ="response")) p_1se <-as.numeric(predict(cv, newx = x_te, s ="lambda.1se", type ="response")) metriche_min <-valuta8(p_min) metriche_1se <-valuta8(p_1se) corretti_min <-sum(as.integer(p_min >0.50) == y_test) corretti_1se <-sum(as.integer(p_1se >0.50) == y_test)data.frame(Specificazione = spec,Modello = nome,Coeff_min =coefficienti_non_nulli(cv, "lambda.min"),Coeff_1se =coefficienti_non_nulli(cv, "lambda.1se"),AUC_min =unname(metriche_min["AUC"]),AUC_1se =unname(metriche_1se["AUC"]),Delta_AUC =unname(metriche_1se["AUC"] - metriche_min["AUC"]),Accuratezza_min =unname(metriche_min["Accuratezza"]),Accuratezza_1se =unname(metriche_1se["Accuratezza"]),F1_min =unname(metriche_min["F1"]),F1_1se =unname(metriche_1se["F1"]),Corretti_min = corretti_min,Corretti_1se = corretti_1se,Delta_corretti = corretti_1se - corretti_min ) }))}))rownames(confronto_lambda) <-NULL# Prima tabella: quanto si riduce il numero dei coefficienti? E l'AUC?kable(confronto_lambda[, c("Specificazione", "Modello", "Coeff_min", "Coeff_1se","AUC_min", "AUC_1se", "Delta_AUC")],digits =5, caption ="Parsimonia e AUC sul test: lambda.min vs lambda.1se")
Parsimonia e AUC sul test: lambda.min vs lambda.1se
Specificazione
Modello
Coeff_min
Coeff_1se
AUC_min
AUC_1se
Delta_AUC
Standard
Ridge
51
51
0.92287
0.92214
-0.00072
Standard
LASSO
34
10
0.92287
0.92094
-0.00193
Standard
Elastic Net
37
11
0.92288
0.92117
-0.00171
Ampliata
Ridge
62
62
0.92279
0.92147
-0.00131
Ampliata
LASSO
36
10
0.92280
0.92094
-0.00186
Ampliata
Elastic Net
42
16
0.92276
0.92095
-0.00182
# Seconda tabella: accuratezza, F1 e numero di clienti classificati bene.kable(confronto_lambda[, c("Specificazione", "Modello","Accuratezza_min", "Accuratezza_1se","F1_min", "F1_1se","Corretti_min", "Corretti_1se", "Delta_corretti")],digits =4, caption ="Classificazione sul test: lambda.min vs lambda.1se (soglia 0,50)")
Classificazione sul test: lambda.min vs lambda.1se (soglia 0,50)
Specificazione
Modello
Accuratezza_min
Accuratezza_1se
F1_min
F1_1se
Corretti_min
Corretti_1se
Delta_corretti
Standard
Ridge
0.8374
0.8349
0.8381
0.8357
12561
12524
-37
Standard
LASSO
0.8363
0.8353
0.8370
0.8364
12544
12530
-14
Standard
Elastic Net
0.8361
0.8355
0.8369
0.8367
12541
12532
-9
Ampliata
Ridge
0.8361
0.8344
0.8368
0.8351
12542
12516
-26
Ampliata
LASSO
0.8363
0.8353
0.8371
0.8364
12545
12530
-15
Ampliata
Elastic Net
0.8360
0.8353
0.8367
0.8365
12540
12529
-11
Commento
Passare da lambda.min a lambda.1se riduce molto il numero di variabili (il LASSO scende da 34-36 a 10), al costo di una perdita di AUC molto piccola: da −0,0007 per il Ridge standard a −0,0019 per il LASSO standard. Sono circa 9-37 clienti classificati correttamente in meno su 15.000. Quindi lambda.1se è un buon compromesso tra semplicità e prestazioni. La scelta di λ resta basata sulla cross-validation del training e non è rifatta guardando il test.
11.9.3 Spiegazione codice
confronto_lambda <- do.call(rbind, lapply(names(modelli_cv), function(spec) {...})): costruisce la tabella ripetendo il calcolo per ogni specificazione e, dentro, per ogni modello penalizzato.
cv <- modelli_cv[[spec]][[nome]] e x_te <- matrici[[spec]]$test: il modello corrente e la sua matrice di test.
p_min <- as.numeric(predict(cv, newx = x_te, s = "lambda.min", type = "response")) e la riga dopo con "lambda.1se": le probabilità previste dallo stesso modello con i due \(\lambda\). Non si ristima niente: si cambia solo il \(\lambda\) usato per prevedere.
metriche_min <- valuta8(p_min) e metriche_1se <- valuta8(p_1se): calcolano le metriche con i due \(\lambda\).
corretti_min <- sum(as.integer(p_min > 0.50) == y_test): conta quanti clienti del test vengono classificati correttamente (previsione uguale alla realtà).
data.frame(... Coeff_min = coefficienti_non_nulli(cv, "lambda.min"), ..., Delta_AUC = unname(metriche_1se["AUC"] - metriche_min["AUC"]), ..., Delta_corretti = corretti_1se - corretti_min): una riga per modello con coefficienti, AUC, accuratezza, F1 e clienti corretti per i due \(\lambda\), più le differenze. unname toglie il nome dal numero.
kable(confronto_lambda[, c(...)], digits = 5, ...): le due tabelle mostrano colonne diverse della stessa tabella: la prima parsimonia e AUC, la seconda accuratezza, F1 e clienti corretti.
Come si legge:Delta_AUC è l’AUC di lambda.1se meno quella di lambda.min (negativo = perdita). Delta_corretti è quanti clienti in più o in meno vengono classificati bene con lambda.1se. Se lambda.1se tiene molti meno coefficienti e peggiora poco le metriche, il risultato è un buon compromesso tra semplicità e prestazioni.
Per ogni metodo i due punti sono l’AUC della versione standard e di quella ampliata. L’asse verticale è molto ingrandito: la distanza tra i punti è nell’ordine di 0,0001, quindi le due versioni sono di fatto sovrapposte.
11.10.1 Spiegazione codice
ordine <- c("Logistica", "Ridge", "LASSO", "Elastic Net"): l’ordine dei quattro metodi sull’asse orizzontale.
tab_s <- tabella_performance[tabella_performance$Specificazione == "Standard", ] e tab_a <- ...: le righe della tabella delle performance per le due specificazioni.
a_s <- tab_s$AUC[match(ordine, tab_s$Modello)] e a_a <- ...: le AUC dei quattro metodi, messe nell’ordine di ordine (match trova la posizione di ogni nome).
lim <- range(c(a_s, a_a)) + c(-0.005, 0.005): limiti dell’asse verticale, dal minimo al massimo delle AUC con un piccolo margine. L’asse è ingrandito: senza, le differenze non si vedrebbero.
plot(seq_along(ordine), a_s, type = "n", ..., xaxt = "n"): crea il grafico vuoto senza le etichette dell’asse orizzontale, che vengono messe a mano.
axis(1, at = seq_along(ordine), labels = ordine): scrive i nomi dei metodi sotto il grafico.
segments(...): una linea grigia che collega, per ogni metodo, il punto della standard con quello dell’ampliata.
points(..., pch = 16, col = "#3C8196") e points(..., pch = 17, col = "#B75B75"): i punti, tondi e azzurri per la standard, triangolari e rosa per l’ampliata.
legend("bottomleft", ...): la legenda in basso a sinistra.
11.11 Confronto descrittivo delle AUC
Riportiamo le differenze tra le AUC senza introdurre ulteriori test. Le due specificazioni sono valutate sullo stesso test set, quindi le differenze si leggono direttamente per entità e direzione. Una differenza piccolissima non va descritta come un miglioramento solo perché positiva.
Confronto descrittivo delle AUC: differenza = ampliata − standard
Modello
AUC_standard
AUC_ampliata
Delta_AUC
Logistica
0.92281
0.92277
-0.00004
Ridge
0.92287
0.92279
-0.00008
LASSO
0.92287
0.92280
-0.00007
Elastic Net
0.92288
0.92276
-0.00012
Commento
Tutte le differenze (ampliata − standard) sono negative e di ordine 10⁻⁴: tra −0,00004 e −0,00012. Una variazione così piccola non è un peggioramento reale: indica che la versione ampliata non porta alcun miglioramento. Il segno da solo non dimostra che il cambiamento sia rilevante o generalizzabile.
11.11.1 Spiegazione codice
ordine_metodi <- c("Logistica", "Ridge", "LASSO", "Elastic Net"): i quattro metodi.
confronto_auc <- do.call(rbind, lapply(ordine_metodi, function(nome) {...})): per ogni metodo costruisce una riga e le incolla in una tabella.
a_std <- tabella_performance$AUC[tabella_performance$Specificazione == "Standard" & tabella_performance$Modello == nome]: cerca nella tabella delle performance l’AUC di quel metodo nella specificazione standard. La parentesi quadra seleziona la riga che soddisfa entrambe le condizioni.
a_amp <- ...: lo stesso per l’ampliata.
data.frame(Modello = nome, AUC_standard = a_std, AUC_ampliata = a_amp, Delta_AUC = a_amp - a_std): la riga con le due AUC e la loro differenza.
kable(confronto_auc, digits = 5, ...): mostra la tabella con 5 decimali, perché le differenze sono molto piccole.
11.12 Matrici di confusione: otto modelli, due gruppi di grafici
Le matrici confrontano le classi osservate (righe) con quelle previste (colonne) con soglia 0,50. Le caselle verdi sono i veri negativi (TN) e i veri positivi (TP); quelle rosa i falsi positivi (FP) e i falsi negativi (FN).
disegna_matrice_p <-function(p, titolo) { pred <-factor(as.integer(p >0.5), levels =c(0, 1)) z <-table(Osservato =factor(y_test, levels =c(0, 1)), Previsto = pred)plot.new()plot.window(xlim =c(0.5, 2.5), ylim =c(0.5, 2.5))for (i in1:2) for (j in1:2) {rect(j - .47, 3- i - .47, j + .47, 3- i + .47,col =if (i == j) "#D9EEE5"else"#F6DEDC", border ="white")text(j, 3- i, format(z[i, j], big.mark =".", decimal.mark =","), cex =1.45, font =2) }axis(1, at =1:2, labels =c("0", "1"), tick =FALSE)axis(2, at =c(2, 1), labels =c("0", "1"), las =1, tick =FALSE)title(main = titolo, xlab ="Previsto", ylab ="Osservato", cex.main =1)}
op <-par(mfrow =c(2, 2), mar =c(4, 4, 3, 1))for (nome innames(previsioni$Standard)) {disegna_matrice_p(previsioni$Standard[[nome]], paste("Standard —", nome))}
par(op)
op <-par(mfrow =c(2, 2), mar =c(4, 4, 3, 1))for (nome innames(previsioni$Ampliata)) {disegna_matrice_p(previsioni$Ampliata[[nome]], paste("Ampliata —", nome))}
par(op)
Commento
Le matrici sono quasi indistinguibili tra metodi e tra specificazioni: ogni modello classifica correttamente circa 12.540-12.560 clienti su 15.000 (circa l’83,6%), con un numero simile di falsi positivi e falsi negativi. La versione ampliata non riduce né i falsi positivi né i falsi negativi.
11.12.1 Spiegazione codice
disegna_matrice_p <- function(p, titolo) {: crea una funzione che disegna la matrice di confusione a partire dalle probabilità p e dal titolo. È la stessa idea di disegna_matrice vista prima, ma riceve direttamente le probabilità.
pred <- factor(as.integer(p > 0.5), levels = c(0, 1)): trasforma le probabilità in decisioni 0/1 con soglia 0,5.
z <- table(Osservato = factor(y_test, levels = c(0, 1)), Previsto = pred): conta quanti clienti cadono in ciascuna delle quattro combinazioni realtà/previsione.
plot.new() e plot.window(xlim = c(0.5, 2.5), ylim = c(0.5, 2.5)): preparano un foglio vuoto in cui le quattro caselle formano una griglia 2×2.
for (i in 1:2) for (j in 1:2) {...}: passa sulle quattro caselle.
rect(..., col = if (i == j) "#D9EEE5" else "#F6DEDC", border = "white"): disegna la casella, verde se è sulla diagonale (previsione giusta), rosa altrimenti.
text(j, 3 - i, format(z[i, j], big.mark = ".", decimal.mark = ","), cex = 1.45, font = 2): scrive il numero di clienti dentro la casella, con il punto per le migliaia.
axis(...) e title(...): etichette 0 e 1 sugli assi e titolo.
par(mfrow = c(2, 2), ...) e for (nome in names(previsioni$Standard)) {...}: mettono quattro grafici in una griglia 2×2 e disegnano la matrice di ciascun metodo; la seconda figura fa lo stesso per l’ampliata.
11.13 Curve ROC per le due specificazioni
{ colori <-c(Logistica ="#293D56", Ridge ="#3C8196",LASSO ="#B75B75", `Elastic Net`="#D69D39") op <-par(mfrow =c(1, 2), mar =c(4, 4, 3, 1))for (spec innames(previsioni)) { nomi <-names(previsioni[[spec]]) r0 <-roc(y_test, previsioni[[spec]][[nomi[1]]],levels =c(0, 1), direction ="<", quiet =TRUE)plot(r0, legacy.axes =TRUE, col = colori[nomi[1]], lwd =2,main =paste("Curve ROC —", spec), xlab ="1 - Specificità", ylab ="Sensibilità")if (length(nomi) >1) for (nome in nomi[-1]) { r <-roc(y_test, previsioni[[spec]][[nome]],levels =c(0, 1), direction ="<", quiet =TRUE)plot(r, add =TRUE, col = colori[nome], lwd =2) }abline(0, 1, lty =3, col ="gray60")legend("bottomright", legend = nomi, col = colori[nomi],lwd =2, bty ="n", cex = .7) }par(op)}
Commento
Le quattro curve di ciascun pannello si sovrappongono quasi del tutto, e anche i due pannelli sono molto simili tra loro. Tutte le curve sono vicine all’angolo in alto a sinistra (AUC circa 0,92), quindi il modello discrimina bene le due classi, ma lo fa allo stesso modo con o senza termini aggiunti.
11.13.1 Spiegazione codice
colori <- c(Logistica = "#293D56", Ridge = ..., LASSO = ...,Elastic Net= ...): un colore per ogni metodo, con il nome del metodo come etichetta, così lo stesso metodo ha lo stesso colore in entrambi i grafici.
par(mfrow = c(1, 2), mar = c(4, 4, 3, 1)): due grafici affiancati, uno per specificazione.
for (spec in names(previsioni)) {...}: ripete il disegno per Standard e Ampliata.
r0 <- roc(y_test, previsioni[[spec]][[nomi[1]]], levels = c(0, 1), direction = "<", quiet = TRUE): calcola la curva ROC del primo modello (la logistica). levels = c(0, 1) e direction = "<" dicono che 0 è la classe negativa, 1 la positiva e che probabilità più alte indicano più rischio.
plot(r0, legacy.axes = TRUE, col = ..., lwd = 2, main = ...): disegna la prima curva e crea il grafico. legacy.axes = TRUE mette sull’asse x “1 − specificità” da 0 a 1 in modo crescente.
for (nome in nomi[-1]) { r <- roc(...); plot(r, add = TRUE, col = colori[nome], lwd = 2) }: calcola e disegna le altre tre curve sopra il grafico già creato (add = TRUE significa “aggiungi, non fare un nuovo grafico”).
abline(0, 1, lty = 3, col = "gray60"): la diagonale, cioè un modello che tira a caso (AUC 0,5).
legend("bottomright", ...): la legenda in basso a destra.
Come si legge: le curve mostrano sensibilità e falsi allarmi al variare della soglia. Più la curva è vicina all’angolo in alto a sinistra, meglio il modello distingue le due classi.
11.14 Un esempio di interazione: gender × credit_score
Questo grafico aiuta a capire che cos’è un’interazione. Facciamo crescere credit_score mentre le altre caratteristiche restano fissate a valori tipici del training, e tracciamo la probabilità stimata dalla logistica ampliata per ciascuna categoria di gender.
{ base <- train[1, , drop =FALSE]for (v insetdiff(names(train), c("credit_risk", "gender", "credit_score"))) {if (is.numeric(train[[v]])) { base[[v]] <-median(train[[v]], na.rm =TRUE) } elseif (is.factor(train[[v]])) { comune <-names(sort(table(train[[v]]), decreasing =TRUE))[1] base[[v]] <-factor(comune, levels =levels(train[[v]])) } } punteggi <-seq(as.numeric(quantile(train$credit_score, .05)),as.numeric(quantile(train$credit_score, .95)), length.out =70) gruppi <-levels(train$gender) griglia <- base[rep(1, length(punteggi) *length(gruppi)), , drop =FALSE] griglia$credit_score <-rep(punteggi, times =length(gruppi)) griglia$gender <-factor(rep(gruppi, each =length(punteggi)), levels = gruppi) griglia$probabilita <-as.numeric(predict(modelli_glm$Ampliata,newdata =prepara_ampliata(griglia), type ="response")) cols <-c("#3C8196", "#B75B75", "#D69D39", "#566399")plot(NA, xlim =range(punteggi), ylim =range(griglia$probabilita),xlab ="Credit score", ylab ="Probabilità stimata di rischio",main ="Interazione gender × credit_score")for (i inseq_along(gruppi)) { ind <- griglia$gender == gruppi[i]lines(griglia$credit_score[ind], griglia$probabilita[ind],col = cols[i], lwd =2.5) }legend("topright", legend = gruppi, col = cols[seq_along(gruppi)],lwd =2.5, bty ="n")}
Commento
Le curve per le due categorie di genere sono quasi sovrapposte: a parità delle altre caratteristiche, la probabilità di rischio stimata è praticamente la stessa per Female e Male a ogni livello di credit score. Questo è coerente con il p-value dell’interazione genderMale:credit_score (0,69), che non indica nessuna differenza di effetto. Il grafico serve a illustrare come si legge un’interazione categorica × numerica; non è una prova di causalità né una raccomandazione di usare gender nelle decisioni di credito.
11.14.1 Spiegazione codice
base <- train[1, , drop = FALSE]: prende un cliente qualsiasi del training come “modello di riga” da cui costruire la griglia.
for (v in setdiff(names(train), c("credit_risk", "gender", "credit_score"))) {...}: per ogni variabile diversa da risposta, genere e credit score, fissa un valore tipico.
base[[v]] <- median(train[[v]], na.rm = TRUE): per le variabili numeriche usa la mediana del training.
comune <- names(sort(table(train[[v]]), decreasing = TRUE))[1] e base[[v]] <- factor(comune, levels = levels(train[[v]])): per le variabili qualitative usa la categoria più frequente.
punteggi <- seq(quantile(train$credit_score, .05), quantile(train$credit_score, .95), length.out = 70): 70 valori di credit score, dal 5° al 95° percentile del training (si evitano gli estremi, poco rappresentativi).
gruppi <- levels(train$gender): le categorie di genere.
griglia <- base[rep(1, length(punteggi) * length(gruppi)), , drop = FALSE]: ripete il cliente “tipico” tante volte quante sono le combinazioni punteggio × genere.
griglia$credit_score <- rep(punteggi, times = length(gruppi)) e griglia$gender <- factor(rep(gruppi, each = length(punteggi)), levels = gruppi): assegna a ogni riga un punteggio e un genere.
griglia$probabilita <- as.numeric(predict(modelli_glm$Ampliata, newdata = prepara_ampliata(griglia), type = "response")): calcola la probabilità di rischio della logistica ampliata. prepara_ampliata serve perché il modello è stato stimato sulle variabili standardizzate.
plot(NA, ...) e il ciclo for (i in seq_along(gruppi)) { lines(...) }: disegna una curva per genere.
legend("topright", ...): la legenda.
Attenzione: se le curve differiscono per andamento, nel modello l’associazione tra credit score e rischio varia tra i generi, a parità delle altre caratteristiche. Non è una prova di causalità né una raccomandazione di usare gender nelle decisioni di credito.
12 Conclusioni
Sul test set gli otto modelli hanno prestazioni praticamente identiche: l’AUC va da 0.9228 a 0.9229. Aggiungere quadrati e interazioni non migliora la classificazione: la differenza di AUC tra versione ampliata e standard è al massimo 0.00012 in valore assoluto, cioè trascurabile.
Anche i test sui singoli termini vanno nella stessa direzione: nella logistica ampliata solo 1 termine su 11 ha p-value sotto 0,05, risultato compatibile con il caso quando si fanno più test insieme. Nessuna delle tre interazioni con gender è significativa.
La regolarizzazione gestisce bene la maggiore complessità: con lambda.1se il LASSO usa 10 variabili su 62 nella versione ampliata (e 10 su 51 nella standard), eliminando tutti i termini aggiunti, con una perdita di AUC inferiore a 0,002. Il risultato è utile: con prestazioni simili si ottiene un modello molto più semplice. Il motivo per cui nulla cambia è che il campione di stima è molto grande (35.000 clienti) rispetto al numero di variabili, e che le relazioni tra le variabili principali e il rischio sono già ben descritte da un modello lineare sul logit.
12.1 Limiti
Un solo split training/test. I risultati dipendono da una sola divisione dei dati (seed 123): con un’altra divisione i numeri potrebbero cambiare leggermente. Le differenze tra i modelli sono comunque così piccole da non cambiare la conclusione.
Soglia fissata a 0,5. Le metriche di classificazione dipendono dalla soglia e non si è tenuto conto del fatto che i due errori hanno costi diversi: lasciar passare un cliente a rischio (falso negativo) è in genere più grave di un falso allarme. L’AUC, invece, non dipende dalla soglia.
Dataset probabilmente sintetico. I dati potrebbero essere stati generati artificialmente, quindi i risultati non vanno generalizzati automaticamente a clienti reali. L’assenza di effetti non lineari potrebbe dipendere da come i dati sono stati generati.
Termini aggiunti solo in parte. Sono stati provati quattro quadrati e sette interazioni, scelti a priori e su indicazione del professore: altre non linearità o altre interazioni non sono state esplorate.
Interazioni con gender. Sono analizzate solo a scopo statistico: non implicano relazioni causali. L’uso del genere in un modello di credito reale richiederebbe una valutazione rigorosa dei vincoli antidiscriminatori.
Variabili non sempre disponibili. Alcune variabili potrebbero non essere note al momento della concessione del prestito: in un uso reale andrebbero escluse.
Elastic Net con α fissato a 0,5. Per l’Elastic Net è stato provato un solo valore di α, un valore intermedio convenzionale tra Ridge e LASSO, senza ottimizzarlo.
Uso del test set. Il test set è stato usato soltanto per valutare le previsioni: il parametro di penalizzazione è stato scelto con la cross-validation sul solo training set.