=== 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)