tools/cavi_extract_features.py

#!/usr/bin/env python
# encoding: utf-8
"""Full CAVI feature extraction for ReID evaluation.

Loads VDT + CRFA + CREA checkpoints and extracts CAVI features.
Usage:
  python tools/cavi_extract_features.py \
    --config-file configs/CARGO/cavi_trace.yml \
    --weights baseline_logs/VDT/model_best.pth \
    --factorizer logs/CARGO/CAVI_TRACE/crfa_factorizer_rank256_project_200iter.pth \
    --crea logs/CARGO/CAVI_TRACE/crea_model_200iter.pth \
    --output logs/CARGO/CAVI_TRACE/cavi_features.pth
"""

import argparse
import os
import sys

import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader

sys.path.append(".")

from fastreid.config import get_cfg
from fastreid.data import build_reid_test_loader
from fastreid.modeling.cavi import ResidualFactorizer, RestitutionExpertBank
from fastreid.modeling.meta_arch import build_model
from fastreid.utils.checkpoint import Checkpointer


def flatten_feat(feat):
    if feat.dim() == 4:
        return feat[..., 0, 0]
    return feat


class CAVIExtractor:
    """Full CAVI inference pipeline: VDT → CRFA → CREA → features."""

    def __init__(self, cfg, vdt_weights, factorizer_path, crea_path,
                 trace_layers, crfa_rank, crfa_hidden, crfa_mode):
        self.cfg = cfg
        self.device = cfg.MODEL.DEVICE

        # Load VDT
        self.model = build_model(cfg)
        Checkpointer(self.model).load(vdt_weights)
        self.model.to(self.device)
        self.model.eval()
        for p in self.model.parameters():
            p.requires_grad_(False)

        # CRFA factorizer
        self.factorizer = ResidualFactorizer(
            dim=cfg.MODEL.BACKBONE.FEAT_DIM,
            num_layers=len(trace_layers),
            rank=crfa_rank,
            hidden_dim=crfa_hidden,
            mode=crfa_mode,
        ).to(self.device)
        ckpt = torch.load(factorizer_path, map_location=self.device)
        sd = ckpt.get("factorizer", ckpt) if isinstance(ckpt, dict) else ckpt
        self.factorizer.load_state_dict(sd)
        self.factorizer.eval()
        for p in self.factorizer.parameters():
            p.requires_grad_(False)

        # CREA
        self.crea = RestitutionExpertBank(
            dim=cfg.MODEL.BACKBONE.FEAT_DIM,
            num_layers=len(trace_layers),
            bottleneck=64,
            topk=2,
        ).to(self.device)
        ckpt_c = torch.load(crea_path, map_location=self.device)
        sd_c = ckpt_c.get("crea", ckpt_c) if isinstance(ckpt_c, dict) else ckpt_c
        self.crea.load_state_dict(sd_c)
        self.crea.eval()
        for p in self.crea.parameters():
            p.requires_grad_(False)

        self.trace_layers = trace_layers

    @torch.no_grad()
    def extract(self, inputs):
        """Extract CAVI features for a batch.

        Returns:
            cavi_feats: [B, D] CAVI features with CREA restoration
            vdt_feats: [B, D] VDT baseline features (for comparison)
        """
        images = self.model.preprocess_image(inputs)
        camids = inputs["camids"].to(self.device)
        global_feats, view_feats, trace = self.model.backbone(images, camids)

        # VDT baseline
        vdt_feats = global_feats - view_feats
        vdt_feats = flatten_feat(vdt_feats)

        # CRFA decomposition
        raw_trace = trace["meta_pre"] - trace["meta_post"]
        split = self.factorizer(vdt_feats, raw_trace, view_feats)
        identity_residuals = split["identity"]  # [B, E, D]

        # CREA restoration
        crea_out = self.crea(vdt_feats, identity_residuals)
        cavi_feats = crea_out["features"]  # [B, D]

        return cavi_feats, vdt_feats, crea_out


def extract_features(args):
    cfg = get_cfg()
    cfg.merge_from_file(args.config_file)
    cfg.merge_from_list(args.opts)
    cfg.defrost()
    cfg.MODEL.BACKBONE.PRETRAIN = False
    cfg.MODEL.BACKBONE.RETURN_TRACE = True
    cfg.MODEL.BACKBONE.TRACE_LAYERS = tuple(args.trace_layers)
    cfg.TEST.IMS_PER_BATCH = args.batch_size
    cfg.freeze()

    extractor = CAVIExtractor(
        cfg, args.weights, args.factorizer, args.crea,
        args.trace_layers, args.crfa_rank, args.crfa_hidden_dim, args.crfa_mode,
    )

    data_loader = build_reid_test_loader(cfg, args.dataset)

    cavi_features = []
    vdt_features = []
    pids_list = []
    camids_list = []

    for inputs in data_loader:
        cavi_f, vdt_f, crea_out = extractor.extract(inputs)
        cavi_features.append(cavi_f.cpu())
        vdt_features.append(vdt_f.cpu())
        pids_list.append(inputs["targets"])
        camids_list.append(inputs["camids"])

    cavi_features = torch.cat(cavi_features, dim=0)
    vdt_features = torch.cat(vdt_features, dim=0)
    pids = torch.cat(pids_list, dim=0)
    camids = torch.cat(camids_list, dim=0)

    result = {
        "cavi_features": cavi_features,
        "vdt_features": vdt_features,
        "pids": pids,
        "camids": camids,
    }

    os.makedirs(os.path.dirname(args.output), exist_ok=True)
    torch.save(result, args.output)
    print(f"Saved CAVI features: {cavi_features.shape} to {args.output}")
    print(f"CAVI feature norm stats: mean={cavi_features.norm(dim=1).mean():.4f}, "
          f"std={cavi_features.norm(dim=1).std():.4f}")

    return result


def parse_args():
    parser = argparse.ArgumentParser(description="CAVI feature extraction")
    parser.add_argument("--config-file", required=True)
    parser.add_argument("--weights", required=True, help="VDT checkpoint")
    parser.add_argument("--factorizer", required=True, help="CRFA checkpoint")
    parser.add_argument("--crea", required=True, help="CREA checkpoint")
    parser.add_argument("--output", default="logs/CARGO/CAVI_TRACE/cavi_features.pth")
    parser.add_argument("--dataset", default="CARGO", help="Dataset name for test loader")
    parser.add_argument("--trace-layers", nargs="+", type=int, default=[8, 9, 10, 11])
    parser.add_argument("--crfa-rank", type=int, default=256)
    parser.add_argument("--crfa-hidden-dim", type=int, default=512)
    parser.add_argument("--crfa-mode", default="project")
    parser.add_argument("--batch-size", type=int, default=64)
    parser.add_argument("opts", nargs=argparse.REMAINDER)
    return parser.parse_args()


def main():
    args = parse_args()
    extract_features(args)


if __name__ == "__main__":
    main()