Update app.py

remove mock implementation, local and hf model loading

ui/app.py

@@ -9,61 +9,28 @@ import sys
 from pathlib import Path
 import json
 from datetime import datetime
-
 # Add current directory to path
 sys.path.append(str(Path(__file__).parent))
 sys.path.append(str(Path(__file__).parent.parent))
 
-import config
 from model_loader import ModelLoader
-from utils import (
-    preprocess_image,
-    postprocess_predictions,
-    format_class_name,
-    get_disease_info,
-    batch_preprocess_images
-)
-from models.mock_model import create_mock_predictions
 
 
 class PlantDiseaseApp:
-    """
-    Main application class for Plant Disease Detection
-    """
-
-    def __init__(self, use_mock=True):
-        """
-        Initialize the application
-
-        Args:
-            use_mock: Whether to use mock model for development
-        """
-        self.use_mock = use_mock
-        self.model_loader = ModelLoader(use_mock=use_mock)
-        self.current_model_name = "CNN from Scratch"
-        self.model = self.model_loader.load_model(self.current_model_name)
+    def __init__(self):
+        self.model_loader = ModelLoader()
+        self.current_modelName = "CNN from Scratch"
+        self.model = self.model_loader.loadModel(self.current_modelName)
         self.flagged_predictions = []
 
-    def predict(self, image, model_name, confidence_threshold):
-        """
-        Make prediction on a single image
-
-        Args:
-            image: Input image
-            model_name: Name of model to use
-            confidence_threshold: Minimum confidence to display
-
-        Returns:
-            Predictions, formatted info, and detailed results
-        """
+    def predict(self, image, modelName, confidence_threshold):
         if image is None:
             return None, "Please upload an image", ""
 
         try:
-            # Switch model if needed
-            if model_name != self.current_model_name:
-                self.model = self.model_loader.load_model(model_name)
-                self.current_model_name = model_name
+            if modelName != self.current_modelName:
+                self.model = self.model_loader.loadModel(modelName)
+                self.current_modelName = modelName
 
             # Preprocess image
             tensor = preprocess_image(image)
@@ -71,12 +38,7 @@ class PlantDiseaseApp:
 
             # Get prediction
             with torch.no_grad():
-                if self.use_mock:
-                    # Use mock predictions for development
-                    predictions = create_mock_predictions(config.CLASS_NAMES)
-                    logits = torch.tensor([list(predictions.values())])
-                else:
-                    logits = self.model(tensor)
+                logits = self.model(tensor)
 
             # Postprocess
             top_predictions, all_predictions = postprocess_predictions(
@@ -113,101 +75,11 @@ class PlantDiseaseApp:
         except Exception as e:
             return None, f"Error during prediction: {str(e)}", ""
 
-    def predict_batch(self, files, model_name, confidence_threshold):
-        """
-        Make predictions on multiple images
-
-        Args:
-            files: List of uploaded files
-            model_name: Name of model to use
-            confidence_threshold: Minimum confidence to display
-
-        Returns:
-            Results for each image
-        """
-        if not files:
-            return "Please upload at least one image"
-
-        results = []
-        for i, file in enumerate(files):
-            try:
-                # Get predictions for this image
-                preds, info, _ = self.predict(file, model_name, confidence_threshold)
-
-                if preds:
-                    top_class = max(preds.items(), key=lambda x: x[1])[0]
-                    top_prob = preds[top_class]
-                    results.append(f"**Image {i+1}:** {top_class} ({top_prob*100:.2f}%)")
-                else:
-                    results.append(f"**Image {i+1}:** No prediction")
-
-            except Exception as e:
-                results.append(f"**Image {i+1}:** Error - {str(e)}")
-
-        return "\n\n".join(results)
-
-    def flag_prediction(self, image, prediction, user_feedback):
-        """
-        Flag a prediction as incorrect
-
-        Args:
-            image: The input image
-            prediction: The model's prediction
-            user_feedback: User's feedback text
-
-        Returns:
-            Confirmation message
-        """
-        if image is None:
-            return "No image to flag"
-
-        flag_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "prediction": prediction,
-            "feedback": user_feedback
-        }
-
-        self.flagged_predictions.append(flag_entry)
-
-        # In a real deployment, you would save this to a file or database
-        # For now, we'll just keep it in memory
-        return f"Thank you! Flagged prediction #{len(self.flagged_predictions)}"
-
-    def get_example_images(self):
-        """
-        Get list of example images from examples directory
-
-        Returns:
-            List of example image paths
-        """
-        examples_dir = Path(__file__).parent / "examples"
-
-        if not examples_dir.exists():
-            return []
-
-        # Get all image files
-        image_extensions = ['.jpg', '.jpeg', '.png']
-        examples = []
 
-        for ext in image_extensions:
-            examples.extend(list(examples_dir.glob(f"*{ext}")))
 
-        return [str(path) for path in examples[:10]]  # Return max 10 examples
+def create_interface():
+    app = PlantDiseaseApp()
 
-
-def create_interface(use_mock=True):
-    """
-    Create the Gradio interface
-
-    Args:
-        use_mock: Whether to use mock model
-
-    Returns:
-        Gradio Blocks interface
-    """
-    app = PlantDiseaseApp(use_mock=use_mock)
-
-    # Custom CSS for better styling
     custom_css = """
     .main-header {
         text-align: center;
@@ -231,7 +103,7 @@ def create_interface(use_mock=True):
         gr.Markdown(
             """
             <div class="main-header">
-                <h1>🌱 Plant Disease Detection System</h1>
+                <h1>Plant Disease Detection System</h1>
                 <p>Upload a plant leaf image to detect diseases using AI</p>
             </div>
             """
@@ -304,7 +176,6 @@ def create_interface(use_mock=True):
                     outputs=flag_output
                 )
 
-            # Tab 2: Example Gallery
             with gr.Tab("Example Images"):
                 gr.Markdown("### Try these example plant images")
                 gr.Markdown("Click on an example below to load it into the predictor")
@@ -329,7 +200,6 @@ def create_interface(use_mock=True):
                         """
                     )
 
-            # Tab 3: Batch Processing
             with gr.Tab("Batch Processing"):
                 gr.Markdown("### Upload multiple images for batch processing")
 
@@ -348,8 +218,6 @@ def create_interface(use_mock=True):
                     inputs=[batch_input, model_selector, confidence_slider],
                     outputs=batch_output
                 )
-
-            # Tab 4: About
             with gr.Tab("About"):
                 gr.Markdown(
                     """
@@ -389,12 +257,11 @@ def create_interface(use_mock=True):
                     """
                 )
 
-        # Footer
         gr.Markdown(
             """
             ---
             **Note:** This is an AI-powered system and predictions should be verified by experts.
-            Built with ❤️ by KCL AI Students
+            Built with love by KCL AI Students
             """
         )
 
@@ -402,15 +269,12 @@ def create_interface(use_mock=True):
 
 
 if __name__ == "__main__":
-    # Create and launch the app
     print("Starting Plant Disease Detection App...")
 
-    # Use mock=True for development, mock=False when you have real models
-    demo = create_interface(use_mock=True)
+    demo = create_interface()
 
-    # Launch the app
     demo.launch(
-        share=False,  # Set to True to create a public link
-        server_name="0.0.0.0",  # Makes it accessible on your network
+        share=False,
+        server_name="0.0.0.0",
         server_port=7860
     )