Hugging Face's logo

TRL documentation

SDPO

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.17.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

SDPO

Self-Distillation Policy Optimization (SDPO) diperkenalkan dalam Reinforcement Learning via Self-Distillation oleh Jonas Hübotter, Frederike Lübeck, Lejs Behric, Anton Baumann, 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 menyampelkan 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

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:

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

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

kelas trl.experimental.sdpo.SDPOConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 5e-05lr_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 = 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 = Falselabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | None = Nonetrust_remote_code: bool = Falsedisable_dropout: bool = Truemax_prompt_length: int | None = 512num_generations: int = 8num_generations_eval: int | None = Nonemax_completion_length: int | None = 256ds3_gather_for_generation: bool = Trueshuffle_dataset: bool = Truegeneration_batch_size: int | None = Nonesteps_per_generation: int | None = Nonetemperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict[str, typing.Any] | None = Nonechat_template_kwargs: dict[str, typing.Any] | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falseuse_teacher_server: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_group_port: int = 51216vllm_server_timeout: float = 240.0vllm_tensor_parallel_size: int = 1vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonenum_iterations: int = 1loss_type: str = 'dapo'mask_truncated_completions: bool = Falsedont_reprompt_on_self_success: bool = Truebeta: float = 0.0epsilon: float = 0.2epsilon_high: float | None = Noneimportance_sampling_level: str = 'token'reward_weights: list[float] | None = Nonescale_rewards: str = 'group'distillation_alpha: float = 1.0distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'sampled_token'distillation_topk: int | None = Nonedistillation_is_clip: float | None = 2.0distillation_add_tail: bool = Falsedistillation_weight: float = 1.0teacher_model_kind: str = 'ema'teacher_update_rate: float = 0.05teacher_sync_steps: int = 1max_reprompt_len: int = 10240use_successful_as_teacher: bool = Truesuccess_reward_threshold: float = 1.0reprompt_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 = Falseenvironment_feedback_only_without_solution: bool = Falseremove_thinking_from_demonstration: bool = Falsediagnostics_warning_interval: int = 10diagnostics_flat_tolerance: float = 1e-08 )

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 mendorong penalaran pada LLM melalui pembelajaran penguatan menggunakan nilai 0.001.
  • epsilon (float, opsional, default 0.2) — Nilai epsilon untuk clipping.
  • epsilon_high (float, opsional) — Nilai epsilon batas atas untuk clipping. 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' menjaga 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 nilai 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 menskalakan 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 self-distillation. Loss-nya adalah (1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss. Harus berada dalam [0, 1]. 1.0 (default) melatih murni dengan self-distillation, 0.0 kembali ke policy gradient bergaya GRPO standar, dan nilai di antaranya mencampurkan keduanya.
  • distillation_alpha (float, opsional, default 1.0) — Koefisien interpolasi divergensi. SDPO token-sampel 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) — Aproximasi top-k untuk SDPO tingkat logit. Harus diatur ketika distillation_mode=topk_logits dan dibiarkan tidak diatur dalam kasus lainnya.
  • distillation_is_clip (float, opsional, default 2.0) — Koefisien clipping untuk importance sampling dalam self-distillation. None menonaktifkan clipping.
  • distillation_add_tail (bool, opsional, default 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, default 1) — Seberapa sering model guru EMA disinkronkan.

Parameter yang mengontrol reprompting

  • use_successful_as_teacher (bool, opsional, default True) — Gunakan rollout yang berhasil sebagai umpan balik implisit untuk self-distillation.
  • success_reward_threshold (float, opsional, defaultnya 1.0) — Reward minimum agar sebuah rollout dianggap sebagai demonstrasi yang berhasil.
  • dont_reprompt_on_self_success (bool, opsional, default True) — Lewati reprompting ketika model menghasilkan respons yang benar.
  • max_reprompt_len (int, opsional, default 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, default 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, default False) — Apakah akan menghapus blok <think>…</think> dari teks demonstrasi.

Parameter yang mengontrol diagnostik

  • diagnostics_warning_interval (int, opsional, default 10) — Keluarkan 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, default False) — Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke from_pretrained dan from_pretrained. Juga diterapkan pada pemuatan reward-model dan reward-tokenizer.
  • disable_dropout (bool, opsional, default 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, default 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 nilai ini sebagai False.
  • max_prompt_length (int, opsional, default 512) — Panjang maksimum prompt. Prompt yang lebih panjang akan dipangkas dari sisi kiri.
  • shuffle_dataset (bool, opsional, default True) — Apakah dataset pelatihan akan diacak.

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 penyelesaian 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 (0, 1]. Atur ke 1.0 untuk mempertimbangkan semua token.
  • 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.
  • min_p (float, opsional) — Probabilitas token minimum, yang akan diskalakan oleh probabilitas token yang paling mungkin. Nilainya harus berada 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 penyelesaian. Ini dapat digunakan untuk lebih menyesuaikan perilaku generasi, seperti mengatur suppress_tokens, num_beams, dll. Jika berisi kunci yang bertentangan dengan parameter generasi lainnya (seperti min_p, top_p, dll.), mereka akan menimpanya.
  • chat_template_kwargs (dict[str, Any], opsional) — Argumen kata kunci tambahan untuk diteruskan ke fungsi apply_chat_template saat menghasilkan kelengkapan.
  • ds3_gather_for_generation (bool, opsional, default True) — Pengaturan ini berlaku untuk DeepSpeed ZeRO-3. Jika diaktifkan, bobot model kebijakan akan dikumpulkan untuk generasi, sehingga meningkatkan kecepatan generasi. Namun, menonaktifkan opsi ini memungkinkan pelatihan model yang melebihi kapasitas VRAM satu GPU, meskipun dengan biaya kecepatan generasi yang lebih lambat. Menonaktifkan opsi ini tidak kompatibel dengan generasi vLLM.

Parameter yang mengontrol akselerasi generasi yang didukung oleh vLLM

  • use_vllm (bool, opsional, default 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, default False) — Hitung logprobs guru dari server generasi vLLM yang berjalan, bukan 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 top-k logprobs guru, bukan kosakata penuh; topk_logits melakukan distilasi pada dukungan top-k milik guru itu sendiri).
  • vllm_mode (str, opsional, default "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 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, default "vllm") — Implementasi model yang 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 memindahkan bobot/cache 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 disediakan, vllm_server_host dan vllm_server_port diabaikan.
  • vllm_server_host (str, opsional, default "0.0.0.0") — Host dari server vLLM yang akan dihubungi. Diabaikan jika vllm_server_base_url disediakan.
  • vllm_server_port (int, opsional, default 8000) — Port server vLLM yang akan dihubungi. Diabaikan jika vllm_server_base_url disediakan.
  • vllm_group_port (int, opsional, default 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, default 240.0) — Durasi total timeout dalam detik untuk menunggu server vLLM siap. Jika server belum siap setelah timeout, ConnectionError akan dilempar.
  • vllm_tensor_parallel_size (int, opsional, default 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 utilisasi 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) — Jendela konteks 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, default 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, default False) — Jika diaktifkan, completion yang terpotong akan dikecualikan dari perhitungan loss, sehingga mencegah mereka dihukum secara tidak tepat dan memperkenalkan noise selama pelatihan. Menurut paper DAPO, ini adalah praktik yang baik untuk stabilitas pelatihan.

Kelas konfigurasi untuk experimental.sdpo.SDPOTrainer.

SDPOTrainer

kelas trl.experimental.sdpo.SDPOTrainer

< >

( model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module]reward_funcs: typing.Any | list[typing.Any] | None = Noneargs: trl.experimental.sdpo.sdpo_config.SDPOConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonereward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)peft_config = None )

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.

latih

< >

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

Parameter

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

Mengembalikan

~trainer_utils.TrainOutput

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

Titik masuk utama pelatihan.

save_model

< >

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

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

Hanya akan menyimpan dari proses utama.

push_to_hub

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = 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”.
  • 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.

Update on GitHub

←SDFT