As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Implantar modelos para inferência em tempo real
**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 Docker integrada 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, CPUs e aceleradores. 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 e LLMs facilmente 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/) — Parte 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 suporta 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 comando put-bucket-cors AWS CLI :
```
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:
**Para o **Definição de contêiner** seção, faça o seguinte:**
1. Em **Tipo de contêiner**, selecione **Pre-builtcontêiner** 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 **Pre-built contêiner**, selecione a **estrutura do contêiner**, a **versão da estrutura** e o **tipo de hardware** que você 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:
**Para o **Artefatos** seção, 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 **Pre-packagedartefatos** e você deve fornecer todos os seus artefatos já empacotados como um arquivo. `tar.gz` Faça o seguinte:
1. Para **Pre-packaged artefatos**, selecione **Input S3 URI para artefatos de modelo pré-empacotados** se você já tiver carregado seu `tar.gz` arquivo 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:
**Para o **Segurança** seção, 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:
**(Opcional) Para o **Opções avançadas** seção, 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 JumpStart LLMs mais usados do hub de modelos, a opção **Configurações alternativas** aparecerá após os campos tipo de instância e contagem de instâncias.
Para os JumpStart LLMs mais populares, AWS tem tipos de instância pré-comparados para otimizar o custo ou o 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:
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:
Depois de configurar sua implantação, escolha **Implantar** para criar o endpoint e implantar o modelo.
## Implantar modelos com os SDKs do Python
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 clássicos de ML 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:
+ Especificando 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\_endpoint](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\_endpoint](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:
+ Especificando 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 comando create-endpoint-config**
O exemplo a seguir cria uma configuração de endpoint com o comando [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html).
```
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 comando create-endpoint-config**
O exemplo a seguir cria uma configuração de endpoint com o comando [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html).
```
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 comando create-inference-component**
O exemplo a seguir cria um componente de inferência com o comando create-inference-component.
```
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"
}
```
------