многоуровневая нейронная сеть

Question

Я пытаюсь выполнить следующую tensorflow учебник и (попытка проблемы 4): https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/udacity/3_regularization.ipynb

Однако, я думаю, что я мог бы быть создание массивов весов ниже неправильно. Как только я изменю hidden_layer на [image_size * image_size,1024,num_labels] (т. Е. Только на один скрытый слой), это отлично работает. В настоящее время я получаю NaN с за потерю.

Одно из возможных решений является то, что блок for i in range(1,len(weights)-1): relus = tf.nn.dropout(tf.nn.relu(tf.matmul(relus, weights[i]) + biases[i]),p_hide) вызывает проблемы, так как я разрушив прошлое значение relus и нейросети нужно им делать обратное распространение. Фактически, когда есть один скрытый слой, этот блок не выполняется.

batch_size = 128 
hidden_layer = [image_size * image_size,1024,300,num_labels] 
l2_regulariser = 0.005 
p_hide = 0.5 

graph = tf.Graph() 
with graph.as_default(): 
    # Input data. For the training data, we use a placeholder that will be fed 
    # at run time with a training minibatch. 
    tf_train_dataset = 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_dataset = tf.constant(valid_dataset) 
    tf_test_dataset = tf.constant(test_dataset) 

    # Variables. 
    weights = [None]*(len(hidden_layer)-1) 
    biases = [None]*(len(hidden_layer)-1) 
    for i in range(len(weights)): 
     weights[i] = tf.Variable(tf.truncated_normal([hidden_layer[i], hidden_layer[i+1]])) 
     biases[i] = tf.Variable(tf.zeros([hidden_layer[i+1]])) 

    # Training computation. 
    relus = tf.nn.dropout(tf.nn.relu(tf.matmul(tf_train_dataset, weights[0]) + biases[0]),p_hide) 
    for i in range(1,len(weights)-1): 
     relus = tf.nn.dropout(tf.nn.relu(tf.matmul(relus, weights[i]) + biases[i]),p_hide) 
    logits = tf.matmul(relus, weights[len(weights)-1]) + biases[len(weights)-1] 

    loss = 0 
    for weight in weights: 
     loss += tf.nn.l2_loss(weight) 

    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels))+ l2_regulariser*loss 


    # Optimizer. 
    global_step = tf.Variable(0) # count the number of steps taken. 
    learning_rate = tf.train.exponential_decay(0.5, global_step, decay_steps=20, decay_rate=0.9) 
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) 


    # Predictions for the training, validation, and test data. 
    train_prediction = tf.nn.softmax(logits) 

    relus = tf.nn.relu(tf.matmul(tf_valid_dataset, weights[0]) + biases[0]) 
    for i in range(1,len(weights)-1): 
     relus = tf.nn.relu(tf.matmul(relus, weights[i]) + biases[i]) 
    valid_prediction = tf.nn.softmax(tf.matmul(relus, weights[len(weights)-1]) + biases[len(weights)-1]) 

    relus = tf.nn.relu(tf.matmul(tf_test_dataset, weights[0]) + biases[0]) 
    for i in range(1,len(weights)-1): 
     relus = tf.nn.relu(tf.matmul(relus, weights[i]) + biases[i]) 
    test_prediction = tf.nn.softmax(tf.matmul(relus, weights[len(weights)-1]) + biases[len(weights)-1]) 

###################### 
# The NN training part 
###################### 
num_steps = 3001 

with tf.Session(graph=graph) as session: 
    tf.initialize_all_variables().run() 
    print("Initialized") 
    for step in range(num_steps): 
    # Pick an offset within the training data, which has been randomized. 
    # Note: we could use better randomization across epochs. 
    offset = (step * batch_size) % (train_labels.shape[0] - batch_size) 
    # Generate a minibatch. 
    batch_data = train_dataset[offset:(offset + batch_size), :] 
    batch_labels = train_labels[offset:(offset + batch_size), :] 
    # Prepare a dictionary telling the session where to feed the minibatch. 
    # The key of the dictionary is the placeholder node of the graph to be fed, 
    # and the value is the numpy array to feed to it. 
    feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels, global_step : int(step)} 
    _, l, predictions = session.run(
     [optimizer, loss, train_prediction], feed_dict=feed_dict) 
    if (step % 500 == 0): 
     print("Minibatch loss at step %d: %f" % (step, l)) 
     print("Minibatch accuracy: %.1f%%" % accuracy(predictions, batch_labels)) 
     print("Validation accuracy: %.1f%%" % accuracy(
     valid_prediction.eval(), valid_labels)) 
    print("Test accuracy: %.1f%%" % accuracy(test_prediction.eval(), test_labels)) 

Answer 1

Вы должны лучше инициализировать веса:

tf.truncated_normal([hidden_layer[i], hidden_layer[i+1]], stddev=0.1) 

И больше всего, вы должны снизить скорость обучения к чему-то около 0.01, 0.001 ...

Я думаю, что ваш получите потерю NaN, потому что скорость обучения слишком высока, и она разбивает сеть (вы получаете взрывающиеся веса).