| # SIFQ — Giải thích toàn bộ Research & Mapping vào Code |
|
|
| > Tài liệu này đọc song song với `sifq_pdf.txt` và source code trong `src/`. |
| > Mỗi khái niệm trong paper đều có pointer đến file code tương ứng. |
| |
| --- |
| |
| ## 1. Vấn đề SIFQ giải quyết |
| |
| ### NFIQ2 có 3 nhược điểm lớn |
| |
| **Nhược điểm 1 — Matcher cũ làm target:** |
| NFIQ2 train supervised với target là match score của VeriFinger (minutiae-based, ~2010). Khi matcher hiện đại như MDGT/DINOv2 đánh giá ảnh khác, quality score không còn tương quan. |
| |
| **Nhược điểm 2 — Feature thiên về optical sensor:** |
| 5 feature tay của NFIQ2 (OCL, LCS, FDA, RVU, OFL) thiết kế cho contact optical. Fingerprint contactless hoặc flat press sẽ có Q thấp dù matcher hiện đại match được. |
| |
| **Nhược điểm 3 — Sensor bias:** |
| Cùng một ngón tay chụp bằng 2 sensor khác nhau → NFIQ2 cho 2 điểm chênh nhau 20–30 đơn vị. Metric đang đo sensor signature thay vì biometric quality thực sự. |
| |
| ### SIFQ giải quyết bằng cách nào? |
| |
| Thay vì dùng matcher score làm label, SIFQ dùng **3 tín hiệu tự giám sát bổ trợ nhau**: |
| |
| | Signal | Vai trò | Ràng buộc | |
| |--------|---------|-----------| |
| | `L_mat` — Matcher-as-teacher | Q phải tương quan với embedding quality của MDGT | Task-relevant | |
| | `L_sens` — Cross-sensor invariance | Q phải giống nhau cho cùng ngón tay ở 2 sensor khác nhau | Sensor-invariant | |
| | `L_deg` — Controlled degradation | Q phải giảm khi ảnh bị degraded (blur, noise, occlusion...) | Ordinal grounding | |
|
|
| Ba tín hiệu tạo **equilibrium**: Q không thể chỉ distill MDGT (vì L_sens ngăn sensor bias), không thể chỉ đo sensor difference (vì L_deg buộc phải predict degradation order), không thể chỉ rank degradation synthetic (vì L_mat kéo về matcher reality). |
| |
| **Điểm cân bằng duy nhất là Q đo đúng biometric quality thực sự.** Bảng dưới cho thấy nếu thiếu bất kỳ signal nào: |
| |
| | Nếu chỉ có... | Thì model sẽ... | |
| |--------------|----------------| |
| | Chỉ `L_mat` | Distill MDGT → không sensor-invariant | |
| | Chỉ `L_sens` | Cho tất cả ảnh cùng score → L_pair = 0 dễ dàng | |
| | Chỉ `L_deg` | Học ranking degradation synthetic, không transfer sang ảnh real | |
| | `L_mat + L_sens` | Không có ordinal grounding → score không có ý nghĩa tuyệt đối | |
| | `L_sens + L_deg` | Không liên kết với matcher reality | |
|
|
| **⚠️ Bài học từ v15–v19 (score collapse):** |
| Ngoài việc cần đủ 3 signal, còn cần đảm bảo: |
| 1. **`L_mat` cần per-image quality gradient thực sự**: Raw cosine với multi-sensor prototype |
| (proto_max_batches=0) → cosine varies with quality, not sensor. Partial prototype |
| (proto_max=150) → cosine bị sensor-bias → không phân biệt quality → collapse. |
| 2. **`L_deg` phải áp dụng cho SD302 chứ không chỉ FVC**: FVC-only L_deg → model học |
| quality function cho FVC nhưng SD302 không có per-image signal → SD302 collapse ở inference. |
| L_spread_ds (per-dataset spread, T27) ngăn score anchoring → an toàn để bật L_deg full cho SD302. |
| 3. **`L_spread_ds` là batch-level, không đủ**: Batch spread thỏa mãn bằng arbitrary ordering, |
| không phải quality. Phải kết hợp với per-image signal từ L_mat + L_deg. |
| |
| --- |
| |
| ## 2. Kiến trúc — 4 Components |
| |
| ``` |
| Image [B,1,224,224] |
| │ |
| ▼ |
| ┌────────────┐ |
| │ Backbone │ TinyViT-5M, grayscale |
| │ TinyViT │ forward_spatial() → [B,196,320] |
| └────────────┘ |
| │ |
| ├── mean(dim=1) → [B, 320] features ──────────────────────────┐ |
| │ │ |
| │ (SpatialConceptHead path: [B,196,320]) ▼ |
| ▼ (ConceptHead legacy: mean-pool → [B,320]) ┌──────────────────┐ |
| ┌──────────────────┐ │ SensorDisc │ |
| │ ConceptHead / │ [B,?]→ … →[B,6] ∈ [0,1] │ GRL(λ) → │ |
| │ SpatialConcept │ see §2.2 for both variants │ [B,64]→[B,Ns] │ |
| └──────────────────┘ └──────────────────┘ |
| │ concepts [B, 6] │ sensor_logits |
| ▼ ▼ |
| ┌──────────────────┐ adversarial sensor loss |
| │ ScoreAggregator │ [B,6]→[B,32]→[B,1]→Sigmoid→×100 |
| └──────────────────┘ |
| │ Q [B,1] ∈ [0, 100] |
| |
| outputs = { "score": Q, "concepts": C, "sensor_logits": S, "features": F } |
| ``` |
| |
| --- |
| |
| ### 2.1 Backbone — `src/models/backbone.py` |
| |
| | | | |
| |---|---| |
| | **Model** | `timm: tiny_vit_5m_224.dist_in22k` | |
| | **Input** | `[B, 1, 224, 224]` — grayscale | |
| | **Output** | `[B, 320]` — global average of spatial tokens | |
| |
| `forward_spatial()` extracts 14×14 token features → mean pool → `[B, 320]`. |
| |
| - TinyViT-5M (not 2M): 2M insufficient capacity for 3 simultaneous losses |
| - Not shared with MDGT: avoids circular dependency; on-sensor deployment target (<50ms ARM Cortex-A72) |
| |
| --- |
| |
| ### 2.2 Concept Head — `src/models/concept_head.py` |
| |
| Two implementations exist. The active version depends on the training flag: |
| |
| **`ConceptHead` (legacy — v16–v26, default `--spatial-concept-head` not set):** |
| ``` |
| Input: [B, 320] — globally-pooled backbone output |
| Linear(320→256) → LayerNorm → GELU → Linear(256→6) → Sigmoid |
| Output: [B, 6], each concept ∈ [0, 1] (high = better quality) |
| ``` |
| Loses all spatial structure before concept prediction. |
| |
| **`SpatialConceptHead` (v27+, enabled via `--spatial-concept-head`):** |
| ``` |
| Input: [B, 196, 320] — backbone.forward_spatial() (14×14 token map) |
| Shared trunk : Linear(320→128) → LayerNorm → GELU → [B, 196, 128] |
| Per-concept : 6 × Linear(128→1) → mean(dim=1) → [B, 6] |
| Activation : Sigmoid → [B, 6] ∈ (0, 1) |
| ``` |
| Each concept projection learns which spatial regions matter (ridge breaks for |
| `continuity`, orientation edges for `orientation_coherence`, bifurcation patches |
| for `minutiae_reliability`). Separate weights per concept reduce entanglement. |
| |
| `SIFQ.forward()` auto-dispatches via `concept_head.uses_spatial` attribute — |
| backward-compatible with all existing checkpoints. |
| |
| **6 concepts (all decrease with degradation — T25):** |
|
|
| | Idx | Name | Meaning | Supervised by | |
| |-----|------|---------|---------------| |
| | 0 | `orientation_coherence` | Ridge flow consistency | dry_skin, wet_press (T39) | |
| | 1 | `ridge_valley_clarity` | Sharp ridge-valley boundaries | blur, jpeg, wet_press, **noise (T42)** | |
| | 2 | `continuity` | Unbroken ridge lines | blur, jpeg | |
| | 3 | `noise_level` | Low noise (↑ = cleaner — T25) | noise | |
| | 4 | `contrast_uniformity` | Even foreground contrast | dry_skin | |
| | 5 | `minutiae_reliability` | Reliable minutiae extraction | occlusion, wet_press | |
| |
| **T42 changes (v32):** |
| - `continuity[2]` removed from `dry_skin`: dry_skin causes ridge fragmentation — at TinyViT patch scale (16×16 px) this looks identical to Gaussian noise texture (both = local high-frequency disruptions). When concept[2] is pulled down by dry_skin, concept[3] (noise_level) follows via shared feature paths → spurious crosstalk (v31 Spearman −0.758). Fix: dry_skin supervised by `contrast[4] + orientation[0]` only — these operate at multi-patch/regional scale, not shared with noise. |
| - `clarity[1]` added to `noise`: TinyViT 16×16 patch embed averages out pixel Gaussian noise (σ=5–30) → concept[3] receives almost no gradient signal from noise alone (v31: noise→noise_level ρ = −0.081). Gaussian noise blurs ridge-valley boundaries at patch scale — clarity[1] detects this → strong ViT signal → provides gradient that reinforces concept[3] in the correct direction. |
| |
| Concepts are not required to be independent — blur reducing both clarity and continuity is physically correct. `L_ortho` only prevents extreme redundancy. |
|
|
| --- |
|
|
| ### 2.3 Score Aggregator — `src/models/aggregator.py` |
|
|
| ``` |
| Linear(6→32) → GELU → Linear(32→1) → Sigmoid → ×100 |
| Output: [B, 1] ∈ [0, 100] (NFIQ2-compatible scale) |
| ``` |
|
|
| `Q(x) = Aggregator(concepts(backbone(x)))` |
|
|
| > **Important:** `outputs["score"]` is already in [0, 100]. Do not multiply by 100 again. Old bug did this → loss thresholds were off by 10×. |
|
|
| --- |
|
|
| ### 2.4 Sensor Discriminator — `src/models/sensor_discriminator.py` |
| |
| ``` |
| GRL(λ) → Linear(320→64) → ReLU → Linear(64→N_sensors) |
| ``` |
| |
| **Gradient Reversal Layer** (`src/models/grad_reverse.py`): |
| - Forward: `f(x) = x` |
| - Backward: `∂L/∂x → −λ · ∂L/∂x` |
| |
| The discriminator is trained to classify sensor identity. GRL forces the backbone to produce features the discriminator *cannot* distinguish → backbone sheds sensor signature. |
| |
| > **TODO:** Paper specifies discriminator should receive intermediate concept-branch features, not raw backbone features. Currently uses backbone output. Not yet implemented. |
| |
| --- |
| |
| ## 3. Ba Loss Functions |
| |
| ### 3.1 `L_mat` — Matcher-as-Teacher |
| |
| **File:** `src/losses/matcher_teacher.py` |
| **Teacher model:** `src/training/mdgt_teacher.py` — load từ `pad/TRAM-downstream/checkpoint/checkpoints_dinov2_tram/best_eer.pt` (DINOv2 ViT-S/14, frozen hoàn toàn) |
| |
| **Công thức:** |
| |
| $$q_{mat}(x) = \frac{\cos(\text{MDGT}(x),\ c_y) - \mu_y}{\sigma_y}$$ |
| |
| $$L_{mat} = \text{Huber}(Q_{normalized}(x),\ q_{mat}(x))$$ |
| |
| Trong đó: |
| - $c_y$ = prototype của identity $y$ (trung bình L2-normalized embeddings) |
| - $\mu_y, \sigma_y$ = mean/std cosine similarity trong class $y$ |
| - $Q_{normalized} = (Q/100 - 0.5) \times 2$ — đưa [0,100] về xấp xỉ [-1, 1] |
| |
| **Code mapping:** |
| |
| ```python |
| # Compute prototype: trung bình embeddings per identity |
| proto = F.normalize(stack(emb_list).mean(0), dim=-1) |
| |
| # v16 (T31): compute per-identity cosine stats (second pass, frozen teacher) |
| # stats[identity] = (mean_cos, std_cos) — min_sigma = 0.02 |
| stats = compute_identity_cos_stats(loss_mat, prototypes, proto_loader, device) |
| |
| # q_mat: cosine similarity normalize per-identity, clamp bằng tanh |
| cos = dot(emb[i], proto[identity_id]) |
| z = (cos − mu_i) / sigma_i |
| q_mat[i] = tanh(z) # ∈ (−1, 1), zero-centred |
|
|
| # Loss |
| pred_normalized = (score / 100.0 - 0.5) * 2.0 |
| return HuberLoss(pred_normalized, q_mat) |
| ``` |
| |
| **Vấn đề v15 (stats=None):** Raw cosine ≈ 0.85 cho mọi ảnh → teacher kéo tất cả score về 92.5, conflict với L_spread → score collapse. Xem TODO T31. |
|
|
| **v16 fix (T31):** Per-identity stats normalization + tanh → teacher target zero-centred, tương thích L_spread. Ảnh tốt hơn trung bình identity → target > 0 → Q > 50. Ảnh kém hơn → target < 0 → Q < 50. |
| |
| **v18 revert (T33a — `--no-mat-stats`):** Skip per-identity cosine stats hoàn toàn. Tất cả images (FVC + SD302) đều dùng raw cosine làm L_mat target → không còn FVC/SD302 quality signal asymmetry. Root cause v17: FVC images có stable per-image tanh targets (từ FVC-only stats) nhưng SD302 images chỉ có raw cosine constant ≈ 0.85 → model học shortcut "FVC=variable quality, SD302=fixed quality ~52.7" → GRL + L_pair triệt tiêu SD302 quality features vì không có L_mat gradient để duy trì chúng. Revert về v14 design: tất cả images dùng raw cosine → L_mat chỉ còn tác dụng anchor mean (không gây asymmetry). |
| |
| --- |
| |
| ### 3.2 `L_sens` — Cross-Sensor Invariance |
|
|
| **File:** `src/losses/sensor_invariance.py` |
|
|
| **Công thức:** |
|
|
| $$L_{pair} = \max(0,\ |Q(x_{s1}) - Q(x_{s2})| - \delta)$$ |
| |
| $$L_{adv} = -\log D(\text{sensor} \mid f(x))$$ |
|
|
| $$L_{sens} = L_{pair} + \lambda_{adv} \cdot \min(L_{adv},\ \ln N_{sensors})$$ |
| |
| Với $\delta = 0.05$, $\lambda_{adv} = 0.3$. Clamp $\min(L_{adv}, \ln N)$ ngăn GRL anti-correlation (T16). |
| |
| **Code mapping (v11 — GRL anti-correlation fix):** |
| |
| ```python |
| # Pairs: cùng identity_id + finger_id, khác sensor_id (built trong batch) |
| l_pair = relu((score_s1 - score_s2).abs() - 0.05).mean() |
| |
| # Adversarial: backbone phải fool sensor discriminator |
| l_adv = cross_entropy(sensor_logits, sensor_labels) |
| |
| # GRL anti-correlation fix (T16): clamp l_adv tại random-guess baseline. |
| # Nếu CE > log(num_sensors): backbone đã đủ confuse discriminator, dừng |
| # gradient reversal — tránh việc backbone học anti-encode sensor identity. |
| rand_ce = log(sensor_logits.size(1)) # log(32) ≈ 3.47 |
| l_adv_clamped = l_adv.clamp(max=rand_ce) |
| |
| # Returns (total, l_pair_detached, l_adv_detached) for diagnostics |
| return l_pair + 0.3 * l_adv_clamped, l_pair.detach(), l_adv.detach() |
| ``` |
| |
| **Quan sát v11 trước khi fix (T16):** `l_adv` dao động 7–16 trong S2–S4, gấp 2–4× random baseline log(32)≈3.47. Diễn giải: backbone không chỉ "mờ" sensor mà học predict sai sensor với high confidence (anti-correlation). Discriminator thích ngưỡc lại → cái cycle không dừng. Clamp ngăn vòng lặp này. |
| |
| **Pair building — `train_sifq.py::build_pair_indices()`:** |
| Group batch theo `(identity_id, finger_id)` → tất cả cặp khác sensor_id trong cùng group. |
| |
| **Quan hệ giữa `L_pair` và `L_adv` — hai cơ chế bổ trợ:** |
| |
| | | `L_pair` | `L_adv` (GRL) | |
| |--|---------|---------------| |
| | Ép ở tầng nào | **Output** — Q score phải bằng nhau | **Feature space** — backbone không được encode sensor info | |
| | Cách hoạt động | Hinge loss trực tiếp trên Q | Gradient reversal qua discriminator | |
| | Tại sao cần cả 2 | Chỉ ép output: backbone vẫn giữ sensor info ẩn trong features | Chỉ ép feature: Q vẫn có thể tái encode sensor qua concept head | |
| |
| **Dataset novelty:** SIFQ là method đầu tiên đưa explicit invariance constraint vào quality learning. NFIQ2 không có mechanism này. |
| |
| --- |
| |
| ### 3.3 `L_deg` — Controlled Degradation Ranking |
| |
| **File:** `src/losses/degradation_ranking.py` |
| **Pipeline:** `src/data/degradation.py` |
| |
| **Công thức:** |
| |
| $$L_{rank} = \max(0,\ Q(x_{high}) - Q(x_{low}) + m) + \max(0,\ Q(x_{low}) - Q(x_{clean}) + m)$$ |
| |
| $$L_{concept\_deg} = \sum_{(deg, c_{target})} \text{Huber}(c_{target}(x_{low}),\ c_{target}(x_{high}) + 0.1)$$ |
| |
| $$L_{deg} = L_{rank} + \gamma \cdot L_{concept\_deg}$$ |
| |
| Với $m=0.1$ (ranking margin), $\gamma=0.5$. |
| |
| **Degradation concept map (index) — T42 (v32) — current:** |
| |
| ```python |
| DEGRADATION_CONCEPT_MAP = { |
| "blur": [1, 2], # clarity↓, continuity↓ |
| "noise": [1, 3], # clarity↓ (T42 co-target), noise_level↓ |
| "jpeg": [2, 1], # continuity↓, clarity↓ |
| "occlusion": [5], # minutiae_reliability↓ only ← T38: reverted from [5,2] to paper |
| "dry_skin": [4, 0], # contrast_uniformity↓, orientation_coherence↓ ← T42: removed continuity |
| "wet_press": [1, 5, 0], # clarity↓, minutiae_reliability↓, orientation_coherence↓ (T39) |
| } |
| ``` |
| |
| **T42 physical reasoning (v32):** |
|
|
| | Change | Before | After | Physical reason | |
| |--------|--------|-------|-----------------| |
| | `noise` | `[3]` | `[1, 3]` | TinyViT patch embed (16×16 px) averages out pixel Gaussian noise σ=5–30 → concept[3] gradient ≈ 0 alone. But noise **also blurs ridge-valley edges** at patch scale (clarity[1]) → ViT detects this → provides training signal that anchors concept[3] in the correct direction. v31: noise→noise_level ρ = −0.081 (very weak). | |
| | `dry_skin` | `[4, 2, 0]` | `[4, 0]` | `continuity[2]` operates at **local patch scale** — same as Gaussian noise texture. dry_skin ridge fragmentation and pixel noise both create "high-frequency local disruptions" in 16×16 patches → shared backbone feature path → when concept[2] is pulled ↓ by dry_skin, concept[3] follows → spurious crosstalk (v31: dry_skin→noise_level ρ = −0.758). Removing continuity forces backbone to use `contrast[4]` (regional brightness gradient) + `orientation[0]` (multi-patch coherence field) — both are **regional-scale** features, not shared with noise. | |
|
|
| **T38 fix — wet_press `[1, 4]` → `[1, 5]` (reverted to paper design):** |
| |
| Root cause: `MorphologicalDilator` used a fixed 3×3 kernel — at 500 DPI, 1 erode iteration = ~1 px ridge expansion, too subtle. Model read level 1 as "good ink coverage" → `minutiae_reliability(level_1) > level_0` → non-monotonic → ρ > 0 (wrong). Consistently wrong: v14 = +0.565, v20 = +0.246, v21 = +0.307. |
| |
| Fix: Scale kernel + blur with severity in `degradation.py`: `ks = 3 + 2*iterations` (5×5/7×7/9×9), `sigma = 1.0 + 0.8*iterations` (1.8/2.6/3.4). Level 1 now visibly impairs bifurcations. Concept map KEPT at `[1, 5]` as designed. |
| |
| **T38 fix — occlusion `[5, 2]` → `[5]` (reverted to paper design) + coverage 55% → 40%:** |
|
|
| T26 added `continuity[2]` because occlusion signal was near-zero, and pushed coverage to 55%. Root cause of weak signal was actually the **unseeded random block positions in eval** — different levels placed blocks in different spots → Spearman ρ incoherent. Now fixed by `np.random.seed(level)` in `compute_crosstalk_matrix` (T38b). With deterministic eval, `[5]` alone provides a clean signal. Coverage reverted to paper range: `0.133 × level` → level 3 = 40% max. |
|
|
| **Note**: Training occlusion still uses random positions (generalization). Only eval is seeded. |
|
|
| **T30 (v15): SD302 concept-only L_deg** — Root cause regression v14: concept head chỉ thấy FVC texture khi bị degraded; eval trên SD302 images thất bại (noise→noise_level: -0.019). |
| - **T30a**: `concept_deg_gamma 0.5 → 2.0` — L_concept 4× mạnh hơn so với L_rank |
| - **T30b**: Apply degradation cho SD302 batch items, chỉ compute L_concept (không L_rank → không score collapse). Lần đầu tiên concept head thấy degraded SD302. |
| - **T30c**: `deg-every-n-steps 2` (giảm từ default 4, giới hạn bởi OOM: 3 forward pass/step với batch=64) |
| |
| **DegradationPipeline — 6 loại, 4 levels (0=clean, 1–3 tăng dần):** |
|
|
| | Type | Kỹ thuật | Severity range | |
| |------|---------|----------------| |
| | `blur` | GaussianBlur kernel $k = 2\lfloor 0.5 + level \times 0.83 \rfloor + 1$ | σ tăng theo level | |
| | `noise` | Additive Gaussian, $\sigma = 5 + level \times 8.3$ | 5→30 | |
| | `jpeg` | JPEG compression quality = $90 - level \times 25$ | 90→15 | |
| | `occlusion` | White block $= 13.3\% \times level$ coverage | 13%→40% | |
| | `dry_skin` | `DrySkinSimulator`: contrast reduce + crack lines | severity 1→3 | |
| | `wet_press` | `MorphologicalDilator`: kernel scales 5×5/7×7/9×9, sigma 1.8/2.6/3.4 | levels 1→3 | |
|
|
| **Code trong training loop (v6 fix):** |
|
|
| ```python |
| # Random sample 1 trong 6 types mỗi deg step |
| deg_type = random.choice(_DEG_TYPES) |
| level_lo = random.randint(1, 2) |
| level_hi = 3 |
| |
| # Tensor [B,1,H,W] float[0,1] → numpy [B,H,W] uint8 |
| imgs_np = (images[:,0].cpu().numpy() * 255).astype(np.uint8) |
| |
| # Apply degradation per image |
| imgs_low = stack([deg_pipeline.apply(img, deg_type, level_lo) for img in imgs_np]) |
| imgs_high = stack([deg_pipeline.apply(img, deg_type, level_hi) for img in imgs_np]) |
| |
| # Forward pass qua model |
| out_low = model(imgs_low_tensor) |
| out_high = model(imgs_high_tensor) |
| |
| l_deg = loss_deg(score_clean, out_low["score"], out_high["score"], |
| out_low["concepts"], out_high["concepts"], deg_type) |
| ``` |
|
|
| **Tất cả concepts GIẢM khi degradation tăng (v13 — T25 fix):** |
|
|
| ```python |
| # T25: Bỏ if c_idx == 3 special case. |
| # Tất cả concepts: high = better quality, low = worse quality. |
| # noise_level mới: high = ít nhiễu = tốt (ngược v12) |
| for c_idx in DEGRADATION_CONCEPT_MAP[deg_type]: |
| l_concept += huber(concepts_low[:, c_idx], concepts_high[:, c_idx] + 0.1) |
| # concepts_low[c] > concepts_high[c] + 0.1 |
| # → more degraded image has lower concept score |
| ``` |
|
|
| **Trước v13 (v12, BUG):** `noise_level` được push tăng theo degradation level. ScoreAggregator resolve conflict bằng cách invert direction → noise_level=-0.168 (Track 4, sai chiều). |
| |
| --- |
| |
| ### 3.4 `L_ortho` — Concept Decorrelation |
|
|
| **File:** `src/losses/orthogonality.py` |
|
|
| $$L_{ortho} = \| \text{off\_diag}(\text{corrcoef}(C)) \|_F^2$$ |
| |
| ```python |
| # Standardize per concept (zero-mean, unit-std across batch) |
| x = concepts - concepts.mean(dim=0, keepdim=True) |
| x = x / (x.std(dim=0, keepdim=True) + 1e-6) |
| corr = (x.T @ x) / max(1, x.shape[0] - 1) # [6, 6] Pearson corr |
| off_diag = corr - eye(6) |
| return (off_diag ** 2).sum() # Frobenius² of off-diagonal |
| ``` |
| |
| Regularize để concepts không hoàn toàn redundant. Không có weight — luôn cộng thẳng vào total loss. |
| |
| --- |
| |
| ### 3.5 Spread Loss (Uniformity) — thêm vào trong training loop |
| |
| **Không có file riêng** — implement trực tiếp trong `scripts/train_sifq.py`. |
|
|
| ```python |
| # uniform mode (v8 default) — force sorted Q-scores → linspace(10, 90) |
| q_sorted, _ = q_batch.sort() |
| target_unif = torch.linspace(10.0, 90.0, n_q, device=device) |
| l_spread = F.mse_loss(q_sorted / 100.0, target_unif / 100.0) |
| # Gradient ép trực tiếp phân bố score: ảnh tốt nhất → 90, xấu nhất → 10 |
| ``` |
|
|
| Weight lịch sử: v15 = 2.0 → v16/v17 = 4.0 → **v18 revert 2.0 (T33b)** → **v21 = 3.0** (`--spread-weight 3.0`). Default code = 4.0. W_SPREAD áp dụng cho **CẢ HAI** `L_spread_global` và `L_spread_sd302`. |
| |
| **Thay thế variance mode của v7** (`relu(10/100 - q_std/100)^2`, max=0.01) vốn bị bão hòa ngay từ đầu (spread=0.010 stuck toàn bộ training). |
|
|
| **v18 (T33b):** W_SPREAD revert về 2.0. W_SPREAD=4.0 cùng với gamma=2.0 làm tệ hơn v14 trong v15–v17. |
|
|
| **v21:** W_SPREAD=3.0 — trung dung giữa v14 (2.0) và v16/v17 (4.0), kết hợp với `--proto-max-batches 0` (full prototypes) và FVC-only L_deg. |
|
|
| --- |
|
|
| ### 3.6 Total Loss |
|
|
| $$L(t) = \alpha(t) \cdot L_{mat} + \beta(t) \cdot L_{sens} + \gamma(t) \cdot L_{deg} + L_{ortho} + w_{spread} \cdot (L_{spread} + L_{spread\_sd302})$$ |
|
|
| Trong đó: |
| - $L_{spread}$: MSE toàn batch (sorted Q → linspace(10,90)) |
| - $L_{spread\_sd302}$: MSE chỉ SD302 subset trong batch (≥8 ảnh) — ép SD302 spread riêng, tránh SD302 dùng FVC variation để thỏa spread (T27) |
| - $w_{spread}$ = 3.0 (v21) — áp cho **cả hai** thành phần spread |
|
|
| --- |
|
|
| ## 4. Training Stage Scheduler |
|
|
| **File:** `src/training/stage_scheduler.py` |
|
|
| | Stage | Epochs | α (mat) | β (sens) | γ (deg) | β/α | Mục đích | |
| |-------|--------|---------|----------|---------|-----|----------| |
| | S1 | 0–9 | 0.10 | **0.00** | 1.00 | 0 | Bootstrap quality ordering từ degradation | |
| | S1→S2 ramp | 10–19 | **0.10→0.28** | **0.00→0.27** | **1.00→0.64** | 0→0.96 | β ramps NHANH HƠN α — β/α → 1.0 ở S2 entry | |
| | S2 | 20–34 | 0.30 | 0.30 | 0.60 | **1.0** | Balanced: GRL pressure = mat pressure | |
| | S2→S3 ramp | 35–39 | **0.30→0.29** | **0.30→0.34** | **0.60→0.52** | >1.0 | β vượt α smooth | |
| | S3 + S4 | 40+ | 0.25 | 0.35 | **0.50** | **1.4** | β > α, γ floor = 0.50 | |
|
|
| > **v21 chạy 60 epochs** → S3 kết thúc ở ep59. S4 (ep60+) không được sử dụng. Code scheduler dùng `(40, 999)` làm sentinel nên logic không thay đổi — chỉ số epoch thực tế bị cắt ngắn bởi `--epochs 60`. |
|
|
| **GRL λ warm-up (DANN schedule):** |
|
|
| $$\lambda(p) = \min\!\left(0.6,\ \frac{2}{1+e^{-10p}}-1\right), \quad p = \frac{\text{epoch}}{\text{total\_epochs}}$$ |
| |
| - ep0: λ=0.000 |
| - ep10: λ=0.555 |
| - ep12+: λ=0.600 (cạn max) |
| |
| **Cosine LR decay (v8 mới):** LR decay từ 1e-4 → 5e-6 theo cosine. Trước với LR cố định → S4 oscillation (v7: loss tăng từ 0.53 lên 1.18 trong ep61-80). |
| |
| **Vì sao β/α phải = 1.0 ngay từ S2 (v11 vs v9):** |
| V9 bug: β/α = 0.50 trong S2 (α=0.40, β=0.20). PolyU contact vs contactless là cross-modality pairs cực mạnh — GRL với β quá thấp không đủ mạnh để override L_mat pressure, backbone vẫn encode sensor/modality signature. Kết quả: L_sens oscillate 2–3 suốt S2/S3. V11: β ramps nhanh hơn α (β Δ0.30 vs α Δ0.20 qua 10 epoch) → β/α = 1.0 NGAY KHI vào S2. GRL và L_mat có sức nặng bằng nhau từ đầu. |
| **PolyU treatment (v11):** PolyU chỉ góp vào L_sens. L_mat và L_deg mask out PolyU records (không compute prototype, không apply degradation cho PolyU images). |
| |
| **Vì sao β entry ramp quan trọng (v8 vs v7):** |
| V7: β nhảy 0→0.20 đột ngột tại ep10 → L_sens explosion: 0.77 (ep10) → 11.32 (ep18), mất 20 epoch phục hồi. |
|
|
| **Vì sao γ floor = 0.50 (v8/v9) thay vì 0.40 (v7):** |
| V7: L_deg plateau tại 0.104 từ ep43+ — chính xác bằng margin m=0.10. γ=0.50 giữ grounding mạnh hơn. |
| |
| --- |
| |
| ## 5. Dataset Pipeline |
| |
| **Files:** `src/data/nist302_loader.py`, `src/data/fvc_loader.py` |
| |
| ``` |
| dataset/ |
| ├── 302a/images/challengers/ → sensors: A, B, C, D, E, F, G, H (8 sensors) |
| │ └── A/roll/png/ filename: {subject}_{sensor}_{captype}_{finger}.png (4 tokens) |
| ├── 302b/images/baseline/ → sensors: R_500, S_500, U_500, V_500 (4 sensors) |
| │ └── U/500/roll/png/ filename: {subject}_{sensor}_{dpi}_{captype}_{finger}.png (5 tokens) |
| ├── nist_302d/images/auxiliary/ → sensors: flat_K, flat_L, flat_M, flat_P (4 sensors) |
| └── FVC_Dataset/ |
| ├── FVC2002/Dbs/Db1_a|Db2_a... filename: {subject}_{impression}.tif |
| └── FVC2004/Dbs/DB1_A|DB2_A... |
| ``` |
| |
| **Đầy đủ sau khi fix: 37,607 ảnh, 22 sensors** |
|
|
| | Dataset | Ảnh | Sensors | Role | Signal | |
| |---------|------|---------|------|--------| |
| | SD302-A (302a) | 13,630 | A–H (8) | Cross-sensor invariance | L_sens, L_mat | |
| | SD302-B (302b) | 11,796 | R,S,U,V (4) | Cross-sensor invariance | L_sens, L_mat | |
| | SD302-D (302d) | 5,141 | K,L,M,P (4) | Cross-sensor invariance | L_sens, L_mat | |
| | FVC2002 | 3,520 | 4 DBs | Matcher-teacher quality anchor | L_mat, L_deg | |
| | FVC2004 | 3,520 | 4 DBs | Matcher-teacher quality anchor | L_mat, L_deg | |
| | PolyU (contact) | 2,976 | 1 (polyu_contact) | Cross-modality hardest invariance | **L_sens ONLY** | |
| | PolyU (contactless) | 2,976 | 1 (polyu_contactless) | Cross-modality hardest invariance | **L_sens ONLY** | |
| |
| |
| > **† Lưu ý cột `noise_level`**: Giá trị theo hướng **model concept[3]**: `Cao` = ít nhiễu = ảnh sạch = tốt (ngược chiều với lượng noise vật lý trong ảnh). Bảng gốc dùng hướng image-domain (Thấp noise=sạch=tốt), nhưng đã được đổi sang hướng concept để nhất quán với kỳ vọng model output. Ví dụ: SD302a rất sạch → concept[3] dự kiến = `Cao`; FVC2004 DB3 nhiều noise → concept[3] dự kiến = `Thấp`. |
|
|
| **Tổng v11: 43,559 ảnh, 24 sensors, 2,612 eligible cross-sensor anchor groups** |
|
|
| **Tổng v14: 42,683 ảnh, 29 sensors** (sau khi loại `R_1000_slap`, `R_500_slap`, `S_500_slap` — ~1,700 non-segmented slap records). Anchor groups: 2,336 eligible. |
|
|
| **PolyU Cross-Fingerprint Database (v9+):** |
| 336 subjects × 6 impressions × 2 modalities = 5,952 ảnh. Cùng ngón tay được chụp bằng CMOS camera (contactless) và URU sensor (contact). Đây là cross-modality pairs mạnh nhất cho L_sens — harder invariance target so với cross-brand sensors trong SD302. File: `src/data/polyu_loader.py`. |
|
|
| **Tại sao SD302 không góp vào L_deg:** |
| SD302 toàn ảnh chất lượng cao (protocol NIST ảnh cần đạt chuẩn). Degradation synthetic trên nó là giả tạo, không phản ánh quality variation thực. FVC có 8 lần chụp cùng ngón tay với **chất lượng tự nhiên dao động** → MDGT xếp hạng thực sự giữa các impression → L_deg có signal vật lý. Thiết kế tách biệt vai trò: SD302 = sensor role, FVC = quality role. |
| |
| **Tại sao FVC cần thiết cho L_mat:** |
| SD302 chỉ có ảnh chất lượng cao → q_mat ≈ constant → L_mat tầm thường. FVC có 8 lần chụp cùng ngón tay (chất lượng thực sự dao động) → MDGT có thể xếp hạng các lần chụp trong cùng subject → q_mat có signal thực sự. |
|
|
| **Metadata parsing:** |
|
|
| | Filename format | Tokens | identity_id | finger_id | sensor_id | |
| |----------------|--------|-------------|-----------|----------| |
| | SD302-A: `00002303_A_roll_05.png` | 4 | `00002303` (stem[0]) | `F05` (stem[-1]) | path-based `A_roll_png` | |
| | SD302-B/D: `00002401_U_500_roll_07.png` | 5 | `00002401` | `F07` | `U_500_roll` | |
| | FVC: `042_3.tif` | 2 | `2002_db1_0042` | `f01` | `fvc2002_db1` | |
|
|
| **Audit kết quả (kiểm tra thực tế):** |
|
|
| - **Finger ID nhất quán across sensors ✅**: 2,000 (subject, finger) pairs xuất hiện ở ≥2 sensors trong cả 302a và 302b |
| - Ví dụ: subject `00002303`, finger `05` → xuất hiện ở cả 8 sensors A–H → cặp L_sens cực tốt |
| - 200 subjects xuất hiện trong cả 302b và 302d → cross-subset L_sens pairs |
| - FVC: mỗi subject có 1 ngón tay duy nhất (finger_id = `f01`) → không có cross-sensor pairs |
| |
| **Bug đã fix: 302a parser:** |
| Parser cũ yêu cầu `len(tokens) >= 5` nhưng 302a chỉ có 4 tokens → **13,630 ảnh bị bỏ hoàn toàn**. Đã sửa thành `>= 4`. Sensor_id từ path vẫn đúng (`A_roll_png`, `B_roll_png`...). |
|
|
| **Risk R1 (cập nhật):** Finger_id đã được xác nhận là nhất quán across sensors trong NIST SD302. Protocol NIST yêu cầu cùng ngón tay trình cho tất cả sensor → finger number có ý nghĩa vật lý. ✅ Không còn là risk. |
| |
| --- |
| |
| ## 6. Evaluation 5 Tracks |
| |
| ### Track 1 — Error Rejection Curve (Primary) |
| |
| **File:** `src/evaluation/erc.py` |
| |
| Sắp xếp ảnh theo Q tăng dần → reject bottom x% → compute FNMR tại FMR=1e-4 trên phần còn lại → plot curve. |
| |
| **AUC_ERC: thấp hơn = tốt hơn.** |
| |
| Kết quả v5: SIFQ=0.8884 vs Random=0.8937 → hơn Random 0.5% — quá yếu. |
| Kỳ vọng v6: L_deg hoạt động → ảnh degraded được score thấp hơn → reject đúng → FNMR giảm nhanh hơn. |
|
|
| --- |
|
|
| ### Track 2 — Sensor Invariance (Core novelty) |
|
|
| **File:** `src/evaluation/sensor_invariance.py` |
|
|
| **KS statistic** (Kolmogorov-Smirnov) giữa Q distributions của 2 sensors: `KS = 0` → giống hoàn toàn. |
|
|
| **Pearson correlation** giữa Q(x_s1) và Q(x_s2) cho paired samples: cao hơn = nhất quán hơn. |
|
|
| | Metric | v11 | v12 | v13 | v14 | v15 | v16 | v17 | v18 actual | v20 actual | **v21 target** | |
| |--------|-----|-----|-----|-----|-----|-----|-----|------------|------------|--------| |
| | mean_ks | 0.557 | 0.510 | 0.634 ❌ | **0.263 ✅** | 0.276 ❌ | 0.527 ❌ | 0.616 ❌ | **0.249 ⚠️** | **0.4936 ❌** | **≤0.27** | |
| | Pearson | — | -0.003 | +0.224 | **+0.294 ✅** | — | 0.046 ❌ | -0.002 ❌ | **0.007 ❌** | **0.0048 ❌** | **≥0.20** | |
| | q_std (inference) | — | — | — | ~15 | — | 0.33 ❌ | 0.60 ❌ | **0.01 ❌❌** | **0.007 ❌❌** | **>12** | |
| | n\_sensor\_pairs | 91 | 91 | 91 | 55 | 55 | 55 | **171** (302a added) | **171** | **171** | **≥100** (302a) | |
|
|
| > **v21 — 🚀 Active training** (T36 fix: full prototypes `--proto-max-batches 0` + FVC-only L_deg). Reasoning: v20 collapsed because `--deg-include-sd302` created a ~53.38 attractor; removing it restores the v14 mechanism where FVC genuine quality variation trains the backbone quality features that transfer to SD302 at inference. |
| **⚠️ v20 score collapse — KS misleading (same as v18 pattern)**: Training q_std≈18.3 (looks healthy) but inference q_std≈0.007. All sensors cluster near 53.38 (A_roll: std=0.007, range 53.364–53.403). Root cause: `--deg-include-sd302` applied L_rank to all clean SD302 images. L_rank only requires Q(clean)>Q(degraded), NOT that different clean images score differently → single ~53.38 attractor satisfies the constraint for all clean SD302. FVC-only signals (genuine quality variation) were blocked by this attractor. Fix: **v21 removes `--deg-include-sd302`**, keeps `--proto-max-batches 0`. |
| > **⚠️ v18 score collapse — KS misleading**: KS=0.249 vượt target "≤0.27" nhưng là **false positive** — tất cả sensors output score ≈54.64 (q_std≈0.01, range 54.62–54.65), phân bố trivially giống nhau vì model không phân biệt được images. Pearson=0.007 xác nhận: hoàn toàn không có cross-sensor ranking consistency. Root cause: T33 revert về raw cosine L_mat (constant ≈0.85 cho tất cả) + không có per-image quality signal → model collapse về trung bình ≈54.64. Concept head cũng collapse: orientation_coherence≈0.995 và noise_level≈0.982 stuck near 1.0; clarity≈0.032, continuity≈0.027, contrast≈0.04, minutiae≈0.027 stuck near 0. |
|
|
| **v13 regression trên KS**: Non-segmented slap sensors (`R_1000_slap`, `R_500_slap`, `S_500_slap`) tạo cụm score ~21.2 (std≈0) → kéo mean_KS lên 0.634. **Pearson cải thiện đáng kể** (+0.224 vs -0.003) — consistent relative ranking tốt hơn. |
| |
| **v14 fix**: Loại non-segmented slap khỏi training và eval (`--exclude-sensor R_1000_slap,R_500_slap,S_500_slap`). |
| |
| **v14 training actuals (60 epochs, from scratch):** |
| - `q_mean` = 52.6 (ep59) — centered tốt hơn v13 (~33 train-time) |
| - `q_std` = 15.5 (ep59) — plateau sau khi GRL equilibrium (peak S1 = 22.6 → drop về 14 khi β kick-in ep11) |
| - `l_pair` = 0.006 (ep59) — sensor invariance xuất sắc, gần bằng 0 |
| - `l_mat` = 0.270 — converged, giảm từ 0.378 (ep0) |
| - 3-phase dynamics: S1 (spread explosion ep0-10) → Transition (GRL compression ep11-15) → Equilibrium (stable ep16-59) |
|
|
| **v14 eval results:** mean_KS = **0.263** ✅ (giảm từ 0.634), Pearson = **+0.294** ✅ (tăng từ 0.224). |
| |
| **Đây là figure quan trọng nhất của paper.** Plot histogram Q per sensor — NFIQ2 expected các histogram tách biệt, SIFQ expected overlap cao. |
| |
| --- |
| |
| ### Track 4 — Concept Grounding (Interpretability claim) |
| |
| **File:** `src/evaluation/concept_grounding.py` |
|
|
|
|
| Sweep degradation level 0→3, tính Spearman ρ giữa level và concept score. |
|
|
| **Cross-talk matrix lý tưởng:** diagonal-heavy — mỗi degradation chỉ ảnh hưởng đến target concept của nó (Spearman ρ mạnh âm trên diagonal, gần 0 off-diagonal). |
|
|
| **Kết quả v13 (Spearman ρ):** |
|
|
| | degradation | orient. | clarity | continuity | noise_lvl | contrast | minutiae | |
| |-------------|---------|---------|-----------|-----------|----------|----------| |
| | **blur** | +0.19 | **-0.49** ✅ | -0.10 | +0.10 | +0.22 | +0.11 | |
| | **noise** | +0.05 | +0.46 | -0.12 | **-0.53** ✅ | -0.06 | -0.20 | |
| | **jpeg** | -0.11 | +0.03 | +0.03 | -0.08 | -0.04 | -0.02 | |
| | **occlusion** | +0.10 | -0.13 | -0.15 | +0.10 | -0.19 | **-0.09** ⚠️ | |
| | **dry_skin** | **-0.35** ✅ | +0.06 | +0.01 | -0.13 | **-0.38** ✅ | +0.01 | |
| | **wet_press** | -0.06 | **-0.48** ✅ | +0.24 | -0.16 | +0.44 | +0.33 | |
| |
| **Kết quả v14 (Spearman ρ):** |
| |
| | degradation | orient. | clarity | continuity | noise_lvl | contrast | minutiae | |
| |-------------|---------|---------|-----------|-----------|----------|----------| |
| | **blur** | +0.11 | **-0.19** ✅ | -0.003 | +0.08 | +0.22 | **+0.50** ❌ | |
| | **noise** | +0.001 | -0.16 | +0.03 | **-0.02** ⚠️ | +0.15 | +0.05 | |
| | **jpeg** | -0.18 | -0.07 | -0.10 | +0.08 | -0.11 | -0.09 | |
| | **occlusion** | +0.06 | +0.04 | **-0.12** ✅ | +0.18 | +0.07 | **+0.18** ❌ | |
| | **dry_skin** | +0.19 | -0.28 | **-0.56** ✅⬆ | **-0.56** ✅⬆ | **-0.62** ✅⬆ | +0.36 | |
| | **wet_press** | **-0.28** ✅ | -0.13 | +0.37 | -0.16 | +0.20 | **+0.57** ❌ | |
|
|
| **Nhận xét v14 so với v13:** |
| - ✅ **dry_skin**: cải thiện mạnh — clarity(-0.28), continuity(-0.56), noise_level(-0.56), contrast(-0.62) đều đúng chiều và mạnh hơn |
| - ✅ **Track 2 KS**: 0.634 → 0.263 (cải thiện lớn nhờ loại slap sensors) |
| - ✅ **Pearson**: 0.224 → 0.294 |
| - ⚠️ **noise→noise_level**: -0.533 (v13) → -0.019 (v14) — regression, gần bằng 0 |
| - ⚠️ **blur→clarity**: -0.490 (v13) → -0.187 (v14) — yếu hơn đáng kể |
| - ❌ **wet_press→minutiae**: +0.326 (v13) → +0.565 (v14) — sai chiều, tệ hơn |
| - ❌ **occlusion→minutiae**: -0.093 (v13) → +0.183 (v14) — flip sang sai chiều |
| |
| **Root cause v14 regression (T30):** Concept head chỉ thấy FVC texture khi degraded (FVC-only L_deg). Eval trên SD302 images — concept head không generalize. v15 fix bằng SD302 concept-only L_deg (T30b) + tăng gamma (T30a) + tăng tần suất (T30c). Eval v15: KS=0.2758 (tệ hơn v14), score range 24–56 (score collapse, không discrimination). |
|
|
| **Root cause v15 failure (T31 — v16 fix):** Score collapse toàn bộ 60 epochs (q_mean≈52.5, q_std≈16, score range 24–56). Chi tiết xem mục TODO T31. |
|
|
| --- |
|
|
| **Kết quả v18 (Spearman ρ — CONCEPT COLLAPSE + INVERSION):** |
|
|
| | degradation | orient. | clarity | continuity | noise_lvl | contrast | minutiae | |
| |-------------|---------|---------|-----------|-----------|----------|----------| |
| | **blur** | -0.572 ❌ | **+0.611** ❌❌ | +0.575 ❌❌ | -0.583 ❌ | +0.552 ❌ | -0.487 ❌ | |
| | **noise** | -0.410 ❌ | +0.288 ❌ | +0.368 ❌ | **-0.296** ✓ | +0.298 ❌ | +0.630 ❌❌ | |
| | **jpeg** | -0.097 | **+0.222** ❌ | +0.194 ❌ | -0.268 | +0.140 | -0.279 | |
| | **occlusion** | -0.162 | -0.151 ✓ | +0.042 ❌ | -0.150 | +0.063 | **-0.133** ✓ | |
| | **dry_skin** | +0.183 | -0.066 ✓ | +0.091 ❌ | +0.086 | **-0.247** ✓ | +0.230 ❌ | |
| | **wet_press** | -0.118 | **+0.217** ❌ | +0.196 ❌ | -0.320 | +0.140 | **-0.245** ✓ | |
| |
| **Chẩn đoán v18 concept collapse**: blur làm TĂNG clarity (+0.611) — đảo chiều hoàn toàn. Root cause: concept head bị stuck ở giá trị cực biên — orientation_coherence≈0.995 và noise_level≈0.982 (bão hòa gần 1.0); clarity≈0.032, continuity≈0.027, contrast≈0.04, minutiae≈0.027 (bão hòa gần 0.0). Khi degradation áp vào ảnh, không có dư địa để concept giảm thêm → bất kỳ thay đổi nhỏ nào đều là noise ngẫu nhiên, dẫn đến Spearman ρ không ổn định. Cùng cơ chế với score collapse (q_std≈0.01): model không phân biệt được input. |
|
|
| --- |
|
|
| ### Track 3 — Cross-Matcher Transfer (Reviewer defense) |
|
|
| Dùng Q của SIFQ (train với MDGT teacher) để tính ERC với **VeriFinger v12 match scores** (matcher chưa từng thấy). |
|
|
| Nếu AUC_ERC vẫn thấp → Q generalizable, không phải chỉ distill MDGT. |
| Hiện tại: chưa có VeriFinger license → bỏ qua hoặc dùng matcher khác. |
| |
| --- |
| |
| ### Track 5 — Human Correlation (Optional) |
| |
| Expert rate ảnh trên Likert 1–5, Spearman ρ với SIFQ score. Tốn công nhưng là evidence mạnh nhất. |
| |
| --- |
| |
| ## 7. File Map — Research Concept → Code |
| |
| | Khái niệm trong paper | File code | |
| |----------------------|-----------| |
| | Backbone (TinyViT-5M) | `src/models/backbone.py` | |
| | Concept Head (6 concepts, legacy v16–v26) | `src/models/concept_head.py::ConceptHead` | |
| | Concept Head (spatial, v27+) | `src/models/concept_head.py::SpatialConceptHead` | |
| | Score Aggregator Q(x) | `src/models/aggregator.py` | |
| | Gradient Reversal Layer | `src/models/grad_reverse.py` | |
| | Sensor Discriminator D | `src/models/sensor_discriminator.py` | |
| | SIFQ full model wrapper | `src/models/sifq.py` | |
| | $L_{mat}$ (Huber + prototype) | `src/losses/matcher_teacher.py` | |
| | $L_{sens}$ (pair + adversarial) | `src/losses/sensor_invariance.py` | |
| | $L_{deg}$ (ranking + concept) | `src/losses/degradation_ranking.py` | |
| | $L_{ortho}$ (decorrelation) | `src/losses/orthogonality.py` | |
| | MDGT teacher loader | `src/training/mdgt_teacher.py` | |
| | Stage scheduler α/β/γ | `src/training/stage_scheduler.py` | |
| | DegradationPipeline (6 types) | `src/data/degradation.py` | |
| | DrySkinSimulator | `src/data/degradation.py::DrySkinSimulator` | |
| | MorphologicalDilator | `src/data/degradation.py::MorphologicalDilator` | |
| | Dataset loader SD302 A/B/D | `src/data/nist302_loader.py` | |
| | Dataset loader FVC 2002/2004 | `src/data/fvc_loader.py` | |
| | Dataset loader PolyU (contactless↔contact) | `src/data/polyu_loader.py` | |
| | Cross-sensor pair builder | `scripts/train_sifq.py::build_pair_indices()` | |
| | Spread/Uniformity loss | `scripts/train_sifq.py` (inline) | |
| | Prototype computation | `scripts/train_sifq.py::compute_teacher_prototypes()` | |
| | Training main loop | `scripts/train_sifq.py::main()` | |
| | Track 1 ERC evaluation | `src/evaluation/erc.py` | |
| | Track 2 Sensor invariance | `src/evaluation/sensor_invariance.py` | |
| | Track 4 Concept grounding | `src/evaluation/concept_grounding.py` | |
| | Run training v21 (T36: full-proto + FVC-only L_deg, 60ep) | `scripts/run_train_v21.sh` | |
| | Run training v14 (segmented only, 60ep from scratch) | `scripts/run_train_v14.sh` | |
| | Run training v13 (80ep, resume v12) | `scripts/run_train_v13.sh` | |
| | Run eval v13 (exclude non-seg slap) | `scripts/run_eval_v13.sh` → `eval_results/v13_seg/` | |
| | Run inference | `scripts/run_infer.py` | |
| | Run evaluation | `scripts/run_eval.py` | |
| | Visualize score milestones | `visualize_score_milestones.py --exclude-sensor ...` | |
| | **MDGTv2 local pipeline** (DINOv2+TRAM+GNN) | `src/models/mdgt/pipeline.py` | |
| | MDGT teacher wrapper (loads local pipeline, frozen) | `src/training/mdgt_teacher.py` | |
| | Pre-cache teacher embeddings (one-time, startup) | `scripts/train_sifq.py::precompute_teacher_embeddings()` | |
| | Image preloading (RAM cache, uint8) | `scripts/train_sifq.py::RecordDataset._preload_images()` | |
| | GPU-native degradation (blur/noise/occlusion) | `scripts/train_sifq.py::_degrade_gpu()` | |
| | CPU degradation with preloaded numpy (jpeg/dry_skin/wet_press) | `scripts/train_sifq.py::_degrade_from_np()` | |
| | Vectorized prototype cosine (1 GPU sync vs ~100) | `src/losses/matcher_teacher.py::_compute_q_mat()` | |
|
|
| --- |
|
|
| ## 8. Luồng dữ liệu trong 1 training step (v21 — current) |
|
|
| **Cấu hình v21:** batch=128, W_SPREAD=3.0, deg_every_n_steps=2, deg_max_images=32, no-mat-stats, proto-max-batches=0, gpus=0+1 (DataParallel) |
|
|
| **Startup (1 lần trước khi train):** |
| ``` |
| 1. RecordDataset._preload_images() → np.empty([N, 224, 224], uint8) ~2 GB RAM |
| → __getitem__ trở thành: arr.copy().float().unsqueeze(0) / 255.0 (không đọc disk) |
| |
| 2. precompute_teacher_embeddings(teacher, train_ds) → Tensor[N, 256] CPU (float32) |
| → Frozen DINOv2+TRAM+GNN chạy 1 lần duy nhất trên toàn bộ N records |
| → Không bao giờ chạy lại trong training loop |
| |
| 3. compute_teacher_prototypes() → dict{identity_id → Tensor[256]} CPU |
| → MDGT prototype per identity (L2-normalized mean embeddings) — 1 lần |
| ``` |
|
|
| **Training step:** |
| ``` |
| Batch (B=128, CrossSensorBatchSampler: 16 anchor pairs + fill) |
| │ |
| ├─ images_np = batch["images_np"] ← [B, 224, 224] uint8, đã trong RAM (không từ GPU) |
| ├─ images = batch["images"].to(device) ← [B, 1, 224, 224] float32 trên GPU |
| │ |
| ├─ Forward SIFQ: model(images) → {score [B,1], concepts [B,6], sensor_logits [B,N_sensors], features [B,320]} |
| │ |
| ├─ L_mat: (chỉ SD302+FVC, bỏ PolyU) |
| │ ├─ emb_cache = emb_cache[record_idxs[_non_polyu_idx]] ← CPU lookup, O(1) |
| │ ├─ _compute_q_mat VECTORIZED (không per-sample .item() sync): |
| │ │ ├─ proto_mat = stack([prototypes[id] for id in ids]).to(device) ← 1 GPU transfer |
| │ │ ├─ cos_values = (emb * proto_mat).sum(dim=-1) ← 1 GPU kernel |
| │ │ ├─ cos_cpu = cos_values.cpu().tolist() ← 1 GPU sync |
| │ │ └─ apply tanh(z) nếu có stats, else raw_cosine (tất cả v21 dùng raw — --no-mat-stats) |
| │ └─ Huber(pred_normalized, q_mat) pred_normalized = (Q/100 - 0.5) × 2 |
| │ |
| ├─ L_sens: |
| │ ├─ build_pair_indices() → pairs (cùng finger, khác sensor) từ SD302 + PolyU trong batch |
| │ ├─ L_pair = relu(|Q(s1) - Q(s2)| - 0.05).mean() |
| │ ├─ L_adv = cross_entropy(sensor_logits, sensor_labels) ← GRL đảo gradient |
| │ ├─ L_adv_clamped = L_adv.clamp(max=log(num_sensors)) ← T16: ngăn anti-corr |
| │ └─ (L_pair + 0.3 × L_adv_clamped, L_pair, L_adv) |
| │ |
| ├─ L_deg (mỗi deg_every_n_steps=2 bước, chỉ FVC — tối đa deg_max_images=32): |
| │ ├─ deg_type = random.choice([blur, noise, jpeg, occlusion, dry_skin, wet_press]) |
| │ ├─ level_lo ∈ {1,2} random, level_hi = 3 |
| │ │ |
| │ ├─ GPU path (blur / noise / occlusion) — không transfer nào: |
| │ │ ├─ imgs_low = _degrade_gpu(images[_fvc_idx], deg_type, level_lo) |
| │ │ └─ imgs_high = _degrade_gpu(images[_fvc_idx], deg_type, level_hi) |
| │ │ |
| │ └─ CPU path (jpeg / dry_skin / wet_press) — đọc từ preloaded numpy, không GPU→CPU: |
| │ ├─ imgs_np = images_np[_fvc_idx] ← uint8, đã trong RAM |
| │ ├─ apply cv2 ops per image (GaussianBlur/imencode/erode/etc.) |
| │ ├─ imgs_low = stack(low_list).float().to(device) / 255.0 ← 1 CPU→GPU |
| │ └─ imgs_high = stack(high_list).float().to(device) / 255.0 ← 1 CPU→GPU |
| │ |
| │ model(imgs_low), model(imgs_high) → 2 SIFQ forward thêm |
| │ L_rank + gamma * L_concept_deg → L_deg |
| │ |
| ├─ L_ortho: standardize concepts → (x.T @ x) / (B-1) → off_diag Frobenius² |
| │ |
| ├─ L_spread_global: uniform MSE(sorted Q_batch / 100, linspace(10,90) / 100) |
| ├─ L_spread_sd302: uniform MSE(sorted Q_sd302 / 100, linspace(10,90) / 100) — nếu ≥8 SD302 |
| │ |
| │ [epoch-end: log train_l_pair, train_l_adv, train_q_mean, train_q_std] |
| │ |
| └─ total = α × L_mat + β × L_sens + γ × L_deg + L_ortho + 3.0 × L_spread_global + 3.0 × L_spread_sd302 |
| └── scaler.backward() → optimizer.step() → scaler.update() (AMP fp16) |
| ``` |
|
|
| **v21 config summary:** |
|
|
| | Param | Giá trị | Ghi chú | |
| |-------|---------|---------| |
| | batch_size | 128 | DataParallel → 64/GPU | |
| | W_SPREAD | 3.0 | --spread-weight 3.0 | |
| | deg_every_n_steps | 2 | Mỗi 2 bước có 1 deg step | |
| | deg_max_images | 32 | Tối đa 32 FVC images/step | |
| | concept_deg_gamma | 0.5 | L_concept weight trong L_deg | |
| | proto_max_batches | 0 | Full dataset (không cap) | |
| | no_mat_stats | True | Raw cosine target (không tanh) | |
| | sd302_concept_weight | 0.0 | T30b disabled | |
| | deg_include_sd302 | False | FVC-only L_deg (T27/T36) | |
|
|
| --- |
|
|
| ## 9. Điểm còn thiếu / TODO |
|
|
| | # | Vấn đề | Impact | Todo | |
| |---|--------|--------|------| |
| | T1 | `L_adv` input nên từ concept-intermediate, không phải backbone features | Trung bình | Sửa `SIFQ.forward()` + `SensorDiscriminator` input dim 320→256 | |
| | T2 | `L_mat` signal yếu vì q_mat ≈ constant với SD302 | ✅ Đã cải thiện (v8) | FVC2002+2004 đã được thêm → 8 impressions/subject → q_mat có real ranking signal | |
| | T3 | Finger_id heuristic không verified | ✅ Đã xác nhận | Audit thực tế: finger ID nhất quán across sensors trong SD302. Không còn là risk. | |
| | T4 | Không có FVC2002/2004 và PolyU CL2CB | ✅ Đã thêm (v9) | FVC2002+2004 (7,040) + PolyU (5,952 contact+contactless). PolyU = cross-modality L_sens mạnh nhất. | |
| | T5 | Track 3 chưa có VeriFinger | Thấp | Dùng matcher khác (FLaRE, AFR-Net open-source) | |
| | T6 | `L_mat` tốn compute nhưng gần như không contribute khi chỉ có SD302 | ✅ Đã xử lý (v8) | FVC thêm vào, L_mat già trị hơn | |
| | T7 | `L_spread` threshold 10/100 tùy ý — variance mode trivially saturates | ✅ Đã fix (v8) | Uniform mode: MSE(sorted Q, linspace(10,90)), weight=2.0 | |
| | T8 | `L_pair` trong `L_sens` sparse vì batch random ít khi có cross-sensor pair | ✅ Đã fix (v7) | `CrossSensorBatchSampler`: mỗi batch đảm bảo k_cross=16 nhóm cóp 2 samples từ khác sensor. | |
| | T9 | GRL λ cố định + stage transition nhảy bậc — shock tại ep10 (β: 0→0.20 đột ngột) | ✅ Đã fix (v8) | DANN warm-up từ ep0; β ramp linear ep10–14 + ep30–34 thay vì nhảy bậc | |
| | T13 | v8: chỉ ramp β, α/γ vẫn step change tại ep15 → sens oscillate 3–3.5 từ ep18 | ✅ Đã fix (v9) | Ramp ALL THREE (α, β, γ) cùng lúc ep10–19; không có step change nào trong toàn bộ schedule | |
| | T10 | Score collapse: spread=0.010 stuck (max penalty) trong toàn bộ v7 | ✅ Đã fix (v8) | Uniform spread mode: gradient trực tiếp ép phân bố score | |
| | T11 | L_deg plateau 0.104 (tại margin boundary m=0.10) từ ep43+ trong v7 | ✅ Đã fix (v8) | γ floor = 0.50 (was 0.40) giữ deg grounding mạnh hơn | |
| | T12 | S4 oscillation: loss tăng từ 0.53 lên 1.18 trong v7 ep61-80 | ✅ Đã fix (v8) | Cosine LR decay 1e-4 → 5e-6 ngăn oscillation giai đoạn finetune | |
| | T14 | `l_pair` và `l_adv` không được log riêng — chỉ thấy `train_l_sens` tổng hợp | ✅ Đã fix (v11) | `SensorInvarianceLoss.forward()` trả về `(total, l_pair, l_adv)` tuple; train script log `train_l_pair`, `train_l_adv` riêng | |
| | T15 | `q_mean` và `q_std` không được log ra metrics.jsonl — không thể monitor score distribution | ✅ Đã fix (v11) | Train script tích lũy `q_sum`/`q_sq_sum`/`q_count` qua từng step → tính epoch-level `train_q_mean`, `train_q_std` | |
| | T16 | GRL anti-correlation: `l_adv` >> `log(num_sensors)` suốt S2–S4 (ep20–47: 7–16 vs random=3.47) → backbone học predict sai sensor với high confidence → GRL game cycling không hội tụ | ✅ Đã fix (v11) | Clamp `l_adv` tại `log(num_sensors)` trước khi đưa vào total. Khi backbone đã đủ confuse discriminator (CE ≥ log N), gradient reversal dừng lại → equilibrium ổn định thay vì anti-correlation cycle | |
| | T17 | **Score collapse v11: 95% ảnh kẹt tại ~58.3** (inference SD302: mean=59.8, std=6.5, median=58.3). Root cause: L_deg chỉ apply cho FVC (16% batch) → L_spread được thỏa mãn batch-level nhờ FVC variation, nhưng SD302 images không có ordinal grounding → model học "SD302 = medium quality ~58" mà không có gradient để phân biệt. Slap sensors (R,S) cho ~88 do có ít samples và backbone capture type signal; roll/flat sensors cho ~58.3 uniform → sensor bias residual. | ⚠️ Fix sai (v12) → Đúng (v13) | **v12 (sai):** Apply L_deg cho ALL datasets. SD302 images anchored tại ~28 (near degraded floor), tệ hơn. **v13 (đúng):** Revert FVC-only L_deg + thêm per-dataset L_spread riêng cho SD302 subset. | |
| | T18 | **`MorphologicalDilator` sai chiều cho wet_press**: Dùng `cv2.dilate` thay vì `cv2.erode`. NIST fingerprints có ridges tối (dark ridges, light valleys). `cv2.dilate` expand vùng sáng → shrink ridges (mô phỏng ngón tay KHÔ, không phải ướt). Wet press cần ridges phình to, lấn vào valleys → phải dùng `cv2.erode` (expand dark regions). Bug giải thích tại sao Track 4 wet_press → clarity=+0.219 (sai chiều, phải âm): dilated image có ridges mảnh hơn → model thấy valleys rõ hơn → clarity tăng. | ✅ Fix (v12) | Đổi `cv2.dilate` → `cv2.erode` trong `MorphologicalDilator.__call__`. Erode expand ridges tối → ridges merge vào valleys → clarity giảm đúng chiều. | |
| | T19 | **`jpeg` và `occlusion` concept signal gần 0** (Track 4 eval v11: jpeg→clarity=-0.045, occlusion→minutiae=-0.032). L_concept_deg quá yếu so với các loss khác cho những type này. Occlusion max 30% coverage (level 3) không đủ khuất minutiae. | ✅ Fix (v12) | Tăng `--deg-every-n-steps` từ 2 → giữ 4 (compute balance sau T17 tăng batch size). Tăng L_concept_deg gamma từ 0.5 → 1.0 trong `DegradationRankingLoss`. Tăng occlusion level 3 từ 30% → 40% coverage. | |
| | T20 | **SD302 scores anchored tại ~28 trong v12** (target 10–90). T17 fix (L_deg on all datasets) dùng synthetic degradation làm ordinal anchor cho SD302. SD302 images trông như "level 1-2 degraded FVC" đối với model → anchor tại ~28 (gần degraded floor). Per-sensor: R/S slap non-segmented std=0.0 (fully collapsed), roll sensors mean=27-28 std=6-7, flat sensors mean=35-40 std=10-15. KS=0.51 vẫn fail vì sensor TYPE bias (slap vs roll vs flat). | ✅ Fix (v13) | Revert T17 (FVC-only L_deg) + Add per-dataset L_spread cho SD302 subset trong mỗi batch. SD302 images buộc phải compete với nhau để có spread [10,90] thay vì được anchored bởi synthetic degradation. | |
| | T21 | **Non-segmented slap collapse** (R_*_slap, S_*_slap std=0.0, score≈21.2 cố định). Full-hand slap images visually homogeneous → không có quality variation tự nhiên → model gán cùng score. v13 eval: sensors này kéo mean_KS từ 0.51 (v12) lên 0.634 (v13). | ✅ Fix (v14) | **T28**: `--exclude-sensor R_1000_slap,R_500_slap,S_500_slap` trong training và eval. Loại ~1,700 records. `run_infer.py`, `run_eval.py`, `train_sifq.py` đều có flag `--exclude-sensor`. Eval v13 chính xác: `run_eval_v13.sh` → `eval_results/v13_seg/`. | |
| | T22 | **Noise concept regression trong v12**: noise_level: +0.188 (v11) → **-0.168 (v12)** (sai chiều hoàn toàn). Root cause: `if c_idx == 3` special case trong `DegradationRankingLoss` push noise_level TĂNG theo degradation. ScoreAggregator (unconstrained MLP) có thể thỏa mãn L_rank bằng cách GIẢM noise_level + dùng positive weight → conflict được resolve bằng cách invert concept direction. Gamma=1.0 (T19) làm conflict mạnh hơn → model phải chọn một hướng nhất quán → chọn inverted direction. | ✅ Fix (v13) | T25: Remove `if c_idx == 3` special case trong `DegradationRankingLoss.forward()`. Tất cả concepts GIẢM theo degradation (high = better quality). Noise_level semantic: **low noise level = low noise = good** (trước: high noise_level = more noise). Consistent với tất cả concepts khác → ScoreAggregator dùng positive weights cho tất cả. | |
| | T23 | **Occlusion concept vẫn dead sau T19** (v12 eval: contin=+0.023, minutiae=+0.075 — sai chiều cả hai). Hai nguyên nhân: (1) `DEGRADATION_CONCEPT_MAP` chỉ supervise minutiae_reliability, bỏ qua continuity; (2) coverage 40% chưa đủ để affect minutiae feature. | ✅ Fix (v13) | T26: Thêm continuity (c_idx=2) vào `DEGRADATION_CONCEPT_MAP["occlusion"] = [5, 2]`. Tăng occlusion level 3 coverage từ 40% → 55% (`0.183 * level`). v13 kết quả: occlusion→minutiae=-0.09 (yếu, chưa đủ). v14 cần monitor. | |
| | T28 | **Non-segmented slap gây nhiễu training và eval** (v13: R_1000_slap score≈21.2 std=0, kéo mean_KS lên 0.634). Full-hand slap ảnh 4 ngón tay → backbone extract feature gần như giống nhau → score collapse về 21.2 cho mọi người. SensorDiscriminator phải waste GRL capacity để align cụm ~21 với segmented counterparts ~54. | ✅ Fix (v14) | T28: `--exclude-sensor R_1000_slap,R_500_slap,S_500_slap`. Loại ~1,700 records từ SD302-B/D. Thêm flag vào `train_sifq.py`, `run_infer.py`, `run_eval.py`, `visualize_score_milestones.py`. Script: `run_train_v14.sh`, `run_eval_v13.sh`. | |
| | T29 | **Epoch plateau quá sớm — 80 epochs lãng phí** (v13: loss converge từ epoch 20; ep20–79 flat). | ✅ Fix (v14) | T29: v14 train từ đầu (không resume) với **60 epochs**. LR cosine schedule 1e-4→0 trên 60 epochs. Nếu resume từ checkpoint: 30 epochs đủ. | |
| | T31 | **Score collapse v15 — tất cả ảnh score gần như giống nhau** (eval range 24–56, q_mean≈52.5 flat suốt 60 epochs). Root cause: `stats=None` trong mọi lần gọi `loss_mat()`. Khi stats=None: `q_mat = raw cosine ≈ 0.85` cho mọi ảnh (MDGT quality-robust → cosine ổn định ở mức cao cho mọi ảnh của cùng identity). L_mat kéo pred_score về `(0.85/2 + 0.5)×100 ≈ 92.5`; L_spread kéo về [10,90]; equilibrium tại q_mean≈52 không thay đổi. Không có gradient nào chỉ ra ảnh nào nên cao/thấp hơn ảnh khác → model chỉ đáp ứng **rank thứ tự** trong batch (L_spread) mà không phân biệt ảnh tốt/xấu thực sự. | ⚠️ Partial fix (v16 — tạo ra bug mới T32) | **T31a (per-identity cos stats):** Sau khi tính prototype, chạy second pass `compute_identity_cos_stats()` để tính `(mean_cos, std_cos)` per identity. Pass `stats=cos_stats` vào `loss_mat()`. **T31b (tanh scaling trong `_compute_q_mat`):** `q_mat = tanh((cos − μᵢ) / σᵢ)` → teacher target zero-centred ∈ (−1,1). **T31c (W_SPREAD 2.0→4.0):** Tăng spread weight. **Nhưng T31 tạo ra conflict mới: xem T32.** | |
| | T32 | **Score collapse v16 — NGHIÊM TRỌNG HƠN v15** (eval range 46.9–50.5, q_std=0.33! Training q_std=15.6 nhưng là false positive — driven bởi FVC trong training batch). Root cause: T31 per-identity stats conflict trực tiếp với L_pair. L_mat muốn **within-identity variation** (`q_mat=tanh((cos−μᵢ)/σᵢ)` → ảnh cùng identity phải score khác nhau). L_pair muốn **within-identity uniformity** (`|Q(s1)−Q(s2)|≤0.05` → cùng identity, khác sensor, score bằng nhau). Conflict không thể resolve → model output ~50 cho tất cả SD302. FVC không có L_pair → FVC spread OK → training q_std=15.6 driven by FVC only. Inference trên SD302-only → q_std=0.33. Sensor bias: roll sensors cluster ≈49.67 vs slap/flat ≈50.2 → KS=0.90 trong range 3.6pt → mean_KS=0.527 (tệ hơn cả v13). | ✅ Fix (v17) | **T32a (`compute_identity_cos_stats(fvc_only=True)`):** Chỉ tính stats cho FVC identities. FVC không có cross-sensor pairs → L_pair=0 → không conflict với L_mat within-identity signal. **T32b (`_compute_q_mat` fallback to raw cosine):** SD302 identities không có trong FVC-only stats → fallback về `raw_cosine ≈ 0.85` (v14 behaviour — constant target, chỉ anchor mean, không conflict với L_pair). FVC images giữ tanh normalization với FVC-specific stats. Files: `src/losses/matcher_teacher.py::_compute_q_mat`, `scripts/train_sifq.py::compute_identity_cos_stats`. | |
| | T33 | **Score collapse v17 — WORSE THAN v16** (eval SD302 range 18.1–53.0, tất cả đổ về ~52.7, q_std=0.60! Training q_std=16.59 OK nhưng false positive driven by FVC). Root cause (sâu hơn T32 đã fix): T32 loại bỏ L_mat vs L_pair CONFLICT nhưng không fix SCORE COLLAPSE. (1) SD302 raw cosine ≈ 0.85 là CONSTANT → L_mat không tạo per-image quality gradient cho SD302 → không có signal để phân biệt SD302 images. (2) GRL + L_pair triệt tiêu discriminative features từ SD302 backbone: GRL xóa sensor-correlated info (bao gồm quality-correlated-with-sensor); L_pair ép same-identity same-score → SD302 feature space bị flatten. (3) FVC có stable per-image tanh targets → model học quality function cho FVC. SD302 chỉ có inconsistent batch-relative spread signals → feature collapse về ~52.7. (4) FVC tanh targets (variable) vs SD302 raw cosine targets (constant) tạo asymmetry → model học shortcut "FVC=variable, SD302=52.7". W_SPREAD=4.0 + gamma=2.0 + sd302_concept_weight=1.0 làm tệ thêm so với v14. KS=0.616 ❌, Pearson=-0.002 ❌. | ✅ Fix (v18) | **T33: Revert tất cả additions từ v15–v17 về v14 baseline + thêm SD302-A.** T33a: `--no-mat-stats` — skip per-identity cosine stats hoàn toàn; tất cả images (FVC + SD302) dùng raw cosine làm L_mat target → không còn FVC/SD302 asymmetry. T33b: W_SPREAD=2.0 (revert từ 4.0). T33c: concept_deg_gamma=0.5 (revert từ 2.0). T33d: sd302_concept_weight=0.0 (revert T30b). T33e: deg-every-n-steps=4 (revert từ 2). NEW: SD302-A included (13,630 images, 8 sensors A-H) — v14 chỉ dùng B+D. Targets: q_std>12, score range 10–90, mean_KS≤0.27, Pearson≥0.25. | |
| | T35 | **Score collapse v15–v19 — two root causes (T33 fixed but v19 still collapsed).** v18 actual: q_std=0.01 ❌❌ (score range ~54.62–54.65). Training showed healthy q_std but inference collapse. Root cause 1 (dominant): Truncated prototypes `--proto-max-batches 150` → only 45% of dataset → SD302 gets 2–3 partial sensor prototypes → cosine is sensor-biased (not quality-correlated) → per-image L_mat gradient near-zero for SD302. Root cause 2: FVC-only L_deg leaves SD302 without ordinal grounding → L_spread_ds is batch-level only → collapses at inference. T35a fix: `--proto-max-batches 0` (full dataset, 15–25 min). T35b fix (proposed): `--deg-include-sd302` → apply L_rank to SD302 too. Note: T35b was WRONG — see T36. | ⚠️ Partial (v20: T35a ✅, T35b ❌) | T35a: Set `--proto-max-batches 0` (no cap). T35b: `--deg-include-sd302` flag (applies L_rank to FVC+SD302 instead of FVC-only). **T35b introduced new collapse — removed in v21.** | |
| | T36 | **Score collapse v20 — `--deg-include-sd302` creates ~53.38 attractor.** v20 training q_std=18.3 (healthy-looking) but ALL SD302 inference scores collapse to ~53.38 (q_std=0.007, range 53.20–53.41). Root cause: L_rank applied to SD302 clean images. L_rank only requires Q(clean)>Q(degraded)+m, NOT that different clean images score differently. Model satisfies L_rank by assigning same ~53.38 to ALL clean SD302 images + lower to degraded → gradient has no reason to differentiate clean images → stable ~53.38 attractor. L_spread_ds (batch-level) + L_pair reinforce attractor. Training q_std=18.3 is FALSE POSITIVE driven entirely by L_spread gradient — at inference (no gradient) model outputs its "natural" ~53.38 for all clean SD302. **Why v14 worked without --deg-include-sd302:** FVC genuine quality variation → MDGT cosine genuinely varies (0.75→0.93 per FVC impression) → L_mat gradient shapes backbone to be quality-discriminative → features TRANSFER to SD302 at inference. L_rank on SD302 blocks this transfer. eval_results/v20: mean_KS=0.4936 ❌, Pearson=0.0048 ❌. | ✅ Fix (v21 — Training) | **T36: Remove `--deg-include-sd302`.** Keep `--proto-max-batches 0` from T35a. FVC-only L_deg: genuine quality variation → L_mat gradient → quality-discriminative backbone → intrinsic SD302 quality scoring. One-line change in run_train_v21.sh vs run_train_v20.sh. | |
| | T37 | **CrossSensorBatchSampler k_cross=16 + full prototypes destroys quality discrimination.** v21: Pearson=0.092, dry_skin orientation=+0.87 ❌. Root cause: `CrossSensorBatchSampler` (added for T8) default k_cross=16 guarantees 16 cross-sensor pairs/batch. With full prototypes (nearly-constant L_mat targets ≈0.85–0.90 for all SD302), backbone over-optimises sensor invariance at expense of quality ordering → Pearson collapses. v14 used random batching (~1–2 pairs by chance). Additionally: DataParallel (--gpus 0,1) causes 4.3× slowdown for TinyViT-5M (v21: ~970s/epoch vs v20 single GPU: ~226s). Redundant double teacher pass (emb_cache + compute_teacher_prototypes both ran teacher on all 42K images). | ✅ Fix (v22 — Training) | **T37: (1) `--k-cross 0`** (disable CrossSensorBatchSampler, random batching like v14); **(2) `--gpus 0`** (single GPU, no DataParallel); **(3) `build_prototypes_from_cache()`** computes prototypes from emb_cache in O(N) CPU — no second teacher pass. All other params same as v21 (proto-max-batches=0, no-mat-stats, spread-weight=3.0, concept-deg-gamma=0.5, FVC-only L_deg). Expected: Pearson≥0.28, KS≤0.28, ~220s/epoch, correct concept grounding. | |
| | T38 (v22) | **minutiae_reliability wrong direction for wet_press; occlusion deviates from paper.** (1) `wet_press → minutiae_reliability[5]` consistently POSITIVE across all versions (v14=+0.565) — simulation 3×3 kernel too subtle at level 1 (~1 px expansion) so model reads it as "good ink". (2) `occlusion` concept map had `[5, 2]` (continuity added in T26) and coverage 55%, both deviating from paper design `[minutiae_reliability only, 10–40%]`. T26 added continuity as a crutch for weak signal, but root cause was unseeded eval (incoherent Spearman ρ across random block positions per level). | ✅ Fix (v22 — Code) | **T38a** (wet_press simulation): Scale `MorphologicalDilator` kernel `ks = 3 + 2*iterations` (5×5/7×7/9×9) + `sigma = 1.0 + 0.8*iterations`. Level 1 visibly impairs bifurcations. Concept map KEPT at `[1, 5]` (paper). **T38b** (occlusion): Revert concept map `[5, 2]` → `[5]`; coverage `0.183×level` → `0.133×level` (max 40%). **T38c** (occlusion eval): `np.random.seed(level)` in `compute_crosstalk_matrix` — deterministic block position per severity level. Files: `src/data/degradation.py`, `src/losses/degradation_ranking.py`, `src/evaluation/concept_grounding.py`. | |
| | T_old38 | **MDGTCheckpointTeacher phụ thuộc vào external `fingerprint_pad` package** (dynamic sys.path injection) — brittle, không versioned, khó deploy. | ✅ Fix (v21, cùng phiên) | Import từ `src/models/mdgt/pipeline.py::MDGTv2` (local). `_ensure_on_path()` và `fingerprint_pad` import đã bị xóa. `MDGTv2` constructor nhận thêm `gnn_heads` và `pool_heads` (absent trong external API cũ). File: `src/training/mdgt_teacher.py`. | |
| |
| |
| --- |
| |
| ## 10. Performance Engineering (v21) |
| |
| ### Bối cảnh |
| |
| Training ban đầu chạy ~3.5–5.7s/it. Sau 3 vòng tối ưu, root causes được xác định và fix: |
| |
| | Iteration | Thời gian | Root cause | |
| |-----------|-----------|------------| |
| | Before | 3.49 s/it (step 39) | Teacher DINOv2 forward mỗi step | |
| | After teacher cache | 4.05 s/it (step 6) | DataLoader disk IO bottleneck bị lộ | |
| | After image preload | 4.96 s/it (step 4) | CUDA warmup + _compute_q_mat GPU syncs | |
| | After vectorize q_mat | ~0.4 s/it (dự kiến, sau warmup) | — | |
| |
| > **Lưu ý:** Các measurement ở step 2–6 bao gồm CUDA kernel JIT compilation (one-time, 2–5s). Cần đến step 20–30 để đo steady-state. |
|
|
| ### Fix 1: Teacher Embedding Cache |
|
|
| **Vấn đề:** DINOv2 ViT-S/14 + TRAM + GNN forward chạy trên ~100 images mỗi step, mỗi epoch. Teacher là frozen → cùng image luôn cho cùng embedding. ~20,000 DINOv2 forward qua 60 epochs = pure waste. |
|
|
| **Thêm nữa:** Attention monkey-patch trong `DINOv2Backbone` vô hiệu hóa xformers, buộc dùng standard O(N²) attention + lưu 12 × `(B, 6, 257, 257)` attention maps per forward. |
|
|
| **Fix:** |
| ```python |
| # scripts/train_sifq.py |
| emb_cache = precompute_teacher_embeddings(teacher, train_ds, device, batch_size=128) |
| # → Tensor[N, 256] CPU float32, ~43 MB cho 42K records |
| |
| # Per step (thay vì teacher forward): |
| _cached_emb = emb_cache[record_idxs[_non_polyu_idx]] # O(1) lookup |
| loss_mat(..., cached_emb=_cached_emb) |
| ``` |
|
|
| **Tiết kiệm:** ~2–3s/it (DINOv2 forward) → 0 (lookup). Startup cost: ~2–3 min (1 lần duy nhất). |
|
|
| --- |
|
|
| ### Fix 2: Image Preloading |
|
|
| **Vấn đề:** Mỗi `RecordDataset.__getitem__` gọi `Image.open(path).convert("L")` + resize. Với 8 DataLoader workers và B=128, mỗi batch cần ~128 disk reads + PIL decode + resize. Đây là CPU/IO bottleneck ẩn sau teacher GPU time. |
|
|
| **Fix:** |
| ```python |
| # RecordDataset.__init__ |
| def _preload_images(self, image_size): |
| cache = np.empty((N, image_size, image_size), dtype=np.uint8) # ~2 GB |
| for i, rec in enumerate(self.records): |
| sample = next(loader.iter_samples([rec])) |
| cache[i] = (sample["image"].squeeze(0) * 255).byte().numpy() |
| self._image_cache = cache |
| |
| # __getitem__: O(1) numpy slice + dtype cast, no disk IO |
| image = torch.from_numpy(self._image_cache[idx].copy()).float().unsqueeze(0) / 255.0 |
| ``` |
|
|
| **Lợi ích kép:** `batch["images_np"]` (uint8 numpy trong batch) cho phép degradation CPU path đọc trực tiếp từ RAM, không cần `images[idx].cpu().numpy()`. |
|
|
| --- |
|
|
| ### Fix 3: Vectorized `_compute_q_mat` |
| |
| **Vấn đề:** `_compute_q_mat` gọi `torch.dot(emb[i], proto).item()` trong Python loop cho mỗi trong ~100 non-polyu samples. Mỗi `.item()` là một GPU synchronization barrier — CPU block cho đến khi GPU hoàn thành. ~100 syncs/step × ~10–100ms/sync = 1–10s overhead. |
|
|
| **Fix:** |
| ```python |
| # Trước: 100 syncs |
| for i, identity in enumerate(identity_ids): |
| cos = float(torch.dot(emb[i], proto).item()) # ← GPU sync! |
| |
| # Sau: 1 sync |
| proto_mat = torch.stack([prototypes[id] for id in identity_ids]).to(emb.device) # 1 transfer |
| proto_mat = F.normalize(proto_mat, dim=-1) |
| cos_values = (emb * proto_mat).sum(dim=-1) # 1 GPU kernel |
| cos_cpu = cos_values.float().cpu().tolist() # 1 sync |
| ``` |
|
|
| **Tiết kiệm:** ~100 GPU syncs → 1. Đây là fix quan trọng nhất sau khi teacher cache đã giải phóng bottleneck ẩn. |
|
|
| --- |
|
|
| ### Fix 4: GPU-Native Degradation |
|
|
| **Vấn đề:** Degradation loop cũ làm `images[_fvc_idx].detach().float().cpu().numpy()` → cv2 ops → `tensor.to(device)`. GPU→CPU là synchronous (stall pipeline). |
|
|
| **Fix:** |
| ```python |
| # _degrade_gpu: blur/noise/occlusion — full GPU, không transfer |
| if deg_type == "blur": |
| return TF.gaussian_blur(images, kernel_size) |
| if deg_type == "noise": |
| return (images + torch.randn_like(images) * sigma).clamp(0, 1) |
| if deg_type == "occlusion": |
| out = images.clone(); out[:, :, y:y+block, x:x+block] = 1.0; return out |
| |
| # _degrade_from_np: jpeg/dry_skin/wet_press — CPU nhưng đọc từ preloaded numpy |
| imgs = images_np[deg_idx] # [K, H, W] uint8, đã trong RAM |
| low = [deg_pipeline.apply(img, t, lo) for img in imgs] |
| ... → single CPU→GPU transfer (không GPU→CPU) |
| ``` |
|
|
| **Breakdown degradation types:** |
|
|
| | Type | Đường đi | Transfer cost | |
| |------|---------|---------------| |
| | blur | GPU (`TF.gaussian_blur`) | 0 | |
| | noise | GPU (`torch.randn_like`) | 0 | |
| | occlusion | GPU (tensor indexing) | 0 | |
| | jpeg | CPU+cv2 → GPU (1 transfer) | 1 CPU→GPU | |
| | dry_skin | CPU+cv2 → GPU (1 transfer) | 1 CPU→GPU | |
| | wet_press | CPU+cv2 → GPU (1 transfer) | 1 CPU→GPU | |
|
|
| --- |
|
|
| ### Tổng quan pipeline v21 |
|
|
| ``` |
| Startup (1 lần, ~3–5 phút): |
| _preload_images() ~2 min → 2 GB RAM |
| precompute_teacher_emb() ~2 min → 43 MB CPU tensor |
| compute_teacher_prototypes() ~1 min → dict[id → 256-D] |
| |
| Per step (~0.4 s steady-state): |
| DataLoader: ~1 ms (numpy slice + cast, no disk) |
| H2D transfer: ~5 ms (pin_memory) |
| SIFQ forward: ~100 ms (TinyViT-5M B=128, DataParallel 2×GPU) |
| L_mat: ~2 ms (emb_cache lookup + 1 GPU kernel + 1 sync) |
| L_sens: ~5 ms (pair indices + hinge loss) |
| L_deg (50%): ~150 ms (2 extra SIFQ forwards B=32 + GPU/CPU deg ops) |
| Backward: ~100 ms |
| Optimizer: ~20 ms |
| ───────────────────── |
| Total: ~0.35–0.55 s/it (estimate, post CUDA warmup) |
| ``` |
|
|
