作者：吴业亮
博客：wuyeliang.blog.csdn.net

LLaMA-Factory 是一款轻量级、模块化的大语言模型（LLM）训练/微调框架，支持 LLaMA、Qwen、Baichuan 等主流模型，覆盖从预训练到对齐微调的全流程（Pre-training、SFT、RLHF、DPO、KTO 等）。本文将从原理和Ubuntu 22.04 实操两方面，系统讲解各训练阶段的核心逻辑与落地步骤。

一、环境准备（Ubuntu 22.04 基础配置）

1. 硬件要求

• 建议：NVIDIA GPU（≥16G 显存，如 A10、RTX 3090/4090、A100），支持 CUDA 11.7+
• 最低：8G 显存（仅支持量化微调，如 QLoRA）

2. 系统依赖安装

# 更新系统
sudo apt update && sudo apt upgrade -y

# 安装基础依赖
sudo apt install -y python3.10 python3.10-venv python3-pip git build-essential

# 安装 CUDA（以 11.8 为例，适配 Ubuntu 22.04）
wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run
sudo sh cuda_11.8.0_520.61.05_linux.run --silent --toolkit
echo "export PATH=/usr/local/cuda-11.8/bin:\$PATH" >> ~/.bashrc
echo "export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:\$LD_LIBRARY_PATH" >> ~/.bashrc
source ~/.bashrc

# 验证 CUDA
nvcc -V  # 应输出 CUDA 11.8 版本信息

3. LLaMA-Factory 安装

# 克隆仓库
git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory

# 创建虚拟环境
python3 -m venv llama-env
source llama-env/bin/activate

# 安装依赖（建议使用国内源加速）
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -e .[torch,metrics]

# 验证安装
llama_factory-cli version  # 输出版本号即成功

二、核心训练方法原理与实践

1. Pre-training（预训练）

原理

预训练是 LLM 的“基础阶段”，核心是让模型从海量无标注文本中学习语言规律（语法、语义、知识）。LLaMA-Factory 的预训练基于自回归语言建模（CLM） 任务：

• 输入：无标注文本序列（如书籍、网页、论文）；
• 目标：模型预测下一个token的概率，损失函数为交叉熵；
• 特点：需海量数据和算力，LLaMA-Factory 支持增量预训练（在已有预训练模型基础上补充领域数据）。

实践（Ubuntu 22.04 增量预训练）

步骤 1：数据准备

预训练数据需为 JSON 格式，单条样本格式：

{"text": "自然语言处理是人工智能的一个重要分支，主要研究人与计算机之间的语言交互。"}

将数据文件（如 pretrain_data.json）放入 data/ 目录，并修改 data/dataset_info.json 注册数据集：

{
  "my_pretrain_data": {
    "file_name": "pretrain_data.json",
    "columns": {"text": "text"},
    "type": "pretrain"
  }
}

步骤 2：启动预训练

使用 QLoRA 降低显存占用（8G 显存可运行），以 LLaMA-2-7B 为例：

llama_factory-cli train \
  --stage pretrain \
  --model_name_or_path meta-llama/Llama-2-7b-hf \  # 基础模型路径（本地/Hub）
  --dataset my_pretrain_data \
  --finetuning_type lora \
  --lora_target q_proj,v_proj \
  --output_dir ./pretrain_output \
  --per_device_train_batch_size 4 \
  --gradient_accumulation_steps 4 \
  --learning_rate 1e-4 \
  --num_train_epochs 3 \
  --logging_steps 10 \
  --save_steps 100 \
  --fp16 True \  # 混合精度训练
  --plot_loss True \
  --report_to none

关键参数说明

• --stage pretrain：指定训练阶段为预训练；
• --finetuning_type lora：使用 LoRA 微调（避免全量参数更新）；
• --fp16：开启 FP16 混合精度，降低显存占用；
• --gradient_accumulation_steps：梯度累积，等效增大 batch size。

2. Post-training（后训练）

原理

Post-training（后训练）是领域适配预训练，属于预训练的“增量版”，核心目标是让模型学习特定领域知识（如医疗、法律、金融），区别于通用预训练：

• 数据：领域专属无标注文本（如医疗论文、法律条文）；
• 任务：仍为 CLM 自回归预测，但数据聚焦单一领域；
• 优势：低成本适配垂直领域，无需从头训练。

实践（金融领域后训练）

仅需修改预训练的数据集为金融文本，其余逻辑一致：

llama_factory-cli train \
  --stage pretrain \  # LLaMA-Factory 中 post-training 复用 pretrain 阶段
  --model_name_or_path meta-llama/Llama-2-7b-hf \
  --dataset finance_pretrain_data \  # 金融领域数据集
  --finetuning_type lora \
  --lora_target q_proj,v_proj \
  --output_dir ./finance_post_train \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 8 \
  --learning_rate 5e-5 \  # 领域适配学习率更低
  --num_train_epochs 2 \
  --fp16 True

3. Supervised Fine-Tuning（SFT，有监督微调）

原理

SFT 是将预训练模型对齐人类指令的核心阶段，核心是让模型学习“指令→回复”的映射关系：

• 数据：有标注的指令-回复对（如 {"instruction": "解释什么是区块链", "output": "区块链是一种分布式账本技术..."}）；
• 任务：序列到序列（Seq2Seq）生成，损失函数为回复部分的交叉熵；
• 关键：数据质量决定 SFT 效果，需保证指令多样性、回复准确性。

实践（Ubuntu 22.04 实操）

步骤 1：SFT 数据准备

JSON 格式示例（单条样本）：

{"instruction": "请解释人工智能的定义", "input": "", "output": "人工智能（AI）是指使计算机系统能够模拟、延伸和扩展人类智能的技术..."},
{"instruction": "计算 2+3*4 的结果", "input": "", "output": "根据四则运算规则，先乘后加：3*4=12，12+2=14，结果为14。"}

注册数据集到 data/dataset_info.json：

{
  "my_sft_data": {
    "file_name": "sft_data.json",
    "columns": {"instruction": "instruction", "input": "input", "output": "output"},
    "type": "sft"
  }
}

步骤 2：启动 SFT 训练

llama_factory-cli train \
  --stage sft \
  --model_name_or_path ./pretrain_output \  # 基于后训练模型微调
  --dataset my_sft_data \
  --finetuning_type lora \
  --lora_rank 8 \
  --lora_target all-linear \
  --output_dir ./sft_output \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 2e-5 \
  --num_train_epochs 5 \
  --max_seq_length 1024 \  # 最大序列长度
  --logging_steps 10 \
  --save_steps 100 \
  --fp16 True \
  --evaluation_strategy steps \  # 按步数验证
  --eval_steps 50 \
  --load_best_model_at_end True  # 保存最优模型

关键优化

• --max_seq_length：根据数据长度设置（如长文本设为 2048）；
• --evaluation_strategy：开启验证，避免过拟合；
• --load_best_model_at_end：训练结束后加载验证集最优模型。

4. RLHF（基于人类反馈的强化学习）

原理

RLHF 是让模型对齐人类偏好的核心框架，分为三步：

1. SFT 基础对齐：先通过 SFT 让模型学会生成符合指令的回复；
2. 奖励模型（RM）训练：让模型学习人类偏好，对不同回复打分（如“更有用”“更安全”的回复得分更高）；
3. 强化学习（PPO）：以奖励模型的得分为目标，优化生成策略，让模型生成更符合人类偏好的回复。

LLaMA-Factory 实现了完整的 RLHF 流程，核心是 RM 训练 + PPO 微调。

实践（RLHF 全流程）

步骤 1：训练奖励模型（RM）

RM 数据为“指令+多回复+排序”，示例：

{
  "instruction": "推荐一本入门级的Python书籍",
  "input": "",
  "output": [
    "《Python编程：从入门到实践》适合新手，案例丰富。",  # 最优回复（排名1）
    "Python入门可以看《Head First Python》，趣味性强。",   # 次优（排名2）
    "随便找本Python书就行。"                              # 最差（排名3）
  ]
}

注册数据集后启动 RM 训练：

llama_factory-cli train \
  --stage rm \
  --model_name_or_path ./sft_output \
  --dataset my_rm_data \
  --finetuning_type lora \
  --lora_target value \  # RM 聚焦 value 层微调
  --output_dir ./rm_output \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 1e-5 \
  --num_train_epochs 3 \
  --max_seq_length 1024 \
  --fp16 True

步骤 2：PPO 强化学习

以 RM 为奖励函数，优化 SFT 模型：

llama_factory-cli train \
  --stage rlhf \
  --model_name_or_path ./sft_output \
  --rm_path ./rm_output \  # 奖励模型路径
  --dataset my_sft_data \  # 复用 SFT 数据集
  --finetuning_type lora \
  --output_dir ./rlhf_output \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 8 \
  --learning_rate 1e-6 \
  --num_train_epochs 2 \
  --max_seq_length 1024 \
  --fp16 True \
  --ppo_clip_ratio 0.2 \  # PPO 裁剪系数
  --ppo_kl_coeff 0.05 \   # KL 散度系数（避免生成偏离原模型）
  --max_grad_norm 1.0

关键参数

• --ppo_clip_ratio：PPO 核心参数，限制策略更新幅度；
• --ppo_kl_coeff：引入 KL 惩罚，防止模型生成无意义文本；
• --rm_path：指定训练好的奖励模型路径。

5. DPO（直接偏好优化）

原理

DPO 是 RLHF 的简化版，无需训练奖励模型和 PPO 强化学习，直接通过偏好数据优化模型：

• 核心思想：最大化“优选回复”的概率，最小化“次优回复”的概率；
• 损失函数：$L_{\text{DPO}}=-\log \left(\sigma \left(\beta \cdot (r_y-r_{y^{\prime }})\right)\right)$，其中 $y$ 是优选回复，$y^{\prime }$ 是次优回复，$\beta$ 是温度系数；
• 优势：流程简化、训练稳定、显存占用低，是当前对齐微调的主流方案。

实践（DPO 微调）

步骤 1：DPO 数据准备

数据格式为“指令+优选回复+次优回复”：

{
  "instruction": "如何提升睡眠质量？",
  "input": "",
  "chosen": "提升睡眠质量可从作息、环境、饮食入手：1. 固定作息；2. 保持卧室黑暗安静；3. 睡前避免咖啡因。",  # 优选回复
  "rejected": "睡不着就吃安眠药，别想太多。"  # 次优回复
}

注册数据集到 data/dataset_info.json：

{
  "my_dpo_data": {
    "file_name": "dpo_data.json",
    "columns": {"instruction": "instruction", "input": "input", "chosen": "chosen", "rejected": "rejected"},
    "type": "dpo"
  }
}

步骤 2：启动 DPO 训练

llama_factory-cli train \
  --stage dpo \
  --model_name_or_path ./sft_output \
  --dataset my_dpo_data \
  --finetuning_type lora \
  --lora_target q_proj,v_proj \
  --output_dir ./dpo_output \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 5e-6 \
  --num_train_epochs 3 \
  --max_seq_length 1024 \
  --fp16 True \
  --dpo_beta 0.1 \  # DPO 温度系数
  --logging_steps 10 \
  --save_steps 100

关键参数

• --stage dpo：指定 DPO 训练阶段；
• --dpo_beta：控制偏好强度（通常设 0.1~0.5）；
• 无需额外训练 RM，直接用偏好数据优化。

6. KTO（知识对齐优化）

原理

KTO（Knowledge-Constrained Tuning）是兼顾“知识准确性”和“人类偏好”的对齐方法，解决 DPO 可能导致的“知识遗忘”问题：

• 核心思想：在 DPO 损失基础上，加入知识约束损失，确保模型生成的回复符合事实；
• 损失函数：$L_{\text{KTO}}=L_{\text{DPO}}+\lambda \cdot L_{\text{knowledge}}$，其中 $L_{\text{knowledge}}$ 是知识准确性损失（如对事实性问题的回复交叉熵）；
• 优势：避免对齐过程中模型丢失预训练阶段学到的知识。

实践（KTO 微调）

LLaMA-Factory 通过组合损失实现 KTO，需同时准备偏好数据和知识数据：

llama_factory-cli train \
  --stage dpo \  # KTO 复用 DPO 阶段，通过损失权重控制
  --model_name_or_path ./sft_output \
  --dataset my_dpo_data,my_knowledge_data \  # 偏好数据+知识数据
  --finetuning_type lora \
  --lora_target q_proj,v_proj \
  --output_dir ./kto_output \
  --per_device_train_batch_size 2 \
  --gradient_accumulation_steps 4 \
  --learning_rate 5e-6 \
  --num_train_epochs 3 \
  --max_seq_length 1024 \
  --fp16 True \
  --dpo_beta 0.1 \
  --kto_alpha 0.5 \  # 知识损失权重
  --logging_steps 10

关键说明

• --kto_alpha：控制知识约束的强度（0~1，越大越侧重知识准确性）；
• my_knowledge_data：事实性问答数据（如 {"instruction": "地球半径是多少？", "output": "地球平均半径约6371千米"}）；
• KTO 本质是 DPO + 知识蒸馏，兼顾偏好和事实准确性。

三、训练后验证与部署

1. 模型验证

使用 LLaMA-Factory 的 CLI 进行交互测试：

llama_factory-cli chat \
  --model_name_or_path meta-llama/Llama-2-7b-hf \
  --adapter_name_or_path ./dpo_output \  # 加载微调后的 LoRA 适配器
  --finetuning_type lora \
  --device cuda:0

2. 模型合并（可选）

将 LoRA 适配器合并到基础模型，方便部署：

llama_factory-cli export \
  --model_name_or_path meta-llama/Llama-2-7b-hf \
  --adapter_name_or_path ./dpo_output \
  --finetuning_type lora \
  --export_dir ./merged_model \
  --export_size 2 \  # 量化为 2-bit（可选）
  --export_legacy_format False

四、常见问题解决（Ubuntu 22.04）

1. CUDA 版本不兼容：确保 PyTorch 版本与 CUDA 匹配（如 CUDA 11.8 对应 torch 2.0.0+）；
2. 显存不足：降低 per_device_train_batch_size、增大 gradient_accumulation_steps、开启 fp16/bf16、使用 QLoRA（--load_in_4bit True）；
3. 数据集加载失败：检查 dataset_info.json 格式，确保字段与数据文件一致；
4. 模型权重下载慢：手动下载模型到本地，指定 --model_name_or_path 为本地路径。

五、总结

LLaMA-Factory 在 Ubuntu 22.04 上实现了从预训练到对齐微调的全流程，各阶段的核心目标和适用场景如下：

阶段	核心目标	适用场景	显存要求
Pre-training	通用语言规律学习	从头/增量预训练	≥16G
Post-training	领域知识适配	垂直领域（医疗/法律）	≥8G
SFT	指令-回复映射学习	基础功能对齐	≥8G
RLHF	人类偏好对齐	高要求的生成质量	≥16G
DPO	简化版偏好对齐	快速对齐、低算力场景	≥8G
KTO	偏好+知识对齐	事实性要求高的场景	≥8G

建议优先使用 SFT + DPO 组合（低成本、高效果），垂直领域场景先做 Post-training 再做 SFT/DPO，可最大化模型效果。