Modèles et plateformes d’IA
L’optimisation directe des préférences : Un guide complet
Ajouter Unite.AI à vos sources préférées sur Google
Aligner les grands modèles de langage (LLM) avec les valeurs et les préférences humaines est un défi. Les méthodes traditionnelles, telles que l’apprentissage par renforcement à partir de commentaires humains (RLHF), ont ouvert la voie en intégrant les entrées humaines pour raffiner les sorties de modèle. Cependant, le RLHF peut être complexe et gourmand en ressources, nécessitant une puissance de calcul et un traitement de données importants. L’optimisation directe des préférences (DPO) émerge comme une approche novatrice et plus simplifiée, offrant une alternative efficace à ces méthodes traditionnelles. En simplifiant le processus d’optimisation, la DPO réduit non seulement la charge de calcul, mais améliore également la capacité du modèle à s’adapter rapidement aux préférences humaines.
Dans ce guide, nous allons plonger dans les fondements, la mise en œuvre et les applications pratiques de la DPO.
Le besoin d’alignement des préférences
Pour comprendre la DPO, il est essentiel de comprendre pourquoi l’alignement des LLM avec les préférences humaines est si important. Malgré leurs capacités impressionnantes, les LLM entraînés sur des ensembles de données vastes peuvent parfois produire des sorties qui sont incohérentes, biaisées ou non alignées avec les valeurs humaines. Ce désalignement peut se manifester de diverses manières :
- Générer du contenu non sécurisé ou nocif
- Fournir des informations inexactes ou trompeuses
- Présenter des biais présents dans les données d’entraînement
Pour résoudre ces problèmes, les chercheurs ont développé des techniques pour affiner les LLM à l’aide de commentaires humains. La méthode la plus prometteuse de ces approches a été le RLHF.
Comprendre le RLHF : Le prédécesseur de la DPO
L’apprentissage par renforcement à partir de commentaires humains (RLHF) a été la méthode de choix pour aligner les LLM avec les préférences humaines. Décomposons le processus RLHF pour comprendre ses complexités :
a) Affinement supervisé (SFT) : Le processus commence par l’affinement d’un LLM pré-entraîné sur un ensemble de données de réponses de haute qualité. Cette étape aide le modèle à générer des sorties plus pertinentes et cohérentes pour la tâche cible.
b) Modélisation de la récompense : Un modèle de récompense distinct est entraîné pour prédire les préférences humaines. Cela implique :
- Générer des paires de réponses pour des invites données
- Demander aux humains de noter quelle réponse ils préfèrent
- Entraîner un modèle pour prédire ces préférences
c) Apprentissage par renforcement : Le LLM affiné est ensuite optimisé à l’aide de l’apprentissage par renforcement. Le modèle de récompense fournit des commentaires, guidant le LLM pour générer des réponses qui s’alignent sur les préférences humaines.
Voici un pseudocode Python simplifié pour illustrer le processus RLHF :
Bien que efficace, le RLHF présente plusieurs inconvénients :
- Il nécessite l’entraînement et la maintenance de plusieurs modèles (SFT, modèle de récompense et modèle optimisé par RL)
- Le processus RL peut être instable et sensible aux hyperparamètres
- Il est gourmand en calcul, nécessitant de nombreuses passes avant et arrière à travers les modèles
Ces limites ont motivé la recherche de solutions plus simples et plus efficaces, conduisant au développement de la DPO.
Optimisation directe des préférences : Concepts fondamentaux
Optimisation directe des préférences https://arxiv.org/abs/2305.18290
Cette image contraste deux approches distinctes pour aligner les sorties de LLM avec les préférences humaines : l’apprentissage par renforcement à partir de commentaires humains (RLHF) et l’optimisation directe des préférences (DPO). Le RLHF repose sur un modèle de récompense pour guider la politique du modèle de langage à travers des boucles de commentaires itératives, tandis que la DPO optimise directement les sorties du modèle pour correspondre aux réponses préférées par les humains en utilisant des données de préférence. Cette comparaison met en évidence les forces et les applications potentielles de chaque méthode, fournissant des insights sur la façon dont les futurs LLM pourraient être entraînés pour mieux s’aligner sur les attentes humaines.
Idées clés derrière la DPO :
a) Modélisation implicite de la récompense : La DPO élimine le besoin d’un modèle de récompense distinct en traitant le modèle de langage lui-même comme une fonction de récompense implicite.
b) Formulation basée sur la politique : Au lieu d’optimiser une fonction de récompense, la DPO optimise directement la politique (modèle de langage) pour maximiser la probabilité de réponses préférées.
c) Solution en forme fermée : La DPO exploite une perspective mathématique qui permet une solution en forme fermée à la politique optimale, évitant ainsi le besoin de mises à jour itératives de RL.
Mise en œuvre de la DPO : Une démonstration pratique de code
L’image ci-dessous présente un extrait de code mettant en œuvre la fonction de perte DPO à l’aide de PyTorch. Cette fonction joue un rôle crucial dans l’affinement de la façon dont les modèles de langage donnent la priorité aux sorties en fonction des préférences humaines. Voici une décomposition des composants clés :
- Signature de la fonction : La fonction
dpo_lossprend plusieurs paramètres, notamment les logarithmes de probabilité de la politique (pi_logps), les logarithmes de probabilité du modèle de référence (ref_logps), et les indices représentant les complétions préférées et non préférées (yw_idxs,yl_idxs). De plus, un paramètrebetacontrôle la force de la pénalité de divergence de KL. - Extraction des logarithmes de probabilité : Le code extrait les logarithmes de probabilité pour les complétions préférées et non préférées à partir des modèles de politique et de référence.
- Calcul du rapport logarithmique : La différence entre les logarithmes de probabilité pour les complétions préférées et non préférées est calculée pour les modèles de politique et de référence. Ce rapport est crucial pour déterminer la direction et l’amplitude de l’optimisation.
- Calcul de la perte et de la récompense : La perte est calculée à l’aide de la fonction
logsigmoid, tandis que les récompenses sont déterminées en mettant à l’échelle la différence entre les logarithmes de probabilité de la politique et du modèle de référence parbeta.
Fonction de perte DPO à l’aide de PyTorch
Plongeons dans les mathématiques derrière la DPO pour comprendre comment elle atteint ces objectifs.
Les mathématiques de la DPO
La DPO est une reformulation astucieuse du problème d’apprentissage de préférences. Voici une décomposition étape par étape :
a) Point de départ : Maximisation de la récompense avec contrainte de KL
L’objectif original du RLHF peut être exprimé comme suit :
- πθ est la politique (modèle de langage) que nous optimisons
- r(x,y) est la fonction de récompense
- πref est une politique de référence (généralement le modèle SFT initial)
- β contrôle la force de la contrainte de divergence de KL
b) Forme de la politique optimale : Il peut être démontré que la politique optimale pour cet objectif prend la forme :
π_r(y|x) = 1/Z(x) * πref(y|x) * exp(1/β * r(x,y))Où Z(x) est une constante de normalisation.
c) Dualité récompense-politique : L’insight clé de la DPO est d’exprimer la fonction de récompense en termes de la politique optimale :
r(x,y) = β * log(π_r(y|x) / πref(y|x)) + β * log(Z(x))d) Supposant que les préférences suivent le modèle de Bradley-Terry, on peut exprimer la probabilité de préférer y1 à y2 comme suit :
p*(y1 ≻ y2 | x) = σ(r*(x,y1) - r*(x,y2))Où σ est la fonction logistique.
e) Objectif de la DPO En substituant notre dualité récompense-politique dans le modèle de préférence, nous arrivons à l’objectif de la DPO :
L_DPO(πθ; πref) = -E_(x,y_w,y_l)~D [log σ(β * log(πθ(y_w|x) / πref(y_w|x)) - β * log(πθ(y_l|x) / πref(y_l|x)))]Cet objectif peut être optimisé en utilisant des techniques de descente de gradient standard, sans le besoin d’algorithmes de RL.
Mise en œuvre de la DPO
Maintenant que nous comprenons la théorie derrière la DPO, regardons comment la mettre en œuvre en pratique. Nous allons utiliser Python et PyTorch pour cet exemple :
import torch
import torch.nn.functional as F
<p>class DPOTrainer:
def __init__(self, model, ref_model, beta=0.1, lr=1e-5):
self.model = model
self.ref_model = ref_model
self.beta = beta
self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)</p>
<p>def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
"""
pi_logps: logarithmes de probabilité de la politique, forme (B,)
ref_logps: logarithmes de probabilité du modèle de référence, forme (B,)
yw_idxs: indices de complétions préférées dans [0, B-1], forme (T,)
yl_idxs: indices de complétions non préférées dans [0, B-1], forme (T,)
beta: température contrôlant la force de la pénalité de KL</p>
<p>Chaque paire de (yw_idxs[i], yl_idxs[i]) représente les indices d'une seule paire de préférence.
"""</p>
<p># Extraire les logarithmes de probabilité pour les complétions préférées et non préférées
pi_yw_logps, pi_yl_logps = pi_logps[yw_idxs], pi_logps[yl_idxs]
ref_yw_logps, ref_yl_logps = ref_logps[yw_idxs], ref_logps[yl_idxs]</p>
<p># Calculer les rapports logarithmiques
pi_logratios = pi_yw_logps - pi_yl_logps
ref_logratios = ref_yw_logps - ref_yl_logps</p>
<p># Calculer la perte DPO
losses = -F.logsigmoid(self.beta * (pi_logratios - ref_logratios))
rewards = self.beta * (pi_logps - ref_logps).detach()</p>
return losses.mean(), rewards
<p>def train_step(self, batch):
x, yw_idxs, yl_idxs = batch
self.optimizer.zero_grad()</p>
<p># Calculer les logarithmes de probabilité pour le modèle et le modèle de référence
pi_logps = self.model(x).log_softmax(-1)
ref_logps = self.ref_model(x).log_softmax(-1)</p>
<p># Calculer la perte
loss, _ = self.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
loss.backward()
self.optimizer.step()</p>
return loss.item()
<p># Utilisation
model = YourLanguageModel() # Initialiser votre modèle
ref_model = YourLanguageModel() # Charger le modèle de référence pré-entraîné
trainer = DPOTrainer(model, ref_model)</p>
<p>for batch in dataloader:
loss = trainer.train_step(batch)
print(f"Perte: {loss}")
Défis et directions futures
Bien que la DPO offre des avantages significatifs par rapport aux approches RLHF traditionnelles, il existe encore des défis et des domaines de recherche à explorer :
a) Scalabilité à des modèles plus grands :
À mesure que les modèles de langage continuent de grandir en taille, appliquer efficacement la DPO à des modèles avec des centaines de milliards de paramètres reste un défi ouvert. Les chercheurs explorent des techniques telles que :
- Méthodes d’affinement efficaces (par exemple, LoRA, prefix tuning)
- Optimisations d’entraînement distribué
- Checkpointing de gradient et entraînement à précision mixte
Exemple d’utilisation de LoRA avec la DPO :
<p>from peft import LoraConfig, get_peft_model</p> <p>class DPOTrainerWithLoRA(DPOTrainer): def __init__(self, model, ref_model, beta=0.1, lr=1e-5, lora_rank=8): lora_config = LoraConfig( r=lora_rank, lora_alpha=32, target_modules=["q_proj", "v_proj"], lora_dropout=0.05, bias="none", task_type="CAUSAL_LM" ) self.model = get_peft_model(model, lora_config) self.ref_model = ref_model self.beta = beta self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)</p> <p># Utilisation base_model = YourLargeLanguageModel() dpo_trainer = DPOTrainerWithLoRA(base_model, ref_model)
b) Adaptation multi-tâche et à few-shot :
Développer des techniques DPO qui peuvent s’adapter efficacement à de nouveaux tâches ou domaines avec des données de préférence limitées est un domaine de recherche actif. Les approches explorées incluent :
- Cadres d’apprentissage meta pour une adaptation rapide
- Affinement basé sur les invites pour la DPO
- Apprentissage de transfert à partir de modèles de préférence généraux à des domaines spécifiques
c) Gestion de préférences ambigües ou contradictoires :
Les données de préférence réelles contiennent souvent des ambiguïtés ou des contradictions. Améliorer la robustesse de la DPO face à ces données est crucial. Les solutions potentielles incluent :
- Modélisation de préférence probabiliste
- Apprentissage actif pour résoudre les ambiguïtés
- Agrégation de préférences multi-agents
Exemple de modélisation de préférence probabiliste :
<p>class ProbabilisticDPOTrainer(DPOTrainer): def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob): # Calculer les rapports logarithmiques pi_yw_logps, pi_yl_logps = pi_logps[yw_idxs], pi_logps[yl_idxs] ref_yw_logps, ref_yl_logps = ref_logps[yw_idxs], ref_logps[yl_idxs]</p> <p>log_ratio_diff = pi_yw_logps.sum(-1) - pi_yl_logps.sum(-1) loss = -(preference_prob * F.logsigmoid(self.beta * log_ratio_diff) + (1 - preference_prob) * F.logsigmoid(-self.beta * log_ratio_diff)) return loss.mean()</p> <p># Utilisation trainer = ProbabilisticDPOTrainer(model, ref_model) loss = trainer.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob=0.8) # 80% de confiance dans la préférence
d) Combinaison de la DPO avec d’autres techniques d’alignement :
Intégrer la DPO avec d’autres approches d’alignement pourrait conduire à des systèmes plus robustes et capables :
- Principes d’IA constitutionnelle pour la satisfaction explicite des contraintes
- Débat et modélisation de récompense récursive pour l’élicitation de préférences complexes
- Apprentissage de récompense inverse pour inférer les fonctions de récompense sous-jacentes
Exemple de combinaison de la DPO avec l’IA constitutionnelle :
<p>class ConstitutionalDPOTrainer(DPOTrainer): def __init__(self, model, ref_model, beta=0.1, lr=1e-5, constraints=None): super().__init__(model, ref_model, beta, lr) self.constraints = constraints or []</p> <p>def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs): base_loss = super().compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)</p> <p>constraint_loss = 0 for constraint in self.constraints: constraint_loss += constraint(self.model, pi_logps, ref_logps, yw_idxs, yl_idxs)</p> return base_loss + constraint_loss <p># Utilisation def safety_constraint(model, pi_logps, ref_logps, yw_idxs, yl_idxs): # Implémenter la logique de vérification de sécurité unsafe_score = compute_unsafe_score(model, pi_logps, ref_logps) return torch.relu(unsafe_score - 0.5) # Pénaliser si le score de sécurité > 0.5</p> <p>constraints = [safety_constraint] trainer = ConstitutionalDPOTrainer(model, ref_model, constraints=constraints)</p>
Considérations pratiques et meilleures pratiques
Lors de la mise en œuvre de la DPO pour des applications réelles, prenez en compte les conseils suivants :
a) Qualité des données : La qualité de vos données de préférence est cruciale. Assurez-vous que votre ensemble de données :
- Couvre une gamme diverse d’entrées et de comportements souhaités
- Présente des annotations de préférence cohérentes et fiables
- Équilibre différents types de préférences (par exemple, factualité, sécurité, style)
b) Ajustement des hyperparamètres : Bien que la DPO ait moins d’hyperparamètres que le RLHF, l’ajustement est toujours important :
- β (beta) : Contrôle le compromis entre la satisfaction de la préférence et la divergence par rapport au modèle de référence. Commencez avec des valeurs autour de 0,1-0,5.
- Taux d’apprentissage : Utilisez un taux d’apprentissage inférieur à celui de l’affinement standard, généralement dans la plage de 1e-6 à 1e-5.
- Taille du lot : Les tailles de lot plus grandes (32-128) fonctionnent souvent bien pour l’apprentissage de préférence.
c) Affinement itératif : La DPO peut être appliquée de manière itérative :
- Entraîner un modèle initial en utilisant la DPO
- Générer de nouvelles réponses en utilisant le modèle entraîné
- Collecter de nouvelles données de préférence sur ces réponses
- Ré-entraîner en utilisant l’ensemble de données élargi
Performance de l’optimisation directe des préférences
Cette image montre la performance des LLM comme GPT-4 par rapport aux jugements humains à travers diverses techniques d’entraînement, notamment l’optimisation directe des préférences (DPO), l’affinement supervisé (SFT) et l’optimisation de la politique proximale (PPO). Le tableau révèle que les sorties de GPT-4 sont de plus en plus alignées sur les préférences humaines, en particulier dans les tâches de résumé. Le niveau d’accord entre GPT-4 et les évaluateurs humains démontre la capacité du modèle à générer du contenu qui résonne avec les évaluateurs humains, presque autant que le contenu généré par les humains.
Études de cas et applications
Pour illustrer l’efficacité de la DPO, regardons quelques applications réelles et certaines de ses variantes :
- DPO itérative : Développée par Snorkel (2023), cette variante combine l’échantillonnage de rejet avec la DPO, permettant un processus de sélection plus raffiné pour les données d’entraînement. En itérant sur plusieurs cycles d’échantillonnage de préférence, le modèle est mieux à même de généraliser et d’éviter de sur-ajuster aux préférences bruyantes ou biaisées.
- IPO (Optimisation itérative de préférence) : Introduite par Azar et al. (2023), l’IPO ajoute un terme de régularisation pour prévenir la sur-ajustement, problème courant dans l’optimisation basée sur les préférences. Cette extension permet aux modèles de maintenir un équilibre entre l’alignement sur les préférences et la préservation des capacités de généralisation.
- KTO (Optimisation de transfert de connaissances) : Une variante plus récente d’Ethayarajh et al. (2023), le KTO se dispense des préférences binaires tout en se concentrant sur le transfert de connaissances du modèle de référence au modèle de politique, en optimisant pour un alignement plus fluide et plus cohérent sur les valeurs humaines.
- DPO multi-modale pour l’apprentissage transversal de domaine par Xu et al. (2024) : Une approche où la DPO est appliquée à travers différents canaux—texte, image et audio—démontrant sa polyvalence pour aligner les modèles sur les préférences humaines à travers divers types de données. Cette recherche met en évidence le potentiel de la DPO dans la création de systèmes d’IA plus complets capables de gérer des tâches complexes et multi-modales.
Conclusion
L’optimisation directe des préférences représente une avancée significative dans l’alignement des modèles de langage avec les préférences humaines. Sa simplicité, son efficacité et sa puissance en font un outil puissant pour les chercheurs et les praticiens.
En exploitant le pouvoir de l’optimisation directe des préférences et en gardant ces principes à l’esprit, vous pouvez créer des modèles de langage qui non seulement présentent des capacités impressionnantes mais s’alignent également étroitement sur les valeurs et les intentions humaines.
