tensorflow随笔-队列（2）

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

import tensorflow as tf

n = 100

xQueue=tf.FIFOQueue(100,dtypes=[tf.int32],shapes=[])

with tf.Session() as sess:
    for i  in xrange(n):
        if i%3==0:
            sess.run(xQueue.enqueue(i))
    sess.run(xQueue.close())
    myx=sess.run(xQueue.dequeue_up_to(100))
    print myx    
    print sum(myx)

使用close后，再使用dequeue_up_to，不会有阻塞

[ 0 3 6 … 93 96 99]
1683

但下面程序会报错

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

import tensorflow as tf

n = 100

xQueue=tf.FIFOQueue(100,dtypes=[tf.int32],shapes=[])

with tf.Session() as sess:
    for i  in xrange(n):
        if i%3==0:
            sess.run(xQueue.enqueue(i))
    sess.run(xQueue.close())
    myx=sess.run(xQueue.dequeue_many(100))
    print myx    
    print sum(myx)

OutOfRangeError (see above for traceback): FIFOQueue ‘_2_fifo_queue_2’ is closed and has insufficient elements (requested 100, current size 34)``

Class RandomShuffleQueue
继承自: QueueBase

以随机顺序从元素中取出队列的队列类。

属性
dtypes
队列元素中每个组件的dtypes列表。

name
底层队列的名字

names
队列元素每个组件的名字列表

queue_ref
底层队列的引用

shapes

队列元素中每个组件的形状列表。

方法
init
init(
capacity,
min_after_dequeue,
dtypes,
shapes=None,
names=None,
seed=None,
shared_name=None,
name=‘random_shuffle_queue’
)

创建一个以随机顺序从元素中取出元素的队列。

随机队列具有有限的容量;支持多个并发生产者和消费者;并提供正确的一次传递。

RandomShuffleQueue则包含容量最大元素的列表。每个元素都是一个定长张量元组，其dtype由dtypes描述，其形状可由shapes描述。

如果指定了shapes参数，那么队列元素的每个组件必须具有各自的固定形状。如果没有指定，不同的队列元素可能有不同的形状，但是不允许使用dequeue_many。

min_after_dequeue参数允许调用者指定在dequeue_many操作完成后留在队列中的元素的最小数量，以确保元素的最小混合级别。通过阻塞这些操作来维护这个不变式，直到有足够的元素被加入队列。在队列关闭后，min_after_dequeue参数将被忽略。

参数:

capacity:一个整数 ，可能存储在此队列中的元素数量的上限。
min_after_dequeue: 一个整数
dtypes: DType对象的列表。dtypes的长度必须等于每个队列元素中的张量的数量。
shapes: (Optional.) (可选)与dtype长度相同或没有长度相同的完整定义的TensorShape对象列表。
names: (Optional.) (可选)。与dtypes或None长度相同的队列中组件的字符串列表。如果指定了dequeue方法，则返回一个名称为键的字典。
seed: 用于创建随机种子。看到tf.set_random_seed 行为。
shared_name: (Optional.) (可选)。如果不是空的，这个队列将在多个会话之间以给定的名称共享。
名称:
name: 队列操作的可选名称。
close
close(
cancel_pending_enqueues=False,
name=None
)

关闭此队列。

这个操作表明没有更多的元素将被放入给定队列中。随后的入队列和入队列很多操作都会失败。如果队列中仍然有足够的元素，后续的dequeue_many操作将继续成功。随后，将阻塞等待更多元素(如果没有调用close)的dequeue和dequeue_many操作将立即失败。

如果cancel_pending_enqueues为真，所有未决请求也将被取消。

参数:

cancel_pending_enqueues: (可选)。一个布尔值，默认为False(如上所述)。
name: 操作的名称(可选)。
返回:

关闭队列的操作。

dequeue

dequeue(name=None)

从这个队列中取出一个元素。

如果执行此操作时队列为空，它将阻塞，直到有一个元素要出队列为止。

在运行时，如果队列是tf.QueueBase.close，在执行之前或执行期间则此操作可能引发错误。如果队列是关闭的，队列是空的，这里没有可以完成此请求的挂起出队操作，将会出现tf.errors.OutOfRangeError。如果会话是tf.Session.close、 tf.errors，tf.errors.CancelledError 错误将被触发。

参数:

name: 操作名字（可选）
返回:

出队的张量元组。

dequeue_many

dequeue_many(
n,
name=None
)

从这个队列中取出并连接n个元素。

这个操作沿着第0维串联排队元素分量张量，形成单个分量张量。dequeue_tuple中的所有组件的大小都是第0维的n。

在运行时，如果队列是tf.QueueBase，则此操作可能引发错误。在执行之前或执行期间关闭。如果队列是关闭的，则该队列包含的元素不超过n个，并且没有可执行此请求tf.errors的挂起排队操作。将会出现OutOfRangeError。如果会话是tf.Session.close，则tf.errors.CancelledError将触发。

参数:

n: 一个标量Tensor，出列元素的数量
name: 操作名字（可选）
返回:

出列的连接张量的列表。

dequeue_up_to

dequeue_up_to(
n,
name=None
)

从这个队列中取出并连接n个元素。

注意，不是所有队列都支持此操作。如果队列不支持DequeueUpTo，则出现tf.errors.UnimplementedError。

这个操作沿着第0维串联队列元素分量张量，形成单个分量张量。如果队列没有被关闭，那么在队列元组中的所有组件的大小都是第0维的n。

如果队列是关闭的，并且有大于0但小于n个元素，那么将立即返回小于n个元素，而不是像tf.QueueBase.dequeue_many那样引发tf.error . outofrangeerror。。如果队列是关闭的，并且队列中还剩下0个元素，那么tf.errors.OutOfRangeError将像在dequeue_many一样抛出，否则，该行为与dequeue_many是相同的。

参数:

n: 一个标量Tensro，包括需要出列的元素数量
name: 操作名字（可选）
返回:

被出队的连接张量的元组。

enqueue

enqueue(
vals,
name=None
)

将一个元素放入这个队列。

如果执行此操作时队列已满，它将阻塞，直到元素被加入队列。

在运行时，如果队列是 tf.QueueBase.close，则此操作可能引发错误。队列在执行之前或执行期间关闭，tf.errors.CancelledError将触发。如果这个操作被阻塞，或者(i)队列被cancel_pending_enqueues=True的关闭操作关闭或(ii)会话是tf.Session.close、tf.errors。tf.errors.CancelledError错误将被提升。

参数:

vals: 张量，张量的列表或元组，或包含要加入的值的字典。
name: 操作的名称(可选)。
返回:

将新的张量元组排队到队列中的操作。

enqueue_many

enqueue_many(
vals,
name=None
)

将零个或多个元素放入此队列。

这个操作沿着第0维对每个分量张量进行切片，以生成多个队列元素。vals中的所有张量在第0维上必须具有相同的大小。

如果执行此操作时队列已满，它将阻塞，直到所有元素都已加入队列。

在运行时，如果队列是tf.QueueBase.close，则在执行之前或执行期关闭此操作可能引发错误。如果在此操作运行之前关闭队列，tf.errors.CancelledError触发。如果这个操作被阻塞，或者(i)队列被cancel_pending_enqueues=True的关闭操作关闭，或者(ii)会话是tf.Session.close、tf.errors，tf.errors.CancelledError 错误将被触发。

参数:

vals: 一个tensor，tensors元组的列表或从中取队列元素字典。
name: 操作名字（可选）
返回:

入一批tensors元组到队列的操作

from_list

from_list(
index,
queues
)

使用queues[index]中的队列引用创建一个队列。

参数:

queues:一个整数标量张量，它决定选择的输入。
queues:QueueBase对象的列表。
返回:

一个QueueBase对象。

Raises:

TypeError: 当队列不是QueueBase对象的列表时，或者当队列的数据类型不完全相同时。

is_closed
is_closed(name=None)

如果队列关闭，返回true。

如果队列是关闭的，此操作返回true;如果队列是打开的，则返回false。

参数:

name: 操作名字（可选）
返回:

如果队列是关闭的，为True;如果队列是打开的，为false。

size

size(name=None)

计算这个队列中的元素数量。

参数:

name: 操作的名称(可选)。
返回:

一个标量张量，包含这个队列中的元素数量。

#!/usr/bin/env python2
# -*- coding: utf-8 -*-


import tensorflow as tf

q=tf.RandomShuffleQueue(capacity=10,min_after_dequeue=2,dtypes="float")

with tf.Session() as sess:    
    for i in range(0,10):
        sess.run(q.enqueue(i))
    for i in range(0,8):
        print sess.run(q.dequeue())
4.0

5.0
8.0
7.0
3.0
0.0
2.0
1.0

#!/usr/bin/env python2
# -*- coding: utf-8 -*-


import tensorflow as tf

q=tf.RandomShuffleQueue(capacity=20,min_after_dequeue=2,dtypes="float")

with tf.Session() as sess:    
    for i in range(0,12):
        sess.run(q.enqueue(i))
    for i in range(0,12):
        print sess.run(q.dequeue())

因为需要保留2个元素，所以最后2个元素无法出列，导致阻塞

10.0
11.0
2.0
7.0
4.0
6.0
3.0
1.0
8.0
0.0
使用队列管理器

#!/usr/bin/env python2
# -*- coding: utf-8 -*-


import tensorflow as tf
import numpy as np

q=tf.RandomShuffleQueue(capacity=200,min_after_dequeue=2,dtypes="float")

counter=tf.Variable(0.)
increment_op=tf.assign_add(counter,tf.constant(1.0))
enqueue_op=q.enqueue([counter])

init=tf.global_variables_initializer()
qr=tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueue_op]*1)
#主线程
with tf.Session() as sess: 
    sess.run(init)
    enqueue_threads=qr.create_threads(sess,start=True)#启动入队线程
    for i in range(0,10):
        print sess.run(q.dequeue())

6.0
12.0
20.0
27.0
36.0
49.0
57.0
66.0
76.0
81.0

队列没能按我们期待的自然数列输出，且线程被阻断。

#!/usr/bin/env python2
# -*- coding: utf-8 -*-


import tensorflow as tf
import numpy as np

q=tf.RandomShuffleQueue(capacity=200,min_after_dequeue=2,dtypes="float")
#x=np.random.randint(100,size=100)
counter=tf.Variable(0.)
increment_op=tf.assign_add(counter,tf.constant(1.0))
enqueue_op=q.enqueue([counter])

init=tf.global_variables_initializer()
qr=tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueue_op]*1)
#主线程
with tf.Session() as sess: 
    sess.run(init)
    coord=tf.train.Coordinator()#协调器，协调线程间的关系。
    enqueue_threads=qr.create_threads(sess,coord=coord,start=True)#启动入队线程
    for i in range(0,10):
        print sess.run(q.dequeue())
    coord.request_stop()#通知其它线程关闭
    coord.join(enqueue_threads)#关闭其它线程后，合并到主线程

4.0
15.0
24.0
36.0
46.0
57.0
68.0
78.0
89.0
98.0