Adam优化器错误：梯度计算所需的变量之一已通过就地操作进行了修改

Question

我正在尝试实现与基本的演员 - 评论算法不同的Actor-Critic学习atuomation算法，它有点改变。

无论如何，我使用了Adam优化器并用pytorch实现

当我首先向批评者反向TD错误时，没有错误。然而，我向后退失去了演员，错误发生了。

-------------------------------------------------- ------------------------- 46＃update中的RuntimeError Traceback（最近调用最后一次）演员Func 47 optimizer_M.zero_grad（）---> 48 loss.backward（）49 optimizer_M.step（）50

〜\ Anaconda3 \ lib \ site-packages \ torch \ tensor.py在向后（self，gradient，retain_graph，create_graph）100个产品。默认为False。 101“”“ - > 102 torch.autograd.backward（self，gradient，retain_graph，create_graph）103 104 def register_hook（self，hook）：

〜\ Anaconda3 \ lib \ site-packages \ torch \ autograd__init __。py in backward（tensors，grad_tensors，retain_graph，create_graph，grad_variables）88 Variable._execution_engine.run_backward（89张张量，grad_tensors，retain_graph，create_graph，---> 90 allow_unreachable = True）#allow_unreachable flag 91 92

RuntimeError：渐变计算所需的变量之一已由inplace操作修改

以上是错误的内容

我试图找到inplace操作，但我没有在我的书面代码中找到。我想我不知道如何处理优化器。

这是主要代码：

        for cur_step in range(1):   
        action = M_Agent(state, flag)  
        next_state, r = env.step(action)   

        # calculate TD Error
        TD_error = M_Agent.cal_td_error(r, next_state)

        # calculate Target
        target = torch.FloatTensor([M_Agent.cal_target(TD_error)])
        logit = M_Agent.cal_logit()
        loss = criterion(logit, target)

        # update value Func
        optimizer_M.zero_grad()
        TD_error.backward()
        optimizer_M.step()

        # update Actor Func
        loss.backward()
        optimizer_M.step()

这是代理网络

    # Actor-Critic Agent
    self.act_pipe = nn.Sequential(nn.Linear(state, 128),
                            nn.ReLU(),
                            nn.Dropout(0.5),
                            nn.Linear(128, 256),
                            nn.ReLU(),
                            nn.Dropout(0.5),
                            nn.Linear(256, num_action),
                            nn.Softmax()
                            )

     self.val_pipe = nn.Sequential(nn.Linear(state, 128),
                            nn.ReLU(),
                            nn.Dropout(0.5),
                            nn.Linear(128, 256),
                            nn.ReLU(),
                            nn.Dropout(0.5),
                            nn.Linear(256, 1)
                            )


      def forward(self, state, flag, test=None):

          temp_action_prob = self.act_pipe(state)
          self.action_prob = self.cal_prob(temp_action_prob, flag)
          self.action = self.get_action(self.action_prob)
          self.value = self.val_pipe(state)

          return self.action

我想分别更新每个网络。

而且我想知道Basic TD Actor-Critic方法使用TD错误进行丢失？或r + V（s'）和V（s）之间的平方误差？

Answer 1

我认为问题在于，在向前传播之后，在向后调用之前将梯度归零。请注意，对于automatic differentiation，您需要计算图形和前向传递期间产生的中间结果。

因此，在TD误差和目标计算之前将梯度归零！而不是在你完成前向传播之后。

    for cur_step in range(1):   
    action = M_Agent(state, flag)  
    next_state, r = env.step(action)   

    optimizer_M.zero_grad()  # zero your gradient here

    # calculate TD Error
    TD_error = M_Agent.cal_td_error(r, next_state)

    # calculate Target
    target = torch.FloatTensor([M_Agent.cal_target(TD_error)])
    logit = M_Agent.cal_logit()
    loss = criterion(logit, target)

    # update value Func
    TD_error.backward()
    optimizer_M.step()

    # update Actor Func
    loss.backward()
    optimizer_M.step()

为了回答你的第二个问题，例如DDPG算法使用平方误差（参见paper）。

另一个建议。在许多情况下，价值和政策网络的大部分都在深层行为者 - 评论者代理中共享：您拥有与最后一个隐藏层相同的层，并使用单个线性输出进行值预测，使用softmax层进行动作分配。如果您具有高维视觉输入，这尤其有用，因为它可以充当多任务学习，但您可以尝试。 （因为我看到你有一个低维状态向量）。