Tutorial sul Modelling a Ensemble: esplora le tecniche di Ensemble Learning

I modelli di machine learning non sono come le soluzioni software tradizionali. Questi modelli richiedono aggiornamenti costanti man mano che arrivano nuovi dati, per garantire previsioni accurate e affidabili. In scenari complessi e sensibili, affidarsi a un singolo modello potrebbe non essere sufficiente per ottenere un risultato ottimale, ed è qui che l'ensemble modeling può aiutare.

Questo tutorial concettuale spiega cos'è l'ensemble modeling nel machine learning e come può migliorare le prestazioni complessive del tuo modello. Poi forniremo una panoramica dei vari metodi a ensemble prima di passare all'illustrazione di uno scenario reale con un'implementazione passo passo in Python.

Il nostro tutorial Ensemble Learning in R con SuperLearner spiega come potenziare i risultati di machine learning basandosi sull'approccio di ensemble learning con il pacchetto SuperLearner in R.

Modelli a Ensemble nel Machine Learning

Immagina un manager musicale che partecipa a una competizione internazionale. Ha accesso a un'ampia varietà di musicisti con competenze diverse:

• Musicisti classici con la capacità di comporre brani tradizionali.
• Musicisti elettronici esperti nell'uso di strumenti elettronici.
• Musicisti jazz con un grande senso dell'improvvisazione.
• Solisti in grado di eseguire assoli complessi e mettere in risalto le proprie abilità tecniche.

Data l'ampia gamma di competenze e background musicali, il manager può combinarle per creare un'esibizione unica e memorabile.

Pensa ai modelli a ensemble come a un'orchestra di musicisti, in cui ognuno è specializzato in uno strumento specifico come pianoforte, tromba, batteria e altro. La combinazione di queste abilità crea una melodia armoniosa.

L'ensemble learning segue la stessa logica:

combina più algoritmi per ottenere prestazioni predittive migliori rispetto a quelle di un singolo modello. Non c'è un numero predefinito di modelli da considerare e alcuni obiettivi di business possono richiederne più di altri.

Errore del Modello e Riduzione dell'Errore con gli Ensemble

L'errore che emerge da qualsiasi modello può essere scomposto matematicamente in tre componenti:

Bias + Varianza + Errore irriducibile

Perché è importante in questo contesto? Per capire cosa succede dietro a un modello a ensemble, devi prima conoscere le cause dell'errore nel modello.

Vediamo questi errori:

Errore di bias

È utile per quantificare quanto, in media, i valori previsti si discostano dal valore reale. Un alto bias significa che abbiamo un modello poco performante che continua a perdere tendenze essenziali.

Varianza

Dall'altra parte, la varianza quantifica quanto differiscono tra loro le previsioni fatte sulla stessa osservazione. Un modello con alta varianza farà overfitting sulla popolazione di training e si comporterà male su osservazioni al di fuori del training. Il seguente diagramma chiarisce meglio la questione (supponi che il punto rosso sia il valore reale e i punti blu le previsioni):

In genere, aumentando la complessità del modello, vedrai una riduzione dell'errore dovuta a un bias più basso. Tuttavia, ciò accade solo fino a un certo punto. Continuando ad aumentare la complessità, finisci per fare overfitting e il modello inizierà a soffrire di alta varianza.

Ora che hai familiarità con le basi dell'ensemble learning, vediamo diverse tecniche di ensemble learning:

Tipi di Metodi a Ensemble

Esistono diversi tipi di metodi a ensemble, ognuno con i propri vantaggi e svantaggi. Questa sezione tratta questi aspetti per aiutarti a scegliere la soluzione giusta per i tuoi casi d'uso.

Prima di approfondire ciascun metodo, capiamo cosa sono i meta e i base learner per comprendere meglio i concetti successivi.

• Base learner sono il primo livello di un'architettura di ensemble learning e ognuno di essi viene addestrato per fare previsioni individuali.
• Meta learner, invece, sono al secondo livello e vengono addestrati sull'output dei base learner.

Bagging

Il bagging è noto anche come bootstrap aggregation. Questa tecnica è simile alla random forest, ma usa tutti i predittori, mentre la random forest utilizza solo un sottoinsieme di predittori in ciascun albero.

Nel bagging, un campione casuale di dati del training set è selezionato con reinserimento, il che permette la duplicazione di istanze nel campione. Di seguito i passaggi principali del bagging:

• Generazione di più bootstrap resample.
• Esecuzione di un algoritmo su ciascun resample per fare previsioni.
• Combinazione delle previsioni facendo la media delle previsioni o prendendo il voto di maggioranza (per la classificazione).

Il bagging presenta diversi vantaggi e svantaggi chiave quando è usato per compiti di classificazione o regressione.

Vantaggi

• Il processo di modellazione è semplice, non richiede concetti matematici avanzati e può gestire valori mancanti.
• Il pacchetto scikit-learn semplifica l'implementazione della logica sottostante. Contiene tutti i moduli per combinare le previsioni di ciascun modello, detti base learner.
• Ha un effetto significativo nella riduzione della varianza su classificatori ad alta varianza. Questo è utile con dati ad alta dimensionalità, evitando che il modello generalizzi male su nuovi dati.
• Il bagging fornisce una stima non distorta dell'errore out-of-bag, che corrisponde all'errore/perdita media restituita da tutti questi classificatori.

Svantaggi

• Il bagging è computazionalmente costoso a causa dell'uso di diversi modelli.
• La media effettuata sulle previsioni rende difficile interpretare il risultato finale.

Boosting

Il boosting adotta un approccio sequenziale, in cui la previsione del modello corrente viene trasferita al successivo. Ogni modello concentra iterativamente l'attenzione sulle osservazioni misclassificate dai suoi predecessori. Ecco il processo generale:

Vantaggi

• Come il bagging, il boosting è facile da capire e da implementare. Inoltre, non richiede preprocessing e può gestire valori mancanti nei dati.
• Riduce efficientemente il bias.
• Gli algoritmi di boosting danno priorità alle caratteristiche che aumentano l'accuratezza complessiva durante il training. Questo processo riduce la dimensionalità dei dati, riducendo così i tempi di calcolo.

Svantaggi

• L'approccio sequenziale fa sì che i modelli successivi correggano gli errori dei precedenti. Questo rende il modello complessivo vulnerabile agli outlier.
• Per lo stesso motivo legato alla sequenzialità, il boosting non è molto scalabile.

Stacking

Lo stacking è abbastanza simile al boosting. Le previsioni dei base learner vengono impilate insieme e usate come input per addestrare il meta learner a produrre previsioni più robuste. Il meta learner viene poi usato per fare le previsioni finali. Bagging e boosting tipicamente usano base learner omogenei, mentre lo stacking tende a includere base learner eterogenei.

Vantaggi

• Sfrutta i punti di forza di più modelli ad alte prestazioni sia per classificazione sia per regressione.
• Come altri modelli a ensemble, lo stacking aiuta a costruire un modello più accurato rispetto ai singoli modelli usati da soli.

Svantaggi

• L'uso di modelli di base complessi può aumentare il rischio di overfitting.
• I diversi livelli del training possono rendere l'architettura di stacking complessa da implementare.

Blending

Il blending è simile allo stacking. Nel blending, la struttura dei dati è composta da training, hold-out e test. I meta learner sono addestrati sui dati di training. Poi le loro previsioni sono combinate con i dati hold-out per costruire il meta modello finale, che usa i dati di test per fare le previsioni finali.

Vantaggi

• Come lo stacking e molti altri metodi a ensemble, il blending può aumentare le prestazioni del modello finale in molti casi.
• Questa tecnica è stata usata con successo per vincere molte competizioni.

Svantaggi

• Suddividere i dati originali secondo l'architettura di blending può limitare l'uso di dati per addestrare i modelli di base, con conseguenti prestazioni inferiori.
• Come altri modelli a ensemble, l'interpretabilità del modello finale è ridotta per via della maggiore complessità, rendendo difficile trarre insight di business cruciali.

Voting

Nel voting, più modelli sono addestrati in modo indipendente e le loro previsioni sono combinate per arrivare a una previsione finale usando hard voting, soft voting o weighted voting:

• Nell'hard voting, la previsione finale è quella più comune tra tutti i modelli.
• Nel soft voting, ogni modello genera una distribuzione di probabilità invece di una previsione binaria. Viene quindi predetta la classe con probabilità più alta.
• Infine, nel weighted voting si assume che alcuni modelli siano più abili di altri e a questi modelli viene assegnato un peso maggiore nel contribuire alla previsione.

Vantaggi

• L'architettura di voting è semplice da implementare rispetto a stacking e blending. Inoltre, non richiede un raffinato fine-tuning.
• L'uso di più base learner nel voting lo rende meno suscettibile all'influenza di singoli modelli, contribuendo a previsioni più stabili e affidabili.

Svantaggi

• Può essere difficile gestire il conflitto tra le previsioni dei modelli, rendendo arduo prendere una decisione finale significativa.
• Aggiungere più modelli all'ensemble di voting non migliora necessariamente le prestazioni finali.

Cascading

Il cascading usa un approccio di stacking ma con un solo modello in ciascun livello. Il primo modello è addestrato su tutti i dati di training e il successivo è addestrato sull'output del modello precedente. L'obiettivo di questa strategia è imparare pattern complessi dai dati, permettendo al modello di fare previsioni migliori.

Vantaggi

• Il modello successivo è specializzato nell'output di quello precedente, riducendo il rumore nei dati.
• Più robusto all'overfitting e in grado di funzionare bene su dati del mondo reale.

Svantaggi

• Implementare il cascading può essere complesso perché comporta l'addestramento di ciascun modello nella sequenza.
• Trovare l'architettura ottimale può richiedere molta sperimentazione e fine-tuning.

Panoramica degli Algoritmi a Ensemble

Le sezioni precedenti hanno illustrato i diversi tipi di modelli a ensemble. Ora vediamo brevemente alcuni modelli popolari.

Random Forest

La Random Forest è un modello comunemente usato che può risolvere sia problemi di classificazione sia di regressione. Una random forest è composta da molti alberi decisionali addestrati tramite bagging. Il suo risultato è determinato facendo la media delle previsioni dei singoli alberi.

La dimensione del nodo, il numero di alberi e il numero di feature campionate sono i tre principali iperparametri da impostare prima dell'addestramento.

E la casualità nella random forest?

Il feature bagging, noto anche come feature randomness, crea un campione casuale di feature per garantire bassa correlazione tra gli alberi decisionali. Questo approccio distingue le random forest dagli alberi decisionali, che considerano tutte le possibili suddivisioni delle feature, mentre le random forest ne considerano solo un sottoinsieme. Leggi di più nel nostro tutorial sulla classificazione con random forest.

XGBoost

Extreme Gradient Boosting, o XGBoost in breve, è usato sia per classificazione sia per regressione. XGBoost è progettato per essere scalabile e altamente efficiente e implementa il framework dei gradient boosting decision trees.

È adatto all'elaborazione di dataset su larga scala ed è compatibile con i principali ambienti distribuiti come Hadoop, MPI (Message Passing Inference) e SGI (Sun Grid Engine). Puoi saperne di più nel nostro tutorial su XGBoost.

AdaBoost

Adaptive Boosting, o AdaBoost, è uno dei primi classificatori di boosting di successo per la classificazione binaria. È “adattivo” perché i pesi sono riassegnati a ogni istanza e alle istanze misclassificate vengono assegnati pesi più alti. Leggi di più su AdaBoost Classification in Python nel nostro tutorial dedicato.

Un'Implementazione Passo Passo di Modelli a Ensemble

Ora che hai capito l'idea principale dell'ensemble modeling e come funzionano alcuni modelli, in questa sezione ci concentreremo sull'implementazione tecnica usando Python.

Configurare l'ambiente

Per iniziare, devi avere installato Python sul tuo computer, insieme alle seguenti librerie:

• pandas per caricare il data frame.
• Scikit-learn per usare gli algoritmi di machine learning esistenti.
• Seaborn e matplotlib per la visualizzazione.

Puoi installare queste librerie usando pip, il gestore pacchetti di Python, come segue:

pip install scikit-learn
pip install pandas
pip install matplotlib seaborn

Per illustrare meglio il caso d'uso, useremo i dati sui prestiti disponibili su DataLab. Il codice di questo tutorial è disponibile anche su DataLab in questa workbook; puoi creare una tua copia della workbook ed eseguire il codice nel browser senza dover installare nulla sul tuo computer.

Comprendere i dati

Il dataset contiene 9.500 prestiti con informazioni sulla struttura del prestito, sul debitore e sull'eventuale rimborso completo, rappresentato dalla colonna not.fully.paid. Le prime cinque osservazioni sono mostrate di seguito:

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()

L'uso della funzione info() genera le seguenti informazioni rilevanti sui dati:

• 9.578 righe (da 0 a 9577) e 14 colonne di tipo numerico tranne purpose, che è di tipo object e fornisce la descrizione testuale dello scopo del prestito.
• Il tag non-null per ogni colonna indica che non ci sono informazioni mancanti in quella specifica colonna, in nessuna delle colonne.

loan_data.info()

Notiamo uno scenario di dati sbilanciati, in cui ci sono molte più osservazioni con classe 0 (8045 osservazioni) rispetto alla classe 1 (solo 1533 osservazioni).

print(loan_data['not.fully.paid'].value_counts())
loan_data['not.fully.paid'].value_counts().plot(kind='barh')

Usare dati così sbilanciati per l'addestramento del modello influenza le prestazioni complessive.

Un modo per affrontare questo problema è l'approccio di undersampling, ovvero ridurre il numero di osservazioni della classe maggioritaria (classe 0). In questo scenario, ci saranno tante osservazioni per la classe 0 quante per la classe 1, e il processo è il seguente:

• Per prima cosa, ottieni il numero di osservazioni della classe 1.

• Seleziona N osservazioni casuali dalla classe 0, dove N è la dimensione del dataframe della classe 1.

• Concatena i due dataframe precedenti.

loan_data_class_1 = loan_data[loan_data['not.fully.paid'] == 1]
number_class_1 = len(loan_data_class_1)
loan_data_class_0 = loan_data[loan_data['not.fully.paid'] == 0].sample(number_class_1)

final_loan_data = pd.concat([loan_data_class_1,
                         	loan_data_class_0])

print(final_loan_data.shape)

Il tutorial Diving Deep with Imbalanced Data fornisce ulteriori risorse per imparare le tecniche per gestire un dataset sbilanciato.

Dopo l'undersampling, otteniamo:

• In totale 3066 osservazioni e 14 colonne.

E la distribuzione bilanciata finale è mostrata di seguito.

Preparare i dati per l'addestramento

Osservando il dataset, notiamo che non tutte le feature hanno la stessa scala e alcuni modelli di machine learning come KNN sono sensibili a tale scala. Questo problema può essere affrontato normalizzando gli intervalli delle feature sulla stessa scala usando il modulo MinMaxScaler. In questo caso, tra 0 e 1.

Inoltre, rimuoveremo la colonna purpose per semplicità, poiché richiede ulteriore preprocessing.

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

# Remove unwanted 'purpose' column and get the data
final_loan_data.drop('purpose', axis=1, inplace=True)
X = final_loan_data.drop('not.fully.paid', axis=1)

normalized_X = scaler.fit_transform(X)

Come in qualsiasi attività predittiva, dobbiamo suddividere i dati in set di training e di test. In questo caso useremo il 77% per il training e il restante 33% per il test.

• L'attributo random state è inizializzato con un valore casuale (nel nostro caso 2023) per garantire la riproducibilità dei risultati.

Stratify è usato per assicurare che il valore target y sia distribuito uniformemente sia nei dati di training che in quelli di test.

from sklearn.model_selection import train_test_split

y = final_loan_data['not.fully.paid']
r_state = 2023
t_size = 0.33

X_train, X_test, y_train, y_test = train_test_split(normalized_X, y,
                                                	test_size=t_size,
                                                	random_state=r_state,
                                                	stratify=y)

Tutti i modelli seguiranno la sequenza di addestramento sui dati di training, previsione sui dati di test e valutazione delle prestazioni dei modelli.

Modello di bagging

La Random Forest è il modello di bagging usato in questa sezione. Useremo i parametri di default per semplicità.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# Define the model
random_forest_model = RandomForestClassifier()
# Fit the random search object to the data
random_forest_model.fit(X_train, y_train)

Dopo l'addestramento, le prestazioni vengono calcolate usando la funzione accuracy_score come segue:

# Make predictions
y_pred = random_forest_model.predict(X_test)

# Get the performance
accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy) 

La precedente istruzione print genera 0.6156, ovvero il 61,56%

Ora confrontiamo questo punteggio con le prestazioni di un approccio di aggregazione tramite blending.

Modello di blending

Per il blending useremo due modelli di base: un albero decisionale e un classificatore K-Nearest Neighbors. Un modello di regressione finale è usato per effettuare le previsioni finali.

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression

I dati di training originali sono suddivisi in un nuovo set di training e un set di validazione. I modelli di base sono addestrati sui dati di training.

X_train, X_val, y_train, y_val = train_test_split(
                                            	X_train, y_train,
                                            	test_size=t_size,
                                            	random_state=r_state)
Vengono quindi generati due dataframe dalle previsioni di questi modelli di base:

Primo dataframe con le previsioni sui dati di validazione concatenate con i dati di validazione originali.
Secondo dataframe con le previsioni sui dati di test concatenate con i dati di test originali.

# Decision Tree Model
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_model_pred_val = dt_model.predict(X_val)
dt_model_pred_test= dt_model.predict(X_test)

dt_model_pred_val = pd.DataFrame(dt_model_pred_val)
dt_model_pred_test = pd.DataFrame(dt_model_pred_test)

# KNN Model
knn_model = KNeighborsClassifier()
knn_model.fit(X_train,y_train)
knn_model_pred_val = knn_model.predict(X_val)
knn_model_pred_test = knn_model.predict(X_test)

knn_model_pred_val = pd.DataFrame(knn_model_pred_val)
knn_model_pred_test = pd.DataFrame(knn_model_pred_test)

Il modello finale di regressione logistica è costruito usando i dati di validazione concatenati e valutato usando i dati di test concatenati.
x_val = pd.DataFrame(X_val)
x_test = pd.DataFrame(X_test)

df_val_lr = pd.concat([x_val, knn_model_pred_val,
                    	dt_model_pred_val], axis=1)

df_test_lr = pd.concat([x_test, dt_model_pred_test,
                     	knn_model_pred_test],axis=1)

# Logistic Regression Model
lr_model = LogisticRegression()

lr_model.fit(df_val_lr,y_val)
lr_model.score(df_test_lr,y_test)
Usando la funzione .score() viene calcolato di default l'accuracy score e non richiede previsioni esplicite.
Il risultato di prestazione è 0.6383, cioè 63,83% ed è circa il 2% più alto rispetto alla random forest iniziale; quindi il modello di blending fornisce le prestazioni migliori.
Il nostro corso Ensemble Methods in Python e Machine Learning with Tree-Based Models in R possono essere un ottimo prossimo passo per proseguire il tuo percorso nel machine learning, approfondendo il mondo dei metodi di classificazione a ensemble, rispettivamente in Python e R.
Conclusione
Questo articolo ha trattato diversi tipi di ensemble modeling insieme alle loro caratteristiche, ai vantaggi e agli svantaggi. Ha inoltre fornito una breve panoramica di alcuni algoritmi basati su modelli a ensemble come Random Forest, Adaboost, XGBoost, Gradient Boosting Trees e Gradient Boosting Machines.
Quando costruisci modelli a ensemble, è importante essere consapevoli dei loro pro e contro per ottenere migliori insight di business.
FAQ
Qual è la differenza tra learner omogenei ed eterogenei?
I learner omogenei utilizzano un tipo simile di algoritmo e iperparametri. La random forest può essere considerata un ensemble di learner omogenei.
Quelli eterogenei, invece, hanno algoritmi e iperparametri diversi. Random forest, reti neurali e KNN possono essere learner eterogenei di un modello a ensemble.
Quali sono i vantaggi dei modelli a ensemble rispetto ai singoli modelli?
Usare modelli a ensemble può portare a previsioni migliori rispetto a un singolo modello.
Qual è la limitazione dei modelli a ensemble?
I modelli a ensemble possono soffrire di mancanza di interpretabilità, nel senso che la conoscenza appresa dai modelli a ensemble non è comprensibile per gli utenti finali.
Quando dovresti evitare di usare modelli a ensemble?
L'uso dei modelli a ensemble dovrebbe essere evitato nelle seguenti condizioni, tra le altre: alta interpretabilità, dati limitati, vincoli di tempo reale e costi computazionali elevati.
Quali sono i diversi tipi di metodi a ensemble nel machine learning?
Bagging, boosting, stacking, voting, blending e cascading sono i principali tipi di metodi a ensemble nel machine learning.