Adam优化器错误:梯度计算所需的变量之一已被内部操作修改。

Question

我正在尝试实现的actor-批评家学习算法，它与基本的演员-评论家算法不一样，它有一点变化。

不管怎样，我使用了Adam优化器，并用py手电筒实现了。

当我首先为评论家返回TD-错误时，没有错误。但是，我向后丢失了演员，出现了错误。

46 #更新Actor Func 47中的跟踪(最近一次调用)optimizer_M.zero_grad() --> 48 loss.backward() 49 optimizer_M.step() 50 ~\Anaconda3 3\lib\site-packages\torch\tensor.py在向后(self，梯度，retain_graph，create_graph) 100个产品中。默认为False。101“”-> 102 torch.autograd.backward(self，梯度，retain_graph，create_graph) 103104 def register_hook(self，钩子)： ~\Anaconda3\lib\site-packages\torch\autograd__init__.py in向后(张量，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标志91 92 RuntimeError:梯度计算所需的变量之一已被内部操作修改

以上是错误的内容。

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

以下是主要代码：

        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

我想分别更新每个网络。

我想知道，基本的TD演员批评家方法使用TD错误作为损失？？还是r+V(s')和V(s)之间的平方误差？

Answer 1

我认为问题是，在向后调用之前，在前向传播之后，将梯度归零。请注意，对于自动微分，您需要计算图和在前进过程中产生的中间结果。

因此，在计算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算法使用了平方错误(参见纸)。

另一项建议。在许多情况下，价值和策略网络的很大一部分是由深入的参与者-批判者代理共享的:您有到最后一个隐藏层的相同层，并且使用单个线性输出进行值预测，而使用softmax层作为动作分布。这是特别有用的，如果你有高维视觉输入，因为它作为一种多任务学习，但无论如何，你可以尝试。(如我所见，你有一个低维状态向量)。