强化学习GridWorld实战：值迭代vs策略迭代，哪个算法收敛更快？（Python代码对比）

强化学习GridWorld实战：值迭代vs策略迭代，哪个算法收敛更快？（Python代码对比）

在强化学习的经典算法中，值迭代(Value Iteration)和策略迭代(Policy Iteration)都是基于动态规划的解决方案。这两种算法都能找到最优策略，但它们的实现方式和收敛特性却大不相同。本文将在一个具体的GridWorld环境中，通过Python代码实现和实验对比，深入分析这两种算法的性能差异。

1. GridWorld环境搭建与问题定义

GridWorld是强化学习中常用的教学环境，它模拟了一个网格世界，智能体(agent)可以在其中移动并获取奖励。我们先定义一个7x8的网格环境：

import numpy as np import matplotlib.pyplot as plt class GridWorld: def __init__(self): self.grid = np.array([ [0, 0, 0, 0, 0, -1, 0, 0], [0, 0, 0, -1, 0, 0, 0, 5], [0, 0, 0, -1, -1, 0, 0, 0], [0, 0, 0, -1, -1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0] ]) self.start_state = (6, 0) # 起点在左下角 self.goal_state = (1, 7) # 目标在右上角 self.current_state = self.start_state

在这个环境中：

• 0表示可通行的格子
• -1表示障碍物（撞墙会获得-1的奖励）
• 5是目标格子（到达获得+5奖励并结束回合）
• 其他格子移动获得0奖励

智能体有四个可能的动作：上(0)、右(1)、下(2)、左(3)。如果动作会导致撞墙，则保持原地不动。

2. 算法原理与实现对比

2.1 值迭代算法

值迭代的核心思想是直接优化值函数，通过贝尔曼最优方程迭代更新：

V(s) ← max_a [R(s,a) + γΣP(s'|s,a)V(s')]

Python实现如下：

def value_iteration(env, gamma=0.9, theta=1e-6): V = np.zeros(env.grid.shape) policy = np.zeros(env.grid.shape, dtype=int) while True: delta = 0 for i in range(env.grid.shape[0]): for j in range(env.grid.shape[1]): if (i,j) == env.goal_state: continue v = V[i,j] max_value = -float('inf') for action in range(4): next_i, next_j, reward = env.get_next_state((i,j), action) new_value = reward + gamma * V[next_i, next_j] if new_value > max_value: max_value = new_value policy[i,j] = action V[i,j] = max_value delta = max(delta, abs(v - V[i,j])) if delta < theta: break return V, policy

值迭代的特点：

• 直接操作值函数，不显式维护策略
• 每次迭代对所有状态进行更新
• 收敛条件是值函数变化小于阈值θ

2.2 策略迭代算法

策略迭代分为两个交替进行的步骤：策略评估和策略改进。

1. 策略评估：固定策略π，计算其值函数Vπ 2. 策略改进：根据Vπ更新策略π'

Python实现核心部分：

def policy_iteration(env, gamma=0.9, theta=1e-6): # 初始化随机策略 policy = np.random.randint(0, 4, size=env.grid.shape) V = np.zeros(env.grid.shape) while True: # 策略评估 while True: delta = 0 for i in range(env.grid.shape[0]): for j in range(env.grid.shape[1]): if (i,j) == env.goal_state: continue v = V[i,j] action = policy[i,j] next_i, next_j, reward = env.get_next_state((i,j), action) V[i,j] = reward + gamma * V[next_i, next_j] delta = max(delta, abs(v - V[i,j])) if delta < theta: break # 策略改进 policy_stable = True for i in range(env.grid.shape[0]): for j in range(env.grid.shape[1]): if (i,j) == env.goal_state: continue old_action = policy[i,j] max_value = -float('inf') for action in range(4): next_i, next_j, reward = env.get_next_state((i,j), action) new_value = reward + gamma * V[next_i, next_j] if new_value > max_value: max_value = new_value policy[i,j] = action if old_action != policy[i,j]: policy_stable = False if policy_stable: break return V, policy

策略迭代的特点：

• 显式维护并改进策略
• 策略评估阶段需要完全收敛
• 通常比值迭代更快收敛到最优策略

3. 实验设计与性能对比

为了系统比较两种算法的性能，我们设计以下实验：

3.1 收敛速度对比

我们固定折扣因子γ=0.9，比较两种算法达到收敛所需的迭代次数：

注意：策略迭代的"迭代次数"指外部循环次数，每次内部策略评估也需要多次迭代

3.2 计算时间对比

在同一硬件环境下，运行100次取平均时间：

3.3 不同γ值下的表现

改变折扣因子γ，观察收敛迭代次数的变化：

从实验结果可以看出：

1. 策略迭代通常比值迭代收敛更快
2. 随着γ增大（更重视远期奖励），两种算法都需要更多迭代
3. 策略迭代在γ接近1时优势更明显

4. 算法选择建议与实战技巧

根据实验结果和实际经验，我们总结以下建议：

4.1 何时选择值迭代

• 状态空间非常大时，值迭代可能更合适，因为：
  • 不需要完整策略评估
  • 每次迭代计算量较小
• 当只需要近似解时，值迭代可以提前终止
• 实现相对简单，调试容易

4.2 何时选择策略迭代

• 中等规模问题中，策略迭代通常更快收敛
• 当需要精确策略时，策略迭代能保证收敛到最优
• 可以结合以下加速技巧：
  • 不完全策略评估（设置宽松的收敛条件）
  • 异步更新策略（不必等全部状态评估完）

4.3 实用优化技巧

对于两种算法都适用的优化方法：

1. 初始化技巧：

   # 乐观初始化可以加速收敛 V = np.ones(env.grid.shape) * np.max(env.grid) / (1 - gamma)

2. 异步更新：

   • 不按固定顺序更新状态
   • 优先更新变化大的状态

3. 并行计算：

   from multiprocessing import Pool def update_state(args): i, j, V, gamma = args # 状态更新逻辑 return i, j, new_value # 在值迭代中使用 with Pool() as p: results = p.map(update_state, [(i,j,V,gamma) for i,j in states])

4. 收敛条件调整：

   • 前期使用宽松条件
   • 后期逐步收紧

5. 可视化分析与案例研究

为了更好地理解两种算法的行为差异，我们进行可视化分析。

5.1 值函数收敛过程

��迭代的值函数变化：

# 记录每次迭代后的值函数 plt.figure(figsize=(12,6)) for i in range(0, 100, 10): plt.subplot(2,5,i//10+1) plt.imshow(V_history[i], cmap='hot') plt.title(f'Iter {i}') plt.colorbar() plt.show()

策略迭代的策略改进过程：

# 可视化策略变化 for i, policy in enumerate(policy_history): plt.figure() plot_policy(policy) plt.title(f'Policy Iteration {i}') plt.show()

5.2 实际路径对比

从同一起点出发，两种算法得到的最优策略生成的路径：

虽然最终策略等价，但收敛过程不同：

• 值迭代前期路径变化较大
• 策略迭代的路径变化更平稳

5.3 大规模GridWorld测试

将网格扩大到20×20，障碍物比例增加到30%：

在大规模问题中，策略迭代的优势更加明显，但内存消耗也更大。