TRL documentation

Trainer DPO

TRL

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Trainer DPO

Tổng quan

TRL hỗ trợ DPO Trainer để huấn luyện các mô hình ngôn ngữ, như được mô tả trong bài báo Direct Preference Optimization: Your Language Model is Secretly a Reward Model của Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, Chelsea Finn.

Tóm tắt từ bài báo như sau:

Mặc dù các mô hình ngôn ngữ (LM) không giám sát quy mô lớn học được kiến thức thế giới rộng rãi và một số kỹ năng suy luận, việc đạt được kiểm soát chính xác hành vi của chúng là khó khăn do bản chất hoàn toàn không giám sát của quá trình huấn luyện. Các phương pháp hiện có để đạt được khả năng điều khiển như vậy thu thập nhãn của con người về chất lượng tương đối của các bản sinh từ mô hình và tinh chỉnh LM không giám sát để phù hợp với các sở thích này, thường sử dụng học tăng cường từ phản hồi của con người (RLHF). Tuy nhiên, RLHF là một quy trình phức tạp và thường không ổn định, trước tiên khớp một mô hình phần thưởng phản ánh sở thích của con người, sau đó tinh chỉnh LM không giám sát lớn bằng học tăng cường để tối đa hóa phần thưởng ước tính này mà không lệch quá xa khỏi mô hình gốc. Trong bài báo này, chúng tôi giới thiệu một cách tham số hóa mới cho mô hình phần thưởng trong RLHF, cho phép trích xuất chính sách tối ưu tương ứng dưới dạng đóng, cho phép chúng tôi giải quyết bài toán RLHF chuẩn chỉ với một tổn thất phân loại đơn giản. Thuật toán kết quả, mà chúng tôi gọi là Tối ưu hóa Sở thích Trực tiếp (DPO), ổn định, hiệu suất cao và nhẹ về mặt tính toán, loại bỏ nhu cầu lấy mẫu từ LM trong quá trình tinh chỉnh hoặc thực hiện tinh chỉnh siêu tham số đáng kể. Các thí nghiệm của chúng tôi cho thấy DPO có thể tinh chỉnh LM để phù hợp với sở thích của con người tốt bằng hoặc tốt hơn các phương pháp hiện có. Đáng chú ý, tinh chỉnh bằng DPO vượt qua RLHF dựa trên PPO về khả năng kiểm soát cảm xúc của các bản sinh, và đạt hoặc cải thiện chất lượng phản hồi trong tóm tắt và hội thoại một lượt trong khi đơn giản hơn đáng kể về mặt triển khai và huấn luyện.

Phương pháp huấn luyện sau này được đóng góp bởi Kashif Rasul và sau đó được tái cấu trúc bởi Quentin Gallouédec.

Bắt đầu nhanh

Ví dụ này minh họa cách huấn luyện một mô hình ngôn ngữ sử dụng DPOTrainer từ TRL. Chúng ta huấn luyện một mô hình Qwen 3 0.6B trên UltraFeedback dataset.

from trl import DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()

Loại và định dạng bộ dữ liệu mong đợi

DPO yêu cầu một tập dữ liệu preference. DPOTrainer tương thích với cả định dạng tập dữ liệu chuẩn và đối thoại. Khi được cung cấp một tập dữ liệu đối thoại, trainer sẽ tự động áp dụng chat template lên tập dữ liệu đó.

# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}

# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                      "chosen": [{"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
                                 {"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "user", "content": "What color is the sky?"},
                                   {"role": "assistant", "content": "It is green."}]}

Nếu bộ dữ liệu của bạn không ở một trong các định dạng này, bạn có thể tiền xử lý để chuyển đổi nó sang định dạng mong đợi. Dưới đây là một ví dụ với bộ dữ liệu Vezora/Code-Preference-Pairs:

from datasets import load_dataset

dataset = load_dataset("Vezora/Code-Preference-Pairs")


def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["input"]}],
        "chosen": [{"role": "assistant", "content": example["accepted"]}],
        "rejected": [{"role": "assistant", "content": example["rejected"]}],
    }


dataset = dataset.map(preprocess_function, remove_columns=["instruction", "input", "accepted", "ID"])
print(next(iter(dataset["train"])))

{
    "prompt": [{"role": "user", "content": "Create a nested loop to print every combination of numbers [...]"}],
    "chosen": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
    "rejected": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
}

Tìm hiểu sâu hơn về phương pháp DPO

Direct Preference Optimization (DPO) là một phương pháp huấn luyện được thiết kế để căn chỉnh mô hình ngôn ngữ với dữ liệu sở thích. Thay vì các cặp đầu vào – đầu ra có giám sát, mô hình được huấn luyện trên các cặp hoàn thành cho cùng một prompt, trong đó một hoàn thành được ưu tiên hơn hoàn thành còn lại. Mục tiêu trực tiếp tối ưu hóa mô hình để mở rộng khoảng cách giữa các log-likelihood của các hoàn thành được ưu tiên và không được ưu tiên, so với một mô hình tham chiếu, mà không cần một mô hình phần thưởng rõ ràng. Trên thực tế, điều này thường được thực hiện bằng cách kìm hãm likelihood của các hoàn thành không được ưu tiên thay vì tăng likelihood của các hoàn thành được ưu tiên.

Phần này phân tích cách DPO hoạt động trên thực tế, bao gồm các bước chính: xử lý trước và tính toán hàm mất mát.

Tiền xử lý và phân từ

Trong quá trình huấn luyện, mỗi ví dụ được kỳ vọng chứa một prompt cùng với một phần hoàn thành được ưu tiên (chosen) và một phần hoàn thành không được ưu tiên (rejected). Để biết thêm chi tiết về các định dạng được kỳ vọng, xem Định dạng tập dữ liệu. DPOTrainer sẽ tokenize mỗi đầu vào bằng tokenizer của mô hình.

Tính toán tổn thất

dpo_figure

Loss được sử dụng trong DPO được định nghĩa như sau: $\mathcal{L}_{\mathrm{DPO}}(\theta) = -\mathbb{E}_{(x,y^{+},y^{-})}\!\left[\log \sigma\!\left(\beta\Big(\log\frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)}-\log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)}\Big)\right)\right]$

trong đó $x$ là prompt, $y^+$ là phần hoàn thành được ưu tiên và $y^-$ là phần hoàn thành không được ưu tiên. $\pi_{\theta}$ là mô hình chính sách đang được huấn luyện, $\pi_{\mathrm{ref}}$ là mô hình tham chiếu, $\sigma$ là hàm sigmoid, và $\beta > 0$ là siêu tham số kiểm soát cường độ của tín hiệu ưu tiên.

Các loại hàm mất mát

Một số công thức hóa của hàm mục tiêu đã được đề xuất trong tài liệu. Ban đầu, hàm mục tiêu của DPO được định nghĩa như đã trình bày ở trên.

`loss_type=`	Mô tả
`"sigmoid"` (mặc định)	Với dữ liệu ưu tiên, chúng ta có thể huấn luyện một bộ phân loại nhị phân theo mô hình Bradley-Terry và thực tế các tác giả của DPO đề xuất sử dụng tổn thất sigmoid trên khả năng xảy ra đã được chuẩn hóa thông qua `logsigmoid` để huấn luyện một hồi quy logistic.
`"hinge"`	Các tác giả của RSO đề xuất sử dụng hàm mất mát hinge trên độ khả năng đã được chuẩn hóa từ bài báo SLiC. Trong trường hợp này, `beta` là nghịch đảo của biên (margin).
`"ipo"`	Các tác giả của IPO lập luận rằng phép biến đổi logit có thể gây quá khớp và đề xuất sử dụng phép biến đổi đồng nhất để tối ưu hóa sở thích trực tiếp; TRL cung cấp tính năng này dưới dạng `loss_type="ipo"`.
`"exo_pair"`	Các tác giả của EXO đề xuất tối ưu hóa sở thích reverse-KL. `label_smoothing` phải lớn hơn nghiêm ngặt `0.0`; giá trị được khuyến nghị là `1e-3` (xem Eq. 16 cho biến thể pairwise đơn giản hóa). Phương pháp đầy đủ sử dụng `K>2` hoàn thành SFT và tiến gần đến PPO khi `K` tăng lên.
`"nca_pair"`	Các tác giả của NCA cho thấy NCA tối ưu hóa khả năng tuyệt đối cho mỗi phản hồi thay vì khả năng tương đối.
`"robust"`	Các tác giả của Robust DPO đề xuất một hàm mất DPO không thiên lệch dưới các sở thích nhiễu. Sử dụng `label_smoothing` trong DPOConfig để mô hình hóa xác suất đảo nhãn; các giá trị hợp lệ nằm trong khoảng `[0.0, 0.5)`.
`"bco_pair"`	Các tác giả của BCO huấn luyện một bộ phân loại nhị phân mà logit của nó đóng vai trò là phần thưởng, sao cho bộ phân loại ánh xạ các cặp {prompt, completion được chọn} sang 1 và các cặp {prompt, completion bị từ chối} sang 0.
`"sppo_hard"`	Các tác giả của SPPO khẳng định rằng SPPO có khả năng giải cân bằng Nash một cách lặp lại bằng cách đẩy phần thưởng được chọn lên gần 1/2 và phần thưởng bị từ chối xuống gần -1/2, đồng thời có thể giảm thiểu các vấn đề về độ thưa của dữ liệu. Việc triển khai xấp xỉ thuật toán này bằng cách sử dụng xác suất nhãn cứng, gán giá trị 1 cho bên thắng và 0 cho bên thua.
`"aot"` hoặc `loss_type="aot_unpaired"`	Các tác giả của AOT đề xuất Phân bố Ưu tiên Căn chỉnh thông qua Vận chuyển Tối ưu. `loss_type="aot"` dành cho dữ liệu ghép cặp; `loss_type="aot_unpaired"` dành cho dữ liệu không ghép cặp. Cả hai đều thực thi sự thống trị ngẫu nhiên thông qua các phân vị đã sắp xếp; kích thước lô (batch) trên mỗi GPU lớn hơn sẽ giúp ích.
`"apo_zero"` hoặc `loss_type="apo_down"`	Phương pháp APO giới thiệu một mục tiêu neo. `apo_zero` tăng trọng số cho các trường hợp thắng và giảm trọng số cho các trường hợp thua (hữu ích khi mô hình hoạt động kém hơn các trường hợp thắng). `apo_down` giảm trọng số cho cả hai, với áp lực mạnh hơn lên các trường hợp thua (hữu ích khi mô hình đã vượt trội hơn các trường hợp thắng).
`"discopop"`	Bài báo DiscoPOP sử dụng LLM để khám phá các hàm mất (loss) tối ưu hóa sở thích ngoại tuyến hiệu quả hơn. Trong bài báo, hàm mất DiscoPOP được đề xuất (một hàm mất được điều biến bằng log-ratio) đã vượt trội hơn các hàm mất tối ưu hóa khác trên các tác vụ khác nhau (sinh văn bản tích cực IMDb, tóm tắt TLDR Reddit, và Alpaca Eval 2.0).
`"sft"`	Mất SFT (Supervised Fine-Tuning) là mất log likelihood âm, được sử dụng để huấn luyện mô hình tạo ra các phản hồi được ưu tiên.
`"sigmoid_norm"`	Các tác giả của SimPO giải quyết vấn đề thiên lệch về độ dài trong hàm mất mát sigmoid gốc bằng cách chuẩn hóa theo số lượng token không bị mask; TRL cung cấp tính năng này dưới dạng `loss_type="sigmoid_norm"`.
`"udpo"`	Các tác giả của UDPO đề xuất một tổn thất DPO không thiên lệch dưới các sở thích nhiễu, mà, khác với `"robust"`, vẫn không thiên lệch khi xác suất đảo ngược bị ước lượng quá cao. Sử dụng `label_smoothing` trong DPOConfig để đặt xác suất đảo ngược ε; các giá trị hợp lệ nằm trong khoảng `[0.0, 0.5)`.

Các chỉ số được ghi log

Trong quá trình huấn luyện và đánh giá, chúng ta ghi lại các chỉ số sau:

global_step: Tổng số bước tối ưu hóa đã thực hiện cho đến nay.
epoch: Số epoch hiện tại, dựa trên việc lặp qua tập dữ liệu.
num_tokens: Tổng số token đã được xử lý cho đến hiện tại.
loss: Mất DPO trung bình trong khoảng thời gian ghi log hiện tại.
entropy: Entropy trung bình của phân phối token dự đoán của mô hình trên các token không bị mask.
aux_loss: Tổn phụ trợ cân bằng tải của mô hình Mixture-of-Experts, trước khi được nhân với router_aux_loss_coef và cộng vào tổn. Chỉ được ghi log khi mô hình là mô hình MoE và router_aux_loss_coef khác không.
mean_token_accuracy: Tỷ lệ các token không bị mask mà dự đoán top-1 của mô hình khớp với token từ phần hoàn thành được chọn.
learning_rate: Tốc độ học hiện tại, có thể thay đổi động nếu sử dụng trình lập lịch.
grad_norm: Chuẩn L2 của các gradient, được tính trước khi cắt gradient.
logits/chosen: Giá trị logit trung bình mà mô hình gán cho các token trong phần hoàn thành được chọn.
logits/rejected: Giá trị logit trung bình mà mô hình gán cho các token trong phần hoàn thành bị từ chối.
logps/chosen: Xác suất log trung bình mà mô hình gán cho các token trong phần hoàn thành được chọn.
logps/rejected: Xác suất log trung bình mà mô hình gán cho các token trong phần hoàn thành bị từ chối.
rewards/chosen: Phần thưởng ẩn trung bình được tính cho phần hoàn thành được chọn, được tính bằng $\beta \log \frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)}$ .
rewards/rejected: Phần thưởng trung bình ẩn được tính cho phần hoàn thành bị từ chối, được tính bằng $\beta \log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)}$ .
rewards/margins: Biên độ phần thưởng ẩn trung bình giữa các câu trả lời được chọn và bị từ chối.
rewards/accuracies: Tỷ lệ các ví dụ mà phần thưởng ngầm (implicit reward) cho phần hoàn thành được chọn cao hơn so với phần hoàn thành bị từ chối.

Tùy chỉnh

Tương thích và ràng buộc

Một số tổ hợp tham số bị hạn chế có chủ đích trong triển khai DPOTrainer hiện tại:

use_weighting=True không được hỗ trợ với loss_type="aot" hoặc loss_type="aot_unpaired".
PEFT adapters nhắm vào lm_head không được hỗ trợ (hãy dùng modules_to_save=["lm_head"] thay thế).
sync_ref_model=True không được hỗ trợ khi huấn luyện với các mô hình PEFT không giữ một ref_model độc lập.
sync_ref_model=True không thể kết hợp với precompute_ref_log_probs=True.
precompute_ref_log_probs=True không được hỗ trợ với IterableDataset (train hoặc eval).

Các tổ hợp nhiều hàm mất

Trainer DPO hỗ trợ kết hợp nhiều hàm mất mát với các trọng số khác nhau, cho phép áp dụng các chiến lược tối ưu hóa tinh vi hơn. Tính năng này đặc biệt hữu ích khi triển khai các thuật toán như MPO (Mixed Preference Optimization). MPO là một phương pháp huấn luyện kết hợp nhiều mục tiêu tối ưu hóa, như được mô tả trong bài báo Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization.

Để kết hợp nhiều hàm mất mát, hãy chỉ định các loại mất mát và trọng số tương ứng dưới dạng danh sách:

# MPO: Combines DPO (sigmoid) for preference and BCO (bco_pair) for quality
training_args = DPOConfig(
    loss_type=["sigmoid", "bco_pair", "sft"],  # loss types to combine
    loss_weights=[0.8, 0.2, 1.0]  # corresponding weights, as used in the MPO paper
)

Khởi tạo mô hình

Bạn có thể truyền trực tiếp các kwargs của phương thức from_pretrained() vào DPOConfig. Ví dụ, nếu bạn muốn tải một mô hình ở độ chính xác khác, tương tự như

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)

Bạn có thể thực hiện điều này bằng cách truyền đối số model_init_kwargs={"dtype": torch.bfloat16} vào DPOConfig.

from trl import DPOConfig

training_args = DPOConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)

Lưu ý rằng tất cả các đối số từ khóa của from_pretrained() đều được hỗ trợ.

Huấn luyện adapter với PEFT

Chúng tôi hỗ trợ tích hợp chặt chẽ với thư viện 🤗 PEFT, cho phép bất kỳ người dùng nào thuận tiện huấn luyện các adapter và chia sẻ chúng trên Hub, thay vì phải huấn luyện toàn bộ mô hình.

from datasets import load_dataset
from trl import DPOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

Bạn cũng có thể tiếp tục huấn luyện PeftModel của mình. Để làm điều đó, trước tiên hãy tải một PeftModel bên ngoài DPOTrainer và truyền nó trực tiếp cho trainer mà không truyền đối số peft_config.

from datasets import load_dataset
from trl import DPOTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

Khi huấn luyện adapter, bạn thường sử dụng tốc độ học cao hơn (≈1e‑5) so với fine-tuning toàn bộ vì chỉ có các tham số mới được học.
DPOConfig(learning_rate=1e-5, ...)

Thử nghiệm nhanh cho DPO

RapidFire AI là một công cụ thử nghiệm mã nguồn mở nằm trên TRL, cho phép bạn khởi chạy nhiều cấu hình DPO cùng lúc, ngay cả trên một GPU duy nhất. Thay vì thử các cấu hình theo tuần tự, RapidFire cho phép bạn xem trước các đường cong học tập của tất cả chúng, dừng các lần chạy kém hiệu suất và nhân bản các lần chạy triển vọng với cài đặt mới trong khi đang chạy mà không cần khởi động lại. Để biết thêm thông tin, xem Tích hợp RapidFire AI.

Huấn luyện với Unsloth

Unsloth là một framework mã nguồn mở để fine-tuning và reinforcement learning, giúp huấn luyện các LLM (như Llama, Mistral, Gemma, DeepSeek, và nhiều hơn) nhanh hơn tới 2 lần với lượng VRAM giảm tới 70%, đồng thời cung cấp quy trình làm việc tối giản, tương thích với Hugging Face cho việc huấn luyện, đánh giá và triển khai. Để biết thêm thông tin, xem Tích hợp Unsloth.

Gọi công cụ với DPO

DPOTrainer hỗ trợ đầy đủ việc tinh chỉnh mô hình có khả năng tool calling. Trong trường hợp này, mỗi ví dụ trong bộ dữ liệu nên bao gồm:

Các tin nhắn hội thoại (prompt, chosen và rejected), bao gồm các cuộc gọi công cụ (tool_calls) và phản hồi công cụ (tin nhắn có vai trò tool)
Danh sách các công cụ khả dụng trong cột tools, thường được cung cấp dưới dạng schema JSON

Để biết chi tiết về cấu trúc bộ dữ liệu mong đợi, hãy xem phần Định dạng Dataset — Tool Calling.

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

DPOTrainer hỗ trợ đầy đủ việc huấn luyện các Mô hình Ngôn ngữ - Thị giác (VLM). Để 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. Một ví dụ về tập dữ liệu như vậy là tập dữ liệu RLAIF-V Dataset.

from trl import DPOConfig, DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=DPOConfig(max_length=None),
    train_dataset=load_dataset("HuggingFaceH4/rlaif-v_formatted", split="train"),
)
trainer.train()

Đối với VLM, việc cắt ngắn có thể loại bỏ các token hình ảnh, dẫn đến lỗi trong quá trình huấn luyện. Để tránh điều này, hãy đặt max_length=None trong DPOConfig. Điều này cho phép mô hình xử lý độ dài chuỗi đầy đủ mà không cắt ngắn các token hình ảnh.
DPOConfig(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 loại bỏ các token hình ảnh cho toàn bộ bộ dữ liệu.

DPOTrainer

lớp trl.DPOTrainer

< source >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.dpo_config.DPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

Tham số

model (str hoặc PreTrainedModel hoặc PeftModel) — Mô hình cần huấn luyện. Có thể là:
- Một chuỗi, là model id của một model được huấn luyện trước lưu trữ trong một model repo trên huggingface.co, hoặc một đường dẫn đến một thư mục chứa các trọng số model được lưu bằng save_pretrained, ví dụ: './my_model_directory/'. Model được nạp bằng <ModelArchitecture>.from_pretrained (trong đó <ModelArchitecture> được suy ra từ cấu hình model) với các tham số từ khóa trong args.model_init_kwargs. Nếu dtype không được chỉ định trong args.model_init_kwargs, giá trị mặc định sẽ là float32. Điều này khác với from_pretrained, nơi mà (từ Transformers v5) dtype được suy ra từ cấu hình model.
- Một đối tượng PreTrainedModel. Chỉ hỗ trợ các mô hình ngôn ngữ nhân quả.
- Một đối tượng PeftModel. Chỉ hỗ trợ các mô hình ngôn ngữ nhân quả.
ref_model (PreTrainedModel, tùy chọn) — Mô hình tham chiếu được sử dụng để tính toán các log xác suất tham chiếu. Nếu được cung cấp, mô hình này sẽ được sử dụng trực tiếp làm chính sách tham chiếu. Nó không thể là một PeftModel. Nếu là None, trainer sẽ tự động sử dụng chính sách ban đầu tương ứng với model, tức là trạng thái mô hình trước khi bắt đầu huấn luyện DPO.
- Nếu được cung cấp, mô hình này được sử dụng trực tiếp làm chính sách tham chiếu. Nó không thể là PeftModel.
- Nếu None, trainer sẽ tự động sử dụng chính sách ban đầu tương ứng với model, tức là trạng thái mô hình trước khi bắt đầu huấn luyện DPO.
args (DPOConfig, tùy chọn) — Cấu hình cho trainer này. Nếu là None, một cấu hình mặc định sẽ được sử dụng.
data_collator (DataCollator, tùy chọn) — Hàm được sử dụng để tạo một batch từ danh sách các phần tử của train_dataset hoặc eval_dataset đã được xử lý. Mặc định sẽ là DataCollatorForPreference nếu mô hình là mô hình ngôn ngữ và DataCollatorForVisionPreference nếu mô hình là mô hình thị giác-ngôn ngữ. Các collator tùy chỉnh phải cắt ngắn các chuỗi trước khi đệm; trainer không áp dụng việc cắt ngắn sau khi collate.
train_dataset (Dataset hoặc IterableDataset) — Dataset dùng cho huấn luyện. Trainer này hỗ trợ cả language modeling và prompt-completion . Định dạng của các mẫu có thể là:
- Chuẩn: Mỗi mẫu chứa văn bản thuần túy.
- Conversational: Mỗi mẫu chứa các tin nhắn có cấu trúc (ví dụ: role và content).
Khi train_dataset là một IterableDataset (ví dụ: một dataset dạng streaming), max_steps phải được cài đặt trong các đối số huấn luyện, vì độ dài của nó không thể suy ra được và tổng số bước huấn luyện là cần thiết để giới hạn vòng lặp huấn luyện và cấu hình trình lập lịch tốc độ học.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict hoặc dict[str, Dataset | IterableDataset]) — Dataset được sử dụng để đánh giá. Nó phải đáp ứng các yêu cầu tương tự như train_dataset.
processing_class (PreTrainedTokenizerBase hoặc ProcessorMixin, tùy chọn) — Lớp xử lý được dùng để xử lý dữ liệu. Bên đệm (padding side) phải được đặt là “left”. Nếu None, lớp xử lý sẽ được tải từ tên mô hình bằng from_pretrained. Một token đệm, tokenizer.pad_token, phải được đặt. Nếu lớp xử lý chưa đặt token đệm, tokenizer.eos_token sẽ được dùng làm mặc định.
compute_metrics (Callable[[EvalPrediction], dict], tùy chọn) — Hàm sẽ được sử dụng để tính các chỉ số đánh giá. Hàm này phải nhận một EvalPrediction và trả về một từ điển ánh xạ từ chuỗi sang giá trị chỉ số. Khi truyền SFTConfig với batch_eval_metrics được đặt thành True, hàm compute_metrics của bạn phải nhận một đối số boolean compute_result. Đối số này sẽ được kích hoạt sau batch đánh giá cuối cùng để báo hiệu rằng hàm cần tính toán và trả về các thống kê tổng hợp toàn cục thay vì tích lũy các thống kê ở cấp độ batch. Các logits mà hàm nhận được sẽ được tính lại bằng một bước forward bổ sung. Tính năng này đã bị ngừng hỗ trợ và sẽ bị loại bỏ trong v2.0.0.
callbacks (danh sách TrainerCallback, tùy chọn) — Danh sách các callback để tùy chỉnh vòng lặp huấn luyện. Những callback này sẽ được thêm vào danh sách các callback mặc định được mô tả chi tiết tại đây.
Nếu bạn muốn xóa một trong các callback mặc định đang được sử dụng, hãy dùng phương thức remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], tùy chọn, mặc định là (None, None)) — Một tuple chứa optimizer và scheduler cần sử dụng. Mặc định sẽ là một instance của AdamW trên model của bạn và một scheduler được cung cấp bởi get_linear_schedule_with_warmup được điều khiển bởi args.
quantization_config (BitsAndBytesConfig, tuỳ chọn) — Cấu hình lượng tử hóa được sử dụng khi tải mô hình từ một định danh mô hình. Kết hợp với peft_config cho huấn luyện QLoRA. Bị bỏ qua nếu mô hình đã được khởi tạo.
peft_config (PeftConfig, tùy chọn) — Cấu hình PEFT được sử dụng để bọc model. Nếu là None, model sẽ không được bọc.

Trainer cho phương pháp Tối ưu hóa Sở thích Trực tiếp (DPO). Thuật toán này ban đầu được đề xuất trong bài báo Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Lớp này là một lớp bao quanh lớp Trainer và kế thừa tất cả các thuộc tính và phương thức của nó.

Ví dụ:

>>> from trl import DPOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

>>> trainer = DPOTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

train

< source >

Tham số

resume_from_checkpoint (str hoặc bool, tùy chọn) — Nếu là str, đường dẫn cục bộ đến một checkpoint đã lưu bởi một phiên Trainer trước đó. Nếu là bool và bằng True, tải 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 tải ở đây.
trial (optuna.Trial hoặc dict[str, Any], tùy chọn) — Lầ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 đó 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

< source >

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

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

< source >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = None**kwargs )

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ó 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 args gốc của Trainer.
revision (str, tùy chọn) — Phiên bản git để commit từ. Mặc định là đầu của nhánh “main”.
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.

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

DPOConfig

lớp trl.DPOConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: list[str] = <factory>loss_weights: list[float] | None = Noneld_alpha: float | None = Nonef_divergence_type: str = 'reverse_kl'f_alpha_divergence_coef: float = 0.5label_smoothing: float = 0.0beta: float = 0.1use_weighting: bool = Falsediscopop_tau: float = 0.05activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512pad_token: str | None = None )

Các tham số điều khiển mô hình

model_init_kwargs (dict[str, Any], tùy chọn) — Các đối số dạng từ khóa cho from_pretrained, được sử dụng khi đối số model của DPOTrainer đượ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) — Có 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 và from_pretrained.
router_aux_loss_coef (float, tùy chọn) — Hệ số của tổn thất phụ cân bằng tải cho các mô hình Mixture-of-Experts (MoE), được cộng vào tổn thất huấn luyện với trọng số này. Khi không được đặt, giá trị được khai báo trong cấu hình mô hình sẽ được sử dụng. Đặt thành 0.0 để tắt nó. Gặp lỗi khi sử dụng với mô hình không phải MoE.
disable_dropout (bool, tùy chọn, mặc định là True) — Có vô hiệu hóa dropout trong mô hình và mô hình tham chiếu hay không.

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

dataset_num_proc (int, tùy chọn) — Số lượng tiến trình được sử dụng để xử lý tập dữ liệu.
max_length (int hoặc None, tùy chọn, mặc định là 1024) — Độ dài tối đa của chuỗi đã được token hóa. Các chuỗi dài hơn max_length sẽ bị cắt bớt từ bên trái hoặc bên phải tùy thuộc vào truncation_mode. Nếu là None, sẽ không áp dụng cắt bớt.
truncation_mode (str, tùy chọn, mặc định là "keep_start") — Chế độ cắt ngắn được sử dụng khi chuỗi vượt quá max_length. Giá trị duy nhất được hỗ trợ là "keep_start". Giá trị "keep_end" đã bị ngừng hỗ trợ và sẽ bị loại bỏ trong v2.0.0.
padding_free (bool, tùy chọn, mặc định là False) — Xác định có thực hiện các bước truyền tiến (forward passes) mà không có padding bằng cách làm phẳng tất cả các chuỗi trong batch thành một chuỗi liên tục duy nhất hay không. Điều này giúp giảm mức sử dụng bộ nhớ bằng cách loại bỏ chi phí do padding gây ra. Hiện tại, tính năng này chỉ được hỗ trợ với FlashAttention 2 hoặc 3, vốn có thể xử lý hiệu quả cấu trúc batch đã được làm phẳng. Tạm thời không khả dụng: kể từ lần refactor DPO, việc đặt giá trị này thành True sẽ phát ra cảnh báo và quay lại sử dụng padding tiêu chuẩn. Tính năng này dự kiến sẽ được khôi phục trong một bản cập nhật tương lai.
pad_to_multiple_of (int hoặc str, tùy chọn, mặc định là "auto") — Nếu được đặt, các chuỗi sẽ được đệm (padding) đến một bội số của giá trị này. "auto" sẽ đệm đến bội số của 128 trên Neuron (AWS Trainium), nơi biên dịch một lần cho mỗi hình dạng đầu vào, và không đệm ở các nơi khác.
precompute_ref_log_probs (bool, tùy chọn, mặc định là False) — Có nên tính trước log probabilities của mô hình tham chiếu cho toàn bộ tập dữ liệu huấn luyện trước khi bắt đầu huấn luyện hay không. Điều này cho phép tiết kiệm bộ nhớ trong quá trình huấn luyện, vì mô hình tham chiếu không cần được giữ trong bộ nhớ.
precompute_ref_batch_size (int, tuỳ chọn) — Kích thước batch sử dụng khi tiền xử lý log xác suất của mô hình tham chiếu. Giá trị này có thể được đặt cao hơn kích thước batch huấn luyện để tăng tốc độ tiền xử lý. Nếu là None, mặc định sẽ là per_device_train_batch_size cho huấn luyện và per_device_eval_batch_size cho đánh giá.

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

loss_type (list[str], tùy chọn, mặc định là ["sigmoid"]) — Loại loss cần sử dụng. Các giá trị có thể là: 'sigmoid', 'hinge', 'ipo', 'exo_pair', 'nca_pair', 'robust', 'bco_pair', 'sppo_hard', 'aot', 'aot_unpaired', 'apo_zero', 'apo_down', 'discopop', 'sft', 'sigmoid_norm', 'udpo'. Nếu cung cấp nhiều loại loss, chúng sẽ được kết hợp bằng các trọng số được chỉ định trong loss_weights.
loss_weights (list[float], tùy chọn) — Danh sách trọng số loss cho các tổ hợp multi-loss. Được sử dụng khi kết hợp nhiều loại loss. Ví dụ: [0.8, 0.2, 1.0] cho MPO. Nếu không được cung cấp, mặc định là trọng số bằng nhau (1.0) cho tất cả các loại loss.
ld_alpha (float, tùy chọn) — Tham số α từ bài báo LD-DPO, kiểm soát trọng số của log-probabilities của các token verbose trong các phản hồi. Nếu None, không áp dụng trọng số cho phần verbose, và loss tương đương với loss DPO tiêu chuẩn. Phải nằm trong [0.0, 1.0]: ld_alpha=1.0 không áp dụng trọng số, và ld_alpha=0.0 che các token vượt quá độ dài chung.
f_divergence_type (str, tùy chọn, mặc định là "reverse_kl") — bộ điều hòa f-divergence giữa policy và reference (bài báo f-DPO). Các giá trị có thể là: reverse_kl (mặc định), forward_kl, js_divergence, alpha_divergence. Chỉ các loại loss được xây dựng dựa trên chênh lệch phần thưởng giữa chosen và rejected mới hỗ trợ giá trị khác mặc định: 'sigmoid', 'sigmoid_norm', 'hinge', 'ipo', 'exo_pair', 'robust', 'discopop', 'sft', 'udpo'. Các loại loss khác không có sự tổng quát hóa f-divergence hợp lệ và sẽ bị từ chối nếu dùng giá trị khác mặc định.
f_alpha_divergence_coef (float, tùy chọn, mặc định là 0.5) — hệ số α cho bộ chuẩn hóa α-divergence u^-α, chỉ được sử dụng khi f_divergence_type='alpha_divergence'.
label_smoothing (float, tùy chọn, mặc định là 0.0) — Tham số làm mượt nhãn (label smoothing) được sử dụng trong Robust DPO, UDPO và EXO. Trong Robust DPO và UDPO, nó được hiểu là xác suất ε mà một nhãn sở thích bị đảo ngược và phải nằm trong khoảng [0.0, 0.5); một giá trị điển hình được khuyến nghị bởi bài báo Robust DPO là 0.1. UDPO sử dụng nó để đặt a = ε / (1 - ε), và bài báo UDPO khuyến nghị a = 0.8, tức là ε = 4/9. Trong EXO, nó tương ứng với tham số làm mượt nhãn ε, mà bài báo khuyến nghị một giá trị điển hình là 1e-3.
beta (float, tùy chọn, mặc định là 0.1) — Tham số kiểm soát mức độ sai lệch so với mô hình tham chiếu. β càng cao thì mức độ sai lệch so với mô hình tham chiếu càng thấp. Đối với tổn thất IPO (loss_type='ipo'), giá trị này là tham số điều hòa được ký hiệu là τ trong bài báo.
use_weighting (bool, tùy chọn, mặc định là False) — Có áp dụng trọng số theo phong cách WPO cho các cặp ưu tiên dựa trên xác suất chuỗi được chuẩn hóa theo độ dài của chính sách hay không.
discopop_tau (float, tùy chọn, mặc định là 0.05) — Tham số τ/nhiệt độ từ bài báo DiscoPOP, kiểm soát hình dạng của hàm mất điều biến theo log-ratio khi sử dụng loss_type='discopop'. Bài báo khuyến nghị giá trị mặc định discopop_tau=0.05.
activation_offloading (bool, tùy chọn, mặc định là False) — Có nên chuyển các activation sang CPU hay không.
sync_ref_model (bool, tùy chọn, mặc định là False) — Liệu có đồng bộ hóa mô hình tham chiếu với mô hình đang hoạt động mỗi ref_model_sync_steps bước hay không, sử dụng tham số ref_model_mixup_alpha. Quá trình đồng bộ hóa này bắt nguồn từ bài báo TR-DPO. sync_ref_model=True hiện chưa tương thích với PEFT hoặc precompute_ref_log_probs=True.
ref_model_mixup_alpha (float, tùy chọn, mặc định là 0.6) — tham số α từ bài báo TR-DPO, kiểm soát sự pha trộn giữa chính sách hiện tại và chính sách tham chiếu trước đó trong quá trình cập nhật. Chính sách tham chiếu được cập nhật theo phương trình: π_ref = α * π_θ + (1 - α) * π_ref_prev. Để sử dụng tham số này, bạn phải đặt sync_ref_model=True.
ref_model_sync_steps (int, tùy chọn, mặc định là 512) — tham số τ từ bài báo TR-DPO, xác định tần suất đồng bộ hóa chính sách hiện tại với chính sách tham chiếu. Để sử dụng tham số này, bạn phải đặt sync_ref_model=True.

Các tham số đã bị ngừng hỗ trợ

pad_token —
Tham số pad_token đã bị ngừng hỗ trợ và sẽ bị loại bỏ trong phiên bản v2.0.0. Hãy đặt trực tiếp tokenizer.pad_token và truyền nó dưới dạng processing_class cho trainer thay vì cách cũ.

Lớp cấu hình cho DPOTrainer.

Lớp này chỉ bao gồm các tham số đặc thù cho huấn luyện DPO. Để xem danh sách đầy đủ các đối số huấn luyện, hãy tham khảo tài liệu TrainingArguments. Lưu ý rằng các giá trị mặc định trong lớp này có thể khác với các giá trị trong TrainingArguments.

Sử dụng HfArgumentParser, chúng ta có thể chuyển lớp này thành các đối số argparse có thể được chỉ định trên dòng lệnh.

Các tham số này có giá trị mặc định khác với TrainingArguments:

logging_steps: Mặc định là 10 thay vì 500.

gradient_checkpointing: Mặc định là True thay vì False.

bf16: Mặc định là True nếu fp16 không được đặt, thay vì False.

learning_rate: Mặc định là 1e-6 thay vì 5e-5.

Update on GitHub

←Chưng cất GRPO→