Skip to content

refactor: Deduplicate language-specific model files#492

Merged
Alex-Wengg merged 2 commits intomainfrom
refactor/deduplicate-language-model-files
Apr 7, 2026
Merged

refactor: Deduplicate language-specific model files#492
Alex-Wengg merged 2 commits intomainfrom
refactor/deduplicate-language-model-files

Conversation

@Alex-Wengg
Copy link
Copy Markdown
Member

@Alex-Wengg Alex-Wengg commented Apr 7, 2026

Summary

Consolidates ~700 lines of duplicated boilerplate across three language-specific model files into a generic implementation. This addresses the architectural debt noted in #457.

Changes

New Files

  • ParakeetLanguageModels.swift - Generic implementation (337 lines)

Refactored Files

  • CtcJaModels.swift: 229 → 22 lines (config + typealias)
  • CtcZhCnModels.swift: 265 → 22 lines (config + typealias)
  • TdtJaModels.swift: 237 → 22 lines (config + typealias)

Supporting Changes

  • Made Repo enum Sendable for Swift 6 concurrency safety
  • Added joint model validation in TdtJaManager (TDT requires joint model)

Architecture

Uses a protocol-based configuration pattern:

public protocol ParakeetLanguageModelConfig: Sendable {
    static var blankId: Int { get }
    static var repository: Repo { get }
    static var languageLabel: String { get }
    // ... model files, int8 support, etc.
}

public struct ParakeetLanguageModels<Config: ParakeetLanguageModelConfig>: Sendable {
    // Generic implementation for all languages
}

Three lightweight configs capture the differences:

  • CtcJaConfig - Japanese CTC (blankId: 3072, 3 models)
  • CtcZhCnConfig - Chinese CTC (blankId: 7000, 3 models + optional int8 encoder)
  • TdtJaConfig - Japanese TDT (blankId: 3072, 4 models with joint)

Type aliases maintain backward compatibility:

public typealias CtcJaModels = ParakeetLanguageModels<CtcJaConfig>

Impact

  • Before: 731 lines of duplicated code
  • After: 403 lines total
  • Reduction: 328 lines removed (~45% reduction)
  • Tests: All CI tests pass ✅
  • Compatibility: Fully backward compatible (same public API)

Test Plan

  • Build succeeds
  • All CI tests pass
  • Existing managers (CtcJaManager, CtcZhCnManager, TdtJaManager) work unchanged

Resolves #457


Open with Devin

Consolidates ~700 lines of duplicated boilerplate across three
language-specific model files into a generic implementation.

Changes:
- Add ParakeetLanguageModels<Config> generic struct (337 lines)
- Refactor CtcJaModels.swift: 229 → 22 lines (config + typealias)
- Refactor CtcZhCnModels.swift: 265 → 22 lines (config + typealias)
- Refactor TdtJaModels.swift: 237 → 22 lines (config + typealias)
- Make Repo enum Sendable for concurrency safety
- Add joint model validation in TdtJaManager

Pattern: Protocol-based configuration with generic implementation.
The ParakeetLanguageModelConfig protocol defines language-specific
settings (blankId, repository, model files, int8 support). Type
aliases maintain backward compatibility.

Reduces codebase by 328 lines (~45% reduction) while maintaining
identical functionality. All CI tests pass.

Resolves #457
devin-ai-integration[bot]

This comment was marked as resolved.

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

VAD Benchmark Results

Performance Comparison

Dataset Accuracy Precision Recall F1-Score RTFx Files
MUSAN 92.0% 86.2% 100.0% 92.6% 566.0x faster 50
VOiCES 92.0% 86.2% 100.0% 92.6% 582.3x 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

github-actions bot commented Apr 7, 2026

✅ Japanese ASR Benchmark Results (CTC)

Status: Passed

Metric Value
CER 9.94%
Samples 50
Avg RTFx 2.5x
Decoder CTC

✅ Benchmark completed successfully. The TDT Japanese hybrid model (CTC preprocessor/encoder + TDT decoder/joint) is working correctly.

View benchmark log

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

Offline VBx Pipeline Results

Speaker Diarization Performance (VBx Batch Mode)

Optimal clustering with Hungarian algorithm for maximum accuracy

Metric Value Target Status Description
DER 14.5% <20% Diarization Error Rate (lower is better)
RTFx 5.13x >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 10.139 5.0 Fetching diarization models
Model Compile 4.345 2.1 CoreML compilation
Audio Load 0.068 0.0 Loading audio file
Segmentation 21.508 10.5 VAD + speech detection
Embedding 203.499 99.6 Speaker embedding extraction
Clustering (VBx) 0.747 0.4 Hungarian algorithm + VBx clustering
Total 204.406 100 Full VBx pipeline

Speaker Diarization Research Comparison

Offline VBx achieves competitive accuracy with batch processing

Method DER Mode Description
FluidAudio (Offline) 14.5% 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 • 225.8s processing • Test runtime: 3m 50s • 04/07/2026, 05:01 AM EST

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

PocketTTS Smoke Test ✅

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

Runtime: 0m29s

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

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

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 5.44x Real-time factor (higher = faster)
Total Audio 470.6s Total audio duration processed
Total Time 88.5s Total processing time

Streaming Metrics

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

Test runtime: 1m39s • 04/07/2026, 04:59 AM 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

github-actions bot commented Apr 7, 2026

Kokoro TTS Smoke Test ✅

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

Runtime: 0m43s

Note: Kokoro TTS uses CoreML flow matching + Vocos vocoder. CI VM lacks physical ANE — performance may differ from Apple Silicon.

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

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 26.09x >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 9.087 22.6 Fetching diarization models
Model Compile 3.894 9.7 CoreML compilation
Audio Load 0.065 0.2 Loading audio file
Segmentation 12.062 30.0 Detecting speech regions
Embedding 20.103 50.0 Extracting speaker voices
Clustering 8.041 20.0 Grouping same speakers
Total 40.220 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 • 40.2s diarization time • Test runtime: 1m 52s • 04/07/2026, 05:03 AM EST

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

Qwen3-ASR int8 Smoke Test ✅

Check Result
Build
Model download
Model load
Transcription pipeline
Decoder size 571 MB (vs 1.1 GB f32)

Performance Metrics

Metric CI Value Expected on Apple Silicon
Median RTFx 0.06x ~2.5x
Overall RTFx 0.06x ~2.5x

Runtime: 3m36s

Note: CI VM lacks physical GPU — CoreML MLState (macOS 15) KV cache produces degraded results on virtualized runners. On Apple Silicon: ~1.3% WER / 2.5x RTFx.

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

Sortformer High-Latency Benchmark Results

ES2004a Performance (30.4s latency config)

Metric Value Target Status
DER 33.4% <35%
Miss Rate 24.4% - -
False Alarm 0.2% - -
Speaker Error 8.8% - -
RTFx 14.3x >1.0x
Speakers 4/4 - -

Sortformer High-Latency • ES2004a • Runtime: 1m 57s • 2026-04-07T09:06:04.520Z

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

ASR Benchmark Results ✅

Status: All benchmarks passed

Parakeet v3 (multilingual)

Dataset WER Avg WER Med RTFx Status
test-clean 0.57% 0.00% 5.60x
test-other 1.56% 0.00% 3.66x

Parakeet v2 (English-optimized)

Dataset WER Avg WER Med RTFx Status
test-clean 0.80% 0.00% 3.73x
test-other 1.00% 0.00% 3.29x

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.698s Average time to process each chunk
Max Chunk Time 1.927s Maximum chunk processing time
First Token 1.987s 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.54x Streaming real-time factor
Avg Chunk Time 1.623s Average time to process each chunk
Max Chunk Time 1.897s Maximum chunk processing time
First Token 1.623s 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: 5m58s • 04/07/2026, 05:12 AM 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

Replace force unwrap with guard let statement and proper error handling.
This follows project guidelines which prohibit force unwrapping.

Changes:
- Replace models.joint! with guard let jointModel = models.joint
- Throw ASRError.processingFailed if joint model is missing
- Remove precondition from init (guard let provides better error handling)

Addresses review feedback on PR #492.
@Alex-Wengg
Copy link
Copy Markdown
Member Author

Fixed Force Unwrap Violation ✅

Addressed the review feedback by removing the force unwrap at .

Changes

  • Removed: Force unwrap models.joint!
  • Added: Guard let statement with proper error handling
  • Removed: Precondition from init (guard let provides better UX)

Before

jointModel: models.joint!,  // Safe to force unwrap - validated in init

After

// Validate joint model is present (required for TDT)
guard let jointModel = models.joint else {
    throw ASRError.processingFailed("TDT models require a joint model")
}
// ...
jointModel: jointModel,

Why This is Better

  1. Follows project guidelines - No force unwrapping
  2. Better error handling - Throws descriptive error instead of crashing
  3. More testable - Error can be caught and tested

Tests

  • ✅ Build succeeds
  • ✅ All CI tests pass

The refactoring now follows all project code standards.

@github-actions
Copy link
Copy Markdown

github-actions bot commented Apr 7, 2026

✅ Japanese ASR Benchmark Results (CTC)

Status: Passed

Metric Value
CER 9.94%
Samples 50
Avg RTFx 1.9x
Decoder CTC

✅ Benchmark completed successfully. The TDT Japanese hybrid model (CTC preprocessor/encoder + TDT decoder/joint) is working correctly.

View benchmark log

@Alex-Wengg Alex-Wengg merged commit 6caeb5d into main Apr 7, 2026
13 checks passed
@Alex-Wengg Alex-Wengg deleted the refactor/deduplicate-language-model-files branch April 7, 2026 13:07
Alex-Wengg added a commit that referenced this pull request Apr 7, 2026
Replace force unwrap with guard let statement and proper error handling.
This follows project guidelines which prohibit force unwrapping.

Changes:
- Replace models.joint! with guard let jointModel = models.joint
- Throw ASRError.processingFailed if joint model is missing
- Remove precondition from init (guard let provides better error handling)

Addresses review feedback on PR #492.
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.

Code architecture inconsistencies, tech debt & out of place

1 participant