队列和线程
队列:
FIFOQueue(capacity, dtypes, name=‘fifo_queue’)
创建一个以先进先出的顺序对元素进行排队的队列
capacity:整数,可能存储在此队列中的元素数量的上限
dtypes:DType对象列表。长度dtypes必须等于每个队列元素中的张量数,dtype的类型形状决定了后面进队列元素形状。
方法:
dequeue(name=None):出队列
enqueue(vals, name=None):进队列
enqueue_many(vals, name=None)----vals列表或者元组
size(name=None):队列大小
例:完成一个出队列、+1、入队列操作(同步操作):
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
# 模拟完成一个出队列、+1、入队列操作(同步操作)
# 1.定义队列
Q = tf.FIFOQueue(3,tf.float32)
# 放入一些数据
enq_many = Q.enqueue_many([[1,2,3]])
# 2.定义读取数据,存数据的过程
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(10):
# tensorflow当中,运行操作有依赖性
sess.run(en_q)
# 训练数据
for i in range(Q.size().eval()):
print(sess.run(Q.dequeue()))
队列管理器:
tf.train.QueueRunner(queue, enqueue_ops=None)----创建一个队列管理器(子线程)
queue:队列
enqueue_ops:添加线程的队列操作列表,[]*2,指定两个线程
create_threads(sess, coord=None,start=False) ----真正开启子线程(在会话中)
start:布尔值,如果True启动线程;如果为False调用者必须调用start()启动线程
coord:线程协调器
return:队列管理器实例
线程协调器:
tf.train.Coordinator() 线程协调员,实现一个简单的机制来协调一组线程的终止
方法:
request_stop() :要求停止
should_stop() 检查是否要求停止
join(threads=None, stop_grace_period_secs=120) 等待线程终止
return:线程协调员实例
例:通过队列管理器来实现变量加1,入队,主线程出队列的操作(异步操作):
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
# 通过队列管理器模拟 子线程存入样本 主线程读取样本的操作(异步操作)
# 1.定义一个队列
Q = tf.FIFOQueue(1000,tf.float32)
# 2.定义要做的事情 循环 值+1,放入队列中
var = tf.Variable(0.0)
# 实现一个自增 tf.assign_add() 即 data = var + 1.0 var = var + 1.0
data = tf.assign_add(var,tf.constant(1.0))
en_q = Q.enqueue(data)
# 3.定义队列管理器op,指定多少个子线程,子线程该干什么
qr = tf.train.QueueRunner(Q,enqueue_ops=[en_q])
# 初始化变量的OP
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
# 初始化变量
sess.run(init_op)
# 开启线程协调器
coord = tf.train.Coordinator()
# 真正开启子线程
threads = qr.create_threads(sess,coord= coord,start=True)
# 主线程,不断读取数据训练
for i in range(300):
print(sess.run(Q.dequeue()))
# 回收子线程
coord.request_stop()
coord.join(threads)
文件读取
tensorflow文件读取流程:
1)构造一个文件队列
2)构造文件阅读器,读取队列内容
2.1)csv文件:每次读取一行 2.2)二进制文件:指定一个样本的bytes读取 2.3)图片文件:一张一张读取
3)解码 decode
4)批处理
文件读取API:
1)文件队列构造:
tf.train.string_input_producer(string_tensor,shuffle=True)
将输出字符串(例如文件名)输入到管道队列
string_tensor:含有文件名的1阶张量(即文件路径+文件名)
num_epochs:过几遍数据,默认无限过数据
return:具有输出字符串的队列
2)构造文件阅读器
根据文件格式,选择对应的文件阅读器
tf.TextLineReader()
阅读文本文件、逗号分隔值(CSV)格式,默认按行读取
return:读取器实例
tf.FixedLengthRecordReader(record_bytes)
要读取每个记录是固定数量字节的二进制文件
record_bytes:整型,指定每次读取的字节数
return:读取器实例
tf.TFRecordReader()
读取TfRecords文件
上述三种文件阅读器有一个共同的读取方法:
read(file_queue):从队列中指定数量内容返回一个Tensors元组(key文件名字,value默认的内容(行,字节))
3)文件内容解码器
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格式
4)批处理
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:留下队列里的张量个数,能够保持随机打乱
文件读取案例:
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def csvread(filelist):
"""
读取CSV文件
:param filelist: 文件路径+名字的列表
:return: 读取的内容
"""
# 2.构造文件的队列
file_queue = tf.train.string_input_producer(file_list)
# 3.构造csv阅读器读取队列数据(按行读取)
reader = tf.TextLineReader()
key,value =reader.read(file_queue)
# 4.解码
# record_defaults:指定每一个样本的每一列的类型,指定默认值
records = [["None"],["None"]]
name,label = tf.decode_csv(value,record_defaults=records)
# 5.想要读取多个数据,就需要批处理
name_batch,label_batch = tf.train.batch([name,label],batch_size=9,num_threads=1,capacity=9)
return name_batch,label_batch
if __name__ == '__main__':
# 1.找到文件,放入列表 路径+名字 ->列表当中
filename = os.listdir("E:/PythonProject/tf/test/")
file_list = [os.path.join("E:/PythonProject/tf/test/",file) for file in filename]
name,label = csvread(file_list)
# 开启会话运行结果
with tf.Session() as sess:
# 定义一个线程协调器
coord = tf.train.Coordinator()
# 开启读文件的线程
threads = tf.train.start_queue_runners(sess,coord=coord)
# 打印读取的内容
print(sess.run([name,label]))
# 回收线程
coord.request_stop()
coord.join()
图片处理
图像基本知识
图像数字化三要素:长度、宽度、通道数
单通道:灰度值[0-255],一个像素点只有一个值
三通道:RGB,一个像素点由三个值组成
三要素与张量的关系:
例–指定3-D张量:[height,width,channels]----[长度,宽度,通道数]
图像基本操作
目的:
1)增加图片数据的统一性
2)所有图片转换成指定大小
3)缩小图片数据量,防止增加开销
操作:缩放图片大小
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)和该文件的内容(value)
图像解码器
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)处理图片数据
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
def picread(filelist):
"""
读取狗图片并转换成张量
:param filelist:文件路径 + 名字的列表
:return:每张图片的张量
"""
# 2.构造文件队列
file_queue = tf.train.string_input_producer(filelist)
# 3.构造阅读器去读取图片内容(默认按照一张一张照片读取)
reader = tf.WholeFileReader()
key,value = reader.read(file_queue)
# 4.对读取的图片数据进行解码
image = tf.image.decode_jpeg(value)
# 5.处理图片的大小(统一大小)
image_resize = tf.image.resize_images(image,[200,200])
# 注意:一定要把样本的形状固定 [200,200,3],在批处理的时候要求所有数据形状必须定义
image_resize.set_shape([200,200,3])
# 6.批处理
image_batch = tf.train.batch([image_resize],batch_size=5,num_threads=1,capacity=5)
return image_batch
if __name__ == '__main__':
# 1.找到文件,放入列表 路径+名字 ->列表当中
filename = os.listdir("E:/PythonProject/tf/data/")
file_list = [os.path.join("E:/PythonProject/tf/data/", file) for file in filename]
image_batch = picread(file_list)
# 开启会话运行结果
with tf.Session() as sess:
# 定义一个线程协调器
coord = tf.train.Coordinator()
# 开启读文件的线程
threads = tf.train.start_queue_runners(sess, coord=coord)
# 打印读取的内容
print(sess.run([image_batch]))
# 回收线程
coord.request_stop()
coord.join()
CIFAR-10数据集:
基本信息:
CIFAR-10数据集包含10个类别的60000个32x32彩色图像,每个类别6000个图像。有50000张训练图像和10000张测试图像。10个类别为:飞机( airplane )、汽车( automobile )、鸟类( bird )、猫( cat )、鹿( deer )、狗( dog )、蛙类( frog )、马( horse )、船( ship )和卡车( truck )。
数据集分为五个训练批次和一个测试批次,每个批次具有10000张。图像测试批的数据里,取10类中的每一类随机取1000张,抽剩下的就随机排列组成了训练批。注意一个训练批中的各类图像并不一定数量相同,总的来看训练批每一类都有5000张图。
下载地址:https://www.cs.toronto.edu/~kriz/cifar.html
二进制版本:
二进制版本包含文件data_batch_1.bin、data_batch_2.bin…data_batch_5.bin以及test_batch.bin。这些文件的每个格式如下:
<1 x标签> <3072 x像素>
...
<1 x标签> <3072 x像素>
换句话说,第一个字节是第一张图片的标签,它是0-9范围内的数字。接下来的3072个字节是图像像素的值。前1024个字节为红色通道值,后1024个为绿色,最后1024个为蓝色。
每个文件都包含10000个这样的3073字节“行”的图像。因此,每个文件的长度应恰好为30730000字节。
还有另一个文件,名为batchs.meta.txt。。这是一个ASCII文件,它将0-9范围内的数字标签映射到有意义的类名称。它只是10个类名的列表,每行一个。第i行上的类名称对应于数字标签i。
二进制文件读取:
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
# 定义cifar的数据等命令行参数
FlAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("cifar_dir","E:/PythonProject/tf/cifar10/cifar-10-bin-batches/","文件夹的目录")
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):
# 1.构造文件队列
file_queue = tf.train.string_input_producer(self.file_list)
# 2.构建二进制文件读取器,读取内容
reader = tf.FixedLengthRecordReader(self.bytes)
key,value = reader.read(file_queue)
# 3.解码内容,二进制文件内容的解码
label_image = tf.decode_raw(value,tf.uint8)
# 4.分割出图片(特征值)和标签数据(目标值)
label = tf.cast(tf.slice(label_image,[0],[self.label_bytes]),tf.int32)
image = tf.slice(label_image,[self.label_bytes],[self.image_bytes])
# 5.对图片的特征数据进行形状的改变
image_reshape = tf.reshape(image,[self.height,self.width,self.channel])
# 6.批处理数据
image_batch , label_batch = tf.train.batch([image_reshape,label],batch_size=10,num_threads=1,capacity=10)
return image_batch,label_batch
if __name__ == '__main__':
filename = os.listdir(FlAGS.cifar_dir)
filelist = [os.path.join(FlAGS.cifar_dir,file)for file in filename if file[-3:] == "bin"]
cf = CifarRead(filelist)
image_batch,label_batch = cf.read_and_decode()
# 开启会话运行结果
with tf.Session() as sess:
# 定义一个线程协调器
coord = tf.train.Coordinator()
# 开启读文件的线程
threads = tf.train.start_queue_runners(sess, coord=coord)
# 打印读取的内容
print(sess.run([image_batch,label_batch]))
# 回收线程
coord.request_stop()
coord.join()
TFRecords分析、存取:
TFRecords是Tensorflow设计的一种内置文件格式,是一种二进制文件,它能更好的利用内存,更方便复制和移动。
文件格式:*.tfrecords
写入文件内容:Example协议块
TFRecords存储:
1、建立TFRecord存储器
tf.python_io.TFRecordWriter(path)----写入tfrecords文件
path: TFRecords文件的路径
方法:
write(record):向文件中写入一个字符串记录
close():关闭文件写入器
注:字符串为一个序列化的Example,Example.SerializeToString()
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])
example = tf.train.Example(features=tf.train.Features(feature={
"image":tf.train.Feature(bytes_list=tf.train. BytesList(value=[Bytes]))
"label":tf.train.Feature(int64_list=tf.train. Int64List(value=[Value]))
}))
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
# 定义cifar的数据等命令行参数
FlAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("cifar_dir","E:/PythonProject/tf/cifar10/cifar-10-bin-batches/","文件夹的目录")
tf.app.flags.DEFINE_string("cifar_tfrecords","E:/PythonProject/tf/tmp/cifar.tfrecords","存进tfrecords的文件")
class CifarRead(object):
"""
完成读取二进制文件,写进tfrecords,再读取tfrecords
"""
def __init__(self,filelist):
# 文件列表
self.file_list = filelist
# 定义读取图片的一些属性
self.height = 32
self.width = 32
self.channnel = 3
# 二进制文件每张图片的字节
self.label_bytes = 1
self.image_bytes = self.height * self.width * self.channnel
self.bytes = self.label_bytes + self.image_bytes
def read_and_decode(self):
# 1.构造文件队列
file_queue = tf.train.string_input_producer(self.file_list)
# 2.构建二进制文件读取器,读取内容
reader = tf.FixedLengthRecordReader(self.bytes)
key,value = reader.read(file_queue)
# 3.解码内容,二进制文件内容的解码
label_image = tf.decode_raw(value,tf.uint8)
# 4.分割出图片(特征值)和标签数据(目标值)
label = tf.cast(tf.slice(label_image,[0],[self.label_bytes]),tf.int32)
image = tf.slice(label_image,[self.label_bytes],[self.image_bytes])
# 5.对图片的特征数据进行形状的改变
image_reshape = tf.reshape(image,[self.height,self.width,self.channnel])
# 6.批处理数据
image_batch , label_batch = tf.train.batch([image_reshape,label],batch_size=10,num_threads=1,capacity=10)
return image_batch,label_batch
def write_to_tfrecords(self,image_batch,label_batch):
"""
将图片的特征值和目标值存进tfrecords
:param image_batch: 10张图片的特征值
:param label_batch: 10张图片的目标值
:return: None
"""
# 1.构造一个tfrecords存储器
writer = tf.python_io.TFRecordWriter(FlAGS.cifar_tfrecords)
# 2.循环将所有样本写入文件,每张图片样本都要构造example协议
for i in range(10):
# 取出第i个图片数据的特征值和目标值
image = image_batch[i].eval().tostring()
label = label_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])),
"label":tf.train.Feature(int64_list = tf.train.Int64List(value=[label])),
}))
# 写入单独的样本
writer.write(example.SerializeToString())
# 关闭
writer.close()
if __name__ == '__main__':
filename = os.listdir(FlAGS.cifar_dir)
filelist = [os.path.join(FlAGS.cifar_dir,file)for file in filename if file[-3:] == "bin"]
cf = CifarRead(filelist)
image_batch,label_batch = cf.read_and_decode()
# 开启会话运行结果
with tf.Session() as sess:
# 定义一个线程协调器
coord = tf.train.Coordinator()
# 开启读文件的线程
threads = tf.train.start_queue_runners(sess, coord=coord)
# 存进tfrecords文件
print("开始存储")
cf.write_to_tfrecords(image_batch, label_batch)
print("结束存储")
# 打印读取的内容
# print(sess.run([image_batch,label_batch]))
# 回收线程
coord.request_stop()
coord.join()
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
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
# 定义cifar的数据等命令行参数
FlAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string("cifar_dir","E:/PythonProject/tf/cifar10/cifar-10-bin-batches/","文件夹的目录")
tf.app.flags.DEFINE_string("cifar_tfrecords","E:/PythonProject/tf/tmp/cifar.tfrecords","存进tfrecords的文件")
class CifarRead(object):
"""
完成读取二进制文件,写进tfrecords,再读取tfrecords
"""
def __init__(self,filelist):
# 文件列表
self.file_list = filelist
# 定义读取图片的一些属性
self.height = 32
self.width = 32
self.channnel = 3
# 二进制文件每张图片的字节
self.label_bytes = 1
self.image_bytes = self.height * self.width * self.channnel
self.bytes = self.label_bytes + self.image_bytes
def read_and_decode(self):
# 1.构造文件队列
file_queue = tf.train.string_input_producer(self.file_list)
# 2.构建二进制文件读取器,读取内容
reader = tf.FixedLengthRecordReader(self.bytes)
key,value = reader.read(file_queue)
# 3.解码内容,二进制文件内容的解码
label_image = tf.decode_raw(value,tf.uint8)
# 4.分割出图片(特征值)和标签数据(目标值)
label = tf.cast(tf.slice(label_image,[0],[self.label_bytes]),tf.int32)
image = tf.slice(label_image,[self.label_bytes],[self.image_bytes])
# 5.对图片的特征数据进行形状的改变
image_reshape = tf.reshape(image,[self.height,self.width,self.channnel])
# 6.批处理数据
image_batch , label_batch = tf.train.batch([image_reshape,label],batch_size=10,num_threads=1,capacity=10)
return image_batch,label_batch
def write_to_tfrecords(self,image_batch,label_batch):
"""
将图片的特征值和目标值存进tfrecords
:param image_batch: 10张图片的特征值
:param label_batch: 10张图片的目标值
:return: None
"""
# 1.构造一个tfrecords存储器
writer = tf.python_io.TFRecordWriter(FlAGS.cifar_tfrecords)
# 2.循环将所有样本写入文件,每张图片样本都要构造example协议
for i in range(10):
# 取出第i个图片数据的特征值和目标值
image = image_batch[i].eval().tostring()
label = label_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])),
"label":tf.train.Feature(int64_list = tf.train.Int64List(value=[label])),
}))
# 写入单独的样本
writer.write(example.SerializeToString())
# 关闭
writer.close()
def read_from_tfrecords(self):
# 1.构造文件队列
file_queue = tf.train.string_input_producer([FlAGS.cifar_tfrecords])
# 2.构造文件阅读器,读取内容example,value为一个样本的序列化example
reader = tf.TFRecordReader()
key, value = reader.read(file_queue)
# 3.解析example
features = tf.parse_single_example(value, features={
"image": tf.FixedLenFeature([], tf.string),
"label": tf.FixedLenFeature([], tf.int64)
})
# 4.解码内容 如果读取的内容格式是string需要解码,如果是int64、float32不需要解码
image = tf.decode_raw(features["image"],tf.uint8)
# 固定图片的形状,方便批处理
image_reshape = tf.reshape(image,[self.height,self.width,self.channnel])
label = features["label"]
print(image_reshape,label)
# 5.进行批处理
image_batch,label_batch = tf.train.batch([image_reshape,label],batch_size=10,capacity=10)
return image_batch,label_batch
if __name__ == '__main__':
filename = os.listdir(FlAGS.cifar_dir)
filelist = [os.path.join(FlAGS.cifar_dir,file)for file in filename if file[-3:] == "bin"]
cf = CifarRead(filelist)
image_batch , label_batch = cf.read_from_tfrecords()
# image_batch,label_batch = cf.read_and_decode()
# 开启会话运行结果
with tf.Session() as sess:
# 定义一个线程协调器
coord = tf.train.Coordinator()
# 开启读文件的线程
threads = tf.train.start_queue_runners(sess, coord=coord)
# 存进tfrecords文件
# print("开始存储")
# cf.write_to_tfrecords(image_batch, label_batch)
# print("结束存储")
# 打印读取的内容
print(sess.run([image_batch,label_batch]))
# 回收线程
coord.request_stop()
coord.join()