Mehrere Tensorflow-Sitzungen gleichzeitig ausführen

Question

Ich versuche mehrere Sitzungen von TensorFlow gleichzeitig auf einer CentOS 7-Maschine mit 64 CPUs auszuführen. Mein Kollege berichtet, dass er die folgenden zwei Codeblöcke können eine parallele Speedup auf seiner Maschine mit vier Kernen zu produzieren:

mnist.py

import numpy as np 
import input_data 
from PIL import Image 
import tensorflow as tf 
import time 


def main(randint): 
    print 'Set new seed:', randint 
    np.random.seed(randint) 
    tf.set_random_seed(randint) 
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 

    # Setting up the softmax architecture 
    x = tf.placeholder("float", [None, 784]) 
    W = tf.Variable(tf.zeros([784, 10])) 
    b = tf.Variable(tf.zeros([10])) 
    y = tf.nn.softmax(tf.matmul(x, W) + b) 

    # Setting up the cost function 
    y_ = tf.placeholder("float", [None, 10]) 
    cross_entropy = -tf.reduce_sum(y_*tf.log(y)) 
    train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy) 

    # Initialization 
    init = tf.initialize_all_variables() 
    sess = tf.Session(
     config=tf.ConfigProto(
      inter_op_parallelism_threads=1, 
      intra_op_parallelism_threads=1 
     ) 
    ) 
    sess.run(init) 

    for i in range(1000): 
     batch_xs, batch_ys = mnist.train.next_batch(100) 
     sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys}) 

    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 

    print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}) 

if __name__ == "__main__": 
    t1 = time.time() 
    main(0) 
    t2 = time.time() 
    print "time spent: {0:.2f}".format(t2 - t1) 

parallel.py

import multiprocessing 
import numpy as np 

import mnist 
import time 

t1 = time.time() 
p1 = multiprocessing.Process(target=mnist.main,args=(np.random.randint(10000000),)) 
p2 = multiprocessing.Process(target=mnist.main,args=(np.random.randint(10000000),)) 
p3 = multiprocessing.Process(target=mnist.main,args=(np.random.randint(10000000),)) 
p1.start() 
p2.start() 
p3.start() 
p1.join() 
p2.join() 
p3.join() 
t2 = time.time() 
print "time spent: {0:.2f}".format(t2 - t1) 

Insbesondere sagt er dass er beobachtet

Running a single process took: 39.54 seconds 
Running three processes took: 54.16 seconds 

Howe ver, wenn ich den Code ausführen:

python mnist.py 
==> Time spent: 5.14 

python parallel.py 
==> Time spent: 37.65 

Wie man sehen kann, erhalte ich eine deutliche Verlangsamung unter Verwendung Multiprozessing während meines Kollegen nicht. Hat jemand einen Einblick, warum dies passieren könnte und was kann getan werden, um es zu beheben?

EDIT

Hier ist ein Beispiel einer Ausgabe. Beachten Sie, dass die Daten geladen werden parallel zu kommen scheint, aber die Ausbildung der einzelnen Modelle hat einen sehr sequenziellen Blick in den Ausgang (und die durch einen Blick auf die CPU-Auslastung in top als das Programm ausführt, überprüft werden kann)

#$ python parallel.py 
Set new seed: 9672406 
Extracting MNIST_data/train-images-idx3-ubyte.gz 
Set new seed: 4790824 
Extracting MNIST_data/train-images-idx3-ubyte.gz 
Set new seed: 8011659 
Extracting MNIST_data/train-images-idx3-ubyte.gz 
Extracting MNIST_data/train-labels-idx1-ubyte.gz 
Extracting MNIST_data/t10k-images-idx3-ubyte.gz 
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz 
Extracting MNIST_data/train-labels-idx1-ubyte.gz 
Extracting MNIST_data/train-labels-idx1-ubyte.gz 
Extracting MNIST_data/t10k-images-idx3-ubyte.gz 
Extracting MNIST_data/t10k-images-idx3-ubyte.gz 
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz 
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz 
I tensorflow/core/common_runtime/local_device.cc:25] Local device intra op parallelism threads: 1 
I tensorflow/core/common_runtime/local_session.cc:45] Local session inter op parallelism threads: 1 
0.9136 
I tensorflow/core/common_runtime/local_device.cc:25] Local device intra op parallelism threads: 1 
I tensorflow/core/common_runtime/local_session.cc:45] Local session inter op parallelism threads: 1 
0.9149 
I tensorflow/core/common_runtime/local_device.cc:25] Local device intra op parallelism threads: 1 
I tensorflow/core/common_runtime/local_session.cc:45] Local session inter op parallelism threads: 1 
0.8931 
time spent: 41.36 

Another EDIT

Angenommen, wir möchten bestätigen, dass das Problem scheinbar mit TensorFlow und nicht mit Multiprocessing ist. Ich ersetzte den Inhalt mnist.py mit einer großen Schleife wie folgt:

def main(randint): 
    c = 0 
    for i in xrange(100000000): 
     c += i 

Zur Ausgabe:

#$ python mnist.py 
==> time spent: 5.16 
#$ python parallel.py 
==> time spent: 4.86 

Daher denke ich, das Problem hier ist nicht mit sich selbst Multiprozessing.

Answer 1

Eine Möglichkeit besteht darin, dass Ihre Sitzungen 64 Kerne jeweils und Stampfen auf sich Vielleicht versuchen zu verwenden versuchen für jede Sitzung NUM_CORES auf einen niedrigeren Wert einstellen

sess = tf.Session(
    tf.ConfigProto(inter_op_parallelism_threads=NUM_CORES, 
        intra_op_parallelism_threads=NUM_CORES)) 

Answer 2

Von Kommentar von OP (user1936768):

Ich habe gute Nachrichten: Es stellt sich heraus, dass auf meinem System zumindest meine Testprogramme nicht lange genug ausgeführt wurden, um die anderen Instanzen von TF zu starten. Wenn ich ein länger laufendes Beispielprogramm in main lege, sehe ich tatsächlich gleichzeitige Berechnungen