Warum bekomme ich [nan] mit TensorFlow, um eine einfache lineare Regression zu berechnen?

Question

Wenn ich TensorFlow zur Berechnung einer einfachen linearen Regression verwende, bekomme ich [Nan], einschließlich: w, b und Verlust.

Hier ist mein Code:

import tensorflow as tf 

w = tf.Variable(tf.zeros([1]), tf.float32) 
b = tf.Variable(tf.zeros([1]), tf.float32) 
x = tf.placeholder(tf.float32) 
y = tf.placeholder(tf.float32) 

liner = w*x+b 

loss = tf.reduce_sum(tf.square(liner-y)) 

train = tf.train.GradientDescentOptimizer(1).minimize(loss) 

sess = tf.Session() 

x_data = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000] 
y_data = [265000, 324000, 340000, 412000, 436000, 490000, 574000, 585000, 680000]              

sess.run(tf.global_variables_initializer()) 

for i in range(1000): 
    sess.run(train, {x: x_data, y: y_data}) 

nw, nb, nloss = sess.run([w, b, loss], {x: x_data, y: y_data}) 

print(nw, nb, nloss) 

Ausgang:

[ nan] [ nan] nan 

Process finished with exit code 0 

Warum dies geschieht, und wie kann ich es beheben?

Answer 1

Sie sind überfüllt mit einer so hohen Lernrate (1 in Ihrem Fall). Versuchen Sie es mit einer Lernrate von 0,001. Außerdem müssen Ihre Daten durch 1000 geteilt und die Anzahl der Iterationen erhöht werden, und es sollte funktionieren. Dies ist der Code, den ich getestet habe und der perfekt funktioniert.

x_data = [1, 2, 3, 4, 5, 6, 7, 8, 9] 
y_data = [265, 324, 340, 412, 436, 490, 574, 585, 680] 

plt.plot(x_data, y_data, 'ro', label='Original data') 
plt.legend() 
plt.show() 

W = tf.Variable(tf.random_uniform([1], 0, 1)) 
b = tf.Variable(tf.zeros([1])) 
y = W * x_data + b 

loss = tf.reduce_mean(tf.square(y - y_data)) 

optimizer = tf.train.GradientDescentOptimizer(0.001) 
train = optimizer.minimize(loss) 
init = tf.initialize_all_variables() 

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

for step in range(0,50000): 
    sess.run(train) 
    print(step, sess.run(loss)) 
print (step, sess.run(W), sess.run(b)) 

plt.plot(x_data, y_data, 'ro') 
plt.plot(x_data, sess.run(W) * x_data + sess.run(b)) 
plt.legend() 
plt.show() 

Answer 2

Dies gibt die Erklärung, die ich glaube:

for i in range(10): 
    print(sess.run([train, w, b, loss], {x: x_data, y: y_data})) 

das folgende Ergebnis liefert:

[None, array([ 4.70380012e+10], dtype=float32), array([ 8212000.], dtype=float32), 2.0248419e+12] 
[None, array([ -2.68116614e+19], dtype=float32), array([ -4.23342041e+15], dtype=float32), 
6.3058345e+29] 
[None, array([ 1.52826476e+28], dtype=float32), array([ 2.41304958e+24], dtype=float32), inf] [None, array([ 
-8.71110858e+36], dtype=float32), array([ -1.37543819e+33], dtype=float32), inf] 
[None, array([ inf], dtype=float32), array([ inf], dtype=float32), inf] 

Ihre Lernrate einfach zu groß ist, so dass Sie "überkorrigieren" den Wert von w bei jeder Iteration (siehe, da es zwischen negativ und positiv oszilliert, mit steigendem absoluten Wert). Sie erhalten höhere und höhere Werte, bis etwas Unendlich erreicht wird, was Nan-Werte erzeugt. Verringern Sie (viel) die Lernrate.