tensorflow中 tf.train.slice_input_producer() 函数和 tf.train.batch() 函数

2024-06-12 12:32
文章标签 函数 input tf train batch tensorflow slice producer

本文主要是介绍tensorflow中 tf.train.slice_input_producer() 函数和 tf.train.batch() 函数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

原创：https://blog.csdn.net/dcrmg/article/details/79776876

别人总结的转载方便自己以后看

tensorflow数据读取机制

tensorflow中为了充分利用GPU，减少GPU等待数据的空闲时间，使用了两个线程分别执行数据读入和数据计算。

具体来说就是使用一个线程源源不断的将硬盘中的图片数据读入到一个内存队列中，另一个线程负责计算任务，所需数据直接从内存队列中获取。

tf在内存队列之前，还设立了一个文件名队列，文件名队列存放的是参与训练的文件名，要训练 N个epoch，则文件名队列中就含有N个批次的所有文件名。 示例图如下：


图片来至于 https://zhuanlan.zhihu.com/p/27238630）

在N个epoch的文件名最后是一个结束标志，当tf读到这个结束标志的时候，会抛出一个 OutofRange 的异常，外部捕获到这个异常之后就可以结束程序了。而创建tf的文件名队列就需要使用到 tf.train.slice_input_producer 函数。


tf.train.slice_input_producer


tf.train.slice_input_producer是一个tensor生成器，作用是按照设定，每次从一个tensor列表中按顺序或者随机抽取出一个tensor放入文件名队列。


[python]  view plain copy
  1. slice_input_producer(tensor_list, num_epochs=None, shuffle=True, seed=None,  
  2.                          capacity=32, shared_name=None, name=None)  

  • 第一个参数 tensor_list：包含一系列tensor的列表，表中tensor的第一维度的值必须相等，即个数必须相等，有多少个图像，就应该有多少个对应的标签。
  • 第二个参数num_epochs: 可选参数，是一个整数值，代表迭代的次数，如果设置 num_epochs=None,生成器可以无限次遍历tensor列表，如果设置为 num_epochs=N，生成器只能遍历tensor列表N次。
  • 第三个参数shuffle： bool类型，设置是否打乱样本的顺序。一般情况下，如果shuffle=True，生成的样本顺序就被打乱了，在批处理的时候不需要再次打乱样本，使用 tf.train.batch函数就可以了;如果shuffle=False,就需要在批处理时候使用 tf.train.shuffle_batch函数打乱样本。
  • 第四个参数seed: 可选的整数，是生成随机数的种子，在第三个参数设置为shuffle=True的情况下才有用。
  • 第五个参数capacity：设置tensor列表的容量。
  • 第六个参数shared_name：可选参数，如果设置一个‘shared_name’，则在不同的上下文环境（Session）中可以通过这个名字共享生成的tensor。
  • 第七个参数name：可选，设置操作的名称。


tf.train.slice_input_producer定义了样本放入文件名队列的方式，包括迭代次数，是否乱序等，要真正将文件放入文件名队列，还需要调用tf.train.start_queue_runners 函数来启动执行文件名队列填充的线程，之后计算单元才可以把数据读出来，否则文件名队列为空的，计算单元就会处于一直等待状态，导致系统阻塞。


tf.train.slice_input_producer 和 tf.train.start_queue_runners 使用：

[python]  view plain copy
  1. import tensorflow as tf  
  2.   
  3. images = ['img1', 'img2', 'img3', 'img4', 'img5']  
  4. labels= [1,2,3,4,5]  
  5.   
  6. epoch_num=8  
  7.   
  8. f = tf.train.slice_input_producer([images, labels],num_epochs=None,shuffle=False)  
  9.   
  10. with tf.Session() as sess:  
  11.     sess.run(tf.global_variables_initializer())  
  12.     coord = tf.train.Coordinator()  
  13.     threads = tf.train.start_queue_runners(sess=sess, coord=coord)  
  14.     for i in range(epoch_num):  
  15.         k = sess.run(f)  
  16.         print '************************'  
  17.         print (i,k)  
  18.   
  19.     coord.request_stop()  
  20.     coord.join(threads)  


tf.train.slice_input_producer函数中shuffle=False，不对tensor列表乱序，输出：

[python]  view plain copy
  1. ************************  
  2. (0, ['img1', 1])  
  3. ************************  
  4. (1, ['img2', 2])  
  5. ************************  
  6. (2, ['img3', 3])  
  7. ************************  
  8. (3, ['img4', 4])  
  9. ************************  
  10. (4, ['img5', 5])  
  11. ************************  
  12. (5, ['img1', 1])  
  13. ************************  
  14. (6, ['img2', 2])  
  15. ************************  
  16. (7, ['img3', 3])  


如果设置shuffle=True，输出乱序：

[python]  view plain copy
  1. ************************  
  2. (0, ['img5', 5])  
  3. ************************  
  4. (1, ['img4', 4])  
  5. ************************  
  6. (2, ['img1', 1])  
  7. ************************  
  8. (3, ['img3', 3])  
  9. ************************  
  10. (4, ['img2', 2])  
  11. ************************  
  12. (5, ['img3', 3])  
  13. ************************  
  14. (6, ['img2', 2])  
  15. ************************  
  16. (7, ['img1', 1])  



tf.train.batch


tf.train.batch是一个tensor队列生成器，作用是按照给定的tensor顺序，把batch_size个tensor推送到文件队列，作为训练一个batch的数据，等待tensor出队执行计算。
[python]  view plain copy
  1. batch(tensors, batch_size, num_threads=1, capacity=32,  
  2.           enqueue_many=False, shapes=None, dynamic_pad=False,  
  3.           allow_smaller_final_batch=False, shared_name=None, name=None)  
  • 第一个参数tensors：tensor序列或tensor字典，可以是含有单个样本的序列;
  • 第二个参数batch_size: 生成的batch的大小;
  • 第三个参数num_threads：执行tensor入队操作的线程数量，可以设置使用多个线程同时并行执行，提高运行效率，但也不是数量越多越好;
  • 第四个参数capacity： 定义生成的tensor序列的最大容量;
  • 第五个参数enqueue_many： 定义第一个传入参数tensors是多个tensor组成的序列，还是单个tensor;
  • 第六个参数shapes： 可选参数，默认是推测出的传入的tensor的形状;
  • 第七个参数dynamic_pad： 定义是否允许输入的tensors具有不同的形状，设置为True，会把输入的具有不同形状的tensor归一化到相同的形状;
  • 第八个参数allow_smaller_final_batch： 设置为True，表示在tensor队列中剩下的tensor数量不够一个batch_size的情况下，允许最后一个batch的数量少于batch_size， 设置为False，则不管什么情况下，生成的batch都拥有batch_size个样本;
  • 第九个参数shared_name： 可选参数，设置生成的tensor序列在不同的Session中的共享名称;
  • 第十个参数name： 操作的名称;

如果tf.train.batch的第一个参数 tensors 传入的是tenor列表或者字典，返回的是tensor列表或字典，如果传入的是只含有一个元素的列表，返回的是单个的tensor，而不是一个列表。

以下举例： 一共有5个样本，设置迭代次数是2次，每个batch中含有3个样本，不打乱样本顺序：

[python]  view plain copy
  1. # -*- coding:utf-8 -*-  
  2. import tensorflow as tf  
  3. import numpy as np  
  4.   
  5. # 样本个数  
  6. sample_num=5  
  7. # 设置迭代次数  
  8. epoch_num = 2  
  9. # 设置一个批次中包含样本个数  
  10. batch_size = 3  
  11. # 计算每一轮epoch中含有的batch个数  
  12. batch_total = int(sample_num/batch_size)+1  
  13.   
  14. # 生成4个数据和标签  
  15. def generate_data(sample_num=sample_num):  
  16.     labels = np.asarray(range(0, sample_num))  
  17.     images = np.random.random([sample_num, 224, 224, 3])  
  18.     print('image size {},label size :{}'.format(images.shape, labels.shape))  
  19.   
  20.     return images,labels  
  21.   
  22. def get_batch_data(batch_size=batch_size):  
  23.     images, label = generate_data()  
  24.     # 数据类型转换为tf.float32  
  25.     images = tf.cast(images, tf.float32)  
  26.     label = tf.cast(label, tf.int32)  
  27.   
  28.     #从tensor列表中按顺序或随机抽取一个tensor  
  29.     input_queue = tf.train.slice_input_producer([images, label], shuffle=False)  
  30.   
  31.     image_batch, label_batch = tf.train.batch(input_queue, batch_size=batch_size, num_threads=1, capacity=64)  
  32.     return image_batch, label_batch  
  33.   
  34. image_batch, label_batch = get_batch_data(batch_size=batch_size)  
  35.   
  36. with tf.Session() as sess:  
  37.     coord = tf.train.Coordinator()  
  38.     threads = tf.train.start_queue_runners(sess, coord)  
  39.     try:  
  40.         for i in range(epoch_num):  # 每一轮迭代  
  41.             print '************'  
  42.             for j in range(batch_total): #每一个batch  
  43.                 print '--------'  
  44.                 # 获取每一个batch中batch_size个样本和标签  
  45.                 image_batch_v, label_batch_v = sess.run([image_batch, label_batch])  
  46.                 # for k in  
  47.                 print(image_batch_v.shape, label_batch_v)  
  48.     except tf.errors.OutOfRangeError:  
  49.         print("done")  
  50.     finally:  
  51.         coord.request_stop()  
  52.     coord.join(threads)  
输出：
[python]  view plain copy
  1. ************  
  2. --------  
  3. ((3, 224, 224, 3), array([0, 1, 2], dtype=int32))  
  4. --------  
  5. ((3, 224, 224, 3), array([3, 4, 0], dtype=int32))  
  6. ************  
  7. --------  
  8. ((3, 224, 224, 3), array([1, 2, 3], dtype=int32))  
  9. --------  
  10. ((3, 224, 224, 3), array([4, 0, 1], dtype=int32))  

每次生成的batch中含有3个样本，不打乱次序，所以生成的tensor序列是按照‘0,1,2,3,4,0,1,2,3……’排列的。

如果设置每个batch中含有2个样本，打乱次序，即设置 batch_size = 2, tf.train.slice_input_producer函数中 shuffle=True，输出为：
[python]  view plain copy
  1. ************  
  2. --------  
  3. ((2, 224, 224, 3), array([3, 0], dtype=int32))  
  4. --------  
  5. ((2, 224, 224, 3), array([4, 1], dtype=int32))  
  6. --------  
  7. ((2, 224, 224, 3), array([2, 3], dtype=int32))  
  8. ************  
  9. --------  
  10. ((2, 224, 224, 3), array([1, 0], dtype=int32))  
  11. --------  
  12. ((2, 224, 224, 3), array([2, 4], dtype=int32))  
  13. --------  
  14. ((2, 224, 224, 3), array([1, 4], dtype=int32))  

与tf.train.batch函数相对的还有一个tf.train.shuffle_batch函数，两个函数作用一样，都是生成一定数量的tensor,组成训练一个batch需要的数据集，区别是tf.train.shuffle_batch会打乱样本顺序。

这篇关于tensorflow中 tf.train.slice_input_producer() 函数和 tf.train.batch() 函数的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1054222。

相关文章

Oracle的to_date()函数详解

Oracle的to_date()函数详解

《Oracle的to_date()函数详解》Oracle的to_date()函数用于日期格式转换,需要注意Oracle中不区分大小写的MM和mm格式代码,应使用mi代替分钟,此外,Oracle还支持毫... 目录oracle的to_date()函数一.在使用Oracle的to_date函数来做日期转换二.日
阅读更多...
C++11的函数包装器std::function使用示例

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function
阅读更多...
hdu1171（母函数或多重背包）

hdu1171（母函数或多重背包）

题意：把物品分成两份，使得价值最接近 可以用背包，或者是母函数来解，母函数（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v） 其中指数为价值，每一项的数目为（该物品数+1）个 代码如下： #include<iostream>#include<algorithm>
阅读更多...
C++操作符重载实例(独立函数)

C++操作符重载实例(独立函数)

C++操作符重载实例，我们把坐标值CVector的加法进行重载，计算c3=c1+c2时，也就是计算x3=x1+x2，y3=y1+y2，今天我们以独立函数的方式重载操作符+（加号），以下是C++代码： c1802.cpp源代码： D:\YcjWork\CppTour>vim c1802.cpp #include <iostream>using namespace std;/*** 以独立函数
阅读更多...
函数式编程思想

函数式编程思想

我们经常会用到各种各样的编程思想，例如面向过程、面向对象。不过笔者在该博客简单介绍一下函数式编程思想. 如果对函数式编程思想进行概括，就是f(x) = na(x) , y=uf(x)…至于其他的编程思想，可能是y=a(x)+b(x)+c(x)…，也有可能是y=f(x)=f(x)/a + f(x)/b+f(x)/c… 面向过程的指令式编程 面向过程，简单理解就是y=a(x)+b(x)+c(x)
阅读更多...
利用matlab bar函数绘制较为复杂的柱状图，并在图中进行适当标注

利用matlab bar函数绘制较为复杂的柱状图，并在图中进行适当标注

示例代码和结果如下：小疑问：如何自动选择合适的坐标位置对柱状图的数值大小进行标注？😂 clear; close all;x = 1:3;aa=[28.6321521955954 26.2453660695847 21.69102348512086.93747104431360 6.25442246899816 3.342835958564245.51365061796319 4.87
阅读更多...
OpenCV结构分析与形状描述符（11）椭圆拟合函数fitEllipse()的使用

OpenCV结构分析与形状描述符（11）椭圆拟合函数fitEllipse()的使用

操作系统：ubuntu22.04 OpenCV版本：OpenCV4.9 IDE:Visual Studio Code 编程语言：C++11 算法描述 围绕一组2D点拟合一个椭圆。 该函数计算出一个椭圆，该椭圆在最小二乘意义上最好地拟合一组2D点。它返回一个内切椭圆的旋转矩形。使用了由[90]描述的第一个算法。开发者应该注意，由于数据点靠近包含的 Mat 元素的边界，返回的椭圆/旋转矩形数据
阅读更多...
Unity3D 运动之Move函数和translate

Unity3D 运动之Move函数和translate

CharacterController.Move 移动 function Move (motion : Vector3) : CollisionFlags Description描述 A more complex move function taking absolute movement deltas. 一个更加复杂的运动函数，每次都绝对运动。 Attempts to
阅读更多...
✨机器学习笔记（二）—— 线性回归、代价函数、梯度下降

✨机器学习笔记（二）—— 线性回归、代价函数、梯度下降

1️⃣线性回归（linear regression） f w , b ( x ) = w x + b f_{w,b}(x) = wx + b fw,b​(x)=wx+b 🎈A linear regression model predicting house prices： 如图是机器学习通过监督学习运用线性回归模型来预测房价的例子，当房屋大小为1250 f e e t 2 feet^
阅读更多...
JavaSE（十三）——函数式编程（Lambda表达式、方法引用、Stream流）

JavaSE（十三）——函数式编程（Lambda表达式、方法引用、Stream流）

函数式编程 函数式编程 是 Java 8 引入的一个重要特性，它允许开发者以函数作为一等公民（first-class citizens）的方式编程，即函数可以作为参数传递给其他函数，也可以作为返回值。 这极大地提高了代码的可读性、可维护性和复用性。函数式编程的核心概念包括高阶函数、Lambda 表达式、函数式接口、流（Streams）和 Optional 类等。 函数式编程的核心是Lambda
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2