Intelligence ArtificielleGuidesPublié le 18 mars 2026 à 15:35• 9 min de lecture

Fine-tuner un modèle IA avec LoRA : le guide pas à pas

Apprenez à personnaliser un modèle d'IA en le fine-tunant avec LoRA, même avec une carte graphique modeste. Guide complet pour débutants.

Fine-tuner un modèle IA avec LoRA : le guide pas à pas

Vous avez déjà joué avec ChatGPT ou des modèles open source comme Llama ou Mistral. Mais saviez-vous qu'on peut personnaliser ces modèles pour qu'ils répondent exactement comme on veut ? C'est ce qu'on appelle le fine-tuning, et grâce à une technique nommée LoRA, c'est devenu accessible même sans un datacenter.

Pensez au fine-tuning comme à un traducteur polyglotte. Il parle déjà 10 langues couramment. Plutôt que de tout lui réapprendre, vous lui enseignez juste les expressions spécifiques à votre métier. C'est rapide, ça ne casse pas ce qu'il sait déjà, et le résultat est bluffant. LoRA fonctionne exactement sur ce principe : on ajuste une toute petite partie du modèle, sans toucher au reste.

Ce qu'il vous faut avant de commencer

Un PC avec une carte graphique NVIDIA (RTX 3060 12 Go ou mieux)
Ubuntu 22.04/24.04 ou Windows avec WSL2
Python 3.10 ou plus récent
Environ 20 Go d'espace disque libre
Une connexion internet (pour télécharger le modèle de base)
De la patience : le premier entraînement prend entre 30 minutes et 2 heures

Si votre carte graphique a moins de 8 Go de VRAM, pas de panique. On utilisera la quantification 4 bits pour faire tenir le modèle en mémoire. Avec 6 Go, ça passe pour les modèles jusqu'à 3 milliards de paramètres.

Étape 1 — Installer l'environnement Python

On commence par créer un espace de travail propre. Un environnement virtuel évite de polluer votre système avec des dizaines de paquets.

bash

## Créer un dossier pour le projet
mkdir ~/lora-finetune && cd ~/lora-finetune

## Créer un environnement virtuel Python
python3 -m venv venv

## Activer l'environnement (à refaire à chaque nouveau terminal)
source venv/bin/activate

## Mettre à jour pip
pip install —upgrade pip

Si la commande python3 ne fonctionne pas, vérifiez votre installation avec python3 —version. Il vous faut la version 3.10 minimum.

Étape 2 — Installer les bibliothèques nécessaires

On va utiliser quatre outils principaux :

transformers : la bibliothèque de Hugging Face pour charger les modèles
peft : l'outil qui gère LoRA (Parameter-Efficient Fine-Tuning)
trl : un assistant pour l'entraînement supervisé
bitsandbytes : pour la quantification 4 bits (faire tenir un gros modèle dans peu de mémoire)

bash

## Installer PyTorch avec support CUDA (GPU NVIDIA)
pip install torch torchvision torchaudio —index-url https://download.pytorch.org/whl/cu121

## Installer les bibliothèques Hugging Face
pip install transformers peft trl datasets accelerate bitsandbytes

L'installation prend quelques minutes. PyTorch seul pèse environ 2 Go.

⚠️ Attention : si vous avez une carte AMD, le processus est différent et nettement plus compliqué. Ce tutoriel se concentre sur NVIDIA, qui reste le standard pour le machine learning.

Étape 3 — Vérifier que le GPU est détecté

Avant d'aller plus loin, on s'assure que Python voit bien votre carte graphique.

bash

python3 -c "import torch; print(f'GPU détecté : {torch.cuda.get_device_name(0)}'); print(f'VRAM : {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} Go')"

Vous devriez voir le nom de votre carte et sa quantité de mémoire. Si Python affiche une erreur, vérifiez que les drivers NVIDIA et CUDA sont installés (nvidia-smi dans le terminal).

Étape 4 — Préparer les données d'entraînement

Le fine-tuning a besoin d'exemples. On va créer un petit jeu de données au format que le modèle attend. Pour cet exercice, on utilise un dataset de conversations déjà formaté disponible sur Hugging Face.

Mais d'abord, comprenons le format. Un modèle de chat attend des échanges structurés : une question (le "prompt") et une réponse idéale. Plus vos exemples sont cohérents et variés, meilleur sera le résultat.

bash

## Créer un script de préparation des données
cat > prepare_data.py << 'EOF'
from datasets import load_dataset

## Charger un dataset d'exemple (conversations en français)
## Vous pouvez remplacer par votre propre dataset
dataset = load_dataset("BAAI/Infinity-Instruct", split="train[:2000]")

## Afficher un exemple pour comprendre la structure
print("Nombre d'exemples :", len(dataset))
print("Colonnes :", dataset.column_names)
print("Premier exemple :")
print(dataset[0])

## Sauvegarder localement
dataset.save_to_disk("./data_prepared")
print("Données sauvegardées dans ./data_prepared")
EOF

python3 prepare_data.py

Pour un vrai projet, vous remplacerez ce dataset par le vôtre. Le format le plus courant est un fichier JSON avec des paires question/réponse, ou un fichier CSV avec deux colonnes.

Étape 5 — Configurer et lancer le fine-tuning LoRA

C'est le cœur du tutoriel. On va charger un modèle pré-entraîné (Qwen 2.5 3B, un bon compromis taille/qualité), lui appliquer LoRA, et l'entraîner sur nos données.

bash

cat > train_lora.py << 'TRAINEOF'
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer, SFTConfig
from datasets import load_from_disk

## —- Configuration du modèle —-
model_id = "Qwen/Qwen2.5-3B-Instruct"

## Quantification 4 bits pour économiser la VRAM
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

print("Chargement du modèle (peut prendre 2-3 min)...")
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quant_config,
    device_map="auto",
)

## —- Configuration LoRA —-
## r=16 : le rang de l'adaptation (plus élevé = plus de capacité mais plus de VRAM)
## lora_alpha=32 : facteur de mise à l'échelle
## target_modules : les couches du modèle qu'on modifie
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    task_type=TaskType.CAUSAL_LM,
)

model = get_peft_model(model, lora_config)

## Afficher combien de paramètres on entraîne réellement
model.print_trainable_parameters()
## Vous verrez quelque chose comme : "trainable params: 13M || all params: 3B || 0.42%"

## —- Charger les données —-
dataset = load_from_disk("./data_prepared")

## —- Configuration de l'entraînement —-
training_config = SFTConfig(
    output_dir="./lora-output",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
    save_steps=100,
    save_total_limit=2,
    bf16=True,
    max_seq_length=512,
    report_to="none",
)

## —- Lancer l'entraînement —-
print("Début de l'entraînement LoRA...")
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=training_config,
    tokenizer=tokenizer,
)

trainer.train()

## —- Sauvegarder l'adaptateur LoRA —-
trainer.save_model("./lora-adapter")
print("Adaptateur LoRA sauvegardé dans ./lora-adapter")
print("Taille de l'adaptateur :", end=" ")

import os
total = sum(os.path.getsize(os.path.join("./lora-adapter", f)) for f in os.listdir("./lora-adapter"))
print(f"{total / 1e6:.1f} Mo")
TRAINEOF

python3 train_lora.py

Quelques repères de temps :

RTX 3060 12 Go : environ 45 min pour 2000 exemples, 3 epochs
RTX 4070 : environ 25 min
RTX 4090 : environ 10 min

⚠️ Surveillez la température GPU pendant l'entraînement (nvidia-smi dans un autre terminal). Au-dessus de 85°C, vérifiez la ventilation.

Étape 6 — Tester le modèle fine-tuné

Le moment de vérité. On charge le modèle de base, on y applique notre adaptateur LoRA, et on lui pose des questions.

bash

cat > test_model.py << 'TESTEOF'
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import PeftModel

model_id = "Qwen/Qwen2.5-3B-Instruct"

## Recharger le modèle de base en 4 bits
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(model_id)
base_model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=quant_config,
    device_map="auto",
)

## Appliquer l'adaptateur LoRA par-dessus
model = PeftModel.from_pretrained(base_model, "./lora-adapter")
model.eval()

## Tester avec une question
prompt = "Explique-moi comment fonctionne un réseau de neurones."
messages = [{"role": "user", "content": prompt}]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=300, temperature=0.7)

response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print("Réponse du modèle fine-tuné :")
print(response)
TESTEOF

python3 test_model.py

Comparez la réponse avec celle du modèle de base (sans LoRA) pour voir la différence. Plus vos données d'entraînement sont spécifiques, plus l'écart sera visible.

Étape 7 — Exporter et partager le modèle

L'avantage de LoRA, c'est que l'adaptateur ne pèse que quelques dizaines de Mo, contre plusieurs Go pour le modèle complet. Vous pouvez le partager facilement.

bash

## Vérifier la taille de l'adaptateur
du -sh ./lora-adapter/
## Typiquement 30-80 Mo pour un modèle 3B

## Pour fusionner LoRA avec le modèle de base (créer un modèle autonome)
cat > merge_model.py << 'MERGEEOF'
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

model_id = "Qwen/Qwen2.5-3B-Instruct"

print("Chargement du modèle de base...")
tokenizer = AutoTokenizer.from_pretrained(model_id)
base_model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="cpu",
)

print("Application de l'adaptateur LoRA...")
model = PeftModel.from_pretrained(base_model, "./lora-adapter")

print("Fusion des poids...")
merged_model = model.merge_and_unload()

print("Sauvegarde du modèle fusionné...")
merged_model.save_pretrained("./model-merged")
tokenizer.save_pretrained("./model-merged")
print("Modèle complet sauvegardé dans ./model-merged")
MERGEEOF

python3 merge_model.py

Le modèle fusionné peut ensuite être converti au format GGUF pour tourner dans Ollama ou llama.cpp.

Étape 8 — L'alternative rapide : Unsloth

Si vous trouvez tout ça un peu verbeux, sachez qu'il existe Unsloth, un outil qui simplifie drastiquement le fine-tuning LoRA. Il est jusqu'à 2 fois plus rapide et consomme moins de VRAM.

bash

## Installer Unsloth
pip install unsloth

## Unsloth fournit des notebooks prêts à l'emploi
## pour Llama, Mistral, Qwen, Phi et d'autres modèles
## Consultez : https://unsloth.ai/docs

Unsloth est particulièrement recommandé si vous débutez ou si votre GPU a peu de VRAM. Son interface graphique (Unsloth Studio) permet même de configurer l'entraînement sans écrire de code.

Pour aller plus loin

Augmenter la qualité : plus vos données sont propres et nombreuses, meilleur sera le résultat. Visez au minimum 500 exemples de qualité.
Ajuster les hyperparamètres : le rang LoRA (r) contrôle la capacité d'adaptation. r=8 pour du léger, r=32 pour du costaud.
QLoRA : la combinaison quantification 4 bits + LoRA, ce qu'on fait dans ce tuto. C'est le meilleur rapport qualité/coût en VRAM.
Reinforcement Learning : après le fine-tuning supervisé, on peut affiner avec du GRPO ou DPO via la bibliothèque TRL.

Le fine-tuning LoRA rend l'IA personnalisable par tous. Vous n'avez pas besoin d'un serveur à 10 000 euros. Une carte graphique gaming et un peu de méthode suffisent pour créer un modèle qui parle votre langue, connaît votre domaine, et répond comme vous le souhaitez.

—-

Sources : documentation officielle [Hugging Face PEFT](https://huggingface.co/docs/peft), [Unsloth](https://unsloth.ai/docs), [TRL](https://huggingface.co/docs/trl)

Fine-tuner un modèle IA avec LoRA : le guide pas à pas