TRL documentation

Pelatih Distilasi

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Pelatih Distilasi

model badge

Ikhtisar

Distillation Trainer mengimplementasikan distilasi pengetahuan on-policy sebagaimana dijelaskan dalam On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes oleh Rishabh Agarwal, Nino Vieillard, Yongchao Zhou, Piotr Stanczyk, Sabela Ramos, Matthieu Geist, dan Olivier Bachem.

Abstrak dari makalah tersebut adalah sebagai berikut:

Knowledge distillation (KD) banyak digunakan untuk mengompresi model guru guna mengurangi biaya inferensi dan jejak memorinya, dengan melatih model siswa yang lebih kecil. Namun, metode KD saat ini untuk model sekuens auto-regresif mengalami ketidakcocokan distribusi antara sekuens output yang dilihat selama pelatihan dan yang dihasilkan oleh siswa selama inferensi. Untuk mengatasi masalah ini, kami memperkenalkan Generalized Knowledge Distillation (GKD). Alih-alih hanya mengandalkan set sekuens output yang tetap, GKD melatih siswa pada sekuens output yang dihasilkan sendiri oleh siswa dengan memanfaatkan umpan balik dari guru pada sekuens tersebut. Berbeda dengan pendekatan KD yang diawasi, GKD juga menawarkan fleksibilitas untuk menggunakan fungsi loss alternatif antara siswa dan guru, yang dapat berguna ketika siswa tidak memiliki ekspresivitas untuk meniru distribusi guru.

DistillationTrainer melatih model student yang lebih kecil agar sesuai dengan distribusi next-token dari teacher pada generasi on-policy milik student itu sendiri. Ia menghasilkan kelengkapan (completions) student secara on-policy (opsional dengan dukungan vLLM) dan mencocokkan teacher pada distribusi next-token lengkapnya menggunakan kerugian (loss) Jensen-Shannon divergence yang di-chunk secara hemat memori, sehingga distribusi padat dari teacher tidak pernah dimaterialisasi secara penuh.

Trainer ini disumbangkan oleh Carlos Miguel Patiño.

Untuk padanan asinkron yang memisahkan generasi dari pelatihan dan menilai terhadap guru yang disajikan melalui HTTP alih-alih langkah maju lokal, lihat AsyncDistillationTrainer.

Mulai cepat

Contoh ini menunjukkan cara melatih model menggunakan metode distilasi. Kami mendistilasi model Qwen 2.5 0.5B Instruct dari guru Qwen 2.5 1.5B Instruct pada prompt dari dataset prompt UltraFeedback. Anda dapat melihat data dalam dataset di sini:

Di bawah ini adalah skrip untuk melatih model.

# train_distillation.py
from datasets import load_dataset
from trl import DistillationTrainer

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

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

Jalankan skrip menggunakan perintah berikut:

torchrun --nproc_per_node 8 train_distillation.py

Menggali lebih dalam ke metode distilasi

On-policy knowledge distillation melatih model student untuk mereproduksi distribusi next-token dari model teacher pada completion yang dihasilkan oleh student itu sendiri, bukan pada set output teacher yang tetap. Belajar dari generasi sendiri memungkinkan student untuk memperbaiki kesalahannya sendiri, yang umumnya menghasilkan kinerja lebih baik daripada off-policy distillation. Bagian ini menguraikan cara kerjanya dalam praktik, mencakup dua langkah utama: menghasilkan completion dan menghitung loss.

Membuat kelengkapan

Pada setiap langkah pelatihan, model siswa menghasilkan satu batch penyelesaian untuk prompt yang diambil secara acak.

Menghitung loss

Loss-nya adalah divergensi Jensen-Shannon (JSD) yang digeneralisasi antara distribusi student pS p_S dan distribusi teacher pT p_T pada token penyelesaian yang dihasilkan, diinterpolasi dengan beta dan didefinisikan sebagai: Lβ=β DKL ⁣[pT∥pM]+(1−β) DKL ⁣[pS∥pM],pM=(1−β) pS+β pT, \mathcal{L}_\beta = \beta \, \mathbb{D}_{\mathrm{KL}}\!\left[ p_T \| p_M \right] + (1 - \beta) \, \mathbb{D}_{\mathrm{KL}}\!\left[ p_S \| p_M \right], \qquad p_M = (1 - \beta) \, p_S + \beta \, p_T,

di mana pM p_M adalah β \beta -campuran dari dua distribusi tersebut. Titik ujungnya mereduksi menjadi divergensi murni: beta=0.0 memberikan forward KL DKL ⁣[pT∥pS] \mathbb{D}_{\mathrm{KL}}\!\left[ p_T \| p_S \right] dan beta=1.0 reverse KL DKL ⁣[pS∥pT] \mathbb{D}_{\mathrm{KL}}\!\left[ p_S \| p_T \right] .

Dalam praktiknya, proyeksi ke logit kosakata dan divergensi dihitung dalam potongan-potongan, sehingga memori aktivasi puncak tidak berskala dengan tensor logit kosakata penuh × panjang sekuens. Lihat Mengurangi Penggunaan Memori.

Jenis dataset yang diharapkan

Dataset harus diformat sebagai dataset conversational prompt-only. Siswa menghasilkan komplitnya sendiri secara on-policy, sehingga hanya prompt yang diperlukan:

{"prompt": [{"role": "user", "content": "What color is the sky?"}]}

Metrik yang dicatat

Selama pelatihan dan evaluasi, kami mencatat metrik berikut:

  • num_tokens: Total jumlah token yang diproses sejauh ini, termasuk prompt dan completion. Saat menggunakan tools, hanya token non-tool yang dihitung.
  • step_time: Rata-rata waktu (dalam detik) yang dibutuhkan per langkah pelatihan (termasuk generasi).
  • completions/mean_length: Rata-rata panjang dari completion yang dihasilkan. Saat menggunakan tools, hanya token non-tool yang dihitung.
  • completions/min_length: Panjang minimum dari komposisi yang dihasilkan. Saat menggunakan tools, hanya token non-tool yang dihitung.
  • completions/max_length: Panjang maksimum dari komplitasi yang dihasilkan. Saat menggunakan tools, hanya token non-tool yang dihitung.
  • completions/mean_terminated_length: Rata-rata panjang dari kelengkapan yang dihasilkan yang diakhiri dengan EOS. Saat menggunakan alat, hanya token non-alat yang dihitung.
  • completions/min_terminated_length: Panjang minimum dari completion yang dihasilkan yang diakhiri dengan EOS. Saat menggunakan tools, hanya token non-tool yang dihitung.
  • completions/max_terminated_length: Panjang maksimum dari completion yang dihasilkan yang diakhiri dengan EOS. Saat menggunakan tools, hanya token non-tool yang dihitung.
  • completions/clipped_ratio: Rasio penyelesaian yang dipotong (clipped).
  • tools/call_frequency: Rata-rata jumlah pemanggilan alat per penyelesaian dalam batch generasi. Dicatat hanya ketika tools disediakan.
  • tools/failure_frequency: Proporsi pemanggilan alat yang gagal (alat tidak ditemukan, memicu pengecualian, atau tipe pemanggilan tidak didukung). Nilainya 0.0 jika tidak ada alat yang dipanggil. Dicatat hanya ketika tools disediakan.
  • entropy: Entropi rata-rata dari prediksi token di seluruh kelengkapan yang dihasilkan (dalam nats).

Kustomisasi

Percepat pelatihan dengan generasi yang didukung vLLM

Generasi sering menjadi bottleneck utama saat melatih dengan metode on-policy. Untuk mempercepat generasi, Anda dapat menggunakan vLLM, mesin inferensi ber-throughput tinggi dan latensi rendah untuk LLM. Untuk mengaktifkannya, pertama instal paketnya dengan

pip install trl[vllm]

Kami mendukung dua cara penggunaan vLLM selama pelatihan: mode colocate dan mode server.

Opsi 1: Mode Colocate

Pada mode ini, vLLM berjalan di dalam proses trainer dan berbagi memori GPU dengan model pelatihan. Hal ini menghindari peluncuran server terpisah dan dapat meningkatkan pemanfaatan GPU, tetapi dapat menyebabkan perebutan memori pada GPU pelatihan. Ini adalah mode default.

from trl import DistillationConfig

training_args = DistillationConfig(
    ...,
    use_vllm=True,  # vllm_mode="colocate" by default
)

Opsi 2: Mode server

Pada mode ini, vLLM berjalan dalam proses terpisah (dan menggunakan GPU terpisah) serta berkomunikasi dengan trainer melalui HTTP. Ini ideal jika Anda memiliki GPU khusus untuk inferensi.

  1. Mulai server vLLM:

    VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
        --weight-transfer-config '{"backend": "nccl"}' \
        --logprobs-mode processed_logprobs \
        --max-logprobs -1
  2. Aktifkan mode server di skrip pelatihan Anda:

    from trl import DistillationConfig
    
    training_args = DistillationConfig(
        ...,
        use_vllm=True,
        vllm_mode="server",
    )

Pastikan server menggunakan GPU yang berbeda dari trainer, jika tidak Anda mungkin akan menemui error NCCL. Anda dapat menentukan GPU yang akan digunakan dengan variabel lingkungan CUDA_VISIBLE_DEVICES.

Tergantung pada ukuran model dan kebutuhan memori GPU keseluruhan untuk pelatihan, Anda mungkin perlu menyesuaikan parameter vllm_gpu_memory_utilization di DistillationConfig untuk menghindari underutilization atau error out-of-memory.

Untuk informasi lebih lanjut, lihat Mempercepat pelatihan dengan vLLM.

Latih adapter dengan PEFT

Kami mendukung integrasi yang erat dengan pustaka 🤗 PEFT, memungkinkan Anda melatih adapter dan membagikannya di Hub, alih-alih melatih seluruh model siswa.

from datasets import load_dataset
from trl import DistillationTrainer
from peft import LoraConfig

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

trainer = DistillationTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    teacher_model="Qwen/Qwen2.5-1.5B-Instruct",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)
trainer.train()

Loss distilasi membaca lm_head.weight secara langsung dan menjalankan backbone student tanpa melewati PeftModel.forward(). Adapter pada lm_head (melalui target_modules) dan metode prompt-learning (PromptTuning, PrefixTuning, P-Tuning) karenanya ditolak, karena akan diabaikan secara diam-diam. Untuk melatih head, gunakan modules_to_save=["lm_head"] sebagai gantinya.

Pelatihan Agen

DistillationTrainer mendukung pelatihan agen: siswa memanggil alat selama generasi dan didistilasi pada trajektori yang dihasilkan. Token hasil alat dimasker dari loss, sehingga siswa hanya dilatih pada token yang dihasilkannya sendiri.

Alat

Argumen tools mengharapkan daftar fungsi Python yang mendefinisikan alat yang tersedia untuk agen:

from trl import DistillationTrainer

trainer = DistillationTrainer(
    tools=[tool1, tool2],
    ...,
)

Setiap tool harus berupa fungsi Python standar dengan argumen dan tipe pengembalian yang diberi type-hint, serta docstring bergaya Google yang menjelaskan tujuannya, argumennya, dan nilai pengembaliannya. Untuk detail lebih lanjut, lihat panduan Passing tools.

Loop panggilan alat memerlukan template obrolan yang menjaga prefiks (menambahkan pesan alat tidak boleh mengubah cara pesan sebelumnya dirender). Untuk keluarga model yang dikenal (misalnya Qwen3, DeepSeek-V3), TRL secara otomatis mengganti dengan template pelatihan yang telah diperbaiki ketika alat diaktifkan. Lihat Template Obrolan untuk daftar lengkap.

Gunakan max_tool_calling_iterations di DistillationConfig untuk membatasi jumlah giliran pemanggilan alat. Secara default tidak ada batas, dan generasi berhenti ketika student menghasilkan giliran respons tanpa pemanggilan alat, ketika completion (semua giliran dan hasil alat) mencapai max_completion_length token, atau ketika urutan penuh mencapai panjang maksimum model (vllm_max_model_length dengan vllm_mode="colocate", atau max_position_embeddings model lainnya).

Contoh:

from trl import DistillationTrainer

def multiply(a: int, b: int) -> int:
    """
    Multiplies two integers.

    Args:
        a: The first integer.
        b: The second integer.

    Returns:
        The product of the two integers.
    """
    return a * b

trainer = DistillationTrainer(
    tools=[multiply],
    ...,
)

Alat asinkron belum didukung — gunakan fungsi sinkron.

Respons Alat Multimodal

Tools dapat mengembalikan gambar bersama teks dengan mengembalikan daftar blok konten. Hal ini berguna untuk pelatihan agen VLM di mana tools menyediakan umpan balik visual (misalnya, tangkapan layar, plot, tangkapan kamera).

from PIL import Image

def take_screenshot() -> list:
    """
    Takes a screenshot of the current screen.

    Returns:
        The screenshot image with a description.
    """
    img = Image.open("screenshot.png")
    return [{"type": "image", "image": img}, {"type": "text", "text": "Here is the screenshot."}]

Gambar yang dikembalikan secara otomatis disuntikkan ke dalam percakapan dan diteruskan ke VLM untuk giliran generasi berikutnya.

Pelatihan Model Bahasa Visual

DistillationTrainer mendukung distilasi Vision-Language Models (VLM) pada dataset multimodal yang berisi teks dan gambar. Sampaikan VLM sebagai student dan teacher, serta berikan dataset hanya berisi prompt dengan kolom image (satu gambar per sampel) atau kolom images (daftar gambar per sampel). Untuk informasi lebih lanjut tentang struktur dataset yang diharapkan, lihat bagian Dataset Format — Vision datasets.

Diuji dengan:

  • Gemma 3 — misalnya, google/gemma-3-4b-it
  • LLaVA-NeXT — misalnya, llava-hf/llava-v1.6-mistral-7b-hf
  • Qwen2-VL — misalnya, Qwen/Qwen2-VL-2B-Instruct
  • Qwen2.5-VL — misalnya, Qwen/Qwen2.5-VL-3B-Instruct

Kompatibilitas dengan semua VLM tidak dijamin. Jika Anda yakin suatu model harus didukung, silakan buka issue di GitHub — atau lebih baik lagi, kirimkan pull request dengan perubahan yang diperlukan.

Antarmuka baris perintah

Gunakan trl distillation CLI untuk memulai pelatihan distilasi dari baris perintah. Ia mendukung pelatihan penuh dan LoRA melalui flag standar ModelConfig.

# Full training:
trl distillation \
    --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \
    --dataset_name trl-lib/ultrafeedback-prompt \
    --learning_rate 2e-5 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 8 \
    --output_dir distilled-model \
    --num_train_epochs 1
# LoRA:
trl distillation \
    --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \
    --dataset_name trl-lib/ultrafeedback-prompt \
    --learning_rate 2e-4 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 8 \
    --output_dir distilled-model \
    --num_train_epochs 1 \
    --use_peft \
    --lora_r 64 \
    --lora_alpha 16

DistillationTrainer

kelas trl.DistillationTrainer

< >

( model: str | PreTrainedModel | PeftModelteacher_model: str | transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.distillation_config.DistillationConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | dict[str, datasets.arrow_dataset.Dataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = Nonetools: list[collections.abc.Callable] | None = None )

Parameter

  • model (str atau PreTrainedModel atau PeftModel) — Model yang akan dilatih. Bisa berupa:
    • String, berupa model id dari model pretrained yang dihosting di dalam model repo di huggingface.co, atau path ke directory yang berisi model weights yang disimpan menggunakan save_pretrained, misalnya './my_model_directory/'. Model dimuat menggunakan <ModelArchitecture>.from_pretrained (di mana <ModelArchitecture> diturunkan dari model config) dengan keyword arguments di args.model_init_kwargs. Jika dtype tidak ditentukan di args.model_init_kwargs, default-nya adalah float32. Ini berbeda dari from_pretrained, di mana (sejak Transformers v5) dtype disimpulkan dari model config.
    • Objek PreTrainedModel. Hanya model bahasa kausal yang didukung.
    • Objek PeftModel. Hanya model bahasa kausal yang didukung.
  • teacher_model (str atau PreTrainedModel, opsional) — Model teacher yang distribusi token-nya berikutnya akan dicocokkan oleh student. Bisa berupa model id / path (dimuat seperti model, menggunakan args.teacher_model_init_kwargs) atau PreTrainedModel yang sudah diinstansiasi. Model ini harus berbagi kosakata dengan student. Bisa diabaikan oleh subclass yang menyediakan teacher dengan cara lain (misalnya server remote).
  • args (DistillationConfig, opsional) — Konfigurasi untuk trainer ini. Jika None, konfigurasi default akan digunakan.
  • train_dataset (Dataset atau IterableDataset) — Dataset yang digunakan untuk pelatihan. Dataset ini harus mencakup kolom "prompt". Kolom tambahan lainnya dalam dataset akan diabaikan. Format sampel dapat berupa:
    • Standar: Setiap sampel berisi teks polos.
    • Konversasional: Setiap sampel berisi pesan terstruktur (misalnya, peran dan konten).

    Ketika train_dataset adalah IterableDataset (misalnya dataset streaming), max_steps harus diatur dalam argumen pelatihan, karena panjangnya tidak dapat disimpulkan dan jumlah total langkah pelatihan diperlukan untuk membatasi loop pelatihan serta mengonfigurasi penjadwal laju pembelajaran.

  • eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict atau dict[str, Dataset | IterableDataset]) — Dataset yang digunakan untuk evaluasi. Dataset ini harus memenuhi persyaratan yang sama dengan train_dataset.
  • processing_class (PreTrainedTokenizerBase, ProcessorMixin, opsional) — Kelas pemrosesan yang digunakan untuk memproses data. Sisi padding harus diatur ke “left”. Jika None, kelas pemrosesan dimuat dari nama model dengan from_pretrained. Token padding, tokenizer.pad_token, harus diatur. Jika kelas pemrosesan belum mengatur token padding, tokenizer.eos_token akan digunakan sebagai default.
  • callbacks (daftar TrainerCallback, opsional) — Daftar callback untuk menyesuaikan loop pelatihan. Callback ini akan ditambahkan ke daftar callback default yang dijelaskan di sini.

    Jika Anda ingin menghapus salah satu callback default yang digunakan, gunakan metode remove_callback.

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opsional, defaultnya (None, None)) — Tuple yang berisi optimizer dan scheduler yang akan digunakan. Secara default akan menggunakan instance AdamW pada model Anda dan scheduler yang diberikan oleh get_linear_schedule_with_warmup yang dikendalikan oleh args.
  • quantization_config (BitsAndBytesConfig, opsional) — Konfigurasi kuantisasi yang digunakan saat memuat model dari pengidentifikasi model. Gabungkan dengan peft_config untuk pelatihan QLoRA. Diabaikan jika model sudah diinstansiasi.
  • peft_config (PeftConfig, opsional) — Konfigurasi PEFT yang digunakan untuk membungkus model. Jika None, model tidak dibungkus.
  • tools (list of Callable, opsional) — Daftar fungsi tool callable yang dapat dipanggil oleh model selama proses generasi. Setiap tool harus berupa fungsi Python standar dengan argumen dan nilai return yang diberi type hint dengan benar, serta docstring bergaya Google yang menjelaskan tujuannya, argumennya, dan nilai return-nya. Untuk detail lebih lanjut, lihat: https://huggingface.co/docs/transformers/en/chat_extras#passing-tools. Model menggunakan nama fungsi, type hints, dan docstring untuk menentukan cara memanggilnya. Pastikan bahwa chat template model mendukung penggunaan tool dan bahwa model tersebut telah di-fine-tune untuk tool calling.

Trainer untuk distilasi pengetahuan. Model siswa dilatih secara on-policy — ia menghasilkan kelengkapan (completions) sendiri — untuk mencocokkan distribusi token berikutnya dari model guru di bawah divergensi Jensen-Shannon yang digeneralisasi (menginterpolasi KL maju, KL mundur, dan JSD melalui beta), sebagaimana diperkenalkan dalam On-Policy Distillation of Language Models.

Contoh:

>>> from trl import DistillationTrainer
>>> from datasets import load_dataset

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

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

latih

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

Parameter

  • resume_from_checkpoint (str atau bool, opsional) — Jika berupa str, jalur lokal ke checkpoint yang disimpan oleh instance Trainer sebelumnya. Jika berupa bool dan bernilai True, muat checkpoint terakhir di args.output_dir yang disimpan oleh instance Trainer sebelumnya. Jika ada, pelatihan akan dilanjutkan dari status model/optimizer/scheduler yang dimuat di sini.
  • trial (optuna.Trial atau dict[str, Any], opsional) — Jalankan trial atau kamus hiperparameter untuk pencarian hiperparameter.
  • ignore_keys_for_eval (list[str], opsional) — Daftar kunci dalam output model Anda (jika berupa dictionary) yang harus diabaikan saat mengumpulkan prediksi untuk evaluasi selama pelatihan.

Mengembalikan

~trainer_utils.TrainOutput

Objek yang berisi jumlah langkah global, kerugian pelatihan, dan metrik.

Titik masuk utama pelatihan.

save_model

< >

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

Akan menyimpan model, sehingga Anda dapat memuatnya kembali menggunakan from_pretrained().

Hanya akan menyimpan dari proses utama.

push_to_hub

< >

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

Parameter

  • commit_message (str, opsional, default "End of training") — Pesan untuk commit saat melakukan push.
  • blocking (bool, opsional, default True) — Apakah fungsi harus hanya mengembalikan nilai setelah git push selesai.
  • token (str, opsional, defaultnya None) — Token dengan izin tulis untuk menimpa argumen asli Trainer.
  • revision (str, opsional) — Revisi git untuk di-commit. Secara default menggunakan head dari branch “main”.
  • private (bool, opsional) — Apakah membuat repo menjadi privat saat dibuat. Defaultnya adalah args.hub_private_repo. Tidak berpengaruh jika repo sudah ada.
  • kwargs (dict[str, Any], opsional) — Argumen kata kunci tambahan yang diteruskan ke ~Trainer.create_model_card.

Unggah self.model dan self.processing_class ke 🤗 model hub di repo self.args.hub_model_id.

DistillationConfig

kelas trl.DistillationConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool | None = Falselabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falseteacher_model_name_or_path: str | None = Noneteacher_model_revision: str | None = Noneteacher_model_init_kwargs: dict[str, typing.Any] | str | None = Nonedisable_dropout: bool = Falsemax_completion_length: int | None = 512ds3_gather_for_generation: bool = Trueshuffle_dataset: bool | None = Truepad_to_multiple_of: int | str | None = 'auto'temperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict | str | None = Nonechat_template_kwargs: dict | str | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_structured_outputs_regex: str | None = Nonevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_server_timeout: float = 240.0vllm_group_port: int = 51216vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonevllm_tensor_parallel_size: int = 1beta: float = 1.0max_tool_calling_iterations: int | None = Nonelog_completions: bool = Falsenum_completions_to_print: int | None = Nonelog_unique_prompts: bool = False )

Parameter yang mengontrol model dan model guru

  • model_init_kwargs (str atau dict[str, Any], opsional) — Argumen kata kunci untuk AutoModelForCausalLM.from_pretrained, digunakan ketika argumen model dari trainer diberikan sebagai string. Nilai revision juga digunakan saat memuat kelas pemrosesan.
  • trust_remote_code (bool, opsional, default False) — Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke from_pretrained dan from_pretrained, untuk student dan teacher.
  • teacher_model_name_or_path (str, opsional) — Nama atau path untuk model teacher. Digunakan ketika teacher dimuat secara lokal.
  • teacher_model_revision (str, opsional) — Revisi model dari model teacher (misalnya, nama branch, tag, atau hash commit).
  • teacher_model_init_kwargs (str atau dict[str, Any], opsional) — Argumen kata kunci yang diteruskan ke AutoModelForCausalLM.from_pretrained saat menginstansiasi model teacher dari string.
  • disable_dropout (bool, opsional, default False) — Apakah akan menonaktifkan dropout pada model student selama pelatihan.

Parameter yang mengontrol pra-pemrosesan data

  • remove_unused_columns (bool, opsional, default False) — Apakah hanya kolom "prompt" yang akan dipertahankan dalam dataset. Trainer mengonsumsi kolom prompt mentah dan menghasilkan kelengkapan secara on-policy, sehingga defaultnya adalah False.
  • max_completion_length (int atau None, opsional, defaultnya 512) — Jumlah maksimum token yang dihasilkan per completion selama on-policy generation.
  • ds3_gather_for_generation (bool, opsional, default True) — Pengaturan ini berlaku untuk DeepSpeed ZeRO-3. Jika diaktifkan, bobot model kebijakan akan dikumpulkan untuk generasi, sehingga meningkatkan kecepatan generasi. Namun, menonaktifkan opsi ini memungkinkan pelatihan model yang melebihi kapasitas VRAM satu GPU, meskipun dengan biaya kecepatan generasi yang lebih lambat. Menonaktifkan opsi ini tidak kompatibel dengan generasi vLLM.
  • shuffle_dataset (bool, opsional, default True) — Apakah dataset pelatihan akan diacak.
  • pad_to_multiple_of (int atau str, opsional, default "auto") — Jika diset, prompt ids dan completion ids akan di-pad hingga menjadi kelipatan dari nilai ini. "auto" melakukan padding hingga kelipatan 128 pada Neuron (AWS Trainium), yang dikompilasi sekali per bentuk input, dan tidak melakukan padding di tempat lain.

Parameter yang mengontrol generasi

  • temperature (float, opsional, default 1.0) — Suhu untuk sampling selama generasi dan untuk menghitung distillation loss. Nilai yang lebih tinggi menghasilkan distribusi probabilitas yang lebih lembut.
  • top_p (float, opsional, default 1.0) — Parameter sampling top-p (nucleus) untuk generasi on-policy.
  • top_k (int, opsional, default 0) — Parameter top-k sampling untuk generasi on-policy. 0 menonaktifkan penyaringan top-k.
  • min_p (float, opsional) — Probabilitas token minimum, yang akan diskalakan oleh probabilitas token yang paling mungkin. Nilainya harus berada di antara 0.0 dan 1.0. Nilai tipikal berada dalam rentang 0.01-0.2.
  • generation_kwargs (dict[str, Any], opsional) — Argumen kata kunci tambahan untuk diteruskan ke GenerationConfig (jika menggunakan transformers) atau SamplingParams (jika menggunakan vLLM) saat mengambil sampel penyelesaian. Ini dapat digunakan untuk lebih menyesuaikan perilaku generasi, seperti mengatur suppress_tokens, num_beams, dll. Jika berisi kunci yang bertentangan dengan parameter generasi lainnya (seperti min_p, top_p, dll.), mereka akan menimpanya.
  • chat_template_kwargs (dict[str, Any], opsional) — Argumen kata kunci tambahan untuk diteruskan ke fungsi apply_chat_template saat menghasilkan kelengkapan.
  • repetition_penalty (float, opsional, default 1.0) — Float yang menghukum token baru berdasarkan apakah token tersebut muncul dalam prompt dan teks yang telah dihasilkan sejauh ini. Nilai > 1.0 mendorong model untuk menggunakan token baru, sedangkan nilai < 1.0 mendorong model untuk mengulang token.
  • cache_implementation (str, opsional) — Implementasi metode cache untuk generasi yang lebih cepat ketika use_vllm diatur ke False.

Parameter yang mengontrol akselerasi generasi yang didukung oleh vLLM

  • use_vllm (bool, opsional, default False) — Apakah akan menggunakan vLLM untuk menghasilkan kelengkapan on-policy dari model student.
  • vllm_mode (str, opsional, default "colocate") — Mode untuk integrasi vLLM student. Bisa "server" atau "colocate".
  • vllm_model_impl (str, opsional, default "vllm") — Backend implementasi model untuk vLLM. Gunakan "vllm" atau "transformers".
  • vllm_enable_sleep_mode (bool, opsional, default False) — Aktifkan mode tidur vLLM untuk memindahkan bobot siswa selama langkah optimizer.
  • vllm_structured_outputs_regex (str, opsional) — Pola regex untuk structured outputs vLLM.

Parameter yang mengontrol server vLLM (hanya digunakan ketika `vllm_mode` adalah `"server"`)

  • vllm_server_base_url (str, opsional) — URL dasar untuk server vLLM student. Jika disediakan, vllm_server_host dan vllm_server_port diabaikan.
  • vllm_server_host (str, opsional, default "0.0.0.0") — Host dari server vLLM student.
  • vllm_server_port (int, opsional, default 8000) — Port dari server vLLM student.
  • vllm_server_timeout (float, opsional, default 240.0) — Timeout untuk terhubung ke server vLLM student.
  • vllm_group_port (int, opsional, default 51216) — Port untuk grup pembaruan bobot vLLM (komunikator NCCL).

Parameter yang mengontrol eksekusi vLLM yang terkolokasi (hanya digunakan ketika `vllm_mode` adalah `"colocate"`)

  • vllm_gpu_memory_utilization (float, opsional, default 0.3) — Utilisasi memori GPU untuk mesin vLLM student yang dikolokasi.
  • vllm_max_model_length (int, opsional) — Panjang urutan maksimum model untuk mesin vLLM yang terkolokasi.
  • vllm_tensor_parallel_size (int, opsional, default 1) — Ukuran paralel tensor untuk mesin vLLM siswa yang terkolokasi.

Parameter yang mengontrol pelatihan

  • beta (float, opsional, default 1.0) — Koefisien interpolasi untuk loss Generalized Jensen-Shannon Divergence. Ketika 0.0, loss-nya adalah forward KL divergence. Ketika 1.0, loss-nya adalah reverse KL divergence. Ketika 0.5, loss-nya adalah JSD standar. Berbeda dengan beta pada GRPO (koefisien penalti KL terhadap model referensi), di sini parameter ini memilih divergensinya sendiri; tidak ada penalti KL model referensi.
  • max_tool_calling_iterations (int, opsional) — Jumlah maksimum giliran pemanggilan alat saat melatih agen. Jika None, tidak ada batas dan generasi berhenti ketika model menghasilkan giliran respons tanpa pemanggilan alat, ketika kelengkapan (semua giliran dan hasil alat) mencapai max_completion_length token, atau ketika urutan penuh mencapai panjang maksimum model (vllm_max_model_length dengan vllm_mode="colocate", max_position_embeddings model lainnya).

Parameter yang mengontrol logging

  • log_completions (bool, opsional, default False) — Apakah akan mencatat sampel pasangan (prompt, completion) setiap logging_steps langkah. Jika rich terinstal, sampel tersebut akan dicetak. Jika logging wandb dan/atau trackio diaktifkan, sampel akan dicatat ke wandb dan/atau trackio.
  • num_completions_to_print (int, opsional) — Jumlah completion yang dicetak dengan rich. Jika None, semua completion dicatat.
  • log_unique_prompts (bool, opsional, default False) — Apakah akan mencatat prompt unik. Jika True, hanya prompt unik yang dicatat. Jika False, semua prompt dicatat.

Kelas konfigurasi untuk DistillationTrainer.

Memperluas TrainingArguments dengan parameter yang spesifik untuk knowledge distillation. Semua field yang diperlukan dideklarasikan di sini.

Dengan HfArgumentParser, kita dapat mengubah kelas ini menjadi argumen argparse yang dapat ditentukan di baris perintah.

Parameter-parameter ini memiliki nilai default yang berbeda dari TrainingArguments:

  • logging_steps: Bawaan adalah 10 alih-alih 500.
  • gradient_checkpointing: Beralih ke True sebagai nilai bawaan, bukan False.
  • bf16: Beralih ke True jika fp16 tidak diatur, alih-alih False.
  • learning_rate: Bawaan adalah 1e-6 alih-alih 5e-5.
Update on GitHub