# KTO Trainer

[![All_models-KTO-blue](https://img.shields.io/badge/All_models-KTO-blue)](https://huggingface.co/models?other=kto,trl)

## Обзор

TRL поддерживает тренаер Kahneman-Tversky Optimization (KTO) для обучения языковых моделей, описанный в статье [KTO: Model Alignment as Prospect Theoretic Optimization](https://huggingface.co/papers/2402.01306) авторов [Kawin Ethayarajh](https://huggingface.co/kawine), [Winnie Xu](https://huggingface.co/xwinxu), [Niklas Muennighoff](https://huggingface.co/Muennighoff), Dan Jurafsky, [Douwe Kiela](https://huggingface.co/douwekiela).

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

> Теория перспектив Канемана и Тверски утверждает, что люди воспринимают случайные переменные предвзятым, но хорошо определённым образом; например, людям присуща известная неприятие потерь. Мы показываем, что целевые функции для выравнивания LLM с человеческой обратной связью неявно включают многие из этих предубеждений — успех этих целевых функций (например, DPO) по сравнению с минимизацией перекрёстной энтропии можно частично объяснить тем, что они являются функциями потерь, учитывающими человеческие особенности (HALOs). Однако функции полезности, которые эти методы приписывают людям, всё ещё отличаются от тех, что описаны в литературе по теории перспектив. Используя модель человеческой полезности Канемана-Тверски, мы предлагаем HALO, который напрямую максимизирует полезность генераций, а не максимизирует логарифмическую правдоподобие предпочтений, как это делают текущие методы. Мы называем этот подход оптимизацией Канемана-Тверски (KTO), и он соответствует или превосходит производительность методов на основе предпочтений на масштабах от 1B до 30B. Принципиально важно, что KTO не требует предпочтений — только бинарного сигнала о том, является ли вывод желательным или нежелательным для данного входа. Это делает его гораздо проще в использовании в реальных условиях, где данные о предпочтениях редки и дороги.

Официальный код можно найти в [ContextualAI/HALOs](https://github.com/ContextualAI/HALOs).

Этот метод постобучения был предложен [Kashif Rasul](https://huggingface.co/kashif), [Younes Belkada](https://huggingface.co/ybelkada), [Lewis Tunstall](https://huggingface.co/lewtun), Pablo Vicente, а впоследствии переписан [Albert Villanova del Moral](https://huggingface.co/albertvillanova).

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

В этом примере показано, как обучить модель с использованием метода KTO. В качестве базовой модели используется [Qwen 0.5B](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct). Для предпочтений используются данные из набора [KTO Mix 14k](https://huggingface.co/datasets/trl-lib/kto-mix-14k). Посмотреть данные в наборе можно здесь:

<iframe src="https://huggingface.co/datasets/trl-lib/kto-mix-14k/embed/viewer/default/train?row=0" frameborder="0" width="100%" height="560px"
>

Ниже приведён скрипт для обучения модели:

```python
# 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()
```

Выполните скрипт с помощью следующей команды:

```bash
torchrun --nproc_per_node 8 train_kto.py
```

Обучение распределено по 8 x H100 GPU и занимает примерно 30 минут. Вы можете отслеживать прогресс обучения, проверяя график вознаграждения. Растущая тенденция в разнице вознаграждений (reward margin) указывает на то, что модель улучшается и со временем генерирует более качественные ответы.

![kto qwen2 reward margin](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/kto-qwen2-reward-margin.png)

Чтобы оценить работу [обученной модели](https://huggingface.co/trl-lib/Qwen2-0.5B-KTO), вы можете использовать [Transformers Chat CLI](https://huggingface.co/docs/transformers/quicktour#chat-with-text-generation-models).

$ transformers chat trl-lib/Qwen2-0.5B-KTO &lt;quentin_gallouedec&gt;: Какой лучший язык программирования?

&lt;trl-lib/Qwen2-0.5B-KTO&gt;: Лучший язык программирования может различаться в зависимости от личных предпочтений, отраслевых требований, технических навыков и знакомства с конкретным сценарием использования или задачей. Ниже приведены некоторые широко используемые языки программирования, которые считаются популярными и востребованными:

Вот несколько других факторов, которые следует учитывать при выборе языка программирования для проекта:

 1 JavaScript: JavaScript — основа веба, используется для создания веб-приложений, API и интерактивных фронтенд-приложений на фреймворках, таких как React и Angular. Синтаксисом он похож на C, C++ и F#, а также прост и доступен для изучения, что делает его популярным выбором как для начинающих, так и для опытных специалистов. 2 Java: Java известна объектно-ориентированным программированием (ООП) и поддержкой Java 8 и .NET. Язык применяется для разработки корпоративного программного обеспечения, высокопроизводительных игр, а также мобильных приложений, игр и настольных приложений. 3 C++: C++ ценится за гибкость и масштабируемость, предлагает полноценное объектно-ориентированное программирование и является популярным выбором для высокопроизводительных вычислений и других технических областей. Это мощная платформа для создания реальных приложений и игр в промышленных масштабах. 4 Python: Python был разработан Гвидо ван Россумом в 1991 году. Это высокоуровневый интерпретируемый язык с динамической типизацией, известный простотой, читаемостью и универсальностью.

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

Для KTO требуется набор данных с [непарными предпочтениями](dataset_formats#unpaired-preference). В качестве альтернативы можно предоставить набор данных с *парными* предпочтениями (также известный просто как *набор данных предпочтений*). В этом случае тренер автоматически преобразует его в формат с непарными предпочтениями, разделяя выбранные и отклонённые ответы, назначая `label = True` для выбранных завершений и `label = False` для отклонённых.

[KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer) совместим с форматами данных как [стандартным](dataset_formats#standard), так и [диалоговым](dataset_formats#conversational). При использовании диалогового набора данных тренер автоматически применяет шаблон чата к данным.

```python
# 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}
```

В теории набор данных должен содержать как минимум одно выбранное и одно отклонённое завершение. Однако некоторые пользователи успешно запускали KTO, используя *только* выбранные или только отклонённые данные. При использовании только отклонённых данных рекомендуется применять консервативную скорость обучения.

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

Оптимизация Канемана–Тверски (KTO) — это метод обучения, предназначенный для выравнивания языковой модели с использованием только бинарного сигнала о том, является ли вывод *желательным* или *нежелательным* для данного входа, а не парами предпочтительных/непредпочтительных завершений. Опираясь на теорию перспектив Канемана и Тверски, метод определяет *потерю с учетом человеческого восприятия* (HALO), которая напрямую максимизирует полезность генераций, асимметрично взвешивая желательные и нежелательные примеры, чтобы отразить человеческую неприятие потерь.

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

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

В процессе обучения каждый пример должен содержать промпт, `completion` и булево значение `label`, указывающее, является ли завершение желательным (`True`) или нежелательным (`False`). Дополнительные сведения об ожидаемых форматах приведены в разделе [Dataset formats](dataset_formats). [KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer) токенизирует каждый вход с помощью токенизатора модели.

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

Член KL-расхождения, используемый в функции потерь KTO, оценивается путём сопоставления каждого промпта с несоответствующим завершением, взятым из другой части батча. По этой причине типы потерь, оценивающие член KL (все, кроме `apo_zero_unpaired`), требуют размер обучающего батча на устройство, больший 1, и последовательную стратегию выборки, чтобы несоответствующие пары оставались стабильными в пределах батча.

Потеря, используемая в KTO (формула 7 в [статье](https://huggingface.co/papers/2402.01306)), определяется следующим образом:

$$ \mathcal{L}_{\mathrm{KTO}}(\theta) = \mathbb{E}_{(x,y)}\!\left[ w(y)\Big(1 - v(x, y)\Big) \right] $$

где значение \\( v(x, y) \\) равно

$$ 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{если } y \text{ желательна} \\ \sigma\!\left(\beta\big(\mathrm{KL} - \log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)}\big)\right) & \text{если } y \text{ нежелательна} \end{cases} $$

Здесь  \\( x \\) — это промпт,  \\( y \\) — дополнение,  \\( \pi_{\theta} \\) — обучаемая модель политики,  \\( \pi_{\mathrm{ref}} \\) — эталонная модель,  \\( \sigma \\) — сигмоидная функция,  \\( \beta > 0 \\) управляет отклонением от эталонной модели, а  \\( \mathrm{KL} \\) — оценка расхождения Кульбака–Лейблера. Вес  \\( w(y) \\) равен `desirable_weight` для желательных дополнений и `undesirable_weight` для нежелательных; он используется для компенсации дисбаланса между количеством желательных и нежелательных примеров.

#### Типы потерь

| `loss_type=` | Описание |
| --- | --- |
| `"kto"` (по умолчанию) | Потери KTO из статьи [KTO](https://huggingface.co/papers/2402.01306). Потери, учитывающие восприятие человека (HALO), основанные на теории перспектив Канемана и Тверски, которые максимизируют полезность желаемых завершений и минимизируют её для нежелательных, используя оценённый член KL-расхождения в качестве опорной точки. |
| `"apo_zero_unpaired"` | Непарный вариант функции потерь APO-zero из статьи [APO](https://huggingface.co/papers/2408.06266). Она повышает вероятность желательных завершений и снижает вероятность нежелательных, не оценивая член KL-расхождения. Используйте эту функцию потерь, если вы считаете, что желательные завершения лучше, чем вывод модели по умолчанию. |

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

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

- `global_step`: общее количество шагов оптимизатора, выполненных на данный момент.
- `epoch`: текущий номер эпохи, основанный на итерации по набору данных.
- `num_tokens`: общее количество обработанных на данный момент токенов.
- `loss`: средняя KTO-потеря за текущий интервал логирования.
- `entropy`: средняя энтропия распределения токенов, предсказанного моделью, по немаскированным токенам.
- `aux_loss`: вспомогательная функция потерь для балансировки нагрузки в модели Mixture-of-Experts, до её масштабирования коэффициентом `router_aux_loss_coef` и добавления к общей функции потерь. Записывается в журнал только в том случае, если модель является MoE и `router_aux_loss_coef` не равен нулю.
- `kl`: средняя оценённая дивергенция Кульбака–Лейблера между моделью политики и эталонной моделью, используемая в качестве опорной точки в функции потерь KTO.
- `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`: средняя неявная разница вознаграждений между выбранным и отклонённым завершениями.

## Настройка

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

Некоторые комбинации аргументов намеренно ограничены в текущей реализации [KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer):

- 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` (для обучения или оценки) или с наборами данных для компьютерного зрения.
- Типы потерь, оценивающие член KL-расхождения (все, кроме `"apo_zero_unpaired"`), требуют `train_sampling_strategy="sequential"` и размера обучающей выборки на устройство, большего, чем 1.

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

Вы можете напрямую передавать аргументы kwargs метода `from_pretrained()` в [KTOConfig](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOConfig). Например, если вы хотите загрузить модель с другой точностью, аналогично

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

это можно сделать, передав аргумент `model_init_kwargs={"dtype": torch.bfloat16}` в [KTOConfig](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOConfig).

```python
from trl import KTOConfig

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

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

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

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

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

Вы также можете продолжить обучение вашей модели `PeftModel`. Для этого сначала загрузите `PeftModel` вне [KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer) и передайте её непосредственно в треньер без аргумента `peft_config`.

> [!TIP]
> При обучении адаптеров обычно используют более высокую скорость обучения, чем при полной дообучении, поскольку обучаются только новые параметры.

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

Обучающий класс [KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer) полностью поддерживает дообучение моделей с возможностями _tool calling_. В этом случае каждый пример в наборе данных должен включать:

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

С подробностями о структуре ожидаемого набора данных см. раздел [Dataset Format — Tool Calling](dataset_formats#tool-calling).

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

[KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer) полностью поддерживает обучение моделей «зрение-язык» (VLM). Чтобы обучить VLM, предоставьте набор данных с колонкой `image` (одно изображение на образец) или колонкой `images` (список изображений на образец). Подробнее об ожидаемой структуре набора данных см. в разделе [Dataset Format — Vision Dataset](dataset_formats#vision-dataset).

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

> [!TIP]
> Для VLM обрезка может привести к удалению токенов изображений, что вызывает ошибки во время обучения. Чтобы избежать этого, установите `max_length=None` в [KTOConfig](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOConfig). Это позволяет модели обрабатывать полную длину последовательности без обрезки токенов изображений.
>
> ```python
> KTOConfig(max_length=None, ...)
> ```
>
> Используйте `max_length` только после того, как вы убедитесь, что усечение не удалит токены изображений для всего набора данных.

## Пример скрипта

Мы предоставляем пример скрипта для обучения модели с использованием метода KTO. Скрипт доступен в [`trl/scripts/kto.py`](https://github.com/huggingface/trl/blob/main/trl/scripts/kto.py)

Чтобы протестировать скрипт KTO на модели [Qwen2 0.5B](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct) с использованием набора данных [UltraFeedback](https://huggingface.co/datasets/trl-lib/kto-mix-14k), выполните следующую команду:

```bash
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
```

## Советы по использованию

### Для моделей Mixture of Experts: включение вспомогательной функции потерь

MOE наиболее эффективны, когда нагрузка распределена между экспертами примерно равномерно. Чтобы обеспечить сходное обучение MOE на этапе preference-tuning, полезно добавить вспомогательный loss от load balancer к итоговому loss.

Этот параметр включается установкой `output_router_logits=True` в конфигурации модели (например, [MixtralConfig](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/mixtral#transformers.MixtralConfig)). Чтобы масштабировать вклад вспомогательной функции потерь в общую функцию потерь, используйте гиперпараметр `router_aux_loss_coef=...` (по умолчанию: `0.001`) в конфигурации модели.

### Рекомендации по размеру батча

Используйте размер батча на шаг (per-step batch size) не менее 4, а эффективный размер батча — в диапазоне от 16 до 128. Даже если ваш эффективный размер батча велик, но размер батча на шаг выбран неудачно, оценка KL в KTO будет неточной.

### Рекомендации по скорости обучения

Каждое значение `beta` имеет максимальную скорость обучения, которую оно может выдержать до ухудшения качества обучения. Для значения по умолчанию `beta = 0.1` скорость обучения обычно не должна превышать `1e-6` для большинства моделей. По мере уменьшения `beta` скорость обучения также следует снижать соответственно. В целом, мы настоятельно рекомендуем держать скорость обучения в диапазоне от `5e-7` до `5e-6`. Даже при работе с небольшими наборами данных мы не рекомендуем использовать скорость обучения вне этого диапазона. Вместо этого увеличьте количество эпох, чтобы получить лучшие результаты.

### Несбалансированные данные

Параметры `desirable_weight` и `undesirable_weight` в [KTOConfig](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOConfig) задают веса, применяемые к потерям для желаемых/положительных и нежелательных/отрицательных примеров. По умолчанию оба равны 1. Однако, если одного из типов примеров больше, чем другого, следует увеличить вес менее распространенного типа так, чтобы соотношение (`desirable_weight`  \\(\times\\) количество положительных) к (`undesirable_weight`  \\(\times\\) количество отрицательных) находилось в диапазоне от 1:1 до 4:3.

## KTOTrainer[[trl.KTOTrainer]]

#### trl.KTOTrainer[[trl.KTOTrainer]]

```python
trl.KTOTrainer(model: str | PreTrainedModel | PeftModel, ref_model: transformers.modeling_utils.PreTrainedModel | None = None, args: trl.trainer.kto_config.KTOConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_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 = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

[Источник](https://github.com/huggingface/trl/blob/v1.18.1/trl/trainer/kto_trainer.py#L462)

**Параметры:**

model (`str` или [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) или `PeftModel`) : Модель, подлежащая обучению. Может быть:  - строкой, являющейся *model id* предобученной модели, размещённой в репозитории моделей на huggingface.co, или путём к *каталогу*, содержащему веса модели, сохранённые с помощью [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained), например, `'./my_model_directory/'`. Модель загружается с помощью `<ModelArchitecture>.from_pretrained` (где `<ModelArchitecture>` определяется из конфигурации модели) с использованием именованных аргументов из `args.model_init_kwargs`. Если `dtype` не указан в `args.model_init_kwargs`, по умолчанию используется `float32`. Это отличается от [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained), где (начиная с Transformers v5) тип данных выводится из конфигурации модели. - Объектом [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel). Поддерживаются только каузальные языковые модели. - Объектом `PeftModel`. Поддерживаются только каузальные языковые модели.

ref_model ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel), *optional*) : Модель, используемая для вычисления эталонных логарифмических вероятностей. - Если указана, эта модель используется непосредственно в качестве эталонной политики. Она не может быть `PeftModel`. - Если `None`, тренер автоматически использует начальную политику, соответствующую `model`, то есть состояние модели до начала обучения KTO.

args ([KTOConfig](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOConfig), *необязательный*) : Конфигурация для этого тренера. Если `None`, используется конфигурация по умолчанию.

data_collator (`DataCollator`, *необязательный*) : Функция для формирования батча из списка элементов обработанного `train_dataset` или `eval_dataset`. По умолчанию используется `DataCollatorForUnpairedPreference`, если модель является языковой, и `DataCollatorForVisionUnpairedPreference`, если модель является мультимодальной (vision-language). Пользовательские collator'ы должны обрезать последовательности до добавления padding; trainer не применяет обрезку после collation.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) или [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : Набор данных для обучения. Этот тренер поддерживает тип [unpaired preference](#unpaired-preference). Формат образцов может быть следующим:  - [Standard](dataset_formats#standard): каждый образец содержит обычный текст. - [Conversational](dataset_formats#conversational): каждый образец содержит структурированные сообщения (например, роль и содержимое).  Если `train_dataset` является [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset) (например, потоковым набором данных), необходимо задать `max_steps` в аргументах обучения, так как его длина не может быть определена, а общее количество шагов обучения требуется для ограничения цикла обучения и настройки планировщика скорости обучения.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset), [DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict), [IterableDatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDatasetDict) или `dict[str, Dataset | IterableDataset]`) : Набор данных для использования при оценке. Он должен соответствовать тем же требованиям, что и `train_dataset`.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) или [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.ProcessorMixin), *необязательный*) : Класс обработки, используемый для обработки данных. Сторона отступов должна быть установлена в "left". Если `None`, класс обработки загружается по имени модели с помощью [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained). Токен отступов, `tokenizer.pad_token`, должен быть установлен. Если класс обработки не установил токен отступов, по умолчанию будет использован `tokenizer.eos_token`.

compute_metrics (`Callable[[EvalPrediction], dict]`, *необязательный*) : Функция, которая будет использоваться для вычисления метрик при оценке. Она должна принимать [EvalPrediction](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.EvalPrediction) и возвращать словарь, сопоставляющий строки со значениями метрик. При передаче [SFTConfig](/docs/trl/v1.18.1/ru/sft_trainer#trl.SFTConfig) с параметром `batch_eval_metrics`, установленным в `True`, ваша функция `compute_metrics` должна принимать булевый аргумент `compute_result`. Это срабатывает после последней пачки оценки, чтобы сигнализировать функции, что необходимо вычислить и вернуть глобальную сводную статистику, а не накапливать статистику на уровне пачек. Логиты, которые она получает, пересчитываются с дополнительным прямым проходом. Это устаревший параметр, который будет удалён в v2.0.0.

callbacks (список [TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback), *необязательный*) : Список колбэков для настройки цикла обучения. Эти колбэки будут добавлены к списку колбэков по умолчанию, описанному [здесь](https://huggingface.co/docs/transformers/main_classes/callback). Если вы хотите удалить один из колбэков по умолчанию, используйте метод [remove_callback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer.remove_callback).

optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *необязательный*, по умолчанию `(None, None)`) : Кортеж, содержащий оптимизатор и планировщик, которые следует использовать. По умолчанию будет использован экземпляр `AdamW` для вашей модели и планировщик, заданный [get_linear_schedule_with_warmup](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) и управляемый `args`.

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.BitsAndBytesConfig), *optional*) : Конфигурация квантования, используемая при загрузке модели по идентификатору модели. Используйте в сочетании с `peft_config` для обучения QLoRA. Игнорируется, если модель уже инициализирована.

peft_config (`PeftConfig`, *необязательный*) : конфигурация PEFT, используемая для обёртки модели. Если `None`, модель не оборачивается.

Trainer для метода оптимизации Канемана-Тверски (KTO). Данный алгоритм был впервые предложен в статье [KTO: Model Alignment as Prospect Theoretic Optimization](https://huggingface.co/papers/2402.01306). Этот класс является обёрткой над классом [Trainer](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) и наследует все его атрибуты и методы.

Пример:

```python
>>> 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[[trl.KTOTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Источник](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L1450)

**Параметры:**

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[[trl.KTOTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Источник](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4077)

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

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

#### push_to_hub[[trl.KTOTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4337)

**Параметры:**

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

**Возвращает:**

URL репозитория, в который была загружена модель, если `blocking=False`, или объект `Future`, отслеживающий ход коммита, если `blocking=True`.

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

## KTOConfig[[trl.KTOConfig]]

#### trl.KTOConfig[[trl.KTOConfig]]

```python
trl.KTOConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 1e-06, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'sequential', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, disable_dropout: bool = True, dataset_num_proc: int | None = None, max_length: int | None = 1024, pad_to_multiple_of: int | str | None = 'auto', precompute_ref_log_probs: bool = False, precompute_ref_batch_size: int | None = None, loss_type: str = 'kto', beta: float = 0.1, desirable_weight: float = 1.0, undesirable_weight: float = 1.0, activation_offloading: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512)
```

[Источник](https://github.com/huggingface/trl/blob/v1.18.1/trl/trainer/kto_config.py#L22)

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

model_init_kwargs (`dict[str, Any]`, *необязательный*) : Именованные аргументы для [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained), используемые, когда аргумент `model` в [KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer) передан в виде строки. Значение `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](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) and [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained).

router_aux_loss_coef (`float`, *необязательный*) : Коэффициент вспомогательной функции потерь для балансировки нагрузки в моделях Mixture-of-Experts (MoE), добавляемой к функции потерь обучения с этим весом. Если значение не задано, используется значение, объявленное в конфигурации модели. Установите `0.0`, чтобы отключить. Вызывает ошибку при использовании с моделью, не являющейся MoE.

disable_dropout (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли отключить dropout в модели и эталонной модели.

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

dataset_num_proc (`int`, *optional*) : Количество процессов, используемых для обработки набора данных.

max_length (`int` или `None`, *необязательный*, по умолчанию `1024`) : Максимальная длина токенизированной последовательности. Последовательности длиннее `max_length` обрезаются справа. Если указано `None`, обрезка не выполняется.

pad_to_multiple_of (`int` или `str`, *необязательный*, по умолчанию `"auto"`) : Если задано, последовательности будут дополнены до кратного этого значения. `"auto"` дополняет до кратного 128 на Neuron (AWS Trainium), который компилируется один раз для каждой формы входных данных, и не выполняет дополнения в других случаях.

precompute_ref_log_probs (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли предварительно вычислить логарифмические вероятности эталонной модели для всего обучающего набора данных перед началом обучения. Это позволяет экономить память во время обучения, так как эталонную модель не нужно удерживать в памяти.

precompute_ref_batch_size (`int`, *optional*) : Размер батча, используемый при предварительном вычислении лог-вероятностей эталонной модели. Это значение можно установить выше, чем размер обучающего батча, чтобы ускорить предобработку. Если `None`, по умолчанию используется `per_device_train_batch_size` для обучения и `per_device_eval_batch_size` для оценки.

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

loss_type (`str`, *необязательный*, по умолчанию `"kto"`) : Тип используемой функции потерь. Возможные значения:  - `"kto"`: Потеря KTO из статьи [KTO](https://huggingface.co/papers/2402.01306). - `"apo_zero_unpaired"`: Непарный вариант потери APO-zero из статьи [APO](https://huggingface.co/papers/2408.06266).

beta (`float`, *необязательный*, по умолчанию `0.1`) : Параметр, контролирующий отклонение от эталонной модели. Чем выше β, тем меньше отклонение от эталонной модели.

desirable_weight (`float`, *optional*, по умолчанию `1.0`) : Потери, соответствующие желаемым парам, взвешиваются этим коэффициентом для компенсации неравного количества желаемых и нежелательных пар.

undesirable_weight (`float`, *optional*, по умолчанию `1.0`) : Нежелательные потери взвешиваются этим коэффициентом, чтобы компенсировать неравное количество желательных и нежелательных пар.

activation_offloading (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли выгружать активации на CPU.

sync_ref_model (`bool`, *необязательный*, по умолчанию `False`) : Синхронизировать ли эталонную модель с активной моделью каждые `ref_model_sync_steps` шагов, используя параметр `ref_model_mixup_alpha`. Эта синхронизация взята из статьи [TR-DPO](https://huggingface.co/papers/2404.09656). `sync_ref_model=True` пока несовместим с PEFT или `precompute_ref_log_probs=True`.

ref_model_mixup_alpha (`float`, *optional*, по умолчанию `0.6`) : параметр α из статьи TR-DPO, который управляет соотношением между текущей политикой и предыдущей референсной политикой при обновлениях. Референсная политика обновляется по формуле: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. Чтобы использовать этот параметр, необходимо установить `sync_ref_model=True`.

ref_model_sync_steps (`int`, *необязательный*, по умолчанию `512`) : параметр τ из статьи [TR-DPO](https://huggingface.co/papers/2404.09656), определяющий, как часто текущая политика синхронизируется с эталонной политикой. Чтобы использовать этот параметр, необходимо установить `sync_ref_model=True`.

Класс конфигурации для [KTOTrainer](/docs/trl/v1.18.1/ru/kto_trainer#trl.KTOTrainer).

Этот класс содержит только параметры, специфичные для обучения KTO. Полный список аргументов обучения см. в документации [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments). Обратите внимание, что значения по умолчанию в этом классе могут отличаться от значений в [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

С помощью [HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser) мы можем превратить этот класс в аргументы [argparse](https://docs.python.org/3/library/argparse#module-argparse), которые можно указать в командной строке.

> [!NOTE]
> Эти параметры имеют значения по умолчанию, отличные от [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments): - `logging_steps`: По умолчанию `10`, а не `500`. - `gradient_checkpointing`: По умолчанию `True`, а не `False`. - `bf16`: По умолчанию `True`, если `fp16` не задан, в отличие от `False`. - `learning_rate`: По умолчанию `1e-6`, а не `5e-5`. - `train_sampling_strategy`: По умолчанию `"sequential"`, а не `"random"`. Типы потерь, оценивающие член KL-дивергенции (все, кроме `"apo_zero_unpaired"`), требуют последовательной выборки, поскольку KL-дополнение для каждого примера вычисляется заранее по соседним элементам в батче с фиксированным порядком; любая другая стратегия нарушает эту связь.

