2026.11.14 13:12:58
学习路线
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. 模型训练跟踪和检测
训练过程看 loss 和其余指标。LLaMA-Factory 接了四种:LlamaBoard、SwanLab、TensorBoard、Wandb。先进入 WebUI,四个界面是训练、评估与预测、对话、导出。
llamafactory-cli webui
打开过的训练页是中文,模型名 LLAMA3-8B,路径 ./Meta-Llama-3-8B,微调方法 lora,训练阶段 Supervised Fine-Tuning,数据集 alpaca_zh_demo。
四种差在记录写到哪,以及 yaml 改哪一行。
| 看板 | 写到哪 | yaml |
|---|---|---|
| LlamaBoard | WebUI 训练页右侧 | 不用加。点「开始」就画 |
| SwanLab | 云端或本机 swanlog | 三行 use_swanlab,不改 report_to |
| TensorBoard | 本机日志目录 | report_to: tensorboard |
1.1 LlamaBoard
LlamaBoard 是 WebUI 训练页自带的 loss 曲线。图例有 original 和 smoothed。打开过的一次:输出目录 train_2025-06-06-22-12-59,设备数量 1,DeepSpeed stage 是 none。
训练 yaml 里的 plot_loss: true 是训练结束之后,在输出目录里另存一张 loss 图。和这块看板不是同一处。
1.2 SwanLab
SwanLab 是开源的训练跟踪。云端和本机都能用,能记超参数、指标、硬件,也能把几次实验放在一起比。训练 yaml 加这三行。前面几份 yaml 的 report_to: none 注释里也列了 swanlab,这里用的是这三行。
use_swanlab: true
swanlab_project: llamafactory
swanlab_run_name: test_run
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。装看板并打开:
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。列表里有两次已完成的实验: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。
1.3 TensorBoard
TensorBoard 是 TensorFlow 开源的离线跟踪。训练 yaml 改一行,WebUI 里在「其他参数设置」的「启用外部记录面板」中选 tensorboard。
report_to: 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。
2. 模型部署和接口调用
训完要在 CPU 或别的机器上跑。权重转成 GGUF,再用 Ollama 拉起来。网页入口是 Open WebUI。
2.1 什么是 GGUF
GGUF 的全名是 GPT-Generated Unified Format。前身是 GGML(GPT-Generated Model Language),给机器学习用的张量库,最早到 2022 年 10 月。它想做成一个单文件就能分发的格式,同一份文件在不同架构的 GPU 和 CPU 上都能推理。后来灵活性不够,兼容也难维护。
训练侧常用 PyTorch。部署时每套库各管一摊,版本也对不齐,于是先后有了 GGML、GGMF、GGJT。GGUF 是在 GGJT 上再收过一版。
| 点 | 补的是什么 |
|---|---|
| 可扩展 | 给工具加功能,或给模型加新特性,旧模型文件还能读 |
| mmap | 用内存映射加载。文件不必先整个读进内存。从 GGJT 起就这么做 |
| 好接 | 少量代码就能加载和存储,不必再捆一套推理库 |
| 信息在文件里 | 加载要用的信息都在这一个模型文件里 |
| 量化 | 支持 4 位、8 位和 F16。权重变小,省显存 |
2.2 把 Llama-3-8B 转成 GGUF
先从魔搭把底模下到本地。Hugging Face 那行注释掉了。
# 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。
| 工具 | 做什么 |
|---|---|
| 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,偏向把速度做上去 |
2.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
2.4 用 Open WebUI 调用
本机已经有 Ollama 时,再用 Open WebUI 做一个网页。浏览器打开 http://localhost:8080。
pip install open-webui
open-webui serve
3. 基于FSDP训练模型
FSDP 和 DeepSpeed 都在做 ZeRO,代码不是同一套。切权重之前先定浮点和混精:低精度做前向和反向,更新写回高精度主权重。再选切到 ZeRO 的哪一档。LLaMA-Factory 不手写 FSDP(),用 accelerate 的 fsdp_config,训练 yaml 在 LoRA 上多一行 quantization_bit: 4。两则报错分别改进程数和参数卸载。
3.1 它和 ZeRO 的关系
全切片同时省显存、提高能开的并行度。显存降下来,同样的卡就能铺更多进程。FSDP 是 ZeRO 在框架里的一种实现。常见两套:微软的 DeepSpeed,以及 Meta 的 Fairscale。Fairscale 收进了 PyTorch,FSDP 以它为基础。DeepSpeed 不是把 FSDP 包了一层。共用的是 ZeRO 这套切分办法:优化器状态、梯度、模型参数。两套代码互不调用。DeepSpeed 用 json 里的 stage 选档,FSDP 用 ShardingStrategy 或 fsdp_sharding_strategy 选档。
数据并行里,每张 NPU 仍留着一份完整参数,包括模型状态和其余状态。这些参数并不是每一步、每一层都同时用到,某一层只在自己的前向或反向里用。用不到的时候可以把它们挪走,把当下这块的显存空出来。
3.2 先看精度
| 格式 | 指数 / 尾数 | 范围 | 用在哪 |
|---|---|---|---|
| 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 |
混精怎么走:
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
3.3 切分策略对应哪一档 ZeRO
| 取值 | 切开什么 | 每张卡仍留着 | 对应 |
|---|---|---|---|
FULL_SHARD | 模型参数、梯度、优化器状态 | 只留自己那一片 | ZeRO-3 |
SHARD_GRAD_OP | 梯度、优化器状态 | 一份完整的模型参数 | ZeRO-2 |
NO_SHARD | 都不切 | 完整的参数、梯度和优化器状态 | ZeRO-0 |
3.4 在 LLaMA-Factory 里启动
FSDP 加 QLoRA 改两个文件,启动时分开传。examples/accelerate/fsdp_config.yaml 管切分和进程。examples/extras/fsdp_qlora/llama3_lora_sft.yaml 管模型和训练。accelerate 这份是 distributed_type: FSDP。DAY4 的 1.4 那份是 DEEPSPEED,各用各的字段。
3.4.1 启动命令
仓库里的脚本指定两张卡,配置和训练 yaml 用仓库里的路径。注释写明 FSDP+QLoRA 不用 GPTQ、AWQ 模型。
#!/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
直接跑:
bash examples/extras/fsdp_qlora/train.sh
说明里另有一条命令:不带 CUDA_VISIBLE_DEVICES,配置文件写成 fsdp_config.yaml,训练参数写成 llm_config.yaml。
accelerate launch \
--config_file fsdp_config.yaml \
src/train.py llm_config.yaml
3.4.2 训练 yaml
训练 yaml 仍是 LoRA。底模按 4 比特放,多一行 quantization_bit: 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 那份有 deepspeed:,指向 ds_z3_config.json,max_samples: 10,1 个 epoch,梯度累积 2。这份用 quantization_bit: 4,样本数 1000,学习率 1.0e-4,3 个 epoch,梯度累积 8。
3.4.3 fsdp_config
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 其余字段相同,只差两处:
| 字段 | 机器上打开的 | 说明里的 |
|---|---|---|
fsdp_offload_params | false | true,注释写卸载可能拖慢训练 |
mixed_precision | bf16,注释可改 fp16 | fp16,注释可改 bf16 |
num_processes 写成实际使用的 GPU 总数。节点数、总进程数改 num_machines、num_processes。也可以先跑 accelerate config,按提示生成一份,再改成这些 FSDP 字段。
进程数和实际卡数对不上时,把 num_processes 改成实际用到的卡数。参数写回时形状对不上,把 fsdp_offload_params 改成 true。写成 true 时参数留在 CPU 内存里,算到这一块再搬回 GPU,单卡显存小一截,训练会变慢。机器上打开的那份仍是 false。
大模型微调34-LoRA实测 复习巩固总结
| 微调方式 | 显存 | 速度 |
|---|---|---|
| 全量微调 | 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 复习巩固总结
- NF4(4bit NormalFloat)。给接近正态分布的权重量身定的 4 比特格式。在这种权重上,实测好于 4 比特整数和 4 比特浮点。
- 双重量化(Double Quantization)。第一次量化会留下一批常量,再把这批常量量化一次,存储再小一截。
- 分页优化器(Paged Optimizers)。用 NVIDIA 的统一内存。显存偶尔不够时,优化器状态在 CPU 内存和 GPU 之间按页自动来回搬,GPU 上的计算不会因为这一下撑满就停。做法和操作系统把内存换到磁盘上一样:先给优化器状态分配可分页的内存,显存紧了就卸到 CPU,优化器要更新时再载回 GPU。
- 多插 Adapter。NF4 加双重量化省下很多空间,精度会掉一截。作者靠多插 adapter 补回来。LoRA 一般只插在 query、value 后面的全连接层。QLoRA 在所有全连接层都插,可训练参数更多,用来补精度损失。
| 方法 | 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 |
大模型微调36-量化与多卡 学习
1. 数据集的来源与llamafactory中的数据集
1.1 大模型训练的几个阶段
四个阶段和得到的模型:
- 预训练阶段,得到 Base 模型。
- 有监督微调阶段,得到 Instruct/Chat 模型。
- 强化学习阶段,得到人类偏好对齐模型。
- 微调阶段,得到适配「垂直领域」的模型。
下面这张表把强化学习拆成奖励建模和强化学习两列。垂直领域微调没有单独一列。
| 预训练 | 有监督微调 | 奖励建模 | 强化学习 | |
|---|---|---|---|---|
| 数据集合 | 原始数据。数千亿单词:图书、百科、网页等 | 标注用户指令。数万用户指令和对应的答案 | 标注对比对。百万量级标注对比对 | 用户指令。十万量级用户指令 |
| 算法 | 语言模型训练 | 语言模型训练 | 二分类模型 | 强化学习方法 |
| 模型 | 基础模型 | SFT 模型 | RM 模型 | RL 模型 |
| 资源需求 | 1000+ GPU,月级别训练时间 | 1–100 GPU,天级别训练时间 | 1–100 GPU,天级别训练时间 | 1–100 GPU,天级别训练时间 |
1.2 是否存在训傻了的情况
- 训好的模型喋喋不休。
- 训好的模型重复叙述?
这两种情况,是四个阶段里缺了有监督微调和强化学习。只做预训练时,模型学的是把文本往下接,停不下来,也会把同一段再说一遍。有监督微调把它收成「问一句、答完就停」。强化学习再按人的偏好把啰嗦、重复压下去。垂直领域微调是在这两步之后适配领域,补不上这两步没做的事。
1.3 微调数据集的构建与处理
按业务来建,要调的是四样:模式、风格、知识、任务。
原生数据有四类:原生数据、业务数据、互联网上的数据、公共的数据集。互联网上的数据标了出来。衍生数据是 GPT-5 或者 Claude 生成的,旁边写着「模型生成的?」。强化学习微调的也标了出来。
用模型生成时,提示是:帮我生成一个意图识别的 100 条数据,意图包括吃饭、睡觉、洗澡、出去玩,输出格式 Q: xxx A: xxx。打开的那一屏从第 1 条写到第 16 条,底下截成 **Q,后面的没有露出。
Q: 我肚子好饿,我们中午去吃点什么? A: 吃饭
Q: 好困啊,明天再聊吧。 A: 睡觉
Q: 身上都是汗,黏糊糊的。 A: 洗澡
Q: 周末天气真好,呆在家里太浪费了。 A: 出去玩
Q: 到饭点了,食堂今天有什么菜? A: 吃饭
Q: 眼睛都快睁不开了,我得躺一会儿。 A: 睡觉
Q: 运动完冲个凉水澡最舒服了。 A: 洗澡
Q: 听说公园的花都开了,我们去逛逛吧? A: 出去玩
Q: 晚上有什么好吃的推荐吗? A: 吃饭
Q: 明天要早起,今晚得早点休息。 A: 睡觉
Q: 帮我拿一下睡衣,我去洗漱。 A: 洗澡
Q: 朋友们约了今晚去唱歌。 A: 出去玩
Q: 外卖到了吗?我快饿扁了。 A: 吃饭
Q: 宝宝已经哄睡着了。 A: 睡觉
Q: 热水器我已经打开了。 A: 洗澡
Q: 假期我们自驾游去吧? A: 出去玩
凑数据先看开源数据集,自己标一条就要一条人工,所以数据量和制作成本放在一起权衡。拿到手再切成训练集和验证集:训练集用来改参数,验证集用来看是不是只会做训练里见过的题。单轮是一问一答,多轮是同一件事接着聊,后面的 Alpaca 和 ShareGPT 就是这两种。
业务数据、网上抓来的、公共数据集都是原生的。网上的和公共的会夹着隐私和有害内容,进训练前要先清洗。清洗旁边写了 scalarAI,这页没有写它做什么。原生的不够、没有数据了,就改走衍生:让 GPT-5 或 Claude 按格式生成,上面那 100 条意图识别就是这么来的。强化学习微调用的对比和指令,这页也放在生成这一边。
只拿一个窄领域去微调,就是在洗原来的参数。金融数据上的能力上去了,原来会的代码、翻译、function calling 会掉,两边是一个 trade-off。板上用「世界模型」带了个问号,没有展开。补法是按比例把数据混回去:代码、翻译能力、function calling 各留 50%/3,三项加起来是一半,金融数据就不会把这三项整段盖掉。
1.4 四类微调数据集
意图识别与槽位抽取。天气查询和音乐播放各一条:
{
"text": "今天天气如何",
"intent": "weather_query",
"entities": [
{"entity": "time", "value": "今天"}
]
}
{
"text": "上海明天温度多少",
"intent": "weather_query",
"entities": [
{"entity": "location", "value": "上海"},
{"entity": "time", "value": "明天"},
{"entity": "weather_type", "value": "温度"}
]
}
{
"text": "杭州会下雨吗",
"intent": "weather_query",
"entities": [
{"entity": "location", "value": "杭州"},
{"entity": "weather_type", "value": "下雨"}
]
}
{
"text": "播放周杰伦的歌",
"intent": "music_play",
"entities": [
{"entity": "artist", "value": "周杰伦"}
]
}
文本摘要是 text 加 summary。一条是 2023 年诺贝尔物理学奖,摘要写成「2023年诺贝尔物理学奖授予三位科学家,表彰其在量子计算领域的突破性贡献。」另一条正文是国家统计局的 2023 年 GDP:总量 126 万亿元,同比增长 5.2%,第三产业增加值占比 54.6%,居民人均可支配收入实际增长 6.1%。摘要写成「2023年中国GDP增长5.2%达126万亿元,第三产业占比超54%,居民收入增长6.1%。」
语言翻译是多轮,conversation_id 为 cross_lang_chat_042,domain 是 travel 和 chit_chat。露出的三轮:
{
"turn": 0,
"speaker": "USER",
"utterance_cn": "你好,请问你能帮我翻译吗?我正在学英语。",
"utterance_en": "Hello, can you help me with translation? I'm learning English."
}
{
"turn": 1,
"speaker": "ASSISTANT",
"utterance_cn": "当然可以!我很乐意帮忙。你想翻译些什么?",
"utterance_en": "Of course! I'd be happy to help. What would you like to translate?"
}
第 2 轮的中文是「太好了!我想知道“这里的Wi-Fi密码是多少”用英语怎么说?」,英文从 Great! I'd like to know how to say 'What is the Wi-Fi password here?' 起被截断。
工具调用数据集。函数名 get_fudan_university_scoreline,说明是查询复旦大学往年分数线,参数 year 是字符串,必填。对话角色依次是 system、user、assistant、function、assistant。系统提示写 CodeFuse 是面向研发领域的智能助手,回答用 Markdown。用户说「查询2020年复旦大学的分数线」。助手的 content 是 null,function_call 的 arguments 里年份是 2020。函数返回的分数线是文科一批 630、文科二批 610、理科一批 650、理科二批 630。助手再用这句话答回去。
1.5 在 LLaMA-Factory 里存放和登记
数据放在仓库的 data/。打开的目录是 /autodl-tmp/LLaMA-Factory/data。能看见的文件有 identity.json、alpaca_en_demo.json、alpaca_zh_demo.json、c4_demo.jsonl、dataset_info.json、dpo_en_demo.json、dpo_zh_demo.json、glaive_toolcall_en_demo.json、glaive_toolcall_zh_demo.json、hh_rlhf_en、kto_en_demo.json、mllm_audio_demo.json、mllm_demo.json、mllm_video_audio_demo.json、mllm_video_demo.json、ultra_chat、wiki_demo.txt、finance_data.json,还有 README.md、belle_multiturn、saves。
登记文件用 vi data_info.json 打开。说明里的名字是 dataset_info.json。页上写明:无论是系统数据集还是自定义数据集,都要注册进这个文件,才能在训练微调里用。字段说明已经在 DAY1 的 3.3。这页列出的通用项是:hf_hub_url、ms_hub_url、script_url、file_name、formatting(默认 alpaca,也可以 sharegpt)、ranking(默认 false)、subset、split(默认 train)、folder、num_samples、columns、tags。
打开的登记里,identity 指向 identity.json,alpaca_en_demo 指向 alpaca_en_demo.json。glaive_toolcall_en_demo 和中文那份是 formatting: sharegpt,columns 里 messages 对 conversations,tools 对 tools。
1.6 Alpaca 格式
三个必填是 instruction、input、output。页上把 input 标成 optional,system 和 history 也是 optional。history 是更早几轮的指令和回答。列名怎么映射,见 DAY1 的 3.4。这页的登记是:
"dataset_name": {
"file_name": "dataset_name.json",
"columns": {
"prompt": "instruction",
"query": "input",
"response": "output",
"system": "system",
"history": "history"
}
}
终端里有三条样本:识别细胞理论和日心说、用三支篮球队的名称写口号、根据下文构建问题。这三条的正文被截断。
1.7 ShareGPT 格式
多轮写在 conversations 里。一轮一个 from 加 value。样例里的角色是 human 和 gpt,另有可选的 system、tools。登记要写 formatting: sharegpt,并用 tags 标出角色字段、内容字段、用户和助手各叫什么。右边那份标签写成 user 和 assistant。左边样例用的是 human 和 gpt:
"dataset_name": {
"file_name": "dataset_name.json",
"formatting": "sharegpt",
"columns": {
"messages": "conversations",
"system": "system",
"tools": "tools"
},
"tags": {
"role_tag": "from",
"content_tag": "value",
"user_tag": "user",
"assistant_tag": "assistant"
}
}
终端里是一段 Java 随机数和对数的多轮,正文被截断。字段和 DAY1 的 3.5 是同一套。
1.8 拓展QA
1. 微调之后已经喋喋不休、重复叙述,怎么补救?
垂直领域微调把前面学过的「答完就停」盖掉了。再训一轮时,按 2.6 的复习 把有监督微调的问答混回来,和新领域的数据一起训。学习率放小,那一节里 ChatGLM 的例子是 2e-4,免得新数据一下把停下来的习惯盖没。
推理侧先止血,不把缺的阶段补回去。DAY8 写过:重复叙述是把本轮回答里已经出现过的 token 的 logit 除掉 repetition_penalty,大于 1 才压得住。喋喋不休靠抽到结束符就停,generate 里写成 eos_token_id,再用 max_new_tokens 卡住最长长度。上面 Ollama 的 Modelfile 里,对应的是 repeat_penalty,这份写的是 1.05。那一问也写了:惩罚只能缓解;数据和训练差了,单靠惩罚补不回来。
微调数据里如果把同一段改写很多遍,模型会背着往下念。一块事实写一问就够,见 DAY2 企业数据。
2. 数据集的构建
公共数据集先从 Hugging Face 拉到本机缓存,再把列映射成 1.6 的 Alpaca 或 1.7 的 ShareGPT,最后在 dataset_info.json 里登记。不登记,训练 yaml 里写了名字也选不到这份文件。
2.1 用镜像加载 Hugging Face 数据集
国内访问 Hugging Face 走镜像,并打开加速:
export HF_ENDPOINT=https://hf-mirror.com # 镜像网站
export HF_HUB_ENABLE_HF_TRANSFER=1 # 开启加速
数据集主页的 Load dataset 里有 load_dataset 的用法。vtllms/sealqa 用 name 选子集,split 选切分:
from datasets import load_dataset
seal_0 = load_dataset("vtllms/sealqa", name="seal_0", split="test")
seal_hard = load_dataset("vtllms/sealqa", name="seal_hard", split="test")
longseal = load_dataset("vtllms/sealqa", name="longseal", split="test")
第一次下完以后,再加载就指到本机缓存,不再走网上的名字:
datasets = load_dataset(path="/root/.cache/huggingface/hub/datasets--vtllms--sealqa")
镜像站上打开的一份是 Heng666/Traditional_Chinese-aya_dataset。页面上标了 Question Answering、Translation、Summarization、Text、parquet、Chinese、1K–10K、apache-2.0。Data Studio 里大约 4.91k 行,列有 inputs、targets、language、language_code、annotation_type、user_id。Use this dataset 的库可选 Datasets、pandas、Croissant、Polars。Datasets 给出的加载是:
from datasets import load_dataset
ds = load_dataset("Heng666/Traditional_Chinese-aya_dataset")
笔记本 build_training_data.ipynb 里先 print(1),再 pip install numpy。源是 http://mirrors.aliyun.com/pypi/simple,numpy 已经在 miniconda3 的 Python 3.12 里。用 root 装包时有一条警告:权限可能和系统包冲突,建议用虚拟环境。
接着按名字加载这份中文数据。Hub 上找不到时,库改用本机缓存,配置名 default,缓存时间是 2025-09-11 17:55:07。train 有 4909 行,列是 inputs、targets、language、language_code、annotation_type、user_id。
#1. 使用hf数据集转成Llamafactory alpaca格式
from datasets import load_dataset
datasets = load_dataset("Heng666/Traditional_Chinese-aya_dataset")
# datasets = load_dataset(path="/root/.cache/huggingface/hub/datasets--Heng666--Traditional_Chinese-aya_dataset") #/root/.cache/huggingface/datasets/vtllms--sealqa
print(datasets)
inputs 和 targets 的前 10 条是论语、孔子一类的问答。正文在单元格里,这里不逐条抄。
print(datasets['train']['inputs'][:10])
print(datasets['train']['targets'][:10])
2.2 转成 Alpaca
inputs 放进 instruction,targets 放进 output,input 空着。一行一个 JSON,写成 jsonl。输出路径是 /root/autodl-tmp/LLaMA-Factory/data/traditional_chinese.jsonl。
import pandas as pd
from datasets import load_dataset
# df = pd.read_csv("your_path") # or pd.read_excel("my_data.xlsx")
alpaca_data = []
question_list = datasets['train']['inputs']
answer_list = datasets['train']['targets']
def create_alpaca_dataset(path, question_list, answer_list):
with open(path, 'w', encoding='utf-8') as f:
for q, a in zip(question_list, answer_list):
item = {
"instruction": q,
"input": "",
"output": a
}
print(item)
alpaca_data.append(item)
f.write(json.dumps(item, ensure_ascii=False) + '\n')
print("转换完成!共转换了 {} 条数据。".format(len(alpaca_data)))
return alpaca_data
alpaca_data = create_alpaca_dataset(
path="/root/autodl-tmp/LLaMA-Factory/data/traditional_chinese.jsonl",
question_list=question_list,
answer_list=answer_list,
)
单元格下沿露出两条已经写成 Alpaca 的结果,input 都是空字符串。
2.3 转成 ShareGPT
另一份是本地 Excel,81 行、两列 question 和 answer,内容是债券、ETF、平仓、多头、空头、套利、期权这类金融问答。要先有 openpyxl 才能读 xlsx。
# !pip install openpyxl
import pandas as pd
dataset = pd.read_excel("/root/data_file/finance.xlsx")
dataset
每一行收成一轮对话:human 说问题,gpt 说答案。写出 /root/autodl-tmp/LLaMA-Factory/data/finance_sharegpt.jsonl。这里的 human / gpt 和 1.7 样例一致。
import pandas as pd
import json
from datasets import load_dataset
question_list = dataset['question']
answer_list = dataset['answer']
def create_sharegpt_dataset(path, question_list, answer_list):
sharegpt_data = []
with open(path, 'w', encoding='utf-8') as f:
for q, a in zip(question_list, answer_list):
item = {
"conversations": [
{"from": "human", "value": q},
{"from": "gpt", "value": a}
]
}
print(item)
sharegpt_data.append(item)
f.write(json.dumps(item, ensure_ascii=False) + '\n')
print("转换完成!共转换了 {} 条数据。".format(len(sharegpt_data)))
return sharegpt_data
sharegpt_data = create_sharegpt_dataset(
path="/root/autodl-tmp/LLaMA-Factory/data/finance_sharegpt.jsonl",
question_list=question_list,
answer_list=answer_list,
)
2.4 登记
同一份 dataset_info.json 里,网上的数据集写 hf_hub_url 或 ms_hub_url,本机转好的文件写 file_name。能看见的几条:
| 登记名 | 从哪读 | 列 |
|---|---|---|
| fineweb-edu | hf_hub_url: HuggingFaceFW/fineweb-edu | prompt → text |
the_stack | hf_hub_url: bigcode/the-stack,ms_hub_url: AI-ModelScope/the-stack | prompt → content |
starcoder_python | hf_hub_url: bigcode/starcoderdata,ms_hub_url: AI-ModelScope/starcoderdata,folder: python | prompt → content |
vtllms_sealqa_alpaca | file_name: sealqa_alpaca.jsonl | prompt / query / response → instruction / input / output |
刚才转出的两份:
"finance_sharegpt": {
"file_name": "finance_sharegpt.jsonl",
"formatting": "sharegpt",
"columns": {
"messages": "conversations"
},
"tags": {
"role_tag": "from",
"user_tag": "human",
"assistant_tag": "gpt"
}
},
"traditional_chinese": {
"file_name": "traditional_chinese.jsonl",
"columns": {
"prompt": "instruction",
"query": "input",
"response": "output"
}
}
traditional_chinese 不写 formatting,按默认的 Alpaca 读。finance_sharegpt 写了 sharegpt,角色标签是 human 和 gpt,和转换函数里的 from 对得上。
3. 微调方法理论介绍与日志监控
全量是把每个参数都更新。显存不够、又怕把预训练盖掉时,改成只更新一部分:冻结是留着原参数里的高层,高效微调是在冻住的底模旁边加一小块可训练的东西。这页最后落到 LoRA 和 QLoRA,前面几种提示微调往往效率和效果不能兼得。
3.1 全量参数微调
Full Parameter Fine-tuning 把所有参数一起训。每个参数都会被更新,直到模型能做你要的事。
灵活性高,性能更好。代价是计算资源要求高。数据量少,或者任务和预训练差得大,会过拟合,也会忘掉预训练里的知识。这和 1.3 里洗参数是同一件事:新数据集上的能力上去,原来的代码、翻译、function calling 掉下去。
3.2 Freeze
Freeze 冻结一部分参数、只更新另一部分。通常冻住底层,只更新高层。Transformer 里一般只开放 FC 层。
特点是训得快,不容易忘掉预训练,也能防过拟合。一个 backbone 可以接多个头:backbone(Unet\mobileNet)+FC 做目标检测、语义分割、实例分割、图像分类;backbone(bert-transformer encoder)+FC 做文本分类、文本摘要。
下面这段把 layers.23 到 layers.27 留着更新,这五个名字之外的参数 requires_grad 设成 False:
# 遍历模型的所有参数和名称
for name, param in model.named_parameters():
# 指定冻结层,(layers.27, layers.26, layers.25, layers.24, layers.23)之外的所有参数
if not any(nd in name for nd in ["layers.27", "layers.26", "layers.25", "layers.24", "layers.23"]):
# 将参数的 requires_grad 属性设置为False,即冻结该参数
param.requires_grad = False
3.3 加一层可训练模块
Adapter、Prefix、Prompt Tuning、P-tuning 都不改底模的全部权重,只多训一小段。原理在 P-Tuning、Prefix-Tuning。这页把它们放在一起,是为了对比后面的 LoRA。
Adapter tuning 在 Transformer 层里插入适配层。图上每一层有 Layer Norm、Adapter、两倍宽度的 Feed-forward,下面还有一层 Adapter 接在 Feed-forward 和 Multi-headed attention 旁边。层数变多,推理要多走这几层,延迟跟着增加。
Prefix Tuning 是在输入前面加一段可训练的前缀。翻译、摘要、表格转文本各有自己的前缀,底下共用一个预训练 Transformer。全量微调则是每个任务一份完整 Transformer。例子是表格转文本:输入 name Starbucks type coffee shop,经过 [SEP],输出 Starbucks serves coffee。前缀占掉一段位置,模型真正能用的序列长度变短,这段前缀也比较难训。
Prompt Tuning 用反向传播只更新 prompt 参数,底模冻住。训完以后同一个模型换不同的 prompt 做多个任务。图上三列:Model Tuning 是底模也能训,也就是全量微调;Prompt Tuning 是底模冻住,只训 soft prompt;Prompt Design 是像 GPT-3 那样手写提示词,底模同样冻住。左边两列标的是任务效果强,右边标的是一份模型同时服务多个任务。
P-tuning 把 prompt 变成可学习的 Embedding。任务名先进 Prompt Encoder,用 MLP 加 LSTM 得到 (v_1 \ldots v_n)。输入文本走词表 Embedding 得到 (x_1 \ldots x_n)。两段交错拼在一起再送进 GPT。
页上的结论:这几种往往做不到又快又好,效果通常不及完全微调。
3.4 LoRA
LoRA 用低秩分解去模拟权重的改变量,只训这一小块,间接改大模型。低秩那一支以前在 LoRA 的思想 里写过。作用位置是 query、key、value 的 (W_q)、(W_k)、(W_v),以及多头注意力的输出矩阵 (W_o)。页上标出的优势是显存占用低、训练速度快、模型小、效果最好。
图上预训练权重是 (W)。旁边的低秩支路:(B) 初始化成 0,(A) 从 (\mathcal{N}(0,\sigma^2)) 里抽,中间的维度是秩 (r)。
这页给的取值:
- 秩通常是 4(简单任务、小数据集)、8,复杂任务、大数据集用 16。
lora_alpha是低秩支路的缩放。太大容易不稳或过拟合,太小看不出效果,一般取 16–32。- Dropout 控制丢掉的概率,比较常见的是 0.2–0.3。较小的模型可以用 0.1 这一档;较大的网络用 0.4–0.5,尤其是在防过拟合的时候。
3.5 QLoRA
QLoRA 是量化和 LoRA 合在一起。底模从常规的 16 比特(FP16 或 BF16)收成 4 比特,同时记下缩放因子 scale 和零点 zero-point,用来把格子里的数还原回去。显存因此小一截。
冻住的底模以 4 比特放着。前向和反向要算的时候,再把这 4 比特动态反量化回 16 比特。只有 LoRA 的 (A)、(B) 留在 16 比特里做训练和梯度更新。
双重量化是把原来用 fp32 存的缩放常数再量化一次,通常收到 8 比特,空间再小一截。NF4 和双重量化各自省的是什么,见 DAY4 的第 2 问。
三列图的差别:
| 全量 | LoRA | QLoRA | |
|---|---|---|---|
| 优化器状态 | 32 比特,跟着全部权重 | 只跟着 adapter | 只跟着 adapter,显存尖峰时整页卸到 CPU |
| Adapter | 没有 | 16 比特 | 16 比特 |
| 底模 | 16 比特 Transformer | 16 比特 Transformer | 4 比特 Transformer |
QLoRA 相对 LoRA,是把 Transformer 收到 4 比特,并用分页优化器接住显存尖峰。
学习率:LoRA 取 1e-4 到 5e-4。QLoRA 因为量化,略低,取 5e-5 到 2e-4。
bitsandbytes 做这三步。先把权重归一化,让它们落进一个区间,常见的值更好表示。再量化到 4 位或 8 位。NF4 的格子相对归一化之后的权重是均匀排开的,用来表示原来的 32 位权重。存的是 4 位或 8 位,计算时反量化成 16 位,推理因此还能快一点。图上蓝的是原始权重,红的是 LLM.int8() 反量化回来的权重,两边都堆在 0 附近。
WebUI 里量化等级选 4(下拉里还有 none 和 8),量化方法选 bnb。等级这栏写的是启用量化(QLoRA),方法这栏写的是使用的量化算法。
3.6 拓展QA
1. 之前的项目里,有从数据集开始做的 QLoRA 实践吗?
有一份脚本是 QLoRA,数据是别人已经做好的文件,不是自己从原始材料做成训练集。微调课里从数据做到训练的那次是 ChatGLM 的 LoRA,底模没有按 4 比特放。
百川这份 sft_lora.py 读的是 ./dataset/Belle_open_source_0.5M.json,最长 1024。底模 ./baichuan-7B 用 load_in_4bit、nf4 和双重量化,计算用 BF16。adapter 插在除 lm_head 以外的 4 比特线性层上,秩 8,lora_alpha 16,dropout 0.05。训 1 个 epoch,每卡 batch 1,梯度累积 4,学习率 3e-4,日志进 tensorboard,存下来的是 baichuansft 这份 adapter。分页优化器不在这份脚本里。数据文件本身怎么从原文变成 json,脚本里没有这一步。
ChatGLM-6B 那次 有数据集、有训练。代码走的是 PEFT 的 LoRA,底模仍是原来的精度,没有 BitsAndBytesConfig。微调课收官时也写了:这一目录没有单独的 QLoRA 大实验。
LLaMA-Factory 里带 quantization_bit: 4 的几次,用的是仓库自带的 alpaca、identity 这一类演示集,也不是从 Hugging Face 或 Excel 自己转出来的。上面第 2 节把中文集转成了 traditional_chinese.jsonl,把金融 Excel 转成了 finance_sharegpt.jsonl,并且登记进了 dataset_info.json。训练那一步还没接到这两份文件上。
4. BAdam&GaLore微调原理讲解
4.1 GaLore
GaLore(Gradient Low-Rank Projection)仍更新模型自己的参数,省显存的地方在梯度上。课上的说法是:通过梯度的低秩投影来减少内存使用。
3.4 的 LoRA 是在权重旁边加一条低秩支路,底模冻住,只更新 (A)、(B)。GaLore 不插这条支路。梯度照常按全部参数算出来,再投到一个低维空间里,用这份低维梯度去改原来的参数。所以优势里「全参数学习」被标成红色,和只训 adapter 分开。
四步接在普通训练后面:
- 梯度计算:和常规训练一样,先算出模型参数的梯度。
- 低秩投影:把这份高维梯度投到低维空间,要存的数据量就少了。
- 梯度更新:用投影后的低维梯度更新模型参数。
- 周期性重构:每隔一定的迭代次数,重新做投影矩阵,好让它还抓得住梯度里的主要信息。
另外三条优势也落在这四步上。内存效率来自第 2 步,存的是低维梯度。优化器兼容是因为第 3 步交给优化器的仍是一份梯度,优化器本身不用换成另一套。易于实现,是这四步加在原来的训练循环上。灵活性对应下面四项可调参数:秩、隔多少步重做投影、缩放、投影怎么初始化。
投影用的是奇异值分解。矩阵 (M = U\Sigma V^{*})。
- (U):描述行的新模式。
- (\Sigma):对角矩阵,对角线上的值越大,对应的模式越重要。
- 要点里把列的新模式写成
$V^T$。
图题是「SVG:奇异值分解算法」。字上的对应是:(U) 是左奇异向量,对着行空间;SIGMA 是奇异值的对角矩阵,只留最重要的前 (K) 个,其余丢掉,这里 (K=100);(V) 是右奇异向量,对着列空间。三块的尺寸按图上的标法:左边那块标着 u,一边是 100,另一边是 10000000;中间 SIGMA 是 100 乘 100;右边那块图里也标着 u,一边是 10000000,另一边是 100。100 就是留下的那一档,10000000 是原来那一维还没压之前的长度。
参数:
| 参数 | 含义 | 怎么取 |
|---|---|---|
rank | 梯度低秩投影的维度,也就是低秩空间能装下多少。越小压得越狠,内存省得越多,梯度信息丢得也越多,收敛会受影响。越大越接近全秩训练,内存省得少。 | 通常取较小的值,范围 16 到 512。例子是 128、256、512,再按模型大小和任务调。 |
update_proj_gap | 每隔多少训练步更新一次低秩投影矩阵。 | 论文里常用 200 步,当作性能和开销的起点。任务不太敏感时可以更大。设成 1 就是每步都重做,理论上最好,计算开销最大。间隔拉大,开销小,但投影方向可能已经过时,优化效率下去。 |
scale | 把低秩梯度再放大的因子。投影是有损压缩,梯度幅值会变小,这个系数把幅值补回来,学习率那一套才还能用。 | 一般用默认值,GaLore 按秩自动算,例如 1.0 / rank。只有优化非常不稳时才拿来微调。 |
proj_type | 投影矩阵 (P) 和 (Q) 怎么初始化。 | 作用这一列:std 是从标准正态分布里随机初始化,标成默认;ortho 初始化成一组正交基,某些任务上有一点提升,计算开销大一些。推荐值这一列写成 std(奇异值分解)、reverse_std、right,后面的选项被挡住了。两列对 std 的叫法不一样,这里按页上分别记下。 |
4.2 BAdam
它仍是 Adam,更新是异步的。普通 Adam 是同步的:同一步里每个参数都拿到自己的梯度,一起改,两份动量也按全部参数存。BAdam 把全部参数分成 (D) 个块,一个时刻只有一个活跃块在动,其余块停在当前值。各块轮流,不是齐步走。
底层就这一步。前向仍然用上所有块,(h = Wx) 里冻住的块也参加计算。反向只给活跃块算梯度,Adam 的自适应学习率只按这块的梯度调步长,两份动量也只留给这块。页上把「不必等其他块的梯度再一起更新」写成块对角近似:当前块的更新只依赖自己的梯度。所以其他块这个周期不用算梯度,也不用存动量。
flowchart TD
split["参数分成 D 个块"] --> fwd["前向:所有块都参与 h = Wx"]
fwd --> bwd["反向:只给活跃块算梯度"]
bwd --> adam["Adam:只给活跃块留两份动量,并按这块调步长"]
adam --> upd["只改活跃块,其余块保持当前值"]
一个块周期(block-epoch)里活跃块不变,默认走 50 步。周期结束就换下一块,旧块的两份动量不再留,新块重新开始攒。内存因此只按一块来,而不是按整份参数。全量那笔账是 8B 的权重、梯度、fp32 主权重和 Adam 的两份动量,大约 128GB,见 单机多卡。这里每个周期只给活跃块留梯度和 Adam 状态。
flowchart LR
p1["块周期 1\n块 1 活跃\n块 2…D 停"] --> p2["块周期 2\n块 2 活跃\n其余停"]
p2 --> p3["…"]
p3 --> pD["块周期 D\n块 D 活跃\n其余停"]
pD --> p1
GaLore 是每一步都改整个 (W),省显存的办法是把梯度压小,同一步里参数仍一起更新。BAdam 省显存的办法是异步:这一周期只改其中一个块。页上写它在收敛速度和运行时间上都优于现有的 LoRA。
流程是:梯度计算、块对角近似、自适应学习率、参数更新、模型优化。上面两张图就是这五步。块对角近似对应「只留活跃块的梯度」。自适应学习率对应 Adam 只作用在这块上。
切块有两种模式,默认 layer。各选项差在哪,见下面的表。
| 参数 | 用在哪种模式 | 选项差在哪 | 默认 |
|---|---|---|---|
use_badam | 总开关 | False:不用 BAdam,优化器仍是原来的 Adam,所有该更新的参数同一步一起改。True:改成按块异步更新。 | False |
badam_mode | 总开关打开之后 | layer:一块是连续的若干层,同一时刻只有这一块可训练。反向传到这块就能停,论文里反向大约省一半,靠的就是这种切法。ratio:不按层切,每次只让下面那个比例的参数可训练,反向不能在某一层停住。 | layer |
badam_start_block | 只对 layer | 先从哪一块开始,填的是块下标。None 是不指定,从第 0 块开始。可以实现部分参数冻结。 | None |
badam_switch_mode | 只对 layer | 到了该换的步数,下一块怎么挑。ascending:下标加一,到最后一块再回到 0。descending:下标减一,到 0 再回到最后一块。random:下一块在全部块里随机抽。fixed:下标不动,一直训起始这块。 | ascending |
badam_switch_interval | 只对 layer | 一块连续训多少步再换,这就是一个块周期。默认 50 步。-1:关掉换块,停在起始块上。和 fixed 的结果一样都是不换块,一个是把间隔关掉,一个是策略写成固定。 | 50 |
badam_update_ratio | 只对 ratio | 每次有梯度的参数占全部参数的比例。0.05 就是大约 5%。调大,这一步改的参数多,显存和反向都上去;调小则相反。 | 0.05 |
badam_mask_mode | 只对 ratio | 这 5% 在权重里怎么挑。adjacent:挑中的参数连在一起,是权重里的一段。scatter:从权重里散着抽,彼此不相邻。 | adjacent |
badam_verbose | 两种模式都可看 | 日志打多少。0:不打印。1:打印当前活跃块的名字。2:在 1 的基础上再打印这块里正在训练的参数名。 | 0 |
注意:不要把 LoRA 和 GaLore/BAdam 一起用。LoRA 的 finetuning_type 是 lora,冻住 (W)、只训 (A)、(B)。GaLore 和 BAdam 改的是权重本身,finetuning_type 要写成 full,并且 pure_bf16 写成 True。full 就是上面那份全量 yaml。已经用过的 bf16: true 仍会留一份 fp32 主权重;pure_bf16 打开后,更新直接落在 bf16 上。
4.3 拓展QA
1. GaLore 和 LoRA、QLoRA 有什么区别?它是基于 LoRA 的吗?
一层线性原来就是 (h = Wx)。一次更新做三件事:前向算出 (h),反向给要改的数一份梯度,优化器拿这份梯度去改这些数。优化器还要给每个正在改的数再存一份状态。这份状态跟着谁,显存就跟着谁涨。三种方法省的都是这块,省法不一样。
LoRA 把前向改成 (h = Wx + BAx),见 LoRA 的思想。(W) 冻住,不给它梯度,优化器也不给它存状态。旁边的 (A) 先从 (d) 降到 (r),(B) 再升回 (d)。(r) 常见 4、8、16,比 (d) 小得多,所以梯度和优化器状态只有 (A)、(B) 这么大。训完可以把 (BA) 加回 (W),推理又变回一层线性。
QLoRA 才是建在 LoRA 上的。前向还是 (h = Wx + BAx),改的还是 (A)、(B)。差别只在 (W) 怎么占显存:按 4 比特放着,要算的时候解开成 16 比特,算完就丢掉。见 3.5。
GaLore 不基于 LoRA。全称是 Gradient Low-Rank Projection,低秩投影的是梯度。LoRA 的全称是 Low-Rank Adaptation,低秩的是旁路 (BA)。两个名字里都有 Low-Rank,所以看起来像一家,算法各走各的。GaLore 的前向仍是 (h = Wx),旁边不挂 (A)、(B)。(W) 里的每个数都改,这就是页上写的全参数学习。反向得到的梯度矩阵和 (W) 一样大。图上那一块一边是 10000000,先做奇异值分解,只留最重要的 100 个方向,优化器只为这 100 维存状态,再用这份额度小的梯度去改 (W)。隔 update_proj_gap 步重新分解一次,论文里常用 200 步,换一批方向。训完变的是 (W) 本身。
放在同一次更新里看:LoRA、QLoRA 少改一些数,QLoRA 再把没改的 (W) 压成 4 比特。GaLore 是数都改,只把「这一步该怎么改」的梯度压小。
2. GaLore 会比 LoRA 费时费力很多吗?
训练时间上会。同一次更新里,费时间的是反向,不是前向那一下矩阵乘。
LoRA 的前向是 (h = Wx + BAx),比原来的 (h = Wx) 多一次很小的旁路乘法。(W) 冻住,反向只给 (A)、(B) 算梯度,优化器也只改这两块小矩阵。(r) 常见 4、8、16。
GaLore 的前向就是原来的 (h = Wx)。反向要像常规训练一样,给 (W) 里的每个数都算梯度,梯度矩阵和 (W) 一样大。算完再做低秩投影,每隔 update_proj_gap 步还要重新做一次奇异值分解。页上写了:间隔设成 1,每步都重做,计算开销最大;论文里常用 200 步,就是在少做几次分解。分解完,优化器仍要把改动写回整个 (W)。所以同样的数据和步数,一轮 GaLore 比一轮 LoRA 久。
省下来的是显存。优化器状态只跟着投影后的那一截低维梯度,不必按整个 (W) 存。换到的是全参数学习:训完 (W) 本身变了。
代码上页上写的是易于实现。训练循环还是原来的四步,优化器不用换一套。人要多调的是 rank、update_proj_gap、scale、proj_type。费力的是机器上的反向和那几次分解,不是多写一条旁路。
QLoRA 比 LoRA 多的是把 (W) 从 4 比特解开再算,反向仍然只走 (A)、(B)。它和 GaLore 不在同一档时间上。
3. 奇异值分解的原理是什么?
它把一块已经算出来的大矩阵拆开,读出里面几条主要方向,并按重要性从大到小排好。GaLore 拿来拆的是梯度。
LoRA 里见过一种拆法:大的改变量写成 (BA),先从 (d) 降到 (r),再升回 (d)。中间那一档很窄,所以一块大矩阵可以用两块瘦矩阵近似,见 LoRA 的思想。奇异值分解的形状也是瘦矩阵夹一块窄的中间。(A)、(B) 是训练学出来的。奇异值分解是从这块矩阵自己身上把方向读出来,对角线上的数同时标出哪一条更重要。
页上的式子是 (M = U\Sigma V^{*})。
- (U):行的新模式,叫左奇异向量,对着行空间。原来每一行很长,(U) 把这些行收成少数几条方向。
- (V):列的新模式,叫右奇异向量,对着列空间。公式里写成 (V^{*}),要点里写成
$V^T$。梯度是实数,这两种写法是同一件事,都是把列方向转置过来用。 - (\Sigma):对角矩阵。对角线上一个数配一对方向。数越大,这一对方向在原矩阵里占得越重。接近 0 的那些,几乎不推动参数。
三块都留下,乘回去就是原来的 (M)。只留前 (K) 个最大的,其余丢掉,乘回去的矩阵和 (M) 很像,独立方向只剩 (K) 条。图上 (K=100)。一边原来是 10000000,留下之后变成三块:一块是 100 对 10000000,中间 (\Sigma) 是 100 乘 100,另一块是 10000000 对 100。100 是留下的方向数,10000000 是原来那一维的长度。图上左右两块都标着 u,字上左边是 (U)、右边是 (V)。
用在这一步更新里:(M) 就是和 (W) 一样大的梯度。分解一次,只把最重要的 100 个方向交给优化器存状态。改 (W) 的时候,再按这些方向写回整个 (W)。过 update_proj_gap 步,梯度里哪几条方向更重要会变,所以再分解一次。
4. 投影矩阵 (P)、(Q) 是什么?LoRA 里讲过吗?
LoRA 那一节没有这两个字母。那边是 (A)、(B),挂在前向里:(h = Wx + BAx)。(P)、(Q) 不出现在这次前向里。前向还是 (h = Wx)。它们出现在反向之后,夹在大梯度和优化器中间。
梯度 (G) 和 (W) 一样大。优化器要是直接吃 (G),存的状态就和 (G) 一样大。(P)、(Q) 做两下:先把 (G) 压成一小块,优化器只看这一小块;再把优化器算出的小更新摊回整个 (W)。
页上没写乘式。用图上的 100 和 10000000 缩一个能看完的例子:设 (W) 是 4×4,秩取 2,这一步的梯度 (G) 也是 4×4。(P) 是 4×2,(Q) 是 4×2。
压下去的时候,先把 (P) 转置成 2×4,乘上 (G) 得到 2×4,再乘 (Q) 得到 2×2。16 个数变成 4 个数。优化器只处理这 4 个数,动量也只存这 4 个数。
写回来的时候,优化器给出一块 2×2 的更新。(P) 乘上它得到 4×2,再乘 (Q) 的转置,得到 4×4,加回 (W)。16 个格子都动了,但只能按这 2 个行方向、2 个列方向一起动。
换回图上的尺寸:(P)、(Q) 一边是 10000000,另一边是 100。压完之后优化器看见的是 100×100。图上中间那块 SIGMA 也是 100×100,那边记的是方向有多重要,这里只是块一样大。左边 100×10000000、右边 10000000×100 那两块瘦矩阵,就是压下去和摊回来时用的两侧。
这两块在 update_proj_gap 步之内不动,论文里常用 200 步。起头怎么填,由 proj_type 定:std 从标准正态分布里抽,ortho 起头是一组正交基。到了该重做的那一步,奇异值分解看当前梯度里哪 100 条方向最重要,用新的方向换掉 (P)、(Q)。然后优化器继续只看压出来的那块小的。
5. BAdam 的训练时间真的比 LoRA 短吗?
短。这是论文里量出来的墙钟时间,不是从「全量」两个字推出来的。同一份数据走完一轮,BAdam 大约 2.5 小时,LoRA 大约 4.1 小时。少掉的几乎全在反向。
设置是 Llama 3-8B、Alpaca-GPT4、一张 RTX 3090、每批 2 条,三个 epoch 取平均:
| 前向 | 反向 | 参数更新 | |
|---|---|---|---|
| LoRA | 0.83 小时 | 3.20 小时 | 136 秒 |
| BAdam | 0.71 小时 | 1.74 小时 | 142 秒 |
前向 BAdam 还略短一点,因为没有 (BA) 那条旁路。更新时间两者差不多。
反向能少,是因为块按连续的 Transformer 层来切。损失从后往前传,传到当前活跃层就可以停,不必再给更前面那些层的权重算梯度。论文里单次反向:所有层一起算是 0.64 秒,只算最前面那层是 0.33 秒,只算最后一层是 0.03 秒。一个块周期里每一层都会轮到,平均下来反向大约是 LoRA 的一半。LoRA 的旁路挂在各层上,每一步都要把所有层的反向走完。
同一张表里的显存:LoRA 秩 8 一共 22.3GB,BAdam 一共 23.5GB,都放得进这张 24GB 的卡。Adam 把所有参数一起改,论文里估是 144.8GB 起,这张卡放不下。所以更短的是 BAdam 这种按层轮流的更新,不是普通全量。
这组数字只覆盖上面这一个模型和这一张卡。块如果不是按连续的层切,反向省得就没这么多。页上「运行时间优于现有的 LoRA」指的就是这种整轮时间。
6. 时间上 BAdam 更短,为什么主流仍是 LoRA?和 QLoRA 比谁更快?
时间上 BAdam 比 QLoRA 更快。主流仍用 LoRA,是因为训完要拿走的东西、以及 16 比特底模放不进卡的时候,LoRA 和 QLoRA 走得通。
| LoRA | QLoRA | BAdam | 普通全量 | |
|---|---|---|---|---|
| 谁在更新 | 只改 (A)、(B),(W) 冻住 | 同样只改 (A)、(B) | 一个时刻只改一个块,轮完是整份 (W) | 每步所有参数一起改 |
| 底模怎么放 | 16 比特 | 4 比特,算的时候解开成 16 比特 | 16 比特,pure_bf16: True | 16 比特,另留 fp32 主权重 |
| 一步时间 | 2.3 秒 | 3.2 秒 | 1.5 秒(附加测试) | 14.2 秒 |
| 显存(这一张表) | 20G | 10G | 20G | 273G |
| 一轮时间(3090,论文) | 约 4.1 小时 | 这组没跑 | 约 2.5 小时 | 卡放不下 |
| 论文里的显存 | 秩 8 为 22.3GB | 这组没跑 | 23.5GB | 估 144.8GB 起 |
| 训完留下 | adapter,可挂回同一份底模 | 仍是 adapter | 整份 (W) | 整份 (W) |
| 什么时候用 | 卡放得下 16 比特底模,还要换任务 | 卡不够,或模型更大 | 16 比特底模放得下,块按连续的层切 | 预训练、增量训练 |
一步时间和前三行显存来自上面 LoRA 实测,BAdam 那一格是同一张对比里的附加测试。一轮时间和论文显存是 Llama 3-8B、一张 RTX 3090 上的另一组,没有 QLoRA。两套数字不能相乘。
QLoRA 一步比 LoRA 慢,是因为底模按 4 比特放着,每步要解开成 16 比特再算,见 3.5。BAdam 一步 1.5 秒对 QLoRA 的 3.2 秒,时间上 BAdam 更快。
LoRA 仍是默认,差在训完留下什么。adapter 可以挂回同一份底模,换任务就换 adapter。BAdam 改的是 (W) 本身。工厂的训练 yaml、合并、推理,默认都按 adapter 这条路走。
显存下限也不同。BAdam 要 finetuning_type: full,16 比特底模必须放在卡上。8B 光权重大约 16GB,加上活跃块的梯度和动量是 23.5GB,一张 24GB 的卡刚刚好。QLoRA 同一张表上是 10G。底模再大、16 比特放不进卡时,BAdam 起不来,QLoRA 还能跑。卡够就 LoRA,卡不够或模型更大就 QLoRA。BAdam 卡在「16 比特底模放得下,又愿意存一整份权重」这一档。
反向能省下一半,是因为块按连续的层切,传到活跃层就停。ratio 或散着挑参数时,这个便宜就没有了。页上还写了不要和 LoRA 一起开。
5. 大模型加速技术
5.1 FlashAttention
FlashAttention 优化的是注意力这一步,目标是少占显存,同时少访问显存。标准自注意力的前向会在 HBM 里算出并留下一整块注意力矩阵,反向算梯度时再把它读回来。序列一长,这块矩阵是 (N \times N),显存随长度成平方涨。这一点和 DAY4 里写的一样:注意力的计算量随长度成平方,FlashAttention 之后实际占的显存更接近线性。
公式还是原来的:
[ \mathrm{Attention}(Q, K, V) = \mathrm{softmax}!\left(\frac{QK^{T}}{\sqrt{d_k}}\right) V ]
(Q) 是 (N \times d),(K^{T}) 是 (d \times N),乘出来的分数矩阵 (S) 和 softmax 之后的 (P) 都是 (N \times N),再乘 (V)((N \times d))得到输出 (O)((N \times d))。标准做法把 (S) 和 (P) 整块放在 HBM 里,内存按 (O(N^{2})) 涨。
所以先看这三层内存差在哪。计算要快,数据得离计算核心近。
| 内存 | 页上的比喻 | 在哪 | 特点 | 用来干什么 |
|---|---|---|---|---|
| SRAM(GPU 缓存) | 砧板 | GPU 芯片内部 | 极快,容量极小,成本极高 | 计算核心直接拿到下一个数据或指令的工作台 |
| HBM(GPU 高带宽内存) | 专用推车 | 和 GPU 封装在一起 | 带宽极高,功耗较低,成本高 | 把海量数据从主存送到计算单元 |
| Main Memory(内存) | 冷藏库 | 主板上的内存条 | 速度、容量、成本折中 | 系统主存,放正在运行的程序和数据 |
A100 上这三层的带宽和容量:SRAM 是 19 TB/s、大约 20 MB;HBM 是 1.5 TB/s、40 GB;主存 DRAM 是 12.8 GB/s、大于 1 TB。SRAM 比 HBM 快一个数量级,但装不下 (N \times N) 的注意力矩阵。FlashAttention 的做法就是:大矩阵留在 HBM 里当仓库,真正的乘法和 softmax 拆成小块,一次只把一块搬进 SRAM。
核心是少做 GPU 内存访问,也就是少做 I/O。长序列上,Transformer 因此更快,也更省内存。不存整个注意力矩阵 (A)。反向要用它时,现场再算一遍。直接重算 (QK^{T}) 仍然慢,所以前向只存一份很小的「配方」,重算才划算。页上把整块矩阵比作蛋糕,配方就是下面两个统计量。
前向:不存蛋糕,只记配方。
标准前向算出 (A = \mathrm{softmax}(QK^{T} / \sqrt{d})),整块写入 HBM。FlashAttention 改成四步。
- 分块。一次只处理一个小块(Tile)。
- 这一块算 (Q_{\mathrm{block}} K_{\mathrm{block}}^{T}),得到注意力分数块。
- softmax 时留下两个统计量。(m(x)) 是这一行的最大值,减去它是为了数值稳定。(l(x)) 是指数和 (\sum \exp(x_i - m(x))),就是 softmax 的分母。
- 写回 HBM 的是输出 (O),加上 (m(x))、(l(x))。中间的 (A) 丢掉。
反向:用配方把蛋糕重做出来。
标准反向从 HBM 把巨大的 (A) 读回来。FlashAttention 只读当前这块的原材料 (Q_{\mathrm{block}})、(K_{\mathrm{block}})、(V_{\mathrm{block}}),以及对应的 (m(x){\mathrm{block}})、(l(x){\mathrm{block}})。在 SRAM 里重算
[ S_{\mathrm{block}} = Q_{\mathrm{block}} K_{\mathrm{block}}^{T} / \sqrt{d} ]
再用存好的最大值和指数和还原 (A_{\mathrm{block}} = \mathrm{softmax}(S_{\mathrm{block}}))。有了这两个数,重算不会数值不稳定,也不必把 (N \times N) 留在 HBM 里。
三件事合在一起:
- 分块,再把核融合。标准流程是 MatMul、Softmax、MatMul 三次独立运算,对应三次 HBM 读写。FlashAttention 把这三步收成一个内核。(Q_i) 一块,(K_j)、(V_j) 另一块,一起载进 SRAM。在 SRAM 里算完这块的分数、做 softmax、再和 (V_j) 相乘。中间结果不写回 HBM,只有最终的输出块 (O_i) 写回去。
- 在线 softmax。softmax 本来要等整行 (S) 都到齐才能除。这里每来一块就更新这一行的最大值和指数和,用这两个小向量保证最后和「整行一起算」是同一个结果。HBM 里始终不落整块 (S) 或 (P)。
- 反向重计算。训练的反向本来要 (S) 和 (P)。这里只留 (O) 和那两个统计量。反向时把 (Q)、(K)、(V) 的块再载进 SRAM,按需重算 (S)、(P) 的块。多算一次前向,换掉 (N \times N) 的存储。页上的说法是:对现在的 GPU,计算通常比访问内存便宜。
GPT-2 上的计时图,纵轴到 15 毫秒。PyTorch 那一列由 Matmul、Mask、Softmax、Dropout、Matmul 五段叠起来。FlashAttention 那一列只剩一根短的 Fused Kernel。
5.2 Unsloth
Unsloth 是训练加速框架,页上的副标题是动态量化加速微调。它要减的是训练时间和内存。LLaMA-Factory 的框架表里,它和 FlashAttention-2 写在同一行「加速」下,见 DAY1 的框架特性。
加速靠手写内核,不靠换卡。计算量大的数学步骤先手推一遍,再用 OpenAI 的 Triton 写成 GPU 内核。硬件不用改。页上写精度损失为 0%,没有用近似去换速度。支持 4 位和 16 位的 QLoRA / LoRA:4 位就是底模按 4 比特放、只训旁路;16 位就是普通 LoRA。开源训练速度写成提高了 5 倍。
站点横幅写的是另一组数字:微调 gpt-oss、Gemma 3n、Qwen3、Llama 4 和 Mistral,快 2 倍,显存少 80%。5 倍是开源训练那一条,2 倍和少 80% 显存是这句横幅,两处按页上分开记。
访问量图的纵轴从 400,000 到 650,000。2025 年 6 月 1 日在 40 万出头,7 月 1 日大约 55 万,8 月 1 日接近 63 万。
动态量化是另一件事:按层的重要程度分配不同的位宽,在压体积和留能力之间取平衡。对照的是 GPTQ。GPTQ 是训完再压,所有层用同一档位宽,见 DAY2 的 GPTQ。
| GPTQ | Unsloth 动态量化 | |
|---|---|---|
| 核心目标 | 把单层的量化误差压到最小 | 把整个模型的最终性能拉到最高 |
| 量化策略 | 统一量化,所有层固定位宽,例如 4 比特 | 选择性、异构量化,不同层可以分到不同位宽 |
| 决策粒度 | 层内(Intra-layer) | 层间、模块间(Inter-layer) |
| 决策依据 | 局部误差补偿,基于 Hessian 矩阵近似。看的是这一层量化前后差多少 | 全局性能校准,看这份模型在数据集上的实际表现 |
| 最终产物 | 一个均匀的低精度模型 | 一个混合精度的模型 |
| 性能表现 | 相对原始模型可能明显下降 | 通常明显好于 GPTQ,更接近原始模型 |
| 模型大小 | 压缩率高,而且可以事先估出来 | 压缩率略低于 GPTQ,因为有的层留在更高精度 |
5.3 Liger Kernel
小标题写成 Liger Kernel。后面的对照表把这一列写成 tiger_kernel。定位是轻量的深度学习内核工具,页上写它专注于推理阶段的硬件适配和计算效率。
三件事。硬件适配:按不同架构自己选一条计算路径。算子融合:把多个低效算子收成一次高效操作,少访问内存。这一步和 5.1 里把 MatMul、Softmax、MatMul 收成一个内核是同一类做法,对象不限于注意力。动态编译:用 JIT 即时编译,按这次输入的数据调整计算图。
应用场景写成边缘设备上的推理加速,以及实时 AI 服务部署。
Factory 的训练参数里另有 enable_liger_kernel,默认 false,和 use_unsloth 写在同一份训练配置里。页上的定位是推理,这个开关出现在训练配置里。两处按各自的写法留下。
5.4 Accelerate
Accelerate 把最常用的两套分布式框架收成一个接口:Fully Sharded Data Parallel(FSDP)和 DeepSpeed。这样 PyTorch 在各种机器设置上做分布式训练,不用各写一套启动。
第 3 节 已经用过这个接口。FSDP 和 DeepSpeed 仍是两套代码,共用的是 ZeRO 的切法。启动时不手写 FSDP(),而是 accelerate launch 配一份 fsdp_config。这页说的就是这层:换切分引擎时,改的是配置,启动命令还是 Accelerate。
四列对照。Unsloth 这一列的数字是速度提升 2–5 倍、显存减少 70%–80%。5.2 里开源训练写成 5 倍,横幅写成快 2 倍、显存少 80%,和这里是同一范围的两种写法。
tiger_kernel | flashattn2 | unsloth | accelerate | |
|---|---|---|---|---|
| 核心目标 | 推理效率优化 | 注意力计算加速 | 速度提升 2–5 倍 | 分布式训练简化 |
| 内存管理 | 静态内存预分配 | 动态分块与复用 | 用 OpenAI Triton 重写计算内核,显存占用减少 70%–80% | 自动内存优化与分配 |
| 硬件适配 | 多架构,CPU / GPU | GPU 优先 | GPU | 多 GPU / TPU 自动适配 |
| 计算优化 | 算子融合、JIT 编译 | Tensor Core 专用优化 | 混合精度与异步流水线 | 自动混合精度与分片 |
| 典型应用 | 边缘设备推理 | 大模型训练与推理 | 单卡(消费级显卡)微调 / 推理 | 多节点多卡训练部署 |
5.5 拓展QA
1. 之前在哪里遇到过 FlashAttention?是训基座的时候用的吗?
是训基座时用的,不是 LoRA 那套微调步骤。写在微调课里,是因为那一节在介绍 ChatGLM2-6B 这个基座怎么造出来。
DAY3 第 26 节 列 ChatGLM2 相对一代的三点,第二点是:采用 FlashAttention,上下文从 2K 提到 32K。同节第 2 问写过底层:公式仍是 (\mathrm{softmax}(QK^{T})V),改的是 GPU 上怎么算。(Q)、(K)、(V) 分块,在 SRAM 里做在线 softmax,不再把整张 (n \times n) 矩阵留在 HBM。2K 到 32K,这块矩阵的面积大约是原来的 256 倍,标准实现放不下。DAY4 3.1.2 复习基座改动时,把同一句又写了一遍。
微调课后面的 LLaMA-Factory 几次 demo 写明是普通 LoRA,不用 FlashAttention-2。安装说明里提过这个包,Windows 上做 QLoRA 或要开这个算子时才装。NLP 课里出现过的,是 PyTorch 没编译 flash_attention 时的一行警告,没有讲这个算法。
2. Unsloth 量化后的效果是不是好于 GPTQ?Factory 里能直接开吗?
效果上,页上写的就是通常明显好于 GPTQ,更接近原来的模型。换来的是体积略大:有的层留在更高精度,压缩率略低于 GPTQ。上一张表里 GPTQ 追求每一层的量化误差最小,Unsloth 按层分配位宽,看的是整个模型在数据上的表现。
Factory 里能开,开的是训练加速,不是用它替换 GPTQ 导出。框架表把 Unsloth 和 FlashAttention-2 放在「加速」那一行。训练 yaml 里加:
use_unsloth: true
默认是 false。quantization_bit: 4 时,它按 4 比特把底模载进来做 QLoRA;不写位数就是 16 比特的 LoRA。加载走 Unsloth 的 FastLanguageModel,手写内核就在这一步。模型类型它不支持时,会关掉这个开关,退回原来的加载。旁边还有 use_unsloth_gc,默认 false,开的是它自己的梯度检查点。
导出仍是 DAY2 那条:GPTQ、AWQ、AQLM 把训完的模型压成统一位宽。use_unsloth: true 不改这条导出,也不会按层写出上一张表里那种混合精度模型。
3. 基座训练为什么不用 Unsloth?能做 GPTQ 是不是就能开 Unsloth?
基座训练不用它。这页的 Unsloth 加速的是已经有底模之后的 LoRA / QLoRA。基座是全部参数都在更新,数据是数千亿词这一档,机器是上千张卡、训几个月,见 1.1。那种训练用的加速是 FlashAttention 这一类,ChatGLM2 把上下文从 2K 拉到 32K 就是这么做的,见 5.x 第 1 问。Unsloth 的 2 倍、5 倍是相对同一次微调的 PyTorch 实现,不是拿来从零训出一份 base。
动态量化和 GPTQ 都在模型已经训完之后。要按层看「哪一层更重要」,得先有一份高精度模型,再在数据集上看表现。基座还在训的时候,没有这份可以拿来分配位宽的成品。
硬件也不和 GPTQ 同一档。页上「无需硬件更改」是说微调还用原来的那张 GPU,把内核换成 Triton 就更快,不用为这次加速另买卡。GPTQ 是导出:示例把 export_device 写成 cpu,要一份未量化的完整权重和校准集 c4_demo.json,跑一次 llamafactory-cli export,见 DAY2 的 GPTQ。它不进入训练循环。
所以能做 GPTQ,推不出能开 Unsloth。GPTQ 成立的条件是合并后的高精度完整模型还在。Unsloth 成立的条件是训练这张卡能跑它的内核,而且 model_type 在它支持的名单里,不支持就会把 use_unsloth 关回去。反过来,手里如果只有一份已经压好的 GPTQ 权重,也开不了这次训练:QLoRA 和 Unsloth 的 4 比特是加载时现压,要的仍是未量化底模,见 DAY2 的合并限制。
4. 跑 Unsloth 要什么硬件?GPTQ 是不是什么机器都能跑?
Unsloth 这条训练要 GPU。官方 Core 写的是 2018 年及以后的 NVIDIA,CUDA 算力最低 7.0,例如 V100、T4、RTX 20、A100、H100。GTX 1070、1080 能跑,但是慢。系统是 Linux 或 Windows,机器上要有带 CUDA 的 PyTorch,以及 Triton、bitsandbytes。纯 CPU 开不了这次训练。
显存按它公布的下限:8B 做 4 比特 QLoRA 大约 6GB,16 比特 LoRA 大约 22GB。这是地板,序列一长、batch 大于 1 还会上去。和上面实测的 LoRA 20G、QLoRA 10G 是同一量级,不是另一套算法把显存消掉。
Factory 的 use_unsloth: true 调的就是这个 Core,按 NVIDIA 这张卡准备。AMD、Intel 有单独的安装说明,不在这次 yaml 的默认路径里。
GPTQ 不是所有硬件都能拿来推理。笔记里能放到 CPU 上的是导出那一步:export_device: cpu,把未量化的完整权重量化一次。导出不挑 GPU。压完的 4 比特模型要拿来对话,常见仍是 NVIDIA 上的 GPTQ 内核。CPU 能导出,不表示任意核显、手机或没有对应内核的机器都能以同样的速度跑这份权重。
5. 最后的对比,四个不在同一层,为什么能放在一张表里对比?
这张表比的是各自改训练里的哪一段、省的是哪一种开销。行是核心目标、内存、硬件、计算和场景。四列没有统一的加速倍数,只有 Unsloth 写了 2–5 倍。拿来当四选一的速度排名,对不上。
一次前向从外到里是两截。外面决定几张卡、参数怎么切,这是 Accelerate。里面某一层算子怎么写,才是另外三列。
| 改的是哪一段 | 和谁叠在同一次运行里 | |
|---|---|---|
| accelerate | 进程和切分。MULTI_GPU、DEEPSPEED、FSDP 都由它拉起 | 外面这一层。里面的注意力、其余算子照常算 |
| flashattn2 | 只换注意力这一个算子。分块、融合、在 SRAM 里做 softmax,见 5.1 | 可以套在 Accelerate 拉起的每张卡里面 |
tiger_kernel | 算子融合和 JIT,对象不限于注意力。页上定位是推理 | 和 FlashAttention 同属「这个算子怎么写」。注意力交给前一列,其余算子可以走这一列 |
| unsloth | 一整套单卡微调。用 Triton 重写内核,再加 4 比特或 16 比特的加载,见 5.2 | 占的是「这一步怎么算」。和前两列比的是内核由谁来写;和 Accelerate 比的是另一段 |
所以四列能并排,是因为每列回答的是不同的问题:卡怎么切开、注意力怎么算、其余算子怎么融合、单卡微调的整段循环由谁重写。同一次多卡训练可以外面用 Accelerate,里面注意力用 FlashAttention。Unsloth 自己已经把单卡微调的内核换成 Triton,它和 tiger_kernel、flashattn2 比的是同一段计算,和 Accelerate 不在一段上。
6. Unsloth 为什么能做动态量化?原理是什么?
量化是把已经训好的权重,改用更少的位数来存。16 比特能分开很接近的两个数。4 比特一共只有十几个格子,很多不同的权重会被收成同一个数。收掉的那一点就是误差。
一层是 (h = Wx)。权重变成 (W+\delta) 之后,输出变成原来的 (h),再加一项 (\delta x)。(\delta) 是权重被收掉多少,(x) 是这一层实际乘上的激活。权重只收掉一点点,乘上的激活很大,输出就会偏一截。
用两个数看这一项从哪来。这是缩小的例子,不是页上的数字。
高精度:
[ h = 1.0 \times 2 + 0.1 \times 0.2 = 2.02 ]
格子一粗,(0.1) 被收成 (0)。权重误差是 ([0,\ -0.1])。多出来的项是 (-0.1 \times 0.2 = -0.02)。输出从 (2.02) 变成 (2.00),几乎没动。
同一份权重误差,把第二个激活从 (0.2) 换成 (8):
[ h = 1.0 \times 2 + 0.1 \times 8 = 2.8 ]
量化后第二个权重是 (0),输出变成 (2.0)。权重只被收掉 (0.1),输出偏了 (0.8)。
所以同一层、同一档位宽,碰上的激活不同,伤害差很多。后面的层还会把这个偏差再乘一次。有的层压完,最后生成的句子几乎不变。有的层压完,整句就偏了。统一 4 比特给每一层同样的位数:敏感的那层位数不够,不敏感的层又占着用不上的位数。
页上把位数改到层与层之间来配。步骤是:
- 留下一份还没压过的高精度模型,当作对照。基座还在训的时候没有这份成品,所以这一步做不了,见 第 3 问。
- 准备一批校准用的句子。页上写的是看这份模型在数据集上的实际表现。
- 先用高精度模型把这些句子跑一遍,记下输出。
- 一次只把一层,或一个模块,换成更低的位宽,同样的句子再跑一遍。这一步不更新权重,只是试「这个已经训好的数用几位来存」。
- 整句输出几乎不变,这一层就用低位宽。整句输出明显变了,这一层退回更高位宽。
- 各层试完,得到一张固定的表,例如第 1 层 8 比特、第 2 层 4 比特。表写进模型里,之后不再改。页上没有写用哪一个分数来量「明显变了」,也没有写哪一层必须是哪一档。公开的做法是和这份高精度模型比,每个模型的表不一样。
- 推理时第 1 层按 8 比特的格子取权重,第 2 层按 4 比特取。换一句输入,位数也不变。
产物是一份混合精度模型。比「全部 4 比特」略大,因为有的层没压到底。整句输出通常更接近原来的模型。
GPTQ 也在减小误差,它盯着一层自己的输出,让这一层的 (h) 尽量接近原来的 (h),用的是这一层的 Hessian 近似。每一层最后仍是同一档。敏感的那层没有额外的位数可用。对照在 5.2。
「动态」容易听成推理时随输入改位数。这页指的是上面那张表:层与层的位宽可以不同,校准做完就固定。
页上另一句「精度损失为 0%」说的是 Triton 内核按原来的公式重写,不用近似去换速度。动态量化是训完之后按层压位数,相对原模型会有损失,只是通常比统一位宽更接近。Factory 的 use_unsloth: true 开的是内核这一件,按 4 比特或 16 比特把底模载进来做 QLoRA / LoRA。它不跑上面第 4 到第 6 步,也不会写出这份混合精度模型,见 第 2 问。
6. 量化核心原理介绍
把浮点权重收成整数再存。整数格子是固定的,浮点范围怎么对齐这些格子,由 scale 和 zero_point 决定。
6.1 对称量化和非对称量化
对称量化要求范围关于零点对称,(r_min = -r_max)。zero_point 就是 0,计算更简单,但会浪费一部分量化区间。非对称量化允许 (r_min) 和 (r_max) 各自取值,整个整数区间都用来表示真实数值,精度更高,但要单独处理 zero_point。
真实数值落在 -3 到 10.2。对称要求两边一样长,左端就得取 -10.2,范围变成 -10.2 到 10.2,zero_point 是 0。-10.2 到 -3 没有原始数值,整数从 -127 到 128 里仍有一截格子分给这段。真正有数的 -3 到 10.2 只能用剩下的格子。
| 左端 | 右端 | 这段里有什么 | |
|---|---|---|---|
| 真实数值 | -3 | 10.2 | 原始权重要表示的范围 |
| 拉成对称之后 | -10.2 | 10.2 | zero_point = 0。-10.2 到 -3 没有原始数值,-3 到 10.2 才有 |
| 对应的整数 | -127 | 128 | 没有原始数值的那一段仍占一截整数格子 |
空出来的区间会把步长拉大。整数间隔数是 (128 - (-127) = 255)。
对称时范围被拉成 20.4:
[ scale = \frac{10.2 - (-10.2)}{255} = \frac{20.4}{255} = 0.08 ]
非对称时范围就是真实的 13.2:
[ scale = \frac{10.2 - (-3)}{255} = \frac{13.2}{255} \approx 0.0518 ]
scale 是每个整数间隔代表的浮点大小。对称多出来的那截空白也要分格子,真实数值每一格代表的浮点更大,同样的整数范围更粗。非对称把 255 个间隔都分给 -3 到 10.2,一格更小,更接近原来的数。代价是浮点 0.0 不再对准整数 0,要记下 zero_point。
6.2 核心参数:scalar 和 zero_point
小标题写成 scalar。公式和说明里写的是 scale,指的是同一个量。
[ scale = \frac{r_max - r_min}{q_max - q_min} ]
(r_max - r_min) 是浮点数要表示的总范围。(q_max - q_min) 是整数域可用的间隔数。UINT8 是 (255 - 0 = 255) 个间隔。两者相除,得到每个整数间隔代表的浮点大小,就是步长 scale。整数每增加 1,浮点增加 scale。
zero_point 是浮点零点 0.0 映射到的那个整数,用来把两个范围锚在一起。
[ zero_point = q_min - round(r_min / scale) ]
与它等价的另一式:
[ zero_point = round(-r_min / scale) + q_min ]
(q_min) 通常是 0,于是简化成 (round(-r_min / scale))。对称量化里这个值就是 0。
下面三组都按这两个式子算。整数每增加 1,浮点就增加一个 scale。zero_point 是浮点 0 落在哪个整数上。
对称,沿用 -10.2 到 10.2、整数 -127 到 128。scale 是 0.08,zero_point 是 0。
| 整数 (q) | 还原出的浮点 (0.08 \times q) |
|---|---|
| -1 | -0.08 |
| 0 | 0 |
| 1 | 0.08 |
| 2 | 0.16 |
浮点 0 落在整数 0 上,所以 zero_point 是 0。整数从 0 走到 1,浮点从 0 走到 0.08,走的就是这个步长。
非对称,浮点仍是 -3 到 10.2,整数改成 UINT8 的 0 到 255,(q_min = 0)。间隔数还是 255,scale 是 (13.2 / 255 \approx 0.0518)。
[ zero_point = round\left(\frac{-(-3)}{13.2/255}\right) = round(57.95) = 58 ]
| 整数 (q) | 还原 (0.0518 \times (q - 58)) | 它在表示 |
|---|---|---|
| 0 | 约 -3.00 | 左端 -3 |
| 58 | 0 | 浮点零点 |
| 59 | 约 0.052 | 比零点多一个步长 |
| 255 | 约 10.20 | 右端 10.2 |
零点不再是整数 0。整数 58 才是浮点 0,整数 0 被拿去表示 -3。同一段真实数值,步长从对称的 0.08 收到约 0.0518。
再缩成能口算的一档。浮点 -2 到 6,整数 0 到 4。
[ scale = \frac{6 - (-2)}{4 - 0} = 2 ]
[ zero_point = round\left(\frac{-(-2)}{2}\right) = 1 ]
| 整数 (q) | 还原 (2 \times (q - 1)) |
|---|---|
| 0 | -2 |
| 1 | 0 |
| 2 | 2 |
| 4 | 6 |
整数 1 是浮点 0。整数每加 1,浮点加 2。-2、0、2、6 这些正好落在格子上的数,还原回来还是自己。落在两格之间的数,要等量化那一步用 (round) 收进去。
6.3 量化与反量化
浮点收成整数:
[ q = round(r / scale) + zero_point ]
[ q = clamp(q,\ q_min,\ q_max) ]
clamp 保证结果不超出整数范围。
整数还原成浮点:
[ r' = scale \times (q - zero_point) ]
(r') 是量化再反量化之后的近似值,会损失一些精度。
精度损失来自 (round),出界时再加一次 (clamp)。存下来的是整数 (q),不是原来的浮点 (r)。反量化只能由这个整数算回一个浮点,同一个 (q) 对应的所有原始值都变回同一个 (r')。
用上面对称的 (scale = 0.08)、(zero_point = 0) 看 (round)。(r = 0.03):
[ q = round(0.03 / 0.08) = round(0.375) = 0 ]
[ r' = 0.08 \times (0 - 0) = 0 ]
0.03 回到了 0。(r = 0.05) 时 (0.05 / 0.08 = 0.625),(round) 得到 1,(r' = 0.08)。凡是除以 scale 之后小数部分被收掉、落到同一个整数的浮点,还原时都变成这一个数。丢掉的就是这个小数部分。
(clamp) 处理的是格子外面的数。(q) 小于 (q_min) 或大于 (q_max) 时被按到端点。端点以外的浮点共用这一个整数,还原时只能回到端点对应的那个浮点,偏差可以大于半个步长。
所以 (r') 靠近 (r),等于 (r) 只发生在 (r) 正好落在某个格子的代表值上。这一步收出来的 (r' - r),就是前面写的权重误差 (\delta)。
6.4 拓展QA
1. 混合精度里的数值类型转换,和这一节是同一套思路吗?
都是少用几位来存一个数,换回来都是近似值。转换的做法不一样。
6.1 到 6.3 先看一整段数的 (r_min)、(r_max),算出一个共用的 scale 和 zero_point,再把每个浮点投到整数格子上。格子等距。上面那组对称的例子里,scale 是 0.08,0.03 和 10.2 用的是同一个步长,0.03 被收成整数 0,还原回来是 0。
混合精度里的 float2half 是每个数自己换浮点格式,见 3.2。FP32 是 1 个符号位、8 位指数、23 位尾数。收成 FP16 时,指数变成 5 位,尾数变成 10 位。收成 BF16 时,指数仍是 8 位,尾数变成 7 位。这一步不看这段数的最小最大,不算 scale,也不做 (q = round(r / scale) + zero_point)。0.03 换成 FP16,旁边有没有 10.2 都不参加它的转换,丢掉的是它自己的尾数位。
误差的形状也不一样。量化整段共用一个步长,偏差大体是半个 scale。浮点格式的一格有多大,跟着这个数本身走:数越大,尾数上的一格代表的绝对值越大。FP16 还把指数从 8 位收到 5 位,太大的数会溢出,范围大约到 65504。BF16 留下和 FP32 一样的指数,就是为了避开这种溢出,代价是尾数更短。
所以混精的主权重仍是 FP32 浮点。前向之前收成 16 位浮点去算,更新再写回 32 位主权重。6.1 到 6.3 存下来的是整数,要用 scale 和 zero_point 才能还原。
2. 为什么这一节叫量化核心原理?和量化是什么关系?
这一节写的就是量化本身。量化是把原来的浮点权重 (r) 换成一个小整数 (q) 存起来,要用的时候再算回一个近似值 (r')。6.1 到 6.3 就是这两步怎么做。
没有 scale 和 zero_point,整数格子里的 0、1、2 不知道该还原成哪个浮点。6.1 决定这段浮点范围怎么摆:对称把零点放在正中间,zero_point 是 0;非对称按真实的最小最大来摆,零点另记。6.2 算出一格有多大、浮点 0 落在哪个整数。6.3 用 (round) 和 (clamp) 得到要存的 (q),再用 (r' = scale \times (q - zero_point)) 还原。(r' - r) 就是量化误差。
QLoRA 里已经用过这两个量。底模从 16 比特收成 4 比特,同时记下 scale 和 zero-point,前向和反向时按它们把 4 比特还原回 16 比特再做矩阵乘。4 比特只有十几个格子,格子怎么对齐那段浮点、还原时乘多少,就是这里的式子。存下来的体积小,是因为每个权重只留一个小整数,外加这一组 scale 和 zero_point,不再留完整的 16 位浮点。
后面的差别都是在这一步上选参数。GPTQ 仍把一层收成同一档整数,只是尽量让这一层的 (h) 接近原来的 (h)。动态量化仍是收成整数,只是不同层用不同的位宽,敏感层格子更细。位宽、对称还是非对称、scale 取多少,变的是格子有多密。收成整数、再乘 scale 还原,这一步不变。
3. Factory 里的量化和这一节是同一个量化吗?
是同一类:把浮点权重收成低位数存起来,计算前再还原成近似的浮点。第 6 节是这套里最基本的一种,整段共用一个 scale,格子等距,用 (round) 投进整数。
Factory 训练时打开的量化不是按这个等距格子排的。yaml 里写:
quantization_bit: 4
quantization_method: bitsandbytes # choices: [bitsandbytes (4/8), hqq (2/3/4/5/6/8), eetq (8)]
bitsandbytes 把底模按 4 比特或 8 比特放着,矩阵乘之前还原成 16 比特,训练的仍是 LoRA。4 比特常用的格式是 NF4:还是 16 个格子,按正态分布来排,0 附近密、两头稀,不是 6.2 里每格都差 0.08 那种等距。还原仍靠一块权重共用的缩放系数。双重量化是把这些系数再压一次,权重的 4 比特不变。这两点写在 DAY4 第 2 问。Factory 的 yaml 只写位数和方法,不写 nf4 和双重量化那两行;百川脚本里才写成 bnb_4bit_quant_type="nf4"。hqq 还能取 2、3、5、6 位,eetq 只取 8 位,都是加载时量化,格子算法各自一套。
导出是另一条。GPTQ、AWQ、AQLM 不写 quantization_bit,把 model_name_or_path 指到已经压好的模型。GPTQ 一层仍是同一档位宽,看的是这一层输出差多少,不是只做 (round(r / scale))。见 DAY2 的 GPTQ。FSDP 加 QLoRA 不用这种已经压好的 GPTQ、AWQ 模型。合并时底模要换回没量化的权重,yaml 里也不写 quantization_bit,见 DAY2 的合并限制。
所以第 6 节给出存和还原的骨架。Factory 训练默认走 NF4,格子不均匀;导出走 GPTQ 这一类,开关也不在 quantization_bit 上。
7. PTQ量化原理
训练完成后,再把已经训好的浮点权重量化。要找一种量化方式,让量化前后的数值分布仍然接近,把 FP32 映射到定点整数 INT8 或 INT4。
7.1 量化步骤
五步:
- 确定量化范围,INT8 或 INT4。
- 计算比例因子 scale 和零点 zero point。把量化范围线性映射到 INT8 的范围,得到比例因子 (S) 和零点 (Z)。这就是 6.2 的那两个量。
- 量化权重:通过 scale 和 zero point。
- 量化激活值:用少量校准数据,统计激活值的分布,据此确定量化范围。
- 计算与推理:训练、推理时先通过 INT8 计算,再反向量化为浮点数。
代码按权重的最小最大来定范围。除数是 255,结果再转成 np.int8。
import numpy as np
# 假设待量化的权重矩阵
weights = np.random.rand(3, 3)
# 计算量化范围
a = np.min(weights)
b = np.max(weights)
# 计算比例因子和零点
scale = (b - a) / 255
zero_point = -round(a / scale)
# 量化权重
weights_quant = np.round(weights / scale + zero_point).astype(np.int8)
# 反量化得到近似值
weights_dequant = (weights_quant - zero_point) * scale
a 是 (r_min),b 是 (r_max)。scale = (b - a) / 255 就是整段范围除以 255 个间隔。zero_point = -round(a / scale) 就是 (q_min = 0) 时的 (round(-r_min / scale))。量化是 (round(r / scale + zero_point)),反量化是 ((q - zero_point) \times scale),和 6.3 同一对式子。
BitAndBytes、GPTQ、HQQ 都列在这类训练后量化里。
7.2 GPTQ
GPTQ(Accurate Low-bit Quantization of Language Models)针对大模型做低精度量化。目标是一层权重量化之后,这一层输出上的误差最小。
模型训练完成之后,对每一层的权重做量化。用近似的二阶优化,例如 Hessian 矩阵,把量化误差压小,低精度下仍尽量保住原来的表现。
要最小化的是
[ \min_{\hat{W}} | W X - \hat{W} X |_2^2 ]
(W) 是原来的浮点权重,形状是 out_features × in_features。(\hat{W}) 是量化后的整数权重。(X) 是一小部分无标签校准数据通过这一层时的输入激活。用这些真实输入看权重一变,输出差多少。
步骤:
- 选择目标:用分组量化把权重分组。
- 逐列量化:按列处理权重矩阵。量化当前列时,其他已经量化的列固定不动。
- 重构误差:算出当前列量化产生的误差。
- 误差反馈:把这个误差反馈给后面还没量化的列,修正那些值,补偿当前列造成的损失。
重复 2 到 4,直到每一列都量化完。
7.3 一个 2×2 的例子
把一个 2×2 的权重从高精度(例如 FP16)收成整数(例如 INT4)。原始权重仍是
[ W = \begin{bmatrix} 2.3 & 5.7 \ 1.9 & 4.1 \end{bmatrix} ]
这一组取 scale (= 0.5),zero point (= -5)。一格代表 0.5 个浮点,浮点 0 落在整数 (-5) 上。量化、反量化仍是
[ q = round(r / scale + zero_point), \qquad r' = (q - zero_point) \times scale ]
反馈用的误差是 (r - r'),不是 (r - q)。(q) 只是格子编号,和权重不在同一个单位上。
海森逆矩阵设成
[ H^{-1} = \begin{bmatrix} 2 & 4 \ 4 & 9 \end{bmatrix} ]
这是为了把比例算出来而设的一组数,不是从校准数据里求的。对角是 2,非对角是 4,都不是 1。量化第 1 列时,这一列的误差先除以对角上的 2,再乘第 1 行第 2 列那个 4,从后面一列里减去:
[ \mathrm{err} = \frac{r - r'}{2}, \qquad W_{\mathrm{col2}} \leftarrow W_{\mathrm{col2}} - \mathrm{err} \times 4 ]
GPTQ 按列做,这里把列说成输出通道。先量化第一列 ([2.3,\ 1.9]^{\mathsf T})。
(2.3):(2.3 / 0.5 + (-5) = -0.4),收到 (q = 0),还原 (r' = 2.5),误差 (2.3 - 2.5 = -0.2)。
(1.9):(1.9 / 0.5 + (-5) = -1.2),收到 (q = -1),还原 (r' = 2.0),误差 (1.9 - 2.0 = -0.1)。
第一列的整数固定为 ([0,\ -1]^{\mathsf T})。误差 (-0.2)、(-0.1) 按上面的比例补进第二列:
[ 5.7 - \left(\frac{-0.2}{2}\right) \times 4 = 5.7 + 0.4 = 6.1 ]
[ 4.1 - \left(\frac{-0.1}{2}\right) \times 4 = 4.1 + 0.2 = 4.3 ]
矩阵变成
[ W' = \begin{bmatrix} 2.5 & 6.1 \ 2.0 & 4.3 \end{bmatrix} ]
左列已经是还原值 (r'),右列还是浮点。再量化第二列。
(6.1):(6.1 / 0.5 - 5 = 7.2),收到 (q = 7),还原 (6.0)。
(4.3):(4.3 / 0.5 - 5 = 3.6),收到 (q = 4),还原 (4.5)。
存下来的是整数 (q)。(r') 是用 scale 乘回去的浮点,scale 是 0.5,所以它落在 0.5 的倍数上,看起来不是整数。scale 取 1、zero point 取 0 时,(r') 才和 (q) 是同一个数。
[ q = \begin{bmatrix} 0 & 7 \ -1 & 4 \end{bmatrix}, \qquad r' = \begin{bmatrix} 2.5 & 6.0 \ 2.0 & 4.5 \end{bmatrix} ]
这四个整数都落在 INT4 的 (-8) 到 (7) 里。若不先补偿,第二列仍是 (5.7) 和 (4.1),会收到 (q = 6) 和 (q = 3),还原成 (5.5) 和 (4.0)。除以 2 再乘 4 之后,两格都跨过了取整边界,收到的是 (7) 和 (4)。
7.4 Hessian 在这里表示什么
权重的 Hessian 矩阵旁边标着牛顿法。格子里没有填数。(i)、(j) 这一格写的是所有权重元素 22 的相关性,也叫影响度:同时改变 (i) 和 (j),最终对体系造成多大的协同影响。
下面一块是权重的 Hessian 逆矩阵,标题写成「逆矩阵矩阵」,格子里同样没有填数。它回答的是:为了抵消某个权重变化带来的影响,应该按什么比例去调整、补偿其他权重。上面那个例子里对角是 2、非对角是 4:第一列的误差先除以 2,再乘 4,补到第二列。比例不是 1,两行补进去的量就不是原来的误差本身。
7.5 拓展QA
1. Hessian 旁边标的牛顿法,在这里是什么意思?
牛顿法是用二阶导数定一步该走多远。损失对权重的一阶导数是梯度,二阶导数排成 Hessian 矩阵 (H)。一步写成
[ \Delta w = -H^{-1} \nabla L ]
梯度只说「往哪边变,输出会变好」。(H^{-1}) 再把这个变化换成每个权重该动多少。两个权重对输出的影响缠在一起时,不能各动各的,要按 (H^{-1}) 里的比例一起动。
GPTQ 没有用牛顿法去重新训练。一层的目标已经是 (|WX - \hat{W}X|_2^2),量化把某一个权重从 (r) 硬收到 (r'),相当于在这个损失上强行走了一步。旁边标牛顿法,是因为补偿用的是同一种乘法:这个误差先乘 (H^{-1}),再加到还没量化的权重上。格子里没有把牛顿法的迭代写出来,只留下 (H) 和 (H^{-1}) 各一张空表。
对上 7.3 的数。第一列 (2.3) 收到整数 (0),还原成 (2.5),误差 (-0.2)。(H^{-1}) 对角是 2、非对角是 4,所以第二列加上的是 ((-0.2)/2 \times 4 = -0.4) 的相反数,(5.7) 变成 (6.1)。除以 2 是在用这一列自己的曲率把误差归一,乘 4 是牛顿法里「另一个权重该按什么比例跟着动」。若比例是 1,(5.7) 只会加上 (0.2),取整边界可能跨不过去。
2. 例子最后为什么不是整数?是因为 scale 取了 0.5 吗?
存下来的结果是整数。那张 (q) 是
[ \begin{bmatrix} 0 & 7 \ -1 & 4 \end{bmatrix} ]
四个数都在 INT4 的 (-8) 到 (7) 里。旁边的 (2.5)、(6.0)、(2.0)、(4.5) 是还原值 (r'),公式是 ((q - (-5)) \times 0.5)。
(0) 还原成 ((0+5)\times 0.5 = 2.5),(7) 还原成 ((7+5)\times 0.5 = 6.0),(-1) 还原成 (2.0),(4) 还原成 (4.5)。scale 是 0.5,整数乘 0.5 就落在半格上。(6.0) 和 (2.0) 看起来像整数,也是 (0.5) 乘出来的。
中间那张 (W') 的左列写成 (2.5)、(2.0),同样是还原值,不是存下来的 (q)。右列 (6.1)、(4.3) 还没量化,所以更不是整数。
scale 取 1、zero point 取 0 时,(r' = q),量化结果看上去就是整数。scale 不是 1 时,磁盘上仍是 (q),算的时候才乘回 scale。
3. 真实场景里 Hessian 矩阵怎么算出来?
7.3 里的 (\begin{bmatrix} 2 & 4 \ 4 & 9 \end{bmatrix}) 是为了把除法乘出来而设的,不是算出来的。真实的 (H) 来自校准数据进这一层时的激活,不来自权重本身。
一层的损失是 (|WX - \hat{W}X|_2^2)。(W) 的一行是这条输出通道上的权重,长度等于输入通道数。把这一行的损失对权重展开,二次项的系数是
[ H = 2XX^{\mathsf T} ]
(X) 的每一列是校准集里一个 token 进到这一层时的输入激活,行数是输入通道数。(XX^{\mathsf T}) 把这些激活按通道两两相乘再加起来,得到一张输入通道 × 输入通道的矩阵。同一层的每一行输出共用这一张 (H),因为式子里没有 (W),只和 (X) 有关。所以一层只算一次,再拿去逐列改这一层的所有行。
(H_{ij}) 大,表示校准句子里第 (i) 个输入通道和第 (j) 个输入通道经常一起大。同时改这两列权重,输出就往同一个方向偏。这就是前面说的相关性。对角是这一列自己有多“响”。
用两个 token、两个输入通道看乘法。这组 (X) 只说明公式,不是 7.3 那张逆矩阵,也不是 c4_demo.json。
[ X = \begin{bmatrix} 1 & 2 \ 0 & 1 \end{bmatrix}, \qquad XX^{\mathsf T} = \begin{bmatrix} 5 & 2 \ 2 & 1 \end{bmatrix}, \qquad H = 2XX^{\mathsf T} = \begin{bmatrix} 10 & 4 \ 4 & 2 \end{bmatrix} ]
再求逆,才是补偿时用的那张表。实现里常把前面的 2 省掉:(H) 和 (H^{-1}) 同时乘一个常数,误差先除对角、再乘非对角,这个常数会消掉,比例不变。校准 token 不够、或者两列激活几乎成比例时,(H) 不可逆,对角上会加上平均对角的一小截,常见是 (1%),然后再做 Cholesky 求逆,不直接对整张矩阵做 inv。
Factory 导出 GPTQ 时,yaml 不写这张矩阵。校准句子在 export_quantization_dataset: data/c4_demo.json,导出过程里逐层把这些句子的激活乘成 (XX^{\mathsf T}),见 DAY2 的 GPTQ。分组量化只决定多少列共用一个 scale,不代替这次乘法。
4. scale 和 zero point 是怎么来的?
不从 Hessian 来。7.3 里的 (0.5) 和 (-5) 是为了让取整边界跨得过去而手选的,不是这四个权重算出来的。
真实量化时,先把连续的若干列分成一组,一组共用一对 scale 和 zero point。常见是 128 列一组。导出 yaml 里没有这个字段,用的是库的默认。这一组权重的最小值是 (a),最大值是 (b)。4 比特从 0 到 15,一共 15 个间隔。公式就是 6.2 和 7.1 那一对:
[ scale = \frac{b - a}{15}, \qquad zero_point = round(-a / scale) ]
(zero_point) 在 (q_min = 0) 时用后面这一式。格子有多密,由这一组自己的跨度 (b-a) 决定。零点落在哪个整数上,由最小值 (a) 离 0 有多远决定。
把 7.3 的整张矩阵当成一组:(a = 1.9),(b = 5.7)。
[ scale = \frac{5.7 - 1.9}{15} = \frac{3.8}{15} \approx 0.2533 ]
[ zero_point = round(-1.9 / 0.2533) = round(-7.5) = -8 ]
(-7.5) 落在两个整数正中间,按远离 0 收到 (-8)。这和例子里手选的 (0.5)、(-5) 不是同一对。手选的步长更粗,零点也不是由 (1.9) 推出来的。
两件事各看各的输入。校准集 c4_demo.json 提供的是进层激活 (X),用来算 (H = 2XX^{\mathsf T}),决定量化误差按什么比例补到后面的列。scale 和 zero point 看的是权重组的最小、最大,校准句子不参加这两个数。激活值自己的量化范围才用校准数据的分布来定,那是 7.1 的第 4 步,和权重组的 scale 不是同一个数。