【面试必问】强化学习之动态规划DP 从理论到实践详解

强化学习中的动态规划：从理论到实践详解

引言

动态规划（Dynamic Programming, DP）是强化学习（Reinforcement Learning, RL）的基石之一。虽然DP算法在实际RL问题中应用有限（因其要求完全已知环境模型），但理解DP对于掌握现代RL算法至关重要。本文将深入剖析DP在RL中的核心思想、关键算法和具体实现。

一、核心概念

1.1 动态规划的基本思想

动态规划的核心是贝尔曼方程（Bellman Equation）和最优性原理（Principle of Optimality）：

• 最优性原理：一个最优策略的子策略也必须是最优的
• 贝尔曼方程：将价值函数表示为即时奖励加上折扣后的未来价值

1.2 马尔可夫决策过程（MDP）

DP要求MDP完全已知，即四元组 $(S,A,P,R)$：

• $S$：状态空间
• $A$：动作空间
• $P(s^{\prime }|s,a)$：状态转移概率
• $R(s,a)$：奖励函数

二、DP的两大核心问题

2.1 预测问题（Prediction）

输入：MDP和策略 $\pi$
输出：状态价值函数 $v_{\pi }$

2.2 控制问题（Control）

输入：MDP
输出：最优策略 ${\pi }_{\ast }$ 和最优价值函数 $v_{\ast }$

三、核心算法详解

3.1 策略评估（Policy Evaluation）

目标：计算给定策略下的状态价值函数

算法原理：
$$v_{k+1}(s)=\sum _a\pi (a|s)\sum _{s^{\prime }}P(s^{\prime }|s,a)[R(s,a)+\gamma v_k(s^{\prime })]$$

迭代过程：反复应用贝尔曼期望方程，直到收敛

# 策略评估算法伪代码
def policy_evaluation(pi, P, gamma=0.9, theta=1e-10):
    V = np.zeros(len(S))
    while True:
        delta = 0
        for s in S:
            v = V[s]
            V[s] = sum(pi[s,a] * sum(P[s,a,s'] * (R[s,a] + gamma * V[s']) 
                     for s' in S) for a in A)
            delta = max(delta, abs(v - V[s]))
        if delta < theta:
            break
    return V

3.2 策略迭代（Policy Iteration）

两个步骤交替进行：

1. 策略评估：计算当前策略的价值函数
2. 策略改进：基于价值函数 greedily 改进策略

# 策略迭代完整实现
def policy_iteration(P, gamma=0.9):
    n_states, n_actions = len(S), len(A)
    pi = np.ones((n_states, n_actions)) / n_actions  # 随机初始化
    
    while True:
        # 策略评估
        V = policy_evaluation(pi, P, gamma)
        
        # 策略改进
        policy_stable = True
        for s in S:
            old_action = np.argmax(pi[s])
            # 计算Q值
            Q = np.zeros(n_actions)
            for a in A:
                Q[a] = sum(P[s,a,s'] * (R[s,a] + gamma * V[s']) for s' in S)
            new_action = np.argmax(Q)
            
            if old_action != new_action:
                policy_stable = False
            
            # 更新策略（确定性策略）
            pi[s] = np.eye(n_actions)[new_action]
        
        if policy_stable:
            break
    
    return pi, V

3.3 价值迭代（Value Iteration）

核心思想：将策略评估和改进步骤合并，直接优化贝尔曼最优方程

$$v_{k+1}(s)=\underset{a}{\max }\sum _{s^{\prime }}P(s^{\prime }|s,a)[R(s,a)+\gamma v_k(s^{\prime })]$$

def value_iteration(P, gamma=0.9, theta=1e-10):
    V = np.zeros(len(S))
    
    while True:
        delta = 0
        for s in S:
            v = V[s]
            # 贝尔曼最优算子
            Q = np.zeros(len(A))
            for a in A:
                Q[a] = sum(P[s,a,s'] * (R[s,a] + gamma * V[s']) for s' in S)
            V[s] = np.max(Q)
            delta = max(delta, abs(v - V[s]))
        
        if delta < theta:
            break
    
    # 提取最优策略
    pi = np.zeros((len(S), len(A)))
    for s in S:
        Q = np.zeros(len(A))
        for a in A:
            Q[a] = sum(P[s,a,s'] * (R[s,a] + gamma * V[s']) for s' in S)
        pi[s, np.argmax(Q)] = 1.0
    
    return pi, V

四、算法对比与复杂度分析

关键结论：

• 策略迭代通常需要更少的迭代次数
• 价值迭代每次迭代更简单
• 实践中常使用截断策略评估（只进行有限次迭代）

五、完整实例：GridWorld问题

import numpy as np
import matplotlib.pyplot as plt

class GridWorld:
    def __init__(self, size=4):
        self.size = size
        self.n_states = size * size
        self.n_actions = 4  # 上、下、左、右
        self.gamma = 0.9
        
        # 定义MDP
        self.P = np.zeros((self.n_states, self.n_actions, self.n_states))
        self.R = np.full((self.n_states, self.n_actions), -1.0)
        
        self._build_model()
    
    def _build_model(self):
        # 构建状态转移概率和奖励
        for s in range(self.n_states):
            row, col = divmod(s, self.size)
            for a, (dr, dc) in enumerate([(-1,0), (1,0), (0,-1), (0,1)]):
                new_row, new_col = row + dr, col + dc
                if 0 <= new_row < self.size and 0 <= new_col < self.size:
                    s_prime = new_row * self.size + new_col
                else:
                    s_prime = s  # 撞墙保持在原地
                self.P[s, a, s_prime] = 1.0
        
        # 设置特殊状态（如终止状态）
        self.R[0, :] = 0  # 左上角为终止状态
        self.R[-1, :] = 0  # 右下角为终止状态
    
    def solve(self, method='value_iteration'):
        if method == 'policy_iteration':
            pi, V = policy_iteration(self.P, self.gamma)
        else:
            pi, V = value_iteration(self.P, self.gamma)
        return pi, V.reshape(self.size, self.size)

# 运行示例
grid = GridWorld()
policy, value = grid.solve('value_iteration')

print("最优价值函数：")
print(np.round(value, 2))
print("\n最优策略（0:上, 1:下, 2:左, 3:右）：")
print(np.argmax(policy, axis=1).reshape(4, 4))

六、优缺点与适用场景

✅ 优点

• 理论完备：收敛性有保证
• 精确解：能得到真正的最优价值函数（在计算精度内）
• 奠定基础：理解DP对掌握Q-learning、Policy Gradient等至关重要

❌ 缺点

• 维度灾难：状态空间增大时计算量爆炸
• 模型依赖：必须完全已知MDP模型
• 计算效率：对大规模问题不实用

🎯 适用场景

• 棋盘游戏（如井字棋、五子棋）
• 小型机器人路径规划
• 金融决策模型
• 教学和理解RL原理

七、现代扩展

1. 异步动态规划：每次只更新部分状态
2. 近似动态规划：使用函数逼近器处理大规模状态空间
3. 实时动态规划：结合实际经验进行更新
4. 与深度学习的结合：形成深度DP方法

八、总结

动态规划是强化学习的理论基石，它教会我们：

• 价值函数的重要性
• 自举（Bootstrapping） 的思想
• 策略评估与改进的迭代框架

尽管DP在实际应用中有局限，但其核心思想渗透在现代RL的每个角落。掌握DP，就等于拿到了理解DQN、PPO等先进算法的钥匙。

参考文献：

• Sutton & Barto 《Reinforcement Learning: An Introduction》
• Bertsekas 《Dynamic Programming and Optimal Control》