Posenschätzung in Echtzeit aus Video 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“. Daraus wurde die Keypoint-Erkennung (häufig zur Posenschätzung verwendet) extrahiert.

Schlüsselpunkte können verschiedene Punkte sein – Teile eines Gesichts, Gliedmaßen eines Körpers usw. Die Posenschätzung ist ein Spezialfall der Schlüsselpunkterkennung – bei der die Punkte Teile eines menschlichen Körpers sind.

Die Posenschätzung ist eine erstaunliche, äußerst unterhaltsame und praktische Anwendung von Computer Vision. Damit können wir auf teure und unhandliche Hardware zur Posenschätzung (Motion-Capture-Anzüge) verzichten. Darüber hinaus können wir die Bewegung von Menschen auf die Bewegung von Robotern im euklidischen Raum abbilden, wodurch feinpräzise motorische Bewegungen ohne die Verwendung von Controllern ermöglicht werden, die normalerweise keine höheren Präzisionsniveaus zulassen. Die Keypoint-Schätzung kann verwendet werden, um unsere Bewegungen in 3D-Modelle in AR und VR zu übersetzen, und wird zunehmend nur mit einer Webcam verwendet. Schließlich – die Posenschätzung kann uns beim Sport und bei der Sicherheit helfen.

In diesem Leitfaden führen wir mithilfe des hochmodernen YOLOv7-Modells eine Posenschätzung in Echtzeit aus einem Video in Python durch.

Insbesondere werden wir mit einem Video von den Olympischen Winterspielen 2018 arbeiten, die im südkoreanischen PyeongChang stattfanden:

Aljona Savchenko und Bruno Massot haben eine erstaunliche Leistung gezeigt, einschließlich überlappender Körper vor der Kamera, schneller fließender Bewegungen und Drehungen in der Luft. Es wird eine großartige Gelegenheit sein, zu sehen, wie das Modell mit schwierig zu erschließenden Situationen umgeht!

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 ein Objekterkennungs-Repository der Industrieklasse, das auf der YOLO-Methode aufbaut. Es ist in PyTorch implementiert, im Gegensatz zu C++ für frühere YOLO-Modelle, ist vollständig Open Source und verfügt über eine wunderbar einfache und leistungsstarke API, mit der Sie das Projekt flexibel ableiten, trainieren und anpassen können. Es ist so ein Grundnahrungsmittel, dass die meisten neuen Versuche zur Verbesserung der YOLO-Methode darauf aufbauen.

So sieht es aus, wenn YOLOR (Sie lernen nur eine Darstellung) und YOLOv7, die auf YOLOR (gleicher Autor) aufbauen, wurden ebenfalls erstellt!

YOLOv7 ist nicht nur eine Objekterkennungsarchitektur – es bietet neue Modellköpfe, die Keypoints (Skelette) ausgeben und Instanzsegmentierung neben nur Bounding-Box-Regression durchführen können, was 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 begonnen haben, praktisch alle anderen zweistufigen Detektoren in Bezug auf Genauigkeit und Geschwindigkeit 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

Beginnen wir damit, das Repository zu klonen, um den Quellcode zu erhalten:

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

Kommen wir nun zu den yolov7 Verzeichnis, das das Projekt enthält, und werfen Sie einen Blick auf den Inhalt:

%cd yolov7
!ls

/content/yolov7
cfg	   figure      output.mp4	 test.py       
data	   hubconf.py  paper		 tools
deploy	   inference   README.md	 train_aux.py
detect.py  LICENSE.md  requirements.txt  train.py
export.py  models      scripts		 utils

Jetzt ist YOLO als Objektdetektor gedacht und wird standardmäßig nicht mit Posenschätzungsgewichten ausgeliefert. Wir möchten die Gewichte herunterladen und daraus eine konkrete Modellinstanz laden. Die Gewichtungen sind im selben GitHub-Repository verfügbar und können auch einfach über die CLI heruntergeladen werden:

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

 % 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  23.4M      0  0:00:06  0:00:06 --:--:-- 32.3M

Nach dem Herunterladen können wir die Bibliotheken und Hilfsmethoden importieren, die wir verwenden werden:

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

Groß! Fahren wir mit dem Laden des Modells und dem Erstellen eines Skripts fort, mit dem Sie Posen aus Videos mit YOLOv7 und OpenCV ableiten können.

Posenschätzung in Echtzeit mit YOLOv7

Lassen Sie uns zuerst eine Methode erstellen, um das Modell aus den heruntergeladenen Gewichten zu laden. Wir prüfen, welches Gerät wir zur Verfügung haben (CPU oder GPU):

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

def load_model():
    model = torch.load('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()

Abhängig davon, ob wir eine GPU haben oder nicht, schalten wir die halbe Genauigkeit ein (mithilfe von float16 statt float32 im Betrieb), was die Inferenz erheblich beschleunigt. Beachten Sie, dass es dringend empfohlen wird, dies auf einer GPU für Echtzeitgeschwindigkeiten durchzuführen, da CPUs wahrscheinlich nicht die Leistung dafür haben, es sei denn, sie laufen auf kleinen Videos.

Lassen Sie uns eine Convinience-Methode zum Ausführen von Inferenzen schreiben. Wir akzeptieren Bilder als NumPy-Arrays (da wir sie später beim Lesen des Videos weitergeben werden). Zuerst mit der letterbox() Funktion – Wir ändern die Größe des Videos und füllen es in eine Form auf, mit der das Modell arbeiten kann. Dies muss und wird nicht die Form (Auflösung) des resultierenden Videos sein!

Dann wenden wir die Transformationen an, konvertieren das Bild in halbe Genauigkeit (falls eine GPU verfügbar ist), stapeln es und führen es durch das Modell:

def run_inference(image):
    
    image = letterbox(image, 960, stride=64, auto=True)[0] 
    
    image = transforms.ToTensor()(image) 
    if torch.cuda.is_available():
      image = image.half().to(device)
    
    image = image.unsqueeze(0) 
    with torch.no_grad():
      output, _ = model(image)
    return output, image

Wir geben die Vorhersagen des Modells sowie das Bild als Tensor zurück. Dies sind „grobe“ Vorhersagen – sie enthalten viele Aktivierungen, die sich überschneiden, und wir wollen sie mit Non-Max-Unterdrückung „bereinigen“ und die vorhergesagten Skelette über das Bild selbst zeichnen:

def draw_keypoints(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)

  return nimg

Wenn diese vorhanden sind, sieht unser allgemeiner Ablauf folgendermaßen aus:

img = read_img()
outputs, img = run_inference(img)
keypoint_img = draw_keypoints(output, img)

Um dies in eine Echtzeit-Videoeinstellung zu übersetzen, verwenden wir OpenCV, um ein Video zu lesen, und führen diesen Prozess für jeden Frame aus. Bei jedem Frame schreiben wir auch den Frame in eine neue Datei, die als Video codiert ist. Dies verlangsamt zwangsläufig den Prozess, da wir die Inferenz ausführen, anzeigen und schreiben – Sie können also die Inferenz und Anzeige beschleunigen, indem Sie die Erstellung einer neuen Datei vermeiden und in die Schleife schreiben:

def pose_estimation_video(filename):
    cap = cv2.VideoCapture(filename)
    
    fourcc = cv2.VideoWriter_fourcc(*'MP4V')
    out = cv2.VideoWriter('ice_skating_output.mp4', fourcc, 30.0, (int(cap.get(3)), int(cap.get(4))))
    while cap.isOpened():
        (ret, frame) = cap.read()
        if ret == True:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            output, frame = run_inference(frame)
            frame = draw_keypoints(output, frame)
            frame = cv2.resize(frame, (int(cap.get(3)), int(cap.get(4))))
            out.write(frame)
            cv2.imshow('Pose estimation', frame)
        else:
            break

        if cv2.waitKey(10) & 0xFF == ord('q'):
            break

    cap.release()
    out.release()
    cv2.destroyAllWindows()

Das VideoWriter akzeptiert mehrere Parameter – den Ausgabedateinamen, den FourCC (vier Codec-Codes, die den Codec angeben, der zum Codieren des Videos verwendet wird), die Framerate und die Auflösung als Tupel. Um das Video nicht zu erraten oder zu skalieren – wir haben die Breite und Höhe des Originalvideos verwendet, das durch das erhalten wurde VideoCapture Instanz, die Daten über das Video selbst enthält, wie z. B. Breite, Höhe, Gesamtzahl der Frames usw.

Jetzt können wir die Methode für jedes Eingabevideo aufrufen:

pose_estimation_video('../ice_skating.mp4')

Dadurch wird ein OpenCV-Fenster geöffnet, das die Inferenz in Echtzeit anzeigt. Außerdem schreibt es eine Videodatei in die yolov7 Verzeichnis (da wir cddrin war):

Zusammenfassung

In diesem Leitfaden haben wir uns die YOLO-Methode, YOLOv7 und die Beziehung zwischen YOLO und Objekterkennung, Posenschätzung und Instanzsegmentierung angesehen. Anschließend haben wir uns angesehen, wie Sie YOLOv7 mithilfe der programmatischen API einfach installieren und damit arbeiten können, und mehrere Convinience-Methoden erstellt, um die Inferenz und die Anzeige von Ergebnissen zu vereinfachen.

Schließlich haben wir ein Video mit OpenCV geöffnet, eine Inferenz mit YOLOv7 durchgeführt und eine Funktion zur Durchführung einer Posenschätzung in Echtzeit erstellt, wobei das resultierende Video in voller Auflösung und 30 FPS auf Ihrer lokalen Festplatte gespeichert wurde.

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