TRL documentation

Асинхронная дистилляция

You are viewing v1.18.1 version. A newer version v1.18.2 is available.
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Асинхронная дистилляция

Этот тренажёр требует vllm, transformers>=5.2.0 и kernels (при обучении FlashAttention загружается из Hub через него). Для распределённого обучения поддерживается только FSDP2 (DeepSpeed ZeRO не поддерживается).

В настоящее время vllm и transformers имеют конфликтующие ограничения зависимостей. Чтобы обойти это, сначала установите vLLM, затем принудительно установите transformers, а после добавьте kernels через extra TRL, который фиксирует версию, принимаемую transformers:

pip install vllm
pip install 'transformers>=5.2.0' --no-deps
pip install 'trl[kernels]'

Обзор

experimental.async_distillation.AsyncDistillationTrainer — это асинхронный аналог DistillationTrainer, построенный по образцу AsyncGRPOTrainer: фоновый рабочий процесс генерации создаёт собственные on-policy завершения студента и оценивает их с помощью учителя, в то время как обучение продолжается параллельно, а не чередуется между генерацией и обновлением градиентов. В отличие от синхронного тренера, учитель никогда не загружается локально — достаточно только URL-адреса сервера vLLM, поэтому учитель может работать на полностью отдельном от студента и тренера оборудовании или даже быть моделью значительно большего размера, чем могла бы поместиться рядом со студентом.

compute_loss минимизирует обобщённую дивергенцию Йенсена–Шеннона между распределениями токенов по позициям для ученика и учителя (beta=0.0 — прямая KL-дивергенция, beta=1.0 — обратная KL-дивергенция, промежуточные значения интерполируют между ними), тот же целевой функционал, что используют DistillationTrainer и ServerDistillationTrainer. Обучение всегда выполняется on-policy: ученик генерирует каждую завершённую последовательность, на которой обучается.

Мультиучительная on-policy дистилляция (MOPD)

MOPD не входит в состав статьи 2306.13649, на основе которой сформулирована основная цель данного тренера (она описывает синхронный сценарий с одним учителем); это отдельный метод, описанный в работе MOPD: Multi-Teacher On-Policy Distillation for Capability Integration in LLM Post-Training. Там MOPD является третьим из трех этапов — сначала общее SFT, затем независимая RL-обучение одного эксперта на каждый домен, после чего MOPD объединяет этих замороженных экспертов в одного студента. AsyncDistillationTrainer реализует только этот третий, объединяющий этап: доменные экспертные учителя должны уже существовать (например, быть обучены отдельно с помощью GRPOTrainer/RLOOTrainer) и обслуживаться по HTTP, прежде чем вы укажете на них teacher_server_urls. В самой статье для этапа 3 используется обратный KL (beta=1.0), а не значение по умолчанию этого тренера beta=0.0 (прямой KL).

teacher_server_urls принимает более одного элемента. При наличии одного элемента все образцы оцениваются этим единственным учителем (простая дистилляция on-policy). При нескольких элементах столбец teacher_id каждого обучающего образца определяет, какой учитель будет его оценивать, — например, запросы по математике направляются учителю-специалисту по математике, а запросы по коду — учителю-специалисту по коду, каждый из которых обслуживается независимо. Каждый образец направляется только на своего соответствующего учителя, усреднение или ансамблирование между учителями не применяются. Если у образца отсутствует или не сопоставлен teacher_id, возникает исключение, а не происходит молчаливого переключения на неверного учителя. См. examples/async_distillation_mopd/async_distillation_mopd.py для рабочего примера, объединяющего экспертов по математике, коду и следованию инструкциям, выпущенных вместе с Open-MOPD, в их общий SFT-чекпоинт, а также examples/async_distillation_mopd/launcher.py для запуска на 4 GPU одной командой Hugging Face Jobs.

Каждый учитель должен использовать тот же токенизатор, что и ученик. Завершения передаются учителям в виде сырых идентификаторов токенов, а идентификаторы кандидатов, которые учитель возвращает, напрямую индексируют собственный словарь ученика в compute_loss. Учителя из той же семейства моделей, что и ученик (как в примере MOPD, где ученик SmolLM3 формируется из экспертов SmolLM3, обученных из одной и той же контрольной точки), удовлетворяют этому условию; учитель с другим словарём обучает ученика на неверных токенах, что остаётся незамеченным, если только его словарь не больше словаря ученика.

Создание контрольных точек и возобновление: параметр ignore_data_skip по умолчанию установлен в True; цикл пропуска и повторного воспроизведения базового Trainer не применяется к живой очереди rollout. Вместо этого индекс первого промпта, по которому ещё не проводилась тренировка, сохраняется в rollout_state.json вместе с каждой контрольной точкой и восстанавливается при возобновлении, благодаря чему worker быстро перемотывает к этому промпту без повторного воспроизведения образцов. Это позиция обученных данных, а не генератора: worker опережает тренировку на глубину очереди rollout, и эти буферизованные образцы теряются при завершении запуска, поэтому возобновление с позиции генератора привело бы к пропуску промптов, которые были сгенерированы, но не использовались для обучения. Потоковые наборы данных (IterableDataset) нельзя перемотать; их worker при возобновлении начинает с промпта 0. При использовании FSDP с bf16=True (по умолчанию) или fp16=True файл model.safetensors записывается в этом типе данных, даже если основные веса имеют тип fp32, поэтому опубликованная контрольная точка имеет размер модели, используемой для обслуживания, а не вдвое больше; основные веса fp32 и состояние оптимизатора по-прежнему записываются в файлы для возобновления (pytorch_model_fsdp.bin, optimizer.bin), которые и читаются при возобновлении, поэтому процесс возобновления не затрагивается. Без FSDP контрольная точка также является файлом для возобновления, поэтому она сохраняет основной тип данных.

Чем отличается от DistillationTrainer

В DistillationTrainer учитель — это локально загруженная модель: генерация, прямой проход учителя и обновление градиентов выполняются последовательно в одном процессе. experimental.async_distillation.AsyncDistillationTrainer разделяет эти задачи так же, как AsyncGRPOTrainer разделяет rollout и обновление в GRPO:

  • Рабочий процесса rollout (фоновый процесс) — генерирует завершения с помощью vLLM-сервера ученика, отправляет полную последовательность обратно на /v1/completions разрешённого учителя с параметром prompt_logprobs для teacher-forced оценки (учитель не генерирует новые токены) и помещает готовые к обучению образцы в очередь.
  • Цикл обучения (основной процесс) — извлекает примеры из очереди, вычисляет обобщённую потерю JSD и обновляет веса ученика.

Поскольку оценка учителя выполняется по HTTP, а не через локальный прямой проход, передаётся только разреженный верхний k-срез его распределения (teacher_top_k), а не полное пространство словаря — см. документацию к параметрам beta и teacher_top_k в experimental.async_distillation.AsyncDistillationConfig, где точно указано, для каких кандидатов протокол гарантирует получение logprob от учителя в каждом режиме beta.

Каждые weight_sync_steps шагов обучения обновлённые веса студента передаются на его сервер vLLM через NCCL. Как и в случае с AsyncGRPOTrainer, генерация опережает обучение, поэтому образцы могут отражать слегка устаревшую политику; max_staleness определяет, на сколько обновлений весов образец может отставать, прежде чем быть отброшенным.

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

# train_async_distillation.py
from datasets import load_dataset
from trl.experimental.async_distillation import AsyncDistillationTrainer

if __name__ == "__main__":  # the rollout worker is a spawned process that re-imports this script
    dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

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

Сервер учителя, vLLM-сервер ученика и тренер должны работать на отдельных GPU. Оба представляют собой обычные экземпляры vllm serve, но требуют разных флагов: учитель используется только для оценки (--logprobs-mode processed_logprobs, чтобы teacher_temperature влияло на возвращаемые logprobs, и --max-logprobs -1, чтобы teacher_top_k могло превышать стандартное ограничение vLLM в 20), тогда как ученик используется только для генерации и требует включения передачи весов через NCCL, чтобы тренер мог передавать в него обновлённые веса. При оценке отправляется вся последовательность ученика, и учитель запрашивается для одного дополнительного токена, поэтому значение --max-model-len учителя (или его значение по умолчанию) должно быть больше, чем у ученика:

# Terminal 1: teacher server on GPU 0 (static, never updated)
CUDA_VISIBLE_DEVICES=0 vllm serve Qwen/Qwen2.5-1.5B-Instruct \
    --port 8001 \
    --logprobs-mode processed_logprobs \
    --max-logprobs -1
# Terminal 2: student's vLLM server on GPU 1 (dev mode + NCCL weight transfer are required)
CUDA_VISIBLE_DEVICES=1 VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen2.5-0.5B-Instruct \
    --port 8000 \
    --weight-transfer-config '{"backend":"nccl"}'
# Terminal 3: training on GPU 2
CUDA_VISIBLE_DEVICES=2 python train_async_distillation.py

LoRA

Передайте peft_config, чтобы обучить адаптер LoRA на студенте, а не на полной модели:

from peft import LoraConfig

trainer = AsyncDistillationTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    train_dataset=dataset,
    peft_config=LoraConfig(r=32, lora_alpha=64, target_modules="all-linear"),
)

Каждый синхронизационный цикл требует передачи обновлённой модели-ученика на её сервер. По умолчанию тренер объединяет адаптер с базовой моделью и отправляет полные объединённые веса, что составляет около 15 ГБ для модели 7B при каждой синхронизации. Запустите vLLM-сервер ученика с флагом --enable-lora, и он будет отправлять только адаптер, что составляет около 160 МБ при r=32:

CUDA_VISIBLE_DEVICES=1 VLLM_SERVER_DEV_MODE=1 VLLM_ALLOW_RUNTIME_LORA_UPDATING=1 vllm serve Qwen/Qwen2.5-0.5B-Instruct \
    --port 8000 \
    --weight-transfer-config '{"backend":"nccl"}' \
    --enable-lora \
    --max-lora-rank 32 \
    --max-loras 6

VLLM_ALLOW_RUNTIME_LORA_UPDATING=1 открывает эндпоинт, на который тренер отправляет каждый новый адаптер. Добавьте VLLM_WORKER_MULTIPROC_METHOD=spawn, если вы используете тензорное параллельное обслуживание, и в любом случае сохраняйте --weight-transfer-config: тренер выбирает режим синхронизации только при запуске, к этому моменту сервер уже запущен, а синхронизация с объединением весов является вариантом по умолчанию. Сервер учителя не затрагивается: он никогда не обновляется.

--max-lora-rank должен быть одним из 1, 8, 16, 32, 64, 128, 256, 320, 512. Он задает максимальный ранг, который сервер может обслуживать, а не ранг, который будет использоваться по умолчанию, поэтому адаптер с r=4 корректно работает при значении 8. --max-loras должен быть не менее max_staleness + 2: тренер регистрирует max_staleness + 1 версий адаптеров, чтобы роллаут, начатый при более старой политике, мог завершиться при ней, а не переключаться на новую в процессе генерации, а при каждой синхронизации загружается следующая версия до разгрузки самой старой. Тренер проверяет оба значения при запуске и сообщает, с какими параметрами нужно перезапустить сервер.

vLLM загружает адаптеры с диска, а не по сети, поэтому тренер записывает каждую версию в <output_dir>/.vllm_lora/ и передаёт серверу путь. Если сервер работает на другой машине, этот каталог должен находиться на файловой системе, доступной обоим узлам.

<output_dir>/.vllm_lora/ — это кэш для обслуживания, а не место, где хранится обученный адаптер. В нём содержатся только самые последние версии, причём каждая из них удаляется вскоре после того, как выходит из окна устаревания. Именно чекпоинты сохраняют обученный вами адаптер, поэтому не отключайте их: при save_strategy="no" многочасовой запуск завершится, не оставив после себя ничего. output_dir также должен быть доступен для чтения сервером и должен пережить завершение задачи, поэтому локальный временный каталог узла не подойдёт, даже если он позволил бы избежать синхронизации с медленной общей файловой системой.

Синхронизация адаптеров не всегда быстрее. При обслуживании LoRA-адаптера vLLM генерирует токены примерно в 1,33–1,39 раза медленнее, чем при обслуживании объединённых весов, а именно генерация обычно определяет общее время выполнения. Взамен вы получаете значительно более короткий перерыв при каждой синхронизации и использование около 1% пропускной способности канала синхронизации. Если узким местом является пропускная способность генерации, объединённая синхронизация часто остаётся лучшим выбором.

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

Rollout проходит через несколько этапов, прежде чем превратиться в градиент. Сначала рассмотрим эти этапы: от промпта до финального состава батча:

Dataset row = PROMPT (message list + optional `teacher_id`)
 └─ ROLLOUT            (1 prompt -> 1 student completion -> 1 teacher scoring call)
     ├─ generate       (student's vLLM /v1/completions, sampled)
     └─ score          (the routed teacher's /v1/completions with `prompt_logprobs`, teacher-forced)
         └─ SAMPLE     (prompt + completion + the teacher's sparse per-position distribution)

════════════ Trainer process boundary: `rollout_buffer` (mp.Queue) ════════════

         └─ SAMPLE (Pulled 1 at a time; dropped if staleness > `max_staleness`)
             └─ ROW            (Planner assigns it to one of `dp` rows, Σ Lᵢ²-balanced)
                 └─ MICRO-BATCH (`dp` rows, one per rank)
                     └─ PACKED ROW (1 concat sequence, `position_ids` reset per sample)
                         └─ FORWARD (`compute_loss`, bs=1, inter-rank padding stripped)
             └─ OPTIMIZER STEP (from `grad_accum` micro-batches)

Чтение сверху вниз:

  • rollout — это один промпт, сгенерированный и оценённый один раз. Группы не существует: в дистилляции нет базовой линии преимущества для вычисления между поколениями, поэтому промпт не повторяется, и один rollout даёт ровно один обучающий пример.
  • примером sample является это дополнение вместе с топ-teacher_top_k кандидатами учителя для каждой позиции дополнения. Именно это передаётся через границу процесса.
  • за пределами границы тренер распределяет образцы по строкам (по одной на каждый ранг DP), упаковывает каждую строку в одну конкатенированную последовательность и накапливает grad_accum микробатчи в один шаг оптимизатора.

Таким образом, мы разделяем наши метрики в зависимости от того, какой этап (или сущность) они описывают:

namespaceсущность, которую он считает
rollout/один цикл генерации и оценки: сколько времени он занял и насколько далеко продвинулся
completions/что студент (vLLM) сгенерировал для одного запроса
sample/представляет один пример обучения, такой, каким он поступает в очередь
batch/один микро-батч или один шаг оптимизатора (сформированный из одного или нескольких образцов)
perf/измеренные секунды и FLOPs

Всё, что измеряет сама функция потерь, логируется без префикса (jsd, entropy, teacher_entropy), а при MOPD — с детализацией по teacher/<teacher_id>/* — см. расхождение ниже.

Давайте также определим некоторые термины, чтобы метрики токенов были однозначными:

  • токены generated — это то, что сгенерировал ученик (completions/*).
  • К forwarded токенам относятся все токены, которые обрабатывает проход forward: промпт и сгенерированные токены.
  • Токены trained — это подмножество, по которому вычисляется loss, где completion_mask == 1. trained ≠ generated: позиция completion, для которой teacher не оценил ни одного кандидата, маскируется в расчёте расхождения, но всё равно передаётся дальше.

Метрики записываются в журнал один раз за окно логирования: всё, что было зафиксировано с момента предыдущей записи, то есть за последние logging_steps шагов оптимизатора. В пределах окна:

  • Среднее значение, измеряемое на каждый rollout, образец или вызов, например rollout/duration_s и rollout/score_s, усредняется по всем rollout'ам, образцам или вызовам в окне. Скорость, например rollout/generated_tokens_per_s, вычисляется как общее количество токенов, делённое на общее количество секунд.
  • В противном случае имя, последняя часть которого содержит слово count, суммируется: sample/dropped_stale_count — это количество выбросов с момента последнего логирования, а не с начала обучения.
  • Имя, последняя часть которого содержит слово max или min, например sample/staleness_max или completions/max_length, сохраняет максимальное или минимальное значение.
  • Любая другая метрика представляет собой среднее значение, записанное в окне.

Единицы:

  • _s: секунды.
  • tokens_per_s: токены в секунду.
  • _frac: доля от 0 до 1.
  • _per_step: величина за один шаг оптимизатора, усреднённая по шагам в окне.

Метрики, которые GRPOTrainer также записывает в журнал, сохраняют свои имена из GRPO (completions/mean_length, completions/clipped_ratio).

Как формируются номера пакетов

Строка — это то, что один DP-ранк прогоняет через сеть в одном микро-батче: несколько сэмплов, склеенных в одну последовательность, при этом position_ids сбрасываются на каждой границе сэмпла. Планировщик определяет, какие сэмплы попадут в какую строку (балансируя Σ Lᵢ², чтобы ни один ранк не отставал), а коллабор данных выполняет склейку.

Во всех наших метриках «шаг» всегда означает полный шаг оптимизатора, а не микро-батч. gradient_accumulation_steps микро-батчей образуют один шаг, и каждая метрика с суффиксом _per_step относится к шагу оптимизатора, что соответствует global_step, logging_steps и остальной терминологии Trainer. Если метрика относится к микро-батчу, это прямо указано (batch/microbatches_per_step), либо это величина на строку (batch/row_*, batch/samples_per_row).

Следовательно, на каждом шаге используется фиксированное количество row-slots:

row-slots per step = gradient_accumulation_steps x world_size

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

sample                                     sample/forwarded_tokens_mean
  └─ packed into a ROW                     batch/samples_per_row, batch/row_tokens_mean
      └─ one row per DP rank               = one micro-batch
          └─ gradient_accumulation_steps micro-batches = one STEP
                                           batch/samples_per_step, batch/forwarded_tokens_per_step

Таким образом, batch/samples_per_step ≈ row-slots x batch/samples_per_row, и аналогично для токенов. Обе стороны совпадают только с точностью до вариации между микробатчами внутри шага — метрики на шаг являются суммами, а метрики на строку — средними значениями — поэтому ожидайте расхождение в доли процента, а не точное совпадение.

batch/row_fill_frac — это метрика, за которой стоит следить, когда образцы длинные: образец на 10k токенов плохо укладывается в бюджет 32k (три помещаются, четыре — никогда, поэтому упаковщик часто получает два, и строка заполняется примерно на 77%), тогда как образцы на 1k токенов укладываются в него почти идеально. Это квантование, а не ошибка, и token_budget — это рычаг управления, с учётом того, что внимание имеет сложность O(L²) на последовательность, поэтому более полная строка из длинных последовательностей не увеличивает потребление памяти линейно.

Очередь развёртывания

Рабочий процесс отправляет оценённые образцы в очередь, а тренер извлекает их из неё. Четыре метрики описывают эту единственную очередь и отвечают на разные вопросы:

метрикавопрос
rollout/queue_sizeсколько образцов сейчас ожидают
sample/time_in_queue_sкак долго один образец находился там до того, как на нём началась тренировка, — вторая половина его «неполитичности»
perf/rollout_wait_sкак долго обучение оставалось заблокированным, потому что очередь была пустой
rollout/backpressure_sсколько времени генерация (worker) ждала, так как опережала обучение на max_staleness шагов

Последние две метрики (perf/rollout_wait_s и rollout/backpressure_s) являются зеркальными отражениями. Их совместное чтение вместе с размером очереди позволяет определить, какая сторона является узким местом:

  • Очередь почти пуста, perf/rollout_wait_s высокий → generation-bound. Тренеру не хватает данных; проверьте rollout/generated_tokens_per_s, rollout/concurrency и rollout/score_s.
  • очередь, содержащая примерно max_staleness шагов токенов, rollout/backpressure_s высокий → ограничение со стороны тренера. Генерация задерживается, а sample/staleness_mean находится вблизи своего предела.
  • оба значения высокие → само ограничение max_staleness слишком строгое: запущенные rollout'ы заполняют его до того, как их образцы попадут в очередь, поэтому тренер ждёт, пока генерация будет приостановлена. Увеличьте max_staleness.
  • оба близки к нулю → сбалансировано!

Завершения

Completion — это то, что сервер vLLM студента сгенерировал для одного запроса.

метриказначение
completions/mean_lengthсгенерированные токены за один прогон
completions/min_length, completions/max_lengthсамое короткое и самое длинное завершение в окне
completions/clipped_ratioдоля завершений, которые не закончились на EOS, то есть были обрезаны по max_completion_length
completions/mean_terminated_length, completions/min_terminated_length, completions/max_terminated_lengthодинаковой длины, по завершённым последовательностям, которые закончились на EOS

Развёртывания

Rollout — это один промпт, пропущенный через весь процесс: сгенерированный студентом, а затем пропущенный через учителя с принудительным обучением (teacher-forcing). Поскольку вызов учителя находится на критическом пути каждого rollout (в отличие от GRPO, где оценка выполняется в отдельном цикле по завершённым группам), медленный учитель напрямую отражается на rollout/duration_s.

метриказначение
rollout/duration_sвремя реального выполнения одного rollout, от диспетчеризации до оцененного образца: генерация и вызов учителя
rollout/score_sиз этого, время, которое занял вызов /v1/completions со стороны учителя
teacher/<id>/score_sТолько MOPD: то же самое, но для каждого учителя отдельно. Один медленный эксперт ограничивает только те rollout-процессы, которые направляются к нему, что усреднённое значение в смешанном режиме скрывает
rollout/generated_tokens_per_sпропускная способность генерации за последний интервал (оконная), поэтому задержка отображается
rollout/concurrencyrollouts в процессе выполнения, то есть генерируемые или оцениваемые
rollout/vllm_retry_countповторные запросы к vLLM, направляемые либо на сервер студента, либо на сервер учителя. В противном случае деградировавший сервер выглядит как необъяснимая медлительность. Этот раздел находится здесь, а не в completions/, поскольку он учитывает запросы к серверу, а не сгенерированный текст
rollout/backpressure_sнасколько долго генерация ждала, так как была на max_staleness шагов впереди. См. очередь rollout
rollout/queue_sizeобразцы с оценкой, ожидающие в очереди развёртывания, измеренные в точке, где тренер извлекает их. См. очередь развёртывания

Образцы, поступающие из очереди

Каждая выборка представляет собой один RolloutSample: промпт, ответ студента и разреженная оценка учителя для него. Воркер помещает их в rollout_buffer; всё, что описано ниже, измеряется на стороне тренера, когда он извлекает их для обучения.

метриказначение
sample/forwarded_tokens_mean, sample/forwarded_tokens_maxтокены в одном образце: промпт + сгенерированный текст. Упаковка — это задача на уровне строк, см. batch/row_*
sample/trained_tokens_meanиз них, по каким именно вычисляется функция потерь
sample/time_in_queue_sсколько времени этот пример находился в этой очереди перед обучением. Не то же самое, что perf/rollout_wait_s — см. очередь rollout
sample/staleness_mean, sample/staleness_maxнасколько устарела версия политики относительно данных. jsd показывает эффект отклонения от текущей политики на потерю; это указывает на причину
sample/dropped_stale_countотброшено образцов из-за превышения max_staleness

Пакеты

Один микро-батч — это world_size строк (помните, что упаковка сворачивает всё в одну последовательность), по одному на каждый ранг DP, так что ранг i выполняет прямой проход по строке i. gradient_accumulation_steps таких микро-батчей образуют один шаг оптимизатора. Таким образом, один шаг охватывает в общей сложности gradient_accumulation_steps × world_size строк. Каждая метрика с суффиксом _per_step ниже представляет собой сумму по всему шагу и по всем рангам; метрики batch/row_* являются средними по строкам.

метриказначение
batch/forwarded_tokens_per_step, batch/trained_tokens_per_stepтокенов за один шаг оптимизатора, переданных и обученных соответственно
batch/samples_per_stepобучающих примеров на шаг оптимизатора
batch/microbatches_per_stepподсчитаны, а не прочитаны из конфигурации
batch/masked_token_fracтокены, переданные вперёд, для которых completion_mask == 0 — доля forward-прохода, не дающая градиента
batch/samples_per_row, batch/row_tokens_mean, batch/row_tokens_maxнасколько плотно планировщик заполнил строку каждого ранга
batch/row_fill_fracrow tokens против token_budget. Низкое значение означает, что бюджет не используется
batch/row_imbalancemax Σ Lᵢ² / mean Σ Lᵢ² по строкам. Сложность Attention составляет O(L²), поэтому это позволяет предсказать, какой ранг задерживает all-reduce градиентов. Значение 1.0 означает идеальное распределение
batch/pad_fracмежранговая отсечка. Затрачивает только байты для широковещательной передачи; удаляется перед прямой
batch/dropped_oversize_countобразцы отброшены из-за превышения token_budget

Расхождение

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

метриказначение
jsdобобщённая JSD, которую минимизирует функция потерь, при заданном beta. Снижение значения означает, что распределение ученика сходится к распределению учителя
entropyсобственная предсказательная энтропия студента. Схлопывание здесь при снижении jsd означает, что студент сужает распределение, а не учится
teacher_entropyэнтропия учителя по кандидатам, которые он сообщил. Значение ограничено снизу истинным значением, так как по каналу передаются только teacher_top_k кандидатов
teacher/<id>/jsdТолько MOPD: jsd ограничивается токенами, оцененными учителем. Учителя в разных доменах могут расходиться с очень разной скоростью, что смешанный jsd усредняет
teacher/<id>/entropyТолько MOPD: тот же самый разбор teacher_entropy
teacher/<id>/token_fracТолько MOPD: доля оценённых токенов, которые взял учитель. Косой роутинг в остальном невидим: учитель, которому не хватает строк, всё равно отчитывается о здоровом teacher/<id>/jsd
aux_lossпотери балансировки нагрузки роутера MoE на микро-батч, усреднённые по рангам, записываемые в журнал, когда модель возвращает логиты роутера и router_aux_loss_coef не равен 0. В отличие от строк выше, это не усреднение на токен

Не существует энтропии entropy для каждого отдельного учителя: энтропия ученика является свойством его собственной политики, а не того, какой учитель оценил образец, поэтому смешанная метрика уже покрывает этот случай.

Производительность

Throughput измеряет количество токенов, которые тренер обрабатывает в секунду. Model FLOPs Utilization (MFU) оценивает процент теоретической вычислительной мощности устройств обучения, используемой для прямого и обратного проходов модели. Мощность, учитываемая при этой оценке, зависит от аппаратного обеспечения и точности обучения.

Throughput и MFU сообщаются на двух временных основаниях:

  • fwd_bwd_ измеряет производительность на этапах прямого и обратного проходов.
  • wall_clock_ измеряет производительность за полный шаг оптимизатора, включая обновления оптимизатора, синхронизацию весов и время, затраченное на ожидание роллаутов.

Эта разница позволяет отделить вычислительную производительность от затрат на ожидание и координацию. Оба показателя MFU описывают только устройства обучения: они не включают вычислительные мощности или аппаратные возможности внешних серверов rollout или teacher. Wall-clock MFU отражает время, которое тринер тратит на ожидание этих сервисов, а не их собственную загрузку.

MFU отображается только в том случае, если для локального устройства обучения известна пиковая вычислительная мощность при выбранной точности, а оценка FLOPs поддерживает архитектуру модели (например, Llama, Qwen2, Qwen3, Qwen3-MoE или Qwen3-VL). В противном случае MFU не выводится; обучение продолжается, а метрики пропускной способности и времени остаются доступными.

метриказначение
perf/step_swall time между шагами оптимизатора: включает вычисления, оптимизатор, синхронизацию весов и ожидание в очереди
perf/fwd_bwd_sforward + backward, суммированные по микробатчам шага. Это знаменатель каждого метрики fwd_bwd_ ниже
perf/fwd_sforward-часть. fwd_s / fwd_bwd_s около 1/3 — это обычное соотношение; более высокое значение означает, что backward-проход дёшев или за recompute платят на forward-проходе
perf/optimizer_soptimizer.step()
perf/rollout_wait_sкак долго тренер находился в заблокированном состоянии из-за пустой очереди. См. очередь rollout
perf/weight_sync_sполная синхронизация, плюс _pause_s (ожидание vLLM), _barrier_s (рассинхронизация рангов) и _transfer_s (передача байтов)
perf/fwd_bwd_forwarded_tokens_per_s, perf/wall_clock_forwarded_tokens_per_sтокенов, переданных вперёд, в секунду на каждой основе
perf/wall_clock_trained_tokens_per_sтак же, но учитывающие только те токены, которые увидела функция потерь
perf/fwd_bwd_mfu, perf/wall_clock_mfuиспользование FLOPs модели на каждой основе

Философия проектирования

Этот тренажер намеренно поддерживается в минимальном виде и не предназначен для превращения в универсальное решение. Если вам требуется функция, которая не поддерживается, мы рекомендуем клонировать репозиторий и адаптировать тренажер под ваши нужды напрямую. Новые функции будут рассматриваться только при наличии значительного спроса со стороны сообщества.

AsyncDistillationConfig

класс trl.experimental.async_distillation.AsyncDistillationConfig

< >

( 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 | None = Nonegradient_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 = 1logging_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 = Truerestore_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 = Nonedtype: str = 'float32'trust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonemax_completion_length: int = 2048temperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonerepetition_penalty: float = 1.0chat_template_kwargs: dict | str | None = Nonevllm_server_base_url: str = 'http://localhost:8000'vllm_server_timeout: float = 1800.0teacher_server_urls: dict[str, str] | str | None = Nonebeta: float = 0.0teacher_temperature: float = 1.0teacher_top_k: int = 8add_tail_bucket: bool = Truetoken_budget: int | None = Nonemax_concurrent_rollouts: int = 512max_staleness: int = 4weight_sync_steps: int = 1rollout_worker_timeout: float = 300.0log_completions: bool = Falselog_completions_steps: int = 100num_completions_to_print: int | None = None )

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

  • model_init_kwargs (dict[str, Any] или str, необязательный) — Параметры с ключами для from_pretrained, используемые при создании экземпляра модели-студента по пути. Значение revision также используется при загрузке класса обработки.
  • dtype (str, необязательный, по умолчанию "float32") — Тип данных для загрузки модели-ученика, один из "auto", "bfloat16", "float16" или "float32". По умолчанию "float32" , так как рассогласование между обучением и инференсом, на которое ориентируются асинхронные тренажерыDefeating the Training-Inference Mismatch via FP16) чувствительно к собственной точности тренажера. Чтобы закрыть этот разрыв от начала до конца, также необходимо запускать vLLM-сервер ученика с тем же типом данных (vllm serve --dtype). A dtype в model_init_kwargs имеет приоритет. Серверы-учителя не затрагиваются: они никогда не обновляются.

    Это определяет только dtype, в котором загружаются веса. При использовании FSDP с смешанной точностью (по умолчанию bf16=True) accelerate повышает точность каждого обучаемого параметра до fp32 перед шардированием, поэтому мастер-веса и состояние оптимизатора остаются в fp32 независимо от значения dtype, тогда как прямой и обратный проходы выполняются в bf16 или fp16. Чекпоинты записываются в этом dtype смешанной точности, а не в fp32. Без FSDP повышение точности не происходит: dtype="bfloat16" в сочетании с bf16=True сохраняет веса и состояния оптимизатора в bf16, что соответствует обучению в чистом bf16.

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

Параметры, управляющие генерацией

  • max_completion_length (int, необязательный, по умолчанию 2048) — Максимальное количество токенов, генерируемых для каждого завершения.
  • temperature (float, необязательный, по умолчанию 1.0) — Температура для выборки завершений студента, сгенерированных по его собственной политике.
  • top_p (float, необязательный, по умолчанию 1.0) — Параметр top-p (nucleus) выборки для генерации on-policy.
  • top_k (int, необязательный, по умолчанию 0) — Параметр top-k выборки для генерации on-policy. 0 отключает top-k фильтрацию.
  • min_p (float, необязательный) — Минимальная вероятность токена, которая масштабируется вероятностью наиболее вероятного токена. Значение должно находиться в диапазоне от 0.0 до 1.0. Типичные значения лежат в диапазоне 0.01-0.2.
  • repetition_penalty (float, необязательный, по умолчанию 1.0) — Число с плавающей точкой, которое штрафует новые токены в зависимости от того, встречаются ли они в исходном запросе и в уже сгенерированном тексте. Значения > 1.0 побуждают модель использовать новые токены, а значения < 1.0 — повторять токены.
  • chat_template_kwargs (dict[str, Any], необязательный) — Дополнительные именованные аргументы для передачи в функцию apply_chat_template при генерации ответов.

Параметры, управляющие серверами vLLM

  • vllm_server_base_url (str, необязательный, по умолчанию "http --//localhost:8000"): Базовый URL vLLM-сервера студента, используемый как для генерации, так и для потоковой передачи обновлений весов.
  • vllm_server_timeout (float, необязательный, по умолчанию 1800.0) — Таймаут в секундах для вызовов серверов vLLM: ожидание готовности сервера студента при запуске, каждый запрос на генерацию или оценку, а также каждый вызов синхронизации весов. Ожидание сервера и вызовы синхронизации весов выбрасывают исключение при истечении таймаута; запрос на генерацию или оценку, для которого истек таймаут, повторяется.
  • teacher_server_urls (dict[str, str], необязательный, по умолчанию {"default" -- "http://localhost:8001"}): Сервер(ы) vLLM для teacher-моделей, каждый из которых запускается с флагом vllm serve <teacher-model> --logprobs-mode processed_logprobs --max-logprobs -1. Каждый teacher статичен: этот trainer никогда не транслирует обновления весов ни одному из них, поэтому teacher не требует ни VLLM_SERVER_DEV_MODE, ни backend для передачи весов, а только эти два флага, которые обеспечивают точность оценки (см. teacher_temperature и teacher_top_k). Каждый teacher должен использовать тот же токенизатор, что и student: завершения отправляются в виде сырых идентификаторов токенов, а идентификаторы, которые teacher возвращает, используются напрямую для индексации собственного словаря student в compute_loss. Teacher с другим словарем будет обучаться по неверным токенам, причем незаметно, если его словарь не больше словаря student. Оценка выполняется как teacher-forced запрос по собственным токенам завершения student (max_tokens=1, prompt_logprobs=teacher_top_k, temperature=teacher_temperature), тот же запрос, который get_sequence_logprobs() отправляет для синхронных server-teacher trainers. Из-за этого одноразового токена teacher требует --max-model-len больше, чем у student, иначе самые длинные завершения не смогут быть оценены. Одна запись оценивает все образцы (обычная одно-teacher on-policy дистилляция, значение по умолчанию). Несколько записей включают MOPD (много-teacher on-policy дистилляция, см. MOPD): столбец teacher_id каждой строки обучения выбирает, какая запись ее оценивает, например {"math": "http://localhost:8002", "code": "http://localhost:8003"} с teacher_id равным "math" или "code" для каждой строки.

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

  • beta (float, необязательный, по умолчанию 0.0) — Коэффициент интерполяции для обобщенного расхождения Дженсена–Шаннона. 0.0 соответствует прямому KL (стремление к среднему), 1.0 — обратному KL (стремление к моде), а промежуточные значения обеспечивают интерполяцию, следуя той же формулировке обобщенного JSD, которую внутренне вычисляет DistillationTrainer. Подмножество, на котором вычисляется расхождение, зависит от режима, что отражает поведение ServerDistillationTrainer: при beta=0.0 используется полное подмножество шириной teacher_top_k, сообщаемое учителем (плюс хвостовая корзина), поскольку взвешивание прямого KL именно и обеспечивает это подмножество. При beta != 0.0 подмножество сужается до двух кандидатов — токена top-1 самого учителя и фактического/реализованного токена завершения — поскольку именно для этих двух токен-идентификаторов протокол передачи гарантирует наличие лог-вероятности от учителя без передачи более широкого (или полного) словаря; любое более широкое подмножество было бы лишь вероятностным приближением покрытия собственных вероятных токенов студента, а не гарантией.
  • teacher_temperature (float, необязательный, по умолчанию 1.0) — Температура softmax для расхождения, применяемая к обеим сторонам: передается учителю, чтобы vLLM вычислял его logprobs при этой температуре на стороне сервера (точно, а не путем масштабирования на клиенте), и применяется к собственным логитам студента в compute_loss, повторяя единственный параметр temperature в ServerDistillationTrainer. Не связан с temperature, который управляет только тем, как студент генерирует свои завершения. Сервер учителя должен работать с флагом --logprobs-mode processed_logprobs, чтобы этот параметр вообще повлиял на возвращаемые logprobs; без него учитель молча возвращает raw logprobs, и настройка затрагивает только сторону студента.
  • teacher_top_k (int, необязательный, по умолчанию 8) — Количество токенов-кандидатов на каждую позицию, запрашиваемых у teacher через prompt_logprobs. Для приближения распределения teacher используются только эти кандидаты (а также реализованный токен, который vLLM всегда сообщает, даже если он не входит в top-k, и хвостовой бакет, захватывающий оставшуюся вероятность, см. add_tail_bucket); полная лексика никогда не передаётся по HTTP. Сторона student в расчёте дивергенции является точной (вычисляется локально, без приближения), поскольку student — это обучаемая модель, и её полные логиты уже доступны в compute_loss. Значение 8 — лёгкий дефолт для smoke-тестов; в production-настройках on-policy-distillation в смежных RL-фреймворках используется разреженная поддержка teacher примерно в том же диапазоне (в miles по умолчанию 16, в EasyOPD — 64), поэтому при реальном обучении разумно увеличить это значение до 16–64. Любое значение выше 20 требует, чтобы сервер teacher был запущен с флагом --max-logprobs -1, который снимает дефолтный лимит vLLM на количество logprob на токен.
  • add_tail_bucket (bool, необязательный, по умолчанию True) — Определяет, следует ли добавлять хвостовое ведро, представляющее оставшуюся вероятность за пределами teacher_top_k, чтобы избежать тривиально малой дивергенции, когда teacher_top_k мало.
  • token_budget (int, необязательный) — Максимальное количество реальных токенов, упакованных в одну строку (один проход вперёд для ранга DP). TokenBudgetBatcher формирует сбалансированные по Σ Lᵢ² микробатчи, строки которых укладываются в этот бюджет, ограничивая пиковое потребление памяти независимо от количества образцов (число образцов в строке становится динамическим). Если None (по умолчанию), значение устанавливается равным max_model_len сервера vLLM для student (запрашивается при начале обучения) — это верхняя граница для длины prompt + completion, поэтому ни один образец rollout не может превысить бюджет. Образец длиннее token_budget не помещается ни в одну строку и отбрасывается с предупреждением, учитывается как batch/dropped_oversize_count.

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

  • max_concurrent_rollouts (int, необязательный, по умолчанию 512) — Максимальное количество rollouts, одновременно обрабатываемых серверами vLLM студента и учителей, в процессе генерации или оценки.
  • max_staleness (int, необязательный, по умолчанию 4) — Максимальное количество шагов обновления весов, на которые образец rollout может отставать от текущей версии модели, прежде чем быть отброшенным. Генерация ограничена этим значением: rollout запускается только тогда, когда количество токенов в очереди и в процессе обработки укладывается в объём, который тренер потребляет за max(max_staleness, 1) шагов.
  • weight_sync_steps (int, необязательный, по умолчанию 1) — Количество шагов обучения между синхронизациями весов с vLLM-сервером студента.
  • rollout_worker_timeout (float, необязательный, по умолчанию 300.0) — Количество секунд с момента последнего сигнала о жизни (heartbeat) от rollout-воркера, после которых тренер считает его зависшим и прерывает работу.

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

  • log_completions (bool, необязательный, по умолчанию False) — Следует ли логировать выборку пар (prompt, completion) каждые log_completions_steps оценённых образцов.
  • log_completions_steps (int, необязательный, по умолчанию 100) — Количество оцененных образцов между записями в журнал завершений. Используется только если log_completions равно True. Считается в образцах, оцененных рабочим процессом rollout, а не в шагах оптимизатора: рабочий процесс выполняется в отдельном процессе от тренажера и не имеет доступа к self.state.global_step.
  • num_completions_to_print (int, необязательный) — Количество завершений, которые нужно вывести с помощью rich. Если None, в журнал записываются все завершения.

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

Этот класс содержит только параметры, специфичные для асинхронной on-policy дистилляции. Полный список аргументов обучения см. в документации TrainingArguments. Обратите внимание, что значения по умолчанию в этом классе могут отличаться от значений в TrainingArguments. Его структура повторяет AsyncGRPOConfig (асинхронный конвейер, сервер vLLM, поля для логирования совпадают), при этом поля clipping/group из GRPO заменены полями потерь teacher-distillation, описанными ниже.

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

  • logging_steps: по умолчанию 1, а не 500.
  • gradient_checkpointing: по умолчанию True, а не False.
  • bf16: по умолчанию True, если не задан fp16, а не False.
  • learning_rate: по умолчанию 1e-6, а не 5e-5.
  • ignore_data_skip: по умолчанию True, а не False; цикл пропуска и повторного воспроизведения базового Trainer не применяется к асинхронной очереди rollout.

AsyncDistillationTrainer

класс trl.experimental.async_distillation.AsyncDistillationTrainer

< >

( model: str | PreTrainedModelargs: trl.experimental.async_distillation.async_distillation_config.AsyncDistillationConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)peft_config: PeftConfig | None = None )

Параметры

  • model (str или PreTrainedModel) — Студентская модель, подлежащая обучению. Может быть:
    • Строка, являющаяся model id предобученной модели, размещённой в репозитории моделей на huggingface.co, или путь к directory, содержащему веса модели, сохранённые с помощью save_pretrained. Загружается с помощью from_pretrained.
    • Объект PreTrainedModel. Его реализация внимания переключается на бэкенд FlashAttention тренера для обучения без отступов.

    Имя модели из конфигурации используется для идентификации ученической модели на её сервере vLLM.

  • args (experimental.async_distillation.AsyncDistillationConfig, необязательный) — Конфигурация для этого тренера. Если None, используется конфигурация по умолчанию.
  • train_dataset (Dataset или IterableDataset) — набор данных для обучения. Должен содержать столбец "prompt" (формат conversational). Любые дополнительные столбцы игнорируются.
  • processing_class (PreTrainedTokenizerBase, необязательный) — Класс обработки, используемый для обработки данных. Если None, он загружается по имени модели с помощью from_pretrained. Если у него нет токена отбивки, используется tokenizer.eos_token.
  • callbacks (список TrainerCallback, необязательный) — Список колбэков для настройки цикла обучения, добавляемых к стандартным колбэкам (см. здесь).
  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], необязательный, по умолчанию (None, None)) — Кортеж, содержащий оптимизатор и планировщик, которые следует использовать. По умолчанию используются AdamW и линейное расписание, управляемое параметром args.
  • peft_config (PeftConfig, необязательный) — Конфигурация PEFT, используемая для обёртки модели. Если None, модель не оборачивается. Если сервер vLLM студента был запущен с --enable-lora, адаптер LoRA синхронизируется с ним как адаптер, а не как объединённые веса; см. раздел LoRA в документации AsyncDistillation.

Асинхронный аналог DistillationTrainer, спроектированный по образцу AsyncGRPOTrainer: фоновый worker для rollout генерирует on-policy завершения студента и оценивает их по отношению к teacher-серверу, пока обучение продолжается параллельно, отделяя процесс rollout от цикла обновления градиентов. Если в GRPO обрезанная функция потерь policy-gradient читает групповое относительное преимущество, то compute_loss этого тренера читает разреженное teacher-распределение для каждой позиции и минимизирует обобщенную JSD по отношению к нему (см. AsyncDistillationConfig.beta), всегда в on-policy режиме: студент генерирует каждое завершение, на котором обучается.

В отличие от синхронного DistillationTrainer, этот тренер поддерживает только оценку по учителю, работающему через HTTP (внешний сервер vLLM). Локальный (внутрипроцессный, на GPU) прямой проход учителя не может выполняться в дочернем процессе, запущенном воркером rollout с отключенным CUDA, так же, как функции вознаграждения в GRPO, и вместо этого должен выполняться в основном процессе обучения; этот путь пока не реализован.

Пример:

>>> from trl.experimental.async_distillation import AsyncDistillationTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

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