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.
# Manejo de plantillas de chat y tokenizadores personalizados
Las plantillas de chat y los tokenizadores personalizados son componentes esenciales para formatear correctamente las entradas de conversación y gestionar la generación de tokens en los modelos importados. Custom Model Import permite importar modelos con plantillas de chat personalizadas que definen cómo se estructuran y se tokenizan las conversaciones en 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 mejores prácticas descritas en la documentación principal de importación de modelos personalizados, incluida la introducción de los pesos de los modelos en un formato de tensores seguros y el suministro de todos los archivos de configuración necesarios.
### Requisitos de formato de la plantilla de chat
Si su modelo usa una plantilla de chat personalizada y quiere usarla con Amazon Bedrock, debe incluir el archivo de plantilla de chat en uno de los siguientes formatos:
+ **`chat_template.jinja`**— Un archivo de plantilla basado en JinjA2 que define el formato de 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 el [tokenizer\$1config.json de Hermes-2-Pro](https://huggingface.co/NousResearch/Hermes-2-Pro-Llama-3-8B/blob/main/tokenizer_config.json#L2059) en Hugging Face.
Custom Model Import procesará automáticamente estos archivos y los incluirá en los directorios correctos durante el proceso de importación.
#### Precedencia de la plantilla 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 incluye un archivo de plantilla de chat independiente (`chat_template.jinja`o`chat_template.json`) Y un `chat_template` campo en el suyo`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 suyo `tokenizer_config.json` si está presente.
**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 separados (`chat_template.jinja`o`chat_template.json`) sin incluir un `chat_template` campo en el tuyo`tokenizer_config.json`.
**Opción 2:** incluye el `chat_template` campo directamente en tu plantilla `tokenizer_config.json` y no proporciones archivos de plantilla separados.
Si tiene plantillas de herramientas personalizadas o configuraciones de plantillas de chat complejas, le recomendamos que utilice la opción 2 (incrustar la plantilla`tokenizer_config.json`), ya que le permite definir varias plantillas con nombres (como «default» y «tool\$1use») en un único archivo de configuración.
**nota**
El archivo de plantilla de chat debe seguir el formato Hugging Face y las convenciones de nomenclatura. Asegúrese de que la plantilla sea compatible con la Transformers biblioteca.
#### Ejemplos de formatos de plantillas de chat
Estos son algunos ejemplos de los dos formatos de plantilla de chat compatibles:
------
#### [ Jinja Format (chat\$1template.jinja) ]
Un ejemplo simplificado de una plantilla de chat basada en Jinja2:
```
{% 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\$1template.json) ]
Un ejemplo simplificado de una plantilla de chat basada en JSON 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úrese de que el archivo de la 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 hayas importado un modelo con una plantilla de chat personalizada, tienes dos opciones para invocar el modelo con entradas de conversación con el formato adecuado:
### Uso de la ChatCompletion API OpenAI con mensajes
Si proporciona entradas en el formato de esquema de mensajes, debe usar la API **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 de entrada 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 plantillas de chat automáticamente.
**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 la plantilla de chat personalizada a la matriz de mensajes y la convertirá en el 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 luego usar la **API de finalización** (no ChatCompletion) con el texto preformateado.
Este enfoque resulta útil cuando se necesita personalizar la lógica de la aplicación de la plantilla o cuando se trabaja con requisitos de tokenización especializados.
#### Paso 1: Aplicar 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 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 del tokenizador desde los archivos del modelo
1. Añada 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: Invoca con la API de finalización
Después de aplicar la plantilla de chat de forma local, 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 coherente en las diferentes implementaciones del SDK. No utilices nombres de parámetros específicos del modelo `max_gen_len` ni variantes similares.
**importante**
Si utiliza el enfoque de tokenización manual, debe utilizar el formato **API de finalización** (con `prompt` campo), no el formato ChatCompletion API (con campo). `messages` La ChatCompletion API espera mensajes sin procesar e intentará volver a aplicar la plantilla de chat, lo que dará como resultado 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 plantillas de chat.
+ **Valide su plantilla de chat**: antes de importar su modelo, pruebe la plantilla de chat localmente utilizando la Transformers biblioteca para asegurarse de que produce el formato de salida esperado.
+ **Incluye todas las fichas especiales**: asegúrate de que tu plantilla de chat incluya todas las fichas especiales necesarias (como beginning-of-sequence end-of-sequence, y marcadores de roles) que tu modelo espera.
+ **Pruebe con conversaciones en varios turnos**: compruebe que su plantilla de chat gestiona correctamente las conversaciones en varios turnos con mensajes alternos entre el usuario y el asistente.
+ **Considere la compatibilidad visual**: si su modelo admite entradas multimodales, asegúrese de que la plantilla de chat incluya una lógica para gestionar los marcadores de contenido de imagen y vídeo.
**aviso**
Las plantillas de chat con un formato incorrecto pueden provocar un rendimiento deficiente del modelo, resultados inesperados o errores en las inferencias. Pruebe siempre minuciosamente la plantilla de chat antes de ponerla en producción.