class_docstr: CTC-attention hybrid Encoder-Decoder model
class_docstr_tok: ["CTC-attention","hybrid","Encoder-Decoder","model"]
code: def __init__(
      self,
      vocab_size: int,
      token_list: Union[Tuple[str, ...], List[str]],
      frontend: Optional[AbsFrontend],
      specaug: Optional[AbsSpecAug],
      normalize: Optional[AbsNormalize],
      preencoder: Optional[AbsPreEncoder],
      encoder: AbsEncoder,
      postencoder: Optional[AbsPostEncoder],
      decoder: Optional[AbsDecoder],
      ctc: CTC,
      joint_network: Optional[torch.nn.Module],
      aux_ctc: dict = None,
      ctc_weight: float = 0.5,
      interctc_weight: float = 0.0,
      ignore_id: int = -1,
      lsm_weight: float = 0.0,
      length_normalized_loss: bool = False,
      report_cer: bool = True,
      report_wer: bool = True,
      sym_space: str = "<space>",
      sym_blank: str = "<blank>",
      transducer_multi_blank_durations: List = [],
      transducer_multi_blank_sigma: float = 0.05,
      # In a regular ESPnet recipe, <sos> and <eos> are both "<sos/eos>"
      # Pretrained HF Tokenizer needs custom sym_sos and sym_eos
      sym_sos: str = "<sos/eos>",
      sym_eos: str = "<sos/eos>",
      extract_feats_in_collect_stats: bool = True,
      lang_token_id: int = -1,
  ):
      assert check_argument_types()
      assert 0.0 <= ctc_weight <= 1.0, ctc_weight
      assert 0.0 <= interctc_weight < 1.0, interctc_weight
  
      super().__init__()
      # NOTE (Shih-Lun): else case is for OpenAI Whisper ASR model,
      #                  which doesn't use <blank> token
      if sym_blank in token_list:
          self.blank_id = token_list.index(sym_blank)
      else:
          self.blank_id = 0
      if sym_sos in token_list:
          self.sos = token_list.index(sym_sos)
      else:
          self.sos = vocab_size - 1
      if sym_eos in token_list:
          self.eos = token_list.index(sym_eos)
      else:
          self.eos = vocab_size - 1
      self.vocab_size = vocab_size
      self.ignore_id = ignore_id
      self.ctc_weight = ctc_weight
      self.interctc_weight = interctc_weight
      self.aux_ctc = aux_ctc
      self.token_list = token_list.copy()
  
      self.frontend = frontend
      self.specaug = specaug
      self.normalize = normalize
      self.preencoder = preencoder
      self.postencoder = postencoder
      self.encoder = encoder
  
      if not hasattr(self.encoder, "interctc_use_conditioning"):
          self.encoder.interctc_use_conditioning = False
      if self.encoder.interctc_use_conditioning:
          self.encoder.conditioning_layer = torch.nn.Linear(
              vocab_size, self.encoder.output_size()
          )
  
      self.use_transducer_decoder = joint_network is not None
  
      self.error_calculator = None
  
      if self.use_transducer_decoder:
          self.decoder = decoder
          self.joint_network = joint_network
  
          if not transducer_multi_blank_durations:
              from warprnnt_pytorch import RNNTLoss
  
              self.criterion_transducer = RNNTLoss(
                  blank=self.blank_id,
                  fastemit_lambda=0.0,
              )
          else:
              from espnet2.asr.transducer.rnnt_multi_blank.rnnt_multi_blank import (
                  MultiblankRNNTLossNumba,
              )
  
              self.criterion_transducer = MultiblankRNNTLossNumba(
                  blank=self.blank_id,
                  big_blank_durations=transducer_multi_blank_durations,
                  sigma=transducer_multi_blank_sigma,
                  reduction="mean",
                  fastemit_lambda=0.0,
              )
              self.transducer_multi_blank_durations = (
                  transducer_multi_blank_durations
              )
  
          if report_cer or report_wer:
              self.error_calculator_trans = ErrorCalculatorTransducer(
                  decoder,
                  joint_network,
                  token_list,
                  sym_space,
                  sym_blank,
                  report_cer=report_cer,
                  report_wer=report_wer,
              )
          else:
              self.error_calculator_trans = None
  
              if self.ctc_weight != 0:
                  self.error_calculator = ErrorCalculator(
                      token_list,
                      sym_space,
                      sym_blank,
                      report_cer,
                      report_wer,
                  )
      else:
          # we set self.decoder = None in the CTC mode since
          # self.decoder parameters were never used and PyTorch complained
          # and threw an Exception in the multi-GPU experiment.
          # thanks Jeff Farris for pointing out the issue.
          if ctc_weight < 1.0:
              assert (
                  decoder is not None
              ), "decoder should not be None when attention is used"
          else:
              decoder = None
              logging.warning("Set decoder to none as ctc_weight==1.0")
  
          self.decoder = decoder
  
          self.criterion_att = LabelSmoothingLoss(
              size=vocab_size,
              padding_idx=ignore_id,
              smoothing=lsm_weight,
              normalize_length=length_normalized_loss,
          )
  
          if report_cer or report_wer:
              self.error_calculator = ErrorCalculator(
                  token_list,
                  sym_space,
                  sym_blank,
                  report_cer,
                  report_wer,
              )
  
      if ctc_weight == 0.0:
          self.ctc = None
      else:
          self.ctc = ctc
  
      self.extract_feats_in_collect_stats = (
          extract_feats_in_collect_stats
      )
  
      self.is_encoder_whisper = "Whisper" in type(self.encoder).__name__
  
      if self.is_encoder_whisper:
          assert (
              self.frontend is None
          ), "frontend should be None when using full Whisper model"
  
      if lang_token_id != -1:
          self.lang_token_id = torch.tensor([[lang_token_id]])
      else:
          self.lang_token_id = None
  
imports: import logging
  from contextlib import contextmanager
  from typing import Dict, List, Optional, Tuple, Union
  import torch
  from packaging.version import parse
  from typeguard import check_argument_types
  from espnet2.asr.ctc import CTC
  from espnet2.asr.decoder.abs_decoder import AbsDecoder
  from espnet2.asr.encoder.abs_encoder import AbsEncoder
  from espnet2.asr.frontend.abs_frontend import AbsFrontend
  from espnet2.asr.postencoder.abs_postencoder import AbsPostEncoder
  from espnet2.asr.preencoder.abs_preencoder import AbsPreEncoder
  from espnet2.asr.specaug.abs_specaug import AbsSpecAug
  from espnet2.asr.transducer.error_calculator import ErrorCalculatorTransducer
  from espnet2.asr_transducer.utils import get_transducer_task_io
  from espnet2.layers.abs_normalize import AbsNormalize
  from espnet2.torch_utils.device_funcs import force_gatherable
  from espnet2.train.abs_espnet_model import AbsESPnetModel
  from espnet.nets.e2e_asr_common import ErrorCalculator
  from espnet.nets.pytorch_backend.nets_utils import th_accuracy
  from espnet.nets.pytorch_backend.transformer.add_sos_eos import add_sos_eos
  from espnet.nets.pytorch_backend.transformer.label_smoothing_loss import LabelSmoothingLoss
label_desc: Use image node_id 1 to create a new ESPnetASRModel object from inherited base classes: AbsESPnetModel with example: obj = ESPnetASRModel(vocab_size, token_list, frontend, specaug, normalize, preencoder, encoder, postencoder, decoder, ctc, joint_network, aux_ctc, ctc_weight, interctc_weight, ignore_id, lsm_weight, length_normalized_loss, report_cer, report_wer, sym_space, sym_blank, transducer_multi_blank_durations, transducer_multi_blank_sigma, sym_sos, sym_eos, extract_feats_in_collect_stats, lang_token_id)