class_docstr: E2E module.
  
  :param int idim: dimension of inputs
  :param int odim: dimension of outputs
  :param Namespace args: argument Namespace containing options
class_docstr_tok: ["E2E","module",".",":","param","int","idim",":","dimension","of","inputs",":","param","int","odim",":","dimension","of","outputs",":","param","Namespace","args",":","argument","Namespace","containing","options"]
docstr: E2E batch beam search.
  
  :param list xs: list of input acoustic feature arrays [(T_1, D), (T_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, recog_args, char_list, rnnlm=None):
      """E2E batch beam search.
  
      :param list xs: list of input acoustic feature arrays [(T_1, D), (T_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 = np.fromiter((xx.shape[0] for xx in xs), dtype=np.int64)
  
      # subsample frame
      xs = [xx[:: self.subsample[0], :] for xx in xs]
      xs = [to_device(self, to_torch_tensor(xx).float()) for xx in xs]
      xs_pad = pad_list(xs, 0.0)
  
      # 0. Frontend
      if self.frontend is not None:
          enhanced, hlens, mask = self.frontend(xs_pad, ilens)
          hs_pad, hlens = self.feature_transform(enhanced, hlens)
      else:
          hs_pad, hlens = xs_pad, ilens
  
      # 1. Encoder
      hs_pad, hlens, _ = self.enc(hs_pad, hlens)
  
      # calculate log P(z_t|X) for CTC scores
      if recog_args.ctc_weight > 0.0:
          lpz = self.ctc.log_softmax(hs_pad)
          normalize_score = False
      else:
          lpz = None
          normalize_score = True
  
      # 2. Decoder
      hlens = torch.tensor(
          list(map(int, hlens))
      )  # make sure hlens is tensor
      y = self.dec.recognize_beam_batch(
          hs_pad,
          hlens,
          lpz,
          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.frontends.feature_transform import feature_transform_for
  from espnet.nets.pytorch_backend.frontends.frontend import frontend_for
  from espnet.nets.pytorch_backend.initialization import lecun_normal_init_parameters, set_forget_bias_to_one
  from espnet.nets.pytorch_backend.nets_utils import get_subsample, pad_list, to_device, to_torch_tensor
  from espnet.nets.pytorch_backend.rnn.argument import add_arguments_rnn_attention_common, add_arguments_rnn_decoder_common, add_arguments_rnn_encoder_common
  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_for
  from espnet.nets.scorers.ctc import CTCPrefixScorer
  from espnet.utils.fill_missing_args import fill_missing_args
label_desc: Use image node_id 12 for calling the E2E obj's underlying member method code with example usage: obj.recognize_batch(xs, recog_args, char_list, rnnlm) and returns: y