टेंसरफ्लो एमएलपी एक्सओआर

Question

प्रशिक्षण नहीं दे रहा है मैंने Google के TensorFlow लाइब्रेरी के साथ एक एमएलपी बनाया है। नेटवर्क काम कर रहा है लेकिन किसी भी तरह से यह ठीक से सीखने से इंकार कर देता है। यह हमेशा लगभग 1.0 के आउटपुट में परिवर्तित होता है इससे कोई फर्क नहीं पड़ता कि वास्तव में इनपुट क्या है।

पूरा कोडhere देखा जा सकता है।

कोई विचार?

---

इस प्रकार इनपुट और आउटपुट (बैच का आकार 4) है:

input_data = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]] # XOR input 
output_data = [[0.], [1.], [1.], [0.]] # XOR output 

n_input = tf.placeholder(tf.float32, shape=[None, 2], name="n_input") 
n_output = tf.placeholder(tf.float32, shape=[None, 1], name="n_output") 

---

छिपा परत विन्यास:

# hidden layer's bias neuron 
b_hidden = tf.Variable(0.1, name="hidden_bias") 

# hidden layer's weight matrix initialized with a uniform distribution 
W_hidden = tf.Variable(tf.random_uniform([2, hidden_nodes], -1.0, 1.0), name="hidden_weights") 

# calc hidden layer's activation 
hidden = tf.sigmoid(tf.matmul(n_input, W_hidden) + b_hidden) 

---

आउटपुट परत विन्यास:

W_output = tf.Variable(tf.random_uniform([hidden_nodes, 1], -1.0, 1.0), name="output_weights") # output layer's weight matrix 
output = tf.sigmoid(tf.matmul(hidden, W_output)) # calc output layer's activation 

---

मेरे तरीकों सीखने इस तरह दिखेगा:

cross_entropy = -tf.reduce_sum(n_output * tf.log(output)) 

:

loss = tf.reduce_mean(cross_entropy) # mean the cross_entropy 
optimizer = tf.train.GradientDescentOptimizer(0.01) # take a gradient descent for optimizing 
train = optimizer.minimize(loss) # let the optimizer train 

मैं पार एन्ट्रापी के लिए दोनों सेट अप करने की कोशिश की 10

और

cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(n_output, output) 

जहां n_output मूल उत्पादन मेरे नेटवर्क द्वारा output_data और output भविष्यवाणी/गणना की मूल्य में वर्णित है।

---

अंदर के लिए लूप (एन अवधियों के लिए) इस प्रकार है प्रशिक्षण:

cvalues = sess.run([train, loss, W_hidden, b_hidden, W_output], 
        feed_dict={n_input: input_data, n_output: output_data}) 

मैं loss, W_hidden की डिबग printig के लिए cvalues ​​के परिणाम की बचत कर रहा हूँ, ...

---

कोई फर्क नहीं पड़ता कि मैं क्या कोशिश की है, जब मैं अपने नेटवर्क का परीक्षण, उत्पादन मान्य करने के लिए कोशिश कर रहा है, यह हमेशा कुछ lik का उत्पादन ई इस:

(...) 
step: 2000 
loss: 0.0137040186673 
b_hidden: 1.3272010088 
W_hidden: [[ 0.23195425 0.53248233 -0.21644847 -0.54775208 0.52298909] 
[ 0.73933059 0.51440752 -0.08397482 -0.62724304 -0.53347367]] 
W_output: [[ 1.65939867] 
[ 0.78912479] 
[ 1.4831928 ] 
[ 1.28612828] 
[ 1.12486529]] 

(--- finished with 2000 epochs ---) 

(Test input for validation:) 

input: [0.0, 0.0] | output: [[ 0.99339396]] 
input: [0.0, 1.0] | output: [[ 0.99289012]] 
input: [1.0, 0.0] | output: [[ 0.99346077]] 
input: [1.0, 1.0] | output: [[ 0.99261558]] 

तो यह नहीं ठीक से सीखने लेकिन हमेशा लगभग 1.0 कोई फर्क नहीं पड़ता जो इनपुट तंग आ गया है करने के लिए converging है।

Answer 1

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

यह एक AdamOptimizer जो त्रुटि एक GradientDescentOptimizer की तुलना में बहुत तेजी से कम हो जाती है का उपयोग करता है। अधिक जानकारी के लिए this post देखें (& प्रश्न ^^) अनुकूलक के बारे में।

असल में, मेरा नेटवर्क केवल 400-800 सीखने के चरणों में उचित परिणाम देता है।

2000 सीखने के बाद कदम उत्पादन लगभग "सही" है:

step: 2000 
loss: 0.00103311243281 

input: [0.0, 0.0] | output: [[ 0.00019799]] 
input: [0.0, 1.0] | output: [[ 0.99979786]] 
input: [1.0, 0.0] | output: [[ 0.99996307]] 
input: [1.0, 1.0] | output: [[ 0.00033751]] 

---

import tensorflow as tf  

##################### 
# preparation stuff # 
##################### 

# define input and output data 
input_data = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]] # XOR input 
output_data = [[0.], [1.], [1.], [0.]] # XOR output 

# create a placeholder for the input 
# None indicates a variable batch size for the input 
# one input's dimension is [1, 2] and output's [1, 1] 
n_input = tf.placeholder(tf.float32, shape=[None, 2], name="n_input") 
n_output = tf.placeholder(tf.float32, shape=[None, 1], name="n_output") 

# number of neurons in the hidden layer 
hidden_nodes = 5 


################ 
# hidden layer # 
################ 

# hidden layer's bias neuron 
b_hidden = tf.Variable(tf.random_normal([hidden_nodes]), name="hidden_bias") 

# hidden layer's weight matrix initialized with a uniform distribution 
W_hidden = tf.Variable(tf.random_normal([2, hidden_nodes]), name="hidden_weights") 

# calc hidden layer's activation 
hidden = tf.sigmoid(tf.matmul(n_input, W_hidden) + b_hidden) 


################ 
# output layer # 
################ 

W_output = tf.Variable(tf.random_normal([hidden_nodes, 1]), name="output_weights") # output layer's weight matrix 
output = tf.sigmoid(tf.matmul(hidden, W_output)) # calc output layer's activation 


############ 
# learning # 
############ 
cross_entropy = -(n_output * tf.log(output) + (1 - n_output) * tf.log(1 - output)) 
# cross_entropy = tf.square(n_output - output) # simpler, but also works 

loss = tf.reduce_mean(cross_entropy) # mean the cross_entropy 
optimizer = tf.train.AdamOptimizer(0.01) # take a gradient descent for optimizing with a "stepsize" of 0.1 
train = optimizer.minimize(loss) # let the optimizer train 


#################### 
# initialize graph # 
#################### 
init = tf.initialize_all_variables() 

sess = tf.Session() # create the session and therefore the graph 
sess.run(init) # initialize all variables 

##################### 
# train the network # 
##################### 
for epoch in xrange(0, 2001): 
    # run the training operation 
    cvalues = sess.run([train, loss, W_hidden, b_hidden, W_output], 
         feed_dict={n_input: input_data, n_output: output_data}) 

    # print some debug stuff 
    if epoch % 200 == 0: 
     print("") 
     print("step: {:>3}".format(epoch)) 
     print("loss: {}".format(cvalues[1])) 
     # print("b_hidden: {}".format(cvalues[3])) 
     # print("W_hidden: {}".format(cvalues[2])) 
     # print("W_output: {}".format(cvalues[4])) 


print("") 
print("input: {} | output: {}".format(input_data[0], sess.run(output, feed_dict={n_input: [input_data[0]]}))) 
print("input: {} | output: {}".format(input_data[1], sess.run(output, feed_dict={n_input: [input_data[1]]}))) 
print("input: {} | output: {}".format(input_data[2], sess.run(output, feed_dict={n_input: [input_data[2]]}))) 
print("input: {} | output: {}".format(input_data[3], sess.run(output, feed_dict={n_input: [input_data[3]]}))) 

Answer 2

मैं टिप्पणी नहीं कर सकता क्योंकि मेरे पास पर्याप्त प्रतिष्ठा नहीं है लेकिन मेरे पास उस उत्तर में कुछ प्रश्न हैं। $ L_2 $ हानि फ़ंक्शन समझ में आता है क्योंकि यह मूल रूप से एमएसई फ़ंक्शन है, लेकिन क्रॉस-एन्ट्रॉपी काम क्यों नहीं करेगा? निश्चित रूप से अन्य एनएन libs के लिए काम करता है।दूसरी बात यह है कि दुनिया में क्यों आपकी इनपुट स्पेस $ 0 [0,1] -> [-1,1] $ से विशेष रूप से से प्रभावित होती है क्योंकि आपने पूर्वाग्रह वैक्टर जोड़े हैं।

संपादित यह एक समाधान किसी भी अतिरिक्त एन्कोडिंग या किसी अजीब लक्ष्य मूल्य के बिना क्रोस एंट्रोपी उपयोग करने के लिए पार एन्ट्रापी और एक गर्म अनेक स्रोतों से संकलित कोड का उपयोग कर संपादित करें^2 बदल स्थानांतरण है

import math 
import tensorflow as tf 
import numpy as np 

HIDDEN_NODES = 10 

x = tf.placeholder(tf.float32, [None, 2]) 
W_hidden = tf.Variable(tf.truncated_normal([2, HIDDEN_NODES])) 
b_hidden = tf.Variable(tf.zeros([HIDDEN_NODES])) 
hidden = tf.nn.relu(tf.matmul(x, W_hidden) + b_hidden) 

W_logits = tf.Variable(tf.truncated_normal([HIDDEN_NODES, 1])) 
b_logits = tf.Variable(tf.zeros([1])) 
logits = tf.add(tf.matmul(hidden, W_logits),b_logits) 


y = tf.nn.sigmoid(logits) 


y_input = tf.placeholder(tf.float32, [None, 1]) 



loss = -(y_input * tf.log(y) + (1 - y_input) * tf.log(1 - y)) 

train_op = tf.train.GradientDescentOptimizer(0.01).minimize(loss) 

init_op = tf.initialize_all_variables() 

sess = tf.Session() 
sess.run(init_op) 

xTrain = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) 


yTrain = np.array([[0], [1], [1], [0]]) 


for i in xrange(2000): 
    _, loss_val,logitsval = sess.run([train_op, loss,logits], feed_dict={x: xTrain, y_input: yTrain}) 

    if i % 10 == 0: 
    print "Step:", i, "Current loss:", loss_val,"logits",logitsval 

print "---------" 
print sess.run(y,feed_dict={x: xTrain})