L’affinage (fine-tuning) reprend un modèle déjà entraîné et poursuit son entraînement sur quelques centaines ou milliers de vos propres exemples. Le modèle n’apprend pas une nouvelle langue ni un nouveau savoir encyclopédique : il prend une habitude. Il répond dans un format précis, adopte un ton, maîtrise une tâche étroite mieux qu’avant.
Pendant longtemps, l’affinage demandait des grappes de cartes graphiques. Deux méthodes l’ont rendu accessible : LoRA, publiée en 2021, et QLoRA, publiée en 2023. Avec elles, un modèle de 8 milliards de paramètres s’affine dans 6 Go de mémoire graphique, d’après le tableau d’Unsloth.
Quand ça vaut le coup
Essayez dans cet ordre, et ne passez à l’étape suivante que si la précédente échoue sur votre banc d’essai :
- Une meilleure consigne. Des instructions précises, trois ou quatre exemples de la réponse attendue, un format imposé par une sortie structurée. C’est gratuit, et cela se change en une minute.
- Un RAG. Si le modèle manque de connaissances (vos produits, vos procédures, des faits récents), donnez-les-lui au moment de répondre. Avec l’affinage, il faudrait réentraîner le modèle à chaque mise à jour des documents.
- L’affinage. Il devient intéressant quand le problème tient à la manière de répondre :
- un format ou un style qu’aucune consigne ne fait tenir sur des milliers de réponses ;
- une tâche étroite et répétée (classer des tickets, extraire des champs) qu’on veut confier à un petit modèle, plus rapide et moins cher qu’un grand ;
- une consigne très longue qu’on veut « graver » dans le modèle pour ne plus la payer à chaque requête.
Unsloth défend une position plus large : selon sa documentation, l’affinage peut reproduire tout ce que fait un RAG, l’inverse étant faux. En pratique, un RAG reste plus simple à tenir à jour et permet de citer ses sources.
Comment ça marche
Un modèle de langage est fait de couches, et chaque couche contient de grandes matrices de poids. L’affinage complet modifie toutes ces valeurs, ce qui demande de garder en mémoire les poids, leurs gradients et l’état de l’optimiseur.
LoRA (low-rank adaptation) gèle les poids d’origine. À côté de chaque matrice visée, elle ajoute deux matrices étroites, B et A, dont le produit a la même taille que la matrice d’origine. Seules B et A apprennent. Leur largeur, le rang r, se règle : avec un rang de 16 sur une matrice de 4 096 par 4 096, on entraîne 131 072 valeurs au lieu de 16,8 millions. Sur GPT-3 175B, l’article d’origine annonce 10 000 fois moins de paramètres entraînables et trois fois moins de mémoire graphique, pour une qualité égale ou meilleure que l’affinage complet sur les modèles testés.
À la fin, on obtient un adaptateur, un fichier bien plus léger que le modèle. On peut le garder à part ou le fusionner dans les poids du modèle.
QLoRA fait la même chose, mais garde les poids gelés en 4 bits, dans un format conçu pour eux (NF4). L’article d’origine affinait ainsi un modèle de 65 milliards de paramètres sur une seule carte de 48 Go, sans perte par rapport à un affinage en 16 bits sur leurs tests.
Le matériel
Unsloth publie ces minimums de mémoire graphique, en précisant que certains modèles demandent davantage :
| Taille du modèle | QLoRA (4 bits) | LoRA (16 bits) |
|---|---|---|
| 3 milliards | 3,5 Go | 8 Go |
| 8 milliards | 6 Go | 22 Go |
| 14 milliards | 8,5 Go | 33 Go |
| 32 milliards | 26 Go | 76 Go |
| 70 milliards | 41 Go | 164 Go |
Côté systèmes, Unsloth fonctionne sous Linux, WSL et Windows avec une carte NVIDIA (capacité CUDA 7.0 au moins, soit les cartes depuis 2018), et prend aussi en charge les cartes AMD et Intel. Sur Mac, l’outil le plus direct reste MLX-LM, la bibliothèque d’Apple, qui fait du LoRA et du QLoRA sur la mémoire unifiée des puces Apple. Sa documentation donne un exemple : un Mistral 7B affiné sur une puce M1 Max avec 32 Go de mémoire, à environ 250 jetons par seconde.
Pour plusieurs cartes graphiques ou des modèles à mélange d’experts, Axolotl vise ces cas : il se pilote par un fichier de configuration YAML et demande Python 3.12 et une carte NVIDIA de génération Ampere ou plus récente, ou une carte AMD, selon son dépôt.
Pas à pas
Aucun des exemples de cette partie n’a été exécuté sur le mini-PC de QUELLE IA : un affinage télécharge plusieurs gigaoctets de poids et occupe la machine de longues minutes. Les commandes et le code suivent la documentation et les dépôts officiels lus le 17 novembre 2026 (Unsloth 2026.11.6, MLX-LM 0.32.2).
Le parcours tient en cinq étapes. Les étapes 2 à 4 se font aussi dans Unsloth Studio, sans écrire de code : son module Data Recipes lit des PDF, DOCX, CSV ou JSONL et en tire un jeu d’exemples, l’entraînement propose QLoRA, LoRA ou l’affinage complet, et l’export produit un GGUF pour llama.cpp, Ollama ou LM Studio, d’après sa documentation lue le 19 novembre 2026. Relisez toujours les exemples générés avant d’entraîner.
1. Préparer les données
Le format le plus courant est un fichier JSONL, une conversation par ligne. Mettez-y la réponse exacte que vous attendez, telle que vous voudriez la lire. Gardez 20 % des exemples à part pour l’évaluation, comme le conseille Unsloth.
{"messages": [{"role": "system", "content": "Tu classes les tickets de support."}, {"role": "user", "content": "Mon imprimante n'imprime plus depuis la mise à jour."}, {"role": "assistant", "content": "{\"categorie\": \"materiel\", \"urgence\": \"normale\"}"}]}
{"messages": [{"role": "system", "content": "Tu classes les tickets de support."}, {"role": "user", "content": "Je n'arrive plus à me connecter, la paie part ce soir."}, {"role": "assistant", "content": "{\"categorie\": \"acces\", \"urgence\": \"haute\"}"}]}
Rangez-les dans donnees/train.jsonl et donnees/valid.jsonl.
2a. Sur Mac, avec MLX-LM
- Installez la bibliothèque avec ses dépendances d’entraînement :
pip install "mlx-lm[train]"
- Lancez l’affinage. Si
--modeldésigne un modèle quantifié, MLX-LM fait du QLoRA, sinon du LoRA ; l’adaptateur est rangé dansadapters/. Les options--batch-size 1et--num-layers 4réduisent la mémoire, comme le conseille la documentation pour une machine de 32 Go.
mlx_lm.lora \
--model mistralai/Mistral-7B-v0.1 \
--train \
--data donnees \
--iters 600 \
--batch-size 1 \
--num-layers 4
- Essayez le résultat, puis fusionnez l’adaptateur et exportez un fichier GGUF pour Ollama ou llama.cpp :
mlx_lm.generate --model mistralai/Mistral-7B-v0.1 --adapter-path adapters \
--prompt "Mon écran reste noir au démarrage."
mlx_lm.fuse --model mistralai/Mistral-7B-v0.1 --export-gguf
Le fichier obtenu est fused_model/ggml-model-f16.gguf.
2b. Sur PC avec une carte NVIDIA, avec Unsloth
- Installez Unsloth dans un environnement Python (3.11 à 3.13) :
uv venv --python 3.12
source .venv/bin/activate
uv pip install unsloth --torch-backend=auto
- Enregistrez ce script sous
affine.py. Il reprend les réglages de départ conseillés par Unsloth (rang 16, alpha égal au rang, toutes les couches linéaires, taux d’apprentissage de 2e-4, une époque) et la structure de son script officielunsloth-cli.py:
from unsloth import FastLanguageModel, is_bfloat16_supported
from datasets import load_dataset
from trl import SFTTrainer, SFTConfig
# 1. Le modèle de base, chargé en 4 bits : c'est ce qui fait du QLoRA.
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="unsloth/Qwen3-8B",
max_seq_length=2048,
load_in_4bit=True,
)
# 2. Les adaptateurs LoRA sur toutes les couches linéaires.
model = FastLanguageModel.get_peft_model(
model,
r=16,
lora_alpha=16,
lora_dropout=0,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
use_gradient_checkpointing="unsloth",
)
# 3. Les conversations mises en forme avec le gabarit de discussion du modèle.
donnees = load_dataset("json", data_files={"train": "donnees/train.jsonl"})["train"]
donnees = donnees.map(lambda ex: {"text": tokenizer.apply_chat_template(ex["messages"], tokenize=False)})
# 4. L'entraînement.
entraineur = SFTTrainer(
model=model,
processing_class=tokenizer,
train_dataset=donnees,
args=SFTConfig(
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
num_train_epochs=1,
learning_rate=2e-4,
bf16=is_bfloat16_supported(),
fp16=not is_bfloat16_supported(),
logging_steps=10,
output_dir="sorties",
max_length=2048,
),
)
entraineur.train()
# 5. L'export en GGUF quantifié, prêt pour Ollama ou llama.cpp.
model.save_pretrained_gguf("modele-gguf", tokenizer, quantization_method="q4_k_m")
- Lancez-le et surveillez la perte (loss) affichée toutes les dix étapes :
python affine.py
Bon à savoir : Unsloth propose aussi Unsloth Studio, une interface web qui fait la même chose sans écrire de code (installation par
curl -fsSL https://unsloth.ai/install.sh | shsur macOS, Linux et WSL, puisunsloth studio). La même interface existe en application de bureau, Unsloth Desktop, gratuite et en bêta pour Mac à puce Apple, Windows et Linux : voir sa fiche.
3. Servir le modèle avec Ollama
Ollama importe un fichier GGUF par un Modelfile d’une ligne. Indiquez le fichier produit à l’étape précédente (son nom exact dépend de l’outil et de la quantification) :
FROM ./modele-gguf/modele.Q4_K_M.gguf
ollama create tickets-support -f Modelfile
ollama run tickets-support "Mon écran reste noir au démarrage."
Ollama ne requantifie pas un GGUF à l’import : choisissez la quantification à l’export.
Les pièges
- Le surapprentissage. Au-delà de trois époques, Unsloth constate peu de gain et plus de risque. Un signe : une perte d’entraînement qui descend sous 0,2. Arrêtez quand la perte sur les exemples gardés à part remonte.
- Le gabarit de discussion. Unsloth prévient qu’un modèle peut répondre mal ou se répéter hors de l’outil d’entraînement si le gabarit utilisé pour servir diffère de celui de l’entraînement. Vérifiez-le dans Ollama ou llama.cpp avant de conclure à un échec.
- Des exemples médiocres. La documentation d’Unsloth le résume : la qualité et la quantité des données se retrouvent dans le résultat. Cent exemples soignés valent mieux que dix mille copiés sans relecture.
- Juger sans banc d’essai. Comparez le modèle affiné au modèle d’origine avec une bonne consigne, sur les exemples gardés à part, plusieurs passages chacun. Le guide sur l’évaluation montre comment.
- La licence du modèle de base. Un modèle affiné hérite de ses conditions d’utilisation : vérifiez-les avant de le distribuer.
Coût
En local, la durée dépend du nombre d’exemples, de leur longueur et de la carte : l’article de QLoRA annonce 24 heures sur une seule carte pour son meilleur modèle, Guanaco. Le coût réel est souvent celui de la préparation des exemples, à écrire et relire à la main. Une fois affiné, le modèle se sert comme n’importe quel modèle local : voici les mieux classés qui tiennent dans 16 Go, de bons candidats comme modèles de base.
Les meilleurs modèles pour une machine de 16 Go
- Qwen3.5-9Ballégée à 8 bits, 11,7 Goscore 66,1
- Gemma 4 12B ITallégée à 4 bits, 8,3 Goscore 64,8 (provisoire)
- Ministral 3 14Ballégée à 4 bits, 9,7 Goscore 64,8 (provisoire)
- Qwen3-14Ballégée à 4 bits, 10,2 Goscore 62,9
- Qwen3.5-4Bcomplète, 10,7 Goscore 62,9 (provisoire)
Mémoire utile retenue : 14 Go, celle des machines suivies de 16 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.
Quel modèle sur ma machine →Les modèles qui tournent en local →
Pour aller plus loin
- Quantification : Q4, Q8, ce qu'on gagne et ce qu'on perdNiveau Expert 14 min
- RAG : donner ses documents à un modèle, pas à pasNiveau Nerd 25 min
- Évaluer un modèle soi-même : un petit banc d'essai maisonNiveau Nerd 20 min
- Poids ouverts, open source et licences des modèles d'IANiveau Amateur 4 min
- Faire tourner une IA sur son ordinateur avec OllamaNiveau Débutant 15 min
- LM Studio, l'IA locale sans ouvrir de terminalNiveau Débutant 12 min
- Les modèles Mistral en local avec Ollama ou LM StudioNiveau Amateur 12 min
Pour monter son atelier d'IA à la maison, mini lab AI, du même auteur, va plus loin.
Sources
- arxiv.org, lue le
- arxiv.org, lue le
- unsloth.ai, lue le
- unsloth.ai, lue le
- unsloth.ai, lue le
- unsloth.ai, lue le
- github.com, lue le
- github.com, lue le
- unsloth.ai, lue le
- unsloth.ai, lue le
- unsloth.ai, lue le
- unsloth.ai, lue le
- github.com, lue le
- github.com, lue le
- docs.ollama.com, lue le
- anthropic.com, lue le
