下面通过一个简单的“迷宫寻宝”例子，用伪代码和Python代码对比直接策略搜索（以PPO为例）和基于值函数的方法（以Q-Learning为例）的核心区别。
问题场景：迷宫寻宝
- 环境：3x3网格迷宫，起点(0,0)，宝藏在(2,2)，障碍物在(1,1)
- 动作：上下左右（离散动作空间）
- 奖励：到达宝藏+100，撞墙（出界或碰障碍物）-10，其他情况0
- 目标：学习从起点到宝藏的最短路径
一、核心区别对比（伪代码）
二、具体代码实现对比
1. 基于值函数的方法（Q-Learning）
import numpy as np# 1. 环境初始化
# 3x3网格：0=空，1=障碍物，2=宝藏；状态用(s_row, s_col)表示
obstacle = (1,1)
treasure = (2,2)
states = [(i,j) for i in range(3) for j in range(3) if (i,j)!=obstacle]
actions = [0,1,2,3] # 0=上,1=下,2=左,3=右# 2. 初始化Q表（状态-动作价值表）
Q = {}
for s in states:Q[s] = {a:0.0 for a in actions} # 初始价值均为0# 3. 超参数
alpha = 0.1 # 学习率（更新Q值的幅度）
gamma = 0.9 # 折现因子
epsilon = 0.1 # 探索率（10%概率随机选动作，90%选Q值最大的动作）
episodes = 1000 # 训练回合数# 4. Q-Learning训练
for _ in range(episodes):s = (0,0) # 起点while s != treasure: # 直到找到宝藏# 选动作：ε-贪婪策略（基于Q表选动作）if np.random.random() < epsilon:a = np.random.choice(actions) # 随机探索else:a = max(Q[s], key=Q[s].get) # 选Q值最大的动作（利用）# 执行动作，得到下一状态和奖励row, col = sif a==0: new_s = (row-1, col) # 上elif a==1: new_s = (row+1, col) # 下elif a==2: new_s = (row, col-1) # 左else: new_s = (row, col+1) # 右# 判断奖励和是否撞墙if new_s not in states: # 出界或撞障碍物reward = -10new_s = s # 留在原地elif new_s == treasure:reward = 100else:reward = 0# 更新Q值（核心：用TD误差修正价值）# TD目标 = 即时奖励 + 折现后的下一状态最大Q值td_target = reward + gamma * max(Q[new_s].values())# TD误差 = 目标与当前Q值的差距td_error = td_target - Q[s][a]# 更新当前Q值Q[s][a] += alpha * td_errors = new_s # 进入下一状态# 5. 测试策略（基于Q表的贪婪策略）
print("Q-Learning学到的策略：")
s = (0,0)
path = [s]
while s != treasure:a = max(Q[s], key=Q[s].get) # 直接选Q值最大的动作row, col = ss = [(row-1,col), (row+1,col), (row,col-1), (row,col+1)][a]path.append(s)
print("路径：", path)
2. 直接策略搜索（PPO简化版）
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim# 1. 环境初始化（同Q-Learning）
obstacle = (1,1)
treasure = (2,2)
states = [(i,j) for i in range(3) for j in range(3) if (i,j)!=obstacle]
actions = [0,1,2,3] # 0=上,1=下,2=左,3=右
state2idx = {s:i for i,s in enumerate(states)} # 状态转索引（用于网络输入）# 2. 定义策略网络（直接参数化策略）
class PolicyNet(nn.Module):def __init__(self):super().__init__()self.fc = nn.Linear(2, 4) # 输入：状态坐标(s_row, s_col)，输出：4个动作的对数概率def forward(self, s):# s是坐标 tuple，转换为张量x = torch.tensor(s, dtype=torch.float32)logits = self.fc(x) # 未归一化的概率return torch.softmax(logits, dim=0) # 输出动作概率分布（和为1）# 3. 初始化策略和优化器
policy = PolicyNet()
optimizer = optim.Adam(policy.parameters(), lr=0.01) # 梯度上升（通过Adam优化器实现）# 4. 超参数
gamma = 0.9
episodes = 1000
epsilon_clip = 0.2 # PPO剪辑系数# 5. PPO训练
for _ in range(episodes):# 采样轨迹（用当前策略收集数据）trajectories = []s = (0,0)rewards = []actions_taken = []while s != treasure:# 选动作：从策略网络的概率分布中采样（直接依赖策略参数）action_probs = policy(s) # 得到4个动作的概率a = torch.multinomial(action_probs, 1).item() # 按概率采样动作# 执行动作（同Q-Learning）row, col = snew_s = [(row-1,col), (row+1,col), (row,col-1), (row,col+1)][a]if new_s not in states:reward = -10new_s = selif new_s == treasure:reward = 100else:reward = 0# 记录轨迹trajectories.append((s, a))rewards.append(reward)actions_taken.append(a)s = new_s# 计算优势函数（简化版：用累积奖励作为优势）G = 0advantages = []for r in reversed(rewards): # 从后往前计算累积奖励G = r + gamma * Gadvantages.insert(0, G)advantages = torch.tensor(advantages, dtype=torch.float32)advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8) # 中心化# PPO更新：限制策略更新幅度old_probs = []for s, a in trajectories:with torch.no_grad(): # 固定旧策略old_prob = policy(s)[a] # 旧策略选该动作的概率old_probs.append(old_prob)old_probs = torch.tensor(old_probs)# 多轮优化（离线更新）for _ in range(3):new_probs = []for s, a in trajectories:new_prob = policy(s)[a] # 新策略选该动作的概率new_probs.append(new_prob)new_probs = torch.tensor(new_probs)# 策略比率：新概率/旧概率ratio = new_probs / old_probs# 剪辑目标函数（PPO核心）surr1 = ratio * advantagessurr2 = torch.clamp(ratio, 1-epsilon_clip, 1+epsilon_clip) * advantagesloss = -torch.min(surr1, surr2).mean() # 负号：因为优化器是梯度下降，转为最小化负损失# 梯度下降更新策略参数（等价于梯度上升最大化奖励）optimizer.zero_grad()loss.backward()optimizer.step()# 6. 测试策略（从策略网络采样动作）
print("PPO学到的策略：")
s = (0,0)
path = [s]
while s != treasure:with torch.no_grad():action_probs = policy(s)a = torch.argmax(action_probs).item() # 选概率最大的动作row, col = ss = [(row-1,col), (row+1,col), (row,col-1), (row,col+1)][a]path.append(s)
print("路径：", path)
三、核心区别总结
-
优化对象不同：
- Q-Learning优化的是“状态-动作价值表”，通过修正价值来间接指导策略；
- PPO优化的是“策略网络参数”，直接调整选动作的概率分布。
-
策略生成方式不同：
- Q-Learning的策略是“确定性”的（选Q值最大的动作）；
- 直接策略搜索的策略是“随机性”的（按概率分布采样动作，后期概率会集中到最优动作）。
-
更新逻辑不同：
- Q-Learning用“TD误差”（目标价值与当前价值的差距）更新价值；
- 直接策略搜索用“策略梯度”（奖励对参数的导数）更新参数，本质是让高奖励的动作被选中的概率增加（梯度上升）。
-
适用场景不同：
- Q-Learning适合离散动作空间（如迷宫寻宝的上下左右）；
- 直接策略搜索适合连续动作空间（如机器人关节角度控制）。
通过代码可以直观看到：Q-Learning的核心是一张记录“动作好不好”的表，而直接策略搜索的核心是一个直接决定“选哪个动作”的概率模型。
