verify

Verify the Pocket TTS Rust port against a Python reference using correlation metrics.

21|5|Updated Jan 24, 2026
One-click install
npx skills add https://github.com/UnaMentis/pocket-tts-ios --skill verify-unamentis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: verify
Source: https://github.com/UnaMentis/pocket-tts-ios/tree/main/.claude/skills/verify
Command: npx skills add https://github.com/UnaMentis/pocket-tts-ios --skill verify-unamentis

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires numpy, scipy, wavfile, whisper, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill ensures the numerical accuracy and performance of the Rust port of Pocket TTS by running rigorous verification tests against a Python reference implementation.

Core Features & Use Cases

  • Numerical Accuracy Testing: Compares generated audio and model latents against a known-good Python version using correlation metrics.
  • Performance Benchmarking: Measures synthesis latency (TTFA, RTF).
  • Regression Detection: Identifies any degradation in audio quality or model behavior after code changes.
  • Use Case: After updating the Rust code for the Pocket TTS model, run this Skill to confirm that the new version produces audio with at least 0.95 correlation to the original Python version and that latency targets are met.

Quick Start

Run the verification tests for the Rust port of Pocket TTS.

Frequently Asked Questions about verify

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I verify Rust port accuracy against a Python reference implementation?

To verify Rust port accuracy, you compare generated audio and model latents against a known-good Python version using correlation metrics. This Skill automates that numerical accuracy testing to ensure the port matches the original model's behavior.

What is audio correlation testing and when do I need it for ML model ports?

Audio correlation testing measures the numerical similarity between audio outputs of two model implementations. You need it for ML model ports to detect regressions and confirm that the ported version produces audio with at least 0.95 correlation to the reference.

How do I benchmark TTS synthesis latency like TTFA and RTF in Rust?

You benchmark TTS synthesis latency by measuring Time To First Audio (TTFA) and Real Time Factor (RTF) during the text-to-speech generation process. This Skill runs those performance benchmarks automatically alongside accuracy checks.

Does this verification process work with Whisper and wavfile dependencies?

Yes, the verification process relies on Whisper and wavfile dependencies, alongside numpy, scipy, and wavfile, to load audio, compute correlations, and assess the numerical accuracy of the Rust port against the Python reference outputs.

Why does my Rust TTS port produce different audio than the Python model?

A Rust TTS port might produce different audio due to numerical regressions or code changes. Running this Skill's regression detection identifies degradation by measuring audio and latent correlation against the Python reference to pinpoint discrepancies.

Can I use this for continuous integration and regression detection in ML ports?

Yes, you can use this Skill for continuous integration and regression detection in ML model ports. It assesses build status, measures synthesis latency, and validates audio correlation to catch any degradation after code changes automatically.