Upload folder using huggingface_hub

.virtual_documents/__notebook_source__.ipynb

@@ -0,0 +1,668 @@
+# This Python 3 environment comes with many helpful analytics libraries installed
+# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python
+# For example, here's several helpful packages to load
+
+import numpy as np # linear algebra
+import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
+
+# Input data files are available in the read-only "../input/" directory
+# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory
+
+import os
+for dirname, _, filenames in os.walk('/kaggle/input'):
+    for filename in filenames:
+        print(os.path.join(dirname, filename))
+
+# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using "Save & Run All" 
+# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session
+
+# Use the kagglehub client library to attach Kaggle resources like competitions, datasets, and models to your session
+# Learn more about kagglehub: https://github.com/Kaggle/kagglehub/blob/main/README.md
+
+import kagglehub
+# kagglehub.dataset_download('<owner>/<dataset-slug>')
+
+
+get_ipython().getoutput("pip install git+https://github.com/jacobgil/pytorch-grad-cam.git -q")
+
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+from PIL import Image
+import copy
+import os
+import shutil
+import random
+
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix , f1_score
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.cuda.amp as amp  
+import torchvision.models as models
+import torchvision.transforms as transforms
+import torchvision.datasets as datasets
+from torchvision.datasets import ImageFolder
+from torch.utils.data import DataLoader ,Dataset
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+from tqdm import tqdm
+from tqdm.auto import tqdm
+from torchvision.models import efficientnet_b3  
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+
+import warnings
+warnings.filterwarnings("ignore")
+
+
+original_dirs = {
+    'Calculus': '/kaggle/input/datasets/salmansajid05/oral-diseases/Calculus/Calculus',
+    'Caries': '/kaggle/input/datasets/salmansajid05/oral-diseases/Data caries/Data caries/caries augmented data set/preview',
+    'Gingivitis': '/kaggle/input/datasets/salmansajid05/oral-diseases/Gingivitis/Gingivitis',
+    'Ulcers': '/kaggle/input/datasets/salmansajid05/oral-diseases/Mouth Ulcer/Mouth Ulcer/Mouth_Ulcer_augmented_DataSet/preview',
+    'Tooth Discoloration': '/kaggle/input/datasets/salmansajid05/oral-diseases/Tooth Discoloration/Tooth Discoloration /Tooth_discoloration_augmented_dataser/preview',
+    'Hypodontia': '/kaggle/input/datasets/salmansajid05/oral-diseases/hypodontia/hypodontia'
+}
+
+
+DATA_DIR = "/kaggle/working/oral_dataset"
+splits = ['train', 'val', 'test']
+classes = list(original_dirs.keys())
+classes
+
+
+import os
+import shutil
+
+NEW_DATASET = "/kaggle/working/oral_dataset"
+
+os.makedirs(NEW_DATASET, exist_ok=True)
+
+for class_name, source_dir in original_dirs.items():
+
+    target_dir = os.path.join(NEW_DATASET, class_name)
+    os.makedirs(target_dir, exist_ok=True)
+
+    for file in os.listdir(source_dir):
+        if file.lower().endswith((".jpg", ".jpeg", ".png")):
+            shutil.copy(
+                os.path.join(source_dir, file),
+                os.path.join(target_dir, file)
+            )
+
+print("Done")
+
+
+full_dataset = datasets.ImageFolder(root=DATA_DIR)
+
+CLASS_NAMES = full_dataset.classes
+NUM_CLASSES = len(CLASS_NAMES)
+
+
+DATA_DIR = original_dirs  
+
+CHECKPOINT_DIR = "./checkpoints"     
+OUTPUT_DIR = "./outputs"           
+os.makedirs(CHECKPOINT_DIR, exist_ok=True)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+IMG_SIZE = 224
+BATCH_SIZE = 32
+NUM_WORKERS = 4
+TRAIN_RATIO, VAL_RATIO, TEST_RATIO = 0.8, 0.1, 0.1
+SEED = 42
+
+EPOCHS = 30                      
+LR_SCRATCH = 1e-3                 
+LR_PRETRAINED_HEAD = 1e-3          
+LR_PRETRAINED_FINETUNE = 1e-5     
+
+WEIGHT_DECAY = 1e-4        
+LABEL_SMOOTHING = 0.1      
+DROPOUT = 0.4
+
+EARLY_STOPPING_PATIENCE = 2
+FREEZE_EPOCHS = 5              
+
+torch.manual_seed(SEED)
+print("Done")
+
+
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD = [0.229, 0.224, 0.225]
+
+train_transform = transforms.Compose([
+    transforms.Resize((IMG_SIZE + 20, IMG_SIZE + 20)),
+    transforms.RandomResizedCrop(IMG_SIZE, scale=(0.8, 1.0)),
+    transforms.RandomHorizontalFlip(p=0.5),
+    transforms.RandomRotation(degrees=15),
+    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+    transforms.ToTensor(),
+    transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD),
+    transforms.RandomErasing(p=0.2),
+])
+
+eval_transform = transforms.Compose([
+    transforms.Resize((IMG_SIZE, IMG_SIZE)),
+    transforms.ToTensor(),
+    transforms.CenterCrop(224),
+    transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD),
+])
+
+
+
+class SubsetWithTransform(Dataset):
+    def __init__(self, base_dataset, indices, transform):
+        self.base_dataset = base_dataset
+        self.indices = indices
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.indices)
+
+    def __getitem__(self, idx):
+        real_idx = self.indices[idx]
+        path, label = self.base_dataset.samples[real_idx]
+        image = self.base_dataset.loader(path)
+        image = self.transform(image)
+        return image, label
+
+
+targets = np.array([label for _, label in full_dataset.samples])
+indices = np.arange(len(full_dataset))
+
+train_idx, temp_idx = train_test_split(
+    indices, test_size=(1 - TRAIN_RATIO), stratify=targets, random_state=SEED
+)
+
+val_ratio_of_temp = VAL_RATIO / (VAL_RATIO + TEST_RATIO)
+val_idx, test_idx = train_test_split(
+    temp_idx, test_size=(1 - val_ratio_of_temp),
+    stratify=targets[temp_idx], random_state=SEED
+)
+
+train_ds = SubsetWithTransform(full_dataset, train_idx, train_transform)
+val_ds = SubsetWithTransform(full_dataset, val_idx, eval_transform)
+test_ds = SubsetWithTransform(full_dataset, test_idx, eval_transform)
+
+train_loader = DataLoader(
+    train_ds,
+    batch_size=BATCH_SIZE,
+    shuffle=True,
+    num_workers=0,
+    pin_memory=True,
+    drop_last=True
+)
+
+val_loader = DataLoader(
+    val_ds,
+    batch_size=BATCH_SIZE,
+    shuffle=False,
+    num_workers=0,
+    pin_memory=True
+)
+
+test_loader = DataLoader(
+    test_ds,
+    batch_size=BATCH_SIZE,
+    shuffle=False,
+    num_workers=0,
+    pin_memory=True
+)
+
+print(f"Count classes: {NUM_CLASSES} -> {CLASS_NAMES}")
+print(f"Count image of train: {len(train_ds)}")
+print(f"Count image of Validation: {len(val_ds)}")
+print(f"Test: {len(test_ds)}")
+
+
+fig, axes = plt.subplots(2, 3, figsize=(10, 7))
+for ax in axes.flatten():
+    img, label = train_ds[np.random.randint(len(train_ds))]
+    img = img * torch.tensor(IMAGENET_STD).view(3,1,1) + torch.tensor(IMAGENET_MEAN).view(3,1,1)
+    img = img.clamp(0, 1).permute(1, 2, 0).numpy()
+    ax.imshow(img)
+    ax.set_title(CLASS_NAMES[label], fontsize=9)
+    ax.axis("off")
+plt.tight_layout()
+plt.show()
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, stride=1):
+        super().__init__()
+        self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, 1, bias=False)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False)
+        self.bn2 = nn.BatchNorm2d(out_channels)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_channels != out_channels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels, 1, stride, bias=False),
+                nn.BatchNorm2d(out_channels),
+            )
+
+    def forward(self, x):
+        identity = self.shortcut(x)
+        out = self.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += identity          # skip connection
+        return self.relu(out)
+
+
+class ScratchCNN(nn.Module):
+    def __init__(self, num_classes, dropout=DROPOUT):
+        super().__init__()
+        self.stem = nn.Sequential(
+            nn.Conv2d(3, 64, 7, 2, 3, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(3, 2, 1),
+        )
+        self.stage1 = self._make_stage(64, 64, 2, stride=1)
+        self.stage2 = self._make_stage(64, 128, 2, stride=2)
+        self.stage3 = self._make_stage(128, 256, 2, stride=2)
+        self.stage4 = self._make_stage(256, 512, 2, stride=2)
+
+        self.global_pool = nn.AdaptiveAvgPool2d(1)
+        self.dropout = nn.Dropout(dropout)
+        self.classifier = nn.Linear(512, num_classes)
+
+    def _make_stage(self, in_c, out_c, num_blocks, stride):
+        layers = [ResidualBlock(in_c, out_c, stride)]
+        for _ in range(num_blocks - 1):
+            layers.append(ResidualBlock(out_c, out_c, 1))
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.stem(x)
+        x = self.stage1(x); x = self.stage2(x)
+        x = self.stage3(x); x = self.stage4(x)
+        x = self.global_pool(x)
+        x = torch.flatten(x, 1)
+        x = self.dropout(x)
+        return self.classifier(x)
+
+_test_out = ScratchCNN(num_classes=NUM_CLASSES)(torch.randn(2, 3, IMG_SIZE, IMG_SIZE))
+
+
+def build_resnet50(num_classes, dropout=DROPOUT):
+    m = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)
+    m.fc = nn.Sequential(nn.Dropout(dropout), nn.Linear(m.fc.in_features, num_classes))
+    return m
+
+def build_efficientnet_b0(num_classes, dropout=DROPOUT):
+    m = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1)
+    m.classifier = nn.Sequential(nn.Dropout(dropout), nn.Linear(m.classifier[1].in_features, num_classes))
+    return m
+
+def build_densenet121(num_classes, dropout=DROPOUT):
+    m = models.densenet121(weights=models.DenseNet121_Weights.IMAGENET1K_V1)
+    m.classifier = nn.Sequential(nn.Dropout(dropout), nn.Linear(m.classifier.in_features, num_classes))
+    return m
+
+
+def freeze_backbone(model, model_name):
+    for p in model.parameters():
+        p.requires_grad = False
+    head = model.fc if model_name == "resnet50" else model.classifier
+    for p in head.parameters():
+        p.requires_grad = True
+    return model
+
+def unfreeze_all(model):
+    for p in model.parameters():
+        p.requires_grad = True
+    return model
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+class EarlyStopping:
+    def __init__(self, patience=EARLY_STOPPING_PATIENCE):
+        self.patience = patience
+        self.best_loss = float("inf")
+        self.counter = 0
+        self.best_state = None
+        self.should_stop = False
+
+    def step(self, val_loss, model):
+        if val_loss < self.best_loss:
+            self.best_loss = val_loss
+            self.counter = 0
+            self.best_state = copy.deepcopy(model.state_dict())
+        else:
+            self.counter += 1
+            if self.counter >= self.patience:
+                self.should_stop = True
+
+
+def run_one_epoch(model, loader, criterion, optimizer=None):
+    is_training = optimizer is not None
+    model.train() if is_training else model.eval()
+
+    total_loss, total_correct, total_samples = 0.0, 0, 0
+    torch.set_grad_enabled(is_training)
+    for images, labels in tqdm(loader, leave=False):
+        images, labels = images.to(DEVICE), labels.to(DEVICE)
+        if is_training:
+            optimizer.zero_grad()
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+        if is_training:
+            loss.backward()
+            optimizer.step()
+        total_loss += loss.item() * images.size(0)
+        total_correct += (outputs.argmax(1) == labels).sum().item()
+        total_samples += images.size(0)
+    torch.set_grad_enabled(True)
+
+    return total_loss / total_samples, total_correct / total_samples
+
+
+def train_model(model, model_name, train_loader, val_loader, epochs, lr,
+                 weight_decay=WEIGHT_DECAY, label_smoothing=LABEL_SMOOTHING):
+    model = model.to(DEVICE)
+    criterion = nn.CrossEntropyLoss(label_smoothing=label_smoothing)
+    optimizer = torch.optim.AdamW(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=lr, weight_decay=weight_decay,
+    )
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="min", factor=0.5, patience=2)
+    early_stopper = EarlyStopping()
+
+    history = {"train_loss": [], "train_acc": [], "val_loss": [], "val_acc": []}
+
+    for epoch in range(1, epochs + 1):
+        train_loss, train_acc = run_one_epoch(model, train_loader, criterion, optimizer)
+        val_loss, val_acc = run_one_epoch(model, val_loader, criterion, optimizer=None)
+        scheduler.step(val_loss)
+
+        history["train_loss"].append(train_loss)
+        history["train_acc"].append(train_acc)
+        history["val_loss"].append(val_loss)
+        history["val_acc"].append(val_acc)
+
+        print(f"[{model_name}] Epoch {epoch}/{epochs} | "
+              f"train_loss={train_loss:.4f} train_acc={train_acc:.4f} | "
+              f"val_loss={val_loss:.4f} val_acc={val_acc:.4f}")
+
+        early_stopper.step(val_loss, model)
+        if early_stopper.should_stop:
+            print(f"[{model_name}] Early stopping {epoch}")
+            break
+
+    model.load_state_dict(early_stopper.best_state)  
+    return model, history
+
+
+@torch.no_grad()
+def evaluate_full(model, loader):
+    model.eval()
+    all_preds, all_labels = [], []
+    for images, labels in tqdm(loader, leave=False, desc="Evaluating"):
+        images = images.to(DEVICE)
+        preds = model(images).argmax(1).cpu().numpy()
+        all_preds.extend(preds)
+        all_labels.extend(labels.numpy())
+
+    acc = accuracy_score(all_labels, all_preds)
+    f1 = f1_score(all_labels, all_preds, average="macro")
+    return {"accuracy": acc, "f1_macro": f1, "predictions": all_preds, "labels": all_labels}
+
+print("Done")
+
+
+def plot_history(history, model_name):
+    fig, axes = plt.subplots(1, 2, figsize=(12, 4))
+    axes[0].plot(history["train_loss"], label="Train Loss")
+    axes[0].plot(history["val_loss"], label="Val Loss")
+    axes[0].set_title(f"{model_name} - Loss"); axes[0].set_xlabel("Epoch"); axes[0].legend()
+
+    axes[1].plot(history["train_acc"], label="Train Acc")
+    axes[1].plot(history["val_acc"], label="Val Acc")
+    axes[1].set_title(f"{model_name} - Accuracy"); axes[1].set_xlabel("Epoch"); axes[1].legend()
+
+    plt.tight_layout()
+    plt.savefig(os.path.join(OUTPUT_DIR, f"{model_name}_history.png"), dpi=150)
+    plt.show()
+
+
+def plot_confusion_matrix(labels, preds, class_names, model_name):
+    cm = confusion_matrix(labels, preds)
+    fig, ax = plt.subplots(figsize=(7, 6))
+    im = ax.imshow(cm, cmap="Blues")
+    ax.set_xticks(range(len(class_names))); ax.set_yticks(range(len(class_names)))
+    ax.set_xticklabels(class_names, rotation=45, ha="right")
+    ax.set_yticklabels(class_names)
+    ax.set_xlabel("Predicted"); ax.set_ylabel("True")
+    ax.set_title(f"Confusion Matrix - {model_name}")
+    for i in range(len(class_names)):
+        for j in range(len(class_names)):
+            ax.text(j, i, cm[i, j], ha="center", va="center",
+                     color="white" if cm[i, j] > cm.max()/2 else "black")
+    plt.colorbar(im)
+    plt.tight_layout()
+    plt.savefig(os.path.join(OUTPUT_DIR, f"{model_name}_confusion_matrix.png"), dpi=150)
+    plt.show()
+
+
+scratch_model = ScratchCNN(NUM_CLASSES)
+print(f"{count_parameters(scratch_model):,}")
+
+scratch_model, scratch_history = train_model(
+    scratch_model, "scratch_cnn", train_loader, val_loader,
+    epochs=EPOCHS, lr=LR_SCRATCH,
+)
+
+
+plot_history(scratch_history, "scratch_cnn")
+
+
+resnet_model = build_resnet50(NUM_CLASSES)
+resnet_model = freeze_backbone(resnet_model, "resnet50")
+
+resnet_model, resnet_history_1 = train_model(
+    resnet_model, "resnet50", train_loader, val_loader,
+    epochs=FREEZE_EPOCHS, lr=LR_PRETRAINED_HEAD,
+)
+
+
+resnet_model = unfreeze_all(resnet_model)
+resnet_model, resnet_history_2 = train_model(
+    resnet_model, "resnet50", train_loader, val_loader,
+    epochs=max(EPOCHS - FREEZE_EPOCHS, 5), lr=LR_PRETRAINED_FINETUNE,
+)
+
+resnet_history = {k: resnet_history_1[k] + resnet_history_2[k] for k in resnet_history_1}
+plot_history(resnet_history, "resnet50")
+
+
+effnet_model = build_efficientnet_b0(NUM_CLASSES)
+effnet_model = freeze_backbone(effnet_model, "efficientnet_b0")
+
+effnet_model, effnet_history_1 = train_model(
+    effnet_model, "efficientnet_b0", train_loader, val_loader,
+    epochs=FREEZE_EPOCHS, lr=LR_PRETRAINED_HEAD,
+)
+
+
+effnet_model = unfreeze_all(effnet_model)
+effnet_model, effnet_history_2 = train_model(
+    effnet_model, "efficientnet_b0", train_loader, val_loader,
+    epochs=max(EPOCHS - FREEZE_EPOCHS, 5), lr=LR_PRETRAINED_FINETUNE,
+)
+
+effnet_history = {k: effnet_history_1[k] + effnet_history_2[k] for k in effnet_history_1}
+plot_history(effnet_history, "efficientnet_b0")
+
+
+densenet_model = build_densenet121(NUM_CLASSES)
+densenet_model = freeze_backbone(densenet_model, "densenet121")
+
+densenet_model, densenet_history_1 = train_model(
+    densenet_model, "densenet121", train_loader, val_loader,
+    epochs=FREEZE_EPOCHS, lr=LR_PRETRAINED_HEAD,
+)
+
+
+densenet_model = unfreeze_all(densenet_model)
+densenet_model, densenet_history_2 = train_model(
+    densenet_model, "densenet121", train_loader, val_loader,
+    epochs=max(EPOCHS - FREEZE_EPOCHS, 5), lr=LR_PRETRAINED_FINETUNE,
+)
+
+densenet_history = {k: densenet_history_1[k] + densenet_history_2[k] for k in densenet_history_1}
+plot_history(densenet_history, "densenet121")
+
+
+all_models = {
+    "scratch_cnn": scratch_model,
+    "resnet50": resnet_model,
+    "efficientnet_b0": effnet_model,
+    "densenet121": densenet_model,
+}
+
+results = []
+best_model_name, best_f1 = None, -1.0
+
+for name, model in all_models.items():
+    print(f"Evaluate {name} on test set...")
+    eval_result = evaluate_full(model, test_loader)
+
+    ckpt_path = os.path.join(CHECKPOINT_DIR, f"{name}.pth")
+    torch.save(model.state_dict(), ckpt_path)
+    print(f"The save weight {name} in: {ckpt_path}")
+
+    plot_confusion_matrix(eval_result["labels"], eval_result["predictions"], CLASS_NAMES, name)
+
+    results.append({
+        "model": name,
+        "trainable_params": count_parameters(model),
+        "test_accuracy": round(eval_result["accuracy"], 4),
+        "test_f1": round(eval_result["f1_macro"], 4),
+    })
+
+    if eval_result["f1_macro"] > best_f1:
+        best_f1 = eval_result["f1_macro"]
+        best_model_name = name
+
+comparison_df = pd.DataFrame(results).sort_values("test_f1", ascending=False).reset_index(drop=True)
+comparison_df.to_csv(os.path.join(OUTPUT_DIR, "models_comparison.csv"), index=False)
+comparison_df
+
+
+for name, model in all_models.items():
+    print(f"Evaluate {name} on test set...")
+
+    eval_result = evaluate_full(model, test_loader)
+
+    print(f"Classification Report for {name}")
+    print(
+        classification_report(
+            eval_result["labels"],
+            eval_result["predictions"],
+            target_names=CLASS_NAMES,
+            digits=4
+        )
+    )
+
+    ckpt_path = os.path.join(CHECKPOINT_DIR, f"{name}.pth")
+    torch.save(model.state_dict(), ckpt_path)
+
+
+best_model = all_models[best_model_name]
+best_path = os.path.join(CHECKPOINT_DIR, "best_model.pth")
+
+torch.save({
+    "model_name": best_model_name,
+    "state_dict": best_model.state_dict(),
+    "class_names": CLASS_NAMES,
+    "test_f1": best_f1,
+}, best_path)
+
+print(f"The Best Model: {best_model_name}  (F1 = {best_f1:.4f})")
+print(f"Save: {best_path}")
+
+
+IMAGE_PATH = '/kaggle/working/oral_dataset/Hypodontia/(100).JPG'
+
+checkpoint = torch.load(os.path.join(CHECKPOINT_DIR, "best_model.pth"), map_location=DEVICE)
+loaded_name = checkpoint["model_name"]
+loaded_classes = checkpoint["class_names"]
+
+builders = {
+    "scratch_cnn": lambda: ScratchCNN(len(loaded_classes)),
+    "resnet50": lambda: build_resnet50(len(loaded_classes)),
+    "efficientnet_b0": lambda: build_efficientnet_b0(len(loaded_classes)),
+    "densenet121": lambda: build_densenet121(len(loaded_classes)),
+}
+inference_model = builders[loaded_name]()
+inference_model.load_state_dict(checkpoint["state_dict"])
+inference_model.to(DEVICE).eval()
+print(f"Download the best model: {loaded_name} (test F1 = {checkpoint['test_f1']:.4f})")
+
+with torch.no_grad():
+    image = Image.open(IMAGE_PATH).convert("RGB")
+    tensor = eval_transform(image).unsqueeze(0).to(DEVICE)
+    probs = torch.softmax(inference_model(tensor), dim=1)[0]
+    pred_idx = probs.argmax().item()
+
+plt.imshow(image); plt.axis("off")
+plt.title(f"Classifier: {loaded_classes[pred_idx]} ({probs[pred_idx]*100:.1f}%)")
+plt.show()
+
+for cname, p in sorted(zip(loaded_classes, probs.tolist()), key=lambda x: -x[1]):
+    print(f"  {cname:25s}: {p*100:5.2f}%")
+
+
+IMAGE_PATH = '/kaggle/working/oral_dataset/Caries/caries_0_1001.jpeg'
+
+checkpoint = torch.load(os.path.join(CHECKPOINT_DIR, "best_model.pth"), map_location=DEVICE)
+loaded_name = checkpoint["model_name"]
+loaded_classes = checkpoint["class_names"]
+
+builders = {
+    "scratch_cnn": lambda: ScratchCNN(len(loaded_classes)),
+    "resnet50": lambda: build_resnet50(len(loaded_classes)),
+    "efficientnet_b0": lambda: build_efficientnet_b0(len(loaded_classes)),
+    "densenet121": lambda: build_densenet121(len(loaded_classes)),
+}
+inference_model = builders[loaded_name]()
+inference_model.load_state_dict(checkpoint["state_dict"])
+inference_model.to(DEVICE).eval()
+print(f"Download the best model: {loaded_name} (test F1 = {checkpoint['test_f1']:.4f})")
+
+with torch.no_grad():
+    image = Image.open(IMAGE_PATH).convert("RGB")
+    tensor = eval_transform(image).unsqueeze(0).to(DEVICE)
+    probs = torch.softmax(inference_model(tensor), dim=1)[0]
+    pred_idx = probs.argmax().item()
+
+plt.imshow(image); plt.axis("off")
+plt.title(f"Classifier: {loaded_classes[pred_idx]} ({probs[pred_idx]*100:.1f}%)")
+plt.show()
+
+for cname, p in sorted(zip(loaded_classes, probs.tolist()), key=lambda x: -x[1]):
+    print(f"  {cname:25s}: {p*100:5.2f}%")
+
+
+import shutil
+
+shutil.make_archive(
+    "/kaggle/working/output_files",
+    "zip",
+    "/kaggle/working/"
+)
+
+
+from IPython.display import FileLink
+
+FileLink('/kaggle/working/output_files.zip')

Gradio.py

@@ -0,0 +1,402 @@
+import torch
+import gradio as gr
+import torch.nn as nn
+import torch.nn.functional as F
+
+from PIL import Image
+import torchvision.transforms as transforms
+from torchvision.models import resnet50
+
+
+# ============================================================
+# CONFIG
+# ============================================================
+MODEL_PATH = r"C:\Users\LOQ\Desktop\Oral Diseases Image Classification\checkpoints\best_model.pth"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+# ============================================================
+# LOAD MODEL
+# ============================================================
+checkpoint = torch.load(MODEL_PATH, map_location=DEVICE)
+
+CLASS_NAMES = checkpoint["class_names"]
+TEST_F1 = checkpoint["test_f1"]
+
+model = resnet50(weights=None)
+model.fc = nn.Sequential(
+    nn.Dropout(0.3),
+    nn.Linear(model.fc.in_features, len(CLASS_NAMES))
+)
+model.load_state_dict(checkpoint["state_dict"])
+model.to(DEVICE)
+model.eval()
+
+eval_transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+
+
+# ============================================================
+# INFERENCE
+# ============================================================
+def predict(image):
+    if image is None:
+        return (
+            gr.update(value="—", visible=True),
+            "—",
+            {},
+            gr.update(visible=False),
+        )
+
+    image = image.convert("RGB")
+    tensor = eval_transform(image).unsqueeze(0).to(DEVICE)
+
+    with torch.no_grad():
+        output = model(tensor)
+        probs = F.softmax(output, dim=1)[0]
+
+    index = torch.argmax(probs).item()
+    prediction = CLASS_NAMES[index]
+    confidence = probs[index].item() * 100
+
+    results = {CLASS_NAMES[i]: float(probs[i]) for i in range(len(CLASS_NAMES))}
+
+    # Build a small verdict badge depending on confidence level
+    if confidence >= 85:
+        badge = f'<div class="verdict verdict-high">✓ High Confidence — {confidence:.1f}%</div>'
+    elif confidence >= 60:
+        badge = f'<div class="verdict verdict-mid">! Moderate Confidence — {confidence:.1f}%</div>'
+    else:
+        badge = f'<div class="verdict verdict-low">? Low Confidence — {confidence:.1f}%</div>'
+
+    return (
+        prediction,
+        f"{confidence:.2f}%",
+        results,
+        gr.update(value=badge, visible=True),
+    )
+
+
+def clear_all():
+    return None, "—", "—", {}, gr.update(visible=False)
+
+
+# ============================================================
+# STYLING
+# ============================================================
+CUSTOM_CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@500&display=swap');
+
+:root {
+    --bg-primary: #0a0e1a;
+    --bg-secondary: #10162a;
+    --bg-card: #131a30;
+    --border-subtle: #232b45;
+    --accent: #14b8a6;
+    --accent-soft: #14b8a622;
+    --accent-2: #6366f1;
+    --text-primary: #e8ecf5;
+    --text-secondary: #8892b0;
+    --text-muted: #5b6485;
+    --radius: 14px;
+}
+
+* { font-family: 'Inter', sans-serif !important; }
+
+.gradio-container {
+    background: radial-gradient(circle at 10% 0%, #101a33 0%, #080b14 55%, #05070d 100%) !important;
+    max-width: 1180px !important;
+    margin: 0 auto !important;
+}
+
+footer { display: none !important; }
+
+/* ---------- HEADER ---------- */
+.app-header {
+    padding: 30px 8px 22px 8px;
+    border-bottom: 1px solid var(--border-subtle);
+    margin-bottom: 26px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+.app-header .brand {
+    display: flex;
+    align-items: center;
+    gap: 14px;
+}
+.app-header .logo-badge {
+    width: 46px;
+    height: 46px;
+    border-radius: 12px;
+    background: linear-gradient(135deg, var(--accent), var(--accent-2));
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 22px;
+    box-shadow: 0 8px 24px -6px #14b8a655;
+    flex-shrink: 0;
+}
+.app-header h1 {
+    font-size: 20px;
+    font-weight: 700;
+    color: var(--text-primary);
+    margin: 0;
+    letter-spacing: -0.02em;
+}
+.app-header p {
+    font-size: 13px;
+    color: var(--text-muted);
+    margin: 2px 0 0 0;
+}
+.app-header .tag {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--accent);
+    background: var(--accent-soft);
+    border: 1px solid #14b8a640;
+    padding: 6px 14px;
+    border-radius: 999px;
+    letter-spacing: 0.03em;
+    text-transform: uppercase;
+}
+
+/* ---------- CARDS ---------- */
+.card {
+    background: var(--bg-card) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: var(--radius) !important;
+    padding: 18px !important;
+}
+.card-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    margin-bottom: 12px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+.card-title::before {
+    content: "";
+    width: 4px;
+    height: 14px;
+    background: var(--accent);
+    border-radius: 2px;
+    display: inline-block;
+}
+
+/* ---------- UPLOAD ZONE ---------- */
+.upload-zone, .upload-zone > div {
+    background: var(--bg-card) !important;
+    border: 1.5px dashed #2b3454 !important;
+    border-radius: var(--radius) !important;
+}
+.upload-zone:hover {
+    border-color: var(--accent) !important;
+}
+
+/* ---------- BUTTONS ---------- */
+#analyze-btn {
+    background: linear-gradient(135deg, #14b8a6, #0d9488) !important;
+    color: #05170f !important;
+    font-weight: 700 !important;
+    border: none !important;
+    border-radius: 10px !important;
+    box-shadow: 0 10px 24px -8px #14b8a670 !important;
+    letter-spacing: 0.01em;
+    transition: transform .15s ease, box-shadow .15s ease;
+}
+#analyze-btn:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 14px 28px -8px #14b8a690 !important;
+}
+#clear-btn {
+    background: transparent !important;
+    color: var(--text-secondary) !important;
+    border: 1px solid var(--border-subtle) !important;
+    border-radius: 10px !important;
+}
+#clear-btn:hover {
+    border-color: #3a4468 !important;
+    color: var(--text-primary) !important;
+}
+
+/* ---------- RESULT FIELDS ---------- */
+#pred-box textarea, #conf-box textarea {
+    background: #0d1326 !important;
+    border: 1px solid var(--border-subtle) !important;
+    color: var(--text-primary) !important;
+    font-weight: 700 !important;
+    font-size: 17px !important;
+    border-radius: 10px !important;
+}
+#conf-box textarea {
+    color: var(--accent) !important;
+    font-family: 'JetBrains Mono', monospace !important;
+}
+label span {
+    color: var(--text-muted) !important;
+    font-size: 11.5px !important;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-weight: 600 !important;
+}
+
+/* ---------- VERDICT BADGE ---------- */
+.verdict {
+    padding: 10px 16px;
+    border-radius: 10px;
+    font-size: 13px;
+    font-weight: 600;
+    text-align: center;
+    margin-bottom: 14px;
+    border: 1px solid transparent;
+}
+.verdict-high { background: #14b8a61a; color: #2dd4bf; border-color: #14b8a640; }
+.verdict-mid  { background: #f59e0b1a; color: #fbbf24; border-color: #f59e0b40; }
+.verdict-low  { background: #ef44441a; color: #f87171; border-color: #ef444440; }
+
+/* ---------- PROBABILITY BARS (gr.Label) ---------- */
+.label-wrap {
+    background: transparent !important;
+    border: none !important;
+}
+#prob-label .container {
+    background: transparent !important;
+}
+
+/* ---------- FOOTER ---------- */
+.app-footer {
+    margin-top: 30px;
+    padding: 18px 4px 10px 4px;
+    border-top: 1px solid var(--border-subtle);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 10px;
+}
+.app-footer .meta {
+    font-size: 12px;
+    color: var(--text-muted);
+    font-family: 'JetBrains Mono', monospace;
+}
+.app-footer .meta b { color: var(--text-secondary); }
+.app-footer .credit {
+    font-size: 12px;
+    color: var(--text-muted);
+}
+.app-footer .credit b { color: var(--text-secondary); }
+
+.disclaimer {
+    font-size: 11.5px;
+    color: var(--text-muted);
+    background: #0d132666;
+    border: 1px solid var(--border-subtle);
+    border-radius: 10px;
+    padding: 10px 14px;
+    margin-top: 16px;
+    line-height: 1.6;
+}
+"""
+
+
+# ============================================================
+# UI
+# ============================================================
+with gr.Blocks(
+    theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate"),
+    css=CUSTOM_CSS,
+    title="Oral Disease Classifier"
+) as demo:
+
+    gr.HTML(
+        f"""
+        <div class="app-header">
+            <div class="brand">
+                <div class="logo-badge">🦷</div>
+                <div>
+                    <h1>Oral Disease Classification</h1>
+                    <p>Computer-vision assisted screening · ResNet50 backbone</p>
+                </div>
+            </div>
+            <div class="tag">Model F1 · {TEST_F1:.3f}</div>
+        </div>
+        """
+    )
+
+    with gr.Row(equal_height=True):
+
+        with gr.Column(scale=5):
+            gr.HTML('<div class="card-title">Input Image</div>')
+            image_input = gr.Image(
+                type="pil",
+                label="",
+                show_label=False,
+                elem_classes="upload-zone",
+                height=340,
+            )
+
+            with gr.Row():
+                clear_btn = gr.Button("Clear", elem_id="clear-btn")
+                button = gr.Button("Analyze Image", elem_id="analyze-btn")
+
+            gr.HTML(
+                """
+                <div class="disclaimer">
+                    ⚠ Decision-support tool only. Predictions are generated by an automated
+                    model and are not a substitute for professional clinical diagnosis.
+                </div>
+                """
+            )
+
+        with gr.Column(scale=5):
+            gr.HTML('<div class="card-title">Analysis Result</div>')
+
+            verdict_html = gr.HTML(visible=False)
+
+            with gr.Row():
+                prediction = gr.Textbox(label="Predicted Class", elem_id="pred-box", interactive=False)
+                confidence = gr.Textbox(label="Confidence", elem_id="conf-box", interactive=False)
+
+            gr.HTML('<div class="card-title" style="margin-top:6px;">Class Probability Distribution</div>')
+            probabilities = gr.Label(
+                label="",
+                show_label=False,
+                elem_id="prob-label",
+                num_top_classes=len(CLASS_NAMES),
+            )
+
+    gr.HTML(
+        f"""
+        <div class="app-footer">
+            <div class="meta">ARCH · <b>ResNet50</b> &nbsp;|&nbsp; DEVICE · <b>{DEVICE.upper()}</b> &nbsp;|&nbsp; CLASSES · <b>{len(CLASS_NAMES)}</b></div>
+            <div class="credit">Built by <b>Nasr Mohamed</b> — AI Engineer &nbsp;·&nbsp; © 2026</div>
+        </div>
+        """
+    )
+
+    button.click(
+        predict,
+        inputs=image_input,
+        outputs=[prediction, confidence, probabilities, verdict_html],
+    )
+
+    clear_btn.click(
+        clear_all,
+        inputs=None,
+        outputs=[image_input, prediction, confidence, probabilities, verdict_html],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

checkpoints/best_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40bd3f0d2f1481704b49946ab76231914f86f4de58cb1fb4b82041a3cd8562f7
+size 94400529

checkpoints/densenet121.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eca85db7d09f70ea5332adf1007c9c69e34dfc0fb78a6e56df4740946223cdde
+size 28448005

checkpoints/efficientnet_b0.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f054f46138686a3cf36f24dc0721d95d822b5915a3b32b16eadc5a0017896a78
+size 16362271

checkpoints/resnet50.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b4b0e828a4b563e4c8380080fab9200ee55733eb9f8baf1883b514f59488c39
+size 94399685

checkpoints/scratch_cnn.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d35823b73231da512a2d0ca6289ef31f947a2bc6821ee32102fd25624e8f322
+size 44798347

outputs/models_comparison.csv

@@ -0,0 +1,5 @@
+model,trainable_params,test_accuracy,test_f1
+resnet50,23520326,0.9477,0.9411
+densenet121,6960006,0.9451,0.9351
+efficientnet_b0,4015234,0.9417,0.9335
+scratch_cnn,11179590,0.8345,0.8236