class_docstr: GaussianMLPBaseline based on garage.tf.models.Model class.
  
  This class can be used to perform regression by fitting a Gaussian
  distribution to the outputs.
  
  Args:
      input_shape (tuple[int]): Input shape of the training data.
      output_dim (int): Output dimension of the model.
      name (str): Model name, also the variable scope.
      hidden_sizes (list[int]): Output dimension of dense layer(s) for
          the MLP for mean. For example, (32, 32) means the MLP consists
          of two hidden layers, each with 32 hidden units.
      hidden_nonlinearity (callable): Activation function for intermediate
          dense layer(s). It should return a tf.Tensor. Set it to
          None to maintain a linear activation.
      hidden_w_init (callable): Initializer function for the weight
          of intermediate dense layer(s). The function should return a
          tf.Tensor.
      hidden_b_init (callable): Initializer function for the bias
          of intermediate dense layer(s). The function should return a
          tf.Tensor.
      output_nonlinearity (callable): Activation function for output dense
          layer. It should return a tf.Tensor. Set it to None to
          maintain a linear activation.
      output_w_init (callable): Initializer function for the weight
          of output dense layer(s). The function should return a
          tf.Tensor.
      output_b_init (callable): Initializer function for the bias
          of output dense layer(s). The function should return a
          tf.Tensor.
      learn_std (bool): Is std trainable.
      init_std (float): Initial value for std.
      adaptive_std (bool): Is std a neural network. If False, it will be a
          parameter.
      std_share_network (bool): Boolean for whether mean and std share
          the same network.
      std_hidden_sizes (list[int]): Output dimension of dense layer(s) for
          the MLP for std. For example, (32, 32) means the MLP consists
          of two hidden layers, each with 32 hidden units.
      min_std (float): If not None, the std is at least the value of min_std,
          to avoid numerical issues.
      max_std (float): If not None, the std is at most the value of max_std,
          to avoid numerical issues.
      std_hidden_nonlinearity (callable): Nonlinearity for each hidden layer
          in the std network.
      std_hidden_w_init (callable): Initializer function for the weight
          of intermediate dense layer(s) in the std network.
      std_hidden_b_init (callable): Initializer function for the bias
          of intermediate dense layer(s) in the std network.
      std_output_nonlinearity (callable): Activation function for output
          dense layer in the std network. It should return a tf.Tensor. Set
          it to None to maintain a linear activation.
      std_output_w_init (callable): Initializer function for the weight
          of output dense layer(s) in the std network.
      std_parameterization (str): How the std should be parametrized. There
          are two options:
          - exp: the logarithm of the std will be stored, and applied a
             exponential transformation
          - softplus: the std will be computed as log(1+exp(x))
      layer_normalization (bool): Bool for using layer normalization or not.
docstr: Network output spec.
  
  Return:
      list[str]: List of key(str) for the network outputs.
docstr_tok: ["Network","output","spec",".","Return",":","list","[","str","]",":","List","of","key","(","str",")","for","the","network","outputs","."]
code: def network_output_spec(self):
      """Network output spec.
  
      Return:
          list[str]: List of key(str) for the network outputs.
  
      """
      return [
          "normalized_dist",
          "normalized_mean",
          "normalized_log_std",
          "dist",
          "mean",
          "log_std",
          "x_mean",
          "x_std",
          "y_mean",
          "y_std",
      ]
  
file_path: garage/src/garage/tf/baselines/gaussian_mlp_baseline_model.py
imports: import numpy
  import tensorflow
  import tensorflow_probability
  from garage.experiment import deterministic
  from garage.tf.models import GaussianMLPModel
label_desc: Use image node_id 2 for calling the GaussianMLPBaselineModel obj's underlying member method code with example usage: obj.network_output_spec() and returns: list