Posenschätzung/Schlüsselpunkterkennung mit YOLOv7 in Python

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 Pose Estimation (Keypoint Detection) in Python mit dem hochmodernen YOLOv7 durch.

Schlüsselpunkte können verschiedene Punkte sein – Teile eines Gesichts, Gliedmaßen eines Körpers usw. Die Posenschätzung ist ein Sonderfall der Schlüsselpunkterkennung – bei der die Punkte Teile eines menschlichen Körpers sind und verwendet werden können, um teure Positionsverfolgungshardware zu ersetzen. Ermöglichen Sie die Steuerung von Over-the-Air-Robotik und treiben Sie ein neues Zeitalter des menschlichen Selbstausdrucks durch AR und VR voran.

YOLO und Posenschätzung

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, dem neuesten Fortschritt in der YOLO-Methodik.

YOLOv7 ist nicht nur eine Objekterkennungsarchitektur – bietet neue Modellköpfe, die Keypoints (Skelette) ausgeben und eine Instanzsegmentierung durchführen können, neben nur einer Bounding-Box-Regression, die bei früheren YOLO-Modellen nicht Standard war. Dies ist nicht überraschend, da viele Objekterkennungsarchitekturen aufgrund der gemeinsamen allgemeinen Architektur auch früher für beispielsweise Segmentierungs- und Schlüsselpunkterkennungsaufgaben umfunktioniert wurden, mit unterschiedlichen Ausgaben je nach Aufgabe. Auch wenn es nicht überraschend ist – die Unterstützung von Instanzsegmentierung und Keypoint-Erkennung wird wahrscheinlich zum neuen Standard für YOLO-basierte Modelle, die vor einigen Jahren damit begonnen haben, praktisch alle anderen zweistufigen Detektoren zu übertreffen.

Dies macht die Instanzsegmentierung und Schlüsselpunkterkennung schneller als je zuvor, mit einer einfacheren Architektur als zweistufige Detektoren.

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

Lassen Sie uns fortfahren und das Projekt von GitHub installieren:

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

Dies schafft ein yolov7 Verzeichnis unter Ihrem aktuellen Arbeitsverzeichnis, in dem Sie die grundlegenden Projektdateien finden können:

%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

Hinweis: Google Colab Notebooks werden auch nach dem Anruf auf das Hauptarbeitsverzeichnis in der nächsten Zelle zurückgesetzt %cd dirname, also müssen Sie ihn in jeder Zelle aufrufen, in der eine Operation ausgeführt werden soll. Lokale Jupyter-Notebooks merken sich die Änderung, sodass Sie den Befehl nicht ständig aufrufen müssen.

Immer wenn Sie Code mit einem bestimmten Satz von Gewichtungen ausführen, werden sie heruntergeladen und in diesem Verzeichnis gespeichert. Um die Posenschätzung durchzuführen, möchten wir die Gewichte für das vortrainierte YOLOv7-Modell für diese Aufgabe herunterladen, das unter zu finden ist /releases/download/ Registerkarte auf GitHub:

! curl -L https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-w6-pose.pt -o yolov7-w6-pose.pt
%cd ..

  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
100  153M  100  153M    0     0  3742k      0  0:00:42  0:00:42 --:--:-- 4573k

/Users/macbookpro/jup

Toll, wir haben die heruntergeladen yolov7-w6-pose.pt weights-Datei, die zum Laden und Rekonstruieren eines trainierten Modells für die Posenschätzung verwendet werden kann.

Laden des YOLOv7 Posenschätzungsmodells

Lassen Sie uns die Bibliotheken importieren, die wir für die Posenschätzung benötigen:

import torch
from torchvision import transforms

from utils.datasets import letterbox
from utils.general import non_max_suppression_kpt
from utils.plots import output_to_keypoint, plot_skeleton_kpts

import matplotlib.pyplot as plt
import cv2
import numpy as np

torch und torchvision sind einfach genug – YOLOv7 wird mit PyTorch implementiert. Das utils.datasets, utils.general und utils.plots -Module stammen aus dem YOLOv7-Projekt und stellen uns Methoden zur Verfügung, die bei der Vorverarbeitung und Vorbereitung von Eingaben für das Modell helfen, auf denen Inferenzen ausgeführt werden. Darunter sind letterbox() um das Bild aufzufüllen, non_max_supression_keypoint() um den Non-Max-Supression-Algorithmus auf der anfänglichen Ausgabe des Modells auszuführen und eine saubere Ausgabe für unsere Interpretation zu erzeugen, sowie die output_to_keypoint() und plot_skeleton_kpts() Methoden, um Schlüsselpunkte tatsächlich zu einem bestimmten Bild hinzuzufügen, sobald sie vorhergesagt wurden.

Wir können das Modell aus der Gewichtsdatei mit laden torch.load(). Erstellen wir eine Funktion, um zu prüfen, ob eine GPU verfügbar ist, laden Sie das Modell, versetzen Sie es in den Inferenzmodus und verschieben Sie es auf die GPU, falls verfügbar:

def load_model():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model = torch.load('yolov7/yolov7-w6-pose.pt', map_location=device)['model']
    
    model.float().eval()

    if torch.cuda.is_available():
        
        
        model.half().to(device)
    return model

model = load_model()

Lassen Sie uns mit dem geladenen Modell eine erstellen run_inference() Methode, die einen String akzeptiert, der auf eine Datei auf unserem System zeigt. Die Methode liest das Bild mit OpenCV (cv2), polstern Sie es mit letterbox(), wenden Sie Transformationen darauf an und wandeln Sie es in einen Stapel um (das Modell wird trainiert und erwartet wie üblich Stapel):

def run_inference(url):
    image = cv2.imread(url) 
    
    image = letterbox(image, 960, stride=64, auto=True)[0] 
    
    image = transforms.ToTensor()(image) 
    
    image = image.unsqueeze(0) 
    output, _ = model(image) 
    return output, image

Hier haben wir das transformierte Bild (weil wir das Original extrahieren und darauf plotten möchten) und die Ausgaben des Modells zurückgegeben. Diese Ausgaben enthalten 45900 Schlüsselpunktvorhersagen, von denen sich die meisten überschneiden. Wir möchten die Non-Max-Unterdrückung auf diese Rohvorhersagen anwenden, genau wie bei Objekterkennungsvorhersagen (bei denen viele Begrenzungsrahmen vorhergesagt werden und sie dann bei gewissem Vertrauen und IoU-Schwellenwert „eingeklappt“ werden). Nach der Unterdrückung können wir jeden Schlüsselpunkt auf dem Originalbild darstellen und anzeigen:

def visualize_output(output, image):
    output = non_max_suppression_kpt(output, 
                                     0.25, 
                                     0.65, 
                                     nc=model.yaml['nc'], 
                                     nkpt=model.yaml['nkpt'], 
                                     kpt_label=True)
    with torch.no_grad():
        output = output_to_keypoint(output)
    nimg = image[0].permute(1, 2, 0) * 255
    nimg = nimg.cpu().numpy().astype(np.uint8)
    nimg = cv2.cvtColor(nimg, cv2.COLOR_RGB2BGR)
    for idx in range(output.shape[0]):
        plot_skeleton_kpts(nimg, output[idx, 7:].T, 3)
    plt.figure(figsize=(12, 12))
    plt.axis('off')
    plt.imshow(nimg)
    plt.show()

Nun, für einige Eingabebilder, wie z karate.jpg Im Hauptarbeitsverzeichnis können wir Inferenz ausführen, Non-Max-Unterdrückung durchführen und die Ergebnisse darstellen mit:

output, image = run_inference('./karate.jpg')
visualize_output(output, image)

Das führt zu:

Dies ist ein ziemlich schwer zu folgerndes Bild! Der größte Teil des rechten Arms des Praktizierenden auf der rechten Seite ist verdeckt, und wir können sehen, dass das Modell davon ausgeht, dass er verdeckt und rechts vom Körper liegt, wobei fehlt, dass der Ellbogen gebeugt ist und dass ein Teil des Arms vorne ist . Der viel deutlicher sichtbare Behandler links wird auch bei verstecktem Bein richtig erkannt.

In der Tat – eine Person, die hinten sitzt, fast vollständig unsichtbar für die Kamera hat ihre Pose scheinbar richtig eingeschätzt, nur basierend auf der Position der Hüften im Sitzen. Großartige Arbeit für das Netzwerk!

Zusammenfassung

In diesem Leitfaden haben wir einen kurzen Blick auf YOLOv7 geworfen, die neueste Weiterentwicklung der YOLO-Familie, die auf YOLOR aufbaut und über die standardmäßigen Objekterkennungsfunktionen der meisten YOLO-basierten Modelle hinaus Funktionen zur Instanzsegmentierung und Schlüsselpunkterkennung bietet .

Wir haben uns dann angesehen, wie wir freigegebene Gewichtsdateien herunterladen, sie laden können, um ein Modell zu konstruieren und eine Inferenz zur Posenschätzung für Menschen durchzuführen, was beeindruckende Ergebnisse liefert.

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