TRL documentation

KTO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

KTO Trainer

All_models-KTO-blue

Aperçu

TRL prend en charge l’optimisation Kahneman-Tversky (KTO) Trainer pour l’entraînement de modèles de langage, telle que décrite dans l’article KTO: Model Alignment as Prospect Theoretic Optimization de Kawin Ethayarajh, Winnie Xu, Niklas Muennighoff, Dan Jurafsky, Douwe Kiela.

L'abstract de l'article est le suivant :

La théorie des perspectives de Kahneman & Tversky nous indique que les humains perçoivent les variables aléatoires de manière biaisée mais bien définie ; par exemple, les humains sont réputés pour leur aversion à la perte. Nous montrons que les objectifs d’alignement des LLM avec les retours humains incorporent implicitement de nombreux de ces biais — le succès de ces objectifs (par exemple, DPO) par rapport à la minimisation de l’entropie croisée peut être partiellement attribué au fait qu’il s’agit de fonctions de perte prenant en compte les humains (HALOs). Cependant, les fonctions d’utilité que ces méthodes attribuent aux humains diffèrent encore de celles de la littérature sur la théorie des perspectives. En utilisant un modèle d’utilité humaine de Kahneman-Tversky, nous proposons un HALO qui maximise directement l’utilité des générations, au lieu de maximiser la log-vraisemblance des préférences, comme le font les méthodes actuelles. Nous appelons cette approche Kahneman-Tversky Optimization (KTO), et elle égale ou surpasse les performances des méthodes basées sur les préférences à des échelles allant de 1B à 30B. Crucialement, KTO n’a pas besoin de préférences — seulement d’un signal binaire indiquant si une sortie est souhaitable ou non souhaitable pour une entrée donnée. Cela le rend beaucoup plus facile à utiliser dans le monde réel, où les données de préférence sont rares et coûteuses.

Le code officiel peut être trouvé dans ContextualAI/HALOs.

Cette méthode de post-entraînement a été proposée par Kashif Rasul, Younes Belkada, Lewis Tunstall, Pablo Vicente, puis refactorisée par Albert Villanova del Moral.

Démarrage rapide

Cet exemple montre comment entraîner un modèle à l'aide de la méthode KTO. Nous utilisons le modèle Qwen 0.5B comme modèle de base. Nous utilisons les données de préférence de KTO Mix 14k. Vous pouvez consulter les données du jeu de données ici :

Voici le script pour entraîner le modèle :

# train_kto.py
from datasets import load_dataset
from trl import KTOConfig, KTOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
train_dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

training_args = KTOConfig(output_dir="Qwen2-0.5B-KTO")
trainer = KTOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()

Exécutez le script à l'aide de la commande suivante :

torchrun --nproc_per_node 8 train_kto.py

Réparti sur 8 x H100 GPU, l’entraînement prend environ 30 minutes. Vous pouvez vérifier la progression de l’entraînement en consultant le graphique de la récompense. Une tendance à la hausse de la marge de récompense indique que le modèle s’améliore et génère de meilleures réponses au fil du temps.

kto qwen2 reward margin

Pour voir les performances du modèle entraîné, vous pouvez utiliser le Transformers Chat CLI.

$ transformers chat trl-lib/Qwen2-0.5B-KTO
<quentin_gallouedec>:
What is the best programming language?

<trl-lib/Qwen2-0.5B-KTO>:
The best programming language can vary depending on individual preferences, industry-specific requirements, technical skills, and familiarity with the specific use case or task. Here are some widely-used programming languages that have been noted as popular and widely used:

Here are some other factors to consider when choosing a programming language for a project:

 1 JavaScript: JavaScript is at the heart of the web and can be used for building web applications, APIs, and interactive front-end applications like frameworks like React and Angular. It's similar to C, C++, and F# in syntax structure and is accessible and easy to learn, making it a popular choice for beginners and professionals alike.
 2 Java: Known for its object-oriented programming (OOP) and support for Java 8 and .NET, Java is used for developing enterprise-level software applications, high-performance games, as well as mobile apps, game development, and desktop applications.
 3 C++: Known for its flexibility and scalability, C++ offers comprehensive object-oriented programming and is a popular choice for high-performance computing and other technical fields. It's a powerful platform for building real-world applications and games at scale.
 4 Python: Developed by Guido van Rossum in 1991, Python is a high-level, interpreted, and dynamically typed language known for its simplicity, readability, and versatility.

Type et format de jeu de données attendus

KTO nécessite un jeu de données de préférences non appariées. Vous pouvez également fournir un jeu de données de préférences appariées (également appelé simplement jeu de données de préférences). Dans ce cas, l’entraîneur le convertit automatiquement au format non apparié en séparant les réponses choisies et rejetées, en attribuant label = True aux complétions choisies et label = False aux complétions rejetées.

Le KTOTrainer 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
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}

# Conversational format
unpaired_preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                               "completion": [{"role": "assistant", "content": "It is blue."}],
                               "label": True}

En théorie, le jeu de données doit contenir au moins une complétion choisie et une complétion rejetée. Cependant, certains utilisateurs ont exécuté avec succès KTO en utilisant uniquement des données choisies ou uniquement des données rejetées. Si vous n'utilisez que des données rejetées, il est conseillé d'adopter un taux d'apprentissage conservateur.

Explorer plus en profondeur la méthode KTO

L'optimisation Kahneman-Tversky (KTO) est une méthode d'entraînement conçue pour aligner un modèle de langage à l'aide d'un simple signal binaire indiquant si une sortie est désirable ou indésirable pour une entrée donnée, plutôt que de s'appuyer sur des paires de complétions préférées/dépréciées. S'inspirant de la théorie du prospectus de Kahneman et Tversky, elle définit une fonction de perte tenant compte de l'humain (HALO) qui maximise directement l'utilité des générations, en pondérant de manière asymétrique les exemples désirables et indésirables afin de refléter l'aversion à la perte des humains.

Cette section détaille le fonctionnement de KTO en pratique, 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, une completion et un booléen label indiquant si la complétion est souhaitable (True) ou non (False). Pour plus de détails sur les formats attendus, consultez Formats de jeu de données. Le KTOTrainer tokenise chaque entrée à l'aide du tokenizer du modèle.

Calcul de la perte

Le terme de divergence KL utilisé par la perte KTO est estimé en appariant chaque invite avec une complétion non correspondante tirée d’ailleurs dans le lot. Pour cette raison, les types de perte qui estiment le terme KL (tous sauf apo_zero_unpaired) exigent une taille de lot d’entraînement par appareil supérieure à 1 et une stratégie d’échantillonnage séquentiel, afin que les paires non correspondantes restent stables au sein d’un lot.

La perte utilisée dans KTO (équation 7 de l' article) ) est définie comme suit : LKTO(θ)=E(x,y) ⁣[w(y)(1−v(x,y))] \mathcal{L}_{\mathrm{KTO}}(\theta) = \mathbb{E}_{(x,y)}\!\left[ w(y)\Big(1 - v(x, y)\Big) \right]

où la valeur v(x,y) v(x, y) est v(x,y)={σ ⁣(β(log⁡πθ(y∣x)πref(y∣x)−KL))if y is desirableσ ⁣(β(KL−log⁡πθ(y∣x)πref(y∣x)))if y is undesirable v(x, y) = \begin{cases} \sigma\!\left(\beta\big(\log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} - \mathrm{KL}\big)\right) & \text{if } y \text{ is desirable} \\ \sigma\!\left(\beta\big(\mathrm{KL} - \log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)}\big)\right) & \text{if } y \text{ is undesirable} \end{cases}

Ici x x est le prompt, y y est la complétion, πθ \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, β>0 \beta > 0 contrôle l'écart par rapport au modèle de référence, et KL \mathrm{KL} est le terme de divergence KL estimé. Le poids w(y) w(y) est desirable_weight pour les complétions souhaitables et undesirable_weight pour les complétions non souhaitables, utilisé pour compenser un déséquilibre entre le nombre d'exemples souhaitables et non souhaitables.

Types de pertes

loss_type=Description
"kto" (par défaut)La perte KTO issue de l'article KTO. Une perte tenant compte de l'humain (HALO) basée sur la théorie des perspectives de Kahneman-Tversky, qui maximise l'utilité des complétions souhaitables et la minimise pour les complétions indésirables, en utilisant un terme de divergence KL estimé comme point de référence.
"apo_zero_unpaired"La variante non appariée de la perte APO-zero issue de l’article APO. Elle augmente la vraisemblance des complétions souhaitables et diminue celle des complétions indésirables, sans estimer le terme de divergence KL. Utilisez cette perte lorsque vous estimez que les complétions souhaitables sont meilleures que la sortie par défaut du modèle.

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 KTO 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.
  • kl : divergence KL moyenne estimée entre le modèle de politique et le modèle de référence, utilisée comme point de référence dans la perte KTO.
  • 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 l'achèvement choisi (désirable).
  • logits/rejected : Les valeurs de logit moyennes attribuées par le modèle aux jetons de la complétion rejetée (indésirable).
  • logps/chosen : La probabilité logarithmique moyenne attribuée par le modèle aux jetons de la complétion choisie (désirable).
  • logps/rejected : La probabilité logarithmique moyenne attribuée par le modèle aux jetons de la complétion rejetée (indésirable).
  • rewards/chosen: La récompense implicite moyenne calculée pour l'achèvement choisi (désirable), 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 l'achèvement rejeté (indésirable), 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.

Personnalisation

Compatibilité et contraintes

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

  • 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) ni avec les jeux de données visuels.
  • Les types de perte qui estiment le terme de divergence KL (tous sauf "apo_zero_unpaired") nécessitent train_sampling_strategy="sequential" et une taille de lot d’entraînement par appareil supérieure à 1.

Initialisation du modèle

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

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct", dtype=torch.bfloat16)

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

from trl import KTOConfig

training_args = KTOConfig(
    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 KTOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = KTOTrainer(
    "Qwen/Qwen2-0.5B-Instruct",
    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 KTOTrainer et transmettez-le directement à l’entraîneur sans passer l’argument peft_config.

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

Appel d'outils avec KTO

Le KTOTrainer 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 et complétion), 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

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

from trl import KTOConfig, KTOTrainer
from datasets import load_dataset

trainer = KTOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=KTOConfig(max_length=None),
    train_dataset=load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", 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 KTOConfig. Cela permet au modèle de traiter la longueur complète de la séquence sans tronquer les jetons d’image.

KTOConfig(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.

Exemple de script

Nous fournissons un script d’exemple pour entraîner un modèle à l’aide de la méthode KTO. Le script est disponible dans trl/scripts/kto.py

Pour tester le script KTO avec le modèle Qwen2 0.5B sur le jeu de données UltraFeedback, exécutez la commande suivante :

torchrun --nproc_per_node 8 trl/scripts/kto.py \
    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/kto-mix-14k \
    --num_train_epochs 1 \
    --output_dir Qwen2-0.5B-KTO

Conseils d'utilisation

Pour les modèles Mixture of Experts : Activer la perte auxiliaire

Les MOEs sont les plus efficaces lorsque la charge est répartie de manière à peu près égale entre les experts.
Pour nous assurer d’entraîner les MOEs de manière similaire lors de l’ajustement par préférence, il est bénéfique d’ajouter la perte auxiliaire du répartiteur de charge à la perte finale.

Cette option est activée en définissant output_router_logits=True dans la configuration du modèle (par exemple MixtralConfig).
Pour ajuster la contribution de la perte auxiliaire à la perte totale, utilisez l'hyperparamètre router_aux_loss_coef=... (valeur par défaut : 0.001) dans la configuration du modèle.

Recommandations de taille de lot

Utilisez une taille de lot par étape d’au moins 4, et une taille de lot effective comprise entre 16 et 128. Même si votre taille de lot effective est importante, si votre taille de lot par étape est faible, l’estimation du KL dans KTO sera médiocre.

Recommandations de taux d'apprentissage

Chaque choix de beta a un taux d'apprentissage maximal qu'il peut tolérer avant que les performances d'apprentissage ne se dégradent. Pour le réglage par défaut de beta = 0.1, le taux d'apprentissage ne devrait généralement pas dépasser 1e-6 pour la plupart des modèles. À mesure que beta diminue, le taux d'apprentissage doit également être réduit en conséquence. En général, nous recommandons vivement de maintenir le taux d'apprentissage entre 5e-7 et 5e-6. Même avec de petits jeux de données, nous déconseillons d'utiliser un taux d'apprentissage en dehors de cette plage. Optez plutôt pour un nombre d'époques plus élevé pour obtenir de meilleurs résultats.

Données déséquilibrées

Les desirable_weight et undesirable_weight de la classe KTOConfig correspondent aux poids appliqués aux pertes des exemples désirables/positifs et indésirables/négatifs. Par défaut, ils sont tous deux égaux à 1. Cependant, si vous avez plus d'un type que de l'autre, vous devez augmenter le poids du type le moins fréquent afin que le rapport entre (desirable_weight ×\times nombre de positifs) et (undesirable_weight ×\times nombre de négatifs) se situe entre 1:1 et 4:3.

KTOTrainer

classe trl.KTOTrainer

< >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.kto_config.KTOConfig | 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 KTO.
    • 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 KTO.
  • args (KTOConfig, facultatif) — Configuration pour 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 DataCollatorForUnpairedPreference si le modèle est un modèle de langage et DataCollatorForVisionUnpairedPreference si le modèle est un modèle de vision-langage. Les collators 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 le type préférence non appariée . 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'optimisation de Kahneman-Tversky (KTO). Cet algorithme a été initialement proposé dans l'article KTO: Model Alignment as Prospect Theoretic Optimization. Cette classe est un wrapper autour de la classe Trainer et hérite de tous ses attributs et méthodes.

Exemple :

>>> from trl import KTOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

>>> trainer = KTOTrainer(
...     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.

KTOConfig

classe trl.KTOConfig

< >

( 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 | None = Nonegradient_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 = 'sequential'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 = 1024pad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: str = 'kto'beta: float = 0.1desirable_weight: float = 1.0undesirable_weight: float = 1.0activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512 )

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 KTOTrainer 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 à droite. Si None, aucun tronquage n’est appliqué.
  • 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 (str, facultatif, par défaut "kto") — Type de perte à utiliser. Les valeurs possibles sont :
    • "kto" : perte KTO issue de l’article KTO.
    • "apo_zero_unpaired" : variante non appariée de la perte APO-zero issue de l’article APO.
  • 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.
  • desirable_weight (float, facultatif, valeur par défaut 1.0) — Les pertes désirables sont pondérées par ce facteur pour compenser le nombre inégal de paires désirables et indésirables.
  • undesirable_weight (float, facultatif, par défaut 1.0) — Les pertes indésirables sont pondérées par ce facteur pour compenser le nombre inégal de paires désirables et indésirables.
  • 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.

Classe de configuration pour le KTOTrainer.

Cette classe ne contient que les paramètres spécifiques à l’entraînement KTO. 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.
  • train_sampling_strategy : la valeur par défaut est "sequential" au lieu de "random". Les types de perte qui estiment le terme de divergence KL (tous sauf "apo_zero_unpaired") nécessitent un échantillonnage séquentiel, car la complétion KL de chaque exemple est précalculée par rapport à ses voisins dans un lot à ordre fixe ; toute autre stratégie rompt cette appariement.
Update on GitHub