tf.FIFOQueue()

Tensorflow–tf.FIFOQueue详解
描述
tf.FIFOQueue根据先进先出（FIFO）的原则创建一个队列。队列是Tensorflow的一种数据结构，每个队列的元素都是包含一个或多个张量的元组，每个元组都有静态的类型和尺寸。入列和出列可以支持一次一个元素，或一次一批元素。它继承于Tensorflow队列执行的基类tf.QueueBase。队列是Tensorflow计算图异步处理张量的重要对象。

初始化
init

__init__(
capacity,
dtypes,
shapes=None,
names=None,
shared_name=None,
name='fifo_queue'
)
1
2
3
4
5
6
7
8
创建一个队列元素按照先进先出的顺序出列的队列。

属性
capacity
整形数字，标识队列可以存储的元素的最大数量
dtypes
一个Dtype对象的列表，长度等于队列元素中的张量个数
shapes
队列元素中的每个组成部分的尺寸对象组成的列表
name
队列操作的命名
shared_name
队列在不同session共享时使用的名称
names
队列元素中的每个组成部分的命名组成的列表
方法
close
close(
cancel_pending_enqueues=False,
name=None
)
1
2
3
4
此方法用来关闭队列，标示没有元素再入列，如果队列中还有元素，则出列操作可以执行，否则会失败。
参数：
cancel_pending_enqueues: 可选，boolean类型，默认False，为True的时候，挂起的请求将被取消；
name：可选，队列操作的名称
返回：
返回队列的关闭操作

dequeue
dequeue(name=None)
1
从队列中移出一个元素。当队列为空的时候，将会阻止此操作，直到有一个元素可以出列。
队列关闭的情况下，操作会报错。如果队列为空且没有入列操作可执行，则报 tf.errors.OutOfRangeError错误。 如果执行此操作的session关闭, 将报tf.errors.CancelledError错误。
参数：
name：可选，队列操作的名称
返回：
返回包含出列张量的元组

dequeue_many
dequeue_many(
n,
name=None
)
1
2
3
4
将n个元素连接到一起移出队列。本操作会将张量的第0维连接到一起形成一个张量出列，所以所有出列的元素组成的元组的第0维的尺寸为n。
如果队列已经关闭，或是队列中剩余的元素少于n个且没有要执行的入列操作会填充队列，则会报 OutOfRange exception的错。如果session关闭，则会报 tf.errors.CancelledError的错。
参数：
n: 出列张量包含的元素个数
name：可选，队列操作的名称
返回：
一组连接在一起出列张量组成的列表。

dequeue_up_to
dequeue_up_to(
n,
name=None
)
1
2
3
4
将n个元素连接到一起移出队列。本操作会将张量的第0维连接到一起形成一个张量出列，所以如果队列没有关闭，所有出列的元素组成的元组的第0维的尺寸为n。
如果队列已经关闭且队列中剩余的元素大于0少于n，则不会像dequeue_many报 OutOfRange exception的错，而是会立即返回少于n的元素。如果队列已经关闭且队列中剩余的元素等于0，则会像dequeue_many一样报OutOfRange exception的错。其他的操作和dequeue_many一样。
注意：不是所有的队列都支持这个操作，如果队列不支持这个操作，会报tf.errors.UnimplementedError错。
参数：
n: 出列张量包含的元素个数
name：可选，队列操作的名称
返回：
一组连接在一起出列张量组成的元组。

enqueue
enqueue(
vals,
name=None
)
1
2
3
4
队列中入列一个元素。如果执行的时候队列已满，将会阻止操作。如果队列关闭，执行会报tf.errors.CancelledError错。如果队列关闭的时候设置cancel_pending_enqueues=True或session关闭，操作会阻止且报tf.errors.CancelledError错误。
参数：
vals: 入列的数据，可以是张量、张量组成的列表或元组，或是字典
name：可选，队列操作的名称
返回：
一组张量的入列操作

enqueue_many
enqueue_many(
vals,
name=None
)
1
2
3
4
入列0或多个元素。本操作将每个元素的第0维切分出来组成多个队列元素作为输入，输入的张量第0维的大小要相同。如果队列已满，操作会被阻止。如果队列关闭，将报tf.errors.CancelledError错。如果队列关闭的时候设置cancel_pending_enqueues=True或session关闭，操作会阻止且报tf.errors.CancelledError错误。
参数：
vals: 入列的数据，可以是张量、张量组成的列表或元组，或是字典
name：可选，队列操作的名称
返回：
一批张量的入列操作

is_closed
is_closed(name=None)
1
队列关闭，返回true；否则，返回false

参数：
name：可选，队列操作的名称
返回：
队列关闭，返回true；否则，返回false

size
size(name=None)
1
计算队列的元素数目
参数：
name：可选，队列操作的名称
返回：
包含队列元素数目的张量

示例
举几个例子帮助理解队列的出列和入列

import tensorflow as tf

input_data=[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]]
q=tf.FIFOQueue(3,dtypes=[tf.float32])
init=q.enqueue(input_data)
output_data=q.dequeue()

with tf.Session() as sess:
init.run()
init.run()
print('1：',sess.run(output_data))
print('2：',sess.run(output_data))
print('3：',sess.run(output_data))
sess.run(q.close(cancel_pending_enqueues=True))
print(sess.run(q.is_closed()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
运行结果为

1： [3. 2. 1.]
2： [3. 2. 1.]
True
1
2
3
import tensorflow as tf

input_data=[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]]
input_data1=[[33.,22.,11.],[11.,22.,33.],[111.,222.,333.]]

q=tf.FIFOQueue(3,dtypes=[tf.float32])
init=q.enqueue(input_data)
init1=q.enqueue(input_data1)

output_data=q.dequeue()

with tf.Session() as sess:
init.run()
init1.run()
print('1：',sess.run(output_data))
print('2：',sess.run(output_data))
print('3：',sess.run(output_data))
sess.run(q.close(cancel_pending_enqueues=True))
print(sess.run(q.is_closed()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
运行结果为

1： [3. 2. 1.]
2： [33. 22. 11.]
True
1
2
3
enqueue()每次入列一个元素，对于同一个输入数据，多次入列会重复入列相同元素。dequeue()每次出列一个元素。

import tensorflow as tf

input_data=[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]]
print(tf.shape(input_data))
q=tf.FIFOQueue(3,dtypes=[tf.float32],shapes=[[]])
init=q.enqueue_many(input_data)
output_data=q.dequeue()
with tf.Session() as sess:
init.run()
print('1：',sess.run(output_data))
print('2：',sess.run(output_data))
print('3：',sess.run(output_data))
sess.run(q.close(cancel_pending_enqueues=True))
print(sess.run(q.is_closed()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
运行结果：

Tensor("Shape:0", shape=(2,), dtype=int32)
1： 3.0
2： 2.0
3： 1.0
True
1
2
3
4
5
因为shapes=[[]]，所以输入数据input_data=[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]]只有[3.,2.,1.]入列，所有第0维的张量为3.，2.，1.，enqueue_many会将他们组合在一起输入队列，所以队列的元素为3.，2.，1.

修改代码为：

import tensorflow as tf

input_data=[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]]
print(tf.shape(input_data))
q=tf.FIFOQueue(3,dtypes=[tf.float32,tf.float32],shapes=[[],[]])
init=q.enqueue_many(input_data)

output_data=q.dequeue()
with tf.Session() as sess:
init.run()
print('1：',sess.run(output_data))
print('2：',sess.run(output_data))
print('3：',sess.run(output_data))
sess.run(q.close(cancel_pending_enqueues=True))
print(sess.run(q.is_closed()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
运行结果为

Tensor("Shape:0", shape=(2,), dtype=int32)
1： [3.0, 11.0]
2： [2.0, 22.0]
3： [1.0, 33.0]
True
1
2
3
4
5
因为shapes=[[],[]]，所以输入数据input_data=[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]]有[[3.,2.,1.],[11.,22.,33.]]入列，先将[3.,2.,1.]和[11.,22.,33.]第0维的3.和11.组合成一个张量[3.0, 11.0]，然后2.和22.就变为0维度，组成第二个张量[2.0, 22.0]，最后1.和33.变为0维度，组成第三个张量[1.0, 33.0]，所以队列的元素为 [3.0, 11.0]，[2.0, 22.0]，[1.0, 33.0]

修改代码

import tensorflow as tf

input_data=[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]]
q=tf.FIFOQueue(3,dtypes=[tf.float32,tf.float32],shapes=[[],[]])
init = q.enqueue_many(input_data)
output_data_many=q.dequeue_many(2)

with tf.Session() as sess:
init.run()
print("Many：", sess.run(output_data_many))
sess.run(q.close(cancel_pending_enqueues=True))
print(sess.run(q.is_closed()))
1
2
3
4
5
6
7
8
9
10
11
12
运行结果

Many： [array([3., 2.], dtype=float32), array([11., 22.], dtype=float32)]
True
1
2
如上例队列的元素为 [3.0, 11.0]，[2.0, 22.0]，[1.0, 33.0]，dequeue_many(2)将队列元素的第0维3.，2.，1.中取2个数据组成[3., 2.]，然后11.，22.，33.变为第0维，再取2个数据组成[11., 22.]，所以出列的数据为[[3., 2.],[11., 22.],]

import tensorflow as tf

input_data=[[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]],[[23.,22.,21.],[211.,222.,233.],[2111.,2222.,2333.]]]
print(tf.shape(input_data))
q=tf.FIFOQueue(3,tf.float32)
init=q.enqueue_many(input_data)
output_data=q.dequeue()
with tf.Session() as sess:
init.run()
print('1：',sess.run(output_data))
print('2：',sess.run(output_data))
print('3：',sess.run(output_data))
sess.run(q.close(cancel_pending_enqueues=True))
print(sess.run(q.is_closed()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
运行结果：

Tensor("Shape:0", shape=(3,), dtype=int32)
1： [3. 2. 1.]
2： [11. 22. 33.]
3： [111. 222. 333.]
True
1
2
3
4
5
输入数据input_data=[[[3.,2.,1.],[11.,22.,33.],[111.,222.,333.]],[[23.,22.,21.],[211.,222.,233.],[2111.,2222.,2333.]]]为三维，所有第0维的张量为[3. 2. 1.]，[11. 22. 33.]， [111. 222. 333.]，enqueue_many会将他们组合在一起输入队列，所以队列的元素为[3. 2. 1.]，[11. 22. 33.]， [111. 222. 333.]
---------------------
作者：GaryBigPig
来源：CSDN
原文：https://blog.csdn.net/fegang2002/article/details/82949863
版权声明：本文为博主原创文章，转载请附上博文链接！