# 微调工具对比

为在 Clore.ai GPU 服务器上训练大语言模型选择合适的微调框架。

{% hint style="info" %}
**微调** 将预训练的大语言模型调整到你的特定任务或领域。本指南比较四个领先的开源工具：Unsloth、Axolotl、LLaMA-Factory 和 TRL——涵盖速度、内存效率、支持的模型和易用性。
{% endhint %}

***

## 快速决策矩阵

|                  | Unsloth       | Axolotl    | LLaMA-Factory | TRL        |
| ---------------- | ------------- | ---------- | ------------- | ---------- |
| **适用场景**         | 速度 + 内存       | 配置驱动训练     | 适合入门者         | 研究 + RLHF  |
| **相对于基线的速度**     | 快 2-5 倍       | ≈1×（标准）    | ≈1×（标准）       | ≈1×（标准）    |
| **内存减少**         | 减少 70-80%     | QLoRA 标准   | QLoRA 标准      | 标准         |
| **RLHF/DPO/PPO** | 基础            | ✅          | ✅             | ✅（原生支持）    |
| **Web UI**       | ❌             | ❌          | ✅             | ❌          |
| **GitHub 星标**    | 23K+          | 9K+        | 37K+          | 1万+        |
| **许可**           | LGPL（非商业用途免费） | Apache 2.0 | Apache 2.0    | Apache 2.0 |

***

## 概览

### Unsloth

Unsloth 专注于一件事：让微调尽可能快且内存高效。它在 Triton 中重写关键操作并优化 CUDA 内核。

**理念**：极致速度，最低显存——没有妥协。

```python
from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-8B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,  # 4 位量化
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,              # LoRA 秩
    target_modules=["q_proj", "k_proj", "v_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",  # 约增加 30% 的批量大小
    random_state=42,
)
```

### Axolotl

Axolotl 用基于 YAML 的配置系统封装了 HuggingFace Transformers。它处理训练设置的复杂性，让你可以专注于数据和超参数。

**理念**：一切在 YAML 中配置，底层保持完全灵活。

```yaml
# config.yml
base_model: meta-llama/Meta-Llama-3-8B
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

datasets:
  - path: mhenrichsen/alpaca_data_cleaned
    type: alpaca

load_in_4bit: true
adapter: qlora

lora_r: 32
lora_alpha: 16
lora_target_modules:
  - q_proj
  - k_proj
  - v_proj
  - o_proj

num_epochs: 3
micro_batch_size: 2
gradient_accumulation_steps: 4
learning_rate: 2e-4
```

### LLaMA-Factory

LLaMA-Factory 支持最广泛的模型和训练方法（100+），并提供用于配置的 Web UI。对于非研究人员来说这是最易上手的选项。

**理念**：所有功能可用，面向所有人。

```bash
# 通过命令行训练
llamafactory-cli train \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --stage sft \
  --do_train \
  --dataset alpaca_gpt4_en \
  --template llama3 \
  --finetuning_type lora \
  --lora_rank 8 \
  --output_dir saves/llama3-8b-lora \
  --num_train_epochs 3.0 \
  --per_device_train_batch_size 2

# 或使用 Web UI
llamafactory-cli webui
```

### TRL（Transformer 强化学习）

TRL 是 HuggingFace 的官方 RLHF 库。它是 PPO、DPO、ORPO 及其他对齐训练方法的标准实现。

**理念**：以研究为先，原生支持对齐训练。

```python
from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset

model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")

training_args = SFTConfig(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=load_dataset("tatsu-lab/alpaca", split="train"),
)

trainer.train()
```

***

## 速度基准

### 训练速度比较（令牌/秒）

测试设置：LLaMA 3.1 8B，LoRA r=16，4 位量化，批量大小 4，A100 80GB

| 工具                   | 每秒标记数（Tokens/sec） | 相对于基线    | 内存（显存） |
| -------------------- | ----------------- | -------- | ------ |
| Unsloth（4 位）         | \~4,200           | **2.8×** | ≈8GB   |
| Axolotl（QLoRA）       | \~1,500           | 1.0×     | 约 16GB |
| LLaMA-Factory（QLoRA） | \~1,480           | ≈1.0×    | 约 16GB |
| TRL（QLoRA）           | \~1,450           | ≈0.97×   | ≈18GB  |
| Unsloth（完整 16 位）     | \~2,800           | **1.9×** | ≈22GB  |

{% hint style="success" %}
**Unsloth 的优势是真实的**：2-5× 的速度来自为注意力、交叉熵、RoPE 和 LoRA 定制的 Triton 内核。不只是市场宣传。
{% endhint %}

### 显存使用比较

训练 LLaMA 3.1 8B，序列长度 2048：

| 方法              | Unsloth | Axolotl | LLaMA-Factory | TRL  |
| --------------- | ------- | ------- | ------------- | ---- |
| 完整微调（bf16）      | 60GB    | 70GB    | 72GB          | 74GB |
| LoRA（bf16）      | 18GB    | 24GB    | 25GB          | 26GB |
| QLoRA（4 位）      | **8GB** | 16GB    | 16GB          | 18GB |
| QLoRA（4 位，长上下文） | 12GB    | 24GB    | 24GB          | 26GB |

**8B 模型的最低 GPU 要求**:

* Unsloth：RTX 3080（10GB） ✅
* 其他：需要 RTX 3090（24GB）

***

## 支持的模型

### 模型支持矩阵

| 模型家族         | Unsloth | Axolotl | LLaMA-Factory | TRL |
| ------------ | ------- | ------- | ------------- | --- |
| LLaMA 3.x    | ✅       | ✅       | ✅             | ✅   |
| LLaMA 2      | ✅       | ✅       | ✅             | ✅   |
| Mistral      | ✅       | ✅       | ✅             | ✅   |
| Mixtral MoE  | ✅       | ✅       | ✅             | ✅   |
| Gemma 2      | ✅       | ✅       | ✅             | ✅   |
| Phi-3/3.5    | ✅       | ✅       | ✅             | ✅   |
| Qwen 2.5     | ✅       | ✅       | ✅             | ✅   |
| DeepSeek     | ✅       | ✅       | ✅             | ✅   |
| Falcon       | ✅       | ✅       | ✅             | ✅   |
| GPT-NeoX     | 部分支持    | ✅       | ✅             | ✅   |
| T5/FLAN      | ❌       | ✅       | ✅             | ✅   |
| BERT/RoBERTa | ❌       | ✅       | ✅             | ✅   |
| 视觉类 LLM      | 部分支持    | 部分支持    | ✅             | ✅   |

### 训练方法支持

| 方法         | Unsloth | Axolotl | LLaMA-Factory | TRL     |
| ---------- | ------- | ------- | ------------- | ------- |
| 完整微调       | ✅       | ✅       | ✅             | ✅       |
| LoRA       | ✅       | ✅       | ✅             | ✅       |
| QLoRA      | ✅       | ✅       | ✅             | ✅       |
| DoRA       | ✅       | ✅       | ✅             | ❌       |
| PEFT       | ✅       | ✅       | ✅             | ✅       |
| SFT        | ✅       | ✅       | ✅             | ✅（原生支持） |
| DPO        | ✅       | ✅       | ✅             | ✅（原生支持） |
| PPO        | ❌       | ✅       | ✅             | ✅（原生支持） |
| ORPO       | ✅       | ✅       | ✅             | ✅       |
| KTO        | ❌       | ✅       | ✅             | ✅（原生支持） |
| GRPO       | ✅       | ❌       | ✅             | ✅       |
| CPT（继续预训练） | ✅       | ✅       | ✅             | ✅       |

***

## Unsloth：深入解析

### 它为何快速

1. **Triton 内核**：在 Triton 中重写了 Flash Attention、交叉熵损失和 LoRA
2. **融合操作**：将多个 CUDA 操作合并为一个内核
3. **智能梯度检查点**："unsloth" 模式节省约 30% 的内存
4. **高效反向传播**：避免物化大型中间张量

### 在 Clore.ai 上的安装

```bash
# CUDA 12.1
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

# 或使用 conda
conda create --name unsloth_env python=3.11
conda activate unsloth_env
conda install pytorch-cuda=12.1 pytorch cudatoolkit xformers -c pytorch -c nvidia -c xformers -y
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes
```

### 完整训练脚本

```python
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
import torch

# 1. 使用 Unsloth 优化加载模型
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct",
    max_seq_length=2048,
    dtype=None,        # 自动检测
    load_in_4bit=True,
)

# 2. 添加 LoRA 适配器
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

# 3. 加载并格式化数据集
dataset = load_dataset("tatsu-lab/alpaca", split="train")

def format_prompt(example):
    return {"text": f"### Instruction:\n{example['instruction']}\n\n### Response:\n{example['output']}"}

dataset = dataset.map(format_prompt)

# 4. 训练
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)
trainer.train()

# 5. 保存
model.save_pretrained("lora_model")
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")
```

**弱点**：不支持 PPO，受限于支持的模型列表，采用 LGPL 许可证（商业使用请核查）

***

## Axolotl：深入解析

### 以配置为先的方式

当你需要可复现、可版本控制的训练配置时，Axolotl 表现出色：

```yaml
# axolotl_config.yml — 完整示例
base_model: meta-llama/Meta-Llama-3-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

# 数据
datasets:
  - path: tatsu-lab/alpaca
    type: alpaca
  - path: ./my_custom_data.jsonl
    type: sharegpt
dataset_prepared_path: ./prepared_data
val_set_size: 0.01

# 量化
load_in_4bit: true
adapter: qlora
bf16: true
tf32: true

# LoRA
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - v_proj
  - k_proj
  - o_proj
  - gate_proj
  - up_proj
  - down_proj

# 训练
sequence_len: 4096
sample_packing: true  # 将短序列打包以提高效率
pad_to_sequence_len: true
micro_batch_size: 2
gradient_accumulation_steps: 4
num_epochs: 3
learning_rate: 0.0002
optimizer: adamw_bnb_8bit
lr_scheduler: cosine

# 日志
logging_steps: 10
eval_steps: 100
save_steps: 100
output_dir: ./outputs/my-model

# wandb
wandb_project: my-fine-tune
wandb_run_id: run-001
```

```bash
# 安装并运行
pip install axolotl[flash-attn,deepspeed]
axolotl train axolotl_config.yml
```

**适用场景**：适用于希望可复现、配置版本化训练的团队

***

## LLaMA-Factory：深入解析

### Web UI 演练

```bash
# 安装
pip install llamafactory

# 启动 Web UI
llamafactory-cli webui
# 打开 http://localhost:7860
```

Web UI 选项卡：

1. **训练** — 配置基础模型、数据集、方法
2. **评估** — 运行 MMLU、CMMLU 基准测试
3. **聊天** — 交互式推理
4. **导出** — 合并 LoRA，量化为 GGUF

### CLI 训练示例

```bash
# 监督微调
llamafactory-cli train \
  --stage sft \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --dataset alpaca_gpt4_en,glaive_toolcall_en \
  --template llama3 \
  --finetuning_type lora \
  --lora_rank 8 \
  --lora_alpha 16 \
  --lora_target all \
  --output_dir saves/llama3-lora \
  --num_train_epochs 3 \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 2e-4 \
  --quantization_bit 4 \
  --flash_attn fa2

# DPO 训练
llamafactory-cli train \
  --stage dpo \
  --model_name_or_path meta-llama/Meta-Llama-3-8B \
  --dataset dpo_mix_en \
  --template llama3 \
  --finetuning_type lora \
  --output_dir saves/llama3-dpo
```

**适用场景**：适合初学者、需要 Web UI 的团队、希望进行 DPO/RLHF 但无需深度研究知识的用户

***

## TRL：深入解析

### RLHF 流程示例

TRL 是对齐训练的首选：

```python
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset

# DPO（直接偏好优化）——最常见的对齐方法
model_name = "meta-llama/Meta-Llama-3-8B-Instruct"

dpo_config = DPOConfig(
    model_name_or_path=model_name,
    output_dir="dpo_outputs",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    beta=0.1,             # KL 惩罚系数
    loss_type="sigmoid",  # 或 "hinge", "ipo", "kto_pair"
    learning_rate=5e-7,
)

# 加载偏好数据集（prompt + 选中 + 被拒绝）
dataset = load_dataset("Anthropic/hh-rlhf", split="train")

trainer = DPOTrainer(
    model=model_name,
    args=dpo_config,
    train_dataset=dataset,
)
trainer.train()
```

**适用场景**：对齐研究、RLHF、DPO、PPO、ORPO 的实现

***

## 选择合适的工具

### 决策流程

```
需要最大速度/最小显存吗？
  → 是 → Unsloth（快 2-5×，适合更小的 GPU）

需要对齐训练（DPO/PPO/RLHF）吗？
  → 是 → TRL 或 LLaMA-Factory
  → 研究/自定义 → TRL
  → 生产/易用 → LLaMA-Factory

需要以配置为先的可复现性吗？
  → 是 → Axolotl

是否为非技术团队或想要 Web UI？
  → 是 → LLaMA-Factory

只是想快速开始？
  → LLaMA-Factory 或 Unsloth
```

### 按团队类型

| 团队      | 推荐            | 理由               |
| ------- | ------------- | ---------------- |
| 个人研究者   | Unsloth       | 速度 + Jupyter 笔记本 |
| 机器学习工程师 | Axolotl       | 配置驱动、可复现         |
| 产品团队    | LLaMA-Factory | Web UI、广泛的模型支持   |
| 对齐团队    | TRL           | 原生的 RLHF 原语      |
| 初创公司    | Unsloth + TRL | 需要时兼顾速度与对齐能力     |

***

## Clore.ai 的 GPU 建议

| 任务               | 最低 GPU         | 推荐配置        | 工具              |
| ---------------- | -------------- | ----------- | --------------- |
| 7-8B LoRA（QLoRA） | RTX 3080（10GB） | RTX 3090    | Unsloth         |
| 13B LoRA         | 生产             | A6000（48GB） | Unsloth/Axolotl |
| 70B LoRA         | A100（80GB）     | 2×A100      | Axolotl/TRL     |
| 8B 完整微调          | A100（40GB）     | A100（80GB）  | 任意              |
| DPO/PPO 7B       | 大规模            | A6000（48GB） | TRL             |

***

## 有用的链接

* [Unsloth GitHub](https://github.com/unslothai/unsloth) — 23K+ 星标
* [Axolotl GitHub](https://github.com/axolotl-ai-cloud/axolotl) — 9K+ 星标
* [LLaMA-Factory GitHub](https://github.com/hiyouga/LLaMA-Factory) — 37K+ 星标
* [TRL GitHub](https://github.com/huggingface/trl) — 10K+ 星标
* [HuggingFace PEFT 文档](https://huggingface.co/docs/peft)

***

## 总结

| 工具                | 适用场景                 | 关键优势             |
| ----------------- | -------------------- | ---------------- |
| **Unsloth**       | 对速度敏感的训练，小显卡可用       | 快 2-5×，显存减少 70%  |
| **Axolotl**       | 配置驱动，可复现的运行          | YAML 为先，支持多种数据格式 |
| **LLaMA-Factory** | 100+ 模型，Web UI，适合初学者 | 最多的模型支持，带 GUI    |
| **TRL**           | RLHF、DPO、对齐研究        | 原生的对齐训练          |

对于大多数 Clore.ai 用例：首先使用 **Unsloth** （速度 + 内存效率），如需 DPO 或 PPO 对齐训练再添加 **TRL** 。