Kani-TTS-2 Stimmklonen

Kani-TTS-2 ausführen — ein hocheffizientes 400M-Parameter Text-to-Speech-Modell mit Stimmklon-Funktion 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 Millionen Parametern, das hochauflösende Sprachsynthese erreicht und dabei nur 3 GB VRAM. Basierend auf LiquidAI's LFM2-Architektur mit NVIDIA NanoCodec behandelt es Audio wie eine Sprache — es erzeugt natürlich klingende Sprache mit Zero-Shot-Stimmenklonung aus einem kurzen Referenz-Audioclip. Bei weniger als der Hälfte der Größe konkurrierender Modelle und einem Bruchteil des Rechenaufwands ist Kani-TTS-2 ideal für Echtzeit-Konversations-KI, Hörbucherzeugung und Stimmenklonung auf sparsamer Hardware.

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

Hauptmerkmale

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

• Zero-Shot-Stimmenklonung — klont jede Stimme aus einer 3–30 Sekunden langen Referenz-Audioprobe

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

• 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 persönliche und kommerzielle Nutzung

• Pretraining-Framework enthalten — trainiere dein eigenes TTS-Modell von Grund auf für jede Sprache

Vergleich mit anderen TTS-Modellen

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

Anforderungen

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

Clore.ai-Empfehlung: Eine RTX 3060 ($0.15–0.30/Tag) ist mehr als ausreichend. Selbst die günstigsten GPU-Instanzen auf Clore.ai laufen Kani-TTS-2 problemlos. Für Batch-Verarbeitung (Hörbücher, Datensätze) bietet eine RTX 4090 ($0.5–2/Tag) ausgezeichneten Durchsatz.

Installation

# Paket installieren
pip install kani-tts-2

# WICHTIG: Kompatible Transformers-Version installieren (erforderlich für 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 generieren
audio, text = model("Hello! Welcome to Kani TTS 2, the next generation of efficient text-to-speech.")

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

Beispielanwendungen

1. Grundlegendes Text-zu-Sprache

from kani_tts import KaniTTS

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

# Mit benutzerdefinierten Parametern erzeugen
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. Stimmenklonung

Klone jede Stimme aus einer kurzen Referenz-Audioprobe:

from kani_tts import KaniTTS, SpeakerEmbedder

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

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

# Sprache in der geklonten Stimme erzeugen
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. Batch-Erzeugung 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 Tag im April, und die Uhren schlugen dreizehn.",
    "Kapitel Zwei. Der Flur roch nach gekochtem Kohl und alten Lumpenteppichen.",
    "Kapitel Drei. Draußen, selbst durch die geschlossene Fensterscheibe, wirkte 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"Generated chapter {i+1}")

4. OpenAI-kompatible Streaming-API

Für Echtzeitanwendungen verwende den OpenAI-kompatiblen Server:

# 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

Verwende ihn dann mit jedem OpenAI-TTS-Client:

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")

Tipps für Clore.ai-Nutzer

1. Dies ist das günstigste Modell zum Betreiben — Mit 3GB VRAM läuft Kani-TTS-2 buchstäblich auf jeder GPU-Instanz bei Clore.ai. Eine RTX 3060 für $0.15/Tag ist mehr als ausreichend für Produktions-TTS.

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

3. Sprecher-Embeddings vorab berechnen — Extrahiere Sprecher-Embeddings einmal und speichere sie. So muss das WavLM-Embedder-Modell nicht bei jeder Anfrage geladen werden.

4. Verwende den OpenAI-kompatiblen Server — Der kani-tts-2-openai-server bietet einen Drop-in-Ersatz für OpenAIs TTS-API und erleichtert die Integration in bestehende Anwendungen.

5. Auf benutzerdefinierte Sprachen trainieren — Kani-TTS-2 enthält ein vollständiges Pretraining-Framework (kani-tts-2-pretrain). Feintune das Modell auf deinem eigenen Sprachdatensatz — es benötigt nur 8× H100s für ~6 Stunden.

Fehlerbehebung

Problem	Lösung
ImportError: kann LFM2 nicht importieren	Installiere die korrekte Transformers-Version: pip install -U "transformers==4.56.0"
Audioqualität ist schlecht / robotisch	Erhöhen Sie temperature auf 0.8–0.9; stelle sicher, dass Referenzaudio für das Klonen sauber ist (kein Hintergrundgeräusch)
Die Stimmenklonung klingt nicht wie die Referenz	Verwende 5–15 Sekunden klares, einsprachiges Audio. Vermeide Musik oder Hintergrundgeräusche in der Referenz
CUDA out of memory	Sollte beim 3GB-Modell nicht passieren — prüfe, ob andere Prozesse GPU-Speicher nutzen (nvidia-smi)
Audio bricht mitten im Satz ab	Kani-TTS-2 unterstützt bis zu ~40 Sekunden. Teile längere Texte in Sätze auf und füge 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, erweiterte Beispiele

• HuggingFace — kani-tts-2-en — Englische Modellgewichte

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

• OpenAI-kompatibler Server — Drop-in-Ersatz für OpenAI TTS-API

• Sprecher-Embedding-Modell — WavLM-basiertes Voice-Embedder

• MarkTechPost-Übersicht — Community-Berichterstattung