AI Eye Disease Detection

Table of Contents

• Project Overview
• Prerequisites
• Installation
• Project Structure
• Usage
  • Running the Application
  • Testing via API
  • Using the Frontend
• Training the Model
• Troubleshooting
• Contributing

Project Overview

Prerequisites

• Python 3.10.16 (recommended for PyTorch compatibility)
• Git
• Dependencies listed in backend/requirements.txt
• GPU recommended for faster inference/training (CPU supported)
• Retinal images in dataset/G1020/Images_Square/ (e.g., 237.jpg)
• Pre-trained model from Hugging Face

Installation

1. Clone the Repository:
   bash

   1git clone https://github.com/Stalin-143/ai-eye-disease-detection.git 2cd ai-eye-disease-detection
2. Create Virtual Environment:
   bash

   1python3.10 -m venv venv 2source venv/bin/activate # Linux/Mac 3venv\Scripts\activate # Windows 4pip install --upgrade pip
3. Install Dependencies:
   bash

   1cd backend 2pip install -r requirements.txt
   If torch==2.0.1 fails, try:
   pip install torch==2.0.1 torchvision==0.15.2
4. Download the Model:
   bash

   1mkdir -p backend/model 2wget https://huggingface.co/5t4l1n/ai-eye-disease-detection/resolve/main/model/best_glaucoma_model.pth -O backend/model/best_glaucoma_model.pth
5. Configure Environment Variables: Create backend/.env:
   plaintext

   1FLASK_ENV=development 2FLASK_DEBUG=True 3FLASK_HOST=0.0.0.0 4FLASK_PORT=5000 5MODEL_PATH=./backend/model/best_glaucoma_model.pth 6MAX_CONTENT_LENGTH=16777216 7ALLOWED_ORIGINS=http://localhost:8000
   Update MODEL_PATH with the absolute path if needed (e.g., /home/stalin/Projects/ai-eye-disease-detection/backend/model/best_glaucoma_model.pth).
6. Clear Cache:
   rm -rf __pycache__ backend/__pycache__ backend/app/__pycache__

Project Structure

ai-eye-disease-detection/
├── backend/
│   ├── app/
│   │   ├── main.py              # Flask app entry point
│   │   ├── routes/prediction.py # API endpoints for predictions
│   │   ├── utils/glaucoma_predictor.py # Model inference logic
│   ├── model/
│   │   ├── best_glaucoma_model.pth # Pre-trained model
│   ├── requirements.txt         # Backend dependencies
│   ├── .env                    # Environment variables
├── frontend/
│   ├── index.html              # Frontend UI
│   ├── script.js               # Frontend JavaScript
│   ├── styles.css              # Frontend styles
├── dataset/
│   ├── G1020/
│   │   ├── Images_Square/      # Retinal images (e.g., 237.jpg)
│   ├── training.ipynb          # Jupyter notebook for training
├── server.py                   # Runs backend and frontend
├── venv/                       # Virtual environment
├── backup.ipynb                # Backup notebook
├── models/                     # Additional models (optional)
├── README.md                   # Project documentation
├── requirements.txt            # Root-level dependencies (optional)
├── templates/                  # Flask templates (if used)

Usage

Running the Application

1. Start Servers:
   bash

   1cd ai-eye-disease-detection 2source venv/bin/activate 3python server.py
   • Backend: http://localhost:5000
   • Frontend: http://localhost:8000 Expected logs:

   INFO:__main__:Starting Flask backend on http://localhost:5000...
   Backend: DEBUG:__main__:✅ Glaucoma predictor initialized successfully!
   INFO:__main__:Starting frontend HTTP server on http://localhost:8000...
   INFO:__main__:Both servers started successfully!

   

2. Stop Servers: Press Ctrl+C.

Build Docker Image

Linux

Windows (Command Prompt or PowerShell)

Run Docker Container

Linux

Windows (PowerShell)

Windows (Command Prompt)

Notes

• -v mounts the local dataset/ directory to /app/dataset in the container.
• Use backticks (`) in PowerShell or carets (^) in Command Prompt for line continuation.
• Ensure the dataset/ directory exists locally.

Verify Container

Linux/Windows

Expected Logs

INFO:__main__:Starting Flask backend on http://localhost:5000...
Backend: DEBUG:__main__:✅ Glaucoma predictor initialized successfully!
INFO:__main__:Starting frontend HTTP server on http://localhost:8000...

Testing via API

1. Check Health:
   curl http://localhost:5000/health
   Expected:
   {"status":"healthy","model_loaded":true}

   

2. Get Model Info:
   curl http://localhost:5000/api/model-info
   Expected:
   {"success":true,"data":{"model_type":"GlaucomaSeverityModel","architecture":"ResNet101 with SE Blocks",...}}

   

3. Predict Glaucoma:
   curl -F "image=@dataset/G1020/Images_Square/237.jpg" -F "return_probabilities=true" http://localhost:5000/api/predict
   Expected:
   {"success":true,"data":{"cdr":0.45,"severity":"Normal","severity_description":"No significant glaucoma signs","confidence":0.95,"risk_level":"Low","probabilities":{"Normal":0.95,"Mild":0.03,"Moderate":0.01,"Severe":0.01}},"filename":"237.jpg"}

   

Using the Frontend

1. Open http://localhost:8000 in a browser.
2. Get Model Info: Click “Get Model Info” to view model details.
3. Predict Glaucoma:
   • Upload an image (e.g., 237.jpg).
   • Check “Show Probabilities” (optional).
   • Click “Predict” to view results.

Training the Model

1. Prepare Dataset:
   • Ensure dataset/G1020/Images_Square/ has labeled images.
   • Check labels in a CSV or directory structure (e.g., Normal/, Mild/).
   • Run:
     ls dataset/G1020
2. Install Jupyter:
   bash

   1source venv/bin/activate 2pip install jupyter
3. Run training.ipynb:
   jupyter notebook dataset/training.ipynb
   • Update dataset path (e.g., dataset/G1020/Images_Square/).
   • Configure model (ResNet101 with SE blocks).
   • Adjust hyperparameters (e.g., learning rate, batch size).
   • Example:
     python

     1import torch 2import torchvision 3from torch.utils.data import DataLoader 4from torchvision import transforms 5transform = transforms.Compose([ 6 transforms.Resize((224, 224)), 7 transforms.ToTensor(), 8 transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) 9]) 10dataset = torchvision.datasets.ImageFolder('dataset/G1020/Images_Square/', transform=transform) 11loader = DataLoader(dataset, batch_size=32, shuffle=True) 12model = torchvision.models.resnet101(pretrained=True) 13model.fc = torch.nn.Linear(model.fc.in_features, 4) 14optimizer = torch.optim.Adam(model.parameters(), lr=0.001) 15criterion = torch.nn.CrossEntropyLoss()
4. Save Model:
   torch.save(model.state_dict(), 'backend/model/new_glaucoma_model.pth')
5. Update .env: Set MODEL_PATH to the new model in backend/.env.

Troubleshooting

• Model Not Loaded:
  • Check:
    ls backend/model/
  • Verify MODEL_PATH in backend/.env.
  • Share logs.
• Prediction Fails:
  • Run:
    curl -F "image=@dataset/G1020/Images_Square/237.jpg" -F "return_probabilities=true" http://localhost:5000/api/predict
  • Share output and logs.
  • Check browser console (F12).
• Pip Install Fails:
  • Share error. Try:
    pip install torch==2.0.1 torchvision==0.15.2

Contributing

1. Fork: https://github.com/Stalin-143/ai-eye-disease-detection
2. Branch: git checkout -b feature/your-feature
3. Commit: git commit -m "Add your feature"
4. Push: git push origin feature/your-feature
5. Open a pull request.