Pózbecslés/kulcspont-észlelés a YOLOv7 segítségével Pythonban

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”.

Az objektumészlelés nem annyira szabványos, mint a képbesorolás, főleg azért, mert a legtöbb új fejlesztést jellemzően egyéni kutatók, karbantartók és fejlesztők végzik, nem pedig nagy könyvtárak és keretrendszerek. Nehéz a szükséges segédprogram-szkripteket olyan keretrendszerbe csomagolni, mint a TensorFlow vagy a PyTorch, és fenntartani az API-irányelveket, amelyek a fejlesztést eddig irányították.

Ez némileg bonyolultabbá, jellemzően bőbeszédesebbé (de nem mindig) teszi az objektumok észlelését, és kevésbé megközelíthetővé, mint a képosztályozás.

A tömegek szerencséjére – az Ultralytics egy egyszerű, nagyon erős és gyönyörű objektumészlelési API-t fejlesztett ki a YOLOv5 köré, amelyet más kutató-fejlesztő csapatok kiterjesztettek újabb verziókra, például a YOLOv7-re.

Ebben a rövid útmutatóban a Pózbecslést (Kulcspont-észlelés) hajtjuk végre Pythonban, a legmodernebb YOLOv7-tel.

A kulcspontok különböző pontok lehetnek – arcrészek, testvégtagok, stb. A pozícióbecslés a kulcspont-észlelés speciális esete – ahol a pontok emberi test részei, és a drága pozíciókövető hardver helyettesítésére használhatók, lehetővé teszi az éteren keresztüli robotika vezérlését, és az emberi önkifejezés új korszakát indítja el az AR és a VR révén.

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 a YOLO első nagyszabású megvalósítása a PyTorch-ban, ami minden eddiginél hozzáférhetőbbé tette, de a fő oka annak, hogy a YOLOv5 ekkora lábra tett szert, a köré épült, gyönyörűen egyszerű és hatékony API is. A projekt elvonatkoztatja a szükségtelen részleteket, miközben lehetővé teszi a testreszabhatóságot, gyakorlatilag az összes használható exportformátumot, és elképesztő gyakorlatokat alkalmaz, amelyek az egész projektet hatékonyvá és a lehető legoptimálisabbá teszik.

A YOLOv5 továbbra is az a legfontosabb projekt, amellyel objektumészlelési modelleket készítenek, és sok olyan adattár, amelyek célja a YOLO módszer továbbfejlesztése, a YOLOv5-tel indul, és hasonló API-t kínálnak (vagy egyszerűen elágazzák a projektet, és építenek rá). Ilyen a helyzet YOLOR (Csak egy ábrázolást tanulsz) és a YOLOv7, amely a YOLOR-ra (ugyanaz a szerző) épült, amely a YOLO módszertan legújabb fejlesztése.

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ő, mivel 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ányává válik, amelyek néhány éve gyakorlatilag az összes többi kétlépcsős detektor teljesítményét felülmúlják.

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

Menjünk előre, és telepítsük a projektet a GitHubról:

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

Ez létrehozza a yolov7 az aktuális munkakönyvtár alatt található könyvtárba, amelyben megtalálhatja az alapvető projektfájlokat:

%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

Jegyzet: A Google Colab Jegyzetfüzetek visszaállnak a fő munkakönyvtárba a következő cellában, még hívás után is %cd dirname, ezért továbbra is meg kell hívnia minden cellában, amelyben egy műveletet szeretne végrehajtani. A helyi Jupyter Notebookok emlékeznek a változásra, így nem kell folyamatosan hívnia a parancsot.

Amikor egy adott súlykészlettel kódot futtat, a rendszer letölti és ebben a könyvtárban tárolja. A pózbecslés végrehajtásához le kell töltenünk az adott feladathoz előre betanított YOLOv7 modell súlyait, amelyek a /releases/download/ lapon a GitHubon:

! 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

Remek, letöltöttük a yolov7-w6-pose.pt súlyok fájl, amely használható egy betanított modell betöltésére és rekonstruálására a pózbecsléshez.

A YOLOv7 pózbecslési modell betöltése

Importáljuk azokat a könyvtárakat, amelyekre szükségünk lesz a pozícióbecsléshez:

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 és a torchvision elég egyszerűek – a YOLOv7 a PyTorch segítségével van megvalósítva. Az utils.datasets, utils.general és a utils.plots A modulok a YOLOv7 projektből származnak, és olyan módszereket biztosítanak számunkra, amelyek segítik az előfeldolgozást és a bemenet előkészítését a modellhez, amelyen a következtetéseket le tudjuk futtatni. Ezek között vannak letterbox() kitömni a képet, non_max_supression_keypoint() futtatni a Non-Max Supression algoritmust a modell kezdeti kimenetén, és tiszta kimenetet készíteni az értelmezésünkhöz, valamint a output_to_keypoint() és a plot_skeleton_kpts() módszerek kulcspontok tényleges hozzáadására egy adott képhez, miután megjósolták azokat.

A modellt a súlyfájlból tölthetjük be torch.load(). Hozzunk létre egy függvényt annak ellenőrzésére, hogy rendelkezésre áll-e GPU, töltsük be a modellt, állítsuk következtetési módba, és vigyük át a GPU-ra, ha elérhető:

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

A modell betöltése után hozzunk létre a run_inference() metódus, amely elfogadja a rendszerünkben lévő fájlra mutató karakterláncot. A módszer OpenCV segítségével olvassa be a képet (cv2), tömítse ki letterbox(), alkalmazzon rá transzformációkat, és alakítsa köteggé (a modell betanítva van, és a szokásos módon kötegeket vár):

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

Itt visszaadtuk az átalakított képet (mert ki akarjuk bontani az eredetit és ábrázolni rajta) és a modell kimeneteit. Ezek a kimenetek 45900 kulcspont előrejelzést tartalmaznak, amelyek többsége átfedi egymást. A nem-maximális elnyomást szeretnénk alkalmazni ezekre a nyers előrejelzésekre, csakúgy, mint az objektumészlelési előrejelzéseknél (ahol a rendszer sok határolókeretet jósol, majd bizonyos bizalom és IoU küszöb miatt „összecsukják”). Az elnyomás után minden kulcspontot ábrázolhatunk az eredeti képen, és megjeleníthetjük:

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

Most néhány bemeneti képhez, mint pl karate.jpg a fő munkakönyvtárban lefuttathatjuk a következtetést, végrehajthatunk nem-maximális elnyomást, és az eredményeket a következőkkel ábrázolhatjuk:

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

Ennek eredményeként:

Erre a képre elég nehéz következtetni! A jobb oldali gyakorló jobb karjának nagy része rejtve van, és láthatjuk, hogy a modell arra következtetett, hogy rejtve van, és a testtől jobbra van, de hiányzik, hogy a könyök be van hajlítva, és hogy a kar egy része előtt van. . A bal oldali gyakorló, amely sokkal tisztábban látható, helyesen következtet, még rejtett lábbal is.

Ami azt illeti – egy hátul ülő személy, szinte teljesen láthatatlan a kamera számára látszólag helyesen becsülték meg a pózukat, pusztán a csípő ülő helyzete alapján. Nagyszerű munka a hálózat nevében!

Következtetés

Ebben az útmutatóban – röviden áttekintettük a YOLO-család legújabb fejlesztését, a YOLOv7-et, amely a YOLOR-ra épül, és a legtöbb YOLO-alapú modell standard objektumészlelési képességein túlmenően példányszegmentálási és kulcspont-észlelési képességeket is biztosít. .

Ezután megvizsgáltuk, hogyan tölthetjük le a kiadott súlyfájlokat, tölthetjük be őket, hogy modellt készítsünk, és hogyan végezzünk pózbecslési következtetést az emberek számára, lenyűgöző eredményeket hozva.

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