VISVESVARAYA TECHNOLOGICAL UNIVERSITY

JNANA SANGAMA, BELAGAVI – 590 018

Mini Project Report

on

Neuro Minds [Alzheimer's disease Prediction]

Using Machine Learning
Submitted in partial fulfillment of the requirements for the VI Semester of degree
of Bachelor of Engineering in Information Science and Engineering of
Visvesvaraya Technological University, Belagavi

Submitted By

Navneeth V 1RN22IS095
Priyanshu Singh 1RN22IS116

Under the Guidance of

Ms. Aishwarya G
Assistant Professor
Department of ISE

Department of Information Science and Engineering

RNS Institute of Technology
Dr. Vishnuvardhan Road, Rajarajeshwari Nagar post,
Channasandra, Bengaluru-560098
2024-2025
 RNS INSTITUTE OF TECHNOLOGY
Dr. Vishnuvardhan Road, Rajarajeshwari Nagar post,

Channasandra, Bengaluru - 560098

DEPARTMENT OF INFORMATION SCIENCE AND ENGINEERING

CERTIFICATE
Certified that the Mini Project Report work entitled Neuro Minds[Alzheimer’s Disease
Prediction] Using Machine Learning has been successfully completed by Navneeth V
(1RN22IS095) and Priyanshu Singh (1RN22IS116) bona fide students of RNS Institute of
Technology, Bengaluru in partial fulfillment of the requirements for the award of degree in
Bachelor of Engineering in Information Science and Engineering of Visvesvaraya
Technological University, Belagavi during academic year 2024-2025. The Mini project report
has been approved as it satisfies the academic requirements in respect of work for the said
degree.

Ms. Aishwarya G Dr. Suresh L Dr. Ramesh Babu

Project Guide Professor and HoD Principal
Assistant Professor Department of ISE RNSIT
Department of ISE RNSIT
 I

DECLARATION

We, Navneeth V [1RN22IS095] and Priyanshu Singh [1RN22IS116] students of VI

Semester BE, in Information Science and Engineering, RNS Institute of Technology
hereby declare that the Mini Project entitled Neuro Minds[Alzheimer’s Disease
Prediction]Using Machine Learning has been carried out by us and submitted in partial
fulfillment of the requirements for the VI Semester degree of Bachelor of Engineering in
Information Science and Engineering of Visvesvaraya Technological University,
Belgaum during academic year 2024-2025.

Place: Bengaluru

Date: 02/06/2025

NAVNEETH V [1RN22IS095]
PRIYANSHU SINGH [1RN22IS116]
ACKNOWLEDGMENT

We express our profound thanks to the Management of the RNS Institute of Technology for fostering an
environment that promotes innovation and academic excellence.

We would like place sincere gratitude to our beloved Director, Dr. M K Venkatesha, and our respected
Principal, Dr. Ramesh Babu H S , for their constant encouragement and insightful support. Their
guidance has been pivotal in keeping us motivated throughout this project work.

Our heartfelt appreciation goes to Dr. Suresh L, Professor and HoD of Information Science and
Engineering , for being the driving force and mastermind behind our SCR activities. We thank our
Project Coordinator and Guide, Ms. Aishwarya, Assistant Professor in the Department of Information
Science and Engineering, for guiding and evaluating the project.

We would like to thank all teaching and non-teaching staff of Information Science and Engineering
department, who have directly or indirectly helped us to carry out the project.
Warm Regards,

NAVNEETH V [1RN22IS095]
PRIYANSHU SINGH[1RN22IS116]

I
ABSTRACT

Neuro Minds is a lightweight deep learning-based image classification system designed to assist in the early
detection and categorization of neurological conditions such as Alzheimer’s and Parkinson’s disease.
Utilizing a custom Convolutional Neural Network (CNN) architecture, the model processes MRI or brain
scan images to classify them into six risk categories—Alzheimer, Mild Risk, Moderate Risk, Very Mild
Risk, No Risk, and Parkinson. Implemented in PyTorch and optimized for real-time inference, the system
leverages image preprocessing and softmax-based confidence scoring to deliver accurate, interpretable
predictions. Designed for usability in platforms like Google Colab, Neuro Minds facilitates intuitive
interaction through simple model and image uploads, making it a practical tool for clinical support and
medical research.

Neuro Minds (Neurodegenerative Medical Imaging-based Neurological Diagnostic System) is an AI-

powered classification framework developed to assist in the non-invasive diagnosis and risk assessment of
neurodegenerative disorders. Built upon a custom-designed Convolutional Neural Network (CNN)
architecture, the system classifies brain scan images into six distinct categories: Alzheimer’s, Parkinson’s,
Mild Risk, Moderate Risk, Very Mild Risk, and No Risk. Developed using PyTorch and optimized for GPU
acceleration, Neuro Minds ensures efficient processing and accurate predictions even on consumer-grade
hardware. The model incorporates robust preprocessing techniques such as normalization and resizing to
224×224 resolution, followed by forward propagation through deep convolutional layers. It utilizes softmax
probability scoring to provide clear, confidence-based outputs for each class. Designed for user-friendly
deployment on platforms like Google Colab, the tool allows users to upload trained model weights and test
images interactively. Neuro Minds aims to bridge the gap between deep learning research and clinical
practice by offering a scalable, interpretable, and accessible solution for early detection and monitoring of
neurodegenerative diseases.

II
 TABLE OF CONTENTS

Acknowledgment I
Abstract II
1 Introduction
1.1 Background . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ….1
1.2 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . .......................................... 1
1.3 Objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .......................................... 2
1.4 Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ..........................................2
2 Methodology
2.1 Software Requirement ................................................................................. 3-5
2.2 Algorithm
2.2.1 Data Retrieval Algorithm .................................................................. 5
2.2.2 Prediction Algorithm ........................................................................... 6
2.3 Data Collection and Analysis procedure
2.3.1 Data Collection Procedure....................................................................... 7
2.3.2 Data Analysis Procedure ..................................................................... 8

3 Requirements
2.4 Functional Requirements ............................................................................ 9-10
2.5 Non-Functional Requirements .................................................................. 10-11
4 Implementation
3.1 Code ........................................................................................................ 12-14
5 Results
4.1 Project Result . . . . . . . . . . . . . . . . . . . . . . …. .... … .. … …..………… 15-17
Conclusion 18

Future Enhancements 19
References 20
Chapter 1
Introduction

1.1 Background

Predicting Alzheimer’s disease from medical images is a complex challenge due to the subtle structural
changes in the brain and variability across patients. Traditional diagnostic methods often depend on expert
analysis of MRI scans, which can be time-intensive and subjective. Deep learning, particularly
convolutional neural networks (CNNs), offers a powerful alternative by automatically learning
discriminative features from raw image data.

By training on labeled brain scans, CNNs can map visual patterns—such as cortical thinning or ventricular
enlargement—to specific disease stages or conditions. This enables automated, scalable, and consistent
prediction of Alzheimer’s and related neurological risks. In this project, we use a CNN-based model to
classify input images into categories like Alzheimer, Parkinson, and varying risk levels, providing a data-
driven solution that generalizes better than traditional rule-based or manual diagnostic approaches.

1.2 Problem Statement

The core objective of this project is to develop a deep learning-based model that can accurately classify
brain scan images to predict Alzheimer’s disease and related neurological conditions. The model analyzes
input medical images to identify early signs of cognitive decline, enabling timely diagnosis and intervention.

1. Disease Classification: Predict the condition category (e.g., Alzheimer, Parkinson, No Risk,
Mild/Moderate Risk) from brain scan images.
2. Clinical Support: Assist healthcare professionals with automated, consistent diagnostic suggestions based
on visual data.

1
 BIS602
3. Image-Based Prediction: Uses CNN to process MRI images and output real-time classification with
confidence levels.

4 Model Evaluation: Different CNN architectures can be tested to compare accuracy and robustness on
medical image datasets.
5 Data Preprocessing: Includes image resizing, normalization, and augmentation to improve generalization
and performance.

a. Objective
The objective of the NeuroMinds project is to develop a deep learning-based solution that can accurately
classify brain MRI images to predict Alzheimer’s disease and related neurological conditions. Leveraging
labeled medical imaging datasets, the project aims to train and evaluate a convolutional neural network
(CNN) model capable of distinguishing between various cognitive states such as Alzheimer, Parkinson, No
Risk, and different levels of dementia risk. The model processes input images through a sequence of
convolutional layers to automatically extract and learn critical visual patterns associated with brain
degeneration. To make this system accessible and practical, the project includes a user-friendly interface in
Google Colab that allows users to upload medical images and instantly receive classification results with
confidence scores. This tool is designed to support healthcare professionals, researchers, and caregivers by
providing consistent, data-driven insights to aid early diagnosis and intervention.

b Scope

The scope of the NeuroMinds project spans multiple domains, including medical imaging, deep learning,
healthcare technology, and artificial intelligence. It covers the full development pipeline—from data
acquisition and preprocessing to CNN model design, training, evaluation, and deployment. The project
focuses on using labeled brain MRI scans to train a convolutional neural network capable of classifying
various stages of neurodegenerative diseases such as Alzheimer’s and Parkinson’s, along with assessing
cognitive risk levels. The solution is deployed through an interactive Google Colab interface, allowing users
to upload brain scan images and receive immediate diagnostic predictions with confidence scores. Beyond
aiding clinical diagnosis, the project lays the groundwork for integrating more advanced capabilities such as

Dept of ISE, RNSIT 2024-25 2

 BCS602

Chapter 2
2.1 Hardware Requirements
 Processor:

 Minimum: Intel Core i5 or AMD Ryzen 5

 Reason: Sufficient for running image preprocessing, CNN inference, and basic training tasks without
significant lag.

• RAM (Memory):

 Minimum: 8 GB
 Recommended: 16 GB or higher
 Reason: Adequate memory ensures smooth handling of image data, especially during model evaluation and
batch processing.

• Storage Space:

 Minimum: 2 GB of free disk space

 Reason: Required for storing model files, sample brain MRI datasets, and necessary Python dependencies.

• Graphics Card (GPU):

 Optional: NVIDIA GPU (e.g., GTX 1050 Ti or higher)

 Reason: While not mandatory, a GPU significantly accelerates CNN training and inference for larger
datasets.

• Operating System:

 Compatible with: Windows 10/11, Linux (Ubuntu recommended), or macOS

 Reason: The project is built with PyTorch and runs on Jupyter/Colab, all of which are cross-platform and
OS-independent.

Dept of ISE, RNSIT 2024-25 3

 BCS602
 Internet Connection:

 Required for: Installing libraries and deploying the Streamlit app (if hosted online)
 Reason: Ensures smooth setup and access to online resources and updates.

 Web Browser:

 Recommended: Chrome, Firefox, or Edge

 Reason: To access and interact with the web-based Streamlit user interface.

2.2 Software Requirements

• Operating System:

 Windows 10/11, Linux (Ubuntu), or macOS

 Reason: The project is built using Python and runs on Jupyter or Google Colab, both of which are cross-
platform compatible.

• Python (Version 3.7 or higher):

 Reason: Primary programming language used for deep learning model development, data
preprocessing, and inference.

• Python Libraries/Packages:

 Must-have:
o torch – for building and loading the CNN model
o torchvision – for image transformations
o Pillow (PIL) – for image handling and loading
o matplotlib – for visualizing predictions
o [Link] – for file upload and interaction in Colab.
 Reason: These libraries cover the full pipeline from image processing and model inference to
visualization and evaluation.

Dept of ISE, RNSIT 2024-25 4

 BCS602
• Jupyter Notebook / Google Colab / VS Code / PyCharm (Any Python IDE):

o Reason: For developing, testing, and running the code. Google Colab is preferred for ease of use.

• Web Browser (Chrome, Firefox, Edge):

 Reason: Required if running the model via Colab or accessing any cloud-based resources.

2.3 Algorithms

1. Convolutional Neural Network (CNN)

 Type: Deep Learning Algorithm (Supervised Classification)

 Purpose: Automatically extracts spatial features from brain scan images to classify neurological conditions
(e.g., Alzheimer, Parkinson, risk levels).
 Library: [Link], torchvision
 Details:
o Uses stacked convolutional layers (nn.Conv2d) to learn hierarchical visual patterns from medical
images.
o Includes activation functions (ReLU), pooling layers (nn.MaxPool2d), and fully connected layers for
classification.
o Final layer outputs predictions for six classes using a softmax-like behavior.
o Effective at capturing complex, non-linear relationships in high-dimensional image data.

2. Dropout Regularization

 Type: Deep Learning Regularization Technique

 Purpose: Reduces overfitting by randomly deactivating neurons during training.
 Library: [Link]
 Details:
o Applied after fully connected layer (fc1) with a dropout rate (e.g., 0.5).
o Prevents the model from becoming too reliant on specific neurons.
o Improves generalization to unseen test images.

Dept of ISE, RNSIT 2024-25 5

 BCS602
3. ReLU Activation Function

 Type: Activation Function

 Purpose: Introduces non-linearity into the CNN, enabling it to learn complex patterns.
 Library: [Link]
 Details:
o Replaces negative values with zero, keeping positive values unchanged.
o Applied after each convolutional and fully connected layer.
o Fast, simple, and prevents vanishing gradient problems.

4. Softmax (via [Link])

 Type: Probability Distribution Function

 Purpose: Converts raw model outputs (logits) into class probabilities.
 Library: [Link]
 Details:
o Applied to model outputs during prediction (in evaluation mode).
o Ensures output values sum to 1, making them interpretable as class probabilities.
o Enables selection of the most probable class with [Link].

5. Model Evaluation (Inference Mode)

 Type: Model Execution Phase

 Purpose: Disables training-specific behavior such as dropout during prediction.
 Library: [Link]()
 Details:
o Ensures consistency and stability in prediction results.
o Prevents weights from updating and avoids randomness introduced by dropout.

Dept of ISE, RNSIT 2024-25 6

 BCS602

2.4 Data Collection and Analysis procedure

1. Identify Data Source

o The primary dataset consists of brain MRI images sourced from publicly available medical imaging
repositories such as Kaggle, ADNI (Alzheimer’s Disease Neuroimaging Initiative), and OASIS
(Open Access Series of Imaging Studies).
2. Download Dataset
o Download image datasets in standard formats (e.g., JPEG, PNG, or NIfTI) along with labels
indicating disease category (e.g., Alzheimer’s, Mild Cognitive Impairment, No Risk, Parkinson’s).
3. Verify Data Authenticity
o Validate dataset credibility by cross-referencing with official medical research studies or
publications and ensuring ethical sourcing and appropriate licensing for academic use.
4. Dataset Preprocessing
o Resize all images to a fixed dimension (e.g., 224x224) for consistency in model input.
o Convert image formats to RGB if required.
o Normalize pixel values using standard mean and standard deviation (e.g., ImageNet values for
transfer learning compatibility).
5. Label Inspection
o Ensure proper labeling of images across all classes (e.g., 'Alzheimer', 'No Risk', 'Very Mild Risk',
etc.).
o Balance dataset classes to avoid bias during training, possibly using data augmentation techniques.
6. Data Augmentation (Optional)
o Apply transformations such as rotation, flipping, or contrast adjustments to increase the diversity of
training samples and improve generalization.
7. Data Organization
o Structure the dataset into directories or CSV-based formats where each image is associated with a
label for supervised learning.
8. Data Splitting
o Divide data into training, validation, and testing sets (e.g., 70/15/15) to ensure unbiased model
evaluation and tuning.

Dept of ISE, RNSIT 2024-25 7

 BCS602

Data Analysis Procedure

1. Understanding the Dataset

o Analyze image counts per class and review image quality and distribution.
o Check for class imbalance and resolution inconsistencies.
2. Exploratory Data Analysis (EDA)
o Plot the number of samples per class to visualize class distribution.
o Display sample images from each category to validate quality and label correctness.
o Visualize pixel intensity histograms to understand image contrast and brightness variations.
3. Categorical Variable Analysis (if metadata is included)
o Analyze patient-related attributes such as age group, gender, or clinical history if available alongside
images.
o Encode categorical metadata using label encoding or one-hot encoding for integration into hybrid
models.
4. Feature Engineering (if using metadata + images)
o Combine imaging data with auxiliary features like age or cognitive scores to improve model
accuracy.
o Normalize numerical metadata and align with image input for multi-input modeling.
5. Handling Missing or Corrupted Data
o Identify missing labels or corrupted image files and either repair or exclude them from the dataset.
o Log and track removed samples for reproducibility.
6. Data Visualization
o Use confusion matrices after initial model runs to visualize classification performance.
o Generate accuracy/loss curves during training to monitor convergence.
o Use Grad-CAM or saliency maps (optional) to interpret model focus areas on MRI images.

Dept of ISE, RNSIT 2024-25 8

 BCS602

Chapter 3

Functional Requirements

User Input Interface

 Allow users to upload brain MRI images through a simple interface (e.g., Colab or web app).
 Optionally enable selection of the disease category for test cases or benchmark evaluation.

• Image Preprocessing Module

 Automatically resize, normalize, and convert images to the appropriate format for model input.
 Ensure consistency in image dimensions and color channels (e.g., 224x224 RGB).

• Disease Prediction Engine

 Use a pre-trained CNN model to classify the uploaded MRI image into one of the diagnostic categories
(e.g., Alzheimer, Parkinson, No Risk, Mild/Moderate Risk).

• Model Loading and Management

 Load trained model weights dynamically and support replacing or updating the model with new versions
without changing the interface.
 Ensure compatibility across different training runs (e.g., support for .pt model files).

• Prediction Output

 Display the predicted class along with the confidence percentage.

 Optionally return the probability distribution across all possible classes.

• Result Visualization

Dept of ISE, RNSIT 2024-25 9

 BCS602
 Show the uploaded image with the predicted class and confidence using matplotlib or a web visualization
tool.

• Dataset Handling (Training/Testing)

 Support uploading custom datasets for evaluation or retraining.

 Provide structure for organizing and managing datasets within the system.

• User-Friendly Interface

 Provide an intuitive front-end using Google Colab or Streamlit for seamless interaction.
 Support drag-and-drop or file browser-based image uploads.

• Input Validation and Error Handling

 Check if uploaded files are valid image formats and show clear error messages for unsupported or corrupted
files.
 Handle missing or empty inputs gracefully.

Non-Functional Requirements
1 Performance

 The system should predict the class within 2–3 seconds after image upload for real-time usability in clinical
or educational environments.

2. Scalability

 Should support processing larger datasets and integration of more disease categories without performance
bottlenecks.

3. Reliability

 Model predictions must be consistent and accurate across repeated evaluations, assuming unchanged inputs
and model weights.
Dept of ISE, RNSIT 2024-25 10
 BCS602

4. Usability

 The UI must be simple and intuitive, requiring minimal user interaction for diagnosis.

5. Maintainability

 The codebase should follow modular design principles with documentation for each function and class to
support future enhancements.

6. Portability

 The system should run across all major platforms (Windows, macOS, Linux) and be compatible with
Jupyter/Colab and major browsers.

Dept of ISE, RNSIT 2024-25 11

 BCS602

Chapter 4

Implementation
# 1. Install Required Packages (Colab only)
!pip install torch torchvision pillow matplotlib thop # Install required libraries

# 2. Import Libraries
import torch
import [Link] as nn
from torchvision import transforms
from PIL import Image
import [Link] as plt
from [Link] import files
import io # Import necessary modules for model, image processing, and file uploads

# 3. Define CNN Model Architecture

class SimpleCNN([Link]):
def __init__(self, model_type='f', num_classes=6):
super(SimpleCNN, self).__init__()
if model_type == 'f':
self.conv1 = nn.Conv2d(3, 16, 3, 1, 1)
self.conv2 = nn.Conv2d(16, 32, 3, 1, 1)
self.conv3 = nn.Conv2d(32, 64, 3, 1, 1)
self.fc1 = [Link](64 * 28 * 28, 256)
[Link] = [Link](0.5)
self.fc2 = [Link](256, num_classes)
[Link] = [Link]()
[Link] = nn.MaxPool2d(2, 2) # Define CNN layers: conv, relu, pool, dropout, and FC layers

Dept of ISE, RNSIT 2024-25 12

 BCS602
def forward(self, x):
x = [Link]([Link](self.conv1(x)))

x = [Link]([Link](self.conv2(x)))
x = [Link]([Link](self.conv3(x)))
x = [Link]([Link](0), -1)
x = [Link](self.fc1(x))
x = [Link](x)
x = self.fc2(x)
return x # Forward pass through the CNN

# 4. Set Device and Load Model

device = [Link]("cuda" if [Link].is_available() else "cpu") # Use GPU if available
model = SimpleCNN(model_type='f', num_classes=6).to(device) # Initialize and move model to device

# 5. Upload the model weights file

print("Upload the model file (e.g., [Link])")
uploaded_model = [Link]() # Upload trained model file
model_path = list(uploaded_model.keys())[0]

# Load model weights

model.load_state_dict([Link](model_path, map_location=device)) # Load weights into model
[Link]() # Set model to evaluation mode

# 6. Define Image Transform

transform = [Link]([
[Link]((224, 224)),
[Link](),
[Link](mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]) # Define preprocessing steps for input image

# 7. Class Names

Dept of ISE, RNSIT 2024-25 13

 BCS602
class_names = ['Alzheimer', 'Mild Risk', 'Moderate Risk', 'Very Mild Risk', 'No Risk', 'Parkinson'] # Class labels

# 8. Prediction Function
def predict_image(model, image, transform):
image = [Link]([Link](image)).convert('RGB')
input_tensor = transform(image).unsqueeze(0).to(device)
with torch.no_grad():
outputs = model(input_tensor)
probs = [Link](outputs, dim=1)
_, pred = [Link](probs, 1)
confidence = probs[0, pred].item() * 100
return [Link](), confidence, image # Predict class, return label, confidence, and image

# 9. Upload and Predict Image

print("Upload an image to classify")
uploaded = [Link]() # Upload an image for prediction

# 10. Process Each Image

for image_name in [Link]():
image_data = uploaded[image_name]
pred_class, confidence, img = predict_image(model, image_data, transform)

[Link](img)
[Link]("off")
[Link](f"{class_names[pred_class]} ({confidence:.2f}%)")
[Link]() # Display image with predicted class and confidence

# Predict the result

print(f"Prediction: {class_names[pred_class]}")
print(f"Confidence:{confidence:.2f}

Dept of ISE, RNSIT 2024-25 14

Chapter 5
Result

15
 BCS602

Dept of ISE, RNSIT 2024-25 16

 BCS602

Dept of ISE, RNSIT 2024-25 17

 Chapter 6

Conclusion
The NeuroMinds: Alzheimer’s Disease Prediction project is a practical application of deep learning in the field of
healthcare and medical imaging. It employs a Convolutional Neural Network (CNN) model to classify brain MRI
images into categories such as Alzheimer’s, Parkinson’s, or varying levels of cognitive risk. The model was trained
on a labeled medical imaging dataset and effectively captures spatial features using multiple convolutional and
pooling layers. The project pipeline covers data preprocessing, model architecture design, training, evaluation, and
deployment through a Streamlit-based web application. Users can upload brain MRI scans and receive instant
predictions along with confidence scores, making the tool highly interactive and clinically relevant. This project
deepens understanding of computer vision techniques, image preprocessing, and model evaluation in the context of
medical diagnostics. It also emphasizes the importance of usability, interpretability, and responsible deployment in
sensitive domains like healthcare. Overall, the NeuroMinds project showcases how AI can assist in early disease
detection, contributing significantly to both technical and societal impact—making it a valuable addition to any data
science

18
Chapter 7
Future Enhancements
1. Integration with Clinical Data APIs
Currently, the image input is manually uploaded by users. A major improvement would be to integrate with
hospital systems or medical image databases (e.g., PACS systems or public APIs like TCIA) to fetch patient
MRI data directly. This would streamline workflows for clinical use and enable real-time diagnostic support.

2. Incorporation of Patient Metadata

The existing model relies solely on MRI images. Future iterations could incorporate patient metadata such as
age, gender, family history, cognitive test scores, and lifestyle factors. These additional features can enhance
model accuracy and personalize predictions based on patient-specific risk profiles.

3. Multi-Modality Imaging Support

Alzheimer’s diagnosis often involves not only MRI scans but also PET scans and CT scans. Expanding the
model to handle multi-modality inputs could improve diagnostic power and give a more comprehensive
understanding of neurological health.

4. Explainable AI and Heatmap Visualizations

To improve interpretability, integrating techniques like Grad-CAM or Layer-wise Relevance Propagation could
visually show which brain regions influenced the model’s decision. This is critical in healthcare settings to
build trust with clinicians and validate predictions.

5. Time-Series Progression Tracking

Extending the system to analyze and compare longitudinal MRI scans of the same patient can help track
disease progression over time. Implementing recurrent models like LSTMs or Transformer-based vision
models could capture temporal patterns in disease development.

6. Federated Learning for Privacy-Preserving Model Training

To address data privacy concerns, especially in medical applications, adopting federated learning would allow
the model to be trained across decentralized hospital datasets without sharing sensitive patient data. This
enhances data security while enabling robust training on diverse datasets.

Dept of ISE, RNSIT 2024-25 19

 BCS602

REFERENCES

1. PyTorch – [Link]
2. Torchvision – [Link]
3. Pillow (PIL) – [Link]
4. Matplotlib – [Link]
5. THOP – [Link]
6. Google Colab – [Link]
7. Python Docs – [Link]
8. Scikit-learn – [Link]

1.

Dept of ISE, RNSIT 2024-25 20