def masked_autoregressive_default_template(hidden_layers,<EOL>shift_only=False,<EOL>activation=tf.nn.relu,<EOL>log_scale_min_clip=-<NUM_LIT>,<EOL>log_scale_max_clip=<NUM_LIT>,<EOL>log_scale_clip_gradient=False,<EOL>name=None,<EOL>*args,  <EOL>**kwargs):
name = name or "<STR_LIT>"<EOL>with tf.compat.v2.name_scope(name):<EOL><INDENT>def _fn(x):<EOL><INDENT>"""<STR_LIT>"""<EOL>input_depth = tf.compat.dimension_value(<EOL>tensorshape_util.with_rank_at_least(x.shape, <NUM_LIT:1>)[-<NUM_LIT:1>])<EOL>if input_depth is None:<EOL><INDENT>raise NotImplementedError(<EOL>"<STR_LIT>")<EOL><DEDENT>input_shape = (<EOL>np.int32(tensorshape_util.as_list(x.shape))<EOL>if tensorshape_util.is_fully_defined(x.shape) else tf.shape(input=x))<EOL>if tensorshape_util.rank(x.shape) == <NUM_LIT:1>:<EOL><INDENT>x = x[tf.newaxis, ...]<EOL><DEDENT>for i, units in enumerate(hidden_layers):<EOL><INDENT>x = masked_dense(<EOL>inputs=x,<EOL>units=units,<EOL>num_blocks=input_depth,<EOL>exclusive=True if i == <NUM_LIT:0> else False,<EOL>activation=activation,<EOL>*args,  <EOL>**kwargs)<EOL><DEDENT>x = masked_dense(<EOL>inputs=x,<EOL>units=(<NUM_LIT:1> if shift_only else <NUM_LIT:2>) * input_depth,<EOL>num_blocks=input_depth,<EOL>activation=None,<EOL>*args,  <EOL>**kwargs)<EOL>if shift_only:<EOL><INDENT>x = tf.reshape(x, shape=input_shape)<EOL>return x, None<EOL><DEDENT>x = tf.reshape(x, shape=tf.concat([input_shape, [<NUM_LIT:2>]], axis=<NUM_LIT:0>))<EOL>shift, log_scale = tf.unstack(x, num=<NUM_LIT:2>, axis=-<NUM_LIT:1>)<EOL>which_clip = (<EOL>tf.clip_by_value<EOL>if log_scale_clip_gradient else clip_by_value_preserve_gradient)<EOL>log_scale = which_clip(log_scale, log_scale_min_clip, log_scale_max_clip)<EOL>return shift, log_scale<EOL><DEDENT>return tf.compat.v1.make_template(name, _fn)<EOL><DEDENT>
Build the Masked Autoregressive Density Estimator (Germain et al., 2015).

    This will be wrapped in a make_template to ensure the variables are only
    created once. It takes the input and returns the `loc` ("mu" in [Germain et
    al. (2015)][1]) and `log_scale` ("alpha" in [Germain et al. (2015)][1]) from
    the MADE network.

    Warning: This function uses `masked_dense` to create randomly initialized
    `tf.Variables`. It is presumed that these will be fit, just as you would any
    other neural architecture which uses `tf.layers.dense`.

    #### About Hidden Layers

    Each element of `hidden_layers` should be greater than the `input_depth`
    (i.e., `input_depth = tf.shape(input)[-1]` where `input` is the input to the
    neural network). This is necessary to ensure the autoregressivity property.

    #### About Clipping

    This function also optionally clips the `log_scale` (but possibly not its
    gradient). This is useful because if `log_scale` is too small/large it might
    underflow/overflow making it impossible for the `MaskedAutoregressiveFlow`
    bijector to implement a bijection. Additionally, the `log_scale_clip_gradient`
    `bool` indicates whether the gradient should also be clipped. The default does
    not clip the gradient; this is useful because it still provides gradient
    information (for fitting) yet solves the numerical stability problem. I.e.,
    `log_scale_clip_gradient = False` means
    `grad[exp(clip(x))] = grad[x] exp(clip(x))` rather than the usual
    `grad[clip(x)] exp(clip(x))`.

    Args:
      hidden_layers: Python `list`-like of non-negative integer, scalars
        indicating the number of units in each hidden layer. Default: `[512, 512].
      shift_only: Python `bool` indicating if only the `shift` term shall be
        computed. Default: `False`.
      activation: Activation function (callable). Explicitly setting to `None`
        implies a linear activation.
      log_scale_min_clip: `float`-like scalar `Tensor`, or a `Tensor` with the
        same shape as `log_scale`. The minimum value to clip by. Default: -5.
      log_scale_max_clip: `float`-like scalar `Tensor`, or a `Tensor` with the
        same shape as `log_scale`. The maximum value to clip by. Default: 3.
      log_scale_clip_gradient: Python `bool` indicating that the gradient of
        `tf.clip_by_value` should be preserved. Default: `False`.
      name: A name for ops managed by this function. Default:
        "masked_autoregressive_default_template".
      *args: `tf.layers.dense` arguments.
      **kwargs: `tf.layers.dense` keyword arguments.

    Returns:
      shift: `Float`-like `Tensor` of shift terms (the "mu" in
        [Germain et al.  (2015)][1]).
      log_scale: `Float`-like `Tensor` of log(scale) terms (the "alpha" in
        [Germain et al. (2015)][1]).

    Raises:
      NotImplementedError: if rightmost dimension of `inputs` is unknown prior to
        graph execution.

    #### References

    [1]: Mathieu Germain, Karol Gregor, Iain Murray, and Hugo Larochelle. MADE:
         Masked Autoencoder for Distribution Estimation. In _International
         Conference on Machine Learning_, 2015. https://arxiv.org/abs/1502.03509