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 k-NN (K-Nearest Neighbors, k plus proches voisins) L'algorithme SageMaker k-nearest neighbors (k-NN) d'Amazon AI est un algorithme basé sur un index. Il utilise une méthode non paramétrique pour la classification ou la régression. Pour les problèmes de classification, l'algorithme interroge les *k* points qui sont les plus proches de l'exemple de point et renvoie l'étiquette la plus fréquemment utilisée de leur classe comme étiquette prédite. Pour les problèmes de régression, l'algorithme interroge les *k* points les plus proches de l'exemple de point et renvoie la moyenne de leurs valeurs de caractéristique comme valeur prédite. L'apprentissage avec l'algorithme k-NN possède trois étapes : l'échantillonnage, la réduction de dimension et la création d'index. L'échantillonnage réduit la taille du jeu de données initial afin qu'il puisse entrer en mémoire. Pour la réduction de dimension, l'algorithme diminue la dimension de caractéristique des données afin de réduire l'empreinte du modèle k-NN en mémoire et la latence de l'inférence. Nous fournissons deux méthodes de réduction des dimensions : méthode par projection aléatoire et méthode FJLT (Fast Johnson-Lindenstrauss Transform). En général, vous utilisez une réduction de dimension pour les jeux de données à dimension élevée (d > 1000) afin d'éviter la « malédiction de dimension » qui perturbe l'analyse statistique des données, lesquelles deviennent de plus en plus clairsemées au fur et à mesure que les dimensions augmentent. L'objectif principal de l'apprentissage de l'algorithme k-NN est de construire l'index. L'index permet les recherches efficaces de distances entre les points dont les valeurs ou les étiquettes de classe n'ont pas encore été déterminées et les k points les plus proches à utiliser pour l'inférence. **Topics** + [Interface d'entrée/sortie pour l'algorithme k-NN](#kNN-input_output) + [Exemples de blocs-notes k-NN](#kNN-sample-notebooks) + [Fonctionnement de l'algorithme k-NN](kNN_how-it-works.md) + [Recommandation d'instance EC2 pour l'algorithme k-NN](#kNN-instances) + [Hyperparamètres k-NN](kNN_hyperparameters.md) + [Régler un modèle k-NN](kNN-tuning.md) + [Formats de données pour les entrées de formation k-NN](kNN-in-formats.md) + [Formats de demande et de réponse k-NN](kNN-inference-formats.md) ## Interface d'entrée/sortie pour l'algorithme k-NN SageMaker AI K-nn prend en charge les canaux de données de train et de test. + Utilisez un *canal formation (train)* pour les données que vous souhaitez échantillonner et construire dans l'index k-NN. + Utilisez un *canal test* pour émettre les scores dans les fichiers journaux. Les scores sont répertoriés sous la forme d'une ligne par mini-lot : précision pour `classifier`, erreur quadratique moyenne (mse, mean-squared error) pour `regressor` pour le score Pour les entrées d'apprentissage, k-NN prend en charge les formats de données `text/csv` et `application/x-recordio-protobuf`. Pour le type d'entrée `text/csv`, les premières colonnes `label_size` sont interprétées comme vecteur d'étiquette de cette ligne. 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 les entrées d'inférence, k-NN prend en charge les formats de données `application/json`, `application/x-recordio-protobuf` et `text/csv`. Le format `text/csv` accepte un champ `label_size` et un paramètre d'encodage. Il suppose un champ `label_size` égal à 0 et un encodage UTF-8. Pour les sorties d'inférence, k-NN prend en charge les formats de données `application/json` et `application/x-recordio-protobuf`. Ces deux formats de données prennent également en charge un mode de sortie détaillé. En mode de sortie détaillé, l'API fournit les résultats de recherche avec le vecteur des distances triées de la plus petite à la plus grande, et les éléments correspondants dans le vecteur des étiquettes. Pour la transformation par lots, l'algorithme k-NN prend en charge le format de données `application/jsonlines` aussi bien pour l'entrée que pour la sortie. Voici un exemple d'entrée : ``` content-type: application/jsonlines {"features": [1.5, 16.0, 14.0, 23.0]} {"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}} ``` Voici un exemple de sortie : ``` accept: application/jsonlines {"predicted_label": 0.0} {"predicted_label": 2.0} ``` Pour plus d'informations sur les formats de fichier en entrée et en sortie, consultez [Formats de données pour les entrées de formation k-NN](kNN-in-formats.md) pour l'apprentissage, [Formats de demande et de réponse k-NN](kNN-inference-formats.md) pour l'inférence, ainsi que la rubrique [Exemples de blocs-notes k-NN](#kNN-sample-notebooks). ## Exemples de blocs-notes k-NN Pour un exemple de carnet utilisant l'algorithme SageMaker AI K-Nearest Neighbor pour prédire les types de couverture sauvage à partir des données géologiques et du service forestier, voir le [K-Nearest Neighbor](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html) Covertype. Utilisez une instance de bloc-notes Jupyter pour exécuter l'exemple dans SageMaker AI. Pour savoir comment créer et ouvrir une instance de bloc-notes Jupyter 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 blocs-notes d'exemples d' SageMaker IA. Recherchez les blocs-notes K-Nearest Neighbor dans la section **Introduction aux algorithmes Amazon**. Pour ouvrir un bloc-notes, cliquez sur son onglet **Use (Utiliser)** et sélectionnez **Create copy (Créer une copie)**. # Fonctionnement de l'algorithme k-NN L'algorithme k-nearest neighbors (k-NN) d'Amazon SageMaker AI suit un processus d'apprentissage en plusieurs étapes qui inclut l'échantillonnage des données d'entrée, la réduction des dimensions et la création d'un index. Les données indexées sont ensuite utilisées lors de l’inférence pour trouver efficacement les k-NN les plus proches pour un point de données donné et faire des prédictions basées sur les étiquettes ou les valeurs voisines. ## Étape 1 : Exemple Pour spécifier le nombre total de points de données à échantillonner à partir du jeu de données d'apprentissage, utilisez le paramètre `sample_size`. Par exemple, si le jeu de données initial comporte 1 000 points de données, que `sample_size` a la valeur 100 et que le nombre total d'instances est 2, chaque travail équivaut à 50 points. Un jeu total de 100 points de données sera collecté. L'échantillonnage s'exécute en temps linéaire en ce qui concerne le nombre de points de données. ## Étape 2 : Exécution de la réduction de dimension L'implémentation actuelle de l'algorithme k-NN possède deux méthodes de réduction de dimension. Vous spécifiez la méthode dans l'hyperparamètre `dimension_reduction_type`. La méthode `sign` spécifie une projection aléatoire, qui utilise une projection linéaire à l'aide d'une matrice de signes aléatoire ; la méthode `fjlt` spécifie une méthode FJLT (Fast Johnson-Lindenstrauss Transform), basée sur la transformation de Fourier. Les deux méthodes conservent les distances L2 et produit interne. La méthode `fjlt` doit être utilisée lorsque la dimension cible est élevée et qu'elle offre de meilleures performances avec l'inférence CPU. Les méthodes diffèrent en termes de complexité de calcul. La méthode `sign` nécessite un temps O(ndk) pour réduire la dimension d'un lot de n points de dimension d en une dimension cible k. La méthode `fjlt` nécessite un temps O(nd log(d)), mais les constantes impliquées sont plus grandes. L'utilisation de la réduction de dimension introduit du bruit dans les données et celui-ci peut réduire la précision des prédictions. ## Étape 3 : Créer un index Au cours de l'inférence, l'algorithme interroge l'indice k-nearest-neighbors d'un point d'échantillonnage. En fonction des références aux points, l'algorithme effectue une prédiction de classification ou de régression. Il base la prédiction sur les étiquettes de classe ou valeurs fournies. L'algorithme k-NN fournit trois différents types d'index : un index plat, un index inversé et un index inversé avec quantification du produit. Vous spécifiez le type avec le paramètre `index_type`. ## Sérialiser le modèle Lorsque l'algorithme k-NN a terminé l'apprentissage, il sérialise trois fichiers à préparer pour l'inférence. + model\$1algo 1 : contient l'index sérialisé pour le calcul des plus proches voisins. + model\$1algo-1.labels : contient les étiquettes sérialisées (format binaire np.float32) pour le calcul de l'étiquette prédite en fonction du résultat de la requête à partir de l'index. + model\$1algo-1.json : contient les métadonnées du modèle au format JSON qui stocke les hyperparamètres `k` et `predictor_type` de l'apprentissage pour l'inférence, ainsi que les autres états pertinents. Avec l'implémentation actuelle de k-NN, vous pouvez modifier le fichier des métadonnées pour changer la façon dont les prédictions sont calculées. Par exemple, vous pouvez modifier `k` en 10 ou modifier `predictor_type` en *regressor*. ``` { "k": 5, "predictor_type": "classifier", "dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20}, "normalize": False, "version": "1.0" } ``` ## Recommandation d'instance EC2 pour l'algorithme k-NN Nous vous recommandons d'effectuer l'entraînement sur une instance de CPU (telle que ml.m5.2xlarge) ou sur une instance de GPU. L'algorithme k-NN prend en charge les familles d'instances de GPU P2, P3, G4dn et G5 pour l'entraînement et l'inférence. Les demandes d'inférence ont CPUs généralement une latence moyenne inférieure à celle des demandes provenant de, GPUs car les communications sont soumises à une taxe sur les CPU-to-GPU communications lorsque vous utilisez du matériel GPU. Cependant, ils ont GPUs généralement un débit plus élevé pour les lots plus importants. # Hyperparamètres k-NN Le tableau suivant répertorie les hyperparamètres que vous pouvez définir pour l'algorithme k-nearest neighbors (k-NN) d'Amazon SageMaker AI. | Nom du paramètre | Description | | --- | --- | | feature\$1dim | Nombre de caractéristiques des données d'entrée. **Obligatoire** Valeurs valides : nombre entier positif. | | k | Le nombre de plus proches voisins. **Obligatoire** Valeurs valides : nombre entier positif | | predictor\$1type | Type d'inférence à utiliser sur les étiquettes de données. **Obligatoire** Valeurs valides : *classifier (classificateur)* pour la classification ou *regressor (régresseur)* pour la régression. | | sample\$1size | Nombre de points de données à échantillonner à partir du jeu de données de l'apprentissage. **Obligatoire** Valeurs valides : nombre entier positif | | dimension\$1reduction\$1target | Dimension cible de la réduction. **Obligatoire** lorsque vous spécifiez le paramètre `dimension_reduction_type`. Valeurs valides : nombre entier positif supérieur à 0 et inférieur à `feature_dim`. | | dimension\$1reduction\$1type | Type de la méthode de réduction de dimension. **Facultatif** Valeurs valides : *sign* pour la projection aléatoire ou *fjlt* pour FJLT (Fast Lindenstrauss-Johnson Transform). Valeur par défaut : Pas de réduction de dimension | | faiss\$1index\$1ivf\$1nlists | *Le nombre de centroïdes à intégrer dans l'index lorsqu'il `index_type` est défaillant. IVFFlat*ou *Faiss.ivFPQ*. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : *auto*, qui se résout en `sqrt(sample_size)`. | | faiss\$1index\$1pq\$1m | Nombre de sous-composants de vecteurs à construire dans l'index lorsque `index_type` a la valeur *faiss.IVFPQ*. La bibliothèque FaceBook AI Similarity Search (FAISS) nécessite que la valeur de `faiss_index_pq_m` soit un diviseur de la dimension des données. Si `faiss_index_pq_m` n'est pas un diviseur de la dimension de données, nous augmentons la dimension de données au plus petit nombre entier divisible par `faiss_index_pq_m`. Si aucune réduction de dimension ne s'applique, l'algorithme complète à l'aide de zéros. Si la réduction de dimension s'applique, l'algorithme augmente la valeur de l'hyperparamètre `dimension_reduction_target`. **Facultatif** Valeurs valides : l'un des nombres entiers positifs suivants : 1, 2, 3, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 96 | | index\$1metric | Métrique permettant de mesurer la distance entre les points lors de la recherche des plus proches voisins. Lorsque la formation a lieu avec `index_type` défini sur `faiss.IVFPQ`, la distance `INNER_PRODUCT` et la similarité `COSINE` ne sont pas prises en charge. **Facultatif** Valeurs valides : *L2* pour la distance euclidienne, *INNER\$1PRODUCT* pour la distance produit interne et *COSINE* pour la similarité de cosinus. Valeur par défaut : *L2* | | index\$1type | Type d'index. **Facultatif** *Valeurs valides : *Faiss.flat*, faiss. IVFFlat*, *Faiss.IVFPQ*. Valeurs par défaut : *faiss.Flat* | | 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 k-NN L'algorithme SageMaker k-nearest neighbors d'Amazon AI est un algorithme supervisé. L'algorithme utilise un jeu de données de test et émet une métrique sur la précision d'une tâche de classification ou sur l'erreur quadratique moyenne d'une tâche de régression. Ces métriques de précision comparent les prédictions du modèle pour leur tâche respective à la vérité du terrain fournie par les données de test empiriques. Pour trouver le meilleur modèle qui rapporte la plus haute précision ou la plus faible erreur sur le jeu de données de test, exécutez une tâche de réglage des hyperparamètres pour k-NN. 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 appropriée pour la tâche de prédiction de 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. Les hyperparamètres sont utilisés uniquement pour vous aider à estimer les paramètres du modèle et ne sont pas utilisés par le modèle formé pour effectuer des prédictions. 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 k-NN L'algorithme des k-NN calcule l'une des deux métriques du tableau suivant au cours de l'apprentissage en fonction du type de tâche spécifié par l'hyperparamètre `predictor_type`. + *classifier (classificateur)* spécifie une tâche de classification et calcule `test:accuracy` + *regressor (régresseur)* spécifie une tâche de régression et calcule `test:mse`. Choisissez pour `predictor_type` une valeur appropriée au type de tâche effectué pour calculer la métrique d'objectif pertinente lors du réglage d'un modèle. | Nom de la métrique | Description | Orientation de l'optimisation | | --- | --- | --- | | test:accuracy | Lorsque `predictor_type` est défini sur *classifier*, l'algorithme k-NN compare l'étiquette prédite, en fonction de la moyenne des étiquettes des k-NN, à l'étiquette de la vérité sur le terrain fournie dans les données du canal de test. La précision signalée est comprise entre 0,0 (0 %) et 1,0 (100 %). | Agrandir | | test:mse | Lorsque `predictor_type` est défini sur *regressor*, l'algorithme k-NN compare l'étiquette prédite, en fonction de la moyenne des étiquettes des k-NN, à l'étiquette de la vérité sur le terrain fournie dans les données du canal de test. L'erreur quadratique moyenne est calculée en comparant les deux étiquettes. | Réduire | ## Hyperparamètres k-NN réglables Réglez le modèle du voisin le plus proche d'Amazon SageMaker AI avec les hyperparamètres suivants. | Nom du paramètre | Type de paramètre | Plages recommandées | | --- | --- | --- | | k | IntegerParameterRanges | MinValue: 1, MaxValue 1024 | | sample\$1size | IntegerParameterRanges | MinValue: 256, MaxValue 20000000 | # Formats de données pour les entrées de formation k-NN Tous les algorithmes intégrés d'Amazon SageMaker AI respectent les formats d'entraînement de saisie courants décrits dans [Common Data Formats - Training](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html). Cette rubrique contient une liste des formats d'entrée disponibles pour l' k-nearest-neighboralgorithme d' SageMaker intelligence artificielle. ## Format de données CSV content-type: text/csv; label\$1size=1 ``` 4,1.2,1.3,9.6,20.3 ``` Les premières colonnes `label_size` sont interprétées comme vecteur d'étiquette de la ligne. ## Format de données RECORDIO type de contenu : application/ x-recordio-protobuf ``` [ Record = { features = { 'values': { values: [1.2, 1.3, 9.6, 20.3] # float32 } }, label = { 'values': { values: [4] # float32 } } } ] } ``` # Formats de demande et de réponse k-NN Tous les algorithmes intégrés d'Amazon SageMaker AI 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' k-nearest-neighboralgorithme SageMaker AI. ## ENTRÉE : format de demande CSV content-type: text/csv ``` 1.2,1.3,9.6,20.3 ``` Accepte un `label_size` ou un paramètre d'encodage. Il suppose un champ `label_size` égal à 0 et un encodage UTF-8. ## ENTRÉE : format de demande JSON content-type: application/json ``` { "instances": [ {"data": {"features": {"values": [-3, -1, -4, 2]}}}, {"features": [3.0, 0.1, 0.04, 0.002]}] } ``` ## ENTRÉE : format de demande JSONLINES content-type: application/jsonlines ``` {"features": [1.5, 16.0, 14.0, 23.0]} {"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}} ``` ## ENTRÉE : format de demande RECORDIO type de contenu : application/ x-recordio-protobuf ``` [ Record = { features = { 'values': { values: [-3, -1, -4, 2] # float32 } }, label = {} }, Record = { features = { 'values': { values: [3.0, 0.1, 0.04, 0.002] # float32 } }, label = {} }, ] ``` ## SORTIE : format de réponse JSON accept: application/json ``` { "predictions": [ {"predicted_label": 0.0}, {"predicted_label": 2.0} ] } ``` ## SORTIE : format de réponse JSONLINES accept: application/jsonlines ``` {"predicted_label": 0.0} {"predicted_label": 2.0} ``` ## SORTIE : format de réponse VERBOSE JSON En mode détaillé, l'API fournit les résultats de recherche avec le vecteur des distances triées de la plus petite à la plus grande, et les éléments correspondants dans le vecteur des étiquettes. Dans cet exemple, k a la valeur 3. accept: application/json; verbose=true ``` { "predictions": [ { "predicted_label": 0.0, "distances": [3.11792408, 3.89746071, 6.32548437], "labels": [0.0, 1.0, 0.0] }, { "predicted_label": 2.0, "distances": [1.08470316, 3.04917915, 5.25393973], "labels": [2.0, 2.0, 0.0] } ] } ``` ## SORTIE : format de réponse RECORDIO-PROTOBUF type de contenu : application/ x-recordio-protobuf ``` [ Record = { features = {}, label = { 'predicted_label': { values: [0.0] # float32 } } }, Record = { features = {}, label = { 'predicted_label': { values: [2.0] # float32 } } } ] ``` ## SORTIE : format de réponse VERBOSE RECORDIO-PROTOBUF En mode détaillé, l'API fournit les résultats de recherche avec le vecteur des distances triées de la plus petite à la plus grande, et les éléments correspondants dans le vecteur des étiquettes. Dans cet exemple, k a la valeur 3. accepter : application/ x-recordio-protobuf ; verbose=true ``` [ Record = { features = {}, label = { 'predicted_label': { values: [0.0] # float32 }, 'distances': { values: [3.11792408, 3.89746071, 6.32548437] # float32 }, 'labels': { values: [0.0, 1.0, 0.0] # float32 } } }, Record = { features = {}, label = { 'predicted_label': { values: [0.0] # float32 }, 'distances': { values: [1.08470316, 3.04917915, 5.25393973] # float32 }, 'labels': { values: [2.0, 2.0, 0.0] # float32 } } } ] ``` ## EXEMPLE DE SORTIE pour l'algorithme k-NN Pour les tâches regressor : ``` [06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334) ``` Pour les tâches classifier : ``` [06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669) ```