code: def transformer_ffn_layer(
      x,
      hparams,
      pad_remover=None,
      conv_padding="LEFT",
      nonpadding_mask=None,
      losses=None,
      cache=None,
      decode_loop_step=None,
      readout_filter_size=0,
      layer_collection=None,
  ):
      """Feed-forward layer in the transformer.
  
      Args:
        x: a Tensor of shape [batch_size, length, hparams.hidden_size]
        hparams: hyperparameters for model
        pad_remover: an expert_utils.PadRemover object tracking the padding
          positions. If provided, when using convolutional settings, the padding
          is removed before applying the convolution, and restored afterward. This
          can give a significant speedup.
        conv_padding: a string - either "LEFT" or "SAME".
        nonpadding_mask: an optional Tensor with shape [batch_size, length].
          needed for convolutional layers with "SAME" padding.
          Contains 1.0 in positions corresponding to nonpadding.
        losses: optional list onto which to append extra training losses
        cache: dict, containing tensors which are the results of previous
            attentions, used for fast decoding.
        decode_loop_step: An integer, step number of the decoding loop.
            Only used for inference on TPU.
        readout_filter_size: if it's greater than 0, then it will be used instead of
          filter_size
        layer_collection: A tensorflow_kfac.LayerCollection. Only used by the
          KFAC optimizer. Default is None.
  
  
      Returns:
        a Tensor of shape [batch_size, length, hparams.hidden_size]
  
      Raises:
        ValueError: If losses arg is None, but layer generates extra losses.
      """
      ffn_layer = hparams.ffn_layer
      relu_dropout_broadcast_dims = (
          common_layers.comma_separated_string_to_integer_list(
              getattr(hparams, "relu_dropout_broadcast_dims", "")
          )
      )
      if ffn_layer == "conv_hidden_relu":
          # Backwards compatibility
          ffn_layer = "dense_relu_dense"
      if ffn_layer == "dense_relu_dense":
          # In simple convolution mode, use `pad_remover` to speed up processing.
          mlperf_log.transformer_print(
              key=mlperf_log.MODEL_HP_FFN_FILTER_DENSE,
              value={
                  "filter_size": hparams.filter_size,
                  "use_bias": "True",
                  "activation": mlperf_log.RELU,
              },
          )
          mlperf_log.transformer_print(
              key=mlperf_log.MODEL_HP_FFN_OUTPUT_DENSE,
              value={
                  "hidden_size": hparams.hidden_size,
                  "use_bias": "True",
              },
          )
          mlperf_log.transformer_print(
              key=mlperf_log.MODEL_HP_RELU_DROPOUT,
              value=hparams.relu_dropout,
          )
          if pad_remover:
              original_shape = common_layers.shape_list(x)
              # Collapse `x` across examples, and remove padding positions.
              x = tf.reshape(
                  x, tf.concat([[-1], original_shape[2:]], axis=0)
              )
              x = tf.expand_dims(pad_remover.remove(x), axis=0)
          conv_output = common_layers.dense_relu_dense(
              x,
              hparams.filter_size,
              hparams.hidden_size,
              dropout=hparams.relu_dropout,
              dropout_broadcast_dims=relu_dropout_broadcast_dims,
              layer_collection=layer_collection,
          )
          if pad_remover:
              # Restore `conv_output` to the original shape of `x`, including padding.
              conv_output = tf.reshape(
                  pad_remover.restore(tf.squeeze(conv_output, axis=0)),
                  original_shape,
              )
          return conv_output
      elif ffn_layer == "conv_relu_conv":
          return common_layers.conv_relu_conv(
              x,
              readout_filter_size or hparams.filter_size,
              hparams.hidden_size,
              first_kernel_size=hparams.conv_first_kernel,
              second_kernel_size=1,
              padding=conv_padding,
              nonpadding_mask=nonpadding_mask,
              dropout=hparams.relu_dropout,
              cache=cache,
              decode_loop_step=decode_loop_step,
          )
      elif ffn_layer == "parameter_attention":
          return common_attention.parameter_attention(
              x,
              hparams.parameter_attention_key_channels
              or hparams.hidden_size,
              hparams.parameter_attention_value_channels
              or hparams.hidden_size,
              hparams.hidden_size,
              readout_filter_size or hparams.filter_size,
              hparams.num_heads,
              hparams.attention_dropout,
          )
      elif ffn_layer == "conv_hidden_relu_with_sepconv":
          return common_layers.conv_hidden_relu(
              x,
              readout_filter_size or hparams.filter_size,
              hparams.hidden_size,
              kernel_size=(3, 1),
              second_kernel_size=(31, 1),
              padding="LEFT",
              dropout=hparams.relu_dropout,
          )
      elif ffn_layer == "sru":
          return common_layers.sru(x)
      elif ffn_layer == "local_moe_tpu":
          overhead = hparams.moe_overhead_eval
          if hparams.mode == tf_estimator.ModeKeys.TRAIN:
              overhead = hparams.moe_overhead_train
          ret, loss = expert_utils.local_moe_tpu(
              x,
              hparams.filter_size // 2,
              hparams.hidden_size,
              hparams.moe_num_experts,
              overhead=overhead,
              loss_coef=hparams.moe_loss_coef,
          )
      elif ffn_layer == "local_moe":
          overhead = hparams.moe_overhead_eval
          if hparams.mode == tf_estimator.ModeKeys.TRAIN:
              overhead = hparams.moe_overhead_train
          ret, loss = expert_utils.local_moe(
              x,
              True,
              expert_utils.ffn_expert_fn(
                  hparams.hidden_size,
                  [hparams.filter_size],
                  hparams.hidden_size,
              ),
              hparams.moe_num_experts,
              k=hparams.moe_k,
              hparams=hparams,
          )
          losses.append(loss)
          return ret
      else:
          assert ffn_layer == "none"
          return x
  
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 4 for calling a global function with example usage: transformer_ffn_layer(x, hparams, pad_remover, conv_padding, nonpadding_mask, losses, cache, decode_loop_step, readout_filter_size, layer_collection) and returns: conv_output, common_layers, common_attention, common_layers, common_layers, ret, x