Estimasi Pose/Deteksi Keypoint dengan YOLOv7 dengan Python

Pengantar

Deteksi objek adalah bidang besar dalam visi komputer, dan salah satu aplikasi visi komputer yang lebih penting "di alam liar".

Deteksi objek tidak standar seperti klasifikasi gambar, terutama karena sebagian besar perkembangan baru biasanya dilakukan oleh peneliti individu, pengelola dan pengembang, daripada perpustakaan besar dan kerangka kerja. Sulit untuk mengemas skrip utilitas yang diperlukan dalam kerangka kerja seperti TensorFlow atau PyTorch dan mempertahankan pedoman API yang memandu pengembangan sejauh ini.

Hal ini membuat deteksi objek agak lebih kompleks, biasanya lebih bertele-tele (tetapi tidak selalu), dan kurang mudah didekati daripada klasifikasi gambar.

Untungnya bagi banyak orang – Ultralytics telah mengembangkan API deteksi objek yang sederhana, sangat kuat, dan indah di sekitar YOLOv5 mereka yang telah diperluas oleh tim penelitian dan pengembangan lain ke versi yang lebih baru, seperti YOLOv7.

Dalam panduan singkat ini, kita akan melakukan Estimasi Pose (Deteksi Keypoint) dengan Python, dengan YOLOv7 yang canggih.

Titik kunci dapat berupa berbagai titik – bagian wajah, anggota tubuh, dll. Estimasi pose adalah kasus khusus deteksi titik kunci – di mana titik-titik tersebut adalah bagian dari tubuh manusia, dan dapat digunakan untuk menggantikan perangkat keras pelacak posisi yang mahal, mengaktifkan kontrol robotika over-the-air, dan menghidupkan era baru ekspresi diri manusia melalui AR dan VR.

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 implementasi skala besar pertama dari YOLO di PyTorch, yang membuatnya lebih mudah diakses daripada sebelumnya, tetapi alasan utama YOLOv5 mendapatkan pijakan seperti itu juga adalah API sederhana dan kuat yang dibangun di sekitarnya. Proyek ini mengabstraksikan detail yang tidak perlu, sementara memungkinkan penyesuaian, hampir semua format ekspor yang dapat digunakan, dan menggunakan praktik luar biasa yang membuat keseluruhan proyek menjadi efisien dan seoptimal mungkin.

YOLOv5 masih merupakan proyek pokok untuk membangun model Deteksi Objek, dan banyak repositori yang bertujuan untuk memajukan metode YOLO dimulai dengan YOLOv5 sebagai dasar dan menawarkan API serupa (atau cukup garpu proyek dan bangun di atasnya). Demikian halnya dengan YOLOR (Anda Hanya Belajar Satu Representasi) dan YOLOv7 yang dibangun di atas YOLOR (penulis yang sama) yang merupakan kemajuan terbaru dalam metodologi YOLO.

YOLOv7 bukan hanya arsitektur deteksi objek – menyediakan kepala model baru, yang dapat menampilkan titik kunci (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 instance dan deteksi keypoint kemungkinan akan menjadi standar baru untuk model berbasis YOLO, yang telah mulai mengungguli hampir semua detektor dua tahap lainnya beberapa tahun yang lalu.

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 lanjutkan dan instal proyek dari GitHub:

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

Ini menciptakan a yolov7 direktori di bawah direktori kerja Anda saat ini, di mana Anda akan dapat menemukan file proyek dasar:

%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

Catatan: Notebook Google Colab disetel ulang ke direktori kerja utama di sel berikutnya, bahkan setelah menelepon %cd dirname, jadi Anda harus terus memanggilnya di setiap sel yang Anda inginkan untuk menjalankan operasi. Notebook Jupyter Lokal mengingat perubahannya, jadi tidak perlu terus memanggil perintah.

Setiap kali Anda menjalankan kode dengan serangkaian bobot tertentu – kode tersebut akan diunduh dan disimpan di direktori ini. Untuk melakukan estimasi pose, kami ingin mengunduh bobot untuk model YOLOv7 yang telah dilatih sebelumnya untuk tugas itu, yang dapat ditemukan di bawah /releases/download/ tab di GitHub:

! 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

Bagus, kami telah mengunduh yolov7-w6-pose.pt file bobot, yang dapat digunakan untuk memuat dan merekonstruksi model terlatih untuk estimasi pose.

Memuat Model Estimasi Pose YOLOv7

Mari impor perpustakaan yang kita perlukan untuk melakukan estimasi pose:

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 dan torchvision cukup mudah – YOLOv7 diimplementasikan dengan PyTorch. Itu utils.datasets, utils.general dan utils.plots modul berasal dari proyek YOLOv7, dan memberi kami metode yang membantu pra-pemrosesan dan menyiapkan input untuk model untuk menjalankan inferensi. Diantaranya adalah letterbox() untuk melapisi gambar, non_max_supression_keypoint() untuk menjalankan algoritma Non-Max Supression pada output awal model dan untuk menghasilkan output yang bersih untuk interpretasi kami, serta output_to_keypoint() dan plot_skeleton_kpts() metode untuk benar-benar menambahkan titik kunci ke gambar tertentu, setelah diprediksi.

Kami dapat memuat model dari file berat dengan torch.load(). Mari buat fungsi untuk memeriksa apakah GPU tersedia, memuat model, memasukkannya ke mode inferensi, dan memindahkannya ke GPU jika tersedia:

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

Dengan model yang dimuat, mari buat run_inference() metode yang menerima string yang menunjuk ke file di sistem kami. Metode ini akan membaca gambar menggunakan OpenCV (cv2), padukan dengan letterbox(), terapkan transformasi padanya, dan ubah menjadi batch (model dilatih dan mengharapkan batch, seperti biasa):

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

Di sini, kami telah mengembalikan gambar yang diubah (karena kami ingin mengekstrak yang asli dan memplotnya) dan output dari model. Output ini berisi 45900 prediksi keypoint, yang sebagian besar tumpang tindih. Kami ingin menerapkan Non-Max Supression pada prediksi mentah ini, sama seperti prediksi Object Detection (di mana banyak kotak pembatas diprediksi dan kemudian mereka "runtuh" ​​karena kepercayaan dan ambang batas IoU). Setelah penekanan, kita dapat memplot setiap keypoint pada gambar asli dan menampilkannya:

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

Sekarang, untuk beberapa gambar input, seperti karate.jpg di direktori kerja utama, kita dapat menjalankan inferensi, melakukan Non-Max Supression dan memplot hasilnya dengan:

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

Ini menghasilkan:

Ini adalah gambaran yang cukup sulit untuk disimpulkan! Sebagian besar lengan kanan praktisi di sebelah kanan tersembunyi, dan kita dapat melihat bahwa model menyimpulkan bahwa itu tersembunyi dan di sebelah kanan tubuh, hilang bahwa siku ditekuk dan sebagian lengan ada di depan . Praktisi di sebelah kiri, yang jauh lebih jelas terlihat, disimpulkan dengan benar, bahkan dengan kaki tersembunyi.

Faktanya – seseorang yang duduk di belakang, hampir sepenuhnya tidak terlihat oleh kamera memiliki pose yang tampaknya diperkirakan dengan benar, hanya berdasarkan posisi pinggul saat duduk. Kerja bagus atas nama jaringan!

Kesimpulan

Dalam panduan ini – kami telah melihat sekilas YOLOv7, kemajuan terbaru dalam keluarga YOLO, yang dibangun di atas YOLOR, dan selanjutnya menyediakan segmentasi instans dan kemampuan deteksi keypoint di luar kemampuan deteksi objek standar dari sebagian besar model berbasis YOLO .

Kami kemudian melihat bagaimana kami dapat mengunduh file berat yang dirilis, memuatnya untuk membuat model dan melakukan inferensi estimasi pose untuk manusia, menghasilkan hasil yang mengesankan.

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