Voz conversacional ChatTTS

Ejecuta texto a voz conversacional ChatTTS con control fino de la prosodia en GPUs de Clore.ai.

ChatTTS es un modelo generativo de voz de 300 millones de parámetros optimizado para escenarios de diálogo como asistentes LLM, chatbots y aplicaciones de voz interactivas. Produce voz con sonido natural, con pausas realistas, risas, muletillas y entonación — características que la mayoría de los sistemas TTS tienen dificultades para reproducir. El modelo admite inglés y chino y genera audio a 24 kHz.

GitHub: 2noise/ChatTTS (30K+ estrellas) Licencia: AGPLv3+ (código), CC BY-NC 4.0 (pesos del modelo — no comercial)

Características clave

• Prosodia conversacional — pausas naturales, muletillas e entonación ajustadas para el diálogo

• Etiquetas de control detalladas — [oral_0-9], [laugh_0-2], [break_0-7], [uv_break], [lbreak]

• Varios hablantes — muestrea hablantes aleatorios o reutiliza incrustaciones del hablante para mantener la coherencia

• Temperatura / top-P / top-K — controla la diversidad de la generación

• Inferencia por lotes — sintetiza varios textos en una sola llamada

• Ligero — ~300M de parámetros, funciona con 4 GB de VRAM

Requisitos

Componente	Mínimo	Recomendado
GPU	RTX 3060 (4 GB libres)	RTX 3090 / RTX 4090
VRAM	4 GB	8 GB+
RAM	8 GB	16 GB
Disco	5 GB	10 GB
Python	3.9+	3.11
CUDA	12.8+	12.8+

Recomendación de Clore.ai: Una RTX 3060 ($0.03–0.07/h) maneja ChatTTS cómodamente. Para producción por lotes o menor latencia, elige una RTX 3090 ($0.07–0.21/h).

Instalación

# Instala desde PyPI
pip install ChatTTS torch torchaudio

# O instálalo desde el código fuente para obtener las funciones más recientes
git clone https://github.com/2noise/ChatTTS.git
cd ChatTTS
pip install -r requirements.txt

# Verificar GPU
python -c "import torch; print(torch.cuda.get_device_name(0))"

Inicio rápido

import ChatTTS
import torch
import torchaudio

# Inicializa y carga el modelo (descarga los pesos en la primera ejecución)
chat = ChatTTS.Chat()
chat.load(compile=False)  # Establece compile=True para una inferencia más rápida después del calentamiento

texts = [
    "¡Hola! ¿Cómo va tu día hasta ahora?",
    "He estado trabajando en este proyecto toda la mañana. Va avanzando muy bien.",
]

wavs = chat.infer(texts)

for i, wav in enumerate(wavs):
    audio_tensor = torch.from_numpy(wav)
    if audio_tensor.dim() == 1:
        audio_tensor = audio_tensor.unsqueeze(0)
    torchaudio.save(f"output_{i}.wav", audio_tensor, 24000)
    print(f"Guardado output_{i}.wav")

Ejemplos de uso

Voz del hablante consistente

Muestrea una incrustación aleatoria del hablante y reutilízala en varias generaciones para una voz consistente:

import ChatTTS
import torch
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

# Muestra un hablante — guarda esta cadena para reutilizarla más tarde
rand_spk = chat.sample_random_speaker()

params_infer_code = ChatTTS.Chat.InferCodeParams(
    spk_emb=rand_spk,
    temperature=0.3,
    top_P=0.7,
    top_K=20,
)

params_refine_text = ChatTTS.Chat.RefineTextParams(
    prompt='[oral_2][laugh_0][break_4]',
)

texts = ["Bienvenido al episodio de hoy. Déjame contarte algo emocionante."]

wavs = chat.infer(
    texts,
    params_refine_text=params_refine_text,
    params_infer_code=params_infer_code,
)

audio = torch.from_numpy(wavs[0])
if audio.dim() == 1:
    audio = audio.unsqueeze(0)
torchaudio.save("consistent_speaker.wav", audio, 24000)

Etiquetas de control a nivel de palabra

Inserta etiquetas de control directamente en el texto para una prosodia precisa:

import ChatTTS
import torch
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

# Etiquetas: [uv_break] = pausa corta, [laugh] = risa, [lbreak] = pausa larga
text = '¿Cuál es [uv_break]tu comida favorita?[laugh][lbreak]'

rand_spk = chat.sample_random_speaker()
params = ChatTTS.Chat.InferCodeParams(spk_emb=rand_spk, temperature=0.3)

# skip_refine_text=True conserva tus etiquetas de control manuales
wavs = chat.infer(text, skip_refine_text=True, params_infer_code=params)

audio = torch.from_numpy(wavs[0])
if audio.dim() == 1:
    audio = audio.unsqueeze(0)
torchaudio.save("controlled_output.wav", audio, 24000)

Procesamiento por lotes con WebUI

ChatTTS incluye una interfaz web de Gradio para uso interactivo:

cd ChatTTS
python examples/web/webui.py --server_name 0.0.0.0 --server_port 7860

Abre la http_pub URL desde el panel de pedidos de Clore.ai para acceder a la interfaz.

Consejos para usuarios de Clore.ai

• Usa compile=True después de las pruebas iniciales — la compilación de PyTorch añade tiempo de inicio, pero acelera significativamente la inferencia repetida

• Mapeo de puertos — expón el puerto 7860/http al desplegar con la WebUI

• Imagen Docker — usa pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime como base

• Persistencia del hablante — guarda rand_spk cadenas en un archivo para que puedas reutilizar voces entre sesiones sin volver a muestrear

• Agrupa tus solicitudes — chat.infer() acepta una lista de textos y los procesa juntos, lo que es más eficiente que hacer llamadas una por una

• Licencia no comercial — los pesos del modelo están bajo CC BY-NC 4.0; revisa los requisitos de la licencia para tu caso de uso

Solución de problemas

Problema	Solución
CUDA sin memoria	Reduce el tamaño del lote o usa una GPU con ≥ 6 GB de VRAM
La descarga del modelo es lenta	Descárgalo previamente desde HuggingFace: huggingface-cli download 2Noise/ChatTTS
El audio tiene estática/ruido	Esto es intencional en el modelo de código abierto (medida contra el abuso); usa compile=True para obtener una salida más limpia
torchaudio.save error de dimensión	Asegúrate de que el tensor sea 2D: audio.unsqueeze(0) si es necesario
Salida en chino ilegible	Asegúrate de que el texto de entrada esté codificado en UTF-8; instala WeTextProcessing para una mejor normalización
Primera inferencia lenta	Normal — la compilación del modelo y la carga de pesos ocurren en la primera llamada; las llamadas posteriores son más rápidas