Optimisation fine d’un LLM open source avec Axolotl en utilisant l’optimisation directe des préférences (DPO)

Tutoriels

Les LLM ont ouvert d’innombrables nouvelles opportunités pour les applications d’IA. Si vous avez déjà souhaité affiner votre propre modèle, ce guide vous montrera comment le faire facilement et sans écrire de code. En utilisant des outils comme Axolotl et DPO, nous parcourrons le processus étape par étape.

Qu’est-ce qu’un LLM?

Un Modèle de Langage Large (LLM) est un modèle d’IA puissant entraîné sur de vastes quantités de données textuelles – des dizaines de billions de caractères – pour prédire le prochain ensemble de mots dans une séquence. Ceci n’a été rendu possible que ces 2 à 3 dernières années grâce aux avancées réalisées dans le calcul GPU, qui ont permis de former de tels modèles énormes en quelques semaines seulement.

Vous avez probablement interagi avec des LLM à travers des produits comme ChatGPT ou Claude auparavant et avez expérimenté directement leur capacité à comprendre et à générer des réponses semblables à celles des humains.

Pourquoi affiner un LLM?

Ne pouvons-nous pas simplement utiliser GPT-4o pour tout? Eh bien, bien qu’il s’agisse du modèle le plus puissant que nous ayons au moment d’écrire cet article, ce n’est pas toujours le choix le plus pratique. Affiner un modèle plus petit, allant de 3 à 14 milliards de paramètres, peut donner des résultats comparables à une fraction du coût. De plus, l’affinement vous permet de posséder votre propriété intellectuelle et réduit votre dépendance à l’égard des tiers.

Comprendre les modèles de base, d’instructions et de chat

Avant de plonger dans l’affinement, il est essentiel de comprendre les différents types de LLM qui existent:

  • Modèles de base : Ils sont pré-entraînés sur de grandes quantités de texte non structuré, tels que des livres ou des données internet. Bien qu’ils aient une compréhension intrinsèque du langage, ils ne sont pas optimisés pour l’inférence et produiront des sorties incohérentes. Les modèles de base sont développés pour servir de point de départ pour le développement de modèles plus spécialisés.
  • Modèles instructifs : Construits sur la base des modèles de base, les modèles instructifs sont affinés en utilisant des données structurées telles que des paires prompt-réponse. Ils sont conçus pour suivre des instructions spécifiques ou répondre à des questions.
  • Modèles de discussion : Également construits sur les modèles de base, mais contrairement aux modèles instructifs, les modèles de discussion sont formés sur des données conversationnelles, ce qui leur permet de s’engager dans un dialogue interactif.

Qu’est-ce que l’apprentissage par renforcement et le DPO ?

L’apprentissage par renforcement (RL) est une technique dans laquelle les modèles apprennent en recevant des retours sur leurs actions. Il est appliqué aux modèles instructifs ou de discussion afin de peaufiner davantage la qualité de leurs sorties. En général, l’apprentissage par renforcement n’est pas effectué sur la base des modèles car il utilise un taux d’apprentissage bien plus bas qui ne suffira pas à faire évoluer suffisamment les performances.

Le DPO est une forme d’apprentissage par renforcement où le modèle est formé en utilisant des paires de bonnes et de mauvaises réponses pour le même prompt/conversation. En présentant ces paires, le modèle apprend à privilégier les bons exemples et à éviter les mauvais.

Quand utiliser le DPO

Le DPO est particulièrement utile lorsque vous souhaitez ajuster le style ou le comportement de votre modèle, par exemple :

  • Ajustements de style : Modifier la longueur des réponses, le niveau de détail ou le degré de confiance exprimé par le modèle.
  • Mesures de sécurité : Entraînez le modèle à décliner de répondre à des demandes potentiellement dangereuses ou inappropriées.

Cependant, le DPO n’est pas adapté pour enseigner au modèle de nouvelles connaissances ou faits. À cette fin, les techniques de Supervised Fine-Tuning (SFT) ou de Retrieval-Augmented Generation (RAG) sont plus appropriées.

Création d’un ensemble de données DPO

Dans un environnement de production, vous généreriez typiquement un ensemble de données DPO en utilisant les retours de vos utilisateurs, par exemple :

  • Retour des utilisateurs : Mise en œuvre d’un mécanisme de pouce levé/pouce baissé sur les réponses.
  • Choix comparatifs : Présenter aux utilisateurs deux sorties différentes et leur demander de choisir la meilleure.

Si vous manquez de données utilisateur, vous pouvez également créer un ensemble de données synthétique en tirant parti de modèles LLM plus grands et plus performants. Par exemple, vous pouvez générer de mauvaises réponses en utilisant un modèle plus petit, puis utiliser GPT-4o pour les corriger.

Pour simplifier, nous utiliserons un ensemble de données prêt à l’emploi de HuggingFace : olivermolenschot/alpaca_messages_dpo_test. Si vous inspectez l’ensemble de données, vous remarquerez qu’il contient des demandes avec des réponses choisies et rejetées — ce sont les bons et les mauvais exemples. Ces données ont été créées de manière synthétique en utilisant GPT-3.5-turbo et GPT-4.

Vous aurez généralement besoin d’un minimum de 500 à 1 000 paires de données pour avoir un entraînement efficace sans surajustement. Les plus grands ensembles de données DPO contiennent jusqu’à 15 000 à 20 000 paires.

Affinage de Qwen2.5 3B Instruct avec Axolotl

Nous allons utiliser Axolotl pour affiner le modèle Qwen2.5 3B Instruct qui se classe actuellement au sommet du Tableau de Classement OpenLLM pour sa catégorie de taille. Avec Axolotl, vous pouvez affiner un modèle sans écrire une seule ligne de code—juste un fichier de configuration YAML. Ci-dessous se trouve le config.yml que nous allons utiliser :

base_model: Qwen/Qwen2.5-3B-Instruct
strict: false

# Axolotl will automatically map the dataset from HuggingFace to the prompt template of Qwen 2.5
chat_template: qwen_25
rl: dpo
datasets:
  - path: olivermolenschot/alpaca_messages_dpo_test
    type: chat_template.default
    field_messages: conversation
    field_chosen: chosen
    field_rejected: rejected
    message_field_role: role
    message_field_content: content

# We pick a directory inside /workspace since that's typically where cloud hosts mount the volume
output_dir: /workspace/dpo-output

# Qwen 2.5 supports up to 32,768 tokens with a max generation of 8,192 tokens
sequence_len: 8192

# Sample packing does not currently work with DPO. Pad to sequence length is added to avoid a Torch bug
sample_packing: false
pad_to_sequence_len: true

# Add your WanDB account if you want to get nice reporting on your training performance
wandb_project:
wandb_entity:
wandb_watch:
wandb_name:
wandb_log_model:

# Can make training more efficient by batching multiple rows together
gradient_accumulation_steps: 1
micro_batch_size: 1

# Do one pass on the dataset. Can set to a higher number like 2 or 3 to do multiple
num_epochs: 1

# Optimizers don't make much of a difference when training LLMs. Adam is the standard
optimizer: adamw_torch

# DPO requires a smaller learning rate than regular SFT
lr_scheduler: constant
learning_rate: 0.00005

# Train in bf16 precision since the base model is also bf16
bf16: auto

# Reduces memory requirements
gradient_checkpointing: true

# Makes training faster (only suported on Ampere, Ada, or Hopper GPUs)
flash_attention: true

# Can save multiple times per epoch to get multiple checkpoint candidates to compare
saves_per_epoch: 1

logging_steps: 1
warmup_steps: 0

Configuration de l’environnement cloud

Pour exécuter l’entraînement, nous utiliserons un service d’hébergement cloud comme Runpod ou Vultr. Voici ce dont vous aurez besoin :

  • Image Docker : Clonez l’image Docker winglian/axolotl-cloud:main fournie par l’équipe Axolotl.
  • *Exigences matérielles : Un GPU avec 80 Go de VRAM (comme un nœud 1×A100 PCIe) sera plus que suffisant pour cette taille de modèle.
  • Stockage : 200 Go de stockage en volume pour accueillir tous les fichiers dont nous avons besoin.
  • Version CUDA : Votre version de CUDA doit être d’au moins 12.1.

*Ce type d’entraînement est considéré comme un affinement complet du LLM et est donc très gourmand en VRAM. Si vous souhaitez exécuter un entraînement localement, sans compter sur des hôtes cloud, vous pourriez tenter d’utiliser QLoRA, qui est une forme d’affinage supervisé. Bien qu’il soit théoriquement possible de combiner DPO & QLoRA, cela est très rarement fait.

Étapes pour commencer l’entraînement

  1. Définir le répertoire de cache HuggingFace :
export HF_HOME=/workspace/hf

Cela garantit que le modèle original est téléchargé sur notre stockage en volume qui est persistant.

  1. Créer un fichier de configuration : Enregistrez le fichier config.yml que nous avons créé précédemment dans /workspace/config.yml.
  1. Démarrer l’entraînement :
python -m axolotl.cli.train /workspace/config.yml

Et voilà ! Votre formation devrait commencer. Après qu’Axolotl ait téléchargé le modèle et les données d’entraînement, vous devriez voir une sortie similaire à ceci : 

[2024-12-02 11:22:34,798] [DEBUG] [axolotl.train.train:98] [PID:3813] [RANK:0] loading model

[2024-12-02 11:23:17,925] [INFO] [axolotl.train.train:178] [PID:3813] [RANK:0] Starting trainer...

L’entraînement devrait prendre seulement quelques minutes à compléter car il s’agit d’un petit ensemble de données de seulement 264 lignes. Le modèle affiné sera enregistré dans /workspace/dpo-output.

Téléchargement du modèle sur HuggingFace

Vous pouvez télécharger votre modèle sur HuggingFace en utilisant l’interface en ligne de commande (CLI) :

  1. Installez l’interface en ligne de commande (CLI) HuggingFace Hub : 
pip install huggingface_hub[cli]
  1. Téléchargez le modèle : 
huggingface-cli upload /workspace/dpo-output yourname/yourrepo

Remplacez yourname/yourrepo par votre nom d’utilisateur HuggingFace réel et le nom du référentiel.

Évaluation de votre modèle affiné

Pour l’évaluation, il est recommandé d’héberger à la fois les modèles d’origine et affinés en utilisant un outil comme Text Generation Inference (TGI). Ensuite, effectuez des inférences sur les deux modèles avec un paramètre de température de 0 (pour garantir des sorties déterministes) et comparez manuellement les réponses des deux modèles.

Cette approche pratique fournit de meilleures informations que de se fier uniquement aux métriques de perte d’évaluation de l’entraînement, qui peuvent ne pas capturer les subtilités de la génération de langage dans les LLM.

Conclusion

Affiner un LLM en utilisant DPO vous permet de personnaliser les modèles pour mieux répondre aux besoins de votre application, tout en maintenant des coûts gérables. En suivant les étapes décrites dans cet article, vous pouvez exploiter la puissance des outils et ensembles de données open source pour créer un modèle qui correspond à vos besoins spécifiques. Que vous souhaitiez ajuster le style des réponses ou mettre en place des mesures de sécurité, DPO offre une approche pratique pour affiner votre LLM.

Joyeux affinage!

Source:
https://www.sitepoint.com/fine-tuning-llm-with-direct-preference-optimization-dpo/