8

我想实现以下算法，取自本书第 13.6 节：

在此处输入图像描述

我不明白如何在 pytorch 中实现更新规则（w 的规则与 theta 的规则非常相似）。

据我所知，torch 需要损失loss.backwward().

这种形式似乎不适用于引用的算法。

我仍然确定在 pytorch 中实现此类更新规则的正确方法。

鉴于 V(s,w) 是神经网络的输出，由 w 参数化，将非常感谢如何更新 w 权重的代码片段。

编辑： Chris Holland 提出了一种实施方法，我实施了它。它不会在 Cartpole 上收敛，我想知道我是否做错了什么。

批评家确实收敛于函数的解，该函数gamma*f(n)=f(n)-1恰好是系列gamma+gamma^2+...+gamma^inf 意义的总和，gamma=1 发散。gamma=0.99 收敛于 100，gamma=0.5 收敛于 2，依此类推。无论演员或政策如何。

编码：

def _update_grads_with_eligibility(self, is_critic, delta, discount, ep_t):
    gamma = self.args.gamma
    if is_critic:
        params = list(self.critic_nn.parameters())
        lamb = self.critic_lambda
        eligibilities = self.critic_eligibilities
    else:
        params = list(self.actor_nn.parameters())
        lamb = self.actor_lambda
        eligibilities = self.actor_eligibilities

    is_episode_just_started = (ep_t == 0)
    if is_episode_just_started:
        eligibilities.clear()
        for i, p in enumerate(params):
            if not p.requires_grad:
                continue
            eligibilities.append(torch.zeros_like(p.grad, requires_grad=False))

    # eligibility traces
    for i, p in enumerate(params):

        if not p.requires_grad:
            continue
        eligibilities[i][:] = (gamma * lamb * eligibilities[i]) + (discount * p.grad)
        p.grad[:] = delta.squeeze() * eligibilities[i]

和

expected_reward_from_t = self.critic_nn(s_t)
probs_t = self.actor_nn(s_t)
expected_reward_from_t1 = torch.tensor([[0]], dtype=torch.float)
if s_t1 is not None:  # s_t is not a terminal state, s_t1 exists.
    expected_reward_from_t1 = self.critic_nn(s_t1)

delta = r_t + gamma * expected_reward_from_t1.data - expected_reward_from_t.data

negative_expected_reward_from_t = -expected_reward_from_t
self.critic_optimizer.zero_grad()
negative_expected_reward_from_t.backward()
self._update_grads_with_eligibility(is_critic=True,
                                    delta=delta,
                                    discount=discount,
                                    ep_t=ep_t)
self.critic_optimizer.step()

编辑 2： Chris Holland 的解决方案有效。问题源于我的代码中导致该行的错误

if s_t1 is not None:
    expected_reward_from_t1 = self.critic_nn(s_t1)

总是被调用，因此expected_reward_from_t1永远不会为零，因此没有为贝尔曼方程递归指定停止条件。

由于没有奖励工程，gamma=1，lambda=0.6，以及演员和评论家的大小为 128 的单个隐藏层，这在 500 集内收敛到了一个相当稳定的最优策略。

甚至更快gamma=0.99，如图所示（最佳折扣剧集奖励约为 86.6）。

谢谢

非常感谢@Chris Holland，他“试了一下”

4

1 回答 1

5

我要试试这个。

.backward()不需要损失函数，它只需要一个可微的标量输出。它近似于模型参数的梯度。让我们看看第一种情况是值函数的更新。

我们有一个梯度出现在 v 上，我们可以近似这个梯度

v = model(s)
v.backward()

这为我们提供了一个梯度，v其具有模型参数的维度。假设我们已经计算了其他参数更新，我们可以计算实际的优化器更新：

for i, p in enumerate(model.parameters()):
    z_theta[i][:] = gamma * lamda * z_theta[i] + l * p.grad
    p.grad[:] = alpha * delta * z_theta[i]

然后我们可以使用opt.step()调整后的梯度来更新模型参数。

于 2019-02-18T16:49:56.177 回答