LGBMClassifier : un guide de démarrage - KDnuggets

Republié par Platon

Suiveurs: 0

LGBMClassifier : un guide de démarrage
Image par l'éditeur

Il existe un grand nombre d'algorithmes d'apprentissage automatique capables de modéliser des phénomènes spécifiques. Alors que certains modèles utilisent un ensemble d'attributs pour surpasser les autres, d'autres incluent des apprenants faibles pour utiliser le reste des attributs pour fournir des informations supplémentaires au modèle, appelés modèles d'ensemble.

Le principe des modèles d'ensemble est d'améliorer les performances du modèle en combinant les prédictions de différents modèles en réduisant leurs erreurs. Il existe deux techniques d'assemblage populaires : le bagging et le boosting.

Le bagging, alias Bootstrapped Aggregation, forme plusieurs modèles individuels sur différents sous-ensembles aléatoires des données de formation, puis fait la moyenne de leurs prédictions pour produire la prédiction finale. Le boosting, quant à lui, implique la formation séquentielle de modèles individuels, où chaque modèle tente de corriger les erreurs commises par les modèles précédents.

Maintenant que nous avons un contexte sur les modèles d'ensemble, double-cliquons sur le modèle d'ensemble boostant, en particulier l'algorithme Light GBM (LGBM) développé par Microsoft.

LGBMClassifier signifie Light Gradient Boosting Machine Classifier. Il utilise des algorithmes d'arbre de décision pour le classement, la classification et d'autres tâches d'apprentissage automatique. LGBMClassifier utilise une nouvelle technique d'échantillonnage unilatéral basé sur le gradient (GOSS) et de regroupement de fonctionnalités exclusives (EFB) pour gérer les données à grande échelle avec précision, ce qui les rend plus rapides et réduit l'utilisation de la mémoire.

Qu'est-ce que l'échantillonnage unilatéral basé sur le gradient (GOSS) ?

Les algorithmes traditionnels d'amplification de gradient utilisent toutes les données pour la formation, ce qui peut prendre du temps lorsqu'il s'agit de grands ensembles de données. Le GOSS de LightGBM, en revanche, conserve toutes les instances avec de grands gradients et effectue un échantillonnage aléatoire sur les instances avec de petits gradients. L'intuition derrière cela est que les instances avec de grands gradients sont plus difficiles à ajuster et contiennent donc plus d'informations. GOSS introduit un multiplicateur constant pour les instances de données avec de petits gradients afin de compenser la perte d'informations lors de l'échantillonnage.

Qu'est-ce que l'offre groupée de fonctionnalités exclusives (EFB) ?

Dans un jeu de données clairsemé, la plupart des caractéristiques sont des zéros. EFB est un algorithme presque sans perte qui regroupe/combine des caractéristiques mutuellement exclusives (caractéristiques non nulles simultanément) pour réduire le nombre de dimensions, accélérant ainsi le processus de formation. Étant donné que ces fonctionnalités sont "exclusives", l'espace de fonctionnalités d'origine est conservé sans perte d'informations significative.

Le package LightGBM peut être installé directement à l'aide de pip - le gestionnaire de packages de python. Tapez la commande partagée ci-dessous sur le terminal ou l'invite de commande pour télécharger et installer la bibliothèque LightGBM sur votre machine :

pip install lightgbm

Les utilisateurs d'Anaconda peuvent l'installer à l'aide de la commande "conda install" comme indiqué ci-dessous.

conda install -c conda-forge lightgbm

En fonction de votre système d'exploitation, vous pouvez choisir la méthode d'installation à l'aide de .

Maintenant, importons LightGBM et les autres bibliothèques nécessaires :

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

Préparation de l'ensemble de données

Nous utilisons le populaire jeu de données Titanic, qui contient des informations sur les passagers du Titanic, la variable cible indiquant s'ils ont survécu ou non. Vous pouvez télécharger le jeu de données à partir de Kaggle ou utilisez le code suivant pour le charger directement depuis Seaborn, comme indiqué ci-dessous :

titanic = sns.load_dataset('titanic')

Supprimez les colonnes inutiles telles que "pont", "embarquer_ville" et "vivant" car elles sont redondantes ou ne contribuent à la survie d'aucune personne à bord du navire. Ensuite, nous avons observé que les caractéristiques « âge », « tarif » et « embarqué » ont des valeurs manquantes - notez que différents attributs sont imputés avec des mesures statistiques appropriées.

# Drop unnecessary columns
titanic = titanic.drop(['deck', 'embark_town', 'alive'], axis=1) # Replace missing values with the median or mode
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])

Enfin, nous convertissons les variables catégorielles en variables numériques en utilisant les codes catégoriques de pandas. Maintenant, les données sont préparées pour démarrer le processus de formation du modèle.

# Convert categorical variables to numerical variables
titanic['sex'] = pd.Categorical(titanic['sex']).codes
titanic['embarked'] = pd.Categorical(titanic['embarked']).codes # Split the dataset into input features and the target variable
X = titanic.drop('survived', axis=1)
y = titanic['survived']

Formation du modèle LGBMClassifier

Pour commencer à former le modèle LGBMClassifier, nous devons diviser l'ensemble de données en caractéristiques d'entrée et en variables cibles, ainsi qu'en ensembles d'apprentissage et de test à l'aide de la fonction train_test_split de scikit-learn.

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

Encodez les données catégorielles ("qui") et ordinales ("classe") pour vous assurer que le modèle est fourni avec des données numériques, car LGBM ne consomme pas de données non numériques.

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])

Ensuite, nous spécifions les hyperparamètres du modèle en tant qu'arguments du constructeur, ou nous pouvons les transmettre en tant que dictionnaire à la méthode set_params.

La dernière étape pour lancer la formation du modèle consiste à charger l'ensemble de données en créant une instance de la classe LGBMClassifier et en l'ajustant aux données de formation.

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)

Ensuite, évaluons les performances du classificateur formé sur l'ensemble de données invisible ou de 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

Réglage des hyperparamètres

Le LGBMClassifier permet une grande flexibilité via des hyperparamètres que vous pouvez régler pour des performances optimales. Ici, nous discuterons brièvement de certains des hyperparamètres clés :

num_feuilles: C'est le paramètre principal pour contrôler la complexité du modèle d'arbre. Idéalement, la valeur de num_leaves doit être inférieure ou égale à 2^(max_depth).
min_data_in_leaf: Il s'agit d'un paramètre important pour éviter le surajustement dans un arbre feuille par feuille. Sa valeur optimale dépend du nombre d'échantillons d'apprentissage et de num_leaves.
profondeur max: Vous pouvez l'utiliser pour limiter explicitement la profondeur de l'arborescence. Il est préférable d'ajuster ce paramètre en cas de surajustement.

Ajustons ces hyperparamètres et entraînons un nouveau modèle :

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

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

 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

Notez que le réglage réel des hyperparamètres est un processus qui implique des essais et des erreurs et peut également être guidé par l'expérience et une compréhension plus approfondie de l'algorithme de renforcement et de l'expertise en la matière (connaissance du domaine) du problème métier sur lequel vous travaillez.

Dans cet article, vous avez découvert l'algorithme LightGBM et son implémentation Python. Il s'agit d'une technique flexible qui est utile pour divers types de problèmes de classification et devrait faire partie de votre boîte à outils d'apprentissage automatique.

Vidhi Chugh est un stratège de l'IA et un leader de la transformation numérique travaillant à l'intersection des produits, des sciences et de l'ingénierie pour créer des systèmes d'apprentissage automatique évolutifs. Elle est une leader de l'innovation primée, une auteure et une conférencière internationale. Elle a pour mission de démocratiser l'apprentissage automatique et de casser le jargon pour que chacun fasse partie de cette transformation.