Formatos de dados comuns para treinamento

Para se preparar para o treinamento, você pode pré-processar seus dados usando uma variedade de AWS serviços, incluindo Amazon AWS Glue, Amazon RedshiftEMR, Amazon Relational Database Service e Amazon Athena. Após o pré-processamento, publique os dados em um bucket do Amazon S3. Para o treinamento, os dados devem passar por uma série de conversões e transformações, incluindo:

• Serialização dos dados de treinamento (processada por você)

• Desserialização dos dados de treinamento (processada pelo algoritmo)

• Desserialização do modelo de treinamento (processada pelo algoritmo)

• Desserialização do modelo treinado (opcional, processada por você)

Ao usar a Amazon SageMaker na parte de treinamento do algoritmo, certifique-se de fazer o upload de todos os dados de uma só vez. Se mais dados forem adicionados a esse local, uma nova chamada de treinamento será necessária para construir um novo modelo.

Tipos de conteúdo compatíveis com algoritmos integrados

A tabela a seguir lista alguns dos ContentTypevalores comumente aceitos e os algoritmos que os usam:

ContentTypes para algoritmos integrados

ContentType	Algoritmo
application/x-image	Algoritmo de detecção de objetos, segmentação semântica
aplicativo/x-recordio	Algoritmo de Detecção de objetos
aplicação/ x-recordio-protobuf	Máquinas de fatoração, K-Means, k-NN, alocação latente de Dirichlet, Linear Learner,,,, Sequence to Sequence NTM PCA RCF
application/jsonlines	BlazingText, DeepAR
image/jpeg	Algoritmo de detecção de objetos, segmentação semântica
image/png	Algoritmo de detecção de objetos, segmentação semântica
text/csv	IP Insights, K-Means, k-NN, alocação de Dirichlet latente, Linear Learner,,,, NTM PCA RCF XGBoost
text/libsvm	XGBoost

Para obter um resumo dos parâmetros usados por cada algoritmo, consulte a documentação dos algoritmos individuais ou esta tabela.

Usando o modo Pipe

No modo Pipe, seu trabalho de treinamento transmite dados diretamente do Amazon Simple Storage Service (Amazon S3). O streaming pode proporcionar tempos de inicialização mais rápidos para trabalhos de treinamento e um melhor throughput. Isso contrasta com o modo Arquivo, no qual seus dados do Amazon S3 são armazenados nos volumes da instância de treinamento. O modo de Arquivo usa de espaço em disco para armazenar tanto os artefatos de modelo finais quanto o conjunto completo de dados de treinamento. Ao transmitir seus dados diretamente do Amazon S3 no modo Pipe, você reduz o tamanho dos volumes do Amazon Elastic Block Store de suas instâncias de treinamento. O modo de Pipe precisa apenas de espaço em disco suficiente para armazenar seus artefatos de modelo finais. Consulte a AlgorithmSpecification para obter detalhes adicionais sobre o modo de entrada de treinamento.

Usando o CSV formato

Muitos SageMaker algoritmos da Amazon oferecem suporte ao treinamento com dados em CSV formato. Para usar dados em CSV formato para treinamento, na especificação do canal de dados de entrada, especifique text/csv como ContentTypeo. A Amazon SageMaker exige que um CSV arquivo não tenha um registro de cabeçalho e que a variável de destino esteja na primeira coluna. Para executar algoritmos de aprendizagem não supervisionada que não tenham um destino, especifique o número de colunas de rótulo no tipo de conteúdo. Por exemplo, neste caso, 'content_type=text/csv;label_size=0'. Para obter mais informações, consulte Agora use o modo Pipe com CSV conjuntos de dados para um treinamento mais rápido nos algoritmos SageMaker integrados da Amazon.

Usando o formato RecordIO

No formato protobuf Recordio, SageMaker converte cada observação no conjunto de dados em uma representação binária como um conjunto de floats de 4 bytes e a carrega no campo de valores do protobuf. Se você estiver usando o Python para preparação de dados, é altamente recomendável usar essas transformações existentes. No entanto, se você estiver usando outra linguagem, o arquivo de definição protobuf abaixo fornecerá o esquema que você usa para converter seus dados no SageMaker formato protobuf.

nota

Para ver um exemplo que mostra como converter a numPy matriz comumente usada no formato protobuf ReCordio, consulte Uma introdução às máquinas de fatoração com. 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;
 }

Depois de criar o buffer de protocolo, armazene-o em um local do Amazon S3 que a SageMaker Amazon possa acessar e que possa ser passado como parte do InputDataConfig login. create_training_job

nota

Para todos os SageMaker algoritmos da Amazon, o ChannelName in InputDataConfig deve ser definido comotrain. Alguns algoritmos também oferecem suporte para input channels de validação ou teste. Eles são normalmente usados para avaliar o desempenho do modelo usando um conjunto de dados de manutenção. Conjuntos de dados de manutenção não são usados no treinamento inicial, mas podem ser usados para ajustar ainda mais o modelo.

Desserialização do modelo treinado

SageMaker Os modelos da Amazon são armazenados como model.tar.gz no bucket do S3 especificado no OutputDataConfig S3OutputPath parâmetro da create_training_job chamada. O bucket do S3 deve estar na mesma AWS região da instância do notebook. Você pode especificar a maioria desses artefatos de modelo ao criar um modelo de hospedagem. Também é possível abrir e revisá-los na sua instância de bloco de anotações. Quando não model.tar.gz está marcado, ele contémmodel_algo-1, que é um objeto Apache serializado. MXNet Por exemplo, veja a seguir como carregar e visualizar o modelo k-means na memória:

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