तंत्रिका नेटवर्क बैकप्रोपैगेशन कार्यान्वयन के मुद्दे

Question

मैं न्यूरल नेटवर्क पर काफी कुछ पढ़ रहा हूं और उन्हें here और here से अतिरिक्त पढ़ने के साथ बैकप्रोगैगेशन, मुख्य रूप से this Coursera course के साथ प्रशिक्षण दे रहा हूं। मैंने सोचा कि मेरे पास कोर एल्गोरिदम का एक बहुत ही हल्का समझ था, लेकिन बैकप्रोपैगेशन प्रशिक्षित तंत्रिका नेट बनाने का मेरा प्रयास काफी काम नहीं कर रहा है और मुझे यकीन नहीं है कि क्यों।

कोड सी ++ में है, अभी तक कोई वेक्टरिसेशन नहीं है।

मैं एक साधारण 2 इनपुट न्यूरॉन्स, 1 छुपा न्यूरॉन, 1 आउटपुट न्यूरॉन, नेटवर्क और मॉडल को मॉडल करने के लिए नेटवर्क बनाना चाहता था। यह समझने के लिए कि अवधारणाओं ने एक और जटिल उदाहरण पर जाने से पहले कैसे काम किया था, जब मैं वजन और पूर्वाग्रहों के मूल्यों में कोडित करता हूं तो मेरा आगे प्रचार कोड काम करता है।

float NeuralNetwork::ForwardPropagte(const float *dataInput) 
{ 
     int number = 0; // Write the input data into the input layer 
     for (auto & node : m_Network[0]) 
     { 
      node->input = dataInput[number++]; 
     } 

     // For each layer in the network 
     for (auto & layer : m_Network) 
     { 
      // For each neuron in the layer 
      for (auto & neuron : layer) 
      { 
       float activation; 
       if (layerIndex != 0) 
       { 
        neuron->input += neuron->bias; 
        activation = Sigmoid(neuron->input); 
       } else { 
        activation = neuron->input; 
       } 

       for (auto & pair : neuron->outputNeuron) 
       { 
        pair.first->input += static_cast<float>(pair.second)*activation; 
       } 
      } 
     } 

     return Sigmoid(m_Network[m_Network.size()-1][0]->input); 
} 

इनके कुछ काफी खराब नाम हैं लेकिन मूल रूप से, neuron-> outputNeuron जोड़े का एक वेक्टर है। पहला अगला न्यूरॉन के लिए एक सूचक और दूसरा वजन मूल्य है। न्यूरॉन-> इनपुट तंत्रिका नेटवर्क समीकरण में "z" मान है, सभी wieghts * सक्रियण + bais का योग।

float NeuralNetwork::Sigmoid(float value) const 
{ 
    return 1.0f/(1.0f + exp(-value)); 
} 

इन दोनों के रूप में इरादा काम करने के लिए दिखाई देते हैं: अवग्रह द्वारा दिया जाता है। नेटवर्क पर पास होने के बाद सभी 'z' या 'neuron-> इनपुट' मान शून्य पर रीसेट हो जाते हैं (या बैकप्रोपैगेशन के बाद)।

मैं फिर नीचे psudo-code के बाद नेटवर्क को प्रशिक्षित करता हूं। प्रशिक्षण कोड कई बार चलाया जाता है।

for trainingExample=0 to m // m = number of training examples 
    perform forward propagation to calculate hyp(x) 
    calculate cost delta of last layer 
     delta = y - hyp(x) 
    use the delta of the output to calculate delta for all layers 
    move over the network adjusting the weights based on this value 
    reset network 

वास्तविक कोड यहाँ है:

void NeuralNetwork::TrainNetwork(const std::vector<std::pair<std::pair<float,float>,float>> & trainingData) 
{ 
    for (int i = 0; i < 100; ++i) 
    { 
     for (auto & trainingSet : trainingData) 
     { 
      float x[2] = {trainingSet.first.first,trainingSet.first.second}; 
      float y  = trainingSet.second; 
      float estimatedY = ForwardPropagte(x); 

      m_Network[m_Network.size()-1][0]->error = estimatedY - y; 
      CalculateError(); 
      RunBackpropagation(); 
      ResetActivations(); 
     } 
    } 
} 

backpropagation समारोह के साथ

द्वारा दिए गए:

void NeuralNetwork::RunBackpropagation() 
{ 
    for (int index = m_Network.size()-1; index >= 0; --index) 
    { 
     for(auto &node : m_Network[index]) 
     { 
      // Again where the "outputNeuron" is a list of the next layer of neurons and associated weights 
      for (auto &weight : node->outputNeuron) 
      { 
       weight.second += weight.first->error*Sigmoid(node->input); 
      } 
      node->bias = node->error; // I'm not sure how to adjust the bias, some of the formulas seemed to point to this. Is it correct? 
     } 
    } 
} 

और लागत द्वारा गणना:

void NeuralNetwork::CalculateError() 
{ 
    for (int index = m_Network.size()-2; index > 0; --index) 
    { 
     for(auto &node : m_Network[index]) 
     { 
      node->error = 0.0f; 

      float sigmoidPrime = Sigmoid(node->input)*(1 - Sigmoid(node->input)); 

      for (auto &weight : node->outputNeuron) 
      { 
       node->error += (weight.first->error*weight.second)*sigmoidPrime; 
      } 
     } 
    } 
} 

मैं randomize वजन और डेटा एस पर इसे चलाते हैं एट:

x = {0.0f,0.0f} y =0.0f 
    x = {1.0f,0.0f} y =0.0f 
    x = {0.0f,1.0f} y =0.0f 
    x = {1.0f,1.0f} y =1.0f 

बेशक मैं एक ही डेटा सेट के साथ प्रशिक्षण और परीक्षण नहीं किया जाना चाहिए, लेकिन मैं सिर्फ बुनियादी backpropagation algortithm और चल रहा प्राप्त करना चाहता था। मैं वजन/पूर्वाग्रहों इस प्रकार हैं देख जब मैं इस कोड को चलाएँ:

Layer 0 
    Bias 0.111129 
    NeuronWeight 0.058659 
    Bias -0.037814 
    NeuronWeight -0.018420 
Layer 1 
    Bias 0.016230 
    NeuronWeight -0.104935 
Layer 2 
    Bias 0.080982 

प्रशिक्षण सेट रन और मतलब डेल्टा [outputLayer] की त्रुटि चुकता लग रहा है somthing की तरह:

Error: 0.156954 
Error: 0.152529 
Error: 0.213887 
Error: 0.305257 
Error: 0.359612 
Error: 0.373494 
Error: 0.374910 
Error: 0.374995 
Error: 0.375000 

... remains at this value for ever... 

और अंतिम मीटर पर (वे हमेशा roughtly इस मूल्य पर अंत)

Layer 0 
    Bias 0.000000 
    NeuronWeight 15.385233 
    Bias 0.000000 
    NeuronWeight 16.492933 
Layer 1 
    Bias 0.000000 
    NeuronWeight 293.518585 
Layer 2 
    Bias 0.000000 

मैं स्वीकार करता हूँ इस तंत्रिका नेटवर्क सीखने की काफी एक राउंडअबाउट रास्ते की तरह लग सकता है कि और कार्यान्वयन है (: वजन की तरह लग रहे ओमेंट) बहुत ही अपरिपक्व। लेकिन क्या कोई भी उस बिंदु को खोज सकता है जहां मैं एक अवैध धारणा करता हूं, या तो कार्यान्वयन या सूत्र गलत है?

संपादित

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

Answer 1

मैंने अपनी समस्या हल की (ऊपर प्रारंभिक पूर्वाग्रह/हस्ताक्षरित प्रधान मुद्दे से परे)। वजन घटाने के बजाय, मैंने घटाना शुरू कर दिया। सूत्रों में मैंने देखा कि उनके पास डेल्टा वैल्यू कैलकुलेशन के अंदर एक ऋण चिह्न था जो मेरे पास नहीं है, लेकिन मैंने वजन के लिए अस्वीकृत मूल्य जोड़ने का अपना प्रारूप रखा है। इसके अतिरिक्त, मैं इस बात से परेशान था कि वजन के साथ क्या करना है और एक स्रोत को गलत तरीके से पढ़ना है जो इसे त्रुटि को सौंपने के लिए कहता है। अब मैं अंतर्ज्ञान को सामान्य वजन के रूप में देख रहा हूं लेकिन ज़ेड के बजाय पूर्वाग्रह स्थिरांक द्वारा गुणा कर रहा हूं। प्रशिक्षण सेट पर पुन: प्रयास करने के बाद ~ 1000 बार ओआर और एंड जैसे सरल बिटवाइव एक्सप्रेशन मॉडल कर सकते हैं।

Answer 2

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

इस छवि में आप देख सकते हैं कि पिछले एक को छोड़कर केवल एक पूर्वाग्रह है, जहां पूर्वाग्रह की आवश्यकता नहीं है।

Here you can read तंत्रिका नेटवर्क के लिए एक बहुत ही सहज दृष्टिकोण। यह पायथन में है, लेकिन यह आपको तंत्रिका नेटवर्क की कुछ अवधारणाओं को बेहतर ढंग से समझने में मदद कर सकता है।