Qwen3-TTS

Qwen3-TTS ist ein 12-Hz-Codec-Sprachmodell mit Mimi-Decoder für hochwertige Sprachsynthese. Das Modell ist 4-Bit-quantisiert und läuft schneller als Echtzeit auf Apple Silicon.

Pipeline

Die Sprachsynthese folgt einer dreistufigen Pipeline:

  1. Talker — 28-lagiger Transformer, der Eingabetext in First-Codebook-Tokens mit 12,5 Hz umwandelt
  2. Code Predictor — 5-lagiger Transformer, der die verbleibenden 15 Codebooks aus den Hidden States des ersten Codebooks vorhersagt
  3. Mimi-Codec-Decoder — Wandelt alle 16 Codebook-Tokens in eine 24-kHz-Audiowellenform um

Architektur

Talker

Der Talker ist das zentrale autoregressive Modell, das aus Texteingaben Codec-Tokens erzeugt.

ParameterWert
Schichten28
Hidden-Dimension1024
Query-Heads16
Key/Value-Heads8 (GQA)
MLPSwiGLU
PositionskodierungRoPE

Code Predictor

Ein leichtgewichtiger 5-lagiger Transformer, der die Hidden States des ersten Codebooks nimmt und die verbleibenden 15 Codebooks parallel vorhersagt. Das vermeidet, den vollen Talker pro Schritt 16 Mal auszuführen.

Mimi-Codec-Decoder

Der Mimi-Decoder wandelt quantisierte Codec-Tokens zurück in Audio:

  1. RVQ-Decode (16 Codebooks)
  2. Pre-Convolution (512 auf 1024 Kanäle)
  3. Pre-Transformer (1024 auf 512 Bottleneck, 8 Schichten, SwiGLU + LayerScale)
  4. Upsampling (2x, 2x)
  5. SEANet-Decoder (Upsample-Stufen 8x, 5x, 4x, 3x)
  6. 24-kHz-Wellenform-Ausgabe

Modellvarianten

ModellGrößeHuggingFace
Qwen3-TTS-0.6B Base (4-bit)1,7 GBaufklarer/Qwen3-TTS-12Hz-0.6B-Base-MLX-4bit
Qwen3-TTS-0.6B Base (8-bit)2,4 GBaufklarer/Qwen3-TTS-12Hz-0.6B-Base-MLX-8bit
Qwen3-TTS-0.6B CustomVoice (4-bit)1,7 GBaufklarer/Qwen3-TTS-12Hz-0.6B-CustomVoice-MLX-4bit
Qwen3-TTS-1.7B Base (4-bit)3,2 GBaufklarer/Qwen3-TTS-12Hz-1.7B-Base-MLX-4bit
Qwen3-TTS-1.7B Base (8-bit)4,8 GBaufklarer/Qwen3-TTS-12Hz-1.7B-Base-MLX-8bit
Qwen3-TTS CoreML (FP16)2,1 GBaufklarer/Qwen3-TTS-CoreML

CoreML-Backend

Das CoreML-Backend führt die vollständige Qwen3-TTS-Pipeline über Core ML auf der GPU aus und ermöglicht damit die Bereitstellung auf iOS und macOS ohne MLX-Abhängigkeiten. Das Modell ist in 6 spezialisierte Submodelle aufgeteilt, optimiert für Apples Compute-Stack:

  1. TextProjector — Projiziert Text-Token-Embeddings in den gemeinsamen Hidden-Raum
  2. CodeEmbedder — Bettet First-Codebook-Tokens und Kontroll-Tokens ein
  3. MultiCodeEmbedder — Bettet Tokens aus den Codebooks 1–15 ein
  4. CodeDecoder — 28-lagiger autoregressiver Transformer mit zustandslosem KV-Cache (max. 256 Positionen)
  5. MultiCodeDecoder — 5-lagiger Code-Predictor für Codebooks 1–15
  6. SpeechDecoder — Mimi-Codec-Decoder, wandelt 16 Codebook-Tokens in 24-kHz-Audio um
# CoreML-Synthese
.build/release/audio speak "Hello, world!" --engine coreml -o hello.wav

# CoreML verwendet standardmäßig Temperatur 0.8 (für qualitativ hochwertige Ausgabe erforderlich)
.build/release/audio speak "Long text here." --engine coreml --temperature 0.9 -o out.wav
CoreML-KV-Cache-Limit

Der CoreML-CodeDecoder verwendet einen festen KV-Cache mit 256 Positionen. Längere Passagen sollten in einzelne Sätze aufgeteilt werden. Decode-Tokens werden automatisch auf die nach dem Prefill verbleibenden Cache-Slots begrenzt.

CLI-Verwendung

Sprache aus Text erzeugen:

.build/release/audio speak "Hello, world!" --output hello.wav

Optionen

SchalterBeschreibung
--engineTTS-Engine: qwen3 (MLX, Standard), coreml (CoreML/GPU) oder cosyvoice
--output, -oPfad der Ausgabe-WAV-Datei
--languageSprache (Standard: english). Weglassen, um den nativen Dialekt des Sprechers zu verwenden.
--modelModellvariante: base oder customVoice
--speakerSprecherstimme (benötigt --model customVoice)
--temperatureSampling-Temperatur (Standard: 0.3)
--top-kTop-k-Sampling-Parameter
--max-tokensMaximale Anzahl zu erzeugender Tokens (Standard: 500)
--streamStreaming aktivieren — gibt Audio-Chunks während der Erzeugung aus
--first-chunk-framesAnzahl der Frames im ersten gestreamten Chunk
--chunk-framesAnzahl der Frames pro nachfolgendem gestreamtem Chunk
--batch-filePfad zu einer Textdatei mit einer Äußerung pro Zeile für Stapelsynthese
--batch-sizeAnzahl paralleler Äußerungen im Stapelmodus

Beispiele

# Grundlegende Synthese
.build/release/audio speak "The quick brown fox." -o fox.wav

# Streaming-Ausgabe
.build/release/audio speak "Long passage of text..." --stream -o stream.wav

# Stapelsynthese aus Datei
.build/release/audio speak --batch-file sentences.txt --batch-size 4 -o output_dir/

Streaming

Der Schalter --stream aktiviert die gestückelte Audio-Ausgabe während der Erzeugung. Statt auf den Abschluss der kompletten Äußerung zu warten, wird Audio als Chunks ausgegeben, während Tokens produziert werden. Verwende --first-chunk-frames und --chunk-frames, um die Chunk-Größe zu steuern.

Stapelmodus

Zum Synthetisieren mehrerer Äußerungen verwende --batch-file mit einer Textdatei, die eine Äußerung pro Zeile enthält. Der Schalter --batch-size steuert, wie viele Äußerungen parallel verarbeitet werden.

Leistung

Auf einem M2 Max erreicht Qwen3-TTS einen RTF (Echtzeitfaktor) von ungefähr 0,55, d. h. es erzeugt Sprache schneller als Echtzeit. Mit compile()-Aufwärmen dauert jeder Schritt etwa 37 ms.

Sicherheitsgrenze

Das Standardmaximum liegt bei 500 Tokens, was bei 12,5 Hz ungefähr 40 Sekunden Audio ergibt. Höhere Werte riskieren ein Überschreiten des Metal-GPU-Watchdog-Timeouts, was auf Apple Silicon einen Systemneustart auslösen kann, da sich die GPU den Compositor teilt.

Sprachen

Qwen3-TTS unterstützt mehrsprachige Sprachsynthese. Das Modell erkennt automatisch die Eingabesprache und erzeugt entsprechend Sprache.

Swift-API

import Qwen3TTS

let model = try await Qwen3TTSModel.loadFromHub()
let audio = try await model.speak("Hello, world!")
try audio.write(to: "hello.wav")