Initial Commit: CropGuard disease detection app

Dockerfile

@@ -0,0 +1,30 @@
+# Use Python 3.13.7 slim image for better performance and smaller size
+FROM python:3.13.7-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && 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 --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create a non-root user for security
+RUN useradd --create-home --shell /bin/bash app && chown -R app:app /app
+USER app
+
+# Expose the port that Hugging Face Spaces expects
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "fastapi_app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,28 @@
 ---
-title: CropGuardFastAPI
-emoji: 📉
+title: CropGuard Plant Disease Detection
+emoji: 🌱
 colorFrom: green
-colorTo: gray
+colorTo: blue
 sdk: docker
 pinned: false
+license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CropGuard - Plant Disease Detection
+
+This is a plant disease classification system using a ResNet-9 model trained on the PlantVillage dataset. 
+
+## Features
+- Detects diseases in 38 different plant categories
+- Supports multiple plant types: Apple, Corn, Tomato, Potato, Grape, and more
+- Real-time prediction with confidence scores
+- User-friendly web interface
+
+## Usage
+Simply upload an image of a plant leaf, and the model will predict the disease (if any) with confidence scores.
+
+## Model Details
+- Architecture: ResNet-9
+- Dataset: PlantVillage
+- Classes: 38 plant disease categories
+- Input: 256x256 RGB images

app.py

@@ -0,0 +1,178 @@
+import gradio as gr
+import torch
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+from PIL import Image
+import os
+
+# Import your model
+from models import ResNet9
+
+# Plant disease class names
+CLASS_NAMES = [
+    'Apple___Apple_scab',
+    'Apple___Black_rot', 
+    'Apple___Cedar_apple_rust',
+    'Apple___healthy',
+    'Blueberry___healthy',
+    'Cherry_(including_sour)__Powdery_mildew',
+    'Cherry(including_sour)__healthy',
+    'Corn(maize)__Cercospora_leaf_spot Gray_leaf_spot',
+    'Corn(maize)_Common_rust',
+    'Corn(maize)__Northern_Leaf_Blight',
+    'Corn(maize)healthy',
+    'Grape___Black_rot',
+    'Grape___Esca(Black_Measles)',
+    'Grape___Leaf_blight(Isariopsis_Leaf_Spot)',
+    'Grape___healthy',
+    'Orange___Haunglongbing(Citrus_greening)',
+    'Peach___Bacterial_spot',
+    'Peach___healthy',
+    'Pepper,_bell___Bacterial_spot',
+    'Pepper,_bell___healthy',
+    'Potato___Early_blight',
+    'Potato___Late_blight',
+    'Potato___healthy',
+    'Raspberry___healthy',
+    'Soybean___healthy',
+    'Squash___Powdery_mildew',
+    'Strawberry___Leaf_scorch',
+    'Strawberry___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_Yellow_Leaf_Curl_Virus',
+    'Tomato___Tomato_mosaic_virus',
+    'Tomato___healthy'
+]
+
+# Load model
+model = None
+
+def load_model():
+    global model
+    try:
+        model = ResNet9(3, len(CLASS_NAMES))
+        state_dict = torch.load("plant-disease-model-state-dict.pth", map_location="cpu")
+        model.load_state_dict(state_dict)
+        model.eval()
+        print("✅ Model loaded successfully")
+        return True
+    except Exception as e:
+        print(f"❌ Model load failed: {e}")
+        return False
+
+def predict_disease(image):
+    """Predict plant disease from image"""
+    if model is None:
+        if not load_model():
+            return {"Error": "Model not available"}
+    
+    # Transform image
+    transform = transforms.Compose([
+        transforms.Resize((256, 256)),
+        transforms.ToTensor()
+    ])
+    
+    try:
+        # Convert and transform image
+        if image is None:
+            return {"Error": "No image provided"}
+            
+        img_tensor = transform(image).unsqueeze(0)
+        
+        # Make prediction
+        with torch.no_grad():
+            outputs = model(img_tensor)
+            probabilities = F.softmax(outputs[0], dim=0)
+            
+            # Get top 5 predictions
+            top5_prob, top5_indices = torch.topk(probabilities, 5)
+            
+            # Format results for Gradio
+            results = {}
+            for i, (prob, idx) in enumerate(zip(top5_prob, top5_indices)):
+                class_name = CLASS_NAMES[idx.item()]
+                # Clean up class name for display
+                clean_name = class_name.replace('___', ' - ').replace('_', ' ')
+                results[clean_name] = float(prob)
+                
+        return results
+        
+    except Exception as e:
+        return {"Error": f"Prediction failed: {str(e)}"}
+
+def format_class_info():
+    """Format class information for display"""
+    plants = {}
+    for class_name in CLASS_NAMES:
+        if '___' in class_name:
+            plant, condition = class_name.split('___', 1)
+            if plant not in plants:
+                plants[plant] = []
+            plants[plant].append(condition.replace('_', ' '))
+    
+    info = "## Supported Plants and Conditions:\n\n"
+    for plant, conditions in sorted(plants.items()):
+        info += f"**{plant.replace('_', ' ')}**: {', '.join(conditions)}\n\n"
+    
+    return info
+
+# Load model on startup
+load_model()
+
+# Create Gradio interface
+with gr.Blocks(title="🌱 CropGuard - Plant Disease Detection", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🌱 CropGuard - Plant Disease Detection
+    
+    Upload an image of a plant leaf to detect diseases using our ResNet-9 model trained on the PlantVillage dataset.
+    
+    **Supported formats**: JPG, PNG, JPEG
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(
+                type="pil",
+                label="Upload Plant Image",
+                height=400
+            )
+            predict_btn = gr.Button("🔍 Analyze Disease", variant="primary", size="lg")
+            
+        with gr.Column():
+            output = gr.Label(
+                label="Disease Prediction Results",
+                num_top_classes=5,
+                show_label=True
+            )
+            
+    # Example images (you can add these later)
+    gr.Markdown("### 📋 Examples")
+    gr.Markdown("Try uploading images of plant leaves to see the disease detection in action!")
+    
+    # Info section
+    with gr.Accordion("ℹ️ Supported Plants & Diseases", open=False):
+        gr.Markdown(format_class_info())
+    
+    # Event handlers
+    predict_btn.click(
+        fn=predict_disease,
+        inputs=image_input,
+        outputs=output
+    )
+    
+    # Also predict on image upload
+    image_input.change(
+        fn=predict_disease,
+        inputs=image_input,
+        outputs=output
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

converter.py

@@ -0,0 +1,19 @@
+import torch
+from models import ResNet9
+
+# Load the existing model
+try:
+    old_model = torch.load("plant-disease-model.pth", map_location="cpu", weights_only=False)
+    
+    # Save only the state dict
+    torch.save(old_model.state_dict(), "plant-disease-model-state-dict.pth")
+    print("✅ Model converted to state dict format")
+    
+    # Test loading the new format
+    new_model = ResNet9(3, 38)  # 38 classes based on your CLASS_NAMES
+    new_model.load_state_dict(torch.load("plant-disease-model-state-dict.pth"))
+    new_model.eval()
+    print("✅ Converted model loads successfully")
+    
+except Exception as e:
+    print(f"❌ Conversion failed: {e}")

fastapi_app.py

@@ -0,0 +1,71 @@
+from fastapi import FastAPI, File, UploadFile
+from fastapi.responses import JSONResponse
+from PIL import Image
+import torch
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+import io
+from models import ResNet9
+
+app = FastAPI(title="CropGuard - Plant Disease Detection")
+
+CLASS_NAMES = [
+    'Apple___Apple_scab', 'Apple___Black_rot', 'Apple___Cedar_apple_rust', 'Apple___healthy',
+    'Blueberry___healthy', 'Cherry_(including_sour)__Powdery_mildew', 'Cherry(including_sour)__healthy',
+    'Corn(maize)__Cercospora_leaf_spot Gray_leaf_spot', 'Corn(maize)_Common_rust',
+    'Corn(maize)__Northern_Leaf_Blight', 'Corn(maize)healthy', 'Grape___Black_rot',
+    'Grape___Esca(Black_Measles)', 'Grape___Leaf_blight(Isariopsis_Leaf_Spot)', 'Grape___healthy',
+    'Orange___Haunglongbing(Citrus_greening)', 'Peach___Bacterial_spot', 'Peach___healthy',
+    'Pepper,_bell___Bacterial_spot', 'Pepper,_bell___healthy', 'Potato___Early_blight',
+    'Potato___Late_blight', 'Potato___healthy', 'Raspberry___healthy', 'Soybean___healthy',
+    'Squash___Powdery_mildew', 'Strawberry___Leaf_scorch', 'Strawberry___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_Yellow_Leaf_Curl_Virus', 'Tomato___Tomato_mosaic_virus', 'Tomato___healthy'
+]
+
+model = None
+
+def load_model():
+    global model
+    if model is None:
+        model = ResNet9(3, len(CLASS_NAMES))
+        state_dict = torch.load("plant-disease-model-state-dict.pth", map_location="cpu")
+        model.load_state_dict(state_dict)
+        model.eval()
+
+load_model()
+
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    try:
+        image_bytes = await file.read()
+        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+        transform = transforms.Compose([
+            transforms.Resize((256, 256)),
+            transforms.ToTensor()
+        ])
+        img_tensor = transform(image)
+        if isinstance(img_tensor, torch.Tensor) and img_tensor.ndimension() == 3:
+            img_tensor = img_tensor.unsqueeze(0)
+        global model
+        if model is None:
+            load_model()
+        if model is None:
+            raise RuntimeError("Model failed to load.")
+        with torch.no_grad():
+            outputs = model(img_tensor)
+            probabilities = F.softmax(outputs[0], dim=0)
+            top5_prob, top5_indices = torch.topk(probabilities, 5)
+            results = {}
+            for prob, idx in zip(top5_prob, top5_indices):
+                class_name = CLASS_NAMES[int(idx.item())]
+                clean_name = class_name.replace('___', ' - ').replace('_', ' ')
+                results[clean_name] = float(prob)
+        return JSONResponse(content={"predictions": results})
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+@app.get("/")
+def root():
+    return {"message": "CropGuard FastAPI is running. Use /predict to POST an image."}

models.py

@@ -0,0 +1,60 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+def ConvBlock(in_channels, out_channels, pool=False):
+    layers = [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
+             nn.BatchNorm2d(out_channels),
+             nn.ReLU(inplace=True)]
+    if pool:
+        layers.append(nn.MaxPool2d(4))
+    return nn.Sequential(*layers)
+
+class ImageClassificationBase(nn.Module):
+    def training_step(self, batch):
+        images, labels = batch
+        out = self(images)
+        loss = F.cross_entropy(out, labels)
+        return loss
+        
+    def validation_step(self, batch):
+        images, labels = batch
+        out = self(images)
+        loss = F.cross_entropy(out, labels)
+        acc = (out.argmax(dim=1) == labels).float().mean()
+        return {"val_loss": loss.detach(), "val_accuracy": acc}
+        
+    def validation_epoch_end(self, outputs):
+        batch_losses = [x["val_loss"] for x in outputs]
+        batch_accuracy = [x["val_accuracy"] for x in outputs]
+        epoch_loss = torch.stack(batch_losses).mean()
+        epoch_accuracy = torch.stack(batch_accuracy).mean()
+        return {"val_loss": epoch_loss, "val_accuracy": epoch_accuracy}
+        
+    def epoch_end(self, epoch, result):
+        print(f"Epoch [{epoch}], train_loss: {result['train_loss']:.4f}, val_loss: {result['val_loss']:.4f}, val_acc: {result['val_accuracy']:.4f}")
+
+
+class ResNet9(ImageClassificationBase):
+    def __init__(self, in_channels, num_classes):
+        super().__init__()
+        self.conv1 = ConvBlock(in_channels, 64)
+        self.conv2 = ConvBlock(64, 128, pool=True)
+        self.res1 = nn.Sequential(ConvBlock(128, 128), ConvBlock(128, 128))
+        self.conv3 = ConvBlock(128, 256, pool=True)
+        self.conv4 = ConvBlock(256, 512, pool=True)
+        self.res2 = nn.Sequential(ConvBlock(512, 512), ConvBlock(512, 512))
+        self.classifier = nn.Sequential(
+            nn.MaxPool2d(4),
+            nn.Flatten(),
+            nn.Linear(512, num_classes)
+        )
+    def forward(self, xb):
+        out = self.conv1(xb)
+        out = self.conv2(out)
+        out = self.res1(out) + out
+        out = self.conv3(out)
+        out = self.conv4(out)
+        out = self.res2(out) + out
+        out = self.classifier(out)
+        return out

plant-disease-model-state-dict.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5e9497ddbb41600362d95c00ad1fe96b2b3ed637ac8a27cc2803e8acff1144d
+size 26397109

requirements.txt

@@ -0,0 +1,4 @@
+torch
+torchvision
+Pillow
+fastapi[standard]