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 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