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

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

---

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

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.

---

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 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 -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://<tu-ip-del-servidor-clore>:7860

---

Configuración paso a paso

Paso 1: conéctate por SSH a tu servidor

ssh root@<la-ip-de-tu-servidor-clore> -p <puerto-ssh>

Paso 2: Instala las dependencias del sistema

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

cd /workspace
git clone https://github.com/yl4579/StyleTTS2.git
cd StyleTTS2

Paso 4: Crea un entorno virtual de Python

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip

Paso 5: Instala las dependencias

pip install -r requirements.txt

# Instala dependencias adicionales si es necesario
pip install phonemizer gruut

Paso 6: Descarga los modelos preentrenados

# 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

# 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

source venv/bin/activate
python app.py

Accede en http://<ip-del-servidor>:7860

---

Ejemplos de uso

Ejemplo 1: TTS básico mediante la API de 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

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

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

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

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

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.

# 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+)

import torch
model = torch.compile(model, mode="reduce-overhead")

3. Inferencia de precisión mixta

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

# 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

apt-get install -y espeak-ng espeak-ng-data
# Verificar la instalación
espeak-ng --version

Problema: falla Phonemizer

pip install phonemizer
# Prueba
python3 -c "from phonemizer import phonemize; print(phonemize('hello world'))"

Problema: CUDA sin memoria

# 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

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	~40× tiempo real	Generación de audiolibros por lotes grandes

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.

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: https://github.com/yl4579/StyleTTS2

• Artículo (arXiv): https://arxiv.org/abs/2306.07691

• Hugging Face (LJSpeech): https://huggingface.co/yl4579/StyleTTS2-LJSpeech

• Hugging Face (LibriTTS): https://huggingface.co/yl4579/StyleTTS2-LibriTTS

• Demo Space: https://huggingface.co/spaces/styletts2/styletts2

• Marketplace de CLORE.AI: https://clore.ai/marketplace