TRPO 算法
想象一下你在学习走钢丝——这就是传统的策略梯度算法。你小心翼翼地迈出每一步,但有时候步子太大,就会突然失去平衡摔下来。这种"一步走错,满盘皆输"的情况在深度强化学习中同样存在:当策略网络是深度模型时,沿着梯度方向更新参数,很可能因为步长太大导致策略性能急剧下降。
TRPO 算法就像给走钢丝的演员系上了安全绳。它提出了一个精妙的思路:在参数更新时划定一个“信任区域”,在这个安全区域内进行策略改进,限制每次更新对策略性能的冲击。
1. TRPO 算法
让我们从数学的角度来理解TRPO的智慧。假设当前策略为 ,参数为 ,我们的目标是找到一个新参数 ,使得新策略 的性能不低于旧策略,即 。其中,目标函数 定义为初始状态的价值期望:
为了比较新旧策略的性能差异,我们使用性能差异引理(Performance Difference Lemma)。该引理指出:
其中, 是优势函数,表示在状态 下采取动作 相对于平均水平的优势。
这个公式告诉我们:如果能保证新策略在每个状态下的期望优势函数都非负,那么策略性能一定会提升。但问题在于,新策略还没有与环境交互,我们无法直接计算这个期望。
从状态价值函数的定义出发,对于任意状态 ,有:
这是因为:
取初始状态 的期望,即得:
接下来,我们将轨迹期望转换为状态访问分布的形式。定义未折扣状态访问分布 为:
其中 是策略 下在时间步 状态为 的概率。于是:
因此,要保证 ,只需:
理想情况下,如果对于所有状态 ,有 ,则性能单调递增。
1.1 巧妙近似
直接优化上述条件是不现实的,因为新策略 的状态访问分布 未知。TRPO采用近似方法,用旧策略 的状态分布 替代 ,并定义替代目标:
为了处理动作分布,使用重要性采样:
为了保证近似准确性,TRPO引入KL散度约束,形成优化问题:
其中 是信任区域半径。该约束确保新旧策略足够接近,从而状态访问分布变化不大,替代目标 是 的合理近似。
2. 约束优化问题
直接求解带约束的优化问题比较复杂,TRPO在实际实现中采用泰勒展开进行近似求解。为方便表示,我们用代替之前的,表示第次迭代后的策略。
2.1 泰勒展开近似
对目标函数和约束在处进行泰勒展开:
-
目标函数的一阶近似:
其中是目标函数的梯度。
-
约束条件的二阶近似:
其中是策略之间平均KL距离的黑塞矩阵。
2.2 近似优化问题
经过近似后,优化问题变为:
2.3 KKT条件求解
使用KKT条件可以直接导出上述问题的解:
3. 共轭梯度法
策略网络通常有成千上万的参数,直接计算和存储黑塞矩阵的逆矩阵在计算上是不可行的。
TRPO通过共轭梯度法直接计算,即参数更新方向。假设满足KL距离约束的最大步长为,根据约束条件有:
求解得到:
参数更新方式为:
在共轭梯度运算中,我们避免直接计算和存储黑塞矩阵,而是计算向量。对于任意向量,可以通过以下方式计算 :
即先用梯度和向量点乘后计算梯度。
共轭梯度法的具体流程如下:
-
初始化: , ,
-
迭代循环 for :
- 计算
- 更新
- 更新
- 如果 非常小,则退出循环
- 计算
- 更新
-
输出:
4. 线性搜索
由于TRPO使用了泰勒展开的1阶和2阶近似,这些近似并不精确,因此可能未必比好,或者未必满足KL散度限制。
TRPO在每次迭代的最后进行一次线性搜索,以确保找到满足条件的参数更新。具体步骤是找到一个最小的非负整数,使得按照:
求出的依然满足KL散度限制,并且能够提升目标函数。其中是一个决定线性搜索长度的超参数。
5. 算法流程
TRPO算法的完整流程如下:
-
初始化策略网络参数,价值网络参数
-
循环每个序列 :
a. 轨迹采样:用当前策略采样轨迹
b. 优势估计:根据收集到的数据和价值网络估计每个状态动作对的优势函数
c. 梯度计算:计算策略目标函数的梯度
d. 共轭梯度:用共轭梯度法计算
e. 线性搜索:找到一个值,并更新策略网络参数:
其中为能提升策略并满足KL距离限制的最小整数
f. 价 值网络更新:更新价值网络参数(与Actor-Critic中的更新方法相同)
-
结束循环
6. 广义优势估计
在TRPO中,我们需要估计优势函数。常用的方法是广义优势估计(GAE)。首先定义时序差分误差:
其中是一个已经学习的状态价值函数。
根据多步时序差分的思想,步优势估计为:
GAE将这些不同步数的优势估计进行指数加权平均:
其中是GAE中引入的超参数。
- 当时,,即只考虑一步差分得到的优势
- 当时,,即考虑所有步数差分得到优势的完全平均值
通过调整,可以在偏差和方差之间进行权衡,获得更稳定的优势估计。
def compute_advantage(gamma, lmbda, td_delta):
td_delta = td_delta.detach().numpy()
advantage_list = []
advantage = 0.0
for delta in td_delta[::-1]:
advantage = gamma * lmbda * advantage + delta
advantage_list.append(advantage)
advantage_list.reverse()
return torch.tensor(advantage_list, dtype=torch.float)
7. TRPO 算法完整实现
import torch
import numpy as np
import gymnasium as gym # 改为 gymnasium
import matplotlib.pyplot as plt
import torch.nn.functional as F
import copy
from collections import deque
import random
# 自定义工具函数,替代 rl_utils
def compute_advantage(gamma, lmbda, td_delta):
td_delta = td_delta.detach().numpy()
advantage_list = []
advantage = 0.0
for delta in td_delta[::-1]:
advantage = gamma * lmbda * advantage + delta
advantage_list.append(advantage)
advantage_list.reverse()
return torch.tensor(advantage_list, dtype=torch.float)
def moving_average(a, window_size):
cumulative_sum = np.cumsum(np.insert(a, 0, 0))
middle = (cumulative_sum[window_size:] - cumulative_sum[:-window_size]) / window_size
r = np.arange(1, window_size-1, 2)
begin = np.cumsum(a[:window_size-1])[::2] / r
end = (np.cumsum(a[:-window_size:-1])[::2] / r)[::-1]
return np.concatenate((begin, middle, end))
def train_on_policy_agent(env, agent, num_episodes, seed=None):
return_list = []
if seed is not None:
env.action_space.seed(seed)
episode_index = 0
for i in range(10):
with tqdm(total=int(num_episodes/10), desc='Iteration %d' % i) as pbar:
for i_episode in range(int(num_episodes/10)):
episode_return = 0
transition_dict = {
'states': [],
'actions': [],
'next_states': [],
'rewards': [],
'dones': []
}
state, _ = env.reset(seed=seed if episode_index == 0 else None)
episode_done = False
while not episode_done:
action = agent.take_action(state)
next_state, reward, terminated, truncated, _ = env.step(action)
episode_done = terminated or truncated
transition_dict['states'].append(state)
transition_dict['actions'].append(action)
transition_dict['next_states'].append(next_state)
transition_dict['rewards'].append(reward)
# dones 仅表示 MDP 终止;时间上限截断仍允许 bootstrap
transition_dict['dones'].append(terminated)
state = next_state
episode_return += reward
return_list.append(episode_return)
agent.update(transition_dict)
if (i_episode+1) % 10 == 0:
pbar.set_postfix({'episode': '%d' % (num_episodes/10 * i + i_episode+1),
'return': '%.3f' % np.mean(return_list[-10:])})
pbar.update(1)
episode_index += 1
return return_list
class PolicyNet(torch.nn.Module):
def __init__(self, state_dim, hidden_dim, action_dim):
super(PolicyNet, self).__init__()
self.fc1 = torch.nn.Linear(state_dim, hidden_dim)
self.fc2 = torch.nn.Linear(hidden_dim, action_dim)
def forward(self, x):
x = F.relu(self.fc1(x))
return F.softmax(self.fc2(x), dim=1)
class ValueNet(torch.nn.Module):
def __init__(self, state_dim, hidden_dim):
super(ValueNet, self).__init__()
self.fc1 = torch.nn.Linear(state_dim, hidden_dim)
self.fc2 = torch.nn.Linear(hidden_dim, 1)
def forward(self, x):
x = F.relu(self.fc1(x))
return self.fc2(x)
class TRPO:
""" TRPO算法 """
def __init__(self, hidden_dim, state_space, action_space, lmbda,
kl_constraint, alpha, critic_lr, gamma, device):
state_dim = state_space.shape[0]
action_dim = action_space.n
# 策略网络参数不需要优化器更新
self.actor = PolicyNet(state_dim, hidden_dim, action_dim).to(device)
self.critic = ValueNet(state_dim, hidden_dim).to(device)
self.critic_optimizer = torch.optim.Adam(self.critic.parameters(),
lr=critic_lr)
self.gamma = gamma
self.lmbda = lmbda # GAE参数
self.kl_constraint = kl_constraint # KL距离最大限制
self.alpha = alpha # 线性搜索参数
self.device = device
def take_action(self, state):
state = torch.as_tensor(np.asarray(state), dtype=torch.float,
device=self.device).unsqueeze(0)
probs = self.actor(state)
action_dist = torch.distributions.Categorical(probs)
action = action_dist.sample()
return action.item()
def hessian_matrix_vector_product(self, states, old_action_dists, vector):
# 计算黑塞矩阵和一个向量的乘积
new_action_dists = torch.distributions.Categorical(self.actor(states))
kl = torch.mean(
torch.distributions.kl.kl_divergence(old_action_dists,
new_action_dists)) # 计算平均KL距离
kl_grad = torch.autograd.grad(kl,
self.actor.parameters(),
create_graph=True)
kl_grad_vector = torch.cat([grad.view(-1) for grad in kl_grad])
# KL距离的梯度先和向量进行点积运算
kl_grad_vector_product = torch.dot(kl_grad_vector, vector)
grad2 = torch.autograd.grad(kl_grad_vector_product,
self.actor.parameters())
grad2_vector = torch.cat([grad.view(-1) for grad in grad2])
return grad2_vector
def conjugate_gradient(self, grad, states, old_action_dists): # 共轭梯度法求解方程
x = torch.zeros_like(grad)
r = grad.clone()
p = grad.clone()
rdotr = torch.dot(r, r)
for i in range(10): # 共轭梯度主循环
Hp = self.hessian_matrix_vector_product(states, old_action_dists,
p)
alpha = rdotr / torch.dot(p, Hp)
x += alpha * p
r -= alpha * Hp
new_rdotr = torch.dot(r, r)
if new_rdotr < 1e-10:
break
beta = new_rdotr / rdotr
p = r + beta * p
rdotr = new_rdotr
return x
def compute_surrogate_obj(self, states, actions, advantage, old_log_probs,
actor): # 计算策略目标
log_probs = torch.log(actor(states).gather(1, actions))
ratio = torch.exp(log_probs - old_log_probs)
return torch.mean(ratio * advantage)
def line_search(self, states, actions, advantage, old_log_probs,
old_action_dists, max_vec): # 线性搜索
old_para = torch.nn.utils.convert_parameters.parameters_to_vector(
self.actor.parameters())
old_obj = self.compute_surrogate_obj(states, actions, advantage,
old_log_probs, self.actor)
for i in range(15): # 线性搜索主循环
coef = self.alpha**i
new_para = old_para + coef * max_vec
new_actor = copy.deepcopy(self.actor)
torch.nn.utils.convert_parameters.vector_to_parameters(
new_para, new_actor.parameters())
new_action_dists = torch.distributions.Categorical(
new_actor(states))
kl_div = torch.mean(
torch.distributions.kl.kl_divergence(old_action_dists,
new_action_dists))
new_obj = self.compute_surrogate_obj(states, actions, advantage,
old_log_probs, new_actor)
if new_obj > old_obj and kl_div < self.kl_constraint:
return new_para
return old_para
def policy_learn(self, states, actions, old_action_dists, old_log_probs,
advantage): # 更新策略函数
surrogate_obj = self.compute_surrogate_obj(states, actions, advantage,
old_log_probs, self.actor)
grads = torch.autograd.grad(surrogate_obj, self.actor.parameters())
obj_grad = torch.cat([grad.view(-1) for grad in grads]).detach()
# 用共轭梯度法计算x = H^(-1)g
descent_direction = self.conjugate_gradient(obj_grad, states,
old_action_dists)
Hd = self.hessian_matrix_vector_product(states, old_action_dists,
descent_direction)
max_coef = torch.sqrt(2 * self.kl_constraint /
(torch.dot(descent_direction, Hd) + 1e-8))
new_para = self.line_search(states, actions, advantage, old_log_probs,
old_action_dists,
descent_direction * max_coef) # 线性搜索
torch.nn.utils.convert_parameters.vector_to_parameters(
new_para, self.actor.parameters()) # 用线性搜索后的参数更新策略
def update(self, transition_dict):
states = torch.tensor(np.array(transition_dict['states']),
dtype=torch.float).to(self.device)
actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(
self.device)
rewards = torch.tensor(transition_dict['rewards'],
dtype=torch.float).view(-1, 1).to(self.device)
next_states = torch.tensor(np.array(transition_dict['next_states']),
dtype=torch.float).to(self.device)
dones = torch.tensor(transition_dict['dones'],
dtype=torch.float).view(-1, 1).to(self.device)
td_target = rewards + self.gamma * self.critic(next_states) * (1 -
dones)
td_delta = td_target - self.critic(states)
advantage = compute_advantage(self.gamma, self.lmbda,
td_delta.cpu()).to(self.device)
old_log_probs = torch.log(self.actor(states).gather(1,
actions)).detach()
old_action_dists = torch.distributions.Categorical(
self.actor(states).detach())
critic_loss = torch.mean(
F.mse_loss(self.critic(states), td_target.detach()))
self.critic_optimizer.zero_grad()
critic_loss.backward()
self.critic_optimizer.step() # 更新价值函数
# 更新策略函数
self.policy_learn(states, actions, old_action_dists, old_log_probs,
advantage)
# 主程序
if __name__ == "__main__":
from tqdm import tqdm
num_episodes = 500
hidden_dim = 128
gamma = 0.98
lmbda = 0.95
critic_lr = 1e-2
kl_constraint = 0.0005
alpha = 0.5
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
env_name = 'CartPole-v1' # 使用 v1 版本
env = gym.make(env_name)
# 设置随机种子
random.seed(0)
np.random.seed(0)
torch.manual_seed(0)
agent = TRPO(hidden_dim, env.observation_space, env.action_space, lmbda,
kl_constraint, alpha, critic_lr, gamma, device)
return_list = train_on_policy_agent(env, agent, num_episodes, seed=0)
episodes_list = list(range(len(return_list)))
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(episodes_list, return_list)
plt.xlabel('Episodes')
plt.ylabel('Returns')
plt.title('TRPO on {}'.format(env_name))
plt.grid(True, alpha=0.3)
plt.subplot(1, 2, 2)
mv_return = moving_average(return_list, 9)
plt.plot(episodes_list[:len(mv_return)], mv_return)
plt.xlabel('Episodes')
plt.ylabel('Returns')
plt.title('TRPO on {} (Moving Average)'.format(env_name))
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
运行结果
下一章将在 TRPO 的信任区域思想之上,介绍实现更简洁的 PPO 算法。