scripts/precompute_qwen_audio_cache_mp.py

#!/usr/bin/env python3
"""纯 CPU 多进程版 Qwen Whisper mel 特征预计算。

相比 `precompute_qwen_audio_cache.py` 的 torchrun 版：
  - 不占用 GPU（Whisper STFT 在 CPU 上跑本来就够快，CPU 并行是正确方向）
  - 进程数不受 GPU 卡数限制（192 核机器可以开 64+ 进程）
  - `multiprocessing.Pool` + `imap_unordered` 负载自动均衡
  - 预期 8h（单进程版）→ 10~15 分钟

典型用法（398K 条音频，32 进程，约 15 分钟）：
    python scripts/precompute_qwen_audio_cache_mp.py \\
        --qa-root /apdcephfs_cq10/.../easy \\
        --splits train valid test \\
        --cache-dir /apdcephfs_cq12/.../qwen_audio_cache_easy_v2 \\
        --num-procs 32 \\
        --no-spatial-cache \\
        --skip-existing

核心设计：
  - Pool initializer 里每个 worker 加载自己的 Qwen feature_extractor（一次，常驻）
  - 强制每个 worker `OMP_NUM_THREADS=1`，避免 numpy/MKL 多线程互相抢核
  - 用 imap_unordered + chunksize=16 降低 IPC 开销
  - `--skip-existing`：主进程先扫已完成的 .pt，只把真正 TODO 的任务下发给 worker
  - 中途中断后再跑，加 `--skip-existing` 即可续传
"""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import sys
import time
from multiprocessing import Pool
from typing import Dict, List, Optional, Tuple

import numpy as np
import soundfile as sf
import torch
from tqdm.auto import tqdm


DEFAULT_MODEL_ID = "/apdcephfs_cq10/share_1603164/user/schmittzhu/model/Qwen2.5-Omni-7B"
DEFAULT_SPATIAL_QWEN_REPO = "/apdcephfs_cq10/share_1603164/user/schmittzhu/code/Spatial-Qwen"
SAMPLE_RATE = 16000
MAX_AUDIO_SECONDS = 20
MAX_AUDIO_SAMPLES = SAMPLE_RATE * MAX_AUDIO_SECONDS


def dtype_from_name(name: str) -> torch.dtype:
    return {"float16": torch.float16, "float32": torch.float32, "bfloat16": torch.bfloat16}[name]


def build_cache_relpath(audio_path: str) -> str:
    """与 precompute_qwen_audio_cache.py 的命名完全一致，生成的 cache 两版互通。"""
    audio_path = os.path.abspath(audio_path)
    stem = os.path.splitext(os.path.basename(audio_path))[0]
    digest = hashlib.sha1(audio_path.encode("utf-8")).hexdigest()[:16]
    return f"{stem}-{digest}.pt"


def collect_unique_audio_paths(
    qa_root: str,
    splits: List[str],
    max_samples_per_split: Optional[int],
) -> List[str]:
    unique: Dict[str, None] = {}
    for split in splits:
        split_path = None
        for ext in (".jsonl", ".json"):
            candidate = os.path.join(qa_root, f"{split}{ext}")
            if os.path.exists(candidate):
                split_path = candidate
                break
        if split_path is None:
            raise FileNotFoundError(f"Missing split file for {split} under {qa_root}")
        with open(split_path, "r", encoding="utf-8") as handle:
            if split_path.endswith(".jsonl"):
                for idx, line in enumerate(handle):
                    if max_samples_per_split is not None and idx >= max_samples_per_split:
                        break
                    record = json.loads(line)
                    unique[os.path.abspath(record["audio_path"])] = None
            else:
                payload = json.load(handle)
                iterator = payload if isinstance(payload, list) else payload.get(
                    "records", payload.get("data", [])
                )
                for idx, record in enumerate(iterator):
                    if max_samples_per_split is not None and idx >= max_samples_per_split:
                        break
                    unique[os.path.abspath(record["audio_path"])] = None
    return sorted(unique.keys())


# ------------------------------------------------------------------
# Worker-level globals（每个 worker 进程独立一份）
# ------------------------------------------------------------------
_FE = None  # Qwen WhisperFeatureExtractor
_CACHE_DIR: Optional[str] = None
_CACHE_DTYPE: Optional[torch.dtype] = None
_NO_SPATIAL_CACHE: bool = False


def _init_worker(
    model_id: str,
    spatial_qwen_repo: str,
    cache_dir_abs: str,
    cache_dtype_name: str,
    no_spatial_cache: bool,
) -> None:
    global _FE, _CACHE_DIR, _CACHE_DTYPE, _NO_SPATIAL_CACHE
    # 每个 worker 强制单线程，避免 numpy/MKL/torch 内部多线程和其他 worker 抢核
    os.environ["OMP_NUM_THREADS"] = "1"
    os.environ["MKL_NUM_THREADS"] = "1"
    os.environ["OPENBLAS_NUM_THREADS"] = "1"
    os.environ["NUMEXPR_NUM_THREADS"] = "1"
    torch.set_num_threads(1)
    if spatial_qwen_repo not in sys.path:
        sys.path.insert(0, spatial_qwen_repo)
    from spatial_qwen.model.processing_qwen2_5_omni import Qwen2_5OmniProcessor
    processor = Qwen2_5OmniProcessor.from_pretrained(model_id)
    _FE = processor.feature_extractor
    _CACHE_DIR = cache_dir_abs
    _CACHE_DTYPE = dtype_from_name(cache_dtype_name)
    _NO_SPATIAL_CACHE = no_spatial_cache


def _process_one(audio_path: str) -> Tuple[str, str, Optional[str]]:
    """处理单条音频。

    Returns:
        (audio_path, relpath, error_msg)
        - error_msg=None 表示成功（或磁盘上已存在、跳过）。
    """
    global _FE, _CACHE_DIR, _CACHE_DTYPE, _NO_SPATIAL_CACHE
    try:
        relpath = build_cache_relpath(audio_path)
        out_path = os.path.join(_CACHE_DIR, relpath)

        # 在 worker 内再做一次存在检查：主进程扫完到 worker 开工之间可能已跑过
        if os.path.exists(out_path):
            return audio_path, relpath, None

        # 读 FOA 波形
        wav, sr = sf.read(audio_path, dtype="float32", always_2d=True)
        if sr != SAMPLE_RATE:
            return audio_path, "", f"bad_sample_rate={sr}"
        # sf 读出 [T, C]，我们要 [C, T]
        foa = wav.T
        if foa.ndim != 2 or foa.shape[0] != 4:
            return audio_path, "", f"bad_shape={tuple(foa.shape)}"
        if foa.shape[1] > MAX_AUDIO_SAMPLES:
            foa = foa[:, :MAX_AUDIO_SAMPLES]
        foa_length = int(foa.shape[1])
        mono = foa.mean(axis=0).astype(np.float32, copy=False)

        # Qwen Whisper mel 特征
        audio_inputs = _FE(
            [mono],
            sampling_rate=SAMPLE_RATE,
            padding="max_length",
            return_attention_mask=True,
            return_tensors="pt",
        )
        input_features = audio_inputs["input_features"]             # [1, D, T_pad]
        feature_attention_mask = audio_inputs["attention_mask"]     # [1, T_pad]
        input_lengths = (feature_attention_mask.sum(-1) - 1) // 2 + 1
        audio_token_lengths = (input_lengths - 2) // 2 + 1
        feature_length = int(feature_attention_mask[0].sum().item())

        payload = {
            "audio_path": audio_path,
            "input_features": input_features[0, :, :feature_length]
                .to(dtype=_CACHE_DTYPE)
                .contiguous(),
            "feature_length": torch.tensor(feature_length, dtype=torch.long),
            "audio_token_length": torch.tensor(
                int(audio_token_lengths[0].item()), dtype=torch.long
            ),
        }
        if not _NO_SPATIAL_CACHE:
            payload["spatial_audio"] = (
                torch.from_numpy(foa).to(dtype=_CACHE_DTYPE).contiguous()
            )
            payload["spatial_audio_length"] = torch.tensor(foa_length, dtype=torch.long)

        # 先写临时文件再原子 rename，避免主进程崩掉后 cache 里出现半成品
        tmp_path = out_path + f".tmp.{os.getpid()}"
        torch.save(payload, tmp_path)
        os.replace(tmp_path, out_path)
        return audio_path, relpath, None
    except Exception as exc:  # noqa: BLE001
        return audio_path, "", f"{type(exc).__name__}: {exc}"


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Multi-process (CPU) version of Qwen audio feature cache precompute.",
    )
    parser.add_argument("--model-id", type=str, default=DEFAULT_MODEL_ID)
    parser.add_argument("--spatial-qwen-repo", type=str, default=DEFAULT_SPATIAL_QWEN_REPO)
    parser.add_argument("--qa-root", type=str, required=True)
    parser.add_argument("--splits", nargs="+", default=["train", "valid", "test"])
    parser.add_argument("--max-samples-per-split", type=int, default=None)
    parser.add_argument("--cache-dir", type=str, required=True)
    parser.add_argument(
        "--cache-dtype",
        type=str,
        default="float16",
        choices=("float16", "float32", "bfloat16"),
    )
    parser.add_argument(
        "--no-spatial-cache",
        action="store_true",
        help="不缓存 spatial_audio 原始波形（推荐！原始 20s 4ch fp16 单条 2.5MB × 398K ≈ 1TB，"
             "不缓存后 cache 仅 ~100GB；训练时 collator 自动 fallback 到 sf.read）。",
    )
    parser.add_argument(
        "--skip-existing",
        action="store_true",
        help="跳过磁盘上已存在的 .pt 文件（支持中断续传）。",
    )
    parser.add_argument(
        "--num-procs",
        type=int,
        default=32,
        help="并发 worker 进程数。机器 192 核时 32~64 是甜区；超过 64 可能被 NFS IO 卡住。",
    )
    parser.add_argument(
        "--chunk-size",
        type=int,
        default=16,
        help="Pool.imap_unordered 的 chunksize，降低 IPC 频率。",
    )
    parser.add_argument(
        "--log-errors-every",
        type=int,
        default=50,
        help="每累积多少个错误打印一次汇总。",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    cache_dir_abs = os.path.abspath(args.cache_dir)
    os.makedirs(cache_dir_abs, exist_ok=True)
    manifest_path = os.path.join(cache_dir_abs, "manifest.json")

    # ---------- 1. 收集任务列表 ----------
    print(
        f"[{time.strftime('%H:%M:%S')}] Collecting unique audio paths from "
        f"{args.qa_root} splits={args.splits}"
    )
    all_audios = collect_unique_audio_paths(
        qa_root=args.qa_root,
        splits=list(args.splits),
        max_samples_per_split=args.max_samples_per_split,
    )
    print(f"Total unique audios: {len(all_audios):,}")

    # ---------- 2. 先过滤已完成的（skip-existing 模式） ----------
    done_entries: Dict[str, str] = {}
    if args.skip_existing:
        t_scan = time.time()
        todo: List[str] = []
        for ap in tqdm(all_audios, desc="scan existing", smoothing=0.1):
            relpath = build_cache_relpath(ap)
            if os.path.exists(os.path.join(cache_dir_abs, relpath)):
                done_entries[ap] = relpath
            else:
                todo.append(ap)
        print(
            f"[{time.strftime('%H:%M:%S')}] Scan done in {time.time()-t_scan:.1f}s: "
            f"already_done={len(done_entries):,}, todo={len(todo):,}"
        )
    else:
        todo = list(all_audios)

    # ---------- 2b. 合并已存在 manifest 的条目，避免覆盖丢失其它 split 的索引 ----------
    # 典型场景：先跑 valid+test 生成 manifest，再跑 train 时若直接 w 模式写 manifest，
    # 会丢失 valid+test 的条目。这里先读入旧 manifest（如果存在），把其中的条目合并进来。
    prior_entries: Dict[str, str] = {}
    if os.path.exists(manifest_path):
        try:
            with open(manifest_path, "r", encoding="utf-8") as fh:
                prior_payload = json.load(fh)
            prior_cache_dir = os.path.abspath(prior_payload.get("cache_dir", cache_dir_abs))
            if prior_cache_dir != cache_dir_abs:
                print(
                    f"[warn] existing manifest cache_dir={prior_cache_dir} != current={cache_dir_abs}, "
                    "skipping prior-entries merge (relpaths may not align)."
                )
            else:
                raw_prior = prior_payload.get("entries", {})
                # 过滤掉磁盘上已不存在的 .pt（防陈旧 manifest 污染）
                kept = 0
                for ap, relpath in raw_prior.items():
                    if os.path.exists(os.path.join(cache_dir_abs, relpath)):
                        prior_entries[os.path.abspath(ap)] = relpath
                        kept += 1
                print(
                    f"[merge] Loaded {kept:,}/{len(raw_prior):,} valid entries from "
                    f"existing manifest.json (stale entries dropped)"
                )
        except Exception as exc:  # noqa: BLE001
            print(f"[warn] failed to read existing manifest, ignoring: {exc}")

    entries: Dict[str, str] = dict(prior_entries)
    entries.update(done_entries)
    errors: List[Tuple[str, str]] = []

    # ---------- 3. 多进程处理 ----------
    if todo:
        print(
            f"[{time.strftime('%H:%M:%S')}] Spawning {args.num_procs} CPU workers "
            f"(chunksize={args.chunk_size}) to process {len(todo):,} audios..."
        )
        t_proc = time.time()
        with Pool(
            processes=args.num_procs,
            initializer=_init_worker,
            initargs=(
                args.model_id,
                args.spatial_qwen_repo,
                cache_dir_abs,
                args.cache_dtype,
                args.no_spatial_cache,
            ),
        ) as pool:
            it = pool.imap_unordered(_process_one, todo, chunksize=args.chunk_size)
            for audio_path, relpath, err in tqdm(
                it, total=len(todo), desc="precompute(mp)", smoothing=0.05
            ):
                if err is None:
                    entries[audio_path] = relpath
                else:
                    errors.append((audio_path, err))
                    if len(errors) % args.log_errors_every == 0:
                        tqdm.write(
                            f"[errors so far {len(errors)}] latest: {audio_path} → {err}"
                        )
        elapsed = time.time() - t_proc
        n = max(len(todo), 1)
        print(
            f"[{time.strftime('%H:%M:%S')}] Processed {len(todo):,} audios in {elapsed:.1f}s "
            f"({n/elapsed:.1f} audios/s, avg {elapsed/n*1000:.1f} ms/audio) "
            f"ok={len(todo)-len(errors):,} errors={len(errors):,}"
        )
    else:
        print("Nothing to do (all entries already cached).")

    # ---------- 4. 写 manifest ----------
    manifest_payload = {
        "cache_dir": cache_dir_abs,
        "entries": entries,
        "metadata": {
            "model_id": args.model_id,
            "qa_root": os.path.abspath(args.qa_root),
            "splits": list(args.splits),
            "num_unique_audio": len(entries),
            "sample_rate": SAMPLE_RATE,
            "max_audio_seconds": MAX_AUDIO_SECONDS,
            "cache_dtype": args.cache_dtype,
            "no_spatial_cache": args.no_spatial_cache,
            "num_errors": len(errors),
        },
    }
    with open(manifest_path, "w", encoding="utf-8") as handle:
        json.dump(manifest_payload, handle, indent=2, sort_keys=True)
    print(
        f"[{time.strftime('%H:%M:%S')}] Wrote manifest to {manifest_path} "
        f"({len(entries):,} entries)"
    )

    # ---------- 5. 错误汇总 ----------
    if errors:
        err_path = os.path.join(cache_dir_abs, "precompute_errors.jsonl")
        with open(err_path, "w", encoding="utf-8") as fh:
            for ap, msg in errors:
                fh.write(json.dumps({"audio_path": ap, "error": msg}) + "\n")
        print(
            f"Logged {len(errors):,} errors to {err_path} (first 5 below):"
        )
        for ap, msg in errors[:5]:
            print(f"  {ap} → {msg}")


if __name__ == "__main__":
    main()