RIR-Bench-Hard: An Adversarial Room Impulse Response Benchmark

RIR-Bench-Hard is a benchmark of 2,600 synthetic room impulse responses (RIRs) engineered to be the failure cases — the acoustically extreme rooms where dereverberation, blind room-acoustics estimation, and far-field ASR quietly fall apart. Most RIR corpora are dominated by ordinary shoebox offices with moderate reverberation; a model can look excellent on those and still collapse on a coupled concert hall, a point-blank near-field capture, or a reverberant warehouse where the direct path is buried. RIR-Bench-Hard isolates exactly those regimes and ships a ready-to-run leaderboard so the hard cases get measured, not averaged away.

Every RIR is generated with pyroomacoustics (image-source + ray tracing) from a fixed per-sample seed, and every acoustic descriptor in the metadata is really measured from the audio — no placeholders. The generator (scripts/generate_rirs.py) and the evaluation harness (eval/) are in the repo, so the whole benchmark is reproducible and auditable end to end.

Why RIR-Bench-Hard

• It targets the tails, not the mean. The five categories below are chosen because they are where published dereverberation / far-field systems degrade: long non-trivial decays, non-exponential (coupled) decays, extreme DRR in both directions, and non-rectangular geometry that violates the shoebox assumption baked into many methods.
• Real, verified acoustics. T60, DRR, C50 and EDT are computed with standard estimators (Schroeder integration, direct-window DRR, clarity, early-decay time) directly from each waveform. A documented quality-control pass flags physically implausible outliers (valid / qc_flag columns) so every stated range is physically sane.
• A leaderboard on day one. eval/ scores a submission with numpy / scipy / soundfile only (no heavy ML deps), reports per-category and test_hard MAE, and ships a seeded identity-baseline result.
• Small and fast. Mono, 16 kHz, int16, capped at ~4 s per RIR — the whole set is ~110 MB, so it downloads in seconds and runs in CI.

The five hard categories

All counts below are the physically-valid rows (QC pass); the five flagged rows are kept in the file as valid=False and excluded from splits and scoring.

Category	n (valid)	What it stresses	T60 (s), min–max	DRR (dB), min–max
long_t60	520	Large halls, long reverberation tails	0.55 – 3.25	−16.7 – +10.2
coupled_rooms	516	Two connected volumes → non-exponential (double-slope) decay	0.14 – 0.77	−11.9 – +0.4
near_field	520	Source < 0.3 m from mic → extreme high DRR	0.21 – 0.48	+5.6 – +24.8
low_drr	520	Far source + asymmetric absorption → reverb-dominated, lowest DRR	1.95 – 8.40	−16.0 – −5.7
non_shoebox	519	L-shaped / polygonal rooms (from_corners, extruded 3D)	0.09 – 0.42	−14.0 – +5.5
Total	2,595

Overall valid ranges: T60 0.09 – 8.40 s (median 0.36), DRR −16.7 – +24.8 dB (median −7.1), C50 −5.0 – +55.7 dB (median 5.3), EDT 0.05 – 2.27 s (median 0.78). The low_drr and long_t60 tails are what make the benchmark hard: a long-T60 / low-DRR regime is exactly where dereverberation and ASR WER degrade most.

near_field RIRs are near-impulsive, so a reverberation decay time is not physically defined for them; those rows carry a null t60_measured/edt_s with qc_flag = near_impulsive but remain valid=True, because their DRR and C50 — the point of that category — are fully meaningful.

Metadata schema

metadata.parquet (and the identical metadata.csv) — one row per RIR:

Column	Type	Description
id	string	Unique id, "<category>_<idx>"
category	string	One of the five hard categories
filepath	string	Relative path to the WAV, data/rirs/<category>/<id>.wav
fs	int	Sample rate, 16000
room_type	string	Geometry family (shoebox_hall, coupled_barbell, l_shape, polygon, …)
room_dims	json	Bounding [L, W, H] in metres
rt60_target	float/null	Design T60 (set only where a Sabine target was used)
t60_measured	float/null	Measured T60 (s), Schroeder T30 fit
drr_db	float	Measured direct-to-reverberant ratio (dB)
c50_db	float	Measured clarity C50 (dB), clamped to ±60
edt_s	float/null	Measured early decay time (s)
source_pos	json	Source [x, y, z] (m)
mic_pos	json	Microphone [x, y, z] (m)
absorption	float	Mean wall absorption coefficient
n_reflections_order	int	Image-source order used
seed	int	Per-sample RNG seed (full reproducibility)
split	string	train / dev / test_hard (empty for QC-flagged rows)
valid	bool	False for physically-implausible rows (excluded from splits/scoring)
qc_flag	string	ok, near_impulsive, or the reason a row is invalid

Metric definitions

• T60 — Schroeder backward-integration energy-decay curve; linear fit on −5 dB → −35 dB (T30), extrapolated to 60 dB.
• DRR — energy in a ±2.5 ms window around the peak vs. the remainder, in dB.
• C50 — 10·log10( E[0–50 ms] / E[50 ms–end] ), referenced to the direct arrival, clamped to ±60 dB.
• EDT — slope over 0 → −10 dB, extrapolated to a 60 dB decay time.

Loading

# Metadata + the dataset viewer:
from datasets import load_dataset
ds = load_dataset("mandipgoswami/RIR-Bench-Hard", split="all")
print(ds[0])          # one metadata row
# filter to the hardest split and valid rows:
hard = ds.filter(lambda r: r["split"] == "test_hard" and r["valid"])

# Get the audio + files (recommended for the WAVs):
from huggingface_hub import snapshot_download
local = snapshot_download("mandipgoswami/RIR-Bench-Hard", repo_type="dataset")

import pandas as pd, soundfile as sf, os
meta = pd.read_parquet(os.path.join(local, "metadata.parquet"))
row = meta[meta.valid].iloc[0]
rir, fs = sf.read(os.path.join(local, row["filepath"]))   # mono, 16 kHz, int16

To apply a RIR to clean speech, convolve: reverberant = scipy.signal.fftconvolve(speech, rir).

Splits

Reproducible, stratified per category so every split contains all five hard types. For each category the samples are ranked by a hardness score z(T60) − z(DRR) (higher T60 and lower DRR = harder); the hardest ~15% form test_hard, a seeded ~10% form dev, and the remainder is train. Resulting valid-row sizes: train 1,946 · dev 260 · test_hard 389. Id lists are in splits/{train,dev,test_hard}.txt and in the split column. test_hard is the headline evaluation set.

How to evaluate / submit

The scorer lives in eval/ and needs only numpy / scipy / soundfile:

# Identity (do-nothing) baseline — the measurement floor:
python eval/evaluate.py --metadata metadata.parquet

# Score your system from a predictions CSV (id + recovered metrics):
python eval/evaluate.py --metadata metadata.parquet --pred my_system.csv --out my_results.csv

# …or from a directory of enhanced <id>.wav outputs:
python eval/evaluate.py --metadata metadata.parquet --enhanced-dir my_outputs/

See eval/README.md for the exact submission format and metric definitions. Report the test_hard overall MAE as your headline.

Leaderboard

Mean absolute error (MAE) vs. the reference metadata, valid rows only. The identity baseline defines the measurement floor (residual is int16-storage quantisation); submit a real dereverberation / room-acoustics system to beat it.

System	split	n	MAE T60 (s)	MAE DRR (dB)	MAE C50 (dB)	MAE EDT (s)
Identity (do-nothing) baseline	overall	2,595	0.0047	0.0045	0.0086	0.0004
Identity (do-nothing) baseline	test_hard	389	0.0062	0.0023	0.0039	0.0005
your system here	test_hard	—	—	—	—	—

Full per-category baseline numbers are in eval/baseline_results.csv.

Quality control

Metadata is computed, then a QC pass marks any physically implausible row valid=False with a reason in qc_flag:

• c50_nonphysical — C50 ≥ 60 dB (late-energy underflow in a near-silent tail);
• t60_too_short — a measured T60 < 0.05 s;
• edt_inconsistent — EDT > 3·T60 + 1 s (early slope inconsistent with the full decay).

In this release 5 of 2,600 rows are flagged valid=False (4 coupled_rooms, 1 non_shoebox), all c50_nonphysical. They are kept in the file (nothing is silently dropped) but excluded from the splits and the leaderboard. The 427 near_impulsive rows are a valid flag, not an invalid one, as explained above. Every acoustic range quoted in this card is computed over valid=True rows only.

Reproducibility

• Generator: scripts/generate_rirs.py — fixed global seed 20260101 plus a deterministic per-sample seed stored in the seed column, so any RIR can be regenerated bit-for-bit.
• Metric estimators are duplicated verbatim in eval/evaluate.py so scoring is self-contained.
• metadata.csv and metadata.parquet are written from the same cleaned DataFrame in one pass.

Related datasets by the author

RIR-Bench-Hard is part of a broader room-acoustics / reverberant-speech research program on the Hub:

• mandipgoswami/rirmega — large-scale RIR collection.
• mandipgoswami/rir-mega-speech — reverberant speech built from RIRs.
• mandipgoswami/whisper-rirmega-bench — far-field ASR benchmark for Whisper under reverberation.
• mandipgoswami/rirmega-eval — evaluation suite for RIR-based tasks.

Related eval sets

Part of the same room-acoustics research program:

• mandipgoswami/audio-eval-suite — small audio-robustness eval set (clean / reverberant / noisy conditions) with reference RT60-regression and reverb-classification tasks.
• mandipgoswami/reverb-speech-mini — tiny dry/wet reverberant-speech pairs for fast dereverberation / robust-ASR sanity checks.
• mandipgoswami/RIR-Bench-Hard — adversarial room-impulse-response benchmark across five hard regimes.

Citation

@misc{goswami2026rirbenchhard,
  title        = {RIR-Bench-Hard: An Adversarial Room Impulse Response Benchmark},
  author       = {Mandip Goswami},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/mandipgoswami/RIR-Bench-Hard}}
}

License

Released under CC-BY-4.0. You are free to share and adapt with attribution. This is a new benchmark inviting submissions — no adoption or citation claims are made; the leaderboard starts from the identity baseline.