code: def universal_transformer_decoder(
      decoder_input,
      encoder_output,
      decoder_self_attention_bias,
      encoder_decoder_attention_bias,
      hparams,
      name="decoder",
      nonpadding=None,
      save_weights_to=None,
      make_image_summary=True,
  ):
      """Universal Transformer decoder function.
  
      Prepares all the arguments and the inputs and passes it to a
      core_universal_transformer_layer to decoder.
  
      Args:
        decoder_input: a Tensor
        encoder_output: a Tensor
        decoder_self_attention_bias: bias Tensor for self-attention
          (see common_attention.attention_bias())
        encoder_decoder_attention_bias: bias Tensor for encoder-decoder attention
          (see common_attention.attention_bias())
        hparams: hyperparameters for model
        name: a string
        nonpadding: optional Tensor with shape [batch_size, encoder_length]
          indicating what positions are not padding.  This is used
          to mask out padding in convoltutional layers.  We generally only
          need this mask for "packed" datasets, because for ordinary datasets,
          no padding is ever followed by nonpadding.
        save_weights_to: an optional dictionary to capture attention weights
          for vizualization; the weights tensor will be appended there under
          a string key created from the variable scope (including name).
        make_image_summary: Whether to make an attention image summary.
  
      Returns:
        y: the output Tensors
        extra_output: which can be used to pass extra information to the body
      """
      x = decoder_input
      attention_dropout_broadcast_dims = (
          common_layers.comma_separated_string_to_integer_list(
              getattr(hparams, "attention_dropout_broadcast_dims", "")
          )
      )
      with tf.variable_scope(name):
          ffn_unit = functools.partial(
              transformer_decoder_ffn_unit,
              hparams=hparams,
              nonpadding_mask=nonpadding,
          )
  
          attention_unit = functools.partial(
              transformer_decoder_attention_unit,
              hparams=hparams,
              encoder_output=encoder_output,
              decoder_self_attention_bias=decoder_self_attention_bias,
              encoder_decoder_attention_bias=encoder_decoder_attention_bias,
              attention_dropout_broadcast_dims=attention_dropout_broadcast_dims,
              save_weights_to=save_weights_to,
              make_image_summary=make_image_summary,
          )
  
          x, extra_output = universal_transformer_layer(
              x, hparams, ffn_unit, attention_unit
          )
  
          return (
              common_layers.layer_preprocess(x, hparams),
              extra_output,
          )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import copy
  import functools
  from six.moves import range
  from tensor2tensor.layers import common_attention
  from tensor2tensor.layers import common_layers
  from tensor2tensor.models import transformer
  from tensor2tensor.utils import contrib
  from tensor2tensor.utils import expert_utils
  import tensorflow.compat.v1
label_desc: Use image node_id 2 for calling a global function with example usage: universal_transformer_decoder(decoder_input, encoder_output, decoder__attention_bias, encoder_decoder_attention_bias, hparams, name, nonpadding, save_weights_to, make_image_summary) and returns: common_layers,  extra_output