Cos’è l’underfitting? Come rilevare e superare l’alto bias nei modelli di ML

Quando costruiamo modelli per prevedere risultati o scoprire pattern, incontriamo varie sfide. Un ostacolo comune è creare un modello che catturi con precisione le tendenze sottostanti nei tuoi dati. A volte i modelli sono troppo semplici e non riescono a imparare le complessità, portando a prestazioni scarse. Questo fenomeno è noto come underfitting.

Un modello in underfitting non solo si comporta male sui dati su cui è stato addestrato, ma non riesce nemmeno a generalizzare a nuovi dati mai visti. Ciò significa che le tue previsioni potrebbero essere inaffidabili in scenari reali. Riconoscere e affrontare l’underfitting è un passo importante per costruire modelli di machine learning robusti ed efficaci. 

Immagine dell’autore

In questo articolo vedremo cos’è l’underfitting, perché accade, come riconoscerlo e, soprattutto, come correggerlo. Se vuoi fare pratica con il machine learning, dai un’occhiata al nostro percorso Machine Learning Fundamentals in Python. 

Cos’è l’underfitting?

Approfondiamo il concetto di underfitting e come si contrappone al suo opposto, l’overfitting. Capire questa distinzione è fondamentale per diagnosticare e migliorare i modelli.

Immagine dell’autore

In poche parole, l’underfitting si verifica quando un modello di machine learning è troppo semplice per catturare i pattern sottostanti nei dati di addestramento. Immagina di provare a far passare una retta attraverso punti che seguono chiaramente una curva, e la retta (il nostro modello) non è abbastanza complessa. Un modello in underfitting soffre di alto bias, cioè fa assunzioni forti sui dati (ad esempio, presume una relazione lineare dove non c’è). 

Poiché non riesce a imparare bene dai dati, si comporta male non solo sui dati di addestramento, ma anche su nuovi dati mai visti (di test). Tuttavia, questi modelli tendono ad avere bassa varianza, cioè le loro previsioni non cambiano molto se li addestri su sottoinsiemi diversi dei dati. La semplicità li rende coerenti, sebbene coerentemente sbagliati.

Matematicamente, questo si ricollega alla decomposizione bias-varianza dell’errore atteso del modello. L’errore atteso di un modello può essere scomposto in tre componenti: bias al quadrato, varianza ed errore irriducibile:

Dove:

• E[(y - f̂(x))²] è l’errore quadratico atteso della previsione.

• Bias(f̂(x)) misura l’errore introdotto approssimando la funzione reale f(x) con il modello.

• Var(f̂(x)) è la variabilità della previsione del modello per diversi dataset di addestramento.

• σ² rappresenta l’errore irriducibile — il rumore intrinseco nei dati che non può essere previsto.

Nell’underfitting, il termine Bias(f̂(x)) domina l’errore. Il modello è troppo semplice, il che porta a errori sistematici e all’incapacità di catturare la vera relazione nei dati.

Contrasto tra underfitting e overfitting

Capire l’underfitting è più facile se lo si confronta con l’overfitting. Mentre i modelli in underfitting sono troppo semplici, quelli in overfitting sono troppo complessi. Imparano i dati di addestramento troppo bene, catturando non solo i pattern sottostanti ma anche il rumore e le fluttuazioni casuali.

Trade-off bias-varianza - Immagine dell’autore

Vediamo le differenze chiave tra underfitting e overfitting:

Questo porta al concetto cruciale di trade-off bias-varianza.

• Alto bias (underfitting): I modelli semplici hanno alto bias ma bassa varianza. Sono costantemente sbagliati ma variano poco con dati di training diversi.
• Alta varianza (overfitting): I modelli complessi hanno basso bias ma alta varianza. Adattano molto bene i dati di training (basso bias) ma sono molto sensibili ai dati specifici usati per l’addestramento, portando a scarsa generalizzazione su nuovi dati. Puoi approfondire nel nostro articolo What is Overfitting?.

L’obiettivo è trovare il punto di equilibrio: un modello abbastanza complesso da catturare i veri pattern (basso bias) ma non così complesso da imparare il rumore (bassa varianza).

Esempi:

• Esempio di underfitting: Provare a prevedere i prezzi delle case, che dipendono da dimensione, posizione, età, ecc., usando solo il numero di stanze. Il modello è troppo semplice (alto bias) e probabilmente farà previsioni scarse per la maggior parte delle case.
• Esempio di overfitting: Creare un modello di regressione polinomiale altamente complesso che passa perfettamente per ogni singolo punto del tuo set di training sui prezzi delle case. Questo modello potrebbe avere errore quasi zero sui dati di training, ma andrà malissimo su nuove case perché ha imparato il rumore specifico del set di training (alta varianza).

Capire dove si colloca il tuo modello su questo spettro è importante per sviluppare soluzioni di machine learning efficaci, come vedremo nelle sezioni seguenti su rilevamento e gestione dell’underfitting.

Cause dell’underfitting e indicatori diagnostici

Ora che sappiamo cos’è l’underfitting, vediamo perché accade e come puoi rilevarlo nei tuoi progetti. Identificare la causa alla radice è essenziale per scegliere la giusta strategia di mitigazione. 

Cause principali dell’underfitting

Diversi fattori possono portare a un modello in underfitting:

Complessità del modello insufficiente

L’algoritmo scelto potrebbe essere troppo semplice rispetto alla struttura sottostante dei dati. Ad esempio, usare una regressione lineare quando la relazione tra feature e variabile target è fortemente non lineare. Il modello manca intrinsecamente della capacità di catturare le complessità.

Addestramento inadeguato

Il modello potrebbe non essere stato addestrato abbastanza a lungo (ad es., troppo poche epoche nelle reti neurali) o con parametri di apprendimento appropriati. Se il processo di training si interrompe prematuramente, il modello non avrà avuto abbastanza opportunità di imparare i pattern, anche se ne ha la capacità.

Rappresentazione delle feature inadeguata 

Le feature usate per addestrare il modello potrebbero non rappresentare adeguatamente i fattori sottostanti che influenzano la variabile target. Questo può significare:

• Feature importanti mancanti: Predittori chiave non sono stati inclusi nel dataset.
• Feature irrilevanti: Il dataset contiene rumore o feature che non correlano con l’esito, potenzialmente fuorviando un modello semplice.
• Feature che richiedono trasformazioni: Le feature potrebbero richiedere scaling, normalizzazione o codifica (ad es., variabili categoriali) per essere utili al modello.

Regolarizzazione eccessiva

Le tecniche di regolarizzazione (come penalità L1 o L2) si usano principalmente per prevenire l’overfitting aggiungendo una penalità alla complessità. Tuttavia, se l’intensità della regolarizzazione (ad es., il parametro lambda) è impostata troppo alta, può penalizzare eccessivamente il modello, costringendolo a essere troppo semplice e quindi causando underfitting. Scopri di più sulla regolarizzazione in Towards Preventing Overfitting in Machine Learning: Regularization.

Dati di bassa qualità o insufficienti

• Dati non sufficienti: Se il dataset di training è troppo piccolo, il modello potrebbe non avere abbastanza esempi per imparare efficacemente i pattern sottostanti.
• Alto rumore: Se i dati sono molto rumorosi, il modello potrebbe faticare a distinguere il segnale dal rumore, soprattutto se è un modello semplice.
• Valori mancanti: Grandi quantità di dati mancanti possono ostacolare la capacità del modello di imparare, in particolare se non gestiti correttamente. Tecniche per affrontare questo tema sono trattate in Handling Missing Data with Imputations in R.

Metodi di rilevamento

Come capire se il tuo modello è in underfitting? Ecco alcune tecniche diagnostiche comuni:

Analisi delle metriche di performance 

L’indicatore più semplice è una performance scarsa su entrambi il set di training e quello di validazione/test. Se il tuo modello ottiene errore alto (o bassa accuratezza, basso R-squared, ecc.) sui dati su cui è stato addestrato, è un forte segnale che non ha imparato efficacemente i pattern. A differenza dell’overfitting, dove la performance in training è eccellente ma quella in test è scarsa, l’underfitting mostra prestazioni scarse su tutta la linea.

Learning curve

Tracciare la performance del modello (ad es., errore o accuratezza) su training e validation in funzione del tempo di training o della dimensione del dataset può essere molto utile. Per un modello in underfitting, le learning curve tipicamente mostrano:

• Errore di training alto che va in plateau presto.
• Errore di validazione alto, vicino a quello di training, che va anch’esso in plateau.
• Entrambe le curve convergono a un livello di errore alto, indicando che il modello non migliora in modo significativo nemmeno con più dati o training.

Analisi delle feature

Rivedi le feature utilizzate. Sono rilevanti? Ci sono interazioni che non hai catturato? Le feature numeriche sono scalate? Le categoriche sono codificate in modo appropriato? 

A volte tornare all’ingegneria delle feature può spiegare perché il modello fatica. I concetti di base sono trattati in Machine Learning Fundamentals in R. Per approfondire le relazioni statistiche, considera risorse come Statistical Inference in R.

Modellazione comparativa

Addestra un modello più complesso (ad es., un albero decisionale o un gradient boosting se inizialmente hai usato la regressione lineare) sugli stessi dati. Se il modello più complesso supera significativamente quello iniziale sia su training che su validation, è probabile che il modello originale fosse in underfitting per complessità insufficiente. 

Puoi tracciare tali confronti con gli strumenti discussi in Machine Learning Experimentation: An Introduction to Weights & Biases.

Capendo queste cause e metodi di rilevamento, puoi diagnosticare efficacemente un modello in underfitting e intraprendere azioni per migliorarne le prestazioni.

Strategie di mitigazione dell’underfitting e best practice

Una volta identificato l’underfitting, il passo successivo è sapere come correggerlo. Fortunatamente, esistono diverse strategie efficaci per aumentare la capacità del modello di imparare i pattern sottostanti nei dati. Vediamone alcune:

Aumentare la complessità del modello

Se il tuo modello è troppo semplice (alto bias), renderlo più complesso spesso può risolvere l’underfitting. Possiamo farlo nei seguenti modi:

Selezione dell’algoritmo

Passa a un modello più potente. Se la regressione lineare è in underfitting, prova la regressione polinomiale, gli alberi decisionali, le random forest, i gradient boosting (come XGBoost o LightGBM) o le SVM con kernel non lineari. Questi modelli hanno intrinsecamente più capacità di catturare relazioni complesse.

Espansione polinomiale delle feature

Per problemi di regressione, puoi creare feature polinomiali a partire dalle tue feature numeriche esistenti. Questo consente ai modelli lineari di adattare relazioni più complesse e curve. Ad esempio, se hai una feature x, puoi aggiungere x2, x3, ecc., come nuove feature. Scikit-learn fornisce PolynomialFeatures per farlo.

Tuning degli iperparametri

Molti modelli complessi hanno iperparametri che controllano la loro complessità (ad es., la profondità di un albero decisionale, il numero di neuroni in uno strato di una rete neurale, il parametro C nelle SVM). Regolare questi iperparametri per consentire maggiore complessità può ridurre il bias. 

Tecniche come Grid Search o Randomized Search sono essenziali qui. Scopri di più con corsi come Hyperparameter Tuning in Python o Hyperparameter Tuning in R. Vedi anche il nostro tutorial su Hyperparameter Optimization in Machine Learning Models.

Feature engineering e data augmentation

A volte il problema non è il modello, ma la rappresentazione dei dati. Migliorare le feature può aiutare molto. Possiamo farlo nei seguenti modi:

Creazione di feature specifiche del dominio

Usa la tua conoscenza del dominio per creare nuove feature potenzialmente più informative. Ad esempio, nel prevedere i prezzi delle case, combinare “numero di camere da letto” e “numero di bagni” in una feature “stanze totali”, o calcolare “età della casa” dall’“anno di costruzione”.

Feature di interazione

Crea feature che rappresentino l’interazione tra feature esistenti (ad es., moltiplicando due feature). Questo può aiutare i modelli a catturare effetti sinergici.

Arricchimento dei dati

Arricchisci il tuo dataset con fonti esterne se possibile. Ad esempio, aggiungendo dati demografici a informazioni sui clienti o dati meteo a previsioni di vendita.

Data augmentation (principalmente per dati non strutturati)

Per immagini o testo, tecniche come ruotare/capovolgere immagini o usare sostituzioni di sinonimi nel testo possono aumentare artificialmente dimensione e diversità del set di training, aiutando il modello a imparare pattern più robusti.

Regolare la regolarizzazione

Se l’underfitting è causato da regolarizzazione eccessiva pensata per prevenire l’overfitting, devi ridurla. Abbassa il valore del parametro di regolarizzazione (ad es., alpha in Ridge/Lasso, C nelle SVM — nota che per le SVM un C più piccolo significa regolarizzazione più forte, quindi dovresti aumentare C).

Se usi il dropout, riduci il tasso di dropout (la frazione di neuroni disattivati durante l’addestramento). Un tasso più basso mantiene maggiore capacità nella rete.

Trovare il giusto equilibrio richiede spesso un attento tuning, a riprova dell’importanza dell’ottimizzazione degli iperparametri.

Metodi ensemble

I metodi ensemble combinano le previsioni di più modelli individuali (weak learner) per produrre una previsione finale più forte e robusta. Sono spesso molto efficaci nel ridurre sia bias sia varianza. Alcuni metodi ensemble sono i seguenti:

• Bagging (ad es., Random Forest): Addestra più modelli (ad es., alberi decisionali) in modo indipendente su diversi campioni bootstrap dei dati e ne fa la media delle previsioni. Questo riduce principalmente la varianza ma può aiutare anche se i learner di base hanno un leggero bias. Dai un’occhiata al nostro tutorial sul Bagging per saperne di più.
• Boosting (ad es., AdaBoost, Gradient Boosting): Addestra i modelli in sequenza, con ogni nuovo modello che si concentra sulla correzione degli errori commessi dai precedenti. Il boosting è particolarmente efficace nel ridurre il bias e trasformare weak learner in strong learner, rendendolo un potente strumento contro l’underfitting. Abbiamo una guida al Boosting per spiegare di più. 
• Stacking: Addestra più modelli di tipi diversi e poi usa un altro modello (meta-learner) per imparare come combinare al meglio le loro previsioni.

Applicando queste strategie, spesso in combinazione, puoi affrontare efficacemente l’underfitting e costruire modelli che catturano meglio le complessità dei tuoi dati.

Applicazioni pratiche e casi di studio

Vedere l’underfitting in azione con dataset e codice può chiarire notevolmente il concetto. Esaminiamo esempi pratici per mostrare come si comporta un modello in underfitting e come migliorarne le prestazioni.

Esempio di underfitting con regressione lineare

Uno scenario comune di underfitting si verifica quando si usa un modello lineare semplice per descrivere una relazione non lineare. Illustriamolo provando a adattare un modello di regressione lineare a dati che seguono un pattern quadratico.

Genereremo dati sintetici in cui la variabile target y ha una relazione quadratica con una feature X. Per prima cosa adatteremo un semplice modello di regressione lineare. Osserveremo le sue prestazioni scarse (alto Mean Squared Error - MSE) e visualizzeremo come non riesce a catturare la curva dei dati. 

Poi espanderemo le feature aggiungendo un termine polinomiale e adatteremo un modello di regressione polinomiale. Questo mostrerà come aumentare la complessità del modello possa ridurre il bias e migliorare significativamente l’accuratezza.

Iniziamo importando le librerie necessarie come segue:

# Import necessary libraries
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_errorOfferto da

Generiamo ora dati sintetici non lineari. Creeremo dati con relazione quadratica: y = 0.5*X^2 + X + 2 + rumore.

np.random.seed(42) # for reproducibility
num_samples = 100
X = np.sort(10 * np.random.rand(num_samples, 1) - 5, axis=0) # Feature X (sorted for plotting)
y_true = 0.5 * X**2 + X + 2 # True quadratic relationship
y = y_true + np.random.randn(num_samples, 1) * 5 # Add some noise to make it realisticOfferto da

Ora adatteremo un semplice modello di regressione lineare (modello in underfitting) come mostrato sotto:

linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X)
mse_linear = mean_squared_error(y, y_pred_linear)

print(f"--- Simple Linear Regression (Potential Underfitting Model) ---")
print(f"Mean Squared Error (MSE): {mse_linear:.2f}")
print(f"Model Coefficients (slope): {linear_model.coef_[0][0]:.2f}")
print(f"Model Intercept: {linear_model.intercept_[0]:.2f}")Offerto da

Output:

--- Simple Linear Regression (Potential Underfitting Model) ---

Mean Squared Error (MSE): 34.03

Model Coefficients (slope): 1.00

Model Intercept: 6.42Offerto da

Ora adatteremo un modello di regressione polinomiale (modello migliorato). Per farlo, creiamo feature polinomiali (grado 2) e poi adattiamo un modello lineare a queste feature. Il passaggio PolynomialFeatures aggiunge nuove feature. Il passaggio LinearRegression ha coefficienti per ciascuna di esse.

Per il grado 2, ci aspettiamo coefficienti per X e X^2. Una pipeline rende questo processo più pulito. L’attributo named_steps della pipeline consente di accedere ai singoli passaggi come mostrato sotto:

polynomial_model = make_pipeline(PolynomialFeatures(degree=2, include_bias=False), LinearRegression())
polynomial_model.fit(X, y)
y_pred_poly = polynomial_model.predict(X)
mse_poly = mean_squared_error(y, y_pred_poly)

print(f"\n--- Polynomial Regression (Degree 2) ---")
print(f"Mean Squared Error (MSE): {mse_poly:.2f}")
poly_reg_coeffs = polynomial_model.named_steps['linearregression'].coef_[0]
poly_reg_intercept = polynomial_model.named_steps['linearregression'].intercept_[0]
print(f"Model Coefficients (for X, X^2): {poly_reg_coeffs[0]:.2f}, {poly_reg_coeffs[1]:.2f}")
print(f"Model Intercept: {poly_reg_intercept:.2f}")Offerto da

Output:

--- Polynomial Regression (Degree 2) ---

Mean Squared Error (MSE): 20.48

Model Coefficients (for X, X^2): 1.13, 0.50

Model Intercept: 2.04Offerto da

Ora visualizziamo l’adattamento del modello come mostrato di seguito:

# Visualization
plt.figure(figsize=(10, 4))
plt.scatter(X, y, s=30, label="Actual Data Points", alpha=0.7, edgecolors='k')
plt.plot(X, y_pred_linear, color='red', linewidth=2, label=f'Linear Fit (Underfitting)\nMSE: {mse_linear:.2f}')
plt.plot(X, y_pred_poly, color='green', linewidth=2, label=f'Polynomial Fit (Degree 2)\nMSE: {mse_poly:.2f}')
plt.title('Demonstrating Underfitting with Linear vs. Polynomial Regression', fontsize=16)
plt.xlabel('Feature X', fontsize=14)
plt.ylabel('Target y', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()Offerto da

Output:

Il grafico conferma visivamente l’underfitting del semplice modello lineare. Non riesce a catturare la curva nei dati. Il modello di regressione polinomiale, incorporando il termine X^2, fornisce un adattamento molto migliore, come evidenziato dal suo MSE più basso.

Questo mostra come espandere le feature (aumentare la complessità del modello) possa ridurre il bias e migliorare l’accuratezza quando la relazione sottostante è non lineare. Passiamo ora a un caso di studio di diagnosi medica.

Caso di studio: diagnosi medica

Simuliamo uno scenario di diagnosi medica usando il noto dataset Breast Cancer Wisconsin (Diagnostic) disponibile in scikit-learn.

Inizieremo provando a costruire un modello di classificazione usando solo un sottoinsieme molto limitato di feature, che potrebbe portare a underfitting. Poi useremo un set più completo di feature e, potenzialmente, un algoritmo più complesso per mostrare il miglioramento.

Iniziamo importando le librerie necessarie come segue:

# Import necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix, ConfusionMatrixDisplayOfferto da

Ora carichiamo e prepariamo i dati:

cancer = load_breast_cancer()
X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y = cancer.target # 0 for malignant, 1 for benignOfferto da

Per la dimostrazione, selezioniamo un sottoinsieme molto limitato di feature per lo scenario di underfitting. Potrebbero non essere le più predittive da sole:

features_limited = ['mean texture', 'mean symmetry']
X_limited = X[features_limited]Offerto da

Per il modello migliorato useremo un set più ampio (o tutte le feature). Scegliamo le prime 10 feature per un set più completo:

features_comprehensive = cancer.feature_names[:10]
X_comprehensive = X[features_comprehensive]Offerto da

Effettuiamo lo split dei dati. Lo faremo separatamente per ciascun set di feature per chiarezza:

X_train_lim, X_test_lim, y_train, y_test = train_test_split(X_limited, y, test_size=0.3, random_state=42, stratify=y)
X_train_comp, X_test_comp, _, _ = train_test_split(X_comprehensive, y, test_size=0.3, random_state=42, stratify=y) # y_train and y_test are the sameOfferto da

Scaliamo le feature: è importante per la regressione logistica e molti altri algoritmi:

scaler_lim = StandardScaler().fit(X_train_lim)
X_train_lim_scaled = scaler_lim.transform(X_train_lim)
X_test_lim_scaled = scaler_lim.transform(X_test_lim)

scaler_comp = StandardScaler().fit(X_train_comp)
X_train_comp_scaled = scaler_comp.transform(X_train_comp)
X_test_comp_scaled = scaler_comp.transform(X_test_comp)Offerto da

Ora adattiamo una regressione logistica con feature limitate:

print("Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)")
log_reg_limited = LogisticRegression(random_state=42, solver='liblinear') # liblinear is good for small datasets
log_reg_limited.fit(X_train_lim_scaled, y_train)
y_pred_lim = log_reg_limited.predict(X_test_lim_scaled)
y_proba_lim = log_reg_limited.predict_proba(X_test_lim_scaled)[:, 1]

acc_lim = accuracy_score(y_test, y_pred_lim)
auc_lim = roc_auc_score(y_test, y_proba_lim)
print(f"Features used: {features_limited}")
print(f"Accuracy: {acc_lim:.4f}")
print(f"AUC: {auc_lim:.4f}")Offerto da

Output:

Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)

Features used: ['mean texture', 'mean symmetry']

Accuracy: 0.7544

AUC: 0.8151Offerto da

Adottiamo una strategia di mitigazione. Adatteremo una regressione logistica con più feature:

print("Scenario 2: Logistic Regression (Comprehensive Features)")
log_reg_comp = LogisticRegression(random_state=42, solver='liblinear')
log_reg_comp.fit(X_train_comp_scaled, y_train)
y_pred_comp_lr = log_reg_comp.predict(X_test_comp_scaled)
y_proba_comp_lr = log_reg_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_lr = accuracy_score(y_test, y_pred_comp_lr)
auc_comp_lr = roc_auc_score(y_test, y_proba_comp_lr)
print(f"Features used: First 10 features") # For brevity
print(f"Accuracy: {acc_comp_lr:.4f}")
print(f"AUC: {auc_comp_lr:.4f}")Offerto da

Output:

Scenario 2: Logistic Regression (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9181

AUC: 0.9831Offerto da

Ora adatteremo un modello più complesso come Random Forest con più feature:

print("Scenario 3: Random Forest (Comprehensive Features)")
rf_comp = RandomForestClassifier(random_state=42, n_estimators=100) # n_estimators is a key hyperparameter
rf_comp.fit(X_train_comp_scaled, y_train) # RF can also benefit from scaled data, though less sensitive
y_pred_comp_rf = rf_comp.predict(X_test_comp_scaled)
y_proba_comp_rf = rf_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_rf = accuracy_score(y_test, y_pred_comp_rf)
auc_comp_rf = roc_auc_score(y_test, y_proba_comp_rf)
print(f"Features used: First 10 features")
print(f"Accuracy: {acc_comp_rf:.4f}")
print(f"AUC: {auc_comp_rf:.4f}")Offerto da

Output:

Scenario 3: Random Forest (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9415

AUC: 0.9878Offerto da

Tracciamo e confrontiamo la matrice di confusione per ciascun caso:

fig, axes = plt.subplots(1, 3, figsize=(20, 5))
fig.suptitle('Comparison of Model Performance (Confusion Matrices on Test Set)', fontsize=16)

# Model 1: Logistic Regression (Limited Features)
cm_lim = confusion_matrix(y_test, y_pred_lim)
disp_lim = ConfusionMatrixDisplay(confusion_matrix=cm_lim, display_labels=cancer.target_names)
disp_lim.plot(ax=axes[0], cmap='Blues')
axes[0].set_title(f'LogReg (Limited Features)\nAcc: {acc_lim:.2f}, AUC: {auc_lim:.2f}')

# Model 2: Logistic Regression (Comprehensive Features)
cm_comp_lr = confusion_matrix(y_test, y_pred_comp_lr)
disp_comp_lr = ConfusionMatrixDisplay(confusion_matrix=cm_comp_lr, display_labels=cancer.target_names)
disp_comp_lr.plot(ax=axes[1], cmap='Greens')
axes[1].set_title(f'LogReg (Comprehensive Features)\nAcc: {acc_comp_lr:.2f}, AUC: {auc_comp_lr:.2f}')

# Model 3: Random Forest (Comprehensive Features)
cm_comp_rf = confusion_matrix(y_test, y_pred_comp_rf)
disp_comp_rf = ConfusionMatrixDisplay(confusion_matrix=cm_comp_rf, display_labels=cancer.target_names)
disp_comp_rf.plot(ax=axes[2], cmap='Oranges')
axes[2].set_title(f'Random Forest (Comprehensive Features)\nAcc: {acc_comp_rf:.2f}, AUC: {auc_comp_rf:.2f}')

plt.tight_layout(rect=[0, 0, 1, 0.96]) # Adjust layout to make space for suptitle
plt.show()Offerto da

Output:

In questo caso di studio, un modello LogisticRegression addestrato su sole due feature (Scenario 1) è destinato all’underfitting per insufficiente informazione, con conseguente bassa accuratezza e AUC. 

Le prestazioni tipicamente migliorano quando lo stesso algoritmo dispone di un set di feature più completo (Scenario 2), perché ha più dati da cui imparare, riducendo il bias.

Ulteriore miglioramento si vede spesso usando un algoritmo più complesso come RandomForestClassifier con il set di feature completo (Scenario 3), poiché può catturare non linearità e interazioni tra feature in modo più efficace, riducendo ulteriormente il bias e migliorando l’adattamento ai dati.

Argomenti avanzati e direzioni future

Sebbene abbiamo coperto le basi, il panorama del machine learning è in continua evoluzione. Ecco un breve sguardo a come l’underfitting si collega ad aree più avanzate.

Il ruolo del deep learning

I modelli di deep learning, in particolare le reti neurali profonde con molti strati, sono noti per la loro alta capacità, cioè possono teoricamente approssimare funzioni molto complesse.

Grazie alla loro complessità intrinseca, i modelli di deep learning sono generalmente meno soggetti a underfitting rispetto ai modelli più semplici, a patto che siano addestrati correttamente su dati sufficienti. La loro struttura consente di imparare automaticamente rappresentazioni di feature intricate da dati grezzi (come pixel nelle immagini o parole nel testo).

Tuttavia, il deep learning non è immune a problemi che sembrano underfitting. Se una rete è progettata male (ad es., profondità/larghezza insufficienti per il compito), non addestrata abbastanza a lungo o usa funzioni di attivazione o algoritmi di ottimizzazione inadeguati, potrebbe comunque non convergere e mostrare alto errore di training.

Innovazioni architetturali come le connessioni residuali (ResNet) e le tecniche di normalizzazione (Batch Normalization) aiutano ad addestrare efficacemente reti molto profonde, mitigando i problemi di gradienti che svaniscono/esplodono e consentendo di raggiungere la piena capacità, evitando problemi di convergenza che imitano l’underfitting.

AutoML (automated machine learning)

Trovare il modello, le feature e gli iperparametri giusti per evitare sia underfitting sia overfitting può richiedere tempo. L’AutoML mira ad automatizzare questo processo.

I framework AutoML possono esplorare automaticamente diversi tipi di modelli (da quelli lineari a ensemble complessi e reti neurali), eseguire feature engineering e selezione, e ottimizzare iperparametri. Cercando sistematicamente in uno spazio vasto di possibilità, l’AutoML può individuare configurazioni di modello con complessità sufficiente per evitare l’underfitting dei dati.

Metodi come la Neural Architecture Search (NAS) progettano automaticamente architetture di rete, mentre tecniche sofisticate di ottimizzazione degli iperparametri (ad es., Bayesian Optimization) trovano in modo efficiente buone impostazioni. Questi strumenti possono accelerare significativamente il processo di ricerca di un modello ben adattato, riducendo lo sforzo manuale necessario per diagnosticare e correggere l’underfitting.

Conclusione

Capire il dilemma underfitting vs overfitting è fondamentale per il successo nel machine learning. Abbiamo visto che l’underfitting nasce quando un modello è troppo semplice (alto bias) per catturare le tendenze sottostanti nei dati, con prestazioni scarse sia su training sia su dati non visti. Le cause principali includono complessità insufficiente del modello, feature scadenti, addestramento inadeguato e regolarizzazione eccessiva.

Diagnosticare l’underfitting implica esaminare le metriche di performance, tracciare le learning curve e confrontare i modelli, spesso con l’aiuto del codice. Fortunatamente, abbiamo diverse strategie per correggerlo: aumentare la complessità del modello (scegliere algoritmi migliori, espansione delle feature, tuning degli iperparametri), migliorare le feature (feature engineering, arricchimento dei dati), regolare la regolarizzazione e impiegare potenti metodi ensemble, come mostrato nei nostri esempi di codice.

Per imparare queste tecniche e altro ancora con esempi pratici, dai un’occhiata al nostro percorso di competenze Machine Learning Fundamentals in Python.