人工智能(AI)#

AI(Artificial Intelligence,人工智能)是最宏观的概念。它的定义从 1956 年的达特茅斯会议沿用至今:让机器完成通常需要人类智能才能完成的任务。Dartmouth AI Conference

这个定义宽到几乎包含一切。1950 年代的国际象棋程序是 AI,专家系统是 AI,今天的大模型也是 AI。AI 是一顶大帽子,下面有很多不同路线的技术。

其中一条路线,叫做机器学习。

机器学习(ML)#

ML(Machine Learning,机器学习)是 AI 的一个子集。它的核心思想是:与其手动写规则让机器完成任务,不如让机器从数据中自动学习规则。

举个具体例子。假设你想写一个程序,判断一封邮件是不是垃圾邮件。传统 AI 路线是:人工总结规则:“含有’免费领取’就标记为垃圾邮件”。但垃圾邮件的措辞每天都在变化,规则永远追不上。ML 的路线是:给程序提供几十万封已经标注好的邮件(这封是垃圾/这封不是垃圾),让程序自己从中发现规律。这种从数据中学习的能力,就是”机器学习”的本质。

深度学习(DL)#

DL(Deep Learning,深度学习)是 ML 的一个子集。它使用一类特定的模型结构:神经网络(Neural Network)。

神经网络得名于对生物神经元的松散模拟。每个”神经元”接收输入,做一次加权求和,再通过一个激活函数产生输出,然后把输出传给下一层。“深度”指的是这个网络有很多层,有时候几十层,有时候上百层。

深度学习的崛起有一个明确的时间节点:2012 年。那一年,Geoffrey Hinton 的团队用卷积神经网络(CNN)参加 ImageNet 图像识别竞赛,错误率从 26% 骤降到 15.3%,领先第二名将近 10 个百分点。ImageNet Large Scale Visual Recognition Challenge 这个结果让学术界意识到,深度学习可以学到人类手工特征工程学不到的东西。

生成式 AI(GenAI)#

GenAI(Generative AI,生成式 AI)是深度学习中一类特定的任务方向。它的目标是:生成新的内容:文字、图片、音频、视频、代码。

传统的深度学习模型大多在做”分类”或”预测”:给定一张图片,判断里面是猫还是狗;给定一段历史股价,预测明天涨还是跌。这类任务的输出是从有限选项中选一个。生成式 AI 的输出空间是无限的:它可以生成一张从未存在过的人脸,写一篇从未有人写过的文章。

能做到这一点,背后靠的是模型学会了数据的分布规律,而不只是分类边界。这个区别在后面讨论”判别式 vs 生成式”时会展开。

大语言模型(LLM)#

LLM(Large Language Model,大语言模型)是生成式 AI 的一个具体分支,专门处理文本。“大”指的是参数量。GPT-3 有 1750 亿参数,Brown et al., 2020 — Language Models are Few-Shot Learners 而推测中的 GPT-4 参数量约在 1.8 万亿量级(SemiAnalysis 估计,参数量未公开)。

LLM 的工作原理,一句话说就是:给定前面的文字,预测下一个词(Token)是什么。这个看似简单的目标,当数据量和参数量都足够大时,迫使模型学会了语法、逻辑、事实知识、甚至一定程度的推理能力。

这五个概念的包含关系如下图所示:

graph TD
    A["AI<br/>人工智能<br/>(1950s~)"] --> B["ML<br/>机器学习<br/>(1980s~)"]
    B --> C["DL<br/>深度学习<br/>(2012~)"]
    C --> D["GenAI<br/>生成式AI<br/>(2021~)"]
    D --> E["LLM<br/>大语言模型<br/>(2018~)"]
    D --> F["图像生成模型<br/>DALL-E / Stable Diffusion"]
    D --> G["音视频生成模型<br/>Sora / AudioCraft"]

    style A fill:#e8f4f8,stroke:#2196F3
    style B fill:#e3f2fd,stroke:#1976D2
    style C fill:#bbdefb,stroke:#1565C0
    style D fill:#90caf9,stroke:#0d47a1
    style E fill:#42a5f5,stroke:#0a2f6e,color:#fff

每一层都是前一层的子集。AI 包含 ML,ML 包含 DL,DL 包含 GenAI,GenAI 包含 LLM。当你看到新闻说”AI 能写代码了”,背后的技术其实是 LLM。

P(Y|X):给定 X,Y 发生的概率#

P(Y|X) 读作”在 X 已知的条件下,Y 的概率”。这是判别式模型的核心。

一个日常例子:你是一名医生,面对一个发烧、咳嗽的病人。你想判断他得的是流感还是普通感冒。你不需要知道”什么样的人会在这个季节生病”,你只需要知道:给定这些症状(X),流感的概率 P(流感 | 发烧,咳嗽) 有多大?

判别式模型做的就是这件事。它学会了从输入 X 到标签 Y 的映射,在输入和标签之间画分界线。垃圾邮件分类器是判别式模型,人脸识别是判别式模型,情感分析(这条评论是正面还是负面?)是判别式模型。

这类模型的特点:高效、精准,但只能输出预定义的几个答案。它永远不会创造出一封”新的邮件”,只会判断给定的邮件属于哪一类。在输出固定、标签确定的场景下,判别式模型仍然是工程上的首选。

P(X) 本身发生的概率#

P(X) 读作”X 发生的概率”。这是生成式模型的核心。

换一个例子:你是一名作曲家,想学莫扎特的风格。你听了他所有的曲子,脑子里建立起了一个模型:什么样的旋律走向、和声搭配、节奏模式,在莫扎特的音乐中是”高概率”的,什么是”低概率”的。

一旦你掌握了这个分布 P(莫扎特风格的音乐),你就可以用它生成新的乐句:采样一段高概率的音符序列,就得到了一段莫扎特风格的新曲子。这个过程没有外部标签 Y,只有对数据分布本身的建模。

LLM 做的事情本质上与此相同。它在海量文本上学习 P(文本),或者更精确地说,P(下一个词 | 前面所有词)。当你输入”明天的天气”,模型知道”可能是晴天”是高概率续写,“可能是一只河马”是低概率续写,于是它生成的回答有意义、连贯、符合人类语言习惯。

两种模型的核心差异如下表所示:

理解这个区别很重要,因为它解释了为什么 LLM 能写文章、写代码,而不只是给句子贴标签。GPT 系列模型的核心训练目标,就是预测下一个词。这是一个生成式目标。Brown et al., 2020 — Language Models are Few-Shot Learners

监督学习:有标准答案的学习#

监督学习(Supervised Learning)是最直觉的范式。你给模型提供大量的”输入-输出”对,让它学习从输入到输出的映射。这就像学生做有答案的习题集:每道题都有参考答案,通过反复对照,逐渐掌握规律。

例子:你收集了 10 万张猫狗图片,每张都标注了”猫”或”狗”。把这些数据喂给一个卷积神经网络,训练结束后,它就学会了区分猫和狗。这里”猫”和”狗”的标注就是监督信号,用于告诉模型正确答案是什么。

监督学习的前提是有高质量的标注数据。标注数据昂贵、耗时,而且永远赶不上现实世界的多样性。这是它的根本局限。

在 LLM 训练中,监督学习出现在两个阶段:一是 Instruction Fine-tuning(指令微调),用人工标注的问答对来教模型按指令回答;二是 RLHF(Reinforcement Learning from Human Feedback,基于人类反馈的强化学习)中的奖励模型训练阶段,用人类对回答质量的打分作为标注。

无监督学习:自己发现规律#

无监督学习(Unsupervised Learning)不需要标注。你只给模型原始数据(没有任何标签),让它自己发现数据中的结构和规律。

这就像一个婴儿学语言。没有人拿着每个单词告诉他”这叫苹果”,他通过大量听和看,逐渐归纳出词语和世界之间的对应关系。

LLM 的预训练(Pre-training)阶段本质上是一种无监督学习。训练数据是从互联网上抓取的海量文本,没有人工标注。模型的训练目标是”预测下一个词”,而正确答案(下一个词)就藏在数据本身里。这种方式叫做自监督学习(Self-supervised Learning),可以视为无监督学习的一种特殊形式。

这个范式的优势是数据成本极低:互联网上有多少文本,就能用多少文本。正是因为这一点,GPT-3 可以在 5000 亿词的数据上训练,让模型获得广泛的知识覆盖。Brown et al., 2020 — Language Models are Few-Shot Learners

强化学习:在环境中试错#

强化学习(Reinforcement Learning,RL)的比喻是训练小狗。你不需要告诉它每一步该怎么做,但每当它做对了,你就给它一块饼干(奖励);做错了,不给。通过大量的试错,它逐渐学会了什么行为能获得更多奖励。

RL 的核心元素有三个:智能体(Agent,做决策的模型)、环境(Environment,给出反馈的系统)、奖励函数(Reward Function,评判好坏的标准)。

在 LLM 训练中,RLHF 是最重要的 RL 应用。它的流程是:先用监督学习训练一个”奖励模型”(学会判断哪个回答更好),然后用这个奖励模型作为”环境”,用 PPO(Proximal Policy Optimization,近端策略优化)等算法来调整 LLM 的输出,使其生成人类更喜欢的回答。Ouyang et al., 2022 — Training language models to follow instructions with human feedback

ChatGPT 之所以比最初的 GPT-3 更”好用”,核心原因就在于 RLHF。原始 GPT-3 会生成任何高概率的文本,包括有害内容、废话、以及偏离用户意图的回答。RLHF 让模型的优化目标从”预测概率”转移到”人类偏好”。这是一个质的转变。

graph LR
    A["预训练<br/>无监督/自监督<br/>海量文本"] --> B["指令微调 SFT<br/>监督学习<br/>标注问答对"]
    B --> C["奖励模型训练<br/>监督学习<br/>人类偏好打分"]
    C --> D["RLHF 对齐<br/>强化学习<br/>PPO 优化"]
    D --> E["对齐后的 LLM<br/>ChatGPT / Claude"]

    style A fill:#fff3e0,stroke:#f57c00
    style B fill:#e8f5e9,stroke:#388e3c
    style C fill:#e3f2fd,stroke:#1976D2
    style D fill:#fce4ec,stroke:#c62828
    style E fill:#f3e5f5,stroke:#7b1fa2,color:#000

第一代 及其根本缺陷#

RNN(Recurrent Neural Network,循环神经网络)是处理序列数据的第一个成熟框架,在 1980 年代被提出,1990 年代开始广泛应用于语音识别和文本处理。

RNN 的工作方式是逐步处理序列。处理一句话时,它从第一个词开始,每读入一个词,就更新一个”隐藏状态”(Hidden State),把这个状态传给下一步。处理完所有词之后,最后的隐藏状态被认为”记住”了整句话的信息。

这个设计有一个致命的数学问题:梯度消失(Vanishing Gradient)。

训练神经网络靠的是反向传播,即计算每个参数对损失函数的梯度,然后沿梯度方向更新参数。在 RNN 中,梯度需要从句子末尾”回传”到句子开头,每经过一个时间步,梯度就要乘以一个权重矩阵。当句子很长时,这相当于把一个小于 1 的数连乘几十次,梯度指数级缩小,趋向于零。结果是:句子开头的词对模型的影响消失了,模型根本学不到长距离的依赖关系。Vanishing gradient problem, Wikipedia

具体说就是:你给模型喂入”北京是中国的____“,RNN 能轻松填入”首都”。但如果句子是”我在北京长大,在上海读了大学,毕业后辗转广州深圳工作多年,去年终于回到了我出生的那座城市____“,句子开头的”北京”离句尾太远,梯度消失后模型根本”记不住”它。

第二代 的记忆门控机制#

1997 年,Sepp Hochreiter 和 Jürgen Schmidhuber 提出了 LSTM(Long Short-Term Memory,长短期记忆网络)。Hochreiter & Schmidhuber, 1997 — Long Short-Term Memory

LSTM 的核心思路是:与其让梯度在所有时间步反复相乘,不如增加一条独立的”记忆通道”(Cell State),用三个可学习的”门”来控制信息的流入、流出和遗忘:

• 遗忘门(Forget Gate):决定从记忆中丢弃哪些旧信息
• 输入门(Input Gate):决定写入哪些新信息
• 输出门(Output Gate):决定读出哪些信息用于此轮预测

记忆通道中的梯度流动接近线性,不会指数级衰减。这让 LSTM 能够记住几百个时间步之前的信息,解决了梯度消失问题。

LSTM 是 2014-2018 年间自然语言处理的主流架构。Google 在 2016 年将 LSTM-based 的 Seq2Seq 模型用于 Google 翻译,翻译质量一夜之间大幅提升。Wu et al., 2016 — Google’s Neural Machine Translation System

但 LSTM 还有两个没有解决的问题:第一,序列必须逐步处理,无法并行。处理一个 1000 词的句子,必须按顺序走 1000 步,训练极慢;第二,即使有记忆门,超长距离的依赖关系依然是弱点:记忆通道里的信息会被不断”稀释”。

第三代:注意力机制(让模型直接”看”任意位置)#

2015 年,Dzmitry Bahdanau 等人在机器翻译任务中引入了注意力机制(Attention Mechanism)。Bahdanau et al., 2015 — Neural Machine Translation by Jointly Learning to Align and Translate

这个想法非常直观。翻译一句话时,翻译每一个词不需要把整句话压缩进一个固定大小的向量。模型可以”回头看”原句的任意位置,计算正在翻译的词和原句每个词的相关性,用这个相关性加权求和,得到这个词最需要关注的上下文。

数学上,注意力机制计算的是:

$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$

其中 Q(Query,查询)代表此次要”查找”的内容,K(Key,键)代表每个位置的标签,V(Value,值)代表每个位置的实际内容。Softmax 确保注意力权重加和为 1。这个公式让模型可以直接计算任意两个位置之间的相关性,不需要通过中间的记忆通道传递。

第四代(彻底抛弃循环结构)#

2017 年 6 月,Google Brain 的研究团队发表了论文《Attention Is All You Need》。Vaswani et al., 2017 — Attention Is All You Need 这篇论文提出了一个激进的想法:如果注意力机制已经能直接连接序列中的任意两个位置,为什么还需要 RNN 的循环结构?

Transformer 完全去掉了循环,用纯粹的注意力机制(自注意力,Self-Attention)和前馈网络(Feed-Forward Network)构建模型。自注意力机制让序列中的每个位置都可以直接”看到”序列中所有其他位置,不需要通过任何中间状态传递。

这带来了两个根本性的优势:

第一,完全可并行化。 由于没有了时间步之间的依赖,整个序列可以同时处理。在 GPU 这种为并行计算设计的硬件上,训练速度可以提升几个数量级。这意味着可以在合理的时间内训练更大的模型,用更多的数据。

第二,长距离依赖的路径长度变为常数。 在 RNN 中,句子首尾之间的依赖路径长度等于句子长度;在 Transformer 中,任意两个位置之间的路径长度恒为 1(一层注意力)。这从根本上解决了长距离依赖的问题。

Transformer 的架构包含两个主要组件:编码器(Encoder)负责理解输入,解码器(Decoder)负责生成输出。后来的 BERT 只用了编码器,GPT 系列只用了解码器,各自针对不同的任务进行了优化。

graph TB
    subgraph RNN时代["RNN 时代 (1990s-2017)"]
        R1["词1"] --> R2["词2"] --> R3["词3"] --> R4["..."] --> R5["词N"]
        R_note["顺序处理,梯度消失,无法并行"]
    end
    
    subgraph LSTM时代["LSTM 时代 (1997-2018)"]
        L1["遗忘门"] --> L2["输入门"] --> L3["输出门"]
        L_note["解决梯度消失,仍然顺序,仍然无法并行"]
    end
    
    subgraph Transformer时代["Transformer 时代 (2017~)"]
        T1["词1"] & T2["词2"] & T3["词3"] & T4["词N"]
        T1 <--> T2
        T1 <--> T3
        T1 <--> T4
        T2 <--> T3
        T2 <--> T4
        T3 <--> T4
        T_note["全并行,任意位置直连,长距离依赖路径=1"]
    end

2017-2022:奠基期#

Transformer 在 2017 年发表时,并没有立刻引发大众关注。它最初只是 Google 内部的一个机器翻译改进方案,但因为翻译质量提升明显,迅速被推广到其他自然语言处理任务。

2018 年是关键年份。Google 发布 BERT,OpenAI 发布 GPT-1。两者都基于 Transformer,但走了截然不同的路线 用编码器,训练目标是”填空”(Masked Language Modeling),擅长理解任务;GPT 用解码器,训练目标是”续写”,擅长生成任务。这两条路线的分歧,一直延续到今天。

GPT-2 在 2019 年出现时,OpenAI 公开表示担心模型可能被用于生成假新闻,最初只发布了小版本。这一决定本身就成了一次最好的营销:当一个模型被认为”太危险而不能公开”,反而证明了它真的具备强大能力。

GPT-3 在 2020 年的发布才是真正的里程碑。1750 亿参数,在 5000 亿词的数据上训练。Few-Shot Learning 的涌现才是最令人震惊的:你只需要给模型三五个例子,告诉它你想做什么,它就能举一反三完成新任务,完全不需要微调。这让学术界意识到,规模(Scale)本身就能带来新能力的涌现。Brown et al., 2020 — Language Models are Few-Shot Learners

2022 年 11 月 ChatGPT 的出现,是一次商业上的爆炸。技术上,ChatGPT 是 GPT-3.5 加上 RLHF 对齐,并没有颠覆性的架构创新。但 RLHF 让模型从”预测文本”变成了”帮助用户”,这个对齐使它从一个研究原型变成了每个人都能用的工具。OpenAI Blog

2023-2024:三强并立与推理模型崛起#

2023 年是竞争格局形成的一年。

GPT-4 在 2023 年 3 月发布。它首次支持图像输入,在大量专业考试(律师资格、医学执照)中的表现达到或超过人类平均水平。OpenAI — GPT-4 Technical Report 但 OpenAI 没有公开参数量,也没有公开训练数据的细节。

Anthropic 同月发布 Claude 1。Anthropic 由 OpenAI 前核心成员创立,走”宪法 AI”(Constitutional AI)路线,用一套明确的规则和原则来指导模型对齐,摆脱对人类标注的完全依赖。Bai et al., 2022 — Constitutional AI: Harmlessness from AI Feedback

Meta 在 2023 年 7 月开源了 Llama 2(70B 参数)。开源决策的意义在于:任何团队都可以在自己的服务器上运行这个模型,不需要通过 API。这迅速催生了大量的本地部署、微调、以及基于 Llama 的衍生模型生态。

2024 年的关键词是”多模态成熟”和”推理模型”。GPT-4o 在 2024 年 5 月发布,支持文字、图像、音频的实时交互。Claude 3 Sonnet 和 Claude 3.5 Sonnet 在编程任务上的表现让很多开发者从 GPT-4 切换过去。

2024 年 9 月,OpenAI 发布 o1,这是一个范式上的转变。o1 在生成最终答案之前,会进行大量的内部”思考”(Chain-of-Thought 推理链),在复杂数学和编程任务上的表现远超 GPT-4o。这条路线后来被称为”推理时计算扩展”(Test-time Compute Scaling)。OpenAI — Learning to Reason with LLMs

年底,DeepSeek-V3 引发了轰动。这个由中国团队(深度求索)发布的开源模型,671B 参数(采用 Mixture-of-Experts 架构,实际激活 37B),在多项基准上与 GPT-4o 持平,但训练成本据报道约为 600 万美元,只是同等闭源模型的一个零头。DeepSeek-V3 Technical Report

2025:开源追平闭源,推理能力爆发#

2025 年 1 月,DeepSeek 发布了 R1,这是一个开源的推理模型,在 AIME 2025 数学竞赛基准和 Codeforces 编程竞赛基准上与 OpenAI o1 持平。这打破了一个重要的预期:推理能力不是闭源公司的专利。DeepSeek-R1 Technical Report

2025 年 5 月,Anthropic 在首届开发者大会上发布 Claude 4 系列(Opus 4 和 Sonnet 4),重点是智能体(Agent)任务的可靠性提升,模型在长时间自主执行多步骤任务时的一致性明显改善。

2025 年 8 月,OpenAI 发布 GPT-5。12 月,GPT-5.2 上线,将上下文窗口扩展至 40 万 Token,并在 AIME 2025 数学基准上取得满分。llm-stats.com — AI Updates

2025 年 11 月,Google 发布 Gemini 3 Pro 和 Deep Think,在 ARC-AGI-2 多模态推理基准上取得高分。年底,DeepSeek V3.2 发布,其增强版本在国际数学奥林匹克(IMO)和 ICPC 世界总决赛的题目上取得金牌级别成绩。DeepSeek V3.2 技术报告,camocopy.com

2026:三强竞争格局与截至 2026-05-09 的排行榜#

截至 2026-05-09,顶级模型的能力差距已经大幅缩小,三家主要参与者(Anthropic、OpenAI、Google)加上 xAI 和 DeepSeek 形成了多强竞争格局。

LMArena(原 LMSYS Chatbot Arena)的盲评排行榜是截至 2026-05-09 公认最可信的模型能力比较之一,因为它基于真实用户对真实输出的偏好投票,而不是专项设计的基准。LMArena Leaderboard

截至 2026-05-09,LMArena 文本排行榜前五名如下:

数据来源:LMArena — Who’s #1 on LMArena Right Now? Live Top-10 (May 2026)

注意:前三名的 Elo 分差在 95% 置信区间之内,属于统计意义上的并列。这意味着顶级模型之间的差距已经小到真实用户难以感知的程度。

GPT-5.4-Pro 在 GPQA Diamond(专家级科学问答)基准上得分 94.4%,Claude Opus 4.7 在 SWE-Bench Verified(真实代码库 Bug 修复)上得分 87.6%。Shakudo — Top 9 Large Language Models as of March 2026

特征(Feature):给机器看的数字#

特征是用来描述一个样本的数值化信息。计算机不能直接处理”一只猫”或”一栋房子”,它只能处理数字。因此,在把数据送进模型之前,首先要把原始信息转化成一组数字——这组数字就是特征向量。

想象你要让计算机判断一张图片里是猫还是狗。图片本身是一堆像素点——每个像素有红、绿、蓝三个颜色通道的数值。对于一张 224×224 的彩色图片,特征的总维度就是 224×224×3=150528 个数字。这 15 万个数字拼在一起,就是这张图片的特征向量。如果用表格来类比,一行数据代表一个样本,这行里的每一列就是一个特征。

再看一个更接地气的例子:预测一栋房子的价格。你可能选择这些特征:建筑面积(平方米)、房龄(年)、楼层、所在城市的邮政编码、到最近地铁站的步行时间(分钟)、小学学区评分。每一个房子实例,都变成了一行 6 个数字。模型学到的,就是这 6 个数字与最终成交价格之间的映射关系。

特征的选取至关重要。在早期的机器学习中,**特征工程(Feature Engineering)**是整个工作中最耗时、最考验领域知识的部分。哪些维度有预测价值?哪些维度是噪声?两个特征之间是否存在交叉关系(例如面积×楼层可能比两者单独更有意义)?这些判断都需要人工完成。特征工程做得好不好,直接决定了模型的上限。

Pedro Domingos, 2012 — A Few Useful Things to Know about Machine Learning 把特征工程称为”机器学习实践中最黑暗的艺术”:没有通用公式,依赖大量领域知识和反复试错。一个好的特征可以让一个简单的线性模型打败一个精心设计的深度网络;一组糟糕的特征,再复杂的模型也救不了。

深度学习的一个核心贡献,恰好是把特征提取这件事也交给了神经网络自己去学。LeCun et al., 2015 — Deep Learning 在《自然》杂志上发表的综述将这一点总结为深度学习的本质:表示学习(Representation Learning)。模型的前几层不再需要人工设计的特征,而是从原始像素或原始文本直接学习出有用的中间表示。这使得端到端训练成为可能——数据输入,预测输出,中间的一切都由模型自己搞定。但理解”特征是什么”,仍然是理解整个机器学习框架的起点。

标签(Label):告诉机器什么是对的#

标签是每个训练样本对应的”正确答案”。这个答案可以是离散的分类,也可以是连续的数值。

在垃圾邮件识别任务中,标签是”垃圾”或”正常”,只有两种取值——这叫二分类(Binary Classification)。在手写数字识别任务中,标签是 0 到 9 之间的整数——这叫多分类(Multiclass Classification)。在房价预测任务中,标签是一个连续的数值——这叫回归(Regression)。

在 LLM(大型语言模型)的预训练阶段,标签的设计更加巧妙:对于一段文本”我今天吃了一碗面”,系统会把它拆成多个训练样本:

• 输入”我今天吃了一碗”,标签是”面”
• 输入”我今天吃了一”,标签是”碗”
• 输入”我今天吃了”,标签是”一”

每一个词元(Token,可以理解为字或子词)的”下一个词元”就是标签。这个任务叫做 next-token prediction,是 LLM 预训练的核心目标,后面我们会详细展开它背后的数学。

标签的质量决定了训练的上限。如果标注人员对”垃圾邮件”的定义前后不一致,如果房价数据包含录入错误,如果文本数据混入了大量乱码,模型所能学到的东西就受到了根本性的限制。工业界中有一个经验:花在数据清洗和标注质量控制上的精力,往往不亚于模型设计本身。“垃圾进,垃圾出”(Garbage In, Garbage Out)是机器学习领域最朴素也最重要的定律之一。

以 LLM 的预训练数据为例,Brown et al., 2020 — Language Models are Few-Shot Learners(GPT-3 论文)中描述了他们对 CommonCrawl 数据集的多轮过滤流程:首先用一个质量分类器给每个文档打分,保留高质量文档;然后做 MinHash 去重,去除重复和近似重复的内容;最后对特定来源(如 Wikipedia、书籍)进行权重提升。最终的 GPT-3 训练集中,CommonCrawl 原始数据的保留率约 10%——90% 被当作”低质量”丢弃了。这说明,即使是互联网上已有的文本,也需要经过严格筛选才能成为”有效标签”。

1
# LLM 数据预处理管道示意(伪代码)
2
raw_data = crawl_internet()
3
scored = quality_classifier.score(raw_data)   # 质量打分
4
deduped = minhash_dedup(scored, threshold=0.8) # 去重
5
filtered = [d for d in deduped if d.score > threshold]
6
# 结果: 原始数据的 ~10% 进入训练

训练集、验证集、测试集:为什么要把数据分成三份#

拿到一批带标签的数据之后,并不是全部用来训练模型。标准做法是把数据分成三份。

**训练集(Training Set)**是模型实际看到、用来调整参数的数据,通常占总量的 70%–80%。模型的每一次参数更新,都基于训练集中的样本计算的梯度。

**验证集(Validation Set)**是训练过程中定期拿来检验的数据。模型不会直接从它学习——也就是说,验证集的数据不会产生参数更新。但工程师会根据模型在验证集上的表现来调整超参数(比如学习率、正则化强度、模型层数)。验证集充当了”摸底考试”的角色:考完之后可以继续复习,但不能把考题原封不动地背下来。

**测试集(Test Set)**是所有调参结束之后,最终只用一次的评估数据。它模拟的是真实世界中模型未曾见过的新数据。如果一个模型在训练集和验证集上都表现优秀,在测试集上却一塌糊涂,就说明整个调参过程本身发生了过拟合——工程师无意中把超参数”调到了”让验证集表现好,但这并不代表真正的泛化能力。

为什么必须分开?因为机器学习本质上是一种有监督的优化过程。如果用同一份数据训练和评估,就像让学生用练习题原卷来考试——分数不能反映真实水平。Stanford CS229 课程讲义将这个数据划分原则作为第一章内容,正说明它是整个领域的根基。

1
# 数据划分示意(伪代码)
2
data = load_dataset()
3
train, val, test = split(data, ratio=[0.75, 0.10, 0.15])
4

5
for epoch in range(num_epochs):
6
    model.train_on(train)            # 更新参数
7
    val_loss = model.evaluate(val)   # 监控泛化
8
    if val_loss not improving:
9
        adjust_hyperparams()         # 调参但不碰测试集
10

11
final_score = model.evaluate(test)   # 只看这一次

实际工程中,还有一种叫做**交叉验证(K-fold Cross Validation)**的技术:把训练集随机分成 K 份,轮流用其中一份做验证、其余做训练,最终取 K 次结果的平均。这在数据量较少时尤其有价值,因为每个样本都有机会既参与训练又参与验证,最大化了数据利用率。但对于现代 LLM 这种需要万亿词元级别数据的训练,完整的 K 折交叉验证代价过高,通常只做单次分割。

过拟合是什么#

想象你在教一个学生备考历史。如果他把练习题的题号和答案逐字背下来,遇到换了说法的同类题就完全不会了,这就是过拟合。对模型来说,过拟合意味着模型把训练数据中的噪声和偶然规律也当成了需要学习的信号,从而失去了泛化到新数据的能力。

从数学角度理解:任何一组带噪声的数据都可以被一个足够复杂的函数完美拟合。对于 $n$ 个数据点,总存在一个 $n-1$ 次多项式通过所有点。但这条曲线在样本点之间可能剧烈抖动,对新数据的预测毫无意义。神经网络有类似的风险:一个拥有数百万参数的网络,如果只看过几千个样本,完全可以记住每一个样本的答案,而不是学到真正的规律。

识别过拟合的方法很直接:训练损失持续下降,但验证损失开始回升。两条曲线之间的差距越大,过拟合越严重。这种”训练集好、验证集差”的模式,是所有机器学习工程师最熟悉的告警信号。

与过拟合相对的概念是欠拟合(Underfitting):模型太简单,连训练数据中的规律都没学到。欠拟合通常表现为训练损失和验证损失都很高。好的模型处于两者之间——训练损失低,验证损失与训练损失差距小。这个平衡点叫做偏差-方差权衡(Bias-Variance Tradeoff):太简单的模型有高偏差(Bias),太复杂的模型有高方差(Variance)。

一个有趣的发现来自 Zhang et al., 2017 — Understanding Deep Learning Requires Rethinking Generalization。研究者发现,即便给神经网络喂入完全随机的标签(把猫的图片随机标注为”狗”或”汽车”),网络仍然能把训练损失降到接近零——它只是在死记硬背。这个实验打破了一个朴素的想象:“只要在训练集上学好了,泛化自然会发生”。泛化能力来自数据本身的规律性,以及正则化手段对过度记忆的抑制。

1
# 过拟合监控示意(伪代码)
2
for epoch in range(epochs):
3
    train_loss = model.train(train_data)
4
    val_loss   = model.evaluate(val_data)
5
    gap = val_loss - train_loss
6
    if gap > threshold:   # 差距扩大 → 过拟合警告
7
        early_stop()

正则化:抑制过拟合的三种主要手段#

L2 正则化(权重衰减,Weight Decay)

L2 正则化的思路是在损失函数里加一个惩罚项,惩罚模型参数的平方和。直觉上,参数越大,模型对训练数据中每个细节越敏感;参数越小越均匀,模型的泛化能力反而更好。数学上,这等价于对参数施加一个朝向零点的持续拉力——每次更新参数时,不仅要朝梯度方向走,还要同时被往零方向拽一点点。

$L_{\text{total}} = L_{\text{task}} + \lambda \sum_i w_i^2$

其中 $\lambda$ 控制惩罚力度。这个超参数的调节是门学问:太小了不起效,太大了又让模型欠拟合(参数全被压成很小的值,模型没有足够的表达能力)。在实践中,$\lambda$ 的典型值在 $10^{-4}$ 到 $10^{-2}$ 之间,通常通过在验证集上搜索来确定。

AdamW 优化器之所以叫”W”,正是因为它实现了解耦的权重衰减(Decoupled Weight Decay),把这个正则化手段做对了——后面的优化器部分会详细解释为何”做对”很关键。

L1 正则化

L1 正则化把惩罚项从参数平方和改成参数绝对值之和:

$L_{\text{total}} = L_{\text{task}} + \lambda \sum_i |w_i|$

与 L2 相比,L1 的一个关键差别是:它更倾向于产生稀疏解——也就是说,会把一部分参数精确压缩到零,而不只是压缩到接近零。这在特征选择场景下很有用:如果你有 1000 个候选特征,L1 会自动把不重要的特征对应的权重置零,相当于做了自动筛选。

L1 在神经网络中的使用频率低于 L2,原因是梯度在零点处不连续(绝对值函数的导数在 0 处无定义),优化器处理起来比 L2 麻烦。在模型压缩领域,L1 正则化是”权重剪枝(Weight Pruning)“的理论基础——通过 L1 获得的稀疏模型,推理时可以跳过零值权重,节省计算资源。

Dropout

Dropout 是深度学习领域特有的正则化手段,由 Srivastava et al., 2014 — Dropout: A Simple Way to Prevent Neural Networks from Overfitting 提出。训练时,在每一个前向传播步骤中,随机把一定比例 $p$(通常 10%–50%)的神经元输出置为零。随机性带来的效果是:网络不能过度依赖任何单个神经元来存储特定的信息,每个神经元必须学会在同事可能”请假”的情况下仍然发挥作用。

推理阶段,Dropout 被关闭,所有神经元都参与计算。为了保持训练和推理阶段期望输出的一致性,通常在推理时把所有神经元的输出乘以 $(1-p)$,或者等价地,在训练时把留下的神经元输出除以 $(1-p)$——后者叫做 Inverted Dropout,是当代框架的主流实现方式。

值得注意的是,在超大规模 LLM 预训练中,Dropout 的使用正在减少。LLaMA 3、Mistral、Gemma 等模型的技术报告显示 Dropout 率为 0 或接近 0。这有两方面原因:一是预训练数据量本身就足够大,过拟合的风险比小数据集低得多;二是某些研究发现,在 Transformer 中高 Dropout 率反而会干扰注意力机制的学习。权重衰减(L2)和精心设计的数据过滤管道,已经承担了原本 Dropout 在正则化方面的职责。

损失函数:交叉熵就是”猜对下一个词”的目标#

损失函数(Loss Function)是衡量模型预测有多差的数学指标。训练的目标是找到一组参数,让损失在训练集上尽可能小。不同任务使用不同的损失函数:回归任务常用均方误差(MSE),分类任务常用交叉熵(Cross-Entropy)。

LLM 的预训练任务——next-token prediction——是一道多分类问题:给定前面的词元序列,从词汇表中所有词元(GPT-2 的词汇表约 50000 个词元)中选出最可能的下一个。模型输出的是一个概率分布,覆盖所有候选词元。这个任务的损失函数正是交叉熵:

$\mathcal{L} = -\sum_{t=1}^{T} \log P(x_{t} \mid x_1, \ldots, x_{t-1})$

对序列中每个位置 $t$,取模型预测正确词元 $x_t$ 的概率的负对数,累加求和。当模型对正确词元给出概率 1.0 时,损失为 0;当概率为 0.01 时,损失为 $-\log(0.01) \approx 4.6$。这个数值越小,意味着模型的”猜词能力”越强。

这个看似简单的目标函数,驱动了 LLM 几乎所有的能力。要想持续猜对下一个词,模型必须掌握:

• 语法:能猜对词序,说明已内化语言的句法规则
• 事实知识:“中国的首都是__“,要猜对”北京”,模型必须存储地理事实
• 逻辑推理:“如果 A > B 且 B > C,则 A__C”,要猜”>“就要做简单推断
• 文体风格:同样的内容,诗歌和新闻的下一个词分布完全不同

Radford et al., 2019 — Language Models are Unsupervised Multitask Learners 一文把这一点说得清楚:语言模型的目标函数天然涵盖了无数隐含任务,next-token prediction 是一把万能钥匙。GPT-2 在没有任何任务专用训练的情况下,通过语言建模目标就获得了翻译、问答、摘要等多种能力的雏形。

timeline
    title 深度学习优化器演进时间线
    1951 : SGD — 随机梯度下降(Robbins & Monro)
    1986 : 反向传播 — 梯度计算高效化(Rumelhart et al.)
    2011 : AdaGrad — 自适应学习率首次出现(Duchi et al.)
    2012 : RMSprop — 指数加权移动平均方差,解决 AdaGrad 衰减(Hinton)
    2014 : Adam — 一阶矩+二阶矩,成为深度学习默认(Kingma & Ba)
    2017 : AdamW — 解耦权重衰减,修正 Adam 正则化缺陷(Loshchilov & Hutter)
    2019 : LAMB — 超大 Batch 训练专用,BERT 76 分钟完成(You et al.)
    2022 : Lion — 符号动量更新,内存占用低于 Adam(Chen et al.)
    2024 : Muon — 正交梯度,训练 FLOPs 降低约 48%(Keller Jordan)
    2026 : AdaMuon — Muon + 元素级自适应,ICLR 2026(Chen et al.)

SGD:最基础的下山方式#

随机梯度下降(SGD,Stochastic Gradient Descent)的逻辑极其简单:计算损失函数对当前参数的梯度,朝着梯度反方向走一小步。“随机”的含义是每次只用训练集中的一小批数据(Mini-batch)来估算梯度,而不是全部数据。

$w \leftarrow w - \eta \cdot \nabla_w \mathcal{L}$

其中 $\eta$ 是学习率,控制步长大小。

SGD 的问题在于:它对所有参数用同一个学习率。然而真实的神经网络中,不同参数的梯度规模差异巨大。词嵌入矩阵的某些行可能每次只被稀疏地更新——因为对应的词在这批数据里根本没出现。固定学习率意味着要么步子太小(低频参数几乎不动),要么步子太大(高频参数跳过最优点)。对于 Transformer 这种参数规模达到数百亿、梯度分布极度不均匀的模型,纯粹的 SGD 实际上是跑不起来的。Kempner Institute, 2024 — Anything but SGD: Evaluating Optimizers for LLM Training 通过实验证实了这一点:标准 SGD 带动量在 LLM 训练中的最优性能显著落后于自适应方法。

Adam:自适应学习率的突破#

Adam(Adaptive Moment Estimation,自适应矩估计)由 Kingma & Ba, 2014 提出,是目前使用最广泛的优化器之一。核心思想是为每个参数维护两个移动平均量:

• 一阶矩 $m_t$(梯度的移动平均):记住梯度的方向,相当于动量
• 二阶矩 $v_t$(梯度平方的移动平均):记住梯度的”波动程度”

更新规则如下:

$m_t = \beta_1 m_{t-1} + (1-\beta_1) g_t$ $v_t = \beta_2 v_{t-1} + (1-\beta_2) g_t^2$ $\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}$ $w \leftarrow w - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$

分母 $\sqrt{v_t}$ 的作用正是自适应学习率:若某个参数的历史梯度很大(已经走得很快),实际步长就会被压缩;若历史梯度很小(这个方向更新很慢),步长就被放大。典型超参数值是 $\beta_1=0.9$, $\beta_2=0.999$, $\epsilon=10^{-8}$。

Adam 的优势很明显:对超参数不敏感,开箱即用效果好,训练初期收敛速度快。缺点是内存开销:需要为每个参数额外存储两个浮点数(一阶矩和二阶矩),优化器状态的内存占用等于模型参数量的两倍。对于一个 70B 参数的模型,BF16 格式存参数需要约 140GB,优化器状态再需要 280GB,总计超过 420GB。

AdamW:修正了一个隐藏 Bug#

Adam 很好,但有一个被长期忽视的设计缺陷 正则化在 Adam 中并没有起到预期的效果。

原始 Adam 中,添加 L2 正则化的常见方式是把 $\lambda w$ 加进梯度里,然后一起做自适应缩放。问题是:自适应缩放会把这个正则化项也一起缩放。对于历史梯度大的参数,自适应步长本来就小,正则化力度也被同比压缩;对于历史梯度小的参数,正则化力度被放大。最终效果是:不同参数受到的正则化程度完全不均匀,达不到”让所有参数都稳定向零收敛”的预期效果。正则化名存实亡。

Loshchilov & Hutter, 2017 — Decoupled Weight Decay Regularization 提出了解决方案:把权重衰减从梯度更新中解耦出来,单独在参数空间执行。

$w \leftarrow (1 - \eta\lambda) w - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$

第一项 $(1 - \eta\lambda) w$ 是纯粹的权重衰减,不受自适应缩放影响;第二项才是梯度更新部分。这个改动在公式上只有一行之差,但在实验上带来了显著的泛化性能提升,尤其在语言建模和图像识别任务上。

这就是”AdamW”名字里”W”的来历 Weight Decay。截至 2025 年,GPT 系列、LLaMA 系列、Gemma、Mistral 等几乎所有主流开源 LLM 的预训练和微调阶段均默认使用 AdamW。权重衰减系数通常设置为 $0.1$,学习率常采用余弦退火(Cosine Annealing)调度。

Muon:正交梯度的新思路#

AdamW 虽然稳定可靠,但并非完美。2024 年底,Keller Jordan 提出了 Muon(MomentUm Orthogonalized by Newton-Schulz),提供了一种从根本上不同的更新策略。

Muon 的核心思想是:在执行梯度更新之前,先把动量矩阵做一次”正交化”处理。具体来说,对于一个权重矩阵 $W \in \mathbb{R}^{m \times n}$,动量 $M$ 也是同维度的矩阵。Muon 通过 Newton-Schulz 迭代算法,将 $M$ 变换成一个近似正交矩阵 $\tilde{M}$,满足 $\tilde{M}\tilde{M}^T \approx I$,然后用 $\tilde{M}$ 来更新参数。

1
# Muon 更新示意(伪代码)
2
M = beta * M + (1 - beta) * grad    # 更新动量
3
M_orth = newton_schulz(M)           # 正交化处理
4
W = W - lr * M_orth                 # 用正交化动量更新参数

正交化带来的效果是:更新向量的奇异值谱更加均匀,每个方向都能得到相对平等的更新,不会被少数大梯度方向所主导。这类似于对梯度做了一种”均衡化”——不是压缩梯度幅度(像 Adam 那样),而是调整更新的方向分布。

实验结果表明,Kosson et al., 2025 — Muon is Scalable for LLM Training 证明 Muon 能够将达到相同损失所需的训练 FLOPs 降低约 48%——即只需 AdamW 约 52% 的计算量就能达到相同模型质量。对于大规模 LLM 训练,这意味着数百万美元的算力节约。

值得注意的是,Muon 目前只适用于 2D 权重矩阵(如 Transformer 的注意力投影矩阵 $W_Q, W_K, W_V$ 和前馈层权重)。Embedding 层是 1D 向量的集合,输出分类头也有其特殊性,这两者仍然需要 AdamW。因此实践中通常是混合策略:隐藏层用 Muon,边界层用 AdamW。

截至 2026-05-09,ICLR 2026 收录的 AdaMuon 进一步将元素级自适应引入 Muon 框架,试图同时获得正交更新和自适应步长的双重优势。这个方向仍在快速演进,能否成为下一个”默认优化器”,尚需更大规模验证。

幂律:规模与性能之间的稳定关系#

2020 年,OpenAI 的 Kaplan et al. — Scaling Laws for Neural Language Models 首次系统地研究了这一问题。研究者训练了大量不同规模的语言模型,测量损失与三个因素的关系:模型参数量 $N$、数据量 $D$、计算量 $C$。结论令人意外地简洁:

$L(N) \approx \left(\frac{N_0}{N}\right)^{\alpha_N}, \quad L(D) \approx \left(\frac{D_0}{D}\right)^{\alpha_D}$

每一个维度单独增大时,损失都以幂律方式下降。更惊人的是,这个规律在跨越数个数量级的实验范围内保持稳定——从数百万参数的小模型到数百亿参数的大模型,直线没有出现明显的”墙”。

这个发现有深远的工程含义:它意味着可以用小规模实验来预测大规模训练的结果。在投入数千万美元训练一个大模型之前,先用几十万美元的小实验拟合出幂律曲线,再外推到目标规模——这是所有大型 LLM 项目的标准实践。

Kaplan et al. 当时的结论倾向于认为,给定固定算力,应优先扩大模型参数量,而非扩大数据量。这一结论深刻影响了此后两年的模型设计。GPT-3(175B 参数,训练数据 300B tokens)正是这种”参数优先”思路的产物——在当时看来,参数越多越好,数据量反倒是次要因素。

Chinchilla:纠正了方向#

2022 年,DeepMind 的 Hoffmann et al. — Training Compute-Optimal Large Language Models(即 Chinchilla 论文)给出了一个不同答案。研究者训练了超过 400 个语言模型,参数量从 7000 万到 160 亿,数据量从 50 亿到 5000 亿词元,系统地扫描了算力预算的各种分配方式。

核心结论如下:在固定计算预算下,模型参数量 $N$ 和训练数据量 $D$ 应该等比例扩大。 换算成直接的比例:每个参数应对应约 20 个训练词元。这与 Kaplan et al. 使用的约 1.7 tokens/param 的比例相差悬殊。

研究者用 Chinchilla 模型验证了这一结论:70B 参数,训练 1.4 万亿词元。与 GPT-3(175B 参数,300B 词元)使用相近的计算量,但 Chinchilla 在几乎所有下游任务上显著超越了 GPT-3。更小的模型、更多的数据,反而赢了。这说明在 Kaplan et al. 的实验框架下,当时的大型模型普遍数据欠充分(undertrained)——它们的规模已经超前,但数据量没有跟上。

1
# Chinchilla 最优计算分配(伪代码)
2
# 给定算力预算 C(FLOPs)
3
# 最优分配: N = D ∝ C^0.5
4
# 即: tokens_per_param ≈ 20
5
N_optimal = sqrt(C / 6)   # 6 ≈ 每个参数每个 token 的 FLOPs
6
D_optimal = 20 * N_optimal

这一发现直接影响了后来的 LLaMA 系列设计。Touvron et al., 2023 — LLaMA: Open and Efficient Foundation Language Models 明确引用 Chinchilla 结论,选择了比当时主流更小但训练更长的策略:7B 参数模型训练超过 1 万亿词元。LLaMA-7B 在推理效率上远超同期的大参数模型,成为此后开源社区大量工程工作的基础。

超越 Chinchilla:当推理成本也要算进来#

Chinchilla 结论的前提是:只优化训练损失,不考虑推理成本。但在真实部署中,一个受欢迎的模型可能每天被调用数十亿次,推理成本绝不可忽视。

Sardana & Frankle, 2024 — Beyond Chinchilla-Optimal: Accounting for Inference in Language Model Scaling Laws 提出了一个扩展框架。直觉上,两个计算成本相近的方案:方案 A 是 7B 参数模型训练 2T tokens,方案 B 是 14B 参数模型训练 1T tokens。训练成本相当,但推理时方案 A 每次只需 7B 参数的计算量,方案 B 需要 14B。如果这个模型被调用 10 亿次,两者的推理成本差距会远超训练差距。

结论是:如果一个模型预期的推理请求量足够大(例如 10 亿次以上),最优策略是将模型训练得比 Chinchilla 更小、数据更多——因为更小的模型推理更快,推理成本的节约可以超过额外训练数据的投入。

截至 2026 年 Laws 的新边界#

截至 2026-05-09,模型训练的 tokens-to-params 比例已经远超 Chinchilla 的 20:1 预测。

根据 AIMultiple 的整理:

这些极端比例下的训练结果表明:模型质量在 tokens/param 远超 Chinchilla 推荐值时仍在持续提升。这一趋势背后有一个现实驱动:随着芯片供应链的瓶颈和推理端需求的爆发,行业正在从”训练成本最优”转向”推理成本最优”。训练一次,推理无数次——把训练做得更充分,每一次推理都能因为模型更小而变得更便宜。

graph LR
    A["固定算力预算 C"] --> B{分配策略}
    B -->|Kaplan 2020| C["大模型 + 少数据\n代表: GPT-3 175B/300BT\ntokens/param ≈ 1.7"]
    B -->|Chinchilla 2022| D["模型与数据均衡扩大\n代表: Chinchilla 70B/1.4TT\nLLaMA-7B/1TT\ntokens/param ≈ 20"]
    B -->|Beyond Chinchilla 2024+| E["小模型 + 海量数据\n+ 考虑推理请求量\n代表: Qwen3-0.6B/36TT\nLFM2.5-350M/28TT\ntokens/param ≈ 60000–80000"]
    C --> F["训练损失低\n但推理慢且贵"]
    D --> G["训练/推理均衡\n仍是基准参考"]
    E --> H["推理成本最优\n适合高频调用场景"]

7.1 Query、Key、Value:信息检索的比喻#

Attention 的计算可以用一个信息检索的比喻来理解。想象你在图书馆里查资料:

• Query(查询 Q):你手上的检索词,描述你想找什么
• Key(键 K):每本书的目录标题,描述这本书讲什么
• Value(值 V):每本书的实际内容

查询过程是:用你的 Query 与每本书的 Key 计算相似度(匹配程度),相似度高的书获得更多”注意力”,最后把所有书的 Value 按注意力权重加权求和,得到你要的信息。

在 Transformer 中,Q、K、V 都是输入向量经过线性变换后得到的:

其中 $X$ 是输入序列,$W_Q, W_K, W_V$ 是可学习的权重矩阵。然后计算 Attention 输出:

逐步拆解这个公式:

1. $QK^\top$ 计算所有 Query-Key 对的点积,得到相似度分数矩阵,维度为 $(\text{序列长度}) \times (\text{序列长度})$
2. 除以 $\sqrt{d_k}$(其中 $d_k$ 是 Key 的维度),防止点积值过大导致 softmax 梯度消失
3. softmax 把分数归一化为总和为 1 的权重分布
4. 用这个权重对 $V$ 加权求和,得到最终输出

这个设计的核心优势在于:序列中任意两个位置之间的”交互”只需要一次矩阵乘法,不需要信息逐步传递。第 1 个词和第 500 个词的关系,跟第 1 个词和第 2 个词的关系在计算路径上是完全等价的。

7.2 多头注意力:从多个角度看问题#

单个 Attention 头只能关注一种类型的关系。多头注意力(Multi-Head Attention, MHA)把 Q、K、V 分别映射到 $h$ 个不同的子空间,每个头独立计算 Attention,最后拼接:

不同的头可以学到不同的依赖关系。比如在句子”The animal didn’t cross the street because it was too tired”中,某个头可能学到”it”指向”animal”,另一个头可能学到”tired”与”it”的状态关系。

7.3 位置编码:给 Attention 补上空间信息#

Attention 机制本身是置换不变的:把输入序列随机打乱顺序,输出不变(因为只看 Q-K 相似度,不看位置)。然而语言中顺序至关重要,“狗咬人”和”人咬狗”意思完全不同。

Transformer 通过位置编码(Positional Encoding)解决这个问题。原版 Vaswani et al., 2017 使用正弦/余弦编码:

把位置编码与词向量相加后输入模型,使得模型能区分不同位置的 token。当代 LLM 普遍使用 RoPE(Rotary Position Embedding)(Su et al., 2021),它通过旋转矩阵对位置信息编码,在扩展上下文长度时表现更好,Llama、DeepSeek、Qwen 等主流模型均采用这一方案。

7.4 前馈层与残差连接#

每个 Transformer 层除了自注意力,还包含一个前馈网络(Feed-Forward Network, FFN):

典型设置是中间维度为模型维度的 4 倍。前馈层负责对每个位置的向量进行独立的非线性变换,可以理解为”信息提炼”阶段。

残差连接(Residual Connection)是深层训练的关键基础设施。He et al., 2015 — Deep Residual Learning for Image Recognition 最初在 CNN 上提出,Transformer 沿用了这一设计:

把输入直接加到输出上(跳跃连接),梯度在反向传播时可以”走捷径”直接流回早期层,有效缓解了梯度消失,使数十层乃至数百层的深度网络成为可能。

graph TD
    A["输入 Token 序列"] --> B["词嵌入 + 位置编码"]
    B --> C["Transformer Block × N"]
    C --> D["输出层 (语言模型头)"]
    
    subgraph "Transformer Block (重复 N 次)"
        E["输入 x"] --> F["Multi-Head Self-Attention"]
        F --> G["Add & LayerNorm"]
        G --> H["Feed-Forward Network"]
        H --> I["Add & LayerNorm"]
        E -->|"残差连接"| G
        G -->|"残差连接"| I
    end

7.5 层归一化与初始化#

Transformer 还有一个容易忽视但至关重要的组件:层归一化(Layer Normalization, LayerNorm)。与批归一化(Batch Normalization)对同一批次中不同样本的同一特征维度做归一化不同,LayerNorm 对同一样本在同一层内的所有特征做归一化:

其中 $\mu$ 和 $\sigma$ 是该层激活值的均值和标准差,$\gamma$ 和 $\beta$ 是可学习的缩放和偏移参数。LayerNorm 的作用是把每层的激活值归一化到近似标准正态分布,使得梯度传播更稳定。

原版 Transformer 在子层之后做归一化(Post-LN),但实践中发现训练初期不稳定。当代 LLM 普遍改用 Pre-LN:在子层之前做归一化,配合良好的初始化策略,使得数百层的深度模型也能稳定训练。此外,Llama 系列还用 RMSNorm(Root Mean Square Layer Normalization,Zhang & Sennrich, 2019)替代 LayerNorm,去掉了均值中心化步骤,计算开销更低且效果相当。

权重初始化策略对深层训练同样关键。若初始权重过大,前向传播中激活值会指数级放大;若过小,信号在深层中消失。Xavier 初始化(Glorot & Bengio, 2010)和 He 初始化(He et al., 2015)根据层的输入输出维度自适应地设定权重方差,是深度网络训练能稳定收敛的工程基础。

7.6 计算复杂度的代价#

Attention 的全局交互能力有一个严峻的代价:时间和内存复杂度都是 $O(n^2)$,其中 $n$ 是序列长度。对于 1,000 个 token 的序列,需要计算 $10^6$ 个注意力分数;对于 100,000 个 token,则是 $10^{10}$。随着 LLM 上下文窗口从 2,048 扩展到 128,000 乃至更长,这一平方增长成为性能瓶颈,催生了后文要讲的诸多优化方案。

在注意力分数矩阵这 $n^2$ 个数中,相当一部分权重在 softmax 后接近零(即大多数位置对特定 query 并不相关)。稀疏 Attention 的研究思路是:能否在不丢失关键信息的前提下,只计算其中一部分注意力分数?Longformer(Beltagy et al., 2020) 结合滑动窗口局部注意力和少量全局 token,将复杂度降至 $O(n)$,处理长达 16,384 token 的序列。BigBird(Zaheer et al., 2020) 在此基础上加入随机注意力,从理论上证明稀疏注意力可以模拟完整注意力的表达能力。这些工作奠定了长上下文处理的理论基础,尽管 FlashAttention 通过工程优化把”全量 Attention”的实际成本大幅压缩,使稀疏近似的必要性在一定程度上降低。

8.1 FlashAttention:让硬件物尽其用#

标准 Attention 实现的瓶颈不在于 FLOP 数量,而在于内存带宽。GPU 有两级存储:高带宽内存(HBM,容量大但慢)和片上 SRAM(极快但只有几十 MB)。标准实现在计算 softmax 时需要把巨大的注意力矩阵写回 HBM,再读回来,这种反复的数据搬运远比矩阵乘法本身耗时。

FlashAttention(Dao et al., 2022) 重新设计了计算顺序,通过分块计算(tiling)把整个 Attention 计算限制在 SRAM 内完成,大幅减少 HBM 访问次数。结果是完全相同的输出,但速度提升 2-4×,内存占用从 $O(n^2)$ 降到 $O(n)$。

FlashAttention-3(Dao, 2024) 专为 NVIDIA H100 GPU 设计,利用异步 Tensor Core 与 TMA(Tensor Memory Accelerator)的重叠计算,以及 FP8 低精度支持,在 H100 上达到 740 TFLOPs/s(FP16)和接近 1.2 PFLOPs/s(FP8),相比标准实现快 3-16×。这一工作于 2024 年发表,截至 2026-05-09 已成为主流训练框架的标准组件。

8.2 MoE:以稀疏换算力#

混合专家模型(MoE, Mixture of Experts)的核心思想是:不需要每个输入都激活模型的全部参数,只激活其中的一小部分”专家”就够了。

在 MoE 层中,原本的前馈网络被替换成 $E$ 个并行的专家网络(expert),加上一个路由器(router)决定每个 token 送去哪几个专家:

其中路由器输出门控权重 $g_i$,Top-$k$ 通常取 2 或 4。

以 DeepSeek-V3 为例(DeepSeek-AI, 2024):模型总参数量 6710 亿,但每个 token 只激活约 370 亿参数。这意味着推理时的计算量只相当于 370 亿参数的稠密模型,而知识容量却接近 6710 亿。

截至 2026-05-09,主流 MoE 模型在专家数量上持续扩张。根据 FriendliAI 的对比报告,GPT-OSS-120B 使用 128 个专家,Qwen3 使用 128 个专家,DeepSeek-R1-0528 使用 256 个专家,LLaMA-4 Maverick 同样使用 128 个专家。GPT-OSS 甚至使用原生 MXFP4 精度量化 MoE 层,使整个 120B 模型能运行在单张 80 GB H100 上。

MoE 的主要工程挑战是负载均衡:如果路由器总把 token 送给同几个专家,其他专家形同虚设,计算资源被浪费,模型也无法从专家分工中获益。早期方案通过在损失函数中加入辅助均衡损失(auxiliary balance loss)来惩罚负载不均,但这会与主任务目标产生冲突,需要仔细调参。DeepSeek 在路由机制中引入了专家偏置项(expert bias),在训练过程中动态调整以保持均衡,效果优于依赖辅助损失的传统方案(Epoch AI 分析)。

MoE 在推理时还面临通信开销问题。在多 GPU 分布式推理中,不同专家可能部署在不同设备上,token 路由需要跨卡通信。DeepSeek-V3 在多节点部署时引入了 Expert Parallelism(专家并行)和冗余专家(redundant expert)机制,在高负载时复制热门专家到多个设备,减少跨节点通信等待。这些工程细节使 DeepSeek-V3 能以接近稠密小模型的延迟服务生产流量。

8.3 MLA:把 KV Cache 压缩 57 倍#

在推理时,Transformer 需要缓存每一层每个已生成 token 的 Key 和 Value(即 KV Cache),以避免重复计算。KV Cache 的内存占用随序列长度线性增长,是长上下文推理的主要成本。

DeepSeek 在 V2/V3/R1 系列中引入了 MLA(Multi-Head Latent Attention,多头潜在注意力)(DeepSeek-AI, 2024):把 Key 和 Value 向量压缩进一个低维潜在向量(latent vector)存储,推理时再投影回高维。这将 KV Cache 的大小压缩了约 57 倍,推理速度提升超过 6 倍,且不牺牲模型性能。根据 Lior Sinai 的技术分析,MLA 与 GQA(Grouped Query Attention)相比在压缩率上有数量级优势。

8.4 Mamba:突破平方复杂度的 SSM#

State Space Model(SSM,状态空间模型)是一类借鉴控制理论的序列模型,用连续状态方程描述序列演化。Mamba(Gu & Dao, 2023) 在 SSM 基础上引入了选择性机制 的参数根据输入动态变化,使得模型可以选择性地”记住”或”忘记”历史信息,而非对所有时间步均等处理。

Mamba 的计算复杂度是 $O(n)$,相比 Transformer 的 $O(n^2)$ 在长序列上有巨大优势。Gu & Dao, 2023 报告显示,对于序列长度超过 2K 的情况,Mamba 的扫描实现比 FlashAttention-2 更快。

Mamba-2(Dao & Gu, 2024) 从理论上证明了某些 SSM 与某些形式的线性 Attention 在数学上是等价的,打通了两个原本被视为对立的研究方向。

Mamba-3(arxiv 2603.15569) 于 2026 年发布,标题为”Improved Sequence Modeling using State Space Principles”。在 1.5B 参数规模下,Mamba-3 在平均下游准确率上比下一个最优模型高 0.6 个百分点,其 MIMO 变体进一步提升 1.2 个百分点。Mamba-3 的发布表明 SSM 路线在 2026 年仍处于活跃演进中,尚未确定能否在大规模预训练上全面取代 Transformer。

graph TD
    A["序列建模需求"] --> B{主要问题}
    B -->|空间局部性| C["CNN 卷积核扫描提取特征 O(n)"]
    B -->|时序依赖| D["RNN/LSTM 隐藏状态记忆 无法并行"]
    D -->|长程依赖+并行| E["Transformer Self-Attention 全局交互 O(n²)"]
    E -->|内存效率| F["FlashAttention 分块计算 IO 优化 更快速度"]
    E -->|参数效率| G["MoE 稀疏激活 知识容量 vs 算力解耦"]
    E -->|KV Cache 压缩| H["MLA 潜在向量压缩 57x KV Cache 减少"]
    E -->|"O(n²) 瓶颈"| I["Mamba / SSM 线性复杂度 O(n)"]

向量的长度(范数)#

向量的长度用勾股定理推广计算,英文叫 norm(范数),写作 $\|\mathbf{v}\|$:

对上面那个三维向量:$\|\mathbf{v}\| = \sqrt{9 + 1 + 49} = \sqrt{59} \approx 7.68$

这个量的实际意义是向量的”幅度”大小。如果你把向量的每个元素都除以它的长度,得到的新向量长度恰好为 1,称为单位向量(unit vector)或归一化向量(normalized vector)。

向量加法和标量乘法#

向量加法就是对应位置相加:

标量乘法就是每个元素都乘以同一个数:

这两个操作看起来平凡,但它们组合在一起就是”线性组合”——用若干个向量各乘一个系数再求和。线性代数的核心操作几乎都能用线性组合表达。

LLM 中的向量#

在 LLM 里,每个 Token(可以理解为一个词片段)都被映射到一个高维向量,称为 Embedding。这个映射由一张查找表完成:词汇表里每个 Token 对应一行,整个查找表就是一个矩阵,形状为 $(V, d)$,其中 $V$ 是词汇表大小,$d$ 是 Embedding 维度。

以 GPT-2 small 为例,$V = 50257$,$d = 768$。处理一个 Token 时,模型直接查表取出对应的 768 维向量,这就是该 Token 的初始表示。后续 Transformer 层不断对这个向量做线性变换和非线性激活,最终在输出层把它变回一个 $V$ 维的概率分布,预测下一个 Token。

常用开源 LLM 的 Embedding 维度对比如下:

来源:Meta Llama 3.1 技术报告

可以看出一个规律:模型越大,$d$ 越大,但头维度 $d_k$ 相对稳定在 128 左右。这是因为 $d_k$ 过小会限制每个 head 的表达能力,过大则会导致点积值方差过大(回忆 $\sqrt{d_k}$ 的缩放因子),工程上 128 是经过大量实验验证的合理值。

把 Embedding 维度 $d$ 看作”语义描述精度”:768 维可能让模型把词的词性、主题、情感等属性分别编码在不同方向上;16384 维则能精细区分更多细粒度的语义属性。但维度增加带来的参数量和计算量是平方级增长的——Attention 的 Q/K/V 投影矩阵大小是 $d \times d_k$,维度翻倍,参数量也翻倍——因此选择合适的 $d$ 本质上是能力和资源之间的权衡。

矩阵的转置#

矩阵的转置(transpose)用上标 $\top$ 表示,操作是把行列互换:

原来是 $2 \times 3$,转置后变成 $3 \times 2$。转置操作在 Attention 推导里会频繁出现,因为我们需要把 $\mathbf{K}$($\text{seq\_len} \times d_k$)变成 $\mathbf{K}^\top$($d_k \times \text{seq\_len}$)才能和 $\mathbf{Q}$ 相乘。

常见矩阵运算速查#

1
# 向量点积:对应元素相乘,求和,结果是一个标量
2
dot(a, b) = sum(a[i] * b[i])
3

4
# 矩阵乘法:C[i,j] = dot(A 的第 i 行, B 的第 j 列)
5
matmul(A, B)[i, j] = dot(A[i, :], B[:, j])
6

7
# 余弦相似度:点积 ÷ 两向量长度乘积
8
cosine_sim(a, b) = dot(a, b) / (norm(a) * norm(b))
9

10
# softmax:把一行数值转为概率分布
11
softmax(x)[i] = exp(x[i]) / sum(exp(x[j]) for j in range(n))

这四个操作是 Transformer forward pass 里出现频率最高的基本单元。理解它们的输入/输出形状,是读懂任何 LLM 架构图的前提。

点积的几何含义#

点积和夹角有这样的关系:

其中 $\theta$ 是两个向量之间的夹角。这个公式告诉我们:

• 两个向量方向完全相同($\theta = 0°$)时,$\cos\theta = 1$,点积取到最大正值
• 两个向量垂直($\theta = 90°$)时,$\cos\theta = 0$,点积为 0,两向量”正交”,互不相关
• 两个向量方向相反($\theta = 180°$)时,$\cos\theta = -1$,点积取到最大负值

因此,点积的正负和大小直接反映两个向量的”朝向一致程度”。

余弦相似度#

把点积除以两个向量的长度,就得到余弦相似度(cosine similarity):

这个值在 $[-1, 1]$ 之间。值为 1 表示完全相似,值为 0 表示无关,值为 -1 表示完全相反。

余弦相似度是 LLM 里衡量语义相似度的核心操作。在向量数据库(如 Faiss、Weaviate)中搜索和用户查询最相似的文档时,本质上就是在计算查询向量和所有文档向量的余弦相似度,取最高的几个返回。搜索”猫”和”狗”的 Embedding 向量,余弦相似度通常在 0.7 以上;搜索”猫”和”量子力学”,余弦相似度通常低于 0.2。

余弦相似度在实际系统里常见的两种应用场景:一是 RAG(Retrieval-Augmented Generation,检索增强生成)里的文档检索,把用户问题转成向量后,找余弦相似度最高的文档块作为上下文;二是 Attention 机制里的注意力得分计算——虽然原始 Attention 用的是未归一化的点积而非余弦相似度,但两者衡量的是同一件事:两个向量的方向一致程度。

1
# 余弦相似度的伪代码
2
def cosine_sim(a, b):
3
    return dot(a, b) / (norm(a) * norm(b))
4

5
# 在向量数据库中找最相似的文档
6
query_vec = embed(user_query)
7
scores = [cosine_sim(query_vec, doc_vec) for doc_vec in doc_store]
8
top_k = argsort(scores, descending=True)[:k]

定义#

给定矩阵 $\mathbf{A}$($m \times k$)和矩阵 $\mathbf{B}$($k \times n$),它们的乘积 $\mathbf{C} = \mathbf{A}\mathbf{B}$ 是一个 $m \times n$ 的矩阵,其中第 $i$ 行、第 $j$ 列的元素是:

也就是 $\mathbf{A}$ 的第 $i$ 行向量与 $\mathbf{B}$ 的第 $j$ 列向量的点积。

注意维度要求:$\mathbf{A}$ 的列数必须等于 $\mathbf{B}$ 的行数(都是 $k$)。内维度必须匹配,否则点积无法计算。

一个完整的 $2 \times 2$ 例子#

计算 $\mathbf{C} = \mathbf{A}\mathbf{B}$:

为什么这个规则有意义#

矩阵乘法的设计目标是表示两个线性变换的复合。如果矩阵 $\mathbf{A}$ 描述”把向量从空间 X 变换到空间 Y”,矩阵 $\mathbf{B}$ 描述”把向量从空间 Y 变换到空间 Z”,那么 $\mathbf{B}\mathbf{A}$ 就直接描述”把向量从空间 X 变换到空间 Z”——两步合一步。

行×列的规则是保证这个”复合”性质成立的唯一合法定义。如果改成对应位置相乘(element-wise),就失去了”变换复合”的语义,不是矩阵乘法。这也是为什么矩阵乘法不满足交换律——两个变换的顺序不同,结果通常不同。

一个直观的类比:先旋转 45° 再镜像,和先镜像再旋转 45°,结果截然不同。Transformer 里的每一层都是一次变换复合,层与层之间的顺序同样不能随意调换。

矩阵乘法的三个重要性质:

这三条性质直接影响到 LLM 的推理优化:结合律成立意味着可以自由选择矩阵相乘的顺序(先乘哪两个矩阵),在某些场景下能大幅减少计算量——这是 KV Cache 和 Flash Decoding 等推理加速技术的数学基础之一。

计算量#

对一个 $m \times k$ 的矩阵乘以 $k \times n$ 的矩阵,共需计算 $m \times n$ 个内积,每个内积需要 $k$ 次乘法和 $k-1$ 次加法,总计算量约为 $2mnk$ 次浮点运算(FLOPs)。当 $m = n = k = 4096$ 时,计算量约为 $1.37 \times 10^{11}$ FLOPs,约 137 GFLOPs。一张 NVIDIA A100 的 BF16 峰值算力是 312 TFLOPS,理论上可以在不到 0.5 毫秒内完成这个操作——这正是 LLM 推理能做到毫秒级响应的物理基础。

5.1 背景 解决什么问题#

在处理一段文字时,每个词的含义依赖于上下文。“苹果”在”吃了一个苹果”和”苹果发布了新手机”里含义完全不同。传统循环神经网络(RNN)只能把之前的信息”压缩”进一个固定大小的隐藏状态,长距离依赖容易被遗忘。

Attention 机制给出了一个根本不同的解法:让模型在处理每个词时,直接查看序列里所有其他词,并按重要程度动态加权汇聚它们的信息。这种”不受距离限制的全局查看”是 Transformer 架构的核心。

Attention 机制最早由 Bahdanau et al., 2014 — Neural Machine Translation by Jointly Learning to Align and Translate 在机器翻译中提出,彼时还嵌套在 RNN 里用于对齐源语言和目标语言。Vaswani et al., 2017 — Attention Is All You Need 把 RNN 完全去掉,证明仅靠 Attention 就能超越 RNN 的翻译质量,Transformer 由此诞生。

RNN 和 Transformer 在处理长距离依赖上的核心差异如下:

5.2 符号约定#

设输入序列有 $T$ 个 Token,每个 Token 已经被 Embedding 为一个 $d_{\text{model}}$ 维的向量。把所有 Token 的向量堆成一个矩阵:

$\mathbf{X}$ 的第 $i$ 行就是第 $i$ 个 Token 的向量表示。

5.3 Q、K、V 投影:把输入映射到三个子空间#

Attention 引入三套可学习的投影矩阵:

通过这三个矩阵把 $\mathbf{X}$ 投影到三个不同的子空间:

这三次操作是三次矩阵乘法。每次乘法都把同一个输入 $\mathbf{X}$ 投影到不同的”视角”:

• Q(Query,查询):代表”当前位置在问什么问题”
• K(Key,键):代表”每个位置对外广播的标签,回答我能回答什么问题”
• V(Value,值):代表”如果我被选中,实际传递过去的信息内容”

这三个名字借鉴了键值数据库(key-value store)的比喻:你用 Query 去检索,Key 决定匹配程度,Value 是实际取回的内容。

5.4 注意力得分矩阵#

现在计算每对位置之间的”匹配程度”。第 $i$ 个 Token 的 Query 向量 $\mathbf{q}_i$($d_k$ 维)和第 $j$ 个 Token 的 Key 向量 $\mathbf{k}_j$($d_k$ 维)的点积,反映了第 $i$ 个 Token 应该”关注”第 $j$ 个 Token 的程度。

把所有 $(i, j)$ 组合的点积一次性算出来,就是矩阵乘法:

$\mathbf{Q}$ 的形状是 $(T, d_k)$,$\mathbf{K}^\top$ 的形状是 $(d_k, T)$,所以 $\mathbf{S}$ 的形状是 $(T, T)$。$S_{ij}$ 就是第 $i$ 个 Token 对第 $j$ 个 Token 的原始注意力得分。

5.5 缩放:为什么要除以 $\sqrt{d_k}$#

为什么要除以 $\sqrt{d_k}$?考虑两个 $d_k$ 维的随机单位向量,它们的点积的方差是 $d_k$,标准差是 $\sqrt{d_k}$。当 $d_k$ 很大时,点积的数值会显著偏离零,导致 softmax 函数在极端值处梯度接近 0,参数更新停滞,训练无法进行。

除以 $\sqrt{d_k}$ 把方差压缩到 1,使 softmax 的输入数值处于合理范围。这个缩放因子由 Vaswani et al., 2017 — Attention Is All You Need 首次提出并沿用至今。

5.6 softmax:归一化为概率分布#

softmax 操作作用于矩阵的每一行。对第 $i$ 行的元素 $(s_{i1}, s_{i2}, \ldots, s_{iT})$:

归一化后的 $A_{ij}$ 满足:所有元素非负,每行元素之和为 1。这样 $A_{ij}$ 就可以解释为概率:第 $i$ 个 Token 在汇聚信息时,分配给第 $j$ 个 Token 的权重。

5.7 加权汇聚:得到最终输出#

注意力权重矩阵 $\mathbf{A}$($T \times T$)乘以 $\mathbf{V}$($T \times d_v$),得到输出矩阵($T \times d_v$)。这是第五次矩阵乘法。每个输出位置的向量是所有 Value 向量按注意力权重加权求和的结果:

词 “苹果” 在句子 “吃了一个苹果” 里,输出向量会主要汇聚 “吃”、“个” 等词的 Value 信息,赋予它”食物”的语义权重;在句子 “苹果发布了新手机” 里,会主要汇聚 “发布”、“手机” 等词的 Value 信息,转向”科技公司”的语义。这就是 Attention 动态调整词义的机制。

5.8 维度汇总#

整个 Attention 操作是五次矩阵乘法的流水线:三次投影($\mathbf{X}\mathbf{W}_Q$, $\mathbf{X}\mathbf{W}_K$, $\mathbf{X}\mathbf{W}_V$)、一次得分计算($\mathbf{Q}\mathbf{K}^\top$)、一次加权汇聚($\mathbf{A}\mathbf{V}$)。

5.9 Multi-Head Attention:多视角并行#

实际的 Transformer 不只用一组 $\mathbf{W}_Q, \mathbf{W}_K, \mathbf{W}_V$,而是用 $h$ 组,称为 Multi-Head Attention(MHA)。每组的 $d_k = d_v = d_{\text{model}} / h$,即把 $d_{\text{model}}$ 维空间切分成 $h$ 份,每份独立做 Attention。

GPT-2 small 有 12 个 head,$d_{\text{model}} = 768$,所以每个 head 的 $d_k = 64$。12 个 head 各自从不同的投影角度提取信息,有的 head 可能专注于句法结构,有的专注于指代关系,有的专注于语义主题。把 12 个 head 的输出拼接在一起(得到 $T \times 768$ 的矩阵),再经过一个输出投影矩阵 $\mathbf{W}_O \in \mathbb{R}^{768 \times 768}$,得到该层的最终输出。

Multi-Head Attention 的所有头可以并行计算,不存在依赖关系。这是 GPU 利用率高的又一个来源。

在实际实现中,MHA 通常不是 $h$ 次分开的矩阵乘法,而是把 $h$ 个 head 的 $\mathbf{W}_Q$ 拼成一个大矩阵 $\mathbf{W}_Q^{\text{all}} \in \mathbb{R}^{d_{\text{model}} \times (h \cdot d_k)}$,一次矩阵乘法得到所有 head 的 Q,然后在 batch 维度上拆开。这样做的原因是 GPU 对”大矩阵乘法”的利用率比”很多小矩阵乘法”高得多——大矩阵能填满更多 Tensor Core,小矩阵的 kernel 调度开销相对较大。

1
# MHA 的实际实现逻辑(伪代码)
2
Q_all = X @ W_Q_all           # (T, h * d_k)
3
K_all = X @ W_K_all           # (T, h * d_k)
4
V_all = X @ W_V_all           # (T, h * d_v)
5
Q = reshape(Q_all, T, h, d_k) # 拆分成 h 个 head
6
K = reshape(K_all, T, h, d_k)
7
V = reshape(V_all, T, h, d_v)
8
# 对所有 head 并行做 Attention ...
9
out = concat(heads, dim=-1) @ W_O  # 拼接后投影

5.10 朴素实现的致命问题#

注意力得分矩阵 $\mathbf{S}$ 的形状是 $(T, T)$。当序列长度 $T = 100000$ 时(GPT-4 Turbo 支持 128K Context),这个矩阵有 $10^{10}$ 个元素,以 float32 存储需要约 40 GB 显存——一张 H100 只有 80 GB 显存,一个单独的得分矩阵就能吃掉一半。

更关键的问题是内存带宽:标准的 Attention 实现需要把 $\mathbf{S}$ 写入显存,再读回来做 softmax,再写入,再读回来做加权求和。每次读写都需要通过相对较慢的 HBM(High Bandwidth Memory)。这个 $O(T^2)$ 的内存访问量成为长序列下的主要瓶颈,驱动了 FlashAttention 的诞生。

6.1 CPU 和 GPU 的架构设计哲学#

CPU(Central Processing Unit,中央处理器)的设计哲学是”快速串行”:它有少数几个复杂核心,每个核心配备大容量 L1/L2/L3 缓存和复杂的分支预测电路,擅长处理逻辑分支多、前后依赖强的任务。现代桌面 CPU 通常有 8 到 24 个核心,但单核性能极高,单个时钟周期内可以乱序执行多条指令。

GPU(Graphics Processing Unit,图形处理器)的设计哲学是”大量并行”:它有成千上万个简单核心(NVIDIA H100 有 16896 个 CUDA 核心),每个核心的单线程性能远低于 CPU,但可以同时对大量数据做相同的操作。GPU 的设计起源于图形渲染:屏幕上的每个像素需要做相同的光照计算,像素之间完全独立,天然适合并行。

6.2 矩阵乘法恰好适合 GPU#

矩阵乘法的计算结构和 GPU 的架构完美匹配:

对每个输出位置 $(i, j)$,这个计算完全独立于其他位置的计算。一个 $1024 \times 1024$ 的矩阵乘法有 $1024^2 \approx 100$ 万个输出元素,每个都可以完全独立并行计算。GPU 的数千个核心同时启动,每个核心计算一小批输出元素,整体计算时间接近单个输出元素的计算时间——这是 CPU 串行处理根本无法企及的效率。

6.3 Tensor Core:专为矩阵乘加设计的硬件单元#

从 NVIDIA Volta 架构(2017)开始,GPU 引入了 Tensor Core——专门为矩阵乘加(Matrix Multiply-Accumulate,MMA)设计的硬件单元。一个 Tensor Core 在一个时钟周期内可以完成一个 $4 \times 4$ 矩阵的乘加操作,等效于 64 次浮点运算,相比普通 CUDA 核心效率提升了一个数量级以上。

这种专用硬件的设计逻辑很直接 的主要计算量就是矩阵乘法,占 Transformer forward pass 浮点运算量的 90% 以上。与其让通用计算核心慢慢计算,不如为矩阵乘法定制专用电路,把常用操作硬化到硅片上。从 Tensor Core 角度看,矩阵乘法的每个输出元素所需的内存读写和浮点运算比值(算术强度)很高——相对于数据量,计算量足够大,核心不会空转等待数据。

6.4 内存层级与带宽瓶颈#

GPU 的内存组织方式如下:

1
寄存器 (Register)  → 极快,容量极小
2
    ↕
3
片上 SRAM (Shared Memory / L1 Cache)  → 快,容量小 (~50 MB on H100)
4
    ↕
5
HBM (High Bandwidth Memory)  → 慢,容量大 (80 GB on H100, ~3.35 TB/s)
6
    ↕
7
PCIe/NVLink (跨 GPU)  → 更慢,用于多卡通信