class_docstr: Gaussian policy that consists of FC layers with fixed covariance.
  
  This model has one output layers: the mean layer.
  The mean of the Gaussian is computed in the same way as FCGaussianPolicy.
  The variance of the Gaussian must be specified as an argument.
  
  Args:
      n_input_channels (int): Number of input channels.
      action_size (int): Number of dimensions of the action space.
      var (float or ndarray): Variance of the Gaussian distribution.
      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.
      nonlinearity (callable): Nonlinearity placed between layers.
      mean_wscale (float): Scale of weight initialization of the mean layer.
code: def __init__(
      self,
      n_input_channels,
      action_size,
      var,
      n_hidden_layers=0,
      n_hidden_channels=None,
      min_action=None,
      max_action=None,
      bound_mean=False,
      nonlinearity=F.relu,
      mean_wscale=1,
  ):
      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
      if np.isscalar(var):
          self.var = np.full(action_size, var, dtype=np.float32)
      else:
          self.var = var
      layers = []
      if n_hidden_layers > 0:
          # Input to hidden
          layers.append(L.Linear(n_input_channels, n_hidden_channels))
          layers.append(self.nonlinearity)
          for _ in range(n_hidden_layers - 1):
              # Hidden to hidden
              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),
              )
          )
      else:
          # There's only one layer for computing the mean
          layers.append(
              L.Linear(
                  n_input_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
              )
          )
  
      def get_var_array(shape):
          self.var = self.xp.asarray(self.var)
          return self.xp.broadcast_to(self.var, shape)
  
      layers.append(
          lambda x: distribution.GaussianDistribution(
              x, get_var_array(x.shape)
          )
      )
      super().__init__(*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 FCGaussianPolicyWithFixedCovariance object from inherited base classes: links, Policy with example: obj = FCGaussianPolicyWithFixedCovariance(n_input_channels, action_size, var, n_hidden_layers, n_hidden_channels, min_action, max_action, bound_mean, nonlinearity, mean_wscale)