Fine-tuning de modèles de langage (LLM)

Le fine-tuning (ajustement fin) représente l'étape suivante dans la personnalisation des modèles de langage, après le prompt engineering et le RAG. Cette technique permet d'adapter un modèle pré-entraîné à des tâches spécifiques ou à un domaine particulier en poursuivant son entraînement sur un ensemble de données ciblées.

Ce guide explore les niveaux de personnalisation des LLM, le processus de fine-tuning, et comment le mettre en œuvre concrètement.

À mesure que votre organisation intègre l'IA, il arrivera un moment où l'application ChatGPT de base ne suffira plus. Il existe plusieurs niveaux de personnalisation des modèles fondamentaux. Voici les meilleures pratiques à suivre :

Complexité : Faible Performance potentielle : Modérée

Optimisez les performances de votre modèle en créant les meilleurs prompts possibles. C'est la première étape et la plus accessible.

Avantages :

• Aucun coût supplémentaire
• Mise en œuvre immédiate
• Pas de compétences techniques avancées requises

Limitations :

• Performances limitées par les capacités du modèle de base
• Nécessite de réitérer les instructions à chaque requête

Quand l'utiliser : Pour tous les cas d'usage en premier lieu, avant d'envisager d'autres approches.

Complexité : Modérée Performance potentielle : Élevée

Connectez des sources de données externes au modèle. L'agent récupère les informations pertinentes avant de générer une réponse, réduisant les erreurs et améliorant la pertinence.

Avantages :

• Accès à des données à jour
• Réduction des hallucinations
• Pas besoin de réentraîner le modèle

Limitations :

• Nécessite une infrastructure (base de données vectorielle)
• Coûts de stockage et d'interrogation
• Dépend de la qualité des sources

Quand l'utiliser : Lorsque vous devez exploiter des données propriétaires ou spécifiques à votre domaine.

Complexité : Élevée Performance potentielle : Très élevée

Ajustez les poids du modèle en continuant son entraînement sur un dataset spécifique. Le modèle “apprend” réellement vos cas d'usage.

Avantages :

• Amélioration drastique sur des tâches spécifiques
• Réduction de la taille des prompts
• Style et ton cohérents

Limitations :

• Nécessite un dataset de qualité (minimum 50-100 exemples)
• Coûts d'entraînement
• Compétences techniques requises
• Risque de surapprentissage

Quand l'utiliser : Lorsque le prompt engineering a atteint ses limites et que vous avez des besoins très spécifiques.

Complexité : Très élevée Performance potentielle : Maximale

Il s'agit d'entraîner le modèle sur un dataset personnalisé qui fait partie intégrante du modèle. Cela va au-delà du fine-tuning pour créer une véritable spécialisation.

Avantages :

• Performance maximale sur un domaine spécifique
• Modèle complètement adapté

Limitations :

• Coûts très élevés
• Nécessite une expertise en ML avancée
• Temps de développement important

Quand l'utiliser : Pour des besoins très spécifiques où le retour sur investissement justifie l'investissement massif.

Le fine-tuning est le processus d'adaptation d'un modèle pré-entraîné à une tâche ou un domaine spécifique en poursuivant son entraînement sur un ensemble de données ciblées.

Imaginez qu'un LLM est comme un étudiant qui a reçu une éducation générale. Le fine-tuning, c'est lui donner une formation spécialisée pour devenir expert dans un domaine particulier.

Vous avez atteint les limites du prompt engineering et devez encore améliorer les performances. Le fine-tuning peut être une bonne solution si :

• Vous souhaitez définir un style, ton, format ou autres aspects qualitatifs spécifiques
• Vous avez des types de réponses spécifiques qui doivent être données à l'utilisateur final
• Les tâches sont trop complexes pour être exprimées dans un prompt

Exemple concret : Un opérateur télécom fine-tune un modèle sur 10 000 conversations de support. Le modèle apprend :

• Le vocabulaire technique spécifique (ADSL, fibre, débit, box)
• Les procédures de dépannage standard
• Le ton empathique et professionnel de la marque

Résultat : 60% des demandes simples sont résolues automatiquement, avec un taux de satisfaction de 85%.

Exemple concret : Un site de mode fine-tune un modèle sur 50 000 descriptions de produits et leurs performances de vente. Le modèle apprend :

• Le style rédactionnel qui convertit le mieux
• Les caractéristiques à mettre en avant par catégorie
• Les associations de produits qui fonctionnent

Résultat : +25% de taux de conversion sur les fiches produits générées par le modèle fine-tuné.

Exemple concret : Une banque d'investissement fine-tune un modèle sur 5 000 rapports financiers annotés. Le modèle apprend :

• La structure standard des rapports financiers
• Les indicateurs clés à extraire
• Les signaux d'alerte dans les formulations

Résultat : Analyse de rapports 10x plus rapide, avec extraction automatique des KPIs et détection d'anomalies.

Pour créer un job de fine-tuning, vous devrez :

1. Construire un dataset
2. Diviser ce dataset en ensemble d'entraînement (training set) et ensemble de test (test set)
3. Entraîner le modèle de votre choix

C'est la partie la plus difficile et la plus longue. Vous devrez construire manuellement un dataset qui décrit les prompts potentiels que le modèle verra en production, avec les réponses attendues.

L'ensemble du dataset doit être construit dans un format de fichier spécifique appelé JSON Lines - extension .jsonl

Chaque ligne du fichier contient un objet JSON complet.

{"instruction": "Come up with a riddle", "input": "", "output": "What's full of keys but can't open a single lock?\nAnswer: A piano."}
{"instruction": "Describe the process of making a paper airplane.", "input": "", "output": "To make a paper airplane, start by folding a piece of paper in half along its width..."}
{"instruction": "Rewrite the given sentence using jargon pertaining to computer engineering.", "input": "We need to construct a data storage system.", "output": "We need to develop a relational database structure."}

Structure des objets :

• instruction : Correspond au prompt qu'un utilisateur écrirait
• input : Correspond à un contexte potentiel (en cas de RAG)
• output : La réponse attendue du modèle

Format pour OpenAI et Mistral :

{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the capital of France?"}, {"role": "assistant", "content": "Paris, as if everyone doesn't know that already."}]}
{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "Who wrote 'Romeo and Juliet'?"}, {"role": "assistant", "content": "Oh, just some guy named William Shakespeare. Ever heard of him?"}]}
{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "How far is the Moon from Earth?"}, {"role": "assistant", "content": "Around 384,400 kilometers. Give or take a few, like that really matters."}]}

Exemple 1 : Assistant juridique

{"instruction": "Analyse ce contrat et identifie les clauses problématiques", "input": "[Texte du contrat]", "output": "J'ai identifié 3 clauses nécessitant votre attention :\n1. Clause 4.2 - Limitation de responsabilité excessive...\n2. Clause 7.1 - Période de préavis non conforme...\n3. Clause 9.3 - Clause de non-concurrence trop large..."}

Exemple 2 : Service client e-commerce

{"instruction": "Un client demande le remboursement d'un article défectueux reçu il y a 35 jours", "input": "Politique de retour : 30 jours", "output": "Je comprends votre frustration concernant cet article défectueux. Bien que notre politique standard soit de 30 jours, nous faisons une exception pour les produits défectueux. Je vais initier immédiatement votre remboursement. Vous recevrez un email de confirmation dans l'heure."}

Exemple 3 : Génération de descriptions produits

{"instruction": "Génère une description pour ce produit", "input": "Chaussures de running Nike Air Zoom Pegasus 40 - Noires - Pointure 42", "output": "Découvrez les Nike Air Zoom Pegasus 40, l'alliance parfaite entre confort et performance. Leur amorti réactif Nike Air vous propulse à chaque foulée, tandis que la tige en mesh respirant assure une ventilation optimale. Idéales pour vos entraînements quotidiens comme vos sorties longues, ces chaussures polyvalentes accompagnent tous les coureurs. Disponibles en noir élégant, pointure 42."}

Diversité : Couvrez différents types de requêtes et scénarios

• Questions simples et complexes
• Différents tons (formel, décontracté, technique)
• Cas limites et situations exceptionnelles

Cohérence : Maintenez un style et une qualité uniformes

• Utilisez toujours la même structure de réponse
• Respectez le même niveau de détail
• Gardez le même ton et la même voix

Qualité > Quantité : Mieux vaut 100 exemples excellents que 1000 moyens

• Vérifiez chaque exemple manuellement
• Assurez-vous que chaque réponse est exacte
• Éliminez les doublons et incohérences

Documentation du domaine : Incluez le vocabulaire et les concepts spécifiques

• Termes techniques de votre secteur
• Acronymes et jargon métier
• Structures de réponse attendues

Une fois votre dataset construit, vous devrez le diviser en deux parties :

Ensemble d'entraînement (Training set) : Les données que le modèle utilisera pour s'entraîner

• Proportion : 70-80% du dataset
• Rôle : Le modèle apprend les patterns de ces données

Ensemble de test (Test set) : Les données que le modèle utilisera pour évaluer ses performances

• Proportion : 20-30% du dataset restant
• Rôle : Permet de vérifier que le modèle généralise bien

Exemple de division :

Si vous avez 100 exemples :

• 70-80 exemples → train.jsonl
• 20-30 exemples → test.jsonl

En suivant ces deux règles, essayez toujours de construire le plus grand dataset possible, mais aussi propre que possible. Par “propre”, nous entendons des prompts réels et des réponses attendues pertinentes pour l'apprentissage du modèle.

Recommandation OpenAI :

• Commencez avec un dataset de 50 lignes
• Évaluez les améliorations de performance
• Si vous voyez des améliorations réelles, construisez un dataset plus large

Recommandations générales par type de tâche :

Une fois votre dataset prêt, vous avez plusieurs options de plateformes pour effectuer le fine-tuning.

LightningAI est une plateforme qui facilite le fine-tuning de modèles open-source.

Avantages :

• Interface utilisateur intuitive
• Gratuit pour débuter (crédits offerts)
• Support de plusieurs modèles open-source

Limitations :

• Pour utiliser le modèle en dehors de LightningAI, vous aurez besoin de développeurs et ingénieurs ML

Modèles disponibles :

• Llama 2 et Llama 3
• Mistral
• Phi-2
• Et d'autres modèles open-source

OpenAI Platform permet de fine-tuner les modèles GPT.

Tarification approximative (à vérifier sur le site OpenAI) :

• Fine-tuning GPT-3.5 : ~$0.008 par 1K tokens (training)
• Utilisation du modèle fine-tuné : ~$0.012 par 1K tokens

Avantages :

• Modèles de très haute qualité
• Infrastructure robuste et scalable
• Documentation excellente

Limitations :

• Coûts
• Modèles propriétaires (vendor lock-in)

Modèles disponibles :

• GPT-4o mini
• GPT-3.5 Turbo
• GPT-4 (sur demande)

Mistral AI propose également du fine-tuning pour ses modèles.

Avantages :

• Modèles performants et européens
• Tarification compétitive
• Open-source pour certains modèles

Modèles disponibles :

• Mistral 7B
• Mistral 8x7B (Mixtral)
• Mistral Medium

Hugging Face AutoTrain : Interface no-code pour fine-tuner des modèles

• AutoTrain
• Gratuit avec vos propres GPUs
• Payant sur leur infrastructure

Google Colab : Pour les plus techniques

• Notebooks gratuits avec GPU (limité)
• Contrôle total du processus
• Nécessite des compétences en Python et ML

RunPod / Vast.ai : Location de GPUs à bas coût

• Flexibilité totale
• Coûts réduits
• Nécessite une expertise technique

# Vérifier le format du dataset
head -n 3 train.jsonl
 
# Vérifier qu'il n'y a pas d'erreurs JSON
python -m json.tool train.jsonl > /dev/null

Sur OpenAI :

# Via l'API
openai api files.create -f train.jsonl -p fine-tune
openai api files.create -f test.jsonl -p fine-tune

openai api fine_tunes.create \
  -t <TRAIN_FILE_ID> \
  -v <TEST_FILE_ID> \
  -m gpt-3.5-turbo \
  --suffix "mon-modele-support-client"

Le fine-tuning peut prendre de quelques minutes à plusieurs heures selon :

• La taille du dataset
• Le modèle choisi
• La charge de la plateforme

Surveillez les métriques :

• Loss (perte) : doit diminuer pendant l'entraînement
• Accuracy (précision) : doit augmenter
• Overfitting : si la performance sur le test set stagne ou diminue

Une fois le fine-tuning terminé, testez le modèle :

import openai
 
response = openai.ChatCompletion.create(
    model="ft:gpt-3.5-turbo:mon-org:mon-modele:abc123",
    messages=[
        {"role": "user", "content": "Question de test"}
    ]
)
 
print(response.choices[0].message.content)

Comparez avec le modèle de base pour mesurer l'amélioration.

✅ Diversifier les exemples : Couvrez tous les cas d'usage possibles

✅ Valider manuellement : Vérifiez chaque exemple avant inclusion

✅ Éviter les biais : Assurez une représentation équilibrée

✅ Documenter : Gardez trace des décisions de création du dataset

❌ Éviter la duplication : Pas d'exemples quasi-identiques

❌ Éviter les contradictions : Des exemples qui se contredisent vont perturber l'apprentissage

Tests quantitatifs :

• Calculez des métriques (accuracy, F1-score, BLEU)
• Comparez avec le modèle de base
• Testez sur un dataset de validation non vu

Tests qualitatifs :

• Testez manuellement sur des cas réels
• Faites tester par les utilisateurs finaux
• Vérifiez la cohérence du ton et du style

A/B Testing :

• Déployez progressivement
• Comparez les performances en conditions réelles
• Mesurez la satisfaction utilisateur

Optimiser le dataset :

• Commencez petit (50-100 exemples)
• Augmentez seulement si nécessaire
• Supprimez les exemples redondants

Choisir le bon modèle :

• Commencez par un modèle plus petit (GPT-3.5 vs GPT-4)
• Ne passez à un modèle plus grand que si vraiment nécessaire

Monitorer l'usage :

• Suivez les coûts d'inférence
• Optimisez les prompts pour réduire les tokens
• Utilisez le cache quand possible

Overfitting (surapprentissage) :

• Le modèle mémorise les exemples au lieu de généraliser
• Solution : Dataset plus large et diversifié, plus de données de test

Dataset trop petit :

• Le modèle n'a pas assez d'exemples pour apprendre
• Solution : Augmenter la taille du dataset progressivement

Mauvaise qualité des données :

• Fautes, incohérences, erreurs factuelles
• Solution : Validation rigoureuse de chaque exemple

Ignorer le test set :

• Ne pas évaluer correctement les performances
• Solution : Toujours garder un test set représentatif et l'utiliser

Mauvais équilibrage :

• Trop d'exemples d'un type, pas assez d'autres
• Solution : Assurer une distribution équilibrée des cas d'usage

Quand utiliser quoi ?

• Prompt Engineering : Toujours commencer par là
• RAG : Besoin d'accès à des connaissances externes ou à jour
• Fine-tuning : Style très spécifique, tâche complexe, ou performances maximales requises

• Droits sur les données : Assurez-vous d'avoir le droit d'utiliser toutes les données d'entraînement
• Droits sur le modèle : Vérifiez les licences (modèles propriétaires vs open-source)
• Usage commercial : Certaines licences interdisent l'usage commercial

• RGPD : Si vos données contiennent des informations personnelles
• Anonymisation : Anonymisez les données sensibles avant fine-tuning
• Localisation : Attention à où les données sont stockées (UE vs USA)

• Biais dans les données : Le fine-tuning peut amplifier les biais présents dans votre dataset
• Représentativité : Assurez-vous que votre dataset représente bien tous vos utilisateurs
• Tests d'équité : Testez le modèle sur différents groupes démographiques

Documentation officielle :

• OpenAI Fine-tuning Guide
• Mistral AI Fine-tuning
• Hugging Face Training

Tutoriels pratiques :

• LightningAI Fine-tuning Tutorial
• DeepLearning.AI - Finetuning LLMs

Outils :

• LitGPT - Fine-tuning open-source facile
• AutoTrain - No-code fine-tuning
• LlamaIndex - Framework pour construire des applications LLM

Datasets d'exemple :

• Hugging Face Datasets
• LightningAI Example Datasets

Le fine-tuning représente une technique puissante pour adapter les modèles de langage à des besoins spécifiques. Bien qu'il nécessite plus d'investissement en temps et en ressources que le prompt engineering ou le RAG, il permet d'atteindre des niveaux de performance supérieurs sur des tâches ciblées.

Points clés à retenir :

• Commencez toujours par le prompt engineering et le RAG avant d'envisager le fine-tuning
• La qualité du dataset est critique : mieux vaut 100 excellents exemples que 1000 moyens
• Évaluez rigoureusement avec un test set représentatif
• Considérez les coûts et la complexité de maintenance
• Assurez-vous d'avoir les droits et de respecter la réglementation

Le fine-tuning n'est pas une solution miracle, mais utilisé correctement, il peut transformer un modèle générique en un assistant spécialisé parfaitement adapté à vos besoins métier.