# SDFT

Fine-Tuning Tự Chưng cất (SDFT) được mô tả trong bài báo [Self-Distillation Enables Continual Learning](https://huggingface.co/papers/2601.19897) của Idan Shenfeld, Mehul Damani, Jonas Hübotter và Pulkit Agrawal.

> Học tập liên tục, cho phép các mô hình thu nhận kỹ năng và kiến thức mới mà không làm suy giảm các khả năng hiện có, vẫn là một thách thức cơ bản đối với các mô hình nền tảng. Trong khi học tăng cường theo chính sách (on-policy reinforcement learning) có thể giảm thiểu sự quên, phương pháp này đòi hỏi các hàm phần thưởng rõ ràng, vốn thường không khả dụng. Học từ các minh chứng của chuyên gia, phương án thay thế chính, bị chi phối bởi tinh chỉnh có giám sát (SFT), vốn mang tính chất ngoại chính sách (off-policy) một cách bản chất. Chúng tôi giới thiệu Tinh chỉnh Tự Phân phối (Self-Distillation Fine-Tuning - SDFT), một phương pháp đơn giản cho phép học tập theo chính sách trực tiếp từ các minh chứng. SDFT tận dụng học trong ngữ cảnh (in-context learning) bằng cách sử dụng mô hình có điều kiện theo minh chứng làm giáo viên của chính nó, tạo ra các tín hiệu huấn luyện theo chính sách giúp bảo toàn các khả năng trước đó trong khi thu nhận kỹ năng mới. Trên các tác vụ học kỹ năng và thu nhận kiến thức, SDFT luôn vượt trội hơn SFT, đạt độ chính xác cao hơn trên tác vụ mới trong khi giảm đáng kể sự quên thảm khốc. Trong các thí nghiệm học tập tuần tự, SDFT cho phép một mô hình duy nhất tích lũy nhiều kỹ năng theo thời gian mà không có sự suy giảm hiệu suất, thiết lập phân phối theo chính sách (on-policy distillation) như một con đường thực tiễn để học tập liên tục từ các minh chứng.

## Cách hoạt động

Fine-tuning giám sát thông thường huấn luyện trên văn bản minh họa theo cách off-policy, điều này có xu hướng ghi đè lên các khả năng trước đó. SDFT thay vào đó học theo on-policy: học sinh tạo ra từ `prompt` thuần túy, một giáo viên — chính là mô hình được xem `prompt` cùng với `privileged_context` của ví dụ — chấm điểm lại các token đó, và phân phối có điều kiện minh họa của nó được chưng cất ngược lại vào học sinh. Giáo viên và học sinh là một mạng duy nhất chỉ khác nhau ở những gì chúng nhìn thấy, tạo thành một vòng lặp chưng cất *tự* thân.

## Chọn giáo viên

`teacher_model_kind` xác định bản sao nào của mô hình đóng vai trò teacher. `"base"` (mặc định) đóng băng trọng số ban đầu làm tham chiếu cố định, khớp với bài báo; `"live"` tái sử dụng student hiện tại làm self-teacher không độ trễ; `"ema"` duy trì trung bình trượt mũ, được đồng bộ lại mỗi `teacher_sync_steps` bước với tỷ lệ `teacher_update_rate`. Trong PEFT, `"base"` được lấy bằng cách vô hiệu hóa adapter trong quá trình forward của teacher để khôi phục trọng số cơ sở, và `"ema"` khi huấn luyện pure-LoRA giữ trung bình trượt trong một adapter `"teacher"` riêng thay vì một bản sao mô hình thứ hai. `"ema"` với mô hình PEFT không phải pure-LoRA (ví dụ `modules_to_save` hoặc `bias`) không được hỗ trợ, vì bản sao EMA riêng biệt không thể khớp tham số với student.

Mặc định, mô hình sinh viên (student) tạo nội dung từ prompt gốc; đặt `generate_from_teacher=True` để lấy mẫu từ prompt có điều kiện bởi bản trình diễn (demonstration) thay thế, đánh đổi độ trung thực on-policy để có các rollout chất lượng cao hơn. Mục tiêu chưng cất (distillation) được thiết lập bởi `distillation_mode` (mặc định là `"topk_logits"`, với các lựa chọn thay thế `"full_logits"` và `"sampled_token"`), `distillation_alpha`, và `distillation_topk`; `num_loss_tokens_to_skip` loại bỏ các token hoàn thành (completion) ở đầu khỏi loss. Quá trình huấn luyện chỉ dùng văn bản; việc tạo nội dung chạy qua transformers theo mặc định, hoặc vLLM (chế độ colocate hoặc server) khi `use_vllm=True`.

## Cách sử dụng

```python
from datasets import Dataset

from trl.experimental.sdft import SDFTConfig, SDFTTrainer

dataset = Dataset.from_dict(
    {
        "prompt": [[{"role": "user", "content": "Solve 2+2."}]],
        "privileged_context": ["Example answer: 4."],
    }
)

training_args = SDFTConfig(
    output_dir="sdft-model",
    distillation_alpha=0.5,
    distillation_mode="topk_logits",
    distillation_topk=5,
    max_completion_length=64,
)

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

Để tạo từ prompt có điều kiện của teacher thay vì prompt của student, hãy đặt `generate_from_teacher=True`. Để tùy chỉnh cách xây dựng prompt của teacher, hãy đặt `teacher_prompt_template` trên [experimental.sdft.SDFTConfig](/docs/trl/v1.18.0/vi/sdft_trainer#trl.experimental.sdft.SDFTConfig).

## 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 = SDFTConfig(
    output_dir="sdft-model",
    use_vllm=True,
    vllm_mode="server",
    teacher_model_kind="live",
    use_teacher_server=True,
    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_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.

## 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`: chỉ bao gồm thông tin bổ sung dành riêng cho giáo viên, chẳng hạn như một ví dụ minh họa, gợi ý hoặc phản hồi đặc quyền

Cả prompt văn bản tiêu chuẩn và prompt hội thoại đều được hỗ trợ bởi cơ chế xử lý prompt của trainer.

## 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 SDFT:

- `on_generation_prompts_selected`: được kích hoạt khi SDFT chọn nguồn prompt cho quá trình tạo on-policy. Payload bao gồm `generation_prompts` đã được chọn và `generation_prompt_text` tương ứng.

## Mẫu script

Sử dụng [`examples/sdft_privileged_context/sdft_privileged_context.py`](https://github.com/huggingface/trl/blob/main/examples/sdft_privileged_context/sdft_privileged_context.py) để khởi động huấn luyện SDFT từ dòng lệnh. Script hỗ trợ bất kỳ causal LM nào từ Hub, các bộ dữ liệu cục bộ tùy chỉnh thông qua `--dataset_path`, và PEFT/LoRA thông qua các cờ chuẩn của `ModelConfig`.

```bash
python examples/sdft_privileged_context/sdft_privileged_context.py \
    --model_name_or_path Qwen/Qwen3.5-0.8B \
    --dataset_name your-org/your-dataset \
    --output_dir outputs/sdft-qwen3.5-0.8b \
    --per_device_train_batch_size 1 \
    --gradient_accumulation_steps 16 \
    --learning_rate 2e-5 \
    --max_prompt_length 1024 \
    --max_completion_length 512 \
    --generate_from_teacher \
    --teacher_model_kind ema \
    --teacher_sync_steps 1 \
    --teacher_update_rate 0.05 \
    --eval_strategy steps \
    --eval_steps 50 \
    --report_to wandb
```

Bản triển khai ban đầu có sẵn tại [idanshen/Self-Distillation](https://github.com/idanshen/Self-Distillation).

## SDFTConfig[[trl.experimental.sdft.SDFTConfig]]

#### trl.experimental.sdft.SDFTConfig[[trl.experimental.sdft.SDFTConfig]]

```python
trl.experimental.sdft.SDFTConfig(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, teacher_model_kind: str = 'base', teacher_update_rate: float = 0.05, teacher_sync_steps: int = 1, distillation_alpha: float = 0.5, distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'topk_logits', distillation_topk: int | None = 100, distillation_is_clip: float | None = 2.0, distillation_add_tail: bool = False, generate_from_teacher: bool = False, teacher_prompt_template: str = '{prompt}\n\n{privileged_context}', num_loss_tokens_to_skip: int = 0)
```

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

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

distillation_alpha (`float`, *tùy chọn*, mặc định là `0.5`) : Hệ số nội suy phân kỳ cho quá trình chưng cất logit top-k của SDFT.

distillation_mode (`Literal["sampled_token", "full_logits", "topk_logits"]`, *tùy chọn*, mặc định là `"topk_logits"`) : Chế độ mục tiêu chưng cất. SDFT mặc định sử dụng chưng cất logit top-k.

distillation_topk (`int`, *tuỳ chọn*, mặc định là `100`) : Số lượng token hàng đầu được sử dụng bởi mục tiêu logit top-k SDFT mặc định.

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.

num_loss_tokens_to_skip (`int`, *tuỳ chọn*, mặc định là `0`) : Số lượng token hoàn thành ban đầu cần loại trừ khỏi tổn thất chưng cất.

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

teacher_model_kind (`str`, *tùy chọn*, mặc định là `"base"`) : Lựa chọn giáo viên ngữ nghĩa cho SDFT. `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`, *optional*, mặc định là `0.05`) : Tốc độ cập nhật EMA được sử dụng khi `teacher_model_kind="ema"`. Giá trị `1.0` giảm cập nhật xuống thành ghi đè cứng, đồng bộ lại giáo viên với trọng số sinh viên hiện tại theo từng chu kỳ.

teacher_sync_steps (`int`, *tuỳ chọn*, mặc định là `1`) : Số bước tối ưu hóa giữa các lần cập nhật giáo viên.

**Các tham số kiểm soát việc tạo điều kiện bởi giáo viên:**

generate_from_teacher (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem việc tạo nội dung theo chính sách (on-policy) có nên sử dụng prompt có điều kiện từ giáo viên thay vì prompt của học sinh hay không.

teacher_prompt_template (`str`, *tùy chọn*, mặc định là `"{prompt}\n\n{privileged_context}"`) : Mẫu được sử dụng để kết hợp prompt của student và privileged context thành prompt của teacher.

**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 `SDFTTrainer` được cung cấp dưới dạng chuỗi. Giá trị `revision` cũng được sử dụng khi nạp 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) cho cả student và teacher.

disable_dropout (`bool`, *tùy chọn*, mặc định là `True`) : Có vô hiệu hóa dropout trong các mô hình student và teacher hay không.

**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ác cột cần thiết cho trainer trong dataset hay không. Giữ giá trị này ở `False` nếu bạn cung cấp các cột bổ sung (chẳng hạn như `privileged_context`) mà trainer cần.

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ợ khi `teacher_model_kind='live'` với `use_vllm=True` và `vllm_mode='server'`, 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:**

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

Lớp cấu hình cho [experimental.sdft.SDFTTrainer](/docs/trl/v1.18.0/vi/sdft_trainer#trl.experimental.sdft.SDFTTrainer).

## SDFTTrainer[[trl.experimental.sdft.SDFTTrainer]]

#### trl.experimental.sdft.SDFTTrainer[[trl.experimental.sdft.SDFTTrainer]]

```python
trl.experimental.sdft.SDFTTrainer(model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module], args: trl.experimental.sdft.sdft_config.SDFTConfig | 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, 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: PeftConfig | None = None)
```

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.0/trl/experimental/sdft/sdft_trainer.py#L206)

Trainer cho tự phân phối chính sách theo kiểu SDFT với các prompt giáo viên rõ ràng.

#### train[[trl.experimental.sdft.SDFTTrainer.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.sdft.SDFTTrainer.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.sdft.SDFTTrainer.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`.

