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.
# Optimización de inferencias para modelos con Amazon SageMaker AI
Con Amazon SageMaker AI, puede mejorar el rendimiento de los modelos de IA generativa mediante la aplicación de técnicas de optimización de inferencias. Al optimizar los modelos, puede lograr una mejor relación costo-rendimiento para el caso de uso. Al optimizar un modelo, puede elegir las técnicas de optimización compatibles se van a aplicar, incluidas la cuantización, la decodificación especulativa y la compilación. Una vez optimizado el modelo, puede realizar una evaluación para ver las métricas de rendimiento en cuanto a latencia, rendimiento y precio.
Para muchos modelos, SageMaker AI también ofrece varias versiones preoptimizadas, cada una de las cuales se adapta a las diferentes necesidades de las aplicaciones en cuanto a latencia y rendimiento. Para estos modelos, puede implementar una de las versiones optimizadas sin tener que primero optimizar el modelo.
## Técnicas de optimización
Amazon SageMaker AI admite las siguientes técnicas de optimización.
### Compilación
La *compilación* optimiza el modelo para obtener el mejor rendimiento disponible en el tipo de hardware elegido sin que se pierda la exactitud. Puede aplicar la compilación de modelos para optimizar los LLM para hardware acelerado, como instancias de GPU, instancias de AWS Trainium o instancias de AWS Inferentia.
Al optimizar un modelo mediante la compilación, sacará partido de la compilación anticipada. Podrá reducir el tiempo de implementación del modelo y la latencia del escalado automático, ya que las ponderaciones del modelo no requieren una compilación justo a tiempo cuando el modelo se implementa en una nueva instancia.
Si decide compilar el modelo para una instancia de GPU, SageMaker AI utiliza la biblioteca TensorRT-LLM para ejecutar la compilación. Si decide compilar el modelo para una instancia de AWS Trainium o de AWS Inferentia, SageMaker AI utiliza el AWS Neuron SDK para ejecutar la compilación.
### Cuantización
La *cuantización* es una técnica para reducir los requisitos de hardware de un modelo mediante el uso de un tipo de datos menos preciso para los ponderaciones y las activaciones. Después de optimizar un modelo con la cuantización, puede alojarlo en GPU menos costosas y con mayor disponibilidad. Sin embargo, es posible que el modelo cuantizado sea menos preciso que el modelo de origen que ha optimizado.
Los formatos de datos que SageMaker AI admite para la cuantificación varían de un modelo a otro. Se admiten siguientes formatos:
+ INT4-AWQ: formato de datos de 4 bits. La cuantización de ponderaciones con reconocimiento de activaciones (AWQ) es una técnica de cuantización para LLM que es eficaz, precisa, con pocos bits y solo para ponderaciones.
+ FP8: la coma flotante de 8 bits (FP8) es un formato de baja precisión para números de coma flotante. Equilibra la eficiencia de la memoria y la precisión del modelo al representar valores con menos bits que el formato de coma flotante estándar FP16.
+ INT8-SmoothQuant: un formato de datos de 8 bits. SmoothQuant es un método de cuantificación de precisión mixta que escala las activaciones y las ponderaciones de forma conjunta al equilibrar sus rangos dinámicos.
### Decodificación especulativa
La *decodificación especulativa* es una técnica que se utiliza para acelerar el proceso de decodificación de grandes LLM. Optimiza la latencia de los modelos sin que se vea afectada la calidad del texto generado.
Esta técnica utiliza un modelo menor pero más rápido denominado modelo de *borrador*. El modelo de borrador genera tokens candidatos, que valida el modelo de *destino*, que es mayor pero más lento. En cada iteración, el modelo de borrador genera varios tokens candidatos. El modelo de destino verifica los tokens y, si detecta que un token en concreto no es aceptable, lo rechaza y lo vuelve a genera. Por lo tanto, el modelo de destino verifica los tokens y genera una pequeño número de ellos.
El modelo de borrador es bastante más rápido que el modelo de destino. Genera todos los tokens rápidamente y, a continuación, envía lotes de ellos al modelo de destino para su verificación. El modelo de destino los evalúa en paralelo, lo que acelera la respuesta final.
SageMaker AI ofrece un modelo de borrador prediseñado que puede utilizar, por lo que no tiene que crear el suyo propio. Si prefiere usar su propio modelo de borrador personalizado, SageMaker AI también admite esta opción.
### Carga rápida de modelos
La técnica de *carga rápida de modelos* prepara un LLM para que SageMaker AI pueda cargarlo en una instancia de ML con mayor rapidez.
Para preparar el modelo, SageMaker AI lo particiona por adelantado dividiéndolo en partes, cada una de las cuales puede residir en una GPU independiente para una inferencia distribuida. Además, SageMaker AI almacena los pesos del modelo en fragmentos del mismo tamaño que SageMaker AI puede cargar en la instancia de forma simultánea.
Cuando SageMaker AI carga el modelo optimizado en la instancia, transmite los pesos del modelo directamente desde Amazon S3 a las GPU de la instancia. Al transmitir los pesos, SageMaker AI omite varios pasos que normalmente son necesarios y que consumen mucho tiempo. Estos pasos incluyen descargar los artefactos del modelo de Amazon S3 al disco, cargar los artefactos del modelo en la memoria del host y particionar el modelo en el host antes de cargar finalmente las particiones en las GPU.
Tras optimizar el modelo para una carga más rápida, puede implementarlo más rápidamente en un punto de conexión de SageMaker AI. Además, si configura el punto de conexión para que utilice el escalado automático, se escala horizontalmente para adaptarse a los aumentos de tráfico.
# 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
# Creación de un trabajo de optimización de inferencias
Puede crear un trabajo de optimización de inferencias mediante Studio o el SDK de Python para SageMaker IA. El trabajo optimiza su modelo mediante la aplicación de las técnicas que elija. Para obtener más información, consulte [Técnicas de optimización](model-optimize.md#optimization-techniques).
**Precios de instancias para trabajos de optimización de inferencias**
Al crear un trabajo de optimización de inferencias que aplica la cuantificación o la compilación, la SageMaker IA elige qué tipo de instancia usar para ejecutar el trabajo. Se le cobrará en función de la instancia utilizada.
Para ver los posibles tipos de instancias y los detalles de sus precios, consulta la información sobre precios de optimización por inferencia en la página de [ SageMaker precios de Amazon](https://aws.amazon.com/sagemaker/pricing/).
No se aplicarán costos adicionales en los trabajos en los que se aplique la decodificación especulativa.
Para conocer los modelos compatibles que puede optimizar, consulte [Referencia de modelos compatibles](optimization-supported-models.md).
## Amazon SageMaker Studio
Complete los siguientes pasos para crear un trabajo de optimización de inferencias en Studio.
**Cómo empezar a crear un trabajo de optimización**
1. En SageMaker AI Studio, cree un trabajo de optimización mediante cualquiera de las siguientes rutas:
+ Para crear un trabajo para un JumpStart modelo, haga lo siguiente:
1. En el menú de navegación, elija **JumpStart**.
1. En la página **Todos los modelos públicos**, elija un proveedor de modelos y, a continuación, seleccione uno de los modelos que admitan la optimización.
1. En la página de detalles del modelo, elija **Optimizar**. Este botón solo está habilitado para los modelos que admiten la optimización.
1. En la página **Crear un trabajo de optimización de inferencias**, algunos JumpStart modelos requieren que firme un acuerdo de licencia de usuario final (EULA) antes de poder 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 crear un trabajo para un JumpStart modelo ajustado, haga lo siguiente:
1. En el panel de navegación, en **Trabajos**, elija **Entrenamiento**.
1. En la página **Trabajos de formación**, elija el nombre de un trabajo que utilizó para ajustar un JumpStart modelo. Estos trabajos tienen el tipo **JumpStartFormación** en la columna **Tipo de trabajo**.
1. En la página de detalles del trabajo de entrenamiento, elija **Optimizar**.
+ Para crear un trabajo para un modelo personalizado, haga lo siguiente:
1. En el menú de navegación, en **Trabajos**, elija **Optimización de inferencias**.
1. Elija **Crear nuevo tarea**.
1. En la página **Crear trabajo de optimización de inferencias**, elija **Agregar modelo**.
1. En la ventana **Agregar modelo**, elija **Modelo personalizado**.
1. Elija una de las siguientes opciones:
**Usa tu modelo actual**: selecciona esta opción para optimizar un modelo que ya hayas creado en SageMaker IA.
**Nombre del modelo existente**: introduzca el nombre de su modelo de SageMaker IA.
**Desde S3**: seleccione esta opción para proporcionar artefactos modelo de Amazon S3. En **URI de S3**, introduzca el URI de la ubicación de Amazon S3 en la que ha almacenado los artefactos del modelo.
1. (Opcional) En el ****nombre del modelo de salida****, puede introducir un nombre personalizado para el modelo optimizado que crea el trabajo. Si no proporciona un nombre, Studio generará uno automáticamente en función de su selección.
1. En la página **Crear trabajo de optimización de inferencias**, en **Nombre del trabajo**, puede aceptar el nombre predeterminado que la SageMaker IA asigna. O bien, para introducir un nombre de trabajo personalizado, seleccione el campo **Nombre del trabajo** y elija **Introducir nombre del trabajo**.
**Establecimiento de las configuraciones de optimización**
1. En **Tipo de instancia de implementación**, elija el tipo de instancia para el que desee optimizar el modelo.
El tipo de instancia afecta a las técnicas de optimización que puede elegir. Para la mayoría de los tipos que utilizan hardware de GPU, las técnicas admitidas son **Cuantización** y **Decodificación especulativa**. Si eliges una instancia que usa silicio personalizado, como la instancia de AWS Inferentia ml.inf2.8xlarge, la técnica admitida es la **compilación**, que puedes usar para compilar el modelo para ese tipo de hardware específico.
1. Seleccione una o varias de las técnicas de optimización que Studio proporciona:
+ Si selecciona **Cuantización**, elija un tipo de datos para la opción **Tipo de datos de precisión**.
+ Si selecciona **Decodificación especulativa**, elija una de las siguientes opciones:
+ **Utilice un modelo de borrador de SageMaker IA: elija usar el modelo** de borrador que proporciona la IA. SageMaker
**nota**
Si opta por utilizar el modelo de borrador de SageMaker IA, también debe habilitar el aislamiento de la red. Studio ofrece esta opción en **Seguridad**.
+ **Elegir JumpStart borrador del modelo**: elija seleccionar un modelo del JumpStart catálogo para usarlo como borrador del modelo.
+ **Elegir su propio modelo de borrador**: elija su propio modelo de borrador y proporcione el URI de S3 en el que se encuentra.
+ Si selecciona **Carga rápida del modelo**, Studio muestra la variable de entorno `OPTION_TENSOR_PARALLEL_DEGREE`. Utilice el campo **Valor** para establecer el grado de paralelismo de tensores. El valor debe dividir GPUs en partes iguales el número de instancias que haya elegido como **tipo de instancia de despliegue**. Por ejemplo, para fragmentar el modelo mientras usas una instancia con 8 GPUs, usa los valores 2, 4 u 8.
+ Si estableces el **tipo de instancia de despliegue** en una instancia de AWS Inferentia o AWS Trainium, Studio podría mostrar que la **compilación** es la única opción admitida. En tal caso, Studio selecciona esta opción automáticamente.
1. En **Salida**, introduzca el URI de una ubicación de Amazon S3. Allí, la SageMaker IA almacena los artefactos del modelo optimizado que crea tu trabajo.
1. (Opcional) Amplíe **Opciones avanzadas** para obtener un control más pormenorizado de la configuración, como, por ejemplo, el rol de IAM, la VPC y las variables de entorno. Para obtener más información, consulte a continuación *Opciones avanzadas*.
1. Cuando haya terminado de configurar el trabajo, seleccione **Crear trabajo**.
Studio muestra la página de detalles del trabajo, que muestra el estado del trabajo y todos sus ajustes.
### Opciones avanzadas
Puede definir las siguientes opciones avanzadas al crear un trabajo de optimización de inferencias.
En **Configuraciones**, puede configurar las siguientes opciones:
**Grado de tensor paralelo **
Un valor para el grado de *paralelismo de tensores*. El paralelismo de tensores es un tipo de paralelismo de modelos en el que las ponderaciones, gradientes y estados del optimizador específicos del modelo se dividen entre los dispositivos. El valor debe dividir en partes iguales el número GPUs de del clúster.
**Longitud máxima del token**
El límite de la cantidad de tokens que generará el modelo. Tenga en cuenta que es posible que el modelo no siempre genere la cantidad máxima de tokens.
**Concurrency (Simultaneidad)**
La capacidad de ejecutar varias instancias de un modelo en el mismo hardware subyacente. Utilice la simultaneidad para ofrecer predicciones a varios usuarios y sacar el máximo partido de la utilización del hardware.
**Tamaño de lote**
Si el modelo realiza *inferencias por lotes*, utilice esta opción para controlar el tamaño de los lotes que procesa el modelo.
La inferencia por lotes genera predicciones de modelos a partir de un lote de observaciones. Es una buena opción para conjuntos de datos grandes o si no necesita una respuesta inmediata a una solicitud de inferencia.
En **Seguridad**, puede configurar las siguientes opciones:
**Rol de IAM**
Una función de IAM que permite a la SageMaker IA realizar tareas en tu nombre. Durante la optimización del modelo, la SageMaker IA necesita su permiso para:
+ Leer los datos de entrada de un bucket de S3
+ Escribir artefactos de modelos en un bucket de S3
+ Escribir registros en Amazon CloudWatch Logs
+ Publica métricas en Amazon CloudWatch
Conceda permisos para todas estas tareas a un rol de IAM.
Para obtener más información, consulte [Cómo utilizar las funciones de ejecución de la SageMaker IA](sagemaker-roles.md).
**Clave de cifrado de KMS**
Una clave en AWS Key Management Service (AWS KMS). SageMaker La IA utiliza la clave para cifrar los artefactos del modelo optimizado cuando la SageMaker IA carga el modelo en Amazon S3.
**VPC**
SageMaker La IA utiliza esta información para crear interfaces de red y conectarlas a los contenedores de sus modelos. Las interfaces de red proporcionan a sus contenedores de modelos una conexión de red en su VPC que no está conectada a Internet. También permiten al modelo conectarse a recursos en su VPC privada.
Para obtener más información, consulte [Ofrezca a los puntos de conexión alojados en SageMaker IA acceso a los recursos de su Amazon VPC](host-vpc.md).
**Habilitación del aislamiento de la red**
Active esta opción si desea restringir el acceso a Internet por parte del contenedor. Los contenedores que funcionan con el aislamiento de la red no pueden realizar llamadas de red salientes.
Debe activar esta opción cuando optimice con decodificación especulativa y utilice el modelo de borrador de SageMaker IA.
Para obtener más información acerca del aislamiento de la red, consulte [Aislamiento de red](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
En **Definición avanzada de contenedores**, puede configurar las siguientes opciones:
**Condición de parada**
Especifica el límite de tiempo durante el que se puede ejecutar un trabajo. Cuando el trabajo alcanza el límite de tiempo, la SageMaker IA finaliza el trabajo. Utilice esta opción para limitar los costos.
**Tags**
Pares clave-valor asociadas al trabajo de optimización.
Para obtener más información sobre las etiquetas, consulte [Tagging AWS resources](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) en la *Referencia general de AWS*.
**Variables de entorno**
Pares clave-valor que definen las variables de entorno que se han de establecer en el contenedor del modelo.
## SageMaker SDK de Python para IA
Puede crear un trabajo de optimización de inferencias utilizando el SDK de Python para SageMaker IA en su proyecto. En primer lugar, defina una instancia `Model` mediante la clase `ModelBuilder`. A continuación, utilice el método `optimize()` para ejecutar un trabajo que optimice el modelo con la cuantización, la decodificación especulativa o la compilación. Cuando se complete el trabajo, implemente el modelo en un punto de conexión de inferencia mediante el método `deploy()`.
Para obtener más información sobre las clases y los métodos utilizados en los siguientes ejemplos, consulta [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)la documentación del SDK de Python para SageMaker IA.
**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 importa las clases del SDK de Python para SageMaker IA 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
from pathlib import Path
```
1. Inicializa una sesión de SageMaker IA. 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 él, la SageMaker IA 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 su modelo según la IA. SageMaker 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 JumpStart modelo. `jumpstart-model-id`Sustitúyalo por el identificador de un JumpStart modelo, por ejemplo`meta-textgeneration-llama-3-70b`.
**nota**
Si quiere optimizar con una decodificación especulativa y quiere utilizar el borrador de SageMaker IA, debe habilitar el aislamiento de la red. Para habilitarlo, incluya el siguiente argumento al inicializar una instancia `ModelBuilder`:
```
enable_network_isolation=True,
```
Para obtener más información acerca del aislamiento de la red, consulte [Aislamiento de red](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
**Optimización con la cuantización**
1. Para ejecutar un trabajo de cuantización, utilice el método `optimize()` y establezca el argumento `quantization_config`. En el siguiente ejemplo se establece `OPTION_QUANTIZE` como una variable de entorno en el contenedor de optimización:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
En este ejemplo, sustituya *`instance-type`* por una instancia de ML, como `ml.p4d.24xlarge`. Sustituya *`s3://output-path`* por la ruta a la ubicación de S3 en la que se almacena el modelo optimizado que crea el trabajo.
El método `optimize()` devuelve un objeto `Model`, que puede utilizar para implementar el modelo en un punto de conexión.
1. Cuando se complete el trabajo, implemente el modelo. En el siguiente ejemplo se utiliza el método `deploy()`:
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
En este ejemplo, sustituya *`instance-type`* por una instancia de ML, como `ml.p4d.24xlarge`.
El método `deploy()` devuelve un objeto predictor, que puede utilizar para enviar solicitudes de inferencia al punto de conexión que aloja el modelo.
**Para optimizar con la decodificación especulativa, utilice el borrador del modelo SageMaker AI**
Cuando optimizas tu modelo con decodificación especulativa, puedes optar por usar un borrador de modelo proporcionado por la SageMaker IA o puedes usar el tuyo propio. En los ejemplos siguientes se utiliza el modelo preliminar de SageMaker IA.
**Requisito previo**
Para optimizar con la decodificación especulativa y el modelo preliminar de SageMaker IA, debe habilitar el aislamiento de la red al definir el modelo.
1. Para ejecutar un trabajo de decodificación especulativa, utilice el método `optimize()` y establezca el argumento `speculative_decoding_config`. El siguiente ejemplo establece la `ModelProvider` clave `SAGEMAKER` para utilizar el borrador del modelo que proporciona la SageMaker IA.
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
En este ejemplo, sustituya *`instance-type`* por una instancia de ML, como `ml.p4d.24xlarge`.
El método `optimize()` devuelve un objeto `Model`, que puede utilizar para implementar el modelo en un punto de conexión.
1. Cuando se complete el trabajo, implemente el modelo. En el siguiente ejemplo se utiliza el método `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
El método `deploy()` devuelve un objeto predictor, que puede utilizar para enviar solicitudes de inferencia al punto de conexión que aloja el modelo.
**Optimización con la decodificación especulativa mediante un modelo de borrador personalizado**
Antes de poder proporcionar su borrador de modelo personalizado a SageMaker AI, primero debe cargar los artefactos del modelo en Amazon S3.
En los siguientes ejemplos se muestra una forma posible de proporcionar un modelo de borrador personalizado. En los ejemplos se descarga el modelo de borrador del Hugging Face Hub, se carga en Amazon S3 y se proporciona el URI de S3 al argumento `speculative_decoding_config`.
1. Si quiere descargar un modelo del Hugging Face Hub, añada la biblioteca `huggingface_hub` a su proyecto y descargue un modelo con el método `snapshot_download()`. En el siguiente ejemplo se descarga un modelo en un directorio local:
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
En este ejemplo, sustituya *`model-id`* por el ID de un modelo, el Hugging Face Hub, como `meta-llama/Meta-Llama-3-8B`. Sustituya *`download-dir`* por un directorio local. Sustituya *`hf-access-token`* por su token de acceso de usuario. Para obtener información sobre cómo obtener su token de acceso, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens) en la documentación de Hugging Face.
Para obtener más información sobre la biblioteca `huggingface_hub`, consulte [Hub client library](https://huggingface.co/docs/huggingface_hub/en/index) en la documentación de Hugging Face.
1. Para que el modelo descargado esté disponible para SageMaker AI, cárguelo en Amazon S3. En el siguiente ejemplo se carga el modelo con el 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",
)
```
En este ejemplo, sustituya *`prefix`* por un calificador que le ayude a distinguir el modelo de borrador en S3, como `spec-dec-custom-draft-model`.
El método `upload_data()` devuelve el URI de S3 de los artefactos del modelo.
1. Para ejecutar un trabajo de decodificación especulativa, utilice el método `optimize()` y establezca el argumento `speculative_decoding_config`. En el siguiente ejemplo se establece la clave `ModelSource` del URI de S3 del modelo de borrador personalizado:
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
En este ejemplo, sustituya *`instance-type`* por una instancia de ML, como `ml.p4d.24xlarge`.
El método `optimize()` devuelve un objeto `Model`, que puede utilizar para implementar el modelo en un punto de conexión.
1. Cuando se complete el trabajo, implemente el modelo. En el siguiente ejemplo se utiliza el método `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
El método `deploy()` devuelve un objeto predictor, que puede utilizar para enviar solicitudes de inferencia al punto de conexión que aloja el modelo.
**Optimización con la compilación**
1. Para ejecutar un trabajo de compilación, utilice el método `optimize()` y establezca el argumento `compilation_config`. En el siguiente ejemplo se utiliza la clave `OverrideEnvironment` para establecer las variables de entorno necesarias en el contenedor de optimización:
```
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",
)
```
En este ejemplo, establezca *`instance-type`* en un tipo de instancia de ML con hardware acelerado. Por ejemplo, para AWS una inferencia acelerada con Inferentia, puede establecer el tipo en una instancia de Inf2, como. `ml.inf2.48xlarge` Sustituya *`s3://output-path`* por la ruta a la ubicación de S3 en la que se almacena el modelo optimizado que crea el trabajo.
1. Cuando se complete el trabajo, implemente el modelo. En el siguiente ejemplo se utiliza el método `deploy()`:
```
predictor = optimized_model.deploy(accept_eula=True)
```
El método `deploy()` devuelve un objeto predictor, que puede utilizar para enviar solicitudes de inferencia al punto de conexión que aloja el modelo.
**Prueba del modelo con una solicitud de inferencia**
+ Para enviar una solicitud de inferencia de prueba al modelo implementado, utilice el método `predict()` de un objeto predictor. En el siguiente ejemplo se pasa la variable `sample_input` que también se pasó a la clase `SchemaBuilder` en los ejemplos para definir el modelo:
```
predictor.predict(sample_input)
```
La entrada de muestra tiene la petición, `"What is the largest planet in the solar system?"`. El método `predict()` devuelve la respuesta que generó el modelo, como se muestra en el siguiente ejemplo:
```
{'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)
Puede utilizar el AWS SDK para Python (Boto3) para crear y gestionar tareas de optimización de inferencias mediante programación. En esta sección se proporcionan ejemplos de diferentes técnicas de optimización.
**Requisitos previos**
Antes de crear un trabajo de optimización con Boto3, asegúrese de tener:
+ AWS Credenciales configuradas: configure sus AWS credenciales con los permisos adecuados
+ Creó un modelo de SageMaker IA (si utiliza un modelo existente)
+ Preparé los datos de entrenamiento en S3 (para la optimización de la decodificación especulativa, se admitía una longitud de contexto de hasta 4096)
+ Función de IAM con los permisos necesarios: su función de ejecución debe tener permisos para acceder a S3 y crear recursos SageMaker
**Ejemplo: Crear un trabajo de optimización con la decodificación especulativa EAGLE (Llama 3.3 70B)**
En este ejemplo se muestra la creación de un trabajo de optimización para un modelo de lenguaje grande mediante la técnica de decodificación 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']}")
```
**Ejemplo: Crear un trabajo de optimización a partir de artefactos del modelo S3 (Qwen3 32B)**
En este ejemplo se muestra cómo crear un trabajo de optimización utilizando artefactos de modelo directamente desde 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']}")
```
**Ejemplo: supervisar y gestionar los trabajos de optimización**
Tras crear un trabajo de optimización, puede supervisar su progreso y gestionarlo mediante estos 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'
# )
```
La decodificación especulativa con Eagle Heads lleva a cabo cuatro tareas de formación secuenciales. Cada trabajo produce un resultado que se convierte en la entrada del siguiente. Solo el resultado del trabajo final se envía a su bucket de S3. Los resultados intermedios se cifran y almacenan en un depósito de servicios de SageMaker IA interno durante un máximo de 20 días. SageMaker AI no tiene permisos para descifrarlos. Si desea que los datos intermedios se eliminen antes de ese período, asegúrese de que su trabajo se haya completado o se haya detenido y, a continuación, abra un caso de soporte [[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 se eliminen estos datos. Incluya en la solicitud su ID de AWS cuenta y el ARN del trabajo de optimización.
## Limitaciones del borrador del SageMaker modelo de IA
Para cualquier modelo que optimice con el modelo preliminar de SageMaker IA, tenga en cuenta los requisitos, las restricciones y las variables de entorno compatibles.
**Requisitos**
Debe hacer lo siguiente:
+ Utilice un modelo proporcionado por SageMaker JumpStart.
+ Habilitar el aislamiento de la red para la implementación del modelo.
+ Si implementa el modelo en un contenedor de inferencia de modelos grandes (LMI), utilice un DJLServing contenedor de la versión 0.28.0 o superior.
Para ver los contenedores disponibles, consulte Contenedores de [inferencia de modelos grandes](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) en el GitHub repositorio de Deep Learning Containers.
+ Si ajusta el JumpStart modelo con precisión, utilice el formato safetensors para los pesos del modelo.
Para obtener más información, consulte [Safetensors](https://huggingface.co/docs/safetensors/en/index) en la documentación de Hugging Face.
**Restricciones**
No puede hacer lo siguiente:
+ Utilizar el modelo en entornos de prueba locales que cree con el modo local.
Para obtener más información sobre el modo local, consulta [Modo local](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode) en la documentación del SDK de Python para SageMaker IA.
+ Acceda al contenedor del modelo a través del AWS Systems Manager agente (agente SSM). El agente SSM proporciona acceso a nivel de shell a su contenedor modelo para que pueda depurar procesos y registrar comandos con Amazon. CloudWatch
Para obtener más información acerca de esta característica, consulte [Acceso a contenedores a través de SSM](ssm-access.md).
+ Configurar el contenedor de modelos para un volcado de núcleo que se produce si el proceso se bloquea.
Para obtener más información sobre los volcados principales de los contenedores modelo, consulte. [ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html)
+ Implementar el modelo en puntos de conexión multimodelo, puntos de conexión multicontenedor o puntos de conexión que alojan componentes de inferencia.
Para obtener más información acerca de estos tipos de puntos de conexión, consulte [Puntos de conexión multimodelo](multi-model-endpoints.md), [Puntos de conexión con varios contenedores](multi-container-endpoints.md) y [Componentes de inferencias](realtime-endpoints-deploy-models.md#inference-components).
+ Crear un paquete de modelos para el modelo. Los paquetes de modelos se utilizan para crear modelos desplegables en los que se publican. AWS Marketplace
Para obtener más información acerca de esta característica, consulte [Cree un recurso de paquete de modelos](sagemaker-mkt-create-model-package.md).
+ Usar su propio código de inferencia en el contenedor de modelos.
+ Utilizar un archivo `requirements.txt` en el contenedor de modelos. Este tipo de archivo muestra las dependencias de los paquetes.
+ Habilitar el parámetro `trust_remote_code` de Hugging Face.
**Variables de entorno admitidas**
Puede configurar el contenedor únicamente con las siguientes variables de entorno:
+ Variables de entorno comunes para contenedores de inferencia de modelos grandes (LMI).
Para obtener más información sobre estas variables, consulte [Environment Variable Configurations](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations) en la documentación del contenedor de LMI.
+ Variables de entorno comunes para los paquetes que Hugging Face Hub proporciona en sus repositorios de Git.
Para los repositorios, consulta [Hugging](https://github.com/huggingface) Face on. GitHub
+ Variables de PyTorch entorno comunes y CUDA.
Para obtener más información sobre estas variables, consulte las [variables de entorno de Torch](https://pytorch.org/docs/stable/torch_environment_variables.html) en la PyTorch documentación.
# Visualización de los resultados del trabajo de optimización
Una vez que haya creado uno o varios trabajos de optimización, puede usar Studio para ver una tabla de resumen de todos los trabajos, donde podrá ver los detalles de cada trabajo.
## Amazon SageMaker Studio
**Visualización de la tabla de resumen de los trabajos de optimización**
+ En el menú de navegación de Studio, en **Trabajos**, elija **Optimización de inferencias**.
En la página **Optimización de inferencias** se muestra una tabla con los trabajos que ha creado. En cada trabajo se muestran las configuraciones de optimización que ha aplicado y el estado del trabajo.
**Visualización de los detalles de un trabajo**
+ En la página **Optimización de inferencias**, en la tabla de resumen, elija el nombre del trabajo.
Studio muestra la página de detalles del trabajo, que indica el estado del trabajo y todos los ajustes que ha aplicado al crear el trabajo. Si el trabajo se ha completado correctamente, SageMaker AI ha almacenado los artefactos del modelo optimizado en la ubicación de Amazon S3 en el **URI de S3 de modelos optimizados**.
# Evaluación del rendimiento de modelos optimizados
Después de utilizar un trabajo de optimización para crear un modelo optimizado, puede realizar una evaluación del rendimiento del modelo. Esta evaluación proporciona métricas en cuanto a latencia, rendimiento y precio. Utilice estas métricas para determinar si el modelo optimizado cumple con las necesidades del caso de uso o si requiere una mayor optimización.
Solo puede realizar evaluaciones de rendimiento con Studio. Esta función no se proporciona a través de la API de Amazon SageMaker AI ni del SDK de Python.
## Antes de empezar
Antes de crear una evaluación del rendimiento, primero debe optimizar un modelo mediante la creación de un trabajo de optimización de inferencias. En Studio, solo puede evaluar los modelos que cree con estos trabajos.
## Creación de la evaluación del rendimiento
Complete los siguientes pasos en Studio para crear una evaluación del rendimiento de un modelo optimizado.
1. En el menú de navegación de Studio, en **Trabajos**, elija **Optimización de inferencias**.
1. Elija el nombre del trabajo que ha creado el modelo optimizado que desea evaluar.
1. En la página de detalles del trabajo, elija **Evaluar rendimiento**.
1. En la página de **evaluación del rendimiento**, algunos JumpStart modelos requieren que firme un acuerdo de licencia de usuario final (EULA) antes de poder 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**.
1. En **Seleccionar un modelo para el tokenizador**, acepte el modelo predeterminado o elija un modelo específico que sirva de tokenizador para la evaluación.
1. En **Conjuntos de datos de entrada**, elija si desea:
+ Utilice los conjuntos de datos de muestra predeterminados de AI. SageMaker
+ Proporcionar un URI de S3 que apunte a sus propios conjuntos de datos de ejemplo.
1. En **URI de S3 para resultados de rendimiento**, proporcione un URI que apunte a la ubicación de Amazon S3 en la que desea almacenar los resultados de la evaluación.
1. Elija **Evaluar**.
Studio muestra la página **Evaluaciones de rendimiento**, donde se muestra el trabajo de evaluación en la tabla. En la columna **Estado** se muestra el estado de la evaluación.
1. Cuando el estado sea **Completado**, elija el nombre del trabajo para ver los resultados de la evaluación.
En la página de detalles de la evaluación se muestran tablas que proporcionan las métricas de rendimiento en cuanto a latencia, rendimiento y precio. Para obtener más información sobre cada métrica, consulte [Referencia de métricas para las evaluaciones del rendimiento de inferencias](#performance-eval-metrics-reference).
## Referencia de métricas para las evaluaciones del rendimiento de inferencias
Tras evaluar correctamente el rendimiento de un modelo optimizado, la página de detalles de la evaluación de Studio muestra las siguientes métricas.
### Métricas de latencia
En la sección **Latencia** se muestran las siguientes métricas.
**Concurrency (Simultaneidad)**
El número de usuarios simultáneos que la evaluación ha simulado para invocar el punto de conexión de forma simultánea.
**Tiempo transcurrido hasta el primer token (ms)**
El tiempo transcurrido entre el envío de la solicitud y el momento en que se recibe el primer token de una respuesta de transmisión.
**Latencia entre tokens (ms)**
El tiempo necesario para generar un token de salida para cada solicitud.
**Latencia del cliente (ms)**
La latencia de la solicitud desde el momento en que se envía la solicitud hasta el momento en que se recibe la respuesta completa.
**Entrada tokens/sec (recuento)**
El número total de tokens de entrada generados, en todas las solicitudes, dividido por la duración total en segundos de la simultaneidad.
**Salida tokens/sec (recuento)**
El número total de tokens de salida generados, en todas las solicitudes, dividido por la duración total en segundos de la simultaneidad.
**Invocaciones de clientes (recuento)**
El número total de solicitudes de inferencia enviadas al punto de conexión entre todos los usuarios de forma simultánea.
**Errores de invocación de clientes (recuento)**
El número total de solicitudes de inferencia enviadas al punto de conexión entre todos los usuarios en una simultaneidad determinada que ha provocado un error de invocación.
**Error en el tokenizador (recuento)**
El número total de solicitudes de inferencia en las que el tokenizador no ha podido analizar la solicitud o la respuesta.
**Respuesta de inferencia vacía (recuento)**
El número total de solicitudes de inferencia que no han generado ningún token de salida o que el tokenizador no ha podido analizar la respuesta.
### Métricas de rendimiento
En la sección **Rendimiento** se muestran las siguientes métricas.
**Concurrency (Simultaneidad)**
El número de usuarios simultáneos que la evaluación ha simulado para invocar el punto de conexión de forma simultánea.
**Entrada tokens/sec/req (recuento)**
El número total de tokens de entrada generadas por segundo y por solicitud.
**Salida tokens/sec/req (recuento)**
El número total de tokens de salida generadas por segundo y por solicitud.
**Tokens de entrada (recuento)**
El número total de tokens de entrada generadas por solicitud.
**Tokens de salida (recuento)**
El número total de tokens de salida generados por solicitud.
### Métricas de precios
En la sección **Precio** se muestran las siguientes métricas.
**Concurrency (Simultaneidad)**
El número de usuarios simultáneos que la evaluación ha simulado para invocar el punto de conexión de forma simultánea.
**Precio por millón de tokens de entrada**
Costo de procesamiento de un millón de tokens de entrada
**Precio por millón de tokens de salida**
Costo de generación de un millón de tokens de salida
# Referencia de modelos compatibles
En las tablas siguientes se muestran los modelos en los que la SageMaker IA admite la optimización de inferencias y las técnicas de optimización compatibles.
**Modelos Llama compatibles**
| Nombre del modelo | Formatos de datos admitidos para la cuantización | Admite decodificación especulativa | Admite carga rápida de modelos | Bibliotecas utilizadas para compilación |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 2 13B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 2 70B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 2 7B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 3 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Llama 3 8B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Meta Code Llama 13B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 13B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 13B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 34B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 34B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 34B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 70B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 70B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Code Llama 7B Python | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Meta Llama 2 13B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 2 13B Chat Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 2 70B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 2 70B Chat Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 2 7B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 2 7B Chat Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3 70B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3 70B Instruct Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3 8B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3 8B Instruct Neuron | Ninguno | No | No | AWSNeurona |
| Meta Code Llama 70B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Code Llama 7B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Code Llama 7B Python Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3.1 405B FP8 | Ninguno | Sí | Sí | Ninguno |
| Meta Llama 3.1 405B Instruct FP8 | Ninguno | Sí | Sí | Ninguno |
| Meta Llama 3.1 70B | INT4-AWQ FP8 | Sí | Sí | Ninguno |
| Meta Llama 3.1 70B Instruct | INT4-AWQ FP8 | Sí | Sí | Ninguno |
| Meta Llama 3.1 8B | INT4-AWQ FP8 | Sí | Sí | Ninguno |
| Meta Llama 3.1 8B Instruct | INT4-AWQ FP8 | Sí | Sí | Ninguno |
| Meta Llama 3.1 70B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3.1 70B Instruct Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3 1 8B Neuron | Ninguno | No | No | AWSNeurona |
| Meta Llama 3.1 8B Instruct Neuron | Ninguno | No | No | AWSNeurona |
**Modelos Mistral compatibles**
| Nombre del modelo | Formatos de datos admitidos para la cuantización | Admite decodificación especulativa | Admite carga rápida de modelos | Bibliotecas utilizadas para compilación |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Mistral 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | AWSNeurona TensorRT-LLM |
| Mistral 7B Neuron | Ninguno | No | No | AWSNeurona |
| Mistral 7B Instruct Neuron | Ninguno | No | No | AWSNeurona |
**Modelos Mixtral compatibles**
| Nombre del modelo | Formatos de datos admitidos para la cuantización | Admite decodificación especulativa | Admite carga rápida de modelos | Bibliotecas utilizadas para compilación |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruct-v0.1 | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
| Mixtral 8x7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Sí | Sí | TensorRT-LLM |
**Arquitecturas de modelos compatibles y tipo EAGLE**
| Nombre de la arquitectura del modelo | Tipo EAGLE |
| --- | --- |
| LlamaForCausalLM | ÁGUILA 3 |
| Qwen 3 KM ForCausal | ÁGUILA 3 |
| Qwen 3 KM NextForCausal | ÁGUILA 2 |
| Qwen 3 KM MoeForCausal | ÁGUILA 3 |
| Qwen2 LM ForCausal | ÁGUILA 3 |
| GptOssForCausalLM | ÁGUILA 3 |