scripts/bench_test_generate_af3.py

"""Generate test-split predictions for AF3+Spatial checkpoints.

Mirror of `scripts/bench_test_generate.py` for the AF3 spatial model.

Usage:
    torchrun --nproc_per_node=8 scripts/bench_test_generate_af3.py \\
        --checkpoint-paths af3_spatial_qa_runs/.../checkpoints/best_trainable.pt \\
        --qa-root /apdcephfs.../easy_filtered --split test \\
        --output-dir af3_spatial_qa_runs/.../bench/test

After predictions.jsonl is emitted, score with the existing (model-agnostic)
scorer:
    python scripts/score_test_predictions.py \\
        --predictions-jsonl .../predictions.jsonl \\
        --azimuth-threshold-deg 20 --elevation-threshold-deg 10
"""
from __future__ import annotations

import argparse
import json
import os
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Dict, List, Optional

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

REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
if REPO_ROOT not in sys.path:
    sys.path.insert(0, REPO_ROOT)

# Inherit distributed/dataset/checkpoint utilities that are model-agnostic
# from the Spatial-Qwen training script.
from train_spatial_beats_qa import (  # type: ignore
    MAX_AUDIO_SAMPLES,
    QwenAudioFeatureCache,
    SAMPLE_RATE,
    build_left_padded_batch,
    build_qa_dataset,
    cleanup_distributed,
    distributed_barrier,
    get_rank,
    get_world_size,
    is_distributed,
    is_main_process,
    make_loader,
    normalize_answer,
    rank0_print,
    setup_distributed,
    shard_dataset_for_rank,
    unwrap_model,
)
# AF3 training utilities (build_processor/build_model with spatial config,
# freeze helpers, LoRA wiring, collator).
from train_spatial_af3_qa import (  # type: ignore
    DEFAULT_AF3_MODEL_ID,
    DEFAULT_AF3_TRANSFORMERS_FORK,
    DEFAULT_OUTPUT_DIR,
    DEFAULT_LORA_TARGET_MODULES,
    DEFAULT_AF3_LORA_PREFIXES,
    apply_llm_lora,
    build_model as build_af3_spatial_model,
    build_processor as build_af3_spatial_processor,
    configure_beats_lora_training,
    configure_encoder_lora_training,
    ensure_af3_on_path,
    freeze_all_but_projector,
)


def clean_generated_answer(text: str) -> str:
    import re
    value = str(text).replace("\r\n", "\n").strip()
    for marker in ("Human:", "Question:", "\nHuman:", "\nQuestion:"):
        if marker in value:
            value = value.split(marker, 1)[0].strip()
    value = next((line.strip() for line in value.splitlines() if line.strip()), "")
    if re.fullmatch(r"[-+]?\d+\.0+", value):
        value = value.split(".", 1)[0]
    return value.strip()


# --------------------------------------------------------------------------- #
# Eval collator (right-pad base prompt, left-pad for generate)
# --------------------------------------------------------------------------- #
@dataclass
class SpatialAF3EvalCollator:
    processor: Any
    sample_rate: int = SAMPLE_RATE
    max_audio_samples: int = MAX_AUDIO_SAMPLES

    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]:
        audio_arrs: List[np.ndarray] = []
        prompts: List[str] = []
        meta: List[Dict[str, Any]] = []
        sa_lens: List[int] = []

        for feat in features:
            wav, sr = sf.read(feat["audio_path"], dtype="float32", always_2d=True)
            if sr != self.sample_rate:
                raise ValueError(f"Expected {self.sample_rate}Hz got {sr} for {feat['audio_path']}")
            wav = wav.T
            if wav.shape[0] != 4:
                raise ValueError(f"Expected 4ch FOA, got {wav.shape}")
            if wav.shape[1] > self.max_audio_samples:
                wav = wav[:, : self.max_audio_samples]
            T = wav.shape[1]
            sa_lens.append(T)
            audio_arrs.append(wav.astype(np.float32, copy=False))
            prompts.append(
                self.processor.audio_token
                + self.processor.spatial_token
                + f"\n{str(feat['prompt']).rstrip()}\n"
            )
            pid = feat.get("pair_id")
            if pid is None or pid == "":
                import hashlib
                key = "|".join(
                    str(feat.get(k, ""))
                    for k in ("scene_id", "segment_stem", "task_name", "question", "audio_path")
                )
                pid = "auto_" + hashlib.sha1(key.encode("utf-8")).hexdigest()[:16]
            meta.append({
                "pair_id": pid,
                "task_name": feat.get("task_name"),
                "question": feat.get("question"),
                "prompt": feat.get("prompt"),
                "answer": feat.get("answer"),
                "audio_path": feat.get("audio_path"),
                "scene_id": feat.get("scene_id"),
                "segment_stem": feat.get("segment_stem"),
                "canonical_answer": feat.get("canonical_answer"),
            })

        batch = self.processor(
            text=prompts,
            audio=audio_arrs,
            padding=True,
            padding_side="right",
            return_tensors="pt",
        )

        prefix_lengths = batch["attention_mask"].sum(1).long()
        batch["prefix_lengths"] = prefix_lengths
        batch["meta"] = meta
        pad_token_id = int(self.processor.tokenizer.pad_token_id or 0)
        gi, gm = build_left_padded_batch(
            batch["input_ids"], batch["attention_mask"], prefix_lengths, pad_token_id
        )
        batch["gen_input_ids"] = gi
        batch["gen_attention_mask"] = gm
        for key, value in list(batch.items()):
            if key in {
                "input_ids", "attention_mask", "prefix_lengths", "meta",
                "gen_input_ids", "gen_attention_mask",
            }:
                continue
            if isinstance(value, torch.Tensor):
                batch[f"gen_{key}"] = value
        return batch


# --------------------------------------------------------------------------- #
# Checkpoint discovery
# --------------------------------------------------------------------------- #
def resolve_checkpoint_paths(args) -> List[str]:
    run_dir = os.path.abspath(args.run_dir)
    checkpoint_dir = os.path.join(run_dir, "checkpoints")
    paths: List[str] = []
    if args.checkpoint_tags:
        for tag in args.checkpoint_tags:
            paths.append(os.path.join(checkpoint_dir, f"{tag}_trainable.pt"))
    if args.checkpoint_paths:
        paths.extend(os.path.abspath(path) for path in args.checkpoint_paths)
    if args.checkpoint_glob:
        paths.extend(str(path) for path in sorted(Path(checkpoint_dir).glob(args.checkpoint_glob)))
    if not paths:
        raise ValueError("Provide at least one of --checkpoint-tags, --checkpoint-paths, or --checkpoint-glob.")
    deduped, seen = [], set()
    for path in paths:
        ap = os.path.abspath(path)
        if ap in seen:
            continue
        if not os.path.exists(ap):
            raise FileNotFoundError(f"Checkpoint not found: {ap}")
        seen.add(ap)
        deduped.append(ap)
    return deduped


def infer_train_args_path(checkpoint_path: str) -> str:
    run_dir = os.path.dirname(os.path.dirname(os.path.abspath(checkpoint_path)))
    path = os.path.join(run_dir, "train_args.json")
    if not os.path.exists(path):
        raise FileNotFoundError(f"train_args.json not found for checkpoint: {checkpoint_path}")
    return path


def load_json(path: str) -> Dict[str, Any]:
    with open(path, "r", encoding="utf-8") as handle:
        return json.load(handle)


def build_eval_model_args(runtime_args, train_args: Dict[str, Any]):
    merged = dict(train_args)
    merged.setdefault("model_id", DEFAULT_AF3_MODEL_ID)
    merged.setdefault("af3_transformers_fork", DEFAULT_AF3_TRANSFORMERS_FORK)
    merged.setdefault("beats_checkpoint", train_args.get("beats_checkpoint"))
    merged.setdefault("beats_repo", train_args.get("beats_repo"))
    merged.setdefault("train_mode", train_args.get("train_mode", "projector_only"))
    merged.setdefault("lora_r", int(train_args.get("lora_r", 16)))
    merged.setdefault("lora_alpha", int(train_args.get("lora_alpha", 32)))
    merged.setdefault("lora_dropout", float(train_args.get("lora_dropout", 0.05)))
    merged.setdefault("lora_target_modules", list(
        train_args.get("lora_target_modules", list(DEFAULT_LORA_TARGET_MODULES))
    ))
    merged.setdefault("lora_target_prefixes", list(
        train_args.get("lora_target_prefixes", list(DEFAULT_AF3_LORA_PREFIXES))
    ))
    merged.setdefault("projector_type", train_args.get("projector_type", "pixel_shuffle"))
    merged.setdefault("projector_shuffle_factor", int(train_args.get("projector_shuffle_factor", 4)))
    merged.setdefault("encoder_token_rate", float(train_args.get("encoder_token_rate", 10.0)))
    merged.setdefault("attn_impl", train_args.get("attn_impl", "auto"))
    merged["device"] = runtime_args.device
    merged["dtype"] = runtime_args.dtype
    merged["gradient_checkpointing"] = False
    merged["projector_fp32"] = bool(train_args.get("projector_fp32", False))
    return argparse.Namespace(**merged)


def instantiate_model_for_checkpoint(runtime_args, checkpoint_path: str):
    train_args = load_json(infer_train_args_path(checkpoint_path))
    model_args = build_eval_model_args(runtime_args, train_args)
    processor = build_af3_spatial_processor(model_args.model_id)
    processor.tokenizer.padding_side = "left"
    model = build_af3_spatial_model(model_args, processor)

    train_mode = str(model_args.train_mode)
    if train_mode == "projector_only":
        freeze_all_but_projector(model)
    elif train_mode == "encoder_lora":
        model, _ = apply_llm_lora(model, model_args)
        configure_encoder_lora_training(model, model_args)
    elif train_mode == "beats_lora":
        model, _ = apply_llm_lora(model, model_args)
        configure_beats_lora_training(model, model_args)

    checkpoint = torch.load(checkpoint_path, map_location="cpu")
    state_dict = checkpoint.get("trainable_state_dict", checkpoint)
    load_result = model.load_state_dict(state_dict, strict=False)
    model.eval()
    return model, processor, train_args, checkpoint, load_result


def filter_dataset(dataset, task_names: Optional[List[str]], question_classes: Optional[List[str]]):
    if not task_names and not question_classes:
        return dataset
    allowed_tasks = set(task_names or [])
    allowed_classes = set(question_classes or [])
    indices = []
    records = dataset.records if hasattr(dataset, "records") else None
    if records is None:
        return dataset
    for index, record in enumerate(records):
        if allowed_tasks and str(record.get("task_name")) not in allowed_tasks:
            continue
        if allowed_classes and str(record.get("question_class")) not in allowed_classes:
            continue
        indices.append(index)
    return torch.utils.data.Subset(dataset, indices)


def to_generation_inputs(batch: Dict[str, Any], device: str) -> Dict[str, torch.Tensor]:
    inputs = {}
    for key, value in batch.items():
        if not key.startswith("gen_") or not isinstance(value, torch.Tensor):
            continue
        inputs[key[4:]] = value.to(device)
    return inputs


def get_model_device(model) -> str:
    m = unwrap_model(model)
    try:
        p = next(m.parameters())
        return str(p.device)
    except StopIteration:
        return "cpu"


def finalize_distributed_prediction_file(output_jsonl_path: str) -> List[Dict[str, Any]]:
    if is_distributed():
        shard_paths = [f"{output_jsonl_path}.rank{rank}.jsonl" for rank in range(get_world_size())]
    else:
        shard_paths = [f"{output_jsonl_path}.rank0.jsonl"]
    merged: List[Dict[str, Any]] = []
    with open(output_jsonl_path, "w", encoding="utf-8") as handle_out:
        for shard_path in shard_paths:
            if not os.path.exists(shard_path):
                continue
            with open(shard_path, "r", encoding="utf-8") as handle_in:
                for line in handle_in:
                    line = line.strip()
                    if not line:
                        continue
                    record = json.loads(line)
                    merged.append(record)
                    handle_out.write(json.dumps(record, ensure_ascii=False) + "\n")
            os.remove(shard_path)
    return merged


def run_generation_bench(
    model,
    processor,
    loader,
    output_jsonl_path: str,
    max_new_tokens: int,
    num_beams: int,
    do_sample: bool,
    bench_name: str,
) -> Dict[str, Any]:
    model.eval()
    rank = get_rank()
    shard_output_path = f"{output_jsonl_path}.rank{rank}.jsonl"
    os.makedirs(os.path.dirname(output_jsonl_path), exist_ok=True)
    eval_model = unwrap_model(model)
    input_device = get_model_device(eval_model)

    with open(shard_output_path, "w", encoding="utf-8") as handle:
        with torch.no_grad():
            progress = tqdm(loader, desc=bench_name, leave=False, disable=not is_main_process())
            for step_i, batch in enumerate(progress):
                generation_inputs = to_generation_inputs(batch, input_device)
                generated = eval_model.generate(
                    **generation_inputs,
                    max_new_tokens=max_new_tokens,
                    num_beams=num_beams,
                    do_sample=do_sample,
                )
                ml = generation_inputs["input_ids"].shape[1]
                generated = generated.detach().cpu()
                for index in range(len(batch["meta"])):
                    prediction_ids = generated[index, ml:]
                    prediction_text = processor.tokenizer.decode(
                        prediction_ids, skip_special_tokens=True
                    ).strip()
                    cleaned_prediction = clean_generated_answer(prediction_text)
                    meta = batch["meta"][index]
                    answer_text = str(meta["answer"]).strip()
                    cleaned_answer = clean_generated_answer(answer_text)
                    raw_em = int(normalize_answer(prediction_text) == normalize_answer(answer_text))
                    cln_em = int(normalize_answer(cleaned_prediction) == normalize_answer(cleaned_answer))
                    record = {
                        "pair_id": meta.get("pair_id"),
                        "task_name": meta.get("task_name"),
                        "question": meta.get("question"),
                        "prompt": meta.get("prompt"),
                        "answer": answer_text,
                        "audio_path": meta.get("audio_path"),
                        "scene_id": meta.get("scene_id"),
                        "segment_stem": meta.get("segment_stem"),
                        "canonical_answer": meta.get("canonical_answer"),
                        "prediction": prediction_text,
                        "prediction_cleaned": cleaned_prediction,
                        "raw_exact_match": raw_em,
                        "cleaned_exact_match": cln_em,
                    }
                    handle.write(json.dumps(record, ensure_ascii=False) + "\n")
                handle.flush()
                del generated, generation_inputs
                if (step_i + 1) % 50 == 0 and torch.cuda.is_available():
                    torch.cuda.empty_cache()

    distributed_barrier()
    if not is_main_process():
        return {}
    merged = finalize_distributed_prediction_file(output_jsonl_path)
    total = max(len(merged), 1)
    raw_em = sum(float(r["raw_exact_match"]) for r in merged) / total
    cln_em = sum(float(r["cleaned_exact_match"]) for r in merged) / total
    return {
        "examples": len(merged),
        "raw_exact_match": raw_em,
        "cleaned_exact_match": cln_em,
    }


# --------------------------------------------------------------------------- #
# CLI
# --------------------------------------------------------------------------- #
def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    p.add_argument("--run-dir", type=str, default=DEFAULT_OUTPUT_DIR)
    p.add_argument("--checkpoint-tags", nargs="+", default=None)
    p.add_argument("--checkpoint-paths", nargs="+", default=None)
    p.add_argument("--checkpoint-glob", type=str, default=None)

    p.add_argument("--qa-root", type=str, required=True)
    p.add_argument("--split", type=str, default="test")
    p.add_argument("--max-samples", type=int, default=None)
    p.add_argument("--task-names", nargs="+", default=None)
    p.add_argument("--question-classes", nargs="+", default=None)

    p.add_argument("--output-dir", type=str, default=None)
    p.add_argument("--skip-existing", action="store_true")

    p.add_argument("--batch-size", type=int, default=1)
    p.add_argument("--num-workers", type=int, default=0)
    p.add_argument("--persistent-workers", action="store_true")
    p.add_argument("--prefetch-factor", type=int, default=2)
    p.add_argument("--device", type=str, default="cuda:0")
    p.add_argument("--dtype", type=str, default="bfloat16",
                    choices=("float32", "bfloat16", "float16"))
    p.add_argument("--max-new-tokens", type=int, default=96)
    p.add_argument("--num-beams", type=int, default=1)
    p.add_argument("--do-sample", action="store_true")

    p.add_argument("--local-rank", type=int, default=-1)
    return p.parse_args()


def main() -> int:
    args = parse_args()
    # Must insert AF3 fork onto sys.path before any transformers import
    # triggered by build_processor/build_model. Use the default fork path;
    # downstream code pulls the per-checkpoint train_args to override if needed.
    ensure_af3_on_path(DEFAULT_AF3_TRANSFORMERS_FORK)
    args = setup_distributed(args)

    checkpoint_paths = resolve_checkpoint_paths(args)
    dataset, _, _ = build_qa_dataset([args.qa_root], args.split, args.max_samples)
    dataset = filter_dataset(dataset, args.task_names, args.question_classes)
    dataset = shard_dataset_for_rank(dataset)
    if len(dataset) == 0:
        raise RuntimeError("Empty dataset after filtering.")

    output_dir = os.path.abspath(
        args.output_dir or os.path.join(args.run_dir, "bench", args.split)
    )
    os.makedirs(output_dir, exist_ok=True)
    rank0_print(f"[bench] output_dir={output_dir}")
    rank0_print(f"[bench] {len(checkpoint_paths)} checkpoint(s) to run")

    summary: List[Dict[str, Any]] = []
    for checkpoint_path in checkpoint_paths:
        ckpt_name = Path(checkpoint_path).stem.replace("_trainable", "")
        ckpt_out_dir = os.path.join(output_dir, ckpt_name)
        predictions_jsonl = os.path.join(ckpt_out_dir, "predictions.jsonl")

        if args.skip_existing and os.path.exists(predictions_jsonl):
            rank0_print(f"[bench] {ckpt_name}: skip (predictions.jsonl exists)")
            distributed_barrier()
            continue

        rank0_print(f"\n[bench] === {ckpt_name} ===")
        model, processor, train_args, checkpoint, load_result = \
            instantiate_model_for_checkpoint(args, checkpoint_path)
        rank0_print(
            f"[bench] {ckpt_name}: loaded "
            f"missing={len(load_result.missing_keys)} "
            f"unexpected={len(load_result.unexpected_keys)}"
        )

        loader = make_loader(
            dataset=dataset,
            collator=SpatialAF3EvalCollator(processor=processor),
            batch_size=args.batch_size,
            num_workers=args.num_workers,
            shuffle=False,
            sampler=None,
            persistent_workers=args.persistent_workers,
            prefetch_factor=args.prefetch_factor,
        )
        quick_metrics = run_generation_bench(
            model=model,
            processor=processor,
            loader=loader,
            output_jsonl_path=predictions_jsonl,
            max_new_tokens=args.max_new_tokens,
            num_beams=args.num_beams,
            do_sample=args.do_sample,
            bench_name=f"bench:{ckpt_name}",
        )
        distributed_barrier()
        del model
        if torch.cuda.is_available():
            torch.cuda.empty_cache()

        if is_main_process():
            payload = {
                "checkpoint": os.path.abspath(checkpoint_path),
                "checkpoint_epoch": checkpoint.get("epoch"),
                "predictions_jsonl": os.path.abspath(predictions_jsonl),
                "quick_metrics": quick_metrics,
                "train_mode": train_args.get("train_mode"),
                "task_filter": args.task_names,
                "question_class_filter": args.question_classes,
            }
            with open(os.path.join(ckpt_out_dir, "bench_summary.json"), "w", encoding="utf-8") as h:
                json.dump(payload, h, indent=2, sort_keys=True, ensure_ascii=False)
            summary.append(payload)
            rank0_print(
                f"[bench] {ckpt_name}: predictions={quick_metrics.get('examples', 0)} "
                f"raw_em={quick_metrics.get('raw_exact_match', 0.0):.4f} "
                f"cleaned_em={quick_metrics.get('cleaned_exact_match', 0.0):.4f}  "
                f"→ {predictions_jsonl}"
            )
        distributed_barrier()

    if is_main_process() and summary:
        with open(os.path.join(output_dir, "summary.json"), "w", encoding="utf-8") as h:
            json.dump(summary, h, indent=2, sort_keys=True, ensure_ascii=False)
        rank0_print(
            "[bench] Next step: run `scripts/score_test_predictions.py` "
            "on each predictions.jsonl to get task-aware metrics + LLM judge."
        )

    cleanup_distributed()
    return 0


if __name__ == "__main__":
    sys.exit(main())