code: def transformer_encoder(
      encoder_input,
      encoder_self_attention_bias,
      hparams,
      name="encoder",
      nonpadding=None,
      save_weights_to=None,
      make_image_summary=True,
      losses=None,
      attn_bias_for_padding=None,
  ):
      """A stack of transformer layers.
  
      Args:
        encoder_input: a Tensor
        encoder_self_attention_bias: bias Tensor for self-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 must either be
          passed in, which we do for "packed" datasets, or inferred from
          encoder_self_attention_bias.  The knowledge about padding is used
          for pad_remover(efficiency) and to mask out padding in convolutional
          layers.
        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.
        losses: optional list onto which to append extra training losses
        attn_bias_for_padding: Padded attention bias in case a unidirectional
          encoder is being used where future attention is masked.
  
      Returns:
        y: a Tensors
      """
      x = encoder_input
      attention_dropout_broadcast_dims = (
          common_layers.comma_separated_string_to_integer_list(
              getattr(hparams, "attention_dropout_broadcast_dims", "")
          )
      )
      mlperf_log.transformer_print(
          key=mlperf_log.MODEL_HP_NUM_HIDDEN_LAYERS,
          value=hparams.num_encoder_layers or hparams.num_hidden_layers,
      )
      mlperf_log.transformer_print(
          key=mlperf_log.MODEL_HP_ATTENTION_DROPOUT,
          value=hparams.attention_dropout,
      )
      mlperf_log.transformer_print(
          key=mlperf_log.MODEL_HP_ATTENTION_DENSE,
          value={
              "use_bias": "false",
              "num_heads": hparams.num_heads,
              "hidden_size": hparams.hidden_size,
          },
      )
  
      with tf.variable_scope(name):
          if nonpadding is not None:
              padding = 1.0 - nonpadding
          else:
              attention_bias = encoder_self_attention_bias
              if attn_bias_for_padding is not None:
                  attention_bias = attn_bias_for_padding
              padding = common_attention.attention_bias_to_padding(
                  attention_bias
              )
              nonpadding = 1.0 - padding
          pad_remover = None
          if (
              hparams.use_pad_remover
              and not common_layers.is_xla_compiled()
          ):
              pad_remover = expert_utils.PadRemover(padding)
          for layer in range(
              hparams.num_encoder_layers or hparams.num_hidden_layers
          ):
              with tf.variable_scope("layer_%d" % layer):
                  with tf.variable_scope("self_attention"):
                      if layer < hparams.get("num_area_layers", 0):
                          max_area_width = hparams.get(
                              "max_area_width", 1
                          )
                          max_area_height = hparams.get(
                              "max_area_height", 1
                          )
                          memory_height = hparams.get(
                              "memory_height", 1
                          )
                      else:
                          max_area_width = 1
                          max_area_height = 1
                          memory_height = 1
                      y = common_attention.multihead_attention(
                          common_layers.layer_preprocess(x, hparams),
                          None,
                          encoder_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,
                          max_relative_position=hparams.max_relative_position,
                          heads_share_relative_embedding=(
                              hparams.heads_share_relative_embedding
                          ),
                          add_relative_to_values=hparams.add_relative_to_values,
                          save_weights_to=save_weights_to,
                          make_image_summary=make_image_summary,
                          dropout_broadcast_dims=attention_dropout_broadcast_dims,
                          max_length=hparams.get("max_length"),
                          vars_3d=hparams.get("attention_variables_3d"),
                          activation_dtype=hparams.get(
                              "activation_dtype", "float32"
                          ),
                          weight_dtype=hparams.get(
                              "weight_dtype", "float32"
                          ),
                          hard_attention_k=hparams.get(
                              "hard_attention_k", 0
                          ),
                          gumbel_noise_weight=hparams.get(
                              "gumbel_noise_weight", 0.0
                          ),
                          max_area_width=max_area_width,
                          max_area_height=max_area_height,
                          memory_height=memory_height,
                          area_key_mode=hparams.get(
                              "area_key_mode", "none"
                          ),
                          area_value_mode=hparams.get(
                              "area_value_mode", "none"
                          ),
                          training=(
                              hparams.get(
                                  "mode", tf_estimator.ModeKeys.TRAIN
                              )
                              == tf_estimator.ModeKeys.TRAIN
                          ),
                      )
                      x = common_layers.layer_postprocess(x, y, hparams)
                  with tf.variable_scope("ffn"):
                      y = transformer_ffn_layer(
                          common_layers.layer_preprocess(x, hparams),
                          hparams,
                          pad_remover,
                          conv_padding="SAME",
                          nonpadding_mask=nonpadding,
                          losses=losses,
                      )
                      x = common_layers.layer_postprocess(x, y, hparams)
          # 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.
          mlperf_log.transformer_print(
              key=mlperf_log.MODEL_HP_NORM,
              value={"hidden_size": hparams.hidden_size},
          )
          return common_layers.layer_preprocess(x, hparams)
  
file_path: tensor2tensor/tensor2tensor/layers/transformer_layers.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from tensor2tensor.layers import common_attention
  from tensor2tensor.layers import common_layers
  from tensor2tensor.utils import expert_utils
  from tensor2tensor.utils import mlperf_log
  import tensorflow.compat.v1
  from tensorflow.compat.v1 import estimator
label_desc: Use image node_id 3 for calling a global function with example usage: transformer_encoder(encoder_input, encoder__attention_bias, hparams, name, nonpadding, save_weights_to, make_image_summary, losses, attn_bias_for_padding) and returns: common_layers