大模型 · Transformer · 神经网络底层原理

单个神经元的输出：

其中 w 是权重向量，x 是输入向量，b 是偏置标量，f 是激活函数。

感知机（Perceptron）是 Rosenblatt 于 1958 年提出的最早的可学习神经元模型，激活函数是阶跃函数（输出 0 或 1）。1969 年 Minsky 指出单层感知机无法解决 XOR（异或）问题，这曾导致神经网络研究进入"寒冬"，直到多层网络与反向传播算法成熟才复苏。

设输入向量 x（维度 d_in），隐藏层有 H 个神经元，输出维度 d_out。

第一层（隐藏层）：

第二层（输出层）：

所谓"训练神经网络"，就是找到合适的 W₁, b₁, W₂, b₂ 使 y 尽可能接近真实答案。一个百亿参数大模型，本质就是数百万个这样的 W 矩阵的集合。

设损失函数为 L，网络中某参数为 w。反向传播要算的是偏导数 ∂L/∂w——损失对参数的梯度。

对于多层网络，损失对深层参数的梯度通过链式法则逐层展开：

反向传播算法（Rumelhart, Hinton, Williams, 1986）高效地复用中间结果，一次性算出所有参数的梯度，复杂度仅约为前向传播的 2 倍。现代深度学习框架（PyTorch、TensorFlow）的"自动微分"自动完成这一过程。

梯度下降更新：算出梯度后，沿梯度反方向更新参数：

参数更新公式（沿梯度反方向走一步）：

根据每次用多少数据算梯度，分三种：

局部最优（local minima）：山地里不止一个谷。全量梯度下降可能卡在某个浅谷；而 mini-batch SGD 的随机性会"踉跄"一下，抖出浅谷，更可能落到更深的谷（更好的解）。这是随机性在优化中的妙用。

交叉熵损失（语言模型核心）。设模型对词表 V 中每个词预测概率 pᵢ，真实下一个词是词 c：

预测越准（p_c 越接近 1），L 越接近 0。语言模型训练就是在大规模语料上最小化所有位置的平均交叉熵。所谓"loss"就是平均交叉熵，Scaling Law 研究的正是它如何随规模下降。

Adam（Kingma & Ba, arXiv:1412.6980, 2014）结合了动量（历史梯度方向）和自适应学习率（按梯度方差缩放），对超参数不敏感、收敛快：

正则化（Regularization）是一切防止过拟合手段的统称，核心思想是给模型加约束，让它没那么多富余容量去死记硬背。常见方法：

正则化的本质是在"训练集拟合"和"泛化能力"之间做权衡（bias-variance tradeoff）——完全不约束会过拟合，约束太狠又会欠拟合（学不到东西）。

损失函数（最小化重构误差）：

注意自编码器是无监督学习——不需要任何标签，只靠"输入=目标"自我重构就能学到有用的表示。这种"数据本身即是监督信号"的特性，正是后来大模型"用下一个词预测做无监督预训练"思想的雏形。

历史地位与现代传承：Hinton 等人 2006 年用自编码器复兴了深度学习研究。它的"压缩→潜在空间"思想一路演进：

• 降噪自编码器：重构被加噪的输入，学更鲁棒的表示。
• VAE（变分自编码器）：让潜在空间结构化、可生成，是重要生成模型。
• 扩散模型（Diffusion）：现代图像生成（Stable Diffusion、DALL·E）的技术祖先之一，其"逐步去噪还原"与自编码器的"重构"一脉相承。

理解了自编码器，就理解了"潜在空间 / 表示学习"这个贯穿现代生成式 AI 的核心概念。

普通层：y = F(x)。残差层：

为什么有效：梯度反向传播时，+x 这条捷径让梯度可以"直达"浅层（梯度至少为 1），打破了连乘衰减。这使得训练 100+ 层甚至 1000 层网络成为可能。ResNet 因此在 ImageNet 上夺冠（2015）。

对单个向量 x（一个 token 的隐藏表示），在其所有维度上：

γ、β 是可学习参数，恢复表达能力。LayerNorm 让每个 token 的表示数值稳定，是深层 Transformer 能稳定训练的关键之一（Ba et al., "Layer Normalization", arXiv:1607.06450）。

LSTM（Hochreiter & Schmidhuber, 1997）的解法是引入一条贯穿所有时间步的"细胞状态"（cell state），并用三个门（gate）——本质是 sigmoid 控制的小开关（输出 0~1）——精确控制信息的流向：

细胞状态的更新公式（核心是一条加法通路，让梯度可以长程流转而不衰减）：

关键在于 f_t ⊙ C_{t−1} 这条加法通路：当遗忘门 f_t 接近 1 时，细胞状态几乎原样传递，梯度也能无衰减地反向流过长序列——这正是 LSTM 能记住几百步之前信息的原因。

核心公式（Vaswani et al., 2017）：

逐步拆解（设序列长度 n，每个向量维度 d_k）：

• Q·Kᵀ：n×n 矩阵，第 i 行 j 列 = 第 i 个词与第 j 个词的"相关度"（点积）
• / √d_k：缩放。防止点积过大导致 softmax 进入梯度极小的饱和区（d_k 是键向量维度）
• softmax(·)：对每行做归一化，把分数变成加起来等于 1 的注意力权重
• · V：用权重对 V 加权求和 → 每个 token 得到融合了全局上下文的新表示

QKV 的来源：输入 X 通过三个可学习矩阵变换：

所以自注意力本质上是：学习三个矩阵 W_Q, W_K, W_V，让模型自己决定每个词该如何关注其他词。

做法：在算 Q·Kᵀ 得到的 n×n 注意力分数矩阵上，叠加一个下三角掩码——把"未来"位置（上三角）的分数设为 −∞，softmax 后这些位置的权重就变成 0（被完全遮蔽）。

对于一个 4 词序列，掩码矩阵长这样：

           位置1   位置2   位置3   位置4
位置1  →   ■      □      □      □
位置2  →   ■      ■      □      □
位置3  →   ■      ■      ■      □
位置4  →   ■      ■      ■      ■

■ = 可见（对角线及以下，即 ≤ 自己的位置），□ = 被遮蔽（严格大于自己的"未来"位置）。

• 位置 1（第一个词）只能看到自己——它没有任何前文。
• 位置 3能看到位置 1、2、3，但看不到位置 4（未来）。
• 位置 4（最后一个词）能看到全部。

这样每个位置 i 只能关注 ≤ i 的位置，保证了自回归生成（autoregressive）的合法性：预测下一个词时，模型真的只能依据已生成的前文，没偷看答案。

每个头用独立的 W_i^Q, W_i^K, W_i^V（维度为 d_model/h），h 个头的结果拼接后用 W^O 投影回原维度。例如 GPT-3 用 96 个头。代价是计算量与头数成正比，但表达力显著增强。

关键洞察：注意力里查询头数（num_attention_heads）与K/V 头数（num_key_value_heads）可以不相等。Q 头照常并行计算，而 K、V 只需按更少的"组"来生成和缓存。

• MHA：Q 头 = K/V 头 = H（如 32）
• MQA（Shazeer, arXiv:1911.02150）：Q 头 = H，K/V 头 = 1（所有 Q 共享一套 K、V）
• GQA（Ainslie et al., arXiv:2305.13245）：Q 头 = H，K/V 头 = G（如 8），即 H/G 个 Q 头共享一组 K、V

实例：DeepSeek-R1-Distill-Qwen-1.5B 的 config.json 中 num_attention_heads=12 而 num_key_value_heads=2，即每 6 个 Q 头共享一套 K、V —— KV Cache 仅为 MHA 的 1/6。

pos 是位置，i 是维度序号，d 是模型维度。不同频率的正余弦让每个位置有唯一编码，且能外推到训练时未见过的更长序列。

大模型是把如下"Transformer Block"堆叠 N 次（GPT-3 是 96 层）。每层包含：

前馈网络 FFN 通常是两层 MLP 加激活函数（GELU）：

每个子层都套 LayerNorm(x + Sublayer(x)) 的"残差+归一化"结构。注意力负责"词与词的信息混合"，FFN 负责"每个位置的非线性变换"，二者交替堆叠构成强大表征。

假设要预测一句话里 10 个词的组合概率，每个词有 10 万种可能，那么总的组合数为 10万¹⁰——一个天文数字。训练语料再大，相对这个空间也极其稀疏：绝大多数合理的句子模型从未见过，概率只能估为 0。这就是"维度灾难"，是传统 n-gram 无法跨越的根本障碍，也正是 Bengio 试图用神经网络攻克的难题。

BPE 训练过程（Sennrich et al., arXiv:1508.07909）：从字符级开始，反复合并语料中出现频率最高的相邻符号对，直到词表达到目标大小。合并规则保存下来，推理时按同样规则切分。

示例："lower" "newer" "lower" → 统计发现 "er" 高频 → 合并为一个 token。最终常见后缀、词根都成为独立 token。

实践影响：API 按 token 计费，不同模型分词器不同（GPT 用 tiktoken/BPE 变体；中文一个字通常≈1 token，英文一个词≈1-2 token）。理解 token 是理解大模型"上下文长度""成本""速度"的基础。

朴素的 one-hot 编码：每个词用一个长度=词表大小（如 50000）的向量表示，只有自己位置是 1，其余全 0。

• 缺陷 1：维度爆炸且全稀疏。50000 维向量只有 1 个 1，浪费严重。
• 缺陷 2：所有词两两正交。任意两个 one-hot 向量的点积都是 0，模型完全无法表达"猫"和"狗"相似——语义信息为零。

分布式表示（Distributed Representation）：放弃 one-hot，让每个词用一个低维稠密向量（如 300 或 4096 维）表示，每一维都承载一部分语义。这就是 Bengio 在 NPLM（2003）中提出的革命性思想，也是所有现代词向量的基础。

整个词表所有词的向量堆在一起，构成一个词向量矩阵（Embedding Matrix），维度为 vocab_size × hidden_size。

实例：DeepSeek-V3 的 vocab_size=129280，hidden_size=7168，则词向量矩阵 = 129280 × 7168 ≈ 9.26 亿参数，约占 1.77 GB（bfloat16）。

查表（Lookup）过程：拿到 token ID（如 3472），直接去矩阵里取第 3472 行，就得到该词的向量。这就是"嵌入层（Embedding Layer）"做的事——本质是一个可学习的查找表。

现代大模型几乎都用第三种——词向量不再是"事先训好再加载"的外部资源，而是模型自身权重的一部分（存在 model.safetensors 里）。这也是为什么同一个词在不同大模型里的向量不同：它们是各自模型在自己的语料和目标下学出来的。

Kaplan et al.（arXiv:2001.08361, 2020）发现测试损失随参数量 N、数据量 D、计算量 C 近似服从幂律：

这意味着性能可外推预测——先在小规模上拟合曲线，就能预测千亿模型的 loss。这是 GPT-3 及后续军备竞赛的理论依据。

Chinchilla（Hoffmann et al., arXiv:2203.15556, 2022）修正了 Kaplan 的结论：在固定计算预算下，模型和数据应同步放大，最优训练 token 数约为参数量的 20 倍（20 tokens/parameter）。此前 GPT-3（175B 参数 / 300B tokens）严重欠训练。

DeepMind 用 70B 参数 + 1.4T tokens 训练的 Chinchilla 反超了 5 倍大的 Gopher（MMLU 67.5%，提升 7%+）。这一发现深刻改变了训练策略——大家不再一味堆参数，而是投入更多数据。

每个 MoE 层把传统的 FFN 替换为"门控路由 + 多个专家 FFN"：

门控网络 G 根据输入 x 决定激活哪几个专家。Switch Transformer（Fedus et al., arXiv:2101.03961）简化为每个 token 只路由到 1 个专家，扩展到万亿参数。

MoE 的挑战是负载均衡（避免所有 token 都涌向少数专家）和通信开销（专家分布在不同 GPU）。DeepSeek 提出的无辅助损失负载均衡（auxiliary-loss-free）是重要工程创新。

没有 KV Cache 时：生成第 N 个词，要重新计算前 N−1 个词的 K、V；生成第 N+1 个词，又要重新计算前 N 个词的 K、V……随着序列变长，重复计算量呈平方级增长，长文本几乎不可用。

有 KV Cache 后：历史词的 K、V 已缓存，每生成一个新词只需算这一个新词的 K、V 并追加进缓存，再用它的 Q 与缓存里所有 K 做注意力。每步计算量与序列长度无关（恒定），整体复杂度从二次方 O(n²) 降到线性 O(n)。

KV Cache 的总大小由五个因素决定：

• L = 序列长度（输入+输出总 token 数）
• N = Transformer 层数
• H = 注意力头数
• D = 每个头的维度
• 2 = K 和 V 两份
• sizeof(dtype) = 每个数占的字节数（float16 / bfloat16 = 2 字节）

实例（Llama-7B，单序列）（注：Llama-7B 为 MHA 架构，32 头全独立 K/V；GQA 从 Llama-2 70B 起才采用）：

注意：这只是单条序列的 KV Cache（尚未算模型参数本身）。若做批处理同时服务 32 个用户，仅 KV Cache 就要 67 GB——这正是大模型推理的显存大头。

TTFT（Time-To-First-Token，首 token 响应时间）：用户发出请求到收到第一个词的延迟，是体验的关键指标。TTFT 的主因是 Prefill 阶段——模型要一次性处理整段长上下文（prompt），计算所有 prompt 词的 K、V 并构建初始 KV Cache。prompt 越长，Prefill 越慢，TTFT 越高。

解码阶段（Decode）则相反：每步只算一个新词（得益于 KV Cache），单步很快，但逐步累积。

这三条限制，催生了下一节的 MQA/GQA（从结构上减少 K、V 数量）和第五篇的 PagedAttention（从内存管理上榨干显存）。

① RoPE 远端失效。现代大模型多用旋转位置编码（RoPE），其旋转角度差异随位置距离指数级衰减。当两词距离超出训练长度（如原设计 4096），远端 token 的旋转差异趋近于零，模型无法区分它们的位置关系，注意力得分失效。

② 注意力稀释（Attention Dilution）。softmax 归一化后，序列越长，每个位置分到的注意力权重越分散。极端情况下，关键信息被均摊到海量 token 上，权重趋近 1/n，模型对关键信息的捕捉能力随长度下降。

③ 显存 O(n²) 黑洞。注意力机制要存储 (batch, heads, seq_len, seq_len) 的注意力矩阵，显存随序列长度平方增长。设 seq_len=163840，单头注意力矩阵就约 53.7 GB，128 头总计约 6874 GB——远超任何单卡 GPU。即便用 FlashAttention 规避存储完整矩阵，计算量仍是 O(n²)。

训练时用较短长度（如 4096），推理时却想用更长上下文——这叫长度外推（Extrapolation）。主流方案：

• YaRN（Yet another RoPE extensioN）：在推理时调整 RoPE 的频率参数，临时扩展长度上限。代价是超出原训练长度后，准确率会下降约 5–20%。
• 滑动窗口注意力（Sliding Window）：每个 token 只关注最近 N 个 token（窗口大小 N ≤ max_position），而非全部。内存与序列长度无关，适合长文本流式推理（如 Mistral、LongFormer），但跨窗口的长程依赖会断裂。
• 分块处理（Chunking）：把超长文档切成多块分别处理，再合并结果。缺点是块间信息丢失可达 15–30%。

所以 max_position_embeddings 不是简单的数字设定，而是硬件算力、数据质量、算法创新三者的动态平衡点——既要给模型足够的能力空间，又要防止它被自身的计算重量压垮。

作为对比，DeepSeek-V3（671B 总参 / 37B 激活的 MoE 模型）的关键字段明显大一个量级：

注意：V3 还会有 MoE 相关字段（如 n_routed_experts 专家数、num_experts_per_tok 每 token 激活专家数），这是它总参 671B 但单次只激活 37B 的配置来源。

model.safetensors 里的参数精度可能是不统一的。原因有二：

• 混合精度训练（Mixed Precision Training）：为兼顾训练速度、显存占用与数值稳定性，现代模型训练时不同部分用不同精度——对精度敏感的部分（如注意力权重、损失计算相关）用 FP32，其余（如 FFN 权重）用 FP16/BF16。导出的权重文件里各张量自然精度各异。
• 量化部署：推理部署时为减小体积、加速，把部分或全部 FP16/BF16 权重进一步量化成 INT8/INT4。

要确认每个参数张量的真实精度，可以查看 config.json 的 torch_dtype（主精度），或用 HuggingFace Transformers 加载后遍历 model.named_parameters() 打印每个张量的 dtype。

Safetensors 是 HuggingFace 推出的一种安全、快速、简单的张量序列化格式，专门用来存储模型权重。

• 安全：传统 PyTorch 用 pickle 格式存权重，而 pickle 在反序列化时可能执行任意代码（加载来路不明的 .bin 模型有被植入恶意代码的风险）。Safetensors 只存张量数据，不含任何可执行代码，从根上规避了这一安全风险。
• 快速：采用零拷贝（zero-copy）加载，读取比 pickle 更快。

所以现在 HuggingFace Hub 上新模型默认用 .safetensors，.bin（pickle）格式正逐步被淘汰。

训练阶段，Adam 等优化器会为每个参数额外维护动量、二阶矩等状态（optimizer state），这些状态加起来体积与权重相当甚至更大。但 model.safetensors 里不存这些——原因很简单：

• 推理只需要权重。前向传播算出预测，靠的是 W, b 这些参数本身，优化器状态在推理时用不到。
• 优化器状态只在"继续训练"时需要。若要断点续训，会单独保存一个 optimizer.pt 之类的文件，与权重文件分离。

所以分发给用户做推理用的 model.safetensors 只保留做预测必需的权重，把与推理无关的训练状态全部剥离，让文件尽可能小、加载尽可能快。

RLHF 最大化奖励的同时，要防止模型为迎合奖励而"跑偏"（偏离原始语言能力），故加 KL 惩罚项：

其中 r_φ 是奖励模型打分，π_θ 是当前策略，π_SFT 是 SFT 模型，β 控制偏离程度。DeepSeek-R1 用的 GRPO（Group Relative Policy Optimization）是 PPO 的简化变体——免去价值网络，用组内相对优势估计，更省算力。

Wei et al.（arXiv:2201.11903）发现：在 few-shot 示例中加入推理过程，模型在算术、常识、符号推理任务上显著提升。本质是把复杂问题分解为多个简单步骤，每步的计算量增加，但每步更可靠。

R1-Zero 的突破（arXiv:2501.12948）：直接对基础模型做 RL（GRPO），用可验证奖励（数学题有标准答案）训练，不经过任何 SFT，推理能力就涌现——AIME 2024 pass@1 从 15.6% 提升到 71.0%（R1-Zero）；进一步加入少量冷启动数据的 R1 模型则达到 79.8%。这颠覆了"必须先 SFT 再 RL"的常识。

FlashAttention（arXiv:2205.14135）：注意力计算的瓶颈不是算力，而是GPU 高带宽内存（HBM）的读写（IO）。FlashAttention 用分块（tiling）+ 在线重缩放，把中间结果尽量留在高速 SRAM 中，减少对慢速 HBM 的读写。结果完全精确（exact attention），却快数倍、省数倍显存。几乎所有现代大模型推理都用它。

LoRA（Low-Rank Adaptation, arXiv:2106.09685）：微调时冻结原权重 W₀，只训练一个低秩更新：

若原矩阵是 4096×4096（1600 万参数），取 r=8 则 B、A 共 (4096+4096)×8 ≈ 6.5 万参数，可训练参数减少 99%+，显存和算力大幅下降，而效果接近全参数微调。这是个人/小团队微调大模型的标准方法。

把浮点值 F.P. 量化成整数，再用整数反量化回浮点值：

逐步拆解（以把 [−1.0, 1.0] 范围的浮点数量化到 [−128, 127] 的 INT8 为例，取 Scale = 1/127、Zero-point = 0）：

• 浮点数 0.5 → 除以 Scale：0.5 / (1/127) = 63.5
• 加 Zero-point：63.5 + 0 = 63.5
• 四舍五入（round）→ 得到量化整数 64
• 反量化：(64 − 0) × (1/127) = 0.5039…（与原始 0.5 接近，但有舍入误差）

这个舍入误差就是量化"轻微精度损失"的来源。Scale 选得越贴合一组数据的真实分布范围，误差越小。

根据 Zero-point 是否为 0，量化分两类：

• 对称量化（Symmetric）：Zero-point = 0，即浮点的 0 量化的整数也是 0。整数范围关于 0 对称（如 INT8 用 [−128, 127]）。计算简单、反量化快，适合分布大致关于 0 对称的权重。
• 非对称量化（Asymmetric）：Zero-point ≠ 0，允许整数范围整体偏移以贴合分布不以 0 为中心的数据（如激活值常全为正）。精度更好，但量化/反量化多一次加法。

实践中，权重多用对称量化（分布对称、省算），激活/KV Cache多用非对称或细粒度量化（分布偏移大、需精拟合）。

• 内存碎片：不同请求序列长度不同，且会动态增长/结束，显存里很快布满零散小块。即使总剩余显存够，也找不到足够大的连续块给新请求，触发 OOM（显存不足）。
• 预分配浪费：为避免上述问题，常按"最大可能长度"预分配，但绝大多数请求用不满，造成大量闲置。
• 批处理填充（padding）浪费：一个批次里所有序列必须填充到最长序列的长度，短请求被迫陪跑，算力和显存双重浪费。

实测中，这些浪费可使显存利用率低至 20–40%——大多数显存不是被有效数据占用，而是被碎片和 padding 吃掉了。

核心思想（Kwon et al., vLLM, arXiv:2309.06180）：KV Cache 不再要求一整块连续显存，而是由许多固定大小的小块（Block / Page）组成，这些块可以分散在显存的任意位置。每条请求通过一张"逻辑→物理"映射表记录自己用了哪些物理块。

带来的三大收益：

• 消除碎片：显存利用率几乎拉满，几乎无浪费，OOM 大幅减少。
• 动态扩展：序列按需增长，无需预分配最大长度。
• 更大批处理量：同批可高效混跑不同长度的请求，无需 padding，吞吐显著提升。

写时复制（Copy-on-Write）共享前缀：多条请求常共享相同前缀（如同一个 system prompt）。PagedAttention 让它们共享同一批物理 Block，只有当某条请求开始生成自己独有的内容时，才复制出新 Block。这在多用户服务同一基础指令时省下大量显存。