StyleTTS2

Ejecuta StyleTTS2, síntesis de voz a nivel humano mediante difusión de estilo en las GPU de Clore.ai

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

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

---

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 u 3080 maneja la inferencia en tiempo real cómodamente. Para procesamiento por lotes o atender usuarios concurrentes, use una 4090 o A100.

---

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 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 -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://<your-clore-server-ip>:7860

---

Configuración paso a paso

Paso 1: Conéctate por SSH a tu servidor

ssh root@<your-clore-server-ip> -p <ssh-port>

Paso 2: Instala 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 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 dependencias

pip install -r requirements.txt

# Instala dependencias adicionales si es necesario
pip install phonemizer gruut

Paso 6: Descarga los modelos preentrenados

# 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

# 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

source venv/bin/activate
python app.py

Acceder en http://<server-ip>:7860

---

Ejemplos de uso

Ejemplo 1: TTS básico vía API de 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

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

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

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

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

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.

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

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

3. Inferencia en precisión mixta

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

# 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

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

Problema: Phonemizer falla

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

Problema: CUDA fuera de 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: 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

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

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.

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: 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

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