class_docstr: GaussianMLPEncoder with GaussianMLPModel.
  
  An embedding that contains a MLP to make prediction based on
  a gaussian distribution.
  
  Args:
      embedding_spec (garage.InOutSpec):
          Encoder specification.
      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.
      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.
      init_std (float): Initial value for std.
      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. It should return a tf.Tensor. Set it to None to
          maintain a linear activation.
      std_output_nonlinearity (callable): Nonlinearity for output layer in
          the std network. It should return a tf.Tensor. Set it to None to
          maintain a linear activation.
      std_parameterization (str): How the std should be parametrized. There
          are a few 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: Get samples of embedding for the given inputs.
  
  Args:
      input_values (numpy.ndarray): Tensors to encode.
  
  Returns:
      numpy.ndarray: Embeddings sampled from embedding distribution.
      dict: Embedding distribution information.
  
  Note:
      It returns an embedding and a dict, with keys
      - mean (list[numpy.ndarray]): Means of the distribution.
      - log_std (list[numpy.ndarray]): Log standard deviations of the
          distribution.
docstr_tok: ["Get","samples","of","embedding","for","the","given","inputs",".","Args",":","input_values","(","numpy.ndarray",")",":","Tensors","to","encode",".","Returns",":","numpy.ndarray",":","Embeddings","sampled","from","embedding","distribution",".","dict",":","Embedding","distribution","information",".","Note",":","It","returns","an","embedding","and","a","dict",",","with","keys","-","mean","(","list","[","numpy.ndarray","]",")",":","Means","of","the","distribution",".","-","log_std","(","list","[","numpy.ndarray","]",")",":","Log","standard","deviations","of","the","distribution","."]
code: def get_latents(self, input_values):
      """Get samples of embedding for the given inputs.
  
      Args:
          input_values (numpy.ndarray): Tensors to encode.
  
      Returns:
          numpy.ndarray: Embeddings sampled from embedding distribution.
          dict: Embedding distribution information.
  
      Note:
          It returns an embedding and a dict, with keys
          - mean (list[numpy.ndarray]): Means of the distribution.
          - log_std (list[numpy.ndarray]): Log standard deviations of the
              distribution.
  
      """
      flat_input = self._embedding_spec.input_space.flatten_n(
          input_values
      )
      samples, means, log_stds = self._f_dist(
          np.expand_dims(flat_input, 1)
      )
      samples = self._embedding_spec.output_space.unflatten_n(
          np.squeeze(samples, 1)
      )
      means = self._embedding_spec.output_space.unflatten_n(
          np.squeeze(means, 1)
      )
      log_stds = self._embedding_spec.output_space.unflatten_n(
          np.squeeze(log_stds, 1)
      )
      return samples, dict(mean=means, log_std=log_stds)
  
imports: import numpy
  import tensorflow
  from garage.experiment import deterministic
  from garage.tf.embeddings import StochasticEncoder
  from garage.tf.models import GaussianMLPModel, StochasticModule
label_desc: Use image node_id 9 for calling the GaussianMLPEncoder obj's underlying member method code with example usage: obj.get_latents(input_values) and returns: samples,  dict