Poseringsuppskattning/nyckelpunktsdetektion med YOLOv7 i Python

Beskrivning

Objektdetektering är ett stort fält inom datorseende och en av de viktigaste tillämpningarna för datorseende "i det vilda".

Objektdetektering är inte lika standardiserad som bildklassificering, främst eftersom de flesta av de nya utvecklingarna vanligtvis görs av enskilda forskare, underhållare och utvecklare, snarare än stora bibliotek och ramverk. Det är svårt att paketera de nödvändiga verktygsskripten i ett ramverk som TensorFlow eller PyTorch och behålla API-riktlinjerna som väglett utvecklingen hittills.

Detta gör objektdetektering något mer komplex, vanligtvis mer omfattande (men inte alltid) och mindre lättillgänglig än bildklassificering.

Lyckligtvis för massorna – Ultralytics har utvecklat ett enkelt, mycket kraftfullt och vackert objektdetekterings-API kring deras YOLOv5 som har utökats av andra forsknings- och utvecklingsteam till nyare versioner, som YOLOv7.

I den här korta guiden kommer vi att utföra Pose Estimation (Keypoint Detection) i Python, med toppmoderna YOLOv7.

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 och kan användas för att ersätta dyr positionsspårningsutrustning, möjliggör över-the-air robotstyrning och driver en ny tidsålder av mänskligt självuttryck genom AR och VR.

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 den första storskaliga implementeringen av YOLO i PyTorch, vilket gjorde den mer tillgänglig än någonsin tidigare, men den främsta anledningen till att YOLOv5 har fått ett sådant fotfäste är också det vackert enkla och kraftfulla API som är byggt runt det. Projektet abstraherar bort de onödiga detaljerna, samtidigt som det tillåter anpassningsbarhet, praktiskt taget alla användbara exportformat, och använder fantastiska metoder som gör hela projektet både effektivt och så optimalt som det kan bli.

YOLOv5 är fortfarande huvudprojektet att bygga objektdetekteringsmodeller med, och många arkiv som syftar till att avancera YOLO-metoden börjar med YOLOv5 som baslinje och erbjuder ett liknande API (eller helt enkelt splittra projektet och bygga ovanpå det). Så är fallet med YOLOR (Du lär dig bara en representation) och YOLOv7 som byggde ovanpå YOLOR (samma författare) vilket är det senaste framsteg inom YOLO-metoden.

YOLOv7 är inte bara en objektdetekteringsarkitektur – 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.

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 gå vidare och installera projektet från GitHub:

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

Detta skapar en yolov7 katalog under din nuvarande arbetskatalog, där du kommer att kunna hitta de grundläggande projektfilerna:

%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

Notera: Google Colab Notebooks återställs till huvudarbetskatalogen i nästa cell, även efter att du har ringt %cd dirname, så du måste fortsätta anropa den i varje cell du vill att en operation ska utföras i. Lokala Jupyter Notebooks kommer ihåg ändringen, så det finns ingen anledning att fortsätta anropa kommandot.

Närhelst du kör kod med en given uppsättning vikter – kommer de att laddas ner och lagras i den här katalogen. För att utföra ställningsuppskattning vill vi ladda ner vikterna för den förtränade YOLOv7-modellen för den uppgiften, som finns under /releases/download/ fliken på 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

Bra, vi har laddat ner yolov7-w6-pose.pt viktfil, som kan användas för att ladda och rekonstruera en tränad modell för ställningsuppskattning.

Laddar YOLOv7 Pose Estimation Model

Låt oss importera de bibliotek som vi behöver för att utföra ställningsuppskattning:

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 och torchvision är enkla nog – YOLOv7 implementeras med PyTorch. De utils.datasets, utils.general och utils.plots moduler kommer från YOLOv7-projektet och ger oss metoder som hjälper oss att förbearbeta och förbereda input för modellen att köra slutledning på. Bland dem finns letterbox() för att fylla bilden, non_max_supression_keypoint() att köra Non-Max Supression-algoritmen på modellens initiala utdata och att producera en ren utdata för vår tolkning, såväl som output_to_keypoint() och plot_skeleton_kpts() metoder för att faktiskt lägga till nyckelpunkter till en given bild, när de väl har förutspåtts.

Vi kan ladda modellen från viktfilen med torch.load(). Låt oss skapa en funktion för att kontrollera om en GPU är tillgänglig, ladda modellen, sätta den i inferensläge och flytta den till GPU:n om den är tillgänglig:

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

Med modellen laddad, låt oss skapa en run_inference() metod som accepterar en sträng som pekar på en fil på vårt system. Metoden kommer att läsa bilden med OpenCV (cv2), fyll den med letterbox(), applicera transformeringar på den och förvandla den till en batch (modellen är tränad på och förväntar sig batcher, som vanligt):

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

Här har vi returnerat den transformerade bilden (eftersom vi vill extrahera originalet och rita på det) och utdata från modellen. Dessa utgångar innehåller 45900 nyckelpunktsförutsägelser, varav de flesta överlappar varandra. Vi kommer att vilja tillämpa Non-Max-undertryckning på dessa råa förutsägelser, precis som med förutsägelser om objektdetektering (där många begränsningsrutor förutsägs och sedan "kollapseras" med tanke på visst förtroende och IoU-tröskel). Efter undertryckning kan vi plotta varje nyckelpunkt på originalbilden och visa den:

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

Nu, för någon ingångsbild, som t.ex karate.jpg i huvudarbetskatalogen kan vi köra inferens, utföra Non-Max Supression och plotta resultaten med:

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

Detta resulterar i:

Detta är en ganska svår bild att sluta sig till! Det mesta av utövarens högra arm till höger är dold, och vi kan se att modellen drar slutsatsen att den är dold och till höger om kroppen, utan att armbågen är böjd och att en del av armen är framför . Utövaren till vänster, som är mycket tydligare, antas korrekt, även med ett dolt ben.

Faktum är att en person som sitter baktill, nästan helt osynlig för kameran har fått sin ställning till synes korrekt uppskattad, bara baserat på höfternas position när de sitter ner. Bra jobbat för nätverkets räkning!

Slutsats

I den här guiden – vi har tagit en kort titt på YOLOv7, det senaste framsteg i YOLO-familjen, som bygger ovanpå YOLOR, och som ytterligare tillhandahåller instanssegmentering och nyckelpunktsdetekteringsmöjligheter utöver standardfunktionerna för objektdetektering hos de flesta YOLO-baserade modeller .

Vi har sedan tagit en titt på hur vi kan ladda ner släppta viktfiler, ladda in dem för att konstruera en modell och utföra ställningsuppskattningar för människor, vilket ger imponerande resultat.

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