डेटा माइनिंग: टूलकिट - थीनो

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

उन कार्यों पर विचार करें जिन्हें हम हल करेंगे, और इसके लिए कौन से उपकरण का उपयोग करना है। पिछले भागों को पढ़ना [ 1 , 2 , 3 ] वांछनीय है, लेकिन आवश्यक नहीं है। स्रोत डेटा जिसे लेखों की श्रृंखला के पिछले हिस्सों के परिणामस्वरूप प्राप्त किया गया था, उसे यहां से लिया जा सकता है [ स्रोत डेटा ]।

कार्य

यदि डेटा के बीच छिपे हुए संबंध हैं, सुविधाओं, संरचनात्मक संबंधों के बीच संबंध, तो इस मामले में इनपुट डेटा के आयाम को कम करने की समस्या उत्पन्न होती है। यह समस्या विशेष रूप से एक स्थिति में स्पष्ट रूप से प्रकट होती है जब बड़ी संख्या में विरल डेटा संसाधित होते हैं।
डेटा की आयामीता को कम करने के तरीकों की तुलना करने के लिए, हम तंत्रिका नेटवर्क संपीड़न (ऑटोकेनोडर) की विधि और प्रमुख घटकों (पीसीए) की विधि पर विचार करने जा रहे हैं।
इस समस्या को हल करने का क्लासिक तरीका प्रमुख घटक विश्लेषण (पीसीए) विधि है। विकिपीडिया इसका अच्छी तरह से वर्णन करता है [ 4 ], एक्सेल में उदाहरणों के साथ साइट पर एक लिंक [ 5 ] भी है, और एक विस्तृत और काफी समझने योग्य विवरण है। यहाँ Habré [ 6 , 7 ] के लेखों के लिंक दिए गए हैं।
एक नियम के रूप में, इनपुट डेटा के आयाम को कम करने के परिणामों की तुलना मुख्य रूप से इस पद्धति को लागू करने के परिणामों से की जाती है।
लेख [ 8 ] बताता है कि एक ऑटो-एनकोडर क्या है और यह कैसे काम करता है, क्योंकि मुख्य सामग्री विशेष रूप से इस दृष्टिकोण के कार्यान्वयन और आवेदन के लिए समर्पित होगी।
बैंगियो और यशुआ ने तंत्रिका नेटवर्क संपीड़न के उपयोग का एक अच्छा और स्पष्ट अवलोकन लिखा है, अगर अचानक किसी को इस दिशा में काम करने के लिए एक ग्रंथ सूची और संदर्भों की आवश्यकता होती है ताकि मौजूदा परिणामों के साथ उनके परिणामों की तुलना की जा सके, [ ९ ] में, धारा ४.ua, पृष्ठ ४ 48-५०।
एक टूलकिट के रूप में, मैंने पायथन और थीनो [ 10 ] का उपयोग करने का फैसला किया। मैंने इस पैकेज की खोज प्रोफेसर जे। हिंटन द्वारा दिए गए लिंक का अध्ययन करते हुए, मशीन लर्निंग के लिए न्यूरल नेटवर्क्स के पाठ्यक्रमों को सुनने के बाद की। इस पैकेज के साथ, "डीप लर्निंग" (गहन शिक्षण तंत्रिका नेटवर्क) के तंत्रिका नेटवर्क कार्यान्वित किए जाते हैं। इस तरह के नेटवर्क, जैसा कि व्याख्यान और लेख में वर्णित है [ 11 , 12 ] ने एंड्रॉइड में Google द्वारा उपयोग किए जाने वाले आवाज मान्यता प्रणाली का आधार बनाया।
कुछ वैज्ञानिकों के अनुसार, तंत्रिका नेटवर्क के निर्माण के लिए यह दृष्टिकोण काफी आशाजनक है, और पहले से ही अच्छे परिणाम दिखाता है। इसलिए, कागल पर समस्याओं को हल करने के लिए इसे लागू करना मेरे लिए दिलचस्प हो गया।
इसके अलावा, deeplearning.net वेबसाइट पर इस विशेष पैकेज के उपयोग से मशीन लर्निंग सिस्टम के कई उदाहरण हैं।

उपकरण

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

• NumPy के साथ घनिष्ठ एकीकरण;
• GPU का पारदर्शी उपयोग;
• चर के प्रभावी भेदभाव;
• तेज और स्थिर अनुकूलन;
• गतिशील सी कोड पीढ़ी;
• उन्नत इकाई परीक्षण और आत्म-परीक्षण क्षमताएं;

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

• निष्पादन की गति का अनुकूलन: थीनो आपकी अभिव्यक्ति के एक हिस्से के GPU या CPU निर्देशों में संकलन करने के लिए g ++ या nvcc का उपयोग कर सकता है, जो शुद्ध पायथन की तुलना में बहुत तेज चलता है;
• चरों की भिन्नता: थियोनो धीरे-धीरे ढाल की गणना के लिए अभिव्यक्ति का निर्माण कर सकती है;
• अनुकूलन स्थिरता: थीनो कुछ संख्यात्मक रूप से गलत अभिव्यक्तियों को पहचान सकता है और अधिक मजबूत एल्गोरिदम का उपयोग करके उनकी गणना कर सकता है

थीनो का निकटतम पैकेज सहानुभूतिपूर्ण है। सिम्पी पैकेज की तुलना मैथेमेटिका से की जा सकती है, जबकि न्यूमप्टी MATLAB पैकेज की तरह है। थीनो एक हाइब्रिड है जिसके डेवलपर्स ने इन दोनों पैकेजों में से सर्वश्रेष्ठ लेने की कोशिश की है।
सबसे अधिक संभावना है, चक्र के दौरान, थीनो को कॉन्फ़िगर करने के तरीके पर एक अलग लेख लिखा जाएगा, तंत्रिका नेटवर्क को प्रशिक्षित करने और स्थापना के दौरान उत्पन्न होने वाली समस्याओं को हल करने के लिए क्यूडीए जीपीयू के उपयोग को कनेक्ट करें।
इस बीच, मेरे लिनक्स स्लैकवेयर 13.37 ऑपरेटिंग सिस्टम में अजगर-2.6, सेटपूलस-0.6c9-py2.6, g ++, अजगर-देव, न्यूमी, साइपी, BLAS स्थापित हैं। अंग्रेजी में सामान्य OS के लिए एक विस्तृत इंस्टालेशन मैनुअल: [ १२ ]।
इससे पहले कि हम डेटा की गतिशीलता को कम करना शुरू करें, हम एक समारोह लिखने के लिए थीनो का उपयोग करने का एक सरल उदाहरण लागू करने का प्रयास करेंगे जो हमें एक समूह को दो भागों में विभाजित करने की हमारी समस्या को हल करने की अनुमति देगा।
डेटा को दो वर्गों में विभाजित करने की एक विधि के रूप में, हम लॉजिस्टिक रिग्रेशन [ 13 ] का उपयोग करते हैं।
नमूना कोड कुछ परिवर्तनों के साथ [ 14 ] पर आधारित है:

import numpy import theano import theano.tensor as T import csv as csv #   csv  csv_file_object = csv.reader(open('./titanik_train_final.csv', 'rb'), delimiter='\t') data=[] # - for row in csv_file_object: #   data.append(row) #    data data = numpy.array(data) #      numpy.array data = data.astype('float') #    float Y = data[:,1] #       Y X = data[:,2:] #           X #   ,   Y csv_file_object = csv.reader(open('./titanik_test_final.csv', 'rb'), delimiter='\t') data_test=[] for row in csv_file_object: data_test.append(row) Tx = numpy.array(data_test) Tx = Tx.astype('float') Tx = Tx[:,1:] #      rng = numpy.random #  N = 891 #  feats = 56 #   training_steps = 10000 #    Theano x = T.matrix("x") y = T.vector("y") w = theano.shared(rng.randn(feats), name="w") b = theano.shared(0., name="b") #  «» Theano p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) #  ,    1 prediction = p_1 > 0.5 #    xent = -y * T.log(p_1) - (1-y) * T.log(1-p_1) #      cost = xent.mean() + 0.01 * (w ** 2).sum() #   gw,gb = T.grad(cost, [w, b]) #    #  «» Theano train = theano.function( inputs=[x,y], outputs=[prediction, xent], updates=((w, w - 0.1 * gw), (b, b - 0.1 * gb))) predict = theano.function(inputs=[x], outputs=prediction) #   for i in range(training_steps): pred, err = train(X, Y) # P = predict(Tx) #   numpy.savetxt('./autoencoder.csv',P,'%i') 

इस कोड में सबसे दिलचस्प लाइनें हैं:

 #  «» Theano p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) #  ,    1 prediction = p_1 > 0.5 #    xent = -y * T.log(p_1) - (1-y) * T.log(1-p_1) #      cost = xent.mean() + 0.01 * (w ** 2).sum() #   gw,gb = T.grad(cost, [w, b]) #    #  «» Theano train = theano.function( inputs=[x,y], outputs=[prediction, xent], updates=((w, w - 0.1 * gw), (b, b - 0.1 * gb))) predict = theano.function(inputs=[x], outputs=prediction) 

यहाँ निम्न होता है (हम इसे अंत से विश्लेषण करेंगे ! ): हमारे पास दो "अभिव्यक्तियाँ" ट्रेन और भविष्यवाणी हैं । वे "संकलित" हैं (यह केवल संकलन नहीं है, लेकिन अध्ययन की शुरुआत में इसे सरल बनाने के लिए बेहतर होगा) एक दृश्य में theano.function का उपयोग करके जिसे तब बुलाया और निष्पादित किया जा सकता है।
पूर्वानुमान के लिए इनपुट पैरामीटर x हैं, और आउटपुट भविष्यवाणी अभिव्यक्ति है, जो p_1> 0.5 है - अर्थात, वह सीमा जो हाँ / नहीं मान लौटाती है, अर्थात, 0 या 1 का मान है। बदले में, अभिव्यक्ति p_1 में चर x के साथ वास्तव में क्या करने की आवश्यकता है, इसकी जानकारी है:

 p_1 = 1 / (1 + T.exp(-T.dot(x, w) - b)) 

जहाँ x, w, b चर हैं, और हम ट्रेन अभिव्यक्ति का उपयोग करके w और b को परिभाषित करते हैं।
ट्रेन के लिए, इनपुट x, y होगा , और आउटपुट भविष्यवाणी और xent होगा । इस मामले में, हम सूत्रों के अनुसार उन्हें अपडेट करते हुए, डब्ल्यू और बी के लिए (इष्टतम मूल्यों के लिए देखें) अपडेट करेंगे

 w-0.1*gw, b-0.1*gb 

जहां gw और gb एक्सटेंट एरर से जुड़े कॉस्टयूम हैं, जो कॉस्ट एक्सप्रेशन के जरिए होते हैं।
और सूत्र द्वारा गणना की गई त्रुटि इस अभिव्यक्ति से प्राप्त होती है:

 xent = -y * T.log(p_1) - (1-y) * T.log(1-p_1) 

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