ténorflow mémoire MNIST tutoriel

Question

J'essaie de compléter tutoriel MNIST de tensorflow website J'ai 2gb geforce 760gtx et à court de mémoire à chaque fois. J'ai essayé de réduire la taille des lots dans les lignes de code à la fin du script:

for i in range(20000): 
batch = mnist.train.next_batch(5) 
if i%100 == 0: 
    train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) 
    print("step %d, training accuracy %g"%(i, train_accuracy)) 
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) 

Mais toujours essayer d'utiliser la même quantité de RAM. Im nouveau à tensorflow et je veux demander, où puis-je réduire l'utilisation de la mémoire dans cet exemple, ou y at-il un code pour le pousser à travers le processeur?

code complet:

# Load mnist data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets('MNIST_data', one_hot=True) 

# Start TensorFlow InteractiveSession 
import tensorflow as tf 
sess = tf.InteractiveSession() 

# Build a Softmax Regression Model 

# 1. Placeholders 
x = tf.placeholder(tf.float32, shape=[None, 784]) 
y_ = tf.placeholder(tf.float32, shape=[None, 10]) 

# 2. Variables 
W = tf.Variable(tf.zeros([784,10])) 
b = tf.Variable(tf.zeros([10])) 
sess.run(tf.initialize_all_variables()) 

# 3. Predicted Class and Loss Function 
y = tf.matmul(x,W) + b 
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y, y_)) 

# Train the Model 
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) 
for i in range(1000): 
    batch = mnist.train.next_batch(100) 
    train_step.run(feed_dict={x: batch[0], y_: batch[1]}) 

# Evaluate the Model 
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1)) 
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels})) 

# Build a Multilayer Convolutional Network 
def weight_variable(shape): 
    initial = tf.truncated_normal(shape, stddev=0.1) 
    return tf.Variable(initial) 

def bias_variable(shape): 
    initial = tf.constant(0.1, shape=shape) 
    return tf.Variable(initial) 

# Convolutional and Pooling 
def conv2d(x, W): 
    return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME') 

def max_pool_2x2(x): 
    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME') 

# First Convolutional Layer 
W_conv1 = weight_variable([5,5,1,32]) 
b_conv1 = bias_variable([32]) 
x_image = tf.reshape(x, [-1,28,28,1]) 
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) 
h_pool1 = max_pool_2x2(h_conv1) 

# Second Convolutional Layer 
W_conv2 = weight_variable([5,5,32,64]) 
b_conv2 = bias_variable([64]) 

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) 
h_pool2 = max_pool_2x2(h_conv2) 

# Densely Connected Layer 
W_fc1 = weight_variable([7*7*64,1024]) 
b_fc1 = bias_variable([1024]) 
h_pool2_flat = tf.reshape(h_pool2, [-1,7*7*64]) 
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1) 

# Dropout 
keep_prob = tf.placeholder(tf.float32) 
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) 

# Readout Layer 
W_fc2 = weight_variable([1024,10]) 
b_fc2 = bias_variable([10]) 

y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2 

# Train and Evaluate the Model 
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_conv, y_)) 
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) 
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1)) 
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 
sess.run(tf.initialize_all_variables()) 
for i in range(20000): 
    batch = mnist.train.next_batch(5) 
    if i%100 == 0: 
     train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) 
    print("step %d, training accuracy %g"%(i, train_accuracy)) 
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) 

print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})) 

Answer 1

Je pense que le problème se produise pas dans la boucle de formation, mais dans l'évaluation de la précision finale où tout le jeu de test est passé en un seul lot de 10000 images:

print("test accuracy %g"%accuracy.eval(
    feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})) 

Sur les GPU de 2 Go ou moins, cela suffit pour utiliser toute la mémoire disponible. J'ai eu le même problème avec ma GTX 965M.

La solution consiste également à utiliser des lots pour l'évaluation. Vous devez calculer le nombre total de lots et accumuler la précision totale. Dans le code:

# evaluate in batches to avoid out-of-memory issues 
n_batches = mnist.test.images.shape[0] // 50 
cumulative_accuracy = 0.0 
for index in range(n_batches): 
    batch = mnist.test.next_batch(50) 
    cumulative_accuracy += accuracy.eval(
     feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0}) 
print("test accuracy {}".format(cumulative_accuracy/n_batches))