Verlust-Funktion arbeitet mit reduce_mean, aber nicht reduce_sum

Question

Ich bin neu im Tensor-Fluss, und habe die Beispiele here betrachtet. Ich wollte das mehrschichtige Perzeptron-Klassifizierungsmodell als Regressionsmodell umschreiben. Bei der Änderung der Verlustfunktion bin ich jedoch auf seltsames Verhalten gestoßen. Es funktioniert gut mit tf.reduce_mean, aber wenn ich versuche mit tf.reduce_sum gibt es Nan in der Ausgabe. Dies erscheint sehr seltsam, da die Funktionen sehr ähnlich sind - der einzige Unterschied ist, dass der Mittelwert das Summenergebnis durch die Anzahl der Elemente teilt. Ich kann also nicht sehen, wie Nan durch diese Veränderung eingeführt werden könnte.

import tensorflow as tf 

# Parameters 
learning_rate = 0.001 

# Network Parameters 
n_hidden_1 = 32 # 1st layer number of features 
n_hidden_2 = 32 # 2nd layer number of features 
n_input = 2 # number of inputs 
n_output = 1 # number of outputs 

# Make artificial data 
SAMPLES = 1000 
X = np.random.rand(SAMPLES, n_input) 
T = np.c_[X[:,0]**2 + np.sin(X[:,1])] 

# tf Graph input 
x = tf.placeholder("float", [None, n_input]) 
y = tf.placeholder("float", [None, n_output]) 

# Create model 
def multilayer_perceptron(x, weights, biases): 
    # Hidden layer with tanh activation 
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1']) 
    layer_1 = tf.nn.tanh(layer_1) 
    # Hidden layer with tanh activation 
    layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2']) 
    layer_2 = tf.nn.tanh(layer_2) 
    # Output layer with linear activation 
    out_layer = tf.matmul(layer_2, weights['out']) + biases['out'] 
    return out_layer 

# Store layers weight & bias 
weights = { 
    'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])), 
    'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])), 
    'out': tf.Variable(tf.random_normal([n_hidden_2, n_output])) 
} 
biases = { 
    'b1': tf.Variable(tf.random_normal([n_hidden_1])), 
    'b2': tf.Variable(tf.random_normal([n_hidden_2])), 
    'out': tf.Variable(tf.random_normal([n_output])) 
} 

pred = multilayer_perceptron(x, weights, biases) 

# Define loss and optimizer 
#se = tf.reduce_sum(tf.square(pred - y)) # Why does this give nans? 
mse = tf.reduce_mean(tf.square(pred - y)) # When this doesn't? 
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(mse) 

# Initializing the variables 
init = tf.global_variables_initializer() 
sess = tf.Session() 
sess.run(init) 

training_epochs = 10 
display_step = 1 

# Training cycle 
for epoch in range(training_epochs): 
    avg_cost = 0. 
    # Loop over all batches 
    for i in range(100): 
     # Run optimization op (backprop) and cost op (to get loss value) 
     _, msev = sess.run([optimizer, mse], feed_dict={x: X, y: T}) 
    # Display logs per epoch step 
    if epoch % display_step == 0: 
     print("Epoch:", '%04d' % (epoch+1), "mse=", \ 
      "{:.9f}".format(msev)) 

Die problematische Variable se wird als Kommentar gekennzeichnet. Es sollte anstelle von mse verwendet werden.

Mit mse die Ausgabe sieht wie folgt aus:

Epoch: 0001 mse= 0.051669389 
Epoch: 0002 mse= 0.031438075 
Epoch: 0003 mse= 0.026629323 
... 

und mit se endet es wie folgt auf:

Epoch: 0001 se= nan 
Epoch: 0002 se= nan 
Epoch: 0003 se= nan 
... 

Answer 1

Der Verlust für die Charge durch Addition ist 1000-mal größer (aus dem Abschöpfen Code Ich denke, dass Ihre Trainingsstapelgröße 1000) ist, also sind Ihre Steigungen und Parameterupdates auch 1000 Mal größer. Die größeren Updates führen offenbar zu nan s.

Im Allgemeinen werden die Lernraten pro Beispiel angegeben, daher sollte der Verlust, um die Gradienten für Aktualisierungen zu finden, auch pro Beispiel sein. Wenn der Verlust pro Batch ist, muss die Lernrate um die Batchgröße reduziert werden, um vergleichbare Trainingsergebnisse zu erhalten.