"""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())