Completed other pages and added dataset page

app.py

@@ -3,20 +3,44 @@ from PIL import Image
 
 def main():
     st.set_page_config(page_title="DR Assistive Tool", layout="centered")
-    # 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("""
-    <h4 style='text-align: center; color: grey;'>An AI-powered assistant for early detection of Diabetic Retinopathy</h4>
+    <h4 style='text-align: center; color: grey;'>
+        An AI-powered assistant for early detection of Diabetic Retinopathy
+    </h4>
     """, unsafe_allow_html=True)
 
+    st.markdown("""---""")
+
+    st.markdown("""
+    ### 🧠 What is DR Assistive Tool?
+    **DR Assistive Tool** is a user-friendly web application built for early and accurate detection of **Diabetic Retinopathy (DR)**—a diabetes-related eye disease that can lead to blindness if not diagnosed in time. This tool uses **AI and deep learning models** trained on retinal images to help healthcare professionals, students, and researchers identify the severity stage of DR.
+
+    By simply uploading a retinal image, the model will:
+    - Analyze the image using advanced machine learning techniques
+    - Predict the stage of Diabetic Retinopathy (No DR, Mild, Moderate, Severe, Proliferative DR)
+    - Provide a quick, reliable, and cost-efficient second opinion for screening
+
+    The app also offers evaluation options to test the model's performance using real datasets, ensuring its credibility and practical usability.
+    """)
+
     st.markdown("""
     ---
     ### 🛠 Features:
-    - **Upload** retinal images to predict DR stage.
-    - **Evaluate** the model using real test datasets.
-    
-    👉 Use the sidebar to navigate between features.
+    - 📤 **Upload retinal images** for DR stage prediction
+    - 📊 **Evaluate** the model using real test datasets
+    - 📁 **View results** with interpretation and confidence score
+    - 📈 **Analyze model performance** using accuracy, precision, confusion matrix, and more (in evaluation mode)
+
+    ---
+    ### 📌 How to Use:
+    1. Use the **sidebar** to select a feature (e.g., Predict or Evaluate).
+    2. In **Evaluate**, to check model accuracy.
+    3. In **Predict**, choose an DR image in sample images to predict or upload a high-quality retinal image (JPEG or PNG).
+
+    ⚠️ *Note: This tool is not a diagnostic tool. This is an assistive tool for Doctors.*
     """)
 
 if __name__ == '__main__':

pages/Dataset.py

@@ -0,0 +1,62 @@
+import streamlit as st
+import pandas as pd
+import os
+from PIL import Image
+
+st.set_page_config(layout="wide")
+st.title("📂 Dataset Information")
+
+# Introduction
+st.markdown("""
+### 🧾 Dataset Overview
+
+## Dataset Descrption
+
+### DDR dataset contains 13,673 fundus images from 147 hospitals, covering 23 provinces in China. The images are classified into 5 classes according to DR severity: none, mild, moderate, severe, and proliferative DR. There is a sixth category which indicates the images with poor quality. The dataset presented here does not include the images with poor quality (sixth category) and all images have been preprocessed to delete the black background. https://www.kaggle.com/datasets/mariaherrerot/ddrdataset
+
+- **No_DR**
+- **Mild**
+- **Moderate**
+- **Severe**
+- **Proliferative_DR**
+""")
+
+# Dataset preparation explanation
+st.markdown("""
+### 🧪 Data Preparation & Splitting
+
+The original dataset was preprocessed and resized to **224x224 pixels**. It was then split into three sets:
+
+- **Training Set**: Used to train the model.
+- **Validation Set** *(optional)*: Used to fine-tune hyperparameters.
+- **Testing Set**: Used for final model evaluation.
+
+We used an 80-20 stratified split:
+- **80%** of the data was used for training.
+- **20%** was reserved for testing, ensuring each class was proportionally represented.
+
+A CSV file (`test_labels.csv`) was created for the test set, containing the filenames and their corresponding class labels.
+""")
+
+# Visualizing the test dataset
+st.markdown("### 📸 Sample Images from Test Dataset")
+
+csv_path = "D:/DR_Classification/splits/test_labels.csv"
+img_dir = "D:/DR_Classification/splits/test"
+
+try:
+    df = pd.read_csv(csv_path)
+    class_names = df.iloc[:, 1].unique()
+
+    for class_name in class_names:
+        st.subheader(f"🔍 Class: {class_name}")
+        class_samples = df[df.iloc[:, 1] == class_name].head(3)
+        cols = st.columns(len(class_samples))
+
+        for i, row in enumerate(class_samples.itertuples()):
+            img_path = os.path.join(img_dir, row[1])
+            if os.path.exists(img_path):
+                image = Image.open(img_path).convert('RGB')
+                cols[i].image(image, caption=row[1], use_column_width=True)
+except Exception as e:
+    st.error(f"Error loading dataset: {e}")

pages/Model_Evaluation.py

@@ -129,6 +129,37 @@ with col2:
 if st.session_state.evaluation_done:
     reevaluate_col, download_col = st.columns([1, 1])
 
+    # ---- Description for Model Evaluation ----
+with st.expander("ℹ️ **What is Model Evaluation?**", expanded=True):
+    st.markdown("""
+    <div style='font-size:16px;'>
+    The **Model Evaluation** section tests how well the trained AI model performs on the unseen <strong>test set</strong> of retinal images. This provides insights into the reliability and performance of the model when deployed in real scenarios.
+
+    #### 🔍 What It Does:
+    - Loads the test dataset of labeled retinal images
+    - Runs the model to predict labels
+    - Compares predictions vs. true labels
+    - Computes:
+        - 📋 **Classification Report** (Precision, Recall, F1-Score)
+        - 🧊 **Confusion Matrix**
+        - 📈 **Multi-class ROC Curve**
+        - ❌ **Misclassified Image Samples**
+    - Saves the full report as a downloadable PDF
+
+    #### 🧭 How to Use:
+    1. Click **🚀 Start Evaluation** to begin analyzing the model’s performance.
+    2. Wait for the evaluation to finish (shows progress bar and batch updates).
+    3. Once done:
+        - Check performance scores for each DR class
+        - View visual summaries like confusion matrix and ROC curve
+        - See the top 5 misclassified examples
+    4. Optionally, download the full evaluation report via **📄 Download PDF**
+
+    ⚠️ <i>Note: This evaluation runs on the full test set and might take several seconds depending on hardware.</i>
+    </div>
+    """, unsafe_allow_html=True)
+
+
 # ---- Evaluation Logic ----
 if st.session_state.trigger_eval:
     st.markdown("### ⏱️ Evaluation Results")

pages/Upload_and_Predict.py

@@ -3,11 +3,75 @@ import torch
 from torchvision import transforms, models
 from PIL import Image
 import numpy as np
+import pandas as pd
+from collections import defaultdict
+import os
 
+# Title
 st.markdown("<h2 style='color: #2E86C1;'>📷 Upload & Predict</h2>", unsafe_allow_html=True)
 
+st.markdown("""
+### 📖 About This Feature: Upload & Predict
+
+This section of the **DR Assistive Tool** allows users to upload retinal images and get an AI-based prediction of the **Diabetic Retinopathy stage**. It uses a fine-tuned **DenseNet-121** model trained specifically for detecting DR severity levels.
+
+The model classifies the uploaded image into one of the five classes:
+- **No DR**
+- **Mild**
+- **Moderate**
+- **Severe**
+- **Proliferative DR**
+
+This is especially helpful for:
+- Students learning about AI in healthcare
+- Researchers testing model robustness
+- Clinicians exploring AI-assisted screening tools
+
+The tool also shows **sample images from the test set** for each class. You can use these images to test the model’s performance and understand what different DR stages look like.
+
+---
+### 🧭 How to Use:
+1. 🔍 **View sample images** from the test set grouped by DR stage.
+   - Click the **"🔍 Predict"** button under a sample image to test how the model classifies it.
+2. 📁 **Upload your own retinal image** (in JPG or PNG format) using the file uploader.
+3. 🧠 Click the **"Predict"** button after uploading.
+   - The model will analyze the image and display:
+     - 🎯 **Predicted DR Stage**
+     - 📊 **Model confidence score (in %)**
+
+⚠️ *Make sure your image is a clear, centered fundus photograph for best results.*
+
+---
+### 🛠 Behind the Scenes:
+- ✅ Model: Pretrained **DenseNet-121**
+- 🖼 Input size: Images are resized to 224×224 pixels
+- 🔄 Normalization: Matches ImageNet pretraining stats
+- 📦 Output: Highest probability class from 5 DR categories using **softmax**
+
+*This tool is for educational and research purposes only — not for clinical use.*
+""", unsafe_allow_html=True)
+
+
+# DR class names
 class_names = ['No DR', 'Mild', 'Moderate', 'Severe', 'Proliferative DR']
 
+# Load sample images from CSV with proper label mapping
+@st.cache_data
+def load_sample_images_from_csv(csv_path=r'D:\\DR_Classification\\splits\\test_labels.csv'):
+    df = pd.read_csv(csv_path)
+    samples = defaultdict(list)
+
+    for i in range(5):
+        class_name = class_names[i]
+        class_samples = df[df['label'] == i].head(5)
+        for _, row in class_samples.iterrows():
+            img_path = row['new_path']
+            if os.path.exists(img_path):
+                samples[class_name].append(img_path)
+    
+    return samples
+
+# Load pretrained model
 @st.cache_resource
 def load_model():
     model = models.densenet121(pretrained=False)
@@ -16,6 +80,7 @@ def load_model():
     model.eval()
     return model
 
+# Image transform function
 transform = transforms.Compose([
     transforms.Resize(256),
     transforms.CenterCrop(224),
@@ -23,6 +88,7 @@ transform = transforms.Compose([
     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
 ])
 
+# Prediction function
 def predict_image(model, image):
     img_tensor = transform(image).unsqueeze(0)
     with torch.no_grad():
@@ -31,14 +97,77 @@ def predict_image(model, image):
         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"])
+# Create two tabs for better separation of features
+tab1, tab2 = st.tabs(["🧪 Sample Images", "📤 Upload & Predict"])
+
+with tab1:
+    st.markdown("### 🧪 Sample Images from Test Set")
+
+    st.markdown("""
+    #### 📖 About This Feature: Sample Images
+    In this tab, you can explore sample retinal images from the test set, grouped by their **Diabetic Retinopathy (DR)** stage. This helps you:
+    - Understand the **visual differences** between DR stages
+    - Test the model’s performance on known data
+    - Get familiar with the model’s prediction behavior
+
+    #### 🧭 How to Use:
+    1. Browse the sample images under each DR class.
+    2. Click **🔍 Predict** under an image to let the AI model analyze it.
+    3. The result will show:
+       - 🎯 **Predicted DR stage**
+       - 📊 **Confidence score**
+    
+    > *Ideal for researchers and students testing the model with known data.*
+    """, unsafe_allow_html=True)
+
+    sample_images = load_sample_images_from_csv()
+
+    for class_name in class_names:
+        if class_name in sample_images and sample_images[class_name]:
+            cols = st.columns(5)
+            for i, img_path in enumerate(sample_images[class_name]):
+                with cols[i]:
+                    st.image(img_path, use_container_width=True)
+
+                    if st.button("🔍 Predict", key=f"predict_{img_path}_{i}"):
+                        image = Image.open(img_path).convert('RGB')
+                        model = load_model()
+                        pred_class, prob = predict_image(model, image)
+                        st.success(f"🎯 Prediction: **{pred_class}** ({prob:.2f}% confidence)")
+        else:
+            st.warning(f"⚠️ No images found for **{class_name}**")
+
+with tab2:
+    st.markdown("### 📤 Upload & Predict")
+
+    st.markdown("""
+    #### 📖 About This Feature: Upload & Predict
+    This tool allows you to upload a **retinal image** and get an **AI-based prediction** of the DR stage using a fine-tuned **DenseNet-121** model.
+
+    The model classifies the image into one of:
+    - No DR
+    - Mild
+    - Moderate
+    - Severe
+    - Proliferative DR
+
+    #### 🧭 How to Use:
+    1. 📁 Upload a **clear fundus image** (JPG or PNG).
+    2. 🧠 Click **Predict** to let the model analyze it.
+    3. ✅ You'll see:
+       - 🎯 The predicted DR stage
+       - 📊 Confidence level (in percentage)
+
+    """, unsafe_allow_html=True)
+
+    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 uploaded_file is not None:
+        image = Image.open(uploaded_file).convert('RGB')
+        st.image(image, caption='🖼 Uploaded Image', use_container_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)")
+        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)")