想象一家大型出版社的流水线：一位资深编辑坐在桌前，不是一次性写完一本书，而是逐字逐句地往后推。每写下一个词，他的目光就落在刚写完的那个词上，心里默念：“根据我目前写下的所有内容，下一个最合适的词会是什么？”他随手写下，然后重复这个过程，直到整篇文章完成。这家出版社在开工前还会做一件重要的事——从仓库里调来海量书籍作为“参考素材”，编辑们通读这些书，捕捉语言使用的规律、词语搭配的习惯，这个过程叫“预训练”。而这位编辑的“逐字写作法”，就是我们要聊的自回归语言模型。它正是ChatGPT、GPT-4等大模型能够“妙语连珠”的核心秘密。

岗位关联

理解GPT自回归预训练，你就掌握了当今大语言模型的技术底色。无论你是要做模型训练、微调还是推理优化，这都是一切工作的起点。

目录
  1. 可视化演示
  2. 自回归原理
  3. 因果掩码机制
  4. 交叉熵损失
  5. 训练数据配比
  6. Token化处理
  7. Scaling规律
  8. 工程训练流程
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

本节配有交互动效（进入视口后自动加载，约 3KB）。

自回归原理

出版社的编辑开始动笔了。他面前摆着一张白纸，他写下第一个词，然后停下来，看着这个词，在心里琢磨：“根据我对语言的了解，下一个词最可能是什么？”他写下第二个词，再看看前两个词，继续推测第三个。就这样，他一个字一个字地往下写，每一步都只依据已经写下的内容来做决定。这种“看着前文写后文”的方式，就是自回归（Autoregressive）的本质——用过去预测未来，用已知推断未知。

在技术世界里，自回归语言模型做的事情和这位编辑一模一样。给定一个词序列 $x_1, x_2, \ldots, x_T$，模型的目标是学习一个概率分布 $P(x_t | x_1, x_2, \ldots, x_{t-1})$，即在已知前 $t-1$ 个词的条件下，预测第 $t$ 个词出现的概率。整个句子的概率可以通过链式法则分解为每个位置上条件概率的乘积：

训练时，模型的输入是完整的句子，但每个位置只能看它前面的词。这与人类写作的方式完全一致——我们不可能先读到句尾再决定开头写什么。正因为这种单向的、从左到右的生成模式，自回归模型也被称为“单向语言模型”。它的优势在于训练目标简单直接：就是最大化真实语料中所有句子的概率。

这种“逐字写稿”的模式有两个重要特性。第一，生成过程天然是序列化的——从第一个词开始，一个一个往后推，直到遇到结束符。第二，模型在训练时见过的所有pattern（前文预测后文）与推理时的行为完全一致，不存在训练与推理的“模拟考”与“实战”偏差。这让自回归架构成为当前大语言模型的主流选择。

P(x1,x2,…,xT)=∏t=1TP(xt∣x1,x2,…,xt−1)\displaystyle P(x_1, x_2, \ldots, x_T) = \prod_{t=1}^{T} P(x_t | x_1, x_2, \ldots, x_{t-1})
这个公式把“生成一个句子”这个大任务，拆解成了“逐个预测下一个词”的小任务。每个小任务只看前文，不看后文。
  1. 链式分解把整个句子出现的联合概率，拆成每个词依次出现的条件概率的连乘
    P(x1,x2,…,xT)=∏t=1TP(xt∣x1,x2,…,xt−1)P(x_1, x_2, \ldots, x_T) = \prod_{t=1}^{T} P(x_t | x_1, x_2, \ldots, x_{t-1})
  2. 条件概率在已知前面所有词的条件下，当前位置词的概率
    P(xt∣x1,x2,…,xt−1)P(x_t | x_1, x_2, \ldots, x_{t-1})
  3. 连乘符号$T$ 个条件概率相乘，得到整句概率
    ∏t=1T\prod_{t=1}^{T}

因果掩码机制

编辑有个神奇的习惯：他在看手稿时，会拿一把尺子挡住还没有写的部分。他只看已经写出来的文字，绝不偷看未来的内容。这并不是什么道德洁癖，而是为了保证自己在写作时不会不经意间“泄露天机”——如果写作时偷看了后文，那预测下一个词的能力就是假的，真到了独立创作时就会露馅。

对于Transformer来说，这把“挡住未来的尺子”就是因果掩码（Causal Mask）。在自注意力计算中，模型需要计算每个词与其他所有词的相关性。但在自回归模型里，位置 $i$ 的词只能attend到位置 $\le i$ 的词。具体做法是在注意力分数矩阵上叠加一个掩码矩阵：下三角部分为0（允许查看），上三角部分为 $-\infty$（禁止查看）。

因果掩码的引入让Transformer从“双向理解”变成了“单向生成”。这听起来像是一种限制——模型明明有能力看到全文，为什么要自废武功？答案在于“一致性”。回想那位编辑，如果他在训练（练笔）时总是偷看后文，那么他的“预测能力”是虚的；真正开始写作（推理）时，后文还不存在，他立刻原形毕露。因果掩码确保训练与推理的行为完全一致，让模型学到的能力在实战中真实可用。

掩码机制还带来一个重要的副产品：训练效率的提升。因为在训练时，每个样本可以同时构造出 $T$ 个“前缀-下一个词”的训练对。例如句子“我爱学习”，可以同时产生“我→爱”、“我爱→学”、“我爱学→习”三组监督信号，一组数据当多组用，这在数据稀缺的年代是巨大的优势。

Attention(Q,K,V)=softmax(QK⊤+Mdk)V,Mij={0if j≤i−∞if j>i\displaystyle \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^\top + M}{\sqrt{d_k}}\right)V, \quad M_{ij} = \begin{cases} 0 & \text{if } j \le i \\ -\infty & \text{if } j > i \end{cases}
掩码矩阵 $M$ 就是那把“尺子”，它把未来位置的注意力分数变成负无穷，经过softmax后概率为0，模型就“看不到”未来了。
  1. 注意力计算Query与Key的点积除以 $\sqrt{d_k}$ 得到注意力分数
    QK⊤dk\frac{QK^\top}{\sqrt{d_k}}
  2. 叠加掩码分数矩阵加上掩码矩阵 $M$，未来位置变成 $-\infty$
    QK⊤+Mdk\frac{QK^\top + M}{\sqrt{d_k}}
  3. softmax归一化掩码位置的 $-\infty$ 经过softmax后概率为0
    softmax(QK⊤+Mdk)\text{softmax}\left(\frac{QK^\top + M}{\sqrt{d_k}}\right)

交叉熵损失

编辑的出版社有一个严格的质检流程。编辑每写完一个词，质检员就会对照“标准答案”（真实语料中的下一个词）来核对他的预测。如果编辑的预测和标准答案一致，就轻轻点头；如果偏离了，就记下偏差大小，回头让编辑调整。这个“核对偏差并反馈调整”的过程，在机器学习中就是损失函数与反向传播。

GPT预训练采用的损失函数是交叉熵（Cross-Entropy）。在每个位置上，模型输出一个词表大小的概率分布 $\hat{y}_t$，而真实词 $x_t$ 被编码为one-hot向量 $y_t$。交叉熵损失衡量这两个分布之间的差异：

因为one-hot向量中只有真实词位置为1，交叉熵实际上可以化简为 $-\log \hat{y}_{t, x_t}$——也就是真实词对应概率的负对数。当模型对真实词的预测概率是0.5时，损失是 $\log 2 \approx 0.693$；当概率逼近1时，损失趋近0；当概率只有0.1时，损失高达2.3。

这个损失函数与“困惑度”（Perplexity）直接相关：$\text{PPL} = \exp(\mathcal{L})$。困惑度可以理解为人话就是“模型在预测下一个词时，平均有多少个候选词让它拿不准”。PPL为50意味着模型平均在50个词之间犹豫，PPL为10则意味着只在10个词之间犹豫。PPL越低，模型对语言的把握越精准。

L=−1T∑t=1T∑v=1Vyt,vlog⁡y^t,v\displaystyle \mathcal{L} = -\frac{1}{T}\sum_{t=1}^{T}\sum_{v=1}^{V} y_{t,v} \log \hat{y}_{t,v}
这个公式可以理解为：对于每个真实出现的词，我们希望模型给它分配的概率尽可能接近1。概率越接近1，损失越小；概率越接近0，损失越大。
  1. 真实词编码第 $t$ 个位置的真实词用one-hot向量表示，只有真实词位置为1，其余为0
    yt,v={1if v=xt0otherwisey_{t,v} = \begin{cases} 1 & \text{if } v = x_t \\ 0 & \text{otherwise} \end{cases}
  2. 逐位置交叉熵对每个位置，取真实词对应位置的概率的对数的负值
    −yt,vlog⁡y^t,v-y_{t,v} \log \hat{y}_{t,v}
  3. 对所有位置取平均将 $T$ 个位置的损失相加后除以 $T$
    −1T∑t=1T∑v=1Vyt,vlog⁡y^t,v-\frac{1}{T}\sum_{t=1}^{T}\sum_{v=1}^{V} y_{t,v} \log \hat{y}_{t,v}

训练数据配比

出版社建了一座巨大的“素材仓库”。这里存放着从世界各地搜罗来的书籍、文章、网页、代码——既有文学名著，也有技术文档，还有数不清的网页评论。但素材并非简单地堆在一起。经验丰富的总编知道：不同来源的素材质量天差地别。精装书籍的文字经过反复校对，是高质量“教材”；而某些网页评论可能语法混乱、内容重复，属于“噪声”。总编的做法是：好书多读，烂书少读，垃圾弃读。

GPT类模型的预训练数据配比遵循同样的逻辑。Common Crawl这类网页抓取数据量最大但质量参差，需要经过严格的清洗和过滤；书籍和维基百科等高质量文本虽然量少，但因为语言规范、信息密度高，会被提升采样权重。实际训练中，一个典型的配比可能是：网页数据占60%，书籍占20%，代码占15%，其他学术文本占5%。

数据的质量过滤是决定模型上限的关键一环。研究者们发明了各种“筛子”：用困惑度过滤低质量文本（质量差的文本通常语言模式混乱，PPL偏高）、用MinHash算法做去重（防止同一内容反复出现导致过拟合）、用分类器判断文本是否属于“低质量”类别。这些环节合在一起，让最终进入训练管道的数据“既多又精”。

配比策略背后还有一个深刻的洞察：模型的知识结构取决于它读过的书。如果一个模型读的网页数据太多、书籍太少，它可能更擅长闲聊但逻辑推理能力偏弱；如果代码比例过低，它的编程能力就会受限。数据配比，本质上是在决定一个模型“偏科”还是不偏科。

Token化处理

出版社的素材库有个特殊的管理制度：所有书籍都被切成了“知识卡片”。每个卡片上有一个常用词组或单词，比如“人工智能”是一个卡，“machine learning“是另一个卡。卡片的规格有限——最小的卡片是一个字，最大的卡片是一个完整的常见短语。切片的标准是”常用优先”，越常见的组合越倾向切成一张卡，这样整本书可以被高效地表示成一小叠卡片。

在GPT中，这个“切卡片”的过程就是Token化，具体算法叫BPE（Byte Pair Encoding）。BPE从字符级别开始，统计语料中相邻字符对的出现频率，将最高频的字符对合并为一个新“子词”，然后重复这个过程，直到达到预设的词表大小。例如，“low“和”lower“共享前缀”low“，BPE可以将它们分成”low“和”er”，而不是当成完全无关的词。

词表大小的选择是一个权衡的艺术。词表太小（如5K），每个词可能被拆成多个Token，序列变长，计算量增大；词表太大（如256K），Embedding矩阵和输出层会占用大量内存，且低频Token学不好。GPT-2用了50K词汇，GPT-3用了96K词汇（GPT-3的词表大小实际为50257，后扩展至96256），基本都是几十万量级。这个量级在不显著增加参数的条件下，能较好平衡序列长度和表示精度。

Pair(a,b)=argmax(a,b)Count(ab)⇒Merge(a,b)=ab\displaystyle \text{Pair}(a, b) = \text{argmax}_{(a,b)} \text{Count}(ab) \quad \Rightarrow \quad \text{Merge}(a, b) = ab
BPE不断合并最高频的字符对。合并次数越多，词表越大，每个Token的信息量也越大。
  1. 统计共现扫描语料，找出所有相邻字符对的频率
    Count(a,b)=#{(a,b) appears in corpus}\text{Count}(a, b) = \#\{(a, b) \text{ appears in corpus}\}
  2. 选择最高频每次选择出现次数最多的字符对
    argmax(a,b)Count(ab)\text{argmax}_{(a,b)} \text{Count}(ab)
  3. 合并更新将选中的字符对合并为一个新Token，更新语料
    Merge(a,b)→ab\text{Merge}(a, b) \rightarrow ab

Scaling规律

出版社社长发现了一个惊人的规律：每当他们让编辑读更多书、把编辑培养得更专业（模型更大），稿件的整体质量都会稳定提升，而且这种提升遵循一条可预测的曲线。更重要的是，读更多书和培养更专业的编辑，两者必须同步进行——只让编辑读更多书却不提升他的能力，效果会大打折扣。

这就是Scaling Law的核心发现。OpenAI在2020年的论文《Scaling Laws for Neural Language Models》中总结：测试损失（即预训练困惑度）与模型参数量 $N$、训练数据量 $D$、计算量 $C$ 之间存在幂律关系：

这些幂律指数告诉我们一个重要的“预算分配”原则：当计算预算增加10倍时，最优的做法是让模型参数量增加约5倍，训练数据量只增加约1.8倍——模型要大一点，数据多一点，但模型增长得更快。这解释了为什么GPT系列的参数量从1.17亿（GPT-1）到1750亿（GPT-3）一路狂奔，而训练数据的增长相对温和。

Scaling Law还揭示了一个令人深思的结论：在数据量固定的情况下，继续增大模型参数带来的收益是递减的。这意味着“堆参数”不是万能药。近年来的研究中，很多工作开始注重在数据质量上做文章——同样的参数规模，用更高质量的数据训练，效果可以超越盲目扩大参数。理解Scaling Law，就是理解了“规模”这把双刃剑：它带来了性能的确定性提升，但也带来了对齐、推理成本等新挑战。

L(N,D)=(Nmin⁡N)αN+(Dmin⁡D)αD+Lmin⁡\displaystyle L(N, D) = \left(\frac{N_{\min}}{N}\right)^{\alpha_N} + \left(\frac{D_{\min}}{D}\right)^{\alpha_D} + L_{\min}
模型的性能（损失）随着参数和数据量的增大而以幂律方式下降。这就像说：编辑能力翻倍，稿件质量会稳定提升，但提升幅度逐渐变小。
  1. 参数量项损失随参数量 $N$ 增大以幂律降低，指数为 $\alpha_N$
    (Nmin⁡N)αN\left(\frac{N_{\min}}{N}\right)^{\alpha_N}
  2. 数据量项损失随数据量 $D$ 增大以幂律降低，指数为 $\alpha_D$
    (Dmin⁡D)αD\left(\frac{D_{\min}}{D}\right)^{\alpha_D}
  3. 不可约损失$L_{\min}$ 是理论上限，即使无限增大规模和数据也无法突破
    Lmin⁡L_{\min}

工程训练流程

一切理论准备就绪，出版社要开工了。车间里排着一长串编辑工位——这就是GPU集群。原始文本数据从仓库中取出，先经过清洗（去除HTML标签、乱码、敏感信息），再切成标准大小的Token块（通常是2048或4096个Token），组成训练批次。模型参数被初始化，优化器（AdamW）准备就绪，学习率调度器设置了预热（warmup）然后余弦衰减。一声令下，训练开始。

GPT-3级别的模型参数量达到1750亿，训练消耗数千Petaflop/s-days的计算量，单卡训练根本不现实。工程上必须依赖分布式并行策略：

  • 数据并行：多张卡各持一份完整模型副本，分吃不同的数据批次，梯度汇总更新
  • 张量并行：把单层参数切分到多张卡上，共同计算一个大矩阵乘法
  • 流水线并行：把模型层数分段，卡与卡之间像流水线一样接力计算

硬件层面，混合精度训练（FP16/BF16）是标配。半精度不仅减少了显存占用（从FP32的4字节降到2字节），还让矩阵计算在GPU Tensor Core上获得数倍加速。但半精度需要注意数值稳定性——梯度下溢和损失尖峰是常见问题，实践中需要在损失函数中加缩放因子，或用BF16这种动态范围更大的格式。

训练过程中的监控同样关键。工程师们盯着训练曲线：“loss是否在平滑下降？”“梯度范数是否异常爆炸？”“学习率是否需要温重启？”这些细节决定了训练能否稳定地完成。调试阶段，先用小模型（如125M参数）在小数据上跑通，再上大模型（如GPT-3级别的1750B）的“缩放实验”，是工程实践中的标准操作。

当训练完成，模型拥有了“语言直觉”，但它还只是一位“读过万卷书、尚未行万里路”的书生。它需要经过指令微调、人类反馈对齐（RLHF）等后续工序，才能真正成为有用的助手。预训练只是第一步，但这是奠定一切能力的基础——正如那位编辑，没有海量阅读，后面的创意写作、风格模仿都将是无源之水。

Total FLOPs≈6ND(训练一个N参数模型在D个Token上的大致计算量)\displaystyle \text{Total FLOPs} \approx 6ND \quad (\text{训练一个N参数模型在D个Token上的大致计算量})
这个公式是一个经典的“经验法则”：训练的总计算量约等于6倍的模型参数量乘以训练Token数。它让你能快速估算训练成本。
  1. 计算量估算约需 $6ND$ 次浮点运算
    6ND6ND
  2. 参数量$N$ 是模型参数量（如1750亿）
    NN
  3. 数据量$D$ 是训练Token总数（如3000亿）
    DD

AI 应用场景

智能客服对话系统

阶段：预训练 + 指令微调

解决的问题：传统客服系统依赖关键词匹配和预设话术，遇到表述灵活的用户提问（如“我的包裹卡在半路了”）就无从应对。基于GPT预训练模型微调的对话系统，通过预训练掌握了语言理解和生成的底层能力，再配合少量客服对话数据进行微调，就能理解各种口语化表达并生成自然流畅的回复。

具体案例：某电商平台使用GPT基础模型，在30万条历史客服工单上微调，构建智能客服助手。预训练让模型天然理解“退货”“物流”“差价”等概念的语言表达，微调则让它学会了规范的服务话术风格。上线后，常见问题的一次解决率从45%提升到76%，人工客服仅需处理复杂投诉。

代码自动补全工具

阶段：预训练（代码语料）+ 微调

解决的问题：传统IDE的代码补全基于语法规则和索引，只能补全变量名和API名称，无法理解开发者写这段代码的意图。GPT模型在包含GitHub代码的语料上预训练后，学到了“代码即文本”的规律——输入函数签名和前几行代码，模型就能续写完整的函数体。

具体案例：程序员Alice正在写一个Python函数用于解析JSON配置文件。她敲完函数定义和文档字符串后，AI助手自动生成了函数体，包含异常处理和边界检查。这个能力来自预训练阶段模型读过数百万个类似的Python函数，理解了“解析JSON的代码长什么样”。

内容创作辅助平台

阶段：预训练 + 监督微调

解决的问题：自媒体创作者需要高效产出高质量文案，过去的“模板生成”工具产出千篇一律。GPT预训练模型学习了海量新闻、博客、小说，对“好的中文长什么样”有深刻理解，可以辅助生成有风格、有结构、有创意的初稿。

具体案例：一位科技博主使用基于GPT模型的内容辅助工具撰写短视频脚本。她只需要输入主题“量子计算科普”，模型就能生成一版包含悬念开头、通俗比喻、简洁收尾的完整脚本。博主只需修改润色即可发布，单条视频的制作时间从半天缩短到1小时。

Python 演示

python90 行
import mathimport torchimport torch.nn as nnimport torch.nn.functional as F class CausalSelfAttention(nn.Module):    def __init__(self, d_model, n_heads):        super().__init__()        self.d_model = d_model        self.n_heads = n_heads        self.head_dim = d_model // n_heads        self.w_q = nn.Linear(d_model, d_model)        self.w_k = nn.Linear(d_model, d_model)        self.w_v = nn.Linear(d_model, d_model)        self.out_proj = nn.Linear(d_model, d_model)     def forward(self, x):        B, T, C = x.shape        q = self.w_q(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)        k = self.w_k(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)        v = self.w_v(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)        attn_weights = q @ k.transpose(-2, -1) / math.sqrt(self.head_dim)        mask = torch.triu(torch.ones(T, T, device=x.device), diagonal=1).bool()        attn_weights = attn_weights.masked_fill(mask, float('-inf'))        attn_weights = F.softmax(attn_weights, dim=-1)        out = attn_weights @ v        out = out.transpose(1, 2).contiguous().view(B, T, C)        return self.out_proj(out) class SimpleGPT(nn.Module):    def __init__(self, vocab_size, d_model=128, n_heads=4, n_layers=2):        super().__init__()        self.token_embed = nn.Embedding(vocab_size, d_model)        self.pos_embed = nn.Embedding(1024, d_model)        self.blocks = nn.ModuleList([            nn.ModuleList([                CausalSelfAttention(d_model, n_heads),                nn.LayerNorm(d_model),                nn.Linear(d_model, 4 * d_model),                nn.Linear(4 * d_model, d_model),                nn.LayerNorm(d_model)            ])            for _ in range(n_layers)        ])        self.ln_f = nn.LayerNorm(d_model)        self.head = nn.Linear(d_model, vocab_size)     def forward(self, idx):        B, T = idx.shape        tok = self.token_embed(idx)        pos = self.pos_embed(torch.arange(T, device=idx.device))        x = tok + pos        for attn, ln1, ff1, ff2, ln2 in self.blocks:            x = x + attn(ln1(x))            x = x + ff2(ff1(ln2(x)))        logits = self.head(self.ln_f(x))        return logits def train_step(model, optimizer, batch, device='cpu'):    x, y = batch    x, y = x.to(device), y.to(device)    logits = model(x)    B, T, V = logits.shape    loss = F.cross_entropy(logits.view(B * T, V), y.view(B * T))    optimizer.zero_grad()    loss.backward()    optimizer.step()    return loss.item() def generate(model, idx, max_new_tokens=20):    model.eval()    for _ in range(max_new_tokens):        idx_cond = idx[:, -100:]        logits = model(idx_cond)        logits = logits[:, -1, :]        probs = F.softmax(logits, dim=-1)        idx_next = torch.multinomial(probs, num_samples=1)        idx = torch.cat([idx, idx_next], dim=1)    return idx if __name__ == "__main__":    torch.manual_seed(42)    vocab_size = 100    model = SimpleGPT(vocab_size)    optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)    train_data = torch.randint(0, vocab_size, (32, 64))    targets = torch.randint(0, vocab_size, (32, 64))    for step in range(5):        loss = train_step(model, optimizer, (train_data, targets))        print(f"step {step}: loss = {loss:.4f}")
目的：实现一个极简GPT模型，包含因果自注意力掩码、多层Transformer块、交叉熵损失训练循环和自回归生成逻辑。
  1. mask = torch.triu(torch.ones(T, T, device=x.device), diagonal=1).bool()生成上三角掩码矩阵，对角线右上方全为True，表示禁止查看未来位置。
  2. attn_weights = attn_weights.masked_fill(mask, float('-inf'))将未来位置的注意力分数设为负无穷，经过softmax后概率为0。
  3. F.cross_entropy(logits.view(B * T, V), y.view(B * T))计算所有位置的平均交叉熵损失，这是预训练的核心监督信号。
  4. torch.multinomial(probs, num_samples=1)从模型输出的概率分布中采样下一个词，而非取最大值，增加生成多样性。
  5. pos = self.pos_embed(torch.arange(T, device=idx.device))生成位置编码，让模型感知词的先后顺序。

常见误区

误区自回归模型就是RNN，因为它们都是“逐个预测下一个词”，RNN的隐藏状态和自回归的上下文窗口没区别。

正解自回归描述的是建模方式（用过去预测未来），RNN是具体的网络架构。GPT使用的Transformer也是自回归模型，但它通过自注意力直接建模所有历史位置的依赖关系，而不是像RNN那样把历史压缩到一个隐藏状态向量中。自回归是一种范式，Transformer和RNN是不同实现方式，就像“按时上班”是制度，走路或开车是不同方式。

为何常见：两者都表现为“从左到右”处理序列，初学者容易混淆抽象范式与具体实现。

误区加了因果掩码后，整个Transformer从底层到顶层都只能看到左侧信息，多头注意力内部无法获得任何右侧信息。

正解掩码确实阻止了注意力层看到未来词，但深层网络的每个位置已经通过残差连接和层堆叠，聚合了所有左侧位置的信息。这种“只能看左边”的限制是单向的，但信息在深度方向可以反复加工——位置5的深层表示不仅知道“位置1-4的词”，还能通过注意力关系理解它们的组合语义。单向约束不等于信息贫乏。

为何常见：把“注意力可见范围”等同于“信息总量”，忘记了残差连接前向传播的累积效应。

误区预训练损失（困惑度）是衡量模型好坏的终极指标，PPL低的模型生成的文本一定更流畅、更有逻辑、更符合人类偏好。

正解PPL衡量的是模型对语言分布的拟合程度，低PPL确实意味着模型对“下一个词”的预测更准。但“准”不代表“好”——一个PPL极低的模型可能只是学会了安全平庸的常见表达（如“这是一个非常重要的问题”），而真正好的生成需要多样性、创造性和上下文相关性。这也是为什么有RLHF（人类反馈对齐）来优化更丰富的目标。

为何常见：PPL是预训练阶段唯一可见的优化指标，容易把手段当目的。

误区预训练就是“喂数据”，喂得越多模型越强。网络上的海量文本随便抓来就能用。

正解数据质量与数据规模同样重要。低质量数据（如乱码、重复内容、机器生成的垃圾文本）不仅无益，反而会污染模型的语言直觉。OpenAI的GPT-3论文中明确提到需要“清洗后”的数据，而近年来的Chinchilla、LIMA等研究进一步证明，高质量数据可以在更小规模上超越纯堆量的效果。

为何常见：“规模决定一切”的观点忽略了规模收益递减和数据质量带来的上限突破。

误区既然损失随参数规模幂律下降，那无限扩大参数量和算力就能让模型无限逼近完美语言模型。

正解Scaling Law中的公式明确指出存在不可约损失 $L_{\min}$，即模型在完美情况下也有理论误差下限。而且幂律意味着规模翻倍的收益在递减。更重要的是，实际工程中还面临数据枯竭（高质量文本有限）、硬件瓶颈（千卡集群的通信开销）、训练不稳定（loss spike）等多重约束。

为何常见：把幂律关系外推到极端区间，忽略了现实约束和理论下限。

面试题

Q1. 自回归语言模型的核心思想是什么？

单选题 · easy

  • A.同时利用上下文双向信息预测词
  • B.用过去词预测当前词的条件概率← 正确答案
  • C.随机生成词与上下文无关
  • D.逐词翻译而非逐词预测

答案：B。自回归的核心是用前文预测下一个词，即 $P(x_t|x_1,...,x_{t-1})$。选项A是BERT等双向模型的做法，C违背自回归的确定性逻辑，D描述的是机器翻译。自回归就是那位逐字写稿的编辑——只依据已写内容推后续。

Q2. 因果掩码在注意力计算中的直接作用是？

单选题 · easy

  • A.增强模型对词序的敏感度
  • B.防止位置i的词看到位置j>i的信息← 正确答案
  • C.加速注意力矩阵的并行计算
  • D.让模型可以处理变长输入

答案：B。因果掩码将未来位置的注意力分数置为 $-\infty$，softmax后注意力权重为0，模型无法attend到未来词。它是训练与推理一致性的关键保障。选项A是位置编码的功能，C和D与掩码无直接关系。

Q3. GPT预训练使用的损失函数直接最大化的是什么？

单选题 · mid

  • A.词表中所有词的平均概率
  • B.真实下一个词的条件对数概率之和← 正确答案
  • C.模型预测分布的方差
  • D.注意力权重的稀疏程度

答案：B。交叉熵损失等价于最大化真实词的对数概率 $-\log \hat{y}_{t,x_t}$。其本质是让模型对正确词给出高概率。选项A没有区分“真实词与其他词”，C是统计量非训练目标，D与训练目标无关。

Q4. 在Transformer中，位置编码的作用是什么？

单选题 · mid

  • A.让模型感知词在序列中的位置顺序← 正确答案
  • B.增加模型的参数量以提升容量
  • C.防止过拟合的正则化手段
  • D.将离散Token映射为连续向量

答案：A。自注意力本身对词序不敏感（permutation invariant），位置编码为每个位置注入唯一的顺序信息，让模型感知“先后关系”。Token嵌入负责D的功能，参数量增大不是目的，位置编码也没有正则化效果。

Q5. 在计算量预算增长10倍时，Scaling Law建议如何分配？

单选题 · mid

  • A.参数量和数据量都增加10倍
  • B.只增加参数量不增加数据量
  • C.参数增约5倍，数据增约1.8倍← 正确答案
  • D.参数和数据都只增加1倍

答案：C。OpenAI的Scaling Law论文给出的最优分配是模型参数增长约5倍、数据增长约1.8倍（总计算量10倍）。这源于参数量和数据的幂律指数差异。选项A不是最优分配，B和D没有充分利用预算。

Q6. 以下哪些策略属于GPT预训练数据处理的常见步骤？

多选题 · mid

  • A.用MinHash去除重复文档← 正确答案
  • B.使用困惑度过滤低质量文本← 正确答案
  • C.对无关语料随机增强数据
  • D.按来源进行质量加权采样← 正确答案

答案：ABD。MinHash去重（A）、困惑度过滤（B）、质量加权采样（D）都是实际采用的数据清洗与配比策略。选项C的“随机增强”没有意义——预训练不是图像分类，无法对文本做简单的随机变换增强。

Q7. 交叉熵损失为什么比均方误差更适合分类预测？

单选题 · hard

  • A.均方误差无法计算梯度
  • B.交叉熵对概率输出有更好的梯度传播← 正确答案
  • C.均方误差会导致网络退化为线性
  • D.交叉熵输出分布天然是均匀的

答案：B。结合softmax的交叉熵在预测错误时梯度大、预测正确时梯度小，且不会出现梯度饱和问题。MSE配合softmax时梯度会乘上 $\hat{y}(1-\hat{y})$，当 $\hat{y}$ 接近0或1时梯度消失，训练极慢。选项A错误（MSE有梯度），C和D均不成立。

Q8. 关于自回归模型的训练与推理一致性，正确的说法是？

多选题 · mid

  • A.训练时模型看到完整输入序列← 正确答案
  • B.推理时模型只能依赖已生成的Token← 正确答案
  • C.一致性保证模型学到的能力在实战中有效← 正确答案
  • D.因果掩码导致训练和推理完全不一致

答案：ABC。训练时虽然一次性输入完整序列，但掩码确保每个位置只看前缀（A对）；推理时逐词生成，自然只能看到已生成的Token（B对）。两者行为一致，这正是因果掩码的目的（C对）。选项D描述反了，掩码恰是为了保持一致。

Q9. 假设词表大小V=1000，序列长度T=10，GPT模型某一个位置的输出logits维度是多少？

单选题 · hard

  • A.1000← 正确答案
  • B.10
  • C.10000
  • D.取决于隐藏层维度

答案：A。输出层是线性层，将隐藏维度映射到词表大小V。每个位置输出一个V维向量，表示词表上各Token的logits。T是序列长度，不是输出维度；隐藏层维度决定中间特征但最终输出维度是V。

Q10. 关于GPT预训练的数据配比，正确的见解是？

多选题 · hard

  • A.书籍和百科质量高，应适当上采样← 正确答案
  • B.网页数据量大但需严格过滤← 正确答案
  • C.代码数据只对编程任务有帮助
  • D.数据配比影响模型知识结构← 正确答案

答案：ABD。高质量文献上采样（A）和网页过滤（B）是标准做法。代码数据不仅提升编程能力，还增强了逻辑推理和结构化理解，对通用任务也有帮助（C错）。不同数据源塑造不同知识结构（D对），配比是预训练的重要决策。