Added multi pages

app.py

@@ -1,125 +1,23 @@
-# Directory Structure Suggestion:
-# diabetic_retinopathy_app/
-# ├── Home.py (Landing Page)
-# ├── pages/
-# │   ├── 1_Upload_and_Predict.py
-# │   └── 2_Model_Evaluation.py
-# └── assets/
-#     └── banner.jpg
-
-# Home.py (Landing Page)
 import streamlit as st
 from PIL import Image
 
 def main():
     st.set_page_config(page_title="DR Assistive Tool", layout="centered")
-    st.title("Welcome to the Diabetic Retinopathy Assistive Tool")
+    # st.image("assets/banner.jpg", use_column_width=True)
+    st.markdown("<h1 style='text-align: center; color: #2E86C1;'>DR Assistive Tool</h1>", unsafe_allow_html=True)
 
     st.markdown("""
-    ### 🌟 Your AI-powered assistant for early detection of Diabetic Retinopathy.
-
-    #### Features:
-    - 🖼️ Upload a retinal image and receive a prediction of its DR stage.
-    - 📊 Evaluate model performance using real test datasets.
+    <h4 style='text-align: center; color: grey;'>An AI-powered assistant for early detection of Diabetic Retinopathy</h4>
+    """, unsafe_allow_html=True)
 
-    Select a page from the left sidebar to get started.
+    st.markdown("""
+    ---
+    ### 🛠 Features:
+    - **Upload** retinal images to predict DR stage.
+    - **Evaluate** the model using real test datasets.
+    
+    👉 Use the sidebar to navigate between features.
     """)
 
-    # image = Image.open("assets/banner.jpg")  # Optional banner image
-    # st.image(image, use_column_width=True)
-
 if __name__ == '__main__':
     main()
-
-
-# pages/1_Upload_and_Predict.py
-import streamlit as st
-import torch
-from torchvision import transforms, models
-from PIL import Image
-import numpy as np
-
-st.title("📷 Upload & Predict Diabetic Retinopathy")
-
-class_names = ['No DR', 'Mild', 'Moderate', 'Severe', 'Proliferative DR']
-
-def load_model():
-    model = models.densenet121(pretrained=False)
-    num_ftrs = model.classifier.in_features
-    model.classifier = torch.nn.Linear(num_ftrs, len(class_names))
-    model.load_state_dict(torch.load("training/Pretrained_Densenet-121.pth", map_location='cpu'))
-    model.eval()
-    return model
-
-transform = transforms.Compose([
-    transforms.Resize(256),
-    transforms.CenterCrop(224),
-    transforms.ToTensor(),
-    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
-])
-
-def predict_image(model, image):
-    img_tensor = transform(image).unsqueeze(0)
-    with torch.no_grad():
-        outputs = model(img_tensor)
-        _, pred = torch.max(outputs, 1)
-        prob = torch.nn.functional.softmax(outputs, dim=1)[0][pred].item() * 100
-    return class_names[pred.item()], prob
-
-uploaded_file = st.file_uploader("Choose a retinal image", type=["jpg", "png"])
-if uploaded_file is not None:
-    image = Image.open(uploaded_file).convert('RGB')
-    st.image(image, caption='Uploaded Retinal Image', use_column_width=True)
-
-    if st.button("🧠 Predict"):
-        with st.spinner('Analyzing image...'):
-            model = load_model()
-            pred_class, prob = predict_image(model, image)
-            st.success(f"Prediction: **{pred_class}** ({prob:.2f}% confidence)")
-
-
-# pages/2_Model_Evaluation.py
-import streamlit as st
-import torch
-from torch.utils.data import DataLoader
-from torchvision import datasets, transforms, models
-import torch.nn as nn
-from tqdm import tqdm
-
-st.title("📈 Model Evaluation on Test Dataset")
-
-@st.cache_data
-
-def load_test_data():
-    transform = transforms.Compose([
-        transforms.Resize(256),
-        transforms.CenterCrop(224),
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
-    ])
-    test_data = datasets.ImageFolder("test_dataset_path", transform=transform)
-    return DataLoader(test_data, batch_size=32, shuffle=False)
-
-def evaluate(model, loader):
-    model.eval()
-    correct, total, loss = 0, 0, 0.0
-    criterion = nn.CrossEntropyLoss()
-    with torch.no_grad():
-        for inputs, labels in loader:
-            outputs = model(inputs)
-            loss += criterion(outputs, labels).item()
-            _, pred = torch.max(outputs, 1)
-            correct += (pred == labels).sum().item()
-            total += labels.size(0)
-    return loss / len(loader), correct / total * 100
-
-if st.button("🧪 Evaluate Trained Model"):
-    test_loader = load_test_data()
-    model = models.densenet121(pretrained=False)
-    model.classifier = nn.Linear(model.classifier.in_features, 5)
-    model.load_state_dict(torch.load("dr_densenet121.pth", map_location='cpu'))
-    model.eval()
-
-    loss, acc = evaluate(model, test_loader)
-    st.write(f"**Test Loss:** {loss:.4f}")
-    st.write(f"**Test Accuracy:** {acc:.2f}%")

pages/Model_Evaluation.py

@@ -0,0 +1,129 @@
+import streamlit as st
+import torch
+from torch.utils.data import DataLoader, Dataset
+from torchvision import transforms, models
+import torch.nn as nn
+from PIL import Image
+import pandas as pd
+import os
+import cv2
+import numpy as np
+
+st.markdown("<h2 style='color: #2E86C1;'>📈 Model Evaluation</h2>", unsafe_allow_html=True)
+
+# Define class names and label map
+class_names = ['No_DR', 'Mild', 'Moderate', 'Severe', 'Proliferative_DR']
+label_map = {label: idx for idx, label in enumerate(class_names)}
+
+# Define your image preprocessing functions
+def apply_median_filter(image):
+    return cv2.medianBlur(image, 5)
+
+def apply_clahe(image):
+    lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)
+    l, a, b = cv2.split(lab)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    cl = clahe.apply(l)
+    merged = cv2.merge((cl, a, b))
+    return cv2.cvtColor(merged, cv2.COLOR_LAB2RGB)
+
+def apply_gamma_correction(image, gamma=1.5):
+    invGamma = 1.0 / gamma
+    table = np.array([(i / 255.0) ** invGamma * 255 for i in np.arange(256)]).astype("uint8")
+    return cv2.LUT(image, table)
+
+def apply_gaussian_filter(image, kernel_size=(5, 5), sigma=1.0):
+    return cv2.GaussianBlur(image, kernel_size, sigma)
+
+# Custom dataset with preprocessing
+class DDRDataset(Dataset):
+    def __init__(self, csv_path, img_dir, transform=None):
+        self.data = pd.read_csv(csv_path)
+        self.img_dir = img_dir
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        img_name = self.data.iloc[idx, 0]
+        label_name = self.data.iloc[idx, 1]
+        label = int(label_map.get(label_name, 0))  # fallback to 0
+
+        img_path = os.path.join(self.img_dir, img_name)
+        image = cv2.imread(img_path)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+        image = apply_median_filter(image)
+        image = apply_clahe(image)
+        image = apply_gamma_correction(image)
+        image = apply_gaussian_filter(image)
+
+        image = Image.fromarray(image)
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label
+
+# -------------------------------
+# Load Test Data with Caching
+# -------------------------------
+@st.cache_resource
+def load_test_data():
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406],
+                             [0.229, 0.224, 0.225])
+    ])
+    dataset = DDRDataset(
+        csv_path="D:/DR_Classification/splits/test_labels.csv",
+        img_dir="D:/DR_Classification/splits/test",
+        transform=transform
+    )
+    return DataLoader(dataset, batch_size=32, shuffle=False)
+
+# -------------------------------
+# Evaluation Function
+# -------------------------------
+def evaluation_test_model(model, test_loader, criterion, device='cpu'):
+    model.eval()
+    running_loss = 0.0
+    correct = 0
+    total = 0
+
+    with torch.no_grad():
+        for inputs, labels in test_loader:
+            inputs, labels = inputs.to(device), labels.to(device)
+            outputs = model(inputs)
+            loss = criterion(outputs, labels)
+
+            running_loss += loss.item()
+            _, predicted = torch.max(outputs, 1)
+            correct += (predicted == labels).sum().item()
+            total += labels.size(0)
+
+    val_loss = running_loss / len(test_loader)
+    val_acc = correct / total * 100
+    return val_loss, val_acc
+
+# -------------------------------
+# Evaluation Button Trigger
+# -------------------------------
+if st.button("🔍 Evaluate Trained Model"):
+    with st.spinner("Evaluating on test data..."):
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        test_loader = load_test_data()
+
+        model = models.densenet121(pretrained=False)
+        model.classifier = nn.Linear(model.classifier.in_features, len(class_names))
+        model.load_state_dict(torch.load("training/Pretrained_Densenet-121.pth", map_location=device))
+        model.to(device)
+
+        criterion = nn.CrossEntropyLoss()
+        val_loss, val_acc = evaluation_test_model(model, test_loader, criterion, device)
+
+        st.success("✅ Evaluation Complete")
+        st.metric("Test Loss", f"{val_loss:.4f}")
+        st.metric("Test Accuracy", f"{val_acc:.2f}%")

pages/Upload_and_Predict.py

@@ -0,0 +1,44 @@
+import streamlit as st
+import torch
+from torchvision import transforms, models
+from PIL import Image
+import numpy as np
+
+st.markdown("<h2 style='color: #2E86C1;'>📷 Upload & Predict</h2>", unsafe_allow_html=True)
+
+class_names = ['No DR', 'Mild', 'Moderate', 'Severe', 'Proliferative DR']
+
+@st.cache_resource
+def load_model():
+    model = models.densenet121(pretrained=False)
+    model.classifier = torch.nn.Linear(model.classifier.in_features, len(class_names))
+    model.load_state_dict(torch.load("training/Pretrained_Densenet-121.pth", map_location='cpu'))
+    model.eval()
+    return model
+
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+def predict_image(model, image):
+    img_tensor = transform(image).unsqueeze(0)
+    with torch.no_grad():
+        outputs = model(img_tensor)
+        _, pred = torch.max(outputs, 1)
+        prob = torch.nn.functional.softmax(outputs, dim=1)[0][pred].item() * 100
+    return class_names[pred.item()], prob
+
+uploaded_file = st.file_uploader("📁 Upload Retinal Image", type=["jpg", "png"])
+
+if uploaded_file is not None:
+    image = Image.open(uploaded_file).convert('RGB')
+    st.image(image, caption='🖼 Uploaded Image', use_column_width=True)
+
+    if st.button("🧠 Predict"):
+        with st.spinner('Analyzing image...'):
+            model = load_model()
+            pred_class, prob = predict_image(model, image)
+            st.success(f"🎯 Prediction: **{pred_class}** ({prob:.2f}% confidence)")