class_docstr: Gaussian policy that consists of fully-connected layers.
  
  This model has two output layers: the mean layer and the variance layer.
  The mean of the Gaussian is computed as follows:
      Let y as the output of the mean layer.
      If bound_mean=False:
          mean = y (if bound_mean=False)
  
      If bound_mean=True:
          mean = min_action + tanh(y) * (max_action - min_action) / 2
  
  The variance of the Gaussian is computed as follows:
      Let y as the output of the variance layer.
      variance = softplus(y) + min_var
  
  Args:
      n_input_channels (int): Number of input channels.
      action_size (int): Number of dimensions of the action space.
      n_hidden_layers (int): Number of hidden layers.
      n_hidden_channels (int): Number of hidden channels.
      min_action (ndarray): Minimum action. Used only when bound_mean=True.
      max_action (ndarray): Maximum action. Used only when bound_mean=True.
      var_type (str): Type of parameterization of variance. It must be
          'spherical' or 'diagonal'.
      nonlinearity (callable): Nonlinearity placed between layers.
      mean_wscale (float): Scale of weight initialization of the mean layer.
      var_wscale (float): Scale of weight initialization of the variance
          layer.
      var_bias (float): The initial value of the bias parameter for the
          variance layer.
      min_var (float): Minimum value of the variance.
code: def __init__(
      self,
      n_input_channels,
      action_size,
      n_hidden_layers=0,
      n_hidden_channels=None,
      min_action=None,
      max_action=None,
      bound_mean=False,
      var_type="spherical",
      nonlinearity=F.relu,
      mean_wscale=1,
      var_wscale=1,
      var_bias=0,
      min_var=0,
  ):
      self.n_input_channels = n_input_channels
      self.action_size = action_size
      self.n_hidden_layers = n_hidden_layers
      self.n_hidden_channels = n_hidden_channels
      self.min_action = min_action
      self.max_action = max_action
      self.bound_mean = bound_mean
      self.nonlinearity = nonlinearity
      self.min_var = min_var
      var_size = {"spherical": 1, "diagonal": action_size}[var_type]
  
      self.hidden_layers = []
      if n_hidden_layers > 0:
          self.hidden_layers.append(
              L.Linear(n_input_channels, n_hidden_channels)
          )
          for _ in range(n_hidden_layers - 1):
              self.hidden_layers.append(
                  L.Linear(n_hidden_channels, n_hidden_channels)
              )
          self.mean_layer = L.Linear(
              n_hidden_channels,
              action_size,
              initialW=LeCunNormal(mean_wscale),
          )
          self.var_layer = L.Linear(
              n_hidden_channels,
              var_size,
              initialW=LeCunNormal(var_wscale),
              initial_bias=var_bias,
          )
      else:
          self.mean_layer = L.Linear(
              n_input_channels,
              action_size,
              initialW=LeCunNormal(mean_wscale),
          )
          self.var_layer = L.Linear(
              n_input_channels,
              var_size,
              initialW=LeCunNormal(var_wscale),
              initial_bias=var_bias,
          )
  
      super().__init__(
          self.mean_layer, self.var_layer, *self.hidden_layers
      )
  
imports: from logging import getLogger
  import chainer
  from chainer import functions
  from chainer.initializers import LeCunNormal
  from chainer import links
  import numpy
  from chainerrl import distribution
  from chainerrl.functions.bound_by_tanh import bound_by_tanh
  from chainerrl import links
  from chainerrl.policy import Policy
label_desc: Use image node_id 1 to create a new FCGaussianPolicy object from inherited base classes: chainer, Policy with example: obj = FCGaussianPolicy(n_input_channels, action_size, n_hidden_layers, n_hidden_channels, min_action, max_action, bound_mean, var_type, nonlinearity, mean_wscale, var_wscale, var_bias, min_var)