garage.tf.regressors.gaussian_cnn_regressor module

A regressor based on a GaussianMLP model.

class GaussianCNNRegressor(input_shape, output_dim, filter_dims, num_filters, strides, padding, hidden_sizes, hidden_nonlinearity=<function tanh>, hidden_w_init=<tensorflow.python.ops.init_ops.GlorotUniform object>, hidden_b_init=<tensorflow.python.ops.init_ops.Zeros object>, output_nonlinearity=None, output_w_init=<tensorflow.python.ops.init_ops.GlorotUniform object>, output_b_init=<tensorflow.python.ops.init_ops.Zeros object>, name='GaussianCNNRegressor', learn_std=True, init_std=1.0, adaptive_std=False, std_share_network=False, std_filter_dims=(), std_num_filters=(), std_strides=(), std_padding='SAME', std_hidden_sizes=(), std_hidden_nonlinearity=None, std_output_nonlinearity=None, layer_normalization=False, normalize_inputs=True, normalize_outputs=True, subsample_factor=1.0, optimizer=None, optimizer_args=None, use_trust_region=True, max_kl_step=0.01)[source]

Bases: garage.tf.regressors.base.StochasticRegressor

Fits a Gaussian distribution to the outputs of a CNN.

Parameters:
  • input_shape (tuple[int]) – Input shape of the model (without the batch dimension).
  • output_dim (int) – Output dimension of the model.
  • filter_dims (tuple[int]) – Dimension of the filters. For example, (3, 5) means there are two convolutional layers. The filter for first layer is of dimension (3 x 3) and the second one is of dimension (5 x 5).
  • num_filters (tuple[int]) – Number of filters. For example, (3, 32) means there are two convolutional layers. The filter for the first layer has 3 channels and the second one with 32 channels.
  • 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’.
  • 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.
  • name – Name of this model (also used as its scope).
  • learn_std (bool) – Whether to train the standard deviation parameter of the Gaussian distribution.
  • init_std (float) – Initial standard deviation for the Gaussian distribution.
  • adaptive_std (bool) – Whether to use a neural network to learn the standard deviation of the Gaussian distribution. Unless True, the standard deviation is learned as a parameter which is not conditioned on the inputs.
  • std_share_network (bool) – Boolean for whether the mean and standard deviation models share a CNN network. If True, each is a head from a single body network. Otherwise, the parameters are estimated using the outputs of two indepedent networks.
  • std_filter_dims (tuple[int]) – Dimension of the filters. For example, (3, 5) means there are two convolutional layers. The filter for first layer is of dimension (3 x 3) and the second one is of dimension (5 x 5).
  • std_num_filters (tuple[int]) – Number of filters. For example, (3, 32) means there are two convolutional layers. The filter for the first layer has 3 channels and the second one with 32 channels.
  • 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.
  • std_hidden_nonlinearity (callable) – Nonlinearity for each hidden layer 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.
  • layer_normalization (bool) – Bool for using layer normalization or not.
  • normalize_inputs (bool) – Bool for normalizing inputs or not.
  • normalize_outputs (bool) – Bool for normalizing outputs or not.
  • subsample_factor (float) – The factor to subsample the data. By default it is 1.0, which means using all the data.
  • optimizer (garage.tf.Optimizer) – Optimizer used for fitting the model.
  • optimizer_args (dict) – Arguments for the optimizer. Default is None, which means no arguments.
  • use_trust_region (bool) – Whether to use a KL-divergence constraint.
  • max_kl_step (float) – KL divergence constraint for each iteration, if use_trust_region is active.
dist_info_sym(x_var, name=None)[source]

Create a symbolic graph of the distribution parameters.

Parameters:
  • x_var (tf.Tensor) – tf.Tensor of the input data.
  • name (str) – Name of the new graph.
Returns:

Outputs of the symbolic distribution parameter

graph.
Return type:

dict[tf.Tensor]
fit(xs, ys)[source]

Fit with input data xs and label ys.

Parameters:
  • xs (numpy.ndarray) – Input data.
  • ys (numpy.ndarray) – Label of input data.
get_params_internal(**args)[source]

Get the params, which are the trainable variables.

log_likelihood_sym(x_var, y_var, name=None)[source]

Create a symbolic graph of the log likelihood.

Parameters:
  • x_var (tf.Tensor) – Input tf.Tensor for the input data.
  • y_var (tf.Tensor) – Input tf.Tensor for the label of data.
  • name (str) – Name of the new graph.
Returns:

Output of the symbolic log-likelihood graph.
Return type:

tf.Tensor
predict(xs)[source]

Predict ys based on input xs.

Parameters:xs (numpy.ndarray) – Input data.
Returns:The predicted ys.
Return type:numpy.ndarray