code: def _super_stack(inputs, attention_bias, hparams, mp, padding="LEFT"):
      """A stack of super_lm layers.
  
      Args:
        inputs: a list of Tensors
        attention_bias: list of bias Tensor for self-attention
          (see common_attention.attention_bias())
        hparams: hyperparameters for model
        mp: a Parallelism object
        padding: a string
  
      Returns:
        y: a list of Tensors
        extra_loss: an optional scalar
      """
      layers = hparams.layers.strip(",").split(",")
      moe_hidden_sizes = [
          int(s) for s in hparams.moe_hidden_sizes.split(",")
      ]
      if hparams.diet_experts:
          (hsize,) = moe_hidden_sizes
  
          def _diet_expert(x):
              return diet.diet_expert(
                  x, hsize, diet.diet_adam_optimizer_params()
              )
  
          expert_fn = _diet_expert
      else:
          expert_fn = expert_utils.ffn_expert_fn(
              hparams.hidden_size, moe_hidden_sizes, hparams.hidden_size
          )
      # scaled_dot_product_attention_with_projections uses a 3d attention bias
      # (no heads), where multihead_attention uses 4d attention bias.
      attention_bias_3d = mp(tf.squeeze, attention_bias, 1)
      mix_size = int(hparams.mix_fraction * hparams.hidden_size)
      accumulator = inputs
      x = inputs
      extra_losses = []
      for layer_num, layer_type in enumerate(layers):
          with tf.variable_scope("%s_%d" % (layer_type, layer_num)):
              tf.logging.info("%s_%d" % (layer_type, layer_num))
              if layer_type == "a":
                  # accumulate
                  accumulator = mp(tf.add, x, accumulator)
                  x = accumulator
              elif layer_type == "n":
                  # normalize
                  x = mp(
                      common_layers.apply_norm,
                      x,
                      hparams.norm_type,
                      hparams.hidden_size,
                      hparams.norm_epsilon,
                  )
              elif layer_type == "d":
                  # dropout
                  x = mp(
                      tf.nn.dropout,
                      x,
                      1.0 - hparams.layer_prepostprocess_dropout,
                  )
              elif layer_type == "m":
                  # mix across shards
                  def _split(t):
                      return tuple(
                          tf.split(
                              t,
                              [
                                  mix_size,
                                  hparams.hidden_size - mix_size,
                              ],
                              2,
                          )
                      )
  
                  to_mix, to_keep = mp(_split, x)
                  mixed = expert_utils.all_reduce_ring(to_mix, mp)
                  mixed = mp(tf.multiply, mixed, mp.n**-0.5)
                  x = mp(
                      lambda a, b: tf.concat([a, b], 2), mixed, to_keep
                  )
              elif layer_type == "att":
                  # single-head attention
                  q = mp(
                      tf.layers.dense,
                      x,
                      hparams.hidden_size,
                      use_bias=False,
                      name="q_transform",
                  )
                  x = mp(
                      common_attention.scaled_dot_product_attention_simple,
                      q,
                      x,
                      x,
                      attention_bias_3d,
                  )
                  x = mp(
                      tf.layers.dense,
                      x,
                      hparams.hidden_size,
                      use_bias=False,
                      name="o_transform",
                  )
              elif layer_type == "multihead-att":
                  # multi-head attention
                  x = mp(
                      common_attention.multihead_attention,
                      x,
                      None,
                      attention_bias,  # bias
                      hparams.multihead_attention_key_channels
                      or hparams.hidden_size,
                      hparams.multihead_attention_value_channels
                      or hparams.hidden_size,
                      hparams.hidden_size,
                      hparams.multihead_attention_num_heads,
                      hparams.attention_dropout,
                  )
              elif layer_type == "ffn":
                  x = mp(
                      common_layers.dense_relu_dense,
                      x,
                      hparams.filter_size,
                      hparams.hidden_size,
                  )
              elif layer_type == "conv":
                  # convolution
                  x = mp(
                      common_layers.conv1d,
                      x,
                      hparams.hidden_size,
                      hparams.kernel_height,
                      activation=tf.nn.relu,
                      padding=padding,
                  )
              elif layer_type == "moe":
                  # mixture of experts - each model shard has its own local MoE.
                  x, loss = mp(
                      expert_utils.local_moe,
                      x,
                      train=hparams.mode == tf_estimator.ModeKeys.TRAIN,
                      expert_fn=expert_fn,
                      num_experts=hparams.moe_num_experts,
                      k=hparams.moe_k,
                      loss_coef=hparams.moe_loss_coef,
                  )
                  extra_losses.extend(loss)
              else:
                  assert False, "unknown sublayer %s" % layer_type
      if extra_losses:
          extra_loss = tf.add_n(extra_losses)
      else:
          extra_loss = None
      return x, extra_loss
  
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 modalities
  from tensor2tensor.utils import diet
  from tensor2tensor.utils import expert_utils
  from tensor2tensor.utils import registry
  from tensor2tensor.utils import t2t_model
  import tensorflow.compat.v1
  from tensorflow.compat.v1 import estimator
label_desc: Use image node_id 1 for calling a global function with example usage: _super_stack(inputs, attention_bias, hparams, mp, padding) and returns: x,  extra_loss, diet, tuple