Architecture

TTS natif par instructions

Compilez le SDK natif depuis les sources de main. Homebrew et les autres distributions CLI précompilées peuvent ne pas encore inclure ces moteurs.

Implémentation (PR #541): main

Bundles MLX publiés: aufklarer/FireRedTTS3-Instruct-MLX-fp32 · aufklarer/MOSS-VoiceGenerator-MLX-bf16

FireRedTTS3-Instruct — FireRedTTS3TTS: FireRedTTS3-Instruct conserve les poids Float32 du modèle et du décodeur. Il renvoie l’audio complet en mémoire : omettez --stream. --language accepte les alias anglais et chinois. Une limite de génération produit une erreur plutôt qu’un succès tronqué.

MOSS-VoiceGenerator — MossVoiceGeneratorTTS: MOSS-VoiceGenerator conserve les poids de langage BF16 et le codec de synthèse FP32. Utilisez --stream pour le PCM progressif. Omettez --language et précisez la langue dans --instruct. La fin vide les seize livres de codes.

Les champs texte et instruction sont limités chacun à 32 768 octets UTF-8. Le prompt d’entrée complet, modèle inclus, doit tenir dans 4 096 tokens après rendu. Les entrées dépassant une limite sont rejetées.

Le suivi des instructions n’a pas encore été noté. Les mesures sur textes courts décrivent la configuration testée ; la certification de régression de latence reste non concluante.

speech speak "The quick brown fox jumps over the lazy dog." --engine breeze \
  --instruct "A clear, calm English narrator." --stream -o design.wav

speech-swift est organisé comme un package Swift modulaire avec des protocoles partagés, des modules de modèles indépendants et une CLI unifiée. Toute l'inférence s'exécute sur l'appareil en utilisant MLX (GPU Metal) ou CoreML (Neural Engine).

Graphe de dépendances des modules

                    ┌──────────┐
                    │ AudioCLI │  (point d'entrée)
                    └────┬─────┘
                         │
                  ┌──────┴──────┐
                  │ AudioCLILib │  (commandes)
                  └──────┬──────┘
                         │
       ┌─────────┬───────┼───────┬──────────┬──────────────┐
       │         │       │       │          │              │
  ┌────┴───┐ ┌──┴──┐ ┌──┴──┐ ┌─┴────┐ ┌───┴────┐ ┌──────┴───────┐
  │Qwen3ASR│ │Qwen3│ │Cosy │ │Perso-│ │Speech- │ │  Speech-     │
  │Parakeet│ │ TTS │ │Voice│ │naPlex│ │  VAD   │ │Enhancement   │
  └────┬───┘ └──┬──┘ └──┬──┘ └──┬───┘ └───┬───┘ └──────┬───────┘
       │        │       │       │         │             │
       └────────┴───────┼───────┴─────────┘             │
                        │                               │
                 ┌──────┴──────┐                        │
                 │ Qwen3Common │  (couches partagées)   │
                 └──────┬──────┘                        │
                        │                               │
                 ┌──────┴──────┐                        │
                 │ AudioCommon │ ◄──────────────────────┘
                 └─────────────┘  (protocoles, E/S audio)

MOSS Transcribe Diarize

MossTranscribe renvoie des segments horodatés attribués aux locuteurs via des backends natifs CoreML et MLX. CoreML utilise un état fixe de 1 024 tokens pour les enregistrements courts. MLX emploie un contexte dynamique de 131 072 tokens, des poids de décodeur affine INT5/INT8 et des caches KV FP16/INT8 optionnels. Les deux runtimes sont hors ligne et autorégressifs, sans streaming.

VoiceChat 11B

Tâche et référence : speech-to-speech duplex ; SALM-Duplex: Efficient and Direct Duplex Modeling for Speech-to-Speech Language Model (Interspeech 2025), cité par la fiche VoiceChat amont de NVIDIA.

Runtime complet, M5 Pro 48 Go, Release, cadence live de 80 ms : l'INT5 avec têtes protégées atteint environ 8.69 Go de RSS maximal ; trois RTF contrôlés du pipeline complet ont donné 0.96, 0.96 et 0.99. Les performances INT8 optimisées n'ont pas encore été remesurées.

VoiceChat implémente le chemin audio-à-audio MLX natif complet : perception FastConformer causale, canaux duplex texte/fonction Nemotron-H, décodeur EAR-TTS autonome conditionné par le texte avec huit itérations MaskGIT et codec neuronal à 22,05 kHz. Le streaming conserve des caches bornés d'attention et de convolution causale par couche, tandis que la fenêtre live stable de huit trames du codec utilise un graphe compilé. Chaque trame d'entrée de 80 ms produit une décision de langage, 31 codes RVQ et exactement 1 764 échantillons de sortie. Le chargeur exige un bundle complet encoder/ + llm/ + tts/ et refuse les anciens exports limités à la compréhension. INT5 maintient désormais un RTF global sous 1 sur le M5 Pro testé, bien que la marge p95 par trame reste faible.

Backends d'inférence

Format des poids de modèles

Les modèles MLX utilisent le format safetensors avec une quantification 4 bits ou 8 bits (taille de groupe 64). Les modèles CoreML utilisent le format compilé .mlmodelc. Les scripts de conversion dans scripts/ convertissent depuis des checkpoints PyTorch.

Cohere et Voxtral proposent aussi des bundles MLX INT5 affines. MLX ne prend pas en charge INT7 affine ; INT8 est l’option de meilleure qualité prise en charge.

Initialisation des modèles MLX

QuantizedLinear.preQuantized crée des tableaux provisoires de zéros pour les couches linéaires quantifiées chargées depuis un checkpoint, évitant les poids aléatoires et leurs graphes temporaires de quantification. withThrowawayRandomState sépare l’initialisation en virgule flottante destinée à être supprimée de la chaîne de clés aléatoires de l’appelant. Les chargeurs de modèles composites isolent chaque composant : T5 et EnCodec de MAGNeT, T5Gemma et SAME-L de Stable Audio 3, et le codec Mimi de CSM. Les embeddings quantifiés de CSM utilisent toujours l’initialiseur amont et conservent sa limitation connue concernant la durée de vie du graphe d’initialisation.

Optimisations de performance

• MLX compile() — Fusion de noyaux pour les boucles autorégressives. Talker utilise compile(shapeless: true), Code Predictor utilise compile(shapeless: false) avec des tailles de cache fixes.
• Bibliothèque de shaders Metal — Le metallib pré-compilé évite environ 5× de surcoût de compilation JIT. Compilé via scripts/build_mlx_metallib.sh.
• Décodage de codec par chunks — Le décodeur TTS traite l'audio par chunks de 25 trames avec chevauchement de contexte de 10 trames pour éviter les timeouts GPU.
• CFG à batch doublé — Le DiT de CosyVoice3 divise par deux les passes de flow matching en groupant conditionnel + inconditionnel ensemble.
• RoPE fusionné — Utilise MLXNN.RoPE adossé à un noyau Metal plutôt qu'une rotation manuelle.
• Fusion BN — La normalisation par batch de WeSpeaker est fusionnée dans les poids Conv2d au moment de la conversion.

Traitement audio

Toutes les E/S audio utilisent du PCM Float32. Le rééchantillonnage interne gère la conversion de format :

Structure des sources

Sources/
  AudioCommon/            Protocoles partagés, E/S audio, capture de la
                          sortie système (SystemAudioTap), téléchargeur
                          HuggingFace, SentencePieceModel (lecteur protobuf)
  MLXCommon/              Utilitaires MLX : chargement des poids, aides QuantizedLinear,
                          aide d'attention multi-tête SDPA, budget Metal
  Qwen3Common/            Composants de modèle partagés (cache KV, RoPE, quantification)
  Qwen3ASR/               Qwen3-ASR parole vers texte
  ParakeetASR/            Parakeet TDT parole vers texte (CoreML)
  ParakeetStreamingASR/   Dictée streaming Parakeet EOU 120M (CoreML)
  OmnilingualASR/         Meta wav2vec2 + CTC, 1 672 langues
                          (CoreML 300M + MLX 300M / 1B / 3B / 7B)
  CohereTranscribeASR/  Cohere Transcribe 2B speech-to-text (MLX)
  VoxtralASR/            Voxtral Mini 3B speech-to-text (MLX)
  Qwen3TTS/               Qwen3-TTS texte vers parole
  FireRedTTS3TTS/         FireRedTTS3-Instruct (MLX, Float32)
  MossVoiceGeneratorTTS/  MOSS-VoiceGenerator (MLX, BF16 + FP32)
  CosyVoiceTTS/           CosyVoice3 texte vers parole
  KokoroTTS/              Kokoro-82M texte vers parole (CoreML)
  Qwen3Chat/              Chat LLM embarqué Qwen3.5-0.8B (MLX + CoreML)
  PersonaPlex/            PersonaPlex parole-à-parole
  SpeechVAD/              VAD (Silero + Pyannote), diarisation, empreintes de locuteur
  SpeechLanguageID/       Identification de la langue parlée (SpeechBrain ECAPA, MLX + CoreML, 107 étiquettes)
  SpeechEnhancement/      Suppression de bruit DeepFilterNet3 (CoreML)
  SourceSeparation/       Open-Unmix HQ / UMX-L + HTDemucs (Demucs v4) music source separation (MLX, 4 stems)
  MAGNeTMusicGen/         MAGNeT text-to-music generation (MLX, 30 s @ 32 kHz, INT4/INT8)
  VoxCPM2TTS/             VoxCPM2 text-to-speech (MLX, 48 kHz, voice cloning + voice design)
  IndexTTS2TTS/           IndexTTS2 voice cloning (MLX, semantic GPT + emotion/tempo/pause control + S2Mel + BigVGAN)
  VibeVoiceTTS/           VibeVoice long-form / multi-speaker TTS (MLX, EN/ZH)
  MADLADTranslation/      MADLAD-400 many-to-many translation (MLX, 400+ languages)
  GLiNER/                 GLiNER2.5-Decide classification + entity spans (MLX, INT8/FP16/FP32)
  AudioCLILib/            Implémentations des commandes CLI
  AudioCLI/               Point d'entrée CLI

scripts/              Conversion de modèles (PyTorch → MLX/CoreML), benchmarking
Tests/                Tests unitaires et d'intégration
Examples/             Applications de démonstration (PersonaPlexDemo, SpeechDemo)

GLiNER2.5-Decide : classification et segments d’entités natifs en MLX (poids INT8, FP16 ou FP32) ; pas de Python à l’inférence.

⚠ Translation out of date — English guide. The new Clef section below awaits translation.

Clef-flash: development preview of local text decisions (9B, affine 4-bit MLX), with a joint schema head and a separate output-embedding prior.