Add KazMix-3 manifests + generation scripts

.gitattributes

@@ -58,3 +58,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+test_clean_kazakh3mix_lufsfix_posneg.json filter=lfs diff=lfs merge=lfs -text
+train_clean_100_kazakh3mix_lufsfix_posneg.json filter=lfs diff=lfs merge=lfs -text
+val_kazakh3mix_lufsfix_posneg.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,27 @@
+---
+license: cc-by-4.0
+language: [kk]
+task_categories: [automatic-speech-recognition]
+tags: [target-speaker-asr, speech-separation, kazakh, overlapping-speech]
+pretty_name: KazMix-3
+---
+
+# KazMix-3
+
+Kazakh three-speaker overlapping-speech dataset for **target-speaker ASR (TS-ASR)**, released with the [Persona-ASR](https://github.com/IS2AI/Persona_ASR) project.
+
+This repository provides the **mixture manifests** and the **generation scripts**, not the audio. Mixtures are derived from the **Kazakh Speech Dataset (KSD, [OpenSLR 140](https://www.openslr.org/140/))**; download KSD and run the scripts to reproduce the audio locally.
+
+## Contents
+- `train_clean_100_kazakh3mix_lufsfix_posneg.json`, `val_kazakh3mix_lufsfix_posneg.json`, `test_clean_kazakh3mix_lufsfix_posneg.json` — target-speaker manifests with positive (target-present) and negative (target-absent) trials.
+- `scripts/` — LUFS-uniform 3-speaker mixture generation and manifest building.
+
+## Manifest fields
+Each entry includes `mixture_audio`, `enrollment_audio`, `transcript`, `speaker_id`, `target_index`, `sample_type` (positive/negative), `label`, and mixing metadata.
+
+## Regenerating the audio
+1. Download KSD from https://www.openslr.org/140/.
+2. Run `scripts/rerender_kazakh3mix_lufs_uniform.py` (see the Persona-ASR repo for full setup), pointing it at your local KSD path.
+
+## Citation
+Please cite Persona-ASR and KSD (OpenSLR 140).

scripts/build_official_librimix3_persona_manifest.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Build target-speaker manifests from official Libri3Mix clean/max audio.
+
+Each positive row points at a Libri3Mix mixture and one present source. Each
+negative row uses the same mixture but an enrollment utterance from a speaker
+that is absent from the mixture. Negatives are sampled at a fixed ratio of the
+positive count per split.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import random
+from pathlib import Path
+
+import pandas as pd
+import soundfile as sf
+
+
+SPLITS = {
+    "train_clean_100": ("libri3mix_train-clean-100.csv", "train-100"),
+    "val": ("libri3mix_dev-clean.csv", "dev"),
+    "test_clean": ("libri3mix_test-clean.csv", "test"),
+}
+
+
+def utt_id_from_rel(path: str) -> str:
+    return Path(path).stem
+
+
+def speaker_id_from_rel(path: str) -> str:
+    return Path(path).parts[-3]
+
+
+def load_transcripts(librispeech_dir: Path) -> dict[str, str]:
+    transcripts: dict[str, str] = {}
+    for trans_path in librispeech_dir.rglob("*.trans.txt"):
+        with trans_path.open("r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                utt, text = line.split(" ", 1)
+                transcripts[utt] = text
+    return transcripts
+
+
+def duration_sec(path: Path) -> float:
+    info = sf.info(str(path))
+    return float(info.frames) / float(info.samplerate)
+
+
+def existing_source_paths(row: pd.Series, librispeech_dir: Path) -> list[Path]:
+    return [librispeech_dir / str(row[f"source_{i}_path"]) for i in range(1, 4)]
+
+
+def make_positive(
+    *,
+    row: pd.Series,
+    split_dir: Path,
+    librispeech_dir: Path,
+    transcripts: dict[str, str],
+    source_idx: int,
+    root: Path,
+) -> dict:
+    mix_id = str(row["mixture_ID"])
+    source_rel = str(row[f"source_{source_idx}_path"])
+    source_path = librispeech_dir / source_rel
+    utt_id = utt_id_from_rel(source_rel)
+    speaker_id = speaker_id_from_rel(source_rel)
+    mix_path = split_dir / "mix_clean" / f"{mix_id}.wav"
+    target_path = split_dir / f"s{source_idx}" / f"{mix_id}.wav"
+    return {
+        "id": f"{mix_id}_target_{source_idx - 1}_pos",
+        "mixture_id": mix_id,
+        "mixture_audio": str(mix_path.resolve()),
+        "enrollment_audio": str(source_path.resolve()),
+        "enrollment_clean_source_path": str(source_path.resolve()),
+        "transcript": transcripts.get(utt_id, ""),
+        "speaker_id": speaker_id,
+        "target_speaker_id": speaker_id,
+        "target_index": source_idx - 1,
+        "duration": duration_sec(mix_path),
+        "sample_type": "positive",
+        "class": "positive",
+        "label": 1,
+        "is_target_present": True,
+        "clean_source_rel": source_rel,
+        "clean_source_path": str(source_path.resolve()),
+        "target_in_mix_path": str(target_path.resolve()),
+        "mixture_variant": "official_librimix3_wav16k_max_mix_clean",
+        "dataset_root": str(root.resolve()),
+    }
+
+
+def make_negative(
+    *,
+    row: pd.Series,
+    split_dir: Path,
+    absent_source: Path,
+    transcripts: dict[str, str],
+    neg_idx: int,
+    root: Path,
+) -> dict:
+    mix_id = str(row["mixture_ID"])
+    source_rel = str(absent_source.relative_to(root / "LibriSpeech"))
+    utt_id = absent_source.stem
+    speaker_id = speaker_id_from_rel(source_rel)
+    mix_path = split_dir / "mix_clean" / f"{mix_id}.wav"
+    return {
+        "id": f"{mix_id}_neg_{neg_idx}",
+        "mixture_id": mix_id,
+        "mixture_audio": str(mix_path.resolve()),
+        "enrollment_audio": str(absent_source.resolve()),
+        "enrollment_clean_source_path": str(absent_source.resolve()),
+        "transcript": "",
+        "speaker_id": speaker_id,
+        "target_speaker_id": speaker_id,
+        "target_index": None,
+        "duration": duration_sec(mix_path),
+        "sample_type": "negative",
+        "class": "negative",
+        "label": 0,
+        "is_target_present": False,
+        "clean_source_rel": source_rel,
+        "clean_source_path": str(absent_source.resolve()),
+        "target_in_mix_path": None,
+        "negative_reference_transcript": transcripts.get(utt_id, ""),
+        "mixture_variant": "official_librimix3_wav16k_max_mix_clean",
+        "dataset_root": str(root.resolve()),
+    }
+
+
+def validate_rendered_split(split_dir: Path, expected_mixes: int) -> None:
+    required_dirs = ["mix_clean", "s1", "s2", "s3"]
+    counts = {d: len(list((split_dir / d).glob("*.wav"))) for d in required_dirs}
+    missing = {k: v for k, v in counts.items() if v != expected_mixes}
+    if missing:
+        raise RuntimeError(f"Incomplete rendered split {split_dir}: counts={counts}, expected={expected_mixes}")
+
+
+def build_split(
+    *,
+    name: str,
+    csv_path: Path,
+    split_dir: Path,
+    librispeech_dir: Path,
+    transcripts: dict[str, str],
+    out_dir: Path,
+    root: Path,
+    negative_ratio: float,
+    seed: int,
+) -> dict:
+    df = pd.read_csv(csv_path)
+    validate_rendered_split(split_dir, len(df))
+    split_enrollments: list[Path] = []
+    for _, row in df.iterrows():
+        split_enrollments.extend(existing_source_paths(row, librispeech_dir))
+    positives: list[dict] = []
+    present_by_mix: list[set[str]] = []
+    for _, row in df.iterrows():
+        present = {speaker_id_from_rel(str(row[f"source_{i}_path"])) for i in range(1, 4)}
+        present_by_mix.append(present)
+        for source_idx in range(1, 4):
+            rec = make_positive(
+                row=row,
+                split_dir=split_dir,
+                librispeech_dir=librispeech_dir,
+                transcripts=transcripts,
+                source_idx=source_idx,
+                root=root,
+            )
+            if not rec["transcript"]:
+                raise RuntimeError(f"Missing transcript for {rec['clean_source_path']}")
+            positives.append(rec)
+
+    rng = random.Random(seed)
+    target_negatives = math.floor(len(positives) * negative_ratio)
+    negatives: list[dict] = []
+    rows = list(df.iterrows())
+    attempts = 0
+    while len(negatives) < target_negatives:
+        row_idx, row = rows[len(negatives) % len(rows)]
+        present = present_by_mix[row_idx]
+        candidate = rng.choice(split_enrollments)
+        attempts += 1
+        if speaker_id_from_rel(str(candidate.relative_to(librispeech_dir))) in present:
+            if attempts > target_negatives * 100:
+                raise RuntimeError("Could not sample enough absent-speaker negatives")
+            continue
+        negatives.append(
+            make_negative(
+                row=row,
+                split_dir=split_dir,
+                absent_source=candidate,
+                transcripts=transcripts,
+                neg_idx=len(negatives),
+                root=root,
+            )
+        )
+
+    records = positives + negatives
+    rng.shuffle(records)
+    out_path = out_dir / f"{name}_official_libri3mix_clean_max_16k_posneg.json"
+    out_path.write_text(json.dumps(records, indent=2), encoding="utf-8")
+    return {
+        "manifest": str(out_path),
+        "total": len(records),
+        "positive": len(positives),
+        "negative": len(negatives),
+        "negative_ratio": len(negatives) / max(1, len(positives)),
+    }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--root", type=Path, default=Path("/workspace/LibriMix/storage_dir"))
+    ap.add_argument("--metadata-dir", type=Path, default=Path("/workspace/LibriMix/metadata/Libri3Mix"))
+    ap.add_argument("--out-dir", type=Path, default=Path("/workspace/new/data/LibriMix/persona_asr/official_libri3mix_clean_max_16k"))
+    ap.add_argument("--negative-ratio", type=float, default=0.5)
+    ap.add_argument("--seed", type=int, default=1337)
+    args = ap.parse_args()
+
+    root = args.root
+    librispeech_dir = root / "LibriSpeech"
+    librimix_dir = root / "Libri3Mix" / "wav16k" / "max"
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+
+    transcripts = load_transcripts(librispeech_dir)
+    summary = {}
+    for idx, (name, (csv_name, split_name)) in enumerate(SPLITS.items()):
+        summary[name] = build_split(
+            name=name,
+            csv_path=args.metadata_dir / csv_name,
+            split_dir=librimix_dir / split_name,
+            librispeech_dir=librispeech_dir,
+            transcripts=transcripts,
+            out_dir=args.out_dir,
+            root=root,
+            negative_ratio=args.negative_ratio,
+            seed=args.seed + idx,
+        )
+
+    summary_path = args.out_dir / "summary.json"
+    summary_path.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/fix_kazakh3mix_enrollment_leakage.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Replace leaked enrollments in Kazakh3Mix manifests.
+
+A "leaked positive" is one where `enrollment_audio` is identical to one of the
+clean source clips that appear in the mixture (`source_clean_paths`). For each
+such row, pick a different utterance from the SAME target speaker (in the same
+split's source directory) that does not appear in `source_clean_paths`.
+
+Only the enrollment fields are touched. Speakers, splits, mixture audio, target
+indices, and labels are unchanged.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import random
+from collections import defaultdict
+from pathlib import Path
+
+
+SPLIT_DIR = {"train": "train-100", "val": "dev", "test": "test"}
+CLEAN_ROOT = Path("/workspace/LibriMix/storage_dir/KazakhSpeech3Mix/wav16k")
+
+
+def index_speaker_utterances(split_dir_name: str) -> dict[str, list[str]]:
+    """speaker_id -> sorted list of clean utterance paths in that split."""
+    root = CLEAN_ROOT / split_dir_name
+    index: dict[str, list[str]] = defaultdict(list)
+    if not root.exists():
+        return index
+    for spk_dir in root.iterdir():
+        if not spk_dir.is_dir():
+            continue
+        for wav in spk_dir.iterdir():
+            if wav.suffix.lower() == ".wav":
+                index[spk_dir.name].append(str(wav))
+    for k in index:
+        index[k].sort()
+    return index
+
+
+def fix_manifest(in_path: Path, out_path: Path, split_dir_name: str, seed: int) -> dict:
+    rows = json.loads(in_path.read_text())
+    speaker_index = index_speaker_utterances(split_dir_name)
+    rng = random.Random(seed)
+
+    n_pos = sum(1 for r in rows if r.get("is_target_present"))
+    n_leaked = 0
+    n_fixed = 0
+    n_unfixable = 0
+
+    for r in rows:
+        if not r.get("is_target_present"):
+            continue
+        enr = r.get("enrollment_audio")
+        sources = list(r.get("source_clean_paths") or [])
+        if enr not in sources:
+            continue
+        n_leaked += 1
+
+        spk = str(r.get("target_speaker_id") or r.get("speaker_id"))
+        forbidden = set(sources)
+        # Also forbid the original (leaked) enrollment so we definitely replace it.
+        forbidden.add(enr)
+        candidates = [u for u in speaker_index.get(spk, []) if u not in forbidden]
+        if not candidates:
+            # Fallback: any utterance from this speaker that differs from current enrollment.
+            candidates = [u for u in speaker_index.get(spk, []) if u != enr]
+        if not candidates:
+            n_unfixable += 1
+            continue
+        new_enr = rng.choice(candidates)
+        r["enrollment_audio"] = new_enr
+        r["enrollment_clean_source_path"] = new_enr
+        # also propagate to top-level fields used in some downstream code
+        if r.get("clean_source_path") == enr:
+            r["clean_source_path"] = new_enr
+        n_fixed += 1
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(rows, ensure_ascii=False, indent=2))
+    return {
+        "in": str(in_path), "out": str(out_path),
+        "positives": n_pos, "leaked": n_leaked,
+        "fixed": n_fixed, "unfixable": n_unfixable,
+    }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in-dir", type=Path,
+                    default=Path("data/LibriMix/persona_asr/kazakh3mix_clean_max_16k_lufsfix"))
+    ap.add_argument("--out-dir", type=Path,
+                    default=Path("data/LibriMix/persona_asr/kazakh3mix_clean_max_16k_lufsfix"),
+                    help="Default: overwrite in_dir in place.")
+    ap.add_argument("--seed", type=int, default=20260617)
+    args = ap.parse_args()
+
+    summary = []
+    plans = [
+        ("train", "train_clean_100_kazakh3mix_lufsfix_posneg.json"),
+        ("val",   "val_kazakh3mix_lufsfix_posneg.json"),
+        ("test",  "test_clean_kazakh3mix_lufsfix_posneg.json"),
+    ]
+    for split, fname in plans:
+        in_p = args.in_dir / fname
+        out_p = args.out_dir / fname
+        s = fix_manifest(in_p, out_p, SPLIT_DIR[split], args.seed + hash(split) % 10_000)
+        s["split"] = split
+        summary.append(s)
+        print(f"  {split:>5}: positives={s['positives']:>6} leaked={s['leaked']:>4} "
+              f"fixed={s['fixed']:>4} unfixable={s['unfixable']:>3}")
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/rerender_kazakh3mix_lufs_uniform.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""Re-render Kazakh3Mix mixtures using LibriMix's true LUFS-uniform convention.
+
+The existing Kazakh3Mix renders use an SNR-driven scheme: all sources normalized
+to -25 LUFS, then the target rescaled to be loudness-louder than the interferers.
+That makes the Kazakh target +3.6 dB louder relative to the combined interferers
+than the official LibriMix renders (where each source LUFS is drawn from
+Uniform[-33, -25] independently and the resulting target/(sum interferers) is
+naturally ~-3.5 dB).
+
+This script:
+  - reads the EXISTING posneg manifests (preserves speaker assignments, splits,
+    pos/neg labels, enrollment/target pairings — none of those are broken),
+  - for each mixture, re-loads the 3 clean source files referenced by
+    `source_clean_paths`,
+  - draws each source's loudness independently from Uniform[-33, -25] LUFS,
+  - normalizes each via pyloudnorm, sums, prevents clipping (scale down only),
+  - writes new mix_clean / s1 / s2 / s3 wavs into a parallel output directory,
+  - writes a new manifest with `mixture_audio` / `target_in_mix_path` / `s*_path`
+    rewritten and the *observed* per-source SNR re-measured.
+
+Run:
+  python scripts/rerender_kazakh3mix_lufs_uniform.py \
+    --in-manifest data/LibriMix/persona_asr/kazakh3mix_clean_max_16k/train_clean_100_kazakh3mix_clean_max_16k_posneg.json \
+    --out-audio-root /workspace/LibriMix/storage_dir/Kazakh3Mix_lufsfix/wav16k/max/train-100 \
+    --out-manifest data/LibriMix/persona_asr/kazakh3mix_clean_max_16k_lufsfix/train_clean_100_kazakh3mix_lufsfix_posneg.json \
+    --workers 16
+
+Tiny smoke-test mode: pass `--limit 100` to render only the first 100 mixtures.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import warnings
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import numpy as np
+import soundfile as sf
+from tqdm.auto import tqdm
+
+warnings.filterwarnings("ignore")
+import pyloudnorm as pyln  # noqa: E402
+
+SR = 16_000
+LUFS_MIN = -33.0
+LUFS_MAX = -25.0
+SILENCE_LUFS = -70.0
+MAX_AMP = 0.9
+EPS = 1e-12
+
+
+def lufs_of(audio: np.ndarray) -> float:
+    if len(audio) < int(0.4 * SR):
+        return SILENCE_LUFS
+    meter = pyln.Meter(SR)
+    try:
+        L = float(meter.integrated_loudness(audio.astype(np.float64)))
+        return L if np.isfinite(L) else SILENCE_LUFS
+    except Exception:
+        return SILENCE_LUFS
+
+
+def normalize_to_lufs(audio: np.ndarray, target_lufs: float) -> np.ndarray:
+    cur = lufs_of(audio)
+    if cur <= SILENCE_LUFS + 1.0:
+        return audio.astype(np.float32)
+    gain = 10.0 ** ((target_lufs - cur) / 20.0)
+    return (audio.astype(np.float32) * gain)
+
+
+def measure_snr_db(target: np.ndarray, interf_sum: np.ndarray) -> float:
+    n = max(len(target), len(interf_sum))
+    t = np.zeros(n, dtype=np.float64); t[: len(target)] = target
+    i = np.zeros(n, dtype=np.float64); i[: len(interf_sum)] = interf_sum
+    pt = float((t * t).mean() + EPS)
+    pi = float((i * i).mean() + EPS)
+    return 10.0 * np.log10(pt / pi)
+
+
+def render_one(args: tuple) -> dict | None:
+    """Render one mixture. Returns updated manifest row or None on failure."""
+    row, out_audio_root, seed = args
+    try:
+        target_index = row.get("target_index")
+        is_pos = bool(row.get("is_target_present") or (row.get("label") == 1))
+        source_paths = row.get("source_clean_paths") or []
+        if not source_paths or len(source_paths) != 3:
+            return None
+        # Load sources
+        sources = []
+        for p in source_paths:
+            wav, sr = sf.read(p, dtype="float32")
+            if wav.ndim == 2:
+                wav = wav.mean(axis=1)
+            if sr != SR:
+                return None
+            sources.append(wav.astype(np.float32))
+
+        # LUFS-uniform sampling
+        rng = random.Random(seed)
+        lufs_targets = [rng.uniform(LUFS_MIN, LUFS_MAX) for _ in range(3)]
+        scaled = [normalize_to_lufs(w, l) for w, l in zip(sources, lufs_targets)]
+
+        # Pad to max length, sum (max mode)
+        n = max(len(s) for s in scaled)
+        padded = [np.concatenate([s, np.zeros(n - len(s), dtype=np.float32)]) for s in scaled]
+        mix = np.sum(padded, axis=0).astype(np.float64)
+
+        # Clipping prevention (only scale DOWN — LibriMix recipe)
+        peak = float(np.max(np.abs(mix))) if mix.size else 0.0
+        clip_scale = 1.0
+        if peak > MAX_AMP:
+            clip_scale = MAX_AMP / peak
+            mix = mix * clip_scale
+            padded = [(p * clip_scale).astype(np.float32) for p in padded]
+
+        mix = mix.astype(np.float32)
+
+        # Observed SNR (target vs sum of two interferers)
+        snr_db = None
+        if is_pos and target_index is not None and 0 <= int(target_index) < 3:
+            ti = int(target_index)
+            others = [padded[i] for i in range(3) if i != ti]
+            snr_db = round(float(measure_snr_db(padded[ti], np.sum(others, axis=0))), 3)
+
+        # Write files
+        mix_id = row.get("mixture_id")
+        out_audio_root = Path(out_audio_root)
+        (out_audio_root / "mix_clean").mkdir(parents=True, exist_ok=True)
+        for si in ("s1", "s2", "s3"):
+            (out_audio_root / si).mkdir(parents=True, exist_ok=True)
+        mix_path = out_audio_root / "mix_clean" / f"{mix_id}.wav"
+        sf.write(str(mix_path), mix, SR, subtype="PCM_16")
+        s_paths = []
+        for i, p in enumerate(padded, start=1):
+            sp = out_audio_root / f"s{i}" / f"{mix_id}.wav"
+            sf.write(str(sp), p.astype(np.float32), SR, subtype="PCM_16")
+            s_paths.append(str(sp))
+
+        # Build updated row
+        out_row = dict(row)
+        out_row["mixture_audio"] = str(mix_path)
+        out_row["s1_path"] = s_paths[0]
+        out_row["s2_path"] = s_paths[1]
+        out_row["s3_path"] = s_paths[2]
+        out_row["target_in_mix_path"] = s_paths[int(target_index)] if (is_pos and target_index is not None) else None
+        out_row["snr_db"] = snr_db
+        out_row["requested_snr_db"] = None  # no longer requested; observed only
+        out_row["source_snr_scale"] = None
+        out_row["controlled_source_index"] = None
+        out_row["lufs_per_source"] = [round(l, 3) for l in lufs_targets]
+        out_row["clip_scale"] = round(clip_scale, 6)
+        out_row["mixture_variant"] = "kazakh3mix_wav16k_max_mix_clean_lufsfix"
+        return out_row
+    except Exception as e:
+        return {"_error": f"{type(e).__name__}: {e}", "id": row.get("id")}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in-manifest", type=Path, required=True)
+    ap.add_argument("--out-audio-root", type=Path, required=True,
+                    help="e.g. /workspace/LibriMix/storage_dir/Kazakh3Mix_lufsfix/wav16k/max/train-100")
+    ap.add_argument("--out-manifest", type=Path, required=True)
+    ap.add_argument("--workers", type=int, default=16)
+    ap.add_argument("--limit", type=int, default=0,
+                    help="Render only first N rows (smoke test). 0 = all.")
+    ap.add_argument("--seed", type=int, default=42)
+    args = ap.parse_args()
+
+    rows = json.loads(args.in_manifest.read_text())
+    if args.limit and args.limit > 0:
+        rows = rows[: args.limit]
+    print(f"[rerender] in={args.in_manifest.name} rows={len(rows)} → out_audio={args.out_audio_root} workers={args.workers}")
+
+    args.out_audio_root.mkdir(parents=True, exist_ok=True)
+    args.out_manifest.parent.mkdir(parents=True, exist_ok=True)
+
+    rng = random.Random(args.seed)
+    jobs = [(row, str(args.out_audio_root), rng.randint(0, 10**9)) for row in rows]
+    new_rows: list[dict] = []
+    errors = 0
+    with ProcessPoolExecutor(max_workers=args.workers) as pool:
+        futures = [pool.submit(render_one, j) for j in jobs]
+        for fut in tqdm(as_completed(futures), total=len(futures), desc=args.in_manifest.stem):
+            r = fut.result()
+            if r is None:
+                errors += 1
+                continue
+            if "_error" in r:
+                errors += 1
+                continue
+            new_rows.append(r)
+
+    new_rows.sort(key=lambda r: r.get("id", ""))
+    args.out_manifest.write_text(json.dumps(new_rows, ensure_ascii=False, indent=2))
+    print(f"[rerender] wrote {args.out_manifest} ({len(new_rows)} rows; {errors} errors)")
+
+    # Quick stats
+    pos = [r for r in new_rows if r.get("is_target_present")]
+    snrs = [r.get("snr_db") for r in pos if r.get("snr_db") is not None]
+    if snrs:
+        a = np.array(snrs)
+        print(f"[rerender] observed target/(sum interferers) SNR (positives): "
+              f"mean={a.mean():+.2f} std={a.std():.2f} p10={np.percentile(a, 10):+.2f} p90={np.percentile(a, 90):+.2f}")
+
+
+if __name__ == "__main__":
+    main()

test_clean_kazakh3mix_lufsfix_posneg.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:586fcecbd265331c01a53161044a6762678f4fcbb01bb1032704a818106a5f38
+size 29947999

train_clean_100_kazakh3mix_lufsfix_posneg.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a592d42d462c7110cafa60020b17a04f270b36c829e582b5ca29396ab2d6d90
+size 144716595

val_kazakh3mix_lufsfix_posneg.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33387b3deaf4cee6e04bfc457758197977a12f7c62686751811660c6e7121862
+size 29749563