LightGBM

LightGBM (machine de boosting par gradient léger) est une infrastructure open source de boosting par gradient qui entraîne des ensembles d’arbres de décision sur des données tabulaires, conçue pour être rapide et peu gourmande en mémoire sur les grands jeux de données. Microsoft l’a publiée en 2016 et a décrit ses algorithmes dans l’article NeurIPS 2017 LightGBM : un arbre de décision par boosting de gradient hautement efficace. En mars 2026, le dépôt officiel a été transféré dans l’organisation lightgbm-org sur GitHub, sous la responsabilité des mêmes mainteneurs. LightGBM prend en charge la classification, la régression et le classement depuis Python, R, C++ et la ligne de commande, et figure dans de nombreuses solutions gagnantes de compétitions d’apprentissage automatique. Sur les tableaux de taille moyenne, d’environ 10 000 lignes, les ensembles d’arbres comme celui-ci surpassent encore souvent l’apprentissage profond.

Fonctionnement de LightGBM#

Le boosting par gradient construit les arbres un par un. Chaque nouvel arbre est ajusté aux gradients de la fonction de perte par rapport aux prédictions de l’ensemble actuel ; dans le cas de l’erreur quadratique, il s’agit simplement des résidus, ce qui lui permet de corriger les erreurs laissées par les arbres précédents. La prédiction du modèle est la somme des sorties de tous les arbres, chacune étant pondérée par un taux d’apprentissage. L’étape coûteuse consiste à trouver la meilleure séparation pour chaque nœud, et LightGBM l’accélère grâce à quatre techniques :

• Séparations fondées sur des histogrammes : avant l’entraînement, LightGBM répartit chaque caractéristique continue dans un maximum de 255 intervalles (max_bin). La recherche de séparation examine les limites des intervalles plutôt que chaque valeur triée ; après une séparation, seul l’histogramme du plus petit enfant est construit à partir des données, puisque celui du plus grand enfant correspond à l’histogramme du parent moins celui du plus petit.
• Croissance feuille par feuille : LightGBM sépare toujours la feuille dont la meilleure séparation réduit le plus la perte, jusqu’à ce que l’arbre compte num_leaves feuilles (31 par défaut), au lieu de séparer tous les nœuds d’un même niveau avant de passer au suivant. À nombre de feuilles égal, cette approche atteint une perte inférieure à la croissance niveau par niveau et produit des arbres profonds et déséquilibrés, qui peuvent surapprendre sur de petits jeux de données.
• Échantillonnage unilatéral fondé sur le gradient (GOSS) : les lignes ayant de grands gradients sont celles que le modèle prédit encore mal. Avec data_sample_strategy="goss", LightGBM conserve les 20 % de lignes dont les gradients sont les plus élevés, échantillonne aléatoirement 10 % supplémentaires parmi les autres, puis repondère cet échantillon pour que la distribution des données reste proche de l’originale.
• Regroupement exclusif de caractéristiques (EFB) : les caractéristiques creuses qui sont rarement non nulles simultanément, comme les colonnes encodées one-hot, sont regroupées en une seule caractéristique, ce qui réduit le nombre d’histogrammes à construire.

Chaque arbre répète la recherche de séparations jusqu’à épuisement de son budget de feuilles ou jusqu’à ce qu’aucune séparation ne soit utile, et le boosting répète l’opération à chaque itération :

LightGBM sépare aussi directement les caractéristiques catégorielles encodées en entiers lorsqu’elles sont indiquées dans categorical_feature, en regroupant les catégories à chaque séparation sans encodage one-hot, et gère les valeurs manquantes par défaut. L’entraînement s’exécute sur des CPU, des GPU (device_type="gpu" ou "cuda"), ainsi que sur plusieurs machines grâce à ses algorithmes d’apprentissage distribué.

Entraîner et régler LightGBM#

Les classes LGBMClassifier, LGBMRegressor et LGBMRanker, au style de scikit-learn, couvrent la plupart des usages. Comme les arbres à croissance feuille par feuille peuvent devenir très profonds, les principaux paramètres de lutte contre le surapprentissage sont num_leaves, min_child_samples (20 lignes par feuille par défaut) et max_depth, ainsi que le taux d’apprentissage et le nombre d’arbres ; le réglage des hyperparamètres ou l’arrêt anticipé sur un jeu de validation permet généralement de trouver les valeurs adaptées. L’efficacité des histogrammes et de la croissance feuille par feuille apparaît en comparant LightGBM au boosting par gradient classique à séparation exacte de scikit-learn, sur un tableau synthétique de 20 000 lignes et 40 caractéristiques :

import time

import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=20_000, n_features=40, n_informative=15, random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# 200 trees each: exact split search vs. LightGBM's histograms and leaf-wise growth
for model in (GradientBoostingClassifier(n_estimators=200), lgb.LGBMClassifier(n_estimators=200, verbose=-1)):
    start = time.perf_counter()
    model.fit(X_train, y_train)
    seconds = time.perf_counter() - start
    print(f"{type(model).__name__}: {seconds:.1f} s, accuracy {model.score(X_test, y_test):.3f}")

Sur un CPU Apple M5 Pro, LightGBM construit ses 200 arbres d’un maximum de 31 feuilles en moins d’une seconde, tandis que scikit-learn a besoin d’environ 20 secondes pour 200 arbres à séparation exacte et de profondeur 3 ; les arbres plus grands de LightGBM atteignent une exactitude de test de 0.956 contre 0.901. Les modèles entraînés peuvent être enregistrés au format texte ou JSON, et onnxmltools les convertit en ONNX pour leur mise en service en dehors de Python.

LightGBM et méthodes connexes#

• XGBoost : la bibliothèque de boosting par gradient qui a popularisé le boosting régularisé du second ordre en 2014. Par défaut, elle construit des arbres à profondeur limitée (max_depth=6), propose une croissance feuille par feuille avec grow_policy="lossguide" et utilise la recherche de séparations par histogramme par défaut depuis la version 2.0 ; les deux bibliothèques partagent donc désormais la plupart de leurs techniques.
• CatBoost : la bibliothèque de boosting de Yandex, publiée en 2017, qui construit des arbres symétriques et encode les caractéristiques catégorielles à l’aide de statistiques cibles ordonnées afin de limiter les fuites de données de la cible.
• Forêt aléatoire : entraîne indépendamment des arbres profonds sur des échantillons bootstrap et fait la moyenne de leurs prédictions, ce qui réduit la variance.
• HistGradientBoosting : HistGradientBoostingClassifier et HistGradientBoostingRegressor de scikit-learn sont des implémentations inspirées de LightGBM, qui répartissent les caractéristiques dans des histogrammes de la même manière.
• Modèles de fondation tabulaires : les transformeurs préentraînés tels que TabPFN font des prédictions sur de petits tableaux en un seul passage avant, sans entraînement propre à chaque jeu de données.

Applications concrètes#

• Fraude et risque de crédit : les banques évaluent les transactions et les demandes de prêt à partir de l’historique du compte, du commerçant, du montant et des caractéristiques temporelles ; l’inférence rapide de LightGBM convient aux décisions prises pour chaque transaction.
• Prévision de la demande : les détaillants prévoient les ventes par produit et par magasin à partir des ventes passées, des prix, des promotions et des caractéristiques calendaires. La fréquentation est une donnée couramment utilisée : le comptage d’objets avec Ultralytics YOLO26 suit les personnes qui franchissent une ligne dans les vidéos du magasin et indique les nombres d’entrées et de sorties par classe ; additionnés par heure, ces nombres deviennent des caractéristiques pour établir une prévision des besoins en personnel avec LightGBM.
• Classement pour la recherche et les recommandations : LGBMRanker s’entraîne par défaut avec l’objectif LambdaRank, qui classe les documents ou les produits au sein de chaque groupe de requêtes afin d’optimiser le gain cumulé actualisé normalisé (NDCG).