Update Readme: v6 final (EfficientNetV2-S, 97.77% acc, T-scaling ECE 0.0053)

README.md

@@ -4,11 +4,14 @@ pipeline_tag: image-classification
 tags:
   - tensorflow
   - keras
+  - safetensors
+  - tflite
+  - tensorflow.js
   - image-classification
-  - densenet121
+  - efficientnetv2
   - architecture
   - building
-  - fgvc
+  - fgic
   - transfer-learning
   - gem-pooling
   - focal-loss
@@ -17,12 +20,13 @@ tags:
   - grad-cam
   - calibration
   - roc-auc
+  - temperature-scaling
 library_name: keras
 language: en
 datasets:
   - 0xgr3y/arch-building-dataset
 widget:
-  - src: https://cdn-uploads.huggingface.co/production/uploads/66cdac913f233bf2c7b4f590/HzXxNze2jmCkV5KPY_fpQ.png
+  - src: results/greyscope-labs-architecture-classification-efficientnetv2.jpg
     example_title: Bridge Classification
 model-index:
   - name: Architectural Building Image Classifier
@@ -36,46 +40,58 @@ model-index:
           split: test
         metrics:
           - type: accuracy
-            value: 0.9688
+            value: 0.9777
             name: Test Accuracy
           - type: accuracy
-            value: 0.9658
+            value: 0.9836
             name: Validation Accuracy (SWA)
           - type: accuracy
-            value: 0.968
+            value: 0.9799
             name: TTA Accuracy
+          - type: f1
+            value: 0.9777
+            name: Macro F1
+          - type: precision
+            value: 0.9777
+            name: Macro Precision
+          - type: recall
+            value: 0.9777
+            name: Macro Recall
+          - type: roc_auc
+            value: 0.9985
+            name: Macro ROC-AUC (OvR)
 ---
 
-![Arch-Building-Image-Classification](results/greyscope-labs-architecture-classification-cnn-transferlearning.PNG)
+![Arch-Building-Image-Classification](results/greyscope-labs-architecture-classification-efficientnetv2.jpg)
 
-# Fine-Grained Image Classification of World Architecture: A DenseNet121 Transfer Learning Approach with Layered Regularization
+# Fine-Grained Image Classification of World Architecture: An EfficientNetV2-S Transfer Learning Approach with Layered Regularization
 
 ### Architectural Building Image Classifier
 
-Fine-Grained Image Classification (FGIC) of world architectural buildings using CNN transfer learning with DenseNet121, enhanced with GeM Pooling, Focal Loss, Discriminative AdamW (LR), Stochastic Weight Averaging (SWA), Grad-CAM explainability, and calibration analysis.
+Fine-Grained Image Classification (FGIC) of world architectural buildings using CNN transfer learning with EfficientNetV2-S, enhanced with GeM Pooling, Focal Loss, Discriminative AdamW (LR), Stochastic Weight Averaging (SWA), Grad-CAM explainability, and calibration analysis.
 
 <table>
-  <tr><td><strong>Architecture</strong></td><td>DenseNet121 + GeM Pooling + Focal Loss + SWA</td></tr>
+  <tr><td><strong>Architecture</strong></td><td>EfficientNetV2-S + GeM Pooling + Focal Loss + SWA</td></tr>
   <tr><td><strong>Task</strong></td><td>Fine-Grained Image Classification (FGIC)</td></tr>
-  <tr><td><strong>Test Accuracy</strong></td><td>96.88%</td></tr>
-  <tr><td><strong>Classes</strong></td><td>8 (Barn, Bridge, Castle, Mosque, Skyscraper, Stadium, Temple, Windmill)</td></tr>
+  <tr><td><strong>Test Accuracy</strong></td><td>97.77%</td></tr>
+  <tr><td><strong>Classes</strong></td><td>8 (barn, bridge, castle, mosque, skyscraper, stadium, temple, windmill)</td></tr>
   <tr><td><strong>Input Size</strong></td><td>320 × 320 pixels</td></tr>
-  <tr><td><strong>Parameters</strong></td><td>9,466,953</td></tr>
+  <tr><td><strong>Parameters</strong></td><td>23,350,633</td></tr>
   <tr><td><strong>Framework</strong></td><td>TensorFlow / Keras 3</td></tr>
   <tr><td><strong>License</strong></td><td><a href="https://www.apache.org/licenses/LICENSE-2.0">Apache-2.0</a></td></tr>
 </table>
 
 ## Model Description
 
-A fine-grained image classification model for world architectural buildings. Built on DenseNet121 pretrained on ImageNet, enhanced with GeM Pooling (learnable generalized mean pooling), Focal Loss, Discriminative AdamW and Stochastic Weight Averaging (SWA). Extended with Grad-CAM explainability visualization, ROC-AUC evaluation, ECE calibration analysis, and t-SNE embedding visualization.
+A fine-grained image classification model for world architectural buildings. Built on EfficientNetV2-S pretrained on ImageNet, enhanced with GeM Pooling (learnable generalized mean pooling), Focal Loss, Discriminative AdamW and Stochastic Weight Averaging (SWA). Extended with Grad-CAM explainability visualization, ROC-AUC evaluation, ECE calibration analysis, and t-SNE embedding visualization.
 
 **Key architectural contributions:**
 
 - **GeM Pooling** (Radenovic et al., CVPR 2018) — replaces global average pooling with a learnable power parameter (p=3.0) that emphasizes high-activation features, yielding stronger discriminative representations for FGIC tasks
 - **Focal Loss** (Lin et al., ICCV 2017, gamma=2.0) — down-weights well-classified examples to focus gradient updates on hard-to-classify building pairs
-- **DiscriminativeAdamW** — extends AdamW with per-layer learning rate multipliers: conv4_block receives LR × 0.1 (pretrained features require smaller updates), while conv5_block and the custom head receive LR × 1.0
+- **DiscriminativeAdamW LR** — extends AdamW with per-variable LR scaling on block6 (×0.1) via update_step override, combined with selective fine-tuning (block6+top_conv unfrozen, BN frozen). LR scaling produces truly discriminative updates — block6 variables receive 10× smaller learning rate than head variables
 - **SWA with BN re-estimation** (Izmailov et al., UAI 2018) — 10-epoch post-training weight averaging with constant LR 1e-4, followed by 100-step batch normalization statistics re-estimation
-- **Grad-CAM** (Selvaraju et al., ICCV 2017) — gradient-weighted class activation mapping for explainability, targeting *conv5_block16_concat*
+- **Grad-CAM** (Selvaraju et al., ICCV 2017) — gradient-weighted class activation mapping for explainability, targeting *top_conv* (last Conv2D layer)
 - **ECE Calibration** (Guo et al., ICML 2017) — Expected Calibration Error with 15-bin reliability diagram to assess prediction confidence reliability
 
 ## Architecture
@@ -83,9 +99,9 @@ A fine-grained image classification model for world architectural buildings. Bui
 ```
 Input (320, 320, 3)
   │
-  DenseNet121 (ImageNet pretrained, 427 layers, 7.04M params)
+  EfficientNetV2-S (ImageNet pretrained, 513 layers, 20.33M params)
   │
-  Conv2D(256, 3×3, ReLU, padding=same)     →  2,359,552 params
+  Conv2D(256, 3×3, ReLU, padding=same)     →  2,949,376 params
   BatchNormalization                        →  1,024 params
   MaxPooling2D(2×2)                         →  0 params
   │
@@ -102,8 +118,8 @@ Output (8 classes)
 
 | Component | Output Shape | Parameters |
 |-----------|-------------|------------|
-| DenseNet121 (Functional) | (None, 10, 10, 1024) | 7,037,504 |
-| Conv2D 256 3×3 | (None, 10, 10, 256) | 2,359,552 |
+| EfficientNetV2-S (Functional) | (None, 10, 10, 1280) | 20,331,360 |
+| Conv2D 256 3×3 | (None, 10, 10, 256) | 2,949,376 |
 | BatchNormalization | (None, 10, 10, 256) | 1,024 |
 | MaxPooling2D 2×2 | (None, 5, 5, 256) | 0 |
 | GeM Pooling p=3.0 | (None, 256) | 1 |
@@ -111,10 +127,10 @@ Output (8 classes)
 | BatchNormalization | (None, 256) | 1,024 |
 | Dropout 0.4 | (None, 256) | 0 |
 | Dense 8 Softmax | (None, 8) | 2,056 |
-| **Total** | | **9,466,953** |
-| Trainable (Phase 1) | | **2,428,425** (9.27 MB) |
-| Trainable (Phase 2) | | **7,884,297** (30.07 MB) |
-| Non-trainable (Phase 1) | | **7,038,528** (26.85 MB) |
+| **Total** | | **23,350,633** |
+| Trainable (Phase 1) | | **3,018,249** (11.51 MB) |
+| Trainable (Phase 2) | | **17,810,225** (67.94 MB) |
+| Non-trainable (Phase 1) | | **20,332,384** (77.56 MB) |
 
 ## Performance
 
@@ -122,32 +138,32 @@ Output (8 classes)
 
 | Metric | Value |
 |--------|-------|
-| Test Accuracy | 96.88% |
-| Validation Accuracy (SWA) | 96.58% |
-| Test-Time Augmentation | 96.80% |
-| Test Loss | 0.4485 |
-| Overfitting Gap (Train − Test) | 3.00% |
-| Macro Avg Precision | 0.9691 |
-| Macro Avg Recall | 0.9688 |
-| Macro Avg F1-Score | 0.9687 |
-| Top-2 Accuracy | 98.59% |
-| Top-3 Accuracy | 99.33% |
-| Macro ROC-AUC (OvR) | 0.9986 |
-| ECE (15 bins) | 0.1438 |
+| Test Accuracy | 97.77% |
+| Validation Accuracy (SWA) | 98.36% |
+| Test-Time Augmentation | 97.99% |
+| Test Loss | 0.4262 |
+| Overfitting Gap (Train − Test) | 2.11% |
+| Macro Avg Precision | 0.9777 |
+| Macro Avg Recall | 0.9777 |
+| Macro Avg F1-Score | 0.9777 |
+| Top-2 Accuracy | 99.26% |
+| Top-3 Accuracy | 99.70% |
+| Macro ROC-AUC (OvR) | 0.9985 |
+| ECE (15 bins) | 0.1204 (pre-T-scaling; post-T-scaling: 0.0053, T=0.54) |
 
 ### Per-Class Results
 
-| Class | Precision | Recall | F1-Score | Support |
-|-------|-----------|--------|----------|---------|
-| Barn | 0.9645 | 0.9702 | 0.9674 | 168 |
-| Bridge | 0.9588 | 0.9702 | 0.9645 | 168 |
-| Castle | 0.9649 | 0.9821 | 0.9735 | 168 |
-| Mosque | 0.9649 | 0.9821 | 0.9735 | 168 |
-| Skyscraper | 0.9708 | 0.9881 | 0.9794 | 168 |
-| Stadium | 0.9936 | 0.9286 | 0.9600 | 168 |
-| Temple | 0.9816 | 0.9524 | 0.9668 | 168 |
-| Windmill | 0.9535 | 0.9762 | 0.9647 | 168 |
-| **Macro Avg** | **0.9691** | **0.9688** | **0.9687** | **1,344** |
+| Class | Precision | Recall | F1-Score | AUC (OvR) | Support |
+|-------|-----------|--------|----------|-----------|---------|
+| barn | 0.9760 | 0.9702 | 0.9731 | 0.9950 | 168 |
+| bridge | 0.9591 | 0.9762 | 0.9676 | 0.9983 | 168 |
+| castle | 0.9763 | 0.9821 | 0.9792 | 0.9996 | 168 |
+| mosque | 0.9763 | 0.9821 | 0.9792 | 0.9987 | 168 |
+| skyscraper | 0.9940 | 0.9940 | 0.9940 | 0.9999 | 168 |
+| stadium | 0.9820 | 0.9762 | 0.9791 | 0.9999 | 168 |
+| temple | 0.9816 | 0.9524 | 0.9668 | 0.9976 | 168 |
+| windmill | 0.9765 | 0.9881 | 0.9822 | 0.9987 | 168 |
+| **Macro Avg** | **0.9777** | **0.9777** | **0.9777** | **0.9985** | **1,344** |
 
 ### Model Selection
 
@@ -155,26 +171,26 @@ Four candidate models were evaluated on the validation set:
 
 | Checkpoint | Val Accuracy | Val Loss | Description |
 |------------|-------------|----------|-------------|
-| `best_phase1.keras` | 89.21% | 1.2231 | Phase 1 checkpoint (backbone frozen) |
-| `best_phase2.keras` | 92.04% | 0.6171 | Phase 2 checkpoint (conv4+conv5 unfrozen) |
-| `best_phase2_ema.keras` | 89.36% | 0.8183 | Phase 2 EMA shadow weights |
-| **`best_phase2_swa.keras`** | **96.58%** | **0.4256** | **SWA averaged weights ← SELECTED** |
+| `head_training.keras` | 92.34% | 1.0109 | Phase 1 checkpoint (backbone frozen) |
+| `fine_tuning.keras` | 96.28% | 0.5655 | Phase 2 checkpoint (block6+top_conv unfrozen) |
+| `fine_tuning_ema.keras` | 93.53% | 0.6007 | Phase 2 EMA (per-step Polyak averaging) |
+| **`fine_tuning_swa.keras`** | **98.36%** | **0.4109** | **SWA averaged weights ← SELECTED** |
 
 ### SWA Progression
 
 | SWA Epoch | Val Accuracy | Val Loss |
 |-----------|-------------|----------|
-| 1 | 93.38% | 0.5580 |
-| 2 | 93.60% | 0.5738 |
-| 3 | 92.86% | 0.5725 |
-| 4 | 95.24% | 0.4806 |
-| 5 | 95.68% | 0.4529 |
-| 6 | 96.35% | 0.4548 |
-| 7 | 94.27% | 0.5141 |
-| 8 | 94.12% | 0.5147 |
-| 9 | 94.49% | 0.5243 |
-| 10 | 96.50% | 0.4424 |
-| **SWA + BN (final)** | **96.58%** | **0.4256** |
+| 1 | 95.76% | 0.5831 |
+| 2 | 97.62% | 0.5116 |
+| 3 | 97.69% | 0.4748 |
+| 4 | 96.95% | 0.4390 |
+| 5 | 97.47% | 0.4490 |
+| 6 | 97.84% | 0.4416 |
+| 7 | 98.14% | 0.4055 |
+| 8 | 97.32% | 0.4359 |
+| 9 | 97.02% | 0.4519 |
+| 10 | 97.54% | 0.4226 |
+| **SWA + BN (final)** | **98.36%** | **0.4109** |
 
 ![Training Curves](results/training_curves.png)
 
@@ -194,14 +210,14 @@ Four candidate models were evaluated on the validation set:
 
 ## Training Details
 
-### Progressive Training
+### Training Strategy
 
-Two-phase strategy train with SWA post-processing:
+Two-phase progressive training with SWA post-processing:
 
 | Phase | Description | Backbone | Optimizer | LR | Max Epochs | Actual Epochs | CutMix+Mixup | FocalLoss LS |
 |-------|-------------|----------|-----------|-----|-----------|---------------|---------------|-------------|
 | **Phase 1** — Feature Extraction | Train custom head only | Frozen (all) | AdamW (wd=2e-5) | 0.001 + CosineDecay + Warmup 3ep | 25 | 1 | Yes (50/50 alternation) | 0.1 |
-| **Phase 2** — Selective Fine-Tuning | Load best_phase1 → fine-tune | conv4_block + conv5_block unfrozen (BN frozen) | DiscriminativeAdamW (conv4=0.1×) | 3e-4 + CosineDecay + Warmup 5ep | 50 | 6 + 10 SWA | No | 0.05 |
+| **Phase 2** — Selective Fine-Tuning | Load head_training → fine-tune | block6 + top_conv unfrozen (BN frozen) | DiscriminativeAdamW (block6=0.1×) | 3e-4 + CosineDecay + Warmup 5ep | 50 | 1 + 10 SWA | No | 0.05 |
 
 > ¹ Phase 1 stops when `val_accuracy ≥ 85%` threshold (myCallback).
 
@@ -215,13 +231,13 @@ Two-phase strategy train with SWA post-processing:
 | Learning Rate | 0.001 | 3×10⁻⁴ |
 | LR Schedule | WarmupCosineDecay (warmup=3) | WarmupCosineDecay (warmup=5) |
 | Weight Decay | 2×10⁻⁵ | 2×10⁻⁵ |
-| LR Multiplier (conv4) | — | 0.1× |
-| LR Multiplier (conv5+head) | — | 1.0× |
+| LR Multiplier (block6) | — | 0.1× (LR scaling via update_step, truly discriminative) |
+| LR Multiplier (top_conv+head) | — | 1.0× |
 | Loss | FocalLoss (gamma=2.0, LS=0.1) | FocalLoss (gamma=2.0, LS=0.05) |
 | Batch Size | 32 | 32 |
 | Early Stopping Patience | 7 | 12 |
 | myCallback Threshold | val_acc ≥ 0.85 | val_acc ≥ 0.92 |
-| EMA Decay | 0.999 | 0.999 |
+| EMA Decay (per-step) | 0.999 | 0.999 |
 | SWA Epochs | — | 10 (post-training) |
 | SWA LR | — | 1×10⁻⁴ (constant) |
 | BN Re-estimation Steps | — | 100 |
@@ -233,25 +249,26 @@ Two-phase strategy train with SWA post-processing:
 
 | Technique | Implementation | Reference |
 |-----------|---------------|-----------|
-| Transfer Learning | DenseNet121 backbone frozen in Phase 1 | Yosinski et al., NeurIPS 2014 |
-| Selective Fine-Tuning | Unfreeze conv4+conv5 only, BN stays frozen | Howard & Ruder, ACL 2018 |
-| Discriminative LR | conv4=0.1×, conv5+head=1.0× | Howard & Ruder, ACL 2018 |
+| Transfer Learning | EfficientNetV2-S backbone frozen in Phase 1 | Yosinski et al., NeurIPS 2014 |
+| Selective Fine-Tuning | Unfreeze block6+top_conv only, BN stays frozen | Howard & Ruder, ACL 2018 |
+| Discriminative LR Scaling | block6 LR×0.1 via update_step (truly discriminative — 10× smaller updates for pretrained features) | Howard & Ruder, ACL 2018 |
 | CutMix + Mixup | Alternation per batch (50/50), Phase 1 only | Yun et al., ICCV 2019; Zhang et al., ICLR 2018 |
 | Focal Loss | gamma=2.0, down-weights easy examples | Lin et al., ICCV 2017 |
 | Label Smoothing | 0.1 (Phase 1) → 0.05 (Phase 2) | Szegedy et al., CVPR 2016 |
 | GeM Pooling | p=3.0 learnable, replaces GAP | Radenovic et al., CVPR 2018 |
 | Dropout | 0.4 after Dense(256)+BN | Srivastava et al., JMLR 2014 |
 | Batch Normalization | After Conv2D and Dense; frozen during fine-tuning | Ioffe & Szegedy, arXiv 2015 |
-| EMA | Shadow weights, decay=0.999 | Tarvainen & Valpola, NeurIPS 2017 |
+| EMA (per-step) | Shadow weights, decay=0.999, Polyak averaging | Tarvainen & Valpola, NeurIPS 2017 |
 | SWA | 10-epoch post-training, constant LR 1e-4 | Izmailov et al., UAI 2018 |
-| Data Augmentation | Rotation ±15°, shift ±10%, zoom ±20%, brightness 0.75–1.15, horizontal flip | Perez & Wang, arXiv 2017 |
+| Data Augmentation | Rotation ±15°, shift ±10%, shear ±0.1 rad, zoom ±20%, brightness 0.75–1.15, channel shift ±10.0, horizontal flip | Perez & Wang, arXiv 2017 |
+| Random Erasing | p=0.5, area [0.02–0.15], aspect [0.3–3.3], applied pre-normalization | Zhong et al., AAAI 2020 |
 | Test-Time Augmentation | 6 augmentation variants, averaged | Shanmugam et al., ICML 2020 |
 | WarmupCosineDecay | Linear warmup + cosine annealing | Loshchilov & Hutter, ICLR 2017 (SGDR) |
 | Early Stopping | Patience 7 (Phase 1) / 12 (Phase 2) | Prechelt, Neural Networks 1998 |
 
 ### Dataset
 
-See more data studio curation [World Architectural Buildings Dataset for Multi‑Class Image Classification](https://huggingface.co/datasets/0xgr3y/arch-building-dataset) — 13,440 images (8 classes × 1,680, balanced) sourced from Pexels with perceptual (pHash) and exact (SHA256) deduplication.
+See the dataset curation page for [World Architectural Buildings Dataset for Multi‑Class Image Classification](https://huggingface.co/datasets/0xgr3y/arch-building-dataset) — 13,440 images (8 classes × 1,680, balanced) sourced from Pexels with perceptual (pHash) and exact (SHA256) deduplication.
 
 | Split | Images | Percentage |
 |-------|--------|------------|
@@ -261,7 +278,7 @@ See more data studio curation [World Architectural Buildings Dataset for Multi
 
 ### Data Preprocessing
 
-- **Normalization:** `preprocess_input` from `tf.keras.applications.densenet` (ImageNet distribution)
+- **Normalization:** `preprocess_input` from `tf.keras.applications.efficientnet_v2` (ImageNet distribution)
 - **Input resolution:** 320×320 (higher than ImageNet default 224×224 to capture fine-grained architectural details — textures, ornaments, facade patterns)
 - **Augmentation:** Applied to training set only; validation and test sets use clean preprocessing
 - **Split method:** `splitfolders.ratio` from `dataset/`, seed=42
@@ -270,19 +287,25 @@ See more data studio curation [World Architectural Buildings Dataset for Multi
 
 | File | Description |
 |------|-------------|
-| `best_phase2_swa.keras` | Best model — SWA averaged weights |
-| `best_phase2.keras` | Phase 2 checkpoint |
-| `saved_model/` | TensorFlow SavedModel format (portable, for TF Serving) |
-| `tflite/model.tflite` | TensorFlow Lite model (mobile/embedded) |
+| `fine_tuning_swa.keras` | Best model — SWA averaged weights (226.75 MB) |
+| `fine_tuning_swa.weights.h5` | Best model weights — clean, no ProtectAI flag (158.31 MB) |
+| `fine_tuning_swa.safetensors` | Best model weights — HF standard, cross-framework (157.10 MB) |
+| `build_model.py` | Architecture reconstruction + CLI inference (20.7 KB) |
+| `head_training.keras` | Phase 1 checkpoint |
+| `fine_tuning.keras` | Phase 2 checkpoint |
+| `fine_tuning_ema.keras` | Phase 2 EMA checkpoint |
+| `saved_model/` | TensorFlow SavedModel format (183.29 MB, for TF Serving) |
+| `tflite/model.tflite` | TensorFlow Lite model (88.36 MB, mobile/embedded) |
 | `tflite/label.txt` | Class label names for TF-Lite |
-| `tfjs_model/` | TensorFlow.js model (browser, 10 weight shards + model.json) |
+| `tfjs_model/` | TensorFlow.js model (89.54 MB, 23 shards + model.json) |
 | `config.json` | Model configuration and evaluation metrics |
 | `label_mapping.json` | Class name ↔ ID mapping with training config and architecture info |
 | `preprocessor_config.json` | Input preprocessing specification (320×320) |
 | `confusion_pairs.json` | Auto-detected confusion pairs from confusion matrix (threshold >5%) |
 | `class_confidence_stats.json` | Per-class mean/std/p5/p95 confidence distribution |
 | `model_benchmark.json` | Model parameters, sizes, speed, Top-K, AUC, ECE, TTA metrics |
-| `calibration_data.json` | ECE, bin accuracies/confidences, per-class AUC for calibration analysis |
+| `calibration_data.json` | ECE, bin accuracies/confidences, per-class AUC, Temperature Scaling (T_opt) for calibrated inference |
+| `temperature_config.json` | Temperature Scaling parameters (T, ECE before/after, method) — Guo et al., ICML 2017 |
 | `results/training_curves.png` | Training/validation accuracy and loss curves |
 | `results/confusion_matrix.png` | Confusion matrix on test set |
 | `results/per_class_accuracy.png` | Per-class accuracy bar chart |
@@ -300,127 +323,41 @@ See more data studio curation [World Architectural Buildings Dataset for Multi
 
 ### Gradio Space
 
-Try the live classify building: [Architecture Building Image Classifier with Space](https://huggingface.co/spaces/0xgr3y/arch-building-classifier)
+Try the live building classifier: [Architecture Building Image Classifier with Space](https://huggingface.co/spaces/0xgr3y/arch-building-classifier)
 
-### Python — Keras
+### Python — build_model.py (recommended)
 
-```python
-from huggingface_hub import hf_hub_download
-import tensorflow as tf
-from tensorflow.keras.applications.densenet import preprocess_input
-from tensorflow.keras.layers import Layer
-from PIL import Image
-import numpy as np
+`build_model.py` is a standalone module that provides:
+- **Custom class definitions** (`GeMPooling`, `FocalLoss`, `DiscriminativeAdamW`) with `@register_keras_serializable` — importing the module registers all custom classes globally, so `load_model()` works without explicit `custom_objects`.
+- **`ArchBuildingClassifier`** — high-level wrapper class with `build()`, `from_weights()`, `from_keras()`, `predict()`, `predict_batch()` methods.
+- **`CUSTOM_OBJECTS`** dict — fallback for explicit `custom_objects=` in `load_model()`.
+- **`build_model()`** — backward-compatible function that returns a raw `tf.keras.Model`.
 
-# ========---Custom Layers (must match training definition)---========
-
-class GeMPooling(Layer):
-    def __init__(self, p=3.0, eps=1e-6, **kwargs):
-        super().__init__(**kwargs)
-        self.p_init = p
-        self.eps = eps
-    def build(self, input_shape):
-        self.p = self.add_weight(name="gem_p", shape=(), dtype=tf.float32,
-            initializer=tf.keras.initializers.Constant(self.p_init), trainable=True)
-        super().build(input_shape)
-    def call(self, x):
-        x = tf.maximum(x, self.eps)
-        x = tf.pow(x, self.p)
-        x = tf.reduce_mean(x, axis=[1, 2], keepdims=False)
-        return tf.pow(x, 1.0 / self.p)
-    def get_config(self):
-        return {**super().get_config(), "p": self.p_init, "eps": self.eps}
-
-class FocalLoss(tf.keras.losses.Loss):
-    def __init__(self, gamma=2.0, alpha=None, label_smoothing=0.0, **kwargs):
-        super().__init__(**kwargs)
-        self.gamma = gamma
-        self.alpha = alpha
-        self.label_smoothing = label_smoothing
-    def call(self, y_true, y_pred):
-        y_pred = tf.clip_by_value(y_pred, 1e-7, 1.0 - 1e-7)
-        if self.label_smoothing > 0:
-            y_true = y_true * (1.0 - self.label_smoothing) + \
-                (self.label_smoothing / tf.cast(tf.shape(y_true)[-1], tf.float32))
-        ce = -y_true * tf.math.log(y_pred)
-        weight = tf.pow(1.0 - y_pred, self.gamma)
-        fl = weight * ce
-        if self.alpha is not None:
-            alpha_t = y_true * self.alpha
-            fl = alpha_t * fl
-        return tf.reduce_mean(tf.reduce_sum(fl, axis=-1))
-    def get_config(self):
-        return {**super().get_config(), "gamma": self.gamma,
-                "alpha": self.alpha, "label_smoothing": self.label_smoothing}
-
-class DiscriminativeAdamW(tf.keras.optimizers.AdamW):
-    def __init__(self, lr_multipliers=None, backbone_layer_idx=0, **kwargs):
-        super().__init__(**kwargs)
-        self.lr_multipliers = lr_multipliers or {}
-        self.backbone_layer_idx = backbone_layer_idx
-        self._var_mult_cache = {}
-    def _build_var_cache(self, model):
-        self._var_mult_cache = {}
-        base_model = model.layers[self.backbone_layer_idx]
-        for layer in base_model.layers:
-            mult = 1.0
-            for pattern, m in self.lr_multipliers.items():
-                if pattern in layer.name:
-                    mult = m
-                    break
-            for var in layer.trainable_variables:
-                self._var_mult_cache[id(var)] = mult
-    def _get_multiplier(self, var):
-        return self._var_mult_cache.get(id(var), 1.0)
-    def apply_gradients(self, grads_and_vars, **kwargs):
-        scaled_gv = []
-        for grad, var in grads_and_vars:
-            if grad is not None:
-                mult = self._get_multiplier(var)
-                if mult != 1.0:
-                    grad = grad * tf.cast(mult, grad.dtype)
-                scaled_gv.append((grad, var))
-            else:
-                scaled_gv.append((grad, var))
-        return super().apply_gradients(scaled_gv, **kwargs)
-    def get_config(self):
-        return {**super().get_config(), "lr_multipliers": self.lr_multipliers,
-                "backbone_layer_idx": self.backbone_layer_idx}
-
-# =====================---Load Model---==========================
-
-LABELS_PATH = hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "label_mapping.json")
-import json
-with open(LABELS_PATH) as f:
-    LABELS = json.load(f)["labels"]
-# ["barn","bridge","castle","mosque","skyscraper","stadium","temple","windmill"]
+Upload `build_model.py` to the same directory as your script or add it to `PYTHONPATH`.
 
-custom_objects = {
-    "GeMPooling": GeMPooling,
-    "FocalLoss": FocalLoss,
-    "DiscriminativeAdamW": DiscriminativeAdamW,
-}
+> **Note:** Filenames below use `fine_tuning_swa` as an example. The actual best checkpoint filename depends on training results — check the repo for the actual `.keras`, `.weights.h5`, and `.safetensors` filenames.
 
-model_path = hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "best_phase2_swa.keras")
-model = tf.keras.models.load_model(model_path, custom_objects=custom_objects, compile=False)
-
-# =======================---Inference---==========================
+```python
+from build_model import ArchBuildingClassifier
+from huggingface_hub import hf_hub_download
 
-img = Image.open("skyscraper_00000.jpg").convert("RGB").resize((320, 320))
-arr = np.expand_dims(preprocess_input(np.array(img, dtype=np.float32)), axis=0)
-preds = model.predict(arr, verbose=0)[0]
-print(f"Predicted: {LABELS[np.argmax(preds)]} ({np.max(preds)*100:.1f}%)")
-```
+# Download weights (clean format)
+weights_path = hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "fine_tuning_swa.weights.h5")
 
-### Python — TensorFlow Lite
+# Load model: architecture + weights
+clf = ArchBuildingClassifier.from_weights(weights_path)
 
-Download the model first:
-```python
-from huggingface_hub import hf_hub_download
-hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "tflite/model.tflite", local_dir=".")
-hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "tflite/label.txt", local_dir=".")
+# Inference
+from PIL import Image
+import numpy as np
+label, confidence, top3 = clf.predict(Image.open("skyscraper_00000.jpg"))
+print(f"Predicted: {label} ({confidence:.1%})")
+for cls, prob in top3:
+    print(f"  {cls}: {prob:.1%}")
 ```
 
+### Python — TF-Lite (fastest inference)
+
 ```python
 import numpy as np
 import tensorflow as tf
@@ -428,19 +365,26 @@ from huggingface_hub import hf_hub_download
 from PIL import Image
 import json
 
+try:
+    from tensorflow.keras.applications.efficientnet_v2 import preprocess_input
+except (ImportError, ModuleNotFoundError):
+    from tensorflow.keras.applications.efficientnet import preprocess_input
+
+# Download
+model_path = hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "tflite/model.tflite")
 labels_path = hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "label_mapping.json")
+
 with open(labels_path) as f:
     LABELS = json.load(f)["labels"]
 
-interpreter = tf.lite.Interpreter(model_path="tflite/model.tflite")
+interpreter = tf.lite.Interpreter(model_path=model_path)
 interpreter.allocate_tensors()
-
 input_details = interpreter.get_input_details()
 output_details = interpreter.get_output_details()
 
 img = Image.open("skyscraper_00000.jpg").convert("RGB").resize((320, 320))
-arr = np.expand_dims(np.array(img, dtype=np.float32), axis=0)
-arr = tf.keras.applications.densenet.preprocess_input(arr)
+arr = np.expand_dims(preprocess_input(
+    np.array(img, dtype=np.float32)), axis=0)
 
 interpreter.set_tensor(input_details[0]["index"], arr)
 interpreter.invoke()
@@ -451,39 +395,135 @@ for i in top3_idx:
     print(f"  {LABELS[i]}: {preds[i]*100:.1f}%")
 ```
 
-### Python — SavedModel
-
-Download the model first:
-```python
-from huggingface_hub import snapshot_download
-snapshot_download("0xgr3y/Arch-Building-Image-Classification", allow_patterns=["saved_model/*"], local_dir=".")
-```
-
-Requires the custom layer definitions from the Keras section above.
+### Python — Keras (convenient)
 
 ```python
+import build_model  # registers custom classes via @register_keras_serializable
 import tensorflow as tf
-import numpy as np
 from huggingface_hub import hf_hub_download
+try:
+    from tensorflow.keras.applications.efficientnet_v2 import preprocess_input
+except (ImportError, ModuleNotFoundError):
+    from tensorflow.keras.applications.efficientnet import preprocess_input
 from PIL import Image
+import numpy as np
 import json
 
+model_path = hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "fine_tuning_swa.keras")
 labels_path = hf_hub_download("0xgr3y/Arch-Building-Image-Classification", "label_mapping.json")
-with open(labels_path) as f:
-    LABELS = json.load(f)["labels"]
 
-custom_objects = {"GeMPooling": GeMPooling, "FocalLoss": FocalLoss,
-                  "DiscriminativeAdamW": DiscriminativeAdamW}
+model = tf.keras.models.load_model(model_path, compile=False)  # custom_objects not needed
 
-model = tf.keras.models.load_model("saved_model", custom_objects=custom_objects, compile=False)
+with open(labels_path) as f:
+    LABELS = json.load(f)["labels"]
 
 img = Image.open("skyscraper_00000.jpg").convert("RGB").resize((320, 320))
-arr = np.expand_dims(tf.keras.applications.densenet.preprocess_input(
-    np.array(img, dtype=np.float32)), axis=0)
+arr = np.expand_dims(preprocess_input(np.array(img, dtype=np.float32)), axis=0)
 preds = model.predict(arr, verbose=0)[0]
 print(f"Predicted: {LABELS[np.argmax(preds)]} ({np.max(preds)*100:.1f}%)")
 ```
 
+### Python — SavedModel (TF Serving)
+
+```python
+from huggingface_hub import snapshot_download
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+
+try:
+    from tensorflow.keras.applications.efficientnet_v2 import preprocess_input
+except (ImportError, ModuleNotFoundError):
+    from tensorflow.keras.applications.efficientnet import preprocess_input
+
+snapshot_download("0xgr3y/Arch-Building-Image-Classification", allow_patterns=["saved_model/*"], local_dir=".")
+
+# Load SavedModel (created via model.export() — inference-only, no custom_objects needed)
+loaded = tf.saved_model.load("saved_model")
+
+img = Image.open("skyscraper_00000.jpg").convert("RGB").resize((320, 320))
+arr = tf.constant(np.expand_dims(preprocess_input(np.array(img, dtype=np.float32)), axis=0))
+preds = loaded(arr).numpy()[0]
+
+top3_idx = np.argsort(preds)[::-1][:3]
+for i in top3_idx:
+    print(f"  Class {i}: {preds[i]*100:.1f}%")
+```
+
+### Python — safetensors (HF standard, cross-framework)
+
+> **Note:** safetensors stores raw weight tensors without architecture metadata. To load, reconstruct the architecture with `build_model.py` first, then map tensors manually. For most use cases, `.weights.h5` (via `ArchBuildingClassifier.from_weights()`) is simpler and equally clean.
+
+```python
+from safetensors.numpy import load_file
+from build_model import ArchBuildingClassifier
+from PIL import Image
+
+# Reconstruct architecture
+clf = ArchBuildingClassifier.build()
+
+# Load safetensors tensors
+tensors = load_file("fine_tuning_swa.safetensors")
+
+# Map tensors to model weights (iterate layers, not .variables — Keras 3 compatible)
+for layer in clf.keras_model.layers:
+    for w in layer.weights:
+        name = w.name.replace(':', '_').replace('/', '_')
+        if name in tensors:
+            w.assign(tensors[name])
+
+# Inference
+label, confidence, top3 = clf.predict(Image.open("skyscraper_00000.jpg"))
+```
+
+## Inference Verification
+
+Keras vs TFLite consistency was verified on 8 random test samples (1 per class):
+
+| Metric | Result |
+|--------|--------|
+| Keras correct | 7/8 (88%) |
+| TFLite correct | 7/8 (88%) |
+| Keras vs TFLite match | **8/8 (100%)** — identical predictions |
+| Keras inference speed | 358.0 ms |
+| TFLite inference speed | 170.0 ms |
+
+> The 1 misclassification (castle→barn, 65% confidence) is consistent with the 97.77% test accuracy. The 8/8 match confirms TFLite conversion preserves model behavior exactly.
+
+## Security Notice (PAIT-KERAS-301)
+
+The `.keras` files in this repository are flagged **"Unsafe"** by [Protect AI Guardian](https://protectai.com/insights/models/0xgr3y/Arch-Building-Image-Classification) (threat: PAIT-KERAS-301). This is a **structural false positive**, not a malware detection:
+
+- **What the scanner checks:** String-matching of `class_name` fields in the Keras v3 config against a whitelist of built-in Keras layers.
+- **Why flagged:** The model contains a custom layer (`GeMPooling`) — a non-standard class name triggers the flag.
+- **What it does NOT check:** The scanner does not analyze the Python code of the custom class, does not look for `eval()`/`exec()`/`os.system()`, and does not detect actual malware.
+- **Other scanners:** VirusTotal ✅, JFrog ✅, HF Picklescan ✅ — all clean. Only Protect AI flags this file.
+
+**The custom classes are safe and open source:**
+- `GeMPooling` — Generalized Mean Pooling (Radenovic et al., CVPR 2018). Pure tensor ops: `tf.pow`, `tf.reduce_mean`, `tf.maximum`.
+- `FocalLoss` — Focal Loss (Lin et al., ICCV 2017). Pure tensor ops.
+- `DiscriminativeAdamW` — AdamW subclass with gradient scaling. No file I/O, no network calls, no arbitrary code.
+
+Full source code for all custom classes is available in [`build_model.py`](https://huggingface.co/0xgr3y/Arch-Building-Image-Classification/blob/main/build_model.py) and the training notebook for public audit.
+
+## Multi-Format Deployment Guide
+
+This model is provided in multiple formats to suit different deployment scenarios. Formats marked ✅ are **not flagged** by Protect AI (no custom class serialization).
+
+| Format | File | Size | Protect AI | Inference Speed | Best For |
+|--------|------|------|------------|-----------------|----------|
+| **TF-Lite** ✅ | `tflite/model.tflite` | ~88 MB | ✅ Safe | **170.0 ms** (fastest) | Mobile, edge, embedded, HF Space |
+| **SavedModel** ✅ | `saved_model/` | ~183 MB | ✅ Safe | — | TensorFlow Serving, cloud backend |
+| **TFJS** ✅ | `tfjs_model/` | ~90 MB | ✅ Safe | — | Browser, Node.js (no backend) |
+| **Weights H5** ✅ | `fine_tuning_swa.weights.h5` | ~158 MB | ✅ Safe | — | Programmatic load via `build_model.py` |
+| **safetensors** ✅ | `fine_tuning_swa.safetensors` | ~157 MB | ✅ Safe | — | HF standard, cross-framework |
+| **Build Script** ✅ | `build_model.py` | ~21 KB | ✅ Safe | — | Architecture reconstruction + `load_weights()` |
+| **Keras** ⚠️ | `fine_tuning_swa.keras` | ~227 MB | ⚠️ Flagged | 358.0 ms | Developer reference, fine-tuning |
+
+### Load Examples
+
+See **Usage** section above for complete load + inference examples for each format.
+
 ## Intended Use
 
 - Architectural style classification from building photographs
@@ -496,6 +536,7 @@ print(f"Predicted: {LABELS[np.argmax(preds)]} ({np.max(preds)*100:.1f}%)")
 - Trained on Pexels stock photography — performance may differ on user-generated or field photographs
 - Limited to 8 architectural classes (barn, bridge, castle, mosque, skyscraper, stadium, temple, windmill)
 - Confusion pair analysis found **0 significant pairs** (threshold >5%) — all 8 classes are well-distinguished by the model; see `confusion_pairs.json` for details
+- Barn and windmill share 3 cross-class duplicates (0.02% of dataset) — left as-is due to negligible impact
 - Inference confidence can be low on atypical examples
 
 ![Misclassification Examples](results/misclassification_examples.png)
@@ -512,11 +553,11 @@ print(f"Predicted: {LABELS[np.argmax(preds)]} ({np.max(preds)*100:.1f}%)")
 
 - **Gradio Space (Live):** [arch-building-classifier Space](https://huggingface.co/spaces/0xgr3y/arch-building-classifier)
 - **Dataset Studio:** [0xgr3y/arch-building-dataset](https://huggingface.co/datasets/0xgr3y/arch-building-dataset)
-- **GitHub Repo:** [arcxteam/arch-building-classifier](https://github.com/arcxteam/arch-building-classifier)
+- **GitHub Repo:** [arcxteam/building-architectural-image-classifier](https://github.com/arcxteam/building-architectural-image-classifier)
 
 ## References
 
-1. Huang, G., Liu, Z., Van Der Maaten, L., & Weinberger, K. Q. (2017). Densely Connected Convolutional Networks. *CVPR 2017*. [arXiv:1608.06993](https://arxiv.org/abs/1608.06993)
+1. Tan, M., & Le, Q. V. (2021). EfficientNetV2: Smaller Models and Faster Training. *ICML 2021*. [arXiv:2104.00298](https://arxiv.org/abs/2104.00298)
 2. Radenovic, F., Tolias, G., & Chum, O. (2018). Fine-Tuning CNN Image Retrieval with No Human Annotation. *IEEE TPAMI*. [arXiv:1711.02512](https://arxiv.org/abs/1711.02512)
 3. Lin, T.-Y., Goyal, P., Girshick, R., He, K., & Dollar, P. (2017). Focal Loss for Dense Object Detection. *ICCV 2017*. [arXiv:1708.02002](https://arxiv.org/abs/1708.02002)
 4. Izmailov, P., Podoprikhin, D., Garipov, T., Vetrov, D., & Wilson, A. G. (2018). Averaging Weights Leads to Wider Optima and Better Generalization. *UAI 2018*. [arXiv:1803.05407](https://arxiv.org/abs/1803.05407)
@@ -544,7 +585,7 @@ print(f"Predicted: {LABELS[np.argmax(preds)]} ({np.max(preds)*100:.1f}%)")
 ```bibtex
 @misc{saugani2026_arch_building,
   title={Fine-Grained Image Classification of World Architecture:
-         A DenseNet121 Transfer Learning Approach with Layered Regularization},
+         An EfficientNetV2-S Transfer Learning Approach with Layered Regularization},
   author={Saugani},
   year={2026},
   publisher={Hugging Face},