LGBMClassifier Una guida introduttiva

Guida introduttiva a LGBMClassifier.

 

Esistono un vasto numero di algoritmi di apprendimento automatico in grado di modellare fenomeni specifici. Mentre alcuni modelli utilizzano un insieme di attributi per superare gli altri, altri includono apprenditori deboli per utilizzare il resto degli attributi per fornire informazioni aggiuntive al modello, noti come modelli di insieme.

Il presupposto dei modelli di insieme è quello di migliorare le prestazioni del modello combinando le previsioni di diversi modelli riducendo i loro errori. Ci sono due tecniche di insieme popolari: bagging e boosting.

Il bagging, anche conosciuto come aggregazione bootstrap, addestra più modelli individuali su diversi sottoinsiemi casuali dei dati di addestramento e poi media le loro previsioni per produrre la previsione finale. Il boosting, d’altra parte, prevede l’addestramento di modelli individuali in sequenza, in cui ogni modello cerca di correggere gli errori commessi dai modelli precedenti.

• Google DeepMind e i ricercatori dell’Università di Tokyo presentano WebAgent un agente guidato da LLM in grado di completare le attività su siti web reali seguendo istruzioni in linguaggio naturale
• I migliori 8 mixer di foto AI nel 2023
• MLOps che copre l’intero ciclo di vita dell’apprendimento automatico Riassunto del documento

Ora che abbiamo contesto sui modelli di insieme, facciamo doppio clic sul modello di insieme di boosting, in particolare sull’algoritmo Light GBM (LGBM) sviluppato da Microsoft.

 

Cos’è LGBMClassifier?

 

LGBMClassifier sta per Light Gradient Boosting Machine Classifier. Utilizza algoritmi alberi di decisione per classificazione, ranking e altre attività di apprendimento automatico. LGBMClassifier utilizza una tecnica innovativa di Gradient-based One-Side Sampling (GOSS) e Exclusive Feature Bundling (EFB) per gestire dati su larga scala con precisione, rendendolo più veloce e riducendo l’uso della memoria.

 

Cos’è Gradient-based One-Side Sampling (GOSS)?

 

Gli algoritmi tradizionali di boosting gradient utilizzano tutti i dati per l’addestramento, cosa che può richiedere molto tempo quando si lavora con grandi set di dati. GOSS di LightGBM, d’altra parte, mantiene tutte le istanze con grandi gradienti e esegue un campionamento casuale sulle istanze con piccoli gradienti. L’intuizione dietro ciò è che le istanze con grandi gradienti sono più difficili da adattare e quindi contengono più informazioni. GOSS introduce un moltiplicatore costante per le istanze di dati con piccoli gradienti per compensare la perdita di informazioni durante il campionamento.

 

Cos’è Exclusive Feature Bundling (EFB)?

 

In un dataset sparso, la maggior parte delle features sono zero. EFB è un algoritmo quasi senza perdite che raggruppa/combina features mutuamente esclusive (features che non sono non-zero contemporaneamente) per ridurre il numero di dimensioni, accelerando così il processo di addestramento. Poiché queste features sono “esclusive”, lo spazio delle features originale viene mantenuto senza una significativa perdita di informazioni.

 

Installazione

 

Il pacchetto LightGBM può essere installato direttamente utilizzando pip, il gestore di pacchetti di Python. Digitare il comando riportato di seguito sia nel terminale che nel prompt dei comandi per scaricare e installare la libreria LightGBM sulla vostra macchina:

pip install lightgbm

 

Gli utenti di Anaconda possono installarlo utilizzando il comando “conda install” come indicato di seguito.

conda install -c conda-forge lightgbm

 

In base al vostro sistema operativo, potete scegliere il metodo di installazione utilizzando questa guida.

 

Pratico!

 

Ora, importiamo LightGBM e altre librerie necessarie:

import numpy as np
import pandas as pd
import seaborn as sns
import lightgbm as lgb
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

 

Preparazione del Dataset

 

Stiamo utilizzando il popolare dataset Titanic, che contiene informazioni sui passeggeri del Titanic, con la variabile target che indica se sono sopravvissuti o meno. È possibile scaricare il dataset da Kaggle o utilizzare il seguente codice per caricarlo direttamente da Seaborn, come mostrato di seguito:

titanic = sns.load_dataset('titanic')

 

Eliminare colonne non necessarie come “deck”, “embark_town” e “alive” perché sono ridondanti o non contribuiscono alla sopravvivenza di alcuna persona sulla nave. Successivamente, abbiamo osservato che le features “age”, “fare” e “embarked” presentano valori mancanti – notare che diversi attributi vengono imputati con adeguate misure statistiche.

# Elimina le colonne non necessarie
titanic = titanic.drop(['deck', 'embark_town', 'alive'], axis=1)

# Sostituisci i valori mancanti con la mediana o la moda
titanic['age'] = titanic['age'].fillna(titanic['age'].median())
titanic['fare'] = titanic['fare'].fillna(titanic['fare'].mode()[0])
titanic['embarked'] = titanic['embarked'].fillna(titanic['embarked'].mode()[0])

 

Infine, convertiamo le variabili categoriche in variabili numeriche utilizzando i codici categorici di pandas. Ora i dati sono pronti per iniziare il processo di addestramento del modello.

# Converti le variabili categoriche in variabili numeriche
titanic['sex'] = pd.Categorical(titanic['sex']).codes
titanic['embarked'] = pd.Categorical(titanic['embarked']).codes

# Dividi il dataset in caratteristiche di input e variabile target
X = titanic.drop('survived', axis=1)
y = titanic['survived']

 

Addestramento del modello LGBMClassifier

 

Per iniziare l’addestramento del modello LGBMClassifier, è necessario dividere il dataset in caratteristiche di input e variabili target, nonché in set di addestramento e test utilizzando la funzione train_test_split di scikit-learn.

# Dividi il dataset in set di addestramento e test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

 

Codifichiamo le variabili categoriche (“who”) e i dati ordinali (“class”) per garantire che il modello riceva dati numerici, poiché LGBM non elabora dati non numerici.

class_dict = {
"Third": 3,
"First": 1,
"Second": 2
}
who_dict = {
"child": 0,
"woman": 1,
"man": 2
}
X_train['class'] = X_train['class'].apply(lambda x: class_dict[x])
X_train['who'] = X_train['who'].apply(lambda x: who_dict[x])
X_test['class'] = X_test['class'].apply(lambda x: class_dict[x])
X_test['who'] = X_test['who'].apply(lambda x: who_dict[x])

 

Successivamente, specifichiamo i parametri iperparametri come argomenti del costruttore o possiamo passarli come un dizionario al metodo set_params.

L’ultimo passo per avviare l’addestramento del modello è caricare il dataset creando un’istanza della classe LGBMClassifier e adattandola ai dati di addestramento.

params = {
'objective': 'binary',
'boosting_type': 'gbdt',
'num_leaves': 31,
'learning_rate': 0.05,
'feature_fraction': 0.9
}
clf = lgb.LGBMClassifier(**params)
clf.fit(X_train, y_train)

 

Successivamente, valutiamo le prestazioni del classificatore addestrato sul dataset non visto o di test.

predictions = clf.predict(X_test)
print(classification_report(y_test, predictions))

 

             precision    recall  f1-score   support

           0       0.84      0.89      0.86       105
           1       0.82      0.76      0.79        74

    accuracy                           0.83       179
   macro avg       0.83      0.82      0.82       179
weighted avg       0.83      0.83      0.83       179

 

Tuning degli iperparametri

 

L’LGBMClassifier consente molta flessibilità tramite gli iperparametri che è possibile regolare per ottenere prestazioni ottimali. Qui, discuteremo brevemente alcuni degli iperparametri chiave:

• num_leaves: questo è il parametro principale per controllare la complessità del modello ad albero. Idealmente, il valore di num_leaves dovrebbe essere inferiore o uguale a 2^(max_depth).
• min_data_in_leaf: questo è un parametro importante per prevenire l’overfitting in un albero a foglia. Il suo valore ottimale dipende dal numero di campioni di addestramento e num_leaves.
• max_depth: è possibile utilizzare questo parametro per limitare esplicitamente la profondità dell’albero. È meglio regolare questo parametro in caso di overfitting.

Regoliamo questi iperparametri e addestriamo un nuovo modello:

modello = lgb.LGBMClassifier(num_leaves=31, min_data_in_leaf=20, max_depth=5)
modello.fit(X_train, y_train)

 

previsioni = modello.predict(X_test)
print(classification_report(y_test, previsioni))

 

             precision    recall  f1-score   support

           0       0.85      0.89      0.87       105
           1       0.83      0.77      0.80        74

    accuracy                           0.84       179
   macro avg       0.84      0.83      0.83       179
weighted avg       0.84      0.84      0.84       179

 

Si noti che l’effettiva regolazione degli iperparametri è un processo che richiede tentativi ed errori e può essere guidato anche dall’esperienza e da una comprensione più approfondita dell’algoritmo di boosting e della competenza nel settore del problema aziendale su cui si sta lavorando.

In questo articolo, hai appreso dell’algoritmo LightGBM e della sua implementazione in Python. È una tecnica flessibile che è utile per vari tipi di problemi di classificazione e dovrebbe far parte del tuo toolkit di machine learning.     Vidhi Chugh è una stratega di intelligenza artificiale e una leader di trasformazione digitale che lavora all’intersezione tra prodotto, scienze e ingegneria per costruire sistemi di machine learning scalabili. È una leader di innovazione premiata, un’autrice e una relatrice internazionale. È in missione per democratizzare il machine learning e rompere il gergo affinché tutti possano far parte di questa trasformazione.