tensorflow之tfrecords--一种数据格式
d# 一、tfrecords是什么
tfrecords是一种二进制编码的文件格式，tensorflow专用。
能将任意数据转换为tfrecords。
更好的利用内存，更方便复制和移动，并且不需要单独的标签文件。
二、使用
1、 将数据保存为tfrecords
TFRecords文件包含了tf.train.Example协议内存块(protocol buffer)(协议内存块包含了字段 Features)。我们可以写一段代码获取你的数据， 将数据填入到Example协议内存块(protocol buffer)，将协议内存块序列化为一个字符串， 并且通过tf.python_io.TFRecordWriter写入到TFRecords文件。
流程：
1. 将数据填入example protocol buffer
2. 将protocol buffer序列化为一个字符串
3. 通过tf.python_io.TFRecordWriter将字符串写入TFRecords文件
# 将数据转化成对应的属性
def _bytes_feature(value):
# 字符串列表类型作为feature的value
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
def _int64_feature(value):
# 整数列表类型作为feature的value
return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
def _float_feature(value):
return tf.train.Feature(float_list=tf.train.FloatList(value=[value]))
writer=tf.python_io.TFRecordWriter('filename') # 初始化一个writer
example=tf.train.Example(
features=tf.train.Features(
feature={
"name": _bytes_feature('xianyi'),
"age": _int64_feature(23)
}
)
) # 填充数据，example填充features，features填充feature，feature填写key和value，value是tf.train.Feature(类型=tf.train.类型(value=[value]))
writer.write(example.SerializeToString()) # 将序列化的example写入文件这个写入example的过程有点复杂。
Example，初始化为tf.train.Example()
包含字段features=tf.train.Features()
字段features包含一个或多个: feature={"key": tf.train.Feature()}
feature是基于key-value对的存储，key是字符串,其映射到的是value 包含3种数据类型：
1. BytesList: 字符串列表: tf.train.BytesList(value=[value])
2. FloatList: 浮点数列表tf.train.FloatList()
3. Int64List: 64位整数列表tf.train.Int64List()
对于图片的numpy数组，可以.tostring之后存到BytesList，可以tf.gfile.FastGFile读入成bytes存到BytesList，可以.flatten后存到FloatList
Example中有几个一致性规则需要注意：
1. 如果一个example的feature K的数据类型是T，那么所有其他的所有feature K都应该是这个数据类型
2. feature K 的value list的item个数可能在不同的example中是不一样多的，这个取决于你的需求
3. 如果在一个example中没有feature k，那么如果在解析的时候指定一个默认值的话，那么将会返回一个默认值
4. 如果一个feature k 不包含任何的value值，那么将会返回一个空的tensor而不是默认值
一个example的例子:
features {
feature {
key: "age"
value { float_list {
value: 29.0
}}
}
feature {
key: "movie"
value { bytes_list {
value: "The Shawshank Redemption"
value: "Fight Club"
}}
}
feature {
key: "movie_ratings"
value { float_list {
value: 9.0
value: 9.7
}}
}
feature {
key: "suggestion"
value { bytes_list {
value: "Inception"
}}
}看一段官网代码tensorflow/tensorflow/examples/how_tos/reading_data/convert_to_records.py：
def _int64_feature(value):
return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
def _bytes_feature(value):
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
def convert_to(data_set, name):
images = data_set.images
labels = data_set.labels
num_examples = data_set.num_examples
rows = images.shape[1]
cols = images.shape[2]
depth = images.shape[3]
filename = os.path.join(FLAGS.directory, name + '.tfrecords')
print('Writing', filename)
with tf.python_io.TFRecordWriter(filename) as writer:
for index in range(num_examples): # example是按照行读的
image_raw = images[index].tostring() # 将np数组转换为字符串存成Bytes_feature...,虽然这样比较大，后面介绍一种需要的存储空间不那么大的方法。
example = tf.train.Example(
features=tf.train.Features(
feature={
'height': _int64_feature(rows),
'width': _int64_feature(cols),
'depth': _int64_feature(depth),
'label': _int64_feature(int(labels[index])),
'image_raw': _bytes_feature(image_raw)
}))
writer.write(example.SerializeToString())例子将图片带标签转换为tfrecords：
from imageio import imread
def _int64_feature(value):
return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
def _bytes_feature(value):
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
def img2feature(path):
# 数组转化为string的第一种方法
# np.array([1.,2.]).tostring()-->b'\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@'
img = imread(path)
feature = tf.train.Features(feature={
'img':_bytes_feature(img.tostring())
})
return feature
def img2feature2(img_path):
# 数组转化为string的第二种方法
# tf.gfile.FastGFile(img,mode='rb).read()-->b'\x00H\x9c\x01I\x9e\x02J\x9f\x03J\xa4\x04K\xa7\x05K\xaa\x05K'另一种编码
with tf.gfile.GFile(img_path, 'rb') as fid:
encoded_jpg = fid.read()
feature = tf.train.Features(feature={
'img': _bytes_feature(encoded_jpg)
})
return feature
def convert_to_tfrecord():
input_dir = './data'
save_path = './data2.tfrecord'
file_list = get_file_list(input_dir)
writer_options = tf.python_io.TFRecordOptions(tf.python_io.TFRecordCompressionType.ZLIB)
writer = tf.python_io.TFRecordWriter(path=save_path, options=writer_options)
for file in file_list:
img_path = os.path.join(input_dir, file)
print (img_path)
feature = img_to_feature_1(img_path)
example = tf.train.Example(features=feature)
writer.write(example.SerializeToString())
writer.close()2、 读取tfrecords
用tf.parse_single_example解码，tf.TFRecordReader读取
一般，为了高效的读取数据，tf中使用队列读取数据
def read_and_decode(filename):
# 生成一个文件名的队列
filename_queue = tf.train.string_input_producer([filename])
reader = tf.TFRecordReader() # 定义一个reader
_, serialized_example = reader.read(filename_queue) # 读取文件名和example
# 还原feature， 和制作tfrecords时一样
feature = { 'label': tf.FixedLenFeature([], tf.int64), # 对于单个元素的变量，我们使用FixlenFeature来读取，需要指明变量存储的数据类型；对于list类型的变量，我们使用VarLenFeature来读取，同样需要指明读取变量的类型
'img_raw' : tf.FixedLenFeature([], tf.string), }
# 使用tf.parse_single_example来解析example
features = tf.parse_single_example(serialized_example, features=feature)
# 对于图像，使用tf.decode_raw解析对应的features，指定类型，然后reshape等
img = tf.decode_raw(features['img_raw'], tf.uint8)
img = tf.reshape(img, [224, 224, 3])
img = tf.cast(img, tf.float32) * (1. / 255) - 0.5
label = tf.cast(features['label'], tf.int32)
return img, label
img, label = read_and_decode('train.tfrecords')
# 在训练时使用shuffle_batch随机打乱顺序，并生成batch
img_batch, label_batch = tf.train.shuffle_batch([img, label],
batch_size=30,
capacity=2000, # 队列的最大容量
num_threads=1, # 进行队列操作的线程数
min_after_dequeue=1000) # dequeue后最小的队列大小,used to ensure a level of mixing of elements.
# tf队列也需要初始化在sess中才能执行
init_op = tf.group(tf.global_variables_initializer(),tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
coord = tf.train.Coordinator() # 创建一个coordinate，用于协调各线程
threads = tf.train.start_queue_runners(coord=coord) # 使用QueueRunner对象来提取数据
try: # 推荐代码
while not coord.should_stop():
# Run training steps or whatever
sess.run(train_op)
except tf.errors.OutOfRangeError:
print 'Done training -- epoch limit reached'
finally:
# When done, ask the threads to stop.关闭线程
coord.request_stop()
# Wait for threads to finish.
coord.join(threads)制作tfrecords和读取的完整代码如下：
import tensorflow as tf
import numpy as np
import os
#=============================================================================#
# write images and label in tfrecord file and read them out
def encode_to_tfrecords(tfrecords_filename, data_num):
''' write into tfrecord file '''
if os.path.exists(tfrecords_filename):
os.remove(tfrecords_filename)
writer = tf.python_io.TFRecordWriter('./'+tfrecords_filename) # 创建.tfrecord文件，准备写入
for i in range(data_num):
img_raw = np.random.randint(0,255,size=(56,56))
img_raw = img_raw.tostring()
example = tf.train.Example(features=tf.train.Features(
feature={
'label': tf.train.Feature(int64_list = tf.train.Int64List(value=[i])),
'img_raw':tf.train.Feature(bytes_list = tf.train.BytesList(value=[img_raw]))
}))
writer.write(example.SerializeToString())
writer.close()
return 0
def decode_from_tfrecords(filename_queue, is_batch):
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue) #返回文件名和文件
features = tf.parse_single_example(serialized_example,
features={
'label': tf.FixedLenFeature([], tf.int64),
'img_raw' : tf.FixedLenFeature([], tf.string),
}) #取出包含image和label的feature对象
image = tf.decode_raw(features['img_raw'],tf.int64)
image = tf.reshape(image, [56,56])
label = tf.cast(features['label'], tf.int64)
if is_batch:
batch_size = 3
min_after_dequeue = 10
capacity = min_after_dequeue+3*batch_size
image, label = tf.train.shuffle_batch([image, label],
batch_size=batch_size,
num_threads=3,
capacity=capacity,
min_after_dequeue=min_after_dequeue)
return image, label
#=============================================================================#
if __name__=='__main__':
# make train.tfrecord
train_filename = "train.tfrecords"
encode_to_tfrecords(train_filename,100)
## # make test.tfrecord
test_filename = 'test.tfrecords'
encode_to_tfrecords(test_filename,10)
# run_test = True
filename_queue = tf.train.string_input_producer([train_filename],num_epochs=None) #读入流中
train_image, train_label = decode_from_tfrecords(filename_queue, is_batch=True)
filename_queue = tf.train.string_input_producer([test_filename],num_epochs=None) #读入流中
test_image, test_label = decode_from_tfrecords(filename_queue, is_batch=True)
with tf.Session() as sess: #开始一个会话
init_op = tf.global_variables_initializer()
sess.run(init_op)
coord=tf.train.Coordinator()
threads= tf.train.start_queue_runners(coord=coord)
try:
# while not coord.should_stop():
for i in range(2):
example, l = sess.run([train_image,train_label])#在会话中取出image和label
print('train:')
print(example, l)
texample, tl = sess.run([test_image, test_label])
print('test:')
print(texample,tl)
except tf.errors.OutOfRangeError:
print('Done reading')
finally:
coord.request_stop()
coord.request_stop()
coord.join(threads)参考
这里写链接内容
这里写链接内容
这里写链接内容
这里写链接内容
tensorflow官方给出了一个新的利用tf.data.TFRecordDataset读取tfrecords的：
这里写链接内容
三、
从TFRecords文件中读取数据， 可以使用tf.TFRecordReader的tf.parse_single_example解析器。这个操作可以将Example协议内存块(protocol buffer)解析为张量。
tf.train.Example定义数据格式:
The recommended format for TensorFlow is a TFRecords file containing tf.train.Example protocol buffers (which contain Features as a field).
tf.python_io.TFRecordWriter写入tfrecords:
You write a little program that gets your data, stuffs it in an Example protocol buffer, serializes the protocol buffer to a string, and then writes the string to a TFRecords file using the tf.python_io.TFRecordWriterclass.
示例：convert_to_records.py
用tf.parse_single_example解码，tf.TFRecordReader读取
To read a file of TFRecords, use tf.TFRecordReaderwith thetf.parse_single_exampledecoder.
示例：fully_connected_reader.py