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。
| 格式 | 指数 / 尾数 | 范围 | 用在哪 |
|---|---|---|---|
| FP32 | 8 / 23 | 约 (1\mathrm{e}{-38}) 到 (3\mathrm{e}{38}) | IEEE 754 单精度。权重、激活长期默认用它 |
| FP16 | 5 / 10 | 约 (5.96\mathrm{e}{-8}) 到 65504 | IEEE 754 半精度。混精训练,以及训完再量化来加快推理 |
| BF16 | 8 / 7 | 指数范围和 FP32 一样 | Brain Floating Point。先用在谷歌 TPU,后来用在 GPU、NPU。指数更宽,用来避开 FP16 的溢出 |
| TF32 | 8 / 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-cli | yaml 没有 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 走 FSDP | accelerate 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。
| 引擎 | 这一门常用的文件 | 要核对的字段 |
|---|---|---|
| DDP | examples/train_lora/llama3_lora_sft.yaml | 不写 deepspeed:。精度是 bf16: true。多卡在命令前加 FORCE_TORCHRUN=1,卡数不写在 yaml 里 |
| DeepSpeed | llama3_lora_sft_ds3.yaml,以及它指向的 ds_z3_config.json | yaml 看 deepspeed: 那一行。json 看 stage。显存不够,这一行改成 ds_z3_offload_config.json |
| FSDP | fsdp_config.yaml,再加 QLoRA 训练 yaml | distributed_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.cpp | GGUF 的源项目。有命令行,也有 Server |
| text-generation-webui | 用得最多的网页界面,扩展多,支持 GPU |
| GPT4All | 免费开源的本地图形界面。Windows、Linux、macOS,支持 GPU |
| LM Studio | 本地图形界面。Windows 和 macOS(Apple 芯片),支持 GPU |
| llama-cpp-python | Python 库。支持 GPU、LangChain,以及和 OpenAI 兼容的 API 服务 |
| candle | Rust 写的机器学习框架。支持 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)]
同一份模型上量到的显存和一步耗时:
| 微调方式 | 显存 | 速度 |
|---|---|---|
| 全量微调 | 273G | 14.2s/it |
| LoRA | 20G | 2.3s/it |
| QLoRA | 10G | 3.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 在所有全连接层都插,可训练参数更多,用来补精度损失。
三列并排时,差在底模精度和优化器放哪。蓝箭头是参数更新,绿箭头是梯度,粉箭头是分页搬运。
| 全量 | LoRA | QLoRA | |
|---|---|---|---|
| 优化器状态 | 一份 32 比特,跟着全部权重 | 只跟着 adapter,每块一小份 | 同样只跟着 adapter,显存尖峰时整页卸到 CPU |
| Adapter | 没有 | 16 比特 | 16 比特,插在每一层全连接上 |
| 底模 | 16 比特 Transformer | 16 比特 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-large | T5-80M | T5-250M | T5-780M | T5-3B | T5-11B |
|---|---|---|---|---|---|---|
| BF16 | 88.6 | 40.1 | 42.1 | 48.0 | 54.3 | 62.0 |
| BF16 replication | 88.6 | 40.0 | 42.2 | 47.3 | 54.9 | - |
| LoRA BF16 | 88.8 | 40.5 | 42.6 | 47.1 | 55.4 | 60.7 |
| QLoRA Int8 | 88.8 | 40.4 | 42.9 | 45.4 | 56.5 | 60.7 |
| QLoRA FP4 | 88.6 | 40.3 | 42.4 | 47.5 | 55.6 | 60.9 |
| QLoRA NF4 + DQ | - | 40.4 | 42.7 | 47.7 | 55.3 | 60.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_rank | int,可选 | 秩。低秩矩阵有多宽,越大可训练参数越多 | r=8 |
lora_alpha | float,可选 | 缩放系数。LoRA 的更新乘上它再加回原权重 | lora_alpha=16 |
lora_dropout | float,可选 | LoRA 支路上的 Dropout | lora_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。
| 行 | 底模 | 训什么 |
|---|---|---|
BF16 | 16 比特,不量化 | 全部权重。这是原来那份基准里公布的全量微调结果 |
BF16 replication | 同样是 16 比特全量 | 这篇论文自己把上面那行又跑了一遍,用来核对基准对得上。T5-11B 这格是 -,没有给出复现 |
LoRA BF16 | 16 比特,冻结 | 只训 adapter。底模不量化,这是 16 比特的 adapter 训法 |
QLoRA Int8 | 量化成 8 比特整数,冻结 | 只训 adapter。8 比特的 QLoRA |
QLoRA FP4 | 量化成 4 比特浮点,冻结 | 只训 adapter。普通的 4 比特浮点 |
QLoRA NF4 + DQ | NF4,再加双重量化,冻结 | 只训 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 里的乱码、空文档、过短文档先滤掉,不然这些噪音也会被说得很顺。系统提示词里写明只根据这段原文回答,对不上就拒答。模型仍然是在续写,只是学过「没有依据」这种答法。