कुछ आधुनिक कैप्चा की मान्यता

यह मेरे द्वारा बाल्टिक वैज्ञानिक और इंजीनियरिंग प्रतियोगिता में प्रस्तुत किए गए काम का नाम था , जिसने मुझे रोमन एकता के साथ-साथ एक नए लैपटॉप के साथ एक आकर्षक कागज़ दिया।

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



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

अजीब तरह से, इन कैप्चा के सभी (अच्छी तरह से, लगभग सभी) बहुत कमजोर थे। सबसे छोटा परिणाम - 20% - पीले ऑपरेटर के अंतर्गत आता है, सबसे बड़ा - 86% - नीले रंग के लिए। इस प्रकार, मेरा मानना ​​है कि "अक्षमता का प्रदर्शन" का कार्य सफलतापूर्वक हल हो गया था।

सेलुलर ऑपरेटरों को चुनने के कारण तुच्छ हैं। प्रतिष्ठित वैज्ञानिक जूरी को, मैंने बाइक से कहा कि “मोबाइल ऑपरेटरों के पास किसी भी कौशल के प्रोग्रामर को काम पर रखने के लिए पर्याप्त पैसा है, और साथ ही, उन्हें स्पैम की मात्रा को कम करने की आवश्यकता है; इस प्रकार, उनका कॅप्चा काफी शक्तिशाली होना चाहिए, जो कि मेरे शोध से पता चलता है, ऐसा बिल्कुल नहीं है। " वास्तव में, सब कुछ बहुत सरल था। मैं कुछ साधारण कैप्चा को पहचानने के लिए हैक करके अनुभव प्राप्त करना चाहता था, और कैप्चा के शिकार के रूप में लाल ऑपरेटर को चुना। और उसके बाद, पूर्वोक्त कहानी का जन्म रेट्रो रूप से हुआ।

तो, शरीर के करीब। मेरे पास कैप्चा के सभी चार प्रकारों को पहचानने के लिए कोई मेगा-उन्नत एल्गोरिथ्म नहीं है; इसके बजाय, मैंने प्रत्येक प्रकार के कैप्चा के लिए अलग से 4 अलग एल्गोरिदम लिखे। हालांकि, इस तथ्य के बावजूद कि एल्गोरिदम विवरण में भिन्न हैं, सामान्य तौर पर वे बहुत समान थे।

मेरे से पहले के कई लेखकों की तरह, मैंने कैप्चा पहचान कार्य को 3 उप-प्रकारों में विभाजित किया है: प्रीप्रोसेसिंग (प्रीप्रोसेस), विभाजन, और मान्यता। प्रीप्रोसेस चरण में, विभिन्न शोर, विकृतियों आदि को मूल छवि से हटा दिया जाता है। विभाजन में, व्यक्तिगत पात्रों को मूल छवि से निकाला जाता है और पोस्ट-प्रोसेसिंग (उदाहरण के लिए, रिवर्स रोटेशन) से उत्पादित किया जाता है। मान्यता के दौरान, वर्ण एक-प्रशिक्षित तंत्रिका नेटवर्क द्वारा एक-एक करके संसाधित होते हैं।

केवल प्रीप्रोसेस काफी अलग था। यह इस तथ्य के कारण है कि विभिन्न CAPTCHAs क्रमशः अलग छवि विरूपण विधियों का उपयोग करते हैं, और इन विकृतियों को दूर करने के लिए एल्गोरिदम बहुत अलग हैं। सेगमेंटेशन ने नाबालिग ट्विस्ट के साथ कनेक्टिविटी घटकों को खोजने के महत्वपूर्ण विचार का शोषण किया (उन्हें केवल पीले- धारीदार के साथ महत्वपूर्ण होना था)। मान्यता चार में से तीन ऑपरेटरों के लिए बिल्कुल समान थी - फिर से, केवल पीला ऑपरेटर अलग था।

कोड OpenCV और FANN पुस्तकालयों का उपयोग करते हुए पायथन में लिखा गया है, जो एक सभ्य फ़ाइल आकार और इसके अलावा एक टैम्बोरिन के बिना स्थापित नहीं किया जा सकता है । इसलिए, मेरे परिणामों को पुन: प्रस्तुत करना आसान नहीं होगा - कम से कम जब तक उपरोक्त पुस्तकालयों के लेखक पायथन के लिए सामान्य बाइंडिंग नहीं बनाते हैं।

लाल

जैसा कि मैंने कहा, मेरे द्वारा चुना गया पहला खरगोश यह कैप्चा था। मुझे लगता है कि कुछ उदाहरण स्थिति को स्पष्ट करेंगे:



यही है, और पहली बार में यह मुझे बहुत सरल लग रहा था ... हालांकि, यह धारणा खरोंच से नहीं पैदा हुई। तो:

• रंग ग्रेस्केल तक ही सीमित हैं, प्रतीक प्रकाश के साथ, पृष्ठभूमि अंधेरे
• कोई अतिरिक्त शोर नहीं
• स्थायी विकृति (जो चित्र से चित्र में नहीं बदल रही है)
• हमेशा पाँच अक्षर होते हैं
• चरित्र आकार लगभग समान हैं
• प्रतीक लगभग हमेशा जुड़े होते हैं

यह सब इस कॅप्चा के गुणों को कम करने के लिए लग रहा था:

• चिपचिपा अक्षर
• विले छेदक फ़ॉन्ट
• बहुत छोटा आकार (83x23 px)

स्वाभाविक रूप से, ये "फायदे" केवल स्वचालित मान्यता की जटिलता के संदर्भ में हैं। तीन चरण की योजना के अनुसार जो मैंने पहले उल्लेख किया था, हम छवि के प्रारंभिक प्रसंस्करण के साथ शुरू करते हैं, अर्थात् 2 गुना वृद्धि।



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





इसके बाद, मैं थ्रेशोल्ड ट्रांसफॉर्मेशन (लोकप्रिय थ्रेशोल्ड) को t = 200 के साथ लागू करता हूं और छवि को उल्टा करता हूं:



अंत में, छोटे (10px से कम) काले जुड़े क्षेत्रों को सफेद रंग से रंगा जाता है:



इसके बाद विभाजन है। जैसा कि मैंने कहा, कनेक्टिविटी घटकों की खोज यहाँ लागू होती है:



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



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

इस तरह के एल्गोरिथ्म के संचालन के सिद्धांत की व्याख्या करने के लिए, आपको हार्डवेयर में थोड़ा गहरा जाना होगा। N से मिलने वाले खंडों की संख्या और चौड़ाई के सरणी को सही ढंग से ( सही तरीके से कहा, हाँ? ) चौड़ाई के अनुसार सभी खंडों को निरूपित करें [n]। हम मानते हैं कि यदि उपरोक्त चरणों के बाद n> 5, तो छवि को मान्यता नहीं दी जा सकती है। संख्या 5 के सभी संभावित डिकंपोज़िशन पर पूर्णांक सकारात्मक शब्दों में विचार करें। उनमें से कई नहीं हैं - केवल 16. प्रत्येक ऐसा अपघटन पाया गया जुड़े घटकों पर वर्णों की कुछ संभावित व्यवस्था से मेल खाता है। यह मानना ​​तर्कसंगत है कि परिणामी सेगमेंट जितना व्यापक होगा, उसमें उतने ही अधिक अक्षर होंगे। सभी पाँच अपघटनों में से, हम केवल उन्हीं को चुनते हैं जिनमें शब्दों की संख्या n होती है। प्रत्येक तत्व को चौड़ाई से चौड़ाई में विभाजित करें [0] - जैसे कि उन्हें सामान्य करें। हम सभी शेष decompositions के साथ भी ऐसा ही करेंगे - हम उनमें से प्रत्येक संख्या को पहले शब्द से विभाजित करते हैं। और अब (ध्यान, चरमोत्कर्ष!), हम ध्यान दें कि परिणामी एन-की को n-आयामी अंतरिक्ष में बिंदुओं के रूप में सोचा जा सकता है। इसे ध्यान में रखते हुए, हम सामान्यीकृत चौड़ाई में पांच के निकटतम यूक्लिडियन अपघटन पाते हैं। यह वांछित परिणाम है।

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

इसलिए, प्रत्येक घटक में वर्णों की संख्या निर्धारित करने के बाद, निम्नलिखित अनुमानी होता है - हम मानते हैं कि वर्णों के बीच विभाजक स्वयं वर्णों की तुलना में पतले हैं। इस अंतरतम ज्ञान का उपयोग करने के लिए, हम खंड में n-1 विभाजकों की व्यवस्था करेंगे, जहाँ n खंड में वर्णों की संख्या है, जिसके बाद हम प्रत्येक विभाजक के एक छोटे से पड़ोस में छवि प्रक्षेपण की गणना करेंगे। इस प्रक्षेपण के परिणामस्वरूप, हमें जानकारी मिलती है कि प्रत्येक कॉलम में कितने पिक्सेल प्रतीकों के हैं। अंत में, प्रत्येक प्रक्षेपण में हम न्यूनतम पाते हैं और विभाजक को वहां स्थानांतरित करते हैं, जिसके बाद हम इन विभाजकों द्वारा छवि को काटते हैं।





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



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

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

वैसे, लगभग हर जगह (पीले ऑपरेटर को छोड़कर) मैंने इस तरह की एक योजना का उपयोग किया - ट्रेनसेट में 200 चित्र, 100 - टेस्टसेट में।

ग्रीन

अगला लक्ष्य मैंने हरा चुना - मैं विरूपण मैट्रिक्स का चयन करने की तुलना में कुछ अधिक गंभीर लेना चाहता था।



लाभ:

• त्रि-आयामी प्रभाव
• रोटेशन और विस्थापन
• असमान चमक

नुकसान:

• प्रतीक पृष्ठभूमि की तुलना में काफी गहरे हैं
• आयत का ऊपरी भाग स्पष्ट रूप से दिखाई देता है - इसका उपयोग रिवर्स रोटेशन के लिए किया जा सकता है

यह पता चला है कि इन कमियों के बावजूद, यह प्रतीत होता है, महत्वहीन हैं, उनका संचालन आपको सभी लाभों से बहुत प्रभावी ढंग से निपटने की अनुमति देता है।

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

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



उपरोक्त को संक्षेप में प्रस्तुत करने के लिए: हम ऐसी रेखा की तलाश करेंगे कि जब वह छवि को नीचे ले जाए, तो इस रेखा पर पड़ी पिक्सेल की चमक सबसे अधिक बढ़ जाती है।

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

अगला कदम पृष्ठभूमि से पात्रों को अलग करना है। यहाँ, यह तथ्य कि पात्र पृष्ठभूमि की तुलना में बहुत गहरे हैं, हमें बहुत मदद करेंगे। यह डेवलपर्स की ओर से एक तार्किक कदम है - अन्यथा तस्वीर को पढ़ना बहुत मुश्किल होगा। जो लोग विश्वास नहीं करते हैं, वे छवि को अपने दम पर दूर करने और खुद को देखने की कोशिश कर सकते हैं।

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

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



अगला, हम पहले पाए गए कोण के लिए एक मोड़ बनाते हैं।



अंत में, दिलेट और इरोड ऑपरेटरों का संयोजन हमें पात्रों में छोड़े गए छोटे छेदों से छुटकारा दिलाता है, जो मान्यता को आसान बनाने में मदद करता है।



पूर्वसंक्रमण की तुलना में यहाँ विभाजन बहुत सरल है। सबसे पहले, हम जुड़े घटकों की तलाश कर रहे हैं।



फिर हम घटकों को क्षैतिज रूप से जोड़ते हैं (प्रक्रिया पहले जैसी ही है):





दरअसल, बस इतना ही। मान्यता इस प्रकार है, लेकिन यह ऊपर से अलग नहीं है।

इस एल्गोरिथ्म ने हमें सफलतापूर्वक मान्यता प्राप्त छवियों के 69% में परिणाम प्राप्त करने और 0.3 वर्णों / छवि की औसत त्रुटि प्राप्त करने की अनुमति दी।

नीला

तो, नीले ऑपरेटर को तीसरे द्वारा "पराजित" का दर्जा मिला। यह था, इसलिए बोलना, वास्तव में बड़ी मछली से पहले एक राहत ...



योग्यता में कुछ लिखना मुश्किल है, लेकिन मैं अभी भी कोशिश कर रहा हूं:

• प्रतीकों को मोड़ना कम या ज्यादा गंभीर बाधा है
• पात्रों के रूप में पृष्ठभूमि शोर
• प्रतीक कभी-कभी एक-दूसरे को स्पर्श करते हैं।

इसके विपरीत:

• पात्रों की तुलना में पृष्ठभूमि काफी हल्की है
• प्रतीक एक आयत में अच्छी तरह से फिट होते हैं
• पात्रों का अलग-अलग रंग उन्हें एक-दूसरे से अलग करना आसान बनाता है

तो, प्रीप्रोसेस। आइए पृष्ठभूमि को क्लिप करके शुरू करें। चूंकि छवि तीन-रंग की है, इसे चैनलों में काट लें, और फिर सभी बिंदुओं को त्याग दें जो सभी चैनलों में 116 से अधिक उज्ज्वल हैं। हमें ऐसा प्यारा मुखौटा मिलता है:



फिर छवि को एचएसवी रंग स्थान ( विकिपीडिया ) में परिवर्तित करें। यह पात्रों के रंग के बारे में जानकारी बचाएगा, और साथ ही उनके किनारों से ढाल को हटा देगा।



हम पहले प्राप्त मास्क को परिणाम पर लागू करते हैं:



यह प्रीप्रोसेस समाप्त होता है। विभाजन भी काफी तुच्छ है। कनेक्टिविटी घटकों के साथ, हमेशा की तरह शुरू करें:





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



इसके अलावा, हमेशा की तरह, मान्यता इस प्रकार है।

यह एल्गोरिथ्म 0.16 वर्णों / छवि की औसत त्रुटि के साथ 86% छवियों को सफलतापूर्वक पहचानता है, जो इस धारणा की पुष्टि करता है कि यह कैप्चा वास्तव में सबसे सरल है। हालांकि, ऑपरेटर सबसे बड़ा नहीं है ...

पीला

सबसे दिलचस्प हिस्सा आ रहा है। तो बोलने के लिए, मेरी रचनात्मक गतिविधि का एपोटॉसिस :) यह कैप्चा वास्तव में कंप्यूटर के लिए सबसे कठिन है, और, दुर्भाग्य से, एक व्यक्ति के लिए।



लाभ:

• धब्बे और रेखाओं के रूप में शोर
• बारी बारी से और पैमाने पर अक्षर
• पात्रों की निकटता

नुकसान:

• बहुत सीमित पैलेट
• सभी लाइनें बहुत पतली हैं
• स्पॉट अक्सर प्रतीकों के साथ ओवरलैप नहीं होते हैं
• सभी वर्णों का घूर्णन कोण लगभग समान है

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

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



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



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



इन मास्क का उपयोग करके मैंने छवि पर इनपेंट एल्गोरिथ्म (या इसके कार्यान्वयन , OpenCV में) को सेट किया है। यह आपको छवि से अधिकांश कचरे को बहुत कुशलता से साफ करने की अनुमति देता है।



हालांकि, OpenCV में इस एल्गोरिथ्म के कार्यान्वयन को फोटो और वीडियो के साथ काम करने के लिए बनाया गया था, और शोर पाठ के साथ कृत्रिम रूप से बनाई गई छवियों की मान्यता नहीं थी। इसे लागू करने के बाद, ग्रेडिएंट दिखाई देते हैं, जिन्हें मैं विभाजन को आसान बनाने के लिए बचना चाहूंगा। इस प्रकार, अतिरिक्त प्रसंस्करण का प्रदर्शन किया जाना है, अर्थात् पैनापन। प्रत्येक पिक्सेल के रंग के लिए, मैं उपरोक्त तालिका से इसकी निकटतम गणना करता हूं (याद रखें, 5 रंग हैं - प्रत्येक अक्षर बनावट और सफेद के लिए एक)।



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



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

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



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

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



यह एल्गोरिथ्म बहुत सटीक है, लेकिन परिणाम स्पष्ट रूप से बहुत बड़े हैं (27 डिग्री से अधिक) मुझे ध्यान में नहीं है। शेष लोगों में से, मुझे अंकगणित माध्य लगता है, जिसके बाद पूरी छवि को इस कोण पर घटाकर घुमाया जाता है। फिर मैं कनेक्टिविटी घटकों के लिए फिर से खोज करता हूं।



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



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

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

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

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

इस एल्गोरिथ्म में एक तंत्रिका नेटवर्क के उपयोग से जुड़ी एक और सूक्ष्मता है। पिछले उदाहरणों में, तंत्रिका नेटवर्क को प्रीप्रोसेस और विभाजन के लगभग कच्चे परिणामों पर प्रशिक्षित किया गया था। यहां, उसने 12% से अधिक सफल मान्यता प्राप्त करने की अनुमति दी। यह स्पष्ट रूप से मुझे शोभा नहीं देता। इसलिए, तंत्रिका नेटवर्क प्रशिक्षण के अगले युग को शुरू करने से पहले, मैंने मूल छवियों में विभिन्न विकृतियों को पेश किया, मोटे तौर पर वास्तविक लोगों को मॉडलिंग करते हुए: सफेद / ग्रे / काले डॉट्स, ग्रे लाइनों / सर्कल / आयतों को जोड़ें, घुमाएं। मैंने 200 छवियों से ट्रेनसेट को 300 तक बढ़ाया और 100 छवियों द्वारा प्रशिक्षण के दौरान प्रशिक्षण की गुणवत्ता का परीक्षण करने के लिए तथाकथित वैलेडसेट को जोड़ा। इसने हमें लगभग पांच प्रतिशत की उत्पादकता वृद्धि प्राप्त करने की अनुमति दी, और, तंत्रिका नेटवर्क के विभाजन के साथ युग्मित, इसने वह परिणाम दिया जो मैंने लेख की शुरुआत में बोला था।

आंकड़े प्रदान करना इस तथ्य से जटिल है कि मैं दो तंत्रिका नेटवर्क के साथ समाप्त हुआ: एक ने उच्च मान्यता प्रतिशत दिया, और दूसरे ने एक छोटी सी त्रुटि दी। यहां मैं पहले परिणाम देता हूं।

कुल मिलाकर, जैसा कि मैंने एक से अधिक बार कहा है, टेस्टसेट में 100 चित्र थे। इनमें से, 20 सफलतापूर्वक पहचाने गए, 80 क्रमशः असफल रहे, और त्रुटि 1.91 वर्ण प्रति छवि थी। अन्य सभी ऑपरेटरों की तुलना में काफी खराब है, लेकिन इसी कैप्चा।

एक निष्कर्ष के बजाय

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

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

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

UPD 2015-04-09: गितुब पर भंडार ।