Formats de données courants pour l'entraînement

Pour préparer l'entraînement, vous pouvez prétraiter vos données à l'aide de différents services AWS, y compris AWS Glue, Amazon EMR, 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, en particulier :

• 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 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.

Types de contenu pris en charge par les algorithmes intégrés

Le tableau suivant répertorie quelques-unes des valeurs 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	Factorization Machines, K-Means, k-NN, Latent Dirichlet Allocation, 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, Latent Dirichlet Allocation, 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.

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 AlgorithmSpecification pour plus de détails sur le mode d'entrée de formation.

Avec le format CSV

De nombreux SageMaker algorithmes Amazon 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 ContentType. Amazon SageMaker 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_type=text/csv;label_size=0'. Pour obtenir un exemple de bloc-notes utilisant le format CSV, consultez Breast Cancer Prediction. 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 SageMaker intégrés d'Amazon.

Avec le format RecordIO

Au format protobuf Recordio, SageMaker convertit chaque observation de l'ensemble de données en une représentation binaire sous la forme d'un ensemble de valeurs flottantes 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 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.

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<string, Value> 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<string, Value> 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 peut accéder et qui peut être transmis InputDataConfig en tant que partie intégrantecreate_training_job.

Note

Pour tous les SageMaker algorithmes Amazon, ChannelName l'entrée InputDataConfig doit être définie surtrain. 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 SageMaker modèles Amazon 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_jobappel. Le compartiment S3 doit se trouver dans la même région AWS que l'instance de 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. Lorsque model.tar.gz est décompressé, il contient model_algo-1, qui est un objet sérialisé Apache 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'))