update app

Dockerfile

@@ -11,11 +11,13 @@ RUN cd espeak-ng && \
  make install
 
 COPY requirements.txt .
-COPY app.py .
 COPY models .
 
 RUN pip install -r requirements.txt
 
+COPY engine.py .
+COPY app.py .
+
 RUN mkdir -p cache && chmod 777 cache
 
 ENV NUMBA_CACHE_DIR=./cache

app.py

@@ -7,42 +7,48 @@ import os
 import json
 from TTS.utils.manage import ModelManager
 from TTS.utils.synthesizer import Synthesizer
-
+from .engine import Piper
 
 MAX_TXT_LEN = 100
 
 SPEAKERS = ['f_cen_05', 'f_cen_81', 'f_occ_31', 'f_occ_de', 'f_sep_31', 'm_cen_08', 'm_occ_44', 'm_val_89']
 
+def carrega_bsc():
+    model_path = os.getcwd() + "/models/bsc/best_model.pth"
+    config_path = os.getcwd() + "/models/bsc/config.json"
+    speakers_file_path = os.getcwd() + "/models/bsc/speakers.pth"
+    vocoder_path = None
+    vocoder_config_path = None
+
+    synthesizer = Synthesizer(
+        model_path, config_path, speakers_file_path, No$
+    )
+
+    return synthesizer
+
+model_bsc = carrega_bsc()
+SPEAKERS = model_bsc.speakers
+
+
 def tts(text, speaker_idx):
     if len(text) > MAX_TXT_LEN:
         text = text[:MAX_TXT_LEN]
         print(f"Input text was cutoff since it went over the {MAX_TXT_LEN} character limit.")
     print(text)
 
-    model_path = os.getcwd() + "/best_model.pth"
-    config_path = os.getcwd() + "/config.json"
-    speakers_file_path = os.getcwd() + "/speakers.pth"
     speakers_maping_path = os.getcwd() + "/speaker_map.json"
-    vocoder_path = None
-    vocoder_config_path = None
-
-    synthesizer = Synthesizer(
-        model_path, config_path, speakers_file_path, None, vocoder_path, vocoder_config_path,
-    )
 
     # Map speaker aliases to speaker ids
     with open(speakers_maping_path, 'r') as fp:
         maping = json.load(fp)
 
-    speaker_idx = maping[speaker_idx]
+    #speaker_idx = maping[speaker_idx]
 
     # synthesize
-    if synthesizer is None:
-        raise NameError("model not found")
-    wavs = synthesizer.tts(text, speaker_idx)
+    wavs = model_bsc.tts(text, speaker_idx)
     # return output
     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as fp:
-        synthesizer.save_wav(wavs, fp)
+        model_bsc.save_wav(wavs, fp)
         return fp.name
 
 
@@ -66,11 +72,9 @@ iface = gr.Interface(
     ],
     outputs=gr.outputs.Audio(label="Output",type="filepath"),
     title="🗣️ TTS Català Multi Parlant - VITS 🗣️",
-    theme="grass",
     description=description,
     article=article,
     allow_flagging="never",
-    flagging_options=['error', 'bad-quality', 'wrong-pronounciation'],
     layout="vertical",
     live=False
 )

engine.py

@@ -0,0 +1,144 @@
+import io
+import json
+import os
+import wave
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Mapping, Optional, Sequence, Union
+
+import numpy as np
+import onnxruntime
+from espeak_phonemizer import Phonemizer
+
+_BOS = "^"
+_EOS = "$"
+_PAD = "_"
+
+
+@dataclass
+class PiperConfig:
+    num_symbols: int
+    num_speakers: int
+    sample_rate: int
+    espeak_voice: str
+    length_scale: float
+    noise_scale: float
+    noise_w: float
+    phoneme_id_map: Mapping[str, Sequence[int]]
+
+
+class Piper:
+    def __init__(
+        self,
+        model_path: Union[str, Path],
+        config_path: Optional[Union[str, Path]] = None,
+        use_cuda: bool = False,
+    ):
+        if config_path is None:
+            config_path = f"{model_path}.json"
+
+        self.config = load_config(config_path)
+        self.phonemizer = Phonemizer(self.config.espeak_voice)
+        self.onnx_options = onnxruntime.SessionOptions()
+        self.onnx_options.intra_op_num_threads = os.cpu_count() - 1
+        self.model = onnxruntime.InferenceSession(
+            str(model_path),
+            sess_options=self.onnx_options,
+            providers=["CPUExecutionProvider"]
+            if not use_cuda
+            else ["CUDAExecutionProvider"],
+        )
+
+    def synthesize(
+        self,
+        text: str,
+        speaker_id: Optional[int] = None,
+        length_scale: Optional[float] = None,
+        noise_scale: Optional[float] = None,
+        noise_w: Optional[float] = None,
+    ) -> bytes:
+        """Synthesize WAV audio from text."""
+        if length_scale is None:
+            length_scale = self.config.length_scale
+
+        if noise_scale is None:
+            noise_scale = self.config.noise_scale
+
+        if noise_w is None:
+            noise_w = self.config.noise_w
+
+        phonemes_str = self.phonemizer.phonemize(text)
+        phonemes = [_BOS] + list(phonemes_str)
+        phoneme_ids: List[int] = []
+
+        for phoneme in phonemes:
+            phoneme_ids.extend(self.config.phoneme_id_map[phoneme])
+            phoneme_ids.extend(self.config.phoneme_id_map[_PAD])
+
+        phoneme_ids.extend(self.config.phoneme_id_map[_EOS])
+
+        phoneme_ids_array = np.expand_dims(np.array(phoneme_ids, dtype=np.int64), 0)
+        phoneme_ids_lengths = np.array([phoneme_ids_array.shape[1]], dtype=np.int64)
+        scales = np.array(
+            [noise_scale, length_scale, noise_w],
+            dtype=np.float32,
+        )
+
+        if (self.config.num_speakers > 1) and (speaker_id is not None):
+            # Default speaker
+            speaker_id = 0
+
+        sid = None
+
+        if speaker_id is not None:
+            sid = np.array([speaker_id], dtype=np.int64)
+
+        # Synthesize through Onnx
+        audio = self.model.run(
+            None,
+            {
+                "input": phoneme_ids_array,
+                "input_lengths": phoneme_ids_lengths,
+                "scales": scales,
+                "sid": sid,
+            },
+        )[0].squeeze((0, 1))
+        audio = audio_float_to_int16(audio.squeeze())
+
+        # Convert to WAV
+        with io.BytesIO() as wav_io:
+            wav_file: wave.Wave_write = wave.open(wav_io, "wb")
+            with wav_file:
+                wav_file.setframerate(self.config.sample_rate)
+                wav_file.setsampwidth(2)
+                wav_file.setnchannels(1)
+                wav_file.writeframes(audio.tobytes())
+
+            return wav_io.getvalue()
+
+
+def load_config(config_path: Union[str, Path]) -> PiperConfig:
+    with open(config_path, "r", encoding="utf-8") as config_file:
+        config_dict = json.load(config_file)
+        inference = config_dict.get("inference", {})
+
+        return PiperConfig(
+            num_symbols=config_dict["num_symbols"],
+            num_speakers=config_dict["num_speakers"],
+            sample_rate=config_dict["audio"]["sample_rate"],
+            espeak_voice=config_dict["espeak"]["voice"],
+            noise_scale=inference.get("noise_scale", 0.667),
+            length_scale=inference.get("length_scale", 1.0),
+            noise_w=inference.get("noise_w", 0.8),
+            phoneme_id_map=config_dict["phoneme_id_map"],
+        )
+
+
+def audio_float_to_int16(
+    audio: np.ndarray, max_wav_value: float = 32767.0
+) -> np.ndarray:
+    """Normalize audio and convert to int16 range"""
+    audio_norm = audio * (max_wav_value / max(0.01, np.max(np.abs(audio))))
+    audio_norm = np.clip(audio_norm, -max_wav_value, max_wav_value)
+    audio_norm = audio_norm.astype("int16")
+    return audio_norm