0xgr3y/Arch-Building-Image-Classification

Fine-Grained World Architecture Image Classification: A DenseNet121 Transfer Learning Approach with Layered Regularization

Architectural Building Image Classifier

Fine-Grained Visual Classification (FGVC) 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.

Architecture	DenseNet121 + GeM Pooling + Focal Loss + SWA
Task	Fine-Grained Visual Classification (FGVC)
Test Accuracy	96.88%
Classes	8 (Barn, Bridge, Castle, Mosque, Skyscraper, Stadium, Temple, Windmill)
Input Size	320 × 320 pixels
Parameters	9,466,953
Framework	TensorFlow / Keras 3
License	Apache-2.0

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.

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 FGVC 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
• 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
• ECE Calibration (Guo et al., ICML 2017) — Expected Calibration Error with 15-bin reliability diagram to assess prediction confidence reliability

Architecture

Input (320, 320, 3)
  │
  DenseNet121 (ImageNet pretrained, 427 layers, 7.04M params)
  │
  Conv2D(256, 3×3, ReLU, padding=same)     →  2,359,552 params
  BatchNormalization                        →  1,024 params
  MaxPooling2D(2×2)                         →  0 params
  │
  GeM Pooling(p=3.0, eps=1e-6, learnable)  →  1 param
  │
  Dense(256, ReLU)                          →  65,792 params
  BatchNormalization                        →  1,024 params
  Dropout(0.4)                              →  0 params
  │
  Dense(8, Softmax)                         →  2,056 params
  │
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
BatchNormalization	(None, 10, 10, 256)	1,024
MaxPooling2D 2×2	(None, 5, 5, 256)	0
GeM Pooling p=3.0	(None, 256)	1
Dense 256 ReLU	(None, 256)	65,792
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)

Performance

Overall Metrics

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

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

Model Selection

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

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

Training Details

Training Strategy

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 1 stops when val_accuracy ≥ 85% threshold (myCallback).

² Phase 2 stops when val_accuracy ≥ 92% threshold (myCallback), followed by 10 SWA epochs (constant LR 1e-4).

Hyperparameters

Parameter	Phase 1	Phase 2
Optimizer	AdamW	DiscriminativeAdamW
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×
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
SWA Epochs	—	10 (post-training)
SWA LR	—	1×10⁻⁴ (constant)
BN Re-estimation Steps	—	100
CutMix (alpha=1.0)	Yes (50% batches)	No
Mixup (alpha=0.2)	Yes (50% batches)	No
Hardware	2× Tesla T4 (MirroredStrategy)	2× Tesla T4 (MirroredStrategy)

Regularization Strategy

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

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
Train	10,752	80%
Validation	1,344	10%
Test	1,344	10%

Data Preprocessing

• Normalization: preprocess_input from tf.keras.applications.densenet (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

Files

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)
tflite/label.txt	Class label names for TF-Lite
tfjs_model/	TensorFlow.js model (browser, 10 weight 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
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
results/reliability_diagram.png	ECE calibration reliability diagram (15 bins)
results/roc_curves.png	Per-class ROC curves (One-vs-Rest)
results/tsne_embedding.png	t-SNE 2D scatter plot from GeM Pooling features
results/gradcam_heatmaps.png	Grad-CAM heatmap visualization per class
results/confidence_per_class.png	Per-class confidence distribution bar chart
results/misclassification_examples.png	Misclassified test samples
results/augmentation_examples.png	Example images after augmentation (training set)
results/inference_keras.png	Keras inference grid — 1 sample per class
results/inference_tflite.png	TF-Lite inference grid — 1 sample per class

Usage

Gradio Space

Try the live inference: arch-building-classifier Space

Python — Keras

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

# ========---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"]

custom_objects = {
    "GeMPooling": GeMPooling,
    "FocalLoss": FocalLoss,
    "DiscriminativeAdamW": DiscriminativeAdamW,
}

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

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}%)")

Python — TensorFlow Lite

Download the model first:

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

import numpy as np
import tensorflow as tf
from huggingface_hub import hf_hub_download
from PIL import Image
import json

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

interpreter.set_tensor(input_details[0]["index"], arr)
interpreter.invoke()
preds = interpreter.get_tensor(output_details[0]["index"])[0]

top3_idx = np.argsort(preds)[::-1][:3]
for i in top3_idx:
    print(f"  {LABELS[i]}: {preds[i]*100:.1f}%")

Python — SavedModel

Download the model first:

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.

import tensorflow as tf
import numpy as np
from huggingface_hub import hf_hub_download
from PIL import Image
import json

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("saved_model", custom_objects=custom_objects, compile=False)

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)
preds = model.predict(arr, verbose=0)[0]
print(f"Predicted: {LABELS[np.argmax(preds)]} ({np.max(preds)*100:.1f}%)")

Intended Use

• Architectural style classification from building photographs
• Educational tool for architecture recognition
• Research baseline for fine-grained visual classification (FGVC)
• Transfer learning experiments on architectural imagery

Limitations

• 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

Ethical Considerations

• All training images sourced from Pexels.com under the Pexels License (free for commercial use, no attribution required). No copyrighted or personally identifiable images were used.
• The dataset contains only photographs of buildings and structures — no people, faces, or private property are the subject of classification.
• The model reflects the visual distribution of Pexels stock photography, which may over-represent Western and iconic architectural styles and under-represent vernacular or regional architecture.
• The 8 class categories are broad and do not capture the full diversity of world architecture. Results should not be used to make definitive claims about architectural categorization.
• URL pattern filtering during dataset collection explicitly excluded AI-generated art, illustrations, and non-photographic content to ensure authenticity.

Links

• Gradio Space (Live): arch-building-classifier Space
• Dataset: 0xgr3y/arch-building-dataset
• GitHub: arcxteam/arch-building-classifier

References

1. Huang, G., Liu, Z., Van Der Maaten, L., & Weinberger, K. Q. (2017). Densely Connected Convolutional Networks. CVPR 2017. arXiv:1608.06993
2. Radenovic, F., Tolias, G., & Chum, O. (2018). Fine-Tuning CNN Image Retrieval with No Human Annotation. IEEE TPAMI. arXiv: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
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
5. Zhang, H., Cisse, M., Dauphin, Y. N., & Lopez-Paz, D. (2018). mixup: Beyond Empirical Risk Minimization. ICLR 2018. arXiv:1710.09412
6. Yun, S., Han, D., Oh, S. J., Chun, S., Choe, J., & Yoo, Y. (2019). CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features. ICCV 2019. arXiv:1905.04899
7. Szegedy, C., Vanhoucke, V., Ioffe, S., Shlens, J., & Wojna, Z. (2016). Rethinking the Inception Architecture for Computer Vision. CVPR 2016. arXiv:1512.00567
8. Yosinski, J., Clune, J., Bengio, Y., & Lipson, H. (2014). How Transferable Are Features in Deep Neural Networks? NeurIPS 2014. arXiv:1411.1792
9. Howard, J., & Ruder, S. (2018). Universal Language Model Fine-tuning for Text Classification. ACL 2018. arXiv:1801.06146
10. Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., & Salakhutdinov, R. (2014). Dropout: A Simple Way to Prevent Neural Networks from Overfitting. JMLR, 15(56), 1929–1958. http://jmlr.org/papers/v15/srivastava14a.html
11. Ioffe, S., & Szegedy, C. (2015). Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. arXiv preprint. arXiv:1502.03167
12. Tarvainen, A., & Valpola, H. (2017). Mean Teachers are Better Role Models: Weight-averaged Consistency Targets Improve Semi-supervised Deep Learning Results. NeurIPS 2017. arXiv:1703.01780
13. Perez, L., & Wang, J. (2017). The Effectiveness of Data Augmentation in Image Classification using Deep Learning. arXiv preprint. arXiv:1712.04621
14. Shanmugam, D., Blalock, D., Balakrishnan, G., Guttag, J., & Sarma, A. (2020). Towards Principled Test-Time Augmentation. ICML 2020. PDF
15. Loshchilov, I., & Hutter, F. (2017). SGDR: Stochastic Gradient Descent with Warm Restarts. ICLR 2017. arXiv:1608.03983
16. Prechelt, L. (1998). Automatic Early Stopping Using Cross Validation: Quantifying the Criteria. Neural Networks, 11(4), 761–767. https://doi.org/10.1016/S0893-6080(98)00010-0
17. Guo, C., Pleiss, G., Sun, Y., & Weinberger, K. Q. (2017). On Calibration of Modern Neural Networks. ICML 2017. arXiv:1706.04599
18. Selvaraju, R. R., Cogswell, M., Das, A., Vedantam, R., Parikh, D., & Batra, D. (2017). Grad-CAM: Visual Explanations from Deep Networks via Gradient-based Localization. ICCV 2017. arXiv:1610.02391
19. van der Maaten, L., & Hinton, G. (2008). Visualizing Data using t-SNE. JMLR, 9(Nov), 2579–2605. http://jmlr.org/papers/v9/vandermaaten08a.html
20. Hand, D. J., & Till, R. J. (2001). A Simple Generalisation of the Area Under the ROC Curve for Multiple Class Classification Problems. Machine Learning, 45(2), 171–186. https://doi.org/10.1023/A:1010920819831
21. Russakovsky, O., Deng, J., Su, H., Krause, J., Satheesh, S., Ma, S., ... & Fei-Fei, L. (2015). ImageNet Large Scale Visual Recognition Challenge. IJCV, 115(3), 211–252. arXiv:1409.0575
22. Lakshminarayanan, B., Pritzel, A., & Blundell, C. (2017). Simple and Scalable Predictive Uncertainty Estimation using Deep Ensembles. NeurIPS 2017. arXiv:1612.01474

Citation

@misc{saugani2026_arch_building,
  title={Fine-Grained World Architecture Image Classification:
         A DenseNet121 Transfer Learning Approach with Layered Regularization},
  author={Saugani},
  year={2026},
  publisher={Hugging Face},
  url={https://huggingface.co/0xgr3y/Arch-Building-Image-Classification}
}