Update app.py

app.py

@@ -2,49 +2,128 @@ import gradio as gr
 from ultralyticsplus import YOLO, render_result
 import cv2
 import time
+import torch
 
-# Load model
+# --------------------------
+# System Checks & Optimization
+# --------------------------
+print("\n" + "="*40)
+print("System Configuration Check:")
+print(f"PyTorch Version: {torch.__version__}")
+print(f"CUDA Available: {torch.cuda.is_available()}")
+print(f"CUDA Device Count: {torch.cuda.device_count()}")
+if torch.cuda.is_available():
+    print(f"Using GPU: {torch.cuda.get_device_name(0)}")
+else:
+    print("Using CPU - For better performance, consider using a GPU environment")
+print("="*40 + "\n")
+
+# --------------------------
+# Model Configuration
+# --------------------------
+# Load model with performance optimizations
 model = YOLO('foduucom/plant-leaf-detection-and-classification')
 
-# Model configuration
-model.overrides.update({
+# Configure model parameters
+model_params = {
     'conf': 0.25,
     'iou': 0.45,
     'imgsz': 640,
-    'device': '0' if next(model.model.parameters()).is_cuda else 'cpu'
-})
+    'device': 'cuda' if torch.cuda.is_available() else 'cpu',
+    'half': True if torch.cuda.is_available() else False  # FP16 acceleration
+}
+model.overrides.update(model_params)
+
+# Warmup model with dummy input
+print("Performing model warmup...")
+dummy_input = torch.randn(1, 3, 640, 640).to(model_params['device'])
+if model_params['half']:
+    dummy_input = dummy_input.half()
+model.predict(dummy_input, verbose=False)
+print("Model warmup complete!\n")
+
+# --------------------------
+# Image Processing Pipeline
+# --------------------------
+def preprocess_image(image):
+    """Optimized image preprocessing"""
+    # Convert RGB to BGR
+    img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    
+    # Resize maintaining aspect ratio
+    max_size = 1280
+    h, w = img.shape[:2]
+    scale = min(max_size/h, max_size/w)
+    img = cv2.resize(img, (int(w*scale), int(h*scale)), 
+                    interpolation=cv2.INTER_LINEAR)
+    return img
 
+# --------------------------
+# Detection Function
+# --------------------------
 def detect_leaves(image):
-    start_time = time.time()
+    try:
+        start_time = time.time()
+        
+        # Step 1: Preprocessing
+        preprocess_start = time.time()
+        img = preprocess_image(image)
+        print(f"Preprocessing time: {time.time() - preprocess_start:.2f}s")
+        
+        # Step 2: Prediction
+        predict_start = time.time()
+        results = model.predict(
+            source=img,
+            verbose=False,
+            stream=False,  # Disable streaming mode
+            augment=False   # Disable TTA for speed
+        )
+        print(f"Prediction time: {time.time() - predict_start:.2f}s")
+        
+        # Step 3: Postprocessing
+        postprocess_start = time.time()
+        num_leaves = len(results[0].boxes)
+        rendered_img = render_result(model=model, image=img, result=results[0])
+        rendered_img = cv2.cvtColor(rendered_img, cv2.COLOR_BGR2RGB)
+        print(f"Postprocessing time: {time.time() - postprocess_start:.2f}s")
+        
+        total_time = time.time() - start_time
+        print(f"\nTotal processing time: {total_time:.2f}s")
+        print(f"Detected leaves: {num_leaves}")
+        print("-"*50)
+        
+        return rendered_img, num_leaves
     
-    # Convert image format
-    img = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    except Exception as e:
+        print(f"Error processing image: {str(e)}")
+        return None, 0
+
+# --------------------------
+# Gradio Interface
+# --------------------------
+with gr.Blocks(title="Leaf Detection", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🍃 Real-Time Plant Leaf Detection")
+    gr.Markdown("Upload a plant image to analyze leaf count and health")
+    
+    with gr.Row():
+        input_image = gr.Image(label="Input Image", type="numpy")
+        output_image = gr.Image(label="Detection Results", width=600)
     
-    # Predict
-    results = model.predict(img, verbose=False)
+    with gr.Row():
+        leaf_count = gr.Number(label="Detected Leaves", precision=0)
+        process_btn = gr.Button("Analyze Image", variant="primary")
     
-    # Process results
-    num_leaves = len(results[0].boxes)
-    rendered_img = render_result(model=model, image=img, result=results[0])
+    progress = gr.Textbox(label="Processing Status", visible=True)
     
-    print(f"Processing time: {time.time() - start_time:.2f}s")
-    return cv2.cvtColor(rendered_img, cv2.COLOR_BGR2RGB), num_leaves
-
-# Create interface with queue support
-interface = gr.Interface(
-    fn=detect_leaves,
-    inputs=gr.Image(label="Plant Image"),
-    outputs=[
-        gr.Image(label="Detection Result", width=600),
-        gr.Number(label="Leaves Count")
-    ],
-    title="🍃 Leaf Detection",
-    flagging_mode="never"  # Updated from allow_flagging
-)
+    process_btn.click(
+        fn=detect_leaves,
+        inputs=[input_image],
+        outputs=[output_image, leaf_count]
+    )
 
 if __name__ == "__main__":
-    interface.launch(
+    demo.launch(
         server_port=7860,
-        share=False,
-        # Removed enable_queue parameter
+        show_error=True,
+        share=False
     )