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
版权声明:本文为博主原创文章,转载请附上博文链接!

posted on 2019-01-02 11:19  AI大道理  阅读(403)  评论(0编辑  收藏  举报

导航