Poseuppskattning i realtid från video i Python med YOLOv7

Beskrivning

Objektdetektering är ett stort fält inom datorseende och en av de viktigaste tillämpningarna för datorseende "i det vilda". Från den extraherades nyckelpunktsdetektering (som ofta används för ställningsuppskattning).

Nyckelpunkter kan vara olika punkter – delar av ett ansikte, lemmar på en kropp, etc. Poseuppskattning är ett specialfall av nyckelpunktsdetektering – där punkterna är delar av en människokropp.

Poseuppskattning är en fantastisk, extremt rolig och praktisk användning av datorseende. Med den kan vi göra oss av med hårdvara som används för att uppskatta poser (motion capture-dräkter), som är kostsamma och svårhanterliga. Dessutom kan vi kartlägga människors rörelser till robotars rörelse i det euklidiska rymden, vilket möjliggör finprecisionsmotorrörelser utan att använda kontroller, som vanligtvis inte tillåter högre precisionsnivåer. Nyckelpunktsuppskattning kan användas för att översätta våra rörelser till 3D-modeller i AR och VR, och används allt oftare för att göra det med bara en webbkamera. Slutligen – ställningsuppskattning kan hjälpa oss inom sport och säkerhet.

I den här guiden kommer vi att utföra positionsuppskattning i realtid från en video i Python, med hjälp av den toppmoderna YOLOv7-modellen.

Specifikt kommer vi att arbeta med en video från vinter-OS 2018, som hölls i Sydkoreas PyeongChang:

Aljona Savchenko och Bruno Massot gjorde en fantastisk prestation, inklusive överlappande kroppar mot kameran, snabba flytande rörelser och snurrande i luften. Det kommer att bli ett fantastiskt tillfälle att se hur modellen hanterar svåröverskådliga situationer!

YOLO och Pose Estimation

YOLO (Du tittar bara en gång) är en metodik, såväl som en familj av modeller byggda för objektdetektering. Sedan starten 2015 har YOLOv1, YOLOv2 (YOLO9000) och YOLOv3 föreslagits av samma författare – och djupinlärningsgemenskapen fortsatte med framsteg med öppen källkod under de pågående åren.

Ultralytics YOLOv5 är ett industriklassat objektdetekteringsförråd, byggt ovanpå YOLO-metoden. Den är implementerad i PyTorch, till skillnad från C++ för tidigare YOLO-modeller, är helt öppen källkod och har ett vackert enkelt och kraftfullt API som låter dig sluta, träna och anpassa projektet flexibelt. Det är en sådan bas att de flesta nya försök att förbättra YOLO-metoden bygger på det.

Det är så YOLOR (Du lär dig bara en representation) och YOLOv7 som byggdes ovanpå YOLOR (samma författare) skapades också!

YOLOv7 är inte bara en objektdetekteringsarkitektur – den tillhandahåller nya modellhuvuden som kan mata ut nyckelpunkter (skelett) och utföra instanssegmentering förutom bara bounding box-regression, vilket inte var standard med tidigare YOLO-modeller. Detta är inte förvånande, eftersom många objektdetekteringsarkitekturer har återanvänts, till exempel segmenterings- och nyckelpunktsdetekteringsuppgifter tidigare, på grund av den delade allmänna arkitekturen, med olika utdata beroende på uppgiften.

Även om det inte är förvånande – att stödja instanssegmentering och nyckelpunktsdetektion kommer sannolikt att bli den nya standarden för YOLO-baserade modeller, som har börjat överträffa praktiskt taget alla andra tvåstegsdetektorer för ett par år sedan när det gäller både noggrannhet och hastighet.

Detta gör instanssegmentering och nyckelpunktsdetektion snabbare att utföra än någonsin tidigare, med en enklare arkitektur än tvåstegsdetektorer.

Själva modellen skapades genom arkitektoniska förändringar, såväl som genom att optimera aspekter av träning, kallad "bag-of-freebies", vilket ökade noggrannheten utan att öka slutsatskostnaden.

Installerar YOLOv7

Låt oss börja med att klona förvaret för att få tag på källkoden:

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

Låt oss nu gå in i yolov7 katalog, som innehåller projektet, och ta en titt på innehållet:

%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

Nu är YOLO avsedd att vara en objektdetektor och levereras inte med poseuppskattningsvikter som standard. Vi vill ladda ner vikterna och ladda en konkret modellinstans från dem. Vikterna är tillgängliga på samma GitHub-förråd och kan enkelt laddas ner via CLI också:

! 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

När vi har laddat ned kan vi importera biblioteken och hjälpmetoderna vi kommer att använda:

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

Bra! Låt oss fortsätta med att ladda modellen och skapa ett skript som låter dig härleda poser från videor med YOLOv7 och OpenCV.

Poseringsuppskattning i realtid med YOLOv7

Låt oss först skapa en metod för att ladda modellen från de nedladdade vikterna. Vi kontrollerar vilken enhet vi har tillgänglig (CPU eller 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()

Beroende på om vi har en GPU eller inte, kommer vi att aktivera halvprecision (med float16 istället för float32 i operationer), vilket gör slutsatser betydligt snabbare. Observera att det uppmuntras starkt att utföra detta på en GPU för realtidshastigheter, eftersom processorer sannolikt kommer att sakna kraften att göra det om de inte körs på små videor.

Låt oss skriva en bekvämlighetsmetod för att köra slutledning. Vi accepterar bilder som NumPy-matriser (eftersom det är vad vi kommer att skicka dem senare när vi läser videon). Först använder du letterbox() funktion – vi kommer att ändra storlek och vaddera videon till en form som modellen kan arbeta med. Detta behöver inte vara och kommer inte att vara formen (upplösningen) på den resulterande videon!

Sedan tillämpar vi transformationerna, konverterar bilden till halv precision (om en GPU är tillgänglig), batchar den och kör den genom modellen:

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

Vi kommer att returnera modellens förutsägelser, såväl som bilden som en tensor. Det här är "grova" förutsägelser - de innehåller många aktiveringar som överlappar varandra, och vi vill "rensa upp dem" med Non-Max Supression och plotta de förutspådda skeletten över själva bilden:

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

Med dessa på plats kommer vårt allmänna flöde att se ut så här:

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

För att översätta det till en videoinställning i realtid – vi använder OpenCV för att läsa en video och kör den här processen för varje bildruta. På varje bildruta kommer vi också att skriva bildrutan till en ny fil, kodad som en video. Detta kommer nödvändigtvis att sakta ner processen när vi kör slutledningen, visar den och skriver – så att du kan påskynda slutledningen och visningen genom att undvika att skapa en ny fil och skriva till den i slingan:

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

Smakämnen VideoWriter accepterar flera parametrar – utdatafilnamnet, FourCC (fyra codec-koder, anger den codec som används för att koda videon), framerate och upplösningen som en tupel. För att inte gissa eller ändra storlek på videon – vi har använt bredden och höjden på originalvideon, erhållen genom VideoCapture instans som innehåller data om själva videon, såsom bredd, höjd, totalt antal bildrutor, etc.

Nu kan vi anropa metoden på vilken ingångsvideo som helst:

pose_estimation_video('../ice_skating.mp4')

Detta öppnar ett OpenCV-fönster som visar slutsatsen i realtid. Och det kommer också att skriva en videofil i yolov7 katalog (eftersom vi har cdgick in på det):

Slutsats

I den här guiden har vi tagit en titt på YOLO-metoden, YOLOv7 och förhållandet mellan YOLO och objektdetektering, ställningsuppskattning och instanssegmentering. Vi har sedan tagit en titt på hur du enkelt kan installera och arbeta med YOLOv7 med hjälp av det programmatiska API:t och skapat flera bekvämlighetsmetoder för att göra slutledningar och visning av resultat enklare.

Slutligen har vi öppnat en video med OpenCV, kört inferens med YOLOv7 och skapat en funktion för att utföra poseringsuppskattning i realtid, spara den resulterande videon i full upplösning och 30FPS på din lokala disk.

Going Further – Praktisk djupinlärning för datorseende

Din nyfikna natur gör att du vill gå längre? Vi rekommenderar att du kollar in vår Kurs: "Praktisk djupinlärning för datorseende med Python".

Ännu en kurs i datorseende?

Vi kommer inte att göra klassificering av MNIST-siffror eller MNIST-mode. De tjänade sin del för länge sedan. Alltför många inlärningsresurser fokuserar på grundläggande datamängder och grundläggande arkitekturer innan de låter avancerade blackbox-arkitekturer bära bördan av prestanda.

Vi vill fokusera på avmystifiering, praktiskhet, förståelse, intuition och riktiga projekt. Vill lära sig hur du kan göra skillnad? Vi tar dig med på en tur från hur våra hjärnor bearbetar bilder till att skriva en klassificerare för djupinlärning för bröstcancer i forskningsklass till nätverk för djupinlärning som "hallucinerar", lär dig principer och teorier genom praktiskt arbete, och utrustar dig med kunskap och verktyg för att bli expert på att tillämpa djupinlärning för att lösa datorseende.

Vad är inuti?

• De första principerna för syn och hur datorer kan läras att "se"
• Olika uppgifter och tillämpningar av datorseende
• Branschens verktyg som gör ditt arbete enklare
• Hitta, skapa och använda datauppsättningar för datorseende
• Teorin och tillämpningen av Convolutional Neural Networks
• Hantera domänskifte, samtidig förekomst och andra fördomar i datamängder
• Överför Lärande och utnyttja andras träningstid och beräkningsresurser till din fördel
• Bygga och träna en toppmodern klassificerare för bröstcancer
• Hur man applicerar en hälsosam dos av skepsis på mainstream idéer och förstår implikationerna av allmänt använda tekniker
• Visualisera ett ConvNets "konceptutrymme" med t-SNE och PCA
• Fallstudier av hur företag använder datorseendetekniker för att uppnå bättre resultat
• Korrekt modellutvärdering, latent rumsvisualisering och identifiering av modellens uppmärksamhet
• Utföra domänforskning, bearbeta dina egna datamängder och upprätta modelltester
• Banbrytande arkitekturer, utvecklingen av idéer, vad som gör dem unika och hur man implementerar dem
• KerasCV – ett WIP-bibliotek för att skapa toppmoderna pipelines och modeller
• Hur man analyserar och läser uppsatser och implementerar dem själv
• Välja modeller beroende på din applikation
• Skapa en komplett maskininlärningspipeline
• Landskap och intuition på objektdetektering med snabbare R-CNN, RetinaNets, SSD och YOLO
• Instans och semantisk segmentering
• Objektigenkänning i realtid med YOLOv5
• Träning av YOLOv5-objektdetektorer
• Arbeta med transformatorer med KerasNLP (industristarkt WIP-bibliotek)
• Integrering av Transformers med ConvNets för att generera bildtexter
• DeepDream
• Deep Learning-modelloptimering för datorseende