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 de nineninesix.ai (publié le 15 février 2026) est un modèle de synthèse vocale open source de 400 M de paramètres qui atteint une synthèse vocale de haute fidélité en n'utilisant que 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 parole au son naturel grâce au clonage vocal sans apprentissage préalable à partir d'un court extrait audio de référence. Avec une taille inférieure de moitié à celle des modèles concurrents et une fraction du calcul, Kani-TTS-2 est parfait pour l'IA conversationnelle en temps réel, la génération de livres audio et le clonage vocal sur du matériel à petit budget.

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

Caractéristiques clés

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

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

• Embeddings du locuteur — représentations de locuteur à 128 dimensions basées sur WavLM pour un contrôle vocal précis

• Jusqu'à 40 secondes d'audio continu — convient aux passages plus longs et aux dialogues

• En temps réel ou plus rapide — RTF ~0,2 sur RTX 5080, en temps réel même sur des GPU à petit budget

• Apache 2.0 — totalement 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 minimale	Clonage vocal	Langue	Licence
Kani-TTS-2	400 M	3 Go	✅ Sans apprentissage préalable	Anglais (extensible)	Apache 2.0
Kokoro	82 M	2GB	❌ Voix prédéfinies	EN, JP, CN	Apache 2.0
Zonos	400 M	8 Go	✅	Multi	Apache 2.0
ChatTTS	300 M	4 Go	❌ Graines aléatoires	Chinois, anglais	AGPL 3.0
Chatterbox	500 M	6 Go	✅	Anglais	Apache 2.0
XTTS (Coqui)	467 M	6 Go	✅	Multi	MPL 2.0
F5-TTS	335M	4 Go	✅	Multi	CC-BY-NC 4.0

Exigences

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

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

Recommandation de Clore.ai : Une RTX 3060 ($0.03–0.07/heure) suffit amplement. Même les instances GPU les moins chères sur Clore.ai exécuteront Kani-TTS-2 sans difficulté. Pour le traitement par lots (livres audio, jeux de données), une RTX 4090 ($0.14–0.42/heure) offre un excellent débit.

Installation

# Installez le paquet
pip install kani-tts-2

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

# Facultatif : installez soundfile pour enregistrer l'audio
pip install soundfile

Démarrage rapide

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

from kani_tts import KaniTTS

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

# Générer la parole
audio, text = model("Bonjour ! Bienvenue dans Kani TTS 2, la nouvelle génération de synthèse vocale efficace.")

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

Exemples d'utilisation

1. Synthèse vocale de base

from kani_tts import KaniTTS

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

# Générer avec des paramètres personnalisés
audio, text = model(
    "Portez ce vieux whisky au juge blond qui fume. "
    "Cette phrase contient chaque lettre de l'alphabet anglais.",
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1
)

model.save_audio(audio, "pangram.wav")
print(f"{len(audio) / 22000:.1f} secondes d'audio générées")

2. Clonage vocal

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

from kani_tts import KaniTTS, SpeakerEmbedder

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

# Extraire l'embedding du locuteur à partir de 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 dans la voix clonée
audio, text = model(
    "Ceci est une démonstration du clonage vocal avec Kani TTS 2. "
    "La voix que vous entendez devrait correspondre à l'échantillon audio de référence.",
    speaker_emb=speaker_embedding
)

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

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

Générez efficacement plusieurs chapitres :

from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

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

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

chapters = [
    "Chapitre un. C'était une journée froide et lumineuse d'avril, et les horloges sonnaient treize heures.",
    "Chapitre deux. Le couloir sentait le chou bouilli et les vieux tapis en guenilles.",
    "Chapitre trois. Dehors, même à travers la vitre fermée, le monde paraissait 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"Chapitre {i+1} généré")

4. API de streaming compatible OpenAI

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

# Clonez 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émarrez le serveur
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080

Utilisez ensuite 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="Bonjour depuis le serveur Kani TTS compatible OpenAI !"
)

response.stream_to_file("streamed_output.wav")

Conseils pour les utilisateurs de Clore.ai

1. C'est le modèle le moins coûteux à faire fonctionner — Avec 3 Go de VRAM, Kani-TTS-2 fonctionne sur littéralement n'importe quelle instance GPU sur Clore.ai. Une RTX 3060 à $0.03–0.07/heure suffit amplement pour une TTS de production.

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

3. Pré-calculez les embeddings du locuteur — Extrayez les embeddings du locuteur une seule fois et enregistrez-les. Cela évite de charger le modèle d'embedding WavLM à chaque requête.

4. Utilisez le serveur compatible OpenAI — Le kani-tts-2-openai-server fournit un remplacement prêt à l'emploi de l'API TTS d'OpenAI, ce qui facilite l'intégration avec les 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). Ajustez finement le modèle sur votre propre jeu de données linguistique — cela ne prend que 8× H100 pendant environ 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 médiocre / robotique	Augmentez temperature à 0,8–0,9 ; assurez-vous que l'audio de référence pour le clonage est propre (pas de bruit de fond)
Le clonage vocal ne ressemble pas à la référence	Utilisez 5 à 15 secondes d'audio clair avec un seul locuteur. Évitez la musique ou le bruit de fond dans la référence
Mémoire CUDA insuffisante	Cela 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 s'interrompt au milieu d'une phrase	Kani-TTS-2 prend en charge jusqu'à environ 40 secondes. Découpez 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

Pour aller plus loin

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

• Hugging Face — 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 prêt à l'emploi pour l'API TTS d'OpenAI

• Modèle d'embedding du locuteur — encodeur vocal basé sur WavLM

• Aperçu de MarkTechPost — couverture communautaire