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: Initialize multi-speaker E2E module.
docstr_tok: ["Initialize","multi-speaker","E2E","module","."]
code: def __init__(self, idim, odim, args):
      """Initialize multi-speaker E2E module."""
      super(E2E, self).__init__()
      torch.nn.Module.__init__(self)
      self.mtlalpha = args.mtlalpha
      assert (
          0.0 <= self.mtlalpha <= 1.0
      ), "mtlalpha should be [0.0, 1.0]"
      self.etype = args.etype
      self.verbose = args.verbose
      # NOTE: for self.build method
      args.char_list = getattr(args, "char_list", None)
      self.char_list = args.char_list
      self.outdir = args.outdir
      self.space = args.sym_space
      self.blank = args.sym_blank
      self.reporter = Reporter()
      self.num_spkrs = args.num_spkrs
      self.spa = args.spa
      self.pit = PIT(self.num_spkrs)
  
      # below means the last number becomes eos/sos ID
      # note that sos/eos IDs are identical
      self.sos = odim - 1
      self.eos = odim - 1
  
      # subsample info
      self.subsample = get_subsample(args, mode="asr", arch="rnn_mix")
  
      # label smoothing info
      if args.lsm_type and os.path.isfile(args.train_json):
          logging.info("Use label smoothing with " + args.lsm_type)
          labeldist = label_smoothing_dist(
              odim, args.lsm_type, transcript=args.train_json
          )
      else:
          labeldist = None
  
      if getattr(
          args, "use_frontend", False
      ):  # use getattr to keep compatibility
          self.frontend = frontend_for(args, idim)
          self.feature_transform = feature_transform_for(
              args, (idim - 1) * 2
          )
          idim = args.n_mels
      else:
          self.frontend = None
  
      # encoder
      self.enc = encoder_for(args, idim, self.subsample)
      # ctc
      self.ctc = ctc_for(args, odim, reduce=False)
      # attention
      num_att = self.num_spkrs if args.spa else 1
      self.att = att_for(args, num_att)
      # decoder
      self.dec = decoder_for(
          args, odim, self.sos, self.eos, self.att, labeldist
      )
  
      # weight initialization
      self.init_like_chainer()
  
      # options for beam search
      if "report_cer" in vars(args) and (
          args.report_cer or args.report_wer
      ):
          recog_args = {
              "beam_size": args.beam_size,
              "penalty": args.penalty,
              "ctc_weight": args.ctc_weight,
              "maxlenratio": args.maxlenratio,
              "minlenratio": args.minlenratio,
              "lm_weight": args.lm_weight,
              "rnnlm": args.rnnlm,
              "nbest": args.nbest,
              "space": args.sym_space,
              "blank": args.sym_blank,
          }
  
          self.recog_args = argparse.Namespace(**recog_args)
          self.report_cer = args.report_cer
          self.report_wer = args.report_wer
      else:
          self.report_cer = False
          self.report_wer = False
      self.rnnlm = None
  
      self.logzero = -10000000000.0
      self.loss = None
      self.acc = None
  
imports: import argparse
  import logging
  import math
  import os
  import sys
  from itertools import groupby
  import numpy
  import torch
  from espnet.nets.asr_interface import ASRInterface
  from espnet.nets.e2e_asr_common import get_vgg2l_odim, label_smoothing_dist
  from espnet.nets.pytorch_backend.ctc import ctc_for
  from espnet.nets.pytorch_backend.e2e_asr import E2E
  from espnet.nets.pytorch_backend.e2e_asr import Reporter
  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, make_pad_mask, 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 RNNP, VGG2L
  from espnet.nets.pytorch_backend.rnn.encoders import encoder_for
label_desc: Use image node_id 4 to create a new E2E object from inherited base classes: ASRInterface, torch.nn with example: obj = E2E(idim, odim, args)