在职前端Leader学习/转行 AI Agent -DAY101

3 阅读51分钟

2026.11.13 10:01:56

学习路线

Python(1) -> Python数据分析(2) -> 机器学习(3) -> 深度学习(4) -> NLP(5–7) -> 大模型应用基础(8) -> 范式(9–10) -> LangChain(11) -> LangGraph(12) -> 上下文与记忆(13–17) -> Wiki(18–19) -> 工具与多智能体(20–25) -> 框架补全(26–31) -> 大模型微调(32–37) -> 多模态(38) -> 后训练(39–42) -> 评估与进化(43) -> SQLAIchemy + FastAPI + Docker(44–46) -> Harness(47–52) -> 编程与安全(53–55)

大模型微调33-LLaMA-Factory 复习巩固总结

1. 基于DeepSpeed加速训练模型

DeepSpeed 看的是多卡训练时,权重、梯度和优化器状态放在哪。第 1 节 按单卡、单机多卡、多机多卡列了启动命令。第 9 节 讲这些进程之间怎么切。两层叠在一起:FORCE_TORCHRUN、deepspeed、accelerate launch 起进程;yaml 里的 deepspeed: 或命令上的 --deepspeed 选定哪份 json。

1.1 单卡不开

一张卡前面不加 FORCE_TORCHRUN。命令是 llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml,普通 LoRA,不写 deepspeed。网页预览里设备数量是 1,DeepSpeed 为 none。QLoRA 多出来的是训练 yaml 里的 quantization_bit: 4,底模按 4 比特放,也不是 DeepSpeed。这些都在 1.1。

1.2 多卡先算显存,再决定切到哪

DDP 只切样本,每张卡留完整的权重和 Adam 状态。DeepSpeed 还能切优化器、梯度、模型参数,并能卸到 CPU。FSDP 也能切这三块。这一门打开的 json 走的是 DeepSpeed。四列分别在分什么,见 9.8 第 3 问。

引擎数据切分模型切分优化器切分参数卸载
DDP支持不支持不支持不支持
DeepSpeed支持支持支持支持
FSDP支持支持支持支持

这一门的训练 yaml 写 bf16: true。8B 只做推理时,BF16 权重大约 16GB。全量还要留梯度、FP32 主权重和 Adam 的两份动量,每个参数 16 字节,8B 大约 128GB,激活另算。4.3 的 LoRA 能放进一张 24GB 卡,是因为底模冻结,优化器只更新那一块低秩矩阵。全量那 128GB 用 ZeRO-3 切开之后,各卡显存加起来仍不够,还是放不下。这和 1.2.1 里全量跑不通是同一笔账。

阶段切开什么每张卡仍各留一份
ZeRO-1优化器状态完整的权重和梯度
ZeRO-2优化器状态和梯度完整的权重
ZeRO-3优化器状态、梯度和权重只留自己那一片

阶段越高,显存越小,也越慢。显存够就用 ZeRO-1,不写 offload。不够再升到 ZeRO-2 或 ZeRO-3,或者把 offload_optimizer、offload_param 的 device 写成 cpu。卸到内存会更慢。

仓库自带五份:ds_z0_config.json(stage: 0,不切)、ds_z2_config.json、ds_z2_offload_config.json(只把优化器卸到 cpu)、ds_z3_config.json、ds_z3_offload_config.json(优化器和参数都卸到 cpu,overlap_comm 是 false)。没有单独的 ZeRO-1 文件,在 ZeRO-0 上把 stage 改成 1。json 里写成 "auto" 的 batch、梯度累积、梯度裁剪和 bf16.enabled,启动时用训练 yaml 填上。桶大小、梯度怎么排这些不用改。全文和字段对照在 9.4,要不要逐项改见 9.8 第 4 问。

GPU 上通信库默认 nccl,不写进 yaml,也不在这几份 json 里。Accelerate 只支持 NVLink。T4、3090 之间是 PIX,用 nvidia-smi topo -m 看。这种卡做多卡训练,走 DeepSpeed。

1.3 训练 yaml 里只有一行

切分没有独立字段。训练 yaml 只写 deepspeed:,指向哪份 json。

打开的 LoRA 文件是 llama3_lora_sft_ds3.yaml,finetuning_type: lora,lora_rank: 8。全文在 9.5。

deepspeed: examples/deepspeed/ds_z3_config.json  # choices: [ds_z0_config.json, ds_z2_config.json, ds_z3_config.json]

显存还不够,同一行改成 offload 那份。

deepspeed: examples/deepspeed/ds_z3_offload_config.json  # choices: [ds_z0_config.json, ds_z2_config.json, ds_z3_config.json]

1.2.1 的 llama3_full_sft.yaml 也指向同一份 ds_z3_config.json,差别是 finetuning_type: full,输出在 saves/llama3-8b/full/sft。9.6.1 还有一份 llama3_full_sft_ds3.yaml,同样指向 ds_z3_config.json,和上面的 LoRA 文件不是同一个。

1.3.1 的多机命令用的是 examples/train_lora/llama3_lora_sft.yaml。命令上没有 json。要切参数,这份 yaml 里得写上 deepspeed:。

1.4 启动时谁在切参数

单机多卡。1.2 的三条里,yaml 带 deepspeed: 的这一条在切参数。不写 CUDA_VISIBLE_DEVICES 就用全部卡。

FORCE_TORCHRUN=1 llamafactory-cli train examples/train_full/llama3_full_sft.yaml

llama3_full_sft_ds3.yaml 是另一份全量配置,里面同样是 ds_z3_config.json。

FORCE_TORCHRUN=1 llamafactory-cli train examples/train_full/llama3_full_sft_ds3.yaml

deepspeed 命令把 json 写在命令上。下面这条是 8 卡全量,--finetuning_type full,输出目录却写成 saves/llama3-8b/lora/full。

deepspeed --num_gpus 8 src/train.py \
--deepspeed examples/deepspeed/ds_z3_config.json \
--stage sft \
--model_name_or_path meta-llama/Meta-Llama-3-8B-Instruct \
--do_train \
--dataset alpaca_en \
--template llama3 \
--finetuning_type full \
--output_dir saves/llama3-8b/lora/full \
--overwrite_cache \
--per_device_train_batch_size 1 \
--gradient_accumulation_steps 8 \
--lr_scheduler_type cosine \
--logging_steps 10 \
--save_steps 500 \
--learning_rate 1e-4 \
--num_train_epochs 2.0 \
--plot_loss \
--bf16

用 deepspeed 启动时不用 CUDA_VISIBLE_DEVICES。--include localhost:1 表示只用本节点的 gpu1。

1.2.2 的 8 进程 torchrun 是 LoRA,命令上没有 --deepspeed。1.2.3 的 accelerate_singleNode_config.yaml 是 distributed_type: MULTI_GPU,没有 zero_stage。这两条只切数据。

多机多卡。下面两条和 1.3.1 相同,每台机器各跑一条,NODE_RANK 分别是 0 和 1,主节点 192.168.0.1:29500。

FORCE_TORCHRUN=1 NNODES=2 NODE_RANK=0 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 \
llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml

FORCE_TORCHRUN=1 NNODES=2 NODE_RANK=1 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 \
llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml

deepspeed 起多机时用 hostfile,端口是 9901。your_program.py 和 ds_config.json 是占位。

deepspeed --num_gpus 8 --num_nodes 2 --hostfile hostfile --master_addr hostname1 --master_port=9901 \
your_program.py <normal cl args> --deepspeed ds_config.json

hostfile 一行一个节点,例如 worker-1 slots=4、worker-2 slots=4。没写 hostfile 时先找 /job/hostfile,找不到就用本机全部 GPU。

accelerate 要切参数时,用的是 deepspeed_config.yaml:distributed_type: DEEPSPEED,zero_stage: 3,两处 offload 都是 none,2 台机器、16 个进程,mixed_precision: fp16。这和 1.3.3 的 accelerate_multiNode_config.yaml 不是同一份,那份是 MULTI_GPU,没有 ZeRO。全文在 9.6.2。

accelerate launch \
--config_file deepspeed_config.yaml \
train.py llm_config.yaml

大模型微调33-LLaMA-Factory 学习

10. LLaMA Factory基于FSDP训练模型

LLaMA-Factory 做单机多卡、多机多卡时,分布式引擎有 DDP、DeepSpeed、FSDP。DeepSpeed 那条线在 第 9 节。这一节是 FSDP:用 PyTorch 的全切片把参数切开,再在 LLaMA-Factory 里用 QLoRA 启动。

10.1 三个引擎切什么

DDP 为每个进程建一个实例,进程之间用 torch.distributed 同步。每张卡留一份完整的模型参数和优化器参数,表上只支持数据切分。

DeepSpeed 提供 ZeRO、offload、Sparse Attention、1 bit Adam、流水线并行。用哪些,按任务和设备选。

FSDP(Fully Sharded Data Parallel,全切片数据并行)把模型参数、梯度和优化器参数切开,每张卡只留其中一部分,用来放下更大的模型。还可以把模型参数卸到 CPU,再降一截显存。

引擎数据切分模型切分优化器切分参数卸载
DDP支持不支持不支持不支持
DeepSpeed支持支持支持支持
FSDP支持支持支持支持

四列分别在分什么,见 9.8 第 3 问。FSDP 这一列和 DeepSpeed 一样,差别在实现落在哪:DeepSpeed 用自己的 json,FSDP 用 PyTorch 的包装和 accelerate 的 fsdp_config。三套各自要核对的字段,见 10.9 第 7 问。

10.2 它和 ZeRO 的关系

全切片同时省显存、提高能开的并行度。显存降下来,同样的卡就能铺更多进程。FSDP 是 ZeRO 在框架里的一种实现。常见两套:微软的 DeepSpeed,以及 Meta 的 Fairscale。Fairscale 收进了 PyTorch,FSDP 以它为基础。DeepSpeed 不是把 FSDP 包了一层,见 10.9 第 1 问。

数据并行里,每张 NPU 仍留着一份完整参数,包括模型状态和其余状态。这些参数并不是每一步、每一层都同时用到,某一层只在自己的前向或反向里用。用不到的时候可以把它们挪走,把当下这块的显存空出来。

10.3 先看精度

切权重、优化器状态和梯度之前,先分清计算用哪种浮点、显存里留哪种。常用四种:FP32、FP16、BF16、TF32。FP32、FP16、BF16 的字节数和 8B 那笔账在 9.2。这里补位宽,以及 TF32。

格式指数 / 尾数范围用在哪
FP328 / 23约 (1\mathrm{e}{-38}) 到 (3\mathrm{e}{38})IEEE 754 单精度。权重、激活长期默认用它
FP165 / 10约 (5.96\mathrm{e}{-8}) 到 65504IEEE 754 半精度。混精训练,以及训完再量化来加快推理
BF168 / 7指数范围和 FP32 一样Brain Floating Point。先用在谷歌 TPU,后来用在 GPU、NPU。指数更宽,用来避开 FP16 的溢出
TF328 / 10指数范围和 FP32 一样计算时把 FP32 的尾数从 23 位收成 10 位,累加仍回到 FP32

FP16 比 FP32 省显存、通信也更少。尾数短一些,网络效果通常受影响不大。量化还有 INT8、INT4、INT1,那是训完之后的格式,不是这四种训练浮点。

BF16 这个名字来自谷歌 Brain 小组。指数位和 FP32 一样多,所以范围宽,用来处理 FP16 训练后期梯度过小、一乘学习率就下溢的情况。

TF32 不用在模型代码里改数据类型,计算时自动把 FP32 截成 TF32,算完再变回 FP32。其余代码继续用 FP32。它的尾数和 FP16 一样是 10 位,指数和 FP32 一样是 8 位,可以看成 19 位,也可以看成加长了尾数的 BF16。输入的 FP32 先把尾数从 23 位舍到 10 位,乘法按这个精度做,累加回到 FP32。FP16 和 BF16 要换一整套位布局,TF32 不用改调用方。省的是带宽、存储和计算位数。

在 NPU 上打开 TF32 和 16 位矩阵乘:

torch.backends.npu.matmul.allow_tf32 = True
torch.backends.npu.matmul.allow_16 = True

10.4 混精怎么走

大模型训练里,混精是把计算密集的前向、反向放在低精度,更新仍写回高精度权重。传统数值计算追求 FP64、FP128。训练是在拟合一个高维函数,低精度够用,速度差一截。

FP16 的范围大约是 (5.96\mathrm{e}{-8}) 到 65504。训练后期激活的梯度已经很小,再乘学习率更小,可能小到 FP16 表示不出来,这一步更新等于没做。所以计算用 FP16,权重另留一份 FP32。

开训时准备两套。FP32 那套是优化器状态和主权重。FP16 那套是拿来做前向、反向的模型参数。更新时把 FP16 梯度乘学习率,加到 FP32 主权重上。下一轮再把 FP32 主权重拷回 FP16。激活用 FP16 存,大批量时显存小一截;卡和卡之间传的梯度也是 FP16,通信量跟着降。

flowchart TD
  F2H[float2half] -->|Weights F16| FWD
  A0[Activations F16] --> FWD
  FWD -->|F16| A1[Activations]

  F2H -->|Weights F16| BA[BWD-Actv]
  G0[Activation Grad F16] --> BA
  BA -->|F16| G1[Activation Grad]

  A1 --> BW[BWD-Weight]
  G1 --> BW
  BW -->|F16| WG[Weight Grad]

  MW[Master-Weights F32] -->|F32| WU[Weight Update]
  WG --> WU
  WU -->|F32| UMW[Updated Master-Weights]
  UMW --> F2H

每个节点在干什么,见 10.9 第 4 问。

批量取 2 的幂,并尽量对齐输入、输出神经元的个数,常见是 8 的倍数,再往上取多少看硬件和数据类型。

FSDP 里用 MixedPrecision 指定这套精度。param_dtype 是计算用的参数,reduce_dtype 是通信归约用的梯度,buffer_dtype 是缓冲。

fpSixteen = MixedPrecision(
    param_dtype=torch.float16,
    reduce_dtype=torch.float16,
    buffer_dtype=torch.float16,
)
bfSixteen = MixedPrecision(
    param_dtype=torch.bfloat16,
    reduce_dtype=torch.bfloat16,
    buffer_dtype=torch.bfloat16,
)
model = FSDP(
    model,
    auto_wrap_policy=t5_auto_wrap_policy,
    mixed_precision=bfSixteen,
)

不同模型的层不一样,精度仍是这一份 MixedPrecision,见 10.9 第 6 问。

10.5 包成 FSDP

和 DDP 一样,在原来的模块外面套一层。套上之后,参数、梯度和优化器状态在多张卡之间切开,单卡占的内存变小。用 LLaMA-Factory 时不用手写这两段,见 10.9 第 5 问。

import torch
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP

torch.cuda.set_device(device_id)
sharded_module = FSDP(my_module)

optim = torch.optim.Adam(sharded_module.parameters(), lr=0.0001)
x = sharded_module(x, y=3, z=torch.Tensor([1]))

loss = x.sum()
loss.backward()
optim.step()

先 set_device 指定当前这张卡,再把 my_module 交进去。优化器要建在包好之后的 parameters() 上。

T5 的例子走 fsdp_main。setup_model("t5-base") 加载模型和分词器。LOCAL_RANK、RANK、WORLD_SIZE 从环境变量读。transformer_auto_wrap_policy 指定按 T5Block 自动包装,后面按这个单位切片。

ShardingStrategy.SHARD_GRAD_OP 是 ZeRO-2:梯度和优化器状态切开,每张卡仍留一份完整参数。要 ZeRO-3 就改成 FULL_SHARD。这个变量在下面的构造里没有传进去,构造时传的是包装策略、混精和 device_id。

BF16 要同时满足:有 CUDA、当前卡支持 BF16、CUDA 不低于 11.0、NCCL 可用且版本不低于 2.10。都满足才用 bfSixteen,否则 mp_policy 为 None,按 FP32 训。

def fsdp_main(args):
    model, tokenizer = setup_model("t5-base")

    local_rank = int(os.environ["LOCAL_RANK"])
    rank = int(os.environ["RANK"])
    world_size = int(os.environ["WORLD_SIZE"])

    t5_auto_wrap_policy = functools.partial(
        transformer_auto_wrap_policy,
        transformer_layer_cls={
            T5Block,
        },
    )
    sharding_strategy: ShardingStrategy = ShardingStrategy.SHARD_GRAD_OP
    torch.cuda.set_device(local_rank)

    bf16_ready = (
        torch.version.cuda
        and torch.cuda.is_bf16_supported()
        and LooseVersion(torch.version.cuda) >= "11.0"
        and dist.is_nccl_available()
        and nccl.version() >= (2, 10)
    )

    if bf16_ready:
        mp_policy = bfSixteen
    else:
        mp_policy = None

    model = FSDP(
        model,
        auto_wrap_policy=t5_auto_wrap_policy,
        mixed_precision=mp_policy,
        device_id=torch.cuda.current_device(),
    )

    optimizer = optim.AdamW(model.parameters(), lr=args.lr)
    scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)

    for epoch in range(1, args.epochs + 1):
        train_accuracy = train(
            args, model, rank, world_size, train_loader, optimizer, epoch
        )
        scheduler.step()

模型还在 CPU 上时就送进 FSDP,同时给上包装策略、混精和当前设备。包完再进多卡上的前向和反向。要少写这些参数、直接配 ZeRO 档,用 DeepSpeed 的 json,见 9.4。

10.6 切分策略对应哪一档 ZeRO

ShardingStrategy 决定参数怎么分。和 9.3 的阶段对齐:

取值切开什么每张卡仍留着对应
FULL_SHARD模型参数、梯度、优化器状态只留自己那一片ZeRO-3
SHARD_GRAD_OP梯度、优化器状态一份完整的模型参数ZeRO-2
NO_SHARD都不切完整的参数、梯度和优化器状态ZeRO-0

LLaMA-Factory 这份 accelerate 配置用的是 FULL_SHARD。

10.7 在 LLaMA-Factory 里启动

FSDP 加 QLoRA 改两个文件:examples/accelerate/fsdp_config.yaml,以及 examples/extras/fsdp_qlora/llama3_lora_sft.yaml。然后:

bash examples/extras/fsdp_qlora/train.sh

脚本里写明不要把 GPTQ、AWQ 模型拿来做 FSDP+QLoRA。两张卡由 CUDA_VISIBLE_DEVICES=0,1 指定,配置文件和训练 yaml 分开传。

#!/bin/bash
# DO NOT use GPTQ/AWQ model in FSDP+QLoRA

CUDA_VISIBLE_DEVICES=0,1 accelerate launch \
    --config_file examples/accelerate/fsdp_config.yaml \
    src/train.py examples/extras/fsdp_qlora/llama3_lora_sft.yaml

训练 yaml 仍是 LoRA,多一行 quantization_bit: 4,底模按 4 比特放,adapter 仍是 LoRA。示例里的模型路径是 meta-llama/Meta-Llama-3-8B-Instruct。机器上打开的同一份把这一行改成了魔搭缓存。下面按机器上的路径写,其余字段与示例相同。eval 整段注释掉。

### model
model_name_or_path: /mnt/workspace/.cache/modelscope/models/LLM-Research/Meta-Llama-3-8B-Instruct
quantization_bit: 4
trust_remote_code: true

### method
stage: sft
do_train: true
finetuning_type: lora
lora_rank: 8
lora_target: all

### dataset
dataset: identity,alpaca_en_demo
template: llama3
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16
dataloader_num_workers: 4

### output
output_dir: saves/llama3-8b/lora/sft
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true
save_only_model: false
report_to: none  # choices: [none, wandb, tensorboard, swanlab, mlflow]

### train
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
learning_rate: 1.0e-4
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true
ddp_timeout: 180000000

### eval
# val_size: 0.1
# per_device_eval_batch_size: 1
# eval_strategy: steps
# eval_steps: 500

和 9.5 那份带 DeepSpeed 的 LoRA 比,这份没有 deepspeed:,多了 quantization_bit: 4。样本数是 1000,学习率 1.0e-4,3 个 epoch,梯度累积 8。DeepSpeed 那份是 max_samples: 10、1 个 epoch、梯度累积 2,并且指向 ds_z3_config.json。

accelerate 配置是 distributed_type: FSDP,不是 1.4 里那份 DEEPSPEED。两份内容不一样,不要合成一份。

机器上打开的 fsdp_config.yaml 是 1 台机器、2 个进程,和脚本里的两张卡一致。fsdp_sharding_strategy: FULL_SHARD 对应 ZeRO-3。fsdp_offload_params: false,没有把参数卸到 CPU。混精写 bf16,注释里写了可以改成 fp16。两个 rank 挤在同一张卡,或参数形状对不上,改 num_processes 和 fsdp_offload_params,见 10.8。

compute_environment: LOCAL_MACHINE
debug: false
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch: BACKWARD_PRE
  fsdp_forward_prefetch: false
  fsdp_cpu_ram_efficient_loading: true
  fsdp_offload_params: false
  fsdp_sharding_strategy: FULL_SHARD
  fsdp_state_dict_type: FULL_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_use_orig_params: true
machine_rank: 0
main_training_function: main
mixed_precision: bf16  # or fp16
num_machines: 1  # the number of nodes
num_processes: 2  # the number of GPUs in all nodes
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

说明里的 examples/accelerate/fsdp_config.yaml 仍是 FULL_SHARD、1 台机器、2 个进程。差别是 fsdp_offload_params: true,注释写明卸载可能拖慢训练;mixed_precision 写成 fp16,注释里可以改成 bf16。

### /examples/accelerate/fsdp_config.yaml
compute_environment: LOCAL_MACHINE
debug: false
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch: BACKWARD_PRE
  fsdp_forward_prefetch: false
  fsdp_cpu_ram_efficient_loading: true
  fsdp_offload_params: true  # offload may affect training speed
  fsdp_sharding_strategy: FULL_SHARD
  fsdp_state_dict_type: FULL_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_use_orig_params: true
machine_rank: 0
main_training_function: main
mixed_precision: fp16  # or bf16
num_machines: 1  # the number of nodes
num_processes: 2  # the number of GPUs in all nodes
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

num_processes 要和实际使用的 GPU 总数一致。节点数、总进程数改 num_machines、num_processes。也可以先跑 accelerate config,按提示生成一份,再改成这些 FSDP 字段。

说明里的启动命令不带 CUDA_VISIBLE_DEVICES,配置文件写成 fsdp_config.yaml,训练参数是 llm_config.yaml。这和上面的 train.sh 不是同一条。

accelerate launch \
  --config_file fsdp_config.yaml \
  src/train.py llm_config.yaml

FSDP+QLoRA 不要用 GPTQ、AWQ 模型。train.sh 开头的注释说的是同一件事。

10.8 两则训练报错

1. 两个 rank 挤在同一张卡

NCCL 报 invalid usage,版本是 2.21.5。最后一行是:Duplicate GPU detected : rank 0 and rank 1 both on CUDA device 70。rank 0 和 rank 1 都落在同一张卡上。

fsdp_config.yaml 里把 num_processes 改成 1。进程数要等于实际用到的 GPU 数,两份进程挤在一张卡上时就写成 1。

2. 参数写回时形状变了

RuntimeError: Cannot writeback when the parameter shape changes
Expects torch.Size([525336576]) but got torch.Size([128256, 4096])

要写回去的是一维的 525336576,拿到的是 (128256 \times 4096)。两者相等,是同一块权重:一边已经拉平,一边还是矩阵。

fsdp_config.yaml 里把 fsdp_offload_params 改成 true。

fsdp_offload_params 决定参数放在 GPU 上,还是卸到 CPU 内存。写成 true 时,参数留在 CPU 内存里,算到这一块再搬回 GPU。单卡占的显存小一截,同样的卡可以放下更大的模型,或者把 batch 开大一点。

参数要参与计算之前,先预取到 GPU。算完的梯度再异步搬回 CPU。搬运和计算叠在一起,用来盖住这次搬运的时间。显存很紧时用它,例如消费级显卡,或者多个人共用一台 GPU 服务器。

代价是变慢。参数要在 CPU 和 GPU 之间多走一趟。CPU 到 GPU 的带宽不够时,例如走 PCIe,这次搬运会成为瓶颈。说明里那份配置的注释写的是同一件事:卸载可能拖慢训练。机器上打开的那份仍是 false,碰到上面这个形状错误再改成 true。

10.9 拓展QA

1. DeepSpeed 是 FSDP 封装之后的结果吗?ZeRO 是两边共用的技术栈吗?

不是封装。共用的是 ZeRO 这套切分办法,不是同一套代码。

ZeRO 规定三块怎么切:优化器状态、梯度、模型参数。框架里有两套实现,互不调用。微软做的是 DeepSpeed,用 ds_z0_config.json 这一类 json 里的 stage 选档。Meta 做的是 Fairscale,收进 PyTorch 之后就是 FSDP,用 ShardingStrategy 或 accelerate 里的 fsdp_sharding_strategy 选档。档可以对齐:FULL_SHARD 对 ZeRO-3,SHARD_GRAD_OP 对 ZeRO-2,NO_SHARD 对 ZeRO-0,见 10.6。

LLaMA-Factory 一次训练只走一边。yaml 写 deepspeed: 就用 DeepSpeed 的 json。distributed_type: FSDP 就用 accelerate 的 fsdp_config。没有先包成 FSDP、再在外面套一层 DeepSpeed。

2. DeepSpeed 是 DDP 封装之后的结果吗?

也不是。进程这一层和 DDP 相同,切分这一层是 DeepSpeed 多出来的。

FORCE_TORCHRUN、torchrun、accelerate launch 拉起的都是数据并行进程:每张卡拿自己的样本,进程之间用 torch.distributed 同步。只开到这一层,就是 DDP。每张卡留完整的权重和优化器状态。

DeepSpeed 不替换这些进程。yaml 里的 deepspeed: 指向哪份 json,由 stage 决定在这些进程上再切优化器状态、梯度或模型参数。所以看到多卡命令,先看有没有这份 json:没有就是 DDP,有就是在 DDP 进程上加了 ZeRO。FSDP 也是加在同一类进程上,只是切分改由 fsdp_sharding_strategy 做,不是 DeepSpeed 的外层。

3. DDP、DeepSpeed、FSDP 是框架,llamafactory-cli、torchrun、accelerate 是里面的三种训练方法吗?llamafactory-cli 底层是在调用 torchrun 吗?

不是三种训练方法。左边三个是引擎,决定参数放在哪。右边三个是启动器,负责把进程拉起来。LLaMA-Factory 才是这次用的训练框架,一次选一个引擎。换启动器不会自动换成另一个引擎。

启动器这一门里怎么选引擎谁拉起进程
llamafactory-cliyaml 没有 deepspeed:,就是 DDP。写了 deepspeed: ds_z3_config.json 这一类路径,就是 DeepSpeed多卡命令前有 FORCE_TORCHRUN=1 时,由它去调用 torchrun。单卡那条没有这个变量,当前进程直接训练
torchrun记下来的命令没有 --deepspeed,是 DDP。入口仍是 src/train.py,加上 --deepspeed 指向 json 就能切自己执行 torchrun
accelerate配置是 MULTI_GPU 就是 DDP。distributed_type: DEEPSPEED 走 DeepSpeed,distributed_type: FSDP 走 FSDPaccelerate launch 自己拉起,不经过 llamafactory-cli

单机多卡、多机多卡的 llamafactory-cli 都带 FORCE_TORCHRUN=1,见 8.4。单卡是 llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml,不经过 torchrun。命令行上直接写 json 时,用的是另一条 deepspeed 启动命令,也不经过 llamafactory-cli,见 9.8 第 7 问。

4. 混精那张图里,每个节点是干什么的?

图上是一轮。先用 FP16 把前向、反向算完,得到权重梯度;再用这份梯度去改 FP32 主权重;改完的主权重变回 FP16,供下一轮用。

节点干什么
float2half把 FP32 主权重收成 FP16 权重。前向和反向用的都是这份,不直接拿主权重去算
Activations F16(进 FWD 的)这一层的输入,FP16。第一层来自上一层的输出,最底下那层来自输入本身
FWD前向。FP16 权重乘 FP16 输入,得到这一层的输出
Activations(出 FWD 的)前向的结果,仍是 FP16。交给下一层做前向,也留给 BWD-Weight 用来算权重梯度
Activation Grad F16(进 BWD-Actv 的)上一层传回来的损失对输出的梯度,FP16。反向从最后一层往前走
BWD-Actv对激活求梯度。用 FP16 权重和上面那份激活梯度,算出要传给前一层的梯度
Activation Grad(出 BWD-Actv 的)传给前一层的激活梯度。它再进前一层的 BWD-Actv,也进本层的 BWD-Weight
BWD-Weight对权重求梯度。用前向留下的激活,和这份激活梯度,算出权重该怎么改
Weight Grad权重梯度,FP16。这是本轮计算的结果,拿去更新主权重
Master-Weights F32真正保存的那份权重,FP32。优化器状态也留在这个精度上
Weight Update把 FP16 的权重梯度乘学习率,加到 FP32 主权重上。更新发生在高精度这边
Updated Master-Weights更新后的 FP32 主权重。下一轮先经过 float2half,再进前向

FWD、BWD-Actv、BWD-Weight 三条边上的 F16 是这一步的输入输出都按 FP16 算。Weight Update 两侧的 F32 是主权重进去、更新后的主权重出来,精度不变。

5. 用 LLaMA-Factory 时,还要手写那两段 FSDP 代码吗?

不用。那两段是 PyTorch 自己调用 FSDP 的写法,用来看它包的是哪一层。走 LLaMA-Factory 时改 fsdp_config.yaml 和训练 yaml,再执行 train.sh。训练 yaml 里没有 FSDP(...)。

fsdp_config.yaml 里的字段对应那两段里要手写的参数。fsdp_sharding_strategy: FULL_SHARD 对应切参数、梯度和优化器状态。fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP 对应 fsdp_main 里按 T5Block 自动包装。mixed_precision: bf16 对应构造时传入的 bfSixteen。accelerate 按这份配置去执行等价的 FSDP(...)。

10.4 的图也不是要手写的过程。它说明 FP16 算前向和反向、FP32 主权重负责更新。配置里写了 bf16,这一圈由框架去做。

6. 不同模型的 Transformer 不一样,FSDP 怎么让混精走同一条路径?

混精改的是参数、梯度和缓冲的数据类型,一层里面是哪种注意力、哪种前馈,不参加这条路径。

模型再不同,也是一棵 nn.Module,权重都是 nn.Parameter。FSDP 包住一个模块之后,对里面每个参数做同一件事:前向和反向前把参数收成 param_dtype,卡和卡之间归约梯度时用 reduce_dtype,缓冲用 buffer_dtype。这就是 10.4 那一圈。图上只有权重和激活的精度,没有某一模型的层名。LLaMA 的一层和 T5 的一层都是矩阵乘,所以走同一圈。

随模型换的是包哪一层,用来决定切片的粒度。fsdp_main 把 transformer_layer_cls 写成 T5Block,是按 T5 的一块来切。LLaMA-Factory 的配置写 fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP,按当前加载的模型决定包哪一层。包的边界变了,边界里面的参数仍用构造时传入的那一份 mixed_precision。配置里写 bf16 或 fp16,也是整次训练一份,不按模型再写一套。

7. 用 DDP、DeepSpeed、FSDP 时,配置里要看哪些字段?

一次训练只开一个引擎。学习率、epoch、数据集三套训练 yaml 都有,下面只列决定引擎和切分的字段。数据切分没有字段,多进程拉起来就在切样本。

训练 yaml 里有 deepspeed: 这一行,这次就是 DeepSpeed。DDP 那一节打开的 llama3_full_sft.yaml 指向 ds_z3_config.json,走的是 DeepSpeed。DDP 用的是没写这一行的配置,例如多机命令里的 llama3_lora_sft.yaml,以及命令上没有 --deepspeed 的 torchrun。

引擎这一门常用的文件要核对的字段
DDPexamples/train_lora/llama3_lora_sft.yaml不写 deepspeed:。精度是 bf16: true。多卡在命令前加 FORCE_TORCHRUN=1,卡数不写在 yaml 里
DeepSpeedllama3_lora_sft_ds3.yaml,以及它指向的 ds_z3_config.jsonyaml 看 deepspeed: 那一行。json 看 stage。显存不够,这一行改成 ds_z3_offload_config.json
FSDPfsdp_config.yaml,再加 QLoRA 训练 yamldistributed_type: FSDP,FULL_SHARD,num_processes 等于实际 GPU 数。训练 yaml 不写 deepspeed:,多 quantization_bit: 4

DDP 和 DeepSpeed 常用 llamafactory-cli 加训练 yaml。accelerate 的 MULTI_GPU、DEEPSPEED 是另一条启动,这一门不靠它。FSDP 没有 llamafactory-cli 那条,常用的就是 accelerate launch 加 fsdp_config.yaml,所以下面第三份仍是它。

下面每份都按字段加了注释。带 * 的是跑之前要核对的:底模、数据、模板、微调方式、精度、batch,以及这一行会不会把引擎换掉。yaml 里的注释可以留着再跑。json 里的 // 只用来看,另存进 .json 会坏,DeepSpeed 直接用仓库里的原文件。

DDP 是机器上跑通的 llama3_lora_sft.yaml。单卡直接 llamafactory-cli train 这份。多卡在命令前加 FORCE_TORCHRUN=1。原文在 4.3。

# DDP。没有 deepspeed: 这一行。每张卡留完整的权重和优化器状态,只切样本。
# 单卡:llamafactory-cli train 这份。多卡:命令前加 FORCE_TORCHRUN=1。

# * 底模。能联网用下面注释掉的模型 ID,这台机器用本地缓存。换模型就改这一行。
# model_name_or_path: LLM-Research/Meta-Llama-3-8B-Instruct
model_name_or_path: /mnt/workspace/.cache/modelscope/models/LLM-Research/Meta-Llama-3-8B-Instruct
trust_remote_code: true                 # 允许执行模型仓库自带的代码。魔搭上这份需要

stage: sft                              # 监督微调
do_train: true                          # 执行训练
finetuning_type: lora                   # * lora 只训低秩矩阵。写成 full 是全量,显存大一截
lora_rank: 8                            # LoRA 的秩。越大,可训练参数越多
lora_target: all                        # 所有线性层都加 LoRA

dataset: identity,alpaca_zh_demo        # * 数据集名字,逗号拼多份。名字要在 dataset_info.json 里
template: llama3                        # * 对话模板,必须和底模同一家。Llama-3 用 llama3
cutoff_len: 2048                        # 单条样本最长 token 数。越长越吃显存
max_samples: 100                        # 最多取多少条。先跑通可以再改小
overwrite_cache: true                   # 覆盖预处理缓存。改了数据或长度就保持 true
preprocessing_num_workers: 16           # 预处理用的进程数
dataloader_num_workers: 4               # 训练时读数据的进程数

output_dir: saves/llama3-8b/lora/sft    # * 权重和日志写到这里。换一次实验就换目录
logging_steps: 5                        # 每 5 步在终端打一次 loss
save_steps: 5                           # 每 5 步存一次。完整跑可以改成 500
plot_loss: true                         # 训练结束画 loss 曲线
overwrite_output_dir: true              # 目录里已有结果时覆盖
save_only_model: false                  # false 连优化器状态一起存,才能断点续训
report_to: none                         # 不上传曲线。要看图再改成 tensorboard 或 swanlab

per_device_train_batch_size: 1          # * 每张卡一次送几条。显存不够保持 1
gradient_accumulation_steps: 8          # * 累积多少步再更新。全局 batch = 本项 × 每卡 batch × 卡数
learning_rate: 1.0e-4                   # 学习率。LoRA 这份是 1e-4
num_train_epochs: 3.0                   # 数据过几遍
lr_scheduler_type: cosine               # 学习率按余弦下降
warmup_ratio: 0.1                       # 前 10% 的步数把学习率从 0 升上去
bf16: true                              # * 计算用 bf16。这台卡跑通过,就保持 true
ddp_timeout: 180000000                  # 多卡互相等待的超时,单位毫秒。这一门没有改
resume_from_checkpoint: null            # null 从头训。续训就写成 checkpoint 目录

DeepSpeed 是 llama3_lora_sft_ds3.yaml。多卡同样是 FORCE_TORCHRUN=1 llamafactory-cli train 这份。和上面那份的差别在 deepspeed: 这一行。原文在 9.5。

# DeepSpeed。和 DDP 那份的差别就是 deepspeed: 这一行。多卡:FORCE_TORCHRUN=1 llamafactory-cli train 这份。

### model
# * 底模。这台机器用本地缓存。换模型就改这一行。
model_name_or_path: /mnt/workspace/.cache/modelscope/models/LLM-Research/Meta-Llama-3-8B-Instruct
trust_remote_code: true                 # 允许执行模型仓库自带的代码

### method
stage: sft                              # 监督微调
do_train: true                          # 执行训练
finetuning_type: lora                   # * lora 只训低秩矩阵。写成 full 是全量
lora_rank: 8                            # LoRA 的秩
lora_target: all                        # 所有线性层都加 LoRA
# * 有这一行就是 DeepSpeed,没有就是 DDP。现在指向 ZeRO-3。显存不够,文件名改成 ds_z3_offload_config.json
deepspeed: examples/deepspeed/ds_z3_config.json  # choices: [ds_z0_config.json, ds_z2_config.json, ds_z3_config.json]

### dataset
dataset: identity,alpaca_en_demo        # * 数据集名字。这份是英文 demo,加上 identity
template: llama3                        # * 对话模板,必须和底模同一家
cutoff_len: 2048                        # 单条样本最长 token 数
max_samples: 10                         # 最多取多少条。这份是先跑通的 10 条
overwrite_cache: true                   # 覆盖预处理缓存
preprocessing_num_workers: 16           # 预处理进程数
dataloader_num_workers: 4               # 训练时读数据的进程数

### output
output_dir: saves/llama3-8b/lora/sft    # * 权重和日志的目录
logging_steps: 5                        # 每 5 步打一次 loss
save_steps: 5                           # 每 5 步存一次
plot_loss: true                         # 训练结束画 loss 曲线
overwrite_output_dir: true              # 覆盖已有输出
save_only_model: false                  # false 连优化器状态一起存
report_to: none                         # choices: [none, wandb, tensorboard, swanlab, mlflow]

### train
per_device_train_batch_size: 1          # * 每张卡一次送几条
gradient_accumulation_steps: 2          # * 累积多少步再更新。json 里同名字段是 auto,启动时用这一行填
learning_rate: 1.0e-4                   # 学习率
num_train_epochs: 1.0                   # 这份只跑 1 个 epoch
lr_scheduler_type: cosine               # 学习率按余弦下降
warmup_ratio: 0.1                       # 前 10% 的步数升温
bf16: true                              # * 计算用 bf16。json 里 bf16.enabled 是 auto,跟着这一行
ddp_timeout: 180000000                  # 多卡等待超时,单位毫秒
resume_from_checkpoint: null            # null 从头训

### eval
# 整段注释掉,这次不算验证集。要开就把井号去掉。
# eval_dataset: alpaca_en_demo          # 验证用哪份数据
# val_size: 0.1                         # 不另给验证集时,从训练集划出 10%
# per_device_eval_batch_size: 1         # 验证时每张卡的 batch
# eval_strategy: steps                  # 按步数做验证
# eval_steps: 500                       # 每 500 步验证一次

切到哪一档不在这份 yaml 里,在它指向的 json。要跑就用仓库里的 ds_z3_config.json,不要把下面这段另存。// 是读的时候用的。带 * 的只有 stage。这里只摘了 zero_optimization,前半段的 batch 和 bf16.enabled 都是 "auto",全文在 9.4,字段对照见 9.8 第 4 问。

"zero_optimization": {
    "stage": 3,                                  // * 3:切优化器、梯度和参数。换档改这个数,或换 yaml 里的文件名
    "overlap_comm": true,                        // 通信和计算叠在一起。offload 那份改成 false
    "contiguous_gradients": true,                // 梯度在显存里排紧凑
    "sub_group_size": 1e9,                       // 参数分组的大小。仓库填的,不用改
    "reduce_bucket_size": "auto",                // 梯度打包传输的桶。auto 不用改
    "stage3_prefetch_bucket_size": "auto",       // 预取下一块参数的桶。不用改
    "stage3_param_persistence_threshold": "auto",// 多小的参数留在卡上、不反复传。不用改
    "stage3_max_live_parameters": 1e9,           // 显存里同时留多少参数。不用改
    "stage3_max_reuse_distance": 1e9,            // 一块参数隔多远会再用到。不用改
    "stage3_gather_16bit_weights_on_model_save": true  // 存盘时把 16 位权重凑成完整一份
}

FSDP 这一门没有写进 llamafactory-cli 的训练 yaml。常用启动是 bash examples/extras/fsdp_qlora/train.sh,里面是 accelerate launch 带上两份文件:下面的训练 yaml,和再下面的 fsdp_config.yaml。训练 yaml 的字段值与 10.7 相同。

# FSDP 的训练 yaml。不要加 deepspeed:,加了就变成 DeepSpeed。不用 GPTQ、AWQ 模型。

### model
# * 底模。示例是 meta-llama/Meta-Llama-3-8B-Instruct,这台机器改成魔搭缓存。
model_name_or_path: /mnt/workspace/.cache/modelscope/models/LLM-Research/Meta-Llama-3-8B-Instruct
quantization_bit: 4                     # * 底模按 4 比特放,训练的仍是 LoRA。这是 QLoRA 多出来的一行
trust_remote_code: true                 # 允许执行模型仓库自带的代码

### method
stage: sft                              # 监督微调
do_train: true                          # 执行训练
finetuning_type: lora                   # * 只训 LoRA。底模是上面的 4 比特
lora_rank: 8                            # LoRA 的秩
lora_target: all                        # 所有线性层都加 LoRA

### dataset
dataset: identity,alpaca_en_demo        # * 数据集名字
template: llama3                        # * 对话模板,必须和底模同一家
cutoff_len: 2048                        # 单条样本最长 token 数
max_samples: 1000                       # 最多取多少条
overwrite_cache: true                   # 覆盖预处理缓存
preprocessing_num_workers: 16           # 预处理进程数
dataloader_num_workers: 4               # 训练时读数据的进程数

### output
output_dir: saves/llama3-8b/lora/sft    # * 权重和日志的目录
logging_steps: 10                       # 每 10 步打一次 loss
save_steps: 500                         # 每 500 步存一次
plot_loss: true                         # 训练结束画 loss 曲线
overwrite_output_dir: true              # 覆盖已有输出
save_only_model: false                  # false 连优化器状态一起存
report_to: none                         # choices: [none, wandb, tensorboard, swanlab, mlflow]

### train
per_device_train_batch_size: 1          # * 每张卡一次送几条
gradient_accumulation_steps: 8          # * 累积多少步再更新
learning_rate: 1.0e-4                   # 学习率
num_train_epochs: 3.0                   # 数据过 3 遍
lr_scheduler_type: cosine               # 学习率按余弦下降
warmup_ratio: 0.1                       # 前 10% 的步数升温
bf16: true                              # * 训练 yaml 的精度。要和 fsdp_config.yaml 的 mixed_precision 对上
ddp_timeout: 180000000                  # 多卡等待超时,单位毫秒

### eval
# 整段注释掉,这次不算验证集。要开就把井号去掉。
# val_size: 0.1                         # 从训练集划出 10% 做验证
# per_device_eval_batch_size: 1         # 验证时每张卡的 batch
# eval_strategy: steps                  # 按步数做验证
# eval_steps: 500                       # 每 500 步验证一次

下面是机器上打开的 fsdp_config.yaml:1 台机器、2 个进程,和脚本里的两张卡一致。说明里那份同名文件差两行,写在对应注释里,不要合成一份。

# FSDP 的集群配置。切分和精度在这份,不在训练 yaml。
# 启动:CUDA_VISIBLE_DEVICES=0,1 accelerate launch --config_file 这份 src/train.py 上面那份训练 yaml

compute_environment: LOCAL_MACHINE      # 在本机跑
debug: false                            # 不开调试
distributed_type: FSDP                  # * 这一行选定 FSDP
downcast_bf16: 'no'                     # 不靠这项再改精度,精度看 mixed_precision
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP  # 按当前模型的一层来包,决定切片粒度
  fsdp_backward_prefetch: BACKWARD_PRE           # 反向开始前先把下一层参数取回
  fsdp_forward_prefetch: false                   # 前向不提前取下一层
  fsdp_cpu_ram_efficient_loading: true           # 加载权重时少占 CPU 内存
  fsdp_offload_params: false                     # * 参数留在 GPU。说明里那份写成 true。形状对不上的报错也改成 true,见 10.8
  fsdp_sharding_strategy: FULL_SHARD             # * 切参数、梯度和优化器状态,对应 ZeRO-3
  fsdp_state_dict_type: FULL_STATE_DICT          # 存盘时凑成一份完整权重
  fsdp_sync_module_states: true                  # 开训前把各进程的参数对齐成同一份
  fsdp_use_orig_params: true                     # 优化器按原来的参数建。LoRA 需要这样
machine_rank: 0                         # 单机就是第 0 台
main_training_function: main            # 入口函数名,保持 main
mixed_precision: bf16                   # * 机器上打开的是 bf16,和训练 yaml 的 bf16: true 一致。说明里那份写成 fp16
num_machines: 1                         # * 机器数
num_processes: 2                        # * 进程数,等于实际使用的 GPU 总数。两个 rank 挤在同一张卡时改成 1,见 10.8
rdzv_backend: static                    # 进程会合方式,示例是 static
same_network: true                      # 这些卡在同一网络
tpu_env: []                             # 下面三项是 TPU。这次用 GPU,保持关闭
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false                          # 用 GPU

11. LLaMA Factory模型训练跟踪和检测

训练过程要看 loss 和其余指标,LLaMA-Factory 接了四种:LlamaBoard、SwanLab、TensorBoard、Wandb。

LlamaBoard 在 WebUI 里。先进入 WebUI:

llamafactory-cli webui

四个界面:训练、评估与预测、对话、导出。训练这一页打开过的是中文、模型名 LLAMA3-8B、路径 ./Meta-Llama-3-8B、微调方法 lora、训练阶段 Supervised Fine-Tuning、数据集 alpaca_zh_demo。

11.1 LlamaBoard

LlamaBoard 是 WebUI 训练页自带的 loss 曲线。图例有 original 和 smoothed。用 WebUI 点「开始」就会画,训练 yaml 里不用再加字段。

打开过的一次:输出目录 train_2025-06-06-22-12-59,设备数量 1,DeepSpeed stage 是 none。曲线画在这一页的右侧。

训练 yaml 里的 plot_loss: true 是训练结束之后,在输出目录里另存一张 loss 图。和这块看板不是同一处。

11.2 SwanLab

SwanLab 是开源的训练跟踪。云端和本机都能用,能记超参数、指标、硬件,也能把几次实验放在一起比。

训练 yaml 里加这三行:

use_swanlab: true
swanlab_project: llamafactory
swanlab_run_name: test_run

前面几份训练 yaml 的 report_to: none 注释里也列了 swanlab。这里用的是上面这三行,不是改 report_to。

WebUI 里在 SwanLab 参数设置中勾上「使用 SwanLab」。项目名填 llamafactory。实验名、工作区、API 密钥可以空着:工作区默认是个人工作区,已经登录就不用再填密钥。模式下拉有 cloud 和 local。说明里的示例选的是 cloud,打开过的一次选的是 local。

local 这次训练打出 SwanLab 0.6.0,可训练参数 20,971,520。日志写在:

/mnt/workspace/LLaMA-Factory/swanlog/run-20250606_222605-a3b1799d

终端里给的查看命令是 swanlab watch /mnt/workspace/LLaMA-Factory/swanlog。装看板并打开:

pip install swanlab
pip install 'swanlab[dashboard]'
swanlab watch /mnt/workspace/LLaMA-Factory/swanlog

起来之后是 SwanLab Experiment Dashboard v0.6.0,本机地址 http://127.0.0.1:5092。停掉用 Ctrl+C。

看板上项目名是 llamafactory,存储路径就是上面的 swanlog。列表里有两次已完成的实验:swan-2 跑了 8 秒,swan- 跑了 9 秒。框架都是 transformers、LlamaFactory。

说明里的曲线示例是 Qwen2-1.5B-Instruct,旁边还能勾上 Qwen2-VL-7B-Instruct 一起比。图上有 train/loss、train/grad_norm、train/learning_rate、train/epoch。

11.3 TensorBoard

TensorBoard 是 TensorFlow 开源的离线跟踪。训练 yaml 里改一行:

report_to: tensorboard

WebUI 里在「其他参数设置」的「启用外部记录面板」中选 tensorboard。

装好再按这次的日志目录打开。tensorboard --version 打出 2.19.0,并提示没有装 TensorFlow,功能少一块,曲线仍能看。

pip install tensorboard
tensorboard --version
tensorboard --logdir=/mnt/workspace/LLaMA-Factory/saves/Custom/lora/train_2025-06-22-13-03/runs --port=6006 --host=localhost

地址是 http://localhost:6006/。另一条把 --logdir 指到 saves/Custom/lora/train_2025-06-06-08-10-05/runs,端口同样是 6006。

打开后能看到 train/epoch、train/grad_norm、train/learning_rate、train/loss,以及 train/num_input_tokens、train/total_flos。

11.4 Wandb

Wandb(Weights and Biases)是云端的训练跟踪。训练 yaml 里加两行:

report_to: wandb
run_name: test_run

WebUI 里同样在「启用外部记录面板」中选 wandb。

12. LLaMA Factory模型部署和接口调用

训完要在 CPU 或别的机器上跑,这一节把权重转成 GGUF,再用 Ollama 拉起来。网页入口是 Open WebUI。

12.1 什么是 GGUF

GGUF 的全名是 GPT-Generated Unified Format。前身是 GGML(GPT-Generated Model Language)。GGML 是给机器学习用的张量库,最早到 2022 年 10 月。它想做成一个单文件就能分发的格式,同一份文件在不同架构的 GPU 和 CPU 上都能推理。后来灵活性不够,兼容也难维护。

训练侧常用 PyTorch。部署时每套库各管一摊,版本也对不齐,于是先后有了 GGML、GGMF、GGJT。开源这边接着改,GGUF 是在 GGJT 上再收过一版,把 GGML 当时的几个问题补上了。

点补的是什么
可扩展给 GGML 那套工具加功能,或给 GGUF 模型加新特性,旧模型文件还能读
mmap用内存映射加载。文件不必先整个读进内存,载入和存储都更快。从 GGJT 起就这么做
好接少量代码就能加载和存储,不必再捆一套推理库。换一种编程语言也容易接
信息在文件里加载要用的信息都在这一个模型文件里,不用另写一份配置
量化支持 4 位、8 位和 F16。权重变小,省显存

12.2 把 Llama-3-8B 转成 GGUF

先从魔搭把底模下到本地。Hugging Face 那行注释掉了,用的是 ModelScope。

# from huggingface_hub import snapshot_download
from modelscope import snapshot_download
model_id = "LLM-Research/Meta-Llama-3-8B-Instruct"
snapshot_download(model_id=model_id, cache_dir="Meta-Llama-3-8B-Instruct")

转换脚本在 llama.cpp 仓库里,文件名是 convert_hf_to_gguf.py。

git clone https://github.com/ggerganov/llama.cpp.git
pip install -r llama.cpp/requirements.txt

机器上转的是已经在魔搭缓存里的那份。不量化留效果,用 f16。要量化就换 q8_0,更快,效果会差一截。

# 如果不量化,保留模型的效果
python llama.cpp/convert_hf_to_gguf.py \
  /mnt/workspace/.cache/modelscope/models/LLM-Research/Meta-Llama-3-8B-Instruct \
  --outtype f16 --verbose \
  --outfile Meta-Llama-3-8B-Instruct_f16.gguf

# 如果需要量化(加速并损效果),直接执行下面脚本就可以
python llama.cpp/convert_hf_to_gguf.py \
  /mnt/workspace/.cache/modelscope/models/LLM-Research/Meta-Llama-3-8B-Instruct \
  --outtype q8_0 --verbose \
  --outfile Meta-Llama-3-8B-Instruct_q8_0.gguf

转的时候日志里有这几行:模型名 Meta-Llama-3-8B-Instruct,架构 LlamaForCausalLM,这份 GGUF 只支持小端,权重表从 model.safetensors.index.json 读。

魔搭模型库里搜 gguf 也能直接下别人转好的文件。这次走的是上面这条自己转。

--outtype 是量化档。转出来的文件是 Meta-Llama-3-8B-Instruct_q8_0.gguf。命令里不量化写的是 f16,下面这张表里不量化写成 fp16 和 f32。

--outtype含义
q2_k一部分张量用更高的精度,其余停在这一档的基础精度
q3_k_l、q3_k_m、q3_k_s不同张量用不同精度,在效果和速度之间折中
q4_0最早的一档,4 位
q4_1、q4_k_m、q4_k_s准确度和速度各差一档,用来平衡显存
q5_0、q5_1、q3_k_m、q5_k_s更准,更吃资源,推理也更慢
q6_k、q8_0这几档里精度最高,也最吃资源、最慢
fp16、f32不量化,留原来的精度

转好的 GGUF 可以用这些工具跑:

工具做什么
Ollama推荐。把本地部署收成几条命令
llama.cppGGUF 的源项目。有命令行,也有 Server
text-generation-webui用得最多的网页界面,扩展多,支持 GPU
GPT4All免费开源的本地图形界面。Windows、Linux、macOS,支持 GPU
LM Studio本地图形界面。Windows 和 macOS(Apple 芯片),支持 GPU
llama-cpp-pythonPython 库。支持 GPU、LangChain,以及和 OpenAI 兼容的 API 服务
candleRust 写的机器学习框架。支持 GPU,偏向把速度做上去

12.3 用 Ollama 跑

用 Ollama 的 Modelfile,指到这份 gguf 就能起模型。

安装并在后台启动服务:

curl -fsSL https://ollama.com/install.sh | sh
nohup ollama serve &

在模型文件旁边建一个名为 ModelFile 的文件。最短只写从哪份 gguf 来:

FROM ./Meta-Llama-3-8B-Instruct_q8_0.gguf

打开过的那份还写了采样和对话模板。temperature 越高越发散,越低越稳。

FROM ./Meta-Llama-3-8B-Instruct_q8_0.gguf

# set the temperature to 0.7 [higher is more creative, lower is more coherent]
PARAMETER temperature 0.7
PARAMETER top_p 0.8
PARAMETER repeat_penalty 1.05
TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ end }}<|im_start|>assistant
{{ .Response }}<|im_end|>"""
# set the system message
SYSTEM """
You are a helpful assistant.
"""

用这份文件创建模型,名字是 Meta-Llama-3-8B-Instruct_q8_0。日志里会解析 GGUF,写完 manifest 后是 success。

ollama create Meta-Llama-3-8B-Instruct_q8_0 --file ./ModelFile
ollama run Meta-Llama-3-8B-Instruct_q8_0

12.4 用 Open WebUI 调用

本机已经有 Ollama 时,再用 Open WebUI 做一个网页。没装就先装,然后启动。

pip install open-webui
open-webui serve

浏览器打开 http://localhost:8080。

大模型微调34-LoRA实测 学习

这次在同一份 Meta-Llama-3-8B-Instruct 上比全量、LoRA、QLoRA:各占多少显存,一步要多久。后面要用其中一种做一个产品问答助手。

1. 环境准备

1.1 租一台机器

在 gpuez.com 登录,租一个新实例。打开过的这一台:显存 32GB,最高 CUDA 12.4,CPU 11 核,内存 60GB,系统盘 30GB,数据盘 50GB,硬盘一共 154GB。单精 48.70 TFLOPS,半精 97.40 Tensor TFLOPS。空闲卡是 6/8,这次 GPU 数量选 1。镜像选 Miniconda / conda3 / 3.10,ubuntu22.04 / 11.8。配置费用 2.56 元/时。选完点立即创建。

1.2 基本环境

conda init bash
. ~/.bashrc
git init
sudo apt update
sudo apt install less nano

镜像带的是 CUDA 11.8,把这一版加进当前环境:

export CUDA_HOME=/usr/local/cuda-11.8
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
export PATH=$CUDA_HOME/bin:$PATH

conda 的下载源写在 ~/.condarc。用 nano ~/.condarc 打开,写上下面这几行:

channels:
  - defaults
show_channel_urls: true

1.3 安装 LLaMA-Factory

git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e ".[torch,metrics]"
pip install modelscope
pip install bitsandbytes
pip install deepspeed==0.14.4
export USE_MODELSCOPE_HUB=1

USE_MODELSCOPE_HUB=1 之后,yaml 里的模型名走魔搭,不再走 Hugging Face。

2. 三次实测

底模都是 LLM-Research/Meta-Llama-3-8B-Instruct。

LoRA 用 examples/train_lora/llama3_lora_sft.yaml。打开时标出来的是模型名、finetuning_type: lora、lora_target: all。stage 是 sft,do_train 是 true。

llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml

QLoRA 打开的文件名是 llama3_lora_sft_otfq.yaml。在模型名下面多两行:4 比特,量化方法 bitsandbytes。可选的方法写在注释里:bitsandbytes 支持 4/8 位,hqq 支持 2/3/4/5/6/8 位,eetq 支持 8 位。

model_name_or_path: LLM-Research/Meta-Llama-3-8B-Instruct
quantization_bit: 4
quantization_method: bitsandbytes  # choices: [bitsandbytes (4/8), hqq (2/3/4/5/6/8), eetq (8)]

同一份模型上量到的显存和一步耗时:

微调方式显存速度
全量微调273G14.2s/it
LoRA20G2.3s/it
QLoRA10G3.2s/it

全量这次占了 273G。前面按参数估算,8B 全量的权重、梯度和 Adam 大约 128GB,激活另算,见 9.2。LoRA 把显存降到 20G,一步也最快。QLoRA 再降到 10G,一步比 LoRA 慢,3.2 秒对 2.3 秒。

怎么选:微调任务首选 LoRA。显存不够,或者要上更大的模型,用 QLoRA。全量留在预训练和增量训练。

大模型微调35-QLoRA 学习

1. 微调方法——QLora方法

论文是 QLORA: Efficient Finetuning of Quantized LLMs,地址 arxiv.org/abs/2305.14…。华盛顿大学提出。底模量化到 4 比特再微调,目标是少占显存,同时把效果拉回 16 比特全量微调。

四个做法:

  • NF4(4bit NormalFloat)。给接近正态分布的权重量身定的 4 比特格式。在这种权重上,实测好于 4 比特整数和 4 比特浮点。
  • 双重量化(Double Quantization)。第一次量化会留下一批常量,再把这批常量量化一次,存储再小一截。
  • 分页优化器(Paged Optimizers)。用 NVIDIA 的统一内存。显存偶尔不够时,优化器状态在 CPU 内存和 GPU 之间按页自动来回搬,GPU 上的计算不会因为这一下撑满就停。做法和操作系统把内存换到磁盘上一样:先给优化器状态分配可分页的内存,显存紧了就卸到 CPU,优化器要更新时再载回 GPU。
  • 多插 Adapter。NF4 加双重量化省下很多空间,精度会掉一截。作者靠多插 adapter 补回来。LoRA 一般只插在 query、value 后面的全连接层。QLoRA 在所有全连接层都插,可训练参数更多,用来补精度损失。

三列并排时,差在底模精度和优化器放哪。蓝箭头是参数更新,绿箭头是梯度,粉箭头是分页搬运。

全量LoRAQLoRA
优化器状态一份 32 比特,跟着全部权重只跟着 adapter,每块一小份同样只跟着 adapter,显存尖峰时整页卸到 CPU
Adapter没有16 比特16 比特,插在每一层全连接上
底模16 比特 Transformer16 比特 Transformer,冻结4 比特 Transformer,冻结

QLoRA 相对 LoRA 多做的两件事,就是把 Transformer 收到 4 比特,并用分页优化器接住显存尖峰。

实验里,adapter 用 16 比特、8 比特或 4 比特,都能回到 16 比特全参数微调的基准。量化本身会掉点,adapter 把这点掉的补上。

GLUE 看的是准确率,模型是 RoBERTa-large。Super-NaturalInstructions 看的是 RougeL,模型从 T5-80M 到 T5-11B。格子里的 - 是这格没有给出数字。每一行是哪一种训法,见 1.1。

方法RoBERTa-largeT5-80MT5-250MT5-780MT5-3BT5-11B
BF1688.640.142.148.054.362.0
BF16 replication88.640.042.247.354.9-
LoRA BF1688.840.542.647.155.460.7
QLoRA Int888.840.442.945.456.560.7
QLoRA FP488.640.342.447.555.660.9
QLoRA NF4 + DQ-40.442.747.755.360.9

几种 4 比特格式比的是 zero-shot 的平均。NF4 明显好于普通 4 比特浮点。NF4 再加双重量化,比只做 NF4 略好一点。双重量化把精度抬得不多,省的是显存。

上一节 QLoRA 实测占 10G,用的就是 bitsandbytes 的 4 比特,见 三次实测。

图上这三项写成 lora_rank、lora_alpha、lora_dropout。这份脚本里对应 LoraConfig 的 r、lora_alpha、lora_dropout,这次取值 8、16、0.05。LLaMA-Factory 的 yaml 用 lora_rank,就是这里的 r。

参数类型做什么这份脚本
lora_rankint,可选秩。低秩矩阵有多宽,越大可训练参数越多r=8
lora_alphafloat,可选缩放系数。LoRA 的更新乘上它再加回原权重lora_alpha=16
lora_dropoutfloat,可选LoRA 支路上的 Dropoutlora_dropout=0.05

同一份脚本把 QLoRA 的前三件事落在 BitsAndBytesConfig 和 LoraConfig 上。底模是本地的百川 7B,只用第 0 张卡。load_in_4bit 加 nf4 是 NF4。bnb_4bit_use_double_quant 是双重量化。计算仍用 BF16,权重留在 4 比特。prepare_model_for_kbit_training 让这份 4 比特模型可以反传。

find_all_linear_names 找出所有 4 比特线性层,再去掉 lm_head。这些层名交给 target_modules,就是在除输出层以外的全连接上都插 adapter。

import bitsandbytes as bnb
import torch
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

model = AutoModelForCausalLM.from_pretrained(
    "./baichuan-7B",
    trust_remote_code=True,
    quantization_config=BitsAndBytesConfig(
        load_in_4bit=True,                       # 权重按 4 比特加载
        bnb_4bit_compute_dtype=torch.bfloat16,   # 计算用 BF16
        bnb_4bit_use_double_quant=True,          # 双重量化
        bnb_4bit_quant_type="nf4",               # NF4
    ),
    device_map={"": 0},
)
model = prepare_model_for_kbit_training(model)

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit
    lora_module_names = set()
    for name, module in model.named_modules():
        if isinstance(module, cls):
            names = name.split(".")
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])
    if "lm_head" in lora_module_names:  # 16 比特的输出层不插
        lora_module_names.remove("lm_head")
    return list(lora_module_names)

modules = find_all_linear_names(model)
config = LoraConfig(
    r=8,
    lora_alpha=16,
    lora_dropout=0.05,
    bias="none",
    target_modules=modules,
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, config)

分页优化器不在这份脚本里。后面的 Trainer 把 optim 写成 adamw_torch。数据是 ./dataset/Belle_open_source_0.5M.json,最长 1024。训练 1 个 epoch,每卡 batch 是 1,梯度累积 4,学习率 3e-4,日志报到 tensorboard。训完用 model.save_pretrained("baichuansft") 存 adapter。完整文件见上面的链接。

拓展QA

1. 实验表里每一行方法是什么,彼此差在哪?

六行做的是同一批任务。GLUE 那一列是 RoBERTa-large 的准确率,后面五列是 T5 在 Super-NaturalInstructions 上的 RougeL。差在底模以什么精度放着、训的是全部权重还是 adapter。

行底模训什么
BF1616 比特,不量化全部权重。这是原来那份基准里公布的全量微调结果
BF16 replication同样是 16 比特全量这篇论文自己把上面那行又跑了一遍,用来核对基准对得上。T5-11B 这格是 -,没有给出复现
LoRA BF1616 比特,冻结只训 adapter。底模不量化,这是 16 比特的 adapter 训法
QLoRA Int8量化成 8 比特整数,冻结只训 adapter。8 比特的 QLoRA
QLoRA FP4量化成 4 比特浮点,冻结只训 adapter。普通的 4 比特浮点
QLoRA NF4 + DQNF4,再加双重量化,冻结只训 adapter。论文主推的这一档。RoBERTa-large 这格是 -

前两行没有 adapter,每个权重都更新。后四行底模冻住,更新的是 adapter。图上 adapter 仍是 16 比特,行名里的 16、8、4 比特说的是底模怎么放。

BF16 和 BF16 replication 是同一种训法的两份数字。两列挨得很近,说明这篇的实验对得上原来的基准。后面四行就拿这个基准来比。

LoRA BF16 到 QLoRA NF4 + DQ,adapter 都在,底模一步比一步更省。Int8 是 8 比特整数。FP4 是 4 比特浮点。NF4 是按权重的分布来排的 4 比特,DQ 是把量化用的缩放系数再压一次,见下面第 2 问。T5-780M 上 Int8 是 45.4,比同列其他行低。其余格子里,4 比特的两行和 16 比特全量、LoRA 都在同一档附近。NF4 + DQ 相对 FP4 抬得不多,省的是显存。

2026.11.13 21:49:36

2. NF4 是啥,DQ 又是啥?

4 比特一共只有 16 个格子,每个权重只能落到其中一格。FP4 是普通的 4 比特浮点,格子按浮点的指数来排,什么数都一视同仁。网络里的权重大多挤在 0 附近,很大的数很少。NF4(Normal Float 4)仍是 4 比特、仍是 16 个格子,但格子按正态分布来排:0 附近更密,两头更稀。常见的那些权重被四舍五入的误差更小。表上「NF4 明显好于普通 4 比特浮点」就是这个差别。脚本里写成 bnb_4bit_quant_type="nf4"。

量化时一块权重共用一个缩放系数,才能把格子里的数还原回去。这些系数原来用更高的精度放着,块一多,它们自己也占显存。DQ(Double Quantization,双重量化)不改权重的 4 比特,是把这些缩放系数再量化一次。权重还是 NF4。表上说精度抬得不多、省的是显存,省的就是这批系数。脚本里的开关是 bnb_4bit_use_double_quant=True。

QLoRA NF4 + DQ 这一行是两件一起做:底模用 NF4 存放,缩放系数再量化一次。adapter 仍是 16 比特,和上面几行一样。

2. LLM微调经验分享

2.1 模型选择

目前主流可微调的模型有 ChatGLM、Baichuan、LLAMA、RWKV。中文较好的是 ChatGLM 和 Baichuan。潜力较好的是 LLAMA。RWKV 的推理效率较好,也有长度外推性。效率来自它的 RNN 架构:输入变长时,内存占比线性增加;Transformer 是指数增长。

2.2 模型大小选择

参数越大,效果一般越好。资源允许时选 30B 以上。参数多、量化低的模型,优于参数少、量化高的模型。页上的例子是 33B-fb4 优于 13b-fb16。

2.3 数据处理

数据可能是 PDF、Word、HTML、代码文件。不同类型都先处理成文本,再滤掉干扰项和乱码。空文档,以及长度低于 100 的文档,也滤掉,用来减少噪音。

2.4 微调方案

前面几种微调方法里,比较推荐 LoRA 或 QLoRA。

2.5 英文模型要不要扩充词表

像 LLaMA 这种模型,词表大小是 32K,主要在英语上训练,具体见 LLaMA 论文。多语种支持不理想。多语言的 XLM-R 词表是 250K。初步统计,LLaMA 词表里中文字符很少,切词时中文被切得更碎,要多个 byte token 才能拼成一个汉字,信息密度下降。扩充过词表的模型里,单个汉字倾向于 1 个 token;LLaMA 里一个汉字可能要 2 到 3 个 token 拼起来,推理效率明显更低。

2.6 如何避免灾难遗忘

下面几种做法可以减少或避免灾难性遗忘。

LoRA 训练出现遗忘时,把 lora_rank 调大,例如从 8 调到 64。和原模型的数据领域差得比较大时,需要更大的秩,原论文有说明。

复习和人一样:预训练或微调时,把之前的训练数据混回来。也可以专门把特征存起来,量化以后放进一个类似记忆库的地方;之后训新任务时,从这个记忆库里重构出记忆,和新数据一起训。页上说参考这篇论文,没有写出论文名。

MoE 是稀疏门控的专家混合层。最近传出 GPT-4 是 8 个 220B 模型的组合。MoE 的资料页上让自己去查。

把学习率调小。ChatGLM 的学习率改到 2e-4 时,训练速度会慢很多。

2.7 拓展QA

1. 模型的幻觉问题如何避免?

理直气壮地说不正确的话,就是幻觉。以前的笔记里写成:生成时胡言乱语,可以是错误陈述、编造事实、复杂推理出错,也可以是复杂语境下理解不够。没在训练里见过的信息答不准,就会臆造。RAG 那节也叫一本正经地胡说。2.6 的灾难遗忘是旧本事被盖掉;幻觉是回答对不上事实。把 lora_rank 调大、学习率改到 2e-4,动的是记不记得住、训得稳不稳。

LangChain 第 52.1 节 写了四条原因。训练知识有偏差,错误被学进去再复现。过度泛化,把普通模式用到不该用的场合。没学到深层含义,复杂推理会错。缺这个领域的知识,就编一段不存在的内容。

那一节里当时的共识是:给模型一段上下文,用 RAG。问题先检索,检索到的文档和问题一起放进 Prompt,再生成。步骤在 RAG 基本原理。这样补的是训练截止之后的资料和私有文档,模型眼前有原文,少编没见过的事实。检索没召回到,或者推理本身错了,幻觉还在。RAG 是减轻,金融和医疗里一次错了仍然严重。

微调这边对着第一条原因做。监督微调学的是把 output 接在问题后面。按 DAY2 企业数据 写:output 必须能在 input 里对上原句,对不上就写拒答。没人改过的草稿不能直接当 output。2.3 里的乱码、空文档、过短文档先滤掉,不然这些噪音也会被说得很顺。系统提示词里写明只根据这段原文回答,对不上就拒答。模型仍然是在续写,只是学过「没有依据」这种答法。