Fine-tuning de LLM pour créer des personnalités d'IA : tutoriel en Python (2026)

Tu demandes à ChatGPT d'écrire « avec ta voix » et il te sort trois paragraphes génériques. Tu lui colles un prompt de 800 mots avec des exemples et des règles, et dès la quatrième réponse il en a oublié la moitié. Le problème, ce n'est pas que le modèle soit mauvais. C'est que tu demandes à la forme quelque chose qui se règle dans les poids.

C'est ça, le fine-tuning : arrêter d'expliquer au modèle comment parler à chaque prompt et le lui apprendre une bonne fois, en l'entraînant avec des exemples de ton style jusqu'à ce que la voix lui vienne par défaut. C'est l'outil qu'il faut pour construire une personnalité d'IA propre. Et en 2026, tu n'as plus besoin d'un cluster ni d'un master : ça tient sur un seul GPU. On va monter ça sans fumée.

Qu'est-ce que le fine-tuning (et quand OUI et quand NON)

Un modèle de base comme Llama ou Qwen arrive déjà pré-entraîné avec la moitié d'internet. Le fine-tuning ne part pas de zéro : il prend ce modèle et continue de l'entraîner avec tes exemples pour l'orienter vers un comportement précis. Ce n'est pas de la magie, c'est de l'ajustement de poids.

L'idée clé que presque personne ne te dit clairement : le fine-tuning est pour la FORME, pas pour les données. Il sert à changer comment ça sonne, comment la sortie est structurée et quel vocabulaire est utilisé. Il ne sert pas à lui injecter une information qui change chaque semaine — ça se glisse dans une faille de connaissance que le fine-tuning couvre mal.

Les modèles de pointe de 2026 continuent d'échouer sur trois choses que le fine-tuning règle à la racine :

• Schéma de sortie exact : qu'il renvoie toujours le même JSON, le même format, sans dévier.
• Vocabulaire de domaine étroit : le jargon de ton secteur, tes termes, tes conventions.
• Voix de marque : ce ton précis qui, à coups de prompts, se dilue de réponse en réponse.

Ce troisième point est justement le cœur de la création d'une personnalité d'IA. Une voix cohérente ne tient pas à force de prompts de plus en plus longs ; elle s'entraîne une fois et elle reste.

Quand ça vaut le coup :

• Tu as une tâche stable avec une sortie prévisible (un ton, un format).
• Tu as testé le prompting et le RAG et le modèle a plafonné.
• Tu as (ou peux réunir) plus de 500 bons exemples cohérents.

Quand NON :

• Tu as besoin que le modèle connaisse des faits précis et à jour → c'est le RAG.
• Ton cas change tout le temps → réentraîner chaque semaine ne passe pas à l'échelle.
• Tu n'as pas encore testé à fond un bon prompt → commence par là, c'est gratuit et réversible.

Le processus de fine-tuning, d'un coup d'œil

Avant le code, la carte. Voici les six étapes que tu parcourras toujours, quel que soit l'outil :

Remarque que l'entraînement n'est qu'une étape sur six, et même pas la plus importante. Les étapes 1 et 2 — les données — décident 80 % du résultat. On le répétera jusqu'à l'ennui.

Pas à pas avec du code (Python + Unsloth)

On va utiliser Unsloth, qui en 2026 est la voie la plus rapide pour entraîner sur un seul GPU : ses kernels optimisés réduisent l'usage mémoire jusqu'à 74 % et accélèrent l'entraînement de 2 à 5 fois par rapport à Hugging Face Transformers brut. Ça marche sur le GPU gratuit de Google Colab. Si tu préfères des pipelines pilotés par config en YAML sans écrire de Python, Axolotl fait la même chose avec un fichier de configuration ; et en dessous, les deux s'appuient sur l'écosystème Hugging Face.

1. Installer l'environnement

pip install unsloth
pip install --no-deps trl peft accelerate bitsandbytes

2. Charger le modèle de base en 4 bits (QLoRA)

On charge un petit modèle de base quantisé en 4 bits pour qu'il tienne dans peu de VRAM, et on lui branche les adaptateurs LoRA.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
  model_name = "unsloth/Meta-Llama-3.1-8B-Instruct",
  max_seq_length = 2048,
  load_in_4bit = True,   # QLoRA : quantise le base en 4 bits
)

model = FastLanguageModel.get_peft_model(
  model,
  r = 16,                # rang de l'adaptateur LoRA (8-64 est courant)
  lora_alpha = 16,
  target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)

3. Entraîner

Avec le dataset déjà formaté (on le voit dans la section suivante), l'entraînement est standard. Peu d'époques : avec des données propres, 1 à 3 passes suffisent et sur-entraîner est un risque bien réel.

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
  model = model,
  tokenizer = tokenizer,
  train_dataset = dataset,         # ton JSONL formaté
  dataset_text_field = "text",
  max_seq_length = 2048,
  args = TrainingArguments(
      per_device_train_batch_size = 2,
      gradient_accumulation_steps = 4,
      num_train_epochs = 2,
      learning_rate = 2e-4,
      output_dir = "outputs",
  ),
)

trainer.train()

4. Inférer et exporter

Tu testes la personnalité tout juste entraînée et, si elle convainc, tu l'exportes en GGUF pour la faire tourner en local avec Ollama.

FastLanguageModel.for_inference(model)
inputs = tokenizer(["Que penses-tu du hype autour de l'IA ?"], return_tensors="pt").to("cuda")
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=128)[0]))

# Exporter pour Ollama / llama.cpp
model.save_pretrained_gguf("ma-personnalite", tokenizer, quantization_method="q4_k_m")

Les données : le dataset qui définit ta personnalité

C'est ici que se trouve le vrai travail. Le format standard de 2026 pour le fine-tuning supervisé (SFT) est le JSONL avec un tableau messages façon ChatML : chaque ligne est une conversation. Ça marche directement dans Unsloth, Axolotl et TRL sans conversions bizarres.

{"messages": [
{"role": "system", "content": "Tu es Blackdark : direct, pratique, anti-fumée. Aucun remplissage."},
{"role": "user", "content": "Ça vaut le coup de payer ChatGPT Plus ?"},
{"role": "assistant", "content": "Ça dépend de combien tu l'utilises vraiment. Si tu ouvres l'app deux fois par semaine, non. Si tu t'en sers tous les jours pour bosser, les 20 par mois sont amortis dès le premier jour. Ce qui ne vaut rien, c'est de payer au cas où."}
]}

Les règles qui comptent vraiment dans le dataset :

• Cohérence de voix : chaque réponse assistant doit sonner comme la personnalité que tu vises. Un seul exemple hors ton salit l'apprentissage.
• Le system fixe le personnage : utilise-le à l'identique dans tous les exemples. C'est l'ancre de l'identité.
• Qualité > quantité : pour le ton et le style, 500 à 2 000 exemples soignés rendent plus que 50 000 bruités. En dessous d'environ 100 lignes, n'essaie même pas.
• Variété des situations : couvre différents types de question pour que la voix tienne au-delà des exemples vus.

Coût et outils, sans surprises

La bonne nouvelle : pour un modèle de 7-8 B avec QLoRA, le calcul est quasi gratuit. Il tient dans environ 8 Go de VRAM, tu entraînes donc sur le GPU gratuit de Colab ou tu loues un GPU dans le cloud pour quelques heures. La vraie dépense n'est pas dans l'entraînement, elle est dans la préparation du dataset : c'est là que passe le temps.

Les trois outils qui dominent en 2026 :

• Unsloth — l'option si tu vises un seul GPU et que la vitesse t'importe. Kernels optimisés, moins de mémoire, plus rapide. Celui qu'on a utilisé ici.
• Axolotl — des pipelines définis dans un YAML. Tu choisis le modèle, le dataset, la méthode et les hyperparamètres dans un fichier et tu lances d'une seule commande, sans écrire de Python. Idéal pour des processus reproductibles.
• Hugging Face (Transformers + PEFT + TRL) — la base sur laquelle les deux précédents s'appuient. Plus de contrôle, plus de friction.

Sur la méthode : LoRA n'entraîne que 0,1 à 1 % des paramètres avec une qualité proche d'un réentraînement complet du modèle. QLoRA ajoute une quantisation en 4 bits et atteint autour de 90 % de la qualité d'un fine-tuning complet, à un coût matériel bien moindre. Pour créer une personnalité à la maison, QLoRA est le point idéal.

Erreurs classiques qui ruinent le résultat

• Vouloir injecter des données par le fine-tuning. L'erreur n° 1. Si tu as besoin que le modèle connaisse des faits à jour, c'est du RAG, pas du fine-tuning. Mélanger les deux concepts mène à des modèles qui hallucinent avec aplomb.
• Dataset sale ou incohérent. Exemples hors ton, formats inconstants, réponses médiocres. Le modèle apprend exactement ce que tu lui donnes, défauts inclus.
• Sur-entraîner. Trop d'époques et le modèle mémorise le dataset au lieu de généraliser ta voix. Commence par 1 à 3 passes et mesure.
• Ne pas évaluer avec des cas neufs. Si tu ne testes qu'avec des exemples présents dans l'entraînement, tu te mens à toi-même. Évalue avec des questions que le modèle n'a jamais vues.
• Sauter le prompting et le RAG. Si tu n'as pas épuisé ce qui est bon marché et réversible, tu résous par le fine-tuning quelque chose qu'un bon prompt réglait en cinq minutes.

Pour qui est le fine-tuning ?

Ce n'est pas pour tout le monde, et c'est très bien ainsi.

Ça t'intéresse si : tu construis un produit ou un agent avec une personnalité de marque propre et tu as besoin que la voix soit identique à chaque réponse ; tu as un format de sortie que le modèle de base ne respecte pas du premier coup ; tu travailles dans un domaine au jargon propre ; ou tu veux réduire le coût par requête face à d'énormes prompts que tu répètes mille fois par jour.

Ça ne t'intéresse pas si : ton problème est de connaissance et non de forme (là, c'est le RAG qui commande) ; tu n'as pas encore pressé un bon prompt système ; ou ton cas est si ponctuel que monter le pipeline coûte plus que le bénéfice.

La question honnête n'est pas « est-ce que je fais du fine-tuning ? », mais « ce qui me fait défaut, c'est la forme ou les données ? ». Si c'est la forme — le ton, la voix, le format —, le fine-tuning est le bon outil et, avec QLoRA et un dataset propre, il est à la portée d'un seul GPU. Si ce sont les données, épargne-toi l'entraînement et monte un RAG. Et si tu ne le sais pas encore, reviens au prompt : la réponse était presque toujours là.