🤵🏻 🏕️ 🤷 केरस और टेन्सरफ्लो ऑब्जेक्ट डिटेक्शन एपीआई प्रौद्योगिकियों का उपयोग करके तंत्रिका नेटवर्क का उपयोग करके अलमारियों पर माल की मान्यता 🧘🏾 ↪️ 📖

लेख में हम सामानों के साथ अलमारियों की तस्वीरों से एक पुनः संग्रह को बहाल करने के व्यावहारिक व्यवसाय कार्य को हल करने के लिए दृढ़ तंत्रिका नेटवर्क के उपयोग के बारे में बात करेंगे। Tensorflow Object Detection API का उपयोग करके, हम खोज / स्थानीयकरण मॉडल को प्रशिक्षित करेंगे। हम एक फ्लोटिंग विंडो और एक गैर-अधिकतम दमन एल्गोरिथ्म का उपयोग करके उच्च-रिज़ॉल्यूशन वाली तस्वीरों में छोटे उत्पादों के लिए खोज की गुणवत्ता में सुधार करेंगे। Keras में, हम ब्रांड द्वारा माल का एक वर्गीकरण लागू कर रहे हैं। समानांतर में, हम 4 साल पहले के निर्णयों के दृष्टिकोण और परिणामों की तुलना करेंगे। लेख में प्रयुक्त सभी डेटा डाउनलोड के लिए उपलब्ध है, और पूरी तरह से काम करने वाला कोड GitHub पर है और इसे एक ट्यूटोरियल के रूप में डिज़ाइन किया गया है।

परिचय

एक प्लानोग्राम क्या है? स्टोर के कंक्रीट ट्रेडिंग उपकरण पर सामानों के प्रदर्शन का लेआउट आरेख।

एक पुनर्जन्म क्या है? यहां और अब स्टोर में मौजूद एक विशिष्ट ट्रेडिंग उपकरण पर सामान का लेआउट।

प्लेनोग्राम - जैसा कि यह होना चाहिए, फिर से शुरू - हमारे पास क्या है।

अब तक, कई दुकानों में, रैक, अलमारियों, काउंटरों, ठंडे बस्ते पर बाकी सामान का प्रबंधन करना विशेष रूप से मैनुअल श्रम है। हजारों कर्मचारी मैन्युअल रूप से उत्पादों की उपलब्धता की जांच करते हैं, शेष राशि की गणना करते हैं, आवश्यकताओं के साथ स्थान की जांच करते हैं। यह महंगा है, और गलतियाँ बहुत संभव हैं। गलत प्रदर्शन या माल की कमी से बिक्री कम होती है।

इसके अलावा, कई निर्माता अपना माल प्रदर्शित करने के लिए खुदरा विक्रेताओं के साथ समझौते करते हैं। और चूंकि बहुत सारे निर्माता हैं, उनके बीच शेल्फ पर सबसे अच्छी जगह के लिए संघर्ष शुरू होता है। हर कोई चाहता है कि उसका उत्पाद खरीदार की आंखों के सामने केंद्र में झूठ बोलता है और सबसे बड़े संभावित क्षेत्र पर कब्जा करता है। लगातार ऑडिट की जरूरत है।

हजारों व्यापारी स्टोर से स्टोर तक यह सुनिश्चित करने के लिए चलते हैं कि उनकी कंपनी के उत्पाद शेल्फ पर हैं और अनुबंध के अनुसार प्रस्तुत किए गए हैं। कभी-कभी वे आलसी होते हैं: किसी रिटेल आउटलेट पर जाने के बजाय अपने घर को छोड़ने के बिना रिपोर्ट संकलित करना अधिक सुखद होता है। लेखा परीक्षकों के स्थायी ऑडिट की आवश्यकता है।

स्वाभाविक रूप से, स्वचालन और इस प्रक्रिया के सरलीकरण का कार्य लंबे समय से हल किया गया है। सबसे कठिन भागों में से एक छवि प्रसंस्करण था: उत्पादों को खोजना और पहचानना। और केवल अपेक्षाकृत हाल ही में इस कार्य को इतना सरल बना दिया गया है कि किसी विशेष मामले के लिए एक सरलीकृत रूप में, इसका पूरा समाधान एक लेख में वर्णित किया जा सकता है। यही हम करेंगे।

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

डेटा और दृष्टिकोण

किसी भी डेटा संचालित दृष्टिकोण के साथ, तंत्रिका नेटवर्क समाधान के लिए डेटा की आवश्यकता होती है। आप उन्हें मैन्युअल रूप से इकट्ठा भी कर सकते हैं: कई सौ काउंटरों को पकड़ने और उन्हें उपयोग करने के लिए चिह्नित करें, उदाहरण के लिए, लेबलआईएमजीएम । उदाहरण के लिए, Yandex.Tolok पर आप मार्कअप ऑर्डर कर सकते हैं।

हम एक वास्तविक परियोजना के विवरण का खुलासा नहीं कर सकते, इसलिए हम खुले डेटा पर प्रौद्योगिकी की व्याख्या करेंगे। खरीदारी करने और फ़ोटो लेने के लिए यह बहुत आलसी था (और हम वहां हमें समझ नहीं पाएंगे), और इंटरनेट पर पाए गए फ़ोटो के मार्कअप को करने की इच्छा सौवीं वर्गीकृत वस्तु के बाद समाप्त हो गई। सौभाग्य से, काफी संयोग से मैं किराने डेटासैट संग्रह में आया था।

2014 में, Idea Teknoloji, इस्तांबुल, तुर्की के कर्मचारियों ने 4 कैमरों पर बनाए गए 40 स्टोर से 354 तस्वीरें अपलोड कीं। इन तस्वीरों में से प्रत्येक पर, उन्होंने कई हजार वस्तुओं की कुल आयतों पर प्रकाश डाला, जिनमें से कुछ को 10 श्रेणियों में वर्गीकृत किया गया था।

ये सिगरेट पैक की तस्वीरें हैं। हम धूम्रपान को बढ़ावा या बढ़ावा नहीं देते हैं। बस कुछ और तटस्थ नहीं था। हम वादा करते हैं कि लेख में हर जगह, जहां स्थिति की अनुमति देता है, हम बिल्लियों की तस्वीरों का उपयोग करेंगे।

अलमारियों की टैग की गई तस्वीरों के अलावा, उन्होंने स्थानीयकरण और वर्गीकरण की समस्या के समाधान के साथ किराने की अलमारियों पर एक लेख रिटेल प्रोडक्ट रिकॉग्निशन की ओर लिखा। यह एक प्रकार का संदर्भ बिंदु निर्धारित करता है: नए दृष्टिकोणों का उपयोग करते हुए हमारा समाधान सरल और अधिक सटीक होना चाहिए, अन्यथा यह दिलचस्प नहीं है। उनके दृष्टिकोण में एल्गोरिदम का एक संयोजन है:

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

हम चरणों में समस्या का समाधान करेंगे:

डेटा की तैयारी। हम अभिलेखागार को पंप करते हैं और इसे काम के लिए सुविधाजनक दृष्टिकोण में बदलते हैं।
ब्रांड वर्गीकरण। हम एक तंत्रिका नेटवर्क का उपयोग करके वर्गीकरण समस्या को हल करते हैं।
फोटो में उत्पादों की खोज करें। हम माल की खोज के लिए तंत्रिका नेटवर्क को प्रशिक्षित करते हैं।
कार्यान्वयन खोजें। हम गैर-अधिकतम को दबाने के लिए एक अस्थायी खिड़की और एक एल्गोरिथ्म का उपयोग करके पता लगाने की गुणवत्ता में सुधार करेंगे।
निष्कर्ष। संक्षेप में बताएं कि वास्तविक जीवन इस उदाहरण की तुलना में अधिक जटिल क्यों है।

प्रौद्योगिकी के

मुख्य तकनीकें जिनका हम उपयोग करेंगे: टेन्सरफ्लो, केरस, टेन्सरफ्लो ऑब्जेक्ट डिटेक्शन एपीआई, ओपनसीवी। यद्यपि विंडोज और मैक ओएस दोनों ही टेंसरफ्लो के साथ काम करने के लिए उपयुक्त हैं, फिर भी हम उबंटू का उपयोग करने की सलाह देते हैं। यहां तक कि अगर आपने पहले कभी इस ऑपरेटिंग सिस्टम के साथ काम नहीं किया है, तो इसका उपयोग करने से आपका एक टन बच जाएगा। GPU के साथ काम करने के लिए Tensorflow स्थापित करना एक ऐसा विषय है जो एक अलग लेख के योग्य है। सौभाग्य से, ऐसे लेख पहले से मौजूद हैं। उदाहरण के लिए, Ubuntu 16.04 पर Nvidia GPU के साथ TensorFlow इंस्टॉल करना । इसमें से कुछ निर्देश पुराने हो सकते हैं।

चरण 1. डेटा तैयार करना ( जीथब लिंक )

यह कदम, एक नियम के रूप में, अनुकरण से बहुत अधिक समय लेता है। सौभाग्य से, हम तैयार किए गए डेटा का उपयोग करते हैं, जिसे हम अपनी आवश्यकता के रूप में परिवर्तित करते हैं।

आप इस तरह से डाउनलोड और अनज़िप कर सकते हैं:

wget https://github.com/gulvarol/grocerydataset/releases/download/1.0/GroceryDataset_part1.tar.gz wget https://github.com/gulvarol/grocerydataset/releases/download/1.0/GroceryDataset_part2.tar.gz tar -xvzf GroceryDataset_part1.tar.gz tar -xvzf GroceryDataset_part2.tar.gz

हमें निम्नलिखित फ़ोल्डर संरचना मिलती है:

हम ShelfImages और ProductImagesFromShelves निर्देशिका से जानकारी का उपयोग करेंगे।
शेल्फ़मैसेज में स्वयं अलमारियों के चित्र हैं। नाम में, चित्र के पहचानकर्ता के साथ रैक की पहचानकर्ता एन्कोडेड है। एक रैक के कई चित्र हो सकते हैं। उदाहरण के लिए, इसकी संपूर्णता में एक तस्वीर और चौराहों के साथ भागों में 5 तस्वीरें।

फ़ाइल C1_P01_N1_S2_2.JPG (रैक C1_P01, स्नैपशॉट N1_S2_2):

हम सभी फ़ाइलों के माध्यम से जाते हैं और पंडों के डेटा फ्रेम फोटो_डैप में जानकारी एकत्र करते हैं:

ProductImagesFromShelves में 11 उपनिर्देशिकाओं में अलमारियों से माल की कट-आउट तस्वीरें हैं: 0 - वर्गीकृत नहीं, 1 - मार्लबोरो, 2 - केंट, आदि। उन्हें विज्ञापित नहीं करने के लिए, हम बिना नाम निर्दिष्ट किए केवल श्रेणी संख्या का उपयोग करेंगे। नामों की फाइलों में रैक, उस पर पैक की स्थिति और आकार की जानकारी होती है।

फ़ाइल C1_P01_N1_S3_1.JPG_1276_1828_276_448.png निर्देशिका 1 (श्रेणी 1, रैक C1_P01, छवि N1_S3_1, ऊपरी बाएं कोने के निर्देशांक (1276, 1828), चौड़ाई 276, ऊंचाई 448) से:

हमें स्वयं अलग-अलग पैक्स की तस्वीरों की आवश्यकता नहीं है (हम उन्हें अलमारियों के चित्रों से बाहर काट देंगे), और हम पांडा डेटा फ्रेम उत्पादों_ पीडीएफ में उनकी श्रेणी और स्थिति के बारे में जानकारी एकत्र करते हैं:

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

जैसा कि हमने पहले ही नोट किया है, एक रैक की कई तस्वीरें हो सकती हैं। तदनुसार, एक ही पैक कई चित्रों में गिर सकता है। इसलिए, हम आपको चित्रों के द्वारा नहीं, और इससे भी अधिक पैक से नहीं, बल्कि रैक से टूटने की सलाह देते हैं। यह आवश्यक है ताकि ऐसा न हो कि विभिन्न कोणों से ली गई एक ही वस्तु ट्रेन और सत्यापन दोनों में समाप्त हो जाए।

हम एक 70/30 विभाजन बनाते हैं (30% रैक सत्यापन के लिए जाते हैं, बाकी प्रशिक्षण के लिए):

 # get distinct shelves shelves = list(set(photos_df['shelf_id'].values)) # use train_test_split from sklearn shelves_train, shelves_validation, _, _ = train_test_split(   shelves, shelves, test_size=0.3, random_state=6) # mark all records in data frames with is_train flag def is_train(shelf_id): return shelf_id in shelves_train photos_df['is_train'] = photos_df.shelf_id.apply(is_train) products_df['is_train'] = products_df.shelf_id.apply(is_train)

हम यह सुनिश्चित करेंगे कि जब हम विभाजित होते हैं, तो प्रशिक्षण और सत्यापन दोनों के लिए प्रत्येक वर्ग के पर्याप्त प्रतिनिधि होते हैं:

नीला रंग सत्यापन के लिए श्रेणी में उत्पादों की संख्या और प्रशिक्षण के लिए नारंगी दिखाता है। सत्यापन के लिए श्रेणी 3 के साथ स्थिति बहुत अच्छी नहीं है, लेकिन सिद्धांत रूप में इसके कुछ प्रतिनिधि हैं।

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

उसी समय, मार्कअप बनाया जाता है जैसे कि फोटो सही ढंग से उन्मुख थे। जल्दी ठीक होने के बाद, चीजें बहुत अधिक मजेदार हो गईं।

हम निम्नलिखित चरणों में उपयोग के लिए अपने डेटा को pkl फाइलों में सहेजेंगे। कुल, हमारे पास है:

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

सत्यापन के लिए, हम अपने डेटा के अनुसार एक रैक प्रदर्शित करते हैं:

 # function to display shelf photo with rectangled products def draw_shelf_photo(file):   file_products_df = products_df[products_df.file == file]   coordinates = file_products_df[['xmin', 'ymin', 'xmax', 'ymax']].values   im = cv2.imread(f'{shelf_images}{file}')   im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)      for xmin, ymin, xmax, ymax in coordinates:       cv2.rectangle(im, (xmin, ymin), (xmax, ymax), (0, 255, 0), 5)   plt.imshow(im) # draw one photo to check our data fig = plt.gcf() fig.set_size_inches(18.5, 10.5) draw_shelf_photo('C3_P07_N1_S6_1.JPG')

चरण 2. ब्रांड द्वारा वर्गीकरण ( जीथब पर लिंक )

कंप्यूटर विज़न के क्षेत्र में छवियों का वर्गीकरण मुख्य कार्य है। समस्या "सिमेंटिक गैप" है: फोटोग्राफी केवल संख्याओं का एक बड़ा मैट्रिक्स है [0, 255]। उदाहरण के लिए, 800x600x3 (3 RGB चैनल)।

यह कार्य कठिन क्यों है:

जैसा कि हमने पहले ही कहा है, हम जिन डेटा का उपयोग करते हैं, उनके लेखक ने 10 ब्रांडों की पहचान की है। यह एक बहुत ही सरल कार्य है, क्योंकि अलमारियों पर सिगरेट के बहुत अधिक ब्रांड हैं। लेकिन जो कुछ इन 10 श्रेणियों में नहीं आया, उसे 0 में भेजा गया - वर्गीकृत नहीं:

"

उनका लेख 92% की कुल सटीकता के साथ इस तरह के एक वर्गीकरण एल्गोरिथ्म प्रदान करता है:

हम क्या करेंगे:

हम प्रशिक्षण के लिए डेटा तैयार करेंगे,
हम ResNet v1 वास्तुकला के साथ एक दृढ़ तंत्रिका नेटवर्क को प्रशिक्षित करते हैं,
सत्यापन के लिए फ़ोटो देखें।

यह "स्वैच्छिक" लगता है, लेकिन हमने अभी केरस के उदाहरण का उपयोग किया है " ट्रेन को CIFAR10 डेटासेट पर एक ResNet " से इसे लेने से ResNet v1 बनाने का कार्य होता है।

प्रशिक्षण प्रक्रिया शुरू करने के लिए, आपको दो सरणियाँ तैयार करने की आवश्यकता है: x - एक आयाम के साथ पैक की तस्वीरें (पैक की संख्या, ऊंचाई, चौड़ाई, 3) और y - एक आयाम (पैक की संख्या, 10) के साथ उनकी श्रेणियां। Array y में तथाकथित 1-गर्म वैक्टर होते हैं। यदि प्रशिक्षण के लिए एक पैक की श्रेणी में 2 नंबर (0 से 9 तक) है, तो यह वेक्टर [0, 0, 1, 0, 0, 0, 0, 0, 0] से मेल खाती है।

एक महत्वपूर्ण सवाल यह है कि चौड़ाई और ऊंचाई के साथ क्या करना है, क्योंकि सभी तस्वीरें अलग-अलग दूरी से अलग-अलग प्रस्तावों के साथ ली गई थीं। हमें कुछ निश्चित आकार चुनने की जरूरत है, जिससे हम अपनी सभी तस्वीरें पैक में ला सकें। यह निश्चित आकार एक मेटा-पैरामीटर है जो यह निर्धारित करता है कि हमारा तंत्रिका नेटवर्क कैसे काम करेगा और काम करेगा।

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

 # resize pack to fixed size SHAPE_WIDTH x SHAPE_HEIGHT def resize_pack(pack):   fx_ratio = SHAPE_WIDTH / pack.shape[1]   fy_ratio = SHAPE_HEIGHT / pack.shape[0]      pack = cv2.resize(pack, (0, 0), fx=fx_ratio, fy=fy_ratio)   return pack[0:SHAPE_HEIGHT, 0:SHAPE_WIDTH]

सत्यापन के लिए स्केल और एक पैक प्रदर्शित करें। ब्रांड का नाम किसी व्यक्ति द्वारा पढ़ना मुश्किल है, आइए देखें कि वर्गीकरण के कार्य के साथ तंत्रिका नेटवर्क कैसे सामना करेंगे:

पिछले चरण में प्राप्त झंडे के अनुसार तैयारी करने के बाद, हम x और y सरणियों को x_train / x_validation और y_train / y_validation में तोड़ते हैं, हमें मिलता है:

 x_train shape: (1969, 120, 80, 3) y_train shape: (1969, 10) 1969 train samples 775 validation samples

डेटा तैयार किया जाता है, हम केरस उदाहरण से ResNet v1 वास्तुकला के तंत्रिका नेटवर्क निर्माता के कार्य की नकल करते हैं:

 def resnet_v1(input_shape, depth, num_classes=10):   …

हम एक मॉडल का निर्माण करते हैं:

 model = resnet_v1(input_shape=x_train.shape[1:], depth=depth, num_classes=num_classes) model.compile(loss='categorical_crossentropy',             optimizer=Adam(lr=lr_schedule(0)), metrics=['accuracy'])

हमारे पास काफी सीमित डेटा सेट है। इसलिए, प्रशिक्षण के दौरान हर बार एक ही फोटो को देखने से मॉडल को रोकने के लिए, हम वृद्धि का उपयोग करते हैं: तस्वीर को यादृच्छिक रूप से स्थानांतरित करें और इसे थोड़ा घुमाएं। Keras इसके लिए विकल्पों का यह सेट प्रदान करता है:

 # This will do preprocessing and realtime data augmentation: datagen = ImageDataGenerator(   featurewise_center=False,  # set input mean to 0 over the dataset   samplewise_center=False,  # set each sample mean to 0   featurewise_std_normalization=False,  # divide inputs by std of the dataset   samplewise_std_normalization=False,  # divide each input by its std   zca_whitening=False,  # apply ZCA whitening   rotation_range=5,  # randomly rotate images in the range (degrees, 0 to 180)   width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)   height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)   horizontal_flip=False,  # randomly flip images   vertical_flip=False)  # randomly flip images datagen.fit(x_train)

हम प्रशिक्षण प्रक्रिया शुरू करते हैं।

 # let's run training process, 20 epochs is enough batch_size = 50 epochs = 15 model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),                   validation_data=(x_validation, y_validation),                   epochs=epochs, verbose=1, workers=4,                   callbacks=[LearningRateScheduler(lr_schedule)])

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

ब्याज के लिए, भ्रम की स्थिति की तुलना करें:

लगभग सभी श्रेणियां हमारे तंत्रिका नेटवर्क को बेहतर ढंग से परिभाषित करती हैं, श्रेणी 4 और 7 को छोड़कर। प्रत्येक भ्रम मैट्रिक्स सेल के प्रतिभाशाली प्रतिनिधियों को देखना भी उपयोगी है:

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

हमारी स्थितियों में मान्यता की गुणवत्ता में सुधार करने का एक स्पष्ट अवसर अधिक फ़ोटो जोड़ना है।

तो, क्लासिफायरियर तैयार है। डिटेक्टर पर जाएं।

चरण 3. तस्वीर में उत्पादों के लिए खोज ( जीथब पर लिंक )

कंप्यूटर दृष्टि के क्षेत्र में निम्नलिखित महत्वपूर्ण कार्य सिमेंटिक विभाजन, स्थानीयकरण, वस्तु खोज और उदाहरण विभाजन हैं।

हमारे कार्य को ऑब्जेक्ट डिटेक्शन की आवश्यकता है। 2014 लेख दृश्य सटीकता के साथ वायोला-जोन्स और एचओजी पद्धति पर आधारित एक दृष्टिकोण प्रदान करता है:

अतिरिक्त सांख्यिकीय प्रतिबंधों के उपयोग के लिए धन्यवाद, उनकी सटीकता बहुत अच्छी है:

अब तंत्रिका नेटवर्क की मदद से ऑब्जेक्ट मान्यता का कार्य सफलतापूर्वक हल किया गया है। हम Tensorflow Object Detection API सिस्टम का उपयोग करेंगे और Mobilenet V1 SSD आर्किटेक्चर के साथ एक न्यूरल नेटवर्क को प्रशिक्षित करेंगे। ऐसे मॉडल को खरोंच से प्रशिक्षित करने के लिए बहुत अधिक डेटा की आवश्यकता होती है और इसमें कई दिन लग सकते हैं, इसलिए हम स्थानांतरण सीखने के सिद्धांत के अनुसार COCO डेटा पर प्रशिक्षित मॉडल का उपयोग करते हैं।

इस दृष्टिकोण की प्रमुख अवधारणा यह है। एक बच्चे को लाखों वस्तुओं को दिखाने की आवश्यकता क्यों नहीं है ताकि वह एक घन से एक गेंद को खोजने और भेद करने के लिए सीखता है? क्योंकि बच्चे में दृश्य प्रांतस्था के विकास के 500 मिलियन वर्ष हैं। विकास ने दृष्टि को सबसे बड़ी संवेदी प्रणाली बना दिया है। मानव मस्तिष्क के न्यूरॉन्स का लगभग 50% (लेकिन यह सटीक नहीं है) छवि प्रसंस्करण के लिए जिम्मेदार है। माता-पिता केवल गेंद और क्यूब दिखा सकते हैं, और फिर बच्चे को कई बार सही कर सकते हैं ताकि वह पूरी तरह से एक को पाता है और दूसरे से अलग होता है।

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

वास्तविक दुनिया की वस्तुओं में बहुत कुछ है। ट्रांसफर लर्निंग, हम बुनियादी सुविधाओं की परिभाषा के पहले से ही प्रशिक्षित स्तरों का उपयोग करते हैं और वस्तुओं की पहचान के लिए जिम्मेदार परतों को प्रशिक्षित करते हैं। ऐसा करने के लिए, सौ तस्वीरें और एक साधारण GPU के संचालन के कुछ घंटे हमारे लिए पर्याप्त हैं। नेटवर्क को मूल रूप से COCO (माइक्रोसॉफ्ट कॉमन ऑब्जेक्ट्स इन कॉनटेक्स्ट) डेटासेट पर प्रशिक्षित किया गया था, जो कि 91 श्रेणियां और 2,500,000 छवियां हैं! कई, हालांकि विकास के 500 मिलियन वर्ष नहीं।

थोड़ा आगे देखें, तो यह gif- एनीमेशन (थोड़ा धीमा, तुरंत स्क्रॉल न करें) टेंसरबोर्ड से सीखने की प्रक्रिया को दर्शाता है। जैसा कि आप देख सकते हैं, मॉडल लगभग पूरी तरह से उच्च गुणवत्ता वाले परिणाम का उत्पादन करना शुरू कर देता है, और फिर पीस आता है:

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

परिणामस्वरूप, हमने पहलू अनुपात बनाए रखते हुए फ़ोटो को 1000x1000 पिक्सेल के आकार तक संकुचित कर दिया। लेकिन जब से एक बड़ी तस्वीर को संपीड़ित किया जाता है, तो बहुत सारे संकेत खो जाते हैं, पहले रैक के प्रत्येक फोटो से यादृच्छिक आकार के कई वर्ग काट दिए गए थे और 1000x1000 में निचोड़ा गया था। परिणामस्वरूप, उच्च रिज़ॉल्यूशन में पैक (लेकिन पर्याप्त नहीं) और छोटे में (लेकिन कई) प्रशिक्षण डेटा में गिर गए। हम दोहराते हैं: यह कदम मजबूर है और, सबसे अधिक संभावना है, पूरी तरह से अनावश्यक है, और संभवतः हानिकारक है।

तैयार और संकुचित तस्वीरों को अलग-अलग निर्देशिकाओं (eval और train) में सहेजा जाता है, और उनका विवरण (उन पर मौजूद बंडलों के साथ) दो पांडा डेटा फ्रेम (train_df और eval_df) के रूप में बनता है:

Tensorflow Object Detection API सिस्टम को tfrecord फ़ाइलों के रूप में प्रस्तुत करने की आवश्यकता होती है। आप उपयोगिता का उपयोग करके उन्हें बना सकते हैं, लेकिन हम इसे एक कोड बना देंगे:

 def class_text_to_int(row_label):   if row_label == 'pack':       return 1   else:       None def split(df, group):   data = namedtuple('data', ['filename', 'object'])   gb = df.groupby(group)   return [data(filename, gb.get_group(x))           for filename, x in zip(gb.groups.keys(), gb.groups)] def create_tf_example(group, path):   with tf.gfile.GFile(os.path.join(path, '{}'.format(group.filename)), 'rb') as fid:       encoded_jpg = fid.read()   encoded_jpg_io = io.BytesIO(encoded_jpg)   image = Image.open(encoded_jpg_io)   width, height = image.size   filename = group.filename.encode('utf8')   image_format = b'jpg'   xmins = []   xmaxs = []   ymins = []   ymaxs = []   classes_text = []   classes = []   for index, row in group.object.iterrows():       xmins.append(row['xmin'] / width)       xmaxs.append(row['xmax'] / width)       ymins.append(row['ymin'] / height)       ymaxs.append(row['ymax'] / height)       classes_text.append(row['class'].encode('utf8'))       classes.append(class_text_to_int(row['class']))   tf_example = tf.train.Example(features=tf.train.Features(feature={       'image/height': dataset_util.int64_feature(height),       'image/width': dataset_util.int64_feature(width),       'image/filename': dataset_util.bytes_feature(filename),       'image/source_id': dataset_util.bytes_feature(filename),       'image/encoded': dataset_util.bytes_feature(encoded_jpg),       'image/format': dataset_util.bytes_feature(image_format),       'image/object/bbox/xmin': dataset_util.float_list_feature(xmins),       'image/object/bbox/xmax': dataset_util.float_list_feature(xmaxs),       'image/object/bbox/ymin': dataset_util.float_list_feature(ymins),       'image/object/bbox/ymax': dataset_util.float_list_feature(ymaxs),       'image/object/class/text': dataset_util.bytes_list_feature(classes_text),       'image/object/class/label': dataset_util.int64_list_feature(classes),   }))   return tf_example def convert_to_tf_records(images_path, examples, dst_file):   writer = tf.python_io.TFRecordWriter(dst_file)   grouped = split(examples, 'filename')   for group in grouped:       tf_example = create_tf_example(group, images_path)       writer.write(tf_example.SerializeToString())   writer.close() convert_to_tf_records(f'{cropped_path}train/', train_df, f'{detector_data_path}train.record') convert_to_tf_records(f'{cropped_path}eval/', eval_df, f'{detector_data_path}eval.record')

यह हमारे लिए एक विशेष निर्देशिका तैयार करने और प्रक्रियाओं को शुरू करने के लिए बनी हुई है:

संरचना अलग हो सकती है, लेकिन हम इसे बहुत सुविधाजनक पाते हैं।

डेटा निर्देशिका में वे फाइलें हैं जो हमने tfrecords (train.record और eval.record) के साथ बनाई हैं, साथ ही उन वस्तुओं के प्रकारों के साथ pack.pbtxt भी हैं जिनके लिए हम तंत्रिका नेटवर्क को प्रशिक्षित करेंगे। हमारे पास परिभाषित करने के लिए केवल एक प्रकार की वस्तु है, इसलिए फ़ाइल बहुत छोटी है:

Sdd_mobilenet_v1 चाइल्ड डायरेक्टरी में मॉडल निर्देशिका (एक समस्या को हल करने के लिए कई मॉडल हो सकते हैं) में .config फ़ाइल में प्रशिक्षण के लिए सेटिंग्स होती हैं, साथ ही दो खाली निर्देशिकाएं: ट्रेन और ईवैल। ट्रेन में, "ट्रेनर" मॉडल नियंत्रण बिंदुओं को बचाएगा, "मूल्यांकनकर्ता" उन्हें उठाएगा, मूल्यांकन के लिए डेटा पर उन्हें चलाएगा और उन्हें eval निर्देशिका में डाल देगा। Tensorboard इन दो निर्देशिकाओं और प्रदर्शन प्रक्रिया की जानकारी का ट्रैक रखेगा।

विन्यास फाइल आदि की संरचना का विस्तृत विवरण। यहाँ और यहाँ पाया जा सकता है । टेंसरफ्लो ऑब्जेक्ट डिटेक्शन एपीआई इंस्टॉलेशन निर्देश यहां देखे जा सकते हैं ।

हम मॉडल / अनुसंधान / object_detection निर्देशिका में जाते हैं और पूर्व-प्रशिक्षित मॉडल का बचाव करते हैं:

 wget http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v1_coco_2017_11_17.tar.gz tar -xvzf ssd_mobilenet_v1_coco_2017_11_17.tar.gz

हम वहां हमारे द्वारा तैयार pack_detector निर्देशिका की प्रतिलिपि बनाते हैं।

सबसे पहले, प्रशिक्षण प्रक्रिया शुरू करें:

 python3 train.py --logtostderr \   --train_dir=pack_detector/models/ssd_mobilenet_v1/train/ \   --pipeline_config_path=pack_detector/models/ssd_mobilenet_v1/ssd_mobilenet_v1_pack.config

हम मूल्यांकन प्रक्रिया शुरू करते हैं। हमारे पास दूसरा वीडियो कार्ड नहीं है, इसलिए हम इसे प्रोसेसर पर लॉन्च करते हैं (निर्देश CUDA_VISIBLE_DEVICES = "" का उपयोग करके)। इस वजह से, उन्हें प्रशिक्षण प्रक्रिया के बारे में बहुत देर हो जाएगी, लेकिन यह इतना बुरा नहीं है:

 CUDA_VISIBLE_DEVICES="" python3 eval.py \   --logtostderr \   --checkpoint_dir=pack_detector/models/ssd_mobilenet_v1/train \   --pipeline_config_path=pack_detector/models/ssd_mobilenet_v1/ssd_mobilenet_v1_pack.config \   --eval_dir=pack_detector/models/ssd_mobilenet_v1/eval

हम टेंसरबोर्ड प्रक्रिया शुरू करते हैं:

 tensorboard --logdir=pack_detector/models/ssd_mobilenet_v1

उसके बाद, हम सुंदर रेखांकन, साथ ही अनुमानित डेटा पर मॉडल के वास्तविक काम (शुरुआत में gif) देख सकते हैं:

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

 python3 export_inference_graph.py \   --input_type image_tensor \   --pipeline_config_path pack_detector/models/ssd_mobilenet_v1/ssd_mobilenet_v1_pack.config \   --trained_checkpoint_prefix pack_detector/models/ssd_mobilenet_v1/train/model.ckpt-13756 \   --output_directory pack_detector/models/ssd_mobilenet_v1/pack_detector_2018_06_03

तो, इस कदम पर हमें एक निष्कर्ष ग्राफ मिला, जिसका उपयोग हम बंडल वस्तुओं की खोज के लिए कर सकते हैं। हम इसके उपयोग को पास करते हैं।

चरण 4. खोज को लागू करना ( जीथब लिंक )

ऊपर दिए गए लिंक पर इनविज़न ग्राफ लोडिंग और इनिशियलाइज़ेशन कोड है। मुख्य खोज विशेषताएं:

 # let's write function that executes detection def run_inference_for_single_image(image, image_tensor, sess, tensor_dict):   # Run inference   expanded_dims = np.expand_dims(image, 0)   output_dict = sess.run(tensor_dict, feed_dict={image_tensor: expanded_dims})   # all outputs are float32 numpy arrays, so convert types as appropriate   output_dict['num_detections'] = int(output_dict['num_detections'][0])   output_dict['detection_classes'] = output_dict['detection_classes'][0].astype(np.uint8)   output_dict['detection_boxes'] = output_dict['detection_boxes'][0]   output_dict['detection_scores'] = output_dict['detection_scores'][0]   return output_dict # it is useful to be able to run inference not only on the whole image, # but also on its parts # cutoff - minimum detection score needed to take box def run_inference_for_image_part(image_tensor, sess, tensor_dict,                                image, cutoff, ax0, ay0, ax1, ay1):   boxes = []   im = image[ay0:ay1, ax0:ax1]   h, w, c = im.shape   output_dict = run_inference_for_single_image(im, image_tensor, sess, tensor_dict)   for i in range(100):       if output_dict['detection_scores'][i] < cutoff:           break       y0, x0, y1, x1, score = *output_dict['detection_boxes'][i], \                               output_dict['detection_scores'][i]       x0, y0, x1, y1, score = int(x0*w), int(y0*h), \                               int(x1*w), int(y1*h), \                               int(score * 100)       boxes.append((x0+ax0, y0+ay0, x1+ax0, y1+ay0, score))   return boxes

फ़ंक्शन पूरे फ़ोटो में नहीं, बल्कि उसके हिस्से में पैक के लिए बंधे हुए बक्से पाता है। फ़ंक्शन कटऑफ पैरामीटर में निर्दिष्ट कम पहचान स्कोर के साथ पाए गए आयतों को भी फ़िल्टर करता है।

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

हालांकि, ध्यान दें कि यदि हम फोटो के एक छोटे से टुकड़े के लिए फ़ंक्शन चलाते हैं, तो मान्यता कटऑफ = 0.9 के साथ लगभग सही है।

यह इस तथ्य के कारण है कि MobileNet V1 SSD मॉडल 300x300 तस्वीरों को इनपुट के रूप में स्वीकार करता है। स्वाभाविक रूप से, इस तरह के संपीड़न के साथ बहुत सारे संकेत खो जाते हैं।

लेकिन ये संकेत बने रहते हैं अगर हम एक छोटे वर्ग को काटते हैं जिसमें कई पैक होते हैं। यह एक फ्लोटिंग विंडो का उपयोग करने के विचार का सुझाव देता है: हम एक तस्वीर में एक छोटी आयत के माध्यम से चलते हैं और हमें जो कुछ भी मिला है उसे याद करते हैं।

: , . . : (detection score), , , overlapTresh ( ):

 # function for non-maximum suppression def non_max_suppression(boxes, overlapThresh):   if len(boxes) == 0:       return np.array([]).astype("int")   if boxes.dtype.kind == "i":       boxes = boxes.astype("float")   pick = []   x1 = boxes[:,0]   y1 = boxes[:,1]   x2 = boxes[:,2]   y2 = boxes[:,3]   sc = boxes[:,4]   area = (x2 - x1 + 1) * (y2 - y1 + 1)   idxs = np.argsort(sc)   while len(idxs) > 0:       last = len(idxs) - 1       i = idxs[last]       pick.append(i)       xx1 = np.maximum(x1[i], x1[idxs[:last]])       yy1 = np.maximum(y1[i], y1[idxs[:last]])       xx2 = np.minimum(x2[i], x2[idxs[:last]])       yy2 = np.minimum(y2[i], y2[idxs[:last]])       w = np.maximum(0, xx2 - xx1 + 1)       h = np.maximum(0, yy2 - yy1 + 1)       #todo fix overlap-contains...       overlap = (w * h) / area[idxs[:last]]              idxs = np.delete(idxs, np.concatenate(([last],           np.where(overlap > overlapThresh)[0])))     return boxes[pick].astype("int")

, , .

निष्कर्ष

«»: , . , , .. .

, , :

150 , , ,
3-7 ,
100 ,
,
(),
(, ),
, «»,
, , (SSD ),
, ,
.

, , .

परिचय

डेटा और दृष्टिकोण

प्रौद्योगिकी के

निष्कर्ष

More articles: