# Pelatih General Online Logit Distillation (GOLD)

[![All_models-GOLD-blue](https://img.shields.io/badge/All_models-GOLD-blue)](https://huggingface.co/models?other=sft,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:

1. **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.
2. **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.
3. **Integrasi mulus dengan GKD** – GOLD mewarisi penjadwalan on-policy vs. off-policy dari [experimental.gkd.GKDTrainer](/docs/trl/v1.18.0/id/gkd_trainer#trl.experimental.gkd.GKDTrainer), sehingga Anda dapat menggabungkan KD tingkat sekuens, JSD yang digeneralisasi, dan distilasi lintas tokenizer dalam satu sesi pelatihan.

> [!NOTE]
> 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](/docs/trl/v1.18.0/id/gold_trainer#trl.experimental.gold.GOLDTrainer) merupakan subkelas dari [SFTTrainer](/docs/trl/v1.18.0/id/sft_trainer#trl.SFTTrainer) dan menerima dataset yang sama seperti trainer TRL lainnya (daftar pesan bergaya ChatML). Flag konfigurasi penting pada [experimental.gold.GOLDConfig](/docs/trl/v1.18.0/id/gold_trainer#trl.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](/docs/trl/v1.18.0/id/gkd_trainer#trl.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 JSD standar.
* `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:

```python
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:

```python
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()
```

> [!NOTE]
> 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](dataset_formats#conversational) [modeling bahasa](dataset_formats#language-modeling), misalnya:

```python
{"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

Distilasi konteks istimewa memberikan informasi tambahan kepada guru yang tidak tersedia bagi siswa pada saat inferensi. Tambahkan kolom konteks ke dataset prompt/completion biasa, lalu aktifkan fitur ini secara eksplisit:

```python
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 untuk teks, 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:
1. **Probabilitas gabungan yang benar** untuk urutan yang dihasilkan sebenarnya (dengan aturan rantai)
2. **Approximasi yang wajar** untuk token kontrafaktual (diskalakan dengan kemungkinan kelanjutan yang sama)
3. **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`](https://github.com/huggingface/trl/blob/main/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`.

```bash
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](/docs/trl/v1.18.0/id/gold_trainer#trl.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](dataset_formats#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.

```python
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`](https://github.com/huggingface/trl/blob/main/examples/gold_qwen3_vl/gold_qwen3_vl.py) untuk meluncurkan pelatihan GOLD VLM dari baris perintah:

```bash
# 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
```

> [!TIP]
> 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](/docs/trl/v1.18.0/id/gold_trainer#trl.experimental.gold.GOLDConfig). Ini memungkinkan model memproses panjang urutan penuh tanpa memotong token gambar.
>
> ```python
> GOLDConfig(max_length=None, ...)
> ```
>
> Gunakan `max_length` hanya jika Anda telah memverifikasi bahwa pemotongan (truncation) tidak akan menghapus token gambar untuk seluruh dataset.

> [!NOTE]
> Distilasi VLM lintas arsitektur memerlukan `use_uld_loss=True`. Trainer akan menampilkan error jika Anda mencoba distilasi lintas arsitektur tanpa ULD loss.

## GOLDTrainer[[trl.experimental.gold.GOLDTrainer]]

#### trl.experimental.gold.GOLDTrainer[[trl.experimental.gold.GOLDTrainer]]

```python
trl.experimental.gold.GOLDTrainer(model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = None, teacher_model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str] = None, args: trl.experimental.gold.gold_config.GOLDConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | dict[str, datasets.arrow_dataset.Dataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: 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 = None, peft_config: typing.Optional[ForwardRef('PeftConfig')] = None)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/gold/gold_trainer.py#L1233)

#### train[[trl.experimental.gold.GOLDTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L1450)

**Parameter:**

resume_from_checkpoint (`str` atau `bool`, *opsional*) : Jika berupa `str`, path 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 state model/optimizer/scheduler yang dimuat di sini.

trial (`optuna.Trial` atau `dict[str, Any]`, *opsional*) : Jalur percobaan atau kamus hiperparameter untuk pencarian hiperparameter.

ignore_keys_for_eval (`list[str]`, *opsional*) : Daftar kunci dalam output model Anda (jika berupa kamus) 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[[trl.experimental.gold.GOLDTrainer.generate_on_policy_outputs]]

```python
generate_on_policy_outputs(model, inputs, generation_config)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/gold/gold_trainer.py#L3356)

#### save_model[[trl.experimental.gold.GOLDTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4077)

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

Hanya akan menyimpan dari proses utama.

#### push_to_hub[[trl.experimental.gold.GOLDTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4337)

**Parameter:**

commit_message (`str`, *opsional*, defaultnya `"End of training"`) : Pesan untuk commit saat push.

blocking (`bool`, *opsional*, defaultnya `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 cabang "main".

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat saat dibuat. Bawaan 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`.

**Mengembalikan:**

URL repositori tempat model didorong jika `blocking=False`, atau objek `Future` yang melacak kemajuan commit jika `blocking=True`.

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

## GOLDConfig[[trl.experimental.gold.GOLDConfig]]

#### trl.experimental.gold.GOLDConfig[[trl.experimental.gold.GOLDConfig]]

```python
trl.experimental.gold.GOLDConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 1e-07, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool = True, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, chat_template_path: str | None = None, dataset_text_field: str = 'text', dataset_kwargs: dict[str, typing.Any] | str | None = None, dataset_num_proc: int | None = None, eos_token: str | None = None, max_length: int | None = 1024, truncation_mode: str = 'keep_start', shuffle_dataset: bool = False, packing: bool = False, packing_strategy: str = 'bfd', padding_free: bool = False, pad_to_multiple_of: int | str | None = 'auto', eval_packing: bool | None = None, completion_only_loss: bool | None = None, assistant_only_loss: bool = False, loss_type: str = 'nll', activation_offloading: bool = False, pad_token: str | None = None, temperature: float = 0.9, top_p: float = 0.95, top_k: int = 0, lmbda: float = 0.5, beta: float = 0.5, max_completion_length: int = 128, teacher_model_name_or_path: str | None = None, teacher_model_revision: str | None = None, teacher_model_init_kwargs: dict[str, typing.Any] | str | None = None, teacher_tokenizer_name_or_path: str | None = None, disable_dropout: bool = True, seq_kd: bool = False, use_privileged_context: bool = False, teacher_prompt_template: str | None = None, privileged_context_column: str = 'privileged_context', num_generations: int = 1, generation_batch_size: int | None = None, use_uld_loss: bool = False, uld_token_merge_strategy: str = 'observed', use_extended_uld: bool = True, uld_use_hybrid_loss: bool = False, uld_hybrid_matched_weight: float | None = None, uld_hybrid_unmatched_weight: float | None = None, uld_crossentropy_weight: float = 0.0, uld_distillation_weight: float = 1.0, uld_student_temperature: float = 1.0, uld_teacher_temperature: float = 1.0, uld_skip_student_eos: bool = True, uld_skip_teacher_eos: bool = True, xtoken_loss_type: str = 'none', xtoken_projection_matrix_path: str | None = None, xtoken_temperature: float = 1.0, xtoken_dynamic_scaling: bool = True, xtoken_uncommon_topk: int = 8192, xtoken_vocab_topk: int = 8192, xtoken_kl_weight: float = 1.0, xtoken_ce_scale: float = 0.1, use_vllm: bool = False, vllm_mode: str = 'colocate', vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8001, vllm_server_timeout: float = 240.0, vllm_group_port: int = 51216, vllm_gpu_memory_utilization: float = 0.9, vllm_tensor_parallel_size: int = 1, vllm_max_model_length: int | None = None, vllm_model_impl: str = 'vllm', vllm_structured_outputs_regex: str | None = None, vllm_sync_frequency: int = 1, vllm_enable_sleep_mode: bool = False, log_completions: bool = False, log_completions_steps: int = 100, num_completions_to_print: int | None = None, wandb_log_unique_prompts: bool = True, callbacks: list[str] = <factory>)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/gold/gold_config.py#L23)

**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 mungkin terkecil dengan probabilitas yang berjumlah `top_p` atau lebih tinggi yang dipertahankan untuk generasi.

top_k (`int`, *opsional*, defaultnya `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 siswa (yaitu, proporsi output yang dihasilkan siswa 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 pelengkapan.

teacher_model_name_or_path (`str`, *opsional*) : Nama model atau path dari model guru. Jika `None`, model guru akan sama dengan model yang sedang dilatih.

teacher_model_revision (`str` atau `None`, *opsional*, defaultnya `None`) : Revisi model dari model guru (misalnya, nama cabang, tag, atau hash commit). Jika `None`, revisi default akan digunakan.

teacher_model_init_kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci untuk diteruskan ke `AutoModelForCausalLM.from_pretrained` saat menginstansiasi model guru dari string. Nilai `revision` juga digunakan saat memuat kelas pemrosesan guru.

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*, defaultnya `True`) : Apakah akan menonaktifkan dropout pada model.

seq_kd (`bool`, *opsional*, defaultnya `False`) : Parameter Seq_kd yang mengontrol apakah akan melakukan Sequence-Level KD (dapat dipandang sebagai FT supervised pada output yang dihasilkan teacher).

use_privileged_context (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengondisikan teacher pada konteks istimewa per-contoh sambil membiarkan prompt student tetap tidak berubah. 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*, defaultnya `"privileged_context"`) : Kolom dataset yang berisi konteks istimewa per-contoh yang digunakan untuk menyusun prompt guru.

num_generations (`int`, *opsional*, defaultnya `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 kerugian ULD:**

use_uld_loss (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan loss Universal Logit Distillation (ULD) alih-alih loss Generalized Jensen-Shannon Divergence.

use_extended_uld (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengaktifkan perataan ULD yang diperluas, yang menggunakan tokenizer untuk meratakan dan menggabungkan probabilitas token di antara tokenisasi siswa dan guru. 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*, defaultnya `"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*, defaultnya `False`) : Apakah akan menggunakan hybrid loss yang menggabungkan ULD loss dan JSD loss. Ketika `True`, loss akhir merupakan kombinasi dari 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 hibrida ULD + JSD. Bobot ini menskalakan kerugian JSD yang dihitung pada 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 hibrida ULD + JSD. Bobot ini menskalakan kerugian ULD yang dihitung pada 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 kerugian ULD.

uld_teacher_temperature (`float`, *opsional*, default `1.0`) : Suhu untuk logits guru dalam perhitungan loss ULD.

uld_skip_student_eos (`bool`, *opsional*, defaultnya `True`) : Apakah akan melewati token EOS untuk student dalam perhitungan loss ULD.

uld_skip_teacher_eos (`bool`, *opsional*, defaultnya `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*, defaultnya `"none"`) : Varian KD lintas-tokenizer: `"none"` (nonaktif), `"p_kl"` (proyeksi KL), atau `"h_kl"` (KL hibrida dengan himpunan 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 kerugian X-Token KD; kerugian 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*, defaultnya `8192`) : H-KL: batasi perbandingan sorted-L1 yang tidak umum ke top-k token per 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 KD X-Token ketika `xtoken_dynamic_scaling=False`.

xtoken_ce_scale (`float`, *opsional*, default `0.1`) : Faktor skala untuk suku CE dalam loss X-Token ketika `xtoken_dynamic_scaling=False`.

**Parameter yang mengontrol integrasi vLLM:**

use_vllm (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan vLLM untuk menghasilkan kelengkapan dari model siswa. Memerlukan `vllm` terpasang.

vllm_mode (`str`, *opsional*, defaultnya `"colocate"`) : Mode untuk integrasi vLLM student. Bisa `"server"` (terhubung ke server vLLM yang sedang berjalan) atau `"colocate"` (menjalankan vLLM dalam proses yang sama).

vllm_server_host (`str`, *opsional*, defaultnya `"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 terkolokasi (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*, defaultnya `1`) : Ukuran paralel tensor untuk mesin vLLM siswa yang terkolokasi (jika `vllm_mode="colocate"`).

vllm_structured_outputs_regex (`str`, *opsional*) : Regex untuk output terstruktur vLLM untuk model siswa.

vllm_server_base_url (`str`, *opsional*) : URL dasar untuk server vLLM (misalnya, `"http://localhost:8001"`). Jika diberikan, `vllm_server_host` dan `vllm_server_port` diabaikan.

vllm_group_port (`int`, *opsional*, defaultnya `51216`) : Port untuk grup pembaruan bobot vLLM (komunikator NCCL). Selama port tidak terisi, tidak perlu diubah.

vllm_max_model_length (`int`, *opsional*) : Panjang maksimum urutan model untuk mesin vLLM yang terkolokasi ketika `vllm_mode="colocate"`. Secara default menggunakan panjang konteks maksimum model.

vllm_model_impl (`str`, *opsional*, defaultnya `"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 pencatatan log:**

log_completions (`bool`, *opsional*, defaultnya `False`) : Apakah akan mencatat sampel dari pasangan (prompt, completion) setiap `logging_steps` langkah. Jika `rich` terinstal, sampel tersebut akan dicetak. Jika logging `wandb` diaktifkan, sampel tersebut 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 penyelesaian yang dicetak dengan `rich`. Jika `None`, semua penyelesaian 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](/docs/trl/v1.18.0/id/gold_trainer#trl.experimental.gold.GOLDTrainer).

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan GOLD. Untuk daftar lengkap argumen pelatihan, silakan merujuk ke dokumentasi [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) dan [SFTConfig](/docs/trl/v1.18.0/id/sft_trainer#trl.SFTConfig).

> [!NOTE]
> Parameter ini memiliki nilai default yang berbeda dari [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments): - `learning_rate`: Defaultnya adalah `1e-7` alih-alih `5e-5`.

