Ricerca nel sito web

Costruire un sistema di rilevamento di oggetti in tempo reale con l'algoritmo YOLO

Negli ultimi anni, il campo della visione artificiale ha assistito a notevoli progressi, e il rilevamento di oggetti in tempo reale è una delle aree più interessanti e di maggior impatto. Il rilevamento di oggetti in tempo reale si riferisce alla capacità di rilevare e identificare oggetti in immagini o video in tempo reale, consentendo un'ampia gamma di applicazioni come veicoli autonomi, sistemi di sorveglianza, realtà aumentata e altro ancora. In questo tutorial esploreremo come costruire un sistema di rilevamento di oggetti in tempo reale utilizzando Python e l'algoritmo YOLO (You Only Look Once).

L'algoritmo YOLO ha rivoluzionato il rilevamento degli oggetti introducendo un approccio unico e unificato che esegue sia la localizzazione che la classificazione degli oggetti in un unico passaggio. A differenza dei metodi tradizionali che utilizzano pipeline complesse che coinvolgono più fasi, l'algoritmo YOLO raggiunge una velocità e una precisione impressionanti trattando il rilevamento degli oggetti come un problema di regressione. Divide l'immagine di input in una griglia e prevede i riquadri di delimitazione e le probabilità delle classi direttamente dalle celle della griglia.

Python, con la sua semplicità, versatilità e il ricco ecosistema di librerie, è una scelta eccellente per implementare sistemi di rilevamento di oggetti in tempo reale. Utilizzeremo il framework Darknet, che è un framework di rete neurale open source scritto in C e CUDA, per addestrare il nostro modello utilizzando l'algoritmo YOLO. Con l'aiuto del framework Darknet e Python, costruiremo un sistema di rilevamento di oggetti in tempo reale in grado di rilevare e classificare oggetti da flussi video in diretta o video registrati.

Iniziare

Per iniziare a costruire il nostro sistema di rilevamento degli oggetti in tempo reale con Python e l'algoritmo YOLO, dobbiamo configurare il nostro ambiente di sviluppo e installare le librerie necessarie. I seguenti passaggi ti guideranno attraverso il processo di installazione −

Passaggio 1: installa OpenCV

OpenCV è una popolare libreria di visione artificiale che fornisce strumenti e funzioni essenziali per l'elaborazione di immagini e video. Possiamo installare OpenCV usando pip, il gestore di pacchetti Python, eseguendo il seguente comando nel terminale −

pip install opencv-python

Passaggio 2: installa Darknet

Darknet è il framework che utilizzeremo per addestrare il nostro modello YOLO. Per installare Darknet, apri una finestra di terminale e segui questi passaggi −

Clona il repository Darknet da GitHub

clone git https://github.com/AlexeyAB/darknet.git

Passa alla directory della Darknet

cd darknet

Costruisci la rete oscura

creare

Questo passaggio potrebbe richiedere del tempo poiché compila il codice C e crea il framework Darknet. Una volta completato il processo di compilazione, dovresti avere l'eseguibile Darknet pronto per l'uso.

Costruire un sistema di rilevamento di oggetti in tempo reale con YOLO

Ora che abbiamo configurato il nostro ambiente di sviluppo e installato le librerie necessarie, possiamo procedere con la creazione del nostro sistema di rilevamento degli oggetti in tempo reale. Ho suddiviso tutti i diversi passaggi coinvolti nel rilevamento degli oggetti seguiti dal codice completo per una migliore comprensione dell'intera pipeline e del processo. Ciò eviterà confusione nel gestire parti di codice più piccole.

Le fasi principali coinvolte nella costruzione del sistema sono le seguenti: −

  • Preparazione del set di dati − Per addestrare il nostro modello YOLO, abbiamo bisogno di un set di dati etichettato contenente immagini e annotazioni corrispondenti. Il set di dati dovrebbe essere costituito da immagini con riquadri di delimitazione etichettati attorno agli oggetti che vogliamo rilevare. Le annotazioni in genere includono l'etichetta della classe e le coordinate del riquadro di delimitazione.

  • Configurazione del modello YOLO - L'algoritmo YOLO ha diverse varianti, come YOLOv1, YOLOv2, YOLOv3 e YOLOv4. Ogni versione ha il proprio file di configurazione che specifica l'architettura di rete, gli iperparametri e le impostazioni di training. Dobbiamo scegliere una versione YOLO adatta e configurarla in base alle nostre esigenze.

  • Addestramento del modello YOLO - Con il set di dati e la configurazione in atto, possiamo iniziare ad addestrare il nostro modello YOLO utilizzando il framework Darknet. L'addestramento prevede l'alimentazione delle immagini etichettate al modello, l'ottimizzazione dei pesi della rete utilizzando la backpropagation e la regolazione dei parametri per ridurre al minimo gli errori di rilevamento.

  • Test e valutazione - Una volta addestrato il modello, possiamo valutarne le prestazioni testandolo su una serie separata di immagini o video. Misuriamo parametri quali precisione, richiamo e precisione media media (mAP) per valutare l'accuratezza e l'affidabilità del nostro sistema di rilevamento degli oggetti.

  • Rilevamento di oggetti in tempo reale - Dopo aver addestrato e valutato con successo il modello, possiamo integrarlo con un flusso video dal vivo o video registrati per eseguire il rilevamento di oggetti in tempo reale. Utilizzeremo OpenCV per acquisire fotogrammi video, applicare l'algoritmo YOLO per il rilevamento di oggetti e visualizzare i risultati in tempo reale.

Esaminiamo ora l'implementazione del codice di ogni passaggio nella creazione del nostro sistema di rilevamento degli oggetti in tempo reale.

Codice completo

Esempio

Ecco il codice completo −

import cv2

# Load YOLO weights and configuration
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
classes = []
with open("coco.names", "r") as f:
   classes = [line.strip() for line in f.readlines()]

# Set up output layers
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

# Load video stream
cap = cv2.VideoCapture(0)

while True:
   # Read frames from the video stream
   ret, frame = cap.read()
   if not ret:
      break

   # Preprocess frame for object detection
   blob = cv2.dnn.blobFromImage(frame, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
   net.setInput(blob)
   outs = net.forward(output_layers)

   # Process the outputs
   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:
            # Object detected
            center_x = int(detection[0] * frame.shape[1])
            center_y = int(detection[1] * frame.shape[0])
            width = int(detection[2] * frame.shape[1])
            height = int(detection[3] * frame.shape[0])
            x = int(center_x - width / 2)
            y = int(center_y - height / 2)

            boxes.append([x, y, width, height])
            confidences.append(float(confidence))
            class_ids.append(class_id)

   # Apply non-maximum suppression to remove overlapping detections
   indices = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
   # Draw bounding boxes and labels on the frame
   font = cv2.FONT_HERSHEY_PLAIN
   colors = np.random.uniform(0, 255, size=(len(classes), 3))
   if len(indices) > 0:
      for i in indices.flatten():
         x, y, w, h = boxes[i]
         label = str(classes[class_ids[i]])
         confidence = confidences[i]
         color = colors[i]
         cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
         cv2.putText(frame, f"{label} {confidence:.2f}", (x, y - 5), font, 1, color, 2)

   # Display the resulting frame
   cv2.imshow("Real-time Object Detection", frame)
   if cv2.waitKey(1) == ord("q"):
      break

# Release resources
cap.release()
cv2.destroyAllWindows()

Conclusione

In questo tutorial, abbiamo esplorato come costruire un sistema di rilevamento di oggetti in tempo reale utilizzando Python e l'algoritmo YOLO. Abbiamo iniziato introducendo il concetto di rilevamento di oggetti in tempo reale e l'importanza dell'algoritmo YOLO nel campo della visione artificiale. Abbiamo poi trattato l'installazione delle librerie necessarie, tra cui Python, OpenCV e il framework Darknet.

Nel contenuto principale, abbiamo discusso i passaggi essenziali coinvolti nella creazione di un sistema di rilevamento di oggetti in tempo reale, come la preparazione del set di dati, la configurazione del modello YOLO, l'addestramento del modello, il test e la valutazione delle sue prestazioni. Abbiamo anche fornito un esempio di codice completo che dimostrava il processo di rilevamento degli oggetti in tempo reale utilizzando Python, OpenCV e l'algoritmo YOLO.

Seguendo i passaggi descritti in questo tutorial, puoi creare il tuo sistema di rilevamento degli oggetti in tempo reale in grado di rilevare e classificare gli oggetti nei flussi video live o nei video registrati. Ciò apre possibilità per un’ampia gamma di applicazioni, inclusi sistemi di sorveglianza, veicoli autonomi ed esperienze di realtà aumentata.

Il rilevamento degli oggetti è un campo entusiasmante e in rapida evoluzione e l'algoritmo YOLO è solo una delle tante tecniche disponibili. Mentre esplori ulteriormente il mondo della visione artificiale, valuta la possibilità di sperimentare altri algoritmi, set di dati e strategie di formazione per migliorare la precisione e le prestazioni dei tuoi sistemi di rilevamento degli oggetti.

Articoli correlati: