Des centaines d'arbres de décision entraînés chacun sur un bout différent des données, qui votent ensemble. C'est l'algo qu'on sort en premier sur un problème de données tabulaires, parce qu'il marche presque toujours correctement sans réglage.
Un seul expert se trompe souvent. Un comité de 300 experts qui n'ont pas vu les mêmes dossiers se trompe beaucoup moins.
Chaque arbre reçoit un tirage avec remise des lignes d'entraînement (bootstrap). Environ un tiers des clients n'est pas vu par un arbre donné.
À chaque découpage, l'arbre ne peut choisir que parmi quelques variables tirées au hasard (paramètre mtry). Les arbres deviennent différents les uns des autres, et c'est ce qui fait la force du groupe.
En classification, la classe majoritaire l'emporte et la part de votes donne une probabilité. En régression, on fait la moyenne des prédictions.
Cas : 160 clients simulés d'un opérateur télécom. Carré noir = client parti (churn), carré blanc = client resté. Le fond montre ce que prédit la forêt.
Passez à 1 arbre et profondeur 12 : l'écart entre les deux scores, c'est le surapprentissage.
Ancienneté, nombre d'appels au support, montant mensuel, type de contrat, incidents des 3 derniers mois. Et la colonne à prédire : le client est-il parti ?
Chaque client reçoit une probabilité de départ. On trie la base, et l'équipe fidélisation appelle d'abord les 10 % les plus à risque.
Si 22 % des clients partent, un modèle qui dit « personne ne part » a 78 % d'exactitude (accuracy) et ne sert à rien. On regarde combien de vrais partants on trouve dans le top 10 %.
Le reste, on le laisse par défaut. Noms donnés pour R (randomForest) et Python (scikit-learn).
Nombre d'arbres. Plus il y en a, plus c'est stable, jamais moins bon, seulement plus lent. 300 à 500 suffisent presque toujours.
Nombre de variables tirées à chaque découpage. Le réglage qui a le plus d'effet. Par défaut, la racine carrée du nombre de variables en classification.
Nombre minimum de clients par feuille. L'augmenter lisse le modèle et limite le surapprentissage sur les petites bases.
Rééquilibrage des classes : en R, sampsize tire autant de partants que de fidèles par arbre ; en Python, class_weight="balanced". Utile quand la classe à détecter est rare.
# Churn clients : Random Forest en R
library(randomForest)
clients <- read.csv("clients_churn.csv")
clients$churn <- as.factor(clients$churn)
clients$contrat <- as.factor(clients$contrat)
set.seed(42)
idx <- sample(nrow(clients), round(0.7 * nrow(clients)))
train <- clients[idx, ]
test <- clients[-idx, ]
modele <- randomForest(churn ~ anciennete + appels_support + montant + contrat + incidents_3m,
data = train, ntree = 300, importance = TRUE)
# Score de départ sur les clients jamais vus
proba <- predict(modele, test, type = "prob")[, "1"]
# Lift : part de partants dans le top 10 % vs dans la base
top <- proba >= quantile(proba, 0.9)
cat("Taux de churn top 10 % :", round(mean(test$churn[top] == "1"), 2), "\n")
cat("Taux de churn moyen :", round(mean(test$churn == "1"), 2), "\n")
print(importance(modele, type = 1))# Churn clients : Random Forest en Python
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
clients = pd.read_csv("clients_churn.csv")
X = pd.get_dummies(clients[["anciennete", "appels_support", "montant", "contrat", "incidents_3m"]])
y = clients["churn"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
modele = RandomForestClassifier(n_estimators=300, min_samples_leaf=5, random_state=42)
modele.fit(X_train, y_train)
# Score de départ sur les clients jamais vus
proba = modele.predict_proba(X_test)[:, 1]
# Lift : part de partants dans le top 10 % vs dans la base
top = proba >= pd.Series(proba).quantile(0.9)
print("Taux de churn top 10 % :", round(y_test[top].mean(), 2))
print("Taux de churn moyen :", round(y_test.mean(), 2))
print(pd.Series(modele.feature_importances_, index=X.columns).sort_values(ascending=False).round(3))Un arbre de décision est un seul modèle, lisible mais instable : quelques lignes de données en plus peuvent changer tout l'arbre. Une Random Forest en combine des centaines, entraînés sur des échantillons différents, ce qui la rend beaucoup plus précise et stable, au prix de la lisibilité.
XGBoost gagne souvent quelques points de performance, mais demande plus de réglages et surapprend plus facilement. Random Forest est le meilleur choix pour un premier modèle solide sans passer des heures à régler les paramètres.
Non. Les arbres découpent les variables par seuils, l'échelle n'a donc aucun effet. Il faut en revanche encoder les variables catégorielles en Python, ce que R gère directement avec les facteurs.
Un seul arbre : lisible par un humain, mais instable. La forêt corrige ce défaut.
Voir la fiche → souvent plus précisLes arbres sont construits l'un après l'autre pour corriger les erreurs du précédent. Plus fort, plus capricieux à régler.
Voir la fiche → la référence à battreMoins précise sur les relations complexes, mais chaque coefficient s'explique à un régulateur.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus