As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Parâmetros para algoritmos integrados
A tabela a seguir lista os parâmetros para cada um dos algoritmos fornecidos pela Amazon SageMaker AI.
| Nome do algoritmo | Nome do canal | Modo de entrada do treinamento | Tipo de arquivo | Classe de instância | Paralelizável |
| --- | --- | --- | --- | --- | --- |
| AutoGluon-Tabular | treinamento e (opcionalmente) validação | Arquivo | CSV | CPU ou GPU (somente instância única) | Não |
| BlazingText | treinamento | Arquivo ou Pipe | Arquivo de texto (uma frase por linha com tokens separados por espaço) | CPU ou GPU (somente instância única) | Não |
| CatBoost | treinamento e (opcionalmente) validação | Arquivo | CSV | CPU (somente instância única) | Não |
| Previsão DeepAR | treinamento e (opcionalmente) teste | Arquivo | linhas JSON ou Parquet | CPU ou GPU | Sim |
| Máquinas de fatoração | treinamento e (opcionalmente) teste | Arquivo ou Pipe | recordIO-protobuf | CPU (GPU para dados densos) | Sim |
| Classificação de imagens - MXNet | treinamento e validação, (opcionalmente) train\$1lst, validation\$1lst e model | Arquivo ou Pipe | recordIO ou arquivos de imagem (.jpg ou .png) | GPU | Sim |
| Classificação de imagens - TensorFlow | treinamento e validação | Arquivo | arquivos de imagem (.jpg, .jpeg ou .png) | CPU ou GPU | Sim (somente em vários GPUs em uma única instância) |
| IP Insights | treinamento e (opcionalmente) validação | Arquivo | CSV | CPU ou GPU | Sim |
| K-Means | treinamento e (opcionalmente) teste | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU ou GPUCommon (dispositivo de GPU único em uma ou mais instâncias) | Não |
| K-Nearest-Neighbors (K-nn) | treinamento e (opcionalmente) teste | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU ou GPU (dispositivo de GPU única em uma ou mais instâncias) | Sim |
| LDA | treinamento e (opcionalmente) teste | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU (somente instância única) | Não |
| LightGBM | treino/treinamento e (opcionalmente) validação | Arquivo | CSV | CPU | Sim |
| Aprendizagem linear | treinamento e (opcionalmente) validação, teste ou ambos | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU ou GPU | Sim |
| Modelo de tópico neural | treinamento e (opcionalmente) validação, teste ou ambos | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU ou GPU | Sim |
| Object2Vec | treinamento e (opcionalmente) validação, teste ou ambos | Arquivo | Linhas JSON | CPU ou GPU (somente instância única) | Não |
| Detecção de objetos - MXNet | treinamento e validação, (opcionalmente) train\$1annotation, validation\$1annotation e model | Arquivo ou Pipe | recordIO ou arquivos de imagem (.jpg ou .png) | GPU | Sim |
| Detecção de objetos - TensorFlow | treinamento e validação | Arquivo | arquivos de imagem (.jpg, .jpeg ou .png) | GPU | Sim (somente em vários GPUs em uma única instância) |
| PCA | treinamento e (opcionalmente) teste | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU ou GPU | Sim |
| Random Cut Forest | treinamento e (opcionalmente) teste | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU | Sim |
| Segmentação semântica | treinamento e validação, train\$1annotation, validation\$1annotation e (opcionalmente) label\$1map e model | Arquivo ou Pipe | Arquivos de imagem | GPU (somente instância única) | Não |
| Modelagem Seq2Seq | treinamento, validação e vocabulário | Arquivo | recordIO-protobuf | GPU (somente instância única) | Não |
| TabTransformer | treinamento e (opcionalmente) validação | Arquivo | CSV | CPU ou GPU (somente instância única) | Não |
| Classificação de texto - TensorFlow | treinamento e validação | Arquivo | CSV | CPU ou GPU | Sim (somente em vários GPUs em uma única instância) |
| XGBoost (0,90-1, 0,90-2, 1,0-1, 1,2-1, 1,2-21) | treinamento e (opcionalmente) validação | Arquivo ou Pipe | CSV, LibSVM ou Parquet | CPU (ou GPU para 1.2-1) | Sim |
Algoritmos que são *paralelizáveis* podem ser implantados em várias instâncias de computação para treinamento distribuído.
Os tópicos a seguir fornecem informações sobre formatos de dados, tipos de instância recomendados do Amazon EC2 e CloudWatch registros comuns a todos os algoritmos integrados fornecidos pela Amazon SageMaker AI.
**nota**
Para consultar a imagem Docker URIs dos algoritmos integrados gerenciados pela SageMaker IA, consulte [Docker Registry Paths and Example](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths) Code.
**Topics**
+ [Formatos de dados comuns para treinamento](cdf-training.md)
+ [Formatos de dados comuns para inferência](cdf-inference.md)
+ [Tipos de instância para algoritmos internos](cmn-info-instance-types.md)
+ [Logs para algoritmos integrados](common-info-all-sagemaker-models-logs.md)
# 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 EMR AWS Glue, Amazon Redshift, Amazon Relational Database Service e Amazon Athena. Após o pré-processamento, publique os dados em um bucket do Amazon S3. Para treinamento, os dados precisam 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 o Amazon SageMaker AI 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.
**Topics**
+ [Tipos de conteúdo compatíveis com algoritmos integrados](#cdf-common-content-types)
+ [Usando o modo Pipe](#cdf-pipe-mode)
+ [Usando o formato CSV](#cdf-csv-format)
+ [Usando o formato RecordIO](#cdf-recordio-format)
+ [Desserialização do modelo treinado](#td-deserialization)
## Tipos de conteúdo compatíveis com algoritmos integrados
A seguinte tabela lista alguns dos valores de [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) 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 |
| application/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, NTM, PCA, RCF, Sequence-to-Sequence |
| 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 latente de Dirichlet, 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](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html).
## 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 espaço em disco para armazenar tanto os artefatos de modelo finais quanto o conjunto de dados de treinamento completo. 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 [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html) para obter detalhes adicionais sobre o modo de entrada de treinamento.
## Usando o formato CSV
Muitos algoritmos de SageMaker IA da Amazon oferecem suporte ao treinamento com dados no formato CSV. Para usar dados no formato CSV para treinamento, na especificação do canal de dados de entrada, especifique **text/csv** como o [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). O Amazon SageMaker AI exige que um arquivo CSV não tenha um registro de cabeçalho e que a variável de destino esteja na primeira coluna. Para executar algoritmos de aprendizado não supervisionado 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\$1type=text/csv;label\$1size=0'**. Para obter mais informações, consulte [Agora use o modo Pipe com conjuntos de dados CSV para um treinamento mais rápido nos algoritmos integrados de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/now-use-pipe-mode-with-csv-datasets-for-faster-training-on-amazon-sagemaker-built-in-algorithms/).
## Usando o formato RecordIO
No formato protobuf Recordio, o SageMaker AI converte cada observação no conjunto de dados em uma representação binária como um conjunto de floats de 4 bytes e, em seguida, 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 formato SageMaker AI protobuf.
**nota**
Para ver um exemplo que mostra como converter a matriz numPy comumente usada no formato recordIO protobuf, consulte *[Uma introdução às máquinas de fatoração com 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;
}
```
Depois de criar o buffer de protocolo, armazene-o em um local do Amazon S3 que o SageMaker Amazon AI possa acessar e que possa ser transmitido como parte do `InputDataConfig` login. `create_training_job`
**nota**
Para todos os algoritmos de SageMaker IA da Amazon, a `ChannelName` `InputDataConfig` entrada deve ser definida como`train`. Alguns algoritmos também oferecem apoio 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
Os modelos de SageMaker IA 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 caderno. Quando não `model.tar.gz` está marcado, ele contém`model_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'))
```
# Formatos de dados comuns para inferência
Os algoritmos de SageMaker IA da Amazon aceitam e produzem vários tipos diferentes de MIME para as cargas HTTP usadas na recuperação de previsões on-line e em minilote. Você pode usar vários AWS serviços para transformar ou pré-processar registros antes de executar a inferência. No mínimo, é preciso converter os dados para os seguintes itens:
+ Serialização da solicitação de inferência (processada por você)
+ Desserialização da solicitação de inferência (processada pelo algoritmo)
+ Serialização da resposta de inferência (processada pelo algoritmo)
+ Desserialização da resposta de inferência (processada por você)
**Topics**
+ [Converter dados para serialização de solicitação de inferência](#ir-serialization)
+ [Converter dados para desserialização de respostas de inferência](#ir-deserialization)
+ [Formatos de solicitação comuns para todos os algoritmos](#common-in-formats)
+ [Use a transformação em lote com algoritmos integrados](#cm-batch)
## Converter dados para serialização de solicitação de inferência
As opções de tipo de conteúdo para solicitações de inferência do algoritmo Amazon SageMaker AI incluem: `text/csv``application/json`, e. `application/x-recordio-protobuf` Algoritmos que não oferecem suporte a todos esses tipos podem oferecer suporte a outros tipos. XGBoost, por exemplo, só suporta `text/csv` desta lista, mas também suporta`text/libsvm`.
Para `text/csv`, o valor do argumento do corpo para `invoke_endpoint` deve ser uma string com vírgulas que separem os valores para cada atributo. Por exemplo, um registro para um modelo com quatro atributos pode parecer assim: `1.5,16.0,14,23.0`. Todas as transformações executadas nos dados de treinamento também devem ser executadas nos dados antes da obtenção da inferência. A ordem dos atributos é importante, devendo permanecer inalterada.
`application/json` é significativamente mais flexível e fornece vários formatos possíveis para os desenvolvedores usarem em suas aplicações. Em um nível alto, em JavaScript, a carga útil pode ter a seguinte aparência:
```
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
}
}
]
}
```
Para especificar o `dataElement`, você tem as seguintes opções:
**Buffers de protocolo equivalentes**
```
// Has the same format as the protocol buffers implementation described for training.
let dataElement = {
"keys": [],
"values": [],
"shape": []
}
```
**Vetor numérico simples**
```
// 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
}
}
```
**Para vários registros**
```
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 ]
}
]
}
```
## Converter dados para desserialização de respostas de inferência
Os algoritmos de SageMaker IA da Amazon retornam JSON em vários layouts. Basicamente, a estrutura é esta:
```
let response = {
"predictions": [{
// Fields in the response object are defined on a per algorithm-basis.
}]
}
```
Os campos incluídos nas predições diferem de algoritmo para algoritmo. Veja a seguir exemplos de resultado para o algoritmo k-means.
**Inferência de único registro**
```
let response = {
"predictions": [{
"closest_cluster": 5,
"distance_to_cluster": 36.5
}]
}
```
**Inferência de vários registros**
```
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
}
]
}
```
**Inferência de vários registros com entrada 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 Os algoritmos de IA também oferecem suporte ao formato JSONLINES, em que o conteúdo da resposta por registro é o mesmo do formato JSON. A estrutura de vários registros é uma coleção de objetos de resposta por registro separados por caracteres de nova linha. O conteúdo da resposta para o KMeans algoritmo integrado para 2 pontos de dados de entrada é:
```
{"distance_to_cluster": 23.40593910217285, "closest_cluster": 0.0}
{"distance_to_cluster": 27.250282287597656, "closest_cluster": 0.0}
```
Ao executar uma transformação em lote, recomendamos usar o tipo de resposta `jsonlines`, definindo o campo `Accept` em `CreateTransformJobRequest` como `application/jsonlines`.
## Formatos de solicitação comuns para todos os algoritmos
A maioria dos algoritmos usa vários dos formatos de solicitação de inferência a seguir:
### Formato da solicitação JSON
**Tipo de conteúdo:** application/JSON
**Formato denso**
```
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]
}
}
}
]
}
```
**Formato esparso**
```
{
"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]
}
}
},
]
}
```
### Formato da solicitação JSONLINES
**Tipo de conteúdo:** application/JSONLINES
**Formato denso**
Um único registro no formato denso pode ser representado como:
```
{ "features": [1.5, 16.0, 14.0, 23.0] }
```
ou:
```
{ "data": { "features": { "values": [ 1.5, 16.0, 14.0, 23.0] } }
```
**Formato esparso**
Um único registro no formato esparso é representado como:
```
{"data": {"features": { "keys": [26, 182, 232, 243, 431], "shape": [2000], "values": [1, 1, 1, 4, 1] } } }
```
Vários registros são representados como uma coleção das representações de registro único, separadas por caracteres de nova linha:
```
{"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] }
```
### Formato da solicitação CSV
**Tipo de conteúdo:** text/csv;label\$1size=0
**nota**
Não há compatibilidade com CSV para máquinas de fatoração.
### Formato da solicitação RECORDIO
Tipo de conteúdo: aplicativo/ x-recordio-protobuf
## Use a transformação em lote com algoritmos integrados
Ao executar a transformação em lote, recomendamos usar o tipo de resposta JSONLINES em vez do JSON, se aceito pelo algoritmo. Para fazer isso, defina o campo `Accept` em `CreateTransformJobRequest` a `application/jsonlines`.
Quando você cria um trabalho de transformação, `SplitType` deve ser definido de acordo com `ContentType` dos dados de entrada. De modo semelhante, dependendo do campo `Accept` em `CreateTransformJobRequest`, `AssembleWith` deve ser ajustado de acordo. Use a seguinte tabela para definir esses campos:
| ContentType | Recomendado SplitType |
| --- | --- |
| application/x-recordio-protobuf | RecordIO |
| text/csv | Line |
| application/jsonlines | Line |
| application/json | None |
| application/x-image | None |
| image/\$1 | None |
| Aceitar | Recomendado AssembleWith |
| --- | --- |
| application/x-recordio-protobuf | None |
| application/json | None |
| application/jsonlines | Line |
Para obter mais informações sobre formatos de resposta de algoritmos específicos, consulte os seguintes tópicos:
+ [Formatos de inferência do DeepAR](deepar-in-formats.md)
+ [Formatos de resposta de máquinas de fatoração](fm-in-formats.md)
+ [Formatos de dados de inferência para IP Insights](ip-insights-inference-data-formats.md)
+ [Formatos de resposta do k-means](km-in-formats.md)
+ [Formatos de resposta e solicitação para k-NN](kNN-inference-formats.md)
+ [Formatos de resposta da aprendizagem linear](LL-in-formats.md)
+ [Formatos de resposta do NTM](ntm-in-formats.md)
+ [Formatos de dados para inferência em Object2Vec](object2vec-inference-formats.md)
+ [Incorporações de codificadores para Object2Vec](object2vec-encoder-embeddings.md)
+ [Formatos de resposta do PCA](PCA-in-formats.md)
+ [Formatos de resposta do RCF](rcf-in-formats.md)
# Tipos de instância para algoritmos internos
A maioria dos algoritmos de SageMaker IA da Amazon foi projetada para aproveitar as vantagens da computação de GPU para treinamento. Apesar dos custos mais altos por instância, GPUs treine mais rapidamente, tornando-os mais econômicos. As exceções são observadas neste guia.
Para saber quais instâncias do EC2 podem ser usadas, consulte [Detalhes da instância](https://aws.amazon.com/sagemaker-ai/pricing/#Instance_details).
O tamanho e o tipo de dados podem ter grande impacto sobre qual configuração de hardware é mais eficaz. Quando o mesmo modelo é treinado de forma recorrente, testes iniciais em uma variedade de tipos de instância podem revelar configurações mais econômicas a longo prazo. Além disso, os algoritmos que treinam com mais eficiência GPUs podem não exigir GPUs uma inferência eficiente. Faça testes para determinar a solução mais econômica. Para obter uma recomendação automática de instância ou realizar testes de carga personalizados, use o [Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html).
Para obter mais informações sobre as especificações de hardware de SageMaker IA, consulte os [preços do Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).
**UltraServers**
UltraServers conecte várias instâncias do Amazon EC2 usando uma interconexão aceleradora de baixa latência e alta largura de banda. Eles são desenvolvidos para lidar com AI/ML cargas de trabalho de grande escala que exigem poder de processamento significativo. Para obter mais informações, consulte [Amazon EC2 UltraServers](https://aws.amazon.com/ec2/ultraservers/). Para começar UltraServers, consulte [Reservar planos de treinamento para seus trabalhos ou HyperPod grupos de treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html).
Para começar a usar a UltraServers Amazon SageMaker AI, [crie um plano de treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/reserve-capacity-with-training-plans.html). Quando você UltraServer estiver disponível no plano de treinamento, crie um trabalho de treinamento com a Console de gerenciamento da AWS API Amazon SageMaker AI ou AWS CLI. Lembre-se de especificar o tipo de UltraServer instância que você comprou no plano de treinamento.
Um UltraServer pode executar um ou vários trabalhos ao mesmo tempo. UltraServers agrupa instâncias, o que lhe dá alguma flexibilidade em termos de como alocar sua UltraServer capacidade em sua organização. Ao configurar seus trabalhos, lembre-se também das diretrizes de segurança de dados da sua organização, pois instâncias em uma UltraServer podem acessar dados de outra tarefa em outra instância na mesma UltraServer.
Se você encontrar falhas de hardware no UltraServer, a SageMaker IA tentará resolver o problema automaticamente. À medida que a SageMaker IA investiga e resolve o problema, você pode receber notificações e ações por meio de AWS Health Eventos ou. AWS Support
Quando seu trabalho de treinamento termina, a SageMaker IA interrompe as instâncias, mas elas permanecem disponíveis em seu plano de treinamento se o plano ainda estiver ativo. Para manter uma instância em UltraServer execução após a conclusão de um trabalho, você pode usar [pools quentes gerenciados](https://docs.aws.amazon.com/sagemaker/latest/dg/train-warm-pools.html).
Se o seu plano de treinamento tiver capacidade suficiente, você poderá até mesmo executar trabalhos de treinamento em vários UltraServers. Por padrão, cada uma UltraServer vem com 18 instâncias, incluindo 17 instâncias e 1 instância sobressalente. Se você precisar de mais instâncias, precisará comprar mais UltraServers. Ao criar um trabalho de treinamento, você pode configurar como os trabalhos são distribuídos UltraServers usando o `InstancePlacementConfig` parâmetro.
Se você não configurar a colocação profissional, a SageMaker IA alocará automaticamente as tarefas para instâncias dentro do seu. UltraServer Essa estratégia padrão é baseada no melhor esforço que prioriza o preenchimento de todas as instâncias em uma única instância UltraServer antes de usar uma diferente. UltraServer Por exemplo, se você solicitar 14 instâncias e tiver 2 UltraServers no seu plano de treinamento, a SageMaker IA usará todas as instâncias da primeira UltraServer. Se você solicitou 20 instâncias e tem 2 UltraServers em seu plano de treinamento, a SageMaker IA usará todas as 17 instâncias na primeira UltraServer e depois usará 3 da segunda UltraServer. As instâncias dentro de um UltraServer uso NVLink para comunicação, mas individuais, UltraServers usam o Elastic Fabric Adapter (EFA), o que pode afetar o desempenho do treinamento do modelo.
# Logs para algoritmos integrados
Os algoritmos de SageMaker IA da Amazon produzem CloudWatch registros da Amazon, que fornecem informações detalhadas sobre o processo de treinamento. Para ver os registros, no console AWS de gerenciamento, escolha **CloudWatch****Registros** e, em seguida, escolha o **grupo/aws/sagemaker/TrainingJobslog.** Cada trabalho de treinamento tem um fluxo de logs por nó no qual foi treinado. O nome do fluxo de logs começa com o valor especificado no parâmetro `TrainingJobName` quando o trabalho foi criado.
**nota**
Se um trabalho falhar e os registros não aparecerem CloudWatch, é provável que tenha ocorrido um erro antes do início do treinamento. Especificar a imagem de treinamento ou o local do S3 incorretos pode ser um dos motivos.
O conteúdo dos logs variam de algoritmo para algoritmo. No entanto, você pode normalmente encontrar as seguintes informações:
+ Confirmação dos argumentos fornecidos no início do log
+ Erros que ocorreram durante o treinamento
+ Medição da precisão de um algoritmo ou do desempenho numérico
+ Cronologia do algoritmo e todos os principais estágios presentes nele
## Erros comuns
Se um trabalho de treinamento apresentar falha, alguns detalhes sobre o problema serão fornecidos pelo valor de retorno `FailureReason` na descrição do trabalho de treinamento, da seguinte forma:
```
sage = boto3.client('sagemaker')
sage.describe_training_job(TrainingJobName=job_name)['FailureReason']
```
Outros são relatados somente nos CloudWatch registros. Estes são alguns dos erros comuns:
1. Especificação incorreta de um hiperparâmetro ou especificação de um hiperparâmetro inválido para o algoritmo.
**Do CloudWatch registro**
```
[10/16/2017 23:45:17 ERROR 139623806805824 train.py:48]
Additional properties are not allowed (u'mini_batch_siz' was
unexpected)
```
1. Especificação de um valor inválido para um hiperparâmetro.
**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. Formato impreciso do arquivo protobuf.
**Do CloudWatch registro**
```
[10/17/2017 18:01:04 ERROR 140234860816192 train.py:48] cannot
copy sequence with size 785 to array axis with dimension 784
```