class_docstr: Speech2Text class for unsupervised ASR
  
  Examples:
      >>> import soundfile
      >>> speech2text = Speech2Text("uasr_config.yml", "uasr.pth")
      >>> audio, rate = soundfile.read("speech.wav")
      >>> speech2text(audio)
      [(text, token, token_int, hypothesis_object), ...]
code: def __init__(
      self,
      uasr_train_config: Union[Path, str] = None,
      uasr_model_file: Union[Path, str] = 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",
      batch_size: int = 1,
      dtype: str = "float32",
      beam_size: int = 20,
      lm_weight: float = 1.0,
      ngram_weight: float = 0.9,
      nbest: int = 1,
      quantize_uasr_model: bool = False,
      quantize_lm: bool = False,
      quantize_modules: List[str] = ["Linear"],
      quantize_dtype: str = "qint8",
  ):
      assert check_argument_types()
  
      if quantize_uasr_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 UASR model
      scorers = {}
      uasr_model, uasr_train_args = UASRTask.build_model_from_file(
          uasr_train_config, uasr_model_file, device
      )
      # TODO(Jiatong): change to not used pre-extracted features for inference
      uasr_model.use_collected_training_feats = True
      uasr_model.to(dtype=getattr(torch, dtype)).eval()
  
      if quantize_uasr_model:
          logging.info("Use quantized uasr model for decoding.")
  
          uasr_model = torch.quantization.quantize_dynamic(
              uasr_model,
              qconfig_spec=quantize_modules,
              dtype=quantize_dtype,
          )
  
      decoder = UASRPrefixScorer(eos=uasr_model.eos)
      token_list = uasr_model.token_list
      scorers.update(decoder=decoder)
      logging.info(f"beam search token list: {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
      weights = dict(
          decoder=1.0,
          lm=lm_weight,
          ngram=ngram_weight,
      )
  
      beam_search = BeamSearch(
          beam_size=beam_size,
          weights=weights,
          scorers=scorers,
          sos=uasr_model.sos,
          eos=uasr_model.eos,
          vocab_size=len(token_list),
          token_list=token_list,
          pre_beam_score_key=None,  # NOTE(jiatong): for frame-decoding
      )
  
      # 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}")
  
      # 5. [Optional] Build Text converter: e.g. bpe-sym -> Text
      if token_type is None:
          token_type = uasr_train_args.token_type
      if bpemodel is None:
          bpemodel = uasr_train_args.bpemodel
  
      # delete
      token_type = "word"
  
      if token_type is None:
          tokenizer = None
      elif token_type == "bpe":
          if bpemodel is not None:
              tokenizer = build_tokenizer(
                  token_type=token_type, bpemodel=bpemodel
              )
          else:
              tokenizer = None
      else:
          tokenizer = build_tokenizer(token_type=token_type)
      converter = TokenIDConverter(token_list=token_list)
      logging.info(f"Text tokenizer: {tokenizer}")
  
      self.uasr_model = uasr_model
      self.uasr_train_args = uasr_train_args
      self.converter = converter
      self.tokenizer = tokenizer
      self.beam_search = beam_search
      self.device = device
      self.dtype = dtype
      self.nbest = nbest
  
imports: import argparse
  import logging
  import sys
  from distutils.version import LooseVersion
  from pathlib import Path
  from typing import Any, List, Optional, Sequence, Tuple, Union
  import numpy
  import torch
  import torch.quantization
  from typeguard import check_argument_types, check_return_type
  from espnet2.fileio.datadir_writer import DatadirWriter
  from espnet2.tasks.lm import LMTask
  from espnet2.tasks.uasr import UASRTask
  from espnet2.text.build_tokenizer import build_tokenizer
  from espnet2.text.token_id_converter import TokenIDConverter
  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.uasr import UASRPrefixScorer
  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(uasr_train_config, uasr_model_file, lm_train_config, lm_file, ngram_scorer, ngram_file, token_type, bpemodel, device, batch_size, dtype, beam_size, lm_weight, ngram_weight, nbest, quantize_uasr_model, quantize_lm, quantize_modules, quantize_dtype)