> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/styletss2.md). # StyleTTS2 Ejecuta texto a voz de nivel humano con StyleTTS2 mediante difusión de estilo en GPUs de Clore.ai StyleTTS2 logra puntuaciones de naturalidad valoradas por humanos por encima de las grabaciones de referencia en los benchmarks LJSpeech y LibriTTS (MOS 4.55 frente a 4.23 de la referencia). Utiliza **difusión de estilo** y **entrenamiento adversarial** para modelar los estilos de habla como una distribución de variables latentes, lo que permite una síntesis expresiva y adaptación de hablante zero-shot a partir de un breve clip de referencia. A diferencia de los sistemas TTS tradicionales, StyleTTS2 puede generalizar a hablantes no vistos con un breve clip de audio de referencia, produciendo un habla que rivaliza con la de actores de voz profesionales. Se ha comprobado que supera las puntuaciones de naturalidad valoradas por humanos en varios conjuntos de datos, algo inédito para el TTS de código abierto. Características principales: * **Naturalidad a nivel humano** — supera las puntuaciones MOS humanas en LJSpeech * **Adaptación de hablante zero-shot** — clona cualquier voz a partir de una breve muestra de audio * **Difusión de estilo** — prosodia y estilo de habla expresivos y variados * **Compatibilidad con múltiples hablantes** — entrenado con LibriTTS (más de 2.300 hablantes) * **Inferencia ligera** — se ejecuta eficientemente en GPU de consumo {% hint style="success" %} Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## Requisitos del servidor | Parámetro | Mínimo | Recomendado | | --------- | ---------------------- | ----------------------- | | GPU | NVIDIA RTX 3070 (8 GB) | NVIDIA RTX 4090 (24 GB) | | VRAM | 6 GB | 12–24 GB | | RAM | 16 GB | 32 GB | | CPU | 4 núcleos | 8+ núcleos | | Disco | 15 GB | 30 GB | | SO | Ubuntu 20.04+ | Ubuntu 22.04 | | CUDA | 11.7+ | 12.1+ | | Python | 3.8+ | 3.10 | | Puertos | 22, 7860 | 22, 7860 | {% hint style="info" %} StyleTTS2 es relativamente ligero: una RTX 3070 o 3080 maneja la inferencia en tiempo real con comodidad. Para procesamiento por lotes o para atender usuarios concurrentes, usa una 4090 o una A100. {% endhint %} *** ## Despliegue rápido en CLORE.AI StyleTTS2 requiere una compilación personalizada de Docker, ya que no existe una imagen preconstruida oficial. La configuración tarda \~10 minutos. ### 1. Encuentra un servidor adecuado Ve a [Marketplace de CLORE.AI](https://clore.ai/marketplace) y filtra por: * **VRAM**: ≥ 6 GB * **GPU**: RTX 3070, 3080, 3090, 4080, 4090, A100 * **Disco**: ≥ 20 GB ### 2. Configura tu despliegue **Imagen Docker (base):** ``` nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04 ``` **Mapeos de puertos:** ``` 22 → Acceso SSH 7860 → Interfaz web de Gradio ``` **Comando de inicio:** ```bash bash -c "apt-get update && apt-get install -y git python3 python3-pip ffmpeg espeak-ng && \\ git clone https://github.com/yl4579/StyleTTS2 /workspace/StyleTTS2 && \\ cd /workspace/StyleTTS2 && pip install -r requirements.txt && \\ python app.py" ``` ### 3. Accede a la interfaz ``` http://:7860 ``` *** ## Configuración paso a paso ### Paso 1: conéctate por SSH a tu servidor ```bash ssh root@ -p ``` ### Paso 2: Instala las dependencias del sistema ```bash apt-get update && apt-get install -y \\ git \\ python3 \\ python3-pip \\ python3-venv \\ ffmpeg \\ espeak-ng \\ libsndfile1 \\ build-essential \\ wget \\ curl ``` ### Paso 3: Clona el repositorio de StyleTTS2 ```bash cd /workspace git clone https://github.com/yl4579/StyleTTS2.git cd StyleTTS2 ``` ### Paso 4: Crea un entorno virtual de Python ```bash python3 -m venv venv source venv/bin/activate pip install --upgrade pip ``` ### Paso 5: Instala las dependencias ```bash pip install -r requirements.txt # Instala dependencias adicionales si es necesario pip install phonemizer gruut ``` ### Paso 6: Descarga los modelos preentrenados ```bash # Descarga el modelo LJSpeech (un solo hablante, alta calidad) mkdir -p Models/LJSpeech wget -O Models/LJSpeech/epoch_2nd_00100.pth \\ "https://huggingface.co/yl4579/StyleTTS2-LJSpeech/resolve/main/Models/LJSpeech/epoch_2nd_00100.pth" wget -O Models/LJSpeech/config.yml \\ "https://huggingface.co/yl4579/StyleTTS2-LJSpeech/resolve/main/Models/LJSpeech/config.yml" # Descarga el modelo LibriTTS (múltiples hablantes, zero-shot) mkdir -p Models/LibriTTS wget -O Models/LibriTTS/epochs_2nd_00020.pth \\ "https://huggingface.co/yl4579/StyleTTS2-LibriTTS/resolve/main/Models/LibriTTS/epochs_2nd_00020.pth" wget -O Models/LibriTTS/config.yml \\ "https://huggingface.co/yl4579/StyleTTS2-LibriTTS/resolve/main/Models/LibriTTS/config.yml" ``` ### Paso 7: Construye y ejecuta el Dockerfile ```bash # Crear Dockerfile cat > Dockerfile << 'EOF' FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04 ENV DEBIAN_FRONTEND=noninteractive RUN apt-get update && apt-get install -y \\ git python3 python3-pip python3-venv \\ ffmpeg espeak-ng libsndfile1 build-essential wget curl \\ && rm -rf /var/lib/apt/lists/* WORKDIR /workspace RUN git clone https://github.com/yl4579/StyleTTS2.git WORKDIR /workspace/StyleTTS2 RUN pip install --no-cache-dir -r requirements.txt EXPOSE 7860 CMD ["python3", "app.py", "--share"] EOF docker build -t styletts2:local . docker run -d --name styletts2 --gpus all \\ -p 7860:7860 \ -v /workspace/models:/workspace/StyleTTS2/Models \\ styletts2:local ``` ### Paso 8: Inicia la demostración de Gradio directamente ```bash source venv/bin/activate python app.py ``` Accede en `http://:7860` *** ## Ejemplos de uso ### Ejemplo 1: TTS básico mediante la API de Python ```python import torch import soundfile as sf import numpy as np from models import * from utils import * import yaml # Carga la configuración config = yaml.safe_load(open("Models/LJSpeech/config.yml")) # Inicializa el modelo model = build_model(recursive_munch(config['model_params']), "cpu") params = torch.load("Models/LJSpeech/epoch_2nd_00100.pth", map_location='cpu') model = load_F0_models(model) # Mover a la GPU device = "cuda" if torch.cuda.is_available() else "cpu" for key in model: model[key] = model[key].to(device) print(f"Modelo cargado en: {device}") print(f"VRAM utilizada: {torch.cuda.memory_allocated()/1e9:.2f} GB") ``` *** ### Ejemplo 2: Clonación de voz zero-shot ```python import torch import torchaudio import soundfile as sf from inference import StyleTTS2Inference # Inicializa el motor de inferencia tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) # Carga el audio de referencia (10-30 segundos funciona mejor) reference_audio, sr = torchaudio.load("reference_voice.wav") # Genera habla con la voz de referencia text = "Clore.ai ofrece una potente infraestructura GPU para aplicaciones de IA, incluida la síntesis de texto a voz." audio = tts.synthesize( text=text, reference_audio=reference_audio, reference_sr=sr, diffusion_steps=10, # Más alto = mejor calidad, más lento embedding_scale=1.5, # Controla la fuerza del estilo alpha=0.3, # Peso del estilo acústico beta=0.7, # Peso del estilo prosódico ) sf.write("cloned_voice_output.wav", audio, 24000) print("¡Salida de voz clonada guardada!") ``` *** ### Ejemplo 3: Control expresivo del estilo ```python from inference import StyleTTS2Inference import soundfile as sf tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) text = "Bienvenido a nuestra presentación sobre computación GPU con Clore.ai." # Experimenta con diferentes parámetros de estilo style_configs = [ {"name": "neutral", "alpha": 0.3, "beta": 0.7, "diffusion_steps": 5}, {"name": "expressive", "alpha": 0.5, "beta": 0.9, "diffusion_steps": 15}, {"name": "fast", "alpha": 0.1, "beta": 0.3, "diffusion_steps": 3}, {"name": "slow_deep", "alpha": 0.7, "beta": 0.5, "diffusion_steps": 20}, ] for cfg in style_configs: audio = tts.synthesize( text=text, diffusion_steps=cfg["diffusion_steps"], alpha=cfg["alpha"], beta=cfg["beta"], ) filename = f"style_{cfg['name']}.wav" sf.write(filename, audio, 24000) print(f"Generado: {filename}") ``` *** ### Ejemplo 4: Interfaz web de Gradio ```python import gradio as gr import soundfile as sf import numpy as np from inference import StyleTTS2Inference import tempfile tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) def synthesize(text, reference_audio, diffusion_steps, alpha, beta): if reference_audio is not None: sr, audio_data = reference_audio # Convertir al formato esperado ref_audio = audio_data.astype(np.float32) / 32768.0 else: ref_audio = None sr = None output = tts.synthesize( text=text, reference_audio=ref_audio, reference_sr=sr, diffusion_steps=int(diffusion_steps), alpha=alpha, beta=beta, ) # Guardar en archivo temporal with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f: sf.write(f.name, output, 24000) return f.name demo = gr.Interface( fn=synthesize, inputs=[ gr.Textbox(label="Texto de entrada", lines=4), gr.Audio(label="Voz de referencia (opcional)", type="numpy"), gr.Slider(1, 30, value=10, label="Pasos de difusión"), gr.Slider(0.0, 1.0, value=0.3, label="Alpha (estilo acústico)"), gr.Slider(0.0, 1.0, value=0.7, label="Beta (estilo prosódico)"), ], outputs=gr.Audio(label="Audio generado"), title="StyleTTS2 en GPU de Clore.ai", description="TTS a nivel humano con difusión de estilo" ) demo.launch(server_name="0.0.0.0", server_port=7860) ``` *** ### Ejemplo 5: Generación por lotes de audiolibros ```python import soundfile as sf import numpy as np from pathlib import Path from inference import StyleTTS2Inference tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) # Dividir el texto en párrafos book_text = """ Capítulo Uno: La revolución de la GPU La historia de la inteligencia artificial no puede separarse de la evolución de las unidades de procesamiento gráfico. Lo que comenzó como hardware especializado para renderizar píxeles se convirtió en el motor de la revolución moderna de la IA. Capítulo Dos: Computación distribuida A medida que los modelos crecieron, el entrenamiento en una sola GPU dio paso a sistemas distribuidos. Plataformas como Clore.ai surgieron para democratizar el acceso a esta capacidad computacional, haciendo que la infraestructura GPU de nivel empresarial fuera accesible para particulares y startups. """.strip() paragraphs = [p.strip() for p in book_text.split('\n\n') if p.strip()] output_dir = Path("audiobook_output") output_dir.mkdir(exist_ok=True) audio_segments = [] for i, paragraph in enumerate(paragraphs): print(f"Procesando párrafo {i+1}/{len(paragraphs)}...") audio = tts.synthesize( text=paragraph, diffusion_steps=10, alpha=0.3, beta=0.7, ) segment_path = output_dir / f"segment_{i+1:03d}.wav" sf.write(str(segment_path), audio, 24000) audio_segments.append(audio) print(f" ✓ Guardado {segment_path}") # Concatenar todos los segmentos con un breve silencio silence = np.zeros(int(24000 * 0.5)) # 0.5 segundos de silencio full_audio = [] for seg in audio_segments: full_audio.append(seg) full_audio.append(silence) combined = np.concatenate(full_audio) sf.write("audiobook_complete.wav", combined, 24000) print(f"\nAudiolibro completo: {len(combined)/24000:.1f} segundos") ``` *** ## Configuración ### Parámetros clave de config.yml ```yaml model_params: dim_in: 64 hidden_dim: 512 max_conv_dim: 512 n_layer: 3 n_mels: 80 diffusion: timesteps: 1000 beta_schedule: "squaredcos_cap_v2" training: batch_size: 16 epochs: 100 save_freq: 10 ``` ### Parámetros de inferencia | Parámetro | Rango | Valor predeterminado | Efecto | | ----------------- | ------- | -------------------- | ------------------------------------------ | | `diffusion_steps` | 1–30 | 10 | Compromiso entre calidad y velocidad | | `alpha` | 0.0–1.0 | 0.3 | Peso del estilo acústico de la referencia | | `beta` | 0.0–1.0 | 0.7 | Peso del estilo prosódico de la referencia | | `embedding_scale` | 1.0–3.0 | 1.5 | Intensidad general del estilo | | `t` | 0.6–1.0 | 0.7 | Nivel de ruido (más alto = más variación) | *** ## Consejos de rendimiento ### 1. Optimiza los pasos de difusión El valor predeterminado de 10 pasos equilibra calidad y velocidad. Para aplicaciones en tiempo real, usa 5 pasos; para la máxima calidad, usa 20–30. ```python # Tiempo real (rápido) audio = tts.synthesize(text, diffusion_steps=5) # Alta calidad (lento) audio = tts.synthesize(text, diffusion_steps=20) ``` ### 2. Usa torch.compile (PyTorch 2.0+) ```python import torch model = torch.compile(model, mode="reduce-overhead") ``` ### 3. Inferencia de precisión mixta ```python with torch.autocast(device_type="cuda", dtype=torch.float16): audio = tts.synthesize(text, diffusion_steps=10) ``` ### 4. Agrupa varias oraciones Procesa varias oraciones juntas cuando sea posible para maximizar el uso de la GPU y reducir la sobrecarga. ### 5. Cachea las incrustaciones del hablante de referencia ```python # Calcula una vez, reutiliza muchas veces speaker_embedding = tts.compute_speaker_embedding(reference_audio, sr) # Reutiliza para múltiples enunciados for text in texts: audio = tts.synthesize_with_embedding(text, speaker_embedding) ``` *** ## Solución de problemas ### Problema: no se encuentra espeak-ng ```bash apt-get install -y espeak-ng espeak-ng-data # Verificar la instalación espeak-ng --version ``` ### Problema: falla Phonemizer ```bash pip install phonemizer # Prueba python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))" ``` ### Problema: CUDA sin memoria ```bash # Reduce el tamaño del lote o usa descarga a CPU export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256 # O cambia a FP16 ``` ### Problema: mala calidad de audio * Aumenta `diffusion_steps` a 15–20 * Asegúrate de que el audio de referencia esté limpio, con 16 kHz como mínimo * Prueba a ajustar `alpha` y `beta` los parámetros * Usa un clip de audio de referencia más largo (15–30 segundos) ### Problema: falla la descarga del modelo desde Hugging Face ```bash pip install huggingface_hub python3 -c " from huggingface_hub import snapshot_download snapshot_download('yl4579/StyleTTS2-LibriTTS', local_dir='Models/LibriTTS') " ``` *** ## Recomendaciones de GPU para Clore.ai StyleTTS2 es un modelo ligero: el checkpoint de LibriTTS ocupa \~300 MB y la inferencia es rápida incluso en GPU modestas. | GPU | VRAM | Precio de Clore.ai | Velocidad de inferencia | Ideal para | | --------- | ----- | ----------------------------------------- | ----------------------- | ------------------------------------------- | | Solo CPU | — | \~$0.02/hr | \~0.5× tiempo real | Desarrollo, pruebas | | RTX 3090 | 24 GB | $0.07–0.21/h | \~15× tiempo real | API de producción, clonación de voz | | RTX 4090 | 24 GB | $0.14–0.42/h | \~25× tiempo real | API de alta concurrencia | | A100 40GB | 40 GB | [bare metal](https://clore.ai/bare-metal) | \~40× tiempo real | Generación de audiolibros por lotes grandes | {% hint style="info" %} **RTX 3090 a $0.07–0.21/h** es la opción óptima para StyleTTS2. El modelo es lo bastante pequeño como para que gastes casi nada en tiempo de GPU: una hora completa de audio sintetizado cuesta menos de 0,01 $ en alquiler de GPU. Para la producción de audiolibros o servicios de clonación de voz, esto es extremadamente rentable. {% endhint %} **Consejo de calidad para clonación de voz zero-shot:** Proporciona 15–30 segundos de audio de referencia limpio a 22 kHz o 24 kHz. El módulo de difusión de estilo necesita suficiente audio para capturar con precisión el estilo de habla, el ritmo y la prosodia. Las referencias ruidosas o demasiado cortas degradan significativamente la calidad de salida. *** ## Enlaces * **GitHub**: * **Artículo (arXiv)**: * **Hugging Face (LJSpeech)**: * **Hugging Face (LibriTTS)**: * **Demo Space**: * **Marketplace de CLORE.AI**: --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/styletss2.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.