import argparse import json import os import re import subprocess import sys from dataclasses import dataclass from pathlib import Path from typing import Any, Dict, List, Optional import numpy as np 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) from train_spatial_beats_qa import ( DEFAULT_MODEL_ID, DEFAULT_OUTPUT_DIR, DEFAULT_QA_ROOT, DEFAULT_SPATIAL_QWEN_REPO, MAX_AUDIO_SAMPLES, QwenAudioFeatureCache, SAMPLE_RATE, SpatialBeatsQACollator, apply_llm_lora, build_left_padded_batch, build_model, build_processor, build_qa_dataset, cleanup_distributed, configure_beats_lora_training, configure_encoder_lora_training, distributed_barrier, dtype_from_name, freeze_all_but_projector, get_rank, get_world_size, is_distributed, is_main_process, make_loader, normalize_answer, rank0_print, resolve_qa_split_path, setup_distributed, shard_dataset_for_rank, unwrap_model, ) DEFAULT_SCORE_SCRIPT = ( "/apdcephfs_cq10/share_1603164/user/schmittzhu/code/" "DCASE2024_seld_baseline/score_bench_predictions.py" ) def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser( description="Batch benchmark Spatial-BEATs Spatial-Qwen checkpoints on a QA split." ) parser.add_argument("--run-dir", type=str, default=DEFAULT_OUTPUT_DIR) parser.add_argument("--checkpoint-tags", nargs="+", default=None, help="Checkpoint tags without the _trainable.pt suffix, e.g. best epoch_001 step_0007000") parser.add_argument("--checkpoint-paths", nargs="+", default=None, help="Explicit checkpoint .pt paths.") parser.add_argument("--checkpoint-glob", type=str, default=None, help="Glob under /checkpoints, e.g. 'step_000[7-9]000_trainable.pt'") parser.add_argument("--qa-root", type=str, default=DEFAULT_QA_ROOT) parser.add_argument("--split", type=str, default="test") parser.add_argument("--max-samples", type=int, default=None) parser.add_argument("--task-names", nargs="+", default=None) parser.add_argument("--question-classes", nargs="+", default=None) parser.add_argument("--audio-feature-cache-manifest", type=str, default=None) parser.add_argument("--audio-feature-cache-max-entries", type=int, default=256) parser.add_argument("--output-dir", type=str, default=None) parser.add_argument("--batch-size", type=int, default=1) parser.add_argument("--num-workers", type=int, default=0) parser.add_argument("--persistent-workers", action="store_true") parser.add_argument("--prefetch-factor", type=int, default=2) parser.add_argument("--device", type=str, default="cuda:0") parser.add_argument("--device-map", type=str, default=None, help="HF device_map (e.g. 'auto') to shard model across GPUs. " "When set, --device is still used for inference tensors.") parser.add_argument("--dtype", type=str, default="bfloat16", choices=("float32", "bfloat16", "float16")) parser.add_argument("--max-new-tokens", type=int, default=48) parser.add_argument("--num-beams", type=int, default=1) parser.add_argument("--do-sample", action="store_true") parser.add_argument("--score-script-path", type=str, default=DEFAULT_SCORE_SCRIPT) parser.add_argument("--skip-existing", action="store_true") parser.add_argument("--local-rank", type=int, default=-1) return parser.parse_args() def load_json(path: str) -> Dict[str, Any]: with open(path, "r", encoding="utf-8") as handle: return json.load(handle) 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() def resolve_checkpoint_paths(args: argparse.Namespace) -> 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: List[str] = [] 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 build_eval_model_args(runtime_args: argparse.Namespace, train_args: Dict[str, Any]) -> argparse.Namespace: merged = dict(train_args) merged.setdefault("model_id", DEFAULT_MODEL_ID) merged.setdefault("beats_checkpoint", train_args.get("beats_checkpoint")) merged.setdefault("beats_repo", train_args.get("beats_repo")) merged.setdefault("spatial_qwen_repo", train_args.get("spatial_qwen_repo", DEFAULT_SPATIAL_QWEN_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", []))) merged.setdefault("lora_target_prefixes", list(train_args.get("lora_target_prefixes", ["thinker.model"]))) merged.setdefault("projector_type", train_args.get("projector_type", "mlp")) merged.setdefault("projector_shuffle_factor", int(train_args.get("projector_shuffle_factor", 1))) merged["device"] = runtime_args.device merged["device_map"] = getattr(runtime_args, "device_map", None) 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: argparse.Namespace, 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_processor(model_args.model_id, model_args.spatial_qwen_repo) processor.tokenizer.padding_side = "left" model = build_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 @dataclass class SpatialBeatsEvalCollator: processor: Any audio_feature_cache: Optional[QwenAudioFeatureCache] = None 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]] = [] cached_input_features: List[torch.Tensor] = [] cached_feature_lengths: List[int] = [] sa_lens: List[int] = [] for feat in features: cache_item = None if self.audio_feature_cache is not None: try: cache_item = self.audio_feature_cache.load(feat["audio_path"]) except KeyError: cache_item = None if cache_item is not None and "spatial_audio" in cache_item and "spatial_audio_length" in cache_item: wav = cache_item["spatial_audio"].to(dtype=torch.float32).cpu().numpy() if wav.ndim != 2 or wav.shape[0] != 4: raise ValueError(f"Cached spatial_audio must have shape [4, T], got {tuple(wav.shape)}") T = int(cache_item["spatial_audio_length"].item()) wav = wav[:, :T] else: import soundfile as sf 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"), } ) if cache_item is not None: cached_input_features.append(cache_item["input_features"]) cached_feature_lengths.append(int(cache_item["feature_length"].item())) lens_t = torch.tensor(sa_lens, dtype=torch.long) t_max = int(lens_t.max()) batch_size = len(audio_arrs) sa_t = torch.zeros(batch_size, t_max, 4, dtype=torch.float32) for index, wav in enumerate(audio_arrs): sa_t[index, : wav.shape[1]] = torch.from_numpy(wav.T) processor_kwargs: Dict[str, Any] = {} if self.audio_feature_cache is not None and cached_input_features: feature_dim = int(cached_input_features[0].shape[0]) max_feature_length = max(cached_feature_lengths) input_features = torch.zeros( batch_size, feature_dim, max_feature_length, dtype=cached_input_features[0].dtype ) feature_attention_mask = torch.zeros(batch_size, max_feature_length, dtype=torch.long) for index, (feature_tensor, feature_length) in enumerate(zip(cached_input_features, cached_feature_lengths)): input_features[index, :, :feature_length] = feature_tensor[:, :feature_length] feature_attention_mask[index, :feature_length] = 1 processor_kwargs["input_features"] = input_features processor_kwargs["feature_attention_mask"] = feature_attention_mask # 强制右填充：build_left_padded_batch 需要 input_ids[i, :pl_i] 是真实前缀， # 若 tokenizer 左填充则 input_ids[i, :pl_i] 包含 padding token 而非完整前缀， # 导致 <|spatial|> token 丢失并引发 RoPE modal_order 验证错误。 # 注意：Qwen2_5OmniProcessorKwargs._defaults 里 text_kwargs.padding_side="left" 是 # 硬编码在处理器内部的，仅修改 tokenizer.padding_side 不会覆盖它； # 必须通过在 __call__ 中传入 padding_side='right' kwarg 才能覆盖。 batch = self.processor( text=prompts, audio=audio_arrs, padding=True, padding_side="right", return_tensors="pt", **processor_kwargs, ) batch["spatial_audio"] = sa_t batch["spatial_audio_attention_mask"] = ( torch.arange(t_max).unsqueeze(0) < lens_t.unsqueeze(1) ) batch["spatial_audio_lengths"] = lens_t batch["meta"] = meta prefix_lengths = batch["attention_mask"].sum(1).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_batch( batch["input_ids"], batch["attention_mask"], prefix_lengths, 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", "meta", "gen_input_ids", "gen_attention_mask"}: continue if isinstance(value, torch.Tensor): batch[f"gen_{key}"] = value return batch 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: """获取模型（或其第一层）所在的 device，兼容 device_map='auto' 多卡分布场景。""" 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_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 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() local_records: List[Dict[str, Any]] = [] 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) # device_map='auto' 时模型分布在多卡，取第一个参数的实际 device 作为输入 tensor 的目标 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 batch in progress: generation_inputs = to_generation_inputs(batch, input_device) generated = eval_model.generate( **generation_inputs, return_audio=False, max_new_tokens=max_new_tokens, num_beams=num_beams, do_sample=do_sample, ) # ml = 左填充 batch 的统一序列长度；generate() 输出 [B, ml+k]， # 新 token 从 ml 开始，对所有样本统一，不能用各自的 prompt_length。 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_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, } local_records.append(record) handle.write(json.dumps(record, ensure_ascii=False) + "\n") distributed_barrier() if not is_main_process(): return {} merged_records = finalize_distributed_prediction_file(output_jsonl_path) total = max(len(merged_records), 1) raw_em = sum(float(record["raw_exact_match"]) for record in merged_records) / total clean_em = sum(float(record["cleaned_exact_match"]) for record in merged_records) / total return { "examples": len(merged_records), "raw_exact_match": raw_em, "cleaned_exact_match": clean_em, } def score_predictions(args: argparse.Namespace, predictions_jsonl: str) -> Dict[str, Any]: output_json = os.path.join(os.path.dirname(predictions_jsonl), "result.json") cmd = [ sys.executable, os.path.abspath(args.score_script_path), "--predictions-jsonl", os.path.abspath(predictions_jsonl), "--qa-root", os.path.abspath(args.qa_root), "--split", args.split, "--output-json", os.path.abspath(output_json), ] subprocess.run(cmd, check=True) return load_json(output_json) def summarize_results(results: List[Dict[str, Any]]) -> Dict[str, Any]: ordered = sorted(results, key=lambda item: item["score_summary"]["task_aware_accuracy"], reverse=True) return { "checkpoints": ordered, "best_checkpoint": ordered[0]["checkpoint"] if ordered else None, } def main() -> None: args = parse_args() args = setup_distributed(args) checkpoint_paths = resolve_checkpoint_paths(args) audio_feature_cache = None if args.audio_feature_cache_manifest: audio_feature_cache = QwenAudioFeatureCache( manifest_path=args.audio_feature_cache_manifest, max_entries=args.audio_feature_cache_max_entries, ) rank0_print( f"Using audio feature cache: {audio_feature_cache.manifest_path} " f"(entries={len(audio_feature_cache):,}, in_memory_max={audio_feature_cache.max_entries})" ) 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("Benchmark dataset is empty 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) all_results: List[Dict[str, Any]] = [] for checkpoint_path in checkpoint_paths: checkpoint_name = Path(checkpoint_path).stem.replace("_trainable", "") checkpoint_output_dir = os.path.join(output_dir, checkpoint_name) predictions_jsonl = os.path.join(checkpoint_output_dir, "predictions.jsonl") result_json = os.path.join(checkpoint_output_dir, "result.json") if args.skip_existing and os.path.exists(predictions_jsonl) and os.path.exists(result_json): rank0_print(f"Skipping existing benchmark for {checkpoint_name}") distributed_barrier() score_summary = load_json(result_json) if is_main_process() else {} if is_main_process(): all_results.append({ "checkpoint": os.path.abspath(checkpoint_path), "predictions_jsonl": os.path.abspath(predictions_jsonl), "score_summary": score_summary, }) continue model, processor, train_args, checkpoint, load_result = instantiate_model_for_checkpoint(args, checkpoint_path) rank0_print( f"[{checkpoint_name}] loaded missing={len(load_result.missing_keys)} " f"unexpected={len(load_result.unexpected_keys)}" ) loader = make_loader( dataset=dataset, collator=SpatialBeatsEvalCollator( processor=processor, audio_feature_cache=audio_feature_cache, ), 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, device=args.device, 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:{checkpoint_name}", ) distributed_barrier() del model if torch.cuda.is_available(): torch.cuda.empty_cache() if is_main_process(): score_summary = score_predictions(args, predictions_jsonl) payload = { "checkpoint": os.path.abspath(checkpoint_path), "checkpoint_epoch": checkpoint.get("epoch"), "predictions_jsonl": os.path.abspath(predictions_jsonl), "quick_metrics": quick_metrics, "score_summary": score_summary, "train_args_path": infer_train_args_path(checkpoint_path), "train_mode": train_args.get("train_mode"), } with open(os.path.join(checkpoint_output_dir, "bench_summary.json"), "w", encoding="utf-8") as handle: json.dump(payload, handle, indent=2, sort_keys=True, ensure_ascii=False) all_results.append(payload) rank0_print( f"[{checkpoint_name}] task_aware_accuracy={score_summary['task_aware_accuracy']:.4f} " f"examples={score_summary['examples']}" ) distributed_barrier() if is_main_process(): summary = summarize_results(all_results) summary_path = os.path.join(output_dir, "summary.json") with open(summary_path, "w", encoding="utf-8") as handle: json.dump(summary, handle, indent=2, sort_keys=True, ensure_ascii=False) rank0_print(f"Saved batch benchmark summary to {summary_path}") cleanup_distributed() if __name__ == "__main__": main()