code: def learn(self, rollout):
      value_loss_epoch = 0
      action_loss_epoch = 0
      entropy_loss_epoch = 0
      if self.config["lr_decay"]:
          lr = self.lr_scheduler.step(step_num=1)
      else:
          lr = None
  
      minibatch_size = int(
          self.config["batch_size"] // self.config["num_minibatches"]
      )
  
      indexes = np.arange(self.config["batch_size"])
      for epoch in range(self.config["update_epochs"]):
          np.random.shuffle(indexes)
          for start in range(
              0, self.config["batch_size"], minibatch_size
          ):
              end = start + minibatch_size
              sample_idx = indexes[start:end]
  
              (
                  batch_obs,
                  batch_action,
                  batch_logprob,
                  batch_adv,
                  batch_return,
                  batch_value,
              ) = rollout.sample_batch(sample_idx)
  
              batch_obs = torch.from_numpy(batch_obs).to(self.device)
              batch_action = torch.from_numpy(batch_action).to(
                  self.device
              )
              batch_logprob = torch.from_numpy(batch_logprob).to(
                  self.device
              )
              batch_adv = torch.from_numpy(batch_adv).to(self.device)
              batch_return = torch.from_numpy(batch_return).to(
                  self.device
              )
              batch_value = torch.from_numpy(batch_value).to(
                  self.device
              )
  
              value_loss, action_loss, entropy_loss = self.alg.learn(
                  batch_obs,
                  batch_action,
                  batch_value,
                  batch_return,
                  batch_logprob,
                  batch_adv,
                  lr,
              )
  
              value_loss_epoch += value_loss
              action_loss_epoch += action_loss
              entropy_loss_epoch += entropy_loss
  
      update_steps = (
          self.config["update_epochs"] * self.config["batch_size"]
      )
      value_loss_epoch /= update_steps
      action_loss_epoch /= update_steps
      entropy_loss_epoch /= update_steps
  
      return value_loss_epoch, action_loss_epoch, entropy_loss_epoch, lr
  
file_path: PARL/benchmark/torch/ppo/agent.py
imports: import parl
  import torch
  import numpy
  from parl.utils.scheduler import LinearDecayScheduler
label_desc: Use image node_id 5 for calling the PPOAgent obj's underlying member method code with example usage: obj.learn(rollout) and returns: value_loss_epoch,  action_loss_epoch,  entropy_loss_epoch,  lr