Brain Tumor Segmentation using SwiM-UNet (Academic Project)

Project Introduction
I am looking for an experienced Python, Deep Learning, and Flask developer to develop a complete Brain Tumor Segmentation System using the Swin-UNet architecture for Final Year Project.
The system will use the BraTS 2021 brain MRI dataset to automatically segment brain tumor regions from MRI scans using a deep learning model.
The project will include dataset preprocessing, deep learning model implementation, model training, performance evaluation, result visualization, and a complete Flask-based web application.
The web application should allow users to upload MRI scans and visualize the predicted brain tumor segmentation results.
My main requirement is not just to receive the source code. I also need complete guidance to install, run, test, understand, demonstrate, and explain the project independently.
The complete project must be developed according to the following requirements.
2. Functional Requirements
Module 1: Dataset Management
Use the official BraTS 2021 dataset.
Use at least 300 patient cases.
Divide the dataset into 60% training and 40% validation sets at patient level.
Support all four MRI modalities: T1, T1ce,T2, FLAIR
Load MRI images and segmentation masks using Nibabel.
Organize and manage dataset files properly.
Generate sample MRI visualizations.
Do not use random or unrelated datasets.
Dataset source:
https://www.kaggle.com/datasets/dschettler8845/brats-2021-task1
Module 2: Image Preprocessing
Load NIfTI MRI files.
Normalize MRI images.
Resize images where required.
Apply data augmentation, including rotation and flipping.
Prepare segmentation masks.
Convert segmentation labels into appropriate formats.
Prepare input images for model training.
Handle all four MRI modalities correctly.
Module 3: Swin-UNet Deep Learning Model
Implement Swin-UNet architecture using PyTorch.
Use the U-Net encoder-decoder structure with Swin Transformer blocks.
Implement Dice Loss combined with Cross-Entropy Loss.
Use AdamW optimizer.
Train the model using the BraTS 2021 dataset.
Save trained model weights and checkpoints.
Monitor training and validation loss.
Implement a proper training pipeline.
Provide configurable training parameters.
Module 4: Model Evaluation
Evaluate the trained model using:
Dice Similarity Coefficient (DSC).
Intersection over Union (IoU).
Training loss.
Validation loss.
Additional requirements:
Compare Swin-UNet with standard U-Net.
Generate training and validation graphs.
Generate actual segmentation performance results.
Visualize Whole Tumor (WT).
Visualize Tumor Core (TC).
Visualize Enhancing Tumor (ET).
Compare predicted masks with ground truth masks.
Provide actual results without fabricated accuracy or performance values.
Module 5: Flask Web Application
Develop a complete and responsive Flask-based web application.
Required pages and features:
Home page.
Project introduction page.
Dashboard.
MRI image upload page.
MRI image visualization.
Swin-UNet segmentation prediction.
Predicted segmentation mask visualization.
Original MRI and predicted result comparison.
Ground truth comparison when ground truth is available.
Separate visualization of WT, TC and ET.
Model performance information.
Download predicted segmentation results.
Upload validation and error handling.
About project page.
User-friendly navigation and responsive design.
Use HTML5, CSS3 and JavaScript to create a clean and professional interface.
Module 6: Result Management
Store prediction records if database integration is appropriate.
Maintain prediction history.
Display previously generated results.
Provide an option to view and download prediction results.
Use SQLite or MySQL if database functionality is implemented.
3. Technical Requirements
The following technologies should be used:
Python
PyTorch
Swin-UNet
Flask
NumPy
Nibabel
OpenCV
Matplotlib
Scikit-learn
HTML5
CSS3
JavaScript
SQLite or MySQL (if required)
The project must have a properly organized folder structure and modular code.
The complete project must be configured and tested so that I can run and demonstrate it on my personal laptop.
The developer must:
Configure the project for Windows.
Provide all installation commands.
Provide a requirements.txt file.
Create a virtual environment setup guide.
Configure Flask to run locally.
Provide CPU-based inference support.
Optimize memory usage for an 8GB RAM system.
Provide a lightweight prediction configuration.
Include trained model weights or a suitable inference checkpoint.
Ensure that sample MRI predictions work locally without downloading the complete training dataset.
Provide a Google Colab notebook for GPU-based model training if local training is not practical.
Explain how to transfer trained model weights from Google Colab to my laptop.
Test the complete application locally before final delivery.
Full training on my laptop is not mandatory if it requires GPU resources. However, the Flask application, trained model loading, sample predictions and project demonstration must work locally.
Please do not assume that my laptop has an NVIDIA GPU.
5. Complete Installation and Running Support (Mandatory)
After completing the project, I need the developer to help me install and run everything on my own laptop.
This support must include:
Python installation and configuration.
VS Code or another suitable IDE setup.
Virtual environment creation.
Installing all Python dependencies.
Dataset download and configuration.
Project folder setup.
Database setup, if applicable.
Model weights configuration.
Running preprocessing scripts.
Running training scripts or Google Colab notebook.
Starting the Flask application.
Opening and using the web application.
Uploading MRI images.
Generating segmentation predictions.
Viewing and downloading results.
The developer must provide step-by-step instructions and assist me in resolving installation errors, dependency conflicts, missing packages, runtime errors and other execution issues until the project runs successfully on my laptop.
At least one live online guidance session or recorded step-by-step installation demonstration must be provided.
6. Complete Source Code and Explanation
I need the complete source code, not just a compiled application or screenshots.
The developer must:
Deliver all Python files.
Deliver the complete Flask application.
Deliver HTML, CSS and JavaScript files.
Deliver model architecture files.
Deliver preprocessing and training scripts.
Deliver evaluation scripts.
Deliver trained model weights.
Deliver requirements.txt.
Deliver database files and scripts, if applicable.
Explain the purpose of every important file.
Explain important classes, functions and modules.
Explain how different components communicate with each other.
Provide properly commented and readable code.
The project should be easy for a beginner to understand and modify.
7. Complete Project Documentation
Provide a comprehensive project documentation/report in editable Microsoft Word format and PDF.
The documentation should include:
Title page.
Abstract.
Introduction.
Problem statement.
Project objectives.
Project scope.
Literature review.
Existing system.
Proposed system.
Functional requirements.
Non-functional requirements.
Hardware and software requirements.
System architecture.
Use case diagram.
Data flow diagram.
Activity diagram.
Dataset description.
Data preprocessing methodology.
Swin-UNet architecture.
Model training methodology.
Model evaluation methodology.
Results and discussion.
Flask web application implementation.
Testing and test cases.
Limitations.
References.
The documentation must accurately describe the actual implemented system, source code, dataset and results.
10. Optional Bonus Features
If possible, implement:
Hyperparameter tuning.
Morphological post-processing.
Conditional Random Fields (CRF).
Better visualization of segmentation results.
Model optimization.
Additional performance improvements.
11. Expected Final Deliverables
The final delivery must include:
Complete project source code.
Complete Flask web application.
Implemented Swin-UNet model.
BraTS 2021 preprocessing scripts.
Training and validation scripts.
Google Colab training notebook.
Trained model weights/checkpoints.
U-Net comparison.
Evaluation graphs and actual results.
Sample MRI images and prediction outputs.
requirements.txt.
Complete project folder.
Complete installation guide.
Complete source code explanation.
Video tutorial or live guidance session.
Successful local execution on my laptop.
The project must be runnable and demonstrable on my laptop.
I must receive complete guidance until I can independently run, understand and demonstrate the project.
My priority is a fully functional, properly documented and understandable project, along with complete support to run and demonstrate it independently.