YOLOv7 ile Python'da Videodan Gerçek Zamanlı Poz Tahmini

Giriş

Nesne algılama, bilgisayarla görü alanında geniş bir alandır ve bilgisayarlı görünün “vahşi doğada” en önemli uygulamalarından biridir. Ondan, anahtar nokta tespiti (çoğu zaman poz tahmini için kullanılır) çıkarıldı.

Anahtar noktalar çeşitli noktalar olabilir – bir yüzün parçaları, bir vücudun uzuvları vb. Poz tahmini, noktaların bir insan vücudunun parçaları olduğu özel bir anahtar nokta algılama durumudur.

Poz tahmini, bilgisayarla görmenin inanılmaz, son derece eğlenceli ve pratik bir kullanımıdır. Bununla birlikte, maliyetli ve hantal olan pozları tahmin etmek için kullanılan donanımı (hareket yakalama kıyafetleri) ortadan kaldırabiliriz. Ek olarak, insanların hareketini Öklid uzayındaki robotların hareketiyle eşleştirerek, genellikle daha yüksek hassasiyet seviyelerine izin vermeyen kontrolörler kullanmadan ince hassas motor hareketini mümkün kılabiliriz. Anahtar nokta tahmini, hareketlerimizi AR ve VR'de 3D modellere dönüştürmek için kullanılabilir ve bunu yalnızca bir web kamerası ile yapmak için giderek daha fazla kullanılmaktadır. Son olarak – poz tahmini, spor ve güvenlikte bize yardımcı olabilir.

Bu kılavuzda, son teknoloji YOLOv7 modelini kullanarak Python'daki bir videodan gerçek zamanlı poz tahmini gerçekleştireceğiz.

Özellikle, Güney Kore'nin PyeongChang kentinde düzenlenen 2018 kış olimpiyatlarından bir video ile çalışacağız:

Aljona Savchenko ve Bruno Massot, kameraya karşı üst üste binen bedenler, hızlı akışkan hareketi ve havada dönme gibi harika bir performans sergilediler. Modelin anlaşılması zor durumlarla nasıl başa çıktığını görmek için harika bir fırsat olacak!

YOLO ve Poz Tahmini

YOLO (Sadece Bir Kez Bakarsınız) nesne algılama için oluşturulmuş bir model ailesi olduğu kadar bir metodolojidir. 2015'teki başlangıcından bu yana, YOLOv1, YOLOv2 (YOLOv9000 (YOLO3) ve YOLOvXNUMX aynı yazar(lar) tarafından önerildi - ve derin öğrenme topluluğu, devam eden yıllarda açık kaynaklı gelişmelerle devam etti.

Ultralytics'in YOLOv5'i YOLO yönteminin üzerine inşa edilmiş, endüstri sınıfı bir nesne algılama deposudur. Önceki YOLO modelleri için C++'ın aksine PyTorch'ta uygulanmaktadır, tamamen açık kaynaklıdır ve projeyi esnek bir şekilde çıkarmanıza, eğitmenize ve özelleştirmenize izin veren güzel, basit ve güçlü bir API'ye sahiptir. YOLO yöntemini geliştirmeye yönelik çoğu yeni girişimin bunun üzerine inşa edildiği bir temeldir.

Bu nasıl YOLOR (Yalnızca Bir Temsil Öğrenirsiniz) ve YOLOR'un (aynı yazar) üzerine inşa edilen YOLOv7 de oluşturuldu!

YOLOv7 yalnızca bir nesne algılama mimarisi değildir - önceki YOLO modellerinde standart olmayan yalnızca sınırlayıcı kutu regresyonunun yanı sıra anahtar noktaları (iskeletleri) çıkarabilen ve örnek segmentasyonu gerçekleştirebilen yeni model kafaları sağlar. Bu şaşırtıcı değildir, çünkü birçok nesne algılama mimarisi, paylaşılan genel mimari nedeniyle, göreve bağlı olarak farklı çıktılarla, örneğin segmentasyon ve anahtar nokta algılama görevleri için daha önce yeniden amaçlandı.

Şaşırtıcı olmasa da, birkaç yıl önce hem doğruluk hem de hız açısından pratikte tüm diğer iki aşamalı dedektörlerden daha iyi performans göstermeye başlayan YOLO tabanlı modeller için örnek segmentasyonu ve anahtar nokta algılamayı desteklemek muhtemelen yeni standart haline gelecektir.

Bu, iki aşamalı dedektörlerden daha basit bir mimariyle, örnek segmentasyonu ve anahtar nokta algılamanın her zamankinden daha hızlı gerçekleştirilmesini sağlar.

Modelin kendisi, mimari değişikliklerin yanı sıra, çıkarım maliyetini artırmadan doğruluğu artıran “ücretsiz çanta” olarak adlandırılan eğitim yönlerini optimize ederek oluşturuldu.

YOLOv7'yi yükleme

Kaynak kodu elde etmek için depoyu klonlayarak başlayalım:

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

Şimdi konuya geçelim yolov7 projeyi içeren dizin ve içeriğe bir göz atın:

%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

Şimdi, YOLO'nun bir nesne dedektörü olması amaçlanmıştır ve varsayılan olarak poz tahmini ağırlıkları ile birlikte gönderilmez. Ağırlıkları indirmek ve onlardan somut bir model örneği yüklemek isteyeceğiz. Ağırlıklar aynı GitHub deposunda bulunur ve CLI aracılığıyla da kolayca indirilebilir:

! 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

İndirdikten sonra kullanacağımız kitaplıkları ve yardımcı yöntemleri içe aktarabiliriz:

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

Harika! Modeli yüklemeye ve YOLOv7 ve OpenCV ile videolardan pozlar çıkarmanıza izin veren bir komut dosyası oluşturmaya başlayalım.

YOLOv7 ile Gerçek Zamanlı Poz Tahmini

Öncelikle indirilen ağırlıklardan modeli yüklemek için bir method oluşturalım. Hangi cihaza sahip olduğumuzu kontrol edeceğiz (CPU veya 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()

GPU'muz olup olmamasına bağlı olarak, yarı kesinliği açacağız (kullanarak float16 yerine float32 operasyonlarda), bu da çıkarımı önemli ölçüde daha hızlı hale getirir. Gerçek zamanlı hızlar için bunu bir GPU'da gerçekleştirmenin son derece teşvik edildiğini unutmayın, çünkü CPU'lar küçük videolarda çalışmadıkça bunu yapacak güce sahip olmayacaktır.

Çıkarımı çalıştırmak için bir ikna yöntemi yazalım. Görüntüleri NumPy dizileri olarak kabul edeceğiz (çünkü onları daha sonra videoyu okurken ileteceğiz). İlk olarak, kullanarak letterbox() işlevi - videoyu yeniden boyutlandıracağız ve modelin çalışabileceği bir şekle göre dolduracağız. Bunun, ortaya çıkan videonun şekli (çözünürlüğü) olması gerekmez ve olmayacak!

Ardından, dönüşümleri uygulayacağız, görüntüyü yarı kesinliğe dönüştüreceğiz (bir GPU varsa), toplu hale getireceğiz ve model üzerinden çalıştıracağız:

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

Modelin tahminlerini ve görüntüyü bir tensör olarak döndüreceğiz. Bunlar "kaba" tahminlerdir - örtüşen birçok etkinleştirme içerirler ve Maksimum Olmayan Bastırma kullanarak bunları "temizlemek" ve tahmin edilen iskeletleri görüntünün üzerine yerleştirmek isteyeceğiz:

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

Bunlar yerinde olduğunda, genel akışımız şöyle görünecektir:

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

Bunu gerçek zamanlı bir video ayarına çevirmek için – bir videoyu okumak için OpenCV kullanacağız ve bu işlemi her kare için çalıştıracağız. Her karede, kareyi video olarak kodlanmış yeni bir dosyaya da yazacağız. Bu, biz çıkarımı çalıştırırken, görüntülerken ve yazarken süreci mutlaka yavaşlatacaktır – böylece yeni bir dosya oluşturmaktan kaçınarak ve döngüde ona yazarak çıkarımı ve görüntülemeyi hızlandırabilirsiniz:

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

The VideoWriter çıktı dosya adı, FourCC (videoyu kodlamak için kullanılan codec bileşenini gösteren dört codec kodu), kare hızı ve bir demet olarak çözünürlük gibi birkaç parametreyi kabul eder. Videoyu tahmin etmemek veya yeniden boyutlandırmamak için - orijinal videonun genişliğini ve yüksekliğini kullandık. VideoCapture genişlik, yükseklik, toplam kare sayısı vb. gibi videonun kendisiyle ilgili verileri içeren örnek.

Şimdi, herhangi bir giriş videosunda yöntemi çağırabiliriz:

pose_estimation_video('../ice_skating.mp4')

Bu, çıkarımı gerçek zamanlı olarak görüntüleyen bir OpenCV penceresi açacaktır. Ayrıca, bir video dosyası yazacaktır. yolov7 dizin (bizden beri cd'd içine):

Sonuç

Bu kılavuzda, YOLO yöntemine, YOLOv7'ye ve YOLO ile nesne algılama, poz tahmini ve örnek segmentasyonu arasındaki ilişkiye bir göz attık. Ardından, programatik API'yi kullanarak YOLOv7'yi nasıl kolayca kurabileceğinizi ve onunla nasıl çalışabileceğinizi inceledik ve çıkarımı ve sonuçları daha kolay görüntülemeyi sağlamak için birkaç ikna yöntemi oluşturduk.

Son olarak, OpenCV kullanarak bir video açtık, YOLOv7 ile çıkarım yaptık ve gerçek zamanlı olarak poz tahmini yapmak için bir işlev yaptık, sonuçta ortaya çıkan videoyu tam çözünürlükte ve 30FPS'de yerel diskinize kaydettik.

Daha İleri Gitmek – Bilgisayarla Görme için Pratik Derin Öğrenme

Meraklı doğanız daha ileri gitmek istemenizi sağlıyor mu? bizim kontrol etmenizi öneririz Kurs: “Python ile Bilgisayarla Görme için Pratik Derin Öğrenme”.

Başka Bir Bilgisayarla Görme Kursu mu?

MNIST rakamları veya MNIST modası sınıflandırması yapmayacağız. Uzun zaman önce rollerine hizmet ettiler. Çok fazla öğrenme kaynağı, gelişmiş kara kutu mimarilerinin performans yükünü omuzlamasına izin vermeden önce temel veri kümelerine ve temel mimarilere odaklanıyor.

odaklanmak istiyoruz gizemden arındırma, pratiklik, anlayış, sezgi ve gerçek projeler. Öğrenmek istemek Nasıl bir fark yaratabilirsin? Beynimizin görüntüleri işleme biçiminden meme kanseri için araştırma düzeyinde bir derin öğrenme sınıflandırıcısı yazmaya, “halüsinasyon” gören derin öğrenme ağlarına, size ilkeleri ve teoriyi pratik çalışmalarla öğreterek, sizi aşağıdaki bilgilerle donatmaya kadar bir yolculuğa çıkaracağız. bilgisayar vizyonunu çözmek için derin öğrenmeyi uygulamada uzman olmak için teknik bilgi ve araçlar.

İçinde ne var?

• Görmenin ilk ilkeleri ve bilgisayarlara “görmeyi” nasıl öğretebiliriz?
• Bilgisayarla görmenin farklı görevleri ve uygulamaları
• İşinizi kolaylaştıracak ticaret araçları
• Bilgisayarla görü için veri kümelerini bulma, oluşturma ve kullanma
• Evrişimli Sinir Ağlarının teorisi ve uygulaması
• Veri kümelerinde etki alanı kayması, birlikte oluşma ve diğer önyargıları işleme
• Öğrenimi aktarın ve başkalarının eğitim süresini ve hesaplama kaynaklarını kendi yararınıza kullanın
• Son teknoloji bir meme kanseri sınıflandırıcısı oluşturmak ve eğitmek
• Ana akım fikirlere sağlıklı bir şüphecilik dozu nasıl uygulanır ve yaygın olarak benimsenen tekniklerin sonuçları nasıl anlaşılır?
• t-SNE ve PCA kullanarak ConvNet'in “kavram uzayını” görselleştirme
• Şirketlerin daha iyi sonuçlar elde etmek için bilgisayarlı görme tekniklerini nasıl kullandıklarına dair vaka çalışmaları
• Uygun model değerlendirmesi, gizli uzay görselleştirmesi ve modelin dikkatinin belirlenmesi
• Alan araştırması yapmak, kendi veri kümelerinizi işlemek ve model testleri oluşturmak
• Son teknoloji mimariler, fikirlerin ilerlemesi, onları benzersiz kılan nedir ve nasıl uygulanacağı
• KerasCV – son teknoloji işlem hatları ve modeller oluşturmak için bir WIP kitaplığı
• Makaleleri nasıl ayrıştırıp okuyabilir ve bunları kendiniz uygulayabilirsiniz
• Uygulamanıza bağlı olarak model seçimi
• Uçtan uca bir makine öğrenimi ardışık düzeni oluşturma
• Daha Hızlı R-CNN'ler, RetinaNet'ler, SSD'ler ve YOLO ile nesne algılamada manzara ve sezgi
• Örnek ve anlamsal segmentasyon
• YOLOv5 ile Gerçek Zamanlı Nesne Tanıma
• YOLOv5 Nesne Dedektörlerinin Eğitimi
• KerasNLP (endüstri gücünde WIP kitaplığı) kullanarak Transformers ile çalışma
• Görüntülerin altyazılarını oluşturmak için Transformers'ı ConvNets ile entegre etme
• DeepDream
• Bilgisayarla görme için Derin Öğrenme modeli optimizasyonu