code: def masked_dense(
      inputs,
      units,
      num_blocks=None,
      exclusive=False,
      kernel_initializer=None,
      reuse=None,
      name=None,
      *args,  # pylint: disable=keyword-arg-before-vararg
      **kwargs,
  ):
      """A autoregressively masked dense layer. Analogous to `tf.layers.dense`.
  
      See [Germain et al. (2015)][1] for detailed explanation.
  
      Args:
        inputs: Tensor input.
        units: Python `int` scalar representing the dimensionality of the output
          space.
        num_blocks: Python `int` scalar representing the number of blocks for the
          MADE masks.
        exclusive: Python `bool` scalar representing whether to zero the diagonal of
          the mask, used for the first layer of a MADE.
        kernel_initializer: Initializer function for the weight matrix.
          If `None` (default), weights are initialized using the
          `tf.glorot_random_initializer`.
        reuse: Python `bool` scalar representing whether to reuse the weights of a
          previous layer by the same name.
        name: Python `str` used to describe ops managed by this function.
        *args: `tf.layers.dense` arguments.
        **kwargs: `tf.layers.dense` keyword arguments.
  
      Returns:
        Output tensor.
  
      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
      """
      # TODO(b/67594795): Better support of dynamic shape.
      input_depth = tf.compat.dimension_value(
          tensorshape_util.with_rank_at_least(inputs.shape, 1)[-1]
      )
      if input_depth is None:
          raise NotImplementedError(
              "Rightmost dimension must be known prior to graph execution."
          )
  
      mask = _gen_mask(
          num_blocks,
          input_depth,
          units,
          MASK_EXCLUSIVE if exclusive else MASK_INCLUSIVE,
      ).T
  
      if kernel_initializer is None:
          kernel_initializer = tf1.glorot_normal_initializer()
  
      def masked_initializer(shape, dtype=None, partition_info=None):
          return mask * kernel_initializer(shape, dtype, partition_info)
  
      with tf.name_scope(name or "masked_dense"):
          layer = tf_keras.tf1_layers.Dense(
              units,
              kernel_initializer=masked_initializer,
              kernel_constraint=lambda x: mask * x,
              name=name,
              dtype=dtype_util.base_dtype(inputs.dtype),
              _scope=name,
              _reuse=reuse,
              *args,  # pylint: disable=keyword-arg-before-vararg
              **kwargs,
          )
          return layer.apply(inputs)
  
imports: import numpy
  import six
  import tensorflow.compat.v1
  import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import bijector
  from tensorflow_probability.python.bijectors import chain
  from tensorflow_probability.python.bijectors import scale
  from tensorflow_probability.python.bijectors import shift
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import tensorshape_util
  from tensorflow_probability.python.internal import tf_keras
  from tensorflow_probability.python.math.numeric import clip_by_value_preserve_gradient
  from tensorflow.python.util import deprecation
label_desc: Use image node_id 3 for calling a global function with example usage: masked_dense(inputs, units, num_blocks, exclusive, kernel_initializer, reuse, name) and returns: unknown, layer