Update app.py

app.py

@@ -1,115 +1,78 @@
 import streamlit as st
 import numpy as np
-import tensorflow as tf  # "tf" is not accessed
-from PIL import Image, ImageDraw
-import gdown
+import tensorflow as tf
 from tensorflow.keras.models import load_model
+from PIL import Image
+import requests
+import tempfile
 import os
 
-# Set page configuration (must be the first Streamlit command)
-st.set_page_config(
-    page_title="Yellow Rust Disease Classification",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Function to download the model
-def download_model_from_drive(file_id, output_path):
-    try:
-        if not os.path.exists(output_path):
-            gdown.download(f"https://drive.google.com/uc?id={file_id}", output_path, quiet=False)
-        else:
-            st.info("Model already downloaded.")
-    except Exception as e:
-        st.error(f"Error downloading model: {e}")
-
-# Define Google Drive file ID and local model path
-file_id = "1EnokggrC6ymrSibtj2t7IHWb9QVtrehS"  # Replace with your Google Drive file ID
-model_path = "my_model.keras"
-
-# Streamlit app
-st.title("Streamlit App with Pretrained Model")
-
-# Download model from Google Drive
-st.write("Downloading model from Google Drive...")
-download_model_from_drive(file_id, model_path)
-
-# Load the model
-if os.path.exists(model_path):
-    st.write("Loading model...")
-    try:
-        model = load_model(model_path, compile=False)
-        st.success("Model loaded successfully!")
-        st.write(model.summary())
-    except Exception as e:
-        st.error(f"Error loading model: {e}")
-else:
-    st.error("Model file not found.")
-
-# Theme selection
-st.sidebar.title("Settings and Preferences")
-theme = st.sidebar.selectbox("Select Theme", ["Light", "Dark"])
-if theme == "Dark":
-    st.markdown(
-        "<style>body { background-color: #0e1117; color: white; }</style>",
-        unsafe_allow_html=True,
-    )
-
-# Title
-st.title("Yellow Rust Disease Classification Dashboard")
-
-# User Input Section
-st.sidebar.header("Upload Image of Plant Leaf")
-image_file = st.sidebar.file_uploader("Upload an Image", type=["jpg", "png", "jpeg"])
-
-if image_file:
-    st.subheader("Uploaded Image")
-    image = Image.open(image_file)
-    st.image(image, caption="Uploaded Image", use_column_width=True)
-
-    # Preprocess the image for prediction
-    def preprocess_image(img):
-        img = img.resize((224, 224))  # Adjust to model input size
-        img_array = np.array(img) / 255.0  # Normalize
-        return np.expand_dims(img_array, axis=0)  # Add batch dimension
-
-    processed_image = preprocess_image(image)
-
-    # Prediction Results
-    predictions = model.predict(processed_image, batch_size=1)
-    class_names = ["0", "MR", "MRMS", "MS", "R", "S"]  # Replace with actual class labels from dataset
+def download_model_from_gdrive():
+    """Downloads the model from Google Drive."""
+    gdrive_url = "https://drive.google.com/uc?id=1EnokggrC6ymrSibtj2t7IHWb9QVtrehS"
+    output_path = "final_meta_model.keras"
+
+    with requests.get(gdrive_url, stream=True) as r:
+        r.raise_for_status()
+        with open(output_path, "wb") as f:
+            for chunk in r.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+    return output_path
+
+def load_or_download_model():
+    """Loads the model from Hugging Face or Google Drive."""
+    hf_model_path = "final_meta_model.keras"
+
+    # Check if model exists locally (from Hugging Face Space storage)
+    if os.path.exists(hf_model_path):
+        model = load_model(hf_model_path)
+    else:
+        st.write("Model not found locally. Downloading from Google Drive...")
+        model_path = download_model_from_gdrive()
+        model = load_model(model_path)
+
+    return model
+
+def preprocess_image(image):
+    """Preprocesses the uploaded image for model prediction."""
+    image = image.resize((224, 224))  # Assuming input size of 224x224 for the model
+    image_array = np.array(image)
+    image_array = image_array / 255.0  # Normalize pixel values to [0, 1]
+    image_array = np.expand_dims(image_array, axis=0)  # Add batch dimension
+    return image_array
+
+def predict_severity(model, image):
+    """Predicts the severity using the model."""
+    predictions = model.predict(image)
+    class_names = ['0', 'MR', 'MRMS', 'MS', 'R', 'S']
     predicted_class = class_names[np.argmax(predictions)]
-    confidence = np.max(predictions) * 100
+    return predicted_class, predictions
 
-    st.header("Prediction Results")
-    st.write(f"**Predicted Status:** {predicted_class}")
-    st.write(f"**Confidence Level:** {confidence:.2f}%")
+# Streamlit App
+st.title("Disease Severity Prediction App")
+st.write("Upload an image to predict the severity of the disease.")
 
-    # Severity Level
-    severity = "High" if confidence > 80 else "Moderate" if confidence > 50 else "Low"
-    st.write(f"**Severity Level:** {severity}")
+# Image Upload
+uploaded_image = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
 
-    # Highlighting a region (Example: bounding box)
-    st.subheader("Highlighted Regions")
-    draw = ImageDraw.Draw(image)
-    # Example bounding box coordinates, adjust as necessary
-    draw.rectangle([50, 50, 150, 150], outline="red", width=3)  # Example bounding box
-    st.image(image, caption="Highlighted Regions", use_column_width=True)
+if uploaded_image:
+    st.image(uploaded_image, caption="Uploaded Image", use_column_width=True)
 
-    # Disease Insights
-    st.header("Disease Insights")
-    for i, class_name in enumerate(class_names):
-        st.write(f"{class_name}: {predictions[0][i] * 100:.2f}%")
+    # Load model
+    with st.spinner("Loading model..."):
+        model = load_or_download_model()
 
-    # Model Performance Metrics (Admin Only)
-    if st.checkbox("Show Model Performance Metrics (Admin Only)"):
-        st.write("**Accuracy:** 95.6%")  # Replace with actual metric
-        st.write("**Precision:** 94.7%")  # Replace with actual metric
-        st.write("**Recall:** 93.5%")  # Replace with actual metric
+    # Preprocess image
+    image = Image.open(uploaded_image)
+    preprocessed_image = preprocess_image(image)
 
-    # User Notifications
-    if severity == "High":
-        st.warning("High severity detected! Immediate action is recommended.")
+    # Predict severity
+    with st.spinner("Predicting severity..."):
+        predicted_class, prediction_scores = predict_severity(model, preprocessed_image)
 
-# Footer
-st.sidebar.info("Powered by Streamlit and TensorFlow")
+    # Display results
+    st.success(f"Predicted Class: {predicted_class}")
+    st.write("Prediction Scores:")
+    for class_name, score in zip(['0', 'MR', 'MRMS', 'MS', 'R', 'S'], prediction_scores[0]):
+        st.write(f"{class_name}: {score:.4f}")