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
Com a Amazon SageMaker AI, você pode começar a obter previsões ou *inferências* de seus modelos treinados de aprendizado de máquina. SageMaker A IA fornece uma ampla seleção de opções de implantação de modelos e infraestrutura de ML para ajudar a atender a todas as suas necessidades de inferência de ML. Com o SageMaker AI Inference, você pode escalar a implantação do seu modelo, gerenciar modelos com mais eficiência na produção e reduzir a carga operacional. SageMaker A IA fornece várias opções de inferência, como endpoints em tempo real para obter inferência de baixa latência, endpoints sem servidor para infraestrutura totalmente gerenciada e auto-scaling e endpoints assíncronos para lotes de solicitações. Ao utilizar a opção de inferência apropriada para o caso de uso, você pode garantir a eficiência da implantação e inferência do modelo.
## Escolha de um atributo
Há vários casos de uso para implantar modelos de ML com SageMaker IA. Esta seção descreve esses casos de uso, bem como o recurso de SageMaker IA que recomendamos para cada caso de uso.
### Casos de uso
A seguir estão os principais casos de uso para implantar modelos de ML com SageMaker IA.
+ **Caso de uso 1: implantar um modelo de machine learning em um ambiente low-code ou no-code.** Para iniciantes ou iniciantes na SageMaker IA, você pode implantar modelos pré-treinados usando a Amazon SageMaker JumpStart por meio da interface do Amazon SageMaker Studio, sem a necessidade de configurações complexas.
+ **Caso de uso 2: usar o código para implantar modelos de machine learning com mais flexibilidade e controle.** Profissionais experientes de ML podem implantar seus próprios modelos com configurações personalizadas para as necessidades de seus aplicativos usando a `ModelBuilder` classe no SDK SageMaker AI Python, que fornece controle refinado sobre várias configurações, como tipos de instância, isolamento de rede e alocação de recursos.
+ **Caso de uso 3: implantar modelos de machine learning em grande escala.** Para usuários avançados e organizações que desejam gerenciar modelos em grande escala na produção, use a AWS SDK para Python (Boto3) e CloudFormation junto com a infraestrutura como código (IaC) e as CI/CD ferramentas desejadas para provisionar recursos e automatizar o gerenciamento de recursos.
### Recursos recomendados
A tabela a seguir descreve as principais considerações e compensações dos recursos de SageMaker IA correspondentes a cada caso de uso.
| | Caso de uso 1 | Caso de uso 2 | Caso de uso 3 |
| --- | --- | --- | --- |
| SageMaker Recurso de IA | Use [ JumpStart no Studio](jumpstart-foundation-models-use-studio-updated.md) para acelerar a implantação do seu modelo básico. | Implante modelos usando [o ModelBuilder SDK do SageMaker Python](how-it-works-modelbuilder-creation.md). | [Implemente e gerencie modelos em grande escala com CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_SageMaker.html). |
| Description | Use a interface do usuário do Studio para implantar modelos pré-treinados de um catálogo em endpoints de inferência pré-configurados. Essa opção é ideal para cientistas de dados civis ou para qualquer pessoa que queira implantar um modelo sem definir configurações complexas. | Use a ModelBuilder classe do Amazon SageMaker AI Python SDK para implantar seu próprio modelo e definir as configurações de implantação. Essa opção é ideal para cientistas de dados experientes ou para qualquer pessoa que tenha seu próprio modelo para implantar e precise de um controle refinado. | Uso CloudFormation e infraestrutura como código (IaC) para controle programático e automação para implantação e gerenciamento SageMaker de modelos de IA. Essa opção é ideal para usuários avançados que precisam de implantações consistentes e reproduzíveis. |
| Otimizado para | Implantações rápidas e simplificadas de modelos de código aberto mais conhecidos | Implantação dos modelos próprios | Gerenciamento contínuo de modelos em produção |
| Considerações | Falta de personalização das configurações do contêiner e das necessidades específicas da aplicação | Sem interface de usuário, requer que você se a vontade para desenvolver e manter o código Python | Requer gerenciamento de infraestrutura e recursos organizacionais, além de exigir familiaridade com os CloudFormation modelos AWS SDK para Python (Boto3) ou com eles. |
| Ambiente recomendado | Um domínio de SageMaker IA | Um ambiente de desenvolvimento do Python configurado com suas AWS credenciais e o SDK do SageMaker Python instalado, ou um IDE de IA, como SageMaker [SageMaker JupyterLab](studio-updated-jl.md) | O AWS CLI, um ambiente de desenvolvimento local e Infraestrutura como Código (IaC) e ferramentas CI/CD |
### Opções adicionais
SageMaker A IA oferece opções diferentes para seus casos de uso de inferência, oferecendo opções sobre a amplitude técnica e a profundidade de suas implantações:
+ **Implantação de um modelo em um endpoint.** Ao implantar o modelo, considere as seguintes opções:
+ [Inferência em tempo real](realtime-endpoints.md). A inferência em tempo real é ideal para workloads de inferência com requisitos interativos e de baixa latência.
+ [Implante modelos com o Amazon SageMaker Serverless Inference](serverless-endpoints.md). Use a Inferência Sem Servidor para implantar modelos sem configurar ou gerenciar nenhuma infraestrutura subjacente. Essa opção é ideal para workloads que têm períodos de inatividade entre picos de tráfego e podem tolerar inicializações a frio.
+ [Inferência assíncrona](async-inference.md). enfileira as solicitações recebidas e as processa de forma assíncrona. Essa opção é ideal para solicitações com grandes tamanhos de carga útil (até 1 GB), tempos de processamento longos (até uma hora) e requisitos de latência quase em tempo real.
+ **Otimização de custo.** Para otimizar os custos de inferência, considere as seguintes opções:
+ [Otimização do desempenho do modelo com o SageMaker Neo](neo.md). Use SageMaker o Neo para otimizar e executar seus modelos de aprendizado de máquina com melhor desempenho e eficiência, ajudando você a minimizar os custos de computação ao otimizar automaticamente os modelos para execução em ambientes como chips AWS Inferentia.
+ [Escalabilidade automática dos modelos de SageMaker IA da Amazon](endpoint-auto-scaling.md). Use o ajuste de escala automático para ajustar dinamicamente os recursos computacionais dos endpoints com base nos padrões de tráfego de entrada, o que ajuda a otimizar os custos ao pagar apenas pelos recursos que você está usando em um momento específico.
# Opções de implantação de modelos no Amazon SageMaker AI
Depois de treinar seu modelo de machine learning, você pode implantá-lo usando o Amazon SageMaker AI para obter predições. O Amazon SageMaker AI oferece as seguintes formas para implantar um modelo, dependendo do seu caso de uso:
+ Para endpoints persistentes e em tempo real que fazem uma predição por vez, use os serviços de hospedagem em tempo real do SageMaker AI. Consulte [Inferência em tempo real](realtime-endpoints.md).
+ Workloads que têm períodos de inatividade entre surtos de tráfego e podem tolerar arranques a frio usam a Inferência Sem Servidor. Consulte [Implante modelos com o Amazon SageMaker Serverless Inference](serverless-endpoints.md).
+ Solicitações com cargas úteis de até 1 GB, tempos de processamento longos e requisitos de latência quase em tempo real usam a inferência assíncrona do Amazon SageMaker. Consulte [Inferência assíncrona](async-inference.md).
+ Para obter predições para um conjunto de dados completo, use a transformação em lote do SageMaker AI. Consulte [Transformação em lote para inferência com a Amazon AI SageMaker](batch-transform.md).
O SageMaker AI oferece componentes para gerenciar recursos e otimizar o desempenho de inferência ao implantar modelos de machine learning:
+ Para gerenciar modelos em dispositivos de borda para que você possa otimizar, proteger, monitorar e manter modelos de machine learning em frotas de dispositivos periféricos, consulte [Implantação de modelos na borda com o SageMaker Edge Manager](edge.md). Isso se aplica a dispositivos de borda, como câmeras inteligentes, robôs, computadores pessoais e dispositivos móveis.
+ Para otimizar os modelos Gluon, Keras, MXNet, PyTorch, TensorFlow, TensorFlow-Lite e ONNX para inferência em máquinas Android, Linux e Windows baseadas em processadores de Ambarella, ARM, Intel, Nvidia, NXP, Qualcomm, Texas Instruments e Xilinx, consulte [Otimização do desempenho do modelo com o SageMaker Neo](neo.md).
Para obter mais informações sobre todas as opções de implantação, consulte [Implantar modelos para inferência](deploy-model.md).
# Entenda as opções para implantar modelos e obter inferências na Amazon AI SageMaker
Para ajudar você a começar a usar a inferência de SageMaker IA, consulte as seções a seguir, que explicam suas opções para implantar seu modelo em SageMaker IA e obter inferências. A seção [Opções de inferência na Amazon AI SageMaker](deploy-model-options.md) pode ajudá-lo a determinar qual atributo é mais adequado ao seu caso de uso para inferência.
Você pode consultar a [Recursos](inference-resources.md) seção para obter mais informações sobre solução de problemas e referência, blogs e exemplos para ajudar você a começar, além de informações comuns FAQs.
**Topics**
+ [Antes de começar](#deploy-model-prereqs)
+ [Etapas para a implantação do modelo](#deploy-model-steps)
+ [Opções de inferência na Amazon AI SageMaker](deploy-model-options.md)
+ [Opções avançadas de endpoint para inferência com a Amazon AI SageMaker](deploy-model-advanced.md)
+ [Próximas etapas para inferência com a Amazon AI SageMaker](deploy-model-next-steps.md)
## Antes de começar
Esses tópicos pressupõem que você tenha criado e treinado um ou mais modelos de machine learning e esteja pronto para implantá-los. Você não precisa treinar seu modelo em SageMaker IA para implantá-lo em SageMaker IA e obter inferências. Se você não tem seu próprio modelo, também pode usar os [algoritmos integrados da SageMaker IA ou modelos pré-treinados](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
Se você é iniciante na SageMaker IA e ainda não escolheu um modelo para implantar, siga as etapas do tutorial [Get Started with Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html). Use o tutorial para se familiarizar com a forma como a SageMaker IA gerencia o processo de ciência de dados e como ela lida com a implantação do modelo. Para obter mais informações sobre treinar um modelo, consulte [Treinar modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/train-model.html).
Para informações adicionais, referência e exemplos, consulte o [Recursos](inference-resources.md).
## Etapas para a implantação do modelo
Para endpoints de inferência, o fluxo de trabalho geral consiste no seguinte:
+ Crie um modelo no SageMaker AI Inference apontando para artefatos de modelo armazenados no Amazon S3 e uma imagem de contêiner.
+ Selecionar uma opção de inferência. Para obter mais informações, consulte [Opções de inferência na Amazon AI SageMaker](deploy-model-options.md).
+ Crie uma configuração de endpoint de inferência de SageMaker IA escolhendo o tipo de instância e o número de instâncias que você precisa por trás do endpoint. Você pode usar o [Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html) para obter recomendações para tipos de instância. Para Inferência Serverless, você só precisa fornecer a configuração de memória necessária com base no tamanho do seu modelo.
+ Crie um endpoint de inferência de SageMaker IA.
+ Invocar seu endpoint para receber uma inferência como resposta.
O diagrama a seguir mostra o fluxo de trabalho anterior.
![\[O fluxo de trabalho descrito no parágrafo anterior mostrando como obter inferências da SageMaker IA.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference-workflow-flowchart.png)
Você pode realizar essas ações usando o AWS console, o AWS SDKs, o SDK do SageMaker Python ou o. CloudFormation AWS CLI
Para inferência em lote com transformação em lote, aponte para os artefatos do modelo e os dados de entrada e crie um trabalho de inferência em lote. Em vez de hospedar um endpoint para inferência, a SageMaker IA envia suas inferências para um local Amazon S3 de sua escolha.
# Opções de inferência na Amazon AI SageMaker
SageMaker A IA fornece várias opções de inferência para que você possa escolher a opção mais adequada à sua carga de trabalho:
+ [Inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html): a *inferência em tempo real* é ideal para inferências online que têm baixa latência ou exigências de Alta throughput. Use inferência em tempo real para um endpoint persistente e totalmente gerenciado (API REST) que pode lidar com tráfego constante, respaldado pelo tipo de instância de sua escolha. A inferência em tempo real comporta tamanhos de carga útil de até 25 MB e tempos de processamento de até 60 segundos para respostas regulares e 8 minutos para respostas de streaming.
+ [Inferência sem servidor: a inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html) *sem servidor é ideal quando você tem padrões de tráfego* intermitentes ou imprevisíveis. SageMaker A IA gerencia toda a infraestrutura subjacente, então não há necessidade de gerenciar instâncias ou políticas de escalabilidade. Você paga apenas por aquilo que usa e não por tempo ocioso. Ele é compatível com tamanhos de carga útil de até 4 MB e tempos de processamento de até 60 segundos.
+ [Transformação em lote](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html): a *transformação em lote* é adequada para processamento offline quando grandes quantidades de dados estão disponíveis antecipadamente e você não precisa de um endpoint persistente. Você também pode usar a transformação em lote para pré-processar conjuntos de dados. Ele pode suportar grandes conjuntos de dados com tamanho e tempos de processamento de dias. GBs
+ [Inferência assíncrona](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference.html): a *inferência assíncrona* é ideal quando você deseja enfileirar solicitações e ter grandes cargas com longos tempos de processamento. A Inferência assíncrona é compatível com cargas úteis de até 1 GB e tempos de processamento longos de até uma hora. Você também pode reduzir a escala verticalmente do seu endpoint para 0 quando não há solicitações para processar.
# Opções avançadas de endpoint para inferência com a Amazon AI SageMaker
Com a inferência em tempo real, você pode otimizar ainda mais o desempenho e o custo com as seguintes opções avançadas de inferência:
+ [Endpoints multimodelo](multi-model-endpoints.md): Use esta opção se você tiver vários modelos que usam o mesmo framework e podem compartilhar um contêiner. Essa opção ajuda a otimizar os custos melhorando a utilização do endpoint e reduzindo as despesas de implantação.
+ [Endpoint com vários contêineres](multi-container-endpoints.md): Use esta opção se você tiver vários modelos que usam frameworks diferentes e requerem contêineres próprios. Você obtém muitos dos benefícios dos endpoints multimodelo e pode implantar uma variedade de estruturas e modelos.
+ [Pipelines de inferência serial](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html): use esta opção se você deseja hospedar modelos com lógica de pré-processamento e pós-processamento por trás de um endpoint. Os pipelines de inferência são totalmente gerenciados pela SageMaker IA e oferecem menor latência porque todos os contêineres são hospedados nas mesmas instâncias do Amazon EC2.
# Próximas etapas para inferência com a Amazon AI SageMaker
Depois de ter um endpoint e entender o fluxo de trabalho geral de inferência, você pode usar os seguintes recursos na SageMaker IA para melhorar seu fluxo de trabalho de inferência.
## Monitoramento
Para acompanhar o desempenho do seu modelo ao longo do tempo por meio de métricas como precisão do modelo e deriva, você pode usar o Model Monitor. Com o Model Monitor, você pode configurar alertas que o notificam quando houver desvios na qualidade do seu modelo. Para saber mais, consulte a [documentação do Model Monitor](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html).
Para saber mais sobre ferramentas que podem ser usadas para monitorar implantações de modelos e eventos que alteram seu endpoint, consulte Monitore a [Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html). Por exemplo, você pode monitorar a integridade do seu endpoint por meio de métricas como erros de invocação e latência do modelo usando métricas da Amazon. CloudWatch As [métricas de invocação de endpoint de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation) podem fornecer informações valiosas sobre o desempenho do seu endpoint.
## CI/CD para implantação do modelo
Para reunir soluções de aprendizado de máquina em SageMaker IA, você pode usar a [SageMaker IA MLOps](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects.html). Você pode usar esse atributo para automatizar as etapas em seu fluxo de trabalho de machine learning e aplicar práticas de CI/CD. Você pode usar [modelos de MLOps projeto](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-templates.html) para ajudar na configuração e implementação de MLOps projetos de SageMaker IA. SageMaker A IA também oferece suporte ao uso de seu próprio [repositório Git de terceiros](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-walkthrough-3rdgit.html) para criar um sistema. CI/CD
Para seus pipelines de ML, use o [registro do modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html) para gerenciar suas versões de modelo e a implantação e automação de seus modelos.
## Barreiras de proteção de implantação
Se você quiser atualizar seu modelo enquanto ele está em produção sem afetar a produção, você pode usar barreiras de proteção de implantação. As grades de proteção de implantação são um conjunto de opções de implantação de modelos no SageMaker AI Inference para atualizar seus modelos de aprendizado de máquina em produção. Usando as opções do total gerenciamento de implantações, você pode controlar a mudança do modelo atual em produção para um novo. Os modos de deslocamento de tráfego oferecem controle detalhado sobre o processo de distribuição de tráfego, e salvaguardas incorporadas, como reversão automática, ajudam a identificar problemas precocemente.
Para saber mais sobre barreiras proteção de implantação, consulte a documentação de [proteções de implantação](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails.html).
## Inferência
Se você precisar executar aplicações de machine learning e aprendizado profundo em grande escala, você pode usar uma instância `Inf1` com um endpoint em tempo real. Esse tipo de instância é adequado para casos de uso como reconhecimento de imagem ou fala, processamento de linguagem natural (PLN), personalização, previsão ou detecção de fraudes.
`Inf1`as instâncias são criadas para suportar aplicativos de inferência de aprendizado de máquina e apresentam os chips AWS Inferentia. `Inf1`as instâncias oferecem maior taxa de transferência e menor custo por inferência do que as instâncias baseadas em GPU.
Para implantar um modelo em `Inf1` instâncias, compile seu modelo com SageMaker o Neo e escolha uma `Inf1` instância para sua opção de implantação. Para saber mais, consulte [Otimizar o desempenho do modelo usando SageMaker o Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
## Otimizar o desempenho do modelo
SageMaker A IA fornece recursos para gerenciar recursos e otimizar o desempenho de inferência ao implantar modelos de aprendizado de máquina. Você pode usar os [algoritmos e modelos pré-criados](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) da SageMaker IA, bem como [imagens pré-criadas do Docker](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html), que são desenvolvidas para aprendizado de máquina.
Para treinar modelos e otimizá-los para implantação, consulte [imagens pré-criadas do Docker](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html) [Otimize o desempenho do modelo usando o Neo SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html). Com SageMaker o Neo, você pode treinar TensorFlow, Apache MXNet PyTorch, ONNX e modelos. XGBoost Em seguida, você pode otimizá-los e implantá-los nos processadores ARM, Intel e Nvidia.
## Ajuste de escala automático
Se você tiver quantidades variáveis de tráfego em seus endpoints, talvez queira experimentar o ajuste de escala automático. Por exemplo, durante as horas de pico, você pode precisar de mais instâncias para processar solicitações. No entanto, durante períodos de baixo tráfego, você pode querer reduzir o uso de recursos computacionais. Para ajustar dinamicamente o número de instâncias provisionadas em resposta a alterações na workload, consulte [Escalabilidade automática dos modelos de SageMaker IA da Amazon](endpoint-auto-scaling.md).
Se você tiver padrões de tráfego imprevisíveis ou não quiser configurar políticas de ajuste de escala, você também pode usar a inferência da tecnologia sem servidor para um endpoint. Em seguida, a SageMaker IA gerencia o escalonamento automático para você. Durante períodos de baixo tráfego, a SageMaker IA reduz seu endpoint e, se o tráfego aumentar, a SageMaker IA aumenta seu endpoint. Para obter mais informações, consulte a documentação do [Implante modelos com o Amazon SageMaker Serverless Inference](serverless-endpoints.md).
# Crie um modelo na Amazon SageMaker AI com ModelBuilder
Preparar seu modelo para implantação em um endpoint de SageMaker IA requer várias etapas, incluindo escolher uma imagem do modelo, definir a configuração do endpoint, codificar suas funções de serialização e desserialização para transferir dados de e para o servidor e o cliente, identificar dependências do modelo e enviá-las para o Amazon S3. `ModelBuilder`pode reduzir a complexidade da configuração e implantação iniciais para ajudá-lo a criar um modelo implantável em uma única etapa.
O `ModelBuilder` executa as seguintes tarefas para você:
+ Converte modelos de aprendizado de máquina treinados usando várias estruturas, como XGBoost ou PyTorch em modelos implantáveis, em uma única etapa.
+ Executa a seleção automática de contêineres com base na estrutura do modelo para que você não precise especificar manualmente seu contêiner. Você ainda pode trazer seu próprio contêiner passando seu próprio URI para `ModelBuilder`.
+ Lida com a serialização dos dados no lado do cliente antes de enviá-los ao servidor para inferência e desserialização dos resultados retornados pelo servidor. Os dados são formatados corretamente sem processamento manual.
+ Permite a captura automática de dependências e empacota o modelo de acordo com as expectativas do servidor do modelo. A captura automática de dependências do `ModelBuilder` é a melhor abordagem para carregar dependências dinamicamente. (Recomendamos que você teste a captura automatizada localmente e atualize as dependências para atender às suas necessidades.)
+ Para casos de uso do modelo de linguagem grande (LLM), opcionalmente executa o ajuste de parâmetros locais das propriedades de serviço que podem ser implantadas para melhor desempenho ao hospedar em um SageMaker endpoint de IA.
+ Suporta a maioria dos servidores e contêineres de modelos populares TorchServe, como Triton DJLServing e contêiner TGI.
## Crie seu modelo com ModelBuilder
`ModelBuilder`é uma classe Python que usa um modelo de estrutura, como XGBoost or PyTorch, ou uma especificação de inferência especificada pelo usuário e o converte em um modelo implantável. `ModelBuilder`fornece uma função de construção que gera os artefatos para implantação. O artefato do modelo gerado é específico para o servidor do modelo, que você também pode especificar como uma das entradas. Para obter mais detalhes sobre a `ModelBuilder` aula, consulte [ModelBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.model_builder.ModelBuilder).
O diagrama a seguir ilustra o fluxo de trabalho geral de criação do modelo quando você usa `ModelBuilder`. O `ModelBuilder` aceita uma especificação de modelo ou inferência junto com seu esquema para criar um modelo implantável que você possa testar localmente antes da implantação.
![\[Criação de modelos e fluxo de implantação usando ModelBuilder.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-builder-flow.png)
O `ModelBuilder` pode lidar com qualquer personalização que você queira aplicar. No entanto, para implantar um modelo de estrutura, o construtor de modelos espera no mínimo um modelo, uma amostra de entrada e saída e a função. No exemplo de código a seguir, `ModelBuilder` é chamado com um modelo de estrutura e uma instância de `SchemaBuilder` com argumentos mínimos (para inferir as funções correspondentes para serializar e desserializar a entrada e saída do endpoint). Nenhum contêiner é especificado e nenhuma dependência empacotada é passada — a SageMaker IA infere automaticamente esses recursos quando você cria seu modelo.
```
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
model_builder = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(input, output),
role_arn="execution-role",
)
```
O exemplo de código a seguir invoca `ModelBuilder` com uma especificação de inferência (como uma instância `InferenceSpec`) em vez de um modelo, com personalização adicional. Nesse caso, a chamada para o construtor de modelos inclui um caminho para armazenar artefatos do modelo e também ativa a captura automática de todas as dependências disponíveis. Para obter detalhes adicionais sobre `InferenceSpec`, consulte [Personalizar o carregamento do modelo e o tratamento de solicitações](#how-it-works-modelbuilder-creation-is).
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": True}
)
```
## Defina métodos de serialização e desserialização
Ao invocar um endpoint de SageMaker IA, os dados são enviados por meio de cargas HTTP com diferentes tipos de MIME. Por exemplo, uma imagem enviada ao endpoint para inferência precisa ser convertida em bytes no lado do cliente e enviada por meio de uma carga útil HTTP para o endpoint. Quando o endpoint recebe a carga útil, ele precisa desserializar a sequência de bytes de volta ao tipo de dados esperado pelo modelo (também conhecido como desserialização do lado do servidor). Depois que o modelo termina a predição, os resultados também precisam ser serializados em bytes que podem ser enviados de volta por meio da carga útil HTTP para o usuário ou o cliente. Depois que o cliente recebe os dados de bytes de resposta, ele precisa realizar a desserialização do lado do cliente para converter os dados de bytes de volta ao formato de dados esperado, como JSON. No mínimo, é preciso converter os dados para as seguintes tarefas:
1. Serialização da solicitação de inferência (processada pelo cliente)
1. Desserialização da solicitação de inferência (processada pelo servidor ou algoritmo)
1. Invocar o modelo contra a carga útil e enviando a carga útil da resposta de volta
1. Serialização da resposta de inferência (processada pelo servidor ou algoritmo)
1. Desserialização da resposta de inferência (processada pelo cliente)
O diagrama a seguir mostra os processos de serialização e desserialização que ocorrem quando você invoca o endpoint.
![\[Diagrama da serialização e desserialização de dados de cliente para servidor.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-builder-serialization.png)
Quando você fornece amostras de entrada e saída para `SchemaBuilder`, o criador de esquemas gera as funções de empacotamento correspondentes para serializar e desserializar a entrada e a saída. Você pode personalizar ainda mais suas funções de serialização com `CustomPayloadTranslator`. Mas, na maioria dos casos, um serializador simples, como o seguinte, funcionaria:
```
input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)
```
Para obter mais detalhes sobre`SchemaBuilder`, consulte [SchemaBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.schema_builder.SchemaBuilder).
O trecho de código a seguir descreve um exemplo em que você deseja personalizar as funções de serialização e desserialização nos lados do cliente e do servidor. Você pode definir seus próprios tradutores de solicitação e resposta com `CustomPayloadTranslator` e repassar esses tradutores para `SchemaBuilder`.
Ao incluir as entradas e saídas com os tradutores, o construtor do modelo pode extrair o formato de dados que o modelo espera. Por exemplo, suponha que a entrada de amostra seja uma imagem bruta e seus tradutores personalizados recortem a imagem e enviem a imagem recortada para o servidor como um tensor. O `ModelBuilder` precisa da entrada bruta e de qualquer código personalizado de pré-processamento ou pós-processamento para derivar um método para converter dados no lado do cliente e do servidor.
```
from sagemaker.serve import CustomPayloadTranslator
# request translator
class MyRequestTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on client side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the input payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on server side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
# response translator
class MyResponseTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on server side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the response payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on client side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
```
Você passa o exemplo de entrada e saída junto com os tradutores personalizados definidos anteriormente ao criar o objeto `SchemaBuilder`, conforme mostrado no seguinte exemplo:
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
Em seguida, você passa a amostra de entrada e saída, junto com os tradutores personalizados definidos anteriormente, para o objeto `SchemaBuilder`.
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
As seções a seguir explicam em detalhes como criar seu modelo `ModelBuilder` e usar suas classes de apoio para personalizar a experiência para seu caso de uso.
**Topics**
+ [Crie seu modelo com ModelBuilder](#how-it-works-modelbuilder-creation-mb)
+ [Defina métodos de serialização e desserialização](#how-it-works-modelbuilder-creation-sb)
+ [Personalizar o carregamento do modelo e o tratamento de solicitações](#how-it-works-modelbuilder-creation-is)
+ [Criar e implantar seu modelo](#how-it-works-modelbuilder-creation-deploy)
+ [Traga seu próprio contêiner (BYOC)](#how-it-works-modelbuilder-creation-mb-byoc)
+ [Usando ModelBuilder no modo local](#how-it-works-modelbuilder-creation-local)
+ [ModelBuilder exemplos](#how-it-works-modelbuilder-creation-example)
## Personalizar o carregamento do modelo e o tratamento de solicitações
Fornecer seu próprio código de inferência por meio do `InferenceSpec` oferece uma camada adicional de personalização. Com o `InferenceSpec`, você pode personalizar como o modelo é carregado e como ele lida com as solicitações de inferência recebidas, ignorando seus mecanismos padrão de carregamento e tratamento de inferência. Essa flexibilidade é particularmente benéfica ao trabalhar com modelos não padrão ou pipelines de inferência personalizados. Você pode personalizar o método `invoke` para controlar como o modelo pré-processa e pós-processa as solicitações recebidas. O método `invoke` garante que o modelo trate corretamente as solicitações de inferência. O exemplo a seguir é usado `InferenceSpec` para gerar um modelo com o HuggingFace pipeline. Para obter mais detalhes sobre`InferenceSpec`, consulte [InferenceSpec](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.spec.inference_spec.InferenceSpec)o.
```
from sagemaker.serve.spec.inference_spec import InferenceSpec
from transformers import pipeline
class MyInferenceSpec(InferenceSpec):
def load(self, model_dir: str):
return pipeline("translation_en_to_fr", model="t5-small")
def invoke(self, input, model):
return model(input)
inf_spec = MyInferenceSpec()
model_builder = ModelBuilder(
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(X_test, y_pred)
)
```
O exemplo a seguir ilustra uma variação mais personalizada de um exemplo anterior. Um modelo é definido com uma especificação de inferência que tem dependências. Nesse caso, o código na especificação de inferência depende do pacote *lang-segment*. O argumento para `dependencies` contém uma declaração que direciona o construtor a instalar o *lang-segment* usando o Git. Como o construtor de modelos é orientado pelo usuário a instalar uma dependência de forma personalizada, a chave `auto` é `False` para desativar a captura automática de dependências.
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": False, "custom": ["-e git+https://github.com/luca-medeiros/lang-segment-anything.git#egg=lang-sam"],}
)
```
## Criar e implantar seu modelo
Chame a função `build` para criar seu modelo implantável. Essa etapa cria um código de inferência (como `inference.py`) em seu diretório de trabalho com o código necessário para criar seu esquema, executar a serialização e desserialização de entradas e saídas e executar outra lógica personalizada especificada pelo usuário.
Como uma verificação de integridade, a SageMaker IA empacota e seleciona os arquivos necessários para implantação como parte da função de `ModelBuilder` construção. Durante esse processo, a SageMaker IA também cria a assinatura HMAC para o arquivo pickle e adiciona a chave secreta na [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API como uma variável de ambiente durante `deploy` (ou`create`). A inicialização do endpoint usa a variável de ambiente para validar a integridade do arquivo pickle.
```
# Build the model according to the model server specification and save it as files in the working directory
model = model_builder.build()
```
Implante seu modelo com o método `deploy` existente do modelo. Nesta etapa, a SageMaker IA configura um endpoint para hospedar seu modelo à medida que ele começa a fazer previsões sobre as solicitações recebidas. Embora o `ModelBuilder` faça inferência dos recursos de endpoint necessários para implantar seu modelo, você pode substituir essas estimativas por seus próprios valores de parâmetros. O exemplo a seguir orienta a SageMaker IA a implantar o modelo em uma única `ml.c6i.xlarge` instância. Um modelo construído do `ModelBuilder` permite o registro ao vivo durante a implantação como um atributo adicional.
```
predictor = model.deploy(
initial_instance_count=1,
instance_type="ml.c6i.xlarge"
)
```
Se você quiser um controle mais refinado sobre os recursos de endpoint atribuídos ao seu modelo, você pode usar um objeto `ResourceRequirements`. Com o `ResourceRequirements` objeto, você pode solicitar um número mínimo de CPUs aceleradores e cópias dos modelos que deseja implantar. Você também pode solicitar um limite mínimo e máximo de memória (em MB). Para usar esse atributo, você precisa especificar seu tipo de endpoint como `EndpointType.INFERENCE_COMPONENT_BASED`. O exemplo a seguir solicita que quatro aceleradores, um tamanho mínimo de memória de 1024 MB e uma cópia do seu modelo sejam implantados em um endpoint do tipo `EndpointType.INFERENCE_COMPONENT_BASED`.
```
resource_requirements = ResourceRequirements(
requests={
"num_accelerators": 4,
"memory": 1024,
"copies": 1,
},
limits={},
)
predictor = model.deploy(
mode=Mode.SAGEMAKER_ENDPOINT,
endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED,
resources=resource_requirements,
role="role"
)
```
## Traga seu próprio contêiner (BYOC)
Se você quiser trazer seu próprio contêiner (estendido de um contêiner de SageMaker IA), você também pode especificar o URI da imagem, conforme mostrado no exemplo a seguir. Você também precisa identificar o servidor de modelos que corresponde à imagem para o `ModelBuilder` gerar artefatos específicos para o servidor de modelos.
```
model_builder = ModelBuilder(
model=model,
model_server=ModelServer.TORCHSERVE,
schema_builder=SchemaBuilder(X_test, y_pred),
image_uri="123123123123.dkr.ecr.ap-southeast-2.amazonaws.com/byoc-image:xgb-1.7-1")
)
```
## Usando ModelBuilder no modo local
Você pode implantar seu modelo localmente usando o argumento `mode` para alternar entre o teste local e a implantação em um endpoint. Você precisa armazenar os artefatos do modelo no diretório de trabalho, conforme mostrado no seguinte trecho:
```
model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")
```
Aprove o objeto do modelo, uma instância `SchemaBuilder`, e defina o modo como `Mode.LOCAL_CONTAINER`. Quando você chama a função `build`, o `ModelBuilder` automaticamente identifica o contêiner da estrutura compatível e verifica as dependências. O exemplo a seguir demonstra a criação de um modelo com um XGBoost modelo no modo local.
```
model_builder_local = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(X_test, y_pred),
role_arn=execution-role,
mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()
```
Chame a função `deploy` para implantar localmente, conforme mostrado no trecho a seguir. Se você especificar parâmetros para tipo ou contagem de instâncias, esses argumentos serão ignorados.
```
predictor_local = xgb_local_builder.deploy()
```
### Solução de problemas no modo local
Dependendo de sua configuração local individual, você pode ter dificuldades para executar o `ModelBuilder` sem problemas em seu ambiente. Consulte a lista a seguir para ver alguns problemas que você pode enfrentar e como resolvê-los.
+ **Já está em uso**: você pode encontrar um erro `Address already in use`. Nesse caso, é possível que um contêiner do Docker esteja sendo executado nessa porta ou que outro processo o esteja utilizando. Você pode seguir a abordagem descrita na [documentação do Linux](https://www.cyberciti.biz/faq/what-process-has-open-linux-port/) para identificar o processo e redirecionar normalmente seu processo local da porta 8080 para outra porta ou limpar a instância do Docker.
+ **Problema de permissão do IAM**: você pode encontrar um problema de permissão ao tentar extrair uma imagem do Amazon ECR ou acessar o Amazon S3. Nesse caso, navegue até a função de execução do caderno ou da instância do Studio Classic para verificar a política `SageMakerFullAccess` ou as respectivas permissões da API.
+ **Problema de capacidade de volume do EBS**: se você implantar um grande modelo de linguagem (LLM), poderá ficar sem espaço ao executar o Docker no modo local ou ter limitações de espaço no cache do Docker. Nesse caso, você pode tentar mover o volume do Docker para um sistema de arquivos com espaço suficiente. Para mover seu volume do Docker, faça as seguintes etapas:
1. Abra um terminal e execute `df` para exibir o uso do disco, conforme mostrado na saída a seguir.
```
(python3) sh-4.2$ df
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 195928700 0 195928700 0% /dev
tmpfs 195939296 0 195939296 0% /dev/shm
tmpfs 195939296 1048 195938248 1% /run
tmpfs 195939296 0 195939296 0% /sys/fs/cgroup
/dev/nvme0n1p1 141545452 135242112 6303340 96% /
tmpfs 39187860 0 39187860 0% /run/user/0
/dev/nvme2n1 264055236 76594068 176644712 31% /home/ec2-user/SageMaker
tmpfs 39187860 0 39187860 0% /run/user/1002
tmpfs 39187860 0 39187860 0% /run/user/1001
tmpfs 39187860 0 39187860 0% /run/user/1000
```
1. Mova o diretório padrão do Docker de `/dev/nvme0n1p1` para para para que você `/dev/nvme2n1` possa utilizar totalmente o volume SageMaker AI de 256 GB. Para obter mais detalhes, consulte a documentação sobre como [mover seu diretório Docker](https://www.guguweb.com/2019/02/07/how-to-move-docker-data-directory-to-another-location-on-ubuntu/).
1. Pare o Docker com o seguinte comando:
```
sudo service docker stop
```
1. Adicione `daemon.json` ou `/etc/docker` ou anexe o seguinte blob JSON ao blob existente:
```
{
"data-root": "/home/ec2-user/SageMaker/{created_docker_folder}"
}
```
1. Mova o diretório do Docker no `/var/lib/docker` para `/home/ec2-user/SageMaker AI` com o seguinte comando:
```
sudo rsync -aP /var/lib/docker/ /home/ec2-user/SageMaker/{created_docker_folder}
```
1. Inicie o Docker com o seguinte comando:
```
sudo service docker start
```
1. Limpe os resíduos com o seguinte comando:
```
cd /home/ec2-user/SageMaker/.Trash-1000/files/*
sudo rm -r *
```
1. Se você estiver usando uma instância de SageMaker notebook, poderá seguir as etapas no [arquivo de preparação do Docker](https://github.com/melanie531/amazon-sagemaker-pytorch-lightning-distributed-training/blob/main/prepare-docker.sh) para preparar o Docker para o modo local.
## ModelBuilder exemplos
Para obter mais exemplos de uso `ModelBuilder` para criar seus modelos, consulte [ModelBuilderexemplos de cadernos](https://github.com/aws-samples/sagemaker-hosting/blob/main/SageMaker-Model-Builder).
# Otimização de inferência para modelos do Amazon SageMaker AI
Com o Amazon SageMaker AI, você pode melhorar o desempenho de seus modelos de IA generativa aplicando técnicas de otimização de inferência. Ao otimizar seus modelos, você pode obter uma melhor relação custo/desempenho para seu caso de uso. Na otimização de um modelo, você escolhe quais das técnicas de otimização oferecidas devem ser aplicadas, como quantização, decodificação especulativa e compilação. Depois que seu modelo for otimizado, você poderá executar uma avaliação para ver as métricas de desempenho de latência, throughput e preço.
Para muitos modelos, o SageMaker AI também oferece várias versões pré-otimizadas, cada uma projetada para atender a diferentes necessidades de latência e throughput das aplicações. Para esses modelos, você pode implantar uma das versões otimizadas sem primeiro otimizar o modelo por conta própria.
## Técnicas de otimização
O Amazon SageMaker AI oferece as técnicas de otimização a seguir.
### Compilação
A *compilação* otimiza o modelo para obter o melhor desempenho disponível no tipo de hardware escolhido sem perda de precisão. Você pode aplicar a compilação de modelos para otimizar LLMs para um hardware acelerado, como instâncias de GPU, do AWS Trainium ou do AWS Inferentia.
Ao otimizar um modelo com compilação, você se beneficia da compilação antecipada. Você reduz o tempo de implantação e a latência de ajuste de escala automático do modelo porque os respectivos pesos não exigem compilação just-in-time quando o modelo é implantado em uma nova instância.
Se você optar por compilar seu modelo para uma instância de GPU, o SageMaker AI usará a biblioteca TensorRT-LLM para executar a compilação. Se você optar por compilar seu modelo para uma instância do AWS Trainium ou do AWS Inferentia, o SageMaker AI usará o AWS Neuron SDK para executar a compilação.
### Quantização
A *quantização* é uma técnica para reduzir os requisitos de hardware de um modelo usando um tipo de dados menos preciso para os pesos e ativações. Depois de otimizar um modelo com quantização, você pode hospedá-lo em GPUs mais baratas e disponíveis. Contudo, o modelo quantizado pode ser menos preciso do que o modelo de origem que você otimizou.
Os formatos de dados que o SageMaker AI aceita para quantização variam de modelo para modelo. Os formatos compatíveis incluem os seguintes:
+ INT4-AWQ: um formato de dados de 4 bits. A quantização de pesos com reconhecimento de ativação (AWQ) é uma técnica de quantização para LLMs eficiente e precisa que utiliza poucos bits e somente pesos.
+ FP8: ponto flutuante de 8 bits (FP8) é um formato de baixa precisão para números de ponto flutuante. Ele contrabalança eficiência de memória e precisão do modelo representando valores com menos bits do que o formato de ponto flutuante FP16 padrão.
+ INT8-SmoothQuant: um formato de dados de 8 bits. SmoothQuant é um método de quantização de precisão mista que escala ativações e pesos conjuntamente, equilibrando os respectivos intervalos dinâmicos.
### Decodificação especulativa
A *decodificação especulativa* é uma técnica para acelerar o processo de decodificação de LLMs. Ela otimiza os modelos para latência sem comprometer a qualidade do texto gerado.
Essa técnica usa um modelo menor, porém mais rápido, chamado *modelo de rascunho*. O modelo de rascunho gera possíveis tokens, que são então validados pelo *modelo de destino* maior, porém mais lento. Em cada iteração, o modelo de rascunho gera vários tokens possíveis. O modelo de destino verifica os tokens e, se descobrir que determinado token não é aceitável, o rejeita e o regenera. Portanto, o modelo de destino verifica os tokens e gera uma pequena quantidade deles.
O modelo de rascunho é significativamente mais rápido do que o modelo de destino. Ela gera todos os tokens rapidamente e, em seguida, envia lotes de tokens ao modelo de destino para verificação. O modelo de destino avalia todos em paralelo, o que acelera a resposta final.
O SageMaker AI oferece um modelo de rascunho predefinido que você pode usar, para que não precise criar o seu. Se preferir usar um modelo de rascunho personalizado, o SageMaker AI também oferece essa opção.
### Carregamento rápido de modelos
A técnica de *carregamento rápido do modelos* prepara um LLM para que o SageMaker AI possa carregá-lo em uma instância de ML mais rapidamente.
Para preparar o modelo, o SageMaker AI o fragmenta com antecedência, dividindo-o em partes que podem residir em uma GPU separada para inferência distribuída. Além disso, o SageMaker AI armazena os pesos do modelo em partes do mesmo tamanho que ele pode carregar na instância simultaneamente.
Quando o SageMaker AI carrega o modelo otimizado na instância, ele transmite os respectivos pesos diretamente do Amazon S3 para as GPUs da instância. Ao transmitir os pesos, o SageMaker AI omite várias etapas demoradas que normalmente são necessárias. Essas etapas incluem baixar os artefatos do modelo do Amazon S3 para o disco, carregar os artefatos do modelo na memória do host e fragmentar o modelo no host antes de finalmente carregar os fragmentos nas GPUs.
Depois de otimizar seu modelo para um carregamento mais rápido, você pode implantá-lo mais depressa em um endpoint do SageMaker AI. Além disso, se você configurar o endpoint para usar o ajuste de escala automático, a escala horizontal aumentará mais rapidamente para atender a aumentos no tráfego.
# Implantar um modelo pré-otimizado
Alguns modelos no JumpStart são pré-otimizados pelo SageMaker AI, o que significa que você pode implantar versões otimizadas desses modelos sem primeiro criar um trabalho de otimização de inferência.
Para ver a lista de modelos com opções pré-otimizadas, consulte [Modelos do JumpStart pré-otimizados](#pre-optimized-js).
## Amazon SageMaker Studio
Use o procedimento a seguir para implantar um modelo do JumpStart pré-otimizado usando o Amazon SageMaker Studio.
**Como implantar um modelo pré-otimizado**
1. No Studio, no menu de navegação à esquerda, escolha **JumpStart**.
1. Na página **Todos os modelos públicos**, escolha um dos modelos pré-otimizados.
1. Na página de detalhes do portal, escolha **Implantar**.
1. Na página de implantação, alguns modelos do JumpStart exigem que você assine um contrato de licença de usuário final (EULA) para continuar. Se solicitado, analise os termos da licença na seção **Contrato de licença**. Se os termos forem aceitáveis para seu caso de uso, marque a caixa de seleção **Aceito o EULA e li os termos e condições**.
Para ter mais informações, consulte [Contratos de licença de usuário final](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
1. Em **Nome do endpoint** e **Contagem de instâncias inicial**, aceite os valores padrão ou defina valores personalizados.
1. Em **Tipo de instância**, mantenha o valor padrão. Do contrário, você não poderá implantar uma configuração pré-otimizada.
1. Em **Models (Modelos)**, expanda a configuração do modelo. O Studio mostra uma tabela que apresenta as configurações pré-otimizadas que você pode escolher. Cada opção tem métricas de latência e throughput. Escolha a opção que melhor atenda às necessidades da sua aplicação.
1. Escolha **Implantar**.
## SageMaker AI Python SDK
Você pode implantar um modelo pré-otimizado usando o SageMaker AI Python SDK em seu projeto. Primeiro, defina uma instância `Model` usando a classe `ModelBuilder`. Em seguida, você use o método `set_deployment_config()` para definir a configuração pré-otimizada que deseja implantar. Depois, use o método `build()` para criar o modelo. Por fim, use o método `deploy()` para implantá-lo em um endpoint de inferência.
Para ter mais informações sobre as classes e os métodos usados nos exemplos a seguir, consulte [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html) na documentação do SageMaker AI Python SDK.
**Como configurar o projeto**
1. No código da sua aplicação, importe as bibliotecas necessárias. O exemplo a seguir importa o SDK para Python (Boto3). Ele também importa os módulos do SageMaker AI Python SDK que você usa para definir e trabalhar com modelos:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. Inicialize uma sessão do SageMaker AI. O seguinte exemplo usa a classe `Session()`:
```
sagemaker_session = Session()
```
**Como definir seu modelo**
1. Crie uma instância `SchemaBuilder` e forneça amostras de entrada e saída. Você deve fornecer essa instância para a classe `ModelBuilder` ao definir um modelo. Com ela, o SageMaker AI gera automaticamente as funções de organização para serializar e desserializar a entrada e a saída.
Para ter mais informações sobre como usar as classes `SchemaBuilder` e `ModelBuilder`, consulte [Crie um modelo na Amazon SageMaker AI com ModelBuilder](how-it-works-modelbuilder-creation.md).
O seguinte exemplo apresenta amostras de strings de entrada e saída para a classe `SchemaBuilder`:
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Defina seu modelo para o SageMaker AI. O seguinte exemplo define os parâmetros para inicializar uma instância `ModelBuilder`:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Este exemplo usa um modelo do JumpStart. Substitua `jumpstart-model-id` pelo ID de um modelo do JumpStart, como `meta-textgeneration-llama-3-70b`.
**Como recuperar métricas de referência**
1. Para determinar qual configuração pré-otimizada você deseja implantar, consulte as opções que o SageMaker AI oferece. O seguinte exemplo as exibe:
```
model_builder.display_benchmark_metrics()
```
O método `display_benchmark_metrics()` imprime uma tabela da seguinte forma:
```
| Instance Type | Config Name | Concurrent Users | Latency, TTFT (P50 in sec) | Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge | lmi-optimized | 1 | 2.25 | 49.70 |
| ml.g5.48xlarge | lmi-optimized | 2 | 2.28 | 21.10 |
| ml.g5.48xlarge | lmi-optimized | 4 | 2.37 | 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized | 1 | 0.10 | 137.40 |
| ml.p4d.24xlarge | lmi-optimized | 2 | 0.11 | 109.20 |
| ml.p4d.24xlarge | lmi-optimized | 4 | 0.13 | 85.00 |
. . .
```
Na primeira coluna, a tabela lista os tipos possíveis de instância que você pode usar para hospedar o modelo escolhido do JumpStart. Para cada tipo de instância, em `Config Name`, ela lista o nome das configurações pré-otimizadas. As configurações que o SageMaker AI oferece são denominadas `lmi-optimized`. Para cada tipo e configuração de instância, a tabela apresenta métricas de referência. Essas métricas indicam o throughput e a latência que o modelo comportará para números diferentes de usuários simultâneos.
1. Com base nas métricas de referência, escolha o tipo de instância e o nome da configuração que melhor atendam às suas necessidades de desempenho. Você usará esses valores quando criar uma configuração de implantação.
**Como implantar um modelo pré-otimizado**
1. Crie uma configuração de implantação. O exemplo a seguir usa uma instância `ModelBuilder`. Ele passa um tipo de instância e um nome de configuração para o método `set_deployment_config()`:
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
Substitua *`config-name`* por um nome de configuração da tabela, como `lmi-optimized`. Substitua `instance-type` por um tipo de instância da tabela, como `ml.p4d.24xlarge`.
1. Compile seu modelo. O exemplo a seguir usa o método `.build()` da instância `ModelBuilder`:
```
optimized_model = model_builder.build()
```
O método `.build()` exibe uma instância `Model` implantável.
1. Implante seu modelo em um endpoint de inferência. O exemplo a seguir usa o método `.deploy()` da instância `Model`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
O método `deploy()` exibe uma instância `Predictor`, que você pode usar para enviar solicitações de inferência ao modelo.
**Como testar seu modelo com uma solicitação de inferência**
+ Depois de implantar seu modelo em um endpoint de inferência, teste as respectivas predições. O seguinte exemplo envia uma solicitação de inferência usando a instância `Predictor`:
```
predictor.predict(sample_input)
```
O modelo exibe o texto que ele gera com uma resposta como a seguinte:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## Modelos do JumpStart pré-otimizados
A seguir estão os modelos do JumpStart que têm configurações pré-otimizadas.
**Meta**
+ Llama 3.1 70B Instruct
+ Llama 3.1 70B
+ Llama 3.1 405B Instruct FP8
+ Llama 3.1 405B FP8
+ Llama 3 8B Instruct
+ Llama 3 8B
+ Llama 3 70B Instruct
+ Llama 3 70B
+ Llama 2 70B Chat
+ Llama 2 7B Chat
+ Llama 2 13B Chat
**HuggingFace**
+ Mixtral 8x7B Instruct
+ Mixtral 8x7B
+ Mistral 7B Instruct
+ Mistral 7B
### Modelos do JumpStart predefinidos
Para alguns modelos e configurações, o SageMaker AI oferece modelos predefinidos para instâncias específicas do AWS Inferentia e AWS Trainium. Para isso, se você criar um trabalho de otimização de compilação e escolher ml.inf2.48xlarge ou ml.trn1.32xlarge como o tipo de instância de implantação, o SageMaker AI buscará os artefatos compilados. Como o trabalho usa um modelo já compilado, ele é concluído rapidamente sem executar a compilação do zero.
Abaixo estão os modelos do JumpStart para os quais o SageMaker AI tem modelos predefinidos:
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Code Llama 7B
+ Code Llama 70B
**HuggingFace**
+ Mistral 7B
# Criar um trabalho de otimização de inferência
Você pode criar um trabalho de otimização de inferência usando o Studio ou o SDK SageMaker AI Python. O trabalho otimiza seu modelo aplicando as técnicas que você escolher. Para obter mais informações, consulte [Técnicas de otimização](model-optimize.md#optimization-techniques).
**Preços de instâncias para trabalhos de otimização de inferência**
Quando você cria um trabalho de otimização de inferência que aplica quantização ou compilação, a SageMaker IA escolhe qual tipo de instância usar para executar o trabalho. Você recebe cobranças com base na instância usada.
Para ver os possíveis tipos de instância e seus detalhes de preços, consulte as informações de preços de otimização de inferência na página de [ SageMaker preços da Amazon](https://aws.amazon.com/sagemaker/pricing/).
Você não terá custos adicionais para trabalhos que aplicam decodificação especulativa.
Para ver os modelos compatíveis que você pode otimizar, consulte [Referência de modelos compatíveis](optimization-supported-models.md).
## SageMaker Estúdio Amazon
Conclua as etapas a seguir para criar um trabalho de otimização de inferência no Studio.
**Como começar a criar um trabalho de otimização**
1. No SageMaker AI Studio, crie um trabalho de otimização por meio de qualquer um dos seguintes caminhos:
+ Para criar um trabalho para um JumpStart modelo, faça o seguinte:
1. No menu de navegação, selecione **JumpStart**.
1. Na página **Todos os modelos públicos**, escolha um fornecedor de modelos e selecione um dos modelos que permitem otimização.
1. Na página de detalhes do modelo, escolha **Otimizar**. Esse botão está habilitado somente para modelos que permitem otimização.
1. Na página **Criar tarefa de otimização de inferência**, alguns JumpStart modelos exigem que você assine um contrato de licença de usuário final (EULA) antes de continuar. Se solicitado, analise os termos da licença na seção **Contrato de licença**. Se os termos forem aceitáveis para seu caso de uso, marque a caixa de seleção **Aceito o EULA e li os termos e condições**.
+ Para criar um trabalho para um JumpStart modelo ajustado, faça o seguinte:
1. No painel de navegação, em **Trabalhos**, escolha **Treinamento**.
1. Na página **Tarefas de treinamento**, escolha o nome de uma tarefa que você usou para ajustar um JumpStart modelo. Esses trabalhos têm o tipo **JumpStarttreinamento** na coluna **Tipo de trabalho**.
1. Na página de detalhes da tarefa de treinamento, escolha **Otimizar**.
+ Para criar um trabalho para um modelo personalizado, faça o seguinte:
1. No menu de navegação, em **Trabalho**, escolha **Otimização da inferência**.
1. Escolha **Create new job** (Criar uma nova tarefa).
1. Na página **Criar trabalho de otimização de inferência**, escolha **Adicionar modelo**.
1. Na janela **Adicionar modelo**, escolha **Modelo personalizado**.
1. Escolha uma das seguintes opções:
**Use seu modelo existente:** selecione essa opção para otimizar um modelo que você já criou na SageMaker IA.
**Nome do modelo existente** - insira o nome do seu modelo de SageMaker IA.
**Do S3** - Selecione essa opção para fornecer artefatos de modelo do Amazon S3. Em **URI do S3**, insira o URI do local no Amazon S3 em que você armazenou os artefatos do seu modelo.
1. (Opcional) Em ****Nome do modelo de saída****, você pode inserir um nome personalizado para o modelo otimizado que o trabalho cria. Se você não fornecer um nome, o Studio gerará automaticamente um com base na sua seleção.
1. Na página **Criar tarefa de otimização de inferência**, em **Job name**, você pode aceitar o nome padrão que a SageMaker IA atribui. Outra opção é, para inserir um nome de trabalho personalizado, escolher o campo **Nome do trabalho** e selecionar **Inserir nome do trabalho**.
**Como definir as configurações de otimização**
1. Em **Tipo de instância de implantação**, escolha o tipo de instância para o qual você deseja otimizar o modelo.
O tipo de instância afeta as técnicas de otimização que você pode escolher. Para a maioria dos tipos que usam hardware de GPU, as técnicas permitidas são **quantização** e **decodificação especulativa**. Se você escolher uma instância que usa silício personalizado, como a instância AWS Inferentia ml.inf2.8xlarge, a técnica suportada é a **Compilação, que você pode usar para compilar** o modelo para esse tipo específico de hardware.
1. Selecione uma ou mais entre as técnicas de otimização que o Studio oferece:
+ Se você selecionar **Quantização**, escolha um tipo de dados para **Tipo de dados de precisão**.
+ Se você selecionar **Decodificação especulativa**, escolha uma das seguintes opções:
+ **Use o modelo de rascunho de SageMaker IA** — Escolha usar o modelo de rascunho fornecido pela SageMaker IA.
**nota**
Se você optar por usar o modelo de rascunho de SageMaker IA, também deverá habilitar o isolamento da rede. O Studio oferece essa opção em **Segurança**.
+ **Escolha o modelo de JumpStart rascunho** — Escolha selecionar um modelo do JumpStart catálogo para usar como seu modelo de rascunho.
+ **Escolher seu próprio modelo de rascunho**: opte por usar seu próprio modelo de rascunho e forneça o URI do S3 que o localiza.
+ Se você escolher **Carregamento rápido do modelo**, o Studio mostrará a variável de ambiente `OPTION_TENSOR_PARALLEL_DEGREE`. Use o campo **Valor** para definir o grau de paralelismo do tensor. O valor deve dividir uniformemente o número de GPUs na instância que você escolheu para o **tipo de instância de implantação**. Por exemplo, para fragmentar seu modelo ao usar uma instância com 8 GPUs, use os valores 2, 4 ou 8.
+ Se você definir o **tipo de instância de implantação** como uma instância AWS Inferentia ou AWS Trainium, o Studio poderá mostrar que a **compilação** é a única opção compatível. Nesse caso, o Studio seleciona essa opção para você.
1. Em **Saída**, insira o URI de um local no Amazon S3. Lá, a SageMaker IA armazena os artefatos do modelo otimizado que seu trabalho cria.
1. (Opcional) Expanda **Opções avançadas** para conseguir um controle mais refinado sobre as configurações, como o perfil do IAM, a VPC e as variáveis de ambiente. Para ter mais informações, consulte *Opções avançadas* abaixo.
1. Quando terminar de configurar o trabalho, escolha **Criar trabalho**.
O Studio mostra a página de detalhes do trabalho, que exibe o status e todas as suas configurações do trabalho.
### Opções avançadas
Você pode definir as opções avançadas a seguir ao criar um trabalho de otimização de inferência.
Em **Configurações**, você pode definir as seguintes opções:
**Tensor de grau paralelo **
Um valor para o grau de *paralelismo de tensores*. O paralelismo de tensores é um tipo de paralelismo de modelo no qual pesos, gradientes e estados do otimizador específicos do modelo são divididos entre dispositivos. O valor deve dividir uniformemente o número de GPUs em seu cluster.
**Tamanho máximo de tokens**
O limite para o número de tokens a serem gerados pelo modelo. Observe que o modelo nem sempre gera o número máximo de tokens.
**Simultaneidade**
A possibilidade de executar várias instâncias de um modelo no mesmo hardware subjacente. Use a simultaneidade para fornecer predições a vários usuários e maximizar a utilização de hardware.
**Tamanho do lote**
Se seu modelo fizer *inferência em lote*, use essa opção para controlar o tamanho dos lotes que ele processa.
A predição em lote, também conhecida como inferência off-line, 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 quando você não precisa de uma resposta imediata a uma solicitação de predição de modelo.
Em **Segurança**, você pode definir as seguintes opções:
**Perfil do IAM**
Uma função do IAM que permite que a SageMaker IA execute tarefas em seu nome. Durante a otimização do modelo, a SageMaker IA precisa da sua permissão para:
+ Ler dados de entrada de um bucket do S3.
+ Gravar artefatos do modelo em um bucket do S3.
+ Grave registros no Amazon CloudWatch Logs
+ Publique métricas na Amazon CloudWatch
Você concede permissões para todas essas tarefas a um perfil do IAM.
Para obter mais informações, consulte [Como usar funções de execução de SageMaker IA](sagemaker-roles.md).
**Chave de criptografia do KMS**
Uma chave em AWS Key Management Service (AWS KMS). SageMaker A IA usa a chave para criptografar os artefatos do modelo otimizado quando a SageMaker IA carrega o modelo no Amazon S3.
**VPC**
SageMaker A IA usa essas informações para criar interfaces de rede e anexá-las aos seus contêineres de modelo. As interfaces de rede concedem aos contêineres de modelo uma conexão de rede na sua VPC, sem acesso à Internet. Além disso, permitem que o modelo conecte-se aos recursos da VPC privada.
Para obter mais informações, consulte [Dê aos endpoints hospedados por SageMaker IA acesso aos recursos em sua Amazon VPC](host-vpc.md).
**Habilitar isolamento de rede**
Ative essa opção se quiser restringir o acesso do contêiner à internet. Os contêineres que funcionam com isolamento de rede não podem fazer nenhuma chamada de rede de saída.
Você deve ativar essa opção ao otimizar com decodificação especulativa e usar o modelo de rascunho de SageMaker IA.
Para ter mais informações sobre níveis de isolamento, consulte [Isolamento de rede](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
Em **Definição avançada de contêiner**, você pode definir as seguintes opções:
**Condição de interrupção**
Especifica o tempo máximo durante o qual um trabalho pode ser executado. Quando o trabalho atinge o limite de tempo, a SageMaker IA termina o trabalho. Use essa opção para limitar os custos.
**Tags**
Pares de chave-valor associados ao trabalho de otimização.
Para ter mais informações sobre tags, consulte [Tagging AWS resources](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) no *Referência geral da AWS*.
**Variáveis de ambiente**
Pares de chave-valor que especificam as variáveis de ambiente que devem ser definidas no contêiner do modelo.
## SageMaker SDK AI para Python
Você pode criar um trabalho de otimização de inferência usando o SDK SageMaker AI Python em seu projeto. Primeiro, defina uma instância `Model` usando a classe `ModelBuilder`. Em seguida, use o método `optimize()` para executar um trabalho que otimize seu modelo com quantização, decodificação especulativa ou compilação. Quando o trabalho estiver concluído, implante o modelo em um endpoint de inferência usando o método `deploy()`.
Para obter mais informações sobre as classes e os métodos usados nos exemplos a seguir, consulte [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)a documentação do SDK para SageMaker AI Python.
**Como configurar o projeto**
1. No código da sua aplicação, importe as bibliotecas necessárias. O exemplo a seguir importa o SDK para Python (Boto3). Ele também importa as classes do SDK SageMaker AI Python que você usa para definir e trabalhar com modelos:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
from pathlib import Path
```
1. Inicialize uma sessão de SageMaker IA. O seguinte exemplo usa a classe `Session()`:
```
sagemaker_session = Session()
```
**Como definir seu modelo**
1. Crie uma instância `SchemaBuilder` e forneça amostras de entrada e saída. Forneça essa instância para a classe `ModelBuilder` ao definir um modelo. Com isso, a SageMaker IA gera automaticamente as funções de organização para serializar e desserializar a entrada e a saída.
Para ter mais informações sobre como usar as classes `SchemaBuilder` e `ModelBuilder`, consulte [Crie um modelo na Amazon SageMaker AI com ModelBuilder](how-it-works-modelbuilder-creation.md).
O seguinte exemplo apresenta amostras de strings de entrada e saída para a classe `SchemaBuilder`:
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Defina seu modelo para SageMaker IA. O seguinte exemplo define os parâmetros para inicializar uma instância `ModelBuilder`:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Este exemplo usa um JumpStart modelo. `jumpstart-model-id`Substitua pela ID de um JumpStart modelo, como`meta-textgeneration-llama-3-70b`.
**nota**
Se você quiser otimizar com decodificação especulativa e usar o rascunho de SageMaker IA, você deve habilitar o isolamento da rede. Para habilitá-lo, inclua o seguinte argumento ao inicializar uma instância `ModelBuilder`:
```
enable_network_isolation=True,
```
Para ter mais informações sobre níveis de isolamento, consulte [Isolamento de rede](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
**Como realizar a otimização com quantização**
1. Para executar um trabalho de quantização, use o método `optimize()` e defina o argumento `quantization_config`. O seguinte exemplo define `OPTION_QUANTIZE` como uma variável de ambiente no contêiner de otimização:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
Neste exemplo, substitua *`instance-type`* por uma instância de ML, como `ml.p4d.24xlarge`. Substitua *`s3://output-path`* pelo caminho para o local do S3 onde você armazena o modelo otimizado criado pelo trabalho.
O método `optimize()` exibe um objeto `Model`, que você pode usar para implantar o modelo em um endpoint.
1. Quando o trabalho for concluído, implante o modelo. O seguinte exemplo usa o método `deploy()`:
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
Neste exemplo, substitua *`instance-type`* por uma instância de ML, como `ml.p4d.24xlarge`.
O método `deploy()` exibe um objeto preditor, que pode ser usado para enviar solicitações de inferência ao endpoint que hospeda o modelo.
**Para otimizar com decodificação especulativa usando o modelo de esboço de SageMaker IA**
Ao otimizar seu modelo com decodificação especulativa, você pode optar por usar um modelo de rascunho fornecido pela SageMaker IA ou usar o seu próprio. Os exemplos a seguir usam o modelo de rascunho de SageMaker IA.
**Pré-requisito**
Para otimizar com a decodificação especulativa e o modelo de esboço de SageMaker IA, você deve ativar o isolamento da rede ao definir seu modelo.
1. Para executar um trabalho de decodificação especulativa, use o método `optimize()` e defina o argumento `speculative_decoding_config`. O exemplo a seguir define a `ModelProvider` chave `SAGEMAKER` para usar o modelo de rascunho fornecido pela SageMaker IA.
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
Neste exemplo, substitua *`instance-type`* por uma instância de ML, como `ml.p4d.24xlarge`.
O método `optimize()` exibe um objeto `Model`, que você pode usar para implantar o modelo em um endpoint.
1. Quando o trabalho for concluído, implante o modelo. O seguinte exemplo usa o método `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
O método `deploy()` exibe um objeto preditor, que você pode usar para enviar solicitações de inferência ao endpoint que hospeda o modelo.
**Como realizar a otimização com decodificação especulativa usando um modelo de rascunho personalizado**
Antes de fornecer seu modelo de rascunho personalizado para a SageMaker IA, você deve primeiro fazer o upload dos artefatos do modelo para o Amazon S3.
Os exemplos a seguir demonstram uma forma possível de fornecer um modelo de rascunho personalizado. Os exemplos baixam o rascunho do modelo do Hugging Face Hub, fazem upload no Amazon S3 e fornecem o URI do S3 para o argumento `speculative_decoding_config`.
1. Se você quiser baixar um modelo do Hugging Face Hub, adicione a biblioteca `huggingface_hub` ao seu projeto e baixe um modelo com o método `snapshot_download()`. O seguinte exemplo baixa um modelo em um diretório local:
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
Neste exemplo, substitua *`model-id`* pelo ID de um modelo do Hugging Face Hub, como `meta-llama/Meta-Llama-3-8B`. Substitua *`download-dir`* por um diretório local. Substitua *`hf-access-token`* pelo seu token de acesso de usuário. Para saber como obter seu token de acesso, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens) na documentação da Hugging Face.
Para saber mais sobre a biblioteca `huggingface_hub`, consulte a [Hub client library](https://huggingface.co/docs/huggingface_hub/en/index) na documentação da Hugging Face.
1. Para disponibilizar seu modelo baixado para a SageMaker IA, faça o upload para o Amazon S3. O seguinte exemplo faz upload do objeto para com o objeto `sagemaker_session`:
```
custom_draft_model_uri = sagemaker_session.upload_data(
path=hf_local_download_dir.as_posix(),
bucket=sagemaker_session.default_bucket(),
key_prefix="prefix",
)
```
Neste exemplo, substitua *`prefix`* por um qualificador que ajude você a distinguir o modelo de rascunho no S3, como `spec-dec-custom-draft-model`.
O método `upload_data()` exibe o URI do S3 para os artefatos do modelo.
1. Para executar um trabalho de decodificação especulativa, use o método `optimize()` e defina o argumento `speculative_decoding_config`. O seguinte exemplo define a chave `ModelSource` para o URI do S3 do modelo de rascunho personalizado:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
Neste exemplo, substitua *`instance-type`* por uma instância de ML, como `ml.p4d.24xlarge`.
O método `optimize()` exibe um objeto `Model`, que você pode usar para implantar o modelo em um endpoint.
1. Quando o trabalho for concluído, implante o modelo. O seguinte exemplo usa o método `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
O método `deploy()` exibe um objeto preditor, que você pode usar para enviar solicitações de inferência ao endpoint que hospeda o modelo.
**Como otimizar com a compilação**
1. Para executar um trabalho de compilação, use o método `optimize()` e defina o argumento `compilation_config`. O seguinte exemplo usa a chave `OverrideEnvironment` para definir as variáveis de ambiente necessárias no contêiner de otimização:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
compilation_config={
"OverrideEnvironment": {
"OPTION_TENSOR_PARALLEL_DEGREE": "24",
"OPTION_N_POSITIONS": "8192",
"OPTION_DTYPE": "fp16",
"OPTION_ROLLING_BATCH": "auto",
"OPTION_MAX_ROLLING_BATCH_SIZE": "4",
"OPTION_NEURON_OPTIMIZE_LEVEL": "2",
}
},
output_path="s3://output-path",
)
```
Neste exemplo, defina *`instance-type`* como um tipo de instância de ML com hardware acelerado. Por exemplo, para inferência acelerada com AWS inferência, você pode definir o tipo como uma instância Inf2, como. `ml.inf2.48xlarge` Substitua *`s3://output-path`* pelo caminho para o local do S3 onde você armazena o modelo otimizado criado pelo trabalho.
1. Quando o trabalho for concluído, implante o modelo. O seguinte exemplo usa o método `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
O método `deploy()` exibe um objeto preditor, que você pode usar para enviar solicitações de inferência ao endpoint que hospeda o modelo.
**Como testar seu modelo com uma solicitação de inferência**
+ Para enviar uma solicitação de inferência de teste ao modelo implantado, use o método `predict()` de um objeto preditor. O seguinte exemplo passa a variável `sample_input`, que também foi passada para a classe `SchemaBuilder` nos exemplos para definir seu modelo:
```
predictor.predict(sample_input)
```
A entrada da amostra tem o prompt `"What is the largest planet in the solar system?"`. O método `predict()` exibe a resposta que o modelo gerou, conforme mostrado no seguinte exemplo:
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## AWS SDK para Python (Boto3)
Você pode usar o AWS SDK para Python (Boto3) para criar e gerenciar programaticamente trabalhos de otimização de inferência. Esta seção fornece exemplos de diferentes técnicas de otimização.
**Pré-requisitos**
Antes de criar um trabalho de otimização com o Boto3, verifique se você tem:
+ AWS Credenciais configuradas - Configure suas AWS credenciais com as permissões apropriadas
+ Criou um modelo de SageMaker IA (se estiver usando um modelo existente)
+ Dados de treinamento preparados no S3 (para otimização de decodificação especulativa, comprimento de contexto suportado de até 4096)
+ Função do IAM com as permissões necessárias — Sua função de execução deve ter permissões para acessar o S3 e criar recursos SageMaker
**Exemplo: Crie um Job de Otimização com a Decodificação EAGLE Speculative (Llama 3.3 70B)**
Este exemplo demonstra a criação de um trabalho de otimização para um grande modelo de linguagem usando a técnica de decodificação especulativa EAGLE:
```
import boto3
# Initialize SageMaker client
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Step 1: Create a SageMaker model (if not already created)
model_response = sagemaker_client.create_model(
ModelName='meta-llama-3-3-70b-instruct',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/Llama-3.3-70B-Instruct/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'SAGEMAKER_ENV': '1',
'SAGEMAKER_MODEL_SERVER_TIMEOUT': '3600'
}
}
)
# Step 2: Create optimization job with speculative decoding
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'meta-llama-3-3-70b-instruct'
}
},
DeploymentInstanceType='ml.p4d.24xlarge',
# MaxInstanceCount specifies the maximum number of instances for distributed training
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_8k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/llama-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Exemplo: Criar um Job de Otimização a partir de artefatos do modelo S3 (Qwen3 32B)**
Este exemplo mostra como criar um trabalho de otimização usando artefatos de modelo diretamente do S3:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Create model from S3 artifacts
model_response = sagemaker_client.create_model(
ModelName='qwen3-32b',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'Mode': 'SingleModel',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/qwen3-32b/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'AWS_REGION': 'us-west-2'
}
}
)
# Create optimization job with smaller training dataset
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='qwen3-optim-job-eagle',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'qwen3-32b'
}
},
DeploymentInstanceType='ml.g6.48xlarge',
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_1k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/qwen3-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Exemplo: monitorar e gerenciar tarefas de otimização**
Depois de criar um trabalho de otimização, você pode monitorar seu progresso e gerenciá-lo usando estes comandos:
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Describe optimization job to check status
describe_response = sagemaker_client.describe_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
)
print(f"Job Status: {describe_response['OptimizationJobStatus']}")
# List all optimization jobs (with pagination)
list_response = sagemaker_client.list_optimization_jobs(
MaxResults=10,
SortBy='CreationTime',
SortOrder='Descending'
)
print("\nRecent optimization jobs:")
for job in list_response['OptimizationJobSummaries']:
print(f"- {job['OptimizationJobName']}: {job['OptimizationJobStatus']}")
# Stop a running optimization job if needed
# sagemaker_client.stop_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
# Delete a completed or failed optimization job
# sagemaker_client.delete_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
```
A decodificação especulativa com Eagle Heads executa quatro trabalhos de treinamento sequenciais. Cada trabalho produz uma saída que se torna a entrada para a próxima. Somente a saída do trabalho final é entregue ao seu bucket do S3. As saídas intermediárias são criptografadas e armazenadas em um bucket de serviços de SageMaker IA interno por até 20 dias. SageMaker A IA não tem permissões para descriptografá-los. Se você quiser que os dados intermediários sejam removidos antes desse período, verifique se seu trabalho foi concluído ou interrompido e, em seguida, abra um caso de suporte [[https://docs.aws.amazon.com/awssupport/latest/user/case-management.html\$1 creating-a-support-case](https://docs.aws.amazon.com/awssupport/latest/user/case-management.html#creating-a-support-case)] para que esses dados sejam excluídos. Inclua na solicitação o ID da sua AWS conta e o ARN do trabalho de otimização.
## Limitações do modelo preliminar de SageMaker IA
Para qualquer modelo que você otimize com o modelo preliminar de SageMaker IA, esteja ciente dos requisitos, restrições e variáveis de ambiente suportadas.
**Requisitos**
Faça o seguinte:
+ Use um modelo fornecido pela SageMaker JumpStart.
+ Habilite o isolamento de rede para a implantação do modelo.
+ Se você implantar o modelo em um contêiner de inferência de modelo grande (LMI), use um DJLServing contêiner na versão 0.28.0 ou superior.
Para ver os contêineres disponíveis, consulte [Contêineres de inferência de modelos grandes](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) no GitHub repositório Deep Learning Containers.
+ Se você ajustar o JumpStart modelo, use o formato de sensores de segurança para os pesos do modelo.
Para ter mais informações sobre esse formato, consulte [Safetensors](https://huggingface.co/docs/safetensors/en/index) na documentação da Hugging Face.
**Restrições**
Você não pode fazer o seguinte:
+ Use o modelo em ambientes de teste locais que você cria com o modo local.
Para obter mais informações sobre o modo local, consulte [Modo local](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode) na documentação do SDK para SageMaker AI Python.
+ Acesse o contêiner do modelo por meio do AWS Systems Manager Agente (Agente SSM). O SSM Agent fornece acesso em nível de shell ao seu contêiner de modelo para que você possa depurar processos e registrar comandos com a Amazon. CloudWatch
Para ter mais informações sobre esse recurso, consulte [Acesso a contêineres por meio do SSM](ssm-access.md).
+ Configure o contêiner do modelo para gerar um dump de memória se o processo falhar.
Para obter mais informações sobre despejos principais de contêineres de modelos, consulte [ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html).
+ Implante o modelo em endpoints multimodelo, endpoints de vários contêineres ou endpoints que hospedam componentes de inferência.
Para ter mais informações sobre esses tipos de endpoint, consulte [Endpoints multimodelo](multi-model-endpoints.md), [Endpoint com vários contêineres](multi-container-endpoints.md) e [Componentes de inferência](realtime-endpoints-deploy-models.md#inference-components).
+ Crie um pacote de modelo para o modelo. Você usa pacotes de modelos para criar modelos implantáveis nos quais você publica. AWS Marketplace
Para ter mais informações sobre esse recurso, consulte [Criar um recurso de pacote de modelos](sagemaker-mkt-create-model-package.md).
+ Use o seu próprio código de inferência no contêiner do modelo.
+ Use um arquivo `requirements.txt` no contêiner do modelo. Esse tipo de arquivo lista as dependências do pacote.
+ Habilite o parâmetro `trust_remote_code` do Hugging Face.
**Variáveis de ambiente compatíveis**
É possível configurar o contêiner somente com as seguintes variáveis de ambiente:
+ Variáveis de ambiente comuns para contêineres de inferência de grandes modelos (LMI).
Para ter mais informações sobre essas variáveis, consulte [Environment Variable Configurations](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations) na documentação do contêiner de LMI.
+ Variáveis de ambiente comuns para pacotes que o Hugging Face Hub fornece nos respectivos repositórios do Git.
Para os repositórios, consulte [Hugging Face on](https://github.com/huggingface). GitHub
+ Variáveis de ambiente comuns PyTorch e CUDA.
Para obter mais informações sobre essas variáveis, consulte [Variáveis de ambiente Torch](https://pytorch.org/docs/stable/torch_environment_variables.html) na PyTorch documentação.
# Visualizar os resultados do trabalho de otimização
Depois de criar um ou mais trabalhos de otimização, você pode usar o Studio para visualizar uma tabela resumida de todos os trabalhos e os detalhes de qualquer trabalho individual.
## Amazon SageMaker Studio
**Como visualizar a tabela de resumo do trabalho de otimização**
+ No menu de navegação, em **Trabalho**, escolha **Otimização da inferência**.
A página **Otimização da inferência** mostra uma tabela que exibe os trabalhos que você criou. Para cada trabalho, ela mostra as configurações de otimização que você aplicou e o status do trabalho.
**Como visualizar os detalhes de um trabalho**
+ Na página **Otimização da inferência**, na tabela de resumo, escolha o nome do trabalho.
O Studio mostra a página de detalhes do trabalho, que exibe o status do trabalho e todas as configurações que você aplicou ao criá-lo. Quando o trabalho é concluído com sucesso, o SageMaker AI armazena os artefatos do modelo otimizado no local do Amazon S3 em **URI do modelo otimizado do S3.**
# Avaliar o desempenho de modelos otimizados
Depois de usar um trabalho de otimização para criar um modelo otimizado, você pode executar uma avaliação do desempenho do modelo. Essa avaliação gera métricas de latência, throughput e preço. Use essas métricas para avaliar se o modelo otimizado atende às necessidades do seu caso de uso ou se requer maior otimização.
Você pode executar avaliações de desempenho somente por meio do Studio. Esse recurso não é fornecido por meio da Amazon SageMaker AI API ou do Python SDK.
## Antes de começar
Para criar uma avaliação de desempenho, você deve primeiro otimizar um modelo criando um trabalho de otimização de inferência. No Studio, é possível avaliar apenas os modelos criados com esses trabalhos.
## Criar a avaliação de desempenho
Conclua as etapas a seguir no Studio para criar uma avaliação de desempenho para um modelo otimizado.
1. No menu de navegação, em **Trabalho**, escolha **Otimização da inferência**.
1. Escolha o nome do trabalho que criou o modelo otimizado que você deseja avaliar.
1. Na página de detalhes do trabalho, escolha **Avaliar desempenho**.
1. Na página **Avaliar desempenho**, alguns JumpStart modelos exigem que você assine um contrato de licença de usuário final (EULA) antes de continuar. Se solicitado, analise os termos da licença na seção **Contrato de licença**. Se os termos forem aceitáveis para seu caso de uso, marque a caixa de seleção **Aceito o EULA e li os termos e condições**.
1. Em **Selecione um modelo para o tokenizador**, aceite o padrão ou escolha um modelo específico para atuar como tokenizador em sua avaliação.
1. Em **Conjuntos de dados de entrada**, escolha se deseja:
+ Use os conjuntos de dados de amostra padrão da SageMaker IA.
+ Fornecer um URI do S3 que aponte para seus próprios conjuntos de dados de amostra.
1. Em **URI do S3 para resultados de desempenho**, forneça um URI que aponte para o local no Amazon S3 onde você deseja armazenar os resultados da avaliação.
1. Escolha **Avaliar**.
O Studio mostra a página **Avaliações de desempenho**, onde seu trabalho de avaliação é mostrado na tabela. A coluna **Status** mostra o status da sua avaliação.
1. Quando o status for **Concluído**, escolha o nome do trabalho para ver os resultados da avaliação.
A página de detalhes da avaliação mostra tabelas que fornecem as métricas de desempenho de latência, throughput e preço. Para ter mais informações sobre cada métrica, consulte [Referência de métricas para avaliações de desempenho de inferência](#performance-eval-metrics-reference).
## Referência de métricas para avaliações de desempenho de inferência
Depois de avaliar com sucesso o desempenho de um modelo otimizado, a página de detalhes da avaliação no Studio mostra as métricas a seguir.
### Métricas de latência
A seção **Latência** mostra as métricas a seguir.
**Simultaneidade**
O número de usuários simultâneos que a avaliação simulou para invocar o endpoint simultaneamente.
**Tempo até o primeiro token (ms)**
O tempo decorrido entre o envio da solicitação e o recebimento do primeiro token de uma resposta de streaming.
**Latência entre tokens (ms)**
O tempo para gerar um token de saída para cada solicitação.
**Latência do cliente (ms)**
A latência da solicitação desde o momento em que a solicitação é enviada até o momento em que a resposta inteira é recebida.
**Entrada tokens/sec (contagem)**
O número total de tokens de entrada gerados, em todas as solicitações, dividido pela duração total em segundos da simultaneidade.
**Saída tokens/sec (contagem)**
O número total de tokens de saída gerados, em todas as solicitações, dividido pela duração total em segundos da simultaneidade.
**Invocações de cliente (contagem)**
O número total de solicitações de inferência enviadas ao endpoint para todos os usuários em uma simultaneidade.
**Erros de invocação de cliente (contagem)**
O número total de solicitações de inferência enviadas ao endpoint para todos os usuários em uma determinada simultaneidade que provocou um erro de invocação.
**Falha no tokenizador (contagem)**
O número total de solicitações de inferência em que o tokenizador falhou ao analisar a solicitação ou a resposta.
**Resposta de inferência vazia (contagem)**
O número total de solicitações de inferência em que nenhum token de saída foi gerado ou em que o tokenizador não conseguiu analisar a resposta.
### Métricas do modo de throughput
A seção **Throughput** mostra as métricas a seguir.
**Simultaneidade**
O número de usuários simultâneos que a avaliação simulou para invocar o endpoint simultaneamente.
**Entrada tokens/sec/req (contagem)**
O número total de tokens de entrada gerados por segundo por solicitação.
**Saída tokens/sec/req (contagem)**
O número total de tokens de saída gerados por segundo por solicitação.
**Tokens de entrada (contagem)**
O número total de tokens de entrada gerados por solicitação.
**Tokens de saída (contagem)**
O número total de tokens de saída gerados por solicitação.
### Métricas de preço
A seção **Preço** mostra as métricas a seguir.
**Simultaneidade**
O número de usuários simultâneos que a avaliação simulou para invocar o endpoint simultaneamente.
**Preço por milhão de tokens de entrada**
Custo do processamento de 1 milhão de tokens de entrada.
**Preço por milhão de tokens de saída**
Custo para gerar 1 milhão de tokens de saída.
# Referência de modelos compatíveis
As tabelas a seguir mostram os modelos para os quais a SageMaker IA oferece suporte à otimização de inferência e mostram as técnicas de otimização suportadas.
**Modelos Llama compatíveis**
| Nome do modelo | Formatos de dados aceitos para quantização | Permite decodificação especulativa | Permite carregamento rápido de modelos | Bibliotecas usadas para compilação |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Llama 2 13B Chat da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Llama 2 70B Chat da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Meta Llama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Llama 2 7B Chat da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Llama 3 70B da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Llama 3 70B Instruct da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Llama 3 8B da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Llama 3 8B Instruct da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Code Llama 13B da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 13B Instruct da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 13B Python da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 34B da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 34B Instruct da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 34B Python da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 70B da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 70B Instruct da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 70B Python da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 7B da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 7B Instruct da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Code Llama 7B Python da Meta | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Llama 2 13B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 2 13B Chat Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 2 70B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 2 70B Chat Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 2 7B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 2 7B Chat Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 3 70B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 3 70B Instruct Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 3 8B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 3 8B Instruct Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Code Llama 70B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Code Llama 7B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Code Llama 7B Python Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Metal Llama 3.1 405B FP8 | Nenhum | Sim | Sim | Nenhum |
| Instrução Meta Llama 3.1 405B FP8 | Nenhum | Sim | Sim | Nenhum |
| Llama 3.1 70B da Meta | INT4-AWQ FP8 | Sim | Sim | Nenhum |
| Llama 3.1 70B Instruct da Meta | INT4-AWQ FP8 | Sim | Sim | Nenhum |
| Llama 3.1 8B da Meta | INT4-AWQ FP8 | Sim | Sim | Nenhum |
| Llama 3.1 8B Instruct da Meta | INT4-AWQ FP8 | Sim | Sim | Nenhum |
| Llama 3.1 70B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 3.1 70B Instruct Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 3 1 8B Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
| Llama 3.1 8B Instruct Neuron da Meta | Nenhum | Não | Não | AWSNeurônio |
**Modelos Mistral compatíveis**
| Nome do modelo | Formatos de dados aceitos para quantização | Permite decodificação especulativa | Permite carregamento rápido de modelos | Bibliotecas usadas para compilação |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Mistral 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | AWSNeurônio TensorRT-LLM |
| Mistral 7B Neuron | Nenhum | Não | Não | AWSNeurônio |
| Mistral 7B Instruct Neuron | Nenhum | Não | Não | AWSNeurônio |
**Modelos Mixtral compatíveis**
| Nome do modelo | Formatos de dados aceitos para quantização | Permite decodificação especulativa | Permite carregamento rápido de modelos | Bibliotecas usadas para compilação |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruct-v0.1 | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
| Mixtral 8x7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sim | Sim | TensorRT-LLM |
**Arquiteturas de modelo suportadas e tipo EAGLE**
| Nome da arquitetura do modelo | Tipo EAGLE |
| --- | --- |
| LlamaForCausalLM | ÁGUIA 3 |
| Rainha 3 LM ForCausal | ÁGUIA 3 |
| Rainha 3 LM NextForCausal | ÁGUIA 2 |
| Rainha 3 LM MoeForCausal | ÁGUIA 3 |
| Rainha 2 LM ForCausal | ÁGUIA 3 |
| GptOssForCausalLM | ÁGUIA 3 |
# Opções para avaliar seu modelo de aprendizado de máquina na Amazon AI SageMaker
Depois de treinar um modelo, avalie-o para determinar se o desempenho e a precisão permitem atingir seus objetivos de negócios. Você pode gerar vários modelos usando métodos diferentes e avaliar cada um deles. Por exemplo, é possível aplicar diferentes regras de negócios para cada modelo e, em seguida, aplicar várias medidas para determinar a adequação de cada um. Você pode ponderar se o modelo precisa ser mais sensível do que específico (ou vice-versa).
Para avaliar o modelo, use dados históricos (offline) ou dados ativos:
+ **Testes offline**: envie solicitações ao modelo para inferências usando dados históricos, não ativos.
Implante seu modelo treinado em um endpoint alfa e use os dados históricos para enviar solicitações de inferência a ele. Para enviar as solicitações, use um notebook Jupyter em sua instância de notebook Amazon SageMaker AI e a AWS SDK para Python (Boto) biblioteca Python de alto nível fornecida pela AI. SageMaker
+ **Teste on-line com dados ao vivo** — a SageMaker IA suporta A/B testes de modelos em produção usando variantes de produção. As variantes de produção são modelos que usam o mesmo código de inferência e são implantados no mesmo endpoint de SageMaker IA. Configure as variantes de produção para que uma pequena parte do tráfego ao vivo seja direcionada para o modelo a ser validado. Por exemplo, você pode optar por enviar 10% do tráfego a uma variante do modelo para avaliação. Depois de satisfeito com o desempenho do modelo, você pode rotear 100% do tráfego para o modelo atualizado. Para obter um exemplo de testes de modelos em produção, consulte [Teste de modelos com variantes de produção](model-ab-testing.md).
Para obter mais informações, consulte artigos e livros sobre como avaliar modelos, por exemplo, [Evaluating Machine Learning Models](http://www.oreilly.com/data/free/evaluating-machine-learning-models.csp).
As opções para avaliação de modelo offline incluem:
+ **Validação usando um conjunto de holdouts**: os profissionais de machine learning geralmente reservam uma parte dos dados como um “conjunto de holdouts”. Eles não usam esses dados para treinamento de modelo.
Com essa abordagem, você avalia o quanto seu modelo fornece inferências sobre o conjunto de holdouts. Em seguida, você avalia a eficácia com que o modelo generaliza o que aprendeu no treinamento inicial, em vez de usar a memória do modelo. Essa abordagem para validação fornece uma ideia da frequência com que o modelo é capaz de inferir a resposta correta.
De algum modo, essa abordagem é semelhante a dar aula para alunos do ensino fundamental. Primeiramente, você fornece um conjunto de exemplos para que eles aprendam. Depois, testa a capacidade deles de inferir a partir do que aprenderam. Com dever de casa e testes, você apresenta problemas que não foram incluídos na aprendizado inicial e determina se eles são capazes de inferir com eficácia. Alunos com memórias perfeitas podem decorar os problemas, em vez de aprender as regras.
Normalmente, o conjunto de dados de holdout representa de 20 a 30% dos dados de treinamento.
+ **Validação k-fold**: nesta abordagem de validação, você divide o conjunto de dados de exemplo em *k* partes. Trata cada uma dessas partes como um conjunto de holdouts definido para* k* execuções de treinamento e usa as outras *k*-1 partes como o treinamento definido para a execução em questão. Para produzir* k* modelos, você usa um processo semelhante e agrega os modelos para gerar o modelo final. O valor *k* está geralmente no intervalo de 5 a 10.
# Recomendador de SageMaker inferência da Amazon
O Amazon SageMaker Inference Recommender é um recurso do Amazon SageMaker AI. Ele reduz o tempo necessário para colocar modelos de aprendizado de máquina (ML) em produção ao automatizar os testes de carga e o ajuste de modelos em todas as instâncias de SageMaker AI ML. Você pode usar o recomendador de inferência para implantar seu modelo em um endpoint de inferência em tempo real ou sem servidor que ofereça melhor desempenho com custo mais baixo. O Inference Recommender ajuda você a selecionar o melhor tipo de instância e configuração para seus modelos e workloads de ML. Ele considera fatores como contagem de instâncias, parâmetros de contêiner, otimizações de modelo, simultaneidade máxima e tamanho da memória.
O Amazon SageMaker Inference Recommender cobra apenas pelas instâncias usadas durante a execução dos trabalhos.
## Como funciona
Para usar o Amazon SageMaker Inference Recommender, você pode [criar um modelo de SageMaker IA ou registrar um modelo](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) no SageMaker Registro de modelos com seus artefatos de modelo. Use o console de SageMaker IA AWS SDK para Python (Boto3) ou o console para executar trabalhos de benchmarking para diferentes configurações de endpoints de SageMaker IA. Os trabalhos do recomendador de inferência ajudam você a coletar e visualizar métricas de desempenho e utilização de recursos para ajudá-lo a decidir qual tipo de endpoint e configuração escolher.
## Como começar
Se você for um usuário iniciante do Amazon SageMaker Inference Recommender, recomendamos que você faça o seguinte:
1. Leia a [Pré-requisitos para usar o Amazon Inference Recommender SageMaker](inference-recommender-prerequisites.md) seção para se certificar de que você atendeu aos requisitos para usar o Amazon SageMaker Inference Recommender.
1. Leia a seção [Empregos de recomendação com o Amazon SageMaker Inference Recommender](inference-recommender-recommendation-jobs.md) para iniciar seus primeiros trabalhos de recomendação do recomendador de inferência.
1. Explore o exemplo introdutório do caderno [Jupyter do Amazon SageMaker Inference Recommender ou analise os exemplos de cadernos](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-inference-recommender/inference-recommender.ipynb) na seção a seguir.
## Cadernos de exemplo
O seguinte exemplo de cadernos Jupyter pode ajudá-lo com os fluxos de trabalho para vários casos de uso no recomendador de inferência:
+ Se você quiser um caderno introdutório que compare um TensorFlow modelo, consulte o caderno [SageMaker Inference](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb) Recommender. TensorFlow
+ Se você quiser comparar um HuggingFace modelo, consulte o [SageMaker Inference Recommender](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/huggingface-inference-recommender/huggingface-inference-recommender.ipynb) para notebook. HuggingFace
+ Se você quiser comparar um XGBoost modelo, consulte o caderno [SageMaker Inference XGBoost Recommender](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb).
+ Se você quiser revisar CloudWatch as métricas de seus trabalhos do Inference Recommender, consulte o caderno de métricas do [SageMaker Inference CloudWatch Recommender](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb).
# Pré-requisitos para usar o Amazon Inference Recommender SageMaker
Antes de usar o Amazon SageMaker Inference Recommender, você deve concluir as etapas de pré-requisito. Como exemplo, mostramos como usar um modelo pré-treinado PyTorch (v1.7.1) ResNet -18 para os dois tipos de trabalhos de recomendação do Amazon SageMaker Inference Recommender. Os exemplos mostrados aqui usam o AWS SDK para Python (Boto3).
**nota**
Os exemplos a seguir foram criados em Python. Remova o caractere de prefixo `!` se você executar qualquer um dos seguintes exemplos de código no seu terminal ou AWS CLI:
Você pode executar os exemplos a seguir com o kernel Python 3 (2.6 TensorFlow Python 3.8 CPU Optimized) em um notebook Amazon Studio. SageMaker Para ter mais informações sobre o Studio, consulte [SageMaker Estúdio Amazon](studio-updated.md).
1. **Crie uma função do IAM para a Amazon SageMaker AI.**
Crie uma função do IAM para a Amazon SageMaker AI que tenha a política gerenciada `AmazonSageMakerFullAccess` do IAM anexada.
1. **Configurar o ambiente.**
Importe dependências e crie variáveis para você Região da AWS, sua função do SageMaker AI IAM (da Etapa 1) e para o cliente de SageMaker IA.
```
!pip install --upgrade pip awscli botocore boto3 --quiet
from sagemaker import get_execution_role, Session, image_uris
import boto3
region = boto3.Session().region_name
role = get_execution_role()
sagemaker_client = boto3.client("sagemaker", region_name=region)
sagemaker_session = Session()
```
1. **(Opcional) Analise os modelos existentes comparados pelo recomendador de inferência.**
O recomendador de inferência compara modelos de zoológicos mais comuns. O recomendador de inferência oferece apoio ao seu modelo, mesmo que ele ainda não tenha sido comparado.
Use `ListModelMetaData` para obter um objeto de resposta que lista o domínio, a estrutura, a tarefa e o nome do modelo dos modelos de machine learning encontrados em zoológicos comuns.
Você usa o domínio, a estrutura, a versão da estrutura, a tarefa e o nome do modelo em etapas posteriores para selecionar uma imagem de inferência do Docker e registrar seu modelo no Model Registry SageMaker . O seguinte exemplo demonstra como listar metadados do modelo com o SDK para Python (Boto3):
```
list_model_metadata_response=sagemaker_client.list_model_metadata()
```
A saída inclui resumos do modelo (`ModelMetadataSummaries`) e metadados de resposta (`ResponseMetadata`) semelhantes aos seguinte exemplo:
```
{
'ModelMetadataSummaries': [{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-cased',
'Task': 'FILL_MASK'
},
{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-uncased',
'Task': 'FILL_MASK'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'MXNET:1.8.0',
'Model': 'resnet18v2-gluon',
'Task': 'IMAGE_CLASSIFICATION'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'PYTORCH:1.6.0',
'Model': 'resnet152',
'Task': 'IMAGE_CLASSIFICATION'
}],
'ResponseMetadata': {
'HTTPHeaders': {
'content-length': '2345',
'content-type': 'application/x-amz-json-1.1',
'date': 'Tue, 19 Oct 2021 20:52:03 GMT',
'x-amzn-requestid': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
},
'HTTPStatusCode': 200,
'RequestId': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
'RetryAttempts': 0
}
}
```
Para esta demonstração, usamos um modelo PyTorch (v1.7.1) ResNet -18 para realizar a classificação de imagens. O seguinte exemplo de código Python armazena a framework, a versão da estrutura, o domínio e a tarefa em variáveis para uso posterior:
```
# ML framework details
framework = 'pytorch'
framework_version = '1.7.1'
# ML model details
ml_domain = 'COMPUTER_VISION'
ml_task = 'IMAGE_CLASSIFICATION'
```
1. **Faça o upload do seu modelo de machine learning para o Amazon S3.**
Use este modelo PyTorch (v1.7.1) ResNet -18 se você não tiver um modelo de aprendizado de máquina pré-treinado:
```
# Optional: Download a sample PyTorch model
import torch
from torchvision import models, transforms, datasets
# Create an example input for tracing
image = torch.zeros([1, 3, 256, 256], dtype=torch.float32)
# Load a pretrained resnet18 model from TorchHub
model = models.resnet18(pretrained=True)
# Tell the model we are using it for evaluation (not training). Note this is required for Inferentia compilation.
model.eval()
model_trace = torch.jit.trace(model, image)
# Save your traced model
model_trace.save('model.pth')
```
Faça download de um exemplo de script `inference.py` de inferência. Crie um `code` diretório e mova o script de inferência para o diretório `code`.
```
# Download the inference script
!wget https://aws-ml-blog-artifacts.s3.us-east-2.amazonaws.com/inference.py
# move it into a code/ directory
!mkdir code
!mv inference.py code/
```
O Amazon SageMaker AI exige que modelos de aprendizado de máquina pré-treinados sejam empacotados como um arquivo TAR compactado (). `*.tar.gz` Comprima seu modelo e script de inferência para atender a esse requisito:
```
!tar -czf test.tar.gz model.pth code/inference.py
```
Quando seu endpoint é provisionado, os arquivos no arquivamento são extraídos para `/opt/ml/model/` o endpoint.
Depois de compactar o modelo e os artefatos do modelo como um `.tar.gz` arquivo, faça o upload deles no bucket do Amazon S3. O seguinte exemplo demonstra como carregar seu modelo para o Amazon S3 usando a AWS CLI:
```
!aws s3 cp test.tar.gz s3://{your-bucket}/models/
```
1. **Selecione uma imagem do Docker de inferência pré-criada ou crie sua própria imagem do Docker de inferência.**
SageMaker A IA fornece contêineres para seus algoritmos integrados e imagens pré-criadas do Docker para algumas das estruturas de aprendizado de máquina mais comuns, como Apache, MXNet TensorFlow, PyTorch e Chainer. Para ver uma lista completa das imagens de SageMaker IA disponíveis, consulte Imagens de [contêineres de Deep Learning Disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Se nenhum dos contêineres de SageMaker IA existentes atender às suas necessidades e você não tiver um contêiner próprio, crie uma nova imagem do Docker. Consulte [Contêineres com código de inferência personalizado](your-algorithms-inference-main.md) para obter informações sobre como criar uma imagem do Docker.
Veja a seguir como recuperar uma imagem de inferência da PyTorch versão 1.7.1 usando o SDK do Python: SageMaker
```
from sagemaker import image_uris
## Uncomment and replace with your own values if you did not define
## these variables a previous step.
#framework = 'pytorch'
#framework_version = '1.7.1'
# Note: you can use any CPU-based instance here,
# this is just to set the arch as CPU for the Docker image
instance_type = 'ml.m5.2xlarge'
image_uri = image_uris.retrieve(framework,
region,
version=framework_version,
py_version='py3',
instance_type=instance_type,
image_scope='inference')
```
Para obter uma lista das instâncias de SageMaker IA disponíveis, consulte [Amazon SageMaker AI Pricing](https://aws.amazon.com/sagemaker/pricing/).
1. **Crie um arquivo de exemplo de carga útil.**
Crie um arquivo que contenha arquivos individuais que a ferramenta de teste de carga possa enviar para seus endpoints de SageMaker IA. Seu código de inferência deve ser capaz de ler os formatos de arquivo do exemplo de carga útil.
A seguir, é baixada uma imagem.jpg que esse exemplo usa em uma etapa posterior para o modelo ResNet -18.
```
!wget https://cdn.pixabay.com/photo/2020/12/18/05/56/flowers-5841251_1280.jpg
```
Comprima o exemplo de carga útil como um pacote:
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
Faça o upload do exemplo de carga útil no Amazon S3 e anote o URI do Amazon S3:
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Você precisará do URI do Amazon S3 em uma etapa posterior, portanto, armazene-o em uma variável:
```
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
payload_s3_key = f"{bucket_prefix}/payload.tar.gz"
sample_payload_url= f"s3://{bucket}/{payload_s3_key}"
```
1. **Prepare sua entrada do modelo para o trabalho de recomendações**
Como último pré-requisito, você tem duas opções para preparar a entrada do modelo. Você pode registrar seu modelo no SageMaker Model Registry, que pode ser usado para catalogar modelos para produção, ou criar um modelo de SageMaker IA e especificá-lo no `ContainerConfig` campo ao criar um trabalho de recomendações. A primeira opção é melhor se você quiser aproveitar os atributos que o [Model Registry](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html) fornece, como gerenciar versões de modelos e automatizar a implantação de modelos. A segunda opção é ideal se você quiser começar rapidamente. Para a primeira opção, vá para a etapa 7. Para a segunda opção, pule a etapa 7 e vá para a etapa 8.
1. **Opção 1: registrar seu modelo no registro de modelos**
Com o SageMaker Model Registry, você pode catalogar modelos para produção, gerenciar versões de modelos, associar metadados (como métricas de treinamento) a um modelo, gerenciar o status de aprovação de um modelo, implantar modelos na produção e automatizar a implantação de modelos com CI/CD.
Quando você usa o SageMaker Model Registry para rastrear e gerenciar seus modelos, eles são representados como um pacote de modelo versionado dentro de grupos de pacotes de modelos. Pacotes de modelos sem versão não fazem parte de um grupo de modelos. Os grupos de pacotes de modelos contêm várias versões ou iterações de um modelo. Embora não seja obrigatório criá-los para cada modelo no registro, eles ajudam a organizar vários modelos que têm o mesmo propósito e fornecem versionamento automático.
Para usar o Amazon SageMaker Inference Recommender, você deve ter um pacote de modelo versionado. Você pode criar um pacote de modelo versionado programaticamente com o ou AWS SDK para Python (Boto3) com o Amazon Studio Classic. SageMaker Para criar um pacote de modelo versionado programaticamente, primeiro crie um grupo de pacotes de modelo com a API `CreateModelPackageGroup`. Em seguida, crie um pacote de modelo usando a API `CreateModelPackage`. Chamar esse método cria um pacote de modelo versionado.
Consulte [Criar um grupo de modelos](model-registry-model-group.md) e obtenha [Registrar uma versão do modelo](model-registry-version.md) instruções detalhadas sobre como criar de forma programática e interativa um grupo de pacotes de modelos e como criar um pacote de modelos versionados, respectivamente, com o e AWS SDK para Python (Boto3) o Amazon Studio Classic. SageMaker
O exemplo de código a seguir demonstra como criar um pacote de modelo versionado usando o AWS SDK para Python (Boto3).
**nota**
Você não precisa aprovar o pacote de modelos para criar um trabalho do recomendador de inferência.
1. **Criar um grupo de pacote de modelos**
Crie um grupo de pacotes de modelos com a API `CreateModelPackageGroup`. Forneça um nome para o grupo de pacotes de modelos `ModelPackageGroupName` e, opcionalmente, forneça uma descrição do pacote de modelos no campo `ModelPackageGroupDescription`.
```
model_package_group_name = ''
model_package_group_description = ''
model_package_group_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageGroupDescription" : model_package_group_description,
}
model_package_group_response = sagemaker_client.create_model_package_group(**model_package_group_input_dict)
```
Consulte o [Guia de referência de SageMaker API da Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) para obter uma lista completa dos argumentos opcionais e obrigatórios para os quais você pode passar [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html).
Crie um pacote de modelos especificando uma imagem do Docker que execute seu código de inferência e a localização do Amazon S3 dos seus artefatos de modelo, e forneça valores para `InferenceSpecification`. O `InferenceSpecification` deve conter informações sobre jobs de inferência que podem ser executados com modelos baseados neste pacote de modelos, incluindo o seguinte:
+ Os caminhos de imagens do Amazon ECR que executam seu código de inferência.
+ (Opcional) Os tipos de instância compatíveis com o pacote de modelo para trabalhos de transformação e endpoints em tempo real usados para inferência.
+ Os formatos de conteúdo de entrada e saída compatíveis com o pacote de modelos para inferência.
Além disso, você deve especificar os seguintes parâmetros ao criar um pacote de modelos:
+ [Domínio](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Domain): o domínio de machine learning do pacote de modelos e seus componentes. Os domínios comuns de machine learning incluem visão computacional e processamento de linguagem natural.
+ [Tarefa](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task): a tarefa de machine learning realizada pelo pacote de modelos. Tarefas comuns de machine learning incluem detecção de objetos e classificação de imagens. Especifique “OUTRO” se nenhuma das tarefas listadas no [Guia de referência da API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) atender ao seu caso de uso. Consulte as descrições dos campos da API [Task](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task) para obter uma lista de tarefas de machine learning compatíveis.
+ [SamplePayloadUrl](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-SamplePayloadUrl): O caminho do Amazon Simple Storage Service (Amazon S3) em que a carga útil da amostra é armazenada. Esse caminho deve apontar para um arquivo tar compactado por gzip (sufixo .tar.gz).
+ [Framework](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-Framework): a framework de machine learning da imagem do contêiner do pacote de modelos.
+ [FrameworkVersion](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-FrameworkVersion): a versão da estrutura da imagem do contêiner do pacote modelo.
Se você fornecer uma lista de permissões de tipos de instância a serem usados para gerar inferências em tempo real para o [SupportedRealtimeInferenceInstanceTypes](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InferenceSpecification.html#sagemaker-Type-InferenceSpecification-SupportedRealtimeInferenceInstanceTypes), o Inference Recommender limitará o espaço de pesquisa dos tipos de instância durante um trabalho. `Default` Use este parâmetro se você tiver restrições orçamentárias ou souber que há um conjunto específico de tipos de instância que podem apoiar seu modelo e imagem de contêiner.
Em uma etapa anterior, baixamos um modelo ResNet 18 pré-treinado e o armazenamos em um bucket do Amazon S3 em um diretório chamado. `models` Recuperamos uma imagem de inferência do Deep Learning Container PyTorch (v1.7.1) e armazenamos o URI em uma variável chamada. `image_uri` Use essas variáveis no exemplo de código a seguir para definir um dicionário usado como entrada para a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html).
```
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
# Similar open source model to the packaged model
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input.
input_content_type='image/jpeg'
# Optional - provide a description of your model.
model_package_description = ''
## Uncomment if you did not store the domain and task in an earlier
## step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version
## in a previous step.
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating a model pacakge group
model_package_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageDescription" : model_package_description,
"Domain": ml_domain,
"Task": ml_task,
"SamplePayloadUrl": sample_payload_url,
"InferenceSpecification": {
"Containers": [
{
"Image": image_uri,
"ModelDataUrl": model_url,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"ModelInput": {"DataInputConfig": data_input_configuration}
}
],
"SupportedContentTypes": [input_content_type]
}
}
```
1. **Criar um pacote de modelo**
Usar a API `CreateModelPackage` para criar um pacote de modelos. Passe o dicionário de entrada definido na etapa anterior:
```
model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)
```
Você precisa do ARN do pacote de modelos para usar o Amazon SageMaker Inference Recommender. Observe o ARN do pacote de modelos ou o armazene em uma variável:
```
model_package_arn = model_package_response["ModelPackageArn"]
print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
1. **Opção 2: criar um modelo e configurar o campo `ContainerConfig`**
Use esta opção se desejar iniciar um trabalho de recomendações de inferência e não precisar registrar seu modelo no registro do modelo. Nas etapas a seguir, você cria um modelo no SageMaker AI e configura o `ContainerConfig` campo como entrada para o trabalho de recomendações.
1. **Criar um modelo**
Criar um modelo com a API do `CreateModel` Para ver um exemplo que chama esse método ao implantar um modelo no SageMaker AI Hosting, consulte [Create a Model (AWS SDK para Python (Boto3))](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html#realtime-endpoints-deployment-create-model).
Em uma etapa anterior, baixamos um modelo ResNet 18 pré-treinado e o armazenamos em um bucket do Amazon S3 em um diretório chamado. `models` Recuperamos uma imagem de inferência do Deep Learning Container PyTorch (v1.7.1) e armazenamos o URI em uma variável chamada. `image_uri` Usamos essas variáveis no exemplo de código a seguir, onde definimos um dicionário usado como entrada para a API `[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html#sagemaker-CreateModel-request-ModelName)`.
```
model_name = ''
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam::::role/*"
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': image_uri,
'ModelDataUrl': model_url,
})
```
1. **Configurar o campo `ContainerConfig`**
Em seguida, você deve configurar o [ContainerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobInputConfig.html#sagemaker-Type-RecommendationJobInputConfig-ContainerConfig)campo com o modelo que você acabou de criar e especificar os seguintes parâmetros nele:
+ `Domain`: o domínio de machine learning do modelo e seus componentes, como visão computacional ou processamento de linguagem natural.
+ `Task`: a tarefa de machine learning que o modelo realiza, como classificação de imagens ou detecção de objetos.
+ `PayloadConfig`: a configuração da carga útil de um trabalho de recomendação. Para obter mais informações sobre os campos, consulte `[RecommendationJobPayloadConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobPayloadConfig.html#sagemaker-Type-RecommendationJobPayloadConfig-SamplePayloadUrl)`.
+ `Framework`: a estrutura de aprendizado de máquina da imagem do contêiner, como PyTorch.
+ `FrameworkVersion`: a versão do framework da imagem de contêiner
+ (Opcional) `SupportedInstanceTypes`: uma lista dos tipos de instância utilizados para gerar inferências em tempo real.
Se você usar o `SupportedInstanceTypes` parâmetro, o recomendador de inferência limitará o espaço de pesquisa para tipos de instância durante um trabalho `Default`. Use este parâmetro se você tiver restrições orçamentárias ou souber que há um conjunto específico de tipos de instância que podem apoiar seu modelo e imagem de contêiner.
No exemplo de código a seguir, usamos os parâmetros definidos anteriormente, juntamente com`NearestModelName`, para definir um dicionário usado como entrada para a API `[CreateInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)`.
```
## Uncomment if you did not store the domain and task in a previous step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version in a previous step
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input
input_content_type='image/jpeg'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating an inference recommendation job
container_config = {
"Domain": ml_domain,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"PayloadConfig": {
"SamplePayloadUrl": sample_payload_url,
"SupportedContentTypes": [ input_content_type ]
},
"DataInputConfig": data_input_configuration
"Task": ml_task,
}
```
# Empregos de recomendação com o Amazon SageMaker Inference Recommender
O Amazon SageMaker Inference Recommender pode fazer dois tipos de recomendações:
1. As recomendações de inferência (tipo de trabalho `Default`) executam um conjunto de testes de carga nos tipos de instância recomendados. Você também pode fazer o teste de carga para um endpoint com tecnologia sem servidor. Você só precisa fornecer um pacote de modelos do nome do recurso da Amazon (ARN) para executar esse tipo de trabalho de recomendação. Os trabalhos de recomendação de inferência são concluídos em 45 minutos.
1. As recomendações de endpoint (tipo de trabalho `Advanced`) são baseadas em um teste de carga personalizado em que você seleciona as instâncias de ML desejadas ou um endpoint sem servidor e fornece um padrão de tráfego personalizado e requisitos de latência e throughput com base em seus requisitos de produção. Este trabalho leva, em média, 2 horas para ser concluído, dependendo da duração definida para o trabalho e do número total de configurações de inferência testadas.
Ambos os tipos de recomendações usam o mesmo APIs para criar, descrever e interromper trabalhos. O resultado é uma lista de recomendações de configuração de instâncias com variáveis de ambiente, custo, throughput e métricas de latência associadas. Os trabalhos de recomendação também fornecem uma contagem de instância inicial que você pode usar para configurar uma política de dimensionamento automático. Para diferenciar os dois tipos de trabalhos, ao criar um trabalho por meio do console de SageMaker IA ou do APIs, especifique `Default` a criação de recomendações preliminares de endpoint e `Advanced` para testes de carga e recomendações de endpoints personalizados.
**nota**
Você não precisa fazer os dois tipos de trabalhos de recomendação em seu próprio fluxo de trabalho. Você pode fazer qualquer uma delas independentemente da outra.
O recomendador de inferência também pode fornecer uma lista de instâncias potenciais ou os cinco principais tipos de instância otimizados em termos de custo, produtividade e latência para implantação de modelo, juntamente com uma pontuação de confiança. Você pode escolher essas instâncias ao implantar seu modelo. O recomendador de inferência executa automaticamente a análise comparativa em relação ao seu modelo para que você forneça as instâncias potenciais. Como essas são recomendações preliminares, recomendamos que você execute outros trabalhos de recomendação de instâncias para obter resultados mais precisos. Para ver as instâncias em potencial, acesse a página de detalhes do seu modelo de SageMaker IA. Para obter mais informações, consulte [Obter instâncias prospectivas instantâneas](inference-recommender-prospective.md).
**Topics**
+ [Obter instâncias prospectivas instantâneas](inference-recommender-prospective.md)
+ [Recomendações de inferência](inference-recommender-instance-recommendation.md)
+ [Obtenha uma recomendação de inferência para um endpoint existente](inference-recommender-existing-endpoint.md)
+ [Interromper sua recomendação de inferência](instance-recommendation-stop.md)
+ [Recomendações compiladas com o Neo](inference-recommender-neo-compilation.md)
+ [Resultados da recomendação](inference-recommender-interpret-results.md)
+ [Obter recomendações de políticas de dimensionamento automático](inference-recommender-autoscaling.md)
+ [Executar um teste de carga personalizado](inference-recommender-load-test.md)
+ [Interromper seu teste de carga](load-test-stop.md)
+ [Solucionar erros do recomendador de inferência](inference-recommender-troubleshooting.md)
# Obter instâncias prospectivas instantâneas
O Inference Recommender também pode fornecer uma lista de *instâncias em potencial*, ou tipos de instância que podem ser adequados para seu modelo, na página de detalhes do modelo de SageMaker IA. O recomendador de inferência executa automaticamente a análise comparativa em relação ao seu modelo para que você forneça as instâncias potenciais. Como essas são recomendações preliminares, recomendamos que você execute outros trabalhos de recomendação de instâncias para obter resultados mais precisos.
Você pode ver uma lista de instâncias potenciais do seu modelo de forma programática usando a [DescribeModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModel.html)API, o SDK do SageMaker Python ou o console de IA. SageMaker
**nota**
Você não obterá instâncias potenciais para modelos que você criou na SageMaker IA antes que esse recurso fosse disponibilizado.
Para visualizar instâncias em potencial para seu modelo por meio do console, faça o seguinte:
1. Acesse o SageMaker console em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, selecione **Modelos**.
1. Na lista de modelos, escolha seu modelo.
Na página de detalhes do seu modelo, acesse a seção **Instâncias potenciais para implantar o modelo**. A captura de tela a seguir mostra essa seção.
![\[Captura de tela da lista de instâncias potenciais na página de detalhes do modelo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inf-rec-prospective.png)
Nesta seção, você pode visualizar as possíveis instâncias otimizadas em termos de custo, throughput e latência para implantação do modelo, juntamente com informações adicionais para cada tipo de instância, como tamanho da memória, contagem de CPU e GPU e custo por hora.
Se você decidir comparar um exemplo de carga útil e executar um trabalho completo de recomendação de inferência para seu modelo, poderá iniciar um trabalho de recomendação de inferência padrão nesta página. Para iniciar um trabalho padrão por meio do console, faça o seguinte:
1. Na página de detalhes do modelo, na **seção Instâncias potenciais para implantar o modelo**, escolha **Executar o trabalho de recomendador de inferência**.
1. Na caixa de diálogo que aparece, para o **bucket do S3 para análise comparativa da carga útil**, insira o local do Amazon S3 onde você armazenou um exemplo de carga para seu modelo.
1. Em **Tipo de conteúdo da carga útil**, insira os tipos de MIME para seus dados de carga útil.
1. (Opcional) Na seção **Compilação de modelo usando SageMaker Neo**, para a **configuração de entrada de dados**, insira uma forma de dados no formato de dicionário.
1. Escolha **Executar trabalho**.
O Inference Recommender inicia o trabalho, e você pode ver o trabalho e seus resultados na página da lista de **recomendações de inferência** no console de IA. SageMaker
Se você quiser executar um trabalho avançado e realizar testes de carga personalizados ou se quiser definir configurações e parâmetros adicionais para seu trabalho, consulte [Executar um teste de carga personalizado](inference-recommender-load-test.md).
# Recomendações de inferência
Os trabalhos de recomendação de inferência executam um conjunto de testes de carga em tipos de instância recomendados ou em um endpoint com tecnologia sem servidor. Os trabalhos de recomendação de inferência usam métricas de desempenho baseadas em testes de carga usando os dados de amostra fornecidos durante o registro da versão do modelo.
**nota**
Antes de criar um trabalho de recomendação de inferência, verifique se você satisfez o [Pré-requisitos para usar o Amazon Inference Recommender SageMaker](inference-recommender-prerequisites.md).
A seguir, demonstramos como usar o Amazon SageMaker Inference Recommender para criar uma recomendação de inferência com base no seu tipo de modelo usando o AWS SDK para Python (Boto3),,, AWS CLI e o Amazon SageMaker Studio Classic, e o console de IA SageMaker
**Topics**
+ [Obter uma recomendação de inferência](instance-recommendation-create.md)
+ [Obter seus resultados de trabalho de recomendação de inferência](instance-recommendation-results.md)
# Obter uma recomendação de inferência
Crie uma recomendação de inferência programaticamente usando o AWS SDK para Python (Boto3) ou o AWS CLI, ou interativamente usando o Studio Classic ou o console de IA. SageMaker **Especifique um nome de trabalho para sua recomendação de inferência, um ARN de função AWS do IAM, uma configuração de entrada e um ARN de pacote de modelos ao registrar seu modelo no registro do modelo ou o nome do modelo e `ContainerConfig` um dicionário de quando você criou seu modelo na seção Pré-requisitos.**
------
#### [ AWS SDK para Python (Boto3) ]
Use a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) para iniciar um trabalho de recomendação de inferência. Defina o campo `JobType` como `'Default'` para trabalhos de recomendação de inferência. Além disso, observe o seguinte:
+ O nome do recurso da Amazon (ARN) de um perfil do IAM que habilita o recomendador de inferência para executar tarefas em seu nome. Defina isso para o campo `RoleArn`.
+ Um ARN do pacote de modelos ou nome do modelo. O recomendador de inferência é compatível com um ARN do pacote de modelos ou um nome de modelo como entrada. Especifique um dos seguintes:
+ O ARN do pacote de modelo versionado que você criou ao registrar seu modelo no AI Model Registry. SageMaker Defina isso para `ModelPackageVersionArn` no campo `InputConfig`.
+ O nome do modelo que você criou. Defina isso para `ModelName` no campo `InputConfig`. Além disso, forneça o dicionário do `ContainerConfig`, que inclui os campos obrigatórios que precisam ser fornecidos com o nome do modelo. Defina isso para `ContainerConfig` no campo `InputConfig`. No `ContainerConfig`, você também pode especificar opcionalmente o campo `SupportedEndpointType`como `RealTime` ou `Serverless`. Se você especificar esse campo, o recomendador de inferência retornará recomendações somente para esse tipo de endpoint. Se você não especificar esse campo, o recomendador de inferência retornará recomendações somente para ambos os tipos de endpoint.
+ Um nome para seu trabalho de recomendação do recomendador de inferência para o campo `JobName`. O nome do cargo do Inference Recommender deve ser exclusivo na AWS região e na sua AWS conta.
Importe o AWS SDK para Python (Boto3) pacote e crie um objeto cliente de SageMaker IA usando a classe cliente. Se você seguiu as etapas na seção **Pré-requisitos**, especifique apenas uma das seguintes opções:
+ Opção 1: se você quiser criar um trabalho de recomendações de inferência com um ARN do pacote de modelos, armazene o ARN do grupo de pacotes de modelos em uma variável chamada `model_package_arn`.
+ Opção 2: se você quiser criar um trabalho de recomendações de inferência com um nome de modelo e `ContainerConfig`, armazene o nome do modelo em uma variável chamada `model_name` e o dicionário do `ContainerConfig` em uma variável chamada `container_config`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide only one of model package ARN or model name, not both.
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
## Uncomment if you would like to create an inference recommendations job with a
## model name instead of a model package ARN, and comment out model_package_arn above
## Provide your model name
# model_name = ''
## Provide your container config
# container_config = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = 'arn:aws:iam:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
# Provide only one of model package ARN or model name, not both.
# If you would like to create an inference recommendations job with a model name,
# uncomment ModelName and ContainerConfig, and comment out ModelPackageVersionArn.
InputConfig = {
'ModelPackageVersionArn': model_package_arn
# 'ModelName': model_name,
# 'ContainerConfig': container_config
}
)
```
Consulte o [Guia de referência de SageMaker API da Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) para obter uma lista completa dos argumentos opcionais e obrigatórios para os quais você pode passar [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html).
------
#### [ AWS CLI ]
Use a API `create-inference-recommendations-job` para iniciar um trabalho de recomendação de inferência. Defina o campo `job-type` como `'Default'` para trabalhos de recomendação de inferência. Além disso, observe o seguinte:
+ O Amazon Resource Name (ARN) de uma função do IAM que permite que o Amazon SageMaker Inference Recommender execute tarefas em seu nome. Defina isso para o campo `role-arn`.
+ Um ARN do pacote de modelos ou nome do modelo. O recomendador de inferência é compatível com um ARN do pacote de modelos ou um nome de modelo como entrada. Especifique um dos seguintes:
+ O ARN do pacote de modelos versionado que você criou ao registrar seu modelo no registro do modelo. Defina isso para `ModelPackageVersionArn` no campo `input-config`.
+ O nome do modelo que você criou. Defina isso para `ModelName` no campo `input-config`. Além disso, forneça o dicionário do `ContainerConfig`, que inclui os campos obrigatórios que precisam ser fornecidos com o nome do modelo. Defina isso para `ContainerConfig` no campo `input-config`. No `ContainerConfig`, você também pode especificar opcionalmente o campo `SupportedEndpointType`como `RealTime` ou `Serverless`. Se você especificar esse campo, o recomendador de inferência retornará recomendações somente para esse tipo de endpoint. Se você não especificar esse campo, o recomendador de inferência retornará recomendações somente para ambos os tipos de endpoint.
+ Um nome para seu trabalho de recomendação do recomendador de inferência para o campo `job-name`. O nome do cargo do Inference Recommender deve ser exclusivo na AWS região e na sua AWS conta.
Para criar trabalhos de recomendação de inferência com um ARN do pacote de modelos, use o seguinte exemplo:
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
}"
```
Para criar trabalhos de recomendação de inferência com um nome de modelo e `ContainerConfig`, use o exemplo a seguir. O exemplo usa o `SupportedEndpointType` campo para especificar que só queremos retornar recomendações de inferência em tempo real:
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelName\": \"model-name\",
\"ContainerConfig\" : {
\"Domain\": \"COMPUTER_VISION\",
\"Framework\": \"PYTORCH\",
\"FrameworkVersion\": \"1.7.1\",
\"NearestModelName\": \"resnet18\",
\"PayloadConfig\":
{
\"SamplePayloadUrl\": \"s3://{bucket}/{payload_s3_key}\",
\"SupportedContentTypes\": [\"image/jpeg\"]
},
\"SupportedEndpointType\": \"RealTime\",
\"DataInputConfig\": \"[[1,3,256,256]]\",
\"Task\": \"IMAGE_CLASSIFICATION\",
},
}"
```
------
#### [ Amazon SageMaker Studio Classic ]
Criar um trabalho de recomendação de inferência no Studio Classic.
1. Em sua aplicação do Studio Classic, escolha o ícone Início (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Na barra de navegação lateral do Studio Classic, escolha **Modelos**.
1. Escolha **Registro de modelo** na lista suspensa para exibir os modelos que você registrou no registro de modelos.
O painel esquerdo exibe uma lista de grupos de modelos. A lista inclui todos os grupos de modelos registrados no registro de modelos da sua conta, incluindo modelos registrados fora do Studio Classic.
1. Selecione o nome do seu grupo de modelos. Quando você seleciona seu grupo de modelos, o painel direito do Studio Classic exibe cabeçalhos de coluna, como **Versões** e **Configuração**.
Se você tiver um ou mais pacotes de modelos em seu grupo de modelos, verá uma lista desses pacotes de modelos na coluna **Versões**.
1. Escolha a coluna de **recomendador de inferência**.
1. Escolha uma função do IAM que conceda permissão do Inference Recommender para acessar AWS os serviços. Você pode criar uma função e anexar a política gerenciada `AmazonSageMakerFullAccess` do IAM para fazer isso. Ou você pode deixar o Studio Classic criar um perfil para você.
1. Escolha **Obter recomendações**.
A recomendação de inferência pode demorar até 45 minutos.
**Atenção**
Não feche essa guia. Se você fechar essa guia, cancelará o trabalho de recomendação de instância.
------
#### [ SageMaker AI console ]
Crie um trabalho de recomendação de instância por meio do console de SageMaker IA fazendo o seguinte:
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, selecione **Recomendador de inferência**.
1. Na página de **trabalhos recomendados de inferência**, escolha **Criar trabalho**.
1. Na **Etapa 1: configuração do modelo**, faça o seguinte:
1. Em **Tipo de trabalho**, escolha **Trabalho de recomendação padrão**.
1. Se você estiver usando um modelo registrado no registro de modelos de SageMaker IA, ative a **opção Escolher um modelo no registro de modelos** e faça o seguinte:
1. Na lista suspensa **Grupo de modelos**, escolha o grupo de modelos no registro de modelos de SageMaker IA em que seu modelo está localizado.
1. Na lista suspensa **Versão do modelo**, escolha a versão desejada do seu modelo.
1. Se você estiver usando um modelo criado no SageMaker AI, desative a **opção Escolher um modelo no registro do modelo** e faça o seguinte:
1. No campo **Nome do modelo**, insira o nome do seu modelo de SageMaker IA.
1. Na lista suspensa da **função do IAM**, você pode selecionar uma função existente AWS do IAM que tenha as permissões necessárias para criar um trabalho de recomendação de instância. Como alternativa, se você não tiver uma função existente, poderá escolher **Criar uma nova função** para abrir o pop-up de criação da função, e a SageMaker IA adicionará as permissões necessárias à nova função que você criar.
1. Para o **bucket do S3 para análise comparativa de carga útil**, insira o caminho do Amazon S3 para seu arquivo de carga útil de amostra, que deve conter arquivos de carga útil de amostra que o recomendador de inferência usa para comparar seu modelo em diferentes tipos de instância.
1. Em **Tipo de conteúdo da carga útil**, insira os tipos de MIME para seus dados de carga útil.
1. (Opcional) Se você desativou a **opção Escolher um modelo no registro do modelo** e especificou um modelo de SageMaker IA, então, para a **configuração do contêiner**, faça o seguinte:
1. Na lista suspensa **Domínio**, selecione o domínio de machine learning do modelo, como visão computacional, processamento de linguagem natural ou machine learning.
1. Na lista suspensa **Estrutura**, selecione a estrutura do seu contêiner, como TensorFlow ou. XGBoost
1. Em **Versão do framework**, insira a versão da estrutura da sua imagem de contêiner.
1. Na lista suspensa **Nome do modelo mais próximo**, selecione o modelo pré-treinado que mais se aproxima do seu.
1. Na lista suspensa **Tarefa**, selecione a tarefa de machine learning que o modelo realiza, como classificação ou regressão de imagens.
1. (Opcional) Para **compilação de modelos usando SageMaker o Neo**, você pode configurar o trabalho de recomendação para um modelo que você compilou usando SageMaker o Neo. Em **Configuração de entrada de dados**, insira a forma correta dos dados de entrada para seu modelo em um formato semelhante a `{'input':[1,1024,1024,3]}`.
1. Escolha **Próximo**.
1. Para a **Etapa 2: instâncias e parâmetros de ambiente**, faça o seguinte:
1. (Opcional) Para **Selecionar instâncias para análise comparativa**, você pode selecionar até 8 tipos de instância que deseja comparar. Se você não selecionar nenhuma instância, o recomendador de inferência considera todos os tipos de instância.
1. Escolha **Próximo**.
1. Para a **Etapa 3: parâmetros de trabalho**, faça o seguinte:
1. (Opcional) No campo **Nome do trabalho**, insira um nome para seu trabalho de recomendação de instância. Quando você cria o trabalho, a SageMaker IA acrescenta um carimbo de data/hora ao final desse nome.
1. (Opcional) No campo **Descrição do trabalho**, insira uma descrição para o trabalho.
1. (Opcional) Na lista suspensa **Chave de criptografia**, escolha uma AWS KMS chave por nome ou insira seu ARN para criptografar seus dados.
1. (Opcional) Em **Duração máxima do teste (s)**, insira o número máximo de segundos durante os quais você deseja que cada teste seja executado.
1. (Opcional) Para **Máximo de invocações por minuto**, insira o número máximo de solicitações por minuto que o endpoint pode alcançar antes de interromper o trabalho de recomendação. Depois de atingir esse limite, a SageMaker IA encerra o trabalho.
1. (Opcional) Para o **Limite de latência do modelo P99 (ms)**, insira o percentil de latência do modelo em milissegundos.
1. Escolha **Próximo**.
1. Para **a Etapa 4: revisar o trabalho**, revise suas configurações e escolha **Enviar**.
------
# Obter seus resultados de trabalho de recomendação de inferência
Colete os resultados do seu trabalho de recomendação de inferência programaticamente com AWS SDK para Python (Boto3) o AWS CLI Studio Classic ou o SageMaker console de IA.
------
#### [ AWS SDK para Python (Boto3) ]
Depois que uma recomendação de inferência for concluída, você poderá usar o `DescribeInferenceRecommendationsJob` para obter os detalhes e as recomendações do trabalho. Forneça o nome do trabalho que você usou ao criar o trabalho de recomendação de inferência.
```
job_name=''
response = sagemaker_client.describe_inference_recommendations_job(
JobName=job_name)
```
Imprima o objeto de resposta. O exemplo de código anterior armazenou a resposta em uma variável chamada `response`.
```
print(response['Status'])
```
Isso retorna uma resposta JSON semelhante ao exemplo a seguir. Observe que este exemplo mostra os tipos de instância recomendados para inferência em tempo real (para ver um exemplo mostrando recomendações de inferência sem servidor, veja o exemplo após este).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
As primeiras linhas fornecem informações sobre o trabalho de recomendação de inferência em si. Isso inclui o nome do trabalho, a função do ARN e os horários de criação e exclusão.
O dicionário `InferenceRecommendations` contém uma lista de recomendações de inferência do recomendador de inferência.
O dicionário `EndpointConfiguration` aninhado contém a recomendação do tipo de instância (`InstanceType`) junto com o nome do endpoint e da variante (um modelo de aprendizado de AWS máquina implantado) que foi usado durante o trabalho de recomendação. Você pode usar o nome do endpoint e da variante para monitoramento no Amazon CloudWatch Events. Consulte [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md) para obter mais informações.
O dicionário `Metrics` aninhado contém informações sobre o custo estimado por hora (`CostPerHour`) para seu endpoint em tempo real em dólares americanos, o custo estimado por inferência (`CostPerInference`) em dólares americanos para seu endpoint em tempo real, o número máximo esperado de `InvokeEndpoint` solicitações por minuto enviadas ao endpoint (`MaxInvocations`) e a latência do modelo (`ModelLatency`), que é o intervalo de tempo (em microssegundos) que seu modelo levou para responder à IA. SageMaker A latência do modelo inclui os tempos de comunicação local necessários para enviar a solicitação e obter a resposta do contêiner de um modelo, bem como o tempo necessário para concluir a inferência dentro do contêiner.
O seguinte exemplo mostra a parte `InferenceRecommendations` da resposta de um trabalho de recomendações de inferência configurado para retornar recomendações de inferência sem servidor:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Você pode interpretar as recomendações para inferência serverless de maneira semelhante aos resultados para inferência em tempo real, com a exceção do `ServerlessConfig`, que indica as métricas retornadas para um endpoint com tecnologia sem servidor com o `MemorySizeInMB` fornecido e quando o `MaxConcurrency = 1` ocorre. Para aumentar a throughput possível no endpoint, aumente o valor de `MaxConcurrency` linearmente. Por exemplo, se a recomendação de inferência mostrar `MaxInvocations` como`1000`, aumentar `MaxConcurrency` para `2` apoiaria 2000 `MaxInvocations`. Observe que isso é verdade apenas até certo ponto, o qual pode variar com base no seu modelo e código. As recomendações serverless também medem a métrica `ModelSetupTime`, que avalia (em microssegundos) o tempo que leva para iniciar os recursos computacionais em um endpoint com tecnologia sem servidor. Para obter mais informações sobre como configurar endpoints sem servidor, consulte a [documentação da Inferência Sem Servidor](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ AWS CLI ]
Após a conclusão de uma recomendação de inferência, você pode usar o `describe-inference-recommendations-job` para obter os detalhes do trabalho e os tipos de instância recomendados. Forneça o nome do trabalho que você usou ao criar o trabalho de recomendação de inferência.
```
aws sagemaker describe-inference-recommendations-job\
--job-name \
--region
```
A resposta JSON deve ser semelhante ao seguinte exemplo: Observe que este exemplo mostra os tipos de instância recomendados para inferência em tempo real (para ver um exemplo mostrando recomendações de inferência sem servidor, veja o exemplo após este).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
As primeiras linhas fornecem informações sobre o trabalho de recomendação de inferência em si. Isso inclui o nome do trabalho, o ARN do perfil, o horário de criação e exclusão.
O dicionário `InferenceRecommendations` contém uma lista de recomendações de inferência do recomendador de inferência.
O dicionário `EndpointConfiguration` aninhado contém a recomendação do tipo de instância (`InstanceType`) junto com o nome do endpoint e da variante (um modelo de aprendizado de AWS máquina implantado) usado durante o trabalho de recomendação. Você pode usar o nome do endpoint e da variante para monitoramento no Amazon CloudWatch Events. Consulte [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md) para obter mais informações.
O dicionário `Metrics` aninhado contém informações sobre o custo estimado por hora (`CostPerHour`) para seu endpoint em tempo real em dólares americanos, o custo estimado por inferência (`CostPerInference`) em dólares americanos para seu endpoint em tempo real, o número máximo esperado de `InvokeEndpoint` solicitações por minuto enviadas ao endpoint (`MaxInvocations`) e a latência do modelo (`ModelLatency`), que é o intervalo de tempo (em milissegundos) que seu modelo levou para responder à IA. SageMaker A latência do modelo inclui os tempos de comunicação local necessários para enviar a solicitação e obter a resposta do contêiner de um modelo, bem como o tempo necessário para concluir a inferência dentro do contêiner.
O seguinte exemplo mostra a parte `InferenceRecommendations` da resposta de um trabalho de recomendações de inferência configurado para retornar recomendações de inferência sem servidor:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Você pode interpretar as recomendações para inferência serverless de maneira semelhante aos resultados para inferência em tempo real, com a exceção do `ServerlessConfig`, que indica as métricas retornadas para um endpoint com tecnologia sem servidor com o `MemorySizeInMB` fornecido e quando o `MaxConcurrency = 1` ocorre. Para aumentar a throughput possível no endpoint, aumente o valor de `MaxConcurrency` linearmente. Por exemplo, se a recomendação de inferência mostrar `MaxInvocations` como`1000`, aumentar `MaxConcurrency` para `2` apoiaria 2000 `MaxInvocations`. Observe que isso é verdade apenas até certo ponto, o qual pode variar com base no seu modelo e código. As recomendações serverless também medem a métrica `ModelSetupTime`, que avalia (em microssegundos) o tempo que leva para iniciar os recursos computacionais em um endpoint com tecnologia sem servidor. Para obter mais informações sobre como configurar endpoints sem servidor, consulte a [documentação da Inferência Sem Servidor](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ Amazon SageMaker Studio Classic ]
As recomendações de inferência são preenchidas em uma nova guia **Recomendações de inferência** no Studio Classic. Pode demorar até 45 minutos para que os resultados apareçam. Essa guia contém **os cabeçalhos das colunas Resultados** e **Detalhes**.
A coluna **Detalhes** fornece informações sobre o trabalho de recomendação de inferência, como o nome da recomendação de inferência, quando o trabalho foi criado (**Hora de criação**) e muito mais. Ele também fornece informações de **Configurações**, como o número máximo de invocações que ocorreram por minuto e informações sobre os nomes de recursos da Amazon usados.
A coluna **Resultados** fornece uma janela de **metas de implantação** e **recomendações de SageMaker IA** na qual você pode ajustar a ordem em que os resultados são exibidos com base na importância da implantação. Há três menus suspensos que você pode usar para fornecer o nível de importância do **custo**, da **Latência** e da **Throughput** para seu caso de uso. Para cada meta (custo, latência e throughput), você pode definir o nível de importância: **menor importância**, **baixa importância, importância** **moderada**, **alta importância** ou **maior** importância.
Com base em suas seleções de importância para cada meta, o Inference Recommender exibe sua recomendação principal no campo de **SageMakerrecomendação** à direita do painel, junto com o custo estimado por hora e a solicitação de inferência. Também fornece informações sobre a latência esperada do modelo, o número máximo de invocações e a número de instâncias. Para recomendações de tecnologia sem servidor, você pode ver os valores ideais para a simultaneidade máxima e o tamanho da memória do endpoint.
Além da recomendação principal exibida, você também pode ver as mesmas informações exibidas para todas as instâncias que o recomendador de inferência testou na seção **Todas as execuções**.
------
#### [ SageMaker AI console ]
Você pode ver seus trabalhos de recomendação de instância no console de SageMaker IA fazendo o seguinte:
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, selecione **Recomendador de inferência**.
1. Na página de trabalhos do **recomendador de inferência**, escolha o nome do seu trabalho de recomendação de inferência.
Na página de detalhes do seu trabalho, você pode ver as **recomendações de inferência**, que são os tipos de instância que a SageMaker IA recomenda para seu modelo, conforme mostrado na captura de tela a seguir.
![\[Captura de tela da lista de recomendações de inferência na página de detalhes do trabalho no console de SageMaker IA.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
Nesta seção, você pode comparar os tipos de instância por vários fatores, como **latência do modelo**, **custo por hora**, **custo por inferência** e **invocações por minuto**.
Nessa página, você também pode visualizar as configurações especificadas para seu trabalho. Na seção **Monitor**, você pode ver as CloudWatch métricas da Amazon que foram registradas para cada tipo de instância. Para saber mais sobre como interpretar essas métricas, consulte [Interpretar resultados](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html).
------
Para obter mais informações sobre como interpretar os resultados de seu trabalho de recomendação, consulte [Resultados da recomendação](inference-recommender-interpret-results.md).
# Obtenha uma recomendação de inferência para um endpoint existente
Os trabalhos de recomendação de inferência executam um conjunto de testes de carga em tipos de instância recomendados e em um endpoint existente. Os trabalhos de recomendação de inferência usam métricas de desempenho baseadas em testes de carga usando os dados de amostra fornecidos durante o registro da versão do modelo.
Você pode comparar e obter recomendações de inferência para um endpoint de inferência de SageMaker IA existente para ajudá-lo a melhorar o desempenho do seu endpoint. O procedimento de obter recomendações para um endpoint de inferência de SageMaker IA existente é semelhante ao procedimento para [obter recomendações de inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html) sem um endpoint. Há várias exclusões de atributos a serem observadas ao comparar um endpoint existente:
+ Você só pode usar um endpoint existente por trabalho do recomendador de inferência.
+ Só é possível ter uma variante em seu endpoint.
+ Não é possível usar um endpoint que permita o dimensionamento automático.
+ Essa funcionalidade só é compatível com [inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html).
+ Essa funcionalidade não é compatível com [endpoints multimodelo em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html).
**Atenção**
É altamente recomendável não executar um trabalho do recomendador de inferência em um endpoint de produção que envolva o tráfego ao vivo. A carga sintética durante a análise comparativa pode afetar seu ponto final de produção e ocasionar controle de utilização ou fornecer resultados de análises comparativas imprecisas. Recomendamos que você use um endpoint que não seja de produção ou de desenvolvedor para fins de comparação.
As seções a seguir demonstram como usar o Amazon SageMaker Inference Recommender para criar uma recomendação de inferência para um endpoint existente com base no seu tipo de modelo usando o AWS SDK for Python (Boto3) e o. AWS CLI
**nota**
Antes de criar um trabalho de recomendação de inferência, verifique se você satisfez o [Pré-requisitos para usar o Amazon Inference Recommender SageMaker](inference-recommender-prerequisites.md).
## Pré-requisitos
Se você ainda não tem um endpoint de inferência de SageMaker IA, pode [obter uma recomendação de inferência sem um](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html) endpoint ou criar um endpoint de inferência em tempo real seguindo as instruções em [Crie seu endpoint e implante seu modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html).
## Criar uma recomendação de inferência para um endpoint existente
Crie uma recomendação de inferência programaticamente usando AWS SDK para Python (Boto3), ou o. AWS CLI Especifique um nome de trabalho para sua recomendação de inferência, o nome de um endpoint de inferência de SageMaker IA existente, um ARN de AWS função do IAM, uma configuração de entrada e o ARN do pacote de modelos de quando você registrou seu modelo no registro do modelo.
------
#### [ AWS SDK para Python (Boto3) ]
Use a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) para obter uma recomendação de inferência. Defina o campo `JobType` como `'Default'` para trabalhos de recomendação de inferência. Além disso, observe o seguinte:
+ Forneça um nome para seu trabalho de recomendação do recomendador de inferência para o campo `JobName`. O nome do cargo do Inference Recommender deve ser exclusivo na AWS região e na sua AWS conta.
+ O nome do recurso da Amazon (ARN) de um perfil do IAM que habilita o recomendador de inferência para executar tarefas em seu nome. Defina isso para o campo `RoleArn`.
+ O ARN do pacote de modelos versionado que você criou ao registrar seu modelo no registro do modelo. Defina isso para `ModelPackageVersionArn` no campo `InputConfig`.
+ Forneça o nome de um endpoint de inferência de SageMaker IA existente para o qual você deseja comparar no Inference Recommender no campo. `Endpoints` `InputConfig`
Importe o AWS SDK para Python (Boto3) pacote e crie um objeto cliente de SageMaker IA usando a classe cliente. Se você seguiu as etapas na seção **Pré-requisitos**, o grupo de pacotes de modelos ARN foi armazenado em uma variável chamada `model_package_arn`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = ':role/*>'
# Provide endpoint name for your endpoint that want to benchmark in Inference Recommender
endpoint_name = ''
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
InputConfig = {
'ModelPackageVersionArn': model_package_arn,
'Endpoints': [{'EndpointName': endpoint_name}]
}
)
```
Consulte o [Guia de referência de SageMaker API da Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) para obter uma lista completa dos argumentos opcionais e obrigatórios para os quais você pode passar [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html).
------
#### [ AWS CLI ]
Use a API `create-inference-recommendations-job` para obter uma recomendação de endpoint de instância. Defina o campo `job-type` como `'Default'` por exemplo, trabalhos de recomendação de endpoints. Além disso, observe o seguinte:
+ Forneça um nome para seu trabalho de recomendação do recomendador de inferência para o campo `job-name`. O nome do cargo do Inference Recommender deve ser exclusivo na AWS região e na sua AWS conta.
+ O Amazon Resource Name (ARN) de uma função do IAM que permite que o Amazon SageMaker Inference Recommender execute tarefas em seu nome. Defina isso para o campo `role-arn`.
+ O ARN do pacote de modelos versionado que você criou ao registrar seu modelo no registro do modelo. Defina isso para `ModelPackageVersionArn` no campo `input-config`.
+ Forneça o nome de um endpoint de inferência de SageMaker IA existente para o qual você deseja comparar no Inference Recommender no campo. `Endpoints` `input-config`
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
\"Endpoints\": [{\"EndpointName\": }]
}"
```
------
## Obter seus resultados de trabalho de recomendação de inferência
Você pode coletar os resultados do seu trabalho de recomendação de inferência programaticamente com o mesmo procedimento para trabalhos de recomendação de inferência padrão. Para obter mais informações, consulte [Obter seus resultados de trabalho de recomendação de inferência](instance-recommendation-results.md).
Ao obter resultados do trabalho de recomendação de inferência para um endpoint existente, você deverá receber uma resposta JSON semelhante a esta:
```
{
"JobName": "job-name",
"JobType": "Default",
"JobArn": "arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id",
"RoleArn": "iam-role-arn",
"Status": "COMPLETED",
"CreationTime": 1664922919.2,
"LastModifiedTime": 1664924208.291,
"InputConfig": {
"ModelPackageVersionArn": "arn:aws:sagemaker:region:account-id:model-package/resource-id",
"Endpoints": [
{
"EndpointName": "endpoint-name"
}
]
},
"InferenceRecommendations": [
{
"Metrics": {
"CostPerHour": 0.7360000014305115,
"CostPerInference": 7.456940238625975e-06,
"MaxInvocations": 1645,
"ModelLatency": 171
},
"EndpointConfiguration": {
"EndpointName": "sm-endpoint-name",
"VariantName": "variant-name",
"InstanceType": "ml.g4dn.xlarge",
"InitialInstanceCount": 1
},
"ModelConfiguration": {
"EnvironmentParameters": [
{
"Key": "TS_DEFAULT_WORKERS_PER_MODEL",
"ValueType": "string",
"Value": "4"
}
]
}
}
],
"EndpointPerformances": [
{
"Metrics": {
"MaxInvocations": 184,
"ModelLatency": 1312
},
"EndpointConfiguration": {
"EndpointName": "endpoint-name"
}
}
]
}
```
As primeiras linhas fornecem informações sobre o trabalho de recomendação de inferência em si. Isso inclui o nome do trabalho, o ARN do perfil e os horários de criação e modificação mais recentes.
O dicionário `InferenceRecommendations` contém uma lista de recomendações de inferência do recomendador de inferência.
O dicionário `EndpointConfiguration` aninhado contém a recomendação do tipo de instância (`InstanceType`) junto com o nome do endpoint e da variante (um modelo de aprendizado de AWS máquina implantado) que foi usado durante o trabalho de recomendação.
O dicionário `Metrics` aninhado contém informações sobre o custo estimado por hora (`CostPerHour`) para seu endpoint em tempo real em dólares americanos, o custo estimado por inferência (`CostPerInference`) em dólares americanos para seu endpoint em tempo real, o número máximo esperado de `InvokeEndpoint` solicitações por minuto enviadas ao endpoint (`MaxInvocations`) e a latência do modelo (`ModelLatency`), que é o intervalo de tempo (em milissegundos) que seu modelo levou para responder à IA. SageMaker A latência do modelo inclui os tempos de comunicação local necessários para enviar a solicitação e obter a resposta do contêiner de um modelo, bem como o tempo necessário para concluir a inferência dentro do contêiner.
O dicionário `EndpointPerformances` aninhado contém o nome do seu endpoint existente no qual o trabalho de recomendação foi executado (`EndpointName`) e as métricas de desempenho do seu endpoint (`MaxInvocations` e `ModelLatency`).
# Interromper sua recomendação de inferência
Talvez você queira interromper um trabalho que está em execução no momento se tiver iniciado um trabalho por engano ou se não precisar mais executá-lo. Interrompa seus trabalhos de recomendação de inferência do recomendador de inferência programaticamente com a API `StopInferenceRecommendationsJob` ou com o Studio Classic.
------
#### [ AWS SDK para Python (Boto3) ]
Especifique o nome do trabalho de recomendação de inferência para o campo `JobName`.
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
Especifique o nome do trabalho do trabalho de recomendação de inferência para a sinalização de `job-name`.
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
Feche a guia na qual você iniciou a recomendação de inferência para interromper sua recomendação de inferência do recomendador de inferência.
------
#### [ SageMaker AI console ]
Para interromper seu trabalho de recomendação de instância por meio do console de SageMaker IA, faça o seguinte:
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, selecione **Recomendador de inferência**.
1. Na página de **trabalhos de recomendação de inferência**, selecione seu trabalho de recomendação de instância.
1. Selecione **Interromper trabalho**.
1. Na caixa de diálogo exibida, escolha **Confirmar**.
Depois de interromper sua tarefa, o **status** da tarefa deve mudar para **Interrompendo**.
------
# Recomendações compiladas com o Neo
No recomendador de inferência, você pode compilar seu modelo com o Neo e obter recomendações de endpoints para seu modelo compilado. [SageMaker O Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) é um serviço que pode otimizar seu modelo para uma plataforma de hardware de destino (ou seja, um tipo de instância ou ambiente específico). Otimizar um modelo com o Neo pode melhorar o desempenho do seu modelo hospedado.
Para estruturas e contêineres compatíveis com NEO, o recomendador de inferência sugere automaticamente recomendações otimizadas para NEO. Para ser elegível para a compilação do Neo, sua opinião deve atender aos seguintes pré-requisitos:
+ Você está usando um [DLC](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) ou XGBoost contêiner de propriedade da SageMaker IA.
+ Você está usando uma versão do framework compatível com o Neo. Para as versões da estrutura suportadas pelo Neo, consulte [Instâncias de nuvem](neo-supported-cloud.md#neo-supported-cloud-instances) a documentação do SageMaker Neo.
+ O Neo exige que você forneça um formato de dados de entrada correto para seu modelo. Você pode especificar essa forma de dados como `[DataInputConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelInput.html#sagemaker-Type-ModelInput-DataInputConfig)` na `[InferenceSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-InferenceSpecification)` ao criar um pacote de modelo. Para obter informações sobre as formas de dados corretas para cada estrutura, consulte [Preparar modelo para compilação](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html) na documentação do SageMaker Neo.
O exemplo a seguir mostra como especificar o `DataInputConfig` campo no`InferenceSpecification`, onde `data_input_configuration` é uma variável que contém a forma de dados em formato de dicionário (por exemplo,`{'input':[1,1024,1024,3]}`).
```
"InferenceSpecification": {
"Containers": [
{
"Image": dlc_uri,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": model_name,
"ModelInput": {"DataInputConfig": data_input_configuration},
}
],
"SupportedContentTypes": input_mime_types, # required, must be non-null
"SupportedResponseMIMETypes": [],
"SupportedRealtimeInferenceInstanceTypes": supported_realtime_inference_types, # optional
}
```
Se essas condições forem atendidas em sua solicitação, o recomendador de inferência executará cenários para versões compiladas e não compiladas do seu modelo, oferecendo várias combinações de recomendações para você escolher. Você pode comparar as configurações das versões compiladas e não compiladas da mesma recomendação de inferência e determinar qual delas é mais adequada ao seu caso de uso. As recomendações são classificadas por custo por inferência.
Para obter as recomendações de compilação do Neo, você não precisa fazer nenhuma configuração adicional além de garantir que sua entrada atenda aos requisitos anteriores. O recomendador de inferência executa automaticamente a compilação do Neo em seu modelo se sua entrada atender aos requisitos, e você receberá uma resposta que inclui recomendações do Neo.
Se você encontrar erros durante a compilação do Neo, consulte[Solucionar erros de compilação do Neo](neo-troubleshooting-compilation.md).
A tabela a seguir é um exemplo de uma resposta que você pode obter de um trabalho do recomendador de inferência que inclui recomendações para modelos compilados. Se o campo `InferenceSpecificationName` for `None`, a recomendação é um modelo não compilado. A última linha, na qual o valor do **InferenceSpecificationName**campo está`neo-00011122-2333-4445-5566-677788899900`, é para um modelo compilado com o Neo. O valor no campo é o nome do trabalho Neo usado para compilar e otimizar seu modelo.
| EndpointName | InstanceType | InitialInstanceCount | EnvironmentParameters | CostPerHour | CostPerInference | MaxInvocations | ModelLatency | InferenceSpecificationName |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| sm-epc-example-00011122 | ml.c5.9xlarge | 1 | [] | 1.836 | 9.15E-07 | 33456 | 7 | Nenhum |
| sm-epc-example-1112233 | ml.c5.2xlarge | 1 | [] | 0,408 | 2.11E-07 | 32211 | 21 | Nenhum |
| sm-epc-example-22233344 | ml.c5.xlarge | 1 | [] | 0,204 | 1.86E-07 | 18276 | 92 | Nenhum |
| sm-epc-example-33344455 | ml.c5.xlarge | 1 | [] | 0,204 | 1.60E-07 | 21286 | 42 | neo-00011122-2333-4445-5566-677788899900 |
## Conceitos básicos
As etapas gerais para criar um trabalho de recomendação de inferência que inclua recomendações otimizadas para Neo são as seguintes:
+ Preparar o modelo ML para compilação Para obter mais informações, consulte [Preparar modelo para compilação](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html) na documentação do Neo.
+ Package seu modelo em um arquivo de modelos (arquivo `.tar.gz`).
+ Crie um arquivo de exemplo de carga útil.
+ Registre seu SageMaker modelo no Registro de Modelos.
+ Crie um trabalho de recomendação de inferência.
+ Veja os resultados do trabalho do recomendador de inferência e escolha uma configuração.
+ Depure falhas de compilação, se houver. Para obter mais informações, consulte [Solucionar problemas de compilação do Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting-compilation.html).
[Para ver um exemplo que demonstra o fluxo de trabalho anterior e como usar recomendações otimizadas para Neo XGBoost, consulte o exemplo de caderno a seguir.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb) Para ver um exemplo que mostra como usar recomendações otimizadas para Neo TensorFlow, consulte o [exemplo](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb) de caderno a seguir.
# Resultados da recomendação
Cada resultado do trabalho do recomendador de inferência inclui`InstanceType`, `InitialInstanceCount` e `EnvironmentParameters` que são parâmetros variáveis de ambiente ajustados para seu contêiner para melhorar sua latência e throughput. Os resultados também incluem métricas de desempenho e custo como `MaxInvocations`, `ModelLatency`, `CostPerHour`, `CostPerInference`, `CpuUtilization` e `MemoryUtilization`.
Na tabela abaixo, fornecemos uma descrição dessas métricas. Essas métricas podem ajudá-lo a restringir sua busca pela melhor configuração de endpoint adequada ao seu caso de uso. Por exemplo, se sua motivação é o desempenho geral do preço com ênfase na throughput, você deve se concentrar em `CostPerInference`.
| Métrica | Description | Caso de uso |
| --- | --- | --- |
| `ModelLatency` | O intervalo de tempo gasto por um modelo para responder conforme visualizado pela SageMaker IA. Esse intervalo inclui os tempos de comunicação locais necessários para enviar a solicitação e buscar a resposta do contêiner de um modelo, bem como o tempo gasto para concluir a inferência no contêiner. Unidade: milissegundos | Workloads sigilosos à latência, como veiculação de anúncios e diagnóstico médico |
| `MaximumInvocations` | O número máximo de solicitações `InvokeEndpoint` enviadas para um endpoint do modelo em um minuto. Unidades: nenhuma | Workloads focadas na throughput, como processamento de vídeo ou inferência em lote |
| `CostPerHour` | O custo estimado por hora para seu endpoint em tempo real. Unidades: dólares norte-americanos | Workloads econômicas sem prazos de latência |
| `CostPerInference` | O custo estimado por chamada de inferência para seu endpoint em tempo real. Unidades: dólares norte-americanos | Maximizar o desempenho geral de preços com foco na produtividade |
| `CpuUtilization` | A utilização de CPU esperada no máximo de invocações por minuto para a instância do endpoint. Unidades: percentual | Entenda a integridade da instância durante a análise comparativa, tendo visibilidade da utilização da CPU principal da instância |
| `MemoryUtilization` | A utilização da memória esperada no máximo de invocações por minuto para a instância do endpoint. Unidades: percentual | Entenda a integridade da instância durante a análise comparativa, tendo visibilidade da utilização da memória principal da instância |
Em alguns casos, talvez você queira explorar outras [métricas do SageMaker AI Endpoint Invocation](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation), como. `CPUUtilization` Cada resultado do trabalho do recomendador de inferência inclui os nomes dos endpoints gerados durante o teste de carga. Você pode usar CloudWatch para revisar os registros desses endpoints mesmo depois de serem excluídos.
A imagem a seguir é um exemplo de CloudWatch métricas e gráficos que você pode analisar para um único endpoint a partir do resultado da recomendação. O resultado dessa recomendação é de um trabalho padrão. A maneira de interpretar os valores escalares dos resultados da recomendação é que eles se baseiem no momento em que o gráfico de invocações começa a se nivelar. Por exemplo, o `ModelLatency` valor relatado está no início do platô ao redor`03:00:31`.
![\[Gráficos para CloudWatch métricas.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference-recommender-cw-metrics.png)
Para obter descrições completas das CloudWatch métricas usadas nos gráficos anteriores, consulte Métricas do [SageMaker AI Endpoint Invocation](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation).
Você também pode ver métricas de desempenho semelhantes às `ClientInvocations` `NumberOfUsers` publicadas pelo recomendador de inferência no `/aws/sagemaker/InferenceRecommendationsJobs` namespace. Para obter uma lista completa de métricas e descrições publicadas pelo recomendador de inferência, consulte [SageMaker Métricas de empregos do Inference Recommender](monitoring-cloudwatch.md#cloudwatch-metrics-inference-recommender).
Consulte o notebook [Amazon SageMaker Inference Recommender - CloudWatch Metrics](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb) Jupyter no repositório [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples)Github para ver um exemplo de como usar o SDK for AWS Python (Boto3) para explorar métricas para seus endpoints. CloudWatch
# Obter recomendações de políticas de dimensionamento automático
Com o Amazon SageMaker Inference Recommender, você pode obter recomendações para políticas de escalonamento automático para seu endpoint de SageMaker IA com base no padrão de tráfego previsto. Se você já concluiu um trabalho de recomendação de inferência, pode fornecer os detalhes do trabalho para obter uma recomendação para uma política de dimensionamento automático que pode ser aplicada ao seu endpoint.
O recomendador de inferência compara valores diferentes para cada métrica para determinar a configuração de dimensionamento automático ideal para seu endpoint. A recomendação de ajuste de escala automático retorna uma política de ajuste de escala automático recomendada para cada métrica definida em seu trabalho de recomendação de inferência. Você pode salvar as políticas e aplicá-las ao seu endpoint com a [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API.
Para começar, revise os pré-requisitos a seguir.
## Pré-requisitos
Antes de começar, você deve ter concluído um trabalho de recomendação de inferência bem-sucedido. Na seção a seguir, você pode fornecer uma ID de recomendação de inferência ou o nome de um endpoint de SageMaker IA que foi comparado durante um trabalho de recomendação de inferência.
Para recuperar o ID do trabalho de recomendação ou o nome do endpoint, você pode visualizar os detalhes do trabalho de recomendação de inferência no console de SageMaker IA ou usar os `EndpointName` campos `RecommendationId` ou retornados pela API. [DescribeInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeInferenceRecommendationsJob.html)
## Criar uma recomendação de configuração de dimensionamento automático
Para criar uma política de recomendação de dimensionamento automático, você pode usar o AWS SDK para Python (Boto3).
O exemplo a seguir mostra os campos da [ GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html)API. Use os seguintes campos ao chamar a API:
+ `InferenceRecommendationsJobName` - Insira o nome do seu trabalho de recomendação de inferência.
+ `RecommendationId` - Insira o ID de uma recomendação de inferência de um trabalho de recomendação. Isso é opcional se você tiver especificado o campo `EndpointName`.
+ `EndpointName` - Insira o nome de um endpoint que foi comparado durante um trabalho de recomendação de inferência. Isso é opcional se você tiver especificado o campo `RecommendationId`.
+ `TargetCpuUtilizationPerCore` - (Opcional) Insira um valor percentual de quanta utilização você deseja que uma instância em seu endpoint use antes do dimensionamento automático. O valor padrão se você não especificar este campo é 50%.
+ `ScalingPolicyObjective` - (Opcional) Um objeto em que você especifica seu padrão de tráfego previsto.
+ `MinInvocationsPerMinute` - (Opcional) O número mínimo de solicitações esperadas para seu endpoint por minuto.
+ `MaxInvocationsPerMinute` - (Opcional) O número máximo de solicitações esperadas para seu endpoint por minuto.
```
{
"InferenceRecommendationsJobName": "string", // Required
"RecommendationId": "string", // Optional, provide one of RecommendationId or EndpointName
"EndpointName": "string", // Optional, provide one of RecommendationId or EndpointName
"TargetCpuUtilizationPerCore": number, // Optional
"ScalingPolicyObjective": { // Optional
"MinInvocationsPerMinute": number,
"MaxInvocationsPerMinute": number
}
}
```
Após enviar sua solicitação, você receberá uma resposta com políticas de ajuste de escala automático definidas para cada métrica. Consulte a próxima seção para obter informações sobre como interpretar a resposta.
## Analisar os resultados da recomendação de configuração de dimensionamento automático
O exemplo a seguir mostra a resposta da [ GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html)API:
```
{
"InferenceRecommendationsJobName": "string",
"RecommendationId": "string", // One of RecommendationId or EndpointName is shown
"EndpointName": "string",
"TargetUtilizationPercentage": Integer,
"ScalingPolicyObjective": {
"MinInvocationsPerMinute": Integer,
"MaxInvocationsPerMinute": Integer
},
"Metric": {
"ModelLatency": Integer,
"InvocationsPerInstance": Integer
},
"DynamicScalingConfiguration": {
"MinCapacity": number,
"MaxCapacity": number,
"ScaleInCooldown": number,
"ScaleOutCooldown": number,
"ScalingPolicies": [
{
"TargetTracking": {
"MetricSpecification": {
"Predefined" {
"PredefinedMetricType": "string"
},
"Customized": {
"MetricName": "string",
"Namespace": "string",
"Statistic": "string"
}
},
"TargetValue": Double
}
}
]
}
}
```
Os campos `InferenceRecommendationsJobName`, `RecommendationID`, `EndpointName` ou `TargetCpuUtilizationPerCore`, e os campos do objeto `ScalingPolicyObjective` são copiados da sua solicitação inicial.
O objeto `Metric` lista as métricas que foram avaliadas em seu trabalho de recomendação de inferência, juntamente com um cálculo dos valores de cada métrica quando a utilização da instância seria igual ao valor `TargetCpuUtilizationPerCore`. Isso é útil para antecipar as métricas de desempenho em seu endpoint quando ele aumenta e diminui a escala com a política de dimensionamento automático recomendada. Por exemplo, considere se sua utilização de instância foi de 50% em seu trabalho de recomendação de inferência e seu valor `InvocationsPerInstance` foi originalmente de `4`. Se você especificar o `TargetCpuUtilizationPerCore` valor como 100% em sua solicitação de recomendação de dimensionamento automático, o valor métrico `InvocationsPerInstance` retornado na resposta é `2` porque você esperava alocar o dobro da utilização da instância.
O `DynamicScalingConfiguration` objeto retorna os valores que você deve especificar para o [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html#autoscaling-PutScalingPolicy-request-TargetTrackingScalingPolicyConfiguration)ao chamar a [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API. Isso inclui os valores de capacidade mínimo e máximo recomendados, os tempos de resfriamento de redução e redução recomendados e o objeto `ScalingPolicies`, que contém o `TargetValue` recomendado que você deve especificar para cada métrica.
# Executar um teste de carga personalizado
Os testes de carga do Amazon SageMaker Inference Recommender conduzem benchmarks abrangentes com base nos requisitos de produção de latência e taxa de transferência, padrões de tráfego personalizados e endpoints sem servidor ou instâncias em tempo real (até 10) que você seleciona.
As seções a seguir demonstram como criar, descrever e interromper um teste de carga programaticamente usando o AWS SDK para Python (Boto3) e o, ou de forma interativa AWS CLI, usando o Amazon SageMaker Studio Classic ou o SageMaker console de IA.
## Criar um trabalho de teste de carga
Crie um teste de carga programaticamente usando o AWS SDK para Python (Boto3), com o ou interativamente usando o AWS CLI Studio Classic ou o SageMaker console de IA. Assim como nas recomendações de inferência do Inference Recommender, especifique um nome de trabalho para seu teste de carga, um ARN de AWS função do IAM, uma configuração de entrada e o ARN do pacote de modelos de quando você registrou seu modelo no registro do modelo. Os testes de carga exigem que você também especifique um padrão de tráfego e condições de interrupção.
------
#### [ AWS SDK para Python (Boto3) ]
Use a API `CreateInferenceRecommendationsJob` para criar um teste de carga do recomendador de inferência. Especifique `Advanced` para o campo `JobType` e forneça:
+ Um nome do trabalho para seu teste de carga (`JobName`). O nome do trabalho deve ser exclusivo em sua AWS região e em sua AWS conta.
+ O nome do recurso da Amazon (ARN) de um perfil do IAM que habilita o recomendador de inferência para executar tarefas em seu nome. Defina isso para o campo `RoleArn`.
+ Um dicionário de configuração de endpoint (`InputConfig`) em que você deve especificar o seguinte:
+ Para `TrafficPattern`, especifique as fases ou o padrão de tráfego das escadas. Com o padrão de tráfego de fases, novos usuários aparecem a cada minuto na taxa especificada por você. Com o padrão de tráfego de escadas, novos usuários aparecem em intervalos cronometrados (ou *etapas*) a uma taxa especificada por você. Escolha uma das seguintes opções:
+ Em `TrafficType`, especifique `PHASES`. Em seguida, para a matriz `Phases`, especifique `InitialNumberOfUsers` (com quantos usuários simultâneos começar, com um mínimo de 1 e máximo de 3), `SpawnRate` (o número de usuários a serem gerados em um minuto para uma fase específica do teste de carga, com um mínimo de 0 e máximo de 3) e `DurationInSeconds` (quanto tempo a fase de tráfego deve durar, com um mínimo de 120 e máximo de 3600).
+ Em `TrafficType`, especifique `STAIRS`. Em seguida, para a matriz `Stairs`, especifique `DurationInSeconds` (quanto tempo a fase de tráfego deve durar, com um mínimo de 120 e máximo de 3600), `NumberOfSteps` (quantos intervalos são usados durante a fase) e `UsersPerStep` (quantos usuários são adicionados durante cada intervalo). Observe que o comprimento de cada etapa é o valor de `DurationInSeconds / NumberOfSteps`. Por exemplo, se seu `DurationInSeconds` for `600` e você especificar `5` etapas, cada etapa terá 120 segundos de duração.
**nota**
Um usuário é definido como um ator gerado pelo sistema que é executado em um loop e invoca solicitações para um endpoint como parte do recomendador de inferência. Para um XGBoost contêiner típico executado em uma `ml.c5.large` instância, os endpoints podem atingir 30.000 invocações por minuto (500 tps) com apenas 15 a 20 usuários.
+ Para `ResourceLimit`, especifique `MaxNumberOfTests` (o número máximo de testes de carga de análise comparativa para um trabalho do Inference Recommender, com um mínimo de 1 e máximo de 10) e `MaxParallelOfTests` (o número máximo de testes de carga de análise comparativa paralelas para um trabalho do recomendador de inferência, com um mínimo de 1 e um máximo de 10).
+ Para `EndpointConfigurations`, você pode especificar um dos seguintes:
+ O campo `InstanceType`, no qual você especifica o tipo de instância na qual deseja executar seus testes de carga.
+ O `ServerlessConfig`, no qual você especifica seus valores ideais para `MaxConcurrency` e `MemorySizeInMB` para um endpoint com tecnologia sem servidor. Para obter mais informações, consulte [Documentação de inferência de tecnologia sem servidor](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
+ Um dicionário de condições de interrupção (`StoppingConditions`), em que, se alguma das condições for atendida, a tarefa do recomendador de inferência será interrompida. Neste exemplo, especifique os seguintes campos no dicionário:
+ Para `MaxInvocations`, especifique o número máximo de solicitações por minuto esperado para o endpoint, com um mínimo de 1 e um máximo de 30.000.
+ Para `ModelLatencyThresholds`, especifique `Percentile` (o limite do percentil de latência do modelo) e `ValueInMilliseconds` (o valor do percentil de latência do modelo em milissegundos).
+ (Opcional) Para `FlatInvocations`, você pode especificar se deseja continuar o teste de carga quando a taxa de TPS (invocações por minuto) se estabilizar. Uma taxa de TPS reduzida geralmente significa que o endpoint atingiu a capacidade. No entanto, talvez você queira continuar monitorando o endpoint em condições de capacidade total. Para continuar o teste de carga quando isso acontecer, especifique esse valor como `Continue`. Caso contrário, o valor padrão será `Stop`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region=
sagemaker_client=boto3.client('sagemaker', region=aws_region)
# Provide a name to your recommendation based on load testing
load_test_job_name=""
# Provide the name of the sagemaker instance type
instance_type=""
# Provide the IAM Role that gives SageMaker permission to access AWS services
role_arn='arn:aws:iam:::role/*'
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn='arn:aws:sagemaker:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName=load_test_job_name,
JobType="Advanced",
RoleArn=role_arn,
InputConfig={
'ModelPackageVersionArn': model_package_arn,
"JobDurationInSeconds": 7200,
'TrafficPattern' : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
'TrafficType': 'PHASES',
'Phases': [
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
},
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
'ResourceLimit': {
'MaxNumberOfTests': 10,
'MaxParallelOfTests': 3
},
"EndpointConfigurations" : [{
'InstanceType': 'ml.c5.xlarge'
},
{
'InstanceType': 'ml.m5.xlarge'
},
{
'InstanceType': 'ml.r5.xlarge'
}]
# Uncomment the ServerlessConfig and comment out the InstanceType field if you want recommendations for a serverless endpoint
# "ServerlessConfig": {
# "MaxConcurrency": value,
# "MemorySizeInMB": value
# }
},
StoppingConditions={
'MaxInvocations': 1000,
'ModelLatencyThresholds':[{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
'FlatInvocations': 'Stop'
}
)
```
Consulte o [Guia de referência de SageMaker API da Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) para obter uma lista completa dos argumentos opcionais e obrigatórios para os quais você pode passar`CreateInferenceRecommendationsJob`.
------
#### [ AWS CLI ]
Use a API `create-inference-recommendations-job` para criar um teste de carga do recomendador de inferência. Especifique `Advanced` para o campo `JobType` e forneça:
+ Um nome do trabalho para seu teste de carga (`job-name`). O nome do trabalho deve ser exclusivo em sua AWS região e em sua AWS conta.
+ O nome do recurso da Amazon (ARN) de um perfil do IAM que habilita o recomendador de inferência para executar tarefas em seu nome. Defina isso para o campo `role-arn`.
+ Um dicionário de configuração de endpoint (`input-config`) em que você deve especificar o seguinte:
+ Para `TrafficPattern`, especifique as fases ou o padrão de tráfego das escadas. Com o padrão de tráfego de fases, novos usuários aparecem a cada minuto na taxa especificada por você. Com o padrão de tráfego de escadas, novos usuários aparecem em intervalos cronometrados (ou *etapas*) a uma taxa especificada por você. Escolha uma das seguintes opções:
+ Em `TrafficType`, especifique `PHASES`. Em seguida, para a matriz `Phases`, especifique `InitialNumberOfUsers` (com quantos usuários simultâneos começar, com um mínimo de 1 e máximo de 3), `SpawnRate` (o número de usuários a serem gerados em um minuto para uma fase específica do teste de carga, com um mínimo de 0 e máximo de 3) e `DurationInSeconds` (quanto tempo a fase de tráfego deve durar, com um mínimo de 120 e máximo de 3600).
+ Em `TrafficType`, especifique `STAIRS`. Em seguida, para a matriz `Stairs`, especifique `DurationInSeconds` (quanto tempo a fase de tráfego deve durar, com um mínimo de 120 e máximo de 3600), `NumberOfSteps` (quantos intervalos são usados durante a fase) e `UsersPerStep` (quantos usuários são adicionados durante cada intervalo). Observe que o comprimento de cada etapa é o valor de `DurationInSeconds / NumberOfSteps`. Por exemplo, se seu `DurationInSeconds` for `600` e você especificar `5` etapas, cada etapa terá 120 segundos de duração.
**nota**
Um usuário é definido como um ator gerado pelo sistema que é executado em um loop e invoca solicitações para um endpoint como parte do recomendador de inferência. Para um XGBoost contêiner típico executado em uma `ml.c5.large` instância, os endpoints podem atingir 30.000 invocações por minuto (500 tps) com apenas 15 a 20 usuários.
+ Para `ResourceLimit`, especifique `MaxNumberOfTests` (o número máximo de testes de carga de análise comparativa para um trabalho do Inference Recommender, com um mínimo de 1 e máximo de 10) e `MaxParallelOfTests` (o número máximo de testes de carga de análise comparativa paralelas para um trabalho do recomendador de inferência, com um mínimo de 1 e um máximo de 10).
+ Para `EndpointConfigurations`, você pode especificar um dos seguintes:
+ O campo `InstanceType`, no qual você especifica o tipo de instância na qual deseja executar seus testes de carga.
+ O `ServerlessConfig`, no qual você especifica seus valores ideais para `MaxConcurrency` e `MemorySizeInMB` para um endpoint com tecnologia sem servidor.
+ Um dicionário de condições de interrupção (`stopping-conditions`), em que, se alguma das condições for atendida, a tarefa do recomendador de inferência será interrompida. Neste exemplo, especifique os seguintes campos no dicionário:
+ Para `MaxInvocations`, especifique o número máximo de solicitações por minuto esperado para o endpoint, com um mínimo de 1 e um máximo de 30.000.
+ Para `ModelLatencyThresholds`, especifique `Percentile` (o limite do percentil de latência do modelo) e `ValueInMilliseconds` (o valor do percentil de latência do modelo em milissegundos).
+ (Opcional) Para `FlatInvocations`, você pode especificar se deseja continuar o teste de carga quando a taxa de TPS (invocações por minuto) se estabilizar. Uma taxa de TPS reduzida geralmente significa que o endpoint atingiu a capacidade. No entanto, talvez você queira continuar monitorando o endpoint em condições de capacidade total. Para continuar o teste de carga quando isso acontecer, especifique esse valor como `Continue`. Caso contrário, o valor padrão será `Stop`.
```
aws sagemaker create-inference-recommendations-job\
--region \
--job-name \
--job-type ADVANCED\
--role-arn arn:aws:iam:::role/*\
--input-config \"{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:::role/*\",
\"JobDurationInSeconds\": 7200,
\"TrafficPattern\" : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
\"TrafficType\": \"PHASES\",
\"Phases\": [
{
\"InitialNumberOfUsers\": 1,
\"SpawnRate\": 60,
\"DurationInSeconds\": 300
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
\"ResourceLimit\": {
\"MaxNumberOfTests\": 10,
\"MaxParallelOfTests\": 3
},
\"EndpointConfigurations\" : [
{
\"InstanceType\": \"ml.c5.xlarge\"
},
{
\"InstanceType\": \"ml.m5.xlarge\"
},
{
\"InstanceType\": \"ml.r5.xlarge\"
}
# Use the ServerlessConfig and leave out the InstanceType fields if you want recommendations for a serverless endpoint
# \"ServerlessConfig\": {
# \"MaxConcurrency\": value,
# \"MemorySizeInMB\": value
# }
]
}\"
--stopping-conditions \"{
\"MaxInvocations\": 1000,
\"ModelLatencyThresholds\":[
{
\"Percentile\": \"P95\",
\"ValueInMilliseconds\": 100
}
],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
\"FlatInvocations\": \"Stop\"
}\"
```
------
#### [ Amazon SageMaker Studio Classic ]
Crie um teste de carga com o Studio Classic.
1. Em sua aplicação do Studio Classic, escolha o ícone Início (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Na barra de navegação lateral do Studio Classic, escolha **Implantações**.
1. Escolha **Recomendador de inferência** na lista suspensa.
1. Escolha **Criar trabalho do recomendador de inferência**. Uma nova guia intitulada **Criar trabalho do recomendador de inferência** é aberta.
1. Selecione o nome do seu grupo de modelos no campo da lista suspensa **Grupo de modelos**. A lista inclui todos os grupos de modelos registrados no registro de modelos da sua conta, incluindo modelos registrados fora do Studio Classic.
1. Selecione uma versão do modelo no campo suspenso **Versão do modelo**.
1. Escolha **Continuar**.
1. Forneça um nome para o trabalho no campo **Nome**.
1. (Opcional) Forneça uma descrição do seu trabalho no campo **Descrição**.
1. Escolha uma função do IAM que conceda permissão do Inference Recommender para acessar AWS os serviços. Você pode criar um perfil e anexar a política gerenciada do IAM `AmazonSageMakerFullAccess` para fazer isso, ou você pode deixar o Studio Classic criar um perfil para você.
1. Escolha **Condições de interrupção** para expandir os campos de entrada disponíveis. Forneça um conjunto de condições para interromper uma recomendação de implantação.
1. Especifique o número máximo de solicitações por minuto esperado para o endpoint no campo **Máximo de invocações por minuto**.
1. Especifique o limite de latência do modelo em microssegundos no campo Limite de **latência do modelo**. O **limite de latência do modelo** descreve o intervalo de tempo gasto por um modelo para responder, conforme visualizado pelo recomendador de inferência. Esse intervalo inclui o tempo de comunicação local necessário para enviar a solicitação e buscar a resposta de um modelo, bem como o tempo gasto para concluir a inferência no contêiner.
1. Escolha **Padrão de tráfego** para expandir os campos de entrada disponíveis.
1. Defina o número inicial de usuários virtuais especificando um número inteiro no campo **Número inicial de usuários**.
1. Forneça um número inteiro para o campo **Taxa de geração**. A taxa de geração define o número de usuários criados por segundo.
1. Defina a duração da fase em segundos especificando um número inteiro no campo **Duração**.
1. (Opcional) Adicione padrões de tráfego adicionais. Para fazer isso, escolha **Adicionar**.
1. Escolha a configuração **Adicional** para revelar o campo **Duração máxima do teste**. Especifique, em segundos, o tempo máximo que um teste pode levar durante um trabalho. Novos trabalhos não são programados após a duração definida. Isso ajuda a garantir que os trabalhos em andamento não sejam interrompidos e que você visualize somente os trabalhos concluídos.
1. Escolha **Continuar**.
1. Escolha **Selecionar instâncias**.
1. No campo **Instâncias para avaliação comparativa**, escolha **Adicionar instâncias para testar**. Selecione até 10 instâncias para o recomendador de inferência usar para testes de carga.
1. Escolha **Configurações adicionais**.
1. Forneça um número inteiro que defina um limite superior para o número de testes que um trabalho pode fazer para o **campo Número máximo de testes**. Observe que cada configuração de endpoint resulta em um novo teste de carga.
1. Forneça um número inteiro para o campo de teste **Paralelo máximo**. Essa configuração define um limite superior no número de testes de carga que podem ser executados paralelamente.
1. Selecione **Enviar**.
O teste de carga pode demorar até 2 horas.
**Atenção**
Não feche essa guia. Se você fechar essa guia, cancelará o trabalho de teste de carga do recomendador de inferência.
------
#### [ SageMaker AI console ]
Crie um teste de carga personalizado por meio do console de SageMaker IA fazendo o seguinte:
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, selecione **Recomendador de inferência**.
1. Na página de **trabalhos recomendados de inferência**, escolha **Criar trabalho**.
1. Na **Etapa 1: configuração do modelo**, faça o seguinte:
1. Em **Tipo de trabalho**, escolha **Trabalho de recomendação padrão**.
1. Se você estiver usando um modelo registrado no registro de modelos de SageMaker IA, ative a **opção Escolher um modelo no registro de modelos** e faça o seguinte:
1. Na lista suspensa **Grupo de modelos**, escolha o grupo de modelos no registro de modelos de SageMaker IA em que seu modelo está.
1. Na lista suspensa **Versão do modelo**, escolha a versão desejada do seu modelo.
1. Se você estiver usando um modelo criado no SageMaker AI, desative a **opção Escolher um modelo no registro do modelo** e faça o seguinte:
1. No campo **Nome do modelo**, insira o nome do seu modelo de SageMaker IA.
1. Para a **função do IAM**, você pode selecionar uma função existente AWS do IAM que tenha as permissões necessárias para criar um trabalho de recomendação de instâncias. Como alternativa, se você não tiver uma função existente, poderá escolher **Criar uma nova função** para abrir o pop-up de criação da função, e a SageMaker IA adicionará as permissões necessárias à nova função que você criar.
1. Para o **bucket do S3 para análise comparativa de carga útil**, insira o caminho do Amazon S3 para seu arquivo de carga útil de amostra, que deve conter arquivos de carga útil de amostra que o recomendador de inferência usa para comparar seu modelo em diferentes tipos de instância.
1. Em **Tipo de conteúdo da carga**, insira os tipos de MIME para seus dados de carga útil.
1. Em **Padrão de tráfego**, configure as fases para o teste de carga fazendo o seguinte:
1. Em **Número inicial de usuários**, especifique com quantos usuários simultâneos você deseja começar (com um mínimo de 1 e um máximo de 3).
1. Em **Taxa de geração**, especifique o número de usuários a serem gerados em um minuto para a fase (com um mínimo de 0 e um máximo de 3).
1. Em **Duração (segundos)**, especifique o quão baixa a fase de tráfego deve ser em segundos (com um mínimo de 120 e um máximo de 3600).
1. (Opcional) Se você desativou a **opção Escolher um modelo no registro do modelo** e especificou um modelo de SageMaker IA, então, para a **configuração do contêiner**, faça o seguinte:
1. Na lista suspensa **Domínio**, selecione o domínio de machine learning do modelo, como visão computacional, processamento de linguagem natural ou machine learning.
1. Na lista suspensa **Estrutura**, selecione a estrutura do seu contêiner, como TensorFlow ou. XGBoost
1. Em **Versão do framework**, insira a versão da estrutura da sua imagem de contêiner.
1. Na lista suspensa **Nome do modelo mais próximo**, selecione o modelo pré-treinado que mais se aproxima do seu.
1. Na lista suspensa **Tarefa**, selecione a tarefa de machine learning que o modelo realiza, como classificação ou regressão de imagens.
1. (Opcional) Para **compilação de modelos usando SageMaker o Neo**, você pode configurar o trabalho de recomendação para um modelo que você compilou usando SageMaker o Neo. Em **Configuração de entrada de dados**, insira a forma correta dos dados de entrada para seu modelo em um formato semelhante a `{'input':[1,1024,1024,3]}`.
1. Escolha **Próximo**.
1. Para a **Etapa 2: instâncias e parâmetros de ambiente**, faça o seguinte:
1. Em **Selecionar instâncias para análise comparativa**, você pode selecionar até 8 tipos de instância que deseja comparar.
1. (Opcional) Em **Intervalos de parâmetros de ambiente**, você pode especificar parâmetros de ambiente que ajudem a otimizar seu modelo. Especifique os parâmetros como pares de **Chave** e **Valor**.
1. Escolha **Próximo**.
1. Para a **Etapa 3: parâmetros de trabalho**, faça o seguinte:
1. (Opcional) No campo **Nome do trabalho**, insira um nome para seu trabalho de recomendação de instância. Quando você cria o trabalho, a SageMaker IA acrescenta um carimbo de data/hora ao final desse nome.
1. (Opcional) No campo **Descrição do trabalho**, insira uma descrição para o trabalho.
1. (Opcional) Na lista suspensa **Chave de criptografia**, escolha uma AWS KMS chave por nome ou insira seu ARN para criptografar seus dados.
1. (Opcional) Em **Número máximo de testes**, insira o número de testes que você deseja executar durante o trabalho de recomendação.
1. (Opcional) Em **Máximo de testes paralelos**, insira o número máximo de testes paralelos que você deseja executar durante o trabalho de recomendação.
1. Em **Duração máxima do teste (s)**, insira o número máximo de segundos que você deseja que cada teste seja executado.
1. Em **Máximo de invocações por minuto**, insira o número máximo de solicitações por minuto que o endpoint pode alcançar antes de interromper o trabalho de recomendação. Depois de atingir esse limite, a SageMaker IA encerra o trabalho.
1. Em **Limite de latência do modelo P99 (ms)**, insira o percentil de latência do modelo em milissegundos.
1. Escolha **Próximo**.
1. Para **a Etapa 4: revisar o trabalho**, revise suas configurações e escolha **Enviar**.
------
## Obter os resultados do seu teste de carga
Você pode coletar métricas programaticamente em todos os testes de carga depois que os testes de carga forem concluídos com AWS SDK para Python (Boto3) o AWS CLI Studio Classic ou o console de SageMaker IA.
------
#### [ AWS SDK para Python (Boto3) ]
Colete métricas com a API `DescribeInferenceRecommendationsJob`. Especifique o nome do trabalho do teste de carga para o campo`JobName`:
```
load_test_response = sagemaker_client.describe_inference_recommendations_job(
JobName=load_test_job_name
)
```
Imprima o objeto de resposta.
```
load_test_response['Status']
```
Isso retorna uma resposta JSON semelhante ao exemplo a seguir. Observe que este exemplo mostra os tipos de instância recomendados para inferência em tempo real (para ver um exemplo mostrando recomendações de inferência sem servidor, veja o exemplo após este).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100}
]},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0}
}
```
As primeiras linhas fornecem informações sobre o próprio trabalho de teste de carga. Isso inclui o nome do trabalho, o ARN do perfil, o horário de criação e exclusão.
O dicionário `InferenceRecommendations` contém uma lista de recomendações de inferência do recomendador de inferência.
O dicionário `EndpointConfiguration` aninhado contém a recomendação do tipo de instância (`InstanceType`) junto com o nome do endpoint e da variante (um modelo de aprendizado de AWS máquina implantado) usado durante o trabalho de recomendação. Você pode usar o nome do endpoint e da variante para monitoramento no Amazon CloudWatch Events. Consulte [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md) para obter mais informações.
O dicionário `EndpointConfiguration` aninhado também contém a recomendação de contagem de instâncias (`InitialInstanceCount`). Esse é o número de instâncias que você deve provisionar no endpoint para atender ao `MaxInvocations` especificado no `StoppingConditions`. Por exemplo, se `InstanceType` for `ml.m5.large` e `InitialInstanceCount` for `2`, você deverá provisionar 2 instâncias `ml.m5.large` para seu endpoint para que ele possa lidar com o TPS especificado na condição de interrupção `MaxInvocations`.
O dicionário `Metrics` aninhado contém informações sobre o custo estimado por hora (`CostPerHour`) para seu endpoint em tempo real em dólares americanos, o custo estimado por inferência (`CostPerInference`) para seu endpoint em tempo real, o número máximo de `InvokeEndpoint` solicitações enviadas ao endpoint e a latência do modelo (`ModelLatency`), que é o intervalo de tempo (em microssegundos) que seu modelo levou para responder à IA. SageMaker A latência do modelo inclui os tempos de comunicação local necessários para enviar a solicitação e obter a resposta do contêiner do modelo, bem como o tempo necessário para concluir a inferência dentro do contêiner.
O seguinte exemplo mostra a parte `InferenceRecommendations` da resposta de um trabalho de recomendações de inferência configurado para retornar recomendações de inferência sem servidor:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Você pode interpretar as recomendações para inferência serverless de maneira semelhante aos resultados para inferência em tempo real, com a exceção do `ServerlessConfig`, que indica as métricas retornadas para um endpoint com tecnologia sem servidor com o `MaxConcurrency` fornecido e quando o `MemorySizeInMB` ocorre. As recomendações serverless também medem a métrica `ModelSetupTime`, que avalia (em microssegundos) o tempo que leva para iniciar os recursos computacionais em um endpoint com tecnologia sem servidor. Para obter mais informações sobre como configurar endpoints com technologia sem servidor, consulte [Documentação de inferência de tecnologia sem servidor](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ AWS CLI ]
Colete métricas com a API `describe-inference-recommendations-job`. Especifique o nome do trabalho do teste de carga para a sinalização `job-name`:
```
aws sagemaker describe-inference-recommendations-job --job-name
```
Isso retorna uma resposta semelhante ao exemplo a seguir. Observe que este exemplo mostra os tipos de instância recomendados para inferência em tempo real (para ver um exemplo mostrando recomendações da Inferência Sem Servidor, veja o exemplo após este).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}]
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0
}
}
```
As primeiras linhas fornecem informações sobre o próprio trabalho de teste de carga. Isso inclui o nome do trabalho, o ARN do perfil, o horário de criação e exclusão.
O dicionário `InferenceRecommendations` contém uma lista de recomendações de inferência do recomendador de inferência.
O dicionário `EndpointConfiguration` aninhado contém a recomendação do tipo de instância (`InstanceType`) junto com o nome do endpoint e da variante (um modelo de aprendizado de AWS máquina implantado) usado durante o trabalho de recomendação. Você pode usar o nome do endpoint e da variante para monitoramento no Amazon CloudWatch Events. Consulte [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md) para obter mais informações.
O dicionário `Metrics` aninhado contém informações sobre o custo estimado por hora (`CostPerHour`) para seu endpoint em tempo real em dólares americanos, o custo estimado por inferência (`CostPerInference`) para seu endpoint em tempo real, o número máximo de `InvokeEndpoint` solicitações enviadas ao endpoint e a latência do modelo (`ModelLatency`), que é o intervalo de tempo (em microssegundos) que seu modelo levou para responder à IA. SageMaker A latência do modelo inclui os tempos de comunicação local necessários para enviar a solicitação e obter a resposta do contêiner do modelo, bem como o tempo necessário para concluir a inferência dentro do contêiner.
O seguinte exemplo mostra a parte `InferenceRecommendations` da resposta de um trabalho de recomendações de inferência configurado para retornar recomendações de inferência sem servidor:
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Você pode interpretar as recomendações de inferência sem servidor de maneira semelhante aos resultados para inferência em tempo real, com exceção de `ServerlessConfig`, que indica os valores especificados para `MaxConcurrency` e `MemorySizeInMB` ao configurar o teste de carga. As recomendações de inferência sem servidor também calculam a métrica `ModelSetupTime`, que avalia (em microssegundos) o tempo que leva para iniciar os recursos computacionais em um endpoint sem servidor. Para obter mais informações sobre como configurar endpoints sem servidor, consulte a [documentação da Inferência Sem Servidor](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ Amazon SageMaker Studio Classic ]
As recomendações são preenchidas em uma nova guia chamada **Recomendações de inferência** no Studio Classic. Pode demorar até 2 horas para que os resultados apareçam. Essa guia contém as colunas **Resultados** e **Detalhes**.
A coluna **Detalhes** fornece informações sobre o trabalho de teste de carga, como o nome dado ao trabalho de teste de carga, quando o trabalho foi criado (**Hora de criação**) e muito mais. Também contém informações de **Configurações**, como o número máximo de invocações que ocorreram por minuto e informações sobre os nomes de recursos da Amazon usados.
A coluna **Resultados** fornece janelas de **metas de implantação** e **recomendações de SageMaker IA** nas quais você pode ajustar a ordem em que os resultados são exibidos com base na importância da implantação. Existem três menus suspensos nos quais você pode fornecer o nível de importância do **Custo**, **Latência** e **Throughput** para o seu caso de uso. Para cada meta (custo, latência e throughput), você pode definir o nível de importância: **menor importância**, **baixa importância, importância** **moderada**, **alta importância** ou **maior** importância.
Com base em suas seleções de importância para cada meta, o Inference Recommender exibe sua recomendação principal no campo de **SageMakerrecomendação** à direita do painel, junto com o custo estimado por hora e a solicitação de inferência. Também fornece informações sobre a latência esperada do modelo, o número máximo de invocações e a número de instâncias.
Além da recomendação principal exibida, você também pode ver as mesmas informações exibidas para todas as instâncias que o recomendador de inferência testou na seção **Todas as execuções**.
------
#### [ SageMaker AI console ]
Você pode ver os resultados do seu trabalho de teste de carga personalizado no console de SageMaker IA fazendo o seguinte:
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, selecione **Recomendador de inferência**.
1. Na página de trabalhos do **recomendador de inferência**, escolha o nome do seu trabalho de recomendação de inferência.
Na página de detalhes do seu trabalho, você pode ver as **recomendações de inferência**, que são os tipos de instância que a SageMaker IA recomenda para seu modelo, conforme mostrado na captura de tela a seguir.
![\[Captura de tela da lista de recomendações de inferência na página de detalhes do trabalho no console de SageMaker IA.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
Nesta seção, você pode comparar os tipos de instância por vários fatores, como **latência do modelo**, **custo por hora**, **custo por inferência** e **invocações por minuto**.
Nessa página, você também pode visualizar as configurações especificadas para seu trabalho. Na seção **Monitor**, você pode ver as CloudWatch métricas da Amazon que foram registradas para cada tipo de instância. Para saber mais sobre como interpretar essas métricas, consulte [Interpretar resultados](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html).
------
# Interromper seu teste de carga
Talvez você queira interromper um trabalho que está em execução no momento se tiver iniciado um trabalho por engano ou se não precisar mais executá-lo. Interrompa seus trabalhos de teste de carga programaticamente com a `StopInferenceRecommendationsJob` API ou por meio do Studio Classic ou do console de SageMaker IA.
------
#### [ AWS SDK para Python (Boto3) ]
Especifique o nome do trabalho do teste de carga para o campo`JobName`:
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
Especifique o nome do trabalho do teste de carga para a sinalização `job-name`:
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
Feche a guia em que você iniciou seu trabalho de carregamento personalizado para interromper o teste de carga do recomendador de inferência.
------
#### [ SageMaker AI console ]
Para interromper seu trabalho de teste de carga por meio do console de SageMaker IA, faça o seguinte:
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, selecione **Recomendador de inferência**.
1. Na página de **trabalhos do recomendador de inferência**, selecione seu trabalho de teste de carga.
1. Selecione **Interromper trabalho**.
1. Na caixa de diálogo exibida, escolha **Confirmar**.
Depois de interromper sua tarefa, o **status** da tarefa deve mudar para **Interrompendo**.
------
# Solucionar erros do recomendador de inferência
Esta seção contém informações sobre como entender e evitar erros comuns, as mensagens de erro que eles geram e orientações sobre como resolver esses erros.
## Como solucionar problemas
Você pode tentar resolver seu erro seguindo as seguintes etapas:
+ Verifique se você atendeu a todos os pré-requisitos para usar o recomendador de inferência. Consulte os pré-requisitos do [Recomendador de inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-prerequisites.html).
+ Verifique se você consegue implantar seu modelo do Registro de modelo em um endpoint e se ele pode processar suas cargas úteis sem erros. Consulte [Implantar um modelo a partir do registro](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry-deploy.html).
+ Ao iniciar um trabalho do Inference Recommender, você deve ver os endpoints sendo criados no console e pode revisar os registros. CloudWatch
## Erros comuns
Revise a tabela a seguir para ver os erros comuns do recomendador de inferência e suas soluções.
| Erro | Solução |
| --- | --- |
| Especifique `Domain` na versão do Pacote de modelos 1. `Domain` é um parâmetro obrigatório para o trabalho. | Certifique-se de fornecer o domínio ML ou `OTHER`, se desconhecido. |
| A função ARN fornecida não pode ser assumida e ocorreu um erro `AWSSecurityTokenServiceException`. | Certifique-se de que a função de execução fornecida tenha as permissões necessárias especificadas nos pré-requisitos. |
| Especifique `Framework` na versão do Pacote de modelos 1. `Framework` é um parâmetro obrigatório para o trabalho. | Certifique-se de fornecer o ML framework ou `OTHER`, se desconhecido. |
| Os usuários no final da fase anterior são 0, enquanto os usuários iniciais da fase atual são 1. | Usuários aqui se referem a usuários virtuais ou threads usados para enviar solicitações. Cada fase começa com A usuários e termina com B usuários, onde B > A. Entre fases sequenciais, x\$11 e x\$12, exigimos que abs(x\$12.A - x\$11.B) <= 3 e >= 0. |
| A duração total do tráfego (transversal) não deve ser maior que a duração do trabalho. | A duração total de todas as suas fases não pode exceder a duração do trabalho. |
| O tipo de instância intermitente ml.t2.medium não é permitido. | O recomendador de inferência não oferece apoio a testes de carga na família de instâncias t2 porque instâncias com capacidade de intermitência não fornecem desempenho consistente. |
| ResourceLimitExceeded ao chamar a CreateEndpoint operação | Você excedeu o limite de recursos de SageMaker IA. Por exemplo, o recomendador de inferência pode não conseguir provisionar endpoints para avaliação comparativa se a conta tiver atingido a cota de endpoints. Para obter mais informações sobre limites e cotas de SageMaker IA, consulte Cotas [e endpoints de SageMaker IA da Amazon](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html). |
| ModelError ao chamar a InvokeEndpoint operação | Um erro de modelo pode acontecer por um dos seguintes motivos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
| PayloadError ao chamar a InvokeEndpoint operação | Um erro de carga útil pode acontecer por um dos seguintes motivos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
## Verifique CloudWatch
Ao iniciar um trabalho do recomendador de inferência, você deve ver os endpoints sendo criados no console. Selecione um dos endpoints e visualize os CloudWatch registros para monitorar qualquer erro 4xx/5xx. Se você tiver um trabalho bem-sucedido de recomendador de inferência, poderá ver os nomes dos endpoints como parte dos resultados. Mesmo que seu trabalho do Inference Recommender não tenha êxito, você ainda pode verificar os CloudWatch registros dos endpoints excluídos seguindo as etapas abaixo:
1. Abra o CloudWatch console da Amazon em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Selecione a região na qual você criou a tarefa recomendador de inferência na lista suspensa **Região** no canto superior direito.
1. No painel de navegação do CloudWatch, escolha **Registros e, em seguida, selecione **Grupos** de registros**.
1. Pesquise o grupo de logs chamado `/aws/sagemaker/Endpoints/sm-epc-*`. Selecione o grupo de logs com base em seu trabalho mais recente do recomendador de inferência.
Você também pode solucionar problemas do seu trabalho verificando os registros do Inference CloudWatch Recommender. Os registros do Inference Recommender, que são publicados no grupo de `/aws/sagemaker/InferenceRecommendationsJobs` CloudWatch registros, oferecem uma visão de alto nível do progresso do trabalho no fluxo de `/execution` registros. Você pode encontrar informações detalhadas sobre cada uma das configurações de endpoint que estão sendo testadas no fluxo de logs do `/Endpoint/`.
**Visão geral dos fluxos de log do recomendador de inferência**
+ `/execution`contém informações gerais do trabalho, como configurações de endpoint programadas para análise comparativa, motivo do salto do trabalho de compilação e motivo da falha de validação.
+ `/Endpoint/` contém informações como progresso da criação do recurso, configuração do teste, motivo da interrupção do teste de carga e status da limpeza do recurso.
+ `/CompilationJob/`contém informações sobre trabalhos de compilação criados pelo recomendador de inferência, como a configuração do trabalho de compilação e o status do trabalho de compilação.
**Crie um alarme para mensagens de erro do recomendador de inferência**
O recomendador de inferência gera instruções de log para erros que podem ser úteis na solução de problemas. Com um grupo de CloudWatch registros e um filtro métrico, você pode procurar termos e padrões nesses dados de registro à medida que os dados são enviados CloudWatch. Em seguida, você pode criar um CloudWatch alarme com base no filtro métrico do grupo de registros. Para obter mais informações, consulte [Criar um CloudWatch alarme com base em um filtro métrico de grupo de registros](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Create_alarm_log_group_metric_filter.html).
## Verifique as análises comparativas
Quando você inicia um trabalho do recomendador de inferência, o recomendador de inferência cria várias análises comparativas para avaliar o desempenho do seu modelo em diferentes tipos de instância. Você pode usar a [ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API para ver os detalhes de todos os benchmarks. Se você tiver uma análise comparativa que falhou, poderá ver os motivos da falha como parte dos resultados.
Para usar a [ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API, forneça os seguintes valores:
+ Para `JobName`, forneça o nome do trabalho do recomendador de inferência.
+ Para`StepType`, use `BENCHMARK` para retornar detalhes sobre as análises comparativas do trabalho.
+ Para`Status`, use `FAILED` para retornar detalhes sobre as análises comparativas do trabalho. Para ver uma lista dos outros tipos de status, consulte o `Status` campo na [ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide the job name for the SageMaker Inference Recommender job
job_name = ''
# Filter for benchmarks
step_type = 'BENCHMARK'
# Filter for benchmarks that have a FAILED status
status = 'FAILED'
response = sagemaker_client.list_inference_recommendations_job_steps(
JobName = job_name,
StepType = step_type,
Status = status
)
```
Você pode imprimir o objeto de resposta para visualizar os resultados. O exemplo de código anterior armazenou a resposta em uma variável chamada `response`:
```
print(response)
```
# Inferência em tempo real
A inferência em tempo real é ideal para cargas de trabalho de inferência em que você tem requisitos em tempo real, interativos e de baixa latência. Você pode implantar seu modelo em serviços de hospedagem de SageMaker IA e obter um endpoint que pode ser usado para inferência. Esses endpoints são totalmente gerenciados e oferecem suporte ao escalonamento automático (consulte [Escalabilidade automática dos modelos de SageMaker IA da Amazon](endpoint-auto-scaling.md)).
**Topics**
+ [Implantar modelos para inferência em tempo real](realtime-endpoints-deploy-models.md)
+ [Invocar modelos para inferência em tempo real](realtime-endpoints-test-endpoints.md)
+ [Endpoints](realtime-endpoints-manage.md)
+ [Opções de hospedagem](realtime-endpoints-options.md)
+ [Escalabilidade automática dos modelos de SageMaker IA da Amazon](endpoint-auto-scaling.md)
+ [volumes do armazenamento de instâncias](host-instance-storage.md)
+ [Validação de modelos em produção](model-validation.md)
+ [Explicabilidade on-line com Clarify SageMaker](clarify-online-explainability.md)
+ [Ajustar modelos com componentes de inferência do adaptador](realtime-endpoints-adapt.md)
# Implantar modelos para inferência em tempo real
**Importante**
Políticas personalizadas do IAM que permitem que o Amazon SageMaker SageMaker Studio ou o Amazon Studio Classic criem SageMaker recursos da Amazon também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permitir que o Studio e o Studio Classic criem recursos, mas não permitisse a marcação, erros AccessDenied "" podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que dão permissões para criar SageMaker recursos já incluem permissões para adicionar tags ao criar esses recursos.
Há várias opções para implantar um modelo usando serviços de hospedagem de SageMaker IA. Você pode implantar interativamente um modelo com o SageMaker Studio. Ou você pode implantar programaticamente um modelo usando um AWS SDK, como o SDK do Python ou o SDK SageMaker for Python (Boto3). Você também pode implantar usando AWS CLI o.
## Antes de começar
Antes de implantar um modelo de SageMaker IA, localize e anote o seguinte:
+ O Região da AWS local onde seu bucket do Amazon S3 está localizado
+ O caminho do URI do Amazon S3 em que os artefatos do modelo são armazenados.
+ O papel do IAM para a SageMaker IA
+ O caminho de registro do URI do Docker Amazon ECR para a imagem personalizada que contém o código de inferência ou a estrutura e a versão de uma imagem incorporada do Docker que é suportada e por AWS
Para obter uma lista dos Serviços da AWS disponíveis em cada um Região da AWS, consulte [Mapas de regiões e redes de borda](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para obter informações sobre como criar funções do IAM, consulte [Criar funções do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
**Importante**
O bucket do S3 em que os artefatos do modelo são armazenados deve estar na mesma Região da AWS do modelo que você está criando.
## Utilização compartilhada de recursos com vários modelos
Você pode implantar um ou mais modelos em um endpoint com a Amazon SageMaker AI. Quando vários modelos compartilham um endpoint, eles utilizam em conjunto os recursos que estão hospedados lá, como instâncias de computação de ML e aceleradores. CPUs A maneira mais flexível de implantar vários modelos em um endpoint é definir cada modelo como um *componente de inferência*.
### Componentes de inferência
Um componente de inferência é um objeto de hospedagem de SageMaker IA que você pode usar para implantar um modelo em um endpoint. Nas configurações do componente de inferência, você especifica o modelo, o endpoint e como o modelo utiliza os recursos que o endpoint hospeda. Para especificar o modelo, você pode especificar um objeto do modelo de SageMaker IA ou especificar diretamente os artefatos e a imagem do modelo.
Nas configurações, você pode otimizar a utilização de recursos, adaptando a forma como os núcleos de CPU, os aceleradores e a memória necessária são alocados ao modelo. Você pode implantar vários componentes de inferência em um endpoint onde cada componente de inferência contém um modelo e as necessidades de utilização de recursos desse modelo.
Depois de implantar um componente de inferência, você pode invocar diretamente o modelo associado ao usar a InvokeEndpoint ação na SageMaker API.
Os componentes de inferência fornecem os seguintes benefícios:
**Flexibilidade**
O componente de inferência desacopla os detalhes da hospedagem do modelo do próprio endpoint. Isso fornece mais flexibilidade e controle sobre como os modelos são hospedados e servidos com um endpoint. Você pode hospedar vários modelos na mesma infraestrutura e adicionar ou remover modelos de um endpoint conforme necessário. Você pode atualizar cada modelo de forma independente.
**Escalabilidade**
Você pode especificar quantas cópias de cada modelo hospedar e definir um número mínimo de cópias para garantir que o modelo seja carregado na quantidade necessária para atender às solicitações. Você pode reduzir a escala horizontalmente de qualquer cópia do componente de inferência até zero, o que abre espaço para aumentar a escala verticalmente de outra cópia.
SageMaker A IA empacota seus modelos como componentes de inferência quando você os implanta usando:
+ SageMaker Estúdio clássico.
+ O SDK do SageMaker Python para implantar um objeto Model (onde você define o tipo de endpoint). `EndpointType.INFERENCE_COMPONENT_BASED`
+ O AWS SDK para Python (Boto3) para definir `InferenceComponent` objetos que você implanta em um endpoint.
## Implemente modelos com o SageMaker Studio
Conclua as etapas a seguir para criar e implantar seu modelo de forma interativa por meio do SageMaker Studio. Para obter mais informações sobre como configurar o Studio, consulte a documentação do [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html). Para obter mais orientações sobre vários cenários de implantação, consulte o blog [Package e implante modelos clássicos de ML de forma fácil LLMs com o Amazon SageMaker AI —](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-2-interactive-user-experiences-in-sagemaker-studio/) Part 2.
### Preparar artefatos e permissões
Conclua esta seção antes de criar um modelo no SageMaker Studio.
Você tem duas opções para trazer os artefatos e criar um modelo no Studio:
1. Você pode trazer um arquivo `tar.gz` pré-empacotado que deve incluir os artefatos do modelo, qualquer código de inferência personalizado e todas as dependências listadas em um arquivo `requirements.txt`.
1. SageMaker A IA pode empacotar seus artefatos para você. Você só precisa trazer os artefatos do modelo bruto e todas as dependências em um `requirements.txt` arquivo, e a SageMaker IA pode fornecer o código de inferência padrão para você (ou você pode substituir o código padrão pelo seu próprio código de inferência personalizado). SageMaker A IA oferece suporte a essa opção para as seguintes estruturas: PyTorch, XGBoost.
Além de trazer seu modelo, sua função AWS Identity and Access Management (IAM) e um contêiner Docker (ou estrutura e versão desejadas para as quais a SageMaker IA tem um contêiner pré-construído), você também deve conceder permissões para criar e implantar modelos por meio do SageMaker AI Studio.
Você deve ter a [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html)política anexada à sua função do IAM para poder acessar a SageMaker IA e outros serviços relevantes. Para ver os preços dos tipos de instância no Studio, você também deve anexar a [AWS PriceListServiceFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPriceListServiceFullAccess.html)política (ou, se não quiser anexar toda a política, mais especificamente, a `pricing:GetProducts` ação).
Se optar por carregar os artefatos do modelo ao criar um modelo (ou carregar um arquivo de amostra de carga útil para recomendações de inferência), você deverá criar um bucket do Amazon S3. O nome do bucket deve ser prefixado pela palavra `SageMaker AI`. Capitalizações alternativas de SageMaker IA também são aceitáveis: `Sagemaker` ou. `sagemaker`
Recomendamos usar a convenção de nomenclatura do bucket `sagemaker-{Region}-{accountID}`. Esse bucket é usado para armazenar os artefatos que você carrega.
Depois de criar o bucket, anexe a seguinte política de CORS (compartilhamento de recursos de origem cruzada) ao bucket:
```
[
{
"AllowedHeaders": ["*"],
"ExposeHeaders": ["Etag"],
"AllowedMethods": ["PUT", "POST"],
"AllowedOrigins": ['https://*.sagemaker.aws'],
}
]
```
Você pode anexar uma política de CORS a um bucket do Amazon S3 usando qualquer um dos seguintes métodos:
+ Por meio da página [Editar compartilhamento de recursos entre origens (CORS)](https://s3.console.aws.amazon.com/s3/bucket/bucket-name/property/cors/edit) no console do Amazon S3
+ Usando a API do Amazon S3 [PutBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketCors.html)
+ Usando o put-bucket-cors AWS CLI comando:
```
aws s3api put-bucket-cors --bucket="..." --cors-configuration="..."
```
### Criar um modelo implantável
Nesta etapa, você cria uma versão implantável do seu modelo em SageMaker IA fornecendo seus artefatos junto com especificações adicionais, como o contêiner e a estrutura desejados, qualquer código de inferência personalizado e configurações de rede.
Crie um modelo implantável no SageMaker Studio fazendo o seguinte:
1. Abra o aplicativo SageMaker Studio.
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Escolha a guia **Modelos implantáveis**.
1. Na página **Modelos implantáveis**, escolha **Criar**.
1. Na página **Criar modelo implantável**, no campo **Nome do modelo**, insira um nome para o modelo.
Há várias outras seções para você preencher na página **Criar modelo implantável**.
A seção de **Definição de contêiner** se parece com a seguinte captura de tela:
![\[Captura de tela da seção de Definição de contêiner para criar um modelo no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-container-definition.png)
**Na seção **Definição de contêiner**, faça o seguinte:**
1. Em **Tipo de contêiner**, selecione **Contêiner pré-construído** se quiser usar um contêiner gerenciado por SageMaker IA ou selecione **Traga seu próprio contêiner** se você tiver seu próprio contêiner.
1. Se você selecionou **Contêiner pré-construído**, selecione o **Framework do contêiner**, a **Versão do framework** e o **Tipo de hardware** que gostaria de usar.
1. Se você selecionou **Traga um contêiner próprio**, insira um caminho do Amazon ECR em **Caminho do ECR até a imagem do contêiner**.
Em seguida, preencha a seção **Artefatos**, que se parece com a seguinte captura de tela:
![\[Captura de tela da seção Artefatos para criar um modelo no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-artifacts-section.png)
**Para a seção **Artefatos**, faça o seguinte:**
1. Se você estiver usando uma das estruturas que a SageMaker IA suporta para empacotar artefatos de modelo (PyTorch ou XGBoost), então, para **Artifacts, você pode escolher a opção **Carregar** artefatos**. Com essa opção, você pode simplesmente especificar seus artefatos de modelo bruto, qualquer código de inferência personalizado que você tenha e seu arquivo requirements.txt, e a SageMaker IA cuida do empacotamento do arquivo para você. Faça o seguinte:
1. Em **Artefatos**, selecione **Carregar artefatos** para continuar fornecendo os arquivos. Caso contrário, se você já tiver um arquivo `tar.gz` que contém os arquivos de modelo, o código de inferência e o arquivo `requirements.txt`, selecione **Inserir URI do S3 para artefatos pré-empacotados**.
1. Se você optar por fazer o upload de seus artefatos, então, para o **bucket S3**, insira o caminho do Amazon S3 até um bucket onde você SageMaker gostaria que a IA armazenasse seus artefatos depois de empacotá-los para você. Depois, execute as seguintes etapas:
1. Em **Carregar artefatos do modelo**, carregue os arquivos de modelo.
1. Para **Código de inferência**, selecione **Usar código de inferência padrão** se quiser usar o código padrão que a SageMaker IA fornece para servir inferência. Caso contrário, selecione **Carregar código de inferência personalizado** para usar um código de inferência próprio.
1. Em **Carregar requirements.txt**, carregue um arquivo de texto que liste todas as dependências que você deseja instalar no runtime.
1. Se você não estiver usando uma estrutura compatível com SageMaker IA para empacotar artefatos do modelo, o Studio mostra a opção de **artefatos pré-empacotados** e você deve fornecer todos os seus artefatos já empacotados como um arquivo. `tar.gz` Faça o seguinte:
1. Em **Artefatos pré-empacotados**, selecione **Inserir URI do S3 para artefatos de modelo pré-empacotados** se você já tiver carregado o arquivo `tar.gz` para o Amazon S3. Selecione **Carregar artefatos de modelo pré-empacotados** se quiser fazer o upload direto do seu arquivo para a IA. SageMaker
1. Se você selecionou **Inserir URI do S3 para artefatos de modelo pré-empacotados**, insira o caminho do Amazon S3 até o arquivo para o **URI do S3**. Caso contrário, selecione e carregue o arquivo a partir da máquina local.
A próxima seção é **Segurança**, que é semelhante à seguinte captura de tela:
![\[Captura de tela da seção Segurança para criar um modelo no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-security-section.png)
**Na seção **Segurança**, faça o seguinte:**
1. Em **Perfil do IAM**, insira o ARN para um perfil do IAM.
1. (Opcional) Em **Nuvem privada virtual (VPC)**, você pode selecionar uma Amazon VPC para armazenar a configuração e os artefatos do modelo.
1. (Opcional) Ative o botão **Isolamento de rede** se quiser restringir o acesso do container à internet.
Por fim, você pode preencher opcionalmente a seção **Opções avançadas**, que se parece com a seguinte captura de tela:
![\[Captura de tela da seção Opções avançadas para criar um modelo no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-advanced-options.png)
**(Opcional) Na seção **Opções avançadas**, faça o seguinte:**
1. Ative a opção **Recomendações de instância personalizada** se quiser executar um trabalho do Amazon SageMaker Inference Recommender em seu modelo após sua criação. O Inference Recommender é um recurso que fornece os tipos de instância recomendados para otimizar o desempenho e o custo da inferência. Você pode ver essas recomendações de instância ao se preparar para implantar o modelo.
1. Em **Adicionar variáveis de ambiente**, insira variáveis de ambiente para o contêiner como pares de chave-valor.
1. Em **Tags**, insira todas as tags como pares de chave-valor.
1. Depois de concluir a configuração do modelo e do contêiner, escolha **Criar modelo implantável**.
Agora você deve ter um modelo no SageMaker Studio que esteja pronto para implantação.
### Implantar o modelo
Por fim, você implanta o modelo que configurou na etapa anterior em um endpoint HTTPS. Você pode implantar um único modelo ou vários modelos no endpoint.
**Compatibilidade de modelo e endpoint**
Antes de implantar um modelo em um endpoint, o modelo e o endpoint devem ser compatíveis e ter os mesmos valores para as seguintes configurações:
O perfil do IAM
A Amazon VPC, incluindo suas sub-redes e grupos de segurança
O isolamento da rede (habilitado ou desabilitado)
O Studio impede que você implante modelos em endpoints incompatíveis das seguintes maneiras:
Se você tentar implantar um modelo em um novo endpoint, a SageMaker IA configura o endpoint com configurações iniciais compatíveis. Se você quebrar a compatibilidade ao alterar essas configurações, o Studio mostrará um alerta e impedirá a implantação.
Se você tentar implantar em um endpoint existente e ele for incompatível, o Studio mostrará um alerta e impedirá a implantação.
Se você tentar adicionar vários modelos a uma implantação, o Studio impede a implantação de modelos incompatíveis entre si.
Quando o Studio mostra o alerta sobre a incompatibilidade do modelo e do endpoint, você pode escolher **Visualizar detalhes** no alerta para ver quais configurações são incompatíveis.
Uma forma de implantar um modelo é fazer o seguinte no Studio:
1. Abra o aplicativo SageMaker Studio.
1. No painel de navegação à esquerda, selecione **Modelos**.
1. Na página **Modelos**, selecione um ou mais modelos na lista de modelos de SageMaker IA.
1. Escolha **Implantar**.
1. Em **Nome do endpoint**, abra o menu suspenso. Você pode selecionar um endpoint existente ou criar um endpoint novo no qual você implanta o modelo.
1. Em **Tipo de instância**, selecione o tipo de instância que você deseja usar para o endpoint. Se você executou anteriormente um trabalho do Inference Recommender para o modelo, os tipos de instância recomendados aparecerão na lista sob o título **Recomendado**. Caso contrário, você verá algumas **Instâncias em potencial** que podem ser adequadas para o modelo.
**Compatibilidade do tipo de instância para JumpStart**
Se você estiver implantando um JumpStart modelo, o Studio mostra apenas os tipos de instância compatíveis com o modelo.
1. Em **Contagem inicial de instâncias**, insira o número inicial de instâncias que você gostaria de provisionar para o endpoint.
1. Em **Contagem máxima de instâncias**, especifique o número máximo de instâncias que o endpoint pode provisionar ao aumentar a escala verticalmente para acomodar um aumento no tráfego.
1. Se o modelo que você está implantando for um dos mais usados no hub JumpStart LLMs de modelos, a opção **Configurações alternativas** aparecerá após os campos tipo de instância e contagem de instâncias.
Para os mais populares JumpStart LLMs, AWS tem tipos de instância pré-comparados para otimizar em termos de custo ou desempenho. Esses dados podem ajudar você a decidir qual tipo de instância usar para implantar o LLM. Escolha **Configurações alternativas** para abrir uma caixa de diálogo que contém os dados pré-comparados. O painel é semelhante à seguinte captura de tela:
![\[Captura de tela da caixa Configurações alternativas\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-jumpstart-alternate-configurations.png)
Na caixa **Configurações alternativas**, faça o seguinte:
1. Selecione um tipo de instância. Você pode escolher **Custo por hora** ou **Melhor desempenho** para ver os tipos de instância que otimizam o custo ou o desempenho para o modelo especificado. Você também pode escolher **Outras instâncias compatíveis** para ver uma lista de outros tipos de instância compatíveis com o JumpStart modelo. Observe que selecionar um tipo de instância aqui substitui qualquer seleção de instância anterior especificada na Etapa 6.
1. (Opcional) Ative a opção **Personalizar a configuração selecionada** para especificar **Número máximo** (o número máximo de tokens que você deseja permitir, que é a soma dos tokens de entrada e a saída gerada pelo modelo), **Tamanho máximo do token de entrada** (o número máximo de tokens que você deseja permitir para a entrada de cada solicitação) e **Máximo de solicitações simultâneas** (o número máximo de solicitações que o modelo pode processar por vez).
1. Escolha **Selecionar** para confirmar o tipo de instância e as configurações.
1. O campo **Modelo** já deve estar preenchido com o nome do dos modelos que você está implantando. Você pode escolher **Adicionar modelo** para adicionar mais modelos à implantação. Para cada modelo adicionado, preencha os seguintes campos:
1. Em **Número de núcleos de CPU**, insira os núcleos de CPU que você gostaria de dedicar ao uso do modelo.
1. Em **Número mínimo de cópias**, insira o número mínimo de cópias do modelo que você deseja hospedar no endpoint a qualquer momento.
1. Em **Memória mínima da CPU (MB)**, insira a quantidade mínima de memória (em MB) exigida pelo modelo.
1. Em **Memória máxima da CPU (MB)**, insira a quantidade máxima de memória (em MB) que você gostaria de permitir que o modelo usasse.
1. (Opcional) Em **Opções avançadas**, faça o seguinte:
1. Para a **função IAM**, use a função de execução padrão do SageMaker AI IAM ou especifique sua própria função que tenha as permissões de que você precisa. Observe que esse perfil do IAM deve ser o mesmo que você especificou ao criar o modelo implantável.
1. Para a **Nuvem Privada Virtual (VPC)**, você pode especificar uma VPC na qual deseja hospedar o endpoint.
1. Em **Chave KMS de criptografia**, selecione uma AWS KMS chave para criptografar dados no volume de armazenamento anexado à instância de computação de ML que hospeda o endpoint.
1. Ative o botão **Habilitar isolamento de rede** para restringir o acesso do contêiner à internet.
1. Em **Configuração de tempo limite**, insira valores para os campos **Tempo limite para baixar dados do modelo (segundos)** e **Tempo limite de verificação de integridade de inicialização do contêiner (segundos)**. Esses valores determinam a quantidade máxima de tempo que a SageMaker IA permite para baixar o modelo para o contêiner e inicializá-lo, respectivamente.
1. Em **Tags**, insira todas as tags como pares de chave-valor.
**nota**
SageMaker A IA configura a função do IAM, a VPC e as configurações de isolamento de rede com valores iniciais compatíveis com o modelo que você está implantando. Se você quebrar a compatibilidade ao alterar essas configurações, o Studio mostrará um alerta e impedirá a implantação.
Após configurar as opções, a página deve ter a aparência da seguinte captura de tela:
![\[Captura de tela da página Implantar modelo no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-deploy-realtime-model-2.png)
Depois de configurar sua implantação, escolha **Implantar** para criar o endpoint e implantar o modelo.
## Implemente modelos com o Python SDKs
Usando o SDK do SageMaker Python, você pode criar seu modelo de duas maneiras. A primeira é criar um objeto de modelo a partir da classe `Model` ou `ModelBuilder`. Se usar a classe `Model` para criar seu objeto `Model`, você precisará especificar o pacote do modelo ou o código de inferência (dependendo do servidor do modelo), scripts para lidar com a serialização e desserialização de dados entre o cliente e o servidor e quaisquer dependências a serem carregadas no Amazon S3 para consumo. A segunda maneira de criar seu modelo é usar o `ModelBuilder` para o qual você fornece artefatos de modelo ou código de inferência. O `ModelBuilder` captura automaticamente as dependências, infere as funções de serialização e desserialização necessárias e empacota as dependências para criar o objeto `Model`. Para saber mais sobre o `ModelBuilder`, consulte [Crie um modelo na Amazon SageMaker AI com ModelBuilder](how-it-works-modelbuilder-creation.md).
A seção a seguir descreve os dois métodos para criar o modelo e implantar o objeto de modelo.
### Configurar
Os exemplos a seguir preparam o processo de implantação do modelo. Eles importam as bibliotecas necessárias e definem a URL do S3 que localiza os artefatos do modelo.
------
#### [ SageMaker Python SDK ]
**Example instruções de importação**
O exemplo a seguir importa módulos do SDK do SageMaker Python, do SDK para Python (Boto3) e da Python Standard Library. Esses módulos fornecem métodos úteis que ajudam você a implantar modelos e são usados pelos demais exemplos a seguir.
```
import boto3
from datetime import datetime
from sagemaker.compute_resource_requirements.resource_requirements import ResourceRequirements
from sagemaker.predictor import Predictor
from sagemaker.enums import EndpointType
from sagemaker.model import Model
from sagemaker.session import Session
```
------
#### [ boto3 inference components ]
**Example instruções de importação**
O exemplo a seguir importa módulos do SDK for Python (Boto3) e da Python Standard Library. Esses módulos fornecem métodos úteis que ajudam você a implantar modelos e são usados pelos demais exemplos a seguir.
```
import boto3
import botocore
import sys
import time
```
------
#### [ boto3 models (without inference components) ]
**Example instruções de importação**
O exemplo a seguir importa módulos do SDK for Python (Boto3) e da Python Standard Library. Esses módulos fornecem métodos úteis que ajudam você a implantar modelos e são usados pelos demais exemplos a seguir.
```
import boto3
import botocore
import datetime
from time import gmtime, strftime
```
------
**Example URL de artefato de modelo**
O código a seguir cria um exemplo de URL do Amazon S3. A URL localiza os artefatos de modelo para um modelo pré-treinado em um bucket do Amazon S3.
```
# Create a variable w/ the model S3 URL
# The name of your S3 bucket:
s3_bucket = "amzn-s3-demo-bucket"
# The directory within your S3 bucket your model is stored in:
bucket_prefix = "sagemaker/model/path"
# The file name of your model artifact:
model_filename = "my-model-artifact.tar.gz"
# Relative S3 path:
model_s3_key = f"{bucket_prefix}/"+model_filename
# Combine bucket name, model file name, and relate S3 path to create S3 model URL:
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
A URL completa do Amazon S3 é armazenada na variável `model_url`, que é usada nos exemplos a seguir.
### Visão geral do
Há várias maneiras de implantar modelos com o SDK do SageMaker Python ou o SDK for Python (Boto3). As seções a seguir resumem as etapas que você conclui para várias abordagens possíveis. Essas etapas são demonstradas pelos exemplos a seguir.
------
#### [ SageMaker Python SDK ]
Usando o SDK do SageMaker Python, você pode criar seu modelo de uma das seguintes formas:
+ **Criar um objeto de modelo a partir da classe `Model`**: Você deve especificar o pacote do modelo ou o código de inferência (dependendo do servidor de modelo), scripts para lidar com a serialização e desserialização de dados entre o cliente e o servidor e quaisquer dependências a serem carregadas no Amazon S3 para consumo.
+ **Criar um objeto de modelo a partir da classe `ModelBuilder`**: Você fornece artefatos de modelo ou código de inferência e o `ModelBuilder` captura automaticamente as dependências, infere as funções de serialização e desserialização necessárias e empacota as dependências para criar o objeto `Model`.
Para saber mais sobre o `ModelBuilder`, consulte [Crie um modelo na Amazon SageMaker AI com ModelBuilder](how-it-works-modelbuilder-creation.md). Você também pode ver o blog [Package e implantar modelos de ML clássicos e LLMs facilmente com SageMaker IA — Parte 1](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/) para obter mais informações.
Os exemplos a seguir descrevem os dois métodos para criar o modelo e implantar o objeto de modelo. Para implantar um modelo dessas formas, conclua as seguintes etapas:
1. Defina os recursos do endpoint a serem alocados ao modelo com um objeto `ResourceRequirements`.
1. Crie um objeto de modelo a partir das classes `Model` ou `ModelBuilder`. O objeto `ResourceRequirements` é especificado nas configurações do modelo.
1. Implante o modelo em um endpoint usando o método `deploy` do objeto `Model`.
------
#### [ boto3 inference components ]
Os exemplos a seguir demonstram como atribuir um modelo a um componente de inferência e, depois, implantar o componente de inferência em um endpoint. Para implantar um modelo dessa forma, conclua as seguintes etapas:
1. (Opcional) Crie um objeto de modelo de SageMaker IA usando o [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)método.
1. Especifique as configurações do endpoint criando um objeto de configuração do endpoint. Para criar um, você usa o método [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config).
1. Crie o endpoint usando o método [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) e, na solicitação, forneça a configuração de endpoint que você criou.
1. Crie um componente de inferência usando o método `create_inference_component`. Nas configurações, você especifica um modelo executando uma das seguintes ações:
+ Especificação de um objeto de modelo de SageMaker IA
+ Especificação do URI da imagem do modelo e o URL do S3
Você também aloca recursos de endpoint para o modelo. Ao criar o componente de inferência, você implanta o modelo no endpoint. Você pode implantar vários modelos em um endpoint criando vários componentes de inferência, um para cada modelo.
------
#### [ boto3 models (without inference components) ]
Os exemplos a seguir demonstram como criar um objeto de modelo e, depois, implantar o modelo em um endpoint. Para implantar um modelo dessa forma, conclua as seguintes etapas:
1. Crie um modelo de SageMaker IA usando o [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)método.
1. Especifique as configurações do endpoint criando um objeto de configuração do endpoint. Para criar um, você usa o método [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config). Na configuração do endpoint, você atribui o objeto do modelo a uma variante de produção.
1. Crie o endpoint usando o método [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html). Na solicitação, forneça a configuração do endpoint que você criou.
Quando você cria o endpoint, a SageMaker IA provisiona os recursos do endpoint e implanta o modelo no endpoint.
------
### Configurar
Os exemplos a seguir configuram os recursos necessários para implantar um modelo em um endpoint.
------
#### [ SageMaker Python SDK ]
O exemplo a seguir atribui os recursos de endpoint a um modelo com um objeto `ResourceRequirements`. Esses recursos incluem núcleos de CPU, aceleradores e memória. Em seguida, o exemplo cria um objeto de modelo a partir da classe `Model`. Como alternativa, você pode criar um objeto de modelo instanciando a [ModelBuilder](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-modelbuilder-creation.html)classe e executando `build` — esse método também é mostrado no exemplo. `ModelBuilder`fornece uma interface unificada para empacotamento de modelos e, nesse caso, prepara um modelo para a implantação de um grande modelo. O exemplo utiliza o `ModelBuilder` para construir um modelo Hugging Face. (Você também pode passar um JumpStart modelo). Depois de criar o modelo, você pode especificar os requisitos de recursos no objeto do modelo. Na próxima etapa, você usará esse objeto para implantar o modelo em um endpoint.
```
resources = ResourceRequirements(
requests = {
"num_cpus": 2, # Number of CPU cores required:
"num_accelerators": 1, # Number of accelerators required
"memory": 8192, # Minimum memory required in Mb (required)
"copies": 1,
},
limits = {},
)
now = datetime.now()
dt_string = now.strftime("%d-%m-%Y-%H-%M-%S")
model_name = "my-sm-model"+dt_string
# build your model with Model class
model = Model(
name = "model-name",
image_uri = "image-uri",
model_data = model_url,
role = "arn:aws:iam::111122223333:role/service-role/role-name",
resources = resources,
predictor_cls = Predictor,
)
# Alternate mechanism using ModelBuilder
# uncomment the following section to use ModelBuilder
/*
model_builder = ModelBuilder(
model="", # like "meta-llama/Llama-2-7b-hf"
schema_builder=SchemaBuilder(sample_input,sample_output),
env_vars={ "HUGGING_FACE_HUB_TOKEN": "}" }
)
# build your Model object
model = model_builder.build()
# create a unique name from string 'mb-inference-component'
model.model_name = unique_name_from_base("mb-inference-component")
# assign resources to your model
model.resources = resources
*/
```
------
#### [ boto3 inference components ]
O exemplo a seguir configura uma integração para o método `create_endpoint_config` com um endpoint HTTP. Você atribui essa configuração a um endpoint ao criá-lo. Na configuração, defina uma ou mais variantes de produção. Para cada variante, você pode escolher o tipo de instância que deseja que a Amazon SageMaker AI provisione e habilitar a escalabilidade gerenciada de instâncias.
```
endpoint_config_name = "endpoint-config-name"
endpoint_name = "endpoint-name"
inference_component_name = "inference-component-name"
variant_name = "variant-name"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
ProductionVariants = [
{
"VariantName": variant_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1,
"ManagedInstanceScaling": {
"Status": "ENABLED",
"MinInstanceCount": 1,
"MaxInstanceCount": 2,
},
}
],
)
```
------
#### [ boto3 models (without inference components) ]
**Example definição do modelo**
O exemplo a seguir define um modelo de SageMaker IA com o `create_model` método no AWS SDK para Python (Boto3).
```
model_name = "model-name"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
PrimaryContainer = {
"Image": "image-uri",
"ModelDataUrl": model_url,
}
)
```
Este exemplo usa o seguinte:
+ `ModelName`: um nome para seu modelo (neste exemplo, ele é armazenado como uma variável de string chamada `model_name`).
+ `ExecutionRoleArn`: O Amazon Resource Name (ARN) da função do IAM que a Amazon SageMaker AI pode assumir para acessar artefatos de modelo e imagens do Docker para implantação em instâncias de computação de ML ou para trabalhos de transformação em lote.
+ `PrimaryContainer`: A localização da imagem do Docker primária que contém código de inferência, artefatos associados e mapas de ambiente personalizado usado pelo código de inferência quando o modelo é implantado para predições.
**Example configuração do endpoint**
O exemplo a seguir configura uma integração para o método `create_endpoint_config` com um endpoint HTTP. A Amazon SageMaker AI usa essa configuração para implantar modelos. Na configuração, você identifica um ou mais modelos, criados com o `create_model` método, para implantar os recursos que você deseja que a Amazon SageMaker AI provisione.
```
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName = "endpoint-config-name",
# List of ProductionVariant objects, one for each model that you want to host at this endpoint:
ProductionVariants = [
{
"VariantName": "variant-name", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
]
)
```
Este exemplo especifica as seguintes chaves para o campo `ProductionVariants`:
+ `VariantName`: o nome da variante de produção.
+ `ModelName`: o nome do modelo que deseja hospedar. Esse é o nome especificado ao criar o modelo.
+ `InstanceType`: o tipo de instância de computação. Consulte o `InstanceType` campo em [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html) e os [preços do SageMaker AI](https://aws.amazon.com/sagemaker/pricing/) para ver uma lista dos tipos de instância de computação compatíveis e os preços de cada tipo de instância.
------
### Implantar
Os exemplos a seguir implantam um modelo em um endpoint.
------
#### [ SageMaker Python SDK ]
O exemplo a seguir implanta o modelo em um endpoint HTTPS em tempo real com o método `deploy` do objeto do modelo. Se você especificar um valor para o argumento `resources` tanto para a criação quanto para a implantação do modelo, os recursos especificados para implantação terão precedência.
```
predictor = model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
resources = resources,
)
```
Para o campo `instance_type`, o exemplo especifica o nome do tipo de instância do Amazon EC2 para o modelo. Para o campo `initial_instance_count`, ele especifica o número inicial de instâncias nas quais executar o endpoint.
O exemplo de código a seguir demonstra outro caso em que você implanta um modelo em um endpoint e depois implanta outro modelo no mesmo endpoint. Nesse caso, você deve fornecer o mesmo nome de endpoint para os métodos `deploy` de ambos os modelos.
```
# Deploy the model to inference-component-based endpoint
falcon_predictor = falcon_model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = ""
resources = resources,
)
# Deploy another model to the same inference-component-based endpoint
llama2_predictor = llama2_model.deploy( # resources already set inside llama2_model
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = "" # same endpoint name as for falcon model
)
```
------
#### [ boto3 inference components ]
Depois de ter uma configuração de endpoint, use o método [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) para criar o endpoint. O nome do endpoint deve ser exclusivo Região da AWS em sua AWS conta.
O recurso abaixo cria um endpoint usando a configuração de endpoint especificada na solicitação. A Amazon SageMaker AI usa o endpoint para provisionar recursos.
```
sagemaker_client.create_endpoint(
EndpointName = endpoint_name,
EndpointConfigName = endpoint_config_name,
)
```
Depois de criar um endpoint, você pode implantar um ou modelos nele criando componentes de inferência. O seguinte exemplo cria um com o método `create_inference_component`:
```
sagemaker_client.create_inference_component(
InferenceComponentName = inference_component_name,
EndpointName = endpoint_name,
VariantName = variant_name,
Specification = {
"Container": {
"Image": "image-uri",
"ArtifactUrl": model_url,
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
},
RuntimeConfig = {"CopyCount": 2}
)
```
------
#### [ boto3 models (without inference components) ]
**Example implantação**
Forneça a configuração do endpoint para a SageMaker IA. O serviço inicia as instâncias de cálculo de ML e implanta o modelo ou modelos conforme especificado na configuração.
Depois de ter o modelo e configuração de endpoint, use o método [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) para criar o endpoint. O nome do endpoint deve ser exclusivo Região da AWS em sua AWS conta.
O recurso abaixo cria um endpoint usando a configuração de endpoint especificada na solicitação. A Amazon SageMaker AI usa o endpoint para provisionar recursos e implantar modelos.
```
create_endpoint_response = sagemaker_client.create_endpoint(
# The endpoint name must be unique within an AWS Region in your AWS account:
EndpointName = "endpoint-name"
# The name of the endpoint configuration associated with this endpoint:
EndpointConfigName = "endpoint-config-name")
```
------
## Implemente modelos com o AWS CLI
Você pode implantar um modelo em um endpoint usando o. AWS CLI
### Visão geral do
Ao implantar um modelo com o AWS CLI, você pode implantá-lo com ou sem o uso de um componente de inferência. As seguintes seções resumem os comandos que você executa para ambas as abordagens: Esses comandos são demonstrados pelos exemplos a seguir.
------
#### [ With inference components ]
Para implantar um modelo com um componente de inferência, faça o seguinte:
1. (Opcional) Crie um modelo com o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html).
1. Especifique as configurações do endpoint ao criar uma configuração de endpoint. Para criar uma, execute o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html).
1. Crie o endpoint usando o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html). No corpo do comando, especifique a configuração do endpoint que você criou.
1. Crie um componente de inferência usando o comando `create-inference-component`. Nas configurações, você especifica um modelo executando uma das seguintes ações:
+ Especificação de um objeto de modelo de SageMaker IA
+ Especificação do URI da imagem do modelo e o URL do S3
Você também aloca recursos de endpoint para o modelo. Ao criar o componente de inferência, você implanta o modelo no endpoint. Você pode implantar vários modelos em um endpoint criando vários componentes de inferência, um para cada modelo.
------
#### [ Without inference components ]
Para implantar um modelo sem usar um componente de inferência, faça o seguinte:
1. Crie um modelo de SageMaker IA usando o [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html)comando.
1. Especifique as configurações do endpoint criando um objeto de configuração do endpoint. Para criar um, use o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html). Na configuração do endpoint, você atribui o objeto do modelo a uma variante de produção.
1. Crie o endpoint usando o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html). No corpo do comando, especifique a configuração do endpoint que você criou.
Quando você cria o endpoint, a SageMaker IA provisiona os recursos do endpoint e implanta o modelo no endpoint.
------
### Configurar
Os exemplos a seguir configuram os recursos necessários para implantar um modelo em um endpoint.
------
#### [ With inference components ]
**Example create-endpoint-config comando**
O exemplo a seguir cria uma configuração de endpoint com o [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)comando.
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name\
--production-variants file://production-variants.json
```
Neste exemplo, o arquivo `production-variants.json` define uma variante de produção com o seguinte JSON:
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
Se o comando for bem-sucedido, ele AWS CLI responderá com o ARN do recurso que você criou.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
#### [ Without inference components ]
**Example comando create-model**
O exemplo a seguir cria um modelo com o comando [create-model](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html).
```
aws sagemaker create-model \
--model-name model-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name \
--primary-container "{ \"Image\": \"image-uri\", \"ModelDataUrl\": \"model-s3-url\"}"
```
Se o comando for bem-sucedido, ele AWS CLI responderá com o ARN do recurso que você criou.
```
{
"ModelArn": "arn:aws:sagemaker:us-west-2:111122223333:model/model-name"
}
```
**Example create-endpoint-config comando**
O exemplo a seguir cria uma configuração de endpoint com o [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)comando.
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--production-variants file://production-variants.json
```
Neste exemplo, o arquivo `production-variants.json` define uma variante de produção com o seguinte JSON:
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
Se o comando for bem-sucedido, ele AWS CLI responderá com o ARN do recurso que você criou.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
### Implantar
Os exemplos a seguir implantam um modelo em um endpoint.
------
#### [ With inference components ]
**Example Comando create-endpoint**
O exemplo a seguir cria um endpoint com o comando [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
Se o comando for bem-sucedido, ele AWS CLI responderá com o ARN do recurso que você criou.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
**Example create-inference-component comando**
O exemplo a seguir cria um componente de inferência com o create-inference-component comando.
```
aws sagemaker create-inference-component \
--inference-component-name inference-component-name \
--endpoint-name endpoint-name \
--variant-name variant-name \
--specification file://specification.json \
--runtime-config "{\"CopyCount\": 2}"
```
Neste exemplo, o arquivo `specification.json` define o contêiner e os recursos de computação com o seguinte JSON:
```
{
"Container": {
"Image": "image-uri",
"ArtifactUrl": "model-s3-url"
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
}
```
Se o comando for bem-sucedido, ele AWS CLI responderá com o ARN do recurso que você criou.
```
{
"InferenceComponentArn": "arn:aws:sagemaker:us-west-2:111122223333:inference-component/inference-component-name"
}
```
------
#### [ Without inference components ]
**Example Comando create-endpoint**
O exemplo a seguir cria um endpoint com o comando [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
Se o comando for bem-sucedido, ele AWS CLI responderá com o ARN do recurso que você criou.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
------
# Invocar modelos para inferência em tempo real
Depois de usar o Amazon SageMaker AI para implantar um modelo em um endpoint, você pode interagir com o modelo enviando solicitações de inferência para ele. Para enviar uma solicitação de inferência para um modelo, você invoca o endpoint que o hospeda. Você pode invocar seus endpoints usando o Amazon SageMaker Studio AWS SDKs, o ou o. AWS CLI
## Invoque seu modelo usando o Amazon Studio SageMaker
Depois de implantar seu modelo em um endpoint, você pode visualizar o endpoint por meio do Amazon SageMaker Studio e testar seu endpoint enviando solicitações de inferência únicas.
**nota**
SageMaker A IA só oferece suporte a testes de endpoint no Studio para endpoints em tempo real.
**Para enviar uma solicitação de inferência de teste para seu endpoint**
1. Inicie o Amazon SageMaker Studio.
1. No painel de navegação à esquerda, escolha **Implantações**.
1. No menu suspenso, escolha **Endpoints.**
1. Encontre seu endpoint pelo nome e escolha o nome na tabela. Os nomes dos endpoints listados no painel **Endpoints** são definidos quando você implanta um modelo. A área de trabalho do Studio abre a página de **Endpoint** em uma nova guia.
1. Escolha a guia **Testar inferência**.
1. Em **Opções de teste**, escolha uma das seguintes opções:
1. Selecione **Testar a solicitação de amostra** para enviar imediatamente uma solicitação ao endpoint. Use o **editor JSON** para fornecer dados de amostra no formato JSON e escolha **Enviar solicitação**para enviar a solicitação ao endpoint. Depois de enviar a solicitação, o Studio mostra a saída da inferência em um cartão à direita do editor JSON.
1. Selecione **Usar código de exemplo do Python SDK** para visualizar o código e enviar uma solicitação ao endpoint. Em seguida, copie o exemplo de código da seção **Exemplo de solicitação de inferência** e execute o código no ambiente de teste.
A parte superior do cartão mostra o tipo de solicitação que foi enviada ao endpoint (somente JSON é aceito). O cartão mostra os seguintes campos:
+ **Status**: exibe um dos seguintes tipos de status:
+ `Success`: a solicitação foi bem-sucedida.
+ `Failed`: a solicitação falhou. Uma resposta aparece em **Motivo da falha**.
+ `Pending`: enquanto a solicitação de inferência está pendente, o status mostra um ícone circular giratório.
+ **Duração da execução**: quanto tempo demorou a invocação (hora de término menos a hora de início) em milissegundos.
+ **Tempo da solicitação**: quantos minutos se passaram desde que a solicitação foi enviada.
+ **Tempo do resultado**: quantos minutos se passaram desde que o resultado foi devolvido.
## Invoque seu modelo usando o AWS SDK para Python (Boto3)
Se quiser invocar um endpoint de modelo no código do seu aplicativo, você pode usar um dos AWS SDKs, incluindo o. AWS SDK para Python (Boto3) Para invocar o endpoint com esse SDK, use um dos seguintes métodos Python:
+ `invoke_endpoint`: envia uma solicitação de inferência para um endpoint do modelo e exibe a resposta que o modelo gera.
Esse método retorna a carga útil de inferência como uma resposta depois que o modelo termina de gerá-la. Para mais informações, consulte a [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) no *AWS SDK para Referência API Python (Boto3)*.
+ `invoke_endpoint_with_response_stream`: envia uma solicitação de inferência para um endpoint do modelo e transmite a resposta de forma incremental enquanto o modelo a gera.
Com esse método, a aplicação recebe partes da resposta à medida que se tornam disponíveis. Para mais informações, consulte a [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) no *AWS SDK para Referência API Python (Boto3)*.
Use esse método somente para invocar modelos que seja compatível comm streaming de inferência.
Antes de usar esses métodos no código do aplicativo, você deve inicializar um cliente do SageMaker AI Runtime e especificar o nome do seu endpoint. O seguinte exemplo configura o cliente e o endpoint para os demais seguintes exemplos:
```
import boto3
sagemaker_runtime = boto3.client(
"sagemaker-runtime", region_name='aws_region')
endpoint_name='endpoint-name'
```
### Invoque para obter uma resposta de inferência
O seguinte exemplo usa o método `invoke_endpoint` para invocar um endpoint com o AWS SDK para Python (Boto3):
```
# Gets inference from the model hosted at the specified endpoint:
response = sagemaker_runtime.invoke_endpoint(
EndpointName=endpoint_name,
Body=bytes('{"features": ["This is great!"]}', 'utf-8')
)
# Decodes and prints the response body:
print(response['Body'].read().decode('utf-8'))
```
Este exemplo fornece dados de entrada no `Body` campo para a SageMaker IA passar para o modelo. Esses dados devem estar no mesmo formato usado para treinamento. O exemplo designa a resposta para a variável `response`.
A variável `response` fornece acesso ao status HTTP, ao nome do modelo implantado e a outros campos. O trecho a seguir imprime o código de status de HTTP:
```
print(response["HTTPStatusCode"])
```
### Invoque para obter uma resposta de fluxo
Se você implantou um modelo que é compatível com streaming de inferência, você pode invocar o modelo para receber sua carga útil de inferência como um fluxo de partes. O modelo entrega essas peças de forma incremental à medida que o modelo as gera. Quando uma aplicação recebe um fluxo de inferência, a aplicação não precisa esperar que o modelo gere toda a carga útil da resposta. Em vez disso, a aplicação recebe imediatamente partes da resposta à medida que se tornam disponíveis.
Ao consumir um fluxo de inferência em sua aplicação, você pode criar interações em que seus usuários percebam que a inferência é rápida porque obtêm a primeira parte imediatamente. Você pode implementar o streaming para oferecer apoio a experiências interativas rápidas, como chatbots, assistentes virtuais e geradores de música. Por exemplo, você pode criar um chatbot que mostre incrementalmente o texto gerado por um modelo de linguagem grande (LLM).
Para obter um fluxo de inferência, você pode usar o método `invoke_endpoint_with_response_stream`. No corpo da resposta, o SDK fornece um objeto `EventStream`, que fornece a inferência como uma série de objetos `PayloadPart`.
**Example Fluxo de inferência**
O seguinte exemplo é um fluxo de objetos `PayloadPart`:
```
{'PayloadPart': {'Bytes': b'{"outputs": [" a"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" challenging"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" problem"]}\n'}}
. . .
```
Em cada parte da carga útil, o campo `Bytes` fornece uma parte da resposta de inferência do modelo. Essa parte pode ser qualquer tipo de conteúdo gerado por um modelo, como texto, imagem ou dados de áudio. Neste exemplo, as partes são objetos JSON que contêm texto gerado de um LLM.
Normalmente, a parte da carga útil contém um bloco discreto de dados do modelo. Neste exemplo, os blocos discretos são objetos JSON inteiros. Ocasionalmente, a resposta de streaming divide as partes em várias partes da carga útil ou combina várias partes em uma parte da carga útil. O seguinte exemplo mostra um bloco de dados no formato JSON dividido em duas partes da carga útil:
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
Ao escrever um código de aplicação que processa um fluxo de inferência, inclua uma lógica que manipule essas divisões e combinações ocasionais de dados. Como uma estratégia, você pode escrever um código que concatene o conteúdo `Bytes` enquanto sua aplicação recebe as partes da carga útil. Ao concatenar os dados JSON de exemplo aqui, você combinaria os dados em um corpo JSON delimitado por nova linha. Em seguida, seu código poderia processar o fluxo analisando todo o objeto JSON em cada linha.
O seguinte exemplo mostra o JSON delimitado por nova linha que você criaria ao concatenar o conteúdo de exemplo de `Bytes`:
```
{"outputs": [" a"]}
{"outputs": [" challenging"]}
{"outputs": [" problem"]}
. . .
```
**Example Código para processar um fluxo de inferência**
O seguinte exemplo de classe Python, `SmrInferenceStream`, demonstra como você pode processar um fluxo de inferência que envia dados de texto no formato JSON:
```
import io
import json
# Example class that processes an inference stream:
class SmrInferenceStream:
def __init__(self, sagemaker_runtime, endpoint_name):
self.sagemaker_runtime = sagemaker_runtime
self.endpoint_name = endpoint_name
# A buffered I/O stream to combine the payload parts:
self.buff = io.BytesIO()
self.read_pos = 0
def stream_inference(self, request_body):
# Gets a streaming inference response
# from the specified model endpoint:
response = self.sagemaker_runtime\
.invoke_endpoint_with_response_stream(
EndpointName=self.endpoint_name,
Body=json.dumps(request_body),
ContentType="application/json"
)
# Gets the EventStream object returned by the SDK:
event_stream = response['Body']
for event in event_stream:
# Passes the contents of each payload part
# to be concatenated:
self._write(event['PayloadPart']['Bytes'])
# Iterates over lines to parse whole JSON objects:
for line in self._readlines():
resp = json.loads(line)
part = resp.get("outputs")[0]
# Returns parts incrementally:
yield part
# Writes to the buffer to concatenate the contents of the parts:
def _write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
# The JSON objects in buffer end with '\n'.
# This method reads lines to yield a series of JSON objects:
def _readlines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
self.read_pos += len(line)
yield line[:-1]
```
Este exemplo processa o fluxo de inferência fazendo o seguinte:
+ Inicializa um cliente SageMaker AI Runtime e define o nome de um endpoint do modelo. Antes de obter um fluxo de inferência, o modelo que o endpoint hospeda deve oferecer compatibilidade com o streaming de inferência.
+ No método de exemplo `stream_inference`, recebe um corpo de solicitação e o passa para o método `invoke_endpoint_with_response_stream` do SDK.
+ Itera sobre cada evento no objeto `EventStream` que o SDK retorna.
+ De cada evento, obtém o conteúdo do objeto `Bytes` no objeto `PayloadPart`.
+ No método `_write` de exemplo, grava em um buffer para concatenar o conteúdo dos objetos `Bytes`. O conteúdo combinado forma um corpo JSON delimitado por nova linha.
+ Usa o método `_readlines` de exemplo para obter uma série iterável de objetos JSON.
+ Em cada objeto JSON, obtém uma parte da inferência.
+ Com a expressão `yield`, retorna as peças de forma incremental.
O seguinte exemplo cria e usa um objeto `SmrInferenceStream`:
```
request_body = {"inputs": ["Large model inference is"],
"parameters": {"max_new_tokens": 100,
"enable_sampling": "true"}}
smr_inference_stream = SmrInferenceStream(
sagemaker_runtime, endpoint_name)
stream = smr_inference_stream.stream_inference(request_body)
for part in stream:
print(part, end='')
```
Este exemplo passa um corpo de solicitação para o método `stream_inference`. Ele itera sobre a resposta para imprimir cada peça que o fluxo de inferência retorna.
O exemplo pressupõe que o modelo no endpoint especificado é um LLM que gera texto. A saída desse exemplo é um corpo de texto gerado que é impresso de forma incremental:
```
a challenging problem in machine learning. The goal is to . . .
```
## Invoque seu modelo usando o AWS CLI
Você pode invocar o endpoint do seu modelo executando comandos com o AWS Command Line Interface ()AWS CLI. A AWS CLI oferece apoio a solicitações de inferência padrão com o comando `invoke-endpoint` e oferece apoio a solicitações de inferência assíncronas com o comando `invoke-endpoint-async`.
**nota**
O AWS CLI não suporta solicitações de inferência de streaming.
O seguinte exemplo usa o comando `invoke-endpoint` para enviar uma solicitação de inferência para um endpoint do modelo:
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name endpoint_name \
--body fileb://$file_name \
output_file.txt
```
Para o parâmetro `--endpoint-name`, forneça o nome do endpoint que você especificou quando o criou. Para o `--body` parâmetro, forneça dados de entrada para que a SageMaker IA passe para o modelo. Os dados devem estar no mesmo formato usado para treinamento. Este exemplo mostra como enviar dados binários para o seu endpoint.
Para obter mais informações sobre quando usar `file://` over `fileb://` ao passar o conteúdo de um arquivo para um parâmetro do AWS CLI, consulte [Melhores práticas para parâmetros de arquivos locais](https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/).
Para obter mais informações e ver parâmetros adicionais que você pode passar, consulte [https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html) na *Referência de Comandos AWS CLI *.
Se o comando `invoke-endpoint` for bem-sucedido, ele retornará uma resposta como a seguinte:
```
{
"ContentType": "; charset=utf-8",
"InvokedProductionVariant": ""
}
```
Se o comando não for bem-sucedido, verifique se a carga útil de entrada está no formato correto.
Visualize a saída da invocação verificando o arquivo de saída do arquivo (`output_file.txt` neste exemplo).
```
more output_file.txt
```
## Invoque seu modelo usando o AWS SDK para Python
### Invocar para transmitir bidirecionalmente uma solicitação e resposta de inferência
Se você quiser invocar um endpoint de modelo no código do seu aplicativo para suportar streaming bidirecional, você pode usar o [novo SDK experimental para Python](https://github.com/awslabs/aws-sdk-python) que oferece suporte ao recurso de streaming bidirecional com suporte a HTTP/2. Esse SDK permite a comunicação bidirecional em tempo real entre seu aplicativo cliente e o SageMaker endpoint, permitindo que você envie solicitações de inferência de forma incremental e, ao mesmo tempo, receba respostas de streaming à medida que o modelo as gera. Isso é particularmente útil para aplicativos interativos em que o cliente e o servidor precisam trocar dados continuamente por meio de uma conexão persistente.
**nota**
O novo SDK experimental é diferente do SDK Boto3 padrão e oferece suporte a conexões bidirecionais persistentes para troca de dados. Ao usar o SDK experimental do Python, recomendamos fortemente a fixação estrita em uma versão do SDK para qualquer caso de uso não experimental.
Para invocar seu endpoint com streaming bidirecional, use o método. `invoke_endpoint_with_bidirectional_stream` Esse método estabelece uma conexão persistente que permite transmitir vários fragmentos de carga útil para seu modelo enquanto recebe respostas em tempo real enquanto o modelo processa os dados. A conexão permanece aberta até que você feche explicitamente o fluxo de entrada ou o endpoint feche a conexão, suportando até 30 minutos de tempo de conexão.
### Pré-requisitos
Antes de usar o streaming bidirecional no código do aplicativo, você deve:
1. Instale o SDK experimental SageMaker Runtime HTTP/2
1. Configurar AWS credenciais para seu cliente SageMaker Runtime
1. Implemente um modelo que suporte streaming bidirecional para um endpoint SageMaker
### Configurar o cliente de streaming bidirecional
O exemplo a seguir mostra como inicializar os componentes necessários para streaming bidirecional:
```
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
# Configuration
AWS_REGION = "us-west-2"
BIDI_ENDPOINT = f"https://runtime.sagemaker.{AWS_REGION}.amazonaws.com:8443"
ENDPOINT_NAME = "your-endpoint-name"
# Initialize the client configuration
config = Config(
endpoint_uri=BIDI_ENDPOINT,
region=AWS_REGION,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
# Create the SageMaker Runtime HTTP/2 client
client = SageMakerRuntimeHTTP2Client(config=config)
```
### Cliente de streaming bidirecional completo
O exemplo a seguir demonstra como criar um cliente de streaming bidirecional que envia várias cargas de texto para um SageMaker endpoint e processa as respostas em tempo real:
```
import asyncio
import logging
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from sagemaker_runtime_http2.models import (
InvokeEndpointWithBidirectionalStreamInput,
RequestStreamEventPayloadPart,
RequestPayloadPart
)
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class SageMakerBidirectionalClient:
def __init__(self, endpoint_name, region="us-west-2"):
self.endpoint_name = endpoint_name
self.region = region
self.client = None
self.stream = None
self.response_task = None
self.is_active = False
def _initialize_client(self):
bidi_endpoint = f"runtime.sagemaker.{self.region}.amazonaws.com:8443"
config = Config(
endpoint_uri=bidi_endpoint,
region=self.region,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
self.client = SageMakerRuntimeHTTP2Client(config=config)
async def start_session(self):
"""Establish a bidirectional streaming connection with the endpoint."""
if not self.client:
self._initialize_client()
logger.info(f"Starting session with endpoint: {self.endpoint_name}")
self.stream = await self.client.invoke_endpoint_with_bidirectional_stream(
InvokeEndpointWithBidirectionalStreamInput(endpoint_name=self.endpoint_name)
)
self.is_active = True
# Start processing responses concurrently
self.response_task = asyncio.create_task(self._process_responses())
async def send_message(self, message):
"""Send a single message to the endpoint."""
if not self.is_active:
raise RuntimeError("Session not active. Call start_session() first.")
logger.info(f"Sending message: {message}")
payload = RequestPayloadPart(bytes_=message.encode('utf-8'))
event = RequestStreamEventPayloadPart(value=payload)
await self.stream.input_stream.send(event)
async def send_multiple_messages(self, messages, delay=1.0):
"""Send multiple messages with a delay between each."""
for message in messages:
await self.send_message(message)
await asyncio.sleep(delay)
async def end_session(self):
"""Close the bidirectional streaming connection."""
if not self.is_active:
return
await self.stream.input_stream.close()
self.is_active = False
logger.info("Stream closed")
# Cancel the response processing task
if self.response_task and not self.response_task.done():
self.response_task.cancel()
async def _process_responses(self):
"""Process incoming responses from the endpoint."""
try:
output = await self.stream.await_output()
output_stream = output[1]
while self.is_active:
result = await output_stream.receive()
if result is None:
logger.info("No more responses")
break
if result.value and result.value.bytes_:
response_data = result.value.bytes_.decode('utf-8')
logger.info(f"Received: {response_data}")
except Exception as e:
logger.error(f"Error processing responses: {e}")
# Example usage
async def run_bidirectional_client():
client = SageMakerBidirectionalClient(endpoint_name="your-endpoint-name")
try:
# Start the session
await client.start_session()
# Send multiple messages
messages = [
"I need help with",
"my account balance",
"I can help with that",
"and recent charges"
]
await client.send_multiple_messages(messages)
# Wait for responses to be processed
await asyncio.sleep(2)
# End the session
await client.end_session()
logger.info("Session ended successfully")
except Exception as e:
logger.error(f"Client error: {e}")
await client.end_session()
if __name__ == "__main__":
asyncio.run(run_bidirectional_client())
```
O cliente inicializa o cliente SageMaker Runtime HTTP/2 com o URI do endpoint regional na porta 8443, que é necessário para conexões de streaming bidirecionais. O `session()` método start\$1 chama `invoke_endpoint_with_bidirectional_stream()` para estabelecer a conexão persistente e cria uma tarefa assíncrona para processar as respostas recebidas simultaneamente.
O `send_event()` método agrupa os dados da carga nos objetos de solicitação apropriados e os envia pelo fluxo de entrada, enquanto escuta e processa `_process_responses()` continuamente as respostas do endpoint à medida que elas chegam. Essa abordagem bidirecional permite a interação em tempo real, na qual o envio de solicitações e o recebimento de respostas acontecem simultaneamente na mesma conexão.
# Endpoints
Depois de implantar o modelo em um endpoint, talvez você queira visualizar e gerenciar o endpoint. Com o SageMaker AI, você pode visualizar o status e os detalhes do endpoint, verificar métricas e logs para monitorar o desempenho do endpoint, atualizar os modelos implantados no endpoint e muito mais.
As seções a seguir mostram como você pode gerenciar endpoints no Amazon SageMaker Studio ou no Console de gerenciamento da AWS.
A página a seguir descreve como visualizar e fazer alterações interativamente nos endpoints usando o console do Amazon SageMaker AI ou o SageMaker Studio.
**Topics**
+ [Visualizar detalhes do endpoint no SageMaker Studio](manage-endpoints-studio.md)
+ [Visualizar detalhes do endpoint no console do SageMaker AI](manage-endpoints-console.md)
# Visualizar detalhes do endpoint no SageMaker Studio
No Amazon SageMaker Studio, você pode visualizar e gerenciar os endpoints de hospedagem do SageMaker AI. Para saber mais sobre o Studio, consulte [Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html).
Para localizar a lista de endpoints no SageMaker, faça o seguinte:
1. Abra a aplicação Studio.
1. No painel de navegação à esquerda, selecione **Implantações**.
1. No menu suspenso, escolha **Endpoints**.
A página **Endpoints** é aberta, listando todos os endpoints de hospedagem do SageMaker AI. Nessa página, você pode ver os endpoints e seu **Status**. Você também pode criar um novo endpoint, editar um endpoint existente ou excluir um endpoint.
Para ver os detalhes de um endpoint específico, escolha um endpoint na lista. Na página de detalhes do endpoint, você tem uma visão geral como na captura de tela a seguir.
![\[Captura de tela da página principal de um endpoint mostrando um resumo dos detalhes do endpoint no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-endpoint-details-page.png)
Cada página de detalhes do endpoint contém as seguintes guias de informações:
# Exibir variantes (ou modelos)
A guia **Variantes** [também chamada de guia **(Modelos)** se o seu endpoint tiver vários modelos implantados] mostra a lista de [variantes de modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-ab-testing.html) ou modelos atualmente implantados no endpoint. A captura de tela a seguir mostra a aparência da visão geral e da seção **Modelos** de um endpoint com vários modelos implantados.
![\[Captura de tela da página principal de um endpoint mostrando vários modelos implantados.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-goldfinch-multi-model-endpoint.png)
É possível adicionar ou editar configurações para cada variante ou modelo. Você também pode selecionar uma variante e habilitar uma política de ajuste de escala automático padrão, que pode ser editada posteriormente na guia **Ajuste de escala automático**.
# Visualizar configurações
Na guia **Configurações**, você pode ver o perfil do IAM da AWS associado ao endpoint, a chave do AWS KMS usada para criptografia (se aplicável), o nome da VPC e as configurações de isolamento de rede.
# Testar inferência
Na guia **Testar inferência**, você pode enviar uma solicitação de teste de inferência para um modelo implantado. Isso é útil se você quiser verificar se o endpoint responde às solicitações conforme o esperado.
Para testar inferência, faça o seguinte:
1. Na guia **Testar inferência** do modelo, escolha uma das seguintes opções:
1. Selecione **Inserir o corpo da solicitação** se quiser testar o endpoint e receber uma resposta por meio da interface do Studio.
1. Selecione **Copiar código de exemplo (Python)** se quiser copiar um exemplo do AWS SDK para Python (Boto3) que possa ser usado para invocar o endpoint por meio de um ambiente local e receber uma resposta programaticamente.
1. Em **Modelo**, selecione o modelo que você deseja testar no endpoint.
1. Se você escolheu o método de teste da interface do Studio, também poderá escolher o **Tipo de conteúdo** desejado para a resposta no menu suspenso.
Depois de configurar a solicitação, você pode escolher **Enviar solicitação** (para receber uma resposta por meio da interface do Studio) ou **Copiar** para copiar o exemplo do Python.
Se você receber uma resposta por meio da interface do Studio, ela se parecerá com a captura de tela a seguir.
![\[Captura de tela de uma solicitação de teste de inferência bem-sucedida em um endpoint no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/endpoint-test-inference.png)
# Ajuste de escala automático
Na guia **Ajuste de escala automático**, você pode visualizar todas as políticas de ajuste de escala automático configuradas para os modelos hospedados no endpoint. A captura de tela a seguir mostra a guia **Ajuste de escala automático**.
![\[Captura de tela da guia Ajuste de escala automático, mostrando uma política ativa.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/inference/studio-endpoint-autoscaling.png)
Você pode escolher **Editar ajuste de escala automático** para alterar qualquer uma das políticas e ativar ou desativar a política de ajuste de escala automático padrão.
Para saber mais sobre o ajuste de escala automático para endpoints em tempo real, consulte [Ajuste de escala automático de modelos do Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html). Se você não tiver certeza de como configurar uma política de ajuste de escala automático para o endpoint, você pode usar um [trabalho de recomendações de ajuste de escala automático do Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-autoscaling.html) para obter recomendações para uma política de ajuste de escala automático.
# Visualizar detalhes do endpoint no console do SageMaker AI
Para visualizar os endpoints no console do SageMaker AI, faça o seguinte:
1. Acesse o console do SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência**.
1. Na lista suspensa, escolha **Endpoints**.
1. Na página **Endpoints**, escolha o seu endpoints.
A página de detalhes do endpoint deve ser aberta, mostrando um resumo do seu endpoint e das métricas que foram coletadas para seu endpoint.
As seções a seguir descrevem as guias na página de detalhes de endpoints.
# Monitoramento de endpoints
Depois de criar um endpoint de hospedagem do SageMaker AI, você pode monitorar monitorá-lo usando o Amazon CloudWatch, que coleta dados brutos e os processa em métricas legíveis quase em tempo real. Ao usar essas métricas, você pode acessar informações históricas e obter uma melhor visão do desempenho do endpoint. Para obter mais informações, consulte o *[Guia do usuário do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
Na guia **Monitoramento** na página de detalhes do endpoint, você pode visualizar os dados de métricas do CloudWatch que foram coletados do seu endpoint.
A aba **Monitoramento** inclui as seguintes seções:
+ **Métricas operacionais**: Visualize métricas que rastreiam a utilização dos recursos do seu endpoint, como a utilização da CPU e a utilização da memória.
+ **Métricas de invocação**: visualize métricas que rastreiam o número, a integridade e o status das solicitações `InvokeEndpoint` que chegam ao seu endpoint, como erros do modelo de invocação e latência do modelo.
+ **Métricas de saúde**: visualize métricas que monitoram a integridade geral do seu endpoint, como falhas de invocação e falhas de notificação.
Para ver a descrição detalhada de cada métrica, consulte [Métricas do Amazon SageMaker AI no Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
A captura de tela a seguir mostra a seção **Métricas operacionais** para um endpoint sem servidor.
![\[Captura de tela dos gráficos de métricas na seção de métricas operacionais da página de detalhes do endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hosting-operational-metrics.png)
Você pode ajustar o **período** e a **estatística** que deseja rastrear para as métricas em uma determinada seção, bem como o período durante o qual deseja visualizar os dados das métricas. Você também pode adicionar e remover widgets de métrica da visualização de cada seção escolhendo **Adicionar widget**. Na caixa de diálogo **Adicionar widget**, você pode selecionar e desmarcar as métricas que deseja ver.
As métricas disponíveis podem depender do seu tipo de endpoint. Por exemplo, endpoints sem servidor têm algumas métricas que não estão disponíveis para endpoints em tempo real. Para mais informações de métricas específicas por tipo de endpoint, consulte as páginas a seguir.
+ [Monitore um endpoint sem servidor](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints-monitoring.html)
+ [Monitore um endpoint assíncrono](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-monitor.html)
+ [Métricas do CW para implantações de endpoint multimodelo](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoint-cloudwatch-metrics.html)
+ [Logs e métricas de pipeline de inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
# Configurações
Você pode escolher a guia **Configurações** para visualizar informações adicionais sobre seu endpoint, como as configurações da captura de dados, a configuração de endpoint e as tags.
# Criar, excluir e visualizar alarmes
Na guia **Alarmes** na página de detalhes do endpoint, você pode visualizar e criar alarmes de métricas de limite estático simples nos quais você especifica um valor limite para uma métrica. Se a métrica violar o valor limite, o alarme entrará no estado `ALARM`. Para obter mais informações sobre alarmes do CloudWatch, consulte [Usando alarmes do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html).
Na seção **Resumo do Endpoint** você pode visualizar o campo **Alarmes**, que informa quantos alarmes estão ativos atualmente em seu endpoint.
Para ver quais alarmes estão no estado `ALARM`, escolha a guia **Alarmes**. A guia **Alarmes** mostra uma lista completa dos alarmes do endpoint com detalhes sobre seu status e condições. A captura de tela a seguir mostra uma lista de alarmes nesta seção que foram configurados para um endpoint.
![\[Captura de tela da guia de alarmes na página de detalhes do endpoint, que mostra uma lista de alarmes do CloudWatch.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hosting-alarms-tab.png)
O status de um alarme pode ser `In alarm`, `OK` ou `Insufficient data` se não houver dados de métricas suficientes sendo coletados.
Para criar um novo alarme para o endpoint, faça o seguinte:
1. Na guia **Alarmes**, escolha **Criar alarme**.
1. A página **Criar alarme** será aberta. Em **Nome do alarme**, digite um nome para o alarme.
1. (Opcional) Insira uma descrição do alarme.
1. Em **Métrica**, escolha a métrica do CloudWatch que você quer que o alarme monitore.
1. Em **Nome da variante**, escolha a variante do modelo de endpoint que você deseja monitorar.
1. Em **Estatística**, escolha uma das estatísticas disponíveis para a métrica selecionada.
1. Em **Período**, escolha o período a ser usado para calcular cada valor de estatísticas. Por exemplo, se você escolher a estatística Média e um período de 5 minutos, cada ponto de dados monitorado pelo alarme é a média dos pontos de dados da métrica em intervalos de 5 minutos.
1. Em **Períodos de avaliação**, insira o número de pontos de dados que você deseja que o alarme considere ao avaliar se deve entrar no estado do alarme ou não.
1. Em **Condição**, escolha a condicional que você deseja usar para o limite de alarme.
1. Em **Valor limite**, insira o valor desejado para seu limite.
1. (Opcional) Para **Notificação**, você pode escolher **Adicionar notificação** para criar ou especificar um tópico do Amazon SNS que receba uma notificação quando o estado do alarme mudar.
1. Selecione **Criar alarme**.
Depois de criar seu alarme, você pode retornar à guia **Alarmes** para ver seu status a qualquer momento. Nesta seção, você também pode selecionar o alarme e **Editar** ou **Excluir** o alarme.
# Opções de hospedagem
Os tópicos a seguir descrevem as opções de hospedagem de SageMaker IA em tempo real disponíveis, além de como configurar, invocar e excluir cada opção de hospedagem.
**Topics**
+ [Endpoints de modelo único](realtime-single-model.md)
+ [Endpoints multimodelo](multi-model-endpoints.md)
+ [Endpoint com vários contêineres](multi-container-endpoints.md)
+ [Pipelines de inferência na Amazon AI SageMaker](inference-pipelines.md)
+ [Excluir endpoints e recursos](realtime-endpoints-delete-resources.md)
# Endpoints de modelo único
Você pode criar, atualizar e excluir endpoints de inferência em tempo real que hospedam um modelo único com o Amazon SageMaker Studio, o AWS SDK para Python (Boto3), o SageMaker Python SDK ou a AWS CLI. Para os procedimentos e exemplos de códigos, consulte [Implantar modelos para inferência em tempo real](realtime-endpoints-deploy-models.md).
# Endpoints multimodelo
Os endpoints multimodelo fornecem uma solução escalável e econômica para a implantação de um grande número de modelos. Eles melhoram a utilização do endpoint compartilhando a mesma frota de recursos e contêiner de serviço para hospedar todos os seus modelos. Isso reduz os custos de hospedagem, melhorando a utilização do endpoint em comparação com o uso de endpoints de modelo único. Também reduz a sobrecarga de implantação porque a Amazon SageMaker AI gerencia o carregamento de modelos na memória e a escalabilidade deles com base nos padrões de tráfego para seu endpoint.
O diagrama a seguir mostra como os endpoints multimodelo funcionam em comparação com os endpoints de modelo único.
![\[Diagrama que mostra como endpoints de multimodelos hospedam modelos versus endpoints de modelo único.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/multi-model-endpoints-diagram.png)
Os endpoints multimodelo são ideais para hospedar um grande número de modelos que usam a mesma framework de ML em um contêiner de serviço compartilhado. Se você tem uma combinação de modelos acessados com frequência e modelos acessados com pouca frequência, um endpoint multimodelo pode servir eficientemente esse tráfego com menos recursos e maior economia de custos. Sua aplicação deve ser tolerante a penalidades de latência ocasionais relacionadas à inicialização a frio que ocorrem ao chamar modelos de uso pouco frequente.
Os endpoints multimodelo oferecem apoio à hospedagem de modelos baseados em CPU e GPU. Ao utilizar modelos com compatibilidade com GPU, você pode reduzir os custos de implantação do modelo por meio do aumento do uso do endpoint e de suas instâncias de computação aceleradas subjacentes.
Os endpoints multimodelo permitem compartilhar o tempo de recursos de memória entre seus modelos. Isso funciona melhor quando os modelos são muito semelhantes em tamanho e latência de invocação. Quando for o caso, os endpoints multimodelo podem efetivamente usar instâncias em todos os modelos. Se você tiver modelos com transações por segundo (TPS) ou requisitos de latência significativamente maiores, recomendamos hospedá-los em endpoints dedicados.
Você pode usar endpoints multimodelo com os seguintes atributos:
+ [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)e VPCs
+ [Ajuste de escala automático](multi-model-endpoints-autoscaling.md)
+ [Pipelines de inferência de série](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) (mas apenas um contêiner habilitado para vários modelos pode ser incluído em um pipeline de inferência)
+ Testes A/B
Você pode usar o console AWS SDK para Python (Boto) ou o SageMaker AI para criar um endpoint multimodelo. Para endpoints multimodelo com compatibilidade com CPU, você pode criar seu endpoint com contêineres personalizados integrando a biblioteca [Multi Model Server](https://github.com/awslabs/multi-model-server).
**Topics**
+ [Como funcionam os endpoints multimodelo](#how-multi-model-endpoints-work)
+ [Cadernos de exemplos para endpoints multimodelo](#multi-model-endpoint-sample-notebooks)
+ [Algoritmos, frameworks e instâncias compatíveis para endpoints multimodelo](multi-model-support.md)
+ [Recomendações de instâncias para implantações de endpoint multimodelo](multi-model-endpoint-instance.md)
+ [Criar um endpoint multimodelo](create-multi-model-endpoint.md)
+ [Invocar um endpoint multimodelo](invoke-multi-model-endpoint.md)
+ [Adicionar ou remover modelos](add-models-to-endpoint.md)
+ [Crie seu próprio contêiner para endpoints multimodelo de SageMaker IA](build-multi-model-build-container.md)
+ [Segurança de endpoint multimodelo](multi-model-endpoint-security.md)
+ [CloudWatch Métricas para implantações de endpoints de vários modelos](multi-model-endpoint-cloudwatch-metrics.md)
+ [Defina o SageMaker comportamento de cache do modelo de endpoint multimodelo de IA](multi-model-caching.md)
+ [Defina políticas de ajuste de escala automático para implantações de endpoints multimodelo](multi-model-endpoints-autoscaling.md)
## Como funcionam os endpoints multimodelo
SageMaker A IA gerencia o ciclo de vida dos modelos hospedados em endpoints de vários modelos na memória do contêiner. Em vez de baixar todos os modelos de um bucket do Amazon S3 para o contêiner ao criar o endpoint, a SageMaker IA os carrega dinamicamente e os armazena em cache quando você os invoca. Quando a SageMaker IA recebe uma solicitação de invocação para um modelo específico, ela faz o seguinte:
1. Roteia a solicitação para uma instância por trás do endpoint.
1. Faz download do modelo do bucket do S3 para o volume de armazenamento dessa instância.
1. Carrega o modelo na memória do contêiner (CPU ou GPU, dependendo se você tem instâncias compatíveis com CPU ou GPU) naquela instância de computação acelerada. Se o modelo já estiver carregado na memória do contêiner, a invocação é mais rápida porque a SageMaker IA não precisa baixá-lo e carregá-lo.
SageMaker A IA continua roteando as solicitações de um modelo para a instância em que o modelo já está carregado. No entanto, se o modelo receber muitas solicitações de invocação e houver instâncias adicionais para o endpoint multimodelo, a SageMaker IA encaminha algumas solicitações para outra instância para acomodar o tráfego. Se o modelo ainda não estiver carregado na segunda instância, o modelo será obtido por download no volume de armazenamento dessa instância e carregado na memória do contêiner.
Quando a utilização da memória de uma instância é alta e a SageMaker IA precisa carregar outro modelo na memória, ela descarrega modelos não utilizados do contêiner dessa instância para garantir que haja memória suficiente para carregar o modelo. Os modelos que são descarregados permanecem no volume de armazenamento da instância e podem ser carregados na memória do contêiner mais tarde sem serem obtidos por download novamente do bucket do S3. Se o volume de armazenamento da instância atingir sua capacidade, a SageMaker IA excluirá todos os modelos não utilizados do volume de armazenamento.
Para excluir um modelo, pare de enviar solicitações e exclua-o do bucket do S3. SageMaker A IA fornece capacidade de endpoint multimodelo em um contêiner de serviço. Adicionar modelos e excluí-los de um endpoint multimodelo não requer a atualização do endpoint propriamente dito. Para adicionar um modelo, faça upload dele para o bucket do S3 e comece a invocá-lo. Você não precisa de alterações de código para usá-lo.
**nota**
Quando você atualiza um endpoint multi-modelo, as solicitações de invocação inicial no endpoint podem apresentar latências mais altas, à medida que o Smart Routing em endpoints multimodelo se adapta ao padrão de tráfego. No entanto, depois que aprende seu padrão de tráfego, você pode experimentar baixas latências nos modelos usados com mais frequência. Modelos usados com menos frequência podem incorrer em algumas latências de inicialização a frio, pois os modelos são carregados dinamicamente em uma instância.
## Cadernos de exemplos para endpoints multimodelo
Para aprender mais sobre como usar endpoints multi-modelo, você pode experimentar os seguintes cadernos de exemplo:
+ Exemplos de endpoints multimodelo usando instâncias com compatibilidade com CPU:
+ [Notebook de XGBoost amostra de endpoint multimodelo](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) — Este notebook mostra como implantar vários XGBoost modelos em um endpoint.
+ [Exemplo de caderno BYOC de endpoints multimodelo](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_bring_your_own/multi_model_endpoint_bring_your_own.html) — Este notebook mostra como configurar e implantar um contêiner de cliente que ofereça suporte a endpoints multimodelo em IA. SageMaker
+ Exemplos de endpoints multimodelo usando instâncias com compatibilidade com GPU:
+ [Execute vários modelos de aprendizado profundo GPUs com os endpoints multimodelo (MME) de SageMaker IA da Amazon](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) — este notebook mostra como usar um contêiner NVIDIA Triton Inference para implantar ResNet -50 modelos em um endpoint multimodelo.
Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar os exemplos anteriores em SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar uma instância do notebook e abri-la, escolha a guia **Exemplos de SageMaker IA** para ver uma lista de todas as amostras de SageMaker IA. O caderno de endpoint multimodelo está localizado na seção **FUNCIONALIDADE AVANÇADA**. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**.
Para obter mais informações sobre casos de uso para endpoints multimodelo, consulte os seguintes blogs e recursos:
+ Vídeo: [Hospedando milhares de modelos em SageMaker IA](https://www.youtube.com/watch?v=XqCNTWmHsLc&t=751s)
+ Vídeo: [SageMaker AI ML para SaaS](https://www.youtube.com/watch?v=BytpYlJ3vsQ)
+ Blog: [How to scale machine learning inference for multi-tenant SaaS use cases](https://aws.amazon.com/blogs/machine-learning/how-to-scale-machine-learning-inference-for-multi-tenant-saas-use-cases/)
+ Estudo de caso: [Veeva Systems](https://aws.amazon.com/partners/success/advanced-clinical-veeva/)
# Algoritmos, frameworks e instâncias compatíveis para endpoints multimodelo
Para obter informações sobre os algoritmos, frameworks e tipos de instância que você pode usar com endpoints multi-modelo, consulte as seguintes seções:
## Algoritmos, frameworks e instâncias compatíveis para endpoints multimodelo usando instâncias apoiadas por CPU
Os contêineres de inferência para os seguintes algoritmos e frameworks oferecem apoio a endpoints multimodelo:
+ [XGBoost algoritmo com Amazon SageMaker AI](xgboost.md)
+ [Algoritmo k-nearest neighbors (k-NN)](k-nearest-neighbors.md)
+ [Algoritmo de Aprendizagem linear](linear-learner.md)
+ [Algoritmo RCF (Random Cut Forest)](randomcutforest.md)
+ [Recursos para usar TensorFlow com a Amazon SageMaker AI](tf.md)
+ [Recursos para usar o Scikit-learn com a Amazon AI SageMaker](sklearn.md)
+ [Recursos para usar o Apache MXNet com a Amazon AI SageMaker](mxnet.md)
+ [Recursos para usar PyTorch com a Amazon SageMaker AI](pytorch.md)
Para usar qualquer outra estrutura ou algoritmo, use o kit de ferramentas de inferência de SageMaker IA para criar um contêiner que ofereça suporte a endpoints de vários modelos. Para mais informações, consulte [Crie seu próprio contêiner para endpoints multimodelo de SageMaker IA](build-multi-model-build-container.md).
Os endpoints multimodelo oferecem apoio a todos os tipos de instância de CPU.
## Algoritmos, frameworks e instâncias compatíveis para endpoints multimodelo usando instâncias apoiadas por GPU
A hospedagem de vários modelos com suporte de GPU em endpoints de vários modelos é suportada pelo servidor [SageMaker AI Triton Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html). Isso é compatível com todas as principais estruturas de inferência, como NVIDIA® TensorRT™,,, Python, ONNX PyTorch MXNet XGBoost, scikit-learn, OpenVINO, C\$1\$1 personalizado e muito mais. RandomForest
Para utilizar qualquer outro framework ou algoritmo, você pode usar o backend Triton para Python ou C\$1\$1 para escrever a lógica do seu modelo e servir qualquer modelo personalizado. Após ter o servidor pronto, você pode começar a implantar centenas de modelos de aprendizado profundo por trás de um único endpoint.
Os endpoints multimodelo oferecem apoio aos seguintes tipos de instância de GPU:
| Família de instâncias | Tipo de instância | v CPUs | GiB de memória por vCPU | GPUs | Memória da GPU |
| --- | --- | --- | --- | --- | --- |
| p2 | ml.p2.xlarge | 4 | 15.25 | 1 | 12 |
| p3 | ml.p3.2xlarge | 8 | 7,62 | 1 | 16 |
| g5 | ml.g5.xlarge | 4 | 4 | 1 | 24 |
| g5 | ml.g5.2xlarge | 8 | 4 | 1 | 24 |
| g5 | ml.g5.4xlarge | 16 | 4 | 1 | 24 |
| g5 | ml.g5.8xlarge | 32 | 4 | 1 | 24 |
| g5 | ml.g5.16xlarge | 64 | 4 | 1 | 24 |
| g4dn | ml.g4dn.xlarge | 4 | 4 | 1 | 16 |
| g4dn | ml.g4dn.2xlarge | 8 | 4 | 1 | 16 |
| g4dn | ml.g4dn.4xlarge | 16 | 4 | 1 | 16 |
| g4dn | ml.g4dn.8xlarge | 32 | 4 | 1 | 16 |
| g4dn | ml.g4dn.16xlarge | 64 | 4 | 1 | 16 |
# Recomendações de instâncias para implantações de endpoint multimodelo
Há vários itens a serem considerados ao selecionar um tipo de instância de SageMaker AI ML para um endpoint multimodelo:
+ Provisione capacidade suficiente do [Amazon Elastic Block Store (Amazon EBS)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) para todos os modelos que precisam ser atendidos.
+ Equilibre o desempenho (minimize as inicializações a frio) e o custo (não provisione a capacidade da instância além do necessário). Para obter informações sobre o tamanho do volume de armazenamento que a SageMaker IA atribui a cada tipo de instância de um endpoint e de um endpoint multimodelo, consulte. [volumes do armazenamento de instâncias](host-instance-storage.md)
+ Para um contêiner configurado para ser executado no modo `MultiModel`, o volume de armazenamento provisionado para suas instâncias é maior do que o padrão do modo `SingleModel`. Isso permite que mais modelos sejam armazenados em cache no volume de armazenamento da instância do que no modo `SingleModel`.
Ao escolher um tipo de instância de SageMaker AI ML, considere o seguinte:
+ Os endpoints multi-modelo são atualmente compatíveis com todos os tipos de instância com CPU e em tipos de instância com uma única GPU.
+ Para a distribuição de tráfego (padrões de acesso) para os modelos que você deseja hospedar atrás de endpoints multimodelo, juntamente com o tamanho do modelo (quantos modelos podem ser carregados na memória na instância), tenha em mente as seguintes informações:
+ Pense na quantidade de memória em uma instância como o espaço de cache para os modelos a serem carregados e pense no número de v CPUs como o limite de simultaneidade para realizar inferência nos modelos carregados (supondo que a invocação de um modelo esteja vinculada à CPU).
+ Para instâncias baseadas em CPU, o número de v CPUs afeta seu máximo de invocações simultâneas por instância (supondo que a invocação de um modelo esteja vinculada à CPU). Uma quantidade maior de v CPUs permite que você invoque mais modelos exclusivos simultaneamente.
+ Para instâncias com compatibilidade com GPU, uma quantidade maior de memória da instância e da GPU permite que você tenha mais modelos carregados e prontos para atender solicitações de inferência.
+ Para instâncias compatíveis com CPU e GPU, tenha alguma memória "folga" disponível para que os modelos não utilizados possam ser descarregados e, especialmente, para endpoints multimodelos com múltiplas instâncias. Se uma instância ou zona de disponibilidade falhar, os modelos nessas instâncias serão redirecionados para outras instâncias por trás do endpoint.
+ Determine sua tolerância aos loading/downloading horários:
+ As famílias de tipos de instância d (por exemplo, m5d, c5d ou r5d) e g5s vêm com um SSD NVMe (memória expressa não volátil), que oferece alto I/O desempenho e pode reduzir o tempo necessário para baixar modelos para o volume de armazenamento e para que o contêiner carregue o modelo do volume de armazenamento.
+ Como os tipos de instância d e g5 vêm com um armazenamento NVMe SSD, a SageMaker IA não anexa um volume de armazenamento do Amazon EBS a essas instâncias de computação de ML que hospedam o endpoint multimodelo. O ajuste de escala automático funciona melhor quando os modelos têm tamanhos semelhantes e são homogêneos, ou seja, quando apresentam latência de inferência e requisitos de recursos semelhantes.
Você também pode usar as seguintes orientações para ajudar a otimizar o carregamento de modelos em seus endpoints multimodelo:
**Escolher um tipo de instância que não consiga armazenar todos os modelos de destino na memória**
Em alguns casos, você pode optar por reduzir custos escolhendo um tipo de instância que não consiga armazenar todos os modelos de destino na memória de uma só vez. SageMaker A IA descarrega modelos dinamicamente quando fica sem memória para abrir espaço para um modelo recém-direcionado. Para modelos solicitados com pouca frequência, você sacrifica a latência dinâmica de carregamento. Em casos com necessidades de latência mais rigorosas, você pode optar por tipos de instância maiores ou mais instâncias. Investir tempo antecipadamente em testes de desempenho e análise ajuda a garantir implantações bem-sucedidas em produção.
**Avaliando as ocorrências no cache do seu modelo**
CloudWatch As métricas da Amazon podem ajudar você a avaliar seus modelos. Para obter mais informações sobre métricas que você pode usar com endpoints multimodelo, consulte [CloudWatch Métricas para implantações de endpoints de vários modelos](multi-model-endpoint-cloudwatch-metrics.md).
Você pode usar a estatística `Average` da métrica `ModelCacheHit` para monitorar a proporção de solicitações em que o modelo já está carregado. Você pode usar a estatística `SampleCount` da métrica `ModelUnloadingTime` para monitorar o número de solicitações de descarga enviadas ao contêiner durante um período de tempo. Se os modelos estiverem sendo descarregados com muita frequência (um indicador de *thrashing*, onde os modelos são descarregados e carregados novamente porque há espaço insuficiente no cache para o conjunto de modelos em uso), considere usar um tipo de instância maior com mais memória ou aumentar o número de instâncias por trás do endpoint multimodelo. Para endpoints multimodelo com várias instâncias, esteja ciente de que um modelo pode ser carregado em mais de 1 instância.
# Criar um endpoint multimodelo
Você pode usar o console de SageMaker IA ou o AWS SDK para Python (Boto) para criar um endpoint multimodelo. Para criar um endpoint baseado em CPU ou GPU por meio do console, consulte o procedimento do console nas seções a seguir. Se você quiser criar um endpoint multimodelo com o AWS SDK para Python (Boto), use o procedimento de CPU ou GPU nas seções a seguir. Os fluxos de trabalho da CPU e da GPU são semelhantes, mas têm várias diferenças, como os requisitos de contêiner.
**Topics**
+ [Criar um endpoint multimodelo (console)](#create-multi-model-endpoint-console)
+ [Crie um endpoint multimodelo usando com o CPUs AWS SDK para Python (Boto3)](#create-multi-model-endpoint-sdk-cpu)
+ [Crie um endpoint multimodelo usando com o GPUs AWS SDK para Python (Boto3)](#create-multi-model-endpoint-sdk-gpu)
## Criar um endpoint multimodelo (console)
Você pode criar endpoints multimodelo com compatibilidade com CPU e GPU por meio do console. Use o procedimento a seguir para criar um endpoint multimodelo por meio do console de SageMaker IA.
**Como criar um endpoint multimodelo (console)**
1. Abra o console do Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Modelo**. No grupo **Inferência**, escolha **Criar modelo**.
1. Em **Nome do modelo**, insira um nome.
1. Para **Perfil do IAM**, escolha ou crie um perfil do IAM que tenha a política `AmazonSageMakerFullAccess` do IAM anexada.
1. Na seção **Definição do contêiner** para **Fornecer opções de imagem de inferência e artefatos de modelo**, escolha **Usar vários modelos**.
![\[A seção da página Criar modelo onde você pode escolher Usar vários modelos.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/mme-create-model-ux-2.PNG)
1. Para a **imagem de contêiner de inferência**, insira o caminho do Amazon ECR para a imagem de contêiner desejada.
Para modelos de GPU, você deve usar um contêiner com compatibilidade com NVIDIA Triton Inference Server. Para obter uma lista de imagens de contêiner que funcionam com endpoints compatíveis com GPU, consulte os [contêineres de inferência NVIDIA Triton (somente suporte para SM)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only). Para obter mais informações sobre o NVIDIA Triton Inference Server, consulte [Usar o Triton Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Server com IA. SageMaker
1. Escolha **Criar modelo**.
1. Implante seu endpoint multimodelo como faria com um endpoint de modelo único. Para instruções, consulte [Implante o modelo nos serviços de hospedagem de SageMaker IA](ex1-model-deployment.md#ex1-deploy-model).
## Crie um endpoint multimodelo usando com o CPUs AWS SDK para Python (Boto3)
Use a seção a seguir para criar um endpoint multimodelo com compatibilidade com instâncias de CPU. Você cria um endpoint multimodelo usando o Amazon SageMaker AI [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config), da [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs mesma forma que criaria um endpoint de modelo único, mas com duas alterações. Ao definir o contêiner do modelo, você precisa passar um novo `Mode` valor de parâmetro, `MultiModel`. Você também precisa passar o campo `ModelDataUrl` que especifica o prefixo do Amazon S3 em que os artefatos do modelo estão localizados, em vez do caminho para um artefato de modelo único como faria ao implantar um único modelo.
Para um exemplo de notebook que usa SageMaker IA para implantar vários XGBoost modelos em um endpoint, consulte Notebook de amostra de [endpoint XGBoost multimodelo](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html).
O procedimento a seguir descreve as principais etapas usadas nesse exemplo para criar um endpoint multimodelo apoiado por CPU.
**Para implantar o modelo (AWS SDK para Python (Boto 3))**
1. Obtenha um contêiner com uma imagem que ofereça compatibilidade com a implantação de endpoints multimodelo. Para obter uma lista de algoritmos integrados e contêineres de framework que oferecem apoio a endpoints multimodelo, consulte [Algoritmos, frameworks e instâncias compatíveis para endpoints multimodelo](multi-model-support.md). Neste exemplo, usamos o algoritmo integrado [Algoritmo k-nearest neighbors (k-NN)](k-nearest-neighbors.md). Chamamos a função utilitária do [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` para obter o endereço da imagem do algoritmo integrado K-Nearest Neighbors.
```
import sagemaker
region = sagemaker_session.boto_region_name
image = sagemaker.image_uris.retrieve("knn",region=region)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
```
1. Obtenha um cliente de AWS SDK para Python (Boto3) SageMaker IA e crie o modelo que usa esse contêiner.
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (Opcional) Se você estiver usando um pipeline de inferência serial, obtenha os contêineres adicionais para inclusão no pipeline e inclua-os no argumento `Containers` do `CreateModel`:
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**nota**
Você pode usar somente um multi-model-enabled endpoint em um pipeline de inferência serial.
1. (Opcional) Se o seu caso de uso não se beneficia do cache de modelo, defina o valor do campo `ModelCacheSetting` do parâmetro `MultiModelConfig` como `Disabled` e inclua-o no argumento `Container` da chamada para `create_model`. O valor do campo `ModelCacheSetting` é `Enabled` por padrão.
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. Configure o endpoint multimodelo para o modelo. Recomendamos configurar seus endpoints com pelo menos duas instâncias. Isso permite que a SageMaker IA forneça um conjunto altamente disponível de previsões em várias zonas de disponibilidade para os modelos.
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.m4.xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
**nota**
Você pode usar somente um multi-model-enabled endpoint em um pipeline de inferência serial.
1. Crie o endpoint multimodelo usando os parâmetros `EndpointName` e `EndpointConfigName`.
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
## Crie um endpoint multimodelo usando com o GPUs AWS SDK para Python (Boto3)
Utilize a seguinte seção para criar um endpoint multimodelo com compatibilidade com GPU: Você cria um endpoint multimodelo usando o Amazon SageMaker AI [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config), e da [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs mesma forma que cria endpoints de modelo único, mas há várias mudanças. Ao definir o contêiner do modelo, você precisa passar um novo `Mode` valor de parâmetro, `MultiModel`. Você também precisa passar o campo `ModelDataUrl` que especifica o prefixo do Amazon S3 em que os artefatos do modelo estão localizados, em vez do caminho para um artefato de modelo único como faria ao implantar um único modelo. Para endpoints multimodelo baseados em GPU, você também deve usar um contêiner com o NVIDIA Triton Inference Server que seja otimizado para execução em instâncias de GPU. Para obter uma lista de imagens de contêiner que funcionam com endpoints compatíveis com GPU, consulte os [contêineres de inferência NVIDIA Triton (somente suporte para SM)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only).
Para ver um exemplo de caderno que demonstra como criar um endpoint multimodelo apoiado por GPUs, consulte [Executar vários modelos de aprendizado profundo com endpoints multimodelo (MME) de SageMaker IA da GPUs Amazon](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb).
O procedimento a seguir destaca as etapas principais para criar um endpoints multimodelo com compatibilidade com GPUs.
**Para implantar o modelo (AWS SDK para Python (Boto 3))**
1. Defina a imagem de contêiner. Para criar um endpoint multimodelo com suporte de GPU para ResNet modelos, defina o contêiner para usar a imagem do [NVIDIA Triton Server](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html). Esse contêiner oferece apoio a endpoints multimodelo e é otimizado para execução em instâncias de GPU. Chamamos a função utilitária [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` para obter o endereço da imagem. Por exemplo:
```
import sagemaker
region = sagemaker_session.boto_region_name
// Find the sagemaker-tritonserver image at
// https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-triton/resnet50/triton_resnet50.ipynb
// Find available tags at https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only
image = ".dkr.ecr..amazonaws.com/sagemaker-tritonserver:".format(
account_id=account_id_map[region], region=region
)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel',
"Environment": {"SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": "resnet"},
}
```
1. Obtenha um cliente de AWS SDK para Python (Boto3) SageMaker IA e crie o modelo que usa esse contêiner.
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (Opcional) Se você estiver usando um pipeline de inferência serial, obtenha os contêineres adicionais para inclusão no pipeline e inclua-os no argumento `Containers` do `CreateModel`:
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**nota**
Você pode usar somente um multi-model-enabled endpoint em um pipeline de inferência serial.
1. (Opcional) Se o seu caso de uso não se beneficia do cache de modelo, defina o valor do campo `ModelCacheSetting` do parâmetro `MultiModelConfig` como `Disabled` e inclua-o no argumento `Container` da chamada para `create_model`. O valor do campo `ModelCacheSetting` é `Enabled` por padrão.
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. Configurar o Endpoints de vários modelos com instâncias compatíveis com GPU para o modelo. Recomendamos configurar seus endpoints com mais de uma instância para permitir alta disponibilidade e maiores ocorrências no cache.
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.g4dn.4xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
1. Crie o endpoint multimodelo usando os parâmetros `EndpointName` e `EndpointConfigName`.
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
# Invocar um endpoint multimodelo
Para invocar um endpoint de vários modelos, use o [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint)do SageMaker AI Runtime da mesma forma que você invocaria um único endpoint de modelo, com uma alteração. Passe um novo parâmetro `TargetModel` especificando qual dos modelos do endpoint será o destino. A `InvokeEndpoint` solicitação do SageMaker AI Runtime é compatível `X-Amzn-SageMaker-Target-Model` com um novo cabeçalho que segue o caminho relativo do modelo especificado para invocação. O sistema de SageMaker IA constrói o caminho absoluto do modelo combinando o prefixo fornecido como parte da chamada da `CreateModel` API com o caminho relativo do modelo.
Os procedimentos a seguir são os mesmos para endpoints multimodelo compatíveis com CPU e GPU.
------
#### [ AWS SDK for Python (Boto 3) ]
A solicitação de predição de exemplo a seguir usa o [AWS SDK para Python (Boto 3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html) no caderno de exemplo.
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName = "",
ContentType = "text/csv",
TargetModel = ".tar.gz",
Body = body)
```
------
#### [ AWS CLI ]
O seguinte exemplo mostra como fazer uma solicitação CSV com duas linhas usando a AWS Command Line Interface (AWS CLI):
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name "" \
--body "1.0,2.0,5.0"$'\n'"2.0,3.0,4.0" \
--content-type "text/csv" \
--target-model ".tar.gz"
output_file.txt
```
Um `output_file.txt` com informações sobre suas solicitações de inferência é feito se a inferência for bem-sucedida. Para ver mais exemplos de como fazer previsões com o AWS CLI, consulte Como [fazer previsões com o AWS CLI na documentação do SDK do](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#making-predictions-with-the-aws-cli) SageMaker Python.
------
O endpoint multimodelo carrega dinamicamente os modelos de destino conforme necessário. Você observará isso quando executar o [MME Sample Notebook](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) à medida que ele itera as invocações aleatórias em relação a vários modelos de destino hospedados por trás de um único endpoint. O primeiro pedido para um determinado modelo leva mais tempo porque o modelo precisa ser baixado do Amazon Simple Storage Service (Amazon S3) e carregado na memória. Isso é chamado de *inicialização a frio* e espera-se que, em terminais de vários modelos, seja otimizado para melhor relação preço/desempenho para os clientes. As chamadas subsequentes terminam mais rapidamente porque não há sobrecarga adicional após o modelo ter sido carregado.
**nota**
Para instâncias com compatibilidade com GPU, o código de resposta HTTP 507 do contêiner GPU indica falta de memória ou outros recursos. Isso faz com que modelos não utilizados sejam descarregados do contêiner para carregar modelos mais frequentemente usados.
## Repetir solicitações em caso de erros ModelNotReadyException
Na primeira vez que você chama `invoke_endpoint` para um modelo, o modelo é baixado do Amazon Simple Storage Service e carregado no contêiner de inferência. Isso faz com que a primeira chamada demore mais para retornar. As chamadas subsequentes para o mesmo modelo terminam mais rapidamente, porque o modelo já está carregado.
SageMaker A IA retorna uma resposta para uma chamada `invoke_endpoint` em até 60 segundos. Alguns modelos são grandes demais para serem baixados em 60 segundos. Se o modelo não terminar de carregar antes do limite de tempo limite de 60 segundos, a solicitação `invoke_endpoint` retornará com o código de erro `ModelNotReadyException` e o modelo continuará sendo baixado e carregado no contêiner de inferência por até 360 segundos. Se você receber um código de erro `ModelNotReadyException` para uma solicitação `invoke_endpoint`, tente fazer a solicitação novamente. Por padrão, as `invoke_endpoint` solicitações de repetição AWS SDKs para Python (Boto 3) (usando o [modo de repetição Legacy](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#legacy-retry-mode)) e Java que resultam em erros. `ModelNotReadyException` Você pode configurar a estratégia de repetição para continuar repetindo a solicitação por até 360 segundos. Se você espera que seu modelo leve mais de 60 segundos para ser baixado e carregado no contêiner, defina o tempo limite do soquete do SDK para 70 segundos. Para obter mais informações sobre como configurar a estratégia de repetição para o AWS SDK para Python (Boto3), consulte [Configurando um modo de repetição](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#configuring-a-retry-mode). O código a seguir mostra um exemplo que configura a estratégia de repetição para repetir as chamadas `invoke_endpoint` por até 180 segundos.
```
import boto3
from botocore.config import Config
# This example retry strategy sets the retry attempts to 2.
# With this setting, the request can attempt to download and/or load the model
# for upto 180 seconds: 1 orginal request (60 seconds) + 2 retries (120 seconds)
config = Config(
read_timeout=70,
retries={
'max_attempts': 2 # This value can be adjusted to 5 to go up to the 360s max timeout
}
)
runtime_sagemaker_client = boto3.client('sagemaker-runtime', config=config)
```
# Adicionar ou remover modelos
Você pode implantar modelos adicionais em um endpoint multimodelo e invocá-los por meio desse endpoint imediatamente. Ao adicionar um novo modelo, você não precisará atualizar ou reduzir o endpoint, assim, evitará o custo de criar e executar um endpoint separado para cada novo modelo. O processo de adição e remoção de modelos é o mesmo para endpoints multimodelo compatíveis com CPU e GPU.
SageMaker A IA descarrega modelos não utilizados do contêiner quando a instância está atingindo a capacidade de memória e mais modelos precisam ser baixados no contêiner. SageMaker A IA também exclui artefatos de modelo não utilizados do volume de armazenamento da instância quando o volume está atingindo a capacidade máxima e novos modelos precisam ser baixados. A primeira invocação para um modelo recém-adicionado leva mais tempo porque o endpoint leva tempo para baixar o modelo do S3 para a memória do contêiner na instância que hospeda o endpoint
Com o endpoint já em execução, copie um novo conjunto de artefatos de modelo para o local do Amazon S3 em que você armazena seus modelos.
```
# Add an AdditionalModel to the endpoint and exercise it
aws s3 cp AdditionalModel.tar.gz s3://amzn-s3-demo-bucket/path/to/artifacts/
```
**Importante**
Para atualizar um modelo, proceda como faria ao adicionar um novo modelo. Use um nome novo e exclusivo. Não substitua artefatos de modelo no Amazon S3 porque a versão antiga do modelo ainda pode estar carregada nos contêineres ou no volume de armazenamento das instâncias no endpoint. As invocações para o novo modelo poderiam, assim, invocar a versão antiga do modelo.
As aplicações cliente podem solicitar predições de modelo de destino adicional assim que forem armazenados no S3.
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName='',
ContentType='text/csv',
TargetModel='AdditionalModel.tar.gz',
Body=body)
```
Para excluir um modelo de um endpoint multimodelo, pare de invocar o modelo dos clientes e remova-o do local do S3 em que os artefatos de modelo são armazenados.
# Crie seu próprio contêiner para endpoints multimodelo de SageMaker IA
Consulte as seções a seguir para trazer seu próprio contêiner e dependências para endpoints multimodelo.
**Topics**
+ [Traga suas próprias dependências para endpoints multimodelo em instâncias com compatibilidade com CPU](#build-multi-model-container-cpu)
+ [Traga suas próprias dependências para endpoints multimodelo em instâncias compatíveis com GPU](#build-multi-model-container-gpu)
+ [Use o kit de ferramentas de inferência de SageMaker IA](#multi-model-inference-toolkit)
+ [Contrato para contêineres personalizados para endpoints multimodelo](mms-container-apis.md)
## Traga suas próprias dependências para endpoints multimodelo em instâncias com compatibilidade com CPU
Se nenhuma das imagens de contêiner pré-criadas atender às suas necessidades, você poderá criar seu próprio contêiner para uso com endpoints multimodelo com compatibilidade com CPU.
Espera-se que as imagens personalizadas do Amazon Elastic Container Registry (Amazon ECR) implantadas no SageMaker Amazon AI sigam o contrato básico [Código de inferência personalizado com serviços de host](your-algorithms-inference-code.md) descrito em que SageMaker rege como a IA interage com um contêiner Docker que executa seu próprio código de inferência. Para que um contêiner seja capaz de carregar e servir vários modelos simultaneamente, há outros APIs comportamentos que devem ser seguidos. Esse contrato adicional inclui novos modelos APIs para carregar, listar, obter e descarregar, além de uma API diferente para invocar modelos. Também há comportamentos diferentes para cenários de erro que APIs você precisa seguir. Para indicar que o contêiner está em conformidade com os requisitos adicionais, você pode adicionar o seguinte comando ao arquivo do Docker:
```
LABEL com.amazonaws.sagemaker.capabilities.multi-models=true
```
SageMaker A IA também injeta uma variável de ambiente no contêiner
```
SAGEMAKER_MULTI_MODEL=true
```
Se você estiver criando um endpoint multimodelo para uma linha de pipeline de inferência serial, seu arquivo Docker deverá ter os rótulos necessários tanto para pipelines de inferência serial quanto para pipelines de vários modelos. Para mais informações sobre pipelines de informações seriais, consulte [Executar predições em tempo real com um pipeline de inferência](inference-pipeline-real-time.md).
Para ajudá-lo a implementar esses requisitos para um contêiner personalizado, duas bibliotecas estão disponíveis:
+ O [Multi Model Server](https://github.com/awslabs/multi-model-server) é uma estrutura de código aberto para servir modelos de aprendizado de máquina que podem ser instalados em contêineres para fornecer o front-end que atenda aos requisitos do novo contêiner de endpoint multimodelo. APIs Ela fornece os recursos de gerenciamento de modelos e o front-end HTTP exigidos pelos endpoints multimodelo para hospedar vários modelos em um único contêiner, carregar modelos e descarregar modelos para dentro e fora do contêiner dinamicamente, e executa a inferência em um modelo carregado especificado. Ela também fornece um backend conectável compatível com um manipulador de backend conectável personalizado em que você pode implementar seu próprio algoritmo.
+ SageMaker O [AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) é uma biblioteca que inicializa o Multi Model Server com uma configuração e configurações que o tornam compatível com endpoints multimodelo de IA. SageMaker Ela também permite ajustar parâmetros de desempenho importantes, como o número de operadores por modelo, dependendo das necessidades do seu cenário.
## Traga suas próprias dependências para endpoints multimodelo em instâncias compatíveis com GPU
Atualmente, o recurso Bring Your Own Container (BYOC) em endpoints multimodelo com instâncias apoiadas por GPU não é suportado pelas bibliotecas Multi Model Server e SageMaker AI Inference Toolkit.
[Para criar endpoints de vários modelos com instâncias apoiadas por GPU, você pode usar o NVIDIA Triton Inference [Server compatível com SageMaker IA. Com os contêineres de inferência NVIDIA Triton](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html).](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only) Para trazer suas próprias dependências, você pode criar seu próprio contêiner com o [NVIDIA Triton Inference Server](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) compatível com SageMaker IA como imagem base para seu arquivo Docker:
```
FROM 301217895009.dkr.ecr.us-west-2.amazonaws.com/sagemaker-tritonserver:22.07-py3
```
**Importante**
Os contêineres com o Triton Inference Server são os únicos contêineres compatíveis que você pode usar para endpoints multimodelo com compatibilidade com GPU.
## Use o kit de ferramentas de inferência de SageMaker IA
**nota**
O kit de ferramentas de inferência de SageMaker IA só é compatível com endpoints multimodelo suportados por CPU. Atualmente, o SageMaker AI Inference Toolkit não é compatível com endpoints multimodelo suportados por GPU.
Contêineres pré-construídos que oferecem apoio a endpoints multimodelo estão listados em [Algoritmos, frameworks e instâncias compatíveis para endpoints multimodelo](multi-model-support.md). Se você quiser usar qualquer outra estrutura de trabalho ou algoritmo, será necessário criar um contêiner. A maneira mais fácil de fazer isso é usar o [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) para estender um contêiner pré-construído existente. O kit de ferramentas de inferência de SageMaker IA é uma implementação para o servidor multimodelo (MMS) que cria endpoints que podem ser implantados na IA. SageMaker Para ver um exemplo de notebook que mostra como configurar e implantar um contêiner personalizado que oferece suporte a endpoints multimodelo em SageMaker IA, consulte o Notebook de amostra BYOC de [endpoint multimodelo](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_bring_your_own).
**nota**
O kit de ferramentas de inferência de SageMaker IA é compatível somente com manipuladores de modelos Python. Se você quiser implementar seu manipulador em qualquer outra linguagem, deverá criar seu próprio contêiner que implemente o endpoint multimodelo adicional. APIs Para mais informações, consulte [Contrato para contêineres personalizados para endpoints multimodelo](mms-container-apis.md).
**Para estender um contêiner usando o kit de ferramentas de inferência de SageMaker IA**
1. Crie um manipulador de modelo. O MMS espera um manipulador de modelo, que é um arquivo Python que implementa funções para pré-processar, obter predições de modelo e processar a saída em um manipulador de modelo. Para obter um exemplo de um manipulador de modelo, consulte [model\$1handler.py](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/model_handler.py) no caderno de exemplo.
1. Importe o toolkit de inferência e use sua função `model_server.start_model_server` para iniciar o MMS. O exemplo a seguir é do arquivo `dockerd-entrypoint.py` do caderno de exemplo. Observe que a chamada para `model_server.start_model_server` transmite o manipulador de modelo descrito na etapa anterior:
```
import subprocess
import sys
import shlex
import os
from retrying import retry
from subprocess import CalledProcessError
from sagemaker_inference import model_server
def _retry_if_error(exception):
return isinstance(exception, CalledProcessError or OSError)
@retry(stop_max_delay=1000 * 50,
retry_on_exception=_retry_if_error)
def _start_mms():
# by default the number of workers per model is 1, but we can configure it through the
# environment variable below if desired.
# os.environ['SAGEMAKER_MODEL_SERVER_WORKERS'] = '2'
model_server.start_model_server(handler_service='/home/model-server/model_handler.py:handle')
def main():
if sys.argv[1] == 'serve':
_start_mms()
else:
subprocess.check_call(shlex.split(' '.join(sys.argv[1:])))
# prevent docker exit
subprocess.call(['tail', '-f', '/dev/null'])
main()
```
1. No `Dockerfile`, copie o manipulador de modelo da primeira etapa e especifique o arquivo Python da etapa anterior como o ponto de entrada no `Dockerfile`. As linhas a seguir são do [Dockerfile](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/Dockerfile) usado no caderno de exemplo:
```
# Copy the default custom service file to handle incoming data and inference requests
COPY model_handler.py /home/model-server/model_handler.py
# Define an entrypoint script for the docker image
ENTRYPOINT ["python", "/usr/local/bin/dockerd-entrypoint.py"]
```
1. Crie e registre o contêiner. O seguinte script de shell do caderno de exemplo constrói o contêiner e o carrega em um repositório do Registro de Contêiner Elástico da Amazon (Amazon ECR) na sua conta AWS :
```
%%sh
# The name of our algorithm
algorithm_name=demo-sagemaker-multimodel
cd container
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
$(aws ecr get-login --region ${region} --no-include-email)
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -q -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
Agora você pode usar esse contêiner para implantar endpoints de vários modelos na SageMaker IA.
**Topics**
+ [Traga suas próprias dependências para endpoints multimodelo em instâncias com compatibilidade com CPU](#build-multi-model-container-cpu)
+ [Traga suas próprias dependências para endpoints multimodelo em instâncias compatíveis com GPU](#build-multi-model-container-gpu)
+ [Use o kit de ferramentas de inferência de SageMaker IA](#multi-model-inference-toolkit)
+ [Contrato para contêineres personalizados para endpoints multimodelo](mms-container-apis.md)
# Contrato para contêineres personalizados para endpoints multimodelo
Para lidar com vários modelos, seu contêiner deve suportar um conjunto APIs que permita que a Amazon SageMaker AI se comunique com o contêiner para carregar, listar, obter e descarregar modelos conforme necessário. O `model_name` é usado no novo conjunto de APIs como o principal parâmetro de entrada. Espera-se que o contêiner do cliente acompanhe os modelos carregados usando `model_name` como chave de mapeamento. Além disso, o `model_name` é um identificador opaco e não é necessariamente o valor do parâmetro `TargetModel` passado para a API `InvokeEndpoint`. O `TargetModel` valor original na `InvokeEndpoint` solicitação é passado para o contêiner APIs como um `X-Amzn-SageMaker-Target-Model` cabeçalho que pode ser usado para fins de registro.
**nota**
Atualmente, endpoints de vários modelos para instâncias com suporte de GPU são compatíveis somente com o contêiner [NVIDIA Triton Inference Server](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) da SageMaker AI. Esse contêiner já implementa o contrato definido abaixo. Os clientes podem usar esse contêiner diretamente com seus endpoints de GPU multimodelo, sem nenhum trabalho adicional.
Você pode configurar o seguinte APIs em seus contêineres para endpoints multimodelo suportados por CPU.
**Topics**
+ [API para carregar modelo](#multi-model-api-load-model)
+ [API para listar modelo](#multi-model-api-list-model)
+ [API para obter modelo](#multi-model-api-get-model)
+ [API para descarregar modelo](#multi-model-api-unload-model)
+ [API para invocar modelo](#multi-model-api-invoke-model)
## API para carregar modelo
Instrui o contêiner a carregar um modelo específico presente no campo `url` do corpo na memória do contêiner do cliente e a manter o controle dele com o `model_name` atribuído. Depois que um modelo é carregado, o contêiner deve estar pronto para atender a solicitações de inferência usando esse `model_name`.
```
POST /models HTTP/1.1
Content-Type: application/json
Accept: application/json
{
"model_name" : "{model_name}",
"url" : "/opt/ml/models/{model_name}/model",
}
```
**nota**
Se `model_name` já estiver carregado, a API deverá retornar 409. Sempre que um modelo não puder ser carregado devido à falta de memória ou a qualquer outro recurso, essa API deve retornar um código de status HTTP 507 para a SageMaker IA, que então inicia o descarregamento de modelos não utilizados para recuperação.
## API para listar modelo
Retorna a lista de modelos carregados na memória do contêiner do cliente.
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
Essa API também oferece apoio à paginação.
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
SageMaker Inicialmente, a IA pode chamar a API List Models sem fornecer um valor para`next_page_token`. Se um campo `nextPageToken` for retornado como parte da resposta, ele será fornecido como o valor para `next_page_token` em uma chamada subsequente da List Models. Se um `nextPageToken` não for retornado, significa que não há mais modelos para retornar.
## API para obter modelo
Essa é uma API de leitura simples na entidade `model_name`.
```
GET /models/{model_name} HTTP/1.1
Accept: application/json
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
}
```
**nota**
Se `model_name` não estiver carregado, a API retornará 404.
## API para descarregar modelo
Instrui a plataforma de SageMaker IA a instruir o contêiner do cliente a descarregar um modelo da memória. Isso inicia a remoção de um modelo candidato conforme determinado pela plataforma ao iniciar o processo de carregamento de um novo modelo. Os recursos provisionados em `model_name` deverão ser recuperados pelo contêiner quando essa API retornar uma resposta.
```
DELETE /models/{model_name}
```
**nota**
Se `model_name` não estiver carregado, a API retornará 404.
## API para invocar modelo
Faz uma solicitação de predição do `model_name` específico fornecido. A `InvokeEndpoint` solicitação do SageMaker AI Runtime é compatível `X-Amzn-SageMaker-Target-Model` com um novo cabeçalho que segue o caminho relativo do modelo especificado para invocação. O sistema de SageMaker IA constrói o caminho absoluto do modelo combinando o prefixo fornecido como parte da chamada da `CreateModel` API com o caminho relativo do modelo.
```
POST /models/{model_name}/invoke HTTP/1.1
Content-Type: ContentType
Accept: Accept
X-Amzn-SageMaker-Custom-Attributes: CustomAttributes
X-Amzn-SageMaker-Target-Model: [relativePath]/{artifactName}.tar.gz
```
**nota**
Se `model_name` não estiver carregado, a API retornará 404.
Além disso, em instâncias de GPU, se `InvokeEndpoint` falhar devido à falta de memória ou de outros recursos, essa API deve retornar um código de status HTTP 507 para a SageMaker IA, que então inicia o descarregamento de modelos não utilizados para recuperação.
# Segurança de endpoint multimodelo
Os modelos e os dados em um endpoint multimodelo são colocalizados no volume de armazenamento da instância e na memória do contêiner. Todas as instâncias dos endpoints Amazon SageMaker AI são executadas em um único contêiner de locatário que você possui. Somente os seus modelos podem ser executados no seu endpoint multimodelo. É sua responsabilidade gerenciar o mapeamento das solicitações para os modelos e fornecer acesso aos usuários aos modelos de destino corretos. SageMaker A IA usa [funções do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) para fornecer políticas baseadas em identidade do IAM que você usa para especificar ações e recursos permitidos ou negados e as condições sob as quais as ações são permitidas ou negadas.
Por padrão, uma entidade do IAM com permissões [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) em um endpoint multimodelo pode invocar qualquer modelo no endereço do prefixo S3 definido na operação [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), desde que a função de execução do IAM definida na operação tenha permissões para fazer download do modelo. Se você precisar restringir o acesso do [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) a um conjunto limitado de modelos no S3, execute um dos seguintes procedimentos:
+ Restringir as chamadas `InvokeEndpont` a modelos específicos hospedados no endpoint usando a chave de condição do IAM `sagemaker:TargetModel`. Por exemplo, a política a seguir permite solicitações `InvokeEndpont` somente quando o valor do campo `TargetModel` corresponde a uma das expressões regulares especificadas:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource":
"arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": ["company_a/*", "common/*"]
}
}
}
]
}
```
------
Para obter informações sobre chaves de condição de SageMaker IA, consulte [Chaves de condição para Amazon SageMaker AI](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys) no *Guia AWS Identity and Access Management do usuário*.
+ Crie endpoints multimodelo com prefixos do S3 mais restritivos.
Para obter mais informações sobre como a SageMaker IA usa funções para gerenciar o acesso aos endpoints e realizar operações em seu nome, consulte[Como usar funções de execução de SageMaker IA](sagemaker-roles.md). Seus clientes também podem ter determinados requisitos de isolamento de dados ditados por suas próprias exigências de conformidade, que podem ser atendidos usando identidades do IAM.
# CloudWatch Métricas para implantações de endpoints de vários modelos
A Amazon SageMaker AI fornece métricas para endpoints para que você possa monitorar a taxa de acerto do cache, o número de modelos carregados e os tempos de espera do modelo para carregamento, download e upload em um endpoint multimodelo. Algumas das métricas são diferentes para endpoints multimodelo suportados por CPU e GPU, então as seções a seguir descrevem as CloudWatch métricas da Amazon que você pode usar para cada tipo de endpoint multimodelo.
Para obter mais informações sobre métricas, consulte **Métricas de carregamento do modelo para endpoint multimodelo** e **Métricas de instâncias de modelos para endpoint multimodelo** em [Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md). Métricas por modelo não são compatíveis.
## CloudWatch métricas para endpoints multimodelo suportados por CPU
Você pode monitorar as seguintes métricas em endpoints multimodelo com compatibilidade com CPU:
O `AWS/SageMaker` namespace inclui as seguintes métricas de carregamento do modelo a partir de chamadas para. [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)
As métricas estão disponíveis a uma frequência de 1 minuto.
Para obter informações sobre por quanto tempo as CloudWatch métricas são retidas, consulte [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)a *Amazon CloudWatch API Reference*.
**Métricas de carregamento de modelos de endpoint multimodelo**
| Métrica | Description |
| --- | --- |
| ModelLoadingWaitTime | O intervalo de tempo em que uma solicitação de invocação esperou que o modelo de destino fosse baixado, carregado, ou os dois, para realizar a inferência. Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelUnloadingTime | O intervalo de tempo necessário para descarregar o modelo por meio da chamada de API `UnloadModel` do contêiner. Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelDownloadingTime | O intervalo de tempo necessário para baixar o modelo do Amazon Simple Storage Service (Amazon S3). Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelLoadingTime | O intervalo de tempo necessário para carregar o modelo com a chamada de API `LoadModel` do contêiner. Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelCacheHit | O número de solicitações `InvokeEndpoint` enviadas para o endpoint multimodelo para o qual o modelo já foi carregado. A estatística Média mostra a proporção de solicitações para as quais o modelo já foi carregado. Unidades: nenhuma Estatísticas válidas: média, soma, contagem de amostras |
**Dimensões para métricas de carregamento de modelos de endpoint multimodelo**
| Dimensão | Description |
| --- | --- |
| EndpointName, VariantName | Filtra as métricas de invocação de endpoint para uma `ProductionVariant` do endpoint e da variante especificados. |
Os namespaces `/aws/sagemaker/Endpoints` incluem as seguintes métricas de instância em chamadas para [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html).
As métricas estão disponíveis a uma frequência de 1 minuto.
Para obter informações sobre por quanto tempo as CloudWatch métricas são retidas, consulte [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)a *Amazon CloudWatch API Reference*.
**Métricas de instâncias de modelos para endpoint multimodelo**
| Métrica | Description |
| --- | --- |
| LoadedModelCount | O número de modelos carregados nos contêineres do endpoint multimodelo. Esta métrica é emitida para cada instância. A estatística Média com um período de 1 minuto informa o número médio de modelos carregados por instância. A estatística Soma informa o número total de modelos carregados em todas as instâncias no endpoint. Os modelos que essa métrica rastreia não são necessariamente exclusivos, porque um modelo pode ser carregado em vários contêineres no endpoint. Unidades: nenhuma Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| CPUUtilization | A soma da utilização de cada núcleo de CPU individual. A utilização da CPU de cada faixa de núcleo é de 0 a 100. Por exemplo, se houver quatro CPUs, o `CPUUtilization` intervalo é de 0% a 400%. Para variantes de endpoint, o valor é a soma da utilização de CPU dos contêineres principais e complementares na instância. Unidades: percentual |
| MemoryUtilization | O percentual de memória usada pelos contêineres em uma instância. Esse intervalo de valores é de 0% a 100%. Para variantes de endpoint, o valor é a soma da utilização de memória dos contêineres principais e complementares na instância. Unidades: percentual |
| DiskUtilization | A porcentagem de espaço em disco usada pelos contêineres em uma instância. Esse intervalo de valores é de 0% a 100%. Para variantes de endpoint, o valor é a soma da utilização do espaço em disco dos contêineres primário e complementar na instância. Unidades: percentual |
## CloudWatch métricas para implantações de endpoints multimodelo de GPU
Você pode monitorar as seguintes métricas em endpoints multimodelo com compatibilidade com GPU:
O `AWS/SageMaker` namespace inclui as seguintes métricas de carregamento do modelo a partir de chamadas para. [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html)
As métricas estão disponíveis a uma frequência de 1 minuto.
Para obter informações sobre por quanto tempo as CloudWatch métricas são retidas, consulte [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)a *Amazon CloudWatch API Reference*.
**Métricas de carregamento de modelos de endpoint multimodelo**
| Métrica | Description |
| --- | --- |
| ModelLoadingWaitTime | O intervalo de tempo em que uma solicitação de invocação esperou que o modelo de destino fosse baixado, carregado, ou os dois, para realizar a inferência. Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelUnloadingTime | O intervalo de tempo necessário para descarregar o modelo por meio da chamada de API `UnloadModel` do contêiner. Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelDownloadingTime | O intervalo de tempo necessário para baixar o modelo do Amazon Simple Storage Service (Amazon S3). Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelLoadingTime | O intervalo de tempo necessário para carregar o modelo com a chamada de API `LoadModel` do contêiner. Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| ModelCacheHit | O número de solicitações `InvokeEndpoint` enviadas para o endpoint multimodelo para o qual o modelo já foi carregado. A estatística Média mostra a proporção de solicitações para as quais o modelo já foi carregado. Unidades: nenhuma Estatísticas válidas: média, soma, contagem de amostras |
**Dimensões para métricas de carregamento de modelos de endpoint multimodelo**
| Dimensão | Description |
| --- | --- |
| EndpointName, VariantName | Filtra as métricas de invocação de endpoint para uma `ProductionVariant` do endpoint e da variante especificados. |
Os namespaces `/aws/sagemaker/Endpoints` incluem as seguintes métricas de instância em chamadas para [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html).
As métricas estão disponíveis a uma frequência de 1 minuto.
Para obter informações sobre por quanto tempo as CloudWatch métricas são retidas, consulte [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)a *Amazon CloudWatch API Reference*.
**Métricas de instâncias de modelos para endpoint multimodelo**
| Métrica | Description |
| --- | --- |
| LoadedModelCount | O número de modelos carregados nos contêineres do endpoint multimodelo. Esta métrica é emitida para cada instância. A estatística Média com um período de 1 minuto informa o número médio de modelos carregados por instância. A estatística Soma informa o número total de modelos carregados em todas as instâncias no endpoint. Os modelos que essa métrica rastreia não são necessariamente exclusivos, porque um modelo pode ser carregado em vários contêineres no endpoint. Unidades: nenhuma Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| CPUUtilization | A soma da utilização de cada núcleo de CPU individual. A utilização da CPU de cada faixa de núcleo é de 0 a 100. Por exemplo, se houver quatro CPUs, o `CPUUtilization` intervalo é de 0% a 400%. Para variantes de endpoint, o valor é a soma da utilização de CPU dos contêineres principais e complementares na instância. Unidades: percentual |
| MemoryUtilization | O percentual de memória usada pelos contêineres em uma instância. Esse intervalo de valores é de 0% a 100%. Para variantes de endpoint, o valor é a soma da utilização de memória dos contêineres principais e complementares na instância. Unidades: percentual |
| GPUUtilization | O percentual de unidades de GPU usadas pelos contêineres em uma instância. O valor pode variar entre o intervalo de 0 a 100 e é multiplicado pelo número de. GPUs Por exemplo, se houver quatro GPUs, o `GPUUtilization` intervalo é de 0% a 400%. Para variantes de endpoint, o valor é a soma da utilização de GPU dos contêineres principais e complementares na instância. Unidades: percentual |
| GPUMemoryUtilization | O percentual de memória de GPU usada pelos contêineres em uma instância. O intervalo de valores é de 0 a 100 e é multiplicado pelo número de. GPUs Por exemplo, se houver quatro GPUs, o `GPUMemoryUtilization` intervalo será de 0% a 400%. Para variantes de endpoint, o valor é a soma da utilização de memória de GPU dos contêineres principais e complementares na instância. Unidades: percentual |
| DiskUtilization | A porcentagem de espaço em disco usada pelos contêineres em uma instância. Esse intervalo de valores é de 0% a 100%. Para variantes de endpoint, o valor é a soma da utilização do espaço em disco dos contêineres primário e complementar na instância. Unidades: percentual |
# Defina o SageMaker comportamento de cache do modelo de endpoint multimodelo de IA
Por padrão, os endpoints multimodelo armazenam em cache os modelos usados com frequência na memória (CPU ou GPU, dependendo se você tem instâncias baseadas em CPU ou GPU) e no disco para fornecer inferência de baixa latência. Os modelos em cache são descarregados e and/or excluídos do disco somente quando um contêiner fica sem memória ou espaço em disco para acomodar um modelo recém-direcionado.
Você pode alterar o comportamento do armazenamento em cache de um endpoint multimodelo e habilitar ou desabilitar explicitamente o cache do modelo definindo o parâmetro `ModelCacheSetting` ao chamar [create\$1model.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)
Recomendamos definir o valor do parâmetro `ModelCacheSetting` em `Disabled` para casos de uso que não se beneficiam do armazenamento em cache do modelo. Por exemplo, quando um grande número de modelos precisa ser servido a partir do endpoint, mas cada modelo é invocado apenas uma vez (ou com pouca frequência). Para esses casos de uso, definir o valor do parâmetro `ModelCacheSetting` em `Disabled` para permitir maiores transações por segundo (TPS) para `invoke_endpoint` solicitações em comparação com o modo de cache padrão. O TPS mais alto nesses casos de uso ocorre porque a SageMaker IA faz o seguinte após a `invoke_endpoint` solicitação:
+ Descarrega assincronamente o modelo da memória e o exclui do disco imediatamente após ser invocado.
+ Fornece maior simultaneidade para baixar e carregar modelos no contêiner de inferência. Para endpoints com suporte de CPU e GPU, a simultaneidade é um fator do número de v da instância CPUs do contêiner.
Para obter diretrizes sobre como escolher um tipo de instância de SageMaker AI ML para um endpoint multimodelo, consulte. [Recomendações de instâncias para implantações de endpoint multimodelo](multi-model-endpoint-instance.md)
# Defina políticas de ajuste de escala automático para implantações de endpoints multimodelo
SageMaker Os endpoints multimodelo de IA oferecem suporte total ao escalonamento automático, que gerencia réplicas de modelos para garantir que os modelos sejam dimensionados com base nos padrões de tráfego. Recomendamos que você configure seu endpoint multimodelo e o tamanho de suas instâncias com base em [Recomendações de instâncias para implantações de endpoint multimodelo](multi-model-endpoint-instance.md) e também configure o ajuste de escala automático baseada em instâncias para o seu endpoint. As taxas de invocação utilizadas para acionar um evento de ajuste de escala automático são baseadas no conjunto agregado de predições em todo o conjunto de modelos servidos pelo endpoint. Para obter detalhes adicionais sobre a configuração do escalonamento automático de endpoints, consulte Dimensionar [automaticamente os modelos de SageMaker IA da Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html).
Você pode configurar políticas de ajuste de escala automático com métricas predefinidas e personalizadas em endpoints multimodelo com compatibilidade com CPU e GPU.
**nota**
SageMaker As métricas de endpoint multimodelo de IA estão disponíveis com granularidade de um minuto.
## Definir uma política de escalabilidade
Para especificar as métricas e os valores de destino de uma política de escalabilidade, você pode configurar uma política de escalabilidade de rastreamento de destino. É possível usar uma métrica predefinida ou personalizada.
A configuração da política de escalabilidade é representada por um bloco JSON. A configuração é salva como um bloco JSON em um arquivo de texto. Você usa esse arquivo de texto ao invocar a AWS CLI ou a API Application Auto Scaling. Para ter mais informações sobre a sintaxe de configuração de política, consulte `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` na *Referência da API do Application Auto Scaling*.
As seguintes opções estão disponíveis para definir uma configuração de política de ajuste de escala de rastreamento de destino:
### Usar uma métrica predefinida
Para definir rapidamente uma política de escalabilidade de rastreamento de destino para uma variante, use a métrica predefinida `SageMakerVariantInvocationsPerInstance`. `SageMakerVariantInvocationsPerInstance` é o número médio de vezes por minuto que cada instância de uma variante é chamada. O uso dessa métrica é altamente recomendável.
Para usar uma métrica predefinida em uma política de escalabilidade, crie uma configuração de rastreamento de destino para a sua política. A configuração rastreamento de destino deve incluir uma `PredefinedMetricSpecification` para a métrica predefinida e um `TargetValue` para o valor de destino da métrica.
O exemplo a seguir descreve uma típica configuração de política de escalabilidade de rastreamento de destino para uma variante. Nesta configuração, usamos a métrica predefinida `SageMakerVariantInvocationsPerInstance` para ajustar o número de instâncias de variante de modo que cada instância tenha uma métrica `InvocationsPerInstance` de `70`.
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "InvocationsPerInstance"
}
}
```
**nota**
Recomendamos que você use `InvocationsPerInstance` ao usar endpoints multimodelo. O `TargetValue` dessa métrica depende dos requisitos de latência da sua aplicação. Também recomendamos que você realize testes de carga em seus endpoints para configurar valores adequados para os parâmetros de escabilidade. Para saber mais sobre o teste de carga e a configuração do escalonamento automático para seus endpoints, consulte o blog [Como configurar endpoints de inferência de escalonamento automático](https://aws.amazon.com/blogs/machine-learning/configuring-autoscaling-inference-endpoints-in-amazon-sagemaker/) na Amazon AI. SageMaker
### Usar uma métrica personalizada
Caso precise definir uma política de escalabilidade de rastreamento de destino que atenda às suas exigências específicas, defina uma métrica personalizada. Você pode definir uma métrica personalizada com base em qualquer métrica de variante de produção que mude em proporção de escalabilidade.
Nem todas as métricas de SageMaker IA funcionam para o rastreamento de alvos. A métrica deve ser de utilização válida e descrever o quão ocupada uma instância está. O valor da métrica deve aumentar ou diminuir em proporção inversa ao número das instâncias de variante. Ou seja, o valor da métrica deve diminuir quando o número de instâncias aumenta.
**Importante**
Antes de colocar o ajuste de escala automático em produção, você deve testá-lo com a métrica personalizada.
#### Exemplo de métrica personalizada para um endpoint multimodelo com compatibilidade com CPU
O exemplo a seguir descreve uma configuração de rastreamento de destino para uma política de escalabilidade. Nessa configuração, para um modelo chamado `my-model`, uma métrica personalizada de `CPUUtilization` ajusta a contagem de instâncias no endpoint com base em uma utilização média da CPU de 50% em todas as instâncias.
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
#### Exemplo de métrica personalizada para um endpoint multimodelo com compatibilidade com GPU
O exemplo a seguir descreve uma configuração de rastreamento de destino para uma política de escalabilidade. Nessa configuração, para um modelo chamado `my-model`, uma métrica personalizada de `GPUUtilization` ajusta a contagem de instâncias no endpoint com base em uma utilização média da GPU de 50% em todas as instâncias.
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "GPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
## Adicionar um período de espera
Para adicionar um período de espera para aumentar a escala horizontalmente do seu endpoint, especifique um valor, em segundos, para `ScaleOutCooldown`. Da mesma forma, para adicionar um período de espera para a redução de escala em seu modelo, insira um valor, em segundos, para `ScaleInCooldown`. Para ter mais informações sobre `ScaleInCooldown` e `ScaleOutCooldown`, consulte `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` na *Referência da API do Application Auto Scaling*.
O exemplo a seguir é um exemplo de configuração de rastreamento de destino para uma política de escalabilidade. Nesta configuração, a métrica predefinida `SageMakerVariantInvocationsPerInstance` é usada para ajustar a escalabilidade com base em uma média de `70` em todas as instâncias dessa variante. A configuração fornece um período de espera de 10 minutos para reduzir a escala horizontalmente, e um período de espera de 5 minutos para aumentar a escala horizontalmente.
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
# Endpoint com vários contêineres
SageMaker Os endpoints de IA de vários contêineres permitem que os clientes implantem vários contêineres, que usam modelos ou estruturas diferentes, em um único SageMaker endpoint de IA. Os contêineres podem ser executados em uma sequência como um pipeline de inferência, ou cada contêiner pode ser acessado individualmente usando invocação direta para melhorar a utilização do endpoint e otimizar os custos.
Para obter informações sobre como invocar os contêineres em um endpoint de vários contêineres em sequência, consulte [Pipelines de inferência na Amazon AI SageMaker](inference-pipelines.md).
Para obter informações sobre como invocar o contêiner específico em um endpoint de vários contêineres em sequência, consulte [Invoque um endpoint de vários contêineres com invocação direta](multi-container-direct.md)
**Topics**
+ [Criar um endpoint de vários contêineres (Boto 3)](multi-container-create.md)
+ [Atualizar um endpoint de vários contêineres](multi-container-update.md)
+ [Invoque um endpoint de vários contêineres com invocação direta](multi-container-direct.md)
+ [Segurança com um endpoint de vários contêineres com invocação direta](multi-container-security.md)
+ [Métricas para endpoints de vários contêineres com invocação direta](multi-container-metrics.md)
+ [Ajuste de escala automático de endpoints com vários contêineres](multi-container-auto-scaling.md)
+ [Solucionar problemas de endpoints de vários contêineres](multi-container-troubleshooting.md)
# Criar um endpoint de vários contêineres (Boto 3)
Crie um endpoint de vários contêineres chamando [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html), e [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) APIs como você faria para criar qualquer outro endpoint. Você pode executar esses contêineres sequencialmente como um pipeline de inferência ou executar cada contêiner individual usando invocação direta. Os endpoints de vários contêineres têm os seguintes requisitos quando você chama `create_model`:
+ Use o parâmetro `Containers` em vez de `PrimaryContainer` e inclua mais de um contêiner no parâmetro `Containers`.
+ O parâmetro `ContainerHostname` é necessário para cada contêiner em um endpoint de vários contêineres com invocação direta.
+ Defina o parâmetro `Mode` do campo `InferenceExecutionConfig` para `Direct` para invocação direta de cada contêiner ou `Serial` para usar contêineres como um pipeline de inferência. O modo padrão é `Serial`.
**nota**
Atualmente, há um limite de até 15 contêineres compatíveis em um endpoint de vários contêineres.
O exemplo a seguir cria um modelo de vários contêineres para invocação direta.
1. Crie elementos de contêiner e `InferenceExecutionConfig` com invocação direta.
```
container1 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage1:mytag',
'ContainerHostname': 'firstContainer'
}
container2 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage2:mytag',
'ContainerHostname': 'secondContainer'
}
inferenceExecutionConfig = {'Mode': 'Direct'}
```
1. Crie o modelo com os elementos do contêiner e defina o campo `InferenceExecutionConfig`.
```
import boto3
sm_client = boto3.Session().client('sagemaker')
response = sm_client.create_model(
ModelName = 'my-direct-mode-model-name',
InferenceExecutionConfig = inferenceExecutionConfig,
ExecutionRoleArn = role,
Containers = [container1, container2]
)
```
Para criar um endpoint, você chamaria [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) e [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) da mesma forma que faria para criar qualquer outro endpoint.
# Atualizar um endpoint de vários contêineres
Para atualizar um endpoint de vários contêineres do Amazon SageMaker AI, conclua as etapas a seguir.
1. Chame [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) para criar um novo modelo com um novo valor para o parâmetro `Mode` no campo `InferenceExecutionConfig`.
1. Chame [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) para criar uma nova configuração de endpoint com um nome diferente usando o novo modelo que você criou na etapa anterior.
1. Chame [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_endpoint) para atualizar o endpoint com a nova configuração de endpoint que você criou na etapa anterior.
# Invoque um endpoint de vários contêineres com invocação direta
SageMaker Os endpoints de IA de vários contêineres permitem que os clientes implantem vários contêineres para implantar modelos diferentes em um endpoint de SageMaker IA. Você pode hospedar até 15 contêineres de inferência diferentes em um único endpoint. Quando usar a invocação direta, você pode enviar uma solicitação para um contêiner de inferência específico hospedado em um endpoint de vários contêineres.
Para invocar um endpoint de vários contêineres com invocação direta, chame [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) como você invocaria qualquer outro endpoint e especifique qual contêiner você deseja invocar usando o parâmetro `TargetContainerHostname`.
O exemplo a seguir invoca diretamente o `secondContainer` de um endpoint de vários contêineres para obter uma predição.
```
import boto3
runtime_sm_client = boto3.Session().client('sagemaker-runtime')
response = runtime_sm_client.invoke_endpoint(
EndpointName ='my-endpoint',
ContentType = 'text/csv',
TargetContainerHostname='secondContainer',
Body = body)
```
Para cada solicitação de invocação direta para um endpoint de vários contêineres, somente o contêiner com o `TargetContainerHostname` processa a solicitação de invocação. Você receberá erros de validação se fizer o seguinte:
+ Especifique um `TargetContainerHostname` que não exista no endpoint
+ Não especifique um valor para `TargetContainerHostname` em uma solicitação para um endpoint configurado para invocação direta
+ Especifique um valor para `TargetContainerHostname` em uma solicitação para um endpoint que não esteja configurado para invocação direta.
# Segurança com um endpoint de vários contêineres com invocação direta
Para endpoints de vários contêineres com invocação direta, há vários contêineres hospedados em uma única instância por meio do compartilhamento de memória e um volume de armazenamento. É sua responsabilidade usar contêineres seguros, manter o mapeamento correto das solicitações para os contêineres de destino e fornecer aos usuários o acesso correto aos contêineres de destino. SageMaker A IA usa funções do IAM para fornecer políticas baseadas em identidade do IAM que você usa para especificar se o acesso a um recurso é permitido ou negado a essa função e sob quais condições. Para obter informações sobre funções do IAM, consulte [Perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) no *AWS Identity and Access Management Manual do usuário*. Para obter informações sobre as políticas baseadas em identidade, consulte [Políticas baseadas em identidade e políticas baseadas em recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
Por padrão, um principal do IAM com permissões `InvokeEndpoint` em um endpoint de vários contêineres com invocação direta pode invocar qualquer contêiner dentro do endpoint com o nome do endpoint que você especifica ao chamar `invoke_endpoint`. Se você precisar restringir o acesso `invoke_endpoint` a um conjunto limitado de contêineres dentro de um endpoint de vários contêineres, use a chave de condição do IAM `sagemaker:TargetContainerHostname`. As políticas a seguir mostram como limitar as chamadas para contêineres específicos em um endpoint.
A política a seguir permite solicitações `invoke_endpoint` somente quando o valor do campo `TargetContainerHostname` corresponde a uma das expressões regulares especificadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"customIps*",
"common*"
]
}
}
}
]
}
```
------
A política a seguir nega solicitações `invoke_endpoint` somente quando o valor do campo `TargetContainerHostname` corresponde a uma das expressões regulares especificadas na declaração `Deny`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"model_name*"
]
}
}
},
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Deny",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"special-model_name*"
]
}
}
}
]
}
```
------
Para obter informações sobre chaves de condição de SageMaker IA, consulte [Chaves de condição para SageMaker IA](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys) no *Guia AWS Identity and Access Management do usuário*.
# Métricas para endpoints de vários contêineres com invocação direta
Além das métricas de endpoint listadas em[Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md), a SageMaker IA também fornece métricas por contêiner.
As métricas por contêiner para endpoints de vários contêineres com invocação direta estão localizadas CloudWatch e categorizadas em dois namespaces: e. `AWS/SageMaker` `aws/sagemaker/Endpoints` O `AWS/SageMaker` namespace inclui métricas relacionadas à invocação, e o namespace `aws/sagemaker/Endpoints` inclui métricas de utilização de memória e CPU.
A tabela a seguir lista as métricas por contêiner para endpoints de vários contêineres com invocação direta. Todas as métricas usam a dimensão [`EndpointName, VariantName, ContainerName`], que filtra as métricas em um endpoint específico, para uma variante específica e corresponde a um contêiner específico. Essas métricas compartilham os mesmos nomes das métricas dos pipelines de inferência, mas em um nível por contêiner [`EndpointName, VariantName, ContainerName`].
| | | | |
| --- |--- |--- |--- |
| Nome da métrica | Description | Dimensão | NameSpace |
| Invocations | O número de solicitações InvokeEndpoint enviadas para um contêiner dentro de um endpoint. Para obter o número total de solicitações enviadas para esse contêiner, use a estatística Sum. Unidades: nenhuma estatísticas válidas: Sum, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation4XX Errors | O número de solicitações InvokeEndpoint em que o modelo retornou um código de resposta HTTP 4xx para um contêiner específico. Para cada 4xx resposta, a SageMaker IA envia um1. Unidades: nenhuma estatísticas válidas: Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation5XX Errors | O número de solicitações InvokeEndpoint em que o modelo retornou um código de resposta HTTP 5xx para um contêiner específico. Para cada 5xx resposta, a SageMaker IA envia um1. Unidades: nenhuma estatísticas válidas: Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| ContainerLatency | O tempo necessário para que o contêiner de destino respondesse conforme visualizado pela SageMaker IA. ContainerLatencyinclui o tempo necessário para enviar a solicitação, buscar a resposta do contêiner do modelo e concluir a inferência no contêiner. Unidades: microssegundos estatísticas válidas: Average, Sum,Min, Max, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| OverheadLatency | O tempo adicionado ao tempo necessário para responder a uma solicitação de um cliente feita pela SageMaker IA para sobrecarga. OverheadLatencyé medido a partir do momento em que a SageMaker IA recebe a solicitação até retornar uma resposta ao cliente, menos o. ModelLatency A latência de sobrecarga pode variar dependendo de tamanhos de carga útil de solicitações e respostas, frequência de solicitações e autenticação ou autorização da solicitação, entre outros fatores. Unidades: microssegundos estatísticas válidas: Average, Sum, Min, Max, 'Contagem de amostras' | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| CPUUtilization | O percentual de unidades de CPU usadas por cada contêiner em execução em uma instância. O valor varia de 0% a 100% e é multiplicado pelo número de CPUs. Por exemplo, se houver quatro CPUs, CPUUtilization pode variar de 0% a 400%. Para endpoints com invocação direta, o número de CPUUtilization métricas é igual ao número de contêineres nesse endpoint. Unidades: percentual | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
| MemoryUtilizaton | O percentual de memória usada por cada contêiner em execução em uma instância. Esse valor varia de 0% a 100%. Da mesma forma que CPUUtilization, em endpoints com invocação direta, o número de MemoryUtilization métricas é igual ao número de contêineres nesse endpoint. Unidades: percentual | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
Todas as métricas na tabela anterior são específicas para endpoints de vários contêineres com invocação direta. Além dessas métricas especiais por contêiner, também há métricas no nível da variante com a dimensão `[EndpointName, VariantName]` de todas as métricas `ContainerLatency` esperadas na tabela.
# Ajuste de escala automático de endpoints com vários contêineres
Se você quiser configurar o ajuste de escala automático para um endpoint de vários contêineres usando a métrica `InvocationsPerInstance`, recomendamos que o modelo em cada contêiner exiba utilização e latência de CPU semelhantes em cada solicitação de inferência. Isso é recomendado porque, se o tráfego para o endpoint de vários contêineres mudar de um modelo de baixa utilização da CPU para um modelo de alta utilização da CPU, mas o volume geral de chamadas permanecer o mesmo, o endpoint não se expandirá e talvez não haja instâncias suficientes para lidar com todas as solicitações do modelo de alta utilização da CPU. Para obter informações sobre a endpoints de ajuste de escala automático, consulte [Escalabilidade automática dos modelos de SageMaker IA da Amazon](endpoint-auto-scaling.md).
# Solucionar problemas de endpoints de vários contêineres
As seções a seguir podem ajudar a solucionar erros em endpoints de vários contêineres.
## Erros do Ping Health Check
Com vários contêineres, a memória do endpoint e a CPU estão sob maior pressão durante a criação do endpoint. Especificamente, as métricas `MemoryUtilization` e `CPUUtilization` são mais altas do que as dos terminais de um único contêiner, porque a pressão de utilização é proporcional ao número de contêineres. Por isso, recomendamos que você escolha tipos de instância com memória e CPU suficientes para garantir que haja memória suficiente na instância para carregar todos os modelos (a mesma orientação se aplica à implantação de um pipeline de inferência). Caso contrário, a criação do endpoint poderá falhar com um erro como `XXX did not pass the ping health check`.
## Falta o accept-bind-to-port rótulo = verdadeiro do Docker
Os contêineres em endpoints de vários contêineres escutam na porta especificada na variável de ambiente `SAGEMAKER_BIND_TO_PORT` em vez da porta 8080. Quando um contêiner é executado em um endpoint de vários contêineres, a SageMaker IA fornece automaticamente essa variável de ambiente ao contêiner. Se essa variável de ambiente não estiver presente, os contêineres padrão usam a porta 8080. Para indicar que o contêiner está em conformidade com esse requisito, use o seguinte comando para adicionar um rótulo ao Dockerfile:
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
Caso contrário, você verá uma mensagem de erro como `Your Ecr Image XXX does not contain required com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true Docker label(s).`
Se o seu contêiner precisar escutar em uma segunda porta, escolha uma porta no intervalo especificado pela variável de ambiente `SAGEMAKER_SAFE_PORT_RANGE`. Especifique o valor como um intervalo inclusivo no formato *XXXX* -*YYYY*, onde XXXX e YYYY são números inteiros de vários dígitos. SageMaker A IA fornece esse valor automaticamente quando você executa o contêiner em um endpoint de vários contêineres.
# Pipelines de inferência na Amazon AI SageMaker
Um *pipeline de inferência* é um modelo de SageMaker IA da Amazon composto por uma sequência linear de dois a quinze contêineres que processam solicitações de inferências sobre dados. Você usa um pipeline de inferência para definir e implantar qualquer combinação de algoritmos integrados de SageMaker IA pré-treinados e seus próprios algoritmos personalizados empacotados em contêineres do Docker. Você pode usar um pipeline de inferência para combinar pré-processamento, predições e tarefas de ciência de dados de pós-processamento. Os pipelines de inferência são totalmente gerenciados.
Você pode adicionar contêineres SageMaker AI Spark ML Serving e scikit-learn que reutilizam os transformadores de dados desenvolvidos para modelos de treinamento. Todo o pipeline de inferência montado pode ser considerado como um modelo de SageMaker IA que você pode usar para fazer previsões em tempo real ou para processar transformações em lote diretamente, sem nenhum pré-processamento externo.
Em um modelo de pipeline de inferência, a SageMaker IA trata as invocações como uma sequência de solicitações HTTP. O primeiro contêiner no pipeline processa a solicitação inicial e, em seguida, a resposta intermediária é enviada como uma solicitação para o segundo contêiner, e assim por diante, para cada contêiner no pipeline. SageMaker A IA retorna a resposta final para o cliente.
Quando você implanta o modelo de pipeline, a SageMaker IA instala e executa todos os contêineres em cada instância do Amazon Elastic Compute Cloud (Amazon EC2) no endpoint ou na tarefa de transformação. O processamento de atributos e inferências são executados com baixa latência porque os contêineres estão localizados nas mesmas instâncias do EC2. Você define os contêineres de um modelo de pipeline usando a operação [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) ou no console. Em vez de definir um `PrimaryContainer`, você usa o parâmetro `Containers` para definir os contêineres que compõem o pipeline. Você também especifica a ordem em que os contêineres são executados.
Um modelo de pipeline é imutável, mas você pode atualizar um pipeline de inferência com a implantação de um novo pipeline usando a operação [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Essa modularidade permite maior flexibilidade durante a experimentação.
Para obter informações sobre como criar um pipeline de inferência com o SageMaker Model Registry, consulte[Implantação do registro do modelo com o Model Registry](model-registry.md).
Não há custos adicionais pelo uso desse atributo. Você paga apenas pelas instâncias em execução em um endpoint.
**Topics**
+ [Cadernos de exemplo para pipelines de inferência](#inference-pipeline-sample-notebooks)
+ [Processamento de atributos com SparkML e Scikit-learn](inference-pipeline-mleap-scikit-learn-containers.md)
+ [Criar um modelo de pipeline](inference-pipeline-create-console.md)
+ [Executar predições em tempo real com um pipeline de inferência](inference-pipeline-real-time.md)
+ [Transformações em lotes com pipelines de inferência](inference-pipeline-batch.md)
+ [Logs e métricas de pipeline de inferência](inference-pipeline-logs-metrics.md)
+ [Solucionar problemas em pipelines de inferência](inference-pipeline-troubleshoot.md)
## Cadernos de exemplo para pipelines de inferência
Para ver um exemplo que mostra como criar e implantar pipelines de inferência, consulte o caderno de amostra [Inference Pipeline with Scikit-learn](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/scikit_learn_inference_pipeline) and Linear Learner. Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar o exemplo em SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md)
Para ver uma lista de todas as amostras de SageMaker IA, depois de criar e abrir uma instância do notebook, escolha a guia **Exemplos de SageMaker IA**. Existem três cadernos de pipeline de inferência. Os dois primeiros cadernos do pipeline de inferência estão localizados na pasta `advanced_functionality`, e o terceiro caderno está na pasta `sagemaker-python-sdk`. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**.
# Processamento de atributos com SparkML e Scikit-learn
Antes de treinar um modelo com algoritmos integrados de SageMaker IA da Amazon ou algoritmos personalizados, você pode usar os pré-processadores Spark e scikit-learn para transformar seus dados e recursos de engenharia.
## Processamento de atributos com o SparkML
Você pode executar trabalhos de ML do Spark com o [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html), um serviço ETL (extrair, transformar, carregar) sem servidor, a partir do seu notebook de IA. SageMaker Você também pode se conectar a clusters do EMR existentes para executar tarefas do SparkML com o [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html). Para fazer isso, você precisa de uma função AWS Identity and Access Management (IAM) que conceda permissão para fazer chamadas do seu notebook de SageMaker IA para AWS Glue o.
**nota**
Para ver quais versões do Python e do Spark são AWS Glue compatíveis, consulte as notas de lançamento do [AWS Glue](/glue/latest/dg/release-notes.html).
Depois dos recursos de engenharia, você empacota e serializa os trabalhos de ML do Spark MLeap em MLeap contêineres que podem ser adicionados a um pipeline de inferência. Você não precisa usar clusters do Spark gerenciados externamente. Com essa abordagem, você pode dimensionar sem problemas de uma amostra de linhas a terabytes de dados. Como os mesmos transformadores funcionam tanto para treinamento quanto para inferência, você não precisa duplicar a lógica de pré-processamento e engenharia de atributos ou desenvolver uma solução única para fazer os modelos persistirem. Com os pipelines de inferência, você não precisa manter a infraestrutura externa e pode fazer predições diretamente das entradas de dados.
Quando você executa uma tarefa do Spark ML no AWS Glue, um pipeline do Spark ML é serializado em formato. [MLeap](https://github.com/combust/mleap) Em seguida, você pode usar o trabalho com o [SparkML Model Serving](https://github.com/aws/sagemaker-sparkml-serving-container) Container em SageMaker um pipeline de inferência de IA. *MLeap*é um formato de serialização e mecanismo de execução para pipelines de aprendizado de máquina. Ele é compatível com Spark, Scikit-learn e TensorFlow para treinar pipelines e exportá-los para um pipeline serializado chamado Bundle. MLeap Você pode desserializar os pacotes de volta ao Spark para pontuação em lote ou para o tempo de execução para alimentar serviços de API em tempo real. MLeap
Para ver um exemplo que mostra como criar recursos de processo com o Spark ML, consulte [Treinar um modelo de ML usando o Apache Spark no Amazon EMR e implantar em](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/sparkml_serving_emr_mleap_abalone) um notebook de amostra de IA. SageMaker
## Processamento de atributos com Scikit-Learn
Você pode executar e empacotar trabalhos do scikit-learn em contêineres diretamente na Amazon AI. SageMaker Para um exemplo de código Python para a construção de um modelo de featurizer scikit-learn que é treinado no [conjunto de dados de íris de Fisher](http://archive.ics.uci.edu/ml/datasets/Iris) (em inglês) e prevê as espécies de íris com base em medições morfológicas, consulte o tópico sobre [Treinamento e predição IRIS com o Scikit-learn no Sagemaker](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris) (em inglês).
# Criar um modelo de pipeline
Para criar um modelo de pipeline que possa ser implantado em um endpoint ou usado para um trabalho de transformação em lote, use o console Amazon SageMaker AI ou a `CreateModel` operação.
**Para criar um pipeline de inferência (console)**
1. Abra o console do Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Modelos** e depois **Criar modelos** no grupo **Inferência**.
1. Na página **Criar modelo**, forneça um nome de modelo, escolha um perfil do IAM e, se você deseja usar uma VPC privada, especifique os valores da VPC.
![\[A página de criação de um modelo para um pipeline de inferência.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/create-pipeline-model.png)
1. Para adicionar informações sobre os contêineres no pipeline de inferência, escolha **Adicionar contêiner** e **Avançar**.
1. Preencha os campos para cada contêiner na ordem em que você deseja executá-los, até o máximo de quinze. Preencha os campos **Opções de entrada de contêiner**, **Local de imagem do código de inferência** e, opcionalmente, os campos **Local dos artefatos do modelo**, **Nome de host do contêiner** e **Variáveis de ambiente**.
![\[Criação de um modelo de pipeline com contêineres.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/create-pipeline-model-containers.png)
A **MyInferencePipelineModel**página resume as configurações dos contêineres que fornecem entrada para o modelo. Se você forneceu as variáveis de ambiente em uma definição de contêiner correspondente, o SageMaker AI as mostrará no campo **Variáveis de ambiente**.
![\[O resumo das configurações de contêiner para o modelo de pipeline.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipeline-MyInferencePipelinesModel-recap.png)
# Executar predições em tempo real com um pipeline de inferência
Você pode usar modelos treinados em um pipeline de inferência para fazer predições em tempo real diretamente sem executar o pré-processamento externo. Ao configurar o pipeline, você pode optar por usar os transformadores de recursos integrados já disponíveis na Amazon SageMaker AI. Ou você pode implementar sua própria lógica de transformação usando apenas algumas linhas de código Spark ou scikit-learn.
[MLeap](https://combust.github.io/mleap-docs/), um formato de serialização e mecanismo de execução para pipelines de aprendizado de máquina, é compatível com Spark, scikit-learn e TensorFlow para treinar pipelines e exportá-los para um pipeline serializado chamado Bundle. MLeap Você pode desserializar os pacotes de volta ao Spark para pontuação em lote ou para o tempo de execução para alimentar serviços de API em tempo real. MLeap
Os contêineres em um pipeline escutam na porta especificada na variável de ambiente `SAGEMAKER_BIND_TO_PORT` (em vez da 8080). Ao ser executada em um pipeline de inferência, a SageMaker IA fornece automaticamente essa variável de ambiente aos contêineres. Se essa variável de ambiente não estiver presente, os contêineres padrão usam a porta 8080. Para indicar que o contêiner está em conformidade com esse requisito, use o seguinte comando para adicionar um rótulo ao Dockerfile:
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
Se o seu contêiner precisar escutar em uma segunda porta, escolha uma porta no intervalo especificado pela variável de ambiente `SAGEMAKER_SAFE_PORT_RANGE`. Especifique o valor como um intervalo inclusivo no formato**"XXXX-YYYY"**, onde `XXXX` e `YYYY` são números inteiros de vários dígitos. SageMaker A IA fornece esse valor automaticamente quando você executa o contêiner em um pipeline de vários contêineres.
**nota**
Para usar imagens personalizadas do Docker em um pipeline que inclui [algoritmos integrados de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), você precisa de uma política do [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html). Seu repositório Amazon ECR deve conceder permissão à SageMaker IA para extrair a imagem. Para obter mais informações, consulte [Solucionar problemas com permissões do Amazon ECR para pipelines de inferência](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions).
## Criar e implantar um endpoint de pipeline de inferência
O código a seguir cria e implanta um modelo de pipeline de inferência em tempo real com o SparkML e XGBoost modelos em série usando o AI SDK. SageMaker
```
from sagemaker.model import Model
from sagemaker.pipeline_model import PipelineModel
from sagemaker.sparkml.model import SparkMLModel
sparkml_data = 's3://{}/{}/{}'.format(s3_model_bucket, s3_model_key_prefix, 'model.tar.gz')
sparkml_model = SparkMLModel(model_data=sparkml_data)
xgb_model = Model(model_data=xgb_model.model_data, image=training_image)
model_name = 'serial-inference-' + timestamp_prefix
endpoint_name = 'serial-inference-ep-' + timestamp_prefix
sm_model = PipelineModel(name=model_name, role=role, models=[sparkml_model, xgb_model])
sm_model.deploy(initial_instance_count=1, instance_type='ml.c4.xlarge', endpoint_name=endpoint_name)
```
## Solicitar inferência em tempo real de um endpoint do pipeline de inferência
O seguinte exemplo mostra como fazer predições em tempo real chamando um endpoint de inferência e transmitindo uma carga útil de solicitações no formato JSON:
```
import sagemaker
from sagemaker.predictor import json_serializer, json_deserializer, Predictor
payload = {
"input": [
{
"name": "Pclass",
"type": "float",
"val": "1.0"
},
{
"name": "Embarked",
"type": "string",
"val": "Q"
},
{
"name": "Age",
"type": "double",
"val": "48.0"
},
{
"name": "Fare",
"type": "double",
"val": "100.67"
},
{
"name": "SibSp",
"type": "double",
"val": "1.0"
},
{
"name": "Sex",
"type": "string",
"val": "male"
}
],
"output": {
"name": "features",
"type": "double",
"struct": "vector"
}
}
predictor = Predictor(endpoint=endpoint_name, sagemaker_session=sagemaker.Session(), serializer=json_serializer,
content_type='text/csv', accept='application/json')
print(predictor.predict(payload))
```
A resposta que você obtém de `predictor.predict(payload)` é o resultado da inferência do modelo.
## Exemplo de pipeline de inferência do Realtime
Você pode executar esse [exemplo de notebook usando o SKLearn preditor](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-python-sdk/scikit_learn_randomforest/Sklearn_on_SageMaker_end2end.ipynb) que mostra como implantar um endpoint, executar uma solicitação de inferência e, em seguida, desserializar a resposta. Encontre esse caderno e mais exemplos no [ GitHub repositório de SageMaker exemplos da Amazon](https://github.com/awslabs/amazon-sagemaker-examples).
# Transformações em lotes com pipelines de inferência
Para obter inferências em um conjunto de dados inteiro, execute uma transformação em lote em um modelo treinado. Para executar inferências em um conjunto de dados inteiro, é possível usar o mesmo modelo de pipeline de inferência criado e implantado em um endpoint para o processamento em tempo real de um trabalho de transformação em lote. Para executar um trabalho de transformação em lote em um pipeline, faça download dos dados de entrada do Amazon S3 e envie-os em uma ou mais solicitações HTTP para o modelo de pipeline de inferência. Para ver um exemplo que mostra como preparar dados para uma transformação em lote, consulte “Seção 2 - Pré-processar os dados brutos de alojamento usando o Scikit Learn” do [Amazon SageMaker Multi-Model Endpoints usando o caderno de amostra Linear Learner](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_linear_learner_home_value). Para obter informações sobre as transformações em lote do Amazon SageMaker AI, consulte[Transformação em lote para inferência com a Amazon AI SageMaker](batch-transform.md).
**nota**
Para usar imagens personalizadas do Docker em um pipeline que inclui [algoritmos integrados do Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), você precisa de uma política do [Amazon Elastic Container Registry (ECR).](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) Seu repositório Amazon ECR deve conceder permissão à SageMaker IA para extrair a imagem. Para obter mais informações, consulte [Solucionar problemas com permissões do Amazon ECR para pipelines de inferência](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions).
O exemplo a seguir mostra como executar um trabalho de transformação usando o SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Neste exemplo, `model_name` está o pipeline de inferência que combina SparkML XGBoost e modelos (criados nos exemplos anteriores). O local do Amazon S3 especificado por `input_data_path` contém os dados de entrada, no formato CSV, a serem baixados e enviados ao modelo SparkML. Depois que o trabalho de transformação for concluído, a localização do Amazon S3 especificada por `output_data_path` contém os dados de saída retornados pelo XGBoost modelo no formato CSV.
```
import sagemaker
input_data_path = 's3://{}/{}/{}'.format(default_bucket, 'key', 'file_name')
output_data_path = 's3://{}/{}'.format(default_bucket, 'key')
transform_job = sagemaker.transformer.Transformer(
model_name = model_name,
instance_count = 1,
instance_type = 'ml.m4.xlarge',
strategy = 'SingleRecord',
assemble_with = 'Line',
output_path = output_data_path,
base_transform_job_name='inference-pipelines-batch',
sagemaker_session=sagemaker.Session(),
accept = CONTENT_TYPE_CSV)
transform_job.transform(data = input_data_path,
content_type = CONTENT_TYPE_CSV,
split_type = 'Line')
```
# Logs e métricas de pipeline de inferência
O monitoramento é importante para manter a confiabilidade, a disponibilidade e o desempenho dos recursos de SageMaker IA da Amazon. Para monitorar e solucionar problemas de desempenho do pipeline de inferência, use CloudWatch registros e mensagens de erro da Amazon. Para obter informações sobre as ferramentas de monitoramento que a SageMaker IA fornece, consulte[AWS Recursos de monitoramento na Amazon SageMaker AI](monitoring-overview.md).
## Usar métricas para monitorar modelos de vários contêineres
Para monitorar os modelos de vários contêineres em Inference Pipelines, use a Amazon. CloudWatch CloudWatchcoleta dados brutos e os processa em métricas legíveis, quase em tempo real. SageMaker Os trabalhos e endpoints de treinamento de IA CloudWatch gravam métricas e registros no `AWS/SageMaker` namespace.
A tabela a seguir lista as métricas e as dimensões para o seguinte:
+ Invocações de endpoint
+ Tarefas de treinamento, tarefas de transformação em lote e instâncias de endpoint
Uma *dimensão* é um name/value par que identifica de forma exclusiva uma métrica. Você pode atribuir até 10 dimensões a uma métrica. Para obter mais informações sobre o monitoramento com CloudWatch, consulte[Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md).
**Métricas de invocação de endpoint**
O namespace `AWS/SageMaker` inclui as seguintes métricas de solicitação de chamadas para [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html):
As métricas são relatadas em intervalos de 1 minuto.
| Métrica | Description |
| --- | --- |
| Invocation4XXErrors | O número de solicitações `InvokeEndpoint` em que o modelo retornou um código de resposta HTTP `4xx`. Para cada `4xx` resposta, a SageMaker IA envia um`1`. Unidades: nenhuma Estatísticas válidas: `Average`, `Sum` |
| Invocation5XXErrors | O número de solicitações `InvokeEndpoint` em que o modelo retornou um código de resposta HTTP `5xx`. Para cada `5xx` resposta, a SageMaker IA envia um`1`. Unidades: nenhuma Estatísticas válidas: `Average`, `Sum` |
| Invocations | As solicitações `number of InvokeEndpoint` enviadas para um endpoint de modelo. Para obter o número total de solicitações enviadas a um endpoint de modelo, use a estatística `Sum`. Unidades: nenhuma Estatísticas válidas: `Sum`, `Sample Count` |
| InvocationsPerInstance | O número de invocações de endpoint enviadas para um modelo, normalizado por in each. `InstanceCount` `ProductionVariant` SageMaker A IA envia 1/ `numberOfInstances` como o valor de cada solicitação, onde `numberOfInstances` é o número de instâncias ativas do ProductionVariant no endpoint no momento da solicitação. Unidades: nenhuma Estatísticas válidas: `Sum` |
| ModelLatency | O tempo que o modelo ou modelos levaram para responder. Isso inclui o tempo necessário para enviar a solicitação, buscar a resposta do contêiner do modelo e concluir a inferência no contêiner. ModelLatency é o tempo total gasto por todos os contêineres em um pipeline de inferência.Unidade: microssegundosEstatísticas válidas: `Average`, `Sum`, `Min`, `Max`, contagem de amostras |
| OverheadLatency | O tempo adicionado ao tempo necessário para responder a uma solicitação de um cliente feita pela SageMaker IA para sobrecarga. `OverheadLatency`é medido a partir do momento em que a SageMaker IA recebe a solicitação até retornar uma resposta ao cliente, menos o. `ModelLatency` A latência de sobrecarga pode variar dependendo de tamanhos de carga útil de solicitações e respostas, frequência de solicitações e autenticação ou autorização da solicitação, entre outros fatores. Unidade: microssegundos Estatísticas válidas: `Average`, `Sum`, `Min`, `Max`, `Sample Count` |
| ContainerLatency | O tempo necessário para que um contêiner do Inference Pipelines respondesse conforme visualizado pela SageMaker IA. ContainerLatencyinclui o tempo necessário para enviar a solicitação, buscar a resposta do contêiner do modelo e concluir a inferência no contêiner.Unidade: microssegundosEstatísticas válidas: `Average`, `Sum`, `Min`, `Max`, `Sample Count` |
**Dimensões para métricas de invocação de endpoint**
| Dimensão | Description |
| --- | --- |
| EndpointName, VariantName, ContainerName | Filtra as métricas de invocação do endpoint para um `ProductionVariant` no endpoint especificado e para a variante especificada. |
**Para um endpoint de pipeline de inferência, CloudWatch lista as métricas de latência por contêiner em sua conta como **Endpoint Container Metrics e **Endpoint Variant Metrics**** no namespace AI, da SageMaker seguinte forma.** A métrica `ContainerLatency` aparece apenas para pipelines de inferências.
![\[O CloudWatch painel para um pipeline de inferência.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipeline-endpoint-metrics.png)
Para cada endpoint e cada contêiner, as métricas de latência exibem nomes para o contêiner, o endpoint, a variante e a métrica.
![\[As métricas de latência para um endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipeline-endpoint-metrics-details.png)
**Métricas de trabalho de treinamento, trabalho de transformação em lote e instância de endpoint**
Os namespaces `/aws/sagemaker/TrainingJobs`, `/aws/sagemaker/TransformJobs` e `/aws/sagemaker/Endpoints` incluem as seguintes métricas para trabalhos de treinamento e instâncias de endpoint:
As métricas são relatadas em intervalos de 1 minuto.
| Métrica | Description |
| --- | --- |
| CPUUtilization | O percentual de unidades de CPU usadas pelos contêineres em execução em uma instância. O valor varia de 0% a 100% e é multiplicado pelo número de CPUs. Por exemplo, se houver quatro CPUs, `CPUUtilization` pode variar de 0% a 400%. Para trabalhos de treinamento, o `CPUUtilization` é a utilização de CPU do contêiner de algoritmo em execução na instância. Para trabalhos de transformação em lote, o `CPUUtilization` é a utilização da CPU do contêiner de transformação em execução na instância. Para modelos de vários contêineres, `CPUUtilization` é a soma da utilização da CPU por todos os contêineres em execução na instância. Para variantes de endpoint, `CPUUtilization` é a soma de utilização da CPU por todos os contêineres em execução na instância. Unidades: percentual |
| MemoryUtilization | O percentual de memória usada pelos contêineres em execução em uma instância. Esse valor varia de 0% a 100%.Para tarefas de treinamento, `MemoryUtilization` é a memória usada pelo contêiner de algoritmo em execução na instância.Para tarefas de transformação em lote, `MemoryUtilization` é a memória usada pelo contêiner de transformação em execução na instância.Para modelos com vários contêineres, MemoryUtilization é a soma da memória usada por todos os contêineres em execução na instância.Para variantes de endpoint, `MemoryUtilization` é a soma da memória usada por todos os contêineres em execução na instância.Unidades: percentual |
| GPUUtilization | A porcentagem de unidades de GPU usadas pelos contêineres em execução em uma instância. `GPUUtilization`varia de 0% a 100% e é multiplicado pelo número de GPUs. Por exemplo, se houver quatro GPUs, `GPUUtilization` pode variar de 0% a 400%. Para tarefas de treinamento, `GPUUtilization` é a GPU usada pelo contêiner de algoritmo em execução na instância. Para trabalhos de transformação em lote, `GPUUtilization` é a GPU usada pelo contêiner de transformação em execução na instância. Para modelos com vários contêineres, `GPUUtilization` é a soma da GPU usada por todos os contêineres em execução na instância. Para variantes de endpoint, `GPUUtilization` é a soma da GPU usada por todos os contêineres em execução na instância. Unidades: percentual |
| GPUMemoryUtilization | A porcentagem da memória da GPU usada pelos contêineres em execução em uma instância. GPUMemoryA utilização varia de 0% a 100% e é multiplicada pelo número de. GPUs Por exemplo, se houver quatro GPUs, `GPUMemoryUtilization` pode variar de 0% a 400%. Para tarefas de treinamento, `GPUMemoryUtilization` é a memória da GPU usada pelo contêiner do algoritmo em execução na instância. Para tarefas de transformação em lote, `GPUMemoryUtilization` é a memória da GPU usada pelo contêiner de transformação em execução na instância. Para modelos com vários contêineres, `GPUMemoryUtilization` é a soma da GPU usada por todos os contêineres em execução na instância. Para variantes de endpoint, `GPUMemoryUtilization` é a soma da memória da GPU usada por todos os contêineres em execução na instância. Unidades: percentual |
| DiskUtilization | A porcentagem do espaço em disco usado pelos contêineres em execução em uma instância. DiskUtilization varia de 0% a 100%. Essa métrica não oferece apoio para trabalhos de transformação em lote. Para tarefas de treinamento, `DiskUtilization` é o espaço em disco usado pelo contêiner de algoritmo em execução na instância. Para variantes de endpoint, `DiskUtilization` é a soma do espaço em disco usado por todos os contêineres fornecidos em execução na instância. Unidades: percentual |
**Dimensões para métricas de trabalho de treinamento, trabalho de transformação em lote e instância de endpoint**
| Dimensão | Description |
| --- | --- |
| Host | Para tarefas de treinamento, `Host` tem o formato `[training-job-name]/algo-[instance-number-in-cluster]`. Use essa dimensão para filtrar as métricas de instância para o trabalho de treinamento e a instância especificados. Esse formato de dimensão está presente somente no namespace `/aws/sagemaker/TrainingJobs`. Para tarefas de transformação em lote, `Host` tem o formato `[transform-job-name]/[instance-id]`. Use essa dimensão para filtrar métricas de instância para o trabalho de transformação em lote e a instância especificados. Esse formato de dimensão está presente somente no namespace `/aws/sagemaker/TransformJobs`. Para endpoints, `Host` tem o formato `[endpoint-name]/[ production-variant-name ]/[instance-id]`. Use essa dimensão para filtrar as métricas de instância para o endpoint, a variante e a instância especificados. Esse formato de dimensão está presente somente no namespace `/aws/sagemaker/Endpoints`. |
Para ajudá-lo a depurar suas tarefas de treinamento, endpoints e configurações de ciclo de vida de instâncias de notebooks, a SageMaker IA também envia tudo o que um contêiner de algoritmo, um contêiner de modelo ou uma configuração de ciclo de vida de instância de notebook envia para ou para o Amazon Logs. `stdout` `stderr` CloudWatch Você pode usar essas informações para depuração e para analisar o progresso.
## Usar logs para monitorar um pipeline de inferência
A tabela a seguir lista os grupos de log e os fluxos de log que a SageMaker IA envia para a Amazon CloudWatch
*Fluxo de logs* é uma sequência de eventos de log que compartilham a mesma origem. Cada fonte separada de registros em CloudWatch forma um fluxo de registros separado. Um *grupo de logs* é um grupo de fluxos de log que compartilham as mesmas configurações de retenção, monitoramento e controle de acesso.
**Logs**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
**nota**
SageMaker A IA cria o grupo de `/aws/sagemaker/NotebookInstances` registros quando você cria uma instância de notebook com uma configuração de ciclo de vida. Para obter mais informações, consulte [Personalização de uma instância de SageMaker notebook usando um script LCC](notebook-lifecycle-config.md).
Para obter mais informações sobre o registro de SageMaker IA, consulte[CloudWatch Registros para Amazon SageMaker AI](logging-cloudwatch.md).
# Solucionar problemas em pipelines de inferência
Para solucionar problemas do pipeline de inferência, use CloudWatch registros e mensagens de erro. Se você estiver usando imagens personalizadas do Docker em um pipeline que inclui algoritmos integrados do Amazon SageMaker AI, você também poderá encontrar problemas de permissões. Para conceder as permissões necessárias, crie uma política do Amazon Elastic Container Registry (Amazon ECR).
**Topics**
+ [Solucionar problemas com permissões do Amazon ECR para pipelines de inferência](#inference-pipeline-troubleshoot-permissions)
+ [Use CloudWatch registros para solucionar problemas de pipelines de SageMaker inferência de IA](#inference-pipeline-troubleshoot-logs)
+ [Use mensagens de erro para solucionar problemas com pipelines de inferência.](#inference-pipeline-troubleshoot-errors)
## Solucionar problemas com permissões do Amazon ECR para pipelines de inferência
Quando você usa imagens personalizadas do Docker em um pipeline que inclui [algoritmos integrados de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), você precisa de uma política do [Amazon ECR.](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) A política permite que seu repositório Amazon ECR conceda permissão para que a SageMaker IA extraia a imagem. A política deve adicionar as seguintes permissões:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "allowSageMakerToPull",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*"
}
]
}
```
------
## Use CloudWatch registros para solucionar problemas de pipelines de SageMaker inferência de IA
SageMaker A IA publica os registros do contêiner para endpoints que implantam um pipeline de inferência CloudWatch na Amazon no seguinte caminho para cada contêiner.
```
/aws/sagemaker/Endpoints/{EndpointName}/{Variant}/{InstanceId}/{ContainerHostname}
```
Por exemplo, os logs desse endpoint são publicados nos seguintes grupos de logs e streams:
```
EndpointName: MyInferencePipelinesEndpoint
Variant: MyInferencePipelinesVariant
InstanceId: i-0179208609ff7e488
ContainerHostname: MyContainerName1 and MyContainerName2
```
```
logGroup: /aws/sagemaker/Endpoints/MyInferencePipelinesEndpoint
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName1
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName2
```
*Fluxo de logs* é uma sequência de eventos de log que compartilham a mesma origem. Cada fonte separada de registros em CloudWatch forma um fluxo de registros separado. Um *grupo de logs* é um grupo de fluxos de log que compartilham as mesmas configurações de retenção, monitoramento e controle de acesso.
**Para ver os grupos de log e streams**
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Na página de navegação, escolha **Logs**.
1. In **Log Groups (Grupos de log)** filtre em **MyInferencePipelinesEndpoint**:
![\[Os grupos de CloudWatch registros foram filtrados para o endpoint do pipeline de inferência.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipeline-log-group-filter.png)
1. Para ver os fluxos de registros, na página **Grupos de CloudWatch registros**, escolha e, em seguida**MyInferencePipelinesEndpoint**, **Pesquisar grupo de registros**.
![\[O fluxo de CloudWatch log do pipeline de inferência.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/pipeline-log-streams-2.png)
Para obter uma lista dos registros que a SageMaker AI publica, consulte[Logs e métricas de pipeline de inferência](inference-pipeline-logs-metrics.md).
## Use mensagens de erro para solucionar problemas com pipelines de inferência.
As mensagens de erro do pipeline de inferência indicam quais contêineres falharam.
Se ocorrer um erro enquanto a SageMaker IA invoca um endpoint, o serviço retornará um `ModelError` (código de erro 424), que indica qual contêiner falhou. Se a carga útil da solicitação (a resposta do contêiner anterior) exceder o limite de 5 MB, a SageMaker AI fornecerá uma mensagem de erro detalhada, como:
Resposta recebida de MyContainerName 1 com o código de status 200. No entanto, a carga útil da solicitação de MyContainerName 1 a MyContainerName 2 é de 6000000 bytes, o que excedeu o limite máximo de 5 MB.
``
Se um contêiner falhar na verificação de integridade do ping enquanto a SageMaker IA estiver criando um endpoint, ele retornará a `ClientError` e indicará todos os contêineres que falharam na verificação de ping na última verificação de integridade.
# Excluir endpoints e recursos
Excluir endpoints para parar de incorrer em cobranças.
## Excluir endpoint
Exclua seu endpoint programaticamente usando AWS SDK para Python (Boto3), com o ou interativamente usando o AWS CLI console de IA. SageMaker
SageMaker A IA libera todos os recursos que foram implantados quando o endpoint foi criado. A exclusão de um endpoint não excluirá a configuração do endpoint ou o SageMaker modelo de IA. Consulte [Excluir configuração de endpoint](#realtime-endpoints-delete-endpoint-config) e obtenha [Excluir modelo](#realtime-endpoints-delete-model) informações sobre como excluir a configuração do endpoint e o modelo de SageMaker IA.
------
#### [ AWS SDK para Python (Boto3) ]
Use a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) para excluir seu endpoint. Especifique o nome do endpoint para o campo `EndpointName`.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint
sagemaker_client.delete_endpoint(EndpointName=endpoint_name)
```
------
#### [ AWS CLI ]
Para excluir um endpoint, use o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html): Para o sinalizador `endpoint-name`, especifique o nome do seu endpoint.
```
aws sagemaker delete-endpoint --endpoint-name
```
------
#### [ SageMaker AI Console ]
Exclua seu endpoint de forma interativa com o console de SageMaker IA.
1. No console de SageMaker IA, no menu [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)de navegação, escolha **Inferência.**
1. Escolha **Endpoints** no menu suspenso. Uma lista de endpoints criados em AWS sua conta aparecerá por nome, Amazon Resource Name (ARN), horário de criação, status e data e hora da última atualização do endpoint.
1. Selecione o endpoint que você deseja excluir.
1. Selecione o botão suspenso **Ações** no canto superior direito.
1. Escolha **Excluir**.
------
## Excluir configuração de endpoint
Exclua a configuração do endpoint de forma programática usando AWS SDK para Python (Boto3), com o ou interativamente usando o AWS CLI console de IA. SageMaker A exclusão de uma configuração de endpoint não exclui endpoints criados usando essa configuração. Consulte [Excluir endpoint](#realtime-endpoints-delete-endpoint) para obter informações sobre como excluir seu endpoint.
Não exclua uma configuração de endpoint em uso por um endpoint ativo ou enquanto o endpoint está sendo atualizado ou criado. Você pode perder a visibilidade do tipo de instância que o endpoint está usando se excluir a configuração de endpoint de um endpoint ativo ou que está sendo criado ou atualizado.
------
#### [ AWS SDK para Python (Boto3) ]
Use a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html) para excluir seu endpoint. Especifique o nome da configuração de endpoint para o campo `EndpointConfigName`.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
endpoint_config_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
Opcionalmente, você pode usar a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) para retornar informações sobre o nome dos seus modelos implantados (variantes de produção), como o nome do seu modelo e o nome da configuração de endpoint associada a esse modelo implantado. Forneça o nome do seu endpoint para o campo `EndpointConfigName`.
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
endpoint_config_name = response['ProductionVariants'][0]['EndpointConfigName']
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
Para obter mais informações sobre outros elementos de resposta retornados por`DescribeEndpointConfig`, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)o [Guia de referência da SageMaker API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html).
------
#### [ AWS CLI ]
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html)para excluir a configuração de endpoint. Especifique o nome da configuração de endpoint para o sinalizador `endpoint-config-name`.
```
aws sagemaker delete-endpoint-config \
--endpoint-config-name
```
Opcionalmente, você pode usar o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) para retornar informações sobre o nome dos seus modelos implantados (variantes de produção), como o nome do seu modelo e o nome da configuração de endpoint associada a esse modelo implantado. Forneça o nome do seu endpoint para o sinalizador `endpoint-config-name`.
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
Isso retornará uma resposta JSON. Você pode copiar e colar, usar um analisador JSON ou usar uma ferramenta criada para análise JSON para obter o nome da configuração do endpoint associado a esse endpoint.
------
#### [ SageMaker AI Console ]
Exclua a configuração do endpoint de forma interativa com o console de SageMaker IA.
1. No console de SageMaker IA, no menu [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)de navegação, escolha **Inferência.**
1. Escolha **Configurações de Endpoint** no menu suspenso. Uma lista de configurações de endpoints criadas em sua conta AWS aparecerá por nome, Nome do recurso da Amazon (ARN) e horário de criação.
1. Selecione a configuração de endpoint que você deseja excluir.
1. Selecione o botão suspenso **Ações** no canto superior direito.
1. Escolha **Excluir**.
------
## Excluir modelo
Exclua seu modelo de SageMaker IA programaticamente usando AWS SDK para Python (Boto3), com o ou interativamente usando o AWS CLI console de IA. SageMaker A exclusão de um modelo de SageMaker IA exclui somente a entrada do modelo que foi criada na SageMaker IA. Excluir um modelo não exclui os artefatos, o código de inferência ou o perfil do IAM do modelo que você especificou ao criar o modelo.
------
#### [ AWS SDK para Python (Boto3) ]
Use a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API para excluir seu modelo de SageMaker IA. Especifique o nome do seu modelo para o campo `ModelName`.
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
model_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete model
sagemaker_client.delete_model(ModelName=model_name)
```
Opcionalmente, você pode usar a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) para retornar informações sobre o nome dos seus modelos implantados (variantes de produção), como o nome do seu modelo e o nome da configuração de endpoint associada a esse modelo implantado. Forneça o nome do seu endpoint para o campo `EndpointConfigName`.
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
model_name = response['ProductionVariants'][0]['ModelName']
sagemaker_client.delete_model(ModelName=model_name)
```
Para obter mais informações sobre outros elementos de resposta retornados por`DescribeEndpointConfig`, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)o [Guia de referência da SageMaker API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html).
------
#### [ AWS CLI ]
Use o [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html)comando para excluir seu modelo de SageMaker IA. Para o sinalizador `model-name`, especifique o nome do modelo.
```
aws sagemaker delete-model \
--model-name
```
Opcionalmente, você pode usar o comando [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) para retornar informações sobre o nome dos seus modelos implantados (variantes de produção), como o nome do seu modelo e o nome da configuração de endpoint associada a esse modelo implantado. Forneça o nome do seu endpoint para o sinalizador `endpoint-config-name`.
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
Isso retornará uma resposta JSON. Você pode copiar e colar, usar um analisador JSON ou usar uma ferramenta criada para análise JSON para obter o nome do modelo associado a esse endpoint.
------
#### [ SageMaker AI Console ]
Exclua seu modelo de SageMaker IA de forma interativa com o console de SageMaker IA.
1. No console de SageMaker IA, no menu [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)de navegação, escolha **Inferência.**
1. No menu suspenso, escolha **Modelos**. Uma lista de modelos criados em AWS sua conta aparecerá por nome, Amazon Resource Name (ARN) e horário de criação.
1. Selecione o modelo que deseja excluir.
1. Selecione o botão suspenso **Ações** no canto superior direito.
1. Escolha **Excluir**.
------
# Escalabilidade automática dos modelos de SageMaker IA da Amazon
O Amazon SageMaker AI oferece suporte à escalabilidade automática (escalabilidade automática) para seus modelos hospedados. O *ajuste de escala automático* ajusta dinamicamente o número de instâncias provisionadas para um modelo em resposta às alterações no workload. Quando a workload aumenta, o ajuste de escala automático disponibiliza mais instâncias online. Quando a workload diminui, o ajuste de escala automático remove as instâncias desnecessárias para que você não precise pagar pelas instâncias provisionadas que não está usando.
**Topics**
+ [Visão geral das políticas de ajuste de escala automático](endpoint-auto-scaling-policy.md)
+ [Pré-requisitos de ajuste de escala automático](endpoint-auto-scaling-prerequisites.md)
+ [Configurar a ajuste de escala automático do modelo com o console](endpoint-auto-scaling-add-console.md)
+ [Registrar um modelo](endpoint-auto-scaling-add-policy.md)
+ [Definir uma política de escalabilidade](endpoint-auto-scaling-add-code-define.md)
+ [Aplicar uma política de escalabilidade](endpoint-auto-scaling-add-code-apply.md)
+ [Instruções para editar uma política de ajuste de escala](endpoint-auto-scaling-edit.md)
+ [Desative temporariamente as políticas de ajuste de escala](endpoint-auto-scaling-suspend-scaling-activities.md)
+ [Excluir uma política de escalabilidade](endpoint-auto-scaling-delete.md)
+ [Verificar o status de uma atividade de ajuste de escala na descrição das atividades de ajuste de escala](endpoint-scaling-query-history.md)
+ [Escalar um endpoint para zero instância](endpoint-auto-scaling-zero-instances.md)
+ [Testes de carga da configuração de ajuste de escala automático](endpoint-scaling-loadtest.md)
+ [Use CloudFormation para criar uma política de escalabilidade](endpoint-scaling-cloudformation.md)
+ [Atualizar endpoints que usam o ajuste de escala automático](endpoint-scaling-update.md)
+ [Excluir endpoints configurados para o ajuste de escala automático](endpoint-delete-with-scaling.md)
# Visão geral das políticas de ajuste de escala automático
Para usar o ajuste de escala automático, é preciso definir uma política de ajuste de escala que adiciona e remove o número de instâncias da sua variante de produção em resposta a workloads reais.
Para escalar automaticamente conforme as mudanças de workload, você tem duas opções: políticas de rastreamento de destinos e ajuste de escala em etapas.
Na maioria dos casos, recomendamos usar políticas de escalabilidade com rastreamento de destinos. Com o rastreamento de metas, você escolhe uma CloudWatch métrica e um valor alvo da Amazon. O Auto Scaling cria e gerencia CloudWatch os alarmes para a política de escalabilidade e calcula o ajuste de escalabilidade com base na métrica e no valor alvo. A política de ajuste de escala adiciona ou remove instâncias conforme necessário para manter a métrica no valor de destino especificado ou próxima dele. Por exemplo, uma política de escalabilidade que usa a métrica predefinida `InvocationsPerInstance` com um valor de destino de 70 pode manter `InvocationsPerInstance` em ou próxima a 70. Para obter mais informações, consulte [Políticas de escalabilidade de rastreamento de destino](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html), no *Guia do usuário do Application Auto Scaling*.
É possível usar a escalabilidade em etapas quando precisar de uma configuração avançada, como especificar quantas instâncias serão implantadas em quais condições. Por exemplo, você deve usar a escalabilidade em etapas se quiser permitir que um endpoint tenha a escala aumentada horizontalmente a partir de zero instância ativa. Para obter uma visão geral das políticas de ajuste de escala em etapas e como elas funcionam, consulte [Step scaling policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) no *Guia do usuário do ajuste de escala automático da aplicação*.
Para criar uma política de escalabilidade de rastreamento de destinos, especifique o seguinte:
+ **Métrica** — A CloudWatch métrica a ser monitorada, como o número médio de invocações por instância.
+ **Valor de destino**: o valor de destino da métrica, como, por exemplo, 70 invocações por instância por minuto.
É possível criar políticas de escalabilidade de rastreamento de destino com métricas predefinidas ou personalizadas. Uma métrica predefinida é definida em uma enumeração para que você possa especificá-la por nome no código ou usá-la no console do AI. SageMaker Como alternativa, você pode usar a AWS CLI ou a API do Application Auto Scaling para aplicar uma política de ajuste de escala com base em uma métrica predefinida ou personalizada.
Observe que as atividades de ajuste de escala são executadas com períodos de espera entre elas para evitar flutuações rápidas na capacidade. Opcionalmente, é possível configurar os períodos de espera para a política de ajuste de escala.
Para obter mais informações sobre os conceitos principais de ajuste de escala automático, consulte a seção a seguir.
## Ajuste de escala programado
Você pode criar ações programadas para executar atividades de ajuste de escala em momentos específicos. Você pode criar ações agendadas que escalam somente uma vez ou que escalam em uma programação recorrente. Após a execução de uma ação programada, a política de ajuste de escala pode continuar a tomar decisões sobre a necessidade de escalar dinamicamente à medida conforme as mudanças de workload. O escalonamento programado só pode ser gerenciado a partir da API Application Auto Scaling AWS CLI ou da API Application Auto Scaling. Para obter mais informações, consulte [Escalabilidade programada](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) no *Guia do usuário do Application Auto Scaling*.
## Limites mínimo e máximo de ajuste de escala
Ao configurar o ajuste de escala automático, você deve especificar seus limites de ajuste de escala antes de criar uma política de ajuste de escala. Você define limites separadamente para o tamanho mínimo e máximo.
O valor mínimo deve ser menor que 1, e igual ou menor que o valor especificado para o valor máximo.
O valor máximo deve ser igual ou maior que o valor especificado para o valor mínimo. SageMaker O escalonamento automático de IA não impõe um limite para esse valor.
Para determinar os limites de ajuste de escala que você precisa para um tráfego típico, teste a configuração de ajuste de escala automático com a taxa esperada de tráfego para o seu modelo.
Se o tráfego de uma variante se tornar zero, a SageMaker IA se expande automaticamente para o número mínimo de instâncias especificado. Nesse caso, a SageMaker IA emite métricas com valor zero.
Há três opções para especificar a capacidade mínima e máxima:
1. Use o console para atualizar as configurações **Contagem mínima de instâncias** e **Contagem máxima de instâncias**.
1. Use as `--max-capacity` opções AWS CLI e inclua `--min-capacity` e ao executar o [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)comando.
1. Chame a [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)API e especifique os `MinCapacity` `MaxCapacity` parâmetros e.
**dica**
Aumente o valor mínimo manualmente para aumentar a escala horizontalmente, ou diminua o valor máximo manualmente para reduzir a escala horizontalmente.
## Período de espera
É usado um *período de espera* para proteger contra o ajuste de escala excessivo ao reduzir a escala horizontalmente (redução da capacidade) ou aumentar a escala horizontalmente (aumento da capacidade) do modelo. Isso é feito através da desaceleração das atividades de ajuste de escala subsequentes até o fim do período. Mais especificamente, bloqueará a exclusão de instâncias nas solicitações para reduzir a escala horizontalmente, bem como a criação de instâncias nas solicitações para aumentar a escala horizontalmente. Para obter mais informações, consulte [Definir períodos de espera](https://docs.aws.amazon.com/autoscaling/application/userguide/target-tracking-scaling-policy-overview.html#target-tracking-cooldown) no *Guia do usuário do Application Auto Scaling*.
Configure o período de espera de sua política de ajuste de escala automático.
Se você não especificar um período de espera para as ações de reduzir a escala horizontalmente ou aumentar a escala horizontalmente, a política de ajuste de escala usa o padrão, que é 300 segundos para cada uma das ações.
Se as instâncias estiverem sendo adicionadas ou removidas muito rapidamente quando você testa sua configuração de ajuste de escala, pense em aumentar esse valor. Esse comportamento poderá ser percebido se o tráfego para o modelo tiver uma grande quantidade de picos, ou se houver várias políticas de ajuste de escala definidas para uma variante.
Se as instâncias não estiverem sendo adicionadas com rapidez suficiente para lidar com o aumento do tráfego, pense em diminuir esse valor.
## Recursos relacionados
Para obter mais informações sobre a configuração de ajuste de escala automático, consulte os recursos a seguir:
+ Seção [application-autoscaling](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling) da *Referência de comandos da AWS CLI *
+ [Referência à API do Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/APIReference/)
+ [Guia do usuário do Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/)
**nota**
SageMaker Recentemente, a IA introduziu novos recursos de inferência baseados em endpoints de inferência em tempo real. Você cria um endpoint de SageMaker IA com uma configuração de endpoint que define o tipo de instância e a contagem inicial de instâncias para o endpoint. Em seguida, crie um componente de inferência, que é um objeto de hospedagem de SageMaker IA que você pode usar para implantar um modelo em um endpoint. Para obter informações sobre como escalar componentes de inferência, consulte A [SageMaker IA adiciona novos recursos de inferência para ajudar a reduzir os custos e a latência de implantação do modelo básico e](https://aws.amazon.com/blogs/aws/amazon-sagemaker-adds-new-inference-capabilities-to-help-reduce-foundation-model-deployment-costs-and-latency/) [reduzir os custos de implantação do modelo em 50%, em média, usando os recursos mais recentes da SageMaker IA](https://aws.amazon.com/blogs/machine-learning/reduce-model-deployment-costs-by-50-on-average-using-sagemakers-latest-features/) no blog. AWS
# Pré-requisitos de ajuste de escala automático
Antes de usar o auto scaling, você já deve ter criado um endpoint do modelo Amazon SageMaker AI. Você pode ter várias versões de modelo para o mesmo endpoint. Cada modelo é chamado de [variante de produção (modelo)](model-ab-testing.md). Para mais informações sobre como implantar um endpoint de modelo, consulte [Implante o modelo nos serviços de hospedagem de SageMaker IA](ex1-model-deployment.md#ex1-deploy-model).
Para ativar o escalonamento automático para um modelo, você pode usar o console de SageMaker IA, o AWS Command Line Interface (AWS CLI) ou um AWS SDK por meio da API Application Auto Scaling.
+ Se essa for a primeira vez que você está configurando o ajuste de escala de um modelo, recomendamos [Configurar a ajuste de escala automático do modelo com o console](endpoint-auto-scaling-add-console.md).
+ Ao usar a API Application Auto Scaling AWS CLI ou a Application Auto Scaling, o fluxo é registrar o modelo como um alvo escalável, definir a política de escalabilidade e aplicá-la. **No console do SageMaker AI, em **Inferência** no painel de navegação, escolha Endpoints.** Encontre o nome do endpoint do modelo e, em seguida, selecione-o para encontrar o nome da variante. Você deve especificar ambos, o nome do endpoint e o nome da variante para ativar o ajuste de escala automático para um modelo.
O escalonamento automático é possível graças a uma combinação do Amazon SageMaker AI CloudWatch, Amazon e Application APIs Auto Scaling. Para obter informações sobre as permissões mínimas necessárias, consulte [Exemplos de políticas baseadas em identidade do Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/security_iam_id-based-policy-examples.html) no *Guia do Usuário do Application Auto Scaling*.
A política do IAM `SagemakerFullAccessPolicy` tem todas as permissões necessárias do IAM para executar o ajuste de escala automático. Para obter mais informações sobre as permissões do SageMaker AI IAM, consulte[Como usar funções de execução de SageMaker IA](sagemaker-roles.md).
Se você estiver usando a sua própria política de permissão personalizada, deverá incluir as seguintes permissões:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:UpdateEndpointWeightsAndCapacities"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/sagemaker.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint",
"Condition": {
"StringLike": { "iam:AWSServiceName": "sagemaker.application-autoscaling.amazonaws.com" }
}
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricAlarm",
"cloudwatch:DescribeAlarms",
"cloudwatch:DeleteAlarms"
],
"Resource": "*"
}
]
}
```
------
## Perfil vinculado a serviço
O Auto Scaling usa a função vinculada ao serviço `AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint`. Essa função vinculada ao serviço concede permissão ao Application Auto Scaling para descrever os alarmes das suas políticas, monitorar os níveis da capacidade atual e escalar a capacidade alvo. Esta função é criada automaticamente para você. Para que a criação automática da função seja bem-sucedida, é preciso ter permissão para a ação `iam:CreateServiceLinkedRole`. Para obter mais informações, consulte [Funções vinculadas ao serviço](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) no *Guia do usuário do Application Auto Scaling*.
# Configurar a ajuste de escala automático do modelo com o console
**Como configurar o ajuste de escala automático para um modelo (console)**
1. Abra o console Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, selecione **Inferência** e depois selecione **Endpoints**.
1. Escolha seu endpoint e, em seguida, nas **Configurações do runtime do Endpoint**, escolha a variante.
1. Escolha **Configurar o ajuste de escala automático**.
1. Na página **Configurar ajuste de escala automático da variante**, para o **Ajuste automático de escala da variante**, faça o seguinte:
1. Na **Contagem da instância mínima**, digite o número mínimo de instâncias que você quer que sejam mantidas na política de ajuste de escala. Pelo menos 1 instância é necessária.
1. Na **Contagem da instância máxima**, digite o número máximo de instâncias que você quer que sejam mantidas na política de ajuste de escala.
1. Para uma **política de ajuste de escala integrada**, faça o seguinte:
1. Para a **Métrica de destino**, `SageMakerVariantInvocationsPerInstance` é selecionada automaticamente para a métrica e não pode ser alterada.
1. Para o **Valor de destino**, digite o número médio de invocações por instância por minuto do modelo. Para determinar esse valor, siga as instruções em [Testes de carga](endpoint-scaling-loadtest.md).
1. (Opcional) Para **Espera ao reduzir a escala horizontalmente (segundos)** e **Espera ao aumentar a escala horizontalmente (segundos)**, insira a quantidade de tempo, em segundos, de cada período de espera.
1. (Opcional) Selecione **Desativar reduzir a escala horizontalmente** se você não quiser que o ajuste de escala automático encerre as instâncias na diminuição do tráfego.
1. Escolha **Salvar**.
Esse procedimento registra um modelo como um destino escalável com o Application Auto Scaling. Quando você registra um modelo, o Application Auto Scaling executa verificações de validação para confirmar se:
+ O modelo existe
+ As permissões são suficientes
+ Você não está registrando uma variante com uma instância de desempenho expansível, como a T2
**nota**
SageMaker A IA não oferece suporte ao escalonamento automático para instâncias com capacidade de intermitência, como T2, porque elas já permitem maior capacidade sob cargas de trabalho maiores. Para obter informações sobre as instâncias de desempenho expansível, consulte [Tipos de instância do Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
# Registrar um modelo
Antes de adicionar uma política de ajuste de escala ao seu modelo, primeiro você deve registrar seu modelo para ajuste de escala automático e definir os limites de ajuste de escala para o modelo.
Os procedimentos a seguir abordam como registrar um modelo (variante de produção) para escalonamento automático usando a AWS Command Line Interface (AWS CLI) ou a API Application Auto Scaling.
**Topics**
+ [Registrar um modelo (AWS CLI)](#endpoint-auto-scaling-add-cli)
+ [Registro de um modelo (API da aplicação Auto Scaling)](#endpoint-auto-scaling-add-api)
## Registrar um modelo (AWS CLI)
Para registrar sua variante de produção, use o [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)comando com os seguintes parâmetros:
+ `--service-namespace`: Defina esse valor como `sagemaker`.
+ `--resource-id`: O identificador de recurso para o modelo (especificamente, a variante de produção). Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante de produção. Por exemplo, .`endpoint/my-endpoint/variant/my-variant`
+ `--scalable-dimension`: Defina esse valor como `sagemaker:variant:DesiredInstanceCount`.
+ `--min-capacity`: O número mínimo de instâncias. Este valor deve ser definido como 1, pelo menos. Além disso, deve ser igual ou menor que o valor especificado para `max-capacity`.
+ `--max-capacity`: O número máximo de instâncias. Este valor deve ser definido como 1, pelo menos. Além disso, deve ser igual ou maior que o valor especificado para `min-capacity`.
**Example**
O exemplo a seguir mostra como registrar uma variante chamada `my-variant`, em execução no endpoint `my-endpoint`, que pode ser escalada dinamicamente para ter de uma a oito instâncias.
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--min-capacity 1 \
--max-capacity 8
```
## Registro de um modelo (API da aplicação Auto Scaling)
Para registrar seu cluster com o Application Auto Scaling, use a ação de API do [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) Application Auto Scaling com os seguintes parâmetros:
+ `ServiceNamespace`—Defina esse valor como `sagemaker`.
+ `ResourceID`: O identificador de recurso da variante de produção. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/my-endpoint/variant/my-variant`.
+ `ScalableDimension`—Defina esse valor como `sagemaker:variant:DesiredInstanceCount`.
+ `MinCapacity`: O número mínimo de instâncias. Este valor deve ser definido como 1, pelo menos. Além disso, deve ser igual ou menor que o valor especificado para `MaxCapacity`.
+ `MaxCapacity`: O número máximo de instâncias. Este valor deve ser definido como 1, pelo menos. Além disso, deve ser igual ou maior que o valor especificado para `MinCapacity`.
**Example**
O exemplo a seguir mostra como registrar uma variante chamada `my-variant`, em execução no endpoint `my-endpoint`, que pode ser escalada dinamicamente para usar uma a oito instâncias.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"MinCapacity": 1,
"MaxCapacity": 8
}
```
# Definir uma política de escalabilidade
Antes de adicionar a política de ajuste de escala ao modelo, salve a sua política de configuração como bloco JSON em um arquivo de texto. Você usa esse arquivo de texto ao invocar o AWS Command Line Interface (AWS CLI) ou a API Application Auto Scaling. Você pode otimizar o escalonamento escolhendo uma CloudWatch métrica apropriada. No entanto, antes de usar uma métrica personalizada na produção, você deve testar o ajuste de escala automático com sua métrica personalizada.
**Topics**
+ [Especifique uma métrica predefinida (CloudWatch métrica: InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined)
+ [Especifique uma métrica predefinida de alta resolução (CloudWatch métricas: ConcurrentRequestsPerModel e) ConcurrentRequestsPerCopy](#endpoint-auto-scaling-add-code-high-res)
+ [Defina uma métrica personalizada (CloudWatch métrica: CPUUtilization)](#endpoint-auto-scaling-add-code-custom)
+ [Defina uma métrica personalizada (CloudWatch métrica: ExplanationsPerInstance)](#endpoint-auto-scaling-online-explainability)
+ [Especificar os períodos de espera](#endpoint-auto-scaling-add-code-cooldown)
Esta seção mostra exemplos de configurações de políticas para políticas de ajuste de escala de rastreamento de destinos.
## Especifique uma métrica predefinida (CloudWatch métrica: InvocationsPerInstance)
**Example**
Veja a seguir um exemplo de configuração de política de rastreamento de metas para uma variante que mantém a média de invocações por instância em 70. Salve esta configuração em um arquivo chamado `config.json`.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
```
Para obter mais informações, consulte a Referência [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)da *API Application Auto Scaling*.
## Especifique uma métrica predefinida de alta resolução (CloudWatch métricas: ConcurrentRequestsPerModel e) ConcurrentRequestsPerCopy
Com as seguintes CloudWatch métricas de alta resolução, você pode definir políticas de escalabilidade para o volume de solicitações simultâneas que seus modelos recebem:
**ConcurrentRequestsPerModel**
O número de solicitações simultâneas recebidas por um contêiner modelo.
**ConcurrentRequestsPerCopy**
O número de solicitações simultâneas recebidas por um componente de inferência.
Essas métricas rastreiam o número de solicitações simultâneas que seus contêineres de modelo processam, incluindo as solicitações que estão enfileiradas dentro dos contêineres. Para modelos que enviam sua resposta de inferência como um fluxo de tokens, essas métricas rastreiam cada solicitação até que o modelo envie o último token da solicitação.
Como métricas de alta resolução, elas emitem dados com mais frequência do que as métricas padrão CloudWatch. Métricas padrão, como a métrica `InvocationsPerInstance`, emitem dados uma vez a cada minuto. No entanto, essas métricas de alta resolução emitem dados a cada 10 segundos. Portanto, à medida que aumenta o tráfego simultâneo para seus modelos, a reação de sua política é aumentar a escala horizontalmente muito mais rapidamente do que faria com as métricas padrão. No entanto, à medida que diminui o tráfego para seus modelos, a política de reduzir a escala horizontalmente segue na mesma velocidade que das métricas padrão.
Veja a seguir um exemplo de configuração da política de rastreamento de metas que adiciona instâncias se o número de solicitações simultâneas por modelo exceder 5. Salve esta configuração em um arquivo chamado `config.json`.
```
{
"TargetValue": 5.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantConcurrentRequestsPerModelHighResolution"
}
}
```
Se você usar componentes de inferência para implantar vários modelos no mesmo endpoint, poderá criar uma política equivalente. Neste caso, defina `PredefinedMetricType` para `SageMakerInferenceComponentConcurrentRequestsPerCopyHighResolution`.
Para obter mais informações, consulte a Referência [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)da *API Application Auto Scaling*.
## Defina uma métrica personalizada (CloudWatch métrica: CPUUtilization)
Para criar uma política de ajuste de escala do rastreamento de destinos com uma métrica personalizada, especifique o nome da métrica, o espaço nominal, a unidade, a estatística e zero ou mais dimensões. Uma dimensão consiste em um nome e um valor de dimensão. É possível usar qualquer métrica de variante de produção que mude na proporção da capacidade.
**Example**
O exemplo de configuração a seguir mostra uma política de ajuste de escala de rastreamento de destino com uma métrica personalizada. A política escala a variante com base na utilização média de 50 por cento da CPU em todas as instâncias. Salve esta configuração em um arquivo chamado `config.json`.
```
{
"TargetValue": 50.0,
"CustomizedMetricSpecification":
{
"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
Para obter mais informações, consulte a Referência [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)da *API Application Auto Scaling*.
## Defina uma métrica personalizada (CloudWatch métrica: ExplanationsPerInstance)
Quando a explicabilidade on-line do endpoint estiver ativada, ele emite a métrica `ExplanationsPerInstance` que gera o número médio de registros explicados por minuto, por instância, para uma variante. A utilização de recursos para explicar registros pode ser mais diferente da utilização de registros preditivos. É altamente recomendável usar essa métrica para o ajuste de escala de rastreamento de destinos de endpoints com a explicabilidade on-line ativada.
Você pode criar várias políticas de rastreamento de destinos para um destino escalável. Considere adicionar a política `InvocationsPerInstance` da seção [Especifique uma métrica predefinida (CloudWatch métrica: InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined) (adicionalmente à política `ExplanationsPerInstance`). Se a maioria das invocações não retornar uma explicação devido ao valor limite definido no parâmetro `EnableExplanations`, o endpoint poderá escolher a política `InvocationsPerInstance`. Se houver um grande número de explicações, o endpoint poderá usar a política `ExplanationsPerInstance`.
**Example**
O exemplo de configuração a seguir mostra uma política de escalabilidade de rastreamento de destino com uma métrica personalizada. A escala da política ajusta o número de instâncias das variantes de modo que cada instância tenha uma métrica `ExplanationsPerInstance` de 20. Salve esta configuração em um arquivo chamado `config.json`.
```
{
"TargetValue": 20.0,
"CustomizedMetricSpecification":
{
"MetricName": "ExplanationsPerInstance",
"Namespace": "AWS/SageMaker",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Sum"
}
}
```
Para obter mais informações, consulte a Referência [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)da *API Application Auto Scaling*.
## Especificar os períodos de espera
Opcionalmente, você pode definir períodos de espera na política de ajuste de escala com rastreamento de destino através a especificação dos parâmetros `ScaleOutCooldown` e `ScaleInCooldown`.
**Example**
Veja a seguir um exemplo de configuração de política de rastreamento de metas para uma variante que mantém a média de invocações por instância em 70. A configuração da política fornece um período de espera de reduzir a escala horizontalmente de 10 minutos (600 segundos) e em um período de espera de expansão de 5 minutos (300 segundos). Salve esta configuração em um arquivo chamado `config.json`.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
Para obter mais informações, consulte a Referência [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)da *API Application Auto Scaling*.
# Aplicar uma política de escalabilidade
Depois de registrar o modelo e definir uma política de ajuste de escala, aplique a política de ajuste de escala ao modelo registrado. Esta seção mostra como aplicar uma política de ajuste de escala com o uso de AWS Command Line Interface (AWS CLI) ou da API do Application Auto Scaling.
**Topics**
+ [Aplicar uma política de ajuste de escala de rastreamento de destino (AWS CLI)](#endpoint-auto-scaling-add-code-apply-cli)
+ [Aplique uma política de escalabilidade (Application Auto Scaling API)](#endpoint-auto-scaling-add-code-apply-api)
## Aplicar uma política de ajuste de escala de rastreamento de destino (AWS CLI)
Para aplicar uma política de escalabilidade ao seu modelo, use o [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) AWS CLI comando com os seguintes parâmetros:
+ `--policy-name`: O nome da política de ajuste de escala.
+ `--policy-type`: Defina esse valor como `TargetTrackingScaling`.
+ `--resource-id`: O identificador de recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, .`endpoint/my-endpoint/variant/my-variant`
+ `--service-namespace`: Defina esse valor como `sagemaker`.
+ `--scalable-dimension`: Defina esse valor como `sagemaker:variant:DesiredInstanceCount`.
+ `--target-tracking-scaling-policy-configuration`: A configuração da política de ajuste de escala de rastreamento de destino a ser usada para o modelo.
**Example**
O exemplo a seguir aplica a política de ajuste de escala de rastreamento de destino chamada `my-scaling-policy` a uma variante chamada `my-variant`, em execução no endpoint `my-endpoint`. Para a opção de `--target-tracking-scaling-policy-configuration`, especifique o arquivo `config.json` que você criou anteriormente.
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--target-tracking-scaling-policy-configuration file://config.json
```
## Aplique uma política de escalabilidade (Application Auto Scaling API)
Para aplicar uma política de escalabilidade a uma variante com a API Application Auto Scaling, use a ação de API do [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) Application Auto Scaling com os seguintes parâmetros:
+ `PolicyName`: O nome da política de ajuste de escala.
+ `ServiceNamespace`: Defina esse valor como `sagemaker`.
+ `ResourceID`: O identificador de recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, .`endpoint/my-endpoint/variant/my-variant`
+ `ScalableDimension`: Defina esse valor como `sagemaker:variant:DesiredInstanceCount`.
+ `PolicyType`: Defina esse valor como `TargetTrackingScaling`.
+ `TargetTrackingScalingPolicyConfiguration`: A configuração da política de ajuste de escala de rastreamento de destino a ser usada para a variante.
**Example**
O exemplo a seguir aplica a política de escalabilidade de rastreamento de destino chamada `my-scaling-policy` a uma variante chamada `my-variant`, em execução no endpoint `my-endpoint`. A configuração da política mantém a média de invocações por instância em 70.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
}
```
# Instruções para editar uma política de ajuste de escala
Depois de criar uma política de ajuste de escala, você pode atualizar qualquer uma de suas configurações, exceto o nome.
Para editar uma política de escalabilidade de rastreamento de metas com o Console de gerenciamento da AWS, use o mesmo procedimento que você costumava [Configurar a ajuste de escala automático do modelo com o console](endpoint-auto-scaling-add-console.md) usar.
Você pode usar a API Application Auto Scaling AWS CLI ou a Application Auto Scaling para editar uma política de escalabilidade da mesma forma que cria uma nova política de escalabilidade. Para obter mais informações, consulte [Aplicar uma política de escalabilidade](endpoint-auto-scaling-add-code-apply.md).
# Desative temporariamente as políticas de ajuste de escala
Depois de configurar o ajuste de escala automático, você tem as seguintes opções quando precisar investigar um problema sem interferência das políticas de ajuste de escala (ajuste de escala dinâmico):
+ Suspenda temporariamente e retome as atividades de escalabilidade chamando o comando da [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)CLI ou a ação [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)da API, especificando um valor booleano para e. `DynamicScalingInSuspended` `DynamicScalingOutSuspended`
**Example**
O exemplo a seguir mostra como suspender as políticas de ajuste de escala para uma variante chamada `my-variant`, em execução no endpoint `my-endpoint`.
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--suspended-state '{"DynamicScalingInSuspended":true,"DynamicScalingOutSuspended":true}'
```
+ Evite reduzir a escala horizontalmente da variante desabilitando a porção referente a reduzir a escala horizontalmente nas políticas específicas de ajuste de escala de rastreamento de destinos. Esse método impede que a política de ajuste de escala exclua as instâncias, enquanto ainda permite a criação delas conforme a necessidade.
Desative temporariamente e, em seguida, ative as atividades de expansão editando a política usando o comando da [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)CLI ou a ação da [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API, especificando um valor booleano para. `DisableScaleIn`
**Example**
Veja a seguir um exemplo de configuração de rastreamento de destino para uma política de ajuste de escala que pode aumentar a escala horizontalmente, mas não reduzir a escala horizontalmente.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"DisableScaleIn": true
}
```
# Excluir uma política de escalabilidade
Quando você não precisar mais de uma política de ajuste de escala, poderá excluí-la a qualquer momento.
**Topics**
+ [Exclua todas as políticas de ajuste de escala e cancele o registro do modelo (console)](#endpoint-auto-scaling-delete-console)
+ [Excluir uma política de escalabilidade (AWS CLI ou Application Auto Scaling API)](#endpoint-auto-scaling-delete-code)
## Exclua todas as políticas de ajuste de escala e cancele o registro do modelo (console)
**Para excluir todas as políticas de ajuste de escala e cancelar o registro da variante como um alvo escalável**
1. Abra o console Amazon SageMaker AI em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, escolha **Endpoints**.
1. Escolha seu endpoint e, em seguida, nas **Configurações do runtime do Endpoint**, escolha a variante.
1. Escolha **Configurar o ajuste de escala automático**.
1. Escolha **Cancelar registro de ajuste de escala automático**.
## Excluir uma política de escalabilidade (AWS CLI ou Application Auto Scaling API)
Você pode usar a API Application Auto Scaling AWS CLI ou a Application Auto Scaling para excluir uma política de escalabilidade de uma variante.
### Excluir uma política de escalabilidade (AWS CLI)
Para excluir uma política de escalabilidade de uma variante, use o [delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html)comando com os seguintes parâmetros:
+ `--policy-name`—O nome da política de escalabilidade.
+ `--resource-id`: O identificador de recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, .`endpoint/my-endpoint/variant/my-variant`
+ `--service-namespace`: Defina esse valor como `sagemaker`.
+ `--scalable-dimension`: Defina esse valor como `sagemaker:variant:DesiredInstanceCount`.
**Example**
O exemplo a seguir exclui uma política de ajuste de escala de rastreamento de destino chamada `my-scaling-policy` de uma variante chamada `my-variant`, em execução no endpoint `my-endpoint`.
```
aws application-autoscaling delete-scaling-policy \
--policy-name my-scaling-policy \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount
```
### Exclua uma política de escalabilidade (API do Application Auto Scaling)
Para excluir a política de escalabilidade da sua variante, use a ação [DeleteScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeleteScalingPolicy.html) da Application Auto Scaling API com os seguintes parâmetros:
+ `PolicyName`—O nome da política de escalabilidade.
+ `ServiceNamespace`: Defina esse valor como `sagemaker`.
+ `ResourceID`: O identificador de recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, .`endpoint/my-endpoint/variant/my-variant`
+ `ScalableDimension`: Defina esse valor como `sagemaker:variant:DesiredInstanceCount`.
**Example**
O exemplo a seguir exclui uma política de escalabilidade de rastreamento de destino chamada `my-scaling-policy` de uma variante chamada `my-variant`, em execução no endpoint `my-endpoint`.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount"
}
```
# Verificar o status de uma atividade de ajuste de escala na descrição das atividades de ajuste de escala
Você pode verificar o status de uma atividade de ajuste de escala do endpoint com ajuste de escala automático na descrição das respectivas atividades. O Application Auto Scaling fornece informações descritivas sobre as atividades de ajuste de escala no namespace especificado das seis semanas anteriores. Para obter mais informações, consulte as [Atividades de ajuste de escala do Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scaling-activities.html) no *Guia do usuário do Application Auto Scaling*.
Para verificar o status de uma atividade de escalabilidade, use o [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)comando. Você não pode verificar o status de uma atividade de ajuste de escala através do console.
**Topics**
+ [Descrição das atividades de ajuste de escala (AWS CLI)](#endpoint-how-to)
+ [Identifique as atividades do ajuste de escala automático bloqueado a partir das cotas de instância (AWS CLI)](#endpoint-identify-blocked-autoscaling)
## Descrição das atividades de ajuste de escala (AWS CLI)
Para descrever as atividades de escalabilidade de todos os recursos de SageMaker IA registrados no Application Auto Scaling, use [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)o comando, `sagemaker` especificando a opção. `--service-namespace`
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker
```
Para descrever as atividades de ajuste de escala de um recurso específico, inclua a opção `--resource-id`.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
O exemplo a seguir mostra o resultado alcançado com a execução desse comando.
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "string",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "string",
"StatusMessage": "string"
}
```
## Identifique as atividades do ajuste de escala automático bloqueado a partir das cotas de instância (AWS CLI)
Ao aumentar a escala horizontalmente (adicionar mais instâncias), você pode atingir sua cota de instâncias do nível da conta. Você pode usar o [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)comando para verificar se atingiu sua cota de instância. Quando você excede sua cota, o ajuste de escala automático é bloqueado.
Para verificar se você atingiu sua cota de instância, use o [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)comando e especifique o ID do recurso para a `--resource-id` opção.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
Na sintaxe de retorno, verifique as chaves [StatusCode](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusCode) e [StatusMessage](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusMessage) e seus valores associados. `StatusCode` devoluções `Failed`. Dentro de `StatusMessage`, há uma mensagem indicando que a cota de serviço no nível da conta foi atingida. Veja a seguir um exemplo da possível aparência que a mensagem pode ter:
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "minimum capacity was set to 110",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "Failed",
"StatusMessage": "Failed to set desired instance count to 110. Reason: The
account-level service limit 'ml.xx.xxxxxx for endpoint usage' is 1000
Instances, with current utilization of 997 Instances and a request delta
of 20 Instances. Please contact AWS support to request an increase for this
limit. (Service: AmazonSageMaker; Status Code: 400;
Error Code: ResourceLimitExceeded; Request ID: request-id)."
}
```
# Escalar um endpoint para zero instância
Ao configurar o ajuste de escala automático para um endpoint, é possível permitir que o processo de redução de escala horizontal diminua o número de instâncias em serviço para zero. Ao fazer isso, você reduz os custos durante os períodos em que o endpoint não está atendendo a solicitações de inferência e, portanto, não exige nenhuma instância ativa.
No entanto, depois de reduzir a escala horizontalmente para zero instância, seu endpoint não poderá responder a nenhuma solicitação de inferência de entrada enquanto ele não provisionar pelo menos uma instância. Para automatizar o processo de provisionamento, crie uma política de escalabilidade em etapas com o Application Auto Scaling. Em seguida, você atribui a política a um CloudWatch alarme da Amazon.
Depois de configurar a política de escalabilidade em etapas e o alarme, o endpoint provisionará automaticamente uma instância assim que receber uma solicitação de inferência à qual não consiga responder. Esteja ciente de que o processo de provisionamento leva alguns minutos. Durante esse período, qualquer tentativa de invocar o endpoint produzirá um erro.
Os procedimentos a seguir explicam como configurar o ajuste de escala automático de um endpoint para que ele tenha a escala reduzida horizontalmente para zero e aumentada horizontalmente a partir de zero instância. Os procedimentos usam comandos com a AWS CLI.
**Antes de começar**
Para que seu endpoint possa ter a escala reduzida horizontalmente para zero ou aumentada horizontalmente a partir de zero instância, ele deve atender aos seguintes requisitos:
+ Estar em serviço.
+ Hospedar um ou mais componentes de inferência. Um endpoint pode ser escalado de e para zero instância somente se hospedar componentes de inferência.
Para obter informações sobre como hospedar componentes de inferência em endpoints de SageMaker IA, consulte. [Implantar modelos para inferência em tempo real](realtime-endpoints-deploy-models.md)
+ Na configuração do endpoint, para o objeto `ManagedInstanceScaling` da variante de produção, você definiu o parâmetro `MinInstanceCount` como `0`.
Para obter informações de referência sobre esse parâmetro, consulte [ProductionVariantManagedInstanceScaling](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantManagedInstanceScaling.html).
**Como habilitar um endpoint para que reduza a escala horizontalmente para zero instância (AWS CLI)**
Para cada componente de inferência que o endpoint hospeda, faça o seguinte:
1. Registre o componente de inferência como um destino escalável. Ao registrá-lo, defina a capacidade mínima como `0`, conforme mostrado no seguinte comando:
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id inference-component/inference-component-name \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--min-capacity 0 \
--max-capacity n
```
Neste exemplo, *inference-component-name* substitua pelo nome do seu componente de inferência. *n*Substitua pelo número máximo de cópias do componente de inferência a serem provisionadas ao escalar.
Para obter mais informações sobre esse comando e cada um de seus parâmetros, consulte [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)na *Referência de AWS CLI Comandos*.
1. Aplique uma política de rastreamento de destino ao componente de inferência, conforme mostrado no seguinte comando:
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--target-tracking-scaling-policy-configuration file://config.json
```
Neste exemplo, *inference-component-name* substitua pelo nome do seu componente de inferência.
No exemplo, o arquivo `config.json` contém uma configuração de política de rastreamento de destino, como a seguinte:
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "SageMakerInferenceComponentInvocationsPerCopy"
},
"TargetValue": 1,
"ScaleInCooldown": 300,
"ScaleOutCooldown": 300
}
```
Para ver mais exemplos de configuração de política de rastreamento, consulte [Definir uma política de escalabilidade](endpoint-auto-scaling-add-code-define.md).
Para obter mais informações sobre esse comando e cada um de seus parâmetros, consulte [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)na *Referência de AWS CLI Comandos*.
**Como habilitar um endpoint para aumente a escala horizontalmente a partir de zero instância (AWS CLI)**
Para cada componente de inferência que o endpoint hospeda, faça o seguinte:
1. Aplique uma política de escalabilidade em etapas ao componente de inferência, conforme mostrado no seguinte comando:
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type StepScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--step-scaling-policy-configuration file://config.json
```
Neste exemplo, *my-scaling-policy* substitua por um nome exclusivo para sua política. *inference-component-name*Substitua pelo nome do seu componente de inferência.
No exemplo, o arquivo `config.json` contém uma configuração de política de escalabilidade em etapas, como a seguinte:
```
{
"AdjustmentType": "ChangeInCapacity",
"MetricAggregationType": "Maximum",
"Cooldown": 60,
"StepAdjustments":
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
}
```
Quando essa política de escalabilidade de etapas é acionada, a SageMaker IA provisiona as instâncias necessárias para dar suporte às cópias dos componentes de inferência.
Depois de criar a política de escalabilidade em etapas, anote o nome do recurso da Amazon (ARN). Você precisará do ARN para o CloudWatch alarme na próxima etapa.
Para ter mais informações sobre políticas de escalabilidade em etapas, consulte [Step scaling policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) no *Guia do usuário do Application Auto Scaling*.
1. Crie um CloudWatch alarme e atribua a ele a política de escalonamento de etapas, conforme mostrado no exemplo a seguir:
```
aws cloudwatch put-metric-alarm \
--alarm-actions step-scaling-policy-arn \
--alarm-description "Alarm when SM IC endpoint invoked that has 0 instances." \
--alarm-name ic-step-scaling-alarm \
--comparison-operator GreaterThanThreshold \
--datapoints-to-alarm 1 \
--dimensions "Name=InferenceComponentName,Value=inference-component-name" \
--evaluation-periods 1 \
--metric-name NoCapacityInvocationFailures \
--namespace AWS/SageMaker \
--period 60 \
--statistic Sum \
--threshold 1
```
Neste exemplo, *step-scaling-policy-arn* substitua pelo ARN da sua política de escalonamento de etapas. *ic-step-scaling-alarm*Substitua por um nome de sua escolha. *inference-component-name*Substitua pelo nome do seu componente de inferência.
Este exemplo define o `--metric-name` parâmetro como`NoCapacityInvocationFailures`. SageMaker A IA emite essa métrica quando um endpoint recebe uma solicitação de inferência, mas o endpoint não tem instâncias ativas para atender à solicitação. Quando esse evento ocorre, o alarme inicia a política de escalabilidade em etapas na etapa anterior.
Para obter mais informações sobre esse comando e cada um de seus parâmetros, consulte [put-metric-alarm](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/put-metric-alarm.html)na *Referência de AWS CLI Comandos*.
# Testes de carga da configuração de ajuste de escala automático
Execute testes de carga para escolher uma configuração de ajuste de escala que funcione da maneira desejada.
As seguintes diretrizes para testes de carga presumem que você está utilizando uma política de ajuste de escala automática que utiliza a métrica de destino predefinida `SageMakerVariantInvocationsPerInstance`:
**Topics**
+ [Determinar as características de desempenho](#endpoint-scaling-loadtest-variant)
+ [Calcular a carga do destino](#endpoint-scaling-loadtest-calc)
## Determinar as características de desempenho
Execute testes de carga para encontrar o pico `InvocationsPerInstance` com o qual a variante de produção do modelo pode lidar, bem como a latência das solicitações à medida que a simultaneidade aumenta.
Esse valor depende do tipo de instância escolhido, das cargas úteis que os clientes do modelo normalmente enviam, e do desempenho de qualquer dependência externa que o modelo tem.
**Para encontrar o pico requests-per-second (RPS), a variante de produção do seu modelo pode lidar com a latência das solicitações**
1. Configure um endpoint com o modelo usando uma única instância. Para obter informações sobre como configurar um endpoint, consulte [Implante o modelo nos serviços de hospedagem de SageMaker IA](ex1-model-deployment.md#ex1-deploy-model).
1. Use uma ferramenta de teste de carregamento para gerar um número crescente de solicitações paralelas e monitorar o RPS e a latência do modelo no resultado gerado pela ferramenta.
**nota**
Você também pode monitorar requests-per-minute em vez do RPS. Nesse caso, na equação, não multiplique por 60 para calcular o `SageMakerVariantInvocationsPerInstance` mostrado abaixo.
Quando a latência do modelo aumenta ou a proporção de transações bem-sucedidas diminui, trata-se do pico RPS que o modelo pode processar.
## Calcular a carga do destino
Depois de encontrar as características de desempenho da variante, você pode determinar o RPS máximo a ser enviado para uma instância. O limite usado para a escalabilidade deve ser menor que esse valor máximo. Use a seguinte equação em combinação com os testes de carga para determinar o valor correto da métrica de destino `SageMakerVariantInvocationsPerInstance` na configuração de ajuste de escala automático:
```
SageMakerVariantInvocationsPerInstance = (MAX_RPS * SAFETY_FACTOR) * 60
```
Onde `MAX_RPS` é o RPS máximo determinado anteriormente, e `SAFETY_FACTOR` é o fator de segurança escolhido para evitar que seus clientes excedam esse RPS máximo. Multiplique por 60 para converter de RPS em para corresponder invocations-per-minute à CloudWatch métrica por minuto que a SageMaker IA usa para implementar o escalonamento automático (você não precisa fazer isso se mediu requests-per-minute em vez de). requests-per-second
**nota**
SageMaker A IA recomenda que você comece o teste com 0,5. `SAFETY_FACTOR` Teste a sua configuração de ajuste de escala para verificar se ela funciona com o seu modelo da maneira esperada, no aumento e na diminuição do tráfego de clientes no seu endpoint.
# Use CloudFormation para criar uma política de escalabilidade
O exemplo a seguir mostra como configurar um ajuste de escala automático do modelo em um endpoint usando o CloudFormation.
```
Endpoint:
Type: "AWS::SageMaker::Endpoint"
Properties:
EndpointName: yourEndpointName
EndpointConfigName: yourEndpointConfigName
ScalingTarget:
Type: "AWS::ApplicationAutoScaling::ScalableTarget"
Properties:
MaxCapacity: 10
MinCapacity: 2
ResourceId: endpoint/my-endpoint/variant/my-variant
RoleARN: arn
ScalableDimension: sagemaker:variant:DesiredInstanceCount
ServiceNamespace: sagemaker
ScalingPolicy:
Type: "AWS::ApplicationAutoScaling::ScalingPolicy"
Properties:
PolicyName: my-scaling-policy
PolicyType: TargetTrackingScaling
ScalingTargetId:
Ref: ScalingTarget
TargetTrackingScalingPolicyConfiguration:
TargetValue: 70.0
ScaleInCooldown: 600
ScaleOutCooldown: 30
PredefinedMetricSpecification:
PredefinedMetricType: SageMakerVariantInvocationsPerInstance
```
Para obter mais informações, consulte [Criar recursos do Application Auto Scaling com AWS CloudFormation](https://docs.aws.amazon.com/autoscaling/application/userguide/creating-resources-with-cloudformation.html) no *Guia do usuário do Application Auto Scaling*.
# Atualizar endpoints que usam o ajuste de escala automático
Quando você atualiza um endpoint, o Application Auto Scaling verifica se algum dos modelos nesse endpoint são destinos do ajuste de escala automático. Se a atualização alterar o tipo de instância de qualquer modelo que esteja submetido ao ajuste de escala automático, o procedimento falhará.
No Console de gerenciamento da AWS, você vê um aviso de que deve cancelar o registro do modelo do escalonamento automático antes de poder atualizá-lo. Se você estiver tentando atualizar o endpoint chamando a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), a chamada falhará. Antes de atualizar o endpoint, exclua todas as políticas de escalabilidade configuradas para ele e cancele o registro da variante como um destino escalável chamando a ação da API Application Auto Scaling [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html). Depois de atualizar o endpoint, você pode registrar a variante atualizada como um destino escalável e anexar uma política de ajuste de escala.
Há uma exceção. Se você alterar o modelo de uma variante configurada para escalonamento automático, o Amazon SageMaker AI Auto Scaling permitirá a atualização. Isso porque a alteração do modelo normalmente não afeta o desempenho a ponto de alterar o comportamento de ajuste de escala. Se você atualizar um modelo de uma variante configurada para o ajuste de escala automático, a alteração do modelo não poderá afetar significativamente o desempenho e o comportamento do ajuste de escala.
Ao atualizar os endpoints de SageMaker IA que têm o escalonamento automático aplicado, conclua as seguintes etapas:
**Como atualizar um endpoint que possui o ajuste de escala automático aplicado**
1. Cancele o registro do endpoint como um alvo escalável ligando para. [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)
1. Devido ao ajuste de escala automático ser bloqueado durante a operação de atualização em andamento (ou caso você tenha desativado o ajuste de escala automático na etapa anterior), convém tomar a precaução adicional de aumentar o número de instâncias de seu endpoint durante a atualização. Para fazer isso, atualize as contagens de instâncias para as variantes de produção hospedadas no endpoint, chamando [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html).
1. Chame [ DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) repetidamente até que o valor no campo `EndpointStatus` da resposta seja `InService`.
1. Chame [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) para obter os valores da configuração do endpoint atual.
1. Crie uma configuração de endpoint chamando [ CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). Para as variantes de produção nas quais você deseja manter a contagem ou peso de instâncias existentes, use o mesmo nome de variante da resposta da chamada para [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) na etapa anterior. Para todos os outros valores, use os valores que você obteve como resposta ao chamar [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) na etapa anterior.
1. Atualize o endpoint chamando [ UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Especifique a configuração do endpoint criado na etapa anterior no campo `EndpointConfig`. Se você quiser reter as propriedades da variante, como contagem de instâncias ou peso, defina o valor do parâmetro `RetainAllVariantProperties` como `True`. Isso especifica que as variantes de produção com o mesmo nome serão atualizadas com a `DesiredInstanceCount` mais recente da resposta da chamada para `DescribeEndpoint`, independentemente dos valores do campo `InitialInstanceCount` no novo `EndpointConfig`.
1. (Opcional) Reative o escalonamento automático ligando para e. [RegisterScalableTarget[PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)
**nota**
As etapas 1 e 7 são necessárias somente se você estiver atualizando um endpoint com as seguintes alterações:
Alteração do tipo de instância de uma variante de produção da qual foi configurado o ajuste de escala automático
Remoção de uma variante de produção que tem o ajuste de escala automático configurado.
# Excluir endpoints configurados para o ajuste de escala automático
Quando você excluir um endpoint, o Application Auto Scaling verificará se algum dos modelos desse endpoint são destinos do ajuste de escala automático. Se algum for e você tiver permissão para cancelar o registro do modelo, o Application Auto Scaling fará o cancelamento e esses modelos deixarão de ser destinos escaláveis, sem que você seja notificado. Se você usa uma política de permissão personalizada que não fornece permissão para a [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)ação, você deve solicitar acesso a essa ação antes de excluir o endpoint.
**nota**
Como um usuário do IAM, talvez você não tenha permissão suficiente para excluir um endpoint se outro usuário tiver configurado o ajuste de escala automático de uma variante nesse endpoint.
# volumes do armazenamento de instâncias
Ao criar um endpoint, o Amazon SageMaker AI associa um volume de armazenamento do Amazon Elastic Block Store (Amazon EBS) às instâncias do Amazon EC2 que hospedam o endpoint. O tamanho do volume de armazenamento é escalável e as opções de armazenamento são divididas em duas categorias: armazenamento baseado em SSD e em HDD.
Para obter mais informações sobre armazenamentos e atributos do Amazon EBS consulte as seguintes páginas:
+ [Atributos do Amazon EBS](https://aws.amazon.com/ebs/features/)
+ [ Guia do usuário EBS da Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)
Para obter uma lista completa dos volumes de armazenamento de instância do host, consulte [Tabela de volumes de armazenamento de instância do host](https://aws.amazon.com/releasenotes/host-instance-storage-volumes-table/)
**nota**
O Amazon SageMaker AI associa um volume de armazenamento do Amazon Elastic Block Store (Amazon EBS) às instâncias do Amazon EC2 somente quando você cria tipos de endpoint [Inferência assíncrona](async-inference.md) ou [Inferência em tempo real](realtime-endpoints.md). Para obter mais informações sobre a personalização do volume de armazenamento do Amazon EBS, consulte [Parâmetros de endpoint do SageMaker AI para inferência de grandes modelos](large-model-inference-hosting.md).
# Validação de modelos em produção
O SageMaker AI permite testar vários modelos ou versões de modelo por trás do mesmo endpoint usando variantes de produção. Uma variante consiste em uma instância de ML e nos componentes de serviço especificados em um modelo do SageMaker AI. Você pode ter várias variantes por trás de um endpoint. Cada variante pode ter um tipo de instância diferente ou um modelo do SageMaker AI que pode ser escalado de forma automática independentemente dos outros. Os modelos dentro das variantes podem ser treinados usando conjuntos de dados diferentes, algoritmos diferentes, estruturas de ML diferentes ou qualquer combinação destes. Todas as variantes por trás de um endpoint compartilham o mesmo código de inferência. O SageMaker AI oferece permite dois tipos de variante: de produção e de sombra.
Se você tiver várias variantes de produção por trás de um endpoint, poderá alocar uma parte de suas solicitações de inferência para cada variante. Cada solicitação é encaminhada para somente uma das variantes de produção. A variante de produção para a qual a solicitação foi roteada fornece a resposta ao chamador. Você pode comparar o desempenho das variantes de produção em relação umas às outras.
Você também pode ter uma variante de sombra correspondente a uma variante de produção por trás de um endpoint. Uma parte das solicitações de inferência que vão para a variante de produção é replicada para a variante sombra. As respostas da variante sombra são registradas para comparação e não são devolvidas ao chamador. Isso permite testar o desempenho da variante de sombra sem expor o chamador à resposta produzida pela variante de sombra.
**Topics**
+ [Teste de modelos com variantes de produção](model-ab-testing.md)
+ [Teste de modelos com variantes de sombra](model-shadow-deployment.md)
# Teste de modelos com variantes de produção
Nos fluxos de trabalho de ML de produção, engenheiros e cientistas de dados frequentemente tentam melhorar o desempenho de várias maneiras, como realizando [Ajuste automático do modelo com SageMaker IA](automatic-model-tuning.md), treinando em dados adicionais ou mais recentes e melhorando a seleção de atributos usando instâncias atualizadas e contêineres de serviço. Você pode usar variantes de produção para comparar seus modelos, instâncias e contêineres e escolher o candidato com melhor desempenho para responder às solicitações de inferência.
Com os endpoints multivariantes de SageMaker IA, você pode distribuir solicitações de invocação de endpoints em várias variantes de produção, fornecendo a distribuição do tráfego para cada variante, ou você pode invocar uma variante específica diretamente para cada solicitação. Neste tópico, analisamos ambos os métodos para testar modelos de ML.
**Topics**
+ [Testar modelos especificando a distribuição de tráfego](#model-testing-traffic-distribution)
+ [Testar modelos invocando variantes específicas](#model-testing-target-variant)
+ [Exemplo de A/B teste de modelo](#model-ab-test-example)
## Testar modelos especificando a distribuição de tráfego
Para testar vários modelos distribuindo o tráfego entre eles, especifique a porcentagem do tráfego que é roteada para cada modelo especificando o peso de cada variante de produção na configuração do endpoint. Para mais informações, consulte [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). O diagrama a seguir mostra como isso funciona mais detalhadamente.
![\[Exemplo mostrando como a distribuição de tráfego entre modelos usando InvokeEndpoint funciona na SageMaker IA.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-traffic-distribution.png)
## Testar modelos invocando variantes específicas
Para testar vários modelos invocando modelos específicos para cada solicitação, especifique a versão específica do modelo que você deseja invocar fornecendo um valor para o `TargetVariant` parâmetro ao chamar. [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) SageMaker A IA garante que a solicitação seja processada pela variante de produção que você especificar. Se você já forneceu distribuição de tráfego e especificou um valor para o parâmetro `TargetVariant`, o roteamento direcionado substituirá a distribuição de tráfego aleatória. O diagrama a seguir mostra como isso funciona mais detalhadamente.
![\[Exemplo mostrando como a invocação de modelos específicos para cada solicitação usando InvokeEndpoint funciona na SageMaker IA.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-target-variant.png)
## Exemplo de A/B teste de modelo
Realizar A/B testes entre um modelo novo e um modelo antigo com tráfego de produção pode ser uma etapa final eficaz no processo de validação de um novo modelo. Nos A/B testes, você testa diferentes variantes de seus modelos e compara o desempenho de cada variante. Se a versão mais recente do modelo oferecer umo desempenho melhor do que a versão existente anterior, substitua a versão antiga do modelo pela nova versão em produção.
O exemplo a seguir mostra como realizar testes de A/B modelo. Para obter uma amostra de caderno que implementa esse exemplo, consulte [A/B Testing ML models in production](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_endpoints/a_b_testing/a_b_testing.html).
### Etapa 1: Criar e implantar modelos
Primeiro, definimos onde nossos modelos estão localizados no Amazon S3. Esses locais são usados quando implantamos nossos modelos em etapas subsequentes:
```
model_url = f"s3://{path_to_model_1}"
model_url2 = f"s3://{path_to_model_2}"
```
Depois, criamos os objetos do modelo com a imagem e os dados do modelo. Esses objetos do modelo são usados para implantar variantes de produção em um endpoint. Os modelos são desenvolvidos treinando modelos de ML em conjuntos de dados diferentes, em algoritmos ou estruturas de trabalho de ML diferentes e em hiperparâmetros diferentes:
```
from sagemaker.amazon.amazon_estimator import get_image_uri
model_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
model_name2 = f"DEMO-xgb-churn-pred2-{datetime.now():%Y-%m-%d-%H-%M-%S}"
image_uri = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-1')
image_uri2 = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-2')
sm_session.create_model(
name=model_name,
role=role,
container_defs={
'Image': image_uri,
'ModelDataUrl': model_url
}
)
sm_session.create_model(
name=model_name2,
role=role,
container_defs={
'Image': image_uri2,
'ModelDataUrl': model_url2
}
)
```
Agora criamos duas variantes de produção, cada uma com seus próprios requisitos de modelo e recurso diferentes (contagens e tipo de instância). Isso permite que você também teste modelos em tipos de instância diferentes.
Definimos um initial\$1weight de 1 para ambas as variantes. Isso significa que 50% das solicitações vão para a `Variant1` e os 50% restantes das solicitações vão para a `Variant2`. A soma dos pesos em ambas as variantes é 2 e cada variante tem atribuição de peso de 1. Isso significa que cada variante recebe 1/2, ou 50%, do tráfego total.
```
from sagemaker.session import production_variant
variant1 = production_variant(
model_name=model_name,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant1',
initial_weight=1,
)
variant2 = production_variant(
model_name=model_name2,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant2',
initial_weight=1,
)
```
Finalmente, estamos prontos para implantar essas variantes de produção em um endpoint de SageMaker IA.
```
endpoint_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
print(f"EndpointName={endpoint_name}")
sm_session.endpoint_from_production_variants(
name=endpoint_name,
production_variants=[variant1, variant2]
)
```
### Etapa 2: Invocar os modelos implantados
Agora enviamos solicitações a esse endpoint para obter inferências em tempo real. Usamos distribuição de tráfego e direcionamento direto.
Primeiro, usamos a distribuição de tráfego configurada na etapa anterior. Cada resposta de inferência contém o nome da variante de produção que processa a solicitação, para que possamos ver que o tráfego para as duas variantes de produção é aproximadamente igual.
```
# get a subset of test data for a quick test
!tail -120 test_data/test-dataset-input-cols.csv > test_data/test_sample_tail_input_cols.csv
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload
)
time.sleep(0.5)
print("Done!")
```
SageMaker A IA emite métricas como `Latency` e `Invocations` para cada variante na Amazon CloudWatch. Para obter uma lista completa das métricas que a SageMaker IA emite, consulte[Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md). Vamos consultar CloudWatch para obter o número de invocações por variante, para mostrar como as invocações são divididas entre as variantes por padrão:
![\[Exemplo de CloudWatch número de invocações por variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-variant-invocations.png)
Agora vamos invocar uma versão específica do modelo especificando `Variant1` como a `TargetVariant` na chamada para `invoke_endpoint`.
```
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload,
TargetVariant="Variant1"
)
time.sleep(0.5)
```
Para confirmar que todas as novas invocações foram processadas por`Variant1`, podemos consultar CloudWatch para obter o número de invocações por variante. Vemos que, para as invocações mais recentes (timestamp mais recente), todas as solicitações foram processadas pela `Variant1`, como tínhamos especificado. Não foram feitas invocações para a `Variant2`.
![\[Exemplo de CloudWatch número de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-target1.png)
### Etapa 3: Avalie o desempenho do modelo
Para ver qual versão do modelo tem melhor desempenho, vamos avaliar a exatidão, a precisão, o recall, a pontuação F1 e o receptor operando charactersistic/Area sob a curva para cada variante. Primeiro, vamos ver essas métricas para a `Variant1`:
![\[Exemplo de gráfico de curva característica de operação do receptor para Variant1.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-curve.png)
Agora vamos ver as métricas para a `Variant2`:
![\[Exemplo de gráfico de curva característica de operação do receptor para Variant2.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model2-curve.png)
Para a maioria de nossas métricas definidas, o desempenho da `Variant2` é melhor, então essa é a que queremos usar na produção.
### Etapa 4: Aumentar o tráfego para o melhor modelo
Agora que determinamos que a `Variant2` tem um desempenho melhor do que a `Variant1`, deslocamos mais tráfego para ela. Podemos continuar usando para `TargetVariant` invocar uma variante de modelo específica, mas uma abordagem mais simples é atualizar os pesos atribuídos a cada variante chamando. [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) Isso altera a distribuição de tráfego para as variantes de produção sem exigir atualizações ao endpoint. Lembre-se da seção de configuração que definimos pesos variantes para dividir o tráfego 50/50. As CloudWatch métricas do total de invocações para cada variante abaixo nos mostram os padrões de invocação de cada variante:
![\[CloudWatch Métricas de exemplo para o total de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-even-dist.png)
Agora, transferimos 75% do tráfego para `Variant2` atribuindo novos pesos a cada variante usando. `UpdateEndpointWeightsAndCapacities` SageMaker A IA agora envia 75% das solicitações de inferência para `Variant2` e 25% das solicitações restantes para`Variant1`.
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 25,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 75,
"VariantName": variant2["VariantName"]
}
]
)
```
As CloudWatch métricas do total de invocações para cada variante nos mostram mais invocações para do que para: `Variant2` `Variant1`
![\[CloudWatch Métricas de exemplo para o total de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-75-25.png)
Podemos continuar monitorando nossas métricas e, quando estivermos satisfeitos com o desempenho de uma variante, podemos rotear 100% do tráfego para essa variante. Usamos [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) para atualizar as atribuições de tráfego para as variantes. O peso para `Variant1` é definido como 0 e o peso para `Variant2` é definido como 1. SageMaker A IA agora envia 100% de todas as solicitações de inferência para o. `Variant2`
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 0,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 1,
"VariantName": variant2["VariantName"]
}
]
)
```
As CloudWatch métricas do total de invocações para cada variante mostram que todas as solicitações de inferência estão sendo processadas `Variant2` e não há solicitações de inferência processadas por. `Variant1`
![\[CloudWatch Métricas de exemplo para o total de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-best-model.png)
Agora é possível atualizar o endpoint com segurança e excluir a `Variant1` do endpoint. Também é possível continuar testando novos modelos em produção adicionando novas variantes ao endpoint e seguindo as etapas de 2 a 4.
# Teste de modelos com variantes de sombra
Você pode usar as implantações de sombra de modelo do SageMaker AI para criar variantes de sombra de longa duração e validar qualquer novo componente possível da sua pilha de serviços de modelos antes de promovê-lo à produção. O diagrama a seguir mostra como as variantes de sombra funcionam mais detalhadamente.
![\[Detalhes de uma variante de sombra.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/juxtaposer/shadow-variant.png)
## Implemente variantes de sombra
O exemplo de código a seguir mostra como você pode implantar programaticamente variantes de sombra. Substitua o *texto do espaço reservado* na política de exemplo por suas próprias informações.
1. Crie dois modelos do SageMaker AI: um para sua variante de produção e outro para sua variante de sombra.
```
import boto3
from sagemaker import get_execution_role, Session
aws_region = "aws-region"
boto_session = boto3.Session(region_name=aws_region)
sagemaker_client = boto_session.client("sagemaker")
role = get_execution_role()
bucket = Session(boto_session).default_bucket()
model_name1 = "name-of-your-first-model"
model_name2 = "name-of-your-second-model"
sagemaker_client.create_model(
ModelName = model_name1,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-first-model",
"ModelDataUrl": "s3-location-of-trained-first-model"
}
]
)
sagemaker_client.create_model(
ModelName = model_name2,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-second-model",
"ModelDataUrl": "s3-location-of-trained-second-model"
}
]
)
```
1. Crie uma configuração de endpoint. Especifique suas variantes de produção e de sombra na configuração.
```
endpoint_config_name = name-of-your-endpoint-config
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": name-of-your-production-variant,
"ModelName": model_name1,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
],
ShadowProductionVariants=[
{
"VariantName": name-of-your-shadow-variant,
"ModelName": model_name2,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
]
)
```
1. Crie um endpoint do .
```
create_endpoint_response = sm.create_endpoint(
EndpointName=name-of-your-endpoint,
EndpointConfigName=endpoint_config_name,
)
```
# Explicabilidade on-line com Clarify SageMaker
Este guia mostra como configurar a explicabilidade on-line com SageMaker o Clarify. Com os endpoints de [inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) de SageMaker IA, você pode analisar a explicabilidade em tempo real, continuamente. A função de explicabilidade on-line se encaixa na parte **Deploy to production** do fluxo de trabalho do [Amazon SageMaker AI Machine Learning](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-mlconcepts.html).
## Como funciona a explicabilidade on-line do Clarify
O gráfico a seguir mostra a arquitetura de SageMaker IA para hospedar um endpoint que atende a solicitações de explicabilidade. Ele descreve as interações entre um endpoint, o contêiner do modelo e o explicador do SageMaker Clarify.
![\[SageMaker Arquitetura de IA mostrando a hospedagem de um endpoint que atende a solicitações de explicabilidade sob demanda.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/clarify/DeveloperGuideArchitecture.png)
Veja como funciona a explicabilidade on-line do Clarify. O aplicativo envia uma `InvokeEndpoint` solicitação no estilo REST para o SageMaker AI Runtime Service. O serviço encaminha essa solicitação para um endpoint de SageMaker IA para obter previsões e explicações. Em seguida, o serviço recebe a resposta do endpoint. Por fim, o serviço envia a resposta de volta para a aplicação.
Para aumentar a disponibilidade do endpoint, a SageMaker IA tenta distribuir automaticamente as instâncias do endpoint em várias zonas de disponibilidade, de acordo com a contagem de instâncias na configuração do endpoint. Em uma instância de endpoint, após uma nova solicitação de explicabilidade, o explicador do SageMaker Clarify chama o contêiner do modelo para fazer previsões. Em seguida, ele calcula e retorna as atribuições do atributo.
Aqui estão as quatro etapas para criar um endpoint que usa a explicabilidade on-line do SageMaker Clarify:
1. [Verifique se seu modelo de SageMaker IA pré-treinado é compatível com a explicabilidade on-line seguindo as etapas de pré-verificação.](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html)
1. [Crie uma configuração de endpoint com a configuração](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) SageMaker explicativa do Clarify usando a API. `CreateEndpointConfig`
1. [Crie um endpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) e forneça a configuração do endpoint para a SageMaker IA usando a `CreateEndpoint` API. O serviço inicia a instância de cálculo de ML e implanta o modelo conforme especificado na configuração.
1. [Invoque o endpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html): depois que o endpoint estiver em serviço, chame a API SageMaker AI Runtime `InvokeEndpoint` para enviar solicitações ao endpoint. O endpoint então retorna explicações e predições.
# Verifique previamente o recipiente modelo
Esta seção mostra como verificar previamente a compatibilidade das entradas e saídas do contêiner do modelo antes de configurar um endpoint. O SageMaker explicador do Clarify é **independente do modelo**, mas tem requisitos para entrada e saída do contêiner do modelo.
**nota**
Você pode aumentar a eficiência configurando seu contêiner para oferecer compatibilidade com solicitações em lote, que oferecem apoio a dois ou mais registros em uma única solicitação. Por exemplo, um único registro é uma única linha de dados CSV ou uma única linha de dados de linhas JSON. SageMaker O Clarify tentará enviar primeiro um pequeno lote de registros para o contêiner do modelo, antes de retornar às solicitações de registro único.
## Entrada de contêiner de modelo
------
#### [ CSV ]
O contêiner do modelo é compatível com entrada em CSV com o tipo MIME: `text/csv`. A tabela a seguir mostra exemplos de entradas compatíveis com o SageMaker Clarify.
| Entrada de contêiner do modelo (representação de string) | Comentários |
| --- | --- |
| '1,2,3,4' | Registro único que usa quatro atributos numéricos. |
| '1,2,3,4\$1n5,6,7,8' | Dois registros, separados por quebra de linha '\$1n'. |
| '"Este é um bom produto",5' | Registro único que contém um atributo de texto e um atributo numérico. |
| '"Este é um bom produto",5\$1n"Experiência de compra ruim",1' | Dois registros. |
------
#### [ JSON Lines ]
SageMaker O AI também suporta entrada no [formato denso de linhas JSON](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines) com o tipo MIME:`application/jsonlines`, conforme mostrado na tabela a seguir.
| Entrada de contêiner de modelo | Comentários |
| --- | --- |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1' | Registro único; uma lista de recursos pode ser extraída por JMESPath expressão`data.features`. |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1\$1n\$1"data":\$1"features":[5,6,7,8]\$1\$1' | Dois registros. |
| '\$1"features":["Este é um bom produto",5]\$1' | Registro único; uma lista de recursos pode ser extraída por JMESPath expressão`features`. |
| '\$1"features":["Este é um bom produto",5]\$1\$1n\$1"features":["Experiência de compra ruim",1]\$1' | Dois registros. |
------
## Entrada de contêiner de modelo
A saída do contêiner do modelo também deve estar no formato denso CSV ou JSON Lines. Além disso, o contêiner do modelo deve incluir as probabilidades dos registros de entrada, que o SageMaker Clarify usa para calcular as atribuições de recursos.
Os exemplos de dados a seguir são para saídas de contêiner de modelo no **formato CSV**.
------
#### [ Probability only ]
Para problemas de regressão e classificação binária, o contêiner do modelo gera um único valor de probabilidade (pontuação) do rótulo previsto. Essas probabilidades podem ser extraídas usando o índice da coluna 0. Para problemas de várias classes, o contêiner do modelo gera uma lista de probabilidades (pontuações). Para problemas de várias classes, se nenhum índice for fornecido, todos os valores serão extraídos.
| Entrada de contêiner de modelo | Saída do contêiner do modelo (representação de string) |
| --- | --- |
| Registro único | '0.6' |
| Dois registros (resultados em uma linha) | '0.6,0.3' |
| Dois registros (resultados em duas linhas) | '0.6\$1n0.3' |
| Registro único de um modelo multiclasse (três classes) | '0.1,0.6,0.3' |
| Dois registros de um modelo multiclasse (três classes) | '0.1,0.6,0.3\$1n0.2,0.5,0.3' |
------
#### [ Predicted label and probabilities ]
O contêiner do modelo gera o rótulo previsto seguido por sua probabilidade no **formato CSV**. As probabilidades podem ser extraídas usando o índice `1`.
| Entrada de contêiner de modelo | Entrada de contêiner de modelo |
| --- | --- |
| Registro único | '1,0.6' |
| Dois registros | '1,0.6\$1n0,0.3' |
------
#### [ Predicted labels header and probabilities ]
Um contêiner de modelo multiclasse treinado pelo Autopilot pode ser configurado para gerar **a representação em sequência** da lista de rótulos e probabilidades previstos no formato **CSV**. No exemplo a seguir, as probabilidades podem ser extraídas por índice `1`. Os cabeçalhos dos rótulos podem ser extraídos pelo índice `1` e os cabeçalhos dos rótulos podem ser extraídos usando o índice `0`.
| Entrada de contêiner de modelo | Entrada de contêiner de modelo |
| --- | --- |
| Registro único | '"[\$1'gato\$1',\$1'cachorro\$1',\$1'peixe\$1']","[0.1,0.6,0.3]"' |
| Dois registros | '"[\$1'gato\$1',\$1'cachorro\$1',\$1'peixe\$1']", "[0.1,0.6,0.3]"\$1n"[\$1'gato\$1',\$1'cachorro\$1',\$1'peixe\$1']","[0.2,0.5,0.3]"' |
------
Os exemplos de dados a seguir são para saídas de contêineres de modelos no formato **JSON Lines**.
------
#### [ Probability only ]
Neste exemplo, o contêiner do modelo gera a probabilidade que pode ser extraída pela expressão [https://jmespath.org/](https://jmespath.org/) no formato `score` **JSON Lines**.
| Entrada de contêiner de modelo | Entrada de contêiner de modelo |
| --- | --- |
| Registro único | '\$1"score":0.6\$1' |
| Dois registros | '\$1"score":0.6\$1\$1n\$1"score":0.3\$1' |
------
#### [ Predicted label and probabilities ]
Neste exemplo, um contêiner de modelo multiclasse gera uma lista de cabeçalhos de rótulos junto com uma lista de probabilidades no formato **JSON Lines.** As probabilidades podem ser extraídas pela `JMESPath` expressão `probability` e os cabeçalhos dos rótulos podem ser extraídos pela expressão `JMESPath` `predicted labels`.
| Entrada de contêiner de modelo | Entrada de contêiner de modelo |
| --- | --- |
| Registro único | '\$1"predicted\$1labels":["gato","cachorro","peixe"],"probabilities":[0.1,0.6,0.3]\$1' |
| Dois registros | '\$1"predicted\$1labels":["gato","cachorro","peixe"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["gato","cachorro","peixe"],"probabilities":[0.2,0.5,0.3]\$1' |
------
#### [ Predicted labels header and probabilities ]
Neste exemplo, um contêiner de modelo multiclasse gera uma lista de cabeçalhos e probabilidades de rótulos no formato **JSON Lines**. As probabilidades podem ser extraídas pela `JMESPath` expressão `probability` e os cabeçalhos dos rótulos podem ser extraídos pela expressão `JMESPath` `predicted labels`.
| Entrada de contêiner de modelo | Entrada de contêiner de modelo |
| --- | --- |
| Registro único | '\$1"predicted\$1labels":["gato","cachorro","peixe"],"probabilities":[0.1,0.6,0.3]\$1' |
| Dois registros | '\$1"predicted\$1labels":["gato","cachorro","peixe"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["gato","cachorro","peixe"],"probabilities":[0.2,0.5,0.3]\$1' |
------
## Validação de contêiner
Recomendamos que você implante seu modelo em um endpoint de inferência de SageMaker IA em tempo real e envie solicitações para o endpoint. Examine manualmente as solicitações (entradas do contêiner do modelo) e as respostas (saídas do contêiner do modelo) para garantir que ambas estejam em conformidade com os requisitos na seção **Entrada do contêiner do modelo** e na seção **Saída do contêiner do modelo**. Se o seu contêiner de modelo oferecer compatibilidade com solicitações em lote, você poderá começar com uma única solicitação de registro e, em seguida, tentar dois ou mais registros.
Os comandos a seguir mostram como solicitar uma resposta usando o AWS CLI. O AWS CLI vem pré-instalado nas instâncias SageMaker Studio Classic e SageMaker Notebook. Se você precisar instalar o AWS CLI, siga este [guia de instalação](https://aws.amazon.com/cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Os parâmetros são definidos da seguinte forma:
+ `$ENDPOINT NAME`: o nome do endpoint.
+ `$CONTENT_TYPE`: o tipo MIME da solicitação (entrada do contêiner do modelo).
+ `$ACCEPT_TYPE`: o tipo MIME da resposta (saída do contêiner do modelo).
+ `$REQUEST_DATA`: a string de carga útil solicitada.
+ `$CLI_BINARY_FORMAT`: o formato do parâmetro da Interface da linha de comando (CLI). Para AWS CLI v1, esse parâmetro deve permanecer em branco. Para v2, esse parâmetro deve ser definido como `--cli-binary-format raw-in-base64-out`.
**nota**
AWS CLI [v2 passa parâmetros binários como strings codificadas em base64 padrão.](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)
Os exemplos a seguir usam AWS CLI v1:
------
#### [ Request and response in CSV format ]
+ A solicitação consiste em um único registro e a resposta é seu valor de probabilidade.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Saída:
`0.6`
+ A solicitação consiste em dois registros, e a resposta inclui suas probabilidades, e o modelo separa as probabilidades por uma vírgula. A `$'content'` expressão no `--body` diz ao comando para interpretar `\n` o conteúdo como uma quebra de linha.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Saída:
`0.6,0.3`
+ A solicitação consiste em dois registros, a resposta inclui suas probabilidades e o modelo separa as probabilidades com uma quebra de linha.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Saída:
`0.6`
`0.3`
+ A solicitação consiste em um único registro e a resposta são valores de probabilidade (modelo multiclasse, três classes).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Saída:
`0.1,0.6,0.3`
+ A solicitação consiste em dois registros e a resposta inclui seus valores de probabilidade (modelo multiclasse, três classes).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Saída:
`0.1,0.6,0.3`
`0.2,0.5,0.3`
+ A solicitação consiste em dois registros, e a resposta inclui rótulo e probabilidade previstos.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Saída:
`1,0.6`
`0,0.3`
+ A solicitação consiste em dois registros e a resposta inclui cabeçalhos e probabilidades dos rótulos.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Saída:
`"['cat','dog','fish']","[0.1,0.6,0.3]"`
`"['cat','dog','fish']","[0.2,0.5,0.3]"`
------
#### [ Request and response in JSON Lines format ]
+ A solicitação consiste em um único registro e a resposta é seu valor de probabilidade.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
Saída:
`{"score":0.6}`
+ A solicitação contém dois registros e a resposta inclui rótulo e probabilidade previstos.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Saída:
`{"predicted_label":1,"probability":0.6}`
`{"predicted_label":0,"probability":0.3}`
+ A solicitação contém dois registros e a resposta inclui cabeçalhos e probabilidades dos rótulos.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
Saída:
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}`
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}`
------
#### [ Request and response in different formats ]
+ A solicitação está no formato CSV e a resposta está no formato JSON Lines:
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Saída:
`{"probability":0.6}`
`{"probability":0.3}`
+ A solicitação está no formato JSON Lines e a resposta está no formato CSV:
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Saída:
`0.6`
`0.3`
------
Depois que as validações forem concluídas, [exclua](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-delete-resources.html) o endpoint de teste.
# Configurar e criar um endpoint
Crie uma nova configuração de endpoint para se adequar ao seu modelo e use essa configuração para criar o endpoint. Você pode usar o contêiner de modelo validado na [etapa de pré-verificação](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html) para criar um endpoint e ativar o recurso de explicabilidade on-line do SageMaker Clarify.
Use o `sagemaker_client` objeto para criar um endpoint usando a [CreateEndpointConfig](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API. Defina o membro `ClarifyExplainerConfig` dentro do `ExplainerConfig` parâmetro da seguinte forma:
```
sagemaker_client.create_endpoint_config(
EndpointConfigName='name-of-your-endpoint-config',
ExplainerConfig={
'ClarifyExplainerConfig': {
'EnableExplanations': '`true`',
'InferenceConfig': {
...
},
'ShapConfig': {
...
}
},
},
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': 'name-of-your-model',
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}]
...
)
sagemaker_client.create_endpoint(
EndpointName='name-of-your-endpoint',
EndpointConfigName='name-of-your-endpoint-config'
)
```
A primeira chamada para o objeto `sagemaker_client` cria uma nova configuração de endpoint com o atributo de explicabilidade ativado. A segunda chamada usa a configuração do endpoint para iniciar o endpoint.
**nota**
Você também pode hospedar vários modelos em um contêiner atrás de um [endpoint multimodelo de inferência em tempo real de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) e configurar a explicabilidade on-line com o Clarify. SageMaker
# A expressão `EnableExplanations`
O `EnableExplanations` parâmetro é uma string de expressão booleana [https://jmespath.org/](https://jmespath.org/). Ele é avaliado para **cada registro** na solicitação de explicabilidade. Se esse parâmetro for avaliado como **verdadeiro**, o registro será explicado. Se esse parâmetro for avaliado **como falso**, as explicações não serão geradas.
SageMaker O Clarify desserializa a saída do contêiner do modelo para cada registro em uma estrutura de dados compatível com JSON e, em seguida, usa o `EnableExplanations` parâmetro para avaliar os dados.
**Observações**
Há duas opções para registros, dependendo do formato da saída do contêiner do modelo.
Se a saída do contêiner do modelo estiver no formato CSV, um registro será carregado como uma matriz JSON.
Se a saída do contêiner do modelo estiver no formato JSON Lines, um registro será carregado como um objeto JSON.
O `EnableExplanations` parâmetro é uma JMESPath expressão que pode ser passada durante as `CreateEndpointConfig` operações `InvokeEndpoint` ou. Se a JMESPath expressão que você forneceu não for válida, a criação do endpoint falhará. Se a expressão for válida, mas o resultado da avaliação da expressão for inesperado, o endpoint será criado com sucesso, mas um erro será gerado quando o endpoint for invocado. Teste sua expressão `EnableExplanations` usando a API `InvokeEndpoint` e, em seguida, aplique-a à configuração do endpoint.
A seguir estão alguns exemplos de expressão `EnableExplanations` válida. Nos exemplos, uma JMESPath expressão inclui um literal usando caracteres de crase. Por exemplo, ``true`` significa verdadeiro.
| Expressão (representação de string) | Saída do contêiner do modelo (representação de string) | Resultado da avaliação (booleano) | Significado |
| --- | --- | --- | --- |
| '`true`' | (N/D) | Verdadeiro | Ative a explicabilidade on-line incondicionalmente. |
| '`false`' | (N/D) | Falso | Desative a explicabilidade on-line incondicionalmente. |
| '[1]>`0.5`' | '1,0.6' | Verdadeiro | Para cada registro, o contêiner do modelo gera seu rótulo e probabilidade previstos. Explica um registro se sua probabilidade (no índice 1) for maior que 0,5. |
| 'probability>`0.5`' | '\$1"predicted\$1label":1,"probability":0.6\$1' | Verdadeiro | Para cada registro, o contêiner do modelo gera dados JSON. Explique um registro se sua probabilidade for maior que 0,5. |
| '\$1contains(probabilities[:-1], max(probabilities))' | '\$1"probabilities": [0.4, 0.1, 0.4], "labels":["gato","cachorro","peixe"]\$1' | Falso | Para um modelo multiclasse: explica um registro se seu rótulo previsto (a classe que tem o valor máximo de probabilidade) for a última classe. Literalmente, a expressão significa que o valor máximo da probabilidade não está na lista de probabilidades, excluindo a última. |
# Conjuntos de dados sintéticos
SageMaker O Clarify usa o algoritmo Kernel SHAP. Com base em um registro (também chamado de amostra ou instância) e na configuração SHAP, o explicador primeiro gera um conjunto de dados sintético. SageMaker Em seguida, o Clarify consulta o contêiner do modelo para obter as previsões do conjunto de dados e, em seguida, computa e retorna as atribuições do recurso. O tamanho do conjunto de dados sintéticos afeta o runtime do explicador Clarify. Conjuntos de dados sintéticos maiores levam mais tempo para obter as predições de modelo do que conjuntos menores.
O tamanho do conjunto de dados sintéticos é determinado pela seguinte fórmula:
```
Synthetic dataset size = SHAP baseline size * n_samples
```
O tamanho da linha de base do SHAP é o número de registros nos dados da linha de base do SHAP. Essas informações são retiradas do `ShapBaselineConfig`.
O tamanho de `n_samples` é definido pelo parâmetro `NumberOfSamples` na configuração do explicador e pelo número de atributos. Se o número de atributos for `n_features`, então `n_samples` é o seguinte:
```
n_samples = MIN(NumberOfSamples, 2^n_features - 2)
```
O seguinte mostra `n_samples` se não `NumberOfSamples` é fornecido:
```
n_samples = MIN(2*n_features + 2^11, 2^n_features - 2)
```
Por exemplo, um registro tabular com 10 atributos tem um tamanho de linha de base SHAP de 1. Se não `NumberOfSamples` for fornecido, o conjunto de dados sintético contém 1.022 registros. Se o registro tiver 20 atributos, o conjunto de dados sintético conterá 2.088 registros.
Para problemas de PNL, `n_features` é igual ao número de atributos não textuais mais o número de unidades de texto.
**nota**
A API `InvokeEndpoint` tem um limite de tempo limite de solicitação. Se o conjunto de dados sintéticos for muito grande, o explicador pode não conseguir concluir o cálculo dentro desse limite. Se necessário, use as informações anteriores para entender e reduzir o tamanho da linha de base do SHAP e `NumberOfSamples`. Se o contêiner do modelo estiver configurado para lidar com solicitações em lote, você também poderá ajustar o valor de `MaxRecordCount`.
# Invocar o endpoint
Depois que o endpoint estiver em execução, use a [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API SageMaker AI Runtime no serviço SageMaker AI Runtime para enviar solicitações ou invocar o endpoint. Em resposta, as solicitações são tratadas como solicitações de explicabilidade pelo explicador do SageMaker Clarify.
**nota**
Para chamar um endpoint, escolha uma das seguintes opções:
Para obter instruções sobre como usar o Boto3 ou AWS CLI para invocar um endpoint, consulte. [Invocar modelos para inferência em tempo real](realtime-endpoints-test-endpoints.md)
[Para usar o SageMaker SDK para Python para invocar um endpoint, consulte a API Predictor.](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html)
## Solicitação
A API `InvokeEndpoint` tem um parâmetro opcional `EnableExplanations`, que é mapeado para o cabeçalho `X-Amzn-SageMaker-Enable-Explanations` HTTP. Se esse parâmetro for fornecido, ele substituirá o parâmetro `EnableExplanations` do `ClarifyExplainerConfig`.
**nota**
Os parâmetros `ContentType` e `Accept` da API `InvokeEndpoint` são necessários. Os formatos compatíveis incluem o tipo MIME `text/csv` e `application/jsonlines`.
Use o `sagemaker_runtime_client` para enviar uma solicitação ao endpoint, da seguinte forma:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName='name-of-your-endpoint',
EnableExplanations='`true`',
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4', # single record (of four numerical features)
)
```
Para endpoints multimodelo, passe um parâmetro adicional `TargetModel` na solicitação do exemplo anterior para especificar a qual modelo direcionar no endpoint. O endpoint multimodelo carrega dinamicamente os modelos de destino conforme necessário. Para obter mais informações sobre endpoints multimodelo, consulte [Endpoints multimodelo](multi-model-endpoints.md). Consulte o [caderno de amostra SageMaker Clarify Online Explicability on Multimodel Endpoint](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular_multi_model_endpoint/multi_model_xgboost_with_online_explainability.ipynb) para obter um exemplo de como configurar e invocar vários modelos de destino a partir de um único endpoint.
## Resposta
Se o endpoint for criado com `ExplainerConfig`, um novo esquema de resposta será usado. Esse novo esquema é diferente e não é compatível com um endpoint que não tem o parâmetro fornecido `ExplainerConfig`.
O tipo MIME da resposta é `application/json`, e a carga útil da resposta pode ser decodificada de bytes UTF-8 para um objeto JSON. Veja a seguir que os membros desse objeto JSON são os seguintes:
+ `version`: a versão do esquema de resposta em formato de string. Por exemplo, .`1.0`
+ `predictions`: as predições que a solicitação faz são as seguintes:
+ `content_type`: o tipo MIME das predições, referindo-se à `ContentType` da resposta do contêiner do modelo.
+ `data`: a sequência de dados de predições fornecida como carga útil da resposta do contêiner do modelo para a solicitação.
+ `label_headers`: os cabeçalhos do rótulo do parâmetro `LabelHeaders`. Isso é fornecido na configuração do explicador ou na saída do contêiner do modelo.
+ `explanations`: as explicações fornecidas na carga útil da solicitação. Se nenhum registro for explicado, esse membro retornará o objeto vazio `{}`.
+
+ `kernel_shap`: uma chave que se refere a uma matriz de explicações do Kernel SHAP para cada registro na solicitação. Se um registro não for explicado, a explicação correspondente será `null`.
O elemento `kernel_shap` tem os seguintes membros:
+ `feature_header`: o nome do cabeçalho dos atributos fornecidos pelo parâmetro `FeatureHeaders` na configuração do explicador `ExplainerConfig`.
+ `feature_type`: o tipo de atributo inferido pelo explicador ou fornecido no parâmetro `FeatureTypes` no `ExplainerConfig`. Esse elemento só está disponível para problemas de explicabilidade da PNL.
+ `attributions`: uma matriz de objetos de atribuição. Os atributos de texto podem ter vários objetos de atribuição, cada um para uma unidade. O objeto de atribuição tem os seguintes membros:
+ `attribution`: uma lista de valores de probabilidade, fornecida para cada classe.
+ `description`: a descrição das unidades de texto, disponível somente para problemas de explicabilidade da PNL.
+ `partial_text`: a parte do texto explicada pelo explicador.
+ `start_idx`: um índice baseado em zero para identificar a localização da matriz no início do fragmento de texto parcial.
# Exemplos de código: SDK para Python
Esta seção fornece um exemplo de código para criar e invocar um endpoint que usa a explicabilidade on-line do SageMaker Clarify. Estes exemplos de código usam o [SDK AWS para Python](https://aws.amazon.com/sdk-for-python/).
## Dados tabulares
O exemplo a seguir usa dados tabulares e um modelo de SageMaker IA chamado`model_name`. Neste exemplo, o contêiner do modelo aceita dados no formato CSV e cada registro tem quatro atributos numéricos. Nessa configuração mínima, **somente para fins de demonstração**, os dados da linha de base do SHAP são definidos como zero. Consulte [Linhas de base do SHAP para explicabilidade](clarify-feature-attribute-shap-baselines.md) para saber como escolher valores mais apropriados para `ShapBaseline`.
Configure o endpoint da seguinte maneira:
```
endpoint_config_name = 'tabular_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '0,0,0,0',
},
},
},
},
)
```
Use a configuração do endpoint para criar um endpoint, como segue:
```
endpoint_name = 'tabular_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
Use a API `DescribeEndpoint` para inspecionar o progresso da criação de um endpoint, da seguinte forma:
```
response = sagemaker_client.describe_endpoint(
EndpointName=endpoint_name,
)
response['EndpointStatus']
```
Depois que o status do endpoint for "InService“, invoque o endpoint com um registro de teste, da seguinte forma:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
)
```
**nota**
No exemplo de código anterior, para endpoints multimodelo, passe um parâmetro adicional `TargetModel` na solicitação para especificar qual modelo deve ser direcionado ao endpoint.
Suponha que a resposta tenha um código de status 200 (sem erro) e carregue o corpo da resposta da seguinte forma:
```
import codecs
import json
json.load(codecs.getreader('utf-8')(response['Body']))
```
A ação padrão para o endpoint é explicar o registro. Veja a seguir um exemplo de saída no objeto JSON retornado.
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.0006380207487381"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [-0.00433456]
}
]
},
{
"attributions": [
{
"attribution": [-0.005369821]
}
]
},
{
"attributions": [
{
"attribution": [0.007917749]
}
]
},
{
"attributions": [
{
"attribution": [-0.00261214]
}
]
}
]
]
}
}
```
Use o parâmetro `EnableExplanations` para habilitar explicações sob demanda, da seguinte forma:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
EnableExplanations='[0]>`0.8`',
)
```
**nota**
No exemplo de código anterior, para endpoints multimodelo, passe um parâmetro adicional `TargetModel` na solicitação para especificar qual modelo deve ser direcionado ao endpoint.
Neste exemplo, o valor de predição é menor que o valor limite de `0.8`, portanto, o registro não é explicado:
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.6380207487381995"
},
"explanations": {}
}
```
Use ferramentas de visualização para ajudar a interpretar as explicações retornadas. A imagem a seguir mostra como os gráficos SHAP podem ser usados para entender como cada atributo contribui para a predição. O valor base no diagrama, também chamado de valor esperado, é a média das predições do conjunto de dados de treinamento. Os atributos que aumentam o valor esperado são vermelhos e os atributos que reduzem o valor esperado são azuis. Consulte o [layout da força aditiva SHAP](https://shap.readthedocs.io/en/latest/generated/shap.plots.force.html) para obter informações adicionais.
![\[Exemplo de gráfico SHAP, que pode ser usado para entender como cada atributo contribui para a predição.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/clarify/force-plot.png)
Veja o [exemplo completo de caderno de notas para dados tabulares](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular/tabular_online_explainability_with_sagemaker_clarify.ipynb).
## Dados de texto
Esta seção fornece um exemplo de código para criar e invocar um endpoint de explicabilidade on-line para dados de texto. O exemplo de código usa SDK para Python.
O exemplo a seguir usa dados de texto e um modelo de SageMaker IA chamado`model_name`. Neste exemplo, o contêiner do modelo aceita dados no formato CSV, e cada registro é uma única string.
```
endpoint_config_name = 'text_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'InferenceConfig': {
'FeatureTypes': ['text'],
'MaxRecordCount': 100,
},
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '""',
},
'TextConfig': {
'Granularity': 'token',
'Language': 'en',
},
'NumberOfSamples': 100,
},
},
},
)
```
+ `ShapBaseline`: um token especial reservado para processamento de linguagem natural (PLN).
+ `FeatureTypes`: identifica o atributo como texto. Se esse parâmetro não for fornecido, o explicador tentará inferir o tipo de atributo.
+ `TextConfig`: especifica a unidade de granularidade e o idioma para a análise dos atributos de texto. Neste exemplo, o idioma é inglês e granularidade `token` significa uma palavra em um texto em inglês.
+ `NumberOfSamples`: um limite para definir os limites superiores do tamanho do conjunto de dados sintéticos.
+ `MaxRecordCount`: o número máximo de registros em uma solicitação que o recipiente modelo pode processar. Esse parâmetro está definido para estabilizar o performance.
Use a configuração de endpoint para criar o endpoint, como segue:
```
endpoint_name = 'text_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
Depois que o status do endpoint se tornar `InService`, invoque o endpoint. O seguinte exemplo de código usa um registro de teste da seguinte forma:
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='"This is a good product"',
)
```
Se a solicitação for concluída com êxito, o corpo da resposta retornará um objeto JSON válido semelhante ao seguinte:
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv",
"data": "0.9766594\n"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [
-0.007270948666666712
],
"description": {
"partial_text": "This",
"start_idx": 0
}
},
{
"attribution": [
-0.018199033666666628
],
"description": {
"partial_text": "is",
"start_idx": 5
}
},
{
"attribution": [
0.01970993241666666
],
"description": {
"partial_text": "a",
"start_idx": 8
}
},
{
"attribution": [
0.1253469515833334
],
"description": {
"partial_text": "good",
"start_idx": 10
}
},
{
"attribution": [
0.03291143366666657
],
"description": {
"partial_text": "product",
"start_idx": 15
}
}
],
"feature_type": "text"
}
]
]
}
}
```
Use ferramentas de visualização para ajudar a interpretar as atribuições de texto retornadas. A imagem a seguir mostra como o utilitário de visualização captum pode ser usado para entender como cada palavra contribui para a predição. Quanto maior a saturação da cor, maior a importância dada à palavra. Neste exemplo, uma cor vermelha brilhante altamente saturada indica uma forte contribuição negativa. Uma cor verde altamente saturada indica uma forte contribuição positiva. A cor branca indica que a palavra tem uma contribuição neutra. Consulte a biblioteca [captum](https://github.com/pytorch/captum) para obter informações adicionais sobre como analisar e renderizar as atribuições.
![\[Utilitário de visualização Captum usado para entender como cada palavra contribui para a predição.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/clarify/word-importance.png)
Veja o [exemplo completo do caderno de notas para dados de texto](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/natural_language_processing/nlp_online_explainability_with_sagemaker_clarify.ipynb).
# Guia de solução de problemas
Se você encontrar erros ao usar a explicabilidade on-line do SageMaker Clarify, consulte os tópicos desta seção.
**`InvokeEndpoint`A API falha com o erro “: ReadTimeoutError Tempo limite de leitura no endpoint...”**
Esse erro significa que a solicitação não pôde ser concluída dentro do limite de tempo de 60 segundos definido pelo tempo limite da [solicitação](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html).
Para reduzir a latência da solicitação, tente o seguinte:
+ Ajuste o performance do modelo durante a inferência. Por exemplo, [o SageMaker AI Neo](https://aws.amazon.com/sagemaker/neo/) pode otimizar modelos para inferência.
+ Permita que o contêiner do modelo processe solicitações em lote.
+ Use um `MaxRecordCount` maior para reduzir o número de chamadas do explicador para o contêiner do modelo. Isso reduzirá a latência e a sobrecarga da rede.
+ Use um tipo de instância que tenha mais recursos alocados. Como alternativa, atribua mais instâncias ao endpoint para ajudar a equilibrar a carga.
+ Reduza o número de registros em uma única solicitação `InvokeEndpoint`.
+ Reduza o número de registros nos dados da linha de base.
+ Use um valor `NumberOfSamples` menor para reduzir o tamanho do conjunto de dados sintético. Para obter mais informações sobre como o número de amostras afeta o seu conjunto de dados sintéticos, consulte [Conjuntos de dados sintéticos](clarify-online-explainability-create-endpoint-synthetic.md).
# Ajustar modelos com componentes de inferência do adaptador
Com a Amazon SageMaker AI, você pode hospedar modelos básicos pré-treinados sem precisar criar seus próprios modelos do zero. No entanto, para adaptar um modelo de base de uso geral às necessidades exclusivas de sua empresa, você deve criar uma versão ajustada dele. Uma técnica de ajuste fino econômica é a adaptação de baixa classificação (LoRa). O princípio por trás da LoRa se aplica quando apenas uma pequena parte de um grande modelo de base precisa ser atualizada para adaptá-lo a novas tarefas ou domínios. Um adaptador de LoRa aumenta a inferência de um modelo de base com apenas algumas camadas extras de adaptador.
*Se você hospeda seu modelo básico usando um componente de inferência de SageMaker IA, você pode ajustar esse modelo básico com adaptadores LoRa criando componentes de inferência de adaptador.* Ao criar um componente de inferência do adaptador, você especifica o seguinte:
+ O *componente de inferência básico* que deve conter o componente de inferência do adaptador. O componente de inferência básico contém o modelo de base que você deseja adaptar. O componente de inferência do adaptador usa os recursos de computação que você atribuiu ao componente de inferência básico.
+ O local onde você armazenou o adaptador de LoRa no Amazon S3.
Depois de criar o componente de inferência do adaptador, você pode invocá-lo diretamente. Quando você faz isso, a SageMaker IA combina o adaptador com o modelo básico para aumentar a resposta gerada.
**Antes de começar**
Para criar um componente de inferência de adaptador, você deve atender aos seguintes requisitos:
+ Você tem um componente de inferência básico que contém o modelo de base a ser adaptado. Você implantou esse componente de inferência em um endpoint de SageMaker IA.
Para ter mais informações sobre como implantar componentes de inferência em endpoints, consulte [Implantar modelos para inferência em tempo real](realtime-endpoints-deploy-models.md).
+ Você tem um modelo de adaptador de LoRa e armazenou os artefatos do modelo como um arquivo `tar.gz` no Amazon S3. Você especifica o URI do S3 dos artefatos ao criar o componente de inferência do adaptador.
Os exemplos a seguir usam o SDK para Python (Boto3) para criar e invocar um componente de inferência de adaptador.
**Example Chamada `create_inference_component` para criar um componente de inferência de adaptador**
O seguinte exemplo cria um componente de inferência de adaptador e o atribui a um componente de inferência básico:
```
sm_client.create_inference_component(
InferenceComponentName = adapter_ic_name,
EndpointName = endpoint_name,
Specification={
"BaseInferenceComponentName": base_inference_component_name,
"Container": {
"ArtifactUrl": adapter_s3_uri
},
},
)
```
Ao usar esse exemplo em seu próprio código, substitua os valores do espaço reservado da seguinte forma:
+ *adapter\$1ic\$1name*— Um nome exclusivo para seu componente de inferência do adaptador.
+ *endpoint\$1name*— O nome do endpoint que hospeda o componente básico de inferência.
+ *base\$1inference\$1component\$1name*— O nome do componente básico de inferência que contém o modelo básico a ser adaptado.
+ *adapter\$1s3\$1uri*— O URI do S3 que localiza o `tar.gz` arquivo com os artefatos do adaptador LoRa.
Você cria um componente de inferência de adaptador com código semelhante ao código de um componente de inferência normal. Uma diferença é que, para o parâmetro `Specification`, você omite a chave `ComputeResourceRequirements`. Quando você invoca um componente de inferência de adaptador, ele é carregado pelo componente de inferência básico. O componente de inferência de adaptador usa os recursos de computação do componente de inferência básico.
Para saber mais sobre como criar e implantar componentes de inferência com o SDK para Python (Boto3), consulte [Implemente modelos com o Python SDKs](realtime-endpoints-deploy-models.md#deploy-models-python).
Depois de criar um componente de inferência de adaptador, você o invoca especificando o nome dele em uma solicitação `invoke_endpoint`.
**Example Chamada `invoke_endpoint` para invocar um componente de inferência de adaptador**
O seguinte exemplo invoca um componente de inferência de adaptador:
```
response = sm_rt_client.invoke_endpoint(
EndpointName = endpoint_name,
InferenceComponentName = adapter_ic_name,
Body = json.dumps(
{
"inputs": prompt,
"parameters": {"max_new_tokens": 100, "temperature":0.9}
}
),
ContentType = "application/json",
)
adapter_reponse = response["Body"].read().decode("utf8")["generated_text"]
```
Ao usar esse exemplo em seu próprio código, substitua os valores do espaço reservado da seguinte forma:
+ *endpoint\$1name*— O nome do endpoint que hospeda os componentes de inferência da base e do adaptador.
+ *adapter\$1ic\$1name*— O nome do componente de inferência do adaptador.
+ *prompt*— O prompt para a solicitação de inferência.
Para saber mais sobre o como invocar componentes de inferência com o SDK para Python (Boto3), consulte [Invocar modelos para inferência em tempo real](realtime-endpoints-test-endpoints.md).
# Implante modelos com o Amazon SageMaker Serverless Inference
O Amazon SageMaker Serverless Inference é uma opção de inferência criada especificamente que permite implantar e escalar modelos de ML sem configurar ou gerenciar nenhuma infraestrutura subjacente. A Inferência Sem Servidor sob demanda é ideal para workloads que têm períodos de inatividade entre surtos de tráfego e podem tolerar inicialização a frio. Os endpoints sem servidor iniciam automaticamente os recursos de computação e aumentam e reduzem a escala horizontalmente, dependendo do tráfego, eliminando a necessidade de escolher tipos de instância ou gerenciar políticas de ajuste de escala. Isso elimina o trabalho pesado indiferenciado de selecionar e gerenciar servidores. A Inferência Sem Servidor se integra ao AWS Lambda para oferecer alta disponibilidade, tolerância a falhas integrada e ajuste de escala automático. Com um pay-per-use modelo, a inferência sem servidor é uma opção econômica se você tiver um padrão de tráfego pouco frequente ou imprevisível. Nos momentos em que não há solicitações, a Inferência Sem Servidor reduz seu endpoint para 0, ajudando você a minimizar seus custos. [Para obter mais informações sobre preços para inferência sem servidor sob demanda, consulte Amazon Pricing. SageMaker ](https://aws.amazon.com/sagemaker/pricing/)
Opcionalmente, você também pode usar a simultaneidade provisionada com Inferência Sem Servidor. A Inferência Sem Servidor com simultaneidade provisionada é uma opção econômica quando você tem picos previsíveis no tráfego. A simultaneidade provisionada permite que você implante modelos em endpoints sem servidor com desempenho previsível e alta escalabilidade, mantendo seus endpoints aquecidos. SageMaker A IA garante que, para o número de simultaneidade provisionada que você aloca, os recursos computacionais sejam inicializados e estejam prontos para responder em milissegundos. Quanto à Inferência Sem Servidor com simultaneidade provisionada, você paga pela capacidade computacional usada para processar solicitações de inferência, cobrada por milissegundo, e pela quantidade de dados processados. Você também paga pelo uso da simultaneidade provisionada, com base na memória configurada, na duração provisionada e na quantidade de simultaneidade ativada. [Para obter mais informações sobre preços para inferência sem servidor com simultaneidade provisionada, consulte Amazon Pricing. SageMaker ](https://aws.amazon.com/sagemaker/pricing/)
[Você pode integrar a inferência sem servidor aos seus MLOps pipelines para agilizar seu fluxo de trabalho de ML e usar um endpoint sem servidor para hospedar um modelo registrado no Model Registry.](model-registry.md)
A inferência sem servidor geralmente está disponível em 21 AWS regiões: Leste dos EUA (Norte da Virgínia), Leste dos EUA (Ohio), Oeste dos EUA (Norte da Califórnia), Oeste dos EUA (Oregon), África (Cidade do Cabo), Ásia-Pacífico (Hong Kong), Ásia-Pacífico (Mumbai), Ásia-Pacífico (Tóquio), Ásia-Pacífico (Sydney), Ásia-Pacífico (Sydney), Canadá (Central), Europa (Frankfurt), Europa (Irlanda), Europa (Londres), Europa (Paris), Europa (Estocolmo), Europa (Milão), Oriente Médio (Bahrein), América do Sul (São Paulo). Para obter mais informações sobre a disponibilidade regional do Amazon SageMaker AI, consulte a [Lista de serviços AWS regionais](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Como funciona
O diagrama a seguir mostra o fluxo de trabalho da Inferência Sem Servidor sob demanda e os benefícios de usar um endpoint sem servidor.
![\[Diagrama mostrando o fluxo de trabalho da Inferência Sem Servidor.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/serverless-endpoints-how-it-works.png)
Quando você cria um endpoint sem servidor sob demanda, a SageMaker IA provisiona e gerencia os recursos de computação para você. Em seguida, você pode fazer solicitações de inferência para o endpoint e receber previsões do modelo em resposta. SageMaker A IA aumenta e diminui os recursos de computação conforme necessário para lidar com o tráfego de solicitações, e você paga apenas pelo que usa.
Para a simultaneidade provisionada, a Inferência Sem Servidor também se integra à aplicação Auto Scaling, para que você possa gerenciar a simultaneidade provisionada com base em uma métrica alvo ou em um cronograma. Para obter mais informações, consulte [Escalar automaticamente a simultaneidade provisionada para um endpoint de sem servidor](serverless-endpoints-autoscale.md).
As seções a seguir fornecem detalhes adicionais sobre a Inferência Sem Servidor e como ela funciona.
**Topics**
+ [Compatibilidade do contêiner](#serverless-endpoints-how-it-works-containers)
+ [Tamanho da memória](#serverless-endpoints-how-it-works-memory)
+ [Invocações simultâneas](#serverless-endpoints-how-it-works-concurrency)
+ [Minimização dos arranques de baixa atividade](#serverless-endpoints-how-it-works-cold-starts)
+ [Exclusões de atributos](#serverless-endpoints-how-it-works-exclusions)
### Compatibilidade do contêiner
Para seu contêiner de endpoint, você pode escolher um contêiner SageMaker fornecido pela IA ou trazer o seu próprio. SageMaker A IA fornece contêineres para seus algoritmos integrados e imagens pré-criadas do Docker para algumas das estruturas de aprendizado de máquina mais comuns, como Apache, MXNet TensorFlow, PyTorch e Chainer. Para obter uma lista das SageMaker imagens disponíveis, consulte Imagens [disponíveis de contêineres de Deep Learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Se você estiver trazendo seu próprio contêiner, deverá modificá-lo para funcionar com SageMaker IA. Para obter mais informações sobre como trazer seu próprio contêiner, consulte [Adapte seu próprio contêiner de inferência para a Amazon AI SageMaker](adapt-inference-container.md).
O tamanho máximo da imagem do contêiner que você pode usar é 10 GB. Para endpoints sem servidor, recomendamos criar somente um operador no contêiner e carregar somente uma cópia do modelo. Observe que isso é diferente dos endpoints em tempo real, em que alguns contêineres de SageMaker IA podem criar um trabalhador para cada vCPU para processar solicitações de inferência e carregar o modelo em cada trabalhador.
Se você já tiver um contêiner para um endpoint em tempo real, poderá usar o mesmo contêiner para seu endpoint sem servidor, embora alguns recursos estejam excluídos. Para saber mais sobre os recursos de contêiner que não são compatíveis com a Inferência Sem Servidor, consulte [Exclusões de atributos](#serverless-endpoints-how-it-works-exclusions). Se você optar por usar o mesmo contêiner, a SageMaker AI guarda (retém) uma cópia da imagem do contêiner até que você exclua todos os endpoints que usam a imagem. SageMaker A IA criptografa a imagem copiada em repouso com uma chave de propriedade da SageMaker IA AWS KMS .
### Tamanho da memória
Seu endpoint sem servidor tem um tamanho mínimo de RAM de 1024 MB (1 GB), e o tamanho máximo de RAM que você pode escolher é 6144 MB (6 GB). Os tamanhos de memória que você pode escolher são 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB ou 6144 MB. A Inferência Sem Servidor atribui automaticamente recursos computacionais proporcionais à memória que você seleciona. Se você escolher um tamanho de memória maior, seu contêiner terá acesso a mais CPUs v. Escolha o tamanho da memória do seu endpoint de acordo com o tamanho do modelo. Geralmente, o tamanho da memória deve ser pelo menos tão grande quanto o tamanho do modelo. Talvez seja necessário fazer um benchmark para escolher a seleção de memória certa para seu modelo com base na sua latência SLAs. Para obter um guia passo a passo do benchmark, consulte [Apresentando o Amazon SageMaker Serverless Inference](https://aws.amazon.com/blogs/machine-learning/introducing-the-amazon-sagemaker-serverless-inference-benchmarking-toolkit/) Benchmarking Toolkit. Os incrementos do tamanho da memória têm preços diferentes; consulte a [página de preços do Amazon SageMaker AI](https://aws.amazon.com/sagemaker/pricing/) para obter mais informações.
Independentemente do tamanho de memória que você escolher, seu endpoint sem servidor tem 5 GB de armazenamento em disco efêmero disponível. Para obter ajuda com problemas de permissões de contêiner ao trabalhar com armazenamento, consulte[Solução de problemas](serverless-endpoints-troubleshooting.md).
### Invocações simultâneas
A Inferência Sem Servidor sob demanda gerencia políticas e cotas de ajuste de escala predefinidas para a capacidade do seu endpoint. Os endpoints sem servidor têm uma cota de quantas invocações simultâneas podem ser processadas ao mesmo tempo. Se o endpoint for invocado antes de concluir o processamento da primeira solicitação, ele processará a segunda solicitação simultaneamente.
A simultaneidade total que você pode compartilhar entre todos os endpoints sem servidor em sua conta depende da sua região:
+ Para as regiões do Leste dos EUA (Ohio), Leste dos Eua (Norte da Virgínia), Oeste dos Eua (Oregon), Ásia-Pacífico (Singapura), Ásia-Pacífico (Sydney), Ásia-Pacífico (Sydney), Ásia-Pacífico (Tóquio), Europa (Frankfurt) e Europa (Irlanda), a simultaneidade total que você pode compartilhar entre todos os endpoints sem servidor por região em sua conta é 1000.
+ Para as regiões Oeste dos EUA (Norte da Califórnia), África (Cidade do Cabo), Ásia-Pacífico (Hong Kong), Ásia-Pacífico (Mumbai), Ásia-Pacífico (Osaka), Ásia-Pacífico (Seul), Canadá (Central), Europa (Londres) Europa (Milão), Europa (Paris), Europa (Paris), Europa (Estocolmo), Oriente Médio (Bahrein) e América do Sul (São Paulo), Europa (Paris), Europa (Estocolmo), Oriente Médio (Bahrein) e América do Sul (São Paulo), a simultaneidade total por região em sua conta é 500.
Você pode definir a simultaneidade máxima para um único endpoint até 200, e o número total de endpoints sem servidor que você pode hospedar em uma região é 50. A simultaneidade máxima de um endpoint individual impede que esse endpoint aceite todas as invocações permitidas para sua conta, e qualquer invocação de endpoint além do máximo é limitada.
**nota**
A simultaneidade provisionada que você atribui a um endpoint sem servidor deve sempre ser menor ou igual à simultaneidade máxima que você atribuiu a esse endpoint.
Para saber como definir a simultaneidade máxima para seu endpoint, consulte. [Criar uma configuração de endpoint](serverless-endpoints-create-config.md) Para obter mais informações sobre cotas e limites, consulte os [endpoints e cotas do Amazon SageMaker AI](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html) no. *Referência geral da AWS* Para solicitar um aumento do limite de serviço, consulte [Ajuda da AWS](https://console.aws.amazon.com/support). Para obter instruções sobre como solicitar um aumento do limite de serviço, consulte [Regiões e cotas compatíveis](regions-quotas.md).
### Minimização dos arranques de baixa atividade
Se o endpoint da Inferência Sem Servidor sob demanda não receber tráfego por um tempo e, de repente, receber novas solicitações, pode levar algum tempo para que seu endpoint ative os recursos de computação para processar as solicitações. Isto é chamado de *inicialização a frio*. Como os endpoints sem servidor provisionam recursos de computação sob demanda, seu endpoint pode passar por inícios a frio. Uma inicialização a frio também pode ocorrer se suas solicitações simultâneas excederem o uso atual da solicitação simultânea. O tempo de inicialização a frio depende do tamanho do modelo, do tempo necessário para fazer o download do modelo e do tempo de inicialização do contêiner.
Para monitorar a duração do seu horário de inicialização a frio, você pode usar a CloudWatch métrica da Amazon `OverheadLatency` para monitorar seu endpoint sem servidor. Essa métrica rastreia o tempo necessário para lançar novos recursos de computação para seu endpoint. Para saber mais sobre o uso de CloudWatch métricas com endpoints sem servidor, consulte. [Alarmes e logs para rastrear métricas de endpoints com tecnologia sem servidor](serverless-endpoints-monitoring.md)
Você pode minimizar as inicializações a frio usando a simultaneidade provisionada. SageMaker A IA mantém o endpoint aquecido e pronto para responder em milissegundos, para o número de simultaneidade provisionada que você alocou.
### Exclusões de atributos
Alguns dos recursos atualmente disponíveis para inferência em tempo real de SageMaker IA não são compatíveis com inferência sem servidor, incluindo pacotes de modelos de AWS mercado, registros privados do Docker GPUs, endpoints multimodelo, configuração de VPC, isolamento de rede, captura de dados, várias variantes de produção, Model Monitor e pipelines de inferência.
Você não pode converter seu endpoint em tempo real baseado em instância em um endpoint sem servidor. Se você tentar atualizar seu endpoint em tempo real para sem servidor, receberá uma mensagem. `ValidationError` Você pode converter um endpoint sem servidor em tempo real, mas depois de fazer a atualização, não é possível revertê-lo para o modo sem servidor.
## Introdução
Você pode criar, atualizar, descrever e excluir um endpoint sem servidor usando o console de SageMaker IA, AWS SDKs o Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) e o. AWS CLI Você pode invocar seu endpoint usando o. AWS SDKs, o Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) e o. AWS CLI Para endpoints sem servidor com simultaneidade provisionada, você pode usar o Application Auto Scaling para escalar automaticamente a simultaneidade provisionada com base em uma métrica alvo ou em um cronograma. Para obter mais informações sobre como configurar e usar um endpoint sem servidor, leia o guia. [Operações de endpoint sem servidor](serverless-endpoints-create-invoke-update-delete.md) Para obter mais informações sobre endpoints sem servidor de ajuste de escala automático com simultaneidade provisionada, consulte. [Escalar automaticamente a simultaneidade provisionada para um endpoint de sem servidor](serverless-endpoints-autoscale.md)
**nota**
Atualmente, o Application Auto Scaling for Serverless Inference with Provisioned Concurrency não é compatível com o AWS CloudFormation.
### Exemplos de cadernos e blogs
[Para exemplos de notebooks Jupyter que mostram fluxos de trabalho de endpoints end-to-end sem servidor, consulte os notebooks de exemplo de inferência sem servidor.](https://github.com/aws/amazon-sagemaker-examples/tree/master/serverless-inference)
# Operações de endpoint sem servidor
Ao contrário de outros endpoints de SageMaker IA em tempo real, o Serverless Inference gerencia os recursos de computação para você, reduzindo a complexidade para que você possa se concentrar no seu modelo de ML em vez de gerenciar a infraestrutura. O guia a seguir destaca os principais recursos dos endpoints sem servidor: como criar, invocar, atualizar, descrever ou excluir um endpoint. Você pode usar o console de SageMaker IA AWS SDKs, o [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) ou o AWS CLI para gerenciar seus endpoints sem servidor.
**Topics**
+ [Concluir os pré-requisitos do .](serverless-endpoints-prerequisites.md)
+ [Criação de endpoint sem servidor](serverless-endpoints-create.md)
+ [invocar um endpoint sem servidor](serverless-endpoints-invoke.md)
+ [Atualizar um endpoint sem servidor](serverless-endpoints-update.md)
+ [Descrever um endpoint sem servidor](serverless-endpoints-describe.md)
+ [Excluir um endpoint sem servidor](serverless-endpoints-delete.md)
# Concluir os pré-requisitos do .
O tópico a seguir descreve os pré-requisitos que você deve concluir antes de criar um endpoint sem servidor. Esses pré-requisitos incluem armazenar adequadamente os artefatos do modelo, configurar um AWS IAM com as permissões corretas e selecionar uma imagem de contêiner.
**Como concluir os pré-requisitos**
1. **Configure uma AWS conta.** Primeiro, você precisa de uma AWS conta e de um usuário AWS Identity and Access Management administrador. Para obter instruções sobre como configurar uma AWS conta, consulte [Como faço para criar e ativar uma nova AWS conta?](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) . Para instruções sobre como proteger sua conta com um usuário administrador do IAM, consulte [Criando seu primeiro usuário administrador do IAM e grupo de usuários](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) no *Guia do usuário do IAM*.
1. **Crie um bucket do Amazon S3**. Você usa um bucket do Amazon S3 para armazenar seus artefatos do modelo. Para saber como criar um bucket, consulte [Criar seu primeiro bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) do S3 no *Guia do usuário do Amazon S3*.
1. **Carregar os artefatos do modelo no bucket do S3.** Para obter instruções sobre como carregar seu modelo em seu bucket, consulte [Carregar um objeto em seu bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) no *Guia do usuário do Amazon S3*.
1. **Crie uma função do IAM para a Amazon SageMaker AI.** A Amazon SageMaker AI precisa acessar o bucket do S3 que armazena seu modelo. Crie uma função do IAM com uma política que dê à SageMaker IA acesso de leitura ao seu bucket. O procedimento a seguir mostra como criar uma função no console, mas você também pode usar a [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)API do *Guia do usuário do IAM*. Para obter informações sobre como conceder mais permissões granulares à sua função com base no seu caso de uso, consulte [Como usar funções de execução de SageMaker IA](sagemaker-roles.md#sagemaker-roles-createmodel-perms).
1. [Faça login no console do IAM](https://console.aws.amazon.com/iam/).
1. Na guia de navegação, selecione **Funções**.
1. Selecione **Criar função**.
1. Em **Selecionar tipo de entidade confiável**, escolha **AWS serviço** e, em seguida, escolha **SageMaker AI**.
1. Escolha **Próximo: permissões** e, em seguida, escolha **Próximo: tags**.
1. (Opcional) Adicione tags como pares de chave-valor se desejar ter metadados para a função.
1. Escolha **Próximo: revisar**.
1. Em **Nome da função**, insira um nome para a nova função que seja exclusivo em sua AWS conta. Você não pode editar o nome da função depois de criar a função.
1. (Opcional) Em **Descrição do perfil**, insira uma descrição para o novo perfil.
1. Selecione **Criar perfil**.
1. **Anexe permissões de bucket do S3 à sua função de SageMaker IA.** Depois de criar uma função do IAM, anexe uma política que dê permissão à SageMaker IA para acessar o bucket do S3 que contém os artefatos do seu modelo.
1. Na guia de navegação do console do IAM, escolha **Perfis**.
1. Na lista de funções, pesquise a função que você criou na etapa anterior por nome.
1. Escolha sua função e, em seguida, escolha **Anexar políticas**.
1. Em **Anexar permissões**, escolha **Criar política**.
1. Na visualização de **Criar política**, selecione a guia **JSON**.
1. Adicione as seguintes declarações de política no editor JSON: Certifique-se de substituir o `` pelo nome do bucket do S3 que armazena os artefatos do modelo. Se você deseja restringir o acesso a uma pasta ou arquivo específico em seu bucket, também pode especificar o caminho da pasta do Amazon S3, por exemplo, `/`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
}
```
------
1. Escolha **Próximo: tags**.
1. (Opcional) Adicione tags aos pares de chave-valor à política.
1. Escolha **Próximo: revisar**.
1. Em **Nome**, insira um nome para a nova política.
1. (Opcional) Adicione uma **Descrição** para a política.
1. Selecione **Criar política**.
1. Depois de criar a política, volte para **Roles** no [console do IAM](https://console.aws.amazon.com/iam/) e selecione sua função de SageMaker IA.
1. Escolha **Anexar políticas**.
1. Em **Anexar permissões**, pesquise a política que você criou por nome. Selecione-a e escolha **Anexar política**.
1. **Selecione uma imagem de contêiner do Docker pré-criada ou traga a sua própria.** O contêiner que você escolher serve para inferência em seu endpoint. SageMaker A IA fornece contêineres para algoritmos integrados e imagens pré-criadas do Docker para algumas das estruturas de aprendizado de máquina mais comuns, como Apache, MXNet TensorFlow, PyTorch e Chainer. Para obter uma lista completa das SageMaker imagens disponíveis, consulte Imagens disponíveis de [contêineres de Deep Learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Se nenhum dos contêineres de SageMaker IA existentes atender às suas necessidades, talvez seja necessário criar seu próprio contêiner Docker. Para obter informações sobre como criar sua imagem do Docker e torná-la compatível com a SageMaker IA, consulte[Contêineres com código de inferência personalizado](your-algorithms-inference-main.md). Para usar seu contêiner com um endpoint sem servidor, a imagem do contêiner deve residir em um repositório Amazon ECR dentro da mesma AWS conta que cria o endpoint.
1. **(Opcional) Registre seu modelo no registro de modelos.** SageMaker O [Model Registry](model-registry.md) ajuda você a catalogar e gerenciar versões de seus modelos para uso em pipelines de ML. Para obter mais informações sobre como registrar uma versão do seu modelo, consulte [Criar um grupo de modelos](model-registry-model-group.md) e [Registrar uma versão do modelo](model-registry-version.md). Para obter um exemplo de registro de modelos e fluxo de trabalho da Inferência Sem Servidor, consulte o seguinte [exemplo de caderno](https://github.com/aws/amazon-sagemaker-examples/blob/main/serverless-inference/serverless-model-registry.ipynb):
1. **(Opcional) Traga uma AWS KMS chave.** Ao configurar um endpoint sem servidor, você tem a opção de especificar uma chave KMS que a SageMaker IA usa para criptografar sua imagem do Amazon ECR. Observe que a política de chaves para a chave do KMS deve conceder acesso ao perfil do IAM que você especifica ao configurar seu endpoint. Para saber mais sobre chaves KMS, consulte o [Guia do desenvolvedor do AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
# Criação de endpoint sem servidor
**Importante**
Políticas personalizadas do IAM que permitem que o Amazon SageMaker SageMaker Studio ou o Amazon Studio Classic criem SageMaker recursos da Amazon também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permitir que o Studio e o Studio Classic criem recursos, mas não permitisse a marcação, erros AccessDenied "" podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que dão permissões para criar SageMaker recursos já incluem permissões para adicionar tags ao criar esses recursos.
Para criar um endpoint sem servidor, você pode usar o console Amazon SageMaker AI APIs, o ou o. AWS CLI Você pode criar um endpoint sem servidor usando um processo semelhante ao de um [endpoint em tempo real](realtime-endpoints.md).
**Topics**
+ [Criar um modelo](serverless-endpoints-create-model.md)
+ [Criar uma configuração de endpoint](serverless-endpoints-create-config.md)
+ [Crie um endpoint do](serverless-endpoints-create-endpoint.md)
# Criar um modelo
Para criar seu modelo, você deve fornecer a localização dos artefatos do modelo e da imagem do contêiner. Você também pode usar uma versão de [SageMaker modelo do Model Registry](model-registry.md). Os exemplos nas seções a seguir mostram como criar um modelo usando a [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, o Model Registry e o [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
## Para criar um modelo (usando o Registro de modelo)
O [Model Registry](model-registry.md) é um recurso da SageMaker IA que ajuda você a catalogar e gerenciar versões do seu modelo para uso em pipelines de ML. Para usar o Model Registry com Inferência Sem Servidor, você deve primeiro registrar uma versão do modelo em um grupo de modelos do registro do modelo. Para saber como registrar um modelo no Registro de modelo, siga os procedimentos em [Criar um grupo de modelos](model-registry-model-group.md) e [Registrar uma versão do modelo](model-registry-version.md).
O exemplo a seguir exige que você tenha o ARN de uma versão de modelo registrada e use o [AWS SDK para Python (Boto3) para chamar a API](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html). [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) Para inferência sem servidor, o Model Registry atualmente só é compatível com o AWS SDK for Python (Boto3). Para o exemplo, especifique os seguintes valores:
+ Em `model_name`, insira um nome para o modelo.
+ Para `sagemaker_role` isso, você pode usar a função padrão SageMaker criada pela IA ou uma função personalizada do SageMaker AI IAM da Etapa 4 da [Concluir os pré-requisitos do .](serverless-endpoints-prerequisites.md) seção.
+ Em `ModelPackageName`, especifique o ARN para a versão do seu modelo, que deve estar registrada em um grupo de modelos no registro do modelo.
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Specify a name for the model
model_name = ""
#Specify a Model Registry model version
container_list = [
{
"ModelPackageName":
}
]
#Create the model
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
container_list
)
```
## Como criar um modelo (usando API)
O exemplo a seguir usa o [AWS SDK para Python (Boto3) para chamar a](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) API. [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) Especifique os seguintes valores:
+ Pois `sagemaker_role,` você pode usar a função padrão SageMaker criada pela IA ou uma função personalizada do SageMaker AI IAM da Etapa 4 da [Concluir os pré-requisitos do .](serverless-endpoints-prerequisites.md) seção.
+ Em `model_url`, especifique o URI do Amazon S3 para seu modelo.
+ Em `container`, recupere o contêiner que você deseja usar pelo caminho do Amazon ECR. Este exemplo usa um contêiner SageMaker fornecido pela IA XGBoost . Se você não selecionou um contêiner de SageMaker IA ou trouxe o seu, consulte a Etapa 6 da [Concluir os pré-requisitos do .](serverless-endpoints-prerequisites.md) seção para obter mais informações.
+ Em `model_name`, insira um nome para o modelo.
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Get model from S3
model_url = "s3://amzn-s3-demo-bucket/models/model.tar.gz"
#Get container image (prebuilt example)
from sagemaker import image_uris
container = image_uris.retrieve("xgboost", region, "0.90-1")
#Create model
model_name = ""
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
Containers = [{
"Image": container,
"Mode": "SingleModel",
"ModelDataUrl": model_url,
}]
)
```
## Para criar um modelo (usando o console)
1. Faça login no [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Na guia de navegação, escolha **Inferência**.
1. Em seguida, escolha **Modelos**.
1. Escolha **Criar modelo**.
1. Em **Nome do modelo**, insira um nome para o modelo que seja exclusivo da sua conta Região da AWS e.
1. Para a **função do IAM**, selecione uma função do IAM que você já criou (consulte[Concluir os pré-requisitos do .](serverless-endpoints-prerequisites.md)) ou permita que a SageMaker IA crie uma para você.
1. Em **Definição do contêiner 1**, para **Opções de entrada de contêiner**, selecione **Fornecer artefatos do modelo e local de entrada**.
1. Em **Fornecer artefatos do modelo e opções de imagem de inferência**, selecione **Usar um único modelo**.
1. Em **Localização da imagem do código de inferência**, insira um caminho do Amazon ECR para um contêiner. A imagem deve ser uma imagem primária SageMaker fornecida pela IA (por exemplo TensorFlow, XGBoost) ou uma imagem que resida em um repositório Amazon ECR na mesma conta na qual você está criando o endpoint. Se você não tiver um contêiner, volte para a Etapa 6 da seção [Concluir os pré-requisitos do .](serverless-endpoints-prerequisites.md) para obter mais informações.
1. Em **Local dos artefatos do modelo**, insira o URI do Amazon S3 em seu modelo de ML. Por exemplo, .`s3://amzn-s3-demo-bucket/models/model.tar.gz`
1. (Opcional) Em **Tags**, adicione pares de chave-valor para criar metadados para seu modelo.
1. Escolha **Criar modelo**.
# Criar uma configuração de endpoint
Após criar um modelo, crie uma configuração de endpoint. Em seguida, você pode implantar seu modelo usando as especificações na configuração do endpoint. Na configuração, você especifica se deseja um endpoint em tempo real ou sem servidor. Para criar uma configuração de endpoint sem servidor, você pode usar o [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home), a [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API ou o. AWS CLI As abordagens de API e console estão descritas nas seções a seguir.
## Para criar uma configuração de endpoint (usando API)
O exemplo a seguir usa o [AWS SDK para Python (Boto3) para chamar a](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) API. [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) Especifique os seguintes valores:
+ Em `EndpointConfigName`, escolha um nome para a configuração do endpoint. O nome deve ser exclusivo em sua conta em uma Região.
+ (Opcional) Para`KmsKeyId`, use o ID da chave, o ARN da chave, o nome do alias ou o ARN do alias para uma AWS KMS chave que você deseja usar. SageMaker A IA usa essa chave para criptografar sua imagem do Amazon ECR.
+ Em `ModelName`, use o nome do modelo que você deseja implantar. Deve ser o mesmo modelo que você usou na etapa [Criar um modelo](serverless-endpoints-create-model.md).
+ Para `ServerlessConfig`:
+ Defina `MemorySizeInMB` como `2048`. Neste exemplo, definimos o tamanho da memória para 2048 MB, mas você pode escolher qualquer um dos seguintes valores para o tamanho de memória: 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB ou 6144 MB.
+ Defina `MaxConcurrency` como `20`. Neste exemplo, definimos a simultaneidade máxima como 20. O número máximo de invocações simultâneas que você pode configurar para um endpoint sem servidor é 200, e o valor mínimo que você pode escolher é 1.
+ (Opcional) Para usar a simultaneidade provisionada, defina `ProvisionedConcurrency` como 10. Para este exemplo, configuramos a concorrência provisionada para 10. O número `ProvisionedConcurrency` de um endpoint sem servidor deve ser menor ou igual ao número `MaxConcurrency`. Você pode deixá-lo vazio se quiser usar o endpoint da Inferência Sem Servidor sob demanda. Você pode escalar dinamicamente a simultaneidade de provisões. Para obter mais informações, consulte [Escalar automaticamente a simultaneidade provisionada para um endpoint de sem servidor](serverless-endpoints-autoscale.md).
```
response = client.create_endpoint_config(
EndpointConfigName="",
KmsKeyId="arn:aws:kms:us-east-1:123456789012:key/143ef68f-76fd-45e3-abba-ed28fc8d3d5e",
ProductionVariants=[
{
"ModelName": "",
"VariantName": "AllTraffic",
"ServerlessConfig": {
"MemorySizeInMB": 2048,
"MaxConcurrency": 20,
"ProvisionedConcurrency": 10,
}
}
]
)
```
## Para criar uma configuração de endpoint (usando o console)
1. Faça login no [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Na guia de navegação, escolha **Inferência**.
1. Em seguida, escolha **Configurações de endpoint**.
1. Escolha **Criar configuração de endpoint**.
1. Em **Nome de configuração de endpoint**, digite um nome que seja exclusivo em sua conta em uma região.
1. Em **Tipo de endpoint**, selecione **Tecnologia sem servidor**.
![\[Captura de tela da opção de tipo de endpoint no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config.png)
1. Em **Variantes de produção**, escolha **Adicionar modelo**.
1. Em **Adicionar modelo**, selecione o modelo que você deseja usar na lista de modelos e escolha **Salvar**.
1. Depois de adicionar seu modelo, em **Ações**, escolha **Editar**.
1. Em **Tamanho da memória**, escolha o tamanho da memória que você deseja em GB.
![\[Captura de tela da opção de tamanho da memória no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config-2.png)
1. Em **Simultaneidade máxima**, insira o máximo de invocações simultâneas desejadas para o endpoint. O valor máximo que você pode inserir é 200 e o mínimo é 1.
1. (Opcional) Para usar a simultaneidade provisionada, insira o número desejado de invocações simultâneas no campo de **Configuração de simultaneidade provisionada**. O número de invocações simultâneas provisionadas deve ser menor ou igual ao número máximo de invocações simultâneas.
1. Escolha **Salvar**.
1. (Opcional) Em **Tags**, insira pares de chave-valor se quiser criar metadados para a configuração de endpoint.
1. Escolha **Criar configuração de endpoint**.
# Crie um endpoint do
Para criar um endpoint sem servidor, você pode usar o [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home), a [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API ou o. AWS CLI As abordagens de API e console estão descritas nas seções a seguir. Depois que você criar seu endpoint, poderá levar alguns minutos para que ele fique disponível.
## Para criar um endpoint (usando API)
O exemplo a seguir usa o [AWS SDK para Python (Boto3) para chamar a](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) API. [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) Especifique os seguintes valores:
+ Em`EndpointName`, insira um nome para o endpoint que seja exclusivo em sua conta em uma região.
+ Em `EndpointConfigName`, use o nome da configuração de endpoint que você criou na seção anterior.
```
response = client.create_endpoint(
EndpointName="",
EndpointConfigName=""
)
```
## Para criar um endpoint (usando o console)
1. Faça login no [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Na guia de navegação, escolha **Inferência**.
1. Em seguida, escolha **Endpoints**.
1. Escolha **Criar endpoint**.
1. Em **Nome do endpoint**, insira um nome que seja exclusivo em sua conta em uma região.
1. Em **Anexar configuração de endpoint**, selecione **Usar uma configuração de endpoint existente**.
1. Em **Configuração de endpoint**, selecione o nome da configuração do endpoint que você criou na seção anterior e escolha **Selecionar configuração do endpoint**.
1. (Opcional) Em **Tags**, insira pares de chave-valor se quiser criar metadados para o seu endpoint.
1. Escolha **Criar endpoint**.
![\[Captura de tela da página de criação e configuração de endpoint no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/serverless-endpoints-create.png)
# invocar um endpoint sem servidor
Para realizar uma inferência usando um endpoint sem servidor, é necessário enviar uma solicitação HTTP ao endpoint. Você pode usar a [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API ou a AWS CLI, que faz uma `POST` solicitação para invocar seu endpoint. O tamanho máximo da carga útil da solicitação e resposta para invocações sem servidor é de 4 MB. Em endpoints sem servidor:
+ O modelo deve ser baixado e o servidor deve responder com êxito `/ping` em 3 minutos.
+ O tempo limite para o contêiner responder às solicitações de inferência `/invocations` é de 1 minuto.
## Para invocar um endpoint
O exemplo a seguir usa o [AWS SDK para Python (Boto3) para chamar a](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) API. [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) Observe que, diferentemente das outras chamadas de API neste guia, para`InvokeEndpoint`, você deve usar o SageMaker Runtime Runtime como cliente. Especifique os seguintes valores:
+ Em `endpoint_name`, use o nome do endpoint sem servidor em serviço que você deseja invocar.
+ Em `content_type`, especifique o tipo MIME dos seus dados de entrada no corpo da solicitação (por exemplo, `application/json`).
+ Em `payload`, use a carga útil da solicitação para inferência. Sua carga útil deve estar em bytes ou em um objeto semelhante a um arquivo.
```
runtime = boto3.client("sagemaker-runtime")
endpoint_name = ""
content_type = ""
payload =
response = runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload
)
```
# Atualizar um endpoint sem servidor
Antes de atualizar seu endpoint, crie uma nova configuração de endpoint ou use uma configuração de endpoint existente. A configuração de endpoint é onde você especifica as alterações para sua atualização. Em seguida, você pode atualizar seu endpoint com o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/home), a [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API ou o. AWS CLI O processo de atualização de um endpoint sem servidor é igual ao processo de atualização de um [endpoint em tempo real](realtime-endpoints.md). Observe que, ao atualizar seu endpoint, você pode experimentar inícios frios ao fazer solicitações para o endpoint, pois a SageMaker IA precisa reinicializar seu contêiner e modelo.
Você pode querer atualizar um endpoint sob demanda para um endpoint sem servidor com simultaneidade provisionada ou ajustar o valor de simultaneidade provisionada para um endpoint de sem servidor existente com simultaneidade provisionada. Em ambos os casos, você precisará criar uma configuração de endpoint de sem servidor com o valor desejado para a simultaneidade provisionada e aplicar `UpdateEndpoint` ao endpoint sem servidor existente. Para obter mais informações sobre como criar uma configuração de endpoint de sem servidor com simultaneidade provisionada, consulte [Criar uma configuração de endpoint](serverless-endpoints-create-config.md).
Se você quiser remover a simultaneidade provisionada de um endpoint sem servidor, precisará criar uma configuração de endpoint sem especificar nenhum valor para a simultaneidade provisionada e, em seguida, aplicar `UpdateEndpoint` ao endpoint.
**nota**
Atualmente, não há compatibilidade para atualizar um endpoint de inferência em tempo real para um endpoint sem servidor sob demanda ou um endpoint sem servidor com simultaneidade provisionada.
## Atualizar o endpoint
Depois de criar uma nova configuração de endpoint sem servidor, você pode usar o [console [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)ou o SageMaker AI](https://console.aws.amazon.com/sagemaker/) para atualizar um endpoint sem servidor existente. Exemplos de como atualizar seu endpoint usando o console AWS SDK para Python (Boto3) e o SageMaker AI estão descritos nas seções a seguir.
### Para atualizar o endpoint (usando Boto3)
O exemplo a seguir usa o [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) para chamar o método [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html). Especifique pelo menos os seguintes parâmetros ao chamar o método:
+ Em `EndpointName`, use o nome do endpoint que você está atualizando.
+ Em `EndpointConfigName`, use o nome da configuração de endpoint que você deseja usar para a atualização.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
)
```
### Para atualizar o endpoint (usando o console)
1. Faça login no [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Na guia de navegação, escolha **Inferência**.
1. Em seguida, escolha **Endpoints**.
1. Na lista de endpoints, selecione o endpoint que você deseja atualizar.
1. Escolha **Alterar** na seção de **Configurações de endpoint**.
1. Em **Alterar a configuração de endpoint**, escolha **Usar uma configuração de endpoint existente**.
1. Na lista de configurações de endpoint, selecione aquela que você deseja usar para sua atualização.
1. Escolha **Selecionar configuração de endpoint**.
1. Escolha **Atualizar endpoint**.
# Descrever um endpoint sem servidor
Talvez você queira recuperar informações sobre seu endpoint, incluindo detalhes como o ARN do endpoint, o status atual, a configuração da implantação e os motivos da falha. Você pode encontrar informações sobre seu endpoint usando o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/home), a [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API ou o. AWS CLI
## Para descrever um endpoint (usando API)
O exemplo a seguir usa o [AWS SDK para Python (Boto3) para chamar a](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#id309) API. [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) Em `EndpointName`, use o nome do endpoint que você deseja verificar.
```
response = client.describe_endpoint(
EndpointName="",
)
```
## Para descrever um endpoint (usando o console)
1. Faça login no [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Na guia de navegação, escolha **Inferência**.
1. Em seguida, escolha **Endpoints**.
1. Na lista de endpoints, escolha o endpoint que deseja verificar.
A página do endpoint contém as informações sobre seu endpoint.
# Excluir um endpoint sem servidor
Você pode excluir seu endpoint sem servidor usando o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/home), a [DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)API ou o. AWS CLI Os exemplos a seguir mostram como excluir seu endpoint por meio da API e do console de SageMaker IA.
## Para excluir um endpoint (usando a API)
O exemplo a seguir usa o [AWS SDK para Python (Boto3) para chamar a](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) API. [DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) Em `EndpointName`, use o nome do endpoint sem servidor que você deseja excluir.
```
response = client.delete_endpoint(
EndpointName="",
)
```
## Para excluir um endpoint (usando o console)
1. Faça login no [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Na guia de navegação, escolha **Inferência**.
1. Em seguida, escolha **Endpoints**.
1. Na lista de endpoints, selecione o endpoint que você deseja excluir.
1. Escolha a lista suspensa **Ações** e depois escolha **Excluir**.
1. Quando solicitado, escolha **Excluir**.
Seu endpoint agora deve iniciar o processo de exclusão.
# Alarmes e logs para rastrear métricas de endpoints com tecnologia sem servidor
Para monitorar seu endpoint sem servidor, você pode usar os alarmes do Amazon CloudWatch. O CloudWatch é um serviço que coleta métricas em tempo real de suas aplicações e recursos da AWS. Um alarme monitora as métricas à medida que elas são coletadas e oferece a capacidade de pré-especificar um limite e as ações a serem tomadas se esse limite for violado. Por exemplo, seu alarme do CloudWatch pode enviar uma notificação se seu endpoint ultrapassar um limite de erro. Ao configurar os alarmes do CloudWatch, você ganha visibilidade do desempenho e da funcionalidade do seu endpoint. Para obter mais informações sobre alarmes do CloudWatch, consulte [Usando alarmes do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html), no *Guia do usuário do Amazon CloudWatch*.
## Monitoramento com CloudWatch
As métricas abaixo são uma lista completa de métricas para endpoints sem servidor. Qualquer métrica não listada abaixo não é publicada para endpoints sem servidor. Para ter mais informações sobre as métricas a seguir, consulte [Monitor Amazon SageMaker AI with Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
### Métricas gerais de endpoint
Essas métricas do CloudWatch são as mesmas publicadas para endpoints em tempo real.
A métrica `OverheadLatency` rastreia toda a latência adicional que o SageMaker AI adicionou, que inclui o tempo de início a frio para o lançamento de novos recursos de computação para seu endpoint sem servidor. Em comparação com os endpoints sem servidor sob demanda, a `OverheadLatency` para endpoints sem servidor com simultaneidade provisionada geralmente é significativamente menor.
Os endpoints sem servidor também podem usar as métricas `Invocations4XXErrors`, `Invocations5XXErrors`, `Invocations`, `ModelLatency`, `ModelSetupTime` e `MemoryUtilization`. Para saber mais sobre essas métricas, consulte [SageMaker Métricas de invocação de endpoints de IA](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation).
### Métricas gerais de endpoint de tecnologia sem servidor
Essas métricas do CloudWatch são publicadas tanto para endpoints sem servidor sob demanda quanto para endpoints sem servidor com simultaneidade provisionada.
| Nome da métrica | Descrição | Unidade/Estatísticas |
| --- | --- | --- |
| ServerlessConcurrentExecutionsUtilization | O número de execuções simultâneas dividido pela simultaneidade máxima. | Unidades: nenhumaEstatísticas válidas: média, máx. e mín. |
### Endpoint sem servidor com métrica de simultaneidade provisionada
Essas métricas do CloudWatch são publicadas para endpoints sem servidor com simultaneidade provisionada.
| Nome da métrica | Descrição | Unidade/Estatísticas |
| --- | --- | --- |
| ServerlessProvisionedConcurrencyExecutions | O número de execuções simultâneas que estão sendo processadas pelo endpoint. | Unidades: contagemEstatísticas válidas: média, máx. e mín. |
| ServerlessProvisionedConcurrencyUtilization | O número de execuções simultâneas dividido pela simultaneidade provisionada alocada. | Unidades: nenhumaEstatísticas válidas: média, máx. e mín. |
| ServerlessProvisionedConcurrencyInvocations | O número de solicitações InvokeEndpoint tratadas pela simultaneidade provisionada. | Unidades: contagemEstatísticas válidas: média, máx. e mín. |
| ServerlessProvisionedConcurrencySpilloverInvocations | O número de solicitações InvokeEndpoint não tratadas pela simultaneidade provisionada, que é tratada pela Inferência Sem Servidor sob demanda. | Unidades: contagemEstatísticas válidas: média, máx. e mín. |
## Logs
Se você quiser monitorar os logs do seu endpoint para depuração ou análise de progresso, você pode usar o Amazon CloudWatch Logs. O grupo de logs fornecido pelo SageMaker AI que você pode usar para endpoints sem servidor é `/aws/sagemaker/Endpoints/[EndpointName]`. Para ter mais informações sobre como usar o CloudWatch Logs no SageMaker AI, consulte [CloudWatch Registros para Amazon SageMaker AI](logging-cloudwatch.md). Para saber mais sobre o CloudWatch Logs, consulte [O que é o Amazon CloudWatch Logs?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) no *Guia do usuário do Amazon CloudWatch Logs*.
# Escalar automaticamente a simultaneidade provisionada para um endpoint de sem servidor
O Amazon SageMaker AI aumenta ou reduz automaticamente a escala na horizontal de endpoints sem servidor sob demanda. Para endpoints sem servidor com simultaneidade provisionada, você pode usar o Application Auto Scaling para aumentar ou reduzir a escala horizontalmente da simultaneidade provisionada com base em seu perfil de tráfego, otimizando assim os custos.
A seguir estão os pré-requisitos para escalar automaticamente a simultaneidade provisionada em endpoints sem servidor:
+ [Registrar um modelo](#serverless-endpoints-autoscale-register)
+ [Definir uma política de escalabilidade](#serverless-endpoints-autoscale-define)
+ [Aplicar uma política de escalabilidade](#serverless-endpoints-autoscale-apply)
Antes de usar o ajuste de escala automático, você já deve ter implantado um modelo em um endpoint sem servidor com simultaneidade provisionada. Os modelos implantados são referidos como [variantes de produção](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html). Consulte [Criar uma configuração de endpoint](serverless-endpoints-create-config.md) e [Crie um endpoint do](serverless-endpoints-create-endpoint.md) para obter mais informações sobre a implantação de um modelo em um endpoint sem servidor com simultaneidade provisionada. Para especificar as métricas e os valores de destino de uma política de escalabilidade, você precisa configurar uma política de rastreamento. Para obter mais informações sobre como definir uma política de escalabilidade, consulte [Definir uma política de escalabilidade](#serverless-endpoints-autoscale-define). Depois de registrar o modelo e definir uma política de escalabilidade, aplique a política de escalabilidade ao modelo registrado. Para obter mais informações sobre como aplicar a política de escalabilidade, consulte [Aplicar uma política de escalabilidade](#serverless-endpoints-autoscale-apply).
Para obter detalhes sobre outros pré-requisitos e componentes usados com o ajuste de escala automático, consulte a seção [Pré-requisitos de ajuste de escala automático](endpoint-auto-scaling-prerequisites.md) na documentação de ajuste de escala automático do [SageMaker AI](endpoint-auto-scaling.md).
## Registrar um modelo
Para adicionar ajuste de escala automático a um endpoint sem servidor com simultaneidade provisionada, primeiro você deve registrar seu modelo (variante de produção) usando a AWS CLI ou a API do Application Auto Scaling.
### Registrar um modelo (AWS CLI)
Para registrar seu modelo, use o comando `register-scalable-target` da AWS CLI com os seguintes parâmetros:
+ `--service-namespace`: defina este valor como `sagemaker`.
+ `--resource-id`: o identificador de recurso para o modelo (especificamente, a variante de produção). Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante de produção. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `--scalable-dimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `--min-capacity`: O número mínimo de simultaneidade provisionada para o modelo. Defina `--min-capacity` como pelo menos 1. Deve ser igual ou menor que o valor especificado para `--max-capacity`.
+ `--max-capacity`: o número máximo de simultaneidade provisionada que deve ser ativada por meio da aplicação Auto Scaling. Defina `--max-capacity` para um mínimo de 1. Deve ser maior que ou igual ao valor especificado para `--min-capacity`.
O seguinte exemplo mostra como registrar um modelo chamado `MyVariant` que é dinamicamente escalado para ter de um valor simultaneamente provisionado de 1 a 10:
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--min-capacity 1 \
--max-capacity 10
```
### Registro de um modelo (API da aplicação Auto Scaling)
Para registrar seu modelo, use a ação `RegisterScalableTarget` da API da aplicação Auto Scaling com os seguintes parâmetros:
+ `ServiceNamespace`: defina este valor como `sagemaker`.
+ `ResourceId`: o identificador de recurso para o modelo (especificamente, a variante de produção). Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante de produção. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `ScalableDimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `MinCapacity`: O número mínimo de simultaneidade provisionada para o modelo. Defina `MinCapacity` como pelo menos 1. Deve ser igual ou menor que o valor especificado para `MaxCapacity`.
+ `MaxCapacity`: o número máximo de simultaneidade provisionada que deve ser ativada por meio da aplicação Auto Scaling. Defina `MaxCapacity` para um mínimo de 1. Deve ser maior que ou igual ao valor especificado para `MinCapacity`.
O seguinte exemplo mostra como registrar um modelo chamado `MyVariant` que é dinamicamente escalado para ter de um valor simultaneamente provisionado de 1 a 10:
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndPoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"MinCapacity": 1,
"MaxCapacity": 10
}
```
## Definir uma política de escalabilidade
Para especificar as métricas e os valores de destino de uma política de escalabilidade, você pode configurar uma política de escalabilidade de rastreamento de destino. Defina a política de escalabilidade como um bloco JSON em um arquivo de texto. Você pode, então, usar esse arquivo de texto ao invocar a AWS CLI ou a API da aplicação Auto Scaling. Use a métrica predefinida `SageMakerVariantProvisionedConcurrencyUtilization` para definir rapidamente a política de escalabilidade de rastreamento de destino.
```
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
},
"ScaleOutCooldown": 1,
"ScaleInCooldown": 1
}
```
## Aplicar uma política de escalabilidade
Depois de registrar seu modelo, você pode aplicar uma política de ajuste de escala ao endpoint sem servidor com a simultaneidade provisionada. Consulte [Aplicar uma política de escalabilidade de rastreamento de destino](#serverless-endpoints-autoscale-apply-target) para aplicar uma política de escalabilidade de rastreamento de destino que você definiu. Se o fluxo de tráfego para o endpoint sem servidor tiver uma rotina previsível, em vez de aplicar uma política de ajuste de escala de rastreamento de metas, talvez você queira agendar ações de ajuste de escala em horários específicos. Para obter mais informações sobre ações de escalabilidade programada, consulte [Escalabilidade programada](#serverless-endpoints-autoscale-apply-scheduled).
### Aplicar uma política de escalabilidade de rastreamento de destino
Você pode usar o Console de gerenciamento da AWS, a AWS CLI ou a API do Application Auto Scaling para aplicar uma política de ajuste de escala de rastreamento de destino ao endpoint sem servidor com simultaneidade provisionada.
#### Aplicar uma política de ajuste de escala de rastreamento de destino (AWS CLI)
Para aplicar uma política de ajuste de escala ao modelo, use o comando `put-scaling-policy` da AWS CLI com os seguintes parâmetros:
+ `--policy-name`: o nome da política de ajuste de escala.
+ `--policy-type`: defina este valor como `TargetTrackingScaling`.
+ `--resource-id`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace`: defina este valor como `sagemaker`.
+ `--scalable-dimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `--target-tracking-scaling-policy-configuration`: a configuração da política de ajuste de escala de rastreamento de destino a ser usada para o modelo.
O exemplo a seguir mostra como aplicar a política de escalabilidade de rastreamento de destino chamada `MyScalingPolicy` para um modelo chamado `MyVariant`. A configuração de política é salva em um arquivo chamado `scaling-policy.json`.
```
aws application-autoscaling put-scaling-policy \
--policy-name MyScalingPolicy \
--policy-type TargetTrackingScaling \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--target-tracking-scaling-policy-configuration file://[file-localtion]/scaling-policy.json
```
#### Aplique uma política de ajuste de escala de rastreamento de destino (aplicação Auto Scaling API)
Para aplicar uma política de escalabilidade ao seu modelo, use a ação `PutScalingPolicy` da API do aplicativo Auto Scaling com os seguintes parâmetros:
+ `PolicyName` – o nome da política de escalabilidade.
+ `PolicyType`: defina este valor como `TargetTrackingScaling`.
+ `ResourceId`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace`: defina este valor como `sagemaker`.
+ `ScalableDimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `TargetTrackingScalingPolicyConfiguration`: a configuração da política de ajuste de escala de rastreamento de destino a ser usada para o modelo.
O exemplo a seguir mostra como aplicar a política de escalabilidade de rastreamento de destino chamada `MyScalingPolicy` para um modelo chamado `MyVariant`. A configuração de política é salva em um arquivo chamado `scaling-policy.json`.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration":
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
}
}
}
```
#### Aplicar uma política de esc labilidade de rastreamento de destino (Console de gerenciamento da AWS)
Aplicar uma política de escalabilidade de rastreamento de destino com o Console de gerenciamento da AWS:
1. Faça login no [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, escolha **Inferência**.
1. Escolha **Endpoints** para ver uma lista de todos os seus endpoints.
1. Escolha o endpoint ao qual você deseja aplicar a política de escalabilidade. Uma página com as configurações do endpoint será exibida, com os modelos (variante de produção) listados na seção **Configurações de runtime do endpoint**.
1. Selecione a variante de produção à qual você deseja aplicar a política de ajuste de escala e escolha **Configurar ajuste de escala automático**. A caixa de diálogo **Configurar ajuste de escala automático da variante** é exibida.
![\[Captura de tela da caixa de diálogo de configuração do ajuste de escala automático da variante no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/serverless-endpoints-variant-autoscaling.png)
1. Insira os valores mínimo e máximo de simultaneidade provisionada nos campos **Simultaneidade provisionada mínima** e **Simultaneidade máxima provisionada**, respectivamente, na seção **Ajuste automático de escala variável**. A Simultaneidade Mínima Provisionada deve ser menor ou igual à Simultaneidade Provisionada Mínima.
1. Insira o valor alvo no campo **Valor alvo** para a métrica alvo, `SageMakerVariantProvisionedConcurrencyUtilization`.
1. (Opcional) Insira os valores de escala em resfriamento e redução de resfriamento (em segundos) nos campos **Escalar em resfriamento** e **Escalar em resfriamento**, respectivamente.
1. (Opcional) Selecione **Desabilitar a redução** se você não quiser que o ajuste de escala automático exclua a instância quando o tráfego diminuir.
1. Selecione **Salvar**.
### Escalabilidade programada
Se o tráfego para o endpoint sem servidor com simultaneidade provisionada seguir um padrão de rotina, talvez você queira programar ações de ajuste de escala em horários específicos, para aumentar ou reduzir a escala horizontalmente da simultaneidade provisionada. Você pode usar a AWS CLI ou o Application Auto Scaling para programar ações de ajuste de escala.
#### Escalabilidade programada (AWS CLI)
Para aplicar uma política de escalabilidade ao modelo, use o comando `put-scheduled-action` AWS CLI com os seguintes parâmetros:
+ `--schedule-action-name`: o nome da atividade de ajuste de escala.
+ `--schedule`: uma expressão cron que especifica os horários de início e término da ação de ajuste de escala com um cronograma recorrente.
+ `--resource-id`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace`: defina este valor como `sagemaker`.
+ `--scalable-dimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `--scalable-target-action`: o alvo da ação de ajuste de escala.
O seguinte exemplo mostra como adicionar uma atividade de ajuste de escala nomeada `MyScalingAction` a um modelo nomeado `MyVariant` em uma programação recorrente: Na programação especificada (todo dia às 12h15 UTC), se a simultaneidade provisionada atual for inferior ao valor especificado para `MinCapacity`. A aplicação Auto Scaling expande a simultaneidade provisionada para o valor especificado por `MinCapacity`.
```
aws application-autoscaling put-scheduled-action \
--scheduled-action-name 'MyScalingAction' \
--schedule 'cron(15 12 * * ? *)' \
--service-namespace sagemaker \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--scalable-target-action 'MinCapacity=10'
```
#### Ajuste de escala programado (API do Application Auto Scaling)
Para aplicar uma política de ajuste de escala ao seu modelo, use a ação `PutScheduledAction` da API do Application Auto Scaling com os seguintes parâmetros:
+ `ScheduleActionName`: o nome da atividade de ajuste de escala.
+ `Schedule`: uma expressão cron que especifica os horários de início e término da ação de ajuste de escala com um cronograma recorrente.
+ `ResourceId`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace`: defina este valor como `sagemaker`.
+ `ScalableDimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `ScalableTargetAction`: o alvo da ação de ajuste de escala.
O seguinte exemplo mostra como adicionar uma atividade de ajuste de escala nomeada `MyScalingAction` a um modelo nomeado `MyVariant` em uma programação recorrente: Na programação especificada (todo dia às 12h15 UTC), se a simultaneidade provisionada atual for inferior ao valor especificado para `MinCapacity`. A aplicação Auto Scaling expande a simultaneidade provisionada para o valor especificado por `MinCapacity`.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScheduledAction
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ScheduledActionName": "MyScalingAction",
"Schedule": "cron(15 12 * * ? *)",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"ScalableTargetAction": "MinCapacity=10"
}
}
}
```
# Limpeza
Depois de terminar de usar o ajuste de escala automático para o endpoint sem servidor com simultaneidade provisionada, você deve limpar os recursos que criou. Isso envolve excluir a política de ajuste de escala e cancelar o registro do modelo do Application Auto Scaling. A limpeza garante que você não incorra em custos desnecessários com recursos que você não está mais utilizando.
## Excluir uma política de escalabilidade
Você pode excluir uma política de ajuste de escala usando o Console de gerenciamento da AWS, AWS CLI ou a API da aplicação Auto Scaling. Para ter mais informações sobre como excluir uma política de ajuste de escala com o Console de gerenciamento da AWS, consulte [Excluir uma política de escalabilidade](endpoint-auto-scaling-delete.md) na [documentação de ajuste de escala automático do SageMaker AI](endpoint-auto-scaling.md).
### Excluir uma política de escalabilidade (AWS CLI)
Para aplicar uma política de escalabilidade ao modelo, use o comando `delete-scaling-policy` AWS CLI com os seguintes parâmetros:
+ `--policy-name`: o nome da política de ajuste de escala.
+ `--resource-id`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace`: defina este valor como `sagemaker`.
+ `--scalable-dimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
O exemplo a seguir exclui a uma política de escalabilidade `MyScalingPolicy` do modelo chamado `MyVariant`.
```
aws application-autoscaling delete-scaling-policy \
--policy-name MyScalingPolicy \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### Exclua uma política de escalabilidade (API do Application Auto Scaling)
Para excluir uma política de ajuste de escala ao seu modelo, use a ação `DeleteScalingPolicy` da API da aplicação Auto Scaling com os seguintes parâmetros:
+ `PolicyName`: o nome da política de ajuste de escala.
+ `ResourceId`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace`: defina este valor como `sagemaker`.
+ `ScalableDimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
O seguinte exemplo usa a API da aplicação Auto Scaling para excluir uma política de ajuste de escala chamada `MyScalingPolicy` de um modelo chamado `MyVariant`:
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
## Cancelar o registro de um modelo
Você pode cancelar o registro de um modelo usando o Console de gerenciamento da AWS, AWS CLI ou a API da aplicação Auto Scaling.
### Cancelar o registro de um modelo (AWS CLI)
Para cancelar o registro de um modelo da aplicação Auto Scaling, use `deregister-scalable-target` AWS CLI; comando com os seguintes parâmetros:
+ `--resource-id`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace`: defina este valor como `sagemaker`.
+ `--scalable-dimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
O seguinte exemplo cancela o registro de um modelo chamado `MyVariant` da aplicação Auto Scaling:
```
aws application-autoscaling deregister-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### Cancelar o registro de um modelo (API da aplicação Auto Scaling)
Para cancelar o registro de um modelo da aplicação Auto Scaling, use a ação `DeregisterScalableTarget` da API da aplicação Auto Scaling com os seguintes parâmetros:
+ `ResourceId`: o identificador do recurso para a variante. Para esse parâmetro, o tipo de recurso é `endpoint` e o identificador exclusivo é o nome da variante. Por exemplo, `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace`: defina este valor como `sagemaker`.
+ `ScalableDimension`: defina este valor como `sagemaker:variant:DesiredProvisionedConcurrency`.
O exemplo a seguir usa a API da aplicação Auto Scaling para cancelar o registro de um modelo chamado `MyVariant` da aplicação Auto Scaling.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeregisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
### Cancelar o registro de um modelo (Console de gerenciamento da AWS)
Para cancelar o registro de um modelo (variante de produção) com: Console de gerenciamento da AWS
1. Abra o [console do Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, escolha **Inferência**.
1. Escolha **Endpoints** para ver uma lista dos seus endpoints.
1. Escolha o endpoint sem servidor que hospeda a variante de produção. Uma página com as configurações do endpoint será exibida, com as variantes de produção listadas na seção **Configurações de runtime do endpoint**.
1. Selecione a variante de produção cujo registro você deseja cancelar e escolha **Configurar ajuste de escala automático**. A caixa de diálogo **Configurar ajuste de escala automático da variante** é exibida.
1. Escolha **Cancelar registro de ajuste de escala automático**.
# Solução de problemas
**Importante**
Políticas personalizadas do IAM que permitem que o Amazon SageMaker Studio ou o Amazon SageMaker Studio Classic criem recursos do Amazon SageMaker também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permitir que o Studio e o Studio Classic criem recursos, mas não permitir o uso de tags, erros de “AccessDenied” podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md) que dão permissões para criar recursos do SageMaker já incluem permissões para adicionar tags ao criar esses recursos.
Se você estiver tendo problemas com a Inferência Sem Servidor, consulte as dicas de solução de problemas a seguir.
## Problemas de contêiner
Se o contêiner usado para um endpoint sem servidor for o mesmo usado em um endpoint baseado em instância, seu contêiner pode não ter permissões para gravar arquivos. Isso pode acontecer por um dos seguintes motivos:
+ Seu endpoint sem servidor não consegue ser criado ou atualizado devido a uma falha na verificação de integridade do ping.
+ Os logs do Amazon CloudWatch Logs para o endpoint mostram que o contêiner está falhando ao gravar em algum arquivo ou diretório devido a um erro de permissão.
Para corrigir esse problema, você pode tentar adicionar permissões de leitura, gravação e execução para `other` no arquivo ou diretório e, em seguida, reconstruir o contêiner. Execute as seguintes etapas para concluir este tutorial:
1. No Dockerfile que você usou para criar seu contêiner, adicione o seguinte comando: `RUN chmod o+rwX `
1. Reconstrua o contêiner.
1. Carregue a nova imagem no registro do contêiner do Amazon ECR.
1. Tente criar ou atualizar o endpoint sem servidor novamente.
# Inferência assíncrona
O Amazon SageMaker Asynchronous Inference é um recurso de SageMaker IA que enfileira as solicitações recebidas e as processa de forma assíncrona. Essa opção é ideal para solicitações com grandes tamanhos de carga útil (até 1 GB), tempos de processamento longos (até uma hora) e requisitos de latência quase em tempo real. A inferência assíncrona permite que você economize custos escalando automaticamente a contagem de instâncias para zero quando não há solicitações para processar, então você só paga quando seu endpoint está processando solicitações.
## Como funciona
A criação de um endpoint de inferência assíncrona é semelhante à criação de endpoints de inferência em tempo real. Você pode usar seus modelos de SageMaker IA existentes e só precisa especificar o `AsyncInferenceConfig` objeto ao criar sua configuração de endpoint com o `EndpointConfig` campo na `CreateEndpointConfig` API. O diagrama seguinte mostra a arquitetura e o fluxo de trabalho da inferência assíncrona:
![\[O diagrama de arquitetura da Inferência Assíncrona mostra como um usuário invoca um endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/async-architecture.png)
Para invocar o endpoint, você precisa colocar a carga útil da solicitação no Amazon S3. Você também precisa fornecer um ponteiro para essa carga útil como parte da solicitação `InvokeEndpointAsync`. Após a invocação, a SageMaker IA enfileira a solicitação para processamento e retorna um identificador e um local de saída como resposta. Após o processamento, a SageMaker IA coloca o resultado no local do Amazon S3. Opcionalmente, você pode escolher receber notificações de sucesso ou erro com o Amazon SNS. Para obter mais informações sobre como configurar notificações assíncronas, consulte [Verifique dos resultados da previsão](async-inference-check-predictions.md).
**nota**
A presença de um objeto de configuração de inferência assíncrona (`AsyncInferenceConfig`) na configuração de endpoint implica que o endpoint só pode receber invocações assíncronas.
## Como faço para começar?
Se você for um usuário iniciante do Amazon SageMaker Asynchronous Inference, recomendamos que você faça o seguinte:
+ Leia [Operações assíncronas do endpoint](async-inference-create-invoke-update-delete.md) para obter informações sobre como criar, invocar, atualizar e excluir um endpoint assíncrono.
+ [Explore o [caderno de exemplo de inferência assíncrona](https://github.com/aws/amazon-sagemaker-examples/blob/main/async-inference/Async-Inference-Walkthrough.ipynb) no repositório aws/. amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) GitHub
Observe que, se seu endpoint usar qualquer um dos atributos listados nesta página de [Exclusions](deployment-guardrails-exclusions.md), você não poderá usar a inferência assíncrona.
# Operações assíncronas do endpoint
Este guia demonstra os pré-requisitos que você deve satisfazer para criar um endpoint assíncrono, além de como criar, invocar e excluir seus endpoints assíncronos. [Você pode criar, atualizar, excluir e invocar endpoints assíncronos com o SDK e o AWS SDKs Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-asynchronous-inference)
**Topics**
+ [Concluir os pré-requisitos do .](async-inference-create-endpoint-prerequisites.md)
+ [Como criar um Endpoint de Inferência Assíncrona](async-inference-create-endpoint.md)
+ [Invocar um endpoint assíncrono](async-inference-invoke-endpoint.md)
+ [Atualizar um endpoint assíncrono](async-inference-update-endpoint.md)
+ [Excluir um endpoint assíncrono](async-inference-delete-endpoint.md)
# Concluir os pré-requisitos do .
O tópico a seguir descreve os pré-requisitos que você deve completar antes de criar um endpoint assíncrono. Esses pré-requisitos incluem armazenar adequadamente os artefatos do modelo, configurar um AWS IAM com as permissões corretas e selecionar uma imagem de contêiner.
**Como concluir os pré-requisitos**
1. **Crie uma função do IAM para a Amazon SageMaker AI.**
A inferência assíncrona precisa de acesso ao URI do bucket do Amazon S3. Para facilitar isso, crie uma função do IAM que possa executar SageMaker IA e tenha permissão para acessar o Amazon S3 e o Amazon SNS. Usando essa função, a SageMaker IA pode ser executada em sua conta e acessar seu bucket do Amazon S3 e tópicos do Amazon SNS.
Você pode criar uma função do IAM usando o console do IAM AWS SDK para Python (Boto3), ou AWS CLI. Veja a seguir um exemplo de como criar um perfil do IAM e anexar as políticas necessárias ao console do IAM.
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação do console do IAM, escolha **Funções** e, em seguida, **Criar função**.
1. Em **Selecionar tipo de entidade confiável**, selecione serviço **AWS **.
1. Escolha o serviço que você deseja que assuma essa função. Nesse caso, escolha **SageMaker AI**. Então, escolha **Próximo: permissões**.
+ Isso cria automaticamente uma política do IAM que concede acesso a serviços relacionados, como Amazon S3, Amazon ECR e Logs. CloudWatch
1. Escolha **Próximo: tags**.
1. (Opcional) Adicione metadados à função anexando tags como pares de chave-valor. Para obter mais informações sobre como usar rótulos no IAM, consulte [Recursos de etiquetas do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Escolha **Próximo: revisar**.
1. Digite um **Nome da função**.
1. Se possível, digite um nome de função ou um sufixo de nome de função. Os nomes das funções devem ser exclusivos em sua AWS conta. Eles não são diferenciados por maiúsculas e minúsculas. Por exemplo, não é possível criar perfis denominados `PRODROLE` e `prodrole`. Como outros AWS recursos podem fazer referência à função, você não pode editar o nome da função após sua criação.
1. (Opcional) Em **Descrição da função**, digite uma descrição para a nova função.
1. Revise a função e escolha **Criar função**.
Observe a função ARN da SageMaker IA. Para encontrar o ARN da função usando o console, faça o seguinte:
1. Acesse o console do IAM: [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Selecione **Funções**.
1. Pesquise a função que acabou de criar digitando o nome da função no campo de pesquisa.
1. Selecione a função.
1. O ARN do perfil está na parte superior da página de **resumo**.
1. **Adicione permissões do Amazon SageMaker AI, Amazon S3 e Amazon SNS à sua função do IAM.**
Depois que a função for criada, conceda permissões de SageMaker IA, Amazon S3 e, opcionalmente, Amazon SNS para sua função do IAM.
Escolha **Funções** no console do IAM. Pesquise a função que você criou digitando o nome da função no campo **Pesquisa**.
1. Escolha sua função.
1. Em seguida, escolha **Anexar políticas**.
1. O Amazon SageMaker Asynchronous Inference precisa de permissão para realizar as seguintes ações:`"sagemaker:CreateModel"`,, e. `"sagemaker:CreateEndpointConfig"` `"sagemaker:CreateEndpoint"` `"sagemaker:InvokeEndpointAsync"`
Essas ações estão incluídas na política `AmazonSageMakerFullAccess`. Adicione essa política à sua perfil do IAM. Busque `AmazonSageMakerFullAccess` no campo de **Pesquisa**. Selecione `AmazonSageMakerFullAccess`.
1. Escolha **Anexar política**.
1. Em seguida, escolha **Anexar políticas** para adicionar permissões do Amazon S3.
1. Selecione **Criar política**.
1. Selecione a guia `JSON`.
1. Adicione a seguinte declaração de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::bucket_name/*"
}
]
}
```
------
1. Escolha **Próximo: tags**.
1. Digite o **Nome da política**.
1. Escolha **Criar política**.
1. Repita as mesmas etapas que você concluiu para adicionar permissões do Amazon S3 para adicionar permissões do Amazon SNS. Para a declaração de política, anexe o seguinte:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sns:Publish"
],
"Effect": "Allow",
"Resource": "arn:aws:sns:us-east-1:111122223333:SNS_Topic"
}
]
}
```
------
1. **Carregue seus dados de inferência (por exemplo, modelo de machine learning, dados de exemplo) no **Amazon S3**.**
1. **Selecione uma imagem de inferência Docker pré-criada ou crie sua própria imagem do Docker de inferência.**
SageMaker A IA fornece contêineres para seus algoritmos integrados e imagens pré-criadas do Docker para algumas das estruturas de aprendizado de máquina mais comuns, como Apache, MXNet TensorFlow, PyTorch e Chainer. Para ver uma lista completa das imagens de SageMaker IA disponíveis, consulte Imagens de [contêineres de Deep Learning Disponíveis](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Se você optar por usar um contêiner fornecido por SageMaker IA, poderá aumentar o tempo limite do endpoint e os tamanhos da carga útil em relação ao padrão definindo as variáveis de ambiente no contêiner. Para saber como definir as diferentes variáveis de ambiente de cada estrutura, consulte a etapa Criar um modelo da criação de um endpoint assíncrono.
Se nenhum dos contêineres de SageMaker IA existentes atender às suas necessidades e você não tiver um contêiner próprio, talvez seja necessário criar um novo contêiner Docker. Consulte [Contêineres com código de inferência personalizado](your-algorithms-inference-main.md) para obter informações sobre como criar sua imagem do Docker.
1. **Crie um tópico do Amazon SNS (opcional)**
Crie um tópico do Amazon Simple Notification Service (Amazon SNS) que envie notificações sobre solicitações que concluíram o processamento. O Amazon SNS é um serviço de notificação para aplicações orientados a mensagens, em que vários assinantes solicitam e recebem notificações “push” de mensagens urgentes de uma variedade de protocolos de transporte, incluindo HTTP, Amazon SQS e e-mail. Você pode especificar tópicos do Amazon SNS quando criar um objeto `EndpointConfig` ao especificar o `AsyncInferenceConfig` usando o API `EndpointConfig`.
Siga as etapas para criar e assinar um tópico do Amazon SNS.
1. Usando o console do Amazon SNS, crie um tópico. Para obter instruções, consulte [Criação de um tópico do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html) no *Guia do desenvolvedor* do *Amazon Simple Notification Service*.
1. Inscreva-se no tópico. Para obter instruções, consulte [Assinatura de um tópico do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) no *Guia do desenvolvedor* do *Amazon Simple Notification Service*.
1. Ao receber um e-mail solicitando que confirme sua assinatura no tópico, confirme a assinatura.
1. Anote o nome do recurso da Amazon (ARN) do tópico. O tópico do Amazon SNS que você criou é outro recurso em sua AWS conta e tem um ARN exclusivo. O formato do ARN é o seguinte:
```
arn:aws:sns:aws-region:account-id:topic-name
```
Para obter mais informações sobre o Amazon SNS, consulte o [Guia do desenvolvedor do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html).
# Como criar um Endpoint de Inferência Assíncrona
Crie um endpoint assíncrono da mesma forma que você criaria um endpoint usando serviços de hospedagem de IA: SageMaker
+ Crie um modelo em SageMaker IA com `CreateModel` o.
+ Criar uma configuração de endpoint com `CreateEndpointConfig`.
+ Crie um endpoint HTTPS com `CreateEndpoint`.
Para criar um endpoint, primeiro você cria um modelo com [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), onde aponta para o artefato do modelo e um caminho de registro do Docker (Imagem). Em seguida, você cria uma configuração usando a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)qual especifica um ou mais modelos que foram criados usando a `CreateModel` API para implantação e os recursos que você deseja que a SageMaker IA provisione. Crie um endpoint com [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) usando a configuração de endpoint especificada na solicitação. Você pode atualizar um endpoint assíncrono com a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Envie e receba solicitações de inferência do modelo hospedado no endpoint com `InvokeEndpointAsync`. Você pode excluir seus endpoints com a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html).
Para obter uma lista completa das SageMaker imagens disponíveis, consulte Imagens disponíveis de [contêineres de Deep Learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Consulte [Contêineres com código de inferência personalizado](your-algorithms-inference-main.md) para obter informações sobre como criar sua imagem do Docker.
**Topics**
+ [Criar um modelo](async-inference-create-endpoint-create-model.md)
+ [Criar uma configuração de endpoint](async-inference-create-endpoint-create-endpoint-config.md)
+ [Criar endpoint](async-inference-create-endpoint-create-endpoint.md)
# Criar um modelo
O exemplo a seguir mostra como criar um usando o AWS SDK para Python (Boto3). As primeiras linhas definem:
+ `sagemaker_client`: um objeto cliente de SageMaker IA de baixo nível que facilita o envio e o recebimento de solicitações de AWS serviços.
+ `sagemaker_role`: uma variável de string com a função SageMaker AI IAM Amazon Resource Name (ARN).
+ `aws_region`: uma variável de string com o nome da sua AWS região.
```
import boto3
# Specify your AWS Region
aws_region=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam:::role/*"
```
Em seguida, especifique a localização do modelo pré-treinado armazenado no Amazon S3. Neste exemplo, usamos um XGBoost modelo pré-treinado chamado`demo-xgboost-model.tar.gz`. O URI completo do Amazon S3 é armazenado em uma variável de string `model_url`:
```
#Create a variable w/ the model S3 URI
s3_bucket = '' # Provide the name of your S3 bucket
bucket_prefix='saved_models'
model_s3_key = f"{bucket_prefix}/demo-xgboost-model.tar.gz"
#Specify S3 bucket w/ model
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
Especifique um contêiner primário. Para o contêiner principal, você especifica a imagem do Docker que contém o código de inferência, os artefatos (do treinamento anterior) e um mapa do ambiente personalizado que o código de inferência usa quando você implanta o modelo para predições.
Neste exemplo, especificamos uma imagem de contêiner de algoritmo XGBoost incorporada:
```
from sagemaker import image_uris
# Specify an AWS container image.
container = image_uris.retrieve(region=aws_region, framework='xgboost', version='0.90-1')
```
Crie um modelo na Amazon SageMaker AI com`CreateModel`. Especifique o seguinte:
+ `ModelName`: um nome para seu modelo (neste exemplo, ele é armazenado como uma variável de string chamada `model_name`).
+ `ExecutionRoleArn`: O Amazon Resource Name (ARN) da função do IAM que a Amazon SageMaker AI pode assumir para acessar artefatos de modelo e imagens do Docker para implantação em instâncias de computação de ML ou para trabalhos de transformação em lote.
+ `PrimaryContainer`: A localização da imagem do Docker primária que contém código de inferência, artefatos associados e mapas de ambiente personalizado usado pelo código de inferência quando o modelo é implantado para predições.
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
})
```
Consulte a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)descrição no Guia de referência SageMaker da API para obter uma lista completa dos parâmetros da API.
Se você estiver usando um contêiner fornecido por SageMaker IA, poderá aumentar o tempo limite do servidor modelo e os tamanhos da carga útil dos valores padrão para os máximos suportados pela estrutura definindo variáveis de ambiente nesta etapa. Talvez você não consiga aproveitar o tempo limite máximo e os tamanhos de carga útil que a inferência assíncrona é compatível com se não definir explicitamente essas variáveis. O exemplo a seguir mostra como você pode definir as variáveis de ambiente para um contêiner de PyTorch inferência com base em TorchServe.
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
'Environment': {
'TS_MAX_REQUEST_SIZE': '100000000',
'TS_MAX_RESPONSE_SIZE': '100000000',
'TS_DEFAULT_RESPONSE_TIMEOUT': '1000'
},
})
```
Quando terminar de criar seu endpoint, verifique se definiu as variáveis de ambiente corretamente imprimindo-as do seu script `inference.py`. A tabela a seguir lista as variáveis de ambiente de uma série de estruturas que você pode definir para alterar os valores padrão.
| Framework | Variáveis de ambiente |
| --- | --- |
| PyTorch 1.8 (baseado em TorchServe) | 'TS\$1MAX\$1REQUEST\$1SIZE': '100000000' 'TS\$1MAX\$1RESPONSE\$1SIZE': '100000000' 'TS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '1000' |
| PyTorch 1.4 (baseado em MMS) | 'MMS\$1MAX\$1REQUEST\$1SIZE': '1000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE': '1000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '900' |
| HuggingFace Contêiner de inferência (baseado em MMS) | 'MMS\$1MAX\$1REQUEST\$1SIZE': '2000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE': '2000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '900' |
# Criar uma configuração de endpoint
Quando tiver um modelo, crie uma configuração de endpoint com [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). Os serviços de hospedagem Amazon SageMaker AI usam essa configuração para implantar modelos. Na configuração, você identifica um ou mais modelos, criados usando com [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), para implantar os recursos que você deseja que a Amazon SageMaker AI provisione. Especifique o objeto `AsyncInferenceConfig` e forneça uma localização de saída do Amazon S3 para `OutputConfig`. Opcionalmente, você pode especificar tópicos do [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) sobre os quais enviar notificações sobre os resultados da predição. Para obter mais informações sobre tópicos do Amazon SNS, consulte o [Configurando o Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html).
O seguinte exemplo mostra como criar uma configuração de endpoint usando AWS SDK para Python (Boto3):
```
import datetime
from time import gmtime, strftime
# Create an endpoint config name. Here we create one based on the date
# so it we can search endpoints based on creation time.
endpoint_config_name = f"XGBoostEndpointConfig-{strftime('%Y-%m-%d-%H-%M-%S', gmtime())}"
# The name of the model that you want to host. This is the name that you specified when creating the model.
model_name=''
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name, # You will specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": f"s3://{s3_bucket}/{bucket_prefix}/output"
# (Optional) specify Amazon SNS topics
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
},
"ClientConfig": {
# (Optional) Specify the max number of inflight invocations per instance
# If no value is provided, Amazon SageMaker will choose an optimal value for you
"MaxConcurrentInvocationsPerInstance": 4
}
}
)
print(f"Created EndpointConfig: {create_endpoint_config_response['EndpointConfigArn']}")
```
No exemplo acima mencionado, você especifica as seguintes chaves para `OutputConfig` no campo `AsyncInferenceConfig`:
+ `S3OutputPath`: Local para fazer upload das saídas de resposta quando nenhum local é fornecido na solicitação.
+ `NotificationConfig`: (Opcional) Tópicos do SNS que publicam notificações para você quando uma solicitação de inferência é bem-sucedida (`SuccessTopic`) ou falha (`ErrorTopic`).
Você também pode especificar o seguinte argumento opcional para `ClientConfig` no campo `AsyncInferenceConfig`:
+ `MaxConcurrentInvocationsPerInstance`: (Opcional) O número máximo de solicitações simultâneas enviadas pelo cliente de SageMaker IA ao contêiner do modelo.
# Criar endpoint
Depois de ter seu modelo e configuração de endpoint, use a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) para criar seu endpoint. O nome do endpoint deve ser exclusivo em uma AWS região da sua AWS conta.
O recurso abaixo cria um endpoint usando a configuração de endpoint especificada na solicitação. A Amazon SageMaker AI usa o endpoint para provisionar recursos e implantar modelos.
```
# The name of the endpoint.The name must be unique within an AWS Region in your AWS account.
endpoint_name = ''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
```
Quando você chama a `CreateEndpoint` API, o Amazon SageMaker Asynchronous Inference envia uma notificação de teste para verificar se você configurou um tópico do Amazon SNS. O Amazon SageMaker Asynchronous Inference também envia notificações de teste após chamadas para e. `UpdateEndpoint` `UpdateEndpointWeightsAndCapacities` Isso permite que a SageMaker IA verifique se você tem as permissões necessárias. A notificação pode simplesmente ser ignorada. A notificação do teste tem o seguinte formato:
```
{
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"TestNotification"
}
```
# Invocar um endpoint assíncrono
Obtenha inferências do modelo hospedado em seu endpoint assíncrono com `InvokeEndpointAsync`.
**nota**
Faça o upload de seus dados de inferência (por exemplo, modelo de machine learning, dados de amostra) para o Amazon S3 se ainda não tiver feito.
: A localização da imagem do Docker primária que contém código de inferência, artefatos associados e mapas de ambiente personalizado usado pelo código de inferência quando o modelo é implantado para previsões.
+ Para `InputLocation`, especifique a localização dos seus dados de inferência.
+ Para `EndpointName`, especifique o nome do seu endpoint.
+ (Opcional) Para `InvocationTimeoutSeconds`, defina o tempo limite máximo para as solicitações. Você pode definir esse valor para um máximo de 3600 segundos (uma hora) por solicitação. Se não especificar esse campo em sua solicitação, por padrão a solicitação expirará em 15 minutos.
```
# Create a low-level client representing Amazon SageMaker Runtime
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the location of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# After you deploy a model into production using SageMaker AI hosting
# services, your client applications use this API to get inferences
# from the model hosted at the specified endpoint.
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName=endpoint_name,
InputLocation=input_location,
InvocationTimeoutSeconds=3600)
```
Você recebe uma resposta como uma string JSON com seu ID de solicitação e o nome do bucket do Amazon S3 que terá a resposta à chamada da API após o processamento.
# Atualizar um endpoint assíncrono
Atualize um endpoint assíncrono com a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Quando você atualiza um endpoint, a SageMaker IA primeiro provisiona e alterna para a nova configuração de endpoint especificada antes de excluir os recursos que foram provisionados na configuração anterior do endpoint. Não exclua um `EndpointConfig` com um endpoint ativo ou enquanto as operações `UpdateEndpoint` ou `CreateEndpoint` estão sendo executadas no endpoint.
```
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
sagemaker_client.update_endpoint(
EndpointConfigName=endpoint_config_name,
EndpointName=endpoint_name
)
```
Quando a Amazon SageMaker AI recebe a solicitação, ela define o status do endpoint como **Atualizando**. Depois de atualizar o endpoint assíncrono, ele define o status como. **InService** Para verificar o status de um endpoint, use a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html). Para ver uma lista completa dos parâmetros que você pode especificar ao atualizar um endpoint, consulte a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html).
# Excluir um endpoint assíncrono
Exclua um endpoint assíncrono de maneira semelhante à que você excluiria um endpoint hospedado por SageMaker IA com a API. [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) Especifique o nome do endpoint assíncrono a ser excluído. Quando você exclui um endpoint, a SageMaker IA libera todos os recursos que foram implantados quando o endpoint foi criado. Excluir um modelo não exclui os artefatos, o código de inferência ou o perfil do IAM do modelo que você especificou ao criar o modelo.
Exclua seu modelo de SageMaker IA com a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API ou com o console de SageMaker IA.
------
#### [ Boto3 ]
```
import boto3
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.delete_endpoint(EndpointName='')
```
------
#### [ SageMaker AI console ]
1. Navegue até o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Expanda a lista suspensa **Inferência**.
1. Selecione **Endpoints**.
1. Pesquise endpoint na barra de pesquisa **Endpoints de pesquisa**.
1. Selecione o seu endpoint .
1. Escolha **Excluir**.
------
Além de excluir o endpoint assíncrono, talvez você queira limpar outros recursos que foram usados para criar o endpoint, como o repositório Amazon ECR (se você criou uma imagem de inferência personalizada), o modelo de SageMaker IA e a própria configuração do endpoint assíncrono.
# Alarmes e logs para rastrear métricas de endpoints assíncronos
Você pode monitorar o SageMaker AI usando o Amazon CloudWatch, que coleta dados brutos e os processa em métricas legíveis quase em tempo real. Como Amazon CloudWatch, você pode acessar as informações históricas e ter uma perspectiva melhor sobre o desempenho da aplicação web ou o do serviço. Para obter mais informações sobre o Amazon CloudWatch, consulte [O que é o Amazon CloudWatch?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html)
## Monitoramento com CloudWatch
As métricas abaixo são uma lista completa de métricas para endpoints assíncronos e estão no namespace `AWS/SageMaker`. Qualquer métrica não listada abaixo não será publicada se o endpoint estiver habilitado para inferência assíncrona. Essas métricas incluem (mas não estão limitadas a):
+ OverheadLatency
+ Invocações
+ InvocationsPerInstance
### Métricas gerais de endpoint
Essas métricas são as mesmas publicadas hoje para endpoints em tempo real. Para ter mais informações sobre outras métricas no Amazon CloudWatch, consulte [Amazon SageMaker AI metrics in Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
| Nome da métrica | Descrição | Unidade/Estatísticas |
| --- | --- | --- |
| `Invocation4XXErrors` | O número de solicitações em que o modelo retornou um código de resposta HTTP 4xx. Para cada resposta 4xx, 1 é enviado; caso contrário, 0 é enviado. | Unidades: nenhumaEstatísticas válidas: média e soma |
| `Invocation5XXErrors` | O número de solicitações InvokeEndpoint em que o modelo retornou um código de resposta HTTP 5xx. Para cada resposta 5xx, 1 é enviado; caso contrário, 0 é enviado. | Unidades: nenhumaEstatísticas válidas: média e soma |
| `ModelLatency` | O intervalo de tempo necessário para que um modelo responda, conforme visualizado no SageMaker AI. Esse intervalo inclui os tempos de comunicação locais necessários para enviar a solicitação e buscar a resposta do contêiner de um modelo, bem como o tempo gasto para concluir a inferência no contêiner. | Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
### Métricas de endpoint de inferência assíncrona
Essas métricas são publicadas para endpoints habilitados para inferência assíncrona. Todas as métricas a seguir são publicadas com uma dimensão `EndpointName`.
| Nome da métrica | Descrição | Unidade/Estatísticas |
| --- | --- | --- |
| `ApproximateBacklogSize` | O número de itens na fila de um endpoint que estão sendo processados no momento ou que ainda precisam ser processados. | Unidades: contagem Estatísticas válidas: média, máx. e mín. |
| `ApproximateBacklogSizePerInstance` | Número de itens na fila dividido pelo número de instâncias atrás de um endpoint. Essa métrica é usada principalmente para configurar o ajuste de escala automático de aplicações para um endpoint habilitado para assíncrono. | Unidades: contagemEstatísticas válidas: média, máx. e mín. |
| `ApproximateAgeOfOldestRequest` | Idade da solicitação mais antiga na fila. | Unidades: segundosEstatísticas válidas: média, máx. e mín. |
| `HasBacklogWithoutCapacity` | O valor dessa métrica é `1` quando há solicitações na fila, mas nenhuma instância atrás do endpoint. O valor é `0` em todos os outros momentos. Você pode usar essa métrica para escalar automaticamente seu endpoint a partir de zero instâncias ao receber uma nova solicitação na fila. | Unidade: contagemEstatística válida: média |
Todas as métricas a seguir são publicadas com as dimensões `EndpointName` e `VariantName`.
| Nome da métrica | Descrição | Unidade/Estatísticas |
| --- | --- | --- |
| `RequestDownloadFailures` | Quando ocorre uma falha de inferência devido a um problema no download da solicitação do Amazon S3. | Unidades: contagemEstatística válida: soma |
| `ResponseUploadFailures` | Quando ocorre uma falha de inferência devido a um problema no upload da resposta para o Amazon S3. | Unidades: contagemEstatística válida: soma |
| `NotificationFailures` | Quando ocorreu um problema ao publicar notificações. | Unidades: contagemEstatística válida: soma |
| `RequestDownloadLatency` | Tempo total para fazer download da carga útil da solicitação. | Unidade: microssegundosEstatísticas válidas: média, soma, mín., máx., contagem de amostras |
| `ResponseUploadLatency` | Tempo total para carregar a carga útil da resposta. | Unidade: microssegundos Estatísticas válidas: média, soma, mín., máx., contagem de amostras |
| `ExpiredRequests` | Número de solicitações na fila com falha devido ao alcance da TTL de solicitação especificada. | Unidades: contagemEstatística válida: soma |
| `InvocationFailures` | Se uma invocação falhar por qualquer motivo. | Unidades: contagemEstatística válida: soma |
| `InvocationsProcesssed` | Número de invocações assíncronas processadas pelo endpoint. | Unidades: contagemEstatística válida: soma |
| `TimeInBacklog` | Tempo total em que a solicitação ficou na fila antes de ser processada. Isso não inclui o tempo real de processamento (ou seja, tempo de download, tempo de upload, latência do modelo). | Unidade: milissegundosEstatísticas válidas: média, soma, mín., máx., contagem de amostras |
| `TotalProcessingTime` | O horário em que a solicitação de inferência foi recebida pelo SageMaker AI até o momento em que o processo da solicitação foi concluído. Isso inclui o tempo no backlog e o tempo para carregar e enviar notificações de resposta, se houver. | Unidade: milissegundosEstatísticas válidas: média, soma, mín., máx., contagem de amostras |
A inferência assíncrona do Amazon SageMaker também inclui métricas em nível de host. Para ter informações sobre métricas em nível de host, consulte [Métricas de trabalhos e endpoints do SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs).
## Logs
Além dos [modelos de log de contêiner](https://docs.aws.amazon.com/sagemaker/latest/dg/logging-cloudwatch.html) que são publicados no Amazon CloudWatch na sua conta, você também recebe um log de nova plataforma para rastrear e depurar solicitações de inferência.
Os novos logs são publicados no Grupo de logs do Endpoint:
```
/aws/sagemaker/Endpoints/[EndpointName]
```
O nome do fluxo de logs consiste de:
```
[production-variant-name]/[instance-id]/data-log.
```
Linhas de log contêm a ID de inferência da solicitação para que os erros possam ser facilmente mapeados para uma solicitação específica.
# Verifique dos resultados da previsão
Há várias maneiras de verificar resultados das previsões do endpoint assíncrono. Algumas opções são:
1. Tópicos do Amazon SNS.
1. Verifique se há saídas em seu bucket do Amazon S3.
## Tópicos do Amazon SNS
O Amazon SNS é um serviço de notificação para aplicativos orientados a mensagens, em que vários assinantes solicitam e recebem notificações “push” de mensagens urgentes de uma variedade de protocolos de transporte, incluindo HTTP, Amazon SQS e e-mail. A inferência assíncrona do Amazon SageMaker publica notificações quando você cria um endpoint com [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) e especifica um tópico do Amazon SNS.
**nota**
Para receber notificações do Amazon SNS, sua Função do IAM deve ter permissões `sns:Publish`. Consulte o [Concluir os pré-requisitos do .](async-inference-create-endpoint-prerequisites.md) para obter informações sobre os requisitos que você deve satisfazer para usar a inferência assíncrona.
Para usar o Amazon SNS para verificar os resultados de previsão do seu endpoint assíncrono, primeiro você precisa criar um tópico, assinar o tópico, confirmar sua assinatura no tópico e anotar o nome do recurso da Amazon (ARN) desse tópico. Para obter informações detalhadas sobre como criar, assinar e encontrar o Amazon ARN de um tópico do Amazon SNS, consulte [Configurando o Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html).
Forneça o(s) ARN(s) do tópico do Amazon SNS no campo `AsyncInferenceConfig` ao criar uma configuração de endpoint com `CreateEndpointConfig`. Você pode especificar um Amazon SNS `ErrorTopic` e um `SuccessTopic`.
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.create_endpoint_config(
EndpointConfigName=, # You specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": "model_name",
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": "s3:///"
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
}
}
)
```
Depois de criar seu endpoint e invocá-lo, você recebe uma notificação do seu tópico do Amazon SNS. Por exemplo, se você se inscreveu para receber notificações por e-mail do seu tópico, receberá uma notificação por e-mail toda vez que invocar seu endpoint. O exemplo a seguir mostra o conteúdo JSON de uma notificação por e-mail de invocação bem-sucedida.
```
{
"awsRegion":"us-east-1",
"eventTime":"2022-01-25T22:46:00.608Z",
"receivedTime":"2022-01-25T22:46:00.455Z",
"invocationStatus":"Completed",
"requestParameters":{
"contentType":"text/csv",
"endpointName":"",
"inputLocation":"s3:////input-data.csv"
},
"responseParameters":{
"contentType":"text/csv; charset=utf-8",
"outputLocation":"s3:////prediction.out"
},
"inferenceId":"11111111-2222-3333-4444-555555555555",
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"InferenceResult"
}
```
## Verifique seu bucket S3
Quando você invoca um endpoint com `InvokeEndpointAsync`, ele retorna um objeto de resposta. Você pode usar o objeto de resposta para obter o URI do Amazon S3 em que sua saída foi armazenada. Com o local de saída, você pode usar a classe de sessão do SageMaker AI do SageMaker Python SDK para verificar programaticamente uma saída.
O seguinte armazena o dicionário de saída de `InvokeEndpointAsync` como uma variável chamada resposta. Com a variável de resposta, você obtém o URI de saída do Amazon S3 e o armazena como uma variável de string chamada `output_location`.
```
import uuid
import boto3
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the S3 URI of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName='',
InputLocation=input_location,
InferenceId=str(uuid.uuid4()),
ContentType="text/libsvm" #Specify the content type of your data
)
output_location = response['OutputLocation']
print(f"OutputLocation: {output_location}")
```
Para obter informações sobre os tipos de conteúdo compatíveis, consulte [Formatos de dados comuns para inferência](cdf-inference.md).
Com o local de saída do Amazon S3, você pode então usar uma [classe de sessão do SageMaker AI do SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/api/utility/session.html?highlight=session) para ler os arquivos do Amazon S3. O exemplo de código a seguir mostra como criar uma função (`get_ouput`) que tentativas repetidas de ler um arquivo do local de saída do Amazon S3:
```
import sagemaker
import urllib, time
from botocore.exceptions import ClientError
sagemaker_session = sagemaker.session.Session()
def get_output(output_location):
output_url = urllib.parse.urlparse(output_location)
bucket = output_url.netloc
key = output_url.path[1:]
while True:
try:
return sagemaker_session.read_s3_file(
bucket=output_url.netloc,
key_prefix=output_url.path[1:])
except ClientError as e:
if e.response['Error']['Code'] == 'NoSuchKey':
print("waiting for output...")
time.sleep(2)
continue
raise
output = get_output(output_location)
print(f"Output: {output}")
```
# Escalabilidade automática de um endpoint assíncrono
O Amazon SageMaker AI oferece suporte para ajuste de escala automático de endpoints assíncronos. O ajuste de escala automático ajusta dinamicamente o número de instâncias provisionadas para um modelo em resposta às alterações na workload. Ao contrário de outros modelos hospedados compatíveis com o Amazon SageMaker AI, com a inferência assíncrona você também pode reduzir a escala verticalmente de suas instâncias de endpoint assíncrono para zero. As solicitações recebidas quando há zero instâncias na fila para processamento quando o endpoint aumenta a escala verticalmente.
Para escalar automaticamente seu endpoint assíncrono, você deve, no mínimo:
+ Registrar um modelo implantado (variante de produção).
+ Definir uma política de escalabilidade
+ Aplicar a política de auto scaling automático.
Antes de usar o ajuste de escala automático, você já deve ter implantado um modelo para um endpoint do SageMaker AI. Os modelos implantados são referidos como uma [variante de produção](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html). Consulte [Implantar o modelo nos serviços de hospedagem do SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-model-deployment.html#ex1-deploy-model) para obter mais informações sobre a implantação de modelo em um endpoint. Para especificar as métricas e os valores de destino de uma política de escalabilidade, você deve configurar uma política de escalabilidade. Para mais informações sobre como definir uma política de escalabilidade, consulte [Definindo uma política de escalabilidade](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-define.html). Depois de registrar o modelo e definir uma política de escalabilidade, aplique a política de escalabilidade ao modelo registrado. Para mais informações sobre como aplicar uma política de escalabilidade, consulte [Aplicar uma política de escalabilidade](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-apply.html).
Para obter mais informações sobre como definir uma política de escalabilidade adicional opcional que aumenta a escala do seu endpoint ao receber uma solicitação após seu endpoint ter sido reduzido para zero, consulte [Opcional: defina uma política de escalabilidade verticalmente de zero para novas solicitações](#async-inference-autoscale-scale-up). Se você não especificar essa política opcional, seu endpoint só iniciará o aumento da escala verticalmente a partir de zero depois que o número de solicitações de backlog exceder o valor de rastreamento de destino.
Para obter detalhes sobre outros pré-requisitos e componentes usados com o ajuste de escala automático, consulte a seção [Prerequisites](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-prerequisites.html) na documentação de ajuste de escala automático do SageMaker AI.
**nota**
Se você anexar várias políticas de escalabilidade ao mesmo grupo do AutoScaling, você pode ter conflitos de escalabilidade. Quando ocorre um conflito, o Amazon EC2 Auto Scaling escolhe a política que provisiona a maior capacidade tanto para aumentar a escala horizontalmente e para reduzir a escala horizontalmente. Para obter mais informações sobre esse comportamento, consulte [Várias políticas de escalabilidade dinâmica na documentação do](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scale-based-on-demand.html#multiple-scaling-policy-resolution) *Amazon EC2 Auto Scaling*.
## Definir uma política de escalabilidade
Para especificar as métricas e os valores de destino de uma política de escalabilidade, você precisa configurar uma política de escalabilidade de rastreamento de destino. Defina a política de escalabilidade como um bloco JSON em um arquivo de texto. Você pode usar esse arquivo de texto ao invocar a AWS CLI ou a API do Application Auto Scaling. Para mais informações sobre a sintaxe de configurações de política, consulte [https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html) na Referência de API de Auto Scaling do Aplicativo.
Para endpoints assíncronos, o SageMaker AI recomenda enfaticamente que você crie uma configuração de política para escalar o rastreamento de destino para uma variante. Neste exemplo de configuração, usamos uma métrica personalizada, `CustomizedMetricSpecification`, chamada de `ApproximateBacklogSizePerInstance`.
```
TargetTrackingScalingPolicyConfiguration={
'TargetValue': 5.0, # The target value for the metric. Here the metric is: ApproximateBacklogSizePerInstance
'CustomizedMetricSpecification': {
'MetricName': 'ApproximateBacklogSizePerInstance',
'Namespace': 'AWS/SageMaker',
'Dimensions': [
{'Name': 'EndpointName', 'Value': }
],
'Statistic': 'Average',
}
}
```
## Defina uma política de escalabilidade dimensionada para zero
Veja a seguir como definir e registrar sua variante de endpoint com o dimensionamento automático do aplicativo usando o AWS SDK para Python (Boto3). Depois de definir um objeto cliente de baixo nível representando o dimensionamento automático do aplicativo com o Boto3, usamos o método [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target) para registrar a variante de produção. Configuramos `MinCapacity` como 0 porque a inferência assíncrona permite a escalabilidade automática para 0 quando não há solicitações para processar.
```
# Common class representing application autoscaling for SageMaker
client = boto3.client('application-autoscaling')
# This is the format in which application autoscaling references the endpoint
resource_id='endpoint/' + + '/variant/' + <'variant1'>
# Define and register your endpoint variant
response = client.register_scalable_target(
ServiceNamespace='sagemaker',
ResourceId=resource_id,
ScalableDimension='sagemaker:variant:DesiredInstanceCount', # The number of EC2 instances for your Amazon SageMaker model endpoint variant.
MinCapacity=0,
MaxCapacity=5
)
```
Para obter uma descrição detalhada sobre a API com dimensionamento automático de aplicativos, consulte a documentação do [Escalonamento de Aplicativos](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target) Boto3.
## Opcional: defina uma política de escalabilidade verticalmente de zero para novas solicitações
Você pode ter um caso de uso em que tenha solicitações esporádicas ou períodos com baixo número de solicitações. Se a escala do seu endpoint tiver sido reduzida verticalmente para zero instâncias durante esses períodos, ele não aumentará a escala verticalmente outra vez até que o número de solicitações na fila exceda a meta especificada em sua política de escalabilidade. Isso pode resultar em longos tempos de espera para solicitações na fila. A seção a seguir mostra como criar uma política de escalabilidade adicional que escale seu endpoint a partir de zero instâncias após receber qualquer nova solicitação na fila. Seu endpoint poderá responder a novas solicitações mais rapidamente, em vez de esperar que o tamanho da fila exceda a meta.
Para criar uma política de escalabilidade para seu endpoint que aumente a escala verticalmente a partir de zero instâncias, faça o seguinte:
1. Crie uma política de escalabilidade que defina o comportamento desejado, que é escalar seu endpoint quando ele está em zero instâncias, mas tem solicitações na fila. A seguir, mostramos como definir uma política de escalabilidade chamada de `HasBacklogWithoutCapacity-ScalingPolicy` usando o AWS SDK para Python (Boto3). Quando a fila é maior que zero e a contagem de instâncias atuais do seu endpoint também é zero, a política aumenta seu endpoint. Em todos os outros casos, a política não afeta o escalonamento do seu endpoint.
```
response = client.put_scaling_policy(
PolicyName="HasBacklogWithoutCapacity-ScalingPolicy",
ServiceNamespace="sagemaker", # The namespace of the service that provides the resource.
ResourceId=resource_id, # Endpoint name
ScalableDimension="sagemaker:variant:DesiredInstanceCount", # SageMaker supports only Instance Count
PolicyType="StepScaling", # 'StepScaling' or 'TargetTrackingScaling'
StepScalingPolicyConfiguration={
"AdjustmentType": "ChangeInCapacity", # Specifies whether the ScalingAdjustment value in the StepAdjustment property is an absolute number or a percentage of the current capacity.
"MetricAggregationType": "Average", # The aggregation type for the CloudWatch metrics.
"Cooldown": 300, # The amount of time, in seconds, to wait for a previous scaling activity to take effect.
"StepAdjustments": # A set of adjustments that enable you to scale based on the size of the alarm breach.
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
},
)
```
1. Crie um alarme do CloudWatch com a métrica personalizada `HasBacklogWithoutCapacity`. Quando acionado, o alarme inicia a política de escalabilidade definida anteriormente. Para obter mais informações sobre métricas do `HasBacklogWithoutCapacity`, consulte [Métricas de endpoint de inferência assíncrona](async-inference-monitor.md#async-inference-monitor-cloudwatch-async).
```
response = cw_client.put_metric_alarm(
AlarmName=step_scaling_policy_alarm_name,
MetricName='HasBacklogWithoutCapacity',
Namespace='AWS/SageMaker',
Statistic='Average',
EvaluationPeriods= 2,
DatapointsToAlarm= 2,
Threshold= 1,
ComparisonOperator='GreaterThanOrEqualToThreshold',
TreatMissingData='missing',
Dimensions=[
{ 'Name':'EndpointName', 'Value':endpoint_name },
],
Period= 60,
AlarmActions=[step_scaling_policy_arn]
)
```
Agora você deve ter uma política de escalabilidade e um alarme do CloudWatch que escalem seu endpoint a partir de zero instâncias sempre que a sua fila tiver solicitações pendentes.
# Solução de problemas
As perguntas frequentes a seguir podem ajudar a solucionar problemas com os endpoints de inferência assíncrona do Amazon SageMaker.
## P: Eu tenho o dimensionamento automático ativado. Como posso encontrar a contagem de instâncias atrás do endpoint em um determinado ponto?
É possível usar os métodos abaixo para encontrar a contagem de instâncias por trás do endpoint:
+ Use a API [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) do SageMaker AI para descrever o número de instâncias atrás do endpoint em um determinado momento.
+ Você pode obter a contagem de instâncias visualizando suas métricas do Amazon CloudWatch. Veja as [métricas de suas instâncias de endpoint](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs), como, por exemplo, `CPUUtilization` ou `MemoryUtilization`, e verifique a estatística de contagem de exemplos por um período de 1 minuto. A contagem deve ser igual ao número de instâncias ativas. A captura de tela a seguir mostra a métrica `CPUUtilization` representada graficamente no console do CloudWatch, em que a **estatística** é definida em `Sample count`, o **período** é definido em `1 minute` e a contagem resultante é 5.
![\[Console do CloudWatch mostrando o gráfico de contagem de instâncias ativas de um endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/cloudwatch-sample-count.png)
## P: Quais são as variáveis de ambiente ajustáveis comuns para contêineres do SageMaker AI?
As tabelas a seguir descrevem as variáveis de ambiente ajustáveis comuns para contêineres do SageMaker AI por tipo de framework.
**TensorFlow**
| Variável de ambiente | Descrição |
| --- | --- |
| `SAGEMAKER_TFS_INSTANCE_COUNT` | Para modelos baseados em TensorFlow, o binário `tensorflow_model_server` é a peça operacional responsável por carregar um modelo na memória, executar entradas em um gráfico de modelo e derivar saídas. Normalmente, uma instância única desse binário é executada para servir modelos em um endpoint. Esse binário é internamente multi-thread e gera vários threads para responder a uma solicitação de inferência. Em certas instâncias, se você observar que a CPU é utilizada de forma respeitável (mais de 30% de utilização), mas a memória está subutilizada (menor que 10% de utilização), aumentar esse parâmetro pode ajudar. Aumentar o número de unidades `tensorflow_model_servers` disponíveis para servir normalmente aumenta a taxa de throughput de um endpoint. |
| `SAGEMAKER_TFS_FRACTIONAL_GPU_MEM_MARGIN` | Esse parâmetro controla a fração da memória da GPU disponível para inicializar CUDA/cuDNN e outras bibliotecas de GPU. `0.2` significa que 20% da memória da GPU disponível é reservada para inicializar CUDA/cuDNN e outras bibliotecas de GPU, e 80% da memória da GPU disponível é alocada igualmente entre os processos de TF. A memória da GPU é pré-alocada, a menos que a opção `allow_growth` esteja habilitada. |
| `SAGEMAKER_TFS_INTER_OP_PARALLELISM` | Isso está relacionado à variável `inter_op_parallelism_threads`. Essa variável determina o número de threads usados por operações independentes sem bloqueio. `0` significa que o sistema escolhe um número apropriado. |
| `SAGEMAKER_TFS_INTRA_OP_PARALLELISM` | Isso está relacionado à variável `intra_op_parallelism_threads`. Isso determina o número de threads que podem ser usados em determinadas operações, como multiplicação de matrizes e reduções para aumentos de velocidade. Um valor de `0` significa que o sistema escolhe um número apropriado. |
| `SAGEMAKER_GUNICORN_WORKERS` | Isso rege o número de processos de trabalho que o Gunicorn deve gerar para lidar com solicitações. Esse valor é usado em combinação com outros parâmetros para derivar um conjunto que maximiza a throughput da inferência. Além disso, `SAGEMAKER_GUNICORN_WORKER_CLASS` rege o tipo de operadores gerados, normalmente `async` ou `gevent`. |
| `SAGEMAKER_GUNICORN_WORKER_CLASS` | Isso rege o número de processos de trabalho que o Gunicorn deve gerar para lidar com solicitações. Esse valor é usado em combinação com outros parâmetros para derivar um conjunto que maximiza a throughput da inferência. Além disso, `SAGEMAKER_GUNICORN_WORKER_CLASS` rege o tipo de operadores gerados, normalmente `async` ou `gevent`. |
| `OMP_NUM_THREADS` | O Python usa internamente o OpenMP para implementar multithreading em processos. Normalmente, são gerados threads equivalentes ao número de núcleos de CPU. Mas quando implementado em cima do Simultaneous Multi Threading (SMT), como o HypeThreading da Intel, um determinado processo pode substituir um núcleo em particular ao gerar duas vezes mais threads do que o número real de núcleos de CPU. Em certos casos, um binário Python pode acabar gerando até quatro vezes mais threads do que os núcleos de processador disponíveis. Portanto, uma configuração ideal para esse parâmetro, se você tiver excesso de assinaturas de núcleos disponíveis usando threads de trabalho, é `1` ou metade do número de núcleos de CPU em uma CPU com o SMT ativado. |
| `TF_DISABLE_MKL` `TF_DISABLE_POOL_ALLOCATOR` | Em alguns casos, desativar o MKL pode acelerar a inferência se `TF_DISABLE_MKL` e `TF_DISABLE_POOL_ALLOCATOR` estiverem definidos como `1`. |
**PyTorch**
| Variável de ambiente | Descrição |
| --- | --- |
| `SAGEMAKER_TS_MAX_BATCH_DELAY` | Este é o tempo máximo de atraso do lote que o TorchServe espera para receber. |
| `SAGEMAKER_TS_BATCH_SIZE` | Se o TorchServe não receber o número de solicitações especificado em `batch_size` antes que o cronômetro pare, ele envia as solicitações recebidas para o manipulador do modelo. |
| `SAGEMAKER_TS_MIN_WORKERS` | O número mínimo de operadores para os quais o TorchServe pode reduzir a escala verticalmente. |
| `SAGEMAKER_TS_MAX_WORKERS` | O número máximo de operadores para os quais o TorchServe pode aumentar a escala verticalmente. |
| `SAGEMAKER_TS_RESPONSE_TIMEOUT` | O atraso de tempo, após o qual a inferência expira na ausência de uma resposta. |
| `SAGEMAKER_TS_MAX_REQUEST_SIZE` | O tamanho máximo da carga útil do TorchServe. |
| `SAGEMAKER_TS_MAX_RESPONSE_SIZE` | O tamanho máximo da resposta do TorchServe. |
**Servidor multimodelo (MMS)**
| Variável de ambiente | Descrição |
| --- | --- |
| `job_queue_size` | Esse parâmetro é útil para ajustar quando você tem um cenário em que o tipo de carga útil da solicitação de inferência é grande e, devido ao tamanho da carga útil ser maior, você pode ter maior consumo de memória de pilha da JVM na qual essa fila está sendo mantida. Idealmente, talvez você queira manter os requisitos de memória de pilha da JVM mais baixos e permitir que os operadores do Python aloquem mais memória para o fornecimento real do modelo. A JVM serve apenas para receber as solicitações HTTP, enfileirá-las e expedi-las aos operadores baseados em Python para inferência. Se você aumentar o `job_queue_size`, poderá acabar aumentando o consumo de memória de pilha da JVM e, por fim, retirar memória do host que poderia ter sido usada por operadores do Python. Portanto, tenha precaução ao ajustar esse parâmetro também. |
| `default_workers_per_model` | Esse parâmetro é para o fornecimento do modelo de backend e pode ser útil ajustá-lo, pois este é o componente crítico do fornecimento do modelo geral, baseado em quais processos do Python geram threads para cada modelo. Se esse componente for mais lento (ou não estiver ajustado adequadamente), o ajuste do front-end pode não ser efetivo. |
## P: Como posso garantir que meu contêiner dê compatibilidade com a inferência assíncrona?
Você pode usar o mesmo contêiner para inferência assíncrona que usa para inferência em tempo real ou Batch Transform. Você deve confirmar se os tempos limite e os limites de tamanho da carga útil em seu contêiner estão definidos para lidar com cargas úteis maiores e tempos limite mais longos.
## P: Quais são os limites específicos da inferência assíncrona? Eles podem ser ajustados?
Consulte os seguintes limites para inferência assíncrona:
+ Limite de tamanho da carga útil: 1 GB
+ Tempo limite máximo: uma solicitação pode levar até 60 minutos.
+ TimeToLive da mensagem na fila (TTL): 6 horas
+ Número de mensagens que podem ser colocadas dentro do Amazon SQS: Ilimitado. No entanto, há uma cota de 120.000 para o número de mensagens em andamento para uma fila padrão e 20.000 para uma fila FIFO.
## P: Quais métricas são melhores para definir com dimensionamento automático na inferência assíncrona? Posso ter várias políticas de escalabilidade?
Em geral, com a inferência assíncrona, você pode aumentar a escala horizontalmente com base em invocações ou instâncias. Para métricas de invocação, é uma boa ideia analisar sua `ApproximateBacklogSize`, métrica que define o número de itens em sua fila que ainda não foram processados. Você pode utilizar essa métrica ou sua métrica `InvocationsPerInstance` para entender em qual TPS pode estar havendo controle de utilização. No nível da instância, verifique seu tipo de instância e a utilização da CPU/GPU para definir quando aumentar a escala horizontalmente. Se uma instância singular está acima de 60 a 70% da capacidade, geralmente é um bom sinal de que você está saturando seu hardware.
Não recomendamos ter várias políticas de escalabilidade, pois elas podem entrar em conflito e causar confusão no nível do hardware, gerando atrasos na quando aumentar a escala horizontalmente.
## P: Por que meu endpoint assíncrono está encerrando uma instância `Unhealthy` e as solicitações de atualização do dimensionamento automático estão falhando?
Verifique se seu contêiner é capaz de lidar com solicitações de ping e invocação simultaneamente. As solicitações de invocação do SageMaker AI levam aproximadamente 3 minutos e, nesse período, geralmente várias solicitações de ping acabam falhando devido ao tempo limite que faz com que o SageMaker AI detecte seu contêiner como `Unhealthy`.
## P: Pode `MaxConcurrentInvocationsPerInstance` funcionar para o meu contêiner modelo BYOC com as configurações ningx/gunicorn/flask?
Sim. `MaxConcurrentInvocationsPerInstance` é um atributo dos endpoints assíncronos. Isso não depende da implantação do contêiner personalizado. `MaxConcurrentInvocationsPerInstance` controla a taxa na qual as solicitações de invocação são enviadas para o contêiner do cliente. Se esse valor for definido como `1`, apenas 1 solicitação será enviada para o contêiner por vez, não importa quantos operadores estejam no contêiner do cliente.
## P: Como posso depurar erros do servidor de modelos (500) no meu endpoint assíncrono?
O erro significa que o contêiner do cliente retornou um erro. O SageMaker AI não controla o comportamento dos contêineres dos clientes. Ele simplesmente exibe a resposta de `ModelContainer` e não tenta novamente. Se quiser, você pode configurar a invocação para tentar novamente em caso de falha. Sugerimos que ative o log de contêineres e verifique seus logs de contêineres para encontrar a causa raiz do erro 500 em seu modelo. Verifique também as métricas `CPUUtilization` e `MemoryUtilization` no momento da falha. Você também pode configurar o [S3FailurePath](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AsyncInferenceOutputConfig.html#sagemaker-Type-AsyncInferenceOutputConfig-S3FailurePath) para a resposta do modelo no Amazon SNS como parte das notificações de erro assíncronas para investigar falhas.
## P: Como posso saber se `MaxConcurrentInvocationsPerInstance=1` tem efeito? Há alguma métrica que eu possa verificar?
Você pode verificar a métrica `InvocationsProcesssed`, que deve estar alinhada com o número de invocações que você espera que sejam processadas em um minuto baseado em uma única simultaneidade.
## P: Como posso monitorar o sucesso e as falhas das minhas solicitações de invocação? Quais são as práticas recomendadas?
A prática recomendada é habilitar o Amazon SNS, que é um serviço de notificação para aplicações orientados a mensagens, em que vários assinantes solicitam e recebem notificações “push” de mensagens urgentes de uma variedade de protocolos de transporte, incluindo HTTP, Amazon SQS e e-mail. A inferência assíncrona publica notificações quando você cria um endpoint com `CreateEndpointConfig` e especifica um tópico do Amazon SNS.
Para usar o Amazon SNS para verificar os resultados da predição do seu endpoint assíncrono, primeiro você precisa criar um tópico, assinar o tópico, confirmar sua assinatura no tópico e anotar o nome do recurso da Amazon (ARN) desse tópico. Para obter informações detalhadas sobre como criar, assinar e encontrar o Amazon ARN de um tópico do Amazon SNS, consulte [Configurando o Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html) no *Guia do desenvolvedor do Amazon SNS*. Para obter mais informações sobre como usar o Amazon SNS com inferência assíncrona, consulte [Verificar resultados da predição](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-check-predictions.html).
## P: Posso definir uma política de escalabilidade que aumente a escala verticalmente a partir de zero instâncias ao receber uma nova solicitação?
Sim. A inferência assíncrona fornece um mecanismo para reduzir a escala verticalmente até zero instâncias quando não há solicitações. Se a escala do seu endpoint tiver sido reduzida verticalmente para zero instâncias durante esses períodos, ele não aumentará a escala verticalmente outra vez até que o número de solicitações na fila exceda a meta especificada em sua política de escalabilidade. Isso pode resultar em longos tempos de espera para solicitações na fila. Nesses casos, se você quiser aumentar a escala verticalmente a partir de zero instâncias para novas solicitações menores do que o destino de fila especificado, você pode usar uma política de escalabilidade adicional chamada `HasBacklogWithoutCapacity`. Para obter mais informações sobre como definir essa política de escalabilidade, consulte [Escalabilidade automaticamente de um endpoint assíncrono](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-autoscale.html#async-inference-autoscale-scale-up).
## P: Estou recebendo um erro informando que o tipo de instância não é compatível com inferência assíncrona. Quais são os tipos de instância compatíveis com a inferência assíncrona?
Para obter uma lista completa de instâncias compatíveis com inferência assíncrona por região, consulte [preços do SageMaker.](https://aws.amazon.com/sagemaker/pricing/) Verifique se a instância necessária está disponível na sua região antes de continuar.
# Transformação em lote para inferência com a Amazon AI SageMaker
Use a transformação em lote quando precisar fazer o seguinte:
+ Pré-processar os conjuntos de dados para remover ruído ou desvio que interfira no treinamento ou na inferência do conjunto de dados.
+ Obter inferências de conjuntos de dados grandes.
+ Executar inferência quando não for necessário um endpoint persistente.
+ Associar registros de entrada com inferências para auxiliar na interpretação de resultados.
Para filtrar dados de entrada antes de executar inferências ou para associar registros de entrada à inferências sobre esses registros, consulte [Associar resultados de predição a registros de entrada](batch-transform-data-processing.md). Por exemplo, é possível filtrar dados de entrada a fim de fornecer contexto para criar e interpretar relatórios sobre os dados de saída.
**Topics**
+ [Uso da transformação em lote para obter inferências de conjuntos de dados grandes](#batch-transform-large-datasets)
+ [Aceleração de um trabalho de transformação em lote](#batch-transform-reduce-time)
+ [Uso da transformação em lote para testar as variantes de produção](#batch-transform-test-variants)
+ [Cadernos de amostra de transformação em lote](#batch-transform-notebooks)
+ [Associar resultados de predição a registros de entrada](batch-transform-data-processing.md)
+ [Armazenamento em Batch Transform](batch-transform-storage.md)
+ [Solução de problemas](batch-transform-errors.md)
## Uso da transformação em lote para obter inferências de conjuntos de dados grandes
A transformação em lotes gerencia automaticamente o processamento de grandes conjuntos de dados nos limites de parâmetros especificados. Por exemplo, ter um arquivo de conjunto de dados, `input1.csv`, armazenado em um bucket do S3. O conteúdo do arquivo de entrada pode ser semelhante ao seguinte exemplo:
```
Record1-Attribute1, Record1-Attribute2, Record1-Attribute3, ..., Record1-AttributeM
Record2-Attribute1, Record2-Attribute2, Record2-Attribute3, ..., Record2-AttributeM
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
...
RecordN-Attribute1, RecordN-Attribute2, RecordN-Attribute3, ..., RecordN-AttributeM
```
Quando um trabalho de transformação em lote é iniciado, a SageMaker IA inicia as instâncias de computação e distribui a carga de trabalho de inferência ou pré-processamento entre elas. A transformação em lote particiona objetos do Amazon S3 na entrada por chave e mapeia objetos do Amazon S3 para as instâncias. Quando você tiver vários arquivos, uma instância pode processar `input1.csv`, e a outra instância pode processar o arquivo chamado `input2.csv`. Se você tiver um arquivo de entrada, mas inicializar várias instâncias de computação, somente uma instância processará o arquivo de entrada. As outras instâncias estão inativas.
Você também pode dividir os arquivos de entrada em minilotes. Por exemplo, é possível criar um minilote de `input1.csv` incluindo somente dois dos registros.
```
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
Record4-Attribute1, Record4-Attribute2, Record4-Attribute3, ..., Record4-AttributeM
```
**nota**
SageMaker A IA processa cada arquivo de entrada separadamente. Ele não combina minilotes de diferentes arquivos de entrada para cumprir o limite [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB ).
Para dividir os arquivos de entrada em minilotes ao criar um trabalho de transformação em lote, defina o valor do [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType )parâmetro como. `Line` SageMaker A IA usa todo o arquivo de entrada em uma única solicitação quando:
+ `SplitType` está definido como `None`.
+ Um arquivo de entrada não pode ser dividido em minilotes.
Observe que a Transformação em Lote não é compatível com entrada em formato CSV que contenha caracteres de nova linha incorporados. Você pode controlar o tamanho dos minilotes usando os parâmetros `[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)` e `[MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)`. `MaxPayloadInMB` não deve ser maior que 100 MB. Se você especificar o parâmetro opcional `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)`, o valor de `(MaxConcurrentTransforms * MaxPayloadInMB)` também não deverá exceder 100 MB.
Se o trabalho de transformação em lote processar com êxito todos os registros em um arquivo de entrada, ele cria um arquivo de saída. O arquivo de saída tem o mesmo nome e a extensão do arquivo `.out`. Em vários arquivos de entrada, como `input1.csv` e `input2.csv`, os arquivos de saída são denominados `input1.csv.out` e `input2.csv.out`. O trabalho de transformação em lotes armazena os arquivos de saída no local especificado no Amazon S3, como `s3://amzn-s3-demo-bucket/output/`.
As predições em um arquivo de saída são listadas na mesma ordem dos registros correspondentes no arquivo de entrada. O arquivo de saída `input1.csv.out`, com base no arquivo de entrada mostrado anteriormente, seria parecido com o seguinte:
```
Inference1-Attribute1, Inference1-Attribute2, Inference1-Attribute3, ..., Inference1-AttributeM
Inference2-Attribute1, Inference2-Attribute2, Inference2-Attribute3, ..., Inference2-AttributeM
Inference3-Attribute1, Inference3-Attribute2, Inference3-Attribute3, ..., Inference3-AttributeM
...
InferenceN-Attribute1, InferenceN-Attribute2, InferenceN-Attribute3, ..., InferenceN-AttributeM
```
Se você definir [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ) como `Line`, poderá definir o parâmetro [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) para `Line` concatenar os registros de saída com um delimitador de linha. Isso não altera o número de arquivos de saída. O número de arquivos de saída é igual ao número de arquivos de entrada, e o uso de `AssembleWith` não mescla arquivos. Se você não especificar o parâmetro `AssembleWith`, os registros de saída serão concatenados em formato binário por padrão.
Quando os dados de entrada são muito grandes e são transmitidos usando codificação HTTP em blocos, para transmitir os dados para o algoritmo, defina [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB) como `0`. Os algoritmos integrados do Amazon SageMaker AI não oferecem suporte a esse recurso.
Para obter mais informações sobre como usar a API para criar um trabalho de transformação em lotes, consulte a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html). Para obter mais informações sobre a relação entre os objetos de entrada e de saída da transformação em lote, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html). Para obter um exemplo de como usar a transformação em lotes, consulte [(Opcional) Faça predições com o Transformador de Lotes](ex1-model-deployment.md#ex1-batch-transform).
## Aceleração de um trabalho de transformação em lote
Se você estiver usando a API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html), poderá reduzir o tempo necessário para a conclusão de trabalhos de transformação de lote usando valores ideais para parâmetros. Isso inclui parâmetros como [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB), [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms) ou [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy). O valor ideal para `MaxConcurrentTransforms` é igual ao número de operadores de computação na tarefa de transformação em lote.
Se você estiver usando o console do SageMaker AI, especifique esses valores ideais de parâmetros na seção **Configuração adicional** da página de **configuração do trabalho de transformação em lote**. SageMaker A IA encontra automaticamente as configurações de parâmetros ideais para algoritmos integrados. Para obter algoritmos personalizados, forneça esses valores por meio de um endpoint [execution-parameters](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests).
## Uso da transformação em lote para testar as variantes de produção
Para testar modelos diferentes ou várias configurações de hiperparâmetro, crie um trabalho de transformação separado para cada nova variante do modelo e use um conjunto de dados de validação. Para cada trabalho de transformação, especifique um nome de modelo exclusivo e um local no Amazon S3 para o arquivo de saída. Para analisar os resultados, use [Logs e métricas de pipeline de inferência](inference-pipeline-logs-metrics.md).
## Cadernos de amostra de transformação em lote
Para ver um caderno de exemplo de transformação em lote, consulte [Transformação em lote com clusters de filme PCA e DBSCAN](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_batch_transform/introduction_to_batch_transform/batch_transform_pca_dbscan_movie_clusters.html). Esse caderno usa transformação em lote com um modelo de análise de componentes de entidades principais (PCA) para reduzir os dados em uma matriz de revisão de itens do usuário. Em seguida, mostra a aplicação de um clustering espacial baseado na densidade de aplicações com algoritmo de ruído (DBSCAN) para agrupar filmes.
Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar o exemplo em SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar e abrir uma instância do notebook, escolha a guia **SageMakerExemplos** para ver uma lista de todos os exemplos de SageMaker IA. Os cadernos de exemplo de modelagem do tópico que usam os algoritmos NTM estão localizados na seção **Funcionalidade avançada**. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**.
# Associar resultados de predição a registros de entrada
Ao fazer predições em um conjunto de dados grande, você pode excluir atributos que não são necessários para a predição. Depois que as predições foram feitas, você pode associar alguns dos atributos excluídos a essas predições ou outros dados de entrada no relatório. Ao usar a transformação em lote para executar essas etapas de processamento de dados, geralmente você pode eliminar o pré-processamento ou o pós-processamento adicional. Você pode usar arquivos de entrada somente nos formatos JSON e CVS.
**Topics**
+ [Fluxo de trabalho para associar inferências a registros de entrada](#batch-transform-data-processing-workflow)
+ [Uso do processamento de dados em trabalhos de transformação em lotes](#batch-transform-data-processing-steps)
+ [JSONPath Operadores suportados](#data-processing-operators)
+ [Exemplos de transformação em lote](#batch-transform-data-processing-examples)
## Fluxo de trabalho para associar inferências a registros de entrada
O diagrama a seguir mostra o fluxo de trabalho para associar inferências a registros de entrada.
![\[Fluxo de trabalho para associar inferências com registros de entrada.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/batch-transform-data-processing.png)
Para associar inferências a dados de entrada, há três etapas principais:
1. Filtre os dados de entrada que não são necessários para inferência antes de passá-los para o trabalho de transformação em lote. Use o parâmetro [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ) para determinar quais atributos usar como entrada para o modelo.
1. Associe os dados de entrada aos resultados de inferência. Use o parâmetro [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ) para combinar os dados de entrada com a inferência.
1. Filtre os dados associados para reter as entradas que são necessárias para fornecer contexto para interpretar as predições nos relatórios. Use [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ) para armazenar a parte especificada do conjunto de dados associado no arquivo de saída.
## Uso do processamento de dados em trabalhos de transformação em lotes
Ao criar um trabalho de transformação em lote com [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) para processar dados:
1. Especifique a parte da entrada a ser transmitida para o modelo com o parâmetro `InputFilter` na estrutura de dados `DataProcessing`.
1. Associe os dados de entrada brutos aos dados transformados com o parâmetro `JoinSource`.
1. Especifique a parte dos dados transformados e de entrada associados do trabalho de transformação em lotes a ser incluída no arquivo de saída com o parâmetro `OutputFilter`.
1. Escolha arquivos em formato CSV ou JSON para entrada:
+ Para arquivos de entrada formatados em JSON ou JSON Lines, o SageMaker AI adiciona o `SageMakerOutput` atributo ao arquivo de entrada ou cria um novo arquivo de saída JSON com os atributos e. `SageMakerInput` `SageMakerOutput` Para obter mais informações, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html).
+ Para arquivos de entrada em formato CSV, os dados de entrada associados são seguidos pelos dados transformados, e a saída é um arquivo CSV.
Se você usar um algoritmo com a estrutura `DataProcessing`, ele deverá ser compatível com o formato escolhido para os *dois* arquivos de entrada e saída. Por exemplo, com o campo [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html) da API `CreateTransformJob`, defina os parâmetros [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) e [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept) como um dos seguintes valores: `text/csv`, `application/json` ou `application/jsonlines`. A sintaxe para especificação de colunas em um arquivo CSV e especificação de atributos em um arquivo JSON são diferentes. Usar a sintaxe errada causará um erro. Para obter mais informações, consulte [Exemplos de transformação em lote](#batch-transform-data-processing-examples). Para obter mais informações sobre formatos de arquivo de entrada e saída para algoritmos integrados, consulte [Algoritmos integrados e modelos pré-treinados na Amazon SageMaker](algos.md).
Os delimitadores de registro para a entrada e a saída também devem ser consistentes com o arquivo de entrada escolhido. O parâmetro [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType) indica como dividir os registros no conjunto de dados de entrada. O parâmetro [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) indica como remontar os registros para a saída. Se definir formatos de entrada e saída como `text/csv`, você também deverá definir os parâmetros `AssembleWith` e `SplitType` como `line`. Se definir os formatos de entrada e saída como `application/jsonlines`, você poderá definir `SplitType` e `AssembleWith` como `line`.
Para arquivos CSV, você não pode usar caracteres de nova linha incorporados. Para arquivos JSON, o nome do atributo `SageMakerOutput` é reservado para saída. O arquivo de entrada JSON não pode ter um atributo com esse nome. Se tiver, os dados no arquivo de entrada podem ser substituídos.
## JSONPath Operadores suportados
Para filtrar e unir os dados de entrada e a inferência, use uma JSONPath subexpressão. SageMaker A IA suporta somente um subconjunto dos JSONPath operadores definidos. A tabela a seguir lista os JSONPath operadores compatíveis. Para dados CSV, cada linha é considerada uma matriz JSON, portanto, somente a base de índice JSONPaths pode ser aplicada, por exemplo,. `$[0]` `$[1:]` Os dados CSV também devem seguir o [formato RFC](https://tools.ietf.org/html/rfc4180).
| JSONPath Operador | Description | Exemplo |
| --- | --- | --- |
| \$1 | O elemento raiz para uma consulta. Esse operador é necessário no início de todas as expressões de caminho. | \$1 |
| . | Um elemento filho com notação de pontos. | `$.id` |
| \$1 | Um caractere curinga. Use no lugar de um nome de atributo ou valor numérico. | `$.id.*` |
| ['' (,'')] | Um elemento ou vários elementos filho com notação de colchetes. | `$['id','SageMakerOutput']` |
| [ (,)] | Um índice ou matriz de índices. Os valores de índice negativos também são compatíveis. Um índice `-1` corresponde ao último elemento em uma matriz. | `$[1]` , `$[1,3,5]` |
| [:] | Um operador de matriz slice. O método matriz slice() extrai uma seção de uma matriz e retorna uma nova matriz. Se você omitir**, a SageMaker IA usa o primeiro elemento da matriz. Se você omitir**, a SageMaker IA usará o último elemento da matriz. | `$[2:5]`, `$[:5]`, `$[2:]` |
Ao usar a notação de colchete para especificar múltiplos elementos filho de um determinado campo, o aninhamento adicional de filhos dentro de colchetes não é compatível. Por exemplo, `$.field1.['child1','child2']` é compatível, mas `$.field1.['child1','child2.grandchild']` não é.
Para obter mais informações sobre JSONPath operadores, consulte [JsonPath](https://github.com/json-path/JsonPath)em GitHub.
## Exemplos de transformação em lote
Os exemplos a seguir mostram algumas maneiras comuns de associar dados de entrada a resultados de predições.
**Topics**
+ [Exemplo: gerar somente inferências](#batch-transform-data-processing-example-default)
+ [Exemplo: inferências de saída unidas a dados de entrada](#batch-transform-data-processing-example-all)
+ [Exemplo: inferências de saída unidas aos dados de entrada e exclusão da coluna ID da entrada (CSV)](#batch-transform-data-processing-example-select-csv)
+ [Exemplo: inferências de saída unidas a uma coluna de ID e exclusão da coluna de ID da entrada (CSV)](#batch-transform-data-processing-example-select-json)
### Exemplo: gerar somente inferências
Por padrão, o parâmetro [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing) não associa resultados de inferência à entrada. Ele gera apenas resultados de inferência.
Se você quiser especificar explicitamente a não união de resultados com entrada, use o SDK do [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) e especifique as seguintes configurações em uma chamada de transformador.
```
sm_transformer = sagemaker.transformer.Transformer(…)
sm_transformer.transform(…, input_filter="$", join_source= "None", output_filter="$")
```
Para gerar inferências usando o AWS SDK para Python, adicione o código a seguir à sua solicitação. CreateTransformJob O código a seguir imita o comportamento padrão.
```
{
"DataProcessing": {
"InputFilter": "$",
"JoinSource": "None",
"OutputFilter": "$"
}
}
```
### Exemplo: inferências de saída unidas a dados de entrada
Se você estiver usando o [SDK do Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) para combinar os dados de entrada com as inferências no arquivo de saída, especifique os `accept` parâmetros `assemble_with` e ao inicializar o objeto transformador. Ao usar a chamada de transformação, especifique `Input` para o parâmetro `join_source` e especifique também os parâmetros `split_type` e `content_type`. O parâmetro `split_type` deve ter o mesmo valor que `assemble_with`, e o parâmetro `content_type` deve ter o mesmo valor que `accept`. Para obter mais informações sobre os parâmetros e seus valores aceitos, consulte a página [Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) no *Amazon SageMaker AI Python SDK*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, join_source="Input", split_type="Line", content_type="text/csv")
```
Se você estiver usando o AWS SDK para Python (Boto 3), junte todos os dados de entrada à inferência adicionando o código a seguir à sua solicitação. [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) Os valores para `Accept` e `ContentType` devem corresponder, e os valores para `AssembleWith` e `SplitType` também devem corresponder.
```
{
"DataProcessing": {
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
Para os arquivos de entrada JSON ou Linhas JSON, os resultados estão na chave `SageMakerOutput` no arquivo JSON de entrada. Por exemplo, se a entrada é um arquivo JSON que contém o par de chave/valor `{"key":1}`, o resultado da transformação de dados pode ser `{"label":1}`.
SageMaker O AI armazena ambos no arquivo de entrada na `SageMakerInput` chave.
```
{
"key":1,
"SageMakerOutput":{"label":1}
}
```
**nota**
O resultado associado para JSON deve ser um objeto de par de chave/valor. Se a entrada não for um objeto de par de valores-chave, o SageMaker AI cria um novo arquivo JSON. No novo arquivo JSON, os dados de entrada são armazenados na chave `SageMakerInput`, e os resultados são armazenados como o valor `SageMakerOutput`.
Por exemplo, para um arquivo CSV, se o registro for `[1,2,3]`, e o resultado de rótulo for `[1]`, o arquivo de saída conterá `[1,2,3,1]`.
### Exemplo: inferências de saída unidas aos dados de entrada e exclusão da coluna ID da entrada (CSV)
Se você estiver usando o [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) para unir seus dados de entrada com a saída de inferência enquanto exclui uma coluna de ID da entrada do transformador, especifique os mesmos parâmetros do exemplo anterior, bem como uma JSONPath subexpressão para a em sua chamada de transformador. `input_filter` Por exemplo, se seus dados de entrada incluírem cinco colunas e a primeira for a coluna ID, use a solicitação de transformação a seguir para selecionar todas as colunas, exceto a coluna ID, como atributos. O transformador ainda gera todas as colunas de entrada unidas às inferências. Para obter mais informações sobre os parâmetros e seus valores aceitos, consulte a página [Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) no *Amazon SageMaker AI Python SDK*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input")
```
Se você estiver usando o AWS SDK para Python (Boto 3), adicione o código a seguir à sua solicitação. `[ CreateTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)`
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
Para especificar colunas no SageMaker AI, use o índice dos elementos da matriz. A primeira coluna é o índice 0, a segunda coluna é o índice 1 e a sexta coluna é o índice 5.
Para excluir a primeira coluna da entrada, defina `[InputFilter](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter )` como `"$[1:]"`. Os dois pontos (`:`) fazem com que a SageMaker IA inclua todos os elementos entre dois valores, inclusive. Por exemplo, `$[1:4]` especifica a segunda até a quinta colunas.
Se você omitir o número após o dois-pontos, por exemplo, `[5:]`, o subconjunto incluirá todas as colunas da sexta até a última. Se você omitir o número antes do dois-pontos, por exemplo `[:5]`, o subconjunto incluirá todas as colunas da primeira (índice 0) até a sexta.
### Exemplo: inferências de saída unidas a uma coluna de ID e exclusão da coluna de ID da entrada (CSV)
Se você estiver usando o [SDK do Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), poderá especificar a saída para unir somente colunas de entrada específicas (como a coluna ID) às inferências especificando a na chamada do `output_filter` transformador. O `output_filter` usa uma JSONPath subexpressão para especificar quais colunas devem ser retornadas como saída após unir os dados de entrada aos resultados da inferência. A solicitação a seguir mostra como você pode fazer predições ao excluir uma coluna de ID e, em seguida, unir a coluna de ID às inferências. Observe que, no exemplo a seguir, a última coluna (`-1`) da saída contém as inferências. Se você estiver usando arquivos JSON, o SageMaker AI armazena os resultados da inferência no atributo. `SageMakerOutput` Para obter mais informações sobre os parâmetros e seus valores aceitos, consulte a página [Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) no *Amazon SageMaker AI Python SDK*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input", output_filter="$[0,-1]")
```
Se você estiver usando o AWS SDK para Python (Boto 3), junte somente a coluna ID às inferências adicionando o código a seguir à sua solicitação. [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input",
"OutputFilter": "$[0,-1]"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
**Atenção**
Se você estiver usando um arquivo de entrada em formato JSON, o arquivo não poderá conter o nome do atributo `SageMakerOutput`. Esse nome do atributo é reservado para as inferências no arquivo de saída. Se o arquivo de entrada no formato JSON contiver um atributo com esse nome, os valores no arquivo de entrada poderão ser substituídos pela inferência.
# Armazenamento em Batch Transform
Quando você executa um trabalho de transformação em lote, o Amazon SageMaker AI anexa um volume de armazenamento do Amazon Elastic Block Store às instâncias do Amazon EC2 que processam seu trabalho. O volume armazena seu modelo e o tamanho do volume de armazenamento é fixado em 30 GB. Você tem a opção de criptografar seu modelo em repouso no volume de armazenamento.
**nota**
Se você tiver um modelo grande, poderá encontrar um `InternalServerError`.
Para obter mais informações sobre armazenamentos e atributos do Amazon EBS, consulte as seguintes páginas:
+ [Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) no Guia do usuário do Amazon EC2.
+ [Volumes do Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes.html) no Guia do usuário do Amazon EC2
**nota**
As instâncias G4dn vêm com seu próprio armazenamento SSD local. Para saber mais sobre instâncias G4dn, consulte a página [ Instâncias G4 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/g4/).
# Solução de problemas
Se você estiver tendo erros no Amazon SageMaker AI Batch Transform, consulte as dicas de solução de problemas a seguir.
## Max. de erros
Se você estiver recebendo erros de tempo limite máximo ao executar trabalhos de transformação em lote, tente o seguinte:
+ Comece com o registro único `[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)`, um tamanho de lote padrão (6 MB) ou menor que você especifica no parâmetro `[MaxPayloadInMB](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)` e um pequeno conjunto de dados de amostra. Ajuste o parâmetro de tempo limite máximo `[InvocationsTimeoutInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelClientConfig.html#sagemaker-Type-ModelClientConfig-InvocationsTimeoutInSeconds)` (que tem no máximo 1 hora) até receber uma resposta de invocação bem-sucedida.
+ Depois de receber uma resposta de invocação bem-sucedida, aumente `MaxPayloadInMB` (que tem no máximo 100 MB) e os parâmetros `InvocationsTimeoutInSeconds` juntos para encontrar o tamanho máximo do lote que pode ser compatível com o tempo limite do modelo desejado. Você pode usar o registro único ou o registro múltiplo `BatchStrategy` nesta etapa.
**nota**
Exceder o limite de `MaxPayloadInMB` causa um erro. Isso pode acontecer com um grande conjunto de dados se não puder ser dividido, se o parâmetro`SplitType` estiver definido como nenhum ou se os registros individuais dentro do conjunto de dados excederem o limite.
+ (Opcional) Ajuste o parâmetro `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)`, que especifica o número máximo de solicitações paralelas que podem ser enviadas a cada instância em um trabalho de transformação em lote. No entanto, o valor de `MaxConcurrentTransforms * MaxPayloadInMB` não deve exceder 100 MB.
## Saída incompleta
SageMaker A IA usa a [API Amazon S3 Multipart Upload para carregar](https://docs.aws.amazon.com/AmazonS3/latest/dev/uploadobjusingmpu.html) os resultados de uma tarefa de transformação em lote para o Amazon S3. Se ocorrer um erro, os resultados obtidos por upload serão removidos do Amazon S3. Em alguns casos, como em uma paralisação da rede, um multipart upload incompleto pode permanecer no Amazon S3. Um upload incompleto também pode ocorrer se você tiver vários arquivos de entrada, mas alguns deles não puderem ser processados pelo SageMaker AI Batch Transform. Os arquivos de entrada que não puderam ser processados não terão arquivos de saída correspondentes no Amazon S3.
Para evitar cobranças de armazenamento, recomendamos adicionar a [política do bucket do S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config) às regras de ciclo de vida do bucket do S3. Essa política exclui multipart uploads incompletos que podem ser armazenados no bucket do S3. Para obter mais informações, consulte [Gerenciamento do ciclo de vida de objetos](https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lifecycle-mgmt.html).
## Trabalho é exibido como `failed`
Se uma tarefa de transformação em lote falhar ao processar um arquivo de entrada devido a um problema com o conjunto de dados, a SageMaker IA marca a tarefa como`failed`. Se um arquivo de entrada contiver um registro inválido, o trabalho de transformação não criará um arquivo de saída para esse arquivo de entrada, pois isso impede que ele mantenha a mesma ordem nos dados transformados e no arquivo de entrada. Quando o conjunto de dados tiver vários arquivos de entrada, um trabalho de transformação continuará a processar arquivos de entrada, mesmo que ele não possa processar um dos arquivos. Os arquivos processados ainda geram resultados utilizáveis.
Se estiver usando seus próprios algoritmos, você poderá usar texto de espaço reservado, como `ERROR`, quando o algoritmo encontrar um registro inválido em um arquivo de entrada. Por exemplo, se o último registro em um conjunto de dados for inválido, o algoritmo colocará o texto do espaço reservado para esse registro no arquivo de saída.
# Paralelismo de modelos e inferência de modelos grandes
O Amazon SageMaker AI inclui contêineres de deep learning (DLCs), especializados, bibliotecas e ferramentas de paralelismo de modelo e inferência de grandes modelos (LMI). Nas seções a seguir, você poderá encontrar os recursos para começar a usar LMI no SageMaker AI.
**Topics**
+ [A documentação do contêiner de inferência de grandes modelos (LMI)](large-model-inference-container-docs.md)
+ [Parâmetros de endpoint do SageMaker AI para inferência de grandes modelos](large-model-inference-hosting.md)
+ [Implantação de modelos não compactados](large-model-inference-uncompressed.md)
+ [Implemente modelos grandes para inferência com TorchServe](large-model-inference-tutorials-torchserve.md)
# A documentação do contêiner de inferência de grandes modelos (LMI)
A [documentação do contêiner de inferência de grandes modelos (LMI)](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/index.html) encontra-se no site de documentação da Deep Java Library.
A documentação foi escrita para desenvolvedores, cientistas de dados e engenheiros de aprendizado de máquina que precisam implantar e otimizar grandes modelos de linguagem (LLMs) na Amazon SageMaker AI. Ele ajuda você a usar contêineres LMI, que são contêineres Docker especializados para inferência de LLM, fornecidos pela. AWS Ela apresenta uma visão geral, guias de implantação, guias de usuário para bibliotecas de inferência compatíveis e tutoriais avançados.
Ao usar a documentação do contêiner de LMI, você consegue:
+ Compreender os componentes e a arquitetura dos contêineres de LMI
+ Saiba como selecionar o tipo de instância e o backend apropriados para seu caso de uso
+ Configure e implante LLMs em SageMaker IA usando contêineres LMI
+ Otimizar o desempenho usando atributos como quantização, paralelismo de tensores e processamentos em lotes contínuos
+ Compare e ajuste seus endpoints de SageMaker IA para otimizar a taxa de transferência e a latência
# Parâmetros de endpoint do SageMaker AI para inferência de grandes modelos
Você pode personalizar os seguintes parâmetros para facilitar a inferência de grandes modelos (LMI) de baixa latência com o SageMaker AI:
+ **Tamanho máximo do volume do Amazon EBS na instância (`VolumeSizeInGB`)**: se o tamanho do modelo for maior que 30 GB e você estiver usando uma instância sem um disco local, aumente esse parâmetro para um pouco maior que o tamanho do seu modelo.
+ **Cota de tempo limite da verificação de integridade (`ContainerStartupHealthCheckTimeoutInSeconds`)**: se o seu contêiner estiver configurado corretamente e os logs do CloudWatch indicarem um tempo limite de verificação de saúde, você deverá aumentar essa cota para que o contêiner tenha tempo suficiente para responder às verificações de saúde.
+ **Cota de tempo limite de download do modelo (`ModelDataDownloadTimeoutInSeconds`)**: se o tamanho do seu modelo for maior que 40 GB, você deverá aumentar essa cota para fornecer tempo suficiente para baixar o modelo do Amazon S3 para a instância.
O trecho de código a seguir demonstra como configurar programaticamente os parâmetros mencionados acima. Substitua o *texto do espaço reservado em itálico* no exemplo por suas próprias informações.
```
import boto3
aws_region = "aws-region"
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name = "endpoint-name"
# Create an endpoint config name.
endpoint_config_name = "endpoint-config-name"
# The name of the model that you want to host.
model_name = "the-name-of-your-model"
instance_type = "instance-type"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": instance_type, # Specify the compute instance type.
"InitialInstanceCount": 1, # Number of instances to launch initially.
"VolumeSizeInGB": 256, # Specify the size of the Amazon EBS volume.
"ModelDataDownloadTimeoutInSeconds": 1800, # Specify the model download timeout in seconds.
"ContainerStartupHealthCheckTimeoutInSeconds": 1800, # Specify the health checkup timeout in seconds
},
],
)
sagemaker_client.create_endpoint(EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name)
```
Para obter mais informações sobre as chaves de `ProductionVariants`, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html).
Para ver exemplos que demonstram como obter inferência de baixa latência com grandes modelos, consulte os [exemplos de inferência de IA generativa no Amazon SageMaker AI](https://github.com/aws-samples/sagemaker-genai-hosting-examples/tree/main) no repositório aws-samples no GitHub.
# Implantação de modelos não compactados
Ao implantar modelos de ML, uma opção é arquivar e compactar os artefatos do modelo em um formato `tar.gz`. Embora esse método funcione bem para modelos pequenos, compactar um artefato de modelo grande com centenas de bilhões de parâmetros e depois descompactá-lo em um endpoint pode levar um tempo significativo. Para inferência de modelos grandes, recomendamos que você implante um modelo de ML não compactado. Este guia mostra como você pode implantar um modelo de ML não compactado.
Para implantar modelos de ML não compactados, faça o upload de todos os artefatos do modelo para o Amazon S3 e organize-os sob um prefixo comum do Amazon S3. Um prefixo do Amazon S3 é uma sequência de caracteres no início de um nome de chave de objeto do Amazon S3, separada do resto do nome por um delimitador. Para ter mais informações sobre prefixos no Amazon S3, consulte [Organizar objetos usando prefixos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-prefixes.html).
Para implantar com o SageMaker AI, você deve usar a barra (/) como delimitador. Você precisa garantir que somente os artefatos associados ao seu modelo de ML sejam organizados com o prefixo. Para modelos de ML com um único artefato não compactado, o prefixo será idêntico ao nome da chave. Você pode verificar quais objetos estão associados ao seu prefixo com AWS CLI:
```
aws s3 ls --recursive s3://bucket/prefix
```
Depois de carregar os artefatos do modelo no Amazon S3 e organizá-los sob um prefixo comum, você pode especificar sua localização como parte do campo [ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelDataSource.html) ao invocar a solicitação [CreateModel.](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) O SageMaker AI baixará automaticamente os artefatos do modelo não compactado em `/opt/ml/model` para inferência. Para ter mais informações sobre as regras que o SageMaker AI utiliza ao baixar artefatos, consulte [S3ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3ModelDataSource.html).
O trecho de código a seguir mostra como você pode invocar a API `CreateModel` ao implantar um modelo não compactado. Substitua *texto do usuário em itálico* por suas próprias informações.
```
model_name = "model-name"
sagemaker_role = "arn:aws:iam::123456789012:role/SageMakerExecutionRole"
container = "123456789012.dkr.ecr.us-west-2.amazonaws.com/inference-image:latest"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
"Image": container,
"ModelDataSource": {
"S3DataSource": {
"S3Uri": "s3://amzn-s3-demo-bucket/prefix/to/model/data/",
"S3DataType": "S3Prefix",
"CompressionType": "None",
},
},
},
)
```
O exemplo acima mencionado pressupõe que os artefatos do seu modelo estejam organizados sob um prefixo comum. Se, em vez disso, seu artefato de modelo for um único objeto Amazon S3 não compactado, altere `"S3Uri"` para apontar para o objeto Amazon S3 e altere `"S3DataType"` para `"S3Object"`.
**nota**
No momento, não é possível usar `ModelDataSource` com o AWS Marketplace, a transformação em lote do SageMaker AI, os endpoints de Inferência Sem Servidor do SageMaker e os endpoints multimodelo do SageMaker.
# Implemente modelos grandes para inferência com TorchServe
Este tutorial demonstra como implantar modelos grandes e fornecer inferência na Amazon SageMaker AI com TorchServe on. GPUs Este exemplo implanta o modelo [OPT-30b](https://huggingface.co/facebook/opt-30b) em uma instância `ml.g5`. Você pode modificar isso para funcionar com outros modelos e tipos de instância. Nos exemplos, substitua `italicized placeholder text` com suas próprias informações.
TorchServe é uma plataforma aberta poderosa para inferência de modelos distribuídos de grande porte. Ao oferecer suporte a bibliotecas populares como PyTorch Pi PPy nativo e HuggingFace Accelerate, ele oferece um manipulador uniforme APIs que permanece consistente em cenários distribuídos de inferência de modelos grandes e modelos não distribuídos. DeepSpeed Para obter mais informações, consulte [TorchServea grande documentação de inferência de modelos](https://pytorch.org/serve/large_model_inference.html#).
## Contêineres de aprendizado profundo com TorchServe
Para implantar um modelo grande sem TorchServe SageMaker IA, você pode usar um dos contêineres de aprendizado profundo de SageMaker IA (DLCs). Por padrão, TorchServe está instalado em todos AWS PyTorch DLCs. Durante o carregamento do modelo, TorchServe pode instalar bibliotecas especializadas personalizadas para modelos grandes, como PiPPy, Deepspeed e Accelerate.
A tabela a seguir lista toda a [SageMaker IA DLCs com TorchServe](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only).
| Categoria DLC | Framework | Hardware | Exemplo de URL |
| --- | --- | --- | --- |
| [SageMaker Contêineres de estrutura de](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) | PyTorch 2.0.0\$1 | CPU, GPU | 763104351884.dkr.ecr.us-east-1.amazonaws.com/PyTorch-inference:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker |
| [SageMaker Contêineres AI Framework Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) | PyTorch 2.0.0\$1 | CPU | 763104351884.dkr. ecr.us-east-1.amazonaws.com /:2.0.1-cpu-py310-ubuntu20.04-sagemaker pytorch-inference-graviton |
| [Contêineres de inferência StabilityAI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#stabilityai-inference-containers) | PyTorch 2.0.0\$1 | GPU | 763104351884.dkr. ecr.us-east-1.amazonaws.com /:2.0.1-sgm0.1.0-gpu-py310-cu118-ubuntu20.04-sagemaker stabilityai-pytorch-inference |
| [Contêineres de neurônios](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) | PyTorch 1.13.1 | Neuronx | 763104351884.dkr. ecr.us-west-2.amazonaws.com /:1.13.1-neuron-py310-sdk2.12.0-ubuntu20.04 pytorch-inference-neuron |
## Introdução
Antes de implantar seu modelo, preencha os pré-requisitos. Você também pode configurar os parâmetros do modelo e personalizar o código do manipulador.
### Pré-requisitos
Para começar, verifique se você tem os seguintes pré-requisitos:
1. Certifique-se de ter acesso a uma AWS conta. [Configure seu ambiente](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) para que eles AWS CLI possam acessar sua conta por meio de um usuário AWS do IAM ou de uma função do IAM. Recomendamos usar uma perfil do IAM. Para fins de teste em sua conta pessoal, você pode anexar as seguintes políticas de permissões gerenciadas à perfil do IAM:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWSServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
Para obter informações sobre como anexar políticas a identidades do IAM, consulte [Adicionar e remover permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM AWS *.
1. Configure suas dependências localmente, conforme mostrado nos exemplos a seguir.
1. Instale a versão 2 do AWS CLI:
```
# Install the latest AWS CLI v2 if it is not installed
!curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" !unzip awscliv2.zip
#Follow the instructions to install v2 on the terminal
!cat aws/README.md
```
1. Instale a SageMaker IA e o cliente Boto3:
```
# If already installed, update your client
#%pip install sagemaker pip --upgrade --quiet
!pip install -U sagemaker
!pip install -U boto
!pip install -U botocore
!pip install -U boto3
```
### Configurar parâmetros e configurações do modelo
TorchServe usa [https://pytorch.org/docs/stable/elastic/run.html](https://pytorch.org/docs/stable/elastic/run.html)para configurar o ambiente distribuído para processamento paralelo de modelos. TorchServe tem a capacidade de oferecer suporte a vários trabalhadores em um modelo grande. Por padrão, TorchServe usa um algoritmo round-robin para atribuir GPUs a um trabalhador em um host. No caso de inferência de modelo grande, o número GPUs atribuído a cada trabalhador é calculado automaticamente com base no número GPUs especificado no `model_config.yaml` arquivo. A variável de ambiente`CUDA_VISIBLE_DEVICES`, que especifica os dispositivos de GPU IDs que estão visíveis em um determinado momento, é definida com base nesse número.
Por exemplo, suponha que haja 8 GPUs em um nó e um trabalhador precise de 4 GPUs em um nó (`nproc_per_node=4`). Nesse caso, TorchServe atribui quatro GPUs ao primeiro trabalhador (`CUDA_VISIBLE_DEVICES="0,1,2,3"`) e quatro GPUs ao segundo trabalhador (`CUDA_VISIBLE_DEVICES="4,5,6,7”`).
Além desse comportamento padrão, TorchServe fornece a flexibilidade para os usuários especificarem GPUs para um trabalhador. Por exemplo, se você definir a variável `deviceIds: [2,3,4,5]` no [arquivo YAML de configuração do modelo](https://github.com/pytorch/serve/blob/5ee02e4f050c9b349025d87405b246e970ee710b/model-archiver/README.md?plain=1#L164) e definir`nproc_per_node=2`, TorchServe atribuirá `CUDA_VISIBLE_DEVICES=”2,3”` ao primeiro trabalhador e `CUDA_VISIBLE_DEVICES="4,5”` ao segundo trabalhador.
No exemplo `model_config.yaml` a seguir, configuramos os parâmetros front-end e backend para o modelo [OPT-30b](https://huggingface.co/facebook/opt-30b). Os parâmetros de front-end configurados são `parallelType`, `deviceType`, `deviceIds ` e `torchrun`. [Para obter informações mais detalhadas sobre os parâmetros de front-end que você pode configurar, consulte a PyTorch GitHub documentação.](https://github.com/pytorch/serve/blob/2bf505bae3046b0f7d0900727ec36e611bb5dca3/docs/configuration.md?plain=1#L267) A configuração de backend é baseada em um mapa YAML que permite a personalização em estilo livre. Para os parâmetros de back-end, definimos a DeepSpeed configuração e os parâmetros adicionais usados pelo código do manipulador personalizado.
```
# TorchServe front-end parameters
minWorkers: 1
maxWorkers: 1
maxBatchDelay: 100
responseTimeout: 1200
parallelType: "tp"
deviceType: "gpu"
# example of user specified GPU deviceIds
deviceIds: [0,1,2,3] # sets CUDA_VISIBLE_DEVICES
torchrun:
nproc-per-node: 4
# TorchServe back-end parameters
deepspeed:
config: ds-config.json
checkpoint: checkpoints.json
handler: # parameters for custom handler code
model_name: "facebook/opt-30b"
model_path: "model/models--facebook--opt-30b/snapshots/ceea0a90ac0f6fae7c2c34bcb40477438c152546"
max_length: 50
max_new_tokens: 10
manual_seed: 40
```
### Personalizar manipuladores
TorchServe oferece [manipuladores básicos](https://github.com/pytorch/serve/tree/master/ts/torch_handler/distributed) e [utilitários de manipulador](https://github.com/pytorch/serve/tree/master/ts/handler_utils) para inferência de modelos grandes criados com bibliotecas populares. O exemplo a seguir demonstra como a classe do manipulador personalizado [TransformersSeqClassifierHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/examples/large_models/deepspeed/custom_handler.py#L16C7-L16C39)estende [BaseDeepSpeedHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/ts/torch_handler/distributed/base_deepspeed_handler.py#L8)e usa os utilitários do [manipulador](https://github.com/pytorch/serve/blob/master/ts/handler_utils/distributed/deepspeed.py). Para ver um exemplo de código completo, consulte o [`custom_handler.py`código na PyTorch GitHub documentação](https://github.com/pytorch/serve/blob/master/examples/large_models/deepspeed/custom_handler.py).
```
class TransformersSeqClassifierHandler(BaseDeepSpeedHandler, ABC):
"""
Transformers handler class for sequence, token classification and question answering.
"""
def __init__(self):
super(TransformersSeqClassifierHandler, self).__init__()
self.max_length = None
self.max_new_tokens = None
self.tokenizer = None
self.initialized = False
def initialize(self, ctx: Context):
"""In this initialize function, the HF large model is loaded and
partitioned using DeepSpeed.
Args:
ctx (context): It is a JSON Object containing information
pertaining to the model artifacts parameters.
"""
super().initialize(ctx)
model_dir = ctx.system_properties.get("model_dir")
self.max_length = int(ctx.model_yaml_config["handler"]["max_length"])
self.max_new_tokens = int(ctx.model_yaml_config["handler"]["max_new_tokens"])
model_name = ctx.model_yaml_config["handler"]["model_name"]
model_path = ctx.model_yaml_config["handler"]["model_path"]
seed = int(ctx.model_yaml_config["handler"]["manual_seed"])
torch.manual_seed(seed)
logger.info("Model %s loading tokenizer", ctx.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.tokenizer.pad_token = self.tokenizer.eos_token
config = AutoConfig.from_pretrained(model_name)
with torch.device("meta"):
self.model = AutoModelForCausalLM.from_config(
config, torch_dtype=torch.float16
)
self.model = self.model.eval()
ds_engine = get_ds_engine(self.model, ctx)
self.model = ds_engine.module
logger.info("Model %s loaded successfully", ctx.model_name)
self.initialized = True
def preprocess(self, requests):
"""
Basic text preprocessing, based on the user's choice of application mode.
Args:
requests (list): A list of dictionaries with a "data" or "body" field, each
containing the input text to be processed.
Returns:
tuple: A tuple with two tensors: the batch of input ids and the batch of
attention masks.
"""
def inference(self, input_batch):
"""
Predicts the class (or classes) of the received text using the serialized transformers
checkpoint.
Args:
input_batch (tuple): A tuple with two tensors: the batch of input ids and the batch
of attention masks, as returned by the preprocess function.
Returns:
list: A list of strings with the predicted values for each input text in the batch.
"""
def postprocess(self, inference_output):
"""Post Process Function converts the predicted response into Torchserve readable format.
Args:
inference_output (list): It contains the predicted response of the input text.
Returns:
(list): Returns a list of the Predictions and Explanations.
"""
```
## Prepare seus artefatos de modelo
Antes de implantar seu modelo na SageMaker IA, você deve empacotar seus artefatos de modelo. Para modelos grandes, recomendamos que você use a PyTorch [torch-model-archiver](https://github.com/pytorch/serve/blob/master/model-archiver/README.md)ferramenta com o argumento`--archive-format no-archive`, que ignora a compactação de artefatos do modelo. O exemplo a seguir salva todos os artefatos do modelo em uma nova pasta chamada `opt/`.
```
torch-model-archiver --model-name opt --version 1.0 --handler custom_handler.py --extra-files ds-config.json -r requirements.txt --config-file opt/model-config.yaml --archive-format no-archive
```
[Depois que a `opt/` pasta for criada, baixe o modelo Opt-30b para a pasta usando a ferramenta Download\$1model. PyTorch ](https://github.com/pytorch/serve/blob/master/examples/large_models/utils/Download_model.py)
```
cd opt
python path_to/Download_model.py --model_path model --model_name facebook/opt-30b --revision main
```
Por fim, faça upload dos artefatos do modelo para um bucket do Amazon S3.
```
aws s3 cp opt {your_s3_bucket}/opt --recursive
```
Agora você deve ter artefatos de modelo armazenados no Amazon S3 prontos para serem implantados em SageMaker um endpoint de IA.
## Implante o modelo usando o SDK do SageMaker Python
Depois de preparar seus artefatos de modelo, você pode implantar seu modelo em um endpoint de hospedagem de SageMaker IA. Esta seção descreve como implantar um único modelo grande em um endpoint e fazer predições de resposta de streaming. Para obter mais informações sobre streaming de respostas de endpoints, consulte [Invocar endpoints em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-test-endpoints.html).
Para implantar seu modelo, conclua as seguintes etapas:
1. Crie uma sessão de SageMaker IA, conforme mostrado no exemplo a seguir.
```
import boto3
import sagemaker
from sagemaker import Model, image_uris, serializers, deserializers
boto3_session=boto3.session.Session(region_name="us-west-2")
smr = boto3.client('sagemaker-runtime-demo')
sm = boto3.client('sagemaker')
role = sagemaker.get_execution_role() # execution role for the endpoint
sess= sagemaker.session.Session(boto3_session, sagemaker_client=sm, sagemaker_runtime_client=smr) # SageMaker AI session for interacting with different AWS APIs
region = sess._region_name # region name of the current SageMaker Studio Classic environment
account = sess.account_id() # account_id of the current SageMaker Studio Classic environment
# Configuration:
bucket_name = sess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}"
print(f'account={account}, region={region}, role={role}, output_path={output_path}')
```
1. Crie um modelo não compactado na SageMaker IA, conforme mostrado no exemplo a seguir.
```
from datetime import datetime
instance_type = "ml.g5.24xlarge"
endpoint_name = sagemaker.utils.name_from_base("ts-opt-30b")
s3_uri = {your_s3_bucket}/opt
model = Model(
name="torchserve-opt-30b" + datetime.now().strftime("%Y-%m-%d-%H-%M-%S"),
# Enable SageMaker uncompressed model artifacts
model_data={
"S3DataSource": {
"S3Uri": s3_uri,
"S3DataType": "S3Prefix",
"CompressionType": "None",
}
},
image_uri=container,
role=role,
sagemaker_session=sess,
env={"TS_INSTALL_PY_DEP_PER_MODEL": "true"},
)
print(model)
```
1. Implante o modelo em uma instância do Amazon EC2, conforme mostrado no exemplo a seguir.
```
model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
volume_size=512, # increase the size to store large model
model_data_download_timeout=3600, # increase the timeout to download large model
container_startup_health_check_timeout=600, # increase the timeout to load large model
)
```
1. Inicialize uma classe para processar a resposta de streaming, conforme mostrado no exemplo a seguir.
```
import io
class Parser:
"""
A helper class for parsing the byte stream input.
The output of the model will be in the following format:
```
b'{"outputs": [" a"]}\n'
b'{"outputs": [" challenging"]}\n'
b'{"outputs": [" problem"]}\n'
...
```
While usually each PayloadPart event from the event stream will contain a byte array
with a full json, this is not guaranteed and some of the json objects may be split across
PayloadPart events. For example:
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
This class accounts for this by concatenating bytes written via the 'write' function
and then exposing a method which will return lines (ending with a '\n' character) within
the buffer via the 'scan_lines' function. It maintains the position of the last read
position to ensure that previous bytes are not exposed again.
"""
def __init__(self):
self.buff = io.BytesIO()
self.read_pos = 0
def write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
data = self.buff.getvalue()
def scan_lines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
if line[-1] != b'\n':
self.read_pos += len(line)
yield line[:-1]
def reset(self):
self.read_pos = 0
```
1. Teste uma predição de resposta de streaming, conforme mostrado no exemplo a seguir.
```
import json
body = "Today the weather is really nice and I am planning on".encode('utf-8')
resp = smr.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=body, ContentType="application/json")
event_stream = resp['Body']
parser = Parser()
for event in event_stream:
parser.write(event['PayloadPart']['Bytes'])
for line in parser.scan_lines():
print(line.decode("utf-8"), end=' ')
```
Agora você implantou seu modelo em um endpoint de SageMaker IA e deve ser capaz de invocá-lo para obter respostas. Para obter mais informações sobre endpoints de SageMaker IA em tempo real, consulte[Endpoints de modelo único](realtime-single-model.md).
# Barreiras de proteção de implantação para atualização de modelos em produção
As barreiras de proteção da implantação são um conjunto de opções de implantação de modelos no Amazon SageMaker AI Inference para atualizar modelos de machine learning em produção. Usando as opções do total gerenciamento de implantações, você pode controlar a mudança do modelo atual em produção para um novo. Os modos de deslocamento de tráfego em implantações azul/verde, como canário e linear, oferecem controle da granularidade sobre o processo de deslocamento de tráfego do seu modelo atual para o novo durante o curso da atualização. Também há proteções integradas, como reversões automáticas que ajudam você a detectar problemas com antecedência e a tomar medidas corretivas automaticamente, antes que elas impactem significativamente a produção.
As barreiras de proteção de implantação fornecem os seguintes benefícios:
+ **Segurança de implantação durante a atualização dos ambientes de produção.** Uma atualização de regressão para um ambiente de produção pode causar tempo de inatividade não planejado e impactos nos negócios, como maior latência do modelo e altas taxas de erro. As barreiras de proteção da implantação ajudam você a mitigar esses riscos fornecendo as práticas recomendadas e barreiras de proteção de segurança operacional integradas.
+ **Implantação totalmente gerenciada.** O SageMaker AI se encarrega de configurar e orquestrar essas implantações e as integra aos mecanismos de atualização de endpoints. Você não precisa compilar e manter mecanismos de orquestração, monitoramento ou reversão. Você pode utilizar o SageMaker AI para configurar e orquestrar essas implantações e se concentrar em utilizar o ML para suas aplicações.
+ **Visibilidade.** Você pode monitorar o andamento da sua implantação por meio da API [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) ou por meio do Amazon CloudWatch Events (para [endpoints compatíveis](deployment-guardrails-exclusions.md)). Para saber mais sobre eventos no SageMaker AI, consulte a seção sobre “Alteração do estado da implantação do endpoint” em [Eventos que a Amazon SageMaker AI envia para a Amazon EventBridge](automating-sagemaker-with-eventbridge.md). Observe que, se seu endpoint usar qualquer uma das funcionalidades da página [Exclusions](deployment-guardrails-exclusions.md), você não poderá usar o CloudWatch Events.
**nota**
As barreiras de proteção de implantação se aplicam apenas aos tipos de endpoints [Inferência assíncrona](async-inference.md) e [Inferência em tempo real](realtime-endpoints.md).
## Como começar
Oferecemos compatibilidade com dois tipos de implantações para atualizar modelos em produção: implantações azul/verde e implantações de rolagem.
+ [Implantações azul/verde](deployment-guardrails-blue-green.md): Você pode transferir o tráfego da sua frota antiga (a frota azul) para uma nova frota (a frota verde) com as atualizações. As implantações azul/verde oferecem [vários modos de deslocamento de tráfego](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green.html). Um modo de deslocamento de tráfego é uma configuração que especifica como o SageMaker AI direciona o tráfego de endpoints para uma nova frota contendo suas atualizações. Os seguintes modos de deslocamento de tráfego fornecem diferentes níveis de controle sobre o processo de atualização do endpoint:
+ [Use todo o deslocamento de tráfego de uma só vez](deployment-guardrails-blue-green-all-at-once.md) transfere todo o seu tráfego de endpoints da frota azul para a frota verde. Quando o tráfego se desloca para a frota verde, seus alarmes preespecificados do Amazon CloudWatch começam a monitorar a frota verde por um determinado período de tempo (o *período de baking*). Se nenhum alarme disparar durante o período de incorporação, o SageMaker AI encerrará a frota azul.
+ [Use o deslocamento de tráfego do canário](deployment-guardrails-blue-green-canary.md) transfere uma pequena parte de seu tráfego (um *canário*) para a frota verde e a monitora por um período de baking. Se o canário tiver êxito na frota verde, o SageMaker AI transferirá o resto do tráfego da frota azul para a frota verde antes de encerrar a frota azul.
+ [Usar o deslocamento de tráfego linear](deployment-guardrails-blue-green-linear.md) fornece ainda mais personalização sobre o número de etapas de deslocamento de tráfego e a porcentagem de tráfego a ser deslocada em cada etapa. *Enquanto a mudança canária permite que você mude o tráfego em duas etapas, a mudança linear estende isso para n etapas espaçadas linearmente.*
+ [Usar implantações contínuas](deployment-guardrails-rolling.md): você pode atualizar seu endpoint à medida que o SageMaker AI provisiona a capacidade de forma incremental e transfere o tráfego para uma nova frota em etapas com o tamanho de lote que você especificar. As instâncias na nova frota são atualizadas com a configuração da nova implantação e, se nenhum alarme do CloudWatch disparar durante o período de incorporação, o SageMaker AI limpará as instâncias na frota antiga. Essa opção oferece controle granular sobre a contagem de instâncias ou a porcentagem de capacidade alterada durante cada etapa.
Você pode criar e gerenciar sua implantação por meio da API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) e dos comandos AWS Command Line Interface do SageMaker. Consulte as páginas individuais de implantação para obter mais detalhes de instrução sobre como configurar sua implantação. Observe que, se o seu endpoint usar qualquer uma das funcionalidades listadas na página [Exclusions](deployment-guardrails-exclusions.md), você não poderá usar as barreiras de proteção de implantação.
Para seguir exemplos guiados que mostram como fazer barreiras de proteção de implantação, consulte nosso exemplo de [cadernos Jupyter](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails) para os modos de deslocamento de tráfego canário e linear.
# Configuração de reversão automática e monitoramento
Os CloudWatch alarmes da Amazon são um pré-requisito para usar períodos de espera nas grades de proteção de implantação. Você só pode usar a funcionalidade de reversão automática nas grades de proteção de implantação se configurar CloudWatch alarmes que possam monitorar um endpoint. Se algum de seus alarmes disparar durante o período de monitoramento especificado, a SageMaker IA iniciará uma reversão completa para o endpoint antigo para proteger seu aplicativo. Se você não tiver nenhum CloudWatch alarme configurado para monitorar seu endpoint, a funcionalidade de reversão automática não funcionará durante a implantação.
Para saber mais sobre a Amazon CloudWatch, consulte [O que é a Amazon CloudWatch?](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) no *Guia do CloudWatch usuário da Amazon*.
**nota**
Certifique-se de que sua função de execução do IAM tenha permissão para realizar a ação `cloudwatch:DescribeAlarms` nos alarmes de reversão automática que você especificar.
## Exemplos de alarme
Para ajudar você a começar, fornecemos os exemplos a seguir para demonstrar as capacidades dos CloudWatch alarmes. Além de usar ou modificar os exemplos a seguir, você pode criar seus próprios alarmes e configurar os alarmes para monitorar várias métricas nas frotas especificadas por um determinado período de tempo. Para ver mais métricas e dimensões de SageMaker IA que você pode adicionar aos seus alarmes, consulte[Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md).
**Topics**
+ [Monitore erros de invocação em frotas antigas e novas](#deployment-guardrails-configuration-alarm-examples-errors-both)
+ [Monitore a latência do modelo na nova frota](#deployment-guardrails-configuration-alarm-examples-latency-new)
### Monitore erros de invocação em frotas antigas e novas
O CloudWatch alarme a seguir monitora a taxa média de erro de um endpoint. Você pode usar esse alarme com qualquer tipo de deslocamento de tráfego de barreiras de proteção de implantação para fornecer monitoramento geral das frotas antigas e novas. Se o alarme disparar, a SageMaker IA iniciará uma reversão para a frota antiga.
Os erros de invocação provenientes da frota antiga e da nova frota contribuem para a taxa média de erro. Se a taxa média de erro exceder o limite especificado, o alarme dispara. Esse exemplo específico monitora os erros 4xx (erros do cliente) nas frotas antigas e novas na duração da implantação. Você também pode monitorar os erros 5xx (erros do servidor) usando a métrica `Invocation5XXErrors`.
**nota**
Para esse tipo de alarme, se sua frota antiga disparar o alarme durante a implantação, a SageMaker IA encerrará sua implantação. Portanto, se sua frota de produto atual já causar erros, considere usar ou modificar um dos exemplos a seguir, que monitora somente a nova frota em busca de erros.
```
#Applied deployment type: all types
{
"AlarmName": "EndToEndDeploymentHighErrorRateAlarm",
"AlarmDescription": "Monitors the error rate of 4xx errors",
"MetricName": "Invocation4XXErrors",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
}
],
"Period": 600,
"EvaluationPeriods": 2,
"Threshold": 1,
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
No exemplo anterior, observe os valores para os seguintes campos:
+ Para `AlarmName` e `AlarmDescription`, insira um nome e descrição de sua escolha para o alarme.
+ Para `MetricName`, use o valor `Invocation4XXErrors` para monitorar erros 4xx no endpoint
+ Para `Namespace`, use o valor `AWS/SageMaker`. Você também pode especificar sua própria métrica personalizada, se aplicável.
+ Para `Statistic`, use `Average`. Isso significa que o alarme calcula a taxa média de erro durante os períodos de avaliação ao calcular se a taxa de erro excedeu o limite.
+ Para a dimensão `EndpointName`, use o nome do endpoint que você está atualizando como valor.
+ Para a dimensão `VariantName`, use o valor `AllTraffic` para especificar todo o tráfego do endpoint.
+ Para `Period`, use `600`. Isso define os períodos de avaliação do alarme para 10 minutos.
+ Para `EvaluationPeriods`, use `2`. Esse valor faz com que o alarme considere os dois períodos de avaliação mais recentes ao determinar o status do alarme.
### Monitore a latência do modelo na nova frota
O exemplo de CloudWatch alarme a seguir monitora a latência do modelo da nova frota durante sua implantação. Você pode usar esse alarme para monitorar somente a nova frota e excluir a frota antiga. O alarme dura por toda a implantação. Este exemplo fornece um end-to-end monitoramento abrangente da nova frota e inicia uma reversão para a frota antiga se a nova frota tiver algum problema de tempo de resposta.
CloudWatch publica as métricas com a dimensão `EndpointConfigName:{New-Ep-Config}` depois que a nova frota começa a receber tráfego, e essas métricas duram mesmo após a conclusão da implantação.
Você pode usar o seguinte exemplo de alarme para qualquer tipo de implantação:
```
#Applied deployment type: all types
{
"AlarmName": "NewEndpointConfigVersionHighModelLatencyAlarm",
"AlarmDescription": "Monitors the model latency on new fleet",
"MetricName": "ModelLatency",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
},
{
"Name": "EndpointConfigName",
"Value":
],
"Period": 300,
"EvaluationPeriods": 2,
"Threshold": 100000, # 100ms
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
No exemplo anterior, observe os valores para os seguintes campos:
+ Para `MetricName`, use o valor `ModelLatency` para monitorar o tempo de resposta do modelo.
+ Para `Namespace`, use o valor `AWS/SageMaker`. Você também pode especificar sua própria métrica personalizada, se aplicável.
+ Para a dimensão `EndpointName`, use o nome do endpoint que você está atualizando como valor.
+ Para a dimensão `VariantName`, use o valor `AllTraffic` para especificar o tráfego de todos os endpoints.
+ Para a dimensão `EndpointConfigName`, o valor deve se referir ao nome da configuração de endpoint do seu novo endpoint atualizado.
**nota**
Se quiser monitorar sua frota antiga em vez da frota nova, você pode alterar a dimensão `EndpointConfigName` para especificar o nome da configuração da sua frota antiga.
# Implantações azul/verde
Quando você atualiza seu endpoint, o Amazon SageMaker AI usa automaticamente uma implantação azul/verde para maximizar a disponibilidade dos endpoints. Em uma implantação azul/verde, o SageMaker AI provisiona uma nova frota com as atualizações (a frota verde). Em seguida, ele transfere o tráfego da frota antiga (a frota azul) para a frota verde. Quando a frota verde opera sem problemas por um período de avaliação configurado (chamado de período de incorporação), o SageMaker AI encerra a frota azul. Com os recursos adicionais em implantações azul/verde, você pode utilizar os modos de deslocamento de tráfego e o monitoramento de reversão automática para proteger seu endpoint de um impacto significativo na produção.
A seguinte lista descreve os principais recursos das implantações azul/verde no SageMaker AI:
+ **Modos de deslocamento de tráfego.** Os modos de deslocamento de tráfego para barreiras de proteção de implantação permitem controlar o volume de tráfego e o número de etapas de deslocamento de tráfego entre a frota azul e a frota verde. Esse recurso permite avaliar progressivamente a performance da frota verde sem confirmar totalmente um deslocamento de tráfego de 100%.
+ **Período de baking.** O período de baking é um período de tempo configurado para monitorar a frota verde antes de prosseguir para a próxima etapa de implantação. Se algum dos alarmes pré-especificados disparar durante qualquer período de baking, todo o tráfego do endpoint será revertido para a frota azul. O período de baking ajuda você a adquirir confiança em sua atualização antes de tornar o deslocamento de tráfego permanente.
+ **Reversões automáticas. ** Você pode especificar os alarmes do Amazon CloudWatch que o SageMaker AI usa para monitorar a frota verde. Se um problema com o código de atualização disparar algum dos alarmes, o SageMaker AI iniciará uma reversão automática para a frota azul a fim de manter a disponibilidade e minimizar os riscos.
## Modos de deslocamento de tráfego.
Os vários modos de deslocamento de tráfego em implantações azul/verde oferecem um controle com mais granularidade sobre o deslocamento de tráfego entre a frota azul e a frota verde. Os modos de deslocamento de tráfego disponíveis para implantações azul/verde são todos simultâneos, canários e lineares. A tabela a seguir mostra uma comparação entre as opções.
**Importante**
Para implantações azul/verde que envolvam deslocamento de tráfego ou baking em vários períodos, você é faturado para ambas as frotas pela duração da atualização, independentemente do tráfego para a frota. Isso contrasta com as implantações azul/verde com deslocamento de tráfego de uma só vez e sem períodos de baking, em que você só é faturado apenas por uma frota durante o curso da atualização.
| Name | O que é isso? | Prós | Contras | Recomendação |
| --- | --- | --- | --- | --- |
| Tudo de uma vez | Alterna todo o tráfego para a nova frota em uma única etapa. | Minimiza a duração geral da atualização. | As atualizações de regressão afetam 100% do tráfego. | Use essa opção para minimizar o custo e o tempo de atualização. |
| Canário | O tráfego se desloca em duas etapas. A primeira etapa (canário) desloca uma pequena parte do tráfego seguida pela segunda etapa, que desloca o restante do tráfego. | Limita o raio de explosão das atualizações regressivas somente à frota de canários. | Ambas as frotas ficam operacionais em paralelismo durante toda a implantação. | Use essa opção para balancear entre a minimização do raio de explosão das atualizações regressivas e a minimização do tempo em que duas frotas estão operacionais. |
| Linear | Uma porção fixa do tráfego se desloca em um número pré-especificado de etapas igualmente espaçadas. | Minimiza o risco de atualizações de regressão ao deslocar o tráfego em várias etapas. | A duração e o custo da atualização são proporcionais ao número de etapas. | Use essa opção para minimizar o risco ao disseminar a implantação em várias etapas. |
## Conceitos básicos
Depois que você especifica sua configuração de implantação desejada, o SageMaker AI gerencia o provisionamento de novas instâncias, o encerramento de instâncias antigas e a transferência de tráfego para você. Você pode criar e gerenciar sua implantação por meio da API e dos comandos AWS Command Line Interface existentes do [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) e [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) do SageMaker. Observe que, se o seu endpoint usar qualquer uma das funcionalidades listadas na página [Exclusions](deployment-guardrails-exclusions.md), você não poderá usar barreiras de proteção de implantação. Consulte as páginas individuais de implantação para obter mais detalhes sobre como configurar sua implantação:
+ [ Atualização azul/verde com deslocamento de tráfego de uma só vez](deployment-guardrails-blue-green-all-at-once.md)
+ [ Atualização azul/verde com deslocamento de tráfego do Canário](deployment-guardrails-blue-green-canary.md)
+ [ Atualização azul/verde com deslocamento de tráfego linear](deployment-guardrails-blue-green-linear.md)
Para seguir exemplos guiados que mostram como usar as barreiras de proteção de implantação, consulte nossos exemplos de [blocos de anotação Jupyter](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails) para os modos de deslocamento de tráfego canário e linear.
# Use todo o deslocamento de tráfego de uma só vez
Com o deslocamento de tráfego, tudo de uma vez, você pode implementar rapidamente uma atualização de endpoint usando as barreiras de proteção de uma implantação azul/verde. Você pode usar essa opção de deslocamento de tráfego para minimizar a duração da atualização e, ao mesmo tempo, aproveitar as garantias de disponibilidade das implantações azul/verde. O atributo de período de baking ajuda você a monitorar o desempenho e a funcionalidade de suas novas instâncias antes de encerrar suas instâncias antigas, garantindo que sua nova frota esteja totalmente operacional.
O diagrama a seguir mostra como, o deslocamento de tráfego de uma só vez gerencia as frotas antigas e novas.
![\[Um deslocamento de tráfego de 100% bem-sucedido da frota anterior para a nova frota.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/deployment-guardrails-blue-green-all-at-once.png)
Quando você usa o deslocamento de tráfego de uma só vez, o SageMaker AI roteia 100% do tráfego para a nova frota (frota verde). Quando a frota verde começa a receber tráfego, o período de baking começa. O período de baking é um período definido em que os alarmes pré-especificados do Amazon CloudWatch monitoram o desempenho da frota verde. Quando nenhum alarme dispara durante o período de incorporação, o SageMaker AI encerra a frota antiga (frota azul). Se algum alarme disparar durante o período de baking, uma reversão automática será iniciada e 100% do tráfego se deslocará de volta para a frota azul.
## Pré-requisitos
Antes de configurar uma implantação com tudo de uma vez, você deve criar alarmes do Amazon CloudWatch para monitorar as métricas a partir do seu endpoint. Se qualquer alarme for disparado durante o período de baking, o tráfego começará a se reverter para sua frota azul. Para saber como configurar os alarmes do CloudWatch em um endpoint, consulte a página de pré-requisitos [Configuração de reversão automática e monitoramento](deployment-guardrails-configuration.md). Para obter mais informações sobre alarmes do CloudWatch, consulte [Usando alarmes do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) no *Guia do usuário do Amazon CloudWatch*.
## Configuração de todo o deslocamento de tráfego de uma só vez
Quando estiver tudo pronto para a implantação e você tiver configurado os alarmes do CloudWatch para o seu endpoint, você poderá usar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) do SageMaker AI ou o comando [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) na AWS Command Line Interface para iniciar a implantação.
**Topics**
+ [Como atualizar um endpoint (API)](#deployment-guardrails-blue-green-all-at-once-configure-api-update)
+ [Como atualizar um endpoint com uma política de atualização azul/verde existente (API)](#deployment-guardrails-blue-green-all-at-once-configure-api-existing)
+ [Como atualizar um endpoint (CLI)](#deployment-guardrails-blue-green-all-at-once-configure-cli-update)
### Como atualizar um endpoint (API)
O exemplo a seguir mostra como você pode atualizar seu endpoint com um deslocamento de tráfego de uma só vez usando o [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) na API do Amazon SageMaker.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "ALL_AT_ONCE"
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
}
}
)
```
Para configurar a opção de deslocamento de tráfego de uma só vez, faça o seguinte:
+ Em `EndpointName`, use o nome do endpoint existente que você deseja atualizar.
+ Em `EndpointConfigName`, use o nome da configuração de endpoint que deseja usar.
+ Em `DeploymentConfig` e `BlueGreenUpdatePolicy`, no `TrafficRoutingConfiguration`, defina o parâmetro `Type` como `ALL_AT_ONCE`. Isso especifica que a implantação usa o modo de deslocamento de tráfego de uma só vez.
+ Para `TerminationWaitInSeconds`, use `600`. Esse parâmetro instrui o SageMaker AI para aguardar pelo tempo especificado (em segundos) depois que sua frota verde estiver totalmente ativa para só então encerrar as instâncias na frota azul. Neste exemplo, antes de encerrar a frota azul, o SageMaker AI espera 10 minutos após o período final de incorporação.
+ Para `MaximumExecutionTimeoutInSeconds`, use `1800`. Esse parâmetro define o tempo máximo em que a implantação pode ser executada antes de o tempo limite ser atingido. No exemplo anterior, sua implantação tem um limite de 30 minutos para ser concluída.
+ Em `AutoRollbackConfiguration`, dentro do campo `Alarms`, você pode adicionar seus alarmes do CloudWatch por nome. Crie uma entrada `AlarmName: ` para cada alarme que você deseja usar.
### Como atualizar um endpoint com uma política de atualização azul/verde existente (API)
Ao usar a API [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) para criar um endpoint, você pode, opcionalmente, especificar uma configuração de implantação para reutilizar em futuras atualizações de endpoint. Você pode usar as mesmas opções `DeploymentConfig` do exemplo anterior da API UpdateEndpoint. Não há alterações no comportamento da API CreateEndpoint. Especificar a configuração da implantação não executa automaticamente uma atualização azul/verde no seu endpoint.
A opção de usar uma configuração de implantação anterior acontece ao usar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) para atualizar seu endpoint. Ao atualizar seu endpoint, você pode usar a opção `RetainDeploymentConfig` para manter a configuração da implantação especificada ao criar o endpoint.
Ao chamar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), defina `RetainDeploymentConfig` como `True` para manter as opções `DeploymentConfig` da configuração de endpoint originais.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### Como atualizar um endpoint (CLI)
Se você estiver usando o AWS CLI, o exemplo a seguir mostra como iniciar uma implantação azul/verde de uma só vez usando o comando [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html).
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "ALL_AT_ONCE"},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Para configurar a opção de deslocamento de tráfego de uma só vez, faça o seguinte:
+ Em `endpoint-name`, use o nome do endpoint que você deseja atualizar.
+ Em `endpoint-config-name`, use o nome da configuração de endpoint que deseja usar.
+ Para `deployment-config`, use um objeto JSON da [BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**nota**
Se você preferir salvar seu objeto JSON em um arquivo, consulte a [Geração de esqueleto AWS CLI e parâmetros de entrada](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) no *Guia do usuário AWS CLI*.
# Use o deslocamento de tráfego do canário
Com o deslocamento de tráfego do canário, você pode testar uma parte do seu tráfego de endpoints na nova frota enquanto a frota antiga atende ao restante do tráfego. Essa etapa de testes é uma barreira de proteção que valida a funcionalidade da nova frota antes de transferir todo o tráfego para a nova frota. Você ainda tem os benefícios de uma implantação azul/verde e o atributo de canário adicionado permite garantir que sua nova frota (verde) possa realizar inferências antes de permitir que ela processe 100% do tráfego.
A parte da sua frota verde que é ativada para receber tráfego é chamada de canário e você pode escolher o tamanho desse canário. Observe que o tamanho do canário deve ser menor que ou igual a 50% da capacidade da nova frota. Quando o período de baking termina e nenhum alarme pré-especificado do Amazon CloudWatch dispara, o restante do tráfego se desloca da frota antiga (azul) para a frota verde. A mudança de tráfego do canário oferece mais segurança durante a sua implantação, pois qualquer problema com o modelo atualizado impacta apenas o canário.
O diagrama a seguir mostra como o deslocamento de tráfego do canário gerencia a distribuição do tráfego entre as frotas azul e verde.
![\[Uma mudança em duas etapas e bem-sucedida do tráfego de canários da frota anterior para a nova frota.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/deployment-guardrails-blue-green-canary.png)
Depois que o SageMaker AI provisiona a frota verde, ele roteia uma parte do tráfego de entrada (por exemplo, 25%) para o canário. Em seguida, começa o período de baking, durante o qual os seus alarmes do CloudWatch monitoram o desempenho da frota verde. Durante esse período, tanto a frota azul quanto a frota verde estão parcialmente ativas e recebendo tráfego. Se algum dos alarmes disparar durante o período de incorporação, o SageMaker AI iniciará uma reversão e todo o tráfego retornará à frota azul. Se nenhum dos alarmes disparar, todo o tráfego será transferido para a frota verde e haverá um período final de baking. Se o período final de incorporação terminar sem acionar nenhum alarme, a frota verde atenderá a todo tráfego e o SageMaker AI encerrará a frota azul.
## Pré-requisitos
Antes de configurar uma implantação com mudança de tráfego do canário, você deve criar alarmes no Amazon CloudWatch para monitorar as métricas do seu endpoint. Os alarmes ficam ativos durante o período de baking e, se algum alarme disparar, todo o tráfego do endpoint será revertido para a frota azul. Para saber como configurar os alarmes do CloudWatch em um endpoint, consulte a página de pré-requisitos [Configuração de reversão automática e monitoramento](deployment-guardrails-configuration.md). Para obter mais informações sobre alarmes do CloudWatch, consulte [Usando alarmes do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html), no *Guia do usuário do Amazon CloudWatch*.
## Configurar o deslocamento de tráfego de canários
Quando estiver tudo pronto para a implantação e já tiver configurado os alarmes do Amazon CloudWatch para o endpoint, você poderá usar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) do Amazon SageMaker AI ou o comando [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) na AWS CLI para iniciar a implantação.
**Topics**
+ [Como atualizar um endpoint (API)](#deployment-guardrails-blue-green-canary-configure-api-update)
+ [Como atualizar um endpoint com uma política de atualização azul/verde existente (API)](#deployment-guardrails-blue-green-canary-configure-api-existing)
+ [Como atualizar um endpoint (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### Como atualizar um endpoint (API)
O exemplo a seguir da API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) mostra como você pode atualizar um endpoint com o deslocamento de tráfego do canário.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "CANARY",
"CanarySize": {
"Type": "CAPACITY_PERCENT",
"Value": 30
},
"WaitIntervalInSeconds": 600
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Para configurar a opção de deslocamento de tráfego do canário, faça o seguinte:
+ Em `EndpointName`, use o nome do endpoint existente que você deseja atualizar.
+ Em `EndpointConfigName`, use o nome da configuração de endpoint que deseja usar.
+ Em `DeploymentConfig` e `BlueGreenUpdatePolicy`, em `TrafficRoutingConfiguration`, defina o parâmetro `Type` como `CANARY`. Isso especifica que a implantação usa o deslocamento de tráfego do canário.
+ No campo `CanarySize`, você pode alterar o tamanho do canário modificando os parâmetros `Type` e `Value`. Para `Type`, use `CAPACITY_PERCENT`, ou seja, a porcentagem da frota verde que você deseja usar como canário e, em seguida, defina `Value` como `30`. Neste exemplo, você usa 30% da capacidade da frota verde como canário. Observe que o tamanho do canário deve ser igual ou menor que 50% da capacidade da frota verde.
+ Para `WaitIntervalInSeconds`, use `600`. O parâmetro instrui o SageMaker AI para que aguarde o tempo especificado (em segundos) entre cada mudança de intervalo. Esse intervalo é a duração do período de baking do canário. No exemplo anterior, o SageMaker AI espera 10 minutos após a troca de canário e, em seguida, conclui o segundo e último deslocamento de tráfego.
+ Para `TerminationWaitInSeconds`, use `600`. Esse parâmetro instrui o SageMaker AI para aguardar pelo tempo especificado (em segundos) depois que sua frota verde estiver totalmente ativa para só então encerrar as instâncias na frota azul. Neste exemplo, antes de encerrar a frota azul, o SageMaker AI espera 10 minutos após o período final de incorporação.
+ Para `MaximumExecutionTimeoutInSeconds`, use `1800`. Esse parâmetro define o tempo máximo em que a implantação pode ser executada antes de o tempo limite ser atingido. No exemplo anterior, sua implantação tem um limite de 30 minutos para ser concluída.
+ Em `AutoRollbackConfiguration`, dentro do campo `Alarms`, você pode adicionar seus alarmes do CloudWatch por nome. Crie uma entrada `AlarmName: ` para cada alarme que você deseja usar.
### Como atualizar um endpoint com uma política de atualização azul/verde existente (API)
Ao usar a API [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) para criar um endpoint, você pode, opcionalmente, especificar uma configuração de implantação para reutilizar em futuras atualizações de endpoint. Você pode usar as mesmas opções `DeploymentConfig` do exemplo anterior da API UpdateEndpoint. Não há alterações no comportamento da API CreateEndpoint. Especificar a configuração da implantação não executa automaticamente uma atualização azul/verde no seu endpoint.
A opção de usar uma configuração de implantação anterior acontece ao usar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) para atualizar seu endpoint. Ao atualizar seu endpoint, você pode usar a opção `RetainDeploymentConfig` para manter a configuração da implantação especificada ao criar o endpoint.
Ao chamar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), defina `RetainDeploymentConfig` como `True` para manter as opções `DeploymentConfig` da configuração de endpoint originais.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### Como atualizar um endpoint (CLI)
Se você estiver usando o AWS CLI, o exemplo a seguir mostra como iniciar uma implantação do canário azul/verde usando o comando [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html).
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "CANARY",
"CanarySize": {"Type": "CAPACITY_PERCENT", "Value": 30}, "WaitIntervalInSeconds": 600},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Para configurar a opção de deslocamento de tráfego do canário, faça o seguinte:
+ Em `endpoint-name`, use o nome do endpoint que você deseja atualizar.
+ Em `endpoint-config-name`, use o nome da configuração de endpoint que deseja usar.
+ Para `deployment-config`, use um objeto JSON da [BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**nota**
Se você preferir salvar seu objeto JSON em um arquivo, consulte a [Geração de esqueleto AWS CLI e parâmetros de entrada](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) no *Guia do usuário AWS CLI*.
# Usar o deslocamento de tráfego linear
O deslocamento de tráfego linear permite que você transfira gradualmente o tráfego de sua frota antiga (frota azul) para sua nova frota (frota verde). Com deslocamento de tráfego linear, você pode deslocar o tráfego em várias etapas, minimizando a chance de uma interrupção no seu endpoint. Essa opção de implantação azul/verde oferece maior controle da granularidade sobre o deslocamento de tráfego.
Você pode escolher o número de instâncias ou a porcentagem da capacidade da frota verde a ser ativada durante cada etapa. Cada etapa linear deve estar apenas entre 10 e 50% da capacidade da frota verde. Para cada etapa, há um período de baking durante o qual seus alarmes pré-especificados do Amazon CloudWatch monitoram as métricas da frota verde. Quando o período de baking termina e nenhum alarme dispara, a porção ativa da sua frota verde continua recebendo tráfego e uma nova etapa começa. Se qualquer alarme for disparado durante o período de baking, o tráfego do endpoint irá se reverter para sua frota azul.
O diagrama a seguir mostra como o deslocamento de tráfego linear roteia o tráfego para as frotas azul e verde.
![\[Uma mudança em três etapas e bem-sucedida do tráfego linear da frota anterior para a nova frota.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/deployment-guardrails-blue-green-linear.png)
Depois que o SageMaker AI provisiona a nova frota, a primeira parte da frota verde é ativada e recebe tráfego. O SageMaker AI desativa a porção de mesmo tamanho da frota azul e o período de incorporação começa. Se qualquer alarme for disparado, todo o tráfego do endpoint irá se reverter para sua frota azul. Se o período de baking terminar, a próxima etapa será iniciada. Outra parte da frota verde é ativada e recebe tráfego, parte da frota azul é desativada e outro período de baking começa. O mesmo processo se repete até que a frota azul seja totalmente desativada e a frota verde esteja totalmente ativa e recebendo todo o tráfego. Se um alarme disparar a qualquer momento, o SageMaker AI encerrará o processo de deslocamento e 100% do tráfego voltará para a frota azul.
## Pré-requisitos
Antes de configurar uma implantação deslocamento de tráfego linear, você deve criar alarmes do CloudWatch para monitorar as métricas a partir do seu endpoint. Os alarmes ficam ativos durante o período de baking e, se algum alarme disparar, todo o tráfego do endpoint será revertido para a frota azul. Para saber como configurar os alarmes do CloudWatch em um endpoint, consulte a página de pré-requisitos [Configuração de reversão automática e monitoramento](deployment-guardrails-configuration.md). Para obter mais informações sobre alarmes do CloudWatch, consulte [Usando alarmes do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) no *Guia do usuário do Amazon CloudWatch*.
## Configurar o deslocamento de tráfego linear
Quando tudo estiver pronto para a implantação e tiver configurado os alarmes do CloudWatch para o seu endpoint, você poderá usar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) do Amazon SageMaker AI ou o comando [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) na AWS CLI para iniciar a implantação.
**Topics**
+ [Como atualizar um endpoint (API)](#deployment-guardrails-blue-green-linear-configure-api-update)
+ [Como atualizar um endpoint com uma política de atualização azul/verde existente (API)](#deployment-guardrails-blue-green-linear-configure-api-existing)
+ [Como atualizar um endpoint (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### Como atualizar um endpoint (API)
O exemplo a seguir da API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) mostra como você pode atualizar um endpoint com deslocamento de tráfego linear.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "LINEAR",
"LinearStepSize": {
"Type": "CAPACITY_PERCENT",
"Value": 20
},
"WaitIntervalInSeconds": 300
},
"TerminationWaitInSeconds": 300,
"MaximumExecutionTimeoutInSeconds": 3600
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Para configurar a opção de deslocamento de tráfego linear, faça o seguinte:
+ Em `EndpointName`, use o nome do endpoint existente que você deseja atualizar.
+ Em `EndpointConfigName`, use o nome da configuração de endpoint que deseja usar.
+ Em `DeploymentConfig` e `BlueGreenUpdatePolicy`, no `TrafficRoutingConfiguration`, defina o parâmetro `Type` como `LINEAR`. Isso especifica que a implantação usa o modo de deslocamento de tráfego linear.
+ No campo `LinearStepSize` você pode alterar o tamanho das etapas modificando os parâmetros `Type` e `Value`. Para`Type`, use `CAPACITY_PERCENT`, ou seja, a porcentagem de sua frota verde que você deseja usar como tamanho da etapa e, em seguida, defina `Value` como `20`. Neste exemplo, você ativa 20% da capacidade da frota verde para cada etapa de deslocamento de tráfego. Observe que, ao personalizar o tamanho da etapa linear, você deve usar apenas etapas que representem 10% a 50% da capacidade da frota verde.
+ Para `WaitIntervalInSeconds`, use `300`. O parâmetro instrui o SageMaker AI para aguardar pelo tempo especificado (em segundos) entre cada deslocamento de tráfego. Esse intervalo é a duração do período de baking entre cada etapa linear. No exemplo anterior, o SageMaker AI espera por 5 minutos entre cada deslocamento de tráfego.
+ Para `TerminationWaitInSeconds`, use `300`. Esse parâmetro instrui o SageMaker AI para aguardar pelo tempo especificado (em segundos) depois que sua frota verde estiver totalmente ativa para só então encerrar as instâncias na frota azul. Neste exemplo, antes de encerrar a frota azul, o SageMaker AI espera 5 minutos após o período final de incorporação.
+ Para `MaximumExecutionTimeoutInSeconds`, use `3600`. Esse parâmetro define o tempo máximo em que a implantação pode ser executada antes de o tempo limite ser atingido. No exemplo anterior, sua implantação tem um limite de 1 hora para ser concluída.
+ Em `AutoRollbackConfiguration`, dentro do campo `Alarms`, você pode adicionar seus alarmes do CloudWatch por nome. Crie uma entrada `AlarmName: ` para cada alarme que você deseja usar.
### Como atualizar um endpoint com uma política de atualização azul/verde existente (API)
Ao usar a API [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) para criar um endpoint, você pode, opcionalmente, especificar uma configuração de implantação para reutilizar em futuras atualizações de endpoint. Você pode usar as mesmas opções `DeploymentConfig` do exemplo anterior da API UpdateEndpoint. Não há alterações no comportamento da API CreateEndpoint. Especificar a configuração da implantação não executa automaticamente uma atualização azul/verde no seu endpoint.
A opção de usar uma configuração de implantação anterior acontece ao usar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) para atualizar seu endpoint. Ao atualizar seu endpoint, você pode usar a opção `RetainDeploymentConfig` para manter a configuração da implantação especificada ao criar o endpoint.
Ao chamar a API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), defina `RetainDeploymentConfig` como `True` para manter as opções `DeploymentConfig` da configuração de endpoint originais.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### Como atualizar um endpoint (CLI)
Se você estiver usando o AWS CLI, o exemplo a seguir mostra como iniciar uma implantação linear azul/verde usando o comando [atualizar endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html).
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '{"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "LINEAR",
"LinearStepSize": {"Type": "CAPACITY_PERCENT", "Value": 20}, "WaitIntervalInSeconds": 300},
"TerminationWaitInSeconds": 300, "MaximumExecutionTimeoutInSeconds": 3600},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Para configurar a opção de deslocamento de tráfego linear, faça o seguinte:
+ Em `endpoint-name`, use o nome do endpoint que você deseja atualizar.
+ Em `endpoint-config-name`, use o nome da configuração de endpoint que deseja usar.
+ Para `deployment-config`, use um objeto JSON da [BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**nota**
Se você preferir salvar seu objeto JSON em um arquivo, consulte a [Geração de esqueleto AWS CLI e parâmetros de entrada](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) no *Guia do usuário AWS CLI*.
# Usar implantações contínuas
Ao atualizar seu endpoint, você pode especificar uma implantação contínua para deslocar gradualmente o tráfego da sua frota antiga para uma nova frota. Você pode controlar o tamanho das etapas de deslocamento de tráfego, bem como especificar um período de avaliação para monitorar problemas nas novas instâncias antes de encerrar instâncias da frota antiga. Com implantações contínuas, as instâncias da frota antiga são limpas após cada deslocamento de tráfego para a nova frota, reduzindo a quantidade de instâncias adicionais necessárias para atualizar seu endpoint. Isso é útil principalmente para instâncias aceleradas que estão sob alta demanda.
As implantações contínuas substituem gradualmente a implantação anterior da versão do modelo pela nova versão, atualizando seu endpoint em tamanhos de lote configuráveis. O comportamento de mudança de tráfego das implantações contínuas é semelhante ao [modo de mudança de tráfego linear](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green-linear.html) nas blue/green implantações, mas as implantações contínuas oferecem o benefício de requisitos de capacidade reduzidos quando comparadas às implantações. blue/green Com implantações contínuas, um número menor de instâncias fica ativo ao mesmo tempo e você tem um controle mais granular sobre quantas instâncias você deseja atualizar na nova frota. Você deve considerar o uso de uma implantação contínua em vez de uma blue/green implantação se tiver modelos grandes ou um endpoint grande com muitas instâncias.
A lista a seguir descreve os principais recursos das implantações contínuas na Amazon SageMaker AI:
+ **Período de baking. **O período de incorporação é um período de tempo determinado para monitorar a nova frota antes de prosseguir para a próxima etapa de implantação. Se algum dos alarmes pré-especificados disparar durante qualquer período de incorporação, todo o tráfego do endpoint será revertido para a frota antiga. O período de incorporação ajuda você a adquirir confiança em sua atualização antes de tornar o deslocamento de tráfego permanente.
+ **Tamanho do lote contínuo.** Você tem controle granular sobre o tamanho de cada lote para o deslocamento de tráfego ou o número de instâncias que deseja atualizar em cada lote. Esse número pode variar de 5 a 50% do tamanho da sua frota. Você pode especificar o tamanho do lote como um número de instâncias ou como a porcentagem geral de sua frota.
+ **Reversão automática. **Você pode especificar CloudWatch os alarmes da Amazon que a SageMaker IA usa para monitorar a nova frota. Se um problema com o código atualizado acionar algum dos alarmes, a SageMaker IA iniciará uma reversão automática para a frota antiga a fim de manter a disponibilidade, minimizando assim o risco.
**nota**
Se seu endpoint usa quaisquer dos atributos listados na página [Exclusões](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html), você não pode usar implantações contínuas.
## Como funciona
Durante uma implantação contínua, a SageMaker IA fornece a infraestrutura para transferir o tráfego da frota antiga para a nova frota sem precisar provisionar todas as novas instâncias de uma só vez. SageMaker A IA usa as seguintes etapas para mudar o tráfego:
1. SageMaker A IA provisiona o primeiro lote de instâncias na nova frota.
1. Uma parte do tráfego é deslocada a partir das instâncias antigas para o primeiro lote de novas instâncias.
1. Após o período de cozimento, se nenhum CloudWatch alarme da Amazon for acionado, a SageMaker IA limpa um lote de instâncias antigas.
1. SageMaker A IA continua provisionando, transferindo e limpando instâncias em lotes até que a implantação seja concluída.
Se um alarme for disparado durante um dos períodos de incorporação, o tráfego será revertido para a frota antiga em lotes do tamanho especificado por você. Como alternativa, você pode especificar a implantação contínua para deslocar 100% do tráfego de volta para a frota antiga caso um alarme seja disparado.
O diagrama a seguir mostra a progressão de uma implantação contínua com êxito, conforme descrito nas etapas anteriores.
![\[As etapas de um deslocamento de tráfego de uma implantação contínua com êxito da frota anterior para a nova frota.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/deployment-guardrails-rolling-diagram.png)
Para criar uma implantação contínua, basta especificar a configuração de implantação desejada. Em seguida, a SageMaker IA gerencia o provisionamento de novas instâncias, o encerramento de instâncias antigas e a transferência de tráfego para você. Você pode criar e gerenciar sua implantação por meio da [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)e dos AWS Command Line Interface comandos existentes.
## Pré-requisitos
Antes de configurar uma implantação contínua, você deve criar CloudWatch alarmes da Amazon para monitorar as métricas do seu endpoint. Se qualquer alarme for disparado durante o período de incorporação, o tráfego começará a reverter para sua frota antiga. Para saber como configurar CloudWatch alarmes em um endpoint, consulte a página de pré-requisitos Configuração e monitoramento de reversão [automática](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-configuration.html). Para saber mais sobre CloudWatch alarmes, consulte Como [usar CloudWatch alarmes da Amazon no Guia CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) *do usuário da Amazon*.
Além disso, revise a página [Exclusões](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html) para garantir que seu endpoint atenda aos requisitos de uma implantação contínua.
## Determinar o tamanho do lote contínuo
Antes de atualizar seu endpoint, determine o tamanho do lote que você deseja usar para deslocar incrementalmente o tráfego para a nova frota.
Para implantações contínuas, você pode especificar um tamanho do lote que seja de 5 a 50% da capacidade da sua frota. Se você escolher um tamanho do lote grande, a implantação será concluída mais rapidamente. No entanto, lembre-se de que o endpoint requer mais capacidade durante a atualização, aproximadamente a sobrecarga do tamanho do lote. Se você escolher um tamanho do lote menor, a implantação demorará mais, mas você usará menos capacidade durante a implantação.
## Configurar uma implantação contínua
Quando estiver pronto para a implantação e configurar os CloudWatch alarmes para o endpoint, você poderá usar a [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API de SageMaker IA ou o comando [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) no para iniciar a AWS Command Line Interface implantação.
**Instrução para atualizar um endpoint**
O exemplo a seguir mostra como você pode atualizar seu endpoint com uma implantação contínua usando o método [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html) do cliente Boto3 AI. SageMaker
Para configurar a implantação contínua, use o exemplo e os campos a seguir.
+ Em `EndpointName`, use o nome do endpoint existente que você deseja atualizar.
+ Em `EndpointConfigName`, use o nome da configuração de endpoint que deseja usar.
+ No `AutoRollbackConfiguration` objeto, dentro do `Alarms` campo, você pode adicionar seus CloudWatch alarmes por nome. Crie uma entrada `AlarmName: ` para cada alarme que você deseja usar.
+ Em `DeploymentConfig`, para o objeto `RollingUpdatePolicy`, especifique os seguintes campos:
+ `MaximumExecutionTimeoutInSeconds`: O limite de tempo para a implantação total. Exceder esse limite causa um tempo limite. O valor máximo que você pode especificar para esse campo é 28800 segundos ou 8 horas.
+ `WaitIntervalInSeconds`— A duração do período de cozimento, durante o qual a SageMaker IA monitora os alarmes para cada lote da nova frota.
+ `MaximumBatchSize`: Especifique o `Type` do lote que você deseja usar (contagem de instâncias ou porcentagem geral da sua frota) e o `Value` ou o tamanho de cada lote.
+ `RollbackMaximumBatchSize`: Use este objeto para especificar a estratégia de reversão caso um alarme dispare. Especifique o `Type` do lote que você deseja usar (contagem de instâncias ou porcentagem geral da sua frota) e o `Value` ou o tamanho de cada lote. Se você não especificar esses campos ou definir o valor como 100% do seu endpoint, a SageMaker IA usa uma estratégia de blue/green reversão e reverte todo o tráfego para a frota antiga quando um alarme dispara.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
},
"RollingUpdatePolicy": {
"MaximumExecutionTimeoutInSeconds": number,
"WaitIntervalInSeconds": number,
"MaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
"RollbackMaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
}
}
)
```
Depois de atualizar seu endpoint, você pode verificar o status da sua implantação contínua e verificar a integridade do seu endpoint. Você pode revisar o status do seu endpoint no console de SageMaker IA ou pode revisar o status do seu endpoint usando a [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API.
No objeto `VariantStatus` retornado pela API `DescribeEndpoint`, o campo `Status` informa a implantação atual ou o status da operação do seu endpoint. Para obter mais informações sobre os possíveis status e o que eles significam, consulte [ProductionVariantStatus](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantStatus.html).
Se você tentou realizar uma implantação contínua e o status do seu endpoint é `UpdateRollbackFailed`, consulte a seção a seguir para obter ajuda na solução de problemas.
## Tratamento de falhas
Se houver falha nas implantações contínuas e na reversão automática, seu endpoint poderá ficar com o status de `UpdateRollbackFailed`. Esse status significa que diferentes configurações de endpoint foram implantadas nas instâncias por trás do seu endpoint e seu endpoint está em serviço com uma combinação de configurações de endpoint antigas e novas.
Você pode fazer outra chamada para a [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API para retornar seu endpoint a um estado íntegro. Especifique a configuração de endpoint e a configuração de implantação desejadas (como uma implantação contínua, uma implantação azul/verde ou nenhuma) para atualizar seu endpoint.
Você pode chamar a [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API para verificar novamente a integridade do seu endpoint, que é retornada no `VariantStatus` objeto como `Status` campo. Se sua atualização tiver êxito, o `Status` do endpoint retornará a `InService`.
# Exclusions
Ao fazer uma implantação azul/verde ou contínua, sua nova configuração de endpoint deve ter o mesmo nome de variante da configuração antiga do endpoint. Também há exclusões baseadas em atributos que tornam seu endpoint incompatível com as barreiras de proteção de implantação no momento. Se seu endpoint usa algum dos seguintes atributos, você não pode usar barreiras de proteção de implantação em seu endpoint, e seu endpoint voltará a usar uma implantação azul/verde com mudanças de tráfego de uma só vez e sem período final de cálculo:
+ Marketplace de contêineres
+ Endpoints que usam instâncias Inf1 (baseadas em inferência)
Se você estiver fazendo uma implantação contínua, há outras exclusões baseadas em atributos:
+ Endpoints de inferência sem servidor
+ Endpoints de inferência multivariante
# Testes de validação por comparação
Com o Amazon SageMaker AI, você pode avaliar qualquer alteração em sua infraestrutura de serviço de modelos comparando o respectivo desempenho com a infraestrutura implantada no momento. Essa prática é conhecida como teste de validação por comparação. Os testes de validação por comparação pode ajudar você a detectar possíveis erros de configuração e problemas de desempenho antes que eles afetem os usuários finais. Com o SageMaker AI, você não precisa investir na criação de sua infraestrutura de testes de validação por comparação para se concentrar no desenvolvimento de modelos.
Você pode usar esse recurso para validar alterações em qualquer componente de sua variante de produção, ou seja, o modelo, o contêiner ou a instância, sem nenhum impacto no usuário final. É útil em situações que incluem, mas não se limitam às seguintes:
+ Você está pensando em promover um novo modelo que foi validado offline para produção, mas deseja avaliar métricas de desempenho operacional, como latência e taxa de erro, antes de tomar essa decisão.
+ Você está considerando mudanças em seu contêiner de infraestrutura de serviço, como corrigir vulnerabilidades ou atualizar para versões mais recentes, e deseja avaliar o impacto dessas mudanças antes da promoção para a produção.
+ Você está pensando em mudar sua instância de ML e quer avaliar o desempenho da nova instância com solicitações de inferência em tempo real.
O console do SageMaker AI oferece uma experiência guiada para gerenciar o fluxo de trabalho dos testes de validação por comparação. Você pode configurar testes de validação por comparação por um período predefinido, monitorar o progresso do teste por meio de um painel ao vivo, limpar após a conclusão e agir de acordo com os resultados. Basta selecionar uma variante de produção com a qual você deseja testar que o SageMaker AI implanta automaticamente a nova variante no modo sombra e encaminha uma cópia das solicitações de inferência para ela, em tempo real, no mesmo endpoint. Somente as respostas da variante de produção são retornadas à aplicação de chamada. Você pode optar por descartar ou registrar as respostas da variante de sombra para comparação offline. Para obter mais informações sobre produção e variantes de sombra, consulte [Validação de modelos em produção](model-validation.md).
Para obter instruções sobre como criar um teste de validação por comparação, consulte [Criar um teste de validação por comparação](shadow-tests-create.md).
**nota**
Certos recursos de endpoint podem tornar seu endpoint incompatível com teste de validação por comparação. Se o endpoint usa algum dos seguintes atributos, não é possível usar testes de validação por comparação em seu endpoint, e a solicitação para configurar testes validação por comparação levará a erros de validação:
Inferência sem servidor
Inferência assíncrona
Marketplace de contêineres
Endpoints de vários contêineres
Endpoints multimodelo
Endpoints que usam instâncias Inf1 (baseadas em inferência)
# Criar um teste de validação por comparação
Você pode criar um teste de validação por comparação para comparar o desempenho de uma variante de sombra com uma variante de produção. Você pode executar o teste em um endpoint existente que esteja atendendo às solicitações de inferência ou criar um novo endpoint no qual executar o teste.
Para criar um teste de validação por comparação, você precisa especificar o seguinte:
+ Uma *variante de produção* que recebe e responde a 100% das solicitações de inferência recebidas.
+ Uma *variante paralela* que recebe uma porcentagem das solicitações recebidas, replicada da variante de produção, mas não retorna nenhuma resposta.
Para cada variante, você pode usar a SageMaker IA para controlar o modelo, o tipo de instância e a contagem de instâncias. Você pode configurar a porcentagem de solicitações recebidas, conhecida como porcentagem de amostragem de tráfego, que você deseja replicar para sua variante sombra. SageMaker A IA gerencia a replicação de solicitações para sua variante sombra e você pode modificar a porcentagem de amostragem de tráfego quando o teste está programado ou em execução. Opcionalmente, você também pode ativar a captura de dados para registrar solicitações e respostas de suas variantes de produção e sombra.
**nota**
SageMaker A IA suporta no máximo uma variante de sombra por endpoint. Para um endpoint com uma variante de sombra, pode haver no máximo uma variante de produção.
Você pode programar o teste para começar a qualquer momento e continuar por um período especificado. A duração padrão é de 7 dias e a máxima é de 30 dias. Depois que o teste for concluído, o endpoint volta ao estado em que estava antes de iniciar o teste. Isso garante que você não precise limpar manualmente os recursos após a conclusão do teste.
Você pode monitorar um teste que está sendo executado por meio de um painel no console de SageMaker IA. O painel fornece uma comparação lado a lado das métricas de invocação e métricas de instância entre as variantes de produção e sombra, além de uma visualização tabular com estatísticas métricas relevantes. Esse painel também está disponível para testes concluídos. Depois de analisar as métricas, você pode optar por promover a variante sombra como a nova variante de produção ou reter a variante de produção existente. Depois de promover a variante sombra, ela responde a todas as solicitações recebidas. Para obter mais informações, consulte [Promover uma variante de sombra](shadow-tests-complete.md#shadow-tests-complete-promote).
O procedimento a seguir descreve como criar um teste de sombra por meio do console de SageMaker IA. Há variações no fluxo de trabalho, dependendo se você deseja usar um endpoint existente ou criar um novo endpoint para o teste de validação por comparação.
**Topics**
+ [Pré-requisitos](#shadow-tests-create-prerequisites)
+ [Insira os detalhes do teste de validação por comparação](#shadow-tests-create-console-shadow-test-details)
+ [Insira as configurações do teste de validação por comparação](#shadow-tests-create-console-shadow-test-settings)
## Pré-requisitos
Antes de criar um teste de sombra com o console de SageMaker IA, você deve ter um modelo de SageMaker IA pronto para uso. Para obter mais informações sobre como criar um modelo de SageMaker IA, consulte[Implantar modelos para inferência em tempo real](realtime-endpoints-deploy-models.md).
Você pode começar com testes paralelos com um endpoint existente com uma variante de produção e uma variante sombra, um endpoint existente com apenas uma variante de produção ou apenas os modelos de SageMaker IA que você gostaria de comparar. Os testes paralelos permitem criar um endpoint e adicionar variantes antes do início do teste.
**nota**
Certos recursos de endpoint podem tornar seu endpoint incompatível com teste de validação por comparação. Se o endpoint usa algum dos seguintes atributos, não é possível usar testes de validação por comparação em seu endpoint, e a solicitação para configurar testes validação por comparação levará a erros de validação:
Inferência sem servidor
Inferência assíncrona
Marketplace de contêineres
Endpoints de vários contêineres
Endpoints multimodelo
Endpoints que usam instâncias Inf1 (baseadas em inferência)
## Insira os detalhes do teste de validação por comparação
Para começar a criar seu teste de validação por comparação, preencha a página **Inserir detalhes do teste de validação por comparação** fazendo o seguinte:
1. Abra o [console de SageMaker IA](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, escolha **Inferência** e, em seguida, escolha **teste de validação por comparação**.
1. Escolha **Criar teste de validação por comparação**.
1. Em **Nome**, insira um nome para o teste.
1. (Opcional) Em **Descrição**, insira uma descrição para o teste.
1. (Opcional) Especifique as **tags** usando pares de **chave** e **valor**.
1. Escolha **Próximo**.
## Insira as configurações do teste de validação por comparação
Depois de preencher a página **Inserir detalhes do teste de validação por comparação**, preencha a página **Inserir configurações do teste de validação por comparação**. Se você já tem um endpoint de inferência de SageMaker IA e uma variante de produção, siga o fluxo de trabalho **Usar um endpoint existente**. Se você ainda não tem uma de endpoint, siga o fluxo de trabalho **Criar uma de novo endpoint**.
------
#### [ Use an existing endpoint ]
Se você quiser usar um endpoint existente para seu teste, preencha a página **Inserir configurações do teste de validação por comparação** fazendo o seguinte:
1. Escolha a função que tem a política de IAM `AmazonSageMakerFullAccess` anexada.
1. Escolha **Usar um endpoint existente** e, em seguida, escolha um dos endpoints disponíveis.
1. (Opcional) Para criptografar o volume de armazenamento em seu endpoint, escolha uma chave KMS existente ou escolha **Inserir um ARN da chave KMS na lista** suspensa em **Chave de criptografia.** Se você escolher a segunda opção, um campo para inserir o ARN da chave KMS será exibido. Insira o ARN da chave KMS nesse campo.
1. Se você tiver várias variantes de produção por trás desse endpoint, remova as que não deseja usar para o teste. Você pode remover uma variante do modelo selecionando-a e, em seguida, escolhendo **Remover**.
1. Se ainda não tiver uma variante de sombra, adicione uma variante de sombra. Para adicionar uma variante de sombra, faça o seguinte:
1. Escolha **Adicionar**.
1. Escolha a **variante de sombra**.
1. Na caixa de diálogo **Adicionar modelo**, escolha o modelo que você deseja usar para sua variante de sombra.
1. Escolha **Salvar**.
1. (Opcional) Na etapa anterior, a variante de sombra é adicionada com as configurações padrão. Para modificar essas configurações, selecione a variante de sombra e escolha **Editar**. A caixa de diálogo **Editar variante de sombra** é exibida. Para obter mais informações sobre preenchimento dessa caixa de diálogo, consulte [Editar um teste de validação por comparação](shadow-tests-view-monitor-edit-individual.md).
1. Na seção **Programação**, insira a duração do teste fazendo o seguinte:
1. Escolha a caixa em **Duração**. É exibido um calendário pop-up.
1. Selecione as datas de início e término no calendário ou insira as datas de início e término nos campos **Data de início** e **Data de término**, respectivamente.
1. (Opcional) Para os campos **Hora de início** e **Hora de término**, insira as horas de início e término, respectivamente, no formato de 24 horas.
1. Escolha **Aplicar**.
A duração mínima é de 1 hora e a duração máxima é de 30 dias.
1. (Opcional) **Ative a captura de dados** para salvar as informações de solicitação e resposta de inferência do seu endpoint em um bucket do Amazon S3 e, em seguida, insira a localização do bucket do Amazon S3.
1. Escolha **Criar teste de validação por comparação**.
------
#### [ Create a new endpoint ]
Se não tiver um endpoint existente para seu teste ou quiser criar um novo endpoint para o seu teste, preencha a página **Inserir configurações do teste de validação por comparação** fazendo o seguinte:
1. Escolha a função que tem a política de IAM `AmazonSageMakerFullAccess` anexada.
1. Escolha **Criar um novo endpoint**.
1. Em **Tag de nome**, insira um nome para o endpoint.
1. Adicione uma variante de produção e uma variante de sombra ao endpoint:
+ Para adicionar uma variante de produção, escolha **Adicionar** e, em seguida, escolha **Variante de produção**. Na caixa de diálogo **Adicionar modelo**, escolha o modelo que deseja usar para sua variante de sombra e em seguida escolha **Salvar**.
+ Para adicionar uma variante de sombra, escolha **Adicionar** e, em seguida, escolha **Variante de sombra**. Na caixa de diálogo **Adicionar modelo**, escolha o modelo que deseja usar para sua variante de sombra e em seguida escolha **Salvar**.
1. (Opcional) Na etapa anterior, a variante de sombra é adicionada com as configurações padrão. Para modificar essas configurações, selecione a variante de sombra e escolha **Editar**. A caixa de diálogo **Editar variante de sombra** é exibida. Para obter mais informações sobre preenchimento dessa caixa de diálogo, consulte [Editar um teste de validação por comparação](shadow-tests-view-monitor-edit-individual.md).
1. Na seção **Programação**, insira a duração do teste fazendo o seguinte:
1. Escolha a caixa em **Duração**. É exibido um calendário pop-up.
1. Selecione as datas de início e término no calendário ou insira as datas de início e término em **Data de início** e **Data de término**, respectivamente.
1. (Opcional) Em **Hora de início** e **Hora de término**, insira as horas de início e término, respectivamente, no formato de 24 horas.
1. Escolha **Aplicar**.
A duração mínima é de 1 hora e a duração máxima é de 30 dias.
1. (Opcional) **Ative a captura de dados** para salvar as informações de solicitação e resposta de inferência do seu endpoint em um bucket do Amazon S3 e, em seguida, insira a localização do bucket do Amazon S3.
1. Escolha **Criar teste de validação por comparação**.
------
Depois de concluir os procedimentos anteriores, agora você deve ter um teste agendado para começar na data e hora de início especificadas. Você pode ver o progresso do teste em um painel. Para obter mais informações sobre visualização do teste e das ações que você pode realizar, consulte [Visualize, monitore e edite testes de validação por comparação](shadow-tests-view-monitor-edit.md).
# Visualize, monitore e edite testes de validação por comparação
Você pode visualizar o status dos seus testes paralelos, monitorar seu progresso em um painel e realizar ações, como iniciar ou interromper um teste mais cedo ou excluir um teste. Os tópicos a seguir mostram como você pode visualizar e modificar os testes de validação por comparação usando o console do SageMaker AI.
**Topics**
+ [Exibir testes de sombra](shadow-tests-view-monitor-edit-list.md)
+ [Monitorar um teste de validação por comparação](shadow-tests-view-monitor-edit-dashboard.md)
+ [Antecipe o início de um teste de validação por comparação](shadow-tests-view-monitor-edit-start.md)
+ [Excluir uma de teste de validação por comparação](shadow-tests-view-monitor-edit-delete.md)
+ [Editar um teste de validação por comparação](shadow-tests-view-monitor-edit-individual.md)
# Exibir testes de sombra
Você pode visualizar o status de todos os seus testes de validação por comparação na página **Testes de sombra** no console do SageMaker AI.
Para visualizar seus testes no console, faça o seguinte:
1. Abra o [console do SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação, escolha **Inferência**.
1. Escolha **Testes de sombra** para ver a página que lista todos os seus testes de sombra. A página deve ter a aparência da captura de tela a seguir, com todos os testes listados na seção **Testes de sombra**.
![\[Lista de todos os testes de sombra.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/juxtaposer/shadow-test-landing-page.png)
Você pode ver o status de um teste no console na página **Testes de sombra** verificando o campo **Status** do teste.
Os status de um teste possíveis são os seguintes:
+ `Creating`: o SageMaker AI está criando seu teste.
+ `Created`: o SageMaker AI terminou de criar seu teste e ele será iniciado no horário agendado.
+ `Updating`: Quando você faz alterações em seu teste, seu teste é exibido como atualização.
+ `Starting`: o SageMaker AI está iniciando seu teste.
+ `Running`: Seu teste está em andamento.
+ `Stopping`: o SageMaker AI está interrompendo seu teste.
+ `Completed`: Seu teste foi concluído.
+ `Cancelled`: Quando você conclui seu teste mais cedo, ele aparece como cancelado.
# Monitorar um teste de validação por comparação
Você pode ver os detalhes de um teste de validação por comparação e monitorá-lo enquanto ele está em andamento ou depois de concluído. O SageMaker AI apresenta um painel ao vivo comparando as métricas operacionais, como latência do modelo e taxa de erro agregada, das variantes de produção e sombra.
Para visualizar os detalhes de um teste individual no console do, faça o seguinte:
1. Selecione o teste que você deseja monitorar na seção **Teste de sombra** na página **Testes de sombra**.
1. Na lista suspensa **Ações**, escolha **Visualizar**. Uma página de visão geral com os detalhes do teste e um painel de métricas é exibida.
A página de visão geral tem as três seções a seguir.
**Resumo**
Esta seção resume o progresso e o status do teste. Também mostra as estatísticas resumidas da métrica escolhida na lista suspensa **Selecionar métrica** na subseção **Métricas**. A captura de tela a seguir mostra essa seção.
![\[Seção Resumo da página visão geral.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/juxtaposer/shadow-test-summary.png)
Na captura de tela anterior, as guias **Configurações** e **Detalhes** mostram as configurações que você selecionou e os detalhes que inseriu ao criar o teste.
**Análise**
Esta seção mostra um painel de métricas com gráficos separados das seguintes métricas:
+ `Invocations`
+ `InvocationsPerInstance`
+ `ModelLatency`
+ `Invocation4XXErrors`
+ `Invocation5XXErrors`
+ `InvocationModelErrors`
+ `CPUUtilization`
+ `MemoryUtilization`
+ `DiskUtilization`
As últimas três métricas monitoram o uso dos recursos de runtime do contêiner do modelo. O resto são métricas do CloudWatch que você pode usar para analisar o desempenho da sua variante. Em geral, menos erros indicam um modelo mais estável. Uma latência mais baixa indica um modelo mais rápido ou uma infraestrutura mais rápida. Para ter mais informações sobre métricas do CloudWatch, consulte [SageMaker Métricas de invocação de endpoints de IA](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation). A captura de tela a seguir mostra o painel de métricas.
![\[Painel de análise de métricas.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/juxtaposer/shadow-test-analysis.png)
**Environment**
Esta seção mostra as variantes que você comparou no teste. Se você estiver satisfeito com o desempenho da variante de sombra, com base nas métricas mencionadas acima, poderá promover a variante de sombra para produção escolhendo **Implantar variante de sombra**. Para obter mais detalhes sobre a implantação de uma variante de sombra, consulte [Promover uma variante de sombra](shadow-tests-complete.md#shadow-tests-complete-promote). Você também pode alterar a porcentagem de amostragem de tráfego e continuar testando quando escolhe **Editar tráfego**. Para obter mais detalhes sobre a edição de uma variante de sombra, consulte [Editar um teste de validação por comparação](shadow-tests-view-monitor-edit-individual.md). A captura de tela a seguir mostra essa seção.
![\[A página Visão geral do ambiente é exibida.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/juxtaposer/shadow-test-environment.png)
# Antecipe o início de um teste de validação por comparação
Você pode iniciar o teste antes do horário de início programado. Se a nova duração do teste ultrapassar trinta dias, o SageMaker AI definirá automaticamente o final do teste para trinta dias após o novo horário de início. Essa ação inicia o teste imediatamente. Se quiser alterar a hora de início ou término do teste, consulte [Editar um teste de validação por comparação](shadow-tests-view-monitor-edit-individual.md).
Para iniciar imediatamente o teste, antes do horário de início programado, por meio do console, faça o seguinte:
1. Selecione o teste que você deseja monitorar na seção **Teste de sombra** na página **Testes de sombra**.
1. Na lista suspensa **Ações**, escolha **Iniciar**. A caixa de diálogo **Iniciar teste de validação por comparação?** é exibida.
1. Escolha **Iniciar agora**.
# Excluir uma de teste de validação por comparação
Você pode excluir um teste do qual não precisa mais. Excluir seu teste exclui somente os metadados do teste e não seu endpoint, variantes ou dados capturados no Amazon S3. Se quiser que seu endpoint pare de funcionar, você deve excluí-lo. Para obter mais informações sobre um endpoint, consulte [Excluir endpoints e recursos](realtime-endpoints-delete-resources.md)
Para excluir um teste por meio do console, faça o seguinte:
1. Selecione o teste que você deseja excluir na seção **Teste de sombra**, na página **Testes de sombra**.
1. Na lista suspensa **Ações**, escolha **Excluir**. A caixa de diálogo **Excluir teste de validação por comparação** é exibida.
1. No campo **Para confirmar exclusão, digite *excluir* na caixa de texto** e digite **delete**.
1. Escolha **Excluir**.
# Editar um teste de validação por comparação
Você pode modificar os testes agendados e em andamento. Antes do início do teste, altere a descrição, a configuração da variante sombra, a data de início e a data de término do teste. Você também pode ativar ou desativar a captura de dados.
Após o início do teste, você só poderá alterar a descrição, a porcentagem de amostragem de tráfego para a variante sombra e a data de término.
Para editar os detalhes do seu teste por meio do console, faça o seguinte:
1. Selecione o teste que você deseja editar na seção **Teste de sombra**, na página **Testes de sombra**.
1. Na lista suspensa **Ações**, escolha **Editar**. A página **Inserir detalhes do teste de validação por comparação** é exibida.
1. (Opcional) Em **Descrição**, insira uma descrição do teste.
1. Escolha **Próximo**. A página **Inserir configurações do teste de validação por comparação** é exibida.
1. (Opcional) Para editar sua variante de sombra, faça o seguinte:
1. Selecione a variante de sombra e escolha **Editar**. A caixa de diálogo **Editar variante de sombra** é exibida. Se o teste já tiver começado, você só poderá alterar a porcentagem de amostragem de tráfego.
1. (Opcional) Em **Nome**, insira o novo nome para substituir o antigo.
1. (Opcional) Em **Amostra de tráfego**, insira a nova porcentagem de amostragem de tráfego para substituir a porcentagem de amostragem de tráfego antiga.
1. (Opcional) Em **Tipo de instância**, selecione o novo tipo de instância na lista suspensa.
1. (Opcional) Em **Contagem de instâncias**, insira a nova contagem de instâncias para substituir a contagem de instâncias antiga.
1. Escolha **Aplicar**.
Você não pode alterar o modelo em sua variante de sombra usando o procedimento acima. Se quiser alterar o modelo, primeiro remova a variante de sombra selecionando-a e escolhendo **Remover**. Em seguida, adicione uma nova variante de sombra.
1. (Opcional) Para editar a duração do teste, faça o seguinte:
1. Escolha a caixa em **Duração** na seção **Programação**. É exibido um calendário pop-up.
1. Se o teste ainda não começou, você pode alterar as datas de início e término. Selecione as novas datas de início e término no calendário ou insira as novas datas de início e término em **Data de início** e **Data de término**, respectivamente.
Se o teste já tiver começado, você só poderá alterar a data de término. Insira a nova data final em **Data final**.
1. (Opcional) Se o teste ainda não começou, você pode alterar os horários de início e término. Em **Hora de início** e **Hora de término**, insira as novas horas de início e término, respectivamente, no formato de 24 horas.
Se o teste já tiver começado, você só poderá alterar a hora de término. Insira a nova hora de término em **Hora de término**, no formato de 24 horas.
1. Escolha **Aplicar**.
1. (Opcional) Ativar ou desativar a opção **Ativar captura de dados**.
1. Escolha **Atualizar teste de validação por comparação**.
# Conclua um teste de sombra
Seu teste é concluído automaticamente no fim da duração programada, ou você pode interromper mais cedo um teste em andamento. Depois que o seu teste for concluído, o status do teste na seção **Testes de sombra** na página **Testes de sombra** será exibido como **Concluído**. Depois, você pode revisar e analisar as métricas finais do seu teste.
Você pode usar o painel de métricas para decidir se deseja promover a variante de sombra para produção. Para obter mais informações sobre como analisar o painel de métricas do seu teste, consulte [Monitorar um teste de validação por comparação](shadow-tests-view-monitor-edit-dashboard.md).
Para obter instruções sobre como concluir seu teste antes do fim do horário de conclusão programado, consulte [Antecipe a conclusão de um teste de sombra](#shadow-tests-complete-early).
Para obter instruções sobre como promover sua variante de sombra para produção, consulte [Promover uma variante de sombra](#shadow-tests-complete-promote).
## Antecipe a conclusão de um teste de sombra
Um dos motivos pelos quais você pode querer concluir um teste de sombra em andamento é se você decidiu que as métricas da sua variante de sombra parecem boas e deseja promovê-las para produção. Você também pode decidir concluir o teste se uma ou mais das variantes não tiverem boa performance.
Para concluir o seu teste antes da data de término programada, faça o seguinte:
1. Selecione o teste que você deseja marcar como concluído na seção **Teste de sombra**, na página **Testes de sombra**.
1. Na lista suspensa de **Ações**, escolha **Concluído** e a caixa de diálogo **Teste de sombra concluído** será exibida.
1. Na caixa de diálogo, escolha uma das seguintes opções:
+ **Sim, implantar variante de sombra**
+ **Não, remover variante de sombra**
1. (Opcional) Na caixa de texto **Comentário**, insira o seu motivo para concluir o teste antes do horário de término programado.
1.
1. Se você decidiu implantar a variante de sombra, escolha **Concluir e prosseguir com a implantação**. A página **Implantar variante de sombra** é exibida. Para obter instruções sobre como preencher essa página, consulte [Promover uma variante de sombra](#shadow-tests-complete-promote).
1. Se você decidir remover a variante de sombra, escolha **Confirmar**.
## Promover uma variante de sombra
Se você decidiu que deseja substituir sua variante de produção pela variante de sombra, você pode atualizar seu endpoint e promover sua variante de sombra para responder às solicitações de inferência. Isso remove da produção a sua variante em produção atual e a substitui pela sua variante de sombra.
Se o seu teste de sombra ainda estiver em andamento, você deve primeiro concluir seu teste. Para concluir o seu teste de sombra antes do final programado, siga as instruções em [Antecipe a conclusão de um teste de sombra](#shadow-tests-complete-early) antes de continuar com esta seção.
Ao promover uma variante de sombra para produção, você tem as seguintes opções para a contagem de instâncias da variante de sombra.
+ Você pode reter o tipo e a contagem de instâncias da variante de produção. Se você selecionar essa opção, sua variante de sombra será iniciada em produção com a contagem de instância atual, garantindo que seu modelo possa continuar processando solicitações de tráfego na mesma escala.
+ Você pode reter a contagem de instâncias e o tipo da sua variante de sombra. Se você quiser usar essa opção, recomendamos que você faça um teste de sombra com 100% de exemplo de tráfego para garantir que a variante de sombra possa processar o tráfego de solicitações na escala atual.
+ Você pode usar valores personalizados para o tipo e a contagem de instâncias. Se você quiser usar essa opção, recomendamos que você faça um teste de sombra com 100% de exemplo de tráfego para garantir que a variante de sombra possa processar o tráfego de solicitações na escala atual.
A menos que você esteja validando o tipo ou a contagem de instâncias da variante sombra, ou ambas, é altamente recomendável que você retenha o tipo e a contagem de instâncias da variante de produção ao promover sua variante de sombra.
Para promover a variante de sombra, faça o seguinte:
1. Se seu teste foi concluído, faça o seguinte:
1. Selecione o na seção **Teste de sombra** na página **Testes de sombra**.
1. Na lista suspensa de **Ações**, escolha **Visualizar**. O painel é exibido.
1. Escolha **Implantar variante de sombra** na seção **Ambiente**. A página **Implantar variante de sombra** é exibida.
Se o teste não tiver sido concluído, consulte [Antecipe a conclusão de um teste de sombra](#shadow-tests-complete-early) para concluir o teste.
1. Na seção **Configurações de variantes**, selecione uma das seguintes opções:
+ **Reter as configurações de produção**
+ **Reter configurações de sombra**
+ **Configurações de instância personalizadas**
Se você selecionou **Configurações de instância Custom**, faça o seguinte:
1. Selecione o tipo de instância na lista suspensa do **Tipo de instância**.
1. Em **Contagem de instâncias**, digite o número de instâncias.
1. Na caixa de texto **Inserir 'implantar' para confirmar a implantação**, insira **deploy**.
1. Escolha **Implantar variante de sombra**.
Seu endpoint do SageMaker AI Inference agora está usando a variante de sombra como sua variante de produção, e sua variante de produção foi removida do endpoint.
# Práticas recomendadas
Ao criar um experimento de inferência, lembre-se das seguintes informações:
+ **Porcentagem de amostragem de tráfego**: a amostragem de 100 por cento das solicitações de inferência permite validar se sua variante paralela pode lidar com o tráfego de produção quando promovida. Você pode começar com uma porcentagem menor de amostragem de tráfego e discar à medida que ganha confiança em sua variante, mas é uma prática recomendada garantir que você tenha aumentado o tráfego para 100% antes da promoção.
+ **Tipo de instância**: a menos que você esteja usando variantes de sombra para avaliar tipos ou tamanhos de instância alternativos, recomendamos que você use o mesmo tipo, tamanho e contagem de instâncias para ter certeza de que sua variante sombra pode lidar com o volume de solicitações de inferência depois de promovê-la.
+ **Ajuste de escala automático**: para garantir que sua variante de sombra possa responder a picos no número de solicitações de inferência ou mudanças nos padrões de solicitações de inferência, é altamente recomendável que você configure o ajuste de escala automático em suas variantes de sombra. Para saber como configurar upgrades automáticos, consulte [Escalabilidade automática dos modelos de SageMaker IA da Amazon](endpoint-auto-scaling.md). Se você configurou o escalonamento automático, também pode validar as alterações nas políticas de escalonamento automático sem causar impacto aos usuários.
+ **Monitoramento de métricas**: depois de iniciar um experimento paralelo e ter invocações suficientes, monitore o painel de métricas para garantir que as métricas, como latência e taxa de erro, estejam dentro dos limites aceitáveis. Isso ajuda você a detectar configurações incorretas mais cedo e a tomar medidas corretivas. Para obter informações sobre como monitorar as métricas de um experimento de inferência em andamento, consulte [Visualize, monitore e edite testes de validação por comparação](shadow-tests-view-monitor-edit.md).
# Acesso a contêineres por meio do SSM
A Amazon SageMaker AI permite que você se conecte com segurança aos contêineres do Docker nos quais seus modelos são implantados para inferência usando o Systems AWS Manager (SSM). Isso lhe dá acesso em nível de shell ao contêiner para que você possa depurar os processos em execução no contêiner e registrar comandos e respostas com a Amazon CloudWatch. Você também pode configurar uma AWS PrivateLink conexão com as instâncias de ML que hospedam seus contêineres para acessar os contêineres via SSM de forma privada.
**Atenção**
Habilitar o acesso SSM pode afetar a performance do seu endpoint. Recomendamos usar esse recurso com seus endpoints de teste ou desenvolvimento e não com os endpoints em produção. Além disso, a SageMaker IA aplica automaticamente os patches de segurança e substitui ou encerra instâncias de endpoint com defeito em 10 minutos. No entanto, para endpoints com variantes de produção habilitadas para SSM, a SageMaker IA atrasa a aplicação de patches de segurança e a substituição ou encerramento de instâncias de endpoint com defeito em um dia, para permitir a depuração.
As seções a seguir detalham como você pode usar esse recurso.
## Lista de permissões
Você precisa entrar em contato com o suporte ao cliente e obter sua conta na lista de permissões para usar esse recurso. Você não pode criar um endpoint com o acesso SSM habilitado, se sua conta não estiver na lista de permissões listadas para esse acesso.
## Habilitar acesso ao SSM
Para habilitar o acesso SSM a um contêiner existente em um endpoint, atualize o endpoint com uma nova configuração de endpoint, com o parâmetro `EnableSSMAccess` definido como `true`. O exemplo a seguir fornece um exemplo de configuração de endpoint.
```
{
"EndpointConfigName": "endpoint-config-name",
"ProductionVariants": [
{
"InitialInstanceCount": 1,
"InitialVariantWeight": 1.0,
"InstanceType": "ml.t2.medium",
"ModelName": model-name,
"VariantName": variant-name,
"EnableSSMAccess": true,
},
]
}
```
Para obter mais informações sobre como habilitar o acesso SSM, consulte [Habilitar SSMAccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html#API_EnableSSMAccess).
## Configuração do IAM
### Permissões do IAM do endpoint
Se você habilitou o acesso SSM para uma instância de endpoint, a SageMaker AI inicia e gerencia o [agente SSM](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html) quando inicia a instância de endpoint. Para permitir que o SSM Agent se comunique com os serviços do SSM, adicione a política a seguir ao perfil de execução sob a qual o endpoint é executado.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssmmessages:CreateControlChannel",
"ssmmessages:CreateDataChannel",
"ssmmessages:OpenControlChannel",
"ssmmessages:OpenDataChannel"
],
"Resource": "*"
}
]
}
```
------
### Permissões do IAM para usuários
Adicione a política a seguir para dar a um usuário do IAM permissões de sessão SSM para se conectar a um destino do SSM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession",
"ssm:TerminateSession"
],
"Resource": "*"
}
]
}
```
------
Você pode restringir os endpoints aos quais um usuário do IAM pode se conectar usando a política a seguir. Substitua *italicized placeholder text* por suas próprias informações.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession"
],
"Resource": "arn:aws:sagemaker:us-east-2:111122223333:endpoint/endpoint-name"
}
]
}
```
------
## Acesso SSM com AWS PrivateLink
Se seus endpoints são executados em uma nuvem privada virtual (VPC) que não está conectada à Internet pública, você pode AWS PrivateLink usar para habilitar o SSM. AWS PrivateLink restringe todo o tráfego de rede entre suas instâncias de endpoint, SSM e Amazon EC2 à rede Amazon. Para obter mais informações sobre como configurar o acesso ao SSM com AWS PrivateLink, consulte [Configurar uma VPC endpoint para o Gerenciador de Sessões](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started-privatelink.html).
## Registro com Amazon CloudWatch Logs
Para endpoints habilitados para acesso SSM, você pode registrar erros do agente SSM com o Amazon Logs. CloudWatch Para obter mais informações sobre como registrar erros com o CloudWatch Logs, consulte [Registrar a atividade da sessão](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-logging.html). O log está disponível no streaming de logs do SSM, `variant-name/ec2-instance-id/ssm`, no grupo de logs do endpoint `/aws/sagemaker/endpoints/endpoint-name`. Para obter mais informações sobre como visualizar o registro, consulte [Exibir dados de registro enviados para o CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData).
As variantes de produção por trás do seu endpoint podem ter vários modelos de contêineres. O log de cada contêiner modelo é registrado no streaming de logs. Cada log é precedido por `[sagemaker ssm logs][container-name]`, onde `container-name` é o nome que você deu ao contêiner ou o nome padrão, como `container_0` e `container_1`.
## Acesso a contêineres de modelos
Para acessar um contêiner de modelo em sua instância de endpoint, você precisa da ID de destino. A ID do destino está em um dos seguintes formatos:
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id` para contêineres em endpoints de contêiner único
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id_container-name` para contêineres em endpoints de contêineres múltiplos
O exemplo a seguir mostra como você pode usar o AWS CLI para acessar um contêiner de modelo usando seu ID de destino.
```
aws ssm start-session --target sagemaker-endpoint:prod-image-classifier_variant1_i-003a121c1b21a90a9_container_1
```
Se você ativar o registro, conforme mencionado em[Registro com Amazon CloudWatch Logs](#ssm-access-logging), poderá encontrar o destino de todos IDs os contêineres listados no início do fluxo de registros do SSM.
**nota**
Você não pode se conectar a contêineres de algoritmo 1P ou contêineres de modelos obtidos da SageMaker IA MarketPlace com SSM. No entanto, você pode se conectar aos contêineres de aprendizado profundo (DLCs) fornecidos por AWS ou a qualquer contêiner personalizado que você possua.
Se você ativou o isolamento de rede para um contêiner modelo que o impede de fazer chamadas de rede de saída, não será possível iniciar uma sessão do SSM para esse contêiner.
Você só pode acessar um contêiner de uma sessão do SSM. Para acessar outro contêiner, mesmo que ele esteja atrás do mesmo endpoint, inicie uma nova sessão de SSM com a ID de destino desse endpoint.
# Servidores de modelo para implantação de modelos com Amazon SageMaker AI
Você pode usar servidores de modelos populares TorchServe, como o DJL Serving e o Triton Inference Server, para implantar seus modelos na IA. SageMaker Os tópicos a seguir explicam como.
**Topics**
+ [Implemente modelos com TorchServe](deploy-models-frameworks-torchserve.md)
+ [Implante modelos com o DJL Serving](deploy-models-frameworks-djl-serving.md)
+ [Implantação de modelo com o servidor de inferência Triton](deploy-models-frameworks-triton.md)
# Implemente modelos com TorchServe
TorchServe é o servidor modelo recomendado para PyTorch, pré-instalado no AWS PyTorch Deep Learning Container (DLC). Essa ferramenta poderosa oferece aos clientes uma experiência consistente e fácil de usar, oferecendo alto desempenho na implantação de vários PyTorch modelos em várias AWS instâncias, incluindo CPU, GPU, Neuron e Graviton, independentemente do tamanho ou da distribuição do modelo.
TorchServe suporta uma ampla variedade de recursos avançados, incluindo batching dinâmico, microbatching, A/B teste de modelo, streaming, torch XLA, TensorRT, ONNX e IPEX. Além disso, ele integra perfeitamente a solução PyTorch de modelos grandes da PiPPy, permitindo o manuseio eficiente de modelos grandes. Além disso, TorchServe estende seu suporte a bibliotecas populares de código aberto DeepSpeed, como Accelerate, Fast Transformers e muito mais, expandindo ainda mais seus recursos. Com TorchServe, AWS os usuários podem implantar e servir seus PyTorch modelos com confiança, aproveitando sua versatilidade e desempenho otimizado em várias configurações de hardware e tipos de modelos. Para obter informações mais detalhadas, você pode consultar a [PyTorchdocumentação e assim TorchServe](https://pytorch.org/serve/) [por diante GitHub](https://github.com/pytorch/serve).
A tabela a seguir lista os AWS PyTorch DLCs suportados pelo TorchServe.
| Tipo de instância | SageMaker Link do PyTorch DLC AI |
| --- | --- |
| CPU e GPU | [SageMaker PyTorch Contêineres AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Recipientes de neurônios](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker Contêineres AI PyTorch Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
As seções a seguir descrevem a configuração para criar e testar PyTorch DLCs na Amazon SageMaker AI.
## Introdução
Para começar, verifique se você tem os seguintes pré-requisitos:
1. Certifique-se de ter acesso a uma AWS conta. Configure seu ambiente para que eles AWS CLI possam acessar sua conta por meio de um usuário AWS do IAM ou de uma função do IAM. Recomendamos usar uma perfil do IAM. Para fins de teste em sua conta pessoal, você pode anexar as seguintes políticas de permissões gerenciadas à perfil do IAM:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWS ServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. Configure localmente suas dependências, conforme mostrado no seguinte exemplo:
```
from datetime import datetime
import os
import json
import logging
import time
# External Dependencies:
import boto3
from botocore.exceptions import ClientError
import sagemaker
sess = boto3.Session()
sm = sess.client("sagemaker")
region = sess.region_name
account = boto3.client("sts").get_caller_identity().get("Account")
smsess = sagemaker.Session(boto_session=sess)
role = sagemaker.get_execution_role()
# Configuration:
bucket_name = smsess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}/models"
print(f"account={account}, region={region}, role={role}")
```
1. Recupere a imagem do PyTorch DLC, conforme mostrado no exemplo a seguir.
SageMaker As imagens de PyTorch DLC AI estão disponíveis em todas as AWS regiões. Para obter mais informações, consulte a [lista de imagens de contêineres do DLC](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only).
```
baseimage = sagemaker.image_uris.retrieve(
framework="pytorch",
region="",
py_version="py310",
image_scope="inference",
version="2.0.1",
instance_type="ml.g4dn.16xlarge",
)
```
1. Crie um espaço de trabalho local.
```
mkdir -p workspace/
```
## Adição de um pacote
As seções a seguir descrevem como adicionar e pré-instalar pacotes em sua imagem de PyTorch DLC.
**Casos de uso do BYOC**
As etapas a seguir descrevem como adicionar um pacote à sua imagem de PyTorch DLC. Para obter mais informações sobre como personalizar seu contêiner, consulte [Criação de imagens personalizadas de contêineres de AWS Deep Learning](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Suponha que você queira adicionar um pacote à imagem docker do PyTorch DLC. Crie um Dockerfile no diretório `docker`, conforme mostrado no seguinte exemplo:
```
mkdir -p workspace/docker
cat workspace/docker/Dockerfile
ARG BASE_IMAGE
FROM $BASE_IMAGE
#Install any additional libraries
RUN pip install transformers==4.28.1
```
1. Crie e publique a imagem do docker personalizada usando o script [ build\$1and\$1push.sh](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/docker/build_and_push.sh) a seguir.
```
# Download script build_and_push.sh to workspace/docker
ls workspace/docker
build_and_push.sh Dockerfile
# Build and publish your docker image
reponame = "torchserve"
versiontag = "demo-0.1"
./build_and_push.sh {reponame} {versiontag} {baseimage} {region} {account}
```
**SageMaker Casos de uso de pré-instalação de IA**
O exemplo a seguir mostra como pré-instalar um pacote em seu contêiner de PyTorch DLC. Você deve criar um arquivo `requirements.txt` localmente no diretório `workspace/code`.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Crie artefatos de TorchServe modelo
No exemplo a seguir, usamos o [ modelo MNIST](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist) pré-treinado. Criamos um diretório`workspace/mnist`, implementamos o [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) seguindo as [instruções de serviço TorchServe personalizadas](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) e [configuramos os parâmetros do modelo](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) (como tamanho do lote e trabalhadores) em [model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml). Em seguida, usamos a TorchServe ferramenta `torch-model-archiver` para criar os artefatos do modelo e fazer o upload para o Amazon S3.
1. Configure os parâmetros do modelo em `model-config.yaml`.
```
ls -al workspace/mnist-dev
mnist.py
mnist_handler.py
mnist_cnn.pt
model-config.yaml
# config the model
cat workspace/mnist-dev/model-config.yaml
minWorkers: 1
maxWorkers: 1
batchSize: 4
maxBatchDelay: 200
responseTimeout: 300
```
1. Crie os artefatos do modelo usando o. [torch-model-archiver ](https://github.com/pytorch/serve/tree/master/model-archiver#torch-model-archiver-for-torchserve)
```
torch-model-archiver --model-name mnist --version 1.0 --model-file workspace/mnist-dev/mnist.py --serialized-file workspace/mnist-dev/mnist_cnn.pt --handler workspace/mnist-dev/mnist_handler.py --config-file workspace/mnist-dev/model-config.yaml --archive-format tgz
```
Se quiser pré-instalar um pacote, você deve incluir o diretório `code` no arquivo `tar.gz`.
```
cd workspace
torch-model-archiver --model-name mnist --version 1.0 --model-file mnist-dev/mnist.py --serialized-file mnist-dev/mnist_cnn.pt --handler mnist-dev/mnist_handler.py --config-file mnist-dev/model-config.yaml --archive-format no-archive
cd mnist
mv ../code .
tar cvzf mnist.tar.gz .
```
1. Carregue `mnist.tar.gz` no Amazon S3.
```
# upload mnist.tar.gz to S3
output_path = f"s3://{bucket_name}/{prefix}/models"
aws s3 cp mnist.tar.gz {output_path}/mnist.tar.gz
```
## Usando endpoints de modelo único para implantar com TorchServe
[O exemplo a seguir mostra como criar um [único modelo de endpoint de inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html), implantar o modelo no endpoint e testar o endpoint usando o Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable/)
```
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
predictor_cls = Predictor,
name = "mnist",
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
predictor = model.deploy(instance_type='ml.g4dn.xlarge',
initial_instance_count=1,
endpoint_name = endpoint_name,
serializer=JSONSerializer(),
deserializer=JSONDeserializer())
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(dummy_data)
```
## Usando endpoints de vários modelos para implantar com TorchServe
Os [endpoints multimodelo](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) são uma solução escalável e econômica para a hospedagem de um grande número de modelos atrás de um endpoint. Eles melhoram a utilização do endpoint compartilhando a mesma frota de recursos e contêiner de serviço para hospedar todos os seus modelos. Eles também reduzem a sobrecarga de implantação porque a SageMaker IA gerencia dinamicamente o carregamento e o descarregamento de modelos, além de escalar os recursos com base nos padrões de tráfego. Os endpoints multimodelo são particularmente úteis para modelos de aprendizado profundo e IA generativa que exigem poder computacional acelerado.
Ao usar TorchServe endpoints multimodelo de SageMaker IA, você pode acelerar seu desenvolvimento usando uma pilha de serviços com a qual está familiarizado e, ao mesmo tempo, aproveitando o compartilhamento de recursos e o gerenciamento simplificado de modelos que os endpoints multimodelo de SageMaker IA fornecem.
[O exemplo a seguir mostra como criar um endpoint multimodelo, implantar o modelo no endpoint e testar o endpoint usando o SDK do Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable/) Detalhes adicionais podem ser encontrados neste [exemplo de caderno](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/torchserve_multi_model_endpoint.ipynb).
```
from sagemaker.multidatamodel import MultiDataModel
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
mme = MultiDataModel(
name = endpoint_name,
model_data_prefix = output_path,
model = model,
sagemaker_session = smsess)
mme.deploy(
initial_instance_count = 1,
instance_type = "ml.g4dn.xlarge",
serializer=sagemaker.serializers.JSONSerializer(),
deserializer=sagemaker.deserializers.JSONDeserializer())
# list models
list(mme.list_models())
# create mnist v2 model artifacts
cp mnist.tar.gz mnistv2.tar.gz
# add mnistv2
mme.add_model(mnistv2.tar.gz)
# list models
list(mme.list_models())
predictor = Predictor(endpoint_name=mme.endpoint_name, sagemaker_session=smsess)
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(date=dummy_data, target_model="mnist.tar.gz")
```
## Metrics
TorchServe suporta métricas no nível do sistema e no nível do modelo. Você pode ativar métricas no modo de formato de log ou no modo do Prometheus por meio da variável de ambiente `TS_METRICS_MODE`. Você pode usar o arquivo TorchServe central de configuração de métricas `metrics.yaml` para especificar os tipos de métricas a serem rastreadas, como contagem de solicitações, latência, uso de memória, utilização de GPU e muito mais. Ao consultar esse arquivo, você pode obter informações sobre o desempenho e a integridade dos modelos implantados e monitorar com eficácia o comportamento do TorchServe servidor em tempo real. Para obter informações mais detalhadas, consulte a [documentação de TorchServe métricas](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Você pode acessar registros de TorchServe métricas semelhantes ao formato StatsD por meio do filtro de CloudWatch registros da Amazon. Veja a seguir um exemplo de um registro de TorchServe métricas:
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```
# Implante modelos com o DJL Serving
O DJL Serving é uma solução de serviço de modelo autônoma universal de alto desempenho. Ele usa um modelo de aprendizado profundo, vários modelos ou fluxos de trabalho e os disponibiliza por meio de um endpoint HTTP.
Você pode usar um dos DJL Serving [Deep Learning Containers (DLCs)](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) para servir seus modelos em AWS. Para saber mais sobre os tipos de modelos e estruturas compatíveis, consulte o repositório [DJL Serving GitHub.](https://github.com/deepjavalibrary/djl-serving)
O DJL Serving oferece muitos atributos que ajudam você a implantar seus modelos com alto desempenho:
+ Facilidade de uso: O DJL Serving pode atender a maioria dos modelos sem nenhuma modificação. Você traz seus artefatos de modelo, e o DJL Serving pode hospedá-los.
+ Suporte a vários dispositivos e aceleradores — o DJL Serving oferece suporte à implantação de modelos em CPUs GPUs, e Inferentia. AWS
+ Desempenho: O DJL Serving executa inferência com muitos threads em uma única máquina virtual Java (JVM) para aumentar o throughput.
+ Lotes dinâmicos: O DJL Serving oferece apoio a lotes dinâmicos para aumentar o throughput.
+ Ajuste de escala automático: O DJL Serving escala automaticamente os operadores com base na carga de tráfego.
+ Suporte a vários mecanismos — o DJL Serving pode hospedar modelos simultaneamente usando estruturas diferentes (por exemplo, PyTorch e). TensorFlow
+ Modelos de conjunto e fluxo de trabalho — O DJL Serving oferece suporte à implantação de fluxos de trabalho complexos compostos por vários modelos e pode executar partes do fluxo de trabalho em e outras partes. CPUs GPUs Os modelos em um fluxo de trabalho podem aproveitar frameworks diferentes.
As seções a seguir descrevem como configurar um endpoint com o DJL Serving on SageMaker AI.
## Introdução
Para começar, verifique se você tem os seguintes pré-requisitos:
1. Certifique-se de ter acesso a uma AWS conta. Configure seu ambiente para que eles AWS CLI possam acessar sua conta por meio de um usuário AWS do IAM ou de uma função do IAM. Recomendamos usar uma perfil do IAM. Para fins de teste em sua conta pessoal, você pode anexar as seguintes políticas de permissões gerenciadas à perfil do IAM:
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. Verifique se o cliente [docker](https://docs.docker.com/get-docker/) está configurado em seu sistema.
1. Faça login no Amazon Elastic Container Registry e defina as seguintes variáveis de ambiente:
```
export ACCOUNT_ID=
export REGION=
aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com
```
1. Extraia a imagem do docker.
```
docker pull 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
```
Para ver todas as imagens de contêiner disponíveis do DJL Serving, consulte os [contêineres de inferência de modelos grandes](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) e os [contêineres de inferência de CPU do DJL Serving](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#djl-cpu-full-inference-containers). Ao escolher uma imagem das tabelas nos links anteriores, substitua a AWS região na coluna URL de exemplo pela região em que você está. Eles DLCs estão disponíveis nas regiões listadas na tabela na parte superior da página [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
## Personalize seu contêiner
Você pode adicionar pacotes às imagens base do DLC para personalizar seu contêiner. Suponha que você queira adicionar um pacote à imagem do docker `763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118`. Você deve criar um dockerfile com a imagem desejada como imagem base, adicionar os pacotes necessários e enviar a imagem para o Amazon ECR.
Para adicionar um pacote, conclua as seguintes etapas:
1. Especifique as instruções para executar as bibliotecas ou pacotes desejados no dockerfile da imagem base.
```
FROM 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
## add custom packages/libraries
RUN git clone https://github.com/awslabs/amazon-sagemaker-examples
```
1. Crie a imagem do Docker do seu dockerfile. Especifique seu repositório do Amazon ECR, o nome da imagem base e uma tag para a imagem. Se você não tiver um repositório do Amazon ECR, consulte [ Uso do Amazon ECR com a AWS CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html) no *Guia do usuário do Amazon ECR* para obter instruções sobre como criar um.
```
docker build -f Dockerfile -t /:
```
1. Envie a imagem do Docker para o seu repositório do Amazon ECR.
```
docker push $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/:
```
Agora você deve ter uma imagem de contêiner personalizada para poder usar para o serviço de modelo. Para ver mais exemplos de personalização do seu contêiner, consulte [Criação de imagens personalizadas de contêineres de AWS Deep Learning](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
## Prepare seus artefatos de modelo
Antes de implantar seu modelo na SageMaker IA, você deve empacotar os artefatos do modelo em um `.tar.gz` arquivo. O DJL Serving aceita os seguintes artefatos em seu arquivo:
+ Ponto de verificação do modelo: Arquivos que armazenam os pesos do modelo.
+ `serving.properties`: Um arquivo de configuração que você pode adicionar para cada modelo. Coloque `serving.properties` no mesmo diretório do seu arquivo do modelo.
+ `model.py`: O código do manipulador de inferência. Isso só é aplicável ao usar o modo Python. Se você não especificar `model.py`, djl-serving usará um dos manipuladores padrão.
Veja a seguir um exemplo de uma estrutura de `model.tar.gz`.
```
- model_root_dir # root directory
- serving.properties
- model.py # your custom handler file for Python, if you choose not to use the default handlers provided by DJL Serving
- model binary files # used for Java mode, or if you don't want to use option.model_id and option.s3_url for Python mode
```
O DJL Serving oferece apoio a mecanismos do Java baseados em mecanismos do DJL ou Python. Nem todos os artefatos anteriores são necessários; os artefatos necessários variam de acordo com o modo escolhido. Por exemplo, no modo Python, você só precisa especificar `option.model_id` no arquivo `serving.properties`; você não precisa especificar o ponto de verificação do modelo dentro dos contêineres para LMI. No modo Java, é necessário empacotar o ponto de verificação do modelo. Para obter mais detalhes sobre como configurar `serving.properties` e operar com mecanismos diferentes, consulte [Modos de operação do DJL Serving](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md).
## Use endpoints de modelo único para implantar com o DJL Serving
Depois de preparar seus artefatos de modelo, você pode implantar seu modelo em um endpoint de SageMaker IA. Esta seção descreve como implantar um modelo único em um endpoint com o DJL Serving. Se você estiver implantando vários modelos, pule esta seção e acesse [Use endpoints multimodelo para implantar com o DJL Serving](#deploy-models-frameworks-djl-mme).
O exemplo a seguir mostra um método para criar um objeto de modelo usando o SDK do Amazon SageMaker Python. Você precisará especificar os seguintes campos:
+ `image_uri`: Você pode recuperar uma das imagens base do DJL Serving, conforme mostrado neste exemplo, ou pode especificar uma imagem do Docker personalizada do seu repositório Amazon ECR, se tiver seguido as instruções em [Personalize seu contêiner](#deploy-models-frameworks-djl-byoc).
+ `model_s3_url`: Isso deve ser um URI do Amazon S3 que aponta para seu arquivo `.tar.gz`.
+ `model_name`: Especifique um nome para o objeto do modelo.
```
import boto3
import sagemaker
from sagemaker.model import Model
from sagemaker import image_uris, get_execution_role
aws_region = "aws-region"
sagemaker_session = sagemaker.Session(boto_session=boto3.Session(region_name=aws_region))
role = get_execution_role()
def create_model(model_name, model_s3_url):
# Get the DJL DeepSpeed image uri
image_uri = image_uris.retrieve(
framework="djl-deepspeed",
region=sagemaker_session.boto_session.region_name,
version="0.20.0"
)
model = Model(
image_uri=image_uri,
model_data=model_s3_url,
role=role,
name=model_name,
sagemaker_session=sagemaker_session,
)
return model
```
## Use endpoints multimodelo para implantar com o DJL Serving
Se você quiser implantar vários modelos em um endpoint, a SageMaker IA oferece endpoints multimodelo, que são uma solução escalável e econômica para a implantação de um grande número de modelos. O DJL Serving também oferece apoio para o carregamento de vários modelos simultaneamente e a execução de inferência em cada um dos modelos simultaneamente. Os contêineres do DJL Serving aderem aos contratos de endpoints multimodelo de SageMaker IA e podem ser usados para implantar endpoints multimodelo.
Cada artefato de modelo individual precisa ser empacotado da mesma forma descrita na seção anterior [Prepare seus artefatos de modelo](#deploy-models-frameworks-djl-artifacts). Você pode definir as configurações específicas do modelo no arquivo `serving.properties` e o código do manipulador de inferência específico do modelo em `model.py`. Para um endpoint multimodelo, os modelos precisam ser organizados da seguinte maneira:
```
root_dir
|-- model_1.tar.gz
|-- model_2.tar.gz
|-- model_3.tar.gz
.
.
.
```
O Amazon SageMaker Python SDK usa o [MultiDataModel](https://sagemaker.readthedocs.io/en/stable/api/inference/multi_data_model.html)objeto para instanciar um endpoint multimodelo. O URI do Amazon S3 para o diretório raiz deve ser passado como o argumento `model_data_prefix` para o construtor `MultiDataModel`.
O DJL Serving também fornece vários parâmetros de configuração para gerenciar os requisitos de memória do modelo, como `required_memory_mb` e `reserved_memory_mb`, que podem ser configurados para cada modelo no arquivo [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties). Esses parâmetros são úteis para lidar com erros de falta de memória com mais facilidade. Para todos os parâmetros configuráveis, consulte [OutofMemory manipulação em djl-serving](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/out_of_memory_management.md).
O atributo de ajuste de escala automático do DJL Serving facilita a garantia de que os modelos sejam escalados adequadamente para o tráfego de entrada. Por padrão, o DJL Serving determina o número máximo de operadores para um modelo que pode ser compatível com base no hardware disponível (como núcleos de CPU ou dispositivos de GPU). Você pode definir limites inferiores e superiores para cada modelo para garantir que um nível mínimo de tráfego sempre possa ser atendido, e que um único modelo não consuma todos os recursos disponíveis. Você pode definir as seguintes propriedades no arquivo [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties):
+ `gpu.minWorkers`: Número mínimo de trabalhadores para GPUs.
+ `gpu.maxWorkers`: Número máximo de trabalhadores para GPUs.
+ `cpu.minWorkers`: Número mínimo de trabalhadores para CPUs.
+ `cpu.maxWorkers`: Número máximo de trabalhadores para CPUs.
[Para ver um end-to-end exemplo de como implantar um endpoint multimodelo na SageMaker IA usando um contêiner DJL Serving, consulte o exemplo de notebook Multi-Model-Inference-Demo.ipynb.](https://github.com/deepjavalibrary/djl-demo/blob/master/aws/sagemaker/Multi-Model-Inference-Demo.ipynb)
# Implantação de modelo com o servidor de inferência Triton
O [servidor de inferência Triton](https://github.com/triton-inference-server/server) é um software de serviço de inferência de código aberto que simplifica a inferência de IA. Com o Triton, você pode implantar qualquer modelo criado com várias estruturas de aprendizado profundo e de aprendizado de máquina, incluindo TensorRT,,, PyTorch ONNX, OpenVINO TensorFlow, Python, RAPIDS FIL e muito mais.
Os contêineres SageMaker AI Triton ajudam você a implantar o Triton Inference Server na plataforma SageMaker AI Hosting para oferecer modelos treinados em produção. Ele suporta os diferentes modos em que a SageMaker IA opera. Para obter uma lista dos contêineres do Triton Inference Server disponíveis na SageMaker IA, consulte Contêineres de [inferência NVIDIA Triton (somente suporte para SM](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)).
Para exemplos de end-to-end notebooks, recomendamos dar uma olhada no [amazon-sagemaker-examples repositório.](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-triton)
## Modos de hospedagem
Os seguintes modos de hospedagem de SageMaker IA são compatíveis com os contêineres Triton:
+ Endpoints de modelo único
+ Esse é o modo de operação padrão da SageMaker IA. Nesse modo, o contêiner do Triton pode carregar um modelo único ou um modelo único de conjunto.
+ O nome do modelo deve ser passado como uma propriedade do ambiente de contêiner, que faz parte da chamada da API de `CreateModel` SageMaker IA. A variável de ambiente usada para passar o nome do modelo é `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`.
+ Endpoints de modelo único com conjunto
+ O servidor de inferência Triton é compatível com um *conjunto*, que é um pipeline ou um DAG (gráfico acíclico direcionado) de modelos. Embora um conjunto seja tecnicamente composto por vários modelos, no modo de endpoint de modelo único padrão, a SageMaker IA pode tratar o *conjunto adequado* (o metamodelo que representa o pipeline) como o modelo principal a ser carregado e, posteriormente, carregar os modelos associados.
+ O nome do modelo do conjunto propriamente dito deve ser usado para carregar o modelo. Ele deve ser passado como uma propriedade do ambiente do contêiner, que faz parte da chamada da `CreateModel` SageMaker API. A variável de ambiente usada para passar o nome do modelo é `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`.
+ Endpoints multimodelo
+ Nesse modo, a SageMaker IA pode servir vários modelos em um único endpoint. Você pode usar esse modo especificando a variável de ambiente `‘MultiModel’: true` como uma propriedade do ambiente do contêiner, que faz parte da chamada da `CreateModel` SageMaker API.
+ Por padrão, nenhum modelo é carregado quando a instância é iniciada. Para executar uma solicitação de inferência em um modelo específico, especifique o `*.tar.gz` arquivo do modelo correspondente como um argumento para a `TargetModel` propriedade da chamada da `InvokeEndpoint` SageMaker API.
+ Endpoints multimodelo com conjunto
+ Nesse modo, a SageMaker IA funciona conforme descrito para endpoints de vários modelos. No entanto, o contêiner SageMaker AI Triton pode carregar vários modelos de conjunto, o que significa que vários pipelines de modelos podem ser executados na mesma instância. SageMaker A IA trata cada conjunto como um modelo, e o conjunto próprio de cada modelo pode ser invocado especificando o arquivo correspondente como o. `*.tar.gz` `TargetModel`
+ Para um melhor gerenciamento de memória durante a memória dinâmica `LOAD` e `UNLOAD`, recomendamos que você mantenha o tamanho do conjunto pequeno.
## Tipos de carga útil de inferência
O Triton oferece aceita dois métodos de envio de uma carga útil de inferência pela rede: `json` e `binary+json` (ou json codificado em binário). A carga útil JSON em ambos os casos inclui o tipo de dados, a forma e o tensor real da solicitação de inferência. O tensor da solicitação deve ser um tensor binário.
Com o formato `binary+json`, você deve especificar o tamanho dos metadados da solicitação no cabeçalho para permitir que o Triton analise corretamente a carga útil binária. No contêiner SageMaker AI Triton, isso é feito usando um `Content-Type` cabeçalho personalizado:`application/vnd.sagemaker-triton.binary+json;json-header-size={}`. Isso é diferente de usar o `Inference-Header-Content-Length` cabeçalho em um servidor de inferência Triton autônomo porque cabeçalhos personalizados não são permitidos na IA. SageMaker
## Uso de config.pbtxt para definir a configuração do modelo
Para servidores de inferência Triton em SageMaker IA, cada modelo deve incluir um `config.pbtxt` arquivo que especifique, no mínimo, as seguintes configurações para o modelo:
+ `name`: Embora isso seja opcional para modelos executados fora da SageMaker IA, recomendamos que você sempre forneça um nome para os modelos a serem executados no Triton on SageMaker AI.
+ [`platform` e/ou `backend`](https://github.com/triton-inference-server/backend/blob/main/README.md#backends): Configurar um backend é essencial para especificar o tipo do modelo. Alguns backends têm classificação adicional, como `tensorflow_savedmodel` ou ` tensorflow_graphdef`. Essas opções podem ser especificadas como parte da chave `platform`, além da chave `backend`. Os backends mais comuns são `tensorrt`, `onnxruntime`, `tensorflow`, `pytorch`, `python`, `dali`, `fil` e `openvino`.
+ `input`: Especifique três atributos para a entrada: `name`, `data_type` e `dims` (a forma).
+ `output`: Especifique três atributos para a saída: `name`, `data_type` e `dims` (a forma).
+ `max_batch_size`: Defina o tamanho do lote para um valor maior ou igual a 1 que indica o tamanho máximo do lote que o Triton deve usar com o modelo.
[Para obter mais detalhes sobre a configuração`config.pbtxt`, consulte o repositório do GitHub Triton.](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md) O Triton fornece várias configurações para ajustar o comportamento do modelo. Algumas das opções de configuração mais comuns e importantes são:
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups): Os grupos de instâncias ajudam a especificar o número e a localização de um determinado modelo. Eles têm os atributos `count`, `kind` e `gpus` (usados quando `kind` é `KIND_GPU`). O atributo `count` é equivalente ao número de operadores. Para um serviço de modelo regular, cada operador tem a sua própria cópia do modelo. Da mesma forma, no Triton, `count` especifica o número de cópias do modelo por dispositivo. Por exemplo, se o tipo `instance_group` for `KIND_CPU`, a CPU terá `count` cópias do modelo.
**nota**
Em uma instância de GPU, a configuração `instance_group` se aplica a cada dispositivo de GPU. Por exemplo, `count` cópias do modelo são colocadas em cada dispositivo de GPU, a menos que você especifique explicitamente quais dispositivos de GPU devem carregar o modelo.
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher) e [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models): O lote dinâmico é usado para modelos sem estado, e o lote de sequência é usado para modelos com estado (onde você deseja rotear uma solicitação para a mesma instância do modelo todas as vezes). Os agendadores de lotes habilitam uma fila por modelo, o que ajuda a aumentar o throughput, dependendo da configuração dos lotes.
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models): Um modelo de conjunto representa um *pipeline* de um ou mais modelos e a conexão dos tensores de entrada e saída entre esses modelos. Ele pode ser configurado especificando `platform` como `ensemble`. A configuração do conjunto é apenas uma representação do pipeline do modelo. Na SageMaker IA, todos os modelos em um conjunto são tratados como dependentes do modelo de conjunto e são contados como um único modelo para métricas de SageMaker IA, como. `LoadedModelCount`
## Publicação de métricas padrão do Triton na Amazon CloudWatch
O NVIDIA Triton Inference Container expõe métricas na porta 8002 (configurável) para os diferentes modelos e GPUs que são utilizadas no Triton Inference Server. Para obter detalhes completos das métricas padrão que estão disponíveis, consulte a GitHub página das métricas do [Triton Inference Server](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/metrics.md). Essas métricas estão no formato do Prometheus e podem ser copiadas usando uma configuração de extração do Prometheus.
A partir da versão v23.07, o contêiner SageMaker AI Triton suporta a publicação dessas métricas na Amazon CloudWatch especificando algumas variáveis de ambiente. Para extrair as métricas do Prometheus, o contêiner AI SageMaker Triton usa o agente da Amazon. CloudWatch
As variáveis de ambiente necessárias que você deve especificar para coletar métricas são as seguintes:
| Variável de ambiente | Description | Valor de exemplo |
| --- | --- | --- |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | Especifique esta opção para permitir que o Triton publique métricas em seu endpoint do Prometheus. | "true" |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | Especifique essa opção para iniciar as pré-verificações necessárias para publicar métricas na Amazon CloudWatch. | "true" |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Especifique esta opção para apontar para o grupo de logs no qual as métricas são gravadas. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesTest" |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Especifique esta opção para apontar para o namespace da métrica em que você deseja ver e plotar as métricas. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesPublicTest" |
| `SAGEMAKER_TRITON_METRICS_PORT` | Especifique isto como 8002 ou qualquer outra porta. Se a SageMaker IA não tiver bloqueado a porta especificada, ela será usada. Caso contrário, outra porta não bloqueada será escolhida automaticamente. | "8002" |
Ao publicar métricas com o Triton on SageMaker AI, tenha em mente as seguintes limitações:
+ Embora você possa gerar métricas personalizadas por meio do back-end C-API e Python (v23.05 em diante), elas atualmente não são suportadas para publicação na Amazon. CloudWatch
+ No modo de endpoints multimodelo (MME) de SageMaker IA, o Triton é executado em um ambiente que exige que o namespace do modelo seja ativado porque cada modelo (exceto os modelos de conjunto) é tratado como se estivesse em seu próprio repositório de modelos. No momento, isso cria uma limitação para as métricas. Quando o namespacing de modelo está ativado, o Triton não distingue as métricas entre dois modelos com o mesmo nome pertencentes a conjuntos diferentes. Como solução alternativa, verifique se cada modelo que está sendo implantado tem um nome exclusivo. Isso também facilita a consulta de suas métricas em CloudWatch.
## Variáveis de ambiente
A tabela a seguir lista as variáveis de ambiente suportadas pelo Triton on SageMaker AI.
| Variável de ambiente | Description | Tipo | Possíveis valores |
| --- | --- | --- | --- |
| `SAGEMAKER_MULTI_MODEL` | Permite que o Triton opere no modo de endpoints multimodelo SageMaker AI. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME` | Especifique o modelo a ser carregado no modo de modelo único SageMaker AI (padrão). Para o modo de conjunto, especifique o nome do conjunto propriamente dito. | String | **conforme especificado em config.pbtxt |
| `SAGEMAKER_TRITON_PING_MODE` | `'ready'`é o modo padrão no modo de modelo único da SageMaker IA e `'live'` é o padrão no modo de endpoints multimodelo da SageMaker IA. | String | `ready`, `live` |
| `SAGEMAKER_TRITON_DISABLE_MODEL_NAMESPACING` | No contêiner SageMaker AI Triton, isso é definido como `true` padrão. | Booleano | `true`, `false` |
| `SAGEMAKER_BIND_TO_PORT` | Enquanto estiver na SageMaker IA, a porta padrão é 8080. Você pode personalizar para uma porta diferente em cenários de vários contêineres. | String | ** |
| `SAGEMAKER_SAFE_PORT_RANGE` | Isso é definido pela plataforma de SageMaker IA ao usar o modo de vários contêineres. | String | **–** |
| `SAGEMAKER_TRITON_ALLOW_GRPC` | Embora a SageMaker IA não ofereça suporte ao GRPC atualmente, se você estiver usando o Triton na frente de um proxy reverso personalizado, poderá optar por habilitar o GRPC. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_GRPC_PORT` | A porta padrão para o GRPC é 8001, mas você pode alterá-la. | String | ** |
| `SAGEMAKER_TRITON_THREAD_COUNT` | Você pode definir o número de threads padrão do manipulador de solicitações HTTP. | String | ** |
| `SAGEMAKER_TRITON_LOG_VERBOSE` | `true`por padrão no SageMaker AI, mas você pode desativar essa opção seletivamente. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_INFO` | `false`por padrão na SageMaker IA. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_WARNING` | `false`por padrão na SageMaker IA. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_ERROR` | `false`por padrão na SageMaker IA. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_SHM_DEFAULT_BYTE_SIZE` | Especifique o tamanho de shm para o backend do Python, em bytes. O valor padrão é 16 MB, mas pode ser aumentado. | String | ** |
| `SAGEMAKER_TRITON_SHM_GROWTH_BYTE_SIZE` | Especifique o tamanho de crescimento de shm para o backend do Python, em bytes. O valor padrão é 1 MB, mas pode ser aumentado para permitir maiores incrementos. | String | ** |
| `SAGEMAKER_TRITON_TENSORFLOW_VERSION` | O valor padrão é `2`. O Triton não oferece mais compatibilidade com o Tensorflow 2 no Triton v23.04. É possível configurar essa variável para as versões anteriores. | String | ** |
| `SAGEMAKER_TRITON_MODEL_LOAD_GPU_LIMIT` | Restrinja a porcentagem máxima de memória da GPU usada para carregamento do modelo, permitindo que o restante seja usado para as solicitações de inferência. | String | ** |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | `false`por padrão na SageMaker IA. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_METRICS_PORT` | A porta padrão é 8002. | String | ** |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | `false`por padrão na SageMaker IA. Defina essa variável `true` para permitir o envio das métricas padrão do Triton para a Amazon. CloudWatch Se essa opção estiver ativada, você será responsável pelos CloudWatch custos quando as métricas forem publicadas em sua conta. | Booleano | `true`, `false` |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Obrigatório se você ativou a publicação de métricas em CloudWatch. | String | ** |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Obrigatório se você ativou a publicação de métricas em CloudWatch. | String | ** |
| `SAGEMAKER_TRITON_ADDITIONAL_ARGS` | Acrescenta quaisquer argumentos adicionais ao iniciar o servidor Triton. | String | ** |
# Implantação de modelos na borda com o SageMaker Edge Manager
**Atenção**
SageMaker O Edge Manager será descontinuado em 26 de abril de 2024. Para obter mais informações sobre como continuar a implantar seus modelos em dispositivos de borda, consulte [SageMaker Fim da vida útil do Edge Manager](edge-eol.md).
O Amazon SageMaker Edge Manager fornece gerenciamento de modelos para dispositivos de ponta para que você possa otimizar, proteger, monitorar e manter modelos de aprendizado de máquina em frotas de dispositivos de ponta, como câmeras inteligentes, robôs, computadores pessoais e dispositivos móveis.
## Por que usar o Edge Manager?
Muitos casos de uso de machine learning (ML) exigem a execução de modelos de ML em uma frota de dispositivos de borda, o que permite obter predições em tempo real, preservar a privacidade dos usuários finais e reduzir o custo da conectividade de rede. Com a crescente disponibilidade de hardware de borda de baixa potência projetado para machine learning, agora é possível executar vários modelos complexos de redes neurais em dispositivos de borda.
No entanto, operar modelos de ML em dispositivos de borda é um desafio, porque os dispositivos, diferentemente das instâncias de nuvem, têm computação, memória e conectividade limitadas. Depois que o modelo for implantado, você precisa monitorar continuamente os modelos, pois o desvio do modelo pode fazer com que a qualidade do modelo diminua com o tempo. Monitorar modelos em toda a sua frota de dispositivos é difícil porque você precisa escrever código personalizado para coletar amostras de dados do seu dispositivo e identificar divergências nas predições. Além disso, os modelos muitas vezes são codificados diretamente na aplicação. Para atualizar o modelo, é necessário reconstruir e atualizar toda a aplicação ou firmware do dispositivo, o que pode causar interrupções nas operações.
Com o SageMaker Edge Manager, você pode otimizar, executar, monitorar e atualizar modelos de aprendizado de máquina em frotas de dispositivos na borda.
## Como funciona?
Em um alto nível, há cinco componentes principais no fluxo de trabalho do SageMaker Edge Manager: compilação de modelos com SageMaker o Neo, empacotamento de modelos compilados pelo Neo, implantação de modelos em seus dispositivos, execução de modelos no mecanismo de inferência de SageMaker IA (agente do Edge Manager) e manutenção de modelos nos dispositivos.
![\[Os cinco componentes principais no fluxo de trabalho do SageMaker Edge Manager.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/smith/smith_overview.png)
SageMaker O Edge Manager usa SageMaker o Neo para otimizar seus modelos para o hardware de destino em um clique e, em seguida, para assinar criptograficamente seus modelos antes da implantação. Usando o SageMaker Edge Manager, você pode obter amostras de dados de entrada e saída do modelo de dispositivos de borda e enviá-los para a nuvem para monitoramento e análise, além de visualizar um painel que rastreia e relata visualmente a operação dos modelos implantados no console de SageMaker IA.
SageMaker O Edge Manager estende recursos que antes só estavam disponíveis na nuvem até a borda, para que os desenvolvedores possam melhorar continuamente a qualidade do modelo usando o Amazon SageMaker Model Monitor para detecção de desvios, depois renomear os dados com o SageMaker AI Ground Truth e retreinar os modelos em IA. SageMaker
## Como faço para usar o SageMaker Edge Manager?
Se você for um usuário iniciante do SageMaker Edge Manager, recomendamos que você faça o seguinte:
1. **Leia a seção [Introdução](https://docs.aws.amazon.com/sagemaker/latest/dg/edge-manager-getting-started.html)** - Esta seção explica como configurar seu primeiro trabalho de empacotamento de borda e criar sua primeira frota.
1. **Explore exemplos de cadernos Jupyter do Edge Manager - Os notebooks** [de exemplo são armazenados no [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) GitHub repositório na pasta sagemaker\$1edge\$1manager.](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker_edge_manager)
# Primeiros passos com o Amazon SageMaker AI Edge Manager
Este guia demonstra como concluir as etapas necessárias para registrar, implantar e gerenciar uma frota de dispositivos e como atender aos pré-requisitos do Amazon SageMaker AI Edge Manager.
**Topics**
+ [Configuração](edge-getting-started-step1.md)
+ [Prepare o modelo para implantação](edge-getting-started-step2.md)
+ [Registre e autentique sua frota de dispositivos](edge-getting-started-step3.md)
+ [Baixe e configure o Edge Manager](edge-getting-started-step4.md)
+ [Execute o agente](edge-getting-started-step5.md)
# Configuração
Antes de começar a usar o SageMaker Edge Manager para gerenciar modelos em suas frotas de dispositivos, você deve primeiro criar funções do IAM para SageMaker IA e. AWS IoT Você também desejará criar pelo menos um bucket do Amazon S3 onde armazenará seu modelo pré-treinado, a saída do seu trabalho de compilação do SageMaker Neo e os dados de entrada de seus dispositivos de ponta.
## Inscreva-se para um Conta da AWS
Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um.
**Para se inscrever em um Conta da AWS**
1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup)
1. Siga as instruções online.
Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.
Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**.
## Criar um usuário com acesso administrativo
Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWS Centro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias.
**Proteja seu Usuário raiz da conta da AWS**
1. Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha.
Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS *.
1. Habilite a autenticação multifator (MFA) para o usuário-raiz.
Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*.
**Criar um usuário com acesso administrativo**
1. Habilita o Centro de Identidade do IAM.
Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.
Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*.
**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.
Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*.
**Atribuir acesso a usuários adicionais**
1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.
Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo.
Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
## Criar funções e armazenamento
SageMaker O Edge Manager precisa acessar seu URI de bucket do Amazon S3. Para facilitar isso, crie uma função do IAM que possa executar a SageMaker IA e tenha permissão para acessar o Amazon S3. Usando essa função, a SageMaker IA pode ser executada em sua conta e acessar seu bucket do Amazon S3.
Você pode criar uma função do IAM usando o console do IAM, o AWS SDK for Python (Boto3) ou. AWS CLI Segue um exemplo de como criar uma perfil do IAM, anexar as políticas necessárias usando o console do IAM e criar um bucket do Amazon S3.
1. **Crie uma função do IAM para a Amazon SageMaker AI.**
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação do console do IAM, escolha **Funções** e, em seguida, **Criar função**.
1. Em **Selecionar tipo de entidade confiável**, selecione serviço **AWS **.
1. Escolha o serviço que você deseja que assuma essa função. Nesse caso, escolha **SageMaker AI**. Então, escolha **Próximo: permissões**.
+ Isso cria automaticamente uma política do IAM que concede acesso a serviços relacionados, como Amazon S3, Amazon ECR e Logs. CloudWatch
1. Escolha **Próximo: tags**.
1. (Opcional) Adicione metadados à função anexando tags como pares de chave-valor. Para obter mais informações sobre como usar rótulos no IAM, consulte [Recursos de etiquetas do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Escolha **Próximo: revisar**.
1. Digite um **Nome da função**.
1. Se possível, digite um nome de função ou um sufixo de nome de função. Os nomes das funções devem ser exclusivos em sua AWS conta. Eles não são diferenciados por maiúsculas e minúsculas. Por exemplo, não é possível criar perfis denominados `PRODROLE` e `prodrole`. Como outros AWS recursos podem fazer referência à função, você não pode editar o nome da função após sua criação.
1. (Opcional) Em **Descrição da função**, digite uma descrição para a nova função.
1. Revise a função e escolha **Criar função**.
Observe o ARN da função SageMaker AI, que você usa para criar um trabalho de compilação com o SageMaker Neo e um trabalho de empacotamento com o Edge Manager. Para encontrar o ARN da função usando o console, faça o seguinte:
1. Vá para o IAMconsole: [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Selecione **Funções**.
1. Pesquise a função que acabou de criar digitando o nome da função no campo de pesquisa.
1. Selecione a função.
1. O ARN do perfil está na parte superior da página de **resumo**.
1. **Crie uma função do IAM para AWS IoT.**
A função AWS IoT do IAM que você cria é usada para autorizar seus objetos. Você também usa a função ARN do IAM para criar e registrar frotas de dispositivos com um objeto cliente de SageMaker IA.
Configure uma função do IAM em sua AWS conta para que o provedor de credenciais assuma em nome dos dispositivos da sua frota de dispositivos. Em seguida, anexe uma política para autorizar seus dispositivos a interagir com os AWS IoT serviços.
Crie uma função programaticamente ou com o console do IAM, semelhante ao que você fez quando criou uma função para SageMaker IA. AWS IoT
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação do console do IAM, escolha **Funções** e, em seguida, **Criar função**.
1. Em **Selecionar tipo de entidade confiável**, selecione serviço **AWS **.
1. Escolha o serviço que você deseja que assuma essa função. Nesse caso, escolha **IoT**. Selecione **IoT** como o **caso de uso**.
1. Escolha **Próximo: Permissões**.
1. Escolha **Próximo: tags**.
1. (Opcional) Adicione metadados à função anexando tags como pares de chave-valor. Para obter mais informações sobre como usar rótulos no IAM, consulte [Recursos de etiquetas do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Escolha **Próximo: revisar**.
1. Digite um **Nome da função**. O nome da função deve começar com `SageMaker AI`.
1. (Opcional) Em **Descrição da função**, digite uma descrição para a nova função.
1. Revise a função e escolha **Criar função**.
1. Depois que a função for criada, escolha **Funções** no console do IAM. Pesquise a função que você criou digitando o nome da função no campo **Pesquisa**.
1. Escolha sua função.
1. Em seguida, escolha **Anexar políticas**.
1. Pesquise por `AmazonSageMakerEdgeDeviceFleetPolicy` no campo de **Pesquisa**. Selecione `AmazonSageMakerEdgeDeviceFleetPolicy`.
1. Escolha **Anexar política**.
1. Adicione a seguinte declaração de política à relação de confiança:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "credentials.iot.amazonaws.com"},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {"Service": "sagemaker.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
------
Uma política de confiança é um [documento da política JSON](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_grammar) no qual você define os princípios que são confiáveis para assumir a função. Para obter mais informações sobre perfis e políticas de confiança, consulte [Termos e conceitos de perfis](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html).
1. Observe o ARN da AWS IoT função. Você usa o ARN da AWS IoT função para criar e registrar a frota de dispositivos. Para encontrar o ARN do perfil do IAM com o console:
1. Acesse o console do IAM: [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Escolha **Perfis**.
1. Pesquise a função que você criou digitando o nome da função no campo **Pesquisar**.
1. Selecione a função.
1. O ARN do perfil está na página Resumo.
1. **Crie um bucket do Amazon S3**.
SageMaker O Neo e o Edge Manager acessam seu modelo pré-compilado e seu modelo compilado a partir de um bucket do Amazon S3. O Edge Manager também armazena dados de amostra da sua frota de dispositivos no Amazon S3.
1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Selecione **Criar bucket**.
1. Em **Nome do bucket**, insira um nome para o bucket.
1. Em **Região**, escolha a AWS região em que você deseja que o bucket resida.
1. Nas **Configurações do Bucket para Bloquear acesso público**, escolha as configurações que deseja aplicar ao bucket.
1. Selecione **Criar bucket**.
Para obter mais informações sobre buckets do S3, consulte Amazon S3 e [Conceitos básicos do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html).
# Prepare o modelo para implantação
Nesta seção, você criará objetos de SageMaker IA e de AWS IoT cliente, fará o download de um modelo de aprendizado de máquina pré-treinado, carregará seu modelo no bucket do Amazon S3, compilará seu modelo para seu dispositivo de destino SageMaker com o Neo e empacotará seu modelo para que ele possa ser implantado com o agente do Edge Manager.
1. **Importe bibliotecas e crie objetos de cliente.**
Este tutorial usa o AWS SDK para Python (Boto3) para criar clientes para interagir com SageMaker IA, Amazon S3 e. AWS IoT
Importe o Boto3, especifique sua região e inicialize os objetos do cliente necessários, conforme mostrado no seguinte exemplo:
```
import boto3
import json
import time
AWS_REGION = 'us-west-2'# Specify your Region
bucket = 'bucket-name'
sagemaker_client = boto3.client('sagemaker', region_name=AWS_REGION)
iot_client = boto3.client('iot', region_name=AWS_REGION)
```
Defina variáveis e atribua a elas o ARN da função que você criou para a SageMaker IA e AWS IoT como strings:
```
# Replace with the role ARN you created for SageMaker
sagemaker_role_arn = "arn:aws:iam:::role/*"
# Replace with the role ARN you created for AWS IoT.
# Note: The name must start with 'SageMaker'
iot_role_arn = "arn:aws:iam:::role/SageMaker*"
```
1. **Treinar um modelo de machine learning.**
Consulte [Treinar um modelo com a Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) para obter mais informações sobre como treinar um modelo de aprendizado de máquina usando SageMaker IA. Se preferir, carregue seu modelo treinado localmente diretamente em um bucket de URI do Amazon S3.
Se você ainda não tiver um modelo, pode usar um modelo pré-treinado para as próximas etapas deste tutorial. Por exemplo, você pode salvar os modelos MobileNet V2 da TensorFlow estrutura. MobileNet O V2 é um modelo de classificação de imagens otimizado para aplicativos móveis. Para obter mais informações sobre a MobileNet V2, consulte o [MobileNet GitHub README](https://github.com/tensorflow/models/tree/master/research/slim/nets/mobilenet).
Digite o seguinte em seu notebook Jupyter para salvar o modelo V2 pré-treinado MobileNet :
```
# Save the MobileNet V2 model to local storage
import tensorflow as tf
model = tf.keras.applications.MobileNetV2()
model.save(“mobilenet_v2.h5”)
```
**nota**
Se você não tiver TensorFlow instalado, poderá fazer isso executando `pip install tensorflow=2.4`
Use a TensorFlow versão 2.4 ou inferior para este tutorial.
O modelo será salvo no arquivo `mobilenet_v2.h5`. Antes de empacotar o modelo, você precisará primeiro compilar seu modelo usando SageMaker o Neo. Verifique [Estruturas, dispositivos, sistemas e arquiteturas compatíveis](neo-supported-devices-edge.md) se sua versão do TensorFlow (ou outra estrutura de sua escolha) é atualmente suportada pelo SageMaker Neo.
SageMaker O Neo exige que os modelos sejam armazenados como um arquivo TAR compactado. Reempacote-o como um arquivo TAR compactado (\$1.tar.gz):
```
# Package MobileNet V2 model into a TAR file
import tarfile
tarfile_name='mobilenet-v2.tar.gz'
with tarfile.open(tarfile_name, mode='w:gz') as archive:
archive.add('mobilenet-v2.h5')
```
1. **Faça upload de seus arquivos para o Amazon S3.**
Depois de treinar seu modo de machine learning, armazene-o em um bucket S3 do Amazon. *O exemplo a seguir usa um AWS CLI comando para carregar o modelo para o bucket do Amazon S3 que você criou anteriormente em um diretório chamado models.* Digite o seguinte em seu caderno Jupyter:
```
!aws s3 cp mobilenet-v2.tar.gz s3://{bucket}/models/
```
1. **Compile seu modelo com o SageMaker Neo.**
Compile seu modelo de aprendizado de máquina com SageMaker o Neo para um dispositivo de ponta. Você precisa conhecer o URI do bucket do Amazon S3 onde você armazenou o modelo treinado, a estrutura de machine learning que você usou para treinar seu modelo, a forma da entrada do seu modelo e seu dispositivo de destino.
Para o modelo MobileNet V2, use o seguinte:
```
framework = 'tensorflow'
target_device = 'jetson_nano'
data_shape = '{"data":[1,3,224,224]}'
```
SageMaker O Neo requer uma forma de entrada de modelo e um formato de modelo específicos com base na estrutura de aprendizado profundo que você usa. Para obter mais informações sobre como salvar seu modelo, consulte [Quais formatos de dados de entrada o SageMaker Neo espera?](neo-compilation-preparing-model.md#neo-job-compilation-expected-inputs). Para obter mais informações sobre os dispositivos e frameworks compatíveis com o Neo, consulte [Estruturas, dispositivos, sistemas e arquiteturas compatíveis](neo-supported-devices-edge.md).
Use a `CreateCompilationJob` API para criar um trabalho de compilação com SageMaker o Neo. Forneça um nome para o trabalho de compilação, o ARN da função de SageMaker IA, o URI do Amazon S3 em que seu modelo está armazenado, a forma de entrada do modelo, o nome da estrutura, o URI do Amazon S3 em que você SageMaker deseja que a IA armazene seu modelo compilado e o destino do seu dispositivo de ponta.
```
# Specify the path where your model is stored
model_directory = 'models'
s3_model_uri = 's3://{}/{}/{}'.format(bucket, model_directory, tarfile_name)
# Store compiled model in S3 within the 'compiled-models' directory
compilation_output_dir = 'compiled-models'
s3_output_location = 's3://{}/{}/'.format(bucket, compilation_output_dir)
# Give your compilation job a name
compilation_job_name = 'getting-started-demo'
sagemaker_client.create_compilation_job(CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
InputConfig={
'S3Uri': s3_model_uri,
'DataInputConfig': data_shape,
'Framework' : framework.upper()},
OutputConfig={
'S3OutputLocation': s3_output_location,
'TargetDevice': target_device},
StoppingCondition={'MaxRuntimeInSeconds': 900})
```
1. **Empacote seu modelo compilado.**
Os trabalhos de empacotamento SageMaker usam modelos compilados pelo NEO e fazem as alterações necessárias para implantar o modelo com o mecanismo de inferência, o agente do Edge Manager. Para empacotar seu modelo, crie um trabalho de empacotamento de borda com a `create_edge_packaging` API ou o console de SageMaker IA.
Você precisa fornecer o nome usado para o trabalho de compilação do Neo, um nome para o trabalho de empacotamento, um ARN da função (consulte a seção [Configuração](edge-getting-started-step1.md)), um nome para o modelo, uma versão do modelo e o URI do bucket do Amazon S3 para a saída do trabalho de empacotamento. Observe que os nomes de tarefas de empacotamento do Edge Manager diferenciam maiúsculas e minúsculas. Veja a seguir um exemplo de como criar um trabalho de empacotamento usando a API.
```
edge_packaging_name='edge-packaging-demo'
model_name="sample-model"
model_version="1.1"
```
Defina o URI do Amazon S3 em que deseja armazenar o modelo empacotado.
```
# Output directory where you want to store the output of the packaging job
packaging_output_dir = 'packaged_models'
packaging_s3_output = 's3://{}/{}'.format(bucket, packaging_output_dir)
```
Use `CreateEdgePackagingJob` para empacotar seu modelo compilado pelo NEO. Forneça um nome para seu trabalho de empacotamento de borda e o nome que você forneceu para seu trabalho de compilação (neste exemplo, ele foi armazenado na variável `compilation_job_name`). Forneça também um nome para seu modelo, uma versão para seu modelo (isso é usado para ajudá-lo a controlar qual versão do modelo você está usando) e o URI do S3 em que você deseja que a SageMaker IA armazene o modelo empacotado.
```
sagemaker_client.create_edge_packaging_job(
EdgePackagingJobName=edge_packaging_name,
CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
ModelName=model_name,
ModelVersion=model_version,
OutputConfig={
"S3OutputLocation": packaging_s3_output
}
)
```
# Registre e autentique sua frota de dispositivos
Nesta seção, você criará seu AWS IoT objeto, criará uma frota de dispositivos, registrará sua frota de dispositivos para que ela possa interagir com a nuvem, criará certificados X.509 para autenticar seus dispositivos AWS IoT Core, associará o alias de função ao AWS IoT que foi gerado quando você criou sua frota, obterá o endpoint AWS específico da conta para o provedor de credenciais, obterá um arquivo oficial da Amazon Root CA e fará o upload do arquivo Amazon CA para o Amazon S3.
1. **Crie AWS IoT coisas.**
SageMaker O Edge Manager aproveita os AWS IoT Core serviços para facilitar a conexão entre os dispositivos de ponta e os endpoints na AWS nuvem. Você pode aproveitar a AWS IoT funcionalidade existente depois de configurar seus dispositivos para trabalhar com o Edge Manager.
Para conectar seu dispositivo a AWS IoT, você precisa criar *objetos AWS IoT ,* criar e registrar um certificado de cliente com a AWS IoT e criar e configurar a função do IAM para seus dispositivos.
Primeiro, crie AWS IoT objetos com o AWS IoT cliente (`iot_client`) que você criou anteriormente com o Boto3. O seguinte exemplo mostra como criar dois objetos:
```
iot_thing_name = 'sample-device'
iot_thing_type = 'getting-started-demo'
iot_client.create_thing_type(
thingTypeName=iot_thing_type
)
# Create an AWS IoT thing objects
iot_client.create_thing(
thingName=iot_thing_name,
thingTypeName=iot_thing_type
)
```
1. **Crie sua frota de dispositivos.**
Crie uma frota de dispositivos com o objeto cliente de SageMaker IA definido em uma etapa anterior. Você também pode usar o console de SageMaker IA para criar uma frota de dispositivos.
```
import time
device_fleet_name="demo-device-fleet" + str(time.time()).split('.')[0]
device_name="sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
```
Especifique o ARN da sua função de IoT. Isso permite AWS IoT conceder credenciais temporárias aos dispositivos.
```
device_model_directory='device_output'
s3_device_fleet_output = 's3://{}/{}'.format(bucket, device_model_directory)
sagemaker_client.create_device_fleet(
DeviceFleetName=device_fleet_name,
RoleArn=iot_role_arn, # IoT Role ARN specified in previous step
OutputConfig={
'S3OutputLocation': s3_device_fleet_output
}
)
```
Um alias de AWS IoT função é criado quando você cria uma frota de dispositivos. Esse alias de função está associado ao AWS IoT uso do `iot_client` objeto em uma etapa posterior.
1. **Registrar a frota de dispositivos.**
Para interagir com a nuvem, você precisa registrar seu dispositivo no SageMaker Edge Manager. Neste exemplo, você registra um único dispositivo com a frota que você criou. Para registrar o dispositivo, você precisa fornecer um nome de dispositivo e o nome da coisa AWS IoT , conforme mostrado no seguinte exemplo:
```
# Device name should be 36 characters
device_name = "sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
sagemaker_client.register_devices(
DeviceFleetName=device_fleet_name,
Devices=[
{
"DeviceName": device_name,
"IotThingName": iot_thing_name
}
]
)
```
1. **Crie certificados X.509.**
Depois de criar o objeto de AWS IoT coisa, você deve criar um certificado de dispositivo X.509 para seu objeto de coisa. Esse certificado autentica seu dispositivo em AWS IoT Core.
Use o seguinte para criar uma chave privada, uma chave pública e um arquivo de certificado X.509 usando o AWS IoT cliente definido (`iot_client`) anteriormente.
```
# Creates a 2048-bit RSA key pair and issues an X.509 # certificate
# using the issued public key.
create_cert = iot_client.create_keys_and_certificate(
setAsActive=True
)
# Get certificate from dictionary object and save in its own
with open('./device.pem.crt', 'w') as f:
for line in create_cert['certificatePem'].split('\n'):
f.write(line)
f.write('\n')
# Get private key from dictionary object and save in its own
with open('./private.pem.key', 'w') as f:
for line in create_cert['keyPair']['PrivateKey'].split('\n'):
f.write(line)
f.write('\n')
# Get a private key from dictionary object and save in its own
with open('./public.pem.key', 'w') as f:
for line in create_cert['keyPair']['PublicKey'].split('\n'):
f.write(line)
f.write('\n')
```
1. **Associe o alias da função a. AWS IoT**
Quando você cria uma frota de dispositivos com SageMaker AI (`sagemaker_client.create_device_fleet()`), um alias de função é gerado para você. Um alias de AWS IoT função fornece um mecanismo para dispositivos conectados se autenticarem AWS IoT usando certificados X.509 e, em seguida, obterem AWS credenciais de curta duração de uma função do IAM associada a um alias de função. AWS IoT O alias da função permite que você altere a função do dispositivo sem precisar atualizar o dispositivo. Use `DescribeDeviceFleet` para obter o nome do alias da função e o ARN.
```
# Print Amazon Resource Name (ARN) and alias that has access
# to AWS Internet of Things (IoT).
sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)
# Store iot role alias string in a variable
# Grabs role ARN
full_role_alias_name = sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)['IotRoleAlias']
start_index = full_role_alias_name.find('SageMaker') # Find beginning of role name
role_alias_name = full_role_alias_name[start_index:]
```
Use o `iot_client` para facilitar a associação do alias de função gerado pela criação da frota de dispositivos com: AWS IoT
```
role_alias = iot_client.describe_role_alias(
roleAlias=role_alias_name)
```
Para obter mais informações sobre o alias de perfil do IAM, consulte o [Alias de função permite acesso a serviços não utilizados](https://docs.aws.amazon.com/iot/latest/developerguide/audit-chk-role-alias-unused-svcs.html).
Você criou e registrou um certificado AWS IoT anteriormente para uma autenticação bem-sucedida do seu dispositivo. Agora, você precisa criar e anexar uma política ao certificado para autorizar a solicitação do token de segurança.
```
alias_policy = {
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": role_alias['roleAliasDescription']['roleAliasArn']
}
}
policy_name = 'aliaspolicy-'+ str(time.time()).split('.')[0]
aliaspolicy = iot_client.create_policy(policyName=policy_name,
policyDocument=json.dumps(alias_policy))
# Attach policy
iot_client.attach_policy(policyName=policy_name,
target=create_cert['certificateArn'])
```
1. **Obtenha o endpoint AWS específico da sua conta para o provedor de credenciais.**
Os dispositivos de borda precisam de um endpoint para assumir as credenciais. Obtenha o endpoint AWS específico da sua conta para o provedor de credenciais.
```
# Get the unique endpoint specific to your AWS account that is making the call.
iot_endpoint = iot_client.describe_endpoint(
endpointType='iot:CredentialProvider'
)
endpoint="https://{}/role-aliases/{}/credentials".format(iot_endpoint['endpointAddress'],role_alias_name)
```
1. **Obtenha o arquivo de CA raiz oficial da Amazon e faça upload para o bucket do Amazon S3.**
Use o seguinte em seu Jupyter Notebook ou AWS CLI (se você usa seu terminal, remova o '\$1' função mágica):
```
!wget https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
Use o endpoint para fazer uma solicitação HTTPS ao provedor de credenciais para que retorne um token de segurança. O comando de exemplo a seguir usa `curl`, mas é possível usar qualquer cliente HTTP.
```
!curl --cert device.pem.crt --key private.pem.key --cacert AmazonRootCA1.pem $endpoint
```
Se o certificado for verificado, faça o upload das chaves e do certificado para o URI do bucket do Amazon S3:
```
!aws s3 cp private.pem.key s3://{bucket}/authorization-files/
!aws s3 cp device.pem.crt s3://{bucket}/authorization-files/
!aws s3 cp AmazonRootCA1.pem s3://{bucket}/authorization-files/
```
Limpe seu diretório de trabalho movendo suas chaves e certificados para um diretório diferente:
```
# Optional - Clean up working directory
!mkdir authorization-files
!mv private.pem.key device.pem.crt AmazonRootCA1.pem authorization-files/
```
# Baixe e configure o Edge Manager
O agente do Edge Manager é um mecanismo de inferência para seus dispositivos de borda. Use o agente para fazer predições com modelos carregados em seus dispositivos de borda. O agente também coleta métricas do modelo e captura dados em intervalos específicos.
Nesta seção, você configurará seu dispositivo com o agente. Para fazer isso, primeiro copie um artefato de lançamento e um certificado raiz de assinatura do bucket de lançamento localmente para sua máquina. Depois de descompactar o artefato de lançamento, carregue-o no Amazon S3. Em seguida, defina e salve um arquivo de configuração para o agente. Um modelo é fornecido para você copiar e colar. Por fim, copie os artefatos da versão, o arquivo de configuração e as credenciais para o seu dispositivo.
1. **Baixe o agente do SageMaker Edge Manager.**
O agente é lançado em formato binário para sistemas operacionais compatíveis. Este exemplo executa inferência em um Jetson Nano que usa um sistema operacional Linux e tem uma arquitetura. ARM64 Para obter mais informações sobre qual sistema operacional e arquitetura os dispositivos compatíveis usam, consulte [Dispositivos, arquiteturas de chip e sistemas compatíveis](neo-supported-devices-edge-devices.md).
Obtenha a versão mais recente dos binários do bucket de lançamento do SageMaker Edge Manager na região us-west-2.
```
!aws s3 ls s3://sagemaker-edge-release-store-us-west-2-linux-armv8/Releases/ | sort -r
```
Isso retorna artefatos de lançamento classificados por sua versão.
```
PRE 1.20210512.96da6cc/
PRE 1.20210305.a4bc999/
PRE 1.20201218.81f481f/
PRE 1.20201207.02d0e97/
```
A versão tem o seguinte formato: `..`. É composto por três componentes:
+ ``: a versão de lançamento. A versão de lançamento está atualmente definida como `1`.
+ ``: a data e hora da liberação do artefato.
+ : o ID de confirmação do repositório a partir do qual a versão foi criada.
Copie o arquivo TAR compactado localmente ou diretamente para o seu dispositivo. O exemplo a seguir mostra como copiar o artefato da versão mais recente no momento em que este documento foi lançado.
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Releases/1.20201218.81f481f/1.20201218.81f481f.tgz ./
```
Depois de ter o artefato, descompacte o arquivo TAR compactado. O seguinte descompacta o arquivo TAR e o armazena em um diretório chamado: `agent_demo`
```
!mkdir agent_demo
!tar -xvzf 1.20201218.81f481f.tgz -C ./agent_demo
```
Carregar os artefatos de liberação do agente para o seu bucket do Amazon S3. O seguinte exemplo de código copia o conteúdo `agent_demo` e o carrega em um diretório dentro do seu bucket do Amazon S3 chamado `agent_demo`:
```
!aws s3 cp --recursive ./agent_demo s3://{bucket}/agent_demo
```
Você também precisa dos certificados raiz de assinatura do bucket de lançamentos:
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Certificates/us-west-2/us-west-2.pem ./
```
Carregue o certificado raiz de assinatura para o seu bucket do Amazon S3:
```
!aws s3 cp us-west-2.pem s3://{bucket}/authorization-files/
```
1. **Defina um arquivo de configuração do agente do SageMaker Edge Manager.**
Primeiro, defina o arquivo de configuração do agente da seguinte forma:
```
sagemaker_edge_config = {
"sagemaker_edge_core_device_name": "device_name",
"sagemaker_edge_core_device_fleet_name": "device_fleet_name",
"sagemaker_edge_core_capture_data_buffer_size": 30,
"sagemaker_edge_core_capture_data_push_period_seconds": 4,
"sagemaker_edge_core_folder_prefix": "demo_capture",
"sagemaker_edge_core_region": "us-west-2",
"sagemaker_edge_core_root_certs_path": "/agent_demo/certificates",
"sagemaker_edge_provider_aws_ca_cert_file": "/agent_demo/iot-credentials/AmazonRootCA1.pem",
"sagemaker_edge_provider_aws_cert_file": "/agent_demo/iot-credentials/device.pem.crt",
"sagemaker_edge_provider_aws_cert_pk_file": "/agent_demo/iot-credentials/private.pem.key",
"sagemaker_edge_provider_aws_iot_cred_endpoint": "endpoint",
"sagemaker_edge_provider_provider": "Aws",
"sagemaker_edge_provider_s3_bucket_name": bucket,
"sagemaker_edge_core_capture_data_destination": "Cloud"
}
```
Substitua o seguinte:
+ `"device_name"` com o nome do seu dispositivo (essa string foi armazenada em uma etapa anterior em uma variável chamada `device_name`).
+ `"device_fleet_name`“ com o nome do seu dispositivo (essa string foi armazenada em uma etapa anterior em uma variável chamada `device_fleet_name`)
+ `"endpoint"`com o endpoint AWS específico da sua conta para o provedor de credenciais (essa string foi armazenada em uma etapa anterior em uma variável chamada). `endpoint`
Em seguida, salve-o como um arquivo JSON:
```
edge_config_file = open("sagemaker_edge_config.json", "w")
json.dump(sagemaker_edge_config, edge_config_file, indent = 6)
edge_config_file.close()
```
Carregue o arquivo de configuração em seu bucket no Amazon S3:
```
!aws s3 cp sagemaker_edge_config.json s3://{bucket}/
```
1. **Copie os artefatos da versão, o arquivo de configuração e as credenciais para o seu dispositivo.**
As instruções a seguir são executadas no próprio dispositivo de borda.
**nota**
Você deve primeiro instalar o Python AWS SDK para Python (Boto3), o e o AWS CLI no seu dispositivo de borda.
Abra um terminal no dispositivo. Crie uma pasta para armazenar os artefatos da versão, suas credenciais e o arquivo de configuração.
```
mkdir agent_demo
cd agent_demo
```
Copie o conteúdo dos artefatos de lançamento que você armazenou no bucket do Amazon S3 para o seu dispositivo:
```
# Copy release artifacts
aws s3 cp s3:///agent_demo/ ./ --recursive
```
(O conteúdo do artefato de lançamento foi armazenado em um diretório chamado `agent_demo` na etapa anterior). Substitua `