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

Обзор

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, определяется следующим образом: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]

где x x — это промпт, y+ y^+ — предпочтительное завершение, а y− y^- — нежелательное завершение. πθ \pi_{\theta} — обучаемая модель политики, πref \pi_{\mathrm{ref}} — эталонная модель, σ \sigma — сигмоидная функция, а β>0 \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: Среднее неявное вознаграждение, вычисленное для выбранного завершения, рассчитывается как βlog⁡πθ(y+ ⁣∣x)πref(y+ ⁣∣x) \beta \log \frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)} .
  • rewards/rejected: Среднее неявное вознаграждение, вычисленное для отклонённого завершения, рассчитывается как βlog⁡πθ(y− ⁣∣x)πref(y− ⁣∣x) \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

< >

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

обучение

< >

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

Параметры

  • 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

< >

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

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

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

push_to_hub

< >

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

Параметры

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

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

DPOConfig

класс 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 )

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

  • 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