scripts/generate_test_3k.py

#!/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()