Dyna-Q 算法
1. 从无模型学习到基于模型的规划
上一章的 Sarsa 与 Q-learning 都是无模型(model-free)方法:它们直接从真实转移 更新价值,不显式学习环境如何变化。Dyna-Q 在 Q-learning 旁增加一个由真实样本学习的环境模型,再用模型生成模拟转移进行规划,因此构成了从无模型学习到基于模型强化学习的最小桥梁。
强化学习算法有两个重要的评价指标:一个是算法收敛后的策略在初始状态下的期望回报,另一个是样本复杂度,即算法达到收敛结果需要在真实环境中采样的样本数量。基于模型的方法可以额外与模型交互,通常减少真实环境样本需求;但模型误差会被规划过程放大,策略最终回报未必优于无模型方法。这一权衡也会延续到后文的 MBPO。
2. Dyna-Q
Dyna-Q 是一种经典的基于模型的强化学习算法,它通过结合真实经验和模拟经验来提升学习效率。如图所示,该算法的核心在于引入了一种称为 Q-planning 的机制,利用学习到的环境模型生成模拟数据,并将这些数据与真实交互数据共同用于策略优化。
在 Q-planning 过程中,算法执行以下步骤:
- 状态-动作选择:从已访问 过的状态集合中随机选取一个状态 ,并在该状态曾经执行过的动作中随机选择一个动作 ;
- 模型预测:利用环境模型 预测转移后的状态 和即时奖励 :
- 价值更新:使用 Q-learning 方法更新动作价值函数 : 其中 为学习率, 为折扣因子。
通过反复执行 Q-planning 步骤,Dyna-Q 在保持样本效率的同时,有效利用模型知识加速策略收敛。
Dyna-Q 算法在每次与环境进行真实交互并执行一次 Q-learning 更新后,会进行 次 Q-planning 过程。其中 Q-planning 的次数 是一个预先设定的超参数,当 时,算法退化为标准的 Q-learning 算法。
值得注意的是,上述 Dyna-Q 算法适用于离散且确定性的环境。在这种环境中,当观察到一条经验数据 时,可以直接对环境模型进行精确更新:
其中 表示环境模型,它将状态-动作对 映射到对应的奖励和下一个状态。
这种直接模型更新的方式使得 Dyna-Q 能够高效地利用历史经验,通过模拟数据加速学习过程。
3. Gymnasium 实现
由于Dyna-Q 算法是基于模型的强化学习算法,因此需要一个环境模型来模拟环境的动态变化。我们使用悬崖漫步环境来模拟。
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from collections import defaultdict
import gymnasium as gym
class DynaQ:
def __init__(self, env, alpha=0.1, gamma=0.95, epsilon=0.1, planning_steps=5):
self.env = env
self.alpha = alpha # 学习率
self.gamma = gamma # 折扣因子
self.epsilon = epsilon # 探索率
self.planning_steps = planning_steps # 规划步数
# Q表
self.q_table = defaultdict(lambda: np.zeros(env.action_space.n))
# 环境模型 (状态-动作 -> 奖励, 下一个状态)
self.model = {}
# 记录状态-动作对
self.state_action_pairs = []
def choose_action(self, state):
"""epsilon-greedy策略选择动作"""
if np.random.random() < self.epsilon:
return self.env.action_space.sample() # 随机探索
else:
return np.argmax(self.q_table[state]) # 利用
def update_q_value(self, state, action, reward, next_state, done):
"""更新Q值"""
if done:
td_target = reward
else:
best_next_action = np.argmax(self.q_table[next_state])
td_target = reward + self.gamma * self.q_table[next_state][best_next_action]
td_error = td_target - self.q_table[state][action]
self.q_table[state][action] += self.alpha * td_error
def update_model(self, state, action, reward, next_state, done):
"""更新环境模型"""
self.model[(state, action)] = (reward, next_state, done)
# 记录经历过的状态-动作对
if (state, action) not in self.state_action_pairs:
self.state_action_pairs.append((state, action))
def planning(self):
"""规划过程:使用模型进行模拟更新"""
for _ in range(self.planning_steps):
if len(self.state_action_pairs) == 0:
break
# 随机选择一个经历过的状态-动作对
idx = np.random.randint(0, len(self.state_action_pairs))
state, action = self.state_action_pairs[idx]
# 从模型中获取预测的奖励和下一个状态
if (state, action) in self.model:
reward, next_state, done = self.model[(state, action)]
# 使用模拟经验更新Q值
self.update_q_value(state, action, reward, next_state, done)
def train(self, episodes=500, max_steps=100):
"""训练Dyna-Q算法"""
rewards = []
steps_per_episode = []
for episode in range(episodes):
state, _ = self.env.reset()
total_reward = 0
step_count = 0
for step in range(max_steps):
# 选择动作
action = self.choose_action(state)
# 执行动作
next_state, reward, terminated, truncated, _ = self.env.step(action)
done = terminated or truncated
# 更新Q值(直接学习)
self.update_q_value(state, action, reward, next_state, done)
# 更新模型
self.update_model(state, action, reward, next_state, done)
# 规划过程(间接学习)
self.planning()
total_reward += reward
state = next_state
step_count += 1
if done:
break
rewards.append(total_reward)
steps_per_episode.append(step_count)
if (episode + 1) % 50 == 0:
avg_reward = np.mean(rewards[-50:])
avg_steps = np.mean(steps_per_episode[-50:])
print(f"Episode {episode + 1}: Average Reward = {avg_reward:.2f}, Average Steps = {avg_steps:.2f}")
return rewards, steps_per_episode
def test(self, episodes=10, max_steps=1000):
"""测试训练好的策略"""
total_rewards = []
for _ in range(episodes):
state, _ = self.env.reset()
total_reward = 0
for _ in range(max_steps):
# 使用贪心策略
action = np.argmax(self.q_table[state])
next_state, reward, terminated, truncated, _ = self.env.step(action)
done = terminated or truncated
total_reward += reward
state = next_state
if done:
break
total_rewards.append(total_reward)
return total_rewards
def plot_results(rewards, steps_per_episode, planning_steps):
"""绘制训练结果"""
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))
# 绘制奖励
window_size = 20
if len(rewards) >= window_size:
smoothed_rewards = [np.mean(rewards[i:i+window_size]) for i in range(len(rewards)-window_size+1)]
ax1.plot(smoothed_rewards, label=f'Dyna-Q (n={planning_steps})', alpha=0.8)
else:
ax1.plot(rewards, label=f'Dyna-Q (n={planning_steps})', alpha=0.8)
ax1.set_xlabel('Episode')
ax1.set_ylabel('Smoothed Reward')
ax1.set_title('Training Performance')
ax1.legend()
ax1.grid(True, alpha=0.3)
# 绘制步数
if len(steps_per_episode) >= window_size:
smoothed_steps = [np.mean(steps_per_episode[i:i+window_size]) for i in range(len(steps_per_episode)-window_size+1)]
ax2.plot(smoothed_steps, label=f'Dyna-Q (n={planning_steps})', alpha=0.8)
else:
ax2.plot(steps_per_episode, label=f'Dyna-Q (n={planning_steps})', alpha=0.8)
ax2.set_xlabel('Episode')
ax2.set_ylabel('Smoothed Steps')
ax2.set_title('Learning Efficiency')
ax2.legend()
ax2.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
def compare_planning_steps():
"""比较不同规划步数的效果"""
env = gym.make('CliffWalking-v1')
planning_steps_list = [0, 5, 10, 20]
results = {}
for n in planning_steps_list:
agent = DynaQ(env, planning_steps=n)
rewards, steps = agent.train(episodes=300)
results[n] = (rewards, steps)
env.close()
# 绘制比较结果
plt.figure(figsize=(12, 8))
for n, (rewards, steps) in results.items():
label = 'Q-learning' if n == 0 else f'Dyna-Q (n={n})'
if len(rewards) >= 20:
smoothed_rewards = [np.mean(rewards[i:i+20]) for i in range(len(rewards)-19)]
plt.plot(smoothed_rewards, label=label, alpha=0.8)
else:
plt.plot(rewards, label=label, alpha=0.8)
plt.xlabel('Episode')
plt.ylabel('Smoothed Reward (20-episode window)')
plt.title('Comparison of Different Planning Steps')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
def visualize_policy(agent, env):
"""可视化学习到的策略"""
policy = np.zeros(48) # CliffWalking有48个状态
for state in range(48):
policy[state] = np.argmax(agent.q_table[state])
# 将策略转换为网格形式
policy_grid = policy.reshape(4, 12)
# 动作映射
action_map = {0: '↑', 1: '→', 2: '↓', 3: '←'}
plt.figure(figsize=(12, 4))
sns.heatmap(policy_grid, annot=True, fmt="",
xticklabels=False, yticklabels=False,
cmap="viridis", cbar_kws={'label': 'Action'})
# 添加动作符号
for i in range(4):
for j in range(12):
action = int(policy_grid[i, j])
plt.text(j + 0.5, i + 0.5, action_map[action],
ha='center', va='center', fontsize=12, fontweight='bold')
# 标记悬崖和终点
plt.gca().add_patch(plt.Rectangle((0.5, 3.5), 10, 0.5, fill=False, edgecolor='red', lw=2))
plt.text(5.5, 3.75, 'Cliff', ha='center', va='center', fontsize=12, fontweight='bold', color='red')
plt.text(11.5, 3.5, 'Goal', ha='center', va='center', fontsize=12, fontweight='bold', color='green')
plt.title('Learned Policy for CliffWalking Environment')
plt.show()
if __name__ == "__main__":
# 创建环境
env = gym.make('CliffWalking-v1')
# 训练Dyna-Q智能体
agent = DynaQ(env, planning_steps=10)
rewards, steps_per_episode = agent.train(episodes=500)
# 绘制训练结果
plot_results(rewards, steps_per_episode, planning_steps=10)
# 可视化学习到的策略
visualize_policy(agent, env)
# 测试训练好的策略
test_rewards = agent.test(episodes=10)
print(f"10 个测试回合的平均奖励:{np.mean(test_rewards):.2f}")
# 比较不同规划步数
compare_planning_steps()
env.close()
planning_steps=0 时,上述实现就是普通 Q-learning;增加规划步数后,每条真实经验会触发更多次模型经验更新,通常能更快传播奖励信息。具体曲线受随机种子、探索率和规划步数影响,因此不应把某一次运行日志当作稳定结论。
4. 从 Dyna-Q 到 MBPO
Dyna-Q 的思想可以概括为“用真实数据学习模型,再用短期模型 rollout 扩充训练数据”。在离散确定性环境中,字典 已足够;面对连续状态、随机动力学时,则需要用神经网络近似转移与奖励分布。MBPO(Model-Based Policy Optimization)延续了相同的数据流:
- 用真实环境数据训练一组概率动力学模型,以模型集成表达认知不确定性;
- 从真实经验池中的状态出发,在模型中执行较短的 rollout;
- 将生成的模型转移加入模型经验 池;
- 用 SAC 等无模型算法同时消费真实经验和模型经验来更新策略。
两者的核心差异是模型与控制器的规模:Dyna-Q 使用表格 Q-learning 和离散模型,MBPO 使用概率神经网络模型和适用于连续控制的 off-policy 算法。MBPO 刻意限制 rollout 长度,因为模型误差会随预测步数累积;这正是从 Dyna-Q 走向现代基于模型强化学习时必须处理的模型偏差问题。因而,Dyna-Q 的规划次数与 MBPO 的 rollout 长度都体现了同一权衡:更多模拟数据提升样本效率,也可能放大模型误差。