Update app.py

app.py

@@ -1,60 +1,92 @@
 import os
-import gradio as gr
+import numpy as np
 import tensorflow as tf
-from tensorflow.keras.models import load_model
 from tensorflow.keras.preprocessing import image
-import numpy as np
+import gradio as gr
+
+# Suppress TensorFlow warnings
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+device = "cuda" if tf.test.is_gpu_available() else "cpu"
+print(f"Running on: {device.upper()}")
+
+# Load the trained tomato disease detection model
+model = tf.keras.models.load_model("Tomato_Leaf_Disease_Model.h5")
+
+# Disease categories
+class_labels = [
+    "Tomato Bacterial Spot",
+    "Tomato Early Blight",
+    "Tomato Late Blight",
+    "Tomato Mosaic Virus",
+    "Tomato Yellow Leaf Curl Virus"
+]
+
+# Image preprocessing function
+def preprocess_image(img):
+    img = img.resize((224, 224))  # Resize for model input
+    img = image.img_to_array(img) / 255.0  # Normalize
+    return np.expand_dims(img, axis=0)  # Add batch dimension
 
-# Ensure the environment is set up correctly (we assume CPU-based execution here)
-os.environ["CUDA_VISIBLE_DEVICES"] = "-1"  # Disable GPU to avoid the GPU-related warnings
-
-# Load the model
-def load_trained_model():
-    try:
-        # Ensure no custom arguments (like batch_shape) are passed during model loading
-        model = load_model('Tomato_Leaf_Disease_Model.h5', compile=True)
-        print("Model loaded successfully")
-        return model
-    except ValueError as e:
-        print(f"Error loading model: {e}")
-        raise
-
-model = load_trained_model()
-
-# Define the function to process the image and predict the disease
-def predict_disease(image_file):
-    try:
-        # Preprocess the image
-        img = image.load_img(image_file, target_size=(224, 224))  # Adjust size based on model input
-        img_array = image.img_to_array(img)
-        img_array = np.expand_dims(img_array, axis=0)  # Add batch dimension
-        img_array /= 255.0  # Normalize the image if required by the model
-
-        # Predict the class of the tomato leaf disease
-        predictions = model.predict(img_array)
-        
-        # Assuming the model returns probabilities, get the class with the highest probability
-        predicted_class = np.argmax(predictions, axis=1)[0]
-
-        # You can map the class index to the disease name if required
-        disease_classes = ['Bacterial_spot', 'Early_blight', 'Late_blight', 'Tomato_mosaic_virus', 'Tomato_Yellow_Leaf_Curl_Virus']
-        predicted_disease = disease_classes[predicted_class]
-
-        return predicted_disease
+# Temperature Scaling: Adjusts predictions using a temperature parameter.
+def apply_temperature_scaling(prediction, temperature):
+    # Avoid log(0) by adding a small epsilon
+    eps = 1e-8
+    scaled_logits = np.log(np.maximum(prediction, eps)) / temperature
+    exp_logits = np.exp(scaled_logits)
+    scaled_probs = exp_logits / np.sum(exp_logits)
+    return scaled_probs
+
+# Min-Max Normalization: Scales the raw confidence based on provided min and max values.
+def apply_min_max_scaling(confidence, min_conf, max_conf):
+    norm = (confidence - min_conf) / (max_conf - min_conf) * 100
+    norm = np.clip(norm, 0, 100)
+    return norm
+
+# Main detection function with adjustable confidence scaling
+def detect_disease_scaled(img, scaling_method, temperature, min_conf, max_conf):
+    processed_img = preprocess_image(img)
+    prediction = model.predict(processed_img)[0]  # Get prediction for single image
+    raw_confidence = np.max(prediction) * 100
+    class_idx = np.argmax(prediction)
+    disease_name = class_labels[class_idx]
     
-    except Exception as e:
-        print(f"Error during prediction: {e}")
-        return "Error during prediction"
-
-# Define Gradio interface
-iface = gr.Interface(
-    fn=predict_disease,
-    inputs=gr.inputs.Image(type="file"),
-    outputs="text",
-    title="Tomato Leaf Disease Detection",
-    description="Upload an image of a tomato leaf, and the model will predict the disease."
-)
-
-# Launch the Gradio interface
-if __name__ == '__main__':
-    iface.launch()
+    if scaling_method == "Temperature Scaling":
+        scaled_probs = apply_temperature_scaling(prediction, temperature)
+        adjusted_confidence = np.max(scaled_probs) * 100
+    elif scaling_method == "Min-Max Normalization":
+        adjusted_confidence = apply_min_max_scaling(raw_confidence, min_conf, max_conf)
+    else:
+        adjusted_confidence = raw_confidence
+
+    # Return both the adjusted result and the raw confidence value
+    result = f"{disease_name} (Confidence: {adjusted_confidence:.2f}%)"
+    raw_text = f"Raw Confidence: {raw_confidence:.2f}%"
+    return result, raw_text
+
+# Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# 🍅 Tomato Sentry: Disease Detection with Confidence Adjustment")
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(type="pil", label="Upload a Tomato Leaf Image")
+            scaling_method = gr.Radio(
+                ["Temperature Scaling", "Min-Max Normalization"],
+                label="Confidence Scaling Method",
+                value="Temperature Scaling"
+            )
+            temperature_slider = gr.Slider(0.5, 2.0, step=0.1, label="Temperature", value=1.0)
+            min_conf_slider = gr.Slider(0, 100, step=1, label="Min Confidence", value=20)
+            max_conf_slider = gr.Slider(0, 100, step=1, label="Max Confidence", value=90)
+            detect_button = gr.Button("Detect Disease")
+        with gr.Column():
+            disease_output = gr.Textbox(label="Detected Disease & Adjusted Confidence", interactive=False)
+            raw_confidence_output = gr.Textbox(label="Raw Confidence", interactive=False)
+    
+    detect_button.click(
+        detect_disease_scaled,
+        inputs=[image_input, scaling_method, temperature_slider, min_conf_slider, max_conf_slider],
+        outputs=[disease_output, raw_confidence_output]
+    )
+
+demo.launch()