class_docstr: Speech2Text class
  
  Examples:
      >>> import soundfile
      >>> speech2text = Speech2Text("st_config.yml", "st.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","(","``","st_config.yml","''",",","``","st.pth","''",")",">",">",">","audio",",","rate","=","soundfile.read","(","``","speech.wav","''",")",">",">",">","speech2text","(","audio",")","[","(","text",",","token",",","token_int",",","hypothesis","object",")",",","...","]"]
code: def __init__(
      self,
      st_train_config: Union[Path, str] = None,
      st_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,
      src_lm_train_config: Union[Path, str] = None,
      src_lm_file: Union[Path, str] = None,
      src_ngram_scorer: str = "full",
      src_ngram_file: Union[Path, str] = None,
      src_token_type: str = None,
      src_bpemodel: str = None,
      device: str = "cpu",
      maxlenratio: float = 0.0,
      minlenratio: float = 0.0,
      asr_maxlenratio: float = 0.0,
      asr_minlenratio: float = 0.0,
      batch_size: int = 1,
      dtype: str = "float32",
      beam_size: int = 20,
      ctc_weight: float = 0.0,
      lm_weight: float = 1.0,
      ngram_weight: float = 0.9,
      penalty: float = 0.0,
      nbest: int = 1,
      normalize_length: bool = False,
      asr_beam_size: int = 20,
      asr_lm_weight: float = 1.0,
      asr_ngram_weight: float = 0.9,
      asr_penalty: float = 0.0,
      asr_ctc_weight: float = 0.3,
      asr_nbest: int = 1,
      enh_s2t_task: bool = False,
      ctc_greedy: bool = False,
      hugging_face_decoder: bool = False,
      hugging_face_decoder_max_length: int = 256,
  ):
      assert check_argument_types()
  
      task = STTask if not enh_s2t_task else EnhS2TTask
  
      # 1. Build ST model
      scorers = {}
      asr_scorers = {}
      st_model, st_train_args = task.build_model_from_file(
          st_train_config, st_model_file, device
      )
      if enh_s2t_task:
          st_model.inherite_attributes(
              inherite_s2t_attrs=[
                  "ctc",
                  "decoder",
                  "eos",
                  "joint_network",
                  "sos",
                  "token_list",
                  "use_transducer_decoder",
              ]
          )
      st_model.to(dtype=getattr(torch, dtype)).eval()
  
      if hasattr(st_model, "decoder"):
          decoder = st_model.decoder
      else:
          decoder = None
      token_list = st_model.token_list
      scorers.update(
          decoder=decoder,
          length_bonus=LengthBonus(len(token_list)),
      )
  
      if ctc_weight > 0:
          assert hasattr(st_model, "st_ctc")
          ctc = CTCPrefixScorer(ctc=st_model.st_ctc, eos=st_model.eos)
          scorers.update(ctc=ctc)
  
      src_token_list = st_model.src_token_list
      if st_model.use_multidecoder:
          asr_decoder = st_model.extra_asr_decoder
          asr_ctc = CTCPrefixScorer(
              ctc=st_model.ctc, eos=st_model.src_eos
          )
          asr_scorers.update(
              decoder=asr_decoder,
              ctc=asr_ctc,
              length_bonus=LengthBonus(len(src_token_list)),
          )
      else:
          asr_decoder = None
  
      # 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
          )
          scorers["lm"] = lm.lm
  
      if src_lm_train_config is not None:
          src_lm, src_lm_train_args = LMTask.build_model_from_file(
              src_lm_train_config, src_lm_file, device
          )
          asr_scorers["lm"] = src_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
  
      if src_ngram_file is not None:
          if src_ngram_scorer == "full":
              from espnet.nets.scorers.ngram import NgramFullScorer
  
              src_ngram = NgramFullScorer(
                  src_ngram_file, src_token_list
              )
          else:
              from espnet.nets.scorers.ngram import NgramPartScorer
  
              src_ngram = NgramPartScorer(
                  src_ngram_file, src_token_list
              )
      else:
          src_ngram = None
      asr_scorers["ngram"] = src_ngram
  
      # 4. Build BeamSearch object
      if st_model.st_use_transducer_decoder:
          beam_search_transducer = BeamSearchTransducer(
              decoder=st_model.decoder,
              joint_network=st_model.st_joint_network,
              beam_size=beam_size,
              lm=scorers["lm"] if "lm" in scorers else None,
              lm_weight=lm_weight,
              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`."
              )
  
          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 st_model.decoder.lm_head
          # del st_model.decoder.decoder
  
          hugging_face_linear_in = decoder.linear_in
          hugging_face_model.to(device=device).eval()
  
          # hacky way to use .score()
          st_model.decoder.hf_generate = hugging_face_model
          weights = dict(
              decoder=1.0 - ctc_weight,
              ctc=ctc_weight,
              lm=lm_weight,
              ngram=ngram_weight,
              length_bonus=penalty,
          )
          beam_search = BeamSearch(
              beam_size=beam_size,
              weights=weights,
              scorers=scorers,
              sos=hugging_face_model.config.decoder_start_token_id,
              eos=hugging_face_model.config.eos_token_id,
              vocab_size=len(token_list),
              token_list=token_list,
              pre_beam_score_key="full",
              normalize_length=normalize_length,
          )
  
          # beam_search = None
          beam_search_transducer = None
  
          # 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:
                  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}")
      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,
          )
          beam_search = BeamSearch(
              beam_size=beam_size,
              weights=weights,
              scorers=scorers,
              sos=st_model.sos,
              eos=st_model.eos,
              vocab_size=len(token_list),
              token_list=token_list,
              pre_beam_score_key="full",
          )
          # 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:
                  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}")
  
      asr_weights = dict(
          decoder=1.0 - asr_ctc_weight,
          ctc=asr_ctc_weight,
          lm=asr_lm_weight,
          ngram=asr_ngram_weight,
          length_bonus=asr_penalty,
      )
      asr_beam_search = BeamSearch(
          beam_size=asr_beam_size,
          weights=asr_weights,
          scorers=asr_scorers,
          sos=st_model.src_sos,
          eos=st_model.src_eos,
          vocab_size=len(src_token_list),
          token_list=src_token_list,
          pre_beam_score_key="full",
          return_hs=True,
      )
      # TODO(karita): make all scorers batchfied
      if batch_size == 1:
          non_batch = [
              k
              for k, v in asr_beam_search.full_scorers.items()
              if not isinstance(v, BatchScorerInterface)
          ]
          if len(non_batch) == 0:
              asr_beam_search.__class__ = BatchBeamSearch
              logging.info(
                  "BatchBeamSearch implementation is selected for ASR."
              )
          else:
              logging.warning(
                  f"As non-batch scorers {non_batch} are found, "
                  f"fall back to non-batch implementation."
              )
      asr_beam_search.to(
          device=device, dtype=getattr(torch, dtype)
      ).eval()
      for scorer in asr_scorers.values():
          if isinstance(scorer, torch.nn.Module):
              scorer.to(
                  device=device, dtype=getattr(torch, dtype)
              ).eval()
      logging.info(f"ASR Beam_search: {asr_beam_search}")
      logging.info(f"Decoding device={device}, dtype={dtype}")
  
      # 4. [Optional] Build Text converter: e.g. bpe-sym -> Text
      # compatibility for whisper tokenizer
      preprocessor_conf = getattr(
          st_train_args, "preprocessor_conf", {}
      )
      whisper_language = preprocessor_conf.get("whisper_language", None)
      whisper_task = preprocessor_conf.get("whisper_task", None)
      if whisper_language:
          src_token_lang, token_lang = whisper_language
      else:
          src_token_lang, token_lang = None, None
  
      if token_type is None:
          token_type = st_train_args.token_type
      if bpemodel is None:
          bpemodel = st_train_args.bpemodel
  
      if token_type is None:
          tokenizer = None
      elif (
          token_type == "bpe"
          or token_type == "hugging_face"
          or "whisper" in token_type
      ):
          if bpemodel is not None:
              tokenizer = build_tokenizer(
                  token_type=token_type,
                  bpemodel=bpemodel,
                  whisper_language=token_lang,
                  whisper_task=whisper_task,
              )
          else:
              tokenizer = None
      else:
          tokenizer = build_tokenizer(token_type=token_type)
      if "whisper" in token_type:
          converter = OpenAIWhisperTokenIDConverter(
              model_type=bpemodel,
              language=token_lang or "en",
              task=whisper_task or "translate",
          )
          beam_search.set_hyp_primer(
              list(
                  converter.tokenizer.sot_sequence_including_notimestamps
              )
          )
      else:
          converter = TokenIDConverter(token_list=token_list)
      logging.info(f"Text tokenizer: {tokenizer}")
  
      if src_token_type is None:
          src_token_type = st_train_args.src_token_type
      if src_bpemodel is None:
          src_bpemodel = st_train_args.src_bpemodel
  
      if src_token_type is None:
          src_tokenizer = None
      elif src_token_type == "bpe" or "whisper" in token_type:
          if src_bpemodel is not None:
              src_tokenizer = build_tokenizer(
                  token_type=src_token_type,
                  bpemodel=src_bpemodel,
                  whisper_language=src_token_lang,
                  whisper_task=whisper_task,
              )
          else:
              src_tokenizer = None
      else:
          src_tokenizer = build_tokenizer(token_type=src_token_type)
      if "whisper" in src_token_type:
          src_converter = OpenAIWhisperTokenIDConverter(
              model_type=src_bpemodel,
              language=src_token_lang or "en",
              task=whisper_task or "translate",
          )
          asr_beam_search.set_hyp_primer(
              list(
                  src_converter.tokenizer.sot_sequence_including_notimestamps
              )
          )
      else:
          src_converter = TokenIDConverter(token_list=src_token_list)
      logging.info(f"Src Text tokenizer: {src_tokenizer}")
  
      self.st_model = st_model
      self.st_train_args = st_train_args
      self.converter = converter
      self.tokenizer = tokenizer
      self.src_converter = src_converter
      self.src_tokenizer = src_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_beam_size = beam_size
      self.hugging_face_decoder_max_length = (
          hugging_face_decoder_max_length
      )
      self.maxlenratio = maxlenratio
      self.minlenratio = minlenratio
      self.asr_beam_search = asr_beam_search
      self.asr_maxlenratio = asr_maxlenratio
      self.asr_minlenratio = asr_minlenratio
      self.device = device
      self.dtype = dtype
      self.nbest = nbest
      self.asr_nbest = asr_nbest
      self.ctc_greedy = ctc_greedy
  
imports: import argparse
  import logging
  import sys
  from pathlib import Path
  from typing import Any, List, Optional, Sequence, Tuple, Union
  import numpy
  import torch
  from typeguard import check_argument_types, check_return_type
  from espnet2.asr.transducer.beam_search_transducer import BeamSearchTransducer
  from espnet2.asr.transducer.beam_search_transducer import Hypothesis
  from espnet2.fileio.datadir_writer import DatadirWriter
  from espnet2.tasks.enh_s2t import EnhS2TTask
  from espnet2.tasks.lm import LMTask
  from espnet2.tasks.st import STTask
  from espnet2.text.build_tokenizer import build_tokenizer
  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.types import str2bool, str2triple_str, str_or_none
  from espnet.nets.batch_beam_search import BatchBeamSearch
  from espnet.nets.beam_search import BeamSearch, Hypothesis
  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(st_train_config, st_model_file, transducer_conf, lm_train_config, lm_file, ngram_scorer, ngram_file, token_type, bpemodel, src_lm_train_config, src_lm_file, src_ngram_scorer, src_ngram_file, src_token_type, src_bpemodel, device, maxlenratio, minlenratio, asr_maxlenratio, asr_minlenratio, batch_size, dtype, beam_size, ctc_weight, lm_weight, ngram_weight, penalty, nbest, normalize_length, asr_beam_size, asr_lm_weight, asr_ngram_weight, asr_penalty, asr_ctc_weight, asr_nbest, enh_s2t_task, ctc_greedy, hugging_face_decoder, hugging_face_decoder_max_length)