# StyleTTS2 StyleTTS2 alcanza puntuaciones de naturalidad valoradas por humanos por encima de las grabaciones reales en los benchmarks LJSpeech y LibriTTS (MOS 4.55 vs 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, permitiendo síntesis expresiva y adaptación de locutor en zero-shot a partir de un breve clip de referencia. A diferencia de los sistemas TTS tradicionales, StyleTTS2 puede generalizar a locutores no vistos con un breve clip de audio de referencia, produciendo voz que compite con actores de voz profesionales. Se ha probado que supera las puntuaciones de naturalidad valoradas por humanos en varios conjuntos de datos — un hito para TTS de código abierto. Características clave: * **Naturalidad a nivel humano** — supera las puntuaciones MOS humanas en LJSpeech * **Adaptación de locutor zero-shot** — clona cualquier voz a partir de una muestra de audio breve * **Difusión de estilo** — prosodia y estilo de habla expresivos y variados * **Soporte multivocero** — entrenado en LibriTTS (más de 2.300 locutores) * **Inferencia ligera** — funciona de manera eficiente en GPUs de consumo {% hint style="success" %} Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](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 u 3080 maneja la inferencia en tiempo real cómodamente. Para procesamiento por lotes o atender usuarios concurrentes, use una 4090 o A100. {% endhint %} *** ## Despliegue rápido en CLORE.AI StyleTTS2 requiere una compilación Docker personalizada ya que no existe una imagen preconstruida oficial. La configuración toma \~10 minutos. ### 1. Encuentra un servidor adecuado Ve a [CLORE.AI Marketplace](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 ``` **Mapeo de puertos:** ``` 22 → acceso SSH 7860 → Interfaz web 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 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 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 dependencias ```bash pip install -r requirements.txt # Instala dependencias adicionales si es necesario pip install phonemizer gruut ``` ### Paso 6: Descarga los modelos preentrenados ```bash # Descargar modelo LJSpeech (un solo locutor, 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" # Descargar modelo LibriTTS (multivocero, 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: Lanza la demo de Gradio directamente ```bash source venv/bin/activate python app.py ``` Acceder en `http://:7860` *** ## Ejemplos de uso ### Ejemplo 1: TTS básico vía API de Python ```python import torch import soundfile as sf import numpy as np from models import * from utils import * import yaml # Cargar configuración config = yaml.safe_load(open("Models/LJSpeech/config.yml")) # Inicializar 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 GPU device = "cuda" if torch.cuda.is_available() else "cpu" for key in model: model[key] = model[key].to(device) print(f"Model loaded on: {device}") print(f"VRAM used: {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 # Inicializar motor de inferencia tts = StyleTTS2Inference( model_path="Models/LibriTTS/epochs_2nd_00020.pth", config_path="Models/LibriTTS/config.yml", device="cuda" ) # Cargar audio de referencia (10-30 segundos funciona mejor) reference_audio, sr = torchaudio.load("reference_voice.wav") # Generar voz con la voz de referencia text = "Clore.ai provides powerful GPU infrastructure for AI applications including text-to-speech synthesis." audio = tts.synthesize( text=text, reference_audio=reference_audio, reference_sr=sr, diffusion_steps=10, # Mayor = mejor calidad, más lento embedding_scale=1.5, # Controla la intensidad 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 de 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 = "Welcome to our presentation on GPU computing with 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"Generated: {filename}") ``` *** ### Ejemplo 4: Interfaz web 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="Input Text", lines=4), gr.Audio(label="Reference Voice (optional)", type="numpy"), gr.Slider(1, 30, value=10, label="Diffusion Steps"), gr.Slider(0.0, 1.0, value=0.3, label="Alpha (Acoustic Style)"), gr.Slider(0.0, 1.0, value=0.7, label="Beta (Prosodic Style)"), ], outputs=gr.Audio(label="Generated Speech"), title="StyleTTS2 on Clore.ai GPU", description="Human-level TTS with style diffusion" ) 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" ) # Divide 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 este poder computacional, haciendo que la infraestructura GPU de nivel empresarial sea accesible para individuos 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"Processing paragraph {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" ✓ Saved {segment_path}") # Concatenar todos los segmentos con una breve pausa 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 en 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 | Por defecto | Efecto | | ----------------- | ------- | ----------- | --------------------------------------------- | | `diffusion_steps` | 1–30 | 10 | Compensación calidad vs velocidad | | `alpha` | 0.0–1.0 | 0.3 | Peso del estilo acústico desde la referencia | | `beta` | 0.0–1.0 | 0.7 | Peso del estilo prosódico desde la referencia | | `embedding_scale` | 1.0–3.0 | 1.5 | Intensidad general del estilo | | `t` | 0.6–1.0 | 0.7 | Nivel de ruido (mayor = más variación) | *** ## Consejos de rendimiento ### 1. Optimizar pasos de difusión El valor predeterminado de 10 pasos equilibra calidad y velocidad. Para aplicaciones en tiempo real, use 5 pasos; para máxima calidad, use 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. Use torch.compile (PyTorch 2.0+) ```python import torch model = torch.compile(model, mode="reduce-overhead") ``` ### 3. Inferencia en precisión mixta ```python with torch.autocast(device_type="cuda", dtype=torch.float16): audio = tts.synthesize(text, diffusion_steps=10) ``` ### 4. Procesar múltiples oraciones por lotes Procese múltiples oraciones juntas cuando sea posible para maximizar la utilización de la GPU y reducir la sobrecarga. ### 5. Caché de incrustaciones de locutor de referencia ```python # Calcular una vez, reutilizar muchas veces speaker_embedding = tts.compute_speaker_embedding(reference_audio, sr) # Reutilizar para múltiples enunciados for text in texts: audio = tts.synthesize_with_embedding(text, speaker_embedding) ``` *** ## Solución de problemas ### Problema: espeak-ng no encontrado ```bash apt-get install -y espeak-ng espeak-ng-data # Verificar instalación espeak-ng --version ``` ### Problema: Phonemizer falla ```bash pip install phonemizer # Prueba python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))" ``` ### Problema: CUDA fuera de 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: Calidad de audio deficiente * Aumente `diffusion_steps` a 15–20 * Asegúrate de que el audio de referencia esté limpio, mínimo 16 kHz * Prueba ajustando `alpha` y `beta` parámetros * Usa un clip de referencia más largo (15–30 segundos) ### Problema: La descarga del modelo falla 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 en Clore.ai StyleTTS2 es un modelo ligero — el checkpoint de LibriTTS tiene \~300MB, la inferencia es rápida incluso en GPUs modestos. | GPU | VRAM | Precio en Clore.ai | Velocidad de inferencia | Mejor para | | --------- | ----- | ------------------ | ----------------------- | ------------------------------------------ | | Solo CPU | — | \~$0.02/hr | \~0.5× tiempo real | Desarrollo, pruebas | | RTX 3090 | 24 GB | \~$0.12/h | \~15× tiempo real | API de producción, clonación de voz | | RTX 4090 | 24 GB | \~$0.70/h | \~25× tiempo real | API de alta concurrencia | | A100 40GB | 40 GB | \~$1.20/h | \~40× tiempo real | Generación masiva por lotes de audiolibros | {% hint style="info" %} **RTX 3090 a \~$0.12/hr** es la opción óptima para StyleTTS2. El modelo es lo suficientemente 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 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:** Proporcione 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 cortas degradan significativamente la calidad de salida. *** ## Enlaces * **GitHub**: * **Artículo (arXiv)**: * **Hugging Face (LJSpeech)**: * **Hugging Face (LibriTTS)**: * **Demo Space**: * **CLORE.AI Marketplace**: --- # Agent Instructions: 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: ``` GET https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/styletss2.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.