Exécutez des k-médoïdes de type PAM sur des milliers de lignes avec clara(), puis visualisez les groupes
Un guide pratique de CLARA (Clustering Large Applications) en R : pourquoi PAM ne passe pas à l’échelle, comment clara() échantillonne les données pour trouver des médoïdes robustes, comment lire le résultat et ses médoïdes, et comment visualiser les regroupements avec fviz_cluster() de factoextra. Travaillé sur un jeu de données simulé de 500 points, avec une comparaison claire de scalabilité CLARA contre PAM.
clara(df, k, samples = 50, pamLike = TRUE) du package cluster — définissez toujours pamLike = TRUE et augmentez samples bien au-delà de la valeur par défaut de 5.k avec la méthode de la silhouette (fviz_nbclust(df, clara, method = "silhouette")).fviz_cluster() de factoextra — le même graphique en un appel que vous utiliseriez pour les k-means ou PAM.CLARA (Clustering Large Applications, Kaufman & Rousseeuw, 1990) est une extension de la méthode des k-médoïdes / PAM conçue pour traiter des jeux de données contenant un grand nombre d’objets — plus de quelques milliers d’observations — sans manquer de temps ou de mémoire.
PAM est robuste et intuitif : il représente chaque regroupement par un point de données réel (un médoïde) plutôt que par une moyenne calculée, ce qui le rend bien moins sensible aux valeurs aberrantes que les k-means. Mais cette robustesse a un prix. PAM calcule et stocke la matrice complète des dissimilarités par paires et la parcourt de façon exhaustive, si bien que son coût croît à peu près avec le carré du nombre d’observations. Sur quelques centaines de points, c’est acceptable ; sur des dizaines de milliers, cela devient infaisable.
CLARA résout cela par une idée simple : ne regroupez pas toutes les données d’un coup — regroupez des échantillons de celles-ci. Utilisez-le chaque fois que vous voulez la robustesse de PAM sur un jeu de données trop grand pour PAM lui-même : tables clients de dizaines de milliers de lignes, journaux de capteurs, grandes matrices génomiques.
Cette leçon fait partie de la série Analyse de regroupements en R. CLARA est l’une des méthodes de partitionnement, aux côtés des k-means et de PAM / k-médoïdes. La règle de similarité dont dépend chaque méthode est traitée dans les mesures de distance pour le regroupement.
Pour voir CLARA à l’œuvre, il nous faut un jeu de données assez grand pour que l’échantillonnage compte. Nous allons en simuler un : 500 points en deux dimensions, répartis en deux groupes bien séparés. Nous fixons d’abord la graine aléatoire afin que le résultat soit reproductible.
set.seed(1234)
# Generate 500 objects, divided into 2 clusters
df <- rbind(cbind(rnorm(200, 0, 8), rnorm(200, 0, 8)),
cbind(rnorm(300, 50, 8), rnorm(300, 50, 8)))
# Specify column and row names
colnames(df) <- c("x", "y")
rownames(df) <- paste0("S", 1:nrow(df))
# Preview the data
head(df, n = 6) x y
S1 -9.656526 3.881815
S2 2.219434 5.574150
S3 8.675529 1.484111
S4 -18.765582 5.605868
S5 3.432998 2.493448
S6 4.048447 6.083699Les 200 premières lignes sont tirées autour de (0, 0) et les 300 suivantes autour de (50, 50), il y a donc clairement deux groupes — mais CLARA ne le sait pas ; il les découvrira à partir des seules coordonnées.
Ici, les deux colonnes sont déjà à la même échelle, nous les laissons donc telles quelles. Avec des données réelles mesurées en unités différentes, standardisez avant le regroupement — passez soit stand = TRUE à clara(), soit scale() les données vous-même — afin qu’aucune variable de forte amplitude ne domine les dissimilarités.
CLARA vit dans le package cluster ; nous utilisons factoextra pour choisir k et tracer le graphique des regroupements :
install.packages(c("cluster", "factoextra"))library(cluster)
library(factoextra)Comme toute méthode de partitionnement, CLARA exige que vous spécifiiez k à l’avance, la première question naturelle est donc combien de regroupements les données veulent-elles ? La méthode de la silhouette moyenne y répond : exécutez le regroupement pour une plage de k et conservez la valeur qui donne la plus grande largeur de silhouette moyenne. fviz_nbclust() le fait en un seul appel — passez-lui simplement clara comme fonction de regroupement :
library(cluster)
library(factoextra)
set.seed(1234)
df <- rbind(cbind(rnorm(200, 0, 8), rnorm(200, 0, 8)),
cbind(rnorm(300, 50, 8), rnorm(300, 50, 8)))
colnames(df) <- c("x", "y")
rownames(df) <- paste0("S", 1:nrow(df))
fviz_nbclust(df, clara, method = "silhouette") +
theme_classic()
La largeur de silhouette moyenne culmine nettement à k = 2 — exactement les deux groupes que nous avons simulés. Nous allons classer les observations en 2 regroupements ci-dessous. Pour le traitement complet du choix de k (coude, silhouette et statistiques de gap), voir la leçon nombre optimal de regroupements.
La fonction est clara() du package cluster. Sa forme simplifiée est :
clara(x, k, metric = "euclidean", stand = FALSE,
samples = 5, pamLike = FALSE)Les arguments à connaître :
x — une matrice ou un tableau de données numériques (lignes = observations, colonnes = variables). Les NA sont autorisés.k — le nombre de regroupements.metric — la mesure de distance : "euclidean" (racine de la somme des carrés des différences) ou "manhattan" (somme des différences absolues). Manhattan est moins sensible aux valeurs aberrantes.stand — si TRUE, les variables sont standardisées avant le calcul des dissimilarités. Recommandé chaque fois que vos variables sont à des échelles différentes.samples — le nombre d’échantillons tirés du jeu de données. La valeur par défaut est 5, mais une valeur bien plus grande (par ex. 50) est recommandée pour un résultat fiable.pamLike — s’il faut utiliser exactement le même algorithme que pam(). Définissez-le à TRUE — il donne un regroupement de meilleure qualité.Avec ces réglages, calculer CLARA tient en une seule ligne. Nous classons les 500 points en 2 regroupements, en tirant 50 échantillons et en demandant l’algorithme de type PAM :
library(cluster)
set.seed(1234)
df <- rbind(cbind(rnorm(200, 0, 8), rnorm(200, 0, 8)),
cbind(rnorm(300, 50, 8), rnorm(300, 50, 8)))
colnames(df) <- c("x", "y")
rownames(df) <- paste0("S", 1:nrow(df))
# Compute CLARA
clara.res <- clara(df, 2, samples = 50, pamLike = TRUE)
# Print the result
print(clara.res)Call: clara(x = df, k = 2, samples = 50, pamLike = TRUE)
Medoids:
x y
S121 -1.531137 1.145057
S455 48.357304 50.233499
Objective function: 9.87862
Clustering vector: Named int [1:500] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ...
- attr(*, "names")= chr [1:500] "S1" "S2" "S3" "S4" "S5" "S6" "S7" ...
Cluster sizes: 200 300
Best sample:
[1] S37 S49 S54 S63 S68 S71 S76 S80 S82 S101 S103 S108 S109 S118 S121
[16] S128 S132 S138 S144 S162 S203 S210 S216 S231 S234 S249 S260 S261 S286 S299
[31] S304 S305 S312 S315 S322 S350 S403 S450 S454 S455 S456 S465 S488 S497
Available components:
[1] "sample" "medoids" "i.med" "clustering" "objective"
[6] "clusinfo" "diss" "call" "silinfo" "data" L’affichage raconte déjà toute l’histoire : deux médoïdes (S121 près de l’origine, S455 près de (50, 50)), une valeur de fonction objectif (la dissimilarité moyenne — le coût que CLARA a minimisé), les tailles des regroupements (200 et 300, exactement les groupes que nous avons construits), et le meilleur échantillon d’étiquettes de lignes qui a produit cette partition.
L’objet renvoyé par clara() contient tout ce dont vous avez besoin. Les composantes que vous utiliserez le plus sont :
medoids — les objets (points de données réels) qui représentent chaque regroupement.clustering — un vecteur donnant le numéro de regroupement de chaque observation.sample — les étiquettes des observations du meilleur échantillon, c’est-à-dire l’échantillon que CLARA a utilisé pour la partition finale.Pour reporter les étiquettes de regroupement sur vos données, ajoutez le vecteur d’affectation comme nouvelle colonne :
library(cluster)
set.seed(1234)
df <- rbind(cbind(rnorm(200, 0, 8), rnorm(200, 0, 8)),
cbind(rnorm(300, 50, 8), rnorm(300, 50, 8)))
colnames(df) <- c("x", "y")
rownames(df) <- paste0("S", 1:nrow(df))
clara.res <- clara(df, 2, samples = 50, pamLike = TRUE)
# Add the cluster assignment to the original data
dd <- cbind(df, cluster = clara.res$cluster)
head(dd, n = 4) x y cluster
S1 -9.656526 3.881815 1
S2 2.219434 5.574150 1
S3 8.675529 1.484111 1
S4 -18.765582 5.605868 1Vous pouvez accéder directement aux médoïdes et au vecteur de regroupement :
library(cluster)
set.seed(1234)
df <- rbind(cbind(rnorm(200, 0, 8), rnorm(200, 0, 8)),
cbind(rnorm(300, 50, 8), rnorm(300, 50, 8)))
colnames(df) <- c("x", "y")
rownames(df) <- paste0("S", 1:nrow(df))
clara.res <- clara(df, 2, samples = 50, pamLike = TRUE)
# Medoids: the two representative observations
clara.res$medoids x y
S121 -1.531137 1.145057
S455 48.357304 50.233499# Clustering: the cluster of each of the first 10 observations
head(clara.res$clustering, 10) S1 S2 S3 S4 S5 S6 S7 S8 S9 S10
1 1 1 1 1 1 1 1 1 1 Les deux médoïdes sont S121 et S455 — des lignes réelles du jeu de données, et non des moyennes calculées. C’est là la caractéristique déterminante des méthodes fondées sur les médoïdes : chaque regroupement est résumé par une observation réelle et interprétable.
Pour voir la partition, utilisez fviz_cluster() de factoextra — le même graphique en un appel que vous utiliseriez pour les k-means ou PAM. Il trace un nuage de points colorés par regroupement, et lorsque les données ont plus de deux variables, il réduit d’abord les dimensions avec une PCA. Ici, nos données sont déjà bidimensionnelles, les axes sont donc simplement x et y :
library(cluster)
library(factoextra)
set.seed(1234)
df <- rbind(cbind(rnorm(200, 0, 8), rnorm(200, 0, 8)),
cbind(rnorm(300, 50, 8), rnorm(300, 50, 8)))
colnames(df) <- c("x", "y")
rownames(df) <- paste0("S", 1:nrow(df))
clara.res <- clara(df, 2, samples = 50, pamLike = TRUE)
fviz_cluster(clara.res,
palette = c("#00AFBB", "#FC4E07"), # colour palette
ellipse.type = "t", # concentration ellipse
geom = "point", pointsize = 1,
ggtheme = theme_classic())
Les deux regroupements se séparent nettement, chacun enveloppé dans une ellipse de concentration de loi de t — un signe rassurant que k = 2 décrit bien ces données. Comme CLARA a travaillé à partir d’échantillons plutôt que de la matrice complète des 500 points, il a atteint ce résultat rapidement et avec une faible empreinte mémoire.
CLARA et PAM produisent le même type de résultat — des regroupements résumés par des médoïdes — mais ils le paient différemment :
| PAM | CLARA | |
|---|---|---|
| Recherche | le jeu de données entier | plusieurs petits échantillons |
| Mémoire | la matrice de dissimilarités complète n × n | seulement la matrice sampsize × sampsize |
| Coût | croît ~ avec n² (lent sur grand n) | quasi linéaire en n — passe à l’échelle des grandes données |
| Résultat | les meilleurs médoïdes globaux | les meilleurs médoïdes trouvés parmi les échantillons |
| Idéal pour | jusqu’à quelques milliers d’observations | des dizaines de milliers et plus |
Le compromis est le compromis habituel : CLARA gagne en vitesse et en faible empreinte mémoire en renonçant à la garantie de trouver les médoïdes globalement optimaux — il ne trouve que le meilleur ensemble parmi les échantillons qu’il a tirés. En pratique, augmenter samples (et sampsize) resserre cet écart. La règle empirique : utilisez PAM tant qu’il s’exécute confortablement ; passez à CLARA dès que les données deviennent trop grandes pour que PAM les gère.
CLARA transforme une recherche globale coûteuse en plusieurs recherches locales bon marché. À chacune des samples itérations, il tire un sous-ensemble de taille sampsize, exécute PAM sur ce seul sous-ensemble pour obtenir k médoïdes candidats \(m_1, \dots, m_k\), puis évalue ces médoïdes par rapport au jeu de données entier par la dissimilarité moyenne
\[ \bar{d} = \frac{1}{n} \sum_{i=1}^{n} d(x_i,\, m_{c(i)}), \]
où \(x_i\) est la \(i\)-ème observation, \(m_{c(i)}\) est le médoïde du regroupement auquel elle est affectée, et \(n\) est le nombre total d’observations. L’ensemble de médoïdes ayant le plus petit \(\bar{d}\) parmi tous les échantillons l’emporte. Comme chaque exécution de PAM ne touche que sampsize points (par défaut \(40 + 2k\)) plutôt que tous les \(n\), le coût par échantillon est indépendant de \(n\) — ce qui explique précisément pourquoi CLARA passe à l’échelle là où PAM ne le peut pas. Plus d’échantillons et un sampsize plus grand réduisent le risque d’un tirage malchanceux au prix de plus de calcul.
Modifiez et exécutez le code ci-dessous dans votre navigateur — aucune installation nécessaire. Essayez d’augmenter samples, de changer k, ou de substituer votre propre grand jeu de données numériques, puis réexécutez et regardez le graphique des regroupements se mettre à jour.
Vous travaillez avec un grand jeu de données à vous ? Demandez à Prova « mes données sont-elles trop grandes pour PAM — devrais-je utiliser CLARA ? » — elle répond avec du code R que vous pouvez exécuter sur vos données, vous aide à régler samples et sampsize, et lit le graphique des regroupements avec vous. The runtime is the judge. Demander à Prova →
samples (le nombre de tirages, par ex. de 5 à 50) et/ou sampsize (la taille de chaque tirage) pour que CLARA cherche plus en profondeur, et définissez set.seed() pour que votre résultat soit reproductible.stand = TRUE à clara() ou scale() les données vous-même — afin que chaque variable contribue équitablement aux dissimilarités.pamLike = TRUE. Sans lui, clara() utilise un algorithme plus ancien et de moindre qualité. Définissez toujours pamLike = TRUE pour que l’échantillonnage suive la même logique que pam().Les deux sont des méthodes de k-médoïdes — chaque regroupement est représenté par un point de données réel (un médoïde). La différence tient à l’échelle : PAM parcourt le jeu de données entier et stocke la matrice complète des dissimilarités par paires, il est donc précis mais lent et gourmand en mémoire sur de grandes données. CLARA exécute PAM sur plusieurs petits échantillons à la place et conserve le meilleur résultat, ce qui passe à l’échelle de dizaines de milliers d’observations au prix de ne trouver que les meilleurs médoïdes parmi les échantillons qu’il a tirés. Voir PAM / k-médoïdes.
Pour de grandes données (plus de quelques milliers de lignes), utilisez CLARA du package cluster : clara(df, k, samples = 50, pamLike = TRUE). Il échantillonne les données pour trouver rapidement des médoïdes robustes, évitant l’explosion mémoire qui rend PAM infaisable à cette taille. Standardisez d’abord vos variables (stand = TRUE ou scale()) si elles sont à des échelles différentes, et choisissez k avec fviz_nbclust(df, clara, method = "silhouette").
La valeur par défaut de samples, 5, est trop basse pour un travail sérieux — augmentez-la à 50 ou plus. Chaque échantillon est un tirage aléatoire indépendant sur lequel CLARA exécute PAM, donc plus d’échantillons réduisent le risque d’un tirage malchanceux et donnent un regroupement plus fiable. Le compromis est le temps de calcul : plus d’échantillons coûtent plus cher. L’argument compagnon sampsize contrôle le nombre d’observations que contient chaque tirage (par défaut \(40 + 2k\)) ; agrandissez-le pour de très grandes données ou des données bruitées.
pamLike = TRUE indique à clara() d’utiliser exactement le même algorithme que pam() lors du regroupement de chaque échantillon, ce qui produit une partition de meilleure qualité. La valeur par défaut (FALSE) conserve un algorithme plus ancien pour la compatibilité ascendante. À moins d’avoir une raison précise de ne pas le faire, définissez toujours pamLike = TRUE.
Oui, chaque fois que vos variables sont à des échelles différentes — CLARA regroupe sur des dissimilarités, donc une variable de forte amplitude dominerait. Passez soit stand = TRUE à clara() (il standardise les colonnes pour vous), soit scale() les données avant le regroupement. Si toutes les variables sont déjà à la même échelle, vous pouvez l’omettre.
Simulez 1000 points en trois groupes bien séparés (par ex. 300 autour de (0,0), 300 autour de (30,30), 400 autour de (0,40)), nommez les colonnes et les lignes, exécutez CLARA avec k = 3, samples = 50 et pamLike = TRUE, affichez les médoïdes, et tracez le graphique des regroupements.
Construisez les données avec rbind(cbind(rnorm(...), rnorm(...)), ...) pour trois blocs, définissez colnames()/rownames(), puis appelez clara(df, 3, samples = 50, pamLike = TRUE) et passez le résultat à fviz_cluster().
library(cluster)
library(factoextra)
set.seed(1234)
df <- rbind(cbind(rnorm(300, 0, 8), rnorm(300, 0, 8)),
cbind(rnorm(300, 30, 8), rnorm(300, 30, 8)),
cbind(rnorm(400, 0, 8), rnorm(400, 40, 8)))
colnames(df) <- c("x", "y")
rownames(df) <- paste0("S", 1:nrow(df))
clara.res <- clara(df, 3, samples = 50, pamLike = TRUE)
clara.res$medoids
fviz_cluster(clara.res, palette = c("#00AFBB", "#E7B800", "#FC4E07"),
ellipse.type = "t", geom = "point", pointsize = 1,
ggtheme = theme_classic())CLARA retrouve les trois groupes, chacun résumé par une observation médoïde réelle.
Vérification rapide. Votre jeu de données comporte 60 000 lignes et PAM manque de mémoire. Vers quelle fonction basculez-vous, et quel unique argument compte le plus pour obtenir un résultat fiable ?
Basculez vers clara(). L’argument qui compte le plus est samples — augmentez-le bien au-delà de la valeur par défaut de 5 (par ex. à 50) pour que CLARA tire assez de sous-ensembles afin de trouver de bons médoïdes ; gardez aussi pamLike = TRUE. CLARA passe à l’échelle des grandes données en regroupant des échantillons plutôt que la matrice de dissimilarités complète n × n.
Vous avez simulé un grand jeu de données, choisi k avec la méthode de la silhouette, exécuté clara() avec samples = 50 et pamLike = TRUE pour une solution robuste, lu les médoïdes et les affectations aux regroupements, et visualisé les deux groupes avec fviz_cluster(). CLARA est la méthode à privilégier quand PAM est trop lent ou trop gourmand en mémoire — même robustesse fondée sur les médoïdes, mais mise à l’échelle des grandes données par l’échantillonnage. Pour des données plus petites, préférez PAM directement ; pour des regroupements sphériques à toute taille, les k-means sont plus rapides encore. Pour cerner k rigoureusement, poursuivez avec le nombre optimal de regroupements.
k avec les méthodes de la silhouette, du coude et du gap. · Mesures de distance pour le regroupement — la règle de dissimilarité dont dépend CLARA.Vous préférez un livre ? Practical Guide to Cluster Analysis in R est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.
Prouvez que vous savez le faire. Maîtrisez toute la série Analyse de clustering en R — suivez votre parcours, construisez des projets et obtenez un certificat.
Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.
dès 15 $/mois facturé annuellement
✓ Vous êtes Pro — continuez. The runtime is the judge.
Prêt à passer à la vitesse supérieure ?
Cette leçon est reproductible : chaque figure a été produite par le code montré — modifiez n’importe quel bloc et exécutez-le, et le bac à sable et le quiz se réexécutent en direct dans votre navigateur. The runtime is the judge.
@online{2026,
author = {},
title = {CLARA : regrouper de grands jeux de données en R},
date = {2026-06-24},
url = {https://www.datanovia.com/learn/machine-learning/clustering/clara},
langid = {fr}
}
Comment fonctionne CLARA
Au lieu de trouver les médoïdes pour le jeu de données entier, CLARA considère un petit échantillon de taille fixe (
sampsize) et lui applique l’algorithme PAM, produisant un ensemble candidat de médoïdes. La qualité de ces médoïdes est ensuite mesurée par rapport au jeu de données complet : chaque objet est affecté au médoïde le plus proche, et la dissimilarité moyenne entre chaque objet et son médoïde devient le coût de cette solution.CLARA répète ce processus d’échantillonnage et de regroupement plusieurs fois (
samples) pour réduire le biais d’échantillonnage, et conserve l’ensemble de médoïdes au coût minimal. En bref :sampsize) à partir des données.kmédoïdes représentatifs. Affectez chaque observation du jeu de données complet à son médoïde le plus proche.Chaque nouveau sous-ensemble est contraint d’inclure les médoïdes trouvés par le meilleur sous-ensemble jusqu’ici, avec des observations aléatoires ajoutées jusqu’à atteindre
sampsize— ainsi la recherche s’améliore continuellement au lieu de repartir de zéro à chaque fois.