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