सभी के बारे में YOLO - Part5 - इसे कैसे कोड करें

इस पोस्ट में, मैं समझाऊंगा कि कैसे COCO डाटासेट से वस्तुओं का पता लगाने के लिए YOLOv3 के वेनिला संस्करण का उपयोग करें और अपने स्वयं के उपयोग के मामले के लिए अपने स्वयं के डेटासेट को कस्टम करने के लिए कैसे करें।

यहाँ का योलो डिटेक्शन कोड एरिक लिंडर्नोरन के जोसेफ रेडमन और अली फरहदी के पेपर के कार्यान्वयन पर आधारित है।

यहां श्रृंखला के लिए लिंक दिए गए हैं।

YOLO के बारे में सब - भाग 1 - थोड़ा सा इतिहास

सभी YOLO के बारे में - Part2 - पहला YOLO

सभी के बारे में YOLO - Part3 - बेहतर, तेज़ और मजबूत YOLOv2

YOLO के बारे में सभी - भाग 4 - YOLOv3, एक वृद्धिशील सुधार

YOLOs के बारे में सभी - भाग 5 - ऊपर और चल रहा है

कृपया मेरे gitrepo में प्रोजेक्ट फ़ोल्डर ढूंढें।

प्रोजेक्ट फ़ोल्डर में, आपको एक उप-फ़ोल्डर मिलेगा जिसे कॉन्फिग फाइल, क्लास के नाम और पर्यावरण चर, डेटासेट के साथ डेटा फ़ोल्डर और कुछ उपयोगी पायथन कार्यों के साथ फ़ोल्डर फ़ोल्डर मिलेगा।

सबसे पहले, YOLOv3 वेट फ़ाइल डाउनलोड करें और इसे निम्न कमांड चलाकर प्रोजेक्ट में कॉन्फ़िगर फ़ोल्डर में रखें। (मैंने रेपो में ऐसा करने के लिए एक .sh फ़ाइल जोड़ी है)

wget https://pjreddie.com/media/files/yolov3.weights

एक बार कॉन्फ़िगर फ़ोल्डर की सामग्री को डाउनलोड करने के बाद कुछ इस तरह दिखना चाहिए।

COCO ऑब्जेक्ट्स का पता लगाने के लिए YOLOv3 को कैसे ऊपर और कैसे चलाना है?

आइए COCO ऑब्जेक्ट्स का पता लगाने के लिए वेनिला YOLO के कार्यान्वयन को देखें।

  • आवश्यक मॉड्यूल आयात करें।
मॉडल से आयात * बर्तन आयात से * आयात ओएस, एसआईएस, समय, डेटाटाइम, torch.utils.data से यादृच्छिक आयात मशाल मशाल आयात डेटासेट से DataLoader, torch.autograd आयात से परिवर्तन Vartimport matplotlib.pyplot के रूप में plt आयात matplotlib.patches पीआईएल आयात छवि से पैच
  • पूर्व-प्रशिक्षित कॉन्फ़िगरेशन और भार, साथ ही COCO डेटासेट के वर्ग नाम, जिस पर Darknet मॉडल प्रशिक्षित किया गया था, लोड करें। img_size, conf_thres और num_thresold ऐसे पैरामीटर हैं जो उपयोग-केस के आधार पर ट्विक किए जा सकते हैं।
नोट: मॉडल को अनुमान लगाने के लिए eval मोड पर सेट करें।
config_path = 'config / yolov3.cfg' weights_path = 'config / yolov3.weights' class_path = 'config / coco.names' img_size = 416 confthres = 0.8 nms_thres = 0.4
# लोड मॉडल और वेट मॉडल = Darknet (config_path, img_size = img_size) model.load_weights (weights_path) model.cuda () मॉडल। yal () क्लासेस = utils .load_classes (class_path) Tensor = torch.cuda.FloatTensor
  • एक छवि दी गई बुनियादी पहचान करने के लिए एक फ़ंक्शन लिखें। कृपया कोड क्या करता है के लिए टिप्पणियों को देखें। अधिकतर यह छवि को प्रीप्रोसेस कर रहा है।
def detect_image (img): # स्केल और पैड इमेज रेश्यो = min (img_size / img.size [0], img_size / img.size [1]) imw = राउंड (img। साइज़ [0] * रेशो) imh = राउंड ( img.size [1] * अनुपात) img_transforms = transforms.Compose ([transforms.Resize ((imh, imw)), transforms.Pad ((int (imh-imw) / 2/2, 0), मैक्स ( int ((imw-imh) / 2), 0), अधिकतम (int (imh-imw) / 2), 0), अधिकतम (int (imw-imh) / 2), 0)), (128,128,128) ), transforms.ToTensor (),]) # छवि को Tensor image_tensor = img_transforms (img) .float () image_tensor = image_tensor.unsqueeze_ (0) input_img = Variable (image_tensor.type (Tensor)) में कनवर्ट करें। और torch.no_grad (): detections = model (input_img) detections = utils.non_max_suppression (detections, 80, conf_thres, nms_thres) रिटर्न के साथ डिटेक्शन प्राप्त करें [0]
  • अब इस फ़ंक्शन का उपयोग इनफ़ेक्शन प्राप्त करने के लिए कोड। यह किसी भी ऑब्जेक्ट के साथ काम करता है जो COCO डेटासेट में है। फिर से अधिकांश कोड छवि को प्रीप्रोसेस करने और बाउंडिंग बॉक्स की साजिश से संबंधित है।
# छवि लोड करें और डिटेल्स प्राप्त करें img_path = "images / blueangels.jpg" prev_time = time.time () img = Image.open (img_path) डिटेक्ट्स = पता_image (img inference_time = datetime.timedelta (सेकंड = time.time) () - () prev_time) प्रिंट ('Inference समय:% s'% (inference_time)) # बाउंडिंग-बॉक्स रंग cmap = plt.get_cmap ('tab20b') रंग = = [cmap (i) i में np.linspace के लिए प्राप्त करें (0, 1, 1) 20)] img = np.array (img) plt.figure () अंजीर, कुल्हाड़ी = plt.subplots (1, figsize = (12,9)) ax.imshow (img) pad_s = अधिकतम (img.shape [0] - img.shape [1], 0) * (img_size / max (img.shape)) pad_y = max (img.shape [1] - img.shape [0], 0) * (img_size / max (img.shape) )) unpad_h = img_size - pad_y unpad_w = img_size - pad_xif डिटेक्शन कोई नहीं है: unique_labels = detections [:, -1] .cpu ()। अद्वितीय () n_cls_preds = len (unique_labels) bbox_colors = random_sample/sample_sample = # ब्राउज डिटेक्शन और एक्स 1, y1, x2, y2, conf, cls_conf, cls_pred इन डिटेक्शन: box_h = ((y2 - y1) / unpad_h) / img.shape [0] box_w = (x2 - X1) के लिए बाउंडिंग बॉक्स ड्रा करें। / unpad_w) * i mg.shape [1] y1 = ((y1 - pad_y // 2) / unpad_h) * img.shape [0] X1 = ((X1 - pad_x // 2) / unpad_w) * img.shape [1] रंग = bbox_colors [int (np.where (unique_labels == int (cls_pred))] [0])] bbox = patches.Rectangle ((X1, y1), box_w, box_h, linewidth = 2, edgecolor = color, facecolor = 'none' ) ax.add_patch (bbox) plt.text (X1, y1, s = classes [int (cls_pred)], color = 'white', verticalalignment = 'top', bbox = {color ': color,' pad ': 0}) plt.axis ('ऑफ') # सेव इमेज plt.savefig (img_path.replace ("। Jpg", "-det.jpg"), bbox_inches = 'tight', pad_inches = 0.0) plt.show ()
  • उपरोक्त स्क्रिप्ट चित्रों पर चित्रण को संभालती है। अब आइए देखें कि इसे वीडियो के लिए कैसे काम करना है।
वीडियोपैथ = 'वीडियो / नमूना_वीडियो .mp4'
IPython.display से% pylab इनलाइन आयात cv2 आयात clear_outputcmap = plt.get_cmap ('tab20b') रंग = [cmap (i) [: 3] i में np .linspace (0, 1, 20)] # initialize vid = cv2 .VideoCapture (वीडिओपैथ) # सार्थक (सत्य): श्रेणी में ii के लिए (40): रिट, फ्रेम = vid.read () फ्रेम = cv2.cvtColor (फ्रेम, cv2.COLOR_B2RRGB) pilimg = Image.fromarray (फ्रेम) का पता लगाता है। Det_image (pilimg) img = np.array (pilimg) pad_x = max (img.shape [0] - img.shape [1], 0) * (img_size (अधिकतम (img.shape)) pad_y = max (img.shape) [१] - img.shape [०], ०) * (img_size / max (img.shape)) unpad_h = img_size - pad_y unpad_w = img_size (पैड_x यदि डिटेक्शन कोई नहीं है: unique_labels = detections [:, -1]। cpu ()। unique () n_cls_preds = len (unique_labels) X1, y1, x2, y2, conf, cls_conf, cls_pred in detections: box_ = = int ((y2 - y1) / unpad_h) * img.shape [0] के लिए। ) box_w = int ((((x2 - X1) / unpad_w) * img.shape [1]) y1 = int (((y1 - pad_y // 2) / unpad_h) * img .shape [0]) X1 = int ((X1 - pad_x // 2) / unpad_w) * img.shape [1]) रंग = रंग [int (cls_conf)। आइटम ())% len (रंग)] color = [i * 255 के लिए I in color] cls = classes [int (cls_pred)] cv2.rectangle (फ्रेम, (X1, y1), (X1 + बॉक्स .w, y1 + box_h) ), रंग, 4) cv2.rectangle (फ्रेम, (X1, y1-35), (X1 + len (cls) * 19 + 60, y1), रंग, -1) cv2.putText (फ्रेम, clad + "- "सेंट (cls_conf.item ()), (X1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 3) अंजीर (अंजीर = (12, 8)) शीर्षक (" वीडियो स्ट्रीम ") imshow (फ्रेम) शो () clear_output (प्रतीक्षा करें = सत्य)
नोट: उपरोक्त कोड का उपयोग लाइव स्ट्रीमिंग के साथ-साथ वीडियो पथ को आईपी कैमरा स्ट्रीम में बदलकर किया जा सकता है।

कस्टम ऑब्जेक्ट्स के लिए काम करने के लिए वेनिला YOLOv3 मॉडल को कैसे ठीक करें?

आइए अपने स्वयं के उपयोग के मामले के लिए कस्टम प्रशिक्षण YOLOv3 देखें। वे इसे प्राप्त करने के कई तरीके हैं। लेकिन निम्न चरण मुझे इंटरनेट पर मिलने वाले सबसे आसान तरीके बताते हैं।

आवश्यक शर्तें

डेटा

पहला कदम यह होगा कि आप अपना प्रशिक्षण डेटा बनाएं अर्थात छवियों को एक बाउंडिंग बॉक्स और क्लास लेबल के साथ टैग करें जिसके लिए आप चाहते हैं कि डिटेक्शन हो जाए।

इसे पूरा करने के लिए कई उपकरण हैं। मैंने पाया सबसे आसान तरीका है लेबलआईजीएम का उपयोग करना। यह एक चित्रमय छवि एनोटेशन उपकरण है। आप पाइप कमांड का उपयोग करके इंस्टॉल कर सकते हैं।

पाइप स्थापित करें

कैसे उपयोग करने के लिए एक अच्छा ट्यूटोरियल खोजने के लिए लिंक पर क्लिक करें।

इमेज सिंपल को लेबल करने का मतलब है बाउंडिंग बॉक्स कोऑर्डिनेट और क्लास को टैग करना। इसलिए प्रत्येक छवि के लिए उत्पन्न लेबल (.txt फ़ाइल) में एक एकल पंक्ति होगी। इसे कुछ योलो प्रारूप कहा जाता है।

नोट: कृपया लेबलआईएमजी उपकरण का उपयोग करके छवियों को टैग करते समय योलो प्रारूप का चयन करना सुनिश्चित करें।
# वर्ग एक्स की चौड़ाई की ऊंचाई 1 0.351466 0.427083 0.367168 0.570486

एक बार छवियां टैग हो जाने के बाद और लेबल (.txt फाइलें) उत्पन्न हो जाती हैं, तो डेटासेट को ट्रेन और सत्यापन के लिए विभाजित करने के लिए एक स्क्रिप्ट चलाएं। कृपया इसे प्राप्त करने के लिए केवल एक बार निम्न अजगर कोड चलाएँ। डेटाप्लोइटो रेपो में इस कोड वाली फाइल है।

आयात glob आयात os आयात np आयात के रूप में npy आयात syscurrent_dir = "./data/artifacts/images" विभाजित_pct = 10 # 10% सत्यापन सेट file_train = खुला ("डेटा / विरूपण साक्ष्य / train.txt", "w") file_val = खुला () glob.iglob (os.path.join (current_dir, "* .JPG")): "शीर्षक में पूर्णांक के लिए" data / कलाकृतियाँ / val.txt "," w ") काउंटर = 1 इंडेक्स_टेस्ट = राउंड (100 / स्प्लिट_पैक्ट)। ext = os.path.splitext (os.path.basename (fullpath)) यदि काउंटर == index_test: counter = 1 file_val.write (current_dir + "/" + title + ".JPG '+" \ n ") अन्य:। file_train.write (current_dir + "/" + title + '.JPG' + "\ n") काउंटर = काउंटर + 1 file_train.close () file_val.close ()

यह 2 फाइलें बनाएगा, train.txt और val.txt जिसमें सभी छवियों के पूर्ण पथ होंगे, जिसमें ट्रेन में 90% और घाटी में 10% होंगे।

एक बार हो जाने के बाद, निम्नलिखित फ़ोल्डर संरचना में डेटासेट प्राप्त करना सुनिश्चित करें।

मुख्य फ़ोल्डर --- डेटा --- डेटासेट नाम --- छवियां --- img1.jpg --- img2.jpg .......... --- लेबल --- img1.txt --- img2.txt .......... --- train.txt --- val.txt

कॉन्फ़िग

अब config / folder में config फाइल के लिए। सबसे पहले, coco.data कुछ इस तरह दिखेगा:

कक्षाएं = 80 # कक्षाओं की संख्या यहाँ ट्रेन जाती है = डेटा / अल्फा / ट्रेन.टेक्स्ट # ट्रेन का मार्ग। /coco.names # क्लास लेबल बैकअप = बैकअप / # के साथ नाम फ़ाइल को संपादित करें जैसा कि यह है

अपने कस्टम डेटासेट के अनुसार इन मूल्यों को संपादित करें। अपने उपयोग के मामले में पाई जाने वाली कक्षाओं की संख्या समाहित करने के लिए "कक्षाएं" संपादित करें। ट्रेन और मान्य क्रमशः ट्रेन। Txt और val.txt के लिए रास्ता रखती है। वर्ग लेबल के साथ "coco.names" फ़ाइल संपादित करें। यह सूची के अनुसार माना जाता है, प्रति पंक्ति, कक्षाओं के नाम (एनोटेशन फ़ाइल के लिए, पहले वाला 0 से संबंधित है, 1 के बगल में है, आदि)

class1 class2 ...
नोट: बैकअप पैरामीटर का उपयोग नहीं किया गया है लेकिन लगता है कि आवश्यक है।

अब yolov3.cfg फ़ाइल के लिए। इसमें YOLOv3 एल्गोरिथम का वास्तुशिल्प विवरण शामिल है।

पहले [नेट] अनुभाग में, अपने GPU मेमोरी को फिट करने के लिए बैच मान और उपखंड समायोजित करें। बैच आकार जितना बड़ा होगा, प्रशिक्षण उतना ही बेहतर और तेज होगा, लेकिन यह अधिक मेमोरी लेगा। यहाँ भी आप Learning_rate को समायोजित कर सकते हैं।

11 जीबी मेमोरी के साथ एनवीडिया जीपीयू के लिए, 16 और 1 उपखंड का एक बैच अच्छा है।

बदलने के लिए दो अन्य महत्वपूर्ण चीजें हैं, जो कि कक्षाएं और अंतिम लेयरफिल्टर मान हैं। और आपको इसे फ़ाइल में तीन अलग-अलग जगहों पर करना होगा।

यदि आप फ़ाइल खोजते हैं, तो आपको 3 [yolo] अनुभाग मिलेंगे। उस अनुभाग के अंदर, अपने मॉडल में कक्षाओं की संख्या निर्धारित करें।

आपको [योलो] के ठीक ऊपर [कन्वेन्शनल] सेक्शन में फिल्टर वैल्यू को भी बदलना होगा।

फिल्टर = (कक्षाएं + 5) x 3

उपरोक्त सभी सेट के साथ, अब आप मॉडल को प्रशिक्षित करने के लिए तैयार होंगे।

कोड

प्रशिक्षण लूप का कार्यान्वयन

  • पुस्तकालयों का आयात करना
__future__ इंपोर्ट डिवीजन से
मॉडल से आयात * utils.utils आयात से * utils.datasets आयात * से utils.parse_config मूल्य *
आयात os आयात sys आयात समय आयात डेटाइम आयात argparse आयात करता है
torch.utils.data से आयात टॉर्च मशाल संशोधन से DataLoader आयात मशाल से आयात डेटासेट मशाल से आयात रूपांतरों। आयात आयात परिवर्तनीय आयात torch.optim रूप में आयात
  • पैमाना सेटिंग
युग = 20 छवि_फॉल्डर = "डेटा / डेटासेट / इमेजेज" बैच_साइज = 16 मॉडल_कोन्फिग_पैथ = "कॉन्फिगरेशन / योलोव 3.cfg" data_config_path = "कॉन्फिगर / कोकोडाटा" वेट्स_पैथ = "कॉन्फिगर / yolov3.weights" class_path = "कॉन्फिगरेशन"। "conf_thres = 0.8 nms_thres = 0.4 n_cpu = 0 img_size = 416 चेकपॉइंट_इंटरवाल = 1 चेकपॉइंट_डिअर = 'चौकियों' का उपयोग_कुडा = सच
  • यदि उपलब्ध हो तो CUDA का उपयोग करें
cuda = torch.cuda.is_available () और use_cuda
  • मेमोरी में डेटा कॉन्फिगर और पैरामीटर प्राप्त करें
# लोड कक्षाएं os.makedirs ("चौकियों", अस्तित्व_ोक = सत्य) कक्षाएं = load_classes (class_path)
# डेटा कॉन्फ़िगरेशन डेटा प्राप्त करें data_config = parse_data_config (data_config_path) train_path = data_config ["ट्रेन"]
# हाइपर पैरामीटर्स प्राप्त करें हाइपरपरम = parse_model_config (model_config_path) [0] Learning_rate = float (हाइपरपैराम ["Learning_rate"]) गति = float (हाइपरपैराम ["गति"]) decay = फ़्लेपर (हाइपरपैराम ["decay"]) burn_in int hyperparams [ "burn_in"])
  • मॉडल शुरू करें और प्रशिक्षित करने के लिए सेट करें।
# मॉडल मॉडल शुरू करें = Darknet (model_config_path) model.load_weights (weights_path)
अगर cuda: model = model.cuda () model.train ()
  • डेटा लोडर प्राप्त करें, और ऑप्टिमाइज़र सेट करें
# डटलोडर डटलोएडर = मशाल ।utils.data.DataLoader (ListDataset (train_path), बैच_साइज = बैच_साइज, फेरबदल = गलत, संख्यात्मक कार्य = n_cpu) प्राप्त करें
Tensor = torch.cuda.FloatTensor अगर cuda और मशाल ।loatTensor
# ऑप्टिमाइज़र ऑप्टिमाइज़र प्राप्त करें = torch.optim.Adam (फ़िल्टर (लैम्ब्डा p: p.requires_grad, model.parameters ()))
  • अब मुख्य प्रशिक्षण पाश के लिए।
रेंज में युगों (युगों) के लिए: बैच_आई, (_, इमग्स, टार्गेट) के लिए इन्युमरेट (डटलोएडर) में: imgs = Variable (imgs.type (Tensor)) टारगेट = Variable (लक्ष्य.टाइप) (Tensor), आवश्यकता_ग्रेड = गलत)
optimizer.zero_grad ()
loss = मॉडल (imgs, लक्ष्य)
loss.backward () optimizer.step ()
प्रिंट ("[एपोक% डी /% डी, बैच% डी /% डी] [हानियाँ: x% f, y% f, w% f, h% f, conf% f, cls% f, कुल% f, रिकॉल :% .5f, परिशुद्धता:% .5f] "% (युग, युग, बैच_ई, लेन (dataloader), model.losses [" x "], model.losses [" y], model.losses ["w" ], model.losses ["h"], model.losses ["conf"], model.losses ["cls"], loss.item (), model.losses ["याद"], मॉडल .losses ["परिशुद्धता" "],))
model.seen + = imgs.size (0)
यदि युग% checkpoint_interval == 0: प्रिंट ("सेविंग") model.save_weights ("% s /% d.weights"% (checkpoint_dir, "नवीनतम")

उपरोक्त लूप ट्रेनों को नाम के रूप में प्रत्येक युग के लिए मॉडल के फ़ोल्डर में एक वेट फ़ाइल बचाता है। यह प्रशिक्षण की प्रगति की निगरानी के लिए नुकसान का एक गुच्छा भी छापता है।

कार्यान्वयन का कार्यान्वयन

  • पुस्तकालयों का आयात करना
मॉडल आयात से * बर्तन आयात से * आयात cv2 आयात os, sys, समय, डेटाटाइम, torch.utils.data से यादृच्छिक आयात मशाल आयात डेटा पत्रक से DataLoader, torch.autadadad आयात से परिवर्तनीय आयात चर
आयात matplotlib.pyplot plt आयात matplotlib.patch के रूप में PIL से पैच आयात के रूप में छवि आयात imutils से आयात करता है ।video आयात WebcamVideoStream
  • पैरामीटर सेट करें। पता लगाने के लिए नए मॉडल का उपयोग करने के लिए, कॉन्फ़िगर फ़ोल्डर में yolov3.weights फ़ाइल के साथ मॉडल फ़ोल्डर में उत्पन्न नवीनतम वेट फ़ाइल को बदलें। सुनिश्चित करें कि वज़न पथ अनुमान कोड बिंदुओं को नवीनतम वज़न पथ पर ले जाए।
num_classes = 1 config_path = 'config / yolov3.cfg' weights_path = 'checkpoint_19.weights' class_path = 'config / coco.names' img_sath = 416 conf_thres = 0.95 nms_thres = 0.95
  • लोड मॉडल और inferences के लिए eval करने के लिए सेट करें
# लोड मॉडल और वेट मॉडल = Darknet (config_path, img_size = img_size) model.load_weights (वेट्स_पैथ) # model.cuda () मॉडल.वैल () क्लासेस = लोड -क्लासेस (class_path) Tensor = torch.FloatTensor
  • कक्षाओं को लोड करने और छवि का पता लगाने के लिए कार्यों को परिभाषित करें।
def load_classes (पाथ): "" "पाथ क्लास लेबल पर 'पाथ'" "" fp = ओपन (पाथ, "r") नाम = fp.read ()। स्प्लिट ("\ n") [:] वापसी नाम
def detect_image (img): # स्केल और पैड इमेज रेश्यो = min (img_size / img.size [0], img_size / img.size [1]) imw = राउंड (img। साइज़ [0] * रेशो) imh = राउंड ( img.size [1] * अनुपात) img_transforms = transforms.Compose ([transforms.Resize ((imh, imw)), transforms.Pad ((int (imh-imw) / 2/2, 0), मैक्स ( int ((imw-imh) / 2), 0), अधिकतम (int (imh-imw) / 2), 0), अधिकतम (int (imw-imh) / 2), 0)), (128,128,128) ), transforms.ToTensor (),]) # छवि को Tensor image_tensor = img_transforms (img) .float () image_tensor = image_tensor.unsqueeze_ (0) input_img = Variable (image_tensor.type (Tensor)) में कनवर्ट करें। और torch.no_grad (): detections = model (input_img) डिटेक्ट्स = utils.non_max_suppression (डिटेक्शन, num_classes, conf_thres, nms_res) रिटर्न डिटेक्शन के साथ डिटेक्ट मिलते हैं [0]
  • अब इंट्रेंस लूप के लिए।
वीडियोपैथ = 'वीडियो / नमूना_वीडियो .mp4'
IPython.display से% pylab इनलाइन आयात cv2 आयात clear_outputcmap = plt.get_cmap ('tab20b') रंग = [cmap (i) [: 3] i में np .linspace (0, 1, 20)] # initialize vid = cv2 .VideoCapture (वीडिओपैथ) # सार्थक (सत्य): श्रेणी में ii के लिए (40): रिट, फ्रेम = vid.read () फ्रेम = cv2.cvtColor (फ्रेम, cv2.COLOR_B2RRGB) pilimg = Image.fromarray (फ्रेम) का पता लगाता है। Det_image (pilimg) img = np.array (pilimg) pad_x = max (img.shape [0] - img.shape [1], 0) * (img_size (अधिकतम (img.shape)) pad_y = max (img.shape) [१] - img.shape [०], ०) * (img_size / max (img.shape)) unpad_h = img_size - pad_y unpad_w = img_size (पैड_x यदि डिटेक्शन कोई नहीं है: unique_labels = detections [:, -1]। cpu ()। unique () n_cls_preds = len (unique_labels) X1, y1, x2, y2, conf, cls_conf, cls_pred in detections: box_ = = int ((y2 - y1) / unpad_h) * img.shape [0] के लिए। ) box_w = int ((((x2 - X1) / unpad_w) * img.shape [1]) y1 = int (((y1 - pad_y // 2) / unpad_h) * img .shape [0]) X1 = int ((X1 - pad_x // 2) / unpad_w) * img.shape [1]) रंग = रंग [int (cls_conf)। आइटम ())% len (रंग)] color = [i * 255 के लिए I in color] cls = classes [int (cls_pred)] cv2.rectangle (फ्रेम, (X1, y1), (X1 + बॉक्स-w, y1 + box_h) ), रंग, 4) cv2.rectangle (फ्रेम, (X1, y1-35), (X1 + len (cls) * 19 + 60, y1), रंग, -1) cv2.putText (फ्रेम, clad + "- "सेंट (cls_conf.item ()), (X1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 3) अंजीर (अंजीर = (12, 8)) शीर्षक (" वीडियो स्ट्रीम ") imshow (फ्रेम) शो () clear_output (प्रतीक्षा करें = सत्य)

कृपया मेरे गिट-रेपो में प्रशिक्षण और निष्कासन दोनों के लिए ज्यूपिटर नोटबुक देखें।

मुझे उम्मीद है कि इस श्रृंखला ने आपको हर चीज की एक स्पष्ट तस्वीर दी है जो कि योलो के बारे में जानना है और आपको अपने स्वयं के कार्यान्वयन में शुरू करना है।

यदि आप किसी विशिष्ट विषय पर एक ब्लॉग देखना चाहते हैं, तो कृपया प्रतिक्रिया अनुभाग में इसका उल्लेख करने के लिए स्वतंत्र महसूस करें। मैं अपनी पूरी कोशिश करूँगा :)

संसाधन:

YOLO: https://arxiv.org/pdf/1506.02640.pdf

YOLOv2 और YOLO9000: https://arxiv.org/pdf/1612.08242.pdf

YOLOv3: https: //arxiv.org/pdf/1804.02767.pdf

मेरे बारे में

मैं वेवलबाई में एक वरिष्ठ एआई विशेषज्ञ हूं। उपयोगकर्ता अनुभव को कम करने और लागत को कम करने के लिए हम आपको वेवलैब्स आर्टिफिशियल इंटेलिजेंस (एआई) का लाभ उठाने में मदद करते हैं। हम विशिष्ट रूप से आपके पूर्ण बाज़ार की क्षमता तक पहुँचने के लिए AI का उपयोग करके आपके उत्पादों को बढ़ाते हैं। हम आपके अनुप्रयोगों में अत्याधुनिक अनुसंधान लाने की कोशिश करते हैं।

Wavelabs.ai में अधिक जानने के लिए स्वतंत्र महसूस करें।

खैर, यह सब इस पोस्ट में है। पढ़ने के लिए धन्यवाद :)

जिज्ञासु बने!

आप लिंक्डइन पर मेरे पास पहुंच सकते हैं।