Ajustez votre propre modèle d’IA : de la donnée au déploiement

L’ajustement (fine-tuning) d’un modèle d’IA peut sembler intimidant, mais il est devenu plus accessible que jamais. Au lieu d’entraîner un modèle à partir de zéro (ce qui nécessite d’énormes ressources de calcul), vous prenez un modèle pré-entraîné et l’adaptez à votre cas d’utilisation spécifique. Imaginez prendre un traducteur généraliste et lui enseigner le jargon de votre secteur : la base est déjà solide, vous ne faites que la spécialiser.

Dans ce guide, vous apprendrez le flux de travail complet : préparer vos données, choisir la bonne approche, ajuster (fine-tuner) à moindre coût et déployer votre modèle. Vous travaillerez sur des exemples concrets en utilisant des outils qui ne nécessitent pas de doctorat en apprentissage automatique.

Comprendre le Fine-Tuning : ce qui se passe réellement

Avant de commencer, clarifions ce que fait le fine-tuning. Un modèle pré-entraîné comprend déjà les modèles linguistiques, les caractéristiques d’image ou les structures de code. Le fine-tuning met à jour les poids du modèle sur vos données spécifiques, afin qu’il apprenne les nuances de votre domaine sans oublier ce qu’il sait déjà.

Il existe deux approches principales :

• Full Fine-Tuning : Met à jour tous les paramètres du modèle. Coûteux en termes de calcul, mais offre une personnalisation maximale. Idéal lorsque vous disposez de données spécifiques au domaine substantielles (plus de 10 000 exemples) et de ressources.
• Parameter-Efficient Fine-Tuning (PEFT) : Met à jour seulement un petit pourcentage des paramètres (souvent 1 à 5 %). Des techniques comme LoRA (Low-Rank Adaptation) rendent cela pratique. Vous conservez le modèle original intact et entraînez de minuscules modules adaptateurs. C’est par là que la plupart des gens devraient commencer.

Pour la plupart des cas d’utilisation, le PEFT est votre allié. Il coûte 10 fois moins en calcul, s’entraîne en quelques heures au lieu de jours, et produit des résultats tout aussi efficaces.

Étape 1 : Préparez vos données d’entraînement

La qualité des données l’emporte toujours sur la quantité. Mille excellents exemples valent mieux qu’un million de médiocres.

Exigences en matière de données :

• 100 à 1 000 exemples minimum pour le PEFT (500 est un bon point de départ)
• Distribution équilibrée — si vous ajustez pour le support client, ne chargez pas votre ensemble de données avec 90 % de tickets de plainte
• Format correspondant à votre cas d’utilisation : paires question-réponse, exemples de classification, extraits de code avec explications

Exemple pratique : Supposons que vous ajustiez pour la classification de documents médicaux. Votre ensemble de données devrait ressembler à ceci :

{
  "instruction": "Classer ce document médical :",
  "input": "Le patient présente une toux persistante depuis 3 semaines, de la fièvre et de la fatigue. La radiographie pulmonaire montre des infiltrats dans le lobe inférieur gauche.",
  "output": "Pneumonie suspectée - nécessite une évaluation urgente"
}
{
  "instruction": "Classer ce document médical :",
  "input": "Bilan de routine. Le patient se sent bien. Signes vitaux normaux. Aucune préoccupation notée.",
  "output": "Examen normal - suivi de routine programmé"
}

Remarquez la cohérence : instruction, input, output. Cette structure aide le modèle à comprendre ce que vous lui demandez.

Liste de contrôle pour la préparation des données :

• Supprimez les doublons et les quasi-doublons
• Corrigez les erreurs évidentes (fautes de frappe, incohérences de formatage)
• Divisez en ensemble d’entraînement (80 %), de validation (10 %) et de test (10 %)
• Assurez-vous que les exemples montrent des cas limites et des variations
• Documentez votre source de données et toutes les étapes de prétraitement

Étape 2 : Choisissez votre outil de Fine-Tuning

Vous avez des options en fonction de votre niveau de confort et de votre budget :

Option A : Hugging Face + Unsloth (Recommandé pour les débutants)

Unsloth est une bibliothèque qui accélère considérablement le fine-tuning. Combinée aux modèles de transformeurs de Hugging Face, c’est la voie la plus simple.

from unsloth import FastLanguageModel
import torch
from datasets import load_dataset
from trl import SFTTrainer

# Charger un petit modèle de base
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/mistral-7b-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
    dtype=torch.float16,
)

# Ajouter les adaptateurs LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # rang LoRA
    lora_alpha=16,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    use_gradient_checkpointing=True,
)

# Charger vos données
dataset = load_dataset("json", data_files="training_data.jsonl")

# Entraîner
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["validation"],
    peft_config=peft_config,
    args=SFTTrainingArguments(
        output_dir="./output",
        learning_rate=2e-4,
        num_train_epochs=3,
        per_device_train_batch_size=2,
    )
)
trainer.train()

Ce processus entier s’exécute sur un GPU grand public (même une RTX 4090 de 24 Go) et coûte moins de 10 $ si vous utilisez le cloud computing.

Option B : API de Fine-Tuning OpenAI (Le plus simple, géré)

Si vous souhaitez que quelqu’un d’autre gère l’infrastructure :

openai api fine_tunes.create \
  -t fine_tune_data.jsonl \
  -m gpt-3.5-turbo

Vous téléchargez votre fichier JSONL et OpenAI s’occupe de tout. Coût : environ 0,08 $ pour 1 000 tokens. Parfait si vous avez 100 à 1 000 exemples.

Option C : Replicate ou Modal (Compromis)

Ces services offrent un fine-tuning géré sans la complexité. Vous poussez le code, ils gèrent l’allocation des GPU.

Étape 3 : Exécuter le Fine-Tuning avec les meilleures pratiques

Hyperparamètres clés à ajuster :

• Taux d’apprentissage (Learning Rate) : Commencez avec 2e-4 pour le PEFT, 5e-5 pour le full fine-tuning. Trop élevé et vous surapprendrez ; trop faible et l’entraînement progressera à peine.
• Taille du lot (Batch Size) : 2-8 pour le PEFT sur du matériel grand public. Les lots plus grands sont plus stables mais nécessitent plus de mémoire.
• Époques (Epochs) : 2-4 pour la plupart des tâches. Au-delà, vous risquez le surapprentissage sur votre petit ensemble de données.
• Étapes d’échauffement (Warmup Steps) : Laissez le modèle s’adapter à l’entraînement sur 100-300 étapes.

Surveillez ces métriques :

• La perte d’entraînement (training loss) doit diminuer en douceur
• La perte de validation (validation loss) doit diminuer puis se stabiliser
• Si la perte de validation augmente tandis que la perte d’entraînement diminue, vous êtes en surapprentissage — réduisez les époques ou ajoutez de la régularisation

Conseil de pro : Faites un essai avec seulement 50 exemples d’abord. Si cela fonctionne, augmentez la taille. Cela vous fera économiser des heures d’expériences ratées.

Étape 4 : Testez et déployez votre modèle

Évaluation avant le déploiement :

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.get_inference_model(
    model=model,  # Votre modèle ajusté
)

prompt = "Classer ce document médical : Le patient présente une fièvre et une toux persistantes."
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=100, temperature=0.7)
print(tokenizer.decode(outputs[0]))

Testez votre modèle sur votre ensemble de test mis de côté et des exemples réels que vous n’avez pas utilisés pendant l’entraînement. Vous recherchez : la précision, la pertinence, l’absence d’hallucinations.

Options de déploiement :

• Hugging Face Spaces : Hébergement gratuit pour l’inférence. Parfait pour les démos. model_id = "votre-nom-utilisateur/votre-modèle" et déployez instantanément.
• vLLM Server : Option auto-hébergée. Exécute votre modèle en tant qu’API. Prend en charge le traitement par lots et l’optimisation GPU.
• Ollama : Exécutez localement sur votre machine ou ordinateur portable. Idéal pour les applications critiques en matière de confidentialité.
• Plateformes Cloud : AWS SageMaker, GCP Vertex AI ou Azure ML pour les charges de travail de production avec mise à l’échelle.

Essayez maintenant : Un projet de Fine-Tuning en 30 minutes

Objectif : Ajuster un petit modèle sur des réponses de support client.

Étape 1 : Créez training_data.jsonl avec 50 échanges de support client :

{"instruction": "Répondez à cette demande de support client :", "input": "Ma commande n'est pas arrivée en 2 semaines", "output": "Je m'excuse pour le retard. Laissez-moi vérifier le statut de votre commande. Pouvez-vous me fournir votre numéro de commande afin que je puisse enquêter ?"}
{"instruction": "Répondez à cette demande de support client :", "input": "Comment réinitialiser mon mot de passe ?", "output": "Allez sur la page de connexion, cliquez sur 'Mot de passe oublié' et suivez les instructions par e-mail."}

Étape 2 : Utilisez Google Colab (GPU gratuit) :

!pip install unsloth
!pip install -q datasets trl peft bitsandbytes
# Collez le code d'entraînement de l'Option A ci-dessus

Étape 3 : Testez votre modèle et téléchargez-le sur Hugging Face Spaces pour une démo en direct.

Temps total : 30 minutes. Coût total : 0 $.

Pièges courants à éviter

• Utiliser trop peu de données : Moins de 50 exemples fonctionne rarement. Visez 200+.
• Ne pas valider sur des données indépendantes : Divisez toujours les données avant l’entraînement. Ne testez pas sur des données que le modèle a vues pendant l’entraînement.
• Surapprentissage à votre domaine : Ajustez le modèle, mais testez-le sur des cas limites réalistes. Gère-t-il les variations ?
• Oublier de sauvegarder vos adaptateurs : Lors de l’utilisation de PEFT, sauvegardez le modèle de base et les adaptateurs LoRA séparément.
• Déployer sans tester : Effectuez toujours des tests d’inférence avant de passer en production. Détectez les hallucinations tôt.