Accueil › Glossaire › CatBoost

CatBoost

CatBoost (Categorical Boosting) est une librairie open source de machine learning basée sur le gradient boosting sur arbres de décision, développée par Yandex. Sa spécificité : elle gère nativement les variables catégorielles sans prétraitement manuel, grâce à un mécanisme innovant appelé Ordered Target Statistics.

Pourquoi CatBoost existe

Avant CatBoost, les deux poids lourds du gradient boosting étaient XGBoost (2014) et LightGBM (2017, Microsoft). Ces deux librairies excellent sur les données tabulaires numériques, mais partagent un problème commun : elles ne savent pas traiter directement les variables catégorielles (texte, identifiants, catégories). Vous devez encoder manuellement vos features avant l’entraînement, via one-hot encoding, label encoding ou target encoding, chaque méthode ayant ses inconvénients (explosion dimensionnelle, fuite d’information, perte de sens).

En 2017, l’équipe ML de Yandex (dirigée par Anna Dorogush, sur la base des travaux d’Andrey Gulin autour de MatrixNet) a publié CatBoost pour résoudre deux problèmes précis :

1. Le traitement natif des variables catégorielles, sans encodage préalable, en évitant la fuite de la variable cible (target leakage).
2. Le biais de prédiction (prediction shift), un défaut théorique du gradient boosting classique où le modèle utilise les mêmes données pour calculer les résidus et pour s’entraîner, ce qui fausse les estimations.

Le résultat : une librairie qui fonctionne remarquablement bien « out of the box », avec des hyperparamètres par défaut déjà très performants, et qui excelle particulièrement sur les jeux de données mixtes (numériques + catégoriels).

Comment CatBoost fonctionne

CatBoost repose sur le même principe que tout algorithme de gradient boosting : construire un ensemble d’arbres de décision de manière séquentielle, chaque nouvel arbre corrigeant les erreurs du précédent. Mais trois innovations le distinguent de ses concurrents.

Ordered Target Statistics (encodage catégoriel)

C’est la « sauce secrète » de CatBoost. Quand vous passez une variable catégorielle (par exemple, la ville d’un utilisateur), CatBoost la convertit en valeur numérique en utilisant les statistiques de la variable cible, mais uniquement calculées sur les observations qui précèdent l’observation courante dans une permutation aléatoire du dataset.

Concrètement, pour l’observation i, la valeur numérique d’une catégorie est calculée uniquement à partir des observations 1 à i-1 dans la permutation. L’observation i elle-même n’est jamais utilisée pour calculer son propre encodage. Ce mécanisme élimine la fuite d’information qui plombe le target encoding classique.

Pour compenser la variance élevée des premières observations (qui disposent de peu de données précédentes), CatBoost utilise plusieurs permutations aléatoires et moyenne les résultats, ce qui stabilise les estimations. Un prior (la moyenne globale de la cible) pondéré par un paramètre de régularisation vient également lisser les catégories rares.

Ordered Boosting (correction du prediction shift)

Le gradient boosting classique (XGBoost, LightGBM) calcule les résidus (erreurs) de chaque observation en utilisant un modèle entraîné sur l’ensemble du dataset, y compris cette observation. C’est un raisonnement circulaire qui introduit un biais, le prediction shift : la distribution des résidus estimés ne correspond pas à leur distribution réelle sur des données inédites.

L’ordered boosting de CatBoost applique la même logique que les Ordered Target Statistics : pour calculer le résidu de l’observation i, il utilise un modèle entraîné uniquement sur les observations précédentes dans la permutation. Chaque arbre est donc construit sur des estimations « honnêtes », sans avoir vu la cible des observations qu’il évalue.

En pratique, CatBoost maintient plusieurs modèles auxiliaires correspondant aux différentes permutations, ce qui augmente le coût mémoire mais réduit significativement le surapprentissage.

Arbres symétriques (oblivious decision trees)

Contrairement à XGBoost (arbres profonds, croissance level-wise) et LightGBM (croissance leaf-wise, arbres asymétriques), CatBoost construit par défaut des arbres symétriques (dits « oblivious »). À chaque niveau de l’arbre, la même condition de split est appliquée à tous les nœuds.

Ce choix a trois conséquences :

Vitesse d’inférence très rapide : la structure régulière permet des optimisations CPU agressives (prédiction par lookup table plutôt que par traversée de branches).
Régularisation implicite : les arbres symétriques sont moins expressifs que les arbres asymétriques, ce qui limite le surapprentissage.
Parallélisation efficace : la structure uniforme se prête bien au calcul GPU et multi-GPU.

Installation et prise en main

L’installation est directe via pip ou conda :

pip install catboost

Ou via conda-forge :

conda install conda-forge::catboost

Voici un exemple minimal de classification avec des features catégorielles :

from catboost import CatBoostClassifier, Pool

# Données avec mix numérique + catégoriel
X_train = [
    [25, "Paris", "CDI"],
    [34, "Lyon", "CDD"],
    [45, "Paris", "Freelance"],
    [29, "Marseille", "CDI"],
]
y_train = [1, 0, 1, 0]

# Indices des colonnes catégorielles
cat_features = [1, 2]

model = CatBoostClassifier(
    iterations=500,
    learning_rate=0.05,
    depth=6,
    cat_features=cat_features,
    verbose=100
)

model.fit(X_train, y_train)

# Prédiction
X_test = [[31, "Lyon", "CDI"]]
print(model.predict(X_test))
print(model.predict_proba(X_test))

L’objet Pool permet de pré-charger les données avec les métadonnées (features catégorielles, poids, timestamps) pour un entraînement plus efficace, surtout sur de gros volumes :

train_pool = Pool(
    data=X_train,
    label=y_train,
    cat_features=cat_features
)
model.fit(train_pool)

Hyperparamètres clés

CatBoost fonctionne bien avec ses valeurs par défaut, mais connaître les paramètres principaux permet d’optimiser les performances sur des cas spécifiques.

Entraînement GPU et distribué

CatBoost supporte l’entraînement sur GPU NVIDIA (CUDA) nativement, sans dépendance externe :

model = CatBoostClassifier(
    task_type="GPU",
    devices="0:1",  # GPU 0 et 1
    iterations=1000
)
model.fit(train_pool)

Les gains de vitesse sont significatifs sur les gros datasets (plusieurs millions de lignes) : comptez un facteur 3x à 10x par rapport au CPU, selon le nombre de features et la profondeur des arbres. CatBoost supporte également le multi-GPU sur une seule machine et l’entraînement distribué via Apache Spark, ce qui le rend adapté aux environnements de production à grande échelle.

Depuis la version 1.2.10, les GPU avec compute capability CUDA >= 3.5 sont supportés, et les librairies CUDA nécessaires sont liées statiquement dans les binaires Linux et Windows.

CatBoost vs XGBoost vs LightGBM

C’est la question que tout le monde pose. Les trois librairies sont excellentes, mais chacune a ses forces.

Verdict

Choisissez CatBoost si votre dataset contient beaucoup de variables catégorielles, si vous voulez un modèle performant sans passer des heures à tuner les hyperparamètres, ou si vous avez besoin d’une inférence très rapide en production. C’est aussi le meilleur choix pour le ranking (Yandex l’utilise en interne pour son moteur de recherche).

Choisissez LightGBM si la vitesse d’entraînement est votre priorité (datasets de plusieurs dizaines de millions de lignes) et que vos features sont principalement numériques.

Choisissez XGBoost si vous voulez le maximum de contrôle sur les hyperparamètres et que vous êtes prêt à investir du temps dans le tuning. XGBoost reste le plus flexible des trois.

En pratique, sur un projet sérieux, testez les trois et comparez sur votre jeu de validation. L’écart de performance est souvent faible (quelques dixièmes de points d’AUC ou de F1), et le meilleur modèle dépend fortement de la nature de vos données.

Fonctionnalités avancées

Features texte et embeddings

Depuis les versions récentes, CatBoost supporte nativement les features texte (pas seulement catégorielles) et les features de type embedding (vecteurs numériques). Vous pouvez passer une colonne contenant des phrases ou des vecteurs denses, et CatBoost les intègre directement dans le processus d’entraînement :

train_pool = Pool(
    data=X_train,
    label=y_train,
    cat_features=[1],
    text_features=[2],       # colonne contenant du texte libre
    embedding_features=[3]   # colonne contenant des vecteurs
)

Interprétabilité et feature importance

CatBoost propose plusieurs méthodes d’importance des features :

PredictionValuesChange : impact moyen de chaque feature sur la prédiction. C’est la méthode par défaut.
LossFunctionChange : variation de la loss quand on retire une feature.
SHAP values : CatBoost implémente un calcul exact et rapide des valeurs SHAP grâce à la structure symétrique de ses arbres.
Interaction strength : mesure les interactions entre paires de features.

# Feature importance SHAP
shap_values = model.get_feature_importance(
    data=train_pool,
    type="ShapValues"
)

# Feature importance classique
importance = model.get_feature_importance(
    data=train_pool,
    type="PredictionValuesChange"
)

Détecteur de surapprentissage automatique

CatBoost intègre un détecteur d’overfitting qui peut stopper automatiquement l’entraînement si la métrique sur le jeu de validation se dégrade :

model = CatBoostClassifier(
    iterations=5000,
    early_stopping_rounds=50,  # arrêt si pas d'amélioration après 50 rounds
    eval_metric="AUC"
)
model.fit(
    X_train, y_train,
    eval_set=(X_val, y_val)
)

Visualisation intégrée

CatBoost fournit un widget Jupyter pour visualiser en temps réel les courbes de loss pendant l’entraînement, les feature importances et les arbres individuels. Il suffit d’installer le package avec l’extra widget (pip install catboost[widget]) et d’activer le mode verbose.

Export et déploiement

Un modèle CatBoost peut être exporté dans de nombreux formats pour le déploiement en production :

Format natif CatBoost : le plus performant, utilisable en C++, Python, Java, C#, Rust.
ONNX : pour l’interopérabilité avec d’autres frameworks.
Core ML : pour le déploiement iOS/macOS.
PMML : pour les environnements d’entreprise compatibles.

# Sauvegarde native
model.save_model("model.cbm")

# Export ONNX
model.save_model("model.onnx", format="onnx")

# Export Core ML
model.save_model("model.mlmodel", format="coreml")

Cas d’usage concrets

Détection de fraude bancaire : les transactions contiennent un mix de données numériques (montant, heure) et catégorielles (type de carte, ville du commerçant, catégorie d’achat). CatBoost excelle dans ce contexte car il exploite directement les catégories sans perte d’information.

Ranking et moteurs de recherche : CatBoost est né chez Yandex pour le ranking. Ses fonctions de loss spécialisées (YetiRank, PairLogit, QuerySoftMax) et son support natif des groupes de requêtes en font un outil de premier choix pour le learning-to-rank.

Recommandation e-commerce : prédire la probabilité de clic ou d’achat en utilisant des features comme l’ID produit, la catégorie, la marque, le profil utilisateur. CatBoost gère ces features à haute cardinalité sans explosion dimensionnelle.

Prédiction de churn : les données clients mélangent numériques (ancienneté, montant dépensé) et catégorielles (type d’abonnement, canal d’acquisition). Les benchmarks académiques montrent que CatBoost obtient régulièrement les meilleurs scores F1 sur ce type de tâche.

Compétitions Kaggle : CatBoost fait partie du trio gagnant (avec XGBoost et LightGBM) des compétitions sur données tabulaires. Les enquêtes Kaggle le classent régulièrement parmi les 7 frameworks ML les plus utilisés par les compétiteurs.

Limites et points de vigilance

Vitesse d’entraînement : CatBoost est généralement plus lent que LightGBM à l’entraînement, surtout en mode ordered boosting. Sur des datasets très volumineux (dizaines de millions de lignes) avec peu de features catégorielles, LightGBM peut être un meilleur choix.

Consommation mémoire : le mécanisme d’ordered boosting avec les permutations multiples consomme plus de mémoire que le gradient boosting classique.

Catégories à très haute cardinalité : si une feature catégorielle a des millions de valeurs uniques, les performances se dégradent. Dans ce cas, un pré-encodage ou une réduction de cardinalité reste recommandé.

Pas adapté aux données non tabulaires : comme tous les algorithmes de gradient boosting, CatBoost n’est pas conçu pour les images, l’audio ou le texte libre (pour ce dernier, l’intégration est possible mais reste limitée comparée aux approches deep learning).

Bonnes pratiques

Déclarez vos features catégorielles. C’est la seule chose que CatBoost vous demande de faire explicitement. Sans cette déclaration, il traitera vos colonnes texte comme des numériques et crashera ou produira des résultats absurdes.

Utilisez early_stopping_rounds. Fixez iterations à une valeur haute (3000-5000) et laissez l’early stopping trouver le nombre optimal d’arbres. C’est la méthode la plus fiable.

Fixez random_seed pour la reproductibilité. CatBoost utilise des permutations aléatoires ; sans seed fixe, les résultats varient légèrement entre deux runs.

Utilisez l’objet Pool plutôt que des arrays bruts, surtout pour les gros datasets. Le Pool pré-quantifie les données et accélère l’entraînement de manière significative.

Ne faites pas de target encoding manuellement avant de passer les données à CatBoost. C’est redondant et potentiellement contre-productif, car CatBoost applique déjà ses propres statistiques ordonnées.