Upload 4 files

app.py

@@ -0,0 +1,284 @@
+"""
+🎯 Application Gradio pour YOLOv3 Object Detection - Pascal VOC
+Déployée sur Hugging Face Spaces
+"""
+
+import gradio as gr
+import torch
+import cv2
+import numpy as np
+from PIL import Image
+from huggingface_hub import hf_hub_download
+import os
+
+# Configuration
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+IMAGE_SIZE = 416
+NUM_CLASSES = 20
+
+# Anchors YOLOv3 (normalisés)
+ANCHORS = [
+    [(0.28, 0.22), (0.38, 0.48), (0.9, 0.78)],
+    [(0.07, 0.15), (0.15, 0.11), (0.14, 0.29)],
+    [(0.02, 0.03), (0.04, 0.07), (0.08, 0.06)],
+]
+
+S = [IMAGE_SIZE // 32, IMAGE_SIZE // 16, IMAGE_SIZE // 8]
+
+# Classes Pascal VOC
+PASCAL_CLASSES = [
+    "aeroplane", "bicycle", "bird", "boat", "bottle",
+    "bus", "car", "cat", "chair", "cow",
+    "diningtable", "dog", "horse", "motorbike", "person",
+    "pottedplant", "sheep", "sofa", "train", "tvmonitor"
+]
+
+# Import du modèle
+from model import YOLOv3
+from utils import cells_to_bboxes, non_max_suppression
+
+
+class YOLOv3Detector:
+    def __init__(self, checkpoint_path):
+        """Initialise le détecteur YOLOv3"""
+        print(f"🔧 Device: {DEVICE}")
+        
+        # Charger le modèle
+        self.model = YOLOv3(num_classes=NUM_CLASSES).to(DEVICE)
+        checkpoint = torch.load(checkpoint_path, map_location=DEVICE)
+        self.model.load_state_dict(checkpoint["state_dict"])
+        self.model.eval()
+        
+        # Anchors mis à l'échelle
+        self.scaled_anchors = (
+            torch.tensor(ANCHORS)
+            * torch.tensor(S).unsqueeze(1).unsqueeze(1).repeat(1, 3, 2)
+        ).to(DEVICE)
+        
+        # Couleurs pour chaque classe
+        np.random.seed(42)
+        self.colors = np.random.randint(0, 255, size=(len(PASCAL_CLASSES), 3), dtype=np.uint8)
+        
+        print("✅ Modèle chargé avec succès!")
+    
+    def preprocess_image(self, image):
+        """Prétraite l'image pour le modèle"""
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+        
+        original_shape = image.shape[:2]
+        image_resized = cv2.resize(image, (IMAGE_SIZE, IMAGE_SIZE))
+        
+        # Normaliser et convertir en tensor
+        image_tensor = torch.from_numpy(image_resized).float() / 255.0
+        image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0)
+        
+        return image_tensor.to(DEVICE), original_shape
+    
+    def detect(self, image, conf_threshold=0.5, iou_threshold=0.45):
+        """Détecte les objets dans l'image"""
+        image_tensor, original_shape = self.preprocess_image(image)
+        
+        with torch.no_grad():
+            predictions = self.model(image_tensor)
+        
+        # Convertir les prédictions en bboxes
+        bboxes = [[] for _ in range(1)]
+        for i in range(3):
+            S = predictions[i].shape[2]
+            anchor = self.scaled_anchors[i]
+            boxes_scale_i = cells_to_bboxes(
+                predictions[i], anchor, S=S, is_preds=True
+            )
+            for idx, box in enumerate(boxes_scale_i):
+                bboxes[idx] += box
+        
+        # Appliquer NMS
+        nms_boxes = non_max_suppression(
+            bboxes[0],
+            iou_threshold=iou_threshold,
+            threshold=conf_threshold,
+            box_format="midpoint",
+        )
+        
+        return nms_boxes
+    
+    def draw_boxes(self, image, boxes):
+        """Dessine les bounding boxes sur l'image"""
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+        
+        image = image.copy()
+        height, width = image.shape[:2]
+        
+        detections_info = []
+        
+        for box in boxes:
+            class_idx = int(box[0])
+            confidence = box[1]
+            x_center, y_center, box_width, box_height = box[2:]
+            
+            # Convertir en coordonnées pixel
+            x1 = int((x_center - box_width / 2) * width)
+            y1 = int((y_center - box_height / 2) * height)
+            x2 = int((x_center + box_width / 2) * width)
+            y2 = int((y_center + box_height / 2) * height)
+            
+            # Couleur pour cette classe
+            color = self.colors[class_idx].tolist()
+            
+            # Dessiner le rectangle
+            cv2.rectangle(image, (x1, y1), (x2, y2), color, 2)
+            
+            # Texte
+            label = f"{PASCAL_CLASSES[class_idx]}: {confidence:.2f}"
+            
+            # Fond du texte
+            (text_width, text_height), _ = cv2.getTextSize(
+                label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1
+            )
+            cv2.rectangle(
+                image, 
+                (x1, y1 - text_height - 4), 
+                (x1 + text_width, y1), 
+                color, 
+                -1
+            )
+            
+            # Texte blanc
+            cv2.putText(
+                image, 
+                label, 
+                (x1, y1 - 4), 
+                cv2.FONT_HERSHEY_SIMPLEX, 
+                0.5, 
+                (255, 255, 255), 
+                1
+            )
+            
+            detections_info.append(f"• {PASCAL_CLASSES[class_idx]}: {confidence:.1%}")
+        
+        return image, detections_info
+
+
+# Télécharger le modèle depuis Hugging Face
+print("📥 Téléchargement du modèle depuis Hugging Face...")
+checkpoint_path = hf_hub_download(
+    repo_id="nathbns/yolov3_from_scratch",
+    filename="checkpoint.pth.tar"
+)
+print(f"✅ Modèle téléchargé: {checkpoint_path}")
+
+# Initialiser le détecteur
+print("🚀 Chargement du modèle...")
+detector = YOLOv3Detector(checkpoint_path)
+
+
+def predict(image, conf_threshold, iou_threshold):
+    """Fonction de prédiction pour Gradio"""
+    if image is None:
+        return None, "❌ Aucune image fournie"
+    
+    # Détecter
+    boxes = detector.detect(image, conf_threshold, iou_threshold)
+    
+    # Dessiner
+    result_image, detections = detector.draw_boxes(image, boxes)
+    
+    # Texte des détections
+    if detections:
+        detection_text = f"**✅ {len(detections)} objet(s) détecté(s) :**\n\n" + "\n".join(detections)
+    else:
+        detection_text = "❌ Aucun objet détecté"
+    
+    return result_image, detection_text
+
+
+# Interface Gradio
+with gr.Blocks(title="YOLOv3 Object Detection", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🎯 YOLOv3 Object Detection - Pascal VOC
+        
+        Uploadez une image pour détecter des objets parmi **20 classes Pascal VOC**.
+        
+        **Classes détectables:** personne, vélo, voiture, moto, avion, bus, train, camion, bateau, 
+        feu de circulation, bouche d'incendie, panneau stop, parcomètre, banc, oiseau, chat, chien, 
+        cheval, mouton, vache, éléphant, ours, zèbre, girafe, sac à dos, parapluie, etc.
+        
+        ---
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(type="pil", label="📸 Image d'entrée")
+            
+            with gr.Accordion("⚙️ Paramètres", open=True):
+                conf_slider = gr.Slider(
+                    minimum=0.1, 
+                    maximum=1.0, 
+                    value=0.5, 
+                    step=0.05,
+                    label="Seuil de confiance",
+                    info="Plus élevé = moins de détections mais plus sûres"
+                )
+                iou_slider = gr.Slider(
+                    minimum=0.1, 
+                    maximum=1.0, 
+                    value=0.45, 
+                    step=0.05,
+                    label="Seuil NMS (IoU)",
+                    info="Plus élevé = plus de boîtes qui se chevauchent"
+                )
+            
+            detect_btn = gr.Button("🔍 Détecter les objets", variant="primary", size="lg")
+        
+        with gr.Column():
+            output_image = gr.Image(label="✨ Résultat")
+            output_text = gr.Markdown(label="📊 Détections")
+    
+    # Action
+    detect_btn.click(
+        fn=predict,
+        inputs=[input_image, conf_slider, iou_slider],
+        outputs=[output_image, output_text]
+    )
+    
+    # Auto-run sur upload
+    input_image.change(
+        fn=predict,
+        inputs=[input_image, conf_slider, iou_slider],
+        outputs=[output_image, output_text]
+    )
+    
+    gr.Markdown(
+        """
+        ---
+        
+        ### 📊 Informations sur le modèle
+        
+        - **Architecture:** YOLOv3 (Darknet-53 backbone)
+        - **Dataset:** Pascal VOC (16 551 images d'entraînement)
+        - **Epochs:** 100
+        - **mAP @ 0.5 IoU:** ~38.3%
+        - **Classes:** 20 objets courants
+        - **Taille d'entrée:** 416x416
+        
+        ---
+        
+        ### 💡 Astuces
+        
+        - **Seuil de confiance bas (0.3):** Plus de détections, mais plus de faux positifs
+        - **Seuil de confiance élevé (0.7):** Moins de détections, mais plus précises
+        - **Seuil NMS:** Contrôle le chevauchement des boîtes de détection
+        
+        ---
+        
+        Créé avec ❤️ par [nathbns](https://huggingface.co/nathbns)
+        """
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+

model.py

@@ -0,0 +1,162 @@
+"""
+Implementation of YOLOv3 architecture
+"""
+
+import torch
+import torch.nn as nn
+
+
+class CNNBlock(nn.Module):
+    """Convolutional block with BatchNorm and LeakyReLU"""
+    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, bn_act=True):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=not bn_act)
+        self.bn = nn.BatchNorm2d(out_channels)
+        self.leaky = nn.LeakyReLU(0.1)
+        self.use_bn_act = bn_act
+
+    def forward(self, x):
+        if self.use_bn_act:
+            return self.leaky(self.bn(self.conv(x)))
+        else:
+            return self.conv(x)
+
+
+class ResidualBlock(nn.Module):
+    """Residual block with skip connection"""
+    def __init__(self, channels, num_repeats=1):
+        super().__init__()
+        self.layers = nn.ModuleList()
+        for _ in range(num_repeats):
+            self.layers.append(
+                nn.Sequential(
+                    CNNBlock(channels, channels // 2, kernel_size=1),
+                    CNNBlock(channels // 2, channels, kernel_size=3, padding=1),
+                )
+            )
+
+    def forward(self, x):
+        for layer in self.layers:
+            x = x + layer(x)
+        return x
+
+
+class ScalePrediction(nn.Module):
+    """Scale prediction block for YOLO output"""
+    def __init__(self, in_channels, num_classes):
+        super().__init__()
+        self.pred = nn.Sequential(
+            CNNBlock(in_channels, 2 * in_channels, kernel_size=3, padding=1),
+            CNNBlock(2 * in_channels, (num_classes + 5) * 3, kernel_size=1, bn_act=False),
+        )
+        self.num_classes = num_classes
+
+    def forward(self, x):
+        return (
+            self.pred(x)
+            .reshape(x.shape[0], 3, self.num_classes + 5, x.shape[2], x.shape[3])
+            .permute(0, 1, 3, 4, 2)
+        )
+
+
+class YOLOv3(nn.Module):
+    """YOLOv3 architecture with Darknet-53 backbone"""
+    def __init__(self, in_channels=3, num_classes=20):
+        super().__init__()
+        self.num_classes = num_classes
+        
+        # Darknet-53 Backbone
+        self.conv1 = CNNBlock(in_channels, 32, kernel_size=3, stride=1, padding=1)
+        
+        self.conv2 = CNNBlock(32, 64, kernel_size=3, stride=2, padding=1)
+        self.residual1 = ResidualBlock(64, num_repeats=1)
+        
+        self.conv3 = CNNBlock(64, 128, kernel_size=3, stride=2, padding=1)
+        self.residual2 = ResidualBlock(128, num_repeats=2)
+        
+        self.conv4 = CNNBlock(128, 256, kernel_size=3, stride=2, padding=1)
+        self.residual3 = ResidualBlock(256, num_repeats=8)
+        
+        self.conv5 = CNNBlock(256, 512, kernel_size=3, stride=2, padding=1)
+        self.residual4 = ResidualBlock(512, num_repeats=8)
+        
+        self.conv6 = CNNBlock(512, 1024, kernel_size=3, stride=2, padding=1)
+        self.residual5 = ResidualBlock(1024, num_repeats=4)
+        
+        # First scale prediction (13x13 - large objects)
+        self.conv7 = CNNBlock(1024, 512, kernel_size=1, stride=1, padding=0)
+        self.conv8 = CNNBlock(512, 1024, kernel_size=3, stride=1, padding=1)
+        self.residual6 = ResidualBlock(1024, num_repeats=1)
+        self.conv9 = CNNBlock(1024, 512, kernel_size=1, stride=1, padding=0)
+        self.scale_pred1 = ScalePrediction(512, num_classes=num_classes)
+        
+        # Second scale (26x26 - medium objects)
+        self.conv10 = CNNBlock(512, 256, kernel_size=1, stride=1, padding=0)
+        self.upsample1 = nn.Upsample(scale_factor=2, mode='nearest')
+        
+        self.conv11 = CNNBlock(768, 256, kernel_size=1, stride=1, padding=0)
+        self.conv12 = CNNBlock(256, 512, kernel_size=3, stride=1, padding=1)
+        self.residual7 = ResidualBlock(512, num_repeats=1)
+        self.conv13 = CNNBlock(512, 256, kernel_size=1, stride=1, padding=0)
+        self.scale_pred2 = ScalePrediction(256, num_classes=num_classes)
+        
+        # Third scale (52x52 - small objects)
+        self.conv14 = CNNBlock(256, 128, kernel_size=1, stride=1, padding=0)
+        self.upsample2 = nn.Upsample(scale_factor=2, mode='nearest')
+        
+        self.conv15 = CNNBlock(384, 128, kernel_size=1, stride=1, padding=0)
+        self.conv16 = CNNBlock(128, 256, kernel_size=3, stride=1, padding=1)
+        self.residual8 = ResidualBlock(256, num_repeats=1)
+        self.conv17 = CNNBlock(256, 128, kernel_size=1, stride=1, padding=0)
+        self.scale_pred3 = ScalePrediction(128, num_classes=num_classes)
+
+    def forward(self, x):
+        # Darknet-53 feature extraction
+        x = self.conv1(x)
+        
+        x = self.conv2(x)
+        x = self.residual1(x)
+        
+        x = self.conv3(x)
+        x = self.residual2(x)
+        
+        x = self.conv4(x)
+        route1 = self.residual3(x)
+        
+        x = self.conv5(route1)
+        route2 = self.residual4(x)
+        
+        x = self.conv6(route2)
+        x = self.residual5(x)
+        
+        # First scale (13x13)
+        x = self.conv7(x)
+        x = self.conv8(x)
+        x = self.residual6(x)
+        x = self.conv9(x)
+        out1 = self.scale_pred1(x)
+        
+        # Second scale (26x26)
+        x = self.conv10(x)
+        x = self.upsample1(x)
+        x = torch.cat([x, route2], dim=1)
+        
+        x = self.conv11(x)
+        x = self.conv12(x)
+        x = self.residual7(x)
+        x = self.conv13(x)
+        out2 = self.scale_pred2(x)
+        
+        # Third scale (52x52)
+        x = self.conv14(x)
+        x = self.upsample2(x)
+        x = torch.cat([x, route1], dim=1)
+        
+        x = self.conv15(x)
+        x = self.conv16(x)
+        x = self.residual8(x)
+        x = self.conv17(x)
+        out3 = self.scale_pred3(x)
+        
+        return [out1, out2, out3]
+

requirements.txt

@@ -0,0 +1,8 @@
+torch>=2.0.0
+torchvision>=0.15.0
+gradio>=4.0.0
+huggingface-hub>=0.17.0
+opencv-python-headless>=4.8.0
+numpy>=1.24.0
+Pillow>=10.0.0
+

utils.py

@@ -0,0 +1,136 @@
+"""
+Utility functions for YOLOv3 (simplifié pour Gradio)
+"""
+
+import torch
+
+
+def intersection_over_union(boxes_preds, boxes_labels, box_format="midpoint"):
+    """
+    Calcule l'intersection over union (IoU) entre deux bounding boxes
+    
+    Args:
+        boxes_preds: Prédictions [x, y, w, h] ou [x1, y1, x2, y2]
+        boxes_labels: Labels [x, y, w, h] ou [x1, y1, x2, y2]
+        box_format: "midpoint" ou "corners"
+    
+    Returns:
+        IoU score
+    """
+    if box_format == "midpoint":
+        box1_x1 = boxes_preds[..., 0:1] - boxes_preds[..., 2:3] / 2
+        box1_y1 = boxes_preds[..., 1:2] - boxes_preds[..., 3:4] / 2
+        box1_x2 = boxes_preds[..., 0:1] + boxes_preds[..., 2:3] / 2
+        box1_y2 = boxes_preds[..., 1:2] + boxes_preds[..., 3:4] / 2
+        box2_x1 = boxes_labels[..., 0:1] - boxes_labels[..., 2:3] / 2
+        box2_y1 = boxes_labels[..., 1:2] - boxes_labels[..., 3:4] / 2
+        box2_x2 = boxes_labels[..., 0:1] + boxes_labels[..., 2:3] / 2
+        box2_y2 = boxes_labels[..., 1:2] + boxes_labels[..., 3:4] / 2
+    else:  # corners
+        box1_x1 = boxes_preds[..., 0:1]
+        box1_y1 = boxes_preds[..., 1:2]
+        box1_x2 = boxes_preds[..., 2:3]
+        box1_y2 = boxes_preds[..., 3:4]
+        box2_x1 = boxes_labels[..., 0:1]
+        box2_y1 = boxes_labels[..., 1:2]
+        box2_x2 = boxes_labels[..., 2:3]
+        box2_y2 = boxes_labels[..., 3:4]
+
+    x1 = torch.max(box1_x1, box2_x1)
+    y1 = torch.max(box1_y1, box2_y1)
+    x2 = torch.min(box1_x2, box2_x2)
+    y2 = torch.min(box1_y2, box2_y2)
+
+    intersection = (x2 - x1).clamp(0) * (y2 - y1).clamp(0)
+    box1_area = abs((box1_x2 - box1_x1) * (box1_y2 - box1_y1))
+    box2_area = abs((box2_x2 - box2_x1) * (box2_y2 - box2_y1))
+
+    return intersection / (box1_area + box2_area - intersection + 1e-6)
+
+
+def non_max_suppression(bboxes, iou_threshold, threshold, box_format="corners"):
+    """
+    Applique le Non-Maximum Suppression (NMS)
+    
+    Args:
+        bboxes: Liste de bboxes [class_pred, prob_score, x, y, w, h]
+        iou_threshold: Seuil IoU pour supprimer les boxes
+        threshold: Seuil de confiance minimum
+        box_format: "midpoint" ou "corners"
+    
+    Returns:
+        Liste de bboxes après NMS
+    """
+    assert type(bboxes) == list
+
+    # Filtrer par confiance
+    bboxes = [box for box in bboxes if box[1] > threshold]
+    bboxes = sorted(bboxes, key=lambda x: x[1], reverse=True)
+    bboxes_after_nms = []
+
+    while bboxes:
+        chosen_box = bboxes.pop(0)
+
+        bboxes = [
+            box
+            for box in bboxes
+            if box[0] != chosen_box[0]  # Différente classe
+            or intersection_over_union(
+                torch.tensor(chosen_box[2:]),
+                torch.tensor(box[2:]),
+                box_format=box_format,
+            )
+            < iou_threshold  # IoU faible
+        ]
+
+        bboxes_after_nms.append(chosen_box)
+
+    return bboxes_after_nms
+
+
+def cells_to_bboxes(predictions, anchors, S, is_preds=True):
+    """
+    Convertit les prédictions YOLOv3 en bounding boxes
+    
+    Args:
+        predictions: Tensor [N, 3, S, S, num_classes+5]
+        anchors: Anchors pour cette échelle
+        S: Taille de la grille (13, 26, ou 52)
+        is_preds: Si True, applique sigmoid/exp
+    
+    Returns:
+        Liste de bboxes converties
+    """
+    BATCH_SIZE = predictions.shape[0]
+    num_anchors = len(anchors)
+    box_predictions = predictions[..., 1:5]
+    
+    if is_preds:
+        anchors = anchors.reshape(1, len(anchors), 1, 1, 2)
+        box_predictions[..., 0:2] = torch.sigmoid(box_predictions[..., 0:2])
+        box_predictions[..., 2:] = torch.exp(box_predictions[..., 2:]) * anchors
+        scores = torch.sigmoid(predictions[..., 0:1])
+        best_class = torch.argmax(predictions[..., 5:], dim=-1).unsqueeze(-1)
+    else:
+        scores = predictions[..., 0:1]
+        best_class = predictions[..., 5:6]
+
+    # Indices de cellules
+    cell_indices = (
+        torch.arange(S)
+        .repeat(predictions.shape[0], 3, S, 1)
+        .unsqueeze(-1)
+        .to(predictions.device)
+    )
+    
+    # Convertir en coordonnées absolues [0, 1]
+    x = 1 / S * (box_predictions[..., 0:1] + cell_indices)
+    y = 1 / S * (box_predictions[..., 1:2] + cell_indices.permute(0, 1, 3, 2, 4))
+    w_h = 1 / S * box_predictions[..., 2:4]
+    
+    converted_bboxes = torch.cat((best_class, scores, x, y, w_h), dim=-1).reshape(
+        BATCH_SIZE, num_anchors * S * S, 6
+    )
+    
+    return converted_bboxes.tolist()
+