大模型怎样把数据学成能力,又怎样把权重算成文字?

大模型怎样把数据学成能力,又怎样把权重算成文字?

Deng YongJie's blog 5 2026-11-15

大模型怎样把数据学成能力,又怎样把权重算成文字?

从 token、梯度与 checkpoint,到 MoE、Prefill 和 Decode 的完整链路

我们通常从一个很自然的问题开始:模型看过那么多书、网页和代码,这些知识究竟放在哪里?继续追问,就会碰到更多名词:神经元、权重、token、专家、checkpoint、KV cache。它们似乎都在“存东西”,却存着完全不同的东西。

理解它们,最有效的办法是追踪两条线:训练怎样改变参数,推理怎样使用参数。 中间再接上保存与加载,整个系统就连起来了。

01-全链路

1. 模型的知识存在哪里?先分清三种“记忆”

一个语言模型在回答问题时,可能同时利用三类信息。

信息来源 实际存放什么 存在哪里 怎样变化
参数记忆 训练得到的权重、偏置等参数 模型文件;运行时的显存、内存或分层存储 训练、模型编辑、替换权重等
上下文状态 当前输入、已生成内容及其计算状态 请求管理器、GPU/Host KV cache 等 随输入与生成更新
外部知识库 原文、记录、索引、检索向量 文档库、数据库、对象存储、搜索系统 增删改外部数据

02-三种记忆

图2|RAG 把外部内容检索出来,放入模型当前可见的上下文。它不要求先把这些内容训练进权重。

模型回答问题时,依据从哪里来?

  • “法国的首都是哪里?” 模型可以凭训练中学到的知识回答“巴黎”。这类知识体现在权重的数值里。
  • “按这份差旅制度,住宿费能报销多少?” 你上传了制度,模型就可以读其中的报销条款,按原文回答。
  • “我的订单发货了吗?” 应用先用订单号查询数据库,再把最新状态交给模型回答。

上传一份制度,模型就学会了吗? 普通聊天里,上传文件是给模型一份可读的资料。微调则会用训练数据更新模型权重。

下次聊天还能不能引用这份制度,取决于应用能否从聊天记录或知识库中再次取出原文。

2. 神经元、层、权重与梯度,分别是什么?

神经元不是一个小型知识库

人工神经元可以用下面的典型形式理解:

z = w₁x₁ + w₂x₂ + … + b
y = φ(z)

x 是输入,w 是权重,b 是偏置,φ 是激活函数。关键不只有乘加,还包括非线性。如果不断堆叠纯线性层,中间没有非线性,整个堆叠仍可以合成一个线性变换,表达能力会受到很大限制。

原书-p035-神经元

在 Transformer 中,“神经元”常被用来指 FFN 的某个中间通道。它与一个参数也不是同一个概念:一个输出通道往往对应一整组输入权重。

61 层不是 61 个梯度

名词 可以怎样理解 典型形状或数量
层/块 一段计算结构,后一层接收前一层的输出 例如 61 个 Transformer 块
权重 θ 计算结构中可学习的数值 向量、矩阵或更高阶张量
激活/隐藏状态 h 某次输入在某层产生的中间结果 例如 [batch, length, hidden_dim]
梯度 ∂L/∂θ 损失对参数变化的局部敏感程度 与对应参数张量形状相同

05-层权重梯度

图4|前向沿层传递激活,反向沿计算依赖传播导数。普通训练保持架构层数不变,主要改变参数数值。

假设某层权重 W 的形状为 [4, 3],它有 12 个参数;对应的 W.grad 通常也是 [4, 3],有 12 个偏导数。不能把“网络有几层”“张量有几个轴”“向量有几个分量”混成一个数字。

词向量和梯度分别告诉我们什么?

先看词的意思。 假设同一个模型把“猫”“小猫”“火车”各表示成一串数,也就是一个向量。如果按同一种方法比较,“猫”和“小猫”的向量更接近,就说明这套表示捕捉到了两个词的某种相似性。这些向量所在的空间叫表示空间。

再看权重怎么调。 假设一个小模型只有一个权重 w,预测值等于 2 × w。我们希望它输出 6,用预测值与 6 相差多少来衡量误差。

  • w = 2 时,模型预测 4,离目标 6 还差 2。
  • 把 w 调到 2.1,模型预测 4.2,只差 1.8。

权重增加了 0.1,误差减少了 0.2。在这段直线上,误差随权重变化的速度就是 −0.2 ÷ 0.1 = −2。这就是此处的梯度。负号告诉我们,此时把权重调大一点,误差就会减小。

一个参数对应一个梯度分量。若模型有三个参数,就能把梯度画成三维箭头。有 12 个参数,箭头就有 12 个分量。“61 层”数的是前向计算经过多少个模块。

原书里的三个术语,也可以放回这个例子理解。

  • 张量用来组织数字。例如,把 12 个权重排成 4 行 3 列,就是一个张量。
  • 链式法则用来把影响逐步传回去。这里先有“权重 → 预测值”,变化率是 2。再有“预测值 → 误差”,在预测值小于 6 时变化率是 −1。两者相乘,得到梯度 −2。
  • 自动微分把这件事交给框架。写好预测值和误差的计算,框架就能沿着这些运算,从误差往回算出权重的梯度。

比较两个模型的能力,可以让它们回答同一组问题。即使两个模型的权重排列不同,例如把两个隐藏神经元和各自的连线一起交换,它们也可能给出完全相同的结果。参数置换的例子

3. 文字怎样变成 token,token 又怎样还原成各种语言?

先把三个对象分开:文本片段、token ID、embedding 向量。

文本片段:"巴黎"                 人能够阅读的文字
token ID:例如 42                分词器赋予的整数编号,示意
embedding:E[42] = [0.1, …]      从可训练嵌入矩阵取出的一行向量

实际的“巴黎”可能是一个 token,也可能被切成多个;42 不是本文声称的真实编号。token ID 只是编号,42 与 43 相邻不代表它们语义相近。

03-文字与token

图5|两端由 tokenizer 处理,中间由神经网络计算。词表和 embedding 不是同一张表。

分词器也要建立,但通常不随语言模型每一步更新

常见 tokenizer 包含规范化、预切分、词表、合并规则和特殊 token 的处理。BPE 会逐步合并常见的相邻单元;Unigram、WordPiece 等又有不同规则。不是所有现代模型都使用 byte-level BPE,也不是所有 tokenizer 都绝对没有未知字符问题。采用完整字节覆盖或字节回退的设计,可以处理词表中没有单独条目的字符。Hugging Face BPE 教程

在字节级方案中,中文、英文、日文都能表示为字节序列。解码器按 token 对应的片段/字节及约定规则拼接,还原出文本,通常不需要先判定“这是哪国语言”。有些 token 只覆盖一个字符的部分字节,流式显示需要正确处理未完成的字符边界。

但能编码某种语言,不等于模型会使用那种语言。编码能力来自 tokenizer 的覆盖范围;流利表达和理解能力来自训练数据、模型及训练过程。中文“每字多少 token”也没有固定比例,应使用实际 tokenizer 计数。

两种“解码器”不是同一个东西

  • Tokenizer decoder / detokenizer:把 ID 序列还原为可显示文本。
  • Transformer decoder:运行注意力、FFN 等神经网络计算,预测后续 token。

前者处理编码约定,后者处理条件概率。名称相似,职责不同。

Embedding 矩阵 E 的形状是 [V, d]:V 是词表大小,d 是隐藏维度。取出一行虽然也是查表,但这张表的数值是训练得到的。推理前后的 tokenizer、词表顺序和模型必须配套;随意更换 tokenizer 会让相同 ID 对应不同文本,破坏输入输出的含义。

4. 一堆矩阵怎样算出下一个 token?

原书第 122 页展示的是带 Encoder 和 Decoder 的 Transformer。理解当前常见的自回归文本模型时,需要再看第 161—164 页的 GPT:它通常采用 decoder-only 结构,没有单独的 Encoder,也不要求每层都有 encoder-decoder cross-attention。

原书-p122-Transformer

图6|原书第 122 页的整体架构图。它帮助认识注意力、FFN 和层堆叠;不能直接当作所有 GPT 类模型的完整结构。

06-前向计算

图7|本文对应的简化 decoder-only 链路。各层通常使用不同的参数,“重复块”不意味着反复调用同一份权重。

一次简化的前向过程是:

input_ids [B,T]
  → Embedding 得到 H [B,T,d]
  → 位置机制 + L 个 Transformer 块
  → 最终归一化
  → 输出层得到 logits [B,T,V]

训练一般需要多个位置的预测;生成时常只需要最后一个相关位置的 logits,推理实现可以避免计算不需要的输出分数。

注意力:按照当前上下文混合信息

以单头普通注意力为例,省略批次维度:

Q = H WQ,K = H WK,V = H WV
A = softmax(QKᵀ / √dₖ + M)
Attention(H) = A V WO

M 是因果遮罩:不允许看的未来位置加上负无穷,softmax 后其权重为零。WQ/WK/WV/WO 是可训练参数;Q/K/V/A 是这次输入产生的中间结果。残差连接把子层输出加回主干,归一化帮助稳定数值。真实模型还可能使用多头、RoPE、GQA、MLA 等设计。Transformer 原论文

注意力确实负责上下文信息交互,但它的投影矩阵也参与学习,所以“注意力完全不存知识”说得过头了。

FFN:非线性变换,不只是再乘一个矩阵

一个简单 FFN 可以写成 φ(HW₁)W₂;常见 SwiGLU 形式则是:

FFN(x) = [SiLU(xWgate) ⊙ (xWup)] Wdown

⊙ 是逐元素乘法。这里有矩阵乘、非线性、门控和残差等操作,不能统称为“全部只有线性矩阵乘法”。

输出层:对词表打分,不是查找“最近的文字”

设最终隐藏向量 h ∈ Rᵈ,输出矩阵 Wout ∈ Rⱽˣᵈ:

z = h Woutᵀ              # z 有 V 个分数,称为 logits
pᵢ = exp(zᵢ) / Σⱼexp(zⱼ) # 概率分布

若实现包含输出偏置,还会加上偏置。点积打分不是天然的最近邻搜索:向量长度、方向和模型所学变换都会影响结果。

下面沿用原问答的 4 维玩具数值,但统一 token 标签,避免“给‘首’最高分却输出‘黎’”的混乱:

h = [0.8, -0.3, 1.2, 0.1]
候选 ID A 的输出权重 = [1.0, -0.5, 1.8, 0.2]
zA = 0.8×1.0 + (-0.3)×(-0.5) + 1.2×1.8 + 0.1×0.2
   = 3.13
教学候选 logit softmax 概率
A 3.13 78.09%
B 0.95 8.83%
C 0.61 6.28%
D 0.34 4.80%
E −0.53 2.01%

贪心解码选择最高分 A;随机采样按分布选择,A 也不是必然获选。温度会改变分布的集中程度,top-p 等规则会限制候选集合。选出的 ID 最后交给配套 tokenizer 还原。概率高表示模型偏好这段续写,不保证事实正确。

“模型里有没有算法”,要区分两个层面

前向计算当然有明确的算法与公式:矩阵乘、softmax、激活、归一化和路由都由代码实现。另一个问题是:回答 17×24 时,它是否调用了人写好的整数乘法程序?纯语言模型前向通常没有自动替换成计算器的这一步;它使用学到的参数及上下文产生后续 token,能力可能来自记忆、可泛化的计算模式或中间推理过程。

但“偶尔算错,所以内部绝不执行任何算法”同样不成立。神经网络可以学到算法式行为,只是可靠性与泛化范围需要验证。若应用调用 Python、计算器或其他工具,则确实可以由外部确定性程序完成算术,模型负责组织调用和解释结果。这是模型计算与工具计算的又一条边界。

5. 训练究竟做了什么?从文本到一次参数更新

你可以把训练理解成:用数据产生监督信号,再利用这个信号调整已经存在的参数。

架构代码定义怎么计算,也定义参数的形状与初始化方式。模型刚被创建时就已经有参数,可以保存成文件,只是通常还没有学到有用能力。训练改变这些数;保存操作负责把当时的数序列化。代码不是被“编译成知识”,文本也不是被逐字改写成一个矩阵。

同一条文本怎样给自己出题?

假设分词后得到:

[法国, 的, 首都, 是, 巴黎]
输入:[法国, 的, 首都, 是]
目标:[的, 首都, 是, 巴黎]

第一个位置预测“的”,最后一个输入位置预测“巴黎”。虽然一批数据包含完整序列,但因果遮罩阻止每个位置看到未来答案。真实前缀作为输入,这叫 teacher forcing。

04-训练闭环

图8|一批已知序列可以在位置维度上并行计算;层与层之间仍有依赖。图中更新公式为 SGD 示意。

对有效预测位置求平均,最基本的损失是:

L(θ) = − meanₜ log pθ(xₜ₊₁ | x₁,…,xₜ)
g = ∇θ L
θnew = θold − ηg              # SGD 示例

实际自回归预训练可以再加入辅助目标,SFT 也常对用户部分或 padding 屏蔽损失;并非所有模型、所有训练阶段都只有一个 next-token 目标。

下面是核心逻辑示意,model、loader 和优化器需由实际训练项目定义,代码不包含分布式、混合精度与恢复流程:

for token_batch in loader:             # token_batch: [B, T+1]
    inputs = token_batch[:, :-1]
    labels = token_batch[:, 1:]
    optimizer.zero_grad(set_to_none=True)

    logits = model(inputs)            # 示例接口直接返回 [B,T,V]
    loss = cross_entropy(
        logits.reshape(-1, logits.size(-1)),
        labels.reshape(-1),
    )
    loss.backward()                   # 自动微分:计算梯度
    optimizer.step()                  # 按优化器规则更新参数

梯度告诉我们参数微小变化对 loss 的影响,优化器决定实际如何移动。Adam/AdamW 会维护梯度的一阶、二阶统计量,还涉及偏差校正、学习率及权重衰减等;它们不是简单逐元素乘一次固定学习率就结束。

原问答的更新算术应当修正为:

w = 0.0123,η = 2×10⁻⁴,g = −4×10⁻⁷
wnew = 0.0123 − (2×10⁻⁴)×(−4×10⁻⁷)
     = 0.01230000008
Δw   = 8×10⁻¹¹

不是 0.01230008。更不能由这一个例子推导“每个参数每步都固定变化 10⁻⁵”。实际更新取决于参数、优化器、精度、调度和梯度;有些参数会被冻结,MoE 中未被选中的专家也可能没有本批次的数据梯度。

为什么预测下一 token 会带来知识和能力?

语法、事实、代码结构、算术规律和上下文关系,都可能帮助模型降低预测损失。大量不同例子共同约束参数后,一些可复用的内部表示和计算模式会被学出来。

但这不是“为了预测就必须理解一切”的数学保证。模型也可能利用表面相关性、训练数据捷径或直接记忆。它会不会某项技能,最终要靠独立测试,而不能从训练目标直接推出。

“模型是数据的有损压缩”可以作为直觉,但不要把语料字节数除以权重字节数当作严格压缩率:token 与原始字节没有统一换算,模型也不是一个可以无损解压语料的压缩包。

6. 学到的知识在权重里长什么样?会不会记住原文?

权重张量有名称、形状和物理地址,但这些地址通常不是人类语义中的“事实地址”。不能通过“第 137 层第 4096 个神经元”直接读出一条完整的百科条目。

一种有用的研究视角,是把 FFN 看成“模式匹配后添加输出方向”的记忆机制。不过 FFN 通常首先输出隐藏空间中的向量,不是每个中间神经元直接输出完整词表概率。多层的注意力、FFN、残差与输出层共同影响答案。Geva 等:FFN 的键值记忆视角

知识可能分布在多层、多组参数的联合取值中;同一个方向或通道也可能参与多种功能。稀疏自编码器研究从模型激活中提取可解释特征,为这种分布式表示提供了证据。但“提取了多少特征”不等于“模型总共有多少知识点”,更不是所有特征都得到同等充分的解释。Anthropic 的特征提取研究

ROME 等模型编辑方法,在特定模型和任务上展示了对事实关联进行局部修改的可能性。这是有条件的研究结果,不能推广为“任何事实都只需改一个方向,其他能力完全不受影响”。ROME 项目与论文

最需要纠正的一句:不是“原文一个字节都没有留下”

更准确的说法是:权重通常不以原始文档文件的形式保存语料,但参数可以编码训练样本,模型有时能够逐字复现其中的片段。 已有研究从语言模型中提取出训练文本,包括并非简单高频名句的内容。Carlini 等:训练数据提取研究

因此,以下两个极端都不成立:

  • “权重就是世界上所有文字的仓库。”
  • “权重绝不保留原文,任何一句训练文本都不可能恢复。”

频率、重复、上下文、模型容量和训练方法都会影响记忆;“知识强度 = 频率 × 一致性”只能算粗略比喻,不是可靠定律。

这也帮助我们理解三种风险:幻觉是生成目标与真实性之间的落差等多因素共同造成的;遗忘是新训练改变共享参数时可能发生的能力损失,并非“改 A 必然毁掉 B”;出处不明确是参数通常没有绑定可直接查询的来源指针。LoRA 可以减少需要训练的参数和存储,但不保证杜绝遗忘;RAG 可以提供可核对的原文,但仍需检查引用是否真的支持回答。

7. 为什么一句提示词就能让模型换语言?

“请用英文回答”与问题一起进入上下文,改变的是条件概率:

p(下一个 token | 问题、语言指令、之前生成的内容)

经过训练,模型可能学会将语言指令与对应回答关联起来。各层计算会让当前表示受指令影响,输出层因而更偏好合适的英文续写。生成的英文又成为后续上下文的一部分。

07-指令与语言

图9|遵循语言要求是一种学到的条件行为,不能简化成“指令 token 的注意力分数一定最大”。

预训练提供大量语言和任务模式,后训练强化指令遵循与回答质量。这里也要避免划出过硬的边界:基础模型可以具有一定指令响应能力;SFT、继续预训练和强化学习既可能调整行为,也可能带来新的知识或任务技能。“预训练只学知识、后训练只学听话”是便于入门的近似,不是事实隔离墙。

同样,“强制第一个词是英文”并不能保证后文始终为英文。指令冲突、上下文干扰、训练覆盖不足和采样设置,都可能影响结果。若产品必须限制输出语言,需要用实际数据评估,并在应用层检查输出。

8. 权重文件、.pt 和 checkpoint,到底是什么关系?

Checkpoint 是快照,不是某一种扩展名

checkpoint 的本义是某个时刻保存下来的状态。它可能只包含模型参数,也可能是一套支持完整恢复的训练快照。后者通常包括:

model                 模型参数和必要 buffers
optimizer             Adam 等优化器状态
scheduler             学习率调度状态
step / tokens_seen    训练进度
rng_state             随机数状态
data_state            采样器或数据读取位置(按实现)
config / metadata     配置、版本、分片布局等

所以,checkpoint 里本来就有权重。发布模型通常是在快照中选择需要的参数,转换命名、布局或精度,再重新打包。一个可加载的完整 state_dict 本身就能用于推理,并非所有 checkpoint 都“不能直接推理”。PyTorch 保存与加载教程

.pt 里不只有浮点数

.pt、.pth 是常见命名约定,不能仅凭后缀判断内容。现代 torch.save 默认使用 ZIP64 容器,内部可包含对象元数据和张量 storage。保存内容可能是一个张量、state_dict,也可能是更大的训练状态字典。

模型参数常见为 FP32/BF16/FP16 等数值;量化模型还可能保存整数打包数据和缩放因子。模型状态也可以有整数 buffer,训练进度、配置和随机状态更不全是浮点数。PyTorch 序列化说明

safetensors 保存什么?

其核心结构为:

8 字节头部长度
JSON 头部:张量名 → dtype、shape、data_offsets
数据区:各张量的数值字节

头部当然有字符串,如 model.layers.0...weight。所以“权重文件里面没有一个字符”按文件格式理解就是错误的;真正要表达的是:张量数据区不是按百科条目组织的文字数据库。 safetensors 也不负责定义完整的神经网络计算图,仍需模型配置和运行代码配合。safetensors 格式定义

一个小型 checkpoint 怎样提取成 safetensors?

对一个自己生成、单机保存、约定 model 键保存完整 state_dict 的小型 checkpoint,提取参数可以像下面这样。它只演示数值重新打包,不是分布式模型的通用转换器,也没有执行训练:

from pathlib import Path
import torch
from safetensors.torch import save_file

release_dir = Path("./release")
release_dir.mkdir(exist_ok=True)
checkpoint = torch.load("./checkpoint.pt", map_location="cpu", weights_only=True)
state = checkpoint["model"]  # 键名必须与保存时的约定一致

# 此示例仅处理普通稠密张量;clone 避免共享 storage 的保存冲突。
tensors = {
    name: value.detach().cpu().contiguous().clone()
    for name, value in state.items()
}
save_file(tensors, str(release_dir / "model.safetensors"))

这里没有重新学习,也没有反向传播。导出后还需配套架构配置与 tokenizer,核对参数名、共享权重关系和加载结果。包含自定义对象的训练快照可能不能用此受限加载方式打开;应使用对应框架的可信恢复流程,不能把陌生 .pt 当成普通文本随意加载。

训练快照为什么常比推理权重大?

下面只做一个传统混合精度 Adam 的容量估算,不声称是某个模型实际 checkpoint 的格式:

保存项 假设每参数字节 671B 参数的十进制体积
BF16 参数 2 1.342 TB
FP32 一阶矩 m 4 2.684 TB
FP32 二阶矩 v 4 2.684 TB
可选 FP32 主参数 4 2.684 TB
前三项合计 10 6.710 TB
四项合计 14 9.394 TB

这里没有加入训练中的激活、通信缓冲区等;梯度是否存进 checkpoint 也看保存时机和实现。实际优化器精度和状态组织可以不同,例如 DeepSeek-V3 报告使用 BF16 一、二阶矩,因此不能把上表直接标成 V3 实际快照大小。DeepSeek-V3 报告 §3.3.3

如果把所有 671B 参数粗算为每参数 1 字节,是 671 GB 的原始数值负载;真实发布件还受到缩放因子、混合精度张量、辅助模块和元数据影响,不必恰好等于这个数。

9. 128 台机器训练,checkpoint 怎样写到 S3,又怎样导出?

先确认数量:128 台服务器,如果每台 8 张 GPU,是 1024 张 GPU。 rank 是参与分布式计算的进程编号,常见一 GPU 一进程,但 rank 不是服务器名称。

数据并行不会自动把每张卡的参数除以卡数

并行方式 分的是什么 对保存的影响
DP 数据并行 不同数据批次 普通 DP 复制参数,不能简单平均除参数量
TP 张量并行 一个张量的不同部分 需知道张量切分轴和布局
PP 流水并行 不同层或层段 需恢复全局层编号
EP 专家并行 不同专家 需恢复全局专家编号;共享部分另算
ZeRO / FSDP 参数、梯度或优化器状态的分片 保存与恢复依赖其分片元数据

一个纯教学例子:1024 个 rank 使用 TP=8、PP=8、DP=16,8×8×16=1024。不考虑 EP、FSDP、层不均衡及共享参数,一个 DP 副本分布在 64 个 rank 上,每 rank 约持有 N/64 参数;另外 15 个 DP 副本拥有对应参数的复制,而不是每 rank 只有 N/1024。原书第 237—252 页可用于复习这些并行概念。

08-checkpoint

图10|保存、恢复和发布是不同操作。导出时应保留所选快照的一致性,不能混用不同 step 的分片。

“合并”的对象是逻辑张量,不是文件字节

设逻辑权重 W 为 [4,6],TP 按列切成两份:

rank 0:W[:, 0:3],形状 [4,3]
rank 1:W[:, 3:6],形状 [4,3]
恢复 W:沿列方向拼接 → [4,6]

如果另一个矩阵按行切分,就必须沿行拼;PP 分片要对应正确的全局层;EP 分片要对应正确专家。部分实现还会融合 QKV、转置矩阵、打包量化权重,或把参数存成展平缓冲区。

ZeRO/FSDP 并不普遍等价于“把整个模型拉成一条长数组再平均切”。 不同版本可能按参数、分组缓冲区、DTensor 等方式组织;应使用该框架的元数据与转换器。直接把 rank 文件 cat 到一起,既不能正确恢复张量,也不能产生有效模型。

发布时通常经历以下处理:

  1. 选定已完整保存的训练步,读取模型配置与分片元数据。
  2. 提取模型参数,核对名称、形状、dtype、层编号与专家编号。
  3. 按训练布局恢复逻辑张量,并按目标运行格式重排或重新分片。
  4. 按需要做精度转换/量化;这不是发布的必选步骤。
  5. 保存参数文件、配置、tokenizer 与索引,并验证转换前后的数值或生成行为。

导出可以逐张量或逐分片流式进行,不一定需要一台拥有数 TB RAM 的“合并节点”。恢复训练时甚至可以直接读取分布式 checkpoint 并重新分片,不经过一个完整单文件。PyTorch DCP:并行保存与加载时重分片

S3 的作用是持久保存,不负责理解模型

分片可以写入共享文件系统,也可以通过合适的存储后端写到 S3。先暂存 CPU 内存或本地 NVMe、再后台上传,是可选工程方案;并非所有集群都必须经过本地盘。

真正重要的是一致性和完成状态:后台保存需要一个不会被后续优化器更新改变的快照;全部分片上传并核验完成后,再把它标记为可恢复。仅有一个 step_12000/ 前缀或部分对象,不代表 checkpoint 完整。

PyTorch 提供的是 dcp.async_save(...) 等接口,并不是原问答中的通用 dcp.save(..., async_save=True)。S3 URI 是否直接受支持,要看选用的 writer/reader 与版本,不能凭路径字符串假设它会工作。DCP 异步保存接口

10. 文字怎么知道该找哪个权重文件?它不需要知道

这是整条链路中最重要的一次分离:文件索引、token 编码、运行时参数访问,是三个层面。

09-三种映射

图11|token ID 42 对应嵌入表的第 42 行,不对应第 42 个权重文件。

发布目录可能包含:

config.json
tokenizer.json / tokenizer.model / 其他配套文件
tokenizer_config.json
model-00001-of-00002.safetensors
model-00002-of-00002.safetensors
model.safetensors.index.json

这里只是结构示例。分片大小和数量由打包策略决定,不是一个专家一个文件,也不是一层必须一个文件。

典型索引只把张量名称映射到文件:

{
  "weight_map": {
    "model.embed_tokens.weight": "model-00001-of-00002.safetensors",
    "model.layers.0.mlp.up_proj.weight": "model-00002-of-00002.safetensors"
  }
}

它不直接给出张量在文件内的字节偏移;偏移由该 safetensors 文件自己的 header 提供。加载器据此找到数值,建立张量,再绑定到模型代码对应的参数位置。Hugging Face 分片模型加载说明

之后,输入 ID 经 E[id] 取得向量,模型算子直接访问已绑定的参数张量。MoE 的专家选择由 router 根据当前隐藏状态计算,也不是按文本关键词去查文件。

典型全驻留部署主要在启动时读权重;CPU/磁盘卸载、按需换入或其他分层设计则可能在运行中继续搬运。模型必须能取得需要的参数,不等于全部参数必须永远驻留 GPU。 这些方案的速度、带宽和容量代价需要单独评估。

11. 专家是什么?总参数与激活参数怎样计算?

在常见稀疏 MoE Transformer 中,专家通常是某一层 FFN 的一组独立参数。相同结构的专家执行相同形式的函数,但 Wgate/Wup/Wdown 的数值不同:

expertᵢ(x) = [SiLU(xWgate,ᵢ) ⊙ (xWup,ᵢ)] Wdown,ᵢ

所以,“专家是不是某个数学公式”的回答应该是:专家是一个有确定计算公式、可训练参数的子网络;它不是人工写好的‘数学题算法库’。

10-MoE

图12|专家在层内被选择;同一个 token 经过不同层时,可以走不同专家。专家编号不是科目标签。

一个教学路由器可以写成:

scores = score_function(xWrouter)
selected = top_k(scores)
y = Σᵢ∈selected αᵢ expertᵢ(x) + shared_expert(x)(如有)

但这是通式,不是所有实现都使用 softmax。DeepSeek-V3 的公开配置采用 sigmoid 评分,并配合分组选择、路由缩放和负载均衡设计。FFN 的 SiLU 门控也不要与“选择专家的 router”混为一谈。DeepSeek-V3 官方配置

用 DeepSeek-V3 校正一次参数账

该公开示例的主干包含 61 层,前 3 层使用稠密 FFN,后 58 层使用 MoE;隐藏维度 7168,路由专家中间维度 2048,每个 MoE 层有 256 个路由专家,每 token 选 8 个,另有 1 个共享专家。配置可直接核对。官方配置文件

单个三矩阵专家忽略偏置的参数量:

Pexpert = 3 × 7168 × 2048 = 44,040,192 ≈ 44.04M

所有路由专家:58 × 256 × Pexpert ≈ 653.91B
每 token 选中:58 ×   8 × Pexpert ≈  20.43B
共享专家:    58 ×   1 × Pexpert ≈   2.55B

20.43B + 2.55B 仍不是 37B。 还要计入前 3 层稠密 FFN、注意力、输出层等常用部分;参数统计也须说明嵌入和辅助模块的计入口径。官方报告给出的总体数是约 671B 总参数、37B 每 token 激活参数,不能把遗漏项用一个含糊的“加注意力就等于”略过。DeepSeek-V3 技术报告

其中 256 是每层路由专家数,58×256=14,848 是主干路由专家实例数。一次 token 前向只选择其中部分专家,但同一批的不同 token 会选到不同专家;批次越大,被触及的专家并集可能越大。

专家常具有相同的矩阵形状,便于 grouped GEMM 和统一调度。但“所有 MoE 专家都必须同构,否则只能串行”并不是普遍定理;异构专家也可以设计,只是实现与调度更复杂。共享专家的目的可以是承接共用模式、减少冗余,它也不必比路由专家更大。DeepSeekMoE 论文

2 万亿参数能推算有多少专家吗?

不能只凭总参数量确定。若假设所有 MoE 层规格相同,可以粗写成:

Ntotal ≈ Nother + Lmoe × (E × Pexpert + Pshared)
Nactive/token ≈ Ncommon + Lmoe × (k × Pexpert + Pshared)

未知量包括层数、专家宽度、专家数、共享部分和其他子层。下面三种纯假设配置都有约 1.966T 路由专家参数:

MoE 层数 每层路由专家 单专家参数 路由专家合计
64 512 60M 1.966T
64 256 120M 1.966T
128 128 120M 1.966T

因此,“2T 模型通常有 512—768 个专家”不是从 2T 这个数字推出的事实。必须查具体模型配置,也必须说清是在数每层专家还是全模型专家实例。

12. 为什么不把小专家合成几个大专家?

可以这样设计。Mixtral 8×7B 就是每层 8 个 FFN 专家、每 token 选 2 个的典型实例;但名称不表示“每个层内专家本身都是一个完整的 7B 模型”。其注意力等部分是共享结构。Mixtral of Experts

比较专家大小时,至少要固定总容量或每 token 计算预算,否则很容易把不同成本的模型放在一起比较。

11-专家粒度权衡

图13|两个教学配置的总容量和激活参数相同。更多小专家带来更细的组合方式,但并不自动增加“知识量”。

多而小的专家可以提供更细的分工与组合;少而大的专家可能减少路由开销,并提供更适合硬件的大矩阵。实际效果还依赖专家负载是否均衡、通信拓扑、批量大小、并行切法、精度及算子实现。

在均匀路由的理想化情况下:

每专家平均接收的 token 数 ≈ 该路由域的 token 总数 × k / E

这里最容易忽视的是“该路由域”:不能把某一张 GPU 的局部 token 数,直接除以全模型专家数。EP 通信会把 token 重新分发到专家所在位置;热点专家和冗余副本也会改变实际分布。

矩阵的行数较小时,GPU 计算利用率可能不高;但不能仅凭这个平均公式就认定现网瓶颈,更不能从“GPU busy 高、功耗低”直接推出唯一原因。需要算子时间、矩阵形状、通信等待和硬件计数的配套证据。

另外,E ≥ GPU 总数 不是通用硬约束。可以使用 TP 切开一个专家、用 DP 复制模型,或采用混合并行;“专家少于 GPU 数就有一大片 GPU 必然空闲”不成立。专家数能被某种 EP 配置均匀切分有工程便利,但也不要求专家数一定是 2 的幂。

13. 权重文件越多、越大,就代表知识越多吗?

文件数首先取决于分片策略。把同一份模型从 5GB 分片改成 2GB 分片,会增加文件数,却不会增加一个参数。把 BF16 参数改成 FP32,体积可以翻倍,也没有凭空得到新知识。

看到的变化 能说明什么 不能直接说明什么
权重文件变多 打包方式或内容发生变化 知识条目更多
同一模型精度提高 每个参数占用更多位 能力按体积同比提高
总参数增加 可训练容量与存储需求发生变化 某个领域一定更准确
激活参数减少 每 token 的部分计算成本可能降低 总内存、通信或延迟同比减少
token 训练量增加 训练看到更多 token 数据一定更新、更干净或更多样

更大的模型可以提供更大容量,但最终能力取决于数据、架构、优化、训练量和评估任务,不能写成未经证明的乘法公式。参数也不只有“事实”:还承担语法、表示变换、路由和任务计算等功能。

Chinchilla 研究的重要启发,是在固定训练计算预算下协调模型大小与训练数据量。它以 70B 模型、1.4T token 展示了优于同算力规模 Gopher 280B 等模型的结果;不是“用与 GPT-3 完全相同算力作对照”。常被引用的约 20 token/参数是特定研究设定下的经验比例,不能当成所有现代稠密/MoE 模型“吃饱”的硬阈值。Chinchilla 论文

如果你的任务很窄,小模型加优质检索可能更划算;但“7B + RAG 一定胜过通用 671B”仍需在自己的问题、文档与评价标准上验证。模型不会因为某个领域与请求无关,就固定花掉“避开 99% 无关知识”的成本。

14. 长提示词为什么先 Prefill,再 Decode?

这个问题的前半段理解基本正确:对于一个普通、未命中缓存的自回归请求,系统处理有效提示词,利用最后位置的 logits 选择第一个输出 token;之后继续自回归生成。

但先区分:几百 K 字符不是几百 K token,API 接受的输入还必须处于模型和服务支持的窗口内。以下假设提示词被完整接受,没有应用层截断或摘要。

12-Prefill-Decode

图14|图中是普通因果注意力的逻辑时序。Prefill 也可以分块执行;混合注意力或状态空间模型还可能维护不同类型的状态。

Prefill 处理已知序列,Decode 处理刚产生的新 token

Prefill 时,提示词 x₁…xₙ 全部已知。模型可以在满足因果遮罩的条件下,批量计算多个位置,建立逐层 KV cache,并产生最后位置的输出分数。

从该分数选择 y₁ 后,普通 decode 下一步把 y₁ 作为新输入,使用之前缓存的 K/V,计算 y₂ 的分布,同时把 y₁ 的 K/V 追加到缓存。随后输入 y₂,再预测 y₃。

它们共享模型参数与数学依赖关系,但并不要求实际调用完全相同的内核或代码分支。Prefill 常使用大矩阵批量算子,decode 可能使用专门的注意力内核、CUDA Graph 和不同调度策略;连续批处理还会同时服务多个请求。

KV cache 保存的是前文的计算结果

在普通因果 Transformer 中,已经处理过的位置不需要因未来 token 出现而改变其历史 K/V,因此可缓存复用。新的 query 仍会读取历史缓存做注意力,不是“看过一遍就再也不读提示词信息”。KV cache 原理

这里还有一个重要界限:KV cache 是缓存的激活状态,不是新训练出来的权重,也不是把整段提示词压成一个最后向量就足够了。 完整注意力通常保留各层各位置所需的缓存;MLA 可以采用压缩潜变量缓存,其他架构可能还维护滑动窗口或递归状态。

能不能不做批量 Prefill,只把提示词逐 token 喂进去?

在相同因果模型和正确缓存机制下,可以顺序处理这些已知 token,逻辑上同样能建立状态。但这仍然是在完成提示词处理工作,只是选择了通常更低效的执行方式。

批量 Prefill 的优势是让多个位置共享权重读取、增加矩阵乘工作量并减少大量逐 token 调度开销。它不是一个神秘的额外网络,而是对已知前缀计算的高效组织。

原问答“8192 个 token 只读同样一份 37GB 权重”不能普遍成立:MoE 中 8192 个 token 可能选择不同专家,权重并集会扩大;实际读取还受缓存、切片和实现影响。长上下文的注意力成本也不等于一次权重扫描。

同理,“Prefill 一定比 Decode 快 240 倍”不是一般结论。两个吞吐数字必须来自同一可比配置,且不能把不同上下文、并发与命中条件混算。

KV cache 与批量 Prefill 是两个不同优化。 不缓存时,每步重算完整前缀,完整注意力重复求和可能出现立方量级的总开销;缓存后顺序处理已知提示词,注意力总工作仍可保持平方量级,但矩阵乘利用率可能较差。小模型在没有 KV cache 时仍能生成,因此它不是自回归在数学上成立的必要条件。

P/D 分离到底传什么?

当 Prefill 与 Decode 放在不同实例时,需要交接可继续推理的状态。主要大块数据通常是 KV cache,此外还有请求 ID、位置、缓存块映射、采样配置,以及具体实现所需的 token 历史等控制信息。首 token 由哪一侧采样、最后一个提示 token 是否在 D 侧处理,也取决于系统设计。

因此,“只传 KV,D 侧绝对看不到提示词 token”过于绝对。有些实现会把请求/提示词发送到两侧,然后让 D 侧复用收到的缓存,而不是重算整个前缀。vLLM P/D 分离文档

对普通 MHA/GQA,忽略块对齐与额外字段,缓存容量可以粗估为:

KV 字节 ≈ 2 × 层数 L × token 数 T × KV 头数 Hkv × 每头维度 dh × 每元素字节 b
          ↑ K 和 V 两份

这是普通 KV 形式的估算,不能不加修改套到 MLA、混合模型、量化缓存或跨卡复制上。网络传输的理想下界为 传输字节 / 有效带宽;400 Gbit/s 的线速相当于 50 GB/s,实际有效带宽还受协议、拓扑、并发、布局转换和同步影响。某个固定“0.18 秒”不能作为所有 P/D 分离的固有开销。

总参数、激活参数与 TPOT 怎样联系?

小批量 decode 常受权重/KV 读写和通信限制,prefill 则更容易获得较高计算利用率;这些是常见趋势,不是每个模型的永久属性。

一个仅供定位问题的 roofline 近似是:

阶段耗时下界 ≳ max(计算量 / 有效算力, 数据搬运量 / 有效带宽)
端到端还需考虑通信、同步、调度,以及能否重叠。

其中要按实际 GPU 和并行布局计算。多卡 TP、EP 与 PP 不能直接用“全模型 37GB ÷ 单卡带宽”代替;2×激活参数 也只是部分矩阵乘 FLOPs 的粗估,没有完整覆盖注意力和其他操作。

所以:总参数影响存储与模型容量,激活参数影响一部分逐 token 计算,但 TPOT 不由激活参数一个数字决定。 本文不据原问答的 16ms 等数值推断任何现网 GPU 利用率或确定瓶颈。

15. 数据集从哪来?从 0 到 1 做自己的模型怎样开始?

先分清“模型数据集”和“业务知识库”

预训练数据集可能来自有使用权限的网页、百科、书籍、论文、代码、领域文档以及经过验证的合成数据;它们最终被组织成训练样本。业务知识库则以可检索、可更新、可追溯为目标组织文档和记录。两者可以使用相同原文,但处理方式和更新方式不同。

不同团队的数据比例、清洗规则和保留率都不同。不能把“网页占 50—70%”“过滤后固定剩 5—15%”写成行业统一配方。FineWeb 等公开数据集的价值,是能够查看其来源、处理和数据说明,学习真实的数据工程流程。FineWeb 数据卡

13-从零开始

图15|训练之前先准备数据与验证集,训练之后验证恢复和导出。一次跑完并不等于模型已经有用。

数据进入训练前,至少需要哪些处理?

  1. 明确来源与目标。 记录版本、语言、许可和适用范围,确定要学什么能力。
  2. 提取与清洗。 去除无关导航、乱码和模板;检查敏感信息、来源质量与任务适配。
  3. 去重与隔离评估。 按文档或来源划分训练/验证/测试,控制跨集合近重复和评测污染。
  4. 选择 tokenizer。 可以复用合适的现有 tokenizer,也可以训练新的;从零训练不意味着必须自造词表。
  5. 编码与构造样本。 转成 ID,处理文档边界、特殊 token、packing、attention mask 与 loss mask。
  6. 组织读取。 可以离线编码后存二进制 ID 或其他格式,也可以流式读取并在线分词;根据吞吐和可复现需求选择。

离线 tokenize 很常见,但不是数学上必需的一次性步骤;ID 存储也不固定只能用 uint32,能否使用 uint16 取决于词表大小等条件。即使离线编码,训练仍可能被存储吞吐、解压、数据处理或网络拖慢,不能保证“GPU 从不等 I/O”。

训练规模先算单位

每优化步有效 token 数
≈ micro_batch_sequences × sequence_length × DP_size × accumulation_steps

优化步数 ≈ 总训练 token 数 / 每优化步 token 数

这个式子假设长度与有效 token 数相对固定;padding、loss mask、变长数据和调度会使统计方式更细。TP/PP 处理的是同一个训练副本中的模型分工,不能再把它们当作新的独立数据副本乘一遍。

若总训练量为 15T、每步 4M token,步数就是 3,750,000,即 375 万步。若每步约 62.9M token,14.8T 对应约 23.5 万步;后者只是用固定批量作量级计算,不能忽略实际批量爬升等安排后冒充精确训练步数。这里最重要的是把“序列条数”和“token 数”分开。

从零学习机制,先训练一个小模型

如果目标是亲手看清全流程,建议从小型稠密 decoder-only 模型开始,例如几百万到几千万参数、短上下文、有限训练步数。模型小不会改变“数据 → loss → 梯度 → 参数 → checkpoint → 加载 → 生成”的基本关系。

阶段 具体产物 完成标准
数据准备 小规模语料、来源说明、独立验证集 能追溯每份数据,检查训练/验证重复
Tokenizer 编码/解码配置与 ID 样本 正确往返还原目标文本,检查特殊 token
模型初始化 配置与随机参数 shape 正确,能完成一次前向和反向
有限训练 loss、验证指标、checkpoint 先能拟合小批样本,再观察独立验证表现
恢复实验 中断后的续训记录 step、优化器、随机与数据状态按预期恢复
导出与加载 参数、配置、tokenizer 未量化转换前后 logits 在预期误差内一致
生成评估 固定问题和输出记录 记录成功与失败,区分记忆、泛化和格式能力

nanoGPT 可用于阅读小型 GPT 的数据准备、模型、训练和采样代码;生产级训练还需要更多数据、分布式、容错和评估工程。不要把短小教学实现的代码量当成万亿模型团队全部工作量,也不要照搬其中某次实验的训练时长。nanoGPT 官方仓库

本学习博客没有执行训练任务;后续实际实验应先确定模型大小、数据、设备、训练步数和输出目录,再按有限预算运行。

如果目的是解决业务问题,先选对路径

路径 主要改变什么 适合的问题 需要注意
RAG 当前可见的外部证据 文档更新频繁,需要引用来源 检索、切块、权限与回答评估都需要工程
SFT / LoRA 参数或参数增量 行为、格式、任务模式与部分领域能力 可能过拟合或遗忘,事实更新不保证可靠
继续预训练 基座参数 增强领域语言和分布适应 需控制新旧能力平衡
从零预训练 架构与全部参数的起点 学习原理、架构研究或独立基座建设 数据、训练、评估与算力预算缺一不可

这几条路径可以组合。RAG 不是免费知识,微调也不是完全不能学事实;应由“需要什么能力、更新频率、可追溯要求、成本和实测表现”来选择。

16. 用一段完整经历,把所有对象对上

现在,沿着一段文本的生命周期走一次。

训练前,文本保存在语料文件中。数据管线清洗、划分并用 tokenizer 把它编码成 ID;模型代码建立参数张量,并按初始化规则填入数值。一批 ID 进入网络,前向产生隐藏状态和 logits,与右移后的真实 ID 计算 loss;反向得到梯度,优化器更新参数。临时激活和梯度按训练策略释放或复用,参数和优化器状态继续留到下一步。

保存时,各 rank 把约定的状态写成同一步的一致 checkpoint。导出时,转换程序按元数据找到参数,处理切分与命名,选择性量化,再把权重、配置和 tokenizer 打包。分成几个 safetensors,是存储与分发的工程选择。

服务启动时,加载器把文件中的张量绑定到模型算子。用户的新提示词经 tokenizer 变成 ID,Prefill 处理已知前缀并建立缓存;输出层给候选 token 打分,生成策略选择 ID,tokenizer 还原文字。随后 Decode 不断使用历史状态计算下一个 token。普通推理期间,参数保持不变;变化的是输入、激活、缓存和输出序列。

最终,训练与推理分别可以记成两条链:

训练:数据 → token IDs → logits → loss → 梯度 → 参数更新 → checkpoint
推理:文字 → token IDs → 向量与层计算 → logits → 选择 ID → 文字

两条链共用模型的前向计算。训练增加了误差计算、反向传播和参数更新;推理增加了面向生成的缓存与调度。 这就是从“模型怎么学会”走到“模型怎么回答”的连接点。