TensorFlow官方教程翻译2:线程和队列

原文地址https://www.tensorflow.org/programmersguide/threadingand_queues

主要内容

队列使用概述
Coordinator
QueueRunner
处理异常

队列对于使用TensorFlow来进行异步计算是一个强大的机制。
像所有的TensorFlow中的东西一样,一个队列是一个TensorFlow图中的一个节点。这是个状态节点,像一个变量:其他节点可以修改它的内容。特别的来说,其他节点可以将新的元素加入队列,或者从队列中出队现存的元素。
为了找点对于队列概念的感觉,让我们来考虑一个简单的例子。我们会创建一个“先进,先出”的队列(FIFOQueue),并且用0填充这个队列。然后,我们构建了一个图,出队一个元素,将这个元素加1,然后将这个元素放回到这个队列的尾部。于是,队列中的数字都在逐渐增加。

Example1:Enqueue and Dequeue Op

Enqueue,EnqueueMany和Dequeue都是特殊的节点。他们保存着指向队列的指针而不是一般的数值,这样使得它们能够修改队列。我们建议你将这些方法认为是和队列的方法类似。实际上,在Python的API中,他们是队列对象的方法(例如q.enqueue(…))。
注意:队列的方法(例如q.enqueue())必须和队列本身运行在相同的硬件上。在创建这些操作的时候,不一致的硬件部署指令会被忽略。
现在你应该对于队列有些感觉了,那让我们深入细节。

队列使用概述

例如像tf.FIFOQueue和tf.RandomShuffleQueue这样的队列,对于在图中异步计算张量而言,是非常重要的TensorFlow对象。
举例来说,一个典型的输入架构就是使用RandomShuffleQueue来为训练模型准备输入:

  • 多线程准备训练数据,并将其压入队列。
  • 一个训练线程运行训练操作,这个操作从队列中出队小批量的数据。

这个架构有很多好处,正如Reading data中所强调的那样,同时这篇文章也一些简化构建输入管道的函数的概述。
TensorFlow的Session对象是多线程的,因此多线程可以很容易的使用相同的图,和并行的运行操作。但是实现一个如上所述的使用线程的Python程序,并不总是那么容易。所有的线程必须能够同时停止,异常需要被捕捉并通知(reported),而队列比如在线程停止的时候,被恰当的关闭。
TensorFlow提供两个类来帮助上述任务的实现:tf.train.Coordinator和tf.train.QueueRunner。这两个类被设计为同时使用。Coordinator类帮助多线程同时停止,并向那些等待他们停止的程序报告异常。QueueRunner类被用来创建多个线程,这些线程用来协作在相同的队列中入队张量。

Coordinator

Coordinator类帮助多线程同时停止。 它的关键方法为:

  • tf.train.Coordinator.should_stop:如果线程应该停止,那么返回True
  • tf.train.Coordinator.request_stop:请求停止线程、
  • tf.train.Coordinator.join:等待,直到指定的线程已经停止

你首先创建一个Coordinator对象,然后创建一些线程来使用Coordinator。通常,线程运行循环,而这个循环会在should_stop()返回为True的时候终止。
任何线程可以决定这次计算应该终止。它仅仅需要调用requeststop(),然后其他线程会随着shouldstop()返回为True而终止。

# Thread body: loop until the coordinator indicates a stop was requested.
# If some condition becomes true, ask the coordinator to stop.
def MyLoop(coord):
  while not coord.should_stop():
...do something...
if ...some condition...:
  coord.request_stop()

# Main thread: create a coordinator.
coord = tf.train.Coordinator()

# Create 10 threads that run 'MyLoop()'
threads = [##threading.Thread(target=MyLoop, args=(coord,)) for i in xrange(10)]

# Start the threads and wait for all of them to stop.
for t in threads:
  t.start()
coord.join(threads)

显然,协调器能管理线程做不同的事情。他们并不需要像上述例子中一样,全都是做同样的事情。协调器同样支持捕捉和报告异常。参见tf.train.Coordinator文档获取更详细的信息。

QueueRunner

QueueRunner类创建一些线程,来反复的运行入队操作。这些线程可以使用一个协调器来同时终止。除此之外,一个队列运行器运行一个关系更为密切的线程,它在协调器报告异常的情况下,自动的关闭队列。
你可以使用队列UN星期来实现上述的架构。
首先构建一个图,使用TenorFlow的队列(比如tf.RandomShuffleQueue)来输入样本。然后添加操作来处理样本,并讲他们入队。最后,添加以出队元素开始的训练操作。

example = ...ops to create one example...
# Create a queue, and an op that enqueues examples one at a time in the queue.
queue = tf.RandomShuffleQueue(...)
enqueue_op = queue.enqueue(example)
# Create a training graph that starts by dequeuing a batch of examples.
inputs = queue.dequeue_many(batch_size)
train_op = ...use 'inputs' to build the training part of the graph...  
在Python的训练程序中,创建一个QueueRunner对象,会运行多个线程来处理和入队样本。创建一个Coordinator的对象,并用coordinator(协调器)来要求队列运行器来启动它的线程。编写训练的循环也可以使用coordinator(协调器)。
# Create a queue runner that will run 4 threads in parallel to enqueue
# examples.
qr = tf.train.QueueRunner(queue, [enqueue_op] * 4)

# Launch the graph.
sess = tf.Session()
# Create a coordinator, launch the queue runner threads.
coord = tf.train.Coordinator()
enqueue_threads = qr.create_threads(sess, coord=coord, start=True)
# Run the training loop, controlling termination with the coordinator.
for step in xrange(1000000):
    if coord.should_stop():
        break
    sess.run(train_op)
# When done, ask the threads to stop.
coord.request_stop()
# And wait for them to actually do it.
coord.join(enqueue_threads)  

处理异常

以队列运行器开始的线程不仅仅是运行入队操作。它们也会捕捉并处理由队列产生的异常,这些异常包括tf.errors.OutOfRangeError异常,这个异常被用来报道队列被关闭。
使用协调器的训练程序必须在其主循环中,同样地捕捉并报道异常。
这里是上面训练循环的增强版。

try:
    for step in xrange(1000000):
        if coord.should_stop():
            break
        sess.run(train_op)
except Exception, e:
    # Report exceptions to the coordinator.
    coord.request_stop(e)
finally:
    # Terminate as usual. It is safe to call `coord.request_stop()` twice.
    coord.request_stop()
    coord.join(threads)

推荐阅读更多精彩内容