跳到主要内容

Dyna-Q 算法

1. 从无模型学习到基于模型的规划​

上一章的 Sarsa 与 Q-learning 都是无模型(model-free)方法:它们直接从真实转移 (s,a,r,s′)(s,a,r,s') 更新价值,不显式学习环境如何变化。Dyna-Q 在 Q-learning 旁增加一个由真实样本学习的环境模型,再用模型生成模拟转移进行规划,因此构成了从无模型学习到基于模型强化学习的最小桥梁。

强化学习算法有两个重要的评价指标:一个是算法收敛后的策略在初始状态下的期望回报,另一个是样本复杂度,即算法达到收敛结果需要在真实环境中采样的样本数量。基于模型的方法可以额外与模型交互,通常减少真实环境样本需求;但模型误差会被规划过程放大,策略最终回报未必优于无模型方法。这一权衡也会延续到后文的 MBPO。

2. Dyna-Q​

Dyna-Q 是一种经典的基于模型的强化学习算法,它通过结合真实经验和模拟经验来提升学习效率。如图所示,该算法的核心在于引入了一种称为 Q-planning 的机制,利用学习到的环境模型生成模拟数据,并将这些数据与真实交互数据共同用于策略优化。

在 Q-planning 过程中,算法执行以下步骤:

  1. 状态-动作选择:从已访问过的状态集合中随机选取一个状态 ss,并在该状态曾经执行过的动作中随机选择一个动作 aa;
  2. 模型预测:利用环境模型 M(s,a)M(s,a) 预测转移后的状态 s′s' 和即时奖励 rr: s′,r←M(s,a)s', r \gets M(s,a)
  3. 价值更新:使用 Q-learning 方法更新动作价值函数 Q(s,a)Q(s,a): Q(s,a)←Q(s,a)+α[r+γmax⁡a′Q(s′,a′)−Q(s,a)]Q(s,a) \gets Q(s,a) + \alpha \left[r + \gamma \max_{a'} Q(s',a') - Q(s,a)\right] 其中 α\alpha 为学习率,γ\gamma 为折扣因子。

通过反复执行 Q-planning 步骤,Dyna-Q 在保持样本效率的同时,有效利用模型知识加速策略收敛。

Image

Dyna-Q 算法在每次与环境进行真实交互并执行一次 Q-learning 更新后,会进行 nn 次 Q-planning 过程。其中 Q-planning 的次数 nn 是一个预先设定的超参数,当 n=0n = 0 时,算法退化为标准的 Q-learning 算法。

值得注意的是,上述 Dyna-Q 算法适用于离散且确定性的环境。在这种环境中,当观察到一条经验数据 (s,a,r,s′)(s, a, r, s') 时,可以直接对环境模型进行精确更新:

M(s,a)←(r,s′)M(s, a) \gets (r, s')

其中 MM 表示环境模型,它将状态-动作对 (s,a)(s, a) 映射到对应的奖励和下一个状态。

这种直接模型更新的方式使得 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 扩充训练数据”。在离散确定性环境中,字典 M(s,a)=(r,s′)M(s,a)=(r,s') 已足够;面对连续状态、随机动力学时,则需要用神经网络近似转移与奖励分布。MBPO(Model-Based Policy Optimization)延续了相同的数据流:

  1. 用真实环境数据训练一组概率动力学模型,以模型集成表达认知不确定性;
  2. 从真实经验池中的状态出发,在模型中执行较短的 rollout;
  3. 将生成的模型转移加入模型经验池;
  4. 用 SAC 等无模型算法同时消费真实经验和模型经验来更新策略。

两者的核心差异是模型与控制器的规模:Dyna-Q 使用表格 Q-learning 和离散模型,MBPO 使用概率神经网络模型和适用于连续控制的 off-policy 算法。MBPO 刻意限制 rollout 长度,因为模型误差会随预测步数累积;这正是从 Dyna-Q 走向现代基于模型强化学习时必须处理的模型偏差问题。因而,Dyna-Q 的规划次数与 MBPO 的 rollout 长度都体现了同一权衡:更多模拟数据提升样本效率,也可能放大模型误差。