python - tfjs - Ejecutar múltiples sesiones de tensorflow concurrentemente

tensorflow js train model

Question

Estoy intentando ejecutar varias sesiones de TensorFlow al mismo tiempo en una máquina CentOS 7 con 64 CPU. Mi colega informa que puede usar los siguientes dos bloques de código para producir una aceleración paralela en su máquina usando 4 núcleos:

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)

En particular, dice que él observa

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

Sin embargo, cuando ejecuto el código:

python mnist.py
==> Time spent: 5.14

python parallel.py 
==> Time spent: 37.65

Como puede ver, obtengo una desaceleración significativa al usar multiprocesamiento, mientras que mi colega no. ¿Alguien tiene alguna idea de por qué esto podría estar ocurriendo y qué se puede hacer para solucionarlo?

EDITAR

Aquí hay algunos ejemplos de salida. Observe que la carga de datos parece ocurrir en paralelo, pero la capacitación de los modelos individuales tiene un aspecto muy secuencial en la salida (y que se puede verificar al observar el uso de la CPU en la top medida que se ejecuta el programa)

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

Otro EDIT

Supongamos que deseamos confirmar que el problema aparentemente es con TensorFlow y no con el multiprocesamiento. mnist.py el contenido de mnist.py con un gran bucle de la siguiente manera:

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

Para salida:

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

Por lo tanto, creo que el problema aquí no es con el multiprocesamiento en sí mismo.

Answer 1

Una posibilidad es que sus sesiones intenten usar 64 núcleos cada uno y pisar fuerte el uno al otro. Tal vez intente establecer NUM_CORES en un valor inferior para cada sesión.

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

Answer 2

Del comentario de OP ( user1936768 ):

Tengo buenas noticias: resulta que, al menos en mi sistema, mis programas de prueba no se ejecutaron durante el tiempo suficiente para que se iniciaran las otras instancias de TF. Cuando pongo un programa de ejemplo de ejecución más larga en main, de hecho veo cálculos concurrentes