Echtzeit-Objekterkennungsinferenz in Python mit YOLOv7

Einleitung

Die Objekterkennung ist ein großes Gebiet der Computer Vision und eine der wichtigeren Anwendungen der Computer Vision „in freier Wildbahn“.

Die Objekterkennung ist nicht so standardisiert wie die Bildklassifizierung, hauptsächlich weil die meisten neuen Entwicklungen typischerweise von einzelnen Forschern, Betreuern und Entwicklern durchgeführt werden und nicht von großen Bibliotheken und Frameworks. Es ist schwierig, die erforderlichen Hilfsskripte in ein Framework wie TensorFlow oder PyTorch zu packen und die API-Richtlinien einzuhalten, die die Entwicklung bisher geleitet haben.

Dies macht die Objekterkennung etwas komplexer, typischerweise ausführlicher (aber nicht immer) und weniger zugänglich als die Bildklassifizierung.

Zum Glück für die Massen – Ultralytics hat eine einfache, sehr leistungsfähige und schöne Objekterkennungs-API um YOLOv5 herum entwickelt, die von anderen Forschungs- und Entwicklungsteams auf neuere Versionen wie YOLOv7 erweitert wurde.

In dieser kurzen Anleitung führen wir die Objekterkennung in Python mit dem hochmodernen YOLOv7 durch.

YOLO Landschaft und YOLOv7

YOLO (Du schaust nur einmal) ist eine Methodik sowie eine Familie von Modellen, die für die Objekterkennung erstellt wurden. Seit der Gründung im Jahr 2015 wurden YOLOv1, YOLOv2 (YOLO9000) und YOLOv3 von denselben Autoren vorgeschlagen – und die Deep-Learning-Community setzte sich in den folgenden Jahren mit Open-Source-Fortschritten fort.

YOLOv5 von Ultralytics ist die erste groß angelegte Implementierung von YOLO in PyTorch, was es zugänglicher als je zuvor machte, aber der Hauptgrund, warum YOLOv5 so Fuß gefasst hat, ist auch die wunderbar einfache und leistungsstarke API, die darum herum gebaut wurde. Das Projekt abstrahiert die unnötigen Details, ermöglicht jedoch Anpassbarkeit, praktisch alle verwendbaren Exportformate und verwendet erstaunliche Praktiken, die das gesamte Projekt sowohl effizient als auch so optimal wie möglich machen.

YOLOv5 ist nach wie vor das Hauptprojekt zum Erstellen von Objekterkennungsmodellen, und viele Repositories, die darauf abzielen, die YOLO-Methode weiterzuentwickeln, beginnen mit YOLOv5 als Basis und bieten eine ähnliche API (oder teilen das Projekt einfach auf und bauen darauf auf). Dies ist der Fall bei YOLOR (Sie lernen nur eine Darstellung) und YOLOv7, das auf YOLOR (gleicher Autor) aufbaut. YOLOv7 ist die neueste Weiterentwicklung der YOLO-Methodik und vor allem bietet YOLOv7 neue Modellköpfe, die Schlüsselpunkte (Skelette) ausgeben und eine Instanzsegmentierung neben nur einer Bounding-Box-Regression durchführen können, was bei früheren YOLO-Modellen nicht Standard war.

Dies macht die Instanzsegmentierung und Schlüsselpunkterkennung schneller als je zuvor!

Darüber hinaus arbeitet YOLOv7 aufgrund einer geringeren Anzahl von Parametern und einer höheren Recheneffizienz schneller und genauer als frühere Modelle:

Das Modell selbst wurde durch architektonische Änderungen sowie Optimierungsaspekte des Trainings erstellt, die als „Beutel mit Werbegeschenken“ bezeichnet werden und die Genauigkeit erhöhen, ohne die Inferenzkosten zu erhöhen.

Installieren von YOLOv7

Die Installation und Verwendung von YOLOv7 läuft darauf hinaus, das GitHub-Repository auf Ihren lokalen Computer herunterzuladen und die mitgelieferten Skripte auszuführen.

Trotzdem können Sie Videos, Bilder usw. in Echtzeit erkennen und die Ergebnisse einfach speichern. Das Projekt folgt den gleichen Konventionen wie YOLOv5, das über eine umfangreiche Dokumentation verfügt, sodass Sie wahrscheinlich Antworten auf weitere Nischenfragen im YOLOv5-Repository finden, wenn Sie welche haben.

Lassen Sie uns das Repository herunterladen und einige Schlussfolgerungen ziehen:

! git clone https://github.com/WongKinYiu/yolov7.git

Dies schafft ein yolov7 Verzeichnis in Ihrem aktuellen Arbeitsverzeichnis, in dem sich das Projekt befindet. Gehen wir in dieses Verzeichnis und sehen uns die Dateien an:

%cd yolov7
!ls
/Users/macbookpro/jup/yolov7
LICENSE.md       detect.py        models           tools
README.md        export.py        paper            train.py
cfg              figure           requirements.txt train_aux.py
data             hubconf.py       scripts          utils
deploy           inference        test.py          runs

Das detect.py ist das Inferenzskript, das Erkennungen ausführt und die Ergebnisse unter speichert runs/detect/video_name, wo Sie die angeben können video_name beim Anrufen der detect.py Skripte. export.py exportiert das Modell in verschiedene Formate wie ONNX, TFLite usw. train.py kann verwendet werden, um einen benutzerdefinierten YOLOv7-Detektor zu trainieren (das Thema eines anderen Handbuchs) und test.py kann verwendet werden, um einen Detektor zu testen (aus einer Gewichtsdatei geladen).

Mehrere zusätzliche Verzeichnisse enthalten die Konfigurationen (cfg), Beispieldaten (inference), Daten zum Bau von Modellen und COCO-Konfigurationen (data), Etc.

YOLOv7 Größen

YOLO-basierte Modelle lassen sich gut skalieren und werden normalerweise als kleinere, weniger genaue Modelle und größere, genauere Modelle exportiert. Diese werden dann jeweils auf schwächeren oder stärkeren Geräten bereitgestellt.

YOLOv7 bietet mehrere Größen an und hat sie mit MS COCO verglichen:

Modell	Testgröße	APTest	AP50test	AP75test	Stapel 1 fps	Batch 32 durchschnittliche Zeit
YOlov7	640	51.4%	69.7%	55.9%	161 fps	2.8 ms
YOLOv7-X	640	53.1%	71.2%	57.8%	114 fps	4.3 ms
YOlov7-W6	1280	54.9%	72.6%	60.1%	84 fps	7.6 ms
YOlov7-E6	1280	56.0%	73.5%	61.2%	56 fps	12.3 ms
YOLOv7-D6	1280	56.6%	74.0%	61.8%	44 fps	15.0 ms
YOlov7-E6E	1280	56.8%	74.4%	62.1%	36 fps	18.7 ms

Abhängig von der zugrunde liegenden Hardware, auf der das Modell ausgeführt werden soll, und der erforderlichen Genauigkeit – Sie können zwischen ihnen wählen. Das kleinste Modell erreicht über 160 FPS auf Bildern der Größe 640, auf einem V100! Sie können auch auf gängigeren Verbraucher-GPUs eine zufriedenstellende Echtzeitleistung erwarten.

Videoinferenz mit YOLOv7

Erstellen Sie ein inference-data Ordner zum Speichern der Bilder und/oder Videos, die Sie erkennen möchten. Angenommen, es befindet sich im selben Verzeichnis, können wir ein Erkennungsskript ausführen mit:

! python3 detect.py --source inference-data/busy_street.mp4 --weights yolov7.pt --name video_1 --view-img

Dadurch wird ein Qt-basiertes Video auf Ihrem Desktop angezeigt, in dem Sie den Live-Fortschritt und die Inferenz Frame für Frame sehen und den Status an unsere Standard-Ausgabepipe ausgeben können:

Namespace(weights=['yolov7.pt'], source='inference-data/busy_street.mp4', img_size=640, conf_thres=0.25, iou_thres=0.45, device='', view_img=True, save_txt=False, save_conf=False, nosave=False, classes=None, agnostic_nms=False, augment=False, update=False, project='runs/detect', name='video_1', exist_ok=False, no_trace=False)
YOLOR 🚀 v0.1-112-g55b90e1 torch 1.12.1 CPU

Downloading https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt to yolov7.pt...
100%|██████████████████████████████████████| 72.1M/72.1M [00:18<00:00, 4.02MB/s]

Fusing layers... 
RepConv.fuse_repvgg_block
RepConv.fuse_repvgg_block
RepConv.fuse_repvgg_block
Model Summary: 306 layers, 36905341 parameters, 6652669 gradients
 Convert model to Traced-model... 
 traced_script_module saved! 
 model is traced! 
 
video 1/1 (1/402) /Users/macbookpro/jup/yolov7/inference-data/busy_street.mp4: 24 persons, 1 bicycle, 8 cars, 3 traffic lights, 2 backpacks, 2 handbags, Done. (1071.6ms) Inference, (2.4ms) NMS
video 1/1 (2/402) /Users/macbookpro/jup/yolov7/inference-data/busy_street.mp4: 24 persons, 1 bicycle, 8 cars, 3 traffic lights, 2 backpacks, 2 handbags, Done. (1070.8ms) Inference, (1.3ms) NMS

Beachten Sie, dass das Projekt auf CPU-basierten Computern langsam läuft (z. B. 1000 ms pro Inferenzschritt in der obigen Ausgabe, lief auf einem Intel-basierten MacBook Pro 2017) und auf GPU-basierten Computern deutlich schneller (näher an ~ 5 ms/Frame auf einem V100). Selbst auf CPU-basierten Systemen wie diesem yolov7-tiny.pt läuft um 172ms/frame, das zwar weit von Echtzeit entfernt ist, aber dennoch sehr gut für die Verarbeitung dieser Operationen auf einer CPU geeignet ist.

Sobald der Lauf abgeschlossen ist, finden Sie das resultierende Video unter runs/video_1 (der Name, den wir in der angegeben haben detect.py Anruf), gespeichert als .mp4:

Rückschluss auf Bilder

Die Inferenz auf Bilder läuft auf denselben Prozess hinaus – das Bereitstellen der URL für ein Bild im Dateisystem und das Aufrufen detect.py:

! python3 detect.py --source inference-data/desk.jpg --weights yolov7.pt

Zusammenfassung

In dieser kurzen Anleitung haben wir einen kurzen Blick auf YOLOv7 geworfen, die neueste Weiterentwicklung der YOLO-Familie, die auf YOLOR aufbaut. Wir haben uns angesehen, wie Sie das Repository auf Ihrem lokalen Computer installieren und Objekterkennungs-Inferenzskripte mit einem vortrainierten Netzwerk für Videos und Bilder ausführen.

In weiteren Leitfäden behandeln wir die Erkennung von Schlüsselpunkten und die Segmentierung von Instanzen.

Weiter gehen – Praktisches Deep Learning für Computer Vision

Ihre neugierige Natur macht Lust auf mehr? Wir empfehlen Ihnen, sich unsere anzuschauen Kurs: „Praxisnahes Deep Learning für Computer Vision mit Python“.

Ein weiterer Computer Vision-Kurs?

Wir werden keine Klassifizierung von MNIST-Ziffern oder MNIST-Mode durchführen. Sie haben ihren Teil vor langer Zeit erfüllt. Zu viele Lernressourcen konzentrieren sich auf grundlegende Datensätze und grundlegende Architekturen, bevor fortgeschrittene Blackbox-Architekturen die Last der Leistung schultern.

Wir wollen uns konzentrieren Entmystifizierung, Praktikabilität, Verständnis, Intuition und echte Projekte. Möchte lernen wie du kannst einen Unterschied machen? Wir nehmen Sie mit auf eine Reise von der Art und Weise, wie unser Gehirn Bilder verarbeitet, über das Schreiben eines forschungstauglichen Deep-Learning-Klassifikators für Brustkrebs bis hin zu Deep-Learning-Netzwerken, die „halluzinieren“, Ihnen die Prinzipien und die Theorie durch praktische Arbeit beibringen und Sie mit dem ausstatten Know-how und Tools, um ein Experte für die Anwendung von Deep Learning zur Lösung von Computer Vision zu werden.

Was ist da drin?

• Die ersten Prinzipien des Sehens und wie Computern das „Sehen“ beigebracht werden kann
• Verschiedene Aufgaben und Anwendungen von Computer Vision
• Das Handwerkszeug, das Ihnen die Arbeit erleichtert
• Suchen, Erstellen und Verwenden von Datensätzen für Computer Vision
• Die Theorie und Anwendung von Convolutional Neural Networks
• Umgang mit Domänenverschiebung, Kookkurrenz und anderen Verzerrungen in Datensätzen
• Übertragen Sie Lernen und nutzen Sie die Trainingszeit und Rechenressourcen anderer zu Ihrem Vorteil
• Aufbau und Schulung eines hochmodernen Brustkrebsklassifikators
• Wie man Mainstream-Ideen mit einer gesunden Portion Skepsis begegnet und die Auswirkungen weit verbreiteter Techniken versteht
• Visualisierung des „Konzeptraums“ eines ConvNet mit t-SNE und PCA
• Fallstudien darüber, wie Unternehmen Computer-Vision-Techniken einsetzen, um bessere Ergebnisse zu erzielen
• Richtige Modellbewertung, Visualisierung des latenten Raums und Identifizierung der Aufmerksamkeit des Modells
• Durchführen von Domänenrecherchen, Bearbeiten eigener Datensätze und Etablieren von Modelltests
• Modernste Architekturen, die Weiterentwicklung von Ideen, was sie einzigartig macht und wie man sie umsetzt
• KerasCV – eine WIP-Bibliothek zum Erstellen hochmoderner Pipelines und Modelle
• Wie man Papiere parst, liest und selbst umsetzt
• Modellauswahl je nach Anwendung
• Erstellen einer End-to-End-Pipeline für maschinelles Lernen
• Landschaft und Intuition zur Objekterkennung mit Faster R-CNNs, RetinaNets, SSDs und YOLO
• Instanz- und semantische Segmentierung
• Objekterkennung in Echtzeit mit YOLOv5
• Training von YOLOv5-Objektdetektoren
• Arbeiten mit Transformers unter Verwendung von KerasNLP (industriestarke WIP-Bibliothek)
• Integrieren von Transformers in ConvNets zum Generieren von Bildunterschriften
• DeepDream
• Deep-Learning-Modelloptimierung für Computer Vision