SGC-1 - Initial commit. Added model to run demo

app.py

@@ -0,0 +1,43 @@
+import torch
+from PIL import Image
+import gradio as gr
+import torchvision.transforms as transforms
+
+from model import SkinGlanceCareClassifier
+from config import Config
+
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+cfg = Config()
+
+model = SkinGlanceCareClassifier.load_from_checkpoint(
+            "model_params_val_f1=0.878.ckpt",
+            cfg=cfg
+        )
+model.to(device)
+model.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])
+])
+
+def predict(image: Image.Image):
+    img = image.convert("RGB")
+    x = transform(img).unsqueeze(0).to(device)
+    with torch.no_grad():
+        logits = model(x)
+    probs = torch.softmax(logits, dim=1).cpu().numpy()[0]
+    return {f"class_{i}": float(probs[i]) for i in range(len(probs))}
+
+iface = gr.Interface(fn=predict,
+                     inputs=gr.Image(type="pil"),
+                     outputs=gr.Label(num_top_classes=3),
+                     title="SkinGlanceCareClassifier",
+                     description="Upload an image for inference"
+                    )
+
+if __name__ == "__main__":
+    iface.launch()

config.py

@@ -0,0 +1,37 @@
+import os
+from dataclasses import dataclass
+
+@dataclass
+class Config:
+    base_model: str = "efficientnet_b3"
+    
+    csv_path: str = os.getenv("CSV_PATH", "./preprocessed_dataset")
+    path_images: str = os.getenv("IMAGES_PATH", "./dataset/surajghuwalewala/ham1000-segmentation-and-classification/versions/2/images")
+    path_healthy: str = os.getenv("HEALTHY_PATH", "./dataset/MCVSLD/Skin Lesion Dataset/train/Healthy")
+    
+    num_classes: int = 8
+    label_classes: tuple = ('MEL', 'NV', 'BCC', 'AKIEC', 'BKL', 'DF', 'VASC', 'HEAL')
+    
+    batch_size: int = 96
+    accumulate_grad_batches: int = 2
+    
+    image_size: int = 224
+    
+    num_workers: int = 12
+    pin_memory: bool = True
+    persistent_workers: bool = True
+    prefetch_factor: int = 4
+    multiprocessing_context = "spawn"
+    
+    max_epochs: int = 100
+    learning_rate: float = 2e-4
+    weight_decay: float = 5e-4
+    precision: str = "bf16-mixed"
+    
+    use_weighted_sampler: bool = False
+    use_smote: bool = True
+    use_smote_startegy = "proportional" # "equal"
+    cache_in_memory: bool = False
+    
+    channels_last: bool = True
+    cudnn_benchmark: bool = True

model.py

@@ -0,0 +1,365 @@
+import torchmetrics
+import numpy as np
+import torch
+import seaborn as sns
+from torchvision import models
+
+import matplotlib.pyplot as plt
+import pytorch_lightning as pl
+import torch.nn as nn
+
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+from sklearn.metrics import confusion_matrix
+from typing import Dict
+
+from config import Config
+
+class SkinGlanceCareClassifier(pl.LightningModule):
+    def __init__(self, cfg: Config):
+        super().__init__()
+        self.save_hyperparameters(ignore=['cfg'])
+        self.cfg = cfg
+        
+        self.model = models.efficientnet_b3(weights=models.EfficientNet_B3_Weights.IMAGENET1K_V1)
+        
+        in_feats = self.model.classifier[1].in_features
+        self.model.classifier = nn.Sequential(
+            nn.Dropout(0.4),
+            nn.Linear(in_feats, 512),
+            nn.GELU(),
+            nn.Dropout(0.25),
+            nn.Linear(512, cfg.num_classes)
+        )
+        
+        self.loss_fn = nn.CrossEntropyLoss(label_smoothing=0.1)
+        
+        self._setup_metrics() 
+        self.sample_images: Dict[int, Dict] = {}
+
+    def on_fit_start(self):
+        if self.cfg.channels_last:
+            self.to(memory_format=torch.channels_last)
+    
+    def forward(self, x):
+        if self.cfg.channels_last and x.dim() == 4:
+            x = x.to(memory_format=torch.channels_last)
+        return self.model(x)
+    
+    def configure_optimizers(self):
+
+        optimizer = torch.optim.AdamW(
+            self.parameters(), 
+            lr=self.cfg.learning_rate, 
+            weight_decay=self.cfg.weight_decay,
+            betas=(0.9, 0.999)
+        )
+        
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
+            optimizer, 
+            T_0=5,
+            T_mult=2,
+            eta_min=1e-6
+        )
+        
+        return {
+            'optimizer': optimizer,
+            'lr_scheduler': {
+                'scheduler': scheduler,
+                'interval': 'epoch',
+            }
+        }
+    
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        
+        logits = self(x)
+        loss = self.loss_fn(logits, y)
+        
+        preds = torch.argmax(logits, dim=1)
+        self.train_acc.update(preds, y)
+        self.train_f1.update(preds, y)
+        
+        self.log('train_loss', loss, on_step=False, on_epoch=True, prog_bar=False)
+        
+        return loss
+
+    def on_train_epoch_end(self):
+        acc = self.train_acc.compute()
+        f1 = self.train_f1.compute()
+        
+        self.log('train_acc', acc, prog_bar=True)
+        self.log('train_f1', f1, prog_bar=True)
+        
+        self.train_acc.reset()
+        self.train_f1.reset()
+
+    def validation_step(self, batch, batch_idx):
+        x, y = batch
+        
+        logits = self(x)
+        loss = self.loss_fn(logits, y)
+        
+        preds = torch.argmax(logits, dim=1)
+        
+        self.val_preds.append(preds.detach().cpu())
+        self.val_labels.append(y.detach().cpu())
+        
+        self.val_acc.update(preds, y)
+        self.val_f1.update(preds, y)
+        self.val_precision.update(preds, y)
+        self.val_recall.update(preds, y)
+        
+        self.log('val_loss', loss, on_epoch=True, prog_bar=False)
+        
+        return loss
+
+    def on_validation_epoch_end(self):
+        acc = self.val_acc.compute()
+        f1 = self.val_f1.compute()
+        
+        self.log('val_acc', acc, prog_bar=True)
+        self.log('val_f1', f1, prog_bar=True)
+        
+        if (self.current_epoch % 5 == 4 or self.current_epoch == 0) and not self.trainer.sanity_checking:
+            val_preds = torch.cat(self.val_preds)
+            val_labels = torch.cat(self.val_labels)
+            
+            cm = confusion_matrix(val_labels.numpy(), val_preds.numpy())
+            self._plot_confusion_matrix(cm, "Validation")
+            
+            precision = self.val_precision.compute().cpu().numpy()
+            recall = self.val_recall.compute().cpu().numpy()
+            self._log_per_class_metrics(precision, recall)
+        
+        self.val_acc.reset()
+        self.val_f1.reset()
+        self.val_precision.reset()
+        self.val_recall.reset()
+        self.val_preds.clear()
+        self.val_labels.clear()
+
+    def test_step(self, batch, batch_idx):
+        x, y = batch
+        
+        logits = self(x)
+        loss = self.loss_fn(logits, y)
+        
+        preds = torch.argmax(logits, dim=1)
+        
+        self.test_preds.append(preds.detach().cpu())
+        self.test_labels.append(y.detach().cpu())
+        
+        if batch_idx % 20 == 5:
+            for i, lbl in enumerate(y):
+                cls = int(lbl.item())
+                if cls not in self.sample_images:
+                    self.sample_images[cls] = {
+                        "image": x[i].detach().cpu().clone(),
+                        "label": cls,
+                        "pred": int(preds[i].item()),
+                    }
+        
+        self.test_acc.update(preds, y)
+        self.test_f1.update(preds, y)
+        self.test_precision.update(preds, y)
+        self.test_recall.update(preds, y)
+        
+        self.log('test_loss', loss, on_epoch=True)
+        
+        return loss
+    
+    def on_test_epoch_end(self):
+
+        acc = self.test_acc.compute()
+        f1 = self.test_f1.compute()
+        precision = self.test_precision.compute()
+        recall = self.test_recall.compute()
+        
+        self.log('test_acc', acc, prog_bar=True)
+        self.log('test_f1', f1, prog_bar=True)
+        
+        test_preds = torch.cat(self.test_preds)
+        test_labels = torch.cat(self.test_labels)
+
+        cm = confusion_matrix(test_labels.numpy(), test_preds.numpy())
+        self._plot_confusion_matrix(cm, "Test")
+        
+        print("\n" + "="*80)
+        print("Test Results - Per-Class Metrics:")
+        print("="*80)
+        print(f"{'Class':<10} {'Precision':<12} {'Recall':<12} {'Instances correctly classified':<10}")
+        print("-"*80)
+        
+        for i, cls_name in enumerate(self.cfg.label_classes):
+            support = (test_labels == i).sum().item()
+            print(f"{cls_name:<10} {precision[i]:.4f}       {recall[i]:.4f}       {support:<10}")
+        
+        print("-"*80)
+        print(f"{'Overall':<10} {'Acc: ' + f'{acc:.4f}':<12} {'F1: ' + f'{f1:.4f}':<12}")
+        print("="*80 + "\n")
+        
+        # print("Grad-CAM visualizations!")
+        # self._generate_gradcam_visualizations()
+        
+        self.test_acc.reset()
+        self.test_f1.reset()
+        self.test_precision.reset()
+        self.test_recall.reset()
+        self.test_preds.clear()
+        self.test_labels.clear()
+
+    def _plot_confusion_matrix(self, cm: np.ndarray, title: str = "Validation"):
+
+        cmn = cm.astype('float') / (cm.sum(axis=1)[:, np.newaxis] + 1e-10)
+        
+        fig, ax = plt.subplots(figsize=(12, 10))
+        sns.heatmap(
+            cmn, 
+            annot=True, 
+            fmt='.2f', 
+            cmap="Blues", 
+            ax=ax,
+            xticklabels=self.cfg.label_classes,
+            yticklabels=self.cfg.label_classes,
+            cbar_kws={'label': 'Normalized Count'}
+        )
+        ax.set_xlabel("Predicted Label", fontsize=12)
+        ax.set_ylabel("True Label", fontsize=12)
+        ax.set_title(f"{title} Confusion Matrix (Epoch {self.current_epoch})", fontsize=14)
+        
+        plt.tight_layout()
+        self.logger.experiment.add_figure(
+            f"{title}_Confusion_Matrix", 
+            fig, 
+            self.current_epoch
+        )
+        plt.close(fig)
+
+    def _log_per_class_metrics(self, precision: np.ndarray, recall: np.ndarray):
+        for i, cls_name in enumerate(self.cfg.label_classes):
+            self.logger.experiment.add_scalars(
+                f"PerClass/{cls_name}",
+                {
+                    "precision": precision[i],
+                    "recall": recall[i],
+                },
+                self.current_epoch,
+            )
+
+    def _find_last_conv_module(self, module: nn.Module):       
+        last_conv = [self.model.features[-1][-1]]
+
+        for m in module.modules():
+            if type(m) is nn.Conv2d:
+                last_conv = m
+        return last_conv
+
+    def _generate_gradcam_visualizations(self):
+        if not self.sample_images:
+            print("No sample images")
+            return
+
+        target_conv = self._find_last_conv_module(self.model)
+
+        if target_conv is None:
+            raise RuntimeError("Not found last layer :(")
+        
+        target_layers = [target_conv]
+        print(f"Target layer: {target_conv}")
+
+        cam = GradCAM(model=self.model, target_layers=target_layers)
+
+        self.model.eval()
+
+        orig_requires = [p.requires_grad for p in self.model.parameters()]
+        for p in self.model.parameters():
+            p.requires_grad_(True)
+
+        fig, axes = plt.subplots(2, self.cfg.num_classes, figsize=(24, 8))
+
+        try:
+            for cls_idx in range(self.cfg.num_classes):
+                if cls_idx not in self.sample_images:
+                    axes[0, cls_idx].axis('off')
+                    axes[1, cls_idx].axis('off')
+                    continue
+
+                sample = self.sample_images[cls_idx]
+                
+                img_tensor = sample["image"].unsqueeze(0).to(self.device).float()
+                true_label = int(sample["label"])
+                pred_label = int(sample["pred"])
+
+                targets = [ClassifierOutputTarget(pred_label)]
+
+                with torch.enable_grad():
+                    img_tensor.requires_grad_(True)
+                    out = self.model(img_tensor)
+
+                    test_loss = out[0, pred_label]
+                    test_loss.backward(retain_graph=True)
+
+                    grayscale_cam = cam(input_tensor=img_tensor, targets=targets)
+                    grayscale_cam = grayscale_cam[0, :]
+
+                img_np = img_tensor.squeeze(0).detach().cpu().numpy().transpose(1, 2, 0)
+                mean = np.array([0.485, 0.456, 0.406])
+                std = np.array([0.229, 0.224, 0.225])
+                img_np = img_np * std + mean
+                img_np = np.clip(img_np, 0, 1)
+
+                visualization = show_cam_on_image(img_np, grayscale_cam, use_rgb=True)
+
+                axes[0, cls_idx].imshow(img_np)
+                axes[0, cls_idx].set_title(
+                    f"{self.cfg.label_classes[cls_idx]}\nTrue: {self.cfg.label_classes[true_label]}",
+                    fontsize=10
+                )
+                axes[0, cls_idx].axis('off')
+
+                axes[1, cls_idx].imshow(visualization)
+                axes[1, cls_idx].set_title(
+                    f"Pred: {self.cfg.label_classes[pred_label]}",
+                    fontsize=10,
+                    color='green' if true_label == pred_label else 'red'
+                )
+                axes[1, cls_idx].axis('off')
+
+            plt.suptitle("Grad-CAM Visualizations - Model Focus Areas", fontsize=16, y=1.02)
+            plt.tight_layout()
+
+            self.logger.experiment.add_figure( "GradCAM_Visualizations", fig, self.current_epoch)
+
+            print("Grad-CAM visualizations - SUCCESS!")
+            
+        finally:
+            plt.close(fig)
+            for p, orig in zip(self.model.parameters(), orig_requires):
+                p.requires_grad_(orig)
+            try:
+                del cam
+            except Exception:
+                pass
+
+    def _setup_metrics(self):
+        num_classes = self.cfg.num_classes
+        
+        self.train_acc = torchmetrics.Accuracy(task='multiclass', num_classes=num_classes)
+        self.train_f1 = torchmetrics.F1Score(task='multiclass', num_classes=num_classes, average='macro')
+        
+        self.val_acc = torchmetrics.Accuracy(task='multiclass', num_classes=num_classes, average='macro')
+        self.val_f1 = torchmetrics.F1Score(task='multiclass', num_classes=num_classes, average='macro')
+        self.val_precision = torchmetrics.Precision(task='multiclass', num_classes=num_classes, average=None)
+        self.val_recall = torchmetrics.Recall(task='multiclass', num_classes=num_classes, average=None)
+        
+        self.test_acc = torchmetrics.Accuracy(task='multiclass', num_classes=num_classes, average='macro')
+        self.test_f1 = torchmetrics.F1Score(task='multiclass', num_classes=num_classes, average='macro')
+        self.test_precision = torchmetrics.Precision(task='multiclass', num_classes=num_classes, average=None)
+        self.test_recall = torchmetrics.Recall(task='multiclass', num_classes=num_classes, average=None)
+        
+        self.val_preds = []
+        self.val_labels = []
+        self.test_preds = []
+        self.test_labels = []

model_params_val_f1=0.878.ckpt

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

requirements.txt

@@ -0,0 +1,9 @@
+torch
+torchvision
+pytorch_lightning
+gradio
+numpy
+scikit-learn
+matplotlib
+seaborn
+pytorch-grad-cam