Finalized accuracy fixes and linked to production Hugging Face backend

backend/app.py

@@ -37,61 +37,59 @@ app.add_middleware(
 # --- GLOBAL MODELS ---
 GENERAL_EXPERT = None
 PLANT_SPECIALIST = None
-PEST_EXPERT = None
+CEREAL_EXPERT = None
 
 from .model_manifest import get_seasonal_experts
 
 def get_experts():
     from transformers import pipeline
-    global GENERAL_EXPERT, PLANT_SPECIALIST, PEST_EXPERT
+    global GENERAL_EXPERT, PLANT_SPECIALIST, CEREAL_EXPERT
     
-    if GENERAL_EXPERT is None or PLANT_SPECIALIST is None or PEST_EXPERT is None:
+    if GENERAL_EXPERT is None or PLANT_SPECIALIST is None or CEREAL_EXPERT is None:
         manifest = get_seasonal_experts()
         print(f"Loading Multi-Expert AI Pipeline...")
         
+        class ManualPipeline:
+            def __init__(self, model_name):
+                from transformers import AutoModelForImageClassification
+                self.model = AutoModelForImageClassification.from_pretrained(model_name).to(torch.float32)
+                self.model.eval()
+                self.torch = torch
+                
+            def manual_image_processor(self, image):
+                import numpy as np
+                # Standardization for PlantVillage models (0.5 mean/std)
+                img = image.convert("RGB").resize((224, 224))
+                img_array = np.array(img).astype(np.float32) / 255.0
+                mean = np.array([0.5, 0.5, 0.5])
+                std = np.array([0.5, 0.5, 0.5])
+                img_array = (img_array - mean) / std
+                img_array = img_array.transpose(2, 0, 1)
+                return self.torch.tensor(img_array, dtype=self.torch.float32).unsqueeze(0)
+
+            def __call__(self, image):
+                inputs = self.manual_image_processor(image)
+                with self.torch.no_grad():
+                    outputs = self.model(inputs)
+                probs = self.torch.nn.functional.softmax(outputs.logits, dim=-1)[0]
+                top_probs, top_indices = self.torch.topk(probs, 5)
+                results = []
+                for i in range(5):
+                    idx = top_indices[i].item()
+                    results.append({
+                        "label": self.model.config.id2label[idx],
+                        "score": top_probs[i].item()
+                    })
+                return results
+
         for entry in manifest:
             try:
-                # Provide strict image processor fallback to correct the HuggingFace missing preprocessor_config crash
-                if entry['id'] == 'specialist':
-                    from transformers import AutoModelForImageClassification
-                    import torch
-                    import numpy as np
-                    
-                    class SpecialistPipeline:
-                        def __init__(self, model_name):
-                            # Force HuggingFace rebuild
-                            self.model = AutoModelForImageClassification.from_pretrained(model_name).to(torch.float32)
-                            self.model.eval()
-                            self.torch = torch
-                            
-                        def manual_image_processor(self, image):
-                            # Completely replaces AutoImageProcessor so torchvision is never required
-                            img = image.convert("RGB").resize((224, 224))
-                            img_array = np.array(img).astype(np.float32) / 255.0
-                            # MobileNetV2 uses strictly 0.5 means/stds
-                            mean = np.array([0.5, 0.5, 0.5])
-                            std = np.array([0.5, 0.5, 0.5])
-                            img_array = (img_array - mean) / std
-                            # HWC to CHW format required by PyTorch
-                            img_array = img_array.transpose(2, 0, 1)
-                            # Explicitly force float32 unconditionally
-                            return self.torch.tensor(img_array, dtype=self.torch.float32).unsqueeze(0)
-
-                        def __call__(self, image):
-                            inputs = self.manual_image_processor(image)
-                            with self.torch.no_grad():
-                                outputs = self.model(inputs)
-                            probs = self.torch.nn.functional.softmax(outputs.logits, dim=-1)[0]
-                            predicted_idx = probs.argmax().item()
-                            return [{"label": self.model.config.id2label[predicted_idx], "score": probs[predicted_idx].item()}]
-                            
-                    pipe = SpecialistPipeline(entry['model'])
-                else:
-                    pipe = pipeline("image-classification", model=entry['model'])
+                # All models in this pipeline (DeiT, MobileNet, ViT-tiny) use the same 224x224 0.5 normalization
+                pipe = ManualPipeline(entry['model'])
                     
                 if entry['id'] == 'generalist': GENERAL_EXPERT = pipe
                 elif entry['id'] == 'specialist': PLANT_SPECIALIST = pipe
-                elif entry['id'] == 'pest': PEST_EXPERT = pipe
+                elif entry['id'] == 'cereal': CEREAL_EXPERT = pipe
                 print(f"Expert [{entry['name']}] Loaded.")
             except Exception as e:
                 print(f"Expert {entry['id']} Failed: {e}")
@@ -100,7 +98,7 @@ def get_experts():
         torch.set_grad_enabled(False)
         gc.collect()
         
-    return GENERAL_EXPERT, PLANT_SPECIALIST, PEST_EXPERT
+    return GENERAL_EXPERT, PLANT_SPECIALIST, CEREAL_EXPERT
 
 def focalize_leaf(image_bytes):
     import numpy as np
@@ -151,12 +149,51 @@ def focalize_leaf(image_bytes):
         return Image.open(io.BytesIO(image_bytes)).convert('RGB'), 0.0
 
 # --- MAPPINGS ---
-# Generalist Map (Covers Rice, Corn, Wheat, Potato, Tomato, etc.)
+# Generalist Map (DeiT Anchor - 38 Classes)
 GENERALIST_MAP = {
     'Apple___Apple_scab': 'Apple - Scab',
     'Apple___Black_rot': 'Apple - Black Rot',
     'Apple___Cedar_apple_rust': 'Apple - Cedar Rust',
     'Apple___healthy': 'Apple - Healthy',
+    'Blueberry___healthy': 'Blueberry - Healthy',
+    'Cherry___Powdery_mildew': 'Cherry - Powdery Mildew',
+    'Cherry___healthy': 'Cherry - Healthy',
+    'Corn___Cercospora_leaf_spot Gray_leaf_spot': 'Corn - Gray Leaf Spot',
+    'Corn___Common_rust': 'Corn - Common Rust',
+    'Corn___Northern_Leaf_Blight': 'Corn - Northern Leaf Blight',
+    'Corn___healthy': 'Corn - Healthy',
+    'Grape___Black_rot': 'Grape - Black Rot',
+    'Grape___Esca_(Black_Measles)': 'Grape - Black Measles',
+    'Grape___Leaf_blight_(Isariopsis_Leaf_Spot)': 'Grape - Leaf Blight',
+    'Grape___healthy': 'Grape - Healthy',
+    'Orange___Haunglongbing_(Citrus_greening)': 'Orange - Citrus Greening',
+    'Peach___Bacterial_spot': 'Peach - Bacterial Spot',
+    'Peach___healthy': 'Peach - Healthy',
+    'Pepper,_bell___Bacterial_spot': 'Pepper - Bacterial Spot',
+    'Pepper,_bell___healthy': 'Pepper - Healthy',
+    'Potato___Early_blight': 'Potato - Early Blight',
+    'Potato___Late_blight': 'Potato - Late Blight',
+    'Potato___healthy': 'Potato - Healthy',
+    'Raspberry___healthy': 'Raspberry - Healthy',
+    'Soybean___healthy': 'Soybean - Healthy',
+    'Squash___Powdery_mildew': 'Squash - Powdery Mildew',
+    'Strawberry___Leaf_scorch': 'Strawberry - Leaf Scorch',
+    'Strawberry___healthy': 'Strawberry - Healthy',
+    'Tomato___Bacterial_spot': 'Tomato - Bacterial Spot',
+    'Tomato___Early_blight': 'Tomato - Early Blight',
+    'Tomato___Late_blight': 'Tomato - Late Blight',
+    'Tomato___Leaf_Mold': 'Tomato - Leaf Mold',
+    'Tomato___Septoria_leaf_spot': 'Tomato - Septoria Spot',
+    'Tomato___Spider_mites Two-spotted_spider_mite': 'Tomato - Spider Mite',
+    'Tomato___Target_Spot': 'Tomato - Target Spot',
+    'Tomato___Tomato_Yellow_Leaf_Curl_Virus': 'Tomato - Yellow Leaf Curl',
+    'Tomato___Tomato_mosaic_virus': 'Tomato - Mosaic Virus',
+    'Tomato___healthy': 'Tomato - Healthy',
+    'Background_without_leaves': 'INVALID'
+}
+
+# Cereal Specialist Map (Multi-Crop - Rice/Wheat/Corn)
+CEREAL_MAP = {
     'Corn___Common_Rust': 'Corn - Common Rust',
     'Corn___Gray_Leaf_Spot': 'Corn - Gray Leaf Spot',
     'Corn___Healthy': 'Corn - Healthy',
@@ -166,19 +203,10 @@ GENERALIST_MAP = {
     'Rice___Brown_Spot': 'Rice - Brown Spot',
     'Rice___Healthy': 'Rice - Healthy',
     'Rice___Leaf_Blast': 'Rice - Leaf Blast',
-    'Rice___Neck_Blast': 'Rice - Neck Blast',
-    'Tomato___Bacterial_Spot': 'Tomato - Bacterial Spot',
-    'Tomato___Early_Blight': 'Tomato - Early Blight',
-    'Tomato___Healthy': 'Tomato - Healthy',
-    'Tomato___Late_Blight': 'Tomato - Late Blight',
-    'Tomato___Leaf_Mold': 'Tomato - Leaf Mold',
-    'Tomato___Septoria_Leaf_Spot': 'Tomato - Septoria Spot',
-    'Tomato___Target_Spot': 'Tomato - Target Spot',
-    'Tomato___Yellow_Leaf_Curl_Virus': 'Tomato - Yellow Leaf Curl',
-    'Tomato___Mosaic_Virus': 'Tomato - Mosaic Virus',
     'Wheat___Brown_Rust': 'Wheat - Brown Rust',
     'Wheat___Healthy': 'Wheat - Healthy',
-    'Wheat___Yellow_Rust': 'Wheat - Yellow Rust'
+    'Wheat___Yellow_Rust': 'Wheat - Yellow Rust',
+    'Invalid': 'INVALID'
 }
 
 # Specialist Map (PlantVillage 38 Classes)
@@ -235,7 +263,7 @@ async def predict(
 ):
     try:
         # Load Experts
-        general_expert, plant_specialist, pest_expert = get_experts()
+        general_expert, plant_specialist, cereal_expert = get_experts()
         contents = await file.read()
         
         # Quality Check
@@ -243,72 +271,104 @@ async def predict(
         if image is None:
             return {"class": "UNKNOWN", "confidence": 0.0, "ai_details": "No leaf detected (too low plant density).", "status": "success"}
 
-        # STEP 1: Generalist Query (The "Broad Reach" model)
+        # STEP 1: Parallel Inference
+        # Generalist (ViT Anchor)
         gen_res = general_expert(image) if general_expert else []
+        # Specialist (Pathology Expert)
         spec_res = plant_specialist(image) if plant_specialist else []
-        pest_res = pest_expert(image) if pest_expert else []
-
-        best_prediction = {"class": "UNKNOWN", "score": 0.0, "expert": "none"}
+        # Cereal Expert (Fallback for Rice/Wheat)
+        cer_res = cereal_expert(image) if cereal_expert else []
 
-        # LOGIC:
-        # 1. If Generalist is VERY confident in a specific disease, trust it.
-        # 2. If Generalist detects a plant type but not sure of disease, ask Specialist.
-        # 3. If Specialist is confident in a known class, trust Specialist (it has better granularity for those 38).
-        # 4. If nothing is confident, try Pest.
+        # --- SPECIES CONSENSUS ENGINE ---
+        # We use the Generalist (ViT) to "anchor" the species because ViT is better at global shape.
         gen_class, gen_score = None, 0.0
         if gen_res:
             label = gen_res[0]['label']
-            if GENERALIST_MAP.get(label):
-                gen_class = GENERALIST_MAP.get(label)
-                gen_score = gen_res[0]['score']
+            gen_class = GENERALIST_MAP.get(label)
+            gen_score = gen_res[0]['score']
 
         spec_class, spec_score = None, 0.0
         if spec_res:
-            s_label = spec_res[0]['label']
-            if SPECIALIST_MAP.get(s_label):
-                spec_class = SPECIALIST_MAP.get(s_label)
-                spec_score = spec_res[0]['score']
+            # Anchor Logic: If Generalist is confident in a species, prioritize Specialist's labels from THAT species.
+            gen_species = gen_class.split(' - ')[0] if gen_class and gen_class != "INVALID" else None
+            
+            # --- HARDENED ANCHORING ---
+            best_spec_match = None
+            # Scan top 5 from specialist for a species match
+            for s in spec_res:
+                mapped = SPECIALIST_MAP.get(s['label'])
+                if mapped:
+                    spec_species = mapped.split(' - ')[0]
+                    # STRICK CONSTRAIN: If Anchor is very confident in a species, we ONLY accept that species from Specialist
+                    if gen_species and gen_score > 0.4:
+                        if spec_species == gen_species:
+                            best_spec_match = (mapped, s['score'])
+                            break
+                    else:
+                        # If anchor is weak, take the first mapped specialist result
+                        best_spec_match = (mapped, s['score'])
+                        break
+            
+            if best_spec_match:
+                spec_class, spec_score = best_spec_match
+
+        cer_class, cer_score = None, 0.0
+        if cer_res:
+            label = cer_res[0]['label']
+            cer_class = CEREAL_MAP.get(label)
+            cer_score = cer_res[0]['score']
 
+        # --- CONFLICT RESOLUTION ---
         best_prediction = {"class": "UNKNOWN", "score": 0.0, "expert": "none"}
 
-        # Conflict Resolution Engine:
-        best_prediction = None
-        
-        # Crops that the 38-class Specialist model is trained explicitly to handle.
-        # If Generalist thinks it's one of these, we completely defer to the Specialist's diagnosis.
-        specialist_crops = ["Tomato", "Potato", "Corn", "Apple", "Grape", "Peach", "Pepper", "Strawberry", "Cherry", "Blueberry", "Orange", "Raspberry", "Soybean", "Squash"]
-        
-        gen_crop_base = gen_class.split(' - ')[0] if gen_class else ""
+        # 1. Check for Background/Invalid rejection
+        if gen_class == "INVALID" and gen_score > 0.6:
+            return {"class": "INVALID", "confidence": gen_score, "ai_details": "Image identified as non-plant background.", "status": "success"}
 
+        # 2. Priority 1: Specialist/Generalist Hybrid (Most Crops)
         if gen_class and spec_class:
-            if gen_crop_base in specialist_crops:
-                 # AGGRESSIVE OVERRIDE: 38-class model probabilities are naturally spread thin. 
-                 # We do not require > 0.4 confidence if we know it's a Specialist crop.
-                 best_prediction = {"class": spec_class, "score": spec_score, "expert": "Specialist (Forced Override)"}
-            elif spec_score > 0.4:
-                 best_prediction = {"class": spec_class, "score": spec_score, "expert": "Specialist"}
-        
-        # If both failed the threshold but we got a valid response, return the highest scoring one anyway as fallback
-        if not best_prediction:
-            if spec_score > gen_score * 1.5:  # If specialist is very confident relatively
-               best_prediction = {"class": spec_class, "score": spec_score, "expert": "Specialist"}
+            gen_species = gen_class.split(' - ')[0] if gen_class != "INVALID" else None
+            spec_species = spec_class.split(' - ')[0]
+            
+            if gen_species == spec_species:
+                # AGREEMENT: Use whichever score is higher, boosted by consensus
+                best_prediction = {"class": spec_class, "score": max(gen_score, spec_score) * 1.05, "expert": "Consensus (ViT+MobileNet)"}
+            elif gen_score > 0.6:
+                # DISAGREEMENT BUT ANCHOR IS CONFIDENT: Trust Anchor species identify
+                # If we forced a spec_match above and it failed, spec_class might be mismatched.
+                # We prioritize Anchor here to fix the Tomato/Pepper confusion.
+                best_prediction = {"class": gen_class, "score": gen_score, "expert": "Vision Anchor Overrule"}
             else:
-               best_prediction = {"class": gen_class or "UNKNOWN", "score": gen_score or 0.0, "expert": "Generalist"}
-                      
+                # Low confidence consensus
+                if spec_score > gen_score:
+                    best_prediction = {"class": spec_class, "score": spec_score, "expert": "Pathology Specialist"}
+                else:
+                    best_prediction = {"class": gen_class, "score": gen_score, "expert": "Vision Anchor"}
         elif spec_class:
-            best_prediction = {"class": spec_class, "score": spec_score, "expert": "Specialist"}
+            best_prediction = {"class": spec_class, "score": spec_score, "expert": "Pathology Specialist"}
         elif gen_class:
-            best_prediction = {"class": gen_class, "score": gen_score, "expert": "Generalist"}
+            best_prediction = {"class": gen_class, "score": gen_score, "expert": "Vision Anchor"}
+
+        # 3. Priority 2: Cereal Specialist (Rice/Wheat)
+        if cer_class and "Rice" in cer_class or "Wheat" in cer_class:
+            if cer_score > 0.4 and cer_score > best_prediction['score']:
+                best_prediction = {"class": cer_class, "score": cer_score, "expert": "Cereal Specialist"}
+
+        # 4. Final Rejection for low confidence
+        if best_prediction['score'] < 0.15:
+             best_prediction = {"class": "UNKNOWN", "score": best_prediction['score'], "expert": "System Confidence Low"}
+
+        final_class = best_prediction['class']
+        print(f"Prediction: {final_class} ({best_prediction['score']*100:.1f}%) via {best_prediction['expert']}")
 
-        # Fallback: Pest expert
-        if pest_res:
-            p_score = pest_res[0]['score']
-            if p_score > 0.40 and p_score > best_prediction['score']:
-                best_prediction = {"class": f"Pest: {pest_res[0]['label']}", "score": p_score, "expert": "Entomology"}
+        log_scan(final_class, float(best_prediction['score']), latitude, longitude)
 
-        # Final Handling for "Random Images"
-        if best_prediction['score'] < 0.12:
-             best_prediction = {"class": "UNKNOWN", "score": best_prediction['score'], "expert": "System Rejection"}
+        return {
+            "class": final_class,
+            "confidence": min(float(best_prediction['score']), 1.0),
+            "ai_details": f"Analysis complete via {best_prediction['expert']} (Plant Density: {density:.1f}%)",
+            "status": "success"
+        }
 
         final_class = best_prediction['class']
         print(f"Prediction: {final_class} ({best_prediction['score']*100:.1f}%) via {best_prediction['expert']}")

backend/download_models.py

@@ -5,13 +5,20 @@ import os
 os.environ["TORCH_FORCE_WEIGHTS_ONLY_LOAD"] = "0"
 
 def download_models():
-    print("Downloading General Expert (Swin Transformer)...")
+    print("Downloading General Expert (DeiT Anchor)...")
     try:
-        pipeline("image-classification", model="microsoft/swin-tiny-patch4-window7-224")
+        pipeline("image-classification", model="rescu/deit-base-patch16-224-finetuned-plantvillage")
         print("General Expert Downloaded!")
     except Exception as e:
         print(f"General Expert Failed: {e}")
 
+    print("Downloading Legacy Swin Expert...")
+    try:
+        pipeline("image-classification", model="microsoft/swin-tiny-patch4-window7-224")
+        print("Legacy Swin Downloaded!")
+    except Exception as e:
+        print(f"Swin Expert Failed: {e}")
+
     print("Downloading Rice Expert (ViT)...")
     try:
         pipeline("image-classification", model="wambugu71/crop_leaf_diseases_vit")

backend/model_manifest.py

@@ -2,7 +2,8 @@ from datetime import datetime
 
 def get_seasonal_experts():
     experts = [
-        {"id": "generalist", "name": "Generalist Expert", "model": "wambugu71/crop_leaf_diseases_vit"},
-        {"id": "specialist", "name": "Plant Health Specialist", "model": "linkanjarad/mobilenet_v2_1.0_224-plant-disease-identification"}
+        {"id": "generalist", "name": "Vision Anchor (DeiT)", "model": "rescu/deit-base-patch16-224-finetuned-plantvillage"},
+        {"id": "specialist", "name": "Pathology Specialist", "model": "linkanjarad/mobilenet_v2_1.0_224-plant-disease-identification"},
+        {"id": "cereal", "name": "Cereal Specialist", "model": "wambugu71/crop_leaf_diseases_vit"}
     ]
     return experts

backend/verify_fix.py

@@ -0,0 +1,79 @@
+import sys
+import os
+
+# Mock dependencies for testing logic without loading weights
+class MockExpert:
+    def __init__(self, results):
+        self.results = results
+    def __call__(self, image):
+        return self.results
+
+def test_consensus():
+    # Simulate Tomato leaf with Bacterial Spot
+    # Specialist misidentifies as Pepper
+    spec_results = [
+        {'label': 'Bell Pepper with Bacterial Spot', 'score': 0.957},
+        {'label': 'Tomato with Bacterial Spot', 'score': 0.030}
+    ]
+    # Generalist (ViT) identifies as Tomato
+    gen_results = [
+        {'label': 'Tomato___Bacterial_spot', 'score': 0.88}
+    ]
+    
+    # Mappings (subset for test)
+    GENERALIST_MAP = {
+        'Tomato___Bacterial_spot': 'Tomato - Bacterial Spot',
+        'Pepper,_bell___Bacterial_spot': 'Pepper - Bacterial Spot'
+    }
+    SPECIALIST_MAP = {
+        "Bell Pepper with Bacterial Spot": "Pepper - Bacterial Spot",
+        "Tomato with Bacterial Spot": "Tomato - Bacterial Spot"
+    }
+
+    # Extract results
+    gen_class = GENERALIST_MAP.get(gen_results[0]['label'])
+    gen_score = gen_results[0]['score']
+    gen_species = gen_class.split(' - ')[0]
+
+    spec_class = None
+    spec_score = 0.0
+    best_spec_match = None
+    
+    # Anchor Logic
+    for s in spec_results:
+        mapped = SPECIALIST_MAP.get(s['label'])
+        if mapped:
+            spec_species = mapped.split(' - ')[0]
+            if gen_species and spec_species == gen_species:
+                best_spec_match = (mapped, s['score'])
+                break
+    
+    if not best_spec_match:
+        for s in spec_results:
+            if SPECIALIST_MAP.get(s['label']):
+                best_spec_match = (SPECIALIST_MAP.get(s['label']), s['score'])
+                break
+    
+    spec_class, spec_score = best_spec_match
+
+    print(f"Generalist says: {gen_class} ({gen_score})")
+    print(f"Specialist says: {spec_class} ({spec_score})")
+    
+    # Conflict Resolution
+    if gen_class and spec_class:
+        gen_species = gen_class.split(' - ')[0]
+        spec_species = spec_class.split(' - ')[0]
+        
+        if gen_species == spec_species:
+            res = {"class": spec_class, "score": max(gen_score, spec_score) * 1.05, "expert": "Consensus"}
+        elif gen_score > 0.7:
+            res = {"class": spec_class, "score": spec_score, "expert": "Vision Anchor Overrule"}
+        else:
+            res = {"class": spec_class if spec_score > gen_score else gen_class, "score": max(spec_score, gen_score)}
+            
+    print(f"FINAL RESULT: {res['class']} via {res['expert']}")
+    assert res['class'] == "Tomato - Bacterial Spot"
+    print("TEST PASSED: Consensus logic correctly chose Tomato even though Specialist preferred Pepper.")
+
+if __name__ == "__main__":
+    test_consensus()

raspberry_pi/app_streamlit.py

@@ -72,6 +72,9 @@ if interpreter:
     # Camera Control
     run_cam = st.toggle("Enable Camera", value=True)
     cap = cv2.VideoCapture(0)
+    
+    import requests
+    import io
 
     while run_cam:
         ret, frame = cap.read()
@@ -79,41 +82,43 @@ if interpreter:
             st.warning("Failed to access camera.")
             break
 
-        # 1. Preprocess
-        # Convert BGR (OpenCV) to RGB (Model Expectation)
-        img_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        img = cv2.resize(img_rgb, (width, height))
-        img = img.astype(np.float32) / 255.0
-        input_data = np.expand_dims(img, axis=0)
-
-        # 2. Predict
-        interpreter.set_tensor(input_details[0]['index'], input_data)
-        interpreter.invoke()
-        output_data = interpreter.get_tensor(output_details[0]['index'])
-        
-        pred_idx = np.argmax(output_data[0])
-        confidence = output_data[0][pred_idx]
-        
-        # 3. UI Update
-        label = "Searching..."
-        color = "white"
-        
-        if confidence > 0.4:
-            label = labels[pred_idx]
-            color = "green" if "Healthy" in label else "red"
-        
         # Display frame
         frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
         frame_placeholder.image(frame_rgb, channels="RGB")
-        
-        # Display Stats
-        res_placeholder.markdown(f"### Diagnosis: **:{color}[{label}]**")
-        conf_placeholder.progress(float(confidence), text=f"Confidence: {confidence*100:.1f}%")
-        
-        if color == "green":
-             status_placeholder.success("Plant looks healthy!")
-        elif color == "red":
-             status_placeholder.error("Warning: Disease potential detected.")
+
+        # 1. Prepare image for API
+        _, buffer = cv2.imencode('.jpg', frame)
+        img_bytes = buffer.tobytes()
+
+        # 2. Call Multi-Expert Backend
+        try:
+            # Point to local backend (assuming it's running on the same machine/network)
+            backend_url = "http://localhost:10000/predict"
+            response = requests.post(backend_url, files={"file": ("image.jpg", img_bytes, "image/jpeg")})
+            
+            if response.status_code == 200:
+                data = response.json()
+                label = data['class']
+                confidence = data['confidence']
+                ai_details = data.get('ai_details', 'Multi-Expert Analysis')
+                
+                color = "green" if "Healthy" in label else "red"
+                if label == "UNKNOWN" or label == "INVALID": color = "white"
+
+                # 3. UI Update
+                res_placeholder.markdown(f"### Diagnosis: **:{color}[{label}]**")
+                conf_placeholder.progress(float(confidence), text=f"Confidence: {confidence*100:.1f}%")
+                
+                if color == "green":
+                     status_placeholder.success(f"Plant looks healthy! ({ai_details})")
+                elif color == "red":
+                     status_placeholder.error(f"Warning: Disease detected! ({ai_details})")
+                else:
+                     status_placeholder.info(f"System: {label} ({ai_details})")
+            else:
+                status_placeholder.warning("Backend server not responding...")
+        except Exception as e:
+            status_placeholder.error(f"Connection Error: Ensure backend is running. ({e})")
 
     cap.release()
 else:

services/aiService.js

@@ -12,7 +12,7 @@ const HF_API_TOKEN = ""; // <-- PASTE YOUR HUGGING FACE TOKEN HERE
 const KINDWISE_API_URL = "https://api.plant.id/v2/health";
 const KINDWISE_API_TOKEN = ""; // <-- PASTE YOUR KINDWISE API KEY HERE (https://web.plant.id/)
 
-// Option C: Custom Backend (Hugging Face / Render)
+// Option C: Custom Backend (Hugging Face Production)
 const BACKEND_API_URL = "https://rhamprassath-greendoctor-backend.hf.space/predict";
 // ----------------------------------------------------------------------