Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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 tienen que pasar por una serie de conversiones y transformaciones, entre las que se incluyen:

Cuando utilices Amazon SageMaker AI 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

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 algoritmos de Amazon SageMaker AI 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 AI requiere que un archivo CSV no tenga un registro de encabezado 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 con los algoritmos integrados de Amazon SageMaker AI.

Uso del formato RecordIO

En el formato Recordio de protobuf, la SageMaker IA 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 utiliza para convertir los datos al formato protobuf de AI. SageMaker

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 pueda acceder Amazon SageMaker AI y que pueda transferirse como parte InputDataConfig de ellacreate_training_job.

Deserialización del modelo de capacitación

Los modelos de Amazon SageMaker AI 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. Si no model.tar.gz está registrado, contienemodel_algo-1, que es un objeto Apache serializado. MXNet 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'))