Initial model upload

app.py

@@ -0,0 +1,17 @@
+import gradio as gr
+from inference import predict
+
+def classify(image):
+    idx, label, probs = predict(image)
+    return {label: float(1.0)}
+
+demo = gr.Interface(
+    fn=classify,
+    inputs=gr.Image(type="filepath", label="Upload a dermatoscopic image"),
+    outputs=gr.Label(label="Predicted lesion"),
+    title="Derm-CNN HAM10000 – Skin Lesion Classifier",
+    description="Upload a dermatoscopic image and get the predicted skin lesion class.",
+    allow_flagging="never"
+)
+
+demo.launch()

inference.py

@@ -0,0 +1,90 @@
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import torch
+from PIL import Image
+
+from model import load_model
+
+
+def load_labels(labels_path: str = "labels.json") -> dict[int, str]:
+    labels_file = Path(labels_path)
+    if not labels_file.exists():
+        raise FileNotFoundError(f"labels.json not found at: {labels_file}")
+
+    with labels_file.open("r", encoding="utf-8") as f:
+        raw = json.load(f)
+
+    return {int(k): v for k, v in raw.items()}
+
+
+def preprocess_image(image_path: str) -> torch.Tensor:
+    img_file = Path(image_path)
+    if not img_file.exists():
+        raise FileNotFoundError(f"Image not found at: {img_file}")
+
+    img = Image.open(img_file).convert("RGB")
+    img = img.resize((28, 28))
+
+    arr = np.array(img).astype("float32") / 255.0  # [H, W, C] in [0,1]
+    arr = np.transpose(arr, (2, 0, 1))            # [C, H, W]
+    tensor = torch.from_numpy(arr).unsqueeze(0)   # [1, 3, 28, 28]
+
+    return tensor
+
+
+def predict(
+    image_path: str,
+    weights_path: str = "model.pth",
+    labels_path: str = "labels.json"
+):
+    model, device = load_model(weights_path)
+    id2label = load_labels(labels_path)
+
+    x = preprocess_image(image_path).to(device)
+
+    with torch.no_grad():
+        logits = model(x)
+        probs = torch.softmax(logits, dim=1)[0]
+
+    pred_idx = int(torch.argmax(probs).item())
+    pred_label = id2label.get(pred_idx, str(pred_idx))
+    probs_list = probs.cpu().tolist()
+
+    return pred_idx, pred_label, probs_list
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run inference with SkinCNN on a dermatoscopic image."
+    )
+    parser.add_argument("image", type=str, help="Path to input dermatoscopic image.")
+    parser.add_argument(
+        "--weights",
+        type=str,
+        default="model.pth",
+        help="Path to model weights (.pth).",
+    )
+    parser.add_argument(
+        "--labels",
+        type=str,
+        default="labels.json",
+        help="Path to labels.json.",
+    )
+    args = parser.parse_args()
+
+    idx, label, probs = predict(
+        image_path=args.image,
+        weights_path=args.weights,
+        labels_path=args.labels,
+    )
+
+    print(f"Predicted class index: {idx}")
+    print(f"Predicted label      : {label}")
+    print(f"Probabilities        : {probs}")
+
+
+if __name__ == "__main__":
+    main()

labels.json

@@ -0,0 +1,9 @@
+{
+  "0": "Actinic keratoses (akiec)",
+  "1": "Basal cell carcinoma (bcc)",
+  "2": "Benign keratosis (bkl)",
+  "3": "Dermatofibroma (df)",
+  "4": "Melanoma (mel)",
+  "5": "Melanocytic nevi (nv)",
+  "6": "Vascular lesions (vasc)"
+}

model.pth

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

model.py

@@ -0,0 +1,91 @@
+import torch
+import torch.nn as nn
+
+
+class SkinCNN(nn.Module):
+    def __init__(self, num_classes: int = 7):
+        super().__init__()
+
+        # Feature extractor
+        self.features = nn.Sequential(
+            # Block 1: 3 -> 32
+            nn.Conv2d(3, 32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2),      # 28x28 -> 14x14
+            nn.BatchNorm2d(32),
+
+            # Block 2: 32 -> 64 -> 64
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2),      # 14x14 -> 7x7
+            nn.BatchNorm2d(64),
+
+            # Block 3: 64 -> 128 -> 128
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2),      # 7x7 -> 3x3
+            nn.BatchNorm2d(128),
+
+            # Block 4: 128 -> 256 -> 256
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2)       # 3x3 -> 1x1
+        )
+
+        # Classifier: 5 FC layers with BatchNorm + Dropout at input
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Dropout(0.2),
+
+            # 256*1*1 -> 256
+            nn.Linear(256 * 1 * 1, 256),
+            nn.ReLU(),
+            nn.BatchNorm1d(256),
+
+            # 256 -> 128
+            nn.Linear(256, 128),
+            nn.ReLU(),
+            nn.BatchNorm1d(128),
+
+            # 128 -> 64
+            nn.Linear(128, 64),
+            nn.ReLU(),
+            nn.BatchNorm1d(64),
+
+            # 64 -> 32
+            nn.Linear(64, 32),
+            nn.ReLU(),
+            nn.BatchNorm1d(32),
+
+            # 32 -> num_classes
+            nn.Linear(32, num_classes)
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.features(x)
+        x = self.classifier(x)
+        return x
+
+
+def load_model(
+    weights_path: str = "model.pth",
+    device: str | None = None
+) -> tuple[nn.Module, torch.device]:
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+    device = torch.device(device)
+
+    model = SkinCNN(num_classes=7)
+    state_dict = torch.load(weights_path, map_location=device)
+    model.load_state_dict(state_dict)
+
+    model.to(device)
+    model.eval()
+
+    return model, device

requirements.txt

@@ -0,0 +1,5 @@
+torch
+torchvision
+numpy
+pillow
+gradio