Upload 43 files

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies for numpy, pandas, PIL, etc.
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        build-essential \
+        libglib2.0-0 \
+        libsm6 \
+        libxext6 \
+        libxrender-dev \
+        gcc \
+        git \
+        wget \
+        curl \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Set environment variables for UTF-8 and production
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    LC_ALL=C.UTF-8 \
+    LANG=C.UTF-8
+
+COPY requirements.txt ./
+RUN pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# Expose the port for Hugging Face Spaces
+EXPOSE 7860
+
+# Healthcheck (optional, but recommended for cloud)
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD curl --fail http://localhost:7860/docs || exit 1
+
+# Use python -m uvicorn for reliability
+CMD ["python", "-m", "uvicorn", "api.main:app", "--host", "0.0.0.0", "--port", "7860"]

api/__init__.py

@@ -0,0 +1 @@
+# API package init

api/endpoints/__init__.py

@@ -0,0 +1 @@
+# Endpoints package init

api/endpoints/paddy_disease.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from models.loader import ModelLoader
+from request_queue.queue_manager import RequestQueue
+
+router = APIRouter(prefix="/predict/paddy-disease", tags=["Paddy Disease"])
+
+model_loader = ModelLoader(config_dir="models/configs")
+request_queue = RequestQueue(maxsize=10)
+
+@router.post("")
+async def predict_paddy_disease(file: UploadFile = File(...)):
+    try:
+        image_bytes = await file.read()
+        def process_request():
+            model = model_loader.load_model("paddy_disease")
+            result = model.predict(image_bytes)
+            return {"filename": file.filename, **result}
+        request_queue.add_request(process_request)
+        response = request_queue.get_request()()
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/endpoints/pest.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from models.loader import ModelLoader
+from request_queue.queue_manager import RequestQueue
+
+router = APIRouter(prefix="/predict/pest", tags=["Pest"])
+
+model_loader = ModelLoader(config_dir="models/configs")
+request_queue = RequestQueue(maxsize=10)
+
+@router.post("")
+async def predict_pest(file: UploadFile = File(...)):
+    try:
+        image_bytes = await file.read()
+        def process_request():
+            model = model_loader.load_model("pest")
+            result = model.predict(image_bytes)
+            return {"filename": file.filename, **result}
+        request_queue.add_request(process_request)
+        response = request_queue.get_request()()
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/endpoints/plant_disease.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from models.loader import ModelLoader
+from request_queue.queue_manager import RequestQueue
+
+router = APIRouter(prefix="/predict/plant-disease", tags=["Plant Disease"])
+
+# Initialize model loader (adjust config path as needed)
+model_loader = ModelLoader(config_dir="models/configs")
+request_queue = RequestQueue(maxsize=10)
+
+@router.post("")
+async def predict_plant_disease(file: UploadFile = File(...)):
+    try:
+        image_bytes = await file.read()
+        def process_request():
+            model = model_loader.load_model("plant_disease")
+            result = model.predict(image_bytes)
+            return {"filename": file.filename, **result}
+        request_queue.add_request(process_request)
+        response = request_queue.get_request()()
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/endpoints/unified.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from models.loader import ModelLoader
+from request_queue.queue_manager import RequestQueue
+
+router = APIRouter(prefix="/predict/unified", tags=["Unified"])
+
+model_loader = ModelLoader(config_dir="models/configs")
+
+# Initialize a global request queue (can be tuned for maxsize)
+request_queue = RequestQueue(maxsize=10)
+
+@router.post("")
+async def predict_unified(file: UploadFile = File(...)):
+    try:
+        image_bytes = await file.read()
+        # Add request to queue and process in order
+        def process_request():
+            router_model = model_loader.load_model("router")
+            router_result = router_model.predict(image_bytes)
+            model_key = router_result.get("model_key", "plant_disease")
+            model = model_loader.load_model(model_key)
+            result = model.predict(image_bytes)
+            return {"filename": file.filename, "router_info": router_result, **result}
+        request_queue.add_request(process_request)
+        # For simplicity, process immediately after adding (single worker scenario)
+        response = request_queue.get_request()()
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

api/main.py

@@ -0,0 +1,10 @@
+from fastapi import FastAPI
+from api.endpoints import plant_disease, paddy_disease, pest, unified
+
+app = FastAPI(title="AgroVisor API", description="Modular, scalable backend for Hugging Face Spaces.")
+
+# Include routers from endpoints (to be implemented in each endpoint module)
+app.include_router(plant_disease.router)
+app.include_router(paddy_disease.router)
+app.include_router(pest.router)
+app.include_router(unified.router)

frontend_app.py

@@ -0,0 +1,63 @@
+import streamlit as st
+import requests
+from PIL import Image
+import io
+import time
+
+API_BASE_URL = "http://localhost:7860"
+
+st.set_page_config(page_title="AgroVisor AI System", page_icon="🌱", layout="wide")
+
+st.title("🌱 AgroVisor AI System")
+st.markdown("Efficient, modular backend with queuing and resource management.")
+
+# Sidebar
+st.sidebar.title("Navigation")
+page = st.sidebar.radio("Choose task", [
+    "Unified Classification",
+    "Plant Disease Detection",
+    "Paddy Disease Classification",
+    "Pest Identification"
+])
+
+# Helper to handle API requests and queue status
+def predict(endpoint, file):
+    files = {"file": (file.name, file.getvalue(), file.type)}
+    try:
+        response = requests.post(f"{API_BASE_URL}/predict/{endpoint}", files=files, timeout=60)
+        if response.status_code == 200:
+            return response.json(), None
+        elif response.status_code == 429:
+            return None, "Server busy or queue full. Please wait and try again."
+        else:
+            return None, f"Error: {response.status_code} - {response.text}"
+    except requests.exceptions.RequestException as e:
+        return None, f"Request failed: {e}"
+
+# Main UI logic
+def show_predict_ui(endpoint, label):
+    st.header(label)
+    uploaded_file = st.file_uploader(f"Upload an image for {label.lower()}", type=["jpg", "jpeg", "png"])
+    if uploaded_file:
+        image = Image.open(uploaded_file)
+        st.image(image, caption="Uploaded Image", use_column_width=True)
+        if st.button(f"Predict {label}"):
+            with st.spinner("Processing and waiting in queue if needed..."):
+                result, error = predict(endpoint, uploaded_file)
+                if error:
+                    st.error(error)
+                elif result:
+                    st.success("Prediction complete!")
+                    st.json(result)
+
+if page == "Unified Classification":
+    show_predict_ui("unified", "Unified Classification")
+elif page == "Plant Disease Detection":
+    show_predict_ui("plant-disease", "Plant Disease Detection")
+elif page == "Paddy Disease Classification":
+    show_predict_ui("paddy-disease", "Paddy Disease Classification")
+elif page == "Pest Identification":
+    show_predict_ui("pest", "Pest Identification")
+
+st.sidebar.markdown("---")
+st.sidebar.info("Backend: FastAPI (modular, lazy loading, LRU cache, queuing)")

models/__init__.py

@@ -0,0 +1 @@
+# Models package init

models/base.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+class BaseModel(ABC):
+    @abstractmethod
+    def load(self):
+        pass
+
+    @abstractmethod
+    def predict(self, input_data):
+        pass

models/cache.py

@@ -0,0 +1,19 @@
+from collections import OrderedDict
+
+class ModelCache(OrderedDict):
+    def __init__(self, max_size=2):
+        super().__init__()
+        self.max_size = max_size
+
+    def __getitem__(self, key):
+        value = super().__getitem__(key)
+        self.move_to_end(key)
+        return value
+
+    def __setitem__(self, key, value):
+        if key in self:
+            self.move_to_end(key)
+        super().__setitem__(key, value)
+        if len(self) > self.max_size:
+            oldest = next(iter(self))
+            del self[oldest]

models/configs/paddy_disease.yaml

@@ -0,0 +1,5 @@
+module: models.paddy_disease_model
+class: PaddyDiseaseModel
+params:
+  model_path: "Models here/paddy_diseases_classifier_cnn.keras"
+  annotation_path: annotations/paddy_disease_classifier.csv

models/configs/pest.yaml

@@ -0,0 +1,5 @@
+module: models.pest_model
+class: PestModel
+params:
+  model_path: "Models here/pest_classifier_effnetB3.keras"
+  annotation_path: annotations/pest_classifier.csv

models/configs/plant_disease.yaml

@@ -0,0 +1,5 @@
+module: models.plant_disease_model
+class: PlantDiseaseModel
+params:
+  model_path: "Models here/plant_disease_classifier_cnn.keras"
+  annotation_path: annotations/plant_disease_classifier.csv

models/configs/router.yaml

@@ -0,0 +1,5 @@
+module: models.router_model
+class: RouterModel
+params:
+  model_path: "Models here/router_classifier_best.keras"
+  annotation_path: annotations/router_classifier.csv

models/loader.py

@@ -0,0 +1,25 @@
+import threading
+from .cache import ModelCache
+from .base import BaseModel
+import yaml
+import importlib
+
+class ModelLoader:
+    def __init__(self, config_dir, cache_size=2):
+        self.config_dir = config_dir
+        self.cache = ModelCache(max_size=cache_size)
+        self.lock = threading.Lock()
+
+    def load_model(self, model_name):
+        with self.lock:
+            if model_name in self.cache:
+                return self.cache[model_name]
+            config_path = f"{self.config_dir}/{model_name}.yaml"
+            with open(config_path, 'r') as f:
+                config = yaml.safe_load(f)
+            module = importlib.import_module(config['module'])
+            model_class = getattr(module, config['class'])
+            model = model_class(**config.get('params', {}))
+            model.load()
+            self.cache[model_name] = model
+            return model

models/paddy_disease_model.py

@@ -0,0 +1,66 @@
+import tensorflow as tf
+import pandas as pd
+import numpy as np
+from models.base import BaseModel
+from PIL import Image
+import io
+from keras import backend as K
+from keras.saving import register_keras_serializable
+
+class PaddyDiseaseModel(BaseModel):
+    def __init__(self, model_path, annotation_path):
+        self.model_path = model_path
+        self.annotation_path = annotation_path
+        self.model = None
+        self.class_names = []
+
+    def focal_loss(self, gamma=2.0, alpha=0.25):
+        @register_keras_serializable()
+        def focal_loss_fixed(y_true, y_pred):
+            y_pred = tf.clip_by_value(y_pred, K.epsilon(), 1. - K.epsilon())
+            cross_entropy = -y_true * tf.math.log(y_pred)
+            weight = alpha * tf.pow(1 - y_pred, gamma)
+            loss = weight * cross_entropy
+            return tf.reduce_mean(tf.reduce_sum(loss, axis=1))
+        return focal_loss_fixed
+
+    def load(self):
+        self.model = tf.keras.models.load_model(
+            self.model_path,
+            custom_objects={'focal_loss_fixed': self.focal_loss(gamma=2.0, alpha=0.25)}
+        )
+        df = pd.read_csv(self.annotation_path)
+        self.class_names = df['class_name'].tolist()
+
+    def preprocess(self, image_bytes):
+        image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+        img = np.array(image)
+        img = tf.image.resize(img, (224, 224)).numpy()
+        img = img.astype('float32') / 255.0
+        img = np.expand_dims(img, axis=0)
+        return img
+
+    def predict(self, image_bytes):
+        img = self.preprocess(image_bytes)
+        preds = self.model.predict(img)[0]
+        idx = int(np.argmax(preds))
+        confidence = float(preds[idx])
+        class_name = self.class_names[idx]
+        top_3_idx = np.argsort(preds)[-3:][::-1]
+        top_3 = [
+            {"class_index": int(i), "class_name": self.class_names[i], "confidence": float(preds[i])}
+            for i in top_3_idx
+        ]
+        is_healthy = 'healthy' in class_name.lower() or 'normal' in class_name.lower()
+        return {
+            "endpoint": "paddy-disease",
+            "description": "Specialized paddy/rice disease classification",
+            "prediction": {
+                "class_index": idx,
+                "class_name": class_name,
+                "confidence": confidence,
+                "is_healthy": is_healthy
+            },
+            "top_3_predictions": top_3,
+            "model_used": "paddy_disease"
+        }

models/pest_model.py

@@ -0,0 +1,63 @@
+import tensorflow as tf
+import pandas as pd
+import numpy as np
+from models.base import BaseModel
+from PIL import Image
+import io
+from keras import backend as K
+
+class PestModel(BaseModel):
+    def __init__(self, model_path, annotation_path):
+        self.model_path = model_path
+        self.annotation_path = annotation_path
+        self.model = None
+        self.class_names = []
+
+    def focal_loss(self, gamma=2.0, alpha=0.25):
+        def focal_loss_fixed(y_true, y_pred):
+            y_pred = tf.clip_by_value(y_pred, K.epsilon(), 1. - K.epsilon())
+            cross_entropy = -y_true * tf.math.log(y_pred)
+            loss = alpha * tf.pow(1 - y_pred, gamma) * cross_entropy
+            return tf.reduce_sum(loss, axis=1)
+        return focal_loss_fixed
+
+    def load(self):
+        self.model = tf.keras.models.load_model(
+            self.model_path,
+            custom_objects={'focal_loss_fixed': self.focal_loss(gamma=2.0, alpha=0.25)}
+        )
+        df = pd.read_csv(self.annotation_path)
+        self.class_names = df['class_name'].tolist()
+
+    def preprocess(self, image_bytes):
+        image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+        img = np.array(image)
+        img = tf.image.resize(img, (224, 224)).numpy()
+        img = img.astype('float32') / 255.0
+        img = np.expand_dims(img, axis=0)
+        return img
+
+    def predict(self, image_bytes):
+        img = self.preprocess(image_bytes)
+        preds = self.model.predict(img)[0]
+        idx = int(np.argmax(preds))
+        confidence = float(preds[idx])
+        class_name = self.class_names[idx]
+        top_3_idx = np.argsort(preds)[-3:][::-1]
+        top_3 = [
+            {"class_index": int(i), "class_name": self.class_names[i], "confidence": float(preds[i])}
+            for i in top_3_idx
+        ]
+        is_healthy = 'healthy' in class_name.lower() or 'normal' in class_name.lower()
+        return {
+            "endpoint": "pest",
+            "description": "Agricultural pest identification",
+            "prediction": {
+                "class_index": idx,
+                "class_name": class_name,
+                "confidence": confidence,
+                "is_healthy": is_healthy
+            },
+            "top_3_predictions": top_3,
+            "model_used": "pest"
+        }

models/plant_disease_model.py

@@ -0,0 +1,51 @@
+import tensorflow as tf
+import pandas as pd
+import numpy as np
+from models.base import BaseModel
+from PIL import Image
+import io
+
+class PlantDiseaseModel(BaseModel):
+    def __init__(self, model_path, annotation_path):
+        self.model_path = model_path
+        self.annotation_path = annotation_path
+        self.model = None
+        self.class_names = []
+
+    def load(self):
+        self.model = tf.keras.models.load_model(self.model_path)
+        df = pd.read_csv(self.annotation_path)
+        self.class_names = df['class_name'].tolist()
+
+    def preprocess(self, image_bytes):
+        image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+        img = np.array(image)
+        img = tf.image.resize(img, (224, 224)).numpy()
+        img = img.astype('float32') / 255.0
+        img = np.expand_dims(img, axis=0)
+        return img
+
+    def predict(self, image_bytes):
+        img = self.preprocess(image_bytes)
+        preds = self.model.predict(img)[0]
+        idx = int(np.argmax(preds))
+        confidence = float(preds[idx])
+        class_name = self.class_names[idx]
+        top_3_idx = np.argsort(preds)[-3:][::-1]
+        top_3 = [
+            {"class_index": int(i), "class_name": self.class_names[i], "confidence": float(preds[i])}
+            for i in top_3_idx
+        ]
+        is_healthy = 'healthy' in class_name.lower() or 'normal' in class_name.lower()
+        return {
+            "endpoint": "plant-disease",
+            "description": "General plant disease classification",
+            "prediction": {
+                "class_index": idx,
+                "class_name": class_name,
+                "confidence": confidence,
+                "is_healthy": is_healthy
+            },
+            "top_3_predictions": top_3,
+            "model_used": "plant_disease"
+        }

models/router_model.py

@@ -0,0 +1,48 @@
+import tensorflow as tf
+import pandas as pd
+import numpy as np
+from models.base import BaseModel
+from PIL import Image
+import io
+
+class RouterModel(BaseModel):
+    def __init__(self, model_path, annotation_path):
+        self.model_path = model_path
+        self.annotation_path = annotation_path
+        self.model = None
+        self.class_names = []
+
+    def load(self):
+        self.model = tf.keras.models.load_model(self.model_path)
+        df = pd.read_csv(self.annotation_path)
+        self.class_names = df['class_name'].tolist()
+
+    def preprocess(self, image_bytes):
+        image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+        img = np.array(image)
+        img = tf.image.resize(img, (224, 224)).numpy()
+        img = img.astype('float32') / 255.0
+        img = np.expand_dims(img, axis=0)
+        return img
+
+    def predict(self, image_bytes):
+        img = self.preprocess(image_bytes)
+        preds = self.model.predict(img)[0]
+        idx = int(np.argmax(preds))
+        confidence = float(preds[idx])
+        class_name = self.class_names[idx]
+        # Map router class to model key
+        if 'plant' in class_name:
+            model_key = 'plant_disease'
+        elif 'paddy' in class_name:
+            model_key = 'paddy_disease'
+        elif 'pest' in class_name:
+            model_key = 'pest'
+        else:
+            model_key = 'plant_disease'
+        return {
+            "router_prediction": class_name,
+            "router_confidence": confidence,
+            "model_key": model_key,
+            "available_classifiers": self.class_names
+        }

request_queue/__init__.py

@@ -0,0 +1 @@
+# Queue package init

request_queue/queue_manager.py

@@ -0,0 +1,15 @@
+import threading
+from queue import Queue
+
+class RequestQueue:
+    def __init__(self, maxsize=10):
+        self.queue = Queue(maxsize=maxsize)
+        self.lock = threading.Lock()
+
+    def add_request(self, request):
+        with self.lock:
+            self.queue.put(request)
+
+    def get_request(self):
+        with self.lock:
+            return self.queue.get()

utils/__init__.py

@@ -0,0 +1 @@
+# Utils package init

utils/helpers.py

@@ -0,0 +1 @@
+# General helper functions can be added here

utils/logger.py

@@ -0,0 +1,11 @@
+import logging
+
+def get_logger(name):
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter('[%(asctime)s] %(levelname)s in %(name)s: %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+    return logger