एक तंत्रिका नेटवर्क

Question

सीखने के उद्देश्यों के लिए, मैंने एक सरल तंत्रिका नेटवर्क ढांचा लागू किया है जो केवल बहु-परत परिसंचरण और सरल बैकप्रोपैगेशन का समर्थन करता है। यह रैखिक वर्गीकरण के लिए ठीक है -श और सामान्य XOR समस्या के लिए काम करता है, लेकिन साइन फ़ंक्शन सन्निकटन के लिए परिणाम संतोषजनक नहीं हैं।

मैं मूल रूप से 6-10 न्यूरॉन्स वाली एक छिपी हुई परत के साथ साइन फ़ंक्शन की एक अवधि का अनुमान लगाने की कोशिश कर रहा हूं। नेटवर्क छुपा परत के लिए एक सक्रियण समारोह के रूप में हाइपरबॉलिक टेंगेंट का उपयोग करता है और आउटपुट के लिए एक रैखिक कार्य करता है। परिणाम साइन लहर का काफी मोटा अनुमान बना हुआ है और गणना करने में लंबा समय लगता है।

मैं संदर्भ के लिए encog को देखा और लेकिन फिर भी मैं इसे सरल backpropagation के साथ काम (लचीला प्रचार में स्विच करके बेहतर पाने के लिए शुरू होता है, लेकिन अभी भी सुपर चालाक आर in this similar question प्रदान की गई स्क्रिप्ट से जिस तरह से भी बदतर है) प्राप्त करने के लिए असफल हो उस के साथ। तो क्या मैं वास्तव में कुछ ऐसा करने की कोशिश कर रहा हूं जो संभव नहीं है? क्या सरल बैकप्रोपैगेशन (कोई गति नहीं, गतिशील सीखने की दर) के साथ साइन का अनुमान लगाना संभव नहीं है? आर में तंत्रिका नेटवर्क लाइब्रेरी द्वारा उपयोग की जाने वाली वास्तविक विधि क्या है?

संपादित: मुझे पता है कि यह निश्चित रूप से संभव है भी सरल backpropagation के साथ एक अच्छा पर्याप्त सन्निकटन खोजने के लिए (यदि आप अपने प्रारंभिक वजन के साथ अविश्वसनीय रूप से भाग्यशाली हैं), लेकिन मैं वास्तव में अधिक है कि अगर यह है पता करने के लिए दिलचस्पी थी व्यवहार्य दृष्टिकोण। मेरे द्वारा कार्यान्वित आर स्क्रिप्ट को मेरे कार्यान्वयन या यहां तक ​​कि एन्कॉग के लचीले प्रचार की तुलना में इतनी तेजी से और मजबूत रूप से (केवल कुछ सीखने के नमूने के साथ 40 युगों में) अभिसरण लगता है। मैं बस सोच रहा हूं कि क्या ऐसा कुछ है जो मैं अपने बैकप्रोपैगेशन एल्गोरिदम को बेहतर प्रदर्शन करने के लिए कर सकता हूं या क्या मुझे कुछ और उन्नत शिक्षण विधि देखना है?

Answer 1

आप निश्चित रूप से असंभव की कोशिश नहीं कर रहे हैं। न्यूरल नेटवर्क universal approximators कर रहे हैं - जिसका अर्थ है कि किसी भी समारोह एफ और त्रुटि ई के लिए, वहां मौजूद कुछ तंत्रिका नेटवर्क (केवल एक ही छिपी परत की आवश्यकता होगी,) कि ई की तुलना में कम त्रुटि के साथ एफ का अनुमान लगा सकता

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

1. अपने डेटा को दो भागों में विभाजित करें: एक प्रशिक्षण सेट (~ 2/3) और एक परीक्षण सेट (~ 1/3)।
2. प्रशिक्षण सेट में सभी आइटमों पर अपने नेटवर्क को प्रशिक्षित करें।
3. परीक्षण सेट में सभी आइटमों पर अपने नेटवर्क का परीक्षण (लेकिन प्रशिक्षित न करें) और औसत त्रुटि रिकॉर्ड करें।
4. जब तक आप न्यूनतम परीक्षण त्रुटि तक नहीं पहुंच जाते हैं, तब तक चरण 2 और 3 दोहराएं (यह "ओवरफिटिंग" के साथ होता है जब आपका नेटवर्क प्रशिक्षण डेटा पर अन्य सभी चीज़ों के नुकसान के लिए सुपर अच्छा हो जाता है) या जब तक आपकी समग्र त्रुटि समाप्त नहीं हो जाती उल्लेखनीय रूप से कमी (नेटवर्क को जितना अच्छा होगा उतना अच्छा है)।
5. यदि इस बिंदु पर त्रुटि स्वीकार्य रूप से कम है, तो आप कर चुके हैं। यदि नहीं, तो आपका नेटवर्क उस कार्य को संभालने के लिए पर्याप्त जटिल नहीं है जिसके लिए आप इसे प्रशिक्षण दे रहे हैं; अधिक छिपे हुए न्यूरॉन्स जोड़ें और शुरुआत में वापस जाएं ...

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

आशा है कि मदद करता है (और खेद है कि मैं और अधिक उपयोगी नहीं हो सकता)!

पीएस: मुझे यह भी पता है क्योंकि मैंने किसी नेटवर्क के साथ अनुमानित साइन देखा है। मैं कहना है कि वह एक अवग्रह सक्रियण समारोह का उपयोग नहीं कर रहा था चाहते हैं, लेकिन मुझे लगता है कि गिनती पर मेरी स्मृति की गारंटी नहीं दे सकते हैं ...

Answer 2

इस बल्कि आसानी से TensorFlow तरह तंत्रिका नेटवर्क के लिए आधुनिक चौखटे का उपयोग कर कार्यान्वित किया जा सकता।

कोड भी काफी सरल है::

उदाहरण के लिए, एक दो परत तंत्रिका अपने कंप्यूटर पर कुछ ही सेकंड में परत गाड़ियों प्रति 100 न्यूरॉन्स का उपयोग कर नेटवर्क और एक अच्छा सन्निकटन देता

import tensorflow as tf 
import numpy as np 

with tf.name_scope('placeholders'): 
    x = tf.placeholder('float', [None, 1]) 
    y = tf.placeholder('float', [None, 1]) 

with tf.name_scope('neural_network'): 
    x1 = tf.contrib.layers.fully_connected(x, 100) 
    x2 = tf.contrib.layers.fully_connected(x1, 100) 
    result = tf.contrib.layers.fully_connected(x2, 1, 
               activation_fn=None) 

    loss = tf.nn.l2_loss(result - y) 

with tf.name_scope('optimizer'): 
    train_op = tf.train.AdamOptimizer().minimize(loss) 

with tf.Session() as sess: 
    sess.run(tf.global_variables_initializer()) 

    # Train the network 
    for i in range(10000): 
     xpts = np.random.rand(100) * 10 
     ypts = np.sin(xpts) 

     _, loss_result = sess.run([train_op, loss], 
            feed_dict={x: xpts[:, None], 
              y: ypts[:, None]}) 

     print('iteration {}, loss={}'.format(i, loss_result))