Qwen3-TTS

Qwen3-TTS est un modèle de langage codec à 12 Hz avec un décodeur Mimi pour une synthèse texte-vers-parole de haute qualité. Le modèle est quantifié sur 4 bits et s'exécute plus vite que le temps réel sur Apple Silicon.

Pipeline

La synthèse vocale suit un pipeline en trois étapes :

1. Talker — transformeur à 28 couches qui convertit le texte en tokens du premier codebook à 12,5 Hz
2. Code Predictor — transformeur à 5 couches qui prédit les 15 codebooks restants à partir des états cachés du premier codebook
3. Décodeur codec Mimi — convertit l'ensemble des 16 tokens de codebook en une forme d'onde audio à 24 kHz

Architecture

Talker

Le Talker est le modèle autorégressif principal qui génère les tokens codec à partir du texte d'entrée.

Code Predictor

Un transformeur léger à 5 couches qui prend les états cachés du premier codebook et prédit les 15 codebooks restants en parallèle. Cela évite de faire tourner le Talker complet 16 fois par étape.

Décodeur codec Mimi

Le décodeur Mimi convertit les tokens codec quantifiés en audio :

1. Décodage RVQ (16 codebooks)
2. Pré-convolution (512 vers 1024 canaux)
3. Pré-transformeur (goulot 1024 vers 512, 8 couches, SwiGLU + LayerScale)
4. Sur-échantillonnage (×2, ×2)
5. Décodeur SEANet (étapes de sur-échantillonnage ×8, ×5, ×4, ×3)
6. Sortie de forme d'onde à 24 kHz

Variantes du modèle

Backend CoreML

Le backend CoreML exécute l'intégralité du pipeline Qwen3-TTS sur GPU via Core ML, ce qui permet un déploiement sur iOS et macOS sans dépendance à MLX. Le modèle est découpé en 6 sous-modèles spécialisés optimisés pour la pile de calcul d'Apple :

1. TextProjector — projette les embeddings de tokens de texte dans l'espace caché partagé
2. CodeEmbedder — embarque les tokens du premier codebook et les tokens de contrôle
3. MultiCodeEmbedder — embarque les tokens des codebooks 1 à 15
4. CodeDecoder — transformeur autorégressif à 28 couches avec cache KV sans état (256 positions maximum)
5. MultiCodeDecoder — code predictor à 5 couches pour les codebooks 1 à 15
6. SpeechDecoder — décodeur codec Mimi, convertit 16 tokens de codebook en audio à 24 kHz

# Synthèse CoreML
.build/release/audio speak "Hello, world!" --engine coreml -o hello.wav

# CoreML utilise temperature 0.8 par défaut (requis pour une sortie de qualité)
.build/release/audio speak "Long text here." --engine coreml --temperature 0.9 -o out.wav

Utilisation en CLI

Générez de la parole à partir de texte :

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

Options

Exemples

# Synthèse basique
.build/release/audio speak "The quick brown fox." -o fox.wav

# Sortie en streaming
.build/release/audio speak "Long passage of text..." --stream -o stream.wav

# Synthèse en lot depuis un fichier
.build/release/audio speak --batch-file sentences.txt --batch-size 4 -o output_dir/

Streaming

L'option --stream active la sortie audio fragmentée pendant la génération. Au lieu d'attendre la fin complète de la phrase, l'audio est émis par fragments à mesure que les tokens sont produits. Utilisez --first-chunk-frames et --chunk-frames pour contrôler la taille de chaque fragment.

Mode lot

Pour synthétiser plusieurs énoncés, utilisez --batch-file avec un fichier texte contenant une ligne par énoncé. L'option --batch-size contrôle combien d'énoncés sont traités en parallèle.

Performance

Sur un M2 Max, Qwen3-TTS atteint un RTF (facteur temps réel) d'environ 0,55, ce qui signifie qu'il génère de la parole plus vite que le temps réel. Avec un préchauffage compile(), chaque étape prend environ 37 ms.

Langues

Qwen3-TTS prend en charge la synthèse texte-vers-parole multilingue. Le modèle détecte automatiquement la langue d'entrée et génère la parole en conséquence.

API Swift

import Qwen3TTS

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