Akiki VAD 1.0

Akiki VAD is a compact, causal voice activity detection model for streaming 16 kHz audio. It returns a speech probability every 16 ms and can be used to identify speech frames before transcription or other audio processing.

Akiki VAD collection

Model details

The model includes the waveform frontend and maintains recurrent state. Each inference step consumes 320 past samples followed by 256 new samples.

The waveform frontend and convolutional encoder follow the Silero VAD v5 design. Akiki reimplements that design with a GRU in place of the LSTM and a 16 ms prediction hop. The trainable weights were learned from random initialization using Silero VAD 6.2.3 supervision.

Fast CPU inference is built into the Python package: the default INT8 path measured 8.90 µs per 16 ms frame through VAD.push() on a Ryzen 9 9900X. See engine benchmarks.

Quickstart

Install akiki from PyPI:

pip install akiki
akiki vad recording.wav

The package includes the fast Akiki Rust inference engine and this model's weights on supported platforms. Inference runs locally. You can start using the model without downloading files from this repository or building Rust.

import soundfile as sf
from akiki import VAD

audio, sample_rate = sf.read("recording.wav", dtype="float32")
with VAD() as vad:
    for frame in vad.push(audio, sample_rate=sample_rate):
        print(frame.start_seconds, frame.end_seconds, frame.probability, frame.speech)
    vad.reset()  # Start a new recording.

Audio must be finite mono float32 at 16 kHz. push() accepts arbitrary buffer sizes and returns a probability and speech decision for each complete 256-sample frame (16 ms). An incomplete final frame remains pending. Use one detector per stream and call reset() between independent recordings.

The default speech threshold is 0.5. Use VAD(threshold=0.6) or akiki vad recording.wav --threshold 0.6 to change it; probabilities are always returned. Applications can define their own rules for joining frames into speech segments.

The repository's example.py uses the same installed package and prints frames as JSON. Its requirements.txt contains akiki:

python example.py recording.wav

Fast CPU inference with the Akiki Rust engine

pip install akiki includes the purpose-built Akiki Rust inference engine and this model's weights on supported platforms. One Python API handles streaming, state, buffering and timestamps, with CPU kernels specialized for this VAD. Normal use requires no separate PyTorch/ONNX runtime or Rust build.

The default INT8 path processes a 16 ms audio frame in 8.90 µs through the public Python VAD.push() API in our recorded CPU benchmark. The native call takes 3.78 µs with prepared pointers. RealFFT stays FP32 for every weight precision.

Measured with akiki 0.0.5 on an AMD Ryzen 9 9900X, one pinned CPU core: three fresh processes per case, 2,000 warmup calls and 7,500 timed calls each. Values are medians of process medians. Whiskers show the range of those three medians, not a confidence interval. Python timing includes input validation, buffering, frontend, recurrent state, timestamps and frame output. Model loading/conversion, audio decoding and acquisition are excluded. Actual speed depends on the CPU and workload; accuracy comparisons are reported separately.

Recorded comparison with other engines and VAD models

The earlier benchmark compared the Akiki Rust engine with ONNX Runtime, PyTorch eager, Candle, tract, Burn Flex and RTen, alongside original TEN-VAD and Silero v5. The Akiki model in this historical comparison is version 0.2.0, before the production RealFFT migration; these are not speedup measurements for version 1.0. The chart above measures the current 1.0 model through akiki.

All rows include the waveform frontend. Native Rust excludes Python; ONNX/PyTorch include their host-call overhead. The archived campaigns use the same CPU and one thread, with different fixtures and warmup/repetition counts. 16 ms-hop medians are multiplied by two to normalize compute per 32 ms audio; this is not a measured two-call median or audio acquisition latency. The hatched TEN row is a measured RealFFT prototype. Framework neural ports share a native STFT. This comparison does not isolate programming-language cost or accuracy.

Exact values, protocol and source hashes · Package plot SVG · Engine comparison SVG

Evaluation

The following table reports the original FP32 weights. The Python Rust runtime uses INT8 by default while keeping RealFFT FP32. Use VAD(engine="rust", model_precision="fp32") for the original precision; precision-specific results cover the other variants.

TEN evaluation covers 30 clips and 8,179 frames; VoxConverse covers 48 recordings and 999,894 frames. Both use 32 ms reference frames. Consecutive 16 ms model probabilities are averaged in pairs for scoring, without timing shifts or smoothing. Average precision is pooled across frames. Precision at recall ≥95% is measured on a threshold grid with a step of 0.01 and uses thresholds that may differ from the default 0.5.

The checkpoint within each training run was selected using teacher-labelled validation data. The release seed was then chosen after comparing three seeds on TEN and VoxConverse. These benchmarks were repeatedly inspected during development, so the results are development comparisons rather than an independent final test.

Training data and method

The model was trained from random initialization using speech probabilities from Silero VAD 6.2.3 as supervision. The prepared corpus contains 357,672 training recordings (993.772 hours) and 17,540 validation recordings (28.262 hours), including labelled audio mixtures and instrumental recordings labelled as non-speech.

The annotated corpus has been uploaded to the Akiki VAD training-data collection on Hugging Face. It includes audio, 32 ms teacher targets, split assignments and provenance. The collection and all of its datasets are publicly available.

Training matches the mean of two consecutive 16 ms model outputs to each 32 ms teacher target using binary cross-entropy. The targets are teacher predictions; they do not establish manually annotated speech boundaries at 16 ms resolution.

Source audio was selected under a commercial-use licence allowlist. Data splits exclude source-group overlap and known benchmark audio hashes across the relevant splits. Speaker identity across source corpora has not been exhaustively checked.

The training recipe and provenance records provide the detailed training configuration, environment and run history.

Limitations

The reported results cover the recordings above. Performance across languages, speakers, recording devices and acoustic conditions is not established by these aggregate scores; assess the model on audio representative of your application. Teacher supervision can also carry over the teacher's detection errors.

The 16 ms output interval describes how often predictions are produced. It does not establish 16 ms speech-boundary accuracy or end-to-end application latency. Each prediction requires the complete 256-sample frame to be available.

The Python interface returns individual frame scores and decisions. Applications that need continuous speech segments must define their own rules for joining frames and handling brief pauses.

Quantizations

The following separate Hugging Face models are linked to this release as quantized derivatives and appear in its Quantizations model tree. All models are public and grouped in the Akiki VAD collection. RealFFT remains FP32 and unchanged in every variant.

Comparison and precision details include artifact sizes and the measured TEN/VoxConverse tradeoffs. Each quantized model carries its own model.safetensors and config.json, evaluation results, source hashes and Python example.

Choose the same precision through the installed Python package, for example VAD(engine="rust", model_precision="int8", fft_precision="fp32"). The package derives and caches the same numerical precision from bundled FP32 weights, so normal Python inference does not require a model download.

Optional exports

For custom integrations and research, exports/ contains the original PyTorch checkpoint and ONNX export with direct tensor examples. Normal inference uses the akiki package above. The native safetensors weights are stored once, at the repository root, alongside config.json.

Files and licence

• model.safetensors and config.json: native weights and model geometry.
• example.py and requirements.txt: inference through the installed akiki package.
• exports/: optional PyTorch and ONNX artifacts.
• release.json: release identity, metrics and artifact hashes.
• provenance/: training, evaluation and safetensors export records.
• SHA256SUMS: package checksums.

Akiki code and weights are provided under Apache-2.0. The independent Silero teacher is MIT licensed; its notice is included in SILERO-MIT.txt. Source datasets retain their own licences and attribution, recorded in attribution/. Teacher weights and source audio are not included in this model package.