👨🏻‍💼 👆🏿 🧒🏿 पायथन कैप्चा डिकोडिंग 🛢️ 🙅🏾 🎳

यह अनुवाद और प्रथम-व्यक्ति कथा रूप सहेजा गया है। बेन स्टुटर, चार्ल्स स्टर्ट विश्वविद्यालय (CSU) में सूचना प्रौद्योगिकी स्नातक।

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

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

कैप्चा को इसलिए डिज़ाइन किया गया है ताकि कोई व्यक्ति बिना किसी कठिनाई के पाठ पढ़ सके, जबकि एक मशीन (हाय, reCaptcha!) नहीं कर सकती। व्यवहार में, इसने कभी काम नहीं किया, क्योंकि साइट पर पोस्ट किए गए लगभग हर कैप्चा को कई महीनों के लिए क्रैक किया गया था।

मैंने बहुत अच्छा किया - 60% से अधिक छवियों को मेरे छोटे संग्रह से सफलतापूर्वक हल किया गया। इंटरनेट पर छवियों की विविधता को देखते हुए बहुत अच्छा है।

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

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

चलिए शुरू करते हैं। इस लेख में मैं जो कुछ बताने जा रहा हूं, उसकी एक सूची इस प्रकार है:

प्रयुक्त प्रौद्योगिकियाँ
कैप्चा क्या है
छवियों से टेक्स्ट कैसे ढूंढें और निकालें
ऐ छवि मान्यता
ट्रेनिंग
यह सब एक साथ रखना
परिणाम और निष्कर्ष

प्रयुक्त प्रौद्योगिकियाँ

सभी उदाहरणों को पीआईएल पुस्तकालय का उपयोग करके पायथन 2.5 में लिखा गया है। इसे पायथन 2.6 में भी काम करना चाहिए (यह पायथन 2.7.3 के तहत ठीक चलता है । लगभग। अनुवाद। )।

अजगर: www.python.org
PIL: www.pythonware.com/products/pil

उन्हें उपरोक्त क्रम में स्थापित करें और आप उदाहरणों को चलाने के लिए तैयार हैं।

पीछे हटना

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

कैप्चा, यह अंत में क्या है?

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

कई वेबसाइटों पर स्पैम को रोकने के लिए उनका उपयोग किया जाता है। उदाहरण के लिए, कैप्चा को विंडोज लाइव आईडी में पंजीकरण पृष्ठ पर पाया जा सकता है।

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

यह छवि एक कैप्चा का एक उदाहरण है जिसे हम डिक्रिप्ट करेंगे। यह एक वास्तविक कैप्चा है, जिसे एक वास्तविक साइट पर पोस्ट किया जाता है।

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

छवियों से टेक्स्ट कैसे ढूंढें और निकालें

एक छवि में पाठ की स्थिति और इसके निष्कर्षण को निर्धारित करने के लिए कई तरीके हैं। Google के साथ, आप हजारों लेख पा सकते हैं जो पाठ खोजने के लिए नए तरीकों और एल्गोरिदम की व्याख्या करते हैं।

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

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

सफेद (पृष्ठभूमि)
ग्रे (शोर)
लाल (पाठ)

पायथन में, यह बहुत सरल लगेगा।

निम्न कोड छवि को खोलता है, इसे जीआईएफ में परिवर्तित करता है (यह हमारे लिए काम करना आसान बनाता है, क्योंकि इसमें केवल 255 रंग हैं) और रंगों का हिस्टोग्राम प्रिंट करता है।

from PIL import Image im = Image.open("captcha.gif") im = im.convert("P") print im.histogram()

परिणामस्वरूप, हमें निम्नलिखित मिलते हैं:

 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0 , 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 1, 2, 0, 1, 0, 0, 1, 0, 2, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 3, 1, 3, 3, 0, 0, 0, 0, 0, 0, 1, 0, 3, 2, 132, 1, 1, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 15, 0 , 1, 0, 1, 0, 0, 8, 1, 0, 0, 0, 0, 1, 6, 0, 2, 0, 0, 0, 0, 18, 1, 1, 1, 1, 1, 2, 365, 115, 0, 1, 0, 0, 0, 135, 186, 0, 0, 1, 0, 0, 0, 116, 3, 0, 0, 0, 0, 0, 21, 1, 1, 0, 0, 0, 2, 10, 2, 0, 0, 0, 0, 2, 10, 0, 0, 0, 0, 1, 0, 625]

यहाँ हम चित्र में 255 रंगों में से प्रत्येक के पिक्सेल की संख्या देखते हैं। आप देख सकते हैं कि सफेद (255, सबसे हाल ही में) सबसे अधिक बार पाया जाता है। इसके बाद लाल (पाठ) आता है। इसे सत्यापित करने के लिए, हम एक छोटी स्क्रिप्ट लिखेंगे:

 from PIL import Image from operator import itemgetter im = Image.open("captcha.gif") im = im.convert("P") his = im.histogram() values = {} for i in range(256): values[i] = his[i] for j,k in sorted(values.items(), key=itemgetter(1), reverse=True)[:10]: print j,k

और हम निम्नलिखित डेटा प्राप्त करते हैं:

रंग	पिक्सेल की संख्या
255	625
212	365
220	186
219	135
169	132
227	116
213	115
234	21
205	18
184	15

यह एक छवि में 10 सबसे आम रंगों की एक सूची है। जैसा कि अपेक्षित था, सफेद सबसे अधिक बार दोहराता है। फिर ग्रे और लाल आते हैं।

एक बार हमारे पास यह जानकारी होने के बाद, हम इन रंग समूहों के आधार पर नई छवियां बनाते हैं। सबसे आम रंगों में से प्रत्येक के लिए, हम एक नई बाइनरी इमेज बनाते हैं (2 रंगों में से), जहां इस रंग के पिक्सेल काले रंग से भरे होते हैं, और बाकी सब कुछ सफेद होता है।

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

 from PIL import Image im = Image.open("captcha.gif") im = im.convert("P") im2 = Image.new("P",im.size,255) im = im.convert("P") temp = {} for x in range(im.size[1]): for y in range(im.size[0]): pix = im.getpixel((y,x)) temp[pix] = pix if pix == 220 or pix == 227: # these are the numbers to get im2.putpixel((y,x),0) im2.save("output.gif")

इस कोड को चलाने से हमें निम्नलिखित परिणाम मिलते हैं।

मूल	परिणाम

तस्वीर में आप देख सकते हैं कि हम पृष्ठभूमि से पाठ निकालने में सफल रहे। इस प्रक्रिया को स्वचालित करने के लिए, आप पहली और दूसरी स्क्रिप्ट को जोड़ सकते हैं।

मैं सुनता हूं कि आप कैसे पूछते हैं: "क्या होगा अगर कैप्चा पर पाठ अलग-अलग रंगों में लिखा गया है?"। हां, हमारी तकनीक अभी भी काम कर सकती है। मान लें कि सबसे सामान्य रंग पृष्ठभूमि रंग है और फिर आप वर्णों के रंग पा सकते हैं।

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

 for each binary image: for each pixel in the binary image: if the pixel is on: if any pixel we have seen before is next to it: add to the same set else: add to a new set

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

 from PIL import Image im = Image.open("captcha.gif") im = im.convert("P") im2 = Image.new("P",im.size,255) im = im.convert("P") temp = {} for x in range(im.size[1]): for y in range(im.size[0]): pix = im.getpixel((y,x)) temp[pix] = pix if pix == 220 or pix == 227: # these are the numbers to get im2.putpixel((y,x),0) # new code starts here inletter = False foundletter=False start = 0 end = 0 letters = [] for y in range(im2.size[0]): # slice across for x in range(im2.size[1]): # slice down pix = im2.getpixel((y,x)) if pix != 255: inletter = True if foundletter == False and inletter == True: foundletter = True start = y if foundletter == True and inletter == False: foundletter = False end = y letters.append((start,end)) inletter=False print letters

परिणामस्वरूप, हमें निम्नलिखित मिला:

 [(6, 14), (15, 25), (27, 35), (37, 46), (48, 56), (57, 67)]

ये प्रत्येक वर्ण की शुरुआत और अंत के क्षैतिज स्थिति हैं।

पैटर्न पहचान के लिए ऐ और वेक्टर अंतरिक्ष

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

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

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

बेशक, कोई मुफ्त पनीर नहीं है। गति में मुख्य नुकसान। वे तंत्रिका नेटवर्क की तुलना में बहुत धीमा हो सकते हैं। लेकिन मुझे लगता है कि उनके फायदे अभी भी इस खामी को दूर करते हैं।

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

मैंने अपनी छवि मान्यता पूर्वोक्त दस्तावेज के आधार पर बनाई थी और यह पहली चीज थी जिसे मैंने अपने पसंदीदा पीएल में लिखने की कोशिश की थी, जो मैं उस समय पढ़ रहा था। इस दस्तावेज़ को पढ़ें और जैसा कि आप इसके सार को समझते हैं - यहाँ वापस आएं।

पहले से ही वापस? सब ठीक है। अब हमें अपने वेक्टर स्पेस को प्रोग्राम करना होगा। सौभाग्य से, यह बिल्कुल मुश्किल नहीं है। चलिए शुरू करते हैं।

 import math class VectorCompare: def magnitude(self,concordance): total = 0 for word,count in concordance.iteritems(): total += count ** 2 return math.sqrt(total) def relation(self,concordance1, concordance2): relevance = 0 topvalue = 0 for word, count in concordance1.iteritems(): if concordance2.has_key(word): topvalue += count * concordance2[word] return topvalue / (self.magnitude(concordance1) * self.magnitude(concordance2))

यह 15 लाइनों में पायथन वेक्टर अंतरिक्ष का कार्यान्वयन है। अनिवार्य रूप से, यह सिर्फ 2 शब्दकोश लेता है और 0 से 1 तक एक संख्या देता है, यह दर्शाता है कि वे कैसे जुड़े हैं। 0 का मतलब है कि वे जुड़े नहीं हैं, लेकिन 1 कि वे समान हैं।

ट्रेनिंग

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

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

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

 from PIL import Image import hashlib import time im = Image.open("captcha.gif") im2 = Image.new("P",im.size,255) im = im.convert("P") temp = {} print im.histogram() for x in range(im.size[1]): for y in range(im.size[0]): pix = im.getpixel((y,x)) temp[pix] = pix if pix == 220 or pix == 227: # these are the numbers to get im2.putpixel((y,x),0) inletter = False foundletter=False start = 0 end = 0 letters = [] for y in range(im2.size[0]): # slice across for x in range(im2.size[1]): # slice down pix = im2.getpixel((y,x)) if pix != 255: inletter = True if foundletter == False and inletter == True: foundletter = True start = y if foundletter == True and inletter == False: foundletter = False end = y letters.append((start,end)) inletter=False # New code is here. We just extract each image and save it to disk with # what is hopefully a unique name count = 0 for letter in letters: m = hashlib.md5() im3 = im2.crop(( letter[0] , 0, letter[1],im2.size[1] )) m.update("%s%s"%(time.time(),count)) im3.save("./%s.gif"%(m.hexdigest())) count += 1

आउटपुट पर, हमें उसी डायरेक्टरी में चित्रों का एक सेट मिलता है। यदि आप कई कैप्चा संसाधित करते हैं, तो उनमें से प्रत्येक को एक अद्वितीय हैश सौंपा गया है।
यहाँ हमारे परीक्षण कैप्चा के लिए इस कोड का परिणाम है:

आप इन छवियों को संग्रहीत करने का निर्णय लेते हैं, लेकिन मैंने उन्हें केवल उसी नाम के साथ एक निर्देशिका में रखा है जो छवि (प्रतीक या संख्या) पर है।

यह सब एक साथ रखना

अंतिम चरण। हमारे पास पाठ निष्कर्षण, चरित्र निष्कर्षण, मान्यता तकनीक और प्रशिक्षण सेट है।

हमें कैप्चा की एक छवि मिलती है, पाठ का चयन करें, वर्ण प्राप्त करें, और फिर हमारे प्रशिक्षण सेट के साथ उनकी तुलना करें। आप इस लिंक पर प्रशिक्षण कार्यक्रम और छोटी संख्या में कैप्चा के साथ अंतिम कार्यक्रम डाउनलोड कर सकते हैं।

यहाँ हम इसके साथ तुलना करने में सक्षम होने के लिए प्रशिक्षण सेट डाउनलोड करते हैं:

 def buildvector(im): d1 = {} count = 0 for i in im.getdata(): d1[count] = i count += 1 return d1 v = VectorCompare() iconset = ['0','1','2','3','4','5','6','7','8','9','0','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t',' u','v','w','x','y','z'] imageset = [] for letter in iconset: for img in os.listdir('./iconset/%s/'%(letter)): temp = [] if img != "Thumbs.db": temp.append(buildvector(Image.open("./iconset/%s/%s"%(letter,img)))) imageset.append({letter:temp})

और फिर सारा जादू हो रहा है। हम यह निर्धारित करते हैं कि प्रत्येक वर्ण कहां है और इसे हमारे वेक्टर स्थान के साथ जांचें। फिर हम परिणामों को क्रमबद्ध करते हैं और उन्हें प्रिंट करते हैं।

 count = 0 for letter in letters: m = hashlib.md5() im3 = im2.crop(( letter[0] , 0, letter[1],im2.size[1] )) guess = [] for image in imageset: for x,y in image.iteritems(): if len(y) != 0: guess.append( ( v.relation(y[0],buildvector(im3)),x) ) guess.sort(reverse=True) print "",guess[0] count += 1

निष्कर्ष

अब हमारे पास सब कुछ है जो हमें चाहिए और हम अपनी चमत्कार मशीन को लॉन्च करने की कोशिश कर सकते हैं।

इनपुट फ़ाइल captcha.gif । अपेक्षित परिणाम: 7s9t9j

 python crack.py (0.96376811594202894, '7') (0.96234028545977002, 's') (0.9286884286888929, '9') (0.98350370609844473, 't') (0.96751165072506273, '9') (0.96989711688772628, 'j')

यहां हम कथित प्रतीक और विश्वास की डिग्री देखते हैं कि यह वास्तव में है (0 से 1 तक)।

ऐसा लगता है कि हम वास्तव में सफल हुए!

वास्तव में, टेस्ट कैप्चा पर यह स्क्रिप्ट लगभग 22% मामलों में एक सफल परिणाम देगा (मुझे 28.5 मिला, लगभग। अनुवाद। )।

 python crack_test.py Correct Guesses - 11.0 Wrong Guesses - 37.0 Percentage Correct - 22.9166666667 Percentage Wrong - 77.0833333333

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

हालांकि, इस तरह के एक बिल्कुल सही एल्गोरिथ्म के साथ, हम ऐसे समय में हर पांचवें कैप्चा को हल कर सकते हैं जहां कोई व्यक्ति एक को हल नहीं कर सकता था।

एक कोर 2 डुओ E6550 पर इस कोड को चलाने से निम्न परिणाम मिलते हैं:

 real 0m5.750s user 0m0.015s sys 0m0.000s

अनुवादक से। मुझे दोहरे कोर T4400 पर निम्नलिखित परिणाम मिले:

 real 0m0.176s user 0m0.160s sys 0m0.012s

हमारी सूची में 48 कैप्चा शामिल हैं, जिसमें से यह निम्न है कि किसी एक को हल करने में लगभग 0.12 सेकंड लगते हैं। हमारी 22% सफलता दर के साथ, हम प्रति दिन लगभग 432,000 कैप्चा हल कर सकते हैं और 95,040 सही परिणाम प्राप्त कर सकते हैं। और अगर आप मल्टीथ्रेडिंग का उपयोग करते हैं?

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

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

पायथन कैप्चा डिकोडिंग