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á.
# Guia de compatibilidade de formato de dados
Este guia descreve os tipos de formato de dados que são compatíveis com as tarefas de processamento do SageMaker Clarify. Os tipos de formato de dados compatíveis incluem extensões de arquivo, estrutura de dados e requisitos ou restrições específicas para conjuntos de dados tabulares, de imagem e de séries temporais. Este guia também mostra como verificar se seu conjunto de dados está em conformidade com esses requisitos.
Em um alto nível, o trabalho de processamento do SageMaker Clarify segue o modelo de entrada-processo-saída para calcular métricas de viés e atribuições de recursos. Consulte os exemplos a seguir para obter detalhes.
A entrada para a tarefa de processamento do SageMaker Clarify consiste no seguinte:
+ O conjunto de dados a ser analisado.
+ O configuração de análise Para obter mais informações sobre como configurar uma análise, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
Durante o estágio de processamento, o SageMaker Clarify calcula métricas de viés e atribuições de recursos. O trabalho de processamento do SageMaker Clarify conclui as seguintes etapas no back-end:
+ O trabalho de processamento do SageMaker Clarify analisa sua configuração de análise e carrega seu **conjunto** de dados.
+ Para calcular métricas de desvio pós-treinamento e atribuições de atributos, o trabalho exige predições de modelo do seu modelo. **O trabalho de processamento do SageMaker Clarify serializa seus dados e os envia como uma **solicitação** ao seu modelo, que é implantado em um endpoint de inferência de SageMaker IA em tempo real.** **Depois disso, o trabalho de processamento do SageMaker Clarify extrai previsões da resposta.**
+ O trabalho de processamento do SageMaker Clarify executa a análise de viés e explicabilidade e, em seguida, gera os resultados.
Para obter mais informações, consulte [Como funcionam os trabalhos de processamento do SageMaker Clarify](clarify-configure-processing-jobs.md#clarify-processing-job-configure-how-it-works).
O parâmetro usado para especificar o formato dos dados depende de onde os dados são usados no fluxo de processamento, como segue:
+ Para um **conjunto de dados de entrada**, use o parâmetro `dataset_type` para especificar o formato ou o tipo MIME.
+ Para uma **solicitação** para um endpoint, use o parâmetro `content_type` para especificar o formato.
+ Para uma **solicitação** para um endpoint, use o parâmetro `accept_type`para especificar o formato.
O conjunto de dados de entrada, a solicitação e a resposta de e para o endpoint não exigem o mesmo formato. Por exemplo, você pode usar um conjunto de dados do Parquet com uma carga útil da solicitação**** CSV e uma carga útil da resposta**** de linhas JSON de acordo com as seguintes condições:
+ Sua análise está configurada corretamente.
+ Seu modelo oferece apoio aos formatos de solicitação e resposta.
**nota**
Se `content_type` ou não `accept_type` forem fornecidos, o contêiner SageMaker Clarify `content_type` infere o e. `accept_type`
**Topics**
+ [Dados tabulares](clarify-processing-job-data-format-tabular.md)
+ [Requisitos de dados de imagens](clarify-processing-job-data-format-image.md)
+ [Dados de séries temporais](clarify-processing-job-data-format-time-series.md)
# Dados tabulares
Dados tabulares referem-se a dados que podem ser carregados em um quadro de dados bidimensional. No quadro, cada linha representa um registro e cada registro tem uma ou mais colunas. Os valores em cada célula do quadro de dados podem ser de tipos de dados numéricos, categóricos ou de texto.
## Pré-requisitos do conjunto de dados tabular
Antes da análise, seu conjunto de dados deveria ter todas as etapas de pré-processamento necessárias já aplicadas. Isso inclui limpeza de dados ou engenharia de atributos.
Você pode fornecer um ou vários conjuntos de dados. Se você fornecer vários conjuntos de dados, use o seguinte para identificá-los na tarefa de processamento do SageMaker Clarify.
+ Use uma configuração [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)nomeada `dataset` ou de análise `dataset_uri` para especificar o conjunto de dados principal. Para obter mais informações sobre `dataset_uri`, consulte a lista de parâmetros em [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
+ Use o parâmetro `baseline` fornecido no arquivo de configuração da análise. O conjunto de dados de linha de base é necessário para a análise SHAP. Para obter mais informações sobre o arquivo de configuração de análise, incluindo exemplos, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
A tabela a seguir lista os formatos de dados compatíveis, suas extensões de arquivo e tipos de MIME.
| Formato de dados | Extensão do arquivo | Tipo MIME |
| --- | --- | --- |
| CSV | csv | `text/csv` |
| Linhas JSON | jsonl | `application/jsonlines` |
| JSON | json | `application/json` |
| Parquet | parquet | "application/x-parquet" |
As seções a seguir mostram exemplos de conjuntos de dados tabulares nos formatos CSV, JSON Lines e Apache Parquet.
### Pré-requisitos de conjunto de dados tabulares em formato CSV
A tarefa de processamento do SageMaker Clarify foi projetada para carregar arquivos de dados CSV no dialeto [csv.excel](https://docs.python.org/3/library/csv.html#csv.excel). No entanto, é flexível o suficiente para compatibilidade com outros terminadores de linha, incluindo `\n` e `\r`.
Para compatibilidade, todos os arquivos de dados CSV fornecidos para a tarefa de processamento do SageMaker Clarify devem ser codificados em UTF-8.
Se o conjunto de dados não conter uma linha de cabeçalho, faça o seguinte:
+ Defina o rótulo de configuração da análise para indexar `0`. Isso significa que a primeira coluna é o rótulo de veracidade.
+ Se o parâmetro `headers` estiver definido, `label` defina o cabeçalho da coluna do rótulo para indicar a localização da coluna do rótulo. Todas as outras colunas são designadas como atributos.
A seguir está um exemplo de um conjunto de dados que não contém uma linha de cabeçalho.
```
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
Se seus dados contiverem uma linha de cabeçalho, defina o parâmetro `label` para indexar `0`. Para indicar a localização da coluna do rótulo, use o cabeçalho do rótulo de veracidade `Label`. Todas as outras colunas são designadas como atributos.
A seguir está um exemplo de um conjunto de dados que contém uma linha de cabeçalho.
```
Label,Rating,A12,A13,Comments
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
### Pré-requisitos de conjunto de dados tabulares em formato JSON
O JSON é um formato flexível para representar dados estruturados que contêm qualquer nível de complexidade. O suporte do SageMaker Clarify para JSON não está restrito a nenhum formato específico e, portanto, permite formatos de dados mais flexíveis em comparação com conjuntos de dados nos formatos CSV ou JSON Lines. Este guia mostra como definir uma configuração de análise para dados tabulares no formato JSON.
**nota**
Para garantir a compatibilidade, todos os arquivos de dados JSON fornecidos para a tarefa de processamento do SageMaker Clarify devem ser codificados em UTF-8.
Veja a seguir exemplos de dados de entrada com registros que contêm uma chave de nível superior, uma lista de atributos e um rótulo.
```
[
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0},
...
]
```
Um exemplo de análise de configuração para o conjunto de dados de exemplo de entrada anterior deve definir os seguintes parâmetros:
+ O `label` parâmetro deve usar a [JMESPath](https://jmespath.org/)expressão `[*].label` para extrair o rótulo de verdade fundamental para cada registro no conjunto de dados. A JMESPath expressão deve produzir uma lista de rótulos em que o i the label corresponda ao i the record.
+ O `features` parâmetro deve usar a JMESPath expressão `[*].features` para extrair uma matriz de recursos para cada registro no conjunto de dados. A JMESPath expressão deve produzir uma matriz ou matriz 2D em que a i th linha contém os valores do recurso correspondente ao i th registro.
A seguir estão exemplos de dados de entrada com registros que contêm uma chave de nível superior e uma chave aninhada que contém uma lista de atributos e rótulos para cada registro.
```
{
"data": [
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
]
}
```
Um exemplo de análise de configuração para o conjunto de dados de exemplo de entrada anterior deve definir os seguintes parâmetros:
+ O `label` parâmetro usa a [JMESPath](https://jmespath.org/)expressão `data[*].label` para extrair o rótulo de verdade fundamental para cada registro no conjunto de dados. A JMESPath expressão deve produzir uma lista de rótulos em que o rótulo é para eles no registro.
+ O `features` parâmetro usa a JMESPath expressão `data[*].features` para extrair a matriz de recursos para cada registro no conjunto de dados. A JMESPath expressão deve produzir uma matriz ou matriz 2D em que a i th linha contém os valores de recurso para o i th registro.
### Pré-requisitos de conjunto de dados tabulares em Formato JSON Lines
Linhas JSON é um formato de texto para representar dados estruturados em que cada linha é um objeto JSON válido. Atualmente, os trabalhos de processamento do SageMaker Clarify são compatíveis apenas com linhas JSON de formato denso SageMaker AI. Para estar em conformidade com o formato exigido, todos os atributos de um registro devem ser listados em uma única matriz JSON. Para obter mais informações sobre linhas JSON, consulte [Formato da solicitação JSONLINES](cdf-inference.md#cm-jsonlines).
**nota**
Todos os arquivos de dados de linhas JSON fornecidos para a tarefa de processamento do SageMaker Clarify devem ser codificados em UTF-8 para garantir a compatibilidade.
A seguir está um exemplo de como definir uma configuração de análise para um registro que contém uma **chave de nível superior** e uma **lista** de elementos.
```
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}
...
```
A análise de configuração do exemplo de conjunto de dados anterior deve definir os parâmetros da seguinte forma:
+ Para indicar a localização do rótulo de verdade fundamental, o parâmetro `label` deve ser definido como a JMESPath expressão`label`.
+ Para indicar a localização da matriz de recursos, o parâmetro `features` deve ser definido como a JMESPath expressão`features`.
Veja a seguir um exemplo de como definir uma configuração de análise para um registro que contém uma **chave de nível superior** e uma **chave aninhada** que contém uma **lista** de elementos.
```
{"data":{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}}
{"data":{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
...
```
A análise de configuração do exemplo de conjunto de dados anterior deve definir os parâmetros da seguinte forma:
+ O parâmetro `label` deve ser definido como a JMESPath expressão `data.label` para indicar a localização do rótulo de verdade fundamental.
+ O parâmetro `features` deve ser definido como a JMESPath expressão `data.features` para indicar a localização da matriz de recursos.
### Pré-requisitos de conjunto de dados tabulares em formato Parquet
O [Parquet](https://parquet.apache.org/) é um formato de dados binários orientado por colunas. Atualmente, os trabalhos de processamento do SageMaker Clarify oferecem suporte ao carregamento de arquivos de dados do Parquet somente quando a contagem de instâncias de processamento é`1`.
Como os trabalhos de processamento do SageMaker Clarify não oferecem suporte à solicitação do endpoint ou à resposta do endpoint no formato Parquet, você deve especificar o formato de dados da solicitação do endpoint definindo o parâmetro de configuração da análise `content_type` para um formato compatível. Para obter mais informações, consulte `content_type` em [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
Os dados do Parquet devem ter nomes das colunas formatados como cadeias de caracteres. Use o parâmetro `label` de configuração de análise para definir o nome da coluna do rótulo para indicar a localização dos rótulos verdadeiros fundamentais. Todas as outras colunas são designadas como atributos.
# Solicitações de endpoint para dados tabulares
Para obter previsões de modelo para análise de viés pós-treinamento e análise de importância de recursos, os trabalhos de processamento do SageMaker Clarify serializam os dados tabulares em bytes e os enviam para um endpoint de inferência como carga útil de solicitação. Esses dados tabulares são provenientes do conjunto de dados de entrada ou são gerados. Se forem dados sintéticos, eles são gerados pelo explicador para análise SHAP ou análise PDP.
O formato de dados da carga útil da solicitação deve ser especificado pelo parâmetro `content_type` de configuração da análise. Se o parâmetro não for fornecido, o trabalho de processamento do SageMaker Clarify usará o valor do `dataset_type` parâmetro como o tipo de conteúdo. Para obter mais informações sobre `content_type` ou `dataset_type`, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
As seções a seguir mostram exemplos de solicitações de endpoint nos formatos CSV e JSON Lines.
## Solicitação de endpoint no formato CSV
A tarefa de processamento do SageMaker Clarify pode serializar dados no formato CSV (tipo MIME:). `text/csv` A tabela a seguir mostra exemplos das cargas úteis de solicitações serializadas.
| Carga útil da solicitação de endpoint (representação de string) | Comentários |
| --- | --- |
| '1,2,3,4' | Registro único (quatro atributos numéricos). |
| '1,2,3,4\$1n5,6,7,8' | Dois registros, separados por quebra de linha '\$1n'. |
| '"Este é um bom produto” ,5' | Registro único (um atributo de texto e um atributo numérico). |
| '"Este é um bom produto” ,5\$1n“Experiência de compra ruim” ,1' | Dois registros. |
## A solicitação do endpoint está no formato JSON Lines
O trabalho de processamento do SageMaker Clarify pode serializar dados no formato denso SageMaker AI JSON Lines (tipo MIME:). `application/jsonlines` Para obter mais informações sobre linhas JSON, consulte [Formato da solicitação JSONLINES](cdf-inference.md#cm-jsonlines).
Para transformar dados tabulares em dados JSON, forneça uma string de modelo para o parâmetro `content_template` de configuração da análise. Para obter mais informações sobre o `content_template`, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md). A tabela a seguir mostra exemplos de cargas úteis da solicitação de linhas JSON serializadas.
| Carga útil da solicitação de endpoint (representação de string) | Comentários |
| --- | --- |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1' | Registro único Nesse caso, o modelo se parece `'{"data":{"features":$features}}' ` e `$features` é substituído pela lista de atributos `[1,2,3,4]`. |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1\$1n\$1"data":\$1"features":[5,6,7,8]\$1\$1' | Dois registros. |
| '\$1"features":["Este é um bom produto",5]\$1' | Registro único Neste caso, o modelo se parece com `'{"features":$features}'` e \$1features é substituído pela lista de atributos `["This is a good product",5]`. |
| '\$1"features":["Este é um bom produto",5]\$1\$1n\$1"features":["Experiência de compra ruim",1]\$1' | Dois registros. |
## A solicitação de endpoint está no formato JSON
Um trabalho de processamento do SageMaker Clarify pode serializar dados em estruturas JSON arbitrárias (tipo MIME:). `application/json` Para fazer isso, você deve fornecer uma string de modelo para o `content_template` parâmetro de configuração da análise. Isso é usado pelo trabalho de processamento do SageMaker Clarify para construir a estrutura JSON externa. Você também deve fornecer uma string de modelo para `record_template`, que é usada para construir a estrutura JSON para cada registro. Para obter mais informações sobre `content_template` e `record_template`, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
**nota**
Como `content_template` e `record_template` são parâmetros de string, qualquer caractere de aspa dupla (`"`) que faça parte da estrutura serializada do JSON deve ser anotado como um caractere de escape em sua configuração. Por exemplo, se você quiser escapar de uma aspa dupla em Python, você pode digitar o seguinte para `content_template`:
```
"{\"data\":{\"features\":$record}}}"
```
A tabela a seguir mostra exemplos de cargas úteis de solicitações JSON serializadas e os parâmetros `content_template` e `record_template` correspondentes necessários para construí-las.
| Carga útil da solicitação de endpoint (representação de string) | Comentários | content\$1template | record\$1template |
| --- | --- | --- | --- |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1' | Um único registro por vez. | '\$1"data":\$1"features":\$1record\$1\$1\$1' | “\$1features" |
| '\$1"instances":[[0, 1], [3, 4]], "feature-names": ["A", "B"]\$1' | Vários registros com nomes de atributos. | ‘\$1"instances":\$1records, "feature-names":\$1feature\$1names\$1' | “\$1features" |
| '[\$1"A": 0, "B": 1\$1, \$1"A": 3, "B": 4\$1]' | Vários registros e pares de chave-valor. | “\$1records" | “\$1features\$1kvp" |
| ‘\$1"A": 0, "B": 1\$1' | Um único registro por vez e pares de chave-valor. | "\$1record" | "\$1features\$1kvp" |
| ‘\$1"A": 0, "nested": \$1"B": 1\$1\$1' | Como alternativa, use o record\$1template totalmente detalhado para estruturas arbitrárias. | "\$1record" | '\$1"A": "\$1\$1A\$1", "nested": \$1"B": "\$1\$1B\$1"\$1\$1' |
# Resposta de endpoint para dados tabulares
Depois que o trabalho de processamento do SageMaker Clarify recebe a resposta de uma invocação de endpoint de inferência, ele desserializa a carga útil da resposta e extrai previsões dela. Use o parâmetro `accept_type` de configuração de análise para especificar o formato de dados da carga útil da resposta. Se não `accept_type` for fornecido, o trabalho de processamento do SageMaker Clarify usará o valor do parâmetro content\$1type como formato de saída do modelo. Para saber mais sobre o `accept_type`, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
As predições podem consistir em rótulos previstos para análise de desvio ou valores de probabilidade (pontuações) para análise de importância do atributo. Na configuração da análise `predictor`, os três parâmetros a seguir extraem as predições.
+ O parâmetro `probability` é usado para localizar os valores de probabilidade (pontuações) na resposta do endpoint.
+ O parâmetro `label` é usado para localizar os rótulos previstos na resposta do endpoint.
+ (Opcional) O parâmetro `label_headers` fornece os rótulos previstos para um modelo multiclasse.
As diretrizes a seguir se referem às respostas de endpoints nos formatos CSV, JSON Lines e JSON.
## O Endpoint Response está em formato CSV
Se a carga de resposta estiver no formato CSV (tipo MIME:`text/csv`), a tarefa de processamento do SageMaker Clarify desserializará cada linha. Em seguida, ele extrai as predições dos dados desserializados usando os índices de coluna fornecidos na configuração da análise. As linhas na carga útil da resposta devem corresponder aos registros na carga útil da solicitação.
As tabelas a seguir fornecem exemplos de dados de resposta em diferentes formatos e para diferentes tipos de problemas. Seus dados podem variar desses exemplos, desde que as predições possam ser extraídas de acordo com a configuração da análise.
As seções a seguir mostram exemplos de respostas de endpoint em formatos CSV.
### A resposta do endpoint está no formato CSV e contém apenas probabilidade
A tabela a seguir é um exemplo de resposta de endpoint para problemas de regressão e classificação binária.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '0.6' |
| Dois registros (resultados em uma linha, divididos por vírgula). | '0.6,0.3' |
| Dois registros (resultados em duas linhas) | '0.6\$1n0.3' |
Para o exemplo anterior, o endpoint gera um único valor de probabilidade (pontuação) do rótulo previsto. Para extrair probabilidades usando o índice e usá-las para análise da importância do atributo, defina o parâmetro `probability` de configuração da análise como índice da coluna `0`. Essas probabilidades também podem ser usadas para análise de desvio se forem convertidas em valor binário usando o parâmetro `probability_threshold`. Para saber mais sobre o `probability_threshold`, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
A tabela a seguir é um exemplo de resposta de endpoint para um problema multiclasse.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único de um modelo multiclasse (três classes). | '0.1,0.6,0.3' |
| Dois registros de um modelo multiclasse (três classes). | '0.1,0.6,0.3\$1n0.2,0.5,0.3' |
Para o exemplo anterior, o endpoint gera uma lista de probabilidades (pontuações). Se nenhum índice for fornecido, todos os valores serão extraídos e usados para análise de importância do atributo. Se o parâmetro de configuração de análise `label_headers` for fornecido. Em seguida, o trabalho de processamento do SageMaker Clarify pode selecionar o cabeçalho do rótulo com a probabilidade máxima como o rótulo previsto, que pode ser usado para análise de viés. Para saber mais sobre o `label_headers`, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
### A resposta do endpoint está no formato CSV e contém apenas o rótulo previsto
A tabela a seguir é um exemplo de resposta de endpoint para problemas de regressão e classificação binária.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '1' |
| Dois registros (resultados em uma linha, divididos por vírgula). | '1,0' |
| Dois registros (resultados em duas linhas) | '1\$1n0' |
Para o exemplo anterior, o endpoint gera o rótulo previsto em vez da probabilidade. Defina o parâmetro `label` da configuração `predictor` para o índice da coluna `0` para que os rótulos previstos possam ser extraídos usando o índice e usados para análise de polarização.
### A resposta do endpoint está no formato CSV e contém rótulo e probabilidade previstos
A tabela a seguir é um exemplo de resposta de endpoint para problemas de regressão e classificação binária.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '1,0.6' |
| Dois registros | '1,0.6\$1n0,0.3' |
Para o exemplo anterior, o endpoint gera o rótulo previsto seguido por sua probabilidade. Defina o `label` parâmetro da `predictor` configuração como índice `0` da coluna e `probability` defina como índice da coluna `1` para extrair os dois valores do parâmetro.
### A resposta do endpoint está no formato CSV e contém rótulos e probabilidades previstas (multiclasse)
Um modelo multiclasse treinado pelo Amazon SageMaker Autopilot pode ser configurado para gerar a representação em sequência da lista de rótulos e probabilidades previstos. A tabela de exemplo a seguir mostra um exemplo de resposta de endpoint de um modelo configurado para gerar `predicted_label`, `probability`, `labels` e `probabilities`.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '"dog",0.6,"[\$1'cat\$1', \$1'dog\$1', \$1'fish\$1']","[0.1, 0.6, 0.3]"' |
| Dois registros | '"dog",0.6,"[\$1'cat\$1', \$1'dog\$1', \$1'fish\$1']","[0.1, 0.6, 0.3]"\$1n""cat",0.7,[\$1'cat\$1', \$1'dog\$1', \$1'fish\$1']","[0.7, 0.2, 0.1]"' |
No exemplo anterior, o trabalho de processamento do SageMaker Clarify pode ser configurado das seguintes maneiras para extrair as previsões.
Para análise de desvio, o exemplo anterior pode ser configurado como um dos seguintes:
+ Defina o parâmetro `label` da configuração `predictor` como `0` para extrair o rótulo previsto.
+ Defina o parâmetro para `2` extrair os rótulos previstos e `probability` defina como `3` para extrair as probabilidades correspondentes. O trabalho de processamento do SageMaker Clarify pode determinar automaticamente o rótulo previsto identificando o rótulo com o maior valor de probabilidade. Referindo-se ao exemplo anterior de um único registro, o modelo prevê três rótulos: `cat`, `dog` e `fish`, com probabilidades correspondentes de `0.1`, `0.6` e `0.3`. Com base nessas probabilidades, o rótulo previsto é `dog`, pois tem o maior valor de probabilidade de `0.6`.
+ Defina `probability` como `3` para extrair as probabilidades. Se `label_headers` for fornecido, o trabalho de processamento do SageMaker Clarify poderá determinar automaticamente o rótulo previsto identificando o cabeçalho do rótulo com o maior valor de probabilidade.
Para análise da importância do atributo, o exemplo anterior pode ser configurado da seguinte forma:
+ Defina `probability` para `3` extrair as probabilidades de todos os rótulos previstos. Em seguida, as atribuições de atributos serão computadas para todos os rótulos. Se o cliente não especificar `label_headers`, as etiquetas previstas serão usadas como cabeçalhos de etiquetas no relatório de análise.
## A resposta do endpoint está no formato JSON Lines
Se a carga de resposta estiver no formato JSON Lines (tipo MIME:`application/jsonlines`), a tarefa de processamento do SageMaker Clarify desserializará cada linha como JSON. Em seguida, ele extrai as previsões dos dados desserializados usando JMESPath expressões fornecidas na configuração da análise. As linhas na carga útil daresposta devem corresponder aos registros na carga útil da solicitação. As tabelas a seguir mostram exemplos de dados de resposta em diferentes formatos. Seus dados podem variar desses exemplos, desde que as predições possam ser extraídas de acordo com a configuração da análise.
As seções a seguir mostram exemplos de respostas de endpoint em formato JSON Lines.
### A resposta do endpoint está no formato JSON Lines e contém apenas probabilidade
A tabela a seguir é um exemplo de resposta de endpoint que gera apenas o valor de probabilidade (pontuação).
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '\$1"score":0.6\$1' |
| Dois registros | '\$1"score":0.6\$1\$1n\$1"score":0.3\$1' |
Para o exemplo anterior, defina o parâmetro de configuração de análise `probability` como JMESPath expressão “pontuação” para extrair seu valor.
### A resposta do endpoint está no formato JSON Lines e contém apenas o rótulo previsto
A tabela a seguir é um exemplo de resposta de endpoint que gera apenas o rótulo previsto.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '\$1"prediction":1\$1' |
| Dois registros | '\$1"prediction":1\$1\$1n\$1"prediction":0\$1' |
Para o exemplo anterior, defina o `label` parâmetro da configuração do preditor como JMESPath expressão`prediction`. Em seguida, o trabalho de processamento do SageMaker Clarify pode extrair os rótulos previstos para análise de viés. Para obter mais informações, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
### A resposta do endpoint está no formato JSON Lines e contém rótulo e probabilidade previstos
A tabela a seguir é um exemplo de resposta de endpoint que gera o rótulo previsto e sua pontuação.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '\$1"prediction":1,"score":0.6\$1' |
| Dois registros | '\$1"prediction":1,"score":0.6\$1\$1n\$1"prediction":0,"score":0.3\$1' |
No exemplo anterior, defina o `label` parâmetro da `predictor` configuração como JMESPath expressão “previsão” para extrair os rótulos previstos. `probability`Defina a JMESPath expressão “pontuação” para extrair a probabilidade. Para obter mais informações, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
### A resposta do endpoint está no formato JSON Lines e contém rótulos e probabilidades previstas (multiclasse)
A tabela a seguir é um exemplo de resposta de endpoint de um modelo multiclasse que gera o seguinte:
+ Uma lista de rótulos previstos.
+ Probabilidades e o rótulo previsto selecionado e sua probabilidade.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| Dois registros | '\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1label":"cat","probability":0.7,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.7,0.2,0.1]\$1' |
No exemplo anterior, a tarefa de processamento do SageMaker Clarify pode ser configurada de várias maneiras para extrair as previsões.
Para análise de desvio, o exemplo anterior pode ser configurado como **um** dos seguintes:
+ Defina o `label` parâmetro da `predictor` configuração para a JMESPath expressão “predicted\$1label” para extrair o rótulo previsto.
+ Defina o parâmetro como a JMESPath expressão “predicted\$1labels” para extrair os rótulos previstos. `probability`Defina a JMESPath expressão “probabilidades” para extrair suas probabilidades. A tarefa SageMaker Clarify determina automaticamente o rótulo previsto identificando o rótulo com o maior valor de probabilidade.
+ `probability`Defina a JMESPath expressão “probabilidades” para extrair suas probabilidades. Se `label_headers` for fornecido, o trabalho de processamento do SageMaker Clarify poderá determinar automaticamente o rótulo previsto identificando o rótulo com o maior valor de probabilidade.
Para analisar a importância do atributo, faça o seguinte:
+ `probability`Defina a JMESPath expressão “probabilidades” para extrair suas probabilidades de todos os rótulos previstos. Em seguida, as atribuições de atributos serão computadas para todos os rótulos.
## A resposta do endpoint está no formato JSON
Se a carga de resposta estiver no formato JSON (tipo MIME:`application/json`), a tarefa de processamento do SageMaker Clarify desserializará toda a carga como JSON. Em seguida, ele extrai as previsões dos dados desserializados usando JMESPath expressões fornecidas na configuração da análise. Os registros na carga útil da resposta devem corresponder aos registros na carga útil da solicitação.
As seções a seguir mostram exemplos de respostas de endpoint em formatos JSON. As tabelas a seguir fornecem exemplos de dados de resposta em diferentes formatos e para diferentes tipos de problemas. Seus dados podem variar desses exemplos, desde que as predições possam ser extraídas de acordo com a configuração da análise.
### A resposta do endpoint está no formato JSON e contém apenas probabilidade
A tabela a seguir é um exemplo de resposta de um endpoint que gera apenas o valor de probabilidade (pontuação).
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '[0.6]' |
| Dois registros | '[0.6,0.3]' |
No exemplo anterior, não há quebra de linha na carga útil da resposta. Em vez disso, um único objeto JSON contém uma lista de pontuações, uma para cada registro na solicitação. Defina o parâmetro de configuração da análise `probability` para a JMESPath expressão “[\$1]” para extrair o valor.
### A resposta do endpoint está no formato JSON Lines e contém apenas o rótulo previsto
A tabela a seguir é um exemplo de resposta de um endpoint que gera apenas o rótulo previsto.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '\$1"predicted\$1labels":[1]\$1' |
| Dois registros | '\$1"predicted\$1labels":[1,0]\$1' |
Defina o `label` parâmetro da `predictor` configuração para a JMESPath expressão “predicted\$1labels” e, em seguida, o trabalho de processamento do SageMaker Clarify poderá extrair os rótulos previstos para análise de viés.
### A resposta do endpoint está no formato JSON e contém rótulo e probabilidade previstos
A tabela a seguir é um exemplo de resposta de endpoint que gera o rótulo previsto e sua pontuação.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '\$1"predictions":[\$1"label":1,"score":0.6\$1' |
| Dois registros | ‘\$1"predictions":[\$1"label":1,"score":0.6\$1,\$1"label":0,"score":0.3\$1]\$1' |
No exemplo anterior, defina o `label` parâmetro da `predictor` configuração para a JMESPath expressão “predictions [\$1] .label” para extrair os rótulos previstos. `probability`Defina a JMESPath expressão “predictions [\$1] .score” para extrair a probabilidade.
### A resposta do endpoint está no formato JSON e contém rótulos e probabilidades previstas (multiclasse)
A tabela a seguir é um exemplo de resposta de um endpoint de um modelo multiclasse que gera o seguinte:
+ Uma lista de rótulos previstos.
+ Probabilidades e o rótulo previsto selecionado e sua probabilidade.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Registro único | '[\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1]' |
| Dois registros | '[\$1"predicted\$1label":"dog","probability":0.6,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1,\$1"predicted\$1label":"cat","probability":0.7,"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.7,0.2,0.1]\$1]' |
O trabalho de processamento do SageMaker Clarify pode ser configurado de várias maneiras para extrair as previsões.
Para análise de desvio, o exemplo anterior pode ser configurado como **um** dos seguintes:
+ Defina o `label` parâmetro da `predictor` configuração para a JMESPath expressão “[\$1] .predicted\$1label” para extrair o rótulo previsto.
+ Defina o parâmetro como a JMESPath expressão “[\$1] .predicted\$1labels” para extrair os rótulos previstos. `probability`Defina a JMESPath expressão “[\$1] .probabilidades” para extrair suas probabilidades. O trabalho de processamento do SageMaker Clarify pode determinar automaticamente a etiqueta prevista identificando a etiqueta com o maior valor de proximidade.
+ `probability`Defina a JMESPath expressão “[\$1] .probabilidades” para extrair suas probabilidades. Se `label_headers` for fornecido, o trabalho de processamento do SageMaker Clarify poderá determinar automaticamente o rótulo previsto identificando o rótulo com o maior valor de probabilidade.
Para análise da importância do recurso, `probability` defina a JMESPath expressão “[\$1] .probabilidades” para extrair suas probabilidades de todos os rótulos previstos. Em seguida, as atribuições de atributos serão computadas para todos os rótulos.
# Verifique previamente a solicitação e resposta do endpoint para dados tabulares
Recomendamos que você implante seu modelo em um endpoint de inferência de SageMaker IA em tempo real e envie solicitações para o endpoint. Examine manualmente as solicitações e respostas para garantir que ambas estejam em conformidade com os requisitos da seção [Solicitações de endpoint para dados tabulares](clarify-processing-job-data-format-tabular-request.md) e da seção [Resposta de endpoint para dados tabulares](clarify-processing-job-data-format-tabular-response.md). Se o seu contêiner de modelo oferecer compatibilidade com solicitações em lote, você poderá começar com uma única solicitação de registro e, em seguida, tentar dois ou mais registros.
Os comandos a seguir mostram como solicitar uma resposta usando o AWS CLI. O AWS CLI vem pré-instalado nas instâncias SageMaker Studio e SageMaker Notebook. Para instalar o AWS CLI, siga este [guia de instalação](https://aws.amazon.com/cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Os parâmetros são definidos da seguinte forma:
+ `$ENDPOINT NAME` - O nome do endpoint.
+ `$CONTENT_TYPE`: O tipo MIME da solicitação (entrada do contêiner do modelo).
+ `$ACCEPT_TYPE`: O tipo MIME da resposta (saída do contêiner do modelo).
+ `$REQUEST_DATA`: A string de carga útil solicitada.
+ `$CLI_BINARY_FORMAT`: o formato do parâmetro da interface da linha de comando (CLI). Para AWS CLI v1, esse parâmetro deve permanecer em branco. Para v2, esse parâmetro deve ser definido como `--cli-binary-format raw-in-base64-out`.
**nota**
AWS CLI [A v2 passa parâmetros binários como strings codificadas em base64 por padrão.](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)
# AWS CLI exemplos de v1
O exemplo na seção anterior foi para a AWS CLI v2. Os exemplos de solicitação e resposta a seguir de e para o endpoint usam AWS CLI v1.
## Solicitação e resposta de endpoint em formato CSV
No exemplo de código a seguir, a solicitação consiste em um único registro e a resposta é seu valor de probabilidade.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
0.6
```
No exemplo de código a seguir, a solicitação consiste em dois registros e a resposta inclui suas probabilidades, que são separadas por uma vírgula.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
No exemplo de código anterior, a `$'content'` expressão no `--body` diz ao comando para interpretar `'\n'` no conteúdo como uma quebra de linha. Segue o resultado da resposta.
```
0.6,0.3
```
No exemplo de código a seguir, a solicitação consiste em dois registros, a resposta inclui suas probabilidades, separadas por uma quebra de linha.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
0.6
0.3
```
No exemplo de código a seguir, a solicitação consiste em um único registro e a resposta são valores de probabilidade de um modelo multiclasse contendo três classes.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
0.1,0.6,0.3
```
No exemplo de código a seguir, a solicitação consiste em dois registros e a resposta inclui seus valores de probabilidade de um modelo multiclasse contendo três classes.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
0.1,0.6,0.3
0.2,0.5,0.3
```
No exemplo de código a seguir, a solicitação consiste em dois registros e a resposta inclui rótulo e probabilidade previstos.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
1,0.6
0,0.3
```
No exemplo de código a seguir, a solicitação consiste em dois registros e a resposta inclui cabeçalhos de rótulos e probabilidades.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
"['cat','dog','fish']","[0.1,0.6,0.3]"
"['cat','dog','fish']","[0.2,0.5,0.3]"
```
## Solicitação e resposta de endpoint em formato JSON Lines
No exemplo de código a seguir, a solicitação consiste em um único registro e a resposta é seu valor de probabilidade.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
{"score":0.6}
```
No exemplo de código a seguir, a solicitação contém dois registros e a resposta inclui rótulo e probabilidade previstos.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
{"predicted_label":1,"probability":0.6}
{"predicted_label":0,"probability":0.3}
```
No exemplo de código a seguir, a solicitação contém dois registros e a resposta inclui cabeçalhos de rótulos e probabilidades.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}
```
## Solicitação e resposta do endpoint em formatos mistos
No exemplo de código a seguir, a solicitação está no formato CSV e a resposta está no formato JSON Lines.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
{"probability":0.6}
{"probability":0.3}
```
No exemplo de código a seguir, a solicitação está no formato JSON Lines e a resposta está no formato CSV.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
0.6
0.3
```
No exemplo de código a seguir, a solicitação está no formato CSV e a resposta está no formato JSON.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
{"predictions":[{"label":1,"score":0.6},{"label":0,"score":0.3}]}
```
# Requisitos de dados de imagens
Um trabalho de processamento do SageMaker Clarify fornece suporte para explicar imagens. Este tópico fornece os requisitos de formato de dados para dados de imagem. Para obter mais informações sobre o processamento de dados de imagem, consulte [Analise os dados da imagem para explicabilidade da visão computacional](clarify-processing-job-run.md#clarify-processing-job-run-cv).
Um conjunto de dados de imagem contém um ou mais arquivos de imagem. Para identificar um conjunto de dados de entrada para o trabalho de processamento do SageMaker Clarify, defina um `dataset_uri` parâmetro de configuração [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html#sagemaker-CreateProcessingJob-request-ProcessingInputs)nomeado `dataset` ou de análise como um prefixo URI do Amazon S3 dos seus arquivos de imagem.
Os formatos de arquivo de imagem e extensões de arquivo compatíveis estão listados na tabela a seguir.
| Formato de imagem | Extensão do arquivo |
| --- | --- |
| JPEG | jpg, jpeg |
| PNG | png |
Configure o parâmetro `dataset_type` da análise para o valor **application/x-image**. Como o tipo não é um formato de arquivo de imagem específico, `content_type` ele será usado para decidir o formato e a extensão do arquivo de imagem.
O trabalho de processamento do SageMaker Clarify carrega cada arquivo de imagem em uma [NumPymatriz](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html) tridimensional para processamento adicional. As três dimensões incluem altura, largura e valores RGB de cada pixel.
## Formato de solicitação do endpoint
O trabalho de processamento do SageMaker Clarify converte os dados RGB brutos de uma imagem em um formato de imagem compatível, como JPEG. Ele faz isso antes de enviar os dados ao endpoint para predições. Os formatos de imagem compatíveis são os seguintes:
| Formatos de dados | Tipo MIME | Extensão do arquivo |
| --- | --- | --- |
| JPEG | `image/jpeg` | jpg, jpeg |
| PNG | `image/png` | png |
| NPY | `application/x-npy` | Todas acima |
Especifique o formato de dados da carga útil da solicitação usando o parâmetro de configuração de análise `content_type`. Se o `content_type` não for fornecido, o formato de dados será padronizado como `image/jpeg`.
## Formato de resposta do endpoint
Ao receber a resposta de uma invocação de endpoint de inferência, o trabalho de processamento do SageMaker Clarify desserializa a carga útil da resposta e, em seguida, extrai as previsões dela.
### Problema de classificação de imagem
O formato de dados da carga útil da resposta deve ser especificado pelo parâmetro de configuração de análise accept\$1type. Se `accept_type` não for fornecido, o formato de dados será padronizado como `application/json`. Os formatos compatíveis são os mesmos descritos na **resposta do Endpoint para dados tabulares na seção de dados** tabulares.
Veja um [Inferência com o algoritmo de classificação de imagens](image-classification.md#IC-inference) exemplo de um algoritmo de classificação de imagens integrado com SageMaker IA que aceita uma única imagem e, em seguida, retorna uma matriz de valores de probabilidade (pontuações), cada um para uma classe.
Conforme mostrado na tabela a seguir, quando o parâmetro `content_type` é definido como `application/jsonlines`, a resposta é um objeto JSON.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Imagem única | '\$1"prediction":[0.1,0.6,0.3]\$1' |
No exemplo anterior, defina o `probability` parâmetro como JMESPath expressão “previsão” para extrair as pontuações.
Conforme mostrado na tabela a seguir, quando o parâmetro `content_type` é definido como `application/json`, a resposta é um objeto JSON.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Imagem única | '[0.1,0.6,0.3]' |
No exemplo anterior, `probability` defina a JMESPath expressão “[\$1]” para extrair todos os elementos da matriz. No exemplo anterior, [`0.1, 0.6, 0.3]` é extraído. Alternativamente, se você pular a configuração do parâmetro de configuração `probability`, todos os elementos da matriz também serão extraídos. Isso ocorre porque toda a carga útil é desserializada como as predições.
### Problema de detecção de objetos
A configuração de análise `accept_type` tem o padrão `application/json`, e o único formato compatível é o Object Detection Inference Format. Para obter mais informações sobre os formatos de resposta, consulte [Formatos de resposta](object-detection-in-formats.md#object-detection-recordio).
A tabela a seguir é um exemplo de resposta de um terminal que gera uma matriz. Cada elemento da matriz é uma matriz de valores contendo o índice da classe, a pontuação de confiança e as coordenadas da caixa delimitadora do objeto detectado.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Imagem única (um objeto) | '[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244]]' |
| Imagem única (dois objetos) | '[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475]]' |
A tabela a seguir é um exemplo de resposta de um endpoint que gera um objeto JSON com uma chave referente à matriz. Defina a configuração da análise `probability` com a chave “predição” para extrair os valores.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) |
| --- | --- |
| Imagem única (um objeto) | '\$1"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244]]\$1' |
| Imagem única (dois objetos) | '\$1"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475]]\$1' |
## Verifique previamente a solicitação e a resposta do endpoint para dados de imagem
Recomendamos que você implante seu modelo em um endpoint de inferência de SageMaker IA em tempo real e envie solicitações para o endpoint. Examine manualmente as solicitações e respostas. Certifique-se de que ambos estejam em conformidade com os requisitos na seção **Solicitação do Endpoint para dados de imagem** e **Resposta do Endpoint para dados de imagem**.
A seguir estão dois exemplos de código que mostram como enviar solicitações e examinar as respostas para problemas de classificação de imagens e detecção de objetos.
### Problema de classificação de imagem
O código de exemplo a seguir instrui um endpoint a ler um arquivo PNG e depois classificá-lo.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-image-classification \
--content-type "image/png" \
--accept "application/json" \
--body fileb://./test.png \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
[0.1,0.6,0.3]
```
### Problema de detecção de objetos
O código de exemplo a seguir instrui um endpoint a ler um arquivo JPEG e, em seguida, detectar os objetos nele contidos.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-object-detection \
--content-type "image/jpg" \
--accept "application/json" \
--body fileb://./test.jpg \
/dev/stderr 1>/dev/null
```
A partir do exemplo de código anterior, segue a saída da resposta.
```
{"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475],[4.0, 0.32643985450267792, 0.3677481412887573, 0.034883320331573486, 0.6318609714508057, 0.5967587828636169],[8.0, 0.22552496790885925, 0.6152569651603699, 0.5722782611846924, 0.882301390171051, 0.8985623121261597],[3.0, 0.42260299175977707, 0.019305512309074402, 0.08386176824569702, 0.39093565940856934, 0.9574796557426453]]}
```
# Dados de séries temporais
Os dados de séries temporais são dados que podem ser carregados em um quadro de dados tridimensional. No quadro, em cada “timestamp”, cada linha representa um registro de destino e, cada registro de destino, tem uma ou mais colunas. Os valores em cada célula do quadro de dados podem ser de tipos de dados numéricos, categóricos ou de texto.
## Pré-requisitos do conjunto de dados de séries temporais
Antes da análise, conclua as etapas de pré-processamento necessárias para preparar seus dados, como limpeza de dados ou engenharia de atributos. Você pode fornecer um ou vários conjuntos de dados. Se você fornecer vários conjuntos de dados, use um dos métodos a seguir para fornecê-los à tarefa de processamento do SageMaker Clarify:
+ Use uma configuração [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)nomeada `dataset` ou de análise `dataset_uri` para especificar o conjunto de dados principal. Para obter mais informações sobre `dataset_uri`, consulte a lista de parâmetros em [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
+ Use o parâmetro `baseline` fornecido no arquivo de configuração da análise. O conjunto de dados de linha de base é necessário para `static_covariates`, se estiver presente. Para obter mais informações sobre o arquivo de configuração de análise, incluindo exemplos, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
A tabela a seguir lista os formatos de dados compatíveis, suas extensões de arquivo e tipos de MIME.
| Formato de dados | Extensão do arquivo | Tipo MIME |
| --- | --- | --- |
| `item_records` | json | `application/json` |
| `timestamp_records` | json | `application/json` |
| `columns` | json | `application/json` |
O JSON é um formato flexível que pode representar qualquer nível de complexidade em seus dados estruturados. Conforme mostrado na tabela, o SageMaker Clarify oferece suporte aos formatos `item_records``timestamp_records`, `columns` e.
## Exemplos de configuração de conjuntos de dados de séries temporais
Esta seção mostra como definir uma configuração de análise usando `time_series_data_config` para dados de séries temporais no formato JSON. Suponha que você tenha um conjunto de dados com dois itens, cada um com um carimbo de data/hora (t), uma série temporal de destino (x), duas séries temporais relacionadas (r) e duas covariáveis estáticas (u), da seguinte forma:
t1 = [0,1,2], t2 = [2,3]
x1 = [5,6,4], x2 = [0,4]
r1 = [0,1,0], r21 = [1,1]
r12 = [0,0,0], r22 = [1,0]
u11 = -1, u21 = 0
u12 = 1, u22 = 2
Você pode codificar o conjunto de dados usando `time_series_data_config` de três maneiras diferentes, dependendo do `dataset_format`. As seções a seguir descrevem cada método.
### Configuração de dados de séries temporais quando `dataset_format` for `columns`
O exemplo a seguir usa o valor `columns` para `dataset_format`. O arquivo JSON a seguir representa o conjunto de dados anterior.
```
{
"ids": [1, 1, 1, 2, 2],
"timestamps": [0, 1, 2, 2, 3], # t
"target_ts": [5, 6, 4, 0, 4], # x
"rts1": [0, 1, 0, 1, 1], # r1
"rts2": [0, 0, 0, 1, 0], # r2
"scv1": [-1, -1, -1, 0, 0], # u1
"scv2": [1, 1, 1, 2, 2], # u2
}
```
Observe que os IDs dos itens são repetidos no campo `ids`. A implementação correta do `time_series_data_config` é mostrada a seguir:
```
"time_series_data_config": {
"item_id": "ids",
"timestamp": "timestamps",
"target_time_series": "target_ts",
"related_time_series": ["rts1", "rts2"],
"static_covariates": ["scv1", "scv2"],
"dataset_format": "columns"
}
```
### Configuração de dados de séries temporais quando `dataset_format` for `item_records`
O exemplo a seguir usa o valor `item_records` para `dataset_format`. O arquivo JSON a seguir representa o conjunto de dados.
```
[
{
"id": 1,
"scv1": -1,
"scv2": 1,
"timeseries": [
{"timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0},
{"timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0},
{"timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0}
]
},
{
"id": 2,
"scv1": 0,
"scv2": 2,
"timeseries": [
{"timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1},
{"timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0}
]
}
]
```
Cada item é representado como uma entrada separada no JSON. O trecho a seguir mostra o correspondente `time_series_data_config` (que usa JMESPath).
```
"time_series_data_config": {
"item_id": "[*].id",
"timestamp": "[*].timeseries[].timestamp",
"target_time_series": "[*].timeseries[].target_ts",
"related_time_series": ["[*].timeseries[].rts1", "[*].timeseries[].rts2"],
"static_covariates": ["[*].scv1", "[*].scv2"],
"dataset_format": "item_records"
}
```
### Configuração de dados de séries temporais quando `dataset_format` for `timestamp_record`
O exemplo a seguir usa o valor `timestamp_record` para `dataset_format`. O arquivo JSON a seguir representa o conjunto de dados anterior.
```
[
{"id": 1, "timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 2, "timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1, "svc1": 0, "svc2": 2},
{"id": 2, "timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0, "svc1": 0, "svc2": 2},
]
```
Cada entrada do JSON representa um único registro de data/hora e corresponde a um único item. A implementação de `time_series_data_config` é mostrada da seguinte forma:
```
{
"item_id": "[*].id",
"timestamp": "[*].timestamp",
"target_time_series": "[*].target_ts",
"related_time_series": ["[*].rts1"],
"static_covariates": ["[*].scv1"],
"dataset_format": "timestamp_records"
}
```
# Solicitações de endpoint para dados de séries temporais
Um trabalho de processamento do SageMaker Clarify serializa os dados em estruturas JSON arbitrárias (com o tipo MIME:). `application/json` Para fazer isso, você deve fornecer uma string de modelo para o `content_template` parâmetro de configuração da análise. Isso é usado pelo trabalho de processamento do SageMaker Clarify para criar a consulta JSON fornecida ao seu modelo. `content_template`contém um registro ou vários registros do seu conjunto de dados. Você também deve fornecer uma string de modelo para `record_template`, que é usada para construir a estrutura JSON de cada registro. Esses registros são, então, inseridos em `content_template`. Para obter mais informações sobre `content_type` ou `dataset_type`, consulte [Arquivos de configuração de análise](clarify-processing-job-configure-analysis.md).
**nota**
Como `content_template` e `record_template` são parâmetros de string, qualquer caractere de aspa dupla (") que faça parte da estrutura serializada do JSON deve ser anotado como um caractere de escape em sua configuração. Por exemplo, se você quiser escapar uma aspa dupla em Python, você pode inserir o seguinte valor para `content_template`:
```
'$record'
```
A tabela a seguir mostra exemplos de cargas úteis de solicitações JSON serializadas e os parâmetros `content_template` e `record_template` correspondentes que são necessários para a construção.
| Caso de uso | Carga útil da solicitação de endpoint (representação de string) | content\$1template | record\$1template |
| --- | --- | --- | --- |
| Um único registro por vez | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Registro único com `$related_time_series` e `$static_covariates` | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
| Vários registros | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00"}]}` | `'{"instances": $records}'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Vários registros com `$related_time_series` e `$static_covariates` | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}]}` | `'{"instances": $records}'` | `''{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
# Resposta do endpoint para dados de séries temporais
O trabalho de processamento do SageMaker Clarify desserializa toda a carga como JSON. Em seguida, ele extrai as previsões dos dados desserializados usando JMESPath expressões fornecidas na configuração da análise. Os registros na carga útil da resposta devem corresponder aos registros na carga útil da solicitação.
A tabela a seguir é um exemplo de resposta de um endpoint que gera apenas o valor médio da predição. O valor de `forecast` usado no `predictor` campo na [configuração da análise](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-configure-analysis.html#clarify-processing-job-configure-analysis-parameters) deve ser fornecido como uma JMESPath expressão para encontrar o resultado da previsão para o trabalho de processamento.
| Carga útil da solicitação de endpoint | Carga útil da resposta do endpoint (representação de string) | JMESPath expressão para previsão na configuração de análise |
| --- | --- | --- |
| Exemplo de registro único. Configuração deve ser `TimeSeriesModelConfig(forecast="prediction.mean")` para extrair a predição corretamente. | `'{"prediction": {"mean": [1, 2, 3, 4, 5]}'` | `'prediction.mean'` |
| Para vários registros. Uma resposta de endpoint AWS DeepAR. | `'{"predictions": [{"mean": [1, 2, 3, 4, 5]}, {"mean": [1, 2, 3, 4, 5]}]}'` | `'predictions[*].mean'` |
# Verifique previamente a solicitação e a resposta do endpoint para dados de séries temporais
É recomendável implantar seu modelo em um endpoint de inferência de SageMaker IA em tempo real e enviar solicitações para o endpoint. Examine manualmente as solicitações e respostas para garantir que ambas estejam em conformidade com os requisitos das seções [Solicitações de endpoint para dados de séries temporais](clarify-processing-job-data-format-time-series-request-jsonlines.md) e [Resposta do endpoint para dados de séries temporais](clarify-processing-job-data-format-time-series-response-json.md). Se o seu contêiner de modelo oferecer compatibilidade com solicitações em lote, você poderá começar com uma única solicitação de registro e, em seguida, tentar dois ou mais registros.
Os comandos a seguir demonstram como solicitar uma resposta usando a AWS CLI. O AWS CLI vem pré-instalado nas instâncias Studio e SageMaker Notebook. Para instalar o AWS CLI, siga o [guia de instalação](https://aws.amazon.com//cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Os parâmetros são definidos da seguinte forma:
+ \$1ENDPOINT NAME: o nome do endpoint.
+ \$1CONTENT\$1TYPE: o tipo MIME da solicitação (entrada do contêiner do modelo).
+ \$1ACCEPT\$1TYPE: o tipo MIME da resposta (saída do contêiner do modelo).
+ \$1REQUEST\$1DATA: a string de carga útil solicitada.
+ \$1CLI\$1BINARY\$1FORMAT: o formato do parâmetro da interface de linha de comandos (CLI). Para AWS CLI v1, esse parâmetro deve permanecer em branco. Para v2, esse parâmetro deve ser definido como `--cli-binary-format raw-in-base64-out`.
**nota**
AWS CLI A v2 passa parâmetros binários como strings codificadas em base64 por padrão. Os exemplos de solicitação e resposta a seguir de e para o endpoint usam AWS CLI v1.
------
#### [ Example 1 ]
No exemplo de código a seguir, a solicitação consiste de um único registro.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json \
--content-type application/json \
--accept application/json \
--body '{"target": [1, 2, 3, 4, 5],
"start": "2024-01-01 01:00:00"}' \
/dev/stderr 1>/dev/null
```
O trecho a seguir mostra a saída correspondente da resposta.
```
{'predictions': {'mean': [1, 2, 3, 4, 5]}
```
------
#### [ Example 2 ]
No exemplo de código a seguir, a solicitação contém dois registros.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json-2 \
--content-type application/json \
--accept application/json \
--body $'{"instances": [{"target":[1, 2, 3],
"start":"2024-01-01 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}], {"target":[1, 2, 3],
"start":"2024-01-02 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}]}' \
dev/stderr 1>/dev/null
```
A seguir, está a saída resultante:
```
{'predictions': [{'mean': [1, 2, 3, 4, 5]}, {'mean': [1, 2, 3, 4, 5]}]}
```
------