TRL documentation

KTO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

KTO Trainer

All_models-KTO-blue

Обзор

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

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

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

Официальный код можно найти в ContextualAI/HALOs.

Этот метод постобучения был предложен Kashif Rasul, Younes Belkada, Lewis Tunstall, Pablo Vicente, а впоследствии переписан Albert Villanova del Moral.

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

В этом примере показано, как обучить модель с использованием метода KTO. В качестве базовой модели используется Qwen 0.5B. Для предпочтений используются данные из набора KTO Mix 14k. Посмотреть данные в наборе можно здесь:

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

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

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

torchrun --nproc_per_node 8 train_kto.py

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

kto qwen2 reward margin

Чтобы оценить работу обученной модели, вы можете использовать Transformers Chat CLI.

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

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

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

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

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

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

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

# 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). Дополнительные сведения об ожидаемых форматах см. в разделе Форматы наборов данных. Объект KTOTrainer токенизирует каждый вход с помощью токенизатора модели.

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

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

Потеря, используемая в KTO (формула 7 в статье) ), определяется следующим образом: LKTO(θ)=E(x,y) ⁣[w(y)(1−v(x,y))] \mathcal{L}_{\mathrm{KTO}}(\theta) = \mathbb{E}_{(x,y)}\!\left[ w(y)\Big(1 - v(x, y)\Big) \right]

где значение v(x,y) v(x, y) равно v(x,y)={σ ⁣(β(log⁡πθ(y∣x)πref(y∣x)−KL))if y is desirableσ ⁣(β(KL−log⁡πθ(y∣x)πref(y∣x)))if y is undesirable v(x, y) = \begin{cases} \sigma\!\left(\beta\big(\log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} - \mathrm{KL}\big)\right) & \text{if } y \text{ is desirable} \\ \sigma\!\left(\beta\big(\mathrm{KL} - \log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)}\big)\right) & \text{if } y \text{ is undesirable} \end{cases}

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

Типы потерь

loss_type=Описание
"kto" (по умолчанию)Потери KTO из статьи KTO. Потери, учитывающие восприятие человека (HALO), основанные на теории перспектив Канемана и Тверски, которые максимизируют полезность желаемых завершений и минимизируют её для нежелательных, используя оценённый член KL-расхождения в качестве опорной точки.
"apo_zero_unpaired"Непарный вариант функции потерь APO-zero из статьи APO. Она повышает вероятность желательных завершений и снижает вероятность нежелательных, не оценивая член 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: Среднее неявное вознаграждение, вычисленное для выбранного (желательного) завершения, рассчитывается как β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: средняя неявная разница вознаграждений между выбранным и отклонённым завершениями.

Настройка

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

Некоторые комбинации аргументов намеренно ограничены в текущей реализации 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. Например, если вы хотите загрузить модель с другой точностью, аналогично

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

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

from trl import KTOConfig

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

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

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

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

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 и передайте её непосредственно в треньер без аргумента peft_config.

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

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

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

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

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

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

KTOTrainer полностью поддерживает обучение моделей «зрение-язык» (VLM). Чтобы обучить VLM, предоставьте набор данных с колонкой image (одно изображение на образец) или колонкой images (список изображений на образец). Подробнее об ожидаемой структуре набора данных см. в разделе Dataset Format — Vision Dataset.

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

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

KTOConfig(max_length=None, ...)

Используйте max_length только после того, как вы убедитесь, что усечение не удалит токены изображений для всего набора данных.

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

Мы предоставляем пример скрипта для обучения модели с использованием метода KTO. Скрипт доступен в trl/scripts/kto.py

Чтобы протестировать скрипт KTO на модели Qwen2 0.5B с использованием набора данных UltraFeedback, выполните следующую команду:

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 аналогичным образом при настройке предпочтений, полезно добавлять вспомогательную функцию потерь от балансировщика нагрузки к итоговой функции потерь.

Этот параметр включается установкой output_router_logits=True в конфигурации модели (например, 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 определяют веса, применяемые к потерям для желаемых/положительных и нежелательных/отрицательных примеров. По умолчанию оба равны 1. Однако, если одного из типов примеров больше, чем другого, следует увеличить вес менее распространенного типа так, чтобы соотношение (desirable_weight ×\times количество положительных) к (undesirable_weight ×\times количество отрицательных) находилось в диапазоне от 1:1 до 4:3.

KTOTrainer

класс trl.KTOTrainer

< >

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

Параметры

  • 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, то есть состояние модели до начала обучения KTO.
    • Если указан, эта модель используется непосредственно в качестве эталонной политики. Она не может быть PeftModel.
    • Если None, тренер автоматически использует начальную политику, соответствующую model, то есть состояние модели до начала обучения KTO.
  • args (KTOConfig, необязательный) — Конфигурация для этого тренера. Если None, используется конфигурация по умолчанию.
  • data_collator (DataCollator, необязательный) — Функция, используемая для формирования батча из списка элементов обработанного train_dataset или eval_dataset. По умолчанию используется DataCollatorForUnpairedPreference, если модель является языковой, и DataCollatorForVisionUnpairedPreference, если модель является мультимодальной (vision-language). Пользовательские collator'ы должны обрезать последовательности до добавления padding; trainer не применяет обрезку после collation.
  • train_dataset (Dataset или IterableDataset) — Набор данных для обучения. Этот trainer поддерживает unpaired preference тип. Формат образцов может быть следующим:
    • 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 для метода оптимизации Канемана-Тверски (KTO). Данный алгоритм был впервые предложен в статье KTO: Model Alignment as Prospect Theoretic Optimization. Этот класс является обёрткой вокруг класса Trainer и наследует все его атрибуты и методы.

Пример:

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

обучение

< >

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

KTOConfig

класс trl.KTOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = 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 = 'sequential'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024pad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: str = 'kto'beta: float = 0.1desirable_weight: float = 1.0undesirable_weight: float = 1.0activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512 )

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

  • model_init_kwargs (dict[str, Any], необязательный) — Параметры-ключи для from_pretrained, используемые, когда аргумент model в 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 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 обрезаются справа. Если None, обрезка не применяется.
  • 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 (str, необязательный, по умолчанию "kto") — Тип используемой функции потерь. Возможные значения:
    • "kto": функция потерь KTO из статьи KTO.
    • "apo_zero_unpaired": Непарный вариант функции потерь APO-zero из статьи APO.
  • beta (float, необязательный, по умолчанию 0.1) — Параметр, контролирующий отклонение от эталонной модели. Чем выше β, тем меньше отклонение от эталонной модели.
  • desirable_weight (float, необязательный, по умолчанию 1.0) — Потери желаемых пар взвешиваются этим коэффициентом, чтобы компенсировать неравное количество желаемых и нежелательных пар.
  • undesirable_weight (float, необязательный, по умолчанию 1.0) — Нежелательные потери взвешиваются этим коэффициентом, чтобы компенсировать неравное количество желательных и нежелательных пар.
  • 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.

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

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

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

Эти параметры имеют значения по умолчанию, отличные от 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-дополнение для каждого примера предварительно вычисляется относительно его соседей в батче с фиксированным порядком; любая другая стратегия нарушает эту пару.
Update on GitHub