| === MDGT TEACHER === |
| 1 from __future__ import annotations |
| 2 |
| 3 from pathlib import Path |
| 4 |
| 5 import torch |
| 6 import torch.nn as nn |
| 7 |
| 8 from models.mdgt.pipeline import MDGTv2 |
| 9 |
| 10 |
| 11 class MDGTCheckpointTeacher(nn.Module): |
| 12 def __init__( |
| 13 self, |
| 14 checkpoint_path: str, |
| 15 device: str = "cpu", |
| 16 ): |
| 17 super().__init__() |
| 18 |
| 19 ckpt_path = Path(checkpoint_path) |
| 20 if not ckpt_path.exists(): |
| 21 raise FileNotFoundError(f"Checkpoint not found: {checkpoint_path}") |
| 22 |
| 23 ckpt = torch.load(str(ckpt_path), map_location=device, weights_only=False) |
| 24 cfg = ckpt.get("config", {}) |
| 25 |
| 26 self.mdgt = MDGTv2( |
| 27 vit_variant=cfg.get("vit_variant", "dinov2_vits14"), |
| 28 num_classes=cfg.get("num_classes", 2), |
| 29 tram_k=cfg.get("tram_k", 30), |
| 30 gnn_layers=cfg.get("gnn_layers", 2), |
| 31 gnn_dim=cfg.get("gnn_dim", 256), |
| 32 gnn_heads=cfg.get("gnn_heads", 4), |
| 33 gnn_k=cfg.get("gnn_k", 9), |
| 34 pool_heads=cfg.get("pool_heads", 4), |
| 35 output_dim=cfg.get("output_dim", 256), |
| 36 image_size=cfg.get("image_size", 224), |
| 37 rpe_dim=cfg.get("rpe_dim", 64), |
| 38 patch_size=cfg.get("patch_size", 0), |
| 39 ) |
| 40 |
| 41 state = ckpt.get("model", ckpt) |
| 42 |
| 43 # Checkpoint was saved from TripletMDGTv2 (self.mdgt = MDGTv2), |
| 44 # so state dict keys are prefixed with "mdgt." |
| 45 first_key = next(iter(state)) |
| 46 if first_key.startswith("mdgt."): |
| 47 state = {k[len("mdgt."):]: v for k, v in state.items()} |
| 48 |
| 49 missing, unexpected = self.mdgt.load_state_dict(state, strict=False) |
| 50 if missing: |
| 51 print(f"[MDGTCheckpointTeacher] {len(missing)} missing keys") |
| 52 if unexpected: |
| 53 print(f"[MDGTCheckpointTeacher] {len(unexpected)} unexpected keys") |
| 54 |
| 55 for p in self.parameters(): |
| 56 p.requires_grad = False |
| 57 self.eval() |
| 58 |
| 59 def forward(self, images: torch.Tensor) -> torch.Tensor: |
| 60 """Return L2-normalised embedding ``(B, output_dim)``.""" |
| 61 emb, _ = self.mdgt(images) |
| 62 return emb |
|
|
| === TRACK 1 MATCH SCORE CODE === |
| 1 """SIFQ Evaluation Runner — SOTA verification across 4 Tracks. |
| 2 |
| 3 Requires: |
| 4 - scores_sifq.jsonl : output of run_infer.py (SIFQ Q scores) |
| 5 - MDGT checkpoint : for computing genuine/impostor match scores (Track 1) |
| 6 - scipy, matplotlib : for plots and KS tests |
| 7 |
| 8 Outputs (saved to --out-dir): |
| 9 - results_track1_erc.json : AUC_ERC table (SIFQ vs random baseline) |
| 10 - results_track2_sensor.json : KS statistics per sensor pair |
| 11 - results_track4_concepts.json: Spearman rho crosstalk matrix |
| 12 - plot_erc.png : ERC curve |
| 13 - plot_sensor_hist.png : Q distribution per sensor |
| 14 - plot_crosstalk.png : concept grounding heatmap |
| 15 |
| 16 NFIQ2 baseline: pass --nfiq2-scores path/to/nfiq2.jsonl (same format as SIFQ |
| 17 scores but generated externally via `nfiq2 --path ...`). |
| 18 |
| 19 Usage: |
| 20 python scripts/run_eval.py \\ |
| 21 --sifq-scores /tmp/sifq_scores.jsonl \\ |
| 22 --mdgt-checkpoint pad/TRAM-downstream/checkpoint/checkpoints_dinov2_tram/best_eer.pt \\ |
| 23 --out-dir eval_results/ |
| 24 """ |
| 25 from __future__ import annotations |
| 26 |
| 27 import argparse |
| 28 import json |
| 29 import sys |
| 30 from collections import defaultdict |
| 31 from pathlib import Path |
| 32 from itertools import combinations |
| 33 |
| 34 import numpy as np |
| 35 import torch |
| 36 import torch.nn.functional as F |
| 37 import matplotlib |
| 38 matplotlib.use("Agg") |
| 39 import matplotlib.pyplot as plt |
| 40 |
| 41 ROOT = Path(__file__).resolve().parents[1] |
| 42 SRC_ROOT = ROOT / "src" |
| 43 if str(SRC_ROOT) not in sys.path: |
| 44 sys.path.insert(0, str(SRC_ROOT)) |
| 45 |
| 46 from evaluation.erc import compute_erc |
| 47 from evaluation.sensor_invariance import sensor_ks_test, cross_sensor_correlation |
| 48 from training.mdgt_teacher import MDGTCheckpointTeacher |
| 49 |
| 50 |
| 51 # --------------------------------------------------------------------------- |
| 52 # Helpers |
| 53 # --------------------------------------------------------------------------- |
| 54 |
| 55 def load_scores(jsonl_path: str) -> list[dict]: |
| 56 rows = [] |
| 57 with open(jsonl_path, encoding="utf-8") as f: |
| 58 for line in f: |
| 59 line = line.strip() |
| 60 if line: |
| 61 rows.append(json.loads(line)) |
| 62 return rows |
| 63 |
| 64 |
| 65 def build_match_scores( |
| 66 rows: list[dict], |
| 67 mdgt: MDGTCheckpointTeacher, |
| 68 device: torch.device, |
| 69 image_size: int = 224, |
| 70 max_pairs: int = 5000, |
| 71 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: |
| 72 """Compute genuine and impostor match scores via MDGT cosine similarity. |
| 73 |
| 74 Returns: |
| 75 quality_scores : [N] SIFQ Q scores for each pair member (mean of pair) |
| 76 match_scores : [N] MDGT cosine similarity |
| 77 labels : [N] 1=genuine, 0=impostor |
| 78 """ |
| 79 from PIL import Image |
| 80 from torchvision import transforms |
| 81 |
| 82 tf = transforms.Compose([ |
| 83 transforms.Resize((image_size, image_size)), |
| 84 transforms.ToTensor(), |
| 85 ]) |
| 86 |
| 87 # Build embedding cache |
| 88 print(" Computing MDGT embeddings for match scores...") |
| 89 paths = [r["image_path"] for r in rows] |
| 90 emb_list: list[torch.Tensor] = [] |
| 91 batch_paths: list[str] = [] |
| 92 batch_size = 16 |
| 93 |
| 94 def flush_emb(bpaths: list[str]) -> None: |
| 95 imgs = [] |
| 96 for p in bpaths: |
| 97 img = Image.open(p).convert("L") |
| 98 imgs.append(tf(img)) |
| 99 batch = torch.stack(imgs, dim=0).to(device) |
| 100 with torch.no_grad(): |
| 101 embs = mdgt(batch) |
| 102 emb_list.extend(embs.cpu()) |
| 103 |
| 104 for row in rows: |
| 105 batch_paths.append(row["image_path"]) |
| 106 if len(batch_paths) >= batch_size: |
| 107 flush_emb(batch_paths) |
| 108 batch_paths.clear() |
| 109 if batch_paths: |
| 110 flush_emb(batch_paths) |
| 111 |
| 112 embs = torch.stack(emb_list, dim=0) # [N, D] |
| 113 |
| 114 # Build genuine pairs (same identity+finger, different sensor) |
| 115 # and impostor pairs (different identity) |
| 116 by_subject: dict[str, list[int]] = defaultdict(list) |
| 117 by_finger_sensor: dict[tuple[str, str], list[int]] = defaultdict(list) |
| 118 for i, r in enumerate(rows): |
| 119 key_fs = (r["identity_id"], r["finger_id"]) |
| 120 by_subject[r["identity_id"]].append(i) |
| 121 by_finger_sensor[key_fs].append(i) |
| 122 |
| 123 rng = np.random.default_rng(42) |
| 124 genuine_pairs: list[tuple[int, int]] = [] |
| 125 for (_, _), idxs in by_finger_sensor.items(): |
| 126 for a, b in combinations(idxs, 2): |
| 127 if rows[a]["sensor_id"] != rows[b]["sensor_id"]: |
| 128 genuine_pairs.append((a, b)) |
| 129 |
| 130 subjects = sorted(by_subject.keys()) |
| 131 impostor_pairs: list[tuple[int, int]] = [] |
| 132 while len(impostor_pairs) < len(genuine_pairs) * 3: |
| 133 s1, s2 = rng.choice(len(subjects), size=2, replace=False) |
| 134 i1 = int(rng.choice(by_subject[subjects[s1]])) |
| 135 i2 = int(rng.choice(by_subject[subjects[s2]])) |
| 136 impostor_pairs.append((i1, i2)) |
| 137 |
| 138 all_pairs = ( |
| 139 [(a, b, 1) for a, b in genuine_pairs] + |
| 140 [(a, b, 0) for a, b in impostor_pairs] |
| 141 ) |
| 142 rng.shuffle(all_pairs) |
| 143 if max_pairs > 0 and len(all_pairs) > max_pairs: |
| 144 all_pairs = all_pairs[:max_pairs] |
| 145 |
| 146 q_all, ms_all, lb_all = [], [], [] |
| 147 q_arr = np.array([r["q_score"] for r in rows]) |
| 148 for a, b, label in all_pairs: |
| 149 cos = float(F.cosine_similarity(embs[a].unsqueeze(0), embs[b].unsqueeze(0)).item()) |
| 150 q_all.append((q_arr[a] + q_arr[b]) / 2.0) |
| 151 ms_all.append(cos) |
| 152 lb_all.append(label) |
| 153 |
| 154 print(f" Pairs: {len(genuine_pairs)} genuine, {len(impostor_pairs)} impostor " |
| 155 f"(using {len(all_pairs)} total)") |
| 156 return np.array(q_all), np.array(ms_all), np.array(lb_all) |
| 157 |
| 158 |
| 159 # --------------------------------------------------------------------------- |
| 160 # Track 1: Error Rejection Curve |
| 161 # --------------------------------------------------------------------------- |
| 162 |
| 163 def run_track1( |
| 164 rows: list[dict], |
| 165 mdgt: MDGTCheckpointTeacher, |
| 166 device: torch.device, |
| 167 out_dir: Path, |
| 168 nfiq2_rows: list[dict] | None = None, |
| 169 image_size: int = 224, |
| 170 ) -> dict: |
| 171 print("[Track 1] Computing ERC...") |
| 172 q_sifq, ms, labels = build_match_scores(rows, mdgt, device, image_size=image_size) |
| 173 |
| 174 rejection_ratios = np.linspace(0.0, 0.5, 50) |
| 175 fnmr_sifq, auc_sifq = compute_erc(q_sifq, ms, labels, rejection_ratios=rejection_ratios) |
| 176 |
| 177 # Random baseline: random quality assignment |
| 178 rng = np.random.default_rng(0) |
| 179 q_rand = rng.uniform(0, 100, size=len(q_sifq)) |
| 180 fnmr_rand, auc_rand = compute_erc(q_rand, ms, labels, rejection_ratios=rejection_ratios) |
| 181 |
| 182 results = { |
| 183 "SIFQ": {"auc_erc": round(auc_sifq, 4)}, |
| 184 "Random": {"auc_erc": round(auc_rand, 4)}, |
| 185 } |
| 186 |
| 187 # NFIQ2 baseline if provided |
| 188 if nfiq2_rows: |
| 189 nfiq2_map = {r["image_path"]: r["q_score"] for r in nfiq2_rows} |
| 190 q_nfiq2 = np.array([nfiq2_map.get(r["image_path"], 50.0) for r in rows]) |
| 191 # Re-build pairs using same MDGT match scores by pairing via indices |
| 192 q_nfiq2_pairs = (q_nfiq2[[a for a, _, _ in [(0,0,0)]]] + q_nfiq2) / 2 # placeholder |
| 193 fnmr_nfiq2, auc_nfiq2 = compute_erc(q_nfiq2, ms, labels, rejection_ratios=rejection_ratios) |
| 194 results["NFIQ2"] = {"auc_erc": round(auc_nfiq2, 4)} |
| 195 |
| 196 # Plot |
| 197 fig, ax = plt.subplots(figsize=(7, 5)) |
| 198 ax.plot(rejection_ratios, fnmr_sifq, label=f"SIFQ (AUC={auc_sifq:.4f})", linewidth=2, color="steelblue") |
| 199 ax.plot(rejection_ratios, fnmr_rand, label=f"Random (AUC={auc_rand:.4f})", linewidth=1.5, |
| 200 linestyle="--", color="gray") |
| 201 if nfiq2_rows: |
| 202 ax.plot(rejection_ratios, fnmr_nfiq2, label=f"NFIQ2 (AUC={auc_nfiq2:.4f})", |
| 203 linewidth=1.5, linestyle=":", color="orangered") |
| 204 ax.set_xlabel("Rejection ratio") |
| 205 ax.set_ylabel("FNMR @ FMR=1e-4") |
| 206 ax.set_title("Error Rejection Curve — lower AUC is better") |
| 207 ax.legend() |
| 208 ax.grid(True, alpha=0.3) |
| 209 fig.tight_layout() |
| 210 fig.savefig(out_dir / "plot_erc.png", dpi=150) |
| 211 plt.close(fig) |
| 212 print(f" ERC plot saved. AUC_ERC: {results}") |
| 213 return results |
| 214 |
| 215 |
| 216 # --------------------------------------------------------------------------- |
| 217 # Track 2: Sensor Invariance |
| 218 # --------------------------------------------------------------------------- |
| 219 |
| 220 def run_track2(rows: list[dict], out_dir: Path, nfiq2_rows: list[dict] | None = None) -> dict: |
| 221 print("[Track 2] Computing sensor invariance...") |
| 222 |
| 223 scores_by_sensor: dict[str, np.ndarray] = {} |
| 224 tmp: dict[str, list[float]] = defaultdict(list) |
| 225 for r in rows: |
| 226 tmp[r["sensor_id"]].append(r["q_score"]) |
| 227 for sid, vals in tmp.items(): |
| 228 scores_by_sensor[sid] = np.array(vals) |
| 229 |
| 230 ks_rows = sensor_ks_test(scores_by_sensor) |
|
|
| === DATASET AND TRANSFORM REFERENCES === |
| sifq/src/configs/default.py:56: image_size: tuple[int, int] = (256, 256) # (H, W) |
| sifq/src/configs/default.py:109: image_size: tuple[int, int] = (256, 256) |
| sifq/src/configs/default.py:172: With image_size=224 and patch_size=14 → 16×16 = 256 patch tokens. |
| sifq/src/configs/default.py:177: image_size: int = 224 |
| sifq/src/configs/default.py:268: image_size: int = 224 |
| sifq/src/data/polyu_loader.py:7:from torchvision import transforms |
| sifq/src/data/polyu_loader.py:51: def __init__(self, image_size: int = 224): |
| sifq/src/data/polyu_loader.py:52: self.transform = transforms.Compose( |
| sifq/src/data/polyu_loader.py:54: transforms.Resize((image_size, image_size)), |
| sifq/src/data/polyu_loader.py:55: transforms.ToTensor(), |
| sifq/src/data/polyu_loader.py:85: tensor = self.transform(image) |
| sifq/src/data/joint_augmentor.py:3:Applies the same geometric transform to both the image and minutiae |
| sifq/src/data/joint_augmentor.py:23: """Applies the same geometric transform to image and minutiae simultaneously. |
| sifq/src/data/fvc_loader.py:9:from torchvision import transforms |
| sifq/src/data/fvc_loader.py:50: def __init__(self, image_size: int = 224): |
| sifq/src/data/fvc_loader.py:51: self.transform = transforms.Compose( |
| sifq/src/data/fvc_loader.py:53: transforms.Resize((image_size, image_size)), |
| sifq/src/data/fvc_loader.py:54: transforms.ToTensor(), |
| sifq/src/data/fvc_loader.py:80: tensor = self.transform(image) |
| sifq/src/data/augmentation.py:20:from torchvision import transforms as T |
| sifq/src/data/augmentation.py:69:def build_train_transform(image_size: int = 224, profile: str = "standard") -> T.Compose: |
| sifq/src/data/augmentation.py:72: Returns a ``torchvision.transforms.Compose`` that takes a PIL image |
| sifq/src/data/augmentation.py:80: T.Resize((image_size, image_size)), |
| sifq/src/data/augmentation.py:83: T.RandomResizedCrop( |
| sifq/src/data/augmentation.py:84: image_size, |
| sifq/src/data/augmentation.py:98: T.Resize((image_size, image_size)), |
| sifq/src/data/augmentation.py:111: T.RandomResizedCrop(image_size, scale=(0.8, 1.0), ratio=(0.95, 1.05)), |
| sifq/src/data/augmentation.py:123: T.ToTensor(), |
| sifq/src/data/augmentation.py:129:def build_val_transform(image_size: int = 224) -> T.Compose: |
| sifq/src/data/augmentation.py:130: """Validation transform: resize + to tensor (no augmentation).""" |
| sifq/src/data/augmentation.py:132: T.Resize((image_size, image_size)), |
| sifq/src/data/augmentation.py:133: T.ToTensor(), |
| sifq/src/data/enhanced_sampler.py:17:from .image_dataset import ImageDataset, ImageListDataset |
| sifq/src/data/enhanced_sampler.py:30: dataset : ImageDataset |
| sifq/src/data/enhanced_sampler.py:52: dataset: ImageDataset, |
| sifq/src/data/enhanced_sampler.py:266: dataset: ImageDataset | ImageListDataset, |
| sifq/src/data/nist302_loader.py:9:from torchvision import transforms |
| sifq/src/data/nist302_loader.py:33: def __init__(self, image_size: int = 224): |
| sifq/src/data/nist302_loader.py:34: self.transform = transforms.Compose( |
| sifq/src/data/nist302_loader.py:36: transforms.Resize((image_size, image_size)), |
| sifq/src/data/nist302_loader.py:37: transforms.ToTensor(), |
| sifq/src/data/nist302_loader.py:58: tensor = self.transform(image) |
| sifq/src/data/dataset.py:27:from torchvision import transforms |
| sifq/src/data/dataset.py:49: image_size: tuple[int, int] = (256, 256), |
| sifq/src/data/dataset.py:56: self.image_size = image_size |
| sifq/src/data/dataset.py:64: self.to_tensor = transforms.ToTensor() |
| sifq/src/data/dataset.py:167: target_h, target_w = self.image_size |
| sifq/src/data/dataset.py:199: (self.image_size[1], self.image_size[0]), Image.BILINEAR |
| sifq/src/data/dataset.py:297: image_size=cfg.image_size, |
| sifq/src/data/image_dataset.py:24:from .augmentation import build_train_transform, build_val_transform |
| sifq/src/data/image_dataset.py:44:class ImageDataset(Dataset): |
| sifq/src/data/image_dataset.py:55: image_size: int = 224, |
| sifq/src/data/image_dataset.py:61: self.transform = ( |
| sifq/src/data/image_dataset.py:62: build_train_transform(image_size, profile=augment_profile) if augment |
| sifq/src/data/image_dataset.py:63: else build_val_transform(image_size) |
| sifq/src/data/image_dataset.py:143: image = self.transform(pil_img) |
| sifq/src/data/image_dataset.py:157: image_size: int = 224, |
| sifq/src/data/image_dataset.py:162: self.transform = ( |
| sifq/src/data/image_dataset.py:163: build_train_transform(image_size, profile=augment_profile) if augment |
| sifq/src/data/image_dataset.py:164: else build_val_transform(image_size) |
| sifq/src/data/image_dataset.py:182: image = self.transform(pil_img) |
| sifq/src/data/image_dataset.py:189: def __init__(self, dataset: ImageDataset, p: int = 8, k: int = 4, device_aware: bool = False): |
| sifq/src/losses/degradation_ranking.py:24:# (mean=0.952, std=0.135, p5=0.936) because concept[0] has NO L_deg target. |
| sifq/src/train.py:17:import torchvision.transforms.functional as TF |
| sifq/src/train.py:62: image_size: int, |
| sifq/src/train.py:67: self.nist_loader = NIST302Loader(image_size=image_size) |
| sifq/src/train.py:68: self.fvc_loader = FVCLoader(image_size=image_size) |
| sifq/src/train.py:73: self._preload_images(image_size) |
| sifq/src/train.py:75: def _preload_images(self, image_size: int) -> None: |
| sifq/src/train.py:77: cache = np.empty((N, image_size, image_size), dtype=np.uint8) |
| sifq/src/train.py:529: nist_loader = NIST302Loader(image_size=args.image_size) |
| sifq/src/train.py:538: fvc_loader = FVCLoader(image_size=args.image_size) |
| sifq/src/train.py:545: polyu_loader = PolyULoader(image_size=args.image_size) |
| sifq/src/train.py:568: train_ds = RecordDataset(records=records, image_size=args.image_size, sensor_to_idx=sensor_to_idx) |
| sifq/src/train.py:897: f"q_mean={_q_mean:.1f} q_std={_q_std:.1f} " |
| sifq/src/models/mdgt/pipeline.py:80: image_size : int |
| sifq/src/models/mdgt/pipeline.py:105: image_size: int = 224, |
| sifq/src/models/mdgt/pipeline.py:119: image_size=image_size, |
| sifq/src/models/mdgt/pipeline.py:126: img_size=image_size, |
| sifq/src/models/mdgt/pipeline.py:207: nn.init.trunc_normal_(self.cls_head.weight, std=0.02) |
| sifq/src/models/mdgt/vit_graph.py:81: image_size=cfg.vit.image_size, |
| sifq/src/models/mdgt/vit_graph.py:84: self._vit_image_size = (cfg.vit.image_size, cfg.vit.image_size) |
| sifq/src/models/mdgt/vit_graph.py:184: # 0. Grayscale → 3-channel + resize for ViT |
| sifq/src/models/mdgt/vit_graph.py:187: if images.shape[-2:] != self._vit_image_size: |
| sifq/src/models/mdgt/vit_graph.py:189: images, size=self._vit_image_size, |
| sifq/src/models/mdgt/relational_pe.py:57: # Normalize spatial features so all 7 dims are ~ [-1, 1] scale. |
| sifq/src/models/mdgt/vit.py:216: nn.init.trunc_normal_(self.pos_embed, std=0.02) |
| sifq/src/models/mdgt/vit.py:217: nn.init.trunc_normal_(self.cls_token, std=0.02) |
| sifq/src/models/mdgt/vit.py:220: nn.init.trunc_normal_(m.weight, std=0.02) |
| sifq/src/models/mdgt/vit_backbone.py:41: image_size : int |
| sifq/src/models/mdgt/vit_backbone.py:51: image_size: int = 224, |
| sifq/src/models/mdgt/vit_backbone.py:62: img_size=image_size, |
| sifq/src/models/mdgt/vit_backbone.py:85: Grayscale images should be repeated to 3 channels |
| sifq/src/models/mdgt/dinov2_backbone.py:30: image_size : int |
| sifq/src/models/mdgt/dinov2_backbone.py:42: image_size: int = 224, |
| sifq/src/models/mdgt/dinov2_backbone.py:53: # ---- Grayscale -> RGB adapter (learned, init to equal mix) ---- |
| sifq/src/models/mdgt/dinov2_backbone.py:61: self.grid_size: tuple[int, int] = (image_size // ps, image_size // ps) |
| sifq/src/models/mdgt/dinov2_backbone.py:130: # Grayscale -> RGB |
| sifq/src/models/mdgt/pipeline_continual_pretrained.py:7: - Grayscale images are converted to RGB via channel replication |
| sifq/src/models/mdgt/pipeline_continual_pretrained.py:73: image_size : int |
| sifq/src/models/mdgt/pipeline_continual_pretrained.py:94: image_size: int = 224, |
| sifq/src/models/mdgt/pipeline_continual_pretrained.py:111: image_size=image_size, |
| sifq/src/training/mdgt_teacher.py:36: image_size=cfg.get("image_size", 224), |
| sifq/scripts/run_eval.py:69: image_size: int = 224, |
| sifq/scripts/run_eval.py:80: from torchvision import transforms |
| sifq/scripts/run_eval.py:82: tf = transforms.Compose([ |
| sifq/scripts/run_eval.py:83: transforms.Resize((image_size, image_size)), |
| sifq/scripts/run_eval.py:84: transforms.ToTensor(), |
| sifq/scripts/run_eval.py:169: image_size: int = 224, |
| sifq/scripts/run_eval.py:172: q_sifq, ms, labels = build_match_scores(rows, mdgt, device, image_size=image_size) |
| sifq/scripts/run_eval.py:312: image_size: int = 224, |
| sifq/scripts/run_eval.py:344: img = cv2.resize(img, (image_size, image_size)) |
| sifq/scripts/run_eval.py:439: image_size=args.image_size, |
| sifq/scripts/run_eval.py:443: image_size=args.image_size) |
| sifq/scripts/run_eval.py:452: image_size=args.image_size, max_images=args.max_concept_images) |
| sifq/scripts/visualize_score_milestones.py:124: norm = plt.Normalize(vmin=q_min, vmax=q_max) |
| sifq/scripts/visualize_score_milestones.py:189: transform=ax_img.transAxes, |
| sifq/scripts/gen_nfiq2_proxy_scores.py:39:def _gabor_energy(gray: np.ndarray, image_size: int = 224) -> float: |
| sifq/scripts/gen_nfiq2_proxy_scores.py:41: img = cv2.resize(gray, (image_size, image_size)).astype(np.float32) / 255.0 |
| sifq/scripts/run_infer.py:95: loader = NIST302Loader(image_size=args.image_size) |
| sifq/scripts/train_sifq.py:17:import torchvision.transforms.functional as TF |
| sifq/scripts/train_sifq.py:62: image_size: int, |
| sifq/scripts/train_sifq.py:67: self.nist_loader = NIST302Loader(image_size=image_size) |
| sifq/scripts/train_sifq.py:68: self.fvc_loader = FVCLoader(image_size=image_size) |
| sifq/scripts/train_sifq.py:73: self._preload_images(image_size) |
| sifq/scripts/train_sifq.py:75: def _preload_images(self, image_size: int) -> None: |
| sifq/scripts/train_sifq.py:77: cache = np.empty((N, image_size, image_size), dtype=np.uint8) |
| sifq/scripts/train_sifq.py:559: nist_loader = NIST302Loader(image_size=args.image_size) |
| sifq/scripts/train_sifq.py:568: fvc_loader = FVCLoader(image_size=args.image_size) |
| sifq/scripts/train_sifq.py:575: polyu_loader = PolyULoader(image_size=args.image_size) |
| sifq/scripts/train_sifq.py:598: train_ds = RecordDataset(records=records, image_size=args.image_size, sensor_to_idx=sensor_to_idx) |
| sifq/scripts/train_sifq.py:933: f"q_mean={_q_mean:.1f} q_std={_q_std:.1f} " |
| sifq/scripts/_gen_report_v24.py:112: ' ScoreAggregator chon noise_level (std=0.340, cao nhat)', |
| pad/TRAM-downstream/livdev_dataloader.py:7:from torchvision import transforms |
| pad/TRAM-downstream/livdev_dataloader.py:190: def __init__(self, dataset, transform): |
| pad/TRAM-downstream/livdev_dataloader.py:192: self.transform = transform |
| pad/TRAM-downstream/livdev_dataloader.py:199: if self.transform: |
| pad/TRAM-downstream/livdev_dataloader.py:200: image = self.transform(image) |
| pad/TRAM-downstream/livdev_dataloader.py:223: transform: dict, |
| pad/TRAM-downstream/livdev_dataloader.py:240: train_dataset = TransformedDataset(train_subset, transform['Train']) |
| pad/TRAM-downstream/livdev_dataloader.py:241: val_dataset = TransformedDataset(val_subset, transform['Test']) |
| pad/TRAM-downstream/livdev_dataloader.py:246: test_dataset = TransformedDataset(dataset, transform['Test']) |
| pad/TRAM-downstream/dataloader.py:7:from torchvision import transforms |
| pad/TRAM-downstream/dataloader.py:190: def __init__(self, dataset, transform): |
| pad/TRAM-downstream/dataloader.py:192: self.transform = transform |
| pad/TRAM-downstream/dataloader.py:199: if self.transform: |
| pad/TRAM-downstream/dataloader.py:200: image = self.transform(image) |
| pad/TRAM-downstream/dataloader.py:223: transform: dict, |
| pad/TRAM-downstream/dataloader.py:240: train_dataset = TransformedDataset(train_subset, transform['Train']) |
| pad/TRAM-downstream/dataloader.py:241: val_dataset = TransformedDataset(val_subset, transform['Test']) |
| pad/TRAM-downstream/dataloader.py:246: test_dataset = TransformedDataset(dataset, transform['Test']) |
| pad/TRAM-downstream/infer.py:51:from torchvision import models, transforms |
| pad/TRAM-downstream/infer.py:60: """Lightweight STN that predicts a 4-parameter affine transform |
| pad/TRAM-downstream/infer.py:157: num_transformer_layers: int = 12, |
| pad/TRAM-downstream/infer.py:201: self.transformer = nn.Sequential( |
| pad/TRAM-downstream/infer.py:204: for _ in range(num_transformer_layers) |
| pad/TRAM-downstream/infer.py:237: tokens = self.transformer(tokens) |
| pad/TRAM-downstream/infer.py:261: def __init__(self, root_dir: str, transform: Optional[transforms.Compose] = None): |
| pad/TRAM-downstream/infer.py:264: self.transform = transform |
| pad/TRAM-downstream/infer.py:298: if self.transform: |
| pad/TRAM-downstream/infer.py:299: img = self.transform(img) |
| pad/TRAM-downstream/infer.py:307: def __init__(self, root_dir: str, transform: Optional[transforms.Compose] = None): |
| pad/TRAM-downstream/infer.py:310: self.transform = transform |
| pad/TRAM-downstream/infer.py:356: if self.transform: |
| pad/TRAM-downstream/infer.py:357: img = self.transform(img) |
| pad/TRAM-downstream/infer.py:550: num_transformer_layers=12, |
| pad/TRAM-downstream/infer.py:597:def get_transform(image_size: int = 224) -> transforms.Compose: |
| pad/TRAM-downstream/infer.py:598: """Grayscale -> 3-channel -> resize -> ImageNet normalize.""" |
| pad/TRAM-downstream/infer.py:599: return transforms.Compose( |
| pad/TRAM-downstream/infer.py:601: transforms.Resize((image_size, image_size)), |
| pad/TRAM-downstream/infer.py:602: transforms.Grayscale(num_output_channels=3), |
| pad/TRAM-downstream/infer.py:603: transforms.ToTensor(), |
| pad/TRAM-downstream/infer.py:604: transforms.Normalize( |
| pad/TRAM-downstream/infer.py:605: mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] |
| pad/TRAM-downstream/infer.py:769: transform = get_transform(args.image_size) |
| pad/TRAM-downstream/infer.py:777: dataset = FVCDataset(db_path, transform=transform) |
| pad/TRAM-downstream/model/pipeline.py:73: image_size : int |
| pad/TRAM-downstream/model/pipeline.py:92: image_size: int = 224, |
| pad/TRAM-downstream/model/pipeline.py:101: img_size=image_size, |
| pad/TRAM-downstream/model/pipeline.py:163: nn.init.trunc_normal_(self.cls_head.weight, std=0.02) |
| pad/TRAM-downstream/model/vit_graph.py:81: image_size=cfg.vit.image_size, |
| pad/TRAM-downstream/model/vit_graph.py:84: self._vit_image_size = (cfg.vit.image_size, cfg.vit.image_size) |
| pad/TRAM-downstream/model/vit_graph.py:184: # 0. Grayscale → 3-channel + resize for ViT |
| pad/TRAM-downstream/model/vit_graph.py:187: if images.shape[-2:] != self._vit_image_size: |
| pad/TRAM-downstream/model/vit_graph.py:189: images, size=self._vit_image_size, |
| pad/TRAM-downstream/model/relational_pe.py:57: # Normalize spatial features so all 7 dims are ~ [-1, 1] scale. |
| pad/TRAM-downstream/model/flare/units.py:10:class NormalizeModule(nn.Module): |
| pad/TRAM-downstream/model/flare/__init__.py:4:from .units import NormalizeModule |
| pad/TRAM-downstream/model/vit.py:202: nn.init.trunc_normal_(self.pos_embed, std=0.02) |
| pad/TRAM-downstream/model/vit.py:203: nn.init.trunc_normal_(self.cls_token, std=0.02) |
| pad/TRAM-downstream/model/vit.py:206: nn.init.trunc_normal_(m.weight, std=0.02) |
| pad/TRAM-downstream/model/domain_bn.py:79: # Normalize using batch stats |
| pad/TRAM-downstream/model/pipeline_continual.py:65: image_size : int |
| pad/TRAM-downstream/model/pipeline_continual.py:87: image_size: int = 224, |
| pad/TRAM-downstream/model/pipeline_continual.py:101: img_size=image_size, |
| pad/TRAM-downstream/model/pipeline_continual.py:115: grid_size = (image_size // 16, image_size // 16) # Patch grid |
| pad/TRAM-downstream/model/pipeline_continual.py:168: nn.init.trunc_normal_(self.cls_head.weight, std=0.02) |
| pad/TRAM-downstream/model/vit_backbone.py:41: image_size : int |
| pad/TRAM-downstream/model/vit_backbone.py:51: image_size: int = 224, |
| pad/TRAM-downstream/model/vit_backbone.py:62: img_size=image_size, |
| pad/TRAM-downstream/model/vit_backbone.py:85: Grayscale images should be repeated to 3 channels |
| pad/TRAM-downstream/model/pipeline_continual_pretrained.py:7: - Grayscale images are converted to RGB via channel replication |
| pad/TRAM-downstream/model/pipeline_continual_pretrained.py:74: image_size : int |
| pad/TRAM-downstream/model/pipeline_continual_pretrained.py:95: image_size: int = 224, |
| pad/TRAM-downstream/model/pipeline_continual_pretrained.py:113: image_size=image_size, |
| pad/TRAM-downstream/eval.py:18:from fingerprint_graph.data.image_dataset import ImageDataset |
| pad/TRAM-downstream/eval.py:379: image_size=cfg.get("image_size", 224), |
| pad/TRAM-downstream/eval.py:396: val_ds = ImageDataset(args.val_image_dir, image_size=ckpt.get("config", {}).get("image_size", 224), augment=False) |
|
|
| === MDGT VALIDATION DATASET IMPLEMENTATION === |
| --- sifq/src/data/image_dataset.py |
| 1 from __future__ import annotations |
| 2 |
| 3 """Image-only dataset for the V2 (ViT + TRAM + GNN) pipeline. |
| 4 |
| 5 Unlike ``FingerprintDataset`` which requires paired minutiae files, |
| 6 this dataset loads only images + identity labels. No minutiae extractor |
| 7 is needed — the ViT backbone learns features end-to-end. |
| 8 |
| 9 Supports directory layouts: |
| 10 1. ImageFolder: ``root/identity_name/sample.{ext}`` |
| 11 2. PolyU: ``root/{first,second}_session/finger_sample.{ext}`` |
| 12 (identity parsed from filename prefix before last underscore) |
| 13 """ |
| 14 |
| 15 import os |
| 16 import random |
| 17 from collections import defaultdict |
| 18 from pathlib import Path |
| 19 |
| 20 import torch |
| 21 from torch.utils.data import Dataset, Sampler |
| 22 from PIL import Image |
| 23 |
| 24 from .augmentation import build_train_transform, build_val_transform |
| 25 |
| 26 |
| 27 IMAGE_EXTS = {".bmp", ".png", ".tif", ".tiff", ".jpg", ".jpeg"} |
| 28 |
| 29 |
| 30 def infer_device_from_name(path_or_name: str) -> str | None: |
| 31 stem = Path(path_or_name).stem |
| 32 parts = stem.split("_") |
| 33 if len(parts) < 4: |
| 34 return None |
| 35 token = parts[1] |
| 36 token_lower = token.lower() |
| 37 if token_lower in {"roll", "plain"}: |
| 38 return token_lower |
| 39 if token.isalpha() and len(token) <= 3: |
| 40 return token |
| 41 return None |
| 42 |
| 43 |
| 44 class ImageDataset(Dataset): |
| 45 """Load fingerprint images with identity labels for metric learning. |
| 46 |
| 47 Returns: |
| 48 image: ``(1, H, W)`` normalised [0, 1] |
| 49 label: int |
| 50 """ |
| 51 |
| 52 def __init__( |
| 53 self, |
| 54 image_dir: str, |
| 55 image_size: int = 224, |
| 56 augment: bool = True, |
| 57 repeat_factor: int = 1, |
| 58 augment_profile: str = "standard", |
| 59 ): |
| 60 super().__init__() |
| 61 self.transform = ( |
| 62 build_train_transform(image_size, profile=augment_profile) if augment |
| 63 else build_val_transform(image_size) |
| 64 ) |
| 65 self.repeat_factor = max(1, int(repeat_factor)) |
| 66 |
| 67 self.samples: list[tuple[str, int]] = [] # (path, label) |
| 68 self.labels: list[int] = [] |
| 69 self.devices: list[str | None] = [] |
| 70 self.label_map: dict[str, int] = {} |
| 71 |
| 72 self._discover(image_dir) |
| 73 |
| 74 # ------------------------------------------------------------------ |
| 75 def _discover(self, image_dir: str): |
| 76 root = Path(image_dir) |
| 77 if not root.exists(): |
| 78 return |
| 79 |
| 80 subdirs = sorted([d for d in root.iterdir() if d.is_dir()]) |
| 81 session_like = subdirs and all("session" in d.name.lower() for d in subdirs) |
| 82 |
| 83 if subdirs and not session_like: |
| 84 has_images = any( |
| 85 any(f.suffix.lower() in IMAGE_EXTS for f in d.iterdir() if f.is_file()) |
| 86 for d in subdirs[:5] |
| 87 ) |
| 88 if has_images: |
| 89 self._discover_imagefolder(root, subdirs) |
| 90 return |
| 91 |
| 92 self._discover_flat(root) |
| 93 |
| 94 def _append_sample(self, img_path: Path, label: int): |
| 95 self.samples.append((str(img_path), label)) |
| 96 self.labels.append(label) |
| 97 self.devices.append(infer_device_from_name(img_path.name)) |
| 98 |
| 99 def _discover_imagefolder(self, root: Path, subdirs: list[Path]): |
| 100 """``root/identity/sample.ext`` layout.""" |
| 101 for idx, identity_dir in enumerate(subdirs): |
| 102 identity = identity_dir.name |
| 103 self.label_map[identity] = idx |
| 104 for img_file in sorted(identity_dir.iterdir()): |
| 105 if img_file.suffix.lower() in IMAGE_EXTS: |
| 106 self._append_sample(img_file, idx) |
| 107 |
| 108 def _discover_flat(self, root: Path): |
| 109 """Flat/PolyU layout — parse identity from filename.""" |
| 110 all_images: list[Path] = [] |
| 111 for ext in IMAGE_EXTS: |
| 112 all_images.extend(root.rglob(f"*{ext}")) |
| 113 all_images = sorted(all_images) |
| 114 |
| 115 identity_of: dict[str, str] = {} |
| 116 for img in all_images: |
| 117 stem = img.stem |
| 118 parts = stem.rsplit("_", 1) |
| 119 identity = parts[0] if len(parts) > 1 else stem |
| 120 identity_of[str(img)] = identity |
| 121 |
| 122 unique_ids = sorted(set(identity_of.values())) |
| 123 id_to_label = {name: idx for idx, name in enumerate(unique_ids)} |
| 124 self.label_map = id_to_label |
| 125 |
| 126 for img in all_images: |
| 127 identity = identity_of[str(img)] |
| 128 label = id_to_label[identity] |
| 129 self._append_sample(img, label) |
| 130 |
| 131 # ------------------------------------------------------------------ |
| 132 @property |
| 133 def num_classes(self) -> int: |
| 134 return len(self.label_map) |
| 135 |
| 136 def __len__(self) -> int: |
| 137 return len(self.samples) * self.repeat_factor |
| 138 |
| 139 def __getitem__(self, idx: int) -> dict[str, object]: |
| 140 idx = idx % len(self.samples) |
| 141 path, label = self.samples[idx] |
| 142 pil_img = Image.open(path).convert("L") |
| 143 image = self.transform(pil_img) |
| 144 return {"image": image, "label": label} |
| 145 |
| 146 |
| 147 class ImageListDataset(Dataset): |
| 148 """Image dataset backed by an explicit list of ``(path, label)`` samples. |
| 149 |
| 150 Useful for continual learning where the effective training set is assembled |
| 151 dynamically from the current stage plus replay exemplars from previous stages. |
| 152 """ |
| 153 |
| 154 def __init__( |
| 155 self, |
| 156 samples: list[tuple[str, int]], |
| 157 image_size: int = 224, |
| 158 augment: bool = True, |
| 159 augment_profile: str = "standard", |
| 160 ): |
| 161 super().__init__() |
| 162 self.transform = ( |
| 163 build_train_transform(image_size, profile=augment_profile) if augment |
| 164 else build_val_transform(image_size) |
| 165 ) |
| 166 self.samples = [(str(path), int(label)) for path, label in samples] |
| 167 self.labels = [label for _path, label in self.samples] |
| 168 self.devices = [infer_device_from_name(path) for path, _label in self.samples] |
| 169 unique_labels = sorted(set(self.labels)) |
| 170 self.label_map = {str(label): label for label in unique_labels} |
| 171 |
| 172 @property |
| 173 def num_classes(self) -> int: |
| 174 return len(self.label_map) |
| 175 |
| 176 def __len__(self) -> int: |
| 177 return len(self.samples) |
| 178 |
| 179 def __getitem__(self, idx: int) -> dict[str, object]: |
| 180 path, label = self.samples[idx] |
| 181 pil_img = Image.open(path).convert("L") |
| 182 image = self.transform(pil_img) |
| 183 return {"image": image, "label": label} |
| 184 |
| 185 |
| 186 class PKSamplerV2(Sampler): |
| 187 """P identities × K samples per batch for metric learning.""" |
| 188 |
| 189 def __init__(self, dataset: ImageDataset, p: int = 8, k: int = 4, device_aware: bool = False): |
| 190 self.p = p |
| 191 self.k = k |
| 192 self.device_aware = device_aware |
| 193 self._len = len(dataset) // (p * k) |
| 194 |
| 195 self.label_to_indices: dict[int, list[int]] = defaultdict(list) |
| 196 self.label_to_device_indices: dict[int, dict[str | None, list[int]]] = defaultdict(lambda: defaultdict(list)) |
| 197 for idx, label in enumerate(dataset.labels): |
| 198 self.label_to_indices[label].append(idx) |
| 199 self.label_to_device_indices[label][dataset.devices[idx]].append(idx) |
| 200 |
| 201 self.labels = sorted(self.label_to_indices.keys()) |
| 202 |
| 203 def _sample_indices(self, label: int) -> list[int]: |
| 204 indices = self.label_to_indices[label] |
| 205 if not self.device_aware: |
| 206 return ( |
| 207 random.sample(indices, self.k) |
| 208 if len(indices) >= self.k |
| 209 else random.choices(indices, k=self.k) |
| 210 ) |
| 211 |
| 212 by_device = self.label_to_device_indices[label] |
| 213 distinct_devices = [dev for dev in by_device if dev is not None] |
| 214 if len(distinct_devices) <= 1: |
| 215 return ( |
| 216 random.sample(indices, self.k) |
| 217 if len(indices) >= self.k |
| 218 else random.choices(indices, k=self.k) |
| 219 ) |
| 220 |
| 221 chosen: list[int] = [] |
| 222 device_keys = distinct_devices.copy() |
| 223 random.shuffle(device_keys) |
| 224 for dev in device_keys: |
| 225 if len(chosen) >= self.k: |
| 226 break |
| 227 chosen.append(random.choice(by_device[dev])) |
| 228 |
| 229 remaining_pool = [idx for idx in indices if idx not in chosen] |
| 230 needed = self.k - len(chosen) |
| 231 if needed > 0: |
| 232 if len(remaining_pool) >= needed: |
| 233 chosen.extend(random.sample(remaining_pool, needed)) |
| 234 else: |
| 235 chosen.extend(remaining_pool) |
| 236 if len(chosen) < self.k: |
| 237 chosen.extend(random.choices(indices, k=self.k - len(chosen))) |
| 238 |
| 239 return chosen |
| 240 |
| 241 def __iter__(self): |
| 242 pool = self.labels.copy() |
| 243 random.shuffle(pool) |
| 244 ptr = 0 |
| 245 |
| 246 for _ in range(self._len): |
| 247 if ptr + self.p > len(pool): |
| 248 pool = self.labels.copy() |
| 249 random.shuffle(pool) |
| 250 ptr = 0 |
| 251 |
| 252 batch_labels = pool[ptr:ptr + self.p] |
| 253 ptr += self.p |
| 254 |
| 255 batch: list[int] = [] |
| 256 for lbl in batch_labels: |
| 257 batch.extend(self._sample_indices(lbl)) |
| 258 yield batch |
| 259 |
| 260 def __len__(self) -> int: |
| 261 return max(1, self._len) |
|
|
