Update chat_ai.py

chat_ai.py

@@ -1,28 +1,12 @@
-# text_to_speech_ai.py
-
 import re
 import tempfile
-import os
 
-import torch
-import click
 import gradio as gr
+import numpy as np
 import soundfile as sf
 import torchaudio
-from cached_path import cached_path
-from transformers import WhisperProcessor, WhisperForConditionalGeneration
-
-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
+from num2words import num2words
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
 from f5_tts.model import DiT
 from f5_tts.infer.utils_infer import (
@@ -34,267 +18,129 @@ from f5_tts.infer.utils_infer import (
     save_spectrogram,
 )
 
-# Definir el dispositivo global (se usa solo dentro de las funciones)
-def get_device():
-    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-@gpu_decorator
-def load_models():
-    """Carga y devuelve los modelos necesarios."""
-    device = get_device()
-    
-    # Cargar el vocoder y moverlo al dispositivo
-    vocoder = load_vocoder().to(device)
-    
-    # Configuración y carga del modelo F5-TTS
-    F5TTS_model_cfg = dict(dim=1024, depth=22, heads=16, ff_mult=2, text_dim=512, conv_layers=4)
-    F5TTS_ema_model = load_model(
-        DiT, F5TTS_model_cfg, str(cached_path("hf://jpgallegoar/F5-Spanish/model_1200000.safetensors"))
-    ).to(device)
-    
-    # Cargar el modelo Whisper para transcripción
-    whisper_processor = WhisperProcessor.from_pretrained("openai/whisper-base")
-    whisper_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-base").to(device)
-    whisper_model.eval()
-    
-    return vocoder, F5TTS_ema_model, whisper_processor, whisper_model, device
-
-# Cargar modelos una sola vez y almacenarlos en variables globales dentro de la función
-def get_models():
-    if not hasattr(get_models, "vocoder"):
-        get_models.vocoder, get_models.F5TTS_ema_model, get_models.whisper_processor, get_models.whisper_model, get_models.device = load_models()
-    return get_models.vocoder, get_models.F5TTS_ema_model, get_models.whisper_processor, get_models.whisper_model, get_models.device
-
-@gpu_decorator
-def infer(
-    ref_audio_orig, ref_text, gen_text, model, remove_silence, cross_fade_duration=0.15, speed=1
-):
-    """Genera el audio sintetizado a partir del texto utilizando la voz de referencia."""
-    try:
-        with torch.no_grad():
-            vocoder, F5TTS_ema_model, _, _, device = get_models()
-            
-            # Preprocesar el audio de referencia y el texto de referencia
-            ref_audio, ref_text = preprocess_ref_audio_text(ref_audio_orig, ref_text)
-            
-            # Mover solo ref_audio al dispositivo
-            ref_audio = ref_audio.to(device)
-            
-            # Asegurar que el texto a generar esté correctamente formateado
-            if not gen_text.startswith(" "):
-                gen_text = " " + gen_text
-            if not gen_text.endswith(". "):
-                gen_text += ". "
-
-            # El texto ingresado por el usuario se utiliza directamente sin modificaciones
-            input_text = gen_text
-
-            print(f"Texto para generar audio: {input_text}")  # Debug: Verificar el texto
-
-            # Procesar la inferencia para generar el audio
-            final_wave, final_sample_rate, combined_spectrogram = infer_process(
-                ref_audio,
-                ref_text,
-                input_text,
-                F5TTS_ema_model,
-                vocoder,
-                cross_fade_duration=cross_fade_duration,
-                speed=speed,
-                progress=gr.Progress(),
-            )
-
-            # Eliminar silencios si está activado
-            if remove_silence:
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as f:
-                    sf.write(f.name, final_wave.cpu().numpy(), final_sample_rate)
-                    remove_silence_for_generated_wav(f.name)
-                    final_wave, _ = torchaudio.load(f.name)
-                final_wave = final_wave.squeeze().cpu().numpy()
-
-            # Guardar el espectrograma (opcional)
-            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
-    except Exception as e:
-        # Log del error para depuración
-        print(f"Error en infer: {e}")
-        return None, None
-
-@gpu_decorator
-def transcribe_audio(audio_path):
-    """Transcribe el audio de referencia usando el modelo Whisper en español."""
-    try:
-        vocoder, F5TTS_ema_model, whisper_processor, whisper_model, device = get_models()
-        
-        if not os.path.exists(audio_path):
-            raise FileNotFoundError(f"Archivo de audio no encontrado: {audio_path}")
-
-        # Cargar el audio
-        audio, rate = torchaudio.load(audio_path)
-
-        # Resample si es necesario
-        if rate != 16000:
-            resampler = torchaudio.transforms.Resample(orig_freq=rate, new_freq=16000)
-            audio = resampler(audio)
-
-        # Asegurarse de que el audio tenga una sola dimensión
-        if audio.ndim > 1:
-            audio = torch.mean(audio, dim=0)
-
-        # Procesar el audio con el procesador de Whisper
-        inputs = whisper_processor(audio.cpu().numpy(), sampling_rate=16000, return_tensors="pt")
+# Implementación de cached_path (si es necesario, dependiendo de tu configuración)
+from cached_path import cached_path
 
-        inputs = {k: v.to(device) for k, v in inputs.items()}
+# Decorador GPU para Spaces o local
+def gpu_decorator(func):
+    return func  # Simplemente devuelve la función, ajusta según tu entorno si usas HF中国镜像站 Spaces
 
-        # Forzar el idioma a español (usando el nombre en inglés)
-        forced_decoder_ids = whisper_processor.get_decoder_prompt_ids(language="spanish", task="transcribe")
+# Cargar el vocoder
+vocoder = load_vocoder()
 
-        # Generar la transcripción
-        with torch.no_grad():
-            predicted_ids = whisper_model.generate(
-                inputs["input_features"],
-                forced_decoder_ids=forced_decoder_ids
-            )
-        transcription = whisper_processor.decode(predicted_ids[0], skip_special_tokens=True)
+# Configuración y carga del modelo F5TTS
+F5TTS_model_cfg = dict(dim=1024, depth=22, heads=16, ff_mult=2, text_dim=512, conv_layers=4)
+F5TTS_ema_model = load_model(
+    DiT, F5TTS_model_cfg, str(cached_path("hf://jpgallegoar/F5-Spanish/model_1200000.safetensors"))
+)
 
-        print(f"Transcripción: {transcription}")  # Debug: Verificar la transcripción
+def traducir_numero_a_texto(texto):
+    texto_separado = re.sub(r'([A-Za-z])(\d)', r'\1 \2', texto)
+    texto_separado = re.sub(r'(\d)([A-Za-z])', r'\1 \2', texto_separado)
+    
+    def reemplazar_numero(match):
+        numero = match.group()
+        return num2words(int(numero), lang='es')
 
-        return transcription
-    except Exception as e:
-        print(f"Error en transcribe_audio: {e}")
-        return None
+    texto_traducido = re.sub(r'\b\d+\b', reemplazar_numero, texto_separado)
 
-def transcribe_and_update(audio_path):
-    """Transcribe el audio de referencia y devuelve el texto transcrito."""
-    transcription = transcribe_audio(audio_path)
-    if transcription is None:
-        return "Error al transcribir el audio de referencia."
-    return transcription
+    return texto_traducido
 
 @gpu_decorator
-def generate_audio(text, ref_audio, ref_text, model_choice, remove_silence):
-    """Genera el audio a partir del texto ingresado utilizando la voz de referencia."""
-    try:
-        if not text.strip():
-            return None, "Por favor, ingresa un texto para generar el audio."
-
-        # Debug: Verificar el texto ingresado
-        print(f"Texto ingresado para TTS: {text}")
-
-        # Si se proporciona audio de referencia y no se proporciona texto de referencia, transcribir el audio
-        if ref_audio and not ref_text.strip():
-            ref_text = transcribe_audio(ref_audio)
-            if ref_text is None:
-                return None, "Error al transcribir el audio de referencia."
-            print(f"Texto de referencia transcrito: {ref_text}")  # Debug
-
-        # Usar directamente el texto ingresado para generar el audio
-        input_text = text
-
-        print(f"Texto final para inferencia: {input_text}")  # Debug
-
-        # Generar el audio utilizando la función infer
-        audio_result, spectrogram_path = infer(
-            ref_audio_orig=ref_audio,
-            ref_text=ref_text,
-            gen_text=input_text,
-            model=model_choice,
-            remove_silence=remove_silence,
-            cross_fade_duration=0.15,
-            speed=1.0,
-        )
-
-        if audio_result is None:
-            return None, "Error al generar el audio."
-
-        sample_rate, waveform = audio_result
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-            sf.write(f.name, waveform, sample_rate)
-            audio_path = f.name
-
-        return audio_path, "Audio generado exitosamente."
-    except Exception as e:
-        print(f"Error en generate_audio: {e}")
-        return None, "Ocurrió un error al generar el audio."
-
-@click.command()
-@click.option("--port", "-p", default=None, type=int, help="Puerto para ejecutar la aplicación")
-@click.option("--host", "-H", default=None, help="Host para ejecutar la aplicación")
-@click.option(
-    "--share",
-    "-s",
-    default=False,
-    is_flag=True,
-    help="Compartir la aplicación a través de un enlace compartido de Gradio",
-)
-@click.option("--api", "-a", default=True, is_flag=True, help="Permitir acceso a la API")
-def main(port, host, share, api):
-    """Función principal para lanzar la aplicación Gradio de Texto a Voz."""
-    print("Iniciando la aplicación de Texto a Voz con Clonación de Voz...")
-    app.queue(api_open=api).launch(
-        server_name=host,
-        server_port=port,
-        share=share,
-        show_api=api
+def infer(
+    ref_audio_orig, ref_text, gen_text, model, remove_silence, cross_fade_duration=0.15, speed=1, show_info=gr.Info
+):
+    ref_audio, ref_text = preprocess_ref_audio_text(ref_audio_orig, ref_text, show_info=show_info)
+
+    ema_model = F5TTS_ema_model
+
+    if not gen_text.startswith(" "):
+        gen_text = " " + gen_text
+    if not gen_text.endswith(". "):
+        gen_text += ". "
+
+    gen_text = gen_text.lower()
+    gen_text = traducir_numero_a_texto(gen_text)
+
+    final_wave, final_sample_rate, combined_spectrogram = infer_process(
+        ref_audio,
+        ref_text,
+        gen_text,
+        ema_model,
+        vocoder,
+        cross_fade_duration=cross_fade_duration,
+        speed=speed,
+        show_info=show_info,
+        progress=gr.Progress(),
     )
 
-if __name__ == "__main__":
-    with gr.Blocks() as app:
-        gr.Markdown(
-            """
-# Conversor de Texto a Voz con Clonación de Voz
-Sube un audio de referencia para clonar la voz y luego escribe el texto que deseas convertir a voz.
-            """
+    # Eliminar silencios
+    if remove_silence:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as f:
+            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()
+
+    # Guardar el 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
+
+# Interfaz Gradio
+with gr.Blocks() as app_tts:
+    gr.Markdown("# TTS por Lotes")
+    ref_audio_input = gr.Audio(label="Audio de Referencia", type="filepath")
+    gen_text_input = gr.Textbox(label="Texto para Generar", lines=10)
+    model_choice = gr.Radio(choices=["F5-TTS"], label="Seleccionar Modelo TTS", value="F5-TTS")
+    generate_btn = gr.Button("Sintetizar", variant="primary")
+    with gr.Accordion("Configuraciones Avanzadas", open=False):
+        ref_text_input = gr.Textbox(
+            label="Texto de Referencia",
+            info="Deja en blanco para transcribir automáticamente el audio de referencia. Si ingresas texto, sobrescribirá la transcripción automática.",
+            lines=2,
         )
-
-        with gr.Row():
-            with gr.Column():
-                ref_audio = gr.Audio(label="Audio de Referencia (Clonación de Voz)", type="filepath")
-                ref_text = gr.Textbox(
-                    label="Texto de Referencia (Opcional)",
-                    info="Opcional: Deja en blanco para transcribir automáticamente el audio de referencia",
-                    lines=2,
-                )
-            with gr.Column():
-                model_choice = gr.Radio(
-                    choices=["F5-TTS"],
-                    label="Modelo TTS",
-                    value="F5-TTS",
-                )
-                remove_silence = gr.Checkbox(
-                    label="Eliminar Silencios",
-                    value=True,
-                )
-
-        with gr.Row():
-            text_input = gr.Textbox(
-                label="Escribe tu texto",
-                placeholder="Ingresa el texto que deseas convertir a voz...",
-                lines=3,
-            )
-            generate_btn = gr.Button("Generar Audio")
-
-        with gr.Row():
-            audio_output = gr.Audio(label="Audio Generado", autoplay=True)
-
-        status = gr.Textbox(label="Estado", interactive=False)
-
-        # Conectar la función de transcripción al evento de cambio del audio de referencia
-        ref_audio.change(
-            fn=transcribe_and_update,
-            inputs=ref_audio,
-            outputs=ref_text,
+        remove_silence = gr.Checkbox(
+            label="Eliminar Silencios",
+            info="El modelo tiende a producir silencios, especialmente en audios más largos. Podemos eliminar manualmente los silencios si es necesario. Ten en cuenta que esta es una característica experimental y puede producir resultados extraños. Esto también aumentará el tiempo de generación.",
+            value=False,
         )
-
-        generate_btn.click(
-            generate_audio,
-            inputs=[text_input, ref_audio, ref_text, model_choice, remove_silence],
-            outputs=[audio_output, status],
+        speed_slider = gr.Slider(
+            label="Velocidad",
+            minimum=0.3,
+            maximum=2.0,
+            value=1.0,
+            step=0.1,
+            info="Ajusta la velocidad del audio.",
+        )
+        cross_fade_duration_slider = gr.Slider(
+            label="Duración del Cross-Fade (s)",
+            minimum=0.0,
+            maximum=1.0,
+            value=0.15,
+            step=0.01,
+            info="Establece la duración del cross-fade entre clips de audio.",
         )
 
-    if not USING_SPACES:
-        main()
-    else:
-        app.queue().launch(share=True)  # Asegura que 'share=True' si se usa Spaces
+    audio_output = gr.Audio(label="Audio Sintetizado")
+    spectrogram_output = gr.Image(label="Espectrograma")
+
+    generate_btn.click(
+        infer,
+        inputs=[
+            ref_audio_input,
+            ref_text_input,
+            gen_text_input,
+            model_choice,
+            remove_silence,
+            cross_fade_duration_slider,
+            speed_slider,
+        ],
+        outputs=[audio_output, spectrogram_output],
+    )
+
+# Ejecutar la aplicación
+if __name__ == "__main__":
+    app_tts.launch()