Tensorflow Ausführung friert für einen kleinen CNN ein

Question

Ich versuche, ein paar einfache Convolutional NN in Tensorflow in Windows 10 mit 40 GB Speicher, mit der CPU-Version. Allerdings stoße ich bis jetzt immer in Schwierigkeiten mit der Ausführung, entweder direkt nach der Initialisierung der Variablen oder nach ein paar Trainings-Iterationen. Im Folgenden finden Sie eine Zusammenfassung meines Codes und was ich erreichen möchte.

Ich habe in jedem Bild eine Sequenz mit fünf Buchstaben, und ich möchte das CNN trainieren, um die Reihenfolge in jedem Bild zu erkennen. Dazu füge ich zwei Faltungsschichten (Höhe/Breite/Kanal: 4/4/5, 4/4/10) in eine Reluktanzschicht, gefolgt von zwei vollständig verbundenen Reluktanzschichten und schließlich einer Softmax-Schicht mit Entropieverlustfunktion.

num_image = 5 
image_size = (28, 150) 
out_channel = 5; 
shape_conv1 = [4, 4, 1, out_channel] # height, width, in_channel, out_channel 
stride_conv1 = [1, 2, 2, 1] 
shape_conv2 = [4, 4, out_channel, out_channel*2] # height, width, in_channel, out_channel 
stride_conv2 = [1, 2, 2, 1] 
num_layer1 = 100 
num_layer2 = 100 

num_output = 10 
num_batch = 200 

size_intermediate = [1, np.ceil(np.ceil(image_size[0]/stride_conv1[1])/stride_conv2[1]), \ 
       np.ceil(np.ceil(image_size[1]/stride_conv1[2])/stride_conv2[2]), out_channel*2] 
size_trans = [int(i) for i in size_intermediate] 

with graph.as_default(): 
    input_data = tf.placeholder(tf.float32, [num_batch-num_image+1, image_size[0], image_size[1], 1]) 
    input_labels = tf.placeholder(tf.float32, [num_image, num_batch-num_image+1, num_output]) 
    reg_coeff = tf.placeholder(tf.float32) 

    weights_conv1 = tf.Variable(tf.truncated_normal(shape_conv1, 0.0, 0.1)) 
    bias_relu1 = tf.Variable(tf.zeros([out_channel])) 
    weights_conv2 = tf.Variable(tf.truncated_normal(shape_conv2, 0.0, 0.1)) 
    bias_relu2 = tf.Variable(tf.zeros([out_channel*2])) 
    weights_layer1 = tf.Variable(tf.truncated_normal(\ 
         [num_image, size_trans[1]*size_trans[2]*size_trans[3], num_layer1], \ 
         0.0, (num_layer1)**-0.5)) 
    bias_layer1 = tf.zeros([num_image, 1, num_layer1]) 
    weights_layer2 = tf.Variable(tf.truncated_normal([num_image, num_layer1, num_layer2], \ 
         0.0, (num_layer2)**-0.5)) 
    bias_layer2 = tf.zeros([num_image, 1, num_layer2]) 
    weights_output = tf.Variable(tf.truncated_normal([num_image, num_layer2, num_output], 0.0, num_output**-0.5)) 
    bias_output = tf.zeros([num_image, 1, num_output]) 

    output_conv1 = tf.nn.conv2d(input_data, weights_conv1, stride_conv1, "SAME") 
    output_relu1 = tf.nn.relu(output_conv1 + bias_relu1) 
    output_conv2 = tf.nn.conv2d(output_relu1, weights_conv2, stride_conv2, "SAME") 
    output_relu2 = tf.nn.relu(output_conv2 + bias_relu2) 

    shape_inter = output_relu2.get_shape().as_list() 
    input_inter = tf.reshape(output_relu2, [1, shape_inter[0], shape_inter[1]*shape_inter[2]*shape_inter[3]]) 
    ## One copy for each letter recognizer 
    input_mid = tf.tile(input_inter, [num_image, 1, 1]) 

    input_layer1 = tf.matmul(input_mid, weights_layer1) + bias_layer1 
    output_layer1 = tf.nn.relu(input_layer1) 
    input_layer2 = tf.matmul(output_layer1, weights_layer2) + bias_layer2 
    output_layer2 = tf.nn.relu(input_layer2) 
    logits = tf.matmul(output_layer2, weights_output) + bias_output 

    # Training prediction 
    train_prediction = tf.nn.softmax(logits) 
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, input_labels)) 
    # Loss term for regularization 
    loss_reg = reg_coeff*(tf.nn.l2_loss(weights_layer1)+tf.nn.l2_loss(bias_layer1)\ 
           +tf.nn.l2_loss(weights_layer2)+tf.nn.l2_loss(bias_layer2)\ 
           +tf.nn.l2_loss(weights_output)+tf.nn.l2_loss(bias_output)) 

    learning_rate = 0.1 
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss+loss_reg) 

Die CNN ist recht einfach und ziemlich klein, so war ich ziemlich überrascht, als ich sah, fror es nach alle Variablen zu initialisieren, oder bestenfalls nach ein paar Trainingsläufe. Es gibt keine Ausgabe irgendeiner Art und ctrl + c würde die Ausführung nicht unterbrechen. Ich frage mich, ob es etwas mit der Windows-Version von Tensorflow zu tun haben könnte, aber ich weiß momentan nicht, wo ich nach Hinweisen suchen soll.

Könnte jemand seinen Vorschlag/Meinung darüber teilen, was mein Problem verursacht haben könnte? Vielen Dank!

BEARBEITEN Sie: Wie in den Kommentaren darauf hingewiesen, möglicherweise ein Problem mit der Art, wie ich Daten an das Modell füttern. Daher poste ich auch diesen Teil des Codes unten.

num_steps = 20000 

fixed_input = np.random.randint(0, 256, [num_batch-num_image+1, 28, 150, 1]) 
fixed_label = np.tile((np.random.choice(10, [num_batch-num_image+1, 1])==np.arange(10)).astype(np.float32), (5, 1, 1)) 

with tf.Session(graph=graph) as session: 
    tf.global_variables_initializer().run() 
    print("Initialized") 
    loss1 = 0.0 
    loss2 = 0.0 

    for i in range(1, num_steps+1): 
     feed_dict = {input_data : fixed_input, input_labels : fixed_label, reg_coeff : 2e-4} 
     _, l1, l2, predictions = session.run([optimizer, loss, loss_reg, train_prediction], feed_dict=feed_dict) 
     loss1 += l1 
     loss2 += l2 

     if i % 500 == 0: 
      print("Batch/reg loss at step %d: %f, %f" % (i, loss1/500, loss2/500)) 
      loss1 = 0.0 
      loss2 = 0.0 
      print("Minibatch accuracy: %.1f%%" % accuracy(predictions, fixed_labels)) 

Ich verwende einfach eine zufällige Eingabe und ihre Etiketten, um zu testen, ob der Code ausgeführt wird. Leider friert die Ausführung innerhalb der ersten Trainingsschritte wieder ein.

Answer 1

Höchstwahrscheinlich liegt es an Warteschlangenläufern. Könnten Sie bitte versuchen, Ihren Trainingsschritt innerhalb von MonitoredSession auszuführen, die die Initialisierung und Warteschlangenausführung unter der Haube behandelt. Es wird wie folgt aussehen:

with tf.train.MonitoredTrainingSession(...) as sess: 
    sess.run(optimizer)