class_docstr: Gaussian policy that consists of FC layers with parametrized covariance.
  
  This model has one output layers: the mean layer.
  The mean of the Gaussian is computed in the same way as FCGaussianPolicy.
  
  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_func (callable): Callable that computes the variance from the var
          parameter. It should always return positive values.
      var_param_init (float): Initial value the var parameter.
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_func=F.softplus,
      var_param_init=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.var_func = var_func
      var_size = {"spherical": 1, "diagonal": action_size}[var_type]
  
      layers = []
      layers.append(L.Linear(n_input_channels, n_hidden_channels))
      for _ in range(n_hidden_layers - 1):
          layers.append(self.nonlinearity)
          layers.append(L.Linear(n_hidden_channels, n_hidden_channels))
      layers.append(self.nonlinearity)
      # The last layer is used to compute the mean
      layers.append(
          L.Linear(
              n_hidden_channels,
              action_size,
              initialW=LeCunNormal(mean_wscale),
          )
      )
  
      if self.bound_mean:
          layers.append(
              lambda x: bound_by_tanh(
                  x, self.min_action, self.max_action
              )
          )
  
      super().__init__()
      with self.init_scope():
          self.hidden_layers = links.Sequence(*layers)
          self.var_param = chainer.Parameter(
              initializer=var_param_init, shape=(var_size,)
          )
  
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 FCGaussianPolicyWithStateIndependentCovariance object from inherited base classes: chainer, Policy with example: obj = FCGaussianPolicyWithStateIndependentCovariance(n_input_channels, action_size, n_hidden_layers, n_hidden_channels, min_action, max_action, bound_mean, var_type, nonlinearity, mean_wscale, var_func, var_param_init)