Cos’è il Bagging nel Machine Learning? Guida con esempi

I metodi di ensemble sono tecniche potenti nel machine learning che combinano più modelli per migliorare l’accuratezza complessiva delle previsioni e la stabilità del modello. Il Bootstrap Aggregating, meglio conosciuto come Bagging, spicca come un metodo di ensemble popolare e ampiamente utilizzato.

In questo tutorial approfondiremo il bagging, come funziona e dove dà il meglio. Lo confronteremo con un altro metodo di ensemble (Boosting) e vedremo un esempio di bagging in Python. Alla fine, avrai una solida comprensione del bagging, incluse le best practice.

Capire l’Ensemble Learning

L’Ensemble Modeling è una tecnica che combina più modelli di machine learning per migliorare le prestazioni predittive complessive. L’idea di base è che un gruppo di weak learner possa unirsi per formare un strong learner.

Un modello di ensemble in genere consiste di due passaggi:

1. Più modelli di machine learning vengono addestrati in modo indipendente.
2. Le loro previsioni vengono aggregate in qualche modo, ad esempio tramite voto, media o pesatura. Questo ensemble viene poi usato per effettuare la previsione complessiva.

Gli ensemble tendono a fornire risultati migliori perché i diversi modelli si completano a vicenda e superano le singole debolezze. Inoltre riducono la varianza e prevengono l’overfitting.

Alcuni metodi di ensemble popolari sono bagging, boosting e stacking. L’ensemble learning è ampiamente usato in compiti di machine learning come classificazione, regressione e clustering per aumentare accuratezza e robustezza.

Che cos’è il Bagging?

Il bagging (bootstrap aggregating) è un metodo di ensemble che prevede l’addestramento di più modelli in modo indipendente su sottoinsiemi casuali dei dati e l’aggregazione delle loro previsioni tramite voto o media.

Nel dettaglio, ciascun modello è addestrato su un sottoinsieme casuale dei dati con campionamento con reinserimento, il che significa che i singoli punti dati possono essere selezionati più di una volta. Questo sottoinsieme casuale è noto come campione bootstrap. Addestrando i modelli su bootstrap diversi, il bagging riduce la varianza dei singoli modelli. Evita anche l’overfitting esponendo i modelli costituenti a parti differenti del dataset.

Le previsioni di tutti i modelli campionati vengono poi combinate tramite una semplice media per produrre la previsione complessiva. In questo modo, il modello aggregato incorpora i punti di forza dei singoli modelli e ne annulla gli errori.

Il bagging è particolarmente efficace nel ridurre varianza e overfitting, rendendo il modello più robusto e accurato, soprattutto quando i singoli modelli sono soggetti ad alta variabilità.

Bagging vs. Boosting

Il boosting è un altro popolare metodo di ensemble spesso confrontato con il bagging. La differenza principale sta nel modo in cui i modelli costituenti vengono addestrati.

Nel bagging, i modelli sono addestrati in parallelo in modo indipendente su diversi sottoinsiemi casuali dei dati. Nel boosting, invece, i modelli sono addestrati in sequenza e ciascun modello apprende dagli errori del precedente. Inoltre, il bagging prevede in genere una semplice media dei modelli, mentre il boosting assegna pesi in base all’accuratezza.

Il bagging riduce la varianza, mentre il boosting riduce il bias. Il bagging può essere usato con modelli instabili come gli alberi decisionali, mentre il boosting funziona meglio con modelli stabili come la regressione lineare.

Entrambi i metodi hanno punti di forza e debolezze. Il bagging è più semplice da eseguire in parallelo, mentre il boosting può essere più potente e accurato. In pratica, conviene testare entrambi su un nuovo problema per vedere quale funziona meglio.

Vantaggi del Bagging

Ecco alcuni vantaggi chiave del bagging:

1. Riduce l’overfitting: può diminuire la probabilità di overfitting, con conseguente miglioramento dell’accuratezza su dati mai visti.
2. Riduce la varianza del modello: più modelli addestrati su sottoinsiemi diversi dei dati fanno la media delle loro previsioni, portando a una varianza inferiore rispetto a un singolo modello.
3. Migliora la stabilità: i cambiamenti nel dataset di training hanno meno impatto sui modelli bagged, rendendo il modello complessivo più stabile.
4. Gestisce alta variabilità: particolarmente efficace per algoritmi come gli alberi decisionali, che tendono ad avere alta varianza.
5. Calcolo parallelizzabile: ogni modello nell’ensemble può essere addestrato in modo indipendente, consentendo l’elaborazione parallela e un uso efficiente delle risorse computazionali.
6. Facile da capire e implementare: il concetto alla base del bagging è semplice e può essere implementato senza modifiche complesse all’algoritmo di apprendimento.
7. Buono con dati rumorosi: il processo di media aiuta a ridurre il rumore nella previsione finale.
8. Gestisce dati sbilanciati: il bagging può aiutare in scenari in cui il dataset è sbilanciato, migliorando le prestazioni del modello in tali situazioni.

Bagging in Python: breve tutorial

In questo tutorial Python, alleneremo un modello di classificazione con albero decisionale su un dataset di churn dei clienti telecom e useremo il metodo di ensemble bagging per migliorarne le prestazioni. Useremo DataLab per ottenere il dataset ed eseguire il codice. Il codice è disponibile anche in questo workbook DataLab, che puoi copiare per eseguirlo nel browser senza installare nulla.

Dataset

Il dataset sul churn dei clienti telecom proviene da un’azienda di telecomunicazioni iraniana. Ogni riga del dataset corrisponde all’attività di un cliente nell’arco di un anno, incluse informazioni su chiamate non riuscite, durata dell’abbonamento e un’etichetta di churn che indica se il cliente ha lasciato il servizio.

Per prima cosa caricheremo il dataset e visualizzeremo le prime 5 righe.

import pandas as pd

customer = pd.read_csv("data/customer_churn.csv")
customer.head()Offerto da

Successivamente, creeremo le variabili indipendenti (X) e dipendenti (y). Poi divideremo il dataset in sottoinsiemi di training e test.

X = customer.drop("Churn", axis=1)
y = customer.Churn

# Split into train and test 
from sklearn.model_selection import train_test_split, cross_val_score
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)Offerto da

Addestra un modello di machine learning

Creeremo una semplice pipeline di machine learning e la adatteremo al dataset di training. La pipeline normalizzerà i dati prima di passare gli input al classificatore ad albero decisionale.

from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', DecisionTreeClassifier(random_state=42))
])

pipeline.fit(X_train, y_train)Offerto da

Segui il corso Machine Learning with Tree-Based Models in Python per imparare a usare modelli basati su alberi ed ensemble per regressione e classificazione con scikit-learn.

Valutazione del modello

Valuteremo un modello ad albero decisionale in modo da poterlo confrontare con il modello di ensemble.

Genereremo report di classificazione effettuando previsioni su un dataset di test.

from sklearn.metrics import classification_report

# Make prediction on the testing data
y_pred = pipeline.predict(X_test)

# Classification Report
print(classification_report(y_pred, y_test))Offerto da

Il nostro modello ha ottenuto il 96% di precision e il 97% di recall sulla classe maggioritaria “0”, ma ha performato male sulla classe minoritaria “1”.

Per comprendere meglio le prestazioni del modello, effettueremo la cross-validation e calcoleremo i relativi punteggi.

# Evaluate the classifier using cross-validation
cv_scores = cross_val_score(pipeline, X, y, cv=5)

print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {np.mean(cv_scores):.2f}")Offerto da

C’è un’alta variazione nei punteggi, con massimi al 95% e minimi al 92%.

Cross-validation scores: [0.95079365 0.94126984 0.93492063 0.94285714 0.92222222]
Mean CV accuracy: 0.94Offerto da

Bagging classifier

Ora creiamo un bagging classifier usando come base stimatore la nostra pipeline (scaler + classificatore ad albero decisionale) e alleniamolo sul dataset di training.

Possiamo migliorare le prestazioni del modello aumentando n_estimators, ma 50 sono sufficienti per risultati di base.

from sklearn.ensemble import BaggingClassifier

# Create a bagging classifier with the decision tree pipeline
bagging_classifier = BaggingClassifier(base_estimator=pipeline, n_estimators=50, random_state=42)

# Train the bagging classifier on the training data
bagging_classifier.fit(X_train, y_train)Offerto da

Valutare il modello di ensemble

Valutiamo ora i risultati del modello di ensemble e confrontiamoli con le prestazioni del singolo modello. Per farlo, genereremo report di classificazione su un dataset di test.

# Make prediction on the testing data
y_pred = bagging_classifier.predict(X_test)

# Classification Report
print(classification_report(y_pred, y_test))Offerto da

Come puoi vedere, abbiamo migliorato le prestazioni del modello in modo significativo. Precision e recall per la classe minoritaria sono aumentate rispettivamente dal 79% all’80% e dal 77% all’82%. Si tratta di un miglioramento rilevante.

Calcoliamo ora il punteggio di cross-validation.

# Evaluate the classifier using cross-validation
cv_scores = cross_val_score(bagging_classifier, X, y, cv=5)

print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {np.mean(cv_scores):.2f}")Offerto da

I nostri punteggi di cross-validation hanno bassa varianza, compresi tra il 94% e il 96%. L’accuratezza complessiva del modello è inoltre aumentata dal 94% al 95%.

Cross-validation scores: [0.95396825 0.95714286 0.94126984 0.96190476 0.95714286]
Mean CV accuracy: 0.95Offerto da

La tecnica del bagging è uno strumento utile nelle applicazioni di machine learning per migliorare accuratezza e stabilità del modello.

Impara tecniche di ensemble come bagging, boosting e stacking per costruire modelli di machine learning avanzati ed efficaci in Python con il corso Ensemble Methods in Python.

Best practice e consigli

Quando usi il bagging nel machine learning, seguire best practice e consigli può massimizzarne l’efficacia:

1. Usa il bagging quando hai modelli ad alta varianza come gli alberi decisionali per migliorarne la stabilità.
2. Combina bagging e cross-validation per una valutazione più affidabile dei tuoi modelli.
3. Usa le random forest (alberi decisionali con bagging) come tecnica di bagging potente e pronta all’uso.
4. Imposta un n_estimators più alto, ad esempio 100-200, quando fai bagging per ottenere il massimo beneficio.
5. Il bagging è facilmente parallelizzabile usando n_jobs. Implementalo su più CPU/macchine per un training più rapido.
6. Poiché il bagging si basa sul bootstrap sampling, assicurati che ogni modello sia addestrato su un sottoinsieme sufficientemente diversificato dei dati.
7. Prima di aggregare, ottimizza le prestazioni di ciascun modello usando GridSearchCV. Buone prestazioni dei singoli modelli di solito si traducono in prestazioni migliori dell’ensemble.

Leggi le best practice di MLOps (Machine Learning Operations) per scoprire pratiche di successo per un deployment affidabile e scalabile dei sistemi di machine learning.

Conclusione

In questo tutorial abbiamo esplorato il bagging, una potente tecnica di ensemble nel machine learning. Il bagging aggrega più modelli per migliorare le prestazioni predittive complessive. Lo abbiamo confrontato con il boosting e abbiamo visto i suoi vantaggi rispetto all’uso di un singolo modello.

Infine, abbiamo implementato un bagging classifier in Python su un dataset di churn telecom. L’ensemble di alberi decisionali ha migliorato l’accuratezza e le prestazioni sulla classe minoritaria rispetto a un singolo albero decisionale. Inoltre, abbiamo imparato suggerimenti utili per massimizzare l’efficacia del bagging nel machine learning.

Se vuoi intraprendere una carriera come machine learning engineer professionista, inizia iscrivendoti al career track Machine Learning Scientist with Python. Imparerai ad addestrare modelli di apprendimento supervisionato, non supervisionato e deep learning usando il linguaggio di programmazione Python.