11

मैं तंत्रिका नेटवर्क का उपयोग करके इस Kaggle Problem को हल करने का प्रयास कर रहा हूं। मैं पाइब्रेन पायथन लाइब्रेरी का उपयोग कर रहा हूं।छिपी हुई परतों की संख्या, छिपी हुई परतों और युगों में इकाइयां जब तक तंत्रिका नेटवर्क प्रशिक्षण डेटा पर स्वीकार्य व्यवहार शुरू नहीं करता है

यह एक शास्त्रीय पर्यवेक्षित लर्निंग समस्या है। निम्नलिखित कोड में: 'डेटा' वैरिएबल numpy array (892 * 8) है। 7 फ़ील्ड मेरी विशेषताएं हैं और 1 फ़ील्ड मेरा आउटपुट वैल्यू है जो '0' या '1' हो सकता है।

from pybrain.datasets import ClassificationDataSet 
from pybrain.supervised.trainers import BackpropTrainer 
from pybrain.tools.shortcuts import buildNetwork 

dataset = ClassificationDataSet(7,1) 
for i in data: 
    dataset.appendLinked(i[1:],i[0]) 
net = buildNetwork(7,9,7,1, bias = True,hiddenclass = SigmoidLayer, outclass = TanhLayer) 
trainer = BackpropTrainer(net, learningrate = 0.04, momentum = 0.96, weightdecay = 0.02, verbose = True) 
trainer.trainOnDataset(dataset, 8000) 
trainer.testOnData(verbose = True) 

मेरी तंत्रिका नेटवर्क, प्रशिक्षण जब मैं प्रशिक्षण डाटा पर यह परीक्षण कर रहा हूँ, इसके हमेशा सभी आदानों के लिए एक एकल उत्पादन देने के बाद। जैसा:

Testing on data: 
out:  [ 0.075] 
correct: [ 1.000] 
error: 0.42767858 
out:  [ 0.075] 
correct: [ 0.000] 
error: 0.00283875 
out:  [ 0.075] 
correct: [ 1.000] 
error: 0.42744569 
out:  [ 0.077] 
correct: [ 1.000] 
error: 0.42616996 
out:  [ 0.076] 
correct: [ 0.000] 
error: 0.00291185 
out:  [ 0.076] 
correct: [ 1.000] 
error: 0.42664586 
out:  [ 0.075] 
correct: [ 1.000] 
error: 0.42800026 
out:  [ 0.076] 
correct: [ 1.000] 
error: 0.42719380 
out:  [ 0.076] 
correct: [ 0.000] 
error: 0.00286796 
out:  [ 0.076] 
correct: [ 0.000] 
error: 0.00286642 
out:  [ 0.076] 
correct: [ 1.000] 
error: 0.42696969 
out:  [ 0.076] 
correct: [ 0.000] 
error: 0.00292401 
out:  [ 0.074] 
correct: [ 0.000] 
error: 0.00274975 
out:  [ 0.076] 
correct: [ 0.000] 
error: 0.00286129 

मैं इतना के रूप में यह हल है, लेकिन फेरबदल learningRate, weightDecay, गति, छिपा इकाइयों की संख्या, छिपा परतों की संख्या, छिपा परतों के वर्ग, उत्पादन परतों के वर्ग की कोशिश की है हर मामले में यह एक ही देता है यदि इनपुट डेटा से इनपुट आता है तो प्रत्येक इनपुट के लिए आउटपुट।

मुझे लगता है कि मुझे इसे 8000 से अधिक बार चलाया जाना चाहिए क्योंकि जब मैं 'एक्सओआर' के लिए तंत्रिका नेटवर्क का निर्माण कर रहा था, तो इससे पहले नैनो पैमाने पर त्रुटियां देने से पहले कम से कम 700 पुनरावृत्तियों का सामना करना पड़ा। 'एक्सओआर' पर प्रशिक्षण डेटा का आकार केवल 4 था जबकि इस मामले में यह 892 है। इसलिए मैंने मूल डेटा के 10% पर 8000 पुनरावृत्तियों का प्रदर्शन किया (अब प्रशिक्षण डेटा का आकार 89 है), फिर भी यह प्रत्येक इनपुट के लिए एक ही आउटपुट दे रहा था प्रशिक्षण डेटा में। और चूंकि मैं इनपुट '0' या '1' में वर्गीकृत करना चाहता हूं, अगर मैं सॉफ़्टमैक्स होने के लिए आउटपुट परत की कक्षा का उपयोग कर रहा हूं, तो यह हमेशा आउटपुट के रूप में '1' दे रहा है।

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

यह संभव है कि कुछ विन्यास है जो अंत में कम त्रुटि दर उत्पन्न करेगा। कम से कम कुछ विन्यास ताकि वह प्रशिक्षण डेटा में सभी इनपुट के लिए एक ही आउटपुट न दे।

मैंने इसे 80,000 पुनरावृत्ति के लिए चलाया (प्रशिक्षण डेटा आकार 89 है)। आउटपुट नमूना:

Testing on data: 
out:  [ 0.340] 
correct: [ 0.000] 
error: 0.05772102 
out:  [ 0.399] 
correct: [ 0.000] 
error: 0.07954010 
out:  [ 0.478] 
correct: [ 1.000] 
error: 0.13600274 
out:  [ 0.347] 
correct: [ 0.000] 
error: 0.06013008 
out:  [ 0.500] 
correct: [ 0.000] 
error: 0.12497886 
out:  [ 0.468] 
correct: [ 1.000] 
error: 0.14177601 
out:  [ 0.377] 
correct: [ 0.000] 
error: 0.07112816 
out:  [ 0.349] 
correct: [ 0.000] 
error: 0.06100758 
out:  [ 0.380] 
correct: [ 1.000] 
error: 0.19237095 
out:  [ 0.362] 
correct: [ 0.000] 
error: 0.06557341 
out:  [ 0.335] 
correct: [ 0.000] 
error: 0.05607577 
out:  [ 0.381] 
correct: [ 0.000] 
error: 0.07247926 
out:  [ 0.355] 
correct: [ 1.000] 
error: 0.20832669 
out:  [ 0.382] 
correct: [ 1.000] 
error: 0.19116165 
out:  [ 0.440] 
correct: [ 0.000] 
error: 0.09663233 
out:  [ 0.336] 
correct: [ 0.000] 
error: 0.05632861 

औसत त्रुटि: 0,112558819082

('अधिकतम त्रुटि:', .21803000849096299, 'माध्य त्रुटि:', 0,096632332865968451)

यह सीमा के भीतर सभी outputs दे रही है (0.33, 0.5) ।

+1

रिपोर्ट की गई त्रुटि मेल क्यों नहीं है | बाहर-सही | इसके अलावा, क्या आपने 8000 से अधिक पुनरावृत्तियों के लिए प्रशिक्षण की कोशिश की है? आपने कोशिश की छुपी नोड्स की सबसे ज्यादा संख्या क्या है? – Junuxx

+0

मैंने प्रत्येक में 11 नोड्स के साथ 2 छिपी हुई परतों की कोशिश की है। यह 8000 पुनरावृत्तियों तक काम नहीं कर रहा था। अभी मैं 9 और 7 नोड्स के साथ 2 छिपी हुई परतों का उपयोग कर रहा हूं और 80,000 पुनरावृत्ति चला रहा हूं, यह लगभग 3 घंटों तक चल रहा है, परिणाम पूरा होने के बाद रिपोर्ट की रिपोर्ट करेगा, हालांकि कुल त्रुटि को देखते हुए, मुझे वास्तव में नहीं लगता कि यह होगा इससे बेहतर नहीं हो सकता। मुझे खेद है, मुझे नहीं पता कि क्यों त्रुटि की त्रुटि मेल नहीं खा रही है। बाहर-सही | –

+0

मैंने 80,000 पुनरावृत्ति के लिए इसे चलाने के परिणामों के साथ प्रश्न अद्यतन किया है। –

उत्तर

6

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

अच्छे सामान्यीकरण के लिए, वजन की संख्या बहुत कम एनपी/एनई होनी चाहिए, जहां एनपी कई पैटर्न हैं और नयी नेट आउटपुट हैं। बिल्कुल "चर्चा" क्या है, मैं कई बार अंतर बताता हूं, 10 कहें। आपके काम में लगभग 1000 पैटर्न और 1 आउटपुट के लिए यह 100 वजन का संकेत देगा।

2 छिपी हुई परतों का उपयोग करने के लिए यह समझ में नहीं आता है। 1 अधिकांश कार्यों के लिए पर्याप्त है जहां गैर-रैखिकता शामिल है। आपके मामले में, अतिरिक्त छिपी हुई परत समग्र परफॉर्मेंस को प्रभावित करके केवल अंतर बनाती है। तो यदि 1 छिपी हुई परत का उपयोग किया जाता है, तो इसमें न्यूरॉन्स की संख्या अनुमानित की जा सकती है क्योंकि वजन की संख्या इनपुट की संख्या से विभाजित होती है, जो कि 100/7 = 14 है।

मैं हर न्यूरॉन्स, या तो हर जगह हाइपरटान या सिग्मोइड में एक ही सक्रियण समारोह का उपयोग करने का सुझाव देता हूं। आपके आउटपुट मान वास्तव में सिग्मोइड के लिए पहले से ही सामान्यीकृत हैं। वैसे भी, आप सभी डेटा में [0,1] में फ़िट होने के लिए इनपुट डेटा सामान्यीकरण द्वारा एनएन प्रदर्शन में सुधार कर सकते हैं। बेशक, प्रत्येक सुविधा को अपने आप सामान्य करें।

आप Pybrain lib के साथ क्या कर सकते हैं, अधिक से अधिक सीखने की दर के साथ सीखने शुरू हुई और फिर इसे सुचारू रूप से चालू कदम (LR * (N - i)/N), जहां मैं वर्तमान कदम है के लिए आनुपातिक कमी, एन - सीखने की शुरुआती दर - एक सीमा, एलआर है।

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

80000 चरणों में 89 पैटर्न पर नेटवर्क चलाने और आपके परिणामों को प्राप्त करने का तथ्य अजीब है। कृपया, एनएन को सही डेटा पास करने की जांच करें, और कृपया जांचें कि आपके द्वारा प्रदान किए गए त्रुटि मानों का क्या अर्थ है। संभवतः, या तो त्रुटियां, या प्रदर्शित आउटपुट गलत जगह से लिया जाता है। मुझे लगता है कि 89 पैटर के लिए स्वीकार्य परिणाम प्राप्त करने के लिए 10000 कदम काफी दूर होना चाहिए।

विशिष्ट कार्य के लिए, मुझे लगता है कि एसओएम नेट एक और विकल्प हो सकता है (बीपी से बेहतर अनुकूल है)।

एक साइडेनोट के रूप में, मैं पाइब्रेन से परिचित नहीं हूं, लेकिन सी ++ और अन्य भाषाओं में कुछ एनएन कोडित किए हैं, इसलिए आपका समय अत्यधिक बाहरी दिखता है।

+0

मैंने 0.2 की सीखने की दर से शुरुआत की और प्रत्येक पुनरावृत्ति के बाद इसे 20,000 पुनरावृत्तियों के लिए 0.999 से गुणा किया गया, फिर भी आउटपुट समान थे। मैंने फिर से डेटा की जांच की है, यह सही है। –

+0

@ जैकस्मिथ, ठीक है, तो यह कुछ पाइब्रेन विशिष्ट हो सकता है, जो मेरे दायरे से बाहर है। फिर भी आपको यह समझने की कोशिश करनी चाहिए कि त्रुटियां क्या हैं। सॉफ्टमैक्स के बिना शुद्ध बीपी आज़माएं। क्या आपने डेटा सामान्यीकरण इनपुट करने का प्रयास किया था? – Stan

+0

मैं सॉफ़्टमैक्स के बिना पहले सॉफ़्टमैक्स के बिना कोशिश कर रहा था, प्रत्येक आउटपुट '1' है। और सामान्यीकरण काम नहीं किया। –

संबंधित मुद्दे