Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Implementación de un modelo preoptimizado
SageMaker AI optimiza previamente algunos modelos de JumpStart, lo que significa que puede implementar versiones optimizadas de estos modelos sin necesidad de crear primero un trabajo de optimización de inferencias.
Para ver la lista de modelos con opciones preoptimizadas, consulte [Modelos preoptimizados de JumpStart](#pre-optimized-js).
## Amazon SageMaker Studio
Utilice el siguiente procedimiento para implementar un modelo preoptimizado de JumpStart mediante Amazon SageMaker Studio.
**Implementación de un modelo preoptimizado**
1. En Studio, en el menú de navegación de la izquierda, elija **JumpStart**.
1. En la página **Todos los modelos públicos**, elija uno de los modelos que se han optimizado previamente.
1. En la página de detalles del modelo, elija **Implementar**.
1. En la página de implementación, algunos modelos de JumpStart requieren que firme un acuerdo de licencia de usuario final (EULA) antes de continuar. Si se solicita, revise los términos de la licencia en la sección **Acuerdo de licencia**. Si los términos son aceptables para el caso de uso, seleccione la casilla de verificación **Acepto el EULA, y he leído los términos y las condiciones**.
Para obtener más información, consulte [Contratos de licencia para usuarios finales](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
1. En **Nombre del punto de conexión** y **Recuento inicial de instancias**, acepte los valores predeterminados o establezca valores personalizados.
1. En **Tipo de instancia**, mantenga el valor predeterminado. De lo contrario, no podrá implementar una configuración preoptimizada.
1. En **Modelos**, amplíe la configuración del modelo. Studio muestra una tabla con las configuraciones preoptimizadas entre las que puede elegir. Cada opción tiene métricas de latencia y rendimiento. Elija la opción que mejor se adapte a las necesidades de la aplicación.
1. Elija **Implementar**.
## SageMaker AI Python SDK
Puede implementar un modelo preoptimizado mediante el SageMaker AI Python SDK en su proyecto. En primer lugar, defina una instancia `Model` mediante la clase `ModelBuilder`. A continuación, utilice el método `set_deployment_config()` para establecer la configuración preoptimizada que desea implementar. A continuación, utilice el método `build()` para crear el modelo. Por último, utilice el método `deploy()` para implementarlo en un punto de conexión de inferencia.
Para obtener más información sobre las clases y los métodos utilizados en los siguientes ejemplos, consulte [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html) en la documentación del SageMaker AI Python SDK.
**Configuración de un proyecto**
1. En el código de la aplicación, importe las bibliotecas necesarias. En el ejemplo siguiente se importa el SDK para Python (Boto3). También se importan los módulos del SageMaker AI Python SDK que se utilizan para definir los modelos y trabajar con ellos:
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. Inicialice una sesión de SageMaker AI. En este ejemplo se usa la clase `Session()`:
```
sagemaker_session = Session()
```
**Definición de un modelo**
1. Cree una instancia de `SchemaBuilder` y proporcione ejemplos de entrada y salida. Al definir un modelo, debe proporcionar esta instancia a la clase `ModelBuilder`. Con ella, SageMaker AI genera automáticamente las funciones de clasificación para serializar y deserializar la entrada y la salida.
Para obtener más información sobre el uso de las clases `SchemaBuilder` y `ModelBuilder`, consulte [Cree un modelo en Amazon SageMaker AI con ModelBuilder](how-it-works-modelbuilder-creation.md).
En el ejemplo siguiente se proporcionan ejemplos de cadenas de entrada y salida para la clase `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 el modelo en SageMaker AI. En el ejemplo siguiente se definen los parámetros para inicializar una instancia de `ModelBuilder`:
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
En este ejemplo se utiliza un modelo de JumpStart. Sustituya el `jumpstart-model-id` por el ID de un modelo de JumpStart, como, por ejemplo, `meta-textgeneration-llama-3-70b`.
**Recuperación de métricas de referencia**
1. Para determinar la configuración preoptimizada que desea implementar, consulte las opciones que ofrece SageMaker AI. En el ejemplo siguiente se muestran:
```
model_builder.display_benchmark_metrics()
```
Este método de `display_benchmark_metrics()` imprime una tabla como la siguiente:
```
| 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 |
. . .
```
En la primera columna, la tabla muestra los posibles tipos de instancias que puede utilizar para alojar el modelo de JumpStart que elija. Para cada tipo de instancia, en `Config Name`, se muestran los nombres de las configuraciones preoptimizadas. Las configuraciones que proporciona SageMaker AI se denominan `lmi-optimized`. Para cada tipo y configuración de instancia, la tabla proporciona métricas de referencia. Estas métricas indican el rendimiento y la latencia que el modelo admitirá para diferentes números de usuarios simultáneos.
1. En función de las métricas de referencia, elija el tipo de instancia y el nombre de la configuración que mejor se adapten a las necesidades de rendimiento. Utilizará estos valores cuando cree una configuración de implementación.
**Implementación de un modelo preoptimizado**
1. Cree una configuración de implementación. En el ejemplo siguiente se utiliza una instancia de `ModelBuilder`. Se transmite un tipo de instancia y un nombre de configuración al método `set_deployment_config()`:
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
Sustituya *`config-name`* por un nombre de configuración de la tabla, como, por ejemplo, `lmi-optimized`. Sustituya `instance-type` por un tipo de instancia de la tabla, como, por ejemplo, `ml.p4d.24xlarge`.
1. Cree el modelo. En el ejemplo siguiente se utiliza el método `.build()` de la instancia de `ModelBuilder`:
```
optimized_model = model_builder.build()
```
El método `.build()` devuelve una instancia de `Model` implementable.
1. Implemente el modelo en un punto de conexión de inferencia. En el ejemplo siguiente se utiliza el método `.deploy()` de la instancia de `Model`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
El método `deploy()` devuelve una instancia de `Predictor`, que puede utilizar para enviar solicitudes de inferencia al modelo.
**Prueba del modelo con una solicitud de inferencia**
+ Después de implementar el modelo en un punto de conexión de inferencia, pruebe las predicciones del modelo. En el siguiente ejemplo se envía una solicitud de inferencia mediante la instancia de `Predictor`:
```
predictor.predict(sample_input)
```
El modelo devuelve el texto que genera con una respuesta como la siguiente:
```
{'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 preoptimizados de JumpStart
A continuación se indican los modelos de JumpStart con configuraciones preoptimizadas.
**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 precompilados de JumpStart
Para algunos modelos y configuraciones, SageMaker AI proporciona modelos precompilados para instancias específicas de AWS Inferentia y AWS Trainium. Para ello, si crea un trabajo de optimización de la compilación y elige ml.inf2.48xlarge o ml.trn1.32xlarge como tipo de instancia de implementación, SageMaker AI obtiene los artefactos compilados. Dado que el trabajo utiliza un modelo que ya está compilado, se completa rápidamente sin ejecutar la compilación desde cero.
A continuación se indican los modelos de JumpStart para los que SageMaker AI tiene modelos precompilados:
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Code Llama 7B
+ Code Llama 70B
**HuggingFace**
+ Mistral 7B