Upload 20960 files

.dockerignore

@@ -0,0 +1,57 @@
+# Git
+.git
+.gitignore
+
+# Documentation
+*.md
+!HF_SPACES_README.md
+!DEPLOYMENT_README.md
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+.venv
+venv/
+.env
+
+# Jupyter Notebooks
+*.ipynb
+notebooks/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Test files
+tests/
+test_*.py
+*_test.py
+
+# Development files
+uselessfiles/
+*.bak
+*.tmp
+
+# Large data files (keep only necessary ones)
+data/raw/
+data/train/
+data/test/
+data/val/
+
+# Keep only essential outputs
+outputs/logs/
+outputs/heatmaps/

.gitattributes

@@ -0,0 +1,5 @@
+*.pth filter=lfs diff=lfs merge=lfs -text
+crop_disease_v3_model.pth filter=lfs diff=lfs merge=lfs -text
+data/processed/train/Pepper__bell___healthy/42f083e2-272d-4f83-ad9a-573ee90e50ec___Screen[[:space:]]Shot[[:space:]]2015-05-06[[:space:]]at[[:space:]]4.01.13[[:space:]]PM.png filter=lfs diff=lfs merge=lfs -text
+outputs/comprehensive_training_analysis.png filter=lfs diff=lfs merge=lfs -text
+outputs/training_curves.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,80 @@
+# 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
+
+# PyTorch models (keep only the main model)
+models/*.pth
+!models/crop_disease_v3_model.pth
+!models/crop_disease_v2_model.pth
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Environment
+.env
+.venv
+venv/
+ENV/
+env/
+
+# Logs
+logs/
+*.log
+
+# Temporary files
+temp/
+tmp/
+*.tmp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Data (keep structure but not large datasets)
+data/raw/*
+!data/raw/README.txt
+data/train/*
+!data/train/README.txt
+data/val/*
+!data/val/README.txt
+data/test/*
+!data/test/README.txt
+
+# Outputs (keep structure)
+outputs/*.png
+outputs/*.jpg
+outputs/*.json
+outputs/heatmaps/*
+!outputs/heatmaps/README.txt
+outputs/logs/*
+!outputs/logs/README.txt
+
+# Jupyter notebook checkpoints
+.ipynb_checkpoints/
+
+# Testing artifacts
+.pytest_cache/
+.coverage
+htmlcov/

Dockerfile

@@ -0,0 +1,36 @@
+# Use Python 3.10 slim image for better compatibility with HF Spaces
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire project
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p models knowledge_base src data outputs
+
+# Expose port 7860 for Hugging Face Spaces
+EXPOSE 7860
+
+# Set environment variable for Hugging Face Spaces
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# Run the FastAPI application with Uvicorn on port 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,539 @@
+---
+title: Crop Disease Detection AI
+emoji: 🌱
+colorFrom: green
+colorTo: yellow
+sdk: docker
+app_port: 7860
+python_version: 3.10
+suggested_hardware: cpu-basic
+suggested_storage: small
+license: apache-2.0
+tags:
+  - computer-vision
+  - agriculture
+  - disease-detection
+  - fastapi
+  - pytorch
+  - gradcam
+  - ai
+  - deep-learning
+  - crop-monitoring
+---
+
+# Crop Disease Detection AI 🌱🔍
+
+> **Advanced Computer Vision System for Agricultural Disease Detection**
+
+This folder contains a state-of-the-art PyTorch-based deep learning system for detecting diseases in crop images using ResNet50 architecture with comprehensive visual explanations and real-time risk assessment.
+
+## 🚀 Key Features
+
+- **Multi-Crop Disease Detection**: Supports Pepper (Bell), Potato, and Tomato crops
+- **15 Disease Classes**: Comprehensive coverage of common agricultural diseases
+- **Visual AI Explanations**: Grad-CAM and LIME explanations for prediction transparency
+- **FastAPI Backend**: High-performance RESTful API with real-time predictions
+- **High Accuracy**: 90.09% test accuracy on validation dataset (v3.0 model)
+- **Risk Assessment**: Automated severity scoring and treatment recommendations
+- **Memory Optimized**: Multiple model variants for different deployment scenarios
+- **Production Ready**: Docker support, comprehensive testing, and monitoring
+
+## 🧠 AI Model Architecture
+
+### Core Model: Enhanced ResNet50
+- **Base Architecture**: Pre-trained ResNet50 on ImageNet with custom classifier head
+- **Fine-tuning**: Specialized transfer learning for agricultural disease detection
+- **Input Specifications**: 224x224 RGB images, normalized with ImageNet statistics
+- **Output**: 15-class disease classification with confidence scores
+- **Model Depth**: 50 layers with residual connections for stable training
+
+### Advanced Architecture Details
+```
+ResNet50 Feature Extractor (frozen/unfrozen)
+├── Custom Classifier Head:
+│   ├── Dropout(0.5)
+│   ├── Linear(2048 → 1024) + BatchNorm + ReLU
+│   ├── Dropout(0.3)
+│   ├── Linear(1024 → 512) + BatchNorm + ReLU
+│   ├── Dropout(0.2)
+│   └── Linear(512 → 15) [Output Layer]
+```
+
+### Model Versions & Performance
+- **v3.0** (Current): Retrained ResNet50 - 90.09% test accuracy
+- **v2.0**: Enhanced feature extraction - 87.5% accuracy
+- **v1.0**: Initial baseline model - 85.2% accuracy
+- **Lite Variants**: Memory-optimized models for edge deployment
+
+## 📊 Supported Disease Classes
+
+### Pepper (Bell) - 2 Classes
+1. **Bacterial Spot** - Xanthomonas infection
+2. **Healthy** - No disease detected
+
+### Potato - 3 Classes
+1. **Early Blight** - Alternaria solani
+2. **Late Blight** - Phytophthora infestans
+3. **Healthy** - No disease detected
+
+### Tomato - 10 Classes
+1. **Bacterial Spot** - Xanthomonas perforans
+2. **Early Blight** - Alternaria solani
+3. **Late Blight** - Phytophthora infestans
+4. **Leaf Mold** - Passalora fulva
+5. **Septoria Leaf Spot** - Septoria lycopersici
+6. **Spider Mites (Two-spotted)** - Tetranychus urticae
+7. **Target Spot** - Corynespora cassiicola
+8. **Yellow Leaf Curl Virus** - Begomovirus
+9. **Mosaic Virus** - Tobacco mosaic virus
+10. **Healthy** - No disease detected
+
+## 🔧 Tech Stack
+
+### Core AI/ML
+- **Deep Learning**: PyTorch 2.1.0, TorchVision 0.16.0
+- **Computer Vision**: OpenCV 4.8.1, PIL (Pillow) 10.0.1
+- **Model Architecture**: ResNet50 with custom classification head
+
+### API & Backend
+- **Web Framework**: FastAPI 0.104.1 with async support
+- **API Documentation**: Automatic OpenAPI/Swagger generation
+- **CORS Support**: Configurable cross-origin resource sharing
+
+### AI Explainability
+- **Grad-CAM**: Gradient-weighted Class Activation Mapping
+- **LIME**: Local Interpretable Model-agnostic Explanations
+- **Custom Visualization**: matplotlib, seaborn for result plotting
+
+### Data Processing
+- **Numerical**: NumPy 1.24.3, Pandas 2.0.3
+- **Image Processing**: Albumentations for augmentation
+- **Serialization**: JSON, Pickle for model and data handling
+
+## 📁 Project Structure
+
+```
+diseases_detection_ai/
+├── main.py                 # FastAPI application entry point (477 lines)
+├── requirements.txt        # Python dependencies and versions
+├── README.md              # Comprehensive documentation (405 lines)
+├── api/                   # API implementations
+│   ├── main.py           # Main API server with full features
+│   ├── main_optimized.py # Memory-optimized API variant
+│   ├── Dockerfile        # Container configuration for deployment
+│   ├── requirements.txt  # API-specific dependencies
+│   └── __init__.py       # Package initialization
+├── src/                   # Core AI modules (10 files)
+│   ├── model.py          # ResNet50 model architecture (193 lines)
+│   ├── model_lite.py     # Lightweight model variants for edge deployment
+│   ├── explain.py        # Grad-CAM visual explanation system
+│   ├── explain_lite.py   # Optimized explanation for mobile
+│   ├── explain_new.py    # Latest explanation implementations
+│   ├── dataset.py        # Data loading, preprocessing, and augmentation
+│   ├── train.py          # Complete model training pipeline
+│   ├── evaluate.py       # Model evaluation and metrics calculation
+│   ├── risk_level.py     # Disease severity assessment algorithms
+│   └── __init__.py       # Package initialization
+├── models/               # Trained model checkpoints
+│   ├── crop_disease_v3_model.pth  # Latest model (v3.0) - Primary
+│   ├── crop_disease_v2_model.pth  # Previous stable version
+│   ├── crop_disese_v0.pth        # Initial baseline model
+│   ├── README.txt        # Model information and usage notes
+│   └── .gitattributes    # Git LFS configuration for large files
+├── knowledge_base/       # Disease information database
+│   └── disease_info.json # Comprehensive disease database (552 lines)
+├── data/                 # Training and test datasets
+│   ├── raw/             # Original dataset images
+│   └── processed/       # Preprocessed and augmented data
+├── notebooks/            # Jupyter analysis and research notebooks
+├── outputs/              # Generated visualizations and results
+├── tests/               # Comprehensive testing suite
+│   ├── test_model.py    # Model functionality tests
+│   ├── test_api.py      # API endpoint testing
+│   └── test_explain.py  # Explanation system tests
+└── uselessfiles/        # Development artifacts and experimental code
+```
+
+## 🛠️ Setup Instructions
+
+### System Requirements
+- **Python**: 3.8+ (tested with 3.9, 3.10, 3.11)
+- **GPU**: CUDA-compatible GPU recommended (NVIDIA RTX series optimal)
+- **Memory**: 8GB+ RAM (16GB recommended for training)
+- **Storage**: 2GB+ free space for models and datasets
+- **OS**: Windows 10/11, Linux (Ubuntu 18.04+), macOS 10.15+
+
+### Installation Steps
+
+1. **Environment Setup**:
+   ```powershell
+   # Navigate to project directory
+   cd diseases_detection_ai
+   
+   # Create isolated virtual environment
+   python -m venv disease_detection_env
+   disease_detection_env\Scripts\activate  # Windows
+   # source disease_detection_env/bin/activate  # Linux/Mac
+   ```
+
+2. **Install Dependencies**:
+   ```powershell
+   # Install all required packages
+   pip install -r requirements.txt
+   
+   # Verify PyTorch installation with CUDA support
+   python -c "import torch; print(f'PyTorch: {torch.__version__}, CUDA: {torch.cuda.is_available()}')"
+   ```
+
+3. **Model Preparation**:
+   ```powershell
+   # Models are included in the repository
+   # Verify model files exist
+   dir models\*.pth
+   ```
+
+4. **Test Installation**:
+   ```powershell
+   # Quick functionality test
+   python -c "from src.model import CropDiseaseResNet50; print('Installation successful!')"
+   ```
+
+### Quick Start Guide
+
+1. **Launch API Server**:
+   ```powershell
+   # Start FastAPI development server
+   python main.py
+   
+   # Server will start on http://localhost:8000
+   # API documentation available at http://localhost:8000/docs
+   ```
+
+2. **Test Disease Detection**:
+   ```powershell
+   # Using PowerShell with Invoke-RestMethod
+   $response = Invoke-RestMethod -Uri "http://localhost:8000/predict" -Method Post -InFile "test_image.jpg" -ContentType "multipart/form-data"
+   $response | ConvertTo-Json
+   ```
+
+3. **Alternative API Testing**:
+   ```powershell
+   # Using curl (if available)
+   curl -X POST "http://localhost:8000/predict" -H "accept: application/json" -H "Content-Type: multipart/form-data" -F "file=@test_crop_image.jpg"
+   ```
+
+## 🔬 Model Training & Evaluation
+
+### Training Dataset Statistics
+- **Total Training Samples**: 14,440 high-quality crop images
+- **Validation Samples**: 3,089 images for model validation
+- **Test Samples**: 3,109 images for final evaluation
+- **Image Resolution**: Variable (224x224 after preprocessing)
+- **Data Augmentation**: Rotation, flip, brightness, contrast adjustments
+- **Last Training Date**: September 9, 2025
+
+### Training Configuration
+```python
+# Training hyperparameters for v3.0 model
+{
+    "epochs": 50,
+    "batch_size": 32,
+    "learning_rate": 0.001,
+    "optimizer": "Adam",
+    "scheduler": "ReduceLROnPlateau",
+    "early_stopping": "patience=7",
+    "data_augmentation": True
+}
+```
+
+### Model Performance Metrics
+- **Test Accuracy**: 90.09% (v3.0)
+- **Validation Accuracy**: 90.06% (v3.0)
+- **Model Size**: ~100MB (full model), ~25MB (lite variant)
+- **Average Inference Time**: <200ms per image on GPU, <800ms on CPU
+- **Memory Usage**: ~2GB GPU memory (full model), ~500MB (lite model)
+
+### Training Commands
+```powershell
+# Train new model from scratch
+python src\train.py --epochs 50 --batch_size 32 --lr 0.001 --save_best
+
+# Resume training from checkpoint
+python src\train.py --resume models\crop_disease_v2_model.pth --epochs 20
+
+# Evaluate existing model
+python src\evaluate.py --model_path models\crop_disease_v3_model.pth --test_data data\test
+
+# Generate visual explanations
+python src\explain.py --image_path test_images\tomato_blight.jpg --output_dir outputs\
+```
+
+## 🌐 API Documentation
+
+### Core Endpoints
+
+#### Disease Prediction
+```http
+POST /predict
+Content-Type: multipart/form-data
+Parameters:
+  - file: image file (JPG, PNG, JPEG)
+  - explain: boolean (optional, default: true)
+  - confidence_threshold: float (optional, default: 0.7)
+
+Response Example:
+{
+  "disease": "Tomato___Early_blight",
+  "disease_display": "Early Blight",
+  "crop": "Tomato",
+  "confidence": 0.9456,
+  "severity": "High",
+  "risk_level": 8.5,
+  "symptoms": ["Brown spots with concentric rings", "Yellowing leaves"],
+  "treatment": {
+    "immediate": ["Remove affected leaves", "Apply fungicide"],
+    "preventive": ["Improve air circulation", "Avoid overhead watering"]
+  },
+  "explanation": {
+    "gradcam_regions": "base64_image_data",
+    "attention_map": "visualization_data"
+  },
+  "processing_time": 0.184
+}
+```
+
+#### Batch Prediction
+```http
+POST /predict/batch
+Content-Type: multipart/form-data
+Parameters:
+  - files: multiple image files
+  
+Response: Array of prediction objects
+```
+
+#### Health Check
+```http
+GET /health
+Response: {
+  "status": "healthy",
+  "model_loaded": true,
+  "version": "3.0",
+  "gpu_available": true,
+  "memory_usage": "1.2GB"
+}
+```
+
+#### Model Information
+```http
+GET /model/info
+Response: {
+  "version": "3.0",
+  "classes": 15,
+  "accuracy": 0.9009,
+  "training_date": "2025-09-09",
+  "supported_crops": ["Pepper (Bell)", "Potato", "Tomato"]
+}
+```
+
+## 🔍 Visual Explanation System
+
+### Grad-CAM Implementation
+Gradient-weighted Class Activation Mapping highlights the most important regions:
+
+```python
+from src.explain import CropDiseaseExplainer
+
+# Initialize explainer with trained model
+explainer = CropDiseaseExplainer(
+    model_path="models/crop_disease_v3_model.pth",
+    device="cuda" if torch.cuda.is_available() else "cpu"
+)
+
+# Generate explanation for image
+explanation = explainer.explain_prediction(
+    image_path="test_image.jpg",
+    save_path="outputs/explanation.jpg",
+    alpha=0.4  # Overlay transparency
+)
+```
+
+### LIME Integration
+Local Interpretable Model-agnostic Explanations for segment-based analysis:
+
+```python
+# Generate LIME explanation
+lime_explanation = explainer.lime_explanation(
+    image_path="test_image.jpg",
+    num_samples=1000,
+    num_features=100
+)
+```
+
+## 🧪 Testing & Quality Assurance
+
+### Automated Testing Suite
+```powershell
+# Run complete test suite
+python -m pytest tests\ -v --cov=src --cov-report=html
+
+# Run specific test categories
+python -m pytest tests\test_model.py -v      # Model functionality
+python -m pytest tests\test_api.py -v       # API endpoints
+python -m pytest tests\test_explain.py -v   # Explanation system
+```
+
+### Manual Testing
+```powershell
+# Test model loading and inference
+python tests\manual_test_model.py
+
+# Test API with sample images
+python tests\manual_test_api.py
+
+# Performance benchmarking
+python tests\benchmark_inference.py
+```
+
+### Integration Testing
+```powershell
+# End-to-end API testing
+python tests\integration_test.py --host localhost --port 8000
+```
+
+## 🚀 Production Deployment
+
+### Docker Deployment
+```powershell
+# Build optimized container
+docker build -t crop-disease-detection-api .\api
+
+# Run with GPU support
+docker run --gpus all -p 8000:8000 crop-disease-detection-api
+
+# Run CPU-only version
+docker run -p 8000:8000 -e USE_GPU=false crop-disease-detection-api
+```
+
+### Environment Configuration
+```powershell
+# Production environment variables
+$env:ENVIRONMENT = "production"
+$env:MODEL_PATH = "models/crop_disease_v3_model.pth"
+$env:CONFIDENCE_THRESHOLD = "0.8"
+$env:ENABLE_EXPLANATIONS = "true"
+$env:MAX_IMAGE_SIZE = "10MB"
+```
+
+### Production Considerations
+- **Load Balancing**: Use multiple API instances behind load balancer
+- **Monitoring**: Implement comprehensive logging and metrics
+- **Security**: Configure proper CORS, rate limiting, and authentication
+- **Performance**: Use GPU acceleration and model quantization
+- **Scalability**: Consider serverless deployment for variable workloads
+
+## 📈 Performance Optimization
+
+### Memory Optimization Strategies
+```python
+# Use lightweight model for resource-constrained environments
+from src.model_lite import TinyDiseaseClassifier
+
+model = TinyDiseaseClassifier(num_classes=15)  # ~5MB model size
+```
+
+### Speed Optimization
+- **Model Quantization**: INT8 quantization for 4x speed improvement
+- **Batch Processing**: Process multiple images simultaneously
+- **Async API**: Non-blocking request handling
+- **Caching**: Cache frequent predictions and explanations
+
+### Edge Deployment
+- **Model Pruning**: Remove unnecessary parameters
+- **Knowledge Distillation**: Train smaller student models
+- **ONNX Export**: Cross-platform deployment support
+
+## 🤝 Development Workflow
+
+### Contributing Guidelines
+1. **Fork Repository**: Create personal fork for development
+2. **Feature Branch**: Create descriptive branch name
+3. **Code Standards**: Follow PEP 8 and add type hints
+4. **Testing**: Add comprehensive tests for new features
+5. **Documentation**: Update README and inline documentation
+6. **Pull Request**: Submit with detailed description and test results
+
+### Code Quality Standards
+- **Type Hints**: All functions must include type annotations
+- **Docstrings**: Google-style docstrings for all public methods
+- **Testing**: Minimum 80% code coverage required
+- **Linting**: Code must pass flake8 and black formatting
+
+## 📄 License & Legal
+
+This project is part of the HackBhoomi2025 agricultural intelligence platform. All rights reserved.
+
+### Model Attribution
+- Base ResNet50 architecture from torchvision (BSD License)
+- Training dataset: Publicly available agricultural disease datasets
+- Custom modifications and enhancements: HackBhoomi2025 team
+
+## 🆘 Troubleshooting Guide
+
+### Common Issues & Solutions
+
+1. **CUDA Out of Memory Error**:
+   ```powershell
+   # Solution: Use lighter model or reduce batch size
+   $env:USE_LITE_MODEL = "true"
+   $env:BATCH_SIZE = "8"
+   ```
+
+2. **Model Loading Errors**:
+   ```powershell
+   # Verify model file integrity
+   python -c "import torch; torch.load('models/crop_disease_v3_model.pth', map_location='cpu')"
+   ```
+
+3. **Low Prediction Accuracy**:
+   - Ensure image quality (minimum 224x224 resolution)
+   - Verify crop type is supported (Pepper, Potato, Tomato only)
+   - Check image format (JPG, PNG supported)
+   - Review confidence threshold settings
+
+4. **API Connection Issues**:
+   ```powershell
+   # Check if server is running
+   Invoke-RestMethod -Uri "http://localhost:8000/health" -Method Get
+   ```
+
+5. **Dependencies Installation Problems**:
+   ```powershell
+   # Clean installation
+   pip cache purge
+   pip install --no-cache-dir -r requirements.txt
+   ```
+
+### Performance Troubleshooting
+- **Slow Inference**: Enable GPU acceleration, use lite model variant
+- **High Memory Usage**: Reduce batch size, use memory-optimized model
+- **API Timeout**: Increase request timeout, optimize image preprocessing
+
+### Support & Resources
+- **Issue Tracking**: GitHub Issues for bug reports and feature requests
+- **Documentation**: Comprehensive API documentation at `/docs`
+- **Community**: HackBhoomi2025 development team for technical support
+
+---
+
+**📊 Project Statistics:**
+- **Lines of Code**: 2,000+ (main application)
+- **Model Parameters**: 25.6M (ResNet50), 1.2M (Lite variant)
+- **Supported Image Formats**: JPG, JPEG, PNG
+- **API Response Time**: <200ms average
+- **Model Accuracy**: 90.09% (state-of-the-art for agricultural disease detection)
+
+*Last Updated: September 2025*  
+*Model Version: 3.0*  
+*API Version: 2.0.0*  
+*Documentation Version: 1.5*

api/Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+COPY ../src ./src
+COPY ../models ./models
+COPY ../knowledge_base ./knowledge_base
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

api/main.py

@@ -0,0 +1,475 @@
+"""
+FastAPI Backend for Crop Disease Detection
+Provides REST API endpoints for disease prediction with visual explanations
+"""
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import torch
+import torch.nn.functional as F
+from PIL import Image
+import io
+import json
+import sys
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+import tempfile
+import traceback
+
+# Add src to path for imports
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+try:
+    from src.model import CropDiseaseResNet50
+    from src.explain import CropDiseaseExplainer
+    from src.risk_level import RiskLevelCalculator
+    from src.dataset import get_transforms
+except ImportError as e:
+    print(f"Import error: {e}")
+    print("Make sure all required modules are available")
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Crop Disease Detection API",
+    description="AI-powered crop disease detection with visual explanations",
+    version="2.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for model and components
+model = None
+explainer = None
+risk_calculator = None
+class_names = []
+device = None
+
+def load_model_and_components():
+    """Load trained model and initialize components"""
+    global model, explainer, risk_calculator, class_names, device
+    
+    try:
+        # Set device
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Using device: {device}")
+        
+        # Load class names from V3 model checkpoint (updated for Pepper, Potato, Tomato)
+        class_names = [
+            'Pepper__bell___Bacterial_spot',
+            'Pepper__bell___healthy',
+            'Potato___Early_blight',
+            'Potato___healthy',
+            'Potato___Late_blight',
+            'Tomato__Target_Spot',
+            'Tomato__Tomato_mosaic_virus',
+            'Tomato__Tomato_YellowLeaf__Curl_Virus',
+            'Tomato_Bacterial_spot',
+            'Tomato_Early_blight',
+            'Tomato_healthy',
+            'Tomato_Late_blight',
+            'Tomato_Leaf_Mold',
+            'Tomato_Septoria_leaf_spot',
+            'Tomato_Spider_mites_Two_spotted_spider_mite'
+        ]
+        
+        # Load trained model
+        model_path = 'models/crop_disease_v3_model.pth'
+        
+        if os.path.exists(model_path):
+            model = CropDiseaseResNet50(num_classes=len(class_names), pretrained=False)
+            checkpoint = torch.load(model_path, map_location=device)
+            
+            # Handle checkpoint format from crop_disease_v3_model.pth
+            if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                state_dict = checkpoint['model_state_dict']
+                # Use class names from checkpoint if available
+                if 'class_names' in checkpoint:
+                    class_names = checkpoint['class_names']
+            else:
+                state_dict = checkpoint
+            
+            model.load_state_dict(state_dict, strict=True)
+            model.to(device)
+            model.eval()
+            print(f"Model loaded from {model_path}")
+        else:
+            print("Warning: No trained model found. Creating untrained model for API structure.")
+            model = CropDiseaseResNet50(num_classes=len(class_names), pretrained=True)
+            model.to(device)
+            model.eval()
+        
+        # Initialize explainer
+        explainer = CropDiseaseExplainer(model, class_names, device)
+        print("Explainer initialized")
+        
+        # Initialize risk calculator
+        risk_calculator = RiskLevelCalculator()
+        print("Risk calculator initialized")
+        
+        return True
+        
+    except Exception as e:
+        print(f"Error loading model and components: {e}")
+        traceback.print_exc()
+        return False
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize components on startup"""
+    success = load_model_and_components()
+    if not success:
+        print("Warning: Failed to load some components. API may have limited functionality.")
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "Crop Disease Detection API",
+        "version": "2.0.0",
+        "status": "active",
+        "endpoints": {
+            "predict": "/predict - POST with image file",
+            "health": "/health - GET for health check"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "ok",
+        "model_loaded": model is not None,
+        "explainer_ready": explainer is not None,
+        "risk_calculator_ready": risk_calculator is not None,
+        "device": str(device) if device else "unknown",
+        "classes": len(class_names)
+    }
+
+@app.post("/predict")
+async def predict_disease(
+    file: UploadFile = File(...),
+    include_explanation: bool = Form(True),
+    weather_humidity: Optional[float] = Form(None),
+    weather_temperature: Optional[float] = Form(None),
+    weather_rainfall: Optional[float] = Form(None),
+    growth_stage: Optional[str] = Form(None)
+):
+    """
+    Predict crop disease from uploaded image
+    
+    Args:
+        file: Uploaded image file
+        include_explanation: Whether to include Grad-CAM explanation
+        weather_humidity: Optional humidity percentage
+        weather_temperature: Optional temperature in Celsius
+        weather_rainfall: Optional rainfall in mm
+        growth_stage: Optional crop growth stage
+    
+    Returns:
+        JSON response with prediction, risk assessment, and explanation
+    """
+    
+    if not model:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    try:
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+        
+        # Read and process image
+        image_data = await file.read()
+        image = Image.open(io.BytesIO(image_data)).convert('RGB')
+        
+        # Preprocess image
+        from torchvision import transforms
+        transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+        
+        input_tensor = transform(image).unsqueeze(0).to(device)
+        
+        # Make prediction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = F.softmax(outputs, dim=1)
+            confidence, predicted_idx = torch.max(probabilities, 1)
+            
+            predicted_class = class_names[predicted_idx.item()]
+            confidence_score = confidence.item()
+        
+        # Get all class probabilities
+        class_probabilities = {
+            class_names[i]: probabilities[0, i].item() 
+            for i in range(len(class_names))
+        }
+        
+        # Parse crop and disease from class name (improved for V3 model formats)
+        if '___' in predicted_class:
+            parts = predicted_class.split('___')
+            crop = parts[0]
+            disease = parts[1]
+        elif '__' in predicted_class:
+            parts = predicted_class.split('__', 1)  # Split only on first occurrence
+            crop = parts[0]
+            disease = parts[1]
+        elif '_' in predicted_class:
+            parts = predicted_class.split('_', 1)  # Split only on first occurrence
+            crop = parts[0]
+            disease = parts[1]
+        else:
+            crop = "Unknown"
+            disease = predicted_class
+        
+        # Calculate risk level
+        weather_data = None
+        if any([weather_humidity, weather_temperature, weather_rainfall]):
+            weather_data = {
+                'humidity': weather_humidity or 50,
+                'temperature': weather_temperature or 25,
+                'rainfall': weather_rainfall or 0
+            }
+        
+        risk_assessment = risk_calculator.calculate_enhanced_risk(
+            predicted_class, confidence_score, weather_data, growth_stage
+        )
+        
+        # Load disease information
+        disease_info = {}
+        try:
+            with open('knowledge_base/disease_info.json', 'r') as f:
+                kb_data = json.load(f)
+                for d in kb_data['diseases']:
+                    # Use the class_name field directly instead of constructing it
+                    if d.get('class_name') == predicted_class:
+                        disease_info = {
+                            'description': d['description'],
+                            'symptoms': d['symptoms'],
+                            'solutions': d['solutions'],
+                            'prevention': d['prevention']
+                        }
+                        break
+        except Exception as e:
+            print(f"Error loading disease info: {e}")
+        
+        # Prepare response
+        response = {
+            'predicted_class': predicted_class,
+            'crop': crop,
+            'disease': disease,
+            'confidence': confidence_score,
+            'risk_level': risk_assessment['risk_level'],
+            'class_probabilities': class_probabilities,
+            'risk_assessment': risk_assessment,
+            'disease_info': disease_info,
+            'prediction_timestamp': risk_assessment['assessment_timestamp']
+        }
+        
+        # Generate visual explanation if requested
+        if include_explanation and explainer:
+            try:
+                # Save temporary image file
+                with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp_file:
+                    image.save(tmp_file.name)
+                    tmp_path = tmp_file.name
+                
+                # Generate explanation
+                explanation = explainer.explain_prediction(
+                    tmp_path, return_base64=True
+                )
+                
+                if 'error' in explanation:
+                    response['explanation'] = {
+                        'error': explanation['error'],
+                        'explanation_image': ''
+                    }
+                else:
+                    response['explanation'] = {
+                        'explanation_image': explanation.get('overlay_base64', ''),
+                        'predicted_class': explanation.get('predicted_class', predicted_class),
+                        'confidence': explanation.get('confidence', confidence_score),
+                        'save_path': explanation.get('save_path', '')
+                    }
+                
+                # Clean up temporary file
+                os.unlink(tmp_path)
+                
+            except Exception as e:
+                print(f"Error generating explanation: {e}")
+                response['explanation'] = {
+                    'error': 'Could not generate visual explanation',
+                    'explanation_image': ''
+                }
+        
+        return JSONResponse(content=response)
+        
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+@app.post("/batch_predict")
+async def batch_predict(files: list[UploadFile] = File(...)):
+    """
+    Predict diseases for multiple images
+    
+    Args:
+        files: List of uploaded image files
+    
+    Returns:
+        JSON response with predictions for all images
+    """
+    
+    if not model:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    if len(files) > 10:  # Limit batch size
+        raise HTTPException(status_code=400, detail="Maximum 10 images per batch")
+    
+    try:
+        predictions = []
+        
+        for i, file in enumerate(files):
+            if not file.content_type.startswith('image/'):
+                predictions.append({
+                    'filename': file.filename,
+                    'error': 'Invalid file type'
+                })
+                continue
+            
+            try:
+                # Process individual image
+                image_data = await file.read()
+                image = Image.open(io.BytesIO(image_data)).convert('RGB')
+                
+                # Make prediction (simplified for batch processing)
+                from torchvision import transforms
+                transform = transforms.Compose([
+                    transforms.Resize((224, 224)),
+                    transforms.ToTensor(),
+                    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+                ])
+                
+                input_tensor = transform(image).unsqueeze(0).to(device)
+                
+                with torch.no_grad():
+                    outputs = model(input_tensor)
+                    probabilities = F.softmax(outputs, dim=1)
+                    confidence, predicted_idx = torch.max(probabilities, 1)
+                    
+                    predicted_class = class_names[predicted_idx.item()]
+                    confidence_score = confidence.item()
+                
+                # Calculate basic risk
+                risk_level = risk_calculator.calculate_base_risk(predicted_class, confidence_score)
+                
+                predictions.append({
+                    'filename': file.filename,
+                    'predicted_class': predicted_class,
+                    'confidence': confidence_score,
+                    'risk_level': risk_level
+                })
+                
+            except Exception as e:
+                predictions.append({
+                    'filename': file.filename,
+                    'error': str(e)
+                })
+        
+        # Generate summary
+        summary = risk_calculator.get_risk_summary([
+            p for p in predictions if 'error' not in p
+        ])
+        
+        return JSONResponse(content={
+            'predictions': predictions,
+            'summary': summary,
+            'total_processed': len(files),
+            'successful_predictions': len([p for p in predictions if 'error' not in p])
+        })
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Batch prediction failed: {str(e)}")
+
+@app.get("/classes")
+async def get_classes():
+    """Get list of supported disease classes"""
+    return {
+        'classes': class_names,
+        'total_classes': len(class_names),
+        'crops': ['Pepper', 'Potato', 'Tomato']
+    }
+
+@app.get("/model_info")
+async def get_model_info():
+    """Get model architecture and training information"""
+    return {
+        'model_name': 'CropDiseaseResNet50',
+        'architecture': 'ResNet50 with custom classifier',
+        'input_size': [3, 224, 224],
+        'num_classes': len(class_names),
+        'device': str(device),
+        'model_file': 'crop_disease_v3_model.pth',
+        'features': {
+            'backbone': 'ResNet50 (pretrained)',
+            'classifier': 'Custom sequential layers with dropout',
+            'grad_cam': 'Available for visual explanations',
+            'risk_assessment': 'Multi-factor risk calculation'
+        },
+        'capabilities': [
+            'Disease classification',
+            'Visual explanations (Grad-CAM)',
+            'Risk level assessment',
+            'Treatment recommendations',
+            'Batch processing'
+        ]
+    }
+
+@app.get("/disease_info/{crop}/{disease}")
+async def get_disease_info(crop: str, disease: str):
+    """Get detailed information about a specific disease"""
+    
+    try:
+        with open('knowledge_base/disease_info.json', 'r') as f:
+            kb_data = json.load(f)
+            
+        for d in kb_data['diseases']:
+            if d['crop'].lower() == crop.lower() and d['disease'].lower() == disease.lower():
+                return d
+        
+        raise HTTPException(status_code=404, detail="Disease information not found")
+        
+    except FileNotFoundError:
+        raise HTTPException(status_code=503, detail="Knowledge base not available")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error retrieving disease info: {str(e)}")
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    print("🚀 Starting Crop Disease Detection API...")
+    print("📊 Loading model and components...")
+    
+    # Load components
+    success = load_model_and_components()
+    if success:
+        print("✅ All components loaded successfully!")
+    else:
+        print("⚠️ Some components failed to load")
+    
+    print("🌐 Starting server on http://localhost:4333")
+    print("📖 API documentation available at http://localhost:4333/docs")
+
+    uvicorn.run(app, host="localhost", port=4333)

api/main_optimized.py

@@ -0,0 +1,401 @@
+"""
+Memory-optimized FastAPI Backend for Crop Disease Detection
+Optimized to use <512MB RAM
+"""
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import torch
+import torch.nn.functional as F
+from PIL import Image
+import io
+import json
+import sys
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+import tempfile
+import traceback
+import gc
+import psutil
+
+# Add src to path for imports
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+try:
+    from src.model import CropDiseaseResNet50Lite
+    from src.explain_lite import CropDiseaseExplainerLite
+    from src.risk_level import RiskLevelCalculator
+    from src.dataset import get_inference_transforms
+except ImportError as e:
+    print(f"Import error: {e}")
+    print("Make sure all required modules are available")
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Crop Disease Detection API (Optimized)",
+    description="Memory-optimized AI-powered crop disease detection",
+    version="2.1.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for model and components
+model = None
+explainer = None
+risk_calculator = None
+class_names = []
+device = None
+transforms = None
+
+def get_memory_usage():
+    """Get current memory usage in MB"""
+    process = psutil.Process(os.getpid())
+    memory_info = process.memory_info()
+    return memory_info.rss / 1024 / 1024  # Convert to MB
+
+def optimize_memory():
+    """Force garbage collection and clear GPU cache"""
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+def load_model_and_components():
+    """Load trained model and initialize components with memory optimization"""
+    global model, explainer, risk_calculator, class_names, device, transforms
+    
+    try:
+        # Set device - prefer CPU for memory efficiency
+        if torch.cuda.is_available() and torch.cuda.get_device_properties(0).total_memory > 2e9:
+            device = torch.device('cuda')
+        else:
+            device = torch.device('cpu')
+        print(f"Using device: {device}")
+        
+        # Optimized class names (reduced set for memory efficiency)
+        class_names = [
+            'Pepper_Bacterial_spot',
+            'Pepper_healthy',
+            'Potato_Early_blight',
+            'Potato_healthy',
+            'Potato_Late_blight',
+            'Tomato_Target_Spot',
+            'Tomato_mosaic_virus',
+            'Tomato_Yellow_Leaf_Curl',
+            'Tomato_Bacterial_spot',
+            'Tomato_Early_blight',
+            'Tomato_healthy',
+            'Tomato_Late_blight',
+            'Tomato_Leaf_Mold',
+            'Tomato_Septoria_leaf_spot',
+            'Tomato_Spider_mites'
+        ]
+        
+        # Load model with memory optimization
+        model_path = 'models/crop_disease_v3_model.pth'
+        
+        if os.path.exists(model_path):
+            # Use lite version of model
+            model = CropDiseaseResNet50Lite(num_classes=len(class_names), pretrained=False)
+            
+            # Load with memory mapping for large files
+            checkpoint = torch.load(model_path, map_location=device, weights_only=True)
+            
+            if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                state_dict = checkpoint['model_state_dict']
+                if 'class_names' in checkpoint:
+                    class_names = checkpoint['class_names']
+            else:
+                state_dict = checkpoint
+            
+            # Load state dict and immediately clear checkpoint from memory
+            model.load_state_dict(state_dict, strict=False)
+            del checkpoint, state_dict
+            optimize_memory()
+            
+            model.to(device)
+            model.eval()
+            
+            # Enable memory efficient mode
+            if hasattr(model, 'set_memory_efficient'):
+                model.set_memory_efficient(True)
+            
+            print(f"Lite model loaded from {model_path}")
+        else:
+            print("Warning: No trained model found. Creating lite model.")
+            model = CropDiseaseResNet50Lite(num_classes=len(class_names), pretrained=True)
+            model.to(device)
+            model.eval()
+        
+        # Initialize lite explainer only if needed
+        explainer = CropDiseaseExplainerLite(model, class_names, device)
+        print("Lite explainer initialized")
+        
+        # Initialize risk calculator
+        risk_calculator = RiskLevelCalculator()
+        print("Risk calculator initialized")
+        
+        # Pre-load transforms
+        transforms = get_inference_transforms(input_size=224)
+        
+        # Force memory cleanup
+        optimize_memory()
+        
+        memory_usage = get_memory_usage()
+        print(f"Memory usage after loading: {memory_usage:.1f} MB")
+        
+        return True
+        
+    except Exception as e:
+        print(f"Error loading model and components: {e}")
+        traceback.print_exc()
+        return False
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize components on startup"""
+    print("Starting optimized disease detection API...")
+    success = load_model_and_components()
+    if success:
+        print("✅ All components loaded successfully")
+    else:
+        print("⚠️ Failed to load some components")
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    memory_usage = get_memory_usage()
+    return {
+        "message": "Crop Disease Detection API (Optimized)",
+        "version": "2.1.0",
+        "status": "active",
+        "memory_usage_mb": f"{memory_usage:.1f}",
+        "optimization": "Memory optimized for <512MB usage",
+        "endpoints": {
+            "predict": "/predict - POST with image file",
+            "health": "/health - GET for health check",
+            "memory": "/memory - GET memory usage info"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint with memory info"""
+    memory_usage = get_memory_usage()
+    return {
+        "status": "ok",
+        "model_loaded": model is not None,
+        "explainer_loaded": explainer is not None,
+        "device": str(device) if device else "unknown",
+        "memory_usage_mb": f"{memory_usage:.1f}",
+        "memory_optimized": memory_usage < 512
+    }
+
+@app.get("/memory")
+async def memory_info():
+    """Get detailed memory usage information"""
+    memory_usage = get_memory_usage()
+    process = psutil.Process(os.getpid())
+    memory_info = process.memory_info()
+    
+    return {
+        "memory_usage_mb": f"{memory_usage:.1f}",
+        "memory_percent": f"{process.memory_percent():.1f}%",
+        "rss_mb": f"{memory_info.rss / 1024 / 1024:.1f}",
+        "vms_mb": f"{memory_info.vms / 1024 / 1024:.1f}",
+        "available_memory_mb": f"{psutil.virtual_memory().available / 1024 / 1024:.1f}",
+        "gpu_memory_allocated": f"{torch.cuda.memory_allocated() / 1024 / 1024:.1f}" if torch.cuda.is_available() else "N/A",
+        "optimization_status": "Optimized" if memory_usage < 512 else "Needs optimization"
+    }
+
+@app.post("/predict")
+async def predict_disease(
+    file: UploadFile = File(...),
+    include_explanation: bool = Form(False),
+    weather_humidity: Optional[float] = Form(None),
+    weather_temperature: Optional[float] = Form(None),
+    weather_rainfall: Optional[float] = Form(None)
+):
+    """
+    Predict plant disease from uploaded image (memory optimized)
+    """
+    if model is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    try:
+        # Memory optimization: track usage
+        initial_memory = get_memory_usage()
+        
+        # Read and validate image with memory limits
+        contents = await file.read()
+        if len(contents) > 5 * 1024 * 1024:  # 5MB limit
+            raise HTTPException(status_code=413, detail="Image too large. Maximum size: 5MB")
+        
+        # Process image with memory optimization
+        image = Image.open(io.BytesIO(contents))
+        
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Resize to reduce memory usage
+        max_size = 224
+        if image.size[0] > max_size or image.size[1] > max_size:
+            image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+        
+        # Apply transforms
+        if transforms is None:
+            transforms_fn = get_inference_transforms(input_size=224)
+        else:
+            transforms_fn = transforms
+            
+        input_tensor = transforms_fn(image).unsqueeze(0).to(device)
+        
+        # Clear image from memory
+        del image, contents
+        optimize_memory()
+        
+        # Prediction with memory optimization
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = F.softmax(outputs, dim=1)
+            confidence, predicted_idx = torch.max(probabilities, 1)
+            
+            predicted_class = class_names[predicted_idx.item()]
+            confidence_score = confidence.item()
+        
+        # Get class probabilities (top 3 only to save memory)
+        class_probs = {}
+        top_probs, top_indices = torch.topk(probabilities[0], min(3, len(class_names)))
+        for i, (prob, idx) in enumerate(zip(top_probs, top_indices)):
+            class_probs[class_names[idx.item()]] = prob.item()
+        
+        # Clear tensors
+        del input_tensor, outputs, probabilities
+        optimize_memory()
+        
+        # Load disease information efficiently
+        disease_info = get_disease_info_lite(predicted_class)
+        
+        # Calculate risk assessment
+        weather_data = {}
+        if weather_humidity is not None:
+            weather_data['humidity'] = weather_humidity
+        if weather_temperature is not None:
+            weather_data['temperature'] = weather_temperature
+        if weather_rainfall is not None:
+            weather_data['rainfall'] = weather_rainfall
+        
+        risk_assessment = risk_calculator.calculate_risk(
+            predicted_class, confidence_score, weather_data
+        ) if risk_calculator else {"overall_risk": "unknown", "risk_factors": [], "recommendations": []}
+        
+        # Generate explanation only if requested and memory allows
+        explanation_data = {}
+        current_memory = get_memory_usage()
+        
+        if include_explanation and current_memory < 400 and explainer:  # Only if we have memory headroom
+            try:
+                explanation_data = explainer.generate_explanation_lite(
+                    await file.read(), predicted_class
+                )
+            except Exception as e:
+                print(f"Explanation generation failed: {e}")
+                explanation_data = {"error": "Explanation unavailable due to memory constraints"}
+        elif include_explanation:
+            explanation_data = {"error": "Explanation disabled due to memory constraints"}
+        
+        # Final memory cleanup
+        optimize_memory()
+        final_memory = get_memory_usage()
+        
+        # Prepare response
+        result = {
+            "predicted_class": predicted_class,
+            "confidence": confidence_score,
+            "class_probabilities": class_probs,
+            "disease_info": disease_info,
+            "risk_assessment": risk_assessment,
+            "crop": extract_crop_name(predicted_class),
+            "memory_usage": {
+                "initial_mb": f"{initial_memory:.1f}",
+                "final_mb": f"{final_memory:.1f}",
+                "memory_optimized": final_memory < 512
+            }
+        }
+        
+        if explanation_data:
+            result["explanation"] = explanation_data
+        
+        return JSONResponse(content=result)
+        
+    except Exception as e:
+        # Cleanup on error
+        optimize_memory()
+        print(f"Prediction error: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+def get_disease_info_lite(disease_class: str) -> Dict[str, Any]:
+    """Get disease information with memory optimization"""
+    try:
+        # Load only essential disease info to save memory
+        knowledge_base_path = Path(__file__).parent.parent / "knowledge_base" / "disease_info.json"
+        
+        if knowledge_base_path.exists():
+            with open(knowledge_base_path, 'r') as f:
+                all_disease_info = json.load(f)
+            
+            # Get specific disease info
+            disease_info = all_disease_info.get(disease_class, {})
+            
+            # Return only essential fields to save memory
+            return {
+                "symptoms": disease_info.get("symptoms", [])[:3],  # Limit to 3 symptoms
+                "solutions": disease_info.get("solutions", [])[:3],  # Limit to 3 solutions
+                "prevention": disease_info.get("prevention", [])[:3],  # Limit to 3 prevention methods
+                "description": disease_info.get("description", "No description available")[:200]  # Truncate description
+            }
+    except Exception as e:
+        print(f"Error loading disease info: {e}")
+    
+    return {
+        "symptoms": ["Symptoms information unavailable"],
+        "solutions": ["Please consult agricultural expert"],
+        "prevention": ["Follow general plant care guidelines"],
+        "description": "Disease information unavailable"
+    }
+
+def extract_crop_name(disease_class: str) -> str:
+    """Extract crop name from disease class"""
+    if disease_class.startswith(('Pepper', 'pepper')):
+        return "Pepper"
+    elif disease_class.startswith(('Potato', 'potato')):
+        return "Potato"
+    elif disease_class.startswith(('Tomato', 'tomato')):
+        return "Tomato"
+    else:
+        return "Unknown"
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    print("Starting memory-optimized disease detection API...")
+    print("Target: <512MB RAM usage")
+    
+    uvicorn.run(
+        app, 
+        host="0.0.0.0", 
+        port=8001,
+        workers=1,  # Single worker to save memory
+        limit_concurrency=2  # Limit concurrent requests
+    )

api/requirements.txt

@@ -0,0 +1,13 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pillow==10.0.1
+torch==2.1.0
+torchvision==0.16.0
+numpy==1.24.3
+opencv-python==4.8.1.78
+matplotlib==3.7.2
+scikit-learn==1.3.0
+seaborn==0.12.2
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4

data/dataset_stats.txt

@@ -0,0 +1,110 @@
+Dataset Organization Statistics
+========================================
+
+Corn___Cercospora_leaf_spot_Gray_leaf_spot:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Corn___Common_rust:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Corn___Northern_Leaf_Blight:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Corn___healthy:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Potato___Early_Blight:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Potato___Late_Blight:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Potato___healthy:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Bacterial_spot:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Early_blight:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Late_blight:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Leaf_Mold:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Septoria_leaf_spot:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Spider_mites_Two_spotted_spider_mite:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Target_Spot:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Tomato_Yellow_Leaf_Curl_Virus:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___Tomato_mosaic_virus:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Tomato___healthy:
+  Total: 5
+  Train: 3
+  Val: 1
+  Test: 1
+
+Summary:
+Total images: 85
+Training: 51 (60.0%)
+Validation: 17 (20.0%)
+Test: 17 (20.0%)

data/processed/dataset_info.json

@@ -0,0 +1,102 @@
+{
+  "dataset_name": "Crop Disease Detection - Retrained",
+  "num_classes": 15,
+  "class_names": [
+    "Pepper__bell___Bacterial_spot",
+    "Pepper__bell___healthy",
+    "Potato___Early_blight",
+    "Potato___Late_blight",
+    "Potato___healthy",
+    "Tomato_Bacterial_spot",
+    "Tomato_Early_blight",
+    "Tomato_Late_blight",
+    "Tomato_Leaf_Mold",
+    "Tomato_Septoria_leaf_spot",
+    "Tomato_Spider_mites_Two_spotted_spider_mite",
+    "Tomato__Target_Spot",
+    "Tomato__Tomato_YellowLeaf__Curl_Virus",
+    "Tomato__Tomato_mosaic_virus",
+    "Tomato_healthy"
+  ],
+  "class_to_idx": {
+    "Pepper__bell___Bacterial_spot": 0,
+    "Pepper__bell___healthy": 1,
+    "Potato___Early_blight": 2,
+    "Potato___Late_blight": 3,
+    "Potato___healthy": 4,
+    "Tomato_Bacterial_spot": 5,
+    "Tomato_Early_blight": 6,
+    "Tomato_Late_blight": 7,
+    "Tomato_Leaf_Mold": 8,
+    "Tomato_Septoria_leaf_spot": 9,
+    "Tomato_Spider_mites_Two_spotted_spider_mite": 10,
+    "Tomato__Target_Spot": 11,
+    "Tomato__Tomato_YellowLeaf__Curl_Virus": 12,
+    "Tomato__Tomato_mosaic_virus": 13,
+    "Tomato_healthy": 14
+  },
+  "split_ratios": {
+    "train": 0.7,
+    "val": 0.15,
+    "test": 0.15
+  },
+  "split_stats": {
+    "train": {
+      "Pepper__bell___Bacterial_spot": 697,
+      "Pepper__bell___healthy": 1034,
+      "Potato___Early_blight": 700,
+      "Potato___healthy": 106,
+      "Potato___Late_blight": 700,
+      "Tomato__Target_Spot": 982,
+      "Tomato__Tomato_mosaic_virus": 261,
+      "Tomato__Tomato_YellowLeaf__Curl_Virus": 2245,
+      "Tomato_Bacterial_spot": 1488,
+      "Tomato_Early_blight": 700,
+      "Tomato_healthy": 1113,
+      "Tomato_Late_blight": 1336,
+      "Tomato_Leaf_Mold": 666,
+      "Tomato_Septoria_leaf_spot": 1239,
+      "Tomato_Spider_mites_Two_spotted_spider_mite": 1173
+    },
+    "val": {
+      "Pepper__bell___Bacterial_spot": 149,
+      "Pepper__bell___healthy": 221,
+      "Potato___Early_blight": 150,
+      "Potato___healthy": 22,
+      "Potato___Late_blight": 150,
+      "Tomato__Target_Spot": 210,
+      "Tomato__Tomato_mosaic_virus": 55,
+      "Tomato__Tomato_YellowLeaf__Curl_Virus": 481,
+      "Tomato_Bacterial_spot": 319,
+      "Tomato_Early_blight": 150,
+      "Tomato_healthy": 238,
+      "Tomato_Late_blight": 286,
+      "Tomato_Leaf_Mold": 142,
+      "Tomato_Septoria_leaf_spot": 265,
+      "Tomato_Spider_mites_Two_spotted_spider_mite": 251
+    },
+    "test": {
+      "Pepper__bell___Bacterial_spot": 151,
+      "Pepper__bell___healthy": 223,
+      "Potato___Early_blight": 150,
+      "Potato___healthy": 24,
+      "Potato___Late_blight": 150,
+      "Tomato__Target_Spot": 212,
+      "Tomato__Tomato_mosaic_virus": 57,
+      "Tomato__Tomato_YellowLeaf__Curl_Virus": 482,
+      "Tomato_Bacterial_spot": 320,
+      "Tomato_Early_blight": 150,
+      "Tomato_healthy": 240,
+      "Tomato_Late_blight": 287,
+      "Tomato_Leaf_Mold": 144,
+      "Tomato_Septoria_leaf_spot": 267,
+      "Tomato_Spider_mites_Two_spotted_spider_mite": 252
+    }
+  },
+  "total_images": {
+    "train": 14440,
+    "val": 3089,
+    "test": 3109,
+    "total": 20638
+  }
+}