Skip to content

feat(tts): Inflect v2 (Micro/Nano) CoreML backend - #823

Open
Alex-Wengg wants to merge 1 commit into
mainfrom
feat/inflect-tts-backend
Open

feat(tts): Inflect v2 (Micro/Nano) CoreML backend#823
Alex-Wengg wants to merge 1 commit into
mainfrom
feat/inflect-tts-backend

Conversation

@Alex-Wengg

Copy link
Copy Markdown
Member

Summary

Adds Inflect v2 as a FluidAudio TTS backend — ultra-tiny VITS-family English TTS (Micro 9.4M / Nano 4.0M params, 24 kHz mono). Companion to the mobius conversion (mobius #80); models published at FluidInference/inflect-v2-coreml.

Design

Two-stage fixed-shape CoreML split with everything stochastic or dynamically shaped on the host (so both graphs are deterministic):

  1. encoder — TextEncoder + duration predictor (fixed 512-token axis).
  2. Host — duration expansion, prior sampling z_p = m + noise·exp(logs)·noise_scale, smallest-fitting frame bucket.
  3. synthesizer_f<N> — reverse coupling flow + HiFiGAN, 8 frame buckets {256…2048}; audio trimmed to exact length.

New module TTS/Inflect/: InflectManager (actor, text + ipa: paths, chunking, pauses, edge fade), InflectSynthesizer, InflectModelStore (lazy bucket loading), InflectSymbols (keithito/espeak symbol table + encoder), InflectNoise (seedable Box–Muller).

Phonemizer (same tradeoff as StyleTTS2)

Inflect trained on espeak-ng IPA. espeak-ng is GPL-3.0 and can't ship in an Apache framework, so the text path reuses the shared Misaki-lexicon + BART G2P frontend (StyleTTS2Phonemizer), which approximates espeak IPA. Callers with real espeak feed IPA directly via synthesize(ipa:) for faithful output. No new dependencies; stays Apache-2.0.

Validation

End-to-end on M5 Pro (real HF download → encoder → host expansion → synthesizer), Parakeet round-trip:

  • micro --phonemes (faithful IPA): "The quick brown fox … over the lazy dog."
  • nano text (Misaki+BART G2P): "Hello from the tiny inflect model." — exact.

Benchmarks (mobius harness, MiniMax-English): micro 25.7 ms p50 / 245× RTFx / WER 1.43%; nano 13.2 ms / 460× / 1.92%.

Unit tests: symbol encoder golden vectors (incl. syllabic-consonant scalar handling), noise determinism + distribution, repo/model wiring. (Local XCTest is unavailable here; tests run in CI.)

CLI

fluidaudio tts "Hello world" --backend inflect --variant nano -o out.wav
fluidaudio tts "həlˈoʊ" --backend inflect-micro --phonemes -o out.wav

Ultra-tiny VITS-family English TTS (9.4M / 4.0M params, 24 kHz). Ships
FluidInference/inflect-v2-coreml: a fixed-shape encoder + duration
predictor and 8 frame-bucketed HiFiGAN synthesizers per variant.
Everything stochastic or dynamically shaped runs host-side in Swift
(duration expansion, prior sampling), so both CoreML graphs are
deterministic.

- InflectManager (actor): text + ipa entry points, phoneme chunking,
  inter-chunk pauses, edge fade.
- InflectSymbols: keithito/espeak symbol table + token encoder. Iterates
  Unicode scalars (a syllabic n̩ is two symbols, not one grapheme) and
  reproduces intersperse(cleaned_text_to_sequence(...)); golden-vector
  tested against the upstream Python.
- InflectSynthesizer: encoder -> host expand+sample z_p -> smallest
  fitting bucket -> trim. InflectNoise: seedable Box-Muller Gaussian.
- English frontend shared with StyleTTS2 (Misaki lexicon + BART G2P,
  espeak-approximated); synthesize(ipa:) bypasses it for faithful
  espeak input. espeak-ng itself (GPL) is not vendored.

Validated end-to-end on M5 Pro: micro IPA and nano text both round-trip
through Parakeet to the input text. Unit tests cover the symbol encoder
(golden vectors), noise determinism, and repo/model wiring.
@github-actions

Copy link
Copy Markdown

PocketTTS Smoke Test ✅

Check Result
Build
Model download
Model load
Synthesis pipeline
Output WAV ✅ (153.8 KB)

Runtime: 1m42s

Note: PocketTTS uses CoreML MLState (macOS 15) KV cache + Mimi streaming state. CI VM lacks physical GPU — audio quality and performance may differ from Apple Silicon.

@github-actions

Copy link
Copy Markdown

Speaker Diarization Benchmark Results

Speaker Diarization Performance

Evaluating "who spoke when" detection accuracy

Metric Value Target Status Description
DER 15.1% <30% Diarization Error Rate (lower is better)
JER 24.9% <25% Jaccard Error Rate
RTFx 30.02x >1.0x Real-Time Factor (higher is faster)

Diarization Pipeline Timing Breakdown

Time spent in each stage of speaker diarization

Stage Time (s) % Description
Model Download 10.602 30.3 Fetching diarization models
Model Compile 4.544 13.0 CoreML compilation
Audio Load 0.044 0.1 Loading audio file
Segmentation 10.485 30.0 Detecting speech regions
Embedding 17.475 50.0 Extracting speaker voices
Clustering 6.990 20.0 Grouping same speakers
Total 34.957 100 Full pipeline

Speaker Diarization Research Comparison

Research baselines typically achieve 18-30% DER on standard datasets

Method DER Notes
FluidAudio 15.1% On-device CoreML
Research baseline 18-30% Standard dataset performance

Note: RTFx shown above is from GitHub Actions runner. On Apple Silicon with ANE:

  • M2 MacBook Air (2022): Runs at 150 RTFx real-time
  • Performance scales with Apple Neural Engine capabilities

🎯 Speaker Diarization Test • AMI Corpus ES2004a • 1049.0s meeting audio • 35.0s diarization time • Test runtime: 2m 29s • 07/25/2026, 06:41 PM EST

@github-actions

Copy link
Copy Markdown

Sortformer High-Latency Benchmark Results

ES2004a Performance (30.4s latency config)

Metric Value Target Status
DER 30.3% <35%
Miss Rate 28.2% - -
False Alarm 0.9% - -
Speaker Error 1.2% - -
RTFx 22.4x >1.0x
Speakers 4/4 - -

Sortformer High-Latency • ES2004a • Runtime: 2m 51s • 2026-07-25T22:42:32.572Z

@github-actions

Copy link
Copy Markdown

Supertonic3 Smoke Test ✅

Check Result
Build
Model download (incl. VectorEstimatorVariants/ int4 buckets)
Model load
Synthesis pipeline (--ve-variant int4)
Output WAV ✅ (364.7 KB)

Runtime: 0m27s

Note: CI VMs lack a physical Neural Engine; the ANE-bucketed VectorEstimator falls back to CPU here. This validates download + variant resolution + synthesis, not ANE residency/perf.

@github-actions

Copy link
Copy Markdown

Offline VBx Pipeline Results

Speaker Diarization Performance (VBx Batch Mode)

Optimal clustering with Hungarian algorithm for maximum accuracy

Metric Value Target Status Description
DER 10.4% <20% Diarization Error Rate (lower is better)
RTFx 9.98x >1.0x Real-Time Factor (higher is faster)

Offline VBx Pipeline Timing Breakdown

Time spent in each stage of batch diarization

Stage Time (s) % Description
Model Download 22.542 21.4 Fetching diarization models
Model Compile 9.661 9.2 CoreML compilation
Audio Load 0.055 0.1 Loading audio file
Segmentation 26.248 25.0 VAD + speech detection
Embedding 104.868 99.8 Speaker embedding extraction
Clustering (VBx) 0.101 0.1 Hungarian algorithm + VBx clustering
Total 105.113 100 Full VBx pipeline

Speaker Diarization Research Comparison

Offline VBx achieves competitive accuracy with batch processing

Method DER Mode Description
FluidAudio (Offline) 10.4% VBx Batch On-device CoreML with optimal clustering
FluidAudio (Streaming) 17.7% Chunk-based First-occurrence speaker mapping
Research baseline 18-30% Various Standard dataset performance

Pipeline Details:

  • Mode: Offline VBx with Hungarian algorithm for optimal speaker-to-cluster assignment
  • Segmentation: VAD-based voice activity detection
  • Embeddings: WeSpeaker-compatible speaker embeddings
  • Clustering: PowerSet with VBx refinement
  • Accuracy: Higher than streaming due to optimal post-hoc mapping

🎯 Offline VBx Test • AMI Corpus ES2004a • 1049.0s meeting audio • 131.2s processing • Test runtime: 2m 25s • 07/25/2026, 06:44 PM EST

@github-actions

Copy link
Copy Markdown

Parakeet EOU Benchmark Results ✅

Status: Benchmark passed
Chunk Size: 320ms
Files Tested: 100/100

Performance Metrics

Metric Value Description
WER (Avg) 7.03% Average Word Error Rate
WER (Med) 4.17% Median Word Error Rate
RTFx 11.98x Real-time factor (higher = faster)
Total Audio 470.6s Total audio duration processed
Total Time 39.9s Total processing time

Streaming Metrics

Metric Value Description
Avg Chunk Time 0.040s Average chunk processing time
Max Chunk Time 0.080s Maximum chunk processing time
EOU Detections 0 Total End-of-Utterance detections

Test runtime: 1m47s • 07/25/2026, 06:48 PM EST

RTFx = Real-Time Factor (higher is better) • Processing includes: Model inference, audio preprocessing, state management, and file I/O

@github-actions

Copy link
Copy Markdown

VAD Benchmark Results

Performance Comparison

Dataset Accuracy Precision Recall F1-Score RTFx Files
MUSAN 94.0% 89.3% 100.0% 94.3% 676.5x faster 50
VOiCES 94.0% 89.3% 100.0% 94.3% 693.4x faster 50

Dataset Details

  • MUSAN: Music, Speech, and Noise dataset - standard VAD evaluation
  • VOiCES: Voices Obscured in Complex Environmental Settings - tests robustness in real-world conditions

✅: Average F1-Score above 70%

@github-actions

Copy link
Copy Markdown

ASR Benchmark Results ✅

Status: All benchmarks passed

Parakeet v3 (multilingual)

Dataset WER Avg WER Med RTFx Status
test-clean 0.57% 0.00% 4.66x
test-other 1.96% 0.00% 2.75x

Parakeet v2 (English-optimized)

Dataset WER Avg WER Med RTFx Status
test-clean 0.80% 0.00% 3.90x
test-other 1.00% 0.00% 3.49x

Streaming (v3)

Metric Value Description
WER 0.00% Word Error Rate in streaming mode
RTFx 0.54x Streaming real-time factor
Avg Chunk Time 1.682s Average time to process each chunk
Max Chunk Time 1.932s Maximum chunk processing time
First Token 1.992s Latency to first transcription token
Total Chunks 31 Number of chunks processed

Streaming (v2)

Metric Value Description
WER 0.00% Word Error Rate in streaming mode
RTFx 0.56x Streaming real-time factor
Avg Chunk Time 1.624s Average time to process each chunk
Max Chunk Time 1.936s Maximum chunk processing time
First Token 1.663s Latency to first transcription token
Total Chunks 31 Number of chunks processed

Streaming tests use 5 files with 0.5s chunks to simulate real-time audio streaming

25 files per dataset • Test runtime: 11m13s • 07/25/2026, 07:00 PM EST

RTFx = Real-Time Factor (higher is better) • Calculated as: Total audio duration ÷ Total processing time
Processing time includes: Model inference on Apple Neural Engine, audio preprocessing, state resets between files, token-to-text conversion, and file I/O
Example: RTFx of 2.0x means 10 seconds of audio processed in 5 seconds (2x faster than real-time)

Expected RTFx Performance on Physical M1 Hardware:

• M1 Mac: ~28x (clean), ~25x (other)
• CI shows ~0.5-3x due to virtualization limitations

Testing methodology follows HuggingFace Open ASR Leaderboard

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant