🎅 😴 🏑 कैप्चा कैसे बायपास करें: टेंसोरफ्लो, केरस, पायथन वी न्यूमेरिक नॉइज़ कैप्चा पर न्यूरल नेटवर्क 🛑 🔚 🈂️

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

साथ ही, अभ्यास में एक सरल तंत्रिका नेटवर्क के काम को समझें, और इसके परिणामों को भी सुधारें।

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

चूल्हे से नाचना। ज्वाइन करने के बजाय

शायद किसी के शब्दों को दोहराया जाएगा, लेकिन डीप लर्निंग पर अधिकांश पुस्तकें वास्तव में इस तथ्य से शुरू होती हैं कि पाठक को पहले से तैयार डेटा की पेशकश की जाती है जिसके साथ वह काम करना शुरू करता है। किसी तरह MNIST - 60,000 हस्तलिखित अंक, CIFAR-10, आदि। पढ़ने के बाद, एक व्यक्ति तैयार हो जाता है ... इन डेटा सेटों के लिए। यह पूरी तरह से स्पष्ट नहीं है कि अपने डेटा का उपयोग कैसे करें और सबसे महत्वपूर्ण बात यह है कि अपने स्वयं के तंत्रिका नेटवर्क का निर्माण करते समय कुछ कैसे सुधारें।

यही कारण है कि pyimagesearch.com पर लेख आपके अपने डेटा के साथ-साथ इसके अनुवाद के साथ कैसे काम करता है , इस बारे में बहुत काम आया।

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

हम कैप्चा पर डेटा एकत्र करते हैं

यहां कुछ नया नहीं है। हमें कैप्चा सैंपल की जरूरत है नेटवर्क हमारे मार्गदर्शन में उनसे सीखेगा। आप खुद कैप्चा को माइन कर सकते हैं, या आप यहां थोड़ा ले सकते हैं - 29,000 कैप्चा । अब आपको प्रत्येक कैप्चा से संख्याओं को काटने की आवश्यकता है। सभी 29,000 कैप्चा में कटौती करना आवश्यक नहीं है, खासकर जब से 1 कैप्चा 5 अंक देता है। 500 कैप्चा पर्याप्त से अधिक होगा।

कैसे कटेगी? फ़ोटोशॉप में यह संभव है, लेकिन बेहतर चाकू रखना बेहतर है।

तो यहाँ अजगर चाकू कोड है - डाउनलोड करें । (विंडोज के लिए। पहले फोल्डर बनाएं C: \ 1 \ test और C: \ 1 \ test-out)।
आउटपुट 1 से 9 तक संख्याओं का एक डंप होगा (कैप्चा में कोई शून्य नहीं हैं)।
इसके बाद, आपको इस रुकावट को 1 से 9 तक के फोल्डर में नंबर से पार्स करना होगा और प्रत्येक फोल्डर में इसी नंबर से डालना होगा। इतने पर कब्जा। लेकिन एक दिन में आप 1000 अंक तक बना सकते हैं।

यदि, संख्या चुनते समय, यह संदिग्ध है कि कौन सी संख्या है, इस नमूने को हटाना बेहतर है। और यह ठीक है अगर संख्या शोर या अपूर्ण रूप से "फ्रेम" दर्ज करें:

आपको प्रत्येक फ़ोल्डर में प्रत्येक अंक के 200 नमूने एकत्र करने की आवश्यकता है। आप इस कार्य को तृतीय-पक्ष सेवाओं में सौंप सकते हैं, लेकिन यह सब कुछ स्वयं करना बेहतर है ताकि आप बाद में गलत तरीके से मिलान किए गए नंबरों की तलाश न करें।

तंत्रिका नेटवर्क। कसौटी

टायट, टायट, हमारे जालों ने मृत व्यक्ति को खींच लिया

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

हम एक साधारण नेटवर्क का उपयोग करेंगे जिसका लॉन्च सिंटैक्स कमांड (!) लाइन से है:

python train_simple_nn.py --dataset animals --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png

* Tensorflow अपनी फ़ाइलों और अप्रचलित तरीकों में त्रुटियों के बारे में काम करते हुए लिख सकता है, आप इसे हाथ से ठीक कर सकते हैं, या आप इसे अनदेखा कर सकते हैं।

मुख्य बात यह है कि कार्यक्रम के बाहर काम करने के बाद, प्रोजेक्ट प्रोजेक्ट फ़ोल्डर में दो फाइलें दिखाई देती हैं: simple_nn_lb.pickle और simple_nn.model, और एक शिलालेख और मान्यता दर वाले जानवर की छवि प्रदर्शित की जाती है, उदाहरण के लिए:

तंत्रिका नेटवर्क - अपना डेटा

अब जब नेटवर्क स्वास्थ्य परीक्षण सत्यापित हो गया है, तो आप अपना डेटा कनेक्ट कर सकते हैं और नेटवर्क को प्रशिक्षित करना शुरू कर सकते हैं।

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

 python train_simple_nn.py --dataset dat --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png

हालाँकि, प्रशिक्षण शुरू करना बहुत जल्दी है।

आपको train_simple_nn.py फ़ाइल को ठीक करना होगा।

1. फ़ाइल के बहुत अंत में:

 #model.summary() score = model.evaluate(testX, testY, verbose=1) print("\nTest score:", score[0]) print('Test accuracy:', score[1])

यह जानकारी जोड़ देगा।

2।

 image = cv2.resize(image, (32, 32)).flatten()

को बदलो

 image = cv2.resize(image, (16, 37)).flatten()

यहां हम इनपुट इमेज का आकार बदलते हैं। वास्तव में यह आकार क्यों? क्योंकि अधिकतर कटा हुआ अंक या तो इस आकार का होता है या इसे घटा दिया जाता है। यदि आप 32x32 पिक्सेल स्केल करते हैं, तो चित्र विकृत हो जाएगा। हाँ, और यह क्यों?

इसके अलावा, हम इस बदलाव को कोशिश में धकेल देते हैं:

 try: image = cv2.resize(image, (16, 37)).flatten() except: continue

क्योंकि कार्यक्रम कुछ चित्रों और मुद्दों को पचा नहीं सकता है, इसलिए उन्हें छोड़ दिया जाता है।

3. अब सबसे महत्वपूर्ण बात। जहां कोड में एक टिप्पणी है

केरेस के साथ आर्किटेक्चर 3072-1024-512-3 को परिभाषित करें

लेख में नेटवर्क आर्किटेक्चर को 3072-1024-512-3 के रूप में परिभाषित किया गया है। इसका मतलब है कि नेटवर्क को इनपुट पर 3072 (32 पिक्सल * 32 पिक्सल * 3) प्राप्त होता है, फिर 1024 परत, 512 और आउटपुट 3 विकल्प - एक बिल्ली, एक कुत्ता या एक पांडा।

हमारे मामले में, इनपुट 1776 (16 पिक्सेल * 37 पिक्सल * 3) है, फिर 1024, परत 512, संख्याओं के 9 वेरिएंट के आउटपुट पर।

इसलिए हमारा कोड:

 model.add(Dense(1024, input_shape=(1776,), activation="sigmoid"))model.add(Dense(512, activation="sigmoid"))

* 9 आउटपुट को अतिरिक्त रूप से इंगित करने की आवश्यकता नहीं है, क्योंकि कार्यक्रम स्वयं डेटासेट में फ़ोल्डर्स की संख्या से बाहर निकलने की संख्या निर्धारित करता है।

हम लॉन्च करते हैं

 python train_simple_nn.py --dataset dat --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --plot output/simple_nn_plot.png

चूंकि संख्याओं के साथ चित्र छोटे होते हैं, नेटवर्क केवल सीपीयू का उपयोग करके, कमजोर हार्डवेयर पर भी बहुत जल्दी (5-10 मिनट) सीखता है।

कमांड लाइन में प्रोग्राम चलाने के बाद, परिणाम देखें:

इसका मतलब यह है कि प्रशिक्षण सेट पर, निष्ठा हासिल की गई थी - 82.19%, नियंत्रण पर - 75.6% और परीक्षण पर - 75.59%।

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

चलो तंत्रिका नेटवर्क के काम का ग्राफिक हिस्सा भी देखते हैं। यह simple_nn_plot.png प्रोजेक्ट के आउटपुट फ़ोल्डर में है:

तेज, उच्चतर, मजबूत। परिणाम में सुधार

एक तंत्रिका नेटवर्क स्थापित करने के बारे में थोड़ा सा, यहां देखें।

प्रामाणिक विकल्प निम्नानुसार है।

युग जोड़ें।
कोड में हम बदलते हैं

 EPOCHS = 75

पर

 EPOCHS = 200

"समय की संख्या" बढ़ाएं जो नेटवर्क प्रशिक्षण से गुजरना होगा।

परिणाम:

इस प्रकार, 93.5%, 92.6%, 92.6%।

तस्वीरों में:

यहां यह ध्यान देने योग्य है कि 130 वें युग के बाद की नीली और लाल रेखाएं एक-दूसरे से फैलने लगती हैं और यह कहती है कि युगों की संख्या में और वृद्धि नहीं होगी। इसे देखें।

कोड में हम बदलते हैं

 EPOCHS = 200

पर

 EPOCHS = 500

और फिर से भाग जाओ।

परिणाम:

तो हमारे पास है:
99%, 95.5%, 95.5%।

और ग्राफ पर:

खैर, युगों की संख्या में वृद्धि स्पष्ट रूप से नेट पर चली गई है। हालांकि, यह परिणाम भ्रामक है।

आइए एक वास्तविक उदाहरण का उपयोग करके नेटवर्क ऑपरेशन की जांच करें।

इन उद्देश्यों के लिए, प्रॉजेक्ट फोल्डर में पूर्वानुमेय स्क्रिप्ट है। शुरू करने से पहले, तैयारी करें।

प्रोजेक्ट के इमेज फ़ोल्डर में, हमने फाइलों को कैप्चा के नंबरों की छवियों के साथ रखा है, जो नेटवर्क को सीखने की प्रक्रिया में पहले नहीं मिला था। यानी यह डेटासेट डेटासेट से अंक नहीं लेना आवश्यक है।

फ़ाइल में ही, हम डिफ़ॉल्ट छवि के आकार के लिए दो लाइनें तय करते हैं:

 ap.add_argument("-w", "--width", type=int, default=16, help="target spatial dimension width") ap.add_argument("-e", "--height", type=int, default=37, help="target spatial dimension height")

कमांड लाइन से चलाएं:

 python predict.py --image images/1.jpg --model output/simple_nn.model --label-bin output/simple_nn_lb.pickle --flatten 1

और हम परिणाम देखते हैं:

एक और तस्वीर:

हालाँकि, यह सभी शोर संख्याओं के साथ काम नहीं करता है:

यहां क्या किया जा सकता है?

प्रशिक्षण के लिए फ़ोल्डर्स में संख्याओं की प्रतियों की संख्या बढ़ाएँ।
अन्य तरीकों का प्रयास करें।

आइए अन्य तरीकों की कोशिश करें

जैसा कि आप पिछले ग्राफ से देख सकते हैं, नीले और लाल रंग की रेखाएं 130 वें युग के आसपास दिखाई देती हैं। इसका मतलब है कि 130 वें युग के बाद सीखना अप्रभावी है। हम 130 वें युग: 89.3%, 88%, 88% पर परिणाम को ठीक करते हैं और देखते हैं कि नेटवर्क के काम को बेहतर बनाने के अन्य तरीके हैं या नहीं।

सीखने की गति कम करें।

 INIT_LR = 0.01

पर

 INIT_LR = 0.001

परिणाम:
41%, 39%, 39%

खैर, द्वारा

एक अतिरिक्त छिपी परत जोड़ें।

 model.add(Dense(512, activation="sigmoid"))

पर

 model.add(Dense(512, activation="sigmoid")) model.add(Dense(258, activation="sigmoid"))

परिणाम:
56%, 62%, 62%

बेहतर है, लेकिन नहीं।

हालाँकि, यदि आप युगों की संख्या बढ़ाकर 250:
84%, 83%, 83%

इसी समय, लाल और नीले रंग की रेखाएं 130 वें युग के बाद एक दूसरे से दूर नहीं होती हैं:

२५० युग बचाएं और थिनिंग लागू करें :

 from keras.layers.core import Dropout

परतों के बीच थिनिंग डालें:

 model.add(Dense(1024, input_shape=(1776,), activation="sigmoid")) model.add(Dropout(0.3)) model.add(Dense(512, activation="sigmoid")) model.add(Dropout(0.3)) model.add(Dense(258, activation="sigmoid")) model.add(Dropout(0.3))

परिणाम:
53%, 65%, 65%

पहला मूल्य बाकी की तुलना में कम है, यह इंगित करता है कि नेटवर्क सीख नहीं रहा है। ऐसा करने के लिए, युगों की संख्या बढ़ाने की सिफारिश की जाती है।

 model.add(Dense(1024, input_shape=(1776,), activation="sigmoid")) model.add(Dropout(0.3)) model.add(Dense(512, activation="sigmoid")) model.add(Dropout(0.3))

परिणाम:
88%, 92%, 92%

1 अतिरिक्त परत के साथ, पतला और 500 युग:

 model.add(Dense(1024, input_shape=(1776,), activation="sigmoid")) model.add(Dropout(0.3)) model.add(Dense(512, activation="sigmoid")) model.add(Dropout(0.3)) model.add(Dense(258, activation="sigmoid"))

परिणाम:
92.4%, 92.6%, 92.58%

युगों में 500 में एक साधारण वृद्धि की तुलना में कम प्रतिशत के बावजूद, ग्राफ और भी अधिक दिखता है:

और नेटवर्क उन छवियों को संसाधित करता है जो पहले बाहर गिर गई थीं:

अब हम सब कुछ एक फाइल में एकत्र करेंगे, जो कैप्चा के साथ छवि को 5 अंकों में काट देगा, प्रत्येक अंक को न्यूरल नेटवर्क के माध्यम से चलाएगा और परिणाम को अजगर इंटरप्रेटर में बदल देगा।

यह यहाँ सरल है उस फ़ाइल में जो हमें कैप्चा से संख्याओं को काटती है, उस फ़ाइल को जोड़ें जो भविष्यवाणियों से संबंधित है।

अब कार्यक्रम न केवल कैप्चा को 5 भागों में काटता है, बल्कि दुभाषिया में सभी मान्यता प्राप्त संख्याओं को भी प्रदर्शित करता है:

फिर, यह ध्यान में रखना होगा कि कार्यक्रम 100% परिणाम नहीं देता है और अक्सर 5 अंकों में से एक गलत होता है। लेकिन यह एक अच्छा परिणाम है, यह देखते हुए कि प्रशिक्षण सेट में प्रत्येक संख्या के लिए केवल 170-200 प्रतियां हैं।

कैप्चा मान्यता एक मध्यम-शक्ति वाले कंप्यूटर पर 3-5 सेकंड तक रहती है।

आप नेटवर्क को बेहतर बनाने के लिए और कैसे प्रयास कर सकते हैं? आप "केरेस लाइब्रेरी - डीप लर्निंग टूल" ए। धज़ुल्ली, एस। पाला नामक पुस्तक में पढ़ सकते हैं।

अंतिम स्क्रिप्ट जो कैप्चा को काटती है और पहचानती है।
यह मापदंडों के बिना शुरू होता है।
नेटवर्क के प्रशिक्षण और परीक्षण के लिए पुनर्नवीनीकरण स्क्रिप्ट।
परीक्षण के लिए कैप्चा, झूठी सकारात्मक सहित - यहाँ ।
काम के लिए मॉडल यहाँ है ।
फ़ोल्डर्स में नंबर यहाँ हैं ।

कैप्चा कैसे बायपास करें: टेंसोरफ्लो, केरस, पायथन वी न्यूमेरिक नॉइज़ कैप्चा पर न्यूरल नेटवर्क