HCIP-AI 学习 Snap
🔥 STREAK 1 天 · 2026 秋 · 期末知识库

把一学期的 AI 课
刷成 Snap 故事

词向量、文本分类、RNN、Seq2Seq、Transformer、CANN 与 NPU 实验——所有考点拆成一张张可以「刷」的知识卡。滑一下是一节,点一下翻面。

12章节
316知识卡
36实验卡
63代码段
CHAPTER STORIES

章节故事 · 点开头像直接跳转

CHATS · TABLE OF CONTENTS

目录 · 像刷聊天列表一样刷知识点

🧠
01 NLP 概论26 个知识点 · 自然语言与 NLP 定义、五层理解、四类歧义、发展三阶段
待读
🔤
02 词向量29 个知识点 · 9 个实验 · 从 OneHot 到 Word2Vec、GloVe、FastText、ELMo 的完整演进
待读
📄
03 文本分类30 个知识点 · 4 个实验 · 同一份四分类语料,四种打法逐层对照:从 TF-IDF 到 BERT
待读
🏷️
04 序列标注25 个知识点 · 从中文分词、词性标注、NER 到 HMM / CRF / BiLSTM+CRF 的一条主线
待读
💬
05 语言模型与文本生成23 个知识点 · 从 N-Gram、RNN 语言模型到 ELMo 动态词向量,外加解码策略与评估指标
待读
🔁
06 RNN 与 Seq2Seq34 个知识点 · 2 个实验 · 从时间步、隐藏状态到编码器-解码器与自回归生成
待读
🔀
07 Transformer39 个知识点 · 5 个实验 · 从 Seq2Seq 的信息瓶颈到自注意力、多头、BERT 与大模型时代的完整演进
待读
⚡
08 昇腾 AI 与 CANN31 个知识点 · 从第四次工业革命到 CANN 异构计算架构:看懂昇腾全栈、Atlas 硬件与一行代码的完整旅程
待读
🧪
09 NPU 实践20 个知识点 · 16 个实验 · 装好环境、跑通 Hello NPU,再用 18 个实验算清加速比从哪来
待读
🗂
10 实验与代码库7 个知识点 · 40+ 个实验、60+ 段代码与四分类数据集的一站式索引
待读
🧪
11 复习与自测13 个知识点 · 高频考点、公式速查、30 条易错点与 7 天复习路线
待读
📎
12 附录与索引3 个知识点 · 材料出处、缩略语、参考链接与更新日志
待读
① 刷故事点章节头像或目录行,跳到对应章节;读完进度环自动点亮。
② 翻卡片每张知识卡正面讲概念,黄色「一句话」是记忆点,自测可点开看答案。
③ 看实验实验卡含目的、步骤、预期结果与常见坑,配合代码索引查文件。
④ 查目录右上角 ☰ 打开全站小节目录;Ctrl K 全站搜索;🃏 随机抽卡自测。
01
NLP OVERVIEW

自然语言处理概论:机器如何读懂人话

先划清概念边界,再看机器理解语言的五层台阶、四类歧义与三代方法。

这一章是整门课的地基:先把「自然语言」「自然语言处理」「NLU / NLG」这几个名词的边界划清楚,再看机器要爬过哪五层台阶才算「读懂」,最后用四类歧义和发展三阶段解释——为什么说 NLP 是人工智能中最困难的问题之一。期末的判断题和多选题,大量考点就藏在这 26 页里。

1.1 什么是自然语言,什么算 NLP

概念 KP 01.1

什么是自然语言?

一句话

语音是物质外壳,词汇和语法是骨架,文字与声音是两种属性。

自然语言(Natural Language)是以语音为物质外壳、由词汇和语法两部分组成的符号系统。它有两个属性:文字(书面形式)和声音(口头形式)——所以 NLP 既要处理「写下来的字」,也要处理「说出来的话」。

从功能看,语言是人类交际的工具,也是人类思维的载体;人类历史上以语言文字形式记载和流传的知识,占人类知识总量的 80% 以上。这个数字是后面解释「NLP 为什么重要」的伏笔。

自然语言最特殊的地方是约定俗成:词怎么念、句怎么造,是使用群体长期磨合出来的,还会随使用不断变化。这把它和人工语言(Artificial Language)区分开——Java、C++ 等程序设计语言的语法由规范明确规定,违反就报错;自然语言没有唯一的「规范文档」,「栓 Q」「绝绝子」这种新说法用的人多了,也就成了词。

(补充)语言符号还有「任意性」:同一个概念,汉语说「狗」,英语说 dog,日语说 inu,音和义之间没有必然联系,全靠约定。也正因为约定会变,NLP 模型得持续用新语料更新,否则昨天的网络新词今天就认不出。

生活类比自然语言像小区邻居之间的「老地方」:没人写文件规定它指哪家店,但住久了大家都懂;Java 像国家标准图纸,少一个分号都过不了编译。
10 秒自测 · 点开看答案

问题:自然语言和 Java 这类人工语言,最本质的区别是什么?

答案:自然语言的规则由使用群体约定俗成、不断演化;人工语言的语法由规范文件明确规定,违反就无法运行。

概念 KP 01.2

冯志伟的定义:NLP 是一种「加工技术」

一句话

拿计算机当工具,加工书面和口头两种形式的自然语言信息。

冯志伟给出的定义是:自然语言处理就是利用计算机为工具,对人类特有的书面形式和口头形式的自然语言信息,进行各种类型处理和加工的技术。

这句话可以拆成三个关键词:工具是计算机;对象是自然语言信息,而且同时包含书面形式(文本)和口头形式(语音);动作是「处理和加工」,包括分类、抽取、翻译、生成等「各种类型」,不是只做某一件事。

(补充)「各种类型」意味着 NLP 不是单一算法,而是一组任务:分词、分类、抽取、翻译、摘要、生成……它们共享语言表示与建模方法,但目标和评价指标各不相同。

这是一个偏技术观的定义——强调 NLP 是「拿机器对语言做加工」的一门技术,落脚点是「能做出什么处理、得到什么结果」。

易错把 NLP 等同于「文本处理」,漏掉口头形式。语音识别、语音合成处理的语音同样是自然语言,属于 NLP 的处理对象。
概念 KP 01.3

Bill Manaris 的定义:NLP 是一门「学科 + 工程闭环」

一句话

从语言模型到计算框架、方法、系统,最后还要管评测。

Bill Manaris 把 NLP 定义为:研究在人与人交际中以及人与计算机交际中的语言问题的一门学科。这个定义把 NLP 的目标说成一条完整的工程闭环:

  • 研制表示语言能力和语言应用的模型;
  • 建立计算框架来实现这样的语言模型;
  • 提出相应的方法来不断完善这样的语言模型;
  • 根据模型设计各种实用系统;
  • 探讨这些实用系统的评测技术。

注意最后一步「评测」也被写进了定义:没有评测,系统好不好只是自说自话。这是考试里容易被忽略的细节。与冯志伟的定义相比:冯定义偏技术(用计算机加工语言信息),Manaris 定义偏学科与工程(模型—框架—方法—系统—评测的完整链条),两者可以对照记忆。

(补充)定义里的「语言能力」与「语言应用」也值得区分:前者指人掌握语言规则的能力,后者指在真实场合使用语言的表现。模型既要描述「会不会」,也要描述「怎么用」——这也是为什么它强调要研制两类模型。

生活类比造车不能只造发动机:先画图纸(模型)、建产线(计算框架)、改工艺(方法)、造出整车(系统),最后还要过碰撞测试(评测)。
概念 KP 01.4

一个总公式:NLP = NLU + NLG

一句话

读懂的 NLU,写出来的 NLG;两者才是 NLP 的完整版图。

讲义把 NLP 拆成两大部分:自然语言理解(Natural Language Understanding, NLU)负责「读懂」,自然语言生成(Natural Language Generation, NLG)负责「写出」。二者之下的各种基础算法,是支撑这两部分的底座。

NLU 重在理解:理解语言和文本,提取出有用的信息,交给下游任务使用。典型任务包括情感识别、意图识别、信息检索(个性化搜索、语义搜索、文本匹配),以及信息抽取(命名实体提取、关系抽取、事件抽取)。

NLG 则是反向:给定结构化数据、文本、图表、音频、视频等输入,生成人类可以理解的自然语言文本。按输入输出模态分三类:文本到文本(text-to-text),如翻译、摘要;文本到其他(text-to-other),如文本生成图片;其他到文本(other-to-text),如视频生成文本。

(补充)NLU 和 NLG 不是「先理解、再生成」的两段固定流水线:问答要先理解问题、再生成答案,翻译要先理解源语言、再生成目标语言,很多任务里两者交替出现。考试问「NLP 的两大部分」答 NLU 和 NLG;问「先后顺序」则不要机械套用。

自然语言理解 NLU

输入语言,输出结构化信息或判断:情感、意图、实体、关系。像「听懂并记下要点」。

自然语言生成 NLG

输入数据或内容,输出人话:译文、摘要、文案、回答。像「把要点讲给人听」。

10 秒自测 · 点开看答案

问题:判断——「NLP 只包含自然语言理解(NLU)」。这句话对吗?

答案:错。NLP 主要包含 NLU 和 NLG 两部分;只做理解不做生成,版图是不完整的。

1.2 NLP 为什么重要,用在哪些场景

概念 KP 01.5

为什么说 NLP 是「皇冠上的明珠」?

一句话

机器擅长表格,人类的绝大部分数据却是没人整理过的文本。

在人工智能出现之前,机器智能处理的主要是结构化数据,例如表格:行列清楚、字段固定,查一列求和就行。但生活里大部分数据是非结构化数据——文章、图片、音频、视频,其中文本数据的数据量和信息量都巨大。

要让机器帮我们处理问题,就得先分析利用这些数据,让机器读懂我们的语言,从而搭建起人类和机器之间沟通的桥梁。搜索、对话、翻译、推荐这些高频场景,底层都站着 NLP。

盖茨有一句流传很广的评价:「语言理解是人工智能领域皇冠上的明珠。」之所以是「明珠」,一是因为语言承载了人类绝大部分知识,二是因为它极难——规则多、歧义多,还高度依赖常识和语境。

(补充)语言和图像还有一个本质差别:图像是连续像素,语言是离散符号。词表有限,但词与词的组合几乎无限,同一个词在不同句子里含义还会变。模型要处理的是「有限符号的无限组合」,这正是难点所在。

生活类比想象一座图书馆:只有少数工具书做了索引(结构化),绝大多数藏书是整本整本的文章(非结构化)。NLP 就是给这些「没编目的书」做索引、做问答、做推荐的手艺。
「语言理解是人工智能领域皇冠上的明珠。」 —— 比尔·盖茨
概念 KP 01.6

场景(一):智能问答、对话助手、语义搜索

一句话

从「给一堆链接」到「直接给答案」,背后都是 NLP。

智能问答(Question Answering):用户用自然语言提一个问题,系统直接给出精确答案,而不是甩出一串网页链接。比如问「这项业务怎么办理」,系统能定位到答案段落,再组织成一句回答。

(补充)问答系统常见形态有检索式(先找段落再抽答案)、知识库问答(把问题转成查询)和生成式(直接组织语言回答);形态不同,但都离不开对问题的理解。

对话助手(Dialogue Assistant):要听懂多轮对话里的上下文和用户意图,再决定是回答、追问还是转人工。讲义里的「对话理解」「智能客服」就是这条线的典型落地:用户说「我上次买的那个怎么退」,助手得先弄明白「那个」指的是哪一单。

语义搜索(Semantic Search):不只看字面重合,而是按意思召回。搜「怎么缓解焦虑」,也能找到讲「减压方法」的文章。讲义的 NLU 任务里还提到个性化搜索和文本匹配,它们都属于信息检索这一大类。

生活类比关键词搜索像按「书名里有没有这三个字」找书;语义搜索像一位读过全馆的图书管理员,听你说「想找本让人静下来的书」,就能把书递给你。
10 秒自测 · 点开看答案

问题:语义搜索和传统关键词搜索的关键差别是什么?

答案:语义搜索按「意思」匹配,能召回字面不同但语义相关的文本;关键词搜索主要按字面重合。

概念 KP 01.7

场景(二):抽取、推荐、翻译、情感分析与审核

一句话

把非结构化文本,变成可查询、可决策的结构化信息。

信息抽取(Information Extraction):从新闻、合同、简历里抽出「谁、何时、何地、做了什么」,具体包括命名实体提取、关系抽取、事件抽取,是知识库和风控系统的原料。

推荐系统(Recommender System):读商品标题、评论、浏览文本,判断用户偏好,再把可能喜欢的内容推过来。机器翻译(Machine Translation):把一种自然语言翻译成另一种,输出仍然是自然语言。

情感分析(Sentiment Analysis):讲义给的场景是对商品评论自动过滤、筛选负面评论供人工审核。进阶的属性情感分析要判断「对哪个属性」正负:例如「外观漂亮、音质不错」是对外观和音质的正面评价;而「买没几天就降价,一点都不开心,闪存跑分就五百多点点」是在抱怨价格和性能。

内容审核(Content Moderation):自动识别违规、风险文本,减轻人工审核的压力。同一套技术还有很多出口:文本创作、文本摘要、词语联想,输入法里「人工」后面跳出「智能」就是最日常的一种联想。(补充)文本摘要分抽取式(挑原句)和生成式(重写),文本创作则包括写文案、写诗、续写等。

易错情感分析不是「数正负词」这么简单。属性级情感分析要同时判断「评价对象」和「极性」,同一句评论里不同属性可能一正一负。
10 秒自测 · 点开看答案

问题:属性情感分析比整句情感分析多做了什么?

答案:它要先定位评论针对的具体属性(如外观、音质、价格、性能),再分别判断每个属性的情感极性。

1.3 机器理解语言要爬的五层台阶

概念 KP 01.8

自然语言理解有哪五个层次?

一句话

语音 → 词法 → 句法 → 语义 → 语用,一层比一层往里。

自然语言的理解和分析是一个层次化的过程,讲义把它分成五个层次:

  1. 语音分析(Phonetic Analysis):根据音位规则,从语音流中区分出一个个独立的音素,再根据音位形态规则找出音节及其对应的词素或词。例:从一段声音里切出 /n/、/i/、/h/、/ao/,认出「你好」。
  2. 词法分析(Lexical Analysis):找出词汇的各个词素,从中获得语言学的信息。例:把「我们学习自然语言处理」切成「我们 / 学习 / 自然语言 / 处理」,并标注词性。
  3. 句法分析(Syntactic Analysis):对句子和短语的结构进行分析,目的是找出词、短语之间的相互关系以及各自在句中的作用。例:分析「我爱北京」的主谓宾结构。
  4. 语义分析(Semantic Analysis):找出词义、结构意义及其结合意义,从而确定语言所表达的真正含义或概念。例:判断「他吃了三个苹果」里的「苹果」是水果,「吃」的受事。
  5. 语用分析(Pragmatic Analysis):研究语言所存在的外界环境对语言使用者所产生的影响。例:「你能把窗户关上吗?」多数场合是请求,而不是问对方有没有这个能力。

前一层是后一层的地基:语音听错,词就切错;词性判错,句法就搭错;结构理解错,语义、语用全跟着错。所以五个层次不是并列的五个模块,而是一条有依赖关系的流水线。

生活类比像剥洋葱:最外层是声波,往里一层是词素,再往里是句子骨架,最里面才是「他到底想表达什么」。剥错一层,里面的芯就取不出来。
记忆技巧五个层次按「从外到内」记——音 → 词 → 句 → 义 → 用。前三个回答「语言长什么样」,后两个回答「语言想说什么」。
10 秒自测 · 点开看答案

问题:分析「这句话是请求还是质问」,属于五个层次中的哪一层?

答案:语用分析——它研究外界环境(说话人、场合、双方关系)对语言使用的影响。

1.4 四类歧义:NLP 最大的难点

易错 KP 01.9

词法歧义:刀口切在哪、词性算哪个、名字认不认得出

一句话

分词、词性、未登录词——词法层三个经典坑。

词法歧义(Lexical Ambiguity)是 NLP 最先撞上的难点,具体有三种表现:

  • 分词边界难确定:中文没有空格,同一串字可能有多种切法。讲义的名例是「南京 / 市长 / 江大桥」与「南京市 / 长江 / 大桥」——前者把「南京」和「市长」切开,剩下「江大桥」(听起来像人名);后者是「南京市 + 长江 + 大桥」。两种切法在语法上都说得通,只能靠常识和上下文裁决。
  • 词性标注难确定:同一个词在不同上下文里词性不同。「我计划考研」里「计划」是动词 v;「我完成了计划」里「计划」是名词 n。
  • 未登录词(OOV, Out-of-Vocabulary)识别难:人名、专有名称、缩略词常常不在词典里。讲义举了「高超 / nr / a」「华明 / nr / nt」「移动 / nt / v」:同一个「高超」可能是人名(nr),也可能是形容词(a);「华明」可能是人名(nr),也可能是机构名(nt);「移动」可能是「中国移动」(nt),也可能是动词(v)。
10 秒自测 · 点开看答案

问题:为什么「南京市长江大桥」是词法歧义的经典例子?

答案:因为没有空格,分词边界不唯一:「南京市 / 长江 / 大桥」和「南京 / 市长 / 江大桥」都读得通,含义却完全不同。

易错 KP 01.10

句法歧义:同一串词,两副骨架

一句话

「咬死了猎人的狗」:是狗咬死了猎人,还是狼咬死了狗?

句法歧义(Syntactic Ambiguity)发生在结构层:句子和短语的依存关系受上下文影响,同一串词可以搭出两副不同的句法骨架。

讲义的名例是「咬死了猎人的狗」。单独看,它可以理解成:

  • 狗是主语,咬死了猎人是动宾——即「(一只)咬死了猎人的狗」;
  • 猎人是定语,狗是中心语——即「咬死了(猎人的狗)」,被咬死的是狗。

把上下文补上就消歧了:「那只狼咬死了猎人的狗」——主语是狼,狗是宾语;「咬死了猎人的狗失踪了」——「咬死了猎人的狗」整体作主语,狗才是动作发出者。讲义用依存句法分析标注 HED(核心)、SBV(主谓)、VOB(动宾)、ATT(定中)、CMP(动补)、RAD(右附加)等关系,两种理解对应两棵不同的依存树。

生活类比同一堆积木没变,拼成房子还是拼成车,取决于你先把哪两块接起来;词没变,句法骨架变了,意思就跟着变。
10 秒自测 · 点开看答案

问题:为什么「那只狼咬死了猎人的狗」没有歧义,而「咬死了猎人的狗」有?

答案:前者补出了「狼」作主语,依存关系被唯一确定;后者缺少主语和上下文,可以作两种结构切分。

易错 KP 01.11

语义歧义:一句话,三种意思

一句话

一句英文三种意思:like 是「像」还是「喜欢」?

语义歧义(Semantic Ambiguity)发生在词义与结构意义的结合处。讲义的例子是一句英文:

At last, a computer understands you like your mother.

同一个句子可以读出三种意思:

  • 计算机会像你的母亲那样很好地理解你(like your mother 表示「像你母亲一样」);
  • 计算机理解你喜欢你母亲(like 当动词「喜欢」);
  • 计算机会像理解你母亲那样去理解你(比较的对象是「理解你母亲」这件事)。

根源在于 like 既可作介词「像」,又可作动词「喜欢」;you 既可能作 understands 的宾语,也可能作 like 从句的主语。词义一换、修饰关系一换,整句概念就变了。这类歧义单靠查词典消不掉,必须结合上下文判断词义和指代。

生活类比一个多义单词像一把瑞士军刀,刀片都在,取哪一片取决于场合;语义歧义就是「刀片取错了」。
10 秒自测 · 点开看答案

问题:语义歧义和句法歧义的核心区别是什么?

答案:句法歧义是「结构关系」不唯一(谁修饰谁、谁是主宾);语义歧义是「词义、指代、修饰意义」不唯一,导致整句有多种解释。

易错 KP 01.12

语用歧义:同一句话,三种语气

一句话

「你在干什么?」可以是关心、质问,也可能是调查。

语用歧义(Pragmatic Ambiguity)是最高层的歧义:字面意思清楚,但说话人的真实意图要靠语境判断。讲义用的是最普通的四个字——「你在干什么?」:

  • 纯粹的询问:朋友之间随口一问,想知道对方正在做些什么事情;
  • 生气的质疑:妈妈对淘气的儿子说,实际表达的是儿子可能干了一些坏事;
  • 疑惑的怀疑:对方做了不太合适或不可告人的事情时,带着调查或质疑的意味。

同一句话,说话人身份、双方关系、场合、语气、前文都会改变它真正的意思。NLP 的困难在于:这些语用信息往往不在文本里,机器拿到的只是那五个字。

注意四类歧义不要背混。词法管「切词、词性、未登录词」,句法管「结构关系」,语义管「词义和修饰带来的整句含义」,语用管「语境里的真实意图」。

1.5 发展三阶段:从写规则到端到端

概念 KP 01.13

基于规则与基于统计:为什么「写规则」走不通

一句话

规则写得完语法,却写不完世界;统计用数据把规律学出来。

第一阶段:基于规则(Rule-based)。做法是让语言学家和工程师人工编写语法规则、词典和转换规则,让机器按规则分析句子、做翻译(补充:早期机器翻译系统、专家系统是代表)。优点是规则可读、可解释,在受限领域能跑通。缺点讲义写得很直接:

  • 规则不可能覆盖所有语句——语言太灵活,例外套着例外;
  • 对开发者要求极高:既要精通计算机,又要精通语言学;
  • 这一阶段虽然解决了一些简单问题,但无法从根本上把自然语言理解实用化。

第二阶段:基于统计(Statistical)。随着互联网高速发展,大规模语料库成为现实,硬件也不断更新完善,NLP 的研究重心从手工规则转向数据驱动,基于统计的方法逐渐代替了基于规则的方法。代表方法(补充,后续章节会展开)有 N-gram 语言模型、隐马尔可夫模型(HMM)、条件随机场(CRF)、统计机器翻译等。优点是从语料中自动估计参数、覆盖面广;缺点是依赖人工设计特征、低频词数据稀疏、长距离依赖建模弱。

生活类比规则方法像背一本「如果对方说 A,就回 B」的对话手册:手册永远写不完,还总遇到没收录的说法;统计方法则是刷几亿句真实语料,总结「哪种说法更常见」。
注意讲义原话是「由经验主义向理性主义过渡」,而通行的学科史叙述是「从理性主义(规则)转向经验主义(统计)」。两种表述都指向同一件事——从人工规则转向数据统计;答题时按老师 PPT 的措辞,理解上抓住「规则让位给统计」即可。
概念 KP 01.14

基于深度学习:端到端,把特征也交给网络

一句话

准备好输入—输出对,设计并训练一个神经网络,端到端完成任务。

第三阶段:基于深度学习(Deep Learning)。做法是端到端(End-to-End)训练:把输入到输出成对的数据准备好,设计并训练一个神经网络,网络就能执行预想的任务。人不再手写规则,也尽量不手工设计特征,表示和特征都交给网络从数据里学。

讲义特别提到,RNN 已经是自然语言处理最常用的方法之一,GRU、LSTM 等模型相继引发了一轮又一轮的热潮。再往后(补充,后续章节展开)还有 Seq2Seq + 注意力、Transformer,以及 BERT、GPT 这类「大规模预训练 + 下游微调」的模型。

优点:自动学习表示和特征,端到端省掉大量人工,效果显著提升,一套架构能迁移到很多任务。代价:依赖大规模数据和算力,模型可解释性差,也可能生成看似流畅却不真实的内容。

阶段核心思想代表方法优点局限
基于规则人工编写语法、词典与转换规则规则系统、专家系统(补充)可解释,不需要大语料规则覆盖不全,门槛极高,难以实用化
基于统计从大规模语料中估计概率与参数N-gram、HMM、CRF、统计机器翻译(补充)数据驱动,覆盖面广依赖人工特征,数据稀疏,长距离依赖弱
基于深度学习端到端训练神经网络,自动学习表示RNN / LSTM / GRU、Seq2Seq、Transformer、BERT / GPT(补充)自动特征,效果好,可迁移依赖数据与算力,可解释性差
10 秒自测 · 点开看答案

问题:三个阶段最简洁的记法是什么?

答案:基于规则 → 基于统计 → 基于深度学习;关键词分别是「人工写规则」「从语料估参数」「端到端学表示」。

概念 KP 01.15

发展四阶段:规则 → 统计 → 深度学习 → 预训练大模型

一句话

人写的规则越来越少,机器从数据里学到的越来越多。

讲义把 NLP 的发展写成三段:基于规则——人工编写语法、词典和转换规则;基于统计——借大规模语料从数据中估计概率与参数;基于深度学习——准备好输入—输出对,端到端训练神经网络,让网络自己学特征。

再往后是第四阶段(补充):预训练大模型。先用海量无标注文本做自监督预训练(BERT 的 MLM / NSP、GPT 的下一个词预测),再在下游数据上微调,或用提示直接调用;讲义后半段的 BERT、LLaMA 都属于这一段。

阶段大致时期(补充)核心做法代表方法主要局限
基于规则1950s–1980s人工编写语法、词典与转换规则早期机器翻译、专家系统、规则系统规则覆盖不全;要既懂计算机又懂语言学;难以实用化
基于统计1990s–2000s从大规模语料中估计概率与参数N-gram、HMM、CRF、统计机器翻译依赖人工特征;低频数据稀疏;长距离依赖弱
基于深度学习2010s端到端训练神经网络,自动学习表示RNN / LSTM / GRU、Seq2Seq、Transformer依赖数据与算力;可解释性差
预训练大模型2018 年起无标注语料自监督预训练 + 微调 / 提示BERT、GPT、LLaMA训练与推理成本高;幻觉;评测困难
生活类比规则像手写菜谱,统计像看大量做菜视频后总结火候,预训练大模型像先把整个菜系吃一遍再上手。
10 秒自测 · 点开看答案

问题:四个阶段的核心动作分别是什么?

答案:写规则 → 从语料估参数 → 端到端学表示 → 无标注语料上自监督预训练。

概念 KP 01.16

中文 NLP 的特殊性:分词是绕不开的第一道工序

一句话

英文有空格,中文只有连写的字;先切词,才谈词性和实体。

英文有空格、大小写和词形变化当线索(补充);中文是一串连写的字,没有现成的词边界,所以第一道工序是中文分词——把连续的字序列按规范重新组合成词序列。分词一变,词性标注、句法分析等下游结果也跟着变。

难点集中在四处:切分歧义(南京/市长/江大桥 vs 南京市/长江/大桥)、词性歧义(「计划」可作动词或名词)、未登录词(人名、专名、缩略词如高超、华明、移动,词典没收录就认不出)、新词不断出现(补充)。

易错分词错,后面全错:同一串字切成「南京/市长/江大桥」,词性标注、句法分析都会跟着偏;未登录词还会让实体识别把「高超、华明」当成普通词。
10 秒自测 · 点开看答案

问题:「南京/市长/江大桥」与「南京市/长江/大桥」体现的是哪种难点?

答案:词法歧义里的分词切分歧义——同一串字存在多种合法切法,边界不同,整句意思就变了。

概念 KP 01.17

语料、标签、指标:监督学习的三件套

一句话

数据是题,标签是答案,指标是判分标准,缺一不可。

监督学习(Supervised Learning)要让模型学会「输入 → 正确答案」,需要三样东西:数据(语料库)、标签(人工标注的答案)、指标(衡量对错的尺子)。PPT 讲统计方法时强调「丰富的语料库成为现实」,讲 BERT 时又拿监督与自监督对比——差别就在标签是不是人给的。

标注质量决定效果上限:标签是模型模仿的标准答案,标错了模型就照着学错,指标再高也只是在错误的卷子上打分(补充)。所以标注要有规范、要查一致性、要抽样质检,成本也要算清——标注通常是整条流水线里最贵的一环。

注意标注错误不会「自动纠正」:模型会把噪声当规律学进去。语料再多,标签脏,效果一样上不去(garbage in, garbage out)。
10 秒自测 · 点开看答案

问题:监督学习和自监督学习的根本区别是什么?

答案:标签从哪来。监督学习的标签由人工标注;自监督的标签从数据本身构造,例如遮住一个词再让模型猜。

概念 KP 01.18

NLP 任务地图:五类任务,看输出形态就能分清

一句话

整段一个标签是分类,每个位置一个标签是序列标注。

NLP 任务名目很多,但按「输入 → 输出」的形态可归成五类:分类(一段文本 → 一个标签)、序列标注(每个位置 → 一个标签)、生成(一段序列 → 另一段序列)、句对匹配(两段文本 → 一个关系)、信息抽取(文本 → 结构化结果)。

分类与序列标注只差一个维度:前者整段共用一个标签,后者每个位置都有标签。生成是「写出一段新的」;句对匹配判断两句话的关系;信息抽取把实体、关系、事件抽成结构化数据。

任务类型输入 → 输出典型例子常用指标
分类一段文本 → 一个标签情感分析、意图识别准确率、精确率 / 召回率 / F1
序列标注每个位置 → 一个标签中文分词、词性标注、命名实体识别按实体或按词算 P/R/F1
生成一段序列 → 一段序列机器翻译、文本摘要、对话生成BLEU、人工评估
句对匹配两段文本 → 一个关系问答匹配、自然语言推理准确率、F1
信息抽取文本 → 结构化结果实体抽取、关系抽取、事件抽取精确率、召回率、F1
判断口诀看输出:一段一个标签是分类;每个位置一个标签是序列标注;输出新文本是生成;判断两句关系是句对匹配;输出槽位或三元组是信息抽取。
10 秒自测 · 点开看答案

问题:「词性标注」属于哪类任务?

答案:序列标注——每个词(位置)都要输出一个词性标签,输出长度与输入等长。

概念 KP 01.19

对话系统四类:任务型、闲聊、知识问答、推荐

一句话

话轮数记一句:只有闲聊越多越好,其余三类越少越好。

对话系统是 NLP 的综合性应用:把自然语言理解、对话管理、自然语言生成串成一条流水线(PPT P118–P125)。按使用目的分四类:任务型、闲聊、知识问答、推荐;它们的领域、评价方式和典型系统各不相同。

最容易考的是话轮数:任务型、知识问答、推荐都追求少废话、快办完,话轮越少越好;只有闲聊希望聊得久,话轮越多越好。任务型的对话管理可以用规则、有限状态自动机、表格、脚本、规划或强化学习(补充)。

类型目的领域以话轮数评价应用典型系统
任务型完成特定任务或动作特定域(垂直类)越少越好虚拟个人助理Siri、Cortana
闲聊闲聊开放域话轮越多越好娱乐、情感陪护小冰
知识问答知识获取开放域越少越好客服、教育IBM Watson
推荐信息推荐特定域越少越好个性化推荐阿里小蜜
注意别把「阿里小蜜」填进任务型:按 PPT 的分类它在「推荐」列。任务型代表是 Siri、Cortana,闲聊代表是小冰,知识问答代表是 IBM Watson。
10 秒自测 · 点开看答案

问题:哪类对话系统希望话轮越多越好?为什么?

答案:闲聊。它的目的是陪聊,聊得越久说明体验越好;任务型、知识问答、推荐都希望用尽量少的话轮把事办完。

概念 KP 01.20

评价指标地图:先看任务输出什么,再选尺子

一句话

分类看 F1,生成看 BLEU,语言模型看 PPL,开放任务看人。

指标要和任务的输出形态匹配:分类看准确率、精确率、召回率、F1(类别不均衡时单看准确率会骗人);序列标注按实体或词算 P/R/F1,边界要完全对上;翻译、摘要等生成任务常用 BLEU,数 n-gram 与参考译文的重合;语言模型看困惑度 PPL = exp(loss),越低越好。

PPL 依赖词表与分词粒度,不能跨模型直接比;BLEU 只看字面重合,同义改写会被扣分;开放生成和对话最终要靠人工评估(流畅、相关、有用、安全)。自动指标便宜但片面,人工评估可靠但贵,通常两者一起报。

任务主要指标指标在看什么常见坑
分类Accuracy、P / R / F1、宏平均 F1判对的比例、各类别查准查全类别不均衡时 Accuracy 虚高
序列标注按实体或按词的 P / R / F1边界与类型是否完全正确看字准确率会被 O 标签撑高
生成(翻译 / 摘要)BLEU(摘要也常看 ROUGE,补充)与参考文本的 n-gram 重合不理解语义,同义改写吃亏
语言模型PPL = exp(loss)对下一个词有多确定词表或分词不同的模型不可比
开放生成 / 对话人工评估(辅以自动指标)流畅、相关、有用、安全成本高、主观性强
易错别把不同任务的指标横向比:PPL 49 和 F1 0.89 不是一回事;指标只在同一任务、同一数据划分下才有可比性。
10 秒自测 · 点开看答案

问题:命名实体识别为什么不汇报「字准确率」?

答案:绝大多数位置是 O(非实体)标签,实体边界错几个,字准确率仍可能 95% 以上,掩盖真实错误;应按实体算 P/R/F1。

概念 KP 01.21

NLP 与 LLM:预训练、微调、提示,三代范式各一句话

一句话

预训练一次,处处复用:从复用向量,到复用模型,再到复用接口。

LLM 不是新任务,而是 NLP 的现阶段解法:NLP 是问题域(分类、抽取、生成、对话),LLM 是当前最强的通用工具(补充)。三代范式可以各用一句话说清:

预训练词向量(Word2Vec、GloVe、ELMo):先学词或上下文的向量,再当特征喂给下游模型;预训练 + 微调(BERT、GPT):先在海量无标注语料上自监督预训练,再用下游标签数据微调参数;预训练 + 提示(GPT-3 之后的 LLM,补充):不改参数,把任务写成提示、给几个示例,让模型直接回答。

生活类比像三种用工具的方式:先借零件(词向量),再改装整机(微调),最后直接说「帮我干这个」(提示)。
10 秒自测 · 点开看答案

问题:BERT 与 GPT-3 的用法主要差在哪?

答案:BERT 走「预训练 + 下游微调」,通常要更新参数;GPT-3 走「预训练 + 提示」,不改参数,靠提示与上下文示例完成任务。

面试 KP 01.22

本章面试速答:五个问题,一句话一个答案

一句话

五个问题覆盖本章主要考法:难点、分工、层次、歧义、历史。

  1. NLP 最大的难点?——歧义(词法、句法、语义、语用),加上语言规则本身写不完。
  2. NLU 与 NLG 是什么关系?——理解与生成;NLP = NLU + NLG + 支撑算法。
  3. 自然语言理解分哪五层?——语音分析 → 词法分析 → 句法分析 → 语义分析 → 语用分析。
  4. 四类歧义各举一例?——南京/市长/江大桥(词法)、咬死了猎人的狗(句法)、like your mother(语义)、你在干什么(语用)。
  5. NLP 的发展经历了哪些阶段?——规则 → 统计 → 深度学习 → 预训练大模型(补充)。
概念 KP 01.23

五层台阶怎么分工?语音、词法、句法、语义、语用各管一段

一句话

音管声音、词管切分与词性、句管骨架、义管含义、用管意图。

五层是一条有先后的流水线:前一层的输出,就是后一层的输入。语音分析从声波里切出音素、音节和词素;词法分析确定词边界与词性;句法分析找出词和短语怎么搭成句;语义分析确定词义与结构组合出的字面含义;语用分析再结合场合、身份推断真实意图。

一句话区分:前两层「拆单位」,中间一层「搭骨架」,后两层「抠意思」——越往下越依赖上下文和常识。

层次处理单位一句话概括
语音音素、音节声音怎么切、怎么对应词素
词法词素、词词怎么切、是什么词性
句法词与短语词怎么搭成合法结构
语义词义、结构义组合起来字面是什么意思
语用(补充)语境、说话人真实意图是什么
易错把五层当成五个并列模块 → 它们有先后依赖:语音切错,词法跟着错;词性判错,句法就搭错,语义、语用全跟着偏。
10 秒自测 · 点开看答案

问题:「你能把窗户关上吗?」要判断它是请求还是提问,属于哪一层?

答案:语用分析——字面在问能力,真实意图要靠场合、说话人身份和双方关系推断。

易错 KP 01.24

标注错一处,模型学一路:脏标签为什么会被学进去?

一句话

标签是标准答案,答案错了,模型只会更坚定地学错。

监督学习的三件套是语料、标签、指标:语料是题,标签是标准答案,指标是判分标准。训练时模型唯一的目标就是让输出逼近标签,标注错误等于把噪声写进了标准答案。

后果有两层:错误模式会被当成规律学进参数,系统性错标会训出系统性错判;指标又在错误标签上打分,可能虚高、掩盖真实问题。所以标注要有规范、双人一致性检查和抽样质检(补充)。

易错以为「数据量大就能冲淡标注错误」→ 随机噪声会被平均,系统性偏差不会;某一类总标错,再多数据也只会让模型更确信这个错误。
10 秒自测 · 点开看答案

问题:为什么「多标一批数据」不一定能救回标注错误?

答案:随机错误会被大量样本平均掉,但系统性错标是稳定模式,模型会把它当规律学进去,数据越多越巩固。

概念 KP 01.25

四把尺子:分类、生成、检索、序列标注各看什么?

一句话

指标跟着输出形态走:判对、像不像、找得全、框得准。

分类看 Accuracy、Precision / Recall / F1;类别不均衡时用宏平均 F1,别被 Accuracy 骗。生成看 BLEU(n-gram 重合),摘要常用 ROUGE(补充),同义改写会吃亏,最终还要人工评估。检索看 Recall@k、MRR、MAP(补充),关心前 k 个结果里有没有、排得靠不靠前。序列标注按实体算 P/R/F1,边界和类型都得对,不能只看 token 准确率。

原则只有一条:指标必须匹配任务的输出形态,不同任务的分数不能横比。

任务主要指标指标在看什么
分类Accuracy、P / R / F1、宏平均 F1整段判对没有、各类查准查全
生成BLEU、ROUGE(补充)、人工评估和参考文本的 n-gram 重合
检索Recall@k、MRR、MAP(补充)前 k 个结果找全没有、排序好不好
序列标注实体级 P / R / F1边界和类型是否完全正确
10 秒自测 · 点开看答案

问题:检索任务为什么不能只报准确率?

答案:检索输出的是排序列表,关心「前 k 个里有没有正确答案、排得多靠前」,要看 Recall@k、MRR、MAP 这类排序指标。

概念 KP 01.26

六站路线:从 NLP 概论一路学到 LLM

一句话

概念打底、词向量过桥、任务练手、模型升级、LLM 收尾。

按课程顺序走六站:概论(定义、五层、四类歧义、三阶段);词向量(OneHot → 共现 / SVD → Word2Vec / GloVe / FastText → ELMo),把词变成向量;分类与标注(文本分类、分词、词性、NER),练完整流水线与评估;语言模型(N-gram → RNN LM、PPL);RNN / Transformer(序列建模、注意力、BERT / GPT);LLM(预训练 + 微调 / 提示,补充)。

每站都在补上一站缺的能力:先有表示,才能训任务;先会小模型,才看得懂大模型。

记忆口诀概念 → 表示 → 任务 → 语言模型 → 架构 → 大模型;前两站打地基,中间两站练手,最后两站升级。
10 秒自测 · 点开看答案

问题:为什么词向量排在分类、标注这些任务之前?

答案:分类和标注模型的输入就是词向量,得先把「词 → 向量」这一步打通,后面的任务才跑得起来。

本章速查 · 考点清单

  • 自然语言:以语音为物质外壳、由词汇和语法组成的符号系统;文字和声音是两种属性;约定俗成,区别于 Java、C++ 等人工语言。
  • 知识占比:以语言文字形式记载和流传的知识占人类知识总量 80% 以上。
  • 冯志伟:用计算机为工具,对书面形式和口头形式的自然语言信息进行各种类型处理和加工的技术。
  • Bill Manaris:研究人与人、人与计算机交际中语言问题的学科;链条 = 模型 → 计算框架 → 方法 → 实用系统 → 评测。
  • NLP = 自然语言理解(NLU)+ 自然语言生成(NLG);判断题常设「只包含 NLU」的陷阱。
  • NLU 任务:情感识别、意图识别、信息检索(个性化搜索、语义搜索、文本匹配)、信息抽取(命名实体、关系、事件)。
  • NLG 三类:text-to-text(翻译、摘要)、text-to-other(文本生成图片)、other-to-text(视频生成文本)。
  • 重要性:真实数据大多非结构化,文本数据量和信息量巨大;NLP 是人与机器沟通的桥梁;「皇冠上的明珠」。
  • 应用场景:智能问答、对话助手、语义搜索、信息抽取、推荐系统、机器翻译、文本创作、情感分析、内容审核、文本摘要、词语联想。
  • 五层次:语音分析 → 词法分析 → 句法分析 → 语义分析 → 语用分析;语用层研究外界环境对语言使用者的影响。
  • 四类歧义:词法(南京 / 市长 / 江大桥、计划 v/n、未登录词 高超 / 华明 / 移动)、句法(咬死了猎人的狗)、语义(computer understands you like your mother)、语用(「你在干什么?」三种语气)。
  • 三阶段:基于规则 → 基于统计 → 基于深度学习。规则方法走不通的原因:覆盖不全 + 门槛高 + 只能解决简单问题。
  • 判断题高频:① NLP 包含 NLU 和 NLG 两部分(对);② 歧义是 NLP 最大的难点(对);③ NLP 只处理文本(错,还有语音等口头形式);④ 深度学习阶段的核心是端到端训练(对);⑤ NLP 经历了规则 → 统计 → 深度学习的发展过程(对)。

来源:第二章 PPT P1–P26。

02
WORD EMBEDDINGS

词向量:从 OneHot 到 ELMo

这一章解决一个核心问题:怎么让神经网络「看懂」词?

自然语言处理的第一个工程问题,就是怎么把「大海」这样的词喂给神经网络。本章按「离散符号 → 统计共现 → 预测学习 → 上下文动态」的路线,讲清 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 等方法干的事,本质上就是把这张矩阵学出来,取其中每一行作为最终词向量。

公式

E ∈ ℝ^(V×d),词 w_i 的向量 = E[i];整张矩阵的参数量 = V × d

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 词表动辄十万级,用它当词向量代价太高,而且学不到语义。

公式

向量长度 = V;不同词 a ≠ b 时,OneHot(a) · OneHot(b) = 0,cos(OneHot(a), OneHot(b)) = 0

生活类比学号 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 只能算「词的编号」,算不上「词的表示」。要表达语义,需要把词放到一个低维、稠密、有远近关系的实数空间里——这就是接着要讲的分布式表示。

公式

存储字节 = V × (V × 4 B);非零比例 = 1 / V;V = 10^5 时,非零比例 = 0.001%

记忆技巧四个死穴记成「长(维度)、空(稀疏)、正交(无语义)、怕新词」,正好一一对应分布式表示的四个卖点:短、稠密、有远近、可泛化。
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 个词、不含自身、对称构造)。每一行都可以当成该词的向量:行向量相似的词,上下文也相似。

词我爱上海杭州北京天安门
我031110
爱301111
上海110000
杭州110000
北京110001
天安门010010

窗口选多大有讲究:小窗口(w = 1~2)偏向捕捉语法搭配,比如「爱—北京」;大窗口偏向捕捉主题,比如「北京—城市—繁华」。窗口越大,矩阵非零元素越多、越稠密。

共现矩阵的优点是统计直接、可解释、不需要训练;缺点是维度高且稀疏、计数被高频词主导、不含词序,新词加入还要重算整张表。这些缺点,正是接下来 SVD 与 Word2Vec 要解决的问题。

公式

X[i][j] = 词 j 在词 i 左右 w 个位置内出现的次数;X 为 V×V 对称矩阵,通常不计 i = j 的自共现

易错把中心词自己也统计进共现 → 每个词与自己的计数虚高、对角线全是词频 → 构造窗口时明确「不含自身」,并按对称矩阵同时更新两格。
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 思考题):

  1. 矩阵规模随词表按 V² 增长,大语料下存储和计算都不可行;
  2. SVD 分解代价高(约 V³ 级别),还要一次性拿到全部语料;
  3. 无法增量更新,新词、新语料都要重建矩阵并重新分解;
  4. 计数被高频功能词主导,必须额外做 PPMI 或加权;
  5. 稀疏词(低频词)的向量质量差。

PPT P37 顺势提问:为什么不直接学习词的分布式表达?这正是 Word2Vec 要回答的问题。

公式

X ≈ U_k Σ_k V_kᵀ,词向量矩阵 W = U_k Σ_k ∈ ℝ^(V×k);k 远小于 V

公式

PPMI(w,c) = max(0, log( (X_wc × ΣX) / (X_w × X_c) ));PMI 越大,说明 w 与 c 的共现越超出随机水平

易错把原始共现计数直接送进 SVD → 主成分被「的 / 是 / 很」等高频率功能词占满,语义相似度被稀释 → 先 log(1+X) 或 PPMI 再分解。
10 秒自测 · 点开看答案

问题:为什么 SVD 之前要做 log(1+X) 或 PPMI,而不是直接用原始计数?

答案:原始计数长尾严重、高频词数值压倒一切,会让分解结果被功能词主导;log 压缩量级,PPMI 衡量「超出随机的共现强度」,都能让语义信号更突出。

SVD 降维后的词向量散点:语义相近的词会聚在一起(实验 3,余弦相似度可视化)。
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 前先减去这一行分数的最大值,数学上概率不变,数值上安全。

公式

P(o|c) = exp(u_o · v_c) / Σ_{w∈V} exp(u_w · v_c)

公式

L = -Σ_t Σ_{o∈窗口(t)} log P(o | c_t),训练目标是最小化 L

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 概率,而是它的近似,换来数量级的加速。工程上负采样更常用。

公式

负采样目标:log σ(u_o · v_c) + Σ_{i=1}^{k} log σ(-u_{n_i} · v_c),σ 为 sigmoid,n_i 为噪声词

公式

单样本复杂度:朴素 softmax O(V);层次 Softmax O(log V);负采样 O(k)

生活类比层次 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 目标:Σ_{i,j} f(X_ij) · (u_i · v_j + b_i + b_j - log X_ij)²

公式

FastText:词 w 的向量 ≈ Σ_{g ∈ n-grams(w)} z_g(示例:apple = ap + pp + pl + le)

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 模型——它们同样从大规模文本中学习词向量,把「上下文相关」做得更彻底。

公式

ELMo 词表示 = γ · Σ_{j=0}^{L} s_j · h_j,h_j 为第 j 层隐状态,s_j 与 γ 为可学习的任务相关权重

静态(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)。

两者的关系:内部评估快、便宜、可解释,但分数高不一定代表下游任务涨点,因为相似度、类比只测了语义空间的一小部分性质;外部评估慢、要重复训练下游模型,但最真实。实际调词向量时,通常先用内部评估快速筛方案,再用外部评估定稿。

公式

类比任务:寻找 w,使 cos(v_king - v_man + v_woman, w) 最大;理想答案 w = queen

生活类比内部评估像模拟考——题出得再像,也只测了考纲的一部分;外部评估像真实项目绩效——能不能把活干成,才是最终标准。
10 秒自测 · 点开看答案

问题:内部评估分数高,模型的命名实体识别效果一定好吗?

答案:不一定。内部评估只测相似度、类比,和下游任务目标不完全一致;最终要看外部评估的下游指标。

面试 KP 02.13

高频思考题:四个最爱问的「为什么」

一句话

维度灾难、softmax 稳定、两套向量、CBOW 丢词序。

  1. 维度灾难到底有多大?V = 10 万时,float32 单个 OneHot 向量 400 KB;100 万个词各存一条约 400 GB(约 372.5 GiB,指导书参考值);非零比例只有 1/V = 0.001%。
  2. softmax 怎么保证数值稳定?先减去当前分数向量的最大值再 exp,即 scores -= scores.max()。exp 的输入变成不超过 0,不会溢出;数学上分子分母同乘一个常数,概率结果不变。
  3. 两套向量为什么要相加?输入向量 U 和输出向量 V 分别承担「当中心词」和「当上下文」两种角色,训练完成后 U + V 能综合两种信息,通常效果更好;只用其中一套也可用,只是信息略少。
  4. CBOW 为什么丢失词序?它把窗口内上下文向量取平均,而平均与顺序无关:「我 爱 北京」和「北京 爱 我」得到同一个隐藏层表示,词序信息被丢掉——这正是名字里 Bag of Words(词袋)的含义。想保留词序,就得换成 RNN、Transformer 这类带位置信息的模型。

外加一个送分点:层次 Softmax 把单样本复杂度从 O(V) 降到 O(log V);负采样只更新正样本加 k 个负样本,复杂度 O(k)。两者都是对全词表 softmax 的近似加速(PPT P43)。

公式

稳定 softmax:p_i = exp(s_i - max(s)) / Σ_j exp(s_j - max(s)),结果与原式相同但不会溢出

注意三个「分布式」别混:分布式表示(词向量)说的是信息分散在多个维度上;分布式假设说的是词义由上下文决定;分布式系统 / 分布式存储说的是多台机器协同,和词向量无关。
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要验证的核心问题
1exp01 / lab01P32OneHot 为什么表达不了语义
2exp02 / lab02P35语义能否由共现统计得到
3exp03 / lab03P36–37稀疏共现能否压成稠密向量
4exp04 / lab04P38–P42能否用「预测上下文」学向量
5exp05 / lab05P40上下文预测中心词行不行
6exp06P43全 softmax 太慢怎么优化
7exp07P44全局共现能否拟合出词向量
8exp08P45没见过的词能否也有向量
9exp09P46词向量能否随上下文变化
10exp10P47向量相似度像不像人的判断
11exp11P47语义关系能否做向量加减
12exp12P47对下游任务到底有没有用
记忆主线每一代方法都在补上一代的一个具体缺陷:两两正交 → 高维稀疏 → 无法增量更新、O(V) 太慢 → 一词一义。
常见坑把 12 个实验当成 12 个孤立脚本,跑完不填表、不看输出。正确做法是每组实验都留下一张「现象—原因—结论」的小表:例如实验 1 的余弦全 0、实验 2 的「的」行、实验 3 的相似度随 k 变化,这些现象连起来才是本章的主线。
实验 LAB 02.1

实验 1 · OneHot 与语义鸿沟

难度 ★☆☆ 对应 PPT P32 lab01_onehot.py / exp01

实验目的:把词变成最朴素的向量,再用两组可量化的结果(余弦全 0、内存爆炸)说明 OneHot 只有「编号」、没有「语义」,从而引出分布式表示。

  1. 写 build_vocab(corpus):按词在语料中首次出现的顺序编号;再写 onehot(word, vocab),返回长度 V、只有一个 1 的 np.ndarray。
  2. 用 PPT P32 的句子 ["this","is","a","simple","example"] 打印 5 个词的向量,确认每个向量长度都等于 V=5。
  3. 计算(this, is)、(simple, example)、(this, simple)三对余弦相似度,观察是否全部为 0。
  4. 按 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

实验目的:按分布式假设(一个词的含义由它周围的词决定)把语料统计成对称共现矩阵,先手算、再用代码验证,并观察窗口大小与高频功能词对矩阵的影响。

  1. 手算:对 PPT P35 的三句「我 爱 上海 / 我 爱 杭州 / 我 爱 北京 天安门」在 w=2 下算出 6×6 矩阵,写在报告里。
  2. 实现 build_cooccurrence(corpus, window=2):先建词表,再对每个中心词 i 取窗口 [i−w, i+w] 内 j≠i 的位置给矩阵计数。
  3. 在统一语料 corpus.txt(10 句)上运行,打印「表头为词、首列为词」的整齐矩阵,并与手算的前 3 句结果比对。
  4. 窗口对比 w=1、2、3,记录矩阵非零元素总数以及「北京」行、「天安门」行的非零个数;最后打印「的」这一行,观察高频功能词的共现范围。
w=2我爱上海杭州北京天安门
我031110
爱301111
上海110000
杭州110000
北京110001
天安门010010

手算矩阵时先看两件事:对角线是否为 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 的思考题。

  1. 复用实验 2 的 build_cooccurrence,写 svd_vectors(X, k, preprocess):先预处理,再用 np.linalg.svd(..., full_matrices=False) 分解,取 U[:, :k] * sqrt(S[:k])。
  2. 取 k=2 打印每个词的 2 维向量,并填 4 对词的相似度:北京-上海、北京-天安门、上海-杭州、北京-城市。
  3. 预处理对比(k=10):原始计数、log(1+X)、PPMI 各训练一次,记录同样 4 对词的余弦,判断哪种结果最接近人的直觉。
  4. 维度实验:k 取 2、5、10、20,画「北京-上海」相似度随 k 变化的折线图;选做 k=2 散点图,用 annotate 标出词名,观察同类词是否聚在一起。
公式

X = UΣVᵀ,取 W = U[:, :k] · √Σ[:k];PPMI(i,j) = max(0, log( P(i,j) / (P(i)·P(j)) ))。

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 拓展)。
不同维度 k 对「北京—上海」相似度的影响:k 太小信息损失大,k 增大后趋于稳定(实验 3 拓展)。
实验 LAB 02.4

实验 4 · Skip-gram

难度 ★★★ 对应 PPT P38 / P39 / P41 / P42 lab04_skipgram.py / exp04

实验目的:用「中心词预测上下文词」实现 Word2Vec 的 Skip-gram,手写前向 softmax 与反向传播,训练 16 维词向量,并用最近邻查询验证「北京 ≈ 上海」这类语义相似性。

  1. 写 make_pairs(corpus_ids, window=2):每个位置取中心词 c,窗口内所有 j≠i 的词作上下文,生成 (c, 上下文) 对;打印词汇表大小 V 与训练对总数。
  2. 实现前向:scores = U @ v[c],先减最大值再 softmax 得到概率 p。
  3. 实现反向:g = p - onehot(o),grad_v = U.T @ g,grad_u = outer(g, v[c]);lr=0.05 训练 300 轮,每 100 轮打印平均损失。
  4. 取最终词向量 word_vec = v + u,用 most_similar 查询北京、上海、城市、繁华的 Top-3 近邻并填表。
公式

P(o | c) = exp(u_oᵀ v_c) / Σ_w exp(u_wᵀ v_c),L = −log softmax(u_oᵀ v_c);梯度:∂L/∂v_c = Uᵀ(p − y),∂L/∂U = (p − y) ⊗ v_c。

初始损失为什么约 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 逐项对比,理解两种架构的差异与适用场景。

  1. 写 make_samples(corpus_ids, window=2),返回(上下文编号列表, 中心词编号);句首句尾的上下文个数不等长,平均时按实际长度取。
  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)。
  3. 两个模型各训练 300 轮,填对比表:训练样本数、第 0 / 300 轮损失、每轮耗时、cos(北京, 上海)、cos(北京, 天安门)、「城市」Top-3 近邻。
  4. 选做:加一句「我 去过 哈尔滨 冰雪 大世界」比较低频词「哈尔滨」的近邻;再用 w=1、2、3 训练 CBOW,看窗口对「北京-上海」相似度的影响。
对比维度Skip-gramCBOW
训练方向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 的结果对照。

  1. 统计每个词的词频,按 counts ** 0.75 计算权重,按比例放大到约 1 万份后用 np.repeat 展开成负采样表。
  2. 对每个正样本 (c, o) 从采样表中抽 K 个负样本,抽到与 o 相同的词就重抽,保证正负样本不重叠。
  3. 前向只算正样本与 K 个负样本的打分:s_pos=u_o·v_c,s_neg=u_k·v_c;损失 L=−log σ(s_pos) − Σ_k log σ(−s_neg)。
  4. 反向:正样本梯度系数 σ(s_pos)−1,负样本系数 σ(s_neg);v_c 累加全部正负贡献后只更新一次;训练 400 轮、lr=0.05、K=5,最后用最近邻检查词向量质量。
公式

L = −log σ(u_oᵀ v_c) − Σ_{k=1}^{K} log σ(−u_kᵀ v_c),σ(x) = 1/(1+e^{−x});单样本复杂度从 O(V) 降到 O(K+1)。

层次 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)与形态相近问题。

  1. GloVe:复用 build_cooccurrence 得到共现矩阵 X,只取非零元素 (i, j);目标是让 w_i·c_j + b_i + b_j 逼近 log X_ij,损失按权重 f(X_ij) 加权。
  2. 用梯度下降训练(dim=8、2000 轮、lr=0.05),最终词向量取 w+c,查看相似度与「上海」的最近邻。
  3. FastText:对每个词加首尾边界符后切字符 2-gram,输入向量=该词所有子词向量之和,输出侧仍用整词向量;反向时把梯度均分回各子词。
  4. 训练后给「苹果汁」合成向量(它在训练语料中从未作为整词出现),与「苹果」「香蕉」等算余弦,验证 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

实验目的:复现「输入嵌入+正弦位置编码+自注意力」三个组件,亲眼看到同一个「苹果」在「吃苹果」与「苹果手机」两种上下文中得到不同向量,从而理解静态词向量与上下文化词向量的分水岭。

  1. 实现 positional_encoding(seq_len, d_model):偶数维用 sin、奇数维用 cos,频率为 10000^(2i/d_model),让每个位置有独一无二的「指纹」。
  2. 实现 attention(Q, K, V):scores = Q @ K.T / sqrt(d),按行 softmax 归一化,再加权求和得到融合上下文的输出。
  3. 准备两句话「我 爱 吃 苹果 和 香蕉」「我 想 买 苹果 手机 壳」,让它们共用同一套静态词嵌入,分别加上位置编码后计算自注意力。
  4. 取两句话中「苹果」(位置 3)的上下文化向量算余弦,再与「静态嵌入和自身比较恒为 1.0」的结果对照,打印结论。
公式

Attention(Q, K, V) = softmax(QKᵀ / √d_k) · V;PE(t, 2i) = sin(t / 10000^(2i/d_model)),PE(t, 2i+1) = cos(t / 10000^(2i/d_model))。

这里最关键的是「共享」与「上下文」的对照:两句话里的「苹果」共用同一个静态嵌入,但加上位置编码、经过自注意力后,各自吸收了周围词的信息,向量就不再相同。位置编码用不同频率的正余弦给每个位置一个唯一指纹,相对位置也能通过线性变换表达。

别把数值当质量本实验的投影矩阵是随机初始化、未训练的,两组向量 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

实验目的:回答「词向量到底好不好」——用内部评估(相似度、类比)直接看向量质量,再用外部评估(情感分类下游任务)看它对真实任务有没有帮助。

  1. 相似度(exp10):用平行语料训练 SGNS,对人工打分的词对算余弦,再用 Spearman 秩相关衡量「模型排序」与「人工排序」是否一致。
  2. 类比(exp11):按 target = v(b) − v(a) + v(c) 做关系平移,遍历词表取与 target 余弦最高的词,记得排除 a / b / c 本身;测「男人→国王,女人→王后」等 3 组。
  3. 下游(exp12):句向量取句中词向量平均,用逻辑回归做情感二分类,对比「训练过的词向量」与「随机初始化词向量」在 6 条评测句上的准确率。
  4. 汇总三种评估的指标与局限:内部评估便宜、快,但可能过拟合评测集;外部评估更贴近真实价值,但成本更高。
评估类型做法指标局限
相似度(内部)词对余弦 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 不是越大越好:先够用,再谈效果。

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×dfloat32 存储
1 万100100 万约 4 MB
10 万3003000 万约 120 MB
100 万3003 亿约 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(补充)。

公式

FastText:vec(w) ≈ Σ_{g∈n-grams(w)} z_g;PPT P45 示例:Apple = ap + pp + pl + le(2-gram)

易错实验 8 的实现里,子词只用于输入侧的中心词向量,输出侧仍是整词表(补充)→ OOV 词可以「查」到近似向量,但不能当预测目标参与训练;另外完全陌生的字/子词仍然拼不出有效向量,子词不是万能的。
10 秒自测 · 点开看答案

问题:FastText 凭什么能给没见过的词一个向量?

答案:它把词表示成字符 n-gram 子词向量之和;新词只要部分子词在训练语料中出现过,就能拼出近似向量,不必等扩充词表。

实验 KP 02.16

共现窗口 w:小窗口抓语法,大窗口抓主题

一句话

小窗口看搭配,大窗口看主题,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。

公式

X ≈ U_k Σ_k V_kᵀ;常用 W = U_k Σ_k^(1/2) ∈ ℝ^(V×k)(也可取 U_k 或 U_kΣ_k),k ≪ V

选 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)。

公式

P(w | c) = Π_{节点 n 在根→w 的路径上} σ(± u_nᵀ v_c),每步一个 sigmoid;复杂度 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 个负样本对应的行,参数量不变,梯度更新量也随之大幅减少。

公式

P_n(w) = f(w)^0.75 / Σ_{w′} f(w′)^0.75;损失 L = −log σ(u_oᵀv_c) − Σ_{k=1}^{K} log σ(−u_kᵀv_c)

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(实测口径)。

公式

J = Σ_{i,j=1}^{V} f(X_ij) · (w_iᵀw̃_j + b_i + b̃_j − log X_ij)²

易错对 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:把两套信息相加,通常比只用一套更好;只用输入侧也能用,只是信息略少。有的实现改成取平均或拼接,思路相同(补充)。

公式

最终词向量 w_final = v_w + u_w(也可取平均或拼接);v_w 为中心词输入向量,u_w 为上下文输出向量

生活类比像一个词有两份档案:一份记录它「当主角」时的表现,一份记录它「当配角」时的表现;查一个词像查一个人,两份档案合起来看才不会漏。
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 只测「相似」、刻意排除关联(补充),同一模型在后者上分数通常更低。报告里要写清评测集、词对数量与预处理,否则不同实验的 ρ 没法直接比较。

公式

Spearman ρ = 1 − 6Σd_i² / (n(n²−1)),d_i 为第 i 个词对在「模型余弦」与「人工打分」中的名次差(无并列时)

数据集规模打分侧重备注
wordsim353353 对相似性 + 相关性PPT P47 举例,常用基线(补充)
SimLex-999999 对只测相似性,控制关联同一模型分数通常更低(补充)
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 高只说明方向近,不保证同义——反义词、强关联词共享上下文,余弦也可能不低(补充)。

公式

cos(A, B) = (A · B) / (|A| × |B|);L2 归一化后 cos(A, B) = A · B,取值 [−1, 1]

易错直接拿未归一化的点积或欧氏距离排序 → 模长大的高频词占便宜,近邻结果失真 → 先把向量归一化,再按余弦或点积取 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 的实验目的、原理与思考题参考答案)。

03
TEXT CLASSIFICATION

文本分类:从 TF-IDF 到 BERT 的四种打法

这一章解决一个核心问题:怎么把一段文本判成一个类别,并且证明它判得准?

文本分类(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:我 爱 上海100101
d2:我 爱 杭州000111
d3:我 爱 北京 天安门011101
生活类比像把一锅汤倒进滤网,只数剩下几块肉、几片菜,却不记下锅顺序。食材清单一模一样的两锅汤,味道可能完全不同——词袋丢掉的正是"味道"。
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 比词袋"更懂谁重要"的地方。

公式

TF-IDF(t, d) = tf(t, d) × log( N / (1 + df(t)) ),其中 N 为文档总数、df(t) 为包含词 t 的文档数

文档(PPT P53 示例)上海北京天安门我杭州爱
d1:我 爱 上海0.7670.00.00.4530.00.453
d2:我 爱 杭州0.00.00.00.4530.7670.453
d3:我 爱 北京 天安门0.00.6080.6080.3590.00.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 再筛。
  • 互信息 / 信息增益:都需要估计概率,样本少时估计噪声大。
公式

χ²(t, c) = N × (A·D − B·C)² / [ (A+B)(C+D)(A+C)(B+D) ],χ² 越大说明词 t 与类别 c 越不独立、相关性越强

10 秒自测 · 点开看答案

问题:卡方值越大,说明特征与类别是什么关系?

答案:独立性越弱、相关性越强,越应该保留。若 χ² 接近 0,说明该词对区分类别几乎没有贡献。

实验 LAB 03.1

实验 1 · TF-IDF + 朴素贝叶斯 / 逻辑回归

难度 ★☆☆ 对应 PPT P52–P56 train_tfidf.py + utils.py

实验目的:用最小成本跑通"文本 → 向量 → 分类器"闭环,拿到四分类的第一个基线,并亲眼看到 TF-IDF 与词袋的差别、朴素贝叶斯与逻辑回归的差别。

  1. 确认 data/ 下四个 CSV 就位,utils.py 的 data_dir 指向真实路径,打印标签分布确认四类都加载成功。
  2. 按 8:2 划分训练 / 测试集,random_state=42、stratify=label_id,保证四类占比一致、结果可复现。
  3. 用 TfidfVectorizer(analyzer='char', ngram_range=(1, 2), max_features=10000) 把文本变成稀疏矩阵;训练集 fit_transform,测试集只 transform。
  4. 训练 MultinomialNB,输出 accuracy 与 classification_report。
  5. 训练 LogisticRegression(max_iter=1000, random_state=42),同样评估,并与 NB 对比。
  6. 拓展:换成 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,专为词频 / 词权这类非负计数特征设计。
公式

P(c|d) ∝ P(c) × Π P(t_i|c),其中 P(t|c) = (count(t, c) + 1) / (count(c) + |V|)(拉普拉斯平滑,|V| 为词表大小)

生活类比像几个评委各自独立打分再汇总。评委之间其实会互相影响(词与词并不独立),但"各打各的分、加起来比大小"往往仍能选出对的那个——这就是朴素贝叶斯能用的原因。
易错直接连乘导致概率下溢成 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。
公式

h_i = ReLU( W · e[i : i+fs] + b ),feature = max_i h_i,y = softmax( W_o · concat(feature) + b_o ),其中 fs 为卷积核高度(2/3/4)

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 基线对比。

  1. TextDataset 在训练集上 build_vocab:统计字符频次、保留最常见的 10000 个,<PAD>=0、<UNK>=1;测试集复用训练集词表。
  2. encode 把每条文本截断 / 补齐到 max_len=256,作为定长输入。
  3. 搭模型:Embedding(128) + 三组卷积(Conv2d(1,128,(fs,128)), fs=2/3/4) + ReLU + 1-max 池化 + Dropout + 全连接 4 类。
  4. 训练:CrossEntropyLoss + Adam(lr=1e-3),batch_size=32,跑 3 个 epoch,每个 epoch 打印训练完成。
  5. 评估:model.eval() + torch.no_grad(),argmax 取预测,输出 accuracy 与分类报告。
  6. 拓展:卷积核再加一个 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。
公式

h_t = LSTM(e_t, h_(t−1)),H = [ h_T(→) ; h_1(←) ],y = softmax( W · H + b ),H 维度为 hidden_dim × 2

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(无词序)形成三方对照。

  1. 数据与字表流程同实验 2(max_len=256、词表 10000、<PAD>=0、<UNK>=1),保持口径一致才能对比。
  2. 搭模型:Embedding(128) + BiLSTM(hidden 128, num_layers=2, dropout 0.3) + 末态拼接 + Dropout + 全连接 4 类。
  3. 训练 3 个 epoch(交叉熵 + Adam lr=1e-3,batch_size=32),每个 epoch 打印完成信息。
  4. 评估:输出 accuracy 与四类分类报告,与实验 2 的 TextCNN 结果并列比较。
  5. 拓展:把 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,会很慢。
公式

y = softmax( W · h_[CLS] + b ),其中 h_[CLS] 为 BERT 最后一层 [CLS] 位置的输出向量

生活类比像转学生:别人从零开始学四则运算(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 与前三套方案放在同一张表里对比。

  1. 在 import 之前设置 HF_ENDPOINT='https://hf-mirror.com',通过国内镜像下载分词器与模型(首次较慢,之后走缓存)。
  2. 同口径划分数据(test_size=0.2、random_state=42、stratify),用 tokenizer(..., truncation=True, padding=True, max_length=256) 批量编码。
  3. 用自定义 BertDataset 把 encodings 与标签包成 Dataset,标签键名为 labels(Trainer 约定)。
  4. 加载 BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=4)。
  5. 配置 TrainingArguments(num_train_epochs=2, per_device_train_batch_size=8, eval_strategy='epoch'),交给 Trainer 训练。
  6. 评估: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 特别小,就要警惕指标不稳。

  • 召回优先:漏报代价大——反诈预警、癌症筛查、安全隐患识别。
  • 精确优先:误伤代价大——垃圾邮件拦截、内容审核、自动封禁。
  • 定位问题:看混淆矩阵里哪两个类互相误判最多,再回头补数据或补特征。
公式

Accuracy = (TP+TN)/N;Precision = TP/(TP+FP);Recall = TP/(TP+FN);F1 = 2·P·R/(P+R)

生活类比像撒网捕鱼: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 的代码,交付物是源代码 + 运行截图或输出文本 + 思考题回答。

  1. 作业一 · 特征粒度与分类器对比:分别用字符级与词级(jieba)TF-IDF,观察特征维度与准确率变化;在朴素贝叶斯、逻辑回归基础上引入 LinearSVC 或 RandomForestClassifier;用 GridSearchCV 调逻辑回归 / SVM 的正则参数 C;指标用 Accuracy、Macro-Precision、Macro-Recall、Macro-F1,并做一张"特征粒度 × 分类器"的对比表。
  2. 作业二 · TextCNN / TextRNN 超参消融与可视化:对比单向 LSTM 与双向 BiLSTM、num_layers = 1 / 2 / 3 的差异;每个 epoch 记录训练 loss 与验证 accuracy 并画曲线,判断是否过拟合;引入学习率衰减(ExponentialLR / CosineAnnealingLR)或早停,观察泛化变化;最后输出测试集混淆矩阵。
  3. 作业三 · 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 越大评估越稳,但训练次数也越多(补充)。

公式

CV 得分 = (1/K) × Σk=1…K score(在 fold_k 上验证的模型);每折内部单独 fit 向量器,测试集留到最后只用一次

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。

公式

FL(pt) = −αt · (1 − pt)γ · log(pt),γ 常取 2;pt 是模型给正确类的概率,越易分权重越小

易错现象:过采样后训练集准确率涨了,少数类 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 是总数减前三项。行归一化得到召回,列归一化得到精确。报告之外一定要看最大的非对角格子:哪两类互相误判、错在边界还是标错。先看行和与列和,再挑最大的几个非对角格子。

真实 \ 预测(示例)体育教育健康旅游
体育45311
教育24422
健康12461
旅游21344
公式

召回c = Mcc / Σj Mcj(行和);精确c = Mcc / Σi Mic(列和);表中数字为示例,不是实测

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-F1 = (1/K) Σc F1c;Micro-F1 = 2·TP总 / (2·TP总 + FP总 + FN总)

平均方式怎么算单标签多分类时等于适用
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,截断会直接丢信息。

公式

等效 batch = per_device_batch × gradient_accumulation_steps × GPU 数;显存 ≈ 激活 + 参数 + 优化器状态

易错现象:开混合精度后 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 提吞吐但抬高尾延迟。再补上置信度校准、阈值与拒识、数据漂移监控(补充)。

公式

端到端延迟 = 排队 + 预处理 + 推理 + 后处理;吞吐 = 每秒完成请求数,两者要按业务 SLO 一起看

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。

04
SEQUENCE TAGGING

序列标注:给每个位置贴一个标签

文本分类回答「这段话是什么」,序列标注回答「这段话的每个位置是什么」。

中文分词、词性标注、命名实体识别看起来是三件不同的事,本质上是同一道题:输入一个长度为 T 的字/词序列,输出一个长度同样为 T 的标签序列。这一章先讲清「逐位置标注」和标签体系(BIO / BIOES),再用「小强去培训中心学习」把三种任务各走一遍;最后沿 HMM → CRF → BiLSTM+CRF → BERT 的路线,讲透标签偏置、全局归一化和维特比解码这三个考点。学完你应该能回答三个问题:HMM 为什么会「偏爱」某些标签?CRF 的全局归一化到底在算什么?BiLSTM 后面为什么还要再接一层 CRF?

4.1 从「一个标签」到「一排标签」

概念 KP 04.1

文本分类和序列标注,差在哪一个维度?

一句话

文本分类整段出一个标签,序列标注每个位置各出一个标签。

文本分类(Text Classification)的输入是一段文本,输出只有一个标签。比如「今天发了工资,我很开心!」→ 正向(positive)。序列标注(Sequence Tagging)的输入也是一段文本,但输出是与输入逐位置对齐的标签序列:第 t 个位置有一个标签,T 个位置就有 T 个标签。

这一个差别会带来两个连锁后果:第一,标签之间有依赖,比如 B(词首)后面通常要跟 I(词中)或 E(词尾),不能每个位置各猜各的;第二,评价方式变了,不能只报一个整体准确率,而要看每个位置、每个实体是否标对。

标签集合由任务自己定义:分词用 B / I / E / S,词性用 n / v / a,NER 用 B-PER / I-ORG / O;同一段输入换一套标签集合,就是另一道任务。模型要学的,是给定整条输入序列,为每个位置分配一个标签,并让整条标签序列尽量自洽。

文本分类(Text Classification)

一段文本 → 1 个标签。例:情感分析、垃圾邮件识别、意图识别。

序列标注(Sequence Tagging)

T 个位置 → T 个标签,逐位置对齐。例:中文分词、词性标注、命名实体识别。

生活类比面对一张合影,文本分类是猜「这是哪次旅行」——整张照片一个标签;序列标注是给照片里每个人贴名字和身份标签——每个位置都要给一个答案。
10 秒自测 · 点开看答案

问题:序列标注的输出长度一定等于输入长度吗?

答案:是。它按位置对齐,输入 T 个单元就输出 T 个标签;变化的是标签集合(分词标签、词性标签、实体标签)。

概念 KP 04.2

序列标注家族:三个最常考的任务

一句话

分词切边界、词性贴词类、NER 圈实体——同一套逐位置框架的三种问法。

中文分词(Chinese Word Segmentation)、词性标注(POS tagging)、命名实体识别(NER)都套用「逐位置贴标签」的框架,区别只在标签代表什么:分词标签表示词边界,词性标签表示词类,实体标签表示这个位置属于哪类实体。此外,关键词抽取、语义角色标注等任务也可以归进这个框架(补充)。

这三类任务的标注都要逐位置对齐,所以标注成本不低,而且一致性要求高:同一个句子两个人标,词边界或实体边界不一致,训练信号就会互相抵消。复习时把「输入是什么、每个位置标什么、标签集合长什么样」三件事对应起来记,比死背任务名有用。

任务输入每个位置标什么典型例子
中文分词连续汉字串词边界(B / I / E / S)一九九八年/中国/实现/……
词性标注(POS)已分好的词序列词性(n、v、a、uj……)迈向/v 充满/v 希望/n
命名实体识别(NER)字序列或词序列实体边界 + 类型(B-PER、I-ORG、O……)小强(B-PER) 去(O) 培训中心(B-ORG……)
10 秒自测 · 点开看答案

问题:以下哪个不属于序列标注任务?A 情感分析 B 中文分词 C 实体识别 D 词性标注

答案:A。情感分析是对整段文本分类,只输出一个标签;B、C、D 都是逐位置标注。

4.2 中文分词与标签体系

概念 KP 04.3

中文分词到底在切什么?

一句话

把连续的字序列,按一定规范重新组合成词序列。

中文分词(Chinese Word Segmentation)指的是把一个汉字序列切分成一个个单独的词;换个说法,分词就是把连续的字序列按照一定的规范重新组合成词序列的过程。英文单词之间天然有空格,中文没有,所以「词」的边界必须由算法判断。

课上给的例子是:一九九八年/中国/实现/进出口/总值/达/一千零九十八点二亿/美元,一共切出 8 个词。注意「一九九八年」「一千零九十八点二亿」这种数字整体被当作一个词,拆开就没有意义了。

分词主要有两类难点(补充):一是歧义切分,同一串汉字可能存在多种合法切法,要靠上下文才能定;二是未登录词,新词、专名、数字与单位的组合在词表里查不到,只能靠字级特征判断边界。这也是为什么分词结果总要和一套分词规范绑定。

记忆分词输出不是「唯一真理」,它依赖分词规范(词表、粒度)。所以标注和评测必须固定同一套规范,否则同一句话能切出不同答案。
10 秒自测 · 点开看答案

问题:例子里「一千零九十八点二亿」应该切成几个词?

答案:1 个。「点」是数字的一部分,整体作为一个数量词,不要按字拆开。

概念 KP 04.4

BIO / BIOES:用几个字母描述词的边界

一句话

B 开始、I 中间、E 结束、S 单字、O 非实体——标签体系就是标注的「语法」。

要把「逐位置贴标签」落下来,需要一套标签体系。最常用的是 BIO:B(Begin)表示一个词或实体的开始,I(Inside)表示中间或结尾,O(Outside)表示这个位置不属于任何实体。BIOES 更细:B 开始、I 中间、E(End)结束、S(Single)单字成词、O 非实体。中文分词里还常见 BMES 写法,M(Middle)就相当于 BIOES 的 I。

用「小强去培训中心学习」做分词,9 个字写成 9 个标签:

位置字分词(BIO)分词(BIOES)说明
1小BB「小强」词首
2强IE「小强」词尾
3去BS单字词
4培BB「培训中心」词首
5训II词中
6中II词中
7心IE词尾
8学BB「学习」词首
9习IE词尾

把标签读回来就是:小强/去/培训中心/学习。BIO 只分「开始 / 不是开始」,BIOES 多出 E 和 S,能明确写出「词在哪里结束、哪个词只有一个字」,对边界更敏感。

两套体系各有取舍:BIO 标签少、迁移和标注都更便宜,但单字词和「词的首字」看起来一样,无法显式收尾;BIOES 标签多两个,边界信息更完整,解码时也更容易满足「有始有终」的约束。选哪套取决于任务和数据,关键是训练、验证、测试、解码四处必须一致,不能中途换体系。

规则

合法词块 = B (I)* E 或 S;BIO 写法下为 B (I)*。单独出现的 I、悬空没有收尾的 B,都是非法标签。

生活类比把每个词想成一个快递包裹:B 是「刚发件」,I 是「运输中」,E 是「已签收」,S 是「同城直达(单字词)」,O 是「这不是包裹」。看一眼标签序列,就知道哪几个字被装进了同一个箱子。
10 秒自测 · 点开看答案

问题:BIOES 里「去」这种单字词用哪个标签?

答案:S(Single)。BIO 里对应的写法是 B。

易错 KP 04.5

标签序列怎么还原成词?非法序列怎么救?

一句话

从 B 开始截取、到 E 或 S 结束,拼出一个个词;不合法的转移要靠约束兜住。

解码(decoding)就是把标签序列还原成结构:从左往右扫,遇到 B 或 S 就打开一个词,遇到 I 继续往下接,遇到 E 或 S 就收尾。上面的 BIOES 序列 B E S B I I E B E 读出来就是:小强/去/培训中心/学习。

不同实现细节略有差异:有的把 S 和 E 都当作「收尾」,有的把 B 单独出现也当作单字词;但核心都是「扫一遍标签序列、按边界拼词」。所以解码之前最好先检查标签序列是否合法,否则会拼出空词或半截词。

但模型逐位置独立取最高分时,可能给出不合法的序列,比如「O I-ORG」——一个 I 前面没有 B,这个 I 就是「孤儿标签」;又或者「B-ORG O I-ORG」这种边界中断。传统 CRF 用转移特征、BiLSTM+CRF 用可学习的转移矩阵,在解码时限制非法转移(B 只能接 I 或 E,I 只能接 I 或 E);工程上还会加约束解码或后处理,把非法序列修正成合法序列。

易错现象:验证集上总出现 O 后面直接跟 I-ORG 的预测。原因:模型逐位置取 argmax,没有「标签必须成块」的约束。怎么办:换全局解码(维特比 + 转移约束),或者在解码时把非法转移的分数置为负无穷。
10 秒自测 · 点开看答案

问题:序列 B-ORG I-ORG O I-ORG 里哪个位置不合法?

答案:第 4 个 I-ORG。I 表示「实体内部」,前面必须是 B-ORG 或 I-ORG,不能跟在 O 后面。

4.3 词性标注与命名实体识别

概念 KP 04.6

词性标注(POS):给每个词贴一个词类

一句话

在分词结果上,为每个词标出名词、动词、形容词等词性。

词性标注(Part-Of-Speech tagging,简称 POS tagging)是指为句子分词结果中的每个单词标注一个正确的词性,也就是确定每个词是名词、动词、形容词或其他词性的过程。例子:迈向/v 充满/v 希望/n 的/uj 新/a 世纪/n(n 名词、v 动词、a 形容词、uj 助词;词性标记含义为补充)。

它是很多 NLP 任务的预处理步骤——句法分析要知道每个词是名词还是动词才能判断主谓宾,信息抽取也常先做词性过滤;但课件特别强调:词性标注不是不可或缺的步骤。端到端神经网络可以直接从字/词向量学到句法或抽取所需的表示,不一定显式经过一层词性标注。

词性也是句法分析的「线索包」:名词性成分更可能充当主语、宾语,动词性成分更可能充当谓语,虚词则提示结构关系;信息抽取里常用「保留名词/动词短语、过滤虚词」的思路筛候选。所以即使不显式做词性标注,词性信息本身仍然值得关注。

易错现象:同一个词在不同句子里词性不同,查表硬编码会错。原因:词性由上下文决定,比如「计划」既可以是名词也可以是动词。怎么办:用上下文特征和序列模型(HMM、CRF、BiLSTM、BERT)来标,而不是词表映射。
10 秒自测 · 点开看答案

问题:词性标注是句法分析的预处理,所以它是所有 NLP 任务不可或缺的一步——对吗?

答案:不对。课件原话是「经过词性标注后的文本会带来很大的便利性,但不是不可或缺的步骤」;端到端模型可以绕过显式的词性标注。

概念 KP 04.7

命名实体识别(NER):把人名和机构圈出来

一句话

找出文本里的命名实体,并判断它是人名、机构、地名还是时间。

命名实体识别(Named Entity Recognition,NER)是自然语言处理的基础任务之一,目标是提取文本中的命名实体并对这些实体分类,比如人名(PER)、地名(LOC)、机构(ORG)、时间(TIME),此外还有货币(MONEY)、百分比(PERCENT)等。

NER 的标签通常写成「位置-类型」:B-PER 表示人名开始,I-PER 表示人名内部,O 表示不是实体。还是「小强去培训中心学习」:

位置字词词性NER(BIO)说明
1小小强nrB-PER人名开始
2强小强nrI-PER人名内部
3去去vO非实体
4培培训中心nB-ORG机构开始
5训培训中心nI-ORG机构内部
6中培训中心nI-ORG机构内部
7心培训中心nI-ORG机构内部
8学学习vO非实体
9习学习vO非实体

读出来就是两个实体:人名「小强」、机构「培训中心」;「去」和「学习」都是 O。课件配图里也出现过 E-PER、E-ORG 的写法(BIOES),和本表的 B/I 含义一致,只是用 E 显式收尾,答题时注意题目用的是哪一套。

易错未登录词(OOV):现象是训练集里没出现过的人名、公司简称、缩略词标不出来。原因:这些词在字/词表里没有记录,边界和类型都缺证据,而人名、专名、缩略词恰恰最常是新词。怎么办:字级建模(Char-CNN / Char-BiLSTM、BERT 的子词切分)能缓解未登录词问题,再配合词典或规则特征。
10 秒自测 · 点开看答案

问题:NER 的 BIO 标签里,O 表示什么?

答案:Outside,该位置不属于任何命名实体,比如例句里「去」「学习」对应的位置。

4.4 方法演进:HMM、CRF 与 BiLSTM+CRF

概念 KP 04.8

方法演进:从 HMM 到 BERT,主线是「越来越会看全局」

一句话

传统统计(HMM/MEMM/CRF)→ 深度(RNN/LSTM)→ BiLSTM+CRF → BERT,核心是上下文与标签约束。

课件把序列标注方法分成两代:传统统计方法有 HMM、MEMM、CRF;深度学习方法有 RNN/LSTM、BiLSTM+CRF、BERT。它们的共同目标始终是同一个:给定输入 x,找出得分最高的标签序列 y。

演进的主线有两条:一是上下文从「只看当前观测」走到「看左右双向上下文」(BiLSTM、BERT);二是标签约束从「逐位置独立」走到「整条序列全局解码」(CRF、BiLSTM+CRF 的 CRF 层)。

代际代表方法怎么定标签主要局限
传统统计HMM生成式 P(x, y),两假设,局部归一化标签偏置、上下文缺失
传统统计MEMM判别式,逐状态局部归一化仍有标签偏置
传统统计CRF全局归一化 P(y | x),人工特征特征工程重、训练慢
深度学习RNN / LSTM逐位置分类标签依赖弱,可能出非法序列
深度学习BiLSTM + CRF发射分数 + 转移约束 + 维特比结构更复杂
预训练BERT每个 token 接分类头依赖预训练、显存大
注意新方法不是把老方法「淘汰」了。HMM 和 CRF 仍是理解标签偏置、全局归一化的最好入口,考试里「为什么加 CRF 层」的答案就来自这两组对比。表中 MEMM、BERT 的具体机制为补充说明。
10 秒自测 · 点开看答案

问题:CRF 相对 HMM 最关键的改变是什么?

答案:取消两个独立假设,用全局特征、在整条序列上做全局归一化,从而解决标签偏置和上下文缺失。

公式 KP 04.9

HMM 的两个假设和三种参数

一句话

标签是看不见的隐状态,字/词是看得见的观测,用两个假设把问题简化。

隐马尔可夫模型(Hidden Markov Model,HMM)把每个位置的标签当作隐状态(hidden state),把字或词当作观测值(observation)。它靠两个假设把序列概率拆成可算的乘积:

  • 齐次马尔可夫假设(隐状态独立假设):当前隐状态只与上一个隐状态有关,与更早的状态无关。
  • 观测独立假设:当前观测值只由当前隐状态产生,与其他时刻的观测值相互独立。

模型有三组参数:初始状态概率 π(第一个标签的分布)、状态转移概率 A(标签 → 标签,如 B-ORG → I-ORG)、发射概率 B(标签 → 字/词,如 I-ORG 发射出「训」)。三个参数齐了,整条序列的联合概率就能写成连乘:

公式

P(x, y) = π(y₁) × ∏ A(y_{t−1} → y_t) × ∏ B(x_t | y_t)(第一个 ∏ 从 t = 2 到 T,第二个从 t = 1 到 T)

HMM 要预测的,就是让这个联合概率最大的标签序列 y。三组参数可以用语料统计(数数)估计,也可以用 EM 算法训练。

生活类比隐状态是「今天到底晴还是雨」,观测是「同事今天穿短袖还是羽绒服」。你只能看见衣服(观测),要反推天气(隐状态)——这就是 HMM 在序列标注里干的事:看见字,反推标签。
10 秒自测 · 点开看答案

问题:HMM 里「隐状态」对应序列标注任务中的什么?

答案:每个位置的标签(如 B-ORG、I-ORG、O);观测则是每个位置上的字或词。

公式 KP 04.10

维特比解码:每一步只留一条最优路径

一句话

用动态规划在指数级的标签路径里,找出整条联合概率最高的那条。

HMM 要算的是 argmax_y P(x, y)。如果每个位置都有 K 个候选标签、序列长度为 T,一共有 Kᵀ 条路径,穷举不可能。维特比(Viterbi)解码用动态规划解决:走到第 t 个位置、停在第 j 个状态时,只保留「到这一步为止概率最高」的那一条路径,其余全部丢掉,下一步只基于这个最优值继续推。

直觉一句话:每到一个路口,只记下「从起点到这里的当前最优走法」;最后从终点一路回溯,就得到全局最优路径。

公式

δ_t(j) = max_i [ δ_{t−1}(i) × A(i → j) ] × B(x_t | j);δ₁(j) = π(j) × B(x₁ | j)

生活类比从北京开车到广州,每经过一个城市,你只在导航里保留「到这座城市为止最省油的一条路线」,不保留所有绕法;到了广州再往前回溯,就得到完整的最优路线。
记忆维特比 = 递推(每一步用上一步的最优值)+ 保留最优前驱 + 终点回溯。它和 HMM 的参数学习算法不是一回事,别混。
10 秒自测 · 点开看答案

问题:维特比在每一步「丢掉」了什么?

答案:丢掉了「到当前状态不是最优」的路径,只保留每个状态上的最优前驱;计算量因此从指数级降到 O(T × K²)。

易错 KP 04.11

HMM 的两个致命伤:标签偏置与上下文缺失

一句话

局部归一化让模型偏爱「岔路少」的状态;观测独立让它看不见前后文。

问题一:标签偏置(label bias)。HMM 的转移概率是逐状态局部归一化的:每个状态出发的所有转移概率之和固定为 1。于是分支出路少的状态,可以把更大的概率压到它那少数几条出边上,模型便倾向于选择「岔路少」的状态,而不是观测证据真正支持的状态。

问题二:上下文缺失。观测独立假设让第 t 步只看当前观测 x_t,用不上前后文。要判断「培」是不是机构名的开头,必须看后面的「训中心」;HMM 看不到,所以性能非常受限。

生活类比一家只有 3 道菜的馆子,每道菜的推荐概率都是 1/3;一家有 10 道菜,每道只有 1/10。只看单道菜的推荐概率,会误以为小馆子的菜更值得点——概率是被「摊」出来的,和菜本身好不好吃无关。局部归一化就有这个味道。
口径提示(补充)label bias 这个说法在文献里更常和 MEMM 一起讨论;本课 PPT 把它记为 HMM 局部归一化导致的同类问题。答题时按课上口径「局部归一化 → 偏向分支少的状态」写即可。
10 秒自测 · 点开看答案

问题:HMM 的哪个假设导致它用不上上下文?

答案:观测独立假设——当前观测只由当前隐状态产生,与其他观测无关,所以模型看不到前后字。

公式 KP 04.12

CRF:取消两个假设,改成整条序列全局打分

一句话

不做生成式建模,直接给整条标签序列打分,再在全局归一化成概率。

条件随机场(Conditional Random Field,CRF)直接建模条件概率 P(y | x),不建模观测 x 的生成过程,因此不需要观测独立假设;标签之间也不再做局部归一化,而是在整条序列上做全局归一化。课件对它的概括是:取消 HMM 的两个独立假设,把标签转移和上下文输入都当作全局特征,在全局做概率归一化。

CRF 定义两类特征:标签转移特征,例如「前一个标签是 B-ORG、当前是 I-ORG」时返回 1;状态特征,例如「当前标签是 I-ORG 且当前字是『训』」时返回 1。每个特征配一个权重 w,整条序列的得分是所有位置、所有特征的加权和:

公式

score(x, y) = Σ_t Σ_k w_k · f_k(y_{t−1}, y_t, x, t);P(y | x) = exp(score(x, y)) / Z(x),其中 Z(x) = Σ_{y'} exp(score(x, y'))

因为分母 Z(x) 要把所有可能的标签序列都算进去,所以叫全局归一化:一条路径的概率不再由某个状态「分到多少」决定,标签偏置自然消失;同时状态特征可以吃进任意上下文(前后字、词、词性),上下文缺失也解决了。

10 秒自测 · 点开看答案

问题:CRF 为什么能解决 HMM 的标签偏置?

答案:它不再逐状态局部归一化,而是对整条标签序列做全局归一化,一条路径的概率由整条序列的总分同其他所有路径比较得出。

面试 KP 04.13

BiLSTM + CRF:神经网络打分,CRF 层管规矩

一句话

BiLSTM 给每个位置输出标签得分,CRF 层学转移约束并全局解码,保证 B-I 合法。

结构是三段:字/词向量 → BiLSTM(双向 LSTM,同时拿到左、右上下文)→ 每个位置输出「标签集大小」维的得分,叫发射分数(emission score)→ CRF 层 → 维特比解码。如果没有 CRF 层,直接对每个位置取最高分,可能得到「O I-ORG」这类非法序列;CRF 层从训练数据里学到标签转移约束(B-ORG 后面接 I-ORG 得分高,O 后面接 I-ORG 得分低),再在整条序列上全局解码。

课件特别强调:BiLSTM+CRF 里的 CRF 并不是传统 CRF 算法,这里只是用于学习标签转移特征、进行全局维度解码的一个神经网络层。它的得分可以写成发射分数加转移分数:

公式

score(x, y) = Σ_t E_{t, y_t} + Σ_t T_{y_{t−1}, y_t};y* = argmax_y score(x, y)

生活类比BiLSTM 像阅卷老师,给每个字「像不像某个标签」单独打分;CRF 像教务处的格式规则:I 前面必须有 B 开头,整张卷子要一起看。最后按整张卷子的总分挑一份最合规的答案,而不是每个空各选最高分。
易错现象:以为加了 CRF 层就万事大吉。原因:CRF 只约束标签之间的转移,不改善每个位置的发射分数;发射分数取决于 BiLSTM(或预训练编码器)的质量。怎么办:先把编码器和标注质量做好,再用 CRF 层兜住合法性,最后用维特比解码。
10 秒自测 · 点开看答案

问题:BiLSTM+CRF 里 CRF 层的作用是什么?

答案:学习标签转移约束并做全局解码(维特比),保证输出标签序列合法(B-I 成对、不出现孤儿 I),而不是重新实现传统 CRF 算法。

4.5 评估:别被字准确率骗了

公式 KP 04.14

评估:为什么 NER 不看「字准确率」

一句话

序列标注按实体级 P/R/F1 评估,边界和类型都对才算对一个实体。

序列标注常按实体级(entity-level)算指标:预测出的实体必须「边界 + 类型」完全正确才算命中。Precision(精确率)= 正确预测实体数 / 预测实体总数;Recall(召回率)= 正确预测实体数 / 真实实体总数;F1 是两者的调和平均。

为什么不看 token 级准确率?因为 O 标签往往占绝大多数,一个「全标 O」的模型也能拿到很高的字准确率,但一个实体都没找出来。工程上常用 seqeval 这类库(补充):先把 BIO 标签序列解析成实体区间(从 B 开始,一直连到 I 或 E),再和标注的实体集合比对。因此训练、验证、测试必须使用同一套标注体系,否则解析出的区间对不上,指标会失真。

公式

P = 正确实体数 / 预测实体数;R = 正确实体数 / 真实实体数;F1 = 2 × P × R / (P + R)

生活类比Precision 像你点到名的那些人里有多少真的在场(别点错人),Recall 像该到的人里你点到了多少(别漏人),F1 是两者之间的平衡。
易错现象:评测分数比人工感觉高很多。原因:边界差一个字(比如「培训中心」只标出「培训」)在实体级算全错,但在 token 级几乎全对,token 指标会掩盖边界错误。怎么办:报告实体级 P/R/F1,并检查 B/I 标签的一致性。
10 秒自测 · 点开看答案

问题:预测了 10 个实体,其中 8 个完全正确;真实实体一共 12 个。此时 P、R 各是多少?

答案:P = 8/10 = 0.80,R = 8/12 ≈ 0.67,F1 ≈ 2 × 0.80 × 0.67 / (0.80 + 0.67) ≈ 0.73(示例计算,不是实测结果)。

概念 KP 04.15

MEMM:判别式模型为什么也逃不过「标注偏置」?

一句话

每个状态先把自己出边的概率归一化,岔路少的状态天然占便宜。

最大熵马尔可夫模型(MEMM)是判别式模型:用最大熵直接建模 P(yt | yt−1, x),能吃任意上下文特征,没有 HMM 的观测独立假设。但它仍在每个状态上做局部归一化——所有出边概率之和为 1。于是只有一条出边的状态必须把概率 1 给它,观测再反对也没用;路径概率又是局部概率连乘,模型便偏爱岔路少的状态,这就是标注偏置(label bias)。(补充:MEMM 的细节 PPT 只列为传统方法之一。)

公式

P(y | x) = ∏t P(yt | yt−1, x),其中 P(yt | yt−1, x) = exp(w·f) / Σy′ exp(w·f(y′)),分母只在当前位置标签上归一化

10 秒自测 · 点开看答案

问题:MEMM 明明用了上下文特征,为什么还会出现标注偏置?

答案:偏置来自局部归一化,不是特征。每个状态先把自己出边归一化,连乘后岔路少的状态被系统性放大;CRF 用全局归一化解决。

公式 KP 04.16

维特比手算:3 个词、2 个标签走一遍

一句话

每步只留「到该状态的最优路径」,三步后回溯拼出整条标签序列。

设标签只有 B、I,初始概率 π(B)=0.6、π(I)=0.4,转移概率 B→B 0.5、B→I 0.5、I→B 0.4、I→I 0.6,三个词的发射概率依次为 (0.5,0.5)、(0.3,0.7)、(0.9,0.1)。δt(j) 表示走到第 t 步停在状态 j 的最高分:用 π 乘发射起步,之后每步取「上一步各状态 × 转移」的最大值再乘发射,最后从终点最高状态回溯。两个终点分数越接近,说明模型对这条序列越没把握,分数差可当置信度参考。

tδ(B)δ(I)最优前驱
10.6×0.5 = 0.3000.4×0.5 = 0.200—
2max(0.300×0.5, 0.200×0.4)×0.3 = 0.045max(0.300×0.5, 0.200×0.6)×0.7 = 0.105两者都来自 t=1 的 B
3max(0.045×0.5, 0.105×0.4)×0.9 = 0.0378max(0.045×0.5, 0.105×0.6)×0.1 = 0.0063来自 t=2 的 I
读表终点 B 的 0.0378 最大 → 回溯 δ3(B) 的前驱是 δ2(I)、δ2(I) 的前驱是 δ1(B),最优序列为 B I B。数字为手算示例,不是实测结果。
10 秒自测 · 点开看答案

问题:上面例子最后的最优标签序列是什么?

答案:B I B。从 t=3 的 B 回溯到 t=2 的 I,再到 t=1 的 B;0.0378 是这条路径与观测的联合分,用来比大小。

概念 KP 04.17

CRF 特征模板:状态特征看字,转移特征看标签对

一句话

模板把「哪个字、哪个标签、哪对标签」写成 0/1 特征,权重靠训练学。

CRF 的得分拆成两类特征:状态特征只看「当前位置输入 + 当前标签」,如「当前标签是 I-ORG 且 wi 是『训』→ 1」;转移特征只看「前一个标签 + 当前标签」,如「pre_y=B-ORG 且 cur_y=I-ORG → 1」。工程上用特征模板批量生成:U01:%x[−1,0] 表示前一个字,U02:%x[0,0] 表示当前字,模板与标签组合后能展开成上千个特征(补充)。模板只负责「组合哪些线索」,具体权重由训练学。

类型模板 / 写法举例含义
状态特征U01:%x[−1,0] + 标签前一个字与当前标签组合
状态特征U02:%x[0,0] + 标签当前字与当前标签组合(PPT 的「I-ORG 且字为训」)
转移特征B01:pre_y / cur_y前标签到当前标签的转移(PPT 的「B-ORG → I-ORG」)
组合特征U05:%x[−1,0]/%x[0,0] + 标签相邻两字组成一个特征(补充)
公式

score(x, y) = Σt Σk wk · fk(yt−1, yt, x, t);权重 w 由训练学习,不靠人工设定

10 秒自测 · 点开看答案

问题:状态特征和转移特征分别回答什么问题?

答案:状态特征回答「这个位置的输入像不像标签 yt」,转移特征回答「yt−1 后面接 yt 合不合理」;两类得分相加再全局归一化。

概念 KP 04.18

BIO 还是 BIOES?单字实体与边界信息决定选哪套

一句话

BIOES 用 E、S 把「结束」写死,边界更清楚,代价是标签翻倍。

BIO 只有 B、I、O 三个字母(T 类实体共 2T+1 个标签),标签少、数据稀疏时更省;缺点是「单字实体」和「实体开头」都标 B,解码时看不出一个 B 在哪结束。BIOES 加上 E(结尾)和 S(单字),每类实体 4 个标签:S 就是单字实体、E 明确收尾,非法序列更少。对中文 NER 这类单字实体多、边界敏感的任务,BIOES 往往更有利(补充:结论依数据而定,小数据要实测)。

体系标签数(T 类实体)单字实体边界信息适合
BIO2T+1B弱数据少、标注成本敏感
BIOES4T+1S强边界敏感、单字实体多
BMES(分词)4S强中文分词
生活类比BIO 只说「从这里开始」,BIOES 还补一句「到这里结束」——后者不容易把两个词黏在一起。
易错现象:训练用 BIO、评测脚本按 BIOES 解析,F1 低得离谱。原因:两套体系解析出的实体区间对不上,E / S 被当成未知标签。怎么办:数据、模型、解码、评测四处固定同一套体系,写进实验配置。
10 秒自测 · 点开看答案

问题:BIOES 里的 S 和 E 分别对应什么情况?

答案:S 表示单字实体(整个实体只有一个 token),E 表示多字实体的最后一个 token,两者都显式写出「结束」。

概念 KP 04.19

嵌套与重叠实体:为什么一条 BIO 标签不够用?

一句话

一个位置只能贴一个标签,装不下「北京大学」里的「北京」。

扁平序列标注假设每个位置只属于一个实体,可现实里实体能嵌套或重叠:例如「北京大学肿瘤医院」整体是机构,里面又含「北京大学」这个机构;「中国银行」整体是机构,其中「中国」可看作地名。BIO 一个位置只有一个标签,只能二选一,另一层信息直接丢失。解法有三类(补充):分层标注(每个实体类型各跑一层 BIO)、基于 span 的模型(先预测起止再分类)、把嵌套结构展开成序列的生成式方法。

10 秒自测 · 点开看答案

问题:为什么 BIO 标不出「北京大学肿瘤医院」里嵌套的「北京大学」?

答案:BIO 每个 token 只有一个标签,外层实体占用了这些位置,内层实体没有位置可标;要换多层标签或 span 级模型。

公式 KP 04.20

标注一致性:Cohen's Kappa 怎么算,分歧怎么仲裁

一句话

Kappa 扣掉「瞎猜也能对上」的部分,剩下的才是真一致。

多人标注先量一致性:Cohen's Kappa κ = (po − pe) / (1 − pe),po 是两人实际一致比例,pe 是随机猜测也能达到的一致比例。κ=0 表示和瞎猜差不多,1 表示完全一致;一般 0.6–0.8 算较好、0.8 以上算很好(经验区间,补充)。三人以上用 Fleiss' Kappa。分歧处理流程:双人独立标小批 → 算 κ → 集中不一致样本由第三人 / 专家仲裁 → 更新标注规范 → 再全量标注并抽检。

公式

κ = (po − pe) / (1 − pe);两类两人时 pe = Σk (nk1/N)·(nk2/N),po = 一致样本数 / N

10 秒自测 · 点开看答案

问题:两人原始一致率 90%,Kappa 一定高吗?

答案:不一定。若绝大多数样本都落在同一个常见标签上,随机一致率 pe 也高,Kappa 会被压低,所以要看 κ 而不只看一致率。

代码 KP 04.21

seqeval 实体级评估:一句 BIO 标签是怎么算成 P/R/F1 的?

一句话

先把标签解析成实体区间,边界和类型都对才算一个 TP。

seqeval 把 BIO / BIOES 标签序列转成实体集合再比对:真实 [B-ORG, I-ORG, I-ORG, I-ORG] 是「培训中心」,预测 [B-ORG, I-ORG, O, O] 是「培训」——按字看对了 2/4,按实体看边界不对,算 0 个 TP、1 个 FP、1 个 FN。所以 NER 的 P/R/F1 是实体级的:边界、类型都一致才算命中。使用时保证训练、评测同一套标签体系,并区分 strict(边界 + 类型)与宽松口径(补充:seqeval 有 mode 参数)。动手前先确认标签体系一致。

from seqeval.metrics import classification_report

y_true = [['B-ORG', 'I-ORG', 'I-ORG', 'I-ORG']]   # 培训中心
y_pred = [['B-ORG', 'I-ORG', 'O', 'O']]           # 培训:边界错
print(classification_report(y_true, y_pred))      # 实体级 P/R/F1,不是字级
易错现象:手算 F1 和 seqeval 对不上。原因:手算按标签个数(甚至按字)统计,seqeval 按整个实体匹配,差一个 I 就整条判错。怎么办:统一实体级口径,报告里写清标签体系与 strict 模式。
10 秒自测 · 点开看答案

问题:真实是 B-ORG I-ORG I-ORG,预测是 B-ORG I-ORG O,seqeval 算几个 TP?

答案:0 个。预测实体「培训」与真实「培训中心」边界不同,算 1 个 FP、1 个 FN;按字算却有 2/3 是对的。

概念 KP 04.22

jieba / HanLP / LTP:三个中文工具的分词与词性集差在哪?

一句话

切分粒度、词性体系、任务覆盖都不同,混用标签会埋雷。

jieba 轻量:词典 + 前缀树分词,默认用 HMM 发现新词,jieba.posseg 给词性,词性集属 ICTCLAS 系(n、v、a、nr、ns、uj 等),课上的「的/uj」就是这套。HanLP 更全:词典、感知机、CRF、深度学习等多模型,覆盖分词、词性、NER、依存等流水线。LTP 是哈工大的流水线工具,覆盖分词、词性、NER、依存句法与语义角色(具体标签集随版本 / 规范而变,补充)。三者切分规范与词性集不同,别跨工具混标签。

工具定位分词路线词性集 / 任务
jieba轻量、上手快词典 + 前缀树 + HMM 新词ICTCLAS 系词性,主做分词 / 词性
HanLP全栈工具包词典 / 感知机 / CRF / 深度学习分词、词性、NER、依存等多任务
LTP哈工大流水线统计 + 神经网络模型分词、词性、NER、依存、语义角色
10 秒自测 · 点开看答案

问题:把 jieba 标好的词性直接拿去训练或评测用 LTP 体系的模型,有什么问题?

答案:两套词性标签集含义与粒度不同,标签对不上,模型学到和评测的不是同一套规范,结果不可比。

概念 KP 04.23

关系抽取与事件抽取:在实体之上再抽一层结构

一句话

NER 找实体,RE 把实体连成关系,EE 抽出整件事的论元。

命名实体识别只标出实体及其类型;关系抽取(RE)在实体之上判断「谁和谁是什么关系」,输出(头实体, 关系, 尾实体)三元组;事件抽取(EE)识别事件类型与触发词,再抽论元角色(谁、何时、何地、金额)。二者常以 NER 为前置,评估单位从「实体」变成「关系 / 论元」。建模有管道式(先 NER 再分类,简单但错误会累积)与联合式(共享编码、同时解码)(补充)。

任务输出评估单位
NER实体 span + 类型实体级 P / R / F1
关系抽取(头实体, 关系, 尾实体)三元组级 P / R / F1
事件抽取事件类型 + 触发词 + 论元事件 / 论元级 F1
10 秒自测 · 点开看答案

问题:关系抽取为什么常把 NER 放在上游?管道式有什么风险?

答案:关系是实体对之间的关系,先识别实体才能连边;管道式会把 NER 的漏标与边界错误直接传给关系分类。

概念 KP 04.24

语义角色标注:一句话里「谁对谁做了什么」

一句话

SRL 以谓词为中心,给每个论元标出语义角色。

语义角色标注(SRL)以谓词(动词)为中心,把句子成分标成语义角色:A0 通常是施事、A1 是受事、A2 常是受益者或工具,另有 TMP(时间)、LOC(地点)等。它不满足于主语 / 宾语这类句法标签,而是回答「谁对谁做了什么」,为问答、信息抽取与机器翻译提供谓词-论元结构。做法是识别谓词后逐谓词做论元边界标注与角色分类,要求边界和角色都精确匹配(补充)。

易错把 A0 / A1 当成主语 / 宾语:被动句「杯子被小明打碎了」里受事「杯子」在句首,照句法位置硬套会把施事受事标反。要按语义关系判断,不要按语序。
10 秒自测 · 点开看答案

问题:SRL 里的 A0、A1 和句法上的主谓宾一样吗?

答案:不一样。A0 多数是施事、A1 多数是受事,但句式一变映射就变,被动句、把字句里尤其明显。

概念 KP 04.25

标注预算有限:主动学习怎么挑最值钱的样本

一句话

标注最贵,主动学习只标模型最没把握的样本。

信息抽取的标注成本远高于分类:一条句子要标实体边界与类型,还要标关系或事件论元,多人之间还得对齐口径。主动学习(active learning)用循环省标注:小种子集训练 → 给未标注池打分 → 挑最有价值样本送标 → 并入训练 → 重训。挑样本三条策略:不确定性(置信度低、margin 小、熵大)、多样性(向量聚类去重,避免挑一堆相似句)、委员会分歧(多个模型意见不一)(补充)。

易错每轮只挑最不确定的样本:模型只见困难样本,训练分布偏斜、评测虚高。要混入 10%–20% 随机样本做对照,并保持测试集固定不变。
10 秒自测 · 点开看答案

问题:主动学习为什么不能只按「不确定性」挑样本?

答案:只挑难例会让训练分布偏离真实分布、模型偏科;要和多样性、随机采样混合,每轮重新评估。

本章速查

一句话:序列标注 = 逐位置分类 + 标签之间的依赖。HMM 输在局部归一化和只看当前观测;CRF 用全局特征和全局归一化补上;BiLSTM+CRF 用神经网络学发射分数、用 CRF 层学转移约束、用维特比做全局解码。

对比项HMMCRFBiLSTM + CRF
建模方式生成式 P(x, y)判别式 P(y | x)神经网络 + 判别式解码
独立性假设齐次马尔可夫 + 观测独立两个都不需要两个都不需要
归一化方式局部(转移逐状态)全局全局(CRF 层)
上下文只看当前观测特征可引入任意上下文BiLSTM 编码左右上下文
标签偏置有无无
特征来源统计计数人工设计特征网络自动学习 + 转移矩阵
解码维特比维特比维特比
  • 标注体系必须一致:训练、验证、测试、解码要用同一套 BIO / BIOES;两套混用会出现「I 前无 B」,实体区间直接解析错。
  • 标签偏置(label bias):局部归一化的模型(如 HMM)会偏向分支少的状态;看到模型「偏爱某几个标签」,先查归一化方式和类不平衡。
  • O 标签过多:O 通常占绝大多数,token 准确率会被撑高;要看实体级 P/R/F1,别被 99% 的字准确率骗了。
  • 非法序列:O → I 这种孤儿标签要靠转移约束、CRF 解码或后处理兜住。
  • 未登录词:人名、缩略词、新词是 NER 的硬骨头,字级/子词建模 + 预训练表示是常见解法。

来源:第二章 PPT P65–P78。

05
LANGUAGE MODELS AND TEXT GENERATION

语言模型与文本生成:从 N-Gram 到 ELMo

这一章解决两个问题:模型怎么"猜下一个词",以及同一个词怎么随上下文变成不同的向量。

语言模型是 GPT、机器翻译、输入法、语音纠错共同的底座:给它前文,它给出下一个词的概率。本章沿着"怎么算这个概率"这条主线,依次看 N-Gram(数频数)、RNN 语言模型(带记忆)、双向 RNN 语言模型(看得到两边但不能生成),最后落到 ELMo——用语言模型把静态词向量升级成随上下文变化的动态词向量。另外补上两块考试常问、课件没有展开的内容:解码策略(贪心 / 束搜索 / 温度采样)与评估指标(PPL / BLEU)。

5.1 语言模型是什么:给"下一个词"算概率

概念 KP 05.1

什么是语言模型?它到底在算什么?

一句话

给定前文,给词表里每个词算一个"接得上"的概率。

语言模型(Language Model, LM)是一个给词序列打概率的模型:给定已经出现的词,它输出词表里每个词作为下一个词的概率。它的训练目标可以概括成一句话——让正确答案是下一个词的概率尽量大。今天的大语言模型(Large Language Model, LLM)参数量再大,预训练目标依旧是这一件事。

由概率的链式法则,一整句话的概率可以由每个词的条件概率连乘得到。例如"大海的颜色"可以拆成 P(大海) × P(的 | 大海) × P(颜色 | 大海, 的)。本章讲的 N-Gram 和 RNN,本质上都是在用不同办法估计这个条件概率;注意每一步的条件都是"全部前文",所以语言模型天然是自回归的——每生成一个词,都要把它算进下一轮的条件里。

凡是需要"续写"或"判断一句话像不像人话"的场景都有它的身影:

  • 文本生成:续写、对话、写作,每一步从概率分布里挑一个词接上去。
  • 输入法与搜索联想:打完"今天天气",候选栏蹦出"真好 / 不错 / 怎么样",就是按条件概率从高到低排序。
  • 机器翻译:解码器逐词生成译文时,要判断"这句译文像不像人话"(第 06 章 Seq2Seq 会用到这个视角)。
  • 纠错与重排序:语音识别、拼写纠错给出若干候选,用语言模型给整句打分,把"我今天去天汽"这类候选压下去。
公式

P(w1, w2, …, wn) = P(w1) × P(w2 | w1) × … × P(wn | w1…wn-1)

生活类比语言模型就是"文字接龙":每个人只能看前面的人说了什么,再接一个最顺的词。区别只在于它不说"我觉得接'开心'顺",而是给词表里每一个词都算一个接得上的概率,再按概率行事。
10 秒自测 · 点开看答案

问题:语言模型输出的是一个词,还是一整个分布?

答案:是整个词表上的概率分布。训练时用交叉熵把正确答案的概率往上推;推理时再从这个分布里"取"一个词,怎么取就是 5.5 节的解码策略。

5.2 N-Gram:数频数的古典语言模型

概念 KP 05.2

N-Gram 语言模型:马尔可夫假设是什么?

一句话

只根据前 n-1 个词猜下一个词:n 越大看得越远,也越容易"没见过"。

N-Gram(N 元语言模型)是最古典的语言模型:它不理解语义,只做两件事——做假设、数频数。

马尔可夫假设(Markov Assumption)说:预测下一个词时,只依赖紧挨着的前 n-1 个词,更早的历史一律忽略。于是 n=1(unigram)只看词频本身,n=2(bigram)看前 1 个词,n=3(trigram)看前 2 个词,n 越大看得越远。这个假设相当于把"整段历史"砍成了"一个固定窗口"。

做了这个假设,条件概率就能用频数相除直接估出来:数一个 n-gram 在语料里出现几次,再数它的前缀出现几次,两者相除就是概率。这就是 N-Gram 的全部算法——没有需要训练的权重,只有一张巨大的计数表。

公式

P(wt | w1…wt-1) ≈ P(wt | wt-n+1…wt-1) = count(wt-n+1…wt) ÷ count(wt-n+1…wt-1)

生活类比把一句话看成一队人:近视 300 度的人只认得出前面 1 个人(bigram),近视 100 度能认出前面 2 个(trigram)。轮到他猜下一个人是谁时,队伍更前面站过谁,他根本没看见——马尔可夫假设就是这副"只认最近几个"的眼镜。
公式 KP 05.3

手算一遍:bigram 下 "I am Lily" 的概率是多少?

一句话

bigram 只看相邻两词,四个条件概率连乘就能拼出整句概率。

课件给的例题只有三句语料(<s> 是句首标记、</s> 是句尾标记,它们也当成词参与统计):

  • <s> I am Lily </s>
  • <s> Lily I am </s>
  • <s> I do not like green eggs and ham </s>

bigram 统计的就是相邻词对。先数分母、再数分子:<s> 在三句开头各出现 1 次、共 3 次,其中后面接 I 的有 2 次,所以 p(I | <s>) = 2/3 ≈ 0.667;I 出现 3 次,有 2 次后面接 am,所以 p(am | I) = 2/3 ≈ 0.667;Lily 出现 2 次,只有 1 次后面是句尾,所以 p(</s> | Lily) = 1/2 = 0.5。

要算整句概率,还得补一步 p(Lily | am):am 出现 2 次,后面接 Lily 的只有 1 次,所以是 1/2。于是整句概率 = 2/3 × 2/3 × 1/2 × 1/2 = 1/9 ≈ 0.111(最后这一步为示例推导)。

公式

p(I | <s>) = 2/3 ≈ 0.667;p(am | I) = 2/3 ≈ 0.667;p(</s> | Lily) = 1/2 = 0.5

易错分母写错:p(I | <s>) 的分母是"<s> 出现的次数",不是"语料共有几句"——本例两者都等于 3,很多考题里并不相等。分子也不是"以 I 开头的句子数",而是"<s> 后面正好接 I 的次数"。
10 秒自测 · 点开看答案

问题:若语料再加一句 <s> I am fine </s>,p(I | <s>) 与 p(am | I) 各变成多少?

答案:p(I | <s>) = 3/4 = 0.75(四句里三句以 I 开头);I 共出现 4 次、其中 3 次后接 am,所以 p(am | I) = 3/4 = 0.75。

概念 KP 05.4

N-Gram 的两个死穴:稀疏与存储

一句话

n 小看不远、n 大见不着——而且计数表大到存不下。

稀疏(Sparsity):n 越大,要统计的 n-gram 组合越多。窗口变大后,绝大多数组合在有限语料里一次都没出现过,count = 0,条件概率就是 0;句子里只要有一个 0,整句概率就归零。模型不是"判定不可能",而是"根本没见过"。

存储(Storage):所有 count 都必须预先数好存下来。词表大小 V、n = 3 时要存的组合量级是 V³;若 V ≈ 10 万,V³ 就是 10¹⁵ 量级(估算),任何机器都存不下;即使 n = 2,也已有 V² = 10¹⁰ 个潜在词对。

所以工程上只能取 n ≈ 3~5 的折中,再用平滑补丁兜底;实际实现还会把概率连乘换成对数相加,否则长句概率会小到浮点下溢成 0(补充)。这两个死穴正是神经网络语言模型要替代 N-Gram 的直接原因。

补充 · 平滑常见补丁是加一平滑(Laplace smoothing)、回退(backoff)与插值(interpolation):给没见过的 n-gram 强行分一点概率,避免整句归零。它们能缓解稀疏,却解决不了"n 大就存不下、n 小就看短"的根本矛盾。
易错稀疏不是"语料太脏",而是组合爆炸的必然结果:任何有限语料对 V 个词的 n 次组合都只是沧海一粟。真正的出路是换模型——用连续向量和参数共享,让"没见过"的组合也能拿到合理概率。

5.3 RNN 语言模型:把记忆接进预测

概念 KP 05.5

RNN 语言模型:Embedding → RNN 层 → softmax

一句话

顺序读词,把前文摘要存进隐藏状态,每一步都预测下一个词。

RNN 语言模型把"数 n-gram"换成"用一个带记忆的网络算条件概率"。输入是词/字编号,流程固定三步:Embedding(查表得到词向量)→ RNN 层(逐词更新隐藏状态)→ softmax 层(输出词表上的概率分布)。

关键在隐藏状态:它把"从开头到当前词"的信息压缩成一个向量,每读一个词就更新一次;softmax 再把当前隐藏状态映射成词表上每个词的得分与概率,取概率最高的词就是这一步的预测。预测出哪个词,就把它接回输入继续预测——这种"用自己上一步的输出当下一步输入"的模式叫自回归(Autoregressive)。

训练时标签是同一句话整体右移一位:输入第 1~n 个词,目标就是第 2~n+1 个词,损失函数是词表级多分类的交叉熵。与文本分类相比,分类任务只取最后一个隐藏状态输出 1 个标签,而语言模型每个时间步都要输出一次预测,同一段文本因此被用出了 n 个训练样本。

公式

ht = tanh(U·e(wt) + W·ht-1);P(wt+1 | w1…wt) = softmax(V·ht + b)

生活类比读小说时,你每读一句,心里就自动生出"下一段大概会怎样"的预期;读得越多,预期越具体。RNN 的隐藏状态就是这份不断被更新的"心理预期",softmax 输出的则是它给每个候选词打的分。
10 秒自测 · 点开看答案

问题:训练 RNN 语言模型时,为什么输入是第 1~n 个词、标签却要右移一位?

答案:语言模型的每个位置都在做"给定前文预测下一个词",右移一位才能让每个位置的输出都有标准答案,从而把每个位置都变成一个分类样本。

概念 KP 05.6

为什么 RNN 语言模型能取代 N-Gram?

一句话

任意长度、参数共享、没有稀疏——三件事一次解决。

课件把 RNN 语言模型的优势归纳为三条,正好对应 N-Gram 的三个痛点:

  • 可处理任意长度:无论句子多长,网络结构不变、参数量不变;N-Gram 的 n 一旦定死,视野就定死了。
  • 参数共享:同一个 RNN 单元在所有时间步复用同一套权重,训练一次就把规律用到所有位置;N-Gram 则是每个词组合各存各的计数。
  • 没有稀疏问题:预测靠词向量与隐藏状态算出的连续值,而不是查表。就算训练时没见过某个词组,只要词向量相近,也能得到合理概率——泛化能力来自向量空间,而不是计数。

此外,隐藏状态理论上能携带从句子开头到当前的全部前文,上下文长度远超 n = 3~5 的窗口;当然实际上会因遗忘而打折(第 06 章讲梯度消失与长距离依赖)。另外,把 RNN 语言模型接在编码器给出的上下文向量之后,它就是 Seq2Seq 的解码器——这部分留到第 06 章展开。

易错"没有稀疏"指的是不需要 n-gram 计数表,不是说 RNN 遇不到没见过的词:未登录词(OOV)仍要处理(<UNK> 或子词切分),两类问题不要混为一谈。
概念 KP 05.7

双向 RNN 语言模型:看得全,为什么不能写?

一句话

它能同时利用左右上下文,但生成时"右边"根本还不存在。

双向 RNN(Bidirectional RNN, BiRNN)用两个方向相反的 RNN 分别读同一句话,把每一步的正向隐藏状态与反向隐藏状态拼接起来,于是每个词的表示都同时包含左边和右边的上下文。对"理解一句话"来说,这比单向强得多。

但它不能直接用于文本生成:生成是单向的,第 t 步要预测的词还没出现,反向 RNN 需要的"右边上下文"此刻并不存在。换一种说法:训练时双向模型已经看过"答案",相当于提前翻了答案页;推理时没有答案可看,模型就无从下手。课件对这一点说得更直接——双向的相当于已经知道了下字预测的答案。

所以双向 RNN 的用武之地是理解类任务:词性标注、命名实体识别、序列标注、情感分类、阅读理解、完形填空,以及"给现成的句子打分"(候选重排序)——这些都不需要它把未来的词写出来。

生活类比做阅读理解时可以翻完整篇文章再答题,这是双向,看得全;老师让你续写小说结尾时,后面的情节还没发生,你只能顺着写,这是单向。双向 RNN 是开卷考生,不是续写作者。
10 秒自测 · 点开看答案

问题:既然双向 RNN 不能生成,为什么还要训练"双向 RNN 语言模型"?

答案:两个方向各自都是合法的单向语言模型,都能正常算条件概率;把两侧表示拼起来就能得到更丰富的词表示,喂给下游理解任务。ELMo 正是沿着这条路走下去的产物。

5.4 从双向 RNN 到 ELMo:动态词向量

概念 KP 05.8

静态 vs 动态词向量:"苹果"到底指什么?

一句话

静态词向量一个词只有一张脸;动态词向量看上下文换表情。

静态词向量(Static Word Embedding)指 Word2Vec、GloVe 这类方法:给每个词学一个固定向量。词表里的"苹果"只有一条记录,不管它出现在"苹果手机"还是"吃苹果"里,向量都一模一样。

动态词向量(Dynamic Word Embedding)则基于语言模型:先在语料上训练"根据上下文生成表示"的能力,再按当前句子现场算出每个词的向量。"苹果手机"里的"苹果"会被上下文拉向数码、品牌,"吃苹果"里的"苹果"则被拉向水果、食物——同一个词,两个不同的向量。

这就是"一词多义"在向量层面的解法:静态向量像查字典,一个词条一个释义;动态向量像结合场合理解,先看它和谁一起出现,再决定它是什么意思。

静态 · Word2Vec / GloVe

一个词一个向量,训练完就冻结;下游直接查表。省事,但消解不了一词多义,也跟不上领域变化。

动态 · ELMo / BERT / GPT

向量由上下文现场计算,同一个词在不同句子中不同;能区分义项,代价是每次都要跑一遍模型。

10 秒自测 · 点开看答案

问题:为什么静态词向量处理"苹果"的一词多义会失效?

答案:因为同一个词只有唯一向量,模型无法区分"手机品牌"和"水果"两个义项;动态词向量把上下文编码进了表示,才能让同一个词在不同句子里拿到不同向量。

概念 KP 05.9

ELMo 的结构:为什么是两个"独立的单向 LSTM"?

一句话

两个单向 LSTM 各读一个方向,谁都没有偷看答案。

ELMo(Embeddings from Language Model)是"用语言模型造动态词向量"的代表作(补充:2018 年提出)。它的骨架不是一个双向 LSTM,而是两个独立的单向 LSTM:一个从左往右读、一个从右往左读,各自训练"预测下一个词"的语言模型任务。

这个区别是考点。真正的双向 LSTM 在每一步都能同时用到左右两边,用它训练"预测下一个词"等于直接看答案,训练不诚实;而两个独立的单向 LSTM 各自只能看自己那一侧,都是合法的语言模型,训练完成后各自都能续写。ELMo 只是把两个方向的隐藏层输出在表示层拼起来用——理解时享受双向信息,训练时不作弊。

双向模型预训练完成后,模型的编码部分就可以用来计算任意文本的动态词向量表示,再交给下游任务使用。

公式

ht,j = [ ht,j→ ; ht,j← ](第 j 层、第 t 个词:把正向与反向的隐藏状态拼接)

生活类比一个案子,侦探 A 从案发当天往后查,侦探 B 从最新线索往回查。两人各自写的报告都是完整的(各自都是合法的单向语言模型),最后把两份报告对照着看,案情才全面。不是一个人同时站在时间的两头。
10 秒自测 · 点开看答案

问题:ELMo 的"双向"与 BiRNN 的"双向"差在哪?

答案:BiRNN 是一个模型在每一步同时读取左右两侧,所以不能用来生成;ELMo 是两个独立的单向 LSTM 各自单向读取,再把表示拼起来,因此既能用于生成式预训练,也便于冻结后当下游特征。

公式 KP 05.10

ELMo 的分层加权:不同任务自己挑"哪一层"

一句话

底层偏字词句法、顶层偏语义;权重由下游任务自己学出来。

ELMo 不止一层 LSTM,每一层输出的隐藏状态都代表不同层次的特征,因此每一层都不能丢:把它们加权求和,权重不是人定的,而是可学习的参数,由下游任务在训练中学出来——不同任务学到的权重不同。

不同层的偏好有规律:越接近顶层的 LSTM 隐含层表示,通常编码了更多语义信息,适合阅读理解这类对语义要求高的任务;越接近底层的表示更偏重词法、句法信息,适合命名实体识别这类任务。

用法上,ELMo 是把预训练好的表示当作"额外的词向量特征"喂给下游模型(feature-based),模型本身不再大改;这一点与后面 BERT 那种"预训练 + 微调全部参数"的范式不同(补充)。

公式

ELMok = γ · Σj=0L sj · hk,j(sj 是可学习权重,γ 是任务相关的缩放系数)

生活类比底层像小学:认字、词性、搭配;中层像中学:句子结构和语法;顶层像大学:主旨与言外之意。改病句(类似 NER)小学功底就够;做阅读理解,得把大学层级的理解调出来。
10 秒自测 · 点开看答案

问题:为什么命名实体识别更偏爱 ELMo 的底层表示?

答案:NER 主要靠"这个词长什么样、附近词的词性与搭配"这类词法、句法线索,底层表示正好偏这一类;而阅读理解需要整句甚至跨句的语义,顶层更合适。

5.5 生成与评估(补充)

概念 KP 05.11

解码策略:贪心、束搜索与温度采样

一句话

模型只给概率分布,怎么从分布里把词挑出来是另一门学问。

语言模型输出的是每个词的概率,解码(decoding)才是把分布变成句子的那一步。最简单的是贪心搜索(Greedy Search):每一步都取当前概率最高的词。它快、结果确定,但只看眼前——某一步的局部最优可能把整句带进沟里,还容易陷入"重复循环"或"过早结束"。

束搜索(Beam Search)每一步保留得分最高的 k 条候选路径(k 即 beam 宽度),最后比较整条序列的累计对数概率,选出全局更优的一条。它比贪心更可能拿到整体更好的句子,代价是计算量与内存大约变成 k 倍。不过束搜索也救不了欠拟合:模型概率分布本身很平时,搜得再细也没用——教学实验里把贪心换成 beam=3,输出几乎没变(补充·实测)。

温度采样(Temperature Sampling)不取 argmax,而是按概率随机采样;采样前先把 logits 除以温度 T 再做 softmax。T < 1 让分布更尖(更保守、更确定),T = 1 保持原分布,T > 1 让分布更平(更随机、更有"创造力"),T 趋近 0 时退化成贪心。

公式

候选序列得分 = Σi log P(yi | y1…yi-1, x);pi = exp(zi / T) ÷ Σj exp(zj / T)

# 取最后一个时间步的 logits,除以温度后再 softmax
next_logits = logits[:, -1, :] / temperature
probs = torch.softmax(next_logits, dim=-1)
# 按概率采样下一个字(temperature=0.7 时更保守)
next_id = torch.multinomial(probs, num_samples=1).item()
# 把生成的字接回输入末尾,进入下一步预测
input_ids = torch.tensor([[next_id]], dtype=torch.long).to(device)
补充 · Top-k 与 Top-p工业界常用"先截断再采样":Top-k 只在概率最高的 k 个词里采样;Top-p(核采样)只在累计概率达到 p 的最小词集合里采样,避免把 T 调大后采到极低概率的怪词。
解码策略每步怎么选词优点代价 / 风险
贪心搜索 Greedy取当前概率最大的 1 个词最快、结果确定、容易复现局部最优;易重复输出、过早结束
束搜索 Beam Search保留 k 条候选路径,最后比较整句累计 log 概率整句概率更优,翻译、摘要常用计算与内存约 ×k;模型欠拟合时收益有限
温度采样 TemperatureT < 1 更尖、T > 1 更平,按概率随机采样有随机性,适合开放生成与对话T 过大易跑题、胡言乱语;结果不可复现
公式 KP 05.12

怎么评价语言模型?PPL 与 BLEU(补充)

一句话

语言模型看"犹豫程度"(PPL),生成结果看"与参考答案的重合"(BLEU)。

困惑度(Perplexity, PPL)衡量"模型在每一步平均要在多少个候选词里犹豫",它就是平均交叉熵损失的指数:PPL = exp(loss)。PPL 越小越好,等于 1 表示完美(每一步都 100% 确定正确答案);词表有 V 个词时,随机乱猜的 PPL 约等于 V。例如一次教学实验中 loss 从 6.7113 降到 3.3779,对应 PPL 从约 821 降到约 29.3——即模型平均还在约 29 个词之间犹豫(补充·实测)。

但 PPL 只说明"模型觉得文本有多顺",判断不了生成结果好不好。翻译、摘要这类有参考答案的任务常用BLEU:把生成结果与参考译文做 1~4-gram 的精确率统计,取加权几何平均,再乘一个长度惩罚 BP(生成太短就惩罚),得分越高越贴近参考译文。

BLEU 的局限也很明确:它只看字面 n-gram 是否重合,同义改写、语序调整、语义正确但用词不同,都可能被扣成低分;它不理解句子含义,只统计表面重叠。所以 BLEU 通常要配合人工评估一起看,不能当作译文质量的唯一标准。

公式

PPL = exp( −(1/N) · Σ ln P(wi | 前文) ) = exp(loss)

补充 · 指标要配套看PPL 依赖词表大小与分词粒度,不同词表、不同分词的模型之间不能直接比 PPL——这就像两个班用不同满分制考试,平均分不可比。BLEU 则依赖参考译文的数量与质量,通常要报多个参考下的平均分。
10 秒自测 · 点开看答案

问题:PPL 从约 821 降到约 29.3,说明了什么?又不能说明什么?

答案:说明模型对下一个词的预测明显更有把握(平均犹豫的候选词从约 821 个降到约 29 个);但不能说明生成的句子一定通顺、准确——PPL 低只代表对训练分布更自信,评价生成质量还得看输出本身(人工或 BLEU 等)。

模型怎么算下一个词上下文范围词向量能否用于生成主要局限
N-Gram数 n-gram 频数,相除得概率前 n-1 个词无(离散计数)能,逐词查表数据稀疏、计数表存储爆炸
RNN 语言模型Embedding → RNN → softmax,逐词更新隐藏状态理论任意长,实际会遗忘动态(隐藏状态随上下文变)能,自回归逐词生成训练慢,长距离依赖会丢失
双向 RNN 语言模型正、反两个方向同时读,拼接两侧隐藏状态左右整句动态不能,生成时右侧不存在只能用于理解类任务
ELMo两个独立单向 LSTM + 多层输出加权求和左右整句(表示层融合)动态能(各自单向),实际用途是取表示权重需下游任务再学习,推理开销大
公式 KP 05.13

N-Gram 平滑:给没见过的组合留一点概率

一句话

加一、插值、回退都是在补零概率,别让整句直接归零。

(补充)N-Gram 只要有一个 count 为 0,整句概率就归零;平滑(Smoothing)就是来兜底的。加一平滑(Add-one / Laplace)给每种组合的计数都 +1,分母同时 +V,概率之和才仍为 1。插值(Interpolation)把不同阶的模型加权混合,例如 P = λ·P₃ + (1−λ)·P₂,λ 可由语料学出来。回退(Backoff)则是高阶查不到就退到低阶,并配合折扣因子把省下的概率分给低阶。Kneser-Ney 再进一步,用“能接多少种不同的词”代替裸频数(补充,只提名字)。

公式

P_add1(wi | wi−1) = (c(wi−1, wi) + 1) ÷ (c(wi−1) + V) P_interp = λ·P_high + (1 − λ)·P_low

易错分母必须 +V 而不是 +1:分子给 V 种可能的下一词都加了 1,分母不补上这 V 个计数,所有概率之和就大于 1。另外加一平滑会把高频词的概率压得偏狠,所以实践中更常用 Kneser-Ney 等折扣类平滑(补充)。
10 秒自测 · 点开看答案

问题:V = 1000,c(wi−1) = 100、c(wi−1, wi) = 0,加一平滑后的条件概率是多少?

答案:(0 + 1) ÷ (100 + 1000) = 1/1100 ≈ 0.00091。没见过的组合也拿到了非零概率,整句就不会归零。

公式 KP 05.14

手算一遍:四个词的概率怎么变成 PPL

一句话

PPL = exp(平均负对数似然),概率越小,困惑度越大。

(补充)困惑度(Perplexity, PPL)是“每一步平均不确定度”的指数:把正确词的概率取对数、求平均,再取 exp。直观理解:PPL 就是模型每走一步平均要在多少个候选词里挑选,越小越有把握。设一句话 4 个词的条件概率依次为 0.5、0.25、0.125、0.0625:平均负对数似然 = −(ln0.5 + ln0.25 + ln0.125 + ln0.0625) ÷ 4 = 1.733,所以 PPL = e1.733 ≈ 5.66,即模型平均在约 5.66 个候选词之间犹豫。若 4 步概率全是 0.5,则 PPL = 2。

公式

PPL = exp( −(1/N) · Σ ln pi ) = (∏ 1/pi)1/N 示例:N = 4,p = 0.5, 0.25, 0.125, 0.0625 → PPL ≈ 5.66

易错两个常见错误:① 忘了最后取 exp,把 1.733 直接当 PPL;② 概率连乘会下溢成 0,实现时先在对数域求和再取 exp。另外 PPL 依赖词表大小与分词粒度,不同词表之间不能直接比(补充)。
10 秒自测 · 点开看答案

问题:PPL = 2 说明了什么?

答案:等价于每一步正确词的平均概率为 0.5,即模型平均只在 2 个等概率候选词之间犹豫;PPL 越小,模型对下一个词越有把握。

公式 KP 05.15

温度采样:T < 1 更保守,T > 1 更随机

一句话

softmax 前先除以 T:T 调小更尖,调大更平。

(补充)温度采样在 softmax 之前先把 logits 除以温度 T:pi = exp(zi/T) ÷ Σj exp(zj/T)。T < 1 时指数被放大,分布更“尖”,高概率词更容易被选中,输出更保守、更可复现;T = 1 保持模型原分布;T > 1 时分布被拉平,低概率词也有机会,输出更随机、更像“发散创作”。T 趋近 0 时退化为 argmax 贪心。以 logits [2, 1, 0] 为例,最高词概率在 T = 1 时约 0.665,T = 0.5 时升到约 0.867,T = 2 时降到约 0.506。

公式

pi ∝ exp(zi / T);T < 1 → 更尖、更保守;T > 1 → 更平、更随机

10 秒自测 · 点开看答案

问题:把温度从 1 调到 0.5,同一组 logits 的采样会有什么变化?

答案:分布变尖,最高概率词的占比上升(示例中约 0.665 → 0.867),模型更倾向选头部词,多样性和“惊喜感”下降。

概念 KP 05.16

Top-k 与 Top-p:截固定个数,还是截累计概率?

一句话

Top-k 固定留 k 个;Top-p 按累计概率截一段,长度自适应。

(补充)两者都在 softmax 之后先截断候选集、再重新归一化。Top-k 固定保留概率最高的 k 个词:k = 1 等价贪心,k = V 等价全量采样;缺点是 k 固定,分布很尖时仍可能放进坏词,分布很平时又会砍掉合理词。Top-p(核采样,Nucleus Sampling)把词按概率从大到小累加,保留“累计概率刚好达到 p”的最小集合(常用 p = 0.9~0.95),候选个数随分布自适应:模型有把握时只留几个词,没把握时自动放宽。所以 Top-k 简单可控,Top-p 更适合开放生成,工程上也常两者叠加使用。

Top-k

固定 k 个候选,超参直观、计算简单;k 太小容易重复,k 太大又太散。

Top-p(核采样)

候选个数动态变化,累计概率到 p 即停;p 大更放飞,p 小更保守。

10 秒自测 · 点开看答案

问题:模型输出分布很平(很多词概率接近)时,Top-p 的候选词数量会怎样?

答案:变多。因为要累加到 p 才停,平坦分布得纳入更多词;分布很尖时则只留少数几个。

面试 KP 05.17

束搜索的三个细节:束宽、长度归一化、提前终止

一句话

每步留 k 条路径,最后比“归一化后的累计对数概率”。

(补充)束搜索每步从当前 k 条候选路径出发,各自扩展词表里的所有词,得到 k × V 个新序列,再按累计对数概率保留最好的 k 条;k 即束宽(beam width),k = 1 退化为贪心,常用 3~10。工程上还有两个细节:① 长度归一化——对数概率全是负数,序列越长累加越小,不归一化会偏爱短句,常见做法是除以 |y|α(α ≈ 0.6~1)或乘 GNMT 长度惩罚;② 提前终止——遇到 </s> 的候选不能再扩展,但最好等“已完成句子的分数”确定优于未完成候选时再停,否则可能错过更好结果。

公式

score(y) = (1 / |y|α) · Σt log P(yt | y<t, x);k = 1 即贪心,k 越大搜索越广,代价约 ×k

易错不归一化直接比总分,短句因项数少而占优,束搜索会系统性偏爱短输出;提前终止也不能“一出现完整句就停”——其他未完成路径可能后来居上。
10 秒自测 · 点开看答案

问题:束宽 k = 3 的束搜索,每一步要评估多少个候选扩展?

答案:k × V(V 为词表大小),再从中留下 3 条路径;所以计算量约是贪心的 3 倍。

公式 KP 05.18

BLEU 与 ROUGE:只看字面重合,为什么只能当参考

一句话

BLEU 看 n-gram 精确率 + 长度惩罚;ROUGE 看召回,都只是字面分。

(补充)BLEU 是翻译常用指标:统计生成句与参考译文在 1~4-gram 上的精确率 pn,每个 n 的匹配数先“截断”到参考中出现的次数,再取加权几何平均,最后乘长度惩罚 BP:候选比参考短时 BP = e1−r/c,把分数压低。ROUGE 更偏召回,常用于摘要:ROUGE-N 看参考里的 n-gram 有多少被生成结果覆盖,ROUGE-L 用最长公共子序列衡量。两者都只数表面重合:同义改写、语序调整、语义正确但用词不同都可能低分,所以只能当参考,必须配合人工评估。

公式

BLEU = BP · exp( Σn wn · ln pn ),BP = min(1, e1−r/c) ROUGE-N = 命中的 n-gram 数 ÷ 参考的 n-gram 总数(召回)

易错BLEU 的匹配数要截断:生成 5 次 the、参考只有 1 次,最多只算 1 次,否则靠重复刷分。另注意 BP 只在候选比参考短时小于 1;候选更长不会被罚,但句子啰嗦还得靠人工看。
概念 KP 05.19

暴露偏差:训练时看真值,推理时只能看自己

一句话

训练喂真值、推理喂自己,这个输入错位就是暴露偏差。

(补充)训练时用教师强制(Teacher Forcing):第 t 步的输入是数据里的真实前文,模型从没吃过自己预测错的词;推理时没有真值,只能把上一步自己的输出喂回去。这种训练与推理的输入分布错位叫暴露偏差(Exposure Bias)。后果是错误累积:第一步偏一点,下一步就落在训练时没见过的状态上,越错越偏,长句尤其明显。缓解办法有 scheduled sampling(逐步混入模型自己的预测)、用束搜索减少单步错误,以及改用序列级目标训练(补充)。但只要还按逐词最大似然训练,它只能缓解、难以根除。

生活类比学车时副驾全程帮你把方向盘掰正(真值);拿到驾照后没人扶,每个小偏差都得自己救——可训练时从没练过“从自己的小错里往回救”,一错就容易滚成大雪球。
10 秒自测 · 点开看答案

问题:暴露偏差的根源是模型容量不够吗?

答案:不是。根源是训练输入(真实前文)与推理输入(模型自己生成的词)分布不一致;模型再强,只要训练仍用教师强制,这个错位就存在。

概念 KP 05.20

生成复读机:repetition penalty、no-repeat n-gram 与覆盖率

一句话

三种手段按住复读:软惩罚、硬禁止、覆盖率约束。

(补充)自回归生成常出现复读:模型见“我我我”“非常非常”这类上下文后,继续重复的概率最高,于是越写越重复。常用三招:① 重复惩罚(repetition penalty)——对已出现词的 logits 做缩放惩罚,正数除以 θ、负数乘以 θ(θ > 1,常见 1.1~1.3);② no-repeat n-gram——直接禁止生成已经出现过的 n-gram(常用 n = 3~4),是硬约束;③ 覆盖率(coverage)——在摘要、翻译中统计源文哪些部分已被关注过,惩罚反复关注同一处、鼓励覆盖未用信息,顺带减少漏译。前两者压重复,覆盖率高还能减少遗漏。

公式

repetition penalty:logit′i = logiti ÷ θ(logiti > 0)或 logiti × θ(logiti < 0),θ > 1 no-repeat n-gram:若下一词会补全出现过的 n-gram,则把它的概率置为 0

易错no-repeat n-gram 是硬约束,可能破坏必要的重复(如“拜拜”“very very”),n 取太小会明显影响流畅度;重复惩罚是软约束,θ 调太大会逼模型躲开常用词,句子反而别扭。两者可叠加,但要分别验证。
概念 KP 05.21

语言模型应用地图:从输入法到代码补全的六种包装

一句话

输入法、纠错、翻译、摘要、对话、代码补全,共用一个下一词概率内核。

语言模型的公共内核是条件概率 P(下一个词 | 上文),产品只是换输入输出与解码约束:输入法按上下文给候选词排序;纠错把低概率片段改成高概率写法;翻译是跨语言条件生成,编码源句再解码;摘要把长文压成短版;对话在多轮上下文上继续生成;代码补全在代码前缀后接 token。训练目标都是预测下一个 token,差在领域数据、提示格式与评测指标(补充)。

应用输入 → 输出关键点
输入法拼音串 → 候选词候选按语言模型概率排序
纠错含错句 → 修正句找低概率片段再替换
翻译源语言句 → 目标语言句编码源句、解码目标句
摘要长文 → 短摘要压缩同时保住关键信息
对话多轮上下文 → 回复续写再加指令约束
代码补全代码前缀 → 后续 token长上下文、格式敏感
10 秒自测 · 点开看答案

问题:输入法与翻译能用同一个语言模型内核吗?

答案:内核都是「给定上文预测下一 token」,差别在输入输出格式、领域数据和解码约束;翻译还要先编码源句。

概念 KP 05.22

检索增强生成(RAG):为什么外挂知识库能减少幻觉(补充)

一句话

RAG 让模型先查资料再答题,把答案依据从记忆换成原文。

大模型把知识压进参数,会过时、记错、无法溯源。检索增强生成(RAG)在回答前先从外部知识库检索 top-k 相关段落:问题编码成向量 → 向量库近邻检索 → 把「问题 + 段落」拼进提示 → 模型依据上下文作答。减少幻觉的原因:答案有原文依据、改文档即可更新知识、可附引用核对。代价是检索召回决定上限,检索错或上下文冲突都会拖垮回答,所以要分块、重排、评测检索命中率(补充)。

易错以为上了 RAG 就不会幻觉:检索不到或召回错误时,模型仍可能凭参数记忆编造。要允许「不知道」、要求引用原文,并单独评测检索命中率。
10 秒自测 · 点开看答案

问题:RAG 减少幻觉的机制是什么?

答案:把答案依据从参数记忆换成检索到的原文,知识可更新、可溯源、可核对;但检索失败时幻觉仍会发生。

概念 KP 05.23

长文本生成:分块、大纲、层次展开与重复控制

一句话

先大纲后展开,分块带重叠,重复交给惩罚与内容规划。

长文本生成要同时解决长度、结构、重复与覆盖四个问题。分块:把长输入切成带重叠的段落,避免跨段信息被切断;层次生成:先出大纲,再逐节展开,最后统一润色;滚动记忆:每生成一节就把前文摘要带回提示,维持全局连贯。重复控制用 repetition penalty、no-repeat n-gram,更根本的是先做内容规划,避免同一要点反复写。评估上 BLEU / ROUGE 只看 n-gram 重合,长文还要看连贯、事实一致与覆盖(补充)。

公式

长文生成 = 分块(带重叠)+ 大纲(逐节展开)+ 滚动摘要 + 重复控制

10 秒自测 · 点开看答案

问题:分块时为什么要留重叠?

答案:避免句子与指代关系正好被切在边界上,保留跨段上下文;代价是会有少量重复内容需要去重。

本章速查

  • 语言模型:给定前文预测下一个词;整句概率 = 各步条件概率连乘。
  • N-Gram:马尔可夫假设只看前 n-1 个词,频数相除估概率;n 越大越稀疏,计数表量级 Vn。
  • 例题数字:bigram 下 p(I | <s>) = 2/3、p(am | I) = 2/3、p(</s> | Lily) = 1/2,整句概率 1/9 ≈ 0.111。
  • RNN 语言模型:Embedding → RNN 层 → softmax;每个时间步都预测,标签右移一位;任意长度、参数共享、无稀疏。
  • 双向 RNN 语言模型:左右上下文都能利用,但不能生成——未来词还不存在,相当于提前看答案;只做理解类任务。
  • 静态 vs 动态词向量:Word2Vec 一词一向量;ELMo 按上下文现场生成,"苹果手机"≠"吃苹果"。
  • ELMo:两个独立的单向 LSTM(不是双向 LSTM)+ 多层输出加权求和 + 权重可学习;底层偏句法、顶层偏语义;预训练后给下游当特征。
  • 解码:贪心快但短视;束搜索保留 k 条路径更看全局;温度 T < 1 保守、T > 1 发散。
  • 评估:PPL = exp(loss),越低越好,但依赖词表、不能跨词表直接比;BLEU 看 n-gram 重合,不理解语义,需配合人工评估。

来源:第二章 PPT P79–P88;PPL/BLEU 为补充。代码片段取自课程代码 train_rnn_lm.py。

06
RNN & SEQ2SEQ

RNN 与 Seq2Seq:让网络学会「记忆」

词不是一个袋子里的散装符号:谁先谁后,会改写整句话的意思。

这一章回答三个问题:序列数据到底难在哪?循环神经网络(RNN)怎样把「记忆」接进网络?Seq2Seq 又怎样把一条只会读的 RNN 改造成一条会写的 RNN?学完你需要能:手写 RNN 前向五步、解释梯度消失与「弼马温」式的长距离依赖、画出训练期用教师强制、推理期用自回归的编码器-解码器结构。

6.1 序列数据:难在「顺序」二字

概念 KP 06.1

序列数据为什么难?先理解「时间步」

一句话

模型看句子不是一眼扫完,而是一个词元一个时间步地往前读。

图像是一整块矩阵,模型可以一次吃完;文本却是变长的序列,元素之间有先后。模型每处理一个词元(token)就算走过一个时间步(time step):处理「播放」是第 1 步,处理「周杰伦」是第 2 步,依此类推。同一个词出现在不同位置,模型看到的历史不同,它的含义也可能不同。

按输入输出的对应关系,序列任务大致分四类:一对一(图像分类)、一对多(看图说话)、多对一(文本分类、情感分析)、多对多(机器翻译、序列标注)。后三类都要处理「变长」和「顺序」,这正是 RNN 登场的理由。

生活类比像银行柜台叫号:客户 A 办完才轮到客户 B,一笔一笔按顺序来。叫号机每喊一个号,就相当于模型往前走了一个时间步。
易错把文本当成「词袋」直接求和再分类,顺序信息在这一步就丢了;时间步不是墙上的秒数,而是「处理到第几个位置」的计数。
10 秒自测 · 点开看答案

问题:「我爱自然语言处理」若切成「我 / 爱 / 自然语言处理」三个词元,处理「自然语言处理」是第几个时间步?

答案:第 3 个时间步。时间步数等于词元个数,与字符数无关。

概念 KP 06.2

相加、平均、全连接,为什么都不够用?

一句话

它们都像搅拌机:食材都进去了,顺序和主次却被搅没了。

要把一句话的词向量融合成一个「文本向量」,最朴素的做法是相加、取平均,或者把所有向量拼起来套一个全连接网络。三者都错在同一个地方:把序列当成了无序集合。

  • 忽略语序:「我爱你」和「你爱我」逐词相加结果完全一样,意思却天差地别。
  • 一视同仁:「播放」和「《稻香》」决定意图,「的」几乎不携带分类信息;简单求和却给了它们同等话语权。
  • 孤立处理:全连接层虽然权重共享,但算「《稻香》」时只看它自己,完全看不见前面的「播放」「周杰伦」。

换句话说,这类方法能得到「句子里有哪些词」,却得不到「这些词怎么排布、谁修饰谁」。而自然语言的很多信息,恰恰藏在排布里。

生活类比把整句话丢进搅拌机打成一锅糊:食材都在,但「先炒后煮」的顺序没了、主料配料的区别也没了——「先放糖后放盐」和「先放盐后放糖」打出来一模一样。
公式

平均池化:s = (1/T) × Σ x_t。交换任意两个 x_i、x_j,s 不变,所以词序信息被彻底抹平。

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 = tanh(W_x · x_t + W_h · h_{t-1} + b)。x_t ∈ R^E,h_t ∈ R^H;实验脚本为对齐方便采用无偏置写法 h_t = tanh(U · x_t + W · h_{t-1})。

易错隐藏状态既是「记忆」又是「每个时间步的输出」;别把最后一步的 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 个议题配一个新秘书、换一套笔记法则,否则每加一个词就要多养一个人。
公式

单层单向:N ≈ E×H + H×H + H;LSTM 约为 4 倍、GRU 约为 3 倍;双向 BiRNN 再乘 2。

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 前向只有五步:

  1. 初始化:造一个全零向量当空白记忆 h_0,每个序列开工前统一清零。
  2. 逐帧处理:按时间步顺序遍历序列,取出当前词向量 x_t。
  3. 核心计算:x_t 与旧记忆各做一次线性变换,相加后过 tanh,得到新记忆。
  4. 状态更新:把新记忆赋给「旧记忆」变量,完成循环传递。
  5. 结果保存:把每一步的 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 道题。你得逆着往第一题翻,把每一步「该背多少锅」累加起来。
公式

L = Σ_{t=1}^{T} L_t;∂L/∂W_h = Σ_{t=1}^{T} ∂L_t/∂W_h(权重共享,梯度累加)。

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 人排队的传话游戏:规则是「每传一人音量减半」,传到队尾早就没声了,这是梯度消失;换成「每传一人音量翻倍」,队尾听到的是炸耳尖叫,这是梯度爆炸。梯度裁剪像给话筒设音量上限——尖叫治好了,但「听不见」的毛病还在。
公式

连续链式乘积:∏_{k=1}^{t} ∂h_k/∂h_{k-1};裁剪:若 ‖g‖ > θ,则 g ← θ · g / ‖g‖。

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。两个方向各自拥有独立权重,但在同一个损失函数下同时训练,协同优化。

它常被用作编码器:命名实体识别、词性标注、句子表示都希望每个位置同时拥有左右上下文。但解码器不能用它,原因见下一张卡。

生活类比像两个人从两头读同一卷竹简:甲从头读到尾,乙从尾读到头。读到中间某一支竹简时,甲说「上文讲的是出征」,乙说「下文讲的是凯旋」——两人的话拼在一起,这一支简的完整含义才浮出来。
公式

h_t = [→h_t ; ←h_t] ∈ R^{2H};两个方向权重独立,参数量约为单向的 2 倍。

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) 这一对。

生活类比像一本带三个开关的会议纪要:旧页要不要撕(遗忘门)、新议题写不写进去(输入门)、这一页要不要念给外面听(输出门)。三者分开控制,书记员就不必每来一个议题都把整本笔记重写一遍。
公式

f_t = σ(W_f·[h_{t-1}, x_t] + b_f);i_t = σ(W_i·[h_{t-1}, x_t] + b_i);o_t = σ(W_o·[h_{t-1}, x_t] + b_o);c_t = f_t ⊙ c_{t-1} + i_t ⊙ tanh(W_c·[h_{t-1}, x_t] + b_c);h_t = o_t ⊙ tanh(c_t)。

易错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 直白。

公式

z_t = σ(W_z·[h_{t-1}, x_t]);r_t = σ(W_r·[h_{t-1}, x_t]);h̃_t = tanh(W_h·[x_t, r_t ⊙ h_{t-1}]);h_t = (1 - z_t) ⊙ h_{t-1} + z_t ⊙ h̃_t。

生活类比像老汤续锅:更新门决定这锅汤里加多少新汤、留多少老汤;重置门决定尝新料时还要不要参考旧汤底的味道。两个旋钮一调,就不必每次都倒掉重熬。
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 = h_T^(enc);p(y_1,…,y_M | x_1,…,x_T) = ∏_{t=1}^{M} 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]])            # 自回归:输出当下一步输入
生活类比贪心像下山只看脚下最陡的方向,每步都爽,最后可能困在小土坑;束搜索像同时派两三个探路队员,各自记下走过的路,最后比较全程总高度再选一条。
公式

贪心:y_t = argmax P(· | y_{<t}, C);束搜索打分:score(y_{1..M}) = Σ_{t=1}^{M} log P(y_t | y_{<t}, C)(取对数防止连乘下溢)。

易错贪心解码必须同时设「遇到 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 循环逐步算并压栈,框架版一次前向在内部完成同样的循环;两条路径数学等价,差异只应来自浮点累加顺序,因此对齐验证必须固定随机种子、无偏置、同初始态。

  1. 准备输入与权重。固定随机种子,把「播放 / 周杰伦 / 的 / 《稻香》」4 个词元查随机词向量表并补 batch 维,得到 (1,4,128) 的输入 x;再生成 U(E,H)、W(H,H),隐藏维度 H 先取 3。手写路径与框架路径必须共用同一组 U、W 和同一份 x,否则比较的是两次不同的随机初始化,对齐无从谈起;种子固定后,输入、U、W 每次运行都相同,三条断言的结论才可复现,换一台机器重跑前也先对齐种子与依赖版本。
  2. 手写前向。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)。
  3. 框架对齐。建 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() 里,避免被记进计算图。
  4. 写三条断言。①手写输出与 y 逐元素比;②手写末态与 h_n 逐元素比;③验证 y[:, -1] 与 h_n 相等——这条是理解「输出序列的最后一片=最终摘要」的钥匙。容差统一用 atol=1e-5;若想更严格,可以再加上 rtol=0,避免数值大的位置被相对误差放行。哪条为 False,先按「权重是否转置 → batch_first 是否漏写 → h_0 是否随机 → 框架是否带 bias」四步排查,而不是先怀疑公式。
  5. 机制验证与迁移。把 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 挡在梯度之外。

  1. 构造错位目标。用自包含的字符反转任务练手(输入「我爱中国」、期望输出「国中爱我」):每条序列加起始符、结束符并按 max_len 补 PAD。取 tgt[:-1] 作解码器输入(以起始符开头),tgt[1:] 作监督目标(以结束符收尾);对齐之后,第 t 步输入是 y_{t-1}、要预测的正好是 y_t,模型没有机会偷看答案。反转任务的好处是答案确定、无需外部语料:只要模型学会把序列倒过来写,就说明编码器确实把顺序信息读进去了。补 PAD 时注意别把结束符截掉:max_len 要留足长度,否则结束符被砍掉,模型永远学不会停。
  2. 编码器读成上下文。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 在这一版里根本不用——这与序列标注要取每个位置输出正好相反。
  3. 训练前向(教师强制)。解码器首步输入起始符(<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、每步重新抽,而不是整轮训练固定成一个值,否则「混合」就退化成全程二选一。
  4. 推理(贪心自回归)。从起始符与 C 出发,每步只喂「上一个词 + 上一步 hidden」,argmax 取词接到结果列表;遇到结束符(<EOS>)就停,同时用 max_len 兜底,一次只解一条样本——推理循环里不该出现 batch 维扩展,否则形状容易广播错乱。贪心是「每步取最大概率」,局部最优可能让整句走偏;想更稳可以换成保留 k 条候选的束搜索,想有多样性可以换成温度采样。停止条件写成「先判 EOS、再判长度」,并把 EOS 本身排除在结果之外。
  5. 对照与拓展。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),层与层之间不共享;只有同一层内部沿时间共享。

公式

h_t^(1) = tanh(U^(1)·x_t + W^(1)·h_{t-1}^(1));h_t^(l) = tanh(U^(l)·h_t^(l-1) + W^(l)·h_{t-1}^(l)),l ≥ 2。

生活类比像公司层层汇报:一线记原始工单,主管汇总成日报,经理再提炼成结论。中间任何一层漏记关键信息,最上面的结论就会失真。
易错层数不是越多越好:梯度要同时穿过「垂直的 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_,逐元素截断、会改变方向,一般不如按范数裁剪(补充)。

公式

||g||₂ = √(Σ_i g_i²);若 ||g||₂ > θ,则 g ← g × θ / ||g||₂。

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)。

公式

c_t = f_t ⊙ c_{t-1} + i_t ⊙ c̃_t;h_t = o_t ⊙ tanh(c_t);f_t、i_t、o_t ∈ (0, 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 更划算,参数少,小数据上过拟合风险也低一些(补充)。

对比项LSTMGRU
门数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 = BP × exp(Σ_{n=1}^{4} w_n·log p_n),w_n = 1/4;p_n = 命中的 n-gram 数 / 候选的 n-gram 总数;BP = min(1, exp(1 − r/c)),c 为候选长度、r 为参考长度。

易错只报 BLEU 不报参考译文与分词口径,分数没有可比性;同义改写还会吃亏——意思对但 n-gram 不重合,得分照样低。所以工程上常同时看人工评估或多个指标(补充)。
10 秒自测 · 点开看答案

问题:BLEU 只看 precision,为什么还要乘 BP?

答案:否则译文越短越容易拿高分(写一个全命中的词即可);BP 用来惩罚比参考译文短的候选。

概念 KP 06.30

从 Seq2Seq 到注意力:瓶颈是怎么被绕过去的(补充)

一句话

不再只递一个定长 C,而是每写一个词就回头翻一次原文。

Seq2Seq 把整句压进一个定长 C,解码每一步用的都是同一个 C,于是有两个毛病:句子一长,开头信息就被挤掉;生成任何词时,都无法「重点看」输入的对应部分。注意力(Attention)的改法很直接:解码器每一步拿当前状态与编码器每个位置的输出算一个匹配分数,softmax 成权重,再对编码器输出加权求和,得到随解码步变化的上下文 c_t。

这样解码器不再只依赖一次性的 C,而是每写一个词就动态回看一遍原文。把「解码器查编码器」推广成「序列内部自己查自己」,就是第 7 章的自注意力(Self-Attention)。

公式

e_{t,i} = score(s_{t-1}, h_i);α_{t,i} = softmax_i(e_{t,i});c_t = Σ_i α_{t,i}·h_i,再与 s_{t-1} 一起预测 y_t。

三条好处① 绕过定长瓶颈:信息留在编码器各步,不必全塞进 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 来自编码器输出;权重矩阵是「目标长度 × 源长度」的长方形,只出现在解码器里。

公式

CrossAttn(Q, K, V) = softmax(QKᵀ / √d_k)·V: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-onlyROUGE
对话多轮上下文 → 一句回复Decoder-only人工 / 任务成功率
语音识别声学帧串 → 文字CTC / RNN-T / 注意力编解码WER / CER
易错先问「对齐吗、长度知道吗」再选结构:给翻译只喂单侧池化向量、给序列标注只取最后一步,都会把任务做残。另一个坑是用逐 token accuracy 评估标注或语音——大量 O 标签和空白帧会把分数刷得很高,必须换成实体级 F1 或 WER。
公式 KP 06.33

训练稳定性:学习率、梯度裁剪、batch size、序列长度(补充)

一句话

四个旋钮互相牵制,只拧一个,通常会把另一个拧坏。

RNN 的训练稳定性被四个量绑在一起。学习率太大,BPTT 连乘出的梯度会一步把权重带飞;太小又收敛不动。梯度裁剪把总范数封顶(常用 1~5),只防爆炸、不治消失。batch size 越大,梯度噪声越小、吞吐越高,但激活显存按 batch 线性上涨,学习率通常也要同步调大(线性缩放法则,补充)。序列长度决定回传步数:长度翻倍,计算、显存和连乘项数都翻倍,长依赖更容易衰减。

旋钮调大之后主要代价经验做法
学习率收敛更快,过大直接发散震荡、出现 NaN1e-3 起手,配 warmup
裁剪阈值梯度更少被截断尖峰失控、一步走飞先打印总范数再定值
batch size吞吐高、梯度更稳激活显存涨,泛化或变差同步调大 lr,别只加 batch
序列长度覆盖更长的依赖显存、计算、回传步数线性涨超长序列用截断 BPTT
公式

激活显存 ∝ batch × 序列长度 × hidden;线性缩放:batch 变为 k 倍时,lr 大致也乘 k(补充)。

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。

07
TRANSFORMER

Transformer:从注意力到大模型

把"必须按顺序读"这条锁链砍断,于是有了 BERT、GPT 和今天的大模型。

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 = f(h₁, h₂, …, hₙ),c 的长度固定为 d,与 n 无关

易错把 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/CNNRNN/CNN自注意力
Decoder 内部RNN/CNNRNN/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 亿个数,这就是"长上下文吃显存"的根源。

每层结构计算量顺序操作数最大路径长度
RNNO(n·d²)O(n)O(n)
CNNO(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);下午再碰一次,再各自回去改。若先闷头写一周再开会,写出来的东西根本对不上——这就是注意力必须在前的原因。
公式

y = LayerNorm(x + Sublayer(x)),Sublayer 为注意力或 FFN

10 秒自测 · 点开看答案

问题:把 FFN 与注意力的顺序对调,模型还能正常训练吗?

答案:能跑,但性能明显下降。"先交流后消化"是被论文和后续实验验证过的结构,反了等于让每个词先闷头加工,再去对齐上下文。

概念KP 07.7

为什么每个子层都要 Add & Norm?

一句话

残差保留"原稿"让梯度直通,LayerNorm 稳住尺度让深层网络训得动。

残差连接(Residual Connection,图中标 Add):把子层的输入 x 直接加到输出上。它有两个好处:一是反向传播时梯度可以沿加法这条"直通车道"流回前面,不必层层穿过乘法;二是子层只需要学"改动量"而不是"完整的新表示",没什么可改就输出 0,信息原样通过。

层归一化(Layer Normalization,图中标 Norm):把每个位置上的 512 维向量减掉自己的均值、除以自己的标准差,再用可学习的 γ、β 缩放平移。同一个 token 自己归一化,与批次里其他句子无关。不用 BatchNorm 的理由很实在:① 文本长度不一,按 batch 统计会抖;② 长序列塞不下几个,batch 常常很小,统计不准;③ 推理时只有一条输入,没有 batch 可统计。

生活类比领导让你改方案,笨办法是重写一份,写崩了原稿也没了;聪明做法是开"修订模式",原稿始终在,你只标修改痕迹,成稿 = 原稿 + 修改。LayerNorm 则像只看小明一个人的六科成绩做标准化——来几个考生都无所谓,每人自成一套标准。
公式

LayerNorm(x) = γ ⊙ (x − μ) / √(σ² + ε) + β,μ、σ 按单个 token 的 d 维统计

易错把 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 位发言",你还得知道自己在哪,所以工牌上再印一行座位号(位置编码)。两样信息印在同一张卡上,一眼看完,而不是挂两块牌子。
公式

X = Embedding(token) × √d_model + PE(pos)

# 输入三步:查词表 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 对"针"叠出几乎不重复的位置指纹。
公式

PE(pos, 2i) = sin(pos / 10000^(2i/d)),PE(pos, 2i+1) = cos(pos / 10000^(2i/d))

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 相当于改成"以小区大门为原点、按方向和距离定位",后面再盖多少栋,坐标系都成立。
公式

q′ = R(pos·θ) q,k′ = R(pos′·θ) k,q′ᵀk′ 只依赖 pos − pos′

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)。先用标签匹配决定"要不要抽这本书",再读正文决定"学到了什么"。
公式

Attention(Q, K, V) = softmax(QKᵀ / √d_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 成比例,行和为 10.56、0.44
④ 加权求和权重 × V,逐元素相加得 Z0.56·V₁ + 0.44·V₂
对照不缩放直接 softmax0.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 倍。

公式

Q = XW_Q,K = XW_K,V = XW_V,Z = softmax(QKᵀ/√d_k)V

步骤张量形状(n=4,d=512,h=8)
输入表示X4 × 512
投影得 Q/K/VQ、K、V4 × 512(每个头 4 × 64)
注意力打分QKᵀ/√d_k4 × 4(每个头一张)
加权求和softmax × V4 × 64(每个头)
拼回输出Concat + W_O4 × 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 开销随头数略增)。所以它是用同样的算力、同样的参数,换来了"多视角"。

生活类比一篇学生作文只让语文老师评,他可能只挑错别字和病句;改成八位老师分别评:语文看语法、数学看数据、心理看情绪、班主任看篇幅,最后把八份评语装订成一份综合评语。每人只看一个维度,合起来就全面了。
公式

MultiHead(Q,K,V) = Concat(head₁, …, head₈) W_O,headᵢ = Attention(QW_Qⁱ, KW_Kⁱ, VW_Vⁱ)

# 投影后按“头”切分:先 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 的放大示意)。
多头注意力矩阵形状流转:拆头 → 每个头独立算注意力 → 拼接 → 乘 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,接近一半注意力分给了"未来"。

公式

score(i, j) = −1e9(当 j > i),随后 attn = softmax(score / …)

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。

公式

CrossAttn = softmax(Q_dec K_encᵀ / √d_k) · V_enc

生活类比闭卷部分只能靠脑子(掩码自注意力);开卷部分题目要求"结合课本第 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,但输出仍是"– !",就是训练量不足的典型表现(实测)。

公式

L = −Σ log P(y_t | y₁…y_{t−1}, x),困惑度 PPL = exp(L)

# 训练:目标句右移一位,输入与监督错开一个时间步
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 的很多细节都要从这对不对称出发。
训练与推理两条路径:训练并行看全句,推理逐词自回归。理解 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 倍——宽度比深度更吃显存。

公式

单层参数 ≈ 4d²(注意力)+ 8d²(FFN)= 12d²,d=512 时约 315 万

模块构成参数量
多头注意力4 × (512×512 + 512)1,050,624
前馈网络(512×2048 + 2048) + (2048×512 + 512)2,099,712
2 个 LayerNorm2 × 2 × 5122,048
单层编码器以上合计3,152,384(约 315 万)
单层解码器两个注意力 + FFN + 3 个 LN4,204,032(约 420 万)
6 + 6 层合计——44,138,496
词嵌入(共享)37,000 × 51218,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-onlyBERT双向,看全句理解、分类、抽取
Decoder-onlyGPT、LLaMA因果,只看左边生成、对话、推理
Encoder-DecoderT5、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-LNPost-LN先 LN 再进子层深层训练稳定
RoPE正弦绝对编码旋转 Q/K相对位置与长上下文
GQA/MQA每个头独立 K/V多组头共享 K/V减少 KV Cache 显存
SwiGLUReLU 前馈门控激活前馈同样参数下效果更好
RMSNormLayerNorm只除均方根更省算力
FlashAttention显式 n×n 矩阵分块 IO 感知计算长序列显存与速度
公式

RMSNorm(x) = x / √(mean(x²) + ε) ⊙ γ  SwiGLU(x) = (Swish(xW₁) ⊙ xV)W₂

生活类比一栋 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、广播、内存连续性。提交物是能跑通的输出加思考题回答,其中掩码后右上三角权重最大值与每行权重和必须给出具体数字,只写"运行成功"不算完成。

  1. 读代码:给 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 把输入拉回了什么量级。
  2. 断言归一化:attn_weights.sum(dim=-1) 应全为 1(fp32 下误差在 1e-6 以内),确认 softmax 是沿最后一维做的,每个 (6,6) 矩阵行和为 1。
  3. 断言掩码:构造 6×6 下三角掩码 torch.tril(torch.ones(6,6)).unsqueeze(0).unsqueeze(0),验证三件事:(a) 右上三角权重最大值 0.000e+00,严格为 0;(b) 每行权重和仍为 1;(c) 第 3 个位置(索引 2)只有 3 个非零权重。
  4. 对照实验:去掉掩码重算一次,记录右上三角最大权重 4.804e-01,并解释它为什么不可能为 0——softmax 对包括"未来"在内的所有位置归一化,未来位置分到了真实的概率质量。
  5. 切法验证:把 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、置换等变。提交物是手算过程(别人能照着复核)与三组对照的差异值,而不是一张"跑通"的截图。

  1. 手算对照:按 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)。
  2. 置换等变(不加 PE):按 [3,1,0,4,2] 打乱 5 个位置的输入,记录纯自注意力打乱前后的输出差异,实测 5.960e-08——这只是浮点噪声,说明自注意力对顺序完全无感。
  3. 置换等变(加 PE):用同样的顺序打乱输入、但不打乱 PE,记录差异跳到 7.067e-02,与上一步跨了六个数量级;再把 PE 也按同样顺序一起打乱,差异应回到 1e-8 量级,这一步排除了"注意力结构本身隐含位置信息"的替代解释。
  4. FFN 独立性:构造一个 batch,除第 3 个位置外其余位置完全相同,验证 FFN 在第 0 个位置的输出完全一致——差异应为严格的 0(不是 1e-8 量级),因为 FFN 对每个位置单独作用,位置之间的信息交换全部由注意力负责。
  5. 宽度消融:把 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,三者都必须能和理论值对上。

  1. 跑通前向:构造随机 batch(B=4、T_src=20、T_tgt=19),确认 logits 形状 (4,19,1656)、模型总可训练参数 7,039,864,并把 src、tgt、enc_output、dec_output、logits 五个形状依次记进实验记录。
  2. 三段 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。填完后与实验记录里的三段表逐格核对——写错一格的典型后果,是交叉注意力静默退化成自注意力。
  3. 基准线对照:随机初始化、未训练时跑一次前向,单步 loss 应接近"均匀瞎猜"的理论值 ln(1656)=7.4122,实测 7.5141,只高 0.1——说明初始化正常、输出层没有实现错误。反过来用这个检查更快:若第一次前向 loss 是 2.0 左右,查 tgt 是否没右移或掩码没加;若是 15.0,查 logits 是否被错误缩放。
  4. 因果掩码消融:把 tgt_mask 改成 None 训练 5 轮,观察 loss 是否异常低(解码器能直接看到未来、等于偷看答案),再推理看输出是否崩坏——这是"训练时完美、推理时崩"的典型形态。
  5. 参数量核算与权重绑定:逐项核对单层编码器 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 率——数字必须来自实测,不能照抄手册。

  1. 跑分词器:记录 "The Wanderer"、"First Part"、"It was a bright cold day in April" 三条的 ids 与回译结果。前两条往返只差大小写;第三条里 bright 与 april 变成 <unk>(id=3),因为它们是语料外的词——这说明"OOV=0.00%"只对训练语料本身成立。
  2. 数据体检:统计这批 200 条句对的平均词数、最长词数、被 max_len=20 截断的比例。实测英文平均 21.27 词、最长 119 词,92 条被截断(46.0%);法文平均 20.80 词、最长 113 词,84 条被截断(42.0%);同源测试下 OOV 英法都是 0.00%。平均句长已经超过上限,近一半句子被切掉尾巴,把平均词数、最长词数、截断率三个数写进记录,作为后续所有改动的对照基线。
  3. 截断埋雷:构造一个 25 词的句子,验证 <eos> 是否还在序列里。实测长度 20、末位 id 1043、eos id=2 不在序列里;把 encode 改成保留首尾 ids[:1] + ids[1:max_len-1] + ids[-1:],重跑确认 eos 是否保留由 False 变为 True。
  4. 移位造 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),监督序列比输入序列少一位。
  5. 查 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 与两个样本的预测,再加四原因诊断——只写"运行成功"同样不算完成。

  1. 完整跑一遍:记录 5 轮平均 loss 与两个测试样本的预测,与手册表格对照。配置为 Adam、lr=1e-3、batch=4、5 轮共 250 步,纯 CPU 全程约 41 秒。
  2. loss 解读:把每轮 loss 换算成困惑度 exp(loss),说明第 5 轮"平均还有约 29 个候选词分不清";同时以 ln(1656)=7.4122 作为"均匀瞎猜"基准线——第一轮 6.7113 已经低于它,说明模型确实在学,而不是没动。
  3. 自回归解码:从 <sos> 起循环,每步把已生成序列重新喂回解码器,只取最后一位 logits 的 argmax,遇 <eos> 或达到上限就退出;同时记录每步耗时,理解"为什么每生成一个词都要重算整段目标序列"——以及没有 KV Cache 时,这一步为什么省不掉。另记两点解读:两个样本输出相同并不奇怪,它们都很短、都含生僻词,欠拟合的模型倾向输出高频标点;第 2 条的目标值是人名本身,模型连"照抄人名"都没学会,进一步印证是训练量问题而不是结构问题。
  4. 训练量消融(收益最高):epoch 从 5 改成 20、数据从 train[:200] 改成 train[:1000](可同时把 max_len 提到 50),再观察 loss 与输出是否出现真实法语词——这是本册最值得做的一个任务。
  5. 诊断输出:先记录贪心与束搜索(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 倍——这就是长上下文又慢又吃显存的根。

序列长度 nn×n 个数单头 fp16相对 n=2048
512262,1440.5 MB1/16
1,0241,048,5762 MB1/4
2,0484,194,3048 MB1
8,19267,108,864128 MB16
128K17,179,869,18432 GB4,096
公式

QKᵀ:n²·d_k 次乘加 → n×n 矩阵;n=2048、d_k=64 时为 4,194,304 个数 = 2.68 亿次乘加(单头单层)

易错把 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 圈都不到。
公式

PE(pos)ᵀ·PE(pos+k) = Σᵢ cos(k / 10000^(2i/d)),结果只含 k,与 pos 无关

易错把热力图的横轴当成时间。横轴是维度索引、纵轴是序列位置 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(补充)。

公式

Post-LN:y = LN(x + Sublayer(x))  Pre-LN:y = x + Sublayer(LN(x))

易错以为 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 的梯度尖峰(补充)。

公式

lr = d_model^(−0.5) · min(step^(−0.5), step · warmup^(−1.5)),原论文 warmup=4000 步

易错以为 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嵌入分解 + 跨层参数共享 + SOPbase 约 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-1201812 / 7681.17 亿预训练 + 下游微调
GPT-2201948 / 160015.4 亿零样本提示
GPT-3202096 / 122881750 亿少样本上下文学习
易错把"零样本"理解成"不需要数据":预训练仍要海量无标注文本,零样本只是下游任务不再给标注样本;真正付出的是预训练成本,不是省掉了数据。
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 算力小)。医院可以铺得很大,单次看病的成本却不由科室总数决定。
公式

y = Σᵢ gᵢ(x)·FFNᵢ(x),i ∈ TopK(g(x)),g = softmax(TopK(W_g·x))

易错以为 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 ≈ 2 × L × n_kv_heads × d_head × seq_len × batch × bytes;LLaMA-2 7B 每 token ≈ 512 KB

易错把 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 等改进。

公式

位置插值:pos′ = pos/s  NTK-aware:b′ = b·s^(d/(d−2)),b=10000,d 为每头维度

易错把"公式能算出第 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 + v8 B约 56 GB否
激活值视结构而定单条 2048 token 约 8.6 GB(示例)是
公式

训练显存 ≈ 16 B × N_params + 激活值;7B → 16 × 7×10⁹ ≈ 112 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 同时训练图像塔与文本塔:同一对图文互相靠近、错误配对推远,学好后把类别名写成提示句,用相似度就能零样本分类。

公式

零样本分类:ŷ = argmax_k cos(f_img(I), f_txt(「a photo of a {类别 k}」));训练用对称 InfoNCE,同批 N 对图文里正样本 1 个、负样本 N−1 个。

易错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 CacheDecode重复计算显存随长度 × batch 涨
连续批处理DecodeGPU 空转调度复杂、尾延迟
量化两段都受益带宽与显存精度损失、要校准
FlashAttentionPrefill / 训练HBM 读写长序列收益才大
公式

Decode 单步时间下限 ≈ 每步要读的字节数 ÷ 显存带宽;吞吐上限 ≈ 带宽 ÷ 每 token 读取字节数 × batch。

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)是模型真正用上的算力比例,常见只有三到五成,拿峰值直接估会乐观两三倍。再乘单卡时价,就是训练账单。

公式

C_train ≈ 6ND;时间 ≈ C_train ÷ (峰值 FLOPS × MFU);成本 ≈ 卡时 × 单卡时价;推理约 2N FLOPs/token。

示例估算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)。

08
ASCEND AI & CANN

昇腾 AI 与 CANN:算力是怎么被用起来的

芯片出算力,CANN 出效率,框架出开发效率,应用使能出行业方案——这一章把整条链路串起来。

前面几章学的是"模型怎么算",这一章回答"算力从哪来、又怎么被用起来":先看 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 亿参数能力上限与训练难度
公式

训练算力需求 ≈ 6 × 参数量 × 训练 token 数(补充:业界常用估算口径,仅用于建立数量级直觉)

生活类比算力是发动机、数据是燃料、模型是图纸——三样凑齐车才跑得起来。少一样,再好的图纸也只是图纸。
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、芯片与硬件自下而上贯通。
昇腾 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 系列硬件:数据中心训练 / 推理与智能边缘产品覆盖全场景。
昇腾 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 Lib1400+ 高性能算子标准件仓库
HCCL多卡集合通信(AllReduce 等)对讲机加汇总员
Ascend C / 毕昇自定义算子开发与编译自己造零件再翻译成图纸
Driver与硬件直接交互,npu-smi 入口地基与水电
记忆技巧先记一条竖线"框架 → 图 → 接口 → 运行时 → 驱动",再记三条横线"算子库、通信库、视觉预处理"。竖线是主干,横线是挂上去的工具。
CANN 软件架构:向上对接框架,向下使能昇腾硬件,中间由图引擎、算子库、通信库、运行时等组成。
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 图模式
通信库HCCLNCCL
编译器毕昇 BishengNVCC
图引擎GETensorRT
性能分析msprof / MindStudio InsightNsight
记忆技巧两边结构一一对应,概念相通、名字不同:熟悉 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 应用开发流程:

  1. 数据采集:拿到原始数据。
  2. 数据处理:筛选、打标签、做特征工程。
  3. 模型训练:编码实现算法,训练模型。
  4. 精度评估:看是否满足精度要求。
  5. 部署上线:把达标的模型部署到生产环境。

"一站式"的含义是:这五步原本要自己找存储、租机器、配环境、搭流水线,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 这类规整三维块。所以比"核数"没有意义,要比峰值算力、显存带宽、显存容量、互联带宽四个硬指标。

公式

CPU:16×16×16×2 = 8192 周期;Vector:16×16 = 256 周期;Cube:1 周期(FP16 单周期 4096 次乘加)

10 秒自测 · 点开看答案

问题:逐元素加法(如 x + y)由哪个单元执行?Cube 主要干什么?

答案:逐元素加法走 Vector 向量单元;Cube 专做矩阵乘、卷积这类规整的矩阵运算。

NPU 内部结构示意:AI Core 与存储、控制单元协同工作。
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 到底走了多少道门:

  1. torch_npu:.npu() 把张量从 Host 内存搬到 Device 内存。
  2. 框架适配:torch.matmul 被映射成 CANN 的 MatMul 算子。
  3. GE 图引擎:算子入图,做融合、内存复用、流水优化。
  4. 毕昇编译器:把优化后的算子编译成 NPU 可执行的 Kernel 指令。
  5. Runtime:分配 Device 内存、创建 Stream,把任务下发到队列。
  6. Driver:通过驱动把指令送到 NPU 硬件。
  7. 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+ 与 +AIAI+ 探索 AI 能力;+AI 千行百业场景化落地
全栈全栈的定义芯片、芯片使能、训练与推理框架、应用使能
全栈全场景的定义公有云、私有云、边缘计算、物联网终端、消费终端
产品训练产品Atlas 800T A2 训练服务器、Atlas 900 A2 PoD 集群
产品推理产品Atlas 800I A2、300I Duo/Pro、300V Pro、500 A2
产品开发者产品Atlas 200I DK A2 开发者套件
DeepSeekV3 与 R1V3 是 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 与 CUDAGE↔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 的对应关系(补充)。

配套链

驱动 / 固件 → CANN 版本 → torch_npu 版本 → PyTorch 版本;示例:torch_npu 2.1.0.post3 ↔ PyTorch 2.1.0

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
msprofCANN / 解析主机侧与设备侧埋点、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 把每张卡各持一段的数据拼成全份发给每张卡,张量并行里拼回完整权重靠它。多卡训练"扩卡不加速",八成就卡在通信等待上。

示例

2 卡 AllReduce(SUM):卡 0 持 [1,2,3]、卡 1 持 [4,5,6] → 两卡都变成 [5,7,9]

操作一句话语义典型用途
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 才是有效算力。

换算

1 PFLOPS = 1000 TFLOPS = 10¹⁵ FLOPS;1 次乘加(MAC)= 2 次操作(FLOPs)

指标常见口径读表先问
TOPSINT8 推理是 INT8 还是 INT4?含不含稀疏?
TFLOPSFP16 / 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 实践手册。

09
NPU PRACTICE

NPU 实践:从 Hello NPU 到 18 个实验

上一章讲 CANN 怎么把框架调用翻译成 NPU 指令,这一章把代码真正放到卡上跑,并学会判断"这次上 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。

命名规则

whl 名 = 包名 - 版本 + cu版本 - cpPython版本 - 平台.whl;四段必须同时匹配

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 只能构造链路——这是环境限制,不是代码写错,实验报告里要如实标注。

生活类比云镜像像"带家具的出租公寓":拎包入住,厨房、网络都配好;本机从零装驱动则像毛坯房,省钱,但装修周期长、还容易装错。
项目课程实测参考说明
Python3.9与 torch_npu 的 cp 版本需匹配
PyTorch2.1.0NPU 环境需与 torch_npu、CANN 配套
torch_npu2.1.0.post3注册 npu 后端,提供 .npu() 等接口
CANN8.0版本需与驱动、torch_npu 匹配
NPUAscend910ProA(单卡)以 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 而不是 ==;只有纯数据搬运(不涉及浮点运算)才用完全相等验证。单次测量噪声大,性能测试还要重复多次取平均,并在报告里写清重复次数与预热次数。

公式

加速比 = T_CPU ÷ T_NPU;allclose 判定:|a − b| ≤ atol + rtol × |b|

生活类比测百米成绩:发令前要等上一组清场(前置同步),自己先热身(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/6 FLOPs/Byte

负载FLOPs访存 Bytes算术强度瓶颈
矩阵乘 N=1282N³ ≈ 4M3N²×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"的完整流程。这是后面所有实验的地基。

  1. 导入 PyTorch 与 torch_npu;后者负责把 NPU 后端注册进 PyTorch,缺这一行后面 .npu() 全部失败。
  2. 检查 NPU 是否可用;若不可用,先查驱动、CANN 环境变量与设备挂载,不要带着问题往下跑。
  3. 打印 NPU 是否可用、设备名、当前设备编号与可见卡数,确认识别到的是正确硬件。
  4. 在 CPU 上创建两个各含三个浮点数的一维张量,搬到 NPU 做加法,再把结果搬回 CPU。
  5. 打印输入与结果,并验证结果等于 [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 创建 → 搬入 → 设备计算 → 搬回 → 验证"的完整链路,并养成三重验证的习惯。

  1. 在 CPU 上创建两个形状 (1000,)、dtype 为 float32 的张量,分别全填充 2.0 与 3.0(用 torch.full 一次填满,比 ones() * 2 少一个算子)。
  2. 分别 .npu() 搬到设备;在 NPU 上执行 x * x + y 得到 z,并查看 z 的设备信息。
  3. 把 z 搬回 CPU;构造同样全为 7.0 的期望张量,用 torch.allclose 做数值比较。
  4. 额外检查形状是否为 (1000,)、dtype 是否为 torch.float32,凑齐形状、类型、数值三重验证。
  5. 必做变体:把长度改成 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 体验"精度换速度"。

  1. 固定随机种子,对 128、512、2048 三种规模分别创建两个随机 FP32 方阵。
  2. CPU 侧执行矩阵乘并计时,作为基准。
  3. 把两个矩阵搬到 NPU;搬运完成后先 torch.npu.synchronize() 排空搬运任务,再开始计时。
  4. 执行矩阵乘,再次同步等待计算真正结束,停止计时;结果搬回 CPU 与基准做带容差比较。
  5. 打印每种规模的 CPU 耗时、NPU 耗时、加速比与一致性;每轮结束释放张量,降低显存压力。
  6. 选做:在规模 2048 下重复计算 20 次,对比 CPU FP32 基准、NPU FP32、NPU FP16;NPU 部分先预热 3 次排除首次算子编译;最后同时看耗时、加速比与和 CPU 结果的最大绝对差异。
规模 NCPU 耗时NPU 耗时加速比结果一致
1280.51 ms0.23 ms2.2×✓
5121.32 ms0.21 ms6.3×✓
2048128.16 ms0.44 ms289.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 启动"的固定开销,以及批量接口为什么能把它省掉。

  1. 固定矩阵维度为 256,构造批量随机 FP32 张量。
  2. 对批量数 8、32、128,分别用 torch.bmm 与 for 循环加 torch.stack 完成相同的批量矩阵乘。
  3. 两种方式各预热一次并同步;计时前后都同步,每种方式重复 20 次取平均。
  4. 用带容差方式验证两者结果一致,打印耗时表与加速比。
  5. 必做思考:解释为什么批量数越大,批量接口的加速比越高。
批量 Bbmm 耗时循环耗时加速比结果一致
80.04 ms0.55 ms12.5×✓
320.20 ms1.98 ms45.3×✓
1280.07 ms7.71 ms107.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. 读取图片,转成 [1, 3, H, W] 的 FP32 张量:permute(2, 0, 1) 通道前置、unsqueeze(0) 加批量维、除以 255 归一化到 0~1。
  2. 构造归一化的 5×5 高斯核:一维权重外积成二维核,再沿通道复制成 [3, 1, 5, 5] 三组。
  3. 在 CPU 上执行分组卷积:groups=3(三个颜色通道各自卷积)、padding=2(保持 512×512 尺寸),并计时。
  4. NPU 侧把图像和卷积核搬过去,同步后计时,计算后再同步,最后把结果搬回 CPU。
  5. 打印 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

实验目的:三个实验从三个侧面回答同一个问题——搬运有多贵、批量能不能摊薄固定开销、少算是不是就等于快。

  1. 实验 5:分别创建 1 MiB、16 MiB、64 MiB 的 FP32 一维张量,按字节数反推元素个数。
  2. 实验 5:先搬一次做预热并建立搬运路径;同步后开始计时,重复多次搬入取平均;同样方法测搬回耗时。
  3. 实验 5:用"字节数 ÷ 平均耗时"计算 Host → Device 有效带宽(GB/s),注意 MiB 是二进制单位、GB/s 是十进制单位,换算别混。
  4. 实验 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 量级。批量越大、单次计算越小,这笔开销占比越高。

五个关键结论(来自手册的实验总结):

  1. 设备搬运:搬入才能计算,中间结果尽量留在 Device 上,减少往返。
  2. 异步计时:计时前后都要同步;性能测试还要预热并多次取平均。
  3. 数值验证:不同设备浮点累加顺序不同,用容差比较;只有纯搬运才用完全相等。
  4. 批量计算:批量接口减少调度与 Kernel 启动次数,适合大量小矩阵或批量图像。
  5. 性能本质:加速比不是固定数字;减少计算量不等于减少耗时。

实验 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 万参数),重点不在刷精度指标,而在把设备、缩放器、上下文三个部件按正确顺序串起来。

  1. 搭三层小网络:1024 维输入映射到 512 维,接 ReLU,再映射到 10 类输出;把整个模型搬到 npu:0,优化器选 Adam、学习率 1e-3,损失用交叉熵。
  2. 用 torch_npu.npu.amp.GradScaler() 创建昇腾专属缩放器——注意不要误用 CUDA 版本的实现。
  3. 数据直接在 NPU 上生成:torch.randn(64, 1024, device='npu:0') 加 64 个取值 0–9 的标签,省掉一次主机到设备的拷贝。
  4. 在 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 决定走哪套通信库。

  1. 配置会合参数:MASTER_ADDR='127.0.0.1'、MASTER_PORT=29500,这是单机多卡的示例;正式多机环境要换成真实主节点地址。
  2. 导入分布式模块与昇腾适配插件,先用 dist.is_initialized() 判断进程组是否已初始化,避免在 Notebook 中重复初始化报错;若未初始化则打印正在初始化 HCCL 后端的提示。
  3. 调用 torch.npu.set_device(0) 把当前进程绑定到 0 号卡,再创建含 2.0、4.0、6.0 三个元素的测试张量,用 .cpu().tolist() 搬回主机打印,作为通信前基线。
  4. 在代码中预留 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 活动看算子执行与等待间隙,两者对照才能判断是"算得慢"还是"等得久"。

  1. 在 npu:0 创建两个 4096×4096 的 FP16 矩阵,作为待测矩阵乘的输入。
  2. 预热设备:连续执行 3 次矩阵乘并 torch.npu.synchronize(),把编译与初始化开销排除在采样区间之外。
  3. 配置采集器:activities 同时开启 CPU 与 NPU 两类活动,打开 record_shapes=True 与 profile_memory=True,关闭堆栈采集 with_stack=False 以控制体积,并用 on_trace_ready=torch_npu.profiler.tensorboard_trace_handler("./npu_profile_results") 指定输出目录。
  4. 用采集器包住 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 的键做加权,等价于把注意力矩阵的上三角遮掉。

  1. 设定多头参数:batch=2、num_heads=16、seq_len=2048、head_dim=64,贴近大模型推理场景。
  2. 在 npu:0 生成查询、键、值三个 FP16 张量,形状均为 (2, 16, 2048, 64),打印形状确认。
  3. 进入 torch_npu.npu.amp.autocast(enabled=True) 上下文,调用 F.scaled_dot_product_attention(q, k, v, is_causal=True),让因果掩码生效——每个位置只能看到自身及之前的位置,符合大语言模型解码语义。
  4. 调用 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——第一条流记录完成标记,第二条流等待该标记,否则会读到尚未写完成的结果。把有依赖的两次计算分到两条流,目的不是让它们真并行,而是给无依赖的搬运与计算留出交错空间。

  1. 在 0 号卡上创建两条独立的 NPU Stream(stream1、stream2),相当于开辟两条任务流水线。
  2. 准备 3 个 2048×2048 的 FP16 矩阵 a、b、c,作为两次矩阵乘的输入。
  3. 在 stream1 的上下文里执行 out1 = torch.matmul(a, b),并在该流内创建 Event、调用 event1.record(stream1) 打完成标记——Event 必须记录在生产数据的那条流上。
  4. 切到 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,正是它的舒适区。

  1. 先探测可用后端:运行 torch._dynamo.list_backends() 打印当前环境支持的全部编译后端;本次实测列表中包含 npu,另有 cudagraphs、inductor、onnxrt、openxla、tvm 等,确认 npu 存在再继续。
  2. 定义三步复合函数:矩阵乘 → 加一个张量 → ReLU 激活,多算子串联更容易触发图融合。
  3. 在 npu:0 创建 3 个 1024×1024 的 FP16 张量作为输入。
  4. 用 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 让主机提交搬运指令后立即返回,计算任务在同一个队列里自动排队等待数据到达。主机提交搬运后立刻打印提示,是成本最低的"是否阻塞"探针;更严格的对比要另写循环,分别统计锁页与分页两种路径的平均耗时。

  1. 在 CPU 侧创建两个 4096×4096 的张量,开启 pin_memory=True,为高带宽搬运做准备。
  2. 用 .to(device, non_blocking=True) 把两个张量搬到 npu:0;主机只提交指令,不等待拷贝结束。
  3. 紧接着在主机侧打印后续提示;若立刻返回,说明主机没有卡在拷贝上,这是异步生效的直观证据。
  4. 在 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 后端则是兜底;先探测再降级,没有独立包的机器也能跑通同一段代码。

  1. 探测并加载图后端:先尝试 import torchair as tng 并调用 tng.get_npu_backend();若环境未安装该独立包,则自动降级到标准的 npu 后端。本次实测成功加载 torchair。
  2. 复用实验六的三步复合函数(矩阵乘 → 加 → ReLU),在 npu:0 创建 3 个 1024×1024 的 FP16 张量。
  3. 把探测到的后端传给 torch.compile 完成编译包装,并打印正在编译的提示;第一次调用触发图捕获与 GE 优化,同步后打印输出形状,作为编译成功的判据。
  4. 用同样的输入再调用一次,直接复用已编译的优化图并打印形状,验证稳定性;若要真正验证动态形状,需另取不同批次或不同序列长度的输入再执行,观察是否复用同一张图、是否避免重新编译。
预期结果

本次实测输出后端加载成功提示、编译提示,以及第一次、第二次执行成功与各形状,两次形状均为 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 字节),正好对应本实验观测到的增量。四次读数正好对应"申请—占用—释放引用—清缓存"四个动作,报告里要把读数与动作一一对应。

  1. 先调用 torch.npu.empty_cache(),打印 memory_allocated 作为本次观测的起点(基线)。
  2. 在 npu:0 创建一个 8192×8192 的单精度矩阵,对应约 256 MiB 的设备内存。
  3. 打印创建后的已分配显存,以及 max_memory_allocated 历史峰值统计;峰值用于评估是否会触发显存溢出。
  4. 删除该大矩阵的 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 由当次输入现算,适合激活值分布逐批变化的大模型推理。

  1. 按 batch=4、seq_len=512、hidden_dim=4096 的形状,在 npu:0 创建 FP16 输入张量,模拟大模型一层的激活输出;打印原始数据类型与形状作为量化前基线。
  2. 用异常保护包住整个量化过程,先检查昇腾适配插件是否挂载动态量化算子的顶级接口:hasattr(torch_npu, 'npu_dynamic_quant')。
  3. 分支一(接口存在):调用 torch_npu.npu_dynamic_quant(input_tensor) 完成 FP16 到 INT8 的动态量化,打印量化输出的形状、数据类型以及缩放因子的形状。
  4. 分支二(接口不存在):打印降级提示,改用通用逐张量量化 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 实验手册的实验总结,对应到本章实验):

  1. 设备搬运:能在 Device 上算的就别搬回 Host,中间结果尽量留在 NPU 继续算(实验四、五)。
  2. 异步计时:NPU 异步执行,取结果、计时前必须同步;性能测试先预热、多次取平均,否则测到的只是任务下发时间或首次编译开销(实验三、六、七、八)。
  3. 数值验证:跨设备浮点累加顺序不同,用带容差的比较;只有纯搬运才用完全相等验证(实验一、四、九)。
  4. 批量与融合:批量接口、融合算子能减少调度与 Kernel 启动次数,尤其适合大量小算子(实验四、五、六)。
  5. 性能本质:加速比不是固定数字,与算术强度、搬运量、固定开销共同相关;「执行成功」不等于「性能提升」(实验五、六、七、八)。

五条结论也可以压成一句口诀:少搬、同步、对数值、批量融合、别迷信加速比。

验收清单(据指导书附录 C,报告逐条打勾):

  1. 环境自检记录 NPU 可用状态、卡数与型号(本次实测 Ascend910ProA、1 张卡、设备号 0),并据此说明实验二为何只能做单卡模拟。
  2. 十个实验逐个运行,每个实验至少留存输出区截图或文本,标注对应步骤编号。
  3. 每个实验写一条结论:通过 / 部分通过 / 未通过,并给出判据(形状、设备、数据类型、输出文件)。据指导书验收表:实验十未通过(环境限制),实验二部分通过(单卡模拟),实验三、六带告警通过,实验八未覆盖变长输入,其余通过。
  4. 实验三额外提交 trace 结果目录名,并写出从 trace 中观察到的一条算子耗时或利用率结论。
  5. 实验九提交四个显存读数的对照,并解释 256 MB 增量与 8192×8192 FP32 矩阵体积的关系。
  6. 实验十如实写明当前环境的失败原因与已尝试的调整,不得按通过提交。
  7. 不提交代码清单;报告只检查步骤、输出与结论,代码以原 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 官方 set_env.sh → 只对当前进程及子进程生效;新终端要重新 source

易错现象:终端里 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 次、计时前后同步、多次取平均。

公式

加速比 = T_CPU ÷ T_NPU;吞吐量 = 批量数 ÷ T_NPU;时延 = 排队 + 搬运 + 计算;MFU = 实际 FLOPs/s ÷ 峰值 FLOPs/s

指标关注什么什么时候看
加速比同一负载的相对收益单点性能对比
吞吐量单位时间处理量批量处理与服务容量
时延单次端到端耗时实时性要求
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 等用例,看不同数据量下的带宽与时延,参数与路径以官方文档为准。

验算

N 卡时卡 i 初值 = i+1(i = 0…N−1),AllReduce(SUM) 后每卡都应为 Σ(i+1) = N(N+1)/2

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 而失败,要如实记"未通过"。

公式

反量化:x ≈ (q − zero_point) × scale;量化误差上界 ≤ scale ÷ 2(补充)

精度位宽速度(材料口径)误差表现典型场景
FP3232 bit基准 1×最小训练基准、精度敏感推理
FP1616 bit更快(实验 2 选做:耗时更低)最大绝对误差增大混合精度训练、常规推理
INT88 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 版本配套)。

10
LABS & CODE INDEX

实验与代码库

这一章不产生新知识,只解决一个问题:复习时想跑某个实验,能立刻查到它在哪、对应哪个文件、应该看到什么结果。

整学期的实验可以分成五组:词向量 12 个、文本分类 4 个(另 3 个拓展作业)、RNN 与 Seq2Seq 2 个、Transformer 5 个、NPU 基础 8 个 + 进阶 10 个。下面先给总表,再给代码文件、数据集、环境版本与验收要求。

使用方法:复习时先看"实验总表"回忆每个实验验证了什么;忘记代码细节时,按文件名去"代码索引"定位;考前只看每行的"一句话结果",快速串起整门课。

10.1 词向量实验(12 个)

#实验难度文件一句话预期结果
1OneHot 与语义鸿沟★☆☆exp01 / lab01_onehot.py任意两词余弦相似度为 0;V=10⁵ 时单向量 400 KB,10⁶ 词矩阵约 372.5 GB
2窗口共现矩阵★★☆exp02 / lab02_cooccurrence.pyw=2 时得到 6×6 对称矩阵;窗口越大非零元素越多
3共现矩阵 + SVD★★☆exp03 / lab03_svd.py取 k=2,cos(北京,上海) 通常 > 0.85,明显高于跨主题词对
4Word2Vec · Skip-gram★★★exp04 / lab04_skipgram.py损失从约 2.4 降到 1.5–1.7;cos(北京,上海) 约 0.6–0.9
5Word2Vec · CBOW★★★exp05 / lab05_cbow.py样本数约为 Skip-gram 的 1/(2w),单轮更快但低频词略弱
6Skip-gram + 负采样(SGNS)★★★exp06_sgns.py每步只更新 k 个负样本,训练显著加速,损失正常下降
7GloVe★★☆exp07_glove.py用共现矩阵加权最小二乘训练,近义词相似度合理
8FastText★★☆exp08_fasttext.py字符 n-gram 可表达 OOV;未登录词也有向量
9Transformer 词嵌入★★☆exp09_transformer_embedding.py输出上下文相关向量,同一词在不同句子中表示不同
10相似度评估★★☆exp10_eval_similarity.py输出词对余弦相似度表,同类词分数更高
11类比评估★★☆exp11_eval_analogy.py验证 King − Queen ≈ Man − Woman 的向量算术
12下游任务评估★★★exp12_eval_downstream.py把词向量接到文本分类等任务,观察准确率变化

前 5 个实验来自《实验指导书·词向量前 5 个实验》,6–12 为扩展实验;带注释版代码在「代码带注释版」目录。

10.2 文本分类实验(4 个 + 3 个作业)

#实验难度文件一句话预期结果
1TF-IDF + 朴素贝叶斯 / 逻辑回归★☆☆train_tfidf.py输出两组评估;逻辑回归通常略优于朴素贝叶斯
2TextCNN 四分类★★☆train_textcnn.py3 个 epoch 后打印准确率与分类报告,通常高于 TF-IDF 基线
3TextRNN(BiLSTM)四分类★★☆train_textrnn.py3 个 epoch 后与 TextCNN 对比准确率与 F1
4BERT 微调四分类★★★train_bert.py用 bert-base-chinese 微调 2 epoch,输出分类报告
作业 1特征工程与多分类器对比★★☆train_tfidf.py + jieba字级/词级 TF-IDF × NB/LR/SVM/随机森林,用表格比较 Macro-F1
作业 2TextCNN/TextRNN 消融与收敛分析★★★train_textcnn.py / train_textrnn.py画 Loss/Accuracy 曲线、混淆矩阵;对比单双向与层数
作业 3BERT 层冻结与鲁棒性★★★train_bert.py对比全量微调 vs 冻结前 6 层;注入噪声后测准确率跌幅

10.3 RNN、Seq2Seq 与 Transformer 实验(7 个)

#实验难度文件一句话预期结果
1RNN 前向计算与框架对齐★★☆RNN.py手写 NumPy RNN 与 nn.RNN 输出逐元素一致(容差内)
2Seq2Seq 编码器-解码器与教师强制★★★train_seq2seq.py训练损失下降,解码能复现训练目标序列
3缩放点积注意力与多头机制★★☆transformer-test.pymask=None 时注意力每行和为 1;6×6 下三角掩码右上角为 0
4前馈网络与正弦位置编码★★☆transformer-test.pyPE 让打乱顺序的输出发生差异;FFN 各位置独立
5编码器-解码器堆叠与三段注意力★★★transformer-test.py三类注意力形状正确;mask 后解码不偷看未来
6词级分词器与数据流水线体检★★☆train_transformer.py词表、句长分布、batch 形状符合预期
7训练、自回归解码与结果诊断★★★train_transformer.py训练 loss 收敛;贪心/束搜索输出可读,BLEU/准确率可复现

10.4 NPU 基础实验(8 个 + 1 个选做)

#实验难度关键点一句话预期结果
0Hello NPU★☆☆环境自检 + 设备搬运NPU 可用 True,设备名正确;CPU→NPU→CPU 链路跑通
1z = x² + y★☆☆张量创建 / 设备 / 逐元素结果全为 7.0,形状、类型、数值三重验证通过
2CPU vs NPU 矩阵乘法★★☆同步、预热、容差、算术强度128/512/2048 规模加速比约 2.2× / 6.3× / 289.8×(示例)
2 选做FP16 vs FP32★★☆精度换速度FP16 更快但最大绝对误差明显增大
3Batch matmul vs 循环★★★Kernel 启动开销批量 8/32/128 加速比约 12.5× / 45.3× / 107.8×(示例)
4图像高斯模糊★★★分组卷积、算术强度单张图加速比约 0.1×,说明小任务 NPU 不一定更快
5Host ↔ Device 搬运带宽★★☆MiB/GB 换算、往返一致数据越大越接近峰值带宽;往返数据完全一致
6批量图像吞吐量★★★批量摊薄固定开销批量增大后吞吐量上升,加速比改善
7二维卷积 vs 可分离卷积★★★乘加减少 60%输出一致;小图上可分离不一定更快

10.5 CANN + NPU 进阶实验(10 个)

#实验核心 API / 概念一句话预期结果
1混合精度训练与梯度缩放torch_npu.npu.amp.GradScaler / autocast单步训练成功,损失为有限正数(实测约 2.3757)
2多卡分布式与 HCCLinit_process_group(backend='hccl')、AllReduce单卡环境只能构造链路;多卡时梯度正确规约
3profiler 性能剖析activities=[CPU,NPU]、record_shapes、trace_handler生成 npu_profile_results,可用 Insight/TensorBoard 打开
4FlashAttention 融合算子F.scaled_dot_product_attention(is_causal=True)输出形状 (2,16,2048,64),设备仍为 npu:0
5多流并发与 Event 同步torch.npu.Stream / Event.record / waitout2 形状 [2048,2048],依赖链正确
6torch.compile 图模式torch.compile(..., backend='npu')首次编译成功,二次运行复用图,输出形状正确
7异步非阻塞传输pin_memory=True、non_blocking=TrueHost 提交后立即继续,打印不被阻塞
8动态 Shape 编译TorchAir 后端 / 自动降级 'npu'两种形状都能执行;相同形状第二次直接复用
9显存池管理memory_allocated / max_memory_allocated / empty_cache285.38 → 541.38 → 285.38 MB 的缓存曲线(示例)
10动态量化torch_npu.npu_dynamic_quant当前环境未直接支持,演示通用 INT8 兼容方案

10.6 代码索引

文件作用输入输出
utils.py共享数据加载 load_data()data/ 下四个 CSVfull_df + label_map
exp01–exp12词向量 12 个实验corpus.txt / 内置语料矩阵、向量、相似度、日志
lab01–lab05词向量指导书答案代码corpus.txt与指导书预期一致的输出
train_tfidf.pyTF-IDF + NB/LR 文本分类四分类 CSV准确率 + 分类报告
train_textcnn.pyTextCNN 文本分类四分类 CSV3 epoch 训练日志 + 评估
train_textrnn.pyTextRNN(BiLSTM)分类四分类 CSV3 epoch 训练日志 + 评估
train_bert.pyBERT 微调分类四分类 CSV + 预训练模型Trainer 训练/评估日志
RNN.py手写 RNN 与 nn.RNN 对齐随机输入/权重两套实现输出对比
train_rnn_lm.pyRNN 语言模型文本语料困惑度/生成结果
train_seq2seq.pySeq2Seq 训练与解码平行语料损失曲线、翻译输出
transformer-test.py注意力/PE/编解码单元测试构造张量形状断言与数值打印
train_transformer.pyTransformer 英法翻译训练平行语料训练日志、BLEU/解码结果
CANN+NPU实验.ipynbNPU 进阶 10 个实验Notebook 顺序运行各 cell 输出与 trace 文件

10.7 数据集与环境

文本分类语料(data.zip)

体育.csv、教育.csv、健康.csv、旅游.csv 四个文件;标签映射固定为 {'体育':0,'教育':1,'健康':2,'旅游':3}。另含停用词表、word2vec 训练语料、新闻语料等辅助文件。

NPU 实验环境

实测参考:Python 3.9 / torch 2.1.0 / torch_npu 2.1.0.post3 / CANN 8.0 / Ascend910ProA;不同机器与镜像版本会有差异,以 torch.npu.get_device_name(0) 输出为准。

项目课程实验推荐说明
Python3.9 / 3.10 / 3.12不同实验环境不同,注意包版本兼容
PyTorch2.1.0 / 2.4.1NPU 环境需与 torch_npu、CANN 配套
torch_npu2.1.0.post3提供 .npu()、混合精度、profiler、量化等接口
CANN8.0 / 9.0版本需与驱动、torch_npu 匹配
机器学习库scikit-learn / pandas / numpyTF-IDF、分类报告、数据处理
深度学习库transformersBERT 微调与 Trainer
面试KP 10.1

实验报告怎么写才不丢分?

一句话

目标—方法—结果—分析—问题,五段齐全,结果必须能复现。

  1. 实验目的:这次实验验证哪个知识点,不要抄指导书原文。
  2. 方法与关键代码:写清数据、模型、超参、环境版本;代码只贴关键段。
  3. 结果:贴运行输出/截图/指标表,注明"示例/实测"。
  4. 分析:解释现象,例如"为什么单张图 NPU 更慢"——算术强度低、固定开销占比高。
  5. 问题与改进:记录报错、版本坑、下一步实验。
易错只贴代码不贴结果、只贴结果不解释、把示例数字当成自己实测的数字,是实验报告最常见的三个扣分点。
10 秒自测 · 点开看答案

问:NPU 实验报告中,为什么要把"同步"写进计时步骤?

答:NPU 是异步执行,不同步时测到的只是任务下发时间,不是真实计算耗时。

概念KP 10.2

按目标复习:三条实验路线

一句话

想懂原理走词向量 → RNN → Transformer;想懂工程走文本分类四连;想懂算力走 NPU 十八题。

原理线

OneHot → 共现 → SVD → Word2Vec → RNN 前向 → Seq2Seq → 注意力 → Transformer 训练。

工程线

TF-IDF 基线 → TextCNN → TextRNN → BERT,同一份语料逐层对照,观察指标变化。

算力线

Hello NPU → 矩阵乘对比 → Batch → 搬运 → 高斯模糊 → 进阶 10 题(精度、通信、性能、图、显存、量化)。

考前速通

只背每个实验的"一句话预期结果" + 一个失败原因,足以应对简答题。

实验 KP 10.3

四分类语料速查:四个文件、一套标签、一条读取链

一句话

体育 0、教育 1、健康 2、旅游 3;四个 CSV 无表头,一行一条文本。

文本分类四个实验共用一份四分类语料:data/ 下的体育.csv、教育.csv、健康.csv、旅游.csv,每个文件一行一条文本、没有表头,读取后按文件名归标签。标签映射全课程固定为 {'体育':0,'教育':1,'健康':2,'旅游':3},四个实验必须一致,target_names 也要按同一顺序取,分类报告才不会张冠李戴。所有脚本都从同目录的 utils.py 里 from utils import load_data 取数,所以 utils.py 必须和 train_*.py 放在一起。

文件标签 id内容说明
体育.csv0体育类中文短文本,一行一条
教育.csv1教育类中文短文本,一行一条
健康.csv2健康类中文短文本,一行一条
旅游.csv3旅游类中文短文本,一行一条

四个文件走同一条流水线:字符级切分 → 训练集上建字表 → 截断/补齐到 max_len=256 → 训练与评估;置 <PAD>=0、<UNK>=1,测试集复用训练集词表。

from utils import load_data
full_df, label_map = load_data()          # 返回合并后的数据表与固定标签映射
print(full_df['label'].value_counts())    # 先确认四类都读到了,再开始训练
易错data_dir 默认是指导书里的示例路径(例如 D:\Desktop\HCIP-AI内容\data),直接跑会 FileNotFoundError;先改成自己的真实目录。若预测结果全判成同一类,也先回来看 load_data() 是否真读到了四类数据——打印 value_counts 比调模型参数快得多。
10 秒自测 · 点开看答案

问题:四个 CSV 各自的标签 id 是什么?为什么四个实验必须用同一套?

答案:体育 0、教育 1、健康 2、旅游 3。映射与 target_names 顺序一致,四个实验的指标才能横向比较,分类报告的行名也不会错位。

实验 KP 10.4

版本配套:torch、torch_npu、CANN 谁跟谁对得上

一句话

torch 与 torch_npu 主次版本必须一致,CANN 是更底层的运行底座。

NPU 环境要三层配套:torch 与 torch_npu 的主次版本必须一致(补充),例如 torch 2.1.0 配 torch_npu 2.1.0.post3;torch_npu 把框架调用翻译给 CANN,所以 CANN 版本要匹配 torch_npu 的适配要求,还要与本机驱动兼容。课程实测参考组合是 Python 3.9 / torch 2.1.0 / torch_npu 2.1.0.post3 / CANN 8.0 / Ascend910ProA;换机器或镜像后,以实际打印的设备名与版本为准。配套的本质是三节套管:torch_npu 按特定 torch 版本编译,CANN 又提供它运行所需的算子与运行时,任何一节口径不对,整条链都跑不起来。

组件课程实测参考配套要点
Python3.93.8 及以上,各实验环境可能不同
torch2.1.0与 torch_npu 主次版本一致
torch_npu2.1.0.post3提供 .npu()、amp、profiler 等接口
CANN8.0需与 torch_npu 的适配要求、驱动匹配
设备Ascend910ProA用 torch.npu.get_device_name(0) 确认
核对命令python -c "import torch; print(torch.__version__)";再 import torch_npu 后打印 torch.npu.is_available() 与 torch.npu.get_device_name(0)。CANN 版本与驱动可用 npu-smi info 及安装目录下的 version 文件核对(补充)。
易错常见错法:torch 升到 2.4、torch_npu 还停在 2.1——import torch_npu 直接报版本不匹配或符号错误;或只装 torch_npu 却没 source CANN 环境变量,torch.npu.is_available() 返回 False。torch 与 torch_npu 要成对升级、成对降级,不要单独动其中一个。
10 秒自测 · 点开看答案

问题:torch 2.4.1 配 torch_npu 2.1.0.post3,能跑吗?

答案:不能。两者主次版本必须一致,否则接口对不上,通常 import 阶段就报错。

实验 KP 10.5

复现 checklist:种子、划分、版本、运行顺序(补充)

一句话

同一个种子、同一份划分、同一版依赖、同一条运行顺序,才算复现。

实验跑出数字不难,难的是换台机器、或一周后的你,还能跑出同一个数字。复现的最低要求是四件事:① 固定随机种子——random、numpy、torch 各设一次;② 数据划分写死——train/val/test 比例固定,分层抽样保持四类比例;③ 依赖版本留档——pip freeze 存 requirements.txt,记下 torch、torch_npu、CANN;④ 运行顺序固定——先确认数据路径,再跑 TF-IDF 基线,最后跑 BERT。这四条不是形式主义:缺哪一条,别人复现的指标就可能差出一截,而你无法解释差在哪。

最小复现包固定种子的入口脚本 + 数据划分文件(或划分代码)+ requirements.txt + 一份运行记录(命令、设备、耗时、关键指标)。答辩或写报告时,这四样能直接证明结果不是碰巧。
易错两个经典「假复现」:只固定 torch.manual_seed,忘了 numpy / random 与 DataLoader 的 worker 种子;先在全部数据上 fit TF-IDF、建词表,再划分训练测试,造成测试集信息泄漏,指标虚高(补充)。
10 秒自测 · 点开看答案

问题:固定了 torch.manual_seed 就一定能完全复现吗?

答案:不一定。numpy / random 的种子、DataLoader worker、硬件与算子版本都会影响结果;种子、划分、版本、运行顺序要一起固定并记录。

易错 KP 10.6

报错速查:路径、版本、显存、CANN 四类故障

一句话

先查路径再查版本,先降显存再查环境变量。

实验里绝大多数报错落在四类:路径错误、版本不匹配、显存不足、CANN 未初始化。路径错误的典型是 FileNotFoundError 与 No module named 'utils';版本不匹配多发生在 torch 与 torch_npu 之间,或 transformers 新旧参数名不同;显存不足(OOM)先查 batch 与 max_length;CANN 未初始化时 torch.npu.is_available() 直接返回 False,要先执行环境初始化脚本。看报错时先抓最后一个异常类型与文件路径,那通常直指病根,别被满屏 warning 带偏。

现象最常见原因处理
FileNotFoundError / No module named 'utils'data_dir 还是示例路径;脚本与 utils.py 不同目录改 data_dir;在该目录下运行脚本
import torch_npu 报版本或符号错误torch 与 torch_npu 主次版本不一致(补充)按配套版本成对重装
显存不足(OOM)batch_size 或 max_length 过大减小 per_device_train_batch_size / max_length
torch.npu.is_available() 为 FalseCANN 环境变量未加载、驱动异常执行环境初始化脚本;用 npu-smi info 查设备(补充)
四类预测全判成同一类数据未正确加载,或类别极不均衡打印 value_counts 确认分布,再查特征与模型
易错别一报错就重装环境:按「路径 → 版本 → 环境变量 → 显存」的顺序排查,先造最小样例复现。重装 PyTorch 很容易把配好的 NPU 环境弄坏,torch 与 torch_npu 必须成对处理。
10 秒自测 · 点开看答案

问题:OOM 时应该先调哪两个参数?还不够怎么办?

答案:先减小 per_device_train_batch_size 与 max_length;还不够再考虑梯度累积、减小模型或清理缓存(补充)。

实验 KP 10.7

可复现记录表:五格填满,这个实验才算做完

一句话

种子、划分、版本、顺序、结果——缺一格,等于没做。

复现不是再跑一次,而是换机器、换时间、换人,还能得到同一结论(补充)。记录表填五格:① 种子——随机模块与框架各设一次,数据加载的子进程也要设;② 划分——比例、分层与随机方式写死,或直接存划分文件;③ 版本——依赖清单留档,记下框架、插件与 CANN 版本;④ 顺序——数据路径 → 基线 → 深模型;⑤ 结果——命令、设备、耗时、指标、混淆矩阵与失败项。

记录栏要填什么不填的后果
种子random / numpy / torch / worker同脚本两次跑出两个指标
划分比例、分层、划分文件测试集泄漏、指标虚高
版本requirements.txt 与环境清单import 报错、数值不可比
顺序先基线后模型、先小后大词表与缓存互相污染
结果命令、设备、耗时、指标、失败项一周后说不清哪版结果
易错现象:只固定 torch.manual_seed 就宣称「结果可复现」。原因:numpy / random、DataLoader worker、非确定性算子与多卡顺序都会改数值。怎么办:前四样一起固定并留档,报告里写「基本复现」,不写「完全一致」。
10 秒自测 · 点开看答案

问题:复现记录里最容易被漏掉的是哪一栏?

答案:结果栏的环境与命令——只留指标不留运行方式,换人就无法复现。

本章速查

  • 词向量:12 个实验,从 OneHot 到三种评估,核心是「统计 → 预测 → 上下文」三代方法。
  • 文本分类:同一份四分类语料,TF-IDF → TextCNN → TextRNN → BERT 逐层对照。
  • 序列模型:RNN 对齐、Seq2Seq 教师强制、Transformer 五个单元测试。
  • NPU:基础 8 题看「什么时候该放 NPU」,进阶 10 题看「工程上怎么用好 NPU」。

来源:《词向量实验指导书》PDF;《文本分类实验指导书》与作业;《RNN 与 Seq2Seq 复习实验指导书》;《Transformer 英法翻译实验指导书/实训手册》;《NPU 实践实验手册》;《CANN+NPU 实验指导书》;CANN+NPU实验.ipynb;各实验代码与 torch 安装 PDF。

11
REVIEW & QUIZ

复习与自测

考前这一章最值钱:把九个章节压成"考点—公式—易错—自测"四张清单。

复习不是把书再读一遍,而是回答三个问题:哪些一定会考?公式会不会写?哪里最容易错?这一章按这三个问题组织,最后给一条 7 天冲刺路线。

建议顺序:先看"高频考点"自测掌握度 → 不会的回到对应章节 → 用"公式速查"默写 → 最后用"随机抽卡"(右上角 🃏)刷 20 题。

11.1 高频考点 Top 30

面试KP 11.1

NLP 与词向量:10 个必答

一句话

OneHot、共现、Word2Vec、ELMo,一条线串起词向量。

  1. NLP 的五大理解层次是什么?——语音、词法、句法、语义、语用。
  2. NLP 最大的难点是什么?——歧义:词法、句法、语义、语用四层。
  3. OneHot 的两大缺陷?——维度灾难 + 语义鸿沟(任意两词正交)。
  4. 分布式假设是什么?——一个词的含义由它周围的词决定。
  5. 共现矩阵 + SVD 的缺点?——高维稀疏、SVD 代价高、不可增量、高频词主导。
  6. Skip-gram 与 CBOW 的区别?——中心词预测上下文 vs 上下文预测中心词。
  7. 负采样为什么快?——每次只更新 k 个负样本,而不是整个词表 softmax。
  8. GloVe 与 Word2Vec 的区别?——全局共现矩阵分解 vs 局部窗口预测。
  9. FastText 如何处理未登录词?——字符 n-gram 子词向量相加。
  10. 静态词向量与动态词向量?——一词一向量 vs 按上下文生成(ELMo/BERT)。
面试KP 11.2

文本分类与序列标注:10 个必答

一句话

从 TF-IDF 到 BERT,再到 HMM/CRF,本质都是「把文本变成标签」。

  1. 文本分类的整体流程?——文本 → 向量化 → 特征选择 → 分类器 → 评估。
  2. TF-IDF 的直觉?——词频高、但在其他文档也常见,权重就低。
  3. 为什么文本特征要做特征选择?——高维稀疏、噪声多、训练慢。
  4. 朴素贝叶斯的"朴素"指什么?——特征条件独立假设。
  5. TextCNN 为什么用一维卷积?——文本是词序序列,卷积核沿词方向滑动。
  6. 类别不均衡时看什么指标?——每类 P/R/F1、Macro-F1、混淆矩阵。
  7. 序列标注与文本分类的区别?——每个位置都要输出标签。
  8. HMM 的两个假设?——齐次马尔可夫 + 观测独立。
  9. HMM 的标签偏置怎么来?——局部归一化,偏向分支少的状态。
  10. BiLSTM+CRF 中 CRF 的作用?——学习标签转移约束并全局解码,保证标签序列合法。
面试KP 11.3

RNN、Transformer 与昇腾:10 个必答

一句话

记忆、注意力、算力,三块拼图各管一段。

  1. RNN 的隐藏状态是什么?——截止当前时间步的"记忆摘要"。
  2. 梯度消失的根源?——BPTT 中雅可比矩阵连乘,因子小于 1 就指数衰减。
  3. LSTM 如何缓解梯度消失?——细胞状态 + 门控,提供近似恒等的梯度通道。
  4. Seq2Seq 的信息瓶颈?——整句压进一个固定长度向量 C。
  5. Teacher Forcing 是什么?——训练时用真实上一词作为解码器输入。
  6. 自注意力为什么能并行?——每个位置同时与全句交互,不依赖时间步递推。
  7. 为什么要除以 √d_k?——防止点积随维度增大而方差过大,softmax 饱和。
  8. 多头注意力的意义?——不同子空间学习不同关系,再拼接融合。
  9. BERT 与 GPT 的核心区别?——双向 Encoder + MLM vs 单向 Decoder + 自回归。
  10. NPU 一定比 CPU 快吗?——不一定,取决于算术强度、搬运量与固定开销。

11.2 公式速查

主题公式 / 规则一句话提醒
余弦相似度cos(a,b) = a·b / (‖a‖‖b‖)OneHot 两两为 0;词向量看方向不看长度
TF-IDFtf-idf(t,d) = tf(t,d) × log(N / (1+df(t)))高频且到处出现的词权重低
贝叶斯分类P(c|x) ∝ P(c) × Π P(x_i|c)条件独立假设 + 拉普拉斯平滑
Precision / Recall / F1P = TP/(TP+FP),R = TP/(TP+FN),F1 = 2PR/(P+R)类别不均衡时 F1 比 Accuracy 可靠
卡方检验χ² = Σ (O−E)² / Eχ² 越大,词与类越不独立、越相关
Skip-gramP(w_o|w_c) = exp(u_o·v_c) / Σ_w exp(u_w·v_c)点积衡量相似度,softmax 归一化
负采样损失−log σ(u_o·v_c) − Σ_k log σ(−u_k·v_c)只更新 k 个负样本
CBOW 隐藏层h = (1/2m) Σ v_{c+j}平均导致词袋特性、丢词序
HMM 联合概率P(x,y) = P(y_1) Π P(y_t|y_{t−1}) Π P(x_t|y_t)初始 × 转移 × 发射
CRF 打分score = Σ 状态特征 + Σ 转移特征全局归一化:P = exp(score)/Z
RNNh_t = tanh(W_x x_t + W_h h_{t−1} + b)权重沿时间共享
Seq2SeqP(y|x) = Π P(y_t | y_<t, c)c 是编码器最后状态;信息瓶颈
缩放点积注意力Attention(Q,K,V) = softmax(QKᵀ/√d_k)V√d_k 防止 softmax 饱和
多头注意力MultiHead = Concat(head_1…head_h)W_O,head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)h=8,每头 d_k=64
正弦位置编码PE(pos,2i)=sin(pos/10000^{2i/d}),PE(pos,2i+1)=cos(…)低维波长短、高维波长长
FFNFFN(x) = W_2 · ReLU(W_1 x + b_1) + b_2逐位置独立,d_ff=2048
LayerNormy = γ · (x−μ)/√(σ²+ε) + β对单个样本的特征维归一化
困惑度 PPLPPL = exp(−(1/N) Σ log P(w_t | w_<t))越小越好,等价于平均分支数
有效带宽BW = 字节数 / 搬运耗时1 MiB = 1024² B,1 GB = 10⁹ B
加速比speedup = CPU 耗时 / NPU 耗时先同步、再预热、重复取平均

11.3 30 条易错点

#易错说法 / 做法正确理解
1OneHot 能表达词义相似任意两词正交,相似度恒为 0
2词向量维度越大越好维度是超参,过大易过拟合、存储与计算变贵
3共现矩阵+SVD 可以增量更新新词/新语料要重建矩阵并重新分解
4Skip-gram 比 CBOW 慢就不好慢是因为样本多;低频词表现通常更好
5负采样改变 softmax 定义是近似训练目标,不是严格的全局 softmax
6FastText 只能做分类也能学词/子词向量,对 OOV 友好
7静态词向量完全没用轻量、快、可解释,是很多线上系统的基线
8文本分类第一步是选模型第一步是把文本编码成向量
9准确率高就没有问题类别不均衡时要看每类 P/R/F1 与混淆矩阵
10TextCNN 的卷积核越大越好核大小对应 n-gram 范围,要按语料调
11BERT 微调必须大学习率预训练模型微调通常用 2e-5~5e-5 的小学习率
12BiLSTM 输出直接当标签每个位置是标签得分,需要 CRF/softmax 解码
13HMM 与 CRF 只是名字不同CRF 取消独立假设并全局归一化,解决标签偏置
14BIO 标注 B 后面一定是 I还要看实体类型是否一致,非法转移要用 CRF 约束
15RNN 参数量随句长增长权重沿时间共享,参数量与句长无关
16双向 RNN 可用于文本生成生成时看不到未来,双向会"作弊"
17梯度裁剪能根治梯度消失只治梯度爆炸;消失要靠门控/残差/注意力
18Seq2Seq 的 C 越大越好C 是固定长度,长句必然信息瓶颈
19Teacher Forcing 推理时也用推理没有标准答案,只能自回归
20束搜索一定比贪心好束宽增加计算量,指标不一定单调提升
21Transformer 没有位置编码也能区分语序自注意力对位置置换等变,必须加位置信息
22位置编码只能用可学习的正弦编码无需训练、可外推,是原论文方案
23多头注意力计算量是单头的 h 倍每头维度缩小为 d/h,总 FLOPs 基本不变
24mask 加在 softmax 之后即可要在 softmax 之前把分数置 −1e9,概率才为 0
25BERT 是双向语言模型它是双向 Encoder + MLM,不是自回归 LM
26BERT 的 [CLS] 天然是句向量要经过下游微调才有分类意义,原始向量并不适合直接做相似度
27NPU 计时不用同步不同步测到的是任务下发时间
28CPU 与 NPU 结果可以逐元素相等浮点累加顺序不同,要用容差比较
29加速比是固定数字由算术强度、数据搬运、固定开销共同决定
30显存 del 后立即还给系统PyTorch 缓存在显存池,需 empty_cache 才交还

11.4 自测 20 题

面试KP 11.4

概念判断(8 题)

一句话

先判断会不会,再决定回哪一章补。

10 秒自测 · 点开看答案

Q1:NLP 中"歧义"最难的是哪一层?

语用层。词法/句法/语义都能靠规则或统计部分解决,语用依赖语境、说话人意图和世界知识,最难形式化。

10 秒自测 · 点开看答案

Q2:为什么 OneHot 无法表达"猫"和"狗"的相似性?

两个不同词的 OneHot 向量正交,内积与余弦相似度恒为 0,模型无法利用"都是动物"这一共性。

10 秒自测 · 点开看答案

Q3:共现矩阵窗口从 1 增大到 3,语义偏向会怎样变化?

小窗口偏向语法/搭配关系,大窗口偏向主题/篇章语义;非零元素增多,矩阵更稠密。

10 秒自测 · 点开看答案

Q4:CBOW 为什么训练更快?

每个位置只产生一个"多对一"样本,样本数约为 Skip-gram 的 1/(2m),单轮计算量更小。

10 秒自测 · 点开看答案

Q5:ELMo 与 Word2Vec 的本质差异?

Word2Vec 是静态词向量,一个词一个向量;ELMo 用双向语言模型按上下文生成动态词向量,并做多层加权。

10 秒自测 · 点开看答案

Q6:HMM 的"标签偏置"和"上下文缺失"分别由哪个假设导致?

标签偏置来自齐次马尔可夫假设(局部归一化转移概率);上下文缺失来自观测独立假设(只看当前观测)。

10 秒自测 · 点开看答案

Q7:为什么自注意力要除以 √d_k?

点积随维度增大方差变大,softmax 会饱和到接近 one-hot,梯度变小;除以 √d_k 把方差拉回 1 附近。

10 秒自测 · 点开看答案

Q8:CANN 在昇腾全栈中处于什么位置?

介于芯片与 AI 框架之间的异构计算架构:向上适配 MindSpore/PyTorch 等框架,向下释放 NPU 算力。

公式KP 11.5

公式与计算(6 题)

一句话

能自己算出来,才说明是真懂而不是眼熟。

10 秒自测 · 点开看答案

Q9:某类 TP=30,FP=10,FN=20,求 P、R、F1。

P=30/40=0.75;R=30/50=0.6;F1=2×0.75×0.6/(0.75+0.6)=0.667。

10 秒自测 · 点开看答案

Q10:d_k=64 时,注意力分数要除以多少?

√64 = 8。

10 秒自测 · 点开看答案

Q11:d_model=512、h=8 的多头注意力,每个头的维度是多少?

512/8 = 64。

10 秒自测 · 点开看答案

Q12:位置编码 pos=1、d=8 时,偶数维 2i=0 的 PE 值是多少?

PE(1,0)=sin(1/10000^0)=sin(1)≈0.8415。

10 秒自测 · 点开看答案

Q13:1 GiB 数据在 0.02 s 内搬完,有效带宽约多少 GB/s?

1024³ B ≈ 1.0737×10⁹ B;1.0737×10⁹ / 0.02 ≈ 53.7 GB/s(十进制 GB)。

10 秒自测 · 点开看答案

Q14:CPU 耗时 128 ms、NPU 耗时 0.44 ms,加速比约多少?

128 / 0.44 ≈ 291×。

实验KP 11.6

实验与工程(6 题)

一句话

实验题考的是解释现象,不是背步骤。

10 秒自测 · 点开看答案

Q15:为什么单张图片的高斯模糊在 NPU 上可能更慢?

计算量小、算术强度低,数据搬运与 Kernel 启动等固定开销占主导,NPU 并行优势发挥不出来。

10 秒自测 · 点开看答案

Q16:批量矩阵乘法为什么比循环快?

一次算子调用完成多个矩阵乘,只启动一次 Kernel;循环方式每个矩阵都要一次 Kernel 启动与调度。

10 秒自测 · 点开看答案

Q17:NPU 性能测试前为什么要预热?

首次执行包含算子编译、内存分配与路径初始化开销,会污染计时;预热后多次取平均才稳定。

10 秒自测 · 点开看答案

Q18:为什么混合精度训练需要 GradScaler?

FP16 下小梯度可能下溢为 0;缩放器先放大损失,反传后再还原梯度,并在检测到非有限值时跳过更新。

10 秒自测 · 点开看答案

Q19:torch.compile 的图模式收益来自哪里?

图捕获后做算子融合、整图下沉与内存规划,减少 Python 开销和 Kernel 启动次数。

10 秒自测 · 点开看答案

Q20:显存 del 之后为什么 memory_allocated 没降?

PyTorch 把释放的显存留在自己的缓存池里复用,没有交还系统;调用 empty_cache 才会清空缓存。

11.5 7 天冲刺路线

天任务产出
Day 1第 01–03 章:NLP 概论 + 词向量 + 文本分类能默写 OneHot 缺点、TF-IDF 公式、四分类流程
Day 2第 04–05 章:序列标注 + 语言模型能画 HMM→CRF→BiLSTM+CRF 演进图
Day 3第 06 章:RNN 与 Seq2Seq能手推 h_t、解释梯度消失与教师强制
Day 4第 07 章:Transformer 上半能手算一遍缩放点积注意力、写 PE 公式
Day 5第 07 章:Transformer 下半 + BERT/LLM能说清 BERT 与 GPT 的区别、MLM/NSP
Day 6第 08–09 章:昇腾 CANN + NPU 实验能画全栈图、说出三因素与 18 个实验结论
Day 7第 10–11 章:实验索引 + 公式 + 自测过一遍 30 条易错点,随机抽卡 20 题
概念KP 11.7

英文术语速记:10 个词,一句话记住

一句话

先练「英文 → 中文 → 一句话作用」,拼写反而不必背。

课件、题干和论文里,术语几乎只写英文。复习时别背拼写,要练三段式:看到英文先想中文,再用一句话说出它解决什么问题。下面 10 个按「先表示、再训练、最后部署」排序:Embedding 把词变成数,Pre-training 与 Fine-tuning 让模型学会任务,Inference 与 Quantization 负责上线。遇到不认识的缩写,先猜它属于表示、训练还是部署。

英文术语中文一句话解释
Embedding嵌入(词嵌入)把离散词查表映射成稠密向量,网络才算得动。
Attention注意力按相关度对全句加权求和,决定「该看哪里」。
Self-Attention自注意力Q / K / V 都来自同一句话,句内互看且可并行。
Pre-training预训练在大规模无标注语料上先学通用表示,如 MLM。
Fine-tuning微调用少量标注数据继续训练,适配具体下游任务。
Inference推理训练完成后只做前向计算,不更新参数。
Quantization量化用低精度表示权重与激活,换更小显存和更快计算(补充)。
Tokenization分词(词元化)把原文切成 token 并映射成 ID,是数据入口。
Perplexity困惑度语言模型的「平均分支数」,越小说明越不困惑。
Throughput吞吐量单位时间处理的样本数,与单条时延不是一回事(补充)。
记忆主线Tokenization → Embedding → Attention 是「怎么表示」,Pre-training → Fine-tuning 是「怎么学」,Inference → Quantization 是「怎么上线」;PPL 看质量,Throughput 看速度。
10 秒自测 · 点开看答案

问:Fine-tuning 与 Pre-training 的根本区别是什么?

Pre-training 用无标注语料自学通用表示(如 MLM),Fine-tuning 用带标注的下游数据把参数调到具体任务上;前者学「语言」,后者学「任务」。

易错KP 11.8

易错点补充 10 条:这些话最容易说反

一句话

每一条都是「听起来很顺、写下来就错」的判断题。

11.3 的 30 条覆盖了概念与实验,这 10 条专挑统计、训练、工程里最容易顺口说错的话(补充)。判断前先问自己:这句话是不是把「相关」说成了「因果」,把「训练」说成了「推理」,把「一次跑通」说成了「可复现」?判断题里凡是出现「一定」「完全」「就是」,多半要打问号,再把这句话翻译成具体实验现象。

#易错说法正确理解
1注意力权重高,说明模型「看」对了地方权重只是加权系数,不等于因果贡献,还会被 Value 与后续层变换(补充)。
2困惑度就是准确率PPL = exp(平均交叉熵),衡量概率质量;与分类 Accuracy 不能互相换算。
3softmax 输出就是置信度它是相对概率且未校准,最高分 0.99 也可能过度自信(补充)。
4训练损失下降,任务指标一定变好损失与指标不同步很常见,类别不均衡时尤其明显。
5拿测试集挑超参没关系反复看测试集就是信息泄漏,指标虚高;测试集只用于最终评估。
6参数量越大效果越好效果由数据、任务与训练策略共同决定,小模型常更划算(补充)。
7固定随机种子就能完全复现多卡、非确定算子与硬件差异仍会带来波动,只能基本复现(补充)。
8量化一定掉点、也一定更快掉点取决于方案与模型;是否变快取决于硬件是否真支持低精度算子。
9混合精度只是省显存FP16 有溢出与下溢风险,需要 loss scale 与 GradScaler 保护数值。
10学习率越小越稳、越好太小收敛慢、易停在平台期;合适的学习率还要配 warmup 与衰减。
易错组合陷阱最常见:用测试集调参(第 5 条)+ 只报损失不看指标(第 4 条)+ 固定种子就宣称可复现(第 7 条),三处同时踩中,结论基本作废。
面试KP 11.9

面试项目怎么讲:STAR 四段模板

一句话

情境一句、任务一句、行动三句、结果一句带数字。

面试官问项目,不是想听「我用了 BERT」,而是验证三件事:项目是不是你做的、关键选择是不是你想过的、结论有没有数据支撑。STAR 四段正好对应这三点,下面用课程里「四分类对比 + NPU 计时」的实验套一遍(补充)。讲完四段再补一句「这里我最大的取舍是……」,把追问引到你准备过的地方。

  1. S(情境):课程要求在昇腾 NPU 上完成中文文本分类,并解释「NPU 是否总比 CPU 快」。
  2. T(任务):同一份四分类语料跑 TF-IDF、TextCNN、TextRNN、BERT 四条线,并测出各规模的加速比与瓶颈。
  3. A(行动):先定指标(Macro-F1 + 混淆矩阵),再逐层对照模型;测速固定「同步 + 预热 + 取平均」;最后用 profiler 判断是算子慢还是搬运慢。
  4. R(结果):给指标表与加速比曲线,结论要一句——小任务被固定开销主导,规模上去 NPU 才吃满;数字填自己的实测。
易错把「行动」讲成工具清单(用了 jieba、PyTorch、torch_npu)。面试官一定会追问「为什么 batch 从 1 调到 32」「为什么看 Macro-F1」,答不上就露馅。
10 秒自测 · 点开看答案

问:STAR 的 R 只讲「效果不错」行不行?

不行。结果要给可复现的指标与对比对象,例如「Macro-F1 比 TF-IDF 基线高 X 个点」,并说明是示例还是自己的实测。

公式KP 11.10

公式默写清单:考前必须写对的 10 条

一句话

能默写、能解释符号,才算真会;写错的回原章节重抄。

默写自检三件事:符号对(上下标、转置、求和范围)、归一化对(分母、√d_k、配分函数 Z)、一句话说清它算什么。下面 10 条按章节顺序排,破折号后是必须跟着写出来的记忆点。考前 10 分钟只看这张卡,盖住提示先默写;连转置、下标和单位一起写,缺一个都算错;写错就回原章节重抄。

  1. 余弦相似度:cos(a,b) = a·b / (‖a‖·‖b‖) —— 只看方向,OneHot 两两为 0。
  2. TF-IDF:tf-idf(t,d) = tf(t,d) × log(N / (1 + df(t))) —— 到处出现的词被降权。
  3. P / R / F1:P = TP/(TP+FP),R = TP/(TP+FN),F1 = 2PR/(P+R) —— 不均衡先看 F1。
  4. HMM 联合概率:P(x,y) = P(y₁) Π P(y_t | y_{t−1}) Π P(x_t | y_t) —— 初始 × 转移 × 发射。
  5. CRF 条件概率:P(y|x) = exp(score(x,y)) / Σ_y′ exp(score(x,y′)) —— 全局归一化,无标签偏置。
  6. RNN 隐状态:h_t = tanh(W_x x_t + W_h h_{t−1} + b) —— 权重沿时间共享。
  7. Seq2Seq:P(y|x) = Π P(y_t | y_<t, c) —— c 定长,长句有信息瓶颈。
  8. 缩放点积注意力:Attention(Q,K,V) = softmax(QKᵀ / √d_k) V —— 除 √d_k 防止 softmax 饱和。
  9. 正弦位置编码:PE(pos,2i) = sin(pos/10000^{2i/d}),PE(pos,2i+1) = cos(pos/10000^{2i/d}) —— 偶数维 sin、奇数维 cos。
  10. 加速比与带宽:speedup = T_CPU / T_NPU,BW = 字节数 / 搬运耗时 —— 先同步、再预热、重复取平均。
默写方法盖住右半部分先写公式,再对照符号;同一公式连写三遍,比读十遍有效。
面试KP 11.11

选择题 10 道:四选一,做完当场判分

一句话

先选再看解析;错题按解析回章节,别只记字母。

题干覆盖第 02–09 章的核心判断,四个选项里混了「半对半错」的干扰项。做题顺序:先划关键词(「首」「一定」「根本」),再排除绝对化表述,最后对照解析回原章节补漏。一套 10 题控制在 8 分钟内,做完只记「为什么错」,不要背题号;错两题以上就把对应章节的速查读一遍,再抽一次。

10 秒自测 · 点开看答案

Q1:Transformer 的 mask 应该加在哪里?
A. softmax 之后
B. softmax 之前,把不允许的位置分数置 −1e9
C. 输出层之后
D. 只在训练时加

选 B。softmax 之后再置零不改变归一化,概率仍会分给被遮位置;必须先在打分阶段压到 −1e9,概率才严格为 0。

10 秒自测 · 点开看答案

Q2:关于 BERT,下面哪句正确?
A. 是单向自回归语言模型
B. 用 MLM + NSP 自监督预训练的双向 Encoder
C. 只能做文本生成
D. 不微调就能直接做分类

选 B。BERT 用 Encoder 双向读入,MLM 遮词预测、NSP 判断下一句;下游任务仍需微调或接任务头。

10 秒自测 · 点开看答案

Q3:某类只占 2%,最能反映模型在少数类上表现的是?
A. Accuracy
B. 该类的 Recall 与 F1
C. 训练 Loss
D. 参数量

选 B。全判多数类也能有 98% 的 Accuracy;要看每类 P / R / F1 与混淆矩阵。

10 秒自测 · 点开看答案

Q4:CRF 相对 HMM 的核心改进是?
A. 用神经网络替代所有参数
B. 取消两个独立假设,改为全局归一化的条件概率
C. 用贪心解码代替维特比
D. 不再需要特征函数

选 B。CRF 直接建模 P(y|x),全局归一化,避免 HMM 局部归一化带来的标签偏置。

10 秒自测 · 点开看答案

Q5:LayerNorm 与 BatchNorm 的主要区别是?
A. LayerNorm 对单个样本的特征维归一化
B. LayerNorm 对 batch 维归一化
C. LayerNorm 没有可学习参数
D. LayerNorm 只能用于卷积

选 A。LayerNorm 在单个样本内部沿特征维求均值方差,不依赖 batch 大小,适合变长序列。

10 秒自测 · 点开看答案

Q6:多卡训练中 HCCL 的 AllReduce 完成什么?
A. 汇总各卡梯度并同步到所有卡
B. 压缩模型体积
C. 加速数据加载
D. 替代优化器

选 A。反向传播后各卡梯度做规约求平均,再同步回所有卡,保证参数一致。

10 秒自测 · 点开看答案

Q7:Skip-gram 的负采样(SGNS)把训练目标变成了?
A. 完整 softmax 的精确分解
B. 一个正样本 + k 个负样本的二分类近似
C. 直接对共现矩阵做 SVD
D. 去掉上下文窗口

选 B。每步只更新 k 个负样本向量,计算量远小于全词表 softmax,是近似训练目标。

10 秒自测 · 点开看答案

Q8:Skip-gram 的训练目标是?
A. 用中心词预测窗口内上下文
B. 用上下文预测中心词
C. 让任意两词向量正交
D. 最小化困惑度

选 A。中心词 → 上下文;反过来「上下文 → 中心词」是 CBOW。

10 秒自测 · 点开看答案

Q9:某词的注意力权重最高,能否直接说它对结果贡献最大?
A. 能,权重就是贡献
B. 不能,权重只是加权系数
C. 只有多头时才能
D. 取决于学习率

选 B。权重还要乘 Value 并被后续层变换,高权重不等于因果重要;解释性需要额外方法(补充)。

10 秒自测 · 点开看答案

Q10:Transformer 必须加位置编码,根本原因是?
A. 自注意力对位置置换等变,打乱词序输出跟着换位
B. 词向量维度太大
C. 训练数据没有顺序
D. 解码需要掩码

选 A。自注意力只算两两关系,本身没有先后概念;位置编码把顺序信息注入。

面试 KP 11.12

英文面试速答:Attention、BERT、Overfitting、NPU 各一句

一句话

定义、机制、用途三个短句,20 秒讲完一个概念。

英文答概念别背长句(补充):先给定义,再说机制,最后说它解决什么问题。下面四句按 20–30 秒设计,开口用 In one sentence 起头,主谓清晰、语速放慢;卡住的词就换简单说法,别硬撑长难句。答完停一秒等追问,不要自己抢着补细节。被问再展开一层,例如 BERT 追问预训练与微调、NPU 追问与 GPU 的架构差异。

术语英文一句话关键词
AttentionAttention takes a weighted sum of values, with weights scored by query–key similarity.weighted sum、similarity
BERTBERT is a bidirectional Transformer encoder pre-trained with masked language modeling and then fine-tuned for each task.bidirectional、MLM、fine-tune
OverfittingOverfitting means the model fits the training data too well and stops generalizing to validation data.generalize、validation
NPUAn NPU is a dedicated neural-network accelerator; Huawei's Ascend runs matrix-heavy ops on AI Cores.accelerator、AI Core
答题模板X is a … that … so …;定义、机制、用途各一句,先用中文想清楚再翻成英文。
10 秒自测 · 点开看答案

问题:用英文解释 BERT 最容易被追问什么?

答案:pre-training 与 fine-tuning 的区别,以及 MLM 为什么能双向。

面试 KP 11.13

错题本模板:题目、错因、正确思路、回看章节

一句话

四栏一条;错因要写「我当时为什么这么想」。

错题本只记会再错的题(补充):一栏写题目与出处,二栏写我的答案与错因类型——知识盲区、概念混淆、看错题、计算错、蒙对;三栏写正确思路的关键一步和依据;四栏写回看章节与复习日期。节奏用 1 / 3 / 7 天:当天记、三天后重做、一周后只看错因抽问。同一错因出现三次,回章节重读,别继续刷题。

栏位写什么判定标准
题目原题关键句、章节、题型不看答案能复述考点
错因我的答案与错因类型能说出当时为什么这么想
正确思路关键一步与依据能解释错项为什么不行
回看章节锚点与复习日期一周后重做仍答对
易错现象:错题本抄满正确答案,下次同题还错。原因:抄答案只记住结论,没修正判断过程。怎么办:每条强制写一句「我当时为什么会这么想」,再写正确思路的第一步。
10 秒自测 · 点开看答案

问题:错题本里最不能少的是哪一栏?

答案:错因栏——只抄答案治不了判断过程,错因类型才能定位回哪一章。

本章速查

  • 一定会考:OneHot 缺点、TF-IDF、SG/CBOW、HMM/CRF、RNN/BPTT、Seq2Seq、注意力、BERT、CANN 全栈。
  • 一定要会写:余弦相似度、TF-IDF、P/R/F1、h_t、Attention、PE。
  • 一定要会解释:梯度消失、信息瓶颈、mask、NPU 加速比、混合精度。
  • 考前最后一眼:30 条易错点 + 公式速查表。

来源:本页为全站复习索引,考点整理自第 01–10 章;补充的面试题与复习路线为学习建议。

12
APPENDIX

附录与索引

每个知识点都能追溯到原始材料;这一章负责把"来源"与"术语"交代清楚。

页面的正文由课程 PPT、实验指导书、实训手册、代码与 Notebook 整理而来;少数通识性补充内容已在卡片内标注"(补充)"。如果你发现某处与老师课件不一致,请以课件原文为准。

12.1 材料来源索引

原始材料主要内容对应章节
《2 第二章 自然语言处理理论和应用.pptx》(129 页)NLP 概论、词向量、文本分类、序列标注、语言模型、Transformer、BERT、LLM、对话系统01–07
《3 第三章 人工智能发展趋势与昇腾AI基础软硬件平台介绍.pptx》(24 页)AI 趋势、昇腾全栈、Atlas 硬件、CANN、MindSpore、应用使能、ModelArts08
《实验指导书_词向量前5个实验.pdf》OneHot、共现矩阵、共现+SVD、Skip-gram、CBOW 五个实验02
《代码带注释版.zip》《实验指导书代码答案.zip》exp01–exp12 与 lab01–lab05 代码、corpus.txt、SVD 可视化图02、10
《HCIP-AI-自然语言处理-文本分类-实验指导书(4).docx》TF-IDF、TextCNN、TextRNN、BERT 四个实验03
《文本分类作业.docx》三项拓展作业:特征工程、超参消融、BERT 层冻结与鲁棒性03、10
《HCIP-AI-自然语言处理-RNN与Seq2Seq复习-实验指导书(1).docx》RNN 前向对齐、Seq2Seq 教师强制两个实验06
《08_RNN_知识点复习.html》《9_seq2seq_知识点复习.html》RNN / BiRNN / BPTT / 梯度问题,Seq2Seq / 教师强制 / 束搜索06
《HCIP-AI-Transformer英法翻译实战-实验指导书.docx / 实训手册.docx》注意力、多头、位置编码、编解码堆叠、分词器、训练与解码 5 个实验07
《2 自然语言处理任务与方法-Transformer知识点详解.html》Transformer 14 节详解、公式、手算、误区与自测07
《data.zip》体育 / 教育 / 健康 / 旅游四分类 CSV、停用词、训练语料03、10
utils.py、train_tfidf.py、train_textcnn.py、train_textrnn.py、train_bert.py四分类实验代码03、10
RNN.py、test-1.py、train_rnn_lm.py、train_seq2seq.py、transformer-test.py、train_transformer.pyRNN、Seq2Seq、Transformer 训练与单元测试06、07、10
《NPU实践实验手册(无代码版).docx》Hello NPU + 7 个基础实验(8 题)09、10
《CANN+NPU实验_实验步骤指导书.docx》《CANN+NPU实验.ipynb》混合精度、HCCL、profiler、FlashAttention、多流、图模式、异步传输、动态 Shape、显存、量化 10 个进阶实验09、10
《云服务器使用.docx》《torch安装.pdf》云服务器、镜像选择、torch 三种安装方式与版本匹配09、10
cann_basics 课程与图片库AI 基础、NPU 架构、CANN 组件与架构图08
论文《Attention Is All You Need》(1706.03762)Transformer 原始结构、复杂度分析07

同一材料存在多个版本时,以最新/最全版本为准;重复文件不重复列出。

12.2 缩略语

缩写英文中文
NLPNatural Language Processing自然语言处理
NLU / NLGNatural Language Understanding / Generation自然语言理解 / 生成
LMLanguage Model语言模型
MLMMasked Language Model掩码语言模型
NSPNext Sentence Prediction下一句预测
ELMoEmbeddings from Language Models基于语言模型的词嵌入
RNN / LSTM / GRURecurrent Neural Network / Long Short-Term Memory / Gated Recurrent Unit循环神经网络 / 长短期记忆 / 门控循环单元
BPTTBackpropagation Through Time随时间反向传播
Seq2SeqSequence to Sequence序列到序列
HMM / CRFHidden Markov Model / Conditional Random Field隐马尔可夫模型 / 条件随机场
NER / POSNamed Entity Recognition / Part-of-Speech命名实体识别 / 词性标注
TF-IDFTerm Frequency–Inverse Document Frequency词频–逆文档频率
CNN / RNN / FFNConvolutional / Recurrent / Feed-Forward Network卷积 / 循环 / 前馈网络
LLMLarge Language Model大语言模型
MoEMixture of Experts混合专家模型
NPUNeural Processing Unit神经网络处理器
CANNCompute Architecture for Neural Networks昇腾异构计算架构
GE / HCCLGraph Engine / Huawei Collective Communication Library图引擎 / 华为集合通信库
DVPPDigital Vision Pre-Processing数字视觉预处理
H2D / D2HHost to Device / Device to Host主机到设备 / 设备到主机

12.3 参考链接

资源链接用途
Attention Is All You Needarxiv.org/abs/1706.03762Transformer 原始论文
BERT 论文arxiv.org/abs/1810.04805BERT 预训练与微调
CS224nweb.stanford.edu/class/cs224n/斯坦福 NLP 课程
李宏毅机器学习speech.ee.ntu.edu.twRNN / attention 中文讲解
昇腾社区hiascend.comCANN 文档、模型库、工具链
PyTorch 官网pytorch.orgtorch 安装命令
Hugging Facehuggingface.co预训练模型与 transformers
离线提示参考链接仅在联网时可用;本页主体内容、代码与图示均已内嵌,断网也能复习。

12.4 版本与更新

版本日期说明
v1.02026-11-21首版:9 章知识库 + 实验索引 + 复习自测,单文件离线版
素材截止2026-11本学期已学内容:NLP 第二章、昇腾第三章、词向量/文本分类/RNN/Transformer 实验、CANN+NPU 实践
面试KP 12.1

这份知识库怎么用最高效?

一句话

先刷目录建立地图,再按章翻卡,最后用随机抽卡和公式速查做考前检索。

  • 第一遍(建立地图):只看每章标题、每张卡的黄色"一句话"和章末速查,知道这门课有哪些块。
  • 第二遍(补细节):按实验线或模型线读正文,重点看公式、代码与易错点。
  • 第三遍(查漏):打开"复习与自测",用随机抽卡和错题回顾;目录的进度环就是你的复习清单。
易错把页面当小说从头读到尾。知识库的用法是"检索 + 对照",不是顺序阅读。
10 秒自测 · 点开看答案

问:只想快速确认"某个实验对应哪个文件",应该看哪一章?

答:第 10 章"实验与代码库",按实验总表或代码索引查。

实验KP 12.2

学习资源与工具清单:从课件到调试器

一句话

课件定范围、指导书管复现、文档查版本、工具找真因。

资源不是越多越好,按五层用最省时间:课件定范围、指导书管复现、论文补原理、社区文档查版本、调试工具找真因。复习先在前两类里闭环,卡住了再去后三类(补充);本页已内嵌关键结论,断网也能用。每类只留一份最新版,重复文件当备份,别在旧版本上找答案。

类别具体资源什么时候用
课程 PPT第二章 NLP 理论与应用(129 页)、第三章 AI 趋势与昇腾平台(24 页)对考点、找老师原话;先看目录与结论页
实验指导书词向量前 5 个、文本分类 4 个、RNN 与 Seq2Seq 2 个、Transformer 英法翻译、NPU 实践、CANN+NPU 进阶 10 个重跑实验、核对步骤与「预期结果」
论文《Attention Is All You Need》(1706.03762)、BERT (1810.04805)读结构图、复杂度与 MLM / NSP 定义,别逐行硬啃(补充)
社区文档昇腾社区(CANN 文档、算子与 API、模型库)、PyTorch 文档、Hugging Face transformers 文档查 API 与版本对应,尤其 torch_npu 与 CANN 的配套关系(补充)
调试工具torch_npu.profiler + Insight / TensorBoard、npu-smi、环境自检脚本、pdb / print先判断是算子慢、搬运慢还是没同步,再改代码
离线优先课件与指导书已覆盖大部分考点;论文与社区文档用于查证与拓展(补充)。
10 秒自测 · 点开看答案

问:想确认某个 torch_npu 接口在当前环境能不能用,先查什么?

先看昇腾社区文档的版本说明,再在环境里 import 并打印版本做自检;只信教程截图,最容易踩版本坑。

概念KP 12.3

素材与版权说明:哪些图来自课程、哪些是补充

一句话

课程素材版权归原作者,标注「补充」的是本站整理。

本页是课程学习笔记,不是官方教材。总原则:课件与厂商资料的版权归原作者;本页只做摘要、重绘与整理,标注(补充)的内容不在课件原文中。如发现与课件不一致,以课件原文为准。个人学习复习可以随意翻阅,公开传播请先获得授权;文中出现的课程材料名称只用于说明来源。

类别具体内容版权与说明
来自课程材料章节观点、公式、实验步骤与「预期结果」整理自课程 PPT、实验指导书、代码与 Notebook版权归课程与原作者,本页仅摘要整理
来自课程图片库第 08 章 CANN 架构、Atlas 硬件、NPU 结构图整理自 cann_basics 课程图片库与课程材料版权归华为与原出处,仅供学习查看
按论文与实验重绘第 02 章 SVD 散点与 k 值对比图来自实验 3 的可视化结果;第 07 章多头注意力与训练/推理示意图按原论文结构重绘示意类图为本站整理(补充)
页面原创整理章节结构、类比、速查表、易错点、自测题、复习路线与全部文字表格本站编写,供个人复习使用(补充)
注意未经授权,不要把课程 PPT、实验指导书或厂商图片用于商业用途、公开发布或二次售卖。

本章速查

  • 材料出处:每一章都能在 12.1 找到对应的 PPT / 文档 / 代码。
  • 术语:看不熟的缩写先查 12.2,再回正文。
  • 版本:v1.0,素材截止 2026-11;后续新增实验可继续追加。

来源:本页为全站索引与元信息,内容依据本学期课程材料整理;参考链接仅供拓展阅读。

正在筛选:实验