Formatos de datos comunes para la capacitación

Para prepararse para la formación, puede preprocesar sus datos mediante diversos AWS servicios, como Amazon EMR AWS Glue, Amazon Redshift, Amazon Relational Database Service y Amazon Athena. Después del preprocesamiento, publique los datos en un bucket de Amazon S3. Para el entrenamiento, los datos deben pasar por una serie de conversiones y transformaciones, que incluyen:

• Serialización de datos de capacitación (gestionados por usted)

• Deserialización de datos de capacitación (gestionados por el algoritmo)

• Serialización del modelo de capacitación (gestionado por el algoritmo)

• Deserialización del modelo de capacitación (opcional, gestionado por usted)

Cuando utilices Amazon SageMaker en la parte de entrenamiento del algoritmo, asegúrate de cargar todos los datos a la vez. Si se agregan más datos a esa ubicación, es necesario realizar una nueva llamada de capacitación para crear una modelo nuevo.

Tipos de contenido compatibles con algoritmos integrados

En la siguiente tabla, se enumeran algunos de los valores ContentType admitidos habitualmente y los algoritmos que los utilizan:

ContentTypes para algoritmos integrados
ContentType	Algoritmo
application/x-image	Algoritmo de detección de objetos, segmentación semántica
application/x-recordio	Algoritmo de detección de objetos
application/x-recordio-protobuf	Máquinas de factorización, K-Means, k-NN, Latent Dirichlet Allocation, aprendizaje lineal, NTM, PCA, RCF, Sequence-to-Sequence
application/jsonlines	BlazingText, DeepAR
image/jpeg	Algoritmo de detección de objetos, segmentación semántica
image/png	Algoritmo de detección de objetos, segmentación semántica
text/csv	IP Insights, K-Means, k-NN, Latent Dirichlet Allocation, aprendizaje lineal, NTM, PCA, RCF, XGBoost
text/libsvm	XGBoost

Para obtener un resumen de los formatos de datos admitidos por cada algoritmo, consulte la documentación para los algoritmos individuales o esta tabla.

Uso del modo canalización

En el modo canalización, su trabajo de entrenamiento transmite datos directamente desde Amazon Simple Storage Service (Amazon S3). La transmisión en streaming puede proporcionar un tiempo de inicio más rápido para trabajos de capacitación y un mejor rendimiento. Esto contrasta con el modo archivo, en el que los datos de Amazon S3 se almacenan en los volúmenes de las instancias de entrenamiento. El modo de archivo usa espacio en disco para almacenar tanto sus artefactos de modelo finales como su conjunto de datos de entrenamiento completo. Al transmitir sus datos directamente desde Amazon S3 en modo canalización, reduce el tamaño de los volúmenes de Amazon Elastic Block Store de sus instancias de entrenamiento. El modo de canalización solo necesita suficiente espacio en disco para almacenar sus artefactos de modelo final. Consulte AlgorithmSpecification para obtener información detallada sobre el modo de entrada de capacitación.

Uso del formato CSV

Muchos SageMaker algoritmos de Amazon admiten el entrenamiento con datos en formato CSV. Para usar datos en formato CSV para el entrenamiento, en la especificación del canal de datos de entrada, establezca text/csv en ContentType. Amazon SageMaker exige que un archivo CSV no tenga un registro de cabecera y que la variable de destino esté en la primera columna. Para ejecutar algoritmos de aprendizaje sin supervisión sin un destino, especifique el número de columnas de etiquetas en el tipo de contenido. Por ejemplo, en este caso 'content_type=text/csv;label_size=0'. Para obtener más información, consulta Cómo usar el modo Pipe con conjuntos de datos CSV para aprender más rápido los algoritmos SageMaker integrados de Amazon.

Uso del formato RecordIO

En el formato Recordio de protobuf, SageMaker convierte cada observación del conjunto de datos en una representación binaria como un conjunto de flotantes de 4 bytes y, a continuación, la carga en el campo de valores de protobuf. Si usa Python para la preparación de sus datos, recomendamos encarecidamente que use estas transformaciones existentes. Sin embargo, si utiliza otro idioma, el siguiente archivo de definición de protobuf proporciona el esquema que se utiliza para convertir los datos al formato protobuf. SageMaker

nota

Si desea ver un ejemplo que muestra cómo convertir la matriz numPy, comúnmente usada, al formato protobuf recordIO, consulte An Introduction to Factorization Machines with 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;
 }

Tras crear el búfer de protocolo, guárdelo en una ubicación de Amazon S3 a la que Amazon SageMaker pueda acceder y que pueda transferirse como parte InputDataConfig de ellacreate_training_job.

nota

Para todos los SageMaker algoritmos de Amazon, ChannelName la InputDataConfig entrada debe estar configurada entrain. Algunos algoritmos también son compatibles con una validación o prueba input channels. Estos suelen usarse para evaluar el rendimiento del modelo mediante un conjunto de datos de exclusiones. Los conjuntos de datos de exclusiones no se usan en la capacitación inicial, pero se pueden usar para ajustar el modelo aún más.

Deserialización del modelo de capacitación

SageMaker Los modelos de Amazon se almacenan como model.tar.gz en el bucket S3 especificado en el OutputDataConfig S3OutputPath parámetro de la create_training_job llamada. El bucket de S3 debe estar en la misma AWS región que la instancia del portátil. Puede especificar la mayoría de estos artefactos de modelo cal crear un modelo de alojamiento. También puede abrirlos y revisarlos en su instancia de bloc de notas. Cuando model.tar.gz no está comprimido en un archivo tar, contiene model_algo-1, que es un objeto de Apache MXNet serializado. Por ejemplo, utilice la siguiente operación para cargar el modelo k-means en la memoria y verlo:

import mxnet as mx
print(mx.ndarray.load('model_algo-1'))