# 训练自定义

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

> [!NOTE]
> 尽管这些示例使用的是 [DPOTrainer](/docs/trl/v1.18.1/zh/dpo_trainer#trl.DPOTrainer)，但这些自定义方法适用于 TRL 中的大多数（如果不是全部）训练器。

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

默认情况下，[DPOTrainer](/docs/trl/v1.18.1/zh/dpo_trainer#trl.DPOTrainer) 会创建一个 `torch.optim.AdamW` 优化器。你可以创建并定义一个不同的优化器，并按如下方式将其传递给 [DPOTrainer](/docs/trl/v1.18.1/zh/dpo_trainer#trl.DPOTrainer)：

```python
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()
```

### 添加学习率调度器

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

```python
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 位加载](https://huggingface.co/docs/transformers/en/peft)。

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

## 添加自定义回调

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

```python
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()])
```

## 添加自定义评估指标

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

```python
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` 来启用它。

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

注意：对于 Ampere GPU（A100、RTX 30xx）或更新的 GPU，请使用 `bf16=True`；对于较旧的 GPU，请使用 `fp16=True`。

## 使用梯度累积

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

```python
# 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 并重写该方法。数据准备、生成、日志记录和检查点保存均继承自父类，因此子类只需包含实际发生变化的部分。

```python
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 以声明损失函数所需的参数：

```python
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`，以便在数据集已处于预期格式时保持其不变：

```python
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`](https://github.com/huggingface/trl/blob/main/examples/sft_diffusion_gemma/sft_diffusion_gemma.py) 将三者结合：`DiffusionGemmaSFTConfig` 在 [SFTConfig](/docs/trl/v1.18.1/zh/sft_trainer#trl.SFTConfig) 的基础上扩展了画布和损坏参数，而 `DiffusionGemmaSFTTrainer` 继承自 [SFTTrainer](/docs/trl/v1.18.1/zh/sft_trainer#trl.SFTTrainer)，并用块扩散去噪目标替换了自回归交叉熵。这两者都不需要对库进行任何修改。

[Antidoom](https://github.com/Liquid4All/antidoom) 是 [Liquid AI](https://huggingface.co/LiquidAI) 推出的一款开源工具，它通过最终令牌偏好优化（[Antislop](https://huggingface.co/papers/2510.15061)）扩展了 [DPOTrainer](/docs/trl/v1.18.1/zh/dpo_trainer#trl.DPOTrainer)。这是一种针对单个令牌位置的偏好损失，能够减少推理模型中的重复循环。

