Rollback to stable v6.1: 2026-01-27 00:54:34

app.py

@@ -5,7 +5,6 @@ from ultralytics import YOLO
 from PIL import Image, ImageOps
 import io
 import tensorflow as tf
-import keras
 import numpy as np
 from tensorflow.keras.applications.mobilenet_v3 import preprocess_input
 import os
@@ -17,7 +16,7 @@ HF_TOKEN = os.environ.get("HF_TOKEN")
 
 app = FastAPI()
 
-# 2. CORS Setup
+# Enable CORS for frontend access
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -26,59 +25,73 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# 3. Model Constants
+# Constants
 CLASS_NAMES = ['Anthracnose', 'Cercospora', 'Fresh Leaf', 'Leaf Curl']
-YOLO_MODEL_PATH = "best.pt"
-MOBILENET_MODEL_PATH = "mobilenetv3_chili_leaf_global.keras"
+YOLO_MODEL_NAME = "best.pt"
+MOBILENET_MODEL_NAME = "mobilenetv3_chili_leaf_global.keras"
 
+# Global model variables
 yolo_model = None
 mobilenet_model = None
 
-# 4. Model Loading Functions
-def load_models():
-    global yolo_model, mobilenet_model
-    
-    # --- Load YOLO ---
+def load_yolo():
+    global yolo_model
+    print(f"Loading YOLO model: {YOLO_MODEL_NAME}")
     try:
-        print(f"Attempting to load YOLO from {YOLO_MODEL_PATH}...")
-        target_path = YOLO_MODEL_PATH
-        if not os.path.exists(target_path):
-            from huggingface_hub import hf_hub_download
-            print("Downloading YOLO from HF Hub...")
-            target_path = hf_hub_download(repo_id="nomandiu9/chili", filename=YOLO_MODEL_PATH, token=HF_TOKEN)
-        yolo_model = YOLO(target_path)
-        print("YOLO model loaded successfully.")
+        # Check local paths first
+        paths = [YOLO_MODEL_NAME, f"backend/{YOLO_MODEL_NAME}", f"/app/{YOLO_MODEL_NAME}"]
+        for p in paths:
+            if os.path.exists(p):
+                yolo_model = YOLO(p)
+                print(f"YOLO loaded from: {p}")
+                return
+        
+        # Fallback to HF Hub
+        from huggingface_hub import hf_hub_download
+        print("Downloading YOLO from HF Hub...")
+        hf_path = hf_hub_download(repo_id="nomandiu9/chili", filename=YOLO_MODEL_NAME, token=HF_TOKEN)
+        yolo_model = YOLO(hf_path)
+        print("YOLO loaded from HF Hub")
     except Exception as e:
-        print(f"ERROR loading YOLO: {e}")
+        print(f"FAILED to load YOLO: {e}")
 
-    # --- Load MobileNet ---
+def load_mobilenet():
+    global mobilenet_model
+    print(f"Loading MobileNet model: {MOBILENET_MODEL_NAME}")
     try:
-        print(f"Attempting to load MobileNet from {MOBILENET_MODEL_PATH}...")
-        target_path = MOBILENET_MODEL_PATH
-        if not os.path.exists(target_path):
+        # Check local paths
+        target_path = None
+        paths = [MOBILENET_MODEL_NAME, f"backend/{MOBILENET_MODEL_NAME}", f"/app/{MOBILENET_MODEL_NAME}"]
+        for p in paths:
+            if os.path.exists(p):
+                target_path = p
+                print(f"Found MobileNet at: {p}")
+                break
+        
+        # Fallback to HF Hub
+        if not target_path:
             from huggingface_hub import hf_hub_download
             print("Downloading MobileNet from HF Hub...")
-            target_path = hf_hub_download(repo_id="nomandiu9/chili", filename=MOBILENET_MODEL_PATH, token=HF_TOKEN)
+            target_path = hf_hub_download(repo_id="nomandiu9/chili", filename=MOBILENET_MODEL_NAME, token=HF_TOKEN)
         
-        # Use keras 3 standalone for .keras files
+        # Load the model
         try:
+            # Try keras 3 standalone first
+            import keras
             mobilenet_model = keras.models.load_model(target_path, compile=False)
-            print("MobileNet whole model loaded successfully.")
-        except Exception as e1:
-            print(f"Full model load failed ({e1}), trying weights-only...")
-            try:
-                mobilenet_model = tf.keras.applications.MobileNetV3Large(weights=None, classes=len(CLASS_NAMES))
-                mobilenet_model.load_weights(target_path)
-                print("MobileNet weights loaded successfully.")
-            except Exception as e2:
-                print(f"CRITICAL ERROR loading MobileNet: {e2}")
+            print("MobileNet whole model loaded.")
+        except:
+            print("Full model load failed, trying weights-only...")
+            mobilenet_model = tf.keras.applications.MobileNetV3Large(weights=None, classes=len(CLASS_NAMES))
+            mobilenet_model.load_weights(target_path)
+            print("MobileNet weights loaded.")
     except Exception as e:
-        print(f"ERROR loading MobileNet: {e}")
+        print(f"FAILED to load MobileNet: {e}")
 
-# Initial Trigger (DIRECT)
-load_models()
+# Initial load
+load_yolo()
+load_mobilenet()
 
-# 5. API Endpoints
 @app.get("/")
 def read_root():
     return {
@@ -90,35 +103,40 @@ def read_root():
 @app.post("/predict")
 async def predict(image: UploadFile = File(...)):
     if not yolo_model or not mobilenet_model:
-        raise HTTPException(status_code=503, detail="Models are initializing")
+        return {"error": "Models are still initializing. Try again in a few seconds."}
 
-    # Read and orient image
+    # 1. Read and fix image orientation
     image_bytes = await image.read()
     img = Image.open(io.BytesIO(image_bytes))
     img = ImageOps.exif_transpose(img).convert("RGB")
 
     results_data = {}
 
-    # --- Step 1: YOLO Bounding Boxes ---
+    # 2. YOLO Bounding Box Extraction
     try:
-        yolo_results = yolo_model(img, imgsz=640, conf=0.15, verbose=False)
+        yolo_results = yolo_model(img, imgsz=640, conf=0.15, verbose=False) 
         yolo_res = yolo_results[0]
         boxes = []
         if hasattr(yolo_res, 'boxes') and yolo_res.boxes is not None:
             for box in yolo_res.boxes:
-                coords = box.xyxy[0].tolist() 
+                coords = box.xyxy[0].tolist()  # [x1, y1, x2, y2]
+                conf = float(box.conf.item()) * 100
+                cls_id = int(box.cls.item())
                 boxes.append({
+                    "id": cls_id,
                     "bbox": coords,
-                    "confidence": float(box.conf.item()) * 100
+                    "yolo_label": yolo_res.names[cls_id],
+                    "yolo_confidence": conf
                 })
         results_data["yolo"] = {"boxes": boxes}
     except Exception as e:
-        results_data["yolo"] = {"boxes": [], "error": str(e)}
+        print(f"YOLO inference error: {e}")
+        results_data["yolo"] = {"error": str(e), "boxes": []}
 
-    # --- Step 2: MobileNet Identification ---
+    # 3. MobileNet Disease Detection
     try:
-        # Resize to 224x224 for MobileNet
-        img_resized = img.resize((224, 224), Image.NEAREST)
+        # Preprocessing
+        img_resized = img.resize((224, 224), Image.NEAREST) 
         img_array = np.asarray(img_resized, dtype=np.float32)
         img_array = np.expand_dims(img_array, axis=0)
         img_array = preprocess_input(img_array)
@@ -135,12 +153,14 @@ async def predict(image: UploadFile = File(...)):
             "confidence": confidence
         }
 
-        # --- Step 3: Label Sync ---
-        # Sync all YOLO boxes to use the MobileNet label
+        # 4. Integrate YOLO boxes with MobileNet labels
+        # We use YOLO for WHERE the disease is, but MobileNet for WHAT the disease is.
         for box in results_data["yolo"]["boxes"]:
             box["label"] = predicted_class
-            
+            box["confidence"] = confidence  # Use MobileNet's confidence for the final label
+
     except Exception as e:
+        print(f"MobileNet inference error: {e}")
         results_data["mobilenet"] = {"error": str(e)}
 
     return results_data

requirements.txt

@@ -4,5 +4,4 @@ python-multipart
 ultralytics
 pillow
 huggingface-hub
-tensorflow>=2.16.1
-keras>=3.0.0
+tensorflow-cpu