code: def batched_index_select(target, indices, flattened_indices=None):
      """
      The given ``indices`` of size ``(batch_size, d_1, ..., d_n)`` indexes into the sequence
      dimension (dimension 2) of the target, which has size ``(batch_size, sequence_length,
      embedding_size)``.
  
      This function returns selected values in the target with respect to the provided indices, which
      have size ``(batch_size, d_1, ..., d_n, embedding_size)``. This can use the optionally
      precomputed :func:`~flattened_indices` with size ``(batch_size * d_1 * ... * d_n)`` if given.
  
      An example use case of this function is looking up the start and end indices of spans in a
      sequence tensor. This is used in the
      :class:`~allennlp.models.coreference_resolution.CoreferenceResolver`. Model to select
      contextual word representations corresponding to the start and end indices of mentions. The key
      reason this can't be done with basic torch functions is that we want to be able to use look-up
      tensors with an arbitrary number of dimensions (for example, in the coref model, we don't know
      a-priori how many spans we are looking up).
  
      Parameters
      ----------
      target : ``torch.Tensor``, required.
          A 3 dimensional tensor of shape (batch_size, sequence_length, embedding_size).
          This is the tensor to be indexed.
      indices : ``torch.LongTensor``
          A tensor of shape (batch_size, ...), where each element is an index into the
          ``sequence_length`` dimension of the ``target`` tensor.
      flattened_indices : Optional[torch.Tensor], optional (default = None)
          An optional tensor representing the result of calling :func:~`flatten_and_batch_shift_indices`
          on ``indices``. This is helpful in the case that the indices can be flattened once and
          cached for many batch lookups.
  
      Returns
      -------
      selected_targets : ``torch.Tensor``
          A tensor with shape [indices.size(), target.size(-1)] representing the embedded indices
          extracted from the batch flattened target tensor.
      """
      if flattened_indices is None:
          # Shape: (batch_size * d_1 * ... * d_n)
          flattened_indices = flatten_and_batch_shift_indices(
              indices, target.size(1)
          )
  
      # Shape: (batch_size * sequence_length, embedding_size)
      flattened_target = target.view(-1, target.size(-1))
  
      # Shape: (batch_size * d_1 * ... * d_n, embedding_size)
      flattened_selected = flattened_target.index_select(
          0, flattened_indices
      )
      selected_shape = list(indices.size()) + [target.size(-1)]
      # Shape: (batch_size, d_1, ..., d_n, embedding_size)
      selected_targets = flattened_selected.view(*selected_shape)
      return selected_targets
  
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 27 for calling a global function with example usage: batched_index_select(target, indices, flattened_indices) and returns: selected_targets