Accueil › Glossaire › LightGBM

LightGBM (Light Gradient Boosting Machine)

LightGBM est un framework de gradient boosting développé par Microsoft qui accélère considérablement l’entraînement grâce à trois innovations : la croissance des arbres par feuille (leaf-wise), l’échantillonnage par gradient (GOSS) et le regroupement exclusif de features (EFB).

Publié en 2017 par Guolin Ke et son équipe chez Microsoft Research, LightGBM s’est rapidement imposé comme l’alternative la plus rapide à XGBoost pour les données tabulaires. Sur les grands datasets, il peut être 10 à 20 fois plus rapide qu’XGBoost tout en atteignant des performances prédictives comparables (voire supérieures). Il est devenu le choix par défaut de nombreux praticiens en machine learning, en data science et dans les compétitions Kaggle.

Les 4 innovations de LightGBM

Croissance leaf-wise (par feuille)

C’est la différence architecturale fondamentale avec XGBoost. Alors qu’XGBoost fait croître les arbres niveau par niveau (level-wise, ajoutant une couche entière de noeuds à la fois), LightGBM fait croître les arbres feuille par feuille (leaf-wise) en choisissant toujours la feuille qui apporte le plus grand gain.

Conséquences : les arbres LightGBM sont plus profonds et asymétriques, capturant des patterns complexes plus rapidement avec moins de feuilles. À nombre de feuilles égal, un arbre leaf-wise est plus expressif qu’un arbre level-wise. En contrepartie, cette stratégie peut overfitter plus facilement sur les petits datasets, car elle produit des arbres plus spécialisés.

GOSS (Gradient-based One-Side Sampling)

Toutes les observations ne contribuent pas de la même manière à l’apprentissage. Les observations avec un grand gradient (erreur résiduelle élevée) sont « sous-entraînées » et contiennent plus d’information pour le prochain arbre. Les observations avec un petit gradient sont déjà bien prédites.

GOSS exploite cette asymétrie : il conserve toutes les observations à grand gradient (typiquement les top 20 %) et sous-échantillonne aléatoirement les observations à petit gradient, en les repondérant pour maintenir une estimation non biaisée. Résultat : un entraînement beaucoup plus rapide avec une perte de précision négligeable.

EFB (Exclusive Feature Bundling)

Dans les données creuses (sparse), de nombreuses features sont « mutuellement exclusives » : elles sont rarement non nulles simultanément. Les variables one-hot encodées en sont l’exemple typique. EFB regroupe ces features exclusives en « bundles », réduisant le nombre effectif de features sans perte significative d’information. C’est particulièrement efficace sur les données de type NLP (matrices TF-IDF) ou les features catégorielles encodées.

Algorithme basé sur les histogrammes

Au lieu de trier les valeurs de chaque feature pour trouver le meilleur split (coûteux en O(n log n)), LightGBM discrétise les valeurs continues en bins (histogrammes). Le calcul des splits se fait sur les histogrammes (O(#bins)) au lieu des valeurs brutes. Cela réduit drastiquement le temps de calcul et la consommation mémoire, surtout sur les grands datasets.

Les hyperparamètres clés

Le paramètre le plus important de LightGBM est num_leaves, pas max_depth. C’est une différence fondamentale avec XGBoost.

LightGBM en Python

Installation

pip install lightgbm

Classification avec early stopping

import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import classification_report, roc_auc_score

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=1000,
    learning_rate=0.05,
    num_leaves=31,
    min_child_samples=20,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,
    reg_lambda=0.1,
    random_state=42,
    verbose=-1
)

model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    callbacks=[lgb.early_stopping(50), lgb.log_evaluation(0)]
)

y_pred = model.predict(X_test)
y_proba = model.predict_proba(X_test)[:, 1]

print(classification_report(y_test, y_pred))
print(f"AUC-ROC : {roc_auc_score(y_test, y_proba):.4f}")
print(f"Meilleur n_estimators : {model.best_iteration_}")

Régression

import lightgbm as lgb
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

model = lgb.LGBMRegressor(
    n_estimators=1000,
    learning_rate=0.05,
    num_leaves=31,
    random_state=42,
    verbose=-1
)

model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    callbacks=[lgb.early_stopping(50), lgb.log_evaluation(0)]
)

y_pred = model.predict(X_test)
print(f"R² : {r2_score(y_test, y_pred):.4f}")
print(f"RMSE : {np.sqrt(mean_squared_error(y_test, y_pred)):.4f}")

Gestion native des features catégorielles

LightGBM gère nativement les features catégorielles, souvent mieux que le one-hot encoding. Il trouve les splits optimaux directement sur les catégories.

# Indiquer les colonnes catégorielles
model = lgb.LGBMClassifier(verbose=-1)
model.fit(X_train, y_train,
          categorical_feature=['ville', 'type_produit'])

Tuning avec Optuna

import optuna

def objective(trial):
    params = {
        'n_estimators': 1000,
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3),
        'num_leaves': trial.suggest_int('num_leaves', 15, 127),
        'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),
        'subsample': trial.suggest_float('subsample', 0.6, 1.0),
        'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
        'reg_alpha': trial.suggest_float('reg_alpha', 1e-3, 10.0, log=True),
        'reg_lambda': trial.suggest_float('reg_lambda', 1e-3, 10.0, log=True),
        'verbose': -1, 'random_state': 42
    }
    model = lgb.LGBMClassifier(**params)
    from sklearn.model_selection import cross_val_score
    scores = cross_val_score(model, X_train, y_train,
                            cv=5, scoring='roc_auc')
    return scores.mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=100)
print(f"Meilleurs paramètres : {study.best_params}")

LightGBM vs XGBoost : comparaison détaillée

En pratique, les performances prédictives de LightGBM et XGBoost sont quasi identiques après tuning soigneux. La différence se fait sur la vitesse : LightGBM est significativement plus rapide, surtout sur les datasets dépassant 100 000 lignes. Pour les petits datasets (< 10 000), la différence de vitesse est négligeable et XGBoost peut être légèrement meilleur grâce à son approche level-wise plus conservatrice.

Quand choisir LightGBM

Grand dataset tabulaire (> 100K lignes) : LightGBM est le choix naturel grâce à sa vitesse. L’avantage est d’autant plus marqué que le dataset est grand.

Beaucoup de features catégorielles : le support natif de LightGBM pour les catégorielles est plus mature et souvent plus performant que le one-hot encoding suivi de XGBoost.

Données creuses / haute dimension : l’EFB réduit automatiquement les features redondantes, ce qui accélère l’entraînement et peut améliorer les performances.

Itérations rapides (prototypage) : quand vous devez tester beaucoup de configurations ou retrainer fréquemment, la vitesse de LightGBM fait gagner des heures.

Compétitions Kaggle : LightGBM et XGBoost sont quasi systématiquement dans les solutions gagnantes. Beaucoup de top kagglers préfèrent LightGBM pour la vitesse de recherche d’hyperparamètres.

Limites de LightGBM

Overfitting sur petits datasets : la croissance leaf-wise crée des arbres plus complexes et asymétriques. Sur de petits datasets (< 5 000 lignes), LightGBM peut overfitter plus facilement qu'XGBoost. Remède : augmenter min_child_samples, réduire num_leaves, activer la régularisation.

Sensibilité aux hyperparamètres : comme XGBoost, LightGBM nécessite un tuning soigneux pour atteindre son potentiel. Le paramètre num_leaves en particulier doit être calibré avec soin (trop haut = overfitting, trop bas = underfitting).

Pas d’extrapolation : comme tous les modèles à base d’arbres, LightGBM ne peut pas prédire en dehors de la plage des données d’entraînement.

Reproductibilité : les résultats peuvent varier légèrement entre les versions de LightGBM et entre les systèmes d’exploitation, en raison des optimisations de parallélisation et d’arrondi.

Applications typiques

Scoring et crédit : prédiction de défaut de paiement, scoring de risque. La vitesse permet de retrainer fréquemment sur des données fraiches.

Détection de fraude : classification binaire sur de grands volumes de transactions. Le paramètre scale_pos_weight gère le déséquilibre de classes.

Systèmes de recommandation : LightGBM supporte nativement le learning-to-rank (LambdaRank), utilisé pour le tri de résultats de recherche et la personnalisation.

Prédiction de churn : classification binaire avec feature importance pour comprendre les facteurs de désabonnement.

Prévision de demande : régression sur séries temporelles agrégées avec features calendaires et lag features.

Verdict

LightGBM est le framework de gradient boosting le plus rapide et l’un des plus performants. Si vous travaillez sur des données tabulaires de taille significative (> 10 000 lignes), c’est le premier algorithme à essayer après une baseline linéaire et un Random Forest.

Notre workflow recommandé : régression logistique (baseline) → Random Forest (performance sans tuning) → LightGBM avec early stopping et Optuna (performance maximale). En parallèle, essayez XGBoost et gardez le meilleur. Dans la pratique, LightGBM et XGBoost produisent des résultats si proches que le choix se fait souvent sur la vitesse d’entraînement (avantage LightGBM) ou la maturité de la documentation (avantage XGBoost).