class_docstr: Speech2Text class
  
  Examples:
      >>> import soundfile
      >>> speech2text = Speech2Text("asr_config.yml", "asr.pth")
      >>> audio, rate = soundfile.read("speech.wav")
      >>> speech2text(audio)
      [(text, token, token_int, hypothesis object), ...]
class_docstr_tok: ["Speech2Text","class","Examples",":",">",">",">","import","soundfile",">",">",">","speech2text","=","Speech2Text","(","``","asr_config.yml","''",",","``","asr.pth","''",")",">",">",">","audio",",","rate","=","soundfile.read","(","``","speech.wav","''",")",">",">",">","speech2text","(","audio",")","[","(","text",",","token",",","token_int",",","hypothesis","object",")",",","...","]"]
code: def __init__(
      self,
      asr_train_config: Union[Path, str] = None,
      asr_model_file: Union[Path, str] = None,
      transducer_conf: dict = None,
      lm_train_config: Union[Path, str] = None,
      lm_file: Union[Path, str] = None,
      ngram_scorer: str = "full",
      ngram_file: Union[Path, str] = None,
      token_type: str = None,
      bpemodel: str = None,
      device: str = "cpu",
      maxlenratio: float = 0.0,
      minlenratio: float = 0.0,
      batch_size: int = 1,
      dtype: str = "float32",
      beam_size: int = 20,
      ctc_weight: float = 0.5,
      lm_weight: float = 1.0,
      ngram_weight: float = 0.9,
      penalty: float = 0.0,
      nbest: int = 1,
      normalize_length: bool = False,
      streaming: bool = False,
      enh_s2t_task: bool = False,
      quantize_asr_model: bool = False,
      quantize_lm: bool = False,
      quantize_modules: List[str] = ["Linear"],
      quantize_dtype: str = "qint8",
      hugging_face_decoder: bool = False,
      hugging_face_decoder_conf: Dict[str, Any] = {},
      time_sync: bool = False,
      multi_asr: bool = False,
      lid_prompt: bool = False,
      lang_prompt_token: Optional[str] = None,
      nlp_prompt_token: Optional[str] = None,
      prompt_token_file: Optional[str] = None,
  ):
      assert check_argument_types()
  
      task = ASRTask if not enh_s2t_task else EnhS2TTask
  
      if quantize_asr_model or quantize_lm:
          if (
              quantize_dtype == "float16"
              and torch.__version__ < LooseVersion("1.5.0")
          ):
              raise ValueError(
                  "float16 dtype for dynamic quantization is not supported with "
                  "torch version < 1.5.0. Switch to qint8 dtype instead."
              )
  
      quantize_modules = set(
          [getattr(torch.nn, q) for q in quantize_modules]
      )
      quantize_dtype = getattr(torch, quantize_dtype)
  
      # 1. Build ASR model
      scorers = {}
      asr_model, asr_train_args = task.build_model_from_file(
          asr_train_config, asr_model_file, device
      )
  
      if enh_s2t_task:
          asr_model.inherite_attributes(
              inherite_s2t_attrs=[
                  "ctc",
                  "decoder",
                  "eos",
                  "joint_network",
                  "sos",
                  "token_list",
                  "use_transducer_decoder",
              ]
          )
      asr_model.to(dtype=getattr(torch, dtype)).eval()
  
      if quantize_asr_model:
          logging.info("Use quantized asr model for decoding.")
  
          asr_model = torch.quantization.quantize_dynamic(
              asr_model,
              qconfig_spec=quantize_modules,
              dtype=quantize_dtype,
          )
  
      decoder = asr_model.decoder
  
      ctc = CTCPrefixScorer(ctc=asr_model.ctc, eos=asr_model.eos)
      token_list = asr_model.token_list
      scorers.update(
          decoder=decoder,
          ctc=ctc,
          length_bonus=LengthBonus(len(token_list)),
      )
  
      # 2. Build Language model
      if lm_train_config is not None:
          lm, lm_train_args = LMTask.build_model_from_file(
              lm_train_config, lm_file, device
          )
  
          if quantize_lm:
              logging.info("Use quantized lm for decoding.")
  
              lm = torch.quantization.quantize_dynamic(
                  lm,
                  qconfig_spec=quantize_modules,
                  dtype=quantize_dtype,
              )
  
          scorers["lm"] = lm.lm
  
      # 3. Build ngram model
      if ngram_file is not None:
          if ngram_scorer == "full":
              from espnet.nets.scorers.ngram import NgramFullScorer
  
              ngram = NgramFullScorer(ngram_file, token_list)
          else:
              from espnet.nets.scorers.ngram import NgramPartScorer
  
              ngram = NgramPartScorer(ngram_file, token_list)
      else:
          ngram = None
      scorers["ngram"] = ngram
  
      # 4. Build BeamSearch object
      if asr_model.use_transducer_decoder:
          # In multi-blank RNNT, we assume all big blanks are
          # just before the standard blank in token_list
          multi_blank_durations = getattr(
              asr_model, "transducer_multi_blank_durations", []
          )[::-1] + [1]
          multi_blank_indices = [
              asr_model.blank_id - i + 1
              for i in range(len(multi_blank_durations), 0, -1)
          ]
  
          if transducer_conf is None:
              transducer_conf = {}
  
          beam_search_transducer = BeamSearchTransducer(
              decoder=asr_model.decoder,
              joint_network=asr_model.joint_network,
              beam_size=beam_size,
              lm=scorers["lm"] if "lm" in scorers else None,
              lm_weight=lm_weight,
              multi_blank_durations=multi_blank_durations,
              multi_blank_indices=multi_blank_indices,
              token_list=token_list,
              **transducer_conf,
          )
          beam_search = None
          hugging_face_model = None
          hugging_face_linear_in = None
      elif (
          decoder.__class__.__name__ == "HuggingFaceTransformersDecoder"
          and hugging_face_decoder
      ):
          if not is_transformers_available:
              raise ImportError(
                  "`transformers` is not available."
                  " Please install it via `pip install transformers`"
                  " or `cd /path/to/espnet/tools && . ./activate_python.sh"
                  " && ./installers/install_transformers.sh`."
              )
  
          if decoder.causal_lm:
              hugging_face_model = AutoModelForCausalLM.from_pretrained(
                  decoder.model_name_or_path
              )
  
              hugging_face_model.resize_token_embeddings(
                  decoder.lm_head.out_features
              )
  
              transformer = get_hugging_face_model_network(
                  hugging_face_model
              )
              transformer.load_state_dict(decoder.decoder.state_dict())
  
              lm_head = get_hugging_face_model_lm_head(
                  hugging_face_model
              )
              lm_head.load_state_dict(decoder.lm_head.state_dict())
          else:
              hugging_face_model = (
                  AutoModelForSeq2SeqLM.from_pretrained(
                      decoder.model_name_or_path
                  )
              )
  
              hugging_face_model.lm_head.load_state_dict(
                  decoder.lm_head.state_dict()
              )
  
              if hasattr(hugging_face_model, "model"):
                  hugging_face_model.model.decoder.load_state_dict(
                      decoder.decoder.state_dict()
                  )
                  del hugging_face_model.model.encoder
              else:
                  hugging_face_model.decoder.load_state_dict(
                      decoder.decoder.state_dict()
                  )
                  del hugging_face_model.encoder
  
          del asr_model.decoder.lm_head
          del asr_model.decoder.decoder
  
          hugging_face_linear_in = decoder.linear_in
          hugging_face_model.to(device=device).eval()
  
          if "num_beams" not in hugging_face_decoder_conf:
              hugging_face_decoder_conf[
                  "num_beams"
              ] = hugging_face_model.config.num_beams
  
          if (
              hugging_face_model.config.pad_token_id is None
              and "pad_token_id" not in hugging_face_decoder_conf
          ):
              hugging_face_decoder_conf[
                  "pad_token_id"
              ] = hugging_face_model.config.eos_token_id
  
          beam_search = None
          beam_search_transducer = None
      else:
          beam_search_transducer = None
          hugging_face_model = None
          hugging_face_linear_in = None
  
          weights = dict(
              decoder=1.0 - ctc_weight,
              ctc=ctc_weight,
              lm=lm_weight,
              ngram=ngram_weight,
              length_bonus=penalty,
          )
  
          if time_sync:
              if not hasattr(asr_model, "ctc"):
                  raise NotImplementedError(
                      "BeamSearchTimeSync without CTC is not supported."
                  )
              if batch_size != 1:
                  raise NotImplementedError(
                      "BeamSearchTimeSync with batching is not yet supported."
                  )
              logging.info(
                  "BeamSearchTimeSync implementation is selected."
              )
  
              scorers["ctc"] = asr_model.ctc
              beam_search = BeamSearchTimeSync(
                  beam_size=beam_size,
                  weights=weights,
                  scorers=scorers,
                  sos=asr_model.sos,
                  token_list=token_list,
              )
          else:
              beam_search = BeamSearch(
                  beam_size=beam_size,
                  weights=weights,
                  scorers=scorers,
                  sos=asr_model.sos,
                  eos=asr_model.eos,
                  vocab_size=len(token_list),
                  token_list=token_list,
                  pre_beam_score_key=None
                  if ctc_weight == 1.0
                  else "full",
                  normalize_length=normalize_length,
              )
  
              # TODO(karita): make all scorers batchfied
              if batch_size == 1:
                  non_batch = [
                      k
                      for k, v in beam_search.full_scorers.items()
                      if not isinstance(v, BatchScorerInterface)
                  ]
                  if len(non_batch) == 0:
                      if streaming:
                          beam_search.__class__ = (
                              BatchBeamSearchOnlineSim
                          )
                          beam_search.set_streaming_config(
                              asr_train_config
                          )
                          logging.info(
                              "BatchBeamSearchOnlineSim implementation is selected."
                          )
                      else:
                          beam_search.__class__ = BatchBeamSearch
                          logging.info(
                              "BatchBeamSearch implementation is selected."
                          )
                  else:
                      logging.warning(
                          f"As non-batch scorers {non_batch} are found, "
                          f"fall back to non-batch implementation."
                      )
  
          beam_search.to(
              device=device, dtype=getattr(torch, dtype)
          ).eval()
          for scorer in scorers.values():
              if isinstance(scorer, torch.nn.Module):
                  scorer.to(
                      device=device, dtype=getattr(torch, dtype)
                  ).eval()
          logging.info(f"Beam_search: {beam_search}")
          logging.info(f"Decoding device={device}, dtype={dtype}")
  
      # 5. [Optional] Build Text converter: e.g. bpe-sym -> Text
      if token_type is None:
          token_type = asr_train_args.token_type
      if bpemodel is None:
          bpemodel = asr_train_args.bpemodel
  
      # compatibility for whisper tokenizer
      preprocessor_conf = getattr(
          asr_train_args, "preprocessor_conf", {}
      )
      whisper_language = preprocessor_conf.get("whisper_language", None)
      whisper_task = preprocessor_conf.get("whisper_task", None)
  
      if token_type is None:
          tokenizer = None
      elif token_type == "bpe" or token_type == "hugging_face":
          if bpemodel is not None:
              tokenizer = build_tokenizer(
                  token_type=token_type,
                  bpemodel=bpemodel,
              )
          else:
              tokenizer = None
      elif "whisper" in token_type:
          tokenizer_language = asr_train_args.preprocessor_conf.get(
              "tokenizer_language", "en"
          )
          tokenizer = build_tokenizer(
              token_type=token_type,
              bpemodel=bpemodel,
              whisper_language=whisper_language,
              whisper_task=whisper_task,
              non_linguistic_symbols=prompt_token_file,
          )
      else:
          tokenizer = build_tokenizer(token_type=token_type)
  
      if token_type == "hugging_face":
          converter = HuggingFaceTokenIDConverter(
              model_name_or_path=bpemodel
          )
      elif bpemodel not in ["whisper_en", "whisper_multilingual"]:
          converter = TokenIDConverter(token_list=token_list)
      else:
          if "speaker_change_symbol" in preprocessor_conf:
              sot_asr = True
          else:
              sot_asr = False
          converter = OpenAIWhisperTokenIDConverter(
              model_type=bpemodel,
              added_tokens_txt=prompt_token_file,
              language=whisper_language or "en",
              task=whisper_task or "transcribe",
              sot=sot_asr,
          )
          beam_search.set_hyp_primer(
              list(
                  converter.tokenizer.sot_sequence_including_notimestamps
              )
          )
          if lang_prompt_token is not None:
              a1 = converter.tokenizer.tokenizer.convert_ids_to_tokens(
                  converter.tokenizer.sot_sequence_including_notimestamps
              )
              a1 = a1[:1] + lang_prompt_token.split() + a1[3:]
              beam_search.set_hyp_primer(
                  list(
                      converter.tokenizer.tokenizer.convert_tokens_to_ids(
                          a1
                      )
                  )
              )
          elif nlp_prompt_token is not None:
              a1 = converter.tokenizer.tokenizer.convert_ids_to_tokens(
                  converter.tokenizer.sot_sequence_including_notimestamps
              )
              prompt_tokens = tokenizer.text2tokens(nlp_prompt_token)
              a1 = a1[:2] + prompt_tokens + a1[3:]
              beam_search.set_hyp_primer(
                  list(
                      converter.tokenizer.tokenizer.convert_tokens_to_ids(
                          a1
                      )
                  )
              )
          elif lid_prompt:
              a1 = converter.tokenizer.tokenizer.convert_ids_to_tokens(
                  converter.tokenizer.sot_sequence_including_notimestamps
              )
              a1 = a1[:1]
              beam_search.set_hyp_primer(
                  list(
                      converter.tokenizer.tokenizer.convert_tokens_to_ids(
                          a1
                      )
                  )
              )
      logging.info(f"Text tokenizer: {tokenizer}")
  
      self.asr_model = asr_model
      self.asr_train_args = asr_train_args
      self.converter = converter
      self.tokenizer = tokenizer
      self.beam_search = beam_search
      self.beam_search_transducer = beam_search_transducer
      self.hugging_face_model = hugging_face_model
      self.hugging_face_linear_in = hugging_face_linear_in
      self.hugging_face_decoder_conf = hugging_face_decoder_conf
      self.maxlenratio = maxlenratio
      self.minlenratio = minlenratio
      self.device = device
      self.dtype = dtype
      self.nbest = nbest
      self.enh_s2t_task = enh_s2t_task
      self.multi_asr = multi_asr
  
imports: import argparse
  import logging
  import sys
  from distutils.version import LooseVersion
  from itertools import groupby
  from pathlib import Path
  from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
  import numpy
  import torch
  import torch.quantization
  from typeguard import check_argument_types, check_return_type
  from espnet2.asr.decoder.hugging_face_transformers_decoder import get_hugging_face_model_lm_head, get_hugging_face_model_network
  from espnet2.asr.decoder.s4_decoder import S4Decoder
  from espnet2.asr.transducer.beam_search_transducer import BeamSearchTransducer
  from espnet2.asr.transducer.beam_search_transducer import ExtendedHypothesis
  from espnet2.asr.transducer.beam_search_transducer import Hypothesis
  from espnet2.fileio.datadir_writer import DatadirWriter
  from espnet2.tasks.asr import ASRTask
  from espnet2.tasks.enh_s2t import EnhS2TTask
  from espnet2.tasks.lm import LMTask
  from espnet2.text.build_tokenizer import build_tokenizer
  from espnet2.text.hugging_face_token_id_converter import HuggingFaceTokenIDConverter
  from espnet2.text.token_id_converter import TokenIDConverter
  from espnet2.text.whisper_token_id_converter import OpenAIWhisperTokenIDConverter
  from espnet2.torch_utils.device_funcs import to_device
  from espnet2.torch_utils.set_all_random_seed import set_all_random_seed
  from espnet2.utils import config_argparse
  from espnet2.utils.nested_dict_action import NestedDictAction
  from espnet2.utils.types import str2bool, str2triple_str, str_or_none
  from espnet.nets.batch_beam_search import BatchBeamSearch
  from espnet.nets.batch_beam_search_online_sim import BatchBeamSearchOnlineSim
  from espnet.nets.beam_search import BeamSearch, Hypothesis
  from espnet.nets.beam_search_timesync import BeamSearchTimeSync
  from espnet.nets.pytorch_backend.transformer.add_sos_eos import add_sos_eos
  from espnet.nets.pytorch_backend.transformer.subsampling import TooShortUttError
  from espnet.nets.scorer_interface import BatchScorerInterface
  from espnet.nets.scorers.ctc import CTCPrefixScorer
  from espnet.nets.scorers.length_bonus import LengthBonus
  from espnet.utils.cli_utils import get_commandline_args
label_desc: Use image node_id 1 to create a new Speech2Text object  with example: obj = Speech2Text(asr_train_config, asr_model_file, transducer_conf, lm_train_config, lm_file, ngram_scorer, ngram_file, token_type, bpemodel, device, maxlenratio, minlenratio, batch_size, dtype, beam_size, ctc_weight, lm_weight, ngram_weight, penalty, nbest, normalize_length, streaming, enh_s2t_task, quantize_asr_model, quantize_lm, quantize_modules, quantize_dtype, hugging_face_decoder, hugging_face_decoder_conf, time_sync, multi_asr, lid_prompt, lang_prompt_token, nlp_prompt_token, prompt_token_file)