TRL documentation

SFT Trainer

TRL

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

SFT Trainer

Обзор

TRL поддерживает SFT Trainer для обучения языковых моделей.

SFTTrainer не поддерживает нативно диффузионные модели, такие как DiffusionGemma, но его легко расширить для этого, см. пример SFT с блок-диффузией.

Метод постобучения был предложен Younes Belkada.

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

В этом примере показано, как обучить языковую модель с помощью SFTTrainer из TRL. Мы обучаем модель Qwen 3 0.6B на Capybara dataset — компактном и разнообразном наборе данных для многоходового диалога, предназначенном для оценки рассуждений и обобщения.

from trl import SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()

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

SFT поддерживает как датасеты для языкового моделирования, так и датасеты в формате «запрос-дополнение». SFTTrainer совместим с форматами как стандартных, так и диалоговых датасетов. При получении диалогового датасета тренер автоматически применяет к нему шаблон чата.

# Standard language modeling
{"text": "The sky is blue."}

# Conversational language modeling
{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}

# Standard prompt-completion
{"prompt": "The sky is",
 "completion": " blue."}

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

Если ваш набор данных не представлен в одном из этих форматов, вы можете предварительно обработать его, чтобы преобразовать в ожидаемый формат. Вот пример с набором данных FreedomIntelligence/medical-o1-reasoning-SFT:

from datasets import load_dataset

dataset = load_dataset("FreedomIntelligence/medical-o1-reasoning-SFT", "en")

def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["Question"]}],
        "completion": [
            {"role": "assistant", "content": f"<think>{example['Complex_CoT']}</think>{example['Response']}"}
        ],
    }

dataset = dataset.map(preprocess_function, remove_columns=["Question", "Response", "Complex_CoT"])
print(next(iter(dataset["train"])))

{
    "prompt": [
        {
            "content": "Given the symptoms of sudden weakness in the left arm and leg, recent long-distance travel, and the presence of swollen and tender right lower leg, what specific cardiac abnormality is most likely to be found upon further evaluation that could explain these findings?",
            "role": "user",
        }
    ],
    "completion": [
        {
            "content": "<think>Okay, let's see what's going on here. We've got sudden weakness [...] clicks into place!</think>The specific cardiac abnormality most likely to be found in [...] the presence of a PFO facilitating a paradoxical embolism.",
            "role": "assistant",
        }
    ],
}

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

Supervised Fine-Tuning (SFT) — это самый простой и наиболее часто используемый метод адаптации языковой модели к целевому набору данных. Модель обучается в полностью контролируемом режиме с использованием пар входных и выходных последовательностей. Цель состоит в минимизации отрицательного логарифма правдоподобия (NLL) целевой последовательности при условии заданного входа.

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

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

В процессе обучения каждый пример должен содержать поле text или пару (prompt, completion) в зависимости от формата набора данных. Подробнее об ожидаемых форматах см. в разделе Dataset formats. Класс SFTTrainer токенизирует каждый вход с помощью токенизатора модели. Если prompt и completion предоставлены отдельно, они объединяются перед токенизацией.

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

sft_figure

Потеря, используемая в SFT, — это токенная кросс-энтропийная потеря, определяемая как: $\mathcal{L}_{\text{SFT}}(\theta) = - \sum_{t=1}^{T} \log p_\theta(y_t \mid y_{<t}),$

где $y_t$ — целевой токен на шаге $t$ , а модель обучается предсказывать следующий токен на основе предыдущих. На практике токены отсечки (padding) маскируются при вычислении функции потерь.

Статья On the Generalization of SFT: A Reinforcement Learning Perspective with Reward Rectification предлагает альтернативную функцию потерь, называемую Dynamic Fine-Tuning (DFT), которая направлена на улучшение обобщения путём корректировки сигнала вознаграждения. Этот метод можно включить, установив loss_type="dft" в SFTConfig. Дополнительные сведения см. в Paper Index - Dynamic Fine-Tuning.

Сдвиг и маскировка меток

В процессе обучения функция потерь вычисляется с использованием сдвига на один токен: модель обучается предсказывать каждый токен в последовательности на основе всех предыдущих токенов. Конкретно, входная последовательность сдвигается на одну позицию вправо для формирования целевых меток. Токены заполнения (если они присутствуют) игнорируются при вычислении функции потерь путём применения индекса игнорирования (по умолчанию: -100) к соответствующим позициям. Это обеспечивает фокусировку функции потерь только на значимых, не являющихся заполнением токенах.

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

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

global_step: общее количество шагов оптимизатора, выполненных на данный момент.
epoch: текущий номер эпохи, основанный на итерации по набору данных.
num_tokens: общее количество обработанных на данный момент токенов.
loss: средняя потеря кросс-энтропии, вычисленная по немаскированным токенам в текущем интервале логирования.
entropy: средняя энтропия распределения токенов, предсказанного моделью, по немаскированным токенам.
aux_loss: вспомогательная функция потерь для балансировки нагрузки в модели Mixture-of-Experts, до её масштабирования коэффициентом router_aux_loss_coef и добавления к общей функции потерь. Записывается в журнал только в том случае, если модель является MoE и router_aux_loss_coef не равен нулю.
mean_token_accuracy: доля немаскированных токенов, для которых топ-1 предсказание модели совпадает с эталонным токеном.
learning_rate: текущая скорость обучения, которая может динамически изменяться при использовании планировщика.
grad_norm: L2-норма градиентов, вычисленная до обрезания градиентов.

Настройка

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

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

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

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

from trl import SFTConfig

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

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

Упаковка

SFTTrainer поддерживает упаковку примеров, при которой несколько примеров упаковываются в одну входную последовательность для повышения эффективности обучения. Чтобы включить упаковку, просто передайте packing=True в конструктор SFTConfig.

training_args = SFTConfig(packing=True)

Подробнее о упаковке см. Packing.

Обучение только на сообщениях ассистента

Чтобы обучать модель только на сообщениях ассистента, используйте диалоговый набор данных и установите assistant_only_loss=True в SFTConfig. Эта настройка гарантирует, что функция потерь вычисляется только для ответов ассистента, игнорируя сообщения пользователя или системы.

training_args = SFTConfig(assistant_only_loss=True)

train_on_assistant

Эта функциональность требует, чтобы шаблон чата содержал ключевые слова {% generation %} и {% endgeneration %}. Для известных семейств моделей (например, Qwen3) TRL автоматически корректирует шаблон, если задано assistant_only_loss=True. Полный список встроенных шаблонов обучения см. в разделе Chat Templates. Для других моделей убедитесь, что ваш шаблон чата содержит эти ключевые слова. Пример см. в HuggingFaceTB/SmolLM3-3B.

Для датасета изображений потеря только для ассистента требует transformers>=5.18.0 и диалогового датасета языкового моделирования.

Обучение только по завершении

Для обучения только на завершении используйте датасет prompt-completion. По умолчанию тренер вычисляет потерю только на токенах завершения, игнорируя токены промпта. Если вы хотите обучаться на полной последовательности, установите completion_only_loss=False в SFTConfig.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

# Load a prompt-completion dataset; loss is computed on the completion only by default
dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    args=SFTConfig(completion_only_loss=True),  # True by default for prompt-completion datasets
    train_dataset=dataset,
)
trainer.train()

train_on_completion

Обучение только на завершениях совместимо с обучением только на сообщениях ассистента. В этом случае используйте диалоговый набор данных prompt-completion и установите assistant_only_loss=True в SFTConfig.

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

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

from datasets import load_dataset
from trl import SFTTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

Вы также можете продолжить обучение вашей модели PeftModel. Для этого сначала загрузите PeftModel вне SFTTrainer и передайте её непосредственно в треньер без аргумента peft_config.

from datasets import load_dataset
from trl import SFTTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

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

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

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

Обучение с Unsloth

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

Пример обучения по инструкциям

Инструктивное обучение обучает базовую языковую модель следовать инструкциям пользователя и вести диалоги. Для этого требуется:

Шаблон чата: определяет, как структурировать диалоги в текстовые последовательности, включая маркеры ролей (user/assistant), специальные токены и границы реплик. Подробнее о шаблонах чата читайте в Chat templates.
Диалоговый набор данных: содержит пары «инструкция–ответ»

В этом примере показано, как преобразовать модель Qwen 3 0.6B Base в модель, следующую инструкциям, с использованием набора данных Capybara dataset и шаблона чата из HuggingFaceTB/SmolLM3-3B. SFT Trainer автоматически обрабатывает обновление токенизатора и конфигурацию специальных токенов.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen3-0.6B-Base",
    args=SFTConfig(
        output_dir="Qwen3-0.6B-Instruct",
        chat_template_path="HuggingFaceTB/SmolLM3-3B",
    ),
    train_dataset=load_dataset("trl-lib/Capybara", split="train"),
)
trainer.train()

Некоторые базовые модели, например от Qwen, имеют предопределённый шаблон чата в токенизаторе модели. В таких случаях применять clone_chat_template() не нужно, так как токенизатор уже обрабатывает форматирование. Однако необходимо привести EOS-токен в соответствие с шаблоном чата, чтобы ответы модели корректно завершались. В этих случаях укажите eos_token в SFTConfig; например, для Qwen/Qwen2.5-1.5B следует установить eos_token="<|im_end|>".

После обучения ваша модель теперь может выполнять инструкции и вести диалоги с помощью нового шаблона чата.

>>> from transformers import pipeline
>>> pipe = pipeline("text-generation", model="Qwen3-0.6B-Instruct/checkpoint-5000")
>>> prompt = "<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\n"
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
'<|im_start|>user\nWhat is the capital of France? Answer in one word.<|im_end|>\n<|im_start|>assistant\nThe capital of France is Paris.'

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

>>> prompt = [{"role": "user", "content": "What is the capital of France? Answer in one word."}]
>>> response = pipe(prompt)
>>> response[0]["generated_text"]
[{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'The capital of France is Paris.'}]

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

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

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

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

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

SFTTrainer полностью поддерживает обучение моделей Vision-Language (VLM). Чтобы обучить VLM, предоставьте датасет с колонкой image (одно изображение на образец) или колонкой images (список изображений на образец). Подробнее об ожидаемой структуре датасета см. в разделе Dataset Format — Vision Dataset. Примером такого датасета является LLaVA Instruct Mix.

from trl import SFTConfig, SFTTrainer
from datasets import load_dataset

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=SFTConfig(max_length=None),
    train_dataset=load_dataset("trl-lib/llava-instruct-mix", split="train"),
)
trainer.train()

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

SFTTrainer

класс trl.SFTTrainer

< source >

( model: str | PreTrainedModel | PeftModelargs: trl.trainer.sft_config.SFTConfig | transformers.training_args.TrainingArguments | 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_loss_func: collections.abc.Callable | 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)optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = Nonepreprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonequantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = Noneformatting_func: collections.abc.Callable[[dict], str] | 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. Поддерживаются только каузальные языковые модели.
args (SFTConfig, необязательный) — Конфигурация для этого тренера. Если None, используется конфигурация по умолчанию.
data_collator (DataCollator, необязательный) — Функция, используемая для формирования батча из списка элементов обработанного train_dataset или eval_dataset. По умолчанию используется DataCollatorForLanguageModeling, а если набор данных содержит изображения, то DataCollatorForVisionLanguageModeling.
train_dataset (Dataset или IterableDataset) — Набор данных для обучения. Этот trainer поддерживает как моделирование языка , так и заполнение по промпту . Формат образцов может быть следующим:
- Standard: каждая выборка содержит обычный текст.
- Диалоговый: каждая выборка содержит структурированные сообщения (например, роль и содержимое).
Тренер также поддерживает предтокенизированные наборы данных, которые распознаются по обязательному столбцу input_ids. Необязательный столбец labels (-100 для токенов, исключённых из функции потерь) используется как есть, если он присутствует; в противном случае метки формируются из необязательных столбцов assistant_masks / completion_mask (которые затем объединяются и удаляются, completion_mask — только при completion_only_loss=True), либо по умолчанию используется копия input_ids. Последовательности усекаются до max_length на этапе подготовки. При skip_prepare_dataset=True подготовка пропускается, и ожидается, что коллабор будет обрабатывать набор данных как есть.

Если train_dataset является IterableDataset (например, потоковым набором данных), то max_steps необходимо задать в аргументах обучения, поскольку его длину невозможно определить, а общее количество шагов обучения требуется для ограничения цикла обучения и настройки планировщика скорости обучения.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict или dict[str, Dataset | IterableDataset]) — Набор данных для оценки. Он должен соответствовать тем же требованиям, что и train_dataset.
processing_class (PreTrainedTokenizerBase, ProcessorMixin, необязательный) — Класс обработки, используемый для обработки данных. Если None, класс обработки загружается по имени модели с помощью from_pretrained. Токен отступов, tokenizer.pad_token, должен быть установлен. Если класс обработки не установил токен отступов, по умолчанию будет использован tokenizer.eos_token.
compute_loss_func (Callable, необязательный) — Функция, которая принимает выходные данные модели, метки и количество элементов во всей накопленной пачке (batch_size * gradient_accumulation_steps) и возвращает потерю. Это устаревший параметр, который будет удален в v2.0.0: вместо этого создайте подкласс SFTTrainer и переопределите compute_loss.
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.
optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], необязательный) — Кортеж, содержащий класс оптимизатора и именованные аргументы для его использования. Переопределяет optim и optim_args в args. Несовместим с аргументом optimizers .
В отличие от optimizers, этот аргумент позволяет избежать необходимости размещать параметры модели на соответствующих устройствах до инициализации Trainer.
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], необязательный) — Функция, которая предобрабатывает logits непосредственно перед их кэшированием на каждом шаге оценки. Она должна принимать два тензора — logits и labels — и возвращать обработанные logits в нужном виде. Изменения, внесённые этой функцией, будут отражены в предсказаниях, полученных в compute_metrics.
Обратите внимание, что метки (второй параметр) будут None, если в наборе данных их нет.
quantization_config (BitsAndBytesConfig, optional) — Конфигурация квантования, используемая при загрузке модели по идентификатору модели. Используйте в сочетании с peft_config для обучения QLoRA. Игнорируется, если модель уже инициализирована.
peft_config (PeftConfig, необязательный) — Конфигурация PEFT, используемая для обёртки модели. Если None, модель не оборачивается.
formatting_func (Callable, необязательный) — Функция форматирования, применяемая к набору данных перед токенизацией. Явное применение функции форматирования преобразует набор данных в тип language modeling.

Trainer для метода Supervised Fine-Tuning (SFT).

Этот класс является обёрткой над классом Trainer и наследует все его атрибуты и методы.

Пример:

>>> from trl import SFTTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("roneneldan/TinyStories", split="train[:1%]")

>>> trainer = SFTTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

обучение

< source >

Параметры

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

Возвращает

~trainer_utils.TrainOutput

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

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

save_model

< source >

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

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

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

push_to_hub

< source >

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

Параметры

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

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

SFTConfig

класс trl.SFTConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 2e-05lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonechat_template_path: str | None = Nonedataset_text_field: str = 'text'dataset_kwargs: dict[str, typing.Any] | str | None = Nonedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'shuffle_dataset: bool = Falsepacking: bool = Falsepacking_strategy: str = 'bfd'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'eval_packing: bool | None = Nonecompletion_only_loss: bool | None = Noneassistant_only_loss: bool = Falseloss_type: str = 'nll'activation_offloading: bool = Falsepad_token: str | None = None )

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

model_init_kwargs (dict[str, Any], необязательный) — Параметры-ключи для from_pretrained, используемые, когда аргумент model в SFTTrainer передан в виде строки. Значение 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.
chat_template_path (str, необязательный) — Если указано, задаёт шаблон чата для модели. Это может быть путь к токенизатору (локальная директория или модель на Hugging Face Hub) либо прямой путь к файлу шаблона Jinja. При использовании файла Jinja необходимо убедиться, что все специальные токены, упомянутые в шаблоне, добавлены в токенизатор, а слой эмбеддингов модели изменён в соответствии с этим.

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

dataset_text_field (str, необязательный, по умолчанию "text") — Имя столбца, содержащего текстовые данные в наборе данных.
dataset_kwargs (dict[str, Any], необязательный) — Словарь необязательных именованных аргументов для подготовки набора данных. Единственный поддерживаемый ключ — skip_prepare_dataset. Если набор данных содержит изображения, skip_prepare_dataset автоматически рассматривается как True независимо от переданного значения, поскольку предобработка выполняется на лету.
dataset_num_proc (int, необязательный) — Количество процессов, используемых для обработки набора данных.
eos_token (str, необязательный) — Токен, используемый для обозначения конца хода или последовательности. Если None, по умолчанию используется processing_class.eos_token.
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.
shuffle_dataset (bool, необязательный, по умолчанию False) — Следует ли перемешивать набор данных.
packing (bool, необязательный, по умолчанию False) — Определяет, следует ли объединять несколько последовательностей в блоки фиксированной длины для повышения вычислительной эффективности и сокращения количества заполнителей (padding). Для определения длины последовательности используется max_length.
packing_strategy (str, необязательный, по умолчанию "bfd") — Стратегия упаковки последовательностей. Может принимать значения "bfd" (best-fit decreasing, обрезает переполнение), "bfd_split" (best-fit decreasing, разделяет переполненные последовательности) или "wrapped" (агрессивная, разрезает посреди последовательности).
padding_free (bool, необязательный, по умолчанию False) — Определяет, следует ли выполнять прямые проходы без дополнения (padding), сжимая все последовательности в батче в одну непрерывную последовательность. Это снижает потребление памяти за счет устранения накладных расходов на padding. В настоящее время поддерживается только с FlashAttention 2 или 3, которые эффективно обрабатывают структуру сжатого батча. Если упаковка включена со стратегией "bfd", режим без padding активируется независимо от значения этого параметра.
pad_to_multiple_of (int или str, необязательный, по умолчанию "auto") — Если задано, последовательности будут дополнены до кратного этого значения. "auto" дополняет до кратного 128 на Neuron (AWS Trainium), который компилируется один раз для каждой формы входных данных, и не выполняет дополнения в других случаях.
eval_packing (bool, необязательный) — Определяет, следует ли упаковывать набор данных для оценки. Если None, используется то же значение, что и у packing.

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

completion_only_loss (bool, необязательный) — Определяет, вычислять ли потерю только для части последовательности, соответствующей ответу. Если установлено в True, потеря вычисляется только для ответа, что поддерживается только для датасетов типа prompt-completion. Если False, потеря вычисляется для всей последовательности. Если None (по умолчанию), поведение зависит от датасета: потеря вычисляется для ответа в датасетах типа prompt-completion и для полной последовательности в датасетах типа language modeling.
assistant_only_loss (bool, необязательный, по умолчанию False) — Определяет, следует ли вычислять потерю только для части последовательности, относящейся к ассистенту. Если установлено в True, потеря вычисляется только для ответов ассистента, что поддерживается только для диалоговых наборов данных. Если False, потеря вычисляется для всей последовательности.
loss_type (str, необязательный, по умолчанию "nll") — Тип функции потерь. Возможные значения:
- "nll": стандартная отрицательная логарифмическая правдоподобность.
- "dft": Dynamic Fine-Tuning, как описано в этой статье.
- "chunked_nll": устаревший псевдоним для "nll", который вычисляет потерю тем же способом. Будет удалён в v2.0.0.
activation_offloading (bool, необязательный, по умолчанию False) — Определяет, следует ли выгружать активации на CPU.

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

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

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

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

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

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

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

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

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

learning_rate: По умолчанию 2e-5, а не 5e-5.

Update on GitHub

←RLOO Интерфейс командной строки (CLI)→