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

# Formatos de dados comuns para inferência
<a name="cdf-inference"></a>

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
<a name="ir-serialization"></a>

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": {
         "<field name>": 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
<a name="ir-deserialization"></a>

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 name="common-in-formats"></a>

A maioria dos algoritmos usa vários dos formatos de solicitação de inferência a seguir:

### Formato da solicitação JSON
<a name="cm-json"></a>

**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
<a name="cm-jsonlines"></a>

**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
<a name="cm-csv"></a>

**Tipo de conteúdo:** text/csv;label\_size=0

**nota**  
Não há compatibilidade com CSV para máquinas de fatoração.

### Formato da solicitação RECORDIO
<a name="cm-recordio"></a>

Tipo de conteúdo: aplicativo/ x-recordio-protobuf

## Use a transformação em lote com algoritmos integrados
<a name="cm-batch"></a>

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/\* | 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)