यह बैकप्रोपैगेशन कार्यान्वयन वजन को सही ढंग से प्रशिक्षित करने में विफल क्यों होता है?

Question

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

जिस समस्या का मैं सामना कर रहा हूं वह अपेक्षाकृत सरल है: तंत्रिका नेटवर्क ट्रेनों के रूप में, इसके वजन को सटीकता में कोई लाभ नहीं होने के साथ शून्य पर प्रशिक्षित किया जा रहा है।

• प्रशिक्षण सेट सही
• लक्ष्य वैक्टर सही
• आगे कदम सही ढंग से जानकारी रिकॉर्ड कर रहा है
• पिछड़े हैं:

  मैं यह सत्यापित करते हुए, यह कई बार ठीक करने के लिए प्रयास किया है चरण डेल्टा ठीक से रिकॉर्ड कर रहे हैं

• डेल्टा पर संकेत सही हैं
• वजन इंडस्ट्रीज हैं समायोजित किया जा रहा eed
• इनपुट परत के डेल्टा सब शून्य
• कोई अन्य त्रुटियों या अतिप्रवाह चेतावनी देखते हैं हैं

कुछ जानकारी:

• प्रशिक्षण आदानों की एक 8x8 ग्रिड हैं [ 0,16) मूल्य तीव्रता का प्रतिनिधित्व करते हैं; इस ग्रिड एक अंक अंकों (एक स्तंभ वेक्टर के लिए परिवर्तित)
• लक्ष्य वेक्टर एक निर्गम कि स्थिति सही संख्या के लिए इसी
• मूल वजन और पूर्वाग्रहों में है 1 गाऊसी वितरण
• द्वारा आवंटित किया जा रहा है का प्रतिनिधित्व करता है सक्रियण एक मानक सिग्मोइड

मुझे यकीन नहीं है कि यहां से कहां जाना है। मैंने सत्यापित किया है कि जिन चीजों को मैं जांचना जानता हूं वे सही तरीके से काम कर रहे हैं, और यह अभी भी काम नहीं कर रहा है, इसलिए मैं यहां पूछ रहा हूं। निम्नलिखित कोड मैं backpropagate लिए उपयोग कर रहा हूँ है:

def backprop(train_set, wts, bias, eta): 
    learning_coef = eta/len(train_set[0]) 

    for next_set in train_set: 
     # These record the sum of the cost gradients in the batch 
     sum_del_w = [np.zeros(w.shape) for w in wts] 
     sum_del_b = [np.zeros(b.shape) for b in bias] 

     for test, sol in next_set: 
      del_w = [np.zeros(wt.shape) for wt in wts] 
      del_b = [np.zeros(bt.shape) for bt in bias] 
      # These two helper functions take training set data and make them useful 
      next_input = conv_to_col(test) 
      outp = create_tgt_vec(sol) 

      # Feedforward step 
      pre_sig = []; post_sig = [] 
      for w, b in zip(wts, bias): 
       next_input = np.dot(w, next_input) + b 
       pre_sig.append(next_input) 
       post_sig.append(sigmoid(next_input)) 
       next_input = sigmoid(next_input) 

      # Backpropagation gradient 
      delta = cost_deriv(post_sig[-1], outp) * sigmoid_deriv(pre_sig[-1]) 
      del_b[-1] = delta 
      del_w[-1] = np.dot(delta, post_sig[-2].transpose()) 

      for i in range(2, len(wts)): 
       pre_sig_vec = pre_sig[-i] 
       sig_deriv = sigmoid_deriv(pre_sig_vec) 
       delta = np.dot(wts[-i+1].transpose(), delta) * sig_deriv 
       del_b[-i] = delta 
       del_w[-i] = np.dot(delta, post_sig[-i-1].transpose()) 

      sum_del_w = [dw + sdw for dw, sdw in zip(del_w, sum_del_w)] 
      sum_del_b = [db + sdb for db, sdb in zip(del_b, sum_del_b)] 

     # Modify weights based on current batch    
     wts = [wt - learning_coef * dw for wt, dw in zip(wts, sum_del_w)] 
     bias = [bt - learning_coef * db for bt, db in zip(bias, sum_del_b)] 

    return wts, bias 

---

शेप के सुझाव, मैं जाँच की क्या में ठीक से जब आकार [2, 1, 1] को हमेशा उत्पादन 1 के एक नेटवर्क के प्रशिक्षण हो रहा है, और वास्तव में, नेटवर्क गाड़ियों उस मामले में। इस बिंदु पर मेरा सबसे अच्छा अनुमान यह है कि ढाल 0s के लिए बहुत दृढ़ता से समायोजित कर रहा है और 1s पर कमजोर है, जिसके परिणामस्वरूप प्रत्येक चरण में वृद्धि के बावजूद शुद्ध कमी आई है - लेकिन मुझे यकीन नहीं है।

Answer 1

मुझे लगता है कि आपकी समस्या शुरुआती वजन की पसंद में है और वजन एल्गोरिदम की शुरुआत के विकल्प में है। Jeff HeatonEncog के लेखक का दावा है कि यह आमतौर पर अन्य प्रारंभिक विधि के बाद खराब होता है। Here वज़न प्रारंभिक एल्गोरिदम परफॉर्मेंस का एक और परिणाम है। अपने अनुभव से भी आपको विभिन्न संकेतों के मूल्यों के साथ अपने वजन को कम करने की सलाह देते हैं। यहां तक ​​कि उन मामलों में जब मेरे पास सभी सकारात्मक आउटपुट वजन होते थे, तो अलग-अलग संकेतों के साथ वजन एक ही संकेत के साथ बेहतर होता था।