class_docstr: GenerateText class
  
  Examples:
      >>> generatetext = GenerateText(
              lm_train_config="lm_config.yaml",
              lm_file="lm.pth",
              token_type="bpe",
              bpemodel="bpe.model",
          )
      >>> prompt = "I have travelled to many "
      >>> generatetext(prompt)
      [(text, token, token_int, hypothesis object), ...]
class_docstr_tok: ["GenerateText","class","Examples",":",">",">",">","generatetext","=","GenerateText","(","lm_train_config=","''","lm_config.yaml","''",",","lm_file=","''","lm.pth","''",",","token_type=","''","bpe","''",",","bpemodel=","''","bpe.model","''",",",")",">",">",">","prompt","=","``","I","have","travelled","to","many","``",">",">",">","generatetext","(","prompt",")","[","(","text",",","token",",","token_int",",","hypothesis","object",")",",","...","]"]
code: def __init__(
      self,
      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",
      maxlen: int = 100,
      minlen: int = 0,
      batch_size: int = 1,
      dtype: str = "float32",
      beam_size: int = 20,
      ngram_weight: float = 0.0,
      penalty: float = 0.0,
      nbest: int = 1,
      quantize_lm: bool = False,
      quantize_modules: List[str] = ["Linear"],
      quantize_dtype: str = "qint8",
  ):
      assert check_argument_types()
  
      # 1. Build language model
      lm, lm_train_args = LMTask.build_model_from_file(
          lm_train_config, lm_file, device
      )
      lm.to(dtype=getattr(torch, dtype)).eval()
  
      if quantize_lm:
          logging.info("Use quantized LM for decoding.")
  
          lm = torch.quantization.quantize_dynamic(
              lm,
              qconfig_spec=set(
                  [getattr(torch.nn, q) for q in quantize_modules]
              ),
              dtype=getattr(torch, quantize_dtype),
          )
  
      token_list = lm_train_args.token_list
  
      # 2. 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
  
      # 3. Build BeamSearch object
      scorers = dict(
          lm=lm.lm,
          ngram=ngram,
          length_bonus=LengthBonus(len(token_list)),
      )
      weights = dict(
          lm=1.0,
          ngram=ngram_weight,
          length_bonus=penalty,
      )
  
      beam_search = BeamSearch(
          scorers=scorers,
          weights=weights,
          beam_size=beam_size,
          vocab_size=len(token_list),
          sos=lm.sos,
          eos=lm.eos,
          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}")
  
      # 4. [Optional] Build Text converter: e.g. bpe-sym -> Text
      if token_type is None:
          token_type = lm_train_args.token_type
      if bpemodel is None:
          bpemodel = lm_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
              )
          else:
              tokenizer = None
      else:
          tokenizer = build_tokenizer(token_type=token_type)
  
      if bpemodel not in ["whisper_en", "whisper_multilingual"]:
          converter = TokenIDConverter(token_list=token_list)
      else:
          converter = OpenAIWhisperTokenIDConverter(model_type=bpemodel)
          beam_search.set_hyp_primer(
              list(
                  converter.tokenizer.sot_sequence_including_notimestamps
              )
          )
      logging.info(f"Text tokenizer: {tokenizer}")
  
      self.lm = lm
      self.lm_train_args = lm_train_args
      self.converter = converter
      self.tokenizer = tokenizer
      self.beam_search = beam_search
      self.maxlen = maxlen
      self.minlen = minlen
      self.device = device
      self.dtype = dtype
      self.nbest = nbest
  
imports: import argparse
  import logging
  import sys
  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.fileio.datadir_writer import DatadirWriter
  from espnet2.tasks.lm import LMTask
  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.scorer_interface import BatchScorerInterface
  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 GenerateText object  with example: obj = GenerateText(lm_train_config, lm_file, ngram_scorer, ngram_file, token_type, bpemodel, device, maxlen, minlen, batch_size, dtype, beam_size, ngram_weight, penalty, nbest, quantize_lm, quantize_modules, quantize_dtype)