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: Return a clone of the encoder.
  
  It copies the configuration of the primitive and also the parameters.
  
  Args:
      name (str): Name of the newly created encoder. It has to be
          different from source encoder if cloned under the same
          computational graph.
  
  Returns:
      garage.tf.embeddings.encoder.Encoder: Newly cloned encoder.
docstr_tok: ["Return","a","clone","of","the","encoder",".","It","copies","the","configuration","of","the","primitive","and","also","the","parameters",".","Args",":","name","(","str",")",":","Name","of","the","newly","created","encoder",".","It","has","to","be","different","from","source","encoder","if","cloned","under","the","same","computational","graph",".","Returns",":","garage.tf.embeddings.encoder.Encoder",":","Newly","cloned","encoder","."]
code: def clone(self, name):
      """Return a clone of the encoder.
  
      It copies the configuration of the primitive and also the parameters.
  
      Args:
          name (str): Name of the newly created encoder. It has to be
              different from source encoder if cloned under the same
              computational graph.
  
      Returns:
          garage.tf.embeddings.encoder.Encoder: Newly cloned encoder.
  
      """
      new_encoder = self.__class__(
          embedding_spec=self._embedding_spec,
          name=name,
          hidden_sizes=self._hidden_sizes,
          hidden_nonlinearity=self._hidden_nonlinearity,
          hidden_w_init=self._hidden_w_init,
          hidden_b_init=self._hidden_b_init,
          output_nonlinearity=self._output_nonlinearity,
          output_w_init=self._output_w_init,
          output_b_init=self._output_b_init,
          learn_std=self._learn_std,
          adaptive_std=self._adaptive_std,
          std_share_network=self._std_share_network,
          init_std=self._init_std,
          min_std=self._min_std,
          max_std=self._max_std,
          std_hidden_sizes=self._std_hidden_sizes,
          std_hidden_nonlinearity=self._std_hidden_nonlinearity,
          std_output_nonlinearity=self._std_output_nonlinearity,
          std_parameterization=self._std_parameterization,
          layer_normalization=self._layer_normalization,
      )
      new_encoder.model.parameters = self.model.parameters
      return new_encoder
  
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 14 for calling the GaussianMLPEncoder obj's underlying member method code with example usage: obj.clone(name) and returns: new_encoder