贝尔曼方程
贝尔曼方程(Bellman Equation)是强化学习中最核心的数学工具之一,它描述了价值函数之间的递推关系。理解贝尔曼方程对于掌握所有强化学习算法都至关重要。
回报与价值
在介绍贝尔曼方程之前,先回顾一下回报和价值的概念。
回报(Return)
回报 是从时刻 开始的累积折扣奖励:
回报可以递归地表示为:
这个递归形式是贝尔曼方程的基础。它告诉我们:当前时刻的回报等于即时奖励加上折扣后的下一时刻回报。
价值函数回顾
状态价值函数 是回报的期望:
动作价值函数 :
贝尔曼期望方程
贝尔曼期望方程描述了给定策略下价值函数的递推关系。
状态价值的贝尔曼方程
状态价值可以分解为两部分:即时奖励和下一状态价值的期望。
这个方程的含义是:
- 对于当前状态 ,考虑所有可能的动作
- 每个动作被选择的概率是
- 执行动作 后,以概率 转移到状态
- 获得即时奖励 ,加上折扣后的下一状态价值
def bellman_expectation_v(env, V, policy, state, gamma=0.99):
value = 0
for action in env.actions:
action_prob = policy(action, state)
for next_state in env.states:
transition_prob = env.transition_prob(state, action, next_state)
reward = env.reward(state, action, next_state)
value += action_prob * transition_prob * (reward + gamma * V[next_state])
return value
动作价值的贝尔曼方程
动作价值同样可以递归表示:
或者用状态价值表示:
def bellman_expectation_q(env, V, policy, state, action, gamma=0.99):
value = 0
for next_state in env.states:
transition_prob = env.transition_prob(state, action, next_state)
reward = env.reward(state, action, next_state)
value += transition_prob * (reward + gamma * V[next_state])
return value
V 与 Q 的关系
通过贝尔曼方程,我们可以清楚地看到 V 和 Q 的关系:
贝尔曼最优方程
贝尔曼最优方程描述了最优价值函数的递推关系。
最优状态价值
最优状态价值 满足:
与贝尔曼期望方程不同,这里使用 而非对动作求期望。这意味着最优策略总是选择能带来最大价值的动作。
最优动作价值
最优动作价值 满足:
最优策略
最优策略可以通过最优动作价值函数直接得到:
对于确定性最优策略:
贝尔曼方程的矩阵形式
对于有限状态空间,贝尔曼方程可以写成矩阵形式,便于分析和计算。
矩阵表示
设状态价值向量为 ,则贝尔曼期望方程可以写成:
其中:
- 是即时奖励期望向量
- 是状态转移矩阵
解析解
通过矩阵运算可以直接求解状态价值:
import numpy as np
def solve_value_function(transition_matrix, reward_vector, gamma=0.99):
num_states = transition_matrix.shape[0]
identity = np.eye(num_states)
V = np.linalg.inv(identity - gamma * transition_matrix) @ reward_vector
return V
这个解析解的时间复杂度是 ,只适用于状态空间较小的情况。
价值迭代算法
贝尔曼最优方程启发了一种求解最优策略的方法:价值迭代。
算法思想
价值迭代通过反复应用贝尔曼最优算子来逼近最优价值函数:
算法实现
def value_iteration(env, gamma=0.99, theta=1e-6):
V = np.zeros(len(env.states))
while True:
delta = 0
for state in env.states:
if env.is_terminal(state):
continue
v = V[state]
q_values = []
for action in env.actions:
q = 0
for next_state in env.states:
prob = env.transition_prob(state, action, next_state)
reward = env.reward(state, action, next_state)
q += prob * (reward + gamma * V[next_state])
q_values.append(q)
V[state] = max(q_values)
delta = max(delta, abs(v - V[state]))
if delta < theta:
break
policy = np.zeros(len(env.states), dtype=int)
for state in env.states:
if env.is_terminal(state):
continue
q_values = []
for action in env.actions:
q = 0
for next_state in env.states:
prob = env.transition_prob(state, action, next_state)
reward = env.reward(state, action, next_state)
q += prob * (reward + gamma * V[next_state])
q_values.append(q)
policy[state] = np.argmax(q_values)
return V, policy
收敛性
价值迭代保证收敛到最优价值函数,因为贝尔曼最优算子是压缩映射。具体来说:
由于 ,价值函数会以指数速度收敛。
策略迭代算法
策略迭代是另一种求解最优策略的方法,它交替进行策略评估和策略改进。
算法步骤
- 策略评估:计算当前策略 的价值函数
- 策略改进:根据 贪心地改进策略
- 重复直到策略不再变化
算法实现
def policy_iteration(env, gamma=0.99, theta=1e-6):
policy = np.zeros(len(env.states), dtype=int)
V = np.zeros(len(env.states))
while True:
while True:
delta = 0
for state in env.states:
if env.is_terminal(state):
continue
v = V[state]
action = policy[state]
q = 0
for next_state in env.states:
prob = env.transition_prob(state, action, next_state)
reward = env.reward(state, action, next_state)
q += prob * (reward + gamma * V[next_state])
V[state] = q
delta = max(delta, abs(v - V[state]))
if delta < theta:
break
policy_stable = True
for state in env.states:
if env.is_terminal(state):
continue
old_action = policy[state]
q_values = []
for action in env.actions:
q = 0
for next_state in env.states:
prob = env.transition_prob(state, action, next_state)
reward = env.reward(state, action, next_state)
q += prob * (reward + gamma * V[next_state])
q_values.append(q)
policy[state] = np.argmax(q_values)
if old_action != policy[state]:
policy_stable = False
if policy_stable:
break
return V, policy
价值迭代 vs 策略迭代
| 特性 | 价值迭代 | 策略迭代 |
|---|---|---|
| 每次迭代 | 更新价值函数 | 评估策略 + 改进策略 |
| 收敛速度 | 较慢 | 较快 |
| 每次迭代开销 | 低 | 高(需要完整策略评估) |
| 适用场景 | 状态空间大 | 状态空间小 |
示例:求解网格世界
让我们用贝尔曼方程求解一个简单的网格世界问题:
import numpy as np
class GridWorld:
def __init__(self, size=4):
self.size = size
self.num_states = size * size
self.num_actions = 4
self.goal = self.num_states - 1
def step(self, state, action):
row, col = state // self.size, state % self.size
if action == 0: # 上
row = max(0, row - 1)
elif action == 1: # 下
row = min(self.size - 1, row + 1)
elif action == 2: # 左
col = max(0, col - 1)
elif action == 3: # 右
col = min(self.size - 1, col + 1)
next_state = row * self.size + col
reward = 1.0 if next_state == self.goal else -0.01
done = next_state == self.goal
return next_state, reward, done
def transition_prob(self, state, action, next_state):
actual_next, _, _ = self.step(state, action)
return 1.0 if next_state == actual_next else 0.0
def reward(self, state, action, next_state):
return 1.0 if next_state == self.goal else -0.01
def is_terminal(self, state):
return state == self.goal
env = GridWorld()
V, policy = value_iteration(env)
print("最优状态价值函数:")
print(V.reshape(4, 4).round(3))
print("\n最优策略 (0=上, 1=下, 2=左, 3=右):")
print(policy.reshape(4, 4))
输出示例:
最优状态价值函数:
[[0.91 0.922 0.934 0.946]
[0.922 0.934 0.946 0.959]
[0.934 0.946 0.959 0.972]
[0.946 0.959 0.972 1. ]]
最优策略 (0=上, 1=下, 2=左, 3=右):
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]
[1 1 1 0]]
小结
贝尔曼方程是强化学习的数学核心:
- 贝尔曼期望方程:描述给定策略下价值函数的递推关系
- 贝尔曼最优方程:描述最优价值函数的递推关系
- 价值迭代:通过反复应用贝尔曼最优算子求解最优策略
- 策略迭代:交替进行策略评估和策略改进
贝尔曼方程为后续的 Q-Learning、DQN 等算法奠定了理论基础。下一章将介绍 Q-Learning 算法,它是一种基于贝尔曼方程的无模型强化学习方法。