Merge branch 'main' of https://huggingface.co/spaces/Ci-Dave/DR_Classification

pages/Model_Evaluation.py

@@ -105,12 +105,12 @@ def load_test_data(csv_path):
 def load_model():
     model = models.densenet121(pretrained=False)
     model.classifier = nn.Linear(model.classifier.in_features, len(class_names))
-    model.load_state_dict(torch.load(r"training\Pretrained_Densenet-121.pth", map_location=torch.device('cpu')))
+    model.load_state_dict(torch.load(r"D:\DR_Classification\Model\Pretrained_Densenet-121.pth", map_location=torch.device('cpu')))
     model.eval()
     return model
 
 # ---- Main UI Buttons ----
-csv_path = r"splits\test_labels.csv"
+csv_path = r"D:\DR_Classification\dataset\Splitted_data\splits\test_labels.csv"
 model = load_model()
 test_loader = load_test_data(csv_path)
 

pages/Upload_and_Predict.py

@@ -57,7 +57,7 @@ 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'):
+def load_sample_images_from_csv(csv_path=r'D:\DR_Classification\dataset\Splitted_data\splits\test_labels.csv'):
     df = pd.read_csv(csv_path)
     samples = defaultdict(list)
 
@@ -76,7 +76,7 @@ def load_sample_images_from_csv(csv_path=r'D:\DR_Classification\splits\test_labe
 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.load_state_dict(torch.load("Model/Pretrained_Densenet-121.pth", map_location='cpu'))
     model.eval()
     return model
 

training/training.ipynb

@@ -16,7 +16,7 @@
    "source": [
     "### STEPS for model training\n",
     "##### Step 1. Define Preprocessing Function \n",
-    "###### Median Filtering, CLAHE, Gamma Correction, ESRGAN(optional)\n",
+    "###### Median Filtering, CLAHE, Gamma Correction\n",
     "##### Step 2. Create Custom Dataset for preprocessing (Pytorch doesn't supports Custom Preprocessing)\n",
     "##### Step 3. Define Transform (with data augmentation)\n",
     "##### Step 4. Create datasets and Dataloaders\n",
@@ -48,26 +48,57 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "80aeae51",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Importing necessary libraries for various operations\n",
+    "\n",
+    "# OS module helps in interacting with the operating system (file and directory handling)\n",
     "import os\n",
+    "\n",
+    "# OpenCV library for image processing\n",
     "import cv2\n",
+    "\n",
+    "# NumPy for numerical operations and handling arrays\n",
     "import numpy as np\n",
+    "\n",
+    "# Pandas for working with structured data like CSV or Excel (DataFrames)\n",
     "import pandas as pd\n",
+    "\n",
+    "# PIL (Python Imaging Library) for handling images in Python\n",
     "from PIL import Image\n",
+    "\n",
+    "# Matplotlib for data visualization (plotting graphs and images)\n",
     "from matplotlib import pyplot as plt\n",
+    "\n",
+    "# Function to split dataset into training and testing sets\n",
     "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "# Shutil helps with file operations like copying and moving files\n",
     "import shutil \n",
+    "\n",
+    "# PyTorch main library - used for building and training deep learning models\n",
     "import torch\n",
+    "\n",
+    "# PyTorch neural network module - contains layers and loss functions\n",
     "import torch.nn as nn\n",
+    "\n",
+    "# TQDM for showing progress bars during training or data processing loops\n",
     "from tqdm import tqdm\n",
+    "\n",
+    "# PyTorch's optimizer module - includes optimizers like Adam, SGD, etc.\n",
     "import torch.optim as optim\n",
+    "\n",
+    "# Learning rate scheduler - automatically adjusts the learning rate during training\n",
     "from torch.optim.lr_scheduler import StepLR\n",
+    "\n",
+    "# Custom Dataset and DataLoader utilities for batch processing\n",
     "from torch.utils.data import Dataset, DataLoader\n",
-    "from torchvision import models, transforms"
+    "\n",
+    "# Pre-trained models and image transformation tools from torchvision\n",
+    "from torchvision import models, transforms\n"
    ]
   },
   {
@@ -80,7 +111,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "99b3890e",
    "metadata": {},
    "outputs": [
@@ -96,55 +127,71 @@
    ],
    "source": [
     "# Load CSV\n",
-    "df = pd.read_csv(\"D:\\\\DR_Classification\\\\dataset\\\\DR_grading.csv\")\n",
-    "df['image_path'] = df['id_code'].apply(lambda x: os.path.join(\"D:\\\\DR_Classification\\\\dataset\\\\images\", x))\n",
+    "# Load the CSV file that contains image IDs and their corresponding labels (diagnosis)\n",
+    "df = pd.read_csv(\"D:\\\\DR_Classification\\\\dataset\\\\DR_grading.csv\") #change path to your csv file\n",
+    "\n",
+    "# Add a new column 'image_path' which holds the full path to each image file\n",
+    "df['image_path'] = df['id_code'].apply(lambda x: os.path.join(\"D:\\\\DR_Classification\\\\dataset\\\\images\", x)) #change path to your image folder\n",
+    "\n",
+    "# Rename the 'diagnosis' column to 'label' to match deep learning convention (features vs label)\n",
     "df['label'] = df['diagnosis']\n",
     "\n",
-    "# Create output directories\n",
-    "output_root = \"D:\\\\DR_Classification\\\\splits\"\n",
-    "os.makedirs(os.path.join(output_root, \"train\"), exist_ok=True)\n",
-    "os.makedirs(os.path.join(output_root, \"test\"), exist_ok=True)\n",
+    "# Create output directories for storing train and test images\n",
+    "output_root = \"D:\\\\DR_Classification\\\\dataset\\\\Splitted_data\\\\splits\" #change path to your output folder\n",
+    "os.makedirs(os.path.join(output_root, \"train\"), exist_ok=True)  # Creates 'train' folder if not existing\n",
+    "os.makedirs(os.path.join(output_root, \"test\"), exist_ok=True)   # Creates 'test' folder if not existing\n",
     "\n",
-    "# Split: train vs test\n",
+    "# Split the dataset into training and testing sets\n",
+    "# test_size=0.3 means 30% of the data will go to the test set\n",
+    "# stratify ensures each class is proportionally represented in both train and test\n",
+    "# random_state ensures reproducibility of the split\n",
     "train_df, test_df = train_test_split(df, test_size=0.3, stratify=df['label'], random_state=42)\n",
     "\n",
-    "# Function to copy images and save CSV\n",
+    "# Define a function to copy the images to their respective folders and save split CSV files\n",
     "def save_split(df_split, split_name):\n",
+    "    # Define the folder where the images will be saved (either train or test)\n",
     "    split_folder = os.path.join(output_root, split_name)\n",
     "    new_paths = []\n",
     "\n",
-    "    # Check if the CSV for the current split already exists\n",
+    "    # Define the path for the split's CSV file (e.g., train_labels.csv)\n",
     "    csv_path = os.path.join(output_root, f\"{split_name}_labels.csv\")\n",
+    "    \n",
+    "    # If the CSV already exists, skip processing to avoid duplication\n",
     "    if os.path.exists(csv_path):\n",
     "        print(f\"{split_name}_labels.csv already exists. Skipping this split.\")\n",
-    "        return  # Skip processing if the CSV file exists\n",
+    "        return\n",
     "\n",
-    "    # Proceed with copying images and saving the new CSV if the CSV does not exist\n",
+    "    # Loop through each row in the split DataFrame\n",
     "    for _, row in df_split.iterrows():\n",
-    "        src = row['image_path']\n",
-    "        dst = os.path.join(split_folder, os.path.basename(src))\n",
+    "        src = row['image_path']  # original image path\n",
+    "        dst = os.path.join(split_folder, os.path.basename(src))  # destination path in train/test folder\n",
     "\n",
+    "        # Copy the image if it exists\n",
     "        if os.path.exists(src):\n",
     "            shutil.copy(src, dst)\n",
-    "            new_paths.append(dst)\n",
+    "            new_paths.append(dst)  # store the new path for saving in CSV\n",
     "        else:\n",
-    "            print(f\"Warning: Missing image file {src}\")\n",
+    "            print(f\"Warning: Missing image file {src}\")  # error message if file not found\n",
     "\n",
+    "    # Create a copy of the split DataFrame and add the new image paths\n",
     "    df_split = df_split.copy()\n",
     "    df_split['new_path'] = new_paths\n",
+    "\n",
+    "    # Save relevant columns into a new CSV file (id, label, new image path)\n",
     "    df_split[['id_code', 'label', 'new_path']].to_csv(csv_path, index=False)\n",
     "    print(f\"{split_name}_labels.csv saved successfully!\")\n",
     "\n",
-    "# Save each split\n",
+    "# Save the training and testing splits\n",
     "save_split(train_df, \"train\")\n",
     "save_split(test_df, \"test\")\n",
     "\n",
+    "# Final print to confirm everything worked\n",
     "print(\"Splits and CSVs checked and saved successfully!\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "d6bda349",
    "metadata": {},
    "outputs": [
@@ -162,7 +209,7 @@
     }
    ],
    "source": [
-    "print(df['image_path'].head())"
+    "print(df['image_path'].head()) # Display the first few rows of the DataFrame to verify paths"
    ]
   },
   {
@@ -214,21 +261,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "id": "3264f03c",
    "metadata": {},
    "outputs": [],
    "source": [
     "# Load the split CSVs\n",
-    "train_df = pd.read_csv(\"D:/DR_Classification/splits/train_labels.csv\")\n",
-    "test_df = pd.read_csv(\"D:/DR_Classification/splits/test_labels.csv\")\n",
+    "train_df = pd.read_csv(\"D:/DR_Classification/dataset/Splitted_data/splits/train_labels.csv\") #change path to your csv file\n",
+    "test_df = pd.read_csv(\"D:/DR_Classification/dataset/Splitted_data/splits/test_labels.csv\") \n",
     "\n",
     "# Extract paths and labels\n",
     "train_paths = train_df['new_path'].tolist()\n",
     "train_labels = train_df['label'].tolist()\n",
     "\n",
-    "test_paths = test_df['new_path'].tolist()\n",
-    "test_labels = test_df['label'].tolist()"
+    "test_paths = test_df['new_path'].tolist() \n",
+    "test_labels = test_df['label'].tolist() "
    ]
   },
   {
@@ -241,28 +288,56 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "id": "0b0e9212",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# Applies a Median Filter to remove noise (especially salt-and-pepper noise)\n",
     "def apply_median_filter(image):\n",
+    "    # cv2.medianBlur applies a median filter with a 3x3 kernel\n",
     "    return cv2.medianBlur(image, 3)\n",
     "\n",
+    "\n",
+    "# Applies CLAHE (Contrast Limited Adaptive Histogram Equalization) to enhance local contrast\n",
     "def apply_clahe(image):\n",
+    "    # Convert the image from RGB color space to LAB color space\n",
     "    lab = cv2.cvtColor(image, cv2.COLOR_RGB2LAB)\n",
+    "    \n",
+    "    # Split LAB into individual channels: L (lightness), A (green–red), B (blue–yellow)\n",
     "    l, a, b = cv2.split(lab)\n",
+    "    \n",
+    "    # Create a CLAHE object with clipLimit=2.0 (limits contrast amplification)\n",
     "    clahe = cv2.createCLAHE(clipLimit=2.0)\n",
+    "    \n",
+    "    # Apply CLAHE to the L channel (intensity)\n",
     "    cl = clahe.apply(l)\n",
+    "    \n",
+    "    # Merge the enhanced L channel with the original A and B channels\n",
     "    merged = cv2.merge((cl, a, b))\n",
+    "    \n",
+    "    # Convert the image back from LAB to RGB color space\n",
     "    return cv2.cvtColor(merged, cv2.COLOR_LAB2RGB)\n",
     "\n",
+    "\n",
+    "# Applies Gamma Correction to adjust image brightness\n",
     "def apply_gamma_correction(image, gamma=1.2):\n",
+    "    # Calculate the inverse of gamma\n",
     "    invGamma = 1.0 / gamma\n",
+    "\n",
+    "    # Create a lookup table for all pixel values (0–255)\n",
+    "    # Each pixel is transformed based on gamma value\n",
     "    table = np.array([(i / 255.0) ** invGamma * 255 for i in np.arange(0, 256)]).astype(\"uint8\")\n",
+    "    \n",
+    "    # Apply the gamma correction using the lookup table\n",
     "    return cv2.LUT(image, table)\n",
     "\n",
+    "\n",
+    "# Applies a Gaussian Blur to smooth the image and reduce noise/detail\n",
     "def apply_gaussian_filter(image, kernel_size=(5, 5), sigma=1.0):\n",
+    "    # cv2.GaussianBlur uses a Gaussian kernel to blur the image\n",
+    "    # kernel_size defines the width and height of the filter\n",
+    "    # sigma defines how much to blur (higher = more blur)\n",
     "    return cv2.GaussianBlur(image, kernel_size, sigma)\n"
    ]
   },
@@ -753,7 +828,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "id": "2090199a",
    "metadata": {},
    "outputs": [
@@ -809,8 +884,8 @@
     "# 2. Load the model architecture\n",
     "# -------------------------------\n",
     "model = models.densenet121(pretrained=False)  # Use DenseNet-121 architecture\n",
-    "model.classifier = nn.Linear(model.classifier.in_features, 5)  # Adjust for 5 classes in DDR dataset\n",
-    "model.load_state_dict(torch.load(r\"D:\\DR_Classification\\training\\Pretrained_Densenet-121.pth\", map_location=torch.device('cpu')))\n",
+    "model.classifier = nn.Linear(model.classifier.in_features, 5)  # Adjust for 5 classes in DDR dataset \n",
+    "model.load_state_dict(torch.load(r\"D:\\DR_Classification\\Model\\Pretrained_Densenet-121.pth\", map_location=torch.device('cpu'))) # Load the trained model weights\n",
     "\n",
     "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
     "model.to(device)\n",
@@ -997,7 +1072,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "id": "30d1e549",
    "metadata": {},
    "outputs": [
@@ -1013,39 +1088,57 @@
     }
    ],
    "source": [
+    "# Import Counter from collections to count occurrences per class\n",
     "from collections import Counter\n",
     "\n",
+    "# Dictionary to track how many predictions were correct per class\n",
     "correct_per_class = Counter()\n",
+    "\n",
+    "# Dictionary to track total number of samples per class\n",
     "total_per_class = Counter()\n",
     "\n",
+    "# Disable gradient calculation for inference (saves memory and computation)\n",
     "with torch.no_grad():\n",
+    "    # Loop over the test dataset\n",
     "    for inputs, labels in test_loader:\n",
+    "        # Move input tensors to the same device as the model (CPU or GPU)\n",
     "        inputs = inputs.to(device)\n",
     "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass: get model predictions\n",
     "        outputs = model(inputs)\n",
+    "\n",
+    "        # Get the index of the class with the highest score for each sample\n",
     "        _, predicted = torch.max(outputs, 1)\n",
     "\n",
+    "        # Compare predictions with true labels, update counters\n",
     "        for label, prediction in zip(labels, predicted):\n",
-    "            total_per_class[label.item()] += 1\n",
+    "            total_per_class[label.item()] += 1  # increment total count for true class\n",
     "            if label == prediction:\n",
-    "                correct_per_class[label.item()] += 1\n",
+    "                correct_per_class[label.item()] += 1  # increment correct count if prediction is correct\n",
     "\n",
-    "class_acc = {class_names[i]: (correct_per_class[i] / total_per_class[i]) * 100 for i in range(n_classes)}\n",
+    "# Compute per-class accuracy: (correct / total) * 100 for each class\n",
+    "# class_names[i] is used to label each class properly\n",
+    "class_acc = {\n",
+    "    class_names[i]: (correct_per_class[i] / total_per_class[i]) * 100\n",
+    "    for i in range(n_classes)\n",
+    "}\n",
     "\n",
-    "# Plot\n",
+    "# Visualization: Bar plot of per-class accuracy\n",
     "plt.figure(figsize=(8, 5))\n",
-    "plt.bar(class_acc.keys(), class_acc.values(), color='skyblue')\n",
+    "plt.bar(class_acc.keys(), class_acc.values(), color='skyblue')  # bar plot with class labels and their accuracy\n",
     "plt.ylabel(\"Accuracy (%)\")\n",
     "plt.title(\"Per-Class Accuracy\")\n",
-    "plt.xticks(rotation=45)\n",
-    "plt.ylim(0, 100)\n",
+    "plt.xticks(rotation=45)  # Rotate class names on x-axis for better readability\n",
+    "plt.ylim(0, 100)  # Set y-axis range from 0 to 100 percent\n",
     "plt.grid(True)\n",
-    "plt.show()\n"
+    "plt.show()\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "id": "653632e3",
    "metadata": {},
    "outputs": [
@@ -1061,37 +1154,56 @@
     }
    ],
    "source": [
+    "# Function to visualize misclassified images from the test set\n",
     "def show_misclassified(model, test_loader, class_names, device='cpu', max_images=6):\n",
+    "    # Set model to evaluation mode (turns off dropout, batchnorm updates)\n",
     "    model.eval()\n",
+    "    \n",
+    "    # List to store misclassified images and their labels\n",
     "    misclassified = []\n",
     "\n",
+    "    # Disable gradient computation for faster inference\n",
     "    with torch.no_grad():\n",
+    "        # Iterate through the test set\n",
     "        for inputs, labels in test_loader:\n",
+    "            # Move data to device (GPU or CPU)\n",
     "            inputs, labels = inputs.to(device), labels.to(device)\n",
+    "            \n",
+    "            # Get predictions from the model\n",
     "            outputs = model(inputs)\n",
     "            _, preds = torch.max(outputs, 1)\n",
     "\n",
+    "            # Check for misclassified samples\n",
     "            for img, true_label, pred_label in zip(inputs, labels, preds):\n",
     "                if true_label != pred_label:\n",
+    "                    # Save the misclassified image and its true/predicted labels\n",
     "                    misclassified.append((img.cpu(), true_label.item(), pred_label.item()))\n",
+    "                \n",
+    "                # Stop once we’ve collected enough misclassified samples\n",
     "                if len(misclassified) >= max_images:\n",
     "                    break\n",
     "            if len(misclassified) >= max_images:\n",
     "                break\n",
     "\n",
+    "    # Plot the misclassified images\n",
     "    plt.figure(figsize=(12, 8))\n",
     "    for i, (img, true_label, pred_label) in enumerate(misclassified):\n",
-    "        plt.subplot(2, 3, i+1)\n",
-    "        img = img.permute(1, 2, 0).numpy()\n",
-    "        img = (img * [0.229, 0.224, 0.225]) + [0.485, 0.456, 0.406]  # Unnormalize\n",
-    "        img = np.clip(img, 0, 1)\n",
+    "        plt.subplot(2, 3, i+1)  # Plot up to 6 images in a 2x3 grid\n",
+    "        \n",
+    "        # Convert tensor image to NumPy format and undo normalization\n",
+    "        img = img.permute(1, 2, 0).numpy()  # Change shape from [C, H, W] to [H, W, C]\n",
+    "        img = (img * [0.229, 0.224, 0.225]) + [0.485, 0.456, 0.406]  # Undo normalization (ImageNet stats)\n",
+    "        img = np.clip(img, 0, 1)  # Make sure pixel values are within [0, 1]\n",
+    "\n",
+    "        # Display the image\n",
     "        plt.imshow(img)\n",
     "        plt.title(f'True: {class_names[true_label]}\\nPred: {class_names[pred_label]}')\n",
-    "        plt.axis('off')\n",
+    "        plt.axis('off')  # Hide axis ticks\n",
+    "    \n",
     "    plt.tight_layout()\n",
     "    plt.show()\n",
     "\n",
-    "# Call it:\n",
+    "# Call the function to show misclassified samples\n",
     "show_misclassified(model, test_loader, class_names, device=device)\n"
    ]
   },
@@ -1105,7 +1217,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "id": "45a03f67",
    "metadata": {},
    "outputs": [
@@ -1207,47 +1319,56 @@
     }
    ],
    "source": [
+    "# Function to visualize a few predictions from the model\n",
     "def visualize_predictions(model, dataloader, class_names, device='cuda', num_images=6):\n",
-    "    model.eval()\n",
-    "    images_shown = 0\n",
-    "    correct_preds = 0\n",
+    "    model.eval()  # Set the model to evaluation mode (no dropout, no gradients)\n",
+    "    images_shown = 0  # Counter for how many images we've displayed\n",
+    "    correct_preds = 0  # Counter for how many predictions were correct\n",
     "\n",
-    "    with torch.no_grad():\n",
+    "    with torch.no_grad():  # No need to calculate gradients during inference\n",
     "        for inputs, labels in dataloader:\n",
-    "            inputs = inputs.to(device)\n",
+    "            inputs = inputs.to(device)  # Move input batch to GPU/CPU\n",
     "            labels = labels.to(device)\n",
-    "            outputs = model(inputs)\n",
-    "            _, preds = torch.max(outputs, 1)\n",
     "\n",
+    "            outputs = model(inputs)  # Get model predictions\n",
+    "            _, preds = torch.max(outputs, 1)  # Get predicted class indices\n",
+    "\n",
+    "            # Move back to CPU for visualization\n",
     "            inputs = inputs.cpu()\n",
     "            labels = labels.cpu()\n",
     "            preds = preds.cpu()\n",
     "\n",
+    "            # Loop through the batch and visualize one image at a time\n",
     "            for i in range(inputs.size(0)):\n",
     "                if images_shown >= num_images:\n",
+    "                    # Print final summary and return\n",
     "                    print(f\"\\n�� Total Correct: {correct_preds}/{num_images} — Accuracy: {(correct_preds / num_images) * 100:.2f}%\")\n",
     "                    return\n",
     "\n",
-    "                img = inputs[i].permute(1, 2, 0).numpy()\n",
-    "                img = (img - img.min()) / (img.max() - img.min())  # normalize for display\n",
+    "                # Convert tensor image to NumPy array and normalize values for visualization\n",
+    "                img = inputs[i].permute(1, 2, 0).numpy()  # [C, H, W] -> [H, W, C]\n",
+    "                img = (img - img.min()) / (img.max() - img.min())  # Scale pixel values to [0, 1]\n",
     "\n",
+    "                # Determine if the prediction is correct\n",
     "                is_correct = preds[i] == labels[i]\n",
     "                correctness = \"✔️ Correct\" if is_correct else \"❌ Wrong\"\n",
     "                if is_correct:\n",
     "                    correct_preds += 1\n",
     "\n",
+    "                # Display the image with its true and predicted labels\n",
     "                plt.imshow(img)\n",
     "                plt.title(f\"True: {class_names[labels[i]]}\\nPred: {class_names[preds[i]]} | {correctness}\")\n",
     "                plt.axis(\"off\")\n",
     "                plt.show()\n",
     "\n",
-    "                images_shown += 1\n",
+    "                images_shown += 1  # Increment the counter\n",
     "\n",
+    "    # Final accuracy summary if loop finishes naturally\n",
     "    print(f\"\\n✅ Total Correct: {correct_preds}/{num_images} — Accuracy: {(correct_preds / num_images) * 100:.2f}%\")\n",
     "\n",
     "# Example usage\n",
     "class_names = ['No DR', 'Mild', 'Moderate', 'Severe', 'Proliferative DR']\n",
-    "visualize_predictions(model, test_loader, class_names, device=device, num_images=8)"
+    "visualize_predictions(model, test_loader, class_names, device=device, num_images=8)\n"
    ]
   },
   {
@@ -1279,7 +1400,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": null,
    "id": "e1133810",
    "metadata": {},
    "outputs": [
@@ -1347,7 +1468,7 @@
     "\n",
     "# Example usage:\n",
     "class_names = ['No DR', 'Mild', 'Moderate', 'Severe', 'Proliferative DR']  # Modify as per your dataset\n",
-    "image_path = r'D:\\DR_Classification\\splits\\train\\007-0025-000.jpg'  # Replace with your image path\n",
+    "image_path = r'D:\\DR_Classification\\dataset\\Splitted_data\\splits\\train\\007-0025-000.jpg'  # Replace with your image path\n",
     "predicted_class, confidence_percentage = predict_image(model, image_path, class_names, device='cpu')\n",
     "\n",
     "print(f\"Predicted Class: {predicted_class}\")\n",