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

2 阅读55分钟

2026.11.16 10:01:39

学习路线

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. 数据获取

按动手做的顺序写:先定阶段和要调的能力,再定数据从哪来、一条里写什么、用 Alpaca 还是 ShareGPT,然后把原始数据拿到本机,转成 jsonl,最后登记进 dataset_info.json。原文在 DAY1 第 1 节 和 第 2 节。

1.1 先定这次训哪一阶段

预训练得到 Base,有监督微调得到 Instruct/Chat,强化学习得到对齐过偏好的模型,再往下才是垂直领域微调。垂直领域没有单独一列,它接在后面两步之后。

预训练有监督微调奖励建模强化学习
数据图书、百科、网页,数千亿单词数万条指令和答案百万量级的对比对十万量级的用户指令
算法语言模型语言模型二分类强化学习
得到基础模型SFT 模型RM 模型RL 模型
资源1000+ GPU,按月1–100 GPU,按天1–100 GPU,按天1–100 GPU,按天

只做预训练,模型学的是把文本往下接,会停不下来,也会把同一段再说一遍。有监督微调收成问一句、答完就停。强化学习再按人的偏好把啰嗦和重复压下去。垂直领域微调补不上这两步没做的事。

1.2 定要调什么、数据从哪来

微调要调的是模式、风格、知识、任务。来源分原生和衍生。原生是业务数据、网上抓来的、公共数据集。网上的和公共的会夹着隐私和有害内容,进训练前先清洗。原生不够,就让 GPT-5 或 Claude 按格式生成,例如 100 条意图识别,输出写成 Q: xxx A: xxx,意图是吃饭、睡觉、洗澡、出去玩。强化学习用的对比和指令也放在生成这一边。

先看开源数据集。自己标一条就要一条人工,数据量和成本放在一起权衡。拿到手再切成训练集和验证集:训练集改参数,验证集看是不是只会做见过的题。单轮是一问一答,多轮是同一件事接着聊。

只用一个窄领域去微调,会把原来的参数洗掉。金融上去了,代码、翻译、function calling 会掉。补法是按比例混回去:这三项各留 50%/3,加起来一半,金融数据就不会把它们整段盖掉。

1.3 定一条样本里写什么

类型一条里有什么
意图识别与槽位抽取text、intent、entities。天气查询抽时间、地点、天气类型,音乐播放抽歌手
文本摘要text 加 summary。一条是诺贝尔物理学奖,一条是 2023 年 GDP
语言翻译多轮,带 conversation_id 和 domain。每轮有中文和英文
工具调用system、user、assistant、function 再回到 assistant。助手先给出函数名和参数,函数返回后再用一句话答

样例全文在 1.4。

1.4 选定 Alpaca 还是 ShareGPT

转文件之前先定格式。单轮用 Alpaca,多轮用 ShareGPT。后面转换时按这张表填字段,登记时再把列名对上。

AlpacaShareGPT
适合单轮。instruction、input、output。input、system、history 可空多轮。conversations 里一轮一个 from 加 value
登记columns 把 prompt、query、response 对到那三列formatting: sharegpt,messages 对到 conversations,tags 标出角色字段和用户、助手各叫什么

样例里 ShareGPT 的角色写成 human 和 gpt,另一份登记示例写成 user 和 assistant。转换时 from 用哪一套,登记时 tags 就写哪一套。字段说明见 1.6 和 1.7。

1.5 把原始数据拿到本机

格式定了再取数。公共数据集从 Hugging Face 拉到本机缓存。国内访问走镜像,并打开加速:

export HF_ENDPOINT=https://hf-mirror.com  # 镜像网站
export HF_HUB_ENABLE_HF_TRANSFER=1  # 开启加速

vtllms/sealqa 用 name 选子集 seal_0、seal_hard、longseal,split 用 test。第一次下完,再加载就指本机缓存 /root/.cache/huggingface/hub/datasets--vtllms--sealqa。加载写法在 2.1。

这次转成训练文件的是 Heng666/Traditional_Chinese-aya_dataset。页面上是问答、翻译、摘要,parquet,中文,大约 4.91k 行,协议 apache-2.0。列是 inputs、targets、language、language_code、annotation_type、user_id。

from datasets import load_dataset
datasets = load_dataset("Heng666/Traditional_Chinese-aya_dataset")

Hub 上找不到时,同一句改成缓存路径 datasets--Heng666--Traditional_Chinese-aya_dataset。笔记本里 train 有 4909 行,配置名 default,缓存时间 2025-09-11 17:55:07。inputs 和 targets 的前 10 条是论语、孔子一类问答。

另一份已经在本机:/root/data_file/finance.xlsx,81 行,两列 question 和 answer,内容是债券、ETF、平仓、多头、空头、套利、期权。读 xlsx 要先有 openpyxl。

1.6 转成 jsonl,放进 data/

转好的文件放在仓库的 data/。Alpaca 用上面那份中文数据:inputs 放进 instruction,targets 放进 output,input 写成空字符串。一行一个 JSON,写到 /root/autodl-tmp/LLaMA-Factory/data/traditional_chinese.jsonl。函数在 2.2。

ShareGPT 用那份 Excel。每一行收成一轮:from 为 human 的是问题,from 为 gpt 的是答案,和 1.4 里样例的角色名一致。写到 /root/autodl-tmp/LLaMA-Factory/data/finance_sharegpt.jsonl。函数在 2.3。

1.7 登记之后训练才能选到

文件落盘后再登记。系统自带的和自己做的都写进 dataset_info.json,训练 yaml 里才能按名字选到。不登记,写了名字也选不到。

常用字段:file_name 指向本机文件,formatting 默认 alpaca,多轮写成 sharegpt。ranking 默认 false。列名对不上时用 columns,角色名对不上时用 tags。不自己转、直接从网上拉的,写 hf_hub_url 或 ms_hub_url。同一份文件里能看见的几条:

登记名从哪读列
fineweb-eduhf_hub_url: HuggingFaceFW/fineweb-eduprompt → text
the_stackhf_hub_url: bigcode/the-stack,ms_hub_url: AI-ModelScope/the-stackprompt → content
starcoder_pythonhf_hub_url: bigcode/starcoderdata,ms_hub_url: AI-ModelScope/starcoderdata,folder: pythonprompt → content
vtllms_sealqa_alpacafile_name: sealqa_alpaca.jsonlprompt / query / response → instruction / input / output

刚才转出的两份按完成先后登记。先是 Alpaca 那份,再是 ShareGPT 那份:

"traditional_chinese": {
  "file_name": "traditional_chinese.jsonl",
  "columns": {
    "prompt": "instruction",
    "query": "input",
    "response": "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 不写 formatting,按默认的 Alpaca 读。finance_sharegpt 写成 sharegpt,user_tag 是 human,assistant_tag 是 gpt,和转换函数里的 from 对得上。原文在 2.4。

2. 训练参数总结

一次训练只开一个引擎。学习率、epoch、数据集三套训练 yaml 都有,下面先分清引擎,再列三份里相同的字段,最后只写每种引擎多出来的几行。数据切分没有字段,多进程拉起来就在切样本。

带 * 的是跑之前要核对的。yaml 里的注释可以留着再跑。json 里的 // 不能另存进 .json,DeepSpeed 直接用仓库里的原文件。

2.1 先定引擎

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

引擎常用文件多出来的字段怎么启动
DDPexamples/train_lora/llama3_lora_sft.yaml不写 deepspeed:。精度是 bf16: true单卡 llamafactory-cli train 这份。多卡在命令前加 FORCE_TORCHRUN=1,卡数不写在 yaml 里
DeepSpeedllama3_lora_sft_ds3.yaml,加上它指向的 ds_z3_config.jsonyaml 看 deepspeed:。json 看 stage。显存不够,这一行改成 ds_z3_offload_config.json同样是 FORCE_TORCHRUN=1 llamafactory-cli train
FSDPQLoRA 训练 yaml,加上 fsdp_config.yaml训练 yaml 不写 deepspeed:,多 quantization_bit: 4。集群配置里是 distributed_type: FSDP、FULL_SHARD,num_processes 等于实际 GPU 数bash examples/extras/fsdp_qlora/train.sh。里面是 accelerate launch,这一门没有 llamafactory-cli 那条

accelerate 配成 MULTI_GPU 或 DEEPSPEED 是另一条启动。DDP 和 DeepSpeed 这一门不靠它。

2.2 三份训练 yaml 里相同的字段

底稿用机器上跑通的 DDP 文件 llama3_lora_sft.yaml。DeepSpeed 和 FSDP 的训练 yaml 沿用这些字段,只改 2.3 和 2.4 里点名的几行。原文在 4.3。

三份里对不上的取值:

字段DDPDeepSpeedFSDP
datasetidentity,alpaca_zh_demoidentity,alpaca_en_demoidentity,alpaca_en_demo
max_samples100101000
gradient_accumulation_steps828
num_train_epochs3.01.03.0
logging_steps / save_steps5 / 55 / 510 / 500
引擎无 deepspeed:deepspeed: 指向 ds_z3_config.jsonquantization_bit: 4,另配 fsdp_config.yaml
# 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 目录

2.3 DeepSpeed

训练 yaml 在 2.2 的底稿上加一行,取值按上面那张表改。多卡命令是 FORCE_TORCHRUN=1 llamafactory-cli train 这份。原文在 9.5。

# * 有这一行就是 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]

切到哪一档不在训练 yaml 里,在它指向的 json。要跑就用仓库里的 ds_z3_config.json。带 * 的只有 stage。这里只摘了 zero_optimization,前半段的 batch 和 bf16.enabled 都是 "auto",启动时用训练 yaml 填。全文在 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 位权重凑成完整一份
}

2.4 FSDP

训练 yaml 同样沿用 2.2,按表改样本数和存盘步数,并多一行 4 比特。不要加 deepspeed:,加了就变成 DeepSpeed。不用 GPTQ、AWQ。原文在 10.7。

quantization_bit: 4                     # * 底模按 4 比特放,训练的仍是 LoRA

切分和精度在 fsdp_config.yaml,不在训练 yaml。下面是机器上打开的那份:1 台机器、2 个进程,和脚本里的两张卡一致。说明里那份同名文件是 fsdp_offload_params: true、mixed_precision: fp16,不要和这一份合成。

两个 rank 挤在同一张卡时,把 num_processes 改成 1。参数写回时形状对不上,把 fsdp_offload_params 改成 true,参数改放到 CPU,训练会变慢。两则报错在 10.8。

# 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
  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                   # * 和训练 yaml 的 bf16: true 一致。说明里那份写成 fp16
num_machines: 1                         # * 机器数
num_processes: 2                        # * 进程数,等于实际使用的 GPU 总数。挤在同一张卡时改成 1
rdzv_backend: static                    # 进程会合方式,示例是 static
same_network: true                      # 这些卡在同一网络
tpu_env: []                             # 下面三项是 TPU。这次用 GPU,保持关闭
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false                          # 用 GPU

大模型微调36-量化与多卡 复习巩固总结

1. 微调原理

微调拿已经训好的权重,在自己的数据上继续训,小幅改参数,让它适应该任务。从头训一个新模型是另一件事。见 为什么要微调 和 微调的过程。

一次更新做三件事:前向算出输出,反向给要改的数一份梯度,优化器按这份梯度改这些数,并给每个正在改的数再存一份状态。显存跟着「谁在被改、状态跟着谁」涨。下面几种方法差在这两处。展开在 DAY1 第 3 节 和 第 4 节。

1.1 全量

全量微调每个参数都更新,直到模型能做这次的任务。灵活性高,任务上的效果也更好。数据量少,或者任务和预训练差得大,会过拟合,也会把预训练里的知识盖掉:新数据上的能力上去,代码、翻译、function calling 掉下去。

8B 这一笔账是权重、梯度、fp32 主权重和 Adam 的两份动量,大约 128GB。实测占 273G,一步 14.2 秒,多出来的是激活。见 三次实测。

1.2 冻结

Freeze 冻住一部分参数,只更新另一部分。通常冻住底层,只更新高层,Transformer 里一般只开放 FC。训得快,底层的预训练留得住,也能防过拟合。同一个 backbone 可以接多个头,换任务就换头。

例子是把 layers.23 到 layers.27 留着更新,这五个名字之外的参数 requires_grad 设成 False。代码在 3.2。

1.3 冻住底模,只加一小块

PEFT 冻住大部分预训练参数,只训少量或新加的参数,好在消费级显卡上把效果拉近全量。手写提示、情景学习不更新参数,不在这一类里。三类常见做法是前缀、层里的小模块、低秩旁路。见 PEFT。

方法加在哪训完的代价
AdapterTransformer 层里插入小模块:先降维,再升回原维度,加上残差。原层冻住推理要多走这几层,延迟增加
Prefix-Tuning输入前面加一段可训练前缀。翻译、摘要各换自己的前缀,底下共用一份 Transformer前缀占掉一段序列长度,这段也难训
Prompt Tuning底模冻住,反向传播只更新 prompt。换 prompt 就换任务只拧输入层,是 Prefix 的瘦身版
P-tuning任务名先进 Prompt Encoder,用 MLP 加 LSTM 得到一组可学习的 Embedding,和词嵌入交错后送进模型效果通常不及全量

更早的 BERT 分类用 PET:人工模板加标签词,把分类收成完形填空。见 BERT-PET。Adapter、Prefix、P-tuning 的展开在 Adapter、Prefix、P-Tuning。这几种往往做不到又快又好。

1.4 LoRA

LoRA 把权重的改变量写成低秩旁路,底模冻住。前向是 (h = Wx + BAx)。(A) 从正态分布里抽,(B) 初始化成 0,训练开始时旁路是 0。秩 (r) 比宽度小得多,梯度和优化器状态只有 (A)、(B) 这么大。训完可以把 (BA) 加回 (W),推理又变回一层线性,不再多一层延迟。见 LoRA 的思想。

这一页把旁路放在 (W_q)、(W_k)、(W_v)、(W_o) 上。秩通常 4 或 8,复杂任务、大数据集用 16。lora_alpha 一般 16–32。Dropout 这一页常见 0.2–0.3。百川脚本用的是秩 8、alpha 16、dropout 0.05。学习率取 1e-4 到 5e-4。

工厂里 finetuning_type: lora。实测占 20G,一步 2.3 秒。

1.5 QLoRA

QLoRA 是量化和 LoRA 合在一起。前向仍是 (h = Wx + BAx),改的仍是 (A)、(B)。底模按 4 比特放着,要算的时候解开成 16 比特,算完丢掉。论文是 QLoRA,四件事见 QLoRA 方法。

  • NF4。4 比特一共 16 个格子,按正态分布来排:0 附近更密。权重大多挤在 0 附近,四舍五入的误差更小。好于普通 4 比特浮点。
  • 双重量化。一块权重共用的缩放系数再量化一次。权重还是 NF4,省的是这批系数。精度抬得不多。
  • 分页优化器。显存尖峰时,优化器状态整页卸到 CPU,要更新再载回。百川脚本把优化器写成 adamw_torch,工厂训练 yaml 也没有这一项。
  • 线性层都插 adapter。LoRA 常见只插 query、value。QLoRA 插到除 lm_head 以外的全部线性层,用更多可训练参数补量化掉的精度。

实验里,底模收到 8 比特或 4 比特、只训 adapter,也能回到 16 比特全量附近。学习率略低,取 5e-5 到 2e-4。工厂是 LoRA 的 yaml 多一行 quantization_bit: 4,存下来的仍是 adapter。实测占 10G,一步 3.2 秒。比 LoRA 慢,是因为每步要把 4 比特解开再算。

1.6 GaLore

GaLore 仍更新模型自己的参数。前向还是 (h = Wx)。梯度按全部参数算出来,再投到低维空间,优化器只为这份低维梯度存状态,然后写回整个 (W)。每隔 update_proj_gap 步重做投影,论文里常用 200 步。投影用奇异值分解,只留最重要的前 (K) 个方向,图上 (K = 100)。

finetuning_type 写成 full,并打开 pure_bf16。bf16: true 仍会留一份 fp32 主权重;pure_bf16 打开后,更新直接落在 bf16 上。LoRA 那条配置冻住 (W),和这里要改的对象不一样,两套配置各开各的。参数和分解见 4.1。

1.7 BAdam

BAdam 仍是 Adam,更新按块轮流。参数分成 (D) 个块。前向里所有块都参加 (h = Wx)。反向只给当前活跃块算梯度,两份动量也只留给这块。一个块周期默认 50 步,然后换下一块,旧块的动量丢掉。

默认按连续的层切。损失从后往前传,传到当前活跃层就可以停。论文里 Llama 3-8B、一张 RTX 3090、Alpaca-GPT4:一轮大约 2.5 小时,同设置的 LoRA 大约 4.1 小时。显存上 LoRA 秩 8 是 22.3GB,BAdam 是 23.5GB。附加测试一步 1.5 秒、20G。这组和上面 273G / 20G / 10G 的实测是两次测量,不能相乘。

16 比特底模要放在卡上。同样写成 finetuning_type: full 和 pure_bf16: True。训完留下的是整份 (W)。切块参数见 4.2。

1.8 怎么选

谁在更新底模怎么放这一门的显存和一步时间训完留下什么时候用
全量每步所有参数一起改16 比特,另留 fp32 主权重273G,14.2 秒整份权重预训练、增量训练
冻结只改留下的高层其余层冻住这一门没有这组实测改过的那些层要留住底层,只让高层适应任务
LoRA只改 (A)、(B)16 比特,冻住20G,2.3 秒adapter,可挂回同一份底模卡放得下 16 比特底模,还要换任务
QLoRA只改 (A)、(B)4 比特,算的时候解开成 16 比特10G,3.2 秒adapter卡不够,或模型更大
GaLore每步都改 (W),优化器只看低维梯度16 比特,pure_bf16这一门没有单独的秒数整份权重要全参数更新,又要把优化器状态压小
BAdam一个时刻只改一块,轮完是整份 (W)16 比特,pure_bf16附加测试 20G、1.5 秒。论文一轮约 2.5 小时整份权重16 比特底模放得下,块按连续的层切

卡放得下 16 比特底模、还要换任务,用 LoRA。卡不够或模型更大,用 QLoRA。要改的是权重本身、又愿意存一整份权重,再在 GaLore 和 BAdam 里选。对照和两组时间的出处在 4.3 第 6 问。

2. 大模型加速技术

这四件改的不是同一段。外面决定几张卡、参数怎么切,是 Accelerate。里面注意力怎么算,是 FlashAttention。其余算子怎么融合,是 Liger Kernel。单卡微调的整段循环由谁重写,是 Unsloth。同一次多卡训练可以外面用 Accelerate,每张卡里的注意力用 FlashAttention。原文在 DAY1 第 5 节。

2.1 FlashAttention

公式仍是原来的。(Q) 是 (N \times d),和 (K^{T}) 乘出 (N \times N) 的分数矩阵,softmax 之后再乘 (V)。标准做法把这块 (N \times N) 留在 HBM 里,显存随长度成平方涨。FlashAttention 之后实际占用更接近线性。计算量本身仍随长度成平方,见 DAY4 的第 7 问。

数据离计算核心越近越快。A100 上 SRAM 大约 19 TB/s、20 MB,HBM 大约 1.5 TB/s、40 GB,主存大约 12.8 GB/s、大于 1 TB。SRAM 装不下整块注意力矩阵。大矩阵留在 HBM,乘法和 softmax 拆成小块,一次只搬一块进 SRAM。

前向不存整块注意力矩阵,只留输出,再加两个很小的统计量:这一行的最大值,以及减去最大值之后的指数和。反向用这两个数在 SRAM 里把这块 softmax 重算出来。多算一次,换掉 (N \times N) 的存储。对现在的 GPU,计算通常比访问内存便宜。

三步收成一个内核。标准流程是两次矩阵乘中间夹一次 softmax,对应三次 HBM 读写。这里一块 (Q)、一块 (K) 和 (V) 一起载进 SRAM,算完分数、做 softmax、再乘 (V),中间结果不写回,只有输出块写回去。softmax 也不等整行到齐:每来一块就更新那两个统计量,结果和整行一起算相同。GPT-2 的计时图里,PyTorch 是 Matmul、Mask、Softmax、Dropout、Matmul 五段;FlashAttention 只剩一根融合内核。

ChatGLM2 训基座时用过它,上下文从 2K 提到 32K。这块矩阵的面积大约是原来的 256 倍,标准实现放不下。后面几次 LLaMA-Factory 的普通 LoRA demo 没有开 FlashAttention-2。见 5.5 第 1 问。

2.2 Unsloth

Unsloth 减的是单卡微调的时间和内存。计算量大的步骤用手写的 Triton 内核重做,卡不用换。这次重写的精度损失写成 0%,没有用近似去换速度。支持 4 位 QLoRA 和 16 位 LoRA。开源训练那一条写成快 5 倍。站点横幅是另一组:快 2 倍,显存少 80%。对照表写成速度 2–5 倍、显存少 70%–80%。三处按原文分开记。

工厂里开的是这件事,训练 yaml 加 use_unsloth: true,默认 false。quantization_bit: 4 时按 4 比特载入做 QLoRA,不写位数就是 16 比特 LoRA。加载走 FastLanguageModel。模型类型不支持时,这个开关会关掉,退回原来的加载。旁边 use_unsloth_gc 默认 false,开的是它自己的梯度检查点。要 NVIDIA GPU,CUDA 算力最低 7.0。8B 做 4 比特大约 6GB,16 比特大约 22GB,这是地板。

动态量化是另一件事:按层的重要程度分配不同位宽,校准做完就固定,推理时不随输入再改。对照的是 GPTQ。GPTQ 训完再压,所有层同一档位宽,盯的是这一层自己的量化误差。Unsloth 这一条看整句输出变了多少,敏感的层留在更高精度,产物是混合精度,体积略大于统一 4 比特,通常更接近原模型。工厂的 use_unsloth: true 不跑这一步,也不会写出这份混合精度模型。导出仍走 GPTQ、AWQ、AQLM。基座训练也不用它:基座是全参数、上千张卡,用的加速是 FlashAttention 这一类。见 5.2 和 5.5。

2.3 Liger Kernel

对照表里这一列写成 tiger_kernel。三件事:按不同架构自己选计算路径;把多个算子收成一次,少访问内存,对象不限于注意力;用 JIT 按这次输入调整计算图。场景写成边缘设备推理和实时服务。

工厂训练配置里另有 enable_liger_kernel,默认 false,和 use_unsloth 写在同一份配置里。说明里的定位是推理,这个开关出现在训练配置里。两处按各自的写法留下。

2.4 Accelerate

Accelerate 把 FSDP 和 DeepSpeed 收成一个启动接口。两套切分仍是两套代码,共用的是 ZeRO 的切法。换引擎时改配置,启动命令还是 accelerate launch。FSDP 这一门就是这么拉起来的,见训练参数里的 FSDP。

2.5 四列对照

Liger KernelFlashAttention-2UnslothAccelerate
改哪一段其余算子的融合和 JIT。说明里定位是推理只换注意力这一个算子单卡微调的整段循环,Triton 重写内核进程和切分
核心目标推理效率注意力加速速度 2–5 倍分布式训练收成一个接口
内存静态预分配分块,SRAM 里复用显存少 70%–80%自动分配
硬件CPU / GPUGPU 优先GPU,消费级单卡多 GPU / TPU
场景边缘设备推理训练和推理单卡微调、推理多机多卡

四列没有统一的加速倍数,只有 Unsloth 写了 2–5 倍。拿来当速度排名对不上。能并排,是因为每列回答的问题不同。

3. 量化

3.1 核心原理

把浮点权重收成整数再存。整数格子是固定的,浮点范围怎么对齐这些格子,由 scale 和 zero_point 决定。小标题写成 scalar,公式里写的是 scale,是同一个量。原文在 DAY1 第 6 节。

对称量化要求范围关于 0 对称,zero_point 就是 0。非对称按真实的最小、最大来摆,整个整数区间都用来表示有数的那段,一格更小。代价是浮点 0 不再对准整数 0,要另记 zero_point。

真实数值落在 -3 到 10.2,整数从 -127 到 128,间隔数是 255。对称把左端拉到 -10.2,范围变成 20.4。-10.2 到 -3 没有原始数值,仍占一截格子。

[ scale = \frac{10.2 - (-10.2)}{255} = 0.08 ]

非对称就用真实的 13.2,整数改成 UINT8 的 0 到 255:

[ scale = \frac{10.2 - (-3)}{255} \approx 0.0518, \qquad zero_point = round(3 / 0.0518) = 58 ]

整数 58 才是浮点 0,整数 0 表示左端 -3。同一段真实数值,步长从 0.08 收到约 0.0518。

一般式是

[ scale = \frac{r_max - r_min}{q_max - q_min}, \qquad zero_point = round(-r_min / scale) + q_min ]

(q_min) 为 0 时,zero_point 就是 (round(-r_min / scale))。对称时这个值是 0。

量化再反量化:

[ q = clamp!\big(round(r / scale) + zero_point,\ q_min,\ q_max\big), \qquad r' = scale \times (q - zero_point) ]

存下来的是整数 (q)。同一个 (q) 盖住的所有原始浮点,还原时都变成这一个 (r')。对称例子里 scale 是 0.08、zero_point 是 0:0.03 收到整数 0,还原成 0;0.05 收到 1,还原成 0.08。出界的数被 clamp 按到端点,偏差可以大于半个步长。(r' - r) 就是权重误差 (\delta)。

混合精度的 float2half 是每个数自己换浮点格式,丢掉的是它自己的尾数位,不看整段的最小最大,也不算 scale。这里存下来的是整数,要用 scale 和 zero_point 才能还原。

Factory 训练打开的 4 比特常用 NF4:仍是 16 个格子,按正态分布排,0 附近密、两头稀,不是上面每格差一个 scale 的等距。yaml 只写 quantization_bit 和 quantization_method。导出的 GPTQ、AWQ、AQLM 不写 quantization_bit,一层仍是同一档位宽,看的是这一层输出差多少。收成低位数、计算前再还原,这一步不变。见 6.4。

3.2 PTQ

训练完成后,再把已经训好的浮点权重量化,让量化前后的分布仍然接近。FP32 映射到 INT8 或 INT4。BitAndBytes、GPTQ、HQQ 都在这一类里。原文在 DAY1 第 7 节。

五步:定 INT8 或 INT4;按 3.1 算 scale 和 zero point;用这两个数量化权重;用少量校准数据统计激活的分布,给激活定范围;计算时先走整数,再反量化成浮点。

权重按自己的最小、最大来定范围。除数是 255,结果转成 int8:

import numpy as np
weights = np.random.rand(3, 3)
a = np.min(weights)          # r_min
b = np.max(weights)          # r_max
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

GPTQ 要让一层量化之后,这一层输出上的误差最小:

[ \min_{\hat{W}} | W X - \hat{W} X |_2^2 ]

(W) 是原来的浮点权重,形状是 out_features × in_features。(\hat{W}) 是量化后的权重。(X) 是一小部分校准数据进到这一层时的激活。权重分成组,按列量化。当前列收成整数之后,产生的误差按 Hessian 逆矩阵的比例补到后面还没量化的列,再量化下一列。

例子把

[ W = \begin{bmatrix} 2.3 & 5.7 \ 1.9 & 4.1 \end{bmatrix} ]

收成 INT4。这一组手选 scale (= 0.5)、zero point (= -5),是为了让取整边界跨得过去,不是这四个权重算出来的。补偿用的逆矩阵也是手设的,对角 2、非对角 4:

[ \mathrm{err} = \frac{r - r'}{2}, \qquad W_{\mathrm{col2}} \leftarrow W_{\mathrm{col2}} - \mathrm{err} \times 4 ]

反馈用的误差是 (r - r')。(q) 只是格子编号。第一列 (2.3) 收到 (q = 0),还原 (2.5),误差 (-0.2),第二列的 (5.7) 变成 (6.1)。(1.9) 收到 (q = -1),还原 (2.0),误差 (-0.1),(4.1) 变成 (4.3)。再量化第二列:(6.1) 收到 (7),还原 (6.0);(4.3) 收到 (4),还原 (4.5)。若不先补偿,(5.7) 和 (4.1) 会收到 (6) 和 (3),还原成 (5.5) 和 (4.0)。

存下来的是

[ 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)。scale 是 0.5,所以 (r') 落在半格上。scale 取 1、zero point 取 0 时,(r') 才和 (q) 是同一个数。

Hessian 来自校准激活,不来自权重。一层的损失对权重展开,二次项是 (H = 2XX^{\mathsf T})。(X) 的每一列是一个 token 进到这一层时的激活。同一层每一行输出共用这一张 (H)。对角是这一列自己有多响,非对角是两个输入通道经常一起大。补偿时用的是 (H^{-1}):误差先除以这一列自己的曲率,再按非对角的比例加到后面的列。例子里的 (\begin{bmatrix} 2 & 4 \ 4 & 9 \end{bmatrix}) 不是算出来的。校准 token 不够、或两列激活几乎成比例时,(H) 不可逆,对角上会加上平均对角的一小截,常见是 (1%),然后再做 Cholesky 求逆。工厂导出不写这张矩阵,校准句子在 export_quantization_dataset: data/c4_demo.json。

scale 和 zero point 看的是权重组的最小、最大。常见 128 列共用一对,4 比特从 0 到 15,一共 15 个间隔:

[ scale = \frac{b - a}{15}, \qquad zero_point = round(-a / scale) ]

把上面那张矩阵当成一组,(a = 1.9),(b = 5.7),scale 约 (0.2533),zero point 是 (-8)。和例子里手选的 (0.5)、(-5) 不是同一对。校准句子参加的是 (H),不参加权重组的这两个数。激活自己的量化范围才用校准数据的分布来定,那是五步里的第 4 步。见 7.3 和 7.5。

2026.11.16 13:14:03

大模型微调36-量化与多卡 学习

8. QAT量化算法原理介绍

QAT(Quantization Aware Training,量化感知训练)在微调时就把取整放进前向。权重还在更新,学的是适应这种取整。训完去掉模拟用的模块,换成真正的 int8 算子再导出。PTQ 是权重已经训完,只决定每个数落进哪个格子,见 3.2。

四步:

  1. 模拟量化。把 round 的误差当成 FP32 训练时的噪声。微调时模型适应这种噪声,最后收成 INT8 时精度掉得少。
  2. 梯度近似。量化不可微,用直通估计(STE)近似梯度。
  3. 参数优化。前向走模拟量化,反向走这份近似梯度,把参数更新成能适应量化后的表示。
  4. 转换与部署。去掉伪量化模块,换成低精度算子(int8 卷积),导出量化模型。

两张图对着同一次卷积。第一个是部署之后的推理,全程整数。第二个是训练,权重和激活各多一个伪量化节点。

推理,只做整数运算:

flowchart TD
  in8["input\nuint8"] --> conv["conv"]
  w8["weights\nuint8"] --> conv
  conv -->|uint32| add["+"]
  b32["biases\nuint32"] --> add
  add -->|uint8| relu["ReLU6"]
  relu -->|uint8| out8["output"]

训练,伪量化:

flowchart TD
  w["weights"] --> wt["wt quant"]
  wt --> conv2["conv"]
  in2["input"] --> conv2
  conv2 --> add2["+"]
  b2["biases"] --> add2
  add2 --> relu2["ReLU6"]
  relu2 --> act["act quant"]
  act --> out2["output"]

第一张 conv 的结果和 biases 都是 uint32,相加之后收成 uint8 再进 ReLU6。第二张 wt quant、act quant 就是前向里的 round 和 clamp,算的仍是浮点。

前向仍用浮点算,数值已经是量化之后的数,所以叫伪量化:

[ W_{\mathrm{fake}} = \mathrm{clamp}(\mathrm{round}(W / s)) \times s ]

没有量化时 (y = F(x, W_{fp32}))。加入 QAT 后

[ y_{qat} = F(x, Q(W_{fp32})) ]

(Q(W_{fp32})) 就是上面的伪权重。计算用的是浮点数,数值是量化后的值。损失是 (\mathcal{L} = \mathrm{Loss}(y_{qat}, y_{true}))。

(s) 是步长。zero_point 为 0 时,这就是 3.1 里先 round 再乘回 scale:得到的仍是浮点 (r'),不是存盘用的整数 (q)。

反向用 STE。舍入和截断的导数丢掉,把 (\partial L / \partial W_{\mathrm{fake}}) 原样传给 (W):

[ \frac{\partial L}{\partial W} = \frac{\partial L}{\partial W_{\mathrm{fake}}} ]

这是近似。写成对量化函数的假设:

[ \frac{\partial Q(W_{fp32})}{\partial W_{fp32}} \approx \mathbf{I} ]

代进链式法则:

[ \frac{\partial \mathcal{L}}{\partial W_{fp32}} \approx \frac{\partial \mathcal{L}}{\partial Q(W_{fp32})} \cdot \mathbf{I} = \frac{\partial \mathcal{L}}{\partial Q(W_{fp32})} ]

也就是

[ \frac{\partial \mathcal{L}}{\partial W_{fp32}} \stackrel{\mathrm{STE}}{=} \frac{\partial \mathcal{L}}{\partial Q(W_{fp32})} ]

拓展QA:

1. 为什么量化不可微?

伪量化是一段楼梯。在两格中间的一整段里,round 的输出是同一个数,导数是 0。跨过取整边界时,输出一下子跳到下一格,这一处没有斜率,导数不存在。clamp 出了整数范围之后钉在端点上,那段的导数也是 0。

用 3.1 里 scale 为 0.08、zero_point 为 0 的例子。(W_{\mathrm{fake}} = s \times \mathrm{round}(W / s))。

(W)(W / 0.08)round 之后(W_{\mathrm{fake}})
0.030.37500
0.0390.487500
0.050.62510.08

0.03 和 0.039 落在同一格,把 (W) 挪一点,(W_{\mathrm{fake}}) 不动。反向要的 (\partial W_{\mathrm{fake}} / \partial W) 在这一段是 0,损失对 (W) 的梯度也是 0,权重得不到更新。0.04 是 (0.5 \times 0.08),正好在两格中间,输出从 0 跳到 0.08,这里写不出一个导数。

STE 就是绕过这段。前向仍用取整后的 (W_{\mathrm{fake}}) 算损失,反向把 (\partial Q / \partial W) 当成单位矩阵,梯度原样传回 (W)。权重还能动,损失看到的仍是量化之后的数。

2. 为什么 STE 能把导数假设成单位矩阵?

这个式子不是算出来的。第 1 问里,格子内部的导数是 0,边界上写不出导数。单位矩阵是换上去的。

前向的 (Q) 是楼梯:(W_{\mathrm{fake}} = s \times \mathrm{round}(W / s))。它和 (W) 的差不超过半个步长。scale 为 0.08 时,0.03 被收成 0,差 0.03;0.05 被收成 0.08,差 0.03。作为函数,(Q(W)) 贴着 (W) 走,像恒等映射 (Q(W) \approx W)。恒等映射对 (W) 的导数才是单位矩阵。

STE 把前向和反向拆开。前向仍走楼梯,损失看到的是取整后的数。反向不走楼梯的导数,那段几乎全是 0,权重会停住。反向改走 (Q) 所贴近的那条恒等映射的导数,也就是 (\mathbf{I})。链式法则就变成:损失对 (W_{\mathrm{fake}}) 的梯度,原样抄给 (W)。

格子内部 (W) 挪一点,(W_{\mathrm{fake}}) 其实不动,STE 仍按「挪了多少、伪权重也挪多少」来更新。多走几步,(W) 会跨过格子边界,前向的损失继续按量化后的数推它。

3. 已经训好的模型怎么做 QAT?

拿已经训好的浮点模型,插上伪量化,再按原来的损失微调一小段,最后把伪量化模块换成 int8 算子。权重在这小段里仍会更新。只在冻结的成品上做一次 round,那是 3.2,不是 QAT。

下面是图上这种卷积网络的关键几步。prepare_qat 在 conv、ReLU 上插入伪量化,前向就是 (W_{\mathrm{fake}})。微调照常反向传播。convert 去掉伪量化,换成 int8 卷积。

import torch
from torch.ao.quantization import convert, get_default_qat_qconfig, prepare_qat

model.load_state_dict(torch.load("fp32.pt"))
model.train()
model.qconfig = get_default_qat_qconfig("fbgemm")  # x86 用 fbgemm,ARM 用 qnnpack
prepare_qat(model, inplace=True)

for x, y in loader:          # 还要标签,损失和原来的微调相同
    optimizer.zero_grad()
    loss = criterion(model(x), y)
    loss.backward()          # 反向走 STE
    optimizer.step()

model.eval()
convert(model, inplace=True)  # 去掉伪量化,换成 int8 算子
torch.save(model.state_dict(), "int8.pt")

卷积后面紧挨着 BN、ReLU 时,要先把这几层融合成一层,再 prepare_qat。图上只有 conv 和 ReLU6。这段接口包的是卷积网络。这一门的 Transformer 不走 prepare_qat。

4. LLaMA-Factory 里怎么开 QAT?

开不了。第 8 节这种 QAT(前向插伪量化、权重按 STE 更新、再 convert 成 int8)工厂没有对应字段。作者说明过:全量训练不支持 QAT,只支持混合精度。文档里出现 QAT 这个词,讲的是概念,参数表里的 quantization_method 只有 bitsandbytes、hqq、eetq。

效果更好,换来的是再做一段会更新权重的微调。QAT 的前向虽然走伪量化,优化器改的仍是浮点权重,显存靠近全量微调。8B 全量实测占 273G。工厂这条路是把底模冻住、只训 LoRA,或者训完再用一小份校准集做 GPTQ。图上的 prepare_qat 包的是卷积网络,不接到 Llama 的 Transformer 上。

训练 yaml 里能开的量化是 QLoRA:底模按 4 比特放着并且冻住,只训 LoRA,权重不会去适应取整。接着再做 GPTQ,也不是 QAT 的替代。合并要回到未量化的底模,GPTQ 再对这份浮点权重做一次取整。底模没有在伪量化的前向里被损失更新过。

finetuning_type: lora
quantization_bit: 4
quantization_method: bitsandbytes

训完要一份低精度的完整模型,走导出,那是 PTQ。校准集没有标签。

model_name_or_path: models/llama3_lora_sft
export_quantization_bit: 4
export_quantization_dataset: data/c4_demo.json
export_dir: models/llama3_gptq

命令是 llamafactory-cli export 这份 yaml。见 GPTQ 导出。

5. QAT 和 PTQ 的效果一样吗?和原来的模型比,数据有什么不同?

效果不一样。三份模型推理时吃的是同一种输入。差别在做出量化权重的那一步要什么数据,以及权重还动不动。

原来的浮点模型PTQQAT
权重训练结束时的浮点,不再改训完后收成整数。GPTQ 用 (H^{-1}) 把误差补到后面的列,权重不按损失更新先插伪量化再微调。权重会挪,去适应取整,最后换成 int8
做这一步要的数据训练时要带标签的训练集。推理只要当时的输入一小份无标签校准集,例如 c4_demo.json。用来定激活的范围,GPTQ 还用它算 (H)。不按损失更新权重带标签的数据,损失仍是 (\mathrm{Loss}(y_{qat}, y_{true}))。没有规定必须把原来的全部数据再过一遍
推理时的输入同一条样本同一条样本同一条样本
和浮点模型比基准取整误差留在已经训完的权重上,精度掉得更多权重适应过这种噪声,最后收成 INT8 时更靠近原来的模型。代价是再做一段带标签的微调

所以对数据的要求确实不同,指的是制作量化模型时。PTQ 不训练,只拿一小份无标签校准集看激活。QAT 还在算损失、更新权重,所以要带标签的数据。没有规定条数和 epoch,也没有要求把原来的全量微调数据再完整过一遍。部署之后,输入和原来的模型是同一套。

效果上 QAT 更好,量化之后更靠近原来的浮点模型。PTQ 的取整误差留在已经训完的权重上,精度掉得更多。代价是 QAT 要再做一段带标签的微调,PTQ 只要那一小份校准集。LLaMA-Factory 做不了 QAT,训完能走的是 GPTQ 这种 PTQ。

9. AWQ量化算法原理介绍

AWQ(Activation-aware Weight Quantization,激活感知权重量化)发生在权重已经训完之后,不再按损失更新权重。一小部分权重特别重要,为了保住性能,这些权重尽可能少被量化。做法是按通道分组,每组一个缩放因子;量化前先缩放,把较大激活所对应的权重放大,减小量化误差。不需要训练,校准集比训练数据小。说明里写它在指令微调和多模态模型上表现好。

OPT-6.7B、INT3、分组 128 的困惑度:

做法PPL
(a)直接四舍五入(RTN)。FP16 权重量化成 INT343.2
(b)按激活找出显著权重,把其中 1% 留在 FP16,其余量化。混精,硬件效率差13.0
(c)AWQ。量化前按通道缩放,再全部量化成 INT3。显著权重靠放大来保护,不必留一份 FP1613.0

(b) 和 (c) 的困惑度都是 13.0。(b) 要在推理时混着两种精度,(c) 量化之后仍是统一的低精度。

9.1 三步

1. 用激活找保护系数。 准备一小份校准集,说明里写通常从训练集里抽。把这些数据送进模型,收集每一层输入激活 (X) 的统计,用的是绝对值。权重 (W) 的形状是 [out_channels, in_channels]。每个通道一个 (s_i):

[ s_i = \frac{1}{|X|}\sum_{x \in X} |x \cdot W_i| ]

也可以不乘权重,直接对输入通道做平均:

[ s_i = \frac{1}{N}\sum_{j=1}^{N}|X_{ij}| ]

(N) 在这一式里写成输入通道数。然后按 (s_i) 给通道排序,(s_i) 越大越靠前。

2. 按保护系数缩放权重。 这一步是 AWQ 的核心。每个通道一个缩放系数

[ f_i = (s_i)^{\alpha} ]

(s_i) 先归一化。重要通道的 (f_i) 大于 1:量化前先放大,量化后再缩回去,相当于这一通道的格子更细。(\alpha) 控制保护强度,通常小于 1,例子是 0.5。(\alpha = 0) 时 (f_i) 全是 1,退回 RTN。

把 (f_i) 放上对角矩阵 (S),权重改成

[ W' = S^{-1} W S ]

(S^{-1} W) 按输出通道缩小,再右乘 (S) 按输入通道放大。

3. 量化缩放后的权重,推理时把缩放乘回去。 (W') 按普通的逐张量或逐通道四舍五入:

[ \hat{W}' = Q(W') ]

推理时用的是量化后的 (\hat{W})。要得到和缩放前等价的输出,得把缩放逆回去:

[ Y = X \hat{W} \approx X ,(S \hat{W}' S^{-1}) ]

9.2 一个数的例子

两条权重,激活大的放大,激活小的缩小。后面三列是四舍五入、反量化、再除回缩放系数。

原权重激活怎么处理放大或缩小后四舍五入反量化除回缩放
1.80.8重要,缩放系数大于 12.532.41.82
0.20.15不重要,缩放系数小于 10.100.080.1

前向是 (X) 乘权重。1.82 乘上 0.8,比 0.15 乘上 0.1 更接近原来的那一项。相对误差是

[ \frac{|\text{量化后权重} - \text{量化前权重}|}{|\text{量化前权重}|} ]

绝对差差不多时,量化前的权重越大,相对误差越小,损失的精度越小。所以重要通道先放大再量化。

9.3 和 PTQ 与 QAT 怎么分

三份都从 FP16 或 FP32 的预训练模型出发。

flowchart TD
  base["预训练模型\nFP16 / FP32"] --> pick["选择量化方法"]
  pick --> ptq["PTQ\n训完直接量化"]
  pick --> qat["QAT\n插入伪量化再微调"]
  pick --> awq["AWQ\n用激活找重要权重"]
  ptq --> ptq2["直接得到量化模型\n损耗高,性能掉得明显"]
  qat --> qat2["权重适应量化误差"]
  qat2 --> qat3["高精度量化模型\n要数据和训练"]
  awq --> awq2["搜索缩放系数"]
  awq2 --> awq3["先缩放,再量化"]
  awq3 --> awq4["高性能量化模型\n不训练"]

AWQ 仍是训完再量化,权重不按损失更新,这一点和 3.2 的 PTQ 相同。它多出来的是量化前按激活把重要通道放大。QAT 则要插入伪量化再训练,见第 8 节。

9.4 拓展QA

1. 手动做 AWQ,核心代码是什么?

写在训练结束之后。拿已经训好的浮点权重,配一小份无标签校准集,做完 9.1 的三步就得到量化权重。这段只做前向统计和取整。

import torch

@torch.no_grad()
def awq_quantize(W, X, alpha=0.5, bits=3):
    """W: [out, in],X: [样本数, in]。"""
    # 1. 每个输入通道一个 s:校准样本上该通道 |X| 的平均。用的是 9.1 不乘权重的那条
    s = X.abs().mean(dim=0)
    s = s / s.mean()                          # 先归一化
    f = s.clamp_min(1e-6).pow(alpha)         # alpha=0 时全是 1,退回直接四舍五入

    # 2. 按输入通道放大。页上写成 W' = S^{-1} W S:
    #    右乘 S 放大输入通道,左乘 S^{-1} 缩小输出通道。
    #    s 来自输入激活,这里能直接算的是右乘这一侧
    W_scaled = W * f.unsqueeze(0)

    # 3. 每个输出通道按 3.1 四舍五入。INT3 的整数范围按 INT4 那个例子来排:-4 到 3
    qmin, qmax = -(1 << (bits - 1)), (1 << (bits - 1)) - 1
    rmin = W_scaled.amin(dim=1, keepdim=True)
    rmax = W_scaled.amax(dim=1, keepdim=True)
    scale = (rmax - rmin) / (qmax - qmin)
    scale = scale.clamp_min(1e-8)             # 这一通道是常数时,scale 会算成 0
    zp = torch.round(-rmin / scale) + qmin
    q = torch.round(W_scaled / scale + zp).clamp(qmin, qmax)

    # 反量化后按输入通道除回 f,对应 9.2 最后一列
    W_hat = (scale * (q - zp)) / f.unsqueeze(0)
    return q, scale, zp, f, W_hat

页上左乘和右乘写的是同一个 (S)。线性层一般输出通道数和输入通道数不同,同一个 (S) 乘不到两侧。校准得到的 (s_i) 按输入通道,放大落在右乘;推理时再按输入通道除回去。

图上 OPT-6.7B 那一行是 INT3、每 128 列共用一对 scale。上面是 9.1 写的逐通道,每个输出通道一对。要按那张图分组,就把同一通道里的 128 列再切开,最小、最大改在这一组上算,公式仍是 3.1。

(\alpha) 的例子是 0.5。9.3 的图写「搜索最优的缩放系数」。步骤给出的是 (f_i = (s_i)^{\alpha}),没有列出要试的那一组 (\alpha)。9.1 还有一条 (s_i) 要乘上 (W_i),上面用的是不乘权重的那条。

上面是一层线性的公式。实际压一个因果语言模型,用 AutoAWQ,流程和 第 8 节的 QAT 代码 不同。QAT 那段是 torch.ao.quantization:prepare_qat、带标签的反向、再 convert 成 int8,包的是卷积网络。这个包不做 AWQ。AutoAWQ 是载入浮点模型、quantize、存盘,中间没有损失,也没有 optimizer.step。

README 里的三步。model_path 用和 GPTQ 导出同一份未量化权重;要压合并结果时,改成那次的 export_dir。

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "meta-llama/Meta-Llama-3-8B-Instruct"
quant_path = "models/llama3_awq"
quant_config = {"zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM"}

model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)

安装是 pip install autoawq。quantize 自己跑校准集,默认 calib_data="pileval",最多 128 条,序列长 512。换成自己的文本时,把 calib_data 设成字符串列表。默认 duo_scaling=True,缩放同时看权重和激活,对应 9.1 的两条 (s_i)。q_group_size: 128 就是图上 128 列一组。w_bit 的例子是 4,和工厂那份 AWQ 模型卡一致;写成 3 才是图上的 INT3,文档说有的位数没有现成的推理内核。README 写 7B 大约 10 到 15 分钟,70B 大约 1 小时。这个库已经停止维护,最后测过的组合是 Torch 2.6.0、Transformers 4.51.3。

这段在工厂外面跑。存下来的 quant_path 可以填进第 2 问的 model_name_or_path。工厂的 extra awq 用来加载这份结果,不调用这里的 quantize。

2. LLaMA-Factory 里怎么用 AWQ?

导出时选不了 AWQ。仓库把「完整模型再压一版」写成 GPTQ,示例是 examples/merge_lora/llama3_gptq.yaml,字段是 export_quantization_bit 和 export_quantization_dataset。AWQ 没有这一份。训练时当场量化的 quantization_method 只有 bnb、hqq、eetq,里面也没有 awq。

工厂里的 AWQ 就是直接用已经压好的底模,再在上面训 LoRA。示例是 examples/train_qlora/llama3_lora_sft_awq.yaml。相对普通 LoRA 只换底模路径,不写 quantization_bit。模型卡上已经是 4 比特。

model_name_or_path: TechxGenus/Meta-Llama-3-8B-Instruct-AWQ

浮点仓库是 meta-llama/Meta-Llama-3-8B-Instruct。上面这份 AWQ 是另一个仓库,模型卡上已经是 4 比特。GPTQ 的例子同样是 TechxGenus 的另一个仓库,TechxGenus/Meta-Llama-3-8B-Instruct-GPTQ。笔记里没有写每个模型都会附带一份 AWQ。没有现成仓库时,用上一问自己压,把 quant_path 填到这里。

上一问那段也不跑、又没有现成 AWQ 仓库时,工厂里到不了 AWQ。仓库没有一份 yaml 能把浮点模型压成 AWQ,也没有字段可以选。工厂能单独走完的低精度是另外两条,算法不同:训练时 quantization_method 用 bnb、hqq 或 eetq;训完要一份低精度完整模型,用上面的 GPTQ 导出。这两条都不做 9.1 的按激活缩放。

命令是 llamafactory-cli train 加这份 yaml。加载要另装 extra awq,见 额外依赖。写出的仍是 saves/ 里的 adapter。

这份 adapter 要并进底模时,底模换回未量化的权重。要带微调结果的低精度完整模型,先合并,再跑上面的 GPTQ。见 6.3 第 4 问。

FSDP 加 QLoRA 不用这种已经压好的 AWQ 模型,见 2.4。

10. HQQ量化原理介绍

HQQ(Half-Quadratic Quantization,半二次优化量化)用在已经有的浮点权重上,求出一组量化权重。它不把每个权重四舍五入到最近的格子,而是最小化一个损失函数,找出一组更合适的量化结果。和 3.2 里的 GPTQ 一样,都是训完再量化。

权重矩阵切成小块,每块单独量化,用来保住局部。每个小块用半二次优化算出自己的 scalar 和 zero_point。反量化只带回权重:

[ W_{\mathrm{float}} \approx \mathrm{scale} \times (W_{\mathrm{quant}} - \mathrm{zero}) ]

这和 3.1 的 (r' = \mathrm{scale} \times (q - \mathrm{zero_point})) 是同一条还原。位数可以是 4 比特或 2 比特。要求解的 (W_q) 写成 int4。

10.1 目标函数

[ L(W_q) = |W - W_q|_2^2 + \lambda |XW - XW_q|_2^2 ]

第一项是量化误差,第二项是输出激活误差。

符号含义
(W)原来的浮点权重,fp16 或 bf16
(W_q)要求解的量化权重,写成 int4
(X)校准集里的输入激活。通常从训练集随机抽一小批,例子是 128 到 512 条,用来代表典型输入
(\lambda)两项的比重。(\lambda) 越大,越偏向保住原来的输出激活,权重和原来的相似度可以让一让

步骤里同时写了另一句:HQQ 只关注权重,不需要激活,反量化式子里也没有激活。上面的第二项仍然用了 (X)。

3.2 里 GPTQ 最小化的是一层输出 (|WX - \hat{W}X|_2^2),再按列把误差补到后面。这里多了第一项 (|W - W_q|_2^2),用 (\lambda) 在两项之间取平衡。

10.2 改成半二次

直接最小化 (L(W_q)) 比较难,因为 (W_q) 是离散的整数。引入辅助变量 (Z),写成等价的半二次形式:

[ L(W_q, Z) = |W - W_q|_2^2 + \lambda |Z - XW_q|_2^2, \qquad Z = XW ]

然后交替优化,迭代求 (W_q) 和 (Z)。先优化连续问题,再投影到离散空间。一个离散优化被拆成一串更简单的子问题。

10.3 一个数的例子

同一通道上,量化和反量化可以共用一套 scaling factor 和 zero_point。共用这一套时,后面写着 a+b 收到 32/16 比特,精度损失累计,并写了混合精度训练。另一句写:不必用同一套 scaling 和 zero_point。

例子用了两套。第一次量化原来的权重,scaling1 是 0.00043,zero_point 是 0。第二次量化重建误差,只标了 scaling2,没有给出数。

量化前量化成的整数反量化
第一次,对 (W)1.321.5
重建误差(1.5 - 1.3 = 0.2)
第二次,对这份误差0.20.15

第二次的整数没有标。补偿是用反量化后的误差去减第一次的重建值:

[ W_{\mathrm{construct,new}} = 1.5 - 0.15 = 1.35 ]

原来的权重是 1.3。1.35 比第一次反量化得到的 1.5 更靠近 1.3。

工厂里要在训练时用 HQQ,在普通 LoRA 的 yaml 上写 quantization_method: hqq,并写 quantization_bit。底模仍是未量化的,写出的仍是 adapter。见 6.3 第 4 问。

10.4 拓展QA

1. 半二次指的是什么?

指 10.2 的拆法。(W_q) 是整数,(L(W_q)) 要在这些离散格子上直接最小化。

引入辅助变量 (Z),约束是 (Z = XW),损失写成

[ L(W_q, Z) = |W - W_q|_2^2 + \lambda |Z - XW_q|_2^2 ]

两项都是平方。平方误差对连续变量是二次函数,最小值好求。(W_q) 还要落在量化整数上,所以不把整份损失一次解完,改成交替:先在连续的一侧按这些平方项求最小值,再把求出来的数投影回量化整数。一次只解连续的那一半,整数的那一半用投影接上,这个交替就叫半二次。一个离散优化被拆成一串更简单的子问题。

10.3 是这个交替的一次。1.3 先量化再反量化得到 1.5,重建误差 0.2 再量化,反量化得到 0.15,从 1.5 里减去,得到 1.35。

2. 工厂里和 HQQ 并列的 bnb、eetq,原理是什么?

三条都是加载时量化。底模仍是未量化的权重,读进显存时按 quantization_method 把权重量化,训练的仍是 LoRA,写出的仍是 adapter。位数写在 quantization_bit。和 GPTQ、AWQ 那种先导出一份低精度完整模型分开。

bitsandbytesHQQEETQ
位数4 或 82、3、4、5、6、8只写 8
怎么定格子4 比特用 NF4,再把缩放系数做双重量化。8 比特是 LLM.int8()每个小块用半二次优化求 scalar 和 zero_point,见这一节权重量化成 int8,每个通道自己一个 scale
要不要校准集加载时按权重自己的分布量化这一节的损失里写了校准激活 (X),步骤里又写只看权重库的说明是不要校准集,也不做量化训练
算的时候存低位数,矩阵乘之前还原成 16 比特反量化仍是 (scale \times (q - zero))权重是 int8,乘用它自己的 GEMM、GEMV 核

bitsandbytes。 先把权重归一化,让它们落进一个区间,常见的值更好表示,再收成 4 位或 8 位。存的是低位数,计算时反量化成 16 位。归一化之后 NF4 的 16 个格子是均匀排开的;映回原来的权重,0 附近更密、两头更稀。一块权重共用的缩放系数再量化一次,就是双重量化,权重的 4 比特不变,省的是这批系数。百川脚本写成 bnb_4bit_quant_type="nf4"、bnb_4bit_use_double_quant=True,计算用 BF16。工厂的 yaml 只写位数和方法,不写这两行。8 比特对应图上的 LLM.int8():原始权重和反量化回来的权重都堆在 0 附近。展开在 QLoRA 和 NF4、双重量化。

quantization_bit: 4
quantization_method: bitsandbytes

一块里有 (1.0) 和 (0.06),绝对值最大是 (1.0),缩放系数就是 (1.0)。(0.06) 已经是归一化之后的位置。NF4 在 0 附近的下一格大约是 (0.0796),再往外大约是 (0.1609)。(0.06) 到 (0.0796) 比到 0 更近,收到这一格,还原仍是 (0.0796)。均匀的 4 比特把 ([-1, 1]) 切成 15 等份,一格大约 (0.143),半格大约 (0.071)。(0.06) 比半格更靠近 0,会收成 0,还原也是 0。同一块里的 (1.0) 两种格子都留在端点。NF4 保住的是靠近 0 的那个小数。这块的缩放系数 (1.0) 若再做双重量化,压的是系数本身,(0.06) 收到的那一格不变。

EETQ。 只做 8 位,是因为核按 int8 写死了:每个权重收成 -127 到 127 里的一个整数,不能改成 4 位或 2 位。量化方式是对称的,zero point 固定为 0。每个输出通道单独取一个 scale,等于这一行权重里绝对值最大的那个数除以 127。这一行里的权重再除以自己的 scale,四舍五入,夹进 -127 到 127。还原是 (scale \times q)。通道与通道的最大值差很多时,小数那一行不会被大数那一行的步长吞掉。

不要校准集,也不做量化训练:scale 只从这一行权重的最大值来,不看激活,也不交替去改已经收好的整数。矩阵乘时输入仍是 16 位浮点,int8 权重在它自己的核里相乘,通道的 scale 乘在这一行的结果上,不必先把整份权重还原成 16 位再做普通矩阵乘。这和 bitsandbytes 的 8 位不是同一条:LLM.int8() 会把特别大的那几列留在 16 位;EETQ 不拆列,一行里每个权重都是 int8。它也不做 10.2 的半二次交替,也不做 9.1 那种按激活先放大再量化。工厂里写成:

quantization_bit: 8
quantization_method: eetq

两个输出通道分开算。

第一行绝对值最大是 (2.54),(scale = 2.54 / 127 = 0.02)。(0.50) 除以 (0.02) 得 (25),还原 (0.50)。(-1.20) 得 (-60),还原 (-1.20)。(2.54) 得 (127),还原 (2.54)。

第二行绝对值最大是 (0.10),(scale = 0.10 / 127)。这一行里的 (0.008):

[ q = round\left(\frac{0.008}{0.10/127}\right) = round(10.16) = 10 ]

[ r' = 10 \times \frac{0.10}{127} \approx 0.00787 ]

若第二行借用第一行的 (0.02),(0.008 / 0.02 = 0.4),收到 (0),还原也是 (0)。按通道各留一个 scale,这个小数还在。zero point 是 0,所以 0 仍落在整数 0 上,正负只用同一个步长。

工厂加载量化的代码里,EETQ 和 HQQ 与 DeepSpeed ZeRO-3、FSDP 写在一起会直接报错。FSDP 那份训练 yaml 用的是 4 比特,走 bitsandbytes。

11. GaLore全量参数微调实战与tensorboard使用

实战二用脚本做一次 LLaMA-Factory 微调。要得到一个用繁体中文回答问题的模型。

数据是已经下好并转成 Alpaca 的 traditional_chinese.jsonl,登记名 traditional_chinese。文件怎么来的见 1.6 和 1.7。底模是 DeepSeek-R1-Distill-Qwen-1.5B,路径 /root/.cache/modelscope/hub/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B。

三条要求:全参数微调加上 GaLore;用 TensorBoard 看训练;脚本里把微调和推理验证都做完。

11.1 训练命令

先装投影那一份:pip install galore_torch。注释标题写成「使用Galore优化器完成全参微调」。优化器那一行仍是 --optim adamw_torch,GaLore 由 --use_galore True 打开。交给 AdamW 的梯度先做低秩投影,优化器本身不换一套,和 4.1 同一条。

################################使用Galore优化器完成全参微调################################
# pip install galore_torch
llamafactory-cli train \
    --stage sft \
    --do_train True \
    --model_name_or_path /root/.cache/modelscope/hub/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B \
    --preprocessing_num_workers 2 \
    --finetuning_type full \
    --template deepseekr1 \
    --flash_attn auto \
    --dataset_dir data \
    --dataset traditional_chinese \
    --cutoff_len 2048 \
    --learning_rate 5e-05 \
    --num_train_epochs 3 \
    --max_samples 1000 \
    --per_device_train_batch_size 2 \
    --gradient_accumulation_steps 8 \
    --lr_scheduler_type cosine \
    --max_grad_norm 1.0 \
    --logging_steps 20 \
    --save_steps 100 \
    --warmup_steps 0 \
    --packing False \
    --enable_thinking True \
    --report_to "tensorboard" \
    --logging_dir single_galore_qwen1.5_log \
    --use_galore True \
    --output_dir saves/DeepSeek-R1-1.5B-Distill/full/train_2025-09-11-18-16-51 \
    --bf16 True \
    --plot_loss True \
    --trust_remote_code True \
    --ddp_timeout 180000000 \
    --include_num_input_tokens_seen True \
    --optim adamw_torch \
    --galore_rank 16 \
    --galore_update_interval 200 \
# --galore_scale 2 \
    --galore_target all

--finetuning_type full 是全参数,权重本身在改,不是只存一份 adapter。GaLore 四项里,这次写上的是:

脚本里的名字取值对应 4.1
galore_rank16rank。范围 16 到 512 的下限
galore_update_interval200update_proj_gap。论文里常用的 200 步
galore_scale这一行被注释掉,写成 2scale。不传就按 1.0 / rank
galore_targetall投影打在哪些层上。all 是全部线性层

脚本里精度是 --bf16 True,没有 --pure_bf16。4.2 里 GaLore、BAdam 那条要再写上 pure_bf16: True,更新才直接落在 bf16 上。

其余和这次任务绑在一起的:模板 deepseekr1,--enable_thinking True。数据目录 data,数据集名 traditional_chinese,最多取 1000 条,截断 2048,--packing False。学习率 5e-05,3 个 epoch,每卡 batch 2,梯度累积 8,余弦调度,梯度裁剪 1.0,预热 0。--flash_attn auto。日志每 20 步打一次,每 100 步存一次。输出目录是 saves/DeepSeek-R1-1.5B-Distill/full/train_2025-09-11-18-16-51,目录名和底模名对不上:底模是 DeepSeek-R1-Distill-Qwen-1.5B,目录写成 DeepSeek-R1-1.5B-Distill。--ddp_timeout 180000000。

11.2 TensorBoard

--report_to "tensorboard" 把曲线交给 TensorBoard,日志目录单独写成 single_galore_qwen1.5_log,不跟输出目录走。看图:

tensorboard --logdir=single_galore_qwen1.5_log --port=6006 --host=localhost

地址仍是 http://localhost:6006/。之前一次 LoRA 把 --logdir 指到 saves/.../runs,看板里有 train/loss、train/grad_norm、train/learning_rate、train/epoch,以及 train/num_input_tokens_seen 打开后多出来的 train/num_input_tokens,见 1.3。这次多了 --include_num_input_tokens_seen True,就是为了那条 token 数。--plot_loss True 是训练结束之后在输出目录里另存一张 loss 图,和这块看板不是同一处。

11.3 推理验证

脚本注释里写的是 llamafactory-cli chat llama3_full_sft.yaml。打开并实际跑的文件是 deepseek_full_sft.yaml,4 行:

model_name_or_path: "/root/autodl-tmp/LLaMA-Factory/saves/DeepSeek-R1-1.5B-Distill/full/train_2025-09-11-18-16-51/checkpoint-100"
template: deepseekr1
infer_backend: huggingface  # choices: [huggingface, vllm, sglang]
trust_remote_code: true

checkpoint-100 对上 --save_steps 100。全参训完,model_name_or_path 直接指这份权重,不用再挂 adapter。模板和训练一样是 deepseekr1,推理后端是 huggingface。

vi deepseek_full_sft.yaml
llamafactory-cli chat deepseek_full_sft.yaml

用来和原模型比的那句是:"玫瑰王国"是指哪个国家?。原模型怎么答、微调后怎么答,这里没有记下。