Update app configuration and add GitHub Pages setup

.github/workflows/deploy.yml

@@ -0,0 +1,33 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      
+    - name: Setup Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.9'
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        
+    - name: Deploy to GitHub Pages
+      uses: peaceiris/actions-gh-pages@v3
+      if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master'
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        publish_dir: ./
+        publish_branch: gh-pages

.gitignore

@@ -0,0 +1,88 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+saved_predictions/
+batch_results/
+*.log
+*.pth
+!resnet50_dr_classifier.pth
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

QUICK_START.md

@@ -0,0 +1,122 @@
+# 🚀 Quick Start Guide
+
+## ⚡ Get Running in 5 Minutes
+
+### 1. **Prerequisites Check**
+- ✅ Python 3.8+ installed
+- ✅ Model file `resnet50_dr_classifier.pth` present
+- ✅ Internet connection (for first-time package installation)
+
+### 2. **Easy Setup (Windows)**
+```bash
+# Option A: Double-click the batch file
+run_app.bat
+
+# Option B: Use PowerShell
+.\run_app.ps1
+
+# Option C: Use PowerShell with setup
+.\run_app.ps1 -Setup
+```
+
+### 3. **Manual Setup (All Platforms)**
+```bash
+# Create virtual environment (recommended)
+python -m venv venv
+
+# Activate virtual environment
+# Windows:
+venv\Scripts\activate
+# macOS/Linux:
+source venv/bin/activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Test the setup
+python test_model.py
+
+# Run the app
+python app.py
+```
+
+### 4. **What Happens Next**
+- 🌐 Web interface opens at `http://127.0.0.1:7860`
+- 📁 Upload OCT images for analysis
+- 🤖 AI classifies images as DR or NoDR
+- 🔥 Grad-CAM heatmap shows AI focus areas
+- 💾 Results automatically saved to `saved_predictions/` folder
+
+## 🎯 Usage Examples
+
+### **Single Image Analysis**
+1. Open `http://127.0.0.1:7860` in your browser
+2. Upload an OCT image
+3. View results and Grad-CAM visualization
+
+### **Batch Processing**
+```bash
+python batch_process.py
+```
+- Process multiple images at once
+- Get CSV report with all results
+- Grad-CAM images saved to `batch_results/` folder
+
+### **Testing & Validation**
+```bash
+python test_model.py
+```
+- Verify model loading
+- Test basic functionality
+- Check all dependencies
+
+## 🔧 Troubleshooting
+
+### **Common Issues**
+
+| Problem | Solution |
+|---------|----------|
+| "Model file not found" | Ensure `resnet50_dr_classifier.pth` is in the project folder |
+| "Package not found" | Run `pip install -r requirements.txt` |
+| "CUDA errors" | App runs on CPU by default. GPU not required |
+| "Port already in use" | Change port in `config.py` or kill existing process |
+
+### **Get Help**
+- Run `python setup.py` for comprehensive setup
+- Check `README.md` for detailed documentation
+- Use `python test_model.py` to diagnose issues
+
+## 📁 Project Structure
+```
+Deep_Learning_for_Ophthalmologist/
+├── app.py                          # 🌐 Main web application
+├── batch_process.py                # 🔄 Batch processing script
+├── test_model.py                   # 🧪 Testing and validation
+├── setup.py                        # ⚙️  Automated setup
+├── config.py                       # 🔧 Configuration settings
+├── requirements.txt                # 📦 Python dependencies
+├── resnet50_dr_classifier.pth     # 🤖 AI model weights
+├── run_app.bat                     # 🪟 Windows batch launcher
+├── run_app.ps1                     # 🪟 Windows PowerShell launcher
+├── README.md                       # 📚 Complete documentation
+├── QUICK_START.md                  # 🚀 This quick start guide
+├── saved_predictions/              # 💾 Single image results
+└── batch_results/                  # 📊 Batch processing results
+```
+
+## 🎉 You're Ready!
+
+Your AI-powered diabetic retinopathy detection app is now ready to use! 
+
+**Next steps:**
+1. 🖱️ Double-click `run_app.bat` (Windows) or run `python app.py`
+2. 🌐 Open your web browser to the displayed URL
+3. 📁 Upload OCT images for analysis
+4. 🔬 Explore the Grad-CAM visualizations
+5. 📊 Use batch processing for multiple images
+
+**Remember:** This tool is for research and educational purposes. Always consult healthcare professionals for medical diagnosis.
+
+---
+
+*Need help? Check the full `README.md` or run `python setup.py` for detailed assistance.*

README.md

@@ -1,13 +1,119 @@
----
-title: ИИ-диагностика диабетической ретинопатии по ОКТ
-emoji: 🏃
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 5.32.0
-app_file: app.py
-pinned: false
-short_description: Определение % вероятности наличия диабетической ретинопатии
+# AI Diabetic Retinopathy Detection
+
+An AI-powered application for detecting diabetic retinopathy (DR) from Optical Coherence Tomography (OCT) images using deep learning and Grad-CAM visualization.
+
+## 🏥 What is Diabetic Retinopathy?
+
+Diabetic retinopathy is a diabetes complication that affects the eyes. It's caused by damage to the blood vessels of the light-sensitive tissue at the back of the eye (retina). Early detection is crucial for preventing vision loss.
+
+## 🚀 Features
+
+- **AI Classification**: Uses a pre-trained ResNet-50 model to classify OCT images as DR (Diabetic Retinopathy) or NoDR (No Diabetic Retinopathy)
+- **Grad-CAM Visualization**: Shows which areas of the image the AI focuses on for diagnosis
+- **Confidence Scoring**: Provides probability scores for predictions
+- **Image Storage**: Automatically saves analyzed images with timestamps
+- **Web Interface**: User-friendly Gradio web interface
+
+## 📋 Requirements
+
+- Python 3.8 or higher
+- PyTorch 2.0+
+- CUDA-compatible GPU (optional, for faster inference)
+
+## 🛠️ Installation
+
+1. **Clone or download this repository**
+   ```bash
+   git clone <repository-url>
+   cd Deep_Learning_for_Ophthalmologist
+   ```
+
+2. **Create a virtual environment (recommended)**
+   ```bash
+   python -m venv venv
+   
+   # On Windows:
+   venv\Scripts\activate
+   
+   # On macOS/Linux:
+   source venv/bin/activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## 🎯 Usage
+
+1. **Start the application**
+   ```bash
+   python app.py
+   ```
+
+2. **Open your web browser** and navigate to the URL shown in the terminal (usually `http://127.0.0.1:7860`)
+
+3. **Upload an OCT image** by clicking the upload area or dragging and dropping an image file
+
+4. **View results**:
+   - The AI will analyze the image and show the classification result
+   - A Grad-CAM heatmap will highlight areas of interest
+   - The prediction and confidence score will be displayed
+   - The analyzed image will be automatically saved to the `saved_predictions` folder
+
+## 📁 File Structure
+
+```
+Deep_Learning_for_Ophthalmologist/
+├── app.py                          # Main application file
+├── requirements.txt                # Python dependencies
+├── resnet50_dr_classifier.pth     # Pre-trained model weights
+├── README.md                      # This file
+└── saved_predictions/             # Folder for saved analyzed images
+```
+
+## 🔬 How It Works
+
+1. **Image Preprocessing**: OCT images are resized to 224x224 pixels and normalized
+2. **AI Analysis**: A ResNet-50 model processes the image to classify DR vs NoDR
+3. **Grad-CAM**: Generates a heatmap showing which image regions influenced the AI's decision
+4. **Results**: Displays classification, confidence score, and visual heatmap
+
+## 📊 Model Information
+
+- **Architecture**: ResNet-50 with modified final layer for binary classification
+- **Training**: Pre-trained on OCT image dataset
+- **Classes**: 2 (DR - Diabetic Retinopathy, NoDR - No Diabetic Retinopathy)
+- **Input**: 224x224 RGB images
+- **Output**: Binary classification with confidence scores
+
+## ⚠️ Important Notes
+
+- **Medical Disclaimer**: This tool is for research and educational purposes only. It should not be used for actual medical diagnosis without proper validation and clinical oversight.
+- **Image Quality**: For best results, use high-quality OCT images with good contrast and resolution
+- **Model Limitations**: The model's accuracy depends on the quality and characteristics of the training data
+
+## 🐛 Troubleshooting
+
+- **CUDA errors**: The app runs on CPU by default. If you have GPU issues, ensure PyTorch is installed correctly
+- **Memory issues**: Large images may cause memory problems. The app automatically resizes images to 224x224
+- **Model loading errors**: Ensure `resnet50_dr_classifier.pth` is in the same directory as `app.py`
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.
+
+## 📄 License
+
+This project is for educational and research purposes. Please ensure compliance with relevant regulations when using medical imaging data.
+
+## 🔗 References
+
+- [PyTorch](https://pytorch.org/)
+- [Gradio](https://gradio.app/)
+- [Grad-CAM](https://github.com/jacobgil/pytorch-grad-cam)
+- [ResNet Paper](https://arxiv.org/abs/1512.03385)
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Note**: This application is designed for research and educational purposes in ophthalmology and medical AI. Always consult with qualified healthcare professionals for actual medical diagnosis and treatment decisions.

app.py

@@ -13,7 +13,8 @@ import datetime
 
 # Setup
 device = torch.device("cpu")
-save_dir = "/home/user/app/saved_predictions"
+# Create save directory in current working directory for cross-platform compatibility
+save_dir = os.path.join(os.getcwd(), "saved_predictions")
 if not os.path.exists(save_dir):
     os.makedirs(save_dir)
     print("📁 Folder created:", save_dir)
@@ -68,11 +69,14 @@ def predict_retinopathy(image):
 # Gradio app
 gr.Interface(
     fn=predict_retinopathy,
-    inputs=gr.Image(type="pil"),
+    inputs=gr.Image(type="pil", label="Upload OCT Image"),
     outputs=[
-        gr.Image(type="pil", label="Метод Grad-CAM"),
-        gr.Text(label="Вероятность ДР в %")
+        gr.Image(type="pil", label="Grad-CAM Heatmap"),
+        gr.Text(label="Diabetic Retinopathy Prediction")
     ],
-    title="Диагностика диабетической ретинопатии",
-    description="Загрузите ОКТ и смотрите ИИ-карту Grad-CAM heatmap"
-).launch()
+    title="AI Diabetic Retinopathy Detection",
+    description="Upload an OCT image to analyze for diabetic retinopathy. The AI will show a Grad-CAM heatmap highlighting areas of interest.",
+    examples=[
+        ["example_oct.jpg"] if os.path.exists("example_oct.jpg") else None
+    ]
+).launch(server_name="0.0.0.0", server_port=7860)

batch_process.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+Batch processing script for diabetic retinopathy detection.
+Processes multiple OCT images and saves results in a structured format.
+"""
+
+import os
+import torch
+import torch.nn.functional as F
+import numpy as np
+from PIL import Image
+from torchvision import models, transforms
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+from pytorch_grad_cam.utils.image import show_cam_on_image
+import csv
+import datetime
+from pathlib import Path
+
+class BatchDRDetector:
+    def __init__(self, model_path="resnet50_dr_classifier.pth"):
+        """Initialize the batch detector with the trained model."""
+        self.device = torch.device("cpu")
+        self.model_path = model_path
+        self.model = None
+        self.cam = None
+        self.transform = None
+        self.output_dir = "batch_results"
+        
+        # Create output directory
+        os.makedirs(self.output_dir, exist_ok=True)
+        
+        self._load_model()
+        self._setup_gradcam()
+        self._setup_transforms()
+    
+    def _load_model(self):
+        """Load the trained ResNet-50 model."""
+        print("🔄 Loading model...")
+        try:
+            self.model = models.resnet50(weights=None)
+            self.model.fc = torch.nn.Linear(self.model.fc.in_features, 2)
+            self.model.load_state_dict(torch.load(self.model_path, map_location=self.device))
+            self.model.to(self.device)
+            self.model.eval()
+            print("✅ Model loaded successfully!")
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            raise
+    
+    def _setup_gradcam(self):
+        """Setup Grad-CAM for visualization."""
+        target_layer = self.model.layer4[-1]
+        self.cam = GradCAM(model=self.model, target_layers=[target_layer])
+        print("✅ Grad-CAM setup complete!")
+    
+    def _setup_transforms(self):
+        """Setup image preprocessing transforms."""
+        self.transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+        ])
+    
+    def process_single_image(self, image_path):
+        """Process a single image and return results."""
+        try:
+            # Load and preprocess image
+            img = Image.open(image_path).convert("RGB")
+            img_tensor = self.transform(img).unsqueeze(0).to(self.device)
+            
+            # Get prediction
+            with torch.no_grad():
+                output = self.model(img_tensor)
+                probs = F.softmax(output, dim=1)
+                pred = torch.argmax(probs, dim=1).item()
+                confidence = probs[0][pred].item()
+            
+            # Generate Grad-CAM
+            rgb_img_np = np.array(img.resize((224, 224))).astype(np.float32) / 255.0
+            rgb_img_np = np.ascontiguousarray(rgb_img_np)
+            grayscale_cam = self.cam(input_tensor=img_tensor, targets=[ClassifierOutputTarget(pred)])[0]
+            cam_image = show_cam_on_image(rgb_img_np, grayscale_cam, use_rgb=True)
+            
+            # Determine label
+            label = "DR" if pred == 0 else "NoDR"
+            
+            return {
+                'image_path': image_path,
+                'prediction': label,
+                'confidence': confidence,
+                'dr_probability': 1 - confidence if pred == 1 else confidence,
+                'cam_image': cam_image,
+                'status': 'success'
+            }
+            
+        except Exception as e:
+            return {
+                'image_path': image_path,
+                'prediction': 'ERROR',
+                'confidence': 0.0,
+                'dr_probability': 0.0,
+                'cam_image': None,
+                'status': f'error: {str(e)}'
+            }
+    
+    def process_directory(self, input_dir, extensions=['.jpg', '.jpeg', '.png', '.tiff', '.bmp']):
+        """Process all images in a directory."""
+        print(f"🔍 Scanning directory: {input_dir}")
+        
+        # Find all image files
+        image_files = []
+        for ext in extensions:
+            image_files.extend(Path(input_dir).glob(f"*{ext}"))
+            image_files.extend(Path(input_dir).glob(f"*{ext.upper()}"))
+        
+        if not image_files:
+            print("❌ No image files found in the directory!")
+            return []
+        
+        print(f"📁 Found {len(image_files)} image files")
+        
+        # Process each image
+        results = []
+        for i, image_path in enumerate(image_files, 1):
+            print(f"🔄 Processing {i}/{len(image_files)}: {image_path.name}")
+            result = self.process_single_image(str(image_path))
+            results.append(result)
+            
+            # Save Grad-CAM image if successful
+            if result['status'] == 'success' and result['cam_image'] is not None:
+                cam_filename = f"cam_{Path(image_path).stem}_{result['prediction']}_{result['confidence']:.3f}.png"
+                cam_path = os.path.join(self.output_dir, cam_filename)
+                Image.fromarray(result['cam_image']).save(cam_path)
+                result['cam_saved_path'] = cam_path
+        
+        return results
+    
+    def save_results_csv(self, results, filename=None):
+        """Save results to a CSV file."""
+        if not filename:
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"dr_results_{timestamp}.csv"
+        
+        csv_path = os.path.join(self.output_dir, filename)
+        
+        with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
+            fieldnames = ['image_path', 'prediction', 'confidence', 'dr_probability', 'status', 'cam_saved_path']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            
+            writer.writeheader()
+            for result in results:
+                # Clean up the result dict for CSV
+                csv_result = {k: v for k, v in result.items() if k in fieldnames}
+                writer.writerow(csv_result)
+        
+        print(f"📊 Results saved to: {csv_path}")
+        return csv_path
+    
+    def generate_summary(self, results):
+        """Generate a summary of the batch processing results."""
+        successful = [r for r in results if r['status'] == 'success']
+        errors = [r for r in results if r['status'] != 'success']
+        
+        if successful:
+            dr_count = len([r for r in successful if r['prediction'] == 'DR'])
+            nodr_count = len([r for r in successful if r['prediction'] == 'NoDR'])
+            
+            avg_confidence = np.mean([r['confidence'] for r in successful])
+            avg_dr_prob = np.mean([r['dr_probability'] for r in successful])
+            
+            summary = {
+                'total_images': len(results),
+                'successful': len(successful),
+                'errors': len(errors),
+                'dr_detected': dr_count,
+                'no_dr_detected': nodr_count,
+                'dr_percentage': (dr_count / len(successful)) * 100 if successful else 0,
+                'average_confidence': avg_confidence,
+                'average_dr_probability': avg_dr_prob
+            }
+        else:
+            summary = {
+                'total_images': len(results),
+                'successful': 0,
+                'errors': len(errors),
+                'dr_detected': 0,
+                'no_dr_detected': 0,
+                'dr_percentage': 0,
+                'average_confidence': 0,
+                'average_dr_probability': 0
+            }
+        
+        return summary
+
+def main():
+    """Main function for batch processing."""
+    print("🚀 Diabetic Retinopathy Detection - Batch Processing")
+    print("=" * 60)
+    
+    # Check if model exists
+    if not os.path.exists("resnet50_dr_classifier.pth"):
+        print("❌ Model file 'resnet50_dr_classifier.pth' not found!")
+        print("   Please ensure the model file is in the current directory.")
+        return
+    
+    # Initialize detector
+    try:
+        detector = BatchDRDetector()
+    except Exception as e:
+        print(f"❌ Failed to initialize detector: {e}")
+        return
+    
+    # Get input directory from user
+    print("\n📁 Enter the path to the directory containing OCT images:")
+    print("   (or press Enter to use current directory)")
+    
+    user_input = input("Directory path: ").strip()
+    
+    if user_input:
+        input_dir = user_input
+    else:
+        input_dir = os.getcwd()
+    
+    if not os.path.exists(input_dir):
+        print(f"❌ Directory not found: {input_dir}")
+        return
+    
+    print(f"\n🎯 Processing images from: {input_dir}")
+    
+    # Process images
+    results = detector.process_directory(input_dir)
+    
+    if not results:
+        print("❌ No results to process!")
+        return
+    
+    # Save results
+    csv_path = detector.save_results_csv(results)
+    
+    # Generate and display summary
+    summary = detector.generate_summary(results)
+    
+    print("\n📊 Batch Processing Summary")
+    print("=" * 40)
+    print(f"Total images: {summary['total_images']}")
+    print(f"Successfully processed: {summary['successful']}")
+    print(f"Errors: {summary['errors']}")
+    
+    if summary['successful'] > 0:
+        print(f"DR detected: {summary['dr_detected']} ({summary['dr_percentage']:.1f}%)")
+        print(f"No DR detected: {summary['no_dr_detected']}")
+        print(f"Average confidence: {summary['average_confidence']:.3f}")
+        print(f"Average DR probability: {summary['average_dr_probability']:.3f}")
+    
+    print(f"\n📁 Results saved to: {detector.output_dir}/")
+    print(f"📊 CSV report: {csv_path}")
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+Configuration file for Diabetic Retinopathy Detection App
+Modify these settings to customize the application behavior
+"""
+
+import os
+
+# Model Configuration
+MODEL_CONFIG = {
+    'model_path': 'resnet50_dr_classifier.pth',
+    'model_architecture': 'resnet50',
+    'num_classes': 2,
+    'input_size': (224, 224),
+    'device': 'cpu'  # Change to 'cuda' if you have a GPU
+}
+
+# Image Processing Configuration
+IMAGE_CONFIG = {
+    'supported_formats': ['.jpg', '.jpeg', '.png', '.tiff', '.bmp'],
+    'max_file_size_mb': 50,  # Maximum file size in MB
+    'normalization_mean': [0.485, 0.456, 0.406],
+    'normalization_std': [0.229, 0.224, 0.225]
+}
+
+# Grad-CAM Configuration
+GRADCAM_CONFIG = {
+    'target_layer': 'layer4[-1]',  # Target layer for visualization
+    'colormap': 'jet',  # Colormap for heatmap visualization
+    'alpha': 0.4  # Transparency of the heatmap overlay
+}
+
+# Application Configuration
+APP_CONFIG = {
+    'title': 'AI Diabetic Retinopathy Detection',
+    'description': 'Upload an OCT image to analyze for diabetic retinopathy. The AI will show a Grad-CAM heatmap highlighting areas of interest.',
+    'theme': 'default',  # Gradio theme
+    'share': False,  # Whether to create a public link
+    'server_name': '127.0.0.1',
+    'server_port': 7860,
+    'debug': False
+}
+
+# Output Configuration
+OUTPUT_CONFIG = {
+    'save_predictions': True,
+    'save_gradcam': True,
+    'output_dir': 'saved_predictions',
+    'batch_output_dir': 'batch_results',
+    'filename_format': '{timestamp}_{label}_{confidence:.3f}.png'
+}
+
+# Medical Disclaimer
+MEDICAL_DISCLAIMER = """
+⚠️ MEDICAL DISCLAIMER ⚠️
+
+This tool is for research and educational purposes only. 
+It should not be used for actual medical diagnosis without proper validation and clinical oversight.
+
+Always consult with qualified healthcare professionals for medical diagnosis and treatment decisions.
+"""
+
+# Class Labels
+CLASS_LABELS = {
+    0: 'DR',      # Diabetic Retinopathy
+    1: 'NoDR'     # No Diabetic Retinopathy
+}
+
+# Confidence Thresholds
+CONFIDENCE_THRESHOLDS = {
+    'high_confidence': 0.9,    # High confidence threshold
+    'medium_confidence': 0.7,  # Medium confidence threshold
+    'low_confidence': 0.5      # Low confidence threshold
+}
+
+# Logging Configuration
+LOGGING_CONFIG = {
+    'log_level': 'INFO',
+    'log_file': 'dr_detection.log',
+    'log_format': '%(asctime)s - %(levelname)s - %(message)s'
+}
+
+# Performance Configuration
+PERFORMANCE_CONFIG = {
+    'batch_size': 1,           # Batch size for processing
+    'num_workers': 0,          # Number of worker processes
+    'pin_memory': False,       # Pin memory for faster data transfer
+    'prefetch_factor': 2       # Prefetch factor for data loading
+}
+
+def get_model_path():
+    """Get the model path, checking if it exists."""
+    model_path = MODEL_CONFIG['model_path']
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Model file not found: {model_path}")
+    return model_path
+
+def get_device():
+    """Get the device to use for inference."""
+    device = MODEL_CONFIG['device']
+    if device == 'cuda' and not torch.cuda.is_available():
+        print("⚠️  CUDA requested but not available. Falling back to CPU.")
+        return 'cpu'
+    return device
+
+def get_output_directory():
+    """Get the output directory, creating it if it doesn't exist."""
+    output_dir = OUTPUT_CONFIG['output_dir']
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+def get_batch_output_directory():
+    """Get the batch output directory, creating it if it doesn't exist."""
+    batch_dir = OUTPUT_CONFIG['batch_output_dir']
+    os.makedirs(batch_dir, exist_ok=True)
+    return batch_dir
+
+# Import torch here to avoid circular imports
+try:
+    import torch
+except ImportError:
+    print("⚠️  PyTorch not available. Some functions may not work.")
+    torch = None

index.html

@@ -0,0 +1,264 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Diabetic Retinopathy Detection</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+        
+        .header {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 40px;
+            text-align: center;
+        }
+        
+        .header h1 {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+            font-weight: 300;
+        }
+        
+        .header p {
+            font-size: 1.1rem;
+            opacity: 0.9;
+        }
+        
+        .content {
+            padding: 40px;
+        }
+        
+        .demo-section {
+            background: #f8f9fa;
+            border-radius: 15px;
+            padding: 30px;
+            margin-bottom: 30px;
+            text-align: center;
+        }
+        
+        .demo-section h2 {
+            color: #333;
+            margin-bottom: 20px;
+            font-size: 1.8rem;
+        }
+        
+        .demo-section p {
+            color: #666;
+            margin-bottom: 25px;
+            font-size: 1.1rem;
+            line-height: 1.6;
+        }
+        
+        .demo-button {
+            display: inline-block;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 15px 30px;
+            text-decoration: none;
+            border-radius: 50px;
+            font-size: 1.1rem;
+            font-weight: 500;
+            transition: all 0.3s ease;
+            box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+        }
+        
+        .demo-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(102, 126, 234, 0.6);
+        }
+        
+        .features {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 30px;
+            margin-bottom: 40px;
+        }
+        
+        .feature-card {
+            background: white;
+            border-radius: 15px;
+            padding: 30px;
+            text-align: center;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+            transition: transform 0.3s ease;
+        }
+        
+        .feature-card:hover {
+            transform: translateY(-5px);
+        }
+        
+        .feature-icon {
+            font-size: 3rem;
+            margin-bottom: 20px;
+        }
+        
+        .feature-card h3 {
+            color: #333;
+            margin-bottom: 15px;
+            font-size: 1.4rem;
+        }
+        
+        .feature-card p {
+            color: #666;
+            line-height: 1.6;
+        }
+        
+        .github-section {
+            background: #24292e;
+            color: white;
+            padding: 40px;
+            text-align: center;
+            border-radius: 15px;
+        }
+        
+        .github-section h2 {
+            margin-bottom: 20px;
+            font-size: 1.8rem;
+        }
+        
+        .github-section p {
+            margin-bottom: 25px;
+            opacity: 0.9;
+            line-height: 1.6;
+        }
+        
+        .github-button {
+            display: inline-block;
+            background: #28a745;
+            color: white;
+            padding: 15px 30px;
+            text-decoration: none;
+            border-radius: 50px;
+            font-size: 1.1rem;
+            font-weight: 500;
+            transition: all 0.3s ease;
+            margin: 0 10px;
+        }
+        
+        .github-button:hover {
+            background: #218838;
+            transform: translateY(-2px);
+        }
+        
+        .medical-disclaimer {
+            background: #fff3cd;
+            border: 1px solid #ffeaa7;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 30px 0;
+            text-align: center;
+        }
+        
+        .medical-disclaimer h3 {
+            color: #856404;
+            margin-bottom: 10px;
+        }
+        
+        .medical-disclaimer p {
+            color: #856404;
+            line-height: 1.6;
+        }
+        
+        @media (max-width: 768px) {
+            .header h1 {
+                font-size: 2rem;
+            }
+            
+            .content {
+                padding: 20px;
+            }
+            
+            .features {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🔬 AI Diabetic Retinopathy Detection</h1>
+            <p>Advanced deep learning system for early detection of diabetic retinopathy from OCT images</p>
+        </div>
+        
+        <div class="content">
+            <div class="demo-section">
+                <h2>🚀 Live Demo</h2>
+                <p>Experience our AI-powered diabetic retinopathy detection system in action. Upload OCT images and get instant analysis with Grad-CAM visualizations.</p>
+                <a href="http://192.168.18.28:7860" class="demo-button" target="_blank">Launch Live Demo</a>
+            </div>
+            
+            <div class="features">
+                <div class="feature-card">
+                    <div class="feature-icon">🤖</div>
+                    <h3>AI-Powered Analysis</h3>
+                    <p>State-of-the-art ResNet-50 model trained on extensive OCT image datasets for accurate diabetic retinopathy detection.</p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">🔥</div>
+                    <h3>Grad-CAM Visualization</h3>
+                    <p>Advanced explainable AI technology that highlights the specific areas of OCT images that influence the AI's diagnosis.</p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">📊</div>
+                    <h3>Confidence Scoring</h3>
+                    <p>Get detailed confidence scores and probability assessments for each diagnosis, ensuring reliable results.</p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">💾</div>
+                    <h3>Result Storage</h3>
+                    <p>Automatically save analyzed images with timestamps, predictions, and confidence scores for future reference.</p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">🔄</div>
+                    <h3>Batch Processing</h3>
+                    <p>Process multiple OCT images simultaneously with comprehensive CSV reporting and batch analysis capabilities.</p>
+                </div>
+                
+                <div class="feature-card">
+                    <div class="feature-icon">🌐</div>
+                    <h3>Web Interface</h3>
+                    <p>User-friendly Gradio web interface accessible from any device with a modern web browser.</p>
+                </div>
+            </div>
+            
+            <div class="medical-disclaimer">
+                <h3>⚠️ Medical Disclaimer</h3>
+                <p>This tool is for research and educational purposes only. It should not be used for actual medical diagnosis without proper validation and clinical oversight. Always consult with qualified healthcare professionals for medical diagnosis and treatment decisions.</p>
+            </div>
+            
+            <div class="github-section">
+                <h2>📚 Open Source Project</h2>
+                <p>This project is completely open source and available on GitHub. Contribute, fork, or star the repository to support the development of AI-powered medical imaging tools.</p>
+                <a href="https://github.com/yourusername/Deep_Learning_for_Ophthalmologist" class="github-button" target="_blank">View on GitHub</a>
+                <a href="https://github.com/yourusername/Deep_Learning_for_Ophthalmologist/fork" class="github-button" target="_blank">Fork Project</a>
+            </div>
+        </div>
+    </div>
+</body>
+</html>

requirements.txt

@@ -1,7 +1,8 @@
-torch
-torchvision
-pillow
-numpy
-gradio
-git+https://github.com/jacobgil/pytorch-grad-cam.git
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+numpy>=1.26.0
+gradio>=4.0.0
+pytorch-grad-cam
+opencv-python>=4.8.0
 

run_app.bat

@@ -0,0 +1,43 @@
+@echo off
+echo ========================================
+echo  Diabetic Retinopathy Detection App
+echo ========================================
+echo.
+
+REM Check if Python is available
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Python is not installed or not in PATH
+    echo Please install Python 3.8+ and try again
+    pause
+    exit /b 1
+)
+
+REM Check if virtual environment exists
+if exist "venv\Scripts\activate.bat" (
+    echo Activating virtual environment...
+    call venv\Scripts\activate.bat
+) else (
+    echo No virtual environment found. Using system Python.
+    echo.
+)
+
+REM Check if model file exists
+if not exist "resnet50_dr_classifier.pth" (
+    echo ERROR: Model file 'resnet50_dr_classifier.pth' not found!
+    echo Please ensure the model file is in the current directory.
+    pause
+    exit /b 1
+)
+
+echo Starting the application...
+echo.
+echo The app will open in your web browser at: http://127.0.0.1:7860
+echo.
+echo Press Ctrl+C to stop the application
+echo.
+
+REM Start the application
+python app.py
+
+pause

run_app.ps1

@@ -0,0 +1,175 @@
+#!/usr/bin/env pwsh
+<#
+.SYNOPSIS
+    Launcher script for Diabetic Retinopathy Detection App
+    
+.DESCRIPTION
+    This script checks prerequisites and launches the AI-powered
+    diabetic retinopathy detection application.
+    
+.PARAMETER Setup
+    Run setup instead of launching the app
+    
+.PARAMETER Test
+    Run tests instead of launching the app
+    
+.PARAMETER Batch
+    Launch batch processing instead of the web app
+#>
+
+param(
+    [switch]$Setup,
+    [switch]$Test,
+    [switch]$Batch
+)
+
+# Set console title
+$Host.UI.RawUI.WindowTitle = "Diabetic Retinopathy Detection App"
+
+# Function to write colored output
+function Write-ColorOutput {
+    param(
+        [string]$Message,
+        [string]$Color = "White"
+    )
+    Write-Host $Message -ForegroundColor $Color
+}
+
+# Function to check Python installation
+function Test-PythonInstallation {
+    try {
+        $pythonVersion = python --version 2>&1
+        if ($LASTEXITCODE -eq 0) {
+            Write-ColorOutput "✅ Python found: $pythonVersion" "Green"
+            return $true
+        }
+    }
+    catch {
+        Write-ColorOutput "❌ Python not found in PATH" "Red"
+        return $false
+    }
+    return $false
+}
+
+# Function to check model file
+function Test-ModelFile {
+    $modelPath = "resnet50_dr_classifier.pth"
+    if (Test-Path $modelPath) {
+        $fileSize = (Get-Item $modelPath).Length / 1MB
+        Write-ColorOutput "✅ Model file found: $modelPath ($([math]::Round($fileSize, 2)) MB)" "Green"
+        return $true
+    }
+    else {
+        Write-ColorOutput "❌ Model file not found: $modelPath" "Red"
+        return $false
+    }
+}
+
+# Function to activate virtual environment
+function Activate-VirtualEnvironment {
+    $venvPath = "venv\Scripts\Activate.ps1"
+    if (Test-Path $venvPath) {
+        Write-ColorOutput "🔄 Activating virtual environment..." "Yellow"
+        & $venvPath
+        return $true
+    }
+    else {
+        Write-ColorOutput "ℹ️  No virtual environment found. Using system Python." "Cyan"
+        return $false
+    }
+}
+
+# Function to run setup
+function Start-Setup {
+    Write-ColorOutput "🚀 Running setup..." "Yellow"
+    if (Test-PythonInstallation) {
+        python setup.py
+    }
+    else {
+        Write-ColorOutput "❌ Cannot run setup without Python" "Red"
+    }
+}
+
+# Function to run tests
+function Start-Tests {
+    Write-ColorOutput "🧪 Running tests..." "Yellow"
+    if (Test-PythonInstallation) {
+        python test_model.py
+    }
+    else {
+        Write-ColorOutput "❌ Cannot run tests without Python" "Red"
+    }
+}
+
+# Function to start batch processing
+function Start-BatchProcessing {
+    Write-ColorOutput "🔄 Starting batch processing..." "Yellow"
+    if (Test-PythonInstallation) {
+        python batch_process.py
+    }
+    else {
+        Write-ColorOutput "❌ Cannot start batch processing without Python" "Red"
+    }
+}
+
+# Function to start web app
+function Start-WebApp {
+    Write-ColorOutput "🌐 Starting web application..." "Yellow"
+    if (Test-PythonInstallation) {
+        python app.py
+    }
+    else {
+        Write-ColorOutput "❌ Cannot start web app without Python" "Red"
+    }
+}
+
+# Main execution
+Clear-Host
+Write-ColorOutput "========================================" "Cyan"
+Write-ColorOutput "  Diabetic Retinopathy Detection App" "Cyan"
+Write-ColorOutput "========================================" "Cyan"
+Write-Host ""
+
+# Check Python installation
+if (-not (Test-PythonInstallation)) {
+    Write-ColorOutput "❌ Python is not installed or not in PATH" "Red"
+    Write-ColorOutput "Please install Python 3.8+ and try again" "Yellow"
+    Read-Host "Press Enter to exit"
+    exit 1
+}
+
+# Check model file
+if (-not (Test-ModelFile)) {
+    Write-ColorOutput "❌ Model file is missing!" "Red"
+    Write-ColorOutput "Please ensure the model file is in the current directory." "Yellow"
+    Read-Host "Press Enter to exit"
+    exit 1
+}
+
+# Activate virtual environment if available
+Activate-VirtualEnvironment
+
+Write-Host ""
+
+# Determine what to run based on parameters
+if ($Setup) {
+    Start-Setup
+}
+elseif ($Test) {
+    Start-Tests
+}
+elseif ($Batch) {
+    Start-BatchProcessing
+}
+else {
+    # Default: start web app
+    Write-ColorOutput "🎯 Starting web application..." "Green"
+    Write-ColorOutput "The app will open in your web browser at: http://127.0.0.1:7860" "Cyan"
+    Write-ColorOutput "Press Ctrl+C to stop the application" "Yellow"
+    Write-Host ""
+    
+    Start-WebApp
+}
+
+Write-Host ""
+Read-Host "Press Enter to exit"

setup.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Setup script for Diabetic Retinopathy Detection App
+Helps with installation and environment setup
+"""
+
+import subprocess
+import sys
+import os
+import platform
+
+def check_python_version():
+    """Check if Python version is compatible."""
+    print("🐍 Checking Python version...")
+    version = sys.version_info
+    if version.major < 3 or (version.major == 3 and version.minor < 8):
+        print(f"❌ Python {version.major}.{version.minor} detected. Python 3.8+ is required.")
+        return False
+    print(f"✅ Python {version.major}.{version.minor}.{version.micro} - Compatible!")
+    return True
+
+def check_pip():
+    """Check if pip is available."""
+    print("📦 Checking pip...")
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "--version"], 
+                      check=True, capture_output=True)
+        print("✅ pip is available!")
+        return True
+    except subprocess.CalledProcessError:
+        print("❌ pip not found. Please install pip first.")
+        return False
+
+def upgrade_pip():
+    """Upgrade pip to latest version."""
+    print("🔄 Upgrading pip...")
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "install", "--upgrade", "pip"], 
+                      check=True)
+        print("✅ pip upgraded successfully!")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"⚠️  Warning: Could not upgrade pip: {e}")
+        return False
+
+def install_requirements():
+    """Install required packages from requirements.txt."""
+    print("📥 Installing required packages...")
+    
+    if not os.path.exists("requirements.txt"):
+        print("❌ requirements.txt not found!")
+        return False
+    
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], 
+                      check=True)
+        print("✅ All packages installed successfully!")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error installing packages: {e}")
+        return False
+
+def check_model_file():
+    """Check if the model file exists."""
+    print("🤖 Checking model file...")
+    if os.path.exists("resnet50_dr_classifier.pth"):
+        file_size = os.path.getsize("resnet50_dr_classifier.pth") / (1024 * 1024)
+        print(f"✅ Model file found: resnet50_dr_classifier.pth ({file_size:.2f} MB)")
+        return True
+    else:
+        print("❌ Model file 'resnet50_dr_classifier.pth' not found!")
+        print("   Please ensure the model file is in the current directory.")
+        return False
+
+def create_directories():
+    """Create necessary directories."""
+    print("📁 Creating directories...")
+    
+    directories = ["saved_predictions", "batch_results"]
+    
+    for directory in directories:
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+            print(f"   ✅ Created: {directory}/")
+        else:
+            print(f"   📁 Exists: {directory}/")
+
+def test_imports():
+    """Test if all required packages can be imported."""
+    print("🧪 Testing imports...")
+    
+    required_packages = [
+        ("torch", "PyTorch"),
+        ("torchvision", "TorchVision"),
+        ("PIL", "Pillow"),
+        ("numpy", "NumPy"),
+        ("gradio", "Gradio"),
+        ("pytorch_grad_cam", "PyTorch Grad-CAM")
+    ]
+    
+    all_good = True
+    
+    for package, name in required_packages:
+        try:
+            if package == "PIL":
+                import PIL
+                print(f"   ✅ {name} imported successfully")
+            else:
+                __import__(package)
+                print(f"   ✅ {name} imported successfully")
+        except ImportError:
+            print(f"   ❌ {name} import failed")
+            all_good = False
+    
+    return all_good
+
+def run_test():
+    """Run the test script to verify everything works."""
+    print("🧪 Running model test...")
+    try:
+        result = subprocess.run([sys.executable, "test_model.py"], 
+                              capture_output=True, text=True)
+        if result.returncode == 0:
+            print("✅ Model test passed!")
+            return True
+        else:
+            print("❌ Model test failed!")
+            print("Output:", result.stdout)
+            print("Errors:", result.stderr)
+            return False
+    except Exception as e:
+        print(f"❌ Could not run test: {e}")
+        return False
+
+def main():
+    """Main setup function."""
+    print("🚀 Diabetic Retinopathy Detection - Setup")
+    print("=" * 50)
+    
+    # Check system info
+    print(f"💻 System: {platform.system()} {platform.release()}")
+    print(f"🐍 Python: {sys.executable}")
+    print()
+    
+    # Step 1: Check Python version
+    if not check_python_version():
+        return False
+    
+    # Step 2: Check pip
+    if not check_pip():
+        return False
+    
+    # Step 3: Upgrade pip
+    upgrade_pip()
+    
+    # Step 4: Install requirements
+    if not install_requirements():
+        return False
+    
+    # Step 5: Check model file
+    if not check_model_file():
+        return False
+    
+    # Step 6: Create directories
+    create_directories()
+    
+    # Step 7: Test imports
+    if not test_imports():
+        print("❌ Some packages failed to import. Please check the installation.")
+        return False
+    
+    # Step 8: Run test
+    if not run_test():
+        print("❌ Model test failed. Please check the model file and installation.")
+        return False
+    
+    print("\n🎉 Setup completed successfully!")
+    print("\n📋 Next steps:")
+    print("   1. Run the web app: python app.py")
+    print("   2. Open your browser to the URL shown in the terminal")
+    print("   3. Upload OCT images for analysis")
+    print("\n🔄 For batch processing:")
+    print("   python batch_process.py")
+    
+    return True
+
+if __name__ == "__main__":
+    success = main()
+    if not success:
+        print("\n❌ Setup failed. Please check the error messages above.")
+        sys.exit(1)

test_model.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the diabetic retinopathy detection model can be loaded correctly.
+Run this before starting the main app to check for any issues.
+"""
+
+import torch
+import torch.nn as nn
+from torchvision import models
+import os
+
+def test_model_loading():
+    """Test if the model can be loaded successfully."""
+    print("🔍 Testing model loading...")
+    
+    try:
+        # Check if model file exists
+        model_path = "resnet50_dr_classifier.pth"
+        if not os.path.exists(model_path):
+            print(f"❌ Error: Model file '{model_path}' not found!")
+            print("   Please ensure the model file is in the current directory.")
+            return False
+        
+        print(f"✅ Model file found: {model_path}")
+        
+        # Check file size
+        file_size = os.path.getsize(model_path) / (1024 * 1024)  # MB
+        print(f"📁 Model file size: {file_size:.2f} MB")
+        
+        # Try to load the model
+        device = torch.device("cpu")
+        print("🔄 Loading model...")
+        
+        model = models.resnet50(weights=None)
+        model.fc = nn.Linear(model.fc.in_features, 2)
+        
+        # Load state dict
+        state_dict = torch.load(model_path, map_location=device)
+        model.load_state_dict(state_dict)
+        model.to(device)
+        model.eval()
+        
+        print("✅ Model loaded successfully!")
+        
+        # Test with dummy input
+        print("🧪 Testing with dummy input...")
+        dummy_input = torch.randn(1, 3, 224, 224)
+        
+        with torch.no_grad():
+            output = model(dummy_input)
+            probs = torch.nn.functional.softmax(output, dim=1)
+            pred = torch.argmax(probs, dim=1).item()
+            confidence = probs[0][pred].item()
+        
+        print(f"✅ Model inference successful!")
+        print(f"   Prediction: {'DR' if pred == 0 else 'NoDR'}")
+        print(f"   Confidence: {confidence:.4f}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error loading model: {str(e)}")
+        return False
+
+def test_dependencies():
+    """Test if required packages are available."""
+    print("\n🔍 Testing dependencies...")
+    
+    try:
+        import gradio
+        print("✅ Gradio imported successfully")
+    except ImportError:
+        print("❌ Gradio not found. Install with: pip install gradio")
+        return False
+    
+    try:
+        import PIL
+        print("✅ PIL/Pillow imported successfully")
+    except ImportError:
+        print("❌ PIL/Pillow not found. Install with: pip install pillow")
+        return False
+    
+    try:
+        import numpy
+        print("✅ NumPy imported successfully")
+    except ImportError:
+        print("❌ NumPy not found. Install with: pip install numpy")
+        return False
+    
+    try:
+        from pytorch_grad_cam import GradCAM
+        print("✅ PyTorch Grad-CAM imported successfully")
+    except ImportError:
+        print("❌ PyTorch Grad-CAM not found. Install with: pip install pytorch-grad-cam")
+        return False
+    
+    return True
+
+def main():
+    """Main test function."""
+    print("🚀 Diabetic Retinopathy Detection - Model Test")
+    print("=" * 50)
+    
+    # Test dependencies
+    deps_ok = test_dependencies()
+    
+    if not deps_ok:
+        print("\n❌ Dependency test failed. Please install missing packages.")
+        return
+    
+    # Test model loading
+    model_ok = test_model_loading()
+    
+    print("\n" + "=" * 50)
+    if model_ok:
+        print("🎉 All tests passed! The app should work correctly.")
+        print("   You can now run: python app.py")
+    else:
+        print("❌ Model test failed. Please check the error messages above.")
+        print("   Make sure the model file is correct and all dependencies are installed.")
+
+if __name__ == "__main__":
+    main()