TRL documentation

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

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 = 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 = 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