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

Question

भविष्यवाणी करने के लिए मैं एनएच वर्ग की भविष्यवाणी करने के लिए बहु-परत तंत्रिका नेटवर्क का उपयोग करने की कोशिश कर रहा हूं।

मैं निम्नलिखित प्रशिक्षण पहले 99 वर्गों

1 1 
2 4 
3 9 
4 16 
5 25 
... 
98 9604 
99 9801 

यह युक्त डेटा कोड है:

import numpy as np 
import neurolab as nl 

# Load input data 
text = np.loadtxt('data_sq.txt') 

# Separate it into datapoints and labels 
data = text[:, :1] 
labels = text[:, 1:] 

# Define a multilayer neural network with 2 hidden layers; 
# First hidden layer consists of 10 neurons 
# Second hidden layer consists of 6 neurons 
# Output layer consists of 1 neuron 
nn = nl.net.newff([[0, 99]], [10, 6, 1]) 

# Train the neural network 
error_progress = nn.train(data, labels, epochs=2000, show=10, goal=0.01) 

# Run the classifier on test datapoints 
print('\nTest results:') 
data_test = [[100], [101]] 
for item in data_test: 
    print(item, '-->', nn.sim([item])[0]) 

कौन सा दोनों 100 वें और 101 वें वर्ग के लिए 1 प्रिंट:

Test results: 
[100] --> [ 1.] 
[101] --> [ 1.] 

ऐसा करने का सही तरीका क्या है?

Answer 1

न्यूरोलैब के लिए दस्तावेज़ों की जांच की - newff डिफ़ॉल्ट रूप से सभी न्यूरॉन्स में sigmoid स्थानांतरण फ़ंक्शन के साथ एनएन बनाता है। सिग्मोइड मान हमेशा (-1; 1) रेंज में होता है, इसलिए आपका आउटपुट कभी भी इस श्रेणी को नहीं छोड़ेगा।

दूसरा वर्ग (4) पहले से ही इस सीमा से बाहर है, इसलिए आपका कोड आपकी समस्या से मेल नहीं खाता है।

अन्य कार्यों का उपयोग करने का प्रयास करें (मैं SoftPlus or ReLU का प्रस्ताव दूंगा)। वे फीड-फॉरवर्ड नेटवर्क के साथ काफी अच्छी तरह से काम करते हैं, बैकप्रोपैगेशन प्रशिक्षण की अनुमति देते हैं (क्योंकि वे पूरे डोमेन में व्युत्पन्न होते हैं) और आपकी आवश्यकता के अनुसार (0, ∞) श्रेणी में मान हैं।

इसके अलावा: न्यूफ परिभाषा के लिए पहला पैरा इनपुट डेटा के लिए है - आप [0, 99] का उपयोग कर रहे हैं जो सभी प्रशिक्षण डेटा से मेल खाता है, लेकिन परीक्षण के दौरान आपके द्वारा किए गए मानों से मेल नहीं खाता है (100 और 101 के बाद से) 99 से बड़े हैं)। इस मान को किसी भी तरह से बदलें, इसलिए जिन मानों पर आप परीक्षण करते हैं वे "विशेष" नहीं हैं (जिसका मतलब है "सीमा के अंत में") - मैं [-300, 300] जैसे कुछ का प्रस्ताव दूंगा।

इसके अलावा, जैसा कि एक टिप्पणी में सेनी 123 ने कहा है, मुझे नहीं लगता कि यह बिल्कुल काम करेगा, लेकिन वर्तमान सेटअप के साथ मैं इसके बारे में सुनिश्चित हो सकता हूं। सौभाग्य। यदि आप सफल हुए तो मुझे बताएं (उदाहरण के लिए टिप्पणियों में)।

अंतिम, लेकिन कम से कम नहीं - आप जो करने की कोशिश कर रहे हैं वह एक्स्ट्रापोलेशन (उस सीमा में मूल्यों के आधार पर कुछ सीमाओं के मूल्यों को समझना) है। एनएन इंटरपोलेशन के लिए बेहतर अनुकूल है (उस सीमा से नमूने के आधार पर सीमा में मूल्यों को समझना), क्योंकि उन्हें प्रशिक्षण में उपयोग किए जाने वाले डेटा को सामान्यीकृत करना है। उदाहरण के लिए, प्रत्येक तीसरे वर्ग (इसलिए 1, 16, 4 9, ...) और फिर बाकी के वर्गों के लिए पूछकर परीक्षण करना (उदाहरण के लिए 2 या 8 के वर्ग के लिए पूछना) के वर्गों को पढ़ाने का प्रयास करें।

Answer 2

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

पर

प्रशिक्षण मैं अंतराल पर नेटवर्क प्रशिक्षित [-7,7] (इस अंतराल के अंदर 300 अंक ले, यह निरंतर बनाने के लिए), और फिर आगे अंतराल [यह परीक्षण किया - 30,30]। सक्रियण कार्य ReLu हैं, और नेटवर्क में 3 छिपी हुई परतें हैं, प्रत्येक आकार 50 का है। युग = 500। परिणाम नीचे दिए गए आंकड़े में चित्रित किया गया है।

तो मूल रूप से, अंतराल के अंदर (और करीब भी) [-7,7], फिट काफी सही है, और फिर यह बाहर या नीचे रैखिक रूप से जारी रहता है। यह देखना अच्छा लगता है कि कम से कम शुरुआत में, नेटवर्क के आउटपुट की ढलान x^2 की ढलान "मिलान" करने की कोशिश करती है।,

भी नंबर पर प्रशिक्षण

अंत में अगर बजाय मैं प्रशिक्षित: हम परीक्षण अंतराल बढ़ाते हैं, तो दो रेखांकन काफी एक बहुत वितरित हो जाते हैं, के रूप में एक नीचे आकृति में देख सकते हैं अंतराल में सभी पूर्णांकों के सेट पर नेटवर्क [-100,100], और इसे इस अंतराल में सभी पूर्णांक (यहां तक ​​कि अजीब) के सेट पर लागू करें, मुझे लगता है:

छवि का उत्पादन करने के लिए नेटवर्क को प्रशिक्षण देते समय ऊपर, मैंने युग को 2500 तक बढ़ा दिया बेहतर सटीकता प्राप्त करें। शेष पैरामीटर अपरिवर्तित रहे। तो ऐसा लगता है कि प्रशिक्षण अंतराल "अंदर" इंटरपोलिंग काफी अच्छी तरह से काम करता है (शायद 0 के आसपास के क्षेत्र को छोड़कर, जहां फिट थोड़ा खराब है)।

import tensorflow as tf 
import matplotlib.pyplot as plt 
import numpy as np 
from tensorflow.python.framework.ops import reset_default_graph 

#preparing training data 
train_x=np.linspace(-7,7,300).reshape(-1,1) 
train_y=train_x**2 

#setting network features 
dimensions=[50,50,50,1] 
epochs=500 
batch_size=5 

reset_default_graph() 
X=tf.placeholder(tf.float32, shape=[None,1]) 
Y=tf.placeholder(tf.float32, shape=[None,1]) 

weights=[] 
biases=[] 
n_inputs=1 

#initializing variables 
for i,n_outputs in enumerate(dimensions): 
    with tf.variable_scope("layer_{}".format(i)): 
     w=tf.get_variable(name="W",shape=[n_inputs,n_outputs],initializer=tf.random_normal_initializer(mean=0.0,stddev=0.02,seed=42)) 
     b=tf.get_variable(name="b",initializer=tf.zeros_initializer(shape=[n_outputs])) 
     weights.append(w) 
     biases.append(b) 
     n_inputs=n_outputs 

def forward_pass(X,weights,biases): 
    h=X 
    for i in range(len(weights)): 
     h=tf.add(tf.matmul(h,weights[i]),biases[i]) 
     h=tf.nn.relu(h) 
    return h 

output_layer=forward_pass(X,weights,biases) 
cost=tf.reduce_mean(tf.squared_difference(output_layer,Y),1) 
cost=tf.reduce_sum(cost) 
optimizer=tf.train.AdamOptimizer(learning_rate=0.01).minimize(cost) 


with tf.Session() as sess: 
    sess.run(tf.global_variables_initializer()) 
    #train the network 
    for i in range(epochs): 
     idx=np.arange(len(train_x)) 
     np.random.shuffle(idx) 
     for j in range(len(train_x)//batch_size): 
      cur_idx=idx[batch_size*j:(batch_size+1)*j] 
      sess.run(optimizer,feed_dict={X:train_x[cur_idx],Y:train_y[cur_idx]}) 
     #current_cost=sess.run(cost,feed_dict={X:train_x,Y:train_y}) 
     #print(current_cost) 
    #apply the network on the test data 
    test_x=np.linspace(-30,30,300) 
    network_output=sess.run(output_layer,feed_dict={X:test_x.reshape(-1,1)})  



plt.plot(test_x,test_x**2,color='r',label='y=x^2') 
plt.plot(test_x,network_output,color='b',label='network output') 
plt.legend(loc='center') 
plt.show()