""" Run mono speech enhancement baselines (MetricGAN+, MossFormer2) on binaural eval outputs. Each ear channel is processed independently, then recombined to binaural. Computes SI-SNR improvement, SNR improvement, delta_ITD, delta_ILD. Usage: python run_baselines.py \ --input_dir experiments/TSDL_old_mixtures/eval_outputs_removeall_old \ --model metricganplus \ --output_dir experiments/metricganplus_baseline/eval_outputs_removeall_old \ --use_cuda """ import argparse import glob import json import os import shutil import tempfile import numpy as np import pandas as pd import soundfile as sf import torch import torchaudio from scipy import signal as scipy_signal from torchmetrics.functional import ( scale_invariant_signal_noise_ratio as si_snr, signal_noise_ratio as snr, ) from tqdm import tqdm SR = 44100 # --------------------------------------------------------------------------- # Spatial metrics (from src/helpers/eval_utils.py, self-contained) # --------------------------------------------------------------------------- def compute_itd(s_left, s_right, sr, t_max=None): corr = scipy_signal.correlate(s_left, s_right) corr /= np.max(np.abs(corr)) + 1e-12 mid = len(corr) // 2 + 1 cc = np.concatenate((corr[-mid:], corr[:mid])) if t_max is not None: cc = np.concatenate([cc[-t_max + 1:], cc[:t_max + 1]]) else: t_max = mid tau = np.argmax(np.abs(cc)) tau -= t_max return tau / sr * 1e6 def compute_ild(s_left, s_right): sum_sq_left = np.sum(s_left ** 2, axis=-1) sum_sq_right = np.sum(s_right ** 2, axis=-1) return 10 * np.log10((sum_sq_left + 1e-12) / (sum_sq_right + 1e-12)) def itd_diff(s_est, s_gt, sr): TMAX = int(round(1e-3 * sr)) itd_est = compute_itd(s_est[0], s_est[1], sr, TMAX) itd_gt = compute_itd(s_gt[0], s_gt[1], sr, TMAX) return np.abs(itd_est - itd_gt) def ild_diff(s_est, s_gt): ild_est = compute_ild(s_est[0], s_est[1]) ild_gt = compute_ild(s_gt[0], s_gt[1]) return np.abs(ild_est - ild_gt) # --------------------------------------------------------------------------- # Model loaders # --------------------------------------------------------------------------- def load_metricganplus(device): from speechbrain.inference.enhancement import SpectralMaskEnhancement model = SpectralMaskEnhancement.from_hparams( source="speechbrain/metricgan-plus-voicebank", savedir="pretrained_models/metricgan-plus-voicebank", run_opts={"device": str(device)}, ) return model def load_mossformer2(): from clearvoice import ClearVoice model = ClearVoice( task='speech_enhancement', model_names=['MossFormer2_SE_48K'], ) return model # --------------------------------------------------------------------------- # Enhancement functions # --------------------------------------------------------------------------- def enhance_metricganplus(model, mixture_wav, device): """ Enhance binaural audio with MetricGAN+ (16kHz mono). mixture_wav: numpy array [2, T] at 44100Hz Returns: numpy array [2, T] at 44100Hz """ resampler_down = torchaudio.transforms.Resample(SR, 16000) resampler_up = torchaudio.transforms.Resample(16000, SR) enhanced_channels = [] for ch in range(2): mono = torch.from_numpy(mixture_wav[ch]).float() # [T] mono_16k = resampler_down(mono.unsqueeze(0)).squeeze(0) # [T_16k] mono_16k_batch = mono_16k.unsqueeze(0).to(device) # [1, T_16k] lengths = torch.tensor([1.0]).to(device) enhanced = model.enhance_batch(mono_16k_batch, lengths) # [1, T_16k] enhanced = enhanced.squeeze(0).cpu() # [T_16k] enhanced_44k = resampler_up(enhanced.unsqueeze(0)).squeeze(0) # [T_44k] enhanced_channels.append(enhanced_44k.numpy()) # Match length to input min_len = min(enhanced_channels[0].shape[-1], enhanced_channels[1].shape[-1], mixture_wav.shape[-1]) output = np.stack([enhanced_channels[0][:min_len], enhanced_channels[1][:min_len]], axis=0) return output def enhance_mossformer2(model, mixture_wav): """ Enhance binaural audio with MossFormer2 (48kHz mono). mixture_wav: numpy array [2, T] at 44100Hz Returns: numpy array [2, T] at 44100Hz """ resampler_down = torchaudio.transforms.Resample(SR, 48000) resampler_up = torchaudio.transforms.Resample(48000, SR) enhanced_channels = [] for ch in range(2): mono = torch.from_numpy(mixture_wav[ch:ch+1]).float() # [1, T] mono_48k = resampler_down(mono) # [1, T_48k] # ClearVoice works with file-based I/O with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp_in, \ tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp_out: tmp_in_path = tmp_in.name tmp_out_path = tmp_out.name try: sf.write(tmp_in_path, mono_48k.numpy()[0], 48000) output_wav = model(input_path=tmp_in_path, online_write=False) # output_wav is a dict or tensor; extract numpy if isinstance(output_wav, dict): output_wav = list(output_wav.values())[0] if isinstance(output_wav, torch.Tensor): output_wav = output_wav.numpy() if isinstance(output_wav, np.ndarray): if output_wav.ndim == 1: output_wav = output_wav[np.newaxis, :] # [1, T] elif output_wav.ndim == 2 and output_wav.shape[0] > output_wav.shape[1]: output_wav = output_wav.T # ensure [C, T] enhanced_48k = torch.from_numpy(output_wav).float() if enhanced_48k.ndim == 1: enhanced_48k = enhanced_48k.unsqueeze(0) enhanced_44k = resampler_up(enhanced_48k) enhanced_channels.append(enhanced_44k.numpy()) finally: if os.path.exists(tmp_in_path): os.unlink(tmp_in_path) if os.path.exists(tmp_out_path): os.unlink(tmp_out_path) min_len = min(enhanced_channels[0].shape[-1], enhanced_channels[1].shape[-1], mixture_wav.shape[-1]) output = np.stack([enhanced_channels[0][0, :min_len], enhanced_channels[1][0, :min_len]], axis=0) return output # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description="Run mono SE baselines on binaural eval outputs") parser.add_argument('--input_dir', type=str, required=True, help="Path to eval_outputs_removeall_old dir") parser.add_argument('--model', type=str, required=True, choices=['metricganplus', 'mossformer2'], help="Baseline model to run") parser.add_argument('--output_dir', type=str, required=True, help="Output directory for baseline results") parser.add_argument('--use_cuda', action='store_true', help="Use CUDA if available") args = parser.parse_args() device = torch.device('cuda' if args.use_cuda and torch.cuda.is_available() else 'cpu') print(f"Using device: {device}") # Load model print(f"Loading {args.model}...") if args.model == 'metricganplus': model = load_metricganplus(device) else: model = load_mossformer2() print("Model loaded.") # Discover sample directories samples_dir = os.path.join(args.input_dir, 'outputs') sample_dirs = sorted([ d for d in os.listdir(samples_dir) if os.path.isdir(os.path.join(samples_dir, d)) ]) print(f"Found {len(sample_dirs)} samples") # Create output directory out_audio_dir = os.path.join(args.output_dir, 'outputs') os.makedirs(out_audio_dir, exist_ok=True) all_results = [] for sample_name in tqdm(sample_dirs, desc=f"Running {args.model}"): sample_path = os.path.join(samples_dir, sample_name) # Find mixture file mix_files = glob.glob(os.path.join(sample_path, 'mixture_*.wav')) if not mix_files: print(f" Skipping {sample_name}: no mixture file found") continue mix_path = mix_files[0] # Load audio gt_path = os.path.join(sample_path, 'gt_speech.wav') if not os.path.exists(gt_path): print(f" Skipping {sample_name}: no gt_speech.wav found") continue mixture, sr_mix = sf.read(mix_path) # [T, 2] gt, sr_gt = sf.read(gt_path) # [T, 2] mixture = mixture.T # [2, T] gt = gt.T # [2, T] # Ensure same length min_len = min(mixture.shape[-1], gt.shape[-1]) mixture = mixture[:, :min_len] gt = gt[:, :min_len] # Enhance if args.model == 'metricganplus': enhanced = enhance_metricganplus(model, mixture, device) else: enhanced = enhance_mossformer2(model, mixture) # Trim to common length min_len = min(enhanced.shape[-1], mixture.shape[-1], gt.shape[-1]) enhanced = enhanced[:, :min_len] mixture_trimmed = mixture[:, :min_len] gt_trimmed = gt[:, :min_len] # Save enhanced audio out_sample_dir = os.path.join(out_audio_dir, sample_name) os.makedirs(out_sample_dir, exist_ok=True) out_wav_name = f'output_{args.model}.wav' sf.write(os.path.join(out_sample_dir, out_wav_name), enhanced.T, SR) # soundfile expects [T, C] # Copy metadata meta_src = os.path.join(sample_path, 'metadata.json') if os.path.exists(meta_src): shutil.copy2(meta_src, os.path.join(out_sample_dir, 'metadata.json')) # Compute metrics mix_t = torch.from_numpy(mixture_trimmed).float() # [2, T] enh_t = torch.from_numpy(enhanced).float() # [2, T] gt_t = torch.from_numpy(gt_trimmed).float() # [2, T] si_snr_imp = (torch.mean(si_snr(enh_t, gt_t)) - torch.mean(si_snr(mix_t, gt_t))).item() snr_imp = (torch.mean(snr(enh_t, gt_t)) - torch.mean(snr(mix_t, gt_t))).item() d_itd = itd_diff(enhanced, gt_trimmed, SR) d_ild = ild_diff(enhanced, gt_trimmed) abs_si_snr = torch.mean(si_snr(enh_t, gt_t)).item() # Load metadata for CSV meta = {} if os.path.exists(meta_src): with open(meta_src) as f: meta = json.load(f) result = { 'scale_invariant_signal_noise_ratio': [si_snr_imp], 'signal_noise_ratio': [snr_imp], 'delta_ITD': [d_itd], 'delta_ILD': [d_ild], 'si_snr': [abs_si_snr], 'metadata': [{ 'mixture_id': meta.get('mixture_id', sample_name), 'mixture_file': meta.get('audio_file', ''), 'command_variant': meta.get('command_variant', {}), }], } all_results.append(result) # Save results.eval.pth results_pth_path = os.path.join(args.output_dir, 'results.eval.pth') torch.save(all_results, results_pth_path) print(f"Saved {results_pth_path}") # Save results.eval.csv rows = [] for r in all_results: row = { 'mixture_id': r['metadata'][0].get('mixture_id', ''), 'mixture_file': r['metadata'][0].get('mixture_file', ''), 'command_type': r['metadata'][0].get('command_variant', {}).get('command_type', ''), 'user_input': r['metadata'][0].get('command_variant', {}).get('user_input', ''), 'target_sources': ', '.join(r['metadata'][0].get('command_variant', {}).get('target_sources', [])), 'scale_invariant_signal_noise_ratio': r['scale_invariant_signal_noise_ratio'][0], 'signal_noise_ratio': r['signal_noise_ratio'][0], 'delta_ITD': r['delta_ITD'][0], 'delta_ILD': r['delta_ILD'][0], 'si_snr': r['si_snr'][0], } rows.append(row) csv_path = os.path.join(args.output_dir, 'results.eval.csv') pd.DataFrame(rows).to_csv(csv_path, index=False) print(f"Saved {csv_path}") # Print summary print("\n=== Summary ===") df = pd.DataFrame(rows) for col in ['scale_invariant_signal_noise_ratio', 'signal_noise_ratio', 'delta_ITD', 'delta_ILD', 'si_snr']: vals = df[col].values print(f" {col}: {np.mean(vals):.4f} +/- {np.std(vals):.4f}") if __name__ == '__main__': main()