Akiki VAD 1.0 — INT4

Native precision variant of the main Akiki VAD model, generated from the same selected seed-1730 checkpoint. Packed signed INT4 projection weights; dynamically quantized INT8 activations. RealFFT, periodic Hann windowing and magnitude computation remain FP32 and unchanged. Biases, the output head, nonlinearities and recurrent state also remain FP32. Only convolution and GRU projections use the selected reduced precision.

Use the Python package

pip install akiki
akiki vad recording.wav --engine rust --model-precision int4 --fft-precision fp32

from akiki import VAD

with VAD(engine="rust", model_precision="int4", fft_precision="fp32") as vad:
    frames = vad.push(audio, sample_rate=16000)

This public API selects the same numerical precision from the package's bundled FP32 weights. Its internal runtime cache may use native packing; this Hub release ships safetensors. The example needs no Hugging Face model download. example.py uses this interface and requirements.txt contains only akiki. Audio must be finite mono float32 at 16 kHz.

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.

INT4 processes a 16 ms audio frame in 11.74 µs through the public Python VAD.push() API in our recorded CPU benchmark. The native call takes 6.61 µ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

Safetensors deployment

This model is self-contained: use model.safetensors and config.json from this repository. No base-model weights or other precision packages are required. Load an existing local copy with the Akiki Rust engine:

let weights = akiki_vad_engine::Weights::load("/local/akiki-vad-1.0-int4")?;

An explicit local model.safetensors path also works with config.json beside it. The C ABI accepts the same directory or file path. Direct integer safetensors loading requires an Akiki engine/library build with the akiki_rowwise v1 loader. Existing older wheels can still select this precision from their bundled FP32 source using the Python example above.

File size: 106,572 bytes for the weights and 1,034 bytes for the configuration. Safetensors keeps named tensors; native SIMD padding is reconstructed in memory. FP16/BF16 retain their original bit patterns; INT8 stores signed weights and FP32 row scales; INT4 packs two signed coefficients per byte and records logical shapes and scales. FORMAT.md documents the schema. The deterministic Fourier basis is reconstructed from the unchanged frontend config, keeping RealFFT FP32 without storing duplicate basis buffers.

The conversion preserves every evaluated coefficient, scale, FP32 bias and head value. All 2,016,170 native 16 ms probabilities per precision, across 30 TEN and 48 VoxConverse recordings, are bit-identical to the previous evaluated release. format-conversion-validation.json records this check and the loader/build hashes. No training, requantization, calibration or FFT change was performed.

Evaluation

All 30 TEN and 48 VoxConverse recordings were evaluated with the unchanged 32 ms reference protocol: average consecutive 16 ms predictions in pairs, preserve recurrent state throughout each recording, and reset between recordings. These repeatedly inspected benchmarks are development comparisons. Small gains or losses do not establish improved generalization. No training, calibration, threshold adjustment or FFT quantization was performed.

evaluation.json includes probability drift and precision at high recall. quantization.json records source revisions, hashes, scope and precision policy. Verify this model package with sha256sum -c SHA256SUMS.

Akiki VAD collection