Fix: Use ultralytics YOLO API instead of DetectMultiBackend to avoid export module dependency

webapp/backend/main.py

@@ -24,24 +24,16 @@ from fastapi.responses import JSONResponse, HTMLResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from PIL import Image
 
-# YOLOv5 imports - Load from local directory
+# YOLOv5 imports - Use ultralytics package (more reliable for deployment)
 import sys
 
-# Add parent yolov5 directory to path
-YOLOV5_ROOT = Path(__file__).resolve().parents[2]
-if str(YOLOV5_ROOT) not in sys.path:
-    sys.path.insert(0, str(YOLOV5_ROOT))
-
-# Import YOLOv5 modules
+# Import YOLOv5 via ultralytics package
 try:
-    from models.common import DetectMultiBackend
-    from utils.general import non_max_suppression, scale_boxes, check_img_size
-    from utils.torch_utils import select_device
-    from utils.augmentations import letterbox
+    from ultralytics import YOLO
     YOLOV5_AVAILABLE = True
-    print("✅ Modules YOLOv5 importés avec succès")
+    print("✅ Ultralytics YOLO importé avec succès")
 except Exception as e:
-    print(f"❌ Erreur d'import YOLOv5: {e}")
+    print(f"❌ Erreur d'import Ultralytics: {e}")
     YOLOV5_AVAILABLE = False
 
 # Initialize FastAPI app
@@ -188,34 +180,34 @@ manager = ConnectionManager()
 
 
 def load_model(model_name: str = "yolov5s"):
-    """Load YOLOv5 model from local files"""
+    """Load YOLOv5 model using ultralytics"""
     global device
     
     if not YOLOV5_AVAILABLE:
-        raise Exception("YOLOv5 non disponible - vérifiez l'installation")
+        raise Exception("Ultralytics YOLO non disponible - vérifiez l'installation")
     
     # Initialize device on first load
     if device is None:
-        device = select_device('')
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
         print(f"📊 Device sélectionné: {device}")
     
     if model_name not in models_cache:
         try:
             print(f"🔄 Chargement du modèle {model_name}...")
             
-            # Path to model weights
-            model_path = YOLOV5_ROOT / f"{model_name}.pt"
-            
-            if not model_path.exists():
-                print(f"⚠️  {model_path} non trouvé, utilisation de yolov5s.pt")
-                model_path = YOLOV5_ROOT / "yolov5s.pt"
-            
-            if not model_path.exists():
-                raise FileNotFoundError(f"Modèle non trouvé: {model_path}. Téléchargez-le depuis https://github.com/ultralytics/yolov5/releases")
+            # Try to load from local file first
+            model_path = f"/app/{model_name}.pt"
             
-            # Load model using DetectMultiBackend
-            model = DetectMultiBackend(str(model_path), device=device, dnn=False, fp16=False)
-            model.eval()
+            if not os.path.exists(model_path):
+                # Try in root directory
+                model_path = f"{model_name}.pt"
+                
+            if not os.path.exists(model_path):
+                # Download from ultralytics hub
+                print(f"⚠️  {model_path} non trouvé, téléchargement depuis ultralytics...")
+                model = YOLO(f"{model_name}.pt")
+            else:
+                model = YOLO(model_path)
             
             models_cache[model_name] = model
             print(f"✅ Modèle {model_name} chargé avec succès!")
@@ -234,60 +226,40 @@ def load_model(model_name: str = "yolov5s"):
 
 
 def process_image(image: Image.Image, model_name: str = "yolov5s", conf_threshold: float = 0.25):
-    """Process image and return detections"""
+    """Process image and return detections using ultralytics API"""
     start_time = time.time()
     
     try:
         # Load model
         model = load_model(model_name)
         
-        # Prepare image
-        img = np.array(image)
-        
-        # Handle different image formats
-        if img.ndim == 2:  # Grayscale
-            img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
-        elif img.shape[2] == 4:  # RGBA
-            img = cv2.cvtColor(img, cv2.COLOR_RGBA2RGB)
-        
-        img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-        
-        # Resize and letterbox
-        img_size = 640
-        h0, w0 = img_bgr.shape[:2]
-        r = img_size / max(h0, w0)
-        if r != 1:
-            img_bgr = cv2.resize(img_bgr, (int(w0 * r), int(h0 * r)), interpolation=cv2.INTER_LINEAR)
-        
-        # Letterbox
-        img_letter, ratio, (dw, dh) = letterbox(img_bgr, img_size, auto=False, scaleup=True)
-        
-        # Convert to tensor
-        img_tensor = torch.from_numpy(img_letter).to(device)
-        img_tensor = img_tensor.permute(2, 0, 1).float() / 255.0
-        if img_tensor.ndimension() == 3:
-            img_tensor = img_tensor.unsqueeze(0)
-        
-        # Inference
-        with torch.no_grad():
-            pred = model(img_tensor)
+        # Convert PIL to numpy array
+        img_array = np.array(image)
         
-        # NMS avec seuil IoU plus élevé pour éviter doublons
-        pred = non_max_suppression(pred, conf_threshold, 0.50, classes=None, agnostic=False, max_det=300)
+        # Run inference using ultralytics API
+        results = model(img_array, conf=conf_threshold, iou=0.45, verbose=False)
         
-        # Process detections
+        # Process results
         detections = []
-        img_display = img.copy()  # RGB image for display
+        img_display = img_array.copy()
         
-        if pred[0] is not None and len(pred[0]) > 0:
-            # Scale boxes back to original image
-            pred[0][:, :4] = scale_boxes(img_tensor.shape[2:], pred[0][:, :4], img_display.shape).round()
+        # Get the first result (single image)
+        result = results[0]
+        
+        if result.boxes is not None and len(result.boxes) > 0:
+            boxes = result.boxes
             
-            for *xyxy, conf, cls in pred[0]:
-                x1, y1, x2, y2 = [int(x.item()) for x in xyxy]
-                confidence = float(conf.item())
-                class_id = int(cls.item())
-                class_name_en = model.names[class_id]
+            for i in range(len(boxes)):
+                # Get box coordinates (xyxy format)
+                box = boxes.xyxy[i].cpu().numpy()
+                x1, y1, x2, y2 = map(int, box)
+                
+                # Get confidence and class
+                confidence = float(boxes.conf[i].cpu().numpy())
+                class_id = int(boxes.cls[i].cpu().numpy())
+                
+                # Get class name
+                class_name_en = result.names[class_id]
                 class_name = CLASS_NAMES_FR.get(class_name_en, class_name_en)
                 
                 detections.append({
@@ -297,7 +269,7 @@ def process_image(image: Image.Image, model_name: str = "yolov5s", conf_threshol
                     "class_id": class_id
                 })
                 
-                # Draw on image (RGB)
+                # Draw on image
                 cv2.rectangle(img_display, (x1, y1), (x2, y2), (0, 255, 0), 2)
                 label = f"{class_name} {confidence:.2f}"
                 (label_w, label_h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)
@@ -332,6 +304,12 @@ def process_image(image: Image.Image, model_name: str = "yolov5s", conf_threshol
             "processing_time": time.time() - start_time,
             "timestamp": datetime.now().isoformat()
         }
+        return {
+            "detections": [],
+            "image": image,
+            "processing_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
 
 
 def update_statistics(detections: List[dict], processing_time: float):