自然语言处理的第一个工程问题,就是怎么把「大海」这样的词喂给神经网络。本章按「离散符号 → 统计共现 → 预测学习 → 上下文动态」的路线,讲清 OneHot、共现矩阵 + SVD、Word2Vec、GloVe / FastText 与 ELMo 各自解决什么问题、又留下什么坑。学完你应该能回答:为什么 OneHot 不够用?Skip-gram 和 CBOW 怎么选?静态词向量和动态词向量差在哪?以及期末最爱考的维度灾难、softmax 数值稳定、两套向量相加、CBOW 丢词序。
2.1 从离散符号到分布式表示
概念
KP 02.1
为什么需要词向量?词向量又怎么用?
一句话 神经网络只认识数字,词向量就是词表索引查出来的那一行实数。
NLP 的处理链是原始文本 → 词序列 → 词向量 → 算法(如神经网络) 。神经网络不会直接处理「大海」两个字,必须先把每个词编码成数值向量,这一步叫词的表示(representation) ,得到的向量就叫词向量(Word Vector) 。
用法分两步。第一步建词表(vocabulary) :给每个词分配一个整数索引,如「我」= 0、「爱」= 1、「上海」= 2。第二步维护一张嵌入矩阵(embedding matrix)E :行数 = 词表大小 V,列数 = 词向量维度 d;第 i 个词的向量就是 E 的第 i 行。查词 = 用索引取一行,不需要任何运算。
PPT P31 的例子:词表 39 个词时用 10 维向量,词表 260 个词时用 25 维。要注意维度 d 是人定的超参数 (常见 50、100、300 维),和词表大小 V 没有固定关系;V 只决定矩阵有多少行,d 决定每个词用几个数描述。
这张矩阵是可学习参数 ,会随任务训练不断更新。Word2Vec 等方法干的事,本质上就是把这张矩阵学出来,取其中每一行作为最终词向量。
vocab = {"我": 0, "爱": 1, "上海": 2} # 词表:词 -> 索引
E = [[0.2, -0.4, 0.7], # 嵌入矩阵:V 行、d 列
[0.1, 0.5, -0.2],
[-0.3, 0.8, 0.4]]
vec = E[vocab["上海"]] # 查表:取索引 2 那一行
print(vec) # [-0.3, 0.8, 0.4](示例)
生活类比 词表像班级花名册,只负责发学号;嵌入矩阵像每人一份的成绩单,学号用来找到那一行,真正描述一个人特点的是成绩单上的各项分数。
10 秒自测 · 点开看答案
问题:词向量维度 d = 300,是不是说明词表里有 300 个词?
答案:不是。d 表示每个词用几个数描述,是超参数;词表大小 V 决定矩阵有多少行。V 和 d 是两个独立的量。
概念
KP 02.2
OneHot:用离散符号表示词
一句话 词表有多大,向量就多长;整个向量只有一个 1。
OneHot(独热编码)是一种用离散符号表示词向量的方法:向量长度等于词汇表中词的总数 V,词在词表里的索引位置取 1,其余位置全为 0。
PPT P32 的词表只有 5 个词,于是:This = [1,0,0,0,0],is = [0,1,0,0,0],a = [0,0,1,0,0],simple = [0,0,0,1,0],example = [0,0,0,0,1]。词表每加入一个新词,所有词的向量都要增加一维,长度重新变成新的 V。
这组向量确实能唯一标识每个词,也简单到不需要训练;但它是离散符号 ,只回答「是哪一个词」,不回答「词是什么意思」。任意两个不同词的 OneHot 向量点积恒为 0、余弦相似度恒为 0,模型无法从「猫」的向量里借到任何关于「狗」的信息。
(补充)OneHot 并非一无是处:在维度很低、类别型特征(性别、城市、颜色)编码时它仍是标准做法。问题在于 NLP 词表动辄十万级,用它当词向量代价太高,而且学不到语义。
生活类比 学号 20230101 和 20230102 只差 1,但只能说明编号挨着,不能说明两个同学性格像。OneHot 的「距离」就是这种编号距离,和语义无关。
易错 用 OneHot 向量做相似度检索或语义匹配 → 结果永远是 0 或 1(只有自己和自己相似)→ 想表达相似性,必须换成分布式词向量。
10 秒自测 · 点开看答案
问题:词汇表有 10000 个词,一个词的 OneHot 向量是多少维?里面有几个 1?
答案:10000 维,只有 1 个 1,其余 9999 个位置全是 0。
易错
KP 02.3
OneHot 的四大缺点:长、空、正交、怕新词
一句话 维度灾难、极度稀疏、正交无语义、新词要扩维,OneHot 一个都躲不掉。
把 OneHot 直接当词向量用,会撞上四个硬伤:
维度灾难 :向量长度 = 词表大小 V。指导书给了一组参考值:V = 10 万时,单个 float32 向量就是 400 KB;若要给 100 万个词各存一条,就是 100 万 × 400 KB ≈ 400 GB(按 1024 进位约 372.5 GB)。若词表本身也涨到 100 万,矩阵为 10^6 × 10^6 × 4 B = 4 TB(补充),存储和计算都不可承受。
极度稀疏 :每个向量只有 1 个非零元素,非零比例只有 1/V;V = 10 万时就是 0.001%,绝大多数维度都在陪跑。
正交无语义 :任意两个不同词的向量正交,点积、余弦相似度都是 0,无法表达「猫」和「狗」相近、「北京」和「上海」相近这类语义关系。
新词难办 :词表出现新词就要扩一维,所有词的向量长度跟着变,模型输入维度也得变,只能重建词表和模型。
所以 OneHot 只能算「词的编号」,算不上「词的表示」。要表达语义,需要把词放到一个低维、稠密、有远近关系的实数空间里——这就是接着要讲的分布式表示。
记忆技巧 四个死穴记成「长(维度)、空(稀疏)、正交(无语义)、怕新词」,正好一一对应分布式表示的四个卖点:短、稠密、有远近、可泛化。
10 秒自测 · 点开看答案
问题:V = 10 万时,单个 float32 的 OneHot 向量占多少空间?非零比例是多少?
答案:10 万 × 4 B = 400 KB;只有 1 个非零元素,非零比例 1/100000 = 0.001%。
概念
KP 02.4
分布式语义表示:词义藏在上下文里
一句话 词义由上下文决定;词向量是实数空间里的一个点。
分布式语义表示(Distributed Semantic Representation) :每个词不再是完全正交的 0-1 向量,而是多维实数空间中的一个点,用一个实数向量表示。这种分布式表示通常就被叫作词嵌入(Word Embedding) 。
背后的假设叫分布式假设(Distributional Hypothesis) :某个单词的含义由它周围的单词形成。换成大白话——想判断一个词是什么意思,就看它平时和哪些词一起出现。
PPT P34 用「北京」和「上海」提问:为什么这两个词的向量相似度高?因为它们出现的上下文几乎一样——「…北京交警刚刚发布消息…」「…上海交警刚刚发布消息…」「…记者从北京市住建委了解到…」「…记者从上海市住建委了解到…」「…放弃北京的工作…」「…我在上海工作…」。模型看到的邻居相似,学出来的向量自然靠近。
这就解决了 OneHot 的根本问题:相似上下文的词,向量也相似,语义相近的词可以互相「借力」。这也是后面共现矩阵、Word2Vec、GloVe 全部方法的共同出发点。(补充)注意区分「分布式表示」和「分布式系统」:前者指信息分散在向量的多个维度上,和分布式计算没有关系。
生活类比 判断一个人是什么样的人,不必看他的身份证号,而看他常和谁来往、常去哪些场合——词的「朋友圈」就是它的上下文,朋友圈相似的人,气质往往也相近。
10 秒自测 · 点开看答案
问题:为什么「北京」和「上海」的词向量相似度高?
答案:它们出现在几乎相同的上下文里(交警、住建委、工作等);按分布式假设,上下文相似,学出的向量就相似。
概念
KP 02.5
共现矩阵:把「谁和谁一起出现」数成一张表
一句话 开一个窗口数邻居,矩阵的每一行就是一条统计出来的词向量。
分布式假设要落地,最直接的办法是数数:对语料里的每个词,看它固定窗口内出现了哪些词,出现一次就在矩阵对应位置加一。这张表叫共现矩阵(Co-occurrence Matrix) 。
窗口大小 w 表示以当前词为中心,左右各取 w 个词作为上下文,不含中心词自身 。例如「我 爱 北京 天安门」中,以「爱」为中心、w = 2,上下文就是「我、北京、天安门」。
共现本身不分方向,所以通常构造成对称矩阵 :数到「爱」与「北京」共现一次,就同时执行 X[爱][北京] += 1 和 X[北京][爱] += 1。
PPT P35 的三句语料「我 爱 上海 / 我 爱 杭州 / 我 爱 北京 天安门」,取 w = 2 得到的矩阵如下(示例;按左右各 2 个词、不含自身、对称构造)。每一行都可以当成该词的向量:行向量相似的词,上下文也相似。
词 我 爱 上海 杭州 北京 天安门
我 0 3 1 1 1 0
爱 3 0 1 1 1 1
上海 1 1 0 0 0 0
杭州 1 1 0 0 0 0
北京 1 1 0 0 0 1
天安门 0 1 0 0 1 0
窗口选多大有讲究:小窗口(w = 1~2)偏向捕捉语法搭配,比如「爱—北京」;大窗口偏向捕捉主题,比如「北京—城市—繁华」。窗口越大,矩阵非零元素越多、越稠密。
共现矩阵的优点是统计直接、可解释、不需要训练;缺点是维度高且稀疏、计数被高频词主导、不含词序,新词加入还要重算整张表。这些缺点,正是接下来 SVD 与 Word2Vec 要解决的问题。
易错 把中心词自己也统计进共现 → 每个词与自己的计数虚高、对角线全是词频 → 构造窗口时明确「不含自身」,并按对称矩阵同时更新两格。
10 秒自测 · 点开看答案
问题:窗口 w 从 1 增大到 3,共现矩阵会发生什么变化?语义偏向有什么改变?
答案:非零元素增多、计数变大,矩阵更稠密;小窗口偏语法搭配,大窗口偏主题语义。
概念
KP 02.6
共现矩阵 + SVD:把大表压成稠密词向量
一句话 截断 SVD 取前 k 个奇异向量,就得到 k 维稠密词向量。
共现矩阵的维度是 V×V,仍然是一张高维稀疏的大表。用截断奇异值分解(Truncated SVD) 可以把它压小:对 X 做奇异值分解 X = U Σ Vᵀ,只保留最大的 k 个奇异值,取左奇异向量 U_k(常再乘 Σ_k)作为每个词的 k 维稠密向量。这条路线就是潜在语义分析(LSA)的思路。
直接对原始计数做 SVD 效果不好,因为计数长尾严重、高频功能词会压过一切。常用两种预处理:log(1+X) 压缩计数量级;PPMI(正点互信息) 度量「共现比随机更频繁多少」,把「的、是、很」这类到处出现的词权重压下去。
指导书实验的预期(示例):小语料上「北京—上海」余弦相似度通常明显偏高(高于 0.85),而「北京—天安门」相对较低或接近,取决于语料规模。也就是说,降维后的向量确实能把同类城市的语义拉近。
共现矩阵 + SVD 的五大缺点(PPT P36 思考题):
矩阵规模随词表按 V² 增长,大语料下存储和计算都不可行;
SVD 分解代价高(约 V³ 级别),还要一次性拿到全部语料;
无法增量更新,新词、新语料都要重建矩阵并重新分解;
计数被高频功能词主导,必须额外做 PPMI 或加权;
稀疏词(低频词)的向量质量差。
PPT P37 顺势提问:为什么不直接学习词的分布式表达?这正是 Word2Vec 要回答的问题。
易错 把原始共现计数直接送进 SVD → 主成分被「的 / 是 / 很」等高频率功能词占满,语义相似度被稀释 → 先 log(1+X) 或 PPMI 再分解。
10 秒自测 · 点开看答案
问题:为什么 SVD 之前要做 log(1+X) 或 PPMI,而不是直接用原始计数?
答案:原始计数长尾严重、高频词数值压倒一切,会让分解结果被功能词主导;log 压缩量级,PPMI 衡量「超出随机的共现强度」,都能让语义信号更突出。
SVD 降维后的词向量散点:语义相近的词会聚在一起(实验 3,余弦相似度可视化)。
2.2 预测式词向量:Word2Vec 与它的后继
概念
KP 02.7
Word2Vec:不数共现,直接用「预测」学词向量
一句话 Skip-gram 由中心猜周围,CBOW 由周围猜中心,预测只是训练手段。
Word2Vec 是预测式词向量方法。它不再显式统计共现矩阵,而是设计一个「预测邻居」的小任务,用梯度下降不断调整词向量——预测任务只是训练手段,训完就可以把预测层丢掉,只留词向量。
两种架构方向相反:Skip-gram(SG) 用中心词预测周围的词,是「一对多」;CBOW(Continuous Bag of Words) 用周围词预测中心词,是「多对一」,隐藏层先把窗口内上下文向量取平均。
PPT P41 的 Skip-gram 示例:句子「… turning into banking crises …」中,以 banking 为中心词、窗口大小为 2,左右两侧的 turning、into、crises 等都是要预测的上下文词。每个位置、每个上下文词都构成一个训练样本,所以 SG 的样本数约为 2w;CBOW 每个位置只产生 1 个样本,训练通常更快。
两种架构没有绝对优劣:SG 对低频词更友好、语义细粒度更好;CBOW 训练快、对高频词友好,小语料上语义区分度可能略弱。
对比项 Skip-gram(SG) CBOW
预测方向 中心词 → 周围词(一对多) 周围词 → 中心词(多对一)
每个位置的样本数 约 2w 个 1 个
训练速度 较慢 较快
低频词表现 更好 较差(平均会稀释稀有词信号)
隐藏层 中心词向量直接送入 上下文向量取平均后送入
适用场景 小语料、低频词、语义细粒度要求高 大语料快速训练、高频词为主
生活类比 像课堂笔记:Skip-gram 是老师给一个关键词,让你猜他前后会讲什么;CBOW 是挖掉句子中间的一个词,让你根据前后文填空。
10 秒自测 · 点开看答案
问题:CBOW 和 Skip-gram 的核心区别是什么?
答案:CBOW 多对一(上下文 → 中心词),Skip-gram 一对多(中心词 → 上下文);CBOW 快、低频词弱,SG 慢、低频词与语义细粒度更好。
公式
KP 02.8
损失函数:点积管相似,softmax 管概率,交叉熵管训练
一句话 越相似点积越大,softmax 归一化成概率,取负对数当损失。
Skip-gram 对每个训练样本(中心词 c,上下文词 o)算一个条件概率:先把两个词的向量做点积 (衡量相似度),再对词表里所有词的点积做 softmax 归一化,得到「在 c 周围出现 o」的概率。
训练目标是让真实上下文词的概率尽量大,因此用负对数似然(Negative Log-Likelihood,等价于交叉熵) 做损失:概率越大,损失越小。把语料所有位置、窗口内所有上下文词的损失加起来,就是整个模型的目标函数。
CBOW 只需把中心词的输出向量换成「上下文输入向量的平均」,其余同理。注意 Word2Vec 每个词有两套向量 :一套作中心词(输入向量 U),一套作上下文(输出向量 V)。训练完成后通常把两套相加 作为最终词向量,因为两套各自承载「当中心词」和「当上下文」的角色,相加能综合两种信息;只用其中一套也可行,只是信息略少。
实现时最容易踩的坑是 softmax 数值溢出:点积较大时 exp 会溢出成 nan。做法是在 exp 前先减去这一行分数的最大值,数学上概率不变,数值上安全。
scores = U @ v[c] # 中心词向量与词表中所有输出向量点积
scores -= scores.max() # 数值稳定:先减最大值,防止 exp 溢出
p = np.exp(scores)
p /= p.sum() # softmax 归一化,得到词表上的概率分布
loss = -np.log(p[o]) # 负对数似然:正确上下文词概率越大,损失越小
易错 softmax 输出 nan 或 inf → exp 前忘记做数值稳定 → 先 scores -= scores.max();这一步数学上等价于原式,但能保证 exp 的输入不超过 0。
10 秒自测 · 点开看答案
问题:训练完成后为什么常把输入向量 U 和输出向量 V 相加作为词向量?只用一套行不行?
答案:两套向量分别承载「当中心词」和「当上下文」的角色,相加能综合两种信息、通常效果更好;只用一套也可以,只是信息略少。
概念
KP 02.9
训练太慢怎么办?层次 Softmax 与负采样
一句话 全词表归一化太贵,改成走哈夫曼树或抽几个反例。
朴素 Word2Vec 每个样本都要对词表 V 里每个词算一遍 softmax:V = 10 万时,单样本计算量就是 10 万次点积,训练慢到不可接受,梯度更新还牵动整个输出矩阵。这就是 PPT P43 说的「词汇表中每个词都要算一遍」的问题。
层次 Softmax(Hierarchical Softmax) 把词表组织成一棵哈夫曼树,每个词对应一条从根到叶的路径,每次只在路径上做二分类(sigmoid),复杂度从 O(V) 降到 O(log V)。叶子越深的词越少见,常见词路径更短,符合直觉。
负采样(Negative Sampling) 换个思路:每次只更新「正确的上下文词」加上随机抽的 k 个「假上下文词」,把多分类问题变成 k+1 个二分类问题,复杂度降到 O(k)(k 通常取 5~20)。噪声词按词频的 3/4 次方采样(补充),让高频词被抽到的概率高一些,但又不至于垄断。
两者都是近似 :训练目标不再是严格的 softmax 概率,而是它的近似,换来数量级的加速。工程上负采样更常用。
生活类比 层次 Softmax 像查纸质字典:不是从第一页翻到最后一页,而是先看拼音首字母、再看第二个字母,一层层缩小范围;负采样像判卷只跟标准答案和几个随机抽来的「陪考」比,不跟全校比。
10 秒自测 · 点开看答案
问题:层次 Softmax 和负采样解决的是同一个问题吗?
答案:是。都为降低「每个样本对全词表算 softmax」的 O(V) 开销:前者用哈夫曼树把路径降到 O(log V),后者只更新正样本加 k 个负样本、降到 O(k),都是近似加速。
概念
KP 02.10
GloVe 与 FastText:一个用全局统计,一个用子词积木
一句话 GloVe 把全局共现塞进矩阵分解;FastText 把词拆成字符 n-gram。
GloVe(Global Vectors for Word Representation) 把全局词共现信息和局部上下文信息结合起来,通过矩阵分解学习词向量。出发点很直接:既然共现矩阵 X 记录了全局统计,就让词向量点积去拟合 log X——两个词共现越多,期望它们的向量越接近。
为避免超高频共现主导训练,GloVe 给每对词加权重 f(X_ij),并对低频强共现做封顶(补充)。与 Word2Vec 相比:Word2Vec 在滑动窗口里逐样本预测,偏局部;GloVe 一次利用整个共现矩阵,偏全局,训练也更容易并行。
FastText 基于词袋模型,把词分解成子词(subword),用字符 n-gram 的向量相加来表示词向量,充分利用字符级信息。PPT P45 的 Apple 示例(2-gram,示例值):⟨ap, pp, pl, le⟩ 四个子词向量相加,正好得到 apple 的向量——第一维 -0.3 + 0.4 + 0.2 - 0.1 = 0.2,第二维 0.2 - 0.1 + 0.3 + 0.5 = 0.9,第三维同理也是 0.9。
这带来的直接好处:即使某个词在词表里没见过(未登录词,OOV),也能用它的子词向量拼出一个近似表示;对形态丰富的语言(如英语词形变化、德语复合词)尤其友好。FastText 还常用作快速文本分类器(补充)。
GloVe 核心:全局共现矩阵分解,拟合 log X;优点是全局统计、可并行,局限是新语料要重算共现矩阵。
FastText 核心:字符 n-gram 子词向量相加;优点是能处理 OOV、形态丰富语言友好,局限是拼写相近不等于语义相近。
生活类比 FastText 像用偏旁部首认字:没见过的「湖」也能从「氵」猜出和水有关;GloVe 像把全班十年的座位表汇总成一张统计表,一次看清谁常和谁坐。
10 秒自测 · 点开看答案
问题:FastText 凭什么能处理未登录词(OOV)?
答案:它把词拆成字符 n-gram 子词,词的向量由子词向量相加得到;没见过的词也能用子词拼出近似向量,不必等扩充词表。
2.3 从静态到动态:ELMo、评估与高频考点
概念
KP 02.11
静态 vs 动态词向量:ELMo 为什么让「苹果」有两个意思
一句话 静态词向量一词一向量;动态词向量按当前上下文现算。
Word2Vec、GloVe、FastText 学出来的都是静态词向量 :每个词对应一个固定向量,无论出现在什么句子里都不变。「苹果手机」和「吃苹果」共用同一个苹果向量,一词多义被强行平均。
动态词向量 基于语言模型:在语料库上预训练上下文表示,再根据当前句子的上下文动态生成每个词的表示向量。同一个「苹果」,在手机语境和水果语境下得到的向量不同;而且在下游任务微调时,向量还会继续随任务学习变化(PPT P84)。
ELMo(Embeddings from Language Model) 是代表性方案。它用两个独立的单向 LSTM :一个从左往右读句子,一个从右往左读,而不是一个双向 RNN。这样做的原因很实际——双向 RNN 在预测当前词时已经「看到」了答案,无法用于文本生成;两个独立单向模型各自能生成,拼起来又能同时利用左右上下文。
ELMo 不只取最后一层:每个词的表示由各层 LSTM 隐状态加权求和 得到,权重和缩放系数都是可学习参数,不同下游任务学到不同权重。通常越靠近顶层的隐状态编码越多语义信息(适合阅读理解类任务),越靠近底层越偏词法、句法信息(适合命名实体识别类任务)。PPT P46 还提到 BERT、GPT 这类 Transformer-based 模型——它们同样从大规模文本中学习词向量,把「上下文相关」做得更彻底。
静态(Word2Vec / GloVe / FastText) 每个词一个固定向量,「苹果」永远是同一个向量;简单、可复用,但一词多义被抹平。
动态(ELMo / BERT / GPT) 由当前上下文现算,手机「苹果」与水果「苹果」向量不同;上下文敏感,但计算贵、需要预训练模型。
生活类比 静态词向量像字典上印好的释义,一个词只有一条;动态词向量像现场同声传译,得听完这句话才知道「苹果」指的是手机还是水果。
10 秒自测 · 点开看答案
问题:ELMo 为什么用两个独立单向 LSTM,而不用一个双向 RNN?
答案:双向 RNN 在预测当前词时已经看到了下文(答案),不能用于文本生成;两个独立单向 LSTM 各自能生成,组合起来又能同时利用左右上下文。
概念
KP 02.12
词向量评估:内部看相似度,外部看下游任务
一句话 内部评估查相似度和类比,外部评估看下游指标涨不涨。
词向量好不好,有两条评估路线(PPT P47)。内部评估(Intrinsic) 直接在词向量空间里做可解释的小任务:
相似度任务 :计算两个词的余弦相似度,和人工打分对比,常用数据集如 wordsim353;
类比任务 :经典的 King - Queen = Man - Woman,即 v_king - v_man + v_woman 应该最接近 v_queen。
外部评估(Extrinsic) 把词向量放到真实下游任务里,以命名实体识别、机器翻译、文本分类等任务的指标来评价词向量的好坏。下游效果好,才说明这套词向量真的有用(PPT P48)。
两者的关系:内部评估快、便宜、可解释,但分数高不一定代表下游任务涨点,因为相似度、类比只测了语义空间的一小部分性质;外部评估慢、要重复训练下游模型,但最真实。实际调词向量时,通常先用内部评估快速筛方案,再用外部评估定稿。
生活类比 内部评估像模拟考——题出得再像,也只测了考纲的一部分;外部评估像真实项目绩效——能不能把活干成,才是最终标准。
10 秒自测 · 点开看答案
问题:内部评估分数高,模型的命名实体识别效果一定好吗?
答案:不一定。内部评估只测相似度、类比,和下游任务目标不完全一致;最终要看外部评估的下游指标。
面试
KP 02.13
高频思考题:四个最爱问的「为什么」
一句话 维度灾难、softmax 稳定、两套向量、CBOW 丢词序。
维度灾难到底有多大? V = 10 万时,float32 单个 OneHot 向量 400 KB;100 万个词各存一条约 400 GB(约 372.5 GiB,指导书参考值);非零比例只有 1/V = 0.001%。
softmax 怎么保证数值稳定? 先减去当前分数向量的最大值再 exp,即 scores -= scores.max()。exp 的输入变成不超过 0,不会溢出;数学上分子分母同乘一个常数,概率结果不变。
两套向量为什么要相加? 输入向量 U 和输出向量 V 分别承担「当中心词」和「当上下文」两种角色,训练完成后 U + V 能综合两种信息,通常效果更好;只用其中一套也可用,只是信息略少。
CBOW 为什么丢失词序? 它把窗口内上下文向量取平均,而平均与顺序无关:「我 爱 北京」和「北京 爱 我」得到同一个隐藏层表示,词序信息被丢掉——这正是名字里 Bag of Words(词袋)的含义。想保留词序,就得换成 RNN、Transformer 这类带位置信息的模型。
外加一个送分点:层次 Softmax 把单样本复杂度从 O(V) 降到 O(log V);负采样只更新正样本加 k 个负样本,复杂度 O(k)。两者都是对全词表 softmax 的近似加速(PPT P43)。
注意 三个「分布式」别混:分布式表示(词向量)说的是信息分散在多个维度上;分布式假设说的是词义由上下文决定;分布式系统 / 分布式存储说的是多台机器协同,和词向量无关。
10 秒自测 · 点开看答案
问题:CBOW 为什么又叫「词袋」模型?
答案:它把上下文向量取平均,平均与词序无关,词序信息被丢弃,只剩「哪些词出现过」这一袋词,所以叫 Bag of Words。
实验
LAB 02.0
12 个实验怎么串:一条「从符号到上下文」的主线
一句话 前 5 个实验打地基,后 7 个补前沿与评估。
指导书的 5 个必做实验对应 PPT P32–P42,按「离散符号 → 统计计数 → 矩阵分解 → 神经网络预测」四步推进:先用 OneHot 暴露「正交、无语义」的问题,再用共现矩阵把语义写进统计量,接着用 SVD 把矩阵压成稠密向量,最后用 Skip-gram / CBOW 直接「学」出向量。
扩展的 7 个实验各有明确动机:exp06 用负采样解决全 softmax 的 O(V) 瓶颈;exp07 / exp08 补上 GloVe 与 FastText 两条代表性路线;exp09 从静态词向量走向上下文化表示;exp10–exp12 则回答「怎么判断词向量好不好」。每张实验卡都给出任务、预期与常见坑,按顺序做即可复现整条演进链。
建议按「先跑通脚本 → 对照预期现象 → 再填表、答思考题」三步做:每张卡最后的 quiz 就是报告里「结果分析」的要点,展开成 100 字左右即可;实验 1–5 是必做,实验 6–12 是扩展,但正是它们把词向量从「会算相似度」推进到「能处理 OOV、能随上下文变化、能被客观评估」。
实验 文件 PPT 要验证的核心问题
1 exp01 / lab01 P32 OneHot 为什么表达不了语义
2 exp02 / lab02 P35 语义能否由共现统计得到
3 exp03 / lab03 P36–37 稀疏共现能否压成稠密向量
4 exp04 / lab04 P38–P42 能否用「预测上下文」学向量
5 exp05 / lab05 P40 上下文预测中心词行不行
6 exp06 P43 全 softmax 太慢怎么优化
7 exp07 P44 全局共现能否拟合出词向量
8 exp08 P45 没见过的词能否也有向量
9 exp09 P46 词向量能否随上下文变化
10 exp10 P47 向量相似度像不像人的判断
11 exp11 P47 语义关系能否做向量加减
12 exp12 P47 对下游任务到底有没有用
记忆主线 每一代方法都在补上一代的一个具体缺陷:两两正交 → 高维稀疏 → 无法增量更新、O(V) 太慢 → 一词一义。
常见坑 把 12 个实验当成 12 个孤立脚本,跑完不填表、不看输出。正确做法是每组实验都留下一张「现象—原因—结论」的小表:例如实验 1 的余弦全 0、实验 2 的「的」行、实验 3 的相似度随 k 变化,这些现象连起来才是本章的主线。
实验
LAB 02.1
实验 1 · OneHot 与语义鸿沟
难度 ★☆☆
对应 PPT P32
lab01_onehot.py / exp01
实验目的:把词变成最朴素的向量,再用两组可量化的结果(余弦全 0、内存爆炸)说明 OneHot 只有「编号」、没有「语义」,从而引出分布式表示。
写 build_vocab(corpus):按词在语料中首次出现的顺序编号;再写 onehot(word, vocab),返回长度 V、只有一个 1 的 np.ndarray。
用 PPT P32 的句子 ["this","is","a","simple","example"] 打印 5 个词的向量,确认每个向量长度都等于 V=5。
计算(this, is)、(simple, example)、(this, simple)三对余弦相似度,观察是否全部为 0。
按 float32(每个元素 4 字节)填维度灾难表:V=10³、10⁴、10⁵ 时单个词的字节数,以及 100 万词矩阵占用的内存;再统计非零元素比例 1/V。
判断标准很简单:如果语义接近的两个词,向量相似度与其他任意词对没有区别,这种表示就没有携带语义。OneHot 的余弦恒为 0,所以「猫—狗」与「猫—钢琴」在模型眼里一样「无关」。
算一笔账 V=10⁵ 时一个词占 400 KB,10⁶ 个词的矩阵就是 372.5 GB;单是存储就超过多数机器的内存,更别说第一层 V×d 的参数矩阵。
预期结果 输出形如 OneHot(this) = [1 0 0 0 0],向量长度等于词汇表大小;三个词对的余弦相似度全部为 0.0。维度表参考值:V=10⁵ 时单个词向量 400 KB,存储 100 万个词的矩阵约 372.5 GB;非零元素比例为 1/V,V=10⁵ 时仅 0.001%。
常见坑 把不同实验的 vocab 混用——编号不同,同一个词的 1 所在位置就不同,余弦计算失去意义;统计内存时只算「一个向量」而忘了乘以词数(V×10⁶×4 字节);用 int8 之类的低精度省内存会破坏实验口径,本实验统一按 float32 计算。
def build_vocab(corpus):
vocab = {}
for sent in corpus:
for w in sent:
if w not in vocab:
vocab[w] = len(vocab) # 首次出现按顺序编号
return vocab
def onehot(word, vocab):
vec = np.zeros(len(vocab), dtype=np.int32) # 长度 = V
vec[vocab[word]] = 1 # 只有 1 个非零
return vec
# 任意两个不同词的 OneHot 点积为 0 -> 余弦相似度恒为 0
思考题 · 点开看参考要点
问:「猫」和「狗」语义接近,OneHot 能体现吗?为什么?
答:不能。两个 OneHot 向量正交、内积恒为 0,余弦相似度恒为 0,模型只能分别记忆它们,无法利用「都是动物」这一共性;这正是必须引入分布式表示的原因。此外 OneHot 还有维度灾难、极度稀疏、新词要扩整张表等缺点。
实验
LAB 02.2
实验 2 · 窗口共现矩阵
难度 ★★☆
对应 PPT P35
lab02_cooccurrence.py / exp02
实验目的:按分布式假设(一个词的含义由它周围的词决定)把语料统计成对称共现矩阵,先手算、再用代码验证,并观察窗口大小与高频功能词对矩阵的影响。
手算:对 PPT P35 的三句「我 爱 上海 / 我 爱 杭州 / 我 爱 北京 天安门」在 w=2 下算出 6×6 矩阵,写在报告里。
实现 build_cooccurrence(corpus, window=2):先建词表,再对每个中心词 i 取窗口 [i−w, i+w] 内 j≠i 的位置给矩阵计数。
在统一语料 corpus.txt(10 句)上运行,打印「表头为词、首列为词」的整齐矩阵,并与手算的前 3 句结果比对。
窗口对比 w=1、2、3,记录矩阵非零元素总数以及「北京」行、「天安门」行的非零个数;最后打印「的」这一行,观察高频功能词的共现范围。
w=2 我 爱 上海 杭州 北京 天安门
我 0 3 1 1 1 0
爱 3 0 1 1 1 1
上海 1 1 0 0 0 0
杭州 1 1 0 0 0 0
北京 1 1 0 0 0 1
天安门 0 1 0 0 1 0
手算矩阵时先看两件事:对角线是否为 0(窗口不含中心词自身)、矩阵是否对称(左右都数了一遍)。再看行向量:「爱」的行几乎连满所有实词,而「上海」「杭州」的行只连「我」「爱」——行向量的差异就是词的「上下文指纹」。
窗口的语义偏向 小窗口更容易捕捉语法 / 搭配关系(如「爱—北京」),大窗口更偏向主题 / 篇章级语义(如「北京—城市—繁华」);窗口大小是后面调参时最直观的超参数。
预期结果 手算矩阵与代码结果一致:对角线全 0、矩阵关于对角线对称,「爱」与「我」共现 3 次,「北京」与「天安门」强共现。窗口对比的预期现象:w 越大,非零元素越多、矩阵越稠密;远距离词「天安门」只在较大窗口下才与更多词建立联系(w=1 时只连「北京」「爱」)。「的」几乎与句中所有词共现,共现计数被高频功能词主导、真实语义信号被稀释。
常见坑 忘记写 j != i,把对角线填成词频而不是 0;只累加窗口一侧却不遍历所有中心词,矩阵会不对称;以为窗口参数 w 是「总宽度」——它表示左右各取 w 个词;中文语料没有分词就直接按空格切,整句会变成一个词;把高频功能词当噪声直接删掉之前,先想清楚后面 PPMI 为什么专门处理它们。
def build_cooccurrence(corpus, window=2):
vocab = {}
for sent in corpus:
for w in sent:
vocab.setdefault(w, len(vocab)) # 词 -> 编号
M = np.zeros((len(vocab), len(vocab)), dtype=np.int64)
for sent in corpus:
for i, center in enumerate(sent):
lo = max(0, i - window) # 窗口左边界
hi = min(len(sent), i + window + 1) # 右边界(不含)
for j in range(lo, hi):
if j != i: # 不含中心词自己
M[vocab[center], vocab[sent[j]]] += 1
return M, vocab
思考题 · 点开看参考要点
问:共现矩阵为什么能表达语义?直接把它当词向量用有什么问题?
答:语义相近的词出现在相似上下文中,共现行向量自然相近,例如「北京」「上海」都与「城市、繁华、热闹」共现。但直接使用的问题也很明显:维度等于 V、高维稀疏;计数被高频词主导;新词加入要重建整个矩阵,无法增量更新。
实验
LAB 02.3
实验 3 · 共现矩阵 + SVD
难度 ★★☆
对应 PPT P36–P37
lab03_svd.py / exp03
实验目的:用截断 SVD 把高维稀疏共现矩阵压缩成 k 维稠密词向量,并比较「原始计数 / log(1+X) / PPMI」三种预处理与不同维度 k 的效果,最后回答 PPT 的思考题。
复用实验 2 的 build_cooccurrence,写 svd_vectors(X, k, preprocess):先预处理,再用 np.linalg.svd(..., full_matrices=False) 分解,取 U[:, :k] * sqrt(S[:k])。
取 k=2 打印每个词的 2 维向量,并填 4 对词的相似度:北京-上海、北京-天安门、上海-杭州、北京-城市。
预处理对比(k=10):原始计数、log(1+X)、PPMI 各训练一次,记录同样 4 对词的余弦,判断哪种结果最接近人的直觉。
维度实验:k 取 2、5、10、20,画「北京-上海」相似度随 k 变化的折线图;选做 k=2 散点图,用 annotate 标出词名,观察同类词是否聚在一起。
k 是词向量的维度,也是保留的主方向数:小语料常用 2–10 观察聚类,真实语料常用 100–300。k 太小会把不同语义压到同一方向,k 太大则连噪声一起保留;「相似度随 k 变化」的折线图就是选 k 的直观依据。
为什么要乘 √Σ U 的列是单位向量,乘上奇异值开方相当于按各维重要性加权,是 LSA 词向量的标准做法,也让不同维度可比。
预期结果 按指导书预期:cos(北京, 上海) 通常明显偏高(一般高于 0.85),而 cos(北京, 天安门) 相对较低,或在小语料上与前者接近(取决于语料规模)。log(1+X) 与 PPMI 通常使同类词(城市名)的相似度更突出、功能词影响更小。k 过小时信息损失严重、相似度波动大,k 增大后数值趋于稳定。
常见坑 对 PPMI 里 log(0) 不做保护(应 log1p 或 max(0, ·) 截断);小语料上 PPMI 会把低频共现放大成噪声;k 取得比奇异值个数还大;以为 SVD 之后新词可以「增量」加进去——新词必须重建矩阵并重新分解,这也正是后面直接学习词向量的动机。
原始计数 长尾严重,高频词数值压倒一切,分解结果容易被「的 / 是 / 很」主导。
log(1+X) / PPMI 压缩计数量级、度量「超出随机的共现强度」,让语义信号更突出。
def svd_vectors(X, k, preprocess="log1p"):
if preprocess == "raw":
Xp = X.astype(np.float64)
elif preprocess == "log1p":
Xp = np.log1p(X) # log(1+X):压缩高频量级
else:
Xp = ppmi(X) # PPMI:抑制高频功能词
U, S, _ = np.linalg.svd(Xp, full_matrices=False)
return U[:, :k] * np.sqrt(S[:k]) # 按奇异值开方缩放
def ppmi(X):
total = X.sum()
Pij = X / total
Pi = X.sum(axis=1, keepdims=True) / total
Pj = X.sum(axis=0, keepdims=True) / total
return np.maximum(0.0, np.log(Pij / (Pi * Pj + 1e-12)))
思考题 · 点开看参考要点
问:共现矩阵 + SVD 方法有哪些缺点?(PPT 原题)
答:① 矩阵规模随词汇表按 V² 增长,大语料下存储与计算都不可行;② SVD 代价高,且需要一次性拿到全部语料;③ 无法增量更新,新词或新语料要重新分解;④ 计数被高频功能词主导,需额外做 PPMI / 加权;⑤ 低频词的向量质量差。这些缺点直接催生了 Word2Vec。
不同维度 k 对「北京—上海」相似度的影响:k 太小信息损失大,k 增大后趋于稳定(实验 3 拓展)。
实验
LAB 02.4
实验 4 · Skip-gram
难度 ★★★
对应 PPT P38 / P39 / P41 / P42
lab04_skipgram.py / exp04
实验目的:用「中心词预测上下文词」实现 Word2Vec 的 Skip-gram,手写前向 softmax 与反向传播,训练 16 维词向量,并用最近邻查询验证「北京 ≈ 上海」这类语义相似性。
写 make_pairs(corpus_ids, window=2):每个位置取中心词 c,窗口内所有 j≠i 的词作上下文,生成 (c, 上下文) 对;打印词汇表大小 V 与训练对总数。
实现前向:scores = U @ v[c],先减最大值再 softmax 得到概率 p。
实现反向:g = p - onehot(o),grad_v = U.T @ g,grad_u = outer(g, v[c]);lr=0.05 训练 300 轮,每 100 轮打印平均损失。
取最终词向量 word_vec = v + u,用 most_similar 查询北京、上海、城市、繁华的 Top-3 近邻并填表。
初始损失为什么约 2.4?未训练时各词打分接近 0,softmax 近似均匀分布,交叉熵约等于 ln V;小语料的 V 只有十来个词,所以初始损失在 2.4 附近。训练后真实上下文词的概率被拉高,损失才降到 1.5–1.7。
两套向量的分工 v 在「作中心词」时更新,u 在「作上下文词」时更新;v+u 把两种角色的信息合并,是 Word2Vec 最常见的取向量方式。
预期结果 按指导书预期:初始损失约 2.4(接近 ln V,实验语料 V≈11),训练后下降到 1.5–1.7 附近(小语料会更快收敛)。cos(北京, 上海) 明显为正(约 0.6–0.9),cos(北京, 天安门) 也较高(同句共现),而跨主题词对(如「城市」与「天安门」)可能为负;「城市」的 Top-3 近邻应集中在「北京 / 上海 / 杭州 / 繁华 / 安静」这类同主题或共现词上。
常见坑 softmax 前不减最大值,exp 溢出出现 nan;g 忘了 g[o] -= 1.0,梯度方向就错了;更新时把整个 U 和中心词那一行混在一起(应只更新 v[c] 一行,U 全矩阵更新);忘了每轮 shuffle 样本;每个样本都要对 V 个词算一遍,V 大时非常慢——这正是实验 6 要解决的问题。
for epoch in range(300):
rng.shuffle(pairs) # 每轮打乱样本
for c, o in pairs:
scores = U @ v[c] # 中心词与每个词的相似度
scores -= scores.max() # 防 exp 溢出
p = np.exp(scores); p /= p.sum() # softmax 概率
g = p.copy(); g[o] -= 1.0 # dL/dscores = p - onehot(o)
grad_v = U.T @ g # dL/dv_c
grad_u = np.outer(g, v[c]) # dL/dU
v[c] -= lr * grad_v # 只更新中心词那一行
U -= lr * grad_u # 更新全部输出向量
# lr=0.05;最终 word_vec = v + u,最近邻按余弦降序取 Top-K
思考题 · 点开看参考要点
问:为什么「北京」和「上海」的向量相似度高?最终词向量为什么要 v + u?
答:两词出现在几乎相同的上下文(「我 爱 __」「__ 是 繁华 的 城市」「__ 很 热闹」)中,训练时同一个上下文要把它们的预测概率都拉高,自然把向量推到相近位置,这是分布式假设的直接体现。v 与 u 分别承载「作为中心词」和「作为上下文」两种角色,相加可综合两种信息;只用一套也能用,只是信息略少。
实验
LAB 02.5
实验 5 · CBOW 与 Skip-gram 对比
难度 ★★★
对应 PPT P40
lab05_cbow.py / exp05
实验目的:实现 CBOW(上下文词平均后预测中心词),并在同一语料、同一 dim=16、同一 lr=0.05、同一 300 轮下与 Skip-gram 逐项对比,理解两种架构的差异与适用场景。
写 make_samples(corpus_ids, window=2),返回(上下文编号列表, 中心词编号);句首句尾的上下文个数不等长,平均时按实际长度取。
前向:h = v[ctx].mean(axis=0),p = softmax(U @ h);反向:g = p - onehot(c),grad_h = U.T @ g,U -= lr * outer(g, h),v[ctx] -= lr * grad_h / len(ctx)。
两个模型各训练 300 轮,填对比表:训练样本数、第 0 / 300 轮损失、每轮耗时、cos(北京, 上海)、cos(北京, 天安门)、「城市」Top-3 近邻。
选做:加一句「我 去过 哈尔滨 冰雪 大世界」比较低频词「哈尔滨」的近邻;再用 w=1、2、3 训练 CBOW,看窗口对「北京-上海」相似度的影响。
对比维度 Skip-gram CBOW
训练方向 1 个中心词 → 多个上下文词 多个上下文词 → 1 个中心词
每位置样本数 约 2w 个(句首句尾不足) 固定 1 个
输入构造 直接查中心词向量 v[c] 上下文向量取平均
收敛速度 样本多,单轮较慢 样本少,单轮更快
低频词表现 通常更好 平均后信号被稀释
为什么样本数约差 2w 倍?Skip-gram 对每个位置枚举窗口内所有上下文词,一个位置最多产生 2w 个样本;CBOW 把整个窗口打包成 1 个样本,只预测 1 个中心词。平均操作与顺序无关——「我 爱 北京」与「北京 爱 我」得到完全相同的 h,这就是 CBOW 的「词袋」特性,也是它丢词序的根源。
不能只看总耗时 两个模型的样本数不同,比较效率应看「每轮耗时」与「收敛所需轮数」;报告里同时给出样本数、损失与相似度,结论才站得住。
预期结果 样本数:CBOW 每句每个位置只产生 1 个样本,Skip-gram 每个位置产生窗口内多个样本,SG 样本数约为 CBOW 的数倍。损失:两者都能下降;CBOW 因样本少、平均化操作,通常收敛更快(单轮更快、损失更低),但在小语料上语义区分度略逊于 Skip-gram。相似度:两者 cos(北京, 上海) 都应明显高于跨主题词对。低频词:Skip-gram 通常优于 CBOW(平均操作会「淹没」低频词信号)。
常见坑 反向传播时除以固定 2w 而不是实际的 len(ctx),句首句尾会算错;更新 v[ctx] 时没有把梯度均分给每个上下文词(h 是平均,链式法则要求均分);两个模型训练样本数不同,不能直接比较「总耗时」;平均与顺序无关,CBOW 天然丢失词序信息,叫 Bag of Words 不是随便起的。
for epoch in range(300):
rng.shuffle(samples)
for ctx, c in samples:
h = v[ctx].mean(axis=0) # 上下文向量取平均(词袋)
scores = U @ h
scores -= scores.max()
p = np.exp(scores); p /= p.sum()
g = p.copy(); g[c] -= 1.0 # 只预测 1 个中心词
grad_h = U.T @ g # dL/dh
U -= lr * np.outer(g, h) # 更新输出向量
v[ctx] -= lr * grad_h / len(ctx) # 梯度均分回每个上下文词
# 样本数:CBOW 每位置 1 个;Skip-gram 每位置约 2w 个
思考题 · 点开看参考要点
问:CBOW 与 Skip-gram 的核心区别是什么?为什么 CBOW 训练更快但低频词表现更差?
答:CBOW 是「多对一」(上下文 → 中心词),Skip-gram 是「一对多」(中心词 → 多个上下文)。CBOW 每个位置只做一次预测、计算量约为 SG 的 1/(2w),所以更快;但多个上下文向量被平均,稀有词出现的样本少又会被高频上下文稀释,梯度信号弱,因此低频词表现更差。CBOW 适合大语料快速收敛,Skip-gram 适合小语料与低频词。
实验
LAB 02.6
实验 6 · SGNS 负采样
难度 ★★★
对应 PPT P43
exp06_sgns.py
实验目的:解决全 softmax 每个样本都要对词汇表算一遍的 O(V) 瓶颈——每个正样本只抽 K=5 个负样本,用 sigmoid 二分类近似 softmax,把复杂度降到 O(K+1),并与实验 4 的结果对照。
统计每个词的词频,按 counts ** 0.75 计算权重,按比例放大到约 1 万份后用 np.repeat 展开成负采样表。
对每个正样本 (c, o) 从采样表中抽 K 个负样本,抽到与 o 相同的词就重抽,保证正负样本不重叠。
前向只算正样本与 K 个负样本的打分:s_pos=u_o·v_c,s_neg=u_k·v_c;损失 L=−log σ(s_pos) − Σ_k log σ(−s_neg)。
反向:正样本梯度系数 σ(s_pos)−1,负样本系数 σ(s_neg);v_c 累加全部正负贡献后只更新一次;训练 400 轮、lr=0.05、K=5,最后用最近邻检查词向量质量。
层次 Softmax 另一条优化路线:用哈夫曼树把词组织成叶子节点,只需沿「根→叶子」路径算 O(log V) 个二分类概率;本实验只介绍思想、不实现,负采样才是重点。
负采样的直觉:训练目标不再是「在 V 个词里挑出正确的那一个」,而是「正确词对得分要高、随机抽到的 K 个假词对得分要低」。每个样本只碰 K+1 个向量,梯度更新量大幅减少,词向量质量却能与全 softmax 接近。
K 怎么取 K 常取 5–20:太小负信号不足、词向量区分度差,太大又接近全 softmax 的代价;本实验的小语料取 K=5 已经够用。
预期结果 脚本开头会打印「全 softmax 每个样本需计算 V 个词的分数;负采样只需 1 个正样本+K=5 个负样本,复杂度从 O(V) 降到 O(K+1)」,以及训练样本数;训练过程中每 100 轮打印一次平均损失,整体趋势应下降。最终的词向量相似度与最近邻「量级」应与实验 4 一致(具体数值以实测为准,不要照抄)。
常见坑 负样本抽到正样本时没有重抽,正负信号相互抵消;把「词频 0.75 次方」理解成对概率做幂运算——是对每个词的计数做幂,再归一化抽样;把 sigmoid 写成 softmax,又回到 O(V);v[c] 的梯度是正样本和所有负样本贡献之和,必须累加后再更新一次,不能每抽一个负样本就更新一次;U 里正样本行要拉近、负样本行要推远,方向别写反。
for c, o in pairs:
negs = []
while len(negs) < K: # 抽 K 个负样本
k = int(table[rng.integers(len(table))]) # 按 count^0.75 抽样
if k != o: # 与正样本相同就重抽
negs.append(k)
s_pos = U[o] @ v[c]
g_pos = 1 / (1 + np.exp(-s_pos)) - 1 # σ(s_pos) - 1
grad_v = g_pos * U[o] # 正样本对 v_c 的梯度
for k in negs:
s_neg = U[k] @ v[c]
g_neg = 1 / (1 + np.exp(-s_neg)) # σ(s_neg)
grad_v += g_neg * U[k] # 负样本梯度累加
U[k] -= lr * g_neg * v[c] # 把负样本推远
v[c] -= lr * grad_v # 1 个中心词只更新一次
# 损失 = -log σ(s_pos) - Σ log σ(-s_neg),复杂度 O(K+1)
思考题 · 点开看参考要点
问:负采样为什么能把单样本复杂度从 O(V) 降到 O(K+1)?层次 Softmax 又是怎么省时间的?
答:全 softmax 要对词汇表每个词算 exp 与归一化、每步更新整个输出矩阵;负采样只对 1 个正样本和 K 个负样本做 sigmoid 二分类,梯度也只碰 K+1 个输出向量。层次 Softmax 则把词组织成哈夫曼树,只算根到叶路径上的 O(log V) 个二分类概率。
实验
LAB 02.7
实验 7 · GloVe 与 FastText
难度 ★★☆
对应 PPT P44–P45
exp07_glove.py + exp08_fasttext.py
实验目的:补齐词向量工具箱的两条不同路线——GloVe 用全局共现做加权最小二乘拟合,FastText 用字符级子词 n-gram 解决未登录词(OOV)与形态相近问题。
GloVe:复用 build_cooccurrence 得到共现矩阵 X,只取非零元素 (i, j);目标是让 w_i·c_j + b_i + b_j 逼近 log X_ij,损失按权重 f(X_ij) 加权。
用梯度下降训练(dim=8、2000 轮、lr=0.05),最终词向量取 w+c,查看相似度与「上海」的最近邻。
FastText:对每个词加首尾边界符后切字符 2-gram,输入向量=该词所有子词向量之和,输出侧仍用整词向量;反向时把梯度均分回各子词。
训练后给「苹果汁」合成向量(它在训练语料中从未作为整词出现),与「苹果」「香蕉」等算余弦,验证 OOV 能力。
GloVe:全局共现 一次性统计全局共现,在非零共现对上批量做加权回归,拟合「点乘 ≈ log 共现次数」。
FastText:子词 n-gram 把词拆成字符 n-gram,词向量=子词向量之和,未登录词也能由见过的子词拼出向量。
权重函数 f(x) 是 GloVe 的关键:0 共现统计不可靠,权重直接为 0;高频共现超过 x_max 后权重封顶为 1;中低频按 (x/x_max)^0.75 平滑加权。这样既不被「的 / 是」这类高频词主导,也不浪费大量非零共现对的信息。
两者互补 GloVe 擅长利用全局统计,FastText 擅长处理词形与未登录词;中文词形变化少,子词的主要收益是 OOV 与拼写变体,而不是时态 / 词缀。
预期结果 GloVe 先打印共现矩阵的大小与非零元素个数(脚本只拟合这些非零对),训练后相似度与最近邻的量级应与前面的模型相当(具体数值以实测为准)。FastText 的「苹果汁」能成功合成向量,不会返回「无法合成」,且按子词共享关系,它与共享「苹果」子词的词更相近、与几乎无共享子词的词更远——这就是形态泛化能力。
常见坑 GloVe 对 X=0 的位置也算 log,导致 −inf(权重函数应在 x=0 时返回 0、不参与损失);x_max 在真实语料常用 100,本实验语料小、取 2,换个语料要重新调;FastText 的 OOV 向量是「事后合成」的,不能把 OOV 词当中心词参与训练(输出侧仍是整词表);子词表只由训练语料决定,完全陌生的字仍然拼不出向量。
def weight_fn(x, x_max=2.0, alpha=0.75):
if x == 0: # 零共现统计不可靠,权重为 0
return 0.0
return 1.0 if x >= x_max else (x / x_max) ** alpha # 高频封顶
def ngrams(word, n=2):
w = f"<{word}>" # 加首尾边界符
return [w[i:i + n] for i in range(len(w) - n + 1)] or [w]
# FastText 输入向量 = 该词全部子词向量之和
# 例:ngrams("苹果", 2) = ["<苹", "苹果", "果>"]
# OOV 词「苹果汁」也由子词拼出向量,不查整词表
思考题 · 点开看参考要点
问:GloVe 与 Word2Vec 的区别是什么?FastText 为什么能处理 OOV?
答:Word2Vec 逐样本在线学习、只看局部窗口;GloVe 先一次性统计全局共现矩阵,再在非零共现对上做加权最小二乘回归,更充分利用全局统计。FastText 把词表示为子词向量之和,未登录词只要部分子词在训练语料中出现过,就能拼出向量,因此能处理 OOV,也让形态相近的词天然共享向量。
实验
LAB 02.8
实验 8 · Transformer 词嵌入
难度 ★★★
对应 PPT P46
exp09_transformer_embedding.py
实验目的:复现「输入嵌入+正弦位置编码+自注意力」三个组件,亲眼看到同一个「苹果」在「吃苹果」与「苹果手机」两种上下文中得到不同向量,从而理解静态词向量与上下文化词向量的分水岭。
实现 positional_encoding(seq_len, d_model):偶数维用 sin、奇数维用 cos,频率为 10000^(2i/d_model),让每个位置有独一无二的「指纹」。
实现 attention(Q, K, V):scores = Q @ K.T / sqrt(d),按行 softmax 归一化,再加权求和得到融合上下文的输出。
准备两句话「我 爱 吃 苹果 和 香蕉」「我 想 买 苹果 手机 壳」,让它们共用同一套静态词嵌入,分别加上位置编码后计算自注意力。
取两句话中「苹果」(位置 3)的上下文化向量算余弦,再与「静态嵌入和自身比较恒为 1.0」的结果对照,打印结论。
这里最关键的是「共享」与「上下文」的对照:两句话里的「苹果」共用同一个静态嵌入,但加上位置编码、经过自注意力后,各自吸收了周围词的信息,向量就不再相同。位置编码用不同频率的正余弦给每个位置一个唯一指纹,相对位置也能通过线性变换表达。
别把数值当质量 本实验的投影矩阵是随机初始化、未训练的,两组向量 cos 的具体大小没有可比性;要验证的是「同一词在不同上下文得到不同向量」这一机制。
预期结果 先逐位置打印位置编码的前 4 维;再打印第一句中「苹果」对所有词的注意力权重(每行和为 1);最后输出:静态嵌入(Word2Vec 式)的 cos=1.0(永远相同、无法区分),而上下文化向量的 cos 明显小于 1.0——上下文不同,向量不同。注意本实验的 Q/K/V 投影矩阵是随机初始化、未训练的(补充),验证的是机制演示,不是模型效果。
常见坑 位置编码的维度与 d_model 对不齐(偶数维 sin、奇数维 cos 要交错填);softmax 按列归一化(应对每个词的所有注意力分数按行归一化);忘了除以 √d_k,点积过大让 softmax 饱和、梯度变小;以为自注意力本身能感知词序——它必须靠位置编码注入顺序信息,去掉 PE 后打乱词序结果不变。
def positional_encoding(seq_len, d_model):
pe = np.zeros((seq_len, d_model))
pos = np.arange(seq_len)[:, None]
i = np.arange(0, d_model, 2)[None, :]
pe[:, 0::2] = np.sin(pos / 10000 ** (i / d_model)) # 偶数维 sin
pe[:, 1::2] = np.cos(pos / 10000 ** (i / d_model)) # 奇数维 cos
return pe
def attention(Q, K, V):
d = Q.shape[-1]
scores = Q @ K.T / np.sqrt(d) # 缩放点积
weights = softmax(scores) # 每行和为 1
return weights @ V, weights # 上下文化向量 + 权重
思考题 · 点开看参考要点
问:静态词向量与上下文化词向量的本质区别是什么?为什么注意力要除以 √d_k?
答:静态词向量(Word2Vec / GloVe / FastText)一词一向量,同一个词在任何句子里都相同;Transformer 的向量由输入嵌入、位置编码和自注意力共同得到,会随上下文变化,所以「吃苹果」与「苹果手机」中的「苹果」不同。除以 √d_k 是为了防止点积随维度增大而数值过大,导致 softmax 进入饱和区、梯度消失。
实验
LAB 02.9
实验 9 · 三种评估:相似度、类比与下游任务
难度 ★★☆
对应 PPT P47
exp10 + exp11 + exp12
实验目的:回答「词向量到底好不好」——用内部评估(相似度、类比)直接看向量质量,再用外部评估(情感分类下游任务)看它对真实任务有没有帮助。
相似度(exp10):用平行语料训练 SGNS,对人工打分的词对算余弦,再用 Spearman 秩相关衡量「模型排序」与「人工排序」是否一致。
类比(exp11):按 target = v(b) − v(a) + v(c) 做关系平移,遍历词表取与 target 余弦最高的词,记得排除 a / b / c 本身;测「男人→国王,女人→王后」等 3 组。
下游(exp12):句向量取句中词向量平均,用逻辑回归做情感二分类,对比「训练过的词向量」与「随机初始化词向量」在 6 条评测句上的准确率。
汇总三种评估的指标与局限:内部评估便宜、快,但可能过拟合评测集;外部评估更贴近真实价值,但成本更高。
评估类型 做法 指标 局限
相似度(内部) 词对余弦 vs 人工打分 Spearman ρ 受评测集选择影响
类比(内部) v(b) − v(a) + v(c) 找最近词 类比准确率 只测少数关系,易被高频词干扰
下游任务(外部) 把词向量接入真实任务 准确率 / F1 成本高,结论依赖具体任务
三类评估要回答三个层次的问题:向量本身是否合理(相似度)、关系结构是否保留(类比)、对任务是否有用(下游)。三者不一致很常见——类比分数高不代表下游任务一定更好,所以真实工作中通常两类评估都看。
留出没看过的评测集 如果反复用同一个相似度 / 类比集调超参,模型就会「针对评测集」优化,分数虚高;报告里应区分「调参用的验证集」与「只看一次的报告集」。
预期结果 exp10 逐条打印人工分与模型余弦,最后输出 Spearman ρ(ρ 越接近 1 越好;真实 wordsim353 上好的词向量约 0.7–0.8)。exp11 逐条打印 ✓/✗ 与「类比准确率:correct/3」,性别方向若被学到,国王−男人+女人应落在王后附近。exp12 逐条打印评测句的预测与两种词向量的分类准确率,训练后的词向量应明显好于随机初始化(具体数值以实测为准)。
常见坑 类比时忘了排除 a / b / c,答案直接命中输入词;把人工分与模型分直接算 Pearson(量纲不同,应看 Spearman 秩相关);下游评估用评测集调参后再报告成绩,等于把答案泄漏给模型;句向量只做简单平均会丢词序,它只是最简基线,不是最佳实践。
def analogy(word_vec, a, b, c):
target = word_vec[b] - word_vec[a] + word_vec[c] # 关系平移
best, best_sim = None, -np.inf
for w, vec in word_vec.items():
if w in (a, b, c): # 排除输入词本身
continue
s = cosine(vec, target)
if s > best_sim:
best, best_sim = w, s
return best, best_sim
# 例:analogy(v, "男人", "国王", "女人") 期望得到 "王后"
思考题 · 点开看参考要点
问:内部评估与外部评估各指什么?类比任务成功说明了什么?
答:内部评估直接考察词向量本身(相似度、类比),不依赖下游任务,快但可能与真实用途脱节;外部评估把词向量接入文本分类、NER、翻译等任务,用任务指标衡量,更贴近实际价值但成本高。类比成功说明词向量空间把「性别」这类语义关系编码成了一个可线性平移的方向:国王→王后的偏移与男人→女人的偏移近似平行。
概念
KP 02.14
维度 d 怎么选:先看词表、再看内存,最后看效果
d 是人定的超参数,和 V 没有公式关系:PPT P31 中 V=39 用 10 维,V=260 用 25 维,d 随 V 增长但远小于 V。
选 d 先看三件事:词表、语料、存储。参数矩阵是 V×d,float32 每个数 4 字节,V 或 d 翻倍,内存就翻倍。小语料 50–100 维通常够用,大语料常用 100–300 维,预训练模型可到 768 维(补充)。
d 太小近义词挤在一起,太大则小语料易过拟合、训练慢、收益递减:先跑 d=100 基线,翻倍没涨就回退(补充)。V 也别无限大,只出现一两次的词通常用 min_count 截掉(补充)。V 由语料和分词决定,d 由预算和任务决定,两者独立调。
词表 V 维度 d 参数量 V×d float32 存储
1 万 100 100 万 约 4 MB
10 万 300 3000 万 约 120 MB
100 万 300 3 亿 约 1.2 GB
10 秒自测 · 点开看答案
问题:V=10 万、d=300 的 float32 嵌入矩阵占多少内存?
答案:10 万 × 300 × 4 B=1.2 亿字节,约 120 MB;V 或 d 再翻倍,存储也跟着翻倍。
概念
KP 02.15
OOV 与子词:为什么要把词拆成 BPE 和字符 n-gram?
一句话 词级词表是封闭的,子词把 OOV 拆成见过的碎片。
未登录词(OOV,Out-of-Vocabulary)指词表里没有的词。词级词表是封闭的,新词只能映射到 <UNK>,所有没见过的词共用一个编号,信息几乎全丢。
子词方案把词拆小:FastText 用字符 n-gram(带首尾边界符),词的向量等于各子词向量之和,没见过的词也能用见过的子词拼出来;拼写、词形相近的词天然共享向量。
BPE 则从字符出发,反复合并语料里最频繁的相邻符号对,直到词表达到目标大小(补充):常见词保持整词,罕见词被切成熟悉的片段,GPT、BERT 这类模型都走子词分词这条路(BERT 具体用 WordPiece,思路同类),基本消灭 OOV(补充)。
易错 实验 8 的实现里,子词只用于输入侧的中心词向量,输出侧仍是整词表(补充)→ OOV 词可以「查」到近似向量,但不能当预测目标参与训练;另外完全陌生的字/子词仍然拼不出有效向量,子词不是万能的。
10 秒自测 · 点开看答案
问题:FastText 凭什么能给没见过的词一个向量?
答案:它把词表示成字符 n-gram 子词向量之和;新词只要部分子词在训练语料中出现过,就能拼出近似向量,不必等扩充词表。
实验
KP 02.16
共现窗口 w:小窗口抓语法,大窗口抓主题
窗口 w 表示中心词左右各取 w 个词。实验 2 对比 w=1、2、3 会看到:w 越大,矩阵非零元素越多、计数越大,矩阵越稠密。
语义上,小窗口只看到紧邻词,偏向语法、搭配(「爱—北京」);大窗口能跨过更多词,偏向主题、篇章(「北京—城市—繁华」)。代价是高频功能词和噪声也被一起纳入——实验 2 里「的」几乎和所有词共现,真实语义被稀释。
所以窗口不是越大越好,要按任务选:词性、搭配类任务偏小,主题、聚类类任务偏大(补充)。实验 2 的记录表里,w 增大时「天安门」行的非零个数变多,才是主题连接变多的直接证据。
生活类比 像用相机拍一条街:小窗口是长焦特写,只看相邻两三家店;大窗口是广角,能看出这一带是商业区还是住宅区。
易错 把 w 当成「窗口总宽度」→ w=2 实际是左右各 2 个词、跨度 5 个位置;另外别只记录矩阵非零总数,实验 2 要求单独看「北京」「天安门」行的非零个数,远距离词的连接变化全藏在这一行里。
实验
KP 02.17
SVD 的 k 怎么选:压得太狠丢语义,留得太多等于没压
一句话 k 是保留的主方向数:够用就好,过大等于没压。
截断 SVD 只保留前 k 个奇异值,k 就是压缩后的向量维度。k 太小,丢掉的方向里还带着语义信息,相似度会随 k 明显波动,「北京—上海」可能忽高忽低;k 太大,留下的主方向接近原矩阵,压缩和去噪都没意义,计算也更贵。
实验 3 取 k=2、5、10、20 画相似度折线,看曲线是否稳定,就是选 k 的直观依据。实操上可以用解释方差比 Σσ_i² / Σσ² 定下限,再用内部评估或下游任务确认(补充);真实 LSA、词向量常取 100–300 维,小语料画图取 2–10 维(补充)。也可以用下游任务反向扫 k,但别在报告测试集上反复挑 k。
选 k 的检查顺序 先看相似度曲线是否稳定,再看解释方差比是否够高;k 超过矩阵秩(即非零奇异值个数,至多 V)后就不再压缩,纯粹是浪费。
10 秒自测 · 点开看答案
问题:k 从 2 加到 20,为什么「北京—上海」相似度可能先波动后趋稳?
答案:k 太小时保留的主方向不足以表达语义,少量噪声方向主导结果;k 增大后主要语义结构被保留,相似度趋于稳定,再加就只是把噪声也带进来。
公式
KP 02.18
层次 Softmax:把「V 选 1」拆成「log V 次二分类」
一句话 词表挂上哈夫曼树,V 选 1 变成 log V 次二分类。
层次 Softmax 把「V 选 1」的多分类改写成树上的路径判定。词表按词频建一棵哈夫曼树:每个词是叶子,从根到叶每经过一个内部节点就做一次二分类,用 sigmoid 决定往左还是往右,路径上概率连乘就是该词的条件概率。
高频词分到短码、路径短;低频词路径长,正好符合「常用词更该快」的直觉。每个内部节点只存一个向量,训练只更新路径上的节点,单样本复杂度从 O(V) 降到 O(log V)。
易错 说「层次 Softmax 是丢掉归一化的近似」→ 不对:树路径上的二分类概率连乘后,仍对所有叶子严格归一化,只是参数化方式换了(补充);真正不归一化、只用二分类近似的是负采样。另一个坑是以为路径长度恒为 log V——哈夫曼树只保证平均路径最短,最坏情况下单条路径仍可能接近 V(补充)。
公式
KP 02.19
负采样:为什么噪声词按词频的 3/4 次方抽?
一句话 噪声词按 f(w)^0.75 抽,高频不垄断、低频不挨饿。
负采样把「从 V 个词里挑出正确上下文」换成「正样本判 1,K 个随机噪声词判 0」,单样本复杂度 O(V) → O(K+1)。
噪声词不是均匀抽,而是按 P_n(w) ∝ f(w)^0.75 采样。原因很实际:按原始词频抽,「的」「是」这类高频词几乎垄断负样本,模型光在学它们;均匀抽又会让稀疏词当太多负样本,噪声太大。0.75 次方把高频压低、低频抬高,是 Word2Vec 论文试出来的经验值(补充)。
K 常取 5–20,语料很大时可降到 2–5(补充),实验 6 取 K=5。每个样本只更新正样本和这 K 个负样本对应的行,参数量不变,梯度更新量也随之大幅减少。
K 怎么取 小语料、小词表用 5–20 个负样本(实验 6 用 K=5);语料和词表越大,越可以少抽几个,K=2–5 也能训好。K 太小负信号不足,太大就接近全 softmax 的代价了。
10 秒自测 · 点开看答案
问题:负采样为什么用 0.75 次方,而不直接用词频或均匀分布?
答案:直接用词频会让「的」「是」等高频词垄断负样本;均匀分布又会过度放大稀疏词。0.75 次方是折中:高频词被抽中的比例降下来,低频词升上去,是论文中的经验最优取值。
公式
KP 02.20
GloVe 目标函数:用加权最小二乘拟合 log 共现
一句话 让点积去拟合 log 共现,用频率权重防止大词欺负人。
GloVe 不逐窗口预测,而是把全局共现矩阵直接当拟合目标:让 w_i·w̃_j + b_i + b̃_j 逼近 log X_ij。
取对数是因为共现次数跨好几个数量级,log 后近似线性,也和 PMI 的比值结构对应(补充)。外面乘权重 f(X_ij) 做加权最小二乘:f(0)=0,零共现不参与损失;高频共现权重封顶为 1,避免「的」「是」主导训练。两个偏置项用来吸收词本身的频率差异。
实验 7 只在非零共现对上训练,小语料取 x_max=2(实测口径)。
易错 对 X_ij=0 的位置也套公式 → log 0 变成 −∞ → 权重函数必须满足 f(0)=0、把这些位置排除。也别把 x_max 当普适常数:论文常用 100,实验 7 的小语料取 2,换语料要重新观察。
实验
KP 02.21
输入向量与输出向量:Word2Vec 为什么学两套?
Word2Vec 里每个词有两套向量:作中心词时用输入向量 v_c,作上下文时用输出向量 u_o;中心词与候选上下文的打分是 u_oᵀv_c,再对全词表做 softmax 得到 P(o|c)。
为什么不共用一套?两个角色预测的方向不同:中心词要输出「周围可能出现谁」,上下文词则作为被预测的一方;分开学能让同一词的两个角色各自拥有参数,表达能力更强(补充)。
实验 4 最后取 word_vec=v+u:把两套信息相加,通常比只用一套更好;只用输入侧也能用,只是信息略少。有的实现改成取平均或拼接,思路相同(补充)。
生活类比 像一个词有两份档案:一份记录它「当主角」时的表现,一份记录它「当配角」时的表现;查一个词像查一个人,两份档案合起来看才不会漏。
10 秒自测 · 点开看答案
问题:两套向量相加是「重复计算」吗?只用一套行不行?
答案:不是重复。两套向量训练时扮演的角色不同、看到的梯度不同,相加是把两种信息合并。只用一套也能用,只是信息略少,效果通常略差一些。
实验
KP 02.22
词向量散点图:PCA 看全局,t-SNE 看邻居
把高维词向量投到 2 维画散点,是实验 3 的选做任务:用 SVD 得到的 2 维向量作坐标,给每个点标上词名,看同类词是否聚在一起。
PCA 是线性投影,保留全局方差最大的方向,快且结果稳定,适合先看大结构;t-SNE 是非线性的,专门保留局部邻居关系,簇更清楚(补充)。
读图时只信「谁和谁近」:坐标轴没有单位,簇与簇之间的距离、不同图之间的远近都不能直接比较;t-SNE 还依赖随机种子和 perplexity(常取 5–50),参数一变布局就可能变(补充)。定量结论要回到最近邻表或相似度指标。
import matplotlib.pyplot as plt
plt.rcParams["font.sans-serif"] = ["Microsoft YaHei"] # Windows 中文字体
W = svd_vectors(X, k=2) # 每个词的 2 维 SVD 向量
plt.scatter(W[:, 0], W[:, 1]) # 每个点是一个词
for w, (x, y) in zip(words, W):
plt.annotate(w, (x, y)) # 标出词名
plt.show()
好看 ≠ 好用 图上一个簇只说明这些词的二维投影挨得近,真正的语义关系可能藏在高维里;散点图适合讲现象,评估结论仍要回到最近邻表和定量指标。
易错 把 t-SNE 图当定量结论 → 不同随机种子、不同 perplexity 画出的布局可以完全不同,簇间距离也没有意义 → 判断词向量好坏要回到最近邻表和 Spearman 这类指标。
面试
KP 02.23
wordsim353 与 Spearman:怎么证明词向量「像人」?
一句话 把模型排序和人工排序放进 Spearman,看它们像不像。
内部评估最常用「词对相似度」:给一批词对和人工打分(如 wordsim353,353 对,0–10 分),算出模型余弦,再看两组排序是否一致。
这里用 Spearman 秩相关而不是 Pearson:余弦和人工分的尺度不同,关系通常只是单调的,秩相关只看排序,不受线性变换影响。ρ∈[−1,1],越接近 1 越好;真实 wordsim353 上好的词向量 ρ 约 0.7–0.8(补充)。
还要注意数据集口径:wordsim353 偏「相关」,关联强但不同义的词对也能拿高分;SimLex-999 只测「相似」、刻意排除关联(补充),同一模型在后者上分数通常更低。报告里要写清评测集、词对数量与预处理,否则不同实验的 ρ 没法直接比较。
数据集 规模 打分侧重 备注
wordsim353 353 对 相似性 + 相关性 PPT P47 举例,常用基线(补充)
SimLex-999 999 对 只测相似性,控制关联 同一模型分数通常更低(补充)
10 秒自测 · 点开看答案
问题:词对相似度评估为什么用 Spearman,而不直接算 Pearson?
答案:模型余弦和人工打分的尺度、量纲都不同,二者关系通常只是单调而非线性;Spearman 基于排名,只关心「排序像不像人」,因此更合适。
概念
KP 02.24
Embedding 层:用预训练词向量,还是随机初始化?
一句话 有现成的先借来当起点;词表或领域差太多,就从头学。
Embedding 层就是一张 V×d 矩阵,按索引取行,本身是可学习参数 。随机初始化 :从零开始,靠任务数据把向量练出来,贴合任务但费数据、低频词学不好。预训练词向量 :把 Word2Vec / GloVe / FastText 学好的向量填进去当初值,等于把外部语料的知识带进来,之后可冻结也可继续训练。
怎么选:标注数据少、领域通用 → 用预训练;数据多、领域特殊(医疗、法律、代码)→ 随机初始化或先做领域内预训练(补充)。还要看词表覆盖:预训练表里没有的词仍是 OOV。
易错 填了预训练向量就以为万事大吉 → 分词方式和词表必须与预训练模型一致,否则索引对不上、大量词落进 UNK,效果反而更差。
10 秒自测 · 点开看答案
问题:预训练词向量填进 Embedding 层后,还会继续更新吗?
答案:看设置——冻结就固定不动,微调就随任务一起更新;选哪种取决于数据量和领域匹配度。
概念
KP 02.25
「语义相似」到底像什么:方向、余弦与近邻检索
一句话 相似看方向不看长短:cos 越大,两个词越同向。
词向量的「像」指上下文分布相似:常出现在相似语境里的词,方向接近。度量用余弦相似度 ,只算夹角、不看模长;向量先做 L2 归一化后,余弦就等于点积,检索更快(补充)。余弦距离 = 1 − cos,也是常用写法(补充)。
近邻检索 就是给定一个词或句向量,在向量库里找 top-k 最近的词。注意:cos 高只说明方向近,不保证同义——反义词、强关联词共享上下文,余弦也可能不低(补充)。
易错 直接拿未归一化的点积或欧氏距离排序 → 模长大的高频词占便宜,近邻结果失真 → 先把向量归一化,再按余弦或点积取 top-k。
10 秒自测 · 点开看答案
问题:余弦相似度等于 0 和等于 1,分别说明什么?
答案:0 表示两个向量正交、方向基本无关;1 表示完全同向,越接近 1 越相似,-1 则是完全反向。
易错
KP 02.26
词向量偏差:语料里的性别与职业偏见会被学进去(补充)
一句话 语料怎么说,向量就怎么记;偏见也会被当成语义。
词向量从语料学共现,而语料带着真实世界的社会偏见:性别与职业的搭配不平衡,会被向量原样继承甚至放大。表现是类比和近邻:某些职业词的邻居里挤满某一性别的词,类比任务也能推出刻板方向(经典研究见 Bolukbasi 等 2016,补充)。
危害在于落地:直接拿去做搜索、推荐、简历筛选,偏见会变成产品行为。缓解分三步:清洗平衡语料、做偏差度量(如 WEAT,补充)、后处理去偏并加上线评估(补充)。
10 秒自测 · 点开看答案
问题:为什么「把性别词从语料里删掉」不能解决偏差?
答案:偏见藏在共现结构里,职业与性别的统计关联仍在;要去偏得清洗语料、量化偏差,再对向量做后处理并持续监控。
概念
KP 02.27
冻结还是微调:预训练词向量怎么迁进下游任务?
一句话 数据少就冻住,数据多就微调;领域差太多先补语料。
冻结(freeze) :词向量表固定不更新,只训任务层,省参数、防小数据过拟合,但词义不会跟着任务变。微调(fine-tune) :Embedding 当参数一起训,常用比任务层更小的学习率,能让词向量适配任务,代价是小语料容易过拟合、忘掉预训练知识。
判断看三件事:标注数据量、领域匹配度、词表覆盖。常用折中:先冻结几个 epoch 再解冻,或分层设学习率(补充);OOV 词无论冻不冻都只能落到 UNK。
冻结 freeze 词向量不动,只训任务层。适合标注少、算力紧、词向量质量高。
微调 fine-tune 词向量随任务更新。适合数据较多、领域与预训练语料接近。
10 秒自测 · 点开看答案
问题:只有几千条标注数据,为什么更倾向冻结词向量?
答案:可训练参数少、更不容易过拟合;等数据充足、领域匹配时,再解冻并用小学习率微调更稳。
概念
KP 02.28
搜索、推荐、聚类、去重:词向量的四个落地场景
一句话 把文本变成向量,剩下的就是算近邻、排个序、判阈值。
四个场景本质上都是「向量化 + 比远近」:搜索 把 query 和文档都转成向量,按余弦召回或排序;推荐 把物品标题、描述向量化,找相似物品、做内容召回;聚类 用 KMeans 把词或文本分堆,做主题聚类、新词发现;去重 看两段文本的余弦是否超过阈值,判近重复。
共通的坑是「怎么把长文本变成一条向量」:直接对词向量取平均最简单,但会丢词序和重点(补充);现代做法多用句向量模型(补充)。
场景 怎么用 关键操作 注意
搜索 query、文档向量化后算相似 余弦 + 近似最近邻(补充) 长文档取平均会丢重点
推荐 物品文本向量找相似物品 内容召回、冷启动 热词主导、领域漂移
聚类 词或文本向量分堆 KMeans、轮廓系数辅助定 k(补充) K 要人工定,簇要人工命名
去重 余弦超阈值判近重复 验证集上校准阈值 阈值随语料和模型变
10 秒自测 · 点开看答案
问题:去重的相似度阈值能直接沿用别处的 0.8 吗?
答案:不能。阈值跟向量模型、语料、文本长度都有关,要在自己的验证集上用标注的近重复对校准。
本章速查 · 考点清单
词向量用法 :词表给索引,嵌入矩阵 E(V×d)按索引取行;d 是超参数,与 V 无关。
OneHot :长度 = V,只有一个 1;任意两词点积 / 余弦 = 0;四大缺点:维度灾难、极度稀疏、正交无语义、新词扩维。
维度灾难量化 :V = 10 万时单向量 400 KB,100 万词约 400 GB(372.5 GiB),非零比例 0.001%。
分布式假设 :词义由上下文决定;相似上下文 → 相似向量,「北京」与「上海」就是典型例子。
共现矩阵 :窗口 w 左右各 w 个词、不含自身、通常对称;小窗口偏语法,大窗口偏主题;缺点:V² 存储、高维稀疏、无词序、无法增量更新。
共现 + SVD :截断 SVD 取前 k 维;预处理用 log(1+X)、PPMI;五大缺点:V² 规模、V³ 分解、不能增量、高频词主导、低频词质量差。
Word2Vec :SG 中心词 → 上下文(一对多,约 2w 样本 / 位置,低频词好);CBOW 上下文 → 中心词(多对一,取平均,快,低频词弱)。
损失 :点积 → softmax 概率 → 负对数似然;softmax 前减最大值防溢出;最终词向量常用 U + V。
加速 :层次 Softmax 用哈夫曼树,O(log V);负采样只更新正样本 + k 个负样本,O(k)。
GloVe :全局共现矩阵分解,拟合 log X;FastText :字符 n-gram 子词向量相加,能处理 OOV。
静态 vs 动态 :Word2Vec / GloVe / FastText 静态、一词一向量;ELMo 用两个独立单向 LSTM,多层隐状态加权求和,按上下文动态生成;BERT / GPT 是 Transformer-based 后继。
评估 :内部 = 相似度(wordsim353)+ 类比(King - Queen = Man - Woman);外部 = 下游任务(NER、机器翻译、文本分类)。
高频易错 :① OneHot 不能表达相似度;② CBOW 平均导致词序丢失;③ 两套向量相加不是重复计算;④ 层次 Softmax / 负采样是近似加速,不是新模型。
来源:第二章 PPT P29–P48(词向量)、P84–P88(静态 / 动态词向量与 ELMo);《HCIP-AI 第 2 章 · 自然语言处理词向量实验指导书》PDF(实验 1–5 的实验目的、原理与思考题参考答案)。
文本分类(Text Classification)是 NLP 里最像"日常业务"的任务:给一段文本,判一个类别。这一章用同一份四分类语料(体育 / 教育 / 健康 / 旅游)当主线,从词袋、TF-IDF 加传统分类器,一路走到 TextCNN、TextRNN 和 BERT 微调,最后用准确率、精确率、召回率、F1 与混淆矩阵验收。学完你应该能回答三个问题:文本怎么变成向量、四个模型各自的取舍在哪、以及为什么"准确率 95%"有时不能信。
3.1 先把任务说清楚:输入什么,输出什么
概念
KP 03.1
文本分类在做什么?输入一段文本,输出一个类别
一句话 文本分类 = 给一段文本贴一个标签:输入是变长文本,输出是离散类别。
课程 PPT 给的定义非常直白:input 是「今天发了工资,我很开心!」,output 是「0(positive)」——这就是一次二分类。本章把难度抬一级,用一份中文短文本四分类语料:体育、教育、健康、旅游,标签编号固定为 体育=0、教育=1、健康=2、旅游=3。
从工程角度看,这个任务可以拆成两个子问题:表示 (怎么把一串汉字变成分类器能算的向量)和判别 (用什么函数把向量映射到类别)。本章几乎所有的技术演进,都是在回答这两个问题中的某一个。
输入:不定长的自然语言文本,几个字到几百字都可能。
输出:离散类别;二分类可以看成四分类的特例。
训练数据:文本 + 标签,模型学的正是「文本 → 类别」的映射。
下游同类任务:情感分析、垃圾邮件识别、内容审核、意图识别。
评价不只看"对了多少",还要看"每类找得全不全"。
生活类比 像医院大厅的分诊台:病人说一段话(文本),护士判断该去哪个科室(类别)。护士不需要逐字理解整段话,只要抓住「发烧」「骨折」这类关键线索——特征提取就是在找这些线索。
10 秒自测 · 点开看答案
问题:文本分类的输出是连续数值还是离散类别?
答案:离散类别(如 0/1/2/3)。模型输出的概率分布只是中间结果,最终要 argmax 取类别。
概念
KP 03.2
一条完整流水线:文本 → 向量化 → 特征选择 → 分类器 → 评估
一句话 文本分类的骨架只有五步;深度学习只是把前三步交给网络自动完成。
不管用传统方法还是深度学习方法,一条文本分类流水线都离不开五站:文本 进、向量化 、特征选择 、分类器 、评估 。传统路线里前两站由人来设计(TF-IDF、卡方检验),深度学习路线里改由 Embedding 和卷积 / 循环 / Transformer 层自己学,但"表示 → 判别 → 验收"的逻辑没有变。
向量化:词袋 / TF-IDF(实验 1),或 Embedding(实验 2–4)。
特征选择:卡方检验、互信息、信息增益,把上万维里的无效特征筛掉。
分类器:朴素贝叶斯、逻辑回归、SVM、决策树、集成算法,或 CNN / RNN / BERT。
训练:定损失(分类用交叉熵)、定优化器(常用 Adam)、定轮次。
评估:Accuracy、Precision、Recall、F1、分类报告、混淆矩阵。
注意评估不是最后补的一步:训练过程中就要看验证集,否则你无法判断是欠拟合还是过拟合。
文本
向量化
特征选择
分类器
评估
新闻正文
BOW / TF-IDF
卡方 / 互信息
NB / CNN / BERT
P / R / F1
图注:五步流水线。实验 1 手工做前两站,实验 2–4 让网络端到端自学表示。
10 秒自测 · 点开看答案
问题:深度学习方案里,哪一步被网络"自动完成"了?
答案:向量化与特征提取。Embedding + 卷积 / LSTM / BERT 直接从字 id 学出表示,不再需要人工设计 TF-IDF 与特征选择。
记忆口诀 「先表示、再筛选、后分类、末验收」——四组动词串起整条流水线;每换一个模型,先问它在哪一步动了手脚。
实验
KP 03.3
同一份四分类语料:四个实验凭什么能互相比较?
一句话 同一份数据、同一套划分、同一套指标,四个实验的分数才有可比性。
实验指导书特意让四个实验共用一份语料,由 utils.py 里的 load_data() 统一读取:data/ 目录下放 体育.csv、教育.csv、健康.csv、旅游.csv 四个文件,每个 CSV 单行单条文本、无表头,读取后按文件名归类,标签映射固定为 {'体育': 0, '教育': 1, '健康': 2, '旅游': 3}。
划分方式也统一:train_test_split(test_size=0.2, random_state=42, stratify=label_id),即 80% 训练、20% 测试,并用分层抽样(Stratified Sampling) 保证四类在两边占比一致;random_state=42 固定随机种子,保证每次运行划分相同、结果可复现。BERT 脚本把测试集命名为验证集(val),口径仍是同一份 20% 数据。
顺序一致:评估时 target_names=list(label_map.keys()),保证第 0 行真的是体育。
环境口径:Python 3.8+、scikit-learn 1.3+、pandas 2.0+、torch 2.0+、transformers 4.30+。
规模参考:BERT 脚本注释按"手头约 4 万条新闻"估量,实际以你的语料为准。
提交要求:每个实验交源代码 + 运行截图或输出文本 + 思考题回答。
import os
import pandas as pd
def load_data():
"""读取四个类别的 CSV,返回 DataFrame 与标签映射"""
data_dir = r'.\data' # 语料目录:四个 CSV 放这里
files = {'体育': '体育.csv', '教育': '教育.csv',
'健康': '健康.csv', '旅游': '旅游.csv'}
data_list = []
for label, name in files.items():
path = os.path.join(data_dir, name)
df = pd.read_csv(path, header=None) # 单行单条文本、无表头
for _, row in df.iterrows():
text = str(row[0]).strip()
if text: # 空行直接丢掉
data_list.append({'text': text, 'label': label})
full_df = pd.DataFrame(data_list)
label_map = {'体育': 0, '教育': 1, '健康': 2, '旅游': 3}
full_df['label_id'] = full_df['label'].map(label_map)
return full_df, label_map
易错 报 FileNotFoundError: 找不到文件:脚本里的 data_dir 是相对路径 r'.\data'(旧示例是绝对路径),要改成你机器上真实的语料目录;路径错了往往表现为"预测全是同一类",先打印 full_df['label'].value_counts() 确认数据真的读进来了。
10 秒自测 · 点开看答案
问题:stratify=label_id 有什么用?去掉会怎样?
答案:按类别比例分层抽样,保证训练 / 测试集四类分布一致;去掉后可能某类样本几乎全落在测试集,评估失真。
3.2 特征工程:从词袋到 TF-IDF,再筛特征
概念
KP 03.4
词袋(BOW):只数词,不管顺序
一句话 词袋把文本拆成"一袋词",只记每个词出现几次,彻底丢掉词序。
词袋模型(Bag of Words, BOW)是最简单的文本向量化方法:它不考虑句子中单词的顺序,只统计词表中每个词在这段文本里出现的次数。向量维度 = 词表大小,绝大多数位置是 0,所以它是典型的高维稀疏表示。
PPT 给的例子:语料是「我 爱 上海」「我 爱 杭州」「我 爱 北京 天安门」三句话,词表是 {上海, 北京, 天安门, 我, 杭州, 爱},于是每句变成一个 6 维计数向量。能看出两件事:一是"我""爱"每篇都有,计数都是 1,提供不了区分信息;二是"北京""天安门"只出现在 d3,才是真正标识第三篇的词。
词袋的硬伤也很清楚:它把「我 爱 上海」和「上海 爱 我」表示成完全相同的向量,词序信息为零;对中文还多一层麻烦——必须先分词,分词错了特征就错了。
文档 上海 北京 天安门 我 杭州 爱
d1:我 爱 上海 1 0 0 1 0 1
d2:我 爱 杭州 0 0 0 1 1 1
d3:我 爱 北京 天安门 0 1 1 1 0 1
生活类比 像把一锅汤倒进滤网,只数剩下几块肉、几片菜,却不记下锅顺序。食材清单一模一样的两锅汤,味道可能完全不同——词袋丢掉的正是"味道"。
10 秒自测 · 点开看答案
问题:「我 爱 上海」和「上海 爱 我」在词袋下有什么区别?
答案:向量完全相同,区别为 0。要保留词序,必须换用 n-gram、卷积、循环网络或预训练模型。
公式
KP 03.5
TF-IDF:给"到处都有的词"降权
一句话 一个词越常见越不值钱,越专属越值钱——这就是 IDF 的直觉。
TF-IDF(Term Frequency–Inverse Document Frequency,词频-逆文档频率)在词频的基础上再乘一个逆文档频率:一个词在本篇里出现得越多,它越能代表这篇;但它在整个语料里越常见,区分能力就越弱。两个信号相乘,正好把"的、是、我"这类到处都有的词压下去,把"上海、天安门"这类只属于少数文档的词抬起来。
TF(词频):词 t 在文档 d 中出现的次数或频率,越大越重要。
IDF(逆文档频率):log(N / (1 + df(t))),N 是文档总数,df(t) 是包含 t 的文档数;df 越大,IDF 越小。
与词袋的差别:词袋只回答"出现了几次",TF-IDF 还回答"这次出现值多少分"。
(补充)sklearn 默认做平滑:idf = ln((1 + N) / (1 + df)) + 1,再对整行做 L2 归一化。
用 PPT P53 的示例验算一下:三篇文档里 df(上海)=1、df(我)=3,所以"上海"的 IDF 明显大于"我";在 d1 里两者 TF 都是 1,归一化后"上海"得 0.767、"我"得 0.453——差距完全来自 IDF。这就是 TF-IDF 比词袋"更懂谁重要"的地方。
文档(PPT P53 示例) 上海 北京 天安门 我 杭州 爱
d1:我 爱 上海 0.767 0.0 0.0 0.453 0.0 0.453
d2:我 爱 杭州 0.0 0.0 0.0 0.453 0.767 0.453
d3:我 爱 北京 天安门 0.0 0.608 0.608 0.359 0.0 0.359
生活类比 像老师划重点:「的」「是」全年级每张卷子都有,不值钱;只有这本讲义才出现的专业名词,才是真正要背的重点。IDF 就是那个"全年级普及率"的倒数。
10 秒自测 · 点开看答案
问题:IDF 为什么要用 log,还要加平滑?
答案:log 把"文档数之比"压成温和的权重,避免极稀有词权重爆炸;加 1 平滑防止分母为 0、未登录词导致无穷大。
概念
KP 03.6
为什么用字符级 n-gram,而不是先分词?
一句话 中文分词会出错,字符级 1–2 gram 不依赖分词器,稳定又好实现。
本课四个实验都采用字符级 n-gram 特征:TfidfVectorizer(analyzer='char', ngram_range=(1, 2))。它直接以"字"和"相邻两字组合"为单元,例如「人工智能」会被切成 人、工、智、能、人工、工智、智能。
好处 :省去分词环节,不受分词器误差影响;对未登录词、网络新词(如"栓Q""绝绝子")更鲁棒;实现简单、结果稳定,是教学与竞赛常用技巧。代价 :特征空间更大(字 × 字组合),本课用 max_features=10000 截断控制维度;"体育""旅游"这类完整语义单元被拆散,可解释性变差;单字特征语义弱,长文本上可能不如词级。
若改词级,需先 jieba.cut 得到词列表,再把 tokenizer=tokenize 传给向量化器,并保证 analyzer='word'。
字符级 char(本课默认) list(text) 按字切,1–2 gram;免分词、抗新词,维度更大、可解释性弱。
词级 word(拓展) jieba 分词后传入 tokenizer;语义单元完整,但受分词误差影响,需额外依赖。
易错 把 analyzer='char' 改成词级后报分词相关错误:tokenizer 必须返回 list(如 list(jieba.cut(text))),且字符级与词级的准确率不能直接横比,因为特征空间已经变了。
10 秒自测 · 点开看答案
问题:字符级 n-gram 最大的两个代价是什么?
答案:特征维度膨胀(需 max_features 截断)与丢失词级语义单元("体育"被拆成"体""育""体育"后语义粒度变粗)。
公式
KP 03.7
高维稀疏必须筛特征:卡方检验、互信息、信息增益
一句话 上万维 TF-IDF 里大半是噪声,先用统计检验挑出"更懂类别"的特征。
词袋或 TF-IDF 向量化之后,特征通常成百上千乃至上万维,且绝大部分是 0——这就是高维稀疏。直接丢给分类器不仅效果不好,训练和预测也慢,所以要先做特征选择 ,过滤掉与类别无关的无效特征。文本分类里常见三种做法:卡方检验(Chi-square)、互信息(Mutual Information, MI)、信息增益(Information Gain, IG)。
卡方检验 源自统计学卡方分布,从「(类,词项)相关表」出发,度量特征和类别独立性的缺乏程度:卡方越大,独立性越小、相关性越大。把 4 个数记清楚就够用了:A = 含该词且属于类 c 的文档数,B = 含该词但不属于 c,C = 不含该词但属于 c,D = 不含该词且不属于 c,N = A+B+C+D。
互信息 衡量"知道词 t 之后,类别 c 的不确定性减少多少":I(t;c) = ΣΣ P(t,c)·log[P(t,c) / (P(t)·P(c))]。信息增益 是互信息的另一张脸:IG(c,t) = H(c) − H(c|t),决策树选分裂特征用的就是它。三者都是"打分后排序、保留前 k 个",实践中可用 SelectKBest(chi2, k=...) 落地。
为什么要筛:降维 → 训练更快、更抗过拟合、更容易解释。
卡方偏好:对低频词容易给出虚高分数(补充),先设 min_df 再筛。
互信息 / 信息增益:都需要估计概率,样本少时估计噪声大。
10 秒自测 · 点开看答案
问题:卡方值越大,说明特征与类别是什么关系?
答案:独立性越弱、相关性越强,越应该保留。若 χ² 接近 0,说明该词对区分类别几乎没有贡献。
实验
LAB 03.1
实验 1 · TF-IDF + 朴素贝叶斯 / 逻辑回归
难度 ★☆☆
对应 PPT P52–P56
train_tfidf.py + utils.py
实验目的:用最小成本跑通"文本 → 向量 → 分类器"闭环,拿到四分类的第一个基线,并亲眼看到 TF-IDF 与词袋的差别、朴素贝叶斯与逻辑回归的差别。
确认 data/ 下四个 CSV 就位,utils.py 的 data_dir 指向真实路径,打印标签分布确认四类都加载成功。
按 8:2 划分训练 / 测试集,random_state=42、stratify=label_id,保证四类占比一致、结果可复现。
用 TfidfVectorizer(analyzer='char', ngram_range=(1, 2), max_features=10000) 把文本变成稀疏矩阵;训练集 fit_transform,测试集只 transform。
训练 MultinomialNB,输出 accuracy 与 classification_report。
训练 LogisticRegression(max_iter=1000, random_state=42),同样评估,并与 NB 对比。
拓展:换成 analyzer='word' + jieba 分词,比较字级与词级的维度、准确率与 macro-F1。
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from utils import load_data
full_df, label_map = load_data()
# 80/20 划分;stratify 保证四类占比一致
X_train, X_test, y_train, y_test = train_test_split(
full_df['text'], full_df['label_id'],
test_size=0.2, random_state=42, stratify=full_df['label_id'])
# 字符级 1-2 gram,不用分词器;截断到 1 万维控制稀疏度
vec = TfidfVectorizer(analyzer='char', ngram_range=(1, 2), max_features=10000)
X_train_vec = vec.fit_transform(X_train) # 只在训练集 fit
X_test_vec = vec.transform(X_test) # 测试集只 transform
names = list(label_map.keys()) # 中文类别名,顺序要对
nb = MultinomialNB().fit(X_train_vec, y_train)
print('NB:', accuracy_score(y_test, nb.predict(X_test_vec)))
print(classification_report(y_test, nb.predict(X_test_vec), target_names=names))
预期结果 脚本先后输出「朴素贝叶斯分类结果」与「逻辑回归分类结果」两组评估,每组含整体 accuracy 与四个类别(体育 / 教育 / 健康 / 旅游)的精确率、召回率、F1、support。按指导书预期:逻辑回归通常略优于朴素贝叶斯(它不做特征条件独立假设);若某类样本明显偏少,该类的召回率会明显偏低——这是类别不均衡的典型现象,可直接写进结果分析。分数以本机实测为准,不要照抄。
常见坑 ① 在测试集上调用 fit_transform 会重新学词表,训练 / 测试特征空间错位,指标虚高;必须 fit_transform 训练集、transform 测试集。② 忘了 stratify 且数据量小,可能某类在测试集里一个样本都没有,classification_report 直接报警。③ max_features 设太小会丢掉大量低频但区分性强的词。
思考题 · 点开看参考要点
思考题:TF-IDF 相比词袋改变了什么?字符级 n-gram 的好处与代价是什么?
参考要点:TF-IDF 用 IDF 压低全语料高频词的权重,让"区分性词语"权重更高,因此更能刻画主题;字符级 n-gram 免分词、抗未登录词,但维度更大、语义粒度更粗,可解释性下降。
3.3 传统分类器:先跑一个便宜又快的基线
公式
KP 03.8
朴素贝叶斯:为什么"明显错误的假设"还能好用?
一句话 假设每个词对类别的贡献互相独立,于是概率可以直接连乘。
朴素贝叶斯(Naive Bayes)建立在贝叶斯公式上:已知文本 d,要判类别 c,就比"哪个类别的后验概率大"。分母 P(d) 对所有类别相同,可以不管,于是 P(c|d) ∝ P(c) × Π P(t_i|c)——这一行里的 Π 就是"朴素"二字:假设在该类别下,各个词出现与否互相条件独立 。这个假设在文本里显然不成立(相邻词高度相关),但它带来的好处是参数极少、训练极快,在高维稀疏特征下反而是稳定基线。
两个必须会写的工程细节:一是取对数,把连乘变成连加,既防下溢又更快:log P(c|d) = log P(c) + Σ log P(t_i|c);二是拉普拉斯平滑(Laplace Smoothing) ,给每个词的出现次数加 1,避免某个没出现过的词让整串概率直接归零。
垃圾邮件例子(PPT P59):输入「黄金地段,快速抢购」,把这句话拆成若干词,分别算垃圾邮件类与正常邮件类的 P(类) × Π P(词|类),谁的得分大就判给谁。真实计算里 P(词|类) 就是该类中该词的计数占比。
优点:训练是计数,几秒完成;小样本可用;高维稀疏下稳。
优点:可解释,能看到哪个词把分数推高了。
缺点:忽略词间相关("不"+"好"被拆开看);概率值不是真实置信度,只适合比大小。
对应实现:MultinomialNB,专为词频 / 词权这类非负计数特征设计。
生活类比 像几个评委各自独立打分再汇总。评委之间其实会互相影响(词与词并不独立),但"各打各的分、加起来比大小"往往仍能选出对的那个——这就是朴素贝叶斯能用的原因。
易错 直接连乘导致概率下溢成 0 → 改用对数相加;不做平滑时,测试文本里出现一个训练时没见过的词,整条概率链变 0 → 平滑 + <UNK> 兜底。
10 秒自测 · 点开看答案
问题:拉普拉斯平滑解决什么问题?
答案:某词在类 c 中一次都没出现时条件概率为 0,会让整串连乘归零。加 1 平滑让每个词都有一个极小的非零概率,同时保持"出现多的词概率更大"。
概念
KP 03.9
逻辑回归、SVM、决策树、集成:高维文本下怎么选?
一句话 文本特征又高又稀,线性模型往往最划算,树模型适合做对照。
完成特征提取后,传统机器学习分类算法都能用来做文本分类,PPT P57 列了五类:朴素贝叶斯、逻辑回归、SVM、决策树、集成算法(随机森林、XGBoost 等)。
逻辑回归(Logistic Regression) :名字带"回归",实际是分类器。为每个类别学一组权重,用 softmax 把得分变成概率,取最大者。不做特征独立假设,能利用词间相关性,因此在本课实验里通常略优于朴素贝叶斯。max_iter=1000 是防止不收敛报错。
支持向量机(Support Vector Machine, SVM) :找最大间隔超平面。文本特征维度高时线性核就够(LinearSVC),是经典强基线,但要对正则参数 C 调参。
决策树(Decision Tree) :按特征阈值逐层分裂,可解释、能导出规则;但高维稀疏下容易过拟合、对数据扰动敏感。
集成算法 :随机森林(Random Forest)用多棵树投票,抗过拟合;XGBoost 用梯度提升逐棵纠错,精度高但更慢、更依赖调参。
实务顺序:先用 TF-IDF + 逻辑回归拿基线,再往上加复杂度。若换成深度模型,基线分数就是"值不值得"的参照。
分类器 核心思想 文本场景优点 注意点
朴素贝叶斯 贝叶斯 + 条件独立 训练极快、小样本可用、可解释 忽略词间相关,概率不可信
逻辑回归 线性得分 + softmax 高维稀疏下稳、能调正则、出概率 线性边界,特征交叉需人工
线性 SVM 最大间隔超平面 文本分类经典强基线 不直接出概率,C 要调
决策树 阈值逐层分裂 规则可解释 高维稀疏易过拟合
随机森林 / XGBoost 多模型集成 精度通常高于单模型 训练慢、参数多,小数据收益有限
10 秒自测 · 点开看答案
问题:为什么逻辑回归在 TF-IDF 特征上常比朴素贝叶斯好?
答案:逻辑回归不假设特征条件独立,能利用词与词之间的相关性来调整权重;朴素贝叶斯把这些相关性全部丢掉,只能靠"独立累加"。
3.4 深度学习:TextCNN、TextRNN、BERT
概念
KP 03.10
TextCNN:用一维卷积扫出"关键词组"
一句话 卷积核只沿字序滑动,一次看 2–4 个字,等价于自动学出来的 N-gram。
TextCNN 是用卷积神经网络做文本分类的经典模型。文本经词嵌入(本课是字嵌入)后得到一个二维矩阵:行是位置、列是 embed_dim。它只有一层卷积、一层最大池化,最后接 softmax 做多分类,结构比图像 CNN 还简单。
为什么不用 2D 卷积 :图像的卷积核从左到右、从上到下扫,是二维滑窗;文本是一维序列,词向量矩阵的"列"只是同一个字的向量维度,横向滑动没有意义。PPT P60 举的例子很到位:把"今天"的 OneHot 向量按 1×2 的窗口从左往右滑,得到的 [0,0]、[0,0]、[0,0]、[0,1] 仍然都是"今天"这个字,这种滑动没有帮助。所以 TextCNN 的卷积核高度 = 连续看的字数(本课 2 / 3 / 4),宽度直接等于 embed_dim,一列扫满整个词向量。
前向流程:Embedding(128 维)→ 三组卷积核(2/3/4,每组 128 通道)→ ReLU → 每路 1-max 池化 → 拼接成 128×3=384 维 → Dropout 0.5 → 全连接输出 4 类 → 交叉熵(内部已含 softmax)。提取出的特征正类似 N-gram 的局部组合关系,区别是这些"词组"是模型自己学出来的,不用人列。
优点:卷积可并行、训练快;局部搭配("主场""进球")捕捉得准;参数比 BERT 小几个数量级。
缺点:只看窗口内(2–4 字),跨句、远距离依赖弱;对长文本"前文否定后文"这类语义不敏感。
为什么 max-pooling:只要窗口内出现一个强特征就保留,对位置和句长不敏感,比平均池化更契合"关键短语决定类别"的文本。
关键超参:embed_dim=128、filter_sizes=[2,3,4]、num_filters=128、dropout 0.5、Adam lr=1e-3、3 个 epoch、batch_size=32。
class TextCNN(nn.Module):
def __init__(self, vocab_size, embed_dim, num_classes,
filter_sizes=[2, 3, 4], num_filters=128):
super().__init__()
# padding_idx=0:让 <PAD> 那一行不参与梯度更新
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
# 卷积核高=连续字数,宽=embed_dim,一列扫满整个字向量
self.convs = nn.ModuleList(
[nn.Conv2d(1, num_filters, (fs, embed_dim)) for fs in filter_sizes])
self.fc = nn.Linear(num_filters * len(filter_sizes), num_classes)
self.dropout = nn.Dropout(0.5)
def forward(self, x):
x = self.embedding(x).unsqueeze(1) # (B,L) → (B,1,L,D) 补通道维
pooled = [torch.max(torch.relu(conv(x)).squeeze(3), dim=2)[0]
for conv in self.convs] # 每路做 1-max 池化
x = torch.cat(pooled, dim=1) # 128 × 3 = 384 维
return self.fc(self.dropout(x)) # 4 类得分,softmax 在损失里
生活类比 像用三把不同宽度的放大镜(看 2 字、3 字、4 字)沿句子从头扫到尾,每把只记下"最像线索的那一格"。三把镜子的发现拼起来,就是对这句话的判据。
易错 忘记 unsqueeze(1):nn.Conv2d 要求四维输入 (N, C, H, W),直接把 (B, L, D) 喂进去会报维度错误;同时别忘了 padding_idx=0 与 <PAD>=0 必须配套。
10 秒自测 · 点开看答案
问题:TextCNN 为什么用 max-pooling 而不是平均池化?
答案:文本里往往一两个关键短语就能决定类别,max 只保留最强响应,且与短语出现在句首还是句尾无关;平均池化会被大量无关字稀释。
实验
LAB 03.2
实验 2 · TextCNN 中文文本分类
难度 ★★☆
对应 PPT P60
train_textcnn.py
实验目的:走通"字符级分词 → 构建字表 → padding → 一维卷积训练 → 评估"的完整深度学习流程,理解卷积核如何自动提取局部 N-gram 特征,并与实验 1 的 TF-IDF 基线对比。
TextDataset 在训练集上 build_vocab:统计字符频次、保留最常见的 10000 个,<PAD>=0、<UNK>=1;测试集复用训练集词表。
encode 把每条文本截断 / 补齐到 max_len=256,作为定长输入。
搭模型:Embedding(128) + 三组卷积(Conv2d(1,128,(fs,128)), fs=2/3/4) + ReLU + 1-max 池化 + Dropout + 全连接 4 类。
训练:CrossEntropyLoss + Adam(lr=1e-3),batch_size=32,跑 3 个 epoch,每个 epoch 打印训练完成。
评估:model.eval() + torch.no_grad(),argmax 取预测,输出 accuracy 与分类报告。
拓展:卷积核再加一个 5、或把 embed_dim 改成 100 / 200,观察四分类准确率变化。
预期结果 每训练完一个 epoch 打印「Epoch N 训练完成」,最后输出「TextCNN 分类评估报告」,含整体 accuracy 与体育 / 教育 / 健康 / 旅游四类的精确率、召回率、F1。按指导书预期:TextCNN 通常高于实验 1 的 TF-IDF 基线,因为字嵌入 + 卷积能自动学局部字序模式;若语料较小也可能因参数多而过拟合,此时减小 embed_dim 或加大 Dropout。具体数值以本机实测为准。
常见坑 ① 测试集重新 build_vocab,编码体系与训练集不一致,指标全乱——必须传 vocab=train_dataset.vocab。② 设备只搬了模型没搬数据,报 "Expected all tensors to be on the same device":texts、labels 都要 .to(device)。③ batch_first=True 没设或忘了 unsqueeze(1),维度对不上。
思考题 · 点开看参考要点
思考题:TextCNN 的卷积核捕捉的是文本的什么信息?它比词袋 / TF-IDF 多利用了哪一层信息?
参考要点:捕捉长度为 2–4 的局部字序组合,类似 N-gram;比 BOW / TF-IDF 多利用了"词序"与局部搭配,且这些模式由模型自动学习而非人工统计。
概念
KP 03.11
TextRNN:把整句话"读"进最后的隐藏状态
一句话 Embedding 之后逐字读,双向 LSTM 末态拼接当作整句向量。
TextRNN 用"字嵌入 + 循环神经网络"建模文本。LSTM 沿序列方向逐字读取,每个时间步的隐藏状态汇聚了"当前字 + 历史上下文";因为普通 RNN 有梯度消失问题(长文本开头的信息传不到结尾),所以用门控的 LSTM(遗忘门 / 输入门 / 输出门)来缓解。
本课实现:Embedding(128) → 双向 LSTM(num_layers=2、hidden 128、dropout 0.3)→ 取最后一层正向末态 hn[-2] 与反向末态 hn[-1] 拼接成 256 维 → Dropout 0.5 → 全连接输出 4 类。双向的意义是:正向读一遍、反向读一遍,每个位置同时拥有"前文"和"后文"。取最后一步的理由是 RNN 的核心假设——经过足够多步后,隐藏状态"已消化"全文,等价于整篇文本的向量表示。
PPT 备注里还给了另一种聚合方式:把每个时间步的前向 / 后向隐状态都拼接起来,再对所有时间步取均值,然后接 softmax(二分类则用 sigmoid)。均值池化更稳、对长文本更友好,代价是丢失"结尾总结"的结构感。
擅长:需要跨位置理解的语义,如否定、转折、程度("虽然……但是……")。
弱点:只能顺序计算、训练比 CNN 慢、显存占用更高;超长文本仍有遗忘。
关键超参:hidden 128、num_layers=2、双向、Adam lr=1e-3、3 个 epoch、batch_size=32。
class TextRNN(nn.Module):
def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes, num_layers=2):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers=num_layers,
batch_first=True, # 输入形状 (batch, seq, feat)
bidirectional=True, # 双向:输出维度翻倍
dropout=0.3)
self.fc = nn.Linear(hidden_dim * 2, num_classes) # 双向拼接 → 256
self.dropout = nn.Dropout(0.5)
def forward(self, x):
x = self.embedding(x) # (B,L) → (B,L,D)
out, (hn, cn) = self.lstm(x)
# hn 形状 (num_layers × 2, B, hidden):[-2] 正向末态、[-1] 反向末态
hidden = torch.cat((hn[-2], hn[-1]), dim=1)
return self.fc(self.dropout(hidden))
生活类比 像秘书听录音做纪要:边听边把要点压进"脑子里的当前状态",听完那一刻脑子里的东西就是全文摘要;双向则是正着听一遍、倒着听一遍,再把两份摘要拼起来。
易错 hn 的形状是 (num_layers × num_directions, batch, hidden),双向时索引是 hn[-2] 与 hn[-1],写成 hn[-1] 和 hn[0] 就取错了方向;全连接输入必须是 hidden_dim * 2,否则维度不匹配。
10 秒自测 · 点开看答案
问题:双向 LSTM 相比单向 LSTM 多利用了什么信息?
答案:每个位置的后文信息。反向读一遍让当前字的隐状态也包含右侧上下文,拼接后同时具备前文与后文。
实验
LAB 03.3
实验 3 · TextRNN(双向 LSTM)中文文本分类
难度 ★★☆
对应 PPT P61
train_textrnn.py
实验目的:掌握"Embedding + 双向 LSTM + 全连接 + softmax"的序列建模路线,理解 TextRNN 如何利用词序与上下文,并与 TextCNN(局部窗口)、TF-IDF(无词序)形成三方对照。
数据与字表流程同实验 2(max_len=256、词表 10000、<PAD>=0、<UNK>=1),保持口径一致才能对比。
搭模型:Embedding(128) + BiLSTM(hidden 128, num_layers=2, dropout 0.3) + 末态拼接 + Dropout + 全连接 4 类。
训练 3 个 epoch(交叉熵 + Adam lr=1e-3,batch_size=32),每个 epoch 打印完成信息。
评估:输出 accuracy 与四类分类报告,与实验 2 的 TextCNN 结果并列比较。
拓展:把 num_layers 改成 1 或 3,观察效果与训练速度;再把双向改单向做消融。
预期结果 每个 epoch 打印「Epoch N 训练完成」,最后输出「TextRNN 分类评估报告」。按指导书预期:在四分类语料上,双向 LSTM 通常能取得与 TextCNN 接近甚至略优的效果(显式建模词序与上下文),但训练更慢、显存占用更高;若语料较短、局部 N-gram 已足以区分类别,两者差距可能不明显——这种"差距不明显"本身也是值得写进分析的现象。分数以实测为准。
常见坑 ① 序列长度 max_len=256 对 LSTM 计算量影响很大,调到 512 会明显变慢甚至 OOM。② 取错隐藏状态方向(见 KP 03.11)。③ 评估时忘写 model.eval(),Dropout 仍在随机丢弃,指标偏低且每次不同;preds 记得 .cpu() 再转 list。
思考题 · 点开看参考要点
思考题:TextRNN 比词袋、TextCNN 多用了什么信息?它和 BERT 的本质差别在哪?
参考要点:多用了序列依赖(词序 + 前后文);BERT 是深度双向 Transformer 预训练模型,能同时利用更深更广的上下文,并自带海量语料先验,但算力需求远高于 LSTM。
概念
KP 03.12
BERT:请一个"读过整个图书馆"的模型来微调
一句话 预训练学语言、微调学任务;[CLS] 位置的输出就是整句向量。
BERT 的架构是基于 Transformer 的多层双向 Encoder,所有层联合左右上下文做深度双向预训练,比单向语言模型的信息量更大。中文版 bert-base-chinese 是 12 层 Transformer、768 维隐藏层、约 1.1 亿参数。
它包含两个阶段:预训练(Pre-training) 在无标注语料上用两个自监督任务学通用语言表示——MLM(掩码语言模型,类似完形填空:80% 换成 [MASK]、10% 换随机词、10% 保持不变)与 NSP(下一句预测,50% 是真正的下一句);微调(Fine-tuning) 把预训练参数当初始化,用下游任务的标注数据训练全部参数。本课实验只微调 2 个 epoch 就能拿到强基线,靠的正是预训练积累的语义先验。
输入由三种 Embedding 相加而成:Token Embeddings(词向量,首位是 [CLS])、Segment Embeddings(区分上下句)、Position Embeddings(位置信息)。分类时用 BertForSequenceClassification 在顶部接一个 num_labels=4 的分类头,取 [CLS] 位置的输出映射到四类概率,用交叉熵微调——因为预训练时 [CLS] 就被训练成"汇总整句信息"的位置。
工程要点:truncation=True、padding=True、max_length=256;attention_mask 让注意力忽略填充位。
Trainer API:TrainingArguments + Trainer,一行 trainer.train() 完成多 epoch 训练。
国内镜像:HF_ENDPOINT='https://hf-mirror.com',必须在 import transformers 之前设置才生效。
代价:显存与训练时间最高;无 GPU 时 Trainer 自动回退 CPU,会很慢。
生活类比 像转学生:别人从零开始学四则运算(TextCNN / TextRNN 从零训练),这位转学生已经读完整个图书馆;你只需告诉他"这次考四选一",再补两节课就能上场。
易错 把 os.environ['HF_ENDPOINT'] 写在 import transformers 之后 → 镜像不生效、下载龟速;eval_strategy 与旧版 evaluation_strategy 拼写混用 → 报 TypeError;target_names 顺序与 num_labels 不一致 → 分类报告里类别名字错位。
10 秒自测 · 点开看答案
问题:为什么分类任务常用 [CLS] 位置的输出?
答案:[CLS] 位于句首、没有具体词义,预训练时被训练成汇总整句与句间关系的特殊位置,因此它的输出天然适合当整句向量接分类头。
实验
LAB 03.4
实验 4 · BERT 微调中文文本分类
难度 ★★★
对应 PPT P62 / P106–P111
train_bert.py
实验目的:理解"预训练 + 微调"这一现代 NLP 范式,会用 transformers 加载 bert-base-chinese 并通过 Trainer 完成四分类微调,最后把 BERT 与前三套方案放在同一张表里对比。
在 import 之前设置 HF_ENDPOINT='https://hf-mirror.com',通过国内镜像下载分词器与模型(首次较慢,之后走缓存)。
同口径划分数据(test_size=0.2、random_state=42、stratify),用 tokenizer(..., truncation=True, padding=True, max_length=256) 批量编码。
用自定义 BertDataset 把 encodings 与标签包成 Dataset,标签键名为 labels(Trainer 约定)。
加载 BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=4)。
配置 TrainingArguments(num_train_epochs=2, per_device_train_batch_size=8, eval_strategy='epoch'),交给 Trainer 训练。
评估:trainer.predict() 得到 (样本数, 4) 的得分,np.argmax(axis=1) 取类别,输出分类报告。
import os
os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com' # 必须在 import 前设置
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
# 截断 + 填充;attention_mask 会自动屏蔽 <PAD> 位
train_enc = tokenizer(train_texts, truncation=True, padding=True, max_length=256)
model = BertForSequenceClassification.from_pretrained(
'bert-base-chinese', num_labels=4) # 顶部换成 4 类分类头
args = TrainingArguments(
output_dir='./results',
num_train_epochs=2, # 预训练模型收敛快
per_device_train_batch_size=8, # BERT 显存大,batch 要小
eval_strategy='epoch') # 旧版写 evaluation_strategy
trainer = Trainer(model=model, args=args,
train_dataset=train_dataset, eval_dataset=val_dataset)
trainer.train()
pred = np.argmax(trainer.predict(val_dataset).predictions, axis=1)
预期结果 先通过镜像下载分词器与模型,完成 2 个 epoch 微调后输出「BERT 分类评估报告」。按指导书预期:BERT 通常取得四个实验中最高的四分类准确率,因为它在海量中文语料上预训练,微调只需"对接"四分类头;代价是显存占用与训练时间明显高于 TextCNN / TextRNN 与 TF-IDF 基线。若显存不足会 OOM,需要减小 batch 或 max_length。
常见坑 ① OOM:把 per_device_train_batch_size 从 8 降到 4,或把 max_length 从 256 降到 128。② 下载超时:镜像必须写在 import 之前;离线环境要提前把模型下到本地缓存。③ 无 GPU 时 Trainer 自动回退 CPU,训练极慢但能跑完,别误以为卡死。④ num_labels 与 label_map 长度不一致。
思考题 · 点开看参考要点
思考题:只微调 2 个 epoch,继续加 epoch 准确率会必然提升吗?
参考要点:不会必然提升。若验证集准确率停止上升而训练 loss 继续下降,就是过拟合信号,应通过减小学习率、加正则、早停(early stopping)来调控。
建议记录 四个实验做完,立刻整理一张对照表:方法 / 特征维度 / 是否用词序 / 训练耗时 / accuracy / macro-F1。期末复习时这张表比任何笔记都好用。
3.5 验收、踩坑与拓展作业
注意 本章所有"预期效果"都来自实验指导书的预期描述,是现象层面的经验,不是固定分数。你自己的运行结果才是指标,写报告时不要照抄任何示例数字。
公式
KP 03.13
Accuracy 会骗人:看 Precision、Recall、F1 与混淆矩阵
一句话 准确率只看整体对错;类别不均衡时,少数类会被"平均"掉。
先认识混淆矩阵(Confusion Matrix) :K 分类就是一张 K×K 的表,行是真实类别、列是预测类别,对角线是判对的,其余是各类误判。二分类时四个格子有专门名字:TP(真正)、FP(假正)、FN(假负)、TN(真负)。
四个指标都从这张表里长出来:Accuracy(准确率) 看整体判对比例;Precision(精确率) 问"被判成该类的样本里有多少真是该类";Recall(召回率) 问"该类真实样本里被找回了多少";F1 是两者的调和平均,对偏低的那一项特别敏感。
为什么不能只看准确率:假设四类里"健康"占 70%,模型把全部样本都判成健康,accuracy 仍有约 70% 看着不低,但另外三类的 recall 全是 0,模型其实什么也没学会。这时要看分类报告 里每一类的 P / R / F1,以及 macro avg (各类简单平均,给少数类同等权重)与 weighted avg (按样本数加权)。support 一列是该类真实样本数,看到某类 support 特别小,就要警惕指标不稳。
召回优先:漏报代价大——反诈预警、癌症筛查、安全隐患识别。
精确优先:误伤代价大——垃圾邮件拦截、内容审核、自动封禁。
定位问题:看混淆矩阵里哪两个类互相误判最多,再回头补数据或补特征。
生活类比 像撒网捕鱼:Precision 是"网里捞上来的有多少是目标鱼"(纯不纯),Recall 是"水里目标鱼有多少被网到"(全不全)。网眼太大,捞得多但不纯;网眼太小,纯度高但漏得多。
易错 只报一个 accuracy 就交报告:四类不均衡时它会被多数类主导。正确做法是同时给分类报告(每类 P / R / F1 + support)、macro-F1 与混淆矩阵,并说明哪一类最难分、为什么。
10 秒自测 · 点开看答案
问题:模型全判为占比 70% 的"健康"类,accuracy 与哪项指标会立刻暴露问题?
答案:其余三类的 recall 全为 0、macro-F1 会非常低;accuracy 看起来却接近 70%,所以只看准确率会被误导。
面试
KP 03.14
同一份语料,四种打法怎么选?
一句话 算力少、数据少用 TF-IDF;要词序用 CNN / RNN;要效果上 BERT。
把四个实验放在一起,差别其实只有三处:特征从哪来 (人工统计 vs 网络自动学)、有没有预训练先验 (从零训练 vs 带着海量语料知识来)、是否利用词序与上下文 (无 / 局部窗口 / 序列 / 全局双向)。按指导书的预期,准确率大致是 BERT 最高、TextCNN 与 TextRNN 高于 TF-IDF 基线,而 TextCNN 与 TextRNN 谁更好要看语料长度与显存预算——但具体数值一律以你自己的运行结果为准。
选型时先问四个问题:有没有 GPU?标注数据有多少?文本多长?要精度还是要延迟?TF-IDF + 线性模型几秒钟就能跑完,适合做基线和线上兜底;TextCNN 并行快、局部搭配敏感,适合短文本与高吞吐场景;TextRNN 擅长跨位置的否定、转折语义;BERT 精度最高,适合标注少但要效果、且显存足够的场景;若文本长达上千字,还要评估 max_length=256 截断带来的信息损失。
方案 文本表示 利用词序 预训练先验 算力需求 适合场景
TF-IDF + NB / LR 人工统计的 1–2 gram 权重 否(仅局部 n-gram) 无 极低,CPU 秒级 快速基线、数据少、无 GPU
TextCNN 字嵌入 + 一维卷积 局部窗口(2–4 字) 无,从零训练 低–中,可并行 短文本、高吞吐、关键短语决定类别
TextRNN 字嵌入 + 双向 LSTM 序列依赖(双向) 无,从零训练 中,顺序计算较慢 否定 / 转折 / 语序敏感的文本
BERT 微调 Transformer 深度双向编码 全局双向 + 位置编码 有,海量中文预训练 高,需 GPU 与大显存 追求精度、标注数据有限、显存够
生活类比 像修东西的四件工具:锤子(TF-IDF)随手能用,螺丝刀(TextCNN)专拧一类螺丝,电钻(TextRNN)能钻深孔,电动螺丝批(BERT)效率最高但要插电。不是越贵越合适,得看活儿有多大。
10 秒自测 · 点开看答案
问题:没有 GPU、标注数据只有几千条,先上哪个方案?
答案:先用 TF-IDF + 逻辑回归 / 线性 SVM 做基线,量小也稳、几秒出结果;确认特征和指标没问题后,再考虑 TextCNN 或 BERT 提升。
易错
KP 03.15
踩坑清单:从字符级到 BERT 的八个细节
一句话 字符级、padding、stratify、padding_idx、显存——八成的 bug 都在这五处。
下面这些坑几乎每个同学都会踩一遍,按"现象 → 原因 → 对策"记:
字符级 vs 词级 :analyzer='char' 免分词;改词级需 jieba + tokenizer 返回 list。两者特征空间不同,分数不能直接横比。
padding :max_len=256 截断 / 补齐,不足用 <PAD>;BERT 靠 attention_mask 屏蔽填充位。别把 PAD 当真实字统计词频。
测试集词表 :必须复用训练集 vocab(vocab=train_dataset.vocab),否则编码不一致、指标失效。
分层抽样 :stratify=label_id 保证四类占比一致;random_state=42 保证可复现。
embedding 的 padding_idx :nn.Embedding(..., padding_idx=0) 让 PAD 行不参与梯度更新;若改了 PAD 编号,这里要同步改。
batch_size :TextCNN / TextRNN 用 32,BERT 用 8(显存大);batch 太大直接 OOM,太小梯度噪声大、收敛慢。每个 epoch 的批数 = 训练集样本数 ÷ batch_size。
维度控制 :max_features=10000 截断 TF-IDF;想再降维就上卡方 / 互信息 / 信息增益筛特征。
BERT 专属 :max_length=256 控显存;镜像写在 import 之前;eval_strategy / evaluation_strategy 按版本二选一。
易错 预测结果全是同一类:多为语料不足或 load_data() 路径错误导致数据没正确加载。先打印 full_df['label'].value_counts() 看四类分布是否合理,再查标签映射与词表,不要一上来就改模型。
10 秒自测 · 点开看答案
问题:报 ModuleNotFoundError: No module named 'utils' 怎么办?
答案:train_*.py 必须与 utils.py 在同一目录,并在该目录下运行脚本(如 python train_tfidf.py)。
实验
HW 03.1
拓展作业 · 三项任务把四类方法吃透
一句话 作业不是重复实验,而是用"对比 + 消融 + 鲁棒性"三把尺子量出模型差异。
作业文档给了三项任务,分别对应实验 1、2、3 与实验 4 的代码,交付物是源代码 + 运行截图或输出文本 + 思考题回答。
作业一 · 特征粒度与分类器对比 :分别用字符级与词级(jieba)TF-IDF,观察特征维度与准确率变化;在朴素贝叶斯、逻辑回归基础上引入 LinearSVC 或 RandomForestClassifier;用 GridSearchCV 调逻辑回归 / SVM 的正则参数 C;指标用 Accuracy、Macro-Precision、Macro-Recall、Macro-F1,并做一张"特征粒度 × 分类器"的对比表。
作业二 · TextCNN / TextRNN 超参消融与可视化 :对比单向 LSTM 与双向 BiLSTM、num_layers = 1 / 2 / 3 的差异;每个 epoch 记录训练 loss 与验证 accuracy 并画曲线,判断是否过拟合;引入学习率衰减(ExponentialLR / CosineAnnealingLR)或早停,观察泛化变化;最后输出测试集混淆矩阵。
作业三 · BERT 层冻结与鲁棒性测试 :方案 A 全量微调,方案 B 冻结底部 6 层只训顶层 + 分类头,对比显存峰值、训练时间与准确率;尝试学习率 2e-5 / 5e-5 并启用 warmup;再向测试集注入噪声(同音字替换、删标点),比较 TF-IDF、TextCNN / TextRNN、BERT 在干净集与噪声集上的 Accuracy 跌幅百分比。
写报告时把"结论"和"证据"绑在一起:例如"冻结底层后训练时间下降、准确率变化很小",同时给出两组的准确率与耗时数字;没有实测就不要写数字。
# 作业一:GridSearchCV 调逻辑回归的正则强度 C
from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score, make_scorer
param_grid = {'C': [0.1, 1, 10]} # C 越小,正则越强
grid = GridSearchCV(
LogisticRegression(max_iter=1000),
param_grid,
cv=5, # 5 折交叉验证
scoring=make_scorer(f1_score, average='macro'), # 不均衡看 macro-F1
)
grid.fit(X_train_vec, y_train) # 只在训练集上搜索,测试集留到最终评估
print(grid.best_params_, grid.best_score_)
print(f1_score(y_test, grid.predict(X_test_vec), average='macro'))
易错 用测试集做网格搜索或选超参,等于把答案泄漏给模型,报告里的分数会虚高;正确做法是训练集内部做交叉验证选参,最后只在测试集上评估一次。
思考题 · 点开看参考要点
思考题:为什么作业要求用 macro-F1 而不是只看 accuracy?
参考要点:四类样本数可能不均衡,accuracy 会被多数类主导;macro-F1 对每一类同等加权,能暴露少数类被忽略的问题。
「文本分类第一步也是最重要的一步,是把整个文本编码成一个向量。」—— 第二章 PPT 小结(P116)
概念
KP 03.16
文本预处理五件事:清洗、去噪、繁简、全半角、停用词
一句话 同一个词只留一种写法,不携带信息的字先删掉,再谈特征。
拿到语料先做五步:清洗(去 HTML 标签、URL、多余空白)、去噪(表情、特殊符号、重复标点)、繁简统一(OpenCC 转简体)、全半角统一(NFKC 把「ABC」折成 ASCII)、去停用词(删「的、了、是」这类高频虚词)。前四步是「统一写法」,最后一步删掉不携带类别信息的词,让 TF-IDF 的维度更值钱。停用词表可用哈工大、百度等公开词表,也可按语料统计(补充)。
步骤 具体做法 不做会怎样
清洗 正则 / BeautifulSoup 去标签、链接 HTML 碎片混进词表,特征变脏
去噪 过滤表情、特殊符号、连续标点 维度膨胀,噪声词干扰权重
繁简 OpenCC 统一转简体(或繁体) 「學習」与「学习」被当成两个词
全半角 unicodedata.normalize('NFKC', s)「AI」与「AI」分裂成两维
停用词 用停用词表删除高频虚词 「的、了」白占权重与维度
注意 停用词对 TF-IDF 有效,但喂 BERT 时通常不删——要保留自然语序与位置信息,删词反而破坏句子(补充)。
10 秒自测 · 点开看答案
问题:为什么停用词对 TF-IDF 可以删,对 BERT 却要慎删?
答案:TF-IDF 按词统计,删掉高频虚词只降维、不伤语义;BERT 吃的是完整句子,删词会打断语序和位置信息。
概念
KP 03.17
jieba 词级 vs 字符级:分词粒度怎么改变 TF-IDF 矩阵?
一句话 词级特征少而语义整,字符级免分词但维度大、粒度粗。
字符级用 analyzer='char'、ngram_range=(1,2),特征是「人工」「工智」这类字与相邻两字;词级要先用 jieba.lcut 分词,再把 tokenizer=jieba.lcut 传给 TfidfVectorizer。同一份四分类语料,词级特征少一个量级、IDF 更可解释(「体育」是完整语义单元);字符级不依赖分词器、对新词更稳,但会把「体育」拆成「体」「育」,单字语义偏弱。词级还会被分词边界错误放大:一处切错,两个特征同时变脏。
易错 现象:改词级后报分词错误或特征对不上。原因:tokenizer 必须返回词列表(jieba.lcut 正好是 list),且要配 analyzer='word'。怎么办:固定数据划分与 random_state 再比;两套特征空间不同,准确率不能直接横比。
10 秒自测 · 点开看答案
问题:词级 TF-IDF 相对字符级,最直接的好处与代价是什么?
答案:好处是维度小、语义单元完整、IDF 更可解释;代价是依赖分词器,歧义切分与未登录词的错误会直接传进特征。
概念
KP 03.18
先划分再 fit:向量器偷看测试集就是数据泄漏
一句话 词表和 IDF 只能从训练集学,测试集只许 transform。
顺序只有一条:先 train_test_split(本课 8:2、random_state=42、按标签 stratify),再在训练集 fit_transform 向量器,最后对测试集只 transform。若先在全量语料上 fit,词表会混进测试集才有的词、IDF 也用了测试集统计,这就是数据泄漏(data leakage):离线分数虚高、上线回落。卡方筛选、重采样、标准化同理,都要放进训练集内部;调参只看验证集。记住:凡是需要「统计」的东西,都只能在训练集上算。
生活类比 像考前偷看了答案,模拟卷分数自然漂亮;真上考场就露馅。
易错 现象:离线 accuracy 很高、上线掉一大截。原因:向量器或特征选择在划分前 fit,测试集信息泄进训练。怎么办:用 Pipeline 把向量化与分类器绑在一起,交叉验证和最终评估都只对训练集 fit。
10 秒自测 · 点开看答案
问题:测试集为什么只能 transform、不能 fit_transform?
答案:fit 会按测试集重新学词表与 IDF,训练 / 测试特征空间错位,指标虚高且不可复现。
概念
KP 03.19
K 折交叉验证:小数据下比单次划分更稳的评估
一句话 训练集切 K 份轮流当验证,分数取平均,代价是训练 K 次。
K 折交叉验证(K-fold Cross Validation)把训练集均分成 K 份,每次留 1 份当验证、其余 K−1 份训练,重复 K 次后取平均。文本分类要用分层版 StratifiedKFold,保证每折四类比例一致,K 常取 5 或 10;它比一次 8:2 划分更稳,因为每个样本都当过一次验证样本。代价是训练 K 次:TF-IDF + 逻辑回归几乎无感,BERT 微调做 5 折就是 5 倍算力。K 越大评估越稳,但训练次数也越多(补充)。
10 秒自测 · 点开看答案
问题:交叉验证时,向量器可以在所有折的全体数据上 fit 一次吗?
答案:不能。每一折都要只在 K−1 份训练数据上 fit,否则验证折信息泄漏;用 Pipeline 包起来最省事。
公式
KP 03.20
类别不均衡:重采样、class_weight 与 Focal Loss 怎么选?
一句话 少数类不是噪声:先改权重和采样,再看 macro-F1 与每类召回。
四类样本数差得大时,模型会倾向多数类:全判「健康」也能有不错的 accuracy,但另外三类 recall 接近 0。三种对策:重采样(少数类过采样、多数类欠采样;SMOTE 在高维稀疏文本上要慎用,补充)、类别权重(class_weight='balanced',深度学习给 CrossEntropyLoss 传 weight)、Focal Loss(用 (1−pt )γ 压低易分样本的损失)。评估改看 macro-F1 与各类 recall。样本少时先调权重,样本足够再考虑 Focal Loss。
易错 现象:过采样后训练集准确率涨了,少数类 recall 没涨。原因:简单复制样本只增加重复记忆,没带来新信息。怎么办:优先类别权重 + 合适指标;要增强就做有信息量的增强(见数据增强卡)。
10 秒自测 · 点开看答案
问题:四类严重不均衡时,为什么不能只报 accuracy?
答案:多数类占比高时,全判多数类也能有高 accuracy,但少数类 recall 为 0;应同时报 macro-F1 与每类 recall。
概念
KP 03.21
混淆矩阵怎么读:四个格子与逐类错误定位
一句话 对角线判对,行看漏、列看错,最大的误判对就是改进点。
K 分类的混淆矩阵是 K×K 表:行是真实类别、列是预测类别,对角线判对、其余判错。对某一类 c 做 one-vs-rest:TP 是对角线,FP 是 c 列之和减 TP,FN 是 c 行之和减 TP,TN 是总数减前三项。行归一化得到召回,列归一化得到精确。报告之外一定要看最大的非对角格子:哪两类互相误判、错在边界还是标错。先看行和与列和,再挑最大的几个非对角格子。
真实 \ 预测(示例) 体育 教育 健康 旅游
体育 45 3 1 1
教育 2 44 2 2
健康 1 2 46 1
旅游 2 1 3 44
10 秒自测 · 点开看答案
问题:「教育」行有 2 个被判成体育、列有 2 个从健康误判进来,分别影响什么?
答案:行上的 2 个是 FN,拉低教育召回;列上的 2 个是 FP,拉低教育精确。
公式
KP 03.22
Macro / Micro / Weighted:分类报告里的三种平均怎么选?
一句话 macro 每类同权,micro 汇总所有格子,weighted 按样本数加权。
三个 avg 都在回答「多类分数怎么合成一个数」,区别在权重:Macro 对每类 P/R/F1 简单平均,每类同权,少数类差一点就掉分,最公平;Micro 先汇总所有类的 TP、FP、FN 再算一个 P/R/F1,单标签多分类时等于 accuracy;Weighted 按 support 加权,接近整体表现,但被多数类主导。想看少数类是否被牺牲用 macro,看整体水平用 weighted 或 micro(补充)。论文和比赛常同时报 macro 与 weighted,便于横向比较。
平均方式 怎么算 单标签多分类时等于 适用
Macro 每类指标简单平均 不被多数类主导的公平分 类别不均衡、关心少数类
Micro 先汇总 TP/FP/FN 再算 Accuracy 看整体正确率
Weighted 按各类 support 加权 接近 accuracy 的加权分 报告综合表现
10 秒自测 · 点开看答案
问题:单标签四分类里,micro-F1 等于什么?为什么?
答案:等于 accuracy。每个样本只属于一个类,micro 汇总后精确率、召回率都退化为「判对比例」。
实验
KP 03.23
TextCNN 调参:卷积核管看多宽,filter 数管看多少种模式
一句话 核尺寸看几个字,filter 数定容量,dropout 防过拟合。
本课默认 embed_dim=128、filter_sizes=[2,3,4]、num_filters=128、dropout 0.5。卷积核高度决定一次看几个连续字:2/3/4 对应 2–4 gram,短文本够用,加 5 能抓更长搭配但参数更多。num_filters 是每种核学多少种模式,越大容量越强、小语料越易过拟合;embed_dim 是字向量维度,指导书让你试 100 / 200;dropout 加在 384 维拼接特征上,语料小就加大、欠拟合就减小。调参时一次只动一个,其余固定,用验证集看变化。
超参 作用 调大的代价 本课值
filter_sizes 一次看几个字(n-gram 宽度) 更长搭配要更多数据 [2,3,4]
num_filters 每种核学多少种模式 参数涨、小语料过拟合 128
embed_dim 字向量维度、表达容量 参数量与显存上升 128
dropout 随机丢弃、抑制过拟合 太大导致欠拟合 0.5
易错 现象:训练 loss 一直降、验证准确率不涨。原因:filter 数 / embed_dim 相对语料太大,模型在背训练集。怎么办:先加大 dropout,再减 num_filters 或 embed_dim,最后才考虑加数据与增强。
10 秒自测 · 点开看答案
问题:把卷积核尺寸从 3 换成 5,一定更好吗?
答案:不一定。核越大看得越宽、能抓更长搭配,但参数更多、对短文本可能根本覆盖不到整句,要用验证集实测。
实验
KP 03.24
BERT 微调 OOM:max_length、batch、梯度累积与混合精度
一句话 显存大致跟 batch × 序列长度走,先降长度,再降 batch、上累积。
微调 bert-base-chinese 时,显存主要吃在激活值上,粗略正比于 batch_size × max_length。OOM 的降法有优先级:先把 max_length 从 256 降到 128(短文本够用),再降 per_device_train_batch_size(8→4→2);batch 太小梯度噪声大,可用梯度累积——每步只算小 batch,累积 N 步再更新,等效 batch 变大;再开混合精度(fp16 / bf16)把激活减半;仍不够就冻结底部若干层(补充,对应作业三)。显存够时优先保住 max_length,截断会直接丢信息。
易错 现象:开混合精度后 loss 变成 NaN。原因:fp16 表示范围小,梯度下溢。怎么办:用带 loss scaling 的自动混合精度(Trainer 的 fp16=True 默认处理),或改用 bf16。
10 秒自测 · 点开看答案
问题:batch 降到 2、gradient_accumulation_steps=4,单卡等效 batch 是多少?
答案:2×4=8,与原来 batch 8 接近,但每步激活显存只按 2 算,省下约四分之三。
实验
KP 03.25
文本数据增强四招:同义词替换、回译、随机删除与交换
一句话 不改变标签、只加在训练集:增强是给模型「换一种说法」的经验。
文本增强的目标是让模型见过同一类别的不同说法,同时不改变标签。常用四招来自 EDA:同义词替换(随机换掉若干词)、随机插入(插入同义词)、随机交换(交换两个词的位置)、随机删除(按概率删词);还有回译(中文→英→中,用机器翻译换句式)。中文同义词可借同义词词林等资源(补充)。铁律:只在训练集上做,验证 / 测试集保持原样,增强后要抽检标签没变。
生活类比 教小孩认猫,不只给一张正面照,还换角度、换光线;但考试卷子不能提前改题。
10 秒自测 · 点开看答案
问题:为什么增强只能加在训练集上?
答案:验证 / 测试集代表真实分布,增强会改变难度与数据分布,指标失去可比性,等于变相泄漏调参信息。
概念
KP 03.26
句对分类:STS、NLI 与文本匹配判的是两句话的关系
一句话 单句分类给一段文本贴标签,句对分类判两段文本之间的关系。
句对分类(pair classification)输入两段文本,输出它们的关系:STS 判语义相似度(回归 0–5 分)、NLI 判蕴含 / 矛盾 / 中立、匹配任务判是否相关。和单句分类比,输入是两个序列、标签描述关系,训练数据要成对构造并配负例。架构分双塔(分别编码再算余弦,可预先建索引)与交叉编码(拼接后送 BERT,更准但每对都要前向一次)(补充)。
任务 输入 → 输出 常用指标
单句分类 一段文本 → 一个类别 Accuracy / F1
STS 两句 → 0–5 相似度 Spearman / Pearson 相关
NLI 两句 → 蕴含 / 矛盾 / 中立 Accuracy
匹配任务 两句 → 相关 / 不相关 Recall@k、MRR
10 秒自测 · 点开看答案
问题:STS 为什么不直接报准确率?
答案:STS 输出的是连续相似度分数,属于回归任务;要看预测分与人工分的排序相关性,硬转成分类会丢掉分级信息。
概念
KP 03.27
多标签与层次分类:一条文本可以同时贴多个标签
一句话 多标签用 K 个独立 sigmoid 并行判断,不能用 softmax 互斥。
多标签分类(multi-label)允许一条文本同时命中多个标签,输出层每个标签一个独立 sigmoid、损失用 BCE;softmax 会让各类互相竞争、只保留最大项,于是永远只能输出一个标签。预测阈值按验证集逐类调,评估看样本级 subset accuracy(整个标签集合全对才算对)与标签级 micro / macro-F1。层次分类的标签有父子结构:可平铺成多标签,或逐层分类、用父类结果约束子类(补充)。
易错 用 softmax 加单标签交叉熵训练多标签:模型被迫单选,重合标签永远学不到。改成每个标签一个 sigmoid 配 BCE,允许一条文本同时输出多个 1。
10 秒自测 · 点开看答案
问题:为什么 subset accuracy 在多标签任务上很苛刻?
答案:它要求整个标签集合完全一致,漏一个或多一个都算全错;所以还要同时看标签级的 micro / macro-F1。
概念
KP 03.28
小样本与零样本:提示学习、数据增强、主动学习三条路
一句话 标注很少时,提示改写任务、增强补数据、主动学习挑样本。
小样本(few-shot)指每类只有几条到几十条标注,零样本(zero-shot)则一条下游标注都没有。三条路线:提示学习(prompt)把分类改写成完形填空——「这句话的情感是[MASK]」,比较「好 / 差」等标签词填入的概率;数据增强用同义替换、回译、模板或大模型合成扩充训练集,标签不能变;主动学习从无标注池挑模型最不确定的样本送人标。小样本评估方差大,要多种子重复并报均值(补充)。
易错 每类只有 5 条却只跑一次随机划分:换一组样本分数可能差十几个点。固定多种子、多次采样取平均,并同时报告波动范围。
10 秒自测 · 点开看答案
问题:零样本分类怎么不训练分类头也能分类?
答案:把任务改写成提示模板,比较各标签词填在 [MASK] 位置的概率,取最高者;靠的是预训练模型已有的语言知识。
公式
KP 03.29
分类模型上线:导出、量化、延迟与吞吐四道关
一句话 上线不只看准确率:导出、量化、延迟、吞吐四道关都要过。
上线先把训练态切成推理态:导出 ONNX / TorchScript,固定输入形状、去掉 dropout 与训练分支;量化把权重(静态量化还包括激活)压到 INT8,动态量化最省事、静态量化要校准集,掉点必须回归验证。延迟看端到端 p50 / p95 / p99,含分词与后处理;吞吐看 QPS,加大 batch 提吞吐但抬高尾延迟。再补上置信度校准、阈值与拒识、数据漂移监控(补充)。
10 秒自测 · 点开看答案
问题:为什么线上服务不一定用大 batch?
答案:大 batch 会堆高排队等待,单条尾延迟(p99)变差;要在吞吐和延迟之间按 SLO 折中,而不是只看平均值。
本章速查
任务 :输入变长文本,输出离散类别;本课语料四分类(体育 / 教育 / 健康 / 旅游)。
流水线 :文本 → 向量化 → 特征选择 → 分类器 → 评估,五步一站不能少。
BOW :只数词频、丢词序;「我 爱 上海」与「上海 爱 我」同向量。
TF-IDF :tf × log(N/(1+df));高频虚词降权,专属词加权。
字符级 n-gram :analyzer='char'、ngram_range=(1,2);免分词,代价是维度大、语义粒度粗。
特征选择 :卡方 χ² 越大越相关;互信息、信息增益同理,目的都是降维去噪。
朴素贝叶斯 :条件独立 + 拉普拉斯平滑 + 对数连加;快、稳、可解释。
逻辑回归 / SVM / 树 / 集成 :高维稀疏首选线性模型,树模型做对照。
TextCNN :一维卷积(核高 = 连续字数)+ 1-max 池化;提取局部 N-gram。
TextRNN :BiLSTM 末态拼接(hn[-2] + hn[-1])当整句向量。
BERT :预训练(MLM + NSP)+ 微调,[CLS] 接分类头,2 个 epoch 即可。
评估 :Accuracy / P / R / F1 + 混淆矩阵;不均衡时看 macro-F1 与各类 recall。
关键超参 :max_len 256、max_features 10000、embed_dim 128、hidden 128、batch 32(BERT 为 8)。
来源:第二章 PPT P49–P64;《HCIP-AI-自然语言处理-文本分类-实验指导书》;《文本分类实验作业文档》;代码 utils.py / train_tfidf.py / train_textcnn.py / train_textrnn.py / train_bert.py。
这一章回答三个问题:序列数据到底难在哪?循环神经网络(RNN)怎样把「记忆」接进网络?Seq2Seq 又怎样把一条只会读的 RNN 改造成一条会写的 RNN?学完你需要能:手写 RNN 前向五步、解释梯度消失与「弼马温」式的长距离依赖、画出训练期用教师强制、推理期用自回归的编码器-解码器结构。
6.1 序列数据:难在「顺序」二字
概念
KP 06.1
序列数据为什么难?先理解「时间步」
一句话 模型看句子不是一眼扫完,而是一个词元一个时间步地往前读。
图像是一整块矩阵,模型可以一次吃完;文本却是变长的序列,元素之间有先后。模型每处理一个词元(token)就算走过一个时间步(time step):处理「播放」是第 1 步,处理「周杰伦」是第 2 步,依此类推。同一个词出现在不同位置,模型看到的历史不同,它的含义也可能不同。
按输入输出的对应关系,序列任务大致分四类:一对一 (图像分类)、一对多 (看图说话)、多对一 (文本分类、情感分析)、多对多 (机器翻译、序列标注)。后三类都要处理「变长」和「顺序」,这正是 RNN 登场的理由。
生活类比 像银行柜台叫号:客户 A 办完才轮到客户 B,一笔一笔按顺序来。叫号机每喊一个号,就相当于模型往前走了一个时间步。
易错 把文本当成「词袋」直接求和再分类,顺序信息在这一步就丢了;时间步不是墙上的秒数,而是「处理到第几个位置」的计数。
10 秒自测 · 点开看答案
问题:「我爱自然语言处理」若切成「我 / 爱 / 自然语言处理」三个词元,处理「自然语言处理」是第几个时间步?
答案:第 3 个时间步。时间步数等于词元个数,与字符数无关。
概念
KP 06.2
相加、平均、全连接,为什么都不够用?
一句话 它们都像搅拌机:食材都进去了,顺序和主次却被搅没了。
要把一句话的词向量融合成一个「文本向量」,最朴素的做法是相加 、取平均 ,或者把所有向量拼起来套一个全连接网络。三者都错在同一个地方:把序列当成了无序集合。
忽略语序 :「我爱你」和「你爱我」逐词相加结果完全一样,意思却天差地别。
一视同仁 :「播放」和「《稻香》」决定意图,「的」几乎不携带分类信息;简单求和却给了它们同等话语权。
孤立处理 :全连接层虽然权重共享,但算「《稻香》」时只看它自己,完全看不见前面的「播放」「周杰伦」。
换句话说,这类方法能得到「句子里有哪些词」,却得不到「这些词怎么排布、谁修饰谁」。而自然语言的很多信息,恰恰藏在排布里。
生活类比 把整句话丢进搅拌机打成一锅糊:食材都在,但「先炒后煮」的顺序没了、主料配料的区别也没了——「先放糖后放盐」和「先放盐后放糖」打出来一模一样。
10 秒自测 · 点开看答案
问题:为什么「我爱你」和「你爱我」的平均池化向量完全相同?
答案:平均与求和不关心元素位置,交换顺序结果不变;文本向量相同,分类器自然无法区分两句话。
概念
KP 06.3
CNN 的固定感受野:看得近,也看不全
一句话 卷积核大小写死,等于给所有句子配同一双固定长度的筷子。
把图像里的卷积神经网络(CNN)搬到文本上:用一维卷积核滑过句子,捕捉「的《稻香》」这类局部搭配,效果类似 n-gram。问题在于感受野(receptive field)是固定的 :窗口大小为 3,就只能看到相邻 3 个词。
堆多层卷积可以扩大视野,但仍有麻烦:其一,远距离信息要经过多次压缩与非线性,容易丢;其二,你无法为所有句子预设一个「最佳窗口」——短句 3 个词够用,长句的关键线索可能隔了 20 个词。
生活类比 拿一双长 20 厘米的筷子夹火锅,只够得着锅边那一圈;换成加长筷子能远一点,可你永远不知道该为这顿火锅配多长的筷子——万一今天点的是巨型鸳鸯锅呢?
10 秒自测 · 点开看答案
问题:把卷积核从 3 扩大到 7,能根治长距离依赖吗?
答案:不能。窗口再大仍是固定窗口,而句子长度不固定;更深堆叠还会稀释远距离信息。根治要靠能按需传递记忆的模型。
6.2 RNN:把「记忆」接进网络
概念
KP 06.4
RNN 的核心思想:带着旧笔记见新词
一句话 新记忆=当前输入的一份变换+上一步记忆的一份变换,再过 tanh。
循环神经网络(RNN,Recurrent Neural Network)给全连接网络加了一条「记忆通道」:处理第 t 个词元时,它既接收当前输入 x_t,也接收上一步传下来的隐藏状态(hidden state) h_{t-1}。两路信息各做一次线性变换后相加,再过激活函数 tanh,就得到新的记忆 h_t。
可以把隐藏状态理解成「到目前为止读到的内容摘要」:h_0 通常初始化为全零向量,表示还没读任何词;每读一个词,摘要就更新一次,并继续传给下一步。走到最后一步的 h_T,就是整句话的定长向量表示。
生活类比 像一位开会做纪要的秘书:每进来一个新议题(当前输入),他不是从零写起,而是先翻上一页纪要(旧记忆),把新内容和旧摘要合在一起,再写下新的一页。会议开多久,就一页一页记下去。
易错 隐藏状态既是「记忆」又是「每个时间步的输出」;别把最后一步的 h_T 与「下一个词的概率分布」混为一谈——h_T 还要过分类层或输出层才有意义。
10 秒自测 · 点开看答案
问题:RNN 在一个时间步里有几路输入?分别是什么?
答案:两路。当前词元向量 x_t 与上一步隐藏状态 h_{t-1};二者线性变换后相加,过 tanh 得到 h_t。
概念
KP 06.5
权重共享:一套「记笔记的方法」用到底
一句话 所有时间步共用同一套 W_x、W_h,句子再长参数量也不变。
RNN 最省参数的设计是权重共享 :无论处理第 1 个还是第 100 个时间步,用的都是同一套输入权重 W_x 和循环权重 W_h。因此参数量只与词向量维度 E、隐藏维度 H 有关,与序列长度 T 无关 。
单层单向 RNN 的参数量约为 E×H + H×H + H。以 E=128、H=64 为例:128×64 + 64×64 + 64 = 12352 个参数。如果按位置各开一套参数,句子一长参数就爆炸;权重共享还顺带带来长度泛化——训练见过 10 个词,推理也能处理 15 个词。
代价是:同一套变换反复使用,也让梯度在时间上反复相乘,这正是后面梯度消失/爆炸的根源。
生活类比 不管会议开 10 分钟还是 3 小时,秘书用的都是同一套速记符号、同一本笔记本的格式;不会给第 5 个议题配一个新秘书、换一套笔记法则,否则每加一个词就要多养一个人。
10 秒自测 · 点开看答案
问题:句子从 10 个词变成 100 个词,单层 RNN 参数量会变成 10 倍吗?
答案:不会。权重共享,参数量与时间步数 T 无关;变长的只是计算图展开的步数。
概念
KP 06.6
文本分类流水线:一条句子怎样变成「定长摘要」
一句话 分词 → 查 ID → 词嵌入 → RNN 逐词处理 → 末状态进分类器。
把一句话送进 RNN 做文本分类,标准流水线是四步:分词 (切成词元)→ 查 ID (词元映射为整数)→ 词嵌入 (用 ID 查表得到 E 维向量)→ RNN 逐词处理 ,最后把末态 h_T 交给全连接分类层。
以「播放 周杰伦 的 《稻香》」为例:4 个词元、每个 128 维,隐藏维度 64。RNN 走完 4 个时间步后,h_4 已融入整句信息;分类层只需回答这句话属于「音乐播放」还是「天气查询」。变长句子因此被压成定长向量,同时顺序信息全程被保留。
注意与序列标注 的区别:文本分类只用最后一个 h_T;分词、词性标注、命名实体识别要用每个时间步 的 h_t,各接一个分类头,给每个位置打标签。
# test-1.py:分词 → 查 ID → 查词向量表,得到 (1, 4, 128) 的输入
vocab = {"播放": 0, "周杰伦": 1, "的": 2, "《稻香》": 3}
tokens = ["播放", "周杰伦", "的", "《稻香》"]
ids = [vocab[t] for t in tokens] # 1) 词元 -> 整数 ID
E = 128
emb_table = np.random.rand(len(vocab), E) # 2) 词嵌入表(真实训练用 nn.Embedding)
x = emb_table[ids][None].astype(np.float32) # 3) 取词向量,补 batch 维 -> (1, 4, 128)
# 4) 送入 RNN 逐时间步计算;最后一步的 h_T 交给分类层
生活类比 像客服中心的分诊台:客服不可能把客户的话「整体闻一遍」,只能逐字听、随手记;听到最后,手里那张便签(最终记忆)写着「此人是想点歌」,往分类员手里一递就完成归类。
易错 一个 batch 里句子长短不一时,不能统一取 out[:, -1]——短句的最后一个位置是 PAD;应按真实长度取最后有效步,或使用 pack_padded_sequence。
10 秒自测 · 点开看答案
问题:文本分类与序列标注在使用 RNN 输出时,最大区别是什么?
答案:分类只取最后一步 h_T,输出一个标签;序列标注取每个时间步的 h_t,逐位置输出标签。
概念
KP 06.7
Type 与 Token:同一个词,为什么有两副面孔
一句话 词嵌入是字典词条(Type),RNN 隐藏态是上下文实例(Token)。
词嵌入(Word2Vec、GloVe)是静态 的:同一个词在任何句子里都拿到同一个向量。语言学把这种抽象词条叫 Type(类型) ,相当于字典里的一个条目。
RNN 的隐藏状态是动态 的:同一个词在不同前文下得到不同的 h_t,这是 Token(实例) ——具体位置、具体上下文里的这一次出现。所以「苹果」在「来两斤苹果」和「苹果又跌了」里是 2 个 Token、1 个 Type。
把动态词向量做成通用范式的是 ELMo:用双向 LSTM 在大规模语料上预训练,再把各层隐藏状态组合成下游任务的词表示。机制由 RNN 提供,范式由 ELMo 普及。
生活类比 身份证上只有一个名字(Type),但同一个人在公司是员工、在家是父亲、在球场上是对手——不同场景下是三个不同的「角色实例」(Token)。
易错 这里的 Token 指「实例」,不是分词后的「词元」。考试里看到「Type vs Token」要答「抽象类型 vs 具体出现」,别答成「词 vs 子词」。
10 秒自测 · 点开看答案
问题:「黑神话」在一段话里出现两次,是几个 Type、几个 Token?
答案:1 个 Type、2 个 Token。两次出现的前文不同,RNN 给出的隐藏状态也不同。
概念
KP 06.8
Elman 的发现:不教语法,也能长出语法
一句话 只让它猜下一个词,隐藏状态自己长出了词性与句法分区。
1990 年,Jeffrey Elman 让 RNN 只做一件事——预测下一个词 ,不给任何词性、句法规则标注。训练完成后观察隐藏状态空间,发现它自发组织出了层级结构 :动词和名词各占一块区域;名词内部,有生命的与无生命的又分开;甚至同一个词(如 Boy)当主语和当宾语时,表示也各自聚类。
原因不神秘:要想把下一个词猜准,模型必须把「这句话现在讲到哪、前面是什么结构」编码进隐藏状态。语法结构不是被教出来的,而是被「猜下一个词」这个任务逼出来的副产品 。这也是自监督预训练最早的思想雏形。
# RNN.py:字符级语言模型——输入与目标只差一位
inputs = tensor_data[:-1].unsqueeze(0) # 输入:A r t i ...
targets = tensor_data[1:].unsqueeze(0) # 目标:r t i f ...
for epoch in range(EPOCHS):
hidden = model.init_hidden() # 每个 epoch 把记忆清零
optimizer.zero_grad()
output, hidden = model(inputs, hidden)
loss = criterion(output.squeeze(0), targets.squeeze(0))
loss.backward()
optimizer.step()
生活类比 像一位从没学过分类学的图书管理员,规矩只有一条:猜下一本书是什么。猜得多了,他闭着眼也能把书架分出区——故事书一区、工具书一区;工具书里菜谱和地图又各一区。没人教他,是「猜下一条」逼出来的。
易错 别以为这个实验用了语法标注。「预测下一个词」是自监督任务,标签就藏在原始文本里;隐藏状态的聚类是涌现现象,不是显式约束。
10 秒自测 · 点开看答案
问题:Elman 的 RNN 没有被教过语法,为什么隐藏状态里会出现名词/动词分区?
答案:为了预测下一个词,模型必须隐式编码前文的语法角色与搭配;预测任务迫使它形成有用的内部表示。
代码
KP 06.9
手写 RNN 的五步套路
一句话 清零 → 逐帧 → 融合 → 传状态 → 收集每一步输出。
不看框架,RNN 前向只有五步:
初始化 :造一个全零向量当空白记忆 h_0,每个序列开工前统一清零。
逐帧处理 :按时间步顺序遍历序列,取出当前词向量 x_t。
核心计算 :x_t 与旧记忆各做一次线性变换,相加后过 tanh,得到新记忆。
状态更新 :把新记忆赋给「旧记忆」变量,完成循环传递。
结果保存 :把每一步的 h_t 存起来,沿时间轴堆成 (B, T, H) 的输出张量。
注意最后一步的 h_T 与输出序列的最后一片 y[:, -1] 是同一个东西(单层情况),一个是「摘要」,一个是「该位置的输出表示」。
def manual_rnn_numpy(x_np, U_np, W_np):
B, T, _ = x_np.shape
h_prev = np.zeros((B, H), dtype=np.float32) # 第 1 步:零记忆
steps = []
for t in range(T): # 第 2 步:逐时间步
x_t = x_np[:, t, :] # 当前输入 (B, E)
# 第 3 步:旧记忆 + 新输入,过 tanh「调节阀」
h_t = np.tanh(x_t @ U_np + h_prev @ W_np)
steps.append(h_t)
h_prev = h_t # 第 4 步:状态前移
outputs = np.stack(steps, axis=1) # 第 5 步:(B, T, H)
return outputs, h_prev
生活类比 像复刻一道家传菜:先洗净空盘(零向量)→ 按菜谱一味一味下料(逐时间步)→ 每下一味都尝尝当前味道(核心计算)→ 把锅里的现状记在心里,作为下一味的判断依据(状态更新)→ 每一步拍张照留念(结果保存)。
易错 训练时每个 batch、每条新序列都要把 h_0 重新清零;把上一条序列的末态带进下一条,等于让模型「串味」,两条实现也对不上。
10 秒自测 · 点开看答案
问题:输入 (B, T, E) 经过手写 RNN 后,输出张量与最终隐藏态分别是什么形状?
答案:输出 (B, T, H),最终隐藏态 (B, H);最后一步输出 y[:, -1] 与 h_T 相等。
代码
KP 06.10
手写版与 nn.RNN 的数值对齐:框架不是黑箱
一句话 同权重、同口径、同初始态,两条实现只应差浮点误差。
对齐验证的做法:用同一组 U、W 和同一份输入,分别跑 NumPy 手写版与 PyTorch 的 nn.RNN,逐元素比较。要点有四个:权重口径 ——nn.RNN 的 weight_ih_l0 形状是 (H, E),手写 U 是 (E, H),拷入时要转置 U.T;无偏置 ——bias=False 才与手写公式同口径;batch_first=True ——输入输出都是 (B, T, ·);h_0 一致 ——两边都用全零。
验证三条断言:逐步输出一致、最终隐藏态一致、最后一步输出等于最终隐藏态。因为浮点累加顺序不同,差异约 1e-6 量级,所以容差用 atol=1e-5;若收紧到 1e-12,会把正常浮点误差误判成实现错误。
rnn = nn.RNN(input_size=E, hidden_size=H, num_layers=1,
nonlinearity="tanh", bias=False,
batch_first=True, bidirectional=False)
with torch.no_grad():
rnn.weight_ih_l0.copy_(U.T) # 框架的输入权重是 (H, E),故转置
rnn.weight_hh_l0.copy_(W.T) # 循环权重 (H, H) 同样转置
y, h_n = rnn(x) # y: (B, T, H),h_n: (1, B, H)
# 三条对齐断言:逐步输出、最终隐藏、最后一步输出 == 最终隐藏
assert torch.allclose(torch.from_numpy(out_np), y, atol=1e-5)
assert torch.allclose(torch.from_numpy(h_np), h_n.squeeze(0), atol=1e-5)
assert torch.allclose(y[:, -1], h_n.squeeze(0), atol=1e-5)
生活类比 同一道菜按两个渠道做出来对暗号:你按家传菜谱做一份,中央厨房按标准化流程做一份,端上桌盲品,人人说「一个味儿」。这说明你的理解没跑偏,框架也确实照这套公式执行。
易错 对齐失败先查三件事:权重是否转置、是否忘了 batch_first、h_0 是否随机初始化;再看框架是否悄悄带了 bias。都不是,才去怀疑公式。
10 秒自测 · 点开看答案
问题:为什么对齐验证用 atol=1e-5,而不是 1e-12?
答案:两条路径浮点累加顺序不同,结果本就相差约 1e-6;阈值过严会把正常误差误判为 bug。
6.3 训练、遗忘与双向视角
公式
KP 06.11
BPTT:把循环摊开成共享权重的深层网络
一句话 总损失是各时间步之和,梯度沿时间累加回序列开头。
RNN 的训练叫随时间反向传播(BPTT,Backpropagation Through Time) :把沿时间的循环按计算图展开,看成一个「每一层都共享同一套权重」的深层前馈网络,然后在上面跑标准反向传播。
总损失是所有时间步损失之和。某个时间步的损失要追究责任时,因为 h_t 依赖前面所有步,梯度必须沿着时间一路倒退回序列开头 ,把每个时间步「贡献的锅」累加起来。所以共享权重的梯度是求和,不是每一步各算各的。
代价是:展开图要保留所有中间状态,序列越长显存/内存开销越大;超长序列常用截断 BPTT(只回传最近 k 步,补充)。
生活类比 像考完试从最后一题倒推查错因:总分掉了 10 分,不一定是最后一道题的锅,可能是第 3 题的概念错误一路带崩了后面 5 道题。你得逆着往第一题翻,把每一步「该背多少锅」累加起来。
10 秒自测 · 点开看答案
问题:BPTT 里 W_h 的梯度,是对各时间步分别求导后相加,还是只对最后一步求导?
答案:相加。每一步的 h_t 都依赖 h_{t-1},所有时间步的损失都会通过共享的 W_h 回传。
公式
KP 06.12
梯度消失与梯度爆炸:连乘出来的两种事故
一句话 梯度是连乘出来的:因子普遍小于 1 就消失,大于 1 就爆炸。
倒带追责时,梯度要穿过一路的导数矩阵连乘 。每个因子大致由循环权重 W_h 与 tanh 的导数组成;tanh 的导数不超过 1,所以因子的大小主要由 W_h 决定。
梯度消失 :因子普遍小于 1,连乘后指数级衰减趋近 0——遥远过去的错误「喊冤没人听见」,模型学不到长距离依赖。
梯度爆炸 :因子普遍大于 1,连乘后指数级膨胀成 Inf/NaN——训练直接崩掉。这个相对好治:梯度裁剪 ,梯度范数超过阈值就强行缩放回去。
生活类比 像 100 人排队的传话游戏:规则是「每传一人音量减半」,传到队尾早就没声了,这是梯度消失;换成「每传一人音量翻倍」,队尾听到的是炸耳尖叫,这是梯度爆炸。梯度裁剪像给话筒设音量上限——尖叫治好了,但「听不见」的毛病还在。
loss.backward()
# 梯度裁剪:所有参数梯度的整体范数超过 5.0 就按比例缩回
# RNN / LSTM 系列几乎必备,主要防梯度爆炸
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
optimizer.step()
易错 梯度裁剪只治爆炸,不治消失。消失了要做的是换门控结构(LSTM/GRU)、用残差/注意力,或换更好的初始化,而不是继续调裁剪阈值。
10 秒自测 · 点开看答案
问题:梯度消失与梯度爆炸,哪一个更容易用工程手段缓解?为什么?
答案:爆炸。梯度是显式数值,检测范数后按比例缩放即可;消失是信息在连乘中衰减为 0,已经丢了,裁剪救不回来。
概念
KP 06.13
长距离依赖:为什么「弼马温」传不到结尾
一句话 隔得越远,梯度越淡;模型天然偏爱最近的信息。
经典例子:孙悟空初到天庭被玉帝封为「弼马温」——一个低微官职。五百年后,有神仙旧事重提,仍用这个官职称呼他,依然是在嘲讽。要理解结尾的「嘲讽」,模型必须关联到句子最开头的「弼马温是低微官职」。可两者隔了整段叙述,梯度从结尾倒带回来时已经衰减到接近 0,这个关键依赖就丢了。
换个视角,从正向传播 看是同一个病:每一步的新输入和循环权重都在稀释、覆盖旧记忆。时间步一多,序列最初的信息所剩无几——两个开头不同、后面完全相同的句子,最终记忆可能几乎没差别。模型「遗忘」了最初的差异,天然偏向近期信息 ,这叫近期偏置。
所以长距离依赖要从两头解释:反向传播时梯度消失,正向传播时记忆被覆盖。真正精巧的解法是带门控的结构,再往后是注意力机制。
生活类比 像追一部隔了 30 集的电视剧:第 2 集主角被羞辱过,第 32 集一句「您还记得当年啊」的潜台词,老观众秒懂,新观众一脸懵——中间 30 集的铺垫在记忆里早被冲刷干净了。
10 秒自测 · 点开看答案
问题:请从反向与正向两个视角,各用一句话解释「弼马温」的关联为什么学不到。
答案:反向看,梯度连乘后衰减为 0,开头的信息传不回来;正向看,每一步都在稀释旧记忆,开头信息被后来的词覆盖。
概念
KP 06.14
BiRNN:两个人从两头读同一卷竹简
一句话 正向、反向两条独立 RNN,每一步输出拼接后一起训练。
单向 RNN 在算第 t 个词时,只能看到它自己和它前面的信息。但很多任务里,一个词的含义还取决于后面的词:读到「苹果味道不错」,后半句才让你确定这是水果;换成「苹果股票大涨」,那就是公司。
双向循环神经网络(BiRNN)就是两个完全独立的 RNN 叠在一起:一个正着读(从左到右)得到一串正向记忆,一个倒着读(从右到左)得到一串反向记忆。每一步的最终输出,是把这一步的正、反两份记忆拼接 起来,维度从 H 变成 2H。两个方向各自拥有独立权重,但在同一个损失函数下同时训练 ,协同优化。
它常被用作编码器:命名实体识别、词性标注、句子表示都希望每个位置同时拥有左右上下文。但解码器不能用它,原因见下一张卡。
生活类比 像两个人从两头读同一卷竹简:甲从头读到尾,乙从尾读到头。读到中间某一支竹简时,甲说「上文讲的是出征」,乙说「下文讲的是凯旋」——两人的话拼在一起,这一支简的完整含义才浮出来。
10 秒自测 · 点开看答案
问题:BiRNN 在每个位置输出的维度是多少?两个方向的权重共享吗?
答案:维度是 2H(正向 H 与反向 H 拼接);两个方向权重各自独立,只共享同一个损失函数。
概念
KP 06.15
BiRNN 的能耐与短板:能看全,但不能实时
一句话 前后文都能用;代价是要等整句读完,不能实时生成。
能耐 :每个位置同时拥有左侧与右侧上下文,对「一词多义」和边界判断特别有用,所以命名实体识别、词性标注、句子编码里常见双向结构。
短板一 · 忘事没根治 :竹简两头各派一个记性差的人,忘事的毛病一个没少,只是忘的方向相反。梯度问题、长距离依赖问题仍在,BiRNN 不是解药。
短板二 · 违反因果性 :想用后文信息,就得把整句话听完才能开口。所以它不能做语言模型、不能做 Seq2Seq 的解码器,也没法给直播做「零延迟」实时字幕——必须等一句话说完。此外计算量约翻倍,也是实际成本。
生活类比 像同声传译必须等发言人把整句说完才敢开口:听懂了结尾,却已经晚了一步。做翻译的编码器可以「先听全」,做生成时只能单向往前写。
易错 把 BiRNN 塞进 Seq2Seq 解码器是经典错误:解码第 t 个词时,后面的词还没生成,哪来的「反向信息」?编码器可以双向,解码器必须单向(或因果掩码)。
10 秒自测 · 点开看答案
问题:为什么 BiRNN 不适合做实时生成任务?
答案:它需要看到完整序列才能算出反向隐藏状态;生成时未来词尚未产生,无法满足因果性。
6.4 门控升级:LSTM 与 GRU(补充)
概念
KP 06.16
LSTM:给记忆装三个门(补充)
一句话 遗忘门决定丢什么,输入门决定记什么,输出门决定露什么。
长短期记忆网络(LSTM,Long Short-Term Memory)在普通 RNN 之外引入一条专门的细胞状态(cell state) c_t,像一条传送带,负责长期保存信息;再用三个门(gate)控制信息进出。门由 Sigmoid 输出 0~1 的开关量,0 表示全关,1 表示全开。
遗忘门 f_t:决定旧细胞状态 c_{t-1} 保留多少。
输入门 i_t:决定新候选记忆写入多少。
输出门 o_t:决定细胞状态有多少暴露成当前隐藏状态 h_t。
因此 LSTM 有 h 和 c 两个状态,编码器交出的上下文也是 (h_n, c_n) 这一对。
生活类比 像一本带三个开关的会议纪要:旧页要不要撕(遗忘门)、新议题写不写进去(输入门)、这一页要不要念给外面听(输出门)。三者分开控制,书记员就不必每来一个议题都把整本笔记重写一遍。
易错 LSTM 的状态是 (h, c) 两个张量,PyTorch 的 nn.LSTM 返回 h_n 与 c_n;传给解码器时只传 h、漏掉 c,状态就不完整。
10 秒自测 · 点开看答案
问题:LSTM 的遗忘门控制的是什么?
答案:控制旧细胞状态 c_{t-1} 有多少保留到 c_t;它决定「过去的信息要忘掉多少」。
概念
KP 06.17
GRU:两扇门就够用(补充)
门控循环单元(GRU,Gated Recurrent Unit)把 LSTM 的细胞状态与隐藏状态合并成一个 h,门也减到两个:
更新门 z_t:调新状态里「保留多少旧记忆、接受多少新候选」。
重置门 r_t:算候选记忆时,决定参考多少旧记忆。
参数量约为 LSTM 的 3/4,结构更简单、训练更快,在很多任务上与 LSTM 效果相当。代价是它没有独立的细胞状态,长期记忆的控制不如 LSTM 直白。
生活类比 像老汤续锅:更新门决定这锅汤里加多少新汤、留多少老汤;重置门决定尝新料时还要不要参考旧汤底的味道。两个旋钮一调,就不必每次都倒掉重熬。
10 秒自测 · 点开看答案
问题:GRU 为什么比 LSTM 参数少?
答案:它只有更新门与重置门两套门参数,且不再单独维护细胞状态;LSTM 有三门 + 细胞状态。
概念
KP 06.18
门控为什么能缓解梯度消失(补充)
一句话 门控把连乘换成加法:旧记忆可以近乎原样地往下传。
普通 RNN 的 h_t 每一步都要过矩阵乘法和 tanh,梯度只能靠「一路连乘」传回去,很容易衰减。LSTM 的细胞状态更新是加法 :c_t = f_t ⊙ c_{t-1} + i_t ⊙ c̃_t。当遗忘门接近 1 时,c_{t-1} 几乎原封不动地进入 c_t,梯度沿这条加法通道也能近乎原样回传,不再被反复压缩。
GRU 的 h_t = (1 - z_t) ⊙ h_{t-1} + z_t ⊙ h̃_t 同理:更新门接近 0 时,旧状态近似恒等映射,梯度有一条「高速公路」。门控还让网络学会在需要时保留、不需要时清空,比固定权重的蛮力连乘灵活得多。
注意措辞:门控是缓解 而不是根治。极长依赖、超长文档仍然吃力,这也解释了后来注意力机制与 Transformer 为什么会成为主线。
生活类比 普通 RNN 像每一站都要把整封信念一遍再手抄一遍,抄到最后字迹全糊;LSTM 像给重要内容开了条存档传送带,只要不按下「删除」,原件就一直在,不必每站重抄。
10 秒自测 · 点开看答案
问题:从公式上看,LSTM 缓解梯度消失的关键在哪里?
答案:细胞状态采用加法更新 c_t = f_t ⊙ c_{t-1} + …;遗忘门接近 1 时形成近似恒等通路,梯度不必反复穿过矩阵乘法与 tanh。
6.5 Seq2Seq:从读到写
概念
KP 06.19
Seq2Seq:Encoder 负责读,Decoder 负责写
一句话 编码器把源句压成 C,解码器拿 C 当起点逐词写出目标句。
文本分类是「多对一」,翻译、摘要、对话却是「多对多」:输入和输出都是不定长序列,而且长度不对应。「我爱人工智能」3 个词,译成英文 "I love artificial intelligence" 是 4 个词。2014 年提出的 Seq2Seq(Sequence-to-Sequence) 用编码器-解码器(Encoder-Decoder)框架统一解决这类序列转换。
编码器 是一条 RNN/LSTM/GRU,逐词读入源序列,读完后的最终状态就是上下文向量 C ;用双向结构时每个位置的表示更完整,也可以把所有时间步做池化或拼接。解码器 是另一条 RNN,用 C 初始化状态,从起始符 开始逐词生成,每一步把自己的输出喂回下一步,直到结束符 或达到最大长度。
它和自编码器(Autoencoder)的壳一样、目标不同:自编码器要求「输出 ≈ 输入」,用来压缩与还原;Seq2Seq 要求生成一个与输入语义相关的全新序列 ,是条件语言模型:p(y | x) = ∏ p(y_t | y_{<t}, C)。
生活类比 像两棒接力:第一棒(编码器)把整段原文读完,把「全句语义概要」这根接力棒交出去;第二棒(解码器)接棒后,一个词一个词地朝终点写,不能回头改已经写下的内容。
易错 C 是编码器最后一步的状态,不是所有输出的平均;LSTM 版 C 是 (h_T, c_T) 一对,只拿 h 会丢信息。
10 秒自测 · 点开看答案
问题:Seq2Seq 的上下文向量 C 从哪里来?
答案:编码器读完整条源序列后的最终隐藏状态(LSTM 还包含细胞状态),作为解码器的初始信息。
概念
KP 06.20
信息瓶颈:全书的细节,一句话怎么装得下
一句话 输入再长都压进同一个定长 C,长句必然漏信息。
Seq2Seq 的硬伤:编码器与解码器之间唯一的桥梁,是一个固定长度 的上下文向量 C。输入再长,都得压进这一个向量——句子一长,开头的关键信息就可能被挤掉;而编码器自身的长距离依赖问题,还会加剧 瓶颈。
工程上有两种用 C 的方式:方式一 ,把 C 当解码器的初始状态,符合「先理解、再动笔」,但解码器全程只在这一刻吃一口老本,长输出里信息会被逐步稀释;方式二 ,不动初始状态,把 C 与每个时间步的词嵌入拼接或相加后输入,每步都提醒「全局主题」,更抗遗忘,但喂的永远是同一个静态 C,不知道「写这个词时该重点看输入的哪部分」。
两种方式都没根治瓶颈,而「动态地回头看输入」正是注意力机制的契机。
方式一:C 当初始状态 经典做法,先理解再动笔;只喂一次,长输出容易忘。
方式二:C 每步都喂 每步提醒全局主题,更抗遗忘;仍是静态向量,不会对齐。
生活类比 像让一个人把一篇长文的所有细节总结成一句话,再只凭这句话复述原文——必然丢信息;偏偏这个人还「隔 30 集就忘前两集剧情」,两种毛病叠加,长句翻译自然丢三落四。
10 秒自测 · 点开看答案
问题:把 C 每步都拼到解码器输入,能根治信息瓶颈吗?
答案:不能。每步喂的仍是同一个静态 C,只能抗遗忘;它没有机制在生成某个词时动态关注源句的对应部分。
代码
KP 06.21
训练三件事:教师强制、错位目标、忽略 PAD
一句话 喂真值、目标错开一位、PAD 位置不算损失。
教师强制(Teacher Forcing) :训练时解码器第 t 步的输入不用自己的预测,而是直接用数据集里的真实标签。每步都从正确历史出发,收敛稳、速度快;但推理时没有标准答案可喂,这种「训练见真值、推理见自己的错」的落差叫曝光偏差。实践常用 0.5~0.8 的混合比例,偶尔让模型吃自己的预测,提前适应推理环境。
错位目标(shifted targets) :解码器输入是「起始符 + 目标前 M-1 个词」,监督目标是「目标后 M 个词」,两者错开一位。这样第 t 步的输入是 y_{t-1},要预测的正好是 y_t,模型不会「偷看答案」。
Padding 与 mask :一个 batch 里句子长短不一,要用 PAD 补齐;计算交叉熵时用 ignore_index 忽略 PAD,否则空白位置也会产生无意义梯度。损失为各有效位置交叉熵之和(或平均)。
# 数据:目标序列右移一位作解码器输入,左移一位作监督目标
tgt = encode(target) # <SOS> y1 ... yM <EOS> <PAD>...
dec_in = tgt[:-1] # 解码器输入:<SOS> y1 ... yM <EOS>...
dec_tgt = tgt[1:] # 监督目标: y1 ... yM <EOS> <PAD>...
# 训练循环:教师强制决定下一步喂真值还是喂自己的预测
pred, hidden = model.decoder(dec_input, hidden)
outputs[:, t, :] = pred
teacher_force = random.random() < teacher_forcing_ratio
dec_input = dec_in[:, t:t+1] if teacher_force else pred.argmax(1, keepdim=True)
# 损失:第 1..M 步预测对齐目标;第 0 列只是占位,不参与计算
loss = criterion(outputs[:, 1:].reshape(-1, V), dec_tgt[:, :-1].reshape(-1))
生活类比 像学开车时副驾坐着教练:你每打一次方向盘,教练立刻把方向盘掰回正确角度,你永远从正确姿势练下一步;但拿照之后副驾空了,得靠自己的记忆开完全程。PAD 则像卷子上的空白区,算平均分时直接跳过,不按错题扣分。
易错 目标不右移就等于把答案原样喂进解码器,训练损失会异常低,推理立刻露馅;另一个坑是忘了 ignore_index=0,PAD 位置也被计入损失。
10 秒自测 · 点开看答案
问题:teacher_forcing_ratio 控制什么?推理时为什么不能继续用它?
答案:控制每一步用真实标签还是模型自己预测的概率。推理时没有真实标签,只能自回归生成。
概念
KP 06.22
推理:自回归、贪心与束搜索
推理时模型自回归 生成:从起始符与 C 出发,第 1 步输出 y_1,再把 y_1 当输入生成 y_2,循环到结束符或最大长度。效率上有一个大坑:朴素实现每生成一个新词,都把已生成的整段序列重新喂给解码器,前面词的隐藏状态被反复重算;正解是状态缓存 ——只喂上一个词 + 上一步隐藏状态,每步只做一次计算。
贪心搜索 每步取概率最高的词,简单高效,但某步的局部最优可能把整句带进沟里;束搜索(Beam Search) 每步保留 k 个候选序列,最后选整体概率最高的一条,通常 k 取 3~5。束越宽,质量通常越好,但计算也越贵。
贪心搜索 每步只留 1 个最优;快,但可能一步错、步步错。
束搜索 每步留 k 个候选,按累计对数概率选全程最优;慢一些,通常更通顺。
# 推理:从 <SOS> 开始,每步只喂上一个词 + 上一步状态
enc_hidden = model.encoder(src_tensor) # 上下文向量 C
dec_input = torch.tensor([[word2idx['<SOS>']]])
hidden = enc_hidden
result = []
for _ in range(max_len):
pred, hidden = model.decoder(dec_input, hidden) # 复用 hidden,不重算历史
next_id = pred.argmax(dim=1).item() # 贪心:取概率最大的词
if next_id == word2idx['<EOS>']: # 遇到结束符就停
break
result.append(idx2word[next_id])
dec_input = torch.tensor([[next_id]]) # 自回归:输出当下一步输入
生活类比 贪心像下山只看脚下最陡的方向,每步都爽,最后可能困在小土坑;束搜索像同时派两三个探路队员,各自记下走过的路,最后比较全程总高度再选一条。
易错 贪心解码必须同时设「遇到 EOS 就停」和「max_len 兜底」,否则模型不肯停机时会死循环;另外推理通常一次只处理一条样本,别把整个 batch 塞进单条解码循环。
10 秒自测 · 点开看答案
问题:束搜索比贪心多做了什么?代价是什么?
答案:每步保留 k 条候选序列并按累计对数概率比较,避免局部最优;代价是计算量与内存约增大 k 倍。
6.6 实验:先对齐公式,再跑通编解码
实验
LAB 06.1
实验 1 · RNN 前向计算:手写 NumPy 与 nn.RNN 对齐
难度 ★★☆
对应知识点 KP 06.4–06.10
test-1.py(指导书 01_RNN.py)
实验目的:用同一组 U、W 把 h_t = tanh(U·x_t + W·h_{t-1}) 亲手算一遍,再和 nn.RNN 逐元素对比,把「框架只是公式的高效实现」从一句口号变成三条断言;顺带把 (B,T,E) → (B,T,H) → (B,H) 三个形状刻进脑子。
原理速览:RNN 在每个时间步做同一件事——把当前词向量 x_t 与上一刻记忆 h_{t-1} 各做一次线性变换后相加,再过 tanh 压到 -1~1,得到新记忆 h_t;h_0 取全零,表示「还没读到任何词」。所有时间步共用 U、W,所以参数量约为 E×H + H×H + H,只与 E、H 有关,与句子长度无关。实验刻意让手写路径与框架路径共用同一组权重:手写版用显式 for 循环逐步算并压栈,框架版一次前向在内部完成同样的循环;两条路径数学等价,差异只应来自浮点累加顺序,因此对齐验证必须固定随机种子、无偏置、同初始态。
准备输入与权重。固定随机种子,把「播放 / 周杰伦 / 的 / 《稻香》」4 个词元查随机词向量表并补 batch 维,得到 (1,4,128) 的输入 x;再生成 U(E,H)、W(H,H),隐藏维度 H 先取 3。手写路径与框架路径必须共用同一组 U、W 和同一份 x,否则比较的是两次不同的随机初始化,对齐无从谈起;种子固定后,输入、U、W 每次运行都相同,三条断言的结论才可复现,换一台机器重跑前也先对齐种子与依赖版本。
手写前向。h_0 初始化为 (B,H) 全零,表示还没读任何词;按 for t in range(T) 逐时间步取出 x_t,算 h_t = tanh(x_t @ U + h_prev @ W),把 h_t 压栈后令 h_prev = h_t,让记忆沿时间往下传;循环结束用 np.stack(steps, axis=1) 沿时间轴堆成 (B,T,H) 的输出,末态 h_prev 就是 (B,H)。注意 h_prev 必须保持 (B,H),不能压成 (H,),否则 batch 维会被广播出错;x_t 是 (B,E),乘 (E,H) 的 U 之后正好是 (B,H)。
框架对齐。建 nn.RNN(input_size=E, hidden_size=H, num_layers=1, nonlinearity="tanh", bias=False, batch_first=True, bidirectional=False);框架的 weight_ih_l0 形状是 (H,E)、weight_hh_l0 是 (H,H),所以拷权重时必须转置:copy_(U.T)、copy_(W.T)。一次前向同时拿到输出 y 与最终隐藏态 h_n,squeeze(0) 去掉层数维后与手写末态同形。batch_first=True 意味着输入是 (B,T,E);若忘写,框架期望 (T,B,E),两条路径的形状要么直接报错,要么静默错位;拷贝权重建议放在 torch.no_grad() 里,避免被记进计算图。
写三条断言。①手写输出与 y 逐元素比;②手写末态与 h_n 逐元素比;③验证 y[:, -1] 与 h_n 相等——这条是理解「输出序列的最后一片=最终摘要」的钥匙。容差统一用 atol=1e-5;若想更严格,可以再加上 rtol=0,避免数值大的位置被相对误差放行。哪条为 False,先按「权重是否转置 → batch_first 是否漏写 → h_0 是否随机 → 框架是否带 bias」四步排查,而不是先怀疑公式。
机制验证与迁移。把 H 从 3 改成 16、E 从 128 改成 32 各重跑一次,三条断言应仍全为 True:维度只改变矩阵形状,不改变「两边算的是同一个公式」这个事实。再在输出序列后接 nn.Linear(H, 5),把每个位置映射成 B-PER / I-PER / B-ORG / I-ORG / O 五类概率,就得到最小序列标注器;与文本分类只取末态接一个分类头相比,序列标注要的是每个时间步的 h_t 各接一个头。这也解释了同一个 RNN 为什么既能分类又能标注:区别只在「用哪几个 h_t」,不在网络本身。实验报告里把「输入 → 输出 → 末态」三个形状写清楚,比贴一张代码截图更能说明你真的看懂了数据流。
def manual_rnn_numpy(x_np, U_np, W_np): # 手写前向:显式循环 T 步
B, T, _ = x_np.shape
h_prev = np.zeros((B, H), dtype=np.float32) # h_0 全零:空白记忆
steps = []
for t in range(T):
x_t = x_np[:, t, :] # 当前时间步输入 (B, E)
h_t = np.tanh(x_t @ U_np + h_prev @ W_np) # h_t = tanh(Ux + Wh)
steps.append(h_t)
h_prev = h_t # 状态前移,交给下一步
return np.stack(steps, axis=1), h_prev # 输出 (B,T,H) 与末态 (B,H)
rnn = nn.RNN(E, H, 1, nonlinearity="tanh", bias=False, batch_first=True)
with torch.no_grad():
rnn.weight_ih_l0.copy_(U.T) # 框架输入权重是 (H,E),与 U 互为转置
rnn.weight_hh_l0.copy_(W.T) # 循环权重 (H,H) 同样转置
y, h_n = rnn(x) # y: (1,4,H),h_n: (1,1,H)
assert torch.allclose(torch.from_numpy(out), y, atol=1e-5) # ①逐步输出
assert torch.allclose(torch.from_numpy(hT), h_n[0], atol=1e-5) # ②最终隐藏
assert torch.allclose(y[:, -1], h_n[0], atol=1e-5) # ③末步=末态
预期结果 形状(指导书示例,H=3):输入 (1,4,128);手写版与 nn.RNN 的输出均为 (1,4,3);两条路径的最终隐藏态均为 (1,3)。三条对齐断言打印结果均为 True——逐步输出一致、最终隐藏态一致、最后一步输出等于最终隐藏态。
数值上两条路径只差浮点累加顺序,约 1e-6 量级;若把 atol 收紧到 1e-6,「逐步输出一致」可能变成 False,放宽回 1e-5 立即恢复,这不是实现错误,而是可以在课堂上讨论的数值计算现象。任务 3 的链路形状:词嵌入 (1,4,128) → RNN → y (1,4,3) → Linear(3→5) → 每个位置的 5 类概率 (1,4,5)。(以上为材料预期示例,实际以本机打印为准。)
任务 2 的追问在这里有答案:E、H 只是把矩阵换个尺寸,两条路径仍然算同一个式子;真正会对不上的是「权重没转置、偏置没关、初始态不一致、batch_first 口径不同」这四类设置错误,而不是维度大小。写实验报告时建议附三样证据:形状打印、三条断言的 True/False 输出、任务 3 的链路形状,正好对应三个考核点。如果三条断言里有 False,先打印两边的第一个差异位置与最大绝对误差,再回头检查设置,通常一眼就能定位。
常见坑 ① 直接 copy_(U) 形状不匹配,或忘了转置导致维度静默错位——框架的 weight_ih_l0 是 (H,E),手写的 U 是 (E,H)。② 忘写 bias=False,框架带偏置、手写不带,结果整体差一个常量。③ 忘写 batch_first=True,输入输出变成 (T,B,H),y[:, -1] 取的就不是最后一步。④ h_0 随机初始化或忘了清零,两条路径起点不同,怎么放宽容差都对不上。⑤ 用 atol=1e-12 这类过严阈值,把正常的浮点累加差异误判成实现错误。⑥ 把 h_n 当成各步输出的平均或求和——它只是最后一步的状态;单层时 y[:, -1] 与 h_n 相等,正是在提醒你「输出序列的最后一片就是摘要」。⑦ 只跑一次看到 True 就收工,没做 H=16、E=32 的复跑;维度变化后仍能对齐,才说明结论不是偶然。
思考题 · 点开看参考要点
思考题:手写实现与 nn.RNN 为什么能对齐、差异为什么只有 1e-6 量级?batch_first=True 到底改变了什么?把 H 或 E 改掉,为什么三条断言仍然成立?
参考要点:两边执行的是同一个公式——同一组 U、W,同样无偏置,同样从全零 h_0 出发,只是矩阵乘法的累加顺序和底层实现不同,浮点误差累积到约 1e-6,所以容差取 1e-5 正好。batch_first 只决定张量布局:True 时输入输出是 (B,T,·),False 时是 (T,B,·),数学没有变,但取最后一步的位置要跟着变——设成 False 时正确的末步写法是 y[-1, :, :] 而不是 y[:, -1],这也是为什么对齐实验要先把口径统一再比较。改 E、H 只改矩阵维度,不改变「公式相同、初始态相同、口径相同」这一事实,所以三条断言恒成立。对齐验证的价值不在「证明框架正确」,而在「确认自己理解的口径和框架完全一致」;手写版慢、框架版快,但慢的那一版才是真正理解公式的地方。
实验
LAB 06.2
实验 2 · Seq2Seq 编码器–解码器与教师强制
难度 ★★☆
对应知识点 KP 06.19–06.22
train_seq2seq.py(指导书 Seq2Seq.py)
实验目的:把只会「读」的编码器和只会「写」的解码器接起来,跑通训练期的教师强制前向与推理期的贪心自回归两条路径,并说清错位目标、上下文注入、PAD 掩码各自在防哪一种错。
原理速览:Seq2Seq 由编码器、解码器两棒组成。编码器逐词读源序列,把不定长输入压成定长上下文向量 C(LSTM 版是 (h_n,c_n) 一对);解码器以 C 为初始状态,从起始符开始逐词写出目标序列,每一步的输出都是目标词表上的一个概率分布。训练时用教师强制:第 t 步喂真实的 y_{t-1},让模型每一步都从正确历史出发;推理时没有真值,只能把上一步的 argmax 回灌给自己,这就是自回归。数据侧靠右移一位制造「输入 y_{t-1}、预测 y_t」的错位对齐,损失侧靠 ignore_index 把 PAD 挡在梯度之外。
构造错位目标。用自包含的字符反转任务练手(输入「我爱中国」、期望输出「国中爱我」):每条序列加起始符、结束符并按 max_len 补 PAD。取 tgt[:-1] 作解码器输入(以起始符开头),tgt[1:] 作监督目标(以结束符收尾);对齐之后,第 t 步输入是 y_{t-1}、要预测的正好是 y_t,模型没有机会偷看答案。反转任务的好处是答案确定、无需外部语料:只要模型学会把序列倒过来写,就说明编码器确实把顺序信息读进去了。补 PAD 时注意别把结束符截掉:max_len 要留足长度,否则结束符被砍掉,模型永远学不会停。
编码器读成上下文。Embedding(padding_idx=0) → LSTM(batch_first=True),逐词读完源序列,只取最终的 (h_n, c_n),形状各 (num_layers,B,H);这一对就是上下文向量 C,LSTM 版必须两个状态一起传给解码器作初始状态。padding_idx=0 让 PAD 的词嵌入固定为零向量、不随训练更新;h_n、c_n 的第一维是层数而不是 batch,传给解码器前不要随意 squeeze;解码器只拿 hidden,编码器每步的 outputs 在这一版里根本不用——这与序列标注要取每个位置输出正好相反。
训练前向(教师强制)。解码器首步输入起始符(<SOS>),之后每步以 teacher_forcing_ratio 的概率喂真实的 y_{t-1}、否则喂上一步的 argmax;每步预测写进 outputs[:, t, :],所以第 0 列保持全零占位。损失只算第 1 列起:output[:, 1:] 对 dec_tgt[:, :-1],用 CrossEntropyLoss(ignore_index=0) 把 PAD 排除在梯度之外,这就是最朴素的 padding mask——只屏蔽损失,不屏蔽注意力;反向传播后用 clip_grad_norm_(..., max_norm=5.0) 防梯度爆炸。这个错位关系写错一位,模型就会被训练成「预测下下个字」,输出顺序错乱或重复,是 Seq2Seq 最经典的 bug。teacher_forcing_ratio 的随机数要每个 batch、每步重新抽,而不是整轮训练固定成一个值,否则「混合」就退化成全程二选一。
推理(贪心自回归)。从起始符与 C 出发,每步只喂「上一个词 + 上一步 hidden」,argmax 取词接到结果列表;遇到结束符(<EOS>)就停,同时用 max_len 兜底,一次只解一条样本——推理循环里不该出现 batch 维扩展,否则形状容易广播错乱。贪心是「每步取最大概率」,局部最优可能让整句走偏;想更稳可以换成保留 k 条候选的束搜索,想有多样性可以换成温度采样。停止条件写成「先判 EOS、再判长度」,并把 EOS 本身排除在结果之外。
对照与拓展。teacher_forcing_ratio 分别取 1.0、0.5、0.0 各跑一次,输出张量形状不变,变的是每步输入来源:全程喂真值收敛最快、但训练与推理落差最大;0.5 让两条路径更接近;全程自预测在早期容易震荡。再对照指导书的 DecoderAlt 变体:C 不进初始状态,而是每步与词嵌入拼接后输入,LSTM 的 input_size 要改成 2H。最后回答信息瓶颈的改进思路:更强的(双向)编码器、让 C 每步都可见、乃至用注意力在生成每个词时按需回看源序列。
def forward(self, src, tgt, teacher_forcing_ratio=0.5): # 节选:B/V 为批大小与词表大小
outputs = torch.zeros(B, tgt.shape[1], V).to(src.device) # 第 0 列占位
hidden = self.encoder(src) # 1) 编码器交出 C=(h_n, c_n)
dec_input = tgt[:, 0:1] # 2) 首步输入 <SOS>
for t in range(1, tgt.shape[1]):
pred, hidden = self.decoder(dec_input, hidden) # 3) 逐步解码
outputs[:, t, :] = pred # 第 t 步预测写回输出张量
use_gt = random.random() < teacher_forcing_ratio
top1 = pred.argmax(dim=1, keepdim=True)
dec_input = tgt[:, t:t+1] if use_gt else top1 # 真值 or 自预测
return outputs # (B, T, V)
# 损失:错位对齐,只算第 1 列起的有效位置,PAD 不参与
loss = criterion(output[:, 1:].reshape(-1, V), dec_tgt[:, :-1].reshape(-1))
预期结果 设备行打印 Using device: cpu(无 GPU 时)或 cuda;训练模式输出张量形状示例为 torch.Size([8, 12, 120])——指导书示例取 batch=8、目标长度 12、目标词表 120,且第 0 列保持全零占位、从第 1 列起才有预测值。标准贪心推理输出一串 token id:以起始符对应的 id 开头(指导书示例 sos_idx=1、eos_idx=2;具体取值取决于特殊符在词表里的顺序),遇结束符或达到 max_len=12 即停止;模型未训练时内容是随机的,但起止行为与单条 batch 的结构必须正确。
DecoderAlt 因上下文注入方式不同,输出 token 列表与标准模式不同;三种 teacher_forcing_ratio 设定下输出形状不变,差异只体现在每步输入来源。以上均为材料给出的预期结果(示例);本仓 train_seq2seq.py 自带 20 个 epoch 的训练循环,损失是否下降、反转是否学会以本机实测为准,不要照抄数字。
形状追踪任务里还可以直接打印 hidden 与 cell:编码器输出时各为 (num_layers,B,H),解码每一步后形状不变、内容在变;outputs 第 0 列恒为零,第 1 列开始才有预测。这三处打印是核对「张量形状 → 数据流」最直接的证据。如果几处打印互相矛盾,按「固定种子 → 确认 dec_in 与 dec_tgt 来自同一条目标序列 → 检查 outputs 列索引是否错一位」的顺序排查。对照标准实现与 DecoderAlt 的输出差异时,不要用「谁对谁错」评价——两者只差上下文注入位置,随机初始化下都只是结构演示。
常见坑 ① 只把 h 传给解码器、漏掉 c——LSTM 的上下文是 (h_n,c_n) 一对,只接 h 状态就不完整。② 目标不右移,把 tgt 原样既当解码器输入又当监督目标,等于把答案喂进去,训练 loss 异常低、推理立刻露馅。③ 把 outputs 的第 0 列也算进损失——它是占位,参与计算只会引入无意义梯度。④ 贪心只写「遇结束符停」却不设 max_len,模型不肯停时死循环。⑤ DecoderAlt 忘把 LSTM 的 input_size 改成 embed_dim+H,一拼接就维度不匹配。⑥ 把整批 src 传进单条解码循环,形状广播错乱。⑦ 把 padding_idx=0 与 ignore_index=0 混为一谈:前者只管词嵌入(PAD 不更新),后者只管损失计算,两件事都要做,缺一不可。⑧ 推理忘了 model.eval() 与 torch.no_grad(),行为与训练期不一致(本脚本无 dropout,换模型时要记得)。
思考题 · 点开看参考要点
思考题:训练时可以用教师强制,推理时为什么不能「也喂标准答案」?DecoderAlt 与标准实现分别把上下文 C 用在哪里,各有什么利弊?
参考要点:推理阶段没有标准答案可喂——要生成的就是答案本身,只能把上一步的输出当下一步输入,这就是自回归;教师强制只是训练期「扶着走」,用真值避免早期一步错步步错,同时按比例混入自预测来缓解曝光偏差。标准实现把 (h_n,c_n) 当解码器初始状态,C 只在开局注入一次,符合「先理解再动笔」,但长输出里信息会被稀释;DecoderAlt 让解码器状态从零开始,每步把 C 与词嵌入拼接后输入,C 每一步都可见、更抗遗忘,代价是输入维度翻倍、参数量与计算增加。两者都没根治「定长 C」的信息瓶颈,改进路线依次是更强的(双向)编码器、把 C 每步拼进解码器、最后用注意力让解码器每步动态回看源序列的对应部分。这也说明教师强制比例是超参数:比例越高训练越稳,但训练与推理的差距也越大。顺带回答实验指导书的最后一问:Seq2Seq 也能做序列标注(输入序列映射到等长标签序列),但标签之间强相关,逐位置分类接 CRF 往往更直接。
概念
KP 06.23
堆叠 RNN:多叠一层,多学到什么?(补充)
一句话 低层记细节,高层提炼结论;层数加深表达力,也拉长梯度回传的路。
堆叠 RNN(Stacked RNN)就是把多层 RNN 摞起来:第 1 层逐时间步读词向量,把每个位置的输出交给第 2 层,第 2 层同样沿时间循环。低层偏向词形与局部搭配,高层逐渐抽象出语义与结构;层数越多,能拟合的层次越深,但需要的数据与显存也越多,小语料上更容易过拟合。
PyTorch 里 num_layers=L 一次完成堆叠,每层各有自己的输入权重 U^(l) 与循环权重 W^(l),层与层之间不共享;只有同一层内部沿时间共享。
生活类比 像公司层层汇报:一线记原始工单,主管汇总成日报,经理再提炼成结论。中间任何一层漏记关键信息,最上面的结论就会失真。
易错 层数不是越多越好:梯度要同时穿过「垂直的 L 层」和「水平的时间步」,层数一多,浅层更容易收不到有效梯度,训练也更慢。小数据先试 1–2 层;要加深时配合层间 Dropout(nn.RNN 的 dropout 只作用在层与层之间,对时间维无效)或残差连接(补充)。
10 秒自测 · 点开看答案
问题:两层堆叠 RNN 里,第二层还沿时间循环吗?两层的 W 共享吗?
答案:仍然循环,每一层都是完整的 RNN;两层各有一套权重,只在同一层内部沿时间共享。
代码
KP 06.24
变长序列:padding + mask 与 pack_padded_sequence(补充)
一句话 补齐让同批形状一致,pack 让 PAD 不参与计算。
一个 batch 里句子长短不一,RNN 要求输入是规则张量,于是先把短句 padding(填补)到批内最长,再用 mask(掩码)把 PAD 位置挡在损失之外。但纯 padding 有副作用:RNN 仍会在 PAD 上推进状态,直接取末态,拿到的可能是「读完一串 PAD」的状态,而不是最后一个真词的状态。
pack_padded_sequence 把有效词元压成 PackedSequence,让 RNN 只在真实长度内计算;算完再用 pad_packed_sequence 还原成规则张量。LSTM/GRU 与双向 RNN 都支持:双向时反向那一程也只在有效长度内走,不会被句尾的 PAD 先污染。
# lengths 为每条样本的真实长度,须在 CPU 上;enforce_sorted=False 可自动排序
packed = nn.utils.rnn.pack_padded_sequence(x, lengths, batch_first=True, enforce_sorted=False)
out, h_n = rnn(packed) # PAD 不参与计算,h_n 是最后一个真词的状态
out, _ = nn.utils.rnn.pad_packed_sequence(out, batch_first=True, total_length=T)
易错 ① pack 之后 out 是 PackedSequence,不能再当普通张量切 out[:, -1];② 漏传 total_length 时,还原出的长度只到批内最长真实长度;③ lengths 要放在 CPU 上,且传真实长度而不是补齐后的长度;④ 只做 padding 不做 mask,PAD 位置的损失照样回传梯度。
10 秒自测 · 点开看答案
问题:只 padding 不 pack,取 out[:, -1] 做分类有什么隐患?
答案:短句最后几个位置是 PAD,RNN 在 PAD 上又推进了几步,拿到的是被 PAD 污染的状态;应按 lengths 取真末步,或改用 pack。
公式
KP 06.25
梯度裁剪:把「超长」的梯度按比例压回去(补充)
一句话 方向不动、长度封顶:范数超过阈值就整体缩回阈值以内。
梯度爆炸时,参数梯度会突然窜到几十上百,一步就把权重带飞。按范数裁剪(norm clipping)的做法是:把所有参数的梯度拼成一条向量,算它的 L2 范数;一旦超过阈值 θ,就整体乘以 θ/||g||。这样方向保留、长度被压回阈值,训练不会因单个异常批次直接崩掉。
PyTorch 用 clip_grad_norm_ 一步完成,返回值是裁剪前的总范数,建议打印出来观察阈值是否合理。另有按值裁剪 clip_grad_value_,逐元素截断、会改变方向,一般不如按范数裁剪(补充)。
loss.backward()
total_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
# 返回值是裁剪前的总范数,用来判断阈值该定多大
optimizer.step()
易错 阈值别拍脑袋:太小则正常梯度天天被压,学得慢且不稳;太大等于没裁。先打印 total_norm 的分布,选一个只截掉「离群尖峰」的值;RNN/Seq2Seq 脚本常用 5.0,Transformer 常用 1.0(补充)。裁剪只治爆炸、不治消失,也不改变梯度方向。
10 秒自测 · 点开看答案
问题:按范数裁剪前后,梯度的方向变了吗?为什么?
答案:没变。所有分量同乘一个正标量 θ/||g||,方向保持,变的只是长度。
公式
KP 06.26
LSTM 三门手算:一个时间步走一遍数字(补充)
一句话 遗忘门管旧账留多少,输入门管新账记多少,输出门管往外说多少。
设上一步 c_{t-1}=0.8,本步三个门与候选值为 f=0.9、i=0.5、c̃=0.6、o=0.7。先更新细胞状态:c_t = f⊙c_{t-1} + i⊙c̃ = 0.9×0.8 + 0.5×0.6 = 1.02;再算对外输出:h_t = o⊙tanh(c_t) ≈ 0.7×0.770 = 0.539。
三个门都由 Sigmoid 产出 0~1 的系数:f 决定旧记忆保留多少,i 决定新候选写进多少,o 决定细胞状态有多少暴露给下一步的网络。三者分工,LSTM 才不必每来一个词就把整本笔记重写一遍。手算的价值在于看清乘法关系:c_t 的大小由 f 与 c_{t-1} 的乘积主导,而 h_t 永远被 tanh 压回 (−1, 1)。
生活类比 像带三个旋钮的保险柜:f 调「旧文件抽走多少」,i 调「新文件放进多少」,o 调「玻璃窗开多大让人看见」;窗关着,柜内文件照样在进出。
易错 别把三个门的角色记混:o 只控制「对外读出」,不决定 c_t 存什么;f=1、i=0 时 c_t = c_{t-1},记忆原样传下去。若 o≈0,h_t≈0,但细胞状态仍在更新(补充)。
10 秒自测 · 点开看答案
问题:若输出门 o=0,c_t 还更新吗?h_t 是多少?
答案:c_t 照常按遗忘门与输入门更新;h_t = 0×tanh(c_t) = 0,只是本步不向网络暴露任何信息。
面试
KP 06.27
LSTM vs GRU:三门对两门,参数与效果怎么选(补充)
一句话 GRU 少一套门、少一个状态,参数量约为 LSTM 的 3/4。
两者都用 Sigmoid 门控,思路一致,差别在「几套门、几个状态」。LSTM 有遗忘门、输入门、输出门,另有一条独立的细胞状态 c;GRU 把 c 与 h 合并,只留更新门 z 与重置门 r。参数量上,单层单向 LSTM 约 4H(E+H+1)、GRU 约 3H(E+H+1):E=128、H=64 时约为 49408 与 37056。
效果没有普遍赢家:长序列、需要精细记忆控制时 LSTM 常略占优;算力紧、要训练快时 GRU 更划算,参数少,小数据上过拟合风险也低一些(补充)。
对比项 LSTM GRU
门数 3 个:遗忘 / 输入 / 输出 2 个:更新 / 重置
状态 h 与 c 两个 只有 h 一个
参数量 ≈ 4H(E+H+1) ≈ 3H(E+H+1),少约 1/4
训练速度 较慢 较快
效果 长依赖、精细记忆控制常略优 多数任务与 LSTM 相当
典型场景 长文本、需要长期记忆 算力紧张、追求速度
易错 别背「GRU 一定更差」或「GRU 全面更好」:两者没有普遍赢家,效果强依赖任务、数据量与调参。面试被问「选哪个」,正确答法是「先跑对照实验,比验证集指标与训练成本」,而不是背结论。
10 秒自测 · 点开看答案
问题:LSTM 与 GRU 的参数量之比大约是多少?为什么?
答案:约 4:3。GRU 只有更新门与重置门两套门参数,也不再单独维护细胞状态。
代码
KP 06.28
BiRNN 训练细节:两套权重怎么拼、下游怎么接(补充)
一句话 正向一套、反向一套,输出按方向拼接,下游只取最后一层。
PyTorch 里 bidirectional=True 之后,框架自动维护正、反两套权重,参数量约翻倍,两套权重在同一个损失下一起更新。输出张量形状变成 (B, T, 2H):最后一维的前 H 个通道是正向、后 H 个是反向。最终隐藏态 hn 的形状是 (2×num_layers, B, H),多层时按「每层先正向后反向」排列,所以 hn[-2] 是最后一层前向末态、hn[-1] 是反向末态。做分类时把这两个末态拼成 2H 向量再接全连接层;做序列标注时则逐位置使用 out 的 2H 输出。
rnn = nn.RNN(input_size=E, hidden_size=H, num_layers=1,
batch_first=True, bidirectional=True)
out, hn = rnn(x) # out: (B,T,2H);hn: (2,B,H)
sent = torch.cat([hn[-2], hn[-1]], dim=1) # 分类:前向末态 + 反向末态 -> (B,2H)
# 序列标注:直接用 out[:, t, :](2H)接每个位置的分类头
易错 反向那一路从序列末尾开始读,PAD 会先被它读到并污染反向状态;变长 batch 必须 pack 或 mask,别指望 padding 还能保持正确。另外正反两路不共享权重,参数与计算都要按 2 倍估算。
10 秒自测 · 点开看答案
问题:反向 RNN 的「最后一步」对应原句的哪个位置?
答案:原句的第 1 个词。它从末尾倒着读,读到开头才算走完全程。
公式
KP 06.29
BLEU:机器翻译的分数是怎么「数」出来的(补充)
一句话 数机器译文有多少 1–4 元组出现在参考译文里,再罚过短。
BLEU 的直觉是「重合度」:把机器译文和参考译文都切成 n-gram,统计机器译文里有多少 n-gram 在参考文中出现过。1-gram 命中率高说明选词对,2-gram、3-gram 高说明搭配和语序顺,4-gram 高说明整段更像人话。对 1~4 元命中率取加权几何平均,再乘短句惩罚 BP,防止模型靠「少写几个词」刷分。
例:候选 6 个词里有 5 个在参考文中出现,则 p1≈0.83;整体分数被最弱的 n-gram 项拖住,所以 BLEU 对语序错乱很敏感。它衡量的是与参考译文的重合,不等同于译文质量(补充)。
易错 只报 BLEU 不报参考译文与分词口径,分数没有可比性;同义改写还会吃亏——意思对但 n-gram 不重合,得分照样低。所以工程上常同时看人工评估或多个指标(补充)。
10 秒自测 · 点开看答案
问题:BLEU 只看 precision,为什么还要乘 BP?
答案:否则译文越短越容易拿高分(写一个全命中的词即可);BP 用来惩罚比参考译文短的候选。
概念
KP 06.30
从 Seq2Seq 到注意力:瓶颈是怎么被绕过去的(补充)
一句话 不再只递一个定长 C,而是每写一个词就回头翻一次原文。
Seq2Seq 把整句压进一个定长 C,解码每一步用的都是同一个 C,于是有两个毛病:句子一长,开头信息就被挤掉;生成任何词时,都无法「重点看」输入的对应部分。注意力(Attention)的改法很直接:解码器每一步拿当前状态与编码器每个位置的输出算一个匹配分数,softmax 成权重,再对编码器输出加权求和,得到随解码步变化的上下文 c_t。
这样解码器不再只依赖一次性的 C,而是每写一个词就动态回看一遍原文。把「解码器查编码器」推广成「序列内部自己查自己」,就是第 7 章的自注意力(Self-Attention)。
三条好处 ① 绕过定长瓶颈:信息留在编码器各步,不必全塞进 C;② 权重可解释:α 常呈现近似词对齐;③ 解码器到编码器各位置的梯度路径变短,长依赖更好学(补充)。代价是每步多算 T 个分数(T 为源序列长度),总复杂度 O(T×M),M 为解码步数。
10 秒自测 · 点开看答案
问题:注意力为什么能缓解信息瓶颈?
答案:解码每一步都直接访问编码器的全部输出并动态加权,不再只靠一个固定长度的 C。
概念
KP 06.31
注意力的直观:解码器每写一个词,都回头看一次原文
一句话 不是把整句记得更牢,而是每写一个词,重新决定该看哪里。
「回头看」不是比喻:解码第 t 步时,解码器拿自己的当前状态当查询,去和编码器每个位置的输出逐一比对,得到一个「这一步该重点看哪几处」的权重分布,再按权重把那些位置的信息加权求和,作为本步的上下文。它与 Seq2Seq 只递一个固定 C 的做法相比,差别不在记住多少,而在于每一步都能重新分配注意力:对齐、重读、跳过无关片段,全由这一组权重决定。
自注意力(Self-Attention) Q、K、V 全部来自同一条序列,每个位置和本序列所有位置打招呼。编码器里全句可见,解码器里要加因果掩码。
交叉注意力(Cross-Attention) Q 来自解码器当前状态,K、V 来自编码器输出;权重矩阵是「目标长度 × 源长度」的长方形,只出现在解码器里。
10 秒自测 · 点开看答案
问题:解码第 5 步和第 6 步用到的上下文向量一样吗?为什么?
答案:不一样。每一步的 Q 随解码状态变化,注意力权重跟着变,加权出的上下文自然不同——这正是「每步回头看」与「一个固定 C 用到底」的区别。
概念
KP 06.32
序列模型的六张脸:分类、标注、翻译、摘要、对话、语音(补充)
一句话 输入输出怎么对齐、长度能不能预知,决定该请哪类结构上场。
六个任务看着花哨,拆开只看两件事:输出和输入是否逐位置对齐、输出长度能不能提前知道。文本分类把整句压成一个标签,是「多对一」;序列标注给每个 token 出一个标签,是等长的「多对多」;翻译与摘要是长度不同的「多对多」,只能靠编码器-解码器。对话拿上文接下文,Decoder-only 最顺手;语音识别把声学帧串映射成文字,是不等长转换,常用 CTC 或注意力编解码。
任务 输入 → 输出 典型结构 主指标
文本分类 整段文本 → 1 个标签 TextCNN / TextRNN / BERT + 分类头 P / R / F1
序列标注 token 序列 → 等长标签序列 BiLSTM+CRF / BERT-CRF 实体级 F1
机器翻译 源句 → 目标句(不等长) 编码器-解码器 + 注意力 BLEU
文本摘要 长文 → 短摘要 编码器-解码器 / Decoder-only ROUGE
对话 多轮上下文 → 一句回复 Decoder-only 人工 / 任务成功率
语音识别 声学帧串 → 文字 CTC / RNN-T / 注意力编解码 WER / CER
易错 先问「对齐吗、长度知道吗」再选结构:给翻译只喂单侧池化向量、给序列标注只取最后一步,都会把任务做残。另一个坑是用逐 token accuracy 评估标注或语音——大量 O 标签和空白帧会把分数刷得很高,必须换成实体级 F1 或 WER。
公式
KP 06.33
训练稳定性:学习率、梯度裁剪、batch size、序列长度(补充)
一句话 四个旋钮互相牵制,只拧一个,通常会把另一个拧坏。
RNN 的训练稳定性被四个量绑在一起。学习率太大,BPTT 连乘出的梯度会一步把权重带飞;太小又收敛不动。梯度裁剪把总范数封顶(常用 1~5),只防爆炸、不治消失。batch size 越大,梯度噪声越小、吞吐越高,但激活显存按 batch 线性上涨,学习率通常也要同步调大(线性缩放法则,补充)。序列长度决定回传步数:长度翻倍,计算、显存和连乘项数都翻倍,长依赖更容易衰减。
旋钮 调大之后 主要代价 经验做法
学习率 收敛更快,过大直接发散 震荡、出现 NaN 1e-3 起手,配 warmup
裁剪阈值 梯度更少被截断 尖峰失控、一步走飞 先打印总范数再定值
batch size 吞吐高、梯度更稳 激活显存涨,泛化或变差 同步调大 lr,别只加 batch
序列长度 覆盖更长的依赖 显存、计算、回传步数线性涨 超长序列用截断 BPTT
10 秒自测 · 点开看答案
问题:序列长度从 128 提到 512,训练还会受什么影响?
答案:回传步数变 4 倍,梯度连乘路径更长、长依赖更易消失;单步显存与耗时也约涨 4 倍。显存不够时用截断 BPTT 分段回传,别把 batch 一路砍到 1。
面试
KP 06.34
评估选错,努力白费:四类任务各看哪个指标(补充)
一句话 先问任务有没有参考答案,再决定用重合度还是用概率。
指标要跟输出形态匹配。分类和序列标注有唯一答案,看 Precision、Recall、F1:类别不均衡时 accuracy 会被多数类带偏,多分类还要声明用 macro 还是 weighted 平均。翻译、摘要这类生成任务没有唯一答案,只能比与参考文的 n-gram 重合:BLEU 偏精确率、多用于翻译,ROUGE 偏召回率、多用于摘要。语言模型没有参考答案,用困惑度 PPL = exp(平均交叉熵) 衡量「平均在多少个词里犹豫」。
任务 主指标 为什么是它 常见误用
文本分类 macro-F1 + 混淆矩阵 少数类不被多数类淹没 只报一个 accuracy
序列标注 实体级 F1 边界与类型都对才算对 逐 token accuracy 被 O 刷高
机器翻译 BLEU + 人工 参考译文不唯一 拿单个 BLEU 当质量定论
文本摘要 ROUGE-N/L + 人工 更看对原文要点的覆盖 忽略事实一致性
语言模型 PPL 衡量对下一个词的把握 跨词表、跨分词直接比
易错 PPL 只在同词表、同分词、同测试集下可比;BLEU/ROUGE 只数表面重合,同义改写会吃亏。正确姿势是自动指标 + 人工抽查一起报,并写清分词口径与参考文数量,否则分数没有可比性。
10 秒自测 · 点开看答案
问题:两个模型在同一测试集上 PPL 为 18 和 21,能直接说前者更好吗?
答案:先确认词表与分词一致。词表大小不同,PPL 对应的「候选词数」就不同;只有口径完全一致时,这个数字才能横向比较。
本章速查
RNN :h_t = tanh(W_x x_t + W_h h_{t−1} + b),权重沿时间共享,参数量与句长无关。
BPTT :把循环按时间展开成深层网络,梯度沿时间累加;连乘因子导致梯度消失/爆炸。
LSTM/GRU :门控 + 细胞状态,给梯度提供近似恒等通道,缓解长距离依赖。
Seq2Seq :Encoder 压缩成 C,Decoder 自回归生成;C 是信息瓶颈。
训练 vs 推理 :训练用 Teacher Forcing + 错位标签;推理只能自回归,贪心或束搜索。
来源:第二章 PPT P65、P79–P90;《HCIP-AI-自然语言处理-RNN与Seq2Seq复习-实验指导书》;08_RNN 与 9_seq2seq 知识点复习页;RNN.py / test-1.py / train_rnn_lm.py / train_seq2seq.py。
2017 年之前,做序列建模绕不开循环神经网络:一个词一个词地读,读得慢,隔得远还会忘。Transformer 把循环和卷积全部删掉,只留下注意力机制与前馈网络,让整句话可以同时计算,任意两个词之间的距离固定为一步。
本章按"动机 → 整体架构 → 自注意力 → 训练与推理 → BERT 与大模型 → 五个实验"的顺序展开。学完你应该能回答:为什么必须换掉 RNN、Q/K/V 在做什么、多头为什么不更贵、训练和推理为什么不对称、BERT 和 GPT 为什么是同一台发动机。
7.1 动机:Seq2Seq 到底卡在哪里
概念 KP 07.1
Seq2Seq 的"固定向量"为什么是原罪?
一句话 把整句话压进一个固定维度的向量,句子越长,每个词分到的信息越少。
序列到序列(Sequence to Sequence,Seq2Seq)模型由编码器(Encoder)和解码器(Decoder)组成,一般用 RNN/LSTM/GRU 实现:编码器把不定长的输入序列压成一个固定长度的上下文向量(context vector)c,解码器再从 c 里"倒出"不定长的输出序列。两个长度都不固定,靠 c 对齐。
问题出在"固定长度"四个字。设句子有 n 个词、c 有 d 维,平均每个词只能分到 d/n 个数字来描述自己。翻译长句时,译文的头几个词往往还不错,越往后越飘——解码器手上只剩一个被稀释过的 c,原文后半段的具体内容已经查不到了。这就是信息瓶颈(information bottleneck)。
生活类比 你看完两小时《流浪地球》,让朋友只用一句话转述给没看过的你。你知道了类型和结局,但谁牺牲了、那句台词怎么说的,全没了。c 就是这"一句话":容器容量写死在 256/512 维,电影越长丢得越多。
易错 把 c 当成"整句的完整编码"。它只是固定容量的摘要:n 越大,每个词平均分到的维度 d/n 越小,长距离依赖丢失得越彻底,工程上表现为句子越长 BLEU 掉得越快。
10 秒自测 · 点开看答案
问题:为什么"把编码器换成更强的 RNN"治不好长句翻译?
答案:瓶颈在"只交出一个固定向量"这个结构,而不在编码器算力。解码器看不到编码器每一步的中间状态,前面说了什么已经无从查起。
概念 KP 07.2
Attention 的三级跳:从"递纸条"到"看白板"
一句话 注意力先救"编码器与解码器的交互",随后连两者内部也全部换成了注意力。
PPT 第 92 页用一张表讲完三代架构,按三个位置对比:编码器内部怎么处理、解码器内部怎么处理、解码器与编码器之间怎么交互。
第一跳:原版 Seq2Seq。内部都是 RNN/CNN,中间靠一个静态向量 c 传递,瓶颈就在这一格。
第二跳:Seq2Seq + 注意力。内部仍用 RNN/CNN,但两者之间从"递一个向量"变成"随时按需取用所有位置",长句翻译被救了回来。
第三跳:Transformer。把内部那两个 RNN 也换成注意力,整句可并行,任意两词一步直达。
处理位置 Seq2Seq(无注意力) Seq2Seq + 注意力 Transformer
Encoder 内部 RNN/CNN RNN/CNN 自注意力
Decoder 内部 RNN/CNN RNN/CNN 自注意力(带掩码)
Decoder ↔ Encoder 固定长度向量 注意力 交叉注意力
生活类比 体育课传话:十个人排队一个传一个,传到队尾话早变味了(第一跳);后来允许每人传话前瞄一眼最早那位的笔记,丢得少了,但队还得排(第二跳);再后来干脆取消排队,全班站在同一块白板前同时看、同时写(第三跳)。
10 秒自测 · 点开看答案
问题:从"Seq2Seq + 注意力"到 Transformer,真正被换掉的是什么?
答案:换掉的是编码器和解码器内部的 RNN/CNN。注意力在第二跳已经出现在两端交互里,Transformer 把它推广到了序列内部。
公式 KP 07.3
复杂度:Transformer 快在哪、贵在哪?
一句话 自注意力用 O(n²d) 的计算量,换来 O(1) 的顺序操作与 O(1) 的最长路径。
看一层网络的成本,要同时看三件事:每层计算量(FLOPs)、顺序操作数(能并行多少)、任意两个位置之间的最大路径长度(信息要传几手)。论文 Table 1(PPT 第 93 页引用)的结论是:
RNN 计算量 O(n·d²) 看起来最小,但顺序操作数是 n。100 个词要排队算 100 轮,GPU 上再多核也只能干等。
自注意力计算量 O(n²·d),顺序操作数是 1,最长路径也是 1:整句一次矩阵乘法算完,任意两个词直接相连。
谁的账更划算取决于 n 和 d 谁大:自注意力与 RNN 的计算量之比约为 n/d。取 d=512,n 小于 512 的短句自注意力更便宜;n 远超 d 的长文本,n² 开始爆炸。n=128K 时,仅一个头的 n×n 注意力矩阵就有约 164 亿个数,这就是"长上下文吃显存"的根源。
每层结构 计算量 顺序操作数 最大路径长度
RNN O(n·d²) O(n) O(n)
CNN O(k·n·d²) O(1) O(log_k n)
自注意力 O(n²·d) O(1) O(1)
生活类比 5 个人圆桌开会最舒服,谁都能直接对话;但公司有 5000 人还搞"全员圆桌",会议室都装不下,只能改成逐级汇报。不是圆桌不好,而是成本随人数平方增长。
易错 以为"FLOPs 少就一定快"。RNN 的总计算量常比自注意力小,但顺序操作数是 n,墙钟时间反而更长。决定训练速度的是并行度,不是总 FLOPs。
10 秒自测 · 点开看答案
问题:n=100、d=512 时,RNN 和自注意力每层大约各要算多少次乘加?
答案:RNN 约 n·d²=2621 万次,自注意力约 n²·d=512 万次。短句时自注意力反而更省,这是论文敢说"更快"的底气。
概念 KP 07.4
标题里的"All"到底在说什么?
一句话 删掉 RNN 和 CNN,只留注意力加前馈网络,效果不但没掉反而更好。
2017 年,Google 的八位作者发表《Attention Is All You Need》(arXiv:1706.03762),在英德、英法机器翻译上刷新当时最好成绩,训练成本比之前的模型低一个数量级(补充)。它保留了编码器-解码器的外壳,却把里面的循环和卷积全拆了:没有循环(no recurrence)、没有卷积(no convolution)、没有位置上的先后依赖,50 个词的计算可以同时发出去。
"All" 不是"注意力万能",而是一句针对当时共识的宣言:处理序列不一定非要 RNN。论文用消融实验撑住了它——把多头换成单头、把注意力换成固定权重、去掉位置编码,性能逐项下降(补充)。真正的意义是把"序列建模"从结构约束问题变成了信息路由问题:模型不再被顺序绑住,才可能做得又深又宽,才有后来的 BERT、GPT、LLaMA。
生活类比 小馆子原来菜单 50 道菜,备料复杂、出餐慢、每道都不精;老板砍到 8 道,专心做到极致,出餐反而更快、口碑更好。"Attention is All You Need" 就是这次砍菜单:删掉不必要的复杂度,剩下的部分跑得更快。
10 秒自测 · 点开看答案
问题:"只用注意力"是不是意味着位置信息也不需要了?
答案:不是。自注意力本身对顺序不敏感(置换等变),必须额外加位置编码,否则"狗咬人"和"人咬狗"在模型眼里一模一样。
7.2 整体架构与输入:6 + 6 层怎么搭
概念 KP 07.5
整体架构:左边 6 层读,右边 6 层写
一句话 编码器 6 层把原文读成一组向量,解码器 6 层边看已翻译部分边回查原文。
Transformer 仍是编码器-解码器结构:编码器(Encoder)由 N=6 个结构相同的层堆叠,解码器(Decoder)也是 N=6 层。每一层进去是 n×512,出来还是 n×512,维度全程不变——因为残差连接要求输入输出能直接相加,所以"6 层"不是把维度压小,而是在同一张 512 维画布上反复精炼 。
"6 层相同"指结构相同,不是参数相同:6 层的权重各算各的,是 6 组独立参数。编码器每层 2 个子层(自注意力、前馈网络),解码器每层 3 个子层(掩码自注意力、交叉注意力、前馈网络),多出来的那块就是"翻译时回头查原文"。解码器的输入是已生成的部分,要右移一位(shifted right)并在最前面加起始符,最后经线性层映射到目标词表的概率分布。
生活类比 做糖醋排骨要走六道工序:焯水、腌制、油炸、调汁、收汁、装盘。每道工序的套路相似,但执行的人、火候、配方不同;排骨从头到尾还是那块排骨,只是被反复加工得更到位。
易错 两个常错:以为 6 层共享一套参数(实际是 6 组);以为解码器能提前看到整句答案(训练时靠掩码封住,推理时根本没有答案)。
10 秒自测 · 点开看答案
问题:输入是 n×512,经过 6 层编码器后输出形状是多少?
答案:还是 n×512。层数改变的是表示的"精度",不改变序列长度 n 和维度 d,否则残差相加无法进行。
概念 KP 07.6
Encoder Block 的六个零件与执行顺序
一句话 注意力先"横向交流",FFN 再"各自消化",每个子层外面都套着 Add & Norm。
PPT 第 95–96 页把一层编码器拆成六个零件:输入嵌入(Input Embedding)、位置编码(Positional Encoding)、多头注意力(Multi-Head Attention)、自注意力(Self-Attention)、前馈网络(Feed Forward)、残差连接(Add)与层归一化(Norm)。其中多头注意力与自注意力是包含关系:多头注意力 = 8 个自注意力并行 + 拼接 ,不是一个并列零件。
执行顺序可以背成一条链:自注意力 → 残差相加 → LayerNorm → 前馈网络 → 残差相加 → LayerNorm 。先用注意力把上下文信息拉进来,再用前馈把拉进来的信息加工成更抽象的特征,这是"先交流、后消化"的关系,顺序反了性能会明显下降。
生活类比 部门上午开碰头会,大家互相通气(注意力);散会后各自回工位查资料、写方案(FFN);下午再碰一次,再各自回去改。若先闷头写一周再开会,写出来的东西根本对不上——这就是注意力必须在前的原因。
10 秒自测 · 点开看答案
问题:把 FFN 与注意力的顺序对调,模型还能正常训练吗?
答案:能跑,但性能明显下降。"先交流后消化"是被论文和后续实验验证过的结构,反了等于让每个词先闷头加工,再去对齐上下文。
概念 KP 07.7
为什么每个子层都要 Add & Norm?
一句话 残差保留"原稿"让梯度直通,LayerNorm 稳住尺度让深层网络训得动。
残差连接(Residual Connection,图中标 Add):把子层的输入 x 直接加到输出上。它有两个好处:一是反向传播时梯度可以沿加法这条"直通车道"流回前面,不必层层穿过乘法;二是子层只需要学"改动量"而不是"完整的新表示",没什么可改就输出 0,信息原样通过。
层归一化(Layer Normalization,图中标 Norm):把每个位置上的 512 维向量减掉自己的均值、除以自己的标准差,再用可学习的 γ、β 缩放平移。同一个 token 自己归一化,与批次里其他句子无关。不用 BatchNorm 的理由很实在:① 文本长度不一,按 batch 统计会抖;② 长序列塞不下几个,batch 常常很小,统计不准;③ 推理时只有一条输入,没有 batch 可统计。
生活类比 领导让你改方案,笨办法是重写一份,写崩了原稿也没了;聪明做法是开"修订模式",原稿始终在,你只标修改痕迹,成稿 = 原稿 + 修改。LayerNorm 则像只看小明一个人的六科成绩做标准化——来几个考生都无所谓,每人自成一套标准。
易错 把 Add 与 Norm 的先后写反。论文原版是 Post-LN:先加残差再归一化;后来的大模型普遍改成 Pre-LN:先归一化再进子层。两种都能跑,但深层训练稳定性差别很大。
概念 KP 07.8
输入三步:Token → Embedding → 加位置
一句话 词的语义走 Embedding,词的位置走位置编码,最后逐元素相加成 X。
PPT 第 97 页把输入拆成三步。第一步分词(Tokenization):把文本切成 token,每个 token 在词表里换成一个整数 ID;英文常用 BPE/WordPiece 切成子词(如 playing → play + ##ing),中文按字或子词切。第二步嵌入(Embedding):拿 ID 去一张"词表大小 × 512"的大表里查一行,得到 512 维词向量。第三步位置编码:把同样维度的位置向量逐元素加进去。
为什么是"相加"而不是"拼接"?拼接会把 512 维变成 1024 维,后续所有矩阵都要跟着改、参数量翻倍;相加保持维度不变,且位置向量的每个维度是固定、可预测的,模型完全有能力学会"哪部分管词义、哪部分管位置"。相加前词向量要先乘 √d_model(512 的平方根约 22.6),否则初始化偏小的词向量会被值域 [−1, 1] 的位置编码淹没。
生活类比 开大会每人胸前挂工牌:照片、姓名、部门说明"我是谁"(词向量);但主持人喊"第 3 排第 5 位发言",你还得知道自己在哪,所以工牌上再印一行座位号(位置编码)。两样信息印在同一张卡上,一眼看完,而不是挂两块牌子。
# 输入三步:查词表 ID → Embedding 查表 → 乘 √d_model → 加位置编码
x = self.embedding(src) * math.sqrt(self.d_model) # (B, L, 512)
x = self.pos_embed(x) # 逐元素相加,形状不变
10 秒自测 · 点开看答案
问题:如果改成拼接(concat),最直接的代价是什么?
答案:维度变成 1024,后面每个子层的输入维度、权重矩阵形状、残差相加都要改,参数量和计算量随之翻倍;而论文验证相加已经够用。
公式 KP 07.9
正弦位置编码:给每个词一个"时钟读数"
一句话 每一维是一个不同波长的 sin/cos,低维像秒针、高维像时针,组合出唯一的位置指纹。
自注意力天生是"集合操作":把词的顺序打乱,算出来的结果只是跟着换位置,内容不变。所以必须把位置信息额外塞进去。PPT 第 98 页使用的是三角函数位置编码(绝对位置编码),pos 是词在句中的位置,2i 是偶数维、2i+1 是奇数维,d 与词向量维度相同。
关键在波长。每一维的波长 λ = 2π·10000^(2i/d),指数随 i 线性增长,波长形成几何级数 :最短的一维约 2π≈6.3 个位置转一圈,最长的一维约 2π×10000≈6.3 万。快慢搭配才能唯一确定位置:只有秒针分不清 3 分 12 秒和 8 分 12 秒,只有时针分不清 3 点和 3 点 59 分,三根针组合起来时刻才唯一。
这套编码是算出来的,不是学出来的:没有参数、不占显存,遇到比训练集更长的句子也能直接算第 1000 个位置,这叫可外推性。三角函数还有和角公式的性质,使 PE(pos+k) 可以写成 PE(pos) 的线性组合(等价于乘一个只与 k 有关的旋转矩阵),因此具备表达相对位置的能力;不过实践中这种隐式相对信息模型并不总能学到(补充)。
生活类比 看挂钟:秒针 60 秒一圈、分针 1 小时一圈、时针 12 小时一圈,你扫一眼就知道"大概 3 点 47 分 20 秒",靠的不是某一根针,而是三根针的相位组合。位置编码用 256 对"针"叠出几乎不重复的位置指纹。
10 秒自测 · 点开看答案
问题:同一位置 pos=3,为什么低维的值变化剧烈、高维的值几乎不动?
答案:低维波长短(像秒针),位置挪一格相位变化大;高维波长极长(像时针),同样挪一格几乎看不出变化。
概念 KP 07.10
RoPE 旋转位置编码(补充)
一句话 不往向量里加位置,而是按位置把 Q、K 旋转一个角度,让内积只依赖相对距离。
原始正弦编码是"绝对编号":每个位置一个固定向量,模型要自己从绝对坐标里推相对关系。RoPE(Rotary Position Embedding)换了思路:把 d 维向量两两分组,每一组按位置 pos 旋转一个角度 θᵢ = pos × 10000^(−2i/d),只旋转查询向量 Q 和键向量 K,值向量 V 不动。
旋转的妙处在于:Q 和 K 各自转过自己的角度后,它们的内积只与角度差(也就是相对位置 pos−pos′)有关。于是"往后数 k 个词"在向量空间里就是"乘一个固定的旋转矩阵",天然获得相对位置表达,也更容易外推到训练时没见过的长上下文。LLaMA 系列用的就是 RoPE,PPT 第 114 页那句"位置编码使用旋转位置编码"指的就是它。
生活类比 老小区按"建成的先后"编门牌:1 号楼、2 号楼……后来中间空地又盖一栋,只能叫"3 号楼 A 座",外卖开始频繁送错。RoPE 相当于改成"以小区大门为原点、按方向和距离定位",后面再盖多少栋,坐标系都成立。
10 秒自测 · 点开看答案
问题:RoPE 只旋转 Q 和 K、不旋转 V,为什么?
答案:位置信息要影响的是"谁和谁相关"的打分,而 V 是加权混合的内容,混进来的是权重算好的结果;旋转 V 不会改变权重,反而破坏内容表示。
7.3 自注意力:每个词都去全句"打听消息"
概念 KP 07.11
Q / K / V:去图书馆找书的三个角色
一句话 用 Q 和所有 K 打分,softmax 成比例,再按比例把 V 的内容混起来。
PPT 第 99 页那句经典例句:"The animal didn't cross the street because it was too tired." 这个 it 指的是 animal 还是 street?人一眼知道是 animal(street 不会累),模型要算出这个结论,就得让 it 去看一眼全句、给每个词打分。
但不能直接拿词向量两两比:同一个词,作为"提问方"和作为"被查询方"该强调的侧面并不一样。于是把同一个输入投影成三个角色:查询向量(Query,Q)是"我在找什么",键向量(Key,K)是"我有什么标签",值向量(Value,V)是"我实际的内容"。用 Q 和所有 K 比相似度打分,分数经 softmax 变成比例,最后按比例把各位置的 V 加权求和。
比的是标签相似度,混的是正文内容,这两件事分开,模型才有表达力。Q 和 K/V 来自同一个序列就是自注意力 ;Q 在解码器、K/V 在编码器就是交叉注意力 。
生活类比 去图书馆找书:你心里想的是"我想找一本讲 Transformer 的入门书"(Q);书脊上的分类号和关键词是标签(K);真正翻开读到的章节内容是正文(V)。先用标签匹配决定"要不要抽这本书",再读正文决定"学到了什么"。
易错 以为 Q、K、V 是三个不同的输入。它们都由同一个 X 乘不同矩阵得到,同源但角色不同;正因为角色不同,才不能共用一个投影矩阵。
10 秒自测 · 点开看答案
问题:为什么 Q 和 K 要用两个不同的权重矩阵?
答案:提问的角度和被检索的特征本来就不该相同。两套矩阵让模型学出这种不对称,比如作为提问方关心"谁在修饰我",作为被查方关心"我是什么词性"。
公式 KP 07.12
手算一遍:14 和 12 怎么变成 0.88 和 0.12
一句话 打分 14/12 → softmax 得 0.88/0.12 → 按这两个比例混合两个 V。
PPT 第 100 页用"机器 / 学习"两个词把整个流程横着摆了一排:输入 → 词嵌入 → 查询/键/值 → 打分(14 和 12)→ 除以 8(√d_k)→ Softmax → 乘值向量 → 求和。
这里有个很多人第一次算不出的地方:0.88 / 0.12 是对原始分数 14、12 直接做 softmax 的结果 (e¹⁴/(e¹⁴+e¹²)≈0.8808);如果严格执行"先除以 8",得到的是 softmax(1.75, 1.5)≈0.56 / 0.44。两个数都对,只是对应流程里的不同位置,理解这一点比背下某个数字重要。
为什么一定要除?Q·K 是 d_k 个乘积之和,维度越高点积的方差越大,分数一大 softmax 就饱和:最大的接近 1,其余接近 0,梯度也接近 0,模型学不动。除以 √d_k 相当于把分数方差拉回 1 附近,让 softmax 工作在"有梯度"的区间。
步骤 在算什么 PPT 示例数值
① 打分 Q 与每个 K 做点积,得到相似度 14、12
② 缩放 除以 √d_k(此例 √64 = 8) 1.75、1.5
③ 归一化 softmax 成比例,行和为 1 0.56、0.44
④ 加权求和 权重 × V,逐元素相加得 Z 0.56·V₁ + 0.44·V₂
对照 不缩放直接 softmax 0.88、0.12(PPT 上的数)
生活类比 项目拨了 100 万要分给 4 个供应商:先评估匹配度(打分),再把分数换算成百分比(softmax,加起来正好 100%),最后按百分比打钱(加权求和)。分数 14 和 12 不能直接当比例用,比例相加必须是 1,这就是 softmax 存在的唯一理由。
易错 把"PPT 上 0.88/0.12"背成"除以 8 之后的结果"。若考试按公式严格算,√d_k 缩放后的答案应是 0.56/0.44;两个数都能自洽,关键是说清楚你在流程的哪一步。
10 秒自测 · 点开看答案
问题:d_k 从 64 加到 512,若不做缩放,注意力分布会怎样?
答案:点积方差随维度变大,softmax 输入落入极端区,输出接近 one-hot、梯度接近 0,变成"一家独吞"。
公式 KP 07.13
矩阵形式:整句一次算完
一句话 X(n×d) 一次乘三个矩阵得到 Q/K/V,所有位置并行,输出仍是 n×d。
上一节"每个词分别算"只是为了讲清楚,真实实现是整句一起做矩阵乘法。设 X 是整句的表示矩阵,形状 n×d(每一行是一个词),W_Q、W_K、W_V 是三个 d×d_k 的可学习矩阵,则 Q = XW_Q、K = XW_K、V = XW_V,一次矩阵乘法就把所有位置算完——这就是并行的关键。
中间那个 n×n 的矩阵就是"谁关注谁"的完整记录:行是提问的人,列是被看的人,第 i 行第 j 列的数字是第 i 个词对第 j 个词的关注程度。因为每行做了 softmax,每行加起来是 1,但每列加起来不是 1 ,说明关注是单向的。把这张矩阵画成热力图,就能看出不同头在看什么;代价也在这里:n 翻倍,矩阵大 4 倍。
步骤 张量 形状(n=4,d=512,h=8)
输入表示 X 4 × 512
投影得 Q/K/V Q、K、V 4 × 512(每个头 4 × 64)
注意力打分 QKᵀ/√d_k 4 × 4(每个头一张)
加权求和 softmax × V 4 × 64(每个头)
拼回输出 Concat + W_O 4 × 512
生活类比 30 个学生互相打分,表格是 30 行 × 30 列、共 900 格。每人给别人的分数加起来必须是 100 分(= 每行 softmax 归一),但"张三给李四 20 分"不代表"李四给张三 20 分"——互评单向,所以矩阵不对称。
10 秒自测 · 点开看答案
问题:注意力矩阵的形状是 n×n 还是 d×d?
答案:n×n(每个头一张),n 是序列长度,d 是表示维度。说"注意力矩阵是 d×d"是把 n 和 d 搞混了,这是论文里常见的误读。
概念 KP 07.14
多头注意力:八个脑袋各看一件事
一句话 512 维切成 8×64,八个头独立算再拼回,算力与参数量几乎不变。
一句话里同时存在多种关系:指代(它 ↔ 小猫)、修饰(没吃饭 ↔ 小猫)、因果(因为饿 ↔ 推到地上)、语序。单个注意力头一次 softmax 只能给出一套权重,被指代占满就分不到因果。多头的解法不是让一个头样样都行,而是让 8 个头各管一摊。
切法要注意:base 版 d=512、h=8,每个头分到 d_k = 512/8 = 64 维。切的是维度,不是句子 ——每个头看到的仍是完整的 n 个词,只是每个词的表示只有 64 维。8 个头各有自己的 W_Q、W_K、W_V,独立算出一套 n×n 权重和 n×64 的输出,最后 Concat 拼回 n×512,再过输出投影 W_O。
多头并不更贵:8 个头各自的 W_Q 是 512×64,合起来 8×512×64 = 512×512,与单头一个 512×512 完全一样;矩阵乘法的 FLOPs 也几乎相同(逐元素级的 softmax 开销随头数略增)。所以它是用同样的算力、同样的参数,换来了"多视角"。
生活类比 一篇学生作文只让语文老师评,他可能只挑错别字和病句;改成八位老师分别评:语文看语法、数学看数据、心理看情绪、班主任看篇幅,最后把八份评语装订成一份综合评语。每人只看一个维度,合起来就全面了。
# 投影后按“头”切分:先 view 成 (B,T,h,d_k),再 transpose 换轴
q = self.q_linear(q).view(B, -1, self.num_heads, self.d_k).transpose(1, 2)
# 拼回时必须严格镜像切分顺序:transpose → contiguous → view
concat = out.transpose(1, 2).contiguous().view(B, -1, self.d_model)
return self.out_linear(concat) # W_O 才是真正把各头信息融合的一步
易错 以为 Concat 就是"融合"。Concat 只是把 8 段评语按顺序装订成册,各头信息还各自占着 64 维;真正让不同头交叉组合的是后面的 W_O。去掉 W_O,性能会明显下降。
10 秒自测 · 点开看答案
问题:8 个头是不是意味着 8 倍计算量和 8 倍参数?
答案:不是。每个头维度降到 1/8,8 个 512×64 合起来就是 1 个 512×512;多头本质是把一个大矩阵拆成 8 个小矩阵并行算再拼回。
多头注意力矩阵形状流转:拆头 → 每个头独立算注意力 → 拼接 → 乘 W_O 输出(B=1、L=3、H=2 的放大示意)。
概念 KP 07.15
Mask:把"不许看"写进 softmax
一句话 在 softmax 之前把要屏蔽的位置填 −1e9,softmax 之后它自然变成 0。
掩码(Mask)有两种。填充掩码(padding mask):一个 batch 里句子长短不一,短句补的 <pad> 不该参与注意力,否则填充位的语义会混进真实位置,交叉注意力还可能把对齐能力浪费在填充位上。因果掩码(causal mask):训练时把正确答案整句喂给解码器,如果不封住未来位置,预测第 2 个词时它已经看到了第 3、4 个词,等于抄答案;训练时 loss 掉得异常快,一推理就崩。
实现上是"含对角线的下三角":位置 i 只能看 j ≤ i,未来位置(j > i)的分数在 softmax 之前填成 −1e9。为什么不是 0?exp(0)=1,填 0 反而让"不许看"变成"优先看";为什么不用 −inf?数学上正确,但 fp16 下 −inf 参与运算容易出 nan。掩码必须加在 softmax 之前 :加在之后权重被直接丢弃,每行和小于 1,输出幅度整体缩小。
实验室实测(B=2, T=6, h=8):因果掩码后右上三角权重最大值为 0.000e+00(严格为 0),每行权重和仍为 1;去掉掩码后右上三角最大权重达 4.804e-01,接近一半注意力分给了"未来"。
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None:
# 掩码必须在 softmax 之前;-1e9 在 fp32 下 exp 后下溢为 0
scores = scores.masked_fill(mask == 0, -1e9)
attn = F.softmax(scores, dim=-1) # 被屏蔽位置权重严格为 0
生活类比 做语文卷子,第 3 题问"第三段的伏笔是什么"。如果允许你翻到最后看参考答案,你根本不用读文章。监考老师把答案页用胶带封住(= 掩码),你必须根据前文推断;训练时封住,推理时本来就没有答案页,所以不需要封。
10 秒自测 · 点开看答案
问题:编码器里的自注意力需要因果掩码吗?
答案:不需要。编码器读的是完整原文,每个词本来就该看全句;因果掩码只用于解码器的自注意力(和语言模型),防止偷看未来。
7.4 训练、推理与模型家族:从参数账到 BERT 和大模型
概念 KP 07.16
交叉注意力:解码器的"开卷回查"
一句话 Q 来自解码器当前状态,K 和 V 来自编码器输出,其余计算与自注意力一模一样。
PPT 第 99 页说"编码器-解码器注意力关注的是输入和输出之间的关系",指的就是交叉注意力(Cross-Attention)。解码器每层有三个子层:① 带掩码的自注意力(自己看自己已生成的部分);② 交叉注意力(回头查原文);③ 前馈网络。
它和自注意力的唯一区别是来源:Q 由解码器当前表示算出,K 和 V 由编码器输出 C 算出 。打分、缩放、softmax、加权求和全部一样。因为源句和目标句长度通常不同,交叉注意力的权重矩阵是长方形(目标长度 × 源长度);可视化出来常能看到清晰的对角线,那就是模型学到的词对齐。注意 K/V 是"只读"的:编码器输出不会在解码过程中改变,变的只是解码器自己的 Q。
生活类比 闭卷部分只能靠脑子(掩码自注意力);开卷部分题目要求"结合课本第 5 章回答",你可以随便翻书、定位、摘抄(交叉注意力)。书是只读的,你只能查不能改;而你的答卷一直在被自己改写。
易错 代码里把交叉注意力的入参写成 (x, x, x),它会静默退化成自注意力:形状照样对,效果等于完全不看原文。正确写法是 (x, enc_output, enc_output)。
10 秒自测 · 点开看答案
问题:交叉注意力的 Q、K、V 分别来自哪里?
答案:Q 来自解码器当前表示(我正在生成谁),K/V 来自编码器输出(我去原文哪里查)。一句话记:Q 永远问"我在处理谁",K/V 永远答"去哪里查"。
概念 KP 07.17
训练看全句,推理逐词吐:这个不对称从哪来?
一句话 训练靠 teacher forcing + 掩码一次算全句;推理靠自回归一次猜一个词。
训练阶段把正确答案整句喂进去,同时做两件事:移位(shifted right,输入去掉末位、监督去掉首位)保证"预测第 t 个词时只能看到前 t−1 个";因果掩码保证同一个 batch 里也看不到后面的位置。两件事合起来,模型可以一次性算出所有位置的预测 ,与正确答案逐位比对求损失,高度并行。
推理阶段没有答案可喂,只能:输入起始符 → 输出第一个词 → 把它接回去再喂 → 输出第二个词 → …… 直到输出结束符,这叫自回归(autoregressive)。因为每步都要重新前向,推理是串行的;工程上用 KV Cache 把前面算过的 K/V 缓存起来,每步只算新词。实验 5 里 5 轮训练 loss 从 6.7113 降到 3.3779,但输出仍是"– !",就是训练量不足的典型表现(实测)。
# 训练:目标句右移一位,输入与监督错开一个时间步
tgt_input = tgt_batch[:, :-1] # 去掉最后一位
tgt_expected = tgt_batch[:, 1:] # 去掉第一位:预测下一个词
logits = model(src_batch, tgt_input, tgt_mask=causal_mask)
loss = criterion(logits.reshape(-1, V), tgt_expected.reshape(-1))
# 推理:从起始符开始,一次只生成一个词
ids = [sos_id]
for _ in range(max_len - 1):
logits = model(src, torch.tensor([ids]))
nxt = logits[0, -1].argmax().item()
ids.append(nxt)
if nxt == eos_id:
break
生活类比 复习时(训练)你摊开全部答案和解析,一整套卷子同时过,哪题不会就看答案,速度快;考试时(推理)答案收走了,只能一题一题往下做,做完第 3 题才知道第 4 题能写什么。同一个能力,两种使用方式,速度天差地别。
10 秒自测 · 点开看答案
问题:训练时喂完整目标句,模型为什么不会"抄答案"?
答案:因为移位 + 因果掩码同时生效:输入里根本没有"当前要预测的那个词",未来位置又被 −1e9 屏蔽,模型只能凭前文和原文去猜。
训练与推理两条路径:训练并行看全句,推理逐词自回归。理解 Transformer 的很多细节都要从这对不对称出发。
公式 KP 07.18
参数账:钱到底花在哪?
一句话 一层约 315 万参数,FFN 占约三分之二;全模型约 6500 万,大头按 d² 算。
取 base 配置 d=512、d_ff=2048、h=8,把一层编码器拆开算:多头注意力的四个 512×512 矩阵加偏置共 1,050,624;FFN 的 512→2048→512 共 2,099,712;两个 LayerNorm 共 2,048;合计 3,152,384,约 315 万。其中 FFN 占了约三分之二,所以"模型变大"主要是在变宽 FFN。
全模型 6 层编码器 + 6 层解码器,解码器每层多一个交叉注意力(约 420 万/层),12 层合计约 4414 万;再加共享的词嵌入与输出层(按 3.7 万词表 × 512 约 1894 万),总量落在 6500 万这个量级,论文 base 版报告的正是 65M。参数大头按 d² 增长:d 从 512 提到 1024 参数量直接翻 4 倍,而层数翻倍只是翻 2 倍——宽度比深度更吃显存。
模块 构成 参数量
多头注意力 4 × (512×512 + 512) 1,050,624
前馈网络 (512×2048 + 2048) + (2048×512 + 512) 2,099,712
2 个 LayerNorm 2 × 2 × 512 2,048
单层编码器 以上合计 3,152,384(约 315 万)
单层解码器 两个注意力 + FFN + 3 个 LN 4,204,032(约 420 万)
6 + 6 层合计 —— 44,138,496
词嵌入(共享) 37,000 × 512 18,944,000
全模型 —— 约 6300 万(论文报 65M)
生活类比 装修报价你以为按房间数算,其实是按面积算:墙漆按平米、地板按平米、吊顶按平米。Transformer 的参数也按 d² 算,所以把宽度从 512 提到 1024,花销直接翻四倍。
10 秒自测 · 点开看答案
问题:为什么说 FFN 才是参数的大头?
答案:每个注意力有 4 个 d² 矩阵,FFN 有两个 d×4d 矩阵,相当于 8 个 d²;单层 12 个 d² 里 FFN 占 8 个,约三分之二。
概念 KP 07.19
BERT:只用 Encoder 的"双向阅读器"
一句话 多层双向 Transformer 编码器,输入是 Token、Segment、Position 三种嵌入之和。
PPT 第 104 页:BERT 的模型架构基于 Transformer 的多层双向编码器 ,所有层都联合上下文语境做预训练,因此比单向语言模型看得更全、语义理解更准。它只用了原图左边那半张(编码器),没有解码器;base 版为 12 层、768 维、12 头、约 1.1 亿参数(补充)。
输入构造有一个经典细节:Token Embeddings(词向量)、Segment Embeddings(区分句子 A/B)、Position Embeddings(位置)三种嵌入逐元素相加 成最终输入。[CLS] 放在开头,它最后一层的向量用于分类;[SEP] 放在句尾并分隔两个句子。BERT 分预训练(pre-train)与微调(fine-tune)两个阶段:预训练用海量无标注语料,微调用下游带标签数据,全部参数一起更新。
输入嵌入 作用
Token Embeddings 词本身的向量;第一个词是 [CLS],其最终向量用于分类
Segment Embeddings 标记属于句子 A 还是 B,服务句对分类等任务
Position Embeddings 位置信息;三种嵌入逐元素相加成输入
生活类比 BERT 像"先通读全文再答题"的考生:读的时候前后文都能看(双向),答题时把整篇文章的理解压缩到 [CLS] 这一个位置上。GPT 则像"只能从左往右读"的考生,读到一半不许翻后面。
易错 以为三种嵌入是拼接。BERT 是相加,维度保持 d_model 不变;另外 [CLS] 不是"句子向量"的天然定义,它是被训练出来承担分类职责的位置。
10 秒自测 · 点开看答案
问题:BERT 用的是 Transformer 的哪一部分?
答案:只用 Encoder(左边半张图),所以是双向的、不能直接做逐词生成;GPT/LLaMA 只用 Decoder,带因果掩码,天生适合生成。
概念 KP 07.20
自监督、MLM 与 NSP:BERT 怎么"自己出题"?
一句话 无标注语料自己挖空、自己换句:MLM 猜被遮的词,NSP 判断两句是否连续。
自监督学习(Self-supervised Learning) :手上只有一堆没有标注的数据,就把数据 x 分成两部分,一部分当输入 x′,另一部分当标签 x″,训练模型让输出逼近 x″。关键是 x″ 不是人标的,而是数据里本来就有的——BERT 正是这样利用海量无标签语料。
预训练由两个自监督任务组成。MLM(Masked Language Model,掩码语言模型)像完形填空:随机遮住一些词,让模型用上下文预测它。PPT 第 108 页的比例是 80% 替换为 [MASK]、10% 替换为随机词、10% 保持原词;被选中的比例通常是 15%(补充)。NSP(Next Sentence Prediction)判断句子 B 是不是句子 A 的下文:50% 保留真实连续的两句(IsNext),50% 从语料里随机抽一句(NotNext),这个关系存在 [CLS] 里。
MLM 的处理 比例 例子
替换为 [MASK] 80% my dog is [MASK]
替换为随机词 10% my dog is apple
保持原词不变 10% my dog is cute
生活类比 MLM 就是英语卷子上的完形填空:把一句话挖掉几个词,让你根据前后文填回来,填对了说明你懂语境。NSP 像把两段文章打乱后问"这两段原本是连着的吗",专门训练句子之间的关系理解。
易错 把 BERT 说成"预测下一个词"。从左到右预测下一个词是 GPT 式语言模型;BERT 的 MLM 是同时看左右两边填中间,所以叫双向。
10 秒自测 · 点开看答案
问题:MLM 为什么保留 10% 的原词不替换?
答案:缓解"预训练有 [MASK]、微调没有 [MASK]"的分布不一致,同时逼模型不能只靠"看到 [MASK] 才认真";10% 随机替换则防止模型只记住位置。
概念 KP 07.21
微调:一个 BERT 干四类任务
一句话 预训练学"语言",微调只换输出头,四类下游任务通吃。
微调(Fine-tuning)阶段用预训练好的 BERT 参数初始化,再把下游任务的带标签数据喂进去,所有参数一起小幅更新。因为底座已经懂语言,通常只需要少量数据和几个 epoch。PPT 第 111 页列出四类任务:单句子分类、句对分类、问答、序列标注。
换的只是"输出头"和输入拼接方式:[CLS] 向量接一个分类层就是单句分类;两句用 [SEP] 隔开、仍取 [CLS] 就是句对分类;问答让模型在段落里预测答案的起止位置;序列标注则对每个 token 的输出接标签。结构不用动,这正是预训练+微调范式的价值:一个底座,稍加改造适配一批任务。
任务类型 输入怎么拼 输出头 典型任务
单句子分类 [CLS] 句子 [SEP] [CLS] 向量 → 类别 情感分析
句对分类 [CLS] A [SEP] B [SEP] [CLS] 向量 → 类别 自然语言推理
问答 [CLS] 问题 [SEP] 段落 [SEP] 预测答案起止位置 抽取式问答
序列标注 [CLS] 句子 [SEP] 每个 token 一个标签 分词/词性/实体识别
生活类比 一把电动螺丝刀,换不同批头就能拧十字、六角、内六角。BERT 的预训练参数就是那把电钻,四类任务的输出头就是不同批头——电机不用重买,换个头就能干新活。
10 秒自测 · 点开看答案
问题:微调时需要把 BERT 全部参数重新随机初始化吗?
答案:不需要。用预训练权重初始化,再在下游数据上整体微调;重新随机初始化就等于丢掉了预训练学到的语言知识。
概念 KP 07.22
LLM 的三种架构与 LLaMA
一句话 Encoder-only 会读、Decoder-only 会写、Encoder-Decoder 读写都会;LLaMA 属于写的那类。
大语言模型(Large Language Model,LLM)指参数海量、能处理广泛语言数据的模型,除了生成、问答、摘要,还能写代码、写文章。PPT 第 113 页把当前 LLM 按 Transformer 的用法分成三类:Encoder-only(BERT 等)、Decoder-only(GPT、LLaMA 等)、Encoder-Decoder(T5、BART、GLM 等)。
以 LLaMA 为例(PPT 第 114 页):Decoder-only 架构,由 32 个 Block 堆叠;文本用 BPE 处理;位置编码用旋转位置编码 RoPE;每个子层用 RMSNorm 归一化;激活函数用 SwiGLU。它是在公开数据集约 1.4T token 上训练的,有 7B、13B、33B、60B 多个版本。
架构 代表模型 注意力方向 擅长
Encoder-only BERT 双向,看全句 理解、分类、抽取
Decoder-only GPT、LLaMA 因果,只看左边 生成、对话、推理
Encoder-Decoder T5、BART、GLM 双向编码 + 交叉注意力 翻译、摘要、序列转换
生活类比 同一款发动机(Transformer Block)装进轿车就是 Decoder-only,跑得快、能长途;装进货车就是 Encoder-only,拉得多、能干活;装进混动车就是 Encoder-Decoder,两种模式切换。发动机没变,变的是车身和变速箱(训练目标 + 掩码方式)。
10 秒自测 · 点开看答案
问题:LLaMA、BERT、T5 分别属于哪一类架构?
答案:LLaMA 是 Decoder-only,BERT 是 Encoder-only,T5 是 Encoder-Decoder。判断方法就看它需要哪半张图、用了什么掩码。
概念 KP 07.23
现代 Transformer 的六处改良(补充)
一句话 公式一个字没改,改的是归一化位置、位置编码、注意力共享与算子实现。
对照 2017 原版,今天的大模型至少有六处常见改动:① Pre-LN :把 LayerNorm 从子层之后挪到子层之前(x + Sublayer(LN(x))),深层训练更稳,通常不再需要小心翼翼地 warmup;② RoPE :用旋转位置编码替代正弦绝对编码;③ GQA/MQA :让多组查询头共享 K/V 头,大幅缩小 KV Cache;④ SwiGLU :用门控激活替代 ReLU 前馈;⑤ RMSNorm :只除以均方根、不减均值不加偏置,更省算力;⑥ FlashAttention :分块计算、不把完整 n×n 矩阵写进显存,数学上仍是精确注意力。
注意:这六处没有一处动了核心公式 ,softmax(QKᵀ/√d_k)V 从 2017 年到现在没变。变的都是"怎么算得更快更稳",所以吃透核心公式,再看 LLaMA、Qwen、DeepSeek 的结构图都不会陌生。
改良 原版 现在 解决什么
Pre-LN Post-LN 先 LN 再进子层 深层训练稳定
RoPE 正弦绝对编码 旋转 Q/K 相对位置与长上下文
GQA/MQA 每个头独立 K/V 多组头共享 K/V 减少 KV Cache 显存
SwiGLU ReLU 前馈 门控激活前馈 同样参数下效果更好
RMSNorm LayerNorm 只除均方根 更省算力
FlashAttention 显式 n×n 矩阵 分块 IO 感知计算 长序列显存与速度
生活类比 一栋 2017 年的老房子,承重墙和梁柱没动(= 注意力公式),这些年陆续换了断桥铝窗(Pre-LN)、加了地暖(RoPE)、把老电线换成铜线(SwiGLU)、装了中央空调(GQA)。住起来舒服多了,但它还是那栋房子。
10 秒自测 · 点开看答案
问题:Pre-LN 和 Post-LN 的区别一句话怎么说?
答案:Post-LN 是"先加残差再归一化"(论文原版),Pre-LN 是"先归一化再进子层、残差直通";后者梯度通路更干净,深层更稳。
7.5 五个实验:从一行注意力公式到端到端英法翻译
实验
LAB 07.1
实验 1 · 缩放点积注意力与多头机制
难度 ★★☆
对应实验 1 / 7.3 节自注意力
transformer-test.py
实验目的:手写缩放点积注意力(Scaled Dot-Product Attention),用三组能直接判真假的断言——每行权重和为 1、因果掩码后右上三角严格为 0、多头输出形状与参数量恒定——把多头注意力从黑盒拆成 view → transpose → matmul → softmax 四步的排列组合,并说清除以 √d_k 到底在压什么、掩码为什么必须加在 softmax 之前。涉及知识点:缩放点积、多头切分、masked_fill、广播、内存连续性。提交物是能跑通的输出加思考题回答,其中掩码后右上三角权重最大值与每行权重和必须给出具体数字,只写"运行成功"不算完成。
读代码:给 scaled_dot_product_attention 逐行写注释,标出四个动作——打分(QKᵀ)、缩放(÷√d_k)、掩码(softmax 之前填 −1e9)、归一化与加权求和;构造随机 q/k/v 形状 (2,8,6,32),mask=None 跑一次,打印 attn_weights 的形状应为 (2,8,6,6)。顺便打印缩放前后的 scores 最大值,体会除以 √d_k 把输入拉回了什么量级。
断言归一化:attn_weights.sum(dim=-1) 应全为 1(fp32 下误差在 1e-6 以内),确认 softmax 是沿最后一维做的,每个 (6,6) 矩阵行和为 1。
断言掩码:构造 6×6 下三角掩码 torch.tril(torch.ones(6,6)).unsqueeze(0).unsqueeze(0),验证三件事:(a) 右上三角权重最大值 0.000e+00,严格为 0;(b) 每行权重和仍为 1;(c) 第 3 个位置(索引 2)只有 3 个非零权重。
对照实验:去掉掩码重算一次,记录右上三角最大权重 4.804e-01,并解释它为什么不可能为 0——softmax 对包括"未来"在内的所有位置归一化,未来位置分到了真实的概率质量。
切法验证:把 num_heads 依次改成 1、4、8,确认输出形状恒为 (2,6,256)、每个 MultiHeadAttention 的参数量恒为 263,168,并记录三种切法对应的 d_k 与缩放因子:d_k=256 时 √256=16、d_k=64 时 √64=8、d_k=32 时 √32≈5.657。
def scaled_dot_product_attention(q, k, v, mask=None):
d_k = q.size(-1) # 每个头的维度
scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k)
if mask is not None: # 掩码必须在 softmax 之前
scores = scores.masked_fill(mask == 0, -1e9)
attn_weights = F.softmax(scores, dim=-1) # 每行和为 1
output = torch.matmul(attn_weights, v) # 对 V 加权求和
return output, attn_weights
# MultiHeadAttention.forward 里:切分与拼回必须严格镜像
q = self.q_linear(q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
concat = out.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
预期结果 实测(B=2, T=6, d_model=256, h=8, d_k=32):输入 (2,6,256) → q 投影后 (2,6,256) → view+transpose 后 (2,8,6,32) → 注意力分数 (2,8,6,6) → 拼回 (2,6,256)。因果掩码后右上三角权重最大值 0.000e+00,每行权重和全为 1(判 True),第 3 个位置的非零权重数为 3;去掉掩码后右上三角最大权重为 4.804e-01。num_heads 取 1/4/8 时输出形状都是 (2,6,256),参数量都是 263,168 = 4×(256×256+256)——头数只改变每头的 d_k 与缩放因子,不改变参数总量,这正是"多头不更贵"的实测依据。这三个数一旦对上,多头注意力就不再是黑盒,它只是 view、transpose、matmul、softmax 四步的排列组合;反过来,如果行和不是 1,先查 softmax 的维度写没写对,再查掩码是不是加在了 softmax 之后。
常见坑 ① 直接把 (B,T,256) reshape 成 (B,h,T,d_k):内存里的排列是"先时间后维度",直接 reshape 会把维度含义错位,形状对得上、数值全错;正确做法是 view(B,T,h,d_k) 再 transpose(1,2)。② transpose 后漏写 contiguous() 会报 view size is not compatible,这种反而好查;真正难查的是切分与拼回顺序不镜像——程序照跑、loss 照降,只是效果莫名差。③ 在 softmax 之后把掩码位置置 0:被屏蔽的概率质量被直接丢弃、而不是重新分配给可见位置,每行和小于 1,输出幅度整体缩小。④ 缩放写成除以 √d_model(√256=16)而不是 √d_k:softmax 的输入被压得过平,注意力分布接近均匀,模型学不到锐利的对齐关系;本脚本 d_k=32,正确缩放因子是 √32≈5.657。
思考题 · 点开看参考要点
思考题:掩码值为什么用 −1e9,而不是 0,也不是 −inf?
参考要点:填 0 时 exp(0)=1,掩码位置反而成了权重最大的位置,等于把"不许看"变成"优先看";−inf 数学上正确,但 fp16 下参与运算容易产生 nan,反向传播时 0×inf 会污染梯度;−1e9 在 fp32 下 exp 后下溢为 0,既严格屏蔽又安全。
实验
LAB 07.2
实验 2 · 前馈网络与正弦位置编码
难度 ★★☆
对应实验 2 / 7.2 节输入表示
transformer-test.py
实验目的:说清前馈网络(FFN)"先升维再降维"在做什么、为什么它是逐位置独立的;手算正弦位置编码并与实测表逐项对照;用置换等变的三组对照定量证明——顺序信息 100% 来自外部注入的位置编码,与注意力结构本身无关。涉及知识点:FFN、ReLU、sin/cos 频率、register_buffer、置换等变。提交物是手算过程(别人能照着复核)与三组对照的差异值,而不是一张"跑通"的截图。
手算对照:按 PE(pos, 2i) = sin(pos / 10000^(2i/d_model))、PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model)),算 pos=1、d_model=8 的前 4 维:第 0 维 sin(1)≈0.8415、第 1 维 cos(1)≈0.5403、第 2 维 sin(1/10)≈0.0998、第 3 维 cos(0.1)≈0.9950,再与实测表逐项核对(d_model=8 时 10000^(2/8)≈10)。
置换等变(不加 PE):按 [3,1,0,4,2] 打乱 5 个位置的输入,记录纯自注意力打乱前后的输出差异,实测 5.960e-08——这只是浮点噪声,说明自注意力对顺序完全无感。
置换等变(加 PE):用同样的顺序打乱输入、但不打乱 PE,记录差异跳到 7.067e-02,与上一步跨了六个数量级;再把 PE 也按同样顺序一起打乱,差异应回到 1e-8 量级,这一步排除了"注意力结构本身隐含位置信息"的替代解释。
FFN 独立性:构造一个 batch,除第 3 个位置外其余位置完全相同,验证 FFN 在第 0 个位置的输出完全一致——差异应为严格的 0(不是 1e-8 量级),因为 FFN 对每个位置单独作用,位置之间的信息交换全部由注意力负责。
宽度消融:把 d_ff 从 2048 改成 1024 与 512,记录参数量与 5 轮后的 loss。实测砍半对 loss 影响很小:在 200 条数据上,瓶颈是数据量与训练量,不是 FFN 宽度。记录两层编码器总参数 2,630,144 随之变化,才能判断"钱花在哪、该不该省"。
class PositionalEncoding(nn.Module):
def __init__(self, d_model=512, max_len=5000):
super().__init__()
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float()
* (-math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term) # 偶数维用 sin
pe[:, 1::2] = torch.cos(position * div_term) # 奇数维用 cos
self.register_buffer('pe', pe.unsqueeze(0)) # 常量、不训练、随设备迁移
def forward(self, x):
return x + self.pe[:, :x.size(1)] # 只取实际长度那一段
# 词嵌入先乘 √d_model 再相加,否则位置信号被词向量淹没
x = self.pos_embed(self.embedding(src) * math.sqrt(self.d_model))
预期结果 位置编码实测(d_model=8,只看前 6 维):pos=0 是 +0.0000 +1.0000 +0.0000 +1.0000 +0.0000 +1.0000;pos=1 是 +0.8415 +0.5403 +0.0998 +0.9950 +0.0100 +0.9999;pos=2 是 +0.9093 −0.4161 +0.1987 +0.9801 +0.0200 +0.9998;pos=3 是 +0.1411 −0.9900 +0.2955 +0.9553 +0.0300 +0.9996。低维变化快(第 0 维从 0 跳到 0.84 再跳 0.91),高维变化慢(第 4 维到 pos=3 才 0.03);pos=0 与 pos=1 的余弦相似度 0.8838、L2 距离 0.9641,相邻位置"像但不同"。置换等变:不加 PE 打乱差异 5.960e-08,加 PE 差异 7.067e-02,PE 一起打乱回到 1e-8;FFN 第 0 位置差异 0.000e+00。d_ff 对照(d_model=256):2048 时单层 FFN 1,050,880、两层编码器总 2,630,144;1024 时 525,568 / 1,579,520;512 时 262,912 / 1,054,208。FFN 占两层编码器约 80% 的参数,是容量的主要来源。还有一点要写进报告:词嵌入必须先乘 √d_model(本脚本 √256=16)再与位置编码相加,否则 PE 的 ±1 会被 N(0,1) 的词向量噪声盖住,位置信号等于白加;这个缩放不是可选的美化项,而是让两者量级匹配的前提。
常见坑 ① 分母写成 10000^(2i)(漏掉除以 d_model):频率跨度爆炸,高维项几乎立刻饱和;正确写法是 10000^(2i/d_model),也就是代码里 exp 与 log 的等价形式。② 全用 sin、或 sin/cos 的奇偶写反:相对位移无法再用线性变换表示,位置信号表达能力大打折扣。③ pe 写成普通属性:CPU 上无感,上 GPU 直接报 device mismatch;写成 nn.Parameter 又会白白多出几兆可训练参数。④ 漏乘 √d_model:词嵌入初始化是 N(0,1)、位置编码值域是 [−1,1],两者量级不匹配,位置信号被词向量淹没。⑤ 把 PE 的 max_len 参数设成 20(而不是默认的 5000):测试稍长一点的句子就越界;反过来 5000×256×4 字节约占 5MB 内存,显存紧张的小设备可以只留够用的长度,但要留足余量(序列长度是动态的,硬编码成 20 会出事)。
思考题 · 点开看参考要点
思考题:如果位置编码全设成 0(等于不加),"猫追狗"和"狗追猫"在模型眼里有什么区别?
参考要点:没有区别。自注意力只比较向量内容、对顺序无感,两句话的 token 集合相同,输出只是位置互换、内容完全一致(实测差异 5.960e-08 就是量化证据),而这两句话语义相反——这就是位置编码是必需项而不是优化项的原因。
实验
LAB 07.3
实验 3 · 编码器-解码器堆叠与三段注意力
难度 ★★★
对应实验 3 / 7.2 节整体架构
transformer-test.py
实验目的:把注意力、FFN、位置编码装成 EncoderLayer → Encoder → DecoderLayer → Decoder → TransformerSeq2Seq;用形状断言、参数量核算与 ln(词表) 基准线三种手段自证实现没写错;重点说清解码器三段子层的 Q/K/V 分别来自哪里——这是本章最容易被问倒的地方。涉及知识点:Post-LN 残差、掩码自注意力、交叉注意力、输出投影、参数量核算。验收标准是三个数:logits 形状、总参数量、第一次前向 loss,三者都必须能和理论值对上。
跑通前向:构造随机 batch(B=4、T_src=20、T_tgt=19),确认 logits 形状 (4,19,1656)、模型总可训练参数 7,039,864,并把 src、tgt、enc_output、dec_output、logits 五个形状依次记进实验记录。
三段 Q/K/V:在 DecoderLayer.forward 里加打印,逐层记录三个子层的 Q、K、V 来源与形状——① 掩码自注意力的 Q/K/V 都来自解码器当前表示,掩码为下三角 tgt_mask;② 交叉注意力的 Q 来自解码器、K/V 来自编码器输出 enc_output,本脚本的 src_mask 传的是 None;③ FFN 逐位置独立,没有 Q/K/V。填完后与实验记录里的三段表逐格核对——写错一格的典型后果,是交叉注意力静默退化成自注意力。
基准线对照:随机初始化、未训练时跑一次前向,单步 loss 应接近"均匀瞎猜"的理论值 ln(1656)=7.4122,实测 7.5141,只高 0.1——说明初始化正常、输出层没有实现错误。反过来用这个检查更快:若第一次前向 loss 是 2.0 左右,查 tgt 是否没右移或掩码没加;若是 15.0,查 logits 是否被错误缩放。
因果掩码消融:把 tgt_mask 改成 None 训练 5 轮,观察 loss 是否异常低(解码器能直接看到未来、等于偷看答案),再推理看输出是否崩坏——这是"训练时完美、推理时崩"的典型形态。
参数量核算与权重绑定:逐项核对单层编码器 MHA 263,168 + FFN 1,050,880 + 两个 LayerNorm 1,024 = 1,315,072,两层 2,630,144,加词嵌入 401,664 与末端 LN 512 得 3,032,320;解码器 3,581,952;输出投影 425,592,合计 7,039,864。再把 projection.weight 绑到 decoder.embedding.weight,参数量降到约 6,614,272,重训 5 轮看 loss 是否掉点。
def forward(self, x, enc_output, src_mask=None, tgt_mask=None):
# ① 掩码自注意力:Q/K/V 都是解码器当前表示,只能看已生成的位置
x = self.norm1(x + self.dropout(self.masked_mha(x, x, x, tgt_mask)))
# ② 交叉注意力:Q 来自解码器,K/V 来自编码器输出(原文只读)
x = self.norm2(x + self.dropout(self.cross_mha(x, enc_output, enc_output, src_mask)))
# ③ 前馈网络:逐位置独立,位置之间不交互
x = self.norm3(x + self.dropout(self.ffn(x)))
return x
# 完整封装:编码 → 解码 → 输出投影,输出 raw logits(不带 softmax)
enc_output = self.encoder(src, src_mask) # (B, T_src, 256)
dec_output = self.decoder(tgt, enc_output, src_mask, tgt_mask) # (B, T_tgt, 256)
return self.projection(dec_output) # (B, T_tgt, 1656)
预期结果 实测(随机初始化、未训练,d_model=256、2 层、8 头、d_ff=2048):src (4,20)、tgt (4,19)、enc_output (4,20,256)、dec_output (4,19,256)、logits (4,19,1656);可训练参数 7,039,864;单步 loss 7.5141,与均匀瞎猜的理论值 ln(1656)=7.4122 几乎重合。参数量逐项可核:编码器 3,032,320 = 词嵌入 401,664 + 两层 2,630,144 + 末端 LN 512;解码器 3,581,952 = 词嵌入 423,936 + 两层 + 末端 LN;输出投影 425,592。绑权重后参数量约 6,614,272,loss 不掉点。三段子层填表结果:① 三处都是解码器表示 + 下三角掩码;② Q 解码器、K/V 编码器 + src_mask=None;③ 无 Q/K/V、逐位置。单层解码器参数量可自己核一遍:两个 MHA 526,336 + FFN 1,050,880 + 三个 LayerNorm 1,536 = 1,578,752,比单层编码器的 1,315,072 多出一个注意力——解码器更贵就贵在这里。这张三段表与参数量账要能当场复述:Q 永远是"我正在处理谁",K/V 永远是"我去哪里查",而 7,039,864 每一个数字都说得出来源。
常见坑 ① 交叉注意力写成 (x, x, x):形状照样对,静默退化成自注意力,等于完全不看原文——这类错误不会报错,只会让 BLEU 怎么调都上不去。② 输出投影后再接 softmax 再算交叉熵:nn.CrossEntropyLoss 内部自带 log_softmax,等于重复归一化,梯度被压缩;现象是 loss 一开始就卡在某个值不动。③ 层堆叠用普通 list 而不是 nn.ModuleList:参数不注册进模型,optimizer 看不到,loss 纹丝不动。④ Post-LN 写成 x + norm(sublayer(x)):与论文原版的 norm(x + sublayer(x)) 不符,2 层还能收敛,加深到 12 层很可能前期发散。⑤ src_mask 一直传 None:编码器不屏蔽 <pad>,填充位的表示会混入真实语义,交叉注意力还可能把对齐能力浪费在填充位上;修法是传填充掩码 (src != pad_id)。200 条数据、平均句长 21.27 词而 max_len=20,每批里 pad 占比不低,这个影响不能忽略。
思考题 · 点开看参考要点
思考题:为什么解码器需要三次 LayerNorm,而编码器只要两次?
参考要点:Post-LN 是每个子层之后各做一次——编码器两个子层(自注意力、FFN),解码器三个子层(掩码自注意力、交叉注意力、FFN)。改成 Pre-LN 后归一化挪进子层内部(x + sub(norm(x))),次数不变但位置不同,末端那一次整体 LayerNorm 变成可选。
实验
LAB 07.4
实验 4 · 词级分词器与数据流水线体检
难度 ★★★
对应实验 4 / 数据层
transformer-test.py
实验目的:读懂 SimpleTokenizer 的四个特殊符号与 build_vocab / encode / decode 三个方法;养成"先给数据做体检"的习惯——看长度分布、截断率、OOV 率;定位数据层埋的三处静默坑。它们的共同特征是:程序不报错,只是结果差得没有道理。涉及知识点:词表构建、特殊符号、max_len 截断、teacher forcing 移位、ignore_index。提交物是你自己这批数据的截断率与 OOV 率——数字必须来自实测,不能照抄手册。
跑分词器:记录 "The Wanderer"、"First Part"、"It was a bright cold day in April" 三条的 ids 与回译结果。前两条往返只差大小写;第三条里 bright 与 april 变成 <unk>(id=3),因为它们是语料外的词——这说明"OOV=0.00%"只对训练语料本身成立。
数据体检:统计这批 200 条句对的平均词数、最长词数、被 max_len=20 截断的比例。实测英文平均 21.27 词、最长 119 词,92 条被截断(46.0%);法文平均 20.80 词、最长 113 词,84 条被截断(42.0%);同源测试下 OOV 英法都是 0.00%。平均句长已经超过上限,近一半句子被切掉尾巴,把平均词数、最长词数、截断率三个数写进记录,作为后续所有改动的对照基线。
截断埋雷:构造一个 25 词的句子,验证 <eos> 是否还在序列里。实测长度 20、末位 id 1043、eos id=2 不在序列里;把 encode 改成保留首尾 ids[:1] + ids[1:max_len-1] + ids[-1:],重跑确认 eos 是否保留由 False 变为 True。
移位造 target:用 [1,5,7,2,0] 手写一遍切片,确认 tgt_input 为 [1,5,7,2]、tgt_expected 为 [5,7,2,0];再检查 DataLoader 输出的 batch 形状——src (4,20)、tgt (4,20),移位后各为 (4,19),监督序列比输入序列少一位。
查 ignore_index:确认损失函数用的是目标端词表的 pad 编号 fr_tokenizer.vocab["<pad>"],而不是源端的。本脚本两端 pad 碰巧都是 0 所以没出错;换一个特殊符号编号不同的分词器,就会静默地把真实词当填充忽略,或者把填充当真实词算损失。
def encode(self, text, max_len=20):
tokens = [self.sos_token] + text.lower().split() + [self.eos_token]
ids = [self.vocab.get(w, self.vocab[self.unk_token]) for w in tokens]
if len(ids) < max_len:
ids += [self.vocab[self.pad_token]] * (max_len - len(ids))
else:
ids = ids[:max_len] # 坑 1:硬截断会把末尾的 <eos> 切掉
return ids
# 修法:保留首尾、只截中间,保证 <eos> 一定在序列里
ids = ids[:1] + ids[1:max_len - 1] + ids[-1:] # sos 留、中间截、eos 留
# 移位:输入去尾、监督去头,错开一位
tgt_input = tgt_batch[:, :-1] # [1, 5, 7, 2]
tgt_expected = tgt_batch[:, 1:] # [5, 7, 2, 0]
预期结果 分词器实测(max_len=20):"The Wanderer" → [1,4,5,2,0,0,…],回译 the wanderer;"First Part" → [1,7,8,2,0,0,…],回译 first part;"It was a bright cold day in April" → [1,276,68,17,3,358,359,50,3,2,0,…],回译 it was a <unk> cold day in <unk>。25 词句子硬截断后长度 20、末位 id 1043、eos 不在(False),修好后变为 True。体检汇总:词表 1,569(英)/1,656(法),平均 21.27/20.80 词,最长 119/113 词,截断 46.0%/42.0%,同源 OOV 0.00%。移位示例 [1,5,7,2,0] → 输入 [1,5,7,2]、监督 [5,7,2,0]。词表偏大的原因之一在分词方式:text.lower().split() 是纯空格切分,标点会粘在词上,"wanderer," 与 "wanderer" 是两个不同词条;200 条句对就能建出 1,656 个法文词条,对这样的数据量已经不算小。
常见坑 ① 硬截断 ids[:max_len]:词数 ≥ max_len−1 时,末尾的 <eos> 被切掉,监督信号里再也没有"该停了",模型学不会在合适位置停止——这是实验 5 输出"– !"最可能的直接原因之一。② ignore_index 跨词表引用编号:本脚本两端的 pad 都是 0 才碰巧没事。③ 在全量数据上建词表再切分训练/测试:OOV 恒为 0,指标虚高,换一批没见过的句子立刻暴露大量 <unk>;正确做法是词表只在训练集上建。④ 移位写成 tgt_input = tgt_expected:loss 能降到 0,但模型只学会抄当前位置的输入,推理时完全不生成。⑤ 忘了统计 pad 占比:短句被补到 20 位,若再不给编码器传填充掩码,这些 <pad> 会参与注意力、稀释真实位置的权重;体检时把"截断率"和"pad 率"一起报出来更完整。
思考题 · 点开看参考要点
思考题:把 max_len 从 20 改成 50,会发生什么?
参考要点:三件事——截断率从 46% 降到接近 0(最长 119 词仍会截断,但绝大多数句子能完整保留);计算量增加,注意力是 O(T²),20→50 是 6.25 倍;pad 占比下降、有效信息密度提高。对当前实验这是收益最高的改动之一,但要和修 eos、加数据量一起做,只改一处输出仍然是"– !"。
实验
LAB 07.5
实验 5 · 训练、自回归解码与结果诊断
难度 ★★★
对应实验 5 / 7.4 节训练与推理
transformer-test.py
实验目的:跑通完整训练循环,用困惑度把 loss 翻译成"平均还有多少个词分不清";手写自回归贪心解码;最核心的是学会从"– !"这类异常输出反推配置问题——这一节的任务不是调出好结果,而是把原因说清楚。涉及知识点:Adam、交叉熵、ignore_index、贪心解码、困惑度、欠拟合判断。提交物是 5 轮 loss 与两个样本的预测,再加四原因诊断——只写"运行成功"同样不算完成。
完整跑一遍:记录 5 轮平均 loss 与两个测试样本的预测,与手册表格对照。配置为 Adam、lr=1e-3、batch=4、5 轮共 250 步,纯 CPU 全程约 41 秒。
loss 解读:把每轮 loss 换算成困惑度 exp(loss),说明第 5 轮"平均还有约 29 个候选词分不清";同时以 ln(1656)=7.4122 作为"均匀瞎猜"基准线——第一轮 6.7113 已经低于它,说明模型确实在学,而不是没动。
自回归解码:从 <sos> 起循环,每步把已生成序列重新喂回解码器,只取最后一位 logits 的 argmax,遇 <eos> 或达到上限就退出;同时记录每步耗时,理解"为什么每生成一个词都要重算整段目标序列"——以及没有 KV Cache 时,这一步为什么省不掉。另记两点解读:两个样本输出相同并不奇怪,它们都很短、都含生僻词,欠拟合的模型倾向输出高频标点;第 2 条的目标值是人名本身,模型连"照抄人名"都没学会,进一步印证是训练量问题而不是结构问题。
训练量消融(收益最高):epoch 从 5 改成 20、数据从 train[:200] 改成 train[:1000](可同时把 max_len 提到 50),再观察 loss 与输出是否出现真实法语词——这是本册最值得做的一个任务。
诊断输出:先记录贪心与束搜索(beam=3)的对比,再按四原因表逐条给出证据与改法:训练步数只有 250、46% 的样本 eos 被截断、词表与测试集同源、测试样本本身是书名与作者名而不是句子。
model.eval()
with torch.no_grad(): # 推理不需要梯度
src_tensor = torch.tensor([src_ids]).to(device)
tgt_ids = [fr_tok.vocab["<sos>"]] # 从起始符开始
for _ in range(max_len - 1):
tgt_tensor = torch.tensor([tgt_ids]).to(device)
L = tgt_tensor.size(1)
tgt_mask = torch.tril(torch.ones(L, L)).unsqueeze(0).unsqueeze(0)
logits = model(src_tensor, tgt_tensor, tgt_mask=tgt_mask)
next_token = torch.argmax(logits[0, -1, :]).item() # 只看最后一位
tgt_ids.append(next_token)
if next_token == fr_tok.vocab["<eos>"]: # 遇结束符即停
break
预期结果 实测(CPU,约 41 秒):5 轮平均 loss 为 6.7113 → 6.1065 → 5.5422 → 4.4826 → 3.3779,对应困惑度 821.6 → 448.8 → 255.2 → 88.5 → 29.3。两个测试样本的预测都是"– !":"The Wanderer"(参考译文 Le grand Meaulnes)与 "Alain-Fournier"(参考译文 Alain-Fournier)都只生成标点。loss 每轮稳定下降(−0.60 / −0.56 / −1.06 / −1.10),说明梯度通路、掩码、损失函数都对;换成 beam search(beam=3)后输出仍接近"– !",说明瓶颈不在解码策略而在训练量。本脚本没有内置 BLEU 计算(补充):要报翻译质量分得自己接一个;但这次更该交的是四原因诊断,别用"BLEU 低"代替原因分析。三个必须给出具体数字的硬指标:5 轮 loss(6.7113 到 3.3779)、两个样本的预测(均为"– !")、每轮困惑度(821.6 到 29.3)。
常见坑 ① 把"loss 降了"当成"学会了翻译":3.3779 只说明学到了训练集的词频分布,一个法语实词都没生成;判断翻译质量要看输出或 BLEU,loss 只是必要条件不是充分条件。② 推理漏掉 model.eval() 或 torch.no_grad():Dropout 仍生效、计算图持续构建,显存涨、结果不稳。③ 只判 <eos> 不判上限:eos 信号被截断弄坏后模型不吐 eos,解码会死循环。④ 三种典型失败要分开归因——输出立刻是全 <eos>/空串,查 eos 信号是否被截断弄坏;反复输出同一个词,是贪心解码的循环陷阱,可换 beam search 或加 repetition penalty;长度异常、越解码越飘,查 max_len 与训练量是否都太小,别一律说成"模型坏了"。⑤ 把 lr 从 1e-3 改成 1e-5(照抄 BERT 微调配置):loss 几乎不动,5 轮可能只降 0.1;从零训练的小模型需要大得多的步长,而开到 1e-1 又会震荡甚至发散——1e-3 才是这个规模合适的值。
思考题 · 点开看参考要点
思考题:如果只允许改一处配置来提升效果,改哪个?
参考要点:改训练量——数据 200→2000、轮数 5→30。实测第 4→5 轮还降了 1.10,loss 远未收敛,当前最直接的瓶颈是训练量而不是结构;修 eos 截断是"让模型学会停"的前提,两件一起做效果最好,而结构一个字都不用改。
7.6 进阶专题:算力账、模型家族与工程优化
公式 KP 07.24
注意力复杂度手算:n=2048、每头 64 维,矩阵到底多大?
一句话 n=2048、d_k=64 时,一张 n×n 分数矩阵就有 419 万个数,单头 fp16 占 8 MB。
O(n²d) 有三个来源:QKᵀ 是 (n×d_k) 乘 (d_k×n),要 n²·d_k 次乘加,产出 n×n 的分数矩阵;softmax 要逐个处理这 n² 个数;再乘 V 又花 n²·d_k。h 个头合计约 2n²d,而 Q/K/V 投影只有 4nd²:短句时投影占主导,序列一长注意力项就压倒一切。
取 n=2048、d_k=64:n²≈419 万个数,单头 fp16 占 8 MB,8 头一层 67 MB,12 层约 805 MB(示例估算)。n 翻倍,矩阵面积和显存都变 4 倍——这就是长上下文又慢又吃显存的根。
序列长度 n n×n 个数 单头 fp16 相对 n=2048
512 262,144 0.5 MB 1/16
1,024 1,048,576 2 MB 1/4
2,048 4,194,304 8 MB 1
8,192 67,108,864 128 MB 16
128K 17,179,869,184 32 GB 4,096
易错 把 n² 和 d² 搞混。注意力矩阵的大小只由序列长度 n 决定,与 d 无关;d 决定的是每个数的计算成本和 Q/K/V 的宽度。长上下文吃显存,吃的是 n²,不是 d。
10 秒自测 · 点开看答案
问题:序列长度从 2048 翻到 4096,注意力的计算量和显存各变几倍?
答案:都变 4 倍。分数矩阵元素数是 n²,计算量 O(n²d) 也按 n² 增长。这就是长上下文必须上 FlashAttention、稀疏注意力等"给 n² 打折"手段的原因。
概念 KP 07.25
把位置编码画出来:为什么几条波形就能表达相对距离?
一句话 低维是密集的快速波纹,高维是缓慢的长波;任意两位置的编码内积只由它们的距离决定。
把 d=512、pos=0…100 的 PE 画成热力图:每行一个位置、每列一个维度,会看到左侧明暗交替得像条形码,越往右条纹越宽,最右几列几乎是一条竖着的单色带。因为每一维就是一条正弦波,波长 λᵢ=2π·10000^(2i/d):第 0 维约 6.3 个位置转一圈,第 256 维要转约 628 个位置。
位置每挪一格,低维相位跳得多、高维跳得少,256 对快慢不同的波叠起来,几乎不会给两个位置发出同一枚指纹。更关键的是,任意两个位置编码的内积只与距离有关、与绝对位置无关——这就是它能表达相对位置的数学依据(补充)。
维度 0
维度 128
维度 256
位置 pos 0
64
维度 0:波长≈6.3(快) 维度 128:≈63(中) 维度 256:≈628(慢)
图注:三个维度的正弦位置编码波形(示意)。维度 0 在 64 个位置内转了约 10 圈;维度 128 约 1 圈;维度 256 连 1/10 圈都不到。
易错 把热力图的横轴当成时间。横轴是维度索引、纵轴是序列位置 pos:同一列看的是"这一维随位置怎么变",同一行才是一个词的完整位置指纹。
10 秒自测 · 点开看答案
问题:波形为什么能编码"相对位置",而不是只能编码绝对位置?
答案:三角函数的和角公式让位置平移 k 等价于每一对 (sin, cos) 子空间旋转一个固定角度 Δ=k/10000^(2i/d);旋转不改变两向量的夹角关系,所以内积只依赖 k。
公式 KP 07.26
Pre-LN 与 Post-LN:只把归一化挪了一步,训练稳定性差在哪?
一句话 论文原版先加残差再归一化,现代大模型先归一化再进子层,后者的梯度通路更干净。
原论文(Post-LN)每层写 y = LayerNorm(x + Sublayer(x)):子层输出与 x 相加后再归一化。现代大模型(Pre-LN)改成 y = x + Sublayer(LayerNorm(x)):先归一化再进子层,残差是纯加法。两者结构几乎相同,区别只在归一化有没有卡在残差高速路上。
Post-LN 的每个残差节点都要穿过一次 LayerNorm,深层时输出层附近的梯度尺度会被逐层放大,训练初期容易发散,所以必须配 warmup。Pre-LN 的梯度可以沿加法一路乘 1 回传,尺度与深度基本无关,warmup 可以缩短甚至去掉,代价是最后通常要补一个 final LayerNorm(补充)。
Post-LN(原论文) y = LN(x + Sublayer(x))。需 warmup,深层易发散;有研究认为同等预算下调好 warmup 后最终精度可能更高(补充)。
Pre-LN(现代默认) y = x + Sublayer(LN(x))。残差直通、训练稳、可省 warmup;GPT-2、LLaMA 等采用,常配 final LN(补充)。
易错 以为 Pre-LN 全面更好。它换来的是"容易训",不是"一定更强":Pre-LN 的表达可能更钝,部分工作会在最后补 final LN 对齐尺度;选型要看深度和训练预算,而不是无脑站队。
10 秒自测 · 点开看答案
问题:为什么 Post-LN 特别依赖 warmup?
答案:它的残差通路被 LN 切断,深层梯度尺度随深度放大。训练初期参数随机、方向不稳,大学习率容易一步走飞,warmup 就是用逐步抬升的学习率避开这段危险期。
面试 KP 07.27
四条训练技巧:warmup、label smoothing、dropout、梯度裁剪
一句话 warmup 防起步摔,label smoothing 防话说太满,dropout 防死记,裁剪防梯度起飞。
四条技巧各治一种病。warmup:学习率从 0 线性升到峰值(原论文 4000 步)再按 1/√step 衰减,因为初期 Adam 的二阶矩估计还不准,大学习率容易一步走飞。label smoothing:把 one-hot 目标改成正确类 1−ε、其余类均分 ε,论文取 ε=0.1,防止 logit 越推越大、模型过度自信。dropout:对子层输出、嵌入加位置、注意力权重按 0.1 随机置零,推理时关闭。梯度裁剪:把梯度范数限制在 1.0,超过就等比缩小,专治少数 batch 的梯度尖峰(补充)。
易错 以为 label smoothing 只影响训练、不动指标:它明确压低正确 token 的目标概率,所以语言模型的困惑度(PPL)通常会变差,但生成更稳、翻译 BLEU 反而升——两个指标方向不一致是正常现象。
10 秒自测 · 点开看答案
问题:warmup 是不是越长越好?
答案:不是。步数太长会让模型长期停在小学习率、浪费训练预算。4000 步是原论文 base 模型在约 10 万步总预算下的经验值,换了模型和数据要重新调。
概念 KP 07.28
BERT 家族:RoBERTa、ALBERT、DistilBERT 各补了哪一刀?
一句话 RoBERTa 说 BERT 没训够,ALBERT 让它变瘦,DistilBERT 让它变快。
RoBERTa(2019):拿掉 NSP,把静态掩码改成每个 epoch 重抽的动态掩码,batch 提到 8K、语料从 16GB 扩到 160GB;结论是 BERT 严重欠训练,同架构跑足就能超过原版。ALBERT:嵌入层做矩阵分解(V×H → V×E + E×H),所有层共享同一套参数,NSP 换成句子顺序预测(SOP);ALBERT-base 约 1200 万参数,约为 BERT-base 的 1/9(补充)。DistilBERT:从 BERT-base 蒸馏出 6 层学生,6600 万参数、少 40%,推理快约 60%,保留约 97% 的 GLUE 表现(补充)。
模型 核心改动 参数量 一句话结论
RoBERTa 去 NSP、动态掩码、更多数据与更久训练 base 约 1.25 亿 同架构跑足即可超过 BERT
ALBERT 嵌入分解 + 跨层参数共享 + SOP base 约 1200 万 参数大减,但单层计算不变
DistilBERT 从 BERT-base 知识蒸馏、只留 6 层 约 6600 万 快约 60%,留约 97% 效果
易错 把 ALBERT 的"跨层参数共享"理解成"算一次复用 12 次":每一层仍然各算一次,只是用的权重相同,计算量不变、参数量变成约 1/12,所以它省显存不省算力。
10 秒自测 · 点开看答案
问题:ALBERT 参数骤降,为什么前向 FLOPs 没有同比下降?
答案:共享只压缩参数,不改变每层要做的矩阵乘;嵌入分解也只缩小了查表矩阵。ALBERT 是"瘦身"而非"提速"。
概念 KP 07.29
GPT-1/2/3:规模涨了约 1500 倍,路线始终是"自回归 + 零样本"
一句话 架构几乎没变,变的是层数、维度、数据和"不改参数直接用"的用法。
GPT-1(2018):12 层、d=768、1.17 亿参数,先在 BooksCorpus 上生成式预训练,再在下游任务上微调,证明"预训练 + 微调"走得通。GPT-2(2019):最大 48 层、d=1600、15.4 亿参数,语料换成 40GB 的 WebText,不再微调——把任务写成提示,靠零样本直接做。GPT-3(2020):96 层、d=12288、1750 亿参数、约 3000 亿 token,把上下文学习做成核心能力(补充)。
从 1.17 亿到 1750 亿,规模涨了约 1500 倍,但架构没变:都是 Decoder-only、都用前一个词预测下一个词。GPT 路线押的是"足够大的自回归模型 + 提示"。
模型 年份 层数 / d_model 参数量 使用方式
GPT-1 2018 12 / 768 1.17 亿 预训练 + 下游微调
GPT-2 2019 48 / 1600 15.4 亿 零样本提示
GPT-3 2020 96 / 12288 1750 亿 少样本上下文学习
易错 把"零样本"理解成"不需要数据":预训练仍要海量无标注文本,零样本只是下游任务不再给标注样本;真正付出的是预训练成本,不是省掉了数据。
10 秒自测 · 点开看答案
问题:GPT-3 和 GPT-1 的本质区别是架构吗?
答案:不是。两者都是 Decoder-only 自回归、下一词预测;区别在规模、数据和调用方式——GPT-1 靠微调迁移,GPT-3 在 prompt 里给例子即可完成任务。
概念 KP 07.30
T5、BART、GLM:三种 Encoder-Decoder 分别怎么"出题"?
一句话 T5 挖空补全,BART 先破坏再复原,GLM 按自回归方式填空。
三者都是 Encoder-Decoder,差别在预训练目标。T5:所有任务统一成"文本进、文本出",预训练用片段挖空——随机把约 15% 的连续片段换成哨兵符 <extra_id_i>,解码器只生成被挖掉的片段。BART:去噪自编码器,用掩码、删除、打乱句子、旋转文档等方式破坏原文,再让解码器逐词重建整句,更擅长生成。GLM:自回归填空,上下文双向可见,被挖掉的片段按随机顺序、一段段自回归生成,因此同时具备双向理解和生成本领(补充)。
模型 预训练目标 如何破坏输入 解码端生成什么
T5 片段挖空 连续 span 换成哨兵符 只生成被挖掉的片段
BART 去噪重建 掩码、删除、打乱、旋转 重建整句
GLM 自回归填空 span 挖空后按随机顺序 逐段自回归填空
易错 把 T5 和 BART 都笼统叫"去噪"就以为一样:T5 解码器只输出被挖掉的短片段,省解码算力;BART 要重建整篇,训练信号更全但解码更长。选型时这决定了谁更省、谁更擅长长文生成。
补充 KP 07.31
MoE:为什么 DeepSeek 能做到 671B 参数、只算 37B?
一句话 把 FFN 拆成 N 个专家,每个 token 只走 top-k 个:参数按 N 涨,算力只按 k 涨。
Transformer 的参数大头在 FFN。MoE(Mixture of Experts,混合专家)把每层 FFN 换成 N 个独立专家 + 一个路由器:路由器给每个 token 打分,只选 top-k 个专家计算,再按门控权重加权求和。于是参数量约按 N 增长(显存要装下全部专家),每个 token 的 FLOPs 却只按 k/N 增长,参数与计算就此解耦。
DeepSeek-V2 总参数 236B、每 token 激活 21B;DeepSeek-V3 总参数 671B、激活 37B,用 1 个共享专家 + 256 个路由专家、每 token 只激活其中 8 个(补充)。代价是负载不均与通信:热门专家被挤爆、冷门专家闲置,专家并行还要付 all-to-all 带宽。
生活类比 大医院有上百个专科(参数量大),但病人先经分诊台(router)分到最对口的 8 个科室,只走这几科(单 token 算力小)。医院可以铺得很大,单次看病的成本却不由科室总数决定。
易错 以为 MoE 省显存:它省的是每 token 的算力和带宽,不是显存——所有专家都得装进去,671B 参数按 fp16 存仍要约 1.3TB。MoE 换的是"同一算力预算下塞进更多参数"。
10 秒自测 · 点开看答案
问题:MoE 训练时最典型的工程麻烦是什么?
答案:负载不均。路由是学出来的,热门专家会越来越热、冷门专家饿死,需要辅助负载均衡损失或动态偏置来调平;分布式训练还要为专家并行付 all-to-all 通信(补充)。
概念 KP 07.32
KV Cache:推理加速的免费午餐,账单开在显存上
一句话 已生成词的 K/V 不会变,缓存后每步只算新词,用显存换时间。
自回归推理时,第 t 步要拿当前词的 Q 去和历史所有词的 K/V 做注意力。若每步都重算历史,第 t 步是 O(t²);但历史词的 K/V 只由它们自己和权重决定,与后面生成什么无关,完全不变。把每层 K/V 缓存起来(KV Cache),每步只算新词的 K/V 再拼接,单步计算就从 O(t²) 降到 O(t)。
代价是显存:缓存随层数、序列长度、batch 线性增长。LLaMA-2 7B(32 层、32 头、每头 128 维、fp16)每 token 约 512 KB,4096 token 约 2GB;batch 32 就是约 64GB,比 14GB 权重还大。GQA/MQA 让多个查询头共享 KV 头,把这份账单除以 4 甚至 8(补充)。
易错 把 KV Cache 算进"模型大小":权重是固定成本,KV Cache 是随 seq_len × batch 线性上涨的运行成本;长上下文推理时它常常超过权重本身,这才是 vLLM 的 PagedAttention 要管理的东西。
10 秒自测 · 点开看答案
问题:KV Cache 为什么只缓存 K、V,不缓存 Q?
答案:Q 只在当前步用完即弃,历史步的 Q 不参与后续任何计算;而历史 K/V 要一直被后面的 Q 查询,所以要存。
补充 KP 07.33
长上下文:RoPE 外推、位置插值、NTK-aware 缩放
一句话 RoPE 能算出任意位置,但对没见过的长度不灵;插值把新位置压回训练区间。
RoPE 的软肋在"没见过的位置":训练长度(如 4K)之外,高频维度转过的角度进入训练时从未出现的区间,注意力打分失真、困惑度暴涨,直接外推会崩。位置插值(PI)把位置整体压缩 pos′ = pos/s,把 8K 挤回 4K 的训练范围,只需约 1000 步微调就能扩窗(补充)。
NTK-aware 缩放不平均压缩,而是把 RoPE 的底数 10000 放大成 b′ = b·s^(d/(d−2)):低维(高频)几乎不动、保住相邻位置的分辨率,高维(低频)被大幅拉长、负责长距离,相当于"高频外推、低频插值",不微调也能零样本扩窗(补充)。再往后还有 YaRN 等改进。
易错 把"公式能算出第 100 万个位置的编码"当成"模型能处理 100 万长度":可外推性只是可计算性,模型没在这些位置上训练过,注意力打分分布会失真,实测表现会崩。
10 秒自测 · 点开看答案
问题:位置插值和 NTK-aware 缩放的关键差别是什么?
答案:PI 把全部位置等比压缩,简单但损失局部(高频)分辨率,需要微调;NTK-aware 只放大底数、让高频维几乎不变,把压缩留给低频维,因此不微调也能扩窗(补充)。
补充 KP 07.34
模型压缩三条路:量化、蒸馏、剪枝各压掉了什么?
一句话 量化砍数值精度,蒸馏换小模型,剪枝删冗余结构,目标都是更小更快。
量化:把 fp16 的权重/激活降到 int8、int4,7B 模型从 14GB 降到 7GB / 3.5GB,直接省显存和带宽;分训练后量化(PTQ)和量化感知训练(QAT),关键是把缩放因子选准、必要时按通道或分组量化,否则少量异常值会毁掉精度。蒸馏:让学生学教师的软标签而不只是硬标签,损失 = α·交叉熵 + (1−α)·KL;DistilBERT 用这招压到 6 层 6600 万参数,速度快约 60%、保留约 97% 的 GLUE。剪枝:删权重(非结构化)或整通道、整头、整层(结构化),只有结构化剪枝才真正加速(补充)。
生活类比 给行李箱减重有三招:抽真空(量化,压掉数字的"体积")、把经验写成手册交给徒弟(蒸馏,换个更小的载体)、扔掉不用的东西(剪枝,删掉冗余结构)。目标相同,代价不同。
易错 以为剪掉的参数越多越快:非结构化剪枝只是把权重置零,矩阵形状没变,普通 GPU 仍按稠密算,只省显存不省时间;要加速得用结构化剪枝或 2:4 稀疏这类硬件支持的格式。
10 秒自测 · 点开看答案
问题:蒸馏为什么通常比"直接训练一个小模型"效果好?
答案:软标签里带有教师学到的类间相似结构(比如"猫"和"狗"比"猫"和"汽车"更近),学生看到的是完整概率分布,决策边界更平滑,信息量大于 one-hot 硬标签(补充)。
公式 KP 07.35
训练显存估算:每个参数 16 字节,激活值才是隐形大头
一句话 混合精度 Adam 每个参数约 16 字节,7B 模型光参数、梯度、优化器状态就要约 112GB。
训练显存 = 参数 + 梯度 + 优化器状态 + 激活值。用混合精度 Adam:参数 bf16 2 字节、梯度 2 字节、fp32 主权重 4 字节、一阶矩 m 4 字节、二阶矩 v 4 字节,合计 16 字节/参数。7B 模型光这四项就约 112GB,单张 80GB 卡装不下,必须切分(ZeRO/FSDP)或卸载。
激活值与层数、batch、序列长度成正比。LLaMA-7B 单条 2048 token:每层 32 头 × 2048² × 2 字节 ≈ 268MB 的注意力矩阵,32 层约 8.6GB——这还没算 FFN 中间层,也正是 FlashAttention 和梯度检查点要解决的问题(示例估算,补充)。
项目 每参数占用 7B 模型 随 batch·seq 增长
参数(bf16) 2 B 约 14 GB 否
梯度(bf16) 2 B 约 14 GB 否
fp32 主权重 4 B 约 28 GB 否
Adam m + v 8 B 约 56 GB 否
激活值 视结构而定 单条 2048 token 约 8.6 GB(示例) 是
易错 只按 2 字节/参数估训练显存:那是推理权重的大小(7B 约 14GB),训练还要梯度和优化器状态,实际是 8 倍;用 SGD 没有 m、v,数字会小很多。
10 秒自测 · 点开看答案
问题:为什么 fp32 训练和混合精度训练的参数相关显存都约是 16 字节/参数?
答案:fp32 是参数 4 + 梯度 4 + m 4 + v 4;混合精度是 bf16 参数 2 + 梯度 2 + fp32 主权重 4 + m 4 + v 4,都等于 16。混合精度省的是计算和带宽,不省优化器状态。
概念
KP 07.36
ViT 与 CLIP:把图像切成「词」,再让图文住进同一个空间(补充)
一句话 ViT 把图片当句子读,CLIP 用配对数据把图和文拉到一起。
ViT(Vision Transformer)把 224×224 的图切成 16×16 的 patch,得到 14×14=196 块;每块展平后线性投影成向量,加上位置编码和 [CLS],就成了一串「视觉词」,直接送进标准 Transformer 编码器。它没有卷积的局部性先验,小数据上常输给 CNN,数据量足够大才反超。CLIP 同时训练图像塔与文本塔:同一对图文互相靠近、错误配对推远,学好后把类别名写成提示句,用相似度就能零样本分类。
易错 patch 越小 token 越多:16 改成 8,序列长度从 196 涨到 784,注意力计算按 n² 涨约 16 倍。CLIP 的零样本分数还很吃提示词写法,模板一换准确率就可能明显波动(补充)。
10 秒自测 · 点开看答案
问题:224×224 的图、patch 取 16,ViT 的序列长度是多少?
答案:196。14×14=196 个 patch;算上 [CLS] 是 197 个 token,比很多句子的长度还长。
概念
KP 07.37
推理部署的组合拳:KV Cache、批处理、量化、FlashAttention 各治哪一段(补充)
一句话 Prefill 拼算力、Decode 拼带宽,四个技术分别补不同的洞。
LLM 推理分两段。Prefill 一次读完整段提示,矩阵够大,是算力瓶颈;Decode 每步只生成一个 token,却要把全部权重和 KV Cache 读一遍,是显存带宽瓶颈。四个技术各补一段:KV Cache 缓存历史 K/V,避免重复计算;连续批处理按 token 动态拼批,填满 GPU 空转;量化把权重和缓存从 fp16 压到 int8/fp8,直接缩短要读的字节;FlashAttention 分块计算、不把 n×n 矩阵写回显存,长序列提速明显。
技术 主攻阶段 省什么 代价
KV Cache Decode 重复计算 显存随长度 × batch 涨
连续批处理 Decode GPU 空转 调度复杂、尾延迟
量化 两段都受益 带宽与显存 精度损失、要校准
FlashAttention Prefill / 训练 HBM 读写 长序列收益才大
10 秒自测 · 点开看答案
问题:只有一条请求时,decode 阶段 GPU 算力利用率为什么很低?
答案:每步只算 1 个 token,矩阵很小,时间几乎都花在把权重从显存搬进来;瓶颈是带宽而非 FLOPs,所以要把 batch 做大,算力才有活干。
公式
KP 07.38
训练成本三行估算:参数量、token 数、FLOPs(补充)
一句话 训练算力 ≈ 6 × 参数量 × token 数,再除以有效算力就是卡时。
估算训练成本只要三个量:参数量 N、训练 token 数 D、有效算力。Transformer 每处理一个「参数 × token」的组合,前向约花 2 次浮点运算、反向约 4 次,所以总计算量 C ≈ 6ND。把 C 除以「峰值算力 × MFU」就得到要烧的卡时——MFU(model FLOPs utilization)是模型真正用上的算力比例,常见只有三到五成,拿峰值直接估会乐观两三倍。再乘单卡时价,就是训练账单。
示例估算 7B 模型训 1T token:C ≈ 6×7×10⁹×10¹² = 4.2×10²² FLOPs。A100 的 bf16 峰值约 312 TFLOPS,按 MFU 40% 折算约 1.25×10¹⁴ FLOPS,约需 9.3 万卡时;1000 张卡跑约 93 小时。
易错 两个常见低估:① 用峰值算力估时间、忘了 MFU,结果乐观 2~3 倍;② 只算训练,不算反复推理与数据清洗。另外 Chinchilla 之后大家才把 token 数看得和参数量一样重,今天的大模型常刻意多喂 token(如 7B 喂 2T)来换更便宜的推理,具体比例不必死背。
面试
KP 07.39
Transformer 面试 8 连问:一条从动机到设计的因果链
一句话 八问一条链:为什么换、怎么算、怎么防、怎么稳。
面试官很少孤立地问某个零件,通常按这条链连问:为什么不要 RNN → Q/K/V 各管什么 → 为什么要多头 → 为什么要 mask → 为什么要位置编码 → 为什么用 LayerNorm → 为什么要残差 → BERT 和 GPT 差在哪。八问在追同一件事:这个设计解决了什么问题、又付出了什么代价。答法上先说「没有它会怎样」,再给结论,比背定义更像真的用过。
问题 一句话答案
为什么不用 RNN? 顺序依赖不能并行、长距离梯度路径长;自注意力一步连通全句,顺序操作数 O(1)。
Q/K/V 各是什么? Q 是我要找什么,K 是我能被谁匹配,V 是我实际交出的内容;QKᵀ 打分,softmax 加权 V。
为什么要多头? 同算力下把表示切到多个子空间,并行关注不同关系;8 个 64 维拼回 512 维。
为什么要 mask? PAD 不该被注意,解码器不许看未来;非法分数在 softmax 前填 −1e9。
为什么要位置编码? 自注意力对顺序无感,不加位置则「狗咬人」与「人咬狗」无法区分。
为什么 LN 不用 BN? 序列长度不一、batch 小、推理只有单条;LN 对每个 token 独立,不依赖 batch 统计。
为什么要残差? 梯度可沿加法直通,子层只学增量,几十层才训得动。
BERT 与 GPT 的区别? 同一套 Block 的两种用法:BERT 双向 + MLM 做理解,GPT 因果 + 下一词做生成。
10 秒自测 · 点开看答案
问题:面试官追问「多头比单头贵吗?」,怎么答?
答案:不贵。每个头把 512 维切成 64 维,8 个头的投影拼起来仍是 512×512,参数量和 FLOPs 与单头几乎相同,只是把表示空间分成了多个子空间。
本章速查
架构 :Encoder 6 层 + Decoder 6 层,d_model 不变;每层 = 注意力 + Add&Norm + FFN + Add&Norm。
注意力 :Attention(Q,K,V) = softmax(QKᵀ/√d_k)V;多头 = 8 个 64 维子空间拼接。
位置编码 :正弦/余弦绝对编码,波长几何级数;现代大模型多用 RoPE。
Mask :padding mask 挡填充,causal mask 挡未来;都在 softmax 之前置 −1e9。
BERT vs GPT :双向 Encoder + MLM/NSP vs 单向 Decoder + 自回归;LLaMA 属于 Decoder-only。
来源:第二章 PPT P89–P116;《HCIP-AI-Transformer 英法翻译实战-实验指导书 / 实训手册》;《Transformer 知识点详解》;transformer-test.py / train_transformer.py;论文 Attention Is All You Need(1706.03762)。
前面几章学的是"模型怎么算",这一章回答"算力从哪来、又怎么被用起来":先看 AI 为什么在这十年爆发,再拆昇腾的全栈全场景与 Atlas 硬件,重点讲 CANN 这张异构计算架构图的每个零件,最后补上 NPU 内部结构与 Host/Device 协同,把一行 torch.matmul 从 Python 追到 Cube 单元。学完这一章,你应该能说清:全栈全场景各指什么、1400+ 算子与 671B DeepSeek 这些数字意味着什么、CANN 与 CUDA 怎么一一对应。
8.1 先看趋势:AI 为什么在这十年爆发
概念
KP 08.1
第四次工业革命:AI 为什么是"新的通用目的技术"?
一句话 AI 不是又一次工具升级,而是像蒸汽机、电力一样,要把所有行业重做一遍。
人类已经走过农耕、蒸汽机、电力、互联网几个时代,正在进入智能时代。第四次工业革命不是单一技术的突破,而是云计算、大数据、物联网、人工智能、5G、生物工程等一批新技术同时融进社会肌理,带来社会可持续发展、经济增长新动能、智慧城市升级、产业数字化转型等宏观变化。华为作为 ICT 基础设施与智能终端提供商,正是沿着这条主线布局昇腾 AI 基础软硬件平台。
课程里对 AI 的发展给了三个判断,值得当成结论背下来:
从专用走向通用 :技术迭代间隔缩短、产业拐点密集涌现,计算系统加速向 AI 算力转移,AI 已经不只是某个任务的专用工具。
它是"新的通用目的技术" :材料把 AI 与蒸汽机、电力并列,称为新的通用目的技术(General Purpose Technology,GPT)。注意这里的 GPT 是经济学概念,不是那个语言模型,缩略语表里专门给了这个释义。
正处在拐点上 :AI 应用与生产力曲线分四段——局部探索、技术与社会环境相互碰撞、相互促进、稳定发展。当前正从"技术创新积累期"走向"行业广泛应用期",第三次 AI 浪潮已经到来,业界在"期待新 GPT"。
生活类比 蒸汽机装上以后,纺织、交通、采矿全都要重做一遍;电力和互联网也一样。AI 现在就在这个位置上——它不是一个可以"顺手加上去"的新功能,而是一套要被所有行业重新适配的基础设施。
10 秒自测 · 点开看答案
问题:这一章材料里的"GPT"指的是什么?
答案:General Purpose Technology,通用目的技术,是经济学概念,与语言模型 GPT 同名不同义。
概念
KP 08.2
三大驱动:算力、数据、模型为什么同时到位?
一句话 算力、数据、模型三条曲线同时陡起来,深度学习才真正爆发。
深度学习的大发展不是某一次算法的灵光一现,而是三个因素同时成熟,材料称之为"技术的脉搏":
无处不在的算力 :智能手机算力已达 10 TOPS 量级,而早期 Intel 奔腾 III PC 只有 1 GOPS 量级;智能设备走进生活、深入行业,算力不再稀缺。
爆发式增长的数据 :全球数据量从 2020 年的 44 ZB 增长到 2025 年的 180 ZB;丰富应用带来图像、语音、文本等非结构化数据的爆发。
迭代更新的模型 :GPT-1 只有 1.1 亿参数,盘古大模型已经到 2000 亿参数,算法模型不断突破、日益复杂。
这三条曲线就是常说的 AI 三大要素:算力、数据、算法(模型)。缺一条都不成立——只有算法没有算力,模型停在论文里;只有算力没有数据,机器空转;数据和算力都有了却没有好模型,也学不出能力。深度学习之所以在这一轮爆发,正是因为三件事第一次同时到位:专用并行算力(GPU/NPU)、互联网积累的海量标注数据、深度网络与反向传播等算法成熟。
"算力是新的生产力"这句话的分量就在这里。材料把芯片比作人工智能的血液——血液输送营养,芯片供给算力;而 CANN 像心脏,让算力真正流到全身。当模型以千亿参数计、训练要动用成千上万张卡时,算力就从"技术成本"变成了"生产能力":谁能稳定、便宜、规模化地拿到算力,谁就能把模型做大、把应用跑通。
驱动 材料里的关键数字 它决定了什么
算力 手机 10 TOPS vs 奔腾 III 1 GOPS;服务器 CPU 约 1~3 TFLOPS,昇腾 910B 单卡约 300 TFLOPS 量级(补充,量级参考) 模型能做多大、训练要跑多久
数据 44 ZB(2020)→ 180 ZB(2025) 模型能见多少"世面"
模型 GPT-1 1.1 亿参数 → 盘古大模型 2000 亿参数 能力上限与训练难度
生活类比 算力是发动机、数据是燃料、模型是图纸——三样凑齐车才跑得起来。少一样,再好的图纸也只是图纸。
10 秒自测 · 点开看答案
问题:判断——只要算法足够好,没有算力也能训练出大模型。
答案:错。算力、数据、模型三要素必须同时到位,算力不足时模型规模与迭代速度都会被直接卡死。
概念
KP 08.3
从 AI+ 到 +AI:AI 进入场景化应用时代
一句话 上半场是"AI 能做什么",下半场是"行业用 AI 做什么"。
AI 的发展可以分成两个阶段,材料用两个写法不同、意思相反的概念来区分:
AI+ :探索人工智能自身的能力上限,是"技术找场景"。材料给了三个超过人类的成绩:图像分类 EfficientNet 模型 Top-5 准确率 98.7%,超过人类 96%;语音识别 RNN-T 模型准确率 96.8%,超过人类 94.17%;阅读理解 BERT 模型准确率 90.9%,超过人类 82%。
+AI :千行百业融合 AI,走向场景化应用,是"场景找技术":智能工业质检、智慧园区、自动驾驶、电力线智能巡检、智慧港口、智慧网点。
两者的关注点完全不同。AI+ 关心 SOTA(state of the art)和榜单,回答"这个任务 AI 能不能做到";+AI 关心成本、时延、稳定性与可维护性,回答"这个场景用 AI 到底划不划算"。产业界真正大规模落地的,都是后者。
记忆技巧 看加号在哪边:AI+ 是 AI 往外扩张(+ 在右边),+AI 是行业把 AI 加进来(+ 在左边)。左边是"行业",右边是"能力"。
易错 把"准确率超过人类"当成"任务已经解决"。超过人类基准只说明模型在特定测试集上够用;真实场景还要过数据分布、标注质量、推理成本、时延、可解释性这几道关。
8.2 再看平台:昇腾的"全栈全场景"
概念
KP 08.4
"全栈"和"全场景"到底指什么?
一句话 全栈是纵向从芯片到应用全自己做,全场景是横向从云到终端全覆盖。
华为在业界率先实现全栈和全场景 AI 解决方案,这两个词分别回答两个不同方向的问题:
全栈 是技术功能视角:包括芯片、芯片使能、训练和推理框架、应用使能在内的全堆栈方案,一条技术栈从上到下都由昇腾提供。
全场景 是部署环境视角:包括公有云、私有云、各种边缘计算、物联网行业终端、消费类终端等全场景的部署环境,从数据中心一直到摄像头和手机。
一句话记住:全栈解决"每一层都有",全场景解决"每个地方都能放"。缺了全栈,就得靠别人补中间层;缺了全场景,模型就只能在机房里跑。
生活类比 把昇腾平台想象成一个人:芯片是血液(供给算力营养),CANN 是心脏(把算力泵到全身),AI 框架是大脑和灵魂(AI 领域的操作系统),应用使能是手脚(真正去完成任务),MindStudio 是随身工具箱——所有开发工作在一个环境里完成,还能一键部署。
10 秒自测 · 点开看答案
问题:全栈、全场景分别从什么视角描述昇腾?
答案:全栈是技术功能视角(纵向分层),全场景是部署环境视角(横向覆盖云边端)。
概念
KP 08.5
昇腾全栈五层:芯片 → CANN → 框架 → 应用使能 → IDE
一句话 五层各管一段,每一层都在替上一层挡掉一类复杂性。
把全栈从上到下拆开,就是五层结构,从下往上走一遍:
芯片层 :昇腾 AI 处理器(训练侧 910B、推理侧 310P 等),提供物理算力;Atlas 系列硬件是它的产品形态。
异构计算架构层 CANN :对上适配框架、对下使能 NPU,是全栈承上启下的枢纽。
AI 框架层 :自研 MindSpore,同时兼容 PyTorch、TensorFlow、飞桨、Caffe 等主流框架。
应用使能层 :MindCluster、MindEdge、MindSpeed、MindIE、MindSDK、ModelZoo,把算力变成可落地的行业方案。
IDE 与工具链 :MindStudio,让开发、调试、部署在一个环境里完成。
层次 代表组件 这一层替上层隐藏了什么
应用/行业方案 MindSDK、ModelZoo、ModelArts 从模型到业务的工程细节
应用使能 MindCluster、MindEdge、MindSpeed、MindIE 集群调度、边缘管理、训练加速、推理部署的复杂度
AI 框架 MindSpore、PyTorch、TensorFlow 算子编排、自动微分、训练循环
异构计算架构 CANN "框架调用 → NPU 指令"的全部翻译与调度
芯片与硬件 昇腾 910B / 310P、Atlas 系列硬件 物理算力与能效
IDE 与工具链 MindStudio 多工具切换成本
注意 多选题常考:昇腾 AI 基础软硬件平台包括 Atlas 系列硬件、CANN、MindSpore、应用使能 MindX,四个选项全选(课程例题答案 ABCD),不要只勾"硬件 + CANN"。
昇腾 AI 基础软硬件平台全栈:应用使能、AI 框架、CANN、芯片与硬件自下而上贯通。
概念
KP 08.6
Atlas 硬件全家福:训练、推理、边缘各归其位
一句话 训练看集群,推理看密度,边缘看环境——Atlas 用三条产品线覆盖。
Atlas 是昇腾的硬件品牌,产品按使用场景分三类:
训练 :Atlas 800T A2 训练服务器是单机训练主力(2U 标准、灵活配置);Atlas 900 A2 PoD 面向大规模训练集群,4U 高密、集群单元、可多柜扩展,配套液冷散热。
推理 :Atlas 300I Duo、Atlas 300I Pro 是推理卡,插在服务器里做加速;Atlas 300V Pro 是视频解析卡,专攻视频分析;Atlas 500 A2 智能小站是边缘推理盒子,宽温设计(-40℃~60℃)、不畏寒暑;Atlas 800I A2 推理服务器是 4U 高密高能效的数据中心推理机型,也是 DeepSeek 的适配机型。
边缘与开发者 :Atlas 200I DK A2 开发者套件开箱即用、参考丰富,适合入门与原型;Atlas 200I A2 是加速模块,供整机厂商集成。
产品 形态 定位 典型场景
Atlas 800T A2 训练服务器(2U) 单机训练主力 单机训练、小规模集群
Atlas 900 A2 PoD 集群单元(4U 高密、多柜扩展、液冷) 大规模训练集群 大模型训练
Atlas 800I A2 推理服务器(4U 高密) 数据中心推理 DeepSeek 等大模型推理
Atlas 300I Duo / 300I Pro 推理卡 服务器插卡推理 通用推理加速
Atlas 300V Pro 视频解析卡 视频分析 智慧城市、视频监控
Atlas 500 A2 智能小站 边缘推理 宽温现场(-40℃~60℃)
Atlas 200I DK A2 开发者套件 学习与原型开发 入门实验、边缘原型
生活类比 选 Atlas 像选车:训练要拉得多、跑得远,是重卡(800T / 900 A2 PoD);推理要在单位时间服务更多请求,是公交车(800I / 300I);边缘现场环境恶劣、要随插随用,是越野车(500 A2 / 200I DK A2)。
10 秒自测 · 点开看答案
问题:大规模训练集群和边缘推理分别对应哪类 Atlas 产品?
答案:训练集群用 Atlas 900 A2 PoD(800T A2 做单机训练);边缘推理用 Atlas 500 A2 智能小站或 200I 系列。
昇腾 Atlas 系列硬件:数据中心训练 / 推理与智能边缘产品覆盖全场景。
面试
KP 08.7
DeepSeek × Ascend:671B 模型与 Atlas 800I A2
一句话 V3 是 MoE 语言模型,R1 是基于 V3 的推理模型,两者总参数量都是 671B。
这是近几年最常被问到的一组对应关系,材料讲得很明确:
DeepSeek-V3 是 DeepSeek 团队开发的混合专家(MoE,Mixture of Experts)语言模型。
DeepSeek-R1 是在 DeepSeek-V3 基础上训练得到的推理模型,不是另起炉灶的另一个基座。
两者总参数量均为 671B 。
为实现高效推理性能,Atlas 800I A2 推理服务器做了深度适配。
再补一层理解(补充):MoE 的"总参数量"和"每个 token 实际激活的参数量"不是一回事——每个 token 只走其中一部分专家,所以 671B 不等于每次推理都要全量计算。但这也让 MoE 推理更吃显存容量、卡间通信带宽和算子融合效率,"硬件深度适配"说的就是把这些环节针对具体机型调优,而不是把模型原样搬上去。
易错 把 R1 说成"另一个更小的模型"、或把两者参数量说成不同。材料原文是:R1 由 V3 训练得到,二者总参数量均为 671B。
10 秒自测 · 点开看答案
问题:MoE 的全称是什么?DeepSeek-V3 与 R1 是什么关系?
答案:Mixture of Experts,混合专家。V3 是 MoE 语言模型,R1 是在 V3 基础上训练得到的推理模型,二者总参数量均为 671B。
8.3 核心是 CANN:异构计算架构
概念
KP 08.8
CANN 是什么:翻译官 + 调度员 + 工具箱
一句话 对上把框架的话翻译给 NPU,对下把算力调度成任务,工具箱里全是现成算子。
CANN 全称 Compute Architecture for Neural Networks(神经网络计算架构),是华为针对 AI 场景推出的异构计算架构:向上支持 MindSpore、PyTorch、TensorFlow 等多种 AI 框架,向下服务 AI 处理器与编程,发挥承上启下的关键作用,是提升昇腾 AI 处理器计算效率的关键平台。
它有三个身份,考试写简答可以直接照这个框架展开:
翻译官 :框架里一句 torch.matmul,最终要变成 NPU 认得的指令,中间的翻译全靠 CANN。
调度员 :任务自动流水、算子深度融合、内存分配、多核并行,都由它安排。
工具箱 :1400+ 高性能算子、集合通信库、视觉预处理、算子开发语言,都是现成的工具。
CANN 的三条关键特性也建议背下来:释放强大算力 (任务自动流水、算子深度融合等优化技术,持续保持性能领先);使能高效开发 (更简单的计算和内存抽象、自动流水同步、更简便的调试手段,降低开发者编码成本);生态开放兼容 (兼容主流 AI 框架,接入主流开源社区,为社区提供昇腾算力支持)。
生活类比 CANN 就是一个"翻译官 + 调度员 + 工具箱"三合一的人:既懂普通话(AI 框架)又懂当地方言(NPU 指令),一边把话翻译过去,一边安排谁先干谁后干,手边还拎着一整箱标准件。
10 秒自测 · 点开看答案
问题:CANN 承上启下,"上"和"下"分别接什么?
答案:上接主流 AI 框架(MindSpore / PyTorch / TensorFlow 等),下接昇腾 NPU 硬件与编程。
概念
KP 08.9
CANN 组件清单:从上到下一排零件各管什么
一句话 框架适配、图引擎、AscendCL、Runtime、DVPP、算子库、HCCL、Ascend C、Driver,一层挡一类麻烦。
CANN 不是一个大黑盒,而是一排各管一段的组件。按材料给出的架构图从上往下数:
框架适配 :torch_npu 等,把 PyTorch 的算子调用映射到 CANN 算子,并向框架注册 npu 设备后端。
GE 昇腾图优化引擎 :图编译、图执行、metadef 三部分,负责整网优化。
AscendCL 昇腾计算语言开发接口 :向上提供统一编程接口及友好开发体系,屏蔽底层差异。
Runtime 运行管理器 :设备、内存、流、事件管理,分配 Device 内存并把任务下发到队列。
DVPP 数字视觉预处理 (Digital Vision Pre-Processing):JPEG / H.264 解码、格式转换、缩放裁剪,把图像整理成 AI Core 能直接吃的规整数据。
CANN Lib 神经网络算子库 :1400+ 高性能算子,单卡计算的"标准件仓库"。
HCCL 华为集合通信库 :多卡、多机之间的数据规约与同步。
Ascend C 编程语言 与算子开发体系、毕昇编译器 及编译调试工具:自己造算子时的语言与"翻译机"。
Driver 昇腾驱动层 :统一内存管理、HDC/P2P 通信、硬件调度,日常用的 npu-smi 就住在这里。
组件 一句话职责 类比
框架适配(torch_npu) 让 PyTorch 代码几乎不改就跑在 NPU 上 万能转接头
GE 图引擎 图融合、内存复用、整图下沉 排班调度中心
AscendCL 统一编程接口,屏蔽底层差异 统一的电源插口标准
Runtime 设备/内存/流管理,下发任务 管家
DVPP 图像视频解码、缩放、裁剪 中央厨房的洗菜切配
CANN Lib 1400+ 高性能算子 标准件仓库
HCCL 多卡集合通信(AllReduce 等) 对讲机加汇总员
Ascend C / 毕昇 自定义算子开发与编译 自己造零件再翻译成图纸
Driver 与硬件直接交互,npu-smi 入口 地基与水电
记忆技巧 先记一条竖线"框架 → 图 → 接口 → 运行时 → 驱动",再记三条横线"算子库、通信库、视觉预处理"。竖线是主干,横线是挂上去的工具。
CANN 软件架构:向上对接框架,向下使能昇腾硬件,中间由图引擎、算子库、通信库、运行时等组成。
概念
KP 08.10
GE 图引擎:把一张图"变快"的三个动作
一句话 图优化省搬运,算子融合省往返,整图下沉省交互。
GE(Graph Engine)是 CANN 里面向昇腾芯片的高性能图模式实现,包含图编译、图执行、metadef 元数据三部分。它靠三个动作把模型变快:
图优化 :图融合 / 算子融合把多个小算子合并成一个大算子;"极致内存"复用中间 Tensor,降低峰值显存;"自动流水"安排算子执行顺序。
算子融合 :以 Conv2D → BatchNorm → ReLU 为例,不融合时要写回 HBM、再读出、再写回,中间结果反复过总线;融合后在片上缓冲区一次算完,只需读入一次、写出一次,访存从 3 轮降到 1 轮。融合成立的前提是数学等价——推理阶段 BatchNorm 的参数可以折叠进卷积的权重和偏置。
整图下沉 :把整张计算图一次性交给 Device 执行,而不是每个算子都"下发—等待—回收"。好处是 Host 与 Device 的交互次数大幅减少、Host CPU 占用降低;适合结构固定、算子多的模型,动态分支多时收益会下降。
代码里对应的就是图模式:先捕获整张图,再整体优化后下沉执行。
import torch
import torch_npu
def step(x, w, b):
return torch.relu(torch.matmul(x, w) + b)
# 图模式:先捕获整张计算图,再整体优化、下沉执行
fast = torch.compile(step, backend="npugraph_ex")
# 调试阶段先用默认的 eager(单算子)模式,跑通后再切图模式榨性能
生活类比 不下沉,像每道工序都要先打电话请示老板才能开始;下沉,像老板一次性把整条产线的指令交给车间主任,车间自己按顺序执行,效率立刻不一样。
易错 以为融合越多越好。融合是数学等价变换,乱融会直接导致结果不对且极难排查 ;实际交给 GE 自动完成,或按官方推荐配置,不要手写不确定的融合。
概念
KP 08.11
算子库与通信库:一个管"够不够",一个管"通不通"
一句话 1400+ 算子保证单卡算得动,HCCL 保证多卡算得齐。
单卡性能看算子库,多卡性能看通信库,这是 CANN 里最容易混淆的两条"横线"。
CANN Lib(神经网络算子库) :提供 1400+ 高性能算子,覆盖 80% 主流算子支持;同一张数字墙上还有 90%+ 支持主流算子、900+ 提供优选模型。补充一点分库常识:ops-math 管数学运算,ops-nn 管神经网络类算子(Conv、Pool、ReLU、BatchNorm、Softmax、LayerNorm),ops-cv 管视觉,ops-transformer 面向 Transformer 场景(FlashAttention、KVCache)。
HCCL(华为集合通信库) :多卡、多机通信,在 PyTorch 分布式里以后端名 hccl 接入。最常用的是 AllReduce——先对所有卡的数据做规约(例如求和),再把结果广播给每一张卡,数据并行训练每一步的梯度同步全靠它;除此之外还有 Broadcast、ReduceScatter 等操作。
为什么通信是瓶颈 :数据并行时每张卡算完梯度都要 AllReduce 一次,通信慢一点,所有卡的算力都在原地等——这就是多卡训练里"扩卡不加速"的常见原因。
注意 HCCL 要求 world_size 与实际卡数一致;单卡环境只能验证链路构造,做不了真正的多卡规约。实验记录里要如实写,不能按"全部通过"提交。
10 秒自测 · 点开看答案
问题:AllReduce 和 ReduceScatter 的区别是什么?
答案:AllReduce 是先规约再让每张卡都拿到完整结果;ReduceScatter 是规约后按卡分发不同部分。
代码
KP 08.12
Ascend C 与毕昇编译器:内置算子不够用怎么办
一句话 内置算子覆盖主流场景,剩下的用 Ascend C 自己写,再交给毕昇编译成 NPU 指令。
当 CANN 内置算子不满足需求时(遇到了不支持的算子,或者想自己写一个更快的版本),就要开发自定义算子。这条路上有两个关键组件:
Ascend C :CANN 面向算子开发场景推出的编程语言,语法与 C/C++ 一致,提供多层接口抽象(基础 API、高阶 API、算子模板库)、自动并行、孪生调试(CPU 侧模拟 + NPU 侧真实执行)。
毕昇编译器(Bisheng) :把 Ascend C 源码编译成 NPU 可执行的 Kernel 指令,是"源码 → 硬件指令"的最后一公里。
写一个算子的核心其实只有三步:搬进来 (HBM → 片上缓冲区)、算一下 (Cube 或 Vector 单元)、搬出去 (片上 → HBM)。一个 kernel 处理的是一个 tile,整块数据怎么切由 Tiling 决定。材料还给了个很实用的效率口径:用 Ascend C 开发自定义算子约 2 人周 。
// 骨架示意:把 x、y 两个张量逐元素相加
__global__ __aicore__ void add_custom_kernel(GM_ADDR x, GM_ADDR y, GM_ADDR z)
{
// ① 声明片上缓冲区(对应 L1 / 统一缓冲区)
TPipe pipe;
TQue<QuePosition::VECIN, 1> inQueueX, inQueueY;
TQue<QuePosition::VECOUT, 1> outQueueZ;
// ② 把数据从 HBM 搬进片上缓冲区
LocalTensor<half> xLocal = inQueueX.AllocTensor<half>();
LocalTensor<half> yLocal = inQueueY.AllocTensor<half>();
DataCopy(xLocal, xGlobal, tileLength);
DataCopy(yLocal, yGlobal, tileLength);
// ③ 在片上做向量加(Vector 单元干活)
LocalTensor<half> zLocal = outQueueZ.AllocTensor<half>();
Add(zLocal, xLocal, yLocal, tileLength);
// ④ 把结果搬回 HBM
DataCopy(zGlobal, zLocal, tileLength);
}
易错 以为可以直接在 HBM 上计算。数据必须先 DataCopy 进片上缓冲区,算完再搬回 HBM——这正是 NPU 存储分层在代码里的样子。
面试
KP 08.13
CANN 的数字名片,以及它与 CUDA 的对照
一句话 1400+ / 80% / 6+ / 90%+ / 900+,再加一张与 CUDA 一一对应的表。
这几个数字是考试常客,背下来就是一道选择题:
1400+ 高性能算子;80% 主流算子支持;6+ 支持主流框架(PyTorch、TensorFlow、飞桨、Caffe 等);90%+ 支持主流算子;900+ 提供优选模型。
两个特性词:动态 Shape (支持变长输入)、Ascend C 编程语言 (业界通用编程范式,2 人周开发自定义算子)。
业界同类计算架构还有 NVIDIA 的 CUDA(Compute Unified Device Architecture)与 AMD 的 ROCm(Radeon Open Compute platform)。CANN 是昇腾的对应物——都是"让开发者更好使用自家 AI 硬件"的高阶接口,用来降低适配成本。
把两边软件栈对齐看,概念几乎是相通的:
维度 CANN(昇腾) CUDA(NVIDIA)
定位 昇腾 NPU 的异构计算架构 NVIDIA GPU 的通用计算平台
生态 兼容 MindSpore、PyTorch、TensorFlow 等,接入主流开源社区 生态成熟,库与工具链最全
编程模型 Ascend C 写算子 + torch_npu 适配框架 + GE 图模式 CUDA C/C++ 写算子 + torch.cuda + TensorRT 图模式
通信库 HCCL NCCL
编译器 毕昇 Bisheng NVCC
图引擎 GE TensorRT
性能分析 msprof / MindStudio Insight Nsight
记忆技巧 两边结构一一对应,概念相通、名字不同:熟悉 CUDA 的人学 CANN 会非常快。答题时先写"定位相同、生态不同、组件一一对应"这三句,再展开填表。
10 秒自测 · 点开看答案
问题:CANN 的 GE、HCCL、毕昇分别对应 CUDA 生态的什么?
答案:GE 对应 TensorRT,HCCL 对应 NCCL,毕昇对应 NVCC。
8.4 上层:框架与应用使能
概念
KP 08.14
MindSpore:全场景、全自动并行、全流程极简
一句话 一套框架、一份 MindIR,端边云零转换。
MindSpore 是华为推出的开源 AI 计算框架,2020 年 3 月开源,设计初衷是解决 AI 框架在安全性、可扩展性、易用性上的问题,并支持多种硬件与场景。它的能力可以用三句话概括:
全场景覆盖 :统一中间表达 MindIR,端边云场景模型部署零转换;模型自适应压缩、框架自定义裁剪。
全自动并行 :一行代码实现串行算法并行化,并行代码量降低 80%;并行策略业界最多,自动搜索最佳并行策略,降低系统调优时间 60%。
全流程极简 :动静态图统一,兼顾模型开发效率与执行效率;可视化模型调优,快速溯源异常 Tensor;400+ 高性能模型开箱即用。
还有两条容易漏掉的:MindSpore 南北向解耦 ,支持多样性算力(NVIDIA、中科海光、天数智芯等异构芯片);并支持异构芯片。也就是说,昇腾是它的原生搭档,但不是唯一去处。
易错 以为 MindSpore 只能跑在昇腾上。它南北向解耦、支持多样性算力;反过来,昇腾也不是只能跑 MindSpore,PyTorch、TensorFlow 都能通过 CANN 跑。
10 秒自测 · 点开看答案
问题:MindIR 是什么?它解决什么问题?
答案:MindSpore 的统一中间表达,让端、边、云场景的模型部署零转换。
概念
KP 08.15
应用使能六件套:从集群到行业 SDK
一句话 MindCluster 管集群、MindEdge 管边缘、MindSpeed 管训练、MindIE 管推理、MindSDK 管行业、ModelZoo 管现成模型。
框架之下是芯片,框架之上要落地到行业,中间这一层叫应用使能。六个套件各管一段:
MindCluster AI 集群系统软件,支持 NPU 训练和推理硬件,提供集群作业调度、运维监控、故障恢复,为训练/评估/部署/推理提供底层软件支撑。
MindEdge 被集成的轻量化端边云协同使能框架,做智能边缘设备使能:MEF Edge 部署在边缘设备上管业务,MEF Center 部署在服务器上做批量管理与监测。
MindSpeed 基于昇腾硬件的训练加速库,提供多维度加速算法,支持主流大语言与多模态大模型,面向大模型全流程加速,降低开发门槛、拿开箱性能。
MindIE 昇腾推理引擎,主打运行加速、调试调优、快速迁移部署;分层开放满足各类需求,统一接口使能极简开发。
MindSDK 行业应用开发套件,沉淀行业知识、使能行业应用极简开发,支持 C++ 与 Python;如 mxIndex 特征检索、mxRec 搜索推荐广告。
ModelZoo 400+ 预训练模型,开箱即用,省去从零训练的成本。
10 秒自测 · 点开看答案
问题:训练加速库和推理引擎分别是哪一个套件?
答案:MindSpeed 负责训练加速,MindIE 负责推理部署与调优。
概念
KP 08.16
ModelArts:一站式 AI 开发流水线
一句话 采数据 → 处理标注 → 训练 → 评估 → 部署,五步都在同一个平台上。
ModelArts 是华为云面向 AI 开发的一站式平台,它对应的是一套标准的 AI 应用开发流程:
数据采集 :拿到原始数据。
数据处理 :筛选、打标签、做特征工程。
模型训练 :编码实现算法,训练模型。
精度评估 :看是否满足精度要求。
部署上线 :把达标的模型部署到生产环境。
"一站式"的含义是:这五步原本要自己找存储、租机器、配环境、搭流水线,ModelArts 把能力覆盖到每个环节,用户可以在一个平台上定制开发 AI 模型。课程实验里用的 Notebook 环境就是这一层的具体形态——CANN、PyTorch、torch_npu 已经装好,打开就能写代码跑 NPU,这正是"平台把环境复杂度挡掉"的意义。
生活类比 从买菜、洗切、下锅、试味到上菜,全在同一个中央厨房完成——不用先跑菜市场、再借灶台、最后租餐厅。ModelArts 就是这个中央厨房。
10 秒自测 · 点开看答案
问题:用五个词复述 AI 应用开发流程。
答案:采集 → 处理/标注 → 训练 → 评估 → 部署。
8.5 补一课:NPU、Host/Device 与一行代码的旅程
概念
KP 08.17
NPU 是什么:16×16 矩阵乘为什么能快 8192 倍(补充)
一句话 CPU 一个一个算,Vector 一行一列一起算,Cube 整个矩阵一起算。
(补充)昇腾 NPU 采用达芬奇(DaVinci)架构,一个 AI Core 里有三类计算单元,分工非常明确:
Cube 矩阵单元 :专做矩阵乘加,FP16 精度下单时钟周期完成 16×16 与 16×16 矩阵乘(4096 次乘加);INT8 精度下完成 16×32 与 32×16 矩阵乘(8192 次乘加)。累加器可把当前结果与历史中间结果叠加,天然适配卷积加偏置等场景。
Vector 向量单元 :做逐元素与向量级运算,单时钟周期完成两组 128 长度 FP16 向量的加/乘,或 64 个 FP32/Int32 元素的加/乘,适配激活函数、归一化等任务。
Scalar 标量单元 :相当于微型 CPU,负责循环控制、分支判断、地址计算与参数配置,为 Cube/Vector 备好数据地址与运算参数。
同一个 16×16 矩阵乘,三种算法三种代价:CPU 标量三重循环要 16×16×16×2 = 8192 个周期;Vector 一行一列同时算,256 个周期;Cube 把整个矩阵一次算完,1 个周期。差距不是"魔法",而是一个周期能并行处理多少数据 的差距。
数量级参考(补充):服务器 CPU(如 64 核 AVX-512)FP16 约 1~3 TFLOPS,昇腾 910B 单卡约 300 TFLOPS 量级。与 GPU 的架构差异在于:GPU 用 SM(含 Tensor Core 与 CUDA Core)以线程束(warp)为单位动态调度;NPU 的 AI Core 内含完整的 Cube + Vector + Scalar,走指令级静态流水,Cube 面向 16×16×16 这类规整三维块。所以比"核数"没有意义,要比峰值算力、显存带宽、显存容量、互联带宽四个硬指标。
10 秒自测 · 点开看答案
问题:逐元素加法(如 x + y)由哪个单元执行?Cube 主要干什么?
答案:逐元素加法走 Vector 向量单元;Cube 专做矩阵乘、卷积这类规整的矩阵运算。
NPU 内部结构示意:AI Core 与存储、控制单元协同工作。
概念
KP 08.18
Host/Device 异构计算:搬得慢,算得再快也白搭(补充)
一句话 Host 发任务、传数据、收结果,Device 拼命算;中间那条 PCIe 就是"搬运墙"。
(补充)NPU 不是插上就能算,它要和 CPU 分工,这套分工叫 Host/Device 异构计算:
CPU(Host) :跑 Python、创建张量、调度任务;NPU(Device) :执行张量计算,拥有独立的 HBM 内存。
数据搬运 :.npu() 把张量从 Host 内存搬到 Device 内存,.cpu() 把结果搬回来;能在设备侧直接创建的数据就省一次拷贝(device='npu:0')。
搬运是要花钱的 :PCIe 4.0 ×16 约 32 GB/s、PCIe 5.0 ×16 约 64 GB/s,而 Device 内 HBM 约 1.2~3.2 TB/s,快 50~100 倍。搬 1 GB 张量走 PCIe 4.0 大约 31 ms,可能比一次同规模矩阵乘还久——这就是"搬运墙"。
异步执行 :.npu()、.cpu() 默认非阻塞,提交拷贝不等于拷贝完成。读结果、测时间、断言数值之前,必须 torch.npu.synchronize(),否则看到的可能是不完整的结果和不真实的耗时。
存储分层 :HBM(32~64 GB)→ L1(MB 级)→ L0A/L0B(Cube 的两个乘数矩阵)→ L0C(累加结果);双缓冲(Ping-Pong)让"搬下一块"和"算这一块"重叠,把搬运时间藏进计算时间。
Host(CPU)
Python · 创建张量 · 调度
Host 内存
Device(NPU)
AI Core · Cube / Vector
HBM(1.2~3.2 TB/s)
.npu() 上行 · PCIe 约 32 GB/s
.cpu() 回传 · 异步,读取前先 synchronize
图注:Host 管调度、Device 管计算;PCIe 与 HBM 的带宽差 50~100 倍,"搬运墙"由此而来(补充)。
生活类比 餐厅后厨:Host 是前厅服务员(接单、传菜、收桌),Device 是厨房。服务员跑得慢、菜供不上,厨师(Cube)再快也只能干等。
易错 计时只调 time.time() 而不调 torch.npu.synchronize(),测出来"快得离谱",其实任务还在队列里没执行完。测时间、读结果、断言数值,三处都要同步。
概念
KP 08.19
一行代码的完整旅程与环境验证
一句话 从 torch.matmul 到 Cube 算完要过六道门;先验证环境,再谈性能。
把前面所有零件串起来,看一行 torch.matmul 从 Python 到 NPU 到底走了多少道门:
torch_npu :.npu() 把张量从 Host 内存搬到 Device 内存。
框架适配 :torch.matmul 被映射成 CANN 的 MatMul 算子。
GE 图引擎 :算子入图,做融合、内存复用、流水优化。
毕昇编译器 :把优化后的算子编译成 NPU 可执行的 Kernel 指令。
Runtime :分配 Device 内存、创建 Stream,把任务下发到队列。
Driver :通过驱动把指令送到 NPU 硬件。
AI Core :Cube 单元执行矩阵乘,结果写回 Device 内存;需要时再 .cpu() 回传 Host。
环境验证也是三板斧:npu-smi info 看卡在不在、健不健康、AICore 利用率、内存、温度、功耗;用 cat $ASCEND_HOME_PATH/$(uname -m)-linux/ascend_toolkit_install.info 看 CANN 版本与芯片型号;再在 Python 里确认 torch_npu 是否注册成功。
import torch
import torch_npu # 注册 npu 后端,缺少这一行后续 .npu() 全部失败
print(torch.npu.is_available()) # NPU 是否可用
print(torch.npu.device_count()) # 可见 NPU 卡数
print(torch.npu.get_device_name(0)) # 0 号卡名称,如 Ascend910ProA
注意 常见环境问题按这个顺序排查:NPU 不可用,先查驱动加载、CANN 环境变量与设备挂载,不要直接往下跑实验;版本不配套(PyTorch、torch_npu、CANN 三者有配套关系)是最常见的原因;多卡实验 world_size 必须与卡数一致;Jupyter 里 TqdmWarning 这类组件版本提示与 NPU 无关,可以忽略,但实验自身的报错不能忽略。
10 秒自测 · 点开看答案
问题:npu-smi 里 AICore 利用率长期 0%,最可能是什么原因?
答案:负载没真正打到 NPU 上,算子多在等 Host 下发或同步;先确认卡状态,再查代码是否真的在 npu 设备上执行。
"人工智能是一种新的通用目的技术(GPT)。" —— 第三章 PPT P9
类别 考点 答案
趋势 第四次工业革命的核心技术 云、大数据、物联网、AI、5G、生物工程等融合驱动
趋势 三大驱动 算力、数据、模型(算法)
数字 数据量增长 44 ZB(2020)→ 180 ZB(2025)
数字 模型参数增长 GPT-1 1.1 亿 → 盘古 2000 亿
概念 AI+ 与 +AI AI+ 探索 AI 能力;+AI 千行百业场景化落地
全栈 全栈的定义 芯片、芯片使能、训练与推理框架、应用使能
全栈 全场景的定义 公有云、私有云、边缘计算、物联网终端、消费终端
产品 训练产品 Atlas 800T A2 训练服务器、Atlas 900 A2 PoD 集群
产品 推理产品 Atlas 800I A2、300I Duo/Pro、300V Pro、500 A2
产品 开发者产品 Atlas 200I DK A2 开发者套件
DeepSeek V3 与 R1 V3 是 MoE 语言模型,R1 基于 V3 训练,均 671B
CANN 全称与定位 Compute Architecture for Neural Networks,承上启下的异构计算架构
CANN 关键数字 1400+ 算子、80% 主流算子、6+ 框架、90%+、900+ 优选模型
CANN 组件 框架适配、GE、AscendCL、Runtime、DVPP、CANN Lib、HCCL、Ascend C、毕昇、Driver
对比 CANN 与 CUDA GE↔TensorRT,HCCL↔NCCL,毕昇↔NVCC,Ascend C↔CUDA C++
框架 MindSpore 三特性 全场景覆盖、全自动并行、全流程极简;MindIR 端边云零转换
平台 ModelArts 五步 采集 → 处理/标注 → 训练 → 评估 → 部署
补充 三类计算单元 Cube 矩阵、Vector 向量、Scalar 标量;16×16 矩阵乘 8192 / 256 / 1 周期
概念
KP 08.20
910B 做训练、310P 做推理、200I 上边缘:芯片型号怎么对号入座
一句话 训练看 910B,推理看 310P,边缘看 Atlas 200I——型号要对上场景。
材料把昇腾硬件按场景分成训练、推理、边缘三条线,芯片与 Atlas 产品要对齐看:训练侧是昇腾 910B,代表机型 Atlas 800T A2 训练服务器(单机训练)与 Atlas 900 A2 PoD(集群单元、多柜扩展、液冷);推理侧是昇腾 310P,代表 Atlas 300I Duo / 300I Pro 推理卡与 Atlas 800I A2 推理服务器;边缘侧是 Atlas 500 A2 智能小站与 Atlas 200I 系列(200I DK A2 开发者套件、200I A2 加速模块),主打开箱即用、宽温现场。材料没有展开每颗芯片的算力规格,答题写清定位与典型机型即可,别硬编 TFLOPS 数字(补充)。
芯片 / 系列 定位 典型 Atlas 产品 场景关键词
昇腾 910B 训练 Atlas 800T A2、Atlas 900 A2 PoD 单机训练、大规模集群、液冷
昇腾 310P 推理 Atlas 300I Duo / 300I Pro、Atlas 800I A2 插卡推理、数据中心推理
Atlas 200I 系列 边缘与开发者 Atlas 200I DK A2、Atlas 200I A2 入门原型、整机集成、宽温现场
易错 把 Atlas 型号当芯片型号。Atlas 是硬件品牌与产品线,芯片是昇腾 910B / 310P;面试时先说"芯片定位"再补"典型机型",两层分开讲才不乱。
10 秒自测 · 点开看答案
问题:训练、推理、边缘三类分别对应哪条芯片线?
答案:训练是 910B,推理是 310P,边缘与开发者是 Atlas 200I 系列。
易错
KP 08.21
CANN、驱动与 torch_npu:三者到底是什么配套关系
一句话 驱动托 CANN,CANN 托 torch_npu;插件版本要跟 PyTorch 走。
三者不是"装最新就好",而是一条自下而上的链条:驱动与固件在最底层,向上支撑 CANN 运行时;CANN 提供算子、运行时与集合通信,是 torch_npu 的依赖;torch_npu 是昇腾适配插件,版本号与 PyTorch 严格对应。课程实测可用组合是 Python 3.9 / PyTorch 2.1.0 / torch_npu 2.1.0.post3 / CANN 8.0 / Ascend910ProA 单卡。核对配套最省事的是"两头对照":用 npu-smi 看驱动与固件版本,用 install.info 看 CANN 版本,再按官方配套表确认 torch_npu 与 PyTorch 的对应关系(补充)。
npu-smi info # 驱动与固件版本、芯片型号
# CANN 版本:看安装目录下的 ascend_toolkit_install.info
cat $ASCEND_HOME_PATH/$(uname -m)-linux/ascend_toolkit_install.info
python -c "import torch, torch_npu; print(torch.__version__, torch_npu.__version__)"
易错 现象:import torch_npu 报找不到 .so,或算子初始化失败。原因:CANN 与驱动不配套,或 torch_npu 与 torch 版本不一致。怎么办:先按两头对照把版本列出来,再按官方配套表重装,不要逐层盲升级。
10 秒自测 · 点开看答案
问题:torch_npu 的版本跟谁严格绑定?
答案:跟 PyTorch 版本绑定;CANN 与驱动是另一层配套,两层都要对。
代码
KP 08.22
Ascend C 算子开发四步:定义、实现、编译、调优
一句话 定义原型 → 写 kernel → 毕昇编译 → 上卡调优,四步走完。
内置 1400+ 算子覆盖主流场景,内置不够用时才自研。Ascend C 的流程可拆成四段:①定义——用算子原型描述输入输出、属性与数据类型,框架据此生成调用入口;②实现——写 kernel,把数据从 HBM 搬进片上缓冲区,在 Cube 或 Vector 上算完再搬回,并用 tiling 决定数据怎么切块;③编译——交给毕昇编译器生成 NPU 可执行的 Kernel 指令;④调优——先用孪生调试的 CPU 侧模拟查逻辑,再上真卡调优。材料给的经验值是开发一个自定义算子约 2 人周。
易错 跳过"定义"直接写 kernel:没有原型与 tiling 约束,编译能过但上卡结果错或性能极差。现象是"能跑但慢、偶尔越界",根因是切块边界与数据对齐没定清楚——先补原型和 tiling,再谈优化。
10 秒自测 · 点开看答案
问题:Ascend C 源码由哪个组件编译成 NPU 指令?
答案:毕昇(Bisheng)编译器,它是"源码 → 硬件指令"的最后一公里。
概念
KP 08.23
模型迁移四步走:把 GPU 代码搬到 NPU 上
一句话 换设备 → 装 torch_npu → 跑通对齐精度 → 最后榨性能,顺序不能反。
把 GPU 代码迁到 NPU 不是重写,主线只有四步(补充):①替换设备——把 cuda / 'cuda:0' 换成 npu / 'npu:0',.cuda() 换 .npu(),torch.cuda.* 换 torch.npu.*,并用 set_device 绑定卡;②安装 torch_npu——按 PyTorch 版本选配套插件,import 之后 npu 后端才注册;③跑通并核对——先 Hello NPU 确认卡在,再用小数据比对输出,形状、类型、数值三重验证都过再放大规模;④调优——上 profiler 找算子耗时,依次试混合精度、批量、图模式与多卡。材料反复强调顺序:能跑通、结果对,才有资格谈快。
记忆技巧 四步记成"换、装、通、优"。其中第三步最容易抢跑:很多人一跑通就调优,结果精度没对齐,优化的是一份错结果。
10 秒自测 · 点开看答案
问题:为什么性能调优必须排在"跑通并核对精度"之后?
答案:精度没对齐时,加速建立在错误结果上;先过三重验证,调优才有意义。
概念
KP 08.24
三个性能工具别混用:msprof、Profiler、npu-smi 各看什么
一句话 npu-smi 看卡,Profiler 看算子,msprof 出 trace——先粗后细。
三个名字常被混用,分工其实很清楚:npu-smi 是驱动层命令行,看"卡在不在、健不健康"——设备号与型号、温度、功耗、HBM 占用、AICore 利用率,属于秒级粗看;torch_npu.profiler 是框架侧采集器,可同时采 CPU 与 NPU 活动、记录算子形状与内存、按 step 切分迭代,产出 trace 用 MindStudio Insight 或 TensorBoard 打开;msprof 是 CANN 侧工具,负责把驱动层埋点采到的原始数据解析成可读 trace,Profiler 的结果也依赖它收尾解析。排查顺序建议:先 npu-smi,再 Profiler,最后才上 trace(补充)。
工具 层级 主要看什么 典型用法
npu-smi 驱动 / 设备 型号、温度、功耗、HBM、AICore 利用率 确认卡在不在、是否满载
torch_npu.profiler 框架 / 采集 算子耗时、CPU 与 NPU 活动、内存、形状 抓一段迭代的 trace
msprof CANN / 解析 主机侧与设备侧埋点、trace 解析 导出并分析性能数据
注意 采集前先预热 3 次,排除首次算子编译;循环内同步后再 step,耗时才能按迭代正确归属(材料实验三)。
10 秒自测 · 点开看答案
问题:只想确认卡是否健康、利用率多少,先用哪个工具?
答案:npu-smi info,秒级粗看;不需要为此采集 trace。
概念
KP 08.25
HCCL 三种集合通信:AllReduce、Broadcast、AllGather 各管什么
一句话 AllReduce 汇总、Broadcast 分发、AllGather 拼全。
HCCL 是 CANN 的集合通信库,在 PyTorch 分布式里以后端名 hccl 接入。三种常用操作按语义分(补充):AllReduce 先对各卡数据规约(常用求和),再把完整结果发给每张卡,数据并行每步同步梯度靠它;Broadcast 把根卡上的同一份数据发给所有卡,训练开始时分发初始权重、超参靠它;AllGather 把每张卡各持一段的数据拼成全份发给每张卡,张量并行里拼回完整权重靠它。多卡训练"扩卡不加速",八成就卡在通信等待上。
操作 一句话语义 典型用途
AllReduce 规约后每张卡都拿全份 数据并行的梯度同步
Broadcast 根卡的数据发给全体 初始权重与超参分发
AllGather 各卡片段拼成全份 张量并行的权重拼接
易错 单卡环境只能构造链路,做不了真正的跨卡规约(材料实验二里 AllReduce 被注释)。把单卡输出写成"多卡通信验证通过"是结论夸大,报告里要如实写"部分通过"。
10 秒自测 · 点开看答案
问题:张量并行里要把各卡的权重分片拼成完整权重,用哪个操作?
答案:AllGather;AllReduce 是规约后每卡拿全份,Broadcast 是一份发全体。
概念
KP 08.26
昇腾生态三张面孔:MindSpore、ModelArts、MindIE 分别面向谁
一句话 MindSpore 给算法、ModelArts 给云端开发、MindIE 给推理上线。
三个都挂在昇腾全栈上,面向的人却完全不同(补充):MindSpore 是自研 AI 计算框架,面向算法与模型开发者,解决"网络怎么定义、训练循环怎么写";ModelArts 是华为云一站式 AI 开发平台,面向想在云上完成采集、标注、训练、评估、部署的人,课程实验的 Notebook 就是它;MindIE 是昇腾推理引擎,面向部署与运维,负责把训好的模型在昇腾上跑快、跑稳,做调试调优与快速迁移。
名字 面向谁 解决什么问题 课程里的位置
MindSpore 算法 / 模型开发者 训练框架:网络定义、自动微分、并行 全栈五层的框架层
ModelArts 云端开发者与学生 一站式:采集 → 标注 → 训练 → 评估 → 部署 Notebook 实验环境
MindIE 部署 / 运维工程师 推理引擎:运行加速、调优、迁移部署 应用使能套件之一
10 秒自测 · 点开看答案
问题:推理引擎是哪一个?它和 MindSpeed 怎么分工?
答案:MindIE 管推理部署与调优;MindSpeed 管训练加速,一个管"推得好",一个管"训得快"。
面试
KP 08.27
昇腾 vs GPU:架构、生态、迁移成本三点对比
一句话 架构不同、生态有差距、迁移分层看;换设备容易,换算子难。
三点对比(补充,按公认口径):①架构——GPU 以 SM 为单位,靠线程束动态调度;NPU 的 AI Core 内含 Cube(矩阵)、Vector(向量)、Scalar(标量),走指令级静态流水,Cube 天然适配规整的矩阵乘与卷积。②生态——CUDA 的库、工具链与社区积累最厚,CANN 组件一一对应但历史短、适配仍在补齐,这是迁移最先撞到的墙。③迁移成本——PyTorch 代码改设备、装 torch_npu 这一层成本低;依赖冷门库和自定义算子的部分要重写,成本最高。结论:难点在"跑得是否同样快",不在"能不能跑"。
维度 昇腾 NPU 路线 NVIDIA GPU 路线 对开发者的含义
架构 AI Core:Cube / Vector / Scalar,静态流水 SM:Tensor Core + CUDA Core,动态调度 比核数没意义,看峰值算力与显存带宽
软件栈 CANN:GE、AscendCL、HCCL、Ascend C、毕昇 CUDA:cuDNN、NCCL、CUDA C++、NVCC 概念一一对应,经验可迁移
迁移成本 改设备为主,冷门算子需自研 主流库齐全,基本零迁移 先跑通再调优,别承诺"无缝"
10 秒自测 · 点开看答案
问题:为什么说迁移成本要"分层看"?
答案:框架层换设备成本低;冷门库、自定义算子与特定 CUDA 行为的代码要重写,成本最高。
面试
KP 08.28
面试三连:CANN 是什么、和 CUDA 差在哪、Host 与 Device 怎么配合
一句话 CANN 是昇腾的 CUDA,Host 管调度、Device 管计算,靠搬运连起来。
三个必答题各给一句标准答案(补充):①CANN 是什么——Compute Architecture for Neural Networks,昇腾的异构计算架构,向上适配 MindSpore、PyTorch、TensorFlow,向下使能 NPU,提供图引擎、算子库、通信库、运行时与算子开发语言,作用等同"昇腾的 CUDA"。②和 CUDA 的区别——定位相同、生态不同、组件一一对应:GE 对 TensorRT、HCCL 对 NCCL、毕昇对 NVCC,差距在生态成熟度与算子覆盖。③Host/Device 怎么协作——Host 跑 Python、创建张量、下发任务,Device 执行计算、有独立 HBM;.npu() 与 .cpu() 负责搬数据,且默认异步,读结果与计时前必须 synchronize。
答题结构 先定义(一句话)→ 再对照(写出 CUDA 的对应物)→ 后举例(一条 .npu() 依次经过哪几层)。三步就能把三问答满,别只背缩写。
10 秒自测 · 点开看答案
问题:CANN 与 CUDA 最本质的相同点和最大差异各是什么?
答案:相同点是定位——都让开发者高效用自家 AI 硬件;差异在生态成熟度与算子覆盖。
概念
KP 08.29
算力单位怎么读:TOPS、TFLOPS、PFLOPS 与 HBM 带宽
一句话 先看精度口径,再看峰值或实测,最后看带宽——缺一条都不能比。
读规格表先把数字对齐(补充):TOPS 标整数推理,TFLOPS 标浮点训练,PFLOPS 是大集群才用的单位,每级差一千倍。显存带宽(GB/s 或 TB/s)决定数据喂不喂得饱,主机侧与卡间另看总线带宽。同一硬件低精度吞吐常是高精度的两倍,跨精度直接比大小必错;规格给的是峰值,乘 MFU 才是有效算力。
指标 常见口径 读表先问
TOPS INT8 推理 是 INT8 还是 INT4?含不含稀疏?
TFLOPS FP16 / FP32 训练 同精度比了吗?峰值还是实测?
PFLOPS 集群整机 是几卡之和?单卡多少?
HBM 带宽 GB/s、TB/s 算力 ÷ 带宽 = 算术强度门槛
10 秒自测 · 点开看答案
问题:A 卡标 256 TOPS(INT8),B 卡标 128 TFLOPS(FP16),能直接说 A 快一倍吗?
答案:不能。精度口径不同,同精度换算后再比,还要看带宽与实测。
概念
KP 08.30
智慧城市、电力巡检、智能制造各用什么昇腾能力
一句话 城市拼视频并发,电力拼边缘可靠,制造拼实时节拍。
三个行业考的是三种能力(补充):智慧城市用 Atlas 300V Pro 视频解析卡做多路解码与目标识别,指标看并发路数与单路时延;电力巡检把缺陷检测模型下沉到 Atlas 500 A2 / 200I,现场要宽温、断网可跑,是小目标缺陷识别;智能制造是产线在线质检,单件耗时必须对上节拍,落点在边缘推理。逻辑都是:场景定形态,形态定芯片,指标定验收。
场景 典型任务 用的能力 验收指标
智慧城市 视频解析、目标与属性识别 300V Pro 多路视频解析 并发路数、单路时延
电力巡检 绝缘子破损、异物等缺陷 500 A2 / 200I 边缘推理、宽温 漏检率、断网可用
智能制造 表面缺陷在线质检 边缘推理 + 实时推理引擎 单件耗时对齐节拍
易错 现象:把数据中心训练卡写进边缘方案。原因:机房算力不等于现场可用——现场要宽温、小体积、断网可跑。怎么办:先定部署环境,再选 300V Pro、500 A2 这类对应形态。
10 秒自测 · 点开看答案
问题:电力巡检为什么优先放边缘?
答案:现场网络差、环境恶劣,要求本地实时判断与断网可用,边缘推理能就近出结果。
面试
KP 08.31
昇腾认证与学习路径:HCIA、HCIP 与动手实验顺序
一句话 先概念、再全栈、后上机;认证按考纲,实验按顺序。
路径照课程顺序走最省力(补充):先学初级、再学中级,最后按方向深化(见下表)。概念过关再上机:环境自检 → Hello NPU → 基础 8 题 → 进阶 10 题 → 模型迁移与部署。CANN 资源以昇腾社区文档为主,配算子样例与模型仓库;考纲科目以华为人才在线当期为准,动手顺序别跳、别只背题。
层级 定位 学什么 本课程对应
HCIA 初级 AI 概念、机器学习与深度学习基础 第 01–07 章概念篇
HCIP 中级 按 Ascend、MindSpore 等方向深化 第 08–09 章工程篇
HCIE 高级 架构设计与复杂场景方案(补充) 综合实战
10 秒自测 · 点开看答案
问题:该先刷认证题还是先跑实验?
答案:先把环境跑通、做出可复现结果,再按考纲刷题;顺序反了,概念记不牢也答不出追问。
本章速查
AI 趋势 :第四次工业革命 + 三大驱动(算力、数据、模型)+ 从 AI+ 到 +AI 的场景化落地。
昇腾定位 :全栈是技术功能视角(芯片→CANN→框架→应用使能),全场景是部署环境视角(云、边、端)。
CANN :翻译官 + 调度员 + 工具箱;1400+ 算子、80% 主流算子、6+ 框架、90%+ 支持、900+ 优选模型。
硬件 :训练 800T A2 / 900 A2 PoD,推理 800I A2(DeepSeek 适配)/ 300I / 300V,边缘 500 A2 / 200I DK A2。
数字必背 :671B(DeepSeek V3 与 R1)、8192 / 256 / 1 周期(CPU / Vector / Cube 算 16×16 矩阵乘)、32 GB/s vs 1.2~3.2 TB/s(PCIe vs HBM)。
来源:第三章 PPT P1–P24;CANN 基础知识;NPU 实践手册。
这一章分三段:先把环境跑通——本地三种 torch 安装方式、版本怎么匹配、云服务器镜像怎么选;再用 Hello NPU 走完"创建 → 搬入 → 计算 → 搬回"的完整链路;最后用 Hello NPU 加实验 1–7 摸清 NPU 的性能脾气:矩阵越大加速比越高、批量接口比循环快、单张小图反而可能更慢。
学完这一章,你不该再问"NPU 比 CPU 快多少",而应该先问三个问题:这个负载的算术强度够高吗?数据搬运占多少?固定开销摊得薄吗?
后半段是进阶 10 题:混合精度、HCCL 多卡、profiler 剖析、FlashAttention、多流 + Event、torch.compile 图模式、异步传输、动态 Shape、显存池与动态量化。它们把"能跑"推进到"跑得稳、跑得快、跑得省"。
9.1 先把环境跑通:安装、版本与云端镜像
概念
KP 09.1
三种 torch 安装方式,按"有没有显卡、网快不快"选
一句话 三种方式任选其一:CPU 版最省事,在线 GPU 版最标准,离线 whl 最省下载时间。
课程材料把 torch 安装分成三种,功能上都能"装上",区别在安装速度与能不能训练:
CPU 版 :一条 pip install torch torchvision 装完,安装速度快,但没有 GPU 加速,训练速度非常慢,只适合跑通语法与轻量实验。
在线 GPU 版 :从官方索引源下载,安装速度取决于网络(校园网可能很慢),训练速度快,是作业与项目最常用的方式。
离线 whl 版 :事先把 wheel 文件下到本地再 pip install,安装速度快、训练速度也快,但必须严格按版本下载。
GPU 版有三个前置条件:必须是 NVIDIA 独立显卡(AMD / Intel 核显没有 CUDA,只能用 CPU 版);装好对应的显卡驱动;不需要手动安装 CUDA / cuDNN,pip 安装的 PyTorch 会自带运行时库。
生活类比 三种方式像去同一个地方:CPU 版是步行,立刻出发但很慢;在线 GPU 版是等网约车,车快,但高峰期要等;离线 whl 是提前把车停到楼下,准备时费点事,之后一路顺畅。
# 1) 打开 Anaconda 终端,先进入目标虚拟环境
conda activate pytorch
# 2) 在线装 GPU 版:--index-url 用官网按你的 CUDA 版本生成的地址
pip install torch torchvision --index-url <官网生成的 cu 源>
# 3) 离线装:三个 whl 的版本必须配套,cp310 只适配 Python 3.10
pip install torch-2.4.1+cu121-cp310-cp310-win_amd64.whl
pip install torchvision-0.19.1+cu121-cp310-cp310-win_amd64.whl
pip install torchaudio-2.4.1+cu121-cp310-cp310-win_amd64.whl
# 4) 验证装的是不是 GPU 版:输出 True 才算成功
python -c "import torch; print(torch.cuda.is_available())"
易错 没激活虚拟环境就 pip install → 包装进了 base 或另一个环境,运行时却 import torch 失败或版本对不上。现象是"明明装过却找不到",原因是终端与解释器不是同一个环境;先 conda activate 再装,装完用同一个终端验证。
易错
KP 09.2
版本匹配:nvidia-smi 的 CUDA 版本只是"上限"
一句话 驱动版本决定能装多高的 cuXXX,文件名里的 cp310 决定你的 Python 必须是 3.10。
先看显卡与驱动版本:在 cmd 或 PowerShell 里输入 nvidia-smi,输出表格上方会显示 CUDA Version: xx.x。这里最容易误读——它是驱动支持的最高 CUDA 版本,向下兼容,不是你"必须安装"的版本。驱动最高支持 12.6,你装 cu121 的 wheel 完全没有问题。
再看 whl 文件名,它其实像一张四段式的车票,每一段都必须对得上。以 torch-2.4.1+cu121-cp310-cp310-win_amd64.whl 为例:2.4.1 是 torch 版本;cu121 表示 CUDA 12.1 的 GPU 版;cp310 表示只适配 Python 3.10;win_amd64 表示 64 位 Windows。三个包还要成套出现:torch 2.4.1 ↔ torchvision 0.19.1 ↔ torchaudio 2.4.1。
离线安装还有一个隐藏要求:三个 whl 必须和你的 Python 版本、系统位数、CUDA 版本一一对应。少对一段,pip 都会告诉你"找不到匹配的 distribution",或者装完 import 时报缺 DLL。
nvidia-smi
# 输出表格上方显示:CUDA Version: 12.6
# 这是驱动支持的最高版本,向下兼容;
# 装 +cu121 的 wheel 可以,装 +cu126 的也可以。
10 秒自测 · 点开看答案
问题:nvidia-smi 显示 CUDA Version 12.6,可以装文件名带 +cu121 的 wheel 吗?
答案:可以。CUDA Version 是驱动的上限,向下兼容;只要 wheel 的 cu 版本不高于 12.6 就能跑。
易错 把 CUDA Version 当成"必须安装的 CUDA 版本",于是跑去装一整套 CUDA 12.6 工具链——多此一举,pip 的 wheel 自带运行时;另外在 Python 3.11 环境里装 cp310 的 whl,pip 会直接显示找不到匹配版本,那不是"下载失败",而是版本对不上。
概念
KP 09.3
终端、虚拟环境与 Jupyter 内核:三处必须指向同一个环境
一句话 一个虚拟环境只服务一个项目;终端提示符、IDE 解释器、Jupyter 内核要对齐。
课程里的操作顺序是固定的:打开 Anaconda 终端(也可以是系统 PowerShell,或 PyCharm 这类 IDE 的内置终端)→ conda activate pytorch 进入目标虚拟环境 → pip install 安装依赖 → python -c "import torch" 验证。终端提示符前面出现环境名,才算真正"进去了"。
IDE 的终端通常继承项目解释器,但 Jupyter Notebook 要单独选内核:打开 Notebook 后,切换到已安装 CANN、PyTorch 与 torch_npu 的那个内核(课程实测环境为 Python 3.9)。这一步选错,后面所有 import torch_npu 都会失败,而且报错看起来像"没装",实际是"没选对"。
判断有没有选对,有两个快速动作:在终端里看提示符有没有环境名;在代码里打印 sys.executable 或 torch.__version__,确认路径和版本就是你以为的那一套。
生活类比 虚拟环境像合租公寓里的独立单间:家具(依赖包)各买各的,互不干扰;在客厅(base 环境)里堆满东西,所有室友(项目)都得跟着乱。
记忆技巧 装之前先 conda activate,装之后先 python -c "import torch";IDE 与 Jupyter 再各确认一次解释器与内核。
易错 ① 同一环境里 pip 与 conda 混着装包,依赖互相覆盖;② Jupyter 内核选成 base,代码里能 import torch 却没有 torch_npu;③ 云上 Notebook 打开后不选内核,直接在默认内核里跑。这三类问题的共同解法:先确认"当前到底是哪个解释器"。
10 秒自测 · 点开看答案
问题:终端里能 import torch_npu,Jupyter 里却失败,最可能是什么原因?
答案:Jupyter 选的内核不是同一个虚拟环境——装包的终端和跑代码的内核不是一条路。
概念
KP 09.4
云服务器与镜像:不用自己拼硬件,也别把单卡当多卡
一句话 课程实验优先用预装 CANN 的 NPU 镜像:选对镜像、选对内核,就能直接开跑。
课程提供的云服务器是启智(OpenI)平台。登录后创建 Notebook 实例,选择带 CANN 与 torch_npu 的 NPU 镜像即可,驱动、CANN 环境变量、Python 依赖都不需要自己装。课程实测参考配置:Python 3.9 / PyTorch 2.1.0 / torch_npu 2.1.0.post3 / CANN 8.0 / Ascend910ProA 单卡;不同镜像的版本会变,一切以启动后的实际输出为准。
选镜像和自检按四步走:① 确认镜像带 CANN 与 torch_npu(不是纯 CPU 镜像);② 在 Notebook 终端执行 npu-smi info,看卡在不在、健不健康;③ 选对 Jupyter 内核,跑环境自检代码(见 9.3 的 Hello NPU);④ 再开始跑实验。手册还提醒:实验 4、6 默认读取当前目录下的图片(如 lena.jpg),要么从手册所在目录启动,要么把图片路径改成自己的。
镜像选错、数据集路径不对、跑完忘记停实例,是云端实验最常见的三类问题。另外,单卡环境做不了真正的多卡集合通信,进阶实验里的 HCCL 只能构造链路——这是环境限制,不是代码写错,实验报告里要如实标注。
生活类比 云镜像像"带家具的出租公寓":拎包入住,厨房、网络都配好;本机从零装驱动则像毛坯房,省钱,但装修周期长、还容易装错。
项目 课程实测参考 说明
Python 3.9 与 torch_npu 的 cp 版本需匹配
PyTorch 2.1.0 NPU 环境需与 torch_npu、CANN 配套
torch_npu 2.1.0.post3 注册 npu 后端,提供 .npu() 等接口
CANN 8.0 版本需与驱动、torch_npu 匹配
NPU Ascend910ProA(单卡) 以 torch.npu.get_device_name(0) 为准
版本来自课程环境实测参考;镜像迭代后版本会变,以实际环境为准。
注意 云实例按资源计费、资源有限:实验做完及时停止实例;单卡环境不要硬跑多卡实验;不同镜像的设备名(Ascend910B3 / Ascend910ProA)与耗时都不同,报告里要写清实际环境。
10 秒自测 · 点开看答案
问题:云端 Notebook 启动后,第一件事应该查什么?
答案:先确认卡与工具链——npu-smi info 看设备,再跑 torch.npu 四项自检,最后才开始实验。
9.2 实验总览与三个通用概念
8 个基础实验(Hello NPU 加实验 1–7,其中实验 2 带一个选做)不是零散练习,而是一条主线:什么情况下把计算放到 NPU 上才真的更快? 难度从"跑通链路"一路升到"分析反例",先看总表,再理解三个通用概念。
实验 难度 考察点 一句话结果(示例/实测)
Hello NPU ★☆☆ 环境检查、设备搬运 NPU 可用 True,设备名正确;CPU → NPU → CPU 链路跑通,a + b = [5.0, 7.0, 9.0]
实验 1 ★☆☆ 张量创建、设备搬运、逐元素运算 z = x² + y 全部等于 7.0;形状 (1000,)、float32、npu:0 三重验证通过
实验 2 ★★☆ 矩阵乘法、性能对比、异步计时 128 / 512 / 2048 三种规模加速比约 2.2× / 6.3× / 289.8×(示例)
实验 2 选做 ★★☆ 数据类型、精度权衡 FP16 更快但最大绝对误差增大,是否可用看业务对精度的容忍度
实验 3 ★★★ Batch 运算、算子调用开销 批量 8 / 32 / 128 的加速比约 12.5× / 45.3× / 107.8×(示例)
实验 4 ★★★ 卷积运算、图像处理、算术强度 单张 512×512 图加速比约 0.1×(示例):NPU 反而更慢
实验 5 ★★☆ 数据搬运、异步同步、有效带宽 数据量越大越接近峰值带宽;往返搬运后数据完全一致
实验 6 ★★★ Batch 图像处理、吞吐量 批量增大后吞吐量上升、加速比改善;批量为 1 时仍可能比 CPU 慢
实验 7 ★★★ 可分离卷积、计算量与耗时 输出在容差内一致;乘加少约 60%,但小图上不一定更快
难度与「一句话结果」来自《NPU 实践实验手册》的实验一览与预期现象;耗时与加速比均为示例,会随硬件、软件版本与随机数据变化。
概念
KP 09.5
Host / Device 与异步执行:CPU 发号施令,NPU 异步干活
一句话 数据要先搬到 Device 才能计算;任务下发立刻返回,要结果先同步。
PyTorch 用设备后端管理异构资源:Host 是 CPU 侧主机内存,负责跑 Python、创建张量、调度任务;Device 是 NPU 侧设备内存(HBM),负责执行张量计算,而且看不见 CPU 的内存。所以标准链路只有四步:在 CPU 创建张量 → .npu() 搬到设备 → 在设备上计算 → .cpu() 搬回主机。
数据有两种进设备的方式:一是直接 torch.randn(N, N, device='npu:0') 在设备上创建,省掉一次主机到设备的拷贝;二是先在 CPU 创建再 .npu(),适合加载磁盘上已有的数据。两者结果一致,区别只在"数据从哪来"。
更关键的是异步:torch.mm、torch.matmul 调用只是把任务下发,函数立刻返回,NPU 在后台排队执行。如果不调用 torch.npu.synchronize() 就读取结果或计时,你拿到的可能只是"下发完成",不是"计算完成"。这也是为什么 print 看起来"没问题":它会隐式触发同步;一旦换成计时代码,少了同步就会把加速比算虚高。
生活类比 点外卖:付款成功(任务已下发)不等于饭到了;要拍照发朋友圈(读取结果),得等骑手送达(同步)。
import torch
import torch_npu # 注册 NPU 后端,缺这一行 .npu() 全部失败
N = 1024
# 方式一:直接在 NPU 上创建,省掉一次 Host -> Device 拷贝
A = torch.randn(N, N, device='npu:0')
B = torch.randn(N, N, device='npu:0')
C = torch.mm(A, B)
# 方式二:Host 先创建,再搬到 Device,适合加载已有数据
A_cpu = torch.randn(N, N)
A_npu = A_cpu.npu()
B_npu = torch.randn(N, N).npu()
C = torch.mm(A_npu, B_npu)
C_cpu = C.cpu() # 搬回 CPU 后才能 .numpy()
同步的时机 只有三类时刻必须同步:① 读数值之前(.item()、比较、断言);② 计时前后;③ 调试定位"究竟是哪一步出错"。其余时候让它异步跑完就好,过度同步反而会吃掉流水线收益。
易错 忘记 .cpu() 就调用 .numpy() → 报 "can't convert npu:0 device type tensor to numpy";计时前不同步 → 把搬运时间算进计算时间,加速比虚高。解决:验证前显式 .cpu(),计时前后各 synchronize 一次。
10 秒自测 · 点开看答案
问题:为什么 print(c) 能正常输出,c.numpy() 却报错?
答案:print 会隐式触发 Device → Host 拷贝;numpy() 要求张量本来就在 CPU 上,必须先 c.cpu()。
公式
KP 09.6
性能测试三要素:同步、预热、容差,缺一不可
一句话 同步定计时边界,预热去首发开销,容差判结果对错。
① 同步 :计时前先同步一次,把搬运等之前下发的任务排空;计算结束、停止计时前再同步一次,等这一次真正跑完。两次位置不同、作用也不同,少任何一个,测到的数都不是"纯计算时间"。
② 预热 :首次执行某个算子时,CANN 需要即时编译生成 Kernel 指令,这次耗时会明显偏高。正式计时前先跑 3 次并同步,把首轮编译与路径初始化开销排除掉。
③ 容差 :CPU 用 MKL / OpenBLAS,NPU 用 CANN 算子库,浮点累加顺序不同,结果必有微小差异。验证用 torch.allclose 而不是 ==;只有纯数据搬运(不涉及浮点运算)才用完全相等验证。单次测量噪声大,性能测试还要重复多次取平均,并在报告里写清重复次数与预热次数。
生活类比 测百米成绩:发令前要等上一组清场(前置同步),自己先热身(warmup),冲线时秒表要按在真正过线那一刻(后置同步);容差则像体温计允许 ±0.1℃,不是要求刻度一模一样。
易错 只在结束处同步 → NPU 耗时把搬运也算进去;不预热 → 第一次的编译开销被当成"NPU 很慢";用 == 比较 → 结果明明正确却"验证失败";只测一次就写报告 → 数字随机器负载乱跳。
10 秒自测 · 点开看答案
问题:为什么开始计时前也要 synchronize 一次?
答案:搬运是异步的,前置同步把搬运排空,避免把 Host 到 Device 的拷贝时间算进计算时间。
公式
KP 09.7
算术强度:加速比的自变量 = 计算量 ÷ 访存量
一句话 算术强度 = FLOPs ÷ Bytes,它决定 NPU 的并行算力能不能被"喂饱"。
算术强度(Arithmetic Intensity)的直观含义是:每搬 1 字节数据,能做多少次浮点运算。强度高 → 计算密集,NPU 的 Cube / Vector 并行单元有活干,加速比高;强度低 → 访存密集,时间花在搬运与启动上,NPU 可能还不如 CPU。
矩形乘法的算术强度可以手算:FLOPs = 2N³(每个输出元素 N 次乘加),访存 Bytes = 3N² × 4(两个输入加一个输出,FP32 每元素 4 字节),所以算术强度 ≈ N/6。N=2048 时约 341,N=4096 时约 683。而 5×5 卷积的每个输出像素只做 2×25 = 50 次浮点运算、读 (25+1) 个 float 约 104 字节,算术强度约 0.48——两者差了约 1400 倍。
这就解释了两个实验现象:2048 矩阵乘能快 289.8×,而单张 512×512 图的高斯模糊只有 0.1×。关键结论:加速比不是硬件的固定属性,而是"数据形状"的函数。同一个 NPU,在不同负载上表现可以差三个数量级。
负载 FLOPs 访存 Bytes 算术强度 瓶颈
矩阵乘 N=128 2N³ ≈ 4M 3N²×4 ≈ 196 KB ≈ 21 偏访存
矩阵乘 N=512 ≈ 268M ≈ 3 MB ≈ 85 计算
矩阵乘 N=2048 ≈ 17G ≈ 50 MB ≈ 341 计算
矩阵乘 N=4096 ≈ 137G ≈ 201 MB ≈ 683 计算密集
5×5 卷积(单像素) 2×25 = 50 (25+1)×4 ≈ 104 B ≈ 0.48 访存密集
以上为按公式估算的数量级示意,用于理解趋势,不是性能指标。
生活类比 用跑车送外卖:如果每单都是"上下楼、等红灯"比路上跑的时间还长(低算术强度),跑车再快也没用;只有长途高速(高算术强度),性能优势才真正兑现。
10 秒自测 · 点开看答案
问题:为什么 2048 矩阵乘的加速比远高于 128?
答案:算术强度随 N 线性增长;N=128 时偏访存、搬运与启动开销占比高,N=2048 时计算密集,NPU 的并行算力才被喂饱。
9.3 Hello NPU 与 7 个基础实验
下面 6 张实验卡覆盖 Hello NPU 与实验 1–7:前 5 张对应单个实验,最后一张把实验 5–7 合并讲,因为它们在回答同一个问题的三个侧面——搬运有多贵、批量能不能摊薄固定开销、少算是不是就等于快。读每张卡时按四步走:先看难度与考察点,再按步骤跑一遍,然后对照「预期结果」判断现象是否符合预期,最后把「常见坑」当成预习清单;报告里的耗时与加速比,务必注明是示例还是本机实测。
实验
LAB 09.1
Hello NPU · 先确认卡真的在,再确认数据真的搬过去了
难度 ★☆☆
对应手册「0. Hello NPU」
hello_npu.py / Cell 1
实验目的:确认 NPU 后端已正确注册,并走完"创建 CPU 张量 → 搬入 NPU → 计算 → 搬回 CPU"的完整流程。这是后面所有实验的地基。
导入 PyTorch 与 torch_npu;后者负责把 NPU 后端注册进 PyTorch,缺这一行后面 .npu() 全部失败。
检查 NPU 是否可用;若不可用,先查驱动、CANN 环境变量与设备挂载,不要带着问题往下跑。
打印 NPU 是否可用、设备名、当前设备编号与可见卡数,确认识别到的是正确硬件。
在 CPU 上创建两个各含三个浮点数的一维张量,搬到 NPU 做加法,再把结果搬回 CPU。
打印输入与结果,并验证结果等于 [5.0, 7.0, 9.0];能说清 .npu() 与 .cpu() 各自完成了什么。
import warnings; warnings.filterwarnings('ignore', message=r'.*(owner does not match|Permission mismatch|TASK_QUEUE_ENABLE)')
import torch
import torch_npu # 注册 NPU 后端
# 四项环境自检
print(torch.npu.is_available()) # NPU 是否可用
print(torch.npu.current_device()) # 当前设备编号
print(torch.npu.device_count()) # 可见 NPU 卡数
print(torch.npu.get_device_name(0)) # 0 号卡名称
# 最小计算:搬入 -> 计算 -> 搬回
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, 5.0, 6.0])
c = (a.npu() + b.npu()).cpu()
print(c.tolist()) # [5.0, 7.0, 9.0]
预期结果 示例输出:NPU 可用 True;设备名一行(课程环境为 Ascend910ProA,其他环境可能是 Ascend910B3);a = [1.0, 2.0, 3.0]、b = [4.0, 5.0, 6.0];a + b = [5.0, 7.0, 9.0](Hello, we are running on NPU.)。验收标准:看到可用状态与设备名、加法结果正确、能解释两次搬运各做了什么。
常见坑 只 import torch 不 import torch_npu → torch.npu 不存在或 .npu() 报错;NPU 不可用还硬跑后面的实验,会把"环境问题"误判成"代码问题"。
实验
LAB 09.2
实验 1 · 在 NPU 上计算 z = x² + y,做形状/类型/数值三重验证
难度 ★☆☆
对应手册「实验 1」
考察:张量创建、设备搬运、逐元素运算
实验目的:用最小代价走通"CPU 创建 → 搬入 → 设备计算 → 搬回 → 验证"的完整链路,并养成三重验证的习惯。
在 CPU 上创建两个形状 (1000,)、dtype 为 float32 的张量,分别全填充 2.0 与 3.0(用 torch.full 一次填满,比 ones() * 2 少一个算子)。
分别 .npu() 搬到设备;在 NPU 上执行 x * x + y 得到 z,并查看 z 的设备信息。
把 z 搬回 CPU;构造同样全为 7.0 的期望张量,用 torch.allclose 做数值比较。
额外检查形状是否为 (1000,)、dtype 是否为 torch.float32,凑齐形状、类型、数值三重验证。
必做变体:把长度改成 5000、换成另一对数,先手算期望值再运行验证。
预期结果 示例输出:z 的前 5 个元素 [7.0, 7.0, 7.0, 7.0, 7.0];z 的设备 npu:0;z 的形状与类型 (1000,), torch.float32;验证结果 ✓ 通过。因为 2.0² + 3.0 = 7.0,所以所有元素相同;设备字段显示 npu:0,说明结果确实来自设备侧计算。顺带算一下:1000 × 4 字节 = 4000 字节 ≈ 3.9 KB,这么小的数据搬运耗时几乎测不出来。
常见坑 用默认 dtype 创建张量,导致 float64 与 float32 混杂;期望张量留在 NPU 上、结果却在 CPU 上,比较时报设备不一致;用 == 而不是 allclose,浮点误差让验证"假失败"。
实验
LAB 09.3
实验 2 · CPU vs NPU 矩阵乘法:先学会正确计时,再谈加速比
难度 ★★☆
对应手册「实验 2 + 实验 2 选做」
matmul_bench.py
实验目的:掌握正确的 NPU 计时方法,观察矩阵规模对加速比的影响;选做部分用 FP16 体验"精度换速度"。
固定随机种子,对 128、512、2048 三种规模分别创建两个随机 FP32 方阵。
CPU 侧执行矩阵乘并计时,作为基准。
把两个矩阵搬到 NPU;搬运完成后先 torch.npu.synchronize() 排空搬运任务,再开始计时。
执行矩阵乘,再次同步等待计算真正结束,停止计时;结果搬回 CPU 与基准做带容差比较。
打印每种规模的 CPU 耗时、NPU 耗时、加速比与一致性;每轮结束释放张量,降低显存压力。
选做:在规模 2048 下重复计算 20 次,对比 CPU FP32 基准、NPU FP32、NPU FP16;NPU 部分先预热 3 次排除首次算子编译;最后同时看耗时、加速比与和 CPU 结果的最大绝对差异。
规模 N CPU 耗时 NPU 耗时 加速比 结果一致
128 0.51 ms 0.23 ms 2.2× ✓
512 1.32 ms 0.21 ms 6.3× ✓
2048 128.16 ms 0.44 ms 289.8× ✓
数据为课程环境的示例/实测,仅用于感受数量级,换机器与版本就会变。
预期结果 示例结果见上表:规模越大,算术强度越高,NPU 的并行优势越容易发挥,加速比从 2.2× 升到 289.8×。选做部分:FP16 通常更快(材料给出的量级是 Cube 对 FP16 的吞吐约为 FP32 的 3 倍),但与 CPU 基准的最大绝对差异也会变大——这就是"精度换速度"的权衡,是否采用取决于业务对误差的容忍度。所有数字都要注明是示例还是本机实测。
常见坑 ① 计时范围把搬运也算进去,加速比被拉低;② 只测一次就下结论,单次抖动大,应重复多次取平均;③ 不预热,第一次的 JIT 编译耗时被当成"NPU 慢";④ 用 == 比较 CPU 与 NPU 结果,累加顺序不同必然误报。
实验
LAB 09.4
实验 3 · Batch 矩阵乘法 vs 循环单次矩阵乘法
难度 ★★★
对应手册「实验 3」
考察:Batch 运算、算子调用开销
实验目的:理解"一次算子调用 = 一次 Kernel 启动"的固定开销,以及批量接口为什么能把它省掉。
固定矩阵维度为 256,构造批量随机 FP32 张量。
对批量数 8、32、128,分别用 torch.bmm 与 for 循环加 torch.stack 完成相同的批量矩阵乘。
两种方式各预热一次并同步;计时前后都同步,每种方式重复 20 次取平均。
用带容差方式验证两者结果一致,打印耗时表与加速比。
必做思考:解释为什么批量数越大,批量接口的加速比越高。
批量 B bmm 耗时 循环耗时 加速比 结果一致
8 0.04 ms 0.55 ms 12.5× ✓
32 0.20 ms 1.98 ms 45.3× ✓
128 0.07 ms 7.71 ms 107.8× ✓
数据为课程环境的示例/实测;单次耗时存在毫秒级抖动,重点看数量级与趋势。
预期结果 示例结果见上表:批量 8 / 32 / 128 的加速比约 12.5× / 45.3× / 107.8×。每一次 torch.matmul 调用背后都是一条"下发、调度、Kernel 启动"的固定链路,开销在 0.05–0.1 ms 量级、与矩阵大小无关;循环方式每次都要走一遍,B 越大累计越多,而 torch.bmm 一次调用完成全部。注意结论有前提:矩阵本身很大时,单次计算时间远大于启动开销,循环的劣势会被淹没。
常见坑 循环结果没有 stack 成三维,无法与 bmm 直接比较;计时把张量创建也算进去;bmm 漏掉 warmup;两种方式的输入张量不是同一份,布局或设备不同导致对比失真。
实验
LAB 09.5
实验 4 · 图像高斯模糊:为什么单张图 NPU 反而更慢
难度 ★★★
对应手册「实验 4」
考察:卷积运算、图像处理、算术强度
实验目的:理解算术强度对加速效果的影响,学会分析"为什么 NPU 不一定比 CPU 快"——这是全章最重要的反例。
读取图片,转成 [1, 3, H, W] 的 FP32 张量:permute(2, 0, 1) 通道前置、unsqueeze(0) 加批量维、除以 255 归一化到 0~1。
构造归一化的 5×5 高斯核:一维权重外积成二维核,再沿通道复制成 [3, 1, 5, 5] 三组。
在 CPU 上执行分组卷积:groups=3(三个颜色通道各自卷积)、padding=2(保持 512×512 尺寸),并计时。
NPU 侧把图像和卷积核搬过去,同步后计时,计算后再同步,最后把结果搬回 CPU。
打印 CPU 耗时、NPU 耗时、加速比与最大绝对差异,并断言输出形状不变。
预期结果 示例输出:图片张量形状 torch.Size([1, 3, 512, 512]);CPU 卷积耗时 6.77 ms;NPU 卷积耗时 51.35 ms;加速比 0.1×。结论:单张 512×512 图的计算量很小(约两千万次乘加),却要把约 3 MB 数据搬进搬出,5×5 卷积的算术强度仅约 0.48 FLOPs/Byte,属于访存密集,搬运与固定开销压倒了计算优势。改进方向:增大批量、增加通道数、改用可分离卷积减少计算量。
常见坑 忘记 permute,HWC 当成 NCHW 乱算;groups 设成 1,三通道信息混色;padding 不设 2,输出缩成 508×508;像素不归一化,数值溢出。
实验
LAB 09.6
实验 5–7 · 搬运成本、批量图像与可分离卷积
难度 ★★☆–★★★
对应手册「实验 5–7」
bandwidth.py / batch_blur.py / separable.py
实验目的:三个实验从三个侧面回答同一个问题——搬运有多贵、批量能不能摊薄固定开销、少算是不是就等于快。
实验 5:分别创建 1 MiB、16 MiB、64 MiB 的 FP32 一维张量,按字节数反推元素个数。
实验 5:先搬一次做预热并建立搬运路径;同步后开始计时,重复多次搬入取平均;同样方法测搬回耗时。
实验 5:用"字节数 ÷ 平均耗时"计算 Host → Device 有效带宽(GB/s),注意 MiB 是二进制单位、GB/s 是十进制单位,换算别混。
实验 5:用完全相等验证往返数据一致——纯搬运不涉及浮点运算,不需要容差。
实验 6 · 批量图像吞吐量 对批量 1、4、16、32 分别做 CPU 与 NPU 分组卷积,每种重复 5 次取平均;输入与卷积核提前搬到 NPU,表中只统计纯卷积时间,不含搬运;同时观察加速比与吞吐量。
实验 7 · 二维卷积 vs 可分离卷积 把 5×5 二维核拆成 1×5 横向加 5×1 纵向两次卷积,每像素乘加从 25 次降到 10 次;但两次卷积就是两次算子调用,小图上额外开销可能吃掉收益。
预期结果 实验 5 :数据量越大,单次搬运耗时越长,但固定开销占比下降,有效带宽更接近峰值;实测带宽通常低于接口的名义峰值,因为还包含驱动、协议、内存页与同步开销;往返数据完全一致。
实验 6 :批量为 1 时 NPU 可能仍比 CPU 慢;批量增大后并行资源利用率提高,吞吐量上升。加速比看"单次快多少",吞吐量看"单位时间处理多少",批量场景应看后者。计时边界是不含搬运的纯卷积,端到端收益要另按实验 5 的方法补算。
实验 7 :两种实现的输出在合理浮点容差内一致、空间尺寸不变;可分离卷积乘加少约 60%,但小图上可能被两次算子调用的额外开销抵消。如果可分离版本反而更慢,不代表实现错误,而是说明"减少计算量 ≠ 减少耗时"。两次卷积的填充方向不同:第一步只补左右,第二步只补上下,合起来才等价于二维卷积。
常见坑 实验 5 的 MiB 与 GB 换算混用(1 MiB = 1.048576 MB),会让带宽整体偏约 5%;实验 6 把搬运算进卷积计时,结论失真;实验 7 两次卷积的 padding 方向搞反,输出尺寸或数值不对。
10 秒自测 · 点开看答案
问题:实验 6 为什么只统计卷积计算时间,不含 Host ↔ Device 搬运?
答案:为了单独观察批量对卷积吞吐的影响;端到端收益要把搬运按实验 5 的方法单独测量后再分析。
面试
KP 09.8
基础实验总结:加速比由三个因素共同决定
一句话 算术强度、搬运量、固定开销——上 NPU 前先过这三道题。
八个基础实验围绕同一个问题:什么情况下把计算放到 NPU 上才真的更快?答案不是"看芯片型号",而是看三个因素:
算术强度 :计算量 ÷ 访存量。矩阵乘 N=2048 时约 341 FLOPs/Byte,5×5 卷积单像素只有约 0.48;前者计算密集、后者访存密集,加速比能差上千倍。
数据搬运量 :数据要先搬到 Device 才能算,算完可能还要搬回 Host。搬运是异步的,也是要花时间的;中间结果尽量留在 NPU 上接着算。
固定开销 :每次算子调用都有 Kernel 启动与调度成本,约 0.05–0.1 ms 量级。批量越大、单次计算越小,这笔开销占比越高。
五个关键结论(来自手册的实验总结):
设备搬运 :搬入才能计算,中间结果尽量留在 Device 上,减少往返。
异步计时 :计时前后都要同步;性能测试还要预热并多次取平均。
数值验证 :不同设备浮点累加顺序不同,用容差比较;只有纯搬运才用完全相等。
批量计算 :批量接口减少调度与 Kernel 启动次数,适合大量小矩阵或批量图像。
性能本质 :加速比不是固定数字;减少计算量不等于减少耗时。
实验 2 · 规模 128 → 2048,加速比 2.2× → 289.8×,算术强度随 N 线性增长。
实验 3 · 批量 B=8 → 128,加速比 12.5× → 107.8×,循环的固定开销越摊越贵。
实验 4 · 反例 单张 512×512 图只有 0.1×:算得少、搬得多,NPU 也会输。
实验 5–7 · 端到端 搬运、批量、可分离卷积——优化计算量不等于优化总耗时。
生活类比 上 NPU 像请一支专业施工队:工程量够大(算术强度高)、材料一次运够(搬运少)、队伍不用反复进场(固定开销摊薄),才比你自己慢慢干更划算。
10 秒自测 · 点开看答案
问题:可分离卷积乘加次数少了约 60%,为什么小图上不一定更快?
答案:省的是计算量,但多了一次算子调用;小图上固定开销与搬运占比高,抵消了计算量的收益。
"加速比不是固定数字,它由算术强度、数据搬运量和固定开销共同决定。" —— 《NPU 实践实验手册》
实验
LAB 09.7
进阶实验 1 · 混合精度训练与梯度缩放
难度 ★★☆
关键 API torch_npu.npu.amp.GradScaler / autocast
实验目的:在单卡 NPU 上跑通一次完整的 FP16 混合精度训练迭代,验证"缩放损失 → 反向传播 → 缩放器更新"这条链路,并理解为什么半精度训练离不开梯度缩放。原理上,FP16 把激活与权重的中间结果位宽减半,显存和吞吐都受益;但 FP16 的表示范围窄,小梯度容易下溢成 0,参数就学不动——缩放器先把损失放大再反传,更新前由 step 内部反缩放,并在检测到 Inf/NaN 时跳过本次更新;autocast 则按算子自动决定用哪档精度。网络故意做小(约 53 万参数),重点不在刷精度指标,而在把设备、缩放器、上下文三个部件按正确顺序串起来。
搭三层小网络:1024 维输入映射到 512 维,接 ReLU,再映射到 10 类输出;把整个模型搬到 npu:0,优化器选 Adam、学习率 1e-3,损失用交叉熵。
用 torch_npu.npu.amp.GradScaler() 创建昇腾专属缩放器——注意不要误用 CUDA 版本的实现。
数据直接在 NPU 上生成:torch.randn(64, 1024, device='npu:0') 加 64 个取值 0–9 的标签,省掉一次主机到设备的拷贝。
在 torch_npu.npu.amp.autocast(enabled=True, dtype=torch.float16) 内完成前向与损失计算,再依次执行 scaler.scale(loss).backward()、scaler.step(optimizer)、scaler.update(),最后打印损失。
预期结果 先出现两行来自 NPU 侧的「非有限值检查与反缩放」提示,这是缩放器在设备侧正常工作的告警、不是失败;随后打印单步迭代成功与当前 Loss,本次实测约 2.3757 (随机数据,每次都会变)。验收看三点:迭代无异常、损失是有限正数、整个过程张量始终在 NPU 上(实测环境为 Ascend910ProA 单卡、设备号 0)。
设计要点/常见坑 三个坑最容易踩:①缩放器来源——必须用昇腾适配插件自带的 amp 模块,误用 CUDA 版会在设备侧报错或静默失效;②调用顺序——放大损失、反向传播、缩放器代更新、刷新缩放系数四步固定,顺序颠倒会导致梯度未还原或缩放系数长期不更新;③上下文范围——前向和损失计算都要放在 autocast 里,只包前向会把两套精度策略混在一起。设备侧出现告警但实验仍打印成功时,以形状、类型和有限数值为判据,不要只看告警;再确认 model 与输入张量的 device 都是 npu:0,"张量始终在 NPU"这条验收才算做实。
import torch, torch.nn as nn, torch_npu
device = torch.device('npu:0')
model = nn.Sequential(nn.Linear(1024, 512), nn.ReLU(), nn.Linear(512, 10)).to(device)
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
scaler = torch_npu.npu.amp.GradScaler() # 必须用昇腾版缩放器
x = torch.randn(64, 1024, device=device) # 数据直接建在 NPU
y = torch.randint(0, 10, (64,), device=device)
opt.zero_grad()
with torch_npu.npu.amp.autocast(enabled=True, dtype=torch.float16):
loss = loss_fn(model(x), y) # 损失也放在上下文内
scaler.scale(loss).backward() # 放大 → 反传
scaler.step(opt) # 反缩放 → 更新
scaler.update() # 刷新缩放系数
print(f"单步 Loss: {loss.item():.4f}") # 本次实测示例约 2.3757
10 秒自测 · 点开看答案
问题:GradScaler 为什么先把 loss 放大再 backward?
答案:FP16 下小梯度容易下溢成 0,放大 loss 等于同步放大梯度,让梯度落在可表示范围内;更新前由 scaler.step() 内部反缩放还原,一旦检测到 Inf/NaN 就跳过本次更新。
实验
LAB 09.8
进阶实验 2 · 多卡分布式与 HCCL 集合通信
难度 ★★☆
关键 API torch.distributed / backend='hccl'
实验目的:掌握分布式进程组的参数配置、进程与 NPU 卡的绑定,以及集合通信链路的构造方式。原理上,HCCL(Huawei Collective Communication Library)是 CANN 的集合通信库,在 PyTorch 分布式中以后端名 hccl 接入;多进程一般由 torchrun 拉起,用主节点地址与端口完成会合,再用 AllReduce 等算子把各卡的梯度或数据规约到一起。三个参数要分清:rank 是本进程编号,world_size 是总进程数,backend 决定走哪套通信库。
配置会合参数:MASTER_ADDR='127.0.0.1'、MASTER_PORT=29500,这是单机多卡的示例;正式多机环境要换成真实主节点地址。
导入分布式模块与昇腾适配插件,先用 dist.is_initialized() 判断进程组是否已初始化,避免在 Notebook 中重复初始化报错;若未初始化则打印正在初始化 HCCL 后端的提示。
调用 torch.npu.set_device(0) 把当前进程绑定到 0 号卡,再创建含 2.0、4.0、6.0 三个元素的测试张量,用 .cpu().tolist() 搬回主机打印,作为通信前基线。
在代码中预留 dist.all_reduce(tensor, op=dist.ReduceOp.SUM) 的位置(本次注释掉);若有多卡环境,用 torchrun --nproc_per_node=N 启动与卡数一致的进程,各进程按本地序号绑定各自的卡,初始化时指定 hccl 后端并启用 AllReduce,核对每张卡上的张量变为各卡数据之和。
预期结果 本次单卡实测输出 3 行:正在初始化 HCCL 分布式通信后端、通信前数据为 2.0 / 4.0 / 6.0、进程组与算子通信链路构造完成。必须如实记录:环境只有 1 张卡(Ascend910ProA、设备号 0),且 AllReduce 调用被注释,本次没有发生实际的多卡规约,只完成了链路与参数层面的验证;单卡输出不能当作多卡链路的证据,报告里要显式写出这条限制。多卡场景的验收标准是:world_size 等于卡数,各进程打印的规约结果一致且等于各卡张量之和。
设计要点/常见坑 后端名必须写 hccl,沿用 GPU 习惯写成 nccl 或 gloo 会初始化失败;建张量前忘记 set_device,所有进程会挤到 0 号卡,造成显存争抢甚至通信挂起;单卡下 AllReduce 退化为本地操作,把单卡输出写成「多卡通信验证通过」属于结论夸大——这也是本实验只能记"部分通过(单卡模拟)"的原因。
import os, torch, torch_npu, torch.distributed as dist
os.environ['MASTER_ADDR'] = '127.0.0.1' # 正式多机换真实主节点地址
os.environ['MASTER_PORT'] = '29500'
if not dist.is_initialized(): # Notebook 中避免重复初始化
print('[HCCL] 正在初始化 HCCL 分布式通信后端...')
torch.npu.set_device(0) # 建张量前先绑定本进程的卡
tensor = torch.tensor([2.0, 4.0, 6.0], device='npu:0')
print('[HCCL] 通信前数据:', tensor.cpu().tolist())
# 真正多卡由 torchrun 拉起,每进程按 local_rank 绑定各自的卡:
# dist.init_process_group(backend='hccl', rank=rank, world_size=world_size)
# dist.all_reduce(tensor, op=dist.ReduceOp.SUM) # 本次单卡环境注释掉
print('[HCCL] HCCL 进程组与算子通信链路构造完成!')
10 秒自测 · 点开看答案
问题:单卡环境里能验证 HCCL 的什么、不能验证什么?
答案:能验证后端参数、设备绑定与通信链路构造;不能验证真正的跨卡规约——AllReduce 在单卡下退化为本地操作,结论最多写"部分通过(单卡模拟)"。
实验
LAB 09.9
进阶实验 3 · torch_npu.profiler 性能剖析
难度 ★★☆
关键 API torch_npu.profiler.profile / tensorboard_trace_handler
实验目的:采集 CPU 与 NPU 两侧的硬件级 trace,学会定位算子耗时与 AI Core 利用率。原理上,性能剖析依赖 CANN 驱动层的埋点,采到的原始数据还要经 msprof 解析成可读 trace;首次运行常包含算子编译、初始化等一次性开销,所以必须先预热,循环内推进 step 才能把数据按迭代切分保存。trace 里 CPU 活动看任务下发与调度,NPU 活动看算子执行与等待间隙,两者对照才能判断是"算得慢"还是"等得久"。
在 npu:0 创建两个 4096×4096 的 FP16 矩阵,作为待测矩阵乘的输入。
预热设备:连续执行 3 次矩阵乘并 torch.npu.synchronize(),把编译与初始化开销排除在采样区间之外。
配置采集器:activities 同时开启 CPU 与 NPU 两类活动,打开 record_shapes=True 与 profile_memory=True,关闭堆栈采集 with_stack=False 以控制体积,并用 on_trace_ready=torch_npu.profiler.tensorboard_trace_handler("./npu_profile_results") 指定输出目录。
用采集器包住 5 次循环:矩阵乘 → 同步 NPU → prof.step() 推进采集;退出上下文后等待解析日志跑完,到输出目录找以 PROF_ 开头的结果,用 MindStudio Insight 或 TensorBoard 查看 AI Core 利用率、算子耗时排行与内存曲线。
预期结果 输出开始采集与采集完毕两条提示,中间是 msprof 对主机侧、设备侧数据的分析日志,最后给出解析总耗时(本次实测解析约 2–4 秒)。本次实测还伴随一条「采集仍在 RECORD 状态时停止」的告警,以及一条「2 条内存记录不完整」的提示,属于收尾阶段的常见现象,trace 仍正常生成。判读时先看算子耗时排行第一的是不是本次循环的矩阵乘,再看 AI Core 是否有明显空闲。验收标准:npu_profile_results 下出现 PROF_ 结果目录,且能被可视化工具打开。
设计要点/常见坑 不预热就把第一次迭代的耗时当稳态性能,是性能判读最常见的失真来源;循环里漏掉 synchronize() 会让耗时错位,漏掉 prof.step() 会导致 trace 保存不完整;只开采集却不设 on_trace_ready,事后找不到落盘位置。看 trace 时先抓 AI Core 利用率与算子耗时排行,别只盯总耗时。
import torch, torch_npu
x = torch.randn(4096, 4096, device='npu:0', dtype=torch.float16)
y = torch.randn(4096, 4096, device='npu:0', dtype=torch.float16)
for _ in range(3): # 预热:排除首次编译开销
torch.matmul(x, y)
torch.npu.synchronize()
with torch_npu.profiler.profile(
activities=[torch_npu.profiler.ProfilerActivity.CPU,
torch_npu.profiler.ProfilerActivity.NPU],
record_shapes=True, profile_memory=True, with_stack=False,
on_trace_ready=torch_npu.profiler.tensorboard_trace_handler('./npu_profile_results')
) as prof:
for _ in range(5):
z = torch.matmul(x, y)
torch.npu.synchronize() # 每次迭代同步,耗时才归属正确
prof.step() # 推进 step,trace 按迭代落盘
print('已保存至 ./npu_profile_results')
10 秒自测 · 点开看答案
问题:为什么循环里每步都要先 synchronize 再 step?
答案:NPU 是异步执行,同步后本次迭代的耗时才能正确归属;step 负责按迭代推进并落盘,两者配合 trace 才可读。
实验
LAB 09.70
进阶实验 4 · FlashAttention 融合算子调用
难度 ★☆☆
关键 API F.scaled_dot_product_attention
实验目的:用融合注意力算子完成一次带因果掩码的多头自注意力计算,验证调用链真正落到 NPU。原理上,标准自注意力会显式生成序列长度平方量级的注意力矩阵;本实验批次 2、16 个头、序列长度 2048,若物化该矩阵,单是中间结果就约 2.7 亿个元素(按形状估算)。PyTorch 的缩放点积注意力(SDPA)在昇腾上会自动映射到 ops-transformer 中的融合 FlashAttention 实现,避免这块显存开销。因果掩码的效果是:第 t 个查询位置只对 0…t 的键做加权,等价于把注意力矩阵的上三角遮掉。
设定多头参数:batch=2、num_heads=16、seq_len=2048、head_dim=64,贴近大模型推理场景。
在 npu:0 生成查询、键、值三个 FP16 张量,形状均为 (2, 16, 2048, 64),打印形状确认。
进入 torch_npu.npu.amp.autocast(enabled=True) 上下文,调用 F.scaled_dot_product_attention(q, k, v, is_causal=True),让因果掩码生效——每个位置只能看到自身及之前的位置,符合大语言模型解码语义。
调用 torch.npu.synchronize() 等待算子真正执行完毕,再读取输出,打印形状与所在设备,确认计算没有回落到 CPU 实现。
预期结果 输入与输出形状均为 2×16×2048×64,输出设备为 npu:0。本次实测打印三行提示:输入张量创建完成、算子执行成功、输出所在设备。验收标准:调用成功、形状不变、设备仍为 NPU;不要求此处的耗时数字,不要自行补一个"加速比";如要测耗时,也必须先同步再计时。
设计要点/常见坑 Q/K/V 的形状、数据类型与设备必须一致,融合算子才能命中:混用 FP16 与 FP32,或把其中一个留在 CPU,会触发回退或直接报错;因果掩码只适用于自回归解码,双向编码任务误开 is_causal=True 会把后半段上下文遮掉;长序列算子是异步执行的,取结果或计时前必须同步,否则拿到的是下发时间而非执行时间。
import torch, torch.nn.functional as F, torch_npu
B, H, L, D = 2, 16, 2048, 64 # 贴近大模型推理规模
q = torch.randn(B, H, L, D, device='npu:0', dtype=torch.float16)
k = torch.randn(B, H, L, D, device='npu:0', dtype=torch.float16)
v = torch.randn(B, H, L, D, device='npu:0', dtype=torch.float16)
print('输入形状:', q.shape)
with torch_npu.npu.amp.autocast(enabled=True):
out = F.scaled_dot_product_attention(q, k, v, is_causal=True) # 因果掩码
torch.npu.synchronize() # 同步后再取结果
print('输出形状:', out.shape, '设备:', out.device) # (2,16,2048,64) / npu:0
10 秒自测 · 点开看答案
问题:若把注意力矩阵物化,2×16×2048×2048 的 FP16 中间结果大约多大?
答案:约 2.68 亿个元素,按每元素 2 字节算约 512 MiB,此外还有 softmax 的临时张量;融合算子把这些中间量留在片上,省显存正是它的关键收益。
实验
LAB 09.71
进阶实验 5 · 多流并发与 Event 同步
难度 ★★★
关键 API torch.npu.Stream / torch.npu.Event
实验目的:用两条独立的 Stream 安排任务,并用 Event 建立跨流依赖,保证异步执行顺序正确。原理上,Stream 是 NPU 上的任务队列,同一条流内任务按提交顺序执行,不同流之间互不等待;当第二条流要消费第一条流的输出时,必须插入 Event——第一条流记录完成标记,第二条流等待该标记,否则会读到尚未写完成的结果。把有依赖的两次计算分到两条流,目的不是让它们真并行,而是给无依赖的搬运与计算留出交错空间。
在 0 号卡上创建两条独立的 NPU Stream(stream1、stream2),相当于开辟两条任务流水线。
准备 3 个 2048×2048 的 FP16 矩阵 a、b、c,作为两次矩阵乘的输入。
在 stream1 的上下文里执行 out1 = torch.matmul(a, b),并在该流内创建 Event、调用 event1.record(stream1) 打完成标记——Event 必须记录在生产数据的那条流上。
切到 stream2,先 event1.wait(stream2) 再执行 out2 = torch.matmul(out1, c);最后调用 torch.npu.synchronize() 做设备级同步,覆盖两条流,打印 out2 形状。
预期结果 本次实测输出两行:两个 Stream 异步任务执行完毕、最终输出形状为 2048×2048。验收标准:无报错、形状正确;如果感兴趣可以进一步对比单流与双流的耗时,但有依赖关系时不应预设一定加速——两条流可能排成一前一后,总耗时与单流接近也属正常。
设计要点/常见坑 不等 Event 就直接用 out1,可能读到未完成的数据且结果不稳定,最麻烦的是它往往不报错——属于静默错误;Event 记在错误的流上,等待就形同虚设;用了自定义流之后只同步默认流,可能漏掉 stream2 的任务,应使用设备级 synchronize;多流解决的是任务交织与等待问题,不等价于无条件提速,"执行成功"不能写成"性能翻倍"。排查这类问题的稳妥办法是:每次读取张量前都先同步,先保证结果正确,再谈并发收益。
import torch, torch_npu
device = torch.device('npu:0')
s1, s2 = torch.npu.Stream(device=device), torch.npu.Stream(device=device)
a = torch.randn(2048, 2048, device=device, dtype=torch.float16)
b = torch.randn(2048, 2048, device=device, dtype=torch.float16)
c = torch.randn(2048, 2048, device=device, dtype=torch.float16)
with torch.npu.stream(s1):
out1 = torch.matmul(a, b) # 第一条流先算
ev = torch.npu.Event()
ev.record(s1) # 在生产数据的流上记录
with torch.npu.stream(s2):
ev.wait(s2) # 先等依赖,再消费 out1
out2 = torch.matmul(out1, c)
torch.npu.synchronize() # 全局同步,覆盖所有流
print(out2.shape) # 预期 2048×2048
10 秒自测 · 点开看答案
问题:如果 Event 在 stream2 里 record,却让 stream2 自己 wait,会发生什么?
答案:Event 记录到了错误的流上,等待不覆盖真正的生产任务,out1 与 out2 之间可能出现竞态,而且通常不报错;记录必须发生在生产 out1 的 stream1 上。
实验
LAB 09.72
进阶实验 6 · torch.compile 图模式与整图下沉
难度 ★★☆
关键 API torch.compile(backend='npu')
实验目的:把多算子函数交给昇腾图编译后端编译执行,理解整图下沉如何减少主机与设备交互。原理上,逐算子执行时每个算子都要由主机下发一次;GE 图引擎把计算图捕获下来做算子融合并整图下沉,主机只下发一次图。它适合多算子连续、形状稳定的复合计算,动态分支多时收益会下降。判断值不值得上图模式,看函数里算子数量与形状是否稳定——三五个算子串联、固定 1024×1024,正是它的舒适区。
先探测可用后端:运行 torch._dynamo.list_backends() 打印当前环境支持的全部编译后端;本次实测列表中包含 npu,另有 cudagraphs、inductor、onnxrt、openxla、tvm 等,确认 npu 存在再继续。
定义三步复合函数:矩阵乘 → 加一个张量 → ReLU 激活,多算子串联更容易触发图融合。
在 npu:0 创建 3 个 1024×1024 的 FP16 张量作为输入。
用 torch.compile(complex_computation, backend='npu') 包装函数(此时尚未真正编译);第一次调用触发图捕获、算子融合与 GE 编译,耗时明显高于普通执行属正常现象,同步后打印输出形状;第二次调用复用已编译的图。
预期结果 输出形状为 1024×1024,说明图编译路径执行成功。本次实测出现一条「修改编译选项可能需要重置动态图状态」的提示,来自同一内核里多次调整编译配置,不影响结果。验收标准:首次调用无异常、输出形状正确;做性能对比时必须排除首次编译耗时;第二次同形状调用时,不应再出现图捕获日志。
设计要点/常见坑 后端名写成未注册的名字,会在首次调用时报错,参数要与探测结果一致;把首次调用耗时当作算子耗时,结论会严重偏高——稳态性能要看后续调用;同一内核反复更换编译选项时,可能需要重置编译状态或重启内核,忽略提示直接比较多次编译结果,容易把正常编译误判成性能异常。
import torch, torch_npu
print(torch._dynamo.list_backends()) # 确认列表里有 'npu'
def f(x, y, z):
return torch.relu(torch.add(torch.matmul(x, y), z)) # 三算子可融合
x = torch.randn(1024, 1024, device='npu:0', dtype=torch.float16)
y = torch.randn(1024, 1024, device='npu:0', dtype=torch.float16)
z = torch.randn(1024, 1024, device='npu:0', dtype=torch.float16)
opt_fn = torch.compile(f, backend='npu') # 这里只是包装,尚未编译
out = opt_fn(x, y, z) # 首次调用触发图捕获与编译
torch.npu.synchronize()
print(out.shape) # 预期 1024×1024
out2 = opt_fn(x, y, z) # 第二次复用已编译图
torch.npu.synchronize()
print(out2.shape)
10 秒自测 · 点开看答案
问题:为什么 torch.compile 包装后第一次调用特别慢、第二次就正常?
答案:第一次要完成图捕获、算子融合与 GE 编译,是一次性开销;编译图缓存后,后续同形状调用直接复用,计时口径必须把首次排除。
实验
LAB 09.73
进阶实验 7 · 异步非阻塞数据传输
难度 ★★☆
关键 API pin_memory=True / non_blocking=True
实验目的:用锁页内存配合非阻塞搬运,让主机侧不必等待拷贝完成,实现搬运与计算的流水线重叠。原理上,普通主机内存可能被操作系统换页,直接内存访问前需要先复制到临时缓冲;锁页内存(Pinned Memory)固定在物理内存里,可被设备直接读取、带宽更高。non_blocking=True 让主机提交搬运指令后立即返回,计算任务在同一个队列里自动排队等待数据到达。主机提交搬运后立刻打印提示,是成本最低的"是否阻塞"探针;更严格的对比要另写循环,分别统计锁页与分页两种路径的平均耗时。
在 CPU 侧创建两个 4096×4096 的张量,开启 pin_memory=True,为高带宽搬运做准备。
用 .to(device, non_blocking=True) 把两个张量搬到 npu:0;主机只提交指令,不等待拷贝结束。
紧接着在主机侧打印后续提示;若立刻返回,说明主机没有卡在拷贝上,这是异步生效的直观证据。
在 NPU 上发起矩阵乘(运行时会在队列里自动等待数据搬运完成,无需手写等待),再 torch.npu.synchronize() 显式同步后打印结果形状。
预期结果 本次实测输出三行:开始异步非阻塞传输、主机侧已提交传输任务、流水线执行完毕;最终结果形状为 4096×4096。验收标准:三步输出齐全、结果形状正确。本单元格只验证机制,未给出与同步搬运的量化对比,不要自行编造加速比;若要写性能结论,必须补一组锁页与分页内存的对照测量。
设计要点/常见坑 源张量不在锁页内存时,non_blocking 的异步效果会打折扣,可能退化为同步拷贝——普通可分页内存要先复制到临时缓冲;搬运提交后到同步完成前,不要修改或释放主机侧源张量,否则搬过去的内容不确定;读取结果、计时、打印设备数据前必须同步;锁页内存不可换出,一次性锁几十 GB 会挤压主机可用内存。
import torch, torch_npu
device = torch.device('npu:0')
a = torch.randn(4096, 4096, pin_memory=True) # 锁页内存
b = torch.randn(4096, 4096, pin_memory=True)
print('[异步传输] 开始异步非阻塞传输...')
na = a.to(device, non_blocking=True) # 主机提交后立即返回
nb = b.to(device, non_blocking=True)
print('[异步传输] 主机侧已提交传输任务') # 能立刻打印说明未阻塞
out = torch.matmul(na, nb) # 队列自动等数据到达
torch.npu.synchronize() # 取结果前显式同步
print('[异步传输] 流水线执行完毕,形状:', out.shape) # 4096×4096
10 秒自测 · 点开看答案
问题:只写 non_blocking=True 但不加 pin_memory=True,还能真正异步吗?
答案:很难。普通可分页内存要先复制到临时锁页缓冲,主机侧仍要参与,异步收益基本消失,可能退化为同步拷贝;真正生效的前提是源张量本身就在锁页内存。
实验
LAB 09.74
进阶实验 8 · 动态 Shape 编译与后端降级
难度 ★★☆
关键 API torchair.get_npu_backend / 自动降级 'npu'
实验目的:掌握昇腾图编译后端的探测与自动降级,并验证编译后的图可被重复复用。原理上,大语言模型推理中批次或序列长度经常变化,若每个尺寸都重新编译,首包延迟会反复出现;图模式配合动态形状能力,可以让一份编译图覆盖多种尺寸。本单元格重点在后端探测、降级与图复用,未构造变长输入。TorchAir 是昇腾的图模式扩展包,标准 npu 后端则是兜底;先探测再降级,没有独立包的机器也能跑通同一段代码。
探测并加载图后端:先尝试 import torchair as tng 并调用 tng.get_npu_backend();若环境未安装该独立包,则自动降级到标准的 npu 后端。本次实测成功加载 torchair。
复用实验六的三步复合函数(矩阵乘 → 加 → ReLU),在 npu:0 创建 3 个 1024×1024 的 FP16 张量。
把探测到的后端传给 torch.compile 完成编译包装,并打印正在编译的提示;第一次调用触发图捕获与 GE 优化,同步后打印输出形状,作为编译成功的判据。
用同样的输入再调用一次,直接复用已编译的优化图并打印形状,验证稳定性;若要真正验证动态形状,需另取不同批次或不同序列长度的输入再执行,观察是否复用同一张图、是否避免重新编译。
预期结果 本次实测输出后端加载成功提示、编译提示,以及第一次、第二次执行成功与各形状,两次形状均为 1024×1024。本次同样出现「修改编译选项需要重置」的提示,可忽略。验收标准:两次执行都成功且形状一致;动态形状部分为待补充用例,不计入通过项——本次只验证了图复用。
设计要点/常见坑 环境没装 torchair 却硬指定 torchair,会在导入阶段直接失败,必须先探测再降级;同一形状跑两次只能证明图可复用,不能证明动态 Shape 通过,报告里不能写成"动态 Shape 验证通过";换尺寸时触发一次重新编译是正常机制,看到编译日志就判定实验失败是误读。
import torch, torch_npu
try:
import torchair as tng
backend = tng.get_npu_backend() # 优先使用 TorchAir 图后端
print('[TorchAir] 成功加载图编译后端')
except ImportError:
backend = 'npu' # 没有独立包就自动降级
print('[TorchAir] 未检测到 torchair,回退 npu 后端')
def f(x, y, z):
return torch.relu(torch.matmul(x, y) + z)
x = torch.randn(1024, 1024, device='npu:0', dtype=torch.float16)
y = torch.randn(1024, 1024, device='npu:0', dtype=torch.float16)
z = torch.randn(1024, 1024, device='npu:0', dtype=torch.float16)
fn = torch.compile(f, backend=backend)
print(fn(x, y, z).shape) # 首次:捕获 + 编译
print(fn(x, y, z).shape) # 同形状:复用编译图
10 秒自测 · 点开看答案
问题:用相同形状的输入跑两次,能证明动态 Shape 编译通过吗?
答案:不能,只能证明编译图可复用;要验证动态形状,必须换不同批次或序列长度再执行,观察同一份图是否被复用、是否避免重新编译。
实验
LAB 09.75
进阶实验 9 · 显存池管理与精细化监控
难度 ★☆☆
关键 API memory_allocated / max_memory_allocated / empty_cache
实验目的:掌握已分配显存、历史峰值的查询与缓存池清理,理解"删除变量不等于显存立刻归还"。原理上,框架向驱动申请的大块显存会留在自己的显存池里循环使用:删掉张量引用后,已分配统计会立刻下降,但缓存仍被池保留;只有主动清空缓存池,才会把空闲块交还。8192×8192 的单精度矩阵约占 256 MiB(8192×8192×4 字节),正好对应本实验观测到的增量。四次读数正好对应"申请—占用—释放引用—清缓存"四个动作,报告里要把读数与动作一一对应。
先调用 torch.npu.empty_cache(),打印 memory_allocated 作为本次观测的起点(基线)。
在 npu:0 创建一个 8192×8192 的单精度矩阵,对应约 256 MiB 的设备内存。
打印创建后的已分配显存,以及 max_memory_allocated 历史峰值统计;峰值用于评估是否会触发显存溢出。
删除该大矩阵的 Python 引用后再次打印已分配显存,观察统计值回落;再手动调用 empty_cache() 打印清理后的显存,确认池中空闲块被释放。最后把四次读数(基线、创建后、删除后、清理后)连同峰值列成一张对照表。
预期结果 本次实测数值:初始化约 285.38 MB 、创建大矩阵后约 541.38 MB (增加约 256 MB)、历史峰值约 541.38 MB、删除变量后回落到约 285.38 MB 、清理缓存后仍约 285.38 MB。峰值与创建后相等,说明进程此前没有更大的历史占用。增量与矩阵体积吻合,说明统计口径正确;不同机型与进程状态下的基线数值会不同。验收标准:四步打印齐全,且峰值不小于创建后的已分配值。
设计要点/常见坑 "已分配"与"缓存保留"是两个口径,混用会得出「删了变量显存没降」的错误结论;max_memory_allocated 是进程启动以来的历史最大值、跨实验会累计,未重置就直接比较两次实验数值会偏高;empty_cache 只释放空闲块,正在被引用的张量不受影响,在每个迭代里频繁清空缓存反而增加重新申请开销。解释 256 MB 增量时,直接用 8192×8192×4 字节推导,比背数字更稳。
import torch, torch_npu
device = torch.device('npu:0')
torch.npu.empty_cache()
print(f'初始化已分配: {torch.npu.memory_allocated(device)/1024**2:.2f} MB') # 约 285.38
big = torch.randn(8192, 8192, device=device, dtype=torch.float32) # 约 256 MB
print(f'创建后: {torch.npu.memory_allocated(device)/1024**2:.2f} MB') # 约 541.38
print(f'历史峰值: {torch.npu.max_memory_allocated(device)/1024**2:.2f} MB') # 约 541.38
del big
print(f'删除后: {torch.npu.memory_allocated(device)/1024**2:.2f} MB') # 回落 285.38
torch.npu.empty_cache()
print(f'清缓存后: {torch.npu.memory_allocated(device)/1024**2:.2f} MB') # 约 285.38
10 秒自测 · 点开看答案
问题:删除大矩阵后 memory_allocated 已回落到 285.38 MB,为什么工程里还要调用 empty_cache()?
答案:del 只是把块归还到框架的缓存池,已分配统计立刻回落,但池仍占着 HBM,可能影响同卡其他任务;empty_cache 才把空闲块交还驱动。本次清理前后读数相同,是因为期间没有新的分配,属于正常现象。
实验
LAB 09.76
进阶实验 10 · 动态量化与兼容方案
难度 ★★☆
关键 API torch_npu.npu_dynamic_quant
实验目的:掌握原生量化算子的探测方法、兼容回退逻辑,以及当前环境下的失败定位。原理上,INT8 量化用更低的位宽换取更高吞吐,动态量化会按输入分布现场计算缩放因子(scale);调用前先探测当前 torch_npu 版本是否挂载了顶级算子接口,若没有就退回通用量化方案,同时要考虑通用方案对输入精度的限制。动态量化不需要离线校准数据,scale 由当次输入现算,适合激活值分布逐批变化的大模型推理。
按 batch=4、seq_len=512、hidden_dim=4096 的形状,在 npu:0 创建 FP16 输入张量,模拟大模型一层的激活输出;打印原始数据类型与形状作为量化前基线。
用异常保护包住整个量化过程,先检查昇腾适配插件是否挂载动态量化算子的顶级接口:hasattr(torch_npu, 'npu_dynamic_quant')。
分支一(接口存在):调用 torch_npu.npu_dynamic_quant(input_tensor) 完成 FP16 到 INT8 的动态量化,打印量化输出的形状、数据类型以及缩放因子的形状。
分支二(接口不存在):打印降级提示,改用通用逐张量量化 torch.quantize_per_tensor(input_tensor.cpu(), scale=0.01, zero_point=0, dtype=torch.qint8) 演示;任何一步抛出异常都打印执行提示,便于定位是接口缺失还是数据类型不支持。
预期结果 本次实测未通过:探测结果为「当前 torch_npu 版本未直接挂载该顶级接口」,因此走了兼容分支;兼容分支随即抛出「量化只接受单精度浮点张量,收到的是半精度」的提示,说明通用量化接口不接受 FP16 输入。结论:本次没有得到有效的 INT8 输出与缩放因子,属于环境限制导致的待修复项,不能记作通过。成功时的验收标准:输出形状与输入一致、数据类型为 INT8、缩放因子形状合理且可与量化值配套还原。
设计要点/常见坑 把降级提示误读成「原生算子调用成功」;直接把 FP16 张量喂给通用量化接口会抛类型错误——要么先把张量转成单精度,要么升级 CANN 与 torch_npu 到提供该动态量化算子的版本,或到适配插件内部模块重新查找算子的挂载路径;只看到「执行提示」就判定实验通过,必须看到 INT8 输出与缩放因子才算完成,本次应如实按"未通过"提交。若走原生分支,要核对 scale 的形状与输出 dtype;若走兼容分支,先 .float() 再量化,并记录是哪一步失败。
import torch, torch_npu
x = torch.randn(4, 512, 4096, device='npu:0', dtype=torch.float16) # 大模型激活
print('原始:', x.dtype, x.shape)
try:
if hasattr(torch_npu, 'npu_dynamic_quant'):
q, scale = torch_npu.npu_dynamic_quant(x) # 原生 INT8 动态量化
print('量化输出:', q.shape, q.dtype, 'scale:', scale.shape)
else:
print('未挂载顶级接口,改走通用兼容方案')
q = torch.quantize_per_tensor(x.cpu(), scale=0.01, zero_point=0,
dtype=torch.qint8) # 本次在此报精度错误
print('兼容方案输出:', q.dtype)
except Exception as e:
print('执行提示:', e) # 量化只接受单精度浮点张量,收到半精度
10 秒自测 · 点开看答案
问题:本次动态量化实验失败的直接原因是什么?
答案:当前 torch_npu 未挂载 npu_dynamic_quant 顶级接口,回退的通用量化接口只接受 FP32,传入 FP16 触发类型错误;这属于环境限制,应按"未通过"记录并按调整建议重跑。
实验
LAB 09.17
进阶实验总结 · 三因素、五结论与验收清单
一句话 NPU 快不快,最后都落到三笔账:算术强度、搬运量、固定开销。
十个进阶实验看似各管一段——精度、通信、剖析、融合算子、多流、图模式、异步搬运、动态 Shape、显存、量化——其实都在回答同一个问题:怎样让 NPU 既算得快、又算得对。把 NPU 实验手册的实验总结搬过来,答案由三个因素共同决定。
算术强度 :计算量与访存量之比。矩阵乘、注意力这类高算术强度算子才喂得饱 Cube 单元;小算子、单张图卷积容易被固定开销主导,放到 NPU 上未必更快。
数据搬运量 :Host 与 Device 之间的 H2D/D2H 以及 HBM 读写。实验四不物化 2048×2048 的注意力矩阵、实验七用锁页内存加非阻塞搬运、实验五把中间结果留在 NPU 继续算,都是在减少搬运。
固定开销 :Kernel 启动、任务下发、图编译、显存申请这些不随计算量增长的成本。实验三用 profiler 把它看见,实验六用整图下沉把它摊薄,实验五用多流把它藏起来。
记忆时可以把三因素缩成一句:算得够不够(算术强度)、搬得多不多(搬运量)、启动贵不贵(固定开销);以后再遇到"NPU 怎么没变快",先按这三项拆,而不是先怀疑硬件。
在这个框架下,十个实验可以归成五条结论(据 NPU 实验手册的实验总结,对应到本章实验):
设备搬运 :能在 Device 上算的就别搬回 Host,中间结果尽量留在 NPU 继续算(实验四、五)。
异步计时 :NPU 异步执行,取结果、计时前必须同步;性能测试先预热、多次取平均,否则测到的只是任务下发时间或首次编译开销(实验三、六、七、八)。
数值验证 :跨设备浮点累加顺序不同,用带容差的比较;只有纯搬运才用完全相等验证(实验一、四、九)。
批量与融合 :批量接口、融合算子能减少调度与 Kernel 启动次数,尤其适合大量小算子(实验四、五、六)。
性能本质 :加速比不是固定数字,与算术强度、搬运量、固定开销共同相关;「执行成功」不等于「性能提升」(实验五、六、七、八)。
五条结论也可以压成一句口诀:少搬、同步、对数值、批量融合、别迷信加速比。
验收清单 (据指导书附录 C,报告逐条打勾):
环境自检记录 NPU 可用状态、卡数与型号(本次实测 Ascend910ProA、1 张卡、设备号 0),并据此说明实验二为何只能做单卡模拟。
十个实验逐个运行,每个实验至少留存输出区截图或文本,标注对应步骤编号。
每个实验写一条结论:通过 / 部分通过 / 未通过,并给出判据(形状、设备、数据类型、输出文件)。据指导书验收表:实验十未通过(环境限制),实验二部分通过(单卡模拟),实验三、六带告警通过,实验八未覆盖变长输入,其余通过。
实验三额外提交 trace 结果目录名,并写出从 trace 中观察到的一条算子耗时或利用率结论。
实验九提交四个显存读数的对照,并解释 256 MB 增量与 8192×8192 FP32 矩阵体积的关系。
实验十如实写明当前环境的失败原因与已尝试的调整,不得按通过提交。
不提交代码清单;报告只检查步骤、输出与结论,代码以原 Notebook 为准。
报告里每个数字都要能追溯到一次打印或一张截图:形状、设备、dtype、目录名、数值,至少有一项能对上,验收时才不会被追问。
设计要点/常见坑 报告里最容易失分的是"结论口径":把单卡模拟写成多卡验证通过、把同形状两次执行写成动态 Shape 通过、把带告警通过写成完全通过、把实验十的兼容分支提示写成本地算子成功。这四个结论都必须加限定词,判据要落到形状、设备、dtype、目录或数值上。
实验
KP 09.9
npu-smi 三连:info、watch、health 各看什么
一句话 info 看总览、watch 看变化、health 看健康,三板斧按顺序来。
npu-smi 是驱动层最常用的命令行,三个子命令对应三种看法(补充,子命令随版本略有差异,以 npu-smi -h 为准):info 打印设备总览——设备号、型号、健康状态、温度、功耗、HBM 已用与总量、AICore 利用率;watch 在 info 基础上按固定间隔刷新,用来观察利用率与显存是否随迭代变化,判断负载到底有没有打在卡上;health 专门查健康状态与错误码。看到非正常状态或降频,先处理硬件与驱动,再谈性能。
npu-smi info # 总览:型号 / 健康 / 温度 / 功耗 / HBM / 利用率
npu-smi info watch -i 0 -c 0 -n 1 # 每秒刷新,看利用率与显存变化(补充)
npu-smi info -t health -i 0 # 健康状态与错误码(补充)
易错 现象:AICore 利用率长期 0%,却以为"NPU 就是快"。原因:任务没真正落到 NPU(漏了 import torch_npu,张量还在 CPU),或算子在等 Host 下发与同步。怎么办:先 npu-smi watch 看利用率与显存是否随训练波动,再回代码确认 device 字段是不是 npu:0。
10 秒自测 · 点开看答案
问题:想判断负载到底有没有打到 NPU 上,用哪个子命令?
答案:npu-smi info watch 连续刷新,看 AICore 利用率与 HBM 是否随迭代变化。
易错
KP 09.10
为什么每次都要 source:ASCEND_HOME_PATH 与 LD_LIBRARY_PATH
一句话 环境变量是进程级配置,新终端、新内核都得重新 source 一次。
CANN 装好后,环境变量不会自动"永久生效"到每个新进程:打开新终端、新建 Notebook 内核、切换虚拟环境,都是新进程,继承不到上一次的设置。所以要先 source 官方脚本(补充,路径以实际安装为准):ASCEND_HOME_PATH 指向 CANN 安装目录,脚本、头文件、算子库、install.info 全靠它定位;LD_LIBRARY_PATH 把运行时动态库目录加进搜索路径,缺了它 import torch_npu 会报找不到 .so;此外还有 PATH、PYTHONPATH 等配合。材料对云端环境的提醒也是这句:环境变量没加载,先跑环境初始化脚本。
易错 现象:终端里 source 过能跑,Jupyter 里 import torch_npu 却失败。原因:Notebook 内核是另一个进程,没继承环境变量。怎么办:在 Notebook 里先执行环境初始化脚本,再跑实验,别在终端里反复 source 自我怀疑。
10 秒自测 · 点开看答案
问题:为什么"终端里明明 source 过",Jupyter 里还要再来一次?
答案:source 只影响当前 shell 及子进程;Jupyter 内核是独立进程,需要自己再初始化。
易错
KP 09.11
三类高频报错:驱动不匹配、找不到 device、算子不支持
一句话 分层定位:卡层看 npu-smi,环境层看变量与内核,算子层看版本与清单。
三类报错按层排(补充):①驱动版本不匹配——npu-smi 报错、初始化提示版本不符,一般是驱动或固件与 CANN 不配套,按配套表升或降驱动;②device 找不到——torch.npu.is_available() 为 False,常见原因是环境变量没 source、容器没挂载设备、Jupyter 内核选错,先 npu-smi info 确认卡可见;③算子不支持——报 not implemented 或悄悄回落到 CPU,多因 CANN / torch_npu 版本旧、算子未覆盖或 dtype 与 shape 不支持,换等价算子、升版本,或用 Ascend C 自研。
现象 最可能的原因 首选处理
导入即报错、npu-smi 异常 驱动 / 固件与 CANN 不配套 按配套表对齐驱动与 CANN
is_available() 为 False 变量未 source、容器未挂载、内核选错 确认卡可见;重 source;选对内核
not implemented 或回落 CPU 版本旧、算子未覆盖、dtype/shape 不支持 换等价算子、升版本、自研算子
10 秒自测 · 点开看答案
问题:报"算子不支持"时按什么顺序排查?
答案:先查版本配套与输入 dtype / shape,再看有没有等价算子,最后才考虑自研。
公式
KP 09.12
四个指标一张嘴:吞吐量、时延、MFU、加速比怎么测
一句话 加速比看相对收益,吞吐看单位时间产量,时延看单次,MFU 看算力榨出几成。
四个指标回答四个不同问题(补充):加速比 = CPU 耗时 ÷ NPU 耗时,衡量同一负载换设备的相对收益;吞吐量 = 批量数 ÷ NPU 耗时,衡量单位时间处理多少,材料实验六就靠它说明"批量越大越划算",批量为 1 时 NPU 可能仍比 CPU 慢;时延是单次请求端到端耗时,包含 H2D/D2H 搬运与排队,决定"能不能实时";MFU(Model FLOPs Utilization)是实际达到的模型 FLOPs/s 与硬件峰值算力之比,衡量算力被榨出几成。测法统一:预热 3 次、计时前后同步、多次取平均。
指标 关注什么 什么时候看
加速比 同一负载的相对收益 单点性能对比
吞吐量 单位时间处理量 批量处理与服务容量
时延 单次端到端耗时 实时性要求
MFU 峰值算力利用率 大模型训练效率
10 秒自测 · 点开看答案
问题:为什么"加速比高"不等于"能上线"?
答案:加速比只比计算段;线上更看端到端时延与吞吐,搬运与排队都会改写结论。
实验
KP 09.13
多卡通信自证:用 all_reduce 与 hccl_test 验通链路
一句话 每张卡持一个可算的数,规约后人人都是总和,才叫真验证。
验证 HCCL 有个最朴素的办法(补充):用 torchrun 按卡数起进程,每个进程按本地序号 set_device 绑定自己的卡,初始化时 backend 必须写 hccl(沿用 GPU 习惯写 nccl 或 gloo 会失败);每张卡创建同形状张量并填入 rank+1,执行 all_reduce(SUM),正确结果应是每张卡都得到 N(N+1)/2。单卡环境只能构造链路、无法验证跨卡规约(材料 Notebook 里 AllReduce 被注释),CANN 自带的 hccl_test 可跑 all_reduce_test 等用例,看不同数据量下的带宽与时延,参数与路径以官方文档为准。
torchrun --nproc_per_node=2 train_hccl.py # 进程数必须等于可见卡数
# 关键三行(伪代码):
# dist.init_process_group(backend="hccl") # 后端名必须是 hccl
# t = torch.full((1,), rank + 1).npu()
# dist.all_reduce(t, op=dist.ReduceOp.SUM) # N=2 时两卡都应为 3
易错 单卡环境硬跑多卡:world_size 与实际卡数不一致,进程组初始化会挂起或直接报错。单卡只能验证参数配置与设备绑定,报告里写"部分通过",别写"多卡验证通过"。
10 秒自测 · 点开看答案
问题:2 卡,卡 0 填 1、卡 1 填 2,AllReduce(SUM) 后每张卡是多少?
答案:3,且两张卡都必须是 3;只看到卡 0 的打印不足以证明通信正确。
实验
KP 09.14
INT8 / FP16 / FP32:速度与误差到底差多少
一句话 位宽减半、速度涨、误差也涨;INT8 最划算也最挑场景。
三档精度是一条"速度换误差"的曲线(补充):FP32 是训练与精度基准,误差最小,但显存与带宽开销最大;FP16 位宽减半,访存量与显存占用都降,材料实验 2 选做里耗时更低,但与 CPU FP32 基准的最大绝对误差明显增大,能否使用看业务容忍度;INT8 再减半,靠 scale 与 zero_point 把浮点压成整数(动态量化现场算 scale),吞吐最高,但误差最大。材料实验十想把 FP16 激活压成 INT8,本次因接口未挂载、通用量化只吃 FP32 而失败,要如实记"未通过"。
精度 位宽 速度(材料口径) 误差表现 典型场景
FP32 32 bit 基准 1× 最小 训练基准、精度敏感推理
FP16 16 bit 更快(实验 2 选做:耗时更低) 最大绝对误差增大 混合精度训练、常规推理
INT8 8 bit 最高(动态量化榨算力) 需 scale 校准,误差最大 推理部署、大模型激活
10 秒自测 · 点开看答案
问题:实验十为什么报"量化只接受单精度、收到的是半精度"?
答案:走的兼容分支只接受 FP32 输入;先把 FP16 转 FP32,或用原生动态量化算子。
代码
KP 09.15
torch_npu 常用 API 速查:从 .npu() 到 profiler
一句话 设备查询、搬运、同步、amp、profiler、显存——六组 API 覆盖日常九成操作。
日常只用得上六组(补充):①设备查询——is_available、device_count、get_device_name、set_device;②搬运——.npu() 与 .cpu(),或在 npu:0 上直接创建省一次拷贝;③同步——torch.npu.synchronize(),读值、计时、断言与调试前必调;④混合精度——torch_npu.npu.amp.autocast 与 GradScaler,注意不是 CUDA 版;⑤剖析——torch_npu.profiler.profile 同时采 CPU 与 NPU;⑥显存——memory_allocated、max_memory_allocated、empty_cache。第七组常被漏掉:Stream 是任务队列,Event 用来定跨流依赖,等 Event 再消费上一流的结果,顺序反了会读到未完成数据。
import torch, torch_npu
torch.npu.is_available(); torch.npu.get_device_name(0); torch.npu.set_device(0)
x = torch.randn(3, device='npu:0') # 设备侧创建,省一次拷贝
y = torch.tensor([1.0]).npu() # 搬运默认异步
torch.npu.synchronize() # 读值 / 计时 / 断言前必调
scaler = torch_npu.npu.amp.GradScaler() # 昇腾版缩放器,不是 torch.cuda.amp
with torch_npu.npu.amp.autocast(enabled=True, dtype=torch.float16):
loss = model(x).sum()
torch_npu.profiler.profile(activities=[...], on_trace_ready=...) # 采集 trace
易错 两层混淆:误用 torch.cuda.amp.GradScaler,在 NPU 上不生效或设备侧报错;误用 torch.cuda.synchronize(),根本同步不到 NPU,计时依旧失真。迁移时把 torch.cuda.* 一次性替换成 torch.npu.* 更稳妥。
10 秒自测 · 点开看答案
问题:迁移完成后,怎么确认代码同步的是 NPU 而不是 GPU?
答案:看有没有 torch.npu.synchronize();CUDA 版管不到 NPU,误用会得到虚假耗时。
实验
KP 09.16
实验报告六段式:目的、环境、步骤、结果、分析、问题
一句话 六段填满、判据写清,未通过项如实写,就不丢分。
六段模板对着一份能验收的报告(补充):①目的——一句话说清验证什么、判据是什么;②环境——硬件型号与卡数、CANN / PyTorch / torch_npu / Python 版本与运行方式;③步骤——按编号写操作与关键命令,不贴整段代码;④结果——形状、设备、dtype、耗时与误差,并注明"示例"还是"实测";⑤分析——用算术强度、搬运量、固定开销三因素解释现象;⑥问题——如实写未通过项与原因。材料验收清单还额外要求:剖析实验要写 trace 结果目录名,显存实验要交四个读数,量化实验不得按通过提交。
段落 必须写清 常见丢分点
目的 验证什么、判据是什么 大段背景,没说清靶子
环境 型号 / 卡数 / 版本 / 内核 只写"NPU 环境"
步骤 编号操作与关键命令 整段粘贴代码
结果 形状 / 设备 / dtype / 耗时 / 误差 数字不标示例或实测
分析 用三因素解释现象 复述结果,没有归因
问题 未通过项与已尝试的调整 隐瞒失败、按通过提交
注意 单卡环境把多卡实验写成"验证通过"、只跑相同形状却写"已验证动态 Shape",都属于结论夸大;评审对照材料的环境限制一眼就能看出来。
10 秒自测 · 点开看答案
问题:报告里的耗时为什么必须注明"示例"还是"实测"?
答案:耗时与加速比随硬件、版本和随机数据变化;不注明来源,结论无法复现。
易错
KP 09.17
四条高频报错:找不到 device、驱动不配、环境没 source、版本不匹配
一句话 先看最后一个异常,再按卡、环境、版本、代码四层往下查。
报错先分层再动手(补充):找不到 device,多是环境变量没 source、容器没挂设备或 Jupyter 内核选错,先用 npu-smi 确认卡可见;驱动与固件不符,初始化阶段就报错,按配套表对齐;导入报找不到库文件,是库搜索路径没带上 CANN;插件与 torch 主次版本必须成对,不一致时导入就报符号错误。顺序从下往上,别一上来就重装。
典型现象 卡在哪层 一句话修法
is_available() 为 False 环境 / 容器 / 内核 重 source,确认 npu-smi 可见
初始化即报版本不符 驱动 / CANN 按配套表对齐,别单升一层
找不到 libascendcl.so 环境变量 补 LD_LIBRARY_PATH,重开内核
import 报符号错误 torch / torch_npu 两包成对升降,主次版本一致
易错 现象:终端里能跑,Jupyter 里 import 就失败。原因:内核是另一个进程,没继承环境变量。怎么办:在 Notebook 第一个 cell 执行环境初始化脚本,再打印设备名确认。
10 秒自测 · 点开看答案
问题:torch 2.4 配 torch_npu 2.1 能跑吗?
答案:不能,主次版本要一致,必须成对升降,否则 import 阶段就报错。
实验
KP 09.18
性能调优顺序:先搬家、再批量、再精度、再图模式、最后多卡
一句话 越便宜的改动越先做;单卡没调好就扩卡,等于白忙。
五步有严格顺序(补充):① 搬家——减少主机与设备之间的拷贝,在设备上直接建张量、开异步传输;② 批量——增大批量摊薄算子启动与固定开销;③ 精度——FP16 混合精度,用速度换误差,必须核对精度;④ 图模式——整图下沉,压住主机下发开销,动态形状会反复编译;⑤ 多卡——HCCL 集合通信放最后,否则通信会掩盖前四项收益。
易错 现象:一上来就开多卡,加速比不升反降。原因:通信与调度开销吃掉收益,也分不清瓶颈在计算还是通信。怎么办:按五步逐项做,每步单独测一次加速比。
10 秒自测 · 点开看答案
问题:为什么图模式排在精度之后?
答案:编译与融合会让掉点来源难判断;先解决精度问题,再上整图下沉,收益才干净。
实验
KP 09.19
从实验脚本到可交付服务:五类验收指标
一句话 正确性、性能、资源、稳定、可运维,五项都过才算能交付。
脚本变服务看五类指标(补充):正确性做精度回归,异常输入要有兜底;性能报 QPS 与 P50/P99 时延,不报均值;资源看 AICore 利用率与 HBM 水位,长跑查显存是否缓慢上涨;稳定性看错误率、超时率与长稳漂移;可运维要有日志、告警、健康检查与版本回滚。压测固定输入长度与并发数,否则数字无法复现。
维度 必看指标 常见坑
正确性 精度回归、异常返回 只测正常输入
性能 QPS、P50/P99、并发 只报均值不报长尾
资源 利用率、HBM 水位、泄漏 忽略显存缓慢上涨
稳定 错误率、超时率、长稳漂移 只跑一次 demo
运维 日志、告警、健康检查、回滚 没有版本号不可回退
10 秒自测 · 点开看答案
问题:上线前只报平均时延够不够?
答案:不够,长尾 P99 常决定体验,还要报 QPS、错误率与长稳漂移。
本章速查
三种安装 :CPU 版最易装但训练极慢;在线 GPU 版最标准;离线 whl 最快,但版本必须严格匹配。
版本四段 :torch 2.4.1 ↔ torchvision 0.19.1 ↔ torchaudio 2.4.1;cu121 = CUDA 12.1;cp310 = Python 3.10;win_amd64 = 64 位 Windows。
CUDA Version :nvidia-smi 显示的是驱动上限,向下兼容,不是必须安装的版本。
三处对齐 :终端提示符、IDE 解释器、Jupyter 内核指向同一个虚拟环境。
云端环境 :课程实测 Python 3.9 / torch 2.1.0 / torch_npu 2.1.0.post3 / CANN 8.0 / Ascend910ProA 单卡,以 npu-smi info 与 get_device_name(0) 为准。
四步链路 :CPU 创建 → .npu() 搬入 → 设备计算 → .cpu() 搬回;中间结果尽量留在 NPU 上。
异步 :下发即返回;读结果或计时前必须 torch.npu.synchronize()。
三要素 :计时前后同步、预热 3 次、用 allclose 容差比较;纯搬运用完全相等。
算术强度 :FLOPs ÷ Bytes;矩阵乘 N=2048 约 341、N=4096 约 683,5×5 卷积单像素约 0.48,相差约 1400 倍。
实测示例 :matmul 2.2× / 6.3× / 289.8×;bmm 12.5× / 45.3× / 107.8×;单张高斯模糊 0.1×(均为示例,环境不同会变)。
五结论 :搬运有成本、计时先同步、容差比相等可靠、批量摊薄固定开销、加速比由三因素共同决定。
进阶十题 :精度(autocast/GradScaler)、通信(HCCL)、性能(profiler/FlashAttention)、流水(Stream/Event)、图(torch.compile/动态 Shape)、数据(非阻塞搬运)、显存(缓存池)、量化(INT8)。
来源:《NPU 实践实验手册》(Hello NPU、实验 1–7、实验总结、概念速览与速查表);《torch 安装》PDF(三种安装方式、nvidia-smi、whl 版本匹配);CANN+NPU实验.ipynb(Cell 1–2 环境自检与张量搬运,Cell 3–12 进阶实验);《CANN+NPU 实验指导书》(环境要求、单元格对照与进阶实验 1–10);《云服务器使用.docx》(启智 OpenI 平台);CANN 基础课「NPU 实践」复习页与《04_npu_practice_appendix》;昇腾 CANN 软件配套说明(PyTorch / torch_npu / CANN 版本配套)。