依存解析入门：让机器读懂句子里的主谓宾关系

可视化演示

\u5c55\u793aRound Robin\u8c03\u5ea6\u7b97\u6cd5\u6309\u65f6\u95f4\u7247\u8f6e\u8f6c\u6267\u884c\u8fdb\u7a0b\u7684\u8fc7\u7a0b\uff0c\u6bcf\u4e2a\u8fdb\u7a0b\u83b7\u5f97\u56fa\u5b9a\u65f6\u95f4\u7247\uff0c\u7528\u5c3d\u540e\u8fdb\u5165\u5c31\u7eea\u961f\u5217\u7b49\u5f85\u3002

名词解释：什么是依存解析

在乐高世界里，每块积木的底部都有卡扣槽，顶上都有凸点，组装的关键就是找到“谁卡进谁”。句子也一样，词与词之间存在“卡扣”关系——有些词是“主人”，有些词是“随从”。比如“可爱小猫吃鱼”里，“吃”是发号施令的主人，它决定了“小猫”和“鱼”的站位；“可爱”则是“小猫”的装饰性随从。

这个概念在语言学中叫“依存关系”（Dependency Relation）。计算机要从一句话所有可能的词对中，找出哪些词真的存在这种主从关联，并画出有向弧。给出定义：如果词 $w_i$ 依存于词 $w_j$，那么 $w_j$ 是 $w_i$ 的支配词（父节点），$w_i$ 是从属词（子节点），记作 $\text{dep}(w_i) = w_j$。

这套思路与传统的“短语结构语法”不同——短语结构语法像把积木先分成一盒盒小套装（名词短语、动词短语），再组合；依存解析则直接关注“每一块积木最终卡在谁身上”，不搞中间包装。对机器来说，依存关系更容易计算，也更贴近语义角色：主语、宾语、修饰语直接从弧上读出来。

回到乐高上：每块“从属积木”都明确知道自己要卡在哪块“支配积木”上，整句话的组装关系就彻底清晰了。这就是依存解析的第一课——谁是主人，谁是随从。

核心关系：主谓宾定状

乐高的卡扣分很多种：长条卡扣连接城墙，十字卡扣固定车轮，圆点卡扣拼接屋顶。依存关系也一样，不同的“卡扣”用不同的标签命名。最常用的标注体系叫 UD（Universal Dependencies，通用依存标注体系），它就像乐高官方的零件命名手册，让全球玩家用同一种语言描述组装关系。

最核心的几种关系：nsubj（主谓关系）标注“小猫 ← 吃”中“小猫”是主语；obj（动宾关系）标注“吃 → 鱼”中“鱼”是宾语；det（限定词）对应“the cat“中的”the“；amod（定中关系）对应”可爱小猫“中”可爱“修饰”小猫“；advmod（状中关系）对应”非常快“中”非常“修饰”快”。

用一个紧凑的记号把两个词和一个标签打包：如果词 $w_i$ 和 $w_j$ 之间存在某类关系 $r$，就记作 $\text{label}(w_i, w_j) = r$。注意这里的关系是有方向的——“小猫”和“吃”之间，标签是 nsubj，方向是从核心“吃”指向从属“小猫”。方向反了，主谓就变成了“谓主”，句子语义就崩了。

搞懂这套标签系统，就像学会了乐高说明书上的图例。以后你看到任何一串“词-词-标签”的组合，都能立即脑补出积木是怎么咬合的。

句子骨骼：依存树结构

把一句话的所有依存弧画在一张图上，你会得到一棵倒挂的树：顶部是唯一的老大（根节点），往下分出树枝，每根树枝再分叉。乐高说明书的封面就是这样的成品图——城堡尖顶在最上方，墙壁和地基依次向下承托。依存树里，“根节点”通常由核心谓语动词担任，比如“可爱小猫吃鱼”的根就是“吃”。

树的规矩很严格：每个词（除了根）有且只有一个父节点，但可以有多个子节点；所有节点通过有向弧连接，不能有回路。也就是说，整棵树的节点数 $V$ 和边数 $E$ 必须满足一个简单的等式——边永远比节点少一条。这保证了图不会乱成一团线球，而是清晰的层级结构。

此外还有一条关于“美观”的性质叫投影性：把所有词从左到右排成一条线，弧画在线上方，如果弧与弧互不交叉，就是投影性的。交叉的弧在工程上更难处理，就像乐高图纸里如果两根线缠在一起，拼装者容易看晕。好在绝大多数语言的日常句子都满足投影性，只有少数疑问句或倒装句会出现交叉。

当你看到一棵完整的依存树时，就等于看到了句子的骨骼——谁是骨架中央的“主梁”，谁是撑起屋檐的“辅柱”，一目了然。这就是机器眼中的句子结构图。

构建方法：自动搭建算法

让机器自动搭建依存树，主要有两条路线，对应两种搭乐高的策略。第一种像“照着说明书逐步拼”：从第一个词开始，一边读一边组装，每一步只做一个决定。这就是转移式解析（transition-based parsing），它用一个栈和一个缓冲区维护组装进度，反复执行三类动作——SHIFT（把新词从缓冲区推到栈顶）、LEFT-ARC（让栈顶第二个词依存于栈顶第一个词）、RIGHT-ARC（反向建立依存）。动作做完，树也搭完了。

第二种像“把全部积木摊开在地板上，研究整体布局后才拼”：这就是图式解析（graph-based parsing）。它先枚举所有可能的词对组合，为每一对打分，然后求一个全局最优的“最大生成树”，保证整棵树得分最高。近年主流的实现用神经网络给词对打分，例如基于双仿射注意力（biaffine attention）的 Deep Biaffine Parser，端到端学习词向量和关系分类器，精度大幅提升。

转移式、图式的核心都可以抽象成一个概率模型：在某个解析状态（配置）$c_t$ 下，选择某个动作 $a_t$ 的概率越大，越说明这个动作正确。公式如下：

搭积木这件事，机器可以一步步顺着拼（转移式），也可以全局观想好再拼（图式）。两者各有擅场：转移式速度快，图式全局更稳，现代系统常常混合两者优势。

经典工具：现成流水线

有了算法还不够，你真去搭乐高时不会从开模做起，而是买套装。NLP 界也把依存解析打包装进了现成“流水线”，开箱即用。学术界最知名的是 Stanford CoreNLP 和 Java 版的 Stanford Parser，英文分析扎实，文档齐全；中文用户则常选哈工大 LTP，分词、词性、依存一条龙，对中文语序优化得很好。

工业界更偏好 Stanza（斯坦福官方 Python 库，支持 70+ 语言，精度高）和 spaCy（推理极快，内存可控，适合线上服务）。选型就像挑乐高套装：收藏党看零件精细度（精度），工程派看拼装速度（延迟），多语言项目则看套装覆盖面（语言支持）。

工具之间的差距可以用标准评测指标衡量，最常用的是 F1 分数，它同时兼顾“找得准”和“找得全”。定义如下：$P$ 是精确率（预测为正确关系的弧中真正正确的比例），$R$ 是召回率（标准答案中真被找到的比例），F1 是二者的调和平均：

在真实项目中，90% 的团队不需要自己训练解析器，而是直接调用这些工具体验“开箱即搭”的爽快感。选对工具，工程就成功了一半。

常见应用：搭完有何用

辛辛苦苦搭好乐高城堡，总不能只摆在橱窗里。依存树的最大价值，是作为“语义基础设施”支撑各种 NLP 应用。第一个典型应用是信息抽取。新闻“苹果公司发布新款手机”经依存解析后，核心动词“发布”连接了主语“苹果公司”和宾语“新款手机”，系统顺势抽取出三元组 $(苹果公司, 发布, 新款手机)$，这正是知识图谱需要的原料。

第二个应用是情感分析。评论“这家餐厅的菜品虽然贵，但服务很好”——如果只看关键词，“贵”是负面词，“好”是正面词，机器会犯晕。依存解析却能看清：“贵”修饰的是“菜品”，“好”修饰的是“服务”，两个观点对象分开评价，情感得分自然更准确。机器翻译也依赖它来理顺语序（尤其是日语、韩语等主宾谓结构与英语不同），问答系统则用它理解“苹果公司今年发布了什么”这个问句的重心在“发布”及其实体上。

这些应用都可以抽象成“从关系中抽三元组”：给定头实体、关系、尾实体，输出结构化知识。形式化地写：

城堡盖好了，自然能装人、储物、观景。依存树搭好了，信息抽取、情感分析、机器翻译这些“住户”就能搬进来。没有这棵树，下游任务就只能靠猜。

日常局限：乐高也怕卡壳

乐高再好玩，遇到几千块零件的巨型套装也会拼到怀疑人生。依存解析同样有怕的东西：长难句是头号杀手。一个句子从句套从句、定语链超过三层时，歧义数量爆炸式增长，即使是 SOTA 模型也会看走眼。比如“他看见了那个拿着望远镜的朋友”——“拿着望远镜”修饰的是“他”还是“朋友”？人类都得分想一下，机器更是容易站错队。

口语和不规范文本也让人头疼。聊天记录里的“哈哈哈笑死我了”、B 站弹幕“这波啊这波是白给”，省略、倒装、错别字层出不穷，依存解析器面对这些“自由拼搭”的乐高零件常常直接懵圈。此外，歧义消解是核心难题，尤其是介词短语挂靠（“在桌子上的猫” vs “看在桌子上的猫”），依存树只能给一种答案，选错就全错。

工程上还要考虑复杂度权衡。转移式解析速度快，时间复杂度低，适合长文本流式处理；图式解析要枚举词对打分，复杂度更高，但全局效果更好。二者的复杂度差异如下：

所以说，依存解析这位“拼装大师”也有脾气：句子太绕、文本太随意、延迟要求太苛刻时，它照样会手忙脚乱。理解这些局限，比盲目相信工具输出更重要。

AI 应用场景

Python 演示

class ArcStandardParser:    """简化版 arc-standard 转移式依存解析器演示"""     def __init__(self, words):        self.words = words        self.stack = []        self.buffer = list(range(len(words)))        self.heads = [None] * len(words)  # heads[i] = (head_idx, rel)     def shift(self):        self.stack.append(self.buffer.pop(0))     def left_arc(self, rel):        head = self.stack[-1]        dep = self.stack.pop(-2)        self.heads[dep] = (head, rel)     def right_arc(self, rel):        head = self.stack[-2]        dep = self.stack.pop(-1)        self.heads[dep] = (head, rel)     def reduce(self):        self.stack.pop()     def parse(self, actions):        for action in actions:            if action[0] == 'SHIFT':                self.shift()            elif action[0] == 'LEFT':                self.left_arc(action[1])            elif action[0] == 'RIGHT':                self.right_arc(action[1])            elif action[0] == 'REDUCE':                self.reduce()            self.show_state(action)     def show_state(self, action):        stack_str = '/'.join(self.words[i] for i in self.stack) if self.stack else '[]'        buf_str = '/'.join(self.words[i] for i in self.buffer) if self.buffer else '[]'        print('%-8s 栈: %-12s 缓冲区: %-12s' % (action[0], stack_str, buf_str))     def show_tree(self):        print()        for i, h in enumerate(self.heads):            if h is not None:                print('%s <- %s (%s)' % (self.words[i], self.words[h[0]], h[1]))            else:                print('%s 是根节点(ROOT)' % self.words[i])  def main():    words = ['小猫', '吃', '鱼']    parser = ArcStandardParser(words)    actions = [        ('SHIFT',),        ('SHIFT',),        ('LEFT', '主谓'),        ('SHIFT',),        ('RIGHT', '动宾'),    ]    parser.parse(actions)    parser.show_tree()  if __name__ == '__main__':    main()

1. self.heads = [None] * len(words)用列表记录每个词的支配词和关系，None 表示该词是根节点。
2. def shift(self)把缓冲区首词推进栈，对应“从零件堆拿一块积木放到搭建台上”。
3. def left_arc(self, rel)栈顶第二个词依存于栈顶词，并弹出它，对应“把下面那块积木卡到上面那块”。
4. def right_arc(self, rel)反向建立依存：栈顶词依存于栈顶第二个词，并弹出栈顶词。
5. parser.parse(actions)按预定义动作序列执行全部步骤，打印每一步的栈和缓冲区状态。
6. parser.show_tree()输出最终的依存关系表，直观看到“谁支配谁”。

常见误区

面试题