# Básicos del chat

Los modelos de chat son modelos conversacionales a los que se puede enviar un mensaje y recibir una respuesta. La mayoría de los modelos de lenguaje desde mediados de 2023 son modelos de chat y pueden denominarse modelos "instruct" o "instruction-tuned". Los modelos que no admiten chat suelen denominarse modelos "base" o "pretrained".

Los modelos más grandes y recientes suelen ser más capaces, pero los modelos especializados en ciertos dominios (texto médico, texto legal, idiomas no ingleses, etc.) a menudo superan a estos modelos más grandes. Pruebe con tablas de clasificación como [OpenLLM](https://hf.co/spaces/HuggingFaceH4/open_llm_leaderboard) y [LMSys Chatbot Arena](https://chat.lmsys.org/?leaderboard) para ayudarle a identificar el mejor modelo para su caso de uso.

Esta guía te muestra cómo cargar rápidamente modelos de chat en Transformers desde la línea de comandos, cómo construir y formatear una conversación y cómo chatear usando [TextGenerationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TextGenerationPipeline).

## CLI de chat

Después de [instalar Transformers](./installation), puedes chatear con un modelo directamente desde la línea de comandos. El comando siguiente inicia una sesión interactiva con un modelo, y al inicio de la sesión se enumeran algunos comandos básicos.

> Para los siguientes comandos, asegúrese de que [`transformers serve` esté en ejecución](./serve-cli/serving).

```bash
transformers chat Qwen/Qwen2.5-0.5B-Instruct
```

    

Puedes iniciar la CLI con banderas `generate` arbitrarias, con el formato `arg_1=value_1 arg_2=value_2 ...`

```bash
transformers chat Qwen/Qwen2.5-0.5B-Instruct do_sample=False max_new_tokens=10
```

Para obtener la lista completa de opciones, ejecute el siguiente comando.

```bash
transformers chat -h
```

El chat se implementa sobre la [AutoClass](./model_doc/auto), utilizando herramientas de [text generation](./llm_tutorial) y [chat](./chat_templating). Utiliza la CLI `transformers serve` por debajo ([docs](./serve-cli/serving)).

## TextGenerationPipeline

[TextGenerationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TextGenerationPipeline) es una clase de alto nivel para la generación de texto con un "modo de chat". El modo de chat se activa cuando se detecta un modelo conversacional y el prompt de chat está [correctamente formateado](./llm_tutorial#prompt-format).

Los modelos de chat aceptan una lista de mensajes (el historial de la conversación) como entrada. Cada mensaje es un diccionario con las claves `role` y `content`. Para iniciar el chat, añade un único mensaje de `user`. También puedes incluir opcionalmente un mensaje de `system` para darle al modelo instrucciones sobre cómo debe comportarse.

```py
chat = [
    {"role": "system", "content": "You are a helpful science assistant."},
    {"role": "user", "content": "Hey, can you explain gravity to me?"}
]
```

Crea el [TextGenerationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TextGenerationPipeline) y pásale `chat`. Para modelos grandes, establecer [device_map="auto"](./models#big-model-inference) ayuda a cargar el modelo más rápido y lo coloca automáticamente en el dispositivo más rápido disponible.

```py
import torch
from transformers import pipeline

pipeline = pipeline(task="text-generation", model="HuggingFaceTB/SmolLM2-1.7B-Instruct", dtype="auto", device_map="auto")
response = pipeline(chat, max_new_tokens=512)
print(response[0]["generated_text"][-1]["content"])
```

Si funciona correctamente, ¡deberías ver una respuesta del modelo! Si deseas continuar la conversación, necesitas actualizar el historial de chat con la respuesta del modelo. Puedes hacerlo agregando el texto a `chat` (usando el rol `assistant`) o leyendo `response[0]["generated_text"]`, que contiene el historial completo de la conversación, incluida la respuesta más reciente.

Una vez que tengas la respuesta del modelo, puedes continuar la conversación añadiendo un nuevo mensaje de `user` al historial del chat.

```py
chat = response[0]["generated_text"]
chat.append(
    {"role": "user", "content": "Woah! But can it be reconciled with quantum mechanics?"}
)
response = pipeline(chat, max_new_tokens=512)
print(response[0]["generated_text"][-1]["content"])
```

Al repetir este proceso, puedes continuar la conversación todo el tiempo que desees, al menos hasta que el modelo se quede sin ventana de contexto o se agote la memoria.

## Rendimiento y uso de memoria

Transformers carga los modelos en precisión `float32` de forma predeterminada, y para un modelo de 8B, esto requiere ~32GB de memoria. Utiliza el argumento `torch_dtype="auto"`, que generalmente usa `bfloat16` para modelos que fueron entrenados con él, para reducir el uso de memoria.

> [!TIP]
> Consulte la documentación de [Quantization](./quantization/overview) para obtener más información sobre los diferentes backends de cuantización disponibles.

Para reducir aún más el uso de memoria, puedes cuantizar el modelo a 8 bits o 4 bits con [bitsandbytes](https://hf.co/docs/bitsandbytes/index). Crea una [BitsAndBytesConfig](/docs/transformers/v5.23.0/es/main_classes/quantization#transformers.BitsAndBytesConfig) con la configuración de cuantización deseada y pásala al parámetro `model_kwargs` de los pipelines. El ejemplo siguiente cuantiza un modelo a 8 bits.

```py
from transformers import pipeline, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)
pipeline = pipeline(task="text-generation", model="meta-llama/Meta-Llama-3-8B-Instruct", device_map="auto", model_kwargs={"quantization_config": quantization_config})
```

En general, el tamaño del modelo y su rendimiento están directamente correlacionados. Los modelos más grandes son más lentos y, además, requieren más memoria, ya que cada parámetro activo debe leerse desde la memoria para cada token generado. Esto es un cuello de botella para la generación de texto con LLM y las principales opciones para mejorar la velocidad de generación son cuantizar un modelo o usar hardware con mayor ancho de banda de memoria. Añadir más potencia de cómputo no ayuda de manera significativa.

También puede probar técnicas como [decodificación especulativa](./assisted_decoding#speculative-decoding), en las que un modelo más pequeño genera tokens candidatos que son verificados por el modelo más grande. Si los tokens candidatos son correctos, el modelo más grande puede generar más de un token a la vez. Esto alivia significativamente el cuello de botella de ancho de banda y mejora la velocidad de generación.

> [!TIP]
Los modelos Mixture-of-Expert (MoE), como [Mixtral](./model_doc/mixtral), [Qwen2MoE](./model_doc/qwen2_moe) y [GPT-OSS](./model_doc/gpt_oss), tienen muchos parámetros, pero solo "activan" una pequeña fracción de ellos para generar cada token. Como resultado, los modelos MoE generalmente tienen requisitos mucho menores de ancho de banda de memoria y pueden ser más rápidos que un LLM regular del mismo tamaño. Sin embargo, técnicas como la decodificación especulativa no son eficaces con los modelos MoE, ya que se activan más parámetros con cada nuevo token especulado.

