微调工具对比

为在 Clore.ai GPU 服务器上训练 LLM 选择合适的微调框架。

微调 将预训练 LLM 适配到你的特定任务或领域。本指南对比了四款领先的开源工具：Unsloth、Axolotl、LLaMA-Factory 和 TRL——涵盖速度、内存效率、支持的模型以及易用性。

---

快速决策矩阵

	Unsloth	Axolotl	LLaMA-Factory	TRL
最适合	速度 + 内存	配置驱动训练	适合初学者	研究 + RLHF
速度相较基线	快 2-5×	~1×（标准）	~1×（标准）	~1×（标准）
内存减少	减少 70-80%	QLoRA 标准	QLoRA 标准	标准
RLHF/DPO/PPO	基础	✅	✅	✅（原生支持）
WebUI	❌	❌	✅	❌
GitHub 星标	23K+	9K+	37K+	1万以上
许可证	LGPL（非商业用途免费）	Apache 2.0	Apache 2.0	Apache 2.0

---

概览

Unsloth

Unsloth 只专注一件事：让微调尽可能快、尽可能节省内存。它用 Triton 重写关键操作并优化 CUDA 内核。

理念：极致速度，最低 VRAM——毫不妥协。

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 中，底层拥有完全灵活性。

# 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+）和训练方法，并提供用于配置的 WebUI。它是非研究人员最易上手的选择。

理念：一切都能运行，适合所有人。

# 通过命令行训练
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

# 或使用 WebUI
llamafactory-cli webui

TRL（Transformer 强化学习）

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

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

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

---

速度基准

训练速度对比（tokens/秒）

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

工具	每秒 Token 数	相较基线	内存（VRAM）
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

Unsloth 的优势确实存在：2-5× 的速度提升来自用于注意力、交叉熵、RoPE 和 LoRA 的自定义 Triton 内核，不只是营销。

VRAM 使用对比

训练 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 上安装

# CUDA 12.8
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

完整训练脚本

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"### 指令:\n{example['instruction']}\n\n### 回复:\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 表现出色：

# 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

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

最适合：希望获得可复现、按配置版本管理的训练运行的团队

---

LLaMA-Factory：深入解析

WebUI 使用说明

# 安装
pip install llamafactory

# 启动 WebUI
llamafactory-cli webui
# 打开 http://localhost:7860

WebUI 选项卡：

1. 训练 — 配置基础模型、数据集和方法

2. 评估 — 运行 MMLU、CMMLU 基准测试

3. 聊天 — 交互式推理

4. 导出 — 合并 LoRA，量化为 GGUF

CLI 训练示例

# 监督微调
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

最适合：初学者、希望使用 WebUI、以及不具备深厚研究知识也能进行 DPO/RLHF 的团队

---

TRL：深入解析

RLHF 流程示例

TRL 是对齐训练的首选：

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,
)

# 加载偏好数据集（提示 + 选中 + 拒绝）
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 的实现

---

选择合适的工具

决策流程

需要最高速度/最低 VRAM 吗？
  → 是 → Unsloth（快 2-5×，可在更小的 GPU 上运行）

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

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

非技术团队或想要 WebUI？
  → 是 → LLaMA-Factory

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

按团队类型

团队	推荐	原因
个人研究者	Unsloth	速度 + Jupyter 笔记本
机器学习工程师	Axolotl	配置驱动、可复现
产品团队	LLaMA-Factory	WebUI、广泛的模型支持
对齐团队	TRL	原生 RLHF 基础组件
初创团队	Unsloth + TRL	需要时兼顾速度 + 对齐

---

Clore.ai GPU 推荐

Clore.ai 市场上未列出多 GPU 的 80GB 级机型。 目前列出的最大配置是 4× RTX PRO 6000 Blackwell（每张 96GB，共 380GB）以及 8–11× RTX 5090（每张 32GB）。A100 / H200 / B200 容量可按 裸机 需求提供。部署前请查看 GPU 价格与可用性 。

任务	最低 GPU	推荐	工具
7-8B LoRA（QLoRA）	RTX 3080（10GB）	RTX 3090	Unsloth
13B LoRA	RTX 3090（24GB）	A6000（48GB）	Unsloth/Axolotl
70B LoRA	A100（80GB）	2×A100	Axolotl/TRL
8B 全参数微调	A100（40GB）	A100（80GB）	任意
DPO/PPO 7B	RTX 4090（24GB）	A6000（48GB）	TRL

---

有用链接

• Unsloth GitHub — 23K+ 星标

• Axolotl GitHub — 9K+ 星标

• LLaMA-Factory GitHub — 37K+ 星标

• TRL GitHub — 10K+ 星标

• HuggingFace PEFT 文档

---

总结

工具	最适合	主要优势
Unsloth	速度关键型训练，小型 GPU	快 2-5×，VRAM 减少 70%
Axolotl	配置驱动、可复现的运行	以 YAML 为先，支持多种数据格式
LLaMA-Factory	100+ 模型、WebUI、初学者	支持最多模型，GUI
TRL	RLHF、DPO、对齐研究	原生对齐训练

对于大多数 Clore.ai 使用场景：先从 Unsloth （速度 + 内存效率）开始，再添加 TRL 如果你需要 DPO 或 PPO 对齐训练。