策略梯度算法
前面的 DQN 及其改进算法 学习动作价值函数,再通过 -贪婪规则隐式地产生策略。策略梯度方法则直接学习显式策略 :输入状态,输出动作概率分布,并以期望回报为目标优化参数。本篇先介绍策略梯度定理,再用 REINFORCE 给出蒙特卡洛实现。
1. 策略梯度
基于策略的方法首先需要将策略参数化。假设我们的目标策略 是一个随机策略,其中 是策略的参数向量。这个策略函数可以使用各种模型来表示:
- 线性模型:
- 神经网络模型:使用深度神经网络来建模复杂的策略函数
策略函数的输入是状态 ,输出是在该状态下各个动作的概率分布。
我们的目标是找到一个最优策略,使得在该策略下智能体在环境中获得的期望回报最大化。为此,我们定义目标函数为:
其中:
- , 表示初始状态分布
- 表示从初始状态 开始,遵循策略 所能获得的期望累积回报
为了优化目标函数 ,我们需要计算其关于参数 的梯度。
策略梯度定理的完整推导过程如下:
Details
-
初始形式:
- 目标函数梯度与状态访问分布 和动作价值函数 的加权和有关
- 表示在策略 下状态 的稳态分布
-
技巧性变换:
- 引入 并同时除以 ,保持等式不变
- 将求和形式转换为期望形式做准备
-
最终形式:
- 利用对数导数恒等式:
- 得到紧凑的期望形式,便于采样估计
由于期望 的下标是 ,这里的估计必须使用当前策略采样的数据,因此 REINFORCE 是同策略(on-policy)算法。这里的“同策略”描述行为策略与目标策略的关系,不等同于“在线学习”。
策略梯度公式具有很直观的解释:
- 当某个动作 在状态 下具有较高的 值时,梯度更新会使策略 的概率增加
- 当某个动作 在状态 下具有较低的 值时,梯度更新会使策略 的概率减少
这种机制使得智能体更倾向于选择那些能够带来高回报的动作,如图所示。
1.1 REINFORCE 算法
对于一个有限步数的环境,REINFORCE 算法中的策略梯度为:
其中:
- 是和环境交互的最大步数
- 是从时刻 开始的累积折扣回报,作为 的蒙特卡洛估计
- 期望 表示在策略 下轨迹的期望
以 CartPole-v1 为例:
- 环境默认每个回合最多 500 步
- 折扣因子 通常设置为 0.99 或 1.0
- 对于每个时间步 ,使用从该步到回合结束的实际累积回报来估计 值
REINFORCE 算法的伪代码如下:
输入:
- 学习率
- 折扣因子
- 初始策略参数
算法流程:
-
初始化策略参数
-
循环每个训练序列 :
a. 轨迹采样:使用当前策略 与环境交互,采样一条完整轨迹
b. 回报计算:对于轨迹中的每个时间步 ,计算从该时刻开始的累积折扣回报
c. 参数更新:对策略参数进行梯度上升更新
-
结束循环
1.2 策略梯度定理的证明
策略梯度定理的证明是强化学习理论中的重要组成部分。我们旨在证明:
其中 是目标函数。
我们从单个状态的价值函数梯度 开始:
定义辅助函数:
定义 为从状态 出发,在 步后到达状态 的概率。
继续推导:
定义折扣状态访问分布:
回到目标函数:
至此,我们成功证明了策略梯度定理:
2. REINFORCE 算法的实现
import gymnasium as gym
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.distributions import Categorical
import matplotlib.pyplot as plt
from collections import deque
import random
# 策略网络
class PolicyNetwork(nn.Module):
def __init__(self, state_dim, action_dim, hidden_dim=128):
super(PolicyNetwork, self).__init__()
self.fc1 = nn.Linear(state_dim, hidden_dim)
self.fc2 = nn.Linear(hidden_dim, hidden_dim)
self.fc3 = nn.Linear(hidden_dim, action_dim)
def forward(self, x):
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return F.softmax(x, dim=-1)
def act(self, state):
state = torch.from_numpy(state).float().unsqueeze(0)
probs = self.forward(state)
m = Categorical(probs)
action = m.sample()
return action.item(), m.log_prob(action)
# REINFORCE 算法
class REINFORCE:
def __init__(self, state_dim, action_dim, learning_rate=1e-3, gamma=0.99):
self.policy_net = PolicyNetwork(state_dim, action_dim)
self.optimizer = optim.Adam(self.policy_net.parameters(), lr=learning_rate)
self.gamma = gamma
self.saved_log_probs = []
self.rewards = []
def select_action(self, state):
action, log_prob = self.policy_net.act(state)
self.saved_log_probs.append(log_prob)
return action
def update_policy(self):
R = 0
policy_loss = []
returns = []
# 计算每个时间步的折扣回报
for r in self.rewards[::-1]:
R = r + self.gamma * R
returns.insert(0, R)
returns = torch.tensor(returns)
# 标准化回报以减少方差
returns = (returns - returns.mean()) / (returns.std() + 1e-9)
for log_prob, R in zip(self.saved_log_probs, returns):
policy_loss.append(-log_prob * R)
self.optimizer.zero_grad()
policy_loss = torch.stack(policy_loss).sum()
policy_loss.backward()
self.optimizer.step()
# 清空当前回合的数据
self.saved_log_probs = []
self.rewards = []
# 训练函数
def train_reinforce(env, agent, num_episodes=1000, max_steps=1000):
scores = []
scores_deque = deque(maxlen=100)
for i_episode in range(1, num_episodes+1):
state, _ = env.reset()
episode_reward = 0
for t in range(max_steps):
action = agent.select_action(state)
next_state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
agent.rewards.append(reward)
episode_reward += reward
if done:
break
state = next_state
agent.update_policy()
scores.append(episode_reward)
scores_deque.append(episode_reward)
if i_episode % 100 == 0:
print('Episode {}\tAverage Score: {:.2f}'.format(
i_episode, np.mean(scores_deque)))
# 如果最近100个回合平均分达到195,认为问题已解决
if np.mean(scores_deque) >= 195.0:
print('Environment solved in {:d} episodes!\tAverage Score: {:.2f}'.format(
i_episode-100, np.mean(scores_deque)))
break
return scores
# 可视化训练过程
def plot_training(scores):
plt.figure(figsize=(12, 5))
# 原始分数
plt.subplot(1, 2, 1)
plt.plot(scores)
plt.xlabel('回合')
plt.ylabel('分数')
plt.title('REINFORCE 训练过程 - 原始分数')
plt.grid(True, alpha=0.3)
# 移动平均分数
plt.subplot(1, 2, 2)
window_size = 100
moving_avg = [np.mean(scores[i-window_size:i]) for i in range(window_size, len(scores))]
plt.plot(range(window_size, len(scores)), moving_avg)
plt.axhline(y=195, color='r', linestyle='--', label='解决阈值 (195)')
plt.xlabel('回合')
plt.ylabel('平均分数 (100回合)')
plt.title('REINFORCE 训练过程 - 移动平均')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 测试训练好的策略
def test_policy(env, agent, num_episodes=10):
print("\n测试训练好的策略...")
test_scores = []
for episode in range(num_episodes):
state, _ = env.reset(seed=1000 + episode)
episode_reward = 0
steps = 0
while True:
with torch.no_grad():
action, _ = agent.policy_net.act(state)
next_state, reward, terminated, truncated, _ = env.step(action)
done = terminated or truncated
episode_reward += reward
steps += 1
state = next_state
if done:
break
test_scores.append(episode_reward)
print(f"测试回合 {episode+1}: 分数 = {episode_reward}, 步数 = {steps}")
print(f"\n测试结果 - 平均分数: {np.mean(test_scores):.2f} ± {np.std(test_scores):.2f}")
return test_scores
# 主函数
def main():
# 创建环境
env = gym.make('CartPole-v1')
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n
print("车杆环境信息:")
print(f"状态空间维度: {state_dim}")
print(f"动作空间大小: {action_dim}")
print(f"最大步数: {env.spec.max_episode_steps}")
# 设置随机种子
seed = 42
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
env.reset(seed=seed)
env.action_space.seed(seed)
# 创建 REINFORCE 智能体
agent = REINFORCE(state_dim, action_dim, learning_rate=1e-3, gamma=0.99)
# 训练
print("\n开始训练 REINFORCE 算法...")
scores = train_reinforce(env, agent, num_episodes=1000)
# 绘制训练曲线
plot_training(scores)
# 测试训练好的策略
test_env = gym.make('CartPole-v1')
test_scores = test_policy(test_env, agent, num_episodes=5)
test_env.close()
if __name__ == "__main__":
main()
运行结果
车杆环境信息:
状态空间维度: 4
动作空间大小: 2
最大步数: 500
开 始训练 REINFORCE 算法...
Episode 100 Average Score: 45.09
Episode 200 Average Score: 133.11
Environment solved in 160 episodes! Average Score: 196.68
测试训练好的策略...
测试回合 1: 分数 = 500.0, 步数 = 500
测试回合 2: 分数 = 306.0, 步数 = 306
测试回合 3: 分数 = 500.0, 步数 = 500
测试回合 4: 分数 = 405.0, 步数 = 405
测试回合 5: 分数 = 298.0, 步数 = 298
测试结果 - 平均分数: 401.80 ± 88.60
3. 从 REINFORCE 到 Actor-Critic
REINFORCE 在回合结束后,用 完整蒙特卡洛回报 更新策略。它无须学习价值函数,估计通常无偏,但方差较大且更新有延迟。一个自然的改进是学习状态价值函数 ,用一步 TD 误差
代替 作为策略更新信号。这样便得到 Actor-Critic 算法:Actor 表示策略,Critic 估计价值。它通过引入一定的自举偏差换取更低方差和逐步更新能力。