Strg-Alt-Entf-0x00/FireRedVAD-GGUF

FireRedVAD GGUF Models

Pre-converted FireRedVAD models in GGUF format for cross-platform inference. Includes Standard VAD, Streaming VAD, and Audio Event Detection (AED) with multiple quantization options.

Original Models: FireRedTeam/FireRedVAD
Conversion Tools: https://github.com/Strg-Alt-Entf-0x00/firered-vad

Quick Start

Download Models

pip install huggingface-hub

from huggingface_hub import hf_hub_download

# Download streaming VAD (INT8-CH, recommended)
model_path = hf_hub_download(
    repo_id="Strg-Alt-Entf-0x00/FireRedVAD-GGUF",
    filename="stream-vad/int8-ch/firered-stream-vad-int8-ch.gguf"
)

Usage Example (Python)

# See conversion repository for inference examples
# https://github.com/Strg-Alt-Entf-0x00/firered-vad

Available Models

All models follow this structure: {model_type}/{quantization}/{filename}.gguf

stream-vad/ — Real-time Streaming VAD (Causal, Low Latency)

Best for real-time voice activity detection. Fully causal — no future context needed. Optimized for streaming applications with 10ms frame processing.

Quantization	Path	Size	MAE vs FP32	SQNR	Notes
INT8-CH	stream-vad/int8-ch/	601 KB	0.000985	59.4 dB	Recommended. Per-channel quantization, near-FP32 accuracy
INT8	stream-vad/int8/	574 KB	0.001918	50.5 dB	Per-tensor quantization, good accuracy
INT16	stream-vad/int16/	1.14 MB	0.000077	94.2 dB	High precision, 2x memory
FP32	stream-vad/fp32/	2.28 MB	0.0	∞	Reference quality, no quantization

vad/ — Standard VAD (Bidirectional, High Accuracy)

Uses bidirectional context (lookback + lookahead). Higher accuracy than stream-vad, but requires buffering full audio segments. Best for offline/batch processing.

Performance: 97.57% F1 on FLEURS-VAD-102 dataset

Quantization	Path	Size	MAE vs FP32	SQNR	Notes
INT8-CH	vad/int8-ch/	627 KB	0.000985	59.4 dB	Recommended for batch processing
INT8	vad/int8/	595 KB	0.001957	50.4 dB	Good accuracy, minimal size
INT16	vad/int16/	1.18 MB	0.000079	94.2 dB	High precision
FP32	vad/fp32/	2.36 MB	0.0	∞	Reference quality

aed/ — Audio Event Detection (Multi-class)

Simultaneous detection of speech, music, and singing in 100+ languages.

Quantization	Path	Size	MAE vs FP32	SQNR	Notes
INT8-CH	aed/int8-ch/	628 KB	0.000985	59.4 dB	Recommended
INT8	aed/int8/	596 KB	0.001957	50.4 dB	Good accuracy
INT16	aed/int16/	1.18 MB	0.000079	94.2 dB	High precision
FP32	aed/fp32/	2.36 MB	0.0	∞	Reference quality

Quantization Details

Why INT8-CH (Per-Channel) is Recommended

Problem with standard INT8 (per-tensor):
DFSMN architectures have wide variance in weight distribution across output channels. A single global scale factor per tensor cannot capture this range accurately, causing quantization errors and silent accuracy degradation.

Solution: INT8 Per-Channel (int8-ch):
Assigns one scale factor per output channel instead of one global factor per tensor. This preserves near-FP32 accuracy (MAE < 0.001, SQNR > 59 dB) while maintaining INT8 speed and memory efficiency.

Metric	int8	int8-ch	int16	fp32
Memory	4x smaller	4x smaller	2x smaller	Baseline
Speed	~4x faster	~4x faster	~2x faster	Baseline
Accuracy (MAE)	0.00196	0.00098	0.00008	0.0
SQNR	50.4 dB	59.4 dB	94.2 dB	∞
Use Case	Memory-constrained	Recommended	High precision	Reference

Quantization Quality Metrics (Per Model)

Each model includes a -debug.json file with per-tensor quantization statistics:

• MAE (Mean Absolute Error): Average difference from FP32
• SQNR (Signal-to-Quantization-Noise Ratio): Quality metric in dB
• Per-channel scale factors: Min/max/mean scales per layer

Example: stream-vad/int8-ch/firered-stream-vad-int8-ch-debug.json

Repository Structure

FireRedVAD-GGUF/
├── README.md
│
├── vad/
│   ├── fp32/
│   │   ├── firered-vad-fp32.gguf
│   │   └── firered-vad-fp32-debug.json
│   ├── int16/
│   │   ├── firered-vad-int16.gguf
│   │   └── firered-vad-int16-debug.json
│   ├── int8/
│   │   ├── firered-vad-int8.gguf
│   │   └── firered-vad-int8-debug.json
│   └── int8-ch/
│       ├── firered-vad-int8-ch.gguf
│       └── firered-vad-int8-ch-debug.json
│
├── stream-vad/
│   └── (same structure as vad/)
│
└── aed/
    └── (same structure as vad/)

Total: 12 GGUF models + 12 debug.json files = 24 files

GGUF Format Details

GGUF (GPT-Generated Unified Format) is a binary format for storing neural network models:

• Self-contained: Model architecture, weights, and metadata in one file
• Memory-mapped: Fast loading without full file read
• Quantization support: Native support for INT8, INT16, FP32 formats
• Metadata: Includes CMVN statistics, architecture config, tensor shapes

Metadata Included

Each GGUF file contains:

• Model type: vad, stream-vad, or aed
• Quantization type: fp32, int16, int8, int8-ch
• Architecture: DFSMN config (hidden size, layers, filters)
• CMVN statistics: Mean and variance for feature normalization
• Tensor info: Names, shapes, types for all model weights

Model Comparison

Feature	Standard VAD	Streaming VAD	AED
Latency	High (buffered)	Low (10ms frames)	Medium
Context	Bidirectional	Causal only	Bidirectional
Accuracy	Highest (97.57% F1)	Very High (~96% F1)	High
Use Case	Offline batch processing	Real-time streaming	Content classification
Output	Speech probability	Speech probability	Speech / Music / Singing
Languages	100+	100+	100+

Conversion Pipeline

These models were converted from the original FireRedVAD PyTorch checkpoints using a custom conversion pipeline:

1. Load PyTorch model (.pth.tar) and CMVN stats (.ark)
2. Extract DFSMN architecture (FC layers, FSMN blocks, output layer)
3. Apply quantization (INT8 per-channel, INT8 per-tensor, INT16, or FP32)
4. Generate GGUF file with metadata and quantized weights
5. Validate conversion (weight-level comparison, MAE/SQNR metrics)

All models validated: Bit-accurate weight comparison against original PyTorch models (MAE < 0.001 for INT8-CH).

Hardware Requirements

Minimum (INT8-CH models)

• RAM: ~5 MB for model + ~2 MB for inference buffers
• CPU: Any modern x86_64, ARM, or RISC-V processor
• Storage: ~600 KB per model

Recommended (FP32 models)

• RAM: ~10 MB for model + ~3 MB for inference buffers
• CPU: SIMD support (SSE, AVX, NEON) for faster inference
• Storage: ~2.3 MB per model

Embedded Systems

• Use INT8-CH models for optimal size/accuracy tradeoff
• ESP32-P4 port available: FireRedVAD-ESP32-P4

Known Limitations

1. Requires 16kHz audio: Models are trained on 16kHz PCM. Resampling required for other rates.
2. Clean audio assumption: Performance degrades in very noisy environments (SNR < 5dB).
3. Feature extraction needed: GGUF files contain only model weights. You need to implement or use existing Fbank feature extraction (80-dim, 25ms window, 10ms shift).
4. No built-in preprocessing: Audio normalization, DC offset removal, and AGC are user responsibility.

License & Attribution

Original Models

• FireRedVAD by Xiaohongshu (FireRedTeam) — Apache 2.0
• Source: https://github.com/FireRedTeam/FireRedVAD
• HuggingFace: https://huggingface.co/FireRedTeam/FireRedVAD

GGUF Conversion

• FireRedVAD-GGUF by Strg-Alt-Entf-0x00 — Apache 2.0
• Repository: https://github.com/Strg-Alt-Entf-0x00/firered-vad
• Conversion tools and inference examples included

Related Projects

• ESP32-P4 Port: FireRedVAD-ESP32-P4 - Native RISC-V optimized models
• Original PyTorch: FireRedTeam/FireRedVAD - Full training code and checkpoints

Citation

@misc{fireredvad-gguf,
  title={FireRedVAD GGUF Models: Quantized Voice Activity Detection for Cross-Platform Inference},
  author={Strg-Alt-Entf-0x00},
  year={2026},
  howpublished={\url{https://huggingface.co/Strg-Alt-Entf-0x00/FireRedVAD-GGUF}},
}

---

Questions or Issues? Open an issue at https://github.com/Strg-Alt-Entf-0x00/firered-vad