class_docstr: Text2Text class
  
  Examples:
      >>> text2text = Text2Text("mt_config.yml", "mt.pth")
      >>> text2text(audio)
      [(text, token, token_int, hypothesis object), ...]
class_docstr_tok: ["Text2Text","class","Examples",":",">",">",">","text2text","=","Text2Text","(","``","mt_config.yml","''",",","``","mt.pth","''",")",">",">",">","text2text","(","audio",")","[","(","text",",","token",",","token_int",",","hypothesis","object",")",",","...","]"]
code: def __init__(
      self,
      mt_train_config: Union[Path, str] = None,
      mt_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",
      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,
  ):
      assert check_argument_types()
  
      # 1. Build MT model
      scorers = {}
      mt_model, mt_train_args = MTTask.build_model_from_file(
          mt_train_config, mt_model_file, device
      )
      mt_model.to(dtype=getattr(torch, dtype)).eval()
  
      decoder = mt_model.decoder
      ctc = (
          CTCPrefixScorer(ctc=mt_model.ctc, eos=mt_model.eos)
          if ctc_weight != 0.0
          else None
      )
      token_list = mt_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
          )
          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 - 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=mt_model.sos,
          eos=mt_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:
              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 = mt_train_args.token_type
      if bpemodel is None:
          bpemodel = mt_train_args.bpemodel
  
      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.mt_model = mt_model
      self.mt_train_args = mt_train_args
      self.converter = converter
      self.tokenizer = tokenizer
      self.beam_search = beam_search
      self.maxlenratio = maxlenratio
      self.minlenratio = minlenratio
      self.device = device
      self.dtype = dtype
      self.nbest = nbest
  
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.fileio.datadir_writer import DatadirWriter
  from espnet2.tasks.lm import LMTask
  from espnet2.tasks.mt import MTTask
  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.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 Text2Text object  with example: obj = Text2Text(mt_train_config, mt_model_file, 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)