class_docstr: GaussianCNNBaseline 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_dim (Tuple[int, int, int]): Dimensions of unflattened input,
          which means [in_height, in_width, in_channels]. If the last 3
          dimensions of input_var is not this shape, it will be reshaped.
      filters (Tuple[Tuple[int, Tuple[int, int]], ...]): Number and dimension
          of filters. For example, ((3, (3, 5)), (32, (3, 3))) means there
          are two convolutional layers. The filter for the first layer have 3
          channels and its shape is (3 x 5), while the filter for the second
          layer have 32 channels and its shape is (3 x 3).
      strides(tuple[int]): The stride of the sliding window. For example,
          (1, 2) means there are two convolutional layers. The stride of the
          filter for first layer is 1 and that of the second layer is 2.
      padding (str): The type of padding algorithm to use,
          either 'SAME' or 'VALID'.
      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 Convolutional model for mean. For example, (32, 32) means the
          network consists of two dense 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_filters (Tuple[Tuple[int, Tuple[int, int]], ...]): Number and
          dimension of filters. For example, ((3, (3, 5)), (32, (3, 3)))
          means there are two convolutional layers. The filter for the first
          layer have 3 channels and its shape is (3 x 5), while the filter
          for the second layer have 32 channels and its shape is (3 x 3).
      std_strides(tuple[int]): The stride of the sliding window. For example,
          (1, 2) means there are two convolutional layers. The stride of the
          filter for first layer is 1 and that of the second layer is 2.
      std_padding (str): The type of padding algorithm to use in std network,
          either 'SAME' or 'VALID'.
      std_hidden_sizes (list[int]): Output dimension of dense layer(s) for
          the Conv for std. For example, (32, 32) means the Conv 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.
code: def __init__(
      self,
      input_dim,
      output_dim,
      filters,
      strides,
      padding,
      hidden_sizes,
      name="GaussianCNNRegressorModel",
      hidden_nonlinearity=tf.nn.tanh,
      hidden_w_init=tf.initializers.glorot_uniform(
          seed=deterministic.get_tf_seed_stream()
      ),
      hidden_b_init=tf.zeros_initializer(),
      output_nonlinearity=None,
      output_w_init=tf.initializers.glorot_uniform(
          seed=deterministic.get_tf_seed_stream()
      ),
      output_b_init=tf.zeros_initializer(),
      learn_std=True,
      adaptive_std=False,
      std_share_network=False,
      init_std=1.0,
      min_std=1e-6,
      max_std=None,
      std_filters=(),
      std_strides=(),
      std_padding="SAME",
      std_hidden_sizes=(32, 32),
      std_hidden_nonlinearity=tf.nn.tanh,
      std_hidden_w_init=tf.initializers.glorot_uniform(
          seed=deterministic.get_tf_seed_stream()
      ),
      std_hidden_b_init=tf.zeros_initializer(),
      std_output_nonlinearity=None,
      std_output_w_init=tf.initializers.glorot_uniform(
          seed=deterministic.get_tf_seed_stream()
      ),
      std_parameterization="exp",
      layer_normalization=False,
  ):
      super().__init__(
          input_dim=input_dim,
          output_dim=output_dim,
          filters=filters,
          strides=strides,
          padding=padding,
          hidden_sizes=hidden_sizes,
          hidden_nonlinearity=hidden_nonlinearity,
          hidden_w_init=hidden_w_init,
          hidden_b_init=hidden_b_init,
          output_nonlinearity=output_nonlinearity,
          output_w_init=output_w_init,
          output_b_init=output_b_init,
          learn_std=learn_std,
          adaptive_std=adaptive_std,
          std_share_network=std_share_network,
          init_std=init_std,
          min_std=min_std,
          max_std=max_std,
          std_filters=std_filters,
          std_strides=std_strides,
          std_padding=std_padding,
          std_hidden_sizes=std_hidden_sizes,
          std_hidden_nonlinearity=std_hidden_nonlinearity,
          std_hidden_w_init=std_hidden_w_init,
          std_hidden_b_init=std_hidden_b_init,
          std_output_nonlinearity=std_output_nonlinearity,
          std_output_w_init=std_output_w_init,
          std_parameterization=std_parameterization,
          layer_normalization=layer_normalization,
          name=name,
      )
      self._input_shape = input_dim
  
file_path: garage/src/garage/tf/baselines/gaussian_cnn_baseline_model.py
imports: import numpy
  import tensorflow
  import tensorflow_probability
  from garage.experiment import deterministic
  from garage.tf.models import GaussianCNNModel
label_desc: Use image node_id 1 to create a new GaussianCNNBaselineModel object from inherited base classes: GaussianCNNModel with example: obj = GaussianCNNBaselineModel(input_dim, output_dim, filters, strides, padding, hidden_sizes, name, hidden_nonlinearity, hidden_w_init, hidden_b_init, output_nonlinearity, output_w_init, output_b_init, learn_std, adaptive_std, std_share_network, init_std, min_std, max_std, std_filters, std_strides, std_padding, std_hidden_sizes, std_hidden_nonlinearity, std_hidden_w_init, std_hidden_b_init, std_output_nonlinearity, std_output_w_init, std_parameterization, layer_normalization)