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.
# Paramètres des algorithmes intégrés
Le tableau suivant répertorie les paramètres de chacun des algorithmes fournis par Amazon SageMaker AI.
| Nom de l'algorithme | Nom du canal | Mode d'entrée de l'entraînement | Type de fichier | Classe d’instance | Parallélisable |
| --- | --- | --- | --- | --- | --- |
| AutoGluon-Tabulaire | entraînement et (éventuellement) validation | Fichier | CSV | UC ou GPU (instance individuelle uniquement) | Non |
| BlazingText | train | Fichier ou Tube | Fichier texte (une phrase par ligne avec des jetons séparés par des espaces) | UC ou GPU (instance individuelle uniquement) | Non |
| CatBoost | entraînement et (éventuellement) validation | Fichier | CSV | CPU (une seule instance uniquement) | Non |
| DeepAR Forecasting | train et (facultativement) test | Fichier | JSON Lines ou Parquet | CPU ou GPU | Oui |
| Machines de factorisation | train et (facultativement) test | Fichier ou Tube | recordIO-protobuf | CPU (GPU pour les données denses) | Oui |
| Classification des images - MXNet | train et validation, (facultativement) train\$1lst, validation\$1lst et model | Fichier ou Tube | recordIO ou fichiers d'image (.jpg ou .png) | GPU | Oui |
| Classification des images - TensorFlow | entraînement et validation | Fichier | fichiers image (.jpg, .jpeg ou .png) | CPU ou GPU | Oui (uniquement sur plusieurs instances GPUs sur une seule instance) |
| IP Insights | train et (facultativement) validation | Fichier | CSV | CPU ou GPU | Oui |
| K-Means | train et (facultativement) test | Fichier ou Tube | recordIO-protobuf ou CSV | CPU ou GPUCommon (un seul périphérique GPU sur une ou plusieurs instances) | Non |
| K-Nearest-Neighbors (K-NN) | train et (facultativement) test | Fichier ou Tube | recordIO-protobuf ou CSV | UC ou GPU (un seul appareil GPU sur une ou plusieurs instances) | Oui |
| LDA | train et (facultativement) test | Fichier ou Tube | recordIO-protobuf ou CSV | CPU (une seule instance uniquement) | Non |
| LightGBM | train et (éventuellement) validation | Fichier | CSV | CPU | Oui |
| Linear Learner | train et (facultativement) validation, test, ou les deux | Fichier ou Tube | recordIO-protobuf ou CSV | CPU ou GPU | Oui |
| Neural Topic Model (NTM) | train et (facultativement) validation, test, ou les deux | Fichier ou Tube | recordIO-protobuf ou CSV | CPU ou GPU | Oui |
| Object2Vec | train et (facultativement) validation, test, ou les deux | Fichier | JSON Lines | UC ou GPU (instance individuelle uniquement) | Non |
| Détection d'objets - MXNet | train et validation, (facultativement) train\$1annotation, validation\$1annotation et model | Fichier ou Tube | recordIO ou fichiers d'image (.jpg ou .png) | GPU | Oui |
| Détection d'objets - TensorFlow | entraînement et validation | Fichier | fichiers image (.jpg, .jpeg ou .png) | GPU | Oui (uniquement sur plusieurs instances GPUs sur une seule instance) |
| PCA | train et (facultativement) test | Fichier ou Tube | recordIO-protobuf ou CSV | CPU ou GPU | Oui |
| Random Cut Forest | train et (facultativement) test | Fichier ou Tube | recordIO-protobuf ou CSV | CPU | Oui |
| Semantic Segmentation | train et validation, train\$1annotation, validation\$1annotation et (facultativement) label\$1map et model | Fichier ou Tube | Fichiers image | GPU (une seule instance uniquement) | Non |
| Modélisation Seq2Seq | train, validation et vocab | Fichier | recordIO-protobuf | GPU (une seule instance uniquement) | Non |
| TabTransformer | entraînement et (éventuellement) validation | Fichier | CSV | UC ou GPU (instance individuelle uniquement) | Non |
| Classification du texte - TensorFlow | entraînement et validation | Fichier | CSV | CPU ou GPU | Oui (uniquement sur plusieurs instances GPUs sur une seule instance) |
| XGBoost (0,90-1, 0,90-2, 1,0-1, 1,2-1, 1,2-21) | train et (facultativement) validation | Fichier ou Tube | CSV, LibSVM ou Parquet | Processeur (ou GPU pour 1.2-1) | Oui |
Les algorithmes qui sont *parallélisables* peuvent être déployés sur plusieurs instances de calcul pour l'entraînement distribué.
Les rubriques suivantes fournissent des informations sur les formats de données, les types d'instances Amazon EC2 recommandés et les CloudWatch journaux communs à tous les algorithmes intégrés fournis par Amazon SageMaker AI.
**Note**
Pour consulter l'image Docker URIs des algorithmes intégrés gérés par l' SageMaker IA, voir [Chemins de registre Docker et exemple](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths) de code.
**Topics**
+ [Formats de données courants pour l'entraînement](cdf-training.md)
+ [Formats de données courants pour l’inférence](cdf-inference.md)
+ [Types d'instances pour les algorithmes intégrés](cmn-info-instance-types.md)
+ [Journaux pour les algorithmes intégrés](common-info-all-sagemaker-models-logs.md)
# Formats de données courants pour l'entraînement
Pour préparer la formation, vous pouvez prétraiter vos données à l'aide de divers AWS services, notamment Amazon EMR AWS Glue, Amazon Redshift, Amazon Relational Database Service et Amazon Athena. Après le prétraitement, publiez les données dans un compartiment Amazon S3. Pour l’entraînement, les données doivent passer par une série de conversions et de transformations, notamment :
+ Sérialisation des données d'entraînement (géré par vous)
+ Désérialisation des données d'entraînement (géré par l'algorithme)
+ Sérialisation du modèle d'entraînement (géré par l'algorithme)
+ Désérialisation du modèle entraîné (facultatif, géré par vous)
Lorsque vous utilisez Amazon SageMaker AI dans la partie apprentissage de l'algorithme, assurez-vous de télécharger toutes les données en une seule fois. Si des données supplémentaires sont ajoutées à cet emplacement, un nouvel appel d'entraînement doit être effectué pour construire un nouveau modèle.
**Topics**
+ [Types de contenu pris en charge par les algorithmes intégrés](#cdf-common-content-types)
+ [Avec le mode Pipe](#cdf-pipe-mode)
+ [Avec le format CSV](#cdf-csv-format)
+ [Avec le format RecordIO](#cdf-recordio-format)
+ [Désérialisation du modèle entraîné](#td-deserialization)
## Types de contenu pris en charge par les algorithmes intégrés
Le tableau suivant répertorie quelques-unes des valeurs [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) et les algorithmes qui les utilisent :
ContentTypes pour les algorithmes intégrés
| ContentType | Algorithm |
| --- | --- |
| application/x-image | Algorithme Object Detection, Semantic Segmentation |
| application/x-recordio | Algorithme de détection d'objets |
| demande/ x-recordio-protobuf | Machines de factorisation, K-Means, K-nn, allocation latente de Dirichlet, Linear Learner, NTM, PCA, RCF, Sequence-to-Sequence |
| application/jsonlines | BlazingText, DeePar |
| image/jpeg | Algorithme Object Detection, Semantic Segmentation |
| image/png | Algorithme Object Detection, Semantic Segmentation |
| text/csv | IP Insights, K-Means, K-nn, allocation latente de Dirichlet, Linear Learner, NTM, PCA, RCF, XGBoost |
| text/libsvm | XGBoost |
Pour obtenir un résumé des paramètres pris en charge par chaque algorithme, reportez-vous à la documentation de chaque algorithme ou à ce [tableau](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html).
## Avec le mode Pipe
Dans le *mode Pipe (Tube)*, votre tâche d'entraînement transmet des données directement à partir d'Amazon Simple Storage Service (Amazon S3). Le streaming peut offrir des temps de démarrage plus rapides pour les tâches d'entraînement et un meilleur débit. Ceci est en contraste avec le *mode File (Fichier)*, dans lequel vos données d'Amazon S3 sont stockées sur les volumes d'instance d'entraînement. Le mode File utilise l'espace disque pour stocker vos artefacts de modèles finaux et votre jeu de données d'entraînement complet. En diffusant vos données directement depuis Amazon S3 en mode Pipe, vous réduisez la taille des volumes Amazon Elastic Block Store de vos instances d'entraînement. En mode Pipe, l'espace disque doit être suffisant pour stocker votre artefact de modèle final. Consultez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html) pour plus de détails sur le mode d'entrée de formation.
## Avec le format CSV
De nombreux algorithmes Amazon SageMaker AI prennent en charge l'entraînement avec des données au format CSV. Afin d'utiliser des données au format CSV pour l'entraînement, dans la spécification de canal de données d'entrée, spécifiez **text/csv** comme [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType). Amazon SageMaker AI exige qu'un fichier CSV ne comporte pas d'enregistrement d'en-tête et que la variable cible se trouve dans la première colonne. Pour exécuter les algorithmes d'apprentissage non supervisés qui n'ont pas de cible, spécifiez le numéro des colonnes d'étiquette dans le type de contenu. Par exemple, dans ce cas **'content\$1type=text/csv;label\$1size=0'**. Pour plus d'informations, consultez [Utiliser désormais le mode Pipe avec des ensembles de données CSV pour un apprentissage plus rapide sur les algorithmes intégrés d'Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/now-use-pipe-mode-with-csv-datasets-for-faster-training-on-amazon-sagemaker-built-in-algorithms/).
## Avec le format RecordIO
Au format protobuf Recordio, SageMaker AI convertit chaque observation de l'ensemble de données en une représentation binaire sous la forme d'un ensemble de flottants de 4 octets, puis la charge dans le champ des valeurs protobuf. Si vous utilisez Python pour préparer les données, nous vous recommandons vivement d'utiliser ces transformations existantes. Toutefois, si vous utilisez une autre langue, le fichier de définition de protobuf ci-dessous fournit le schéma que vous utilisez pour convertir vos données au format SageMaker AI protobuf.
**Note**
Pour obtenir un exemple illustrant la façon de convertir le tableau numPy couramment utilisé au format recordIO protobuf, consultez l'article relatif à *[présentation des machines de factorisation avec MNIST](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html)*.
```
syntax = "proto2";
package aialgs.data;
option java_package = "com.amazonaws.aialgorithms.proto";
option java_outer_classname = "RecordProtos";
// A sparse or dense rank-R tensor that stores data as doubles (float64).
message Float32Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated float values = 1 [packed = true];
// If key is not empty, the vector is treated as sparse, with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For example, if shape = [ 10, 20 ], floor(keys[i] / 20) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// A sparse or dense rank-R tensor that stores data as doubles (float64).
message Float64Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated double values = 1 [packed = true];
// If this is not empty, the vector is treated as sparse, with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For example, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// A sparse or dense rank-R tensor that stores data as 32-bit ints (int32).
message Int32Tensor {
// Each value in the vector. If keys is empty, this is treated as a
// dense vector.
repeated int32 values = 1 [packed = true];
// If this is not empty, the vector is treated as sparse with
// each key specifying the location of the value in the sparse vector.
repeated uint64 keys = 2 [packed = true];
// An optional shape that allows the vector to represent a matrix.
// For Exmple, if shape = [ 10, 20 ], floor(keys[i] / 10) gives the row,
// and keys[i] % 20 gives the column.
// This also supports n-dimensonal tensors.
// Note: If the tensor is sparse, you must specify this value.
repeated uint64 shape = 3 [packed = true];
}
// Support for storing binary data for parsing in other ways (such as JPEG/etc).
// This is an example of another type of value and may not immediately be supported.
message Bytes {
repeated bytes value = 1;
// If the content type of the data is known, stores it.
// This allows for the possibility of using decoders for common formats
// in the future.
optional string content_type = 2;
}
message Value {
oneof value {
// The numbering assumes the possible use of:
// - float16, float128
// - int8, int16, int32
Float32Tensor float32_tensor = 2;
Float64Tensor float64_tensor = 3;
Int32Tensor int32_tensor = 7;
Bytes bytes = 9;
}
}
message Record {
// Map from the name of the feature to the value.
//
// For vectors and libsvm-like datasets,
// a single feature with the name `values`
// should be specified.
map features = 1;
// An optional set of labels for this record.
// Similar to the features field above, the key used for
// generic scalar / vector labels should be 'values'.
map label = 2;
// A unique identifier for this record in the dataset.
//
// Whilst not necessary, this allows better
// debugging where there are data issues.
//
// This is not used by the algorithm directly.
optional string uid = 3;
// Textual metadata describing the record.
//
// This may include JSON-serialized information
// about the source of the record.
//
// This is not used by the algorithm directly.
optional string metadata = 4;
// An optional serialized JSON object that allows per-record
// hyper-parameters/configuration/other information to be set.
//
// The meaning/interpretation of this field is defined by
// the algorithm author and may not be supported.
//
// This is used to pass additional inference configuration
// when batch inference is used (e.g. types of scores to return).
optional string configuration = 5;
}
```
Après avoir créé le tampon du protocole, stockez-le dans un emplacement Amazon S3 auquel Amazon SageMaker AI peut accéder et qui peut être transmis `InputDataConfig` en tant que partie intégrante`create_training_job`.
**Note**
Pour tous les algorithmes Amazon SageMaker AI, `ChannelName` l'entrée `InputDataConfig` doit être définie sur`train`. Certains algorithmes prennent également en charge des paramètres `input channels` de validation ou de test. Ils servent généralement à évaluer les performances du modèle en utilisant un jeu de données d'exclusion. Les jeux de données d'exclusion ne sont pas utilisés dans l'entraînement initial, mais ils peuvent être utilisés pour ajuster le modèle.
## Désérialisation du modèle entraîné
Les modèles Amazon SageMaker AI sont stockés sous la forme model.tar.gz dans le compartiment S3 spécifié dans le `OutputDataConfig` `S3OutputPath` paramètre de l'`create_training_job`appel. Le compartiment S3 doit se trouver dans la même AWS région que l'instance du bloc-notes. Vous pouvez spécifier la plupart de ces artefacts de modèle lors de la création d'un modèle d'hébergement. Vous pouvez également les ouvrir et les consulter dans l'instance de bloc-notes. Lorsqu'il n'`model.tar.gz`est pas goudronné, il contient `model_algo-1` un objet Apache sérialisé. MXNet Par exemple, vous utilisez la formule suivante pour charger le modèle des k-moyennes (k-means) en mémoire et l'afficher :
```
import mxnet as mx
print(mx.ndarray.load('model_algo-1'))
```
# Formats de données courants pour l’inférence
Les algorithmes Amazon SageMaker AI acceptent et produisent différents types MIME pour les charges utiles HTTP utilisées pour récupérer les prédictions en ligne et par mini-lots. Vous pouvez utiliser plusieurs AWS services pour transformer ou prétraiter des enregistrements avant d'exécuter l'inférence. Au minimum, vous devez convertir les données pour les éléments suivants :
+ Sérialisation de demandes d’inférence (gérée par vous)
+ Désérialisation de demandes d’inférence (gérée par l’algorithme)
+ Sérialisation de réponses d’inférence (gérée par l’algorithme)
+ Désérialisation de réponses d’inférence (gérée par vous)
**Topics**
+ [Conversion des données pour la sérialisation de demandes d’inférence](#ir-serialization)
+ [Conversion des données pour la désérialisation de demandes d’inférence](#ir-deserialization)
+ [Formats de demande courants pour les algorithmes](#common-in-formats)
+ [Utilisation de la transformation par lots avec les algorithmes intégrés](#cm-batch)
## Conversion des données pour la sérialisation de demandes d’inférence
Les options de type de contenu pour les demandes d'inférence d'algorithmes Amazon SageMaker AI incluent : `text/csv``application/json`, et`application/x-recordio-protobuf`. Les algorithmes qui ne prennent pas en charge tous ces types peuvent en prendre en charge d'autres types. XGBoost, par exemple, uniquement les supports `text/csv` de cette liste, mais également les supports`text/libsvm`.
Pour `text/csv`, la valeur de l'argument Body envoyé à `invoke_endpoint` doit être une chaîne avec des virgules entre les valeurs pour chaque fonction. Par exemple, un enregistrement pour un modèle ayant quatre fonctions peut ressembler à `1.5,16.0,14,23.0`. Les transformations effectuées sur les données d'entraînement doivent également être exécutées sur les données avant d'obtenir l'inférence. L'ordre des fonctions est pris en compte et doit rester inchangé.
`application/json` est plus flexible et offre plusieurs formats possibles pouvant être utilisés par les développeurs dans leurs applications. À un niveau élevé, dans JavaScript, la charge utile peut ressembler à ce qui suit :
```
let request = {
// Instances might contain multiple rows that predictions are sought for.
"instances": [
{
// Request and algorithm specific inference parameters.
"configuration": {},
// Data in the specific format required by the algorithm.
"data": {
"": dataElement
}
}
]
}
```
Vous avez les possibilités suivantes pour spécifier l'élément `dataElement` :
**Équivalent des Protocol Buffers**
```
// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
"keys": [],
"values": [],
"shape": []
}
```
**Vecteur numérique simple**
```
// An array containing numeric values is treated as an instance containing a
// single dense vector.
let dataElement = [1.5, 16.0, 14.0, 23.0]
// It will be converted to the following representation by the SDK.
let converted = {
"features": {
"values": dataElement
}
}
```
**Pour plusieurs enregistrements**
```
let request = {
"instances": [
// First instance.
{
"features": [ 1.5, 16.0, 14.0, 23.0 ]
},
// Second instance.
{
"features": [ -2.0, 100.2, 15.2, 9.2 ]
}
]
}
```
## Conversion des données pour la désérialisation de demandes d’inférence
Les algorithmes Amazon SageMaker AI renvoient du JSON dans plusieurs mises en page. À un haut niveau, la structure est la suivante :
```
let response = {
"predictions": [{
// Fields in the response object are defined on a per algorithm-basis.
}]
}
```
Les champs inclus dans les prédictions diffèrent d'un algorithme à l'autre. Voici des exemples de sorties pour l'algorithme des k-moyennes (k-means).
**Inférence à enregistrement unique**
```
let response = {
"predictions": [{
"closest_cluster": 5,
"distance_to_cluster": 36.5
}]
}
```
**Inférence à enregistrements multiples**
```
let response = {
"predictions": [
// First instance prediction.
{
"closest_cluster": 5,
"distance_to_cluster": 36.5
},
// Second instance prediction.
{
"closest_cluster": 2,
"distance_to_cluster": 90.3
}
]
}
```
**Inférence à enregistrements multiples avec entrée protobuf**
```
{
"features": [],
"label": {
"closest_cluster": {
"values": [ 5.0 ] // e.g. the closest centroid/cluster was 1.0
},
"distance_to_cluster": {
"values": [ 36.5 ]
}
},
"uid": "abc123",
"metadata": "{ "created_at": '2017-06-03' }"
}
```
SageMaker Les algorithmes d'intelligence artificielle prennent également en charge le format JSONLINES, où le contenu de réponse par enregistrement est le même que celui du format JSON. La structure à plusieurs enregistrements est une collection d’objets de réponse par enregistrement séparés par des caractères de saut de ligne. Le contenu de réponse de l' KMeans algorithme intégré pour 2 points de données d'entrée est le suivant :
```
{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}
```
Pendant l'exécution de la transformation par lots, nous recommandons d'utiliser la réponse du type `jsonlines` en définissant le champ `Accept` dans `CreateTransformJobRequest` sur `application/jsonlines`.
## Formats de demande courants pour les algorithmes
La plupart des algorithmes utilisent un grand nombre des formats de demande d’inférence suivants.
### Format de demande JSON
**Type de contenu :** application/JSON
**Format dense**
```
let request = {
"instances": [
{
"features": [1.5, 16.0, 14.0, 23.0]
}
]
}
let request = {
"instances": [
{
"data": {
"features": {
"values": [ 1.5, 16.0, 14.0, 23.0]
}
}
}
]
}
```
**Format clairsemé**
```
{
"instances": [
{"data": {"features": {
"keys": [26, 182, 232, 243, 431],
"shape": [2000],
"values": [1, 1, 1, 4, 1]
}
}
},
{"data": {"features": {
"keys": [0, 182, 232, 243, 431],
"shape": [2000],
"values": [13, 1, 1, 4, 1]
}
}
},
]
}
```
### Format de demande JSONLINES
**Type de contenu :** application/JSONLINES
**Format dense**
Un seul enregistrement au format dense peut être représenté comme suit :
```
{ "features": [1.5, 16.0, 14.0, 23.0] }
```
ou :
```
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
```
**Format clairsemé**
Un seul enregistrement au format fragmenté est représenté comme suit :
```
{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }
```
Plusieurs enregistrements sont représentés sous la forme d’une collection de représentations à un seul enregistrement, séparées par des caractères de saut de ligne :
```
{"data": {"features": { "keys": [0, 1, 3], "shape": [4], "values": [1, 4, 1] } } }
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
{ "features": [1.5, 16.0, 14.0, 23.0] }
```
### Format de demande CSV
**Type de contenu :** text/CSV; label\$1size=0
**Note**
La prise en charge du format CSV n'est pas disponible pour l'algorithme Factorization Machines.
### Format de demande RECORDIO
Type de contenu : application/ x-recordio-protobuf
## Utilisation de la transformation par lots avec les algorithmes intégrés
Lors de l'exécution de la transformation par lots, nous recommandons d'utiliser les réponses du type JSONLINES plutôt que JSON, si l'algorithme les prend en charge. Pour ce faire, définissez le champ `Accept` dans `CreateTransformJobRequest` sur `application/jsonlines`.
Lorsque vous créez une tâche de transformation, `SplitType` doit être défini en fonction du `ContentType` des données d’entrée. De même, selon le champ `Accept` dans `CreateTransformJobRequest`, `AssembleWith` doit être défini en conséquence. Utilisez le tableau suivant pour définir ces champs :
| ContentType | Recommandé SplitType |
| --- | --- |
| application/x-recordio-protobuf | RecordIO |
| text/csv | Line |
| application/jsonlines | Line |
| application/json | None |
| application/x-image | None |
| image/\$1 | None |
| Accept | Recommandé AssembleWith |
| --- | --- |
| application/x-recordio-protobuf | None |
| application/json | None |
| application/jsonlines | Line |
Pour plus d'informations sur les formats de réponse pour les algorithmes spécifiques, consultez les éléments suivants :
+ [Formats d'inférence DeepAR](deepar-in-formats.md)
+ [Formats de réponse Factorization Machines](fm-in-formats.md)
+ [Formats de données d'inférence IP Insights](ip-insights-inference-data-formats.md)
+ [Formats de réponse des k-moyennes](km-in-formats.md)
+ [Formats de demande et de réponse k-NN](kNN-inference-formats.md)
+ [Formats de réponse d'apprentissage linéaire](LL-in-formats.md)
+ [Formats de la réponse NTM](ntm-in-formats.md)
+ [Format de données pour l'inférence d'Object2Vec](object2vec-inference-formats.md)
+ [Intégrations de l'encodeur pour Object2Vec](object2vec-encoder-embeddings.md)
+ [Formats de la réponse PCA](PCA-in-formats.md)
+ [Formats de la réponse RCF](rcf-in-formats.md)
# Types d'instances pour les algorithmes intégrés
La plupart des algorithmes Amazon SageMaker AI ont été conçus pour tirer parti du calcul par GPU à des fins d'entraînement. Malgré des coûts par instance plus élevés, GPUs entraînez-vous plus rapidement, ce qui les rend plus rentables. Les exceptions sont notées dans ce guide.
Pour découvrir les instances EC2 prises en charge, consultez le [détail des instances](https://aws.amazon.com/sagemaker-ai/pricing/#Instance_details).
La taille et le type des données peuvent jouer un rôle important dans la détermination de la configuration du matériel qui est la plus efficace. Lorsqu'un même modèle est entraîné de façon répétée, un test initial sur un éventail de types d'instances peut permettre de découvrir des configurations qui sont plus économiques à long terme. De plus, les algorithmes qui s'entraînent le plus efficacement GPUs peuvent ne pas nécessiter GPUs d'inférence efficace. Faites des tests pour déterminer quelle est la solution la plus rentable. Pour obtenir une recommandation d'instance automatique ou effectuer des tests de charge personnalisés, utilisez [Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html).
Pour plus d'informations sur les spécifications matérielles de l' SageMaker IA, consultez la [tarification d'Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).
**UltraServers**
UltraServers connectez plusieurs instances Amazon EC2 à l'aide d'une interconnexion accélératrice à faible latence et à bande passante élevée. Ils sont conçus pour gérer des AI/ML charges de travail à grande échelle nécessitant une puissance de traitement importante. Pour de plus amples informations, veuillez consulter [Amazon EC2 UltraServers](https://aws.amazon.com/ec2/ultraservers/). Pour commencer UltraServers, consultez la section [Réserver des plans de formation pour vos tâches ou HyperPod clusters de formation](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html).
Pour commencer à utiliser UltraServers Amazon SageMaker AI, [créez un plan de formation](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html). Une fois que le vôtre UltraServer est disponible dans le plan de formation, créez un poste de formation avec l' AWS Management Console API Amazon SageMaker AI, ou AWS CLI. N'oubliez pas de spécifier le type d' UltraServer instance que vous avez acheté dans le plan de formation.
An UltraServer peut exécuter une ou plusieurs tâches à la fois. UltraServers regroupe les instances, ce qui vous donne une certaine flexibilité quant à la manière d'allouer vos UltraServer capacités au sein de votre organisation. Lorsque vous configurez vos tâches, tenez également compte des directives de sécurité des données de votre organisation, car les instances d'une tâche UltraServer peuvent accéder aux données d'une autre tâche dans une autre instance de la même entreprise UltraServer.
Si vous rencontrez des défaillances matérielles dans le UltraServer, l' SageMaker IA essaie automatiquement de résoudre le problème. Au fur et à mesure que l' SageMaker IA enquête et résout le problème, vous pouvez recevoir des notifications et des actions par le biais d' AWS Health événements ou AWS Support.
Une fois votre tâche de formation terminée, l' SageMaker IA arrête les instances, mais elles restent disponibles dans votre plan de formation si celui-ci est toujours actif. Pour maintenir une instance en UltraServer cours d'exécution après la fin d'une tâche, vous pouvez utiliser des [pools de chaleur gérés](https://docs.aws.amazon.com/sagemaker/latest/dg/train-warm-pools.html).
Si la capacité de votre plan de formation est suffisante, vous pouvez même exécuter plusieurs tâches de formation UltraServers. Par défaut, chacune UltraServer est fournie avec 18 instances, dont 17 instances et une instance de rechange. Si vous avez besoin de plus d'instances, vous devez en acheter davantage UltraServers. Lorsque vous créez une tâche de formation, vous pouvez configurer la manière dont les tâches sont réparties à UltraServers l'aide du `InstancePlacementConfig` paramètre.
Si vous ne configurez pas le placement, l' SageMaker IA alloue automatiquement les emplois aux instances de votre. UltraServer Cette stratégie par défaut est basée sur le meilleur effort qui donne la priorité au remplissage de toutes les instances en une seule UltraServer avant d'en utiliser une autre. UltraServer Par exemple, si vous demandez 14 instances et que vous en avez 2 UltraServers dans votre plan de formation, SageMaker AI utilise toutes les instances de la première UltraServer. Si vous avez demandé 20 instances et que vous UltraServers en avez 2 dans votre plan de formation, SageMaker AI utilisera les 17 instances dans la première, UltraServer puis en utilisera 3 dans la seconde UltraServer. Les instances au sein d'un UltraServer même NVLink appareil servent à communiquer, mais les individus UltraServers utilisent Elastic Fabric Adapter (EFA), ce qui peut affecter les performances d'entraînement des modèles.
# Journaux pour les algorithmes intégrés
Les algorithmes Amazon SageMaker AI produisent des CloudWatch journaux Amazon, qui fournissent des informations détaillées sur le processus de formation. Pour afficher les journaux, dans la console de AWS gestion **CloudWatch**, choisissez **Logs**, puis choisissez le **groupe/aws/sagemaker/TrainingJobslog**. Chaque tâche d'entraînement a un flux de journaux par nœud sur lequel elle a été entraînée. Le nom du flux de journaux commence par la valeur spécifiée dans le paramètre `TrainingJobName` lors de la création de la tâche.
**Note**
Si une tâche échoue et que les journaux n'apparaissent pas CloudWatch, il est probable qu'une erreur se soit produite avant le début de la formation. Parmi les raisons pouvant expliquer cette erreur, on peut citer la spécification de la mauvaise image d'entraînement ou du mauvais emplacement S3.
Le contenu des journaux varie selon les algorithmes. Cependant, vous pouvez généralement y trouver les informations suivantes :
+ Confirmation des arguments fournis au début du journal
+ Erreurs qui se sont produites au cours de l'entraînement
+ Mesure des performances numériques ou de la précision d'un algorithme
+ Horodatages de l'algorithme et principales étapes au sein de l'algorithme
## Erreurs courantes
Si une tâche d'entraînement échoue, certains détails sur l'échec sont fournis par la valeur `FailureReason` renvoyée dans la description de la tâche d'entraînement, comme suit :
```
sage = boto3.client('sagemaker')
sage.describe_training_job(TrainingJobName=job_name)['FailureReason']
```
D'autres ne sont signalés que dans les CloudWatch journaux. Les erreurs courantes sont les suivantes :
1. Spécification erronée d'un hyperparamètre ou spécification d'un hyperparamètre qui n'est pas valide pour l'algorithme.
**À partir du CloudWatch journal**
```
[10/16/2017 23:45:17 ERROR 139623806805824 train.py:48]
Additional properties are not allowed (u'mini_batch_siz' was
unexpected)
```
1. Spécification d'une valeur non valide pour un hyperparamètre
**FailureReason**
```
AlgorithmError: u'abc' is not valid under any of the given
schemas\n\nFailed validating u'oneOf' in
schema[u'properties'][u'feature_dim']:\n {u'oneOf':
[{u'pattern': u'^([1-9][0-9]*)$', u'type': u'string'},\n
{u'minimum': 1, u'type': u'integer'}]}\
```
**FailureReason**
```
[10/16/2017 23:57:17 ERROR 140373086025536 train.py:48] u'abc'
is not valid under any of the given schemas
```
1. Format de fichier protobuf inapproprié
**À partir du CloudWatch journal**
```
[10/17/2017 18:01:04 ERROR 140234860816192 train.py:48] cannot
copy sequence with size 785 to array axis with dimension 784
```