# SDPO

Self-Distillation Policy Optimization (SDPO) diperkenalkan dalam [Reinforcement Learning via Self-Distillation](https://huggingface.co/papers/2601.20802) oleh [Jonas Hübotter](https://huggingface.co/jonhue), Frederike Lübeck, Lejs Behric, [Anton Baumann](https://huggingface.co/antonbaumann), Marco Bagatella, Daniel Marta, Ido Hakimi, Idan Shenfeld, Thomas Kleine Buening, Carlos Guestrin, dan Andreas Krause.

> Model bahasa besar semakin sering dilatih ulang menggunakan pembelajaran penguatan di domain yang dapat diverifikasi, seperti kode dan matematika. Namun, metode saat ini untuk reinforcement learning with verifiable rewards (RLVR) hanya belajar dari reward hasil skalar per percobaan, yang menciptakan bottleneck credit-assignment yang serius. Banyak lingkungan yang dapat diverifikasi sebenarnya menyediakan umpan balik teks yang kaya, seperti error runtime atau evaluasi judge, yang menjelaskan mengapa suatu percobaan gagal. Kami memformalkan pengaturan ini sebagai reinforcement learning with rich feedback dan memperkenalkan Self-Distillation Policy Optimization (SDPO), yang mengubah umpan balik yang ditokenisasi menjadi sinyal pembelajaran yang padat tanpa memerlukan guru eksternal atau model reward eksplisit. SDPO memperlakukan model saat ini yang dikondisikan pada umpan balik sebagai self-teacher dan mendistil prediksi token berikutnya yang diinformasikan umpan balik tersebut kembali ke dalam kebijakan. Dengan cara ini, SDPO memanfaatkan kemampuan model untuk mengidentifikasi kesalahannya sendiri secara retrospektif dalam konteks. Di seluruh penalaran ilmiah, penggunaan alat, dan pemrograman kompetitif pada LiveCodeBench v6, SDPO meningkatkan efisiensi sampel dan akurasi akhir dibandingkan baseline RLVR yang kuat. Yang patut dicatat, SDPO juga melampaui baseline di lingkungan RLVR standar yang hanya mengembalikan umpan balik skalar dengan menggunakan rollout yang berhasil sebagai umpan balik implisit untuk percobaan yang gagal. Terakhir, menerapkan SDPO pada pertanyaan individu saat pengujian mempercepat penemuan pada tugas reward biner yang sulit, mencapai probabilitas penemuan yang sama dengan best-of-k sampling atau percakapan multi-turn dengan 3x lebih sedikit percobaan.

## Cara kerjanya

SDPO menargetkan pembelajaran penguatan dengan imbalan yang dapat diverifikasi (RLVR), di mana setiap percobaan hanya menghasilkan imbalan skalar yang jarang. Metode ini mengubahnya menjadi sinyal padat pada tingkat token: untuk setiap prompt, kebijakan mengambil sampel `num_generations` penyelesaian yang dinilai oleh `reward_funcs`, sebuah rollout yang berhasil (ditambah umpan balik `privileged_context` opsional) menjadi reprompt guru, dan distribusi guru yang diinformasikan umpan balik atas sebuah penyelesaian didistilkan kembali ke dalam kebijakan. Guru dan siswa adalah jaringan yang sama, sehingga tidak diperlukan guru eksternal atau model imbalan di luar verifier.

## Mode loss dan guru

`distillation_weight` mengontrol bagaimana kedua sinyal tersebut digabungkan sebagai kombinasi konveks: loss-nya adalah `(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss`. Nilai `1.0` (default) melatih murni berdasarkan loss self-distillation, `0.0` kembali ke policy gradient bergaya GRPO standar, dan nilai di antaranya mencampurkan keduanya. Tujuan distilasi itu sendiri diatur oleh `distillation_mode` — `"sampled_token"` (default) menggunakan reverse KL tingkat token dan membutuhkan `distillation_alpha=1.0`, sedangkan `"full_logits"` dan `"topk_logits"` melakukan distilasi pada seluruh atau top-`distillation_topk` kosakata.

`teacher_model_kind` memilih bobot guru: `"ema"` (default) melacak siswa dengan rata-rata bergerak eksponensial yang disinkronkan setiap `teacher_sync_steps` langkah pada laju `teacher_update_rate`, `"live"` menggunakan ulang siswa saat ini secara langsung, dan `"base"` membekukan bobot awal. Reprompting diatur oleh `use_successful_as_teacher`, `success_reward_threshold`, `dont_reprompt_on_self_success`, dan string `reprompt_template` / `solution_template` / `feedback_template`. Generasi dijalankan melalui transformers secara default, atau vLLM (mode colocate atau server) ketika `use_vllm=True`.

## Kolom dataset yang diharapkan

Setiap contoh harus menyediakan:

- `prompt`: prompt yang ditampilkan ke siswa
- `privileged_context`: teks istimewa opsional, seperti umpan balik lingkungan, yang digunakan saat `include_environment_feedback=True`

## Penggunaan

```python
from datasets import Dataset

from trl.experimental.sdpo import SDPOConfig, SDPOTrainer

dataset = Dataset.from_dict(
    {
        "prompt": [[{"role": "user", "content": "Solve 2+2."}]],
        "privileged_context": ["Your earlier answer used the wrong format."],
    }
)

training_args = SDPOConfig(
    output_dir="sdpo-model",
    distillation_mode="topk_logits",       # Explicitly select top-K logit distillation
    distillation_topk=100,                 # Required when using top-K logit distillation
    include_environment_feedback=True,     # Use dataset privileged_context for teacher reprompts
)

trainer = SDPOTrainer(
    model="Qwen/Qwen2.5-1.5B-Instruct",
    reward_funcs=reward_func,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()
```

SDPO selalu memerlukan kolom `prompt`. Untuk menggunakan umpan balik lingkungan, sertakan juga kolom `privileged_context` dan atur `include_environment_feedback=True`. SDPO akan menggunakan rollout yang berhasil dan, jika diaktifkan, teks tersebut untuk membangun reprompt guru untuk self-distillation.

## Menyajikan model guru dari server vLLM

Dengan `teacher_model_kind="live"`, guru adalah siswa saat ini, yang bobotnya sudah dipegang oleh **server** vLLM (bobot tersebut disinkronkan untuk generasi di setiap langkah). Atur `use_teacher_server=True` untuk menilai log-probabilitas guru di server yang sama tersebut, alih-alih menjalankan forward guru lokal yang terpisah, sehingga guru sepenuhnya dihapus dari langkah pelatihan:

```python
training_args = SDPOConfig(
    output_dir="sdpo-model",
    use_vllm=True,
    vllm_mode="server",
    teacher_model_kind="live",
    use_teacher_server=True,
    distillation_weight=1.0,
    distillation_mode="sampled_token",
)
```

Saat menggunakan server guru:

- `use_vllm=True` dan `vllm_mode="server"` wajib diisi
- `teacher_model_kind` harus berupa `"live"` (server memegang bobot siswa saat ini)
- `distillation_weight` harus `1.0` (distilasi murni; campuran cembung dengan kerugian kebijakan memerlukan logits seluruh kosakata)
- `distillation_mode` harus berupa `"sampled_token"` (reverse KL pada token yang terealisasi) atau `"topk_logits"`. Server mengembalikan log-prob top-k milik teacher itu sendiri, sehingga `topk_logits` melakukan distilasi pada dukungan top-k teacher (tidak dapat menggunakan dukungan student, berbeda dengan tujuan lokal); dengan teacher `"live"`, kedua dukungan tersebut hampir berimpit. `full_logits` tidak tersedia.

## Callback

Trainer mengeluarkan serangkaian kecil hook callback yang berguna untuk debugging, observabilitas, dan pengujian. Hook-hook ini dimaksudkan sebagai titik integrasi praktis untuk alur kerja self-distillation eksperimental.

Hook self-distilasi bersama:

- `on_self_distillation_batch_prepared`: dipicu ketika batch self-distillation siap. Payload mencakup `prompt_ids`, `completion_ids`, dan `old_per_token_logps` ketika input clipping importance-sampling tersedia.
- `on_generation_batch_built`: dipicu saat batch generasi baru yang dibuffer dibuat. Payload-nya mencakup `generate_every` dan `steps_per_generation`.

Hook khusus SDPO:

- `on_teacher_context_built`: dipicu setelah SDPO membangun input yang dikondisikan oleh teacher. Payload mencakup `teacher_input_ids`, `teacher_attention_mask`, `completion_mask`, dan `self_distillation_mask`.

## Skrip contoh

Gunakan [`examples/sdpo_math/sdpo_math.py`](https://github.com/huggingface/trl/blob/main/examples/sdpo_math/sdpo_math.py) untuk meluncurkan pelatihan SDPO dari baris perintah. Skrip ini mendukung reward matematika yang dapat diverifikasi, umpan balik lingkungan melalui `--feedback_column`, dan PEFT/LoRA melalui flag standar `ModelConfig`.

```bash
python examples/sdpo_math/sdpo_math.py \
    --model_name_or_path Qwen/Qwen2.5-Math-1.5B-Instruct \
    --dataset_name openai/gsm8k \
    --dataset_config main \
    --output_dir outputs/sdpo-qwen35-2b-gsm8k \
    --learning_rate 5e-5 \
    --dtype bfloat16 \
    --bf16 true \
    --max_completion_length 128 \
    --use_peft \
    --lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj \
    --per_device_train_batch_size 1 \
    --gradient_accumulation_steps 2 \
    --num_generations 8 \
    --generation_batch_size 32 \
    --distillation_alpha 1.0 \
    --distillation_mode sampled_token \
    --distillation_weight 0.5 \
    --report_to none \
    --eval_strategy steps \
    --eval_steps 1000 \
    --save_strategy no
```

## SDPOConfig[[trl.experimental.sdpo.SDPOConfig]]

#### trl.experimental.sdpo.SDPOConfig[[trl.experimental.sdpo.SDPOConfig]]

```python
trl.experimental.sdpo.SDPOConfig(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 = 5e-05, 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 = False, 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] | None = None, trust_remote_code: bool = False, disable_dropout: bool = True, max_prompt_length: int | None = 512, num_generations: int = 8, num_generations_eval: int | None = None, max_completion_length: int | None = 256, ds3_gather_for_generation: bool = True, shuffle_dataset: bool = True, generation_batch_size: int | None = None, steps_per_generation: int | None = None, temperature: float = 1.0, top_p: float = 1.0, top_k: int = 0, min_p: float | None = None, generation_kwargs: dict[str, typing.Any] | None = None, chat_template_kwargs: dict[str, typing.Any] | None = None, repetition_penalty: float = 1.0, cache_implementation: str | None = None, use_vllm: bool = False, use_teacher_server: bool = False, vllm_mode: str = 'colocate', vllm_model_impl: str = 'vllm', vllm_enable_sleep_mode: bool = False, vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8000, vllm_group_port: int = 51216, vllm_server_timeout: float = 240.0, vllm_tensor_parallel_size: int = 1, vllm_gpu_memory_utilization: float = 0.3, vllm_max_model_length: int | None = None, num_iterations: int = 1, loss_type: str = 'dapo', mask_truncated_completions: bool = False, dont_reprompt_on_self_success: bool = True, beta: float = 0.0, epsilon: float = 0.2, epsilon_high: float | None = None, importance_sampling_level: str = 'token', reward_weights: list[float] | None = None, scale_rewards: str = 'group', distillation_alpha: float = 1.0, distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'sampled_token', distillation_topk: int | None = None, distillation_is_clip: float | None = 2.0, distillation_add_tail: bool = False, distillation_weight: float = 1.0, teacher_model_kind: str = 'ema', teacher_update_rate: float = 0.05, teacher_sync_steps: int = 1, max_reprompt_len: int = 10240, use_successful_as_teacher: bool = True, success_reward_threshold: float = 1.0, reprompt_template: str = '{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n', solution_template: str = '\nCorrect solution:\n\n{successful_previous_attempt}\n\n', feedback_template: str = '\nThe following is feedback from your unsuccessful earlier attempt:\n\n{feedback_raw}\n\n', include_environment_feedback: bool = False, environment_feedback_only_without_solution: bool = False, remove_thinking_from_demonstration: bool = False, diagnostics_warning_interval: int = 10, diagnostics_flat_tolerance: float = 1e-08)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/sdpo/sdpo_config.py#L24)

**Parameter yang mengontrol tujuan kebijakan online:**

beta (`float`, *opsional*, default `0.0`) : Koefisien KL. Jika `0.0` (default), model referensi tidak dimuat, sehingga mengurangi penggunaan memori dan meningkatkan kecepatan pelatihan. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning](https://huggingface.co/papers/2501.12948) menggunakan nilai `0.001`.

epsilon (`float`, *opsional*, defaultnya `0.2`) : Nilai epsilon untuk pemotongan (clipping).

epsilon_high (`float`, *opsional*) : Nilai epsilon batas atas untuk pemotongan. Jika tidak ditentukan, nilainya secara default sama dengan nilai batas bawah yang ditentukan dalam argumen `epsilon`. Paper DAPO merekomendasikan `0.28`.

importance_sampling_level (`str`, *opsional*, defaultnya `"token"`) : Mengontrol apakah rasio importance sampling dihitung pada level `'token'` atau `'sequence'`. `'token'` mempertahankan rasio log-probabilitas per token mentah (satu bobot per token). `'sequence'` merata-ratakan rasio log-probabilitas di seluruh token valid untuk menghasilkan satu rasio per sequence. Paper GSPO menunjukkan bahwa sampling level sequence sering kali menghasilkan pelatihan yang lebih stabil dan keselarasan yang lebih baik dengan reward level sequence.

reward_weights (`list[float]`, *opsional*) : Bobot untuk setiap fungsi reward. Harus sesuai dengan jumlah fungsi reward. Jika `None`, semua reward diberi bobot yang sama dengan bobot `1.0`.

scale_rewards (`str` atau `bool`, *opsional*, defaultnya `"group"`) : Menentukan strategi penskalaan untuk reward. Nilai yang didukung adalah: `True` atau `'group'` (default): reward diskalakan berdasarkan simpangan baku di dalam setiap grup, memastikan varians unit di dalam sebuah grup. `'batch'`: reward diskalakan berdasarkan simpangan baku di seluruh batch, seperti yang direkomendasikan dalam paper PPO Lite. `False` atau `'none'`: tidak ada penskalaan yang diterapkan. Paper Dr. GRPO merekomendasikan untuk tidak melakukan penskalaan reward, karena penskalaan berdasarkan simpangan baku memperkenalkan bias tingkat kesulitan per pertanyaan.

**Parameter yang mengontrol loss SDPO:**

distillation_weight (`float`, *opsional*, default `1.0`) : Bobot kombinasi konveks antara tujuan kebijakan dan distilasi diri. Loss-nya adalah `(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss`. Harus berada dalam `[0, 1]`. `1.0` (default) melatih murni dengan distilasi diri, `0.0` kembali ke gradien kebijakan bergaya GRPO standar, dan nilai di antaranya mencampurkan keduanya.

distillation_alpha (`float`, *opsional*, default `1.0`) : Koefisien interpolasi divergensi. SDPO token-terambil memerlukan pengaturan reverse-KL resmi `distillation_alpha=1.0`.

distillation_mode (`Literal["sampled_token", "full_logits", "topk_logits"]`, *opsional*, defaultnya `"sampled_token"`) : Mode tujuan distilasi. `sampled_token` adalah mode SDPO default dan membutuhkan `distillation_alpha=1.0`.

distillation_topk (`int`, *opsional*) : Aproksimasi top-k untuk SDPO pada level logit. Harus diatur ketika `distillation_mode=topk_logits` dan dibiarkan tidak diatur selain itu.

distillation_is_clip (`float`, *opsional*, default `2.0`) : Koefisien pemotongan untuk importance sampling dalam self-distillation. `None` menonaktifkan pemotongan.

distillation_add_tail (`bool`, *opsional*, defaultnya `False`) : Apakah akan menambahkan bucket ekor untuk massa probabilitas non-top-k.

**Parameter yang mengontrol teacher:**

teacher_model_kind (`str`, *opsional*, defaultnya `"ema"`) : Pilihan guru semantik. `base` menggunakan siswa awal, `live` menggunakan siswa saat ini, dan `ema` menggunakan guru yang dirata-rata secara eksponensial.

teacher_update_rate (`float`, *opsional*, default `0.05`) : Laju pembaruan teacher yang digunakan untuk sinkronisasi teacher EMA.

teacher_sync_steps (`int`, *opsional*, defaultnya `1`) : Seberapa sering model guru EMA disinkronkan.

**Parameter yang mengontrol reprompting:**

use_successful_as_teacher (`bool`, *opsional*, defaultnya `True`) : Gunakan rollout yang berhasil sebagai umpan balik implisit untuk self-distillation.

success_reward_threshold (`float`, *opsional*, defaultnya `1.0`) : Reward minimum untuk sebuah rollout agar dianggap sebagai demonstrasi yang berhasil.

dont_reprompt_on_self_success (`bool`, *opsional*, defaultnya `True`) : Lewati permintaan ulang ketika model menghasilkan respons yang benar.

max_reprompt_len (`int`, *opsional*, defaultnya `10240`) : Panjang maksimum untuk reprompting dalam self-distillation.

reprompt_template (`str`, *opsional*, defaultnya `"{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n"`) : Template untuk mem-prompt ulang guru dengan demonstrasi yang berhasil.

solution_template (`str`, *opsional*, defaultnya `"\nCorrect solution : \n\n{successful_previous_attempt}\n\n"`): Template untuk memformat teks demonstrasi yang berhasil.

feedback_template (`str`, *opsional*, defaultnya `"\nThe following is feedback from your unsuccessful earlier attempt : \n\n{feedback_raw}\n\n"`): Template untuk memformat umpan balik lingkungan untuk reprompting.

include_environment_feedback (`bool`, *opsional*, defaultnya `False`) : Apakah akan menyertakan umpan balik lingkungan dalam reprompt guru jika tersedia.

environment_feedback_only_without_solution (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan umpan balik hanya ketika tidak ada solusi yang berhasil tersedia.

remove_thinking_from_demonstration (`bool`, *opsional*, defaultnya `False`) : Apakah akan menghapus ... blok dari teks demonstrasi.

**Parameter yang mengontrol diagnostik:**

diagnostics_warning_interval (`int`, *opsional*, default `10`) : Menerbitkan diagnostik trainer yang berulang setiap N langkah degeneratif berurutan. Atur ke 0 untuk menonaktifkan.

diagnostics_flat_tolerance (`float`, *opsional*, default `1e-8`) : Toleransi yang digunakan untuk menentukan apakah varians reward atau aktivitas reprompt secara efektif nol.

**Parameter yang mengontrol model:**

model_init_kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci untuk `transformers.AutoModelForCausalLM.from_pretrained`, digunakan ketika argumen `model` dari `SDPOTrainer` diberikan sebagai string. Nilai `revision` juga digunakan saat memuat kelas pemrosesan.

trust_remote_code (`bool`, *opsional*, defaultnya `False`) : Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) dan [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained). Juga diterapkan pada pemuatan reward-model dan reward-tokenizer.

disable_dropout (`bool`, *opsional*, defaultnya `True`) : Apakah akan menonaktifkan dropout pada model. Ini berguna untuk pelatihan dengan model referensi, karena mencegah model menghasilkan logprobs yang berbeda untuk input yang sama.

**Parameter yang mengontrol pra-pemrosesan data:**

remove_unused_columns (`bool`, *opsional*, defaultnya `False`) : Apakah hanya kolom 'prompt' yang akan dipertahankan dalam dataset. Jika Anda menggunakan fungsi reward kustom yang memerlukan kolom selain 'prompts' dan 'completions', Anda harus mempertahankan ini sebagai `False`.

max_prompt_length (`int`, *opsional*, defaultnya `512`) : Panjang maksimum prompt. Prompt yang lebih panjang akan dipangkas dari sisi kiri.

shuffle_dataset (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengacak dataset pelatihan.

**Parameter yang mengontrol generasi:**

num_generations (`int`, *opsional*, default `8`) : Jumlah generasi yang akan disampelkan. Ukuran batch efektif (num_processes * per_device_batch_size * gradient_accumulation_steps) harus dapat dibagi habis oleh nilai ini.

num_generations_eval (`int`, *opsional*) : Jumlah generasi yang akan disampelkan selama evaluasi. Hal ini memungkinkan penggunaan lebih sedikit generasi selama evaluasi untuk menghemat komputasi. Jika `None`, menggunakan nilai dari `num_generations`.

max_completion_length (`int`, *opsional*, defaultnya `256`) : Panjang maksimum dari pelengkap yang dihasilkan.

temperature (`float`, *opsional*, default `1.0`) : Suhu untuk sampling. Semakin tinggi suhu, semakin acak hasil pelengkapannya.

top_p (`float`, *opsional*, default `1.0`) : Float yang mengontrol probabilitas kumulatif dari token teratas yang dipertimbangkan. Harus berada dalam rentang (0, 1]. Atur ke 1.0 untuk mempertimbangkan semua token.

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.

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.

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.

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

ds3_gather_for_generation (`bool`, *opsional*, defaultnya `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 dari satu GPU, meskipun dengan biaya kecepatan generasi yang lebih lambat. Menonaktifkan opsi ini tidak kompatibel dengan generasi vLLM.

**Parameter yang mengontrol akselerasi generasi yang didukung oleh vLLM:**

use_vllm (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan vLLM untuk menghasilkan kelengkapan. Jika diatur ke `True`, trainer akan menggunakan vLLM untuk generasi alih-alih model.generate() default. Memerlukan `vllm` terpasang.

use_teacher_server (`bool`, *opsional*, defaultnya `False`) : Hitung logprobs guru dari server generasi vLLM yang berjalan alih-alih dari forward guru lokal. Hanya didukung untuk `teacher_model_kind='live'` dengan `use_vllm=True`, `vllm_mode='server'`, `distillation_weight=1.0` (distilasi murni), dan `distillation_mode` dalam {'sampled_token', 'topk_logits'} (server mengembalikan logprobs top-k dari guru, bukan kosakata penuh; `topk_logits` mendistilasi pada dukungan top-k milik guru itu sendiri).

vllm_mode (`str`, *opsional*, defaultnya `"colocate"`) : Mode yang digunakan untuk integrasi vLLM ketika `use_vllm` diatur ke `True`. Harus salah satu dari `'server'` atau `'colocate'`. `'server'`: Trainer akan mengirim permintaan generasi ke server vLLM yang terpisah. Pastikan server vLLM sedang berjalan (mulai dengan `vllm serve`). `'colocate'`: vLLM akan berjalan dalam proses yang sama dan berbagi GPU pelatihan. Ini menghindari kebutuhan akan server terpisah tetapi dapat menyebabkan perebutan sumber daya dengan pelatihan.

vllm_model_impl (`str`, *opsional*, defaultnya `"vllm"`) : Implementasi model yang akan digunakan untuk vLLM. Harus salah satu dari `transformers` atau `vllm`. `transformers`: Gunakan backend `transformers` untuk implementasi model. `vllm`: Gunakan pustaka `vllm` untuk implementasi model.

vllm_enable_sleep_mode (`bool`, *opsional*, default `False`) : Aktifkan mode tidur vLLM untuk mengoffload bobot/kache selama langkah optimizer. Menjaga penggunaan memori GPU tetap rendah, tetapi membangunkan mesin menambah latensi transfer host–perangkat.

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

vllm_server_host (`str`, *opsional*, defaultnya `"0.0.0.0"`) : Host dari server vLLM untuk dihubungkan. Diabaikan jika vllm_server_base_url disediakan.

vllm_server_port (`int`, *opsional*, defaultnya `8000`) : Port server vLLM untuk terhubung. Diabaikan jika vllm_server_base_url disediakan.

vllm_group_port (`int`, *opsional*, defaultnya `51216`) : Nomor port untuk grup pembaruan bobot. Ini digunakan untuk berkomunikasi dengan server vLLM. Kecuali port tersebut sedang digunakan, tidak perlu diubah.

vllm_server_timeout (`float`, *opsional*, defaultnya `240.0`) : Total durasi timeout dalam detik untuk menunggu server vLLM siap. Jika server belum siap setelah timeout, `ConnectionError` akan dilempar.

vllm_tensor_parallel_size (`int`, *opsional*, defaultnya `1`) : Mengontrol ukuran paralel tensor untuk vLLM. Pengaturan ini hanya berlaku ketika `vllm_mode` diatur ke `'colocate'`. Jika Anda menggunakan `vllm_mode='server'`, parameter ini harus diteruskan secara terpisah saat meluncurkan server vLLM melalui flag `--vllm_tensor_parallel_size`.

vllm_gpu_memory_utilization (`float`, *opsional*, default `0.3`) : Mengontrol pemanfaatan memori GPU untuk vLLM. Pengaturan ini hanya berlaku ketika `vllm_mode` diatur ke `'colocate'`. Jika Anda menggunakan `vllm_mode='server'`, parameter ini harus diteruskan secara terpisah saat meluncurkan server vLLM melalui flag `--vllm_gpu_memory_utilization`.

vllm_max_model_length (`int`, *opsional*) : Context window untuk vLLM. Atur nilainya setidaknya sama dengan panjang prompt maksimum dalam dataset ditambah `max_completion_length`; jika diabaikan, nilainya akan disimpulkan dari konfigurasi model.

**Parameter yang mengontrol pelatihan:**

loss_type (`str`, *opsional*, defaultnya `"dapo"`) : Menentukan formulasi loss yang akan digunakan. Nilai yang didukung adalah 'grpo', 'bnpo', 'dr_grpo', dan 'dapo'. 'grpo': Mengagregasi loss tingkat token dengan menormalisasi berdasarkan panjang sekuens. Tidak disarankan karena bias panjang—pendekatan ini cenderung lebih memilih penyelesaian yang lebih pendek dengan keuntungan positif dan yang lebih panjang dengan keuntungan negatif. 'dapo' (default): Mengagregasi loss tingkat token dengan menormalisasi berdasarkan jumlah token aktif dalam batch global yang terakumulasi. Metode ini diperkenalkan dalam paper DAPO untuk menghilangkan bias panjang. 'dr_grpo': Mengagregasi loss tingkat token dengan menormalisasi menggunakan konstanta global. Metode ini diperkenalkan dalam paper Dr. GRPO untuk menghilangkan bias panjang. Nilai konstanta tersebut sesuai dengan `max_completion_length`. 'bnpo': Mengagregasi loss tingkat token dengan menormalisasi berdasarkan jumlah token aktif dalam batch lokal. Perhatikan bahwa normalisasi hanya dilakukan pada batch lokal, sehingga hasil mungkin sedikit bervariasi tergantung pada ukuran batch lokal, meskipun ukuran batch efektif tetap konstan. Saat menggunakan `per_device_train_batch_size==1`, loss-nya ekuivalen dengan loss GRPO.

num_iterations (`int`, *opsional*, defaultnya `1`) : Jumlah iterasi per batch (dilambangkan sebagai μ dalam algoritma).

generation_batch_size (`int`, *opsional*) : Ukuran batch yang digunakan untuk generasi. Jika `None`, nilainya secara default adalah ukuran batch pelatihan efektif: `per_device_train_batch_size * num_processes * steps_per_generation`.

steps_per_generation (`int`, *opsional*) : Jumlah langkah per generasi. Jika `None`, nilainya secara default adalah `gradient_accumulation_steps`.

mask_truncated_completions (`bool`, *opsional*, defaultnya `False`) : Saat diaktifkan, kelengkapan yang terpotong dikecualikan dari perhitungan loss, sehingga mencegah mereka dihukum secara keliru dan memperkenalkan noise selama pelatihan. Menurut paper DAPO, ini adalah praktik yang baik untuk stabilitas pelatihan.

Kelas konfigurasi untuk [experimental.sdpo.SDPOTrainer](/docs/trl/v1.18.0/id/sdpo_trainer#trl.experimental.sdpo.SDPOTrainer).

## SDPOTrainer[[trl.experimental.sdpo.SDPOTrainer]]

#### trl.experimental.sdpo.SDPOTrainer[[trl.experimental.sdpo.SDPOTrainer]]

```python
trl.experimental.sdpo.SDPOTrainer(model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module], reward_funcs: typing.Any | list[typing.Any] | None = None, args: trl.experimental.sdpo.sdpo_config.SDPOConfig | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, reward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), peft_config = None)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/sdpo/sdpo_trainer.py#L322)

Trainer untuk Self-Distillation Policy Optimization (SDPO).

SDPO meningkatkan optimasi on-policy dengan self-distillation dari trajektori berhadiah tinggi milik model itu sendiri. Metode ini mengubah umpan balik yang ditokenisasi menjadi sinyal pembelajaran yang padat tanpa memerlukan guru eksternal atau model hadiah eksplisit. SDPO memperlakukan model saat ini yang dikondisikan pada umpan balik sebagai self-teacher, lalu mendistilkan prediksi token berikutnya yang diinformasikan umpan balik tersebut kembali ke dalam kebijakan.

#### train[[trl.experimental.sdpo.SDPOTrainer.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.

#### save_model[[trl.experimental.sdpo.SDPOTrainer.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.sdpo.SDPOTrainer.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`.