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 documento

dati <- 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 barra
  text(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'intercetta
x_train <- x_all[idx_train, ]
x_test  <- x_all[-idx_train, ]
y_train <- train$credit_risk
y_test  <- test$credit_risk

cat("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 <- ...== 0 which 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 ratio
                       z            = 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 piccoli
cv_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:

  1. divide il training in 10 parti (fold);

  2. stima il modello su 9 parti e lo prova sulla decima;

  3. ripete ruotando la parte di prova, 10 volte;

  4. 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.

Standardizzazione glmnet 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.1se

    plot(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-validation
    polygon(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 lambda
    abline(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 diminuisce
    plot(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)) 2 else 4, 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 set
auc_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 corrette
    Sensibilita = rec,                     # a rischio veri: quanti ne trovo
    Specificita = TN / (TN + FP),          # non a rischio veri: quanti li riconosco
    Precisione  = prec,                    # tra i "a rischio" previsti, quanti lo sono davvero
    F1          = 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 in c("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))))
}

 Logistica classica 
         Previsto
Osservato    0    1
        0 6247 1253
        1 1192 6308

 Ridge (lambda.min) 
         Previsto
Osservato    0    1
        0 6248 1252
        1 1188 6312

 LASSO (lambda.min) 
         Previsto
Osservato    0    1
        0 6238 1262
        1 1194 6306

 Elastic Net (lambda.min) 
         Previsto
Osservato    0    1
        0 6233 1267
        1 1188 6312
Commento

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 in 1:2) {
      for (j in 1:2) {
        # le caselle sulla diagonale (previsioni giuste) sono verdi, le altre rosa
        rect(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 in c("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 set
principali <- 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 in seq_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"], "-") * 100

  matplot(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 logistica
  legend("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") else NA_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) <- NULL
kable(esplorazione_numeriche, digits = 3,
      caption = "Variabili numeriche (solo training)")
Variabili numeriche (solo training)
Variabile Media Dev_standard Correlazione_con_rischio Pct_al_massimo
credit_score 690.196 73.819 -0.449 1.714
debt_to_income_ratio 0.800 0.200 0.366 73.246
financial_stability_score 0.642 0.069 -0.343 0.003
repayment_history_score 88.824 8.068 -0.294 6.880
missed_payment_count 0.648 0.810 0.252 0.003
total_outstanding_debt 188798.756 120424.477 0.189 1.517
loan_to_income_ratio 2.867 1.505 0.175 0.006
late_payment_count 1.797 1.341 0.126 0.003
loan_amount 346116.307 221814.233 0.110 1.766
fraud_risk_score 14.713 8.679 0.085 0.003
monthly_savings 4734.660 2297.940 -0.074 0.003
pension_balance 335196.595 146892.776 -0.064 3.957
annual_income 120859.804 40681.747 -0.060 0.103
monthly_income 10071.881 3428.736 -0.059 0.003
fraud_alert_count 0.283 0.529 0.056 0.023
liquid_asset_balance 117355.007 68448.907 -0.052 0.317
payment_delay_days 6.309 4.723 0.051 0.003
savings_ratio 0.467 0.155 -0.050 7.663
employer_contribution 12698.975 5895.477 -0.049 0.003
employee_contribution 9054.576 4494.371 -0.043 0.003
emergency_fund_months 1.106 0.782 -0.039 0.003
unusual_transaction_ratio 0.123 0.094 0.032 0.023
transaction_amount 8547.189 7372.831 0.032 0.046
monthly_transaction_volume 203901.501 189694.961 0.031 0.229
flagged_transaction_count 0.640 0.804 0.029 0.009
max_transaction 31052.431 29908.499 0.026 0.169
device_change_frequency 1.194 1.088 0.026 0.003
cross_border_transaction_count 1.512 1.227 0.018 0.009
monthly_expense 5337.494 2460.578 -0.013 0.003
digital_banking_usage 0.712 0.160 -0.010 0.003
credit_history_years 26.342 6.899 0.008 16.169
years_employed 24.957 7.773 0.008 3.120
age 52.014 7.376 0.006 0.986
cash_withdrawal_frequency 5.495 2.348 0.004 0.003
pension_growth_rate 7.207 2.199 -0.002 0.014
transaction_frequency 23.974 4.657 0.002 0.003
active_credit_accounts 4.200 1.799 0.001 0.060
years_to_retirement 8.590 4.741 -0.001 0.071
dependents 1.797 1.330 0.001 1.066
online_payment_ratio 0.751 0.145 0.001 0.003
nomi_categoriche <- names(train)[vapply(train, is.factor, logical(1))]
esplorazione_categoriche <- do.call(rbind, lapply(nomi_categoriche, function(v) {
  do.call(rbind, lapply(levels(train[[v]]), function(liv) {
    presenti <- !is.na(train[[v]]) & train[[v]] == liv
    data.frame(Variabile = v, Categoria = liv,
               Clienti = sum(presenti),
               Pct_rischio = if (sum(presenti) > 0)
                 100 * mean(y_train[presenti] == 1) else NA_real_)
  }))
}))
rownames(esplorazione_categoriche) <- NULL
kable(esplorazione_categoriche, digits = 2,
      caption = "Tasso di rischio per categoria (solo training)")
Tasso di rischio per categoria (solo training)
Variabile Categoria Clienti Pct_rischio
gender Female 15494 50.35
gender Male 19506 49.72
marital_status Divorced 2700 51.37
marital_status Married 21454 49.91
marital_status Single 6183 50.12
marital_status Widowed 4663 49.45
education_level Bachelor 12537 50.26
education_level Diploma 7677 50.05
education_level Doctorate 1729 49.33
education_level Master 6682 49.99
education_level Secondary 6375 49.63
employment_status Government 7469 50.88
employment_status Retired 6940 49.02
employment_status Salaried 14089 50.12
employment_status Self_Employed 6502 49.77
Commento

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 in c("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.

variabili_z <- c("age", "annual_income", "credit_score", "debt_to_income_ratio",
                 "financial_stability_score", "missed_payment_count",
                 "repayment_history_score")
stopifnot(all(variabili_z %in% names(train)),
          all(vapply(train[variabili_z], is.numeric, logical(1))))
medie <- vapply(train[variabili_z], mean, numeric(1))
deviazioni <- vapply(train[variabili_z], sd, numeric(1))
stopifnot(all(is.finite(deviazioni)), all(deviazioni > 0))

prepara_ampliata <- function(df) {
  res <- df
  for (v in variabili_z) {
    res[[v]] <- (df[[v]] - medie[[v]]) / deviazioni[[v]]
  }
  res
}
train_amp <- prepara_ampliata(train)
test_amp  <- prepara_ampliata(test)

formula_ampliata <- credit_risk ~ . +
  I(age^2) + I(credit_score^2) + I(debt_to_income_ratio^2) +
  I(financial_stability_score^2) +
  credit_score:missed_payment_count +
  financial_stability_score:debt_to_income_ratio +
  credit_score:repayment_history_score +
  credit_score:debt_to_income_ratio +
  gender:credit_score + gender:annual_income + gender:debt_to_income_ratio

mat_ampliata <- crea_matrici(formula_ampliata, train_amp, test_amp)
matrici <- list(Standard = mat_standard, Ampliata = mat_ampliata)

kable(data.frame(
  Specificazione = names(matrici),
  Clienti_training = c(nrow(mat_standard$train), nrow(mat_ampliata$train)),
  Clienti_test = c(nrow(mat_standard$test), nrow(mat_ampliata$test)),
  Colonne_predittive = c(ncol(mat_standard$train), ncol(mat_ampliata$train))
), caption = "Stessi clienti, specificazioni con complessità diversa")
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 in c(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-7 else 1e-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 in names(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.

11.6 Complessità: quanti coefficienti rimangono?

coefficienti_non_nulli <- function(modello, lambda) {
  sum(as.matrix(coef(modello, s = lambda))[-1, 1] != 0)
}

tabella_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]]
    data.frame(
      Specificazione = spec, Modello = nome,
      Lambda_min = cv$lambda.min,
      Coeff_min = coefficienti_non_nulli(cv, "lambda.min"),
      Lambda_1se = cv$lambda.1se,
      Coeff_1se = coefficienti_non_nulli(cv, "lambda.1se"),
      Predittori_totali = ncol(matrici[[spec]]$train)
    )
  }))
}))
rownames(tabella_lambda) <- NULL
kable(tabella_lambda, digits = 4, caption = "Scelta di lambda e coefficienti mantenuti")
Scelta di lambda e coefficienti mantenuti
Specificazione Modello Lambda_min Coeff_min Lambda_1se Coeff_1se Predittori_totali
Standard Ridge 0.0003 51 0.0148 51 51
Standard LASSO 0.0007 34 0.0114 10 51
Standard Elastic Net 0.0012 37 0.0228 11 51
Ampliata Ridge 0.0002 62 0.0073 62 62
Ampliata LASSO 0.0011 36 0.0114 10 62
Ampliata Elastic Net 0.0012 42 0.0173 16 62
# 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.

nuove_colonne <- setdiff(colnames(mat_ampliata$train), colnames(mat_standard$train))

estrai_beta <- function(nome, scelta) {
  beta <- as.matrix(coef(modelli_cv$Ampliata[[nome]], s = scelta))
  stopifnot(all(nuove_colonne %in% rownames(beta)))
  as.numeric(beta[nuove_colonne, 1])
}

beta_lasso_min <- estrai_beta("LASSO", "lambda.min")
beta_lasso_1se <- estrai_beta("LASSO", "lambda.1se")
beta_enet_min <- estrai_beta("Elastic Net", "lambda.min")
beta_enet_1se <- estrai_beta("Elastic Net", "lambda.1se")

tipo_termini <- ifelse(grepl("^I\\(", nuove_colonne), "Quadratico",
                       ifelse(grepl("gender", nuove_colonne, fixed = TRUE),
                              "Interazione con gender", "Altra interazione"))

tabella_selezione <- data.frame(
  Termine = nuove_colonne,
  Tipo = tipo_termini,
  LASSO_min = ifelse(beta_lasso_min != 0, "Sì", "No"),
  LASSO_1se = ifelse(beta_lasso_1se != 0, "Sì", "No"),
  ElasticNet_min = ifelse(beta_enet_min != 0, "Sì", "No"),
  ElasticNet_1se = ifelse(beta_enet_1se != 0, "Sì", "No")
)
kable(tabella_selezione,
      caption = "Termini aggiunti selezionati nei modelli penalizzati (specificazione ampliata)")
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 in names(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 in names(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) else 0
  recall <- if ((TP + FN) > 0) TP / (TP + FN) else 0
  f1 <- if ((precisione + recall) > 0) {
    2 * precisione * recall / (precisione + recall)
  } else 0
  c(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) <- NULL
kable(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.

11.10 Grafico delle AUC: standard contro ampliata

{
  ordine <- c("Logistica", "Ridge", "LASSO", "Elastic Net")
  tab_s <- tabella_performance[tabella_performance$Specificazione == "Standard", ]
  tab_a <- tabella_performance[tabella_performance$Specificazione == "Ampliata", ]
  a_s <- tab_s$AUC[match(ordine, tab_s$Modello)]
  a_a <- tab_a$AUC[match(ordine, tab_a$Modello)]
  lim <- range(c(a_s, a_a)) + c(-0.005, 0.005)
  plot(seq_along(ordine), a_s, type = "n", xlim = c(0.7, 4.3), ylim = lim,
       xaxt = "n", xlab = "", ylab = "AUC sul test",
       main = "Confronto AUC (asse verticale ingrandito)")
  axis(1, at = seq_along(ordine), labels = ordine)
  grid(col = "#E5E5E5")
  segments(seq_along(ordine), a_s, seq_along(ordine), a_a, col = "gray65")
  points(seq_along(ordine), a_s, pch = 16, col = "#3C8196", cex = 1.3)
  points(seq_along(ordine), a_a, pch = 17, col = "#B75B75", cex = 1.3)
  legend("bottomleft", legend = c("Standard", "Ampliata"),
         pch = c(16, 17), col = c("#3C8196", "#B75B75"), bty = "n")
}

Commento

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.

ordine_metodi <- c("Logistica", "Ridge", "LASSO", "Elastic Net")
confronto_auc <- do.call(rbind, lapply(ordine_metodi, function(nome) {
  a_std <- tabella_performance$AUC[
    tabella_performance$Specificazione == "Standard" &
      tabella_performance$Modello == nome]
  a_amp <- tabella_performance$AUC[
    tabella_performance$Specificazione == "Ampliata" &
      tabella_performance$Modello == nome]
  data.frame(Modello = nome, AUC_standard = a_std,
             AUC_ampliata = a_amp, Delta_AUC = a_amp - a_std)
}))
kable(confronto_auc, digits = 5,
      caption = "Confronto descrittivo delle AUC: differenza = ampliata − standard")
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 in 1:2) for (j in 1: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 in names(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 in names(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 in names(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 in setdiff(names(train), c("credit_risk", "gender", "credit_score"))) {
    if (is.numeric(train[[v]])) {
      base[[v]] <- median(train[[v]], na.rm = TRUE)
    } else if (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 in seq_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.