# SDPO

Self-Distillation Policy Optimization (SDPO) được giới thiệu trong [Reinforcement Learning via Self-Distillation](https://huggingface.co/papers/2601.20802) bởi [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, và Andreas Krause.

> Các mô hình ngôn ngữ lớn ngày càng được huấn luyện hậu (post-train) bằng học tăng cường trong các lĩnh vực có thể kiểm chứng như mã nguồn và toán học. Tuy nhiên, các phương pháp hiện tại cho học tăng cường với phần thưởng có thể kiểm chứng (RLVR) chỉ học từ một phần thưởng kết quả dạng vô hướng cho mỗi lần thử, tạo ra một nút thắt cổ chai nghiêm trọng trong việc gán tín dụng (credit-assignment). Nhiều môi trường có thể kiểm chứng thực tế cung cấp phản hồi văn bản phong phú, chẳng hạn như lỗi thời gian chạy hoặc đánh giá của trọng tài, giải thích lý do tại sao một lần thử thất bại. Chúng tôi chính thức hóa bối cảnh này là học tăng cường với phản hồi phong phú và giới thiệu Tối ưu hóa Chính sách Tự Chưng cất (Self-Distillation Policy Optimization - SDPO), phương pháp chuyển đổi phản hồi đã được token hóa thành tín hiệu học tập dày đặc mà không cần bất kỳ giáo viên bên ngoài hay mô hình phần thưởng rõ ràng nào. SDPO coi mô hình hiện tại có điều kiện dựa trên phản hồi như một giáo viên tự thân và chưng cất các dự đoán token tiếp theo có thông tin phản hồi của nó trở lại chính sách. Bằng cách này, SDPO tận dụng khả năng của mô hình trong việc nhận diện lại các sai sót của chính nó trong ngữ cảnh. Trên các bài toán suy luận khoa học, sử dụng công cụ và lập trình cạnh tranh trên LiveCodeBench v6, SDPO cải thiện hiệu quả mẫu và độ chính xác cuối cùng so với các đường cơ sở RLVR mạnh. Đáng chú ý, SDPO cũng vượt trội hơn các đường cơ sở trong các môi trường RLVR tiêu chuẩn chỉ trả về phản hồi dạng vô hướng bằng cách sử dụng các lượt triển khai thành công làm phản hồi ngầm cho các lần thử thất bại. Cuối cùng, việc áp dụng SDPO cho từng câu hỏi riêng lẻ tại thời điểm kiểm tra (test time) đẩy nhanh quá trình khám phá trên các tác vụ phần thưởng nhị phân khó, đạt được xác suất khám phá tương đương với lấy mẫu best-of-k hoặc hội thoại nhiều lượt với số lần thử ít hơn 3 lần.

## Cách hoạt động

SDPO nhắm đến học tăng cường với phần thưởng có thể kiểm chứng (RLVR), trong đó mỗi lần thử chỉ tạo ra một phần thưởng vô hướng thưa. Nó chuyển đổi điều đó thành tín hiệu dày đặc ở cấp độ token: với mỗi prompt, chính sách lấy mẫu `num_generations` phần hoàn thành được chấm điểm bởi `reward_funcs`, một rollout thành công (cùng với phản hồi `privileged_context` tùy chọn) trở thành một yêu cầu lại từ giáo viên, và phân phối của giáo viên trên một phần hoàn thành, được thông tin bởi phản hồi, được chưng cất ngược lại vào chính sách. Giáo viên và học sinh là cùng một mạng, nên không cần giáo viên bên ngoài hay mô hình phần thưởng nào ngoài bộ kiểm chứng.

## Các chế độ Loss và giáo viên

`distillation_weight` kiểm soát cách hai tín hiệu được kết hợp dưới dạng tổ hợp lồi: loss là `(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss`. `1.0` (mặc định) huấn luyện thuần túy trên loss tự chưng cất, `0.0` quay về gradient chính sách kiểu GRPO tiêu chuẩn, và các giá trị trung gian pha trộn cả hai. Mục tiêu chưng cất bản thân được thiết lập bởi `distillation_mode` — `"sampled_token"` (mặc định) sử dụng reverse KL ở cấp độ token và yêu cầu `distillation_alpha=1.0`, trong khi `"full_logits"` và `"topk_logits"` chưng cất trên toàn bộ hoặc top-`distillation_topk` từ vựng.

`teacher_model_kind` chọn trọng số của teacher: `"ema"` (mặc định) theo dõi student bằng trung bình trượt mũ được đồng bộ mỗi `teacher_sync_steps` bước với tốc độ `teacher_update_rate`, `"live"` tái sử dụng student hiện tại trực tiếp, và `"base"` đóng băng trọng số ban đầu. Việc reprompting được điều khiển bởi `use_successful_as_teacher`, `success_reward_threshold`, `dont_reprompt_on_self_success`, và các chuỗi `reprompt_template` / `solution_template` / `feedback_template`. Quá trình sinh mặc định chạy qua transformers, hoặc vLLM (chế độ colocate hoặc server) khi `use_vllm=True`.

## Các cột dữ liệu tập được kỳ vọng

Mỗi ví dụ phải cung cấp:

- `prompt`: prompt dành cho sinh viên
- `privileged_context`: văn bản đặc quyền tùy chọn, chẳng hạn như phản hồi từ môi trường, được sử dụng khi `include_environment_feedback=True`

## Cách sử dụng

```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 luôn yêu cầu một cột `prompt`. Để sử dụng phản hồi từ môi trường, hãy bao gồm cả cột `privileged_context` và đặt `include_environment_feedback=True`. SDPO sẽ sử dụng các rollout thành công và, khi được bật, văn bản đó để xây dựng các reprompt cho giáo viên phục vụ cho tự chưng cất.

## Phục vụ mô hình teacher từ máy chủ vLLM

Với `teacher_model_kind="live"`, teacher chính là student hiện tại, mà **server** vLLM đã giữ các trọng số của nó (chúng được đồng bộ cho mỗi bước sinh). Đặt `use_teacher_server=True` để tính điểm log-probabilities của teacher trên cùng server đó thay vì chạy một bước forward teacher cục bộ riêng, loại bỏ hoàn toàn teacher khỏi bước huấn luyện:

```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",
)
```

Khi sử dụng máy chủ giáo viên:

- `use_vllm=True` và `vllm_mode="server"` là bắt buộc
- `teacher_model_kind` phải là `"live"` (máy chủ giữ trọng số của học sinh hiện tại)
- `distillation_weight` phải là `1.0` (chỉ dùng distillation; để trộn lồi với policy loss thì cần logits của toàn bộ từ vựng)
- `distillation_mode` phải là `"sampled_token"` (reverse KL trên token thực tế) hoặc `"topk_logits"`. Server trả về top-k log-probs của chính teacher, do đó `topk_logits` sẽ thực hiện distillation trên top-k support của teacher (không thể dùng support của student, khác với local objective); với teacher `"live"`, hai support này gần như trùng khớp. `full_logits` không khả dụng.

## Callbacks

Trainer phát ra một bộ nhỏ các callback hooks hữu ích cho việc gỡ lỗi, quan sát và kiểm thử. Các hook này được thiết kế như những điểm tích hợp thực tế cho các quy trình tự chưng cất (self-distillation) mang tính thử nghiệm.

Các hook tự chưng cất chung:

- `on_self_distillation_batch_prepared`: được kích hoạt khi một batch tự chưng cất đã sẵn sàng. Payload bao gồm `prompt_ids`, `completion_ids` và `old_per_token_logps` khi các đầu vào cho việc cắt xén lấy mẫu quan trọng (importance-sampling clipping) khả dụng.
- `on_generation_batch_built`: được kích hoạt khi một lô sinh có bộ đệm mới được tạo. Nội dung tải bao gồm `generate_every` và `steps_per_generation`.

Hook dành riêng cho SDPO:

- `on_teacher_context_built`: được kích hoạt sau khi SDPO xây dựng các đầu vào có điều kiện từ teacher. Payload bao gồm `teacher_input_ids`, `teacher_attention_mask`, `completion_mask` và `self_distillation_mask`.

## Mẫu script

Sử dụng [`examples/sdpo_math/sdpo_math.py`](https://github.com/huggingface/trl/blob/main/examples/sdpo_math/sdpo_math.py) để khởi động huấn luyện SDPO từ dòng lệnh. Script hỗ trợ phần thưởng toán học có thể kiểm chứng, phản hồi môi trường thông qua `--feedback_column`, và PEFT/LoRA thông qua các cờ chuẩn của `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)
```

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

**Các tham số kiểm soát mục tiêu chính sách trực tuyến:**

beta (`float`, *optional*, mặc định là `0.0`) : Hệ số KL. Nếu `0.0` (mặc định), mô hình tham chiếu sẽ không được nạp, giúp giảm mức sử dụng bộ nhớ và cải thiện tốc độ huấn luyện. [DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning](https://huggingface.co/papers/2501.12948) sử dụng giá trị `0.001`.

epsilon (`float`, *optional*, mặc định là `0.2`) : Giá trị epsilon cho việc cắt (clipping).

epsilon_high (`float`, *optional*) : Giá trị epsilon giới hạn trên để cắt. Nếu không được chỉ định, mặc định sẽ bằng giá trị giới hạn dưới được chỉ định trong tham số `epsilon`. Bài báo DAPO khuyến nghị `0.28`.

importance_sampling_level (`str`, *tuỳ chọn*, mặc định là `"token"`) : Kiểm soát việc tính toán tỷ lệ lấy mẫu quan trọng ở cấp độ `'token'` hay `'sequence'`. `'token'` giữ nguyên các tỷ lệ log-xác suất cho từng token (một trọng số cho mỗi token). `'sequence'` lấy trung bình các tỷ lệ log-xác suất trên các token hợp lệ để tạo ra một tỷ lệ duy nhất cho mỗi chuỗi. Bài báo GSPO cho thấy việc lấy mẫu ở cấp độ chuỗi thường mang lại quá trình huấn luyện ổn định hơn và sự phù hợp tốt hơn với phần thưởng ở cấp độ chuỗi.

reward_weights (`list[float]`, *optional*) : Trọng số cho mỗi hàm phần thưởng. Phải khớp với số lượng các hàm phần thưởng. Nếu là `None`, tất cả các phần thưởng được gán trọng số bằng nhau với trọng số `1.0`.

scale_rewards (`str` hoặc `bool`, *tùy chọn*, mặc định là `"group"`) : Xác định chiến lược chuẩn hóa cho phần thưởng. Các giá trị được hỗ trợ là: `True` hoặc `'group'` (mặc định): phần thưởng được chuẩn hóa theo độ lệch chuẩn trong mỗi nhóm, đảm bảo phương sai đơn vị trong một nhóm. `'batch'`: phần thưởng được chuẩn hóa theo độ lệch chuẩn trên toàn bộ batch, như được khuyến nghị trong bài báo PPO Lite. `False` hoặc `'none'`: không áp dụng chuẩn hóa. Bài báo Dr. GRPO khuyến nghị không chuẩn hóa phần thưởng, vì việc chuẩn hóa theo độ lệch chuẩn sẽ gây ra thiên kiến về độ khó ở cấp độ câu hỏi.

**Các tham số kiểm soát tổn thất SDPO:**

distillation_weight (`float`, *optional*, mặc định là `1.0`) : Trọng số tổ hợp lồi giữa các mục tiêu chính sách và tự phân phối. Tổn thất là `(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss`. Phải nằm trong `[0, 1]`. `1.0` (mặc định) huấn luyện thuần túy bằng tự phân phối, `0.0` quay về gradient chính sách kiểu GRPO tiêu chuẩn, và các giá trị trung gian kết hợp cả hai.

distillation_alpha (`float`, *tuỳ chọn*, mặc định là `1.0`) : Hệ số nội suy phân kỳ. Token SDPO được lấy mẫu yêu cầu cài đặt reverse-KL chính thức `distillation_alpha=1.0`.

distillation_mode (`Literal["sampled_token", "full_logits", "topk_logits"]`, *tuỳ chọn*, mặc định là `"sampled_token"`) : Chế độ mục tiêu chưng cất. `sampled_token` là chế độ SDPO mặc định và yêu cầu `distillation_alpha=1.0`.

distillation_topk (`int`, *optional*) : Xấp xỉ top-k cho SDPO ở cấp độ logit. Phải được đặt khi `distillation_mode=topk_logits` và để trống trong các trường hợp khác.

distillation_is_clip (`float`, *optional*, mặc định là `2.0`) : Hệ số cắt cho lấy mẫu quan trọng trong tự đào tạo. `None` tắt việc cắt.

distillation_add_tail (`bool`, *tùy chọn*, mặc định là `False`) : Có thêm một thùng đuôi cho khối lượng xác suất không thuộc top-k hay không.

**Các tham số kiểm soát giáo viên:**

teacher_model_kind (`str`, *tùy chọn*, mặc định là `"ema"`) : Lựa chọn giáo viên ngữ nghĩa. `base` sử dụng học sinh ban đầu, `live` sử dụng học sinh hiện tại, và `ema` sử dụng giáo viên trung bình mũ.

teacher_update_rate (`float`, *tuỳ chọn*, mặc định là `0.05`) : Tốc độ cập nhật của teacher được sử dụng để đồng bộ hóa teacher EMA.

teacher_sync_steps (`int`, *tuỳ chọn*, mặc định là `1`) : Tần suất đồng bộ hóa mô hình giáo viên EMA.

**Các tham số kiểm soát việc nhắc lại:**

use_successful_as_teacher (`bool`, *tùy chọn*, mặc định là `True`) : Sử dụng các rollout thành công như phản hồi ẩn cho tự phân phối (self-distillation).

success_reward_threshold (`float`, *tuỳ chọn*, mặc định là `1.0`) : Phần thưởng tối thiểu để một rollout được coi là một minh chứng thành công.

dont_reprompt_on_self_success (`bool`, *tùy chọn*, mặc định là `True`) : Bỏ qua việc hỏi lại khi mô hình tạo ra phản hồi chính xác.

max_reprompt_len (`int`, *tuỳ chọn*, mặc định là `10240`) : Độ dài tối đa cho việc nhắc lại (reprompting) trong tự phân phối (self-distillation).

reprompt_template (`str`, *tùy chọn*, mặc định là `"{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n"`) : Mẫu để nhắc lại cho giáo viên với một minh chứng thành công.

solution_template (`str`, *tùy chọn*, mặc định là `"\nCorrect solution : \n\n{successful_previous_attempt}\n\n"`): Mẫu để định dạng văn bản minh họa thành công.

feedback_template (`str`, *tùy chọn*, mặc định là `"\nThe following is feedback from your unsuccessful earlier attempt : \n\n{feedback_raw}\n\n"`): Mẫu để định dạng phản hồi từ môi trường cho việc nhắc lại.

include_environment_feedback (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có bao gồm phản hồi từ môi trường trong các yêu cầu nhắc lại của giáo viên khi có sẵn hay không.

environment_feedback_only_without_solution (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng phản hồi chỉ khi không có giải pháp thành công nào hay không.

remove_thinking_from_demonstration (`bool`, *tùy chọn*, mặc định là `False`) : Có nên loại bỏ các khối ... khỏi văn bản minh họa hay không.

**Các tham số kiểm soát chẩn đoán:**

diagnostics_warning_interval (`int`, *tuỳ chọn*, mặc định là `10`) : Phát ra các chẩn đoán trainer lặp lại mỗi N bước suy thoái liên tiếp. Đặt thành 0 để tắt.

diagnostics_flat_tolerance (`float`, *tùy chọn*, mặc định là `1e-8`) : Độ dung sai được sử dụng để quyết định xem phương sai phần thưởng hay hoạt động reprompt có thực sự bằng không hay không.

**Các tham số kiểm soát mô hình:**

model_init_kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa cho `transformers.AutoModelForCausalLM.from_pretrained`, được sử dụng khi đối số `model` của `SDPOTrainer` được cung cấp dưới dạng chuỗi. Giá trị `revision` cũng được sử dụng khi nạp các lớp xử lý.

trust_remote_code (`bool`, *tùy chọn*, mặc định là `False`) : Cho phép tải các model và tokenizer có kèm theo mã Python tùy chỉnh từ Hub hay không. Tham số này được chuyển tiếp đến [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) và [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained). Nó cũng được áp dụng cho việc tải reward-model và reward-tokenizer.

disable_dropout (`bool`, *tùy chọn*, mặc định là `True`) : Có vô hiệu hóa dropout trong mô hình hay không. Điều này hữu ích khi huấn luyện với một mô hình tham chiếu, vì nó ngăn mô hình tạo ra các logprobs khác nhau cho cùng một đầu vào.

**Các tham số kiểm soát tiền xử lý dữ liệu:**

remove_unused_columns (`bool`, *tùy chọn*, mặc định là `False`) : Có nên chỉ giữ lại cột 'prompt' trong bộ dữ liệu hay không. Nếu bạn sử dụng một hàm thưởng tùy chỉnh yêu cầu bất kỳ cột nào khác ngoài 'prompts' và 'completions', bạn nên giữ giá trị này là `False`.

max_prompt_length (`int`, *tuỳ chọn*, mặc định là `512`) : Độ dài tối đa của prompt. Các prompt dài hơn sẽ bị cắt bỏ từ phía bên trái.

shuffle_dataset (`bool`, *tùy chọn*, mặc định là `True`) : Có trộn (shuffle) bộ dữ liệu huấn luyện hay không.

**Các tham số kiểm soát quá trình sinh:**

num_generations (`int`, *optional*, mặc định là `8`) : Số lượng thế hệ để lấy mẫu. Kích thước lô hiệu dụng (num_processes * per_device_batch_size * gradient_accumulation_steps) phải chia hết cho giá trị này.

num_generations_eval (`int`, *optional*) : Số lượng thế hệ cần lấy mẫu trong quá trình đánh giá. Điều này cho phép sử dụng ít thế hệ hơn trong đánh giá để tiết kiệm tài nguyên tính toán. Nếu là `None`, sẽ sử dụng giá trị của `num_generations`.

max_completion_length (`int`, *tuỳ chọn*, mặc định là `256`) : Độ dài tối đa của phần hoàn thành được tạo ra.

temperature (`float`, *tùy chọn*, mặc định là `1.0`) : Nhiệt độ cho việc lấy mẫu. Nhiệt độ càng cao, các phần hoàn thành càng ngẫu nhiên hơn.

top_p (`float`, *tuỳ chọn*, mặc định là `1.0`) : Giá trị `float` kiểm soát xác suất tích lũy của các token hàng đầu cần xem xét. Phải nằm trong khoảng (0, 1]. Đặt thành 1.0 để xem xét tất cả các token.

top_k (`int`, *optional*, mặc định là `0`) : Số lượng token từ vựng có xác suất cao nhất cần giữ lại cho top-k-filtering. Nếu là `0`, top-k-filtering sẽ bị vô hiệu hóa và tất cả các token đều được xem xét.

min_p (`float`, *optional*) : Xác suất tối thiểu của token, sẽ được nhân với xác suất của token có khả năng cao nhất. Giá trị này phải nằm trong khoảng từ 0.0 đến 1.0. Các giá trị điển hình thường nằm trong khoảng 0.01-0.2.

repetition_penalty (`float`, *optional*, mặc định là `1.0`) : Giá trị số thực để phạt các token mới dựa trên việc chúng có xuất hiện trong prompt và văn bản đã tạo ra cho đến hiện tại hay không. Các giá trị > 1.0 khuyến khích mô hình sử dụng các token mới, trong khi các giá trị < 1.0 khuyến khích mô hình lặp lại các token.

cache_implementation (`str`, *tùy chọn*) : Triển khai phương thức cache để tạo nhanh hơn khi use_vllm được đặt thành False.

generation_kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho `GenerationConfig` (nếu dùng transformers) hoặc `SamplingParams` (nếu dùng vLLM) khi lấy mẫu các câu trả lời hoàn chỉnh. Điều này có thể được dùng để tùy chỉnh thêm hành vi sinh, chẳng hạn như đặt `suppress_tokens`, `num_beams`, v.v. Nếu nó chứa các khóa xung đột với các tham số sinh khác (như `min_p`, `top_p`, v.v.), chúng sẽ ghi đè lên các tham số đó.

chat_template_kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho hàm `apply_chat_template` khi tạo các câu trả lời hoàn chỉnh.

ds3_gather_for_generation (`bool`, *tuỳ chọn*, mặc định là `True`) : Cài đặt này áp dụng cho DeepSpeed ZeRO-3. Nếu được bật, trọng số của mô hình chính sách sẽ được thu thập cho quá trình sinh, giúp tăng tốc độ sinh. Tuy nhiên, việc tắt tuỳ chọn này cho phép huấn luyện các mô hình vượt quá dung lượng VRAM của một GPU đơn lẻ, dù phải đánh đổi bằng tốc độ sinh chậm hơn. Việc tắt tuỳ chọn này không tương thích với sinh bằng vLLM.

**Các tham số kiểm soát tăng tốc sinh nội dung được hỗ trợ bởi vLLM:**

use_vllm (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng vLLM để tạo các câu trả lời hoàn chỉnh hay không. Nếu đặt thành `True`, trình huấn luyện sẽ sử dụng vLLM để tạo thay vì model.generate() mặc định. Yêu cầu `vllm` phải được cài đặt.

use_teacher_server (`bool`, *tuỳ chọn*, mặc định là `False`) : Tính toán logprobs của teacher từ máy chủ sinh vLLM đang chạy thay vì một bước forward cục bộ của teacher. Chỉ được hỗ trợ với `teacher_model_kind='live'` cùng `use_vllm=True`, `vllm_mode='server'`, `distillation_weight=1.0` (chỉ thuần túy distillation), và `distillation_mode` nằm trong {'sampled_token', 'topk_logits'} (máy chủ trả về top-k logprobs của teacher, không phải toàn bộ từ vựng; `topk_logits` thực hiện distillation trên tập top-k riêng của teacher).

vllm_mode (`str`, *tùy chọn*, mặc định là `"colocate"`) : Chế độ sử dụng cho tích hợp vLLM khi `use_vllm` được đặt thành `True`. Phải là một trong `'server'` hoặc `'colocate'`. `'server'`: Trainer sẽ gửi các yêu cầu sinh nội dung đến một máy chủ vLLM riêng biệt. Hãy đảm bảo rằng một máy chủ vLLM đang chạy (khởi động bằng `vllm serve`). `'colocate'`: vLLM sẽ chạy trong cùng tiến trình và chia sẻ các GPU huấn luyện. Điều này tránh được nhu cầu về một máy chủ riêng biệt nhưng có thể gây ra tranh chấp tài nguyên với quá trình huấn luyện.

vllm_model_impl (`str`, *tùy chọn*, mặc định là `"vllm"`) : Bản triển khai mô hình để sử dụng cho vLLM. Phải là một trong `transformers` hoặc `vllm`. `transformers`: Sử dụng backend `transformers` cho bản triển khai mô hình. `vllm`: Sử dụng thư viện `vllm` cho bản triển khai mô hình.

vllm_enable_sleep_mode (`bool`, *tùy chọn*, mặc định là `False`) : Bật chế độ ngủ của vLLM để chuyển tải trọng số/bộ nhớ đệm trong bước tối ưu hóa. Giữ mức sử dụng bộ nhớ GPU thấp, nhưng việc đánh thức engine sẽ thêm độ trễ chuyển dữ liệu giữa host và thiết bị.

vllm_server_base_url (`str`, *tùy chọn*) : URL gốc cho máy chủ vLLM (ví dụ: 'http://localhost:8000'). Nếu được cung cấp, `vllm_server_host` và `vllm_server_port` sẽ bị bỏ qua.

vllm_server_host (`str`, *tùy chọn*, mặc định là `"0.0.0.0"`) : Host của máy chủ vLLM để kết nối. Bỏ qua nếu đã cung cấp vllm_server_base_url.

vllm_server_port (`int`, *tuỳ chọn*, mặc định là `8000`) : Cổng của máy chủ vLLM để kết nối. Bỏ qua nếu đã cung cấp vllm_server_base_url.

vllm_group_port (`int`, *optional*, mặc định là `51216`) : Số cổng cho nhóm cập nhật trọng số. Cổng này được sử dụng để liên lạc với máy chủ vLLM. Trừ khi cổng đang bị chiếm dụng, bạn không cần phải thay đổi nó.

vllm_server_timeout (`float`, *tuỳ chọn*, mặc định là `240.0`) : Tổng thời gian chờ (tính bằng giây) để chờ máy chủ vLLM khởi động. Nếu máy chủ chưa sẵn sàng sau thời gian chờ, một `ConnectionError` sẽ được ném ra.

vllm_tensor_parallel_size (`int`, *optional*, mặc định là `1`) : Kiểm soát kích thước song song tensor cho vLLM. Cài đặt này chỉ áp dụng khi `vllm_mode` được đặt thành `'colocate'`. Nếu bạn đang sử dụng `vllm_mode='server'`, tham số này phải được truyền riêng khi khởi động máy chủ vLLM thông qua cờ `--vllm_tensor_parallel_size`.

vllm_gpu_memory_utilization (`float`, *tuỳ chọn*, mặc định là `0.3`) : Kiểm soát mức sử dụng bộ nhớ GPU cho vLLM. Cài đặt này chỉ áp dụng khi `vllm_mode` được đặt thành `'colocate'`. Nếu bạn đang sử dụng `vllm_mode='server'`, tham số này phải được truyền riêng khi khởi động máy chủ vLLM thông qua cờ `--vllm_gpu_memory_utilization`.

vllm_max_model_length (`int`, *tuỳ chọn*) : Cửa sổ ngữ cảnh cho vLLM. Đặt giá trị này ít nhất bằng độ dài prompt tối đa trong bộ dữ liệu cộng thêm `max_completion_length`; nếu bỏ qua, giá trị sẽ được suy ra từ cấu hình mô hình.

**Các tham số kiểm soát quá trình huấn luyện:**

loss_type (`str`, *tùy chọn*, mặc định là `"dapo"`) : Xác định công thức loss cần sử dụng. Các giá trị được hỗ trợ là 'grpo', 'bnpo', 'dr_grpo' và 'dapo'. 'grpo': Tổng hợp loss ở cấp độ token bằng cách chuẩn hóa theo độ dài chuỗi. Không khuyến nghị do thiên lệch về độ dài—cách tiếp cận này có xu hướng ưu tiên các completion ngắn hơn khi advantage dương và dài hơn khi advantage âm. 'dapo' (mặc định): Tổng hợp loss ở cấp độ token bằng cách chuẩn hóa theo số lượng token hoạt động trong batch tích lũy toàn cục. Phương pháp này được giới thiệu trong bài báo DAPO để loại bỏ thiên lệch về độ dài. 'dr_grpo': Tổng hợp loss ở cấp độ token bằng cách chuẩn hóa theo một hằng số toàn cục. Phương pháp này được giới thiệu trong bài báo Dr. GRPO để loại bỏ thiên lệch về độ dài. Giá trị của hằng số tương ứng với `max_completion_length`. 'bnpo': Tổng hợp loss ở cấp độ token bằng cách chuẩn hóa theo số lượng token hoạt động trong batch cục bộ. Lưu ý rằng việc chuẩn hóa chỉ được thực hiện trên batch cục bộ, do đó kết quả có thể thay đổi nhẹ tùy thuộc vào kích thước batch cục bộ, bất chấp kích thước batch hiệu dụng không đổi. Khi sử dụng `per_device_train_batch_size==1`, loss tương đương với loss GRPO.

num_iterations (`int`, *tuỳ chọn*, mặc định là `1`) : Số lần lặp cho mỗi lô (được ký hiệu là μ trong thuật toán).

generation_batch_size (`int`, *tuỳ chọn*) : Kích thước batch để sử dụng cho quá trình sinh. Nếu là `None`, giá trị mặc định sẽ là kích thước batch huấn luyện hiệu dụng: `per_device_train_batch_size * num_processes * steps_per_generation`.

steps_per_generation (`int`, *tùy chọn*) : Số bước cho mỗi lần sinh. Nếu là `None`, giá trị mặc định sẽ là `gradient_accumulation_steps`.

mask_truncated_completions (`bool`, *tùy chọn*, mặc định là `False`) : Khi được bật, các phần hoàn thành bị cắt ngắn sẽ bị loại khỏi việc tính toán loss, ngăn chúng bị phạt sai và gây nhiễu trong quá trình huấn luyện. Theo bài báo DAPO, đây là một thực hành tốt cho sự ổn định của huấn luyện.

Lớp cấu hình cho [experimental.sdpo.SDPOTrainer](/docs/trl/v1.18.0/vi/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)
```

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

Trainer cho Tối ưu hóa Chính sách Tự phân phối (SDPO).

SDPO tăng cường tối ưu hóa on-policy bằng cách tự chưng cất từ các quỹ đạo phần thưởng cao của chính mô hình. Nó chuyển đổi phản hồi đã được token hóa thành tín hiệu học tập dày đặc mà không cần giáo viên bên ngoài hay mô hình phần thưởng tường minh. SDPO coi mô hình hiện tại có điều kiện theo phản hồi như một giáo viên tự thân và chưng cất các dự đoán token tiếp theo dựa trên phản hồi của nó trở lại chính sách.

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

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

**Tham số:**

resume_from_checkpoint (`str` hoặc `bool`, *tùy chọn*) : Nếu là `str`, đường dẫn cục bộ đến checkpoint đã lưu bởi một phiên `Trainer` trước đó. Nếu là `bool` và bằng `True`, nạp checkpoint cuối cùng trong *args.output_dir* do một phiên `Trainer` trước đó lưu lại. Nếu có, quá trình huấn luyện sẽ tiếp tục từ trạng thái model/optimizer/scheduler được nạp tại đây.

trial (`optuna.Trial` hoặc `dict[str, Any]`, *tùy chọn*) : Chạy thử nghiệm hoặc từ điển siêu tham số cho việc tìm kiếm siêu tham số.

ignore_keys_for_eval (`list[str]`, *tùy chọn*) : Một danh sách các khóa trong đầu ra của mô hình của bạn (nếu nó là một từ điển) cần được bỏ qua khi thu thập các dự đoán để đánh giá trong quá trình huấn luyện.

**Trả về:** `~trainer_utils.TrainOutput`

Đối tượng chứa số bước toàn cục, tổn thất huấn luyện và các chỉ số.

Điểm vào chính cho quá trình huấn luyện.

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

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

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

Sẽ lưu mô hình, để bạn có thể tải lại bằng `from_pretrained()`.

Chỉ lưu từ tiến trình chính.

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

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

**Tham số:**

commit_message (`str`, *tùy chọn*, mặc định là `"End of training"`) : Thông điệp để commit khi đẩy lên.

blocking (`bool`, *tùy chọn*, mặc định là `True`) : Xác định xem hàm có nên chỉ trả về khi `git push` đã hoàn tất hay không.

token (`str`, *tùy chọn*, mặc định là `None`) : Token có quyền ghi để ghi đè lên các đối số gốc của Trainer.

revision (`str`, *tùy chọn*) : Bản sửa git để commit từ. Mặc định là đầu của nhánh "main".

private (`bool`, *tùy chọn*) : Xác định xem có làm cho kho riêng tư khi nó được tạo hay không. Mặc định là `args.hub_private_repo`. Không có hiệu lực nếu kho đã tồn tại.

kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung được truyền đến `~Trainer.create_model_card`.

**Trả về:**

URL của kho lưu trữ nơi mô hình đã được đẩy lên nếu `blocking=False`, hoặc một đối tượng `Future` theo dõi tiến trình của lệnh commit nếu `blocking=True`.

Tải `self.model` và `self.processing_class` lên 🤗 model hub tại repo `self.args.hub_model_id`.

