> 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/chatterbox-tts.md).

# Clonación de voz Chatterbox

Ejecuta Chatterbox TTS de Resemble AI para clonación de voz zero-shot y síntesis de voz multilingüe en GPUs de Clore.ai.

Chatterbox es una familia de modelos de texto a voz de código abierto de última generación de [Resemble AI](https://resemble.ai). Realiza clonación de voz zero-shot a partir de un breve clip de referencia (\~10 segundos), admite etiquetas paralingüísticas como `[laugh]` y `[cough]`, y ofrece una variante multilingüe que cubre más de 23 idiomas. Hay tres variantes del modelo disponibles: Turbo (350M, baja latencia), Original (500M, controles creativos) y Multilingüe (500M, más de 23 idiomas).

{% hint style="info" %}
**Multilingual V3 es ahora el punto de control multilingüe recomendado.** El mismo tamaño de 0.5B que la versión anterior, con mejor similitud de voz del hablante, menos alucinaciones y un habla más natural en todos los idiomas compatibles. Todo lo que aparece a continuación se aplica sin cambios — descarga los pesos actuales y obtendrás V3.
{% endhint %}

**GitHub:** [resemble-ai/chatterbox](https://github.com/resemble-ai/chatterbox) **PyPI:** [chatterbox-tts](https://pypi.org/project/chatterbox-tts/) **Licencia:** MIT

## Características clave

* **Clonación de voz zero-shot** — clona cualquier voz a partir de \~10 segundos de audio de referencia
* **Etiquetas paralingüísticas** (Turbo) — `[laugh]`, `[cough]`, `[chuckle]`, `[sigh]` para un habla realista
* **23+ idiomas** (Multilingüe) — árabe, chino, francés, alemán, japonés, coreano, ruso, español y más
* **Ajuste de CFG y exageración** (Original) — control creativo sobre la expresividad
* **Tres tamaños de modelo** — Turbo (350M), Original (500M), Multilingüe (500M)
* **licencia MIT** — totalmente abierto para uso comercial

## Requisitos

| Componente | Mínimo         | Recomendado         |
| ---------- | -------------- | ------------------- |
| GPU        | RTX 3060 12 GB | RTX 3090 / RTX 4090 |
| VRAM       | 6 GB           | 10 GB+              |
| RAM        | 8 GB           | 16 GB               |
| Disco      | 5 GB           | 15 GB               |
| Python     | 3.10+          | 3.11                |
| CUDA       | 12.8+          | 12.8+               |

**Recomendación de Clore.ai:** RTX 3090 ($0.07–0.21/h) para disponer de un margen cómodo de VRAM. La RTX 3060 funciona con el modelo Turbo. Para el modelo multilingüe con textos largos, considera una RTX 4090 ($0.14–0.42/h).

## Instalación

```bash
# Instala desde PyPI
pip install chatterbox-tts

# O instala desde el código fuente
git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox
pip install -e .

# Verificar
python -c "from chatterbox.tts import ChatterboxTTS; print('Chatterbox listo')"
```

## Inicio rápido

### Modelo Turbo (Menor latencia)

```python
import torchaudio as ta
from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")

# TTS básico con etiquetas paralingüísticas
text = "¡Hola, bienvenido de nuevo! [chuckle] Tengo una gran noticia para ti hoy."

# Clonación de voz — proporciona un clip de referencia de más de 10 segundos
wav = model.generate(text, audio_prompt_path="reference_voice.wav")

ta.save("output_turbo.wav", wav, model.sr)
print(f"Guardado a {model.sr} Hz")
```

### Modelo original (inglés, controles creativos)

```python
import torchaudio as ta
from chatterbox.tts import ChatterboxTTS

model = ChatterboxTTS.from_pretrained(device="cuda")

text = "El rápido zorro marrón salta sobre el perro perezoso. Era una hermosa mañana."

# Generar sin clonación de voz (usa la voz predeterminada)
wav = model.generate(text)
ta.save("output_default.wav", wav, model.sr)

# Generar con clonación de voz
wav = model.generate(text, audio_prompt_path="my_voice_sample.wav")
ta.save("output_cloned.wav", wav, model.sr)
```

## Ejemplos de uso

### Clonación de voz multilingüe

```python
import torchaudio as ta
from chatterbox.mtl_tts import ChatterboxMultilingualTTS

model = ChatterboxMultilingualTTS.from_pretrained(device="cuda")

# Francés
french_text = "Bonjour, comment allez-vous? Bienvenue dans notre démonstration."
wav_fr = model.generate(french_text, language_id="fr")
ta.save("output_french.wav", wav_fr, model.sr)

# Japonés
japanese_text = "こんにちは、テキスト読み上げのデモンストレーションです。"
wav_ja = model.generate(japanese_text, language_id="ja")
ta.save("output_japanese.wav", wav_ja, model.sr)

# Ruso con clonación de voz
russian_text = "Привет! Это демонстрация синтеза речи на русском языке."
wav_ru = model.generate(
    russian_text,
    language_id="ru",
    audio_prompt_path="russian_speaker.wav"
)
ta.save("output_russian.wav", wav_ru, model.sr)

print("Generación multilingüe completada")
```

### Etiquetas paralingüísticas (Turbo)

```python
import torchaudio as ta
from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")

samples = [
    ("saludo", "¡Hola! [laugh] Es tan bueno verte de nuevo."),
    ("nervioso", "Eh, bueno [cough] no estoy realmente seguro de eso."),
    ("emocionado", "¡Dios mío! [chuckle] ¡Eso es una noticia absolutamente increíble!"),
]

for name, text in samples:
    wav = model.generate(text, audio_prompt_path="speaker_ref.wav")
    ta.save(f"para_{name}.wav", wav, model.sr)
    print(f"Generado: {name}")
```

### Script de procesamiento por lotes

```python
import torchaudio as ta
from chatterbox.tts import ChatterboxTTS
import os

model = ChatterboxTTS.from_pretrained(device="cuda")

# Procesa una lista de líneas (por ejemplo, para capítulos de audiolibros)
lines = [
    "Capítulo uno. La aventura comienza.",
    "Era una noche oscura y tormentosa.",
    "El héroe se detuvo en la encrucijada, inseguro del camino por delante.",
]

os.makedirs("output_batch", exist_ok=True)

for i, line in enumerate(lines):
    wav = model.generate(line, audio_prompt_path="narrator_voice.wav")
    ta.save(f"output_batch/line_{i:03d}.wav", wav, model.sr)
    print(f"[{i+1}/{len(lines)}] {line[:40]}...")

print("Procesamiento por lotes completado")
```

## Consejos para usuarios de Clore.ai

* **Elección del modelo** — usa Turbo para agentes de voz de baja latencia, Original para trabajo creativo en inglés y Multilingual para contenido en otros idiomas
* **Calidad del audio de referencia** — usa un clip limpio, sin ruido, de 10 a 30 segundos para obtener los mejores resultados de clonación de voz
* **Configuración de Docker** — imagen base `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime`, expón el puerto `7860/http` para Gradio
* **Gestión de memoria** — llama a `torch.cuda.empty_cache()` entre grandes lotes para liberar VRAM
* **Idiomas compatibles** — ar, da, de, el, en, es, fi, fr, he, hi, it, ja, ko, ms, nl, no, pl, pt, ru, sv, sw, tr, zh
* **Espacio de HuggingFace** — pruébalo antes de alquilarlo en [huggingface.co/spaces/ResembleAI/Chatterbox](https://huggingface.co/spaces/ResembleAI/Chatterbox)

## Solución de problemas

| Problema                       | Solución                                                                                                                   |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
| `CUDA sin memoria`             | Usa Turbo (350M) en lugar de Original/Multilingual (500M), o alquila una GPU más grande                                    |
| La voz clonada no coincide     | Usa un clip de referencia más largo (15–30 s), más limpio y con un ruido de fondo mínimo                                   |
| `numpy` conflicto de versiones | Ejecuta `pip install numpy==1.26.4 --force-reinstall`                                                                      |
| Descarga lenta del modelo      | Los modelos se descargan desde HuggingFace en la primera ejecución (\~2 GB); descárgalos previamente con `huggingface-cli` |
| El audio tiene artefactos      | Reduce la longitud del texto por generación; los textos muy largos pueden degradar la calidad                              |
| `ModuleNotFoundError`          | Asegúrate de `pip install chatterbox-tts` se completó sin errores; comprueba la compatibilidad con Python 3.11             |


---

# 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/chatterbox-tts.md?ask=<question>&goal=<endgoal>
```

`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.