Points clés
- LoRA = Ajouter des couches entraînables à un modèle pré-entraîné. Seuls 1–5 % des poids du modèle sont entraînables, réduisant drastiquement VRAM et temps.
- Besoins du fine-tuning : 500–1000 exemples de haute qualité, 8–16 Go de VRAM, 1–4 heures d'entraînement.
- Meilleurs outils : Unsloth (le plus rapide), Hugging Face TRL, Axolotl (le plus flexible).
- Rang LoRA (r) : Inférieur (r=8) est plus petit, plus rapide ; supérieur (r=64) est plus expressif. Par défaut : r=16–32.
- En avril 2026, LoRA est prêt pour la production et largement soutenu par les moteurs d'inférence.
Comment fonctionne LoRA ?
LoRA ajoute de petites matrices « adaptateur » aux côtés des poids du modèle original. Pendant l'entraînement, seuls les adaptateurs sont mis à jour. Les poids d'origine restent figés.
Exemple : Un modèle 13B compte 13 milliards de poids. LoRA ajoute seulement 50 millions de paramètres entraînables (~0,4 % du total). L'entraînement est 100× plus rapide.
À l'inférence, la sortie adaptateur se fusionne avec la sortie du modèle principal via multiplication matricielle. Pénalité de vitesse minimale (~5 %).
Résultat : Un modèle spécifique au domaine performant sur vos tâches, nécessitant seulement 8 Go de VRAM au lieu de 26 Go.
Qu'est-ce que QLoRA (LoRA quantisé en 4 bits) ?
QLoRA combine LoRA et la quantisation 4 bits — le modèle de base se charge en 4 bits (QLoRA) tandis que seul l'adaptateur s'entraîne en 16 bits. Cela réduit de moitié les besoins en VRAM :
En avril 2026, QLoRA est le standard sur matériel grand public. L'indicateur `load_in_4bit=True` d'Unsloth dans l'exemple de code ci-dessus active QLoRA automatiquement. La différence de qualité de 2 % par rapport au LoRA complet est négligeable pour la plupart des tâches d'adaptation de domaine.
Quand utiliser LoRA (16 bits) plutôt que QLoRA (4 bits) ?
• Tâches nécessitant une précision maximale (médical, analyse de contrats juridiques)
• Vous avez 16+ Go de VRAM disponibles
• Fine-tuning de modèles 3B ou plus petits (les économies QLoRA sont minimes aux petites tailles)
| Méthode | VRAM Modèle 7B | VRAM Modèle 13B | Qualité vs Complet |
|---|---|---|---|
| Fine-tuning complet | 28 Go | 52 Go | 100 % (référence) |
| LoRA (base 16 bits) | 16 Go | 30 Go | ~97 % |
| QLoRA (base 4 bits) | 8 Go | 14 Go | ~95 % |
Fine-tuning ou RAG ?
Matrice de décision :
Avant d'investir dans le fine-tuning LoRA, vérifiez que de meilleurs prompts ne peuvent pas d'abord résoudre le problème — le prompt engineering est plus rapide, réversible et agnostique au modèle. Pour le cadre de décision complet, voir prompt engineering vs fine-tuning : comment décider.
Le fine-tuning est l'une des façons de garder un workflow de code productif hors ligne. Pour l'installation hors ligne plus complète — modèle, IDE, cache de paquets, miroir de docs — voir LLM de code local sans Internet.
| Critère | Fine-tuning | RAG |
|---|---|---|
| Fréquence de changement des documents | Annuel ou moins | Hebdomadaire ou plus |
| Besoins en connaissances | Compréhension profonde | La récupération suffit |
| Données d'entraînement disponibles | Besoin 500+ exemples | N'importe quel document |
| Coût (long terme) | Unique ($50–200) | Embeddings continus |
| Latence | Plus rapide (pas de récupération) | Plus lent (récupération + LLM) |
| Meilleur pour | Code, écriture créative, style | Bases de connaissances, Q&R |
Comment préparez-vous les données d'entraînement ?
La qualité des données d'entraînement détermine le succès du fine-tuning. Mauvaises données = mauvais modèle.
Minimum : 500 exemples. Chaque exemple = entrée + sortie attendue.
Optimal : 1000–5000 exemples. Plus de données = meilleure précision.
Format : JSON ou JSONL. Chaque ligne = un exemple d'entraînement.
[\n {"instruction": "Traduire en anglais", "input": "Bonjour le monde", "output": "Hello world"},\n {"instruction": "Résumer", "input": "Texte long...", "output": "Résumé..."},\n {"instruction": "Critique de code", "input": "Code Python...", "output": "Commentaires de critique..."}\n]\n\n# OU format instruction-only:\n[\n {"text": "<|user|>Traduire en anglais\nBonjour<|assistant|>Hello"},\n {"text": "<|user|>Résumer\nTexte<|assistant|>Résumé"}\n]
Configuration du fine-tuning avec Unsloth
Unsloth est le framework LoRA le plus rapide (4× de vitesse vs entraînement standard) :
# Installer unsloth\npip install unsloth[colab-new] xformers bitsandbytes\n\nfrom unsloth import FastLanguageModel\nfrom datasets import load_dataset\n\n# Charger le modèle de base avec LoRA\nmodel, tokenizer = FastLanguageModel.from_pretrained(\n model_name="unsloth/llama-3.1-8b-bnb-4bit",\n max_seq_length=2048,\n load_in_4bit=True,\n lora_r=16, lora_alpha=32,\n lora_dropout=0.05\n)\n\n# Charger les données d'entraînement\ndataset = load_dataset("json", data_files="training.jsonl")\n\n# Configurer le trainer\nfrom trl import SFTTrainer\ntrainer = SFTTrainer(\n model=model,\n tokenizer=tokenizer,\n train_dataset=dataset["train"],\n dataset_text_field="text",\n max_seq_length=2048,\n args=TrainingArguments(\n per_device_train_batch_size=4,\n num_train_epochs=3,\n learning_rate=2e-4,\n output_dir="output"\n )\n)\n\n# Entraîner\ntrainer.train()Hyperparamètres clés pour le fine-tuning LoRA
| Hyperparamètre | Valeur recommandée | Plage typique | Effet |
|---|---|---|---|
| learning_rate | 2e-4 | 1e-5 à 1e-3 | Plus bas = stable, convergence lente |
| lora_r (rang) | 16 | 4 à 64 | Plus haut = expressif, lent |
| lora_alpha | 32 | 8 à 256 | Plus haut = effet LoRA plus fort |
| num_train_epochs | 3 | 1 à 10 | Plus d'epochs = risque de surapprentissage |
| batch_size | 4 | 1 à 32 | Plus grand = entraînement rapide, plus VRAM |
| warmup_steps | 100 | 0 à 1000 | Augmentation progressive du LR, stabilise |
Comment évaluez-vous les modèles fine-tunés ?
Perte d'entraînement : Doit diminuer au cours des epochs. Si elle stagne, le learning rate peut être trop bas.
Perte de validation : Doit diminuer mais rester au-dessus de la perte d'entraînement (normal). Si elle augmente, surapprentissage.
Tests manuels : Exécutez le modèle fine-tuné sur des exemples de test et comparez les sorties aux résultats attendus.
Tâches de benchmark : Utilisez des benchmarks standard (MMLU, HumanEval) pour mesurer les améliorations.
Quelles sont les erreurs courantes du fine-tuning ?
- Trop peu d'exemples d'entraînement. <200 exemples mènent souvent au surapprentissage. Collectez au moins 500.
- Entraîner trop d'epochs. Le modèle mémorise au lieu d'apprendre des motifs généralisables. Maximum 3–5 epochs.
- Ne pas valider sur des données non vues. Divisez toujours les données (80/20). Validez fréquemment pour détecter le surapprentissage.
- Utiliser les mêmes données pour fine-tuning et évaluation. La précision rapportée est invalide si évaluée sur des données d'entraînement.
- Ne pas sauvegarder les checkpoints. L'entraînement peut durer des heures. Sauvegardez chaque epoch pour récupérer après un crash.
Questions fréquemment posées sur le fine-tuning LoRA
Combien de données d'entraînement sont nécessaires ?
Au minimum 500 exemples, idéalement 1000–5000. La qualité prime sur la quantité. 100 bons exemples valent mieux que 1000 médiocres.
Puis-je fine-tuner sur un ordinateur portable ?
Oui. Utilisez la quantisation 4 bits et LoRA. Un modèle 7B nécessite 8 Go de VRAM ; l'entraînement prend 1–2 heures sur CPU (lent) ou 10–15 min sur GPU.
Comment fusionner les adaptateurs LoRA au modèle de base ?
Utilisez Unsloth ou HF Transformers : `model.merge_and_unload()`. Crée un fichier unique (~3–4 Go pour 7B), prêt pour l'inférence.
Puis-je combiner plusieurs adaptateurs LoRA ?
Oui, avec restrictions. Empilez-les pour une application séquentielle, ou utilisez les techniques de composition adaptateur (ex. DoRA).
Un modèle fine-tuné est-il meilleur que RAG pour les connaissances métier ?
Pour la plupart des tâches, oui. Les modèles fine-tunés comprennent profondément les concepts métier. RAG excelle quand les documents sont volumineux et changent souvent.
Quelle est la différence entre LoRA et QLoRA ?
LoRA charge le modèle de base en 16 bits et entraîne les petites couches adaptateur. QLoRA charge en 4 bits et entraîne les adaptateurs en 16 bits. QLoRA utilise environ la moitié du VRAM : 8 Go pour 7B vs 16 Go pour LoRA. Différence de qualité ~2 % — négligeable pour la plupart des tâches. Unsloth active QLoRA avec `load_in_4bit=True`.
Comment utiliser un modèle fine-tuné LoRA dans Ollama ?
Après l'entraînement, fusionnez l'adaptateur : `model.merge_and_unload()`. Convertissez en GGUF via le script `convert.py` de llama.cpp. Créez un fichier Modelfile Ollama pointant au fichier GGUF : `FROM ./my-finetuned-model.gguf`. Puis : `ollama create my-model -f Modelfile` et `ollama run my-model`. Le modèle fine-tuné fonctionne identiquement à tout modèle Ollama.
Puis-je fine-tuner Llama 3.3 70B avec LoRA sur du matériel grand public ?
Oui, avec QLoRA. Llama 3.3 70B en 4 bits nécessite ~40 Go de VRAM — tient sur un RTX 4090 dual (2×24 Go) ou un A100 80GB. Entraînement : 4–8 heures sur 1000 exemples. Pour la plupart, fine-tuner 7B ou 13B est plus pratique et offre 90 %+ du gain de qualité 70B pour les tâches métier.
Quel outil est meilleur pour le fine-tuning LoRA ?
Unsloth est le plus rapide sur matériel grand public — 2× plus rapide que l'entraînement standard avec 70 % moins de VRAM. HF TRL avec PEFT est le plus largement utilisé. Axolotl convient mieux aux utilisateurs avancés nécessitant de la flexibilité de configuration.
Comment utiliser un modèle fine-tuné LoRA avec des outils d'inférence locaux ?
Fusionnez l'adaptateur : `model.merge_and_unload()`. Convertissez en GGUF via llama.cpp. Créez un Modelfile Ollama : `FROM ./model.gguf`. Importez dans LM Studio via interface graphique. Utilisez avec vLLM : `vllm serve ./model.gguf`. Tous les moteurs d'inférence locaux acceptent les fichiers GGUF fusionnés.
Sources
- Hu, E. et al. (2021). "LoRA: Low-Rank Adaptation of Large Language Models." https://arxiv.org/abs/2106.09685 — Article LoRA original montrant 0,4 % de paramètres entraînables égalant la qualité du fine-tuning complet.
- Dettmers, T. et al. (2023). "QLoRA: Efficient Finetuning of Quantized LLMs." https://arxiv.org/abs/2305.14314 — Article QLoRA : modèle de base quantisé 4 bits + adaptateurs LoRA 16 bits réduit VRAM de moitié.
- Unsloth. (2026). "Unsloth: 4× Faster LoRA Training." https://github.com/unslothai/unsloth — Framework LoRA le plus rapide, supporte Llama 3.x, Qwen2.5, Mistral avec 4× speedup.
- Hugging Face. (2025). "TRL: Transformer Reinforcement Learning." https://github.com/huggingface/trl — SFTTrainer pour fine-tuning supervisé avec support adaptateur LoRA.