YOLOv7 . के साथ पायथन में वीडियो से रीयल-टाइम मुद्रा अनुमान

परिचय

कंप्यूटर विज़न में ऑब्जेक्ट डिटेक्शन एक बड़ा क्षेत्र है, और "जंगली में" कंप्यूटर विज़न के अधिक महत्वपूर्ण अनुप्रयोगों में से एक है। इसमें से, कीपॉइंट डिटेक्शन (अक्सर मुद्रा अनुमान के लिए उपयोग किया जाता है) निकाला गया था।

मुख्य बिंदु विभिन्न बिंदु हो सकते हैं - चेहरे के हिस्से, शरीर के अंग, आदि। मुद्रा अनुमान मुख्य बिंदु का पता लगाने का एक विशेष मामला है - जिसमें बिंदु मानव शरीर के अंग होते हैं।

मुद्रा अनुमान कंप्यूटर दृष्टि का एक अद्भुत, अत्यंत मजेदार और व्यावहारिक उपयोग है। इसके साथ, हम पोज़ (मोशन कैप्चर सूट) का अनुमान लगाने के लिए उपयोग किए जाने वाले हार्डवेयर को दूर कर सकते हैं, जो महंगे और बोझिल हैं। इसके अतिरिक्त, हम यूक्लिडियन अंतरिक्ष में रोबोट की गति के लिए मनुष्यों की गति को मैप कर सकते हैं, नियंत्रकों का उपयोग किए बिना ठीक सटीक मोटर गति को सक्षम करते हैं, जो आमतौर पर उच्च स्तर की सटीकता की अनुमति नहीं देते हैं। एआर और वीआर में हमारे आंदोलनों को 3 डी मॉडल में अनुवाद करने के लिए कीपॉइंट अनुमान का उपयोग किया जा सकता है, और केवल एक वेबकैम के साथ ऐसा करने के लिए तेजी से उपयोग किया जा रहा है। अंत में - मुद्रा अनुमान हमें खेल और सुरक्षा में मदद कर सकता है।

इस गाइड में, हम अत्याधुनिक YOLOv7 मॉडल का उपयोग करते हुए, पायथन में एक वीडियो से रीयल-टाइम पोज़ अनुमान का प्रदर्शन करेंगे।

विशेष रूप से, हम दक्षिण कोरिया के प्योंगचांग में आयोजित 2018 शीतकालीन ओलंपिक के एक वीडियो के साथ काम करेंगे:

अल्जोना सावचेंको और ब्रूनो मासोट ने एक अद्भुत प्रदर्शन किया, जिसमें कैमरे के खिलाफ अतिव्यापी निकायों, तेज द्रव आंदोलन और हवा में कताई शामिल है। यह देखने का एक अद्भुत अवसर होगा कि मॉडल कठिन-से-अनुमानित स्थितियों को कैसे संभालता है!

योलो और मुद्रा अनुमान

योलो (आप केवल एक बार देखें) एक कार्यप्रणाली है, साथ ही ऑब्जेक्ट डिटेक्शन के लिए बनाए गए मॉडलों का परिवार है। 2015 में स्थापना के बाद से, YOLOv1, YOLOv2 (YOLO9000) और YOLOv3 को एक ही लेखक (लेखकों) द्वारा प्रस्तावित किया गया है - और गहन शिक्षण समुदाय निरंतर वर्षों में ओपन-सोर्स प्रगति के साथ जारी रहा।

Ultralytics 'YOLOv5 एक उद्योग-ग्रेड ऑब्जेक्ट डिटेक्शन रिपॉजिटरी है, जिसे YOLO विधि के शीर्ष पर बनाया गया है। यह पिछले YOLO मॉडल के लिए C++ के विपरीत, PyTorch में लागू किया गया है, पूरी तरह से खुला स्रोत है, और इसमें एक सुंदर सरल और शक्तिशाली 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

हम मॉडल की भविष्यवाणियों के साथ-साथ छवि को टेंसर के रूप में वापस कर देंगे। ये "मोटे" भविष्यवाणियां हैं - इनमें कई सक्रियण शामिल हैं जो ओवरलैप करते हैं, और हम गैर-अधिकतम दमन का उपयोग करके "उन्हें साफ़ करना" चाहते हैं, और छवि पर ही अनुमानित कंकालों को प्लॉट करना चाहते हैं:

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)

इसे रीयल-टाइम वीडियो सेटिंग में अनुवाद करने के लिए - हम एक वीडियो पढ़ने के लिए ओपनसीवी का उपयोग करेंगे, और इस प्रक्रिया को प्रत्येक फ्रेम के लिए चलाएंगे। प्रत्येक फ़्रेम पर, हम फ़्रेम को एक वीडियो के रूप में एन्कोडेड एक नई फ़ाइल में भी लिखेंगे। यह आवश्यक रूप से प्रक्रिया को धीमा कर देगा क्योंकि हम अनुमान चला रहे हैं, इसे प्रदर्शित कर रहे हैं और लिख रहे हैं - ताकि आप एक नई फ़ाइल के निर्माण और लूप में इसे लिखने से बचकर अनुमान और प्रदर्शन को गति दे सकें:

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

RSI VideoWriter कई मापदंडों को स्वीकार करता है - आउटपुट फ़ाइल नाम, फोरसीसी (चार कोडेक कोड, जो वीडियो को एन्कोड करने के लिए इस्तेमाल किए गए कोडेक को दर्शाता है), फ्रैमरेट और रिज़ॉल्यूशन एक ट्यूपल के रूप में। वीडियो का अनुमान न लगाने या उसका आकार बदलने के लिए - हमने मूल वीडियो की चौड़ाई और ऊंचाई का उपयोग किया है, जिसे के माध्यम से प्राप्त किया गया है VideoCapture उदाहरण जिसमें वीडियो के बारे में ही डेटा होता है, जैसे कि चौड़ाई, ऊंचाई, फ़्रेम की कुल संख्या, आदि।

अब, हम किसी भी इनपुट वीडियो पर विधि को कॉल कर सकते हैं:

pose_estimation_video('../ice_skating.mp4')

यह एक ओपनसीवी विंडो खोलेगा, जो वास्तविक समय में अनुमान प्रदर्शित करेगा। और साथ ही, यह में एक वीडियो फ़ाइल लिखेगा yolov7 निर्देशिका (चूंकि हमने cdइसमें डी):

निष्कर्ष

इस गाइड में, हमने YOLO विधि, YOLOv7 और YOLO और ऑब्जेक्ट डिटेक्शन, पोज़ एस्टीमेशन और इंस्टेंस सेगमेंटेशन के बीच संबंध पर एक नज़र डाली है। फिर हमने इस पर एक नज़र डाली कि आप प्रोग्रामेटिक एपीआई का उपयोग करके YOLOv7 के साथ आसानी से कैसे स्थापित और काम कर सकते हैं, और अनुमान लगाने और परिणामों को प्रदर्शित करने को आसान बनाने के लिए कई विश्वसनीय तरीके बनाए हैं।

अंत में, हमने OpenCV का उपयोग करके एक वीडियो खोला है, YOLOv7 के साथ निष्कर्ष निकाला है, और वास्तविक समय में मुद्रा अनुमान करने के लिए एक फ़ंक्शन बनाया है, जिसके परिणामस्वरूप वीडियो को पूर्ण रिज़ॉल्यूशन में सहेजा गया है और आपकी स्थानीय डिस्क पर 30FPS है।

आगे जाना - कंप्यूटर विजन के लिए व्यावहारिक गहन शिक्षण

आपका जिज्ञासु स्वभाव आपको और आगे जाना चाहता है? हम अनुशंसा करते हैं कि हमारी जाँच करें कोर्स: "पायथन के साथ कंप्यूटर विजन के लिए प्रैक्टिकल डीप लर्निंग".

एक और कंप्यूटर विजन कोर्स?

हम MNIST अंकों या MNIST फैशन का वर्गीकरण नहीं करेंगे। उन्होंने बहुत समय पहले अपनी भूमिका निभाई थी। उन्नत ब्लैक-बॉक्स आर्किटेक्चर को प्रदर्शन का बोझ उठाने देने से पहले बहुत से सीखने के संसाधन बुनियादी डेटासेट और बुनियादी आर्किटेक्चर पर ध्यान केंद्रित कर रहे हैं।

हम पर ध्यान केंद्रित करना चाहते हैं रहस्योद्घाटन, व्यावहारिकता, समझ, अंतर्ज्ञान और वास्तविक परियोजनाएं. सीखना चाहते है कैसे आप कुछ कर सकते है? हम आपको हमारे दिमाग की छवियों को संसाधित करने से लेकर स्तन कैंसर के लिए एक शोध-ग्रेड डीप लर्निंग क्लासिफायर लिखने से लेकर गहन शिक्षण नेटवर्क तक ले जाएंगे जो "मतिभ्रम" करते हैं, आपको व्यावहारिक कार्य के माध्यम से सिद्धांत और सिद्धांत सिखाते हैं, आपको इससे लैस करते हैं कंप्यूटर विज़न को हल करने के लिए गहन शिक्षण को लागू करने में विशेषज्ञ बनने के लिए जानकारी और उपकरण।

अंदर क़या है?

• दृष्टि के पहले सिद्धांत और कंप्यूटर को "देखना" कैसे सिखाया जा सकता है
• कंप्यूटर विज़न के विभिन्न कार्य और अनुप्रयोग
• व्यापार के उपकरण जो आपके काम को आसान बना देंगे
• कंप्यूटर विज़न के लिए डेटासेट खोजना, बनाना और उपयोग करना
• दृढ़ तंत्रिका नेटवर्क का सिद्धांत और अनुप्रयोग
• डेटासेट में डोमेन शिफ्ट, सह-घटना और अन्य पूर्वाग्रहों को संभालना
• अपने लाभ के लिए सीखने और दूसरों के प्रशिक्षण समय और कम्प्यूटेशनल संसाधनों का उपयोग करना स्थानांतरित करें
• एक अत्याधुनिक स्तन कैंसर क्लासिफायर का निर्माण और प्रशिक्षण
• मुख्यधारा के विचारों पर संदेह की एक स्वस्थ खुराक कैसे लागू करें और व्यापक रूप से अपनाई गई तकनीकों के निहितार्थ को समझें
• t-SNE और PCA का उपयोग करके ConvNet के "अवधारणा स्थान" की कल्पना करना
• बेहतर परिणाम प्राप्त करने के लिए कंपनियां कंप्यूटर विज़न तकनीकों का उपयोग कैसे करती हैं, इसका केस अध्ययन
• उचित मॉडल मूल्यांकन, गुप्त स्थान विज़ुअलाइज़ेशन और मॉडल के ध्यान की पहचान करना
• डोमेन अनुसंधान करना, अपने स्वयं के डेटासेट को संसाधित करना और मॉडल परीक्षण स्थापित करना
• अत्याधुनिक वास्तुकला, विचारों की प्रगति, उन्हें क्या विशिष्ट बनाता है और उन्हें कैसे लागू किया जाए
• KerasCV - अत्याधुनिक पाइपलाइन और मॉडल बनाने के लिए WIP लाइब्रेरी
• पेपर कैसे पार्स करें और पढ़ें और उन्हें स्वयं कैसे लागू करें
• अपने आवेदन के आधार पर मॉडल का चयन
• एंड-टू-एंड मशीन लर्निंग पाइपलाइन बनाना
• तेजी से आर-सीएनएन, रेटिनानेट्स, एसएसडी और योलो के साथ ऑब्जेक्ट डिटेक्शन पर लैंडस्केप और अंतर्ज्ञान
• इंस्टेंस और सिमेंटिक सेगमेंटेशन
• YOLOv5 . के साथ रीयल-टाइम ऑब्जेक्ट रिकग्निशन
• YOLOv5 ऑब्जेक्ट डिटेक्टरों का प्रशिक्षण
• KerasNLP (उद्योग-शक्ति WIP पुस्तकालय) का उपयोग कर ट्रांसफॉर्मर के साथ कार्य करना
• छवियों के कैप्शन उत्पन्न करने के लिए ट्रांसफॉर्मर को कन्वनेट के साथ एकीकृत करना
• DeepDream
• कंप्यूटर विज़न के लिए डीप लर्निंग मॉडल ऑप्टिमाइज़ेशन