L’algoritmo AdaBoost (Adaptive Boosting) con scikit-learn in Python

L’algoritmo AdaBoost è una tecnica di apprendimento di insieme che combina diversi classificatori deboli per creare un classificatore forte. Utilizzando Python e scikit-learn, implementeremo AdaBoost per la classificazione, includendo un semplice esempio con il dataset Iris. Il codice comprenderà il caricamento dei dati, la suddivisione in set di addestramento e test, l’addestramento del modello, le previsioni e la valutazione delle prestazioni. Inoltre, visualizzeremo i risultati per una comprensione più approfondita.

[wpda_org_chart tree_id=21 theme_id=50]

L’algoritmo AdaBoost (Adaptive Boosting)

L’algoritmo AdaBoost, abbreviazione di Adaptive Boosting, è stato introdotto nel 1995 da Yoav Freund e Robert Schapire. Freund e Schapire hanno sviluppato AdaBoost come una tecnica per migliorare le prestazioni di modelli di machine learning deboli.

L’idea di base di AdaBoost è stata ispirata da un altro algoritmo chiamato “Boosting”, che è un approccio generale per combinare classificatori deboli in un classificatore forte. AdaBoost ha portato questa idea a un livello successivo, introducendo l’adattamento iterativo dei pesi degli esempi di addestramento durante il processo di apprendimento.

La forza di AdaBoost risiede nella sua capacità di concentrarsi sugli esempi di addestramento difficili, assegnando loro pesi maggiori. Ogni classificatore debole successivo è quindi addestrato per concentrarsi sugli esempi che sono stati classificati erroneamente dai classificatori precedenti. Questo processo iterativo consente ad AdaBoost di creare un classificatore forte che può avere prestazioni superiori rispetto ai singoli classificatori deboli.

AdaBoost ha dimostrato di essere efficace in una varietà di applicazioni, compresa la classificazione di immagini, la rilevazione di oggetti, il riconoscimento del volto e molte altre aree di machine learning. L’algoritmo ha contribuito significativamente alla comunità scientifica e ha aperto la strada per ulteriori sviluppi nell’ambito dell’ensemble learning, dove si cercano modi innovativi di combinare modelli per ottenere prestazioni migliori.

AdaBoost e l’Ensemble Learning

La teoria di AdaBoost si basa su concetti chiave di ensemble learning e boosting.

L’ensemble learning è una tecnica di machine learning che prevede di combinare più modelli di base (chiamati “weak learners” o classificatori deboli) per creare un modello più robusto e accurato. L’obiettivo principale dell’ensemble learning è quello di ridurre la varianza, migliorare la stabilità e migliorare le prestazioni generali del modello, combinando le previsioni di più modelli.

Ci sono diversi approcci per implementare ensemble learning, tra cui:

1. Bagging (Bootstrap Aggregating): Questo metodo coinvolge l’addestramento di modelli indipendenti su set di dati campionati con sostituzione dal set di addestramento originale. Le previsioni di tutti i modelli vengono quindi combinate, ad esempio, tramite votazione, per ottenere un risultato finale.
2. Boosting: In questo approccio, i modelli sono addestrati in sequenza, con ogni modello che cerca di migliorare le prestazioni rispetto agli errori commessi dai modelli precedenti. AdaBoost è un esempio famoso di un algoritmo di boosting.
3. Random Forests: Questo è un tipo di ensemble learning basato sul bagging, che utilizza un insieme di alberi decisionali. Ogni albero è addestrato su un campione casuale dei dati e le previsioni di tutti gli alberi vengono combinate per ottenere un risultato finale.
4. Stacking: In questo metodo, i modelli di base vengono addestrati su tutto il set di dati e le loro previsioni vengono utilizzate come input per un modello di “meta-learning”, che produce il risultato finale.

L’ensemble learning è ampiamente utilizzato in vari ambiti del machine learning, compresi problemi di classificazione, regressione e clustering. Ha dimostrato di essere efficace nel migliorare le prestazioni dei modelli, soprattutto quando i singoli modelli di base sono deboli o tendono ad avere prestazioni simili su diversi sottoinsiemi dei dati.

Come funziona AdaBoost?

Ecco una spiegazione dettagliata di come funziona AdaBoost:

1. Classificatori deboli (Weak Learners): AdaBoost inizia con un classificatore debole, che è un modello di machine learning relativamente semplice che può avere una precisione solo leggermente migliore di un tasso di indovinamento casuale. Un esempio comune di classificatore debole è un albero decisionale poco profondo (stump).
2. Inizializzazione dei pesi: Ogni istanza nel set di addestramento viene inizialmente assegnata ad un peso uguale. Questi pesi vengono utilizzati per dare più importanza alle istanze più difficili durante l’addestramento.
3. Iterazioni (Boosting): AdaBoost esegue iterazioni per addestrare una serie di classificatori deboli. In ogni iterazione, il modello cerca di correggere gli errori commessi dal modello combinato fino a quel punto. Durante ogni iterazione, il modello attribuisce pesi maggiori alle istanze classificate erroneamente nelle iterazioni precedenti.
4. Calcolo del peso del classificatore: Viene calcolato il peso del classificatore debolmente addestrato in base all’errore ponderato che ha commesso. I classificatori che commettono errori più grandi ricevono pesi più bassi.
5. Aggiornamento dei pesi delle istanze: Gli esempi classificati erroneamente ricevono pesi più alti, mentre quelli classificati correttamente ricevono pesi più bassi. Ciò fa sì che il modello si concentri su esempi più difficili nelle iterazioni successive.
6. Combinazione dei classificatori deboli: AdaBoost combina i classificatori deboli pesati in un unico modello forte. La combinazione tiene conto delle prestazioni di ciascun classificatore in modo ponderato, dove i pesi sono determinati in base alla precisione di ciascun classificatore.
7. Output finale: L’output finale è un modello forte ottenuto dalla combinazione di tutti i classificatori deboli. Questo modello finale ha una maggiore precisione rispetto ai singoli classificatori deboli.

L’importanza di AdaBoost risiede nel fatto che, attraverso questo processo iterativo, il modello si focalizza sugli esempi difficili da classificare, migliorando così le prestazioni complessive del sistema. AdaBoost è robusto e può adattarsi a una varietà di modelli deboli, rendendolo un potente strumento di ensemble learning.

Implementiamo AdaBoost in Python

Puoi implementare AdaBoost in Python utilizzando librerie come scikit-learn, che fornisce un’implementazione semplice e flessibile dell’algoritmo. Di seguito ti mostro un esempio di implementazione di AdaBoost per la classificazione utilizzando scikit-learn sul dataset di prova Irisi.

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_iris

# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target

# Split the dataset into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Choose the base weak classifier (in this case, a decision tree)
weak_classifier = DecisionTreeClassifier(max_depth=1)

# Choose the number of iterations (n_estimators) and a learning rate (learning_rate)
n_estimators = 50
learning_rate = 1.0

# Create the AdaBoost classifier
adaboost_classifier = AdaBoostClassifier(estimator=weak_classifier, n_estimators=n_estimators, learning_rate=learning_rate, random_state=42)

# Train the AdaBoost model
adaboost_classifier.fit(X_train, y_train)

# Make predictions on the test set
predictions = adaboost_classifier.predict(X_test)

# Evaluate the model's performance
accuracy = accuracy_score(y_test, predictions)
print(f'Accuracy of the AdaBoost model: {accuracy}')

In questo esempio, stiamo utilizzando un albero decisionale poco profondo come classificatore debole. Puoi cambiare il tipo di classificatore debole regolando il parametro base_estimator. Personalizza anche altri parametri come n_estimators e learning_rate in base alle tue esigenze. Eseguendo il codice otteniamo il seguente risultato:

Accuracy of the AdaBoost model: 1.0

Vediamo adesso la matrice di confusione per visualizzare al meglio i risultati.

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix

# Create a confusion matrix
cm = confusion_matrix(y_test, predictions)

# Plot the confusion matrix
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=iris.target_names, yticklabels=iris.target_names)
plt.title('Confusion Matrix')
plt.xlabel('Predicted Label')
plt.ylabel('True Label')
plt.show()

Eseguendo si ottiene la matrice di confusione in forma grafica.

Ricorda che questo è solo un esempio di implementazione e puoi adattarlo in base al tuo specifico caso d’uso e dataset.

Ora diamo un’occhiata più dettagliata al codice appena utilizzato e diamo una spiegazione dettagliata dei vari passi:

1. Importazione delle librerie:

   from sklearn.ensemble import AdaBoostClassifier
   from sklearn.tree import DecisionTreeClassifier
   from sklearn.model_selection import train_test_split
   from sklearn.metrics import accuracy_score
   from sklearn.datasets import load_iris

In questo passo, stiamo importando le librerie necessarie. AdaBoostClassifier è la classe di scikit-learn per l’implementazione di AdaBoost, DecisionTreeClassifier è il classificatore debole base (un albero decisionale poco profondo in questo caso), e altre librerie sono utilizzate per la gestione dei dati e la valutazione delle prestazioni.

2. Caricamento del dataset:

   iris = load_iris()
   X = iris.data
   y = iris.target

Qui stiamo caricando il dataset Iris utilizzando la funzione load_iris() di scikit-learn. X è la matrice delle feature contenente le misurazioni dei fiori, mentre y è il vettore delle etichette di classe.

3. Divisione del dataset:

   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Questo passo suddivide il dataset in set di addestramento e di test. Il 20% dei dati è utilizzato come set di test, mentre l’80% è utilizzato per addestrare il modello.

4. Configurazione del classificatore debole e di AdaBoost:

   weak_classifier = DecisionTreeClassifier(max_depth=1)
   n_estimators = 50
   learning_rate = 1.0
   adaboost_classifier = AdaBoostClassifier(base_estimator=weak_classifier, n_estimators=n_estimators, learning_rate=learning_rate, random_state=42)

In questo passo, stiamo configurando il classificatore debole (un albero decisionale poco profondo) e il classificatore AdaBoost. n_estimators specifica il numero di iterazioni (classificatori deboli) da addestrare.

5. Addestramento del modello:

   adaboost_classifier.fit(X_train, y_train)

Qui stiamo addestrando il modello AdaBoost utilizzando il set di addestramento.

6. Predizioni e valutazione:

   predictions = adaboost_classifier.predict(X_test)
   accuracy = accuracy_score(y_test, predictions)
   print(f'Accuracy of the AdaBoost model: {accuracy}')

Infine, facciamo delle predizioni sul set di test e calcoliamo l’accuratezza del modello confrontando le predizioni con le etichette reali.