Conceitos básicos / Tutorial prático / ...
Implantar um modelo de machine learning em um endpoint de inferência em tempo real
TUTORIAL
Visão geral
Neste tutorial, você aprenderá a implantar um modelo de machine learning (ML) treinado em um endpoint de inferência em tempo real usando o Amazon SageMaker Studio.
O SageMaker Studio é um ambiente de desenvolvimento integrado (IDE) para ML que fornece uma interface de caderno Jupyter totalmente gerenciada na qual você pode executar tarefas completas do ciclo de vida de ML, inclusive implantação de modelo.
O SageMaker oferece diferentes opções de inferência que auxiliam em uma ampla gama de casos de uso:
- SageMaker Real-Time Inference em tempo real para workloads com baixos requisitos de latência na ordem de milissegundos
- SageMaker Serverless Inference para workloads com padrões de tráfego intermitente ou pouco frequente
- SageMaker Asynchronous Inference para inferências com grandes tamanhos de carga útil ou que necessitam de longos tempos de processamento
- SageMaker Batch Transform para executar previsões em lotes de dados
Neste tutorial, você usará a opção Real-Time Inference para implantar um modelo do XGBoost de classificação binária que já foi treinado em um conjunto de dados sintéticos de solicitações de sinistro de seguro automotivo. O conjunto de dados consiste em detalhes e recursos extraídos sobre solicitações e clientes, com uma coluna fraud (fraude) indicando se a solicitação foi fraudulenta ou não. O modelo prevê a probabilidade de uma solicitação ser fraudulenta. Você fará o papel de um engenheiro de machine learning para implantar esse modelo e executar inferências de amostra.
O que você aprenderá
Neste guia, você vai:
- Criar um modelo do SageMaker com base em um artefato de modelo treinado
- Configurar e implantar um endpoint de inferência em tempo real para atender ao modelo
- Invocar o endpoint para executar previsões de amostra usando dados de teste
- Anexar uma política de escalabilidade automática ao endpoint para lidar com as alterações de tráfego
Pré-requisitos
Antes de iniciar este guia, você precisará de:
- Uma conta da AWS: caso ainda não tenha uma conta, siga o guia de conceitos básicos Setting Up Your Environment (Configurar seu ambiente) para obter uma breve visão geral.
AWS Experience
Iniciante
Tempo para a conclusão
25 minutos
Custo para a conclusão
Consulte os preços do SageMaker para estimar o custo deste tutorial.
Requisitos
É necessário se conectar a uma conta da AWS.
Serviços usados
Amazon SageMaker Real-time Inference, Amazon SageMaker Studio
Data da última atualização
19 de maio de 2022
Implementação
Etapa 1: configurar o domínio do Amazon SageMaker Studio
Com o Amazon SageMaker, é possível implantar um modelo visualmente pelo console ou de maneira programática com o SageMaker Studio ou blocos de anotações do SageMaker. Neste tutorial, implante o modelo de maneira programática usando um bloco de anotações do SageMaker Studio, que requer um domínio do SageMaker Studio.
Uma conta da AWS pode ter apenas um domínio do SageMaker Studio por região. Caso você já tenha um domínio do SageMaker Studio na região Leste dos EUA (Norte da Virgínia), siga o Guia de configuração do SageMaker Studio para anexar as políticas do AWS IAM necessárias à sua conta do SageMaker Studio, ignore a Etapa 1 e vá diretamente para a Etapa 2.
Caso não tenha um domínio SageMaker Studio, continue com os passos da Etapa 1 para executar um modelo do AWS CloudFormation que cria um domínio do SageMaker Studio e adiciona as permissões necessárias para finalizar este tutorial.
Escolha o link da pilha do AWS CloudFormation. Esse link abre o console do AWS CloudFormation e cria seu domínio do SageMaker Studio e um usuário chamado studio-user. Também adiciona as permissões necessárias à sua conta do SageMaker Studio. No console do CloudFormation, confirme se US East (N. Virginia) (Leste dos EUA [Norte da Virgínia]) é a Region (Região) exibida no canto superior direito. O Stack name (Nome da pilha) deve ser CFN-SM-IM-Lambda-Catalog e não poderá ser alterado. Essa pilha leva cerca de dez minutos para criar todos os recursos.
A pilha pressupõe que você já tenha uma VPC pública configurada na conta. Se você não tiver uma VPC pública, consulte VPC com uma única sub-rede pública para aprender a criar uma VPC pública.
Selecione I acknowledge that AWS CloudFormation might create IAM resources (Estou ciente de que o AWS CloudFormation pode criar recursos do IAM) e escolha Create stack (Criar pilha).
No painel do CloudFormation, escolha Stacks (Pilhas). A pilha leva cerca de dez minutos para ser criada. Quando a pilha é criada, o status da pilha é mudado de CREATE_IN_PROGRESS para CREATE_COMPLETE.
Etapa 2: configurar um bloco de anotações do SageMaker Studio
Nesta etapa, você executará um novo bloco de anotações do SageMaker Studio, instalará as bibliotecas de código aberto necessárias e configurará as variáveis do SageMaker necessárias para obter o artefato do modelo treinado do Amazon Simple Storage Service (Amazon S3). Mas como o artefato de modelo não pode ser implantado diretamente para inferência, primeiro é necessário criar um modelo do SageMaker com base no artefato do modelo. O modelo criado conterá o código de treinamento e inferência que o SageMaker usará para implantar o modelo.
Digite SageMaker Studio na barra de pesquisa do console e escolha SageMaker Studio.
Escolha US East (N. Virginia) (Leste dos EUA [Norte da Virgínia]) na lista suspensa Region (Região) no canto superior direito do console do SageMaker. Em Launch app (Iniciar aplicação), selecione Studio para abrir o SageMaker Studio usando o perfil studio-user.
Abra a interface do SageMaker Studio. Na barra de navegação, escolha File (Arquivo), New (Novo), Notebook (Bloco de anotações).
Na caixa de diálogo Set up notebook environment (Configurar ambiente de bloco de anotações), em Image (Imagem), selecione Data Science (Ciência de dados). O kernel Python 3 é selecionado automaticamente. Escolha Select .
O kernel no canto superior direito do bloco de anotações agora deverá exibir Python 3 (Data Science) (Ciência de dados).
Copie e cole o seguinte trecho de código em uma célula do bloco de anotações e pressione Shift+Enter para executar a célula atual para atualizar a biblioteca aiobotocore, que é uma API para interagir com muitos dos produtos da AWS. Ignore avisos para reiniciar o kernel ou qualquer erro de conflito de dependência.
%pip install --upgrade -q aiobotocoreTambém é necessário criar uma instância do objeto de cliente do S3 e definir os locais do bucket do S3 padrão em que métricas e artefatos de modelo serão carregados. Para isso, copie e cole o código a seguir em uma célula do bloco de anotações e execute-o. O bucket de gravação sagemaker-<your-Region>-<your-account-id> é criado automaticamente pelo objeto de sessão do SageMaker na linha 16 do código abaixo. Os conjuntos de dados que você usa para treinamento estão localizados em um bucket público do S3 chamado sagemaker-sample-files, que foi especificado como o bucket de leitura na linha 29. A localização dentro do bucket é especificada no prefixo de leitura.
import pandas as pd
import numpy as np
import boto3
import sagemaker
import time
import json
import io
from io import StringIO
import base64
import pprint
import re
from sagemaker.image_uris import retrieve
sess = sagemaker.Session()
write_bucket = sess.default_bucket()
write_prefix = "fraud-detect-demo"
region = sess.boto_region_name
s3_client = boto3.client("s3", region_name=region)
sm_client = boto3.client("sagemaker", region_name=region)
sm_runtime_client = boto3.client("sagemaker-runtime")
sm_autoscaling_client = boto3.client("application-autoscaling")
sagemaker_role = sagemaker.get_execution_role()
# S3 locations used for parameterizing the notebook run
read_bucket = "sagemaker-sample-files"
read_prefix = "datasets/tabular/synthetic_automobile_claims"
model_prefix = "models/xgb-fraud"
data_capture_key = f"{write_prefix}/data-capture"
# S3 location of trained model artifact
model_uri = f"s3://{read_bucket}/{model_prefix}/fraud-det-xgb-model.tar.gz"
# S3 path where data captured at endpoint will be stored
data_capture_uri = f"s3://{write_bucket}/{data_capture_key}"
# S3 location of test data
test_data_uri = f"s3://{read_bucket}/{read_prefix}/test.csv"Etapa 3: criar um endpoint do Real-Time Inference
No SageMaker, há vários métodos para implantar um modelo treinado em um endpoint do Real-Time Inference: SDK do SageMaker, AWS SDK - Boto3 e console do SageMaker. Para obter mais informações, consulte Deploy Models for Inference (Implantar modelos para inferência) no Guia do desenvolvedor do Amazon SageMaker. O SDK do SageMaker tem mais abstrações comparado ao AWS SDK - Boto3, e este expõe APIs de nível inferior para proporcionar maior controle sobre a implantação do modelo. Neste tutorial, você implantará o modelo usando o AWS SDK -Boto3. Para implantar um modelo, é necessário seguir três etapas em sequência:
- Crie um modelo do SageMaker com base no artefato de modelo
- Crie uma configuração de endpoint para especificar propriedades, como tipo de instância e contagem
- Crie o endpoint usando a configuração de endpoint
Para criar um modelo do SageMaker usando o artefato de modelo treinado armazenado no S3, copie e cole o código a seguir. O método create_model usa o contêiner do Docker que contém a imagem de treinamento (para este modelo, o contêiner XGBoost) e a localização do artefato do modelo no S3 como parâmetros.
# Retrieve the SageMaker managed XGBoost image
training_image = retrieve(framework="xgboost", region=region, version="1.3-1")
# Specify a unique model name that does not exist
model_name = "fraud-detect-xgb"
primary_container = {
"Image": training_image,
"ModelDataUrl": model_uri
}
model_matches = sm_client.list_models(NameContains=model_name)["Models"]
if not model_matches:
model = sm_client.create_model(ModelName=model_name,
PrimaryContainer=primary_container,
ExecutionRoleArn=sagemaker_role)
else:
print(f"Model with name {model_name} already exists! Change model name to create new")
Verifique o modelo criado no console do SageMaker, na seção Models (Modelos).
Após a criação do modelo do SageMaker, copie e cole o código abaixo para usar o método Boto3 create_endpoint_config para configurar o endpoint. As principais entradas para o método create_endpoint_config são o nome da configuração de endpoint e as informações de grade, como o tipo e a contagem da instância de inferência, o nome do modelo a ser implantado e o compartilhamento de tráfego que o endpoint deve solucionar. Além dessas configurações, também é possível configurar a captura de dados especificando um DataCaptureConfig. Esse recurso permite configurar o endpoint em tempo real para capturar e armazenar as solicitações ou respostas no Amazon S3. A captura de dados é uma das etapas na configuração do monitoramento de modelos. Quando combinada com métricas de referência e trabalhos de monitoramento, ela ajuda a monitorar a performance do modelo comparando métricas de dados de teste às referências. Esse monitoramento é útil para programar o novo treinamento do modelo com base no modelo ou no descompasso de dados e para fins de auditoria. Na configuração atual, tanto a entrada (dados de teste de entrada) como a saída (previsões do modelo) são capturadas e armazenadas no bucket do S3 padrão.
# Endpoint Config name
endpoint_config_name = f"{model_name}-endpoint-config"
# Endpoint config parameters
production_variant_dict = {
"VariantName": "Alltraffic",
"ModelName": model_name,
"InitialInstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"InitialVariantWeight": 1
}
# Data capture config parameters
data_capture_config_dict = {
"EnableCapture": True,
"InitialSamplingPercentage": 100,
"DestinationS3Uri": data_capture_uri,
"CaptureOptions": [{"CaptureMode" : "Input"}, {"CaptureMode" : "Output"}]
}
# Create endpoint config if one with the same name does not exist
endpoint_config_matches = sm_client.list_endpoint_configs(NameContains=endpoint_config_name)["EndpointConfigs"]
if not endpoint_config_matches:
endpoint_config_response = sm_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[production_variant_dict],
DataCaptureConfig=data_capture_config_dict
)
else:
print(f"Endpoint config with name {endpoint_config_name} already exists! Change endpoint config name to create new")Verifique a configuração de endpoint criada no console do SageMaker, na seção Endpoint configurations (Configurações de endpoint).
Copie e cole o código a seguir para criar o endpoint. O método create_endpoint utiliza a configuração de endpoint como parâmetro e implanta o modelo especificado no endpoint em uma instância de computação. O modelo leva cerca de seis minutos para ser implantado.
endpoint_name = f"{model_name}-endpoint"
endpoint_matches = sm_client.list_endpoints(NameContains=endpoint_name)["Endpoints"]
if not endpoint_matches:
endpoint_response = sm_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name
)
else:
print(f"Endpoint with name {endpoint_name} already exists! Change endpoint name to create new")
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp["EndpointStatus"]
while status == "Creating":
print(f"Endpoint Status: {status}...")
time.sleep(60)
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp["EndpointStatus"]
print(f"Endpoint Status: {status}")Para verificar o status do endpoint, escolha o ícone SageMaker resources (Recursos do SageMaker). Em SageMaker resources (Recursos do SageMaker), selecione Endpoints. Em name (nome), selecione fraud-detect-xgb-endpoint.
Etapa 4: invocar o endpoint de inferência
Depois que o status do endpoint é alterado para InService, você pode invocar o endpoint usando a API REST, o AWS SDK - Boto3, o SageMaker Studio, a AWS CLI ou o SDK do SageMaker Python. Neste tutorial, você usará o AWS SDK - Boto3. Antes de chamar um endpoint, é importante que os dados de teste sejam devidamente formatados para o endpoint usando serialização e desserialização. A serialização é o processo de converter dados brutos em um formato como .csv em fluxos de bytes que o endpoint poderá usar. A desserialização é o processo reverso da conversão de fluxo de bytes para um formato legível por humanos. Neste tutorial, você invocará o endpoint enviando as cinco primeiras amostras de um conjunto de dados de teste. Para invocar o endpoint e obter resultados de previsão, copie e cole o código a seguir. Como a solicitação para o endpoint (conjunto de dados de teste) está no formato .csv, utiliza-se um processo de serialização em csv para criar a carga útil. A resposta então é desserializada para uma matriz de previsões. Depois que a execução é concluída, a célula retorna as previsões do modelo e os rótulos verdadeiros para as amostras de teste. O modelo do XGBoost retorna probabilidades em vez de rótulos de classe reais. O modelo previu uma probabilidade muito baixa de as amostras de teste serem solicitações fraudulentas, e as previsões estão de acordo com os rótulos verdadeiros.
# Fetch test data to run predictions with the endpoint
test_df = pd.read_csv(test_data_uri)
# For content type text/csv, payload should be a string with commas separating the values for each feature
# This is the inference request serialization step
# CSV serialization
csv_file = io.StringIO()
test_sample = test_df.drop(["fraud"], axis=1).iloc[:5]
test_sample.to_csv(csv_file, sep=",", header=False, index=False)
payload = csv_file.getvalue()
response = sm_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
Body=payload,
ContentType="text/csv",
Accept="text/csv"
)
# This is the inference response deserialization step
# This is a bytes object
result = response["Body"].read()
# Decoding bytes to a string
result = result.decode("utf-8")
# Converting to list of predictions
result = re.split(",|\n",result)
prediction_df = pd.DataFrame()
prediction_df["Prediction"] = result[:5]
prediction_df["Label"] = test_df["fraud"].iloc[:5].values
prediction_df
Para monitorar as métricas de invocação de endpoint usando o Amazon CloudWatch, abra o console do SageMaker. Em Inference (Inferência), selecione Endpoints, fraud-detect-xgb-endpoint.
Na página Endpoint details (Detalhes do endpoint), em Monitor (Monitorar), escolha View invocation metrics (Visualizar métricas de invocação). A princípio, você verá apenas um único ponto no gráfico de métricas. Porém, após várias invocações, verá uma linha semelhante à da captura de tela de exemplo.
A página Metrics (Métricas) exibe várias métricas de performance de endpoint. É possível escolher diferentes períodos para visualização de performance de endpoint, como mais de uma hora ou três horas. Selecione qualquer métrica para ver a tendência dela no período escolhido. Na próxima etapa, escolha uma dessas métricas para definir as políticas de escalabilidade automática.
Como a captura de dados foi definida na configuração de endpoint, há uma forma de inspecionar qual carga útil foi enviada ao endpoint juntamente com a resposta. Os dados capturados levam algum tempo para serem totalmente carregados no S3. Copie e cole o código a seguir para verificar se a captura de dados foi concluída.
from sagemaker.s3 import S3Downloader
print("Waiting for captures to show up", end="")
for _ in range(90):
capture_files = sorted(S3Downloader.list(f"{data_capture_uri}/{endpoint_name}"))
if capture_files:
capture_file = S3Downloader.read_file(capture_files[-1]).split("\n")
capture_record = json.loads(capture_file[0])
if "inferenceId" in capture_record["eventMetadata"]:
break
print(".", end="", flush=True)
time.sleep(1)
print()
print(f"Found {len(capture_files)} Data Capture Files:")Os dados capturados são armazenados como um arquivo separado para cada invocação de endpoint no S3 em JSON Lines, um formato delimitado por nova linha para armazenar dados estruturados em que cada linha é um valor JSON. Copie e cole o código a seguir para recuperar os arquivos de captura de dados.
capture_files = sorted(S3Downloader.list(f"{data_capture_uri}/{endpoint_name}"))
capture_file = S3Downloader.read_file(capture_files[0]).split("\n")
capture_record = json.loads(capture_file[0])
capture_record
Copie e cole o código a seguir para decodificar os dados nos arquivos capturados usando base64. O código recupera as cinco amostras de teste que foram enviadas como carga útil e as previsões delas. Esse recurso é útil para inspecionar cargas de endpoint com respostas de modelo e monitorar a performance do modelo.
input_data = capture_record["captureData"]["endpointInput"]["data"]
output_data = capture_record["captureData"]["endpointOutput"]["data"]
input_data_list = base64.b64decode(input_data).decode("utf-8").split("\n")
print(input_data_list)
output_data_list = base64.b64decode(output_data).decode("utf-8").split("\n")
print(output_data_list)
Etapa 5: configurar a escalabilidade automática para endpoint
As workloads que usam endpoints do Real-Time Inference endpoints geralmente têm baixos requisitos de latência. Além disso, com os picos de tráfego, os endpoints do Real-Time Inference podem sofrer sobrecarga de CPU, alta latência ou exceder o tempo limite. Por isso, é importante escalar a capacidade para lidar com as alterações de tráfego de maneira eficiente e com baixa latência. A escalabilidade automática de inferência do SageMaker monitora suas workloads e ajusta dinamicamente a contagem de instâncias para manter uma performance de endpoint estável e previsível por um baixo custo. Quando a workload aumenta, a escalabilidade automática inclui instâncias online e, quando a workload diminui, ela remove instâncias desnecessárias, ajudando a reduzir os custos com computação. Neste tutorial, você usará o AWS SDK - Boto3 para configurar a escalabilidade automática para seu endpoint. O SageMaker fornece vários tipos de escalabilidade automática: escalabilidade de rastreamento de destino, escalabilidade em etapas, escalabilidade sob demanda e escalabilidade programada. Neste tutorial, você usará uma política de escalabilidade de rastreamento de destino, que é acionada quando a métrica de escalabilidade escolhida ultrapassa o limite do destino escolhido.
A escalabilidade automática pode ser configurada em duas etapas. Primeiro, configure uma política de escalabilidade com detalhes do número mínimo, desejado, e do número máximo de instâncias por endpoint. Copie e cole o código a seguir para configurar uma política de escalabilidade de rastreamento de destino. O número máximo especificado de instâncias é iniciado quando o tráfego ultrapassa os limites escolhidos, que você escolherá na próxima etapa.
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
# SageMaker expects resource id to be provided with the following structure
resource_id = f"endpoint/{endpoint_name}/variant/{resp['ProductionVariants'][0]['VariantName']}"
# Scaling configuration
scaling_config_response = sm_autoscaling_client.register_scalable_target(
ServiceNamespace="sagemaker",
ResourceId=resource_id,
ScalableDimension="sagemaker:variant:DesiredInstanceCount",
MinCapacity=1,
MaxCapacity=2
)Copie e cole o código a seguir para criar a política de escalabilidade. A métrica de escalabilidade escolhida é SageMakerVariantInvocationsPerInstance, que é o número médio de vezes por minuto que cada instância de inferência para uma variante de modelo é invocada. Quando esse número ultrapassa o limite escolhido de 5, aciona-se a escalabilidade automática.
# Create Scaling Policy
policy_name = f"scaling-policy-{endpoint_name}"
scaling_policy_response = sm_autoscaling_client.put_scaling_policy(
PolicyName=policy_name,
ServiceNamespace="sagemaker",
ResourceId=resource_id,
ScalableDimension="sagemaker:variant:DesiredInstanceCount",
PolicyType="TargetTrackingScaling",
TargetTrackingScalingPolicyConfiguration={
"TargetValue": 5.0, # Target for avg invocations per minutes
"PredefinedMetricSpecification": {
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance",
},
"ScaleInCooldown": 600, # Duration in seconds until scale in
"ScaleOutCooldown": 60 # Duration in seconds between scale out
}
)Copie e cole o código a seguir para recuperar os detalhes da política de escalabilidade.
response = sm_autoscaling_client.describe_scaling_policies(ServiceNamespace="sagemaker")
pp = pprint.PrettyPrinter(indent=4, depth=4)
for i in response["ScalingPolicies"]:
pp.pprint(i["PolicyName"])
print("")
if("TargetTrackingScalingPolicyConfiguration" in i):
pp.pprint(i["TargetTrackingScalingPolicyConfiguration"])Copie e cole o código a seguir para criar fazer o teste de estresse do endpoint. O código é executado por 250 segundos e invoca o endpoint repetidas vezes enviando amostras selecionadas aleatoriamente do conjunto de dados de teste.
request_duration = 250
end_time = time.time() + request_duration
print(f"Endpoint will be tested for {request_duration} seconds")
while time.time() < end_time:
csv_file = io.StringIO()
test_sample = test_df.drop(["fraud"], axis=1).iloc[[np.random.randint(0, test_df.shape[0])]]
test_sample.to_csv(csv_file, sep=",", header=False, index=False)
payload = csv_file.getvalue()
response = sm_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
Body=payload,
ContentType="text/csv"
)É possível monitorar as métricas de endpoint usando o Amazon CloudWatch. Para obter uma lista de métricas de endpoint disponíveis, inclusive de invocação, consulte SageMaker Endpoint Invocation Metrics (Métricas de invocação de endpoint do SageMaker). No console do SageMaker, em Inference (Inferência), escolha Endpoints, fraud-detect-xgb-endpoint. Na página Endpoint details (Detalhes do endpoint), navegue até a seção Monitor (Monitorar) e escolha View invocation metrics (Visualizar métricas de invocação). Na página Metrics (Métricas), selecione InvocationsPerInstance (trata-se de uma métrica de monitoramento que você escolhe ao definir a política de escalabilidade) e Invocations (Invocações) na lista de métricas. Depois, escolha a guia Graphed metrics (Métricas em grafos).
Na página Graphed metrics (Métricas em grafos), inspecione visualmente o padrão de tráfego recebido pelo endpoint e alterar o detalhamento do tempo, por exemplo, do padrão de cinco minutos para um minuto. Pode levar alguns minutos para a escalabilidade automática adicionar a segunda instância. Depois que a nova instância for adicionada, você perceberá que as invocações por instância equivalem a metade do total de invocações.
Quando o endpoint receber a carga útil aumentada, verifique o status do endpoint executando o código abaixo. Esse código verifica quando o status do endpoint é alterado de InService para Updating e rastreia as contagens de instâncias. Alguns minutos depois, você verá o status ser alterado de InService para Updating e de volta para InService, porém com uma contagem de instâncias mais alta.
# Check the instance counts after the endpoint gets more load
response = sm_client.describe_endpoint(EndpointName=endpoint_name)
endpoint_status = response["EndpointStatus"]
request_duration = 250
end_time = time.time() + request_duration
print(f"Waiting for Instance count increase for a max of {request_duration} seconds. Please re run this cell in case the count does not change")
while time.time() < end_time:
response = sm_client.describe_endpoint(EndpointName=endpoint_name)
endpoint_status = response["EndpointStatus"]
instance_count = response["ProductionVariants"][0]["CurrentInstanceCount"]
print(f"Status: {endpoint_status}")
print(f"Current Instance count: {instance_count}")
if (endpoint_status=="InService") and (instance_count>1):
break
else:
time.sleep(15)
Etapa 6: limpar os recursos
Para evitar cobranças não intencionais, é uma prática recomendada excluir recursos que você não está mais usando.
Exclua o modelo, a configuração de endpoint e o endpoint criado neste tutorial executando o bloco de código a seguir no bloco de anotações. Se você não excluir o endpoint, sua conta continuará acumulando cobranças para a instância de computação que está em execução no endpoint.
# Delete model
sm_client.delete_model(ModelName=model_name)
# Delete endpoint configuration
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
# Delete endpoint
sm_client.delete_endpoint(EndpointName=endpoint_name)Para excluir o bucket do S3, faça o seguinte:
- Abra o console do Amazon S3. Na barra de navegação, escolha Buckets, sagemaker-<your-Region>-<your-account-id>, e marque a caixa de seleção ao lado de fraud-detect-demo. Selecione Delete (Excluir).
- Na caixa de diálogo Delete objects (Excluir objetos), verifique se você selecionou o objeto correto para excluir e digite permanently delete (excluir permanentemente) na caixa de confirmação Permanently delete objects (Excluir objetos permanentemente).
- Quando esse passo for concluído e o bucket estiver vazio, você poderá excluir o bucket sagemaker-<your-Region>-<your-account-id> realizando o mesmo procedimento novamente.
O kernel Data Science usado para executar a imagem do bloco de anotações neste tutorial acumulará cobranças até você interromper o kernel ou executar as etapas a seguir para excluir as aplicações. Para obter mais informações, consulte Shut Down Resources (Desativar recursos) no Guia do desenvolvedor do Amazon SageMaker.
Para excluir as aplicações do SageMaker Studio, faça o seguinte: no console do SageMaker Studio, escolha studio-user e exclua todas as aplicações listadas em Apps (Aplicações) escolhendo Delete app (Excluir aplicação). Aguarde até o Status ser alterado para Deleted (Excluído).
Se você usou um domínio existente do SageMaker Studio na Etapa 1, ignore o restante da Etapa 6 e vá diretamente para a seção de conclusão.
Se você executou o modelo do CloudFormation na Etapa 1 para criar um novo domínio do SageMaker Studio, prossiga com as etapas a seguir para excluir o domínio, o usuário e os recursos criados pelo modelo do CloudFormation.
Para abrir o console do CloudFormation, insira CloudFormation na barra de pesquisa do Console da AWS e escolha CloudFormation nos resultados da pesquisa.
No painel do CloudFormation, escolha Stacks (Pilhas). Na lista suspensa de status, selecione Active (Ativo). Em Stack name (Nome da pilha), escolha CFN-SM-IM-Lambda-catalog para abrir a página de detalhes da pilha.
Na página de detalhes da pilha CFN-SM-IM-Lambda-catalog, escolha Delete (Excluir) para excluir a pilha junto com os recursos que ela criou na Etapa 1.
Conclusão
Parabéns! Você concluiu o tutorial Implantar o modelo de machine learning em um endpoint de inferência em tempo real.
Neste tutorial, você criou um modelo do SageMaker e o implantou em um endpoint do Real-Time Inference. Você usou a API do AWS SDK - Boto3 para invocar o endpoint e testá-lo executando inferências de amostra enquanto utilizava o recurso de captura de dados para salvar cargas úteis de endpoint e respostas no S3. Por fim, você configurou a escalabilidade automática usando uma métrica de invocação de endpoint de destino para solucionar as flutuações de tráfego.
Continue sua jornada de machine learning com o SageMaker seguindo a seção de próximas etapas abaixo.
Treinar um modelo de aprendizado profundo
Criar um modelo de machine learning automaticamente
Encontre mais tutoriais práticos