Transformers documentation
Plantillas de chat
Plantillas de chat
La guía de conceptos básicos del chat explica cómo almacenar historiales de chat y generar texto desde modelos de chat mediante TextGenerationPipeline.
Esta guía está destinada a usuarios más avanzados y cubre las clases y métodos subyacentes, así como los conceptos clave para comprender lo que realmente ocurre cuando chateas con un modelo.
La idea clave para entender los modelos de chat es la siguiente: todos los LM causales, ya sean entrenados para chat o no, continúan una secuencia de tokens. Cuando se entrenan los LM causales, el proceso suele comenzar con un “pre-entrenamiento” sobre un corpus de texto masivo, lo que crea un modelo “base”.
A continuación, estos modelos base suelen “ajustarse” (fine-tuning) para chat, lo que significa entrenarlos con datos formateados como una secuencia de mensajes. ¡Aun así, el chat sigue siendo solo una secuencia de tokens! La lista de diccionarios role y content que se pasan
a un modelo de chat se convierte en una secuencia de tokens, a menudo con tokens de control como <|user|> o <|assistant|> o <|end_of_message|>, que permiten al modelo ver la estructura del chat.
Existen muchos formatos de chat posibles, y diferentes modelos pueden usar formatos o tokens de control distintos, ¡incluso si fueron ajustados a partir del mismo modelo base!
No entres en pánico: no necesitas memorizar todos los posibles formatos de chat para usar modelos de chat. Los modelos de chat incluyen plantillas de chat, que indican cómo esperan que se formateen los chats.
Puedes acceder a estas plantillas con el método apply_chat_template. Veamos dos ejemplos. Ambos modelos están afinados a partir del mismo modelo base Mistral-7B:
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1")
chat = [
{"role": "user", "content": "Hello, how are you?"},
{"role": "assistant", "content": "I'm doing great. How can I help you today?"},
{"role": "user", "content": "I'd like to show off how chat templating works!"},
]
tokenizer.apply_chat_template(chat, tokenize=False)<s>[INST] Hello, how are you? [/INST]I'm doing great. How can I help you today?</s> [INST] I'd like to show off how chat templating works! [/INST]from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("HuggingFaceH4/zephyr-7b-beta")
chat = [
{"role": "user", "content": "Hello, how are you?"},
{"role": "assistant", "content": "I'm doing great. How can I help you today?"},
{"role": "user", "content": "I'd like to show off how chat templating works!"},
]
tokenizer.apply_chat_template(chat, tokenize=False)<|user|>\nHello, how are you?</s>\n<|assistant|>\nI'm doing great. How can I help you today?</s>\n<|user|>\nI'd like to show off how chat templating works!</s>\nMistral-7B-Instruct utiliza los tokens [INST] y [/INST] para indicar el inicio y el final de los mensajes del usuario, mientras que Zephyr-7B utiliza los tokens <|user|> y <|assistant|> para indicar los roles de los hablantes. Por eso las plantillas de chat son importantes: con los tokens de control incorrectos, estos modelos tendrían un rendimiento mucho peor.
Usando apply_chat_template
La entrada de apply_chat_template debe estructurarse como una lista de diccionarios con las claves role y content. La clave role especifica el hablante y la clave content contiene el mensaje. Los roles comunes son:
userpara mensajes del usuarioassistantpara los mensajes del modelosystempara las directrices sobre cómo debe actuar el modelo (generalmente se coloca al principio del chat)
apply_chat_template toma esta lista y devuelve una secuencia formateada. Establece tokenize=True si deseas tokenizar la secuencia.
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("HuggingFaceH4/zephyr-7b-beta")
model = AutoModelForCausalLM.from_pretrained("HuggingFaceH4/zephyr-7b-beta", device_map="auto", dtype=torch.bfloat16)
messages = [
{"role": "system", "content": "You are a friendly chatbot who always responds in the style of a pirate",},
{"role": "user", "content": "How many helicopters can a human eat in one sitting?"},
]
tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
print(tokenizer.decode(tokenized_chat["input_ids"][0]))<|system|>
You are a friendly chatbot who always responds in the style of a pirate</s>
<|user|>
How many helicopters can a human eat in one sitting?</s>
<|assistant|>Pasa el chat tokenizado a generate() para generar una respuesta.
outputs = model.generate(**tokenized_chat, max_new_tokens=128)
print(tokenizer.decode(outputs[0]))<|system|>
You are a friendly chatbot who always responds in the style of a pirate</s>
<|user|>
How many helicopters can a human eat in one sitting?</s>
<|assistant|>
Matey, I'm afraid I must inform ye that humans cannot eat helicopters. Helicopters are not food, they are flying machines. Food is meant to be eaten, like a hearty plate o' grog, a savory bowl o' stew, or a delicious loaf o' bread. But helicopters, they be for transportin' and movin' around, not for eatin'. So, I'd say none, me hearties. None at all.Algunos tokenizadores añaden tokens especiales
<bos>y<eos>. Las plantillas de chat ya deben incluir todos los tokens especiales necesarios, y añadir tokens especiales adicionales suele ser incorrecto o redundante, lo que perjudica el rendimiento del modelo. Al formatear texto conapply_chat_template(tokenize=False), asegúrate de estableceradd_special_tokens=Falsesi vas a tokenizar después para evitar duplicar estos tokens. Esto no es un problema si usasapply_chat_template(tokenize=True), lo que significa que suele ser la opción más segura.
add_generation_prompt
Es posible que hayas notado el argumento add_generation_prompt en los ejemplos anteriores.
Este argumento añade tokens al final del chat que indican el inicio de una respuesta de assistant. Recuerda: debajo de todas las abstracciones de chat, los modelos de chat siguen siendo modelos de lenguaje que continúan una secuencia de tokens.
Si incluyes tokens que le indican que ahora está en una respuesta de assistant, escribirá una respuesta correctamente, pero si no incluyes estos tokens, el modelo puede confundirse y hacer algo extraño, como continuar el mensaje del usuario en lugar de responderle.
Veamos un ejemplo para entender lo que realmente hace add_generation_prompt. Primero, formateemos un chat sin add_generation_prompt:
tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
tokenized_chat<|im_start|>user
Hi there!<|im_end|>
<|im_start|>assistant
Nice to meet you!<|im_end|>
<|im_start|>user
Can I ask a question?<|im_end|>Ahora, formateemos el mismo chat con add_generation_prompt=True:
tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
tokenized_chat<|im_start|>user
Hi there!<|im_end|>
<|im_start|>assistant
Nice to meet you!<|im_end|>
<|im_start|>user
Can I ask a question?<|im_end|>
<|im_start|>assistant
Cuando add_generation_prompt=True, se añade <|im_start|>assistant al final para indicar el inicio de un mensaje de assistant. Esto permite que el modelo sepa que la siguiente respuesta será de assistant.
No todos los modelos requieren prompts de generación, y algunos modelos, como Llama, no tienen tokens especiales antes de la respuesta de assistant. En estos casos, add_generation_prompt no tiene efecto.
continue_final_message
El parámetro continue_final_message controla si el mensaje final del chat debe continuarse o no, en lugar de iniciar uno nuevo. Elimina los tokens de fin de secuencia para que el modelo continúe la generación desde el mensaje final.
Esto es útil para “prellenar” la respuesta de un modelo. En el ejemplo siguiente, el modelo genera texto que continúa la cadena JSON en lugar de iniciar un nuevo mensaje. Puede ser muy útil para mejorar la precisión en el seguimiento de instrucciones cuando se sabe cómo iniciar sus respuestas.
chat = [
{"role": "user", "content": "Can you format the answer in JSON?"},
{"role": "assistant", "content": '{"name": "'},
]
formatted_chat = tokenizer.apply_chat_template(chat, tokenize=True, return_dict=True, continue_final_message=True)
model.generate(**formatted_chat)No se deben usar add_generation_prompt y continue_final_message juntos. El primero añade tokens que inician un nuevo mensaje, mientras que el segundo elimina los tokens de fin de secuencia. Usarlos juntos devuelve un error.
Pase un nombre de campo como cadena para precargar ese campo en lugar de content. Los modelos de razonamiento leen su razonamiento de un campo separado reasoning_content. Precargar content cierra el bloque de razonamiento antes de que comience la generación, por lo que el modelo no puede continuar dentro de él. Precargar reasoning_content directamente deja el bloque abierto.
chat = [
{"role": "user", "content": "Explain 1+1"},
{"role": "assistant", "reasoning_content": "The user wants a simple addition. ", "content": ""},
]
formatted_chat = tokenizer.apply_chat_template(chat, tokenize=False, continue_final_message="reasoning_content")El campo con nombre debe existir en el mensaje final y debe ser referenciado por la plantilla de chat. Se genera un error si alguna de estas comprobaciones falla.
TextGenerationPipeline establece add_generation_prompt en True de forma predeterminada para iniciar un nuevo mensaje. Sin embargo, si el mensaje final del chat tiene el rol assistant, asume que el mensaje es un prefill y cambia a continue_final_message=True. Esto se debe a que la mayoría de los modelos no admiten varios mensajes consecutivos de asistente. Para anular este comportamiento, pase explícitamente el argumento continue_final_message a la pipeline.
Entrenamiento de modelos
Entrenar un modelo con una plantilla de chat es una buena manera de garantizar que la plantilla coincida con los tokens en los que se entrenó el modelo. Aplique la plantilla de chat como un paso de preprocesamiento a su conjunto de datos. Establezca add_generation_prompt=False porque los tokens adicionales para solicitar una respuesta del asistente no son útiles durante el entrenamiento.
A continuación se muestra un ejemplo de preprocesamiento de un conjunto de datos con una plantilla de chat.
from transformers import AutoTokenizer
from datasets import Dataset
tokenizer = AutoTokenizer.from_pretrained("HuggingFaceH4/zephyr-7b-beta")
chat1 = [
{"role": "user", "content": "Which is bigger, the moon or the sun?"},
{"role": "assistant", "content": "The sun."}
]
chat2 = [
{"role": "user", "content": "Which is bigger, a virus or a bacterium?"},
{"role": "assistant", "content": "A bacterium."}
]
dataset = Dataset.from_dict({"chat": [chat1, chat2]})
dataset = dataset.map(lambda x: {"formatted_chat": tokenizer.apply_chat_template(x["chat"], tokenize=False, add_generation_prompt=False)})
print(dataset['formatted_chat'][0])<|user|>
Which is bigger, the moon or the sun?</s>
<|assistant|>
The sun.</s>Después de este paso, puedes continuar siguiendo la receta de entrenamiento para modelos de lenguaje causales utilizando la columna formatted_chat.