TensorFlow：数据读取的三种方式

TensorFlow的系统架构，如下图所示：

TensorFlow系统架构图

TensorFlow的系统架构分为两个部分：

前端系统：提供编程模型，负责构造计算图；
后端系统：提供运行时环境，负责执行计算图。

在处理数据的过程当中，由于现在的硬件性能的极大提升，数值计算过程可以通过加强硬件的方式来改善。

因此数据读取（即IO)往往会成为系统运行性能的瓶颈。

在TensorFlow框架中提供了三种数据读取方式：

Preloaded data: 预加载数据
Feeding: placeholder, feed_dict 由占位符代替数据，运行时填入数据
Reading from file: 从文件中直接读取

以上三种读取方式各有自己的特点，在了解这些特点或区别之前，需要知道TensorFlow是如何进行工作的。

TF的核心是用的C++写的，这样的好处是运行的速度较快，但是缺点并不灵活。

而python恰好相反，所以结合了两种语言的优势。涉及计算的核心算子和运行框架是用的C++写的，并提供API给python。

python调用这些API设计训练模型（graph），再将设计好的graph给后端去执行。

简而言之，Python的角色是Design，C++是Run。

1. Preload data: constant 预加载数据

特点：数据直接嵌入graph，由graph传入session中运行

import tensorflow as tf

#设计graph
x = tf.constant([1,2,3], name='x')
y = tf.constant([2,3,4], name='y')
z = tf.add(x,y, name='z')

#打开一个session，计算z
with tf.Session() as sess:
    print(sess.run(z))

运行结果如下：
这里写图片描述
在设计Graph的时候，x和y就被定义成了两个有值的列表，在计算z的时候直接取x1和x2的值。

2.Feeding: placeholder, feed_dict

特点：由占位符代替数据，运行时填入数据

import tensorflow as tf

#设计graph，用占位符代替
x = tf.placeholder(tf.int16)
y = tf.placeholder(tf.int16)
z = tf.add(x,y, name='z')

#打开一个session
with tf.Session() as sess:
    #创建数据
    xs = [1,2,3]
    ys = [2,3,4]
    #运行session,用feed_dict来将创建的数据传递进占位符
    print(sess.run(z, feed_dict={x: xs, y: ys}))

运行结果如下：
这里写图片描述

在这里x, y只是占位符，没有具体的值，那么运行的时候去哪取值呢？这时候就要用到sess.run()中的feed_dict参数。

将Python产生的数据喂给后端，并计算z。

3.Reading From File：直接从文件中读取

前两种方法很方便，但是遇到大型数据的时候就会很吃力，即使是Feeding，中间环节的增加也是不小的开销，比如数据类型转换等等。最优的方案就是在Graph定义好文件读取的方法，让TF自己去从文件中读取数据，并解码成可使用的样本集。

这种直接从文件中读取数据的方式需要设计成Queue的方式才能较好的解决IO瓶颈的问题。
Queue机制有如下三个特点：

producer-consumer pattern(生产消费模式)
独立于主线程执行
异步IO: reader.read(queue) tf.train.batch()

这里写图片描述

在上图中，首先由一个单线程把文件名堆入队列，两个Reader同时从队列中取文件名并读取数据，Decoder将读出的数据解码后堆入样本队列，最后单个或批量取出样本（图中没有展示样本出列）。

我们这里通过三段代码逐步实现上图的数据流，这里我们不使用随机，让结果更清晰。

文件准备

$ echo -e "Alpha1,A1\nAlpha2,A2\nAlpha3,A3" > A.csv  
$ echo -e "Bee1,B1\nBee2,B2\nBee3,B3" > B.csv  
$ echo -e "Sea1,C1\nSea2,C2\nSea3,C3" > C.csv  
$ cat A.csv  
Alpha1,A1  
Alpha2,A2  
Alpha3,A3

单个Reader，单个样本

import tensorflow as tf  
# 生成一个先入先出队列和一个QueueRunner  
filenames = ['A.csv', 'B.csv', 'C.csv']  
filename_queue = tf.train.string_input_producer(filenames, shuffle=False)  
# 定义Reader  
reader = tf.TextLineReader()  
key, value = reader.read(filename_queue)  
# 定义Decoder  
example, label = tf.decode_csv(value, record_defaults=[['null'], ['null']])  
# 运行Graph  
with tf.Session() as sess:  
    coord = tf.train.Coordinator()  #创建一个协调器，管理线程  
    threads = tf.train.start_queue_runners(coord=coord)  #启动QueueRunner, 此时文件名队列已经进队。  
    for i in range(10):  
        print example.eval()   #取样本的时候，一个Reader先从文件名队列中取出文件名，                               #读出数据，Decoder解析后进入样本队列。  
    coord.request_stop()  
    coord.join(threads)  
# outpt  
Alpha1  
Alpha2  
Alpha3  
Bee1  
Bee2  
Bee3  
Sea1  
Sea2  
Sea3  
Alpha1

单个Reader，多个样本

import tensorflow as tf  
filenames = ['A.csv', 'B.csv', 'C.csv'] 
## filenames = tf.train.match_filenames_once('.\data\*.csv') 
filename_queue = tf.train.string_input_producer(filenames, shuffle=False)  
reader = tf.TextLineReader()  
key, value = reader.read(filename_queue)  
example, label = tf.decode_csv(value, record_defaults=[['null'], ['null']])  
# 使用tf.train.batch()会多加了一个样本队列和一个QueueRunner。Decoder解后数据会进入这个队列，再批量出队。  
# 虽然这里只有一个Reader，但可以设置多线程，相应增加线程数会提高读取速度，但并不是线程越多越好。  
example_batch, label_batch = tf.train.batch(  
      [example, label], batch_size=5)  
with tf.Session() as sess:  
    coord = tf.train.Coordinator()  
    threads = tf.train.start_queue_runners(coord=coord)  
    for i in range(10):  
        print example_batch.eval()  
    coord.request_stop()  
    coord.join(threads)  
# output  
# ['Alpha1' 'Alpha2' 'Alpha3' 'Bee1' 'Bee2']  
# ['Bee3' 'Sea1' 'Sea2' 'Sea3' 'Alpha1']  
# ['Alpha2' 'Alpha3' 'Bee1' 'Bee2' 'Bee3']  
# ['Sea1' 'Sea2' 'Sea3' 'Alpha1' 'Alpha2']  
# ['Alpha3' 'Bee1' 'Bee2' 'Bee3' 'Sea1']  
# ['Sea2' 'Sea3' 'Alpha1' 'Alpha2' 'Alpha3']  
# ['Bee1' 'Bee2' 'Bee3' 'Sea1' 'Sea2']  
# ['Sea3' 'Alpha1' 'Alpha2' 'Alpha3' 'Bee1']  
# ['Bee2' 'Bee3' 'Sea1' 'Sea2' 'Sea3']  
# ['Alpha1' 'Alpha2' 'Alpha3' 'Bee1' 'Bee2']  
多Reader，多个样本

import tensorflow as tf  
filenames = ['A.csv', 'B.csv', 'C.csv']  
filename_queue = tf.train.string_input_producer(filenames, shuffle=False)  
reader = tf.TextLineReader()  
key, value = reader.read(filename_queue)  
record_defaults = [['null'], ['null']]  
example_list = [tf.decode_csv(value, record_defaults=record_defaults)  
                  for _ in range(2)]  # Reader设置为2  
# 使用tf.train.batch_join()，可以使用多个reader，并行读取数据。每个Reader使用一个线程。  
example_batch, label_batch = tf.train.batch_join(  
      example_list, batch_size=5)  
with tf.Session() as sess:  
    coord = tf.train.Coordinator()  
    threads = tf.train.start_queue_runners(coord=coord)  
    for i in range(10):  
        print example_batch.eval()  
    coord.request_stop()  
    coord.join(threads)  

# output  
# ['Alpha1' 'Alpha2' 'Alpha3' 'Bee1' 'Bee2']  
# ['Bee3' 'Sea1' 'Sea2' 'Sea3' 'Alpha1']  
# ['Alpha2' 'Alpha3' 'Bee1' 'Bee2' 'Bee3']  
# ['Sea1' 'Sea2' 'Sea3' 'Alpha1' 'Alpha2']  
# ['Alpha3' 'Bee1' 'Bee2' 'Bee3' 'Sea1']  
# ['Sea2' 'Sea3' 'Alpha1' 'Alpha2' 'Alpha3']  
# ['Bee1' 'Bee2' 'Bee3' 'Sea1' 'Sea2']  
# ['Sea3' 'Alpha1' 'Alpha2' 'Alpha3' 'Bee1']  
# ['Bee2' 'Bee3' 'Sea1' 'Sea2' 'Sea3']  
# ['Alpha1' 'Alpha2' 'Alpha3' 'Bee1' 'Bee2']

tf.train.batch与tf.train.shuffle_batch'数是单个Reader读取，但是可以多线程。tf.train.batch_join'和tf.train.shuffle_batch_join可设置多Reader读取，每个Reader使用一个线程。至于两种方法的效率，单Reader时，2个线程就达到了速度的极限。多Reader时，2个Reader就达到了极限。所以并不是线程越多越快，甚至更多的线程反而会使效率下降。

迭代控制

filenames = ['A.csv', 'B.csv', 'C.csv']  
filename_queue = tf.train.string_input_producer(filenames, shuffle=False, num_epochs=3)  # num_epoch: 设置迭代数  
reader = tf.TextLineReader()  
key, value = reader.read(filename_queue)  
record_defaults = [['null'], ['null']]  
example_list = [tf.decode_csv(value, record_defaults=record_defaults)  
                  for _ in range(2)]  
example_batch, label_batch = tf.train.batch_join(  
      example_list, batch_size=5)  
init_local_op = tf.initialize_local_variables()  
with tf.Session() as sess:  
    sess.run(init_local_op)   # 初始化本地变量   
    coord = tf.train.Coordinator()  
    threads = tf.train.start_queue_runners(coord=coord)  
    try:  
        while not coord.should_stop():  
            print example_batch.eval()  
    except tf.errors.OutOfRangeError:  
        print('Epochs Complete!')  
    finally:  
        coord.request_stop()  
    coord.join(threads)  
    coord.request_stop()  
    coord.join(threads)  
# output  
# ['Alpha1' 'Alpha2' 'Alpha3' 'Bee1' 'Bee2']  
# ['Bee3' 'Sea1' 'Sea2' 'Sea3' 'Alpha1']  
# ['Alpha2' 'Alpha3' 'Bee1' 'Bee2' 'Bee3']  
# ['Sea1' 'Sea2' 'Sea3' 'Alpha1' 'Alpha2']  
# ['Alpha3' 'Bee1' 'Bee2' 'Bee3' 'Sea1']  
# Epochs Complete!

在迭代控制中，记得添加 tf.initialize_local_variables()，官网教程没有说明，但是如果不初始化，运行就会报错。

参考博客：https://blog.csdn.net/chengshuhao1991/article/details/78644966