# 微调工具对比

为在 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** 。


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-zh/dui-bi/finetuning-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.