Vous utilisez un LLM via API, mais les réponses restent génériques. Le modèle ne connait ni votre jargon métier, ni vos conventions, ni la structure de vos documents internes. La solution : fine-tuner un LLM open source directement sur vos données pour obtenir un modèle spécialisé, deployable on-premise, sans envoyer la moindre donnee a un tiers.
Ce guide pas à pas vous montre comment fine-tuner un modèle comme Mistral 7B avec Hugging Face TRL, PEFT et QLoRA — de la preparation du dataset au push du modèle fine-tune. Chaque étape est accompagnee de code fonctionnel que vous pouvez executer sur un GPU grand public (24 Go de VRAM suffisent). Si vous hésitez encore sur le modèle a adapter, notre article sur les criteres techniques et juridiques pour choisir un LLM open source vous aidera a trancher avant de commencer.
Audience : data scientists, ML engineers et developpeurs Python familiers avec PyTorch et le CLI Hugging Face.
Le pipeline repose sur quatre bibliothèques clés de l'écosystème Hugging Face :
Perplexity
ChatGPT
Claude
Grok
Gemini
Mistral
SFTTrainer pour le supervised fine-tuningInstallez l'ensemble des dépendances :
```bash
pip install torch transformers trl peft bitsandbytes datasets accelerate
```
Vérifiez que votre GPU est bien détecté :
```python
import torch
print(f"CUDA disponible : {torch.cuda.is_available()}")
print(f"GPU : {torch.cuda.get_device_name(0)}")
print(f"VRAM : {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} Go")
```
Sortie attendue (exemple avec une RTX 4090) :
```bash
CUDA disponible : True
GPU : NVIDIA GeForce RTX 4090
VRAM : 24.6 Go
```
Un fine-tuning complet d'un modèle 7B nécessite environ 120 Go de VRAM — soit plusieurs GPU A100. QLoRA (Quantized Low-Rank Adaptation) combine deux techniques pour rendre l'entraînement accessible :
Résultat : vous entrainez un modèle 7B sur un seul GPU 24 Go, avec des performances proches du fine-tuning complet. Pour les cas ou meme cette empreinte est trop élevée, explorez les possibilites du LLM en edge computing.
La qualité du dataset conditionne directement la qualité du modèle fine-tune. Le SFTTrainer de TRL attend un format conversationnel standard :
```python
from datasets import Dataset
# Exemple : dataset de support client e-commerce
training_data = [
{
"messages": [
{"role": "system", "content": "Tu es un assistant expert en support client pour une enseigne retail."},
{"role": "user", "content": "Ma commande 45231 est en retard de 3 jours, que se passe-t-il ?"},
{"role": "assistant", "content": "Je verifie le suivi de votre commande 45231. Le colis est actuellement bloque au hub de tri de Lyon depuis le 24/02. Je lance une reclamation transporteur et vous recevrez un email de confirmation sous 2h. Souhaitez-vous un avoir ou un renvoi express ?"}
]
},
{
"messages": [
{"role": "system", "content": "Tu es un assistant expert en support client pour une enseigne retail."},
{"role": "user", "content": "Comment retourner un article achete en ligne ?"},
{"role": "assistant", "content": "Pour retourner un article : 1) Connectez-vous a votre espace client, 2) Selectionnez la commande concernee, 3) Cliquez sur 'Retourner un article', 4) Imprimez l'etiquette prepayee. Le remboursement intervient sous 5 jours ouvrables apres reception en entrepot."}
]
}
]
dataset = Dataset.from_list(training_data)
print(dataset)
# Dataset({ features: ['messages'], num_rows: 2 })
```
En production, constituez un dataset de 500 a 5 000 exemples de haute qualité, couvrant les cas d'usage reels de votre métier. La extraction de valeur a partir de données textuelles non structurees peut vous aider a constituer ce corpus a partir de vos tickets, emails ou documents internes.
Nous utilisons Mistral 7B Instruct comme modèle de base. La configuration BitsAndBytesConfig active la quantification NF4 avec double quantification pour une compression maximale :
```python
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch
model_id = "mistralai/Mistral-7B-Instruct-v0.3"
# Configuration QLoRA 4-bit
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
)
# Chargement du modele quantifie
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=bnb_config,
device_map="auto",
attn_implementation="flash_attention_2",
)
# Chargement du tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"
```
La configuration LoRA determine quels modules du modèle sont adaptes et avec quelle capacite. Un rang r=16 offre un bon compromis performance/mémoire pour la plupart des cas métier :
```python
from peft import LoraConfig, TaskType
peft_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,
bias="none",
)
```
Avec cette configuration, seuls ~4 millions de paramètres sont entraînés sur les 7 milliards du modèle — soit 0,06 % du total. Cela illustre parfaitement l'approche Data Science efficiente que nous privilegions chez Flowt.
Le SFTTrainer de TRL encapsule toute la logique d'entraînement. On utilise SFTConfig pour parametrer les hyperparametres :
```python
from trl import SFTConfig, SFTTrainer
sft_config = SFTConfig(
output_dir="./mistral-7b-support-client",
num_train_epochs=3,
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
learning_rate=2e-4,
lr_scheduler_type="cosine",
warmup_ratio=0.1,
max_seq_length=1024,
gradient_checkpointing=True,
gradient_checkpointing_kwargs={"use_reentrant": False},
bf16=True,
logging_steps=10,
save_strategy="epoch",
optim="paged_adamw_8bit",
)
trainer = SFTTrainer(
model=model,
args=sft_config,
train_dataset=dataset,
processing_class=tokenizer,
peft_config=peft_config,
)
# Lancement de l'entrainement
trainer.train()
```
Paramètres clés a retenir :
paged_adamw_8bit : optimiseur qui page la mémoire GPU pour eviter les OOMgradient_checkpointing : echange du compute contre de la mémoire — indispensable en QLoRAgradient_accumulation_steps=4 : simule un batch effectif de 8 (2 x 4) sans mémoire supplementairecosine scheduler : décroissance douce du learning rate, plus stable que lineaireApres l'entraînement, sauvegardez les adaptateurs (quelques dizaines de Mo seulement) :
```python
# Sauvegarde des adaptateurs LoRA
trainer.save_model("./mistral-7b-support-client/final")
# Push optionnel sur le Hugging Face Hub
# trainer.push_to_hub("votre-org/mistral-7b-support-client")
print("Adaptateurs sauvegardes avec succes.")
```
Chargez les adaptateurs et testez une inference :
```python
from peft import PeftModel
from transformers import pipeline
# Recharger le modele de base + adaptateurs
base_model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=bnb_config,
device_map="auto",
)
model_ft = PeftModel.from_pretrained(base_model, "./mistral-7b-support-client/final")
# Pipeline d'inference
pipe = pipeline(
"text-generation",
model=model_ft,
tokenizer=tokenizer,
max_new_tokens=256,
)
messages = [
{"role": "system", "content": "Tu es un assistant expert en support client pour une enseigne retail."},
{"role": "user", "content": "Je voudrais echanger ma taille, comment faire ?"},
]
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
result = pipe(prompt)
print(result[0]["generated_text"])
```
Si le modèle répond avec le ton, le format et les procédures spécifiques a votre entreprise plutôt qu'une réponse générique, le fine-tuning est réussi. Pour aller plus loin et déployer ce LLM sur votre infrastructure, vous devrez fusionner les adaptateurs avec le modèle de base avant la mise en production.
Ne vous fiez pas uniquement a la loss d'entraînement. Mettez en place une évaluation rigoureuse :
Le fine-tuning est un processus itératif. Analysez les erreurs du modèle, enrichissez le dataset sur les cas mal couverts, et relancez un entraînement. Cette boucle d'amélioration continue s'intégré dans une demarche DataOps / MLOps structuree. Pour les pipelines qui combinent texte, images et autres modalites, notre guide sur les chaines de traitement multimodales en IA open source complete cette approche.
Avant de déployer, pensez a :
model.merge_and_unload() pour simplifier le servingL'application de ces techniques au secteur du commerce est détaillée dans notre article sur l'IA dans le retail, ou le fine-tuning alimente des modèles de personnalisation client et de prévision de demande.
Fine-tuner un LLM open source avec QLoRA et Hugging Face TRL est desormais accessible a toute equipe disposant d'un GPU 24 Go et de données métier de qualité. En quelques heures d'entraînement et moins de 5 000 exemples, vous obtenez un modèle spécialisé qui surpasse les LLM génériques sur vos cas d'usage — tout en gardant le controle total sur vos données et votre infrastructure.
Les étapes clés : preparer un dataset conversationnel propre, configurer QLoRA pour un entraînement mémoire-efficient, itérer sur la base des evaluations, et déployer via une pipeline MLOps robuste.
Chez Flowt, nos experts en IA generative accompagnent les entreprises dans le fine-tuning et le déploiement de LLM adaptes a leurs données métier. Demandez un audit IA gratuit pour évaluer le potentiel du fine-tuning sur vos cas d'usage.
Vous souhaitez être accompagné pour lancer votre projet Data ou IA ?
.webp)