| 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] |
| 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") |
|
|
| |
| 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() |
|
|
