brouhaha.onnx: fp32 ONNX export of the validated checkpoint
metadata.json: sanitized conversion metadata
validation_fp32_summary.json: parity summary against the native PyTorch pipeline
benchmark_cpu_summary.json: local CPU benchmark summary
LICENSE: upstream MIT license

Scope of this conversion

This export covers the core neural forward pass only.

It does not include the full upstream inference pipeline around the model, such as:

sliding-window chunking
overlap aggregation
final VAD thresholding / binarization

Those steps remain part of the Python-side pipeline in the upstream Brouhaha project and in the local bridge code used to validate this conversion.

Input and output contract

The released model corresponds to the upstream models/best checkpoint configuration:

Item	Value
Sample rate	16,000 Hz
Chunk duration	6.0 s
Input tensor name	`waveforms`
Input shape	`(batch, 1, 96000)`
Input dtype	`float32`
Output tensor name	`scores`
Output shape	`(batch, frames, 3)`
Output dtype	`float32`

The three output channels correspond to:

VAD-related scores
SNR estimates
C50 estimates

Validation

This fp32 release was checked against the native PyTorch model and the wrapped end-to-end Python pipeline used in this conversion project.

Observed validation summary:

raw forward-pass parity: pass
end-to-end pipeline parity: pass
worst observed VAD mean absolute difference: 0.0
worst observed SNR max absolute difference: 0.000286102294921875
worst observed C50 max absolute difference: 0.000324249267578125

See validation_fp32_summary.json for the exact summary values included with this release.

Benchmark

Local CPU benchmark summary for batch size 1 over 10 runs:

Runtime	Seconds / run
Native PyTorch	0.08259631249820813
ONNX Runtime CPU	0.02837088329833932

This corresponds to an observed local speedup of about 2.91x for the exported fp32 ONNX model.

These numbers are environment-specific and should be treated as indicative rather than guaranteed.

Minimal ONNX Runtime example

python

import numpy as np
import onnxruntime as ort

session = ort.InferenceSession("brouhaha.onnx", providers=["CPUExecutionProvider"])

waveforms = np.zeros((1, 1, 96000), dtype=np.float32)
scores = session.run(["scores"], {"waveforms": waveforms})[0]

print(scores.shape)

Limitations

This release publishes fp32 only.
An fp16 export was produced during conversion work, but it showed material drift on SNR and C50 and is therefore not released here.
The ONNX graph is intended for 16 kHz mono 6-second waveform chunks.
For behavior closest to upstream Brouhaha, pair this model with the same chunking, aggregation, and thresholding logic used by the original Python pipeline.

Provenance

Upstream repository: marianne-m/brouhaha-vad
Upstream commit used for this conversion: 9f8ef68e13102cfd155490d5ffbf89247823ffa9
Upstream license: MIT

Citation

If you use this model, please cite the original Brouhaha work:

bibtex

@article{lavechin2023brouhaha,
  Title   = {{Brouhaha: multi-task training for voice activity detection, speech-to-noise ratio, and C50 room acoustics estimation}},
  Author  = {Marvin Lavechin and Marianne Metais and Hadrien Titeux and Alodie Boissonnet and Jade Copet and Morgane Riviere and Elika Bergelson and Alejandrina Cristia and Emmanuel Dupoux and Herve Bredin},
  Year    = {2023},
  Journal = {ASRU}
}

FredrikKarlssonSpeech/brouhaha-vad-onnx

brouhaha-vad-onnx

What is included