Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Algorithme des k-moyennes (k-means)
L'algorithme des k-moyennes (k-means) est un algorithme d'apprentissage non supervisé. Il tente de trouver des regroupements discrets au sein des données, au sein desquels les membres d'un groupe sont aussi semblables que possible les uns des autres et aussi différents que possible des membres des autres groupes. Vous définissez les attributs qui doivent être utilisés par l'algorithme pour déterminer la similarité.
Amazon SageMaker AI utilise une version modifiée de l'algorithme de clustering k-means à l'échelle du Web. Par rapport à la version originale de l'algorithme, la version utilisée par Amazon SageMaker AI est plus précise. Comme l'algorithme d'origine, elle effectue une mise à l'échelle par rapport aux ensembles de données massifs et fournit des améliorations dans les délais de l'entraînement. Pour ce faire, la version utilisée par Amazon SageMaker AI diffuse des mini-lots (petits sous-ensembles aléatoires) des données d'entraînement. Pour plus d'informations sur les mini-lots et les k-moyennes (k-means), consultez [Web-scale k-means Clustering](https://dl.acm.org/doi/10.1145/1772690.1772862).
L'algorithme des k-moyennes (k-means) s'attend à des données tabulaires, où les lignes représentent les observations que vous souhaitez regrouper, et les colonnes, les attributs des observations. L'attribut *n* de chaque ligne représente un point dans un espace à *n* dimension(s). La distance euclidienne entre ces points représente la similarité des observations correspondantes. L'algorithme regroupe les observations avec les valeurs d'attribut similaires (les points correspondant à ces observations sont rapprochés). Pour plus d'informations sur le fonctionnement de k-means dans Amazon SageMaker AI, consultez[Fonctionnement du clustering des données à l'aide de l'algorithme de k-moyennes (k-means)](algo-kmeans-tech-notes.md).
**Topics**
+ [Interface d'entrée/sortie pour l'algorithme des k-moyennes](#km-inputoutput)
+ [Recommandations relatives aux instances EC2 pour l'algorithme des k-moyennes](#km-instances)
+ [Exemples de blocs-notes de k-moyennes](#kmeans-sample-notebooks)
+ [Fonctionnement du clustering des données à l'aide de l'algorithme de k-moyennes (k-means)](algo-kmeans-tech-notes.md)
+ [Hyperparamètres pour k-moyennes (k-means)](k-means-api-config.md)
+ [Régler un modèle de k-moyennes](k-means-tuning.md)
+ [Formats de réponse des k-moyennes](km-in-formats.md)
## Interface d'entrée/sortie pour l'algorithme des k-moyennes
Pour l'entraînement, l'algorithme des k-moyennes (k-means) s'attend à ce que les données soient fournies dans le canal *train* (`S3DataDistributionType=ShardedByS3Key` recommandé), avec un canal *test* facultatif (`S3DataDistributionType=FullyReplicated` recommandé) pour y marquer les données. Les deux formats de fichier `recordIO-wrapped-protobuf` et `CSV` sont pris en charge pour l'entraînement. Vous pouvez utiliser le mode File (Fichier) ou le mode Pipe (Tube) pour entraîner les modèles sur les données obéissant au format `recordIO-wrapped-protobuf` ou au format `CSV`.
Pour l'inférence, les trois formats `text/csv`, `application/json` et `application/x-recordio-protobuf` sont pris en charge. L'algorithme des k-moyennes renvoie une étiquette `closest_cluster` et la valeur de `distance_to_cluster` pour chaque observation.
Pour plus d'informations sur les formats de fichier en entrée et en sortie, consultez [Formats de réponse des k-moyennes](km-in-formats.md) pour l'inférence, ainsi que la rubrique [Exemples de blocs-notes de k-moyennes](#kmeans-sample-notebooks). L'algorithme des k-moyennes ne prend pas en charge l'apprentissage de plusieurs instances, dans lequel l'ensemble d'entraînement est constitué de « sacs » étiquetés, chacun d'entre eux étant un ensemble d'instances non étiquetées.
## Recommandations relatives aux instances EC2 pour l'algorithme des k-moyennes
Nous vous recommandons d'entraîner les données de k-moyennes sur les instances CPU. Vous pouvez effectuer l'entraînement sur les instances de GPU, mais vous devez limiter l'entraînement sur GPU aux instances à un seul GPU (telles que ml.g4dn.xlarge), car un seul GPU est utilisé par instance. L'algorithme des k-moyennes prend en charge les instances P2, P3, G4dn et G5 pour l'entraînement et l'inférence.
## Exemples de blocs-notes de k-moyennes
Pour un exemple de carnet utilisant l'algorithme SageMaker AI K-means pour segmenter la population des comtés des États-Unis en fonction d'attributs identifiés à l'aide d'une analyse en composantes principales, [voir Analyser les données du recensement américain pour la segmentation de la population à l'aide](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/US-census_population_segmentation_PCA_Kmeans/sagemaker-countycensusclustering.html) d'Amazon AI. SageMaker Pour savoir comment créer et accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Une fois que vous avez créé une instance de bloc-notes et que vous l'avez ouverte, sélectionnez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Pour ouvrir un bloc-notes, cliquez sur son onglet **Use (Utiliser)** et sélectionnez **Create copy (Créer une copie)**.
# Fonctionnement du clustering des données à l'aide de l'algorithme de k-moyennes (k-means)
L'algorithme des k-moyennes est un algorithme qui entraîne un modèle regroupant les objets similaires. Il procède en associant chaque observation du jeu de données d'entrée à un point de l'espace à *n* dimensions (où *n* est le nombre d'attributs de l'observation). Par exemple, votre ensemble de données peut contenir des observations de température et d'humidité dans une région particulière, qui sont mappées aux points (*t, h*) d'une espace bidimensionnel.
**Note**
Les algorithmes de clustering ne sont pas supervisés. Dans l’apprentissage non supervisé, les étiquettes qui pourraient être associées à des objets du jeu de données d’entraînement ne sont pas utilisées. Pour de plus amples informations, veuillez consulter [Apprentissage non supervisé](algorithms-choose.md#algorithms-choose-unsupervised-learning).
Dans le cadre du clustering en k-moyennes (k-means), chaque cluster possède un centre. Lors de l'entraînement de modèle, l'algorithme des k-moyennes (k-means) utilise la distance entre le point correspondant à chaque observation dans l'ensemble de données et les centres de cluster comme base pour le clustering. Choisissez le nombre de clusters (*k*) à créer.
Par exemple, supposons que vous souhaitiez créer un modèle pour identifier les chiffres manuscrits et que vous choisissiez l'ensemble de données MNIST pour l'entraînement. L'ensemble de données fournit des milliers d'images de chiffres manuscrits (0 à 9). Dans cet exemple, vous pouvez choisir de créer 10 clusters, un pour chaque chiffre (0, 1,..., 9). Dans le cadre de l'entraînement de modèle, l'algorithme des k-moyennes regroupe les images en entrée en 10 clusters.
Chaque image de l'ensemble de données MNIST est une image de 28 x 28 pixels, avec un total de 784 pixels. Chaque image correspond à un point dans un espace à 784 dimensions, similaire à un point dans un espace 2D (x, y). Pour rechercher le cluster auquel un point appartient, l'algorithme des k-moyennes détecte la distance entre ce point et tous les centres de cluster. Il choisit ensuite le cluster ayant le centre le plus proche comme cluster auquel l'image appartient.
**Note**
Amazon SageMaker AI utilise une version personnalisée de l'algorithme dans laquelle, au lieu de spécifier que l'algorithme crée *k* clusters, vous pouvez choisir d'améliorer la précision du modèle en spécifiant des centres de clusters supplémentaires *(K = k\$1x*). Cependant, l'algorithme réduit finalement le nombre de clusters à *k*.
Dans SageMaker AI, vous spécifiez le nombre de clusters lors de la création d'un poste de formation. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Dans le corps de la demande, vous ajoutez le mappage de chaîne `HyperParameters` pour indiquer les chaînes `k` et `extra_center_factor`.
Voici un résumé du fonctionnement de k-means pour l'entraînement des modèles en SageMaker IA :
1. Il détermine les *K* centres de cluster initiaux.
**Note**
Dans les rubriques suivantes, *K* clusters fait référence à *k \$1 x*, où vous spécifiez *k* et *x* lors de la création d'une tâche d'entraînement du modèle.
1. Il répète les données d'entraînement en entrée et recalcule les centres de cluster.
1. Il réduit les clusters obtenus au nombre de *k* (si le spécialiste des données a spécifié la création de *k\$1x* clusters dans la demande).
Les sections suivantes expliquent également certains des paramètres qui peuvent être spécifiés par un spécialiste des données pour configurer une tâche d'entraînement de modèle dans le cadre du mappage de chaîne `HyperParameters`.
**Topics**
+ [Étape 1 : Déterminer les centres de cluster initiaux](#kmeans-step1)
+ [Étape 2 : Répéter le jeu de données d'entraînement et calculer les centres de cluster](#kmeans-step2)
+ [Étape 3 : Réduire le nombre de clusters de *K* à *k*](#kmeans-step3)
## Étape 1 : Déterminer les centres de cluster initiaux
Lors de l'utilisation de k-means dans l' SageMaker IA, les centres de cluster initiaux sont choisis parmi les observations d'un petit lot échantillonné de manière aléatoire. Choisissez l'une des stratégies suivantes pour déterminer la façon dont ces centres de cluster initiaux sont sélectionnés :
+ L'approche aléatoire—Choisissez aléatoirement *K* observations dans votre jeu de données d'entrée en tant que centres de cluster. Par exemple, vous pouvez choisir un centre de cluster qui pointe vers l'espace à 784 dimensions correspondant à 10 images (quelconques) dans l'ensemble de données d'entraînement MNIST.
+ L'approche de type k-moyennes\$1\$1 (k-means\$1\$1), qui fonctionne comme suit :
1. Démarrez avec un cluster et déterminez son centre. Vous sélectionnez de façon aléatoire une observation à partir de votre ensemble de données d'entraînement et vous utilisez le point correspondant à l'observation comme centre de cluster. Par exemple, dans l'ensemble de données MNIST, choisissez de façon aléatoire une image de chiffre manuscrit. Choisissez ensuite le point dans l'espace à 784 dimensions qui correspond à l'image choisie comme centre de cluster. Il s'agit du centre de cluster 1.
1. Déterminez le centre du cluster 2. Choisissez de façon aléatoire une observation dans les observations restantes de l'ensemble de données d'entraînement. Choisissez-en une qui est différente de celle que vous avez sélectionnée précédemment. Cette observation correspond à un point qui est éloigné du centre de cluster 1. En utilisant l'ensemble de données MNIST comme exemple, vous effectuez les opérations suivantes :
+ Pour chacune des images restantes, recherchez la distance entre le point correspondant et le centre de cluster 1. Mettez au carré la distance et attribuez une probabilité proportionnelle au carré de la distance. Ainsi, une image qui est différente de celle que vous avez sélectionnée précédemment possède une plus forte probabilité d'être sélectionnée comme centre de cluster 2.
+ Choisissez l'une des images de façon aléatoire, en fonction des probabilités attribuées à l'étape précédente. Le point qui correspond à l'image est le centre de cluster 2.
1. Répétez l'étape 2 pour trouver le centre de cluster 3. Cette fois, trouvez les distances entre les images restantes et le centre de cluster 2.
1. Répétez l'opération jusqu'à ce que vous ayez les centres de clusters *K*.
Pour former un modèle à l' SageMaker IA, vous créez un poste de formation. Dans la demande, vous fournissez les informations de configuration en spécifiant les mappages de chaîne `HyperParameters` suivants :
+ Pour spécifier le nombre de clusters à créer, ajoutez la chaîne `k`.
+ Pour une plus grande précision, ajoutez la chaîne facultative `extra_center_factor`.
+ Pour spécifier la stratégie à utiliser pour déterminer les centres de cluster initiaux, ajoutez la chaîne `init_method` et définissez sa valeur sur `random` ou `k-means++`.
Pour plus d'informations sur l'estimateur K-means SageMaker AI, consultez [K-means dans](https://sagemaker.readthedocs.io/en/stable/algorithms/unsupervised/kmeans.html) la documentation du SDK Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
Vous disposez maintenant d'un ensemble initial de centres de cluster.
## Étape 2 : Répéter le jeu de données d'entraînement et calculer les centres de cluster
Les centres de cluster que vous avez créés à l'étape précédente sont principalement aléatoires, mais l'ensemble de données d'entraînement rentre partiellement en compte. Au cours de cette étape, vous utilisez l'ensemble de données d'entraînement pour déplacer ces centres vers les centres de cluster réels. L'algorithme itère sur l'ensemble des données d'entraînement et recalcule les *K* centres de cluster.
1. Lisez un mini-lot d'observations (un petit sous-ensemble de tous les enregistrements choisi de façon aléatoire) à partir de l'ensemble de données d'entraînement et effectuez les opérations ci-après.
**Note**
Lors de la création d'une tâche d'entraînement de modèle, vous spécifiez la taille du lot dans la chaîne `mini_batch_size` dans le mappage de chaîne `HyperParameters`.
1. Attribuez toutes les observations du mini-lot à l'un des clusters ayant le centre de cluster le plus proche.
1. Calculez le nombre d'observations attribuées à chaque cluster. Calculez ensuite la proportion de nouveaux points attribués par cluster.
Prenons l'exemple des clusters suivants :
Cluster c1 = 100 points précédemment attribués. Vous avez ajouté 25 points provenant du mini-lot au cours de cette étape.
Cluster c2 = 150 points précédemment attribués. Vous avez ajouté 40 points provenant du mini-lot au cours de cette étape.
Cluster c3 = 450 points précédemment attribués. Vous avez ajouté 5 points provenant du mini-lot au cours de cette étape.
Calculez la proportion de nouveaux points attribués à chacun des clusters comme suit :
```
p1 = proportion of points assigned to c1 = 25/(100+25)
p2 = proportion of points assigned to c2 = 40/(150+40)
p3 = proportion of points assigned to c3 = 5/(450+5)
```
1. Calculez le centre des nouveaux points ajoutés à chaque cluster :
```
d1 = center of the new points added to cluster 1
d2 = center of the new points added to cluster 2
d3 = center of the new points added to cluster 3
```
1. Calculez la moyenne pondérée pour trouver les centres de cluster mis à jour comme suit :
```
Center of cluster 1 = ((1 - p1) * center of cluster 1) + (p1 * d1)
Center of cluster 2 = ((1 - p2) * center of cluster 2) + (p2 * d2)
Center of cluster 3 = ((1 - p3) * center of cluster 3) + (p3 * d3)
```
1. Lisez le mini-lot suivant et répétez l'étape 1 pour recalculer les centres de cluster.
1. Pour plus d'informations sur l'algorithme des *k*-moyennes par mini-lot, consultez [Clustering en k-moyennes (k-means) à l'échelle du Web](https://citeseerx.ist.psu.edu/document?repid=rep1type=pdf&doi=b452a856a3e3d4d37b1de837996aa6813bedfdcf) (langue française non garantie).
## Étape 3 : Réduire le nombre de clusters de *K* à *k*
Si l'algorithme a créé *K* clusters—*(K = k\$1x)* où *x* est supérieur à 1—, il réduit le nombre de clusters de *K* à *k*. (Pour plus d'informations, consultez `extra_center_factor` dans la discussion précédente.) Il procède en appliquant la méthode de Lloyd avec initialisation par `kmeans++` des *K* centres de cluster. Pour plus d'informations sur la méthode de Lloyd, consultez l'article sur le [clustering en k-moyennes](https://pdfs.semanticscholar.org/0074/4cb7cc9ccbbcdadbd5ff2f2fee6358427271.pdf).
# Hyperparamètres pour k-moyennes (k-means)
Dans la demande [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html), vous spécifiez l'algorithme de formation que vous voulez utiliser. Vous pouvez également spécifier des hyperparamètres spécifiques à l'algorithme sous forme de cartes. string-to-string Le tableau suivant répertorie les hyperparamètres de l'algorithme d'entraînement k-means fourni par Amazon SageMaker AI. Pour plus d'informations sur le fonctionnement du clustering à l'aide de l'algorithme des k-moyennes (k-means), consultez [Fonctionnement du clustering des données à l'aide de l'algorithme de k-moyennes (k-means)](algo-kmeans-tech-notes.md).
| Nom du paramètre | Description |
| --- | --- |
| feature\$1dim | Nombre de caractéristiques des données d'entrée. **Obligatoire** Valeurs valides : nombre entier positif |
| k | Nombre de clusters requis. **Obligatoire** Valeurs valides : nombre entier positif |
| epochs | Nombre de passages effectués sur les données d'entraînement. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1 |
| eval\$1metrics | Liste JSON des types de métriques utilisés pour présenter un score pour le modèle. Les valeurs autorisées sont `msd` pour la distance quadratique moyenne (MSD, Means Square Distance) et `ssd` pour la somme des carrés des distances (SSD, Sum of Square Distance). Si les données de test sont fournies, le score est calculé pour chacune des métriques demandées. **Facultatif** Valeurs valides : `[\"msd\"]`, `[\"ssd\"]` ou `[\"msd\",\"ssd\"]`. Valeur par défaut : `[\"msd\"]` |
| extra\$1center\$1factor | L'algorithme crée K centres = `num_clusters` \$1 `extra_center_factor` lorsqu'il s'exécute et réduit le nombre de centres de K à `k` lors de la finalisation du modèle. **Facultatif** Valeurs valides : nombre entier positif ou `auto`. Valeur par défaut : `auto` |
| half\$1life\$1time\$1size | Permet de déterminer le poids accordé à une observation lors du calcul d'une moyenne de cluster. Ce poids décroit de façon exponentielle au fur et à mesure que de plus en plus de points sont observés. Lorsqu'un point est observé pour la première fois, il se voit attribuer un poids 1 lors du calcul de la moyenne du cluster. La constante decay de la fonction exponentielle decay est choisie afin que son poids soit 1/2 après l'observation des points `half_life_time_size`. S'il est défini sur 0, il n'y a pas de diminution. **Facultatif** Valeurs valides : entier non négatif Valeur par défaut : 0 |
| init\$1method | Méthode par laquelle l'algorithme choisit les centres de cluster initiaux. L'approche standard des k-moyennes les choisit de façon aléatoire. Une autre méthode, k-moyennes\$1\$1 (k-means\$1\$1), sélectionne le premier centre de cluster de façon aléatoire. Ensuite, elle répartit la position des clusters initiaux restants en pondérant la sélection des centres avec une distribution de probabilité proportionnelle au carré de la distance des points de données restants des centres existants. **Facultatif** Valeurs valides : `random` ou `kmeans++`. Valeur par défaut : `random` |
| local\$1lloyd\$1init\$1method | Méthode d'initialisation de la procédure espérance-maximisation (EM) de Lloyd utilisée pour créer le modèle final contenant `k` centres. **Facultatif** Valeurs valides : `random` ou `kmeans++`. Valeur par défaut : `kmeans++` |
| local\$1lloyd\$1max\$1iter | Nombre maximal d'itérations de la procédure espérance-maximisation (EM) de Lloyd utilisée pour créer le modèle final contenant `k` centres. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 300 |
| local\$1lloyd\$1num\$1trials | Nombre de fois où la procédure espérance-maximisation (EM) avec la moindre perte est exécutée lors de la création du modèle final contenant `k` centres. **Facultatif** Valeurs valides : nombre entier positif ou `auto`. Valeur par défaut : `auto` |
| local\$1lloyd\$1tol | Tolérance de modification dans la fonction perte pour un arrêt anticipé de la procédure espérance-maximisation (EM) de Lloyd utilisée lors de la création du modèle final contenant `k` centres. **Facultatif** Valeurs valides : float. Plage [0, 1]. Valeur par défaut : 0.0001 |
| mini\$1batch\$1size | Nombre d'observations par mini-lot pour l'itérateur de données. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 5000 |
# Régler un modèle de k-moyennes
Le *réglage de modèle automatique*, ou réglage d'hyperparamètre, détecte la meilleure version d'un modèle en exécutant plusieurs tâches qui testent une plage d'hyperparamètres sur votre jeu de données. Vous choisissez les hyperparamètres réglables, une plage de valeurs pour chacun d'eux et une métrique d'objectif. Vous choisissez la métrique d'objectif parmi les métriques que calcule l'algorithme. Le réglage de modèle automatique recherche parmi les hyperparamètres choisis la combinaison de valeurs qui produira un modèle permettant d'optimiser la métrique d'objectif.
L'algorithme SageMaker k-means d'Amazon AI est un algorithme non supervisé qui regroupe les données en clusters dont les membres sont aussi similaires que possible. Comme il est non supervisé, l'algorithme n'utilise pas de jeu de données de validation par rapport auquel les hyperparamètres puissent être optimisés. En revanche, il accepte bel et bien un jeu de données de test et émet les métriques qui dépendent du carré de la distance entre les points de données et les centroïdes de cluster définitifs au terme de chaque exécution de l'entraînement. Pour rechercher le modèle qui contient les clusters les plus serrés sur le jeu de données de test, vous pouvez utiliser une tâche de réglage des hyperparamètres. Les clusters optimisent la similarité de leurs membres.
Pour plus d'informations sur le réglage de modèle, consultez [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md).
## Métriques calculées par l'algorithme des k-moyennes
L'algorithme des k-moyennes calcule les métriques suivantes pendant l'entraînement. Lors du réglage d'un modèle, choisissez l'une de ces métriques comme métrique d'objectif.
| Nom de la métrique | Description | Orientation de l'optimisation |
| --- | --- | --- |
| test:msd | Distances quadratiques moyennes entre chaque enregistrement du jeu de test et le centre le plus proche du modèle. | Réduire |
| test:ssd | Somme des carrés des distances entre chaque enregistrement du jeu de test et le centre le plus proche du modèle. | Réduire |
## Hyper-paramètres des k-moyennes réglables
Réglez le modèle SageMaker k-means d'Amazon AI avec les hyperparamètres suivants. Les hyperparamètres qui ont le plus fort impact sur les métriques d'objectif des k-moyennes sont : `mini_batch_size`, `extra_center_factor` et `init_method`. Le réglage de l'hyperparamètre `epochs` se traduit généralement par des améliorations mineures.
| Nom du paramètre | Type de paramètre | Plages recommandées |
| --- | --- | --- |
| epochs | IntegerParameterRanges | MinValue: 1 h 10 MaxValue |
| extra\$1center\$1factor | IntegerParameterRanges | MinValue: 4 h 10 MaxValue |
| init\$1method | CategoricalParameterRanges | ['kmeans\$1\$1', 'random'] |
| mini\$1batch\$1size | IntegerParameterRanges | MinValue: 3000, :15 000 MaxValue |
# Formats de réponse des k-moyennes
Tous les algorithmes intégrés à l' SageMaker IA respectent le format d'inférence d'entrée commun décrit dans [Common Data Formats - Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html). Cette rubrique contient une liste des formats de sortie disponibles pour l'algorithme SageMaker AI k-means.
## Format de réponse JSON
```
{
"predictions": [
{
"closest_cluster": 1.0,
"distance_to_cluster": 3.0,
},
{
"closest_cluster": 2.0,
"distance_to_cluster": 5.0,
},
....
]
}
```
## Format de réponse JSONLINES
```
{"closest_cluster": 1.0, "distance_to_cluster": 3.0}
{"closest_cluster": 2.0, "distance_to_cluster": 5.0}
```
## Format de réponse RECORDIO
```
[
Record = {
features = {},
label = {
'closest_cluster': {
keys: [],
values: [1.0, 2.0] # float32
},
'distance_to_cluster': {
keys: [],
values: [3.0, 5.0] # float32
},
}
}
]
```
## Format de réponse CSV
La première valeur de chaque ligne correspond à `closest_cluster`.
La deuxième valeur de chaque ligne correspond à `distance_to_cluster`.
```
1.0,3.0
2.0,5.0
```