🧬Guide d'ajustement des LLM

Apprenez toutes les bases et les meilleures pratiques de l'ajustement. Accessible aux débutants.

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

Le fine-tuning / l'entraînement / l'entraînement postérieur adapte le comportement d'un modèle, enrichit et injecte des connaissances, et optimise les performances pour des domaines et des tâches spécifiques. Par exemple :

• OpenAI’s GPT-5 a été post-entraîné pour améliorer le suivi des instructions et un comportement de chat utile.

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

Avec Unsloth, vous pouvez faire du fine-tuning ou du RL gratuitement sur Colab, Kaggle ou localement avec seulement 3 Go de VRAM en utilisant notre 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 d'utilisation du fine-tuning ou du RL:

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

• Peut utiliser des interactions clients historiques 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 ajusté comme un agent spécialisé conçu pour accomplir des tâches spécifiques de manière plus efficace et efficiente. Le fine-tuning 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 contient 70 milliards de nombres. Au lieu de changer ces 70 milliards de nombres, nous ajoutons des matrices fines 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 d'origine 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 (jaunes), nous optimisons 2 matrices fines A et B.

Idées reçues sur le fine-tuning :

Vous avez peut-être entendu que le fine-tuning ne permet pas à un modèle d'apprendre de nouvelles connaissances ou que le RAG est meilleur que le fine-tuning. C'est faux. Vous pouvez entraîner un modèle spécialisé en codage avec le fine-tuning 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. Lisez plus de FAQ + idées reçues ici:

🤔FAQ + L'ajustement est-il fait pour moi ?

2. Choisir le bon modèle + 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 le fine-tuning normal, le RL, QLoRA ou l'entraînement LoRA :

• 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 notebooks, mais pour la plupart des cas d'usage, la SFT standard suffit.

• LoRA est une méthode d'entraînement efficace en paramètres qui conserve généralement les poids du modèle de base gelés et entraîne un petit ensemble de poids d'adaptateur à 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 supporte également le fine-tuning 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 correctement réalisé, LoRA peut égaler le FFT.

• Unsloth tous types de modèles: texte en parole, embedding, GRPO, RL, vision, multimodal et plus.

La recherche montre que 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 quants, 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 le modèle de votre choix 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 les modèles Instruct, car ils permettent un fine-tuning direct en utilisant des modèles de conversation (ChatML, ShareGPT, etc.) et nécessitent moins de données par rapport aux modèles Base (qui utilisent Alpaca, Vicuna, etc.). En savoir plus sur les différences entre modèles instruct et base ici.

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

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

• Les modèles avec aucun suffixe sont dans leur format d'origine 16 bits ou 8 bits. Bien qu'ils soient les modèles originaux des créateurs officiels, nous incluons parfois des corrections importantes - telles que des corrections de template de chat ou de tokenizer. Il est donc recommandé d'utiliser nos versions lorsque 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 supporte 8192, nous recommandons 2048 pour les tests. Unsloth permet un fine-tuning avec un contexte 4× plus long.

• dtype = None – Par défaut sur 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 de 4× pour le fine-tuning. La désactiver permet le fine-tuning LoRA en 16 bits. Vous pouvez aussi activer LoRA 16 bits avec load_in_16bit = True

• Pour activer le fine-tuning complet (FFT), définissez full_finetuning = True. Pour le fine-tuning 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 le fine-tuning complet (FFT), qui est coûteux en calcul. Commencez par tester avec LoRA ou QLoRA d'abord ; si cela ne fonctionne pas là, cela ne fonctionnera presque certainement pas avec le FFT. Et si LoRA échoue, ne supposez pas que le FFT le réparera magiquement.

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 :

🚀LLM Tutorials 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 qui peut ê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 fine-tune, il est donc impératif de bien réussir cette partie.

• Vous pouvez générer des données de façon synthétique et structurer votre jeu de données (en paires Q&A) en utilisant ChatGPT ou des LLM locaux.

• Vous pouvez aussi utiliser notre nouveau notebook 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 notebook ici.

• Le fine-tuning peut apprendre 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, 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 exemple si vous affinez un LLM pour le code, le simple fait de fournir 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 bons hyperparamètres en utilisant les meilleures pratiques issues de la recherche et d'expériences réelles - et comprenez comment chacun influence 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 + Prérequis

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

Notebooks Unsloth

Nous recommandons aux débutants d'utiliser d'abord nos notebooks 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, embedding, GRPO, RL, vision, multimodal, différents cas d'usage 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 aussi besoin d'assez 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 + É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. C'est 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 également la validation.

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. Augmentez plutôt 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 runs complets, remplacez par num_train_epochs = 1 (1–3 époques recommandées pour éviter le surapprentissage).

• learning_rate = 2e-4 – Plus bas pour un fine-tuning 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 é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 tests. Si vous avez déjà utilisé toutes les données d'entraînement, alors vous devez l'évaluer manuellement. Vous pouvez aussi 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 + Déploiement du modèle

Exécutons maintenant 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 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 2x plus rapide nativement également, donc n'oubliez jamais d'appeler FastLanguageModel.for_inference(model). Si vous voulez que le modèle produise des réponses plus longues, réglez max_new_tokens = 128 sur un nombre plus grand comme 256 ou 1024. Notez que vous devrez attendre plus longtemps pour le résultat également !

Sauvegarde + 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 par-dessus le 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 seul appareil (comme un ordinateur portable ou 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 inférence d'entreprise ou 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 également pousser sur le hub Hugging Face si vous souhaitez téléverser votre modèle ! N'oubliez pas d'obtenir un jeton et ajoutez votre token !

Après avoir enregistré le modèle, nous pouvons à nouveau utiliser Unsloth pour exécuter le modèle lui-même ! Utilisez FastLanguageModel à nouveau pour l'appeler pour l'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 les astuces et conseils de fine-tuning, rendez-vous sur nos blogs qui offrent une grande valeur éducative : https://unsloth.ai/blog/

Si vous avez besoin d'aide pour le fine-tuning, vous pouvez aussi rejoindre notre serveur Discord ici ou Reddit r/unsloth. Merci d'avoir lu et espérons que cela vous a été utile !