1. 预训练模型框架的三种理解：

理解层次	指的是什么	典型代表
① 范式层面	"预训练→微调"这套训练流程	BERT / GPT 开创的两阶段范式
② 架构层面	模型内部的网络结构	Transformer 架构
③ 工程层面	训练/调用模型的软件工具	PyTorch / Transformers / DeepSpeed

1.1 范式层面（最常被问到的）

预训练指的是一套两阶段训练体系：

阶段1 预训练 (Pre-training)
  用海量通用语料（维基、网页、书籍）训练模型
  目标：学会语言本身——语法、常识、推理能力
  类比：通识教育（读万卷书）

阶段2 微调 (Fine-tuning)
  用少量任务数据（问答对、对话记录）继续训练
  目标：学会特定任务——客服、翻译、写代码
  类比：岗位培训（入职后定向培养）

一句话：预训练模型 = 读过万卷书的应届生，微调 = 针对性岗前培训。 所有主流大模型（GPT、Qwen、DeepSeek、LLaMA）都跑在这套范式上。

1.2 架构层面

主流预训练模型的骨架都是 Transformer：

输入 → Embedding → 多层 Transformer Block → 输出
                        ↓
         每层 = 注意力机制 + 前馈网络 + 残差连接

类比：模型框架 = 工厂生产流水线的图纸。每一层干什么、怎么连接，就是"架构"。

1.3 工程层面（最容易混淆）

框架	作用	遇到场景
PyTorch	深度学习底层计算库	写训练/推理代码的根基
Transformers (HF)	模型仓库 + 统一接口	一行代码加载 GPT/Qwen
DeepSpeed	分布式训练优化	训练千亿参数大模型
Megatron-LM	大规模并行训练	英伟达系训练框架
LLaMA-Factory	微调工具箱	自己微调模型时
LangChain	应用层框架（不负责训练）	把模型包装成 Agent 工具链

工程层代码示例：

from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B")
# 一行代码，加载别人"预训练好的模型"

---

2. GPT 预训练原理：为什么猜词能学到通用知识

2.1 一句话回答

GPT 预训练只做一件事：读海量文本，反复练习"猜下一个词"。猜得多了，文本里蕴含的所有规律（语法、事实、逻辑、常识）就被迫压缩进了模型的参数里——这就是通用知识的来源。

关键不是"猜词"任务本身，而是"猜词"是一个必须动用全部知识才能做对的任务。

2.2 预训练任务

给定前文，预测下一个词的概率：

  "今天天气真___"  →  好: 0.7   差: 0.2   桌子: 0.01 ...

预测错了 → 计算 loss（惩罚）
预测对了 → loss 变小（奖励）

用"下山"类比：loss 是海拔，训练就是沿着梯度一步步往山谷走，每猜错一次就调整一步参数。语料有 3000 亿个 token，模型就走 3000 亿步"下山"。（宏观角度）

2.3 为什么"猜词" = 学知识

核心逻辑：你猜不对一个词，说明你不懂背后的规律；为了每次都猜对，模型被迫学会规律。

例子	要猜的词	被迫学会的知识
I ___ to school yesterday	went	语法：过去时
The capital of France is ___	Paris	事实：法国首都=巴黎
It rained, so the ground is ___	wet	逻辑：因果推理
You should ___ before crossing the road	look	常识：过马路先看

规律：每个需要猜的词，背后都对应一条知识。"猜词"就是一场考试，语料就是题库，模型为了拿高分（loss 最小）被迫学会题库里的所有规律。

2.4 知识存在哪：参数里

知识不是存在"记忆文件"里，而是分散存储在几千亿个权重参数中：

知识类型	存储方式	类比
语法规则	注意力机制学会"哪些词该互相看"	句子成分搭配习惯
事实知识	前馈网络层的参数	"法国→巴黎"的接线
上下文关联	注意力权重	查字典的索引
推理链条	多层网络的组合	多步思考的电路

GPT 的"记忆"是模糊的——知识被压缩成了参数，而不是逐字抄写。

2.5 为什么是"通用"知识

原因1：语言是知识的载体。 人类几千年的知识——科学、历史、法律、代码、菜谱——绝大部分以文本形式存在。学会了人类语言，就等于读完了人类知识库的索引。

原因2：压缩即智能（Compression = Intelligence）。 一个能完美预测下一个词的模型，其内部压缩表示必须覆盖：词义、语法、事实、逻辑、常识、代码规则。任何一条没掌握，总有一类句子它会猜错。

类比：语料是"压缩包"，模型参数是"解压器"。预训练就是让解压器不断逼近完美——完美的解压器必然完整理解了压缩包里的全部信息。

2.6 规模与涌现

BERT 2018 年就在用这套思路，为什么 GPT 在 2023 年爆发？因为三个规模一起涨：

规模	作用
数据规模	知识覆盖面变广（读过更多书）
参数规模	单条知识存得更精细（记性更好）
算力规模	能完成更大步数的下山（训练更充分）

越过临界点后出现涌现：从"表面统计"（看到 France 就联想 Paris）变成"抽象概念"（推理、规划、举一反三）。就像学生刷题到一定程度，从"背答案"变成"会方法"。

2.7 总结图

海量文本（人类知识压缩包）
    │  预训练：猜下一个词 × 3000亿次
    ▼
参数更新（下山 3000 亿步）
    │
    ▼
权重中沉淀了语法/事实/逻辑/常识
    │
    ▼
= 通用知识（可被微调调用、被对话激活）

一句话：GPT 不是"被教了知识"，而是"为了猜对每一个词，
被迫自己从文本里提炼出了知识"。

---

3. 微观理论：一次学习的三步曲

3.1 宏观 vs 微观对照

宏观（下山类比）	微观（数学理论）
一座损失函数山	每个样本算出一个 loss 标量
山 = 所有样本的平均	L = (1/N) Σ loss_i
走一步	W ← W - η·∇L
找谷底	所有参数梯度 → 0
学知识	权重矩阵里的关联强度变化

微观层面，一次"学习"就是三个动作：前向传播 → 反向传播 → 参数更新，循环万亿次。

3.2 微观三步曲

① 前向：输入 → 层层计算 → 输出概率 → 算 loss
② 反向：用链式法则，把 loss 的"责任"逐层分摊到每个参数
③ 更新：每个参数沿负梯度方向挪一小步

三个公式就是全部微观理论：

  前向    loss = -log P(正确答案)
  反向    dL/dW = (dL/dz) · (dz/dW)     ← 链式法则
  更新    W ← W - η · dL/dW             ← 下山那一步

3.3 手算例子：教模型"猫→追"

设定：词表 3 个词 {猫(0), 追(1), 老鼠(2)}，最简模型：

P(下一个词|猫) = softmax(W · onehot(猫))
W 是 3×3 矩阵，W 第 i 行 = "从词 i 出发的转移向量"

初始化：W = 0（什么都没学）。训练样本：“猫 追”。

第 1 次前向：

输入 猫 → onehot [1,0,0] → logits = W第0行 = [0, 0, 0]
softmax([0,0,0]) = [1/3, 1/3, 1/3]   （三选一，纯蒙）
正确答案是"追"(下标1)：
loss = -log(1/3) = 1.10

第 1 次反向：

dL/dz = 预测概率 - 正确答案onehot
      = [1/3, 1/3, 1/3] - [0, 1, 0]
      = [1/3, -2/3, 1/3]

解读：模型觉得"追"的概率太低(1/3)，梯度在"追"位置是负的(-2/3)，
意思是：把"追"的概率推上去，把另外两个压下来。

梯度只落在 W 的第 0 行（因为输入是"猫"）：
dL/dW[0] = [1/3, -2/3, 1/3]

第 1 次更新（η = 0.1）：

W[0] ← W[0] - 0.1 × [1/3, -2/3, 1/3]
     = [0,0,0] - [0.033, -0.067, 0.033]
     = [-0.033, +0.067, -0.033]

再走一次前向验证：

logits = [-0.033, +0.067, -0.033]
softmax：e^-0.033=0.967，e^0.067=1.069，e^-0.033=0.967
P(追) = 1.069 / (0.967+1.069+0.967) = 0.356
loss  = -log(0.356) = 1.03

结果：P(追) 从 0.333 → 0.356，loss 从 1.10 → 1.03。
一次训练，模型就朝正确方向挪动了一点点。

3.4 知识如何写进权重：关联强化

关键观察：更新后的 W[0] = [-0.033, +0.067, -0.033]，第 1 列（“追”）是唯一正的。这条知识——“猫后面跟追”——在微观上就长这样：一行权重里某一列被推高了。

反复训练 1 万次（语料里"猫追"出现 1 万次）：
每次梯度都在"追"这一列加一点，其他列减一点
→ 第 1 列被反复推高，最终形成强关联
→ 知识从"一次微弱证据"变成"稳定记忆"

微观本质 = 关联强化（水流冲刷类比）：
  同一组参数反复收到同一方向的梯度 → 权重累积（记忆形成）
  梯度方向相反 → 权重抵消（遗忘/干扰）

微观上，学习 = 统计意义上的重复强化。"猫追老鼠"出现 1 万次，权重变化是单次的 1 万倍；出现 1 次的知识基本留不下痕迹。

3.5 Transformer 各部件的微观角色

部件	微观上在做什么
注意力层	Q·Kᵀ 算相似度打分，softmax 选"该看谁"，再对 V 加权求和 = 把相关 token 的信息搬运过来（动态信息检索）
前馈网络 FFN	两段线性变换+激活，常被解读为 key-value 记忆存储（知识的主要仓库）
残差连接	给梯度一条"高速通道"直达浅层，防止深层梯度消失
LayerNorm	稳定每层数值分布，防止训练发散

宏观上"模型在猜词"，微观上它做两件事的组合：注意力负责"从上下文里找线索"，FFN 负责"从参数记忆里调知识"——两者叠加，才算出下一个词的概率。

3.6 三个宏观现象的微观解释

宏观现象	微观解释
为什么需要海量语料	单次权重更新量 ≈ η × 梯度 ≈ 10⁻⁴ 量级；一条知识要靠成千上万次同向梯度累积。语料少 = 冲刷次数不够 = 学不牢
为什么记忆是"模糊"的	知识分布式编码在几十亿参数中共同表达，回答时近似检索，相近概念互相串扰 → 张冠李戴、幻觉
为什么会遗忘（灾难性遗忘）	新旧模式竞争同一组参数，新梯度与旧权重方向相反，互相抵消 → 旧知识被"冲平"

3.7 宏观 ↔ 微观对照表

下山类比（宏观）	微观理论
整座山	Σ所有样本的 loss（一个标量场）
站在山顶	loss 很大，预测全靠蒙
往谷底走一步	W ← W - η·∇L（挪一小步）
梯度方向	dL/dW：哪个参数该增、该减
走到谷底	所有参数梯度 ≈ 0，loss 最小
学会知识	权重矩阵形成稳定的关联结构
走错路/绕弯	梯度噪声、局部极小、学习率过大

宏观上模型"下山找谷底"，微观上每一次都是"算概率 → 算误差 → 把误差按链式法则分摊给每个参数 → 每个参数朝正确方向挪 10⁻⁴ 那么一点点"。万亿次这样的微观动作累加，就是"预训练学到了知识"。

---

4. 上下文窗口：由什么技术决定

4.1 四因素总览

上下文不是由某一个技术决定的，而是被四件事共同卡住：

因素	卡住的是什么
注意力复杂度	算力（O(n²)，平方爆炸）
KV Cache	显存（每多一个 token 都要存东西）
位置编码	模型"知不知道谁先谁后"
训练数据长度	模型"见过多长的上下文"

4.2 核心矛盾：注意力是 O(n²) 的

Transformer 注意力机制中，每个 token 都要和序列里所有其他 token 计算相关度：

序列长度 n → 计算量 ∝ n²

Copy

注意力矩阵元素数量（n²）及显存占用（fp16）：

序列长度	注意力矩阵元素	显存占用
4K	1670万	33 MB
32K	10.7亿	2.1 GB
128K	168亿	33 GB
1M	——	2 TB（爆了）

128K 上下文时，光注意力矩阵就要 33GB 显存，一张 A100(80G) 就快被吃光了——这还只是临时计算数据，没算模型参数。

类比：让 128K 个人开会，每个人都必须和另外 128K 个人逐一握手——握手次数是 128K 的平方。这就是"上下文越长，越贵"的数学根源。

破解方向：

• FlashAttention：优化计算与显存搬运，让 O(n²) 在工程上可行
• 稀疏注意力：只和附近及少数重要 token 算（Mistral 的滑动窗口）
• 线性注意力 / Mamba：理论可无限长

4.3 推理时的直接瓶颈：KV Cache

生成每个新 token 时，模型都要"重新读一遍"前面所有 token。为了不重复计算，工程上把每个历史 token 的 K 和 V 向量缓存下来——这就是 KV Cache。

类比：开会时有人做会议纪要，每个发言人都记一行，方便随时翻。

KV Cache 显存随上下文线性增长：

公式：每 token ≈ 2 × 层数 × 组数 × 头维度 × 2字节

以 32 层、8 组、128 维、fp16 为例：
每 1 个 token  ≈ 128 KB
32K 上下文     ≈ 4 GB
128K 上下文    ≈ 16 GB   ← 光纪要就占 16G 显存

破解方向：

• GQA / MQA（分组查询注意力）：KV 显存直接除以 4~8，如今所有主流模型标配
• KV 量化：压缩缓存精度省显存

4.4 位置编码：决定"懂不懂顺序"

注意力本身"不分先后"——它只知道"谁和谁有关"，不知道谁在前谁在后。"猫咬狗"和"狗咬猫"对它没区别。所以必须给每个 token 编位置号，这就是位置编码。

位置编码技术	特点
正弦位置编码	原始方案，序列一长就乱
RoPE（旋转编码）	主流方案，带相对位置信息，天然支持一定外推
YaRN / NTK 插值	把训练时 4K 的位置编号"拉伸"到 128K，无需重训就能扩上下文

关键点：很多模型发布后"上下文升级"（8K → 128K），靠的是位置编码插值 + 少量长文本继续训练，而不是推翻重来。

4.5 训练数据：上下文是"练"出来的

模型推理时能处理的上下文，基本不会超过训练时见过的序列长度：

GPT-3 训练序列 2K  →  上下文 2K
Claude 训练到 200K →  上下文 200K

道理：从来没读过超过 4K 字的长文，突然给 128K 字的文章让总结，注意力机制不知道该怎么处理那么远的依赖关系——它没"见过"这种距离。

所以长上下文能力 = 训练阶段用长序列 + 语料里有足够多的长文本。这是数据工程问题，不只是算法问题。

4.6 技术演进时间线

时间	技术	上下文量级
2017 BERT	原始注意力	512
2020 GPT-3	原始注意力	2K
2022 ChatGPT	+ 更好的训练	4K~8K
2023 GPT-4	+ FlashAttention	8K~128K
2023-24	长上下文之战：GQA/RoPE/YaRN	Claude 200K、Gemini 1M~2M
未来	Mamba/线性注意力	理论无限

每一步涨的都是四个因素里的一两个，没有一个技术能单独解决全部四个瓶颈。

4.7 总结图

想扩大上下文，四道关卡依次过：

① 训练数据：语料里得有长文（数据）
② 位置编码：RoPE + 插值，让模型懂长距离顺序（算法）
③ 注意力：FlashAttention / 稀疏化，压住 O(n²)（算力）
④ KV Cache：GQA / 量化，省显存（硬件）

一句话：上下文 = 算力(注意力平方) + 显存(KV cache) +
        算法(位置编码) + 数据(训练长度) 四者的最小值。
        哪一块最短，上下文就被卡在哪。

---

5. 核心公式速查表

概念	公式 / 数值
交叉熵损失	loss = -log P(正确答案)
反向传播	dL/dW = (dL/dz) · (dz/dW)（链式法则）
参数更新	W ← W - η · dL/dW
注意力复杂度	O(n²)，n = 序列长度
KV Cache 每 token	≈ 2 × 层数 × 组数 × 头维度 × 2字节
单次权重更新量	≈ η × 梯度 ≈ 10⁻⁴ 量级
模型参数量 ↔ 显存	1B 参数 fp16 ≈ 2GB（推理）

---

1.上下文计算？

    用上轮公式反推，取决于模型结构（层数 L、GQA 组数 G）：

      每 token KV = 2 × L × G × H × 2字节

      结构 A（64层, 8组, 128维）: 256 KB/token
        870GB ÷ 256KB ≈ 3.3M tokens（约 3M 上下文）

      结构 B（96层, 16组, 128维）: 768 KB/token
        870GB ÷ 768KB ≈ 1.1M tokens（约 1M 上下文）✓ 更符合主流

      结构 C（80层, 8组, 128维）: 320 KB/token
        870GB ÷ 320KB ≈ 2.7M tokens

    也就是说：如果 K3 的模型是 96 层 + GQA 16 组，
    870GB KV 正好对应约 1M 上下文的超长窗口——这个量级
    和"2.8T 参数 + 1M 上下文"的产品定位是吻合的。

---