Hi, I’m running into the following error:

Cudnn RNN backward can only be called in training mode

I’m pretty sure I call model.eval() before backward(), My codes are attached below
    def episode(self, deterministic=False):
        if self.noise:
            self.noise.reset_states()

        state, _ = self.env.reset()
        steps = 0

        log_probs = []
        rewards = []

        agent_wealth = [1.]
        market_wealth = [1.]
        while True:
            self.actor.eval()
            action = self.actor(torch.from_numpy(state[None, ...]).to(self.args.device))
            action.squeeze_(0)
            if self.noise and not deterministic:
                action += torch.from_numpy(self.noise.sample())

            weights, log_p = self.get_weights(action)

            next_state, reward, done, info = self.env.step(weights)
            log_probs.append(log_p)
            rewards.append(reward)

            agent_wealth.append(info['portfolio_value'])
            market_wealth.append(info['market_avg_return'] * market_wealth[-1])

            steps += 1
            state = next_state
            self.total_steps += 1
            if done and not deterministic:
                # --------update policy ---------
                self.actor.train()

                agent_sr = SharpeRatio(agent_wealth)
                market_sr = SharpeRatio(market_wealth)

                policy_gradient = []
                for log_ps in log_probs:
                    policy_gradient.append(- log_ps * (agent_sr - market_sr))

                self.optimizer.zero_grad()
                policy_gradient = torch.stack(policy_gradient).sum()
                policy_gradient.backward()
                self.optimizer.step()
                # ---------------------------

            if done:
                break
        return sum(rewards), steps

    def get_weights(self, action):
        values, indices = torch.topk(action, self.args.G)
        proportions = torch.softmax(values, dim=-1)
        weights = np.zeros_like(action.detach().cpu().numpy())
        for i, indice in enumerate(indices):
            weights[indice.item()] = proportions[i].detach().cpu().numpy()
        log_p = torch.log(proportions)
        return weights, log_p

the episode method executes the interacting and learning procedure of the agent, and the get_weights method get the real weight pass to the environment according to the network’s output, as you can see, I called model.train() method before policy_gradient.backward(), so anyone can tell me where is the problem?