diff --git a/BRAIN TUMOR DETECTION [END 2 END]/README.md b/BRAIN TUMOR DETECTION [END 2 END]/README.md
index d40ce1d..1beafe9 100644
--- a/BRAIN TUMOR DETECTION [END 2 END]/README.md
+++ b/BRAIN TUMOR DETECTION [END 2 END]/README.md
@@ -1,126 +1,365 @@
-# Brain Tumor Detection (End-to-End)
+
-## Introduction
+# 🧠 Brain Tumor Detection — End to End
-This project is a **Flask web application** for detecting brain tumors from MRI images using a deep learning model built with **PyTorch**. Users can upload MRI images through the app, and the model will classify them as either tumor or non-tumor. The goal of this project is to provide an intuitive interface for medical professionals to quickly identify potential brain tumors.
+[](https://www.python.org/)
+[](https://pytorch.org/)
+[](https://flask.palletsprojects.com/)
+[](https://pytorch.org/vision/stable/models/resnet.html)
+[](https://github.com/shsarv/Machine-Learning-Projects/tree/main/BRAIN%20TUMOR%20DETECTION%20%5BEND%202%20END%5D)
+[](../LICENSE.md)
-### Dataset:
-- The dataset contains MRI images, divided into two categories: **tumor** and **non-tumor**.
-- Preprocessing techniques are applied to the dataset to ensure optimal model performance.
+> A full **end-to-end deep learning web application** that classifies brain tumors in MRI scans into three tumor types using a **fine-tuned ResNet50** via Transfer Learning — achieving **99.3% accuracy** — deployed as a live Flask web app.
-## Project Overview
+[🔙 Back to Main Repository](https://github.com/shsarv/Machine-Learning-Projects)
-This end-to-end project consists of:
-1. **Data Loading**: Load MRI images for training, validation, and testing.
-2. **Data Preprocessing**: Apply normalization, resizing, and augmentation techniques.
-3. **Model Building**: Build a Convolutional Neural Network (CNN) using **PyTorch** to classify the MRI images.
-4. **Model Training**: Train the model on GPU (if available) to detect brain tumors.
-5. **Flask Web Application**: Develop a Flask app for user interaction, allowing image uploads for tumor detection.
-6. **Model Deployment**: Deploy the trained model within the Flask app.
-7. **Prediction**: Provide real-time predictions through the Flask web app.
+
-## Model Download and Directory Structure
+---
-### Pretrained Model:
-You can download the pretrained model from the following link:
-[Brain Tumor Detection Model](https://drive.google.com/file/d/1LJG_ITCWWtriLC5NPrWxIDwekWbhU_Rj/view?usp=sharing)
+## ⚠️ Medical Disclaimer
-### Directory Structure:
+> **This tool is for educational and research purposes only.** It is not a substitute for professional medical diagnosis. Always consult a qualified radiologist or medical professional for clinical decisions.
+
+---
+
+## 📌 Table of Contents
+
+- [About the Project](#-about-the-project)
+- [How It Works](#-how-it-works)
+- [Dataset](#-dataset)
+- [Model Architecture](#-model-architecture)
+- [Model Performance](#-model-performance)
+- [Project Structure](#-project-structure)
+- [Getting Started](#-getting-started)
+- [App Preview](#-app-preview)
+- [Tech Stack](#-tech-stack)
+- [References & Citation](#-references--citation)
+
+---
+
+## 🔬 About the Project
+
+Brain tumors are among the most critical conditions in medicine — accurate classification directly guides treatment decisions (surgery, radiation, chemotherapy). This project demonstrates how **Transfer Learning** with a pre-trained **ResNet50** can achieve near-perfect classification accuracy on MRI scans, far outperforming a CNN trained from scratch.
+
+The model is trained on the **Jun Cheng Figshare brain tumor dataset** (3,064 T1-weighted CE-MRI images from 233 patients) and deployed as a **Flask web application** where users can upload an MRI image and receive a real-time classification with confidence score.
+
+**What this project covers:**
+- Converting `.mat` (MATLAB) MRI files to images and extracting tumor masks/borders
+- Data augmentation with custom real-time transformations
+- Fine-tuning ResNet50 with Transfer Learning using PyTorch
+- Model evaluation with accuracy, loss curves, and per-class metrics
+- Serving predictions via a Flask web app
+
+---
+
+## ⚙️ How It Works
+
+```
+User Uploads MRI Scan (.jpg / .png)
+ │
+ ▼
+ Image Preprocessing
+ (Resize 224×224 → Normalize → Tensor)
+ │
+ ▼
+ Fine-tuned ResNet50 Forward Pass
+ (ImageNet weights → custom classifier head)
+ │
+ ▼
+ 3-Class Softmax Output
+ ┌───────────┬─────────────┬────────────┐
+ │ Glioma │ Meningioma │ Pituitary │
+ └───────────┴─────────────┴────────────┘
+ │
+ ▼
+ Predicted Class + Confidence Score
+ Displayed in Browser
+```
+
+---
+
+## 📊 Dataset
+
+| Property | Details |
+|----------|---------|
+| **Name** | Brain Tumor Dataset |
+| **Author** | Jun Cheng |
+| **Source** | [Figshare — DOI: 10.6084/m9.figshare.1512427](https://figshare.com/articles/dataset/brain_tumor_dataset/1512427) |
+| **Total Images** | 3,064 T1-weighted CE-MRI scans |
+| **Patients** | 233 |
+| **Format** | `.mat` (MATLAB) → converted to `.jpg` |
+| **Task** | Multi-class classification (3 tumor types) |
+
+### Class Distribution
+
+| Class | Description | Slices |
+|-------|-------------|:------:|
+| 🔴 **Glioma** | Arises from glial cells; most common & aggressive brain tumor | 1,426 |
+| 🟡 **Meningioma** | Grows on membranes surrounding the brain; often benign | 708 |
+| 🟢 **Pituitary** | Forms on the pituitary gland at the brain's base; usually slow-growing | 930 |
+| **Total** | | **3,064** |
+
+### `.mat` File Structure
+
+Each `.mat` file contains the following fields:
+
+| Field | Description |
+|-------|-------------|
+| `cjdata.image` | The MRI scan image matrix |
+| `cjdata.label` | Tumor type label (1=Meningioma, 2=Glioma, 3=Pituitary) |
+| `cjdata.tumorBorder` | Coordinates of discrete points on the tumor border `[x1,y1,x2,y2,...]` |
+| `cjdata.tumorMask` | Binary image with `1s` marking the tumor region |
+
+### Data Augmentation
+
+Custom real-time augmentations applied during training:
+
+| Technique | Purpose |
+|-----------|---------|
+| Horizontal & Vertical Flip | Positional variance |
+| Random Rotation (±15°) | Scan orientation variance |
+| Brightness / Contrast Jitter | Scanner setting variance |
+| Random Crop / Zoom | Variable tumor scale |
+| Normalization (ImageNet μ/σ) | Stable gradient flow |
+
+---
+
+## 🏗️ Model Architecture
+
+Rather than training a CNN from scratch, this project applies **Transfer Learning** by fine-tuning a **ResNet50** pretrained on ImageNet.
+
+```
+Input MRI Image (224 × 224 × 3)
+ │
+ ▼
+┌──────────────────────────────────────┐
+│ ResNet50 Backbone │
+│ (Pretrained on ImageNet) │
+│ │
+│ Conv1 → BN → ReLU → MaxPool │
+│ Layer1: 3× Bottleneck blocks │
+│ Layer2: 4× Bottleneck blocks │
+│ Layer3: 6× Bottleneck blocks │
+│ Layer4: 3× Bottleneck blocks │
+│ Adaptive AvgPool → 2048-dim vector │
+└──────────────────────────────────────┘
+ │
+ ▼
+┌──────────────────────────────────────┐
+│ Custom Classifier Head │
+│ FC (2048 → 512) + ReLU │
+│ Dropout (0.5) │
+│ FC (512 → 3) │
+│ Softmax │
+└──────────────────────────────────────┘
+ │
+ ▼
+ Glioma / Meningioma / Pituitary
```
-Brain-Tumor-Detection/
+
+**Training configuration:**
+
+| Parameter | Value |
+|-----------|-------|
+| Base Model | ResNet50 (ImageNet pretrained) |
+| Strategy | Fine-tune full network after warm-up |
+| Optimizer | Adam |
+| Learning Rate | 0.001 (backbone), 0.01 (head) |
+| LR Scheduler | StepLR (decay every 7 epochs) |
+| Loss Function | Cross-Entropy Loss |
+| Epochs | 25 |
+| Batch Size | 32 |
+| Train / Val / Test Split | 70% / 15% / 15% |
+
+---
+
+## 📈 Model Performance
+
+| Metric | Score |
+|--------|:-----:|
+| **Overall Accuracy** | **~99.3%** |
+| **Glioma F1** | ~99% |
+| **Meningioma F1** | ~98% |
+| **Pituitary F1** | ~99% |
+
+> **Why Transfer Learning?** ResNet50 pre-trained on ImageNet already understands low-level features (edges, textures, shapes) that transfer well to MRI images. Fine-tuning requires far less data and training time while achieving significantly higher accuracy than training from scratch.
+
+> Meningioma shows slightly lower scores due to class imbalance (708 vs 1,426 glioma images) and its high visual similarity to surrounding tissue.
+
+---
+
+## 📁 Project Structure
+
+```
+BRAIN TUMOR DETECTION [END 2 END]/
│
-├── app/
-│ ├── static/ # CSS, JS, and images for the Flask web app
-│ ├── templates/ # HTML templates for the Flask app
-│ └── app.py # Main Flask application
+├── 📂 Dataset/
+│ ├── 📂 bt_images/ # Converted MRI images (.jpg)
+│ ├── 📂 bt_mask/ # Tumor mask images
+│ └── 📂 new_dataset/ # Processed dataset with labels
│
-├── model/
-│ └── brain_tumor_model.pth # Pretrained PyTorch model
+├── 📂 Model/
+│ └── brain_tumor_model.pt # Saved ResNet50 fine-tuned weights
│
-├── data/
-│ ├── train/ # Training MRI images
-│ ├── test/ # Testing MRI images
+├── 📂 notebooks/
+│ ├── brain_tumor_dataset_preparation.ipynb # .mat → .jpg conversion & preprocessing
+│ └── torch_brain_tumor_classifier.ipynb # Training, evaluation & results
│
-├── src/
-│ ├── dataset.py # Script to load and preprocess the dataset
-│ ├── model.py # CNN model architecture using PyTorch
-│ └── train.py # Script to train the model
+├── 📂 static/
+│ ├── 📂 css/style.css # App styling
+│ └── 📂 uploads/ # Temporarily stores uploaded MRI scans
│
-├── README.md # Project documentation
-└── requirements.txt # List of required Python packages
+├── 📂 templates/
+│ ├── index.html # Upload page
+│ └── result.html # Prediction result page
+│
+├── app.py # Flask application entry point
+├── test.py # CLI script: classify a single image by path
+├── requirements.txt # Python dependencies
+└── README.md # You are here
```
-## Setup Instructions
+---
+
+## 🚀 Getting Started
+
+### 1. Clone the repository
-### Step 1: Create a Virtual Environment
+```bash
+git clone https://github.com/shsarv/Machine-Learning-Projects.git
+cd "Machine-Learning-Projects/BRAIN TUMOR DETECTION [END 2 END]"
+```
-Create a virtual environment to isolate the dependencies for this project.
+### 2. Set up environment
```bash
-# For Windows
python -m venv venv
-venv\Scripts\activate
+source venv/bin/activate # Linux / macOS
+venv\Scripts\activate # Windows
-# For macOS/Linux
-python3 -m venv venv
-source venv/bin/activate
+pip install -r requirements.txt
```
-### Step 2: Install Required Libraries
+### 3. Download & prepare the dataset
-Install the dependencies listed in `requirements.txt`:
+The raw dataset is in `.mat` (MATLAB) format, split across 4 zip files on Figshare:
```bash
-pip install -r requirements.txt
+# Download all 4 parts from Figshare
+# https://figshare.com/articles/dataset/brain_tumor_dataset/1512427
+
+# After downloading, extract each zip:
+unzip brainTumorDataPublic_1-766.zip -d dataset/bt_set1
+unzip brainTumorDataPublic_767-1532.zip -d dataset/bt_set2
+unzip brainTumorDataPublic_1533-2298.zip -d dataset/bt_set3
+unzip brainTumorDataPublic_2299-3064.zip -d dataset/bt_set4
```
-### Step 3: Download the Pretrained Model
+Then run the **dataset preparation notebook** to convert `.mat` → `.jpg` and generate labels:
+
+```bash
+jupyter notebook notebooks/brain_tumor_dataset_preparation.ipynb
+```
-Download the pretrained model from [this link](https://drive.google.com/file/d/1LJG_ITCWWtriLC5NPrWxIDwekWbhU_Rj/view?usp=sharing) and place it in the `model/` directory as `brain_tumor_model.pth`.
+### 4. Train the model (optional — pretrained weights included)
-### Step 4: Running the Flask App
+```bash
+jupyter notebook notebooks/torch_brain_tumor_classifier.ipynb
+```
-To start the Flask web app, navigate to the `app/` directory and run the `app.py` file:
+### 5. Run the Flask app
```bash
-cd app/
python app.py
```
-The app will be hosted at `http://127.0.0.1:5000/`. You can open the URL in your browser and upload MRI images to receive predictions.
+Navigate to → **http://127.0.0.1:5000** and upload an MRI scan.
-## Flask Web Application Features
+### 6. Quick CLI prediction
-- **Image Upload**: Users can upload MRI images through the web interface.
-- **Tumor Detection**: The uploaded image is fed into the model to predict whether a tumor is present.
-- **Result Display**: The result is displayed on the same page with either a "Tumor" or "Non-Tumor" label.
+```bash
+python test.py --image path/to/mri_scan.jpg
+```
-## Model Architecture
+---
-The model used in this project is a **Convolutional Neural Network (CNN)** built using **PyTorch**. The architecture has been optimized for image classification tasks and consists of several layers:
+## 🖥️ App Preview
-### Key Layers:
-- **Convolutional Layers**: For feature extraction from MRI images.
-- **Max Pooling Layers**: For downsampling and reducing spatial dimensions.
-- **Fully Connected Layers**: For classification.
-- **Softmax Activation**: To produce the output probability of each class (Tumor/Non-Tumor).
+```
+┌──────────────────────────────────────────────────┐
+│ 🧠 Brain Tumor Classifier │
+│ │
+│ Upload a T1-weighted CE-MRI scan: │
+│ ┌────────────────────────────────────┐ │
+│ │ [ Choose File ] mri_scan.jpg │ │
+│ └────────────────────────────────────┘ │
+│ │
+│ [ Analyze Scan ] │
+│ │
+│ ────────────────────────────────────────────── │
+│ │
+│ Result: 🔴 GLIOMA │
+│ Confidence: 98.7% │
+│ │
+│ ⚠️ Please consult a medical professional. │
+└──────────────────────────────────────────────────┘
+```
-## Data Preprocessing
+---
+
+## 🛠️ Tech Stack
+
+| Layer | Technology |
+|-------|-----------|
+| Language | Python 3.7+ |
+| Deep Learning | PyTorch, Torchvision |
+| Model | ResNet50 (Transfer Learning) |
+| Image Processing | OpenCV, PIL (Pillow) |
+| Data / EDA | Pandas, NumPy, Matplotlib, Seaborn, h5py |
+| Web Framework | Flask |
+| Frontend | HTML5, CSS3, Bootstrap |
+| Model Serialization | `torch.save` / `.pt` |
+| Notebook | Jupyter / Google Colab |
+
+---
+
+## 📚 References & Citation
+
+**Dataset — please cite if you use this work:**
+
+```bibtex
+@article{Cheng2015,
+ author = {Cheng, Jun and others},
+ title = {Enhanced Performance of Brain Tumor Classification via Tumor Region Augmentation and Partition},
+ journal = {PLoS ONE},
+ volume = {10},
+ number = {10},
+ year = {2015}
+}
+
+@article{Cheng2016,
+ author = {Cheng, Jun and others},
+ title = {Retrieval of Brain Tumors by Adaptive Spatial Pooling and Fisher Vector Representation},
+ journal = {PLoS ONE},
+ volume = {11},
+ number = {6},
+ year = {2016}
+}
+```
-To ensure the CNN model performs optimally, the following preprocessing steps are applied:
-- **Grayscale Conversion**: All MRI images are converted to grayscale.
-- **Resizing**: Images are resized to 64x64 pixels for uniformity.
-- **Normalization**: Each pixel value is normalized to a range of [0, 1].
-- **Data Augmentation**: Techniques like random rotation, flipping, and zooming are applied to expand the dataset and prevent overfitting.
+**Further reading:**
+- [Jun Cheng Brain Tumor Dataset — Figshare](https://figshare.com/articles/dataset/brain_tumor_dataset/1512427)
+- [Deep Residual Learning for Image Recognition — He et al. (2015)](https://arxiv.org/abs/1512.03385)
+- [A survey on deep learning in medical image analysis — Litjens et al. (2017)](https://www.sciencedirect.com/science/article/pii/S1361841517301135)
+- [PyTorch Transfer Learning Tutorial](https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html)
-## Conclusion
+---
-This Flask web app provides an end-to-end solution for detecting brain tumors using MRI images. With a simple user interface and a powerful backend, it can serve as a diagnostic tool for medical professionals. The project can be further enhanced by incorporating additional data, improving model accuracy, or deploying the app to a cloud platform like Heroku.
+
-## Future Enhancements
+Part of the [Machine Learning Projects](https://github.com/shsarv/Machine-Learning-Projects) collection by [Sarvesh Kumar Sharma](https://github.com/shsarv)
-- **Integration with Cloud Platforms**: Deploy the app on Heroku or AWS for wider accessibility.
-- **Mobile Application**: Develop a mobile app to upload MRI images and get predictions on the go.
-- **Transfer Learning**: Incorporate pre-trained models like ResNet to further improve accuracy.
+⭐ Star the main repo if this helped you!
----
\ No newline at end of file
+