fix

app.py

@@ -1,4 +1,7 @@
+import random
+import sys
 import nltk
+
 nltk.download('punkt_tab')
 from sentence_analyzer import SentenceAnalyzer
 import re
@@ -10,29 +13,41 @@ import gradio as gr
 import numpy as np
 import soundfile as sf
 import torchaudio
-import torch
 from cached_path import cached_path
 from transformers import AutoModelForCausalLM, AutoTokenizer
-from tqdm import tqdm
+
 try:
     import spaces
+
     USING_SPACES = True
 except ImportError:
     USING_SPACES = False
 
+
 def gpu_decorator(func):
     if USING_SPACES:
         return spaces.GPU(func)
     else:
         return func
 
-# Importando a nova API F5TTS
-from f5_tts.api import F5TTS
-from f5_tts.infer.utils_infer import preprocess_ref_audio_text
 
+from f5_tts.model import DiT, UNetT
+from f5_tts.model.utils import seed_everything
+from f5_tts.infer.utils_infer import (
+    load_vocoder,
+    load_model,
+    preprocess_ref_audio_text,
+    infer_process,
+    remove_silence_for_generated_wav,
+    save_spectrogram,
+)
+
+# Carregar vocoder
+vocoder = load_vocoder()
 import os
 from huggingface_hub import hf_hub_download
 
+
 def load_f5tts():
     # Carrega o caminho do repositório e o nome do arquivo das variáveis de ambiente
     repo_id = os.getenv("MODEL_REPO_ID", "SWivid/F5-TTS/F5TTS_Base")
@@ -40,88 +55,87 @@ def load_f5tts():
     token = os.getenv("HUGGINGFACE_TOKEN")
     # Valida se o token está presente
     if not token:
-        raise ValueError("A variável de ambiente 'HUGGINGFACE_TOKEN' não foi definida.")
+        raise ValueError(
+            "A variável de ambiente 'HUGGINGFACE_TOKEN' não foi definida."
+        )
     # Faz o download do modelo do repositório privado
-    ckpt_path = hf_hub_download(repo_id=repo_id, filename=filename, use_auth_token=token)
-
-    # Define as configurações do modelo (ajuste se necessário)
-    F5TTS_model_cfg = dict(dim=1024, depth=22, heads=16, ff_mult=2, text_dim=512, conv_layers=4)
+    ckpt_path = hf_hub_download(
+        repo_id=repo_id, filename=filename, use_auth_token=token
+    )
 
-    # Retorna a instância da API F5TTS
-    return F5TTS(
-        model_type="F5-TTS",  # Ajuste o nome do modelo se necessário
-        ckpt_file=ckpt_path,
-        vocab_file="/home/user/app/data/Emilia_ZH_EN_pinyin/vocab.txt",  # Caminho para o arquivo vocab.txt
-        device="cuda" if torch.cuda.is_available() else "cpu",  # Define o dispositivo
-        use_ema=True
+    F5TTS_model_cfg = dict(
+        dim=1024, depth=22, heads=16, ff_mult=2, text_dim=512, conv_layers=4
     )
+    return load_model(DiT, F5TTS_model_cfg, ckpt_path, use_ema=True)
 
-# Carregar modelo F5TTS usando a nova API
-F5TTS_ema_model = load_f5tts()
 
-# Variáveis globais para o cache
-last_checkpoint = None
-last_device = None
-last_ema = None
-tts_api = None
-training_process = None  # Adicione esta linha se necessário para o seu contexto
+# Carregar modelo F5TTS
+F5TTS_ema_model = load_f5tts()
 
-# Modificação na classe F5TTS para salvar o áudio em um arquivo temporário
-class F5TTS(F5TTS):  # Herdando da classe original F5TTS
-    def infer(
-        self,
-        ref_file,
-        ref_text,
-        gen_text,
-        show_info=print,
-        progress=tqdm,
-        target_rms=0.1,
-        cross_fade_duration=0.15,
-        sway_sampling_coef=-1,
-        cfg_strength=2,
-        nfe_step=32,
-        speed=1.0,
-        fix_duration=None,
-        remove_silence=False,
-        file_wave=None,
-        file_spect=None,
-        seed=-1,
-    ):
-        if seed == -1:
-            seed = random.randint(0, sys.maxsize)
-        seed_everything(seed)
-        self.seed = seed
-        wav, sr, spect = infer_process(  # Chamando infer_process
-            ref_file,
-            ref_text,
-            gen_text,
-            self.ema_model,
-            show_info=show_info,
-            progress=progress,
-            target_rms=target_rms,
-            cross_fade_duration=cross_fade_duration,
-            nfe_step=nfe_step,
-            cfg_strength=cfg_strength,
-            sway_sampling_coef=sway_sampling_coef,
-            speed=speed,
-            fix_duration=fix_duration,
-            device=self.device,
-        )
-        if file_wave is not None:
-            self.export_wav(wav, file_wave, remove_silence)
-        if file_spect is not None:
-            self.export_spectrogram(spect, file_spect)
+@gpu_decorator
+def infer(
+    ref_audio_orig,
+    ref_text,
+    gen_text,
+    remove_silence,
+    cross_fade_duration=0.15,
+    speed=1,
+    nfe=32,
+    show_info=gr.Info,
+    seed=-1,
+):
+    if seed == -1:
+        seed = random.randint(0, sys.maxsize)
+    seed_everything(seed)
 
-        # Salvar o áudio em um arquivo temporário
+    print(f"Usando seed: {seed}")
+    ref_audio, ref_text = preprocess_ref_audio_text(
+        ref_audio_orig, ref_text, show_info=show_info
+    )
+    ema_model = F5TTS_ema_model
+    final_wave, final_sample_rate, combined_spectrogram = infer_process(
+        ref_audio,
+        ref_text.lower().strip(),
+        gen_text.lower().strip(),
+        ema_model,
+        vocoder,
+        cross_fade_duration=cross_fade_duration,
+        nfe_step=nfe,
+        speed=speed,
+        show_info=show_info,
+        progress=gr.Progress(),
+    )
+    # Remover silêncios
+    if remove_silence:
         with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as f:
-            sf.write(f.name, wav, sr)
-            audio_file = f.name  # Atribuir o caminho do arquivo temporário à variável audio_file
-
-        # Retornar o caminho do arquivo temporário
-        return audio_file, self.device, str(self.seed)
+            sf.write(f.name, final_wave, final_sample_rate)
+            remove_silence_for_generated_wav(f.name)
+            final_wave, _ = torchaudio.load(f.name)
+        final_wave = final_wave.squeeze().cpu().numpy()
+    # Salvar espectrograma
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_spectrogram:
+        spectrogram_path = tmp_spectrogram.name
+        save_spectrogram(combined_spectrogram, spectrogram_path)
+    return (final_sample_rate, final_wave), spectrogram_path, ref_text, seed
 
 
-with gr.Blocks() as app: 
+# Estilos CSS
+custom_css = """
+#sentences-container {
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    padding: 10px;
+    margin-bottom: 10px;
+}
+.sentence-box {
+    border: 1px solid #eee;
+    padding: 5px;
+    margin-bottom: 5px;
+    border-radius: 4px;
+    background-color: #f9f9f9;
+}
+"""
+with gr.Blocks(css=custom_css) as app:
     with gr.Tabs():
         with gr.Tab("TTS Básico"):
             gr.Markdown("# TTS Básico com F5-TTS")
@@ -129,8 +143,8 @@ with gr.Blocks() as app:
             # Entradas básicas
             ref_audio_input = gr.Audio(label="Áudio de Referência", type="filepath")
             gen_text_input = gr.Textbox(label="Texto para Gerar", lines=10)
+            seed_input = gr.Number(label="Seed (opcional)", value=-1)
             generate_btn = gr.Button("Sintetizar", variant="primary")
-
             # Configurações avançadas
             gr.Markdown("### Configurações Avançadas")
             with gr.Accordion("Expandir Configurações Avançadas", open=False):
@@ -152,6 +166,7 @@ with gr.Blocks() as app:
                     step=0.1,
                     info="Ajuste a velocidade do áudio.",
                 )
+
                 cross_fade_duration_slider = gr.Slider(
                     label="Duração do Cross-fade (s)",
                     minimum=0.0,
@@ -176,7 +191,6 @@ with gr.Blocks() as app:
                     step=1,
                     info="Ajuste NFE Step.",
                 )
-                seed_input = gr.Number(label="Seed", value=-1, minimum=-1)  # Seed na seção avançada
 
             analyzer = SentenceAnalyzer()
 
@@ -190,11 +204,8 @@ with gr.Blocks() as app:
                 speed_slider,
                 nfe_slider,
                 chunk_size_slider,
-                seed_input,  # Passando o seed para process_chunks
+                seed_input,
             ):
-                # Acessando a instância F5TTS_ema_model diretamente
-                f5tts_model = F5TTS_ema_model 
-
                 # Dividir o texto em sentenças
                 sentences = analyzer.split_into_sentences(gen_text_input)
 
@@ -207,37 +218,39 @@ with gr.Blocks() as app:
                 # Processar cada chunk
                 audio_segments = []
                 for chunk in chunks:
-                    # Usando a função infer correta aqui
-                    audio_file, _, _ = f5tts_model.infer(  # Usando f5tts_model.infer
-                        ref_file=ref_audio_input,
-                        ref_text=ref_text_input,
-                        gen_text=chunk,
-                        nfe_step=nfe_slider,
-                        speed=speed_slider,
+                    audio_out, spectrogram_path, ref_text_out, seed_used = infer(
+                        ref_audio_input,
+                        ref_text_input,  # Utiliza o Texto de Referência como está
+                        chunk,  # Processa o chunk atual
+                        remove_silence,
+                        cross_fade_duration_slider,
+                        speed_slider,
+                        nfe_slider,
                         seed=seed_input,
-                        remove_silence=remove_silence,
                     )
-                    audio_data, _ = torchaudio.load(audio_file)
-                    audio_segments.append(audio_data.squeeze().cpu().numpy())
+                    sr, audio_data = audio_out
+                    audio_segments.append(audio_data)
 
                 # Concatenar os segmentos de áudio gerados
                 if audio_segments:
                     final_audio_data = np.concatenate(audio_segments)
                     return (
-                        (24000, final_audio_data),  # Áudio final - assumindo taxa de amostragem de 24000
-                        None,  # Espectrograma - não estamos gerando um espectrograma aqui
-                        gr.update(value=ref_text_input),  # Nenhuma mudança no Texto de Referência
-                        f5tts_model.seed  # Retornando o seed da instância F5TTS_ema_model
+                        (sr, final_audio_data),  # Áudio final
+                        spectrogram_path,  # Espectrograma
+                        gr.update(
+                            value=ref_text_out
+                        ),  # Nenhuma mudança no Texto de Referência
+                        gr.update(value=seed_used),
                     )
                 else:
                     gr.Warning("Nenhum áudio gerado.")
-                    return None, None, gr.update(), None  # Retornando None para o seed
+                    return None, None, gr.update(), gr.update()
 
             # Saídas
             gr.Markdown("### Resultados")
             audio_output = gr.Audio(label="Áudio Sintetizado")
-            seed_output = gr.Text(label="Seed usada:")  # Saída do Seed
-
+            spectrogram_output = gr.Image(label="Espectrograma")
+            seed_output = gr.Number(label="Seed Usada")
             # Associação do botão `generate_btn` à função `process_chunks`
             generate_btn.click(
                 process_chunks,
@@ -250,31 +263,35 @@ with gr.Blocks() as app:
                     speed_slider,
                     nfe_slider,
                     chunk_size_slider,
-                    seed_input,  
-                ],  
+                    seed_input,
+                ],
                 outputs=[
                     audio_output,
-                    ref_text_input,
+                    spectrogram_output,
+                    ref_text_input,  # Atualiza o texto de referência, se necessário
                     seed_output,
                 ],
             )
-    
-# Código para iniciar a aplicação Gradio
-    @click.command()
-    @click.option("--port", "-p", default=None, type=int, help="Port to run the app on")
-    @click.option("--host", "-H", default=None, help="Host to run the app on")
-    @click.option(
-        "--share",
-        "-s",
-        default=False,
-        is_flag=True,
-        help="Share the app via Gradio share link",
+
+
+@click.command()
+@click.option("--port", "-p", default=None, type=int, help="Port to run the app on")
+@click.option("--host", "-H", default=None, help="Host to run the app on")
+@click.option(
+    "--share",
+    "-s",
+    default=False,
+    is_flag=True,
+    help="Share the app via Gradio share link",
+)
+@click.option("--api", "-a", default=True, is_flag=True, help="Allow API access")
+def main(port, host, share, api):
+    global app
+    print("Starting app...")
+    app.queue(api_open=api).launch(
+        server_name=host, server_port=port, share=share, show_api=api
     )
-    @click.option("--api", "-a", default=True, is_flag=True, help="Allow API access")
-    def main(port, host, share, api):
-        global app
-        print("Starting app...")
-        app.queue(api_open=api).launch(server_name=host, server_port=port, share=share, show_api=api)
+
 
 if __name__ == "__main__":
     if not USING_SPACES:

logs/sentence_analyzer_2024-12-02.log

@@ -76,3 +76,15 @@
 2024-12-02 20:47:48,875 - SentenceAnalyzer - DEBUG - Normalized whitespace
 2024-12-02 20:47:48,898 - SentenceAnalyzer - DEBUG - Split text into 1 sentences using NLTK
 2024-12-02 20:47:48,898 - SentenceAnalyzer - INFO - Split text into 1 sentences after cleanup
+2024-12-02 20:55:23,847 - SentenceAnalyzer - DEBUG - Logger set up successfully
+2024-12-02 20:55:23,847 - SentenceAnalyzer - INFO - SentenceAnalyzer initialized successfully
+2024-12-02 20:55:48,213 - SentenceAnalyzer - DEBUG - Starting sentence splitting
+2024-12-02 20:55:48,213 - SentenceAnalyzer - DEBUG - Normalized text using NFC
+2024-12-02 20:55:48,214 - SentenceAnalyzer - DEBUG - Removed page numbers and chapter titles
+2024-12-02 20:55:48,214 - SentenceAnalyzer - DEBUG - Replaced hyphenated line breaks
+2024-12-02 20:55:48,214 - SentenceAnalyzer - DEBUG - Replaced multiple newlines with a space
+2024-12-02 20:55:48,214 - SentenceAnalyzer - DEBUG - Normalized whitespace
+2024-12-02 20:55:48,235 - SentenceAnalyzer - DEBUG - Split text into 1 sentences using NLTK
+2024-12-02 20:55:48,235 - SentenceAnalyzer - INFO - Split text into 1 sentences after cleanup
+2024-12-02 21:02:37,760 - SentenceAnalyzer - DEBUG - Logger set up successfully
+2024-12-02 21:02:37,760 - SentenceAnalyzer - INFO - SentenceAnalyzer initialized successfully

src/f5_tts/api.py

@@ -1,5 +1,4 @@
-import random
-import sys
+
 from importlib.resources import files
 
 import soundfile as sf