# Trainer Chưng cất Logit Trực tuyến Chung (GOLD)

[![All_models-GOLD-blue](https://img.shields.io/badge/All_models-GOLD-blue)](https://huggingface.co/models?other=sft,gold)

## Tổng quan

General Online Logit Distillation (GOLD) là một phần mở rộng của Universal Logit Distillation (ULD), hỗ trợ các cặp student/teacher có tokenizer khác nhau. Phương pháp này căn chỉnh các đoạn văn bản (textual spans) do cả hai tokenizer tạo ra và gộp các logits liên quan để không bỏ sót token hoàn thành nào. Điều này cho phép thực hiện chưng cất kiến thức (knowledge distillation) giữa các tokenizer khác nhau, bao gồm cả các họ mô hình hỗn hợp (ví dụ: student LLaMA với teacher Qwen).

Các khả năng chính:

1. **Định vị giữa các tokenizer** – GOLD giải mã tăng dần các token của học sinh và giáo viên, nhóm các đoạn văn có cùng văn bản hiển thị, và gộp các xác suất bên trong mỗi nhóm. Điều này đảm bảo các số hạng tổn thất được tính trên toàn bộ phần hoàn thành ngay cả khi ranh giới token khác nhau.
2. **Thất ích ULD lai** – khi `uld_use_hybrid_loss` được bật, GOLD so sánh trực tiếp các khớp từ vựng chính xác và chuyển sang thất ích ULD xác suất đã sắp xếp ban đầu cho các token không khớp. Điều này cải thiện độ ổn định cho các học sinh có từ vựng chỉ trùng khớp một phần với giáo viên.
3. **Tích hợp liền mạch với GKD** – GOLD kế thừa lịch trình on-policy so với off-policy từ [experimental.gkd.GKDTrainer](/docs/trl/v1.18.1/vi/gkd_trainer#trl.experimental.gkd.GKDTrainer), cho phép bạn kết hợp KD cấp chuỗi, JSD tổng quát và chưng cất cross-tokenizer trong một lần chạy huấn luyện duy nhất.

> [!NOTE]
> GOLD hiện là một phần của namespace `trl.experimental`. Các API có thể thay đổi mà không cần thông báo trong khi tính năng đang được phát triển.

## Mẹo sử dụng

[experimental.gold.GOLDTrainer](/docs/trl/v1.18.1/vi/gold_trainer#trl.experimental.gold.GOLDTrainer) kế thừa từ [SFTTrainer](/docs/trl/v1.18.1/vi/sft_trainer#trl.SFTTrainer) và nhận các bộ dữ liệu giống như các trainer TRL khác (các danh sách tin nhắn theo phong cách ChatML). Các cờ cấu hình quan trọng trong [experimental.gold.GOLDConfig](/docs/trl/v1.18.1/vi/gold_trainer#trl.experimental.gold.GOLDConfig) bao gồm:

* `use_uld_loss` – bật tắt Universal Logit Distillation. Đặt giá trị này thành `True` cho các cấu hình cross-tokenizer.
* `teacher_tokenizer_name_or_path` – bắt buộc khi `use_uld_loss=True`; GOLD sử dụng teacher tokenizer để căn chỉnh các token.
* `uld_use_hybrid_loss`, `uld_hybrid_matched_weight`, `uld_hybrid_unmatched_weight` – bật và gán trọng số cho loss hybrid matched/unmatched.
* `beta`, `lmbda`, `seq_kd` – kế thừa từ [experimental.gkd.GKDConfig](/docs/trl/v1.18.1/vi/gkd_trainer#trl.experimental.gkd.GKDConfig), kiểm soát nội suy JSD tổng quát và tỷ lệ lấy mẫu on-policy.
* `use_privileged_context`, `teacher_prompt_template`, `privileged_context_column` – cho phép teacher xem thêm ngữ cảnh riêng cho từng ví dụ trong khi prompt của student giữ nguyên. Hiện tại tính năng này chỉ giới hạn cho huấn luyện text, off-policy, standard-JSD.
* `num_generations`, `generation_batch_size` – kiểm soát việc tạo rollout được đệm xuyên suốt các cửa sổ tích lũy gradient. `generation_batch_size` là số lượng prompt duy nhất trên mỗi worker cho mỗi bước tối ưu hóa.

Một ví dụ đầu-cuối tối giản:

```python
from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer

train_dataset = load_dataset(
    "HuggingFaceTB/OpenR1-Math-220k-default-verified",
    "all",
    split="train[:1024]",
)

trainer = GOLDTrainer(
    model="meta-llama/Llama-3.2-1B-Instruct",
    teacher_model="Qwen/Qwen2.5-0.5B-Instruct",
    args=GOLDConfig(output_dir="gold-model", use_uld_loss=True, teacher_tokenizer_name_or_path="Qwen/Qwen2.5-0.5B-Instruct"),
    train_dataset=train_dataset,
)
trainer.train()
```

Đối với các quy trình khởi động nhanh, bạn có thể dựa vào các định danh chuỗi như đã minh họa ở trên—trainer sẽ tự động tải model và tokenizer cho bạn. Việc khởi tạo tường minh `AutoModelForCausalLM`, `AutoTokenizer`, hoặc điền dữ liệu vào `GOLDConfig` chỉ được khuyến nghị cho các trường hợp sử dụng nâng cao, nơi bạn cần kiểm soát chi tiết quá trình khởi tạo.

Một cấu hình rõ ràng hơn có thể trông như sau khi bạn cần tùy chỉnh việc tải mô hình, cài đặt tokenizer hoặc các đối số huấn luyện:

```python
from datasets import load_dataset
from trl.experimental.gold import GOLDConfig, GOLDTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

student_name = "meta-llama/Llama-3.2-1B-Instruct"
teacher_name = "Qwen/Qwen2.5-0.5B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(student_name)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(student_name)
teacher_model = AutoModelForCausalLM.from_pretrained(teacher_name)

train_dataset = load_dataset(
    "HuggingFaceTB/Countdown-Task-GOLD",
    "verified_Qwen2.5-0.5B-Instruct",
    split="train",
)

training_args = GOLDConfig(
    output_dir="gold-model",
    per_device_train_batch_size=1,
    teacher_model_name_or_path=teacher_name,
    teacher_tokenizer_name_or_path=teacher_name,
    use_uld_loss=True,
    uld_use_hybrid_loss=True,
)

trainer = GOLDTrainer(
    model=model,
    teacher_model=teacher_model,
    args=training_args,
    processing_class=tokenizer,
    train_dataset=train_dataset,
)
trainer.train()
```

> [!NOTE]
> GOLD đệm một lô sinh thành đầy đủ của cửa sổ optimizer (`per_device_train_batch_size * gradient_accumulation_steps`) và tái sử dụng nó qua các bước tích lũy. Nếu lô cuối cùng không đủ kích thước, GOLD sẽ cảnh báo và bỏ lô cuối đó (`Dropping last batch due to unexpected batch size`). Đặt `dataloader_drop_last=True` để tránh cảnh báo này.

### Kiểu dữ liệu tập dữ liệu dự kiến

GOLD yêu cầu một tập dữ liệu [đối thoại](dataset_formats#conversational) [mô hình hóa ngôn ngữ](dataset_formats#language-modeling), ví dụ:

```python
{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}
```

`GOLDTrainer` giữ lại các tin nhắn thô để bộ sắp xếp ChatML có thể xây dựng các prompt và completions với các ranh giới chính xác.

## Bối cảnh đặc quyền

Privileged-context distillation cung cấp cho teacher thêm thông tin mà student không có sẵn ở thời điểm suy luận. Thêm một cột context vào dataset prompt/completion thông thường, sau đó bật tính năng này một cách rõ ràng:

```python
from datasets import Dataset

dataset = Dataset.from_list(
    [
        {
            "prompt": [{"role": "user", "content": "What caused the outage?"}],
            "completion": [{"role": "assistant", "content": "A timeout change caused the outage."}],
            "privileged_context": "The deployment changed the timeout immediately before errors began.",
        }
    ]
)

args = GOLDConfig(
    output_dir="gold-model",
    lmbda=0.0,
    use_privileged_context=True,
)
```

Student được huấn luyện trên prompt và completion gốc. Theo mặc định, teacher nhận một prompt riêng được xây dựng từ `"{prompt}\n\n{privileged_context}"`, sau đó chấm điểm chính xác completion đó. Với dữ liệu hội thoại, GOLD chỉ viết lại lượt user cuối cùng trước khi áp dụng lại chat template; các lượt system, tool và assistant giữ nguyên không thay đổi. Đặt `teacher_prompt_template` để tùy chỉnh prompt này, và `privileged_context_column` để sử dụng một cột khác thay vì `"privileged_context"`.

Prompt của teacher không bao giờ bị cắt ngắn, do đó hãy đảm bảo nó nằm trong cửa sổ ngữ cảnh của mô hình teacher. Hỗ trợ ban đầu này được cố ý giới hạn ở văn bản, JSD distillation chuẩn off-policy: `lmbda` phải là `0`, và `seq_kd=True`, `use_uld_loss=True`, X-Token KD (`xtoken_loss_type` khác `"none"`), packing, VLMs, và Liger Kernel không được hỗ trợ với privileged context.

## Cách Token Merging Hoạt Động

Khi học sinh và giáo viên sử dụng các tokenizer khác nhau, cùng một văn bản có thể được tách thành các phần khác nhau:

- **Sinh viên**: `"Hugging Face"` → 1 token
- **Giáo viên**: `"Hugging"`, `" Face"` → 2 token

GOLD căn chỉnh các chuỗi này và gộp các xác suất đa-token của teacher thành một phân phối duy nhất có thể so sánh với phân phối đơn-token của student.

### Gộp xác suất

Với một chuỗi token của giáo viên `[token₀, token₁, ..., tokenₖ]` ánh xạ tới một token sinh viên duy nhất, GOLD tính toán:

```
P_merged(y) = P(y | context) × P(token₁ | token₀, context) × ... × P(tokenₖ | ..., context)
```

trong đó:
- `P(y | context)` là phân phối xác suất biên trên tất cả các token từ vựng ở vị trí đầu tiên
- `P(tokenᵢ | ..., context)` là các xác suất có điều kiện **scalar** của các token thực tế đã được tạo ra

**Insight chính**: Chỉ các xác suất có điều kiện của các **token tiếp theo thực tế** được trích xuất dưới dạng các số vô hướng. Phân phối biên đầy đủ tại vị trí đầu tiên sau đó được điều chỉnh bằng cách nhân với các xác suất vô hướng này.

Điều này đảm bảo:
1. **Xác suất liên hợp chính xác** cho chuỗi được tạo ra thực tế (theo quy tắc chuỗi)
2. **Gần hợp lý** cho các token phản thực (được nhân với cùng một khả năng tiếp nối)
3. **Các phân phối chưa chuẩn hóa** giữ nguyên các xác suất tương đối chính xác để tính toán tổn thất ULD

### Ví dụ

Đã cho:
```
P(x₀):         ["HF": 0.6,  "is": 0.3,  "cool": 0.1]
P(x₁ | "HF"):  ["HF": 0.05, "is": 0.9,  "cool": 0.05]
```

Nếu token 0 và 1 được gộp lại, và chuỗi thực tế là `["HF", "is"]`:
```
P_merged("HF")   = 0.6 × 0.9 = 0.54  ✓ (correct joint probability)
P_merged("is")   = 0.3 × 0.9 = 0.27
P_merged("cool") = 0.1 × 0.9 = 0.09
```

Phân phối đã gộp là chưa được chuẩn hóa (tổng bằng 0.81), nhưng đây là chủ đích và đúng cho việc tính toán tổn thất ULD, vốn sử dụng sắp xếp và khoảng cách L1.

## Mẫu script

Sử dụng [`examples/gold_chatbot_arena/gold_chatbot_arena.py`](https://github.com/huggingface/trl/blob/main/examples/gold_chatbot_arena/gold_chatbot_arena.py) để khởi động huấn luyện GOLD từ dòng lệnh. Script hỗ trợ huấn luyện đầy đủ và LoRA thông qua các cờ `ModelConfig` tiêu chuẩn.

```bash
python examples/gold_chatbot_arena/gold_chatbot_arena.py \
    --model_name_or_path meta-llama/Llama-3.2-1B-Instruct \
    --teacher_model_name_or_path Qwen/Qwen2-1.5B-Instruct \
    --dataset_name trl-lib/chatbot_arena_completions \
    --learning_rate 2e-5 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 8 \
    --output_dir gold-model \
    --num_train_epochs 1 \
    --push_to_hub
```

## Huấn luyện Mô hình Ngôn ngữ Thị giác

[experimental.gold.GOLDTrainer](/docs/trl/v1.18.1/vi/gold_trainer#trl.experimental.gold.GOLDTrainer) hỗ trợ chưng cất VLM-to-VLM. Cả mô hình sinh viên và mô hình giáo viên đều phải là mô hình thị giác-ngôn ngữ. Để huấn luyện một VLM, hãy cung cấp một tập dữ liệu có cột `image` (một hình ảnh cho mỗi mẫu) hoặc cột `images` (danh sách các hình ảnh cho mỗi mẫu). Để biết thêm thông tin về cấu trúc tập dữ liệu mong đợi, hãy xem phần [Định dạng tập dữ liệu — Tập dữ liệu thị giác](dataset_formats#vision-datasets).

Khi học sinh và giáo viên chia sẻ cùng kiến trúc và tokenizer (ví dụ: Qwen3-VL-8B sang Qwen3-VL-2B), hàm mất JSD tổng quát chuẩn được áp dụng trực tiếp. Khi chúng có `model_type` khác nhau (ví dụ: Qwen3-VL sang LFM2.5-VL), hãy đặt `use_uld_loss=True` để bật việc căn chỉnh giữa các tokenizer khác nhau thông qua Universal Logit Distillation. Ảnh được xử lý riêng biệt thông qua bộ xử lý của từng mô hình.

```python
from datasets import load_dataset
import torch
from transformers import AutoModelForImageTextToText, AutoProcessor
from trl.experimental.gold import GOLDConfig, GOLDTrainer

student_name = "Qwen/Qwen3-VL-2B-Instruct"
teacher_name = "Qwen/Qwen3-VL-8B-Instruct"

processor = AutoProcessor.from_pretrained(student_name, padding_side="left")
student_model = AutoModelForImageTextToText.from_pretrained(student_name, dtype=torch.bfloat16)
teacher_model = AutoModelForImageTextToText.from_pretrained(teacher_name, dtype=torch.bfloat16)

train_dataset = load_dataset("trl-lib/llava-instruct-mix", split="train")

trainer = GOLDTrainer(
    model=student_model,
    teacher_model=teacher_model,
    args=GOLDConfig(
        output_dir="gold-vlm-model",
        max_length=None,
        teacher_model_name_or_path=teacher_name,
        use_uld_loss=False,
    ),
    train_dataset=train_dataset,
    processing_class=processor,
)
trainer.train()
```

Đối với chưng cất liên họ, đặt `use_uld_loss=True` và `teacher_tokenizer_name_or_path` thành tên mô hình giáo viên.

Sử dụng [`examples/gold_qwen3_vl/gold_qwen3_vl.py`](https://github.com/huggingface/trl/blob/main/examples/gold_qwen3_vl/gold_qwen3_vl.py) để khởi động huấn luyện GOLD VLM từ dòng lệnh:

```bash
# Same-family distillation (JSD loss, vLLM enabled)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name Qwen/Qwen3-VL-2B-Instruct \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct

# Cross-family distillation (ULD loss, local generation)
torchrun --nproc_per_node 8 examples/gold_qwen3_vl/gold_qwen3_vl.py \
    --student_model_name LiquidAI/LFM2.5-VL-1.6B \
    --teacher_model_name Qwen/Qwen3-VL-8B-Instruct \
    --use_uld_loss \
    --no-use_vllm
```

> [!TIP]
> Đối với VLM, `truncation_mode='keep_end'` không được hỗ trợ vì các token hình ảnh nằm trong phần prompt của chuỗi và có thể bị loại bỏ mà không có cảnh báo. Hãy sử dụng `truncation_mode='keep_start'` (mặc định) hoặc đặt `max_length=None` trong [experimental.gold.GOLDConfig](/docs/trl/v1.18.1/vi/gold_trainer#trl.experimental.gold.GOLDConfig). Điều này cho phép mô hình xử lý toàn bộ độ dài chuỗi mà không cắt bớt các token hình ảnh.
>
> ```python
> GOLDConfig(max_length=None, ...)
> ```
>
> Chỉ sử dụng `max_length` khi bạn đã xác minh rằng việc cắt bớt sẽ không xóa các token hình ảnh cho toàn bộ bộ dữ liệu.

> [!NOTE]
> Chưng cất VLM liên kiến trúc yêu cầu `use_uld_loss=True`. Bộ huấn luyện sẽ gây ra lỗi nếu bạn cố gắng chưng cất liên kiến trúc mà không có tổn thất ULD.

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

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

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.1/trl/experimental/gold/gold_trainer.py#L1233)

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

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.1/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.

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

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.1/trl/experimental/gold/gold_trainer.py#L3356)

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

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.1/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.gold.GOLDTrainer.push_to_hub]]

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.1/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`.

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

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

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.1/trl/experimental/gold/gold_config.py#L23)

**Các tham số kiểm soát quá trình tạo và vòng lặp huấn luyện:**

temperature (`float`, *tùy chọn*, mặc định là `0.9`) : 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`, *optional*, mặc định là `0.95`) : Nếu được đặt thành float < 1, chỉ bộ nhỏ nhất gồm các token có xác suất cao nhất, với tổng xác suất bằng hoặc lớn hơn `top_p`, sẽ được giữ lại cho quá trình sinh.

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.

lmbda (`float`, *tuỳ chọn*, mặc định là `0.5`) : Tham số Lambda kiểm soát tỷ lệ dữ liệu của học sinh (tức là tỷ lệ các đầu ra do học sinh tạo ra theo chính sách).

beta (`float`, *optional*, mặc định là `0.5`) : Hệ số nội suy giữa `0.0` và `1.0` của hàm mất mát Generalized Jensen-Shannon Divergence. Khi beta là `0.0`, hàm mất mát là KL divergence. Khi beta là `1.0`, hàm mất mát là Inverse KL Divergence.

max_completion_length (`int`, *tùy chọn*, mặc định là `128`) : Số lượng token tối đa để tạo ra cho mỗi lần hoàn thành.

teacher_model_name_or_path (`str`, *tùy chọn*) : Tên hoặc đường dẫn của mô hình teacher. Nếu là `None`, mô hình teacher sẽ giống với mô hình đang được huấn luyện.

teacher_model_revision (`str` hoặc `None`, *tùy chọn*, mặc định là `None`) : Phiên bản của mô hình teacher (ví dụ: tên nhánh, tag, hoặc commit hash). Nếu là `None`, phiên bản mặc định sẽ được sử dụng.

teacher_model_init_kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa để truyền cho `AutoModelForCausalLM.from_pretrained` khi khởi tạo mô hình teacher từ một chuỗi. Giá trị `revision` cũng được sử dụng khi nạp lớp xử lý của teacher.

teacher_tokenizer_name_or_path (`str`, *tùy chọn*) : Tên hoặc đường dẫn Tokenizer cho mô hình teacher. Nếu là None khi sử dụng ULD loss, sẽ dùng cùng tokenizer với mô hình student (không được khuyến nghị cho việc distillation giữa các tokenizer khác nhau).

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

seq_kd (`bool`, *tùy chọn*, mặc định là `False`) : Tham số Seq_kd kiểm soát việc có thực hiện Sequence-Level KD (có thể xem là FT có giám sát trên đầu ra do teacher tạo ra) hay không.

use_privileged_context (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có điều kiện hóa giáo viên dựa trên ngữ cảnh đặc quyền cho từng ví dụ trong khi giữ nguyên prompt của học viên hay không. Tính năng này chỉ được hỗ trợ cho văn bản, với phương pháp chưng cất JSD chuẩn ngoài chính sách.

teacher_prompt_template (`str`, *tùy chọn*) : Mẫu được sử dụng để xây dựng prompt của teacher. Nó phải chứa `{prompt}` và có thể chứa `{privileged_context}`. Khi `None`, mặc định là `"{prompt}\n\n{privileged_context}"`.

privileged_context_column (`str`, *tùy chọn*, mặc định là `"privileged_context"`) : Cột dữ liệu chứa ngữ cảnh đặc quyền cho từng ví dụ, được sử dụng để xây dựng prompt của teacher.

num_generations (`int`, *tùy chọn*, mặc định là `1`) : Số lượng bản sinh cho mỗi prompt. Mỗi prompt được lặp lại số lần này trong lô sinh.

generation_batch_size (`int` hoặc `None`, *tùy chọn*, mặc định là `None`) : Số lượng prompt duy nhất trên mỗi worker cho mỗi bước tối ưu hóa. Nếu là `None`, giá trị này được tính từ `(per_device_train_batch_size * gradient_accumulation_steps) // num_generations`.

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

use_uld_loss (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng tổn thất Universal Logit Distillation (ULD) thay cho tổn thất Generalized Jensen-Shannon Divergence hay không.

use_extended_uld (`bool`, *tùy chọn*, mặc định là `True`) : Có bật tính năng căn chỉnh ULD mở rộng, sử dụng tokenizer để căn chỉnh và gộp xác suất token giữa các cách phân tách token của học sinh và giáo viên hay không. Khi `True`, trình huấn luyện sẽ tính toán ánh xạ token và gộp xác suất cho các token bị tách; khi `False`, ULD sẽ sử dụng cắt ngắn theo vị trí đơn giản như trong bài báo ULD gốc. Đặt thành `False` cho các tokenizer không phải ByteLevel cũng không phải BPE có byte-fallback (ví dụ: Llama 2).

uld_token_merge_strategy (`str`, *tùy chọn*, mặc định là `"observed"`) : Chiến lược được sử dụng để căn chỉnh logits của câu trả lời và gộp xác suất token trong tổn thất ULD. Với `"observed"`, logits của câu trả lời được cắt tại các vị trí câu trả lời và các token bị tách (khi `use_extended_uld=True`) được gộp bằng cách nhân phân phối biên tại vị trí đầu tiên với các xác suất có điều kiện vô hướng của các token thực tế ở phía sau. Với `"bayesian"`, phần cắt logits của câu trả lời được dịch chuyển sớm một vị trí để `probs[k]` dự đoán `token_ids[k]` (quy tắc chuỗi), và các token bị tách được gộp bằng cách sử dụng phân phối đầy đủ tại vị trí cuối cùng, có điều kiện trên các token tiền tố thực tế, nhân với các xác suất vô hướng của các token trước đó. Việc dịch chuyển căn chỉnh logits được áp dụng bất kể `use_extended_uld` có được bật hay không.

uld_use_hybrid_loss (`bool`, *tuỳ chọn*, mặc định là `False`) : Có sử dụng tổn thất lai kết hợp tổn thất ULD và tổn thất JSD hay không. Khi `True`, tổn thất cuối cùng là sự kết hợp của JSD cho các ánh xạ token đã biết và ULD cho các ánh xạ token chưa biết.

uld_hybrid_matched_weight (`float` hoặc `None`, *tùy chọn*) : Trọng số cho thành phần loss của token khớp khi sử dụng loss hybrid ULD + JSD. Trọng số này nhân với loss JSD được tính trên các token có ánh xạ trực tiếp giữa tokenization của student và teacher. Nếu là `None`, sẽ sử dụng trọng số thích ứng dựa trên mức độ trùng lặp của bảng từ vựng. Phải được đặt cùng với `uld_hybrid_unmatched_weight` (cả hai đều là `None` hoặc cả hai đều là `float`).

uld_hybrid_unmatched_weight (`float` hoặc `None`, *tùy chọn*) : Trọng số cho thành phần loss của token không khớp khi sử dụng loss hybrid ULD + JSD. Trọng số này điều chỉnh loss ULD được tính trên các token không có ánh xạ trực tiếp giữa tokenization của student và teacher. Nếu là `None`, sẽ sử dụng trọng số thích ứng dựa trên mức độ trùng lặp của bảng từ vựng. Phải được đặt cùng với `uld_hybrid_matched_weight` (cả hai đều là `None` hoặc cả hai đều là `float`).

uld_crossentropy_weight (`float`, *tuỳ chọn*, mặc định là `0.0`) : Trọng số cho thành phần loss entropy chéo trong loss ULD. Nếu bằng 0, chỉ sử dụng loss chưng cất ULD.

uld_distillation_weight (`float`, *tùy chọn*, mặc định là `1.0`) : Trọng số cho thành phần loss chưng cất trong ULD loss.

uld_student_temperature (`float`, *tùy chọn*, mặc định là `1.0`) : Nhiệt độ cho logits của student trong tính toán tổn thất ULD.

uld_teacher_temperature (`float`, *tuỳ chọn*, mặc định là `1.0`) : Nhiệt độ cho logits của teacher trong tính toán tổn thất ULD.

uld_skip_student_eos (`bool`, *tùy chọn*, mặc định là `True`) : Có bỏ qua token EOS cho student trong tính toán ULD loss hay không.

uld_skip_teacher_eos (`bool`, *tùy chọn*, mặc định là `True`) : Có bỏ qua token EOS cho teacher trong tính toán ULD loss hay không.

**Các tham số cho KD cross-tokenizer X-Token (https:**

xtoken_loss_type (`str`, *tùy chọn*, mặc định là `"none"`) : Biến thể KD giữa các tokenizer: `"none"` (tắt), `"p_kl"` (KL chiếu), hoặc `"h_kl"` (KL lai với tập chung được nới lỏng). Yêu cầu `teacher_tokenizer_name_or_path` và `xtoken_projection_matrix_path`.

xtoken_projection_matrix_path (`str`, *tùy chọn*) : Đường dẫn đến tệp ma trận chiếu đã tính trước. Bắt buộc khi `xtoken_loss_type != "none"`.

xtoken_temperature (`float`, *tùy chọn*, mặc định là `1.0`) : Nhiệt độ T cho tổn thất KD X-Token; tổn thất được nhân với T² (Hinton 2015).

xtoken_dynamic_scaling (`bool`, *tùy chọn*, mặc định là `True`) : Thang đo KD bằng `stop_gradient(abs(CE) / abs(KD))` cho mỗi microbatch để cân bằng độ lớn của loss (phương trình 7 trong bài báo).

xtoken_uncommon_topk (`int`, *optional*, mặc định là `8192`) : H-KL: giới hạn so sánh L1 không phổ biến đã sắp xếp xuống top-k token cho mỗi bên.

xtoken_vocab_topk (`int`, *tuỳ chọn*, mặc định là `8192`) : P-KL: giới hạn KL xuống top-k token giáo viên toàn cục theo logit tối đa. Tương tác với ma trận chiếu `--top-k`: các token giáo viên nằm ngoài phạm vi của ma trận sẽ nhận được khối lượng học sinh chiếu gần bằng không và chi phối KL, do đó các giá trị nhỏ hơn sẽ tập trung loss vào các token mà học sinh có thể khớp được.

xtoken_kl_weight (`float`, *tùy chọn*, mặc định là `1.0`) : Trọng số cho hạng tử KD X-Token khi `xtoken_dynamic_scaling=False`.

xtoken_ce_scale (`float`, *tùy chọn*, mặc định là `0.1`) : Hệ số tỷ lệ cho số hạng CE trong tổn thất X-Token khi `xtoken_dynamic_scaling=False`.

**Các tham số kiểm soát tích hợp 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 từ mô hình sinh viên hay không. Yêu cầu phải cài đặt `vllm`.

vllm_mode (`str`, *tùy chọn*, mặc định là `"colocate"`) : Chế độ cho tích hợp vLLM của student. Hoặc là `"server"` (kết nối đến một máy chủ vLLM đang chạy) hoặc `"colocate"` (chạy vLLM trong cùng một tiến trình).

vllm_server_host (`str`, *tùy chọn*, mặc định là `"0.0.0.0"`) : Host của máy chủ vLLM cho mô hình sinh viên (nếu `vllm_mode="server"`).

vllm_server_port (`int`, *tuỳ chọn*, mặc định là `8001`) : Cổng của máy chủ vLLM cho mô hình sinh viên (nếu `vllm_mode="server"`).

vllm_server_timeout (`float`, *tuỳ chọn*, mặc định là `240.0`) : Thời gian chờ để kết nối với máy chủ vLLM của student (nếu `vllm_mode="server"`).

vllm_gpu_memory_utilization (`float`, *tuỳ chọn*, mặc định là `0.9`) : mức sử dụng bộ nhớ GPU cho engine vLLM của student được đặt cùng vị trí (nếu `vllm_mode="colocate"`). Khuyến nghị đặt giá trị này ở mức thấp nếu mô hình student và teacher chia sẻ cùng một GPU.

vllm_tensor_parallel_size (`int`, *tuỳ chọn*, mặc định là `1`) : Kích thước song song tensor cho engine vLLM của student được đặt cùng vị trí (nếu `vllm_mode="colocate"`).

vllm_structured_outputs_regex (`str`, *tùy chọn*) : Regex cho đầu ra có cấu trúc của vLLM cho mô hình sinh viên.

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

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

vllm_max_model_length (`int`, *optional*) : Độ dài chuỗi tối đa của mô hình cho engine vLLM colocated khi `vllm_mode="colocate"`. Mặc định là độ dài ngữ cảnh tối đa của mô hình.

vllm_model_impl (`str`, *tùy chọn*, mặc định là `"vllm"`) : Backend triển khai mô hình để sử dụng trong vLLM. Sử dụng `"vllm"` (mặc định) hoặc `"transformers"`.

vllm_sync_frequency (`int`, *tuỳ chọn*, mặc định là `1`) : Tần suất (theo số bước huấn luyện) để đồng bộ trọng số của mô hình học sinh sang engine vLLM. Đặt thành 1 để đồng bộ sau mỗi bước.

vllm_enable_sleep_mode (`bool`, *tùy chọn*, mặc định là `False`) : Bật chế độ ngủ của vLLM để chuyển trọng số/bộ đệm của student ra ngoài 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ị.

**Các tham số kiểm soát ghi log:**

log_completions (`bool`, *tùy chọn*, mặc định là `False`) : Có nên ghi nhật ký một mẫu các cặp (prompt, completion) mỗi `logging_steps` bước hay không. Nếu `rich` được cài đặt, nó sẽ in ra mẫu đó. Nếu ghi nhật ký `wandb` được bật, nó sẽ ghi mẫu đó vào `wandb`.

log_completions_steps (`int`, *tuỳ chọn*, mặc định là `100`) : Số bước giữa các lần ghi log các cặp (prompt, completion). Chỉ được sử dụng nếu `log_completions` được đặt thành `True`.

num_completions_to_print (`int` hoặc `None`, *tùy chọn*) : Số lượng kết quả hoàn thành cần in ra bằng `rich`. Nếu là `None`, tất cả các kết quả hoàn thành sẽ được ghi log.

wandb_log_unique_prompts (`bool`, *tùy chọn*, mặc định là `True`) : Có ghi log các prompt duy nhất lên wandb hay không. Thao tác này sẽ tạo một run mới cho mỗi prompt duy nhất.

callbacks (`list[str]`, *tùy chọn*, mặc định là `[]`) : Các callback cần chạy trong quá trình huấn luyện.

Lớp cấu hình cho [experimental.gold.GOLDTrainer](/docs/trl/v1.18.1/vi/gold_trainer#trl.experimental.gold.GOLDTrainer).

Lớp này chỉ bao gồm các tham số đặc thù cho huấn luyện GOLD. Để xem danh sách đầy đủ các đối số huấn luyện, vui lòng tham khảo tài liệu [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments) và [SFTConfig](/docs/trl/v1.18.1/vi/sft_trainer#trl.SFTConfig).

> [!NOTE]
> Các tham số này có giá trị mặc định khác với [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments): - `learning_rate`: Mặc định là `1e-7` thay vì `5e-5`.

