Estimasi Pose Real-Time dari Video dengan Python dengan YOLOv7

Pengantar

Deteksi objek adalah bidang besar dalam visi komputer, dan salah satu aplikasi visi komputer yang lebih penting "di alam liar". Dari situ, deteksi keypoint (sering digunakan untuk estimasi pose) diekstraksi.

Titik kunci dapat berupa berbagai titik – bagian wajah, anggota tubuh, dll. Estimasi pose adalah kasus khusus pendeteksian titik kunci – di mana titik-titik tersebut merupakan bagian dari tubuh manusia.

Estimasi pose adalah penggunaan computer vision yang luar biasa, sangat menyenangkan dan praktis. Dengan itu, kita dapat menyingkirkan perangkat keras yang digunakan untuk memperkirakan pose (setelan motion capture), yang mahal dan berat. Selain itu, kami dapat memetakan pergerakan manusia ke pergerakan robot di ruang Euclidean, memungkinkan pergerakan motor presisi halus tanpa menggunakan pengontrol, yang biasanya tidak memungkinkan tingkat presisi yang lebih tinggi. Estimasi keypoint dapat digunakan untuk menerjemahkan gerakan kita ke model 3D dalam AR dan VR, dan semakin sering digunakan untuk melakukannya hanya dengan webcam. Terakhir – estimasi pose dapat membantu kita dalam olahraga dan keamanan.

Dalam panduan ini, kita akan melakukan estimasi pose real-time dari video dengan Python, menggunakan model YOLOv7 yang canggih.

Secara khusus, kami akan bekerja dengan video dari olimpiade musim dingin 2018, yang diadakan di PyeongChang Korea Selatan:

Aljona Savchenko dan Bruno Massot melakukan pertunjukan yang luar biasa, termasuk tubuh yang tumpang tindih dengan kamera, gerakan cepat yang mengalir dan berputar di udara. Ini akan menjadi kesempatan luar biasa untuk melihat bagaimana model menangani situasi yang sulit disimpulkan!

Estimasi YOLO dan Pose

YOLO (Kamu Hanya Melihat Sekali) adalah metodologi, serta keluarga model yang dibangun untuk deteksi objek. Sejak dimulai pada tahun 2015, YOLOv1, YOLOv2 (YOLO9000) dan YOLOv3 telah diusulkan oleh penulis yang sama – dan komunitas pembelajaran mendalam melanjutkan dengan kemajuan open-source di tahun-tahun berikutnya.

YOLOv5 dari Ultralitik adalah repositori deteksi objek kelas industri, dibangun di atas metode YOLO. Ini diimplementasikan di PyTorch, berbeda dengan C++ untuk model YOLO sebelumnya, sepenuhnya open source, dan memiliki API yang sangat sederhana dan kuat yang memungkinkan Anda menyimpulkan, melatih, dan menyesuaikan proyek secara fleksibel. Ini adalah bahan pokok sehingga sebagian besar upaya baru untuk meningkatkan metode YOLO dibangun di atasnya.

Ini adalah bagaimana YOLOR (Anda Hanya Belajar Satu Representasi) dan YOLOv7 yang dibangun di atas YOLOR (penulis yang sama) juga dibuat!

YOLOv7 bukan hanya arsitektur deteksi objek – ia menyediakan model head baru, yang dapat menampilkan keypoint (kerangka) dan melakukan segmentasi instan selain hanya regresi kotak pembatas, yang tidak standar dengan model YOLO sebelumnya. Ini tidak mengherankan, karena banyak arsitektur deteksi objek yang digunakan kembali untuk tugas segmentasi dan deteksi keypoint sebelumnya juga, karena arsitektur umum bersama, dengan output yang berbeda tergantung pada tugas.

Meskipun tidak mengejutkan – mendukung segmentasi instans dan deteksi keypoint kemungkinan akan menjadi standar baru untuk model berbasis YOLO, yang telah mulai mengungguli hampir semua detektor dua tahap lainnya beberapa tahun lalu dalam hal akurasi dan kecepatan.

Ini membuat segmentasi instans dan deteksi keypoint lebih cepat untuk dilakukan daripada sebelumnya, dengan arsitektur yang lebih sederhana daripada detektor dua tahap.

Model itu sendiri dibuat melalui perubahan arsitektur, serta mengoptimalkan aspek pelatihan, dijuluki "bag-of-freebies", yang meningkatkan akurasi tanpa meningkatkan biaya inferensi.

Menginstal YOLOv7

Mari kita mulai dengan mengkloning repositori untuk mendapatkan kode sumber:

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

Sekarang, mari kita beralih ke yolov7 direktori, yang berisi proyek, dan lihat isinya:

%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

Sekarang, YOLO dimaksudkan sebagai pendeteksi objek, dan tidak dikirimkan dengan bobot estimasi pose oleh dedfault. Kami ingin mengunduh bobot dan memuat contoh model konkret darinya. Bobot tersedia di repositori GitHub yang sama, dan juga dapat dengan mudah diunduh melalui 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

Setelah diunduh, kami dapat mengimpor pustaka dan metode pembantu yang akan kami gunakan:

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

Besar! Mari mulai memuat model dan membuat skrip yang memungkinkan Anda menyimpulkan pose dari video dengan YOLOv7 dan OpenCV.

Estimasi Pose Real-Time dengan YOLOv7

Pertama-tama mari kita buat metode untuk memuat model dari bobot yang diunduh. Kami akan memeriksa perangkat apa yang kami miliki (CPU atau 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()

Bergantung pada apakah kami memiliki GPU atau tidak, kami akan mengaktifkan setengah presisi (menggunakan float16 alih-alih float32 dalam operasi), yang membuat inferensi secara signifikan lebih cepat. Perhatikan bahwa sangat dianjurkan untuk melakukan ini pada GPU untuk kecepatan waktu nyata, karena CPU kemungkinan akan kekurangan daya untuk melakukannya kecuali jika dijalankan pada video kecil.

Mari kita tulis metode kenyamanan untuk menjalankan inferensi. Kami akan menerima gambar sebagai array NumPy (karena itulah yang akan kami sampaikan nanti saat membaca video). Pertama, menggunakan letterbox() fungsi – kita akan mengubah ukuran dan mempadatkan video ke bentuk yang dapat digunakan oleh model. Ini tidak perlu dan tidak akan menjadi bentuk (resolusi) dari video yang dihasilkan!

Kemudian, kami akan menerapkan transformasi, mengonversi gambar menjadi setengah presisi (jika GPU tersedia), mengelompokkannya dan menjalankannya melalui 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

Kami akan mengembalikan prediksi model, serta gambar sebagai tensor. Ini adalah prediksi "kasar" – mereka berisi banyak aktivasi yang tumpang tindih, dan kami ingin "membersihkannya" menggunakan Non-Max Supression, dan memplot kerangka yang diprediksi di atas gambar itu sendiri:

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

Dengan ini di tempat, aliran umum kami akan terlihat seperti:

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

Untuk menerjemahkannya ke pengaturan video waktu nyata – kami akan menggunakan OpenCV untuk membaca video, dan menjalankan proses ini untuk setiap frame. Pada setiap bingkai, kami juga akan menulis bingkai ke dalam file baru, yang dikodekan sebagai video. Ini tentu akan memperlambat proses saat kita menjalankan inferensi, menampilkannya, dan menulisnya – sehingga Anda dapat mempercepat inferensi dan tampilan dengan menghindari pembuatan file baru dan menulisnya dalam loop:

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

Grafik VideoWriter menerima beberapa parameter – nama file keluaran, FourCC (empat kode codec, yang menunjukkan codec yang digunakan untuk mengkodekan video), framerate dan resolusi sebagai tuple. Untuk tidak menebak atau mengubah ukuran video – kami telah menggunakan lebar dan tinggi video asli, diperoleh melalui VideoCapture instance yang berisi data tentang video itu sendiri, seperti lebar, tinggi, jumlah total bingkai, dll.

Sekarang, kita dapat memanggil metode pada video input apa pun:

pose_estimation_video('../ice_skating.mp4')

Ini akan membuka jendela OpenCV, menampilkan inferensi secara real-time. Dan juga, itu akan menulis file video di yolov7 direktori (karena kami telah cdakan ke dalamnya):

Kesimpulan

Dalam panduan ini, kita telah melihat metode YOLO, YOLOv7 dan hubungan antara YOLO dan deteksi objek, estimasi pose, dan segmentasi instan. Kami kemudian melihat bagaimana Anda dapat dengan mudah menginstal dan bekerja dengan YOLOv7 menggunakan API terprogram, dan membuat beberapa metode kenyamanan untuk membuat inferensi dan menampilkan hasil lebih mudah.

Terakhir, kami telah membuka video menggunakan OpenCV, menjalankan inferensi dengan YOLOv7, dan membuat fungsi untuk melakukan estimasi pose secara real-time, menyimpan video yang dihasilkan dalam resolusi penuh dan 30FPS di disk lokal Anda.

Melangkah Lebih Jauh – Pembelajaran Mendalam Praktis untuk Visi Komputer

Sifat ingin tahu Anda membuat Anda ingin melangkah lebih jauh? Kami merekomendasikan untuk memeriksa kami Kelas: “Pembelajaran Mendalam Praktis untuk Visi Komputer dengan Python”.

Kursus Computer Vision lainnya?

Kami tidak akan melakukan klasifikasi digit MNIST atau mode MNIST. Mereka melayani bagian mereka sejak lama. Terlalu banyak sumber belajar yang berfokus pada kumpulan data dasar dan arsitektur dasar sebelum membiarkan arsitektur kotak hitam tingkat lanjut memikul beban kinerja.

Kami ingin fokus pada demistifikasi, kepraktisan, pemahaman, intuisi dan proyek nyata. Mau belajar bagaimana Anda dapat membuat perbedaan? Kami akan membawa Anda dalam perjalanan dari cara otak kami memproses gambar hingga menulis pengklasifikasi pembelajaran mendalam tingkat penelitian untuk kanker payudara hingga jaringan pembelajaran mendalam yang "berhalusinasi", mengajari Anda prinsip dan teori melalui kerja praktik, membekali Anda dengan pengetahuan dan alat untuk menjadi ahli dalam menerapkan pembelajaran mendalam untuk memecahkan visi komputer.

Apa yang ada di dalam?

• Prinsip pertama visi dan bagaimana komputer dapat diajarkan untuk "melihat"
• Berbagai tugas dan aplikasi visi komputer
• Alat perdagangan yang akan membuat pekerjaan Anda lebih mudah
• Menemukan, membuat, dan memanfaatkan kumpulan data untuk visi komputer
• Teori dan penerapan Jaringan Saraf Konvolusi
• Menangani pergeseran domain, kejadian bersama, dan bias lainnya dalam kumpulan data
• Transfer Belajar dan memanfaatkan waktu pelatihan dan sumber daya komputasi orang lain untuk keuntungan Anda
• Membangun dan melatih pengklasifikasi kanker payudara yang canggih
• Bagaimana menerapkan dosis skeptisisme yang sehat untuk mengarusutamakan gagasan dan memahami implikasi dari teknik yang diadopsi secara luas
• Memvisualisasikan "ruang konsep" ConvNet menggunakan t-SNE dan PCA
• Studi kasus tentang bagaimana perusahaan menggunakan teknik visi komputer untuk mencapai hasil yang lebih baik
• Evaluasi model yang tepat, visualisasi ruang laten dan mengidentifikasi perhatian model
• Melakukan penelitian domain, memproses kumpulan data Anda sendiri, dan membuat pengujian model
• Arsitektur mutakhir, perkembangan ide, apa yang membuatnya unik dan bagaimana menerapkannya
• KerasCV – perpustakaan WIP untuk menciptakan saluran pipa dan model yang canggih
• Cara mengurai dan membaca makalah dan menerapkannya sendiri
• Memilih model tergantung pada aplikasi Anda
• Membuat pipeline machine learning ujung ke ujung
• Lanskap dan intuisi pada deteksi objek dengan R-CNN, RetinaNet, SSD, dan YOLO yang Lebih Cepat
• Instance dan segmentasi semantik
• Pengenalan Objek Real-Time dengan YOLOv5
• Melatih Detektor Objek YOLOv5
• Bekerja dengan Transformers menggunakan KerasNLP (perpustakaan WIP kekuatan industri)
• Mengintegrasikan Transformer dengan ConvNets untuk menghasilkan keterangan gambar
• Deepdream
• Optimalisasi model Deep Learning untuk visi komputer