Seltsame NaN-Werte für Verlustfunktion (MLP) in TensorFlow

Question

Ich hoffe, Sie können mir helfen. Ich implementiere ein kleines mehrschichtiges Perzeptron mit TensorFlow und ein paar Tutorials, die ich im Internet gefunden habe. Das Problem ist, dass das Netz in der Lage ist, etwas zu lernen, und damit meine ich, dass ich irgendwie den Wert des Trainingsfehlers optimieren und eine ordentliche Genauigkeit erreichen kann, und genau das habe ich angestrebt. Allerdings nehme ich mit Tensorboard einige seltsame NaN-Werte für die Verlustfunktion auf. Ziemlich viel tatsächlich. Hier sehen Sie meine neueste Tensorboard-Aufzeichnung der Verlustfunktionsausgabe. Bitte alle diese Dreiecke, gefolgt von Diskontinuitäten - das sind die NaN-Werte, beachten Sie auch, dass der allgemeine Trend der Funktion ist, was Sie erwarten würden.

Tensorboard zu berichten

Ich dachte, dass eine hohe Lernrate könnte das Problem sein, oder vielleicht ein Netz, das zu tief ist, die Steigungen zu verursachen, zu explodieren, so senkte ich die Lernrate und verwendet einen einzigen versteckte Ebene (dies ist die Konfiguration des obigen Bildes und der Code unten). Nichts hat sich geändert, ich habe den Lernprozess nur langsamer gemacht.

Tensorflow-Code

import tensorflow as tf 
import numpy as np 
import scipy.io, sys, time 
from numpy import genfromtxt 
from random import shuffle 

#shuffles two related lists #TODO check that the two lists have same size 
def shuffle_examples(examples, labels): 
    examples_shuffled = [] 
    labels_shuffled = [] 
    indexes = list(range(len(examples))) 
    shuffle(indexes) 
    for i in indexes: 
     examples_shuffled.append(examples[i]) 
     labels_shuffled.append(labels[i]) 
    examples_shuffled = np.asarray(examples_shuffled) 
    labels_shuffled = np.asarray(labels_shuffled) 
return examples_shuffled, labels_shuffled 

# Import and transform dataset 
dataset = scipy.io.mmread(sys.argv[1]) 
dataset = dataset.astype(np.float32) 

all_labels = genfromtxt('oh_labels.csv', delimiter=',') 
num_examples = all_labels.shape[0] 

dataset, all_labels = shuffle_examples(dataset, all_labels) 

# Split dataset into training (66%) and test (33%) set 
training_set_size = 2000 
training_set = dataset[0:training_set_size] 
training_labels = all_labels[0:training_set_size] 
test_set = dataset[training_set_size:num_examples] 
test_labels = all_labels[training_set_size:num_examples] 

test_set, test_labels = shuffle_examples(test_set, test_labels) 

# Parameters 
learning_rate = 0.0001 
training_epochs = 150 
mini_batch_size = 100 
total_batch = int(num_examples/mini_batch_size) 

# Network Parameters 
n_hidden_1 = 50 # 1st hidden layer of neurons 
#n_hidden_2 = 16 # 2nd hidden layer of neurons 
n_input = int(sys.argv[2]) # number of features after LSA 
n_classes = 2; 

# Tensorflow Graph input 
with tf.name_scope("input"): 
    x = tf.placeholder(np.float32, shape=[None, n_input], name="x-data") 
    y = tf.placeholder(np.float32, shape=[None, n_classes], name="y-labels") 

print("Creating model.") 

# Create model 
def multilayer_perceptron(x, weights, biases): 
    with tf.name_scope("h_layer_1"): 
     # First hidden layer with SIGMOID activation 
     layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1']) 
     layer_1 = tf.nn.sigmoid(layer_1) 
    #with tf.name_scope("h_layer_2"): 
     # Second hidden layer with SIGMOID activation 
     #layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2']) 
     #layer_2 = tf.nn.sigmoid(layer_2) 
    with tf.name_scope("out_layer"): 
     # Output layer with SIGMOID activation 
     out_layer = tf.add(tf.matmul(layer_1, weights['out']), biases['bout']) 
     out_layer = tf.nn.sigmoid(out_layer) 
    return out_layer 

# Layer weights 
with tf.name_scope("weights"): 
    weights = { 
     'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1], stddev=0.01, dtype=np.float32)),  
     #'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], stddev=0.05, dtype=np.float32)), 
     'out': tf.Variable(tf.random_normal([n_hidden_1, n_classes], stddev=0.01, dtype=np.float32)) 
} 

# Layer biases 
with tf.name_scope("biases"): 
    biases = { 
     'b1': tf.Variable(tf.random_normal([n_hidden_1], dtype=np.float32)), 
     #'b2': tf.Variable(tf.random_normal([n_hidden_2], dtype=np.float32)), 
     'bout': tf.Variable(tf.random_normal([n_classes], dtype=np.float32)) 
    } 

# Construct model 
pred = multilayer_perceptron(x, weights, biases) 

# Define loss and optimizer 
with tf.name_scope("loss"): 
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) 
with tf.name_scope("adam"): 
    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) 

# Initializing the variables 
init = tf.initialize_all_variables() 

# Define summaries 
tf.scalar_summary("loss", cost) 
summary_op = tf.merge_all_summaries() 

print("Model ready.") 

# Launch the graph 
with tf.Session() as sess: 
    sess.run(init) 

    board_path = sys.argv[3]+time.strftime("%Y%m%d%H%M%S")+"/" 
    writer = tf.train.SummaryWriter(board_path, graph=tf.get_default_graph()) 

    print("Starting Training.") 
    for epoch in range(training_epochs): 
     training_set, training_labels = shuffle_examples(training_set, training_labels) 
     for i in range(total_batch): 
      # example loading 
      minibatch_x = training_set[i*mini_batch_size:(i+1)*mini_batch_size] 
      minibatch_y = training_labels[i*mini_batch_size:(i+1)*mini_batch_size] 
      # Run optimization op (backprop) and cost op 
      _, summary = sess.run([optimizer, summary_op], feed_dict={x: minibatch_x, y: minibatch_y}) 
      # Write log 
      writer.add_summary(summary, epoch*total_batch+i) 

    print("Optimization Finished!") 

# Test model 
test_error = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y)) 
accuracy = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) 
accuracy = tf.reduce_mean(tf.cast(accuracy, np.float32)) 
test_error, accuracy = sess.run([test_error, accuracy], feed_dict={x: test_set, y: test_labels}) 
print("Test Error: " + test_error.__str__() + "; Accuracy: " + accuracy.__str__()) 
print("Tensorboard path: " + board_path) 

Answer 1

Ich werde die Lösung hier posten für den Fall, jemand in einer ähnlichen Art und Weise stecken bleibt. Wenn Sie diese Darstellung sehr sorgfältig sehen, kommen alle NaN-Werte (die Dreiecke) regelmäßig, als ob am Ende jeder Schleife etwas dazu führt, dass die Ausgabe der Verlustfunktion einfach NaN wird. Das Problem ist, dass ich bei jeder Schleife eine Mini-Charge von "leeren" Beispielen gab. Das Problem liegt darin, wie ich meine innere Ausbildung Schleife erklärt:

for i in range(total_batch): 

Nun, was würden wir hier gefällt, ist durch den gesamten Trainingssatz haben Tensorflow zu gehen, ein mini auf einmal. Also schauen wir uns an, wie total_batch erklärt wurde:

total_batch = int(num_examples/mini_batch_size) 

Das ist nicht ganz das, was wir tun wollen würde - wie wir das Training eingestellt nur betrachten. Also ändere diese Zeile zu:

total_batch = int(training_set_size/mini_batch_size) 

Das Problem wurde behoben. Es ist anzumerken, dass Tensorflow diese "leeren" Chargen zu ignorieren schien, indem er NaN für den Verlust berechnete, aber die Gradienten nicht aktualisierte - deshalb war der Trend des Verlustes der eines Netzes, das etwas lernt.