> 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-fr/audio-et-voix/kani-tts.md). # 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](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/) **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 {% hint style="warning" %} **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](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement. {% endhint %} | 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 ```bash # 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 : ```python 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 ```python 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 : ```python 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 : ```python 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 : ```bash # 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 : ```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="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](https://github.com/nineninesix-ai/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](https://github.com/nineninesix-ai/kani-tts-2) — paquet PyPI, documentation d'utilisation, exemples avancés * [Hugging Face — kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) — poids du modèle anglais * [Cadre de pré-entraînement](https://github.com/nineninesix-ai/kani-tts-2-pretrain) — Entraînez votre propre modèle TTS à partir de zéro * [Serveur compatible OpenAI](https://github.com/nineninesix-ai/kani-tts-2-openai-server) — remplacement prêt à l'emploi pour l'API TTS d'OpenAI * [Modèle d'embedding du locuteur](https://huggingface.co/nineninesix/speaker-emb-tbr) — encodeur vocal basé sur WavLM * [Aperçu 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/) — couverture communautaire --- # 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-fr/audio-et-voix/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.