Lure-TTS und Lure Turbo: 600M-Sprachmodelle mit Tags und Stimmklonen

Ein Entwickler hat Qwen3-TTS (0,6 Mrd. Parameter) per Reinforcement Learning und Distillation zu Lure und Lure Turbo weitertrainiert. Die Modelle verstehen Tags wie (laugh), Regieanweisungen und klonen Stimmen, das Turbo-Modell läuft rund 4x schneller als Echtzeit. Das gesamte Training kostete laut Autor unter 200 US-Dollar.

Modell-Releases Selbst ausprobieren 25. Okt. 2026 4 Min. Lesezeit Quelle: r/LocalLLaMA

Worum es geht

Der Entwickler „smirkishere“ hat auf r/LocalLLaMA zwei kleine Sprachsynthese-Modelle (TTS, Text-to-Speech) vorgestellt: Lure und Lure Turbo. Beide sind Feinabstimmungen von Qwen3-TTS-12Hz-0.6B-Base, einem Modell mit etwa 600 Millionen Parametern (Parameter – grob gesagt die Stellschrauben, die ein Modell beim Training gelernt hat). Sie können Text mit eingebetteten Tags wie (laugh) sprechen, folgen Regieanweisungen wie „warm, amused“ und klonen Stimmen anhand einer Referenzaufnahme. Veröffentlicht wurden der Trainingscode (Repo smirki/lure-train, Apache-2.0) und eine eigene Inferenz-Engine namens Lure-TTS. Die Angaben zu Tempo und Qualität stammen vom Autor selbst und wurden nicht unabhängig geprüft. Aus der Quelle geht nicht eindeutig hervor, wo genau die Modellgewichte liegen; verlinkt sind Code und Engine.

Motivation

Der Autor wollte ein schnelles, kleines TTS-Modell, das als Sprachassistent angenehm klingt und keine große GPU braucht. Das Basismodell Qwen3-TTS las Tags wie (laugh) einfach vor, statt sie umzusetzen. Das sollte das Training beheben.

Wie das Training funktioniert

Die Pipeline läuft komplett auf der Cloud-Plattform Modal:

Datenbereinigung: Der Autor trainierte Klassifikatoren für Intensität, Ereignisse (Lachen, Weinen, Seufzen, Schlucken), Emotion und Richtung. Damit säuberte er Daten aus YODAS und dem Open-Yap-Sample.
SFT (Supervised Fine-Tuning – Training an Beispielpaaren aus Text und Audio): Das Modell lernt, Tags umzusetzen. Das Manifest ist eine jsonl-Datei mit Audiopfad, Text mit Tags, Sprecher und Richtung. Der Verlust ist Cross-Entropy auf Codebook 0 plus 0,5-mal der Mittelwert über die Codebooks 1–15 (Codebook – eine der parallelen Tabellen diskreter Audio-Codes).
Spezialisten-Zweige mit GRPO: Pro Fähigkeit wird ein „Lehrer“ per Dr.GRPO trainiert (Reinforcement Learning mit überprüfbaren Belohnungen). Der Zweig V belohnt Stimmähnlichkeit (ECAPA und WavLM-SV), Zweig R Robustheit und lange Texte (30–75 s) über niedrige Wortfehlerrate (WER). Die WER ist der Mittelwert aus Qwen3-ASR-1.7B und Granite Speech 5. Fehlerhafte Aufnahmen, etwa ohne Endmarke oder mit Wortschleifen, bekommen eine feste niedrige Belohnung. Gruppengröße 8, 16 Prompts pro Schritt, KL-Strafe beta 0,1. Emotions- und Event-Zweige sind geplant.
Destillation (OPD): Die Lehrer werden per On-Policy-Distillation in ein Modell zurückgeführt. Dabei erzeugt der Schüler selbst Audio, und der Lehrer bewertet jeden Code. Die Alternative ist ein einfacher Task-Vector-Merge (merge.py). Laut Autor gefiel ihm am Ende der Sprecherähnlichkeits-Lehrer am besten; Lure entspricht V-Schritt 150.

Lure Turbo: schneller durch weniger Durchläufe

Der Standard-Code-Predictor braucht 15 sequenzielle Durchläufe pro 80-ms-Frame. Ein erster Versuch mit einem 300M-Modell mit 12 Schichten klang laut Autor nur „okayish“ und dünn. Besser funktionierte es, den Code-Predictor auf 3 Durchläufe zu verkürzen: Codebooks 1–3, 4–7 und 8–15 werden gruppiert. Der Kopf V2s ergänzt ein kleines MLP, das Codebooks innerhalb einer Gruppe nacheinander samplet. Er wird zunächst gegen den Standard-Predictor aufgewärmt und dann per OPD gegen das volle Lure-Modell trainiert (120 Schritte mit je 16 On-Policy- und 8 Anker-Clips; Talker-Lernrate 2e-6, Kopf 3e-5).

Zahlen

Messung	Wert (Herstellerangabe)
RTF Lure Turbo	0,14
RTF Fish S2 Pro (5B)	0,195
Sprecherähnlichkeit (ECAPA)	0,699, gleich zu Fish S2 Pro
Trainingskosten	unter 200 US-Dollar

RTF (Real-Time-Factor) ist die Rechenzeit geteilt durch die Audiodauer; 0,14 bedeutet etwa 7-fach schneller als Echtzeit, der Titel nennt „4x“. Die Tests liefen auf H100-GPUs.

Die Lure-TTS-Engine

Die Engine basiert auf faster-qwen3-tts (CUDA), mlx-audio (Mac) und audio.cpp (CPU). Sie bietet eine Python-API, ein CLI und einen OpenAI-kompatiblen Server und läuft mit Lure, Lure Turbo und allen Qwen3-TTS-12Hz-Checkpoints. Auf einer RTX 4090 kommt das erste Audio laut Autor nach 0,17 s statt 10,6 s mit dem Referenzcode; der RTF liegt bei 0,53 statt 2,54 (rund 5x schneller). Möglich machen das 0,32-s-Streaming-Chunks, CUDA-Graphs und Batching von bis zu 8 Anfragen.

Was du zum Ausprobieren brauchst

Der Download ist 2,5 GB groß (Lure Turbo 2,7 GB). Zum Ausführen brauchst du rund 4 GB VRAM. Das ist berechnet, die Entwickler nennen keine Mindestzahl, nur dass eine 24-GB-Karte acht Stimmen gleichzeitig schafft. Offiziell getestet sind NVIDIA-Karten ab der Ampere-Generation (RTX 30er und neuer); auf älteren Karten ohne bf16 wie der T4 läuft es langsamer als Echtzeit. Auf Macs mit Apple-Chip läuft es über MLX (M5 mit 16 GB: etwas schneller als Echtzeit), auf reiner CPU nur sehr langsam. Windows ist laut Entwicklern noch nicht getestet. Die Schritt-für-Schritt-Anleitung für alle drei Systeme findest du unten. Zum eigenen Training brauchst du ein Modal-Konto (Autor: RTX PRO 6000).

Einordnung

Das Projekt zeigt, dass Methoden wie RLVR und On-Policy-Distillation auch mit kleinem Budget ein Open-Source-TTS spürbar verbessern. Praktisch interessant ist die Kombination aus Tags, Regieanweisung und Cloning in einem 0,6B-Modell. Kritisch: Alle Benchmarks sind Selbstauskünfte eines Einzelnen, es gibt keine Hörtests, und der Autor sagt selbst, er lerne noch. Tags wie (laugh: big) oder (whispering) funktionieren auf langen Zeilen noch nicht gut, freie Paraphrasen und Emotionswechsel fehlen. Der Vergleich mit Fish S2 Pro bezieht sich auf Tempo und ECAPA, nicht auf Natürlichkeit. Der Autor sucht Helfer für Hörbewertungen und Rechenleistung.

Begriffe einfach erklärt

TTS: Text-to-Speech: Software, die geschriebenen Text in gesprochene Sprache umwandelt.
RTF: Real-Time-Factor: Rechenzeit geteilt durch die Länge des erzeugten Audios. Unter 1 ist schneller als Echtzeit.
GRPO: Eine Reinforcement-Learning-Methode: Das Modell erzeugt mehrere Versuche, und bessere als der Gruppendurchschnitt werden belohnt.
On-Policy-Distillation (OPD): Ein Schüler-Modell erzeugt selbst Ausgaben, und ein Lehrer-Modell bewertet sie. So übernimmt der Schüler dessen Fähigkeiten.
Voice Cloning: Das Nachahmen einer Stimme anhand einer kurzen Referenzaufnahme.
WER: Wortfehlerrate: Anteil der Wörter, die eine Spracherkennung im erzeugten Audio falsch versteht.
ECAPA: Ein Sprecher-Erkennungsmodell, dessen Ähnlichkeitswert misst, wie sehr zwei Stimmen gleich klingen.

Quellen

r/LocalLLaMA github.com

#tts#sprachsynthese#qwen3-tts#voice-cloning#reinforcement-learning#open-source

Originalquelle lesen

Selbst ausprobieren: Lure-TTS / Lure Turbo

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

Du kannst Text in natürliche Sprache umwandeln, mit Inline-Tags wie (laugh) und Regieanweisungen wie „warm, amused“. Außerdem kannst du Stimmen aus einer Referenzaufnahme klonen. Lokal läuft das als Python-API, CLI oder OpenAI-kompatibler Server.

Für wen lohnt es sich?

Interessant für Bastler, die einen schnellen lokalen Sprachassistenten oder Vorlese-Tools bauen wollen. Weniger geeignet, wenn du ein ausgereiftes, fertig verpacktes Produkt erwartest.

Größe0,9 Mrd. Parameter

Download2,5 GB (bei 100 MBit/s ca. 3 Min.)

Lizenzapache-2.0

ArtSprachausgabe (Text zu Sprache)

Hugging FaceTesslate/Lure-TTS-0.6B

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 4 GB VRAMBerechnet, nicht gemessen: Die Gewichte sind zusammen 2,5 GB groß (2,5 × 1,2 + 1 ≈ 4 GB). Mehr Speicher erlaubt mehrere gleichzeitige Stimmen; eine 24-GB-Karte schafft laut Hersteller 8 Streams. Auf dem Mac teilen sich Programm und Modell den normalen Arbeitsspeicher. Ohne Grafikkarte geht es nur sehr langsam (etwa 6,6-fach langsamer als Echtzeit).

Mac (Apple Silicon M1–M5) ab 8 GB gemeinsamer SpeicherGrafik und Prozessor teilen sich den Speicher – etwa 70 % davon kann das Modell nutzen

Speicherplatz ca. 4,5 GB freiModell-Download plus Programme

Im Browser Online-Demo vorhandenauf Hugging Face ausprobieren, ganz ohne Installation

Lure Turbo ist die schnellere Variante für Echtzeit-Assistenten; Lure ist das Basismodell mit dem vollen 15-Pass-Predictor. Beide haben 0,6B Parameter.

Die Engine unterstützt NVIDIA-GPUs über CUDA, Macs über mlx-audio und reine CPU über audio.cpp.
Auf einer RTX 4090 kommt das erste Audio nach 0,17 s (Herstellerangabe).
Batching von bis zu 8 gleichzeitigen Anfragen ist möglich.
Für das Training nutzte der Autor Modal mit einer RTX PRO 6000.

Wie finde ich heraus, was mein Rechner hat?

Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler (smirki/lure-tts auf GitHub). Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Im Browser (ohne Installation)

Die Entwickler haben eine Online-Demo auf Hugging Face. Dort kannst du das Modell sofort ausprobieren, ohne etwas zu installieren. Manchmal musst du kurz warten, bis die Demo aufgewacht ist.

Online-Demo öffnen

Windows 10 / 11

Windows 10 / 11: nicht offiziell getestet. Windows wurde laut Quelle noch nicht getestet. Diese Anleitung nutzt den PyTorch-Weg über qwen-tts mit NVIDIA-Grafikkarte, hier ohne Turbo und ohne Regie-Anweisung. Alternativ: die Online-Demo im Hugging-Face-Space smirki/lure-tts oder WSL2 mit den Linux-Schritten.

Voraussetzungen prüfen. Du brauchst Python 3 (ab etwa 3.10), Git und eine NVIDIA-Grafikkarte mit aktuellem Treiber. Öffne PowerShell und prüfe die Installation mit den Befehlen.
```
python --version
git --version
nvidia-smi
```
Ordner und Umgebung anlegen. Lege einen leeren Ordner an und darin eine virtuelle Umgebung. Die hält alle Pakete getrennt vom Rest deines PCs.
```
mkdir lure; cd lure
python -m venv .venv
.venv\Scripts\Activate.ps1
```
PyTorch installieren. PyTorch ist die Rechenbibliothek, die das Modell auf der Grafikkarte ausführt. Der Download ist groß und dauert.
```
pip install torch --index-url https://download.pytorch.org/whl/cu128
```
Programmpakete installieren. Installiere qwen-tts, das Lure laden kann, und soundfile zum Speichern der Audiodatei. Außerdem das Hilfsprogramm zum Modell-Download.
```
pip install qwen-tts soundfile huggingface_hub
```
Referenz-Stimme bereitstellen. Lure klont eine Stimme. Nimm 3 bis 12 Sekunden deiner Stimme auf Englisch auf, ohne Musik, und speichere sie als reference.wav in diesem Ordner. Schreibe auf, was genau gesagt wird. Stimmt der Text nicht, werden Wörter ausgelassen oder wiederholt.

Skript speichern. Speichere diesen Code als demo.py im Ordner. Trage bei ref_text die genauen Worte deiner Aufnahme ein. Das Modell wird beim ersten Start automatisch heruntergeladen (ca. 2,5 GB).

import soundfile as sf
from qwen_tts import Qwen3TTSModel

tts = Qwen3TTSModel.from_pretrained("Tesslate/Lure-TTS-0.6B", device_map="cuda:0", dtype="bfloat16")
wavs, sr = tts.generate_voice_clone(
    text="I'm sorry. (sigh) I never meant for any of this to happen.",
    language="English",
    ref_audio="reference.wav",
    ref_text="Transcript of the reference clip.",
    non_streaming_mode=True,
)
sf.write("out.wav", wavs[0], sr)

Starten. Starte das Skript. Der Text in Klammern, hier (sigh), wird als Seufzer gespielt und nicht vorgelesen.
```
python demo.py
```
Ergebnis. Im Ordner liegt die Datei hello.wav (bzw. out.wav unter Windows) mit deiner geklonten Stimme, die den englischen Satz inklusive Lachen oder Seufzer spricht.

macOS

macOS: unterstützt. Auf Macs mit Apple-Chip (M1 oder neuer) läuft das Modell über das mlx-Backend, auf einem M5 mit 16 GB etwa in Echtzeit (RTF 0,79). Intel-Macs sind in der Quelle nicht genannt. Die Stimmähnlichkeit liegt auf dem Mac etwas unter der Referenz.

Voraussetzungen prüfen. Du brauchst einen Mac mit Apple-Chip, Python 3 und Git. Installiere die Xcode-Kommandozeilentools, falls sie fehlen. Öffne dazu das Terminal.
```
xcode-select --install
python3 --version
git --version
```
Programm herunterladen. Lade das Lure-Programm von GitHub herunter und wechsle in den Ordner. Alle weiteren Befehle laufen in diesem Ordner.
```
git clone https://github.com/smirki/lure-tts && cd lure-tts
```
Umgebung anlegen. Eine virtuelle Umgebung hält alle Pakete getrennt vom Rest deines Macs. Aktiviere sie.
```
python3 -m venv .venv && source .venv/bin/activate
```
Programm installieren. Das installiert Lure mit dem mlx-Backend (Apples Rechenbibliothek) und dem Server-Zubehör.
```
pip install ./backends/mlx ".[server]"
```
Modell herunterladen. Das lädt die Modelldateien (ca. 2,5 GB) in den Ordner models/lure. Falls der Befehl hf fehlt, installiere vorher huggingface_hub mit pip.
```
pip install huggingface_hub
hf download Tesslate/Lure-TTS-0.6B --local-dir models/lure
```
Referenz-Stimme bereitstellen. Lure klont eine Stimme. Nimm 3 bis 12 Sekunden deiner Stimme auf Englisch auf, ohne Musik, und speichere sie als ref.wav im Ordner lure-tts. Schreibe genau auf, was gesagt wird. Ein falscher Text führt zu ausgelassenen Wörtern.
Erste Sprachausgabe erzeugen. Setze den Modellpfad und erzeuge die Datei. Ersetze den Text bei --ref-text durch deinen echten Satz. (laugh) wird als Lachen gespielt.
```
export LURE_MODEL=models/lure
lure say "Hello there. (laugh) Okay." --ref-wav ref.wav --ref-text "Transcript of ref.wav." --save-voice me -o hello.wav
```
Gleiche Stimme erneut nutzen. Die Stimme ist jetzt unter dem Namen me gespeichert und muss nicht neu berechnet werden.
```
lure say "Same voice, no re-encoding." --voice me -o again.wav
```
Ergebnis. Im Ordner liegt die Datei hello.wav (bzw. out.wav unter Windows) mit deiner geklonten Stimme, die den englischen Satz inklusive Lachen oder Seufzer spricht.

Linux

Linux: unterstützt. Das cuda-Backend ist mit echten Gewichten geprüft und braucht eine NVIDIA-Karte ab Ampere (z. B. RTX 30er). Auf einer T4 läuft es langsamer als Echtzeit. Ohne NVIDIA-Karte gibt es einen CPU-Build (C++), der aber sehr langsam ist.

Voraussetzungen prüfen. Du brauchst Python 3 (ab etwa 3.10), Git und eine NVIDIA-Karte ab Ampere mit installiertem Treiber. Prüfe es im Terminal.
```
python3 --version
git --version
nvidia-smi
```
Programm herunterladen. Lade das Lure-Programm von GitHub herunter und wechsle in den Ordner. Alle weiteren Befehle laufen dort.
```
git clone https://github.com/smirki/lure-tts && cd lure-tts
```
Umgebung anlegen. Eine virtuelle Umgebung hält alle Pakete getrennt vom Rest des Systems. Aktiviere sie.
```
python3 -m venv .venv && source .venv/bin/activate
```

Programm installieren. Erst PyTorch für CUDA, dann die Pakete des cuda-Backends. Das dauert einige Minuten. Die Option --no-deps lässt unnötige Zusatzpakete weg.

pip install torch --index-url https://download.pytorch.org/whl/cu128
pip install -r backends/cuda/requirements.txt
pip install --no-deps qwen-tts-hf==0.1.1.post1
pip install ".[server]" && pip install --no-deps ./backends/cuda

Modell herunterladen. Das lädt die Modelldateien (ca. 2,5 GB) nach models/lure. Falls hf fehlt, installiere vorher huggingface_hub.
```
pip install huggingface_hub
hf download Tesslate/Lure-TTS-0.6B --local-dir models/lure
```
Referenz-Stimme bereitstellen. Lure klont eine Stimme. Nimm 3 bis 12 Sekunden deiner Stimme auf Englisch auf, ohne Musik, und speichere sie als ref.wav im Ordner lure-tts. Schreibe genau auf, was gesagt wird, sonst werden Wörter ausgelassen.
Erste Sprachausgabe erzeugen. Setze den Modellpfad und erzeuge die Datei. Ersetze den Text bei --ref-text durch deinen echten Satz. (laugh) wird als Lachen gespielt.
```
export LURE_MODEL=models/lure
lure say "Hello there. (laugh) Okay." --ref-wav ref.wav --ref-text "Transcript of ref.wav." --save-voice me -o hello.wav
```
Ergebnis. Im Ordner liegt die Datei hello.wav (bzw. out.wav unter Windows) mit deiner geklonten Stimme, die den englischen Satz inklusive Lachen oder Seufzer spricht.

Das kannst du ausprobieren

Okay (laugh) du hast mich erwischt.

(whispering) Ich verrate dir ein Geheimnis, aber sag es niemandem weiter.

Willkommen zurück! Heute ist das Wetter richtig gut, wollen wir einen Spaziergang planen?

Wenn es hakt

Die Modellgewichte und das Hugging-Face-Repo sind in der Quelle nicht genannt; prüfe das Repo smirki/lure-tts.

Tags wie (laugh: big) oder (whispering) funktionieren auf langen Zeilen laut Autor noch nicht zuverlässig.

Die Modelle wurden vor allem für Englisch trainiert (YODAS); deutsche Qualität ist unbelegt.

Auf der CPU ist die Ausgabe deutlich langsamer als auf GPU.

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: apache-2.0.

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.