Esistono due cause principali degli errori nei modelli di machine learning:
- Bias descrive un modello che fa assunzioni semplificate così che la funzione obiettivo sia più facile da approssimare; un modello potrebbe “imparare” che ogni uomo alto 5'9 nel mondo veste una taglia media: questo è chiaramente di parte.
- Varianza descrive la variabilità nella previsione del modello; quanto cambia la previsione del modello quando cambiamo i dati usati per addestrarlo.
Per ottenere una soluzione più accurata, cerchiamo di ridurre la quantità di bias e varianza presenti nel modello. Non è un compito banale. Bias e varianza sono in contrasto tra loro: ridurre l’uno aumenta l’altra, a causa di un concetto noto come il compromesso bias-varianza.
In questo articolo imparerai:
- Come rilevare se un modello soffre di alto bias o alta varianza
- Come diagnosticare un modello affetto da uno dei due problemi
- Come costruire un modello con buon fitting
Prima di entrare nel merito del rilevamento dei sintomi di errore, approfondiamo il compromesso bias-varianza.
Uno sguardo al compromesso bias-varianza
Tutti gli algoritmi di apprendimento supervisionato puntano allo stesso obiettivo: stimare la funzione di mappatura (f_hat) per una variabile target (y) dato un certo input (X). La funzione che un modello di machine learning mira ad approssimare viene chiamata funzione obiettivo.
Cambiare i dati di input usati per approssimare la variabile target probabilmente produrrà una funzione obiettivo diversa, che può influenzare le uscite previste dal modello. Quanto la nostra funzione obiettivo varia al variare dei dati di addestramento è noto come varianza. Non vogliamo che il modello abbia alta varianza perché, pur potendo funzionare perfettamente durante l’addestramento, fallirebbe nel generalizzare a istanze mai viste.
Nell’immagine sopra, la funzione obiettivo approssimata è la linea verde e la retta di regressione è in nero. Nota quanto bene il modello apprende i dati di addestramento con la linea verde. Fa di tutto per separare tutte le osservazioni rosse e blu. Se addestrassimo questo modello su nuove osservazioni, imparerebbe una funzione obiettivo completamente nuova e tenterebbe di riprodurre lo stesso comportamento.
Considera uno scenario in cui usiamo un metodo lineare come la regressione lineare per approssimare la funzione obiettivo. La prima cosa da notare sulla regressione lineare è che assume una relazione lineare tra i dati di input e il target che stiamo cercando di prevedere. Gli eventi nel mondo reale sono molto più complessi. Al costo di un po’ di flessibilità, questa semplice assunzione rende la funzione obiettivo molto più rapida da apprendere e più facile da comprendere. Facciamo riferimento a questo paradigma come bias.
Nell’immagine sopra, la linea rossa rappresenta la funzione obiettivo appresa. Molte osservazioni cadono molto lontano dai valori previsti dal modello.
Possiamo ridurre il bias in un modello rendendolo più flessibile, ma questo introduce varianza. D’altro canto, possiamo ridurre la varianza semplificando il modello, ma così introduciamo bias. Non c’è modo di sfuggire a questa relazione. L’alternativa migliore è scegliere e configurare un modello in modo che trovi un equilibrio nel compromesso tra bias e varianza.
A causa di fattori sconosciuti che influenzano la funzione obiettivo, ci sarà sempre un po’ di errore presente nel modello, noto come errore irriducibile. Lo si può osservare nell’immagine sopra notando la quantità di errore che si verifica nel punto più basso del grafico del Total Error. Per costruire il modello ideale, dobbiamo trovare un equilibrio tra bias e varianza tale che l’errore totale sia minimizzato. Questo è illustrato dalla linea tratteggiata chiamata Optimum Model Complexity.
Approfondiamo bias e varianza usando le learning curve.
Anatomia di una learning curve
Le learning curve sono grafici usati per mostrare le prestazioni di un modello all’aumentare della dimensione del set di addestramento. Un altro modo d’uso è mostrare le prestazioni del modello su un periodo di tempo definito. In genere le utilizziamo per diagnosticare algoritmi che apprendono incrementalmente dai dati. Funziona valutando un modello sui dataset di training e di validazione, quindi tracciando le prestazioni misurate.
Per esempio, immagina di aver modellato la relazione tra alcuni input e output usando un algoritmo di machine learning. Iniziamo addestrando il modello su una sola istanza e validandolo su cento istanze. Cosa pensi accadrà? Se hai detto che il modello apprenderà perfettamente i dati di addestramento, hai ragione: non ci sarebbero errori.
Non è difficile modellare la relazione tra un singolo input e output; basta ricordarsi quella relazione. La parte difficile è fare previsioni accurate quando si presentano nuove istanze mai viste. Poiché il nostro modello ha imparato così bene i dati di addestramento, avrebbe enormi difficoltà a generalizzare a dati che non ha mai visto. Di conseguenza, il modello si comporterà male sui dati di validazione. Questo significa che ci sarebbe una grande differenza tra le prestazioni del modello sui dati di training e su quelli di validazione. Chiamiamo questa differenza errore di generalizzazione.
Se il nostro algoritmo vuole avere qualche possibilità di migliorare le previsioni sul dataset di validazione, dobbiamo aggiungere più dati. L’introduzione di nuove istanze nei dati di addestramento cambierà inevitabilmente la funzione obiettivo del modello. Le prestazioni del modello man mano che il dataset di training cresce possono essere monitorate e tracciate per mostrare l’evoluzione degli errori di training e di validazione.
Questo significa che il grafico mostrerà due risultati diversi:
- Curva di training: la curva calcolata dai dati di addestramento; serve a capire quanto bene il modello sta apprendendo.
- Curva di validazione: la curva calcolata dai dati di validazione; serve a capire quanto bene il modello sta generalizzando a istanze mai viste.
Queste curve ci mostrano quanto bene il modello sta performando man mano che i dati crescono, da qui il nome learning curve.
Nota: lo stesso processo può essere usato per capire come il modello apprende nel tempo. Invece di monitorare il modello mentre i dati aumentano, monitoriamo quanto bene apprende nel tempo. Per esempio, potresti decidere di imparare una nuova lingua. La tua padronanza potrebbe essere valutata e assegnata un punteggio numerico per mostrare come te la sei cavata nel corso di 52 settimane.
Ora che conosci l’anatomia di una learning curve, mettiamola in pratica con un dataset reale per darti una comprensione visiva.
Use case: prevedere le valutazioni immobiliari
Useremo il dataset: market historical data set of real estate valuation. Questi dati sono stati raccolti a Sindian Dist., New Taipei, Taiwan e consistono in dati storici di mercato.
Il nostro compito è prevedere la valutazione immobiliare date le seguenti feature:
- X1=data della transazione (ad esempio, 2013.250=marzo 2013, 2013.500=giugno 2013, ecc.)
- X2=età dell’immobile (unità: anni)
- X3=distanza dalla stazione MRT più vicina (unità: metri)
- X4=numero di minimarket nel raggio percorribile a piedi (intero)
- X5=coordinata geografica, latitudine (unità: gradi)
- X6=coordinata geografica, longitudine (unità: gradi)
La variabile target è definita come:
- Y= prezzo della casa per unità di superficie (10000 Nuovi Dollari Taiwanesi/Ping, dove Ping è un’unità locale, 1 Ping = 3,3 metri quadrati)
Il target che stiamo prevedendo è continuo, quindi il problema richiederà tecniche di regressione.
Cominciamo dando un’occhiata ai dati:
import pandas as pd
data = pd.read_excel("/content/gdrive/MyDrive/real_estate_valuation_data.xlsx")
print(data.info())
data.head()
>>>>
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 414 entries, 0 to 413
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 No 414 non-null int64
1 X1 transaction date 414 non-null float64
2 X2 house age 414 non-null float64
3 X3 distance to the nearest MRT station 414 non-null float64
4 X4 number of convenience stores 414 non-null int64
5 X5 latitude 414 non-null float64
6 X6 longitude 414 non-null float64
7 Y house price of unit area 414 non-null float64
dtypes: float64(6), int64(2)
memory usage: 26.0 KB
None
No X1 transaction date X2 house age X3 distance to the nearest MRT station X4 number of convenience stores X5 latitude X6 longitude Y house price of unit area
0 1 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 3 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 4 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 5 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
C’è una feature extra chiamata No che non era menzionata nella documentazione dei dati. È possibile che si riferisca a un indice, ma per semplicità la rimuoveremo. Inoltre, i nomi delle feature non riflettono quanto indicato in documentazione, quindi faremo un po’ di pulizia.
# rename the columns
renamed_columns = [col.split()[0] for col in data.columns]
renamed_columns_map = {data.columns[i]:renamed_columns[i] for i in range(len(data.columns))}
data.rename(renamed_columns_map, axis=1, inplace=True)
# remove No column
data.drop("No", axis=1, inplace=True)
print(data.head())
# separate features and target data
features, target = data.columns[:-1], data.columns[-1]
X = data[features]
y = data[target]
Ecco come appare il dataset finale prima di separare feature e target:
X1 X2 X3 X4 X5 X6 Y
0 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
Per dimostrare bias, varianza e soluzioni con buon fitting, costruiremo tre modelli: un decision tree regressor, una support vector machine per la regressione e un random forest regressor. Dopo aver costruito i modelli, tracceremo le learning curve per ciascuno e condivideremo alcune tecniche di diagnosi.
Diagnosticare le learning curve
Le learning curve si interpretano valutandone la forma. Una volta interpretata forma e dinamica, possiamo usarle per diagnosticare eventuali problemi nel comportamento di un modello di machine learning.
La funzione learning_curve() in Scikit-learn rende semplice monitorare gli score di training e validazione, che è ciò che serve per tracciare una learning curve.
I parametri che passiamo alla funzione learning_curve() sono i seguenti:
- estimator: il modello usato per approssimare la funzione obiettivo
- X: i dati di input
- y: il target
- cv: la strategia di suddivisione per la cross-validation
- scoring: la metrica usata per valutare le prestazioni del modello
- train_sizes: i numeri assoluti di esempi di training che verranno utilizzati per generare la learning curve; i valori che usiamo sono completamente arbitrari.
Modello 1: Decision tree regressor
Un modello con alta varianza si dice overfit. Impara molto bene sia i dati di addestramento sia il rumore casuale, con il risultato di un modello che va bene sui dati di training ma non sa generalizzare a istanze mai viste. Osserviamo tale comportamento quando l’algoritmo usato è troppo flessibile per il problema da risolvere o quando il modello è addestrato troppo a lungo.
Per esempio, il decision tree regressor è un algoritmo di machine learning non lineare. Gli algoritmi non lineari tipicamente hanno basso bias e alta varianza. Questo suggerisce che cambiamenti al dataset causeranno grandi variazioni nella funzione obiettivo.
Dimostriamo l’alta varianza con il nostro decision tree regressor:
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt
# overfitting
decision_tree = DecisionTreeRegressor()
train_sizes, train_scores, test_scores = learning_curve(
estimator=decision_tree,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 165, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Il modello commette pochissimi errori quando deve prevedere istanze viste durante l’addestramento, ma va molto male su nuove istanze a cui non è stato esposto. Puoi osservare questo comportamento notando quanto è grande l’errore di generalizzazione tra la curva di training e quella di validazione. Una soluzione per migliorare questo comportamento può essere aggiungere più istanze al dataset di training, il che introduce bias. Un’altra soluzione può essere aggiungere regolarizzazione al modello (cioè impedire all’albero di crescere fino alla massima profondità).
Modello 2: Support Vector Machine
Un modello con alto bias si dice underfit. Fa assunzioni semplicistiche sui dati di addestramento, il che rende difficile apprendere gli schemi sottostanti. Ne risulta un modello con alto errore sia sui dataset di training sia di validazione. Possiamo osservare tale comportamento quando il modello usato è troppo semplice per il problema da risolvere o quando non viene addestrato abbastanza a lungo.
Per esempio, la support vector machine è un algoritmo lineare di machine learning. Gli algoritmi lineari tipicamente hanno alto bias e bassa varianza. Questo suggerisce che si fanno più assunzioni sulla forma della funzione obiettivo. Per introdurre più bias nel nostro modello, abbiamo aggiunto regolarizzazione impostando il parametro C nel modello.
Dimostriamo l’alto bias con la nostra support vector machine:
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
# Underfitting
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
svm = SVR(C=0.25)
train_sizes, train_scores, test_scores = learning_curve(
estimator=svm,
X=X_scaled,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Il divario di generalizzazione tra la curva di training e quella di validazione diventa estremamente piccolo all’aumentare della dimensione del dataset di training. Questo indica che aggiungere più esempi al modello non ne migliorerà le prestazioni. Una soluzione può essere creare più feature o rendere il modello più flessibile per ridurre il numero di assunzioni.
Modello 3: Random Forest Regressor
Un modello con buon fitting si colloca nella zona grigia tra underfitting e overfitting. Potrebbe non essere così performante sui dati di training come nel caso di overfitting, ma commetterà molti meno errori quando affronta istanze mai viste. Questo comportamento si osserva quando l’errore di training aumenta, ma solo fino a stabilizzarsi, mentre l’errore di validazione diminuisce fino a stabilizzarsi.
Per dimostrarlo useremo una random forest, che è un ensemble di alberi decisionali. Questo significa che il modello è anch’esso non lineare, ma si aggiunge bias creando più modelli diversi e combinandone le previsioni.
Abbiamo anche aggiunto più regolarizzazione impostando max_depth, che controlla la profondità massima di ciascun albero, a tre.
Vediamo come appare in codice:
from sklearn.ensemble import RandomForestRegressor
# better
random_forest = RandomForestRegressor(max_depth=3)
train_sizes, train_scores, test_scores = learning_curve(
estimator=random_forest,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Ora puoi vedere che abbiamo ridotto l’errore nei dati di validazione. È avvenuto al costo di prestazioni indebolite sui dati di training, ma nel complesso è un modello migliore.
L’errore di generalizzazione è molto più piccolo, con un numero basso di errori. Inoltre, entrambe le curve sono stabili oltre una dimensione del training set pari a 250, il che implica che aggiungere altre istanze potrebbe non migliorare molto ulteriormente questo modello.
In sintesi, il comportamento di un modello può essere osservato usando le learning curve. Lo scenario ideale quando si costruiscono modelli di machine learning è mantenere l’errore il più basso possibile. Due fattori che portano ad alto errore sono bias e varianza, e saper trovare un equilibrio tra i due si tradurrà in un modello più performante.
