การประเมินท่าทางแบบเรียลไทม์จากวิดีโอใน Python ด้วย YOLOv7

บทนำ

การตรวจจับวัตถุเป็นฟิลด์ขนาดใหญ่ในการมองเห็นด้วยคอมพิวเตอร์ และเป็นหนึ่งในแอปพลิเคชั่นที่สำคัญกว่าของการมองเห็นด้วยคอมพิวเตอร์ "ในธรรมชาติ" จากนั้นจึงแยกการตรวจจับจุดสำคัญ (มักใช้สำหรับการประเมินท่าทาง)

จุดสำคัญอาจเป็นจุดต่างๆ ได้ เช่น ส่วนต่างๆ ของใบหน้า แขนขาของร่างกาย ฯลฯ การประมาณค่าท่าทางเป็นกรณีพิเศษของการตรวจจับจุดสำคัญ ซึ่งจุดต่างๆ เป็นส่วนหนึ่งของร่างกายมนุษย์

การประมาณค่าท่าทางเป็นการใช้คอมพิวเตอร์วิทัศน์ที่น่าทึ่ง สนุกสุดๆ และใช้งานได้จริง ด้วยสิ่งนี้ เราจึงขจัดฮาร์ดแวร์ที่ใช้ในการประเมินท่าทาง (ชุดจับการเคลื่อนไหว) ซึ่งมีค่าใช้จ่ายสูงและเทอะทะ นอกจากนี้ เราสามารถจับคู่การเคลื่อนที่ของมนุษย์กับการเคลื่อนที่ของหุ่นยนต์ในอวกาศแบบยุคลิด ซึ่งทำให้สามารถเคลื่อนมอเตอร์ได้อย่างแม่นยำโดยไม่ต้องใช้ตัวควบคุม ซึ่งปกติแล้วจะไม่อนุญาตให้มีความแม่นยำในระดับที่สูงขึ้น สามารถใช้การประมาณค่าจุดสำคัญเพื่อแปลการเคลื่อนไหวของเราเป็นโมเดล 3 มิติใน AR และ VR และมีการใช้เว็บแคมมากขึ้นเรื่อยๆ สุดท้าย – การประมาณการท่าทางสามารถช่วยเราได้ในด้านกีฬาและความปลอดภัย

ในคู่มือนี้ เราจะทำการประเมินท่าทางแบบเรียลไทม์จากวิดีโอใน Python โดยใช้โมเดล YOLOv7 ที่ล้ำสมัย

โดยเฉพาะอย่างยิ่ง เราจะทำงานกับวิดีโอจากโอลิมปิกฤดูหนาวปี 2018 ซึ่งจัดขึ้นที่เมืองพยองชางของเกาหลีใต้:

Aljona Savchenko และ Bruno Massot แสดงผลงานได้อย่างยอดเยี่ยม ซึ่งรวมถึงตัวกล้องที่ทับซ้อนกัน การเคลื่อนที่ของของเหลวอย่างรวดเร็ว และการหมุนไปในอากาศ มันจะเป็นโอกาสอันยอดเยี่ยมที่จะได้เห็นว่าตัวแบบจัดการกับสถานการณ์ที่สรุปยากได้อย่างไร!

YOLO และการประมาณการท่าทาง

YOLO (คุณมองเพียงครั้งเดียว) เป็นวิธีการเช่นเดียวกับกลุ่มของแบบจำลองที่สร้างขึ้นสำหรับการตรวจจับวัตถุ นับตั้งแต่ก่อตั้งในปี 2015 YOLOv1, YOLOv2 (YOLO9000) และ YOLOv3 ได้รับการเสนอโดยผู้เขียนคนเดียวกัน – และชุมชนการเรียนรู้เชิงลึกยังคงดำเนินต่อไปด้วยความก้าวหน้าแบบโอเพนซอร์ซในปีต่อๆ ไป

Ultralytics' YOLOv5 เป็นพื้นที่เก็บข้อมูลการตรวจจับวัตถุระดับอุตสาหกรรม ซึ่งสร้างขึ้นจากวิธี YOLO มีการใช้งานใน PyTorch ซึ่งต่างจาก C++ สำหรับรุ่น YOLO รุ่นก่อนๆ เป็นโอเพ่นซอร์สอย่างสมบูรณ์ และมี API ที่เรียบง่ายและทรงพลังที่สวยงาม ซึ่งช่วยให้คุณอนุมาน ฝึกฝน และปรับแต่งโครงการได้อย่างยืดหยุ่น มันเป็นวัตถุดิบหลักที่ความพยายามครั้งใหม่ในการปรับปรุงวิธี YOLO สร้างขึ้นบนนั้น

นี่คือวิธีที่ YOLOR (คุณเรียนรู้เพียงหนึ่งตัวแทน) และ YOLOv7 ที่สร้างบน YOLOR (ผู้เขียนคนเดียวกัน) ก็ถูกสร้างขึ้นเช่นกัน!

YOLOv7 ไม่ได้เป็นเพียงสถาปัตยกรรมการตรวจจับวัตถุ แต่มีส่วนหัวของโมเดลใหม่ ที่สามารถส่งออกจุดสำคัญ (โครงกระดูก) และดำเนินการแบ่งกลุ่มอินสแตนซ์นอกเหนือจากการถดถอยของขอบเขตเท่านั้น ซึ่งไม่ได้มาตรฐานสำหรับรุ่น YOLO รุ่นก่อน ไม่น่าแปลกใจเลย เนื่องจากสถาปัตยกรรมการตรวจจับวัตถุจำนวนมากถูกนำมาใช้ใหม่สำหรับการแบ่งส่วนอินสแตนซ์และงานการตรวจจับจุดสำคัญก่อนหน้านี้เช่นกัน เนื่องจากสถาปัตยกรรมทั่วไปที่ใช้ร่วมกัน โดยมีเอาต์พุตที่แตกต่างกันขึ้นอยู่กับงาน

แม้ว่าจะไม่ใช่เรื่องน่าแปลกใจ แต่การสนับสนุนการแบ่งส่วนอินสแตนซ์และการตรวจจับจุดสำคัญจะกลายเป็นมาตรฐานใหม่สำหรับโมเดลที่ใช้ YOLO ซึ่งเริ่มมีประสิทธิภาพเหนือกว่าเครื่องตรวจจับแบบสองขั้นตอนอื่นๆ ทั้งหมดเมื่อสองสามปีก่อนทั้งในด้านความแม่นยำและความเร็ว

สิ่งนี้ทำให้การแบ่งส่วนอินสแตนซ์และการตรวจจับจุดคีย์ทำงานได้เร็วกว่าที่เคย ด้วยสถาปัตยกรรมที่ง่ายกว่าตัวตรวจจับแบบสองขั้นตอน

โมเดลนี้สร้างขึ้นจากการเปลี่ยนแปลงทางสถาปัตยกรรม รวมถึงการเพิ่มประสิทธิภาพด้านการฝึกอบรม เรียกว่า "กระเป๋าของแจกฟรี" ซึ่งเพิ่มความแม่นยำโดยไม่เพิ่มต้นทุนการอนุมาน

กำลังติดตั้ง YOLOv7

เริ่มต้นด้วยการโคลนที่เก็บเพื่อรับซอร์สโค้ด:

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

ตอนนี้ขอย้ายไปอยู่ใน yolov7 ไดเร็กทอรีซึ่งมีโครงการและดูเนื้อหา:

%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

ตอนนี้ YOLO ถูกกำหนดให้เป็นเครื่องตรวจจับวัตถุ และไม่ได้จัดส่งพร้อมน้ำหนักการประเมินท่าทางโดย dedfault เราจะต้องการดาวน์โหลดตุ้มน้ำหนักและโหลดอินสแตนซ์โมเดลที่เป็นรูปธรรมจากพวกมัน ตุ้มน้ำหนักมีอยู่ในที่เก็บ GitHub เดียวกัน และสามารถดาวน์โหลดผ่าน 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

เมื่อดาวน์โหลดแล้ว เราสามารถนำเข้าไลบรารีและวิธีการช่วยเหลือที่เราจะใช้:

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

ยอดเยี่ยม! มาเริ่มด้วยการโหลดโมเดลและสร้างสคริปต์ที่ให้คุณอนุมานโพสท่าจากวิดีโอด้วย YOLOv7 และ OpenCV

การประเมินท่าทางแบบเรียลไทม์ด้วย YOLOv7

มาสร้างวิธีการโหลดโมเดลจากน้ำหนักที่ดาวน์โหลดกันก่อน เราจะตรวจสอบว่ามีอุปกรณ์ใดบ้าง (CPU หรือ 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 หรือไม่ เราจะเปิดความแม่นยำครึ่งหนึ่ง (โดยใช้ float16 แทน float32 ในการดำเนินการ) ซึ่งทำให้การอนุมานเร็วขึ้นอย่างมาก โปรดทราบว่าขอแนะนำให้ดำเนินการนี้บน GPU สำหรับความเร็วแบบเรียลไทม์ เนื่องจาก CPU มักจะไม่มีพลังที่จะทำอย่างนั้นได้ เว้นแต่จะใช้งานในวิดีโอขนาดเล็ก

มาเขียนวิธีสร้างความมั่นใจในการอนุมานกัน เราจะยอมรับรูปภาพเป็นอาร์เรย์ NumPy (เนื่องจากเราจะส่งต่อรูปภาพเหล่านี้ในภายหลังขณะอ่านวิดีโอ) ขั้นแรก ใช้ letterbox() ฟังก์ชัน – เราจะปรับขนาดและแพ็ดวิดีโอให้เป็นรูปร่างที่โมเดลสามารถใช้ได้ ไม่จำเป็นต้องเป็นเช่นนี้และไม่ใช่รูปร่าง (ความละเอียด) ของวิดีโอที่ได้!

จากนั้น เราจะใช้การแปลง แปลงรูปภาพเป็นความแม่นยำครึ่งหนึ่ง (หากมี GPU) แบทช์และเรียกใช้ผ่านโมเดล:

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

เราจะส่งคืนการคาดคะเนของแบบจำลอง เช่นเดียวกับภาพเป็นเทนเซอร์ สิ่งเหล่านี้เป็นการคาดคะเนที่ "คร่าวๆ" ซึ่งประกอบด้วยการเปิดใช้งานจำนวนมากที่ทับซ้อนกัน และเราจะต้อง "ล้างข้อมูลเหล่านั้น" โดยใช้ Non-Max Supression และวางแผนโครงกระดูกที่คาดการณ์ไว้เหนือรูปภาพ:

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

ด้วยสิ่งเหล่านี้ โฟลว์ทั่วไปของเราจะมีลักษณะดังนี้:

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

ในการแปลเป็นการตั้งค่าวิดีโอแบบเรียลไทม์ เราจะใช้ OpenCV เพื่ออ่านวิดีโอ และเรียกใช้กระบวนการนี้สำหรับทุกเฟรม ในแต่ละเฟรม เราจะเขียนเฟรมลงในไฟล์ใหม่ โดยเข้ารหัสเป็นวิดีโอ การทำเช่นนี้จะทำให้กระบวนการช้าลงในขณะที่เรากำลังเรียกใช้การอนุมาน แสดงและเขียน ดังนั้นคุณจึงสามารถเร่งความเร็วการอนุมานและแสดงผลโดยหลีกเลี่ยงการสร้างไฟล์ใหม่และเขียนลงในลูป:

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

พื้นที่ VideoWriter ยอมรับพารามิเตอร์หลายตัว – ชื่อไฟล์เอาท์พุต, FourCC (โค้ดโค้ดสี่ตัว แสดงถึงตัวแปลงสัญญาณที่ใช้ในการเข้ารหัสวิดีโอ) อัตราเฟรมและความละเอียดเป็นทูเพิล เพื่อไม่ให้เดาหรือปรับขนาดวิดีโอ – เราใช้ความกว้างและความสูงของวิดีโอต้นฉบับซึ่งได้มาจาก VideoCapture ที่มีข้อมูลเกี่ยวกับตัววิดีโอ เช่น ความกว้าง ความสูง จำนวนเฟรมทั้งหมด เป็นต้น

ตอนนี้ เราสามารถเรียกใช้เมธอดในวิดีโออินพุตใดๆ ได้:

pose_estimation_video('../ice_skating.mp4')

ซึ่งจะเป็นการเปิดหน้าต่าง OpenCV โดยแสดงการอนุมานแบบเรียลไทม์ และยังเขียนไฟล์วิดีโอใน yolov7 ไดเร็กทอรี (ตั้งแต่เราได้ cdเข้าไปในนั้น):

สรุป

ในคู่มือนี้ เราได้พิจารณาวิธี YOLO, YOLOv7 และความสัมพันธ์ระหว่าง YOLO กับการตรวจจับวัตถุ การประมาณค่าท่าทาง และการแบ่งส่วนอินสแตนซ์ จากนั้น เราได้พิจารณาวิธีที่คุณสามารถติดตั้งและทำงานกับ YOLOv7 ได้อย่างง่ายดายโดยใช้ API แบบเป็นโปรแกรม และสร้างวิธีการสร้างความมั่นใจหลายวิธีเพื่อให้การอนุมานและแสดงผลลัพธ์ง่ายขึ้น

สุดท้าย เราได้เปิดวิดีโอโดยใช้ OpenCV ทำการอนุมานด้วย YOLOv7 และสร้างฟังก์ชันสำหรับการประเมินท่าทางแบบเรียลไทม์ บันทึกวิดีโอที่ได้ในความละเอียดเต็มและ 30FPS บนดิสก์ในเครื่องของคุณ

ก้าวต่อไป – การเรียนรู้เชิงลึกเชิงปฏิบัติสำหรับคอมพิวเตอร์วิทัศน์

ธรรมชาติที่อยากรู้อยากเห็นของคุณทำให้คุณต้องการไปต่อหรือไม่? เราขอแนะนำให้ตรวจสอบของเรา คอร์ส: “การเรียนรู้เชิงลึกเชิงปฏิบัติสำหรับคอมพิวเตอร์วิทัศน์ด้วย Python”.

หลักสูตร Computer Vision อื่น?

เราจะไม่ทำการจำแนกตัวเลข MNIST หรือแฟชั่น MNIST พวกเขาทำหน้าที่ส่วนของตนเมื่อนานมาแล้ว ทรัพยากรการเรียนรู้จำนวนมากเกินไปมุ่งเน้นไปที่ชุดข้อมูลพื้นฐานและสถาปัตยกรรมพื้นฐาน ก่อนปล่อยให้สถาปัตยกรรมกล่องดำขั้นสูงรับภาระด้านประสิทธิภาพ

เราต้องการที่จะมุ่งเน้นไปที่ การทำให้ลึกลับ, การปฏิบัติจริง, ความเข้าใจ, ปรีชา และ โครงการจริง. ต้องการเรียน อย่างไร คุณสามารถสร้างความแตกต่าง? เราจะพาคุณเดินทางตั้งแต่วิธีที่สมองของเราประมวลผลภาพไปจนถึงการเขียนตัวแยกประเภทการเรียนรู้เชิงลึกระดับการวิจัยสำหรับมะเร็งเต้านม ไปจนถึงเครือข่ายการเรียนรู้เชิงลึกที่ "หลอน" สอนหลักการและทฤษฎีแก่คุณผ่านการทำงานจริง เพื่อให้คุณมี ความรู้และเครื่องมือในการเป็นผู้เชี่ยวชาญในการประยุกต์ใช้การเรียนรู้เชิงลึกเพื่อแก้ปัญหาคอมพิวเตอร์วิทัศน์

อะไรอยู่ข้างใน?

• หลักการมองเห็นเบื้องต้นและวิธีการสอนคอมพิวเตอร์ให้ “มองเห็น”
• งานต่างๆ และการประยุกต์ใช้คอมพิวเตอร์วิทัศน์
• เครื่องมือการค้าที่จะทำให้งานของคุณง่ายขึ้น
• การค้นหา การสร้าง และการใช้ชุดข้อมูลสำหรับคอมพิวเตอร์วิทัศน์
• ทฤษฎีและการประยุกต์ใช้ Convolutional Neural Networks
• การจัดการการเปลี่ยนแปลงโดเมน การเกิดขึ้นร่วม และอคติอื่นๆ ในชุดข้อมูล
• ถ่ายทอดการเรียนรู้และใช้เวลาฝึกอบรมและทรัพยากรการคำนวณของผู้อื่นเพื่อประโยชน์ของคุณ
• การสร้างและฝึกอบรมผู้จำแนกมะเร็งเต้านมที่ล้ำสมัย
• วิธีการใช้ความสงสัยที่ดีต่อสุขภาพกับแนวคิดกระแสหลักและทำความเข้าใจกับความหมายของเทคนิคที่นำมาใช้กันอย่างแพร่หลาย
• การแสดงภาพ "พื้นที่แนวคิด" ของ ConvNet โดยใช้ t-SNE และ PCA
• กรณีศึกษาวิธีที่บริษัทต่างๆ ใช้เทคนิคการมองเห็นด้วยคอมพิวเตอร์เพื่อให้ได้ผลลัพธ์ที่ดีขึ้น
• การประเมินแบบจำลองที่เหมาะสม การสร้างภาพพื้นที่แฝง และการระบุความสนใจของแบบจำลอง
• ดำเนินการวิจัยโดเมน ประมวลผลชุดข้อมูลของคุณเอง และสร้างการทดสอบแบบจำลอง
• สถาปัตยกรรมล้ำสมัย ความก้าวหน้าของแนวคิด สิ่งที่ทำให้มีเอกลักษณ์เฉพาะตัว และวิธีนำไปใช้
• KerasCV – ไลบรารี WIP สำหรับสร้างไปป์ไลน์และโมเดลที่ทันสมัย
• วิธีแยกวิเคราะห์และอ่านเอกสารและนำไปใช้เอง
• การเลือกรุ่นขึ้นอยู่กับการใช้งานของคุณ
• การสร้างไปป์ไลน์การเรียนรู้ของเครื่องแบบ end-to-end
• ภูมิทัศน์และสัญชาตญาณในการตรวจจับวัตถุด้วย R-CNN ที่เร็วกว่า, RetinaNets, SSD และ YOLO
• การแบ่งกลุ่มตัวอย่างและความหมาย
• การจดจำวัตถุแบบเรียลไทม์ด้วย YOLOv5
• การฝึกอบรมเครื่องตรวจจับวัตถุ YOLOv5
• การทำงานกับ Transformers โดยใช้ KerasNLP (ไลบรารี WIP ที่มีความแข็งแกร่งในอุตสาหกรรม)
• การรวม Transformers เข้ากับ ConvNets เพื่อสร้างคำบรรยายภาพ
• Deepdream
• การเพิ่มประสิทธิภาพโมเดล Deep Learning สำหรับคอมพิวเตอร์วิทัศน์