Un clustering qui lit chaque ligne une seule fois et la range dans un arbre de petits sous-groupes résumés, avant de regrouper ces résumés en segments. Il est conçu pour les bases trop grandes pour la mémoire et accepte de nouvelles lignes sans tout recalculer.
Un recenseur qui traverse la ville une seule fois. Il ne note pas chaque habitant mais tient un carnet de petits quartiers homogènes, qu'il regroupe en grandes zones à la fin.
Chaque client rejoint le sous-groupe le plus proche si celui-ci reste assez compact (seuil de rayon, threshold). Sinon, il ouvre un nouveau sous-groupe.
Chaque sous-groupe est stocké sous forme de trois éléments : effectif, somme et somme des carrés des valeurs. Ces résumés sont rangés dans un arbre équilibré, le CF-tree, qui tient en mémoire même pour des millions de lignes.
À la fin, un clustering classique (hiérarchique ou K-means) regroupe ces quelques dizaines ou centaines de sous-groupes en segments métier.
Panier moyen, achats par mois, jours depuis le dernier achat, nombre de catégories achetées, part des achats en promotion. Ici 2 000 clients lus par lots de 500 pour simuler un flux. La méthode vise des bases de plusieurs millions de lignes.
Sur le jeu d'exemple, l'arbre résume les 2 000 clients en 80 sous-groupes, regroupés en 4 segments : 300 très gros clients (panier moyen proche de 150 €, 10 achats par mois), 500 réguliers, 500 clients inactifs depuis 8 mois qui achètent surtout en promotion, et 700 occasionnels.
Il n'y a pas de bonne réponse à laquelle comparer. On vérifie que les segments restent les mêmes quand on mélange l'ordre des lignes ou qu'on change le seuil, et on les compare à un K-means sur un échantillon. Le gain de BIRCH se mesure en temps de calcul et en mémoire sur la base complète.
Noms donnés pour R (stream) et Python (scikit-learn). Les variables doivent être standardisées avant tout, sinon le seuil n'a pas de sens.
Rayon maximal d'un sous-groupe, dans l'unité des données standardisées. Trop petit : des milliers de sous-groupes et peu de gain. Trop grand : des clients différents fusionnent dès la lecture. Sur le jeu d'exemple en Python, 0,5 donne 80 sous-groupes.
Nombre maximal de branches par nœud de l'arbre. Joue surtout sur la mémoire et la vitesse, rarement sur les segments obtenus. scikit-learn utilise 50 par défaut.
Nombre de segments finaux, obtenus en regroupant les sous-groupes. En Python, n_clusters=None garde les sous-groupes bruts, et on peut aussi passer son propre modèle de clustering pour l'étape finale.
# Segmentation d'une grande base clients : BIRCH en R
library(stream)
clients <- read.csv("clients_segmentation.csv")
variables <- c("panier_moyen", "achats_par_mois", "recence_jours", "nb_categories", "part_promo")
X <- scale(clients[, variables])
set.seed(42)
# Micro : arbre BIRCH (threshold = rayon max d'un sous-groupe) ; macro : regroupement en 4 segments
modele <- DSC_TwoStage(micro = DSC_BIRCH(threshold = 0.5, branching = 50, maxLeaf = 50),
macro = DSC_Kmeans(k = 4))
# Une seule passe sur les données, lues comme un flux
flux <- DSD_Memory(as.data.frame(X))
update(modele, flux, n = nrow(X))
cat("Sous-groupes résumés dans l'arbre :", nclusters(modele, type = "micro"), "\n")
# Centres des 4 segments, remis en unités d'origine, et nombre de clients par segment
centres <- as.matrix(get_centers(modele, type = "macro"))
centres <- sweep(sweep(centres, 2, attr(X, "scaled:scale"), "*"), 2, attr(X, "scaled:center"), "+")
print(round(centres, 1))
print(round(get_weights(modele, type = "macro")))# Segmentation d'une grande base clients : BIRCH en Python
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import Birch
clients = pd.read_csv("clients_segmentation.csv")
variables = ["panier_moyen", "achats_par_mois", "recence_jours", "nb_categories", "part_promo"]
X = StandardScaler().fit_transform(clients[variables])
# threshold : rayon max d'un sous-groupe ; n_clusters : regroupement final en 4 segments
modele = Birch(threshold=0.5, branching_factor=50, n_clusters=4)
# Une seule passe, par lots de 500 clients, comme un flux quotidien
for debut in range(0, len(X), 500):
modele.partial_fit(X[debut:debut + 500])
print("Sous-groupes résumés dans l'arbre :", len(modele.subcluster_centers_))
clients["segment"] = modele.predict(X)
# Taille et profil moyen de chaque segment, en unités d'origine
print(clients["segment"].value_counts().sort_index())
print(clients.groupby("segment")[variables].mean().round(1).to_string())Balanced Iterative Reducing and Clustering using Hierarchies. L'algorithme a été publié en 1996 par Zhang, Ramakrishnan et Livny pour regrouper des bases trop grandes pour la mémoire vive. Son idée clé : résumer chaque sous-groupe par son effectif, sa somme et sa somme des carrés.
Sur une base qui tient en mémoire, le K-means est plus simple et souvent aussi bon. BIRCH devient intéressant quand la base est très grande, quand les données arrivent en flux, ou pour réduire des millions de lignes à quelques centaines de sous-groupes avant une classification hiérarchique.
Oui. Chaque ligne est affectée au moment où elle est lue, donc les sous-groupes dépendent de l'ordre de lecture. L'étape finale de regroupement atténue cet effet. En pratique, on mélange les lignes et on relance pour vérifier que les segments restent stables.
Même logique de centres, mais plusieurs passes sur toute la base. Plus simple à régler tant que les données tiennent en mémoire.
Voir la fiche → l'autre option grands volumesMet à jour les centres par petits paquets de lignes. Souvent plus robuste que BIRCH quand les variables sont nombreuses.
Voir la fiche → le complément naturelTrop lente sur une grande base, mais idéale pour regrouper les sous-groupes produits par BIRCH.
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