Publish Moldovan Romanian XTTS-v2 model

LICENSE.txt

@@ -0,0 +1,84 @@
+# Coqui Public Model License 1.0.0
+https://coqui.ai/cpml.txt
+
+
+This license allows only non-commercial use of a machine learning model and its outputs.
+
+
+## Acceptance
+
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+
+## Licenses
+
+
+The licensor grants you a copyright license to do everything you might do with the model that would otherwise infringe the licensor's copyright in it, for any non-commercial purpose. The licensor grants you a patent license that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the model in the form provided by 
+the licensor, for any non-commercial purpose.
+
+
+## Non-commercial Purpose
+
+
+Non-commercial purposes include any of the following uses of the model or its output, but only so far as you do not receive any direct or indirect payment arising from the use of the model or its output.
+
+
+### Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious
+observance. 
+
+
+### Use by commercial or for-profit entities for testing, evaluation, or non-commercial research and development. Use of the model to train other models for commercial use is not a non-commercial purpose. 
+
+
+### Use by any charitable organization for charitable purposes, or for testing or evaluation. Use for revenue-generating activity, including projects directly funded by government grants, is not a non-commercial purpose.
+
+
+## Notices
+
+
+You must ensure that anyone who gets a copy of any part of the model, or any modification of the model, or their output, from you also gets a copy of these terms or the URL for them above.
+
+
+## No Other Rights
+
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+
+## Patent Defense
+
+
+If you make any written claim that the model infringes or contributes to infringement of any patent, your licenses for the model granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+
+## Violations
+
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the model or its output that is not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 30 days of receiving notice.  Otherwise, all your licenses
+end immediately.
+
+
+## No Liability
+
+
+***As far as the law allows, the model and its output come as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the model or its output, under any kind of legal claim. If this provision is not enforceable in your jurisdiction, your licenses are void.***
+
+
+## Definitions
+
+
+The **licensor** is the individual or entity offering these terms, and the **model** is the model the licensor makes available under these terms, including any documentation or similar information about the model.
+
+
+**You** refers to the individual or entity agreeing to these terms.
+
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+
+**Your licenses** are all the licenses granted to you under these terms.
+
+
+**Use** means anything you do with the model or its output requiring one of your licenses.

README.md

@@ -0,0 +1,126 @@
+---
+language:
+- ro
+license: other
+license_name: coqui-public-model-license-1.0.0
+license_link: https://coqui.ai/cpml.txt
+library_name: coqui
+pipeline_tag: text-to-speech
+base_model: coqui/XTTS-v2
+tags:
+- xtts-v2
+- text-to-speech
+- romanian
+- moldovan-dialect
+- voice-cloning
+- educational-speech
+datasets:
+- other
+---
+
+# XTTS-v2 for Moldovan Dialectal Romanian
+
+This checkpoint adapts
+[`coqui/XTTS-v2`](https://huggingface.co/coqui/XTTS-v2) to Romanian educational
+speech with Moldovan dialectal characteristics. XTTS-v2 is a multilingual
+voice-cloning model and requires a short reference recording at inference time.
+
+## Training data and configuration
+
+TTS preparation started from a 35,760-segment Romanian educational-speech
+corpus. Segments exceeding the configured maximum waveform length were removed,
+leaving 31,472 eligible utterances (55.05 hours). With seed 42, these were split
+as follows:
+
+| Partition | Utterances | Duration |
+|---|---:|---:|
+| Train | 25,178 | 44.06 h |
+| Evaluation | 3,147 | 5.47 h |
+| Test | 3,147 | 5.52 h |
+
+Training used an NVIDIA A100-SXM4-80GB GPU for 30 epochs, batch size 4,
+gradient accumulation 63 (effective batch size 252), and learning rate
+`5e-6`. The recorded execution lasted 8 hours and 6 minutes.
+
+Corpus release:
+https://drive.google.com/drive/folders/1Va0tmpp-Q8A2gGbFwLignYVtf0KD6Uth
+
+## Files
+
+- `best_model.pth`: fine-tuned XTTS-v2 checkpoint.
+- `config.json`: model and inference configuration.
+- `vocab.json`: tokenizer vocabulary.
+- `dvae.pth` and `mel_stats.pth`: XTTS-v2 acoustic assets.
+- `generate_tts.py`: local inference example, including Romanian text
+  normalization used during evaluation.
+
+No reference-speaker recording is included. Supply a reference WAV for a voice
+that you have permission to use.
+
+## Installation and usage
+
+Use Python 3.10 or 3.11 and install the dependencies from `requirements.txt`.
+Download the repository, place a reference recording at
+`reference_voice/reference.wav`, edit `TEXT` in `generate_tts.py`, and run:
+
+```bash
+python generate_tts.py
+```
+
+The included script loads `best_model.pth` explicitly, applies Romanian
+cedilla-to-comma-below normalization, and synthesizes at 24 kHz. A CUDA-capable
+GPU is strongly recommended.
+
+## Evaluation
+
+Automatic intelligibility proxies on 10 generated prompts produced 1.68% WER
+(95% CI 0.00-4.13), 0.36% CER (0.00-0.86), and generation RTF 0.388. These
+scores were obtained by transcribing generated speech with the accompanying
+fine-tuned ASR model and are not independent measures of speech quality.
+
+A randomized, model-blinded pilot evaluation involved 10 listeners (8 native
+Moldovan listeners), 10 matched prompts, five female and five male reference
+voices, and 20 samples per listener. Naturalness and timbre similarity favored
+the fine-tuned model after listener-level multiplicity correction. Moldovan
+dialectal adequacy showed a positive but statistically uncertain trend;
+pronunciation favored the Romanian baseline, and sentence-ending stability was
+nearly tied.
+
+## Limitations and responsible use
+
+- The listening study is preliminary and contains only 10 listeners.
+- The training data emphasize planned educational speech, not spontaneous
+  conversation.
+- The automatic WER/CER comparison contains only 10 prompts.
+- Output quality depends strongly on reference-audio quality, text
+  normalization, and inference parameters.
+- Voice cloning must only be performed with informed consent or another valid
+  legal basis. Do not use this model for impersonation, deception, fraud, or
+  unauthorized biometric processing.
+
+## Authors and project
+
+Marius Cerescu, Alexandr Parahonco, Olesea Caftanatov, Tudor Bumbu, Nichita
+Degteariov, and Ion Bostan. Vladimir Andrunachievici Institute of Mathematics
+and Computer Science, Moldova State University, Chisinau, Republic of Moldova.
+
+This work was elaborated within the project *Platforma Educationala bazata pe
+Inteligenta Artificiala "Guguta"*, registered in the State Register of projects
+in science and innovation, code 25.80012.0807.21TC, project leader Tudor Bumbu,
+Dr.
+
+## Citation
+
+```bibtex
+@inproceedings{cerescu2026moldovan,
+  title     = {Fine-Tuning Neural Speech Models for Romanian Speech Recognition and Synthesis with Moldovan Dialectal Data},
+  author    = {Cerescu, Marius and Parahonco, Alexandr and Caftanatov, Olesea and Bumbu, Tudor and Degteariov, Nichita and Bostan, Ion},
+  booktitle = {International Conference on System Analysis and Intelligent Information Technologies (SAIIT)},
+  year      = {2026}
+}
+```
+
+## License
+
+This derivative model is distributed under the Coqui Public Model License 1.0.
+Review `LICENSE.txt` before downloading or using the checkpoint.

best_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4db1d793c27cdae9956b2f0ebb5519a982268e51f3becf204278f27f4dd3086f
+size 5608050938

config.json

@@ -0,0 +1,160 @@
+{
+    "output_path": "output",
+    "logger_uri": null,
+    "run_name": "run",
+    "project_name": null,
+    "run_description": "\ud83d\udc38Coqui trainer run.",
+    "print_step": 25,
+    "plot_step": 100,
+    "model_param_stats": false,
+    "wandb_entity": null,
+    "dashboard_logger": "tensorboard",
+    "save_on_interrupt": true,
+    "log_model_step": null,
+    "save_step": 10000,
+    "save_n_checkpoints": 5,
+    "save_checkpoints": true,
+    "save_all_best": false,
+    "save_best_after": 10000,
+    "target_loss": null,
+    "print_eval": false,
+    "test_delay_epochs": 0,
+    "run_eval": true,
+    "run_eval_steps": null,
+    "distributed_backend": "nccl",
+    "distributed_url": "tcp://localhost:54321",
+    "mixed_precision": false,
+    "precision": "fp16",
+    "epochs": 1000,
+    "batch_size": 32,
+    "eval_batch_size": 16,
+    "grad_clip": 0.0,
+    "scheduler_after_epoch": true,
+    "lr": 0.001,
+    "optimizer": "radam",
+    "optimizer_params": null,
+    "lr_scheduler": null,
+    "lr_scheduler_params": {},
+    "use_grad_scaler": false,
+    "allow_tf32": false,
+    "cudnn_enable": true,
+    "cudnn_deterministic": false,
+    "cudnn_benchmark": false,
+    "training_seed": 54321,
+    "model": "xtts",
+    "num_loader_workers": 0,
+    "num_eval_loader_workers": 0,
+    "use_noise_augment": false,
+    "audio": {
+        "sample_rate": 22050,
+        "output_sample_rate": 24000
+    },
+    "use_phonemes": false,
+    "phonemizer": null,
+    "phoneme_language": null,
+    "compute_input_seq_cache": false,
+    "text_cleaner": null,
+    "enable_eos_bos_chars": false,
+    "test_sentences_file": "",
+    "phoneme_cache_path": null,
+    "characters": null,
+    "add_blank": false,
+    "batch_group_size": 0,
+    "loss_masking": null,
+    "min_audio_len": 1,
+    "max_audio_len": 1000000000,
+    "min_text_len": 1,
+    "max_text_len": 1000000000,
+    "compute_f0": false,
+    "compute_energy": false,
+    "compute_linear_spec": false,
+    "precompute_num_workers": 0,
+    "start_by_longest": false,
+    "shuffle": false,
+    "drop_last": false,
+    "datasets": [
+        {
+            "formatter": "",
+            "dataset_name": "",
+            "path": "",
+            "meta_file_train": "",
+            "ignored_speakers": null,
+            "language": "",
+            "phonemizer": "",
+            "meta_file_val": "",
+            "meta_file_attn_mask": ""
+        }
+    ],
+    "test_sentences": [],
+    "eval_split_max_size": null,
+    "eval_split_size": 0.01,
+    "use_speaker_weighted_sampler": false,
+    "speaker_weighted_sampler_alpha": 1.0,
+    "use_language_weighted_sampler": false,
+    "language_weighted_sampler_alpha": 1.0,
+    "use_length_weighted_sampler": false,
+    "length_weighted_sampler_alpha": 1.0,
+    "model_args": {
+        "gpt_batch_size": 1,
+        "enable_redaction": false,
+        "kv_cache": true,
+        "gpt_checkpoint": null,
+        "clvp_checkpoint": null,
+        "decoder_checkpoint": null,
+        "num_chars": 255,
+        "tokenizer_file": "",
+        "gpt_max_audio_tokens": 605,
+        "gpt_max_text_tokens": 402,
+        "gpt_max_prompt_tokens": 70,
+        "gpt_layers": 30,
+        "gpt_n_model_channels": 1024,
+        "gpt_n_heads": 16,
+        "gpt_number_text_tokens": 6681,
+        "gpt_start_text_token": null,
+        "gpt_stop_text_token": null,
+        "gpt_num_audio_tokens": 1026,
+        "gpt_start_audio_token": 1024,
+        "gpt_stop_audio_token": 1025,
+        "gpt_code_stride_len": 1024,
+        "gpt_use_masking_gt_prompt_approach": true,
+        "gpt_use_perceiver_resampler": true,
+        "input_sample_rate": 22050,
+        "output_sample_rate": 24000,
+        "output_hop_length": 256,
+        "decoder_input_dim": 1024,
+        "d_vector_dim": 512,
+        "cond_d_vector_in_each_upsampling_layer": true,
+        "duration_const": 102400
+    },
+    "model_dir": null,
+    "languages": [
+        "en",
+        "es",
+        "fr",
+        "de",
+        "it",
+        "pt",
+        "pl",
+        "tr",
+        "ru",
+        "nl",
+        "cs",
+        "ar",
+        "zh-cn",
+        "hu",
+        "ko",
+        "ja",
+        "hi",
+        "ro"
+    ],
+    "temperature": 0.75,
+    "length_penalty": 1.0,
+    "repetition_penalty": 5.0,
+    "top_k": 50,
+    "top_p": 0.85,
+    "num_gpt_outputs": 1,
+    "gpt_cond_len": 30,
+    "gpt_cond_chunk_len": 4,
+    "max_ref_len": 30,
+    "sound_norm_refs": false
+}

dvae.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b29bc227d410d4991e0a8c09b858f77415013eeb9fba9650258e96095557d97a
+size 210514388

generate_tts.py

@@ -0,0 +1,297 @@
+"""
+XTTS-v2 Moldovan TTS — Generare audio din text
+Folosește modelul fine-tunat pe grai moldovenesc.
+
+Prima rulare: extrage și salvează latentele vocii de referință (~10s).
+Rulările următoare: încarcă latentele salvate (~instant).
+"""
+
+import os
+import sys
+import time
+import torch
+import soundfile as sf
+import numpy as np
+
+# ══════════════════════════════════════════════════════════════
+#  TEXT DE GENERAT (modifică aici)
+# ══════════════════════════════════════════════════════════════
+
+TEXT = """
+Bună ziua! Eu sunt un model de sinteză vocală antrenat pe grai moldovenesc.
+"""
+
+# ══════════════════════════════════════════════════════════════
+#  CONFIGURARE
+# ══════════════════════════════════════════════════════════════
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Căi model
+MODEL_DIR = SCRIPT_DIR
+CHECKPOINT_PATH = os.path.join(MODEL_DIR, "best_model.pth")
+CONFIG_PATH = os.path.join(MODEL_DIR, "config.json")
+VOCAB_PATH = os.path.join(MODEL_DIR, "vocab.json")
+
+# Voce de referință
+REFERENCE_AUDIO = os.path.join(SCRIPT_DIR, "reference_voice", "reference.wav")
+CACHED_LATENTS = os.path.join(SCRIPT_DIR, "reference_voice", "cached_latents.pth")
+
+# Output
+OUTPUT_DIR = os.path.join(SCRIPT_DIR, "output")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# Parametri generare
+TEMPERATURE = 0.7
+TOP_P = 0.7
+TOP_K = 30
+LENGTH_PENALTY = 0.8
+REPETITION_PENALTY = 10.0
+GPT_COND_LEN = 6  # Secunde de audio referință pentru condiționare
+
+# Cedilla → comma-below
+CEDILLA_TO_COMMA = str.maketrans({
+    "\u015f": "\u0219",  # ş -> ș
+    "\u0163": "\u021b",  # ţ -> ț
+    "\u015e": "\u0218",  # Ş -> Ș
+    "\u0162": "\u021a",  # Ţ -> Ț
+})
+
+
+# ══════════════════════════════════════════════════════════════
+#  PATCH TOKENIZER ROMÂNESC
+# ══════════════════════════════════════════════════════════════
+
+def patch_tokenizer_for_romanian():
+    """Aplică patch pentru suport limba română în tokenizer-ul XTTS."""
+    import re
+    import TTS
+    tts_dir = os.path.dirname(TTS.__file__)
+    tokenizer_file = os.path.join(tts_dir, "tts", "layers", "xtts", "tokenizer.py")
+
+    if not os.path.exists(tokenizer_file):
+        print(f"WARN: tokenizer.py negăsit la {tokenizer_file}")
+        return
+
+    with open(tokenizer_file, "r", encoding="utf-8") as f:
+        content = f.read()
+    original = content
+
+    # Adaugă 'ro' la listele de limbi
+    if '"ro"' not in content and "'ro'" not in content:
+        content = re.sub(
+            r"""(['"])zh-cn\1(\s*)\]""",
+            lambda m: f'{m.group(1)}zh-cn{m.group(1)}, {m.group(1)}ro{m.group(1)}{m.group(2)}]',
+            content
+        )
+
+    # Safe .get() replacements
+    for old, new in {
+        "self.abbreviations[lang]": "self.abbreviations.get(lang, [])",
+        "self.symbols[lang]": "self.symbols.get(lang, [])",
+        "_abbreviations[lang]": "_abbreviations.get(lang, [])",
+        "_symbols_multilingual[lang]": "_symbols_multilingual.get(lang, [])",
+        'and_equivalents[lang]': 'and_equivalents.get(lang, "and")',
+        '_ordinal_re[lang]': '_ordinal_re.get(lang, re.compile(r"(?!x)x"))',
+    }.items():
+        if old in content:
+            content = content.replace(old, new)
+
+    # Cedilla normalization block
+    if "_CEDILLA_TO_COMMA" not in content:
+        import_match = re.search(r'^import re\s*$', content, re.MULTILINE)
+        if import_match:
+            cedilla_block = (
+                '\n# Cedilla -> comma-below normalization for Romanian\n'
+                '_CEDILLA_TO_COMMA = str.maketrans({\n'
+                '    "\u015f": "\u0219",\n'
+                '    "\u0163": "\u021b",\n'
+                '    "\u015e": "\u0218",\n'
+                '    "\u0162": "\u021a",\n'
+                '})\n'
+            )
+            pos = import_match.end()
+            content = content[:pos] + cedilla_block + content[pos:]
+
+    # Inject cedilla normalization in multilingual_cleaners
+    if "_CEDILLA_TO_COMMA" in content:
+        mc_match = re.search(r'(def multilingual_cleaners\([^)]*\):\s*\n)', content)
+        if mc_match:
+            func_start = mc_match.end()
+            if "_CEDILLA_TO_COMMA" not in content[func_start:func_start + 500]:
+                injection = '    if lang == "ro":\n        text = text.translate(_CEDILLA_TO_COMMA)\n'
+                content = content[:func_start] + injection + content[func_start:]
+
+    # Add 'ro' to _ordinal_re dict
+    if "_ordinal_re" in content:
+        ord_match = re.search(r'_ordinal_re\s*=\s*\{', content)
+        if ord_match:
+            brace_start = content.index('{', ord_match.start())
+            depth = 0
+            brace_end = brace_start
+            for ci in range(brace_start, len(content)):
+                if content[ci] == '{':
+                    depth += 1
+                elif content[ci] == '}':
+                    depth -= 1
+                if depth == 0:
+                    brace_end = ci
+                    break
+            ordinal_dict = content[brace_start:brace_end + 1]
+            if '"ro"' not in ordinal_dict and "'ro'" not in ordinal_dict:
+                new_dict = ordinal_dict[:-1] + '    "ro": re.compile(r"([0-9]+)\\.(?=\\s|$)"),\n}'
+                content = content[:brace_start] + new_dict + content[brace_end + 1:]
+
+    # Add 'ro' to preprocess_text
+    for old_pat, new_pat in [
+        ('"pt", "ru"', '"pt", "ro", "ru"'),
+        ("'pt', 'ru'", "'pt', 'ro', 'ru'"),
+    ]:
+        if old_pat in content:
+            content = content.replace(old_pat, new_pat, 1)
+            break
+
+    if content != original:
+        with open(tokenizer_file, "w", encoding="utf-8") as f:
+            f.write(content)
+        # Reload affected modules
+        mods_to_reload = [k for k in sys.modules if 'xtts' in k.lower() or 'tokenizer' in k.lower()]
+        for mod in mods_to_reload:
+            del sys.modules[mod]
+        print("  Tokenizer patch românesc aplicat!")
+    else:
+        print("  Tokenizer deja patch-uit.")
+
+
+# ══════════════════════════════════════════════════════════════
+#  MAIN
+# ══════════════════════════════════════════════════════════════
+
+def main():
+    t_start = time.time()
+
+    # Verificări
+    if not os.path.exists(CHECKPOINT_PATH):
+        print(f"ERROR: best_model.pth nu există la {CHECKPOINT_PATH}")
+        sys.exit(1)
+    if not os.path.exists(REFERENCE_AUDIO):
+        print(f"ERROR: Audio de referință nu există la {REFERENCE_AUDIO}")
+        print(f"Copiază fișierul WAV în: {os.path.dirname(REFERENCE_AUDIO)}")
+        sys.exit(1)
+
+    # GPU check
+    if torch.cuda.is_available():
+        gpu_name = torch.cuda.get_device_name(0)
+        vram = torch.cuda.get_device_properties(0).total_memory / 1024**3
+        print(f"GPU: {gpu_name} ({vram:.1f} GB VRAM)")
+    else:
+        print("WARN: GPU nu a fost detectat! Generarea va fi foarte lentă.")
+
+    # Patch tokenizer
+    print("\nAplicare patch tokenizer românesc...")
+    patch_tokenizer_for_romanian()
+
+    # Patch torchaudio.load pentru a folosi soundfile (evită FFmpeg/torchcodec pe Windows)
+    import torchaudio
+    def _soundfile_load(filepath, **kwargs):
+        data, sr = sf.read(filepath, dtype='float32')
+        if data.ndim == 1:
+            data = data[np.newaxis, :]
+        else:
+            data = data.T
+        return torch.from_numpy(data), sr
+    torchaudio.load = _soundfile_load
+
+    # Încărcare model
+    print("\nÎncărcare model XTTS-v2...")
+    t_load = time.time()
+
+    from TTS.tts.configs.xtts_config import XttsConfig
+    from TTS.tts.models.xtts import Xtts
+
+    config = XttsConfig()
+    config.load_json(CONFIG_PATH)
+
+    model = Xtts.init_from_config(config)
+    model.load_checkpoint(
+        config,
+        checkpoint_path=CHECKPOINT_PATH,
+        vocab_path=VOCAB_PATH,
+        use_deepspeed=False,
+    )
+    model.cuda()
+    model.eval()
+    print(f"  Model încărcat în {time.time() - t_load:.1f}s")
+
+    # Latente vocale (cache)
+    if os.path.exists(CACHED_LATENTS):
+        print(f"\nÎncărcare latente din cache...")
+        cached = torch.load(CACHED_LATENTS, weights_only=True)
+        gpt_cond_latent = cached["gpt_cond_latent"].cuda()
+        speaker_embedding = cached["speaker_embedding"].cuda()
+        print("  Latente încărcate din cache!")
+    else:
+        print(f"\nExtragere latente din: {os.path.basename(REFERENCE_AUDIO)}")
+        gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(
+            audio_path=[REFERENCE_AUDIO],
+            gpt_cond_len=GPT_COND_LEN,
+        )
+        # Salvare cache
+        torch.save({
+            "gpt_cond_latent": gpt_cond_latent.cpu(),
+            "speaker_embedding": speaker_embedding.cpu(),
+        }, CACHED_LATENTS)
+        print(f"  Latente salvate în cache: {CACHED_LATENTS}")
+
+    # Pregătire text
+    text = TEXT.strip()
+    if not text:
+        print("ERROR: TEXT este gol!")
+        sys.exit(1)
+
+    text_clean = text.translate(CEDILLA_TO_COMMA)
+
+    # Generare
+    print(f"\nGenerare audio...")
+    print(f"  Text: {text_clean[:100]}{'...' if len(text_clean) > 100 else ''}")
+
+    t_gen = time.time()
+    with torch.no_grad():
+        output = model.inference(
+            text_clean,
+            "ro",
+            gpt_cond_latent,
+            speaker_embedding,
+            temperature=TEMPERATURE,
+            top_p=TOP_P,
+            top_k=TOP_K,
+            length_penalty=LENGTH_PENALTY,
+            repetition_penalty=REPETITION_PENALTY,
+        )
+
+    wav = output["wav"]
+    if isinstance(wav, torch.Tensor):
+        wav = wav.cpu().numpy()
+    wav = wav.squeeze()
+
+    gen_time = time.time() - t_gen
+    duration = len(wav) / 24000
+
+    # Salvare
+    from datetime import datetime
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    out_path = os.path.join(OUTPUT_DIR, f"tts_{timestamp}.wav")
+    sf.write(out_path, wav, 24000)
+
+    # Raport
+    print(f"\n{'=' * 50}")
+    print(f"  Audio generat:  {out_path}")
+    print(f"  Durată audio:   {duration:.2f}s")
+    print(f"  Timp generare:  {gen_time:.2f}s")
+    print(f"  Timp total:     {time.time() - t_start:.1f}s")
+    print(f"  RTF:            {gen_time / duration:.2f}x")
+    print(f"{'=' * 50}")
+
+
+if __name__ == "__main__":
+    main()

mel_stats.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f69422a8a8f344c4fca2f0c6b8d41d2151d6615b7321e48e6bb15ae949b119c
+size 1067

requirements.txt

@@ -0,0 +1,5 @@
+TTS==0.22.0
+torch
+torchaudio
+soundfile
+numpy