Valeur de perte énorme à NaN sur la régularisation et l'abandon dans un réseau de neurones profonds

Question

Je prends le cours de Deep Learning sur Udacity. Une des tâches qui est donnée est d'implémenter la régularisation et l'abandon dans un réseau de neurones à plusieurs couches.

Après la mise en œuvre, ma perte de minibatch dans incroyablement élevée à l'étape 0, les changements à l'infini à l'étape 1, et devient alors inexistante pour le reste de la sortie

Offset at step 0: 0 
Minibatch loss at step 0: 187359330304.000000 
Minibatch accuracy: 10.2% 
Validation accuracy: 10.0% 

Offset at step 1: 128 
Minibatch loss at step 1: inf 
Minibatch accuracy: 14.1% 
Validation accuracy: 10.0% 

Offset at step 2: 256 
Minibatch loss at step 2: nan 
Minibatch accuracy: 7.8% 
Validation accuracy: 10.0% 

Offset at step 3: 384 
Minibatch loss at step 3: nan 
Minibatch accuracy: 11.7% 
Validation accuracy: 10.0% 

est ici tout le code correspondant. Je suis confiant que cela n'a rien à voir avec la façon dont j'ai fait mon optimisation (puisque cela vient de la tâche donnée) ou ma régularisation donc je ne sais pas où cela pourrait être. J'ai aussi joué avec le nombre de nœuds dans les calques cachés (1024> 300> 60) mais ça fait la même chose.

Voici mon code (excusez l'indentation, il est correct dans mon code):

batch_size = 128 
num_nodes_1 = 768 
num_nodes_2 = 1024 
num_nodes_3 = 512 
dropout_value = 0.5 
beta = 0.01 

graph = tf.Graph() 
with graph.as_default(): 

tf_train_data = tf.placeholder(tf.float32, shape=(batch_size, image_size*image_size)) 
tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels)) 
tf_valid_data = tf.constant(valid_dataset) 
tf_test_data = tf.constant(test_dataset) 

def gen_weights_biases(input_size, output_size): 
    weights = tf.Variable(tf.truncated_normal([input_size, output_size])) 
    biases = tf.Variable(tf.zeros([output_size])) 
    return weights, biases 

weights_1, biases_1 = gen_weights_biases(image_size*image_size, num_nodes_1) 
weights_2, biases_2 = gen_weights_biases(num_nodes_1, num_nodes_2) 
weights_3, biases_3 = gen_weights_biases(num_nodes_2, num_nodes_3) 
weights_4, biases_4 = gen_weights_biases(num_nodes_3, num_labels) 

logits_1 = tf.matmul(tf_train_data, weights_1) + biases_1 
h_layer_1 = tf.nn.relu(logits_1) 
h_layer_1 = tf.nn.dropout(h_layer_1, dropout_value) 

logits_2 = tf.matmul(h_layer_1, weights_2) + biases_2 
h_layer_2 = tf.nn.relu(logits_2) 
h_layer_2 = tf.nn.dropout(h_layer_2, dropout_value) 

logits_3 = tf.matmul(h_layer_2, weights_3) + biases_3 
h_layer_3 = tf.nn.relu(logits_3) 
h_layer_3 = tf.nn.dropout(h_layer_3, dropout_value) 

logits_4 = tf.matmul(h_layer_3, weights_4) + biases_4 

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=tf_train_labels, logits=logits_4)) 
regularization = tf.nn.l2_loss(logits_1) + tf.nn.l2_loss(logits_2) + tf.nn.l2_loss(logits_3) + tf.nn.l2_loss(logits_4) 
reg_loss = tf.reduce_mean(loss + regularization * beta) 

global_step = tf.Variable(0) 
learning_rate = tf.train.exponential_decay(0.5, global_step, 750, 0.8) 
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(reg_loss, global_step=global_step) 

train_prediction = tf.nn.softmax(logits_4) 

def make_prediction(input_data): 
    p_logits_1 = tf.matmul(input_data, weights_1) + biases_1 
    p_layer_1 = tf.nn.relu(p_logits_1) 
    p_logits_2 = tf.matmul(p_layer_1, weights_2) + biases_2 
    p_layer_2 = tf.nn.relu(p_logits_2) 
    p_logits_3 = tf.matmul(p_layer_2, weights_3) + biases_3 
    p_layer_3 = tf.nn.relu(p_logits_3) 

    p_logits_4 = tf.matmul(p_layer_3, weights_4) + biases_4 
    return tf.nn.relu(p_logits_4) 

valid_prediction = make_prediction(tf_valid_data) 
test_prediction = make_prediction(tf_test_data) 

num_steps = 10001 

with tf.Session(graph=graph) as session: 
tf.global_variables_initializer().run() 
print("Initialized \n") 

for step in range(num_steps): 
    offset = (step * batch_size) % (train_labels.shape[0] - batch_size) 
    batch_data = train_dataset[offset:(offset + batch_size), :] 
    batch_labels = train_labels[offset:(offset + batch_size), :] 

    feed_dict = {tf_train_data:batch_data, tf_train_labels:batch_labels} 

    _, l, predictions = session.run([optimizer, reg_loss, train_prediction], feed_dict=feed_dict) 

    if(step % 1 == 0): 
     print("Offset at step %d: %d" % (step, offset)) 
     print("Minibatch loss at step %d: %f" % (step, l)) 
     print("Minibatch accuracy: %.1f%%" % accuracy(predictions, batch_labels)) 
     print("Validation accuracy: %.1f%% \n" % accuracy(valid_prediction.eval(), valid_labels)) 

print("Test accuracy: %.1f%%" % accuracy(test_prediction.eval(), test_labels)) 

Pourquoi cela se produit, et comment puis-je résoudre ce problème?

Answer 1

Le problème était l'écart type pour les poids. Je ne sais pas pourquoi cela a réglé le problème et si quelqu'un pouvait m'expliquer, je l'apprécierais. Quoi qu'il en soit la solution était:

def gen_weights_biases(input_size, output_size): 
    weights = tf.Variable(tf.truncated_normal([input_size, output_size], stddev=math.sqrt(2.0/(input_size)))) 
    biases = tf.Variable(tf.zeros([output_size])) 
    return weights, biases 

Le taux bêta devait également être réduit à 0,0001