Question

我正在尝试实现与基本的actor-critic算法不同的 Actor-Critic学习自动演算法。

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

当我先向批评家提出TD错误时，没有任何错误。但是，我为Actor倒退，发生了错误。

-------------------------------------------------- ---------------------------- RuntimeError Traceback（最近一次调用   最后）        46＃更新演员功能        47优化器_M.zero_grad（）   ---> 48 loss.backward（）        49 Optimizer_M.step（）        50

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

〜\ Anaconda3 \ lib \ site-packages \ torch \ autograd__init __。py在   向后（张量，grad_tensors，retain_graph，create_graph，   grad_variables）        第88章        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 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层进行操作分布。如果您具有高维度的视觉输入，这将特别有用，因为它可以作为多任务学习的一种手段，但是您仍然可以尝试。（据我所知，您有一个低维状态向量）。

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

1 个答案: