跳到主要内容

贝尔曼方程

贝尔曼方程(Bellman Equation)是强化学习中最核心的数学工具之一,它描述了价值函数之间的递推关系。理解贝尔曼方程对于掌握所有强化学习算法都至关重要。

回报与价值

在介绍贝尔曼方程之前,先回顾一下回报和价值的概念。

回报(Return)

回报 GtG_t 是从时刻 tt 开始的累积折扣奖励:

Gt=Rt+1+γRt+2+γ2Rt+3+...=k=0γkRt+k+1G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + ... = \sum_{k=0}^{\infty} \gamma^k R_{t+k+1}

回报可以递归地表示为:

Gt=Rt+1+γGt+1G_t = R_{t+1} + \gamma G_{t+1}

这个递归形式是贝尔曼方程的基础。它告诉我们:当前时刻的回报等于即时奖励加上折扣后的下一时刻回报。

价值函数回顾

状态价值函数 Vπ(s)V^\pi(s) 是回报的期望:

Vπ(s)=Eπ[GtSt=s]V^\pi(s) = \mathbb{E}_\pi[G_t | S_t = s]

动作价值函数 Qπ(s,a)Q^\pi(s,a)

Qπ(s,a)=Eπ[GtSt=s,At=a]Q^\pi(s,a) = \mathbb{E}_\pi[G_t | S_t = s, A_t = a]

贝尔曼期望方程

贝尔曼期望方程描述了给定策略下价值函数的递推关系。

状态价值的贝尔曼方程

状态价值可以分解为两部分:即时奖励和下一状态价值的期望。

Vπ(s)=aπ(as)sP(ss,a)[R(s,a,s)+γVπ(s)]V^\pi(s) = \sum_a \pi(a|s) \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma V^\pi(s')]

这个方程的含义是:

  1. 对于当前状态 ss,考虑所有可能的动作 aa
  2. 每个动作被选择的概率是 π(as)\pi(a|s)
  3. 执行动作 aa 后,以概率 P(ss,a)P(s'|s,a) 转移到状态 ss'
  4. 获得即时奖励 R(s,a,s)R(s,a,s'),加上折扣后的下一状态价值 γVπ(s)\gamma V^\pi(s')
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

动作价值的贝尔曼方程

动作价值同样可以递归表示:

Qπ(s,a)=sP(ss,a)[R(s,a,s)+γaπ(as)Qπ(s,a)]Q^\pi(s,a) = \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma \sum_{a'} \pi(a'|s') Q^\pi(s',a')]

或者用状态价值表示:

Qπ(s,a)=sP(ss,a)[R(s,a,s)+γVπ(s)]Q^\pi(s,a) = \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma V^\pi(s')]

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 的关系:

Vπ(s)=aπ(as)Qπ(s,a)V^\pi(s) = \sum_a \pi(a|s) Q^\pi(s,a)

Qπ(s,a)=sP(ss,a)[R(s,a,s)+γVπ(s)]Q^\pi(s,a) = \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma V^\pi(s')]

贝尔曼最优方程

贝尔曼最优方程描述了最优价值函数的递推关系。

最优状态价值

最优状态价值 V(s)V^*(s) 满足:

V(s)=maxasP(ss,a)[R(s,a,s)+γV(s)]V^*(s) = \max_a \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma V^*(s')]

与贝尔曼期望方程不同,这里使用 max\max 而非对动作求期望。这意味着最优策略总是选择能带来最大价值的动作。

最优动作价值

最优动作价值 Q(s,a)Q^*(s,a) 满足:

Q(s,a)=sP(ss,a)[R(s,a,s)+γmaxaQ(s,a)]Q^*(s,a) = \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma \max_{a'} Q^*(s',a')]

最优策略

最优策略可以通过最优动作价值函数直接得到:

π(s)=argmaxaQ(s,a)\pi^*(s) = \arg\max_a Q^*(s,a)

对于确定性最优策略:

π(s)=argmaxasP(ss,a)[R(s,a,s)+γV(s)]\pi^*(s) = \arg\max_a \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma V^*(s')]

贝尔曼方程的矩阵形式

对于有限状态空间,贝尔曼方程可以写成矩阵形式,便于分析和计算。

矩阵表示

设状态价值向量为 VRS\mathbf{V} \in \mathbb{R}^{|S|},则贝尔曼期望方程可以写成:

Vπ=Rπ+γPπVπ\mathbf{V}^\pi = \mathbf{R}^\pi + \gamma \mathbf{P}^\pi \mathbf{V}^\pi

其中:

  • Rπ\mathbf{R}^\pi 是即时奖励期望向量
  • Pπ\mathbf{P}^\pi 是状态转移矩阵

解析解

通过矩阵运算可以直接求解状态价值:

Vπ=(IγPπ)1Rπ\mathbf{V}^\pi = (\mathbf{I} - \gamma \mathbf{P}^\pi)^{-1} \mathbf{R}^\pi

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

这个解析解的时间复杂度是 O(S3)O(|S|^3),只适用于状态空间较小的情况。

价值迭代算法

贝尔曼最优方程启发了一种求解最优策略的方法:价值迭代。

算法思想

价值迭代通过反复应用贝尔曼最优算子来逼近最优价值函数:

Vk+1(s)=maxasP(ss,a)[R(s,a,s)+γVk(s)]V_{k+1}(s) = \max_a \sum_{s'} P(s'|s,a) [R(s,a,s') + \gamma V_k(s')]

算法实现

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

收敛性

价值迭代保证收敛到最优价值函数,因为贝尔曼最优算子是压缩映射。具体来说:

Vk+1VγVkV||V_{k+1} - V^*||_\infty \leq \gamma ||V_k - V^*||_\infty

由于 γ<1\gamma < 1,价值函数会以指数速度收敛。

策略迭代算法

策略迭代是另一种求解最优策略的方法,它交替进行策略评估和策略改进。

算法步骤

  1. 策略评估:计算当前策略 π\pi 的价值函数 VπV^\pi
  2. 策略改进:根据 VπV^\pi 贪心地改进策略
  3. 重复直到策略不再变化

算法实现

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 算法,它是一种基于贝尔曼方程的无模型强化学习方法。