Valós idejű pózbecslés videóból Pythonban a YOLOv7 segítségével

Bevezetés

Az objektumészlelés a számítógépes látás nagy területe, és a számítógépes látás egyik legfontosabb alkalmazása „vadon”. Ebből kinyerték a kulcspont-detektálást (amelyet gyakran pózbecslésre használnak).

A kulcspontok különböző pontok lehetnek – arcrészek, testvégtagok stb. A pozícióbecslés a kulcspont-észlelés egy speciális esete – ahol a pontok az emberi test részei.

A pózbecslés a számítógépes látás elképesztő, rendkívül szórakoztató és praktikus alkalmazása. Ezzel megszüntethetjük a pózbecsléshez használt hardvert (mozgásrögzítő ruhákat), amelyek költséges és nehézkesek. Ezenkívül az emberek mozgását leképezhetjük a robotok mozgásával az euklideszi térben, lehetővé téve a finom precíziós motormozgásokat vezérlők használata nélkül, amelyek általában nem tesznek lehetővé nagyobb pontosságot. A kulcspontbecslés segítségével mozgásainkat 3D-s modellekké alakíthatjuk AR-ben és VR-ben, és egyre gyakrabban használják ezt csupán egy webkamerával. Végül – a pózbecslés segítségünkre lehet a sportban és a biztonságban.

Ebben az útmutatóban valós idejű pózbecslést hajtunk végre egy Python nyelvű videóból, a legmodernebb YOLOv7 modell segítségével.

Konkrétan egy videóval fogunk dolgozni a 2018-as téli olimpiáról, amelyet a dél-koreai PyeongChangban rendeztek meg:

Aljona Savchenko és Bruno Massot elképesztő teljesítményt nyújtott, beleértve a testek átfedését a kamerával, a gyors folyadékmozgást és a levegőben való forgást. Lenyűgöző lehetőség lesz látni, hogy a modell hogyan kezeli a nehezen következtethető helyzeteket!

YOLO és pózbecslés

YOLO (Csak egyszer nézel) egy módszertan, valamint egy objektumészlelésre épített modellcsalád. A 2015-ös indulás óta a YOLOv1, YOLOv2 (YOLO9000) és YOLOv3 változatot ugyanaz a szerző(k) javasolták – és a mélytanulási közösség nyílt forráskódú fejlesztésekkel folytatódott a következő években.

Az Ultralytics YOLOv5 egy iparági szintű objektumészlelési adattár, amely a YOLO módszerre épül. PyTorch-ban van megvalósítva, szemben a korábbi YOLO modellek C++-jával, teljesen nyílt forráskódú, és gyönyörűen egyszerű és hatékony API-ja van, amely lehetővé teszi a projektek rugalmas következtetését, betanítását és testreszabását. Annyira alapvető, hogy a YOLO-módszer javítására tett legtöbb új próbálkozás erre épül.

Így YOLOR (Csak egy ábrázolást tanulsz) és a YOLOR-ra (ugyanaz a szerző) épülő YOLOv7 is létrejött!

A YOLOv7 nem csupán egy objektumészlelési architektúra – új modellfejeket biztosít, amelyek kulcspontokat (csontvázakat) tudnak kiadni, és példányszegmentálást hajtanak végre a csak határolódoboz-regresszió mellett, ami a korábbi YOLO modelleknél nem volt szabványos. Ez nem meglepő, hiszen sok objektumészlelési architektúrát korábban is újrahasznosítottak például szegmentálási és kulcspont-észlelési feladatokra, a közös általános architektúra miatt, feladattól függően eltérő kimenetekkel.

Bár ez nem meglepő – a példányszegmentálás és a kulcspont-felismerés támogatása valószínűleg a YOLO-alapú modellek új szabványa lesz, amelyek néhány éve gyakorlatilag az összes többi kétlépcsős detektor teljesítményét felülmúlják mind pontosságban, mind sebességben.

Ez minden eddiginél gyorsabbá teszi a példányszegmentálást és a kulcspont-észlelést, egyszerűbb architektúrával, mint a kétlépcsős detektorok.

Magát a modellt építészeti változtatások, valamint a képzés szempontjainak optimalizálása révén hozták létre, amelyet „zsákos ajándéknak” neveztek, ami növelte a pontosságot a következtetési költségek növelése nélkül.

A YOLOv7 telepítése

Kezdjük a tár klónozásával, hogy megkapjuk a forráskódot:

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

Most pedig térjünk át a yolov7 könyvtárba, amely tartalmazza a projektet, és nézze meg a tartalmát:

%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

A YOLO-t tárgydetektornak szánták, és alapértelmezés szerint nem szállítják a pózbecslési súlyokkal. Le akarjuk tölteni a súlyokat, és be kell tölteni belőlük egy konkrét modellpéldányt. A súlyok ugyanabban a GitHub-tárolóban érhetők el, és könnyen letölthetők a CLI-n keresztül is:

! 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

A letöltést követően importálhatjuk az általunk használt könyvtárakat és segédmetódusokat:

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

Nagy! Folytassuk a modell betöltésével és egy olyan szkript létrehozásával, amely lehetővé teszi, hogy a YOLOv7 és az OpenCV segítségével videókból következtessünk pózokra.

Valós idejű pózbecslés a YOLOv7 segítségével

Először hozzunk létre egy módszert a modell betöltésére a letöltött súlyokból. Ellenőrizzük, milyen eszköz áll rendelkezésünkre (CPU vagy 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()

Attól függően, hogy van-e GPU-nk vagy nincs, bekapcsoljuk a félpontosságot (a float16 helyett float32 műveletekben), ami lényegesen gyorsabbá teszi a következtetést. Vegye figyelembe, hogy ezt erősen ajánlott GPU-n végrehajtani a valós idejű sebesség érdekében, mivel a CPU-k valószínűleg nem képesek erre, hacsak nem futnak kis videókon.

Írjunk egy kényelmi módszert a következtetés futtatásához. A képeket NumPy tömbként fogadjuk el (mivel később, a videó olvasása közben ezt adjuk át). Először is a letterbox() funkció – átméretezzük és a videót olyan alakra párnázzuk, amellyel a modell képes működni. Ennek nem kell lennie, és nem is lesz az eredményül kapott videó alakja (felbontása)!

Ezután alkalmazzuk a transzformációkat, átalakítjuk a képet fél pontosságúra (ha van GPU), kötegbe rakjuk és végigfuttatjuk a 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

Visszaadjuk a modell előrejelzéseit, valamint a képet tenzorként. Ezek „durva” előrejelzések – sok aktiválást tartalmaznak, amelyek átfedik egymást, és szeretnénk „megtisztítani” őket a Non-Max Supression segítségével, és a megjósolt csontvázakat magán a képen ábrázolni:

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

Ha ezek a helyükön vannak, általános folyamatunk így fog kinézni:

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

Ennek valós idejű videóbeállításra való lefordításához az OpenCV-t használjuk a videó olvasásához, és ezt a folyamatot minden képkockánál futtatjuk. Minden képkockán a képkockát egy új fájlba is írjuk, videóként kódolva. Ez szükségszerűen lelassítja a folyamatot, miközben a következtetést futtatjuk, megjelenítjük és írjuk – így felgyorsíthatja a következtetést és a megjelenítést, ha elkerüli az új fájl létrehozását és a ciklusban való írását:

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

A VideoWriter Számos paramétert fogad el – a kimeneti fájlnevet, a FourCC-t (négy kodekkód, amelyek a videó kódolásához használt kodeket jelölik), a képkocka sebességet és a felbontást sorként. A videó kitalálása vagy átméretezése elkerülése érdekében az eredeti videó szélességét és magasságát használtuk, amelyet a VideoCapture példány, amely magáról a videóról tartalmaz adatokat, mint például a szélesség, magasság, a képkockák teljes száma stb.

Most bármelyik bemeneti videón meghívhatjuk a metódust:

pose_estimation_video('../ice_skating.mp4')

Ezzel megnyílik egy OpenCV ablak, amely valós időben jeleníti meg a következtetést. Ezenkívül videofájlt fog írni a yolov7 könyvtár (mióta mi cd'd bele):

Következtetés

Ebben az útmutatóban áttekintettük a YOLO módszert, a YOLOv7-et, valamint a YOLO és az objektumészlelés, a pózbecslés és a példányszegmentálás közötti kapcsolatot. Ezt követően megvizsgáltuk, hogyan telepítheti egyszerűen és hogyan dolgozhat vele a YOLOv7 programozási API használatával, és több kényelmi módszert is létrehoztunk, amelyek megkönnyítik a következtetést és az eredmények megjelenítését.

Végül megnyitottunk egy videót az OpenCV segítségével, lefuttattuk a következtetést a YOLOv7-tel, és létrehoztunk egy funkciót a valós idejű pózbecslés végrehajtására, így az eredményül kapott videót teljes felbontásban és 30 FPS-ben mentettük a helyi lemezre.

Továbblépve – Gyakorlati mélytanulás a számítógépes látáshoz

Érdeklődő természete arra készteti, hogy tovább menjen? Javasoljuk, hogy tekintse meg nálunk Tanfolyam: „Practical Deep Learning for Computer Vision with Python”.

Újabb számítógépes látás tanfolyam?

Nem végezzük az MNIST számjegyek osztályozását vagy az MNIST divatot. Régen kiszolgálták a részüket. Túl sok tanulási erőforrás összpontosít az alapvető adatkészletekre és alapvető architektúrákra, mielőtt a fejlett feketedoboz-architektúrákra hagyná a teljesítmény terhét.

Mi arra szeretnénk koncentrálni demisztifikáció, gyakorlatiasság, megértés, intuíció és a valódi projektek. Tanulni akar hogyan tudsz változtatni? Elvezetjük Önt az agyunk képfeldolgozási módjától a mellrák kutatási szintű mélytanulási osztályozójának megírásáig a mély tanulási hálózatokig, amelyek „hallucinálnak”, gyakorlati munkán keresztül megtanítjuk az alapelveket és az elméletet, felkészítve a know-how és eszközök ahhoz, hogy szakértővé váljon a mélytanulás alkalmazásában a számítógépes látás megoldásában.

Mi van benne?

• A látás első alapelvei és hogyan lehet a számítógépeket „látni” tanítani
• A számítógépes látás különböző feladatai és alkalmazásai
• A szakma eszközei, amelyek megkönnyítik a munkáját
• Adatkészletek keresése, létrehozása és felhasználása számítógépes látáshoz
• A konvolúciós neurális hálózatok elmélete és alkalmazása
• Tartományeltolódás, együttes előfordulás és egyéb torzítások kezelése az adatkészletekben
• Transzfer Tanulás és mások képzési idejének és számítási erőforrásainak felhasználása az Ön javára
• Korszerű emlőrák osztályozó felépítése és betanítása
• Hogyan alkalmazzunk egy egészséges adag szkepticizmust a mainstream ötletekhez, és hogyan értsük meg a széles körben elfogadott technikák következményeit
• A ConvNet „koncepcióterének” megjelenítése t-SNE és PCA segítségével
• Esettanulmányok arról, hogy a vállalatok hogyan használják a számítógépes látástechnikákat a jobb eredmények elérése érdekében
• Megfelelő modellértékelés, látens tér vizualizáció és a modell figyelmének azonosítása
• Domainkutatás végzése, saját adatkészletek feldolgozása és modelltesztek létrehozása
• Élvonalbeli architektúrák, az ötletek fejlődése, mi teszi őket egyedivé és hogyan valósítsuk meg őket
• KerasCV – WIP-könyvtár a legkorszerűbb csővezetékek és modellek létrehozásához
• Hogyan elemezze és olvassa el a dolgozatokat, és saját maga hajtsa végre azokat
• Modellek kiválasztása az alkalmazástól függően
• Végpontok közötti gépi tanulási folyamat létrehozása
• Tájkép és intuíció a tárgyfelismeréshez a gyorsabb R-CNN-ekkel, RetinaNetekkel, SSD-kkel és YOLO-val
• Példány és szemantikai szegmentáció
• Valós idejű objektumfelismerés a YOLOv5 segítségével
• YOLOv5 objektumdetektorok képzése
• Transzformátorokkal való munkavégzés KerasNLP-vel (ipari erősségű WIP-könyvtár)
• Transformers integrálása ConvNetekkel a képek feliratainak létrehozásához
• Deepdream
• Deep Learning modell optimalizálása számítógépes látáshoz