# Kani-TTS-2 Voice Cloning

nineninesix.ai द्वारा Kani-TTS-2 (जारी: 15 फरवरी, 2026) एक 400M-पैरामीटर ओपन-सोर्स टेक्स्ट-टु-स्पीच मॉडल है जो केवल **3GB VRAM**का उपयोग करके उच्च-निष्ठा वाली भाषण सिंथेसिस प्राप्त करता है। LiquidAI के LFM2 आर्किटेक्चर और NVIDIA NanoCodec पर निर्मित, यह ऑडियो को एक भाषा के रूप में मानता है — एक छोटे संदर्भ ऑडियो क्लिप से जीरो-शॉट वॉइस क्लोनिंग के साथ प्राकृतिक सुनाई देने वाला भाषण उत्पन्न करता है। प्रतिस्पर्धी मॉडलों के आकार के आधे से भी कम और गणना के एक हिस्से पर, Kani-TTS-2 वास्तविक-समय संवादात्मक एआई, ऑडियोबुक उत्पादन और बजट हार्डवेयर पर वॉइस क्लोनिंग के लिए आदर्श है।

**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/) **लाइसेंस:** Apache 2.0

## प्रमुख विशेषताएँ

* **400M पैरामीटर, 3GB VRAM** — लगभग किसी भी आधुनिक GPU पर चलता है, जिसमें RTX 3060 भी शामिल है
* **जीरो-शॉट वॉइस क्लोनिंग** — 3–30 सेकंड के संदर्भ ऑडियो नमूने से किसी भी आवाज़ को क्लोन करें
* **स्पीकर एम्बेडिंग्स** — सटीक वॉइस नियंत्रण के लिए WavLM-आधारित 128-डायमेंशनल स्पीकर प्रतिनिधित्व
* **लगातार ऑडियो के लिए 40 सेकंड तक** — लंबे अनुच्छेदों और संवाद के लिए उपयुक्त
* **रीयल-टाइम या उससे तेज़** — RTX 5080 पर RTF \~0.2, बजट GPUs पर भी वास्तविक-समय
* **Apache 2.0** — व्यक्तिगत और व्यावसायिक उपयोग के लिए पूरी तरह खुला
* **पूर्व-प्रशिक्षण फ्रेमवर्क शामिल** — किसी भी भाषा पर शून्य से अपना TTS मॉडल ट्रेन करें

## अन्य TTS मॉडलोंとの तुलना

| मॉडल           | पैरामीटर | न्यूनतम VRAM | वॉइस क्लोनिंग     | भाषा                     | लाइसेंस      |
| -------------- | -------- | ------------ | ----------------- | ------------------------ | ------------ |
| **Kani-TTS-2** | 400M     | 3GB          | ✅ जीरो-शॉट        | अंग्रेजी (विस्तार योग्य) | Apache 2.0   |
| Kokoro         | 82M      | 2GB          | ❌ प्रीसेट वॉइसेज़ | EN, JP, CN               | Apache 2.0   |
| Zonos          | 400M     | 8GB          | ✅                 | मल्टी                    | Apache 2.0   |
| ChatTTS        | 300M     | 4GB          | ❌ रैंडम सीड्स     | चीनी, अंग्रेज़ी          | AGPL 3.0     |
| Chatterbox     | 500M     | 6GB          | ✅                 | अंग्रेज़ी                | Apache 2.0   |
| XTTS (Coqui)   | 467M     | 6GB          | ✅                 | मल्टी                    | MPL 2.0      |
| F5-TTS         | 335M     | 4GB          | ✅                 | मल्टी                    | CC-BY-NC 4.0 |

## आवश्यकताएँ

| घटक    | न्यूनतम                   | अनुशंसित          |
| ------ | ------------------------- | ----------------- |
| GPU    | कोई भी जिसमें 3GB VRAM हो | RTX 3060 या बेहतर |
| VRAM   | 3GB                       | 6GB               |
| RAM    | 8GB                       | 16GB              |
| डिस्क  | 2GB                       | 5GB               |
| Python | 3.9+                      | 3.11+             |
| CUDA   | 11.8+                     | 12.0+             |

**Clore.ai सिफारिश:** एक RTX 3060 (~~$0.15–0.30/दिन) पर्याप्त से भी अधिक है। Clore.ai पर सबसे सस्ते GPU इंस्टेंस भी Kani-TTS-2 को आराम से चला पाएंगे। बैच प्रोसेसिंग (ऑडियोबुक, डेटासेट) के लिए, एक RTX 4090 (~~$0.5–2/दिन) उत्कृष्ट थ्रूपुट प्रदान करता है।

## इंस्टॉलेशन

```bash
# पैकेज इंस्टॉल करें
pip install kani-tts-2

# महत्वपूर्ण: संगत transformers संस्करण इंस्टॉल करें (LFM2 आर्किटेक्चर के लिए आवश्यक)
pip install -U "transformers==4.56.0"

# वैकल्पिक: ऑडियो सहेजने के लिए soundfile इंस्टॉल करें
pip install soundfile
```

## त्वरित प्रारम्भ

भाषण उत्पन्न करने के तीन लाइनें:

```python
from kani_tts import KaniTTS

# अंग्रेज़ी मॉडल के साथ इनिशियलाइज़ करें
model = KaniTTS('nineninesix/kani-tts-2-en')

# स्पीच जेनरेट करें
audio, text = model("Hello! Welcome to Kani TTS 2, the next generation of efficient text-to-speech.")

# फ़ाइल में सहेजें
model.save_audio(audio, "output.wav")
```

## उपयोग के उदाहरण

### 1. बेसिक टेक्स्ट-टु-स्पीच

```python
from kani_tts import KaniTTS

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

# कस्टम पैरामीटर्स के साथ जनरेट करें
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. वॉइस क्लोनिंग

किसी छोटे संदर्भ ऑडियो नमूने से किसी भी आवाज़ को क्लोन करें:

```python
from kani_tts import KaniTTS, SpeakerEmbedder

# मॉडल्स इनिशियलाइज़ करें
model = KaniTTS('nineninesix/kani-tts-2-en')
embedder = SpeakerEmbedder()

# संदर्भ ऑडियो से स्पीकर एम्बेडिंग निकालें (3-30 सेकंड की सिफारिश)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# क्लोन की गई आवाज़ में भाषण उत्पन्न करें
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. ऑडियोबुक के लिए बैच जेनरेशन

प्रभावी ढंग से कई अध्याय उत्पन्न करें:

```python
from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

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

# एक नैरेटर वॉइस का उपयोग करें
narrator_emb = embedder.embed_audio_file("narrator_sample.wav")

chapters = [
    "Chapter One. It was a bright cold day in April, and the clocks were striking thirteen.",
    "Chapter Two. The hallway smelt of boiled cabbage and old rag mats.",
    "Chapter Three. Outside, even through the shut window pane, the world looked cold.",
]

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. OpenAI-अनुकूल स्ट्रीमिंग API

रीयल-टाइम अनुप्रयोगों के लिए, OpenAI-अनुकूल सर्वर का उपयोग करें:

```bash
# सर्वर को क्लोन करें
git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git
cd kani-tts-2-openai-server

# निर्भरताएँ इंस्टॉल करें
pip install -r requirements.txt

# सर्वर शुरू करें
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080
```

फिर किसी भी OpenAI TTS क्लाइंट के साथ इसका उपयोग करें:

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

response.stream_to_file("streamed_output.wav")
```

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

1. **इसे चलाना सबसे सस्ता मॉडल है** — 3GB VRAM पर, Kani-TTS-2 वास्तव में Clore.ai पर किसी भी GPU इंस्टेंस पर चलता है। $0.15/दिन की RTX 3060 उत्पादन TTS के लिए अधिक से अधिक पर्याप्त है।
2. **एक भाषा मॉडल के साथ संयोजन करें** — एक GPU इंस्टेंस किराये पर लें और एक छोटा LLM (जैसे Mistral 3 8B) और Kani-TTS-2 दोनों एक साथ चलाएँ ताकि एक पूर्ण वॉइस असिस्टेंट बन सके। वे GPU साझा करेंगे और जगह बचेगी।
3. **स्पीकर एम्बेडिंग्स पहले से कम्प्यूट करें** — स्पीकर एम्बेडिंग्स एक बार निकालकर सहेजें। इससे हर अनुरोध पर WavLM एम्बेडर मॉडल लोड करने की आवश्यकता नहीं होगी।
4. **OpenAI-अनुकूल सर्वर का उपयोग करें** — यह `kani-tts-2-openai-server` OpenAI के TTS API के लिए एक ड्राप-इन प्रतिस्थापन प्रदान करता है, जिससे मौजूदा अनुप्रयोगों के साथ एकीकरण आसान हो जाता है।
5. **कस्टम भाषाओं पर प्रशिक्षण करें** — Kani-TTS-2 में एक पूरा पूर्व-प्रशिक्षण फ्रेमवर्क शामिल है ([kani-tts-2-pretrain](https://github.com/nineninesix-ai/kani-tts-2-pretrain))। अपने स्वयं के भाषा डेटासेट पर मॉडल को फाइन-ट्यून करें — इसके लिए केवल \~6 घंटों के लिए 8× H100s की आवश्यकता होती है।

## समस्याओं का निवारण

| समस्या                                    | समाधान                                                                                                              |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `ImportError: cannot import LFM2`         | सही transformers संस्करण इंस्टॉल करें: `pip install -U "transformers==4.56.0"`                                      |
| ऑडियो गुणवत्ता खराब / रोबोटिक है          | बढ़ाएँ `temperature` को 0.8–0.9 तक; क्लोनिंग के लिए संदर्भ ऑडियो सुनिश्चित करें कि साफ़ हो (कोई पृष्ठभूमि शोर न हो) |
| वॉइस क्लोनिंग संदर्भ जैसी नहीं सुनाई देती | 5–15 सेकंड का स्पष्ट, एकल-भाषी ऑडियो उपयोग करें। संदर्भ में संगीत या पृष्ठभूमि शोर से बचें                          |
| `CUDA में आउट ऑफ मेमोरी`                  | 3GB मॉडल के साथ ऐसा नहीं होना चाहिए — जांचें कि क्या अन्य प्रक्रियाएँ GPU मेमोरी का उपयोग कर रही हैं (`nvidia-smi`) |
| ऑडियो वाक्य के बीच में कट जाता है         | Kani-TTS-2 \~40 सेकंड तक का समर्थन करता है। लंबे टेक्स्ट को वाक्यों में विभाजित करें और आउटपुट को जोड़ें            |
| CPU पर धीमा                               | GPU इन्फरेंस की दृढ़ सिफारिश की जाती है। एक साधारण GPU भी CPU से 10–50× तेज़ है                                     |

## अधिक पढ़ने के लिए

* [GitHub — kani-tts-2](https://github.com/nineninesix-ai/kani-tts-2) — PyPI पैकेज, उपयोग दस्तावेज़, उन्नत उदाहरण
* [HuggingFace — kani-tts-2-en](https://huggingface.co/nineninesix/kani-tts-2-en) — अंग्रेज़ी मॉडल वेट्स
* [पूर्व-प्रशिक्षण फ्रेमवर्क](https://github.com/nineninesix-ai/kani-tts-2-pretrain) — अपना TTS मॉडल शून्य से ट्रेन करें
* [OpenAI-अनुकूल सर्वर](https://github.com/nineninesix-ai/kani-tts-2-openai-server) — OpenAI TTS API के लिए ड्राप-इन प्रतिस्थापन
* [स्पीकर एम्बेडिंग मॉडल](https://huggingface.co/nineninesix/speaker-emb-tbr) — WavLM-आधारित वॉइस एम्बेडर
* [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/) — समुदाय कवरेज