🧬Guide de fine-tuning des LLM

Apprenez toutes les bases et les meilleures pratiques du fine-tuning. Adapté aux débutants.

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

L'affinage / l'entraînement / le post-entraînement des modèles personnalise leur comportement, enrichit 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 le suivi des instructions et le comportement utile en conversation.

• La méthode standard de post-entraînement s'appelle Supervised Fine-Tuning (SFT). D'autres méthodes incluent l'optimisation par préférence (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 la forme de récompenses ou pénalités.

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

• Mettre à jour et 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 LLMs de prédire si un titre a un impact positif ou négatif sur une entreprise.

• Peut utiliser des interactions historiques avec 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 de 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 changer les 70 milliards de nombres, nous ajoutons des matrices fines A et B à chaque poids, et optimisons celles-ci. Cela signifie que nous n'optimisons que 1 % des poids. LoRA correspond à lorsque le modèle original est en 16 bits non quantifié 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 matrices fines 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 RAG est meilleur que l'affinage. C'est false. Vous pouvez entraîner un modèle spécialisé en codage avec l'affinage et le RL tandis que RAG ne peut pas changer les poids du modèle et se contente d'augmenter ce que le modèle voit au moment de l'inférence. Lisez plus de FAQ + idées reçues ici:

🤔FAQ + Le fine-tuning est-il fait pour moi ?

Présentation d'Unsloth Studio : Notre nouvelle interface web open-source pour entraîner et exécuter des modèles. Cela signifie que vous pouvez désormais affiner des modèles sans code et bénéficier de fonctionnalités d'observabilité et de création automatique de jeux de données.

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

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

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

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

• QLoRA combine LoRA avec la 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 fait, LoRA peut égaler le FFT.

• Unsloth tous types de modèles: texte en parole, embeddings, 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 la perte de précision pour QLoRA par rapport à LoRA est désormais en grande partie récupérée.

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 par 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 (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 quants dynamiques 4 bits Unsloth des quantifications. Ces modèles consomment légèrement plus de VRAM que les modèles standard BitsAndBytes 4 bits mais offrent une précision nettement supérieure.

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

• Les modèles sans suffixe sont dans leur format original 16 bits ou 8 bits. Bien qu'il s'agisse des modèles originaux des créateurs officiels, nous incluons parfois des corrections importantes - telles que des correctifs de modèle de conversation 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. Alors que Llama-3 prend 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 en 4 bits, réduisant l'utilisation de mémoire par 4 pour l'affinage. La désactiver active l'affinage LoRA en 16 bits. Vous pouvez également 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 fréquente 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à, cela ne fonctionnera presque certainement pas avec FFT. Et si LoRA échoue, n'assumez pas que le FFT résoudra magiquement le problème.

Vous pouvez aussi faire Texte en parole (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. Afin d'être utiles pour 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 faire cette partie.

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

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

• L'affinage peut apprendre à partir d'un référentiel existant de documents et étendre continuellement sa base de connaissances, mais le simple dépôt de données ne fonctionnera pas aussi bien. Pour des résultats optimaux, sélectionnez 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 dépôt de toutes vos données de code peut en fait 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 notebooks, nous utilisons le jeu de données Alpaca cependant d'autres notebooks 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 hyperparamètres en utilisant les bonnes 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 la façon dont les hyperparamètres affectent l'entraînement, voir :

🧠Hyperparameters Guide

5. Installation et exigences

Vous pouvez utiliser Unsloth de deux manières principales : nos notebooks gratuits ou localement.

Notebooks Unsloth

Nous recommandons aux débutants d'utiliser nos notebooks premiers car c'est la façon la plus simple de commencer avec des étapes guidées. Vous pouvez ensuite exporter les notebooks pour les utiliser localement.

Unsloth propose des notebooks pas à pas pour texte en parole, embeddings, 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 de suffisamment de VRAM et de ressources.

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

🛠️Exigences d'Unsloth

📥Installation

6. Entraînement et évaluation

Une fois que tout est prêt, il est temps d'entraîner ! Si quelque chose ne fonctionne pas, souvenez-vous que vous pouvez toujours modifier 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, qui montre à quel point le modèle apprend de votre jeu de données. Dans de nombreux cas, une perte 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 perte ne diminue pas, vous devrez peut-être ajuster vos paramètres. Si la perte tombe à 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 lot plus grandes.

• per_device_train_batch_size = 2 – Augmentez 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 lot 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 pour voir s'il vous convient. Vous pouvez également 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 tester. Si vous avez déjà utilisé toutes les données d'entraînement, vous devrez alors les évaluer manuellement. Vous pouvez également utiliser des outils d'évaluation automatiques mais gardez à l'esprit que les outils automatisés peuvent ne pas correspondre parfaitement à vos critères d'évaluation.

7. Exécution et déploiement du modèle

Maintenant exécutons 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-tours, nous pouvons désormais également appeler le modèle comme s'il avait vu des conversations passées comme ci-dessous :

Rappel : Unsloth lui-même offre 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, réglez max_new_tokens = 128 sur un nombre plus grand comme 256 ou 1024. Notez que vous devrez aussi attendre plus longtemps le résultat !

Sauvegarde et déploiement

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

🖥️Inférence et déploiement

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

GGUF & llama.cpp

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

vLLM

Nous pouvons maintenant sauvegarder le modèle affiné en tant que petit fichier de 100 Mo appelé adaptateur LoRA comme ci-dessous. Vous pouvez aussi le pousser sur le hub Hugging Face si vous voulez téléverser votre modèle ! N'oubliez pas d'obtenir un token Hugging Face

et d'ajouter votre token ! 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. C'est terminé !

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 fournissent une valeur éducative et considérable :

https://unsloth.ai/blog/ ici ou Si vous avez besoin d'aide pour l'affinage, vous pouvez aussi rejoindre notre serveur DiscordReddit r/unsloth