以下数字为教学示例,不构成对任何真实系统或供应商的承诺。
Agent 的奖励有两种给法:只在任务结束时给一个值(轨迹/稀疏奖励),或每一步按进展给一点(过程/塑形奖励)。稀疏奖励干净,但学习信号稀薄,Agent 要走很多次才知道什么是对的;过程奖励信号密集,但设计错了会奖励错误的行为。
这一节用一个取钥匙开门的走廊任务比较三种信号。任务很小,可以精确复现:走廊 0..5,起点在 4,钥匙在 1,门在 5。必须先取钥匙再开门,否则开门失败。
三种信号的差异
| 信号 | 给法 | 信号密度 | 风险 |
|---|---|---|---|
| 稀疏 | 只在终点给 ±1 | 极低 | 学得慢 |
| 进度 | 终点奖励 + 势能差 | 高 | 势能方向要正确 |
| 原地奖励 | 给"不动"发奖励 | 高 | 会奖励停住 |
稀疏和进度都是"合法的塑形",区别在密度;原地奖励是坏的塑形——它给了 Agent 一个"不前进也有奖励"的出口,Agent 立刻学会停在那里。
势能塑形为什么有效
进度信号用势能函数给中间状态赋值:没钥匙时,势能 = 离钥匙越近越高;有钥匙时,势能 = 离门越近越高。每一步的奖励 = 势能变化:
$$r_{\text{step}} = r_{\text{terminal}} + \beta \cdot \left[\phi(s’) - \phi(s)\right]$$
势能差的性质是:它只对"朝目标走"给正分,对"走开"给负分,而且不与最终奖励冲突——这正是"好的塑形"的定义。势能塑形加快了学习,因为中间每一步都携带了"这个方向对不对"的信息。
关键要看到势能函数用了子目标(钥匙、门):它把"先取钥匙再开门"的顺序知识编码进了奖励。没有钥匙时朝门走,势能不增反降,Agent 学到的是"顺序错了"。
坏的塑形:给原地等待发奖励
stay_bonus 信号给"stay 动作且未到终点"额外 +0.2。听起来是在鼓励"不要盲目乱动",实际效果是:Agent 学会了在起点 4 一直 stay。因为 stay 每步都有 +0.2 奖励,还不会触发失败的 -1;比冒险探索更"划算"。
这就是奖励塑形最危险的地方:任何"额外奖励"都是可以被 Agent 专门优化的信号。你以为在引导行为,Agent 找到的是奖励的机器——停在原地刷奖励。这条教训和 7.3 的验证器漏洞是同一个原理,发生在奖励层。
最小实验:三种信号的学习
下面的实验在走廊任务上用固定种子跑表格 Q-learning,每 10 回合检查一次贪心策略,记录首次成功所需回合数与最终策略路径。
# file: agp_lab/reward_shaping.py | write
# tier: 3
# verify: python3 -m unittest tests.test_reward_shaping
"""轨迹奖励与过程奖励:稀疏、进度塑形与错误塑形。
走廊 0..5,起点在 4,钥匙在 1,门在 5:必须先取钥匙再开门。三种信号
分别是:只在终点给 ±1、在终点奖励上叠加“朝当前子目标前进”的进度
奖励、以及给“原地等待”发过程奖励。实验比较学习速度与最终策略。
"""
from __future__ import annotations
import random
STATES = tuple(range(6))
START = 4
KEY = 1
GOAL = 5
ACTIONS = ("left", "right", "stay")
SIGNALS = ("sparse", "progress", "stay_bonus")
def step(state: int, action: str) -> int:
if action == "right":
return min(GOAL, state + 1)
if action == "left":
return max(0, state - 1)
if action == "stay":
return state
raise ValueError(f"未知动作: {action}")
def progress(state: int, has_key: bool) -> float:
"""进度势函数:没钥匙时朝钥匙走,有钥匙时朝门走。"""
target = GOAL if has_key else KEY
return -abs(target - state) / GOAL
def reward(signal: str, state: int, action: str,
next_state: int, has_key_before: bool) -> float:
"""has_key_before 是动作执行前是否已持钥匙。"""
has_key_after = has_key_before or next_state == KEY
terminal = 0.0
if next_state == GOAL:
terminal = 1.0 if has_key_after else -1.0
if signal == "sparse":
return terminal
if signal == "progress":
return terminal + 0.1 * (
progress(next_state, has_key_after) - progress(state, has_key_before)
)
if signal == "stay_bonus":
return terminal + (0.2 if action == "stay" and next_state != GOAL else 0.0)
raise ValueError(f"未知信号: {signal}")
def _state_index(state: int, has_key: bool) -> int:
return state + len(STATES) * int(has_key)
def train(
signal: str,
episodes: int,
alpha: float = 0.5,
gamma: float = 0.9,
epsilon: float = 0.2,
seed: int = 7,
steps: int = 30,
) -> list[list[float]]:
"""固定种子的表格 Q-learning;状态索引 = 位置 + 是否持钥匙。"""
if episodes < 0:
raise ValueError("episodes 不能为负")
rng = random.Random(seed)
q = [[0.0 for _ in ACTIONS] for _ in range(2 * len(STATES))]
for _ in range(episodes):
state = START
has_key = False
for _ in range(steps):
row = q[_state_index(state, has_key)]
if rng.random() < epsilon:
index = rng.randrange(len(ACTIONS))
else:
best = max(row)
ties = [i for i, value in enumerate(row) if value == best]
index = rng.choice(ties)
action = ACTIONS[index]
next_state = step(state, action)
next_has_key = has_key or next_state == KEY
next_row = q[_state_index(next_state, next_has_key)]
target = reward(signal, state, action, next_state, has_key)
if next_state != GOAL:
target += gamma * max(next_row)
row[index] += alpha * (target - row[index])
state = next_state
has_key = next_has_key
if state == GOAL:
break
return q
TIE_ORDER = {"right": 0, "stay": 1, "left": 2}
def greedy_rollout(q: list[list[float]], limit: int = 30) -> tuple[list[int], bool]:
"""按贪心策略从起点走一遍;并列时偏好前进,返回路径与是否成功。"""
state = START
has_key = False
path = [state]
for _ in range(limit):
row = q[_state_index(state, has_key)]
best = max(row)
index = min(
(i for i, value in enumerate(row) if value == best),
key=lambda i: TIE_ORDER[ACTIONS[i]],
)
state = step(state, ACTIONS[index])
has_key = has_key or state == KEY
path.append(state)
if state == GOAL:
return path, has_key
return path, False
def episodes_to_success(signal: str, checkpoint: int = 10, maximum: int = 300) -> int | None:
"""每 checkpoint 回合检查一次贪心策略,返回首次成功所需回合数。"""
for episodes in range(checkpoint, maximum + 1, checkpoint):
q = train(signal, episodes)
if greedy_rollout(q)[1]:
return episodes
return None
if __name__ == "__main__":
print(f"{'signal':<13}{'first_success':>14} path")
for signal in SIGNALS:
first = episodes_to_success(signal)
path, ok = greedy_rollout(train(signal, 300))
shown = str(first) if first is not None else "never"
print(f"{signal:<13}{shown:>14} {'-'.join(map(str, path))} ok={ok}")
运行:
cd private/labs/agp-lab
python3 -m agp_lab.reward_shaping
输出:
signal first_success path
sparse 20 4-3-2-1-2-3-4-5 ok=True
progress 10 4-3-2-1-2-3-4-5 ok=True
stay_bonus never 4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4-4 ok=False
这张表是三件事的直观证据。
进度塑形把首次成功从 20 回合提前到 10。 同样的任务、同样的算法,只有奖励信号不同。稀疏信号要 20 回合才学会;进度信号 10 回合就学会了。势能差让每步都带方向信息,学习的信号从"终点才知道"变成"每步都知道"。
两条成功路径完全相同。 sparse 和 progress 都收敛到 4-3-2-1-2-3-4-5:先走到钥匙 1,再折返到门 5。势能塑形没有改变最终策略,只是让它更快到达——好的塑形改变学习速度,不改变最优解。这可以当作一条检验:如果塑形后策略变了,说明塑形方向错了。
坏的塑形学会的是"停住"。 stay_bonus 的路径是 30 步全在 4,ok=False。它一次都没有取钥匙、没有接近门,因为停在 4 每步都有 +0.2,永远最优。这个结果不是"学不会",而是学会了一个更省力的"解决方案"——刷奖励。判断一个塑形好不好,要看它会不会创造一个比"完成任务"更简单的奖励路径。
过程奖励的判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 方向正确 | 朝子目标势能升 | 给"不动"也发奖 |
| 不改变最优 | 塑形后策略不变 | 塑形后行为走样 |
| 有子目标知识 | 钥匙、门编码进势能 | 只奖励"移动"本身 |
| 单调合法 | 势能差方向与目标一致 | 局部奖励与终点奖励打架 |
| 可审计 | 每步奖励可回放 | 奖励来源黑盒 |
“不改变最优"是硬检验:塑形只能加速收敛,不能把 Agent 引到新的、不是原任务最优的路径上。发现塑形后策略变了,先怀疑塑形,再怀疑任务定义。
架构含义
奖励设计对架构有三个直接约束:
- 奖励函数与策略解耦。 奖励是系统的观测数据,不是模型的一部分;改奖励不重训模型。
- 塑形要声明来源。 势能函数、每个奖励项的含义要文档化,能审计为什么给这个分。
- 要检查奖励捷径。 上线前用固定策略跑一遍,看是否存在"刷奖励"路径。
第 3 条是过程奖励独有的防线:给 Agent 学习或选优的自由度之前,先确认没有比"好好做"更省力的得分方式。
与三条工作负载的关系
- W2 代码修复:进度奖励可以按"测试通过数、编译通过"给,但要注意别奖励"只跑测试不改代码”。
- W1 检索问答:进度奖励按"引用命中"给,容易奖励堆引用而不答问题。
- W3 运维处置:进度奖励高度危险,每步都可能触碰不可逆动作;通常不该用过程奖励。
W3 尤其要小心:过程奖励鼓励"多做几步",但运维处置里多做的步骤可能就是错误步骤。对不可逆负载,稀疏奖励或直接判定更安全。
小结
- 奖励要么在终点给(稀疏),要么按进展给(过程塑形)。
- 势能塑形用子目标编码顺序知识,只改变学习速度,不改变最优解。
- 坏的塑形会制造"比完成任务更省力的奖励路径":给原地发奖,Agent 就停在原地。
- 判断塑形好坏的一条硬检验:塑形后策略是否改变。
- 奖励函数是系统的观测数据,要和策略解耦、来源可审计。
- 不可逆负载要慎用过程奖励,稀疏奖励或直接判定更安全。
阅读导航:上一节:10.3 放弃与澄清:什么时候不该调用 · 下一节:11.2 归因方法:反事实、Shapley 与启发式 。
常见错误与边界
- 给"动起来"发奖。 奖励移动本身,Agent 会来回动而不靠近目标。
- 塑形改变最优。 好的塑形只加速收敛;策略变了说明塑形方向错。
- 奖励来源黑盒。 说不清为什么给分,就无法审计刷奖励路径。
- 对不可逆负载用过程奖励。 鼓励多做一步,可能就是多做错一步。
- 忽略奖励捷径。 上线前不跑固定策略,发现不了"停在原地刷分"。
- 把奖励绑进模型。 奖励是系统的数据,改奖励不应重训模型。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。