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.
# Gestión de plantillas de chat y tokenizadores personalizados
Las plantillas de chat personalizadas y los tokenizadores son componentes esenciales para formatear correctamente las entradas conversacionales y gestionar la generación de tokens en los modelos importados. La importación de modelos personalizados permite importar modelos con plantillas de chat personalizadas que definen cómo se estructuran y tokenizan las conversaciones de varios turnos.
## Importación de modelos con plantillas de chat personalizadas
Al importar un modelo con plantillas de chat personalizadas, asegúrese de seguir las prácticas recomendadas que se describen en la documentación principal sobre la importación de modelos personalizados, como introducir los pesos de los modelos en un formato de tensores seguro y proporcionar todos los archivos de configuración necesarios.
### Requisitos de formato de las plantillas de chat
Si su modelo usa una plantilla de chat personalizada y usted quiere usar esa plantilla con Amazon Bedrock, debe incluir el archivo de la plantilla de chat en uno de los siguientes formatos:
+ **`chat_template.jinja`**— Un archivo Jinja2-based de plantilla que define cómo se formatean los mensajes.
+ **`chat_template.json`**— Un archivo JSON que contiene la plantilla de chat como un valor de cadena.
+ **`tokenizer_config.json`con plantilla de chat integrada**: también puedes incluir la plantilla de chat directamente en tu `tokenizer_config.json` archivo como un `chat_template` campo. Para ver un ejemplo, consulta [ Hermes-2-Pro ](https://huggingface.co/NousResearch/Hermes-2-Pro-Llama-3-8B/blob/main/tokenizer_config.json#L2059) tokenizer\_config.json en Hugging Face.
Custom Model Import procesará automáticamente estos archivos y los incluirá en los directorios correctos durante el proceso de importación.
#### Prioridad de las plantillas de chat
Si proporciona varias fuentes de plantillas de chat, Amazon Bedrock aplica las siguientes reglas de prioridad:
1. **Los archivos de plantillas de chat independientes tienen prioridad**: si incluyes un archivo (`chat_template.jinja`o`chat_template.json`) de plantilla de chat independiente y un `chat_template` campo en el tuyo`tokenizer_config.json`, se utilizará el archivo independiente y se ignorará la plantilla incrustada. `tokenizer_config.json`
1. **Plantilla incrustada como alternativa**: si no proporciona un archivo de plantilla de chat independiente, Amazon Bedrock utilizará el `chat_template` campo del suyo`tokenizer_config.json`, si lo tiene.
**aviso**
**Elija un enfoque: ** para evitar confusiones y garantizar un comportamiento predecible, le recomendamos encarecidamente que utilice solo UNO de estos enfoques:
**Opción 1: ** proporciona archivos de plantilla de chat independientes (`chat_template.jinja`o`chat_template.json`) sin incluir ningún `chat_template` campo en tu`tokenizer_config.json`.
**Opción 2: ** Incluye el `chat_template` campo directamente en tu plantilla `tokenizer_config.json` y no proporciones archivos de plantilla independientes.
Si tiene plantillas de herramientas personalizadas o configuraciones complejas de plantillas de chat, le recomendamos que utilice la opción 2 (incrustar la plantilla`tokenizer_config.json`), ya que le permite definir varias plantillas con nombre (como «default» y «tool\_use») en un único archivo de configuración.
**nota**
El archivo de plantilla de chat debe seguir el formato de Hugging Face y las convenciones de nomenclatura. Asegúrate de que tu plantilla sea compatible con la Transformers biblioteca.
#### Ejemplos de formatos de plantillas de chat
Estos son algunos ejemplos de los dos formatos de plantillas de chat compatibles:
------
#### [ Jinja Format (chat\_template.jinja) ]
Un ejemplo simplificado de una plantilla de Jinja2-based chat:
```
{% for message in messages %}
{% if loop.first and message['role'] != 'system' %}
<|im_start|>system
You are a helpful assistant.<|im_end|>
{% endif %}
<|im_start|>{{ message['role'] }}
{{ message['content'] }}<|im_end|>
{% endfor %}
{% if add_generation_prompt %}
<|im_start|>assistant
{% endif %}
```
Para ver un ejemplo completo, consulta la plantilla de [GPT-OSS chat ](https://huggingface.co/openai/gpt-oss-20b/blob/main/chat_template.jinja) en Hugging Face.
------
#### [ JSON Format (chat\_template.json) ]
Un ejemplo simplificado de una plantilla de JSON-based chat con soporte visual:
```
{
"chat_template": "{% for message in messages %}{% if loop.first and message['role'] != 'system' %}<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n{% endif %}<|im_start|>{{ message['role'] }}\n{% if message['content'] is string %}{{ message['content'] }}<|im_end|>\n{% else %}{% for content in message['content'] %}{% if content['type'] == 'image' %}<|vision_start|><|image_pad|><|vision_end|>{% elif 'text' in content %}{{ content['text'] }}{% endif %}{% endfor %}<|im_end|>\n{% endif %}{% endfor %}{% if add_generation_prompt %}<|im_start|>assistant\n{% endif %}"
}
```
Para ver un ejemplo completo con soporte multimodal, consulta la plantilla de [Qwen2-VL chat ](https://huggingface.co/Qwen/Qwen2-VL-72B-Instruct/blob/main/chat_template.json) en Hugging Face.
------
**importante**
Asegúrate de que tu archivo de plantilla de chat siga exactamente la convención de nomenclatura (`chat_template.jinja`o`chat_template.json`) y el formato que se muestran en los ejemplos anteriores. Las plantillas con un formato incorrecto pueden provocar errores de importación o inferencia.
## Invocar modelos con plantillas de chat personalizadas
Una vez que haya importado un modelo con una plantilla de chat personalizada, tiene dos opciones para invocar el modelo con entradas de conversación con el formato correcto:
### Uso de la API OpenAI con Messages ChatCompletion
Si estás proporcionando entradas en el formato del esquema de mensajes, debes usar la API de ** OpenAI ChatCompletion . ** Cuando utilice este formato de API con un modelo que tenga una plantilla de chat cargada (`chat_template.jinja`o`chat_template.json`), Amazon Bedrock convertirá automáticamente los mensajes introducidos al formato correcto mediante la plantilla de chat.
Este es el enfoque recomendado, ya que proporciona la integración más fluida y permite a Amazon Bedrock gestionar la aplicación de la plantilla de chat de forma automática.
**Ejemplo: uso de la ChatCompletion API OpenAI con una plantilla de chat personalizada **
```
import json
import boto3
# Initialize Bedrock Runtime client
client = boto3.client('bedrock-runtime', region_name='us-east-1')
# Define the model ARN for your imported model with custom chat template
model_id = 'arn:aws:bedrock:us-east-1:123456789012:imported-model/your-model-id'
# Prepare the request payload using messages format
payload = {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello, how are you?"
}
],
"max_tokens": 150,
"temperature": 0.7
}
# Invoke the model
response = client.invoke_model(
modelId=model_id,
body=json.dumps(payload),
accept='application/json',
contentType='application/json'
)
# Parse and display the response
response_body = json.loads(response['body'].read())
print(json.dumps(response_body, indent=2))
```
En este ejemplo, Amazon Bedrock aplicará automáticamente su plantilla de chat personalizada a la matriz de mensajes y la convertirá al formato adecuado para su modelo.
### Enfoque de tokenización manual
Como alternativa, si prefieres tener el control total sobre la aplicación de la plantilla de chat y el proceso de tokenización, puedes aplicar manualmente la plantilla de chat a tu conversación y, a continuación, usar la API de ** finalización ** (no ChatCompletion) con el texto preformateado.
Este enfoque es útil cuando necesitas personalizar la lógica de la aplicación de la plantilla o cuando trabajas con requisitos de tokenización especializados.
#### Paso 1: Aplica la plantilla de chat localmente
Usa el siguiente fragmento de código para cargar tu plantilla de chat personalizada y aplicarla a una conversación de forma local:
```
from transformers import AutoTokenizer
# Configuration paths - update these with your actual paths
TOKENIZER_PATH = "" # Path to tokenizer directory
# Load tokenizer with updated chat template
tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_PATH)
# Test chat template with sample conversation
chat_history = [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Hello, how are you?"},
]
# Apply chat template and display formatted output to make sure chat template works as expected
formatted_chat = tokenizer.apply_chat_template(chat_history, tokenize=False)
print(formatted_chat)
```
Este código muestra cómo:
1. Cargue la configuración de su tokenizador desde los archivos del modelo
1. Agregue la plantilla de chat personalizada a la configuración del tokenizador
1. Aplica la plantilla de chat a un historial de conversaciones
1. Genere el texto formateado que se puede enviar al modelo
#### Paso 2: Invocar con la API de finalización
Después de aplicar la plantilla de chat localmente, usa el texto formateado con la API de finalización:
```
import json
import boto3
# Initialize Bedrock Runtime client
client = boto3.client('bedrock-runtime', region_name='us-east-1')
# Define the model ARN for your imported model
model_id = 'arn:aws:bedrock:us-east-1:123456789012:imported-model/your-model-id'
# Use the formatted_chat output from Step 1 as the prompt
payload = {
"prompt": formatted_chat,
"max_tokens": 150,
"temperature": 0.7
}
# Invoke the model using Completion format (not ChatCompletion)
response = client.invoke_model(
modelId=model_id,
body=json.dumps(payload),
accept='application/json',
contentType='application/json'
)
# Parse and display the response
response_body = json.loads(response['body'].read())
print(json.dumps(response_body, indent=2))
```
**aviso**
**Utilice siempre el `max_tokens` parámetro: ** cuando utilice la API de finalización con importaciones de modelos personalizados, utilice siempre el `max_tokens` parámetro para garantizar la compatibilidad del esquema de finalización de OpenAI. Esto evita cualquier confusión en la traducción y garantiza un comportamiento uniforme en las diferentes implementaciones del SDK. No utilices nombres de parámetros similares o variantes similares `max_gen_len` para cada modelo.
**importante**
Cuando utilices el enfoque de tokenización manual, debes usar el formato de la API de ** finalización (con `prompt` campo), no el ** formato de la ChatCompletion API (con campo). `messages` La ChatCompletion API espera recibir mensajes sin procesar e intentará volver a aplicar la plantilla de chat, lo que generará un formato incorrecto.
### Prácticas recomendadas
+ **Utilice la ChatCompletion API siempre que sea posible**: la ChatCompletion API OpenAI con formato de mensajes proporciona la experiencia más fluida y permite a Amazon Bedrock gestionar automáticamente la aplicación de las plantillas de chat.
+ **Valide su plantilla de chat**: antes de importar su modelo, pruebe la plantilla de chat localmente con la Transformers biblioteca para asegurarse de que produce el formato de salida esperado.
+ **Incluye todos los identificadores especiales**: asegúrate de que tu plantilla de chat incluya todos los identificadores especiales necesarios (como los marcadores de inicio y fin de secuencia y de rol) que tu modelo espera.
+ **Prueba con conversaciones de varios turnos**: comprueba que tu plantilla de chat gestione correctamente las conversaciones de varios turnos con mensajes alternos del usuario y del asistente.
+ **Considera el soporte visual**: si tu modelo admite entradas multimodales, asegúrate de que tu plantilla de chat incluya una lógica para gestionar los marcadores de contenido de imágenes y vídeos.
**aviso**
Las plantillas de chat con un formato incorrecto pueden provocar un rendimiento deficiente del modelo, resultados inesperados o errores de inferencia. Pruebe siempre minuciosamente su plantilla de chat antes de implementarla en producción.