Clonage vocal Kani-TTS-2

Exécutez Kani-TTS-2 — un modèle de synthèse vocale ultra-efficace de 400M de paramètres avec clonage vocal sur les GPU Clore.ai

Kani-TTS-2 par nineninesix.ai (publié le 15 février 2026) est un modèle open-source de synthèse vocale de 400M de paramètres qui atteint une synthèse vocale haute fidélité en utilisant seulement 3 Go de VRAM. Construit sur l'architecture LFM2 de LiquidAI avec NVIDIA NanoCodec, il traite l'audio comme un langage — générant une voix naturelle avec clonage vocal zero-shot à partir d'un court extrait audio de référence. À moins de la moitié de la taille des modèles concurrents et avec une fraction de la puissance de calcul, Kani-TTS-2 est parfait pour l'IA conversationnelle en temps réel, la génération de livres audio et le clonage de voix sur du matériel économique.

HuggingFace : nineninesix/kani-tts-2-en GitHub : nineninesix-ai/kani-tts-2 PyPI : kani-tts-2 Licence : Apache 2.0

Principales caractéristiques

• 400M de paramètres, 3 Go VRAM — fonctionne sur pratiquement n'importe quel GPU moderne, y compris le RTX 3060

• Clonage vocal zero-shot — cloner n'importe quelle voix à partir d'un échantillon audio de référence de 3 à 30 secondes

• Embeddings de locuteur — représentations de locuteur 128-dim basées sur WavLM pour un contrôle précis de la voix

• Jusqu'à 40 secondes d'audio continu — adapté pour des passages plus longs et des dialogues

• Temps réel ou plus rapide — RTF ~0.2 sur RTX 5080, en temps réel même sur des GPU à budget limité

• Apache 2.0 — entièrement ouvert pour un usage personnel et commercial

• Cadre de préentraînement inclus — entraînez votre propre modèle TTS à partir de zéro dans n'importe quelle langue

Comparaison avec d'autres modèles TTS

Modèle	Paramètres	VRAM min	Clonage de voix	Langue	Licence
Kani-TTS-2	400M	3 Go	✅ Zero-shot	Anglais (extensible)	Apache 2.0
Kokoro	82M	2Go	❌ Voix prédéfinies	EN, JP, CN	Apache 2.0
Zonos	400M	8 Go	✅	Multi	Apache 2.0
ChatTTS	300M	4 Go	❌ Graines aléatoires	Chinois, Anglais	AGPL 3.0
Chatterbox	500M	6 Go	✅	Anglais	Apache 2.0
XTTS (Coqui)	467M	6 Go	✅	Multi	MPL 2.0
F5-TTS	335M	4 Go	✅	Multi	CC-BY-NC 4.0

Exigences

Composant	Minimum	Recommandé
GPU	N'importe lequel avec 3 Go de VRAM	RTX 3060 ou mieux
VRAM	3 Go	6 Go
RAM	8 Go	16Go
Disque	2Go	5Go
Python	3.9+	3.11+
CUDA	11.8+	12.0+

Recommandation Clore.ai : Un RTX 3060 (0,15–0,30 $/jour) est plus que suffisant. Même les instances GPU les moins chères sur Clore.ai exécuteront confortablement Kani-TTS-2. Pour le traitement par lot (livres audio, jeux de données), un RTX 4090 (0,5–2 $/jour) offre un excellent débit.

Installation

# Installer le paquet
pip install kani-tts-2

# IMPORTANT : Installer une version compatible de transformers (requis pour l'architecture LFM2)
pip install -U "transformers==4.56.0"

# Optionnel : Installer soundfile pour sauvegarder l'audio
pip install soundfile

Démarrage rapide

Trois lignes pour générer de la parole :

from kani_tts import KaniTTS

# Initialiser avec le modèle anglais
model = KaniTTS('nineninesix/kani-tts-2-en')

# Générer la parole
audio, text = model("Hello! Welcome to Kani TTS 2, the next generation of efficient text-to-speech.")

# Sauvegarder dans un fichier
model.save_audio(audio, "output.wav")

Exemples d'utilisation

1. Synthèse vocale basique

from kani_tts import KaniTTS

model = KaniTTS('nineninesix/kani-tts-2-en')

# Générer avec des paramètres personnalisés
audio, text = model(
    "The quick brown fox jumps over the lazy dog. "
    "This sentence contains every letter of the English alphabet.",
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1
)

model.save_audio(audio, "pangram.wav")
print(f"Generated {len(audio) / 22000:.1f} seconds of audio")

2. Clonage vocal

Cloner n'importe quelle voix à partir d'un court échantillon audio de référence :

from kani_tts import KaniTTS, SpeakerEmbedder

# Initialiser les modèles
model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Extraire l'embedding du locuteur depuis l'audio de référence (3-30 secondes recommandées)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# Générer la parole avec la voix clonée
audio, text = model(
    "This is a demonstration of voice cloning with Kani TTS 2. "
    "The voice you hear should match the reference audio sample.",
    speaker_emb=speaker_embedding
)

model.save_audio(audio, "cloned_output.wav")

3. Génération par lots pour livres audio

Générer plusieurs chapitres efficacement :

from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# Utiliser une voix de narrateur
narrator_emb = embedder.embed_audio_file("narrator_sample.wav")

chapters = [
    "Chapitre Un. C'était un jour lumineux et froid d'avril, et les horloges sonnaient treize.",
    "Chapitre Deux. Le couloir sentait le chou bouilli et les vieux paillassons en chiffon.",
    "Chapitre Trois. Dehors, même à travers la vitre fermée, le monde semblait froid.",
]

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"Generated chapter {i+1}")

4. API de streaming compatible OpenAI

Pour des applications en temps réel, utilisez le serveur compatible OpenAI :

# Cloner le serveur
git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git
cd kani-tts-2-openai-server

# Installer les dépendances
pip install -r requirements.txt

# Démarrer le serveur
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080

Puis utilisez-le avec n'importe quel client TTS OpenAI :

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="Hello from the OpenAI-compatible Kani TTS server!"
)

response.stream_to_file("streamed_output.wav")

Conseils pour les utilisateurs de Clore.ai

1. C'est le modèle le moins cher à faire fonctionner — Avec 3 Go de VRAM, Kani-TTS-2 fonctionne sur littéralement n'importe quelle instance GPU sur Clore.ai. Un RTX 3060 à 0,15 $/jour est plus que suffisant pour la TTS en production.

2. Combinez avec un modèle de langage — Louez une instance GPU et faites tourner à la fois un petit LLM (par ex., Mistral 3 8B) et Kani-TTS-2 simultanément pour un assistant vocal complet. Ils partageront le GPU avec de la marge.

3. Précalculer les embeddings de locuteur — Extrayez les embeddings de locuteur une fois et enregistrez-les. Cela évite de charger le modèle WavLM embedder à chaque requête.

4. Utilisez le serveur compatible OpenAI — Le kani-tts-2-openai-server fournit un remplacement plug-and-play pour l'API TTS d'OpenAI, facilitant l'intégration avec des applications existantes.

5. Entraînez sur des langues personnalisées — Kani-TTS-2 inclut un cadre complet de préentraînement (kani-tts-2-pretrain). Affinez le modèle sur votre propre jeu de données linguistique — cela ne nécessite que 8× H100 pendant ~6 heures.

Dépannage

Problème	Solution
ImportError : impossible d'importer LFM2	Installez la bonne version de transformers : pip install -U "transformers==4.56.0"
La qualité audio est faible / robotique	Augmentez température à 0,8–0,9 ; assurez-vous que l'audio de référence pour le clonage soit propre (sans bruit de fond)
Le clonage vocal ne ressemble pas à la référence	Utilisez 5–15 secondes d'audio clair d'un seul locuteur. Évitez la musique ou le bruit de fond dans la référence
CUDA out of memory	Ne devrait pas arriver avec le modèle 3 Go — vérifiez si d'autres processus utilisent la mémoire GPU (nvidia-smi)
L'audio se coupe en milieu de phrase	Kani-TTS-2 prend en charge jusqu'à ~40 secondes. Divisez les textes plus longs en phrases et concaténez les sorties
Lent sur CPU	L'inférence sur GPU est fortement recommandée. Même un GPU basique est 10–50× plus rapide que le CPU

Lectures complémentaires

• GitHub — kani-tts-2 — paquet PyPI, documentation d'utilisation, exemples avancés

• HuggingFace — kani-tts-2-en — poids du modèle anglais

• Cadre de préentraînement — Entraînez votre propre modèle TTS à partir de zéro

• Serveur compatible OpenAI — Remplacement plug-and-play pour l'API TTS d'OpenAI

• Modèle d'embedding de locuteur — Embedder vocal basé sur WavLM

• Aperçu MarkTechPost — Couverture communautaire