> 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/kani-tts.md). # Clonación de voz Kani-TTS-2 Ejecuta Kani-TTS-2: un modelo de texto a voz ultrar eficiente de 400M parámetros con clonación de voz en GPUs de Clore.ai Kani-TTS-2 de nineninesix.ai (lanzado el 15 de febrero de 2026) es un modelo de texto a voz de código abierto con 400 millones de parámetros que logra síntesis de voz de alta fidelidad usando solo **3 GB de VRAM**. Construido sobre la arquitectura LFM2 de LiquidAI con NVIDIA NanoCodec, trata el audio como un lenguaje — generando voz de sonido natural con clonación de voz zero-shot a partir de un breve clip de audio de referencia. Con menos de la mitad del tamaño de los modelos competidores y una fracción del cómputo, Kani-TTS-2 es perfecto para IA conversacional en tiempo real, generación de audiolibros y clonación de voz en hardware económico. **HuggingFace:** [nineninesix/kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) **GitHub:** [nineninesix-ai/kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) **PyPI:** [kani-tts-2](https://pypi.org/project/kani-tts-2/) **Licencia:** Apache 2.0 ## Características clave * **400 millones de parámetros, 3 GB de VRAM** — funciona en prácticamente cualquier GPU moderna, incluida la RTX 3060 * **Clonación de voz zero-shot** — clona cualquier voz a partir de una muestra de audio de referencia de 3 a 30 segundos * **Embeddings del hablante** — representaciones del hablante de 128 dimensiones basadas en WavLM para un control preciso de la voz * **Hasta 40 segundos de audio continuo** — adecuado para pasajes más largos y diálogos * **En tiempo real o más rápido** — RTF \~0.2 en RTX 5080, en tiempo real incluso en GPU económicas * **Apache 2.0** — totalmente abierto para uso personal y comercial * **Marco de preentrenamiento incluido** — entrena tu propio modelo TTS desde cero en cualquier idioma ## Comparación con otros modelos TTS | Modelo | Parámetros | VRAM mínima | Clonación de voz | Idioma | Licencia | | -------------- | ---------- | ----------- | ----------------------- | ------------------- | ------------ | | **Kani-TTS-2** | 400M | 3GB | ✅ Zero-shot | Inglés (extensible) | Apache 2.0 | | Kokoro | 82M | 2 GB | ❌ Voces preestablecidas | EN, JP, CN | Apache 2.0 | | Zonos | 400M | 8GB | ✅ | Varias | Apache 2.0 | | ChatTTS | 300M | 4GB | ❌ Semillas aleatorias | Chino, inglés | AGPL 3.0 | | Chatterbox | 500M | 6GB | ✅ | Inglés | Apache 2.0 | | XTTS (Coqui) | 467M | 6GB | ✅ | Varias | MPL 2.0 | | F5-TTS | 335M | 4GB | ✅ | Varias | CC-BY-NC 4.0 | ## Requisitos {% hint style="warning" %} **Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue. {% endhint %} | Componente | Mínimo | Recomendado | | ---------- | --------------------------- | ------------------- | | GPU | Cualquiera con 3 GB de VRAM | RTX 3060 o superior | | VRAM | 3GB | 6GB | | RAM | 8GB | 16GB | | Disco | 2 GB | 5GB | | Python | 3.9+ | 3.11+ | | CUDA | 12.8+ | 12.8+ | **Recomendación de Clore.ai:** Una RTX 3060 ($0.03–0.07/h) es más que suficiente. Incluso las instancias de GPU más baratas en Clore.ai ejecutarán Kani-TTS-2 con comodidad. Para el procesamiento por lotes (audiolibros, conjuntos de datos), una RTX 4090 ($0.14–0.42/h) proporciona un rendimiento excelente. ## Instalación ```bash # Instala el paquete pip install kani-tts-2 # IMPORTANTE: instala una versión compatible de transformers (requerida para la arquitectura LFM2) pip install -U "transformers==4.56.0" # Opcional: instala soundfile para guardar audio pip install soundfile ``` ## Inicio rápido Tres líneas para generar voz: ```python from kani_tts import KaniTTS # Inicializa con el modelo en inglés model = KaniTTS('nineninesix/kani-tts-2-en') # Generar voz audio, text = model("¡Hola! Bienvenido a Kani TTS 2, la próxima generación de texto a voz eficiente.") # Guardar en archivo model.save_audio(audio, "output.wav") ``` ## Ejemplos de uso ### 1. Texto a voz básico ```python from kani_tts import KaniTTS model = KaniTTS('nineninesix/kani-tts-2-en') # Genera con parámetros personalizados audio, text = model( "El rápido zorro marrón salta sobre el perro perezoso. " "Esta oración contiene cada letra del alfabeto inglés.", temperature=0.7, top_p=0.9, repetition_penalty=1.1 ) model.save_audio(audio, "pangram.wav") print(f"Se generaron {len(audio) / 22000:.1f} segundos de audio") ``` ### 2. Clonación de voz Clona cualquier voz a partir de una breve muestra de audio de referencia: ```python from kani_tts import KaniTTS, SpeakerEmbedder # Inicializa los modelos model = KaniTTS('nineninesix/kani-tts-2-en') embedder = SpeakerEmbedder() # Extrae el embedding del hablante del audio de referencia (se recomiendan de 3 a 30 segundos) speaker_embedding = embedder.embed_audio_file("reference_voice.wav") # Genera voz con la voz clonada audio, text = model( "Esta es una demostración de clonación de voz con Kani TTS 2. " "La voz que escuches debería coincidir con la muestra de audio de referencia.", speaker_emb=speaker_embedding ) model.save_audio(audio, "cloned_output.wav") ``` ### 3. Generación por lotes para audiolibros Genera múltiples capítulos de forma eficiente: ```python from kani_tts import KaniTTS, SpeakerEmbedder import soundfile as sf model = KaniTTS('nineninesix/kani-tts-2-en') embedder = SpeakerEmbedder() # Usa una voz de narrador narrator_emb = embedder.embed_audio_file("narrator_sample.wav") chapters = [ "Capítulo uno. Era un día brillante y frío de abril, y los relojes daban las trece.", "Capítulo dos. El pasillo olía a col hervida y a viejos felpudos.", "Capítulo tres. Afuera, incluso a través del cristal de la ventana cerrada, el mundo parecía frío.", ] for i, chapter_text in enumerate(chapters): audio, _ = model(chapter_text, speaker_emb=narrator_emb) model.save_audio(audio, f"chapter_{i+1}.wav") print(f"Capítulo {i+1} generado") ``` ### 4. API de streaming compatible con OpenAI Para aplicaciones en tiempo real, usa el servidor compatible con OpenAI: ```bash # Clona el servidor git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git cd kani-tts-2-openai-server # Instalar dependencias pip install -r requirements.txt # Iniciar el servidor python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080 ``` Luego úsalo con cualquier cliente TTS de OpenAI: ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed") response = client.audio.speech.create( model="kani-tts-2-en", voice="default", input="¡Hola desde el servidor Kani TTS compatible con OpenAI!" ) response.stream_to_file("streamed_output.wav") ``` ## Consejos para usuarios de Clore.ai 1. **Este es el modelo más económico de ejecutar** — Con 3 GB de VRAM, Kani-TTS-2 se ejecuta literalmente en cualquier instancia de GPU en Clore.ai. Una RTX 3060 a $0.03–0.07/h es más que suficiente para TTS en producción. 2. **Combínalo con un modelo de lenguaje** — Alquila una instancia de GPU y ejecuta simultáneamente un LLM pequeño (p. ej., Mistral 3 8B) y Kani-TTS-2 para tener un asistente de voz completo. Compartirán la GPU con margen de sobra. 3. **Precalcula los embeddings del hablante** — Extrae los embeddings del hablante una sola vez y guárdalos. Así evitas cargar el modelo embebedor WavLM en cada solicitud. 4. **Usa el servidor compatible con OpenAI** — El `kani-tts-2-openai-server` proporciona un reemplazo directo de la API TTS de OpenAI, lo que facilita la integración con aplicaciones existentes. 5. **Entrena en idiomas personalizados** — Kani-TTS-2 incluye un marco completo de preentrenamiento ([kani-tts-2-pretrain](https://github.com/nineninesix-ai/kani-tts-2-pretrain)). Ajusta el modelo con tu propio conjunto de datos de idioma — solo se necesitan 8× H100 durante unas 6 horas. ## Solución de problemas | Problema | Solución | | ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | | `ImportError: no se puede importar LFM2` | Instala la versión correcta de transformers: `pip install -U "transformers==4.56.0"` | | La calidad de audio es mala / robótica | Aumenta `temperature` a 0.8–0.9; asegúrate de que el audio de referencia para la clonación esté limpio (sin ruido de fondo) | | La clonación de voz no suena como la referencia | Usa de 5 a 15 segundos de audio claro de un solo hablante. Evita música o ruido de fondo en la referencia | | `CUDA sin memoria` | No debería ocurrir con el modelo de 3 GB — comprueba si otros procesos están usando memoria de la GPU (`nvidia-smi`) | | El audio se corta a mitad de la oración | Kani-TTS-2 admite hasta \~40 segundos. Divide los textos más largos en oraciones y concatena las salidas | | Lento en CPU | Se recomienda encarecidamente la inferencia en GPU. Incluso una GPU básica es de 10 a 50 veces más rápida que la CPU | ## Lecturas adicionales * [GitHub — kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) — paquete de PyPI, documentación de uso, ejemplos avanzados * [HuggingFace — kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) — pesos del modelo en inglés * [Marco de preentrenamiento](https://github.com/nineninesix-ai/kani-tts-2-pretrain) — Entrena tu propio modelo TTS desde cero * [Servidor compatible con OpenAI](https://github.com/nineninesix-ai/kani-tts-2-openai-server) — Reemplazo directo de la API TTS de OpenAI * [Modelo de embeddings del hablante](https://huggingface.co/nineninesix/speaker-emb-tbr) — embebedor de voz basado en WavLM * [Resumen de MarkTechPost](https://www.marktechpost.com/2026/02/15/meet-kani-tts-2-a-400m-param-open-source-text-to-speech-model-that-runs-in-3gb-vram-with-voice-cloning-support/) — Cobertura de la comunidad --- # 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/kani-tts.md?ask=&goal= ``` `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.