Kani-TTS-2-Stimmklonung

Führe Kani-TTS-2 aus — ein ultraeffizientes Text-to-Speech-Modell mit 400M Parametern und Stimmklonung auf Clore.ai-GPUs

Kani-TTS-2 von nineninesix.ai (veröffentlicht am 15. Februar 2026) ist ein Open-Source-Text-zu-Sprache-Modell mit 400 Mio. Parametern, das hochwertige Sprachsynthese mit nur 3 GB VRAM. Auf Basis der LFM2-Architektur von LiquidAI mit NVIDIA NanoCodec behandelt es Audio als Sprache — und erzeugt natürlich klingende Sprache mit Zero-Shot-Stimmklonen aus einem kurzen Referenzaudioausschnitt. Mit weniger als der halben Größe konkurrierender Modelle und einem Bruchteil des Rechenaufwands ist Kani-TTS-2 perfekt für Echtzeit-Konversations-KI, Hörbucherstellung und Stimmklonen auf günstiger Hardware.

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

Hauptfunktionen

• 400 Mio. Parameter, 3 GB VRAM — läuft auf praktisch jeder modernen GPU, einschließlich RTX 3060

• Zero-Shot-Stimmenklonierung — klone jede Stimme aus einem Referenzaudio von 3–30 Sekunden

• Sprecher-Embeddings — WavLM-basierte 128-dimensionale Sprecherrepräsentationen für präzise Sprachsteuerung

• Bis zu 40 Sekunden kontinuierliches Audio — geeignet für längere Passagen und Dialoge

• Echtzeit oder schneller — RTF ~0,2 auf RTX 5080, in Echtzeit sogar auf günstigen GPUs

• Apache 2.0 — vollständig offen für private und kommerzielle Nutzung

• Pretraining-Framework enthalten — trainiere dein eigenes TTS-Modell von Grund auf in jeder Sprache

Vergleich mit anderen TTS-Modellen

Modell	Parameter	Min. VRAM	Stimmenklonierung	Sprache	Lizenz
Kani-TTS-2	400 Mio.	3GB	✅ Zero-Shot	Englisch (erweiterbar)	Apache 2.0
Kokoro	82 Mio.	2GB	❌ Voreingestellte Stimmen	EN, JP, CN	Apache 2.0
Zonos	400 Mio.	8 GB	✅	Mehrere GPUs	Apache 2.0
ChatTTS	300 Mio.	4 GB	❌ Zufallsseeds	Chinesisch, Englisch	AGPL 3.0
Chatterbox	500 Mio.	6 GB	✅	Englisch	Apache 2.0
XTTS (Coqui)	467 Mio.	6 GB	✅	Mehrere GPUs	MPL 2.0
F5-TTS	335M	4 GB	✅	Mehrere GPUs	CC-BY-NC 4.0

Anforderungen

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Komponente	Minimum	Empfohlen
GPU	Jede mit 3 GB VRAM	RTX 3060 oder besser
VRAM	3GB	6 GB
RAM	8 GB	16 GB
Festplatte	2GB	5 GB
Python	3.9+	3.11+
CUDA	12.8+	12.8+

Clore.ai-Empfehlung: Eine RTX 3060 ($0,03–0,07/Stunde) reicht vollkommen aus. Selbst die günstigsten GPU-Instanzen auf Clore.ai können Kani-TTS-2 problemlos ausführen. Für die Stapelverarbeitung (Hörbücher, Datensätze) bietet eine RTX 4090 ($0,14–0,42/Stunde) einen hervorragenden Durchsatz.

Installation

# Paket installieren
pip install kani-tts-2

# WICHTIG: Kompatible Transformers-Version installieren (erforderlich für die LFM2-Architektur)
pip install -U "transformers==4.56.0"

# Optional: soundfile zum Speichern von Audio installieren
pip install soundfile

Schnellstart

Drei Zeilen, um Sprache zu erzeugen:

from kani_tts import KaniTTS

# Mit dem englischen Modell initialisieren
model = KaniTTS('nineninesix/kani-tts-2-en')

# Sprache erzeugen
audio, text = model("Hallo! Willkommen bei Kani TTS 2, der nächsten Generation effizienter Text-zu-Sprache.")

# In Datei speichern
model.save_audio(audio, "output.wav")

Anwendungsbeispiele

1. Grundlegende Text-zu-Sprache

from kani_tts import KaniTTS

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

# Mit benutzerdefinierten Parametern erzeugen
audio, text = model(
    "Der flinke braune Fuchs springt über den faulen Hund. "
    "Dieser Satz enthält jeden Buchstaben des englischen Alphabets.",
    temperature=0.7,
    top_p=0.9,
    repetition_penalty=1.1
)

model.save_audio(audio, "pangram.wav")
print(f"{len(audio) / 22000:.1f} Sekunden Audio erzeugt")

2. Stimmklonen

Klonen Sie jede Stimme aus einem kurzen Referenzaudioausschnitt:

from kani_tts import KaniTTS, SpeakerEmbedder

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

# Sprecher-Embedding aus Referenzaudio extrahieren (3–30 Sekunden empfohlen)
speaker_embedding = embedder.embed_audio_file("reference_voice.wav")

# Sprache in der geklonten Stimme erzeugen
audio, text = model(
    "Dies ist eine Demonstration des Stimmklonens mit Kani TTS 2. "
    "Die Stimme, die Sie hören, sollte mit dem Referenzaudioausschnitt übereinstimmen.",
    speaker_emb=speaker_embedding
)

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

3. Stapelgenerierung für Hörbücher

Mehrere Kapitel effizient erzeugen:

from kani_tts import KaniTTS, SpeakerEmbedder
import soundfile as sf

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

# Eine Erzählerstimme verwenden
narrator_emb = embedder.embed_audio_file("narrator_sample.wav")

chapters = [
    "Kapitel Eins. Es war ein heller, kalter Apriltag, und die Uhren schlugen dreizehn.",
    "Kapitel Zwei. Der Flur roch nach gekochtem Kohl und alten Fußmatten.",
    "Kapitel Drei. Draußen wirkte selbst durch die geschlossene Fensterscheibe die Welt kalt.",
]

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"Kapitel {i+1} erzeugt")

4. OpenAI-kompatible Streaming-API

Für Echtzeitanwendungen den OpenAI-kompatiblen Server verwenden:

# Server klonen
git clone https://github.com/nineninesix-ai/kani-tts-2-openai-server.git
cd kani-tts-2-openai-server

# Abhängigkeiten installieren
pip install -r requirements.txt

# Server starten
python server.py --model nineninesix/kani-tts-2-en --host 0.0.0.0 --port 8080

Dann mit jedem beliebigen OpenAI-TTS-Client verwenden:

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="Hallo vom OpenAI-kompatiblen Kani-TTS-Server!"
)

response.stream_to_file("streamed_output.wav")

Tipps für Clore.ai-Nutzer

1. Dies ist das günstigste Modell zum Ausführen — Mit 3 GB VRAM läuft Kani-TTS-2 auf buchstäblich jeder GPU-Instanz auf Clore.ai. Eine RTX 3060 für $0,03–0,07/Stunde ist für produktives TTS mehr als ausreichend.

2. Mit einem Sprachmodell kombinieren — Miete eine GPU-Instanz und betreibe gleichzeitig ein kleines LLM (z. B. Mistral 3 8B) und Kani-TTS-2 für einen vollständigen Sprachassistenten. Sie teilen sich die GPU mit reichlich Reserve.

3. Sprecher-Embeddings vorab berechnen — Extrahiere Sprecher-Embeddings einmal und speichere sie. Dadurch entfällt das Laden des WavLM-Embedders bei jeder Anfrage.

4. Den OpenAI-kompatiblen Server verwenden — Der kani-tts-2-openai-server bietet einen direkten Ersatz für die OpenAI-TTS-API und lässt sich dadurch leicht in bestehende Anwendungen integrieren.

5. Auf benutzerdefinierten Sprachen trainieren — Kani-TTS-2 enthält ein vollständiges Pretraining-Framework (kani-tts-2-pretrain). Fine-tune das Modell auf deinem eigenen Sprachdatensatz — dafür brauchst du nur 8× H100s für etwa 6 Stunden.

Fehlerbehebung

Problem	Lösung
ImportError: LFM2 kann nicht importiert werden	Installieren Sie die richtige Transformers-Version: pip install -U "transformers==4.56.0"
Die Audioqualität ist schlecht / klingt robotisch	Erhöhen Sie temperature auf 0,8–0,9; stellen Sie sicher, dass das Referenzaudio für das Klonen sauber ist (kein Hintergrundrauschen)
Stimmklonen klingt nicht wie die Referenz	Verwenden Sie 5–15 Sekunden klares Audio mit nur einer Sprecherstimme. Vermeiden Sie Musik oder Hintergrundrauschen in der Referenz
CUDA-Speicher erschöpft	Sollte bei einem 3-GB-Modell nicht passieren — prüfen Sie, ob andere Prozesse den GPU-Speicher verwenden (nvidia-smi)
Audio bricht mitten im Satz ab	Kani-TTS-2 unterstützt bis zu etwa 40 Sekunden. Teilen Sie längere Texte in Sätze auf und fügen Sie die Ausgaben zusammen
Langsam auf der CPU	GPU-Inferenz wird dringend empfohlen. Selbst eine einfache GPU ist 10–50× schneller als die CPU

Weiterführende Lektüre

• GitHub — kani-tts-2 — PyPI-Paket, Nutzungsdokumentation, fortgeschrittene Beispiele

• HuggingFace — kani-tts-2-en — Gewichte des englischen Modells

• Pretraining-Framework — Trainiere dein eigenes TTS-Modell von Grund auf

• OpenAI-kompatibler Server — Direkter Ersatz für die OpenAI-TTS-API

• Sprecher-Embedding-Modell — WavLM-basierter Stimm-Embeddder

• MarkTechPost-Überblick — Berichterstattung aus der Community