Update app.py

app.py

@@ -1,78 +1,146 @@
+import os
 import gradio as gr
+import numpy as np
+import requests
+from tensorflow.keras.models import load_model
+from PIL import Image
 
-# ===== Dummy Model & Utility Functions =====
-# Model A (for versions 1.x)
-def model_A(image):
-    return "Model A predicts: [Example Disease A]"
+# ===== Hugging Face API Token =====
+HF_API_TOKEN = os.getenv("HF_API_TOKEN")  # Ensure this is set in your environment
 
-# Model B (for versions 2.x)
-def model_B(image):
-    return "Model B predicts: [Example Disease B]"
+# ===== Load Trained Models =====
+model_a = load_model("modela.h5")
+model_b = load_model("modelb.h5")
+classifier_model = load_model("classifier.h5")
 
-# Dummy classifier: Checks if image is a tomato leaf.
-def classifier(image):
-    # Replace with actual classification logic.
-    return "Tomato Leaf"
+# ===== Preprocessing Function =====
+def preprocess_image(image, target_size=(224, 224)):
+    # Ensure the image is resized and normalized.
+    if isinstance(image, Image.Image):
+        img = image.resize(target_size)
+    else:
+        img = Image.fromarray(image).resize(target_size)
+    img_array = np.array(img) / 255.0
+    img_array = np.expand_dims(img_array, axis=0)
+    return img_array
+
+# ===== Prediction Functions =====
+def predict_model_a(image):
+    img = preprocess_image(image)
+    pred = model_a.predict(img)
+    # Replace with your own mapping from predictions to disease names.
+    return "Disease A detected" if np.argmax(pred) == 1 else "No disease"
+
+def predict_model_b(image):
+    img = preprocess_image(image)
+    pred = model_b.predict(img)
+    return "Disease B detected" if np.argmax(pred) == 1 else "No disease"
+
+def predict_classifier(image):
+    img = preprocess_image(image)
+    pred = classifier_model.predict(img)
+    # Assume classifier returns class 1 for a tomato leaf.
+    return "Tomato Leaf" if np.argmax(pred) == 1 else "Not Tomato Leaf"
+
+# ===== Hugging Face Inference API Calls =====
+def call_llama2(prompt):
+    """Call the Llama 2-7B Chat model on Hugging Face for conversational advice."""
+    headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 100}}
+    url = "https://api-inference.huggingface.co/models/meta-llama/Llama-2-7b-chat-hf"
+    response = requests.post(url, headers=headers, json=payload)
+    if response.status_code == 200:
+        result = response.json()
+        if isinstance(result, list) and "generated_text" in result[0]:
+            return result[0]["generated_text"]
+        else:
+            return "No response from Llama 2."
+    else:
+        return f"Error calling Llama 2 API: {response.status_code}"
 
-# Dummy AI assistants for each model type.
+def call_openassistant(prompt):
+    """Call an OpenAssistant model on Hugging Face for conversational advice."""
+    headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+    payload = {"inputs": prompt, "parameters": {"max_new_tokens": 100}}
+    url = "https://api-inference.huggingface.co/models/OpenAssistant/oasst-sft-7-llama"
+    response = requests.post(url, headers=headers, json=payload)
+    if response.status_code == 200:
+        result = response.json()
+        if isinstance(result, list) and "generated_text" in result[0]:
+            return result[0]["generated_text"]
+        else:
+            return "No response from OpenAssistant."
+    else:
+        return f"Error calling OpenAssistant API: {response.status_code}"
+
+# ===== AI Assistant Functions =====
 def ai_assistant_v1(image, prediction):
-    return "Advice from AI Assistant v1: Ensure proper irrigation and pest monitoring."
+    # Use Llama 2-7B Chat (Model A version)
+    if "No disease" in prediction:
+        prompt = ("You are an agricultural advisor. The tomato crop appears healthy. "
+                  "Provide additional preventive tips and good practices for maintaining crop health.")
+    else:
+        prompt = (f"You are an agricultural advisor. A disease has been detected: {prediction}. "
+                  "Provide detailed advice on how to manage and curb this disease, and explain more about it in simple terms.")
+    return call_llama2(prompt)
 
 def ai_assistant_v2(image, prediction):
-    return "Advice from AI Assistant v2: Consider organic pesticides and crop rotation."
+    # Use OpenAssistant (Model B version)
+    if "No disease" in prediction:
+        prompt = ("You are an agricultural advisor. The tomato crop appears healthy. "
+                  "Offer additional preventive tips and guidelines for maintaining a healthy crop.")
+    else:
+        prompt = (f"You are an agricultural advisor. A disease has been detected: {prediction}. "
+                  "Provide actionable steps and detailed advice on how to control and manage this disease in tomato crops.")
+    return call_openassistant(prompt)
 
-# ===== Process Function for Versioned Logic =====
+# ===== Process Function Based on Version =====
 def process_version(image, version):
     if image is None:
         return "No image provided."
     
     # --- Version 1.x (Model A) ---
     if version == "1.1":
-        # Model A only + link to notebook
-        result = model_A(image)
+        result = predict_model_a(image)
         return f"Model A Prediction: {result}\n\n[View Model A Training Notebook](https://huggingface.co/your-model-a-notebook)"
     
     elif version == "1.2":
-        # Model A + AI Assistant
-        result = model_A(image)
+        result = predict_model_a(image)
         advice = ai_assistant_v1(image, result)
         return f"Model A Prediction: {result}\nAdvice: {advice}"
     
     elif version == "1.3":
-        # Classifier + Model A + AI Assistant
-        cls_result = classifier(image)
+        cls_result = predict_classifier(image)
         if cls_result != "Tomato Leaf":
             return "Classifier: The image is not a tomato leaf. Please try again."
-        result = model_A(image)
+        result = predict_model_a(image)
         advice = ai_assistant_v1(image, result)
         return (f"Classifier: {cls_result}\nModel A Prediction: {result}\nAdvice: {advice}\n\n"
                 f"[View Model A & Classifier Training Notebook](https://huggingface.co/your-model-a-classifier-notebook)")
     
     # --- Version 2.x (Model B) ---
     elif version == "2.1":
-        # Model B only + link to notebook
-        result = model_B(image)
+        result = predict_model_b(image)
         return f"Model B Prediction: {result}\n\n[View Model B Training Notebook](https://huggingface.co/your-model-b-notebook)"
     
     elif version == "2.2":
-        # Model B + AI Assistant
-        result = model_B(image)
+        result = predict_model_b(image)
         advice = ai_assistant_v2(image, result)
         return f"Model B Prediction: {result}\nAdvice: {advice}"
     
     elif version == "2.3":
-        # Classifier + Model B + AI Assistant
-        cls_result = classifier(image)
+        cls_result = predict_classifier(image)
         if cls_result != "Tomato Leaf":
             return "Classifier: The image is not a tomato leaf. Please try again."
-        result = model_B(image)
+        result = predict_model_b(image)
         advice = ai_assistant_v2(image, result)
         return (f"Classifier: {cls_result}\nModel B Prediction: {result}\nAdvice: {advice}\n\n"
                 f"[View Model B & Classifier Training Notebook](https://huggingface.co/your-model-b-classifier-notebook)")
+    
     else:
         return "Invalid version selected."
 
-# ===== Helper to Select Between Uploaded & Camera Image =====
+# ===== Helper Function to Choose Between Uploaded & Camera Image =====
 def combine_images(uploaded, camera):
     return camera if camera is not None else uploaded
 
@@ -99,11 +167,11 @@ def update_css(theme):
 
 # ===== Gradio Interface =====
 with gr.Blocks() as demo:
-    # Hidden element for injecting CSS (initially Light theme)
+    # Hidden element for CSS injection (initially Light theme)
     css_injector = gr.HTML(update_css("Light"))
     
     gr.Markdown("# 🌿 FarmVi8ion – AI-powered Crop Monitoring")
-    gr.Markdown("Detect tomato leaf diseases and get AI-driven advice for your crops.")
+    gr.Markdown("Detect tomato leaf diseases and get actionable advice on how to curb them.")
     
     with gr.Row():
         # ----- Left Column (≈30%) -----
@@ -131,13 +199,12 @@ with gr.Blocks() as demo:
                 - Model B & Classifier: [Training Notebook](https://huggingface.co/your-model-b-classifier-notebook)
                 """
             )
-        
         # ----- Right Column (≈70%) -----
         with gr.Column(scale=2):
             image_input = gr.Image(
                 label="📂 Upload Tomato Leaf Image", 
                 type="pil",
-                tool="editor"  # enables basic image editing (crop, zoom, rotate)
+                tool="editor"  # Enables cropping, zooming, and rotating.
             )
             camera_input = gr.Image(
                 label="📸 Use Camera (Live Preview)", 
@@ -147,10 +214,10 @@ with gr.Blocks() as demo:
     
     output = gr.Textbox(label="📝 Diagnosis & Advice", lines=8)
     
-    # Update CSS dynamically based on theme choice
+    # Update CSS dynamically based on theme selection.
     theme_choice.change(fn=update_css, inputs=theme_choice, outputs=css_injector)
     
-    # Process image on submit (combining uploaded & camera image)
+    # When submit is clicked, combine image inputs and process the selected version.
     submit.click(
         fn=lambda uploaded, camera, ver: process_version(combine_images(uploaded, camera), ver),
         inputs=[image_input, camera_input, version],