TRL documentation

DPO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

DPO Trainer

All_models-DPO-blue smol_course-Chapter_2-yellow

Aperçu

TRL prend en charge le DPO Trainer pour l’entraînement de modèles de langage, tel que décrit dans l’article Direct Preference Optimization: Your Language Model is Secretly a Reward Model de Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, Chelsea Finn.

L'abstract de l'article est le suivant :

Bien que les grands modèles de langage non supervisés (LM) apprennent de larges connaissances du monde et certaines compétences de raisonnement, il est difficile d’obtenir un contrôle précis de leur comportement en raison de la nature entièrement non supervisée de leur entraînement. Les méthodes existantes pour acquérir cette capacité de pilotage collectent des étiquettes humaines sur la qualité relative des générations du modèle et réentraînent le LM non supervisé pour l’aligner sur ces préférences, souvent au moyen de l’apprentissage par renforcement à partir de retours humains (RLHF). Cependant, le RLHF est une procédure complexe et souvent instable, qui consiste d’abord à entraîner un modèle de récompense reflétant les préférences humaines, puis à réentraîner le grand LM non supervisé en utilisant l’apprentissage par renforcement pour maximiser cette récompense estimée sans s’éloigner trop du modèle d’origine. Dans cet article, nous introduisons une nouvelle paramétrisation du modèle de récompense dans le RLHF qui permet d’extraire la politique optimale correspondante sous forme fermée, nous permettant ainsi de résoudre le problème standard de RLHF avec une simple perte de classification. L’algorithme résultant, que nous appelons Direct Preference Optimization (DPO), est stable, performant et léger sur le plan computationnel, éliminant le besoin d’échantillonnage depuis le LM pendant la réentraînement ou d’ajustement significatif des hyperparamètres. Nos expériences montrent que DPO peut réentraîner des LM pour les aligner sur les préférences humaines aussi bien, voire mieux, que les méthodes existantes. Notamment, la réentraînement avec DPO surpasse le RLHF basé sur PPO en capacité à contrôler le sentiment des générations, et égale ou améliore la qualité des réponses dans la résumation et le dialogue à tour unique, tout en étant considérablement plus simple à implémenter et à entraîner.

Cette méthode de post-entraînement a été proposée par Kashif Rasul puis refactorisée par Quentin Gallouédec.

Démarrage rapide

Cet exemple montre comment entraîner un modèle de langage à l'aide du DPOTrainer de TRL. Nous entraînons un modèle Qwen 3 0.6B sur le jeu de données UltraFeedback.

from trl import DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()

Type et format de jeu de données attendus

DPO nécessite un jeu de données de préférence. Le DPOTrainer est compatible avec les formats de jeu de données standard et conversationnel. Lorsqu’un jeu de données conversationnel est fourni, l’entraîneur applique automatiquement le modèle de chat au jeu de données.

# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}

# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                      "chosen": [{"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
                                 {"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "user", "content": "What color is the sky?"},
                                   {"role": "assistant", "content": "It is green."}]}

Si votre jeu de données n'est pas dans l'un de ces formats, vous pouvez le prétraiter pour le convertir dans le format attendu. Voici un exemple avec le jeu de données Vezora/Code-Preference-Pairs :

from datasets import load_dataset

dataset = load_dataset("Vezora/Code-Preference-Pairs")


def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["input"]}],
        "chosen": [{"role": "assistant", "content": example["accepted"]}],
        "rejected": [{"role": "assistant", "content": example["rejected"]}],
    }


dataset = dataset.map(preprocess_function, remove_columns=["instruction", "input", "accepted", "ID"])
print(next(iter(dataset["train"])))
{
    "prompt": [{"role": "user", "content": "Create a nested loop to print every combination of numbers [...]"}],
    "chosen": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
    "rejected": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
}

Explorer plus en profondeur la méthode DPO

L’optimisation par préférences directes (DPO) est une méthode d’entraînement conçue pour aligner un modèle de langage avec des données de préférences. Plutôt que des paires d’entrée-sortie supervisées, le modèle est entraîné sur des paires de complétions pour le même prompt, où l’une des complétions est préférée à l’autre. L’objectif optimise directement le modèle afin d’élargir la marge entre les log-vraisemblances des complétions préférées et non préférées, par rapport à un modèle de référence, sans nécessiter de modèle de récompense explicite. En pratique, cela est généralement réalisé en supprimant la vraisemblance des complétions non préférées plutôt qu’en augmentant la vraisemblance des complétions préférées.

Cette section détaille le fonctionnement pratique de DPO, en couvrant les étapes clés : prétraitement et calcul de la perte.

Prétraitement et tokenisation

Lors de l’entraînement, chaque exemple est censé contenir un prompt ainsi qu’une complétion préférée (chosen) et une complétion non préférée (rejected). Pour plus de détails sur les formats attendus, consultez Formats de jeu de données. Le DPOTrainer tokenise chaque entrée à l’aide du tokenizer du modèle.

Calcul de la perte

dpo_figure

La perte utilisée dans DPO est définie comme suit :LDPO(θ)=−E(x,y+,y−) ⁣[log⁡σ ⁣(β(log⁡πθ(y+ ⁣∣x)πref(y+ ⁣∣x)−log⁡πθ(y− ⁣∣x)πref(y− ⁣∣x)))] \mathcal{L}_{\mathrm{DPO}}(\theta) = -\mathbb{E}_{(x,y^{+},y^{-})}\!\left[\log \sigma\!\left(\beta\Big(\log\frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)}-\log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)}\Big)\right)\right]

où x x est le prompt, y+ y^+ est la complétion préférée et y− y^- est la complétion non préférée. πθ \pi_{\theta} est le modèle de politique en cours d'entraînement, πref \pi_{\mathrm{ref}} est le modèle de référence, σ \sigma est la fonction sigmoïde, et β>0 \beta > 0 est un hyperparamètre qui contrôle l'intensité du signal de préférence.

Types de pertes

Plusieurs formulations de l'objectif ont été proposées dans la littérature. Initialement, l'objectif de DPO était défini comme présenté ci-dessus.

loss_type=Description
"sigmoid" (par défaut)À partir des données de préférence, nous pouvons entraîner un classifieur binaire selon le modèle de Bradley-Terry et, en effet, les auteurs de DPO proposent la perte sigmoïde sur la vraisemblance normalisée via logsigmoid pour ajuster une régression logistique.
"hinge"Les auteurs de RSO proposent d'utiliser une perte à charnière sur la vraisemblance normalisée issue de l'article SLiC. Dans ce cas, le beta est l'inverse de la marge.
"ipo"Les auteurs de IPO soutiennent que la transformation logit peut entraîner un surapprentissage et proposent la transformation identité pour optimiser directement les préférences ; TRL expose cela via loss_type="ipo".
"exo_pair"Les auteurs de EXO proposent l’optimation de préférence par KL inverse. label_smoothing doit être strictement supérieur à 0.0 ; une valeur recommandée est 1e-3 (voir l’équation 16 pour la variante par paires simplifiée). La méthode complète utilise K>2 complétions SFT et se rapproche de PPO lorsque K augmente.
"nca_pair"Les auteurs de NCA montrent que NCA optimise la vraisemblance absolue pour chaque réponse plutôt que la vraisemblance relative.
"robust"Les auteurs de Robust DPO proposent une perte DPO non biaisée en présence de préférences bruitées. Utilisez label_smoothing dans DPOConfig pour modéliser la probabilité d'inversion des étiquettes ; les valeurs valides sont comprises dans l'intervalle [0.0, 0.5).
"bco_pair"Les auteurs de BCO entraînent un classifieur binaire dont le logit sert de récompense, de sorte que le classifieur associe les paires {prompt, réponse choisie} à 1 et les paires {prompt, réponse rejetée} à 0.
"sppo_hard"Les auteurs de SPPO affirment que SPPO est capable de résoudre l'équilibre de Nash de manière itérative en poussant les récompenses choisies à être aussi proches de 1/2 que possible et les récompenses rejetées à être aussi proches de -1/2 que possible, et peut atténuer les problèmes de rareté des données. L'implémentation approxime cet algorithme en utilisant des probabilités d'étiquettes dures, en attribuant 1 au gagnant et 0 au perdant.
"aot" ou loss_type="aot_unpaired"Les auteurs de AOT proposent l’alignement préférentiel distributionnel par transport optimal. loss_type="aot" est destiné aux données appariées ; loss_type="aot_unpaired" est destiné aux données non appariées. Les deux appliquent la dominance stochastique via des quantiles triés ; des tailles de lot par GPU plus importantes sont bénéfiques.
"apo_zero" ou loss_type="apo_down"La méthode APO introduit un objectif ancré. apo_zero renforce les gagnants et atténue le poids des perdants (utile lorsque le modèle sous-performe par rapport aux gagnants). apo_down atténue le poids des deux, avec une pression plus forte sur les perdants (utile lorsque le modèle surpasse déjà les gagnants).
"discopop"L’article DiscoPOP utilise des LLM pour découvrir des pertes d’optimisation des préférences hors ligne plus efficaces. Dans l’article, la perte DiscoPOP proposée (qui est une perte modulée par un rapport logarithmique) surpasse d’autres pertes d’optimisation sur différentes tâches (génération de texte positif IMDb, résumés TLDR Reddit et Alpaca Eval 2.0).
"sft"La perte SFT (Supervised Fine-Tuning) est la perte de log-vraisemblance négative, utilisée pour entraîner le modèle à générer des réponses préférées.
"sigmoid_norm"Les auteurs de SimPO traitent le biais de longueur de la perte sigmoïde originale en normalisant par le nombre de jetons non masqués ; TRL expose cette option sous la forme loss_type="sigmoid_norm".
"udpo"Les auteurs de UDPO proposent une perte DPO non biaisée sous préférences bruitées qui, contrairement à "robust", reste non biaisée lorsque la probabilité d'inversion est surestimée. Utilisez label_smoothing dans DPOConfig pour définir la probabilité d'inversion ε ; les valeurs valides sont comprises dans l'intervalle [0.0, 0.5).

Métriques journalisées

Lors de l'entraînement et de l'évaluation, nous enregistrons les métriques suivantes :

  • global_step : le nombre total d'étapes d'optimiseur effectuées jusqu'à présent.
  • epoch : numéro de l'époque en cours, basé sur l'itération du jeu de données.
  • num_tokens : le nombre total de jetons traités jusqu'à présent.
  • loss : perte DPO moyenne sur l'intervalle de journalisation actuel.
  • entropy : l'entropie moyenne de la distribution de jetons prédite par le modèle sur les jetons non masqués.
  • aux_loss : perte auxiliaire d'équilibrage de charge d'un modèle Mixture-of-Experts, avant d'être mise à l'échelle par router_aux_loss_coef et ajoutée à la perte. Journalisée uniquement lorsque le modèle est un modèle MoE et que router_aux_loss_coef est non nul.
  • mean_token_accuracy : La proportion de jetons non masqués pour lesquels la prédiction top-1 du modèle correspond au jeton de l’achèvement choisi.
  • learning_rate : le taux d'apprentissage actuel, susceptible de changer dynamiquement si un planificateur est utilisé.
  • grad_norm : la norme L2 des gradients, calculée avant le rognage des gradients.
  • logits/chosen : Les valeurs de logit moyennes attribuées par le modèle aux jetons de la complétion choisie.
  • logits/rejected : Les valeurs de logit moyennes attribuées par le modèle aux jetons de la complétion rejetée.
  • logps/chosen : La probabilité logarithmique moyenne attribuée par le modèle aux jetons de la complétion choisie.
  • logps/rejected : La probabilité logarithmique moyenne attribuée par le modèle aux jetons de la complétion rejetée.
  • rewards/chosen: La récompense implicite moyenne calculée pour la complétion choisie, calculée comme βlog⁡πθ(y+ ⁣∣x)πref(y+ ⁣∣x) \beta \log \frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)} .
  • rewards/rejected: La récompense implicite moyenne calculée pour la complétion rejetée, calculée comme βlog⁡πθ(y− ⁣∣x)πref(y− ⁣∣x) \beta \log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)} .
  • rewards/margins : Marge de récompense implicite moyenne entre les complétions choisies et rejetées.
  • rewards/accuracies : La proportion d'exemples pour lesquels la récompense implicite de la complétion choisie est supérieure à celle de la complétion rejetée.

Personnalisation

Compatibilité et contraintes

Certaines combinaisons d’arguments sont volontairement restreintes dans l’implémentation actuelle de DPOTrainer :

  • use_weighting=True n'est pas pris en charge avec loss_type="aot" ou loss_type="aot_unpaired".
  • Les adaptateurs PEFT ciblant lm_head ne sont pas pris en charge (utilisez plutôt modules_to_save=["lm_head"]).
  • sync_ref_model=True n'est pas pris en charge lors de l'entraînement avec des modèles PEFT qui ne conservent pas de ref_model indépendant.
  • sync_ref_model=True ne peut pas être combiné avec precompute_ref_log_probs=True.
  • precompute_ref_log_probs=True n'est pas pris en charge avec IterableDataset (entraînement ou évaluation).

Combinaisons de pertes multiples

Le formateur DPO permet de combiner plusieurs fonctions de perte avec des poids différents, ce qui rend possibles des stratégies d’optimisation plus sophistiquées. Cette fonctionnalité est particulièrement utile pour implémenter des algorithmes tels que MPO (Mixed Preference Optimization). MPO est une approche d’entraînement qui combine plusieurs objectifs d’optimisation, comme décrit dans l’article Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization.

Pour combiner plusieurs pertes, spécifiez les types de perte et les poids correspondants sous forme de listes :

# MPO: Combines DPO (sigmoid) for preference and BCO (bco_pair) for quality
training_args = DPOConfig(
    loss_type=["sigmoid", "bco_pair", "sft"],  # loss types to combine
    loss_weights=[0.8, 0.2, 1.0]  # corresponding weights, as used in the MPO paper
)

Initialisation du modèle

Vous pouvez passer directement les kwargs de la méthode from_pretrained() à DPOConfig. Par exemple, si vous souhaitez charger un modèle dans une précision différente, de manière analogue à

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)

vous pouvez le faire en passant l'argument model_init_kwargs={"dtype": torch.bfloat16} à DPOConfig.

from trl import DPOConfig

training_args = DPOConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)

Notez que tous les arguments par mot-clé de from_pretrained() sont pris en charge.

Entraîner des adaptateurs avec PEFT

Nous prenons en charge une intégration étroite avec la bibliothèque 🤗 PEFT, permettant à tout utilisateur d’entraîner et de partager des adaptateurs sur le Hub de manière pratique, plutôt que d’entraîner l’ensemble du modèle.

from datasets import load_dataset
from trl import DPOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

Vous pouvez également poursuivre l’entraînement de votre PeftModel. Pour cela, chargez d’abord un PeftModel en dehors de DPOTrainer et transmettez-le directement à l’entraîneur sans passer l’argument peft_config.

from datasets import load_dataset
from trl import DPOTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

Lors de l’entraînement d’adapters, vous utilisez généralement un taux d’apprentissage plus élevé (≈1e‑5) que lors d’un fine-tuning complet, car seuls les nouveaux paramètres sont appris.

DPOConfig(learning_rate=1e-5, ...)

Expérimentation rapide pour DPO

RapidFire AI est un moteur d’expérimentation open source qui s’appuie sur TRL et vous permet de lancer plusieurs configurations DPO simultanément, même sur un seul GPU. Plutôt que d’essayer les configurations séquentiellement, RapidFire vous permet de visualiser plus tôt toutes leurs courbes d’apprentissage, d’arrêter les exécutions sous-performantes et de cloner les prometteuses avec de nouveaux paramètres en cours d’exécution sans redémarrage. Pour plus d’informations, consultez Intégration RapidFire AI.

Entraîner avec Unsloth

Unsloth est un framework open source pour le fine-tuning et l'apprentissage par renforcement qui entraîne les LLM (comme Llama, Mistral, Gemma, DeepSeek, etc.) jusqu'à 2 fois plus rapidement avec jusqu'à 70 % de VRAM en moins, tout en offrant un flux de travail simplifié et compatible Hugging Face pour l'entraînement, l'évaluation et le déploiement. Pour plus d'informations, consultez Intégration Unsloth.

Appel d'outils avec DPO

Le DPOTrainer prend entièrement en charge l’ajustement fin des modèles dotés de capacités de tool calling. Dans ce cas, chaque exemple du jeu de données doit inclure :

  • Les messages de la conversation (invite, choix et rejet), y compris les appels d'outils (tool_calls) et les réponses d'outils (messages avec le rôle tool)
  • La liste des outils disponibles dans la colonne tools, généralement fournie sous forme de schémas JSON

Pour plus de détails sur la structure attendue du jeu de données, consultez la section Format du jeu de données — Tool Calling.

Entraînement des modèles de vision et de langage

DPOTrainer prend entièrement en charge l’entraînement des modèles Vision-Language (VLM). Pour entraîner un VLM, fournissez un jeu de données contenant soit une colonne image (une image par exemple), soit une colonne images (liste d’images par exemple). Pour plus d’informations sur la structure attendue du jeu de données, consultez la section Format du jeu de données — Jeu de données Vision. Un exemple de tel jeu de données est le jeu de données RLAIF-V Dataset.

from trl import DPOConfig, DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=DPOConfig(max_length=None),
    train_dataset=load_dataset("HuggingFaceH4/rlaif-v_formatted", split="train"),
)
trainer.train()

Pour les VLM, la troncature peut supprimer des jetons d’image, ce qui entraîne des erreurs lors de l’entraînement. Pour éviter cela, définissez max_length=None dans DPOConfig. Cela permet au modèle de traiter la longueur complète de la séquence sans tronquer les jetons d’image.

DPOConfig(max_length=None, ...)

N’utilisez max_length que si vous avez vérifié que la troncature ne supprimera pas les jetons d’image pour l’ensemble du jeu de données.

DPOTrainer

classe trl.DPOTrainer

< >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.dpo_config.DPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

Paramètres

  • model (str ou PreTrainedModel ou PeftModel) — Modèle à entraîner. Peut être l'un des éléments suivants :
    • Une chaîne de caractères, correspondant à l'identifiant du modèle d'un modèle pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co, ou à un chemin vers un dossier contenant les poids du modèle enregistrés à l'aide de save_pretrained, par exemple './my_model_directory/'. Le modèle est chargé à l'aide de <ModelArchitecture>.from_pretrained (où <ModelArchitecture> est dérivé de la configuration du modèle) avec les arguments nommés de args.model_init_kwargs. Si dtype n'est pas spécifié dans args.model_init_kwargs, la valeur par défaut est float32. Cela diffère de from_pretrained, où (depuis Transformers v5) le type de données est déduit de la configuration du modèle.
    • Un objet PreTrainedModel. Seuls les modèles de langage causaux sont pris en charge.
    • Un objet PeftModel. Seuls les modèles de langage causaux sont pris en charge.
  • ref_model (PreTrainedModel, facultatif) — Modèle de référence utilisé pour calculer les log-probabilités de référence. S'il est fourni, ce modèle est utilisé directement comme politique de référence. Il ne peut pas être un PeftModel. S'il est None, l'entraîneur utilisera automatiquement la politique initiale correspondant à model, c'est-à-dire l'état du modèle avant le début de l'entraînement DPO.
    • Si fourni, ce modèle est utilisé directement comme politique de référence. Il ne peut pas être un PeftModel.
    • Si None, le formateur utilisera automatiquement la politique initiale correspondant à model, c’est-à-dire l’état du modèle avant le début de l’entraînement DPO.
  • args (DPOConfig, facultatif) — Configuration de ce formateur. Si None, une configuration par défaut est utilisée.
  • data_collator (DataCollator, facultatif) — Fonction à utiliser pour former un lot à partir d'une liste d'éléments du train_dataset ou eval_dataset traité. La valeur par défaut est DataCollatorForPreference si le modèle est un modèle de langage et DataCollatorForVisionPreference si le modèle est un modèle de vision-langage. Les collateurs personnalisés doivent tronquer les séquences avant le bourrage ; le formateur n'applique pas de troncature après le collation.
  • train_dataset (Dataset ou IterableDataset) — Jeu de données à utiliser pour l'entraînement. Cet entraîneur prend en charge les types language modeling et prompt-completion . Le format des échantillons peut être l'un des deux suivants :
    • Standard : chaque échantillon contient du texte brut.
    • Conversationnel : chaque échantillon contient des messages structurés (par exemple, le rôle et le contenu).

    Lorsque train_dataset est un IterableDataset (par exemple un jeu de données en streaming), max_steps doit être défini dans les arguments d’entraînement, car sa longueur ne peut pas être déduite et le nombre total d’étapes d’entraînement est nécessaire pour limiter la boucle d’entraînement et configurer le planificateur de taux d’apprentissage.

  • eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict ou dict[str, Dataset | IterableDataset]) — Jeu de données à utiliser pour l'évaluation. Il doit répondre aux mêmes exigences que train_dataset.
  • processing_class (PreTrainedTokenizerBase ou ProcessorMixin, facultatif) — Classe de traitement utilisée pour traiter les données. Le côté de bourrage doit être défini sur « left ». Si None, la classe de traitement est chargée à partir du nom du modèle avec from_pretrained. Un jeton de bourrage, tokenizer.pad_token, doit être défini. Si la classe de traitement n’a pas défini de jeton de bourrage, tokenizer.eos_token sera utilisé par défaut.
  • compute_metrics (Callable[[EvalPrediction], dict], facultatif) — La fonction utilisée pour calculer les métriques lors de l'évaluation. Elle doit prendre un EvalPrediction en entrée et renvoyer un dictionnaire associant des chaînes de caractères aux valeurs des métriques. Lors du passage d'un SFTConfig avec batch_eval_metrics défini sur True, votre fonction compute_metrics doit prendre un argument booléen compute_result. Cela sera déclenché après le dernier lot d'évaluation pour indiquer que la fonction doit calculer et renvoyer les statistiques globales de synthèse plutôt que d'accumuler les statistiques au niveau du lot. Les logits qu'elle reçoit sont recalculés lors d'un passage avant supplémentaire. Cette fonctionnalité est obsolète et sera supprimée dans la v2.0.0.
  • callbacks (liste de TrainerCallback, facultatif) — Liste de callbacks pour personnaliser la boucle d'entraînement. Ils seront ajoutés à la liste des callbacks par défaut détaillée ici.

    Si vous souhaitez supprimer l'un des callbacks par défaut utilisés, utilisez la méthode remove_callback.

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], facultatif, par défaut (None, None)) — Un tuple contenant l'optimiseur et le planificateur à utiliser. Par défaut, une instance de AdamW est utilisée sur votre modèle ainsi qu'un planificateur défini par get_linear_schedule_with_warmup et contrôlé par args.
  • quantization_config (BitsAndBytesConfig, facultatif) — Configuration de quantification utilisée lors du chargement du modèle à partir d'un identifiant de modèle. À combiner avec peft_config pour l'entraînement QLoRA. Ignoré si le modèle est déjà instancié.
  • peft_config (PeftConfig, facultatif) — Configuration PEFT utilisée pour envelopper le modèle. Si None, le modèle n'est pas enveloppé.

Trainer pour la méthode d'optimation des préférences directes (DPO). Cet algorithme a été initialement proposé dans l'article Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Cette classe est un wrapper autour de la classe Trainer et hérite de tous ses attributs et méthodes.

Exemple :

>>> from trl import DPOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

>>> trainer = DPOTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

train

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

Paramètres

  • resume_from_checkpoint (str ou bool, facultatif) — Si c'est une str, chemin local d'un point de contrôle enregistré par une instance précédente de Trainer. Si c'est un bool et vaut True, charge le dernier point de contrôle dans args.output_dir enregistré par une instance précédente de Trainer. S'il est présent, l'entraînement reprendra à partir des états du modèle/optimiseur/planificateur chargés ici.
  • trial (optuna.Trial ou dict[str, Any], facultatif) — L’exécution de l’essai ou le dictionnaire d’hyperparamètres pour la recherche d’hyperparamètres.
  • ignore_keys_for_eval (list[str], facultatif) — Une liste de clés dans la sortie de votre modèle (s’il s’agit d’un dictionnaire) qui doivent être ignorées lors de la collecte des prédictions pour l’évaluation pendant l’entraînement.

Retourne

~trainer_utils.TrainOutput

Objet contenant le nombre d'étapes globales, la perte d'entraînement et les métriques.

Point d'entrée principal de l'entraînement.

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

Enregistrera le modèle, ce qui vous permettra de le recharger à l'aide de from_pretrained().

N'enregistrera que depuis le processus principal.

push_to_hub

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Paramètres

  • commit_message (str, facultatif, par défaut "End of training") — Message à committer lors de la poussée.
  • blocking (bool, facultatif, par défaut True) — Indique si la fonction doit ne renvoyer que lorsque le git push est terminé.
  • token (str, facultatif, par défaut None) — Jeton avec permission d’écriture pour écraser les arguments originaux du Trainer.
  • revision (str, facultatif) — La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche « main ».
  • private (bool, facultatif) — Indique s'il faut rendre le dépôt privé lors de sa création. La valeur par défaut est args.hub_private_repo. N'a aucun effet si le dépôt existe déjà.
  • kwargs (dict[str, Any], facultatif) — Arguments supplémentaires passés à ~Trainer.create_model_card.

Téléchargez self.model et self.processing_class sur le hub de modèles 🤗 dans le dépôt self.args.hub_model_id.

DPOConfig

classe trl.DPOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: list[str] = <factory>loss_weights: list[float] | None = Noneld_alpha: float | None = Nonef_divergence_type: str = 'reverse_kl'f_alpha_divergence_coef: float = 0.5label_smoothing: float = 0.0beta: float = 0.1use_weighting: bool = Falsediscopop_tau: float = 0.05activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512pad_token: str | None = None )

Paramètres qui contrôlent le modèle

  • model_init_kwargs (dict[str, Any], facultatif) — Arguments par mot-clé pour from_pretrained, utilisés lorsque l’argument model du DPOTrainer est fourni sous forme de chaîne de caractères. La valeur de revision est également utilisée lors du chargement de la classe de traitement.
  • trust_remote_code (bool, facultatif, valeur par défaut False) — Indique s'il faut autoriser le chargement de modèles et de tokenizers qui incluent du code Python personnalisé depuis le Hub. Transmis à from_pretrained et from_pretrained.
  • router_aux_loss_coef (float, facultatif) — Coefficient de la perte auxiliaire d’équilibrage de charge pour les modèles Mixture-of-Experts (MoE), ajoutée à la perte d’entraînement avec ce poids. Si non défini, la valeur déclarée par la configuration du modèle est utilisée. Définissez-le à 0.0 pour le désactiver. Échoue s’il est utilisé avec un modèle non-MoE.
  • disable_dropout (bool, facultatif, valeur par défaut True) — Indique s'il faut désactiver le dropout dans le modèle et le modèle de référence.

Paramètres qui contrôlent la prétraitement des données

  • dataset_num_proc (int, facultatif) — Nombre de processus à utiliser pour le traitement du jeu de données.
  • max_length (int ou None, facultatif, par défaut 1024) — Longueur maximale de la séquence tokenisée. Les séquences plus longues que max_length sont tronquées à gauche ou à droite selon le truncation_mode. Si None, aucun tronquage n’est appliqué.
  • truncation_mode (str, facultatif, par défaut "keep_start") — Mode de troncature à utiliser lorsque la séquence dépasse max_length. La seule valeur prise en charge est "keep_start". La valeur "keep_end" est obsolète et sera supprimée dans la v2.0.0.
  • padding_free (bool, facultatif, par défaut False) — Indique s'il faut effectuer les passages en avant sans bourrage (padding) en aplatissant toutes les séquences du lot en une seule séquence continue. Cela réduit l'utilisation de la mémoire en éliminant le surcoût lié au bourrage. Actuellement, cette option n'est prise en charge qu'avec FlashAttention 2 ou 3, qui peuvent traiter efficacement la structure de lot aplatie. Temporairement indisponible : depuis la refonte de DPO, la configuration à True émet un avertissement et bascule sur le bourrage standard. Son retour est prévu dans une mise à jour future.
  • pad_to_multiple_of (int ou str, facultatif, valeur par défaut "auto") — Si défini, les séquences seront remplies jusqu'à un multiple de cette valeur. "auto" remplit jusqu'à un multiple de 128 sur Neuron (AWS Trainium), qui compile une fois par forme d'entrée, et ne remplit pas ailleurs.
  • precompute_ref_log_probs (bool, facultatif, par défaut False) — Indique s'il faut précalculer les logarithmes des probabilités du modèle de référence pour l'ensemble du jeu de données d'entraînement avant le début de l'entraînement. Cela permet d'économiser de la mémoire pendant l'entraînement, car le modèle de référence n'a pas besoin d'être conservé en mémoire.
  • precompute_ref_batch_size (int, facultatif) — Taille de lot à utiliser lors de la précalcul des probabilités log des modèles de référence. Cette valeur peut être définie plus élevée que la taille de lot d’entraînement pour accélérer la prétraitement. Si None, la valeur par défaut est per_device_train_batch_size pour l’entraînement et per_device_eval_batch_size pour l’évaluation.

Paramètres qui contrôlent l'entraînement

  • loss_type (list[str], facultatif, par défaut ["sigmoid"]) — Type de perte à utiliser. Les valeurs possibles sont : 'sigmoid', 'hinge', 'ipo', 'exo_pair', 'nca_pair', 'robust', 'bco_pair', 'sppo_hard', 'aot', 'aot_unpaired', 'apo_zero', 'apo_down', 'discopop', 'sft', 'sigmoid_norm', 'udpo'. Si plusieurs types de perte sont fournis, ils seront combinés à l'aide des poids spécifiés dans loss_weights.
  • loss_weights (list[float], facultatif) — Liste des poids de perte pour les combinaisons multi-pertes. Utilisé lors de la combinaison de plusieurs types de perte. Exemple : [0.8, 0.2, 1.0] pour MPO. S'il n'est pas fourni, la valeur par défaut est des poids égaux (1.0) pour tous les types de perte.
  • ld_alpha (float, facultatif) — Paramètre α issu du papier LD-DPO, qui contrôle le pondération des log-probabilités des jetons verbeux dans les réponses. Si None, aucune pondération n’est appliquée à la partie verbeuse, et la perte est équivalente à la perte DPO standard. Doit être compris dans [0.0, 1.0] : ld_alpha=1.0 n’applique aucune pondération, et ld_alpha=0.0 masque les jetons au-delà des longueurs partagées.
  • f_divergence_type (str, facultatif, valeur par défaut "reverse_kl") — régulariseur de divergence f entre la politique et la référence (article f-DPO). Les valeurs possibles sont : reverse_kl (par défaut), forward_kl, js_divergence, alpha_divergence. Seuls les types de perte basés sur la différence de récompense entre l’exemple choisi et l’exemple rejeté acceptent une valeur non par défaut : 'sigmoid', 'sigmoid_norm', 'hinge', 'ipo', 'exo_pair', 'robust', 'discopop', 'sft', 'udpo'. Les autres types de perte n’ont pas de généralisation valide en divergence f et sont rejetés si une valeur non par défaut est fournie.
  • f_alpha_divergence_coef (float, facultatif, valeur par défaut 0.5) — coefficient α pour le régulariseur de divergence α u^-α, utilisé uniquement lorsque f_divergence_type='alpha_divergence'.
  • label_smoothing (float, facultatif, valeur par défaut 0.0) — Paramètre de lissage des étiquettes utilisé dans Robust DPO, UDPO et EXO. Dans Robust DPO et UDPO, il est interprété comme la probabilité ε qu'une étiquette de préférence soit inversée et doit être comprise dans [0.0, 0.5) ; une valeur typique recommandée par le papier Robust DPO est 0.1. UDPO l'utilise pour définir a = ε / (1 - ε), et le papier UDPO recommande a = 0.8, soit ε = 4/9. Dans EXO, il correspond au paramètre de lissage des étiquettes ε, pour lequel le papier recommande une valeur typique de 1e-3.
  • beta (float, facultatif, par défaut 0.1) — Paramètre contrôlant l'écart par rapport au modèle de référence. Plus β est élevé, moins l'écart par rapport au modèle de référence est important. Pour la perte IPO (loss_type='ipo'), cette valeur est le paramètre de régularisation noté τ dans l'article.
  • use_weighting (bool, facultatif, valeur par défaut False) — Indique s'il faut appliquer un pondération de type WPO aux paires de préférences en utilisant les probabilités de séquence normalisées par la longueur de la politique.
  • discopop_tau (float, facultatif, valeur par défaut 0.05) — Paramètre τ/température issu de l'article DiscoPOP, qui contrôle la forme de la perte modulée par le rapport logarithmique lors de l'utilisation de loss_type='discopop'. L'article recommande la valeur par défaut discopop_tau=0.05.
  • activation_offloading (bool, facultatif, valeur par défaut False) — Indique s'il faut décharger les activations sur le CPU.
  • sync_ref_model (bool, facultatif, par défaut False) — Indique s'il faut synchroniser le modèle de référence avec le modèle actif toutes les ref_model_sync_steps étapes, en utilisant le paramètre ref_model_mixup_alpha. Cette synchronisation provient du papier TR-DPO. sync_ref_model=True n'est pas encore compatible avec PEFT ou precompute_ref_log_probs=True.
  • ref_model_mixup_alpha (float, facultatif, valeur par défaut 0.6) — Paramètre α issu du papier TR-DPO, qui contrôle le mélange entre la politique actuelle et la politique de référence précédente lors des mises à jour. La politique de référence est mise à jour selon l'équation : π_ref = α * π_θ + (1 - α) * π_ref_prev. Pour utiliser ce paramètre, vous devez définir sync_ref_model=True.
  • ref_model_sync_steps (int, facultatif, valeur par défaut 512) — paramètre τ issu de l’article TR-DPO, qui détermine la fréquence à laquelle la politique actuelle est synchronisée avec la politique de référence. Pour utiliser ce paramètre, vous devez définir sync_ref_model=True.

Paramètres obsolètes

  • pad_token —

    Le paramètre pad_token est obsolète et sera supprimé dans la version v2.0.0. Définissez directement tokenizer.pad_token et passez-le en tant que processing_class au formateur à la place.

Classe de configuration pour le DPOTrainer.

Cette classe ne contient que les paramètres spécifiques à l’entraînement DPO. Pour la liste complète des arguments d’entraînement, veuillez consulter la documentation de TrainingArguments. Notez que les valeurs par défaut de cette classe peuvent différer de celles de TrainingArguments.

À l’aide de HfArgumentParser, nous pouvons transformer cette classe en arguments argparse qui peuvent être spécifiés sur la ligne de commande.

Ces paramètres ont des valeurs par défaut différentes de TrainingArguments :

  • logging_steps : la valeur par défaut est 10 au lieu de 500.
  • gradient_checkpointing : la valeur par défaut est True au lieu de False.
  • bf16 : passe à True par défaut si fp16 n’est pas défini, au lieu de False.
  • learning_rate : la valeur par défaut est 1e-6 au lieu de 5e-5.
Update on GitHub