TRL documentation

DPO Trainer

TRL

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.18.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

DPO Trainer

Обзор

TRL поддерживает DPO Trainer для обучения языковых моделей, как описано в статье Direct Preference Optimization: Your Language Model is Secretly a Reward Model авторов Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, Chelsea Finn.

Аннотация из статьи следующая:

Хотя крупные языковые модели (LM), обученные в режиме без учителя, приобретают обширные знания о мире и некоторые навыки рассуждения, точное управление их поведением затруднено из-за полностью неуправляемой природы их обучения. Существующие методы достижения такой управляемости собирают человеческие метки относительного качества генераций модели и дообучают неуправляемую LM для согласования с этими предпочтениями, часто с использованием обучения с подкреплением на основе обратной связи от человека (RLHF). Однако RLHF — это сложная и часто нестабильная процедура, которая сначала обучает модель вознаграждения, отражающую человеческие предпочтения, а затем дообучает крупную неуправляемую LM с помощью обучения с подкреплением, чтобы максимизировать эту оцененную награду, не отклоняясь слишком сильно от исходной модели. В данной статье мы вводим новую параметризацию модели вознаграждения в RLHF, которая позволяет извлекать соответствующую оптимальную политику в явном виде, что позволяет решать стандартную задачу RLHF с использованием только простой функции потерь классификации. Получившийся алгоритм, который мы называем Direct Preference Optimization (DPO), стабилен, эффективен и вычислительно легкий, устраняя необходимость в выборке из LM во время дообучения или в значительной настройке гиперпараметров. Наши эксперименты показывают, что DPO может дообучать LM для согласования с человеческими предпочтениями не хуже, а иногда и лучше существующих методов. Примечательно, что дообучение с DPO превосходит RLHF на основе PPO в способности контролировать тональность генераций и соответствует или улучшает качество ответов в задачах суммаризации и диалога в один ход, оставаясь при этом значительно более простым в реализации и обучении.

Этот метод постобучения был предложен Kashif Rasul и впоследствии переписан Quentin Gallouédec.

Быстрый старт

В этом примере показано, как обучить языковую модель с помощью DPOTrainer из TRL. Мы обучаем модель Qwen 3 0.6B на наборе данных UltraFeedback dataset.

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()

Ожидаемый тип и формат набора данных

Для DPO необходим набор данных предпочтений. DPOTrainer совместим с форматами как стандартных, так и диалоговых наборов данных. При использовании диалогового набора данных тренер автоматически применяет шаблон чата к данным.

# 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."}]}

Если ваш набор данных не представлен в одном из этих форматов, вы можете предварительно обработать его, чтобы преобразовать в ожидаемый формат. Вот пример с набором данных 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 [...]"}],
}

Более подробный обзор метода DPO

Direct Preference Optimization (DPO) — это метод обучения, предназначенный для согласования языковой модели с данными предпочтений. Вместо пар «вход–выход» с учителем модель обучается на парах завершений для одного и того же запроса, где одно завершение предпочтительнее другого. Целью является прямая оптимизация модели для расширения разрыва между логарифмическими правдоподобиями предпочтительных и нежелательных завершений относительно эталонной модели, без необходимости явной модели вознаграждения. На практике это обычно достигается подавлением правдоподобия нежелательных завершений, а не увеличением правдоподобия предпочтительных.

В этом разделе подробно описано, как DPO работает на практике, с охватом ключевых шагов: предобработка и вычисление функции потерь.

Предобработка и токенизация

В процессе обучения каждый пример должен содержать промпт, а также предпочтительное (chosen) и нежелательное (rejected) завершение. Подробнее об ожидаемых форматах см. в разделе Форматы наборов данных. Объект DPOTrainer токенизирует каждый вход с помощью токенизатора модели.

Вычисление функции потерь

dpo_figure

Функция потерь, используемая в DPO, определяется следующим образом: $\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]$

где $x$ — это промпт, $y^+$ — предпочтительное завершение, а $y^-$ — нежелательное завершение. $\pi_{\theta}$ — обучаемая модель политики, $\pi_{\mathrm{ref}}$ — эталонная модель, $\sigma$ — сигмоидная функция, а $\beta > 0$ — гиперпараметр, контролирующий силу сигнала предпочтений.

Типы потерь

В литературе предложено несколько формулировок целевой функции. Изначально целевая функция DPO была определена, как показано выше.

`loss_type=`	Описание
`"sigmoid"` (по умолчанию)	Исходя из данных предпочтений, мы можем обучить бинарный классификатор согласно модели Брэдли-Терри, и, в частности, авторы DPO предлагают использовать сигмоидную потерю на нормализованном правдоподобии через `logsigmoid` для обучения логистической регрессии.
`"hinge"`	Авторы RSO предлагают использовать шарнирный штраф (hinge loss) на нормализованную правдоподобность из статьи SLiC. В этом случае `beta` является обратной величиной к зазору (margin).
`"ipo"`	Авторы IPO утверждают, что преобразование логитов может приводить к переобучению, и предлагают использовать тождественное преобразование для прямой оптимизации предпочтений; TRL предоставляет это как `loss_type="ipo"`.
`"exo_pair"`	Авторы EXO предлагают оптимизацию предпочтений с обратным KL. Значение `label_smoothing` должно строго превышать `0.0`; рекомендуемое значение — `1e-3` (см. уравнение 16 для упрощённого попарного варианта). Полный метод использует `K>2` завершения SFT и приближается к PPO по мере роста `K`.
`"nca_pair"`	Авторы NCA показывают, что NCA оптимизирует абсолютную правдоподобность для каждого ответа, а не относительную правдоподобность.
`"robust"`	Авторы Robust DPO предлагают несмещённую функцию потерь DPO для зашумлённых предпочтений. Используйте `label_smoothing` в DPOConfig для моделирования вероятности инверсии меток; допустимые значения находятся в диапазоне `[0.0, 0.5)`.
`"bco_pair"`	Авторы BCO обучают бинарный классификатор, логит которого используется в качестве награды, так что классификатор отображает пары {prompt, chosen completion} в 1, а пары {prompt, rejected completion} — в 0.
`"sppo_hard"`	Авторы SPPO утверждают, что SPPO способен итеративно находить равновесие Нэша, сдвигая выбранные вознаграждения к значению 1/2, а отклонённые — к -1/2, и способен смягчать проблему разреженности данных. Реализация аппроксимирует этот алгоритм, используя вероятности жёстких меток: победителю присваивается 1, а проигравшему — 0.
`"aot"` или `loss_type="aot_unpaired"`	Авторы AOT предлагают выравнивание распределительных предпочтений с помощью оптимального транспорта. `loss_type="aot"` предназначен для парных данных, а `loss_type="aot_unpaired"` — для непарных. Оба метода обеспечивают стохастическое доминирование через отсортированные квантили; увеличение размера батча на GPU помогает.
`"apo_zero"` или `loss_type="apo_down"`	Метод APO вводит якорную целевую функцию. `apo_zero` усиливает выигрышные примеры и снижает вес проигрышных (полезно, когда модель уступает выигрышным). `apo_down` снижает вес обоих, но сильнее давит на проигрышные (полезно, когда модель уже превосходит выигрышные).
`"discopop"`	Статья DiscoPOP использует LLM для поиска более эффективных потерь для офлайн-оптимизации предпочтений. В статье предложенная функция потерь DiscoPOP (являющаяся лог-отношением с модуляцией) показала лучшие результаты по сравнению с другими функциями потерь на различных задачах (генерация позитивных текстов IMDb, суммаризация Reddit TLDR и Alpaca Eval 2.0).
`"sft"`	Потеря SFT (Supervised Fine-Tuning) — это потеря отрицательной логарифмической правдоподобности, используемая для обучения модели генерировать предпочтительные ответы.
`"sigmoid_norm"`	Авторы SimPO устраняют смещение по длине в исходной сигмоидной функции потерь, нормализуя её по количеству немаскированных токенов; TRL предоставляет это как `loss_type="sigmoid_norm"`.
`"udpo"`	Авторы UDPO предлагают несмещённую функцию потерь DPO для зашумлённых предпочтений, которая, в отличие от `"robust"`, остаётся несмещённой, даже если вероятность инверсии завышена. Используйте `label_smoothing` в DPOConfig, чтобы задать вероятность инверсии ε; допустимые значения находятся в диапазоне `[0.0, 0.5)`.

Записываемые метрики

Во время обучения и оценки мы фиксируем следующие метрики:

global_step: общее количество шагов оптимизатора, выполненных на данный момент.
epoch: текущий номер эпохи, основанный на итерации по набору данных.
num_tokens: общее количество обработанных на данный момент токенов.
loss: средняя DPO-потеря за текущий интервал логирования.
entropy: средняя энтропия распределения токенов, предсказанного моделью, по немаскированным токенам.
aux_loss: вспомогательная функция потерь для балансировки нагрузки в модели Mixture-of-Experts, до её масштабирования коэффициентом router_aux_loss_coef и добавления к общей функции потерь. Записывается в журнал только в том случае, если модель является MoE и router_aux_loss_coef не равен нулю.
mean_token_accuracy: доля немаскированных токенов, для которых топ-1 предсказание модели совпадает с токеном из выбранного завершения.
learning_rate: текущая скорость обучения, которая может динамически изменяться при использовании планировщика.
grad_norm: L2-норма градиентов, вычисленная до обрезания градиентов.
logits/chosen: средние значения логитов, которые модель присваивает токенам в выбранном завершении.
logits/rejected: средние значения логитов, которые модель присваивает токенам в отклонённом завершении.
logps/chosen: средняя логарифмическая вероятность, которую модель присваивает токенам в выбранном завершении.
logps/rejected: средняя логарифмическая вероятность, которую модель присваивает токенам в отклонённом завершении.
rewards/chosen: Среднее неявное вознаграждение, вычисленное для выбранного завершения, рассчитывается как $\beta \log \frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)}$ .
rewards/rejected: Среднее неявное вознаграждение, вычисленное для отклонённого завершения, рассчитывается как $\beta \log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)}$ .
rewards/margins: средняя неявная разница вознаграждений между выбранным и отклонённым завершениями.
rewards/accuracies: Доля примеров, в которых неявная награда за выбранное завершение выше, чем за отклонённое.

Настройка

Совместимость и ограничения

Некоторые комбинации аргументов намеренно ограничены в текущей реализации DPOTrainer:

use_weighting=True не поддерживается при использовании loss_type="aot" или loss_type="aot_unpaired".
PEFT-адаптеры, нацеленные на lm_head, не поддерживаются (вместо этого используйте modules_to_save=["lm_head"]).
sync_ref_model=True не поддерживается при обучении с моделями PEFT, которые не сохраняют отдельную ref_model.
sync_ref_model=True нельзя использовать вместе с precompute_ref_log_probs=True.
precompute_ref_log_probs=True не поддерживается с IterableDataset (для обучения или оценки).

Комбинации нескольких функций потерь

Тренер DPO поддерживает объединение нескольких функций потерь с различными весами, что позволяет реализовывать более сложные стратегии оптимизации. Это особенно полезно для реализации алгоритмов, таких как MPO (Mixed Preference Optimization). MPO — это подход к обучению, который объединяет несколько целей оптимизации, как описано в статье Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization.

Чтобы объединить несколько потерь, укажите типы потерь и соответствующие веса в виде списков:

# 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
)

Инициализация модели

Вы можете напрямую передать аргументы kwargs метода from_pretrained() в DPOConfig. Например, если вы хотите загрузить модель с другой точностью, аналогично

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

это можно сделать, передав аргумент model_init_kwargs={"dtype": torch.bfloat16} в DPOConfig.

from trl import DPOConfig

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

Обратите внимание, что поддерживаются все именованные аргументы from_pretrained().

Обучение адаптеров с PEFT

Мы поддерживаем тесную интеграцию с библиотекой 🤗 PEFT, что позволяет любому пользователю удобно обучать адаптеры и делиться ими на Hub, а не обучать всю модель целиком.

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()

Вы также можете продолжить обучение вашей модели PeftModel. Для этого сначала загрузите PeftModel вне DPOTrainer и передайте её непосредственно в треньер без аргумента 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()

При обучении адаптеров обычно используют более высокую скорость обучения (≈1e‑5), чем при полной дообучении, поскольку обучаются только новые параметры.
DPOConfig(learning_rate=1e-5, ...)

Быстрая экспериментальная работа с DPO

RapidFire AI — это экспериментальная система с открытым исходным кодом, работающая поверх TRL и позволяющая запускать несколько конфигураций DPO одновременно, даже на одном GPU. Вместо последовательного перебора конфигураций RapidFire позволяет ранее увидеть все их кривые обучения, остановить низкоэффективные запуски и клонировать перспективные с новыми настройками на лету без перезапуска. Подробнее см. RapidFire AI Integration.

Обучение с Unsloth

Unsloth — это open-source-фреймворк для дообучения и обучения с подкреплением, который обучает LLM (такие как Llama, Mistral, Gemma, DeepSeek и другие) до 2× быстрее, сокращая потребление VRAM до 70%, при этом обеспечивая упрощенный, совместимый с Hugging Face рабочий процесс для обучения, оценки и развертывания. Подробнее см. Интеграция с Unsloth.

Вызов инструментов с DPO

Обучатель DPOTrainer полностью поддерживает дообучение моделей с возможностями tool calling. В этом случае каждый пример в наборе данных должен включать:

Сообщения диалога (запрос, выбранный и отклонённый ответы), включая вызовы инструментов (tool_calls) и ответы инструментов (сообщения с ролью tool)
Список доступных инструментов в столбце tools, как правило, предоставляется в виде схем JSON

С подробностями о структуре ожидаемого набора данных см. раздел Dataset Format — Tool Calling.

Обучение моделей «зрение-язык»

DPOTrainer полностью поддерживает обучение моделей «зрение-язык» (VLM). Чтобы обучить VLM, предоставьте датасет с колонкой image (одно изображение на образец) или колонкой images (список изображений на образец). Подробнее об ожидаемой структуре датасета см. в разделе Формат датасета — визуальный датасет. Примером такого датасета является датасет 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()

Для VLM обрезка может привести к удалению токенов изображений, что вызывает ошибки во время обучения. Чтобы избежать этого, установите max_length=None в DPOConfig. Это позволяет модели обрабатывать полную длину последовательности без обрезки токенов изображений.
DPOConfig(max_length=None, ...)
Используйте max_length только после того, как вы убедитесь, что усечение не удалит токены изображений для всего набора данных.

DPOTrainer

класс trl.DPOTrainer

< source >

( 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 )

Параметры

model (str или PreTrainedModel или PeftModel) — Модель, подлежащая обучению. Может быть одним из следующих:
- Строка, являющаяся model id предобученной модели, размещённой в репозитории моделей на huggingface.co, или путь к каталогу, содержащему веса модели, сохранённые с помощью save_pretrained, например './my_model_directory/'. Модель загружается с помощью <ModelArchitecture>.from_pretrained (где <ModelArchitecture> определяется из конфигурации модели) с использованием именованных аргументов из args.model_init_kwargs. Если dtype не указан в args.model_init_kwargs, по умолчанию используется float32. Это отличается от from_pretrained, где (начиная с Transformers v5) тип данных выводится из конфигурации модели.
- Объект PreTrainedModel. Поддерживаются только каузальные языковые модели.
- Объект PeftModel. Поддерживаются только каузальные языковые модели.
ref_model (PreTrainedModel, необязательный) — Эталонная модель, используемая для вычисления эталонных логарифмических вероятностей. Если указана, эта модель используется напрямую в качестве эталонной политики. Она не может быть PeftModel. Если значение равно None, тренер автоматически использует начальную политику, соответствующую model, то есть состояние модели до начала обучения DPO.
- Если указан, эта модель используется непосредственно в качестве эталонной политики. Она не может быть PeftModel.
- Если None, тренер автоматически использует начальную политику, соответствующую model, то есть состояние модели до начала обучения DPO.
args (DPOConfig, необязательный) — Конфигурация для этого тренера. Если None, используется конфигурация по умолчанию.
data_collator (DataCollator, необязательный) — Функция для формирования батча из списка элементов обработанного train_dataset или eval_dataset. По умолчанию используется DataCollatorForPreference, если модель является языковой, и DataCollatorForVisionPreference, если модель является мультимодальной (vision-language). Пользовательские collator'ы должны обрезать последовательности до выравнивания (padding); trainer не применяет обрезку после формирования батча.
train_dataset (Dataset или IterableDataset) — Набор данных для обучения. Этот trainer поддерживает как моделирование языка , так и запрос-завершение . Формат образцов может быть следующим:
- Standard: каждая выборка содержит обычный текст.
- Диалоговый: каждая выборка содержит структурированные сообщения (например, роль и содержимое).
Если train_dataset является IterableDataset (например, потоковым набором данных), то max_steps необходимо задать в аргументах обучения, поскольку его длину невозможно определить, а общее количество шагов обучения требуется для ограничения цикла обучения и настройки планировщика скорости обучения.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict или dict[str, Dataset | IterableDataset]) — Набор данных для оценки. Он должен соответствовать тем же требованиям, что и train_dataset.
processing_class (PreTrainedTokenizerBase or ProcessorMixin, optional) — Processing class used to process the data. The padding side must be set to “left”. If None, the processing class is loaded from the model’s name with from_pretrained. A padding token, tokenizer.pad_token, must be set. If the processing class has not set a padding token, tokenizer.eos_token will be used as the default.
compute_metrics (Callable[[EvalPrediction], dict], необязательный) — Функция, которая будет использоваться для вычисления метрик при оценке. Она должна принимать EvalPrediction и возвращать словарь, сопоставляющий строки со значениями метрик. При передаче SFTConfig с параметром batch_eval_metrics, установленным в True, ваша функция compute_metrics должна принимать булевый аргумент compute_result. Это срабатывает после последней пачки оценки, чтобы сигнализировать функции, что необходимо вычислить и вернуть глобальную сводную статистику, а не накапливать статистику на уровне пачек. Логиты, которые она получает, пересчитываются с дополнительным прямым проходом. Это устаревший вариант, который будет удален в v2.0.0.
callbacks (список TrainerCallback, необязательный) — Список callback'ов для настройки цикла обучения. Они будут добавлены к списку callback'ов по умолчанию, описанных здесь.
Если вы хотите удалить один из используемых по умолчанию колбэков, воспользуйтесь методом remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], необязательный, по умолчанию (None, None)) — Кортеж, содержащий оптимизатор и планировщик, которые будут использоваться. По умолчанию будет создан экземпляр AdamW для вашей модели и планировщик, заданный функцией get_linear_schedule_with_warmup и управляемый параметрами args.
quantization_config (BitsAndBytesConfig, optional) — Конфигурация квантования, используемая при загрузке модели по идентификатору модели. Используйте в сочетании с peft_config для обучения QLoRA. Игнорируется, если модель уже инициализирована.
peft_config (PeftConfig, необязательный) — Конфигурация PEFT, используемая для обёртки модели. Если None, модель не оборачивается.

Trainer для метода Direct Preference Optimization (DPO). Данный алгоритм был впервые предложен в статье Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Этот класс является обёрткой над классом Trainer и наследует все его атрибуты и методы.

Пример:

>>> 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()

обучение

< source >

Параметры

resume_from_checkpoint (str или bool, необязательный) — Если передано значение типа str, это локальный путь к сохранённой контрольной точке, созданной предыдущим экземпляром Trainer. Если передано значение типа bool и оно равно True, загружается последняя контрольная точка из args.output_dir, сохранённая предыдущим экземпляром Trainer. Если параметр указан, обучение возобновляется из состояний модели/оптимизатора/планировщика, загруженных из этой контрольной точки.
trial (optuna.Trial или dict[str, Any], необязательный) — Запуск испытания или словарь гиперпараметров для поиска гиперпараметров.
ignore_keys_for_eval (list[str], необязательный) — Список ключей в выводе вашей модели (если он представляет собой словарь), которые следует игнорировать при сборе предсказаний для оценки во время обучения.

Возвращает

~trainer_utils.TrainOutput

Объект, содержащий количество глобальных шагов, потерю обучения и метрики.

Основная точка входа для обучения.

save_model

< source >

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

Сохранит модель, чтобы вы могли загрузить её снова с помощью from_pretrained().

Сохранение будет выполняться только из основного процесса.

push_to_hub

< source >

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

Параметры

commit_message (str, необязательный, по умолчанию "End of training") — Сообщение для коммита при отправке.
blocking (bool, необязательный, по умолчанию True) — Определяет, должна ли функция возвращаться только после завершения git push.
token (str, необязательный, по умолчанию None) — Токен с правом записи для перезаписи исходных аргументов Trainer.
revision (str, необязательный) — Git-ревизия, от которой выполняется коммит. По умолчанию используется head ветки “main”.
kwargs (dict[str, Any], необязательный) — Дополнительные именованные аргументы, передаваемые в ~Trainer.create_model_card.

Загрузите self.model и self.processing_class в модельный хаб 🤗 в репозиторий self.args.hub_model_id.

DPOConfig

класс trl.DPOConfig

< source >

( 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 = 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 )

Параметры, управляющие моделью

model_init_kwargs (dict[str, Any], необязательный) — Параметры-ключи для from_pretrained, используемые, когда аргумент model в DPOTrainer передан в виде строки. Значение revision также используется при загрузке обрабатывающего класса.
trust_remote_code (bool, optional, defaults to False) — Whether to allow loading models and tokenizers that ship custom Python code from the Hub. Forwarded to from_pretrained and from_pretrained.
router_aux_loss_coef (float, необязательный) — Коэффициент вспомогательной функции потерь для балансировки нагрузки в моделях Mixture-of-Experts (MoE), добавляемой к функции потерь обучения с этим весом. Если значение не задано, используется значение, объявленное в конфигурации модели. Установите 0.0, чтобы отключить её. Вызывает ошибку при использовании с моделью, не являющейся MoE.
disable_dropout (bool, необязательный, по умолчанию True) — Определяет, следует ли отключить dropout в модели и эталонной модели.

Параметры, управляющие предобработкой данных

dataset_num_proc (int, необязательный) — Количество процессов, используемых для обработки набора данных.
max_length (int or None, необязательный, по умолчанию 1024) — Максимальная длина токенизированной последовательности. Последовательности длиннее max_length обрезаются слева или справа в зависимости от truncation_mode. Если None, обрезка не применяется.
truncation_mode (str, необязательный, по умолчанию "keep_start") — Режим усечения, используемый, когда последовательность превышает max_length. Единственное поддерживаемое значение — "keep_start". Значение "keep_end" устарело и будет удалено в v2.0.0.
padding_free (bool, необязательный, по умолчанию False) — Определяет, следует ли выполнять прямые проходы без дополнения (padding), сжимая все последовательности в батче в одну непрерывную последовательность. Это снижает потребление памяти за счет устранения накладных расходов на padding. В настоящее время поддерживается только с FlashAttention 2 или 3, которые эффективно обрабатывают структуру сжатого батча. Временно недоступно: после рефакторинга DPO установка значения True вызывает предупреждение и переключается на стандартный padding. Планируется вернуть эту возможность в одном из будущих обновлений.
pad_to_multiple_of (int или str, необязательный, по умолчанию "auto") — Если задано, последовательности будут дополнены до кратного этого значения. "auto" дополняет до кратного 128 на Neuron (AWS Trainium), который компилируется один раз для каждой формы входных данных, и не выполняет дополнения в других случаях.
precompute_ref_log_probs (bool, необязательный, по умолчанию False) — Определяет, следует ли предварительно вычислить логарифмические вероятности эталонной модели для всего обучающего набора данных перед началом обучения. Это позволяет экономить память во время обучения, так как эталонную модель не нужно удерживать в памяти.
precompute_ref_batch_size (int, необязательный) — Размер батча, используемый при предварительном вычислении лог-вероятностей эталонной модели. Это значение можно установить выше, чем размер обучающего батча, чтобы ускорить предобработку. Если None, по умолчанию используется per_device_train_batch_size для обучения и per_device_eval_batch_size для оценки.

Параметры, управляющие обучением

loss_type (list[str], необязательный, по умолчанию ["sigmoid"]) — Тип используемой функции потерь. Возможные значения: 'sigmoid', 'hinge', 'ipo', 'exo_pair', 'nca_pair', 'robust', 'bco_pair', 'sppo_hard', 'aot', 'aot_unpaired', 'apo_zero', 'apo_down', 'discopop', 'sft', 'sigmoid_norm', 'udpo'. Если указано несколько типов потерь, они будут объединены с использованием весов, заданных в loss_weights.
loss_weights (list[float], необязательный) — Список весов потерь для комбинаций нескольких потерь. Используется при объединении нескольких типов потерь. Пример: [0.8, 0.2, 1.0] для MPO. Если не задано, по умолчанию используются равные веса (1.0) для всех типов потерь.
ld_alpha (float, необязательный) — параметр α из статьи LD-DPO, который управляет весами лог-вероятностей подробных токенов в ответах. Если None, взвешивание подробной части не применяется, и функция потерь эквивалентна стандартной функции потерь DPO. Должно находиться в диапазоне [0.0, 1.0]: ld_alpha=1.0 не применяет взвешивание, а ld_alpha=0.0 маскирует токены, выходящие за пределы общих длин.
f_divergence_type (str, необязательный, по умолчанию "reverse_kl") — регуляризатор f-расстояния между политикой и эталонной моделью (статья f-DPO). Возможные значения: reverse_kl (по умолчанию), forward_kl, js_divergence, alpha_divergence. Нестандартное значение поддерживается только для типов потерь, основанных на разнице наград для выбранных и отвергнутых ответов: 'sigmoid', 'sigmoid_norm', 'hinge', 'ipo', 'exo_pair', 'robust', 'discopop', 'sft', 'udpo'. Для остальных типов потерь не существует корректного обобщения f-расстояния, и они отклоняются при использовании нестандартного значения.
f_alpha_divergence_coef (float, необязательный, по умолчанию 0.5) — коэффициент α для регуляризатора α-дивергенции u^-α, используется только при f_divergence_type='alpha_divergence'.
label_smoothing (float, необязательный, по умолчанию 0.0) — Параметр сглаживания меток, используемый в Robust DPO, UDPO и EXO. В Robust DPO и UDPO он интерпретируется как вероятность ε того, что метка предпочтения инвертирована, и должен лежать в диапазоне [0.0, 0.5); типичное значение, рекомендуемое в статье о Robust DPO, составляет 0.1. UDPO использует его для вычисления a = ε / (1 - ε), при этом в статье о UDPO рекомендуется a = 0.8, то есть ε = 4/9. В EXO он соответствует параметру сглаживания меток ε, для которого в статье рекомендуется типичное значение 1e-3.
beta (float, необязательный, по умолчанию 0.1) — Параметр, контролирующий отклонение от эталонной модели. Чем выше β, тем меньше отклонение от эталонной модели. Для функции потерь IPO (loss_type='ipo') это значение является параметром регуляризации, обозначенным как τ в статье.
use_weighting (bool, необязательный, по умолчанию False) — Определяет, следует ли применять взвешивание в стиле WPO для пар предпочтений с использованием нормализованных по длине вероятностей последовательностей политики.
discopop_tau (float, необязательный, по умолчанию 0.05) — параметр τ/температуры из статьи DiscoPOP, который управляет формой лог-отношения модулированной функции потерь при использовании loss_type='discopop'. В статье рекомендуется значение по умолчанию discopop_tau=0.05.
activation_offloading (bool, необязательный, по умолчанию False) — Определяет, следует ли выгружать активации на CPU.
sync_ref_model (bool, необязательный, по умолчанию False) — Определяет, следует ли синхронизировать эталонную модель с активной моделью каждые ref_model_sync_steps шагов, используя параметр ref_model_mixup_alpha. Эта синхронизация описана в статье TR-DPO. sync_ref_model=True пока несовместим с PEFT или precompute_ref_log_probs=True.
ref_model_mixup_alpha (float, необязательный, по умолчанию 0.6) — параметр α из статьи TR-DPO, который управляет смесью текущей политики и предыдущей референсной политики при обновлениях. Референсная политика обновляется по формуле: π_ref = α * π_θ + (1 - α) * π_ref_prev. Чтобы использовать этот параметр, необходимо установить sync_ref_model=True.
ref_model_sync_steps (int, необязательный, по умолчанию 512) — параметр τ из статьи TR-DPO, определяющий, как часто текущая политика синхронизируется с эталонной политикой. Чтобы использовать этот параметр, необходимо установить sync_ref_model=True.

Устаревшие параметры

pad_token —
Параметр pad_token устарел и будет удалён в версии v2.0.0. Вместо этого задайте tokenizer.pad_token напрямую и передайте его в тренера как processing_class.

Класс конфигурации для DPOTrainer.

Этот класс содержит только параметры, специфичные для обучения DPO. Полный список аргументов обучения см. в документации TrainingArguments. Обратите внимание, что значения по умолчанию в этом классе могут отличаться от значений в TrainingArguments.

С помощью HfArgumentParser мы можем превратить этот класс в аргументы argparse, которые можно указать в командной строке.

Эти параметры имеют значения по умолчанию, отличные от TrainingArguments:

logging_steps: по умолчанию 10, а не 500.

gradient_checkpointing: по умолчанию True, а не False.

bf16: по умолчанию True, если не задан fp16, а не False.

learning_rate: по умолчанию 1e-6, а не 5e-5.

Update on GitHub

←Дистилляция GRPO→