En Bref : Oui, fine-tuner un LLM comme Phi-3 sur un PC gamer (GPU Nvidia avec 12Go+ de VRAM) est devenu possible en 2025. Le secret ? Des outils magiques comme Unsloth et une préparation maniaque de vos données. Ce n’est pas simple, mais c’est accessible. On vous montre comment.
Le « fine-tuning » est sur toutes les lèvres. L’idée est séduisante : prendre un modèle de langage généraliste et le spécialiser, lui apprendre un style, un jargon, une compétence particulière, en utilisant vos propres données. Un rêve de développeur.
Pendant longtemps, c’était un domaine réservé aux entreprises avec des fermes de GPU. Mais les choses changent vite, très vite. Aujourd’hui, je vais vous montrer que c’est possible de le faire à la maison.
Attention, je ne vais pas vous vendre du rêve. Ce n’est pas une promenade de santé. Ça demande de la rigueur et le bon matériel. Mais c’est une aventure incroyablement gratifiante. Alors, mythe ou réalité ? Attachez vos ceintures, on plonge dans la salle des machines.
🤔 Fine-Tuning vs RAG : Lequel Choisir ?
Avant d’aller plus loin, une mise au point s’impose. On confond souvent fine-tuning et RAG.
- RAG (Retrieval-Augmented Generation) : C’est comme donner un livre ouvert à un étudiant pendant un examen. Vous donnez au LLM des documents (un PDF, un site web…) au moment de la question, et il s’en sert pour répondre. C’est idéal pour faire de la question/réponse sur des bases de connaissances qui changent souvent.
- Fine-Tuning : C’est comme faire suivre un cursus spécialisé à l’étudiant. On ne lui donne pas de nouveaux livres, on modifie sa façon de penser, son style, sa structure de raisonnement. C’est parfait pour adapter le comportement du modèle.
En bref : Vous voulez que l’IA réponde sur la base de VOS documents ? Utilisez le RAG. Vous voulez que l’IA parle ou raisonne comme vous ? C’est le fine-tuning.
🛠️ Avant de Commencer : Les Vrais Prérequis
Ce tutoriel s’adresse à ceux qui ont déjà une base solide. Il suppose que vous êtes familier avec l’exécution de modèles en local. Si ce n’est pas le cas ou si des termes comme « runner » ou « GGUF » sont encore flous, nous vous recommandons fortement de commencer par notre guide complet pour installer votre première IA locale avant de vous lancer dans l’aventure du fine-tuning.
Le Matériel : Le Juge de Paix
On ne va pas se mentir, tout tourne autour d’un composant : la VRAM de votre carte graphique (GPU).
- GPU Nvidia (CUDA) obligatoire : Oui, c’est une triste réalité. L’écosystème de l’entraînement est massivement optimisé pour les cartes Nvidia. C’est possible avec AMD, mais 100x plus complexe.
- < 8 Go VRAM : Oubliez. Vous allez souffrir.
- 12 Go VRAM (RTX 3060, 4060, 2080 Ti) : C’est le point d’entrée. Vous pourrez fine-tuner des petits modèles (jusqu’à 7-8 milliards de paramètres) avec les bonnes optimisations.
- 16 Go VRAM (RTX 4070, 3080) : On commence à être à l’aise.
- 24 Go VRAM (RTX 3090, 4090) : C’est le luxe. Vous pouvez entraîner des modèles plus gros et plus vite.
Les Logiciels
Il vous faudra un environnement de développement Python. Si vous êtes sur Windows, je recommande chaudement d’utiliser WSL2 (Windows Subsystem for Linux) pour avoir un environnement Linux stable. Vous devrez installer les librairies Python suivantes : torch
, transformers
, datasets
, trl
et le plus important : unsloth
.
Les Données
C’est le carburant de votre fusée. Sans un bon jeu de données, votre projet est voué à l’échec. Il vous faut des exemples de « ce que je demande » et « ce que je veux comme réponse ».
💾 Préparer son Jeu de Données : L’Étape la Plus Importante
C’est ici que 90% des projets de fine-tuning échouent. La qualité de vos données est plus importante que la taille de votre modèle.
Un format très populaire et simple à mettre en place est le format « Alpaca ». Votre jeu de données sera un fichier (souvent un .json
) qui contient une liste d’exemples. Chaque exemple est un objet avec trois clés :
instruction
: Ce que vous demandez au modèle.input
: (Optionnel) Un contexte supplémentaire pour l’instruction.output
: La réponse exacte que vous attendez.
Voici un exemple pour un LLM qui doit générer des commits Git :
[
{
"instruction": "Génère un message de commit pour les changements suivants.",
"input": "diff --git a/app.py b/app.py\n--- a/app.py\n+++ b/app.py\n@@ -1,3 +1,4 @@\n def hello():\n- print('hello world')\n+ print('hello world!')\n+ # Added exclamation mark",
"output": "feat: add punctuation to greeting"
},
{
"instruction": "Génère un message de commit pour les changements suivants.",
"input": "diff --git a/utils.py b/utils.py\n--- a/utils.py\n+++ b/utils.py\n@@ -5,3 +5,5 @@\n \n def new_func():\n+ # This function is not yet implemented\n+ pass",
"output": "chore: add placeholder for new function"
}
]
Insight : La qualité prime sur la quantité. Mieux vaut 200 exemples parfaits et variés que 2000 exemples bruités ou répétitifs. Le principe « Garbage In, Garbage Out » (des déchets en entrée, des déchets en sortie) est la loi numéro 1 du machine learning.
⚙️ Notre Outillage : Le Setup Gagnant
Pour rendre ce défi réalisable, on va utiliser une combinaison gagnante.
1. Le Modèle : Microsoft Phi-3 Mini
C’est la star du moment. Un modèle « petit » (3.8 milliards de paramètres) mais incroyablement performant pour sa taille. Il est assez léger pour être fine-tuné sur un GPU de 12 Go de VRAM. Vous pouvez le trouver sur Hugging Face sous le nom microsoft/phi-3-mini-4k-instruct
.
2. La Librairie : Unsloth
C’est notre arme secrète. Le dépôt GitHub de Unsloth est une pépite. C’est une surcouche aux librairies de Hugging Face qui optimise drastiquement l’utilisation de la mémoire et la vitesse d’entraînement. En gros, ils ont réécrit des parties du code d’entraînement pour qu’il soit jusqu’à 2x plus rapide et consomme 60% de VRAM en moins. C’est ce qui rend le fine-tuning local possible. Il s’intègre parfaitement avec la technique LoRA (Low-Rank Adaptation), qui consiste à ne modifier qu’une toute petite fraction des poids du modèle, ce qui est beaucoup plus efficace.
3. L’Environnement : Google Colab ou WSL2
Si votre PC n’est pas assez puissant ou si vous voulez juste tester, Google Colab offre des GPU gratuits (souvent des T4 avec 16Go de VRAM). C’est une excellente option pour commencer. Sinon, WSL2 sur Windows ou un Linux natif sont parfaits.
🧪 Tutoriel Pas à Pas : Fine-Tuning de Phi-3 avec Unsloth
Assez de théorie, passons à la pratique. Voici à quoi ressemble le script Python.
Étape 0 : Installation
Ouvrez votre terminal (dans WSL2 ou Colab) et installez les dépendances nécessaires.
pip install "unsloth[colab-new] @ git+[https://github.com/unslothai/unsloth.git](https://github.com/unslothai/unsloth.git)"
pip install "wandb" # Optionnel, pour le suivi des métriques
Étape 1 : Le script Python
Créez un fichier finetune.py
. Voici le code complet, que nous allons décortiquer.
import torch
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
# 1. Charger le modèle avec Unsloth (4bit quantization pour économiser la VRAM)
max_seq_length = 2048
dtype = None # Laisser Unsloth décider
load_in_4bit = True
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/phi-3-mini-4k-instruct-gguf", # Version Unsloth de Phi-3
max_seq_length = max_seq_length,
dtype = dtype,
load_in_4bit = load_in_4bit,
)
# 2. Configurer le modèle pour l'entraînement LoRA
model = FastLanguageModel.get_peft_model(
model,
r = 16, # Rang de l'adaptation. 8, 16, 32 sont des valeurs communes.
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",],
lora_alpha = 16,
lora_dropout = 0,
bias = "none",
use_gradient_checkpointing = True,
random_state = 3407,
use_rslora = False,
loftq_config = None,
)
# 3. Préparer les données (format Alpaca)
alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
### Instruction:
{}
### Input:
{}
### Response:
{}"""
def formatting_prompts_func(examples):
instructions = examples["instruction"]
inputs = examples["input"]
outputs = examples["output"]
texts = []
for instruction, input, output in zip(instructions, inputs, outputs):
text = alpaca_prompt.format(instruction, input, output)
texts.append(text)
return { "text" : texts, }
# Charger votre propre dataset
dataset = load_dataset("json", data_files="my_dataset.json", split="train")
dataset = dataset.map(formatting_prompts_func, batched = True,)
# 4. Configurer l'entraîneur
trainer = SFTTrainer(
model = model,
tokenizer = tokenizer,
train_dataset = dataset,
dataset_text_field = "text",
max_seq_length = max_seq_length,
dataset_num_proc = 2,
packing = False,
args = TrainingArguments(
per_device_train_batch_size = 2,
gradient_accumulation_steps = 4,
warmup_steps = 5,
max_steps = 60, # Nombre d'étapes d'entraînement. A ajuster !
learning_rate = 2e-4,
fp16 = not torch.cuda.is_bf16_supported(),
bf16 = torch.cuda.is_bf16_supported(),
logging_steps = 1,
optim = "adamw_8bit",
weight_decay = 0.01,
lr_scheduler_type = "linear",
seed = 3407,
output_dir = "outputs",
),
)
# 5. Lancer l'entraînement !
trainer.train()
# 6. Sauvegarder le modèle
model.save_pretrained("lora_model") # Sauvegarde uniquement l'adaptateur LoRA
Insight : Une fois l’entraînement terminé, vous avez un dossier
lora_model
. Ce n’est pas le modèle complet, juste le « patch ». Pour l’utiliser, vous devez charger le modèle de base puis appliquer ce patch. Il est aussi possible de fusionner les deux pour créer un nouveau modèle autonome que vous pourrez ensuite convertir au format GGUF et utiliser avec des outils comme Ollama ou LM Studio. Pour en savoir plus sur ces outils, consultez notre grand comparatif.
📊 Évaluer le Résultat : Est-ce que ça a Marché ?
Une fois l’entraînement fini, le travail n’est pas terminé. Il faut vérifier si le modèle s’est amélioré.
Prenez quelques exemples de votre jeu de données de test (que le modèle n’a jamais vu pendant l’entraînement). Posez la question au modèle de base (le Phi-3 original) et à votre version fine-tunée.
Exemple :
- Prompt : Génère un message de commit pour un ajout de commentaire.
- Réponse du modèle de base :
feat: add new comments to the code to improve readability
- Réponse du modèle fine-tuné :
docs: clarify code with comments
Si votre modèle fine-tuné adopte le format et le style que vous lui avez appris (ici, le « conventional commit »), c’est une victoire !
Attention cependant au « catastrophic forgetting » (oubli catastrophique). Parfois, en se sur-spécialisant, le modèle peut devenir moins bon sur des tâches générales. C’est un équilibre à trouver.
✅ Conclusion : Alors, Mythe ou Réalité ?
C’est une réalité. En 2025, fine-tuner un LLM puissant sur un PC personnel est à la portée d’un amateur éclairé et bien équipé. Ce n’est plus de la science-fiction. Des outils comme Unsloth ont changé la donne.
Mais le mythe à abattre, c’est que c’est une solution magique. Non, vous n’allez pas transformer un modèle de 3 milliards de paramètres en un concurrent de GPT-4. Le fine-tuning ne donne pas la connaissance, il façonne le comportement.
Le succès de votre projet dépendra de trois choses :
- Votre GPU : La VRAM est reine.
- La qualité de vos données : C’est 80% du travail.
- Votre patience : Attendez-vous à expérimenter, échouer, et recommencer.
Maintenant que vous avez un modèle sur-mesure, il est temps de l’utiliser ! Apprenez à l’intégrer dans vos workflows quotidiens, par exemple en créant des scripts.
➡️ Pour des idées, jetez un œil à nos 5 hacks de productivité avec les LLM en ligne de commande.
L’aventure ne fait que commencer !