class_docstr: An exploration that adds white noise to continuous actions.
  
  If explore=True, returns actions plus scale (annealed over time) x
  Gaussian noise. Also, some completely random period is possible at the
  beginning.
  
  If explore=False, returns the deterministic action.
class_docstr_tok: ["An","exploration","that","adds","white","noise","to","continuous","actions",".","If","explore=True",",","returns","actions","plus","scale","(","annealed","over","time",")","x","Gaussian","noise",".","Also",",","some","completely","random","period","is","possible","at","the","beginning",".","If","explore=False",",","returns","the","deterministic","action","."]
code: def _get_torch_exploration_action(
      self,
      action_dist: ActionDistribution,
      explore: bool,
      timestep: Union[int, TensorType],
  ):
      # Set last timestep or (if not given) increase by one.
      self.last_timestep = (
          timestep if timestep is not None else self.last_timestep + 1
      )
  
      # Apply exploration.
      if explore:
          # Random exploration phase.
          if self.last_timestep < self.random_timesteps:
              (
                  action,
                  _,
              ) = self.random_exploration.get_torch_exploration_action(
                  action_dist, explore=True
              )
          # Take a Gaussian sample with our stddev (mean=0.0) and scale it.
          else:
              det_actions = action_dist.deterministic_sample()
              scale = self.scale_schedule(self.last_timestep)
              gaussian_sample = scale * torch.normal(
                  mean=torch.zeros(det_actions.size()), std=self.stddev
              ).to(self.device)
              action = torch.min(
                  torch.max(
                      det_actions + gaussian_sample,
                      torch.tensor(
                          self.action_space.low,
                          dtype=torch.float32,
                          device=self.device,
                      ),
                  ),
                  torch.tensor(
                      self.action_space.high,
                      dtype=torch.float32,
                      device=self.device,
                  ),
              )
      # No exploration -> Return deterministic actions.
      else:
          action = action_dist.deterministic_sample()
  
      # Logp=always zero.
      logp = torch.zeros(
          (action.size()[0],), dtype=torch.float32, device=self.device
      )
  
      return action, logp
  
imports: from gymnasium.spaces import Space
  import numpy
  from typing import Union, Optional
  from ray.rllib.models.action_dist import ActionDistribution
  from ray.rllib.models.modelv2 import ModelV2
  from ray.rllib.utils.annotations import override, PublicAPI
  from ray.rllib.utils.exploration.exploration import Exploration
  from ray.rllib.utils.exploration.random import Random
  from ray.rllib.utils.framework import try_import_tf, try_import_torch, get_variable, TensorType
  from ray.rllib.utils.numpy import convert_to_numpy
  from ray.rllib.utils.schedules import Schedule
  from ray.rllib.utils.schedules.piecewise_schedule import PiecewiseSchedule
  from ray.rllib.utils.tf_utils import zero_logps_from_actions
label_desc: Use image node_id 4 for calling the GaussianNoise obj's underlying member method code with example usage: obj._get_torch_exploration_action(action_dist, explore, timestep) and returns: action,  logp