🧬Guide d'affinage des LLM

Apprenez toutes les bases et les meilleures pratiques de l'affinage. Convient aux débutants.

1. Qu'est-ce que l'affinage (fine-tuning) ?

L'affinage / l'entraînement / le post-entraînement de modèles personnalise leur comportement, améliore et injecte des connaissances, et optimise les performances pour des domaines et des tâches spécifiques. Par exemple :

• OpenAI GPT-5 a été post-entraîné pour améliorer la capacité à suivre des instructions et le comportement utile en chat.

• La méthode standard de post-entraînement s'appelle l'affinage supervisé (SFT). D'autres méthodes incluent l'optimisation des préférences (DPO, ORPO), la distillation et l'apprentissage par renforcement (RL) (GRPO, GSPO), où un "agent" apprend à prendre des décisions en interagissant avec un environnement et en recevant des retours sous forme de récompenses ou punitions.

Avec Unsloth, vous pouvez affiner ou faire du RL gratuitement sur Colab, Kaggle ou localement avec seulement 3 Go de VRAM en utilisant nos carnets (notebooks). En affinant un modèle pré-entraîné sur un jeu de données, vous pouvez :

• Mettre à jour + apprendre de nouvelles connaissances: Injecter et apprendre de nouvelles informations spécifiques au domaine.

• Personnaliser le comportement: Ajuster le ton, la personnalité ou le style de réponse du modèle.

• Optimiser pour des tâches: Améliorer la précision et la pertinence pour des cas d'utilisation spécifiques.

Exemples de cas d'utilisation d'affinage ou de RL:

• Permet aux LLM de prédire si un titre impacte positivement ou négativement une entreprise.

• Peut utiliser les interactions historiques des clients pour des réponses plus précises et personnalisées.

• Affiner un LLM sur des textes juridiques pour l'analyse de contrats, la recherche de jurisprudence et la conformité.

Vous pouvez considérer un modèle affiné comme un agent spécialisé conçu pour accomplir des tâches spécifiques de manière plus efficace et efficiente. L'affinage peut reproduire toutes les capacités du RAG, mais pas l'inverse.

❓Qu'est-ce que LoRA/QLoRA ?

Dans les LLM, nous avons des poids de modèle. Llama 70B a 70 milliards de nombres. Au lieu de modifier les 70 milliards de nombres, nous ajoutons plutôt de fines matrices A et B à chaque poids, et optimisons celles-ci. Cela signifie que nous n'optimisons qu'1 % des poids. LoRA correspond au cas où le modèle original n'est pas quantifié en 16 bits tandis que QLoRA quantifie en 4 bits pour économiser 75 % de mémoire.

Au lieu d'optimiser les poids du modèle (jaune), nous optimisons 2 fines matrices A et B.

Idées reçues sur l'affinage :

Vous avez peut-être entendu que l'affinage ne permet pas à un modèle d'apprendre de nouvelles connaissances ou que le RAG fonctionne mieux que l'affinage. C'est faux. Vous pouvez entraîner un modèle spécialisé en codage avec l'affinage et le RL tandis que le RAG ne peut pas modifier les poids du modèle et se contente d'augmenter ce que le modèle voit au moment de l'inférence. Lire plus sur les FAQ + idées reçues ici:

🤔FAQ + L'affinage est-il adapté pour moi ?

2. Choisir le bon modèle + la bonne méthode

Si vous êtes débutant, il est préférable de commencer avec un petit modèle instruct comme Llama 3.1 (8B) et d'expérimenter à partir de là. Vous devrez aussi décider entre l'affinage normal, le RL, QLoRA ou LoRA :

• l'apprentissage par renforcement (RL) est utilisé lorsque vous avez besoin qu'un modèle excelle dans un comportement spécifique (par ex. appel d'outils) en utilisant un environnement et une fonction de récompense plutôt que des données étiquetées. Nous avons plusieurs exemples de carnets (notebook), mais pour la plupart des cas d'utilisation, le SFT standard est suffisant.

• LoRA est une méthode d'entraînement efficace en paramètres qui garde généralement figés les poids du modèle de base et entraîne un petit ensemble de poids adaptateurs à faible rang ajoutés (en précision 16 bits).

• QLoRA combine LoRA avec une précision 4 bits pour gérer des modèles très grands avec des ressources minimales.

• Unsloth prend également en charge l'affinage complet (FFT) et le pré-entraînement, qui nécessitent beaucoup plus de ressources, mais le FFT est généralement inutile. Lorsqu'il est bien réalisé, LoRA peut égaler le FFT.

• Unsloth tous types de modèles: texte en parole (text-to-speech), embedding, GRPO, RL, vision, multimodal et plus.

La recherche montre que s'entraîner et servir dans la même précision aide à préserver la précision. Cela signifie que si vous voulez servir en 4 bits, entraînez en 4 bits et vice versa.

Nous recommandons de commencer par QLoRA, car c'est l'une des méthodes les plus accessibles et efficaces pour entraîner des modèles. Nos quants dynamiques 4 bits réduisent désormais en grande partie la perte de précision de QLoRA par rapport à LoRA.

Vous pouvez changer le nom du modèle par celui que vous souhaitez en le faisant correspondre au nom du modèle sur Hugging Face, par ex. 'unsloth/llama-3.1-8b-unsloth-bnb-4bit'.

Nous recommandons de commencer avec les modèles Instruct, car ils permettent un affinage direct en utilisant des modèles de conversation (ChatML, ShareGPT, etc.) et nécessitent moins de données comparés aux modèles de base (Base models) (qui utilisent Alpaca, Vicuna, etc.). En savoir plus sur les différences entre modèles instruct et modèles de base ici.

• Les noms de modèles se terminant par unsloth-bnb-4bit indiquent qu'ils sont quantifications dynamiques 4 bits Unsloth des quants. Ces modèles consomment légèrement plus de VRAM que les modèles standard BitsAndBytes 4 bits mais offrent une précision significativement plus élevée.

• Si un nom de modèle se termine simplement par bnb-4bit, sans "unsloth", il se réfère à une quantification standard BitsAndBytes 4 bits.

• Les modèles sans suffixe sont dans leur format original 16 bits ou 8 bits. Bien qu'ils soient les modèles originaux des créateurs officiels, nous incluons parfois des correctifs importants - tels que des corrections de template de chat ou de tokenizer. Il est donc recommandé d'utiliser nos versions lorsqu'elles sont disponibles.

Il existe d'autres paramètres que vous pouvez activer/désactiver :

• max_seq_length = 2048 – Contrôle la longueur du contexte. Bien que Llama-3 prenne en charge 8192, nous recommandons 2048 pour les tests. Unsloth permet un affinage avec un contexte 4× plus long.

• dtype = None – Par défaut à None ; utilisez torch.float16 ou torch.bfloat16 pour les GPU plus récents.

• load_in_4bit = True – Active la quantification 4 bits, réduisant l'utilisation mémoire par 4× pour l'affinage. La désactiver active l'affinage LoRA en 16 bits. Vous pouvez aussi activer LoRA 16 bits avec load_in_16bit = True

• Pour activer l'affinage complet (FFT), définissez full_finetuning = True. Pour l'affinage en 8 bits, définissez load_in_8bit = True.

• Remarque : Une seule méthode d'entraînement peut être définie sur True à la fois.

Une erreur courante est de se lancer directement dans l'affinage complet (FFT), qui est gourmand en calcul. Commencez par tester avec LoRA ou QLoRA d'abord ; si cela ne fonctionne pas là-bas, cela ne fonctionnera presque certainement pas avec le FFT. Et si LoRA échoue, ne supposez pas que le FFT résoudra magiquement le problème.

Vous pouvez aussi faire texte en parole (Text-to-speech, TTS), raisonnement (GRPO), vision, RL (GRPO, DPO), pré-entraînement continu, complétion de texte et d'autres méthodologies d'entraînement avec Unsloth.

Lisez notre guide sur le choix des modèles :

❓What Model Should I Use?

Pour des tutoriels individuels sur les modèles :

🚀Complete LLM Directory

3. Votre jeu de données

Pour les LLM, les jeux de données sont des collections de données pouvant être utilisées pour entraîner nos modèles. Pour être utiles à l'entraînement, les données textuelles doivent être dans un format pouvant être tokenisé.

• Vous devrez créer un jeu de données généralement avec 2 colonnes - question et réponse. La qualité et la quantité refléteront en grande partie le résultat final de votre affinage, il est donc impératif de bien réussir cette étape.

• Vous pouvez générer des données de manière synthétique et structurer votre jeu de données (en paires Q/A) en utilisant ChatGPT ou des LLM locaux.

• Vous pouvez également utiliser notre nouveau carnet Synthetic Dataset qui analyse automatiquement des documents (PDF, vidéos, etc.), génère des paires Q/A et nettoie automatiquement les données en utilisant des modèles locaux comme Llama 3.2. Accédez au carnet ici.

• L'affinage peut apprendre à partir d'un référentiel existant de documents et étendre continuellement sa base de connaissances, mais le simple fait de déverser des données ne fonctionnera pas aussi bien. Pour des résultats optimaux, constituez un jeu de données bien structuré, idéalement sous forme de paires question-réponse. Cela améliore l'apprentissage, la compréhension et la précision des réponses.

• Mais, ce n'est pas toujours le cas, par ex. si vous affinez un LLM pour le code, le simple fait de déverser toutes vos données de code peut en réalité permettre à votre modèle d'obtenir des améliorations de performance significatives, même sans formatage structuré. Donc cela dépend vraiment de votre cas d'utilisation.

En savoir plus sur la création de votre jeu de données :

📈Guide des jeux de données

Pour la plupart de nos exemples de carnets, nous utilisons le jeu de données Alpaca cependant d'autres carnets comme Vision utiliseront des jeux de données différents qui peuvent nécessiter des images dans la sortie de la réponse également.

4. Comprendre les hyperparamètres d'entraînement

Apprenez à choisir les bons hyperparamètres en utilisant les meilleures pratiques issues de la recherche et d'expériences réelles - et comprenez comment chacun affecte les performances de votre modèle.

Pour un guide complet sur comment les hyperparamètres affectent l'entraînement, voir :

🧠Hyperparameters Guide

5. Installation + Prérequis

Vous pouvez utiliser Unsloth via deux moyens principaux, nos carnets gratuits ou localement.

Carnets Unsloth

Nous recommandons aux débutants d'utiliser nos carnets (notebooks) premiers car c'est le moyen le plus simple de commencer avec des étapes guidées. Vous pouvez ensuite exporter les carnets pour les utiliser localement.

Unsloth propose des carnets pas à pas pour texte en parole (text-to-speech), embedding, GRPO, RL, vision, multimodal, différents cas d'utilisation et plus.

Installation locale

Vous pouvez aussi installer Unsloth localement via Docker ou pip install unsloth (avec Linux, WSL ou Windows). Selon le modèle que vous utilisez, vous aurez également besoin d'assez de VRAM et de ressources.

L'installation d'Unsloth requerra un appareil Windows ou Linux. Une fois Unsloth installé, vous pouvez copier-coller nos carnets et les utiliser dans votre propre environnement local. Voir :

🛠️Exigences d'Unsloth

📥Installation

6. Entraînement + Évaluation

Une fois que vous avez tout configuré, il est temps d'entraîner ! Si quelque chose ne fonctionne pas, n'oubliez pas que vous pouvez toujours changer les hyperparamètres, votre jeu de données, etc.

Vous verrez un journal de nombres pendant l'entraînement. Il s'agit de la perte d'entraînement (training loss), qui montre à quel point le modèle apprend de votre jeu de données. Dans de nombreux cas, une loss autour de 0,5 à 1,0 est un bon signe, mais cela dépend de votre jeu de données et de la tâche. Si la loss ne diminue pas, vous devrez peut-être ajuster vos paramètres. Si la loss tend vers 0, cela peut signifier un surapprentissage, il est donc important de vérifier la validation également.

La perte d'entraînement apparaîtra sous forme de nombres

Nous recommandons généralement de conserver les paramètres par défaut sauf si vous avez besoin d'un entraînement plus long ou de tailles de batch plus grandes.

• per_device_train_batch_size = 2 – Augmenter pour une meilleure utilisation du GPU mais attention à un entraînement plus lent dû au padding. À la place, augmentez gradient_accumulation_steps pour un entraînement plus fluide.

• gradient_accumulation_steps = 4 – Simule une taille de batch plus grande sans augmenter l'utilisation mémoire.

• max_steps = 60 – Accélère l'entraînement. Pour des exécutions complètes, remplacez par num_train_epochs = 1 (1–3 époques recommandées pour éviter le surapprentissage).

• learning_rate = 2e-4 – Plus bas pour un affinage plus lent mais plus précis. Essayez des valeurs comme 1e-4, 5e-5, ou 2e-5.

Évaluation

Pour évaluer, vous pouvez faire une évaluation manuelle en discutant simplement avec le modèle et voir si cela vous convient. Vous pouvez aussi activer l'évaluation pour Unsloth, mais gardez à l'esprit que cela peut prendre du temps selon la taille du jeu de données. Pour accélérer l'évaluation, vous pouvez : réduire la taille du jeu de données d'évaluation ou définir evaluation_steps = 100.

Pour les tests, vous pouvez aussi prendre 20 % de vos données d'entraînement et les utiliser pour les tests. Si vous avez déjà utilisé toutes les données d'entraînement, alors vous devez les évaluer manuellement. Vous pouvez aussi utiliser des outils d'évaluation automatiques mais gardez à l'esprit que les outils automatisés peuvent ne pas s'aligner parfaitement sur vos critères d'évaluation.

7. Exécution + Déploiement du modèle

Maintenant lançons le modèle après avoir terminé le processus d'entraînement ! Vous pouvez modifier la partie soulignée en jaune ! En fait, parce que nous avons créé un chatbot multi-tour, nous pouvons maintenant aussi appeler le modèle comme s'il avait vu des conversations passées comme ci-dessous :

Rappel : Unsloth lui-même fournit une inférence 2× plus rapide nativement aussi, donc n'oubliez jamais d'appeler FastLanguageModel.for_inference(model). Si vous voulez que le modèle génère des réponses plus longues, définissez max_new_tokens = 128 à un nombre plus grand comme 256 ou 1024. Notez que vous devrez aussi attendre plus longtemps le résultat !

Sauvegarde + Déploiement

Pour sauvegarder et déployer votre modèle dans les moteurs d'inférence souhaités comme Ollama, vLLM, Open WebUI, vous devrez utiliser l'adaptateur LoRA en plus du modèle de base. Nous avons des guides dédiés pour chaque framework :

🖥️Inférence & Déploiement

Si vous exécutez l'inférence sur un appareil unique (comme un ordinateur portable ou un Mac), utilisez llama.cpp pour convertir au format GGUF à utiliser dans Ollama, llama.cpp, LM Studio etc. :

GGUF & llama.cpp

Si vous déployez un LLM pour une entreprise ou une inférence multi-utilisateur pour FP8, AWQ, utilisez vLLM :

vLLM

Nous pouvons maintenant sauvegarder le modèle affiné sous la forme d'un petit fichier de 100 Mo appelé adaptateur LoRA comme ci-dessous. Vous pouvez aussi pousser sur le hub Hugging Face si vous souhaitez téléverser votre modèle ! N'oubliez pas d'obtenir un jeton (token) et d'ajouter votre jeton !

Après avoir sauvegardé le modèle, nous pouvons de nouveau utiliser Unsloth pour exécuter le modèle lui-même ! Utilisez FastLanguageModel à nouveau pour l'appeler en inférence !

8. Nous avons fini !

Vous avez affiné avec succès un modèle de langage et l'avez exporté vers le moteur d'inférence souhaité avec Unsloth !

Pour en savoir plus sur des astuces et conseils d'affinage, rendez-vous sur nos blogs qui offrent une valeur éducative et considérable : https://unsloth.ai/blog/

Si vous avez besoin d'aide sur l'affinage, vous pouvez aussi rejoindre notre serveur Discord ici ou Reddit r/unsloth. Merci de votre lecture et en espérant que cela vous ait été utile !