#!/usr/bin/env python # encoding: utf-8 import argparse import json import os import sys from collections import OrderedDict import numpy as np import torch sys.path.append(".") sys.path.append(os.path.dirname(__file__)) from cavi_train_crfa import ( build_masks, embed_pre_head, find_donors, forward_frozen_vdt, hard_margin, setup, ) from fastreid.data import build_reid_train_loader from fastreid.modeling.cavi import ResidualFactorizer from fastreid.modeling.meta_arch import build_model from fastreid.utils.checkpoint import Checkpointer def load_factorizer(path, cfg, args): checkpoint = torch.load(path, map_location=cfg.MODEL.DEVICE) saved_args = checkpoint.get("args", {}) if isinstance(checkpoint, dict) else {} state_dict = ( checkpoint.get("factorizer", checkpoint) if isinstance(checkpoint, dict) else checkpoint ) rank = int(saved_args.get("rank", args.rank)) hidden_dim = int(saved_args.get("hidden_dim", args.hidden_dim)) mode = saved_args.get("factorizer_mode", "gated") factorizer = ResidualFactorizer( dim=cfg.MODEL.BACKBONE.FEAT_DIM, num_layers=len(args.trace_layers), rank=rank, hidden_dim=hidden_dim, mode=mode, ).to(cfg.MODEL.DEVICE) factorizer.load_state_dict(state_dict) factorizer.eval() return factorizer, {"rank": rank, "hidden_dim": hidden_dim, "mode": mode} @torch.no_grad() def evaluate_batch(model, factorizer, inputs, alpha): id_feats, raw_trace, view_feats = forward_frozen_vdt(model, inputs) base_emb = embed_pre_head(model, id_feats) pids = inputs["targets"].detach().cpu().numpy() views = np.array(inputs["viewids"]) same_cross, diff_same_view = find_donors(pids, views) valid = np.where((same_cross >= 0) & (diff_same_view >= 0))[0] if valid.size == 0: return None same_cross = torch.from_numpy(same_cross).to(id_feats.device) diff_same_view = torch.from_numpy(diff_same_view).to(id_feats.device) valid_index = torch.from_numpy(valid).to(id_feats.device) pos_mask, neg_mask = build_masks(valid, pids, views, id_feats.device) split = factorizer(id_feats, raw_trace, view_feats) # Evaluate per-layer and aggregate num_layers = raw_trace.size(1) residual_sets = OrderedDict() # Always include raw trace for comparison for layer_idx in range(num_layers): residual_sets[f"raw_L{layer_idx}"] = raw_trace[:, layer_idx] residual_sets[f"id_L{layer_idx}"] = split["identity"][:, layer_idx] residual_sets[f"view_L{layer_idx}"] = split["view"][:, layer_idx] # Also include mean-pooled versions residual_sets["raw_mean"] = raw_trace.mean(dim=1) residual_sets["id_mean"] = split["identity"].mean(dim=1) residual_sets["view_mean"] = split["view"].mean(dim=1) residual_sets["raw_last"] = raw_trace[:, -1] residual_sets["id_last"] = split["identity"][:, -1] residual_sets["view_last"] = split["view"][:, -1] base_margin, base_valid = hard_margin( base_emb[valid_index], base_emb, pos_mask, neg_mask ) valid_index = valid_index[base_valid] pos_mask = pos_mask[base_valid] neg_mask = neg_mask[base_valid] base_margin = base_margin[base_valid] if valid_index.numel() == 0: return None results = OrderedDict() for name, residual in residual_sets.items(): same_update = id_feats[valid_index] + alpha * residual[same_cross[valid_index]] diff_update = ( id_feats[valid_index] + alpha * residual[diff_same_view[valid_index]] ) same_margin, same_valid = hard_margin( embed_pre_head(model, same_update), base_emb, pos_mask, neg_mask ) diff_margin, diff_valid = hard_margin( embed_pre_head(model, diff_update), base_emb, pos_mask, neg_mask ) keep = same_valid & diff_valid if keep.sum() == 0: continue same_gain = same_margin[keep] - base_margin[keep] diff_gain = diff_margin[keep] - base_margin[keep] gap = same_gain - diff_gain results[name] = { "valid_anchors": int(keep.sum().item()), "same_gain": float(same_gain.mean().item()), "diff_gain": float(diff_gain.mean().item()), "ownership_gap": float(gap.mean().item()), "same_positive_ratio": float((same_gain > 0).float().mean().item()), "diff_nonpositive_ratio": float((diff_gain <= 0).float().mean().item()), "gap_positive_ratio": float((gap > 0).float().mean().item()), "residual_norm": float(residual.norm(dim=1).mean().item()), "raw_norm": float(raw_trace.norm(dim=2).mean().item()), } return results def aggregate(rows): totals = OrderedDict() for row in rows: for name, metrics in row.items(): if name not in totals: totals[name] = {"weight": 0} for key in metrics: if key != "valid_anchors": totals[name][key] = 0.0 weight = metrics["valid_anchors"] totals[name]["weight"] += weight for key, value in metrics.items(): if key != "valid_anchors": totals[name][key] += value * weight summary = OrderedDict() for name, metrics in totals.items(): weight = metrics.pop("weight") summary[name] = {"valid_anchors": int(weight)} for key, value in metrics.items(): summary[name][key] = float(value / max(weight, 1)) return summary def evaluate(args): cfg = setup(args) model = build_model(cfg) Checkpointer(model).load(args.weights) model.to(cfg.MODEL.DEVICE) model.eval() for param in model.parameters(): param.requires_grad_(False) factorizer, factorizer_meta = load_factorizer(args.factorizer, cfg, args) data_loader = build_reid_train_loader(cfg, combineall=cfg.DATASETS.COMBINEALL) rows = [] try: for batch_idx, inputs in enumerate(data_loader): if batch_idx < args.skip_batches: continue if args.max_batches and len(rows) >= args.max_batches: break row = evaluate_batch(model, factorizer, inputs, args.alpha) if row is not None: rows.append(row) finally: if hasattr(data_loader, "shutdown"): data_loader.shutdown() report = OrderedDict() report["config_file"] = args.config_file report["weights"] = args.weights report["factorizer"] = args.factorizer report["factorizer_meta"] = factorizer_meta report["trace_layers"] = args.trace_layers report["alpha"] = args.alpha report["skip_batches"] = args.skip_batches report["max_batches"] = args.max_batches report["num_batches"] = len(rows) report["summary"] = aggregate(rows) report["batches"] = rows os.makedirs(os.path.dirname(args.output), exist_ok=True) with open(args.output, "w") as handle: json.dump(report, handle, indent=2) print(json.dumps(report["summary"], indent=2)) return report def parse_args(): parser = argparse.ArgumentParser( description="Evaluate CAVI CRFA factorizer with held-out exchange diagnostics" ) parser.add_argument("--config-file", required=True) parser.add_argument("--weights", required=True) parser.add_argument("--factorizer", required=True) parser.add_argument("--output", default="logs/CARGO/CAVI_TRACE/crfa_eval.json") parser.add_argument( "--trace-layers", nargs="+", type=int, default=[8, 9, 10, 11] ) parser.add_argument("--alpha", type=float, default=-0.01) parser.add_argument("--max-batches", type=int, default=20) parser.add_argument("--skip-batches", type=int, default=40) parser.add_argument("--batch-size", type=int, default=64) parser.add_argument("--num-workers", type=int, default=0) parser.add_argument("--rank", type=int, default=32) parser.add_argument("--hidden-dim", type=int, default=256) parser.add_argument("--seed", type=int, default=3407) parser.add_argument("opts", nargs=argparse.REMAINDER) return parser.parse_args() def main(): args = parse_args() evaluate(args) if __name__ == "__main__": main()