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