tensorflow內存MNIST教程

Question

我試圖從tensorflow website 完成MNIST教程我有2gb geforce 760gtx和每次內存不足。 我試圖減少這些代碼行批量大小在腳本的末尾：

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}) 

但它總是嘗試使用RAM的量相同。我對tensorflow很感興趣，我想問一下，在這個例子中，我可以在哪裏減少內存的使用，或者是否有代碼來推動它通過CPU？

全碼：

# 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

我希望這個問題在訓練循環不會發生，但是在所有的測試組單批10000個圖像通過最終精度評價：

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

在2 GB或更少的GPU上，這足以用盡所有可用內存。我與我的GTX 965M有同樣的問題。

解決方案也是使用批處理進行評估。您需要計算批次總數並累計總準確度。在代碼：

# 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))