Affiner un LLM Open Source avec Axolotl à l’aide de l’optimisation des préférences directes (DPO) –

Les LLM ont ouvert d’innombrables nouvelles opportunités pour les applications de l’IA. Si vous avez toujours voulu peaufiner votre propre modèle, ce guide vous montrera comment le faire facilement et sans écrire de code. À l’aide d’outils comme Axolotl et DPO, nous suivrons le processus étape par étape.

Qu’est-ce qu’un LLM ?

Un Large Language Model (LLM) est un puissant modèle d’IA entraîné sur de grandes quantités de données textuelles (des dizaines de milliards de caractères) pour prédire l’ensemble de mots suivant dans une séquence. Cela n’a été rendu possible qu’au cours des 2-3 dernières années grâce aux progrès réalisés dans le calcul GPU, qui ont permis de former des modèles aussi énormes en quelques semaines.

Vous avez probablement déjà interagi avec des LLM via des produits comme ChatGPT ou Claude et avez expérimenté leur capacité à comprendre et à générer des réponses de type humain.

Pourquoi peaufiner un LLM ?

Ne pouvons-nous pas simplement utiliser GPT-4o pour tout ? Eh bien, même s’il s’agit du modèle le plus puissant dont nous disposons au moment de la rédaction de 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 pour une petite fraction du coût. De plus, le réglage fin vous permet de posséder votre propriété intellectuelle et réduit votre dépendance à l’égard de tiers.

Comprendre les modèles de base, d’instruction et de discussion

Avant de se lancer dans la mise au point, 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 textes non structurés, 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 résultats incohérents. Les modèles de base sont développés pour servir de point de départ au développement de modèles plus spécialisés.
• Modèles d’instruction : construits sur des modèles de base, les modèles d’instruction sont affinés à l’aide de données structurées telles que des paires invite-réponse. Ils sont conçus pour suivre des instructions spécifiques ou répondre à des questions.
• Modèles de chat : également construits sur des modèles de base, mais contrairement aux modèles d’instruction, les modèles de chat sont formés sur des données conversationnelles, ce qui leur permet d’engager un dialogue aller-retour.

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 commentaires sur leurs actions. Il est appliqué pour instruire ou discuter avec des modèles afin d’affiner davantage la qualité de leurs sorties. En règle générale, RL n’est pas effectué au-dessus des modèles de base car il utilise un taux d’apprentissage beaucoup plus faible, ce qui ne fera pas suffisamment bouger l’aiguille.

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

Quand utiliser le DPO

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

• Ajustements de style : modifiez 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 à refuser de répondre à des invites potentiellement dangereuses ou inappropriées.

Cependant, DPO n’est pas adapté pour enseigner au modèle de nouvelles connaissances ou de nouveaux faits. À cette fin, les techniques de réglage fin supervisé (SFT) ou de génération augmentée par récupération (RAG) sont plus appropriées.

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

Dans un environnement de production, vous générerez généralement un ensemble de données DPO en utilisant les commentaires de vos utilisateurs, par exemple :

• Commentaires des utilisateurs : mise en œuvre d’un mécanisme de pouce vers le haut/vers le bas sur les réponses.
• Choix comparatifs : présenter aux utilisateurs deux résultats différents et leur demander de choisir le meilleur.

Si vous manquez de données utilisateur, vous pouvez également créer un ensemble de données synthétiques en exploitant des LLM plus volumineux 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 plus de simplicité, 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 invites avec des réponses choisies et rejetées : ce sont les bons et les mauvais exemples. Ces données ont été créées synthétiquement à l’aide de GPT-3.5-turbo et GPT-4.

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

Instruction de réglage fin de Qwen2.5 3B avec Axolotl

Nous utiliserons Axolotl pour affiner le modèle Qwen2.5 3B Instruct qui se classe actuellement en tête du classement. Classement OpenLLM pour sa classe de taille. Avec Axolotl, vous pouvez affiner un modèle sans écrire une seule ligne de code : juste un fichier de configuration YAML. Vous trouverez ci-dessous le config.yml que nous utiliserons :

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 animer la formation, 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 VRAM de 80 Go (comme un nœud PCIe 1 × A100) 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 CUDA doit être au moins 12.1.

*Ce type de formation est considéré comme une mise au point complète du LLM et est donc très intensif en VRAM. Si vous souhaitez organiser une formation localement, sans dépendre d’hôtes cloud, vous pouvez essayer d’utiliser QLoRA, qui est une forme de réglage fin supervisé. Bien qu’il soit théoriquement possible de combiner DPO & QLoRA, cela est très rarement fait.

Étapes pour commencer la formation

1. Définir le répertoire de cache HuggingFace :

export HF_HOME=/workspace/hf

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

2. Créer un fichier de configuration : enregistrez le fichier config.yml que nous avons créé précédemment dans /workspace/config.yml.

3. Commencer la formation :

python -m axolotl.cli.train /workspace/config.yml

Et voilà ! Votre formation devrait commencer. Une fois qu’Axolotl a téléchargé le modèle et les données d’entraînement, vous devriez voir un résultat similaire à celui-ci :

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

La formation ne devrait prendre que quelques minutes puisqu’il s’agit d’un petit ensemble de données de seulement 264 lignes. Le modèle affiné sera enregistré dans /espace de travail/dpo-sortie.

Téléchargement du modèle sur HuggingFace

Vous pouvez télécharger votre modèle sur HuggingFace à l’aide de la CLI :

1. Installez la CLI HuggingFace Hub :

pip install huggingface_hub[cli]

2. Téléchargez le modèle :

huggingface-cli upload /workspace/dpo-output yourname/yourrepo

Remplacez votre nom/votre dépôt par votre nom d’utilisateur et votre nom de référentiel HuggingFace réels.

Évaluation de votre modèle affiné

Pour l’évaluation, il est recommandé d’héberger à la fois les modèles originaux et affinés à l’aide d’un outil tel que Inférence de génération de texte (TGI). Ensuite, effectuez une inférence sur les deux modèles avec un réglage 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 s’appuyer uniquement sur des mesures de perte d’évaluation de la formation, qui peuvent ne pas saisir les nuances de la génération linguistique dans les LLM.

Conclusion

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

Bon réglage !