#!/usr/bin/env python3 """ Generate deterministic test_3k dataset from audio_mixtures_old/test/. Creates ~3000 test files with: - Hard-copied WAV files (same audio, new name) - JSON metadata with SINGLE fixed command and pre-computed SNR values - Zero randomness when loaded by dataloader Usage: conda activate semhear_emma2 python scripts/generate_test_3k.py \ --source_dir data/audio_mixtures_old/test \ --output_dir data/audio_mixtures_old/test_3k \ --snr_speech_min -5 --snr_speech_max 15 \ --snr_dist_min -5 --snr_dist_max 15 \ --background_scaling --target_background_rms 0.1 \ --training_seed 123 \ --target_count 3000 \ --generation_seed 42 """ import argparse import os import json import glob import shutil import hashlib import logging from collections import defaultdict import numpy as np import torchaudio def parse_args(): parser = argparse.ArgumentParser( description='Generate deterministic test_3k dataset') parser.add_argument('--source_dir', type=str, required=True, help='Path to source test directory (audio_mixtures_old/test)') parser.add_argument('--output_dir', type=str, required=True, help='Path to output directory (audio_mixtures_old/test_3k)') parser.add_argument('--snr_speech_min', type=float, default=-5, help='Min speech SNR in dB') parser.add_argument('--snr_speech_max', type=float, default=15, help='Max speech SNR in dB') parser.add_argument('--snr_dist_min', type=float, default=-5, help='Min distractor SNR in dB') parser.add_argument('--snr_dist_max', type=float, default=15, help='Max distractor SNR in dB') parser.add_argument('--background_scaling', action='store_true', help='Enable background RMS scaling') parser.add_argument('--target_background_rms', type=float, default=0.1, help='Target background RMS (if scaling enabled)') parser.add_argument('--training_seed', type=int, default=123, help='Training seed (must match dataloader config)') parser.add_argument('--target_count', type=int, default=3000, help='Target number of test files to generate') parser.add_argument('--generation_seed', type=int, default=42, help='Seed for sampling variants') parser.add_argument('--dry_run', action='store_true', help='Print sampling plan without writing files') return parser.parse_args() def calculate_active_rms(signal, threshold=1e-5): """Calculate RMS only over active (non-zero) portions of the signal. Mirrors AudioMixturesSpatialDataset.calculate_active_rms() exactly. """ active_mask = np.abs(signal) > threshold if np.any(active_mask): return np.sqrt(np.mean(signal[active_mask]**2)) else: return threshold def compute_snr_info(background_mono, spatial_stems, spatial_labels, snr_config, seed): """ Compute SNR scaling factors without modifying audio. Mirrors apply_snr_mixing() logic from audio_mixtures_spatial.py exactly, but only returns the info dict and background scaling factor. Args: background_mono: Background stem (T,) numpy array spatial_stems: List of mono stems [(T,), ...] for speech/distractors spatial_labels: List of source labels ['speech', 'hammer', ...] snr_config: Dict with SNR ranges seed: Random seed for reproducible SNR sampling Returns: snr_info: Dict with per-source SNR info background_scaling_factor: Float scaling factor for background """ np.random.seed(seed) # Calculate background RMS as 0dB reference background_rms = np.sqrt(np.mean(background_mono**2)) if background_rms < 1e-8: background_rms = 1e-8 # Background scaling background_scaling_factor = 1.0 if snr_config.get('background_scaling', False): target_bg_rms = snr_config.get('target_background_rms', 0.1) background_scaling_factor = target_bg_rms / background_rms background_rms = target_bg_rms # Update reference RMS snr_info = {} for i, (stem, label) in enumerate(zip(spatial_stems, spatial_labels)): # Determine SNR range for this source type if label == 'speech': snr_range = snr_config.get('speech', {'min': 0, 'max': 0}) else: snr_range = snr_config.get('distractors', {'min': 0, 'max': 0}) # Sample SNR if snr_range['min'] == snr_range['max']: snr_db = snr_range['min'] else: snr_db = np.random.uniform(snr_range['min'], snr_range['max']) # Calculate target RMS based on SNR target_signal_rms = background_rms * (10 ** (snr_db / 20)) # Calculate current signal RMS using active-only portions current_signal_rms = calculate_active_rms(stem) if current_signal_rms < 1e-8: current_signal_rms = 1e-8 # Compute scaling factor scaling_factor = target_signal_rms / current_signal_rms snr_info[label] = { 'target_snr_db': float(snr_db), 'scaling_factor': float(scaling_factor), 'original_active_rms': float(current_signal_rms), 'target_rms': float(target_signal_rms), 'rms_calculation': 'active_only' } # Store background info snr_info['background'] = { 'reference_rms': float(background_rms), 'scaling_applied': snr_config.get('background_scaling', False), 'target_rms': float( snr_config.get('target_background_rms', background_rms) ) if snr_config.get('background_scaling', False) else float(background_rms) } return snr_info, float(background_scaling_factor) def sample_variants(json_files, target_count, generation_seed): """ Sample (file, variant_index) pairs to reach target_count. Strategy: - 1-distractor files (3 variants): take ALL variants - 2-distractor files (9 variants): stratified sample of 5 per file - 3-distractor files (27 variants): stratified sample to fill remaining Stratified = pick one from each command_type first, then fill randomly. Returns: List of (json_file_path, variant_index) tuples """ rng = np.random.RandomState(generation_seed) # Group files by distractor count files_by_distcount = defaultdict(list) for jf in json_files: with open(jf, 'r') as f: metadata = json.load(f) files_by_distcount[metadata['distractor_count']].append((jf, metadata)) selected_pairs = [] # 1-distractor: take ALL variants (3 each) for jf, metadata in files_by_distcount[1]: for vi in range(len(metadata['command_variants'])): selected_pairs.append((jf, vi)) # 2-distractor: stratified sample of 5 per file for jf, metadata in files_by_distcount[2]: chosen = _stratified_sample(metadata['command_variants'], 5, rng) for vi in chosen: selected_pairs.append((jf, vi)) # 3-distractor: fill remaining to reach target current_count = len(selected_pairs) n_3dist_files = len(files_by_distcount[3]) n_needed = target_count - current_count per_file = max(1, n_needed // n_3dist_files) leftover = n_needed - (per_file * n_3dist_files) for file_idx, (jf, metadata) in enumerate(files_by_distcount[3]): n_to_pick = per_file + (1 if file_idx < leftover else 0) n_to_pick = min(n_to_pick, len(metadata['command_variants'])) chosen = _stratified_sample(metadata['command_variants'], n_to_pick, rng) for vi in chosen: selected_pairs.append((jf, vi)) return selected_pairs def _stratified_sample(variants, n_to_pick, rng): """Pick n_to_pick variant indices, ensuring command_type diversity.""" # Group indices by command type type_groups = defaultdict(list) for vi, v in enumerate(variants): type_groups[v['command_type']].append(vi) chosen = [] # Pick one from each type first for cmd_type in ['no_input', 'remove_only', 'keep_only', 'mixed_commands']: if cmd_type in type_groups and len(type_groups[cmd_type]) > 0: idx = rng.choice(type_groups[cmd_type]) chosen.append(int(idx)) # If we already have enough, trim if len(chosen) >= n_to_pick: chosen = list(rng.choice(chosen, size=n_to_pick, replace=False)) return sorted(chosen) # Fill remaining slots randomly from unchosen variants remaining = [vi for vi in range(len(variants)) if vi not in chosen] n_extra = min(n_to_pick - len(chosen), len(remaining)) if n_extra > 0: extra = rng.choice(remaining, size=n_extra, replace=False) chosen.extend(int(x) for x in extra) return sorted(chosen) def main(): args = parse_args() logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s') # Build SNR config snr_config = { 'speech': {'min': args.snr_speech_min, 'max': args.snr_speech_max}, 'distractors': {'min': args.snr_dist_min, 'max': args.snr_dist_max}, 'background_scaling': args.background_scaling, 'target_background_rms': args.target_background_rms, } logging.info(f"SNR config: {json.dumps(snr_config, indent=2)}") logging.info(f"Training seed: {args.training_seed}") # Find all JSON files in source directory json_files = sorted(glob.glob(os.path.join(args.source_dir, '*.json'))) logging.info(f"Found {len(json_files)} source JSON files") if len(json_files) == 0: raise ValueError(f"No JSON files found in {args.source_dir}") # Sample variants selected_pairs = sample_variants(json_files, args.target_count, args.generation_seed) logging.info(f"Selected {len(selected_pairs)} (file, variant) pairs " f"(target was {args.target_count})") # Print distribution summary type_counts = defaultdict(int) dist_counts = defaultdict(int) for jf, vi in selected_pairs: with open(jf) as f: m = json.load(f) type_counts[m['command_variants'][vi]['command_type']] += 1 dist_counts[m['distractor_count']] += 1 logging.info("Command type distribution:") for ct, count in sorted(type_counts.items()): logging.info(f" {ct}: {count}") logging.info("Distractor count distribution:") for dc, count in sorted(dist_counts.items()): logging.info(f" {dc}-distractor: {count}") if args.dry_run: logging.info("Dry run complete. No files written.") return # Create output directory os.makedirs(args.output_dir, exist_ok=True) # Cache: compute SNR info once per unique WAV file snr_cache = {} # wav_path -> (snr_info, bg_scaling_factor) # Generate files for pair_idx, (json_file, variant_idx) in enumerate(selected_pairs): wav_file = json_file.replace('.json', '.wav') original_stem = os.path.splitext(os.path.basename(wav_file))[0] new_stem = f"{original_stem}_v{variant_idx}" # Load original metadata with open(json_file, 'r') as f: orig_metadata = json.load(f) # Compute SNR info (cached per unique WAV) if wav_file not in snr_cache: # Load 5-channel audio mixture_channels, file_sr = torchaudio.load(wav_file) assert file_sr == 44100, f"Expected 44.1kHz, got {file_sr}Hz" # Extract stems (same logic as dataloader) speech_stem = mixture_channels[0].numpy() background_mono = mixture_channels[1].numpy() spatial_stems = [speech_stem] spatial_labels = ['speech'] for i, distractor_name in enumerate(orig_metadata['distractors']): channel_idx = 2 + i if channel_idx < mixture_channels.shape[0]: spatial_stems.append(mixture_channels[channel_idx].numpy()) spatial_labels.append(distractor_name) # Compute SNR using ORIGINAL file path for seed (matches dataloader) file_hash = int.from_bytes( hashlib.sha256(str(wav_file).encode()).digest()[:4], 'little') snr_seed = file_hash + args.training_seed snr_info, bg_scaling_factor = compute_snr_info( background_mono, spatial_stems, spatial_labels, snr_config, snr_seed) snr_cache[wav_file] = (snr_info, bg_scaling_factor) else: snr_info, bg_scaling_factor = snr_cache[wav_file] # Get the specific command variant command_variant = orig_metadata['command_variants'][variant_idx] # Build new metadata (NO command_variants list — only singular command_variant) new_metadata = { 'mixture_id': new_stem, 'original_mixture_id': orig_metadata['mixture_id'], 'scene_name': orig_metadata['scene_name'], 'distractor_count': orig_metadata['distractor_count'], 'distractors': orig_metadata['distractors'], 'audio_file': f"{new_stem}.wav", 'split': 'test', 'audio_metadata': orig_metadata['audio_metadata'], # SINGULAR command_variant (not a list) 'command_variant': command_variant, # Pre-computed SNR info 'snr_info': snr_info, 'background_scaling_factor': bg_scaling_factor, } # Write new JSON new_json_path = os.path.join(args.output_dir, f"{new_stem}.json") with open(new_json_path, 'w') as f: json.dump(new_metadata, f, indent=2) # Hard copy WAV new_wav_path = os.path.join(args.output_dir, f"{new_stem}.wav") shutil.copy2(wav_file, new_wav_path) if (pair_idx + 1) % 100 == 0: logging.info(f"Generated {pair_idx + 1}/{len(selected_pairs)} files") logging.info(f"Done. Generated {len(selected_pairs)} files in {args.output_dir}") # Write generation manifest manifest = { 'total_files': len(selected_pairs), 'source_dir': os.path.abspath(args.source_dir), 'output_dir': os.path.abspath(args.output_dir), 'snr_config': snr_config, 'training_seed': args.training_seed, 'generation_seed': args.generation_seed, 'target_count': args.target_count, 'command_type_distribution': dict(type_counts), 'distractor_count_distribution': {str(k): v for k, v in dist_counts.items()}, } manifest_path = os.path.join(args.output_dir, '_generation_manifest.json') with open(manifest_path, 'w') as f: json.dump(manifest, f, indent=2) logging.info(f"Manifest written to {manifest_path}") if __name__ == '__main__': main()