从符号到连接：人工智能三次可计算化跃迁与路线取舍

简介：《人工智能读书报告》是一份面向人工智能入门学习者、课程选读者及需要整理学科脉络读者的阅读报告文档，围绕人工智能发展史、基本方法与典型应用展开，适合用于课程作业参考、知识梳理与复习提纲。压缩包共1个docx文件，大小约19KB，内容以连续章节笔记形式组织，便于直接阅读和摘录。文档从亚里士多德、培根、莱布尼茨、图灵等早期思想切入，串联逻辑法、搜索法、归结原理、语义网络、专家系统、神经网络反向传播等关键节点，并延伸到国外发展现状、我国研究进展及符号计算、模式识别、机器翻译、数据挖掘等应用方向。已有307人学习，可作为快速建立人工智能知识框架的轻量资料。

1. 人工智能的历史不是人物年表：三次「把问题变成可计算形式」的搬迁

很多人翻开一份人工智能报告，第一反应是把它当人名加年份的流水账读：谁在哪一年提了什么，谁又推翻了谁。这么读不算错，但合上书什么也留不下。真正值得抓住的是一条主线——每一次跃迁，这个领域都在干同一件事：把一个原本只能靠人「意会」的问题，强行翻译成机器能一步步执行的形式。翻译成功了，方向就热闹三五年；翻译卡住了，整个领域就掉进低谷。这份报告的价值不在于它列了多少条史实，而在于它把「表示—推理—搜索」这条链条完整摆了出来，还顺带把两次范式翻转的转折点标了出来。搞懂这条链条，你再看今天那些模型，就不会被「它是不是有意识」这类问题绕进去。后面几章按三次搬迁展开：先讲符号怎么变得可计算，再讲搜索怎么把「求解」变成「找路」，最后讲知识怎么从人手里搬到机器里、又怎么反过来从数据里长出来。

2. 符号化的地基：为什么「思维」必须先变成一串机器能操作的符号

2.1 演绎与归纳：两条推理路径为什么谁也替不了谁

形式逻辑的起点，是「从已经为真的前提里，按固定规则推出必然为真的结论」。最经典的骨架是三段论：所有 A 都是 B，某个东西是 A，所以它是 B。这里真正值得注意的不是结论，而是规则的合法性来自形式而不是内容——把 A 和 B 换成任何词项，只要结构不变，结论依然成立。这个性质是「可机械化」的第一个信号：一台机器根本不需要理解「人」到底指什么，它只要识别出结构，就能执行这一步。

归纳走的是反方向：从若干具体观察推到一条一般命题。它不保真，只提供概率性支持，但它是唯一能产出「前提里本来没有的知识」的路径。演绎是把已有知识展开，归纳是往知识库里加新条目，两者在能力上是互补而非替代的关系。

报告里那句「人工智能的基本方法是逻辑法和搜索法」，拆开看就是这两种推理的工程化：逻辑法负责演绎，搜索法负责在巨大的可能性空间里找归纳出来的那条路。早期系统几乎全是纯演绎派——机器定理证明就是典型，前提和规则都写死，机器只负责展开。后来机器学习的崛起，本质上是把归纳这一半补了回来。

2.2 符号化：把推理从「看含义」改成「看形状」

自然语言没法直接拿来做机械推理，原因很实在：同一个词在不同句子里含义不同，指代要消解，省略要补全，一句话的正确解读依赖上下文。这些对人类是本能，对机器是灾难。机械执行的前提是每一步只看符号的形状，不看符号的含义。

数理逻辑做的正是这件事：设计一套没有歧义的形式语言（命题变元、连接词、量词），规定形成规则（怎么算合法公式），再规定变形规则（怎么从旧公式得到新公式）。整套东西写出来只有几个符号，却能表达「A 蕴含 B」「对所有 x 都成立 P(x)」这类结构。一旦推理变成「对符号串做合法变形」，它就可以被写进程序。

# 用「事实集合 + 规则表」表示知识，推理只做符号匹配，不关心符号指代什么 facts = {"a_is_human", "human_implies_mortal"} # 规则三元组：(蕴含式本体, 前件, 后件) rules = [("human_implies_mortal", "a_is_human", "a_is_mortal")] def forward_chain(facts, rules): changed = True while changed: # 一直推到不动点，直到没有新事实产生 changed = False for impl, ante, concl in rules: if impl in facts and ante in facts and concl not in facts: facts.add(concl) # 纯字符串拼接，不做任何语义判断 changed = True return facts print(forward_chain(facts, rules))

这段前向链的关键在最后一行注释：推理机全程不知道a_is_human是「人是会死的」这件事，它只做集合成员判断和字符串搬运。参数上，facts是可增长的已知事实集，rules是静态规则表，changed是收敛标志——只要还能推出新事实就继续，推不出来就停机。这个「推到不动点」的模式，后来在产生式系统、Datalog、甚至构建工具里反复出现。

符号化的代价也很清楚：规则得有人写，公式得有人形式化。这一步的人工成本，就是后面所有瓶颈的源头。

2.3 通用计算模型：为什么「程序」和「数据」能躺在同一条纸带上

有了形式语言，还差最后一块：一台能执行任意形式规则的机器。1936 年提出的那个理想计算机模型，结构极简——一条无限长的纸带负责存储，一个读写头负责读和写，一个有限状态寄存器记住「我现在在哪个状态」，一张转移表规定「当前状态读到某个符号时该写什么、往哪移、转到哪个状态」。

# 极简计算模型：纸带 + 读写头 + 转移表 # 转移表条目：(当前状态, 读到符号) -> (写入符号, 移动方向, 新状态) table = { ("q0", "1"): ("1", "R", "q0"), # 读到 1：原样写回，右移，状态不变 ("q0", "0"): ("1", "N", "qf"), # 读到 0：改写成 1，不动，转入终止态 } def run(tape, head, state, table, steps=1000): tape = list(tape) for _ in range(steps): sym = tape[head] if (state, sym) not in table: return "".join(tape), state # 无规则可用即停机 write, move, state = table[(state, sym)] tape[head] = write if move == "R": head += 1 elif move == "L": head -= 1 return "".join(tape), state # 步数用尽，视为未停机 print(run("1110", 0, "q0", table))

参数说明：tape是输入数据，head是读写头当前位置，state是当前状态，table就是「程序」，steps是防止死循环的步数上限——这一点很关键，停机问题不可判定，所以任何模拟器都必须自带一个硬性预算而不是等它自己停。

这个模型真正颠覆性的性质是第二条：转移表本身可以编码成纸带上的符号。于是同一台机器，读入不同的表就能执行不同的过程。专用机器变成了通用机器，「软件」这个概念从此成立。对人工智能的意义在于——从这一刻起，实现一个新算法不再是造一台新硬件，而是写一张新表，迭代速度从「按年造机器」变成「按天改程序」。这是后面所有故事得以发生的前提，报告把它放在最前面讲，是有道理的。

3. 搜索：为什么早期人工智能的本事几乎全是「在状态空间里找路」

3.1 状态空间的三元组：把现实问题翻译成一副骨架

搜索问题的形式化只需要三样东西：状态集合 S、算子集合 O（把状态映射到后继状态并附带代价）、以及一个能机械判定的目标测试。加上初始状态，就是一副完整骨架。八数码、路径规划、下棋、定理证明，看上去毫无关系，套进这副骨架之后是同一个问题。

翻译过程中真正难的是三件事。第一，确定什么算「状态」——状态里包含的信息必须足够决定后续所有可能性，同时又不能冗余，否则空间白白膨胀。第二，确定「一步」的粒度——粒度粗，解空间小但算子本身难构造；粒度细，算子好写但分支因子爆炸。第三，确定目标能不能被机械判定——如果判断「到没到」需要人来看，那这套形式化就崩了。

报告里提到早期搜索被用在机器翻译、机器定理证明、跳棋程序上，这三者恰好是同一副骨架的三种填充：翻译的状态是「已译部分加待译片段」，定理证明的状态是「当前已知公式集」，跳棋的状态是「棋盘局面」。粒度选择在这里体现得最明显——定理证明的一步可以是一条推理规则，也可以是一次完整的归结，前者分支多后者分支少，但后者的单步实现复杂得多。

3.2 启发式与 A*：为什么「不高估」这三个字就能保证最优

盲目搜索不看目标在哪，只按固定顺序展开。它的复杂度是分支因子 b 的深度 d 次方，二十层、每层三个分支就是三十五亿个节点，纯靠算力堆不过去。启发式搜索换了个思路：给每个待展开节点一个估计值 h(n)，表示「从这到目标大概还要花多少」，优先展开估计值小的。

A* 把这套东西形式化成 f(n) = g(n) + h(n)，其中 g 是从起点到 n 的实际代价，h 是 n 到目标的估计代价。广度优先是 h 恒等于 0 的特例，贪心搜索是只看 h 不看 g 的特例，带权最短路是两者都退化的特例——它们其实是同一个公式的不同参数选择。

import heapq def a_star(start, goal, neighbors, h): """neighbors(node) 返回 [(后继节点, 边代价), ...]；h(node) 返回估计剩余代价""" open_heap = [(h(start), 0, start)] # 堆元素：(f 值, g 值, 节点)，按 f 排序 best_g = {start: 0} # 每个节点已知的最小 g，用于惰性删除过期条目 parent = {start: None} while open_heap: f, g, node = heapq.heappop(open_heap) if node == goal: # 第一次弹出目标即为最优解（前提：h 可采纳） path = [] while node is not None: path.append(node) node = parent[node] return path[::-1] if g > best_g.get(node, float("inf")): continue # 这条是历史遗留的过期堆条目，直接丢弃 for nxt, cost in neighbors(node): ng = g + cost if ng < best_g.get(nxt, float("inf")): best_g[nxt] = ng # 找到更短路径，更新并重开/新开该节点 parent[nxt] = node heapq.heappush(open_heap, (ng + h(nxt), ng, nxt)) return None # open 集耗尽仍无解

三个参数里最关键的是h。它必须满足可采纳性：对任意节点 n，h(n) 都不超过从 n 到目标的真实最小代价。只要这条成立，A* 在树搜索下返回的解一定最优。证明思路是反证：假设 A* 返回了目标 G2，而存在更优解 G1，那么 G1 路径上必有一个节点 n 还在 open 集里；此时 f(n) = g(n) + h(n) ≤ g(G1) < g(G2) = f(G2)，意味着 n 的优先级高于 G2，它应该先被弹出，矛盾。

更实用的一个性质是一致性：h(n) ≤ c(n, n') + h(n')，即估计值沿边不会下降得比实际代价还快。满足一致性时，节点第一次被弹出就是它的最优解，closed 集不需要重开，实现可以简化一半。另外两个容易翻车的点：堆里那些被更新过的旧条目必须用惰性删除过滤掉，否则会重复展开；如果 h 不可采纳但你想保留效率，那得到的是次优解——这一点在做有严格时限的规划时必须提前说清楚。

3.3 有效分支因子：启发式到底省了多少，能不能量化

「启发式好不好」这件事其实可以算出来。定义有效分支因子 b*：设深度为 d 的搜索实际扩展了 N 个节点，解 b*^d = N。盲目搜索时 b* = b；启发式完美时 b* = 1，也就是根本不分支，一路走到底。

举个数：b = 3、d = 20。h 恒为 0 时 N ≈ 3^20 ≈ 35 亿；换成质量不错的 h，b* 能压到 1.3 左右，N ≈ 1.3^20 ≈ 190。同一个问题、同一台机器，节点数差了七个数量级。报告里引用那句「求解效果与启发式函数有关」，机制就在这里——不是「启发式有点用」，而是启发式直接决定了这个问题在工程上可不可解。

这也解释了为什么早期人工智能那么强调搜索：算力极其有限，唯一的杠杆就是把领域知识压缩进 h 里。h 写得越好，需要的算力越少。这条思路后来在棋类程序上被推到极致——评估函数本质上就是 h 的一种，只不过是靠人手工调了几十年，直到被从数据里学出来的函数替代。

4. 知识表示与推理：语义网络、归结原理和专家系统各自补上了哪一段

4.1 语义网络：把知识从「规则表」换成「图」

规则表的问题是它把知识切成了互不相关的条目，条目之间的关系全靠人去维护。语义网络换了组织方式：节点是概念，边是关系。最常用的几条边是 IS-A（下位概念指向上位概念）、has-part（整体到部件）、以及各种领域自定义的谓词。

这种结构的最大好处是继承推理：属性沿 IS-A 边向下传递，只要在「鸟」这个节点上标了「会飞」，那么「麻雀」节点自动获得该属性，不需要再写一条规则。知识在结构上被压缩了，加一个新概念的边际成本很低。

代价也很明确。第一，边没有形式语义，「IS-A」到底表示集合包含、还是表示实例属于、还是表示某种默认关联，全靠约定；不同人画出来的图放在一起会打架。第二，多继承会让继承链出现菱形，两个上位节点对同一属性给出冲突值时，网络本身没办法裁决，只能靠附加的优先级规则。第三，推理的闭包是不可判定的——你没法保证问「这个节点有没有某个属性」时能在有限步内得到确定答案，因为继承链可能很长甚至成环。

和它同期出现的还有产生式规则（IF 条件 THEN 动作，配合前向链或后向链）和框架表示（一个概念对应一个槽结构，槽里填值或填默认值）。三者的分工大致是：产生式擅长过程性知识，语义网络擅长概念之间的静态关系，框架擅长描述一个有内部结构的事物。工程上很少只用一种。

4.2 归结原理：为什么「完备」和「好用」是两件互不蕴含的事

归结原理的核心想法是反证法：要证明命题 P，就先假设 ¬P，把它和已有前提一起化成子句集（每条子句是一组文字的析取），然后反复做消解——如果某条子句含文字 L、另一条含 ¬L，就把这两个文字消掉，剩下的文字合并成新子句。如果最终能推出空子句，说明假设 ¬P 与前提矛盾，于是 P 成立。

def resolve(c1, c2): """命题逻辑消解：c1 含文字 lit，c2 含 ¬lit 时，消去 lit 并合并其余文字。 命题变量用整数编码，取负号表示否定；返回新子句或 None（无法消解）。""" for lit in c1: if -lit in c2: return frozenset((c1 - {lit}) | (c2 - {-lit})) return None # 例：子句 {1, 2}（p 或 q）与 {-1, 3}（非 p 或 r）消解得 {2, 3}（q 或 r） print(resolve(frozenset({1, 2}), frozenset({-1, 3})))

参数上，子句用不可变集合表示便于哈希和去重，lit与-lit的配对靠整数符号自动完成，返回None表示两条子句没有互补文字、不构成消解。一阶逻辑版本还要多做一步「合一」——不是直接比对符号相等，而是找一组变量替换让两个原子公式变得相同，这比命题情形复杂一个量级。

归结原理的地位在报告里被特别强调，说它是「第一个也是目前唯一具有完备性的推理方法」。这句话要准确理解：完备指只要子句集不可满足，就一定能通过有限步消解导出空子句——它不会漏解。但完备性完全不管效率。子句数量在消解过程中会指数膨胀，而且消解本身对公式的书写形式很敏感，换一种等价的写法可能把证明步数从十步拖到一万步。所以工程实践中几乎不会裸用归结：要么加大量的选择策略和删除策略（比如优先消解短子句、丢弃被包含的子句），要么干脆换用针对特定领域的专用算法。

翻成一句话：归结原理解决的是「能不能推出」，工程关心的是「能不能在资源预算内推出」，这两件事之间隔着一整个搜索问题——绕了一圈又回到了第 3 章。

4.3 专家系统的知识获取瓶颈：为什么规则越写越脆

专家系统的结构很清晰：知识库（领域专家的规则集）、推理机（前向链或后向链）、解释模块、人机界面。70 年代提出知识工程的概念，80 年代形成产业，那段时间它几乎是「人工智能落地」的唯一形态。

它撞上的第一个墙叫知识获取瓶颈。领域专家能给出结论，但说不清自己是怎么得出结论的——那些判断依据在长期实践里被压缩成了直觉，人自己都调不出来。知识工程师只能用大量案例去「榨」，一个案例问出几条规则，几百条规则背后是几百次访谈。这活儿没法自动化，成本随规则数量线性上涨。

第二堵墙叫脆断。规则系统的行为在覆盖范围内精确，一旦掉到覆盖范围之外就彻底失效，没有「能力退化」这回事——它不会说「我不确定」，只会给一个错误答案。人类专家遇到没见过的情况会犹豫、会类比、会请求更多信息，规则系统不会。这在低风险场景还能忍，在高风险场景就是致命的。

这也解释了为什么医疗诊断类专家系统在技术上做得相当扎实，投入实际使用却始终困难。诊断建议本身可能很准，但系统给错一次的责任归属、以及「越过它建议」的流程成本，远远超过它带来的平均收益。这不是技术问题，是部署环境的成本结构问题——一份报告如果只写「因为医疗风险大所以难落地」，等于什么都没说；拆开看是脆断特性加上责任归属，两条加起来才构成真正的障碍。

80 年代之后知识工程退潮，表面看是神经网络抢了风头，实际上更直接的原因是：规则库的维护成本随着规模非线性上涨，涨到某个点之后，加新规则的收益抵不过它引入的冲突和回归风险。这个教训在今天的知识库工程里依然成立。

5. 避坑：读这类人工智能综述时最容易踩的五个坑

5.1 五条踩坑记录

第一坑：把「某模型被判死刑」读成「这条路线彻底失败了」。现象是读到 1969 年那本专著系统论证了单层感知机的表达上限、随后神经网络研究进入十几年低谷，就顺手记成「神经网络当年被证明不行」。原因是那句结论有严格的限定条件：被证明的是单层感知机表达不了线性不可分函数（连异或都做不到），不是「多层不行」；当时的真实困境是没有训练多层网络的有效方法，隐层权重拿不到监督信号。解决办法是看到任何「某某被证明不行」的结论，先追问三件事：被否掉的是哪一层、用什么方法训练的、换成什么条件能救。三问答不上来，这条结论就先别往笔记里写。

第二坑：把「搜索」等同于暴力枚举，觉得是老古董。现象是看到报告大篇幅讲搜索法，觉得这是算力不足年代的权宜之计，今天的模型用不上。原因是忽略了启发式这个变量——A* 的实际扩展节点数由有效分支因子决定，不是 b^d 那个上限；h 设计得好，指数问题在实践里能压到接近线性。解决办法是读任何搜索算法，先找它的 h 是怎么来的、满不满足可采纳性，再看复杂度。今天大模型做规划、做检索增强，底层还是这套「生成候选 + 打分排序 + 回溯剪枝」的结构，只是打分函数从手工 h 变成了学出来的模型。

第三坑：把「归结原理是唯一完备的推理方法」读成「它是最强的推理方案」。现象是看到「完备」两个字就默认它全面胜出。原因是完备性只管「有没有解」，不管「多快要到解」；子句集的指数膨胀和形式敏感性是真实存在的成本，裸用归结在稍大的问题上跑不动。解决办法是把「完备性」和「可行性」分成两个独立维度评估：前者是理论保证，后者是工程预算。看到「唯一」「最强」这类表述，先在旁边标一句「在什么维度上」。

第四坑：把专家系统的衰落归因于「知识没用」。现象是读完专家系统那一节，结论变成「符号主义路线走不通，还是数据驱动好」。原因是真正卡住它的是知识获取与维护的边际成本，再加上规则系统的脆断特性——覆盖范围内精确、范围外直接失效且不自知。知识本身价值极高，问题是搬进机器的通路太窄。解决办法是评估这类系统时看两个指标：加一条新规则的边际成本，以及掉出覆盖范围时的行为。这两个指标比演示效果有用得多。

第五坑：把符号主义和连接主义当成两条互斥路线去站队。现象是读完历史，下意识把它归类为「旧路线输给了新路线」。原因是两者解决的根本不是同一个层次的问题——符号层管显式、可解释、可追溯的推理；连接层管从数据里长出表示，负责感知和模式。它们的强项几乎不重叠。解决办法是看今天的实际系统：底层是神经表示，上层挂检索、工具调用、规则约束、结果校验，全是符号化的东西。所谓「谁赢了」这个问题本身就问错了层次。

5.2 用一个最小实验自己验证：单层为什么连异或都做不了

上面第一坑值得亲手验一遍，成本不到一分钟。

import numpy as np X = np.array([[0,0],[0,1],[1,0],[1,1]], dtype=float) y = np.array([0,1,1,0], dtype=float) # 异或：两类点无法用一条直线分开 # 两层结构：隐层先把输入搬到可分空间，输出层再做线性划分 np.random.seed(0) W1 = np.random.randn(2, 4); b1 = np.zeros(4) # 隐层 4 个神经元 w2 = np.random.randn(4); b2 = 0.0 lr = 0.1 for _ in range(20000): h = np.tanh(X @ W1 + b1) # 隐层：非线性映射 out = h @ w2 + b2 # 输出层：线性组合 d = out - y # 输出层误差 gw2 = h.T @ d / len(X); gb2 = d.mean() dh = np.outer(d, w2) * (1 - h**2) # 误差回传：乘 tanh 的导数 gW1 = X.T @ dh / len(X); gb1 = dh.mean(0) w2 -= lr * gw2; b2 -= lr * gb2 W1 -= lr * gW1; b1 -= lr * gb1 pred = ((np.tanh(X @ W1 + b1) @ w2 + b2) > 0.5).astype(float) print(pred, (pred == y).all())

把隐层去掉、只留out = X @ w + b再跑一遍，你会发现无论训练多久、学习率怎么调，误差都下不去。原因不是训练不够，是表达力不足：单层结构的决策边界只能是一条直线，而异或需要两条。注意dh那一行里的(1 - h**2)——它是把输出层误差摊回隐层的必经之路，没有它，隐层权重拿不到任何梯度信号。这正是第二坑和第一坑的汇合点：受限的不是「神经网络」这个概念，而是「没有隐层」和「不知道隐层怎么调」这两件事。

6. 连接主义的复活与路线取舍：为什么「调隐层权重」这一步卡了二十年

卡住的那二十年，问题的准确描述是信用分配：输出层错了，误差好算，直接和期望值相减；但隐层的每个权重该负多少责任？隐层神经元的输出没有对应的「标准答案」，人没法给它标一个目标值。没有目标值就没有误差，没有误差就没法更新。

1986 年那套方法的突破点，是把链式法则用在了这张计算图上。输出层的误差按权重比例往回摊，摊到隐层时再乘上该层激活函数的导数，得到隐层的等效误差；这个过程可以一层层往前推，任意深度都成立。两行公式概括全部：

# 输出层误差：预测减标签，乘激活导数 delta_out = (a_out - y) * sigmoid_prime(z_out) # 隐层误差：把后一层的误差按权重加权回来，再乘本层激活导数 delta_hidden = (delta_out @ W_out.T) * sigmoid_prime(z_hidden) # 权重更新：本层输入的外积 W_hidden -= lr * (a_in.T @ delta_hidden) / batch_size

本文还有配套的精品资源，点击获取