#!/usr/bin/env python3 """ 定位 POS noise 不导致性能下降的原因（用代码证据）。 做两件事： 1) 统计不同 pos_noise_ratio 下 noun_mask/verb_mask 的有效覆盖率（相对 LLaMA token mask）。 2) 对同一批样本，在相同 ckpt 下比较关键输出是否变化（binding_score / delta_s / saliency_scores / out_class）。 """ import argparse import json import os from pathlib import Path import numpy as np import torch def load_jsonl(path: Path, limit=None): items = [] with path.open("r", encoding="utf-8") as f: for i, line in enumerate(f): if limit is not None and i >= limit: break line = line.strip() if not line: continue items.append(json.loads(line)) return items def main(): ap = argparse.ArgumentParser() ap.add_argument("--ckpt", required=True) ap.add_argument("--config", default="data/MR_16.py") ap.add_argument("--device", type=int, default=0) ap.add_argument("--eval_path", default="data/highlight_val_release.jsonl") ap.add_argument("--v_feat_dirs", default="/home/szha0669/myproject/FlashVTG/features/qvhighlight_6b") ap.add_argument("--t_feat_dir", default="/home/szha0669/myproject/FlashVTG/features/qvhighlight_llama_text_feature") ap.add_argument("--a_feat_dir", default="/home/szha0669/myproject/FlashVTG/features/qvhighlight/slowfast_features") ap.add_argument("--n", type=int, default=64, help="number of samples to probe") ap.add_argument("--ratios", default="0.0,0.2,0.5,1.0") args = ap.parse_args() # project root root = Path(__file__).resolve().parent.parent os.environ["PYTHONPATH"] = f"{root}:{root/'FlashVTG'}:" + os.environ.get("PYTHONPATH", "") from FlashVTG.config import TestOptions from FlashVTG.model import build_model1 from FlashVTG.start_end_dataset import StartEndDataset, start_end_collate, prepare_batch_inputs dev = torch.device(f"cuda:{args.device}" if torch.cuda.is_available() else "cpu") # load model (weights only) ckpt = torch.load(args.ckpt, map_location="cpu", weights_only=False) opt = ckpt["opt"] opt.device = dev opt.resume = args.ckpt model, _ = build_model1(opt) model.load_state_dict(ckpt["model"], strict=False) model.to(dev).eval() print("=== FDIM/ISA key args (from ckpt opt) ===") for k in ["use_fdim", "fdim_inject_h", "fdim_proposal_alpha", "fdim_topk_ratio", "fdim_threshold", "fdim_gating_mode"]: print(f"{k} = {getattr(opt, k, None)}") ratios = [float(x) for x in args.ratios.split(",")] # make datasets per ratio (only for mask generation difference) datasets = {} for r in ratios: datasets[r] = StartEndDataset( dset_name=opt.dset_name, data_path=args.eval_path, v_feat_dirs=[args.v_feat_dirs], q_feat_dir=args.t_feat_dir, q_feat_type=opt.q_feat_type, max_q_l=opt.max_q_l, max_v_l=opt.max_v_l, ctx_mode=opt.ctx_mode, data_ratio=1.0, normalize_v=True, normalize_t=True, clip_len=opt.clip_length, max_windows=opt.max_windows, load_labels=True, span_loss_type=opt.span_loss_type, txt_drop_ratio=0, dset_domain=getattr(opt, "dset_domain", None), a_feat_dir=args.a_feat_dir, pos_noise_ratio=r, ) # pick sample indices idxs = list(range(min(args.n, len(datasets[ratios[0]])))) def stats_for_ratio(r: float): ds = datasets[r] noun_cover = [] verb_cover = [] noun_any = 0 verb_any = 0 # output diffs (vs ratio 0.0) return dict(noun_cover=noun_cover, verb_cover=verb_cover, noun_any=noun_any, verb_any=verb_any) # gather model outputs for each ratio outs = {} mask_stats = {} for r in ratios: ds = datasets[r] bs = [] noun_cover = [] verb_cover = [] noun_any = 0 verb_any = 0 for idx in idxs: sample = ds[idx] batch = start_end_collate([sample]) meta = batch[0][0] model_inputs, _ = prepare_batch_inputs(batch[1], dev, non_blocking=False, batch_meta=batch[0]) src_txt_mask = model_inputs["src_txt_mask"][0].bool().detach().cpu().numpy() L_txt = int(src_txt_mask.shape[0]) n_txt = int(src_txt_mask.sum()) noun_m = model_inputs.get("noun_mask", None) verb_m = model_inputs.get("verb_mask", None) if noun_m is None or verb_m is None: noun_cover.append(0.0) verb_cover.append(0.0) else: noun_vec = noun_m[0].bool().detach().cpu().numpy()[:L_txt] verb_vec = verb_m[0].bool().detach().cpu().numpy()[:L_txt] noun_any += int(noun_vec.any()) verb_any += int(verb_vec.any()) noun_cover.append(float((noun_vec & src_txt_mask).sum()) / max(n_txt, 1)) verb_cover.append(float((verb_vec & src_txt_mask).sum()) / max(n_txt, 1)) with torch.no_grad(): out = model(**model_inputs, targets={"label": batch[0]}) # store a few signals as numpy def _get(name): v = out.get(name, None) if v is None: return None if isinstance(v, torch.Tensor): return v[0].detach().float().cpu().numpy() return v bs.append( dict( qid=meta.get("qid"), sal=_get("saliency_scores"), cls=_get("out_class"), bind=_get("binding_score"), delta=_get("delta_s"), gate=_get("binding_gate"), prop_gate=_get("proposal_gate_mask"), prop_bind=_get("proposal_binding"), ) ) outs[r] = bs mask_stats[r] = dict( noun_any=noun_any, verb_any=verb_any, noun_cover=float(np.mean(noun_cover)), verb_cover=float(np.mean(verb_cover)), ) # compare outputs vs 0.0 base_r = ratios[0] diffs = {} for r in ratios[1:]: sal_l1 = [] cls_l1 = [] bind_l1 = [] delta_l1 = [] for b0, b1 in zip(outs[base_r], outs[r]): def l1(a, b): if a is None or b is None: return None n = min(len(a), len(b)) return float(np.mean(np.abs(a[:n] - b[:n]))) sal_l1.append(l1(b0["sal"], b1["sal"]) or 0.0) if b0["cls"] is not None and b1["cls"] is not None: # cls: [N,1] or [N] -> flatten c0 = b0["cls"].reshape(-1) c1 = b1["cls"].reshape(-1) cls_l1.append(l1(c0, c1) or 0.0) else: cls_l1.append(0.0) bind_l1.append(l1(b0["bind"], b1["bind"]) or 0.0) delta_l1.append(l1(b0["delta"], b1["delta"]) or 0.0) diffs[r] = dict( sal_l1=float(np.mean(sal_l1)), cls_l1=float(np.mean(cls_l1)), bind_l1=float(np.mean(bind_l1)), delta_l1=float(np.mean(delta_l1)), ) print("=== POS mask coverage (mean over sampled items) ===") for r in ratios: s = mask_stats[r] print(f"ratio={r:.1f} noun_any={s['noun_any']}/{len(idxs)} verb_any={s['verb_any']}/{len(idxs)} " f"noun_cover={s['noun_cover']:.3f} verb_cover={s['verb_cover']:.3f}") def agg_gate(arrs): arrs = [a for a in arrs if a is not None] if not arrs: return None x = np.concatenate([a.reshape(-1) for a in arrs], axis=0) return dict(mean=float(x.mean()), p50=float(np.percentile(x, 50)), p90=float(np.percentile(x, 90)), max=float(x.max())) print("\n=== binding_gate stats (all positions concatenated) ===") for r in ratios: gates = [b["gate"] for b in outs[r]] s = agg_gate(gates) print(f"ratio={r:.1f} gate_stats={s}") print("\n=== proposal_gate_mask stats (fraction selected) ===") for r in ratios: pg = [b['prop_gate'] for b in outs[r]] pg = [a for a in pg if a is not None] if not pg: print(f"ratio={r:.1f} proposal_gate_mask=None") continue # proposal_gate_mask is [N] or [B,N]; we stored sample[0] so [N] or [N,] frac = [float(a.reshape(-1).mean()) for a in pg] print(f"ratio={r:.1f} selected_frac_mean={float(np.mean(frac)):.4f} selected_frac_p50={float(np.percentile(frac,50)):.4f}") print("\n=== proposal_binding stats (all proposals concatenated) ===") for r in ratios: pb = [b['prop_bind'] for b in outs[r]] s = agg_gate(pb) print(f"ratio={r:.1f} proposal_binding_stats={s}") print("\n=== Output mean |L1| vs ratio=%.1f (mean over sampled items) ===" % base_r) for r in ratios[1:]: d = diffs[r] print(f"ratio={r:.1f} sal_l1={d['sal_l1']:.6f} cls_l1={d['cls_l1']:.6f} " f"bind_l1={d['bind_l1']:.6f} delta_l1={d['delta_l1']:.6f}") if __name__ == "__main__": main()