LightGBM : croissance feuille par feuille et avantages en vitesse
Comparez les performances de LightGBM et de XGBoost sur un grand ensemble de données, comprenez la croissance des arbres feuille par feuille et niveau par niveau et utilisez la prise en charge des caractéristiques catégorielles.
LightGBM : croissance feuille par feuille et avantages en vitesse est une leçon Machine Learning Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Machine Learning Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Machine Learning Academy comprend 4 leçons au total.
Qu’est-ce que LightGBM ?
LightGBM (Light Gradient Boosting Machine) est une bibliothèque de gradient boosting développée par Microsoft en 2017. Elle a été conçue spécifiquement pour répondre aux limites de vitesse et de mémoire de XGBoost sur les grands jeux de données. LightGBM a introduit deux innovations algorithmiques majeures : le Gradient-based One-Side Sampling (GOSS) pour réduire le nombre d’instances de données prises en compte à chaque itération, et l’Exclusive Feature Bundling (EFB) pour réduire le nombre de variables en regroupant les variables creuses mutuellement exclusives. Ensemble, ces innovations rendent LightGBM nettement plus rapide que XGBoost sur les grands jeux de données tabulaires.
Croissance des arbres niveau par niveau ou feuille par feuille
La plupart des implémentations du boosting par gradient (y compris XGBoost par défaut) construisent les arbres niveau par niveau : tous les nœuds de profondeur 1 sont divisés avant qu’un nœud de profondeur 2 ne le soit. Cela garantit des arbres équilibrés, mais gaspille des calculs sur des divisions qui réduisent très peu la perte. LightGBM construit les arbres feuille par feuille : à chaque étape, il trouve, dans l’ensemble de l’arbre, la feuille unique dont la division réduirait le plus la perte, quel que soit son niveau, puis la divise. Cela produit des arbres déséquilibrés qui réduisent plus rapidement la perte à chaque division et nécessitent donc moins de divisions pour atteindre la même précision.
Risque de surapprentissage avec la croissance feuille par feuille
La croissance feuille par feuille peut entraîner un surapprentissage sur les petits jeux de données, car elle recherche agressivement la réduction de perte la plus importante et peut mémoriser des exemples individuels dans des feuilles très profondes. La solution consiste à utiliser le paramètre num_leaves (nombre total maximal de feuilles dans un arbre). Régler correctement num_leaves limite la complexité de l’arbre plus précisément que max_depth seul. Une règle empirique courante : num_leaves = 2^(max_depth) / 2. Pour une profondeur équivalente à max_depth de 6, essayez une valeur de num_leaves comprise entre 32 et 50 environ.
import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
X, y = load_breast_cancer(return_X_y=True)
for nl in [8, 16, 31, 64, 128]:
model = lgb.LGBMClassifier(n_estimators=100, num_leaves=nl, learning_rate=0.1,
random_state=42, verbose=-1)
score = cross_val_score(model, X, y, cv=5).mean()
print(f'num_leaves={nl:4d}: CV accuracy={score:.4f}')Installation et utilisation de base de LightGBM
LightGBM s’installe avec pip install lightgbm. Comme XGBoost, il fournit une API compatible avec scikit-learn grâce à LGBMClassifier et LGBMRegressor. Définissez verbose=-1 pour masquer la sortie de l’entraînement (LightGBM est bavard par défaut). Les principaux hyperparamètres sont similaires à ceux de XGBoost : n_estimators, learning_rate, num_leaves (à la place de max_depth) et subsample.
# Install: pip install lightgbm
import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = lgb.LGBMClassifier(
n_estimators=200,
learning_rate=0.05,
num_leaves=31,
random_state=42,
verbose=-1
)
model.fit(X_train, y_train)
print('LightGBM test accuracy:', model.score(X_test, y_test))Comparaison de vitesse : LightGBM contre XGBoost
LightGBM est généralement 5 à 10 fois plus rapide que XGBoost sur les grands jeux de données, tout en offrant une précision similaire ou supérieure. Cet avantage en vitesse vient de : (1) la recherche de divisions fondée sur des histogrammes (qui regroupe les valeurs continues des variables en intervalles discrets, réduisant le calcul des divisions candidates de O(n) à O(bins)) ; (2) la croissance feuille par feuille (qui nécessite moins de divisions) ; (3) GOSS (qui n’entraîne le modèle que sur les exemples à gradient élevé et sur un échantillon aléatoire d’exemples à faible gradient). L’avantage en vitesse est particulièrement marqué pour les jeux de données comportant plus de 100 000 lignes ou plus de 1 000 variables.
import lightgbm as lgb
import xgboost as xgb
from sklearn.datasets import fetch_california_housing
import time, numpy as np
X, y = fetch_california_housing(return_X_y=True)
lgb_model = lgb.LGBMRegressor(n_estimators=300, verbose=-1, random_state=42)
xgb_model = xgb.XGBRegressor(n_estimators=300, eval_metric='rmse', verbosity=0, random_state=42)
for name, m in [('LightGBM', lgb_model), ('XGBoost', xgb_model)]:
start = time.time()
m.fit(X, y)
print(f'{name}: {round(time.time()-start, 2)}s')Prise en charge des variables catégorielles
L’un des avantages pratiques de LightGBM est sa prise en charge native des variables catégorielles. Au lieu d’exiger un encodage one-hot, vous pouvez transmettre les indices des colonnes catégorielles au paramètre categorical_feature. LightGBM apprend les divisions optimales en testant tous les regroupements de catégories, ce qui est plus expressif que les divisions binaires de l’encodage one-hot et évite l’explosion du nombre de variables lorsque des variables comportent des centaines de catégories. Cette possibilité est particulièrement utile pour les jeux de données de commerce en ligne contenant des identifiants de produits ou des codes de localisation.
import lightgbm as lgb
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
np.random.seed(42)
n = 1000
df = pd.DataFrame({'color': np.random.choice(['red', 'blue', 'green'], n),
'size': np.random.randint(1, 10, n),
'label': np.random.randint(0, 2, n)})
df['color'] = df['color'].astype('category')
X, y = df[['color', 'size']], df['label']
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)
model = lgb.LGBMClassifier(n_estimators=50, verbose=-1)
model.fit(X_tr, y_tr, categorical_feature=['color'])
print('Accuracy with native categoricals:', round(model.score(X_te, y_te), 4))Arrêt anticipé dans LightGBM
LightGBM prend en charge l’arrêt anticipé grâce aux fonctions de rappel. Transmettez une fonction de rappel early_stopping avec le nombre de tours de patience, ainsi qu’une fonction de rappel log_evaluation pour contrôler la verbosité. L’état du meilleur modèle (meilleure itération) est automatiquement utilisé pour les prédictions. Comme avec XGBoost, cela vous permet de définir une valeur très élevée pour n_estimators et de laisser l’arrêt anticipé trouver le meilleur compromis sans surapprentissage.
import lightgbm as lgb
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
model = lgb.LGBMClassifier(n_estimators=1000, learning_rate=0.05, num_leaves=31, random_state=42)
model.fit(X_tr, y_tr,
eval_set=[(X_val, y_val)],
callbacks=[lgb.early_stopping(stopping_rounds=20), lgb.log_evaluation(0)])
print('Best iteration:', model.best_iteration_)
print('Val accuracy:', round(model.score(X_val, y_val), 4))Principaux hyperparamètres de LightGBM
Les hyperparamètres les plus importants de LightGBM sont les suivants : num_leaves (contrôle la complexité et constitue le principal levier de régularisation), learning_rate (une valeur plus faible nécessite davantage d’arbres et améliore la généralisation), min_child_samples (nombre minimal d’exemples par feuille, à augmenter avec num_leaves pour éviter le surapprentissage), subsample et colsample_bytree (régularisation stochastique), ainsi que reg_alpha/reg_lambda (pénalités L1/L2). Commencez par les valeurs par défaut, puis ajustez d’abord num_leaves et min_child_samples.
LightGBM pour la régression
LGBMRegressor fonctionne de la même manière pour les tâches de régression. Il prend en charge plusieurs fonctions de perte via le paramètre objective : 'regression' (L2), 'regression_l1' (MAE), 'huber' (robuste aux valeurs aberrantes) et 'quantile' (pour les intervalles de prédiction). La régression quantile avec LightGBM est particulièrement utile en production : entraînez un modèle pour le 10e percentile et un autre pour le 90e percentile afin de produire des bornes d’incertitude calibrées autour des prédictions.
import lightgbm as lgb
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
model = lgb.LGBMRegressor(n_estimators=300, learning_rate=0.05, num_leaves=31,
verbose=-1, random_state=42)
rmse = np.sqrt(-cross_val_score(model, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print('LightGBM Regression RMSE:', round(rmse, 4))Choisir entre XGBoost et LightGBM
XGBoost et LightGBM sont tous deux excellents. En pratique : utilisez LightGBM lorsque votre jeu de données est volumineux (plus de 100 000 lignes), que vous avez besoin d’itérations rapides pendant l’exploration ou que vous disposez de variables catégorielles à grand nombre de modalités. Utilisez XGBoost lorsque votre jeu de données est petit ou moyen, que vous souhaitez une croissance plus prudente niveau par niveau, moins susceptible de provoquer un surapprentissage sur des données bruitées, ou que votre équipe maîtrise déjà XGBoost. Dans les concours, on essaie généralement les deux et on choisit celui qui obtient les meilleurs résultats sur le jeu de validation. CatBoost est une troisième solution performante, avec une gestion encore meilleure des variables catégorielles.
Importance des variables dans LightGBM
Comme XGBoost, LightGBM fournit l’importance des variables, accessible via model.feature_importances_ (qui utilise par défaut le nombre de divisions dans l’API sklearn) ou model.booster_.feature_importance(importance_type='gain'). Le type gain est généralement plus informatif : il mesure l’amélioration moyenne de la perte pour chaque division utilisant cette variable. LightGBM prend également en charge les valeurs SHAP pour expliquer le modèle indépendamment de celui-ci, via model.predict(X, pred_contrib=True) dans l’API native, et fournit ainsi une attribution détaillée des variables pour chaque prédiction.
import lightgbm as lgb
import pandas as pd
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X, y = data.data, data.target
model = lgb.LGBMClassifier(n_estimators=100, verbose=-1, random_state=42)
model.fit(X, y)
importances = pd.Series(model.feature_importances_, index=data.feature_names)
print(importances.sort_values(ascending=False).head(5))Vérification rapide
Vérifiez votre compréhension de la stratégie de croissance de LightGBM présentée dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que la croissance feuille par feuille de LightGBM trouve la meilleure feuille unique à diviser à chaque tour et converge plus rapidement que la croissance niveau par niveau, que num_leaves est le principal paramètre de contrôle de la complexité et remplace max_depth, et que la prise en charge native des variables catégorielles par LightGBM évite le surcoût de l’encodage one-hot. Nous allons maintenant examiner en détail les principaux hyperparamètres : le taux d’apprentissage, le nombre d’estimateurs et la profondeur maximale.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « LightGBM : croissance feuille par feuille et avantages en vitesse » est-elle gratuite ?
Oui — le texte complet de « LightGBM : croissance feuille par feuille et avantages en vitesse » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Machine Learning Academy, passe à CoddyKit PRO. Le cours Machine Learning Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « LightGBM : croissance feuille par feuille et avantages en vitesse » ?
Comparez les performances de LightGBM et de XGBoost sur un grand ensemble de données, comprenez la croissance des arbres feuille par feuille et niveau par niveau et utilisez la prise en charge des ca… Tu pratiques Machine Learning Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Machine Learning Academy ?
Aucune expérience préalable n'est requise. Machine Learning Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « LightGBM : croissance feuille par feuille et avantages en vitesse » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Machine Learning Academy ?
Oui. Chaque leçon Machine Learning Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Intuition du boosting : correction séquentielle des erreurs
- XGBoost : régularisation, arrêt anticipé et importance des caractéristiques
- LightGBM : croissance feuille par feuille et avantages en vitesse
- Hyperparamètres clés : taux d’apprentissage, n_estimators et max_depth