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