Ошибка оптимизатора Адама: одна из переменных, необходимых для вычисления градиента, была изменена операцией на месте - PullRequest
Новая
       29

Ошибка оптимизатора Адама: одна из переменных, необходимых для вычисления градиента, была изменена операцией на месте

1 голос
/ 14 апреля 2019

Я пытаюсь реализовать Алгоритм обучения актера-критика , который не совпадает с базовым алгоритмом критика актера, он немного изменился.

В любом случае, я использовал оптимизатор Адама и реализовалс pytorch

при первой обратной TD-ошибке для Critic ошибки нет.Тем не менее, я проиграл актеру, произошла ошибка.

--------------------------------------------------------------------------- RuntimeError Traceback (большинствопоследний вызов последним) в 46 # обновление Actor Func 47 optimizer_M.zero_grad () ---> 48 loss.backward () 49 optimizer_M.step () 50

~ \ Anaconda3 \ lib \ site-packages \ torch\ tenor.py в обратном направлении (само, градиент, retain_graph, create_graph) 100 продуктов.По умолчанию False.101 "" "-> 102 torch.autograd.backward (self, градиент, 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 Variable._execution_engine.run_backward (89 тензоров, grad_tensors, retain_graph, create_graph, ---> 90 allow_unreachable = True) # allow_unreachable flag 91 921016 * 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)?

1 Ответ

2 голосов
/ 14 апреля 2019

Я думаю, что проблема в том, что вы обнуляете градиенты прямо перед обратным вызовом, после прямого распространения.Обратите внимание, что для автоматического дифференцирования вам нужен график вычислений и промежуточные результаты, которые вы получаете во время прямого прохода.

Так что обнуляйте градиенты до вашей ошибки 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 для распределения действий.Это особенно полезно, если у вас есть визуальные входы большого размера, так как они выполняют функцию обучения с несколькими задачами, но, тем не менее, вы можете попробовать.(Как я вижу, у вас есть низкоразмерный вектор состояния).

...