Pelatih General Online Logit Distillation (GOLD)

Ikhtisar

General Online Logit Distillation (GOLD) adalah ekstensi dari Universal Logit Distillation (ULD) yang mendukung pasangan student/teacher dengan tokenizer yang berbeda. Metode ini menyelaraskan span teks yang dihasilkan oleh kedua tokenizer dan menggabungkan logits terkait sehingga tidak ada token penyelesaian yang terlewat. Hal ini memungkinkan knowledge distillation lintas tokenizer, termasuk keluarga model campuran (misalnya, student LLaMA dengan teacher Qwen).

Kemampuan utama:

Penyelarasan lintas tokenizer – GOLD secara bertahap mendekode token siswa dan guru, mengelompokkan cuplikan dengan teks yang terlihat sama, dan menggabungkan probabilitas di dalam setiap kelompok. Hal ini menjamin bahwa istilah kerugian dihitung di atas penyelesaian penuh meskipun batas token berbeda.
Hybrid ULD loss – ketika uld_use_hybrid_loss diaktifkan, GOLD membandingkan kecocokan persis kosakata secara langsung dan kembali ke kerugian ULD probabilitas terurut asli untuk token yang tidak cocok. Hal ini meningkatkan stabilitas bagi siswa yang kosakatanya hanya sebagian tumpang tindih dengan guru.
Integrasi mulus dengan GKD – GOLD mewarisi penjadwalan on-policy vs. off-policy dari experimental.gkd.GKDTrainer, sehingga Anda dapat menggabungkan KD tingkat sekuens, JSD yang digeneralisasi, dan distilasi lintas tokenizer dalam satu sesi pelatihan.

GOLD saat ini merupakan bagian dari namespace trl.experimental. API dapat berubah tanpa pemberitahuan selama fitur ini masih dalam tahap iterasi.

Tips penggunaan

experimental.gold.GOLDTrainer merupakan subkelas dari SFTTrainer dan menerima dataset yang sama seperti trainer TRL lainnya (daftar pesan bergaya ChatML). Flag konfigurasi penting pada experimental.gold.GOLDConfig meliputi:

use_uld_loss – mengaktifkan Universal Logit Distillation. Atur ini ke True untuk setup cross-tokenizer.
teacher_tokenizer_name_or_path – wajib diisi saat use_uld_loss=True; GOLD menggunakan tokenizer guru untuk menyelaraskan token.
uld_use_hybrid_loss, uld_hybrid_matched_weight, uld_hybrid_unmatched_weight – mengaktifkan dan memberi bobot pada loss hybrid matched/unmatched.
beta, lmbda, seq_kd – diwarisi dari experimental.gkd.GKDConfig, mengontrol interpolasi JSD umum dan rasio sampling on-policy.
use_privileged_context, teacher_prompt_template, privileged_context_column – memungkinkan teacher melihat konteks tambahan per-contoh sementara prompt student tetap tidak berubah. Saat ini, fitur ini terbatas pada pelatihan teks, off-policy, dan standard-JSD.
num_generations, generation_batch_size – mengontrol pembuatan rollout yang dibuffer di seluruh jendela akumulasi gradien. generation_batch_size adalah jumlah prompt unik per worker per langkah optimizer.

A minimal end-to-end example:

from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer

train_dataset = load_dataset(
    "HuggingFaceTB/OpenR1-Math-220k-default-verified",
    "all",
    split="train[:1024]",
)

trainer = GOLDTrainer(
    model="meta-llama/Llama-3.2-1B-Instruct",
    teacher_model="Qwen/Qwen2.5-0.5B-Instruct",
    args=GOLDConfig(output_dir="gold-model", use_uld_loss=True, teacher_tokenizer_name_or_path="Qwen/Qwen2.5-0.5B-Instruct"),
    train_dataset=train_dataset,
)
trainer.train()

Untuk alur kerja cepat, Anda dapat mengandalkan pengidentifikasi string seperti yang ditunjukkan di atas—pelatih akan memuat model dan tokenizer untuk Anda. Instansiasi eksplisit AutoModelForCausalLM, AutoTokenizer, atau pengisian GOLDConfig hanya disarankan untuk kasus penggunaan lanjutan di mana Anda memerlukan kontrol terperinci atas inisialisasi.

Setup yang lebih eksplisit mungkin terlihat seperti ini ketika Anda perlu menyesuaikan pemuatan model, pengaturan tokenizer, atau argumen pelatihan:

from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

student_name = "meta-llama/Llama-3.2-1B-Instruct"
teacher_name = "Qwen/Qwen2.5-0.5B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(student_name)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(student_name)
teacher_model = AutoModelForCausalLM.from_pretrained(teacher_name)

train_dataset = load_dataset(
    "HuggingFaceTB/Countdown-Task-GOLD",
    "verified_Qwen2.5-0.5B-Instruct",
    split="train",
)

training_args = GOLDConfig(
    output_dir="gold-model",
    per_device_train_batch_size=1,
    teacher_model_name_or_path=teacher_name,
    teacher_tokenizer_name_or_path=teacher_name,
    use_uld_loss=True,
    uld_use_hybrid_loss=True,
)

trainer = GOLDTrainer(
    model=model,
    teacher_model=teacher_model,
    args=training_args,
    processing_class=tokenizer,
    train_dataset=train_dataset,
)
trainer.train()

GOLD menyangga satu batch generasi penuh untuk jendela optimizer (per_device_train_batch_size * gradient_accumulation_steps) dan memakainya kembali di seluruh langkah akumulasi. Jika batch terakhir berukuran kurang, GOLD akan memperingatkan dan membuang batch terakhir tersebut (Dropping last batch due to unexpected batch size). Atur dataloader_drop_last=True untuk menghindari peringatan ini.

Jenis dataset yang diharapkan

GOLD memerlukan dataset percakapan modeling bahasa, misalnya:

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

GOLDTrainer menyimpan pesan mentah agar collator ChatML dapat menyusun prompt dan completion dengan batas yang benar.

Konteks Khusus

Privileged-context distillation memberikan informasi tambahan kepada teacher yang tidak tersedia bagi student pada saat inference. Tambahkan kolom context ke dataset prompt/completion biasa, lalu aktifkan fitur ini secara eksplisit:

from datasets import Dataset

dataset = Dataset.from_list(
    [
        {
            "prompt": [{"role": "user", "content": "What caused the outage?"}],
            "completion": [{"role": "assistant", "content": "A timeout change caused the outage."}],
            "privileged_context": "The deployment changed the timeout immediately before errors began.",
        }
    ]
)

args = GOLDConfig(
    output_dir="gold-model",
    lmbda=0.0,
    use_privileged_context=True,
)

Student dilatih pada prompt dan completion asli. Teacher menerima prompt terpisah yang secara default dibangun dari "{prompt}\n\n{privileged_context}", kemudian menilai completion yang persis sama. Untuk data percakapan, GOLD hanya menulis ulang giliran user terakhir sebelum menerapkan ulang chat template; giliran system, tool, dan assistant tetap tidak berubah. Atur teacher_prompt_template untuk menyesuaikan prompt ini, dan privileged_context_column untuk menggunakan kolom selain "privileged_context".

Prompt guru tidak pernah dipotong, sehingga pastikan prompt tersebut muat dalam jendela konteks model guru. Dukungan awal ini sengaja dibatasi pada teks dan distilasi JSD standar off-policy: lmbda harus 0, dan seq_kd=True, use_uld_loss=True, X-Token KD (xtoken_loss_type selain "none"), packing, VLM, serta Liger Kernel tidak didukung dengan konteks istimewa.

Cara Kerja Penggabungan Token

Ketika siswa dan guru menggunakan tokenizer yang berbeda, teks yang sama mungkin dipecah dengan cara yang berbeda:

Mahasiswa: "Hugging Face" → 1 token
Guru: "Hugging", " Face" → 2 token

GOLD menyelaraskan sekuens-sekuens ini dan menggabungkan probabilitas multi-token dari teacher menjadi satu distribusi tunggal yang dapat dibandingkan dengan distribusi single-token dari student.

Menggabungkan Probabilitas

Untuk sekuens token guru [token₀, token₁, ..., tokenₖ] yang dipetakan ke satu token siswa, GOLD menghitung:

P_merged(y) = P(y | context) × P(token₁ | token₀, context) × ... × P(tokenₖ | ..., context)

di mana:

P(y | context) adalah distribusi probabilitas marginal atas semua token kosakata pada posisi pertama
P(tokenᵢ | ..., context) adalah probabilitas kondisional skalar dari token aktual yang dihasilkan

Insight utama: Hanya probabilitas kondisional dari token kelanjutan aktual yang diekstrak sebagai skalar. Distribusi marginal penuh pada posisi pertama kemudian diskalakan dengan mengalikan probabilitas skalar tersebut.

Hal ini memastikan:

Probabilitas gabungan yang benar untuk urutan yang dihasilkan sebenarnya (dengan aturan rantai)
Approximasi yang wajar untuk token kontrafaktual (diskalakan dengan kemungkinan kelanjutan yang sama)
Distribusi tidak ternormalisasi yang mempertahankan probabilitas relatif yang benar untuk perhitungan kerugian ULD

Contoh

Diberikan:

P(x₀):         ["HF": 0.6,  "is": 0.3,  "cool": 0.1]
P(x₁ | "HF"):  ["HF": 0.05, "is": 0.9,  "cool": 0.05]

Jika token 0 dan 1 digabungkan, dan urutan sebenarnya adalah ["HF", "is"]:

P_merged("HF")   = 0.6 × 0.9 = 0.54  ✓ (correct joint probability)
P_merged("is")   = 0.3 × 0.9 = 0.27
P_merged("cool") = 0.1 × 0.9 = 0.09

Distribusi gabungan tidak ternormalisasi (menjumlahkan menjadi 0.81), tetapi ini disengaja dan benar untuk komputasi kerugian ULD, yang menggunakan pengurutan dan jarak L1.

Skrip contoh

Gunakan examples/gold_chatbot_arena/gold_chatbot_arena.py untuk meluncurkan pelatihan GOLD dari command line. Skrip ini mendukung pelatihan penuh dan LoRA melalui flag standar ModelConfig.

python examples/gold_chatbot_arena/gold_chatbot_arena.py \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
    --dataset_name trl-lib/chatbot_arena_completions \
    --learning_rate 2e-5 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 8 \
    --output_dir gold-model \
    --num_train_epochs 1 \
    --push_to_hub

Pelatihan Model Bahasa Visual

experimental.gold.GOLDTrainer mendukung distilasi VLM-ke-VLM. Baik model siswa maupun guru harus berupa model bahasa-visi. Untuk melatih VLM, sediakan dataset 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.

Ketika model siswa dan guru berbagi arsitektur dan tokenizer yang sama (misalnya Qwen3-VL-8B ke Qwen3-VL-2B), kerugian JSD umum standar diterapkan secara langsung. Ketika mereka memiliki model_type yang berbeda (misalnya Qwen3-VL ke LFM2.5-VL), atur use_uld_loss=True untuk mengaktifkan penyesuaian lintas-tokenizer melalui Universal Logit Distillation. Gambar diproses secara terpisah melalui prosesor masing-masing model.

from datasets import load_dataset
import torch
from transformers import AutoModelForImageTextToText, AutoProcessor
from trl.experimental.gold import GOLDConfig, GOLDTrainer

student_name = "Qwen/Qwen3-VL-2B-Instruct"
teacher_name = "Qwen/Qwen3-VL-8B-Instruct"

processor = AutoProcessor.from_pretrained(student_name, padding_side="left")
student_model = AutoModelForImageTextToText.from_pretrained(student_name, dtype=torch.bfloat16)
teacher_model = AutoModelForImageTextToText.from_pretrained(teacher_name, dtype=torch.bfloat16)

train_dataset = load_dataset("trl-lib/llava-instruct-mix", split="train")

trainer = GOLDTrainer(
    model=student_model,
    teacher_model=teacher_model,
    args=GOLDConfig(
        output_dir="gold-vlm-model",
        max_length=None,
        teacher_model_name_or_path=teacher_name,
        use_uld_loss=False,
    ),
    train_dataset=train_dataset,
    processing_class=processor,
)
trainer.train()

Untuk distilasi lintas keluarga, atur use_uld_loss=True dan teacher_tokenizer_name_or_path ke nama model guru.

Gunakan examples/gold_qwen3_vl/gold_qwen3_vl.py untuk meluncurkan pelatihan GOLD VLM dari baris perintah:

# Same-family distillation (JSD loss, vLLM enabled)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name Qwen/Qwen3-VL-2B-Instruct \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct

# Cross-family distillation (ULD loss, local generation)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name LiquidAI/LFM2.5-VL-1.6B \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct \
    --use_uld_loss \
    --no-use_vllm

Untuk VLM, truncation_mode='keep_end' tidak didukung karena token gambar berada di bagian prompt dari urutan dan dapat dihapus secara diam-diam. Gunakan truncation_mode='keep_start' (default) atau atur max_length=None di experimental.gold.GOLDConfig. Ini memungkinkan model memproses panjang urutan penuh tanpa memotong token gambar.
GOLDConfig(max_length=None, ...)
Gunakan max_length hanya jika Anda telah memverifikasi bahwa pemotongan (truncation) tidak akan menghapus token gambar untuk seluruh dataset.

Distilasi VLM lintas arsitektur memerlukan use_uld_loss=True. Trainer akan menampilkan error jika Anda mencoba distilasi lintas arsitektur tanpa ULD loss.

GOLDTrainer

kelas trl.experimental.gold.GOLDTrainer

< source >

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = Noneteacher_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str] = Noneargs: trl.experimental.gold.gold_config.GOLDConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | 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.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None)preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonepeft_config: typing.Optional[ForwardRef('PeftConfig')] = None )

latih

< source >

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.

generate_on_policy_outputs

< source >

( modelinputsgeneration_config )

save_model

< source >

( 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

< source >

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

GOLDConfig

kelas trl.experimental.gold.GOLDConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-07lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonechat_template_path: str | None = Nonedataset_text_field: str = 'text'dataset_kwargs: dict[str, typing.Any] | str | None = Nonedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'shuffle_dataset: bool = Falsepacking: bool = Falsepacking_strategy: str = 'bfd'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'eval_packing: bool | None = Nonecompletion_only_loss: bool | None = Noneassistant_only_loss: bool = Falseloss_type: str = 'nll'activation_offloading: bool = Falsepad_token: str | None = Nonetemperature: float = 0.9top_p: float = 0.95top_k: int = 0lmbda: float = 0.5beta: float = 0.5max_completion_length: int = 128teacher_model_name_or_path: str | None = Noneteacher_model_revision: str | None = Noneteacher_model_init_kwargs: dict[str, typing.Any] | str | None = Noneteacher_tokenizer_name_or_path: str | None = Nonedisable_dropout: bool = Trueseq_kd: bool = Falseuse_privileged_context: bool = Falseteacher_prompt_template: str | None = Noneprivileged_context_column: str = 'privileged_context'num_generations: int = 1generation_batch_size: int | None = Noneuse_uld_loss: bool = Falseuld_token_merge_strategy: str = 'observed'use_extended_uld: bool = Trueuld_use_hybrid_loss: bool = Falseuld_hybrid_matched_weight: float | None = Noneuld_hybrid_unmatched_weight: float | None = Noneuld_crossentropy_weight: float = 0.0uld_distillation_weight: float = 1.0uld_student_temperature: float = 1.0uld_teacher_temperature: float = 1.0uld_skip_student_eos: bool = Trueuld_skip_teacher_eos: bool = Truextoken_loss_type: str = 'none'xtoken_projection_matrix_path: str | None = Nonextoken_temperature: float = 1.0xtoken_dynamic_scaling: bool = Truextoken_uncommon_topk: int = 8192xtoken_vocab_topk: int = 8192xtoken_kl_weight: float = 1.0xtoken_ce_scale: float = 0.1use_vllm: bool = Falsevllm_mode: str = 'colocate'vllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8001vllm_server_timeout: float = 240.0vllm_group_port: int = 51216vllm_gpu_memory_utilization: float = 0.9vllm_tensor_parallel_size: int = 1vllm_max_model_length: int | None = Nonevllm_model_impl: str = 'vllm'vllm_structured_outputs_regex: str | None = Nonevllm_sync_frequency: int = 1vllm_enable_sleep_mode: bool = Falselog_completions: bool = Falselog_completions_steps: int = 100num_completions_to_print: int | None = Nonewandb_log_unique_prompts: bool = Truecallbacks: list[str] = <factory> )

Parameter yang mengontrol generasi dan loop pelatihan

temperature (float, opsional, default 0.9) — Suhu untuk sampling. Semakin tinggi suhu, semakin acak hasil pelengkapannya.
top_p (float, opsional, default 0.95) — Jika diatur ke float < 1, hanya kumpulan token paling probabel terkecil dengan probabilitas yang berjumlah top_p atau lebih tinggi yang dipertahankan untuk generasi.
top_k (int, opsional, default 0) — Jumlah token kosakata dengan probabilitas tertinggi yang dipertahankan untuk top-k-filtering. Jika 0, top-k-filtering dinonaktifkan dan semua token dipertimbangkan.
lmbda (float, opsional, default 0.5) — Parameter Lambda yang mengontrol fraksi data student (yaitu, proporsi output yang dihasilkan student secara on-policy).
beta (float, opsional, default 0.5) — Koefisien interpolasi antara 0.0 dan 1.0 untuk loss Generalized Jensen-Shannon Divergence. Ketika beta adalah 0.0, loss-nya adalah KL divergence. Ketika beta adalah 1.0, loss-nya adalah Inverse KL Divergence.
max_completion_length (int, opsional, defaultnya 128) — Jumlah maksimum token yang akan dihasilkan per completion.
teacher_model_name_or_path (str, opsional) — Nama atau path dari model teacher. Jika None, model teacher akan sama dengan model yang sedang dilatih.
teacher_model_revision (str atau None, opsional, defaultnya None) — Revisi model dari model teacher (misalnya, nama branch, tag, atau hash commit). Jika None, revisi default yang digunakan.
teacher_model_init_kwargs (dict[str, Any], opsional) — Argumen kata kunci untuk diteruskan ke AutoModelForCausalLM.from_pretrained saat menginstansiasi model teacher dari string. Nilai revision juga digunakan saat memuat kelas pemrosesan teacher.
teacher_tokenizer_name_or_path (str, opsional) — Nama atau path tokenizer untuk model teacher. Jika None saat menggunakan ULD loss, akan menggunakan tokenizer yang sama dengan model student (tidak direkomendasikan untuk distilasi lintas-tokenizer).
disable_dropout (bool, opsional, default True) — Apakah akan menonaktifkan dropout pada model.
seq_kd (bool, opsional, default False) — Parameter seq_kd yang mengontrol apakah akan melakukan Sequence-Level KD (dapat dipandang sebagai supervised FT pada output yang dihasilkan teacher).
use_privileged_context (bool, opsional, default False) — Apakah akan mengondisikan teacher pada konteks istimewa per-contoh sambil tetap mempertahankan prompt student tanpa perubahan. Fitur ini hanya didukung untuk teks, distilasi JSD standar off-policy.
teacher_prompt_template (str, opsional) — Template yang digunakan untuk menyusun prompt guru. Harus berisi {prompt} dan boleh berisi {privileged_context}. Jika None, defaultnya adalah "{prompt}\n\n{privileged_context}".
privileged_context_column (str, opsional, default "privileged_context") — Kolom dataset yang berisi konteks istimewa per contoh yang digunakan untuk menyusun prompt guru.
num_generations (int, opsional, default 1) — Jumlah generasi per prompt. Setiap prompt diulang sebanyak ini dalam batch generasi.
generation_batch_size (int atau None, opsional, defaultnya None) — Jumlah prompt unik per worker per langkah optimizer. Jika None, nilainya dihitung dari (per_device_train_batch_size * gradient_accumulation_steps) // num_generations.

Parameter yang mengontrol loss ULD

use_uld_loss (bool, opsional, default False) — Apakah akan menggunakan loss Universal Logit Distillation (ULD) alih-alih loss Generalized Jensen-Shannon Divergence.
use_extended_uld (bool, opsional, default True) — Apakah akan mengaktifkan perataan ULD yang diperluas yang menggunakan tokenizer untuk meratakan dan menggabungkan probabilitas token di antara tokenisasi student dan teacher. Ketika True, trainer akan menghitung pemetaan token dan menggabungkan probabilitas untuk token yang dipecah; ketika False, ULD akan menggunakan pemotongan posisional sederhana seperti pada paper ULD asli. Atur ke False untuk tokenizer yang bukan ByteLevel maupun BPE dengan fallback byte (mis. Llama 2).
uld_token_merge_strategy (str, opsional, default "observed") — Strategi yang digunakan untuk menyelaraskan logit jawaban dan menggabungkan probabilitas token dalam kerugian ULD. Dengan "observed", logit jawaban dipotong pada posisi jawaban dan token yang terpecah (ketika use_extended_uld=True) digabungkan dengan mengalikan distribusi marginal pada posisi pertama dengan probabilitas kondisional skalar dari token aktual yang lebih akhir. Dengan "bayesian", potongan logit jawaban digeser satu posisi lebih awal sehingga probs[k] memprediksi token_ids[k] (aturan rantai), dan token yang terpecah digabungkan menggunakan distribusi penuh dari posisi terakhir, dikondisikan pada token prefiks aktual, dikalikan dengan probabilitas skalar dari token yang lebih awal. Pergeseran penyelarasan logit berlaku terlepas dari apakah use_extended_uld diaktifkan atau tidak.
uld_use_hybrid_loss (bool, opsional, default False) — Apakah akan menggunakan hybrid loss yang menggabungkan ULD loss dan JSD loss. Ketika True, loss akhir adalah kombinasi JSD untuk pemetaan token yang diketahui dan ULD untuk pemetaan token yang tidak diketahui.
uld_hybrid_matched_weight (float atau None, opsional) — Bobot untuk komponen kerugian token yang cocok saat menggunakan kerugian hybrid ULD + JSD. Bobot ini menskalakan kerugian JSD yang dihitung atas token yang memiliki pemetaan langsung antara tokenisasi siswa dan guru. Jika None, menggunakan pembobotan adaptif berdasarkan tumpang tindih kosakata. Harus disetel bersama dengan uld_hybrid_unmatched_weight (keduanya None atau keduanya float).
uld_hybrid_unmatched_weight (float atau None, opsional) — Bobot untuk komponen kerugian token yang tidak cocok saat menggunakan kerugian hybrid ULD + JSD. Bobot ini menskalakan kerugian ULD yang dihitung atas token yang tidak memiliki pemetaan langsung antara tokenisasi siswa dan guru. Jika None, menggunakan pembobotan adaptif berdasarkan tumpang tindih kosakata. Harus disetel bersama dengan uld_hybrid_matched_weight (keduanya None atau keduanya float).
uld_crossentropy_weight (float, opsional, default 0.0) — Bobot untuk komponen cross-entropy loss dalam ULD loss. Jika 0, hanya ULD distillation loss yang digunakan.
uld_distillation_weight (float, opsional, default 1.0) — Bobot untuk komponen distillation loss dalam ULD loss.
uld_student_temperature (float, opsional, default 1.0) — Suhu untuk logits siswa dalam perhitungan loss ULD.
uld_teacher_temperature (float, opsional, default 1.0) — Suhu untuk logits guru dalam perhitungan loss ULD.
uld_skip_student_eos (bool, opsional, default True) — Apakah token EOS untuk student akan dilewati dalam perhitungan loss ULD.
uld_skip_teacher_eos (bool, opsional, default True) — Apakah akan melewati token EOS untuk teacher dalam perhitungan loss ULD.

Parameter untuk KD cross-tokenizer X-Token (https

xtoken_loss_type (str, opsional, default "none") — Varian KD lintas-tokenizer: "none" (nonaktif), "p_kl" (KL proyeksi), atau "h_kl" (KL hibrida dengan set umum yang dilonggarkan). Memerlukan teacher_tokenizer_name_or_path dan xtoken_projection_matrix_path.
xtoken_projection_matrix_path (str, opsional) — Path ke file matriks proyeksi yang sudah dihitung sebelumnya. Wajib diisi ketika xtoken_loss_type != "none".
xtoken_temperature (float, opsional, default 1.0) — Suhu T untuk loss X-Token KD; loss dikalikan dengan T² (Hinton 2015).
xtoken_dynamic_scaling (bool, opsional, default True) — Skala KD dengan stop_gradient(abs(CE) / abs(KD)) per microbatch untuk menyeimbangkan magnitudo loss (persamaan 7 di paper).
xtoken_uncommon_topk (int, opsional, default 8192) — H-KL: batasi perbandingan L1 yang diurutkan untuk token yang tidak umum hingga top-k token di setiap sisi.
xtoken_vocab_topk (int, opsional, default 8192) — P-KL: batasi KL ke top-k token guru global berdasarkan logit maksimum. Berinteraksi dengan matriks proyeksi --top-k: token guru di luar jangkauan matriks tersebut mendapatkan massa siswa yang diproyeksikan mendekati nol dan mendominasi KL, sehingga nilai yang lebih kecil memusatkan loss pada token yang dapat dicocokkan oleh siswa.
xtoken_kl_weight (float, opsional, default 1.0) — Bobot untuk istilah X-Token KD ketika xtoken_dynamic_scaling=False.
xtoken_ce_scale (float, opsional, default 0.1) — Faktor skala untuk suku CE dalam X-Token loss ketika xtoken_dynamic_scaling=False.

Parameter yang mengontrol integrasi vLLM

use_vllm (bool, opsional, default False) — Apakah akan menggunakan vLLM untuk menghasilkan kelengkapan dari model siswa. Memerlukan vllm terinstal.
vllm_mode (str, opsional, default "colocate") — Mode untuk integrasi vLLM student. Bisa "server" (menghubungkan ke server vLLM yang sedang berjalan) atau "colocate" (menjalankan vLLM dalam proses yang sama).
vllm_server_host (str, opsional, default "0.0.0.0") — Host dari server vLLM untuk model student (jika vllm_mode="server").
vllm_server_port (int, opsional, default 8001) — Port server vLLM untuk model student (jika vllm_mode="server").
vllm_server_timeout (float, opsional, default 240.0) — Timeout untuk terhubung ke server vLLM student (jika vllm_mode="server").
vllm_gpu_memory_utilization (float, opsional, default 0.9) — Utilisasi memori GPU untuk mesin vLLM student yang dikolokasi (jika vllm_mode="colocate"). Disarankan untuk mengatur nilai ini ke angka rendah jika model student dan teacher berbagi GPU yang sama.
vllm_tensor_parallel_size (int, opsional, default 1) — Ukuran paralel tensor untuk mesin vLLM siswa yang terkolokasi (jika vllm_mode="colocate").
vllm_structured_outputs_regex (str, opsional) — Regex untuk structured outputs vLLM pada model student.
vllm_server_base_url (str, opsional) — URL dasar untuk server vLLM (misalnya, "http://localhost:8001"). Jika disediakan, vllm_server_host dan vllm_server_port diabaikan.
vllm_group_port (int, opsional, default 51216) — Port untuk grup pembaruan bobot vLLM (komunikator NCCL). Selama port tidak terisi, tidak perlu diubah.
vllm_max_model_length (int, opsional) — Panjang urutan maksimum model untuk mesin vLLM yang terkolokasi ketika vllm_mode="colocate". Nilainya secara default adalah panjang konteks maksimum model.
vllm_model_impl (str, opsional, default "vllm") — Backend implementasi model yang akan digunakan di vLLM. Gunakan "vllm" (default) atau "transformers".
vllm_sync_frequency (int, opsional, default 1) — Frekuensi (dalam langkah pelatihan) untuk menyinkronkan bobot model siswa ke mesin vLLM. Atur ke 1 untuk menyinkronkan setelah setiap langkah.
vllm_enable_sleep_mode (bool, opsional, default False) — Aktifkan mode tidur vLLM untuk mengoffload bobot/kache siswa selama langkah optimizer. Menjaga penggunaan memori GPU tetap rendah, tetapi membangunkan mesin menambah latensi transfer host–perangkat.

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 diaktifkan, sampel akan dicatat ke wandb.
log_completions_steps (int, opsional, defaultnya 100) — Jumlah langkah antara pencatatan pasangan (prompt, completion). Hanya digunakan jika log_completions diatur ke True.
num_completions_to_print (int atau None, opsional) — Jumlah completion yang dicetak dengan rich. Jika None, semua completion dicatat.
wandb_log_unique_prompts (bool, opsional, defaultnya True) — Apakah akan mencatat prompt unik ke wandb. Hal ini akan membuat run baru untuk setiap prompt unik.
callbacks (list[str], opsional, defaultnya []) — Callback yang akan dijalankan selama pelatihan.

Kelas konfigurasi untuk experimental.gold.GOLDTrainer.

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan GOLD. Untuk daftar lengkap argumen pelatihan, silakan merujuk ke dokumentasi TrainingArguments dan SFTConfig.

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

learning_rate: Bawaan adalah 1e-7 alih-alih 5e-5.

Update on GitHub