import argparse import json import os import re from collections import defaultdict from dataclasses import dataclass from typing import Any, Dict, List, Optional, Tuple import numpy as np import soundfile as sf import torch from torch.utils.data.distributed import DistributedSampler from torch.utils.data import Subset from tqdm.auto import tqdm from train_spatial_qa import ( DEFAULT_MODEL_ID, DEFAULT_QA_ROOT, DEFAULT_QA_VERSION, DEFAULT_SPUR_REPO, MAX_AUDIO_SAMPLES, SAMPLE_RATE, QA_VERSION_TO_SUBDIR, QAAudioJsonlDataset, SpatialQACollator, add_spur_repo_to_path, apply_llm_lora, build_left_padded_text_batch, build_generation_inputs, cleanup_distributed, build_model, build_processor, configure_spatial_lora_training, configure_adapter_lora_training, distributed_barrier, freeze_all_but_spatial_modules, get_rank, is_main_process, make_loader, normalize_answer, rank0_print, resolve_qa_root, resolve_qa_split_path, setup_distributed, unwrap_model, ) DEFAULT_RUN_DIR = ( "/apdcephfs_cq10/share_1603164/user/schmittzhu/code/DCASE2024_seld_baseline/" "spatial_qa_runs/spatial_lora_4gpu_full" ) DCASE_CORE_CATEGORY_TASKS = { "azimuth": [ "estimate_azimuth", "classify_azimuth_bin_text", "classify_azimuth_bin_choice", "compare_azimuth", "same_azimuth", ], "elevation": [ "estimate_elevation", "classify_elevation_bin_text", "classify_elevation_bin_choice", "compare_elevation", ], "distance": [ "estimate_distance", "compare_distance", ], "motion": [ "classify_motion", "detect_motion", ], "detect": [ "detect_time", "count_sources", "identify_source_by_location", "identify_source_by_doa", "identify_source_by_doa_distance", ], } def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser( description="Benchmark base Qwen and adapted spatial checkpoints on the QA test split." ) parser.add_argument("--spur-repo-path", type=str, default=DEFAULT_SPUR_REPO) parser.add_argument("--run-dir", type=str, default=DEFAULT_RUN_DIR) parser.add_argument("--checkpoint-path", type=str, default=None) parser.add_argument("--checkpoint-tag", type=str, default="best") parser.add_argument("--model-id", type=str, default=None) parser.add_argument( "--qa-root", type=str, default=None, help="Explicit QA directory containing train/valid/test json or jsonl files. Overrides --qa-version.", ) parser.add_argument( "--qa-version", type=str, default=DEFAULT_QA_VERSION, choices=sorted(QA_VERSION_TO_SUBDIR.keys()), help="Named QA dataset version under the prepared_datasets root.", ) parser.add_argument("--split", type=str, default="test") parser.add_argument("--max-samples", type=int, default=None) parser.add_argument( "--category-groups", nargs="+", default=None, choices=sorted(DCASE_CORE_CATEGORY_TASKS.keys()), help="Run separate benchmarks on DCASE task groups aligned to the OV1 category split.", ) parser.add_argument( "--task-names", nargs="+", default=None, help="Optional explicit DCASE task_name filter. Overrides --category-groups if set.", ) parser.add_argument("--batch-size", type=int, default=1) parser.add_argument("--num-workers", type=int, default=0) parser.add_argument("--device", type=str, default="cuda:0") parser.add_argument( "--dtype", type=str, default="bfloat16", choices=("float32", "bfloat16", "float16"), ) parser.add_argument("--max-new-tokens", type=int, default=32) parser.add_argument("--num-beams", type=int, default=1) parser.add_argument("--do-sample", action="store_true") parser.add_argument("--local-rank", type=int, default=-1) parser.add_argument("--seld233-feature-cache-manifest", type=str, default=None) parser.add_argument("--seld233-hidden-cache-manifest", type=str, default=None) parser.add_argument("--skip-base-qwen", action="store_true") parser.add_argument("--skip-adapted", action="store_true") parser.add_argument( "--mode", type=str, default="both", choices=("both", "base", "adapted"), help="Run base Qwen, adapted checkpoint, or both in separate invocations.", ) parser.add_argument( "--question-classes", nargs="+", default=None, help="Filter by question_class in the QA records.", ) parser.add_argument("--output-dir", type=str, default=None) return parser.parse_args() def dtype_from_name(name: str) -> torch.dtype: return { "float32": torch.float32, "bfloat16": torch.bfloat16, "float16": torch.float16, }[name] def load_json(path: str) -> Dict[str, Any]: with open(path, "r", encoding="utf-8") as handle: return json.load(handle) def resolve_checkpoint_path(args: argparse.Namespace) -> str: if args.checkpoint_path is not None: return os.path.abspath(args.checkpoint_path) checkpoint_name = f"{args.checkpoint_tag}_trainable.pt" return os.path.abspath(os.path.join(args.run_dir, "checkpoints", checkpoint_name)) def build_eval_model_args(args: argparse.Namespace, train_args: Dict[str, Any]) -> argparse.Namespace: defaults = { "spur_repo_path": DEFAULT_SPUR_REPO, "model_id": DEFAULT_MODEL_ID, "baseline_repo_path": os.path.abspath(os.getcwd()), "seld233_task_id": "233", "seld233_checkpoint_path": train_args.get("seld233_checkpoint_path"), "seld233_feature_stats_dir": train_args.get("seld233_feature_stats_dir"), "gradient_checkpointing": False, "spatial_fp32": bool(train_args.get("spatial_fp32", False)), "spatial_backbone_fp32": bool(train_args.get("spatial_backbone_fp32", False)), "lora_r": int(train_args.get("lora_r", 16)), "lora_alpha": int(train_args.get("lora_alpha", 32)), "lora_dropout": float(train_args.get("lora_dropout", 0.05)), "lora_target_modules": list(train_args.get("lora_target_modules", [])), "lora_target_prefixes": list(train_args.get("lora_target_prefixes", ["thinker.model"])), "train_mode": train_args.get("train_mode", "spatial_lora"), "device": args.device, "dtype": args.dtype, } merged = dict(defaults) merged.update(train_args) # Runtime launch context must override the saved training args. merged["device"] = args.device merged["dtype"] = args.dtype merged["spur_repo_path"] = args.spur_repo_path if args.model_id is not None: merged["model_id"] = args.model_id if "lora_target_modules" not in merged or not merged["lora_target_modules"]: merged["lora_target_modules"] = [ "q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj", ] if "lora_target_prefixes" not in merged or not merged["lora_target_prefixes"]: merged["lora_target_prefixes"] = ["thinker.model"] return argparse.Namespace(**merged) def load_adapted_model( args: argparse.Namespace, checkpoint_path: str, train_args: Dict[str, Any], ): model_args = build_eval_model_args(args, train_args) processor = build_processor(model_args.model_id) processor.tokenizer.padding_side = "left" model = build_model(model_args, processor) if model_args.train_mode == "spatial_only": freeze_all_but_spatial_modules(model) elif model_args.train_mode == "adapter_lora": model, _ = apply_llm_lora(model, model_args) configure_adapter_lora_training(model, model_args) elif model_args.train_mode == "spatial_lora": model, _ = apply_llm_lora(model, model_args) configure_spatial_lora_training(model, model_args) else: pass 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, checkpoint, load_result def load_base_qwen_model(args: argparse.Namespace, model_id: str): add_spur_repo_to_path(args.spur_repo_path) from spatial_qwen.model.modeling_qwen2_5_omni import Qwen2_5OmniForConditionalGeneration from spatial_qwen.model.processing_qwen2_5_omni import Qwen2_5OmniProcessor processor = Qwen2_5OmniProcessor.from_pretrained(model_id) processor.tokenizer.padding_side = "left" model = Qwen2_5OmniForConditionalGeneration.from_pretrained( model_id, torch_dtype=dtype_from_name(args.dtype), low_cpu_mem_usage=True, ) if hasattr(model, "disable_talker"): model.disable_talker() model.to(args.device) model.eval() return model, processor def clean_generated_answer(text: str) -> str: 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() @dataclass class BaseAudioEvalCollator: 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_arrays: List[np.ndarray] = [] texts: List[str] = [] meta: List[Dict[str, Any]] = [] for feature in features: wav, sr = sf.read(feature["audio_path"], dtype="float32", always_2d=True) if sr != self.sample_rate: raise ValueError( f"Expected {self.sample_rate} Hz audio, got {sr} for {feature['audio_path']}" ) wav = wav.T if wav.ndim != 2 or wav.shape[0] < 1: raise ValueError(f"Expected audio shape [C, T], got {tuple(wav.shape)}") if wav.shape[1] > self.max_audio_samples: wav = wav[:, : self.max_audio_samples] mono_audio = wav[0].astype(np.float32, copy=False) prompt_text = f"{self.processor.audio_token}\n{feature['prompt'].rstrip()}\n" audio_arrays.append(mono_audio) texts.append(prompt_text) meta.append( { "pair_id": feature.get("pair_id"), "task_name": feature.get("task_name"), "question": feature.get("question"), "prompt": feature.get("prompt"), "answer": feature.get("answer"), "audio_path": feature.get("audio_path"), } ) batch = self.processor( text=texts, audio=audio_arrays, padding=True, return_tensors="pt", ) batch["meta"] = meta prefix_lengths = batch["attention_mask"].sum(dim=1).to(dtype=torch.long) batch["prefix_lengths"] = prefix_lengths pad_token_id = int(self.processor.tokenizer.pad_token_id or 0) generation_input_ids, generation_attention_mask = build_left_padded_text_batch( input_ids=batch["input_ids"], attention_mask=batch["attention_mask"], prefix_lengths=prefix_lengths, pad_token_id=pad_token_id, ) batch["gen_input_ids"] = generation_input_ids batch["gen_attention_mask"] = generation_attention_mask for key, value in list(batch.items()): if key in {"input_ids", "attention_mask", "prefix_lengths", "gen_input_ids", "gen_attention_mask"}: continue if isinstance(value, torch.Tensor): batch[f"gen_{key}"] = value return batch def compute_metrics_from_records(records: List[Dict[str, Any]]) -> Dict[str, Any]: per_task: Dict[str, Dict[str, float]] = defaultdict( lambda: {"count": 0.0, "raw_exact_match": 0.0, "cleaned_exact_match": 0.0} ) total_raw = 0.0 total_cleaned = 0.0 for record in records: task_name = str(record.get("task_name") or "unknown") raw_em = float(record["raw_exact_match"]) cleaned_em = float(record["cleaned_exact_match"]) total_raw += raw_em total_cleaned += cleaned_em per_task[task_name]["count"] += 1.0 per_task[task_name]["raw_exact_match"] += raw_em per_task[task_name]["cleaned_exact_match"] += cleaned_em total_count = float(len(records)) summary = { "examples": int(total_count), "raw_exact_match": total_raw / max(total_count, 1.0), "cleaned_exact_match": total_cleaned / max(total_count, 1.0), "per_task": {}, } for task_name, stats in sorted(per_task.items()): count = max(float(stats["count"]), 1.0) summary["per_task"][task_name] = { "count": int(stats["count"]), "raw_exact_match": float(stats["raw_exact_match"]) / count, "cleaned_exact_match": float(stats["cleaned_exact_match"]) / count, } return summary def filter_dataset_by_task_names(dataset, task_names: List[str]): allowed = set(task_names) indices = [ index for index, record in enumerate(dataset.records) if str(record.get("task_name")) in allowed ] return Subset(dataset, indices) def filter_dataset_by_field(dataset, field_name: str, allowed_values: List[str]): allowed = set(allowed_values) indices = [ index for index, record in enumerate(dataset.records) if str(record.get(field_name)) in allowed ] return Subset(dataset, indices) def finalize_distributed_prediction_file(output_jsonl_path: str) -> List[Dict[str, Any]]: shard_paths = [ f"{output_jsonl_path}.rank{rank}.jsonl" for rank in range(int(os.environ.get("WORLD_SIZE", "1"))) ] if dist_is_enabled() else [f"{output_jsonl_path}.rank0.jsonl"] merged_records: List[Dict[str, Any]] = [] with open(output_jsonl_path, "w", encoding="utf-8") as merged_handle: for shard_path in shard_paths: if not os.path.exists(shard_path): continue with open(shard_path, "r", encoding="utf-8") as shard_handle: for line in shard_handle: line = line.strip() if not line: continue record = json.loads(line) merged_records.append(record) merged_handle.write(json.dumps(record, ensure_ascii=False) + "\n") os.remove(shard_path) return merged_records def dist_is_enabled() -> bool: return int(os.environ.get("WORLD_SIZE", "1")) > 1 def run_generation_bench( model, processor, loader, device: str, output_jsonl_path: str, max_new_tokens: int, num_beams: int, do_sample: bool, bench_name: str, ) -> Dict[str, Any]: model.eval() records: List[Dict[str, Any]] = [] os.makedirs(os.path.dirname(output_jsonl_path), exist_ok=True) rank = get_rank() shard_output_path = f"{output_jsonl_path}.rank{rank}.jsonl" 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 batch in progress: generation_inputs = build_generation_inputs(batch, device) generation_inputs.pop("prefix_lengths", None) generated = unwrap_model(model).generate( **generation_inputs, return_audio=False, max_new_tokens=max_new_tokens, num_beams=num_beams, do_sample=do_sample, ) prompt_lengths = generation_inputs["attention_mask"].sum(dim=1).tolist() generated = generated.detach().cpu() for index, prompt_length in enumerate(prompt_lengths): prediction_ids = generated[index, int(prompt_length):] 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_exact_match = int( normalize_answer(prediction_text) == normalize_answer(answer_text) ) cleaned_exact_match = 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, "prediction": prediction_text, "prediction_cleaned": cleaned_prediction, "raw_exact_match": raw_exact_match, "cleaned_exact_match": cleaned_exact_match, } records.append(record) handle.write(json.dumps(record, ensure_ascii=False) + "\n") if is_main_process(): metrics = compute_metrics_from_records(records) progress.set_postfix( raw_em=f"{metrics['raw_exact_match']:.4f}", clean_em=f"{metrics['cleaned_exact_match']:.4f}", n=int(metrics["examples"]), ) distributed_barrier() if not is_main_process(): return {} merged_records = finalize_distributed_prediction_file(output_jsonl_path) return compute_metrics_from_records(merged_records) def print_summary(name: str, metrics: Dict[str, Any]) -> None: print( f"[{name}] examples={metrics['examples']} " f"raw_em={metrics['raw_exact_match']:.4f} " f"clean_em={metrics['cleaned_exact_match']:.4f}" ) for task_name, stats in metrics["per_task"].items(): print( f" - {task_name}: count={stats['count']} " f"raw_em={stats['raw_exact_match']:.4f} " f"clean_em={stats['cleaned_exact_match']:.4f}" ) def run_benchmark_for_dataset( dataset, dataset_name: str, args: argparse.Namespace, output_dir: str, model_id: str, train_args: Dict[str, Any], checkpoint_path: str, combined_summary: Dict[str, Any], ) -> None: if len(dataset) == 0: raise RuntimeError(f"Filtered dataset for {dataset_name} is empty.") dataset_output_dir = os.path.join(output_dir, dataset_name) os.makedirs(dataset_output_dir, exist_ok=True) dataset_summary: Dict[str, Any] = { "examples": len(dataset), } if not args.skip_base_qwen: base_model, base_processor = load_base_qwen_model(args, model_id) base_sampler = DistributedSampler(dataset, shuffle=False) if args.distributed else None base_loader = make_loader( dataset=dataset, collator=BaseAudioEvalCollator(processor=base_processor), batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False, sampler=base_sampler, ) base_predictions_path = os.path.join(dataset_output_dir, "base_qwen_audio_only_predictions.jsonl") base_metrics = run_generation_bench( model=base_model, processor=base_processor, loader=base_loader, device=args.device, output_jsonl_path=base_predictions_path, max_new_tokens=args.max_new_tokens, num_beams=args.num_beams, do_sample=args.do_sample, bench_name=f"{dataset_name}:base_qwen", ) if is_main_process(): dataset_summary["base_qwen_audio_only"] = base_metrics print_summary(f"{dataset_name}/base_qwen_audio_only", base_metrics) del base_model if torch.cuda.is_available(): torch.cuda.empty_cache() distributed_barrier() if not args.skip_adapted: adapted_model, adapted_processor, checkpoint_payload, load_result = load_adapted_model( args=args, checkpoint_path=checkpoint_path, train_args=train_args, ) spatial_collator = SpatialQACollator( processor=adapted_processor, include_generation_inputs=True, ) adapted_sampler = DistributedSampler(dataset, shuffle=False) if args.distributed else None adapted_loader = make_loader( dataset=dataset, collator=spatial_collator, batch_size=args.batch_size, num_workers=args.num_workers, shuffle=False, sampler=adapted_sampler, ) adapted_predictions_path = os.path.join(dataset_output_dir, "adapted_spatial_predictions.jsonl") adapted_metrics = run_generation_bench( model=adapted_model, processor=adapted_processor, loader=adapted_loader, device=args.device, output_jsonl_path=adapted_predictions_path, max_new_tokens=args.max_new_tokens, num_beams=args.num_beams, do_sample=args.do_sample, bench_name=f"{dataset_name}:adapted_spatial", ) if is_main_process(): dataset_summary["adapted_spatial_checkpoint"] = { **adapted_metrics, "checkpoint_epoch": checkpoint_payload.get("epoch"), "checkpoint_step": checkpoint_payload.get("step"), "missing_keys": len(load_result.missing_keys), "unexpected_keys": len(load_result.unexpected_keys), } print_summary(f"{dataset_name}/adapted_spatial_checkpoint", adapted_metrics) del adapted_model if torch.cuda.is_available(): torch.cuda.empty_cache() distributed_barrier() if is_main_process(): summary_path = os.path.join(dataset_output_dir, "summary.json") with open(summary_path, "w", encoding="utf-8") as handle: json.dump(dataset_summary, handle, indent=2, sort_keys=True, ensure_ascii=False) combined_summary[dataset_name] = dataset_summary def main() -> None: args = parse_args() args = setup_distributed(args) if args.mode == "base": args.skip_adapted = True elif args.mode == "adapted": args.skip_base_qwen = True try: add_spur_repo_to_path(args.spur_repo_path) train_args_path = os.path.join(args.run_dir, "train_args.json") if os.path.exists(train_args_path): train_args = load_json(train_args_path) elif args.skip_adapted: train_args = {} rank0_print( f"train_args.json not found under {args.run_dir}; continuing in base-only mode " "with CLI/default arguments." ) else: raise FileNotFoundError(f"Missing train_args.json: {train_args_path}") model_id = args.model_id or train_args.get("model_id") or DEFAULT_MODEL_ID # 优先级：--qa-root > --qa-version（非默认值）> train_args 中保存的 qa_root > 默认值 if args.qa_root: # 用户显式传了 --qa-root，直接使用 qa_root = resolve_qa_root(args.qa_root, args.qa_version) elif args.qa_version != DEFAULT_QA_VERSION: # 用户显式传了 --qa-version（非默认值），按版本解析，忽略 train_args 中的 qa_root qa_root = resolve_qa_root(None, args.qa_version) elif train_args.get("qa_root"): # 使用训练时保存的 qa_root qa_root = resolve_qa_root(train_args["qa_root"], args.qa_version) else: qa_root = DEFAULT_QA_ROOT split_path = resolve_qa_split_path(qa_root, args.split) if args.output_dir is None: if args.mode == "both": output_dir = os.path.join(args.run_dir, "bench_results", args.split) else: output_dir = os.path.join(args.run_dir, "bench_results", args.split, f"{args.mode}_only") else: output_dir = os.path.abspath(args.output_dir) if is_main_process(): os.makedirs(output_dir, exist_ok=True) checkpoint_path = None if not args.skip_adapted: checkpoint_path = resolve_checkpoint_path(args) if not os.path.exists(checkpoint_path): raise FileNotFoundError(f"Missing adapted checkpoint: {checkpoint_path}") dataset = QAAudioJsonlDataset( split_path, max_samples=args.max_samples, feature_cache_manifest_path=args.seld233_feature_cache_manifest, hidden_cache_manifest_path=args.seld233_hidden_cache_manifest, ) if len(dataset) == 0: raise RuntimeError(f"Empty evaluation split: {split_path}") rank0_print( f"Loaded benchmark dataset {split_path}: examples={len(dataset)} " f"mode={args.mode} world_size={args.world_size} batch_size={args.batch_size}" ) combined_summary: Dict[str, Any] = { "split": args.split, "examples": len(dataset), "qa_root": qa_root, "split_path": split_path, "model_id": model_id, "checkpoint_path": checkpoint_path, "mode": args.mode, "world_size": args.world_size, "batch_size_per_rank": args.batch_size, } if args.question_classes is not None: filtered_dataset = filter_dataset_by_field(dataset, "question_class", args.question_classes) run_benchmark_for_dataset( dataset=filtered_dataset, dataset_name="question_class_filter", args=args, output_dir=output_dir, model_id=model_id, train_args=train_args, checkpoint_path=checkpoint_path, combined_summary=combined_summary, ) elif args.task_names is not None: filtered_dataset = filter_dataset_by_task_names(dataset, args.task_names) run_benchmark_for_dataset( dataset=filtered_dataset, dataset_name="task_filter", args=args, output_dir=output_dir, model_id=model_id, train_args=train_args, checkpoint_path=checkpoint_path, combined_summary=combined_summary, ) elif args.category_groups is not None: has_question_class = any(record.get("question_class") for record in dataset.records) for category_name in args.category_groups: if has_question_class: filtered_dataset = filter_dataset_by_field(dataset, "question_class", [category_name]) else: filtered_dataset = filter_dataset_by_task_names( dataset, DCASE_CORE_CATEGORY_TASKS[category_name], ) run_benchmark_for_dataset( dataset=filtered_dataset, dataset_name=category_name, args=args, output_dir=output_dir, model_id=model_id, train_args=train_args, checkpoint_path=checkpoint_path, combined_summary=combined_summary, ) else: run_benchmark_for_dataset( dataset=dataset, dataset_name="full_split", args=args, output_dir=output_dir, model_id=model_id, train_args=train_args, checkpoint_path=checkpoint_path, combined_summary=combined_summary, ) if is_main_process(): summary_path = os.path.join(output_dir, "summary.json") with open(summary_path, "w", encoding="utf-8") as handle: json.dump(combined_summary, handle, indent=2, sort_keys=True, ensure_ascii=False) print(f"Saved benchmark summary to {summary_path}") finally: cleanup_distributed() if __name__ == "__main__": main()