"""SIFQ Evaluation Runner — SOTA verification across 4 Tracks. Requires: - scores_sifq.jsonl : output of run_infer.py (SIFQ Q scores) - MDGT checkpoint : for computing genuine/impostor match scores (Track 1) - scipy, matplotlib : for plots and KS tests Outputs (saved to --out-dir): - results_track1_erc.json : AUC_ERC table (SIFQ vs random baseline) - results_track2_sensor.json : KS statistics per sensor pair - results_track4_concepts.json: Spearman rho crosstalk matrix - plot_erc.png : ERC curve - plot_sensor_hist.png : Q distribution per sensor - plot_crosstalk.png : concept grounding heatmap NFIQ2 baseline: pass --nfiq2-scores path/to/nfiq2.jsonl (same format as SIFQ scores but generated externally via `nfiq2 --path ...`). Usage: python scripts/run_eval.py \\ --sifq-scores /tmp/sifq_scores.jsonl \\ --mdgt-checkpoint pad/TRAM-downstream/checkpoint/checkpoints_dinov2_tram/best_eer.pt \\ --out-dir eval_results/ """ from __future__ import annotations import argparse import json import sys from collections import defaultdict from pathlib import Path from itertools import combinations import numpy as np import torch import torch.nn.functional as F import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt ROOT = Path(__file__).resolve().parents[1] SRC_ROOT = ROOT / "src" if str(SRC_ROOT) not in sys.path: sys.path.insert(0, str(SRC_ROOT)) from evaluation.erc import compute_erc from evaluation.sensor_invariance import sensor_ks_test, cross_sensor_correlation from training.mdgt_teacher import MDGTCheckpointTeacher # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- def load_scores(jsonl_path: str) -> list[dict]: rows = [] with open(jsonl_path, encoding="utf-8") as f: for line in f: line = line.strip() if line: rows.append(json.loads(line)) return rows def build_match_scores( rows: list[dict], mdgt: MDGTCheckpointTeacher, device: torch.device, image_size: int = 224, max_pairs: int = 5000, ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """Compute genuine and impostor match scores via MDGT cosine similarity. Returns: quality_scores : [N] SIFQ Q scores for each pair member (mean of pair) match_scores : [N] MDGT cosine similarity labels : [N] 1=genuine, 0=impostor """ from PIL import Image from torchvision import transforms tf = transforms.Compose([ transforms.Resize((image_size, image_size)), transforms.ToTensor(), ]) # Build embedding cache print(" Computing MDGT embeddings for match scores...") paths = [r["image_path"] for r in rows] emb_list: list[torch.Tensor] = [] batch_paths: list[str] = [] batch_size = 16 def flush_emb(bpaths: list[str]) -> None: imgs = [] for p in bpaths: img = Image.open(p).convert("L") imgs.append(tf(img)) batch = torch.stack(imgs, dim=0).to(device) with torch.no_grad(): embs = mdgt(batch) emb_list.extend(embs.cpu()) for row in rows: batch_paths.append(row["image_path"]) if len(batch_paths) >= batch_size: flush_emb(batch_paths) batch_paths.clear() if batch_paths: flush_emb(batch_paths) embs = torch.stack(emb_list, dim=0) # [N, D] # Build genuine pairs (same identity+finger, different sensor) # and impostor pairs (different identity) by_subject: dict[str, list[int]] = defaultdict(list) by_finger_sensor: dict[tuple[str, str], list[int]] = defaultdict(list) for i, r in enumerate(rows): key_fs = (r["identity_id"], r["finger_id"]) by_subject[r["identity_id"]].append(i) by_finger_sensor[key_fs].append(i) rng = np.random.default_rng(42) genuine_pairs: list[tuple[int, int]] = [] for (_, _), idxs in by_finger_sensor.items(): for a, b in combinations(idxs, 2): if rows[a]["sensor_id"] != rows[b]["sensor_id"]: genuine_pairs.append((a, b)) subjects = sorted(by_subject.keys()) impostor_pairs: list[tuple[int, int]] = [] while len(impostor_pairs) < len(genuine_pairs) * 3: s1, s2 = rng.choice(len(subjects), size=2, replace=False) i1 = int(rng.choice(by_subject[subjects[s1]])) i2 = int(rng.choice(by_subject[subjects[s2]])) impostor_pairs.append((i1, i2)) all_pairs = ( [(a, b, 1) for a, b in genuine_pairs] + [(a, b, 0) for a, b in impostor_pairs] ) rng.shuffle(all_pairs) if max_pairs > 0 and len(all_pairs) > max_pairs: all_pairs = all_pairs[:max_pairs] q_all, ms_all, lb_all = [], [], [] q_arr = np.array([r["q_score"] for r in rows]) for a, b, label in all_pairs: cos = float(F.cosine_similarity(embs[a].unsqueeze(0), embs[b].unsqueeze(0)).item()) q_all.append((q_arr[a] + q_arr[b]) / 2.0) ms_all.append(cos) lb_all.append(label) print(f" Pairs: {len(genuine_pairs)} genuine, {len(impostor_pairs)} impostor " f"(using {len(all_pairs)} total)") return np.array(q_all), np.array(ms_all), np.array(lb_all) # --------------------------------------------------------------------------- # Track 1: Error Rejection Curve # --------------------------------------------------------------------------- def run_track1( rows: list[dict], mdgt: MDGTCheckpointTeacher, device: torch.device, out_dir: Path, nfiq2_rows: list[dict] | None = None, image_size: int = 224, ) -> dict: print("[Track 1] Computing ERC...") q_sifq, ms, labels = build_match_scores(rows, mdgt, device, image_size=image_size) rejection_ratios = np.linspace(0.0, 0.5, 50) fnmr_sifq, auc_sifq = compute_erc(q_sifq, ms, labels, rejection_ratios=rejection_ratios) # Random baseline: random quality assignment rng = np.random.default_rng(0) q_rand = rng.uniform(0, 100, size=len(q_sifq)) fnmr_rand, auc_rand = compute_erc(q_rand, ms, labels, rejection_ratios=rejection_ratios) results = { "SIFQ": {"auc_erc": round(auc_sifq, 4)}, "Random": {"auc_erc": round(auc_rand, 4)}, } # NFIQ2 baseline if provided if nfiq2_rows: nfiq2_map = {r["image_path"]: r["q_score"] for r in nfiq2_rows} q_nfiq2 = np.array([nfiq2_map.get(r["image_path"], 50.0) for r in rows]) # Re-build pairs using same MDGT match scores by pairing via indices q_nfiq2_pairs = (q_nfiq2[[a for a, _, _ in [(0,0,0)]]] + q_nfiq2) / 2 # placeholder fnmr_nfiq2, auc_nfiq2 = compute_erc(q_nfiq2, ms, labels, rejection_ratios=rejection_ratios) results["NFIQ2"] = {"auc_erc": round(auc_nfiq2, 4)} # Plot fig, ax = plt.subplots(figsize=(7, 5)) ax.plot(rejection_ratios, fnmr_sifq, label=f"SIFQ (AUC={auc_sifq:.4f})", linewidth=2, color="steelblue") ax.plot(rejection_ratios, fnmr_rand, label=f"Random (AUC={auc_rand:.4f})", linewidth=1.5, linestyle="--", color="gray") if nfiq2_rows: ax.plot(rejection_ratios, fnmr_nfiq2, label=f"NFIQ2 (AUC={auc_nfiq2:.4f})", linewidth=1.5, linestyle=":", color="orangered") ax.set_xlabel("Rejection ratio") ax.set_ylabel("FNMR @ FMR=1e-4") ax.set_title("Error Rejection Curve — lower AUC is better") ax.legend() ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(out_dir / "plot_erc.png", dpi=150) plt.close(fig) print(f" ERC plot saved. AUC_ERC: {results}") return results # --------------------------------------------------------------------------- # Track 2: Sensor Invariance # --------------------------------------------------------------------------- def run_track2(rows: list[dict], out_dir: Path, nfiq2_rows: list[dict] | None = None) -> dict: print("[Track 2] Computing sensor invariance...") scores_by_sensor: dict[str, np.ndarray] = {} tmp: dict[str, list[float]] = defaultdict(list) for r in rows: tmp[r["sensor_id"]].append(r["q_score"]) for sid, vals in tmp.items(): scores_by_sensor[sid] = np.array(vals) ks_rows = sensor_ks_test(scores_by_sensor) mean_ks = float(np.mean([row["ks_stat"] for row in ks_rows])) if ks_rows else 0.0 # Cross-sensor Pearson on paired images (same finger, different sensor) by_finger: dict[tuple[str, str], dict[str, list[float]]] = defaultdict(lambda: defaultdict(list)) for r in rows: key = (r["identity_id"], r["finger_id"]) by_finger[key][r["sensor_id"]].append(r["q_score"]) paired_scores: list[tuple[float, float]] = [] for key, by_s in by_finger.items(): sensors = sorted(by_s.keys()) for s1, s2 in combinations(sensors, 2): for q1, q2 in zip(by_s[s1], by_s[s2]): paired_scores.append((q1, q2)) pearson_sifq = cross_sensor_correlation(paired_scores) results = { "SIFQ": { "mean_ks_across_sensors": round(mean_ks, 4), "cross_sensor_pearson": round(pearson_sifq, 4), "n_sensor_pairs": len(ks_rows), "per_pair_ks": ks_rows, } } if nfiq2_rows: n_tmp: dict[str, list[float]] = defaultdict(list) nfiq2_by_path = {r["image_path"]: r for r in nfiq2_rows} for r in rows: if r["image_path"] in nfiq2_by_path: n_tmp[r["sensor_id"]].append(nfiq2_by_path[r["image_path"]]["q_score"]) nfiq2_by_sensor = {sid: np.array(vals) for sid, vals in n_tmp.items()} nfiq2_ks = sensor_ks_test(nfiq2_by_sensor) nfiq2_mean_ks = float(np.mean([row["ks_stat"] for row in nfiq2_ks])) if nfiq2_ks else 0.0 results["NFIQ2"] = {"mean_ks_across_sensors": round(nfiq2_mean_ks, 4)} # Plot: Q histogram per sensor n_sensors = len(scores_by_sensor) fig, ax = plt.subplots(figsize=(8, 5)) colors = plt.cm.tab10(np.linspace(0, 1, min(n_sensors, 10))) for (sid, vals), color in zip(sorted(scores_by_sensor.items()), colors): ax.hist(vals, bins=40, alpha=0.5, label=sid[:30], color=color, density=True) ax.set_xlabel("SIFQ Quality Score") ax.set_ylabel("Density") ax.set_title(f"Quality score distribution per sensor\n(mean KS={mean_ks:.4f}, Pearson={pearson_sifq:.4f})\nLow KS = sensor-invariant") ax.legend(fontsize=7, loc="upper left") ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(out_dir / "plot_sensor_hist.png", dpi=150) plt.close(fig) # Scatter plot: Q_s1 vs Q_s2 for paired images if paired_scores: arr = np.array(paired_scores[:2000]) fig2, ax2 = plt.subplots(figsize=(5, 5)) ax2.scatter(arr[:, 0], arr[:, 1], alpha=0.3, s=10, color="steelblue") ax2.set_xlabel("Q — sensor 1") ax2.set_ylabel("Q — sensor 2") ax2.set_title(f"Cross-sensor quality consistency\nPearson r={pearson_sifq:.3f}") mn, mx = arr.min(), arr.max() ax2.plot([mn, mx], [mn, mx], "r--", alpha=0.5, label="ideal") ax2.legend() ax2.grid(True, alpha=0.3) fig2.tight_layout() fig2.savefig(out_dir / "plot_sensor_scatter.png", dpi=150) plt.close(fig2) print(f" Sensor invariance done. Mean KS={mean_ks:.4f}, Pearson={pearson_sifq:.4f}") return results # --------------------------------------------------------------------------- # Track 4: Concept Grounding # --------------------------------------------------------------------------- def run_track4( checkpoint_path: str, device: torch.device, test_image_paths: list[str], out_dir: Path, image_size: int = 224, max_images: int = 100, ) -> list[dict]: from evaluation.concept_grounding import compute_crosstalk_matrix from data.degradation import DegradationPipeline from models.aggregator import ScoreAggregator from models.backbone import SIFQBackbone from models.concept_head import ConceptHead, SpatialConceptHead from models.sensor_discriminator import SensorDiscriminator from models.sifq import SIFQ import cv2 print("[Track 4] Computing concept grounding (crosstalk matrix)...") ckpt = torch.load(checkpoint_path, map_location=device, weights_only=False) num_sensors = ckpt.get("metrics", {}).get("n_sensors", 10) backbone = SIFQBackbone(model_name="tiny_vit_5m_224.dist_in22k", pretrained=False) _use_spatial = ckpt.get("config", {}).get("spatial_concept_head", False) if _use_spatial: concept_head = SpatialConceptHead(in_dim=backbone.feature_dim) else: concept_head = ConceptHead(in_dim=backbone.feature_dim) aggregator = ScoreAggregator(k=6) sensor_disc = SensorDiscriminator(in_dim=backbone.feature_dim, num_sensors=num_sensors) model = SIFQ(backbone, concept_head, aggregator, sensor_disc) model.load_state_dict(ckpt["model"], strict=True) model.to(device).eval() deg_pipeline = DegradationPipeline() test_images_np = [] for p in test_image_paths[:max_images]: img = cv2.imread(p, cv2.IMREAD_GRAYSCALE) if img is not None: img = cv2.resize(img, (image_size, image_size)) test_images_np.append(img) if not test_images_np: print(" No test images loaded for concept grounding — skipping Track 4") return [] rows = compute_crosstalk_matrix(model, deg_pipeline, test_images_np, device=str(device)) # Plot heatmap try: concept_names = concept_head.CONCEPT_NAMES deg_names = [r["degradation"] for r in rows] matrix = np.array([[r[c] for c in concept_names] for r in rows]) fig, ax = plt.subplots(figsize=(10, 6)) im = ax.imshow(matrix, vmin=-1, vmax=1, cmap="RdYlGn", aspect="auto") ax.set_xticks(range(len(concept_names))) ax.set_xticklabels(concept_names, rotation=30, ha="right", fontsize=9) ax.set_yticks(range(len(deg_names))) ax.set_yticklabels(deg_names, fontsize=9) for i in range(len(deg_names)): for j in range(len(concept_names)): ax.text(j, i, f"{matrix[i, j]:.2f}", ha="center", va="center", fontsize=7) plt.colorbar(im, ax=ax, label="Spearman ρ") ax.set_title("Concept grounding (crosstalk matrix)\nDiagonal-heavy = well-grounded concepts") fig.tight_layout() fig.savefig(out_dir / "plot_crosstalk.png", dpi=150) plt.close(fig) print(f" Crosstalk matrix saved.") except Exception as e: print(f" Warning: could not plot crosstalk: {e}") return rows # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def parse_args() -> argparse.Namespace: p = argparse.ArgumentParser(description="SIFQ evaluation — SOTA verification") p.add_argument("--sifq-scores", type=str, required=True, help="JSONL output from run_infer.py") p.add_argument("--checkpoint", type=str, required=True, help="SIFQ checkpoint (for Track 4 concept grounding)") p.add_argument("--mdgt-checkpoint", type=str, default="/home/aiserver/works/fingerprint/pad/TRAM-downstream/checkpoint/checkpoints_dinov2_tram/best_eer.pt", help="MDGT checkpoint for computing match scores") p.add_argument("--nfiq2-scores", type=str, default="", help="Optional JSONL with NFIQ2 scores (same format as --sifq-scores)") p.add_argument("--out-dir", type=str, default="eval_results", help="Directory to save plots and result JSONs") p.add_argument("--image-size", type=int, default=224) p.add_argument("--max-pairs", type=int, default=5000, help="Max genuine+impostor pairs for ERC computation") p.add_argument("--max-concept-images", type=int, default=50, help="Max images for concept grounding (Track 4)") p.add_argument("--skip-track1", action="store_true", help="Skip ERC (Track 1) — needs MDGT inference which is slow") p.add_argument("--skip-track4", action="store_true", help="Skip concept grounding (Track 4)") p.add_argument("--exclude-sensor", type=str, default="", help="Comma-separated sensor_ids to exclude before evaluation. " "E.g. 'R_1000_slap,R_500_slap,S_500_slap'") return p.parse_args() # --------------------------------------------------------------------------- # TXT summary writer # --------------------------------------------------------------------------- _CONCEPT_KEYS = [ ("orientation_coherence", "orient_coh"), ("ridge_valley_clarity", "clarity "), ("continuity", "continuity"), ("noise_level", "noise_lvl "), ("contrast_uniformity", "contrast "), ("minutiae_reliability", "minutiae "), ] # T41 concept map — annotate target cells with * # Indices match _CONCEPT_KEYS order: 0=orient_coh, 1=clarity, 2=continuity, # 3=noise_lvl, 4=contrast, 5=minutiae _DEG_TARGETS = { "blur": {1, 2}, # clarity, continuity "noise": {1, 3}, # clarity, noise_lvl "jpeg": {1}, # clarity only "occlusion": {5}, # minutiae "dry_skin": {4, 0}, # contrast, orient_coh "wet_press": {1, 5, 0}, # clarity, minutiae, orient_coh } def _save_summary_txt(all_results: dict, out_path: Path) -> None: from datetime import datetime W = 72 lines = [] def sep(ch="="): lines.append(ch * W) sep() lines.append(f"{'SIFQ EVALUATION SUMMARY':^{W}}") sep() lines.append(f"Generated : {datetime.now().strftime('%Y-%m-%d %H:%M')}") lines.append("") # ── Track 1 ────────────────────────────────────────────────────────── if "track1_erc" in all_results: lines.append("TRACK 1 — ERROR REJECTION CURVE (AUC ↓ better)") sep("-") for method, v in all_results["track1_erc"].items(): lines.append(f" {method:<10s} AUC_ERC = {v['auc_erc']:.4f}") lines.append("") # ── Track 2 ────────────────────────────────────────────────────────── if "track2_sensor_invariance" in all_results: lines.append("TRACK 2 — SENSOR INVARIANCE") sep("-") for method, v in all_results["track2_sensor_invariance"].items(): if not isinstance(v, dict) or "mean_ks_across_sensors" not in v: continue ks = v["mean_ks_across_sensors"] pr = v.get("cross_sensor_pearson", float("nan")) n = v.get("n_sensor_pairs", "?") ks_flag = "✓" if ks <= 0.15 else "✗" pr_flag = "✓" if pr >= 0.75 else "✗" lines.append(f" Method : {method}") lines.append(f" Mean KS (↓ better) : {ks:.4f} {ks_flag} [target ≤ 0.15]") lines.append(f" Pearson (↑ better) : {pr:.4f} {pr_flag} [target ≥ 0.75]") lines.append(f" Pairs : {n}") pairs = v.get("per_pair_ks", []) if pairs: lines.append("") lines.append(f" All {len(pairs)} sensor pairs sorted by KS ↓:") lines.append(f" {'Sensor A':<24s} {'Sensor B':<24s} {'KS':>7s}") lines.append(f" {'-'*24} {'-'*24} {'-'*7}") for p in sorted(pairs, key=lambda x: x["ks_stat"], reverse=True): lines.append( f" {p['sensor_a']:<24s} {p['sensor_b']:<24s} {p['ks_stat']:>7.4f}" ) lines.append("") # ── Track 4 ────────────────────────────────────────────────────────── if "track4_concept_grounding" in all_results: lines.append("TRACK 4 — CONCEPT GROUNDING") lines.append(" Spearman ρ: negative = concept ↓ with degradation = correct (*= target)") sep("-") # header col_w = 9 hdr_keys = [short for _, short in _CONCEPT_KEYS] lines.append( f" {'Degradation':<12s} " + " ".join(f"{h:>{col_w}s}" for h in hdr_keys) ) lines.append( f" {'-'*12} " + " ".join("-" * col_w for _ in _CONCEPT_KEYS) ) for row in all_results["track4_concept_grounding"]: deg = row.get("degradation", "?") targets = _DEG_TARGETS.get(deg, set()) cells = [] for ci, (json_key, _) in enumerate(_CONCEPT_KEYS): val = row.get(json_key, float("nan")) tag = "*" if ci in targets else " " cells.append(f"{val:>+7.3f}{tag} ") lines.append(f" {deg:<12s} " + " ".join(cells)) lines.append("") sep() txt = "\n".join(lines) with open(out_path, "w", encoding="utf-8") as f: f.write(txt) print(f"[eval] Summary table: {out_path}") def main() -> None: args = parse_args() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") out_dir = Path(args.out_dir) out_dir.mkdir(parents=True, exist_ok=True) rows = load_scores(args.sifq_scores) print(f"Loaded {len(rows)} SIFQ score records from {args.sifq_scores}") if args.exclude_sensor: excluded = {s.strip() for s in args.exclude_sensor.split(",") if s.strip()} rows = [r for r in rows if r["sensor_id"] not in excluded] print(f"After excluding sensors {excluded}: {len(rows)} records remain") nfiq2_rows = load_scores(args.nfiq2_scores) if args.nfiq2_scores else None all_results: dict = {} # ---- Track 2: Sensor Invariance (fast, always run) ---- t2 = run_track2(rows, out_dir, nfiq2_rows=nfiq2_rows) all_results["track2_sensor_invariance"] = t2 # ---- Track 1: ERC (needs MDGT inference) ---- if not args.skip_track1: print(f"Loading MDGT teacher from {args.mdgt_checkpoint}") mdgt = MDGTCheckpointTeacher( checkpoint_path=args.mdgt_checkpoint, model_name="vit_small_patch14_dinov2.lvd142m", image_size=args.image_size, device=str(device), ).to(device) t1 = run_track1(rows, mdgt, device, out_dir, nfiq2_rows=nfiq2_rows, image_size=args.image_size) all_results["track1_erc"] = t1 else: print("[Track 1] Skipped (--skip-track1)") # ---- Track 4: Concept Grounding ---- if not args.skip_track4: test_paths = [r["image_path"] for r in rows] t4 = run_track4(args.checkpoint, device, test_paths, out_dir, image_size=args.image_size, max_images=args.max_concept_images) all_results["track4_concept_grounding"] = t4 else: print("[Track 4] Skipped (--skip-track4)") # ---- Save summary as TXT table ---- summary_path = out_dir / "eval_summary.txt" _save_summary_txt(all_results, summary_path) print(f"\n{'='*60}") print("EVALUATION SUMMARY") print(f"{'='*60}") if "track1_erc" in all_results: print("\nTrack 1 — Error Rejection Curve (AUC, lower=better):") for method, v in all_results["track1_erc"].items(): print(f" {method:10s}: AUC_ERC = {v['auc_erc']:.4f}") if "track2_sensor_invariance" in all_results: print("\nTrack 2 — Sensor Invariance:") for method, v in all_results["track2_sensor_invariance"].items(): if isinstance(v, dict) and "mean_ks_across_sensors" in v: print(f" {method:10s}: Mean KS = {v['mean_ks_across_sensors']:.4f} " f"Pearson = {v.get('cross_sensor_pearson', 'N/A')}") print(f"\nPlots and TXT saved to: {out_dir}") print(f"Full summary: {summary_path}") if __name__ == "__main__": main()