[tf] TFRecord + Dataset 进行数据的写入和读取

  • Record顾名思义主要是为了记录数据的。
  • 使用TFRocord存储数据的好处:
    • 为了更加方便的建图,原来使用placeholder的话,还要每次feed_dict一下,使用TFRecord+ Dataset 的时候直接就把数据读入操作当成一个图中的节点,就不用每次都feed了。
    • 可以方便的和Estimator进行对接。
  • TFRecord以字典的方式进行数据的创建。

将数据写入TFRecord 文件

创建一个writer

writer = tf.python_io.TFRecordWriter('%s.tfrecord' %'data')

创建存储类型tf_feature

.tfrecord里面写数据的时候首先要先定义写入数据项(feature)的类型。

  • int64tf.train.Feature(int64_list = tf.train.Int64List(value=输入))
  • float32tf.train.Feature(float_list = tf.train.FloatList(value=输入))
  • stringtf.train.Feature(bytes_list=tf.train.BytesList(value=输入))
  • 注:输入必须是list(向量),由于tensorflow feature类型只接受list数据,但是如果数据类型是矩阵或者张量的时候,有两种解决方法:
    • 转成list类型:将张量fattenlist(也就是向量),再用写入list的方式写入。
    • 转成string类型:将张量用.tostring()转换成string类型,再用tf.train.Feature(bytes_list=tf.train.BytesList(value=[input.tostring()]))来存储。
    • 形状信息:不管那种方式都会使数据丢失形状信息,所以在向该样本中写入feature时应该额外加入shape信息作为额外feature。shape信息是int类型,这里我是用原feature名字+’_shape’来指定shape信息的feature名。
# 这里我们将会写3个样本,每个样本里有4个feature:标量,向量,矩阵,张量
for i in range(3):
    # 创建字典
    features={}
    # 写入标量,类型Int64,由于是标量,所以"value=[scalars[i]]" 变成list
    features['scalar'] = tf.train.Feature(int64_list=tf.train.Int64List(value=[scalars[i]]))
    
    # 写入向量,类型float,本身就是list,所以"value=vectors[i]"没有中括号
    features['vector'] = tf.train.Feature(float_list = tf.train.FloatList(value=vectors[i]))
    
    # 写入矩阵,类型float,本身是矩阵,一种方法是将矩阵flatten成list
    features['matrix'] = tf.train.Feature(float_list = tf.train.FloatList(value=matrices[i].reshape(-1)))
    # 然而矩阵的形状信息(2,3)会丢失,需要存储形状信息,随后可转回原形状
    features['matrix_shape'] = tf.train.Feature(int64_list = tf.train.Int64List(value=matrices[i].shape))
    
    # 写入张量,类型float,本身是三维张量,另一种方法是转变成字符类型存储,随后再转回原类型
    features['tensor']         = tf.train.Feature(bytes_list=tf.train.BytesList(value=[tensors[i].tostring()]))
    # 存储丢失的形状信息(806,806,3)
    features['tensor_shape'] = tf.train.Feature(int64_list = tf.train.Int64List(value=tensors[i].shape))

将 tf_feature 转换成 tf_example 以及进行序列化

# 将存有所有feature的字典送入tf.train.Features中
tf_features = tf.train.Features(feature= features)
# 再将其变成一个样本example
tf_example = tf.train.Example(features = tf_features)
# 序列化该样本
tf_serialized = tf_example.SerializeToString()

写入样本 关闭文件

# 写入一个序列化的样本
writer.write(tf_serialized)
# 由于上面有循环3次,所以到此我们已经写了3个样本
# 关闭文件    
writer.close()

使用Dataset读取数据

之前的一篇Dataset的介绍 介绍了Dataset的基本用法,下面的介绍如何和TFRecord配合使用。

dataset = tf.data.TFRecordDataset(filenames)
# 这样的话就是读取两次数据,数据量就是两倍
dataset = tf.data.TFRecordDataset(["test.tfrecord","test.tfrecord"])

解析feature信息。

是写入的逆过程,所以会需要写入时的信息:使用库pandas

  • isbyte是用于记录该feature是否字符化了。
  • default是所读的样本该feature值如果有确实,用什么进行填补,一般是使用np.NaN
  • length_type:是指示读取向量的方式是否是定长。
data_info = pd.DataFrame({'name':['scalar','vector','matrix','matrix_shape','tensor','tensor_shape'],
                         'type':[scalars[0].dtype,vectors[0].dtype,matrices[0].dtype,tf.int64, tensors[0].dtype,tf.int64],
                         'shape':[scalars[0].shape,(3,),matrices[0].shape,(len(matrices[0].shape),),tensors[0].shape,(len(tensors[0].shape),)],
                         'isbyte':[False,False,True,False,False,False],
                         'length_type':['fixed','fixed','var','fixed','fixed','fixed']},
                         columns=['name','type','shape','isbyte','length_type','default'])

创建解析函数

example_proto,也就是序列化后的数据(也就是读取到的TFRecord数据)。

def parse_function(example_proto):
    # 只接受一个输入:example_proto,也就是序列化后的样本tf_serialized

解析方式有两种:

  • 定长特征解析:tf.FixedLenFeature(shape, dtype, default_value)
    • shape:可当reshape来用,如vectorshape(3,)改动成了(1,3)
      注:如果写入的feature使用了.tostring()shape就是()
    • dtype:必须是tf.float32tf.int64tf.string中的一种。
    • default_valuefeature值缺失时所指定的值。
  • 不定长特征解析:tf.VarLenFeature(dtype)
  • 注:可以不明确指定shape,但得到的tensorSparseTensor
dics = {# 这里没用default_value,随后的都是None
            'scalar': tf.FixedLenFeature(shape=(), dtype=tf.int64, default_value=None), 
             
            # vector的shape刻意从原本的(3,)指定成(1,3)
            'vector': tf.FixedLenFeature(shape=(1,3), dtype=tf.float32), 
            
            # 使用 VarLenFeature来解析
            'matrix': tf.VarLenFeature(dtype=dtype('float32')), 
            'matrix_shape': tf.FixedLenFeature(shape=(2,), dtype=tf.int64), 
            # tensor在写入时 使用了toString(),shape是()
            # 但这里的type不是tensor的原type,而是字符化后所用的tf.string,随后再回转成原tf.uint8类型
            'tensor': tf.FixedLenFeature(shape=(), dtype=tf.string), 
            'tensor_shape': tf.FixedLenFeature(shape=(3,), dtype=tf.int64)}

进行解析

  • 得到的parsed_example也是一个字典,其中每个key是对应feature的名字,value是相应的feature解析值。如果使用了下面两种情况,则还需要对这些值进行转变。其他情况则不用。

  • string类型:tf.decode_raw(parsed_feature, type) 来解码
    注:这里type必须要和当初.tostring()化前的一致。如tensor转变前是tf.uint8,这里就需是tf.uint8;转变前是tf.float32,则tf.float32

  • VarLen解析:由于得到的是SparseTensor,所以视情况需要用tf.sparse_tensor_to_dense(SparseTensor)来转变成DenseTensor

# 把序列化样本和解析字典送入函数里得到解析的样本
parsed_example = tf.parse_single_example(example_proto, dics)
# 解码字符
parsed_example['tensor'] = tf.decode_raw(parsed_example['tensor'], tf.uint8)
# 稀疏表示 转为 密集表示
parsed_example['matrix'] = tf.sparse_tensor_to_dense(parsed_example['matrix'])

转变形状

# 转变matrix形状
parsed_example['matrix'] = tf.reshape(parsed_example['matrix'], parsed_example['matrix_shape'])
# 转变tensor形状
parsed_example['tensor'] = tf.reshape(parsed_example['tensor'], parsed_example['tensor_shape'])

执行解析函数

new_dataset = dataset.map(parse_function)

创建迭代器

  • 有了解析过的数据集后,接下来就是获取当中的样本。
  • make_one_shot_iterator():表示只将数据读取一次,然后就抛弃这个数据了
# 创建获取数据集中样本的迭代器
iterator = new_dataset.make_one_shot_iterator()

获取样本

# 获得下一个样本
next_element = iterator.get_next()
# 创建Session
sess = tf.InteractiveSession()

# 获取
i = 1
while True:
    # 不断的获得下一个样本
    try:
        # 获得的值直接属于graph的一部分,所以不再需要用feed_dict来喂
        scalar,vector,matrix,tensor = sess.run([next_element['scalar'],
                                                next_element['vector'],
                                                next_element['matrix'],
                                                next_element['tensor']])
    # 如果遍历完了数据集,则返回错误
    except tf.errors.OutOfRangeError:
        print("End of dataset")
        break
    else:
        # 显示每个样本中的所有feature的信息,只显示scalar的值
        print('==============example %s ==============' %i)
        print('scalar: value: %s | shape: %s | type: %s' %(scalar, scalar.shape, scalar.dtype))
        print('vector shape: %s | type: %s' %(vector.shape, vector.dtype))
        print('matrix shape: %s | type: %s' %(matrix.shape, matrix.dtype))
        print('tensor shape: %s | type: %s' %(tensor.shape, tensor.dtype))
    i+=1
plt.imshow(tensor)

进行shuffle

  • buffer_size=10000:的含义是先创建一个大小为10000的buffer,然后对这个buffer进行打乱,如果buffersize过大的话虽然打乱效果很好,但是更加的占用内存,如果buffersize小的话打乱效果不好,一般可以设置为一个batch_size的10倍。
shuffle_dataset = new_dataset.shuffle(buffer_size=10000)
iterator = shuffle_dataset.make_one_shot_iterator()
next_element = iterator.get_next()

设置batch

batch_dataset = shuffle_dataset.batch(4)
iterator = batch_dataset.make_one_shot_iterator()
next_element = iterator.get_next()

Batch_padding

  • 可以在每个batch内进行padding
  • padded_shapes指定了内部数据是如何pad的。
  • rank数要与元数据对应
  • rank中的任何一维被设定成None-1时都表示将pad到该batch下的最大长度。
batch_padding_dataset = new_dataset.padded_batch(4, 
                        padded_shapes={'scalar': [],
                                       'vector': [-1,5],
                                       'matrix': [None,None],
                                       'matrix_shape': [None],
                                       'tensor': [None,None,None],
                                       'tensor_shape': [None]})
iterator = batch_padding_dataset.make_one_shot_iterator()
next_element = iterator.get_next()

设置epoch

使用.repeat(num_epochs)来指定要遍历几遍整个数据集。

num_epochs = 2
epoch_dataset = new_dataset.repeat(num_epochs)
iterator = epoch_dataset.make_one_shot_iterator()
next_element = iterator.get_next()
    原文作者:VanJordan
    原文地址: https://www.jianshu.com/p/72596a8488c3
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞