บทนำ
การตรวจจับวัตถุเป็นฟิลด์ขนาดใหญ่ในการมองเห็นด้วยคอมพิวเตอร์ และเป็นหนึ่งในแอปพลิเคชั่นที่สำคัญกว่าของการมองเห็นด้วยคอมพิวเตอร์ "ในธรรมชาติ"
การตรวจจับวัตถุไม่ได้มาตรฐานเท่ากับการจำแนกภาพ สาเหตุหลักมาจากการพัฒนาใหม่ส่วนใหญ่มักทำโดยนักวิจัย ผู้ดูแล และนักพัฒนาแต่ละคน แทนที่จะเป็นไลบรารีและเฟรมเวิร์กขนาดใหญ่ เป็นการยากที่จะจัดแพ็คเกจสคริปต์ยูทิลิตี้ที่จำเป็นในเฟรมเวิร์ก เช่น TensorFlow หรือ PyTorch และรักษาแนวทาง API ที่เป็นแนวทางในการพัฒนาจนถึงตอนนี้
สิ่งนี้ทำให้การตรวจจับวัตถุค่อนข้างซับซ้อนมากขึ้น โดยทั่วไปแล้วจะละเอียดกว่า (แต่ไม่เสมอไป) และเข้าถึงได้น้อยกว่าการจัดประเภทรูปภาพ
โชคดีสำหรับคนจำนวนมาก – Ultralytics ได้พัฒนา API การตรวจจับวัตถุที่เรียบง่าย ทรงพลัง และสวยงามรอบๆ YOLOv5 ซึ่งได้รับการขยายโดยทีมวิจัยและพัฒนาอื่นๆ ในเวอร์ชันที่ใหม่กว่า เช่น YOLOv7
ในคู่มือฉบับย่อนี้ เราจะดำเนินการ Pose Estimation (Keypoint Detection) ใน Python ด้วย YOLOv7 ที่ล้ำสมัย
จุดสำคัญอาจเป็นจุดต่างๆ เช่น ส่วนต่างๆ ของใบหน้า แขนขา ฯลฯ การประมาณค่าท่าทางเป็นกรณีพิเศษของการตรวจจับจุดสำคัญ ซึ่งจุดต่างๆ เป็นส่วนหนึ่งของร่างกายมนุษย์ และสามารถใช้แทนฮาร์ดแวร์ติดตามตำแหน่งที่มีราคาแพงได้ เปิดใช้งานการควบคุมหุ่นยนต์แบบ over-the-air และขับเคลื่อนยุคใหม่ของการแสดงออกของมนุษย์ผ่าน AR และ VR
YOLO และการประมาณการท่าทาง
YOLO (คุณมองเพียงครั้งเดียว) เป็นวิธีการเช่นเดียวกับกลุ่มของแบบจำลองที่สร้างขึ้นสำหรับการตรวจจับวัตถุ นับตั้งแต่ก่อตั้งในปี 2015 YOLOv1, YOLOv2 (YOLO9000) และ YOLOv3 ได้รับการเสนอโดยผู้เขียนคนเดียวกัน – และชุมชนการเรียนรู้เชิงลึกยังคงดำเนินต่อไปด้วยความก้าวหน้าแบบโอเพนซอร์ซในปีต่อๆ ไป
Ultralytics' YOLOv5 เป็นการนำ YOLO ไปใช้งานขนาดใหญ่ครั้งแรกใน PyTorch ซึ่งทำให้เข้าถึงได้ง่ายกว่าที่เคย แต่เหตุผลหลักที่ YOLOv5 ได้รับการตั้งหลักดังกล่าวก็คือ API ที่เรียบง่ายและทรงพลังซึ่งสร้างขึ้นโดยรอบ โปรเจ็กต์จะสรุปรายละเอียดที่ไม่จำเป็นออกไป ในขณะที่อนุญาตให้ปรับแต่งได้ ทุกรูปแบบการส่งออกที่ใช้งานได้จริง และใช้แนวทางปฏิบัติที่น่าทึ่งที่ทำให้ทั้งโปรเจ็กต์มีประสิทธิภาพและเหมาะสมที่สุดเท่าที่จะทำได้
YOLOv5 ยังคงเป็นโครงการหลักในการสร้างแบบจำลองการตรวจจับวัตถุด้วย และที่เก็บจำนวนมากที่มีจุดมุ่งหมายเพื่อพัฒนาวิธี YOLO เริ่มต้นด้วย YOLOv5 เป็นพื้นฐานและเสนอ API ที่คล้ายกัน (หรือเพียงแค่แยกโครงการแล้วสร้างต่อยอด) นั่นคือกรณีของ YOLOR (คุณเรียนรู้เพียงหนึ่งตัวแทน) และ YOLOv7 ซึ่งสร้างขึ้นจาก YOLOR (ผู้เขียนคนเดียวกัน) ซึ่งเป็นความก้าวหน้าล่าสุดในวิธีการของ YOLO
YOLOv7 ไม่ได้เป็นเพียงสถาปัตยกรรมการตรวจจับวัตถุ – มีส่วนหัวของโมเดลใหม่ ที่สามารถส่งออกจุดสำคัญ (โครงกระดูก) และดำเนินการแบ่งส่วนอินสแตนซ์นอกเหนือจากการถดถอยของขอบเขตเท่านั้น ซึ่งไม่ได้มาตรฐานสำหรับรุ่น YOLO รุ่นก่อน ไม่น่าแปลกใจเลย เนื่องจากสถาปัตยกรรมการตรวจจับวัตถุจำนวนมากถูกนำมาใช้ใหม่สำหรับการแบ่งส่วนอินสแตนซ์และงานการตรวจจับจุดสำคัญก่อนหน้านี้เช่นกัน เนื่องจากสถาปัตยกรรมทั่วไปที่ใช้ร่วมกัน โดยมีเอาต์พุตที่แตกต่างกันขึ้นอยู่กับงาน แม้ว่าจะไม่ใช่เรื่องน่าแปลกใจ แต่การสนับสนุนการแบ่งส่วนอินสแตนซ์และการตรวจจับจุดสำคัญจะกลายเป็นมาตรฐานใหม่สำหรับโมเดลที่ใช้ YOLO ซึ่งเริ่มมีประสิทธิภาพเหนือกว่าเครื่องตรวจจับแบบสองขั้นตอนอื่นๆ ทั้งหมดเมื่อสองสามปีก่อน
สิ่งนี้ทำให้การแบ่งส่วนอินสแตนซ์และการตรวจจับจุดคีย์ทำงานได้เร็วกว่าที่เคย ด้วยสถาปัตยกรรมที่ง่ายกว่าตัวตรวจจับแบบสองขั้นตอน
โมเดลนี้สร้างขึ้นจากการเปลี่ยนแปลงทางสถาปัตยกรรม รวมถึงการเพิ่มประสิทธิภาพด้านการฝึกอบรม เรียกว่า "กระเป๋าของแจกฟรี" ซึ่งเพิ่มความแม่นยำโดยไม่เพิ่มต้นทุนการอนุมาน
กำลังติดตั้ง YOLOv7
ไปข้างหน้าและติดตั้งโครงการจาก GitHub:
! git clone https://github.com/WongKinYiu/yolov7.git
สิ่งนี้จะสร้างไฟล์ yolov7 ไดเร็กทอรีภายใต้ไดเร็กทอรีการทำงานปัจจุบันของคุณ ซึ่งคุณจะพบไฟล์โปรเจ็กต์พื้นฐาน:
%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
หมายเหตุ Google Colab Notebooks รีเซ็ตเป็นไดเร็กทอรีการทำงานหลักในเซลล์ถัดไป แม้จะโทรไปแล้วก็ตาม %cd dirnameดังนั้น คุณจะต้องเรียกมันต่อไปในแต่ละเซลล์ที่คุณต้องการให้มีการดำเนินการ สมุดบันทึก Jupyter ในพื้นที่จะจดจำการเปลี่ยนแปลงนั้นไว้ ดังนั้นจึงไม่จำเป็นต้องเรียกใช้คำสั่งต่อไป
เมื่อใดก็ตามที่คุณเรียกใช้โค้ดด้วยชุดน้ำหนักที่กำหนด โค้ดเหล่านั้นจะถูกดาวน์โหลดและจัดเก็บไว้ในไดเร็กทอรีนี้ ในการประมาณค่าท่าทาง เราจะต้องดาวน์โหลดน้ำหนักสำหรับโมเดล YOLOv7 ที่ผ่านการฝึกอบรมล่วงหน้าสำหรับงานนั้น ซึ่งสามารถพบได้ภายใต้ /releases/download/ แท็บบน 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
เยี่ยมมาก เราดาวน์โหลด . แล้ว yolov7-w6-pose.pt ไฟล์ weights ซึ่งสามารถใช้เพื่อโหลดและสร้างแบบจำลองที่ผ่านการฝึกอบรมขึ้นใหม่สำหรับการประมาณค่าท่าทาง
กำลังโหลด YOLOv7 Pose Estimation Model
มานำเข้าไลบรารีที่เราจำเป็นต้องทำการประเมินท่าทางกันเถอะ:
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 และ torchvision ตรงไปตรงมาเพียงพอ - ใช้งาน YOLOv7 กับ PyTorch ดิ utils.datasets, utils.general และ utils.plots โมดูลมาจากโครงการ YOLOv7 และจัดเตรียมวิธีการที่ช่วยในการประมวลผลล่วงหน้าและเตรียมอินพุตสำหรับโมเดลเพื่อเรียกใช้การอนุมาน ในบรรดานั้นคือ letterbox() เพื่อรองภาพ non_max_supression_keypoint() เพื่อรันอัลกอริธึม Non-Max Supression ในเอาต์พุตเริ่มต้นของโมเดล และเพื่อสร้างเอาต์พุตที่สะอาดสำหรับการตีความของเรา เช่นเดียวกับ output_to_keypoint() และ plot_skeleton_kpts() วิธีการเพิ่มจุดสำคัญให้กับภาพที่กำหนดจริง ๆ เมื่อคาดการณ์แล้ว
เราสามารถโหลดแบบจำลองจากไฟล์น้ำหนักด้วย torch.load(). มาสร้างฟังก์ชันเพื่อตรวจสอบว่ามี GPU หรือไม่ โหลดโมเดล วางไว้ในโหมดอนุมาน และย้ายไปยัง GPU หากมี:
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()
ดูคู่มือเชิงปฏิบัติสำหรับการเรียนรู้ Git ที่มีแนวทางปฏิบัติที่ดีที่สุด มาตรฐานที่ยอมรับในอุตสาหกรรม และเอกสารสรุปรวม หยุดคำสั่ง Googling Git และจริงๆ แล้ว เรียน มัน!
เมื่อโหลดโมเดลแล้ว มาสร้าง a . กัน run_inference() เมธอดที่รับสตริงที่ชี้ไปยังไฟล์ในระบบของเรา วิธีการจะอ่านภาพโดยใช้ OpenCV (cv2) ปาดด้วย letterbox()ใช้การแปลงกับมัน และแปลงเป็นแบทช์ (โมเดลได้รับการฝึกอบรมและคาดว่าจะเป็นแบทช์ตามปกติ):
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
ที่นี่ เราได้ส่งคืนรูปภาพที่แปลงแล้ว (เพราะเราต้องการแยกต้นฉบับและลงจุดบนรูปภาพ) และผลลัพธ์ของโมเดล เอาต์พุตเหล่านี้มีการคาดคะเนจุดสำคัญ 45900 ซึ่งส่วนใหญ่ทับซ้อนกัน เราจะต้องการใช้ Non-Max Supression กับการคาดการณ์ดิบเหล่านี้ เช่นเดียวกับการคาดการณ์ของ Object Detection (โดยที่กรอบขอบเขตจำนวนมากถูกคาดการณ์และจากนั้นจะ "ยุบ" ด้วยความมั่นใจและขีดจำกัดของ IoU) หลังจากการปราบปราม เราสามารถพล็อตจุดสำคัญแต่ละจุดบนภาพต้นฉบับและแสดง:
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()
ตอนนี้สำหรับภาพอินพุตบางภาพเช่น karate.jpg ในไดเร็กทอรีการทำงานหลัก เราสามารถเรียกใช้การอนุมาน ดำเนินการ Non-Max Supression และพล็อตผลลัพธ์ด้วย:
output, image = run_inference('./karate.jpg')
visualize_output(output, image)
ผลลัพธ์นี้ใน:
นี่เป็นภาพที่สรุปได้ยากทีเดียว! แขนขวาของผู้ปฏิบัติส่วนใหญ่ทางด้านขวาถูกซ่อนไว้ และเราจะเห็นได้ว่าแบบจำลองนั้นอนุมานได้ว่าซ่อนอยู่และอยู่ทางด้านขวาของร่างกาย ขาดว่าศอกงอและแขนส่วนหนึ่งอยู่ข้างหน้า . ผู้ฝึกหัดทางด้านซ้ายซึ่งมองเห็นได้ชัดเจนกว่านั้นได้รับการอนุมานอย่างถูกต้องแม้จะซ่อนขาไว้ก็ตาม
ตามความเป็นจริง - คนที่นั่งด้านหลัง แทบจะมองไม่เห็นกล้องเลย ได้ประมาณการท่าที่ถูกต้อง โดยพิจารณาจากตำแหน่งของสะโพกขณะนั่งลง ยิ่งใหญ่ในนามเครือข่าย!
สรุป
ในคู่มือนี้ เราได้ดูคร่าวๆ เกี่ยวกับ YOLOv7 ซึ่งเป็นความก้าวหน้าล่าสุดในตระกูล YOLO ซึ่งสร้างขึ้นจาก YOLOR และให้ความสามารถในการแบ่งกลุ่มอินสแตนซ์และการตรวจจับจุดสำคัญที่เหนือกว่าความสามารถในการตรวจจับวัตถุมาตรฐานของแบบจำลองที่ใช้ YOLO ส่วนใหญ่ .
จากนั้นเราได้ดูวิธีที่เราสามารถดาวน์โหลดไฟล์น้ำหนักที่ปล่อยออกมา โหลดไฟล์เพื่อสร้างแบบจำลองและทำการอนุมานการประมาณค่าท่าทางสำหรับมนุษย์ ให้ผลลัพธ์ที่น่าประทับใจ
ก้าวต่อไป – การเรียนรู้เชิงลึกเชิงปฏิบัติสำหรับคอมพิวเตอร์วิทัศน์
ธรรมชาติที่อยากรู้อยากเห็นของคุณทำให้คุณต้องการไปต่อหรือไม่? เราขอแนะนำให้ตรวจสอบของเรา คอร์ส: “การเรียนรู้เชิงลึกเชิงปฏิบัติสำหรับคอมพิวเตอร์วิทัศน์ด้วย 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 สำหรับคอมพิวเตอร์วิทัศน์
- blockchain
- C + +
- รหัส
- เหรียญอัจฉริยะ
- วิสัยทัศน์คอมพิวเตอร์
- การเรียนรู้ลึก ๆ
- ชวา
- การตรวจจับจุดสำคัญ
- เรียนรู้เครื่อง
- โทเค็นที่ไม่สามารถทำซ้ำได้
- ทะเลเปิด
- PHP
- เพลโต
- เพลโตไอ
- เพลโตดาต้าอินเทลลิเจนซ์
- เกมเพลโต
- Platoblockchain
- เพลโตดาต้า
- เพลโตเกม
- รูปหลายเหลี่ยม
- ประมาณการท่าทาง
- หลาม
- ไฟฉาย
- เกิดปฏิกิริยา
- สัญญาสมาร์ท
- โซลานา
- สแต็ค
- คบเพลิง
- Vyper
- Web3
- Yolo
- ลมทะเล
