🥢 🌯 🍫 PyBrain और PyQt4 (Python3) पर सरल वर्गीकरण 🧓🏼 👨‍👩‍👧‍👦 🕖

Python3 का अध्ययन, मैंने PyBrain लाइब्रेरी को चित्रित किया (जैसा कि मैं कर सकता था)। मैंने यहाँ पहले ही इस बारे में लिखा था।

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

कृत्रिम तंत्रिका नेटवर्क (एएनएन) को बहुत सरल - वर्गीकरण से पहले कार्य निर्धारित किया जाएगा, जिसका नाम है: लैटिन वर्णमाला के अक्षरों की मान्यता।

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

हेब्रैटैट के तहत आपके लिए इंतजार कर रहा है: कैसे PyQt4 पर डेटा तैयार करने का एक विवरण, argparse मॉड्यूल का उपयोग करके, और निश्चित रूप से PyBrain !

हब पर और यहां न केवल लेख पढ़ने के बाद, आप समझते हैं कि एएनएन को लिखना / बनाना / डिज़ाइन करना मुश्किल नहीं है, बल्कि इसके लिए प्रशिक्षण और परीक्षण डेटा का एक सेट तैयार करना मुश्किल है। इसलिए, हमारा कार्य दो उप-प्रकारों में विभाजित है:

प्रशिक्षण के लिए डेटा तैयार करें;
डिजाइन और प्रशिक्षण ANN।

हम इसे उसी क्रम में करेंगे। तो उदय पर बात करने के लिए।

डेटा की तैयारी

संदर्भ की शर्तें

आइए कार्य को स्पष्ट करें: पत्र की छवि के साथ छवि का आकार, कहेंगे, 64 से 64 पिक्सेल (एएनएन से कुल 4096 इनपुट)।
ऐसा करने के लिए, हमें इन चित्रों का एक जनरेटर लिखना होगा। और हम इसे, स्वाभाविक रूप से, अजगर में लिखेंगे।
प्रशिक्षण डेटा में शामिल होंगे:

लोअरकेस लैटिन अक्षर
अपरकेस में लैटिन अक्षर
अक्षर अलग-अलग आकार के हो सकते हैं (वैकल्पिक)
शैली अलग हो सकती है (विभिन्न फोंट का उपयोग किया जा सकता है)

इसके आधार पर, हम एक जनरेटर लिखते हैं जिसमें पैरामीटर इनपुट हैं:

अक्षरों की सूची, जैसे एबीसी या एफएक्स (रेंज)
फ़ॉन्ट आकार 40
फ़ॉन्ट का उपयोग किया गया
उस फ़ोल्डर का पथ जहां उत्पन्न चित्र जोड़े जाएंगे

एक छवि हेरफेर विधि ढूँढना

जनरेटर लिखने के लिए, हमें अजगर में इमेज प्रोसेसिंग विधियों की जानकारी चाहिए। Google ने हमारी बहुत मदद नहीं की। उन्होंने सुझाव दिया कि या तो पायथन इमेजिंग लाइब्रेरी का उपयोग किया जाए - संक्षिप्त जनहित याचिका , या PyGame ।
केवल यहाँ दुर्भाग्य है। पहला केवल python2 के लिए है, और आखिरी रिलीज़ 2009 में थी। हालांकि github.com पर तीसरे पायथन के लिए उनका कांटा है । मैनुअल पढ़ने के बाद, मुझे एहसास हुआ कि सब कुछ इतना सरल नहीं है।
PyGame एक अधिक दिलचस्प विकल्प है, यहां तक कि मैनुअल इसे लंबे समय तक पढ़ता है। मुझे एहसास हुआ कि मुझे विशेष रूप से पुस्तकालय को समझने की आवश्यकता है, लेकिन कुछ भी तस्वीर के साथ नहीं किया जा सकता है। और नाखूनों को हथौड़ा देने के लिए माइक्रोस्कोप का उपयोग करना भी एक विकल्प नहीं है। इसके लिए नहीं कि इस पुस्तकालय का उद्देश्य है।
अभी तक गुगली की। पाइथनमगिक भी है, लेकिन यह केवल यूनिक्स जैसे सिस्टम के लिए है। और फिर यह मुझ पर dawned! PyQt4 !
मैं Qt4 से काफी परिचित हूं, मैंने C ++ / Qt में बहुत कुछ लिखा है। हां, यह लाइब्रेरी स्विस चाकू की तरह है। यदि आप चाहें, तो आप बीयर की एक बोतल खोलेंगे, यदि आप चाहते हैं, तो लकड़ी के टुकड़े से एक सुंदर आकृति काट दी जाएगी। मुख्य बात चाकू का उपयोग करने में सक्षम होना है। Qt और स्टॉप पर।
Habré की खोज ने हमें PyQt पर बहुत कम जानकारी दी। खैर, कोई बात नहीं - हम इसका पता लगाएंगे।

छवि निर्माण और बचत लेखन

पहली बात यह है कि PyQt4 स्थापित है। इसके साथ, मुझे उम्मीद है, पाठक सामना करेंगे - मैं इस पर ध्यान नहीं दूंगा। मैं उपयोग करने के लिए तुरंत पारित कर दूंगा।
हम आवश्यक मॉड्यूल आयात करेंगे और PyQt4 में कार्यक्रम के लिए "मछली" तैयार करेंगे।

#!/usr/bin/env python3 import sys from PyQt4.QtGui import * from PyQt4.Qt import * def main(): app = QApplication([]) # some code here if __name__ == "__main__": sys.exit(main())

app = QApplication([]) साथ लाइन बहुत महत्वपूर्ण है। उसे मत भूलना। मेरे बिना, अजगर SIGFAULT के साथ दुर्घटनाग्रस्त हो जाता है और कोई चेतावनी और त्रुटियां नहीं देता है।

अब "लॉजिक" को वर्किंग लॉजिक से भरें। सहेजें फ़ंक्शन जोड़ें, जो दिए गए मापदंडों के साथ छवि को बचाएगा।

 def save(png_file, letter = 'A', font = "Arial", size = 40, align = Qt.AlignCenter): img = QImage(64,64, QImage.Format_RGB32) img.fill(Qt.white) p = QPainter(img) p.setPen(Qt.black) p.setFont(QFont(font,size)) p.drawText(img.rect(), align, letter) p.end() img.save(png_file)

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

छू मंतर हो गया

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

  p = argparse.ArgumentParser(description='Symbols image generator') p.add_argument('-f','--font', default='Arial', help='Font name, default=Arial') p.add_argument('-s','--size', type=int, default=40, help='Font size, default=40') p.add_argument('-d','--dir', default='.', help='Output directory, default=current') p.add_argument('letters', help='Array of letters(abc) or range (az)') args = p.parse_args()

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

 उपयोग: gen_pic.py [-h] [-f FONT] [-s आकार] [-d DIR] पत्र

 प्रतीक छवि जनरेटर

 स्थिति संबंधी तर्क:
   अक्षरों की संख्या (abc) या रेंज (az)

 वैकल्पिक तर्क:
   -h, --help यह मदद संदेश और बाहर निकलने को दिखाता है
   -f फॉंट, --font फॉंट फ़ॉन्ट नाम, डिफ़ॉल्ट = एरियल
   -S SIZE, - आकार आकार फ़ॉन्ट, डिफ़ॉल्ट = 40
   -d DIR, --dir DIR आउटपुट डायरेक्टरी, डिफ़ॉल्ट = करंट

अब निर्देशिका पथ के अस्तित्व के लिए एक चेक जोड़ें और अक्षरों की सीमा का विस्तार करें। ऐसा करने के लिए, हम नियमित अभिव्यक्ति का उपयोग करते हैं। उन्हें इस मामले में विशेष रूप से ज़रूरत नहीं है, लेकिन कार्यक्रम को अधिक प्रभावशाली बनाना आवश्यक है! इसके लिए हमें os , os.path और re मॉड्यूल की आवश्यकता है।

  if os.path.exists(args.dir): os.mkdir(args.dir) if re.match('^([az]-[az])|([AZ]-[AZ])$', args.letters): begin = args.letters[0] end = args.letters[2] if (ord(end)-ord(begin))>26: print("Error using letters. Only AZ or az available, not Az.") p.print_help() return letters = [chr(a) for a in range(ord(begin),ord(end)+1)] else: letters = args.letters

खैर यहाँ। यह एक चक्र को व्यवस्थित करने और ड्राइंग के बदले सभी अक्षरों को स्थानांतरित करने के लिए बनी हुई है।

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

कुल मिलाकर, पूरे जनरेटर ने हमें केवल 55 लाइनें लीं (कोड लेख के अंत में दिया गया है)। यह महान नहीं है?
और मुझे यकीन है कि अजगर के गुरु को निश्चित रूप से अनुकूलन के लिए बहुत अधिक अवसर मिलेंगे। लेकिन क्यों? सब कुछ काम करता है, कोड काफी सरल और संक्षिप्त है। सीधी आँख आनन्दित करती है।

एएनएन विकास

अब एएनएन पर काम शुरू करते हैं। आरंभ करने के लिए, PyBrain की क्षमताओं से परिचित हों ।

PyBrain और Python3 के बारे में लयात्मक विषयांतर

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

 # FIXME: अगली पंक्ति NaN के उत्पादन से arac रखती है।  मैं नहीं
 # जानते हैं कि ऐसा क्यों है, लेकिन किसी भी तरह से __str__ विधि
 # ndarray वर्ग कुछ ठीक करता है,
 # str (आउटर)

जाहिर तौर पर पायथन 3 में यह हैक काम नहीं किया।

इनपुट पर हमारे पास 0 से 1 तक प्रत्येक पिक्सेल के चमक मूल्यों द्वारा निर्दिष्ट एक छवि (ग्रे टन में) है।
इसके साथ शुरू करने के लिए, हम एक एएनएन बनाएंगे जो कि सीमित अक्षरों और अलग-अलग रजिस्टरों के बिना पहचान करेगा। हम डेटा को एक फ़ॉन्ट के साथ प्रशिक्षित करेंगे और देखेंगे कि नेटवर्क इन अक्षरों को एक अलग फ़ॉन्ट (परीक्षण सेट) के साथ कैसे पहचानता है। उदाहरण के लिए, A, B, C, D, Z अक्षर लें ।

चूँकि हमारा नेटवर्क अक्षर सीखेगा, जिनकी छवियाँ 64 से 64 पिक्सेल आकार की हैं, हमारे नेटवर्क पर इनपुट की संख्या 4096 होगी ।
हमारे पास क्रमशः 5 पहचानने योग्य पत्र होंगे, और नेटवर्क आउटपुट की संख्या पांच है ।
अब सवाल यह है कि क्या हमें छिपी हुई परतों की आवश्यकता है? और यदि हां, तो कितना?
मैंने छिपी परतों के बिना करने का फैसला किया, इसलिए एक नेटवर्क ऑब्जेक्ट बनाने के लिए मैं निम्नलिखित कॉल करता हूं:

 net = buildNetwork(64 * 64, 5)

64 न्यूरॉन्स के आकार के साथ एक छिपी हुई परत बनाने के लिए और छिपी हुई परत सॉफ्टमैक्सलेयर के प्रकार के लिए, आपको निम्नलिखित चीजें बनाने की जरूरत है:

 net = buildNetwork(64 * 64, 8 * 8, 5, hiddenclass=SoftmaxLayer)

दुर्भाग्य से, लेख ने इस फ़ंक्शन के बारे में कहा, लेकिन कोई विवरण नहीं दिया गया था। मैं इस दोष को ठीक करूंगा।

बिल्ड नेटवर्क के बारे में लाइकज़ ()

BuildNetwork () फ़ंक्शन को जल्दी से एक फीडफ़ॉरवर्ड नेटवर्क बनाने के लिए डिज़ाइन किया गया है और इसमें निम्न प्रारूप है:

 pybrain.tools.shortcuts.buildNetwork(*layers, **options)

परतें - पूर्णांकों की एक सूची या टपल जिसमें प्रत्येक परत में न्यूरॉन्स की संख्या होती है
विकल्प " नाम = वैल " के रूप में लिखे गए हैं और इसमें शामिल हैं:
पूर्वाग्रह (डिफ़ॉल्ट = सत्य) - छिपी हुई परतों में ऑफसेट शुरू करें
outputbias (डिफ़ॉल्ट = सत्य) - आउटपुट परत में ऑफसेट शुरू करें
hiddenclass और outclass - क्रमशः छुपी हुई परतों और आउटपुट परत के लिए प्रकार सेट करते हैं। न्यूरॉनलेयर वर्ग का वंशज होना चाहिए। पूर्वनिर्धारित मूल्य गॉसियन लेयर, लिनियरलेयर, एलएसटीएमएलयर, एमडीएलएसटीएमएलयर, सिग्मायॉलेयर, सॉफ्टमैक्सलेयर, तन्हेलर हैं।
यदि आवर्तक ध्वज सेट किया गया है, तो RecurrentNetwork बनाया जाएगा, अन्यथा FeedForwardNetwork।
यदि तेज़ ध्वज सेट किया जाता है, तो तेज़ arac नेटवर्क का उपयोग किया जाएगा, अन्यथा यह अजगर में PyBrain नेटवर्क का अपना कार्यान्वयन होगा।

जो लोग रुचि रखते हैं, वे ब्रेनडैम फ़ाइल में buildNetwork () फ़ंक्शन पर कॉल को सही / अनसुना करके अन्य विकल्प चुन सकते हैं।

ANN प्रशिक्षण

तो, यह प्रशिक्षण लेने का समय है। हमारे कार्यक्रम का उपयोग करते हुए gen_pic.py हम आवश्यक पत्र उत्पन्न करते हैं।
मैंने इसे इस तरह किया:

 ./gen_pic.py -d ./learn -f FreeMono ABCDZ
 /gen_pic.py -d/learn -f Times ABCDZ
 ./gen_pic.py -d ./learn -f Arial ABCDZ
 /gen_pic.py -d/test -f DroidMono ABCDZ
 /gen_pic.py -d/test -f Sans ABCDZ

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

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

 def init_brain(learn_data, epochs, TrainerClass=BackpropTrainer): ... net = buildNetwork(64 * 64, 5, hiddenclass=LinearLayer) # fill dataset with learn data ds = ClassificationDataSet(4096, nb_classes=5, class_labels=['A', 'B', 'C', 'D', 'Z']) for inp, out in learn_data: ds.appendLinked(inp, [trans[out]]) ... ds._convertToOneOfMany(bounds=[0, 1]) ... trainer = TrainerClass(net, verbose=True) trainer.setData(ds) trainer.trainUntilConvergence(maxEpochs=epochs) return net

संक्षेप में समझाएँ कहाँ।
ClassificationDataSet - वर्गीकरण प्रयोजनों के लिए एक विशेष प्रकार का डेटासेट। स्रोत डेटा और वर्ग क्रम संख्या (ट्रांस [आउट]) उसके लिए एक नमूना संकलित करने के लिए पर्याप्त हैं।
_ConvertToOneOfMany () फ़ंक्शन आउटपुट लेयर के मानों में इन्हीं क्लास नंबरों का अनुवाद करता है।
इसके बाद, हम नेटवर्क को "शिक्षक" में स्थानांतरित करते हैं और कहते हैं कि हम अतिरिक्त जानकारी प्रदर्शित करने में रुचि रखते हैं (पुस्तकालय कंसोल पर मध्यवर्ती गणनाओं को प्रिंट करेगा)।
हम शिक्षक को एक प्रशिक्षण सेट (सेटडेटा ()) के साथ एक डेटासेट देते हैं और प्रशिक्षण शुरू करते हैं (trainUntilConvergence ()), जो या तो तब तक प्रशिक्षण देगा जब तक कि नेटवर्क परिवर्तित नहीं होता है, या जब तक कि अधिकतम संख्या में प्रशिक्षण युग नहीं आ जाता है।

निष्कर्ष

तो, लक्ष्य प्राप्त होता है।
कोड लिखा और काम करता है। जेनरेटर, हालांकि, उस नेटवर्क से बहुत अधिक कर सकता है जिसे हमने आज, अपने वर्तमान स्वरूप में बनाया है। लेकिन फिर आपके लिए एक अनपेक्षित क्षेत्र है, प्रिय% उपयोगकर्ता नाम%! ठीक करने के लिए कुछ है, जहां संपादित करना है, क्या फिर से लिखना है ...

मैं जोड़ूंगा कि मैंने दो प्रशिक्षकों - बैकप्रॉपट्रेनर और आरपीप्रोमिनसट्र्रेनर का परीक्षण किया।
बैकप्रॉपट्रेनर एल्गोरिदम की गति खराब है, बहुत धीरे-धीरे परिवर्तित होती है। किस वजह से, प्रशिक्षण में बहुत समय लगता है।
Brain.py में एक लाइन बदलकर आप RPropMinusTrainer को देख सकते हैं। यह बहुत जल्दी है और बहुत अच्छे परिणाम दिखाता है।
मैं यह भी जोड़ूंगा कि मैं प्रशिक्षण सेट के लिए भी 100% मान्यता प्राप्त नहीं कर सका , शायद मुझे प्रत्येक में परतों की संख्या और न्यूरॉन्स की संख्या का चयन करना होगा - मुझे नहीं पता। इस कार्यक्रम में कोई व्यावहारिक समझ नहीं है, लेकिन पायथन 3 सीखने के लिए यह कार्य काफी अच्छा है: यहां आप सूचियों और शब्दकोशों के साथ काम कर सकते हैं, कमांड लाइन मापदंडों की प्रक्रिया कर सकते हैं, छवियों के साथ काम कर सकते हैं, नियमित अभिव्यक्ति कर सकते हैं, फ़ाइल सिस्टम के साथ काम कर सकते हैं (os और os.path मॉड्यूल )।

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

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

आप नीचे दिए गए स्पॉइलर में सोर्स कोड ले सकते हैं।

Gen_pic.py फ़ाइल कोड

 #!/usr/bin/env python3 import sys import argparse import re import os import os.path from PyQt4.QtGui import * from PyQt4.Qt import * def saveWrap(dir='.', letter='A', font="Arial", size=40, align=Qt.AlignCenter): png_file = dir + "/" + font + "_" + letter + "_" + str(size) + ".png" save(png_file, letter, font, size, align) def save(png_file, letter='A', font="Arial", size=40, align=Qt.AlignCenter): img = QImage(64, 64, QImage.Format_RGB32) img.fill(Qt.white) p = QPainter(img) p.setPen(Qt.black) p.setFont(QFont(font, size)) p.drawText(img.rect(), align, letter) p.end() img.save(png_file) def main(): app = QApplication([]) p = argparse.ArgumentParser(description='Symbols image generator') p.add_argument('-f', '--font', default='Arial', help='Font name, default=Arial') p.add_argument('-s', '--size', type=int, default=40, help='Font size, default=40') p.add_argument('-d', '--dir', default='.', help='Output directory, default=current') p.add_argument('letters', help='Array of letters(abc) or range (az)') args = p.parse_args() path = os.path.abspath(args.dir) if not os.path.exists(path): print("Directory not exists, created!") os.makedirs(path) if re.match('^([az]-[az])|([AZ]-[AZ])$', args.letters): begin = args.letters[0] end = args.letters[2] if (ord(end) - ord(begin)) > 26: print("Error using letters. Only AZ or az available, not Az.") p.print_help() return letters = [chr(a) for a in range(ord(begin), ord(end) + 1)] else: letters = args.letters for lett in letters: saveWrap(path, lett, args.font, args.size) return 0 if __name__ == "__main__": sys.exit(main())

ब्रेनडैम फ़ाइल कोड

 #!/usr/bin/env python3 import sys import argparse import re import os import os.path from PyQt4.QtGui import * from PyQt4.Qt import * from pybrain.tools.shortcuts import buildNetwork from pybrain.datasets import ClassificationDataSet from pybrain.structure.modules import SigmoidLayer, SoftmaxLayer, LinearLayer from pybrain.supervised.trainers import BackpropTrainer from pybrain.supervised.trainers import RPropMinusTrainer def init_brain(learn_data, epochs, TrainerClass=BackpropTrainer): if learn_data is None: return None print ("Building network") # net = buildNetwork(64 * 64, 8 * 8, 5, hiddenclass=TanhLayer) # net = buildNetwork(64 * 64, 32 * 32, 8 * 8, 5) net = buildNetwork(64 * 64, 5, hiddenclass=LinearLayer) # fill dataset with learn data trans = { 'A': 0, 'B': 1, 'C': 2, 'D': 3, 'Z': 4 } ds = ClassificationDataSet(4096, nb_classes=5, class_labels=['A', 'B', 'C', 'D', 'Z']) for inp, out in learn_data: ds.appendLinked(inp, [trans[out]]) ds.calculateStatistics() print ("\tNumber of classes in dataset = {0}".format(ds.nClasses)) print ("\tOutput in dataset is ", ds.getField('target').transpose()) ds._convertToOneOfMany(bounds=[0, 1]) print ("\tBut after convert output in dataset is \n", ds.getField('target')) trainer = TrainerClass(net, verbose=True) trainer.setData(ds) print("\tEverything is ready for learning.\nPlease wait, training in progress...") trainer.trainUntilConvergence(maxEpochs=epochs) print("\tOk. We have trained our network.") return net def loadData(dir_name): list_dir = os.listdir(dir_name) list_dir.sort() list_for_return = [] print ("Loading data...") for filename in list_dir: out = [None, None] print("Working at {0}".format(dir_name + filename)) print("\tTrying get letter name.") lett = re.search("\w+_(\w)_\d+\.png", dir_name + filename) if lett is None: print ("\tFilename not matches pattern.") continue else: print("\tFilename matches! Letter is '{0}'. Appending...".format(lett.group(1))) out[1] = lett.group(1) print("\tTrying get letter picture.") out[0] = get_data(dir_name + filename) print("\tChecking data size.") if len(out[0]) == 64 * 64: print("\tSize is ok.") list_for_return.append(out) print("\tInput data appended. All done!") else: print("\tData size is wrong. Skipping...") return list_for_return def get_data(png_file): img = QImage(64, 64, QImage.Format_RGB32) data = [] if img.load(png_file): for x in range(64): for y in range(64): data.append(qGray(img.pixel(x, y)) / 255.0) else: print ("img.load({0}) failed!".format(png_file)) return data def work_brain(net, inputs): rez = net.activate(inputs) idx = 0 data = rez[0] for i in range(1, len(rez)): if rez[i] > data: idx = i data = rez[i] return (idx, data, rez) def test_brain(net, test_data): for data, right_out in test_data: out, rez, output = work_brain(net, data) print ("For '{0}' our net said that it is '{1}'. Raw = {2}".format(right_out, "ABCDZ"[out], output)) pass def main(): app = QApplication([]) p = argparse.ArgumentParser(description='PyBrain example') p.add_argument('-l', '--learn-data-dir', default="./learn", help="Path to dir, containing learn data") p.add_argument('-t', '--test-data-dir', default="./test", help="Path to dir, containing test data") p.add_argument('-e', '--epochs', default="1000", help="Number of epochs for teach, use 0 for learning until convergence") args = p.parse_args() learn_path = os.path.abspath(args.learn_data_dir) + "/" test_path = os.path.abspath(args.test_data_dir) + "/" if not os.path.exists(learn_path): print("Error: Learn directory not exists!") sys.exit(1) if not os.path.exists(test_path): print("Error: Test directory not exists!") sys.exit(1) learn_data = loadData(learn_path) test_data = loadData(test_path) # net = init_brain(learn_data, int(args.epochs), TrainerClass=RPropMinusTrainer) net = init_brain(learn_data, int(args.epochs), TrainerClass=BackpropTrainer) print ("Now we get working network. Let's try to use it on learn_data.") print("Here comes a tests on learn-data!") test_brain(net, learn_data) print("Here comes a tests on test-data!") test_brain(net, test_data) return 0 if __name__ == "__main__": sys.exit(main())

PyBrain के साथ इस परिचित पर आज मुझे लगता है कि खत्म हो गया है। जल्द मिलते हैं!

अद्यतन: नियमित अभिव्यक्ति को निर्धारित अखंड के अनुरोध पर।

PyBrain और PyQt4 (Python3) पर सरल वर्गीकरण