机器学习——TensorflowIO操作-6

Tensorflow与深度学习

线程队列与IO操作

1、队列和线程

2、文件读取

3、图片处理

在计算争分夺秒的时候，需要去提高IO读取的速度？

当然需要，因为神经网络的训练量往往几个亿，实际训练的时候只是读出一部分训练
既然如此，边读边训练当然是正确的，况且这里是真正的多线程

队列和线程

1、队列与队列管理器

2、线程和协调器

Tensorflow队列

——在训练样本的时候，希望读入的训练样本时有序的

——tf.FIFOQueue 先进先出队列，按顺序出队列

——tf.RandomShuffleQueue 随机出队列

tf.FIFOQueue

——FIFOQueue(capacity, dtypes, name=‘fifo_queue’)

——创建一个以先进先出的顺序对元素进行排队的队列

——capacity：整数。可能存储在此队列中的元素数量的上限

——dtypes：DType对象列表。长度dtypes必须等于每个队列元素中的张量数,dtype的类型形状，决定了后面进队列元素形状

——method

——dequeue(name=None) 出队

——enqueue(vals, name=None): 入队

——enqueue_many(vals, name=None):vals列表或者元组

——返回一个进队列操作

——

——size(name=None)

完成一个出队列、+1、入队列操作(同步操作)

特性讲解：
数据的依赖性

out_q = Q.dequeue()
data = out_q + 1
en_q = Q.enqueue(data)

完成一个出队，入队+1的操作
那么在执行时，因为数据的依赖性，只需要

 # 处理数据
    for i in range(100):
        sess.run(en_q)

即前面定义的都是图的结构，后面才开始迭代运算

# 1、首先定义队列
Q = tf.FIFOQueue(3, tf.float32)
# 放入一些数据
enq_many = Q.enqueue_many([[0.1, 0.2, 0.3], ])

定义队列的结构，然后传入数据([[0.1, 0.2, 0.3], ])
加逗号表示传入的是元组，如果直接输入[0.1, 0.2, 0.3]会被理解为张量就不能使用了

import tensorflow as tf
import os


# 模拟一下同步先处理数据，然后才能取数据训练
# tensorflow当中，运行操作有依赖性

# 1、首先定义队列
Q = tf.FIFOQueue(3, tf.float32)

# 放入一些数据
enq_many = Q.enqueue_many([[0.1, 0.2, 0.3], ])

# 2、定义一些处理数据的螺距，取数据的过程      取数据，+1， 入队列

out_q = Q.dequeue()

data = out_q + 1

en_q = Q.enqueue(data)

with tf.Session() as sess:
    # 初始化队列
    sess.run(enq_many)

    # 处理数据
    for i in range(100):
        sess.run(en_q)

    # 训练数据
    for i in range(Q.size().eval()):
        print(sess.run(Q.dequeue()))

入队列需要注意

分析：当数据量很大时，入队操作从硬盘中读取数据，放入内存中，

主线程需要等待入队操作完成，才能进行训练。会话里可以运行多个线程，实现异步读取。

队列管理器

——tf.train.QueueRunner(queue, enqueue_ops=None)

——创建一个QueueRunner

——

——queue：A Queue

——enqueue_ops：添加线程的队列操作列表，[]*2,指定两个线程

——create_threads(sess, coord=None,start=False)

—— 创建线程来运行给定会话的入队操作

——start：布尔值，如果True启动线程；如果为False调用者

——必须调用start()启动线程

——coord:线程协调器，后面线程管理需要用到

——return：

通过队列管理器来实现变量加1，入队，主线程出队列的操作，观察效果？

(异步操作)

分析：这时候有一个问题就是，入队自顾自的去执行，在需要的出队操作完成之后，程序没法结束。需要一个实现线程间的同步，终

止其他线程。

线程协调器

——tf.train.Coordinator()

—— 线程协调员,实现一个简单的机制来协调一组线程的终止

——

——request_stop()

——should_stop() 检查是否要求停止

——join(threads=None, stop_grace_period_secs=120)

——等待线程终止

——

——return:线程协调员实例

——

文件读取

1、文件读取流程

2、文件读取API

3、文件读取案例

import tensorflow as tf
import os
#制造一个队列，动态添加数据，动态读取，可以容纳200个数
fifo_queue = tf.FIFOQueue(200, tf.float32)
#定义如何向队列加入数据，以前一个数据为基，自增，
tf_variable = tf.Variable(0.0)
tf_assign_add = tf.assign_add(tf_variable, tf.constant(1.0))
fifo_queue_enqueue = fifo_queue.enqueue(tf_assign_add)

#设计多线程队列完成数据的组装,队列管理器op，指定线程和线程的操作
tf_train_queue_runner = tf.train.QueueRunner(fifo_queue, enqueue_ops=[fifo_queue_enqueue] * 2)
#初始化变量OP
variables_initializer = tf.global_variables_initializer()
#图设计完毕
with tf.Session() as sess:
    #初始化变量
    sess.run(variables_initializer)
    #开启图，开启线程管理器
    train_coordinator = tf.train.Coordinator()
    #开启子线程执行队列预设操作
    threads = tf_train_queue_runner.create_threads(sess, coord=train_coordinator, start=True)
    #此时数据已经在源源不断的生成了，模拟为不断地从文件中读取数据

    #模拟训练，取出组装的部分数据，根据多线程特性，此时数据还在生成
    for i in range(100):
        print(sess.run(fifo_queue.dequeue()))
    #训练完毕，关闭拿数据线程,回收线程
    train_coordinator.request_stop()
    train_coordinator.join(threads)

文件读取流程2

1、文件读取API-文件队列构造

——tf.train.string_input_producer(string_tensor,shuffle=True)

——将输出字符串（例如文件名）输入到管道队列

——

——string_tensor 含有文件名的1阶张量

——num_epochs:过几遍数据，默认无限过数据

——return:具有输出字符串的队列

2、文件读取API-文件阅读器

——根据文件格式，选择对应的文件阅读器

——class tf.TextLineReader

——阅读文本文件逗号分隔值（CSV）格式,默认按行读取

——return：读取器实例

——

——tf.FixedLengthRecordReader(record_bytes)

——要读取每个记录是固定数量字节的二进制文件

——record_bytes:整型，指定每次读取的字节数

——return：读取器实例

——

——tf.TFRecordReader

——读取TfRecords文件

——有一个共同的读取方法：

——read(file_queue)：从队列中指定数量内容

——返回一个Tensors元组（key文件名字，value默认的内容(行，字节)）

3、文件读取API-文件内容解码器

——由于从文件中读取的是字符串，需要函数去解析这些字符串到张量

——

——tf.decode_csv(records,record_defaults=None,field_delim = None，name = None)

——将CSV转换为张量，与tf.TextLineReader搭配使用

——records:tensor型字符串，每个字符串是csv中的记录行

——field_delim:默认分割符”,”

——record_defaults:参数决定了所得张量的类型，并设置一个值在输入字符串中缺少使用默认值,如

——tf.decode_raw(bytes,out_type,little_endian = None，name = None)

—— 将字节转换为一个数字向量表示，字节为一字符串类型的张量,与函数tf.FixedLengthRecordReader搭配使用，二进制读取为uint8格式

开启线程操作

——tf.train.start_queue_runners(sess=None,coord=None)

—— 收集所有图中的队列线程，并启动线程

——sess:所在的会话中

——coord：线程协调器

——return：返回所有线程队列

如果读取的文件为多个或者样本数量为多个，怎么去管道读取？

管道读端批处理

——tf.train.batch(tensors,batch_size,num_threads = 1,capacity = 32,name=None)

——读取指定大小（个数）的张量

——tensors：可以是包含张量的列表

——batch_size:从队列中读取的批处理大小

——num_threads：进入队列的线程数

——capacity：整数，队列中元素的最大数量

——return:tensors

——

——tf.train.shuffle_batch(tensors,batch_size,capacity,min_after_dequeue,

—— num_threads=1,)

——乱序读取指定大小（个数）的张量

——min_after_dequeue:留下队列里的张量个数，能够保持随机打乱

文件读取案例

1、文件简单读取
csv文件读取

def csvread(filelist):
    """
    读取CSV文件
    :param filelist: 文件路径+名字的列表
    :return: 读取的内容
    """
    # 1、构造文件的队列
    file_queue = tf.train.string_input_producer(filelist)
    # 2、构造csv阅读器读取队列数据（按一行）
    reader = tf.TextLineReader()
    key, value = reader.read(file_queue)
    # 3、对每行内容解码
    # record_defaults:指定每一个样本的每一列的类型，指定默认值[["None"], [4.0]]
    records = [["None"], ["None"]]
    example, label = tf.decode_csv(value, record_defaults=records)
    # 4、想要读取多个数据，就需要批处理
    example_batch, label_batch = tf.train.batch([example, label], batch_size=9, num_threads=1, capacity=9)
    print(example_batch, label_batch)
    return example_batch, label_batch

图片文件读取

def picread(filelist):
    """
    读取狗图片并转换成张量
    :param filelist: 文件路径+ 名字的列表
    :return: 每张图片的张量
    """
    # 1、构造文件队列
    file_queue = tf.train.string_input_producer(filelist)
    # 2、构造阅读器去读取图片内容（默认读取一张图片）
    reader = tf.WholeFileReader()
    key, value = reader.read(file_queue)
    print(value)
    # 3、对读取的图片数据进行解码
    image = tf.image.decode_jpeg(value)
    print(image)
    # 5、处理图片的大小（统一大小）
    image_resize = tf.image.resize_images(image, [200, 200])
    print(image_resize)
    # 注意：一定要把样本的形状固定 [200, 200, 3],在批处理的时候要求所有数据形状必须定义
    image_resize.set_shape([200, 200, 3])
    print(image_resize)
    # 6、进行批处理
    image_batch = tf.train.batch([image_resize], batch_size=20, num_threads=1, capacity=20)
    print(image_batch)
    return image_batch

2、CIFAR-10二进制数据读取

import tensorflow as tf
import os
# 定义cifar的数据等命令行参数
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("cifar_dir", "./data/cifar10/cifar-10-batches-bin/", "文件的目录")
tf.app.flags.DEFINE_string("cifar_tfrecords", "./tmp/cifar.tfrecords", "存进tfrecords的文件")
class CifarRead(object):
    """完成读取二进制文件， 写进tfrecords，读取tfrecords
    """
    def __init__(self, filelist):
        # 文件列表
        self.file_list = filelist
        # 定义读取的图片的一些属性
        self.height = 32
        self.width = 32
        self.channel = 3
        # 二进制文件每张图片的字节
        self.label_bytes = 1
        self.image_bytes = self.height * self.width * self.channel
        self.bytes = self.label_bytes + self.image_bytes
    def read_and_decode(self):
        #构造文件队列
        file_queve = tf.train.string_input_producer(self.file_list)
        #构造二进制文件读取器，读取内容，大小已经预设
        reader = tf.FixedLengthRecordReader(self.bytes)
        key,value = reader.read(file_queve)
        #解码内容，二进制文件
        label_image = tf.decode_raw(value, tf.uint8)
        #分解出图片和标签数据，得到特征值和标签值
        label= tf.cast(tf.slice(label_image, [0], [self.label_bytes]), tf.int32)
        image = tf.slice(label_image, [self.label_bytes], [self.image_bytes])
        #对图片的特征数据进行形状改变
        image_reshape = tf.reshape(image, [self.height, self.width, self.channel])
        #批量处理数据
        image_batch,lable_batch = tf.train.batch([image_reshape, label], batch_size=10, num_threads=1, capacity=10)
        return image_batch,lable_batch
    def write_tfrecords(self,image_batch,lable_batch):
        """将图片的特征值和标签存入tfrecordes"""
        #建立tfrecords存储器
        writer = tf.python_io.TFRecordWriter(FLAGS.cifar_tfrecords)
        #循环将样本写入文件，每张图片都要遵守example协议
        for i in range(10 ):
            #取出第i个图片数据的特征值和目标值
            image=image_batch[i].eval().tostring()
            lable=int(lable_batch[i].eval([0]))
            #构造一个样本的example
            example = tf.train.Example(features=tf.train.Features(
                feature={"image": tf.train.Feature(bytes_list=tf.train.BytesList(value=[image])),
                         "lable": tf.train.Feature(int64_list=tf.train.Int64List(value=[lable])), }))
            #写入单独的样本
            writer.write(example.SerializeToString())
            #关闭
            writer.close()
            return None
    def read_from_tfrecords(self):
        #构造文件队列
        file_queve = tf.train.string_input_producer([FLAGS.cifar_tfrecords])
        #构造文件阅读器，读取example,value
        reader = tf.TFRecordReader()
        key,value = reader.read(file_queve)
        #解析example
        features = tf.parse_single_example(value, features={
            "image": tf.FixedLenFeature([], tf.string),
            "label": tf.FixedLenFeature([], tf.int64),
        })
        #解码内容，如果读取的内容格式是String需要解码，int64,float32不需要
        image=tf.decode_raw(features['image'],tf.uint8)
        #固定图片的形状，方便批处理
        image_reshape=tf.reshape(image,[self.height,self.width,self.channel])
        lable = tf.cast(features["lable"], tf.int32)
        #进行批处理
        image_batch,label_batch = tf.train.batch([image_reshape, lable], batch_size=10, num_threads=1, capacity=10)
        return image_batch,label_batch
if __name__=="__main__":
    #找到文件，放入列表    路径+名字
    file_name = os.listdir(FLAGS.cifar_dir)
    fileList = [os.path.join(FLAGS.cifar_dir.file) for file in file_name if file[-3:] == "bin"]
    cf=CifarRead(fileList)
    image_batch,label_batch = cf.read_from_tfrecords()
    #开启会话
    with tf.Session() as sess:
        # 存进tfrecords文件
        # cf.write_ro_tfrecords(image_batch, label_batch)
        print(sess.run([image_batch,label_batch]))
        

文件读取案例流程

CIFAR-10二进制数据读取

图像读取

1、图像基本知识

2、图像读取API

3、 TFRecords分析、存取
tf是一种十分完善的格式，可以免去重定义分割特征值和训练值的步骤

图像基本知识

图像数字化三要素

——三要素：长度、宽度、通道数

三通道，RGB

一通道，灰度值

三要素与张量的关系

指定3-D张量：

长度

通道数

宽度

图像基本操作

目的：

1、增加图片数据的统一性

2、所有图片转换成指定大小

3、缩小图片数据量，防止增加开销

操作：

1、缩小图片大小

图像基本操作API

——tf.image.resize_images(images, size)

——缩小图片

——images：4-D形状[batch, height, width, channels]或3-D形状的张

——量[height, width, channels]的图片数据

——size：1-D int32张量：new_height, new_width，图像的新尺寸

——返回4-D格式或者3-D格式图片

图片批处理案例

狗图片读取

图像读取API

——图像读取器

——tf.WholeFileReader

——将文件的全部内容作为值输出的读取器

——return：读取器实例

——read(file_queue):输出将是一个文件名（key）和该文件的内容值）

——

——图像解码器

——tf.image.decode_jpeg(contents)

——将JPEG编码的图像解码为uint8张量

——return:uint8张量，3-D形状[height, width, channels]

——tf.image.decode_png(contents)

——将PNG编码的图像解码为uint8或uint16张量

——return:张量类型，3-D形状[height, width, channels]

——

图片批处理案例流程

1、构造图片文件队列

2、构造图片阅读器

3、读取图片数据

4、处理图片数据

TFRecords分析、存取

——TFRecords是Tensorflow设计的一种内置文件格式，是一种二进制文件，

——它能更好的利用内存，更方便复制和移动

——

——为了将二进制数据和标签(训练的类别标签)数据存储在同一个文件中

TFRecords文件分析

——文件格式：*.tfrecords

——

——

——写入文件内容：Example协议块

TFRecords存储

——1、建立TFRecord存储器

——tf.python_io.TFRecordWriter(path)

——写入tfrecords文件

——path: TFRecords文件的路径

——return：写文件

——

——method

——write(record):向文件中写入一个字符串记录

——

——close():关闭文件写入器

注：字符串为一个序列化的Example,Example.SerializeToString()

TFRecords存储

——2、构造每个样本的Example协议块

——tf.train.Example(features=None)

——写入tfrecords文件

——features:tf.train.Features类型的特征实例

——return：example格式协议块

——

——tf.train.Features(feature=None)

——构建每个样本的信息键值对

——feature:字典数据,key为要保存的名字，

——value为tf.train.Feature实例

——return:Features类型

——

——tf.train.Feature(**options)

——**options：例如

——bytes_list=tf.train. BytesList(value=[Bytes])

——int64_list=tf.train. Int64List(value=[Value])

——

——tf.train. Int64List(value=[Value])

——tf.train. BytesList(value=[Bytes])

——tf.train. FloatList(value=[value])

——

——

——

——

——

TFRecords读取方法

——同文件阅读器流程,中间需要解析过程

——

——解析TFRecords的example协议内存块

——tf.parse_single_example(serialized,features=None,name=None)

——解析一个单一的Example原型

——serialized：标量字符串Tensor，一个序列化的Example

——features：dict字典数据，键为读取的名字，值为FixedLenFeature

——return:一个键值对组成的字典，键为读取的名字

——tf.FixedLenFeature(shape,dtype)

——shape：输入数据的形状，一般不指定,为空列表

——dtype：输入数据类型，与存储进文件的类型要一致

——类型只能是float32,int64,string

——

CIFAR-10批处理结果存入tfrecords流程

1、构造存储器

2、构造每一个样本的Example

3、写入序列化的Example

读取tfrecords流程

1、构造TFRecords阅读器

2、解析Example

3、转换格式，bytes解码