> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-zh/xun-lian/llama-factory.md).

# LLaMA-Factory

在 Clore.ai GPU 上使用 LLaMA-Factory 通过 LoRA/QLoRA 和网页界面微调 100+ 个 LLM

LLaMA-Factory 是最全面的开源微调框架，支持 100+ 种语言模型，包括所有 LLaMA 变体、Qwen、Mistral、Phi、Falcon、ChatGLM 等。它提供 LoRA、QLoRA、全量微调、RLHF、DPO 和 PPO —— 全部可通过直观的网页界面（LLaMA Board）或 CLI 完成。CLORE.AI 的按需 GPU 服务器使其成为以远低于云服务商成本启动微调任务的理想平台。

{% hint style="success" %}
所有示例都可以在通过以下方式租用的 GPU 服务器上运行 [CLORE.AI 市场](https://clore.ai/marketplace).
{% endhint %}

## 服务器要求

| 参数  | 最低               | 推荐            |
| --- | ---------------- | ------------- |
| 内存  | 16 GB            | 32 GB+        |
| 显存  | 8 GB（QLoRA）      | 24 GB+        |
| 磁盘  | 50 GB            | 200 GB+       |
| GPU | NVIDIA RTX 2080+ | A100，RTX 4090 |

{% hint style="info" %}
**训练方式决定 GPU 需求：**

* **QLoRA（4 位）**：7B 模型需 8 GB VRAM，13B 需 16 GB
* **LoRA（float16）**：7B 模型需 16 GB VRAM，13B 需 40 GB
* **全量微调**：每 7B 参数约需 \~14 GB VRAM（+ 优化器状态）
* 多 GPU（DeepSpeed/FSDP）可扩展到任意数量的 GPU
  {% endhint %}

## 在 CLORE.AI 上快速部署

**Docker 镜像：** `hiyouga/llamafactory:latest`

**端口：** `22/tcp`, `7860/http`

**环境变量：**

| 变量                     | 示例          | 描述                       |
| ---------------------- | ----------- | ------------------------ |
| `HF_TOKEN`             | `hf_xxx...` | 用于受限模型的 HuggingFace 令牌   |
| `WANDB_API_KEY`        | `xxx...`    | 用于实验跟踪的 Weights & Biases |
| `CUDA_VISIBLE_DEVICES` | `0,1`       | 要使用的 GPU                 |

## 逐步设置

### 1. 在 CLORE.AI 上租用 GPU 服务器

访问 [CLORE.AI 市场](https://clore.ai/marketplace) 并根据你的任务选择：

| 任务        | 显存    | 推荐 GPU          |
| --------- | ----- | --------------- |
| QLoRA 7B  | 8 GB  | RTX 3070/2080   |
| QLoRA 13B | 16 GB | RTX 3090/A4000  |
| LoRA 7B   | 16 GB | RTX 3090/A4000  |
| LoRA 13B  | 40 GB | A6000/A100 40GB |
| 全量 FT 7B  | 80 GB | A100 80GB       |
| 多 GPU     | 视情况而定 | 任意 GPU 的 2-8 倍  |

### 2. SSH 登录到你的服务器

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. 创建工作目录

```bash
mkdir -p /root/llamafactory/{data,models,output,saves}
```

### 4. 拉取 Docker 镜像

```bash
docker pull hiyouga/llamafactory:latest
```

### 5. 启动 LLaMA-Factory

**使用 Web UI（LLaMA Board）启动：**

```bash
docker run -d \\
  --name llamafactory \
  --gpus all \\
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \
  -v /root/llamafactory/models:/root/.cache/huggingface \
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \
  -e HF_TOKEN=hf_your_token_here \\
  hiyouga/llamafactory:latest \
  llamafactory-cli webui
```

**使用 Weights & Biases 跟踪：**

```bash
docker run -d \\
  --name llamafactory \
  --gpus all \\
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \
  -v /root/llamafactory/models:/root/.cache/huggingface \
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \
  -e HF_TOKEN=hf_your_token_here \\
  -e WANDB_API_KEY=your_wandb_key \
  hiyouga/llamafactory:latest \
  llamafactory-cli webui
```

**使用 DeepSpeed 的多 GPU（4 张 GPU）：**

```bash
docker run -d \\
  --name llamafactory \
  --gpus all \\
  --shm-size 16g \\
  --ipc host \\
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \
  -v /root/llamafactory/models:/root/.cache/huggingface \
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \
  -e CUDA_VISIBLE_DEVICES=0,1,2,3 \
  hiyouga/llamafactory:latest \
  bash -c "llamafactory-cli webui"
```

### 6. 访问网页界面

查看日志并获取 URL：

```bash
docker logs -f llamafactory
```

你的 CLORE.AI http\_pub URL，端口 7860：

```
https://<order-id>-7860.clore.ai/
```

***

## 使用示例

### 示例 1：通过网页 UI 进行 LoRA 微调（LLaMA Board）

1. 在你的 CLORE.AI URL 上打开 LLaMA Board
2. 前往 **训练** 标签页
3. 配置：
   * **模型名称**: `LLaMA-3` → `Meta-Llama-3-8B-Instruct`
   * **训练阶段**: `监督微调`
   * **数据集**：选择你的数据集（或上传自定义数据集）
   * **微调方式**: `lora`
   * **LoRA rank**: `8` （越高 = 训练参数越多）
   * **学习率**: `1e-4`
   * **轮数**: `3`
   * **输出目录**: `llama3-finetuned`
4. 点击 **开始** 开始训练
5. 在以下位置监控 loss 曲线： **Loss** 图表

### 示例 2：基于 CLI 的 QLoRA 微调

准备一个训练配置 YAML：

```bash
docker exec -it llamafactory bash

cat > /app/LLaMA-Factory/configs/qlora_mistral.yaml << 'EOF'
### 模型
model_name_or_path: mistralai/Mistral-7B-Instruct-v0.3

### 方法
stage: sft
do_train: true
finetuning_type: lora
lora_target: all
lora_rank: 16
lora_alpha: 32
lora_dropout: 0.05

### 数据集
dataset: alpaca_en
template: mistral
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16

### 输出
output_dir: saves/mistral-qlora
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true

### 训练
per_device_train_batch_size: 2
gradient_accumulation_steps: 8
learning_rate: 0.0001
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
fp16: true

### 量化
quantization_method: bitsandbytes
quantization_bit: 4
EOF

# 运行训练
llamafactory-cli train /app/LLaMA-Factory/configs/qlora_mistral.yaml
```

### 示例 3：上传自定义数据集

以 Alpaca 格式创建一个自定义数据集：

```bash
# 创建数据集文件
cat > /root/llamafactory/data/my_dataset.json << 'EOF'
[
  {
    "instruction": "你是一家科技公司的客服。请提供有帮助的回答。",
    "input": "更新后我的笔记本电脑无法开机。我该怎么办？",
    "output": "我理解这会让人非常沮丧。让我们一步一步排查：\n\n1. **长按电源键 10 秒** 强制关机\n2. **拔掉电源线**，如果电池可拆卸也取下电池，等待 30 秒\n3. **重新连接电源** 并尝试开机\n4. 如果仍无响应，在启动时按 **F8/F11** 进入恢复模式\n\n你希望我详细带你操作其中的某一步吗？"
  },
  {
    "instruction": "你是一家科技公司的客服。",
    "input": "如何重置我的密码？",
    "output": "重置密码很简单！步骤如下：\n\n1. 前往登录页面并点击 **'Forgot Password'**\n2. 输入你的 **注册邮箱地址**\n3. 查收包含重置链接的邮件（也请检查垃圾邮件文件夹）\n4. 点击链接并 **创建新密码**\n\n重置链接 24 小时后失效。如果你在 5 分钟内没有收到邮件，请联系支持团队。"
  }
]
EOF

# 在 dataset_info.json 中注册数据集
docker exec -it llamafactory bash -c "
cat >> /app/LLaMA-Factory/data/dataset_info.json << 'EOF2'
,
\"my_dataset\": {
  \"file_name\": \"/root/llamafactory/data/my_dataset.json\"
}
EOF2
"
```

然后在 `my_dataset` 在 LLaMA Board 的数据集下拉菜单中选择。

### 示例 4：DPO（直接偏好优化）

```yaml
### configs/dpo_llama.yaml

model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct

### 方法 - DPO
stage: dpo
do_train: true
finetuning_type: lora
lora_rank: 8

### DPO 特有设置
pref_beta: 0.1
pref_loss: sigmoid  # sigmoid, hinge, ipo

### 数据集（必须是偏好格式）
dataset: dpo_en_demo
template: llama3
cutoff_len: 2048

### 输出
output_dir: saves/llama3-dpo
logging_steps: 10
save_steps: 100

### 训练
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
learning_rate: 5e-5
num_train_epochs: 1.0
fp16: true
```

```bash
docker exec -it llamafactory bash -c "llamafactory-cli train /configs/dpo_llama.yaml"
```

### 示例 5：使用微调后的模型进行推理

训练完成后，测试你的模型：

```bash
docker exec -it llamafactory bash

# 交互式聊天
llamafactory-cli chat \
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \
  --template mistral \
  --finetuning_type lora
```

或者导出合并后的模型：

```bash
llamafactory-cli export \
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \
  --template mistral \
  --finetuning_type lora \
  --export_dir /app/LLaMA-Factory/output/mistral-merged \
  --export_size 4 \
  --export_legacy_format false
```

***

## 配置

### 关键训练参数

| 参数                            | 典型值        | 描述                     |
| ----------------------------- | ---------- | ---------------------- |
| `lora_rank`                   | 8–64       | LoRA rank（越高 = 表达能力越强） |
| `lora_alpha`                  | rank 的 2 倍 | LoRA alpha 缩放          |
| `lora_dropout`                | 0.0–0.1    | LoRA 层的 dropout        |
| `lora_target`                 | `all`      | 应用 LoRA 的层             |
| `learning_rate`               | `1e-4`     | 初始学习率                  |
| `num_train_epochs`            | 1–5        | 训练轮数                   |
| `per_device_train_batch_size` | 1–4        | 每个 GPU 的批大小            |
| `gradient_accumulation_steps` | 4–16       | 等效批量倍数                 |
| `cutoff_len`                  | 1024–4096  | 最大序列长度                 |
| `quantization_bit`            | 4 或 8      | QLoRA 量化位数             |
| `warmup_ratio`                | 0.05–0.1   | 学习率预热比例                |
| `lr_scheduler_type`           | `cosine`   | 学习率调度                  |

### 支持的微调方法

| 方法                | 显存占用 | 质量  | 适用场景  |
| ----------------- | ---- | --- | ----- |
| `full`            | 非常高  | 最佳  | 无限显存  |
| `freeze`          | 中等   | 好   | 冻结基础层 |
| `lora`            | 低    | 非常好 | 默认选择  |
| `qlora` （lora+量化） | 最低   | 好   | 有限显存  |

### 多 GPU DeepSpeed 训练

在多 GPU 上训练时，使用以下方式启动 `torchrun`:

```bash
docker exec -it llamafactory bash -c "
FORCE_TORCHRUN=1 NNODES=1 RANK=0 MASTER_ADDR=127.0.0.1 MASTER_PORT=29500 \
llamafactory-cli train configs/qlora_mistral.yaml \
  --deepspeed examples/deepspeed/ds_z3_config.json
"
```

***

## 性能提示

### 1. 按 GPU 类型优化的 QLoRA 设置

**8 GB VRAM（RTX 3070）：**

```yaml
quantization_bit: 4
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
cutoff_len: 1024
```

**24 GB VRAM（RTX 3090/4090）：**

```yaml
quantization_bit: 4  # 仍然使用 QLoRA 以获得更大的批大小
per_device_train_batch_size: 4
gradient_accumulation_steps: 4
cutoff_len: 2048
```

**80 GB VRAM（A100）：**

```yaml
# 无需量化——直接使用 LoRA
finetuning_type: lora
per_device_train_batch_size: 8
gradient_accumulation_steps: 2
cutoff_len: 4096
fp16: true
```

### 2. 使用 Flash Attention 2 处理更长上下文

```yaml
flash_attn: fa2  # 需要 Ampere+ GPU
```

这可以让你在相同显存下使用 2 倍长度的序列进行训练。

### 3. 梯度检查点

以约 20% 更慢的训练速度换取显存节省：

```yaml
gradient_checkpointing: true
```

### 4. 选择合适的 LoRA 目标

```yaml
lora_target: all  # 所有线性层（默认，质量最佳）
# 或
lora_target: q_proj,v_proj  # 最小化，最快，质量较低
```

### 5. 冻结顶层以快速适配

```yaml
finetuning_type: freeze
freeze_trainable_layers: 2   # 仅训练最上面的 2 层
freeze_trainable_modules: all
```

对于简单任务适配，比完整 LoRA 快得多。

### 6. 使用 TensorBoard 监控

```bash
# 在单独的终端中
docker exec -it llamafactory bash -c "
tensorboard --logdir /app/LLaMA-Factory/saves --host 0.0.0.0 --port 6006
"
```

在你的 CLORE.AI 订单中添加 6006 端口即可访问 TensorBoard。

***

## 故障排查

### 问题：训练时出现“CUDA 显存不足”

1. 减小批大小： `per_device_train_batch_size: 1`
2. 启用梯度检查点： `gradient_checkpointing: true`
3. 减少上下文长度： `cutoff_len: 512`
4. 使用 QLoRA（4 位）： `quantization_bit: 4`
5. 降低 LoRA rank： `lora_rank: 4`

### 问题：训练损失不下降

* 检查学习率——尝试 `5e-5` 或 `2e-4`
* 验证数据集格式是否与模板匹配
* 增大 `lora_rank` （8→16→32）
* 检查 `lora_target: all` 是否已设置

### 问题：训练速度慢

```bash
# 检查容器内的 GPU 使用率
docker exec -it llamafactory bash -c "watch -n 1 nvidia-smi"
```

如果 GPU 利用率 < 80%：

* 增大批大小
* 使用 Flash Attention： `flash_attn: fa2`
* 移除 `gradient_checkpointing` 如果显存允许

### 问题：Web UI 中找不到模型

```bash
# 预下载到缓存卷
docker exec -it llamafactory bash -c "
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3
"
```

然后刷新 LLaMA Board 中的模型列表。

### 问题：数据集格式错误

所有数据集格式都必须匹配 `dataset_info.json` 规范：

```bash
# 验证数据集
docker exec -it llamafactory python3 -c "
import json
with open('/app/LLaMA-Factory/data/my_dataset.json') as f:
    data = json.load(f)
print(f'数据集共有 {len(data)} 个样本')
print('第一个样本的键：', list(data[0].keys()))
"
```

### 问题：无法访问 WebUI 端口

确保 LLaMA-Factory 已启动 Gradio 服务器：

```bash
docker logs llamafactory 2>&1 | grep -E "Running on|Error|Traceback"
```

在 `--share` 作为替代方案，可使用 public Gradio URL 标志。

***

## 链接

* [GitHub](https://github.com/hiyouga/LLaMA-Factory)
* [文档](https://llamafactory.readthedocs.io)
* [Docker Hub（hiyouga）](https://hub.docker.com/r/hiyouga/llamafactory)
* [支持的模型](https://github.com/hiyouga/LLaMA-Factory?tab=readme-ov-file#supported-models)
* [数据集格式](https://github.com/hiyouga/LLaMA-Factory/blob/main/data/README.md)
* [CLORE.AI 市场](https://clore.ai/marketplace)

***

## Clore.ai GPU 推荐

{% hint style="warning" %}
**Clore.ai 市场上未列出多 GPU 的 80GB 级机型。** 目前列出的最大配置是 4× RTX PRO 6000 Blackwell（每张 96GB，共 380GB）以及 8–11× RTX 5090（每张 32GB）。A100 / H200 / B200 容量可按 [裸机](https://clore.ai/bare-metal) 需求提供。部署前请查看 [GPU 价格与可用性](/guides/guides_v2-zh/ru-men-zhi-nan/pricing.md) 。
{% endhint %}

| 使用场景       | 推荐 GPU          | Clore.ai 预计成本                     |
| ---------- | --------------- | --------------------------------- |
| 开发/测试      | RTX 3090（24GB）  | $0.07–0.21/gpu/hr                 |
| 微调（7B–13B） | RTX 4090（24GB）  | $0.14–0.42/gpu/hr                 |
| 大模型（70B+）  | A100 80GB       | [裸机](https://clore.ai/bare-metal) |
| 多 GPU 训练   | 2-4 张 A100 80GB | [裸机](https://clore.ai/bare-metal) |

> 💡 本指南中的所有示例都可以部署在 [Clore.ai](https://clore.ai/marketplace) GPU 服务器上。浏览可用 GPU 并按小时租用——无需承诺，拥有完整 root 访问权限。


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-zh/xun-lian/llama-factory.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
