class_docstr: Transformer that predicts blocks of the output in parallel.
code: def body(self, features):
      assert self._hparams.block_size > 0
      assert not common_layers.is_xla_compiled()
      assert "targets_segmentation" not in features
  
      decoder_output = super(TransformerBlockParallel, self).body(
          features
      )
      assert not isinstance(decoder_output, tuple)
      assert len(decoder_output.shape) == 4
  
      relu_dropout_broadcast_dims = (
          common_layers.comma_separated_string_to_integer_list(
              getattr(self._hparams, "relu_dropout_broadcast_dims", "")
          )
      )
  
      with tf.variable_scope(
          "block_size_%d" % self._hparams.block_size
      ):
          block_output = common_layers.dense_relu_dense(
              decoder_output,
              self._hparams.block_size * self._hparams.filter_size,
              self._hparams.block_size * self._hparams.hidden_size,
              dropout=self._hparams.relu_dropout,
              dropout_broadcast_dims=relu_dropout_broadcast_dims,
          )
  
      batch_size, length = common_layers.shape_list(decoder_output)[:2]
      block_output = tf.reshape(
          block_output,
          [
              batch_size,
              length,
              self._hparams.block_size,
              self._hparams.hidden_size,
          ],
      )
  
      block_output = common_layers.layer_postprocess(
          decoder_output, block_output, self._hparams
      )
  
      return block_output
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from tensor2tensor.data_generators import text_encoder
  from tensor2tensor.layers import common_layers
  from tensor2tensor.models import transformer
  from tensor2tensor.utils import registry
  import tensorflow.compat.v1
  from tensorflow.compat.v1 import estimator
label_desc: Use image node_id 1 for calling the TransformerBlockParallel obj's underlying member method code with example usage: obj.body(features) and returns: block_output