class_docstr: RNN decoder with attention mechanism.
  
  Args:
      memory: The memory to query, e.g., the output of an RNN encoder. This
          tensor should be shaped `[batch_size, max_time, dim]`.
      memory_sequence_length (optional): A tensor of shape `[batch_size]`
          containing the sequence lengths for the batch
          entries in memory. If provided, the memory tensor rows are masked
          with zeros for values past the respective sequence lengths.
      cell (RNNCell, optional): An instance of `RNNCell`. If `None`, a cell
          is created as specified in :attr:`hparams`.
      cell_dropout_mode (optional): A Tensor taking value of
          :tf_main:`tf.estimator.ModeKeys <estimator/ModeKeys>`, which
          toggles dropout in the RNN cell (e.g., activates dropout in
          TRAIN mode). If `None`, :func:`~texar.tf.global_mode` is used.
          Ignored if :attr:`cell` is given.
      vocab_size (int, optional): Vocabulary size. Required if
          :attr:`output_layer` is `None`.
      output_layer (optional): An output layer that transforms cell output
          to logits. This can be:
  
          - A callable layer, e.g., an instance             of :tf_main:`tf.layers.Layer <layers/Layer>`.
          - A tensor. A dense layer will be created using the tensor             as the kernel weights. The bias of the dense layer is determined by            `hparams.output_layer_bias`. This can be used to tie the output             layer with the input embedding matrix, as proposed in             https://arxiv.org/pdf/1608.05859.pdf
          - `None`. A dense layer will be created based on attr:`vocab_size`            and `hparams.output_layer_bias`.
          - If no output layer after the cell output is needed, set             `(vocab_size=None, output_layer=tf.identity)`.
      cell_input_fn (callable, optional): A callable that produces RNN cell
          inputs. If `None` (default), the default is used:
          `lambda inputs, attention: tf.concat([inputs, attention], -1)`,
          which cancats regular RNN cell inputs with attentions.
      hparams (dict, optional): Hyperparameters. Missing
          hyperparamerter will be set to default values. See
          :meth:`default_hparams` for the hyperparameter sturcture and
          default values.
  
  See :meth:`~texar.tf.modules.RNNDecoderBase._build` for the inputs and outputs
  of the decoder. The decoder returns
  `(outputs, final_state, sequence_lengths)`, where `outputs` is an instance
  of :class:`~texar.tf.modules.AttentionRNNDecoderOutput`.
  
  Example:
  
      .. code-block:: python
  
          # Encodes the source
          enc_embedder = WordEmbedder(data.source_vocab.size, ...)
          encoder = UnidirectionalRNNEncoder(...)
  
          enc_outputs, _ = encoder(
              inputs=enc_embedder(data_batch['source_text_ids']),
              sequence_length=data_batch['source_length'])
  
          # Decodes while attending to the source
          dec_embedder = WordEmbedder(vocab_size=data.target_vocab.size, ...)
          decoder = AttentionRNNDecoder(
              memory=enc_outputs,
              memory_sequence_length=data_batch['source_length'],
              vocab_size=data.target_vocab.size)
  
          outputs, _, _ = decoder(
              decoding_strategy='train_greedy',
              inputs=dec_embedder(data_batch['target_text_ids']),
              sequence_length=data_batch['target_length']-1)
docstr: The state size of the attention-wrapped cell.
  Equivalent to :attr:`decoder.cell.state_size`.
docstr_tok: ["The","state","size","of","the","attention-wrapped","cell",".","Equivalent","to",":","attr",":","`","decoder.cell.state_size","`","."]
code: def wrapper_state_size(self):
      """The state size of the attention-wrapped cell.
      Equivalent to :attr:`decoder.cell.state_size`.
      """
      return self._cell.state_size
  
imports: import collections
  import copy
  import tensorflow
  from tensorflow.contrib.seq2seq import AttentionWrapper
  from tensorflow.python.util import nest
  from tensorflow.contrib.seq2seq import tile_batch
  from texar.tf.modules.decoders.rnn_decoder_base import RNNDecoderBase
  from texar.tf.utils import utils
label_desc: Use image node_id 14 for calling the AttentionRNNDecoder obj's underlying member method code with example usage: obj.wrapper_state_size() and returns: self