testing

README.md

@@ -1,12 +1,75 @@
 ---
-title: Leprosy
-emoji: 👀
-colorFrom: purple
-colorTo: indigo
+title: Leprosy Detection
+emoji: ⚡
+colorFrom: red
+colorTo: gray
 sdk: gradio
-sdk_version: 5.6.0
+sdk_version: 3.44.4
 app_file: app.py
 pinned: false
+license: cc-by-4.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Leprosy Detection App
+
+Leprosy Gradio Detection web application. In this application, I have used a fine tuned YOLOv5s model to detect Leprosy samples based on images. The application uses gradio as the platform and can also be used in the [Huggingface online hosting application](https://huggingface.co/spaces/Arekku21/Leprosy-Detection). 
+
+## Overview
+[Leprosy](https://en.wikipedia.org/wiki/Leprosy), also known as Hansen's disease, is a chronic infectious disease that primarily affects the skin and peripheral nerves. The model used is a YOLO model from [Ultralytics](https://github.com/ultralytics/yolov5) with their version YOLOv5. 
+
+### Features
+
+- Upload an image to the app.
+- Utilizes a fine-tuned YOLOv5s model for leprosy detection.
+- Detect and label leprosy regions in the uploaded image.
+
+## Prerequisites
+
+Before running the application, make sure you have the following prerequisites installed on your system:
+
+- Python 3.x 
+- Git
+- Gradio
+- Pip package manager
+- Conda Virtual environment (optional but recommended)
+
+### Installation Steps and Running the app
+
+To install the required Python libraries, navigate to the project directory and run the following command:
+
+#### Step 1 Clone the repository
+```
+# Make sure you have git-lfs installed (https://git-lfs.com)
+git lfs install
+git clone https://huggingface.co/spaces/Arekku21/Leprosy-Detection
+
+# if you want to clone without large files – just their pointers
+# prepend your git clone with the following env var:
+GIT_LFS_SKIP_SMUDGE=1
+```
+
+#### Step 2 Install requirements
+```
+#navigate to your cloned repository and location of requirmenents.txt
+pip install -r requirements.txt
+```
+
+#### Step 3 Run the app
+```
+#ensure that you are using the right environment or have all the requirements installed
+#ensure that you are navigated to the cloned repository
+python app.py
+```
+
+#### Step 4 Using the app
+Your terminal should look like this and follow the local host URL link to use the application. 
+```
+Downloading: "https://github.com/ultralytics/yolov5/zipball/master" to C:\Users\master.zip
+
+YOLOv5  2023-9-28 Python-3.9.18 torch-2.0.1+cpu CPU
+
+Fusing layers... 
+Model summary: 157 layers, 7015519 parameters, 0 gradients, 15.8 GFLOPs
+Adding AutoShape...
+Running on local URL:  http://127.0.0.1:7860
+```

app.py

@@ -0,0 +1,208 @@
+import gradio as gr
+import torch
+import torch.nn as nn
+from torchvision import transforms
+from PIL import Image
+import cv2
+import numpy as np
+import requests
+import os
+from typing import Tuple, Dict
+
+# CustomViT model definition
+class PatchEmbedding(nn.Module):
+    def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768):
+        super().__init__()
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.n_patches = (img_size // patch_size) ** 2
+        self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size)
+
+    def forward(self, x):
+        x = self.proj(x)
+        x = x.flatten(2)
+        x = x.transpose(1, 2)
+        return x
+
+class Attention(nn.Module):
+    def __init__(self, dim, n_heads=12, qkv_bias=True, attn_drop=0., proj_drop=0.):
+        super().__init__()
+        self.n_heads = n_heads
+        self.scale = (dim // n_heads) ** -0.5
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(self, x):
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.n_heads, C // self.n_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)
+        attn = (q @ k.transpose(-2, -1)) * self.scale
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+class TransformerBlock(nn.Module):
+    def __init__(self, dim, n_heads, mlp_ratio=4., qkv_bias=True, drop=0., attn_drop=0.):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attn = Attention(dim, n_heads=n_heads, qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop)
+        self.norm2 = nn.LayerNorm(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = nn.Sequential(
+            nn.Linear(dim, mlp_hidden_dim),
+            nn.GELU(),
+            nn.Dropout(drop),
+            nn.Linear(mlp_hidden_dim, dim),
+            nn.Dropout(drop)
+        )
+
+    def forward(self, x):
+        x = x + self.attn(self.norm1(x))
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+class CustomViT(nn.Module):
+    def __init__(self, img_size=224, patch_size=16, in_channels=3, num_classes=2, embed_dim=768, depth=12, n_heads=12, mlp_ratio=4., qkv_bias=True, drop_rate=0.):
+        super().__init__()
+        self.patch_embed = PatchEmbedding(img_size, patch_size, in_channels, embed_dim)
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, 1 + self.patch_embed.n_patches, embed_dim))
+        self.pos_drop = nn.Dropout(p=drop_rate)
+        self.blocks = nn.ModuleList([
+            TransformerBlock(embed_dim, n_heads, mlp_ratio, qkv_bias, drop_rate, drop_rate)
+            for _ in range(depth)
+        ])
+        self.norm = nn.LayerNorm(embed_dim)
+        self.head = nn.Linear(embed_dim, num_classes)
+
+    def forward(self, x):
+        B = x.shape[0]
+        x = self.patch_embed(x)
+        cls_tokens = self.cls_token.expand(B, -1, -1)
+        x = torch.cat((cls_tokens, x), dim=1)
+        x = x + self.pos_embed
+        x = self.pos_drop(x)
+        for block in self.blocks:
+            x = block(x)
+        x = self.norm(x)
+        x = x[:, 0]
+        x = self.head(x)
+        return x
+
+# Helper functions
+def load_model(model_path: str) -> CustomViT:
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = CustomViT(num_classes=2)
+    state_dict = torch.load(model_path, map_location=device)
+    
+    # Remove 'module.' prefix if present
+    if all(k.startswith('module.') for k in state_dict.keys()):
+        state_dict = {k[7:]: v for k, v in state_dict.items()}
+    
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+    return model
+
+def preprocess_image(image: np.ndarray) -> torch.Tensor:
+    # Convert numpy array to PIL Image
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+    
+    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])
+    ])
+    return transform(image).unsqueeze(0)
+
+def predict_image(image: np.ndarray, model: CustomViT) -> Tuple[np.ndarray, Dict[str, float]]:
+    device = next(model.parameters()).device
+    
+    # Preprocess the image
+    image_tensor = preprocess_image(image)
+    
+    # Make prediction
+    with torch.no_grad():
+        outputs = model(image_tensor.to(device))
+        probabilities = torch.nn.functional.softmax(outputs, dim=1)[0]
+        
+    # Create visualization
+    visualization = image.copy()
+    height, width = visualization.shape[:2]
+    
+    # Add prediction overlay
+    result = "Leprosy" if probabilities[0] > probabilities[1] else "No Leprosy"
+    confidence = float(probabilities[0] if result == "Leprosy" else probabilities[1])
+    
+    # Add text to image
+    color = (0, 0, 255) if result == "Leprosy" else (0, 255, 0)
+    cv2.putText(visualization, f"{result}: {confidence:.2%}", 
+                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
+    
+    # Convert BGR to RGB for Gradio
+    visualization = cv2.cvtColor(visualization, cv2.COLOR_BGR2RGB)
+    
+    # Prepare labels dictionary
+    labels = {
+        "Leprosy": float(probabilities[0]),
+        "No Leprosy": float(probabilities[1])
+    }
+    
+    return visualization, labels
+
+# Download example images
+file_urls = [
+    'https://www.dropbox.com/scl/fi/onrg1u9tqegh64nsfmxgr/lp2.jpg?rlkey=2vgw5n6abqmyismg16mdd1v3n&dl=1',
+    'https://www.dropbox.com/scl/fi/xq103ic7ovuuei3l9e8jf/lp1.jpg?rlkey=g7d9khyyc6wplv0ljd4mcha60&dl=1',
+    'https://www.dropbox.com/scl/fi/fagkh3gnio2pefdje7fb9/Non_Leprosy_210823_86_jpg.rf.5bb80a7704ecc6c8615574cad5d074c5.jpg?rlkey=ks8afue5gsx5jqvxj3u9mbjmg&dl=1',
+]
+
+def download_example_images():
+    examples = []
+    for i, url in enumerate(file_urls):
+        filename = f"example_{i}.jpg"
+        if not os.path.exists(filename):
+            response = requests.get(url)
+            with open(filename, 'wb') as f:
+                f.write(response.content)
+        examples.append(filename)
+    return examples
+
+# Main Gradio interface
+def create_gradio_interface():
+    # Load the model
+    model = load_model('best_custom_vit_mo50.pth')
+    
+    # Create inference function
+    def inference(image):
+        return predict_image(image, model)
+    
+    # Download example images
+    examples = download_example_images()
+    
+    # Create Gradio interface
+    interface = gr.Interface(
+        fn=inference,
+        inputs=gr.Image(),
+        outputs=[
+            gr.Image(label="Prediction Visualization"),
+            gr.Label(label="Classification Probabilities")
+        ],
+        title="Leprosy Detection using Vision Transformer",
+        description="Upload an image to detect signs of leprosy using a Vision Transformer model.",
+        examples=examples,
+        cache_examples=False
+    )
+    
+    return interface
+
+if __name__ == "__main__":
+    interface = create_gradio_interface()
+    interface.launch()
+    

best_custom_vit_mo50.pth

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

requirements.txt

@@ -0,0 +1,44 @@
+# Deep Learning Framework -------------------------------------
+torch>=1.8.0
+torchvision>=0.9.0
+
+# Web Interface and Visualization ----------------------------
+gradio>=4.0.0
+matplotlib>=3.3
+seaborn>=0.11.0
+pandas>=1.1.4
+
+# Image Processing and Data Handling -------------------------
+opencv-python>=4.1.1
+Pillow>=7.1.2
+numpy>=1.22.2
+scipy>=1.4.1
+requests>=2.23.0
+
+# YOLOv5 Specific Dependencies ------------------------------
+ultralytics>=8.0.147
+thop>=0.1.1  # FLOPs computation
+PyYAML>=5.3.1
+psutil  # system resources
+tqdm>=4.64.0
+gitpython>=3.1.30
+
+# CUDA Support (optional) -----------------------------------
+--extra-index-url https://download.pytorch.org/whl/cu118
+torch
+torchvision
+
+# Development Tools (optional) ------------------------------
+# tensorboard>=2.4.1
+# clearml>=1.2.0
+# ipython  # interactive notebook
+# albumentations>=1.0.3
+# pycocotools>=2.0.6  # COCO mAP
+
+# Export Tools (optional) ----------------------------------
+# onnx>=1.10.0  # ONNX export
+# onnx-simplifier>=0.4.1  # ONNX simplifier
+# coremltools>=6.0  # CoreML export
+# tensorflow>=2.4.0  # TF exports
+# tensorflowjs>=3.9.0  # TF.js export
+# openvino-dev>=2023.0  # OpenVINO export