Überblick über YOLO (You Only Look Once)

1. Geschichte und Entwicklung von YOLO

YOLO (You Only Look Once) wurde erstmals 2015 von Joseph Redmon und seinem Team entwickelt. Es markierte einen bedeutenden Durchbruch im Bereich der Echtzeit-Objekterkennung. Die ursprüngliche Version, YOLOv1, führte das Konzept ein, das gesamte Bild nur einmal durch ein neuronales Netzwerk zu leiten, um Vorhersagen zu treffen, anstatt regionsbasierte Ansätze zu verwenden, wie es bei R-CNN der Fall war. Dies machte YOLO extrem schnell und effizient.

Die Entwicklung von YOLO hat mehrere Versionen durchlaufen:

1. YOLOv1 (2015): Einführung des einheitlichen CNN-basierten Ansatzes zur Objekterkennung in Echtzeit.
2. YOLOv2 (2016) (YOLO9000): Verbesserungen in Genauigkeit und Geschwindigkeit sowie die Fähigkeit, mehr als 9000 Objektklassen zu erkennen.
3. YOLOv3: The third iteration of the YOLO model family, originally by Joseph Redmon, known for its efficient real-time object detection capabilities.
4. YOLOv4: A darknet-native update to YOLOv3, released by Alexey Bochkovskiy in 2020.
5. YOLOv5: An improved version of the YOLO architecture by Ultralytics, offering better performance and speed trade-offs compared to previous versions.
6. YOLOv6: Released by Meituan in 2022, and in use in many of the company's autonomous delivery robots.
7. YOLOv7: Updated YOLO models released in 2022 by the authors of YOLOv4.
8. YOLOv8: The latest version of the YOLO family by Ultralytics, featuring enhanced capabilities such as instance segmentation, pose/keypoints estimation, and classification.
9. YOLOv9: An experimental model trained on the Ultralytics YOLOv5 codebase implementing Programmable Gradient Information (PGI).
10. YOLOv10: By Tsinghua University, featuring NMS-free training and efficiency-accuracy driven architecture, delivering state-of-the-art performance and latency.

2. Hauptmerkmale von YOLO

YOLO hat mehrere Schlüsselfunktionen, die es von anderen Objekterkennungsmodellen unterscheiden:

• Einheitliches Modell: YOLO betrachtet die Objekterkennung als ein einzelnes Regressionsproblem, was bedeutet, dass das gesamte Bild in einem Durchlauf verarbeitet wird.
• Echtzeitfähigkeit: Aufgrund seiner Architektur und Effizienz kann YOLO Objekte in Echtzeit erkennen und klassifizieren, was es ideal für Anwendungen wie autonome Fahrzeuge und Überwachungssysteme macht.
• Hohe Genauigkeit: Durch die Verwendung von Feature-Pyramiden und ankerbasierten Methoden kann YOLO eine hohe Genauigkeit bei der Objekterkennung erreichen.
• Skalierbarkeit: YOLO ist skalierbar und kann auf verschiedene Objektklassen und Bildgrößen angewendet werden.
• Geringe Anzahl falscher Positiver: Dank seiner präzisen Lokalisierungsfähigkeiten und der Verwendung von Non-Maximum Suppression (NMS) reduziert YOLO die Anzahl falscher Positiver.

Beispiel: Die folgende Tabelle zeigt die Erkennungsgenauigkeit (mAP) und die Verarbeitungsgeschwindigkeit (FPS) von YOLOv3 im Vergleich zu anderen Modellen:

3. Vergleich mit anderen Objekterkennungsmodellen

YOLO unterscheidet sich in mehreren wesentlichen Aspekten von anderen gängigen Objekterkennungsmodellen wie R-CNN, Fast R-CNN, Faster R-CNN und SSD:

• R-CNN: Verwendet eine regionsbasierte Methode, bei der Regionen von Interesse (RoIs) vorgeschlagen und dann klassifiziert werden. Dies ist langsamer und weniger effizient als YOLO.
• Fast R-CNN und Faster R-CNN: Verbesserungen des ursprünglichen R-CNN, die die Geschwindigkeit erhöhen, aber immer noch komplexer und langsamer als YOLO sind.
• SSD (Single Shot MultiBox Detector): Ähnlich wie YOLO, aber verwendet mehrere Ebenen für die Vorhersage, was die Erkennungsgenauigkeit auf verschiedenen Skalen verbessert, jedoch oft langsamer als YOLO.
• YOLO: Ein einheitlicher Ansatz, der das gesamte Bild in einem Durchgang verarbeitet und somit viel schneller ist. Dies macht YOLO ideal für Echtzeitanwendungen.

Beispiel: Das folgende Diagramm zeigt den Vergleich der Verarbeitungsgeschwindigkeit und Genauigkeit verschiedener Objekterkennungsmodelle:

import cv2
import numpy as np
from ultralytics import YOLO

# Laden Sie das YOLOv8-Modell
model = YOLO("yolov8.pt")  # Ersetzen Sie "yolov8.pt" durch den Pfad zu Ihrem YOLOv8-Gewichtsdatei

# Laden Sie das Bild
image = cv2.imread("wohnzimmer.jpg")
height, width, channels = image.shape

# Bildvorverarbeitung
blob = cv2.dnn.blobFromImage(image, 1/255.0, (640, 640), swapRB=True, crop=False)
model.setInput(blob)

# Durchführen der Vorhersagen
outputs = model.predict(blob)

# Extrahieren der Informationen
class_ids = []
confidences = []
boxes = []

for output in outputs:
    for detection in output:
        scores = detection[5:]
        class_id = np.argmax(scores)
        confidence = scores[class_id]
        if confidence > 0.5:
            box = detection[0:4] * np.array([width, height, width, height])
            (centerX, centerY, w, h) = box.astype("int")

            x = int(centerX - (w / 2))
            y = int(centerY - (h / 2))

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

# Anwenden von Non-Maximum Suppression
indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)

# Laden der Klassennamen
with open("coco.names", "r") as f:
    classes = [line.strip() for line in f.readlines()]

# Zeichnen der Rechtecke und Beschriftungen
for i in range(len(boxes)):
    if i in indexes:
        x, y, w, h = boxes[i]
        label = str(classes[class_ids[i]])
        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
        cv2.putText(image, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

# Anzeige des Ergebnisses
cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Diese detaillierte Übersicht über YOLO gibt Einblicke in seine Geschichte, Hauptmerkmale und einen Vergleich mit anderen Objekterkennungsmodellen. Dies bietet eine solide Grundlage für das Verständnis der Stärken und Einsatzmöglichkeiten von YOLO.