

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

# Execução de trabalhos de inferência em lote
<a name="autopilot-deploy-models-batch"></a>

A inferência em lote, também conhecida como inferência offline, gera predições de modelo em um lote de observações. A inferência em lote é uma boa opção para grandes conjuntos de dados ou se você não precisar de uma resposta imediata a uma solicitação de predição de modelo. Por outro lado, a inferência online ([inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-deploy-models.html#autopilot-deploy-models-realtime)) gera predições em tempo real. Você pode fazer inferências em lote a partir de um modelo do Autopilot usando o [SDK do SageMaker Python](https://sagemaker.readthedocs.io/en/stable/), a interface de usuário (UI) do Autopilot, o SDK [AWS para Python](https://aws.amazon.com/sdk-for-python/) (boto3) ou o (). AWS Command Line Interface [AWS CLI](https://docs.aws.amazon.com/cli/)

As guias a seguir mostram três opções para implantar seu modelo: Usando APIs, interface do piloto automático ou usando APIs para implantar a partir de contas diferentes. Estas instruções supõem que você já criou um modelo no Autopilot. Se você não tem um modelo, consulte [Crie trabalhos de regressão ou classificação para dados tabulares com a API do AutoML](autopilot-automate-model-development-create-experiment.md). Para ver exemplos de cada opção, abra cada guia.

## Implemente um modelo usando a interface do Autopilot
<a name="autopilot-deploy-models-batch-ui"></a>

A interface do usuário do Autopilot contém menus suspensos úteis, botões de alternância, dicas de ferramentas e muito mais para ajudá-lo(a) a navegar pela implantação do modelo.

As etapas a seguir mostram como implantar um modelo de um experimento do Autopilot para predições em lote. 

1. Faça login em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)e selecione **Studio** no painel de navegação.

1. No painel de navegação à esquerda, escolha **Studio**.

1. Em **Comece a usar**, selecione o domínio no qual você deseja iniciar a aplicação Studio. Se o seu perfil de usuário pertencer apenas a um domínio, você não verá a opção para selecionar um domínio.

1. Selecione o perfil de usuário para o qual você deseja iniciar a aplicação do Studio Classic. Se não houver perfil de usuário no domínio, escolha **Criar perfil de usuário**. Para obter mais informações, consulte [Adicionar perfis de usuário](https://docs.aws.amazon.com/sagemaker/latest/dg/domain-user-profile-add.html).

1. Escolha **Executar o Studio**. Se o perfil do usuário pertencer a um espaço compartilhado, escolha **Espaços abertos**. 

1. Quando o console do SageMaker Studio Classic abrir, escolha o botão **Launch SageMaker Studio**.

1. Selecione **AutoML** no painel de navegação à esquerda.

1. Em **Nome**, selecione o experimento do Autopilot correspondente ao modelo que você deseja implantar. Isso abre uma nova guia de **trabalhos do Autopilot**.

1. Na seção **Nome do modelo**, selecione o modelo que deseja implantar.

1. Escolha **Implantar modelo**. Isso abre uma nova guia.

1. Escolha **Make batch predictions (Fazer predições em lote)** na parte superior da página.

1. Para a **configuração do trabalho de transformação de lotes**, insira **o tipo de instância**, **Contagem de instâncias** e outras informações opcionais.

1. Na seção **Configuração de dados de entrada**, abra o menu suspenso. 

   1. Para o **tipo de dados S3**, escolha **ManifestFile**ou **S3Prefix**.

   1. **Para **Tipo de divisão**, escolha **Linha**, **Recordio **TFRecord****ou Nenhum.**

   1. Para **Compactação**, escolha **Gzip** ou **Nenhuma**. 

1. Para a **localização do S3**, insira o local do bucket do Amazon S3 dos dados de entrada e outras informações opcionais.

1. Em **Configuração de dados de saída**, insira o bucket do S3 para os dados de saída e escolha como [montar a saída](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#sagemaker-Type-TransformOutput-AssembleWith) do seu trabalho. 

   1. Para **Configuração adicional (opcional)**, você pode inserir um tipo MIME e uma **Chave de criptografia S3**.

1. Para **filtragem de entrada/saída e junções de dados (opcional)**, você insere uma JSONpath expressão para filtrar os dados de entrada, une os dados da fonte de entrada aos dados de saída e insere uma JSONpath expressão para filtrar os dados de saída. 

   1. Para ver exemplos de cada tipo de filtro, consulte a [DataProcessing API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html#sagemaker-Type-DataProcessing-InputFilter).

1. Para realizar predições em lote no seu conjunto de dados de entrada, selecione **Criar tarefa de transformação em lote**. Uma nova guia **Trabalhos de transformação de lotes** é exibida.

1. Na guia **Trabalhos de transformação de lotes**: Localize o nome do seu trabalho na seção **Status**. Em seguida, verifique o progresso do trabalho. 

## Implemente usando SageMaker APIs
<a name="autopilot-deploy-models-batch-steps"></a>

Para usar o SageMaker APIs para inferência em lote, há três etapas:

1. **Obtenha definições de candidatos** 

   As definições de candidatos de [InferenceContainers](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLCandidate.html#sagemaker-Type-AutoMLCandidate-InferenceContainers)são usadas para criar um modelo de SageMaker IA. 

   O exemplo a seguir mostra como usar a [DescribeAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJob.html)API para obter definições de candidatos para o melhor candidato a modelo. Veja o AWS CLI comando a seguir como exemplo.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name {{<job-name>}} --region {{<region>}}
   ```

   Use a [ListCandidatesForAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListCandidatesForAutoMLJob.html)API para listar todos os candidatos. O comando da AWS CLI a seguir é um exemplo.

   ```
   aws sagemaker list-candidates-for-auto-ml-job --auto-ml-job-name {{<job-name>}} --region {{<region>}}
   ```

1. **Crie um modelo de SageMaker IA**

   Para criar um modelo de SageMaker IA usando a [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, use as definições de contêiner das etapas anteriores. O comando da AWS CLI a seguir é um exemplo.

   ```
   aws sagemaker create-model --model-name '{{<your-custom-model-name>}}' \
                       --containers ['{{<container-definition1}}>, {{<container-definition2>}}, {{<container-definition3>}}]' \
                       --execution-role-arn '{{<execution-role-arn>}}' --region '{{<region>}}
   ```

1. **Crie um trabalho de transformação da SageMaker IA** 

   O exemplo a seguir cria um trabalho de transformação de SageMaker IA com a [CreateTransformJob](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-transform-job.html)API. Veja o AWS CLI comando a seguir como exemplo.

   ```
   aws sagemaker create-transform-job --transform-job-name '{{<your-custom-transform-job-name>}}' --model-name '{{<your-custom-model-name-from-last-step>}}'\
   --transform-input '{
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix", 
                   "S3Uri": "{{<your-input-data>}}" 
               }
           },
           "ContentType": "{{text/csv}}",
           "SplitType": "Line"
       }'\
   --transform-output '{
           "S3OutputPath": "{{<your-output-path>}}",
           "AssembleWith": "Line" 
       }'\
   --transform-resources '{
           "InstanceType": "{{<instance-type>}}", 
           "InstanceCount": {{1}}
       }' --region '{{<region>}}'
   ```

Verifique o progresso do seu trabalho de transformação usando a [DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)API. Veja o AWS CLI comando a seguir como exemplo.

```
aws sagemaker describe-transform-job --transform-job-name '{{<your-custom-transform-job-name>}}' --region {{<region>}}
```

Depois que o trabalho for concluído, o resultado previsto estará disponível em `<your-output-path>`. 

O nome do arquivo resultante tem o seguinte formato: `<input_data_file_name>.out`. Por exemplo, se seu arquivo de entrada for `text_x.csv`, o nome de saída será `text_x.csv.out`.

As guias a seguir mostram exemplos de código para SageMaker Python SDK, AWS SDK for Python (boto3) e o. AWS CLI

------
#### [ SageMaker Python SDK ]

O exemplo a seguir usa o **[SDK do SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html)** para fazer previsões em lotes.

```
from sagemaker import AutoML

sagemaker_session= sagemaker.session.Session()

job_name = '{{test-auto-ml-job}}' # your autopilot job name
automl = AutoML.attach(auto_ml_job_name=job_name)
output_path = '{{s3://test-auto-ml-job/output}}'
input_data = '{{s3://test-auto-ml-job/test_X.csv}}'

# call DescribeAutoMLJob API to get the best candidate definition
best_candidate = automl.describe_auto_ml_job()['BestCandidate']
best_candidate_name = best_candidate['CandidateName']

# create model
model = automl.create_model(name=best_candidate_name, 
               candidate=best_candidate)

# create transformer
transformer = model.transformer(instance_count={{1}}, 
    instance_type='{{ml.m5.2xlarge}}',
    assemble_with='Line',
    output_path=output_path)

# do batch transform
transformer.transform(data=input_data,
                      split_type='Line',
                       content_type='{{text/csv}}',
                       wait=True)
```

------
#### [ AWS SDK for Python (boto3) ]

 O exemplo a seguir usa o **AWS SDK para Python (boto3)** para fazer predições em lotes.

```
import sagemaker 
import boto3

session = sagemaker.session.Session()

sm_client = boto3.client('sagemaker', region_name='{{us-west-2}}')
role = '{{arn:aws:iam::1234567890:role/sagemaker-execution-role}}'
output_path = '{{s3://test-auto-ml-job/output}}'
input_data = '{{s3://test-auto-ml-job/test_X.csv}}'

best_candidate = sm_client.describe_auto_ml_job(AutoMLJobName=job_name)['BestCandidate']
best_candidate_containers = best_candidate['InferenceContainers']
best_candidate_name = best_candidate['CandidateName']

# create model
reponse = sm_client.create_model(
    ModelName = best_candidate_name,
    ExecutionRoleArn = role,
    Containers = best_candidate_containers 
)

# Lauch Transform Job
response = sm_client.create_transform_job(
    TransformJobName=f'{best_candidate_name}-transform-job',
    ModelName=model_name,
    TransformInput={
        'DataSource': {
            'S3DataSource': {
                'S3DataType': 'S3Prefix',
                'S3Uri': input_data
            }
        },
        'ContentType': "{{text/csv}}",
        'SplitType': 'Line'
    },
    TransformOutput={
        'S3OutputPath': output_path,
        'AssembleWith': 'Line',
    },
    TransformResources={
        'InstanceType': '{{ml.m5.2xlarge}}',
        'InstanceCount': {{1}},
    },
)
```

O trabalho de inferência em lote retorna uma resposta no formato a seguir.

```
{'TransformJobArn': '{{arn:aws:sagemaker:us-west-2:1234567890:transform-job/test-transform-job}}',
 'ResponseMetadata': {'RequestId': '659f97fc-28c4-440b-b957-a49733f7c2f2',
  'HTTPStatusCode': 200,
  'HTTPHeaders': {'x-amzn-requestid': '659f97fc-28c4-440b-b957-a49733f7c2f2',
   'content-type': 'application/x-amz-json-1.1',
   'content-length': '96',
   'date': 'Thu, 11 Aug 2022 22:23:49 GMT'},
  'RetryAttempts': 0}}
```

------
#### [ AWS Command Line Interface (AWS CLI) ]

1. **Obtenha as definições do candidato** usando o exemplo de código a seguir.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name '{{test-automl-job}}' --region {{us-west-2}}
   ```

1. **Crie o modelo** usando o exemplo de código a seguir.

   ```
   aws sagemaker create-model --model-name '{{test-sagemaker-model}}'
   --containers '[{
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3",
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/data-processor-models/test-job1-dpp0-1-e569ff7ad77f4e55a7e549a/output/model.tar.gz}}",
       "Environment": {
           "AUTOML_SPARSE_ENCODE_RECORDIO_PROTOBUF": "1",
           "AUTOML_TRANSFORM_MODE": "feature-transform",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "application/x-recordio-protobuf",
           "SAGEMAKER_PROGRAM": "sagemaker_serve",
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code"
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-xgboost:1.3-1-cpu-py3",
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/tuning/flicdf10v2-dpp0-xgb/test-job1E9-244-7490a1c0/output/model.tar.gz}}",
       "Environment": {
           "MAX_CONTENT_LENGTH": "20971520",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv",
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,probabilities" 
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3", 
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/data-processor-models/test-job1-dpp0-1-e569ff7ad77f4e55a7e549a/output/model.tar.gz}}", 
       "Environment": { 
           "AUTOML_TRANSFORM_MODE": "inverse-label-transform", 
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv", 
           "SAGEMAKER_INFERENCE_INPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,labels,probabilities", 
           "SAGEMAKER_PROGRAM": "sagemaker_serve", 
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code" 
       } 
   }]' \
   --execution-role-arn '{{arn:aws:iam::1234567890:role/sagemaker-execution-role}}' \
   --region '{{us-west-2}}'
   ```

1. **Crie o trabalho de transformação** usando o exemplo de código a seguir.

   ```
   aws sagemaker create-transform-job --transform-job-name '{{test-tranform-job}}'\
    --model-name '{{test-sagemaker-model}}'\
   --transform-input '{
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix",
                   "S3Uri": "{{s3://amzn-s3-demo-bucket/data.csv}}"
               }
           },
           "ContentType": "{{text/csv}}",
           "SplitType": "Line"
       }'\
   --transform-output '{
           "S3OutputPath": "{{s3://amzn-s3-demo-bucket/output/}}",
           "AssembleWith": "Line"
       }'\
   --transform-resources '{
           "InstanceType": "{{ml.m5.2xlarge}}",
           "InstanceCount": {{1}}
       }'\
   --region '{{us-west-2}}'
   ```

1. **Verifique o progresso do trabalho de transformação** usando o exemplo de código a seguir. 

   ```
   aws sagemaker describe-transform-job --transform-job-name  '{{test-tranform-job}}' --region {{us-west-2}}
   ```

   A seguir está a resposta do trabalho de transformação.

   ```
   {
       "TransformJobName": "{{test-tranform-job}}",
       "TransformJobArn": "{{arn:aws:sagemaker:us-west-2:1234567890:transform-job/test-tranform-job}}",
       "TransformJobStatus": "InProgress",
       "ModelName": "{{test-model}}",
       "TransformInput": {
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix",
                   "S3Uri": "{{s3://amzn-s3-demo-bucket/data.csv}}"
               }
           },
           "ContentType": "{{text/csv}}",
           "CompressionType": "None",
           "SplitType": "Line"
       },
       "TransformOutput": {
           "S3OutputPath": "{{s3://amzn-s3-demo-bucket/output/}}",
           "AssembleWith": "Line",
           "KmsKeyId": ""
       },
       "TransformResources": {
           "InstanceType": "{{ml.m5.2xlarge}}",
           "InstanceCount": {{1}}
       },
       "CreationTime": 1662495635.679,
       "TransformStartTime": 1662495847.496,
       "DataProcessing": {
           "InputFilter": "$",
           "OutputFilter": "$",
           "JoinSource": "None"
       }
   }
   ```

   Depois de `TransformJobStatus` ser alterado para `Completed`, você pode verificar o resultado da inferência no `S3OutputPath`.

------

## Implementar modelos de contas diferentes
<a name="autopilot-deploy-models-batch-across-accounts"></a>

Para criar um trabalho de inferência em lote em uma conta diferente daquela em que o modelo foi gerado, siga as instruções em [Implemente modelos de contas diferentes](autopilot-deploy-models-realtime.md#autopilot-deploy-models-realtime-across-accounts). Em seguida, você pode criar modelos e transformar trabalhos seguindo o [Implemente usando SageMaker APIs](#autopilot-deploy-models-batch-steps).