Choisir le meilleur algorithme de regroupement en R

Q: Comment utiliser clValid en R ?

Standardisez vos données numériques, puis appelez clValid(df, nClust = 2:6, clMethods = c("hierarchical","kmeans","pam"), validation = "internal"). Utilisez summary() pour voir le tableau complet des mesures et les Optimal Scores gagnants, ou optimalScores() pour n’avoir que les gagnants sous forme de data frame. Définissez validation = "stability" pour les mesures APN/AD/ADM/FOM, et plot() sur le résultat pour voir chaque mesure sur la plage de k.

Q: Quelle est la différence entre les mesures de validation interne et de stabilité ?

Les mesures internes (connectivité, Dunn, silhouette) notent un regroupement à partir des seules données — elles demandent « ces clusters sont-ils compacts et bien séparés ? » Les mesures de stabilité (APN, AD, ADM, FOM) re-regroupent les données en supprimant chaque colonne et récompensent les résultats qui changent à peine — elles demandent « obtiendrais-je le même regroupement à partir de données légèrement différentes ? » Utilisez les deux : un bon regroupement devrait bien se classer sur les mesures internes et être stable.

Q: Faut-il maximiser ou minimiser chaque mesure de clValid ?

Maximisez la silhouette et l’indice de Dunn (plus haut = meilleure séparation). Minimisez la connectivité et les quatre mesures de stabilité — APN, AD, ADM et FOM (plus bas = plus reproductible). Le tableau Optimal Scores applique déjà la bonne direction pour vous et rapporte le meilleur score unique par mesure.

Q: Pourquoi AD et FOM suggèrent-ils plus de clusters que la silhouette ?

AD et FOM sont des mesures de stabilité à l’échelle des distances sans borne supérieure, et elles tendent à continuer de s’améliorer à mesure que les clusters rapetissent — elles dérivent donc vers un k plus grand (ici PAM avec 6). La silhouette et l’indice de Dunn récompensent une vraie séparation, qui culmine au nombre réel de groupes (ici k = 2). En cas de désaccord, privilégiez les mesures bornées (silhouette, APN, ADM) et votre connaissance du domaine.

Comparez k-means, PAM et la classification hiérarchique avec les mesures internes et de stabilité de clValid

Ne devinez pas quel algorithme de regroupement convient à vos données — mesurez-le. Utilisez le package clValid pour comparer k-means, PAM et la classification hiérarchique sur une plage de k avec des mesures de validation internes (connectivité, Dunn, silhouette) et de stabilité (APN, AD, ADM, FOM).

Date de publication

24 juin 2026

Modifié

7 juillet 2026

Points clés

Ne devinez pas quel algorithme de regroupement convient à vos données — comparez-en plusieurs d’un coup et mesurez le résultat.
Le package clValid exécute k-means, PAM, la classification hiérarchique et d’autres sur une plage de k en un seul appel.
Les mesures internes (connectivité, indice de Dunn, silhouette) évaluent un regroupement à partir des seules données — une silhouette / un Dunn plus élevés et une connectivité plus faible sont meilleurs.
Les mesures de stabilité (APN, AD, ADM, FOM) re-regroupent après suppression de chaque colonne et récompensent les résultats qui ne changent pas — plus petit est meilleur.
Lisez le tableau Optimal Scores et optimalScores() pour voir quel algorithme l’emporte sur quelle mesure, puis laissez votre domaine trancher.

Introduction

Vous avez décidé de regrouper vos données — profils d’expression génique, segments de clientèle ou, comme ici, mesures de fleurs. Mais quel algorithme ? k-means est rapide et familier ; PAM / k-médoïdes est robuste aux valeurs aberrantes ; la classification hiérarchique vous donne un dendrogramme. Et quel k ? Examiner un graphique par algorithme ne passe pas à l’échelle, et il est facile de se leurrer.

L’approche honnête consiste à arrêter de deviner et à mesurer. Le package clValid (Brock et al., 2008) compare plusieurs algorithmes de regroupement simultanément, sur une plage de nombres de clusters, en un seul appel de fonction — et note chaque combinaison à l’aide de mesures de validation publiées. Vous lisez directement la paire algorithme-et-k qui l’emporte.

clValid utilise deux familles de mesures :

Mesures internes — jugent le regroupement à partir des seules données (compacité et séparation) : la connectivité, le coefficient de silhouette et l’indice de Dunn (les mêmes statistiques traitées en détail dans statistiques de validation des regroupements).
Mesures de stabilité — un cas particulier des mesures internes qui vérifient la cohérence : re-regrouper les données en supprimant chaque colonne, une à la fois, et récompenser les regroupements qui changent à peine. Ce sont APN, AD, ADM et FOM.

Cette leçon les exécute toutes deux sur les classiques données iris et en lit les résultats.

Les mesures, en bref

Avant le code, sachez ce que vous optimisez — la direction compte, car certaines mesures se maximisent et d’autres se minimisent.

Mesures internes :

Connectivité — à quelle fréquence des observations voisines se retrouvent dans des clusters différents. Elle va de 0 à ∞ et doit être minimisée.
Largeur de silhouette — à quel point chaque point s’insère bien dans son propre cluster par rapport au voisin le plus proche. Elle va de −1 à 1 et doit être maximisée.
Indice de Dunn — le rapport entre la plus petite distance inter-clusters et le plus grand diamètre intra-cluster. Il va de 0 à ∞ et doit être maximisé.

Les mesures de stabilité re-regroupent toutes après suppression d’une colonne à la fois et comparent au regroupement obtenu sur l’ensemble des données :

APN — la proportion moyenne d’observations non placées dans le même cluster. Dans [0, 1], plus petit est meilleur.
AD — la distance moyenne entre observations placées dans le même cluster dans les deux cas. Dans [0, ∞), plus petit est meilleur.
ADM — la distance moyenne entre centres de clusters pour les observations placées dans le même cluster dans les deux cas. Dans [0, ∞), plus petit est meilleur.
FOM — le figure of merit : la variance intra-cluster moyenne de la colonne supprimée, prédite à partir des colonnes restantes. Dans [0, ∞), plus petit est meilleur.

Note

Pour APN, ADM et FOM, les valeurs se situent entre 0 et 1, des valeurs plus petites indiquant un regroupement plus cohérent (plus stable). AD va de 0 à ∞, et là encore plus petit est préférable. Ainsi, pour toutes les mesures de stabilité, la règle est la même : plus bas = plus reproductible.

clValid propose aussi des mesures de validation biologique (les clusters regroupent-ils des gènes partageant une fonction connue ?) pour les données de puces à ADN / RNA-seq — hors de notre périmètre ici, mais il est bon de savoir qu’elles existent.

Les données

Nous utilisons les classiques données iris — quatre mesures de fleurs sur 150 spécimens. Nous supprimons l’étiquette Species (le regroupement est non supervisé — on ne lui donne pas la réponse) et standardisons les quatre colonnes numériques pour que chacune contribue de façon égale quelles que soient ses unités. C’est la même préparation que dans toutes les leçons de regroupement.

library(clValid)

# iris without the Species label, scaled (mean 0, sd 1 per column)
df <- scale(iris[, -5])
head(df)

     Sepal.Length Sepal.Width Petal.Length Petal.Width
[1,]   -0.8976739  1.01560199    -1.335752   -1.311052
[2,]   -1.1392005 -0.13153881    -1.335752   -1.311052
[3,]   -1.3807271  0.32731751    -1.392399   -1.311052
[4,]   -1.5014904  0.09788935    -1.279104   -1.311052
[5,]   -1.0184372  1.24503015    -1.335752   -1.311052
[6,]   -0.5353840  1.93331463    -1.165809   -1.048667

Chaque appel de clValid() ci-dessous part de ce df standardisé.

La fonction `clValid()`

Un seul appel fait toute la comparaison. La forme simplifiée :

clValid(obj, nClust, clMethods = "hierarchical",
        validation = "stability", maxitems = 600,
        metric = "euclidean", method = "average")

Les arguments que vous définirez :

obj — votre matrice numérique ou votre data frame (lignes = éléments à regrouper).
nClust — les nombres de clusters à évaluer, p. ex. 2:6.
clMethods — les algorithmes à comparer. Au choix parmi "hierarchical", "kmeans", "diana", "fanny", "som", "model", "sota", "pam", "clara", "agnes" — plusieurs autorisés.
validation — la famille de mesures : "internal", "stability" ou "biological" — plusieurs autorisées.
metric — la distance : "euclidean", "correlation" ou "manhattan".
method — pour la classification hiérarchique, la méthode d’agrégation : "ward", "single", "complete" ou "average".

Nous comparerons trois algorithmes — hierarchical, kmeans et pam — sur k = 2 à 6.

Validation interne

Commençons par les mesures internes. Nous passons les trois algorithmes et demandons validation = "internal" ; clValid() calcule la connectivité, le Dunn et la silhouette pour chaque combinaison algorithme-et-k d’un coup. summary() affiche le tableau complet ainsi que les Optimal Scores gagnants :

library(clValid)
df <- scale(iris[, -5])

clmethods <- c("hierarchical", "kmeans", "pam")
intern <- clValid(df, nClust = 2:6,
                  clMethods = clmethods, validation = "internal")
summary(intern)


Clustering Methods:
 hierarchical kmeans pam 

Cluster sizes:
 2 3 4 5 6 

Validation Measures:
                                 2       3       4       5       6
                                                                  
hierarchical Connectivity   0.9762  5.5964  7.5492 18.0508 24.7306
             Dunn           0.2674  0.1874  0.2060  0.0700  0.0762
             Silhouette     0.5818  0.4803  0.4067  0.3746  0.3248
kmeans       Connectivity   0.9762 23.8151 25.9183 40.3198 40.1524
             Dunn           0.2674  0.0265  0.0700  0.0808  0.0808
             Silhouette     0.5818  0.4599  0.4189  0.3455  0.3441
pam          Connectivity   0.9762 23.0726 31.8067 35.7964 44.5413
             Dunn           0.2674  0.0571  0.0566  0.0642  0.0361
             Silhouette     0.5818  0.4566  0.4091  0.3574  0.3400

Optimal Scores:

             Score  Method       Clusters
Connectivity 0.9762 hierarchical 2       
Dunn         0.2674 hierarchical 2       
Silhouette   0.5818 hierarchical 2

Lisez le bloc Optimal Scores en bas — il indique le meilleur score unique pour chaque mesure et d’où il provient :

Connectivité — meilleur 0.98, hiérarchique, 2 clusters (le plus bas, comme souhaité).
Dunn — meilleur 0.27, hiérarchique, 2 clusters (le plus haut, comme souhaité).
Silhouette — meilleur 0.58, hiérarchique, 2 clusters (le plus haut, comme souhaité).

Le verdict est unanime : la classification hiérarchique avec deux clusters l’emporte sur chaque mesure interne. Et quel que soit l’algorithme, le nombre optimal de clusters semble être 2 pour les trois mesures — exactement les deux groupes bien séparés que vous attendriez de iris (setosa contre le reste). optimalScores() renvoie uniquement ce tableau des gagnants sous forme de data frame si vous le voulez par programmation :

library(clValid)
df <- scale(iris[, -5])
clmethods <- c("hierarchical", "kmeans", "pam")
intern <- clValid(df, nClust = 2:6,
                  clMethods = clmethods, validation = "internal")

optimalScores(intern)

                 Score       Method Clusters
Connectivity 0.9761905 hierarchical        2
Dunn         0.2674261 hierarchical        2
Silhouette   0.5817500 hierarchical        2

Validation de stabilité

Passons aux mesures de stabilité. Même appel, validation = "stability" — clValid() re-regroupe les données en supprimant tour à tour chacune des quatre colonnes et rapporte APN, AD, ADM et FOM. Nous n’affichons que les gagnants avec optimalScores() :

library(clValid)
df <- scale(iris[, -5])

clmethods <- c("hierarchical", "kmeans", "pam")
stab <- clValid(df, nClust = 2:6,
                clMethods = clmethods, validation = "stability")
optimalScores(stab)

          Score       Method Clusters
APN 0.003266667 hierarchical        2
AD  1.004288856          pam        6
ADM 0.016087089 hierarchical        2
FOM 0.455750052          pam        6

En lisant les quatre gagnants (rappel : plus petit est meilleur pour tous) :

APN — meilleur 0.003, hiérarchique, 2 clusters.
AD — meilleur 1.004, PAM, 6 clusters.
ADM — meilleur 0.016, hiérarchique, 2 clusters.
FOM — meilleur 0.456, PAM, 6 clusters.

L’histoire de la stabilité est donc partagée : pour APN et ADM, la classification hiérarchique avec deux clusters donne à nouveau le meilleur score ; pour AD et FOM, PAM avec six clusters l’emporte. C’est fréquent — AD et FOM sont des mesures à l’échelle des distances qui continuent souvent de s’améliorer à mesure que vous ajoutez des clusters (des clusters plus nombreux et plus petits sont individuellement plus reproductibles), si bien qu’elles tendent à favoriser un k plus grand. APN et ADM, qui comptent les changements d’appartenance, s’accordent ici avec les mesures internes.

Tracer les mesures de validation

Un tableau est précis ; un graphique vous montre la courbe entière sur la plage de k, de sorte que vous voyez comment chaque algorithme se comporte à mesure que des clusters sont ajoutés. Appelez plot() sur le résultat clValid — il dessine un panneau par mesure, une ligne par algorithme. Nous désactivons la légende intégrée et ajoutons la nôtre, plus propre :

library(clValid)
df <- scale(iris[, -5])
clmethods <- c("hierarchical", "kmeans", "pam")
intern <- clValid(df, nClust = 2:6,
                  clMethods = clmethods, validation = "internal")

op <- par(mfrow = c(1, 3), mar = c(4, 4, 2, 1))
plot(intern, legend = FALSE)

Three panels — connectivity, Dunn index, and silhouette width — each plotting the three algorithms (hierarchical, k-means, PAM) against the number of clusters from 2 to 6, with hierarchical best at k = 2.

par(op)

Lisez les panneaux de gauche à droite. La connectivité augmente avec k (pire) pour chaque algorithme, l’hiérarchique étant la plus basse. Le Dunn et la silhouette culminent tous deux à k = 2 puis déclinent — l’hiérarchique est en tête. Le graphique rend visuel le verdict du tableau : l’hiérarchique à k = 2 domine les mesures internes.

Le même plot() fonctionne sur le résultat de stabilité — choisissez les mesures qui vous intéressent :

library(clValid)
df <- scale(iris[, -5])
clmethods <- c("hierarchical", "kmeans", "pam")
stab <- clValid(df, nClust = 2:6,
                clMethods = clmethods, validation = "stability")

op <- par(mfrow = c(1, 3), mar = c(4, 4, 2, 1))
plot(stab, measure = c("APN", "AD", "ADM"), legend = FALSE)

Three panels — APN, AD, and ADM stability measures — plotting hierarchical, k-means and PAM against the number of clusters, with APN and ADM lowest for hierarchical at k = 2.

par(op)

APN et ADM restent proches de zéro pour l’hiérarchique aux petits k (très stables), tandis qu’AD continue de baisser à mesure que k grandit — ce qui explique exactement pourquoi AD a couronné PAM à k = 6 dans le tableau. Voir les courbes vous évite de sur-interpréter un seul chiffre gagnant.

Une recommandation pratique

Mettez les deux tableaux côte à côte pour iris :

Famille	Mesure	Gagnant	k
Interne	Connectivité	hiérarchique	2
Interne	Dunn	hiérarchique	2
Interne	Silhouette	hiérarchique	2
Stabilité	APN	hiérarchique	2
Stabilité	AD	PAM	6
Stabilité	ADM	hiérarchique	2
Stabilité	FOM	PAM	6

Cinq mesures sur sept — et toutes les mesures de séparation/compacité — pointent vers la classification hiérarchique avec deux clusters. Les deux dissidentes (AD, FOM) sont des mesures à l’échelle des distances biaisées vers un k plus grand, alors ne les laissez pas supplanter le consensus.

Le flux de travail qui se généralise au-delà d’iris :

Comparez les algorithmes, ne vous engagez pas sur un seul. Passez-en plusieurs à clMethods et laissez les mesures arbitrer.
Regardez l’interne et la stabilité. Les mesures internes jugent « ce regroupement est-il bon ? » ; la stabilité demande « obtiendrais-je le même regroupement à partir de données légèrement différentes ? » Vous voulez les deux.
Surveillez la direction. Maximisez la silhouette et le Dunn ; minimisez la connectivité et toutes les mesures de stabilité.
Laissez le domaine trancher. Les mesures présélectionnent (ici, hiérarchique / k = 2) ; choisissez le résultat que vous pouvez interpréter, puis confirmez-le avec les statistiques de validation des regroupements.

Essayez en direct

Les tableaux et graphiques ci-dessus ont été rendus au moment de la compilation. Vous voulez ajouter un algorithme (disons "diana") ou changer la plage de k ? Modifiez le code et appuyez sur Run — il s’exécute dans votre navigateur via webR (sans installation).

🟢 Avec un agent IA

Demandez à Prova « quel algorithme de regroupement et combien de clusters conviennent le mieux à mes données ? » — elle répond avec du code clValid() que vous pouvez exécuter sur votre propre matrice, puis vous aide à lire les scores internes et de stabilité. The runtime is the judge. Demander à Prova →

Problèmes courants

Les mesures internes et de stabilité sont en désaccord (p. ex. l’interne dit k = 2, AD/FOM disent k = 6). C’est attendu. Les mesures internes récompensent des clusters compacts et séparés ; AD et FOM sont des mesures de stabilité à l’échelle des distances qui continuent de s’améliorer à mesure que les clusters rapetissent, si bien qu’elles dérivent vers un k plus grand. Fiez-vous au consensus entre les mesures — et préférez APN/ADM (bornées dans [0, 1]) à AD/FOM quand c’est la stabilité qui vous importe, puisque les mesures bornées ne sont pas biaisées par le nombre de clusters.

Quelle method hiérarchique utiliser ? clValid() utilise par défaut method = "average" pour la classification hiérarchique. Le choix compte : "ward" (utilisez "ward.D2" si vous appelez hclust directement) tend à donner des clusters compacts et de taille égale ; "single" enchaîne ; "complete" est sensible aux valeurs aberrantes. Si vous coupez un dendrogramme par la suite, faites correspondre la méthode ici à celle que vous utiliserez là — voir la classification hiérarchique.

Que mesurent réellement APN et AD ? Toutes deux suppriment une colonne, re-regroupent et comparent au regroupement obtenu sur l’ensemble des données. APN compte la proportion d’observations qui ont changé de cluster (une mesure d’appartenance, bornée 0–1). AD mesure la distance moyenne entre observations restées ensemble (une mesure géométrique, non bornée). APN répond à « les étiquettes ont-elles bougé ? » ; AD répond à « de combien les choses se sont-elles déplacées ? » — elles peuvent désigner des gagnants différents.

clValid() affiche des messages ou est lent. Il avertit lorsque vos données n’ont pas de noms de lignes (sans gravité) et re-regroupe une fois par colonne supprimée pour la stabilité, ce qui est plus lourd qu’un seul regroupement. Définissez execute: { message: false } dans l’en-tête pour faire taire les notes, et gardez nClust et la liste d’algorithmes modestes lors de l’exploration.

Questions fréquentes

Quel algorithme de regroupement est le meilleur ?

Il n’existe pas d’algorithme universellement meilleur — cela dépend de la forme de vos données et de votre objectif. La façon honnête de choisir est de mesurer : exécutez clValid() avec plusieurs algorithmes dans clMethods (p. ex. c("hierarchical", "kmeans", "pam")) et une plage de nClust, puis lisez les Optimal Scores. Sur iris, la classification hiérarchique avec deux clusters l’emporte sur presque toutes les mesures internes et de stabilité. Laissez les mesures présélectionner, puis choisissez le résultat que vous pouvez interpréter.

Comment utiliser clValid en R ?

Standardisez vos données numériques, puis appelez clValid(df, nClust = 2:6, clMethods = c("hierarchical","kmeans","pam"), validation = "internal"). Utilisez summary() pour voir le tableau complet des mesures et les Optimal Scores gagnants, ou optimalScores() pour n’avoir que les gagnants sous forme de data frame. Définissez validation = "stability" pour les mesures APN/AD/ADM/FOM, et plot() sur le résultat pour voir chaque mesure sur la plage de k.

Quelle est la différence entre les mesures de validation interne et de stabilité ?

Les mesures internes (connectivité, Dunn, silhouette) notent un regroupement à partir des seules données — elles demandent « ces clusters sont-ils compacts et bien séparés ? » Les mesures de stabilité (APN, AD, ADM, FOM) re-regroupent les données en supprimant chaque colonne et récompensent les résultats qui changent à peine — elles demandent « obtiendrais-je le même regroupement à partir de données légèrement différentes ? » Utilisez les deux : un bon regroupement devrait bien se classer sur les mesures internes et être stable.

Faut-il maximiser ou minimiser chaque mesure de clValid ?

Maximisez la silhouette et l’indice de Dunn (plus haut = meilleure séparation). Minimisez la connectivité et les quatre mesures de stabilité — APN, AD, ADM et FOM (plus bas = plus reproductible). Le tableau Optimal Scores applique déjà la bonne direction pour vous et rapporte le meilleur score unique par mesure.

Pourquoi AD et FOM suggèrent-ils plus de clusters que la silhouette ?

AD et FOM sont des mesures de stabilité à l’échelle des distances sans borne supérieure, et elles tendent à continuer de s’améliorer à mesure que les clusters rapetissent — elles dérivent donc vers un k plus grand (ici PAM avec 6). La silhouette et l’indice de Dunn récompensent une vraie séparation, qui culmine au nombre réel de groupes (ici k = 2). En cas de désaccord, privilégiez les mesures bornées (silhouette, APN, ADM) et votre connaissance du domaine.

Testez vos connaissances

Exercice : comparer les algorithmes sur les mesures de stabilité

Complétez le code pour qu’il compare hierarchical, kmeans et pam sur les mesures de stabilité pour k = 2 à 6, puis affiche uniquement les scores gagnants.

library(clValid)
df <- scale(iris[, -5])

clmethods <- c("hierarchical", "kmeans", "pam")
stab <- clValid(df, nClust = 2:6,
                clMethods = clmethods, validation = "stability")
optimalScores(stab)
# APN & ADM → hierarchical, k = 2; AD & FOM → PAM, k = 6.

Vérification rapide : quel énoncé est correct ?

Une connectivité plus élevée signifie un meilleur regroupement.
Les mesures de stabilité doivent toutes être minimisées — des valeurs plus petites signifient un regroupement plus reproductible.
clValid() ne peut évaluer qu’un seul algorithme de regroupement à la fois.

Afficher la réponse

L’énoncé 2 est correct. APN, AD, ADM et FOM se minimisent tous — plus petit signifie que le regroupement change à peine quand une colonne est supprimée. L’énoncé 1 est faux : la connectivité se minimise (plus bas est meilleur). L’énoncé 3 est faux : clMethods accepte plusieurs algorithmes, ce qui est tout l’intérêt de clValid().

Conclusion

Vous avez comparé k-means, PAM et la classification hiérarchique sur iris avec un appel de clValid() par famille de mesures. Les mesures internes (connectivité 0.98, Dunn 0.27, silhouette 0.58) ont couronné à l’unanimité la classification hiérarchique avec deux clusters ; les mesures de stabilité s’accordaient pour l’essentiel (APN, ADM → hiérarchique / 2), AD et FOM favorisant PAM / 6 comme tendent à le faire les mesures à l’échelle des distances. La leçon : ne devinez pas l’algorithme — comparez-en plusieurs et lisez les mesures, puis laissez l’interprétabilité trancher. Une fois l’algorithme choisi, validez les clusters que vous conservez.

Leçons connexes

Statistiques de validation des regroupements — les mesures de connectivité, de silhouette et de Dunn que clValid rapporte, expliquées en détail. · Déterminer le nombre optimal de clusters — les méthodes du coude, de la silhouette et du gap pour fixer k. · Regroupement k-means · PAM / k-médoïdes · Classification hiérarchique — les algorithmes comparés ici.
Utilisez-le sur : k-means · PAM · classification hiérarchique · Analyse de regroupement — la série complète. · Machine Learning — le pilier.

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.

Obtenir le livre (PDF) →Les leçons restent gratuites en ligne.

Cette page vous a-t-elle été utile ?

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.

Commencer gratuitement →

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

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Prêt à passer à la vitesse supérieure ?

Prouvez-le — obtenez le certificat Partitionnement (clustering).Passer l'évaluation →Essayez sur vos propres données avec Prova — the runtime is the judge.Ouvrir Prova →

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Choisir le meilleur algorithme de regroupement en R},
  date = {2026-06-24},
  url = {https://www.datanovia.com/learn/machine-learning/clustering/choosing-best-algorithm},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Choisir le meilleur algorithme de regroupement en R.” 2026. June 24. https://www.datanovia.com/learn/machine-learning/clustering/choosing-best-algorithm.