#!/usr/bin/env python3 """ Evaluate event detection by comparing the model output against the pre-rendered GT binaural file (gt_*.wav) already present in each eval output folder. Unlike evaluate_event_detection.py, this script requires NO stem reconstruction, NO 5-channel WAV, and NO dataset initialisation — the GT file is already in each sample directory alongside the model output. Interpretation -------------- The GT file encodes exactly the sources the model should output for the given command (speech + any distractors that should be kept). At the distractor time window: • SI-SNR / NXCorr (output vs GT) High → model output matches GT → model behaved correctly Low → model output diverges from GT → model failed • CLAP audio-audio similarity (output crop vs GT crop) High → output sounds like GT at that window → correct behaviour Low → output diverges from GT at that window → failure CSV output: event_detection_scores_gt.csv (compare vs event_detection_scores.csv) Bulk usage: python evaluate_event_detection_gt.py \\ --eval_outputs_dir experiments_final/combined_v1/eval_outputs_test_3k/outputs \\ --output_csv experiments_final/combined_v1/eval_outputs_test_3k/event_detection_scores_gt.csv \\ [--use_cuda] [--batch_size 256] [--num_workers 6] """ import csv import sys import json import argparse import concurrent.futures from pathlib import Path import numpy as np import torch import torch.nn.functional as F import torchaudio # ── Project root ────────────────────────────────────────────────────────────── PROJECT_ROOT = Path(__file__).parent sys.path.insert(0, str(PROJECT_ROOT)) SR = 44100 # ── Decision thresholds (single-sample display only) ───────────────────────── SISNR_THRESHOLD_DB = -10.0 NXCORR_THRESHOLD = 0.10 CLAP_THRESHOLD = 0.25 # ── CSV columns ─────────────────────────────────────────────────────────────── CSV_FIELDS = [ "sample_name", "mixture_id", "command_type", "target_sources", "distractor_key", "distractor_name", "distractor_start_s", "distractor_end_s", "gt_label", # REMOVED / PRESENT (what the model should do) "si_snr_db", # output vs GT — high = output matches GT "nxcorr", # output vs GT — high = output matches GT "clap_sim", # CLAP audio-audio: output crop vs GT crop "clap_label", # GT wav filename (for reference) "error", ] # ── Default single-sample paths ─────────────────────────────────────────────── _DEFAULT_SAMPLE_DIR = ( PROJECT_ROOT / "experiments_final/combined_v1/eval_outputs_test_3k/outputs" / "000_airport_1dist_005_rep1_v0_no_input" ) # ═══════════════════════════════════════════════════════════════════════════════ # Audio helpers # ═══════════════════════════════════════════════════════════════════════════════ def load_mono(path: Path) -> torch.Tensor: """Load any-channel WAV and mix down to mono. Returns (1, T).""" audio, sr = torchaudio.load(str(path)) assert sr == SR, f"Expected {SR} Hz, got {sr} Hz in {path}" return audio.mean(dim=0, keepdim=True) def crop_to_window(audio: torch.Tensor, start_s: float, end_s: float) -> torch.Tensor: """Crop (1, T) to [start_s, end_s) in seconds.""" return audio[:, int(start_s * SR): int(end_s * SR)] # ═══════════════════════════════════════════════════════════════════════════════ # Metrics # ═══════════════════════════════════════════════════════════════════════════════ def si_snr(estimate: torch.Tensor, reference: torch.Tensor) -> float: """SI-SNR in dB between estimate and reference (1-D tensors).""" from torchmetrics.functional import scale_invariant_signal_noise_ratio est = estimate.reshape(1, -1).float() ref = reference.reshape(1, -1).float() L = min(est.shape[-1], ref.shape[-1]) return scale_invariant_signal_noise_ratio(est[..., :L], ref[..., :L]).item() def normalized_xcorr(a: torch.Tensor, b: torch.Tensor) -> float: """Peak normalized cross-correlation in [0, 1] between two 1-D tensors.""" a = a.reshape(1, 1, -1).float() b = b.reshape(1, 1, -1).float() if a.shape[-1] < b.shape[-1]: a, b = b, a xcorr = F.conv1d(a, b) norm = (a.norm() * b.norm()).clamp(min=1e-8) return (xcorr.abs().max() / norm).item() def binary_decision(score: float, threshold: float, higher_means_correct: bool) -> str: correct = score > threshold if higher_means_correct else score < threshold return "CORRECT ✓" if correct else "WRONG ✗" # ═══════════════════════════════════════════════════════════════════════════════ # Batched CLAP (no file I/O — direct tensor path) # ═══════════════════════════════════════════════════════════════════════════════ def _prep_clap_tensor(audio: torch.Tensor, target_len: int, use_cuda: bool) -> torch.Tensor: """Replicate CLAP's load_audio_into_tensor pad/trim logic from a (1,T) tensor.""" x = audio.reshape(-1).float() if x.shape[0] >= target_len: x = x[:target_len] else: reps = int(np.ceil(target_len / x.shape[0])) x = x.repeat(reps)[:target_len] t = x.reshape(1, -1) return t.cuda() if use_cuda else t def flush_clap_batch(crops, clap_model): """ Batch CLAP audio-audio similarity: model output crop vs GT crop. crops : list of (model_crop (1,T), gt_crop (1,T), row_dict) Fills row["clap_sim"] in-place. No temp files. """ if not crops: return target_len = clap_model.args.duration * clap_model.args.sampling_rate use_cuda = getattr(clap_model, "use_cuda", False) and torch.cuda.is_available() n = len(crops) try: model_prep = [_prep_clap_tensor(mc, target_len, use_cuda) for mc, gc, row in crops] gt_prep = [_prep_clap_tensor(gc, target_len, use_cuda) for mc, gc, row in crops] batch = torch.stack(model_prep + gt_prep, dim=0) # (2N, 1, target_len) all_embs = clap_model._get_audio_embeddings(batch) # (2N, D) numpy array for i, (mc, gc, row) in enumerate(crops): a = torch.tensor(all_embs[i]).unsqueeze(0) # model output emb b = torch.tensor(all_embs[n + i]).unsqueeze(0) # GT emb row["clap_sim"] = f"{F.cosine_similarity(a, b).item():.6f}" except Exception as e: for _, _, row in crops: row["error"] = (row.get("error") or "").rstrip() + f" clap_batch:{e}" # ═══════════════════════════════════════════════════════════════════════════════ # Per-sample processing # ═══════════════════════════════════════════════════════════════════════════════ def _error_row(sample_name, mixture_id, command_type, target_sources, error): row = {f: "" for f in CSV_FIELDS} row["sample_name"] = sample_name row["mixture_id"] = mixture_id row["command_type"] = command_type row["target_sources"] = target_sources row["error"] = error return row def process_sample_signal_only(sample_dir: Path) -> tuple: """ Compute signal metrics (SI-SNR, NXCorr) for one sample using the GT wav as the reference. CLAP is handled later in batch by flush_clap_batch. Returns (rows, crops) where crops contains (model_crop, gt_crop, row_dict). """ with open(sample_dir / "metadata.json") as f: meta = json.load(f) command_type = meta["command_variant"]["command_type"] target_sources_list = meta["command_variant"]["target_sources"] target_sources = "|".join(target_sources_list) mixture_id = meta.get("mixture_id", "") # ── Find output WAV ─────────────────────────────────────────────────────── output_files = sorted(sample_dir.glob("output_*.wav")) if not output_files: return ([_error_row(sample_dir.name, mixture_id, command_type, target_sources, error="Output WAV not found")], []) # ── Find GT WAV ─────────────────────────────────────────────────────────── gt_files = sorted(sample_dir.glob("gt_*.wav")) if not gt_files: return ([_error_row(sample_dir.name, mixture_id, command_type, target_sources, error="GT WAV not found")], []) model_out_mono = load_mono(output_files[0]) # (1, T) gt_mono = load_mono(gt_files[0]) # (1, T) gt_filename = gt_files[0].name # ── Per-distractor scoring ──────────────────────────────────────────────── audio_meta = meta.get("audio_metadata", {}) distractor_info = {k: v for k, v in audio_meta.items() if k.startswith("distractor_")} if not distractor_info: return ([_error_row(sample_dir.name, mixture_id, command_type, target_sources, error="no distractor metadata")], []) rows = [] crops = [] for dist_key in sorted(distractor_info.keys()): info = distractor_info[dist_key] name = info["name"] t_start = info["mixture_start"] t_end = info["mixture_end"] gt_label = "PRESENT" if name in target_sources_list else "REMOVED" row = { "sample_name": sample_dir.name, "mixture_id": mixture_id, "command_type": command_type, "target_sources": target_sources, "distractor_key": dist_key, "distractor_name": name, "distractor_start_s": f"{t_start:.4f}", "distractor_end_s": f"{t_end:.4f}", "gt_label": gt_label, "si_snr_db": "", "nxcorr": "", "clap_sim": "", "clap_label": gt_filename, "error": "", } model_crop = crop_to_window(model_out_mono, t_start, t_end) gt_crop = crop_to_window(gt_mono, t_start, t_end) model_1d = model_crop.squeeze(0) gt_1d = gt_crop.squeeze(0) try: row["si_snr_db"] = f"{si_snr(model_1d, gt_1d):.4f}" except Exception as e: row["error"] += f"si_snr:{e} " try: row["nxcorr"] = f"{normalized_xcorr(model_1d, gt_1d):.6f}" except Exception as e: row["error"] += f"nxcorr:{e} " rows.append(row) crops.append((model_crop, gt_crop, row)) return rows, crops # ═══════════════════════════════════════════════════════════════════════════════ # Main # ═══════════════════════════════════════════════════════════════════════════════ def main(): parser = argparse.ArgumentParser( description="Evaluate event detection: model output vs GT wav.") parser.add_argument("--use_cuda", action="store_true") parser.add_argument("--eval_outputs_dir", type=str, default=None, help="Bulk mode: directory containing eval sample subfolders") parser.add_argument("--output_csv", type=str, default=None, help="Path to write scores CSV") parser.add_argument("--batch_size", type=int, default=256, help="Audio crops per CLAP batch (default 256)") parser.add_argument("--num_workers", type=int, default=6, help="Worker threads for signal metrics (default 6)") args = parser.parse_args() bulk_mode = args.eval_outputs_dir is not None print("Initializing CLAP model ...") from msclap import CLAP clap_model = CLAP(version="2023", use_cuda=args.use_cuda) # ════════════════════════════════════════════════════════════════════════ # SINGLE-SAMPLE MODE # ════════════════════════════════════════════════════════════════════════ if not bulk_mode: sample_dir = _DEFAULT_SAMPLE_DIR output_files = sorted(sample_dir.glob("output_*.wav")) gt_files = sorted(sample_dir.glob("gt_*.wav")) if not output_files or not gt_files: print("ERROR: output or GT wav not found in", sample_dir) return with open(sample_dir / "metadata.json") as f: meta = json.load(f) model_out_mono = load_mono(output_files[0]) gt_mono = load_mono(gt_files[0]) audio_meta = meta.get("audio_metadata", {}) distractor_info = {k: v for k, v in audio_meta.items() if k.startswith("distractor_")} print(f"\n{'═'*60}") print(f"Sample : {sample_dir.name}") print(f"Output : {output_files[0].name}") print(f"GT : {gt_files[0].name}") print(f"Command : {meta['command_variant']['command_type']}") print(f"Targets : {meta['command_variant']['target_sources']}") print(f"{'═'*60}") for dist_key in sorted(distractor_info.keys()): info = distractor_info[dist_key] name = info["name"] t_start = info["mixture_start"] t_end = info["mixture_end"] gt_label = ("PRESENT" if name in meta["command_variant"]["target_sources"] else "REMOVED") print(f"\n{'─'*60}") print(f"Distractor : {name} ({t_start:.3f}s – {t_end:.3f}s) gt_label={gt_label}") print() model_crop = crop_to_window(model_out_mono, t_start, t_end) gt_crop = crop_to_window(gt_mono, t_start, t_end) sisnr_score = si_snr(model_crop.squeeze(0), gt_crop.squeeze(0)) nxcorr_score = normalized_xcorr(model_crop.squeeze(0), gt_crop.squeeze(0)) print(f" SI-SNR (output vs GT) : {sisnr_score:+7.2f} dB " f"→ {binary_decision(sisnr_score, SISNR_THRESHOLD_DB, True)}") print(f" NXCorr (output vs GT) : {nxcorr_score:8.4f} " f"→ {binary_decision(nxcorr_score, NXCORR_THRESHOLD, True)}") target_len = clap_model.args.duration * clap_model.args.sampling_rate use_cuda = getattr(clap_model, "use_cuda", False) and torch.cuda.is_available() try: batch = torch.stack([ _prep_clap_tensor(model_crop, target_len, use_cuda), _prep_clap_tensor(gt_crop, target_len, use_cuda), ], dim=0) embs = clap_model._get_audio_embeddings(batch) sim = F.cosine_similarity( torch.tensor(embs[0]).unsqueeze(0), torch.tensor(embs[1]).unsqueeze(0), ).item() print(f" CLAP (output vs GT) : {sim:8.4f} " f"→ {binary_decision(sim, CLAP_THRESHOLD, True)}") except Exception as e: print(f" CLAP (output vs GT) : FAILED — {e}") print(f"\n{'═'*60}\nDone.") return # ════════════════════════════════════════════════════════════════════════ # BULK MODE # ════════════════════════════════════════════════════════════════════════ eval_outputs_dir = Path(args.eval_outputs_dir) output_csv = Path(args.output_csv) if args.output_csv else \ eval_outputs_dir.parent / "event_detection_scores_gt.csv" sample_dirs = sorted([d for d in eval_outputs_dir.iterdir() if d.is_dir()]) total = len(sample_dirs) batch_size = args.batch_size num_workers = args.num_workers print(f"\nBulk mode: {total} samples batch_size={batch_size} num_workers={num_workers}") print(f"Output: {output_csv}") print("Reference: GT wav in each sample folder (no stem reconstruction)") output_csv.parent.mkdir(parents=True, exist_ok=True) def _process_one(sd): try: return process_sample_signal_only(sd) except Exception as e: return [_error_row(sd.name, "", "", "", error=str(e))], [] with open(output_csv, "w", newline="") as csvfile: writer = csv.DictWriter(csvfile, fieldnames=CSV_FIELDS) writer.writeheader() csvfile.flush() for chunk_start in range(0, total, batch_size): chunk = sample_dirs[chunk_start: chunk_start + batch_size] end = min(chunk_start + batch_size, total) print(f"[{chunk_start+1:4d}–{end:4d}/{total}] signal metrics ...", flush=True) with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as ex: results = list(ex.map(_process_one, chunk)) chunk_rows = [] chunk_crops = [] for rows, crops in results: chunk_rows.extend(rows) chunk_crops.extend(crops) print(f" CLAP batch ({len(chunk_crops)} crops) ...", flush=True) flush_clap_batch(chunk_crops, clap_model) for row in chunk_rows: writer.writerow({f: row.get(f, "") for f in CSV_FIELDS}) csvfile.flush() print(f"\nDone. Scores written to {output_csv}") if __name__ == "__main__": main()