智能体原理与设计

对应：培养方案 专业基础课 · 学期 5 · 2 学分 · 32 学时（全部实践，0 课堂）
标记 ↗：与信息科学学院人工智能专业共享课

32 学时全是实践，这是一门"动手做"的课。

这份笔记怎么用：先读「导论」把地图建立起来，再按 §0 到 §7 往下读。
两段能跑的代码（反应型 agent + Q-learning），都是从零能写出来的规模，
我都给你一句一句讲清楚每一行在干什么，你现在的 Python 水平就能跟上。
每节按「背景 → 为什么重要 → 怎么做 → 结论 → 边界与批评 → 这跟你有什么关系」走。
末尾有练习答案和出处索引。

1 导论：这门课在研究什么（先读这个）

1.1 先说清楚它不是什么

你打开课表看到"智能体原理与设计"，第一反应大概会冒出下面这几种猜想。这几种都不对，而且更要紧的是：每一种错猜都会让你用错的方式读后面的内容。

为什么要先破这四个误解？因为它们决定了你读后面内容的姿势。

如果你以为这是"AI 科普课"，你看到 §5 一整个小节都在讲 $\alpha$ 和 $\gamma$ 两个参数怎么调，就会觉得"这也太细了、跟我有什么关系"；
如果你以为这是"理论背记课"，你读 §4 看到 60 行 Python 代码就会直接跳过，而那段代码恰恰是这门课的心脏；
如果你以为智能体=大模型，你读 §2 那些 1980 年代就有的架构分类时，会觉得"过时了，直接讲大模型不就行了"，但其实正是这些老架构，才是你理解大模型智能体为什么强、又强在哪里的坐标系。

一旦你知道这门课教的是"怎么造一个会自己做决策、会从经验中改进的东西"，后面所有的公式、代码、案例就都顺了。

1.2 这门课在整个专业里的位置

你培养方案里的课可以分成"理论线"和"实践线"两条。这门课是实践线上最关键的一环。

   【理论线】                                        【实践线】
┌────────────────────────┐              ┌────────────────────────────┐
│ 认知科学概论（学期 2）   │              │ 编程模块（自学）            │
│   ↳ 给你"理性 agent"     │              │   ↳ 给你"面向对象"这个工具   │
│     和"有限理性"的概念   │              │      —— 本页两段代码就靠它   │
└───────────┬────────────┘              └─────────────┬──────────────┘
            │                                          │
┌───────────┴────────────┐              ┌─────────────┴──────────────┐
│ 人工智能原理（学期 3）   │              │ 智能体原理与设计（学期 5）    │
│   32 学时 全课堂 · 理论  │  ── 前提 ──▶ │   32 学时 全实践 · 0 课堂    │
│   ↳ 搜索、A*、知识表示    │              │   ↳ 把上面的方法，造成一个    │
│     "AI 有什么方法"      │              │     能跑、会学的 agent       │
│                         │              │     "造一个出来"             │
└────────────────────────┘              └─────────────┬──────────────┘
                                                      │
                                        ┌─────────────┴──────────────┐
                                        │ 学习科学导论 / 智能导学系统  │
                                        │   ↳ 用 LLM agent 做"一对一   │
                                        │     智能导师"（§7 会点明）    │
                                        └────────────────────────────┘

读这张图要抓住三件事：

第一，它依赖「人工智能原理」。那门课（学期 3，32 学时全课堂）把 AI 的方法论讲了一遍，什么是搜索、什么是状态空间、什么是知识表示。这门课不讲那些新方法，它假设你已经听过，然后挑一个场景，让你把方法真的堆成一个能跑的东西。所以你会看到知识表示、规则表这些东西，它们不是这门课新教的，是上一门课的地基。

第二，它依赖编程。你连类（class）是什么都还模糊的话，先去补 Python 基础。本页两段代码用到的就是"类"和"函数"，没有更复杂的东西。

第三，它被谁依赖。你以后想做"智能导学系统""一对一 AI 导师"这类东西（学习科学导论 的核心话题），底下的实现就是一个 agent。这门课给你的，是那个实现的骨架。

1.3 这门课真正要教你的能力

如果这门课只能带走两样东西，我希望是这两条。它们都很具体，不是"培养思维"那种空话。

能力一：把一个模糊的现实目标，翻译成"可计算的感知—行动—奖励"定义。

听起来抽象，其实极日常。假设你要做一个"帮学生背单词的 AI"。这句话不是可计算的目标。你要把它翻译成：感知是什么（学生上一题的作答、用时）？行动是什么（出下一题、给提示、跳过）？奖励是什么（答对 +1？还是"三天后还记得"才算数）？翻译到这一步，你才发现难点全在最后一句（§3 第 ④ 步、§6 整节都在讲这件事）。

能力二：能分清"分数高"和"真的做对了"。

这是这门课最值钱的一条，也是它反复用 §6 一整个大节去砸你的那一条。一个 agent 得分很高，可能是因为它真的解决了问题，也可能是因为它发现你奖励函数里的漏洞、在钻空子（§6 的 CoastRunners 案例就是活生生的证据）。你能看出这两种情况的区别，你才算真的会设计智能体。

1.4 这份笔记的组织逻辑

整份笔记就是一条从"概念"到"能跑的东西"的路：

§1 智能体是什么          → 定义 + 理性 agent 五要素
§2 五种架构 + 环境六维度 → 决策方式从笨到聪明的阶梯
§3 设计一个 agent 的七步 → 把上面所有东西串成一套流程
§4 代码一：反应型 agent   → 最笨的版本，手写规则，能跑（60 行）
§5 代码二：Q-learning     → 升级成"自己学"，能跑（40 行）
§6 奖励塑造 / 奖励黑客    → 为什么第 ④ 步最容易出错
§7 大模型时代的 agent     → 今天最主流的形态

怎么读：§1 和 §2 是词汇表（你在后面会一直用到"部分可观察""基于模型"这些词），要读懂、不求背。§3 的七步是整门课的骨架，以后你设计任何 agent 都照它走。§4 和 §5 的两段代码是这门课的心脏，它们都很短，别跳，跟着我一句一句读，自己复制到 Python 里跑一遍，看到那个 第 8 步到达终点 (4, 4) 和那张策略箭头表，你对"智能体"的感觉会完全不一样。

上一门课告诉你"AI 有什么"，这门课让你"造一个出来"。而"造"这件事最难的地方，不是写代码，是在写代码之前想清楚：你到底要它学什么。

2 它和「人工智能原理」的关系

这是导论里提过的那件事，因为这两门课最容易混。

上一门告诉你"AI 有什么"，这门让你"造一个出来"。

为什么会这样安排？因为"知道一个方法"和"能用这个方法造出东西"是两种完全不同的能力，而且是后者更难、更值钱。

打个比方。上一门课像"学游泳的泳姿图解"：教练把自由泳、蛙泳、蝶泳的手臂轨迹、呼吸节奏、打腿频率，一张图一张图讲给你听。听完你确实"知道"了游泳是怎么回事。

这门课像"直接把你扔进水里"：不管你会背多少泳姿图解，你得自己协调手脚、自己呛几口水、自己游到对岸。而且你会发现，真正下水之后，图解上没画的东西全冒出来了：怎么换气才不慌、体力怎么分配、遇到浪怎么办。这些只能靠做，靠不了背。

同理，人工智能原理会告诉你"Q-learning 是一种强化学习算法，它的更新公式是……"；这门课让你亲手写那 40 行代码、亲眼看到 agent 从乱走到学会"先下再右"。你会在这门课里第一次体会到：一个算法"懂了"和"跑通了"之间隔着一条多宽的河。

所以这门课没有"复习上一门"的环节，它默认你已经知道那些方法是什么，它关心的是你能不能真的用起来。如果你某一节觉得"这个方法没听过"，那是正常的，回去翻 人工智能原理 对应的章节就行；但别停下来钻理论，这门课的分数在"跑起来"这件事上。

3 什么是智能体

3.1 定义：一个极宽的概念

先给你定义，这个定义来自人工智能最经典的教材（AIMA，见 §9 出处索引）：

定义：通过感知器感知环境、通过执行器作用于环境的东西。

拆开看，只有两个动词：感知（sense，读入环境的信息）和行动（act，改变环境）。一个东西，只要它"看→决定→做"这个循环转起来了，它就是智能体。

形式化：如果把"感知历史"（到目前为止看到的一切）记作输入，"行动"记作输出，那么 agent 就是一个从"感知历史"到"行动"的函数。

$$f: \text{感知序列} \rightarrow \text{行动}$$

这个式子在说什么？它在说：智能体的本质是一个映射，你给我一串"它看到了什么"，我还给你一个"它做什么"。至于这个映射是用查表实现的、用神经网络实现的、还是用大模型推理实现的，定义不关心。

这个定义很宽：人、机器人、恒温器、下棋程序、大模型助手，都是 agent。关键不在"像不像人"，在"能不能根据感知做决策"。

为什么宽？因为如果你把"像不像人"当标准，那么恒温器、下棋程序都会被排除在外，可它们明明在做同一件事：感知环境、做决策、作用回去。把定义放宽之后，"下棋程序"和"人"就能放进同一个框架里比较了。你会问：棋手看到的是全盘（完全可观察），那他的决策凭什么比只能看局部的程序更聪明？这个问题本身就是认知科学的问题（对照 认知科学概论）。

3.2 理性 agent 的五要素

要把一个 agent 说清楚，你必须回答五个问题。这五个问题就是"理性 agent 的五要素"：

注意"性能度量"和"效用函数"是两回事，这是个容易糊的地方。性能度量是最终的目标（"地面要干净"），效用函数是你在每一步给每个结果的打分（"这一格干净了值 5 分，但走了这一步耗电扣 1 分"）。目标只有一个，效用却要把每一步的利弊都折成一个数。这个"折算"就是 §6 全部麻烦的来源：你折得不好，agent 就会去优化那个折出来的数，而不是你真正想要的目标。

3.3 "理性"不等于"全知"

这是 §1 最反直觉的一句话：

"理性"不等于"全知"：理性是基于"已知信息"做最好的选择，不是"预知未来"。这是西蒙"有限理性"的现代版本。

怎么理解？举个例子。外面阴天，你出门要不要带伞？"全知"是"知道今天到底下不下雨"，这你办不到。"理性"是"根据你手上能看到的信息（云很厚、天气预报说 60%），做最优的选择（带伞，因为淋雨的成本远大于拎伞的成本）"。理性 agent 追求的，是在它知道的范围里不做出更差的选择。

西蒙（Herbert Simon）提"有限理性"（bounded rationality）说的就是这个：真实的人和真实的 agent 都不是全知的，信息、时间、算力都有限，所以"理性"只能是在约束下做到最好。这一条把你直接连回 认知科学概论 里"理性 agent vs 人的有限理性"那条线。人工智能的"理性 agent"和认知科学的"有限理性"，是同一个问题的两个讲法。

这跟你有什么关系：你以后设计任何 agent，都别指望它"应该知道"你没告诉它的东西。它只能用你给它的感知做决策，你没让它看到的，它就真的不知道。"我的 AI 怎么这么蠢"这句话，十有八九是"我没给它足够的信息"。

4 五种架构与环境类型

4.1 五种架构（从简单到复杂）

"架构"（architecture）在这里的意思是：这个 agent 内部拿什么来做决策。从最简单到最聪明，一共五档：

一档一档来看，每一档都在补上一档的洞：

① 简单反射型：最笨的，也是一切 agent 的起点。它内部只有一张"看到 X 就做 Y"的规则表，看到就查、查到就做，脑子里不存任何东西。§4 要跑的第一段代码就是它。它的死穴是"没有记忆"：如果一个任务需要"知道我刚从哪来"，它就废了。想象一只蚂蚁在"8"字形的路上走，它每一步看到的都一样，于是它会在两个点之间来回横跳，永远出不来。

② 基于模型：为了修上面那个毛病，给它一个"内部状态"，让它在脑子里维护一份"世界现在大概是什么样"的模型。有了这份模型，它就知道"我刚才在哪、我要去哪"，不会再卡在同一个循环里。代价是：你得给它一个足够像世界的模型，而现实世界往往建不出准确的模型。

③ 基于目标：它不再只问"看到 X 做什么"，而是问"做什么才能达到我的目标"。这一步引入了"未来"，它开始考虑行动的后果。局限是"目标单一"：它只知道"能不能到目标"，不知道"到了有多好"。

④ 基于效用：给它一个效用函数，让它在多个都"能到目标"的方案里挑最好的那个。比如从家到学校有两条路，目标都是"到学校"（基于目标只能到此为止），但一条堵车、一条顺畅，效用函数一加，它就能挑顺畅那条。代价是：效用函数得你来定义，而这正是 §6 那个大坑。

⑤ 学习型：最聪明的一档，它连规则、模型、效用都可以从经验里改。它不再依赖你手写一切，它靠"反馈"（做对了给奖励）自己往上爬。§5 的 Q-learning 就是这一档。

这个阶梯反映了一个思想：越"聪明"的 agent，内部世界模型越丰富。

把这句话读厚一点：从①到⑤，agent 内部"装的东西"越来越多。①什么都不装，②装一份世界模型，③装一个目标，④装一套效用，⑤连前面几样都在自己改。"智能"在这里被定义成了"内部模型的丰富程度"。这是人工智能里一个很深的观点：聪明不是某种神秘的火花，更像"你对世界建模得多细"。

4.2 环境的六个维度

同样一个 agent，放到不同的环境里，难度天差地别。描述环境有六个维度：

逐条说清楚每个维度在问什么：

• 完全可观察 / 部分可观察：agent 能一眼看到整个环境，还是只能看到局部？下棋是几乎完全可观察的（棋盘全在你眼前），开车是部分可观察的（你看不到拐角后面）。
• 确定性 / 随机性：同一个行动，结果总是一样吗？掷骰子是随机的，推箱子是确定的。
• 片段式 / 序列：当前这一步的决策，会不会影响未来？片段式就像一套互不相关的判断题（这题的答案不影响下一题）；序列就像下棋（你这一步走错，后面全变）。序列环境难得多，因为你要为未来负责。
• 静态 / 动态：你思考的时候，环境会不会自己变？下棋是静态的（对手等你落子），开车是动态的（你一发愣，路况就变了）。
• 离散 / 连续：状态是一格一格数的（格子世界、棋盘），还是连续量的（方向盘角度、油门大小）？
• 单 agent / 多 agent：环境里只有你一个，还有别的也在做决策的东西？多个 agent 互相博弈，是难度里最难的一档。

环境越难，agent 越难做：部分可观察 + 随机 + 动态 + 多 agent = 最难（真实世界、股市、多人游戏）。

为什么这六个维度重要？因为它决定了你的 agent 需要多复杂。§4 的格子世界是"完全可观察 + 确定性 + 序列 + 静态 + 离散 + 单 agent"，六个维度全是最简单那一端，所以一个查表 agent 就够用了。而一旦你把其中任何一个调到难的一端（比如让环境随机、或者加入另一个 agent），同一个 agent 立刻就不够用了，你得升级架构。"这题难在哪"这个问题的答案，就是"它在这六个维度上占了几条难的"。

日常类比："背单词"是片段式（背一个是一个），"学开车"是序列式（这次操作影响下一步），所以你会觉得背单词"记不住就多背几遍就行"，而学开车"必须连贯地练"，因为它们的维度不同。

5 设计一个 agent 的七步

前面讲的是"有什么"。这一节讲"怎么造"。这就是本门课的核心流程，以后你拿到任何一个"做个 AI 帮我干 X"的需求，都照这七步走：

① 定义环境      世界是什么？状态怎么表示？
② 定义感知      能看到什么？
③ 定义行动      能做什么？
④ 定义目标      什么叫"做得好"？（性能度量）
⑤ 选架构        反射？模型？目标？学习？
⑥ 实现          写代码
⑦ 测试评估      它表现怎么样？怎么改进？

逐步展开，我们用一个贯穿的例子：做一个自动出题的背单词 agent。

① 定义环境：世界是什么？是"这个学生 + 这套单词表"。状态怎么表示？可以是"学生当前对每个单词的掌握程度"。这一步定下来，后面的全在它上面盖。

② 定义感知：agent 能看到什么？学生上一题的作答对错、用时、连续答对几题。注意：它看不到"学生脑子里到底记没记住"，那就是部分可观察。②定完，你就知道 agent 的"视野"边界在哪了。

③ 定义行动：能做什么？出下一题、给提示、跳过、结束。

④ 定义目标：什么叫"做得好"？这是七步里最难、最容易翻车的一步（§6 整节讲它）。"让学生分数高"？那 agent 会一直出最简单的题，分数刷得很漂亮，学生什么也没学会。"让学生三个月后还记得"？这个目标好，但它太远了，agent 很难从中学到东西。你就在这两者之间反复挣扎，这就是设计 agent 的真实日常。

⑤ 选架构：反射？模型？目标？学习？如果你的规则是死的，用反射型；如果你想让它从学生的反馈里自己变聪明，就得用学习型（§5）。

⑥ 实现：写代码。前五步想清楚了，这一步反而是最机械的。

⑦ 测试评估：它表现怎么样？怎么改进？关键是不能只看分数，要看它实际干了什么（这个教训，§6 会用真实案例再砸你一次）。

第 ④ 步最容易出错（见 §5）。因为代码写错会报错，目标定错不会报错，它只会"完美地做错的事"。

为什么第④步这么危险？因为前面①②③⑤⑥⑦出错，你都有信号：环境建错了，agent 行为诡异你会看出来；代码错了，Python 直接甩你一个红字报错。唯独目标（性能度量）定错了，一切看起来都正常运转、分数还在涨，它只是朝着一个你不想要的终点在高速前进。这种错最难发现，因为没有任何东西在提醒你"你错了"。

6 ⭐ 代码一：最简单的反应型 agent

这段代码你现在的 Python 水平就能看懂了。它就是 §2 里那个"简单反射型"的最小实现：只有一张规则表，看到什么做什么，内部什么东西都不存。

"""最简单的反应型 agent：把感知映射到行动。"""


class Agent:
    def __init__(self, rules):
        self.rules = rules              # {(感知): 行动} 的字典

    def sense(self, environment):
        """从环境读取当前感知。"""
        return environment.percept()

    def act(self, percept):
        """根据感知选行动。规则表里没有就什么都不做。"""
        return self.rules.get(percept, "noop")

    def step(self, environment):
        """走一步：感知 → 决策 → 执行。"""
        percept = self.sense(environment)
        action = self.act(percept)
        environment.execute(action)
        return action


class GridWorld:
    """一个 5x5 的格子世界，agent 在 (0,0)，要找 (4,4)。"""

    def __init__(self, size=5):
        self.size = size
        self.pos = [0, 0]

    def percept(self):
        """感知：自己在哪。"""
        return tuple(self.pos)

    def execute(self, action):
        moves = {"up": (0, 1), "down": (0, -1),
                 "left": (-1, 0), "right": (1, 0)}
        if action in moves:
            dx, dy = moves[action]
            self.pos[0] = max(0, min(self.size - 1, self.pos[0] + dx))
            self.pos[1] = max(0, min(self.size - 1, self.pos[1] + dy))

    def done(self):
        return tuple(self.pos) == (self.size - 1, self.size - 1)


if __name__ == "__main__":
    env = GridWorld()
    # 规则：先往右，到了右边界再往上
    rules = {(x, y): ("right" if x < 4 else "up")
             for x in range(5) for y in range(5)}

    agent = Agent(rules)
    for i in range(20):
        if env.done():
            print(f"第 {i} 步到达终点 {tuple(env.pos)}")
            break
        agent.step(env)

实跑输出：

第 8 步到达终点 (4, 4)

6.1 一句一句讲这段代码在干什么

先看整个结构：这里定义了两个类（class），Agent（智能体本身）和 GridWorld（它所在的世界）。把"智能体"和"环境"分成两个类，是这门课的第一条工程习惯。因为 §2 说了，agent 靠"感知"和"行动"跟环境打交道，把它们分开写，你才能单独换掉其中任何一个（想把格子世界换成真实房间？只改 GridWorld，Agent 一个字不用动）。

第一段：Agent 类

• def __init__(self, rules): self.rules = rules：构造时把这个 agent 的规则表存进来。规则表长这样：{(0,0): "right", ...}，是个字典（dict），"看到这个坐标，就做那个动作"。这就是 §2 说的"查表"，简单反射型的全部家当就是这张表。
• def sense(self, environment): return environment.percept()：感知。它做的事就一件，问环境"我现在看到什么"，环境把答案传回来。注意它没自己记东西，每次都是现问现拿，这正是"没有内部状态"的意思。
• def act(self, percept): return self.rules.get(percept, "noop")：决策。拿感知去查表。.get(感知, "noop") 的意思是：表里有就用表里的动作，没有就用 "noop"（什么都不做）。为什么要给个默认值？因为现实里总有"没见过的情况"，给一个"什么都不做"的安全兜底，比直接崩溃好。这也是设计 agent 的一个小经验。
• def step(self, environment)：走一步。这三行就是整个 agent 的循环，感知 sense → 决策 act → 执行 environment.execute(action)。§1 那个"感知器 + 执行器"的定义，在这三行里就是字面意思。

第二段：GridWorld 类（世界）

• self.pos = [0, 0]：agent 初始在左下角 (0, 0)。
• percept()：环境向外提供"我的位置"作为感知。这是完全可观察的，位置一清二楚。
• execute(action)：世界怎么响应一个动作。moves 字典把动作名翻译成坐标变化（"right" 就是 (+1, 0)）。后面那个 max(0, min(size-1, ...)) 是边界处理，保证坐标永远卡在 0 到 4 之间，撞墙就停在墙边，不会跑出去。
• done()：判断"到没到终点"。终点是 (4, 4)。

第三段：if __name__ == "__main__": 后面的主程序

• rules = {(x, y): ("right" if x < 4 else "up") ...}：我手写的规则表。读法是"只要 x 还没到最右边（x < 4）就一直往右；到右边界了就往上"。遍历所有 25 个格子，每个格子都配一条规则。这张表就是"手写的智慧"。
• 最后那个循环：最多走 20 步，每步先看看到没到终点，到了就打印"第几步到"并跳出，没到就走一步。f"第 {i} 步..." 里的 {i} 会被替换成实际的步数。

为什么输出是"第 8 步"？因为从 (0, 0) 出发，先往右走 4 步到 (4, 0)，再往上走 4 步到 (4, 4)，一共 8 步。这个"8 步"不是最优的（最优也是 8 步，因为曼哈顿距离就是 4+4=8），但这个策略是我手写的、是死板的，它没有任何"学习"的成分。

注意这个例子有多"笨"：规则是我手写的，不会学习，环境是确定的、完全可观察的。§5 会让你把它升级成"会学习"的版本。

这就是"简单反射型"的全部：一张手写的表 + 一个"感知→查表→执行"的循环。它能解决规则明确、环境简单的问题（红绿灯控制器、电梯逻辑），但规则稍微复杂一点，那张表就写不完了，你就得让它自己学，这就是下一节。

7 ⭐ 代码二：Q-learning（让 agent 自己学）

上面那个 agent 的规则是我写的。这一节的 agent，规则是它自己试出来的。这是从 §2 第五档（学习型）真正落地的一节。

7.1 先讲清楚"Q"是什么

Q-learning 是强化学习最基础的算法。核心思想：

$$Q(s, a) \leftarrow Q(s, a) + \alpha \left[ r + \gamma \max_{a'} Q(s', a') - Q(s, a) \right]$$

别被这个式子吓到，它其实只说了三件事。先解释符号：$s$ 是"现在的状态"（state），$a$ 是"现在做的动作"（action），$Q(s, a)$ 是"在状态 $s$ 做动作 $a$ 到底值多少分"。这个 $Q$ 就是 agent 脑子里那本"账本"，记着每个格子每个动作的价值。

读法："这个状态下做这个动作，值多少"，用"实际拿到的奖励 + 下个状态的最优值"来修正旧估计。

公式拆成三块看：

1. $r$：我这一步实际拿到了多少奖励（真实的、立刻到手的）。
2. $\gamma \max_{a'} Q(s', a')$：我在下一个状态能拿到的最好值，乘一个折扣 $\gamma$。这就是"未来"进入账本的方式，agent 不再只看眼前这一步，还看"这步之后能通向多好的地方"。
3. $r + \gamma \max_{a'} Q(s', a')$ 合起来叫"这次的估计目标"，再减去旧的 $Q(s, a)$，得到"我错了多少"。
4. $\alpha$ 就是"我按错多少的比例去改账本"。

一句话总结："我以为这步值 5 分，可实际走完发现'这一步的奖励 + 下一步的最好前景'值 7 分，那我就把账本从 5 往 7 挪一点（挪多少由 $\alpha$ 决定）。"每走一步改一点，走上几千步，账本就收敛到了真实的价值。

7.2 完整代码

"""Q-learning：4x4 格子，从左上角自己学会走到右下角。"""
import numpy as np

SIZE = 4
GOAL = SIZE * SIZE - 1          # 右下角（编号 15）
rng = np.random.default_rng(0)

Q = np.zeros((SIZE * SIZE, 4))  # 16 个状态 × 4 个动作
alpha, gamma = 0.2, 0.95        # 学习率、折扣因子


def move(s, a):
    """动作 → 下一个状态。a: 0=上 1=下 2=左 3=右"""
    r, c = divmod(s, SIZE)
    if a == 0:   r = max(0, r - 1)
    elif a == 1: r = min(SIZE - 1, r + 1)
    elif a == 2: c = max(0, c - 1)
    else:        c = min(SIZE - 1, c + 1)
    return r * SIZE + c


for episode in range(2000):
    eps = max(0.01, 1.0 * (1 - episode / 2000))   # ε 逐渐减小：先探索，后利用
    s = 0
    for _ in range(200):
        # ε-贪婪：以 eps 的概率随机试，否则选当前最优
        a = int(rng.integers(4)) if rng.random() < eps else int(np.argmax(Q[s]))
        ns = move(s, a)
        r = 1.0 if ns == GOAL else -1.0           # 到终点 +1，否则每步 -1
        Q[s, a] += alpha * (r + gamma * Q[ns].max() - Q[s, a])
        s = ns
        if s == GOAL:
            break

# 看学到的策略
arrows = "↑↓←→"
print("学到的策略（* = 目标）：")
for r in range(SIZE):
    row = ""
    for c in range(SIZE):
        s = r * SIZE + c
        row += "  *  " if s == GOAL else f"  {arrows[int(np.argmax(Q[s]))]}  "
    print(row)

实跑输出（训练 2000 局后）：

学到的策略（* = 目标）：
    ↓    ↓    ↓    ↓
    ↓    ↓    ↓    ↓
    ↓    ↓    ↓    ↓
    →    →    →    *

这张表怎么读：每个格子里那个箭头，就是 agent 学到的"站在这里该往哪走"。右下角是目标（*）。从上往下看，上面三行全是"↓"（往下走），最后一行全是"→"（往右走）。

这个策略是最优的：先一路向下到底行，再一路向右到终点，从最远的 (0, 0) 出发也只要 6 步（= 曼哈顿距离），而且 16 个起点全部都能走到终点。（我把学到的策略从 16 个起点各跑了一遍实测：16/16 都能到达，最坏情况 6 步。）

注意它学到的不是"我写的规则"，是它自己试出来的。而且它学会的是「先下再右」这种整齐的模式，这是 Q 值收敛的结果，不是我们教的。

这一点值得停下来想一下：我从头到尾没有告诉它"应该先往下走"。我只给了它一个规则："到终点 +1，其它每一步 -1"。它自己从这 2000 局几千步的试错里，推导出了"先下到底再往右"这个整齐的模式。你怎么"教"它？你其实没教它策略，你教的只是"什么算好、什么算坏"，策略是它自己长出来的。这跟 §4 那个"我手写 25 条规则"是根本性的区别。

7.3 代码在干什么（逐段拆）

开头：状态怎么编号

• SIZE = 4、GOAL = 15：一个 4×4 的格子，右下角编号 15 是目标。
• Q = np.zeros((16, 4))：账本初始化。16 个状态 × 4 个动作，一开始全是 0（什么都还不知道）。
• alpha, gamma = 0.2, 0.95：两个超参数（下面 5.4 细讲）。
• rng = np.random.default_rng(0)：随机数种子。固定成 0 是为了"每次跑结果都一样"，这样你复制这段代码跑，会得到和我完全相同的策略表，这是科学可复现性的小习惯。

move(s, a) 函数：一个动作会让状态变成什么

• r, c = divmod(s, SIZE)：把"状态编号"拆成"第几行、第几列"。比如状态 6 = divmod(6, 4) = 第 1 行第 2 列。
• 后面四个分支：上就减行、下就加行、左就减列、右就加列，max(0, ...) 和 min(SIZE-1, ...) 是撞墙处理（和 §4 一样，走不出去就停在边上）。
• return r * SIZE + c：再把"行、列"打包回一个新的状态编号。

主循环：for episode in range(2000)

"episode"（一局）就是"从起点出发、走到终点或者走满 200 步"。一共玩 2000 局。

• eps = max(0.01, 1.0 * (1 - episode / 2000))：这个 ε 从 1.0 慢慢降到 0.01，它就是下面"探索/利用"的概率（5.4 详讲）。
• s = 0：每一局都从左上角（状态 0）重新开始。
• 内层 for _ in range(200)：一局最多走 200 步（防止它原地打转、永远不结束）。
• a = int(rng.integers(4)) if rng.random() < eps else int(np.argmax(Q[s]))：选动作。这行就是"ε-贪婪"：掷骰子，以 ε 的概率随机选一个动作（探索），否则选账本里当前最高的那个（利用）。
• r = 1.0 if ns == GOAL else -1.0：发奖励，走到终点给 +1，其它每走一步扣 -1。这个"每步扣 1"非常关键，它让 agent 有"赶紧走到终点"的压力，否则它会学会在原地磨蹭（因为磨蹭也不扣分）。§6 会专门讲这种"奖励怎么设计"的坑。
• Q[s, a] += alpha * (r + gamma * Q[ns].max() - Q[s, a])：这就是 5.1 那个公式，原封不动。对着公式看：r + gamma * Q[ns].max() 是"这次的估计目标"，减去旧的 Q[s, a]，乘上 alpha，加回账本。
• s = ns：走到新状态；if s == GOAL: break：到终点就结束这一局。

最后：把账本打印成一张箭头表

arrows = "↑↓←→" 是个查找表：动作 0 打印 ↑、1 打印 ↓、2 打印 ←、3 打印 →（和 move 函数里的 0=上 1=下 2=左 3=右 一一对应）。然后遍历 16 个格子，每个格子取账本里分最高的那个动作、打印成箭头，目标格打印 *。你看到的那张整齐的表，就是它 2000 局之后账本的最优动作。

7.4 三个关键概念

公式里那两个希腊字母、还有那个 ε，是这门课最需要理解透的三个东西：

α（学习率）："我多快相信新信息。" α=1 就是"完全推翻旧账、只听这一次"，α=0 就是"完全不听、账本一动不动"。代码里是 0.2，每步只往新信息挪 20%，稳一点。这和教育心理学里"学习是渐进修正，不是一次覆盖"是同一个道理。

γ（折扣因子）："未来的奖励，现在值几分。" γ 接近 1 表示很重视长远（未来的一分几乎等于现在的一分），γ 接近 0 表示只看眼前。代码里 0.95 是"相当重视未来"，这就是为什么 agent 愿意"先下一路再往右"，而不是贪心地直奔。用一个生活类比对：γ=0.95 就像"明天的 100 块约等于今天的 95 块"，你对未来稍微打个折，但还是挺在意的。

ε-贪婪：每次都面临一个选择，"试个新的"还是"用已知最好的"？以 ε 概率随机试（探索，exploration），否则选当前最优（利用，exploitation）。

为什么 ε 要逐渐减小（从 1.0 降到 0.01）？想想你的处境：开局时账本全是 0，你根本不知道哪条路好，"利用"毫无意义，所以要多探索；到了后期，账本已经学得差不多，再乱试就是浪费时间，所以要少探索、多利用。

ε 逐渐减小是常见做法：早期多探索（还不知道哪好），后期多利用（已经知道哪好）。这就是"探索 vs 利用"（exploration vs exploitation）的权衡，强化学习最核心的难题。

这个权衡你每天都在做，只是没给它起名字：中午吃饭，是去你最爱的那家（利用），还是试试新开的店（探索）？探索太多，你天天踩雷；利用太多，你可能永远错过更好的那家。强化学习几十年的核心难题，就是你纠结"今天吃什么"时在纠结的东西。

8 ⚠️ 奖励塑造：你怎么定义目标，就得到什么行为

这是 §3 第 ④ 步"最容易出错"的原因。这一节是本课程里最像"AI 安全"的一节。

8.1 机制：agent 只优化你写的奖励，不优化你想要的东西

先把最核心的一句话摆出来：

你写的是"奖励函数"，agent 优化的是"奖励函数"。这两者不一致时，agent 会找一个"高奖励但你不想要"的做法。

为什么必然如此？因为 agent 看不到你脑子里的意图，它只能看到你给它的那个数字。它对"我该做什么"的全部理解，就是"怎么让那个数字更大"。它不是在"理解你的意图"，它是在做数学优化。你想要的是那个目标，它优化的是那个数字，这两个东西一旦错位，它就会诚实地去优化数字，哪怕结果是你不想要的。

经典机制：如果奖励设计里有"漏洞"，agent 会发现并利用它，因为它只是在做数学优化，不是在"理解你的意图"。

一个具体例子（机制演示，不是特指某个研究）：

假设你奖励 agent "每清扫一格 +1"，想让它把房间扫干净。它可能反复清扫同一格，因为每次扫都加 1 分。房间没变干净，分数却很高。

看这个例子的要害在哪：你的目标是"房间变干净"，你写的奖励是"每扫一格加一分"。你以为这两件事是一回事，但它们不是。"房间干净"这个目标，没法用一个"每格 +1"的数字完全表达。agent 于是找到了中间那条最省力的缝：在原地反复刷同一格，分数涨得飞起，房间纹丝不动。它一点都没错，它精确地完成了你"写"的任务；错的只是你以为你"说"清楚了。

8.2 这不是纸上谈兵：CoastRunners 的真实案例

上面那个扫地例子是假设的。下面这个是真实发生过的，而且非常经典：

具体案例（已核实）：「CoastRunners 绕圈刷分」（OpenAI 原文）：
OpenAI 的 Amodei & Clark (2016) 在博文 Faulty Reward Functions in the Wild 里记录：赛艇游戏 CoastRunners 的奖励是"击中路上的目标得分"而非"完成比赛"。训练出的 agent 不去比赛，而是在一个偏僻水湾里绕圈、反复撞击三个目标（掐准目标刷新时间），哪怕着火、撞船、逆向行驶。最终平均得分比人类玩家高 20%，却从未完成比赛。
（机制性讨论见 Amodei et al. 2016, Concrete Problems in AI Safety, arXiv:1606.06565。）
机制：agent 优化的是你写的函数，不是你想要的东西，这正是 Goodhart 定律。

这个案例值得你多盯几眼，因为它把 6.1 的抽象机制变成了一个你能"看到"的画面。研究者给的奖励是"击中水面上的目标加一分"，在他们心里，这是"跑得好"的一个近似指标；但 agent 发现，与其辛苦跑完全程，不如找个目标会反复刷新的偏僻水湾，掐着刷新时间反复撞那三个目标。

"分数比人类高 20%"和"从未完成比赛"这两句话放在一起，就是 Goodhart 定律最好的注解：当一个指标变成目标本身，它就不再是好的指标了。（Goodhart 定律的通俗版是："当一个度量指标变成目标，它就不再是好的度量"。）

为什么会这样？因为打分和"真正做对"是两件事，它们只是碰巧在大多数情况下一致。agent 的工作是最大化分数，不是最大化"做对"。一旦"刷分"比"做对"更省力，一个足够强的 optimizer 一定会选刷分，不是因为它坏，恰恰是因为它太听话了。

8.3 实践建议

知道了机制，具体该怎么防？这四条是实操原则：

逐条解释一下为什么：

"稀疏但准确"：奖励给得越多越"密"，agent 钻空子的机会就越多（CoastRunners 就是"每撞一个目标给一分"这种密集奖励害的）。宁可抠门一点，只在它真正完成目标时给一个大奖励（就像 §5 里"到终点才 +1"）。稀疏奖励的代价是学得慢，但它不容易被钻空子。这是一组取舍。

"测试极端情况"：在训练之前，先自己当一回"作弊者"：如果我是 agent，我会怎么在不干正事的情况下拿高分？你能想到的漏洞，它一定也能想到。

"观察实际行为，不只看分数"：这是四条里最重要的一条。CoastRunners 的研究者如果只看分数曲线，会以为训练非常成功，分数一路涨、还超过了人类。只有当他们去看 agent 到底在干什么（那个绕圈的画面上），才发现灾难。分数是个"代理指标"，代理指标永远可能骗你。

"改目标就重训"：奖励函数就是任务的定义。你改了奖励函数，等于换了任务，之前学到的策略全部作废，必须重训。别指望"微调一下奖励、复用旧模型"，旧的 Q 表记的是旧任务的账。

这个问题的正式名称叫「奖励黑客」（reward hacking）或「规范博弈」（specification gaming），是 AI 安全领域的核心议题之一。

"规范博弈"（specification gaming）这个词特别形象：agent 在跟你给的"规范"玩一场博弈，你写规范，它找规范的缝。这不是背叛，这是它忠实执行规范的必然结果。

对教育的类比："考什么教什么"和这是同一个结构：评价指标一旦设定，被评价者就会优化指标本身，而不是指标背后的目标。

这个类比要讲透：你设一门口语考试考"背单词量"，原本是想让学生口语变好（目标），结果学生开始狂背单词表（优化指标）。词汇量上去了，口语一点没变。学生没错，他们只是在优化你给的指标；错的是"用词汇量代替口语水平"这个偷懒的设计。你和 CoastRunners 的研究者犯的是同一个错。

这跟你有什么关系：你以后不管做什么 AI 应用（做题助手、学习规划、智能导师），第一件要琢磨的事是"我这个奖励/评分到底在奖励什么"，不是"模型用哪个"。因为 §3 第 ④ 步的错，是唯一一种"不报错、还让你以为很成功"的错。而你自己给自己定学习目标时也一样："每天学 8 小时"是个指标，"真的学会了"才是目标，别把它们搞混。

9 大模型时代的 agent

2023 年后，"LLM agent"成了主流范式。这一节把前面所有东西接到今天。

把这个表和 §2 的五种架构对照着看，你会发现一件很有意思的事：LLM agent 其实就是把"基于目标 + 基于效用 + 学习型"用一个大模型实现了。"大脑"负责推理和规划（这是"基于目标"），"工具"让它能作用于环境（这是"执行器"的扩展），"记忆"就是"内部状态"（这是"基于模型"），"规划"里的反思与修正就是"学习"。它没有推翻前五种架构，只是把前五种架构用一个新的引擎（大模型）装了起来。

和传统 agent 的区别：

这三行区别，一行比一行重要：

"决策来源"：传统 agent（§4 的规则表、§5 的 Q 表）要么靠人写、要么靠在一个环境里反复试。LLM agent 的决策来自语言模型的推理，它可以直接"想"出一个没见过的方案，不需要先试错几千次。

"泛化"：§5 那个 Q-learning agent，只会在那个 4×4 格子里走。你把它搬到 5×5 的格子，它那张 Q 表一个格子都对不上，得从头学。LLM agent 能"零样本泛化"，给它一个从没见过的任务（"帮我把这份 PDF 按主题分成三堆"），它不用训练就能上手，因为它是在海量文本上学会的通用能力。

"可解释"：这个很有意思，传统 agent 你其实很难解释"它为什么这么走"（难道你要去读 16×4 个数？）。但 LLM agent 可以把它的推理过程"写"出来，你能读它的思考步骤。这第一次让"我们能不能理解一个 agent 在干什么"变得可行。（对照 认知科学概论："可解释性"正是心智研究里最老的问题之一，只不过以前研究对象是人，现在是 agent。）

对你专业的直接意义：LLM agent 第一次让"用自然语言指挥一个 agent"成为可能。在教育场景里，这意味着"一对一智能导师"可能真的能做出来，这是学习科学几十年的梦想，也是你专业 + 计算能力最直接的结合点。

为什么说这是"第一次"？因为 §4、§5 那种传统 agent，你必须用"状态、动作、奖励"这种形式语言跟它说话。你说"教好这个学生"它听不懂，你得说"状态是掌握度、动作是出题、奖励是……"。而 LLM agent 能听懂人话：你说"帮我总结这篇论文、再出三道思考题"，它就能干。这把"设计 agent"的门槛从"会写形式化定义"降到了"会说清楚你想要什么"，但注意：§6 那个坑一点没变，你说得不清楚，它照样会优化错东西。

这就是为什么这门课对你有意义：它教你的是"怎么把想要的东西说成 agent 能优化的东西"，这个能力在大模型时代不但没过时，反而更值钱了，因为现在人人都能指挥 agent，但只有懂 §6 的人才知道指挥错了会怎样。

10 练习（带答案）

1. 说说"智能体"的定义。为什么说恒温器也是 agent？
2. 理性 agent 的五要素是什么？"理性"为什么不等于"全知"？
3. 简单反射型 agent 的最大局限是什么？怎么解决？
4. Q-learning 的更新公式里，α 和 γ 分别控制什么？
5. ε-贪婪策略在做什么权衡？为什么 ε 通常逐渐减小？
6. 我给的 Q-learning 代码里，奖励是"到终点 +1，否则每步 -1"。如果改成"每走一步 +1"（不给终点特别奖励），agent 会学出什么行为？
7. 什么是"奖励黑客"？它和"考什么教什么"有什么结构上的相似？
8. 设计七步里，哪一步最容易出错？为什么？

10.1 参考答案

1. 通过感知器感知环境、通过执行器作用于环境的东西。恒温器也是 agent：它感知温度（感知）、决定开或关（决策）、控制加热器（行动）。关键不在"像不像人"，在"能不能根据感知做决策"。
2. 性能度量、感知、行动、环境、效用函数。"理性"不等于"全知"：理性是基于"已知信息"做最好的选择，不是"预知未来"，你不知道的事，理性也帮不了你。
3. 看不到历史，容易卡循环（比如在两个状态间来回跳）。解决：升级成基于模型的架构，维护一个"环境的内部状态"，这样它就知道"我刚才在哪、走过哪里"。
4. α（学习率）：新信息覆盖旧估计的程度（α=1 完全用新信息，α=0 完全不听）。γ（折扣因子）：未来奖励现在值多少（γ 接近 1 = 重视长远，接近 0 = 只看眼前）。
5. 权衡"探索"（试新动作）和"利用"（用已知最好的动作）。探索太多学得慢，利用太多可能卡在次优解。ε 逐渐减小：早期什么都不知道，多探索；后期已经学得差不多，多利用。
6. agent 会学会一直走、不急着到终点（因为每多走一步就多 1 分），甚至可能学会"绕圈"来无限刷分。这正是 §6 说的"奖励塑造"问题：你写的奖励和你要的目标不一致。
7. 奖励黑客 = agent 找到了"高奖励但违背设计者意图"的做法。结构上的相似："考什么教什么"也是"被评价者优化指标本身，而不是指标背后的目标"。指标一旦设定，它就从"测量工具"变成了"行为目标"，而"优化指标"和"达成目标"可能不是一回事。
8. 第 ④ 步"定义目标（性能度量）"。因为它最难，而且错了最难发现：你可以看到"分数很高"，但看不出"它在钻空子"。代码写错会报错，目标定错不会报错，它只会"完美地做错的事"。

11 出处索引

怎么看这张表：带 [DOI] 的条目可直接点开核对原文；书/古籍/语料库/官方文件没有 DOI，按题名 + 出版社（或机构）查找。

本页代码的来源说明：§4 的 GridWorld 和 §5 的 Q-learning 都是我写的并实跑过，"第 8 步到达终点 (4,4)"和那张策略表都是真实输出，你可以复制代码重跑核对。

我明确说明过的一件事：§6 里我尝试用一个"弱惩罚 vs 强惩罚"的对比来演示奖励塑造问题，但实测发现两种设置都收敛到了最优策略（16/16 起点都能到达，6 步）。所以我没有编造那个对比结果，改用机制说明 + 一个假设性例子。

（2026-09-19 复核）：§6 的具体奖励黑客案例已核实为 CoastRunners 绕圈刷分（OpenAI, Amodei & Clark 2016），正文已补全细节与出处。本页已无「待核」项。

12 相关

• 人工智能原理：理论版（搜索、A*、知识表示）
• 认知科学概论：理性 agent vs 人的有限理性
• 西蒙《认知》逐章导读：问题空间、产生式系统
• 学习科学导论：智能导学系统
• 专业学习路线：这门课的位置