code: def generate():
      parser = argparse.ArgumentParser(description="TTS inference")
      parser.add_argument(
          "--model-dir", type=str, help="model checkpoint dir"
      )
      parser.add_argument("--wav", type=str, help="output wav path")
      parser.add_argument("--txt", type=str, help="input text")
      parser.add_argument(
          "--uroman-dir",
          type=str,
          default=None,
          help="uroman lib dir (will download if not specified)",
      )
      parser.add_argument(
          "--lang",
          type=str,
          default=None,
          help="language iso code (required for Romanian)",
      )
      args = parser.parse_args()
      ckpt_dir, wav_path, txt = args.model_dir, args.wav, args.txt
  
      if torch.cuda.is_available():
          device = torch.device("cuda")
      elif (
          hasattr(torch.backends, "mps")
          and torch.backends.mps.is_available()
          and torch.backends.mps.is_built()
      ):
          device = torch.device("mps")
      else:
          device = torch.device("cpu")
  
      print(f"Run inference with {device}")
      vocab_file = f"{ckpt_dir}/vocab.txt"
      config_file = f"{ckpt_dir}/config.json"
      assert os.path.isfile(config_file), f"{config_file} doesn't exist"
      hps = utils.get_hparams_from_file(config_file)
      text_mapper = TextMapper(vocab_file)
      net_g = SynthesizerTrn(
          len(text_mapper.symbols),
          hps.data.filter_length // 2 + 1,
          hps.train.segment_size // hps.data.hop_length,
          **hps.model,
      )
      net_g.to(device)
      _ = net_g.eval()
  
      g_pth = f"{ckpt_dir}/G_100000.pth"
      print(f"load {g_pth}")
  
      _ = utils.load_checkpoint(g_pth, net_g, None)
  
      print(f"text: {txt}")
      is_uroman = hps.data.training_files.split(".")[-1] == "uroman"
      if is_uroman:
          with tempfile.TemporaryDirectory() as tmp_dir:
              if args.uroman_dir is None:
                  cmd = f"git clone git@github.com:isi-nlp/uroman.git {tmp_dir}"
                  print(cmd)
                  subprocess.check_output(cmd, shell=True)
                  args.uroman_dir = tmp_dir
              uroman_pl = os.path.join(
                  args.uroman_dir, "bin", "uroman.pl"
              )
              print(f"uromanize")
              txt = text_mapper.uromanize(txt, uroman_pl)
              print(f"uroman text: {txt}")
      txt = txt.lower()
      txt = text_mapper.filter_oov(txt, lang=args.lang)
      stn_tst = text_mapper.get_text(txt, hps)
      with torch.no_grad():
          x_tst = stn_tst.unsqueeze(0).to(device)
          x_tst_lengths = torch.LongTensor([stn_tst.size(0)]).to(device)
          hyp = (
              net_g.infer(
                  x_tst,
                  x_tst_lengths,
                  noise_scale=0.667,
                  noise_scale_w=0.8,
                  length_scale=1.0,
              )[0][0, 0]
              .cpu()
              .float()
              .numpy()
          )
  
      os.makedirs(os.path.dirname(wav_path), exist_ok=True)
      print(f"wav: {wav_path}")
      write(wav_path, hps.data.sampling_rate, hyp)
      return
  
imports: import os
  import re
  import glob
  import json
  import tempfile
  import math
  import torch
  from torch import nn
  from torch.nn import functional
  from torch.utils.data import DataLoader
  import numpy
  import commons
  import utils
  import argparse
  import subprocess
  from data_utils import TextAudioLoader, TextAudioCollate, TextAudioSpeakerLoader, TextAudioSpeakerCollate
  from models import SynthesizerTrn
  from scipy.io.wavfile import write
label_desc: Use image node_id 1 for calling a global function with example usage: generate() without return types