บทนำ
การตรวจจับวัตถุเป็นฟิลด์ขนาดใหญ่ในการมองเห็นด้วยคอมพิวเตอร์ และเป็นหนึ่งในแอปพลิเคชั่นที่สำคัญกว่าของการมองเห็นด้วยคอมพิวเตอร์ "ในธรรมชาติ" จากนั้นจึงแยกการตรวจจับจุดสำคัญ (มักใช้สำหรับการประเมินท่าทาง)
จุดสำคัญอาจเป็นจุดต่างๆ ได้ เช่น ส่วนต่างๆ ของใบหน้า แขนขาของร่างกาย ฯลฯ การประมาณค่าท่าทางเป็นกรณีพิเศษของการตรวจจับจุดสำคัญ ซึ่งจุดต่างๆ เป็นส่วนหนึ่งของร่างกายมนุษย์
การประมาณค่าท่าทางเป็นการใช้คอมพิวเตอร์วิทัศน์ที่น่าทึ่ง สนุกสุดๆ และใช้งานได้จริง ด้วยสิ่งนี้ เราจึงขจัดฮาร์ดแวร์ที่ใช้ในการประเมินท่าทาง (ชุดจับการเคลื่อนไหว) ซึ่งมีค่าใช้จ่ายสูงและเทอะทะ นอกจากนี้ เราสามารถจับคู่การเคลื่อนที่ของมนุษย์กับการเคลื่อนที่ของหุ่นยนต์ในอวกาศแบบยุคลิด ซึ่งทำให้สามารถเคลื่อนมอเตอร์ได้อย่างแม่นยำโดยไม่ต้องใช้ตัวควบคุม ซึ่งปกติแล้วจะไม่อนุญาตให้มีความแม่นยำในระดับที่สูงขึ้น สามารถใช้การประมาณค่าจุดสำคัญเพื่อแปลการเคลื่อนไหวของเราเป็นโมเดล 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
หมายเหตุ การเรียกร้อง !cd dirname
ย้ายคุณไปยังไดเร็กทอรีในเซลล์นั้น โทร %cd dirname
ย้ายคุณไปยังไดเร็กทอรีข้ามเซลล์ที่กำลังจะมีขึ้นและช่วยให้คุณอยู่ที่นั่น
ตอนนี้ 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
ดูคู่มือเชิงปฏิบัติสำหรับการเรียนรู้ Git ที่มีแนวทางปฏิบัติที่ดีที่สุด มาตรฐานที่ยอมรับในอุตสาหกรรม และเอกสารสรุปรวม หยุดคำสั่ง Googling Git และจริงๆ แล้ว เรียน มัน!
ยอดเยี่ยม! มาเริ่มด้วยการโหลดโมเดลและสร้างสคริปต์ที่ให้คุณอนุมานโพสท่าจากวิดีโอด้วย 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
เข้าไปในนั้น):
หมายเหตุ หาก GPU ของคุณมีปัญหา หรือหากคุณต้องการฝังผลลัพธ์ของโมเดลเช่นนี้ลงในแอปพลิเคชันที่มีเวลาแฝงซึ่งเป็นส่วนสำคัญของเวิร์กโฟลว์ ให้ทำให้วิดีโอมีขนาดเล็กลงและทำงานในเฟรมที่เล็กลง นี่เป็นวิดีโอแบบ Full HD 1920×1080 และน่าจะทำงานได้อย่างรวดเร็วบนระบบภายในบ้านส่วนใหญ่ แต่ถ้าระบบของคุณทำงานได้ไม่ดีนัก ให้ทำให้ภาพมีขนาดเล็กลง
สรุป
ในคู่มือนี้ เราได้พิจารณาวิธี 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 สำหรับคอมพิวเตอร์วิทัศน์