code: def decoder(
      decoder_input,
      encoder_output,
      decoder_self_attention_bias,
      encoder_decoder_attention_bias,
      hparams,
      name="decoder",
      save_weights_to=None,
      make_image_summary=True,
  ):
      """A stack of transformer layers.
  
      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
        save_weights_to: an optional dictionary to capture attention weights
          for visualization; 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: a Tensors
      """
      x = decoder_input
      with tf.variable_scope(name):
          for layer in range(
              hparams.num_decoder_layers or hparams.num_hidden_layers
          ):
              layer_name = "layer_%d" % layer
              with tf.variable_scope(layer_name):
                  with tf.variable_scope("self_attention"):
                      y = common_attention.multihead_attention(
                          common_layers.layer_preprocess(x, hparams),
                          None,
                          decoder_self_attention_bias,
                          hparams.attention_key_channels
                          or hparams.hidden_size,
                          hparams.attention_value_channels
                          or hparams.hidden_size,
                          hparams.hidden_size,
                          hparams.num_heads,
                          hparams.attention_dropout,
                          attention_type=hparams.self_attention_type,
                          save_weights_to=save_weights_to,
                          make_image_summary=make_image_summary,
                      )
                      utils.collect_named_outputs(
                          "norms",
                          "decoder_self_attention_%d" % (layer),
                          tf.norm(y, axis=-1),
                      )
                      x = common_layers.layer_postprocess(x, y, hparams)
                      utils.collect_named_outputs(
                          "norms",
                          "decoder_self_attention_post_%d" % (layer),
                          tf.norm(x, axis=-1),
                      )
                  if encoder_output is not None:
                      with tf.variable_scope("encdec_attention"):
                          y = common_attention.multihead_attention(
                              common_layers.layer_preprocess(
                                  x, hparams
                              ),
                              encoder_output,
                              encoder_decoder_attention_bias,
                              hparams.attention_key_channels
                              or hparams.hidden_size,
                              hparams.attention_value_channels
                              or hparams.hidden_size,
                              hparams.hidden_size,
                              hparams.num_heads,
                              hparams.attention_dropout,
                              save_weights_to=save_weights_to,
                              make_image_summary=make_image_summary,
                          )
                          utils.collect_named_outputs(
                              "norms",
                              "decoder_encoder_attention_%d" % (layer),
                              tf.norm(y, axis=-1),
                          )
                          x = common_layers.layer_postprocess(
                              x, y, hparams
                          )
                          utils.collect_named_outputs(
                              "norms",
                              "decoder_encoder_attention_post_%d"
                              % (layer),
                              tf.norm(x, axis=-1),
                          )
                  with tf.variable_scope("ffn"):
                      y = common_layers.dense_relu_dense(
                          common_layers.layer_preprocess(x, hparams),
                          hparams.filter_size,
                          hparams.hidden_size,
                          dropout=hparams.relu_dropout,
                      )
                      utils.collect_named_outputs(
                          "norms",
                          "decoder_ffn_%d" % (layer),
                          tf.norm(y, axis=-1),
                      )
                      x = common_layers.layer_postprocess(x, y, hparams)
                      utils.collect_named_outputs(
                          "norms",
                          "decoder_ffn_post_%d" % (layer),
                          tf.norm(x, axis=-1),
                      )
          # if normalization is done in layer_preprocess, then it should also be done
          # on the output, since the output can grow very large, being the sum of
          # a whole stack of unnormalized layer outputs.
          return common_layers.layer_preprocess(x, hparams)
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from six.moves import range
  from tensor2tensor.layers import common_attention
  from tensor2tensor.layers import common_hparams
  from tensor2tensor.layers import common_layers
  from tensor2tensor.layers import vqa_layers
  from tensor2tensor.models.research import vqa_attention
  from tensor2tensor.utils import registry
  import tensorflow.compat.v1
  from tensorflow.compat.v1 import estimator
  from tensorflow.contrib.layers.python.layers import utils
label_desc: Use image node_id 8 for calling a global function with example usage: decoder(decoder_input, encoder_output, decoder__attention_bias, encoder_decoder_attention_bias, hparams, name, save_weights_to, make_image_summary) and returns: common_layers