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á.
# Implantação e predição de modelos do Autopilot
Este guia do Amazon SageMaker Autopilot inclui etapas para implantação de modelos, configuração de inferência em tempo real e execução de inferência com trabalhos em lote.
Depois de criar e treinar seus modelos, você poderá implantá-los para obter predições de duas maneiras:
1. Use [Implantar modelos para inferência em tempo real](autopilot-deploy-models-realtime.md) para configurar um endpoint e obter predições de forma interativa. A inferência em tempo real é ideal para workloads de inferência em que você tem requisitos em tempo real, interativos e de baixa latência.
1. Use [Execução de trabalhos de inferência em lote](autopilot-deploy-models-batch.md) para fazer predições paralelas em lotes de observações em um conjunto de dados inteiro. 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.
**nota**
Para evitar cobranças desnecessárias: depois que os endpoints e os recursos criados a partir da implantação do modelo não forem mais necessários, você poderá excluí-los. Para obter informações sobre preços de instâncias por região, consulte [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
# Implantar modelos para inferência em tempo real
A inferência em tempo real é ideal para workloads de inferência em que você tem requisitos em tempo real, interativos e de baixa latência. Esta seção mostra como você pode usar a inferência em tempo real para obter predições do seu modelo de forma interativa.
Para implantar o modelo que produziu a melhor métrica de validação em um experimento do Autopilot, você tem várias opções. Por exemplo, ao usar o Autopilot no SageMaker Studio Classic, você pode implantar o modelo automática ou manualmente. Você também pode usar SageMaker APIs para implantar manualmente um modelo de piloto automático.
As guias a seguir mostram três opções para implantar seu modelo. 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 usando a interface de usuário (UI) do Autopilot
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. Você pode implantar usando um dos seguintes procedimentos: automático ou manual.
+ **Implantação automática**: para implantar automaticamente o melhor modelo de um experimento do Autopilot em um endpoint
1. [Crie um experimento](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development-create-experiment.html) no SageMaker Studio Classic.
1. Mude o valor de **Implantação automática** para **Sim**.
**nota**
**A implantação automática falhará se a cota de recursos padrão ou a cota de clientes para instâncias de endpoint em uma região for muito limitada.** No modo de otimização de hiperparâmetros (HPO), você precisa ter pelo menos duas instâncias ml.m5.2xlarge. No modo de agrupamento, você precisa ter pelo menos uma instância ml.m5.12xlarge. Se você encontrar uma falha relacionada às cotas, poderá [solicitar um aumento do limite de serviço](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) para instâncias de endpoint de SageMaker IA.
+ **Implantação manual**: para implantar manualmente o melhor modelo de um experimento do Autopilot em um endpoint
1. [Crie um experimento](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development-create-experiment.html) no SageMaker Studio Classic.
1. Mude o valor de **Implantação automática** para **Não**.
1. Selecione o modelo que deseja implantar em **Nome do modelo**.
1. Selecione o botão laranja de **Implantação e configurações avançadas** localizado à direita do placar. Isso abre uma nova guia.
1. Configure o nome do endpoint, o tipo de instância e outras informações opcionais.
1. Selecione o botão laranja **Implantar modelo** para implantar em um endpoint.
1. Verifique o progresso do processo de criação do endpoint no [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)navegando até a seção Endpoints. Essa seção está localizada no menu suspenso **Inferência** no painel de navegação.
1. Depois que o status do endpoint mudar de **Creating** para **InService**, conforme mostrado abaixo, retorne ao Studio Classic e invoque o endpoint.
![\[SageMaker Console de IA: página de endpoints para criar um endpoint ou verificar o status do endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/autopilot/autopilot-check-progress.PNG)
## Implemente usando SageMaker APIs
Você também pode obter inferência em tempo real implantando seu modelo usando **chamadas de API**. Esta seção mostra as cinco etapas desse processo usando trechos de código AWS Command Line Interface (AWS CLI).
Para obter exemplos de código completos para AWS CLI comandos e AWS SDK para Python (boto3), abra as guias diretamente seguindo estas etapas.
1. **Obtenha definições de candidatos**
Obtenha as definições do contêiner candidato em [InferenceContainers](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLCandidate.html#sagemaker-Type-AutoMLCandidate-InferenceContainers). Essas definições de candidatos são usadas para criar um modelo de SageMaker IA.
O exemplo a seguir usa a [DescribeAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJob.html)API para obter as definições do candidato ao melhor modelo. Veja o AWS CLI comando a seguir como exemplo.
```
aws sagemaker describe-auto-ml-job --auto-ml-job-name --region
```
1. **Listar candidatos**
O exemplo a seguir usa 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 --region
```
1. **Crie um modelo de SageMaker IA**
Use as definições de contêiner das etapas anteriores para criar um modelo de SageMaker IA usando a [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API. Veja o AWS CLI comando a seguir como exemplo.
```
aws sagemaker create-model --model-name '' \
--containers [', , ]' \
--execution-role-arn '' --region '
```
1. **Criar uma configuração de endpoint**
O exemplo a seguir usa a [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API para criar uma configuração de endpoint. Veja o AWS CLI comando a seguir como exemplo.
```
aws sagemaker create-endpoint-config --endpoint-config-name '' \
--production-variants '' \
--region ''
```
1. **Criar o endpoint**
O AWS CLI exemplo a seguir usa a [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API para criar o endpoint.
```
aws sagemaker create-endpoint --endpoint-name '' \
--endpoint-config-name '' \
--region ''
```
Verifique o progresso da implantação do seu endpoint usando a [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API. Veja o AWS CLI comando a seguir como exemplo.
```
aws sagemaker describe-endpoint —endpoint-name '' —region
```
Depois que `EndpointStatus` muda para `InService`, o endpoint está pronto para ser usado para inferência em tempo real.
1. **Invocar o endpoint**
A estrutura de comando a seguir invoca o endpoint para inferência em tempo real.
```
aws sagemaker invoke-endpoint --endpoint-name '' \
--region '' --body '' [--content-type] ''
```
As guias a seguir contêm exemplos de código completos para implantar um modelo com o SDK AWS para Python (boto3) ou AWS CLI.
------
#### [ AWS SDK for Python (boto3) ]
1. **Obtenha as definições do candidato** usando o exemplo de código a seguir.
```
import sagemaker
import boto3
session = sagemaker.session.Session()
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
job_name = 'test-auto-ml-job'
describe_response = sm_client.describe_auto_ml_job(AutoMLJobName=job_name)
# extract the best candidate definition from DescribeAutoMLJob response
best_candidate = describe_response['BestCandidate']
# extract the InferenceContainers definition from the caandidate definition
inference_containers = best_candidate['InferenceContainers']
```
1. **Crie o modelo** usando o exemplo de código a seguir.
```
# Create Model
model_name = 'test-model'
sagemaker_role = 'arn:aws:iam:444455556666:role/sagemaker-execution-role'
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
Containers = inference_containers
)
```
1. **Crie a configuração de endpoint** usando o exemplo de código a seguir.
```
endpoint_config_name = 'test-endpoint-config'
instance_type = 'ml.m5.2xlarge'
# for all supported instance types, see
# https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html#sagemaker-Type-ProductionVariant-InstanceType # Create endpoint config
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": "variant1",
"ModelName": model_name,
"InstanceType": instance_type,
"InitialInstanceCount": 1
}
]
)
print(f"Created EndpointConfig: {endpoint_config_response['EndpointConfigArn']}")
```
1. **Crie o endpoint** e implante o modelo com o exemplo de código a seguir.
```
# create endpoint and deploy the model
endpoint_name = 'test-endpoint'
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
print(create_endpoint_response)
```
**Verifique o status da criação do endpoint** usando o exemplo de código a seguir.
```
# describe endpoint creation status
status = sagemaker_client.describe_endpoint(EndpointName=endpoint_name)["EndpointStatus"]
```
1. **Invoque o endpoint** para inferência em tempo real usando a estrutura de comando a seguir.
```
# once endpoint status is InService, you can invoke the endpoint for inferencing
if status == "InService":
sm_runtime = boto3.Session().client('sagemaker-runtime')
inference_result = sm_runtime.invoke_endpoint(EndpointName='test-endpoint', ContentType='text/csv', Body='1,2,3,4,class')
```
------
#### [ 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", amzn-s3-demo-bucket1
"ModelDataUrl": "s3://amzn-s3-demo-bucket/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/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", aws-region
"ModelDataUrl": "s3://amzn-s3-demo-bucket/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'
```
Para obter detalhes adicionais, consulte [Criando um modelo](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker/create-model.html).
O comando da `create model` responderá no formato a seguir.
```
{
"ModelArn": "arn:aws:sagemaker:us-west-2:1234567890:model/test-sagemaker-model"
}
```
1. **Crie a configuração de endpoint** usando o exemplo de código a seguir.
```
aws sagemaker create-endpoint-config --endpoint-config-name 'test-endpoint-config' \
--production-variants '[{"VariantName": "variant1",
"ModelName": "test-sagemaker-model",
"InitialInstanceCount": 1,
"InstanceType": "ml.m5.2xlarge"
}]' \
--region us-west-2
```
O comando de configuração `create endpoint` responderá no formato a seguir.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint-config/test-endpoint-config"
}
```
1. **Crie um endpoint** usando o exemplo de código a seguir.
```
aws sagemaker create-endpoint --endpoint-name 'test-endpoint' \
--endpoint-config-name 'test-endpoint-config' \
--region us-west-2
```
O comando da `create endpoint` responderá no formato a seguir.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint/test-endpoint"
}
```
Verifique o progresso da implantação do endpoint usando o seguinte exemplo de código da CLI [describe-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint.html):
```
aws sagemaker describe-endpoint --endpoint-name 'test-endpoint' --region us-west-2
```
A verificação de progresso anterior responderá no formato a seguir.
```
{
"EndpointName": "test-endpoint",
"EndpointArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint/test-endpoint",
"EndpointConfigName": "test-endpoint-config",
"EndpointStatus": "Creating",
"CreationTime": 1660251167.595,
"LastModifiedTime": 1660251167.595
}
```
Depois das alterações `EndpointStatus` para `InService`, o endpoint está pronto para uso em inferência em tempo real.
1. **Invoque o endpoint** para inferência em tempo real usando a estrutura de comando a seguir.
```
aws sagemaker-runtime invoke-endpoint --endpoint-name 'test-endpoint' \
--region 'us-west-2' \
--body '1,51,3.5,1.4,0.2' \
--content-type 'text/csv' \
'/tmp/inference_output'
```
Para obter mais opções, consulte [invocar um endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker-runtime/invoke-endpoint.html).
------
## Implemente modelos de contas diferentes
Você pode implantar um modelo do Autopilot a partir de uma conta diferente da conta original na qual o modelo foi gerado. Para implementar a implantação do modelo entre contas, esta seção mostra como fazer o seguinte: Conceda permissão para assumir a função na conta da qual você deseja implantar (a conta geradora). Faça uma chamada para a conta `DescribeAutoMLJob` de implantação para obter informações do modelo. Conceder direitos de acesso aos artefatos do modelo da conta geradora.
1. **Conceder permissão à conta de implantação**
Para assumir a função na conta geradora, você deve dar permissão para a conta de implantação. Isso permite que a conta de implantação descreva as tarefas do Autopilot na conta geradora.
O exemplo a seguir usa uma conta geradora com uma entidade `sagemaker-role` confiável. O exemplo mostra como dar permissão a uma conta de implantação com o ID 111122223333 para assumir a função da conta geradora.
```
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"sagemaker.amazonaws.com"
],
"AWS": [ "111122223333"]
},
"Action": "sts:AssumeRole"
}
```
A nova conta com o ID 111122223333 agora pode assumir a função da conta geradora.
Em seguida, chame a API `DescribeAutoMLJob` da conta de implantação para obter uma descrição do trabalho criado pela conta geradora.
O exemplo de código a seguir descreve o modelo da conta de implantação.
```
import sagemaker
import boto3
session = sagemaker.session.Session()
sts_client = boto3.client('sts')
sts_client.assume_role
role = 'arn:aws:iam::111122223333:role/sagemaker-role'
role_session_name = "role-session-name"
_assumed_role = sts_client.assume_role(RoleArn=role, RoleSessionName=role_session_name)
credentials = _assumed_role["Credentials"]
access_key = credentials["AccessKeyId"]
secret_key = credentials["SecretAccessKey"]
session_token = credentials["SessionToken"]
session = boto3.session.Session()
sm_client = session.client('sagemaker', region_name='us-west-2',
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
aws_session_token=session_token)
# now you can call describe automl job created in account A
job_name = "test-job"
response= sm_client.describe_auto_ml_job(AutoMLJobName=job_name)
```
1. **Conceda acesso à conta de implantação** aos artefatos do modelo na conta geradora.
Conceda acesso à conta de implantação somente aos artefatos do modelo na conta geradora para implantá-la. Eles estão localizados no [S3 OutputPath](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLOutputDataConfig.html#sagemaker-Type-AutoMLOutputDataConfig-S3OutputPath) que foi especificado na chamada de `CreateAutoMLJob` API original durante a geração do modelo.
Para dar acesso à conta de implantação aos artefatos do modelo, escolha uma das seguintes opções:
1. [Dê acesso](https://aws.amazon.com/premiumsupport/knowledge-center/cross-account-access-s3/) ao `ModelDataUrl` da conta geradora para a conta de implantação.
Em seguida, você precisa dar permissão à conta de implantação para assumir a função. Siga as etapas de [inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-deploy-models.html#autopilot-deploy-models-realtime) para implantar.
1. [Copie artefatos do modelo](https://aws.amazon.com/premiumsupport/knowledge-center/copy-s3-objects-account/) do [S3](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLOutputDataConfig.html#sagemaker-Type-AutoMLOutputDataConfig-S3OutputPath) original da conta geradora OutputPath para a conta geradora.
Para conceder acesso aos artefatos do modelo, defina um modelo `best_candidate` e reatribua os contêineres do modelo à nova conta.
O exemplo a seguir mostra como definir um modelo `best_candidate` e reatribuir o `ModelDataUrl`.
```
best_candidate = automl.describe_auto_ml_job()['BestCandidate']
# reassigning ModelDataUrl for best_candidate containers below
new_model_locations = ['new-container-1-ModelDataUrl', 'new-container-2-ModelDataUrl', 'new-container-3-ModelDataUrl']
new_model_locations_index = 0
for container in best_candidate['InferenceContainers']:
container['ModelDataUrl'] = new_model_locations[new_model_locations_index++]
```
Após essa atribuição de contêineres, siga as etapas em [Implemente usando SageMaker APIs](#autopilot-deploy-models-api) para implantar.
Para criar uma carga útil em inferência em tempo real, veja o exemplo do caderno para [definir uma carga útil de teste](https://aws.amazon.com/getting-started/hands-on/machine-learning-tutorial-automatically-create-models). Para criar a carga útil a partir de um arquivo CSV e invocar um endpoint, consulte a seção **Prever com seu modelo** em [Criar um modelo de machine learning automaticamente](https://aws.amazon.com/getting-started/hands-on/create-machine-learning-model-automatically-sagemaker-autopilot/#autopilot-cr-room).
# Execução de trabalhos de inferência em lote
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 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
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 --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 --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 '' \
--containers [', , ]' \
--execution-role-arn '' --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 '' --model-name ''\
--transform-input '{
"DataSource": {
"S3DataSource": {
"S3DataType": "S3Prefix",
"S3Uri": ""
}
},
"ContentType": "text/csv",
"SplitType": "Line"
}'\
--transform-output '{
"S3OutputPath": "",
"AssembleWith": "Line"
}'\
--transform-resources '{
"InstanceType": "",
"InstanceCount": 1
}' --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 '' --region
```
Depois que o trabalho for concluído, o resultado previsto estará disponível em ``.
O nome do arquivo resultante tem o seguinte formato: `.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
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).