| | |
| |
|
| | import argparse |
| | import os |
| | import sys |
| | import tempfile |
| | import time |
| |
|
| | import torch |
| | import torchaudio |
| |
|
| | from tortoise.api import MODELS_DIR, TextToSpeech |
| | from tortoise.utils.audio import get_voices, load_voices, load_audio |
| | from tortoise.utils.text import split_and_recombine_text |
| |
|
| | parser = argparse.ArgumentParser( |
| | description='TorToiSe is a text-to-speech program that is capable of synthesizing speech ' |
| | 'in multiple voices with realistic prosody and intonation.') |
| |
|
| | parser.add_argument( |
| | 'text', type=str, nargs='*', |
| | help='Text to speak. If omitted, text is read from stdin.') |
| | parser.add_argument( |
| | '-v, --voice', type=str, default='random', metavar='VOICE', dest='voice', |
| | help='Selects the voice to use for generation. Use the & character to join two voices together. ' |
| | 'Use a comma to perform inference on multiple voices. Set to "all" to use all available voices. ' |
| | 'Note that multiple voices require the --output-dir option to be set.') |
| | parser.add_argument( |
| | '-V, --voices-dir', metavar='VOICES_DIR', type=str, dest='voices_dir', |
| | help='Path to directory containing extra voices to be loaded. Use a comma to specify multiple directories.') |
| | parser.add_argument( |
| | '-p, --preset', type=str, default='fast', choices=['ultra_fast', 'fast', 'standard', 'high_quality'], dest='preset', |
| | help='Which voice quality preset to use.') |
| | parser.add_argument( |
| | '-q, --quiet', default=False, action='store_true', dest='quiet', |
| | help='Suppress all output.') |
| |
|
| | output_group = parser.add_mutually_exclusive_group(required=True) |
| | output_group.add_argument( |
| | '-l, --list-voices', default=False, action='store_true', dest='list_voices', |
| | help='List available voices and exit.') |
| | output_group.add_argument( |
| | '-P, --play', action='store_true', dest='play', |
| | help='Play the audio (requires pydub).') |
| | output_group.add_argument( |
| | '-o, --output', type=str, metavar='OUTPUT', dest='output', |
| | help='Save the audio to a file.') |
| | output_group.add_argument( |
| | '-O, --output-dir', type=str, metavar='OUTPUT_DIR', dest='output_dir', |
| | help='Save the audio to a directory as individual segments.') |
| |
|
| | multi_output_group = parser.add_argument_group('multi-output options (requires --output-dir)') |
| | multi_output_group.add_argument( |
| | '--candidates', type=int, default=1, |
| | help='How many output candidates to produce per-voice. Note that only the first candidate is used in the combined output.') |
| | multi_output_group.add_argument( |
| | '--regenerate', type=str, default=None, |
| | help='Comma-separated list of clip numbers to re-generate.') |
| | multi_output_group.add_argument( |
| | '--skip-existing', action='store_true', |
| | help='Set to skip re-generating existing clips.') |
| |
|
| | advanced_group = parser.add_argument_group('advanced options') |
| | advanced_group.add_argument( |
| | '--produce-debug-state', default=False, action='store_true', |
| | help='Whether or not to produce debug_states in current directory, which can aid in reproducing problems.') |
| | advanced_group.add_argument( |
| | '--seed', type=int, default=None, |
| | help='Random seed which can be used to reproduce results.') |
| | advanced_group.add_argument( |
| | '--models-dir', type=str, default=MODELS_DIR, |
| | help='Where to find pretrained model checkpoints. Tortoise automatically downloads these to ' |
| | '~/.cache/tortoise/.models, so this should only be specified if you have custom checkpoints.') |
| | advanced_group.add_argument( |
| | '--text-split', type=str, default=None, |
| | help='How big chunks to split the text into, in the format <desired_length>,<max_length>.') |
| | advanced_group.add_argument( |
| | '--disable-redaction', default=False, action='store_true', |
| | help='Normally text enclosed in brackets are automatically redacted from the spoken output ' |
| | '(but are still rendered by the model), this can be used for prompt engineering. ' |
| | 'Set this to disable this behavior.') |
| | advanced_group.add_argument( |
| | '--device', type=str, default=None, |
| | help='Device to use for inference.') |
| | advanced_group.add_argument( |
| | '--batch-size', type=int, default=None, |
| | help='Batch size to use for inference. If omitted, the batch size is set based on available GPU memory.') |
| |
|
| | tuning_group = parser.add_argument_group('tuning options (overrides preset settings)') |
| | tuning_group.add_argument( |
| | '--num-autoregressive-samples', type=int, default=None, |
| | help='Number of samples taken from the autoregressive model, all of which are filtered using CLVP. ' |
| | 'As TorToiSe is a probabilistic model, more samples means a higher probability of creating something "great".') |
| | tuning_group.add_argument( |
| | '--temperature', type=float, default=None, |
| | help='The softmax temperature of the autoregressive model.') |
| | tuning_group.add_argument( |
| | '--length-penalty', type=float, default=None, |
| | help='A length penalty applied to the autoregressive decoder. Higher settings causes the model to produce more terse outputs.') |
| | tuning_group.add_argument( |
| | '--repetition-penalty', type=float, default=None, |
| | help='A penalty that prevents the autoregressive decoder from repeating itself during decoding. ' |
| | 'Can be used to reduce the incidence of long silences or "uhhhhhhs", etc.') |
| | tuning_group.add_argument( |
| | '--top-p', type=float, default=None, |
| | help='P value used in nucleus sampling. 0 to 1. Lower values mean the decoder produces more "likely" (aka boring) outputs.') |
| | tuning_group.add_argument( |
| | '--max-mel-tokens', type=int, default=None, |
| | help='Restricts the output length. 1 to 600. Each unit is 1/20 of a second.') |
| | tuning_group.add_argument( |
| | '--cvvp-amount', type=float, default=None, |
| | help='How much the CVVP model should influence the output.' |
| | 'Increasing this can in some cases reduce the likelihood of multiple speakers.') |
| | tuning_group.add_argument( |
| | '--diffusion-iterations', type=int, default=None, |
| | help='Number of diffusion steps to perform. More steps means the network has more chances to iteratively' |
| | 'refine the output, which should theoretically mean a higher quality output. ' |
| | 'Generally a value above 250 is not noticeably better, however.') |
| | tuning_group.add_argument( |
| | '--cond-free', type=bool, default=None, |
| | help='Whether or not to perform conditioning-free diffusion. Conditioning-free diffusion performs two forward passes for ' |
| | 'each diffusion step: one with the outputs of the autoregressive model and one with no conditioning priors. The output ' |
| | 'of the two is blended according to the cond_free_k value below. Conditioning-free diffusion is the real deal, and ' |
| | 'dramatically improves realism.') |
| | tuning_group.add_argument( |
| | '--cond-free-k', type=float, default=None, |
| | help='Knob that determines how to balance the conditioning free signal with the conditioning-present signal. [0,inf]. ' |
| | 'As cond_free_k increases, the output becomes dominated by the conditioning-free signal. ' |
| | 'Formula is: output=cond_present_output*(cond_free_k+1)-cond_absenct_output*cond_free_k') |
| | tuning_group.add_argument( |
| | '--diffusion-temperature', type=float, default=None, |
| | help='Controls the variance of the noise fed into the diffusion model. [0,1]. Values at 0 ' |
| | 'are the "mean" prediction of the diffusion network and will sound bland and smeared. ') |
| |
|
| | usage_examples = f''' |
| | Examples: |
| | |
| | Read text using random voice and place it in a file: |
| | |
| | {parser.prog} -o hello.wav "Hello, how are you?" |
| | |
| | Read text from stdin and play it using the tom voice: |
| | |
| | echo "Say it like you mean it!" | {parser.prog} -P -v tom |
| | |
| | Read a text file using multiple voices and save the audio clips to a directory: |
| | |
| | {parser.prog} -O /tmp/tts-results -v tom,emma <textfile.txt |
| | ''' |
| |
|
| | try: |
| | args = parser.parse_args() |
| | except SystemExit as e: |
| | if e.code == 0: |
| | print(usage_examples) |
| | sys.exit(e.code) |
| |
|
| | extra_voice_dirs = args.voices_dir.split(',') if args.voices_dir else [] |
| | all_voices = sorted(get_voices(extra_voice_dirs)) |
| |
|
| | if args.list_voices: |
| | for v in all_voices: |
| | print(v) |
| | sys.exit(0) |
| |
|
| | selected_voices = all_voices if args.voice == 'all' else args.voice.split(',') |
| | selected_voices = [v.split('&') if '&' in v else [v] for v in selected_voices] |
| | for voices in selected_voices: |
| | for v in voices: |
| | if v != 'random' and v not in all_voices: |
| | parser.error(f'voice {v} not available, use --list-voices to see available voices.') |
| |
|
| | if len(args.text) == 0: |
| | text = '' |
| | for line in sys.stdin: |
| | text += line |
| | else: |
| | text = ' '.join(args.text) |
| | text = text.strip() |
| | if args.text_split: |
| | desired_length, max_length = [int(x) for x in args.text_split.split(',')] |
| | if desired_length > max_length: |
| | parser.error(f'--text-split: desired_length ({desired_length}) must be <= max_length ({max_length})') |
| | texts = split_and_recombine_text(text, desired_length, max_length) |
| | else: |
| | texts = split_and_recombine_text(text) |
| | if len(texts) == 0: |
| | parser.error('no text provided') |
| |
|
| | if args.output_dir: |
| | os.makedirs(args.output_dir, exist_ok=True) |
| | else: |
| | if len(selected_voices) > 1: |
| | parser.error('cannot have multiple voices without --output-dir"') |
| | if args.candidates > 1: |
| | parser.error('cannot have multiple candidates without --output-dir"') |
| |
|
| | |
| | if args.play: |
| | try: |
| | import pydub |
| | import pydub.playback |
| | except ImportError: |
| | parser.error('--play requires pydub to be installed, which can be done with "pip install pydub"') |
| |
|
| | seed = int(time.time()) if args.seed is None else args.seed |
| | if not args.quiet: |
| | print('Loading tts...') |
| | tts = TextToSpeech(models_dir=args.models_dir, enable_redaction=not args.disable_redaction, |
| | device=args.device, autoregressive_batch_size=args.batch_size) |
| | gen_settings = { |
| | 'use_deterministic_seed': seed, |
| | 'verbose': not args.quiet, |
| | 'k': args.candidates, |
| | 'preset': args.preset, |
| | } |
| | tuning_options = [ |
| | 'num_autoregressive_samples', 'temperature', 'length_penalty', 'repetition_penalty', 'top_p', |
| | 'max_mel_tokens', 'cvvp_amount', 'diffusion_iterations', 'cond_free', 'cond_free_k', 'diffusion_temperature'] |
| | for option in tuning_options: |
| | if getattr(args, option) is not None: |
| | gen_settings[option] = getattr(args, option) |
| | total_clips = len(texts) * len(selected_voices) |
| | regenerate_clips = [int(x) for x in args.regenerate.split(',')] if args.regenerate else None |
| | for voice_idx, voice in enumerate(selected_voices): |
| | audio_parts = [] |
| | voice_samples, conditioning_latents = load_voices(voice, extra_voice_dirs) |
| | for text_idx, text in enumerate(texts): |
| | clip_name = f'{"-".join(voice)}_{text_idx:02d}' |
| | if args.output_dir: |
| | first_clip = os.path.join(args.output_dir, f'{clip_name}_00.wav') |
| | if (args.skip_existing or (regenerate_clips and text_idx not in regenerate_clips)) and os.path.exists(first_clip): |
| | audio_parts.append(load_audio(first_clip, 24000)) |
| | if not args.quiet: |
| | print(f'Skipping {clip_name}') |
| | continue |
| | if not args.quiet: |
| | print(f'Rendering {clip_name} ({(voice_idx * len(texts) + text_idx + 1)} of {total_clips})...') |
| | print(' ' + text) |
| | gen = tts.tts_with_preset( |
| | text, voice_samples=voice_samples, conditioning_latents=conditioning_latents, **gen_settings) |
| | gen = gen if args.candidates > 1 else [gen] |
| | for candidate_idx, audio in enumerate(gen): |
| | audio = audio.squeeze(0).cpu() |
| | if candidate_idx == 0: |
| | audio_parts.append(audio) |
| | if args.output_dir: |
| | filename = f'{clip_name}_{candidate_idx:02d}.wav' |
| | torchaudio.save(os.path.join(args.output_dir, filename), audio, 24000) |
| |
|
| | audio = torch.cat(audio_parts, dim=-1) |
| | if args.output_dir: |
| | filename = f'{"-".join(voice)}_combined.wav' |
| | torchaudio.save(os.path.join(args.output_dir, filename), audio, 24000) |
| | elif args.output: |
| | filename = args.output if args.output else os.tmp |
| | torchaudio.save(args.output, audio, 24000) |
| | elif args.play: |
| | f = tempfile.NamedTemporaryFile(suffix='.wav', delete=True) |
| | torchaudio.save(f.name, audio, 24000) |
| | pydub.playback.play(pydub.AudioSegment.from_wav(f.name)) |
| |
|
| | if args.produce_debug_state: |
| | os.makedirs('debug_states', exist_ok=True) |
| | dbg_state = (seed, texts, voice_samples, conditioning_latents, args) |
| | torch.save(dbg_state, os.path.join('debug_states', f'debug_{"-".join(voice)}.pth')) |
| |
|
