class_docstr: E2E module.
  
  :param List idims: List of dimensions of inputs
  :param int odim: dimension of outputs
  :param Namespace args: argument Namespace containing options
docstr: E2E beam search.
  
  :param list xs_list: list of list of input acoustic feature arrays
          [[(T1_1, D), (T1_2, D), ...],[(T2_1, D), (T2_2, D), ...], ...]
  :param Namespace recog_args: argument Namespace containing options
  :param list char_list: list of characters
  :param torch.nn.Module rnnlm: language model module
  :return: N-best decoding results
  :rtype: list
code: def recognize_batch(self, xs_list, recog_args, char_list, rnnlm=None):
      """E2E beam search.
  
      :param list xs_list: list of list of input acoustic feature arrays
              [[(T1_1, D), (T1_2, D), ...],[(T2_1, D), (T2_2, D), ...], ...]
      :param Namespace recog_args: argument Namespace containing options
      :param list char_list: list of characters
      :param torch.nn.Module rnnlm: language model module
      :return: N-best decoding results
      :rtype: list
      """
      prev = self.training
      self.eval()
      ilens_list = [
          np.fromiter(
              (xx.shape[0] for xx in xs_list[idx]), dtype=np.int64
          )
          for idx in range(self.num_encs)
      ]
  
      # subsample frame
      xs_list = [
          [xx[:: self.subsample_list[idx][0], :] for xx in xs_list[idx]]
          for idx in range(self.num_encs)
      ]
  
      xs_list = [
          [
              to_device(self, to_torch_tensor(xx).float())
              for xx in xs_list[idx]
          ]
          for idx in range(self.num_encs)
      ]
      xs_pad_list = [
          pad_list(xs_list[idx], 0.0) for idx in range(self.num_encs)
      ]
  
      # 1. Encoder
      hs_pad_list, hlens_list = [], []
      for idx in range(self.num_encs):
          hs_pad, hlens, _ = self.enc[idx](
              xs_pad_list[idx], ilens_list[idx]
          )
          hs_pad_list.append(hs_pad)
          hlens_list.append(hlens)
  
      # calculate log P(z_t|X) for CTC scores
      if recog_args.ctc_weight > 0.0:
          if self.share_ctc:
              lpz_list = [
                  self.ctc[0].log_softmax(hs_pad_list[idx])
                  for idx in range(self.num_encs)
              ]
          else:
              lpz_list = [
                  self.ctc[idx].log_softmax(hs_pad_list[idx])
                  for idx in range(self.num_encs)
              ]
          normalize_score = False
      else:
          lpz_list = None
          normalize_score = True
  
      # 2. Decoder
      hlens_list = [
          torch.tensor(list(map(int, hlens_list[idx])))
          for idx in range(self.num_encs)
      ]  # make sure hlens is tensor
      y = self.dec.recognize_beam_batch(
          hs_pad_list,
          hlens_list,
          lpz_list,
          recog_args,
          char_list,
          rnnlm,
          normalize_score=normalize_score,
      )
  
      if prev:
          self.train()
      return y
  
imports: import argparse
  import logging
  import math
  import os
  from itertools import groupby
  import chainer
  import numpy
  import torch
  from chainer import reporter
  from espnet.nets.asr_interface import ASRInterface
  from espnet.nets.e2e_asr_common import label_smoothing_dist
  from espnet.nets.pytorch_backend.ctc import ctc_for
  from espnet.nets.pytorch_backend.nets_utils import get_subsample, pad_list, to_device, to_torch_tensor
  from espnet.nets.pytorch_backend.rnn.attentions import att_for
  from espnet.nets.pytorch_backend.rnn.decoders import decoder_for
  from espnet.nets.pytorch_backend.rnn.encoders import Encoder, encoder_for
  from espnet.nets.scorers.ctc import CTCPrefixScorer
  from espnet.utils.cli_utils import strtobool
label_desc: Use image node_id 13 for calling the E2E obj's underlying member method code with example usage: obj.recognize_batch(xs_list, recog_args, char_list, rnnlm) and returns: y