Ocena položaja v realnem času iz videa v Pythonu z YOLOv7

Predstavitev

Zaznavanje predmetov je obsežno področje računalniškega vida in ena pomembnejših aplikacij računalniškega vida »v naravi«. Iz njega je bilo pridobljeno zaznavanje ključnih točk (ki se pogosto uporablja za oceno položaja).

Ključne točke so lahko različne točke – deli obraza, okončine telesa itd. Ocena položaja je poseben primer zaznavanja ključnih točk – pri katerem so točke deli človeškega telesa.

Ocena položaja je neverjetna, izjemno zabavna in praktična uporaba računalniškega vida. Z njim lahko odpravimo strojno opremo, ki se uporablja za ocenjevanje poz (obleke za zajem gibanja), ki je draga in okorna. Poleg tega lahko preslikamo gibanje ljudi v gibanje robotov v evklidskem prostoru, kar omogoča fino natančno gibanje motorja brez uporabe krmilnikov, ki običajno ne omogočajo višjih ravni natančnosti. Oceno ključne točke je mogoče uporabiti za prevajanje naših gibov v 3D modele v AR in VR, vse pogosteje pa se uporablja za to samo s spletno kamero. Končno – ocena položaja nam lahko pomaga pri športu in varnosti.

V tem priročniku bomo izvedli oceno položaja v realnem času iz videoposnetka v Pythonu z uporabo najsodobnejšega modela YOLOv7.

Natančneje, delali bomo z videoposnetkom z zimskih olimpijskih iger 2018, ki so potekale v južnokorejskem Pjongčangu:

Aljona Savchenko in Bruno Massot sta naredila neverjeten nastop, vključno s prekrivajočimi se telesi proti kameri, hitrim tekočim gibanjem in vrtenjem v zraku. To bo izjemna priložnost, da vidimo, kako se model spopada s situacijami, ki jih je težko sklepati!

YOLO in ocena poze

YOLO (pogledaš samo enkrat) je metodologija, pa tudi družina modelov, zgrajenih za odkrivanje objektov. Od ustanovitve leta 2015 so YOLOv1, YOLOv2 (YOLO9000) in YOLOv3 predlagali isti avtorji – in skupnost za globoko učenje je v naslednjih letih nadaljevala z odprtokodnim napredkom.

Ultralytics' YOLOv5 je repozitorij za odkrivanje predmetov industrijskega razreda, zgrajen na podlagi metode YOLO. Implementiran je v PyTorchu, v nasprotju s C++ za prejšnje modele YOLO, je popolnoma odprtokoden in ima čudovito preprost in zmogljiv API, ki vam omogoča sklepanje, usposabljanje in prilagodljivo prilagajanje projekta. To je tako pomembna sestavina, da večina novih poskusov izboljšanja metode YOLO temelji na njej.

Tako je YOLOR (Naučiš se samo enega prikaza) in YOLOv7, ki je bil zgrajen na vrhu YOLOR (isti avtor), sta bila prav tako ustvarjena!

YOLOv7 ni samo arhitektura za zaznavanje objektov – ponuja nove glave modelov, ki lahko izpišejo ključne točke (okostja) in izvedejo segmentacijo primerkov poleg le regresije omejevalnih okvirjev, kar ni bilo standardno pri prejšnjih modelih YOLO. To ni presenetljivo, saj je bilo zaradi skupne splošne arhitekture veliko arhitektur zaznavanja objektov spremenjenih namenov za na primer naloge segmentacije in zaznavanja ključnih točk, z različnimi izhodi glede na nalogo.

Čeprav ni presenetljivo – podpora segmentaciji primerkov in zaznavanju ključnih točk bo verjetno postala nov standard za modele, ki temeljijo na YOLO, ki so pred nekaj leti začeli prekašati praktično vse druge dvostopenjske detektorje tako v smislu natančnosti kot hitrosti.

Zaradi tega sta segmentacija primerkov in zaznavanje ključnih točk hitrejša kot kdaj koli prej, s preprostejšo arhitekturo kot dvostopenjski detektorji.

Sam model je bil ustvarjen z arhitekturnimi spremembami, pa tudi z optimiziranimi vidiki usposabljanja, imenovanimi »bag-of-freebies«, kar je povečalo natančnost brez povečanja stroškov sklepanja.

Namestitev YOLOv7

Začnimo s kloniranjem repozitorija, da se dokopamo do izvorne kode:

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

Zdaj pa pojdimo na yolov7 imenik, v katerem je projekt, in si oglejte vsebino:

%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

Zdaj je YOLO mišljen kot detektor predmetov in ni privzeto dobavljen z utežmi ocene položaja. Želeli bomo prenesti uteži in iz njih naložiti konkreten primerek modela. Uteži so na voljo v istem repozitoriju GitHub in jih je mogoče enostavno prenesti tudi prek CLI:

! 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

Ko jih prenesemo, lahko uvozimo knjižnice in pomožne metode, ki jih bomo uporabljali:

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

Super! Nadaljujmo z nalaganjem modela in ustvarjanjem skripta, ki vam omogoča sklepanje postav iz videoposnetkov z YOLOv7 in OpenCV.

Ocena položaja v realnem času z YOLOv7

Najprej ustvarimo metodo za nalaganje modela iz prenesenih uteži. Preverili bomo, katero napravo imamo na voljo (CPE ali GPE):

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

Odvisno od tega, ali imamo GPE ali ne, bomo vklopili polovično natančnost (z uporabo float16 Namesto float32 v operacijah), zaradi česar je sklepanje bistveno hitrejše. Upoštevajte, da je zelo priporočljivo, da to izvedete na grafičnem procesorju za hitrosti v realnem času, saj procesorjem verjetno ne bo dovolj moči za to, razen če se izvajajo na majhnih videoposnetkih.

Napišimo priročno metodo za izvajanje sklepanja. Slike bomo sprejeli kot nize NumPy (ker jim bomo to posredovali pozneje med branjem videa). Najprej z uporabo letterbox() funkcijo – videoposnetku bomo spremenili velikost in ga podložili v obliko, s katero bo model lahko deloval. Ni nujno, da je in ne bo to oblika (ločljivost) nastalega videoposnetka!

Nato bomo uporabili transformacije, sliko pretvorili v polovično natančnost (če je GPE na voljo), jo serijsko obdelali in pognali skozi model:

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

Vrnili bomo napovedi modela, pa tudi sliko kot tenzor. To so "grobe" napovedi - vsebujejo veliko aktivacij, ki se prekrivajo, in želeli jih bomo "počistiti" z uporabo ne-max supresije in narisati predvidene skelete čez samo sliko:

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

Ko jih postavimo, bo naš splošni tok videti takole:

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

Da bi to prevedli v nastavitev videa v realnem času, bomo uporabili OpenCV za branje videoposnetka in zagnali ta postopek za vsak okvir. Na vsak okvir bomo tudi zapisali okvir v novo datoteko, kodirano kot video. To bo nujno upočasnilo postopek, saj izvajamo sklepanje, ga prikazujemo in pišemo – tako da lahko pospešite sklepanje in prikaz tako, da se izognete ustvarjanju nove datoteke in pisanju vanjo v zanki:

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

O VideoWriter sprejme več parametrov – ime izhodne datoteke, FourCC (štiri kode kodekov, ki označujejo kodek, ki se uporablja za kodiranje videoposnetka), hitrost sličic in ločljivost kot tuple. Da ne bi ugibali ali spreminjali velikosti videoposnetka – uporabili smo širino in višino izvirnega videa, pridobljeno prek VideoCapture primerek, ki vsebuje podatke o samem videu, kot so širina, višina, skupno število sličic itd.

Zdaj lahko metodo pokličemo na katerem koli vhodnem videu:

pose_estimation_video('../ice_skating.mp4')

S tem se odpre okno OpenCV, ki prikazuje sklepanje v realnem času. Prav tako bo zapisal video datoteko v yolov7 imenik (odkar smo cdbi vanj):

zaključek

V tem priročniku smo si ogledali metodo YOLO, YOLOv7 in razmerje med YOLO in zaznavanjem predmetov, oceno položaja in segmentacijo primerkov. Nato smo si ogledali, kako lahko enostavno namestite YOLOv7 in delate z njim z uporabo programskega API-ja, in ustvarili več priročnih metod za lažje sklepanje in prikazovanje rezultatov.

Nazadnje smo odprli videoposnetek z uporabo OpenCV, zagnali sklepanje z YOLOv7 in izdelali funkcijo za izvajanje ocene položaja v realnem času, pri čemer smo dobljeni videoposnetek shranili v polni ločljivosti in 30 FPS na vaš lokalni disk.

Naprej – Praktično poglobljeno učenje za računalniški vid

Ali zaradi vaše radovedne narave želite iti dlje? Priporočamo, da si ogledate naše Tečaj: »Praktično poglobljeno učenje za računalniški vid s Pythonom«.

Še en tečaj računalniškega vida?

Ne bomo izvajali klasifikacije števk MNIST ali načina MNIST. Svojo so že zdavnaj odslužili. Preveč učnih virov se osredotoča na osnovne nabore podatkov in osnovne arhitekture, preden prepusti naprednim arhitekturam črnih skrinjic breme zmogljivosti.

Želimo se osredotočiti na demistifikacija, praktičnosti, razumevanje, intuicija in pravi projekti. Želim se naučiti kako lahko kaj spremeniš? Popeljali vas bomo od načina, na katerega naši možgani obdelujejo slike, do pisanja raziskovalnega klasifikatorja globokega učenja za raka dojke do omrežij globokega učenja, ki »halucinirajo«, vas naučijo načel in teorije s praktičnim delom ter vas opremijo z znanje in izkušnje ter orodja, da postanete strokovnjak za uporabo globokega učenja za reševanje računalniškega vida.

Kaj je notri?

• Prva načela vida in kako lahko računalnike naučimo "videti"
• Različne naloge in aplikacije računalniškega vida
• Strokovna orodja, ki vam bodo olajšala delo
• Iskanje, ustvarjanje in uporaba naborov podatkov za računalniški vid
• Teorija in uporaba konvolucijskih nevronskih mrež
• Obravnava premikov domene, sopojavljanja in drugih pristranskosti v nizih podatkov
• Prenos učenja in uporaba časa za usposabljanje in računalniških virov drugih v vašo korist
• Izdelava in usposabljanje najsodobnejšega klasifikatorja raka dojke
• Kako uporabiti zdrav odmerek skepticizma za glavne ideje in razumeti posledice splošno sprejetih tehnik
• Vizualizacija »konceptnega prostora« ConvNet z uporabo t-SNE in PCA
• Študije primerov o tem, kako podjetja uporabljajo tehnike računalniškega vida za doseganje boljših rezultatov
• Pravilno vrednotenje modela, vizualizacija latentnega prostora in prepoznavanje pozornosti modela
• Izvajanje domenskih raziskav, obdelava lastnih naborov podatkov in vzpostavljanje testov modelov
• Vrhunske arhitekture, razvoj idej, kaj jih dela edinstvene in kako jih uresničiti
• KerasCV – knjižnica WIP za ustvarjanje najsodobnejših cevovodov in modelov
• Kako razčleniti in brati prispevke ter jih implementirati sami
• Izbira modelov glede na vašo aplikacijo
• Ustvarjanje cevovoda strojnega učenja od konca do konca
• Pokrajina in intuicija pri zaznavanju predmetov s hitrejšimi R-CNN, RetinaNets, SSD in YOLO
• Instančna in pomenska segmentacija
• Prepoznavanje predmetov v realnem času z YOLOv5
• Usposabljanje detektorjev predmetov YOLOv5
• Delo s transformatorji z uporabo KerasNLP (industrijska knjižnica WIP)
• Integracija Transformers s ConvNets za ustvarjanje napisov slik
• Deepdream
• Optimizacija modela globokega učenja za računalniški vid