tools/cavi_eval_crfa.py

#!/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()