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.
- LoRA est prêt pour la production et largement soutenu par les moteurs d'inférence.
📍 En une phrase
Le fine-tuning LoRA adapte un modèle pré-entraîné à votre domaine en entraînant de petites couches adaptateur (environ 0,4 % du total des poids) plutôt que tout le modèle, permettant à un fine-tune Llama 3.1 8B de tourner sur seulement 8 Go de VRAM en 1-2 heures avec Unsloth.
💬 En termes simples
Le fine-tuning signifie normalement réentraîner un modèle énorme depuis zéro, ce qui exige du matériel sérieux. LoRA est un raccourci : au lieu de toucher tous les poids du modèle, il entraîne un petit ensemble de couches supplémentaires qui orientent le modèle vers votre domaine ou style d'écriture spécifique. C'est pourquoi ça tient sur des GPU grand public et se termine en quelques heures au lieu de plusieurs jours.
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 :
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 (jusqu'à 2× de vitesse vs entraînement standard, selon unsloth.ai) :
# 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.
Qu'est-ce que LoRA et comment fonctionne-t-il ?
LoRA (Low-Rank Adaptation) ajoute des couches adaptateur entraînables à un modèle de base figé. Au lieu de mettre à jour 7 milliards de paramètres, LoRA entraîne seulement les poids adaptateur (typiquement 1–10 millions). Cela réduit VRAM 10–20× et le temps d'entraînement de jours à heures.
Quel format de fichier utilisent les poids adaptateur LoRA ?
Les adaptateurs LoRA sont sauvegardés en fichiers Safetensors (ex. adapter_model.safetensors) aux côtés d'un adapter_config.json. La taille totale est typiquement 50–500 Mo selon le rang (lora_r) et le nombre de couches.
Puis-je distribuer un modèle fine-tuné LoRA ?
Vous pouvez distribuer les poids adaptateur LoRA séparement du modèle de base. Les utilisateurs doivent déjà avoir le modèle de base téléchargé. Vérifiez la licence du modèle de base (Meta Llama est permissive pour la plupart ; certains modèles restreignent la redistribution commerciale).
Combien de temps prend le fine-tuning LoRA sur matériel grand public ?
Sur RTX 4090 (24 Go VRAM) : 1000 exemples × 3 epochs = environ 15–30 minutes. Sur Apple M3 Pro (18 Go) : environ 2–4 heures. Sur CPU seul : 8–24 heures selon la taille du modèle. Utilisez GPU ou Apple Silicon pour des temps pratiques.
Sources
- Hu, E. et al. (2021). "LoRA: Low-Rank Adaptation of Large Language Models." 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." 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). "Train LLMs up to 2× faster with 70% less VRAM (Unsloth)." github.com/unslothai/unsloth — Framework LoRA le plus rapide, supporte Llama 3.x, Qwen3, Mistral avec jusqu'à 2× speedup.
- Hugging Face. (2025). "TRL: Transformer Reinforcement Learning." github.com/huggingface/trl — SFTTrainer pour fine-tuning supervisé avec support adaptateur LoRA.