Upload 21 files

benchmarks/dereverb_sisdr/README.md

@@ -0,0 +1,8 @@
+# Dereverberation baseline (SI-SDRi)
+
+Toy pipeline for generating reverberant speech by convolving clean speech with an RIR, and applying a naive magnitude shrinkage baseline.
+
+Usage: place a short `samples/clean.wav` (not included) and run:
+```bash
+python baseline_dereverb.py
+```

benchmarks/dereverb_sisdr/README.md~

@@ -0,0 +1,8 @@
+# Dereverberation baseline (SI-SDRi)
+
+Toy pipeline for generating reverberant speech by convolving clean speech with an RIR, and applying a naive magnitude shrinkage baseline.
+
+Usage: place a short `samples/clean.wav` (not included) and run:
+```bash
+python baseline_dereverb.py
+```

benchmarks/dereverb_sisdr/baseline_dereverb.py

@@ -0,0 +1,34 @@
+# benchmarks/dereverb_sisdr/baseline_dereverb.py
+import numpy as np, soundfile as sf
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+CLEAN = ROOT / "samples" / "clean.wav"          # user-provided
+RIR   = ROOT / "samples" / "rir_000053.wav"  # example path
+
+def convolve(x, h):
+    return np.convolve(x, h)[:len(x)]
+
+def sisdr(ref, est, eps=1e-8):
+    ref = ref - np.mean(ref); est = est - np.mean(est)
+    s = np.dot(est, ref) * ref / (np.dot(ref, ref) + eps)
+    e = est - s
+    return 10*np.log10((np.dot(s,s)+eps)/(np.dot(e,e)+eps))
+
+def main():
+    if not CLEAN.exists():
+        raise SystemExit(f"Missing CLEAN wav: {CLEAN}")
+    if not RIR.exists():
+        raise SystemExit(f"Missing example RIR: {RIR}")
+    x, sr = sf.read(CLEAN, dtype="float32")
+    if x.ndim > 1: x = x[:,0]
+    h, _ = sf.read(RIR, dtype="float32")
+    if h.ndim > 1: h = h[:,0]
+    y = convolve(x, h)
+    # naive baseline: shrink magnitude in time (toy)
+    y_hat = y * 0.9
+    print("SI-SDR (rev):", sisdr(x, y))
+    print("SI-SDR (est):", sisdr(x, y_hat))
+
+if __name__ == "__main__":
+    main()

benchmarks/rt60_regression/README.md

@@ -0,0 +1,19 @@
+# RT60 Regression Baseline
+
+A fast baseline predicting RT60-like targets from RIR signals using lightweight features + RandomForest.
+
+## Usage
+```bash
+pip install soundfile numpy pandas scikit-learn
+python benchmarks/rt60_regression/train_rt60.py             # auto target
+python benchmarks/rt60_regression/train_rt60.py --target rt60
+```
+
+**Default target order:**  
+`rt60, drr_db, c50_db, c80_db, band_rt60s.125, 250, 500, 1000, 2000, 4000`
+
+If you have no `valid` split, the script will carve 10% of `train` as an in-memory validation set.
+
+## Tips
+- Ensure `metadata/metadata.csv` paths match your audio under `data/` (or set `RIRMEGA_DATA_DIR`).
+- To run on a tiny subset quickly, generate `data-mini/` (see `scripts/make_mini_subset.py`) and copy this folder to a fresh repo/Space.

benchmarks/rt60_regression/README.md~

@@ -0,0 +1,9 @@
+# RT60 Regression (baseline)
+
+Simple baseline that predicts `rt60_t30` from lightweight RIR features.
+Default expects local data under `../../data`.
+
+Run:
+```bash
+python train_rt60.py
+```

benchmarks/rt60_regression/train_rt60.py

@@ -0,0 +1,115 @@
+import os, ast, json, math, argparse
+from pathlib import Path
+import numpy as np, pandas as pd, soundfile as sf
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+SCRIPT_ROOT = Path(__file__).resolve().parents[2]              # .../rirmega
+DEF_DATA_ROOT = os.getenv("RIRMEGA_DATA_DIR", str(SCRIPT_ROOT / "data/audio/rir_output_50k"))
+DEF_META = Path(DEF_DATA_ROOT) / "metadata" / "metadata.csv"
+RT60_KEYS_ORDER = ["rt60","drr_db","c50_db", "c80_db","band_rt60s.125", "band_rt60s.250","band_rt60s.500","band_rt60s.1000","band_rt60s.2000","band_rt60s.4000"]
+
+def _parse_metrics(s):
+    if s is None: return {}
+    s = str(s).strip()
+    if not s: return {}
+    for fn in (json.loads, ast.literal_eval):
+        try:
+            v = fn(s)
+            if isinstance(v, dict): return v
+        except Exception: pass
+    return {}
+
+def _deep(d, k):
+    cur = d
+    for part in k.split("."):
+        if not isinstance(cur, dict) or part not in cur: return None
+        cur = cur[part]
+    return cur
+
+def get_rt60(metrics, key=None):
+    d = _parse_metrics(metrics)
+    if not d: return None
+    if key:
+        v = _deep(d, key) if "." in key else d.get(key)
+        try: return float(v) if v is not None else None
+        except Exception: return None
+    for k in RT60_KEYS_ORDER:
+        v = _deep(d, k) if "." in k else d.get(k)
+        try:
+            if v is not None: return float(v)
+        except Exception: pass
+    return None
+
+def feats(path: Path):
+    y, sr = sf.read(str(path), dtype="float32", always_2d=False)
+    if isinstance(y, np.ndarray) and y.ndim > 1: y = y[:,0]
+    y = y.astype(np.float32, copy=False)
+    y /= (np.max(np.abs(y)) + 1e-9)
+    e = np.abs(y); e_mean, e_std = float(e.mean()), float(e.std())
+    e_skew = float((np.mean(((e - e_mean) / (e_std + 1e-9)) ** 3)))
+    e_kurt = float((np.mean(((e - e_mean) / (e_std + 1e-9)) ** 4)))
+    ce = np.cumsum(y[::-1] ** 2)[::-1] + 1e-12
+    edc_db = 10*np.log10(ce/ce[0]); n=len(edc_db); i1=int(0.05*n); i2=max(int(0.35*n), i1+5)
+    slope = float(np.polyfit(np.arange(i1,i2), edc_db[i1:i2], 1)[0])
+    Y=np.fft.rfft(y); mag=np.abs(Y); idx=np.arange(len(mag))
+    centroid = float((idx*mag).sum()/(mag.sum()+1e-9))
+    return np.array([e_mean,e_std,e_skew,e_kurt,slope,centroid], dtype=np.float32)
+
+def main():
+    ap = argparse.ArgumentParser("RT60 baseline (compact schema)")
+    ap.add_argument("--meta", default=str(DEF_META))
+    ap.add_argument("--data-root", default=str(DEF_DATA_ROOT))
+    ap.add_argument("--split-valid", default="valid")
+    ap.add_argument("--target", default=None)
+    args = ap.parse_args()
+
+    meta = pd.read_csv(args.meta)
+    if not {"wav","metrics","split"}.issubset(meta.columns):
+        raise SystemExit("metadata.csv must have wav, metrics, split columns")
+
+    # normalize splits
+    meta["split"] = meta["split"].astype(str).str.strip().str.lower()
+    tr = meta[meta["split"]=="train"].copy()
+    va = meta[meta["split"]==args.split_valid.lower()].copy()
+    if len(tr)==0: raise SystemExit("no train rows found")
+    if len(va)==0:
+        va = tr.sample(frac=0.10, random_state=42)
+        tr = tr.drop(va.index)
+        print(f"[INFO] no '{args.split_valid}' rows; using 10% of train as validation. train={len(tr)} valid={len(va)}")
+    else:
+        print(f"[INFO] using explicit splits: train={len(tr)} {args.split_valid}={len(va)}")
+
+    base = Path(args.data_root)
+
+    def build(df):
+        X=[]; y=[]
+        missing_audio=0; missing_target=0
+        for _,r in df.iterrows():
+            t = get_rt60(r["metrics"], args.target)
+            if t is None:
+                missing_target += 1
+                continue
+            p = Path(r["wav"])
+            p = p if p.is_absolute() else (base / p)
+            if not p.exists():
+                missing_audio += 1
+                continue
+            X.append(feats(p)); y.append(float(t))
+        return (np.stack(X), np.array(y, dtype=np.float32)) if X else (None,None), (missing_audio, missing_target)
+
+    (Xtr,ytr), miss_tr = build(tr)
+    (Xva,yva), miss_va = build(va)
+    if Xtr is None or Xva is None:
+        raise SystemExit(f"No usable samples: train missing (audio,target)={miss_tr}, "
+                         f"valid missing (audio,target)={miss_va}. "
+                         f"Make sure files exist under {base} and CSV 'wav' paths match.")
+
+    m = RandomForestRegressor(n_estimators=400, random_state=0, n_jobs=-1).fit(Xtr,ytr)
+    pred = m.predict(Xva)
+    mae = mean_absolute_error(yva, pred)
+    rmse = math.sqrt(mean_squared_error(yva, pred))
+    print(f"Samples: train={len(Xtr)} valid={len(Xva)} | MAE={mae:.4f}s RMSE={rmse:.4f}s")
+
+if __name__ == "__main__":
+    main()

rirmega/__init__.py

@@ -0,0 +1,10 @@
+"""
+RIR-Mega dataset loader package.
+
+Usage (after uploading to Hugging Face):
+    from datasets import load_dataset
+    ds = load_dataset("mandipgoswami/rirmega", name="default")
+"""
+from .dataset import RIRMega
+
+__all__ = ["RIRMega"]

rirmega/dataset.py

@@ -0,0 +1,177 @@
+import os
+import csv
+import datasets
+
+_CITATION = (
+    "@dataset{RIRMega2025, title={RIR-Mega}, author={Goswami, Mandip}, "
+    "year={2025}, doi={10.5281/zenodo.17387402}}"
+)
+
+_DESCRIPTION = (
+    "RIR-Mega loader for the compact metadata schema: "
+    "id,family,split,seed_room,fs,wav,room_size,absorption,absorption_bands,"
+    "max_order,source,microphone,array,metrics,rng_seed (+ optional checksum_sha256)."
+)
+
+_HOMEPAGE = "https://github.com/mandip42/rirmega"
+
+
+def _to_int(value: str, default: int = 0) -> int:
+    try:
+        return int(float(value))
+    except Exception:
+        return default
+
+
+class RIRMega(datasets.GeneratorBasedBuilder):
+    """
+    Hugging Face Datasets loader for RIR-Mega (compact schema).
+    Expects a CSV at {DATA_ROOT}/metadata/metadata.csv with the columns:
+
+        id,family,split,seed_room,fs,wav,room_size,absorption,absorption_bands,
+        max_order,source,microphone,array,metrics,rng_seed
+
+    Optional column:
+        checksum_sha256
+
+    DATA_ROOT defaults to "data" (relative to current working dir), or you can set:
+        RIRMEGA_DATA_DIR=/absolute/path/to/data
+    """
+    VERSION = datasets.Version("1.0.0")
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(
+            name="default",
+            version=VERSION,
+            description="RIR-Mega compact schema loader",
+        ),
+    ]
+
+    def _info(self) -> datasets.DatasetInfo:
+        # Keep raw CSV columns as strings so users can parse downstream as they prefer.
+        # Provide normalized 'sample_rate' (int) in addition to the raw 'fs' (string).
+        features = datasets.Features(
+            {
+                # decodes to (array, sr) when accessed
+                "audio": datasets.Audio(sampling_rate=None),
+
+                # normalized/common fields
+                "id": datasets.Value("string"),
+                "split": datasets.Value("string"),
+                "file_path": datasets.Value("string"),   # from 'wav' (CSV)
+                "sample_rate": datasets.Value("int32"),  # from 'fs' (CSV; parsed)
+
+                # raw CSV columns preserved (strings)
+                "family": datasets.Value("string"),
+                "seed_room": datasets.Value("string"),
+                "fs": datasets.Value("string"),
+                "wav": datasets.Value("string"),
+                "room_size": datasets.Value("string"),
+                "absorption": datasets.Value("string"),
+                "absorption_bands": datasets.Value("string"),
+                "max_order": datasets.Value("string"),
+                "source": datasets.Value("string"),
+                "microphone": datasets.Value("string"),
+                "array": datasets.Value("string"),
+                "metrics": datasets.Value("string"),
+                "rng_seed": datasets.Value("string"),
+
+                # optional checksum column (if you ran make_checksums.py)
+                "checksum_sha256": datasets.Value("string"),
+            }
+        )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        # Data root can be overridden via env var; otherwise defaults to ./data
+        data_root = os.getenv("RIRMEGA_DATA_DIR", "data")
+        meta_path = os.path.join(data_root, "metadata", "metadata.csv")
+
+        # We create three split generators and filter by 'split' in _generate_examples
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"meta": meta_path, "want": "train", "root": data_root},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={"meta": meta_path, "want": "valid", "root": data_root},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={"meta": meta_path, "want": "test", "root": data_root},
+            ),
+        ]
+
+    def _generate_examples(self, meta: str, want: str, root: str):
+        """
+        Yields examples filtered by the `split` column (train|valid|test).
+        Resolves relative wav paths under `root` (data root) and passes absolute
+        paths through as-is.
+        """
+        with open(meta, newline="", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            # Normalize header names once (in case of BOM/spacing)
+            headers = [h.strip().lstrip("\ufeff") for h in (reader.fieldnames or [])]
+            H = {h.lower(): h for h in headers}
+
+            required = {"id", "split", "fs", "wav"}
+            if not required.issubset(set(h.lower() for h in headers)):
+                raise ValueError(
+                    "metadata.csv missing required columns. "
+                    f"Need {sorted(required)}; have {headers}"
+                )
+
+            for idx, row in enumerate(reader):
+                split = (row.get(H["split"], "") or "").strip().lower()
+                if split != want:
+                    continue
+
+                rid = (row.get(H["id"], "") or "").strip() or str(idx)
+                fs_raw = (row.get(H["fs"], "") or "").strip()
+                wav_raw = (row.get(H["wav"], "") or "").strip()
+
+                # Normalize sample rate
+                sr = _to_int(fs_raw, default=0)
+
+                # Resolve file path for the 'audio' feature
+                if wav_raw and not os.path.isabs(wav_raw):
+                    file_abs = os.path.join(root, wav_raw)
+                else:
+                    file_abs = wav_raw
+
+                # Build example dict (keep all known columns if present)
+                ex = {
+                    # Audio is lazy-decoded by HF (path stored; bytes=None)
+                    "audio": {"path": file_abs, "bytes": None},
+
+                    # normalized/common fields
+                    "id": rid,
+                    "split": split,
+                    "file_path": wav_raw,
+                    "sample_rate": sr,
+
+                    # raw CSV fields
+                    "family": (row.get(H.get("family", ""), "") or ""),
+                    "seed_room": (row.get(H.get("seed_room", ""), "") or ""),
+                    "fs": fs_raw,
+                    "wav": wav_raw,
+                    "room_size": (row.get(H.get("room_size", ""), "") or ""),
+                    "absorption": (row.get(H.get("absorption", ""), "") or ""),
+                    "absorption_bands": (row.get(H.get("absorption_bands", ""), "") or ""),
+                    "max_order": (row.get(H.get("max_order", ""), "") or ""),
+                    "source": (row.get(H.get("source", ""), "") or ""),
+                    "microphone": (row.get(H.get("microphone", ""), "") or ""),
+                    "array": (row.get(H.get("array", ""), "") or ""),
+                    "metrics": (row.get(H.get("metrics", ""), "") or ""),
+                    "rng_seed": (row.get(H.get("rng_seed", ""), "") or ""),
+
+                    # optional checksum
+                    "checksum_sha256": (row.get("checksum_sha256", "") or row.get("CHECKSUM_SHA256", "") or ""),
+                }
+
+                yield idx, ex

rirmega/dataset.py~

@@ -0,0 +1,177 @@
+import os
+import csv
+import datasets
+
+_CITATION = (
+    "@dataset{RIRMega2025, title={RIR-Mega}, author={Goswami, Mandip}, "
+    "year={2025}, doi={10.5281/zenodo.17387402}}"
+)
+
+_DESCRIPTION = (
+    "RIR-Mega loader for the compact metadata schema: "
+    "id,family,split,seed_room,fs,wav,room_size,absorption,absorption_bands,"
+    "max_order,source,microphone,array,metrics,rng_seed (+ optional checksum_sha256)."
+)
+
+_HOMEPAGE = "https://github.com/mandip42/rirmega"
+
+
+def _to_int(value: str, default: int = 0) -> int:
+    try:
+        return int(float(value))
+    except Exception:
+        return default
+
+
+class RIRMega(datasets.GeneratorBasedBuilder):
+    """
+    Hugging Face Datasets loader for RIR-Mega (compact schema).
+    Expects a CSV at {DATA_ROOT}/metadata/metadata.csv with the columns:
+
+        id,family,split,seed_room,fs,wav,room_size,absorption,absorption_bands,
+        max_order,source,microphone,array,metrics,rng_seed
+
+    Optional column:
+        checksum_sha256
+
+    DATA_ROOT defaults to "data" (relative to current working dir), or you can set:
+        RIRMEGA_DATA_DIR=/absolute/path/to/data
+    """
+    VERSION = datasets.Version("1.0.0")
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(
+            name="default",
+            version=VERSION,
+            description="RIR-Mega compact schema loader",
+        ),
+    ]
+
+    def _info(self) -> datasets.DatasetInfo:
+        # Keep raw CSV columns as strings so users can parse downstream as they prefer.
+        # Provide normalized 'sample_rate' (int) in addition to the raw 'fs' (string).
+        features = datasets.Features(
+            {
+                # decodes to (array, sr) when accessed
+                "audio": datasets.Audio(sampling_rate=None),
+
+                # normalized/common fields
+                "id": datasets.Value("string"),
+                "split": datasets.Value("string"),
+                "file_path": datasets.Value("string"),   # from 'wav' (CSV)
+                "sample_rate": datasets.Value("int32"),  # from 'fs' (CSV; parsed)
+
+                # raw CSV columns preserved (strings)
+                "family": datasets.Value("string"),
+                "seed_room": datasets.Value("string"),
+                "fs": datasets.Value("string"),
+                "wav": datasets.Value("string"),
+                "room_size": datasets.Value("string"),
+                "absorption": datasets.Value("string"),
+                "absorption_bands": datasets.Value("string"),
+                "max_order": datasets.Value("string"),
+                "source": datasets.Value("string"),
+                "microphone": datasets.Value("string"),
+                "array": datasets.Value("string"),
+                "metrics": datasets.Value("string"),
+                "rng_seed": datasets.Value("string"),
+
+                # optional checksum column (if you ran make_checksums.py)
+                "checksum_sha256": datasets.Value("string"),
+            }
+        )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        # Data root can be overridden via env var; otherwise defaults to ./data
+        data_root = os.getenv("RIRMEGA_DATA_DIR", "data")
+        meta_path = os.path.join(data_root, "metadata", "metadata.csv")
+
+        # We create three split generators and filter by 'split' in _generate_examples
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"meta": meta_path, "want": "train", "root": data_root},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={"meta": meta_path, "want": "valid", "root": data_root},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={"meta": meta_path, "want": "test", "root": data_root},
+            ),
+        ]
+
+    def _generate_examples(self, meta: str, want: str, root: str):
+        """
+        Yields examples filtered by the `split` column (train|valid|test).
+        Resolves relative wav paths under `root` (data root) and passes absolute
+        paths through as-is.
+        """
+        with open(meta, newline="", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            # Normalize header names once (in case of BOM/spacing)
+            headers = [h.strip().lstrip("\ufeff") for h in (reader.fieldnames or [])]
+            H = {h.lower(): h for h in headers}
+
+            required = {"id", "split", "fs", "wav"}
+            if not required.issubset(set(h.lower() for h in headers)):
+                raise ValueError(
+                    "metadata.csv missing required columns. "
+                    f"Need {sorted(required)}; have {headers}"
+                )
+
+            for idx, row in enumerate(reader):
+                split = (row.get(H["split"], "") or "").strip().lower()
+                if split != want:
+                    continue
+
+                rid = (row.get(H["id"], "") or "").strip() or str(idx)
+                fs_raw = (row.get(H["fs"], "") or "").strip()
+                wav_raw = (row.get(H["wav"], "") or "").strip()
+
+                # Normalize sample rate
+                sr = _to_int(fs_raw, default=0)
+
+                # Resolve file path for the 'audio' feature
+                if wav_raw and not os.path.isabs(wav_raw):
+                    file_abs = os.path.join(root, wav_raw)
+                else:
+                    file_abs = wav_raw
+
+                # Build example dict (keep all known columns if present)
+                ex = {
+                    # Audio is lazy-decoded by HF (path stored; bytes=None)
+                    "audio": {"path": file_abs, "bytes": None},
+
+                    # normalized/common fields
+                    "id": rid,
+                    "split": split,
+                    "file_path": wav_raw,
+                    "sample_rate": sr,
+
+                    # raw CSV fields
+                    "family": (row.get(H.get("family", ""), "") or ""),
+                    "seed_room": (row.get(H.get("seed_room", ""), "") or ""),
+                    "fs": fs_raw,
+                    "wav": wav_raw,
+                    "room_size": (row.get(H.get("room_size", ""), "") or ""),
+                    "absorption": (row.get(H.get("absorption", ""), "") or ""),
+                    "absorption_bands": (row.get(H.get("absorption_bands", ""), "") or ""),
+                    "max_order": (row.get(H.get("max_order", ""), "") or ""),
+                    "source": (row.get(H.get("source", ""), "") or ""),
+                    "microphone": (row.get(H.get("microphone", ""), "") or ""),
+                    "array": (row.get(H.get("array", ""), "") or ""),
+                    "metrics": (row.get(H.get("metrics", ""), "") or ""),
+                    "rng_seed": (row.get(H.get("rng_seed", ""), "") or ""),
+
+                    # optional checksum
+                    "checksum_sha256": (row.get("checksum_sha256", "") or row.get("CHECKSUM_SHA256", "") or ""),
+                }
+
+                yield idx, ex

rirmega/schema.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+
+@dataclass
+class RIRMeta:
+    """Typed view of the compact metadata schema (all fields optional except id, split, fs, wav)."""
+    id: str
+    split: str
+    fs: str         # kept as string in CSV; parsed to int in loader as sample_rate
+    wav: str
+
+    # Optional / pass-through fields (kept as strings; parse downstream as needed)
+    family: str = ""
+    seed_room: str = ""
+    room_size: str = ""           # e.g., "[12.0, 8.0, 3.2]" or "12x8x3.2"
+    absorption: str = ""          # free-form or dict-like string
+    absorption_bands: str = ""    # free-form or dict-like string
+    max_order: str = ""
+    source: str = ""              # often dict-like string
+    microphone: str = ""          # often dict-like string
+    array: str = ""               # often dict-like string
+    metrics: str = ""             # often dict-like string
+    rng_seed: str = ""
+    checksum_sha256: str = ""     # optional column added by make_checksums.py

samples/clean.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfee1216b41a63a8910767d3a8410ccdc69ff8a16ef81776d13449353ec679a7
+size 256044

samples/rir_000003.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf57dd545496cfddc21d70226dfed089ea49afdf89ffd8185061bbcc6a61b6b8
+size 285868

samples/rir_000053.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2f6d0e47667b4cab6b196f2edaf11a8f1fb48eb9fb4a8e62d21b38732d06f57
+size 144252

scripts/make_checksums.py

@@ -0,0 +1,163 @@
+# scripts/make_checksums.py
+import argparse, csv, hashlib, pathlib, sys, os
+from collections import defaultdict
+
+def sha256(p, buf=1024*1024):
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        while chunk := f.read(buf):
+            h.update(chunk)
+    return h.hexdigest()
+
+def norm_header(h: str) -> str:
+    return (h or "").strip().lstrip("\ufeff").lower().replace(" ", "_")
+
+def norm_path_for_match(p: str) -> str:
+    # Normalize separators and remove leading .\ or ./, make POSIX-ish
+    q = p.replace("\\", "/")
+    while q.startswith("./") or q.startswith(".\\"):
+        q = q[2:]
+    return q
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--meta", default="data/metadata/metadata.csv",
+                    help="Path to metadata.csv")
+    ap.add_argument("--audio-root", default="data/audio",
+                    help="Root folder containing audio files")
+    ap.add_argument("--path-col", default=None,
+                    help="Column name that holds paths (default: auto-detect; prefers 'file_path')")
+    ap.add_argument("--checksum-col", default="checksum_sha256",
+                    help="Column name to write sha256 into")
+    args = ap.parse_args()
+
+    root = pathlib.Path(__file__).resolve().parents[1]
+    audio_root = (root / args.audio_root).resolve()
+    meta_path = (root / args.meta).resolve()
+
+    if not meta_path.exists():
+        sys.exit(f"[ERR] metadata file not found: {meta_path}")
+    if not audio_root.exists():
+        print(f"[WARN] audio root not found yet: {audio_root}")
+
+    # Build map: relative path (POSIX) -> sha256
+    print("[INFO] Scanning audio files for checksums…")
+    hashmap = {}
+    for p in audio_root.rglob("*"):
+        if p.suffix.lower() not in {".wav", ".flac"} or not p.is_file():
+            continue
+        rel = p.relative_to(root).as_posix()
+        hashmap[norm_path_for_match(rel)] = sha256(p)
+
+    # Read CSV with dialect sniffing and normalized headers
+    print(f"[INFO] Reading metadata: {meta_path}")
+    raw = meta_path.read_text(encoding="utf-8", errors="replace")
+    try:
+        dialect = csv.Sniffer().sniff(raw.splitlines()[0] if raw else ",")
+    except Exception:
+        dialect = csv.excel  # fallback to comma
+
+    rows = []
+    with open(meta_path, newline="", encoding="utf-8", errors="replace") as f:
+        reader = csv.reader(f, dialect)
+        try:
+            headers = next(reader)
+        except StopIteration:
+            sys.exit("[ERR] metadata.csv appears empty.")
+
+        norm_headers = [norm_header(h) for h in headers]
+        hdr_map = {norm_header(h): i for i, h in enumerate(headers)}
+
+        # Choose the path column
+        candidate_names = [norm_header(args.path_col)] if args.path_col else [
+            "file_path", "filepath", "path", "relative_path", "audio_path", "wav", "rir_path"
+        ]
+        path_col_norm = next((c for c in candidate_names if c in hdr_map), None)
+        if not path_col_norm:
+            msg = (f"[ERR] Could not find a path column. Looked for any of: "
+                   f"{candidate_names}. Available columns: {norm_headers}")
+            sys.exit(msg)
+
+        checksum_col_norm = norm_header(args.checksum_col)
+        # If checksum column absent, append it
+        if checksum_col_norm not in hdr_map:
+            headers.append(args.checksum_col)
+            norm_headers.append(checksum_col_norm)
+            checksum_idx = len(headers) - 1
+        else:
+            checksum_idx = hdr_map[checksum_col_norm]
+
+        path_idx = hdr_map[path_col_norm]
+
+        # Process rows
+        rows.append(headers)  # header row for writing back
+        for i, row in enumerate(reader, start=1):
+            # pad short rows
+            if len(row) < len(headers):
+                row += [""] * (len(headers) - len(row))
+            # Normalize the path for lookup
+            csv_path_raw = (row[path_idx] or "").strip()
+            if not csv_path_raw:
+                print(f"[WARN] row {i}: empty path cell; leaving checksum blank")
+                rows.append(row)
+                continue
+
+            # Try multiple lookup strategies
+            candidates = []
+
+            # 1) CSV path as given (normalized)
+            candidates.append(norm_path_for_match(csv_path_raw))
+
+            # 2) If CSV path is absolute, try making it relative to project root
+            p = pathlib.Path(csv_path_raw)
+            if p.is_absolute():
+                try:
+                    rel = p.relative_to(root).as_posix()
+                    candidates.append(norm_path_for_match(rel))
+                except Exception:
+                    pass
+
+            # 3) If CSV path is relative to audio_root
+            try:
+                rel2 = (audio_root / csv_path_raw).resolve().relative_to(root).as_posix()
+                candidates.append(norm_path_for_match(rel2))
+            except Exception:
+                pass
+
+            # 4) Fallback: match by basename if unique
+            basename = pathlib.Path(csv_path_raw).name
+            if basename:
+                # build once a reverse index by basename
+                pass
+
+            # deduplicate candidates
+            candidates = list(dict.fromkeys(candidates))
+
+            sha = ""
+            for cand in candidates:
+                sha = hashmap.get(cand, "")
+                if sha:
+                    break
+
+            # As a last resort, basename matching (unique)
+            if not sha and basename:
+                matches = [v for k, v in hashmap.items() if pathlib.Path(k).name == basename]
+                if len(matches) == 1:
+                    sha = matches[0]
+
+            row[checksum_idx] = sha
+            if not sha:
+                print(f"[WARN] row {i}: no match for '{csv_path_raw}' (tried {len(candidates)} candidates)")
+            rows.append(row)
+
+    # Write back CSV (same dialect; UTF-8)
+    print(f"[INFO] Writing updated metadata with checksums → {meta_path}")
+    with open(meta_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f, dialect)
+        writer.writerows(rows)
+
+    print("[DONE] Checksums inserted. "
+          f"Found hashes for ~{sum(1 for r in rows[1:] if r[checksum_idx])} rows.")
+
+if __name__ == "__main__":
+    main()

scripts/make_mini_subset.py

@@ -0,0 +1,47 @@
+# scripts/make_mini_subset.py
+# Create a tiny subset under data-mini/ for quick demos/Spaces.
+import os, shutil
+from pathlib import Path
+import pandas as pd
+
+ROOT = Path(__file__).resolve().parents[1]
+SRC_META = ROOT / "data" / "metadata" / "metadata.csv"
+SRC_DATA = ROOT / "data"
+DST = ROOT / "data-mini"
+
+N_TRAIN = 200
+N_VALID = 50
+
+def main():
+    if not SRC_META.exists():
+        raise SystemExit(f"Missing: {SRC_META}")
+    df = pd.read_csv(SRC_META)
+    if "wav" not in df.columns or "split" not in df.columns:
+        raise SystemExit("metadata.csv must have 'wav' and 'split' columns")
+
+    train = df[df["split"].str.lower()=="train"].sample(min(N_TRAIN, sum(df["split"].str.lower()=="train")), random_state=0)
+    valid = df[df["split"].str.lower()=="valid"]
+    if len(valid)==0:
+        valid = df[df["split"].str.lower()=="train"].drop(train.index).sample(min(N_VALID, len(df)), random_state=0)
+        valid = valid.assign(split="valid")
+
+    sub = pd.concat([train, valid], ignore_index=True).copy()
+    if DST.exists(): shutil.rmtree(DST)
+    (DST / "metadata").mkdir(parents=True, exist_ok=True)
+
+    copied = 0
+    for _, r in sub.iterrows():
+        wav = str(r["wav"]).strip()
+        src = (SRC_DATA / wav) if not os.path.isabs(wav) else Path(wav)
+        if not src.exists():
+            continue
+        dest = DST / wav
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(src, dest)
+        copied += 1
+
+    sub.to_csv(DST / "metadata" / "metadata.csv", index=False)
+    print(f"Copied {copied} files. Wrote {DST / 'metadata' / 'metadata.csv'}")
+
+if __name__ == "__main__":
+    main()

scripts/validate_metadata.py

@@ -0,0 +1,77 @@
+# scripts/validate_metadata.py
+import csv, sys, pathlib
+
+# Two accepted schemas:
+REQUIRED_A = {"rir_id","file_path","sample_rate","rir_length","method",
+              "src_x","src_y","src_z","mic_x","mic_y","mic_z",
+              "distance","azimuth_deg","elevation_deg",
+              "rt60_t20","rt60_t30","drr_db","room_l","room_w","room_h","vol_m3","split"}
+REQUIRED_B = {"id","split","fs","wav"}  # compact schema
+
+def find_default_meta():
+    here = pathlib.Path(__file__).resolve().parents[1]
+    candidates = [
+        here / "data" / "metadata" / "metadata.csv",
+        here / "data" / "metadata.csv",
+    ]
+    for p in candidates:
+        if p.exists():
+            return p
+    return None
+
+def validate(path: pathlib.Path):
+    with path.open(newline="", encoding="utf-8", errors="replace") as f:
+        r = csv.DictReader(f)
+        headers = { (h or "").strip().lstrip("\ufeff").lower() for h in (r.fieldnames or []) }
+        if REQUIRED_A.issubset(headers):
+            schema = "A"
+        elif REQUIRED_B.issubset(headers):
+            schema = "B"
+        else:
+            missingA = sorted(REQUIRED_A - headers)
+            missingB = sorted(REQUIRED_B - headers)
+            raise SystemExit(
+                "metadata.csv does not match a known schema.\n"
+                f"- Missing for Schema A: {missingA}\n"
+                f"- Missing for Schema B: {missingB}\n"
+                f"Headers seen: {sorted(headers)}"
+            )
+
+        for i,row in enumerate(r, 1):
+            if schema == "A":
+                if not (row.get("file_path") or "").strip():
+                    raise SystemExit(f"row {i}: empty file_path")
+                try:
+                    if int(float(row["sample_rate"])) <= 0:
+                        raise ValueError
+                except Exception:
+                    raise SystemExit(f"row {i}: invalid sample_rate -> {row.get('sample_rate')}")
+                try:
+                    if int(float(row["rir_length"])) <= 0:
+                        raise ValueError
+                except Exception:
+                    raise SystemExit(f"row {i}: invalid rir_length -> {row.get('rir_length')}")
+            else:
+                if not (row.get("wav") or "").strip():
+                    raise SystemExit(f"row {i}: empty wav path")
+                try:
+                    if int(float(row["fs"])) <= 0:
+                        raise ValueError
+                except Exception:
+                    raise SystemExit(f"row {i}: invalid fs -> {row.get('fs')}")
+
+    print(f"metadata OK ✅ ({schema=}) @ {path}")
+
+if __name__ == "__main__":
+    # Accept optional path; fallback to default
+    p = None
+    if len(sys.argv) >= 2 and sys.argv[1].strip():
+        p = pathlib.Path(sys.argv[1]).expanduser().resolve()
+        if not p.exists():
+            raise SystemExit(f"[ERR] Not found: {p}")
+    else:
+        p = find_default_meta()
+        if p is None:
+            raise SystemExit("Usage: python scripts/validate_metadata.py <path/to/metadata.csv>\n"
+                             "Could not auto-find data/metadata/metadata.csv")
+    validate(p)

space_app/README.md

@@ -0,0 +1,5 @@
+# RIR-Mega Space App (mini baseline)
+
+- Copy this folder's contents into a new Hugging Face **Space** (SDK: Gradio).
+- Also upload a tiny `data-mini/` next to `app.py` in the Space repo (or set `RIRMEGA_DATA_DIR`).
+- Press "Run baseline" to compute MAE/RMSE on the mini subset.

space_app/app.py

@@ -0,0 +1,100 @@
+# Simple Gradio app to run the RT60 baseline on a mini subset.
+import os, json, ast
+from pathlib import Path
+import gradio as gr
+import numpy as np
+import pandas as pd
+import soundfile as sf
+from sklearn.ensemble import RandomForestRegressor
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_ROOT = Path(os.getenv("RIRMEGA_DATA_DIR", ROOT / "data-mini"))
+META = DATA_ROOT / "metadata" / "metadata.csv"
+
+RT60_KEYS_ORDER = ["rt60","drr_db","c50_db","c80_db",
+                   "band_rt60s.125","band_rt60s.250","band_rt60s.500",
+                   "band_rt60s.1000","band_rt60s.2000","band_rt60s.4000"]
+
+def _parse_metrics(s):
+    if s is None: return {}
+    s = str(s).strip()
+    if not s: return {}
+    for fn in (json.loads, ast.literal_eval):
+        try:
+            v = fn(s)
+            if isinstance(v, dict): return v
+        except Exception: pass
+    return {}
+
+def _deep(d,k):
+    cur = d
+    for part in k.split("."):
+        if not isinstance(cur, dict) or part not in cur: return None
+        cur = cur[part]
+    return cur
+
+def feats(path: Path):
+    y, sr = sf.read(str(path), dtype="float32", always_2d=False)
+    import numpy as np
+    if isinstance(y, np.ndarray) and y.ndim > 1: y = y[:,0]
+    y = y.astype(np.float32, copy=False)
+    y /= (np.max(np.abs(y)) + 1e-9)
+    e = np.abs(y)
+    e_mean, e_std = float(e.mean()), float(e.std())
+    e_skew = float((np.mean(((e - e_mean) / (e_std + 1e-9)) ** 3)))
+    e_kurt = float((np.mean(((e - e_mean) / (e_std + 1e-9)) ** 4)))
+    ce = np.cumsum(y[::-1] ** 2)[::-1] + 1e-12
+    edc_db = 10*np.log10(ce/ce[0]); n=len(edc_db); i1=int(0.05*n); i2=max(int(0.35*n), i1+5)
+    slope = float(np.polyfit(np.arange(i1,i2), edc_db[i1:i2], 1)[0])
+    Y=np.fft.rfft(y); mag=np.abs(Y); idx=np.arange(len(mag))
+    centroid = float((idx*mag).sum()/(mag.sum()+1e-9))
+    return np.array([e_mean,e_std,e_skew,e_kurt,slope,centroid], dtype=np.float32)
+
+def run_baseline(target_key):
+    if not META.exists():
+        return "No metadata found."
+    df = pd.read_csv(META)
+    if "split" not in df.columns or "wav" not in df.columns or "metrics" not in df.columns:
+        return "metadata.csv missing columns."
+    df["split"] = df["split"].astype(str).str.lower()
+    tr = df[df["split"]=="train"]
+    va = df[df["split"]=="valid"]
+    if len(va)==0:
+        va = tr.sample(frac=0.25, random_state=0)
+        tr = tr.drop(va.index)
+
+    def build(d):
+        import numpy as np
+        X=[]; y=[]
+        for _,r in d.iterrows():
+            dct = _parse_metrics(r["metrics"])
+            val = _deep(dct, target_key) if "." in target_key else dct.get(target_key)
+            if val is None: continue
+            p = Path(r["wav"])
+            p = p if p.is_absolute() else (DATA_ROOT / p)
+            if not p.exists(): continue
+            X.append(feats(p)); y.append(float(val))
+        if not X: return None, None
+        return np.stack(X), np.array(y, dtype=np.float32)
+
+    Xtr,ytr = build(tr)
+    Xva,yva = build(va)
+    if Xtr is None or Xva is None:
+        return "No usable samples for chosen target."
+    m = RandomForestRegressor(n_estimators=300, random_state=0).fit(Xtr,ytr)
+    pred = m.predict(Xva)
+    import numpy as np
+    mae = float(np.mean(np.abs(yva-pred)))
+    rmse = float(np.sqrt(np.mean((yva-pred)**2)))
+    return f"MAE={mae:.4f}s  RMSE={rmse:.4f}s  (n_train={len(Xtr)}, n_valid={len(Xva)})"
+
+import gradio as gr
+with gr.Blocks() as demo:
+    gr.Markdown("# RIR-Mega: RT60 Baseline (mini)")
+    target = gr.Dropdown(choices=RT60_KEYS_ORDER, value="rt60", label="Target key in metrics")
+    out = gr.Markdown()
+    btn = gr.Button("Run baseline")
+    btn.click(run_baseline, [target], [out])
+
+if __name__ == "__main__":
+    demo.launch()

space_app/requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+scikit-learn
+numpy
+pandas
+soundfile