Rienadire

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Fine-tuning de modèles de langage (LLM) ======

===== Introduction =====

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.

===== Les niveaux de personnalisation des LLM =====

À 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 :

{{ :ai:image_5_.png?400 |}}

==== Niveau 1 : Prompt Engineering ====

**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.

==== Niveau 2 : RAG (Retrieval-Augmented Generation) ====

**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.

==== Niveau 3 : Fine-tuning ====

**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.

==== Niveau 4 : Continued Training (Entraînement continu) ====

**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.

===== Qu'est-ce que le fine-tuning ? =====

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.

===== Quand le fine-tuning est-il nécessaire ? =====

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

===== Cas d'usage concrets en entreprise =====

==== 1. Automatisation du support client ====

^ Scénario ^ Problème initial ^ Solution ^ Bénéfices ^
| Une entreprise souhaite déployer un assistant virtuel pour gérer les demandes clients plus efficacement | Le LLM générique ne comprend pas pleinement les produits, services ou jargon spécifiques de l'entreprise | Fine-tuner le LLM sur les historiques d'interactions du service client, FAQs et documentation produits rend l'assistant plus apte à résoudre les problèmes, fournir des informations précises et comprendre le contexte des demandes | Amélioration de la satisfaction client, réduction des délais de résolution, charge de travail réduite pour les agents humains |

**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%.

==== 2. Personnalisation de contenu en e-commerce ====

^ Scénario ^ Problème initial ^ Solution ^ Bénéfices ^
| Une plateforme e-commerce vise à améliorer l'engagement des utilisateurs en fournissant des descriptions de produits et recommandations personnalisées | Le LLM générique génère des descriptions et recommandations génériques qui ne résonnent pas avec les segments d'utilisateurs spécifiques | Fine-tuner le LLM sur les données de comportement utilisateur, historique d'achats et avis produits permet au modèle de générer du contenu plus pertinent et personnalisé | Augmentation des taux de conversion, amélioration de l'expérience utilisateur, fidélisation client en fournissant du contenu aligné avec les préférences individuelles |

**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é.

==== 3. Analyse de documents financiers ====

^ Scénario ^ Problème initial ^ Solution ^ Bénéfices ^
| Une société de services financiers doit analyser et résumer de grands volumes de documents financiers (rapports de résultats, analyses de marché, dépôts réglementaires) | Le LLM générique peut avoir du mal avec la terminologie spécialisée et les détails complexes typiques des documents financiers | Fine-tuner le LLM sur un dataset de textes financiers (rapports passés, articles de presse financière, documents réglementaires) permet au modèle de mieux comprendre et traiter ces informations | Résumés plus précis et perspicaces, temps de traitement réduits, capacités de prise de décision améliorées pour les analystes et parties prenantes |

**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.

===== Comment créer un job de fine-tuning ? =====

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

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

==== Étape 1 : Construire un dataset ====

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.

=== Format du fichier : JSON Lines (.jsonl) ===

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.

=== Format LightningAI ===

<code json>
{"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."}
</code>

**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 OpenAI / Mistral ===

<WRAP center round important 80%>
**IMPORTANT** : Selon la plateforme sur laquelle vous effectuerez votre fine-tuning, le format attendu peut différer.
</WRAP>

Format pour OpenAI et Mistral :

<code json>
{"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."}]}
</code>

=== Exemples pratiques de construction de dataset ===

**Exemple 1 : Assistant juridique**

<code json>
{"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..."}
</code>

**Exemple 2 : Service client e-commerce**

<code json>
{"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."}
</code>

**Exemple 3 : Génération de descriptions produits**

<code json>
{"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."}
</code>

=== Conseils pour créer un dataset de qualité ===

**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

==== Étape 2 : Division Train/Test ====

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''

<WRAP center round tip 80%>
**Astuce** : Assurez-vous que le test set représente bien la diversité de vos cas d'usage. Ne mettez pas tous les cas faciles dans le train et tous les cas difficiles dans le test (ou vice versa).
</WRAP>

=== Quelle est la taille idéale du dataset ? ===

<WRAP center round important 80%>
**NOTE** : Il existe deux règles simples à suivre :

  - **Plus de données, c'est mieux**
  - **Garbage in, garbage out** (données de mauvaise qualité = résultats de mauvaise qualité)
</WRAP>

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** :

^ Type de tâche ^ Minimum recommandé ^ Idéal ^
| Style et ton | 50-100 exemples | 500-1000 |
| Tâche simple (classification) | 100-200 exemples | 1000-2000 |
| Tâche complexe (analyse) | 500-1000 exemples | 5000-10000 |
| Génération créative | 1000-2000 exemples | 10000+ |

==== Étape 3 : Lancer le job de fine-tuning ====

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

===== Plateformes de fine-tuning =====

==== LightningAI ====

[[https://lightning.ai/|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 ====

[[https://platform.openai.com/|OpenAI Platform]] permet de fine-tuner les modèles GPT.

<WRAP center round alert 80%>
**IMPORTANT** : Le fine-tuning OpenAI n'est **PAS gratuit**

Le fine-tuning sur OpenAI a un coût (généralement moins de 1€ pour un petit dataset, mais peut monter rapidement). Les jobs de fine-tuning ne sont **pas inclus** dans l'abonnement GPT+. Vous devrez payer en plus.
</WRAP>

**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 ====

[[https://mistral.ai/|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

==== Alternatives open-source ====

**Hugging Face AutoTrain** : Interface no-code pour fine-tuner des modèles
  * [[https://huggingface.co/autotrain|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

===== Processus de fine-tuning étape par étape =====

==== 1. Préparation ====

<code bash>
# 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
</code>

==== 2. Upload du dataset ====

Sur OpenAI :
<code bash>
# Via l'API
openai api files.create -f train.jsonl -p fine-tune
openai api files.create -f test.jsonl -p fine-tune
</code>

==== 3. Lancement du fine-tuning ====

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

==== 4. Monitoring ====

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

==== 5. Évaluation ====

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

<code python>
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)
</code>

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

===== Bonnes pratiques =====

==== Qualité du dataset ====

✅ **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

==== Évaluation rigoureuse ====

**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

==== Gestion des coûts ====

**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

===== Erreurs courantes à éviter =====

**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

===== Fine-tuning vs autres approches =====

^ Critère ^ Prompt Engineering ^ RAG ^ Fine-tuning ^
| **Complexité** | Faible | Moyenne | Élevée |
| **Coût** | Gratuit | Moyen (infrastructure) | Élevé (données + compute) |
| **Temps de mise en œuvre** | Immédiat | Jours/semaines | Semaines/mois |
| **Flexibilité** | Très flexible | Flexible | Rigide (nécessite réentraînement) |
| **Performance** | Bonne | Très bonne | Excellente (sur tâche spécifique) |
| **Maintenance** | Facile | Moyenne | Complexe |
| **Données requises** | Aucune | Documents/connaissances | Dataset annoté (50-10000+ exemples) |

**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

===== Considérations éthiques et légales =====

==== Propriété intellectuelle ====

  * **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

==== Protection des données ====

  * **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 et équité ====

  * **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

===== Ressources complémentaires =====

**Documentation officielle** :
  * [[https://platform.openai.com/docs/guides/fine-tuning|OpenAI Fine-tuning Guide]]
  * [[https://docs.mistral.ai/capabilities/finetuning/|Mistral AI Fine-tuning]]
  * [[https://huggingface.co/docs/transformers/training|Hugging Face Training]]

**Tutoriels pratiques** :
  * [[https://lightning.ai/docs/pytorch/stable/advanced/finetuning.html|LightningAI Fine-tuning Tutorial]]
  * [[https://www.deeplearning.ai/short-courses/finetuning-large-language-models/|DeepLearning.AI - Finetuning LLMs]]

**Outils** :
  * [[https://github.com/Lightning-AI/lit-gpt|LitGPT]] - Fine-tuning open-source facile
  * [[https://github.com/huggingface/autotrain-advanced|AutoTrain]] - No-code fine-tuning
  * [[https://www.llamaindex.ai/|LlamaIndex]] - Framework pour construire des applications LLM

**Datasets d'exemple** :
  * [[https://huggingface.co/datasets|Hugging Face Datasets]]
  * [[https://github.com/Lightning-AI/lit-gpt/tree/main/tutorials|LightningAI Example Datasets]]

===== Conclusion =====

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.