code: def get_final_encoder_states(
      encoder_outputs, mask, bidirectional=False
  ):
      """
      Given the output from a ``Seq2SeqEncoder``, with shape ``(batch_size, sequence_length,
      encoding_dim)``, this method returns the final hidden state for each element of the batch,
      giving a tensor of shape ``(batch_size, encoding_dim)``.  This is not as simple as
      ``encoder_outputs[:, -1]``, because the sequences could have different lengths.  We use the
      mask (which has shape ``(batch_size, sequence_length)``) to find the final state for each batch
      instance.
  
      Additionally, if ``bidirectional`` is ``True``, we will split the final dimension of the
      ``encoder_outputs`` into two and assume that the first half is for the forward direction of the
      encoder and the second half is for the backward direction.  We will concatenate the last state
      for each encoder dimension, giving ``encoder_outputs[:, -1, :encoding_dim/2]`` concated with
      ``encoder_outputs[:, 0, encoding_dim/2:]``.
      """
      # These are the indices of the last words in the sequences (i.e. length sans padding - 1).  We
      # are assuming sequences are right padded.
      # Shape: (batch_size,)
      last_word_indices = mask.sum(1).long() - 1
      batch_size, _, encoder_output_dim = encoder_outputs.size()
      expanded_indices = last_word_indices.view(-1, 1, 1).expand(
          batch_size, 1, encoder_output_dim
      )
      # Shape: (batch_size, 1, encoder_output_dim)
      final_encoder_output = encoder_outputs.gather(1, expanded_indices)
      final_encoder_output = final_encoder_output.squeeze(
          1
      )  # (batch_size, encoder_output_dim)
      if bidirectional:
          final_forward_output = final_encoder_output[
              :, : (encoder_output_dim // 2)
          ]
          final_backward_output = encoder_outputs[
              :, 0, (encoder_output_dim // 2) :
          ]
          final_encoder_output = torch.cat(
              [final_forward_output, final_backward_output], dim=-1
          )
      return final_encoder_output
  
imports: from __future__ import division
  from __future__ import absolute_import
  from collections import defaultdict
  import logging
  import math
  import torch
  from allennlp.common.checks import ConfigurationError
label_desc: Use image node_id 5 for calling a global function with example usage: get_final_encoder_states(encoder_outputs, mask, bidirectional) and returns: final_encoder_output