Découvrez YOLO, le framework pour la détection d’objets en temps réel !

Dans le domaine de la vision par ordinateur, la détection d’objets en temps réel revêt une grande importance pour notamment la surveillance vidéo, la conduite autonome et la réalité augmentée. Le framework YOLO (You Only Look Once) pour Python est devenu l’un des outils les plus populaires, efficace et précis pour de nombreuses raisons.

Qu’est-ce que YOLO ?

YOLO est un framework de détection d’objets en temps réel développé par Joseph Redmon et son équipe. Contrairement aux approches classiques qui effectuent des classifications d’objets à l’aide de cadres glissants (sliding windows) ou de régions d’intérêt (regions of interest), YOLO formule la détection d’objets comme un problème de régression sur une grille d’ancres (anchors grid).

Comment fonctionne YOLO ?

Entraîné sur l’ensemble de données Microsoft COCO, Le fonctionnement de YOLO, peut être divisé en trois étapes principales.

Découpage de l’image en grille

YOLO divise l’image d’entrée en une grille régulière. Chaque cellule de la grille prédit un certain nombre de boîtes englobantes (bounding boxes) et les classes d’objets correspondantes.

Prédiction des boîtes englobantes et des classes

Pour chaque cellule de la grille, YOLO prédit des coordonnées de boîtes englobantes (bounding boxes) et associe des probabilités aux classes d’objets possibles.

Filtrage des détections

En utilisant des seuils de confiance (confidence threshold) et des techniques de suppression non maximale (non-maximum suppression), YOLO filtre les détections redondantes et ne conserve que les détections les plus fiables.

Voici quelques exemples de code YOLO

Configuration et initialisation :

   import cv2
   import numpy as np

   net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
   layer_names = net.getLayerNames()
   output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]
   colors = np.random.uniform(0, 255, size=(len(classes), 3))

Chargement de l’image et détection :

   img = cv2.imread("image.jpg")
   height, width, channels = img.shape

   blob = cv2.dnn.blobFromImage(img, 0.00392, (416, 416), (0, 0, 0), True, crop=False)

   net.setInput(blob)
   outs = net.forward(output_layers)

   class_ids = []
   confidences = []
   boxes = []
   for out in outs:
       for detection in out:
           scores = detection[5:]
           class_id = np.argmax(scores)
           confidence = scores[class_id]
           if confidence > 0.5:
               # Coordonnées de la boîte englobante
               center_x = int(detection[0] * width)
               center_y = int(detection[1] * height)
               w = int(detection[2] * width)
               h = int(detection[3] * height)

               # Coordonnées de l'angle supérieur gauche
               x = int(center_x - w / 2)
               y = int(center_y - h / 2)

               boxes.append([x, y, w, h])
               confidences.append(float(confidence))
               class_ids.append(class_id)

Affichage des résultats :

   indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)

   font = cv2.FONT_HERSHEY_PLAIN
   for i in range(len(boxes)):
       if i in indexes:
           x, y, w, h = boxes[i]
           label = classes[class_ids[i]]
           color = colors[class_ids[i]]
           cv2.rectangle(img, (x, y), (x + w, y + h), color, 2)
           cv2.putText(img, label, (x, y + 30), font, 3, color, 3)

   cv2.imshow("YOLO Object Detection", img)
   cv2.waitKey(0)
   cv2.destroyAllWindows()

YOLO (You Only Look Once) est un framework de détection d’objets en temps réel qui a révolutionné la manière dont nous abordons ce problème. Sa méthode unique basée sur la régression sur une grille d’ancres a produit des résultats précis et rapides. Àvotre tour d’explorer les possibilités infinies de YOLO dans le domaine du monde numérique !