# Bases du chat

Les modèles de chat sont des modèles conversationnels auxquels vous pouvez envoyer un message et recevoir une réponse. La plupart des modèles de langage depuis la mi-2023 sont des modèles de chat et peuvent être désignés comme des modèles « instruct » ou « instruction-tuned ». Les modèles qui ne prennent pas en charge le chat sont souvent appelés modèles « base » ou « pretrained ».

Les modèles plus volumineux et plus récents sont généralement plus performants, mais les modèles spécialisés dans certains domaines (textes médicaux, juridiques, langues non anglaises, etc.) peuvent souvent surpasser ces modèles plus volumineux. Essayez des classements comme [OpenLLM](https://hf.co/spaces/HuggingFaceH4/open_llm_leaderboard) et [LMSys Chatbot Arena](https://chat.lmsys.org/?leaderboard) pour vous aider à identifier le meilleur modèle pour votre cas d'usage.

Ce guide vous montre comment charger rapidement des modèles de chat dans Transformers depuis la ligne de commande, comment construire et formater une conversation, et comment discuter à l’aide de [TextGenerationPipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.TextGenerationPipeline).

## CLI de chat

Après avoir [installé Transformers](./installation), vous pouvez discuter avec un modèle directement depuis la ligne de commande. La commande ci-dessous lance une session interactive avec un modèle, et affiche quelques commandes de base au début de la session.

> Pour les commandes suivantes, assurez-vous que [`transformers serve` est en cours d'exécution](./serve-cli/serving).

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

    

Vous pouvez lancer le CLI avec des drapeaux `generate` arbitraires, au format `arg_1=value_1 arg_2=value_2 ...`

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

Pour obtenir la liste complète des options, exécutez la commande ci-dessous.

```bash
transformers chat -h
```

Le chat est implémenté au-dessus de la [AutoClass](./model_doc/auto), en utilisant les outils de [text generation](./llm_tutorial) et de [chat](./chat_templating). Il utilise le CLI `transformers serve` en interne ([docs](./serve-cli/serving)).

## TextGenerationPipeline

[TextGenerationPipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.TextGenerationPipeline) est une classe de génération de texte de haut niveau dotée d'un « mode conversation ». Ce mode est activé lorsqu'un modèle conversationnel est détecté et que le prompt de conversation est [correctement formaté](./llm_tutorial#prompt-format).

Les modèles de chat acceptent une liste de messages (l’historique de la conversation) en entrée. Chaque message est un dictionnaire avec les clés `role` et `content`. Pour démarrer la conversation, ajoutez un seul message `user`. Vous pouvez également inclure, en option, un message `system` pour indiquer au modèle comment se comporter.

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

Créez le [TextGenerationPipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.TextGenerationPipeline) et passez-lui `chat`. Pour les grands modèles, définir [device_map="auto"](./models#big-model-inference) aide à charger le modèle plus rapidement et le place automatiquement sur l’appareil le plus rapide 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 cela fonctionne correctement, vous devriez voir une réponse du modèle ! Si vous souhaitez poursuivre la conversation, vous devez mettre à jour l’historique de la discussion avec la réponse du modèle. Vous pouvez le faire en ajoutant le texte à `chat` (en utilisant le rôle `assistant`), ou en lisant `response[0]["generated_text"]`, qui contient l’historique complet de la discussion, y compris la réponse la plus récente.

Une fois que vous avez la réponse du modèle, vous pouvez poursuivre la conversation en ajoutant un nouveau message `user` à l’historique de la conversation.

```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"])
```

En répétant ce processus, vous pouvez poursuivre la conversation aussi longtemps que vous le souhaitez, du moins jusqu’à ce que le modèle épuise sa fenêtre de contexte ou que votre mémoire soit insuffisante.

## Performance et utilisation de la mémoire

Transformers charge les modèles en précision `float32` par défaut, et pour un modèle de 8B, cela nécessite environ 32 Go de mémoire ! Utilisez l'argument `torch_dtype="auto"`, qui utilise généralement `bfloat16` pour les modèles entraînés avec ce format, afin de réduire votre consommation de mémoire.

> [!TIP]
> Consultez la documentation [Quantization](./quantization/overview) pour plus d'informations sur les différents backends de quantification disponibles.

Pour réduire encore davantage la consommation de mémoire, vous pouvez quantifier le modèle en 8 bits ou 4 bits avec [bitsandbytes](https://hf.co/docs/bitsandbytes/index). Créez un [BitsAndBytesConfig](/docs/transformers/main/fr/main_classes/quantization#transformers.BitsAndBytesConfig) avec les paramètres de quantification souhaités et transmettez-le au paramètre `model_kwargs` des pipelines. L'exemple ci-dessous quantifie un modèle en 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 général, la taille d’un modèle et ses performances sont directement corrélées. Les modèles plus grands sont plus lents et nécessitent davantage de mémoire, car chaque paramètre actif doit être lu depuis la mémoire pour chaque jeton généré. C’est un goulot d’étranglement pour la génération de texte par LLM, et les principales options pour améliorer la vitesse de génération consistent à soit quantifier un modèle, soit utiliser du matériel offrant une bande passante mémoire plus élevée. Ajouter de la puissance de calcul n’apporte pas d’amélioration significative.

Vous pouvez également essayer des techniques comme le [décodage spéculatif](./assisted_decoding#speculative-decoding), où un modèle plus petit génère des jetons candidats qui sont vérifiés par le modèle plus grand. Si les jetons candidats sont corrects, le modèle plus grand peut générer plus d'un jeton à la fois. Cela atténue considérablement le goulot d'étranglement de bande passante et améliore la vitesse de génération.

> [!TIP]
Les modèles Mixture-of-Expert (MoE) tels que [Mixtral](./model_doc/mixtral), [Qwen2MoE](./model_doc/qwen2_moe) et [GPT-OSS](./model_doc/gpt_oss) possèdent un grand nombre de paramètres, mais n'« activent » qu'une petite fraction d'entre eux pour générer chaque jeton. En conséquence, les modèles MoE présentent généralement des besoins en bande passante mémoire beaucoup plus faibles et peuvent être plus rapides qu'un LLM classique de taille équivalente. Toutefois, des techniques comme le décodage spéculatif sont inefficaces avec les modèles MoE, car un plus grand nombre de paramètres est activé à chaque nouveau jeton spéculé.