TRL documentation

训练自定义

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

训练自定义

TRL 在设计上注重模块化,以便用户能够根据需求高效地自定义训练循环。以下是如何应用和测试不同技术的示例。

尽管这些示例使用的是 DPOTrainer,但这些自定义方法适用于 TRL 中的大多数(如果不是全部)训练器。

使用不同的优化器和调度器

默认情况下,DPOTrainer 会创建一个 torch.optim.AdamW 优化器。你可以创建并定义一个不同的优化器,并按如下方式将其传递给 DPOTrainer:

from datasets import load_dataset
from torch import optim
from transformers import AutoModelForCausalLM
from trl import DPOTrainer

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
optimizer = optim.SGD(model.parameters(), lr=1e-6)

trainer = DPOTrainer(
    model=model,
    train_dataset=dataset,
    optimizers=(optimizer, None),
)
trainer.train()

添加学习率调度器

你还可以通过同时传入优化器和学习率调度器来添加学习率调度器:

from torch import optim

optimizer = optim.AdamW(model.parameters(), lr=1e-6)
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

trainer = DPOTrainer(..., optimizers=(optimizer, lr_scheduler))

传递 8 位参考模型

由于 trl 在使用 from_pretrained 从 transformers 加载模型时支持所有关键字参数,因此您也可以利用 transformers 中的 load_in_8bit 来实现更节省内存的微调。

有关 8 位模型加载的更多信息,请参阅 transformers 中的 以 8 位或 4 位加载。

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)
ref_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct", quantization_config=quantization_config)

trainer = DPOTrainer(..., ref_model=ref_model)

添加自定义回调

你可以通过添加回调来定制训练循环,以实现日志记录、监控或提前停止。回调允许你在训练过程中的特定时间点执行自定义代码。

from transformers import TrainerCallback


class CustomLoggingCallback(TrainerCallback):
    def on_log(self, args, state, control, logs=None, **kwargs):
        if logs is not None:
            print(f"Step {state.global_step}: {logs}")


trainer = DPOTrainer(..., callbacks=[CustomLoggingCallback()])

添加自定义评估指标

您可以定义自定义评估指标,以便在训练过程中进行跟踪。这对于监控模型在特定任务上的表现非常有用。

def compute_metrics(eval_preds):
    logits, labels = eval_preds
    # Add your metric computation here
    return {"custom_metric": 0.0}


training_args = DPOConfig(..., eval_strategy="steps", eval_steps=100)

trainer = DPOTrainer(..., eval_dataset=eval_dataset, compute_metrics=compute_metrics)

使用混合精度训练

混合精度训练可以显著加快训练速度并降低内存占用。您可以在训练配置中设置 bf16=True 或 fp16=True 来启用它。

# Use bfloat16 precision (recommended for modern GPUs)
training_args = DPOConfig(..., bf16=True)

注意:对于 Ampere GPU(A100、RTX 30xx)或更新的 GPU,请使用 bf16=True;对于较旧的 GPU,请使用 fp16=True。

使用梯度累积

在 GPU 内存有限的情况下进行训练时,梯度累积允许你在更新权重之前,通过多个步骤累积梯度来模拟更大的批次大小。

# Simulate a batch size of 32 with per_device_train_batch_size=4 and gradient_accumulation_steps=8
training_args = DPOConfig(
    ...,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
)

更改训练目标

子类化 trainer 是自定义训练的最简单方式。损失函数定义在 compute_loss 方法中,因此若要使用不同的训练目标,只需子类化 trainer 并重写该方法。数据准备、生成、日志记录和检查点保存均继承自父类,因此子类只需包含实际发生变化的部分。

import torch

from trl import DPOTrainer
from trl.trainer.utils import selective_log_softmax


class MyDPOTrainer(DPOTrainer):
    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        # In this example: the hinge loss from https://huggingface.co/papers/2309.06657
        input_ids, attention_mask = inputs["input_ids"], inputs["attention_mask"]
        shift_labels, shift_completion_mask = input_ids[:, 1:], inputs["completion_mask"][:, 1:]
        logits = model(input_ids=input_ids, attention_mask=attention_mask).logits
        with torch.no_grad():
            ref_logits = self.ref_model(input_ids=input_ids, attention_mask=attention_mask).logits

        # Sum the log-probs over the completion tokens, for the policy and for the reference model
        logps = (selective_log_softmax(logits[:, :-1], shift_labels) * shift_completion_mask).sum(dim=1)
        ref_logps = (selective_log_softmax(ref_logits[:, :-1], shift_labels) * shift_completion_mask).sum(dim=1)

        chosen_logps, rejected_logps = logps.chunk(2, dim=0)  # batch is [chosen, rejected]
        ref_chosen_logps, ref_rejected_logps = ref_logps.chunk(2, dim=0)
        delta = (chosen_logps - ref_chosen_logps) - (rejected_logps - ref_rejected_logps)
        return torch.relu(1 - self.beta * delta).mean()

向配置中添加参数

子类化 config 以声明损失函数所需的参数:

from dataclasses import dataclass, field

from trl import DPOConfig


@dataclass
class MyDPOConfig(DPOConfig):
    my_coef: float = field(default=0.1, metadata={"help": "Coefficient of the custom term."})

更改批次格式

当损失函数需要默认 collator 无法生成的输入时,请传入自定义的 collator,并重写 _prepare_dataset,以便在数据集已处于预期格式时保持其不变:

class MyDPOTrainer(DPOTrainer):
    def _prepare_dataset(self, dataset, *args, **kwargs):
        return dataset


trainer = MyDPOTrainer(..., data_collator=my_collator)

完整示例

块扩散 SFT 示例 examples/sft_diffusion_gemma/sft_diffusion_gemma.py 将三者结合:DiffusionGemmaSFTConfig 在 SFTConfig 的基础上扩展了画布和损坏参数,而 DiffusionGemmaSFTTrainer 继承自 SFTTrainer,并用块扩散去噪目标替换了自回归交叉熵。这两者都不需要对库进行任何修改。

Antidoom 是 Liquid AI 推出的一款开源工具,它通过最终令牌偏好优化(Antislop)扩展了 DPOTrainer。这是一种针对单个令牌位置的偏好损失,能够减少推理模型中的重复循环。

Update on GitHub