टेन्सफोर्लो एमएनआईएसटी: 'std :: bad_alloc'

Question

का उदाहरण फेंकने के बाद बुलाया गया है। मैं अपने डिफ़ॉल्ट एमएनआईएसटी डेटा सेट का उपयोग करके टेन्सफोर्लो पर एक कनवॉल्यूशनल न्यूरल नेटवर्क को कार्यान्वित करने की कोशिश कर रहा हूं।

from __future__ import print_function 
import tensorflow as tf 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets('MNIST_data', one_hot=True) 


def compute_accuracy(v_xs, v_ys): 
    global prediction 
    y_pre = sess.run(prediction, feed_dict={xs: v_xs, keep_prob: 1}) 
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(v_ys,1)) 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) 
    result = sess.run(accuracy, feed_dict={xs: v_xs, ys: v_ys, keep_prob: 1}) 
    return result 

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) 

def conv2d(x, W): 
    # stride [1, x_movement, y_movement, 1] 
    # Must have strides[0] = strides[3] = 1 
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') 

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

# define placeholder for inputs to network 
xs = tf.placeholder(tf.float32, [None, 784]) # 28x28 
ys = tf.placeholder(tf.float32, [None, 10]) 
keep_prob = tf.placeholder(tf.float32) 
x_image = tf.reshape(xs, [-1, 28, 28, 1]) 
# print(x_image.shape) # [n_samples, 28,28,1] 

## conv1 layer ## 
W_conv1 = weight_variable([5,5, 1,32]) # patch 5x5, in size 1, out size 32 
b_conv1 = bias_variable([32]) 
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # output size 28x28x32 
h_pool1 = max_pool_2x2(h_conv1)           # output size 14x14x32 

## conv2 layer ## 
W_conv2 = weight_variable([5,5, 32, 64]) # patch 5x5, in size 32, out size 64 
b_conv2 = bias_variable([64]) 
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) # output size 14x14x64 
h_pool2 = max_pool_2x2(h_conv2)           # output size 7x7x64 

## fc1 layer ## 
W_fc1 = weight_variable([7*7*64, 1024]) 
b_fc1 = bias_variable([1024]) 
# [n_samples, 7, 7, 64] ->> [n_samples, 7*7*64] 
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) 
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) 

## fc2 layer ## 
W_fc2 = weight_variable([1024, 10]) 
b_fc2 = bias_variable([10]) 
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2) 

# the error between prediction and real data 
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), 
               reduction_indices=[1]))  # loss 
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) 

sess = tf.Session() 

sess.run(tf.global_variables_initializer()) 


for i in range(100): 
    batch_xs, batch_ys = mnist.train.next_batch(10) 
    sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys, keep_prob: 0.5}) 
    if i % 10 == 0: 
     print(compute_accuracy(
     mnist.test.images, mnist.test.labels)) 

इस संदेश के साथ क्रियान्वित करने, अजगर दुर्घटनाओं पर: 'std :: bad_alloc' का एक उदाहरण फेंक क्या() के बाद कहा जाता है को समाप्त : std :: bad_alloc

मैं कहना है कि करने में सक्षम था ऐसा तब होता है जब मैं compute_accuracy फ़ंक्शन को कॉल करता हूं, या सामान्य रूप से, जब मैं पूरे mnist.test iamges और लेबल लोड करता हूं। क्या किया जा सकता है, इस पर कोई सुझाव दिया गया है, क्योंकि मैं इस डेटा का उपयोग करना चाहता हूं। मैं एक अलग मामले में पूरी तरह से छवियों के साथ काम करने में सक्षम हूं।

Answer 1

मुझे लगता है कि आप स्मृति से बाहर हो रहे हैं। यह मेरी मशीन (6 जीबी ग्राफिक्स कार्ड) पर ठीक है। बैच आकार को कम करने का प्रयास करें, या एक छोटी पूरी तरह से जुड़े परत का उपयोग करें।

Answer 2

मुझे एक ही समस्या थी। मैंने सटीकता की गणना करने के लिए परीक्षण छवियों की संख्या को कम करके इसे हल किया, उदा। मैं कुछ इसी तरह के साथ

print(compute_accuracy(mnist.test.images, mnist.test.labels)) 

प्रतिस्थापित

batch_test = mnist.test.next_batch(5000) 
print(compute_accuracy(batch_test[0], batch_test[1]) 

मुझे आशा है कि इस मदद करता है करने के लिए।