实战tfrecord文件的生成与读取

最新推荐文章于 2021-09-02 17:09:35 发布
最新推荐文章于 2021-09-02 17:09:35 发布
阅读量896 收藏 3
点赞数 3
分类专栏： tensorflow_2.0 文章标签： tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41660119/article/details/105888140
版权

1、tfrecord基础API使用

tfrecord文件格式

         -> tf.train.Example
                            -> tf.train.Features -> dict{"key": tf.train.Feature}
                                                -> tf.train.Feature -> tf.train.ByteList/FloatList/Int64List

 （1）定义tf.train.ByteList/FloatList/Int64List

favorite_books = [name.encode('utf-8')
                  for name in ["machine learning", "cc150"]]
favorite_books_bytelist = tf.train.BytesList(value = favorite_books)
print(favorite_books_bytelist)

hours_floatlist = tf.train.FloatList(value = [15.5, 9.5, 7.0, 8.0])
print(hours_floatlist)

age_int64list = tf.train.Int64List(value = [42])
print(age_int64list)
value: "machine learning"
value: "cc150"

value: 15.5
value: 9.5
value: 7.0
value: 8.0

value: 42

（2）定义features

features = tf.train.Features(
    feature = {
        "favorite_books_bytelist": tf.train.Feature(
            bytes_list = favorite_books_bytelist),
        "hours_floatlist": tf.train.Feature(
            float_list = hours_floatlist),
        "age_int64list": tf.train.Feature(
            int64_list = age_int64list),
    }
)
print(features)
feature {
  key: "age"
  value {
    int64_list {
      value: 42
    }
  }
}
feature {
  key: "favorite_books"
  value {
    bytes_list {
      value: "machine learning"
      value: "cc150"
    }
  }
}
feature {
  key: "hours"
  value {
    float_list {
      value: 15.5
      value: 9.5
      value: 7.0
      value: 8.0
    }
  }
}

（3）定义Example

example = tf.train.Example(features=features)
print(example)

features {
  feature {
    key: "age"
    value {
      int64_list {
        value: 42
      }
    }
  }
  feature {
    key: "favorite_books"
    value {
      bytes_list {
        value: "machine learning"
        value: "cc150"
      }
    }
  }
  feature {
    key: "hours"
    value {
      float_list {
        value: 15.5
        value: 9.5
        value: 7.0
        value: 8.0
      }
    }
  }
}

（4）将example序列化

因为在存储时需要对内容进行压缩，以减少size。

serialized_example = example.SerializeToString()
print(serialized_example)
b'\n\\\n-\n\x0efavorite_books\x12\x1b\n\x19\n\x10machine learning\n\x05cc150\n\x0c\n\x03age\x12\x05\x1a\x03\n\x01*\n\x1d\n\x05hours\x12\x14\x12\x12\n\x10\x00\x00xA\x00\x00\x18A\x00\x00\xe0@\x00\x00\x00A'

（5）生成tfrecord文件

将序列化后的example存到文件中，生成一个tfrecord文件

output_dir = 'tfrecord_basic'
if not os.path.exists(output_dir):
    os.mkdir(output_dir)
filename = "test.tfrecords"
filename_fullpath = os.path.join(output_dir, filename) #全路径：文件夹+文件名
with tf.io.TFRecordWriter(filename_fullpath) as writer:
    for i in range(3):
        writer.write(serialized_example)#将序列化后的example写进去三次

（6）读取TFRecord文件

1）读取序列化后的example的TFRecord文件

dataset = tf.data.TFRecordDataset([filename_fullpath])#生成TFRecord的dateset
for serialized_example_tensor in dataset:
    print(serialized_example_tensor)
tf.Tensor(b'\n\\\n-\n\x0efavorite_books\x12\x1b\n\x19\n\x10machine learning\n\x05cc150\n\x0c\n\x03age\x12\x05\x1a\x03\n\x01*\n\x1d\n\x05hours\x12\x14\x12\x12\n\x10\x00\x00xA\x00\x00\x18A\x00\x00\xe0@\x00\x00\x00A', shape=(), dtype=string)
tf.Tensor(b'\n\\\n-\n\x0efavorite_books\x12\x1b\n\x19\n\x10machine learning\n\x05cc150\n\x0c\n\x03age\x12\x05\x1a\x03\n\x01*\n\x1d\n\x05hours\x12\x14\x12\x12\n\x10\x00\x00xA\x00\x00\x18A\x00\x00\xe0@\x00\x00\x00A', shape=(), dtype=string)
tf.Tensor(b'\n\\\n-\n\x0efavorite_books\x12\x1b\n\x19\n\x10machine learning\n\x05cc150\n\x0c\n\x03age\x12\x05\x1a\x03\n\x01*\n\x1d\n\x05hours\x12\x14\x12\x12\n\x10\x00\x00xA\x00\x00\x18A\x00\x00\xe0@\x00\x00\x00A', shape=(), dtype=string)

2）将序列化后的example解析成正常的example，再进行读取

#定义一个字典，字典中定义了每一个feature所对应的类型
expected_features = {
    "favorite_books": tf.io.VarLenFeature(dtype = tf.string), #变长
    "hours": tf.io.VarLenFeature(dtype = tf.float32),
    "age": tf.io.FixedLenFeature([], dtype = tf.int64),
}
dataset = tf.data.TFRecordDataset([filename_fullpath])
for serialized_example_tensor in dataset:
    #print(serialized_example_tensor)
    #对于每个数值并未直接打印，而是先解析一下
    example = tf.io.parse_single_example(
        serialized_example_tensor,
        expected_features)
    print(example)
    books = tf.sparse.to_dense(example["favorite_books"],
                               default_value=b"")
    for book in books:
        print(book.numpy().decode("UTF-8"))
{'favorite_books': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x00000125F39D5198>, 'hours': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x00000125F39D5278>, 'age': <tf.Tensor: id=164, shape=(), dtype=int64, numpy=42>}
machine learning
cc150
{'favorite_books': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x00000125F3999E48>, 'hours': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x00000125F39992B0>, 'age': <tf.Tensor: id=183, shape=(), dtype=int64, numpy=42>}
machine learning
cc150
{'favorite_books': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x00000125F39D51D0>, 'hours': <tensorflow.python.framework.sparse_tensor.SparseTensor object at 0x00000125F39D52B0>, 'age': <tf.Tensor: id=202, shape=(), dtype=int64, numpy=42>}
machine learning
cc150

（7）将TFRecord存储成压缩文件（330B vs 127B）

压缩文件与普通文件有很多相同地方，在下面主要介绍不同的地方，其他未介绍的地方，应与普通文件的用法相同。

filename_fullpath_zip = filename_fullpath + '.zip'
options = tf.io.TFRecordOptions(compression_type = "GZIP")
with tf.io.TFRecordWriter(filename_fullpath_zip, options) as writer:
    for i in range(3):
        writer.write(serialized_example)
dataset_zip = tf.data.TFRecordDataset([filename_fullpath_zip], 
                                      compression_type= "GZIP")
for serialized_example_tensor in dataset_zip:
    example = tf.io.parse_single_example(
        serialized_example_tensor,
        expected_features)
    books = tf.sparse.to_dense(example["favorite_books"],
                               default_value=b"")
    for book in books:
        print(book.numpy().decode("UTF-8"))
machine learning
cc150
machine learning
cc150
machine learning
cc150

2、实战-将csv文件转化为tfrecord文件

在csv_reader_dataset中，我们在map函数中对每一行进行解析。

在parse_csv_line中，我们把每一行给拆成了前八个和后一个，即x和y。这样csv_reader_dataset返回的dataset里，每一个batch都是两个元素，即x_batch和y_batch。

而batch解绑定直接用了for循环，如下，

#接下来遍历这三个dataset,把取到的数据放到tfrecord中去
def serialize_example(x, y):
    """Converts x, y to tf.train.Example and serialize"""
    input_feautres = tf.train.FloatList(value = x)
    label = tf.train.FloatList(value = y)
    features = tf.train.Features(
        feature = {
            "input_features": tf.train.Feature(
                float_list = input_feautres),
            "label": tf.train.Feature(float_list = label)
        }
    )
    example = tf.train.Example(features = features)
    return example.SerializeToString()


#将从csv中读取的dataset转化成tf.example，再写到tf.record文件中。
def csv_dataset_to_tfrecords(base_filename, dataset,
                             n_shards, #存成多少个文件
                             steps_per_shard,
                             compression_type = None):
    options = tf.io.TFRecordOptions(
        compression_type = compression_type)
    all_filenames = []
    
    for shard_id in range(n_shards):#遍历每一个要生成的小文件
        filename_fullpath = '{}_{:05d}-of-{:05d}'.format(
            base_filename, shard_id, n_shards)
        with tf.io.TFRecordWriter(filename_fullpath, options) as writer:
            #for x_batch, y_batch in dataset.take(steps_per_shard):
            for x_batch, y_batch in dataset.skip(shard_id * steps_per_shard).take(steps_per_shard):#取得的每个数据都是一个batch
                for x_example, y_example in zip(x_batch, y_batch):#解batch
                    writer.write(
                        serialize_example(x_example, y_example))
        all_filenames.append(filename_fullpath)
    return all_filenames

生成不压缩的tfrecord文件：

#生成不压缩的tfrecord文件
n_shards = 20
train_steps_per_shard = 11610 // batch_size // n_shards #得到在每一个shard上，需要有多少个batch
valid_steps_per_shard = 3880 // batch_size // n_shards
test_steps_per_shard = 5170 // batch_size // n_shards

#输出文件夹
output_dir = "generate_tfrecords"
if not os.path.exists(output_dir):
    os.mkdir(output_dir)

train_basename = os.path.join(output_dir, "train")
valid_basename = os.path.join(output_dir, "valid")
test_basename = os.path.join(output_dir, "test")

train_tfrecord_filenames = csv_dataset_to_tfrecords(
    train_basename, train_set, n_shards, train_steps_per_shard, None)
valid_tfrecord_filenames = csv_dataset_to_tfrecords(
    valid_basename, valid_set, n_shards, valid_steps_per_shard, None)
test_tfrecord_fielnames = csv_dataset_to_tfrecords(
    test_basename, test_set, n_shards, test_steps_per_shard, None)

生成压缩后的tfrecord文件:

#生成压缩后的tfrecord文件
n_shards = 20
train_steps_per_shard = 11610 // batch_size // n_shards
valid_steps_per_shard = 3880 // batch_size // n_shards
test_steps_per_shard = 5170 // batch_size // n_shards

output_dir = "generate_tfrecords_zip"
if not os.path.exists(output_dir):
    os.mkdir(output_dir)

train_basename = os.path.join(output_dir, "train")
valid_basename = os.path.join(output_dir, "valid")
test_basename = os.path.join(output_dir, "test")

train_tfrecord_filenames = csv_dataset_to_tfrecords(
    train_basename, train_set, n_shards, train_steps_per_shard,
    compression_type = "GZIP")
valid_tfrecord_filenames = csv_dataset_to_tfrecords(
    valid_basename, valid_set, n_shards, valid_steps_per_shard,
    compression_type = "GZIP")
test_tfrecord_fielnames = csv_dataset_to_tfrecords(
    test_basename, test_set, n_shards, test_steps_per_shard,
    compression_type = "GZIP")

3、实战-读取tfrecord文件

expected_features = {
    "input_features": tf.io.FixedLenFeature([8], dtype=tf.float32),
    "label": tf.io.FixedLenFeature([1], dtype=tf.float32)
}

def parse_example(serialized_example):
    example = tf.io.parse_single_example(serialized_example,
                                         expected_features)
    return example["input_features"], example["label"]

def tfrecords_reader_dataset(filenames, n_readers=5,
                             batch_size=32, n_parse_threads=5,
                             shuffle_buffer_size=10000):
    dataset = tf.data.Dataset.list_files(filenames)
    dataset = dataset.repeat()
    dataset = dataset.interleave(
        lambda filename: tf.data.TFRecordDataset(
            filename, compression_type = "GZIP"),
        cycle_length = n_readers
    )
    dataset.shuffle(shuffle_buffer_size)
    dataset = dataset.map(parse_example,
                          num_parallel_calls=n_parse_threads)
    dataset = dataset.batch(batch_size)
    return dataset

tfrecords_train = tfrecords_reader_dataset(train_tfrecord_filenames,
                                           batch_size = 3)
for x_batch, y_batch in tfrecords_train.take(2):
    print(x_batch)
    print(y_batch)
tf.Tensor(
[[-1.1334558   1.0731637  -0.38411045 -0.19008651 -0.45323023 -0.06815852
   1.0292323  -1.3457658 ]
 [-1.0591781   1.3935647  -0.02633197 -0.1100676  -0.6138199  -0.09695935
   0.3247131  -0.03747724]
 [-0.24628098  1.2333642  -0.41765466  0.02003763  0.16009521  0.15687561
  -0.7250671   0.6965625 ]], shape=(3, 8), dtype=float32)
tf.Tensor(
[[1.598]
 [0.672]
 [1.849]], shape=(3, 1), dtype=float32)
tf.Tensor(
[[ 0.51780826  0.6726626   0.15955476 -0.22812782  0.06029374 -0.03868682
   0.94524986 -1.2808508 ]
 [-0.07763786  0.91296333 -0.33707762 -0.27174184 -0.81251556  0.05529061
  -0.6644131   0.5916997 ]
 [-0.3680344  -1.0094423   9.957168    8.32342    -1.1128273  -0.14463872
   1.3418335  -0.21224862]], shape=(3, 8), dtype=float32)
tf.Tensor(
[[1.883]
 [1.652]
 [1.406]], shape=(3, 1), dtype=float32)

附全部代码：

import matplotlib as mpl
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import sklearn
import pandas as pd
import os
import sys
import time
import tensorflow as tf

from tensorflow import keras

print(tf.__version__)
print(sys.version_info)
for module in mpl, np, pd, sklearn, tf, keras:
    print(module.__name__, module.__version__)

source_dir = "./generate_csv/"
print(os.listdir(source_dir))

def get_filenames_by_prefix(source_dir, prefix_name):
    all_files = os.listdir(source_dir) #获取该目录下所有的文件名
    results = []
    for filename in all_files:
        if filename.startswith(prefix_name):
            results.append(os.path.join(source_dir, filename))#全路径
    return results

train_filenames = get_filenames_by_prefix(source_dir, "train")
valid_filenames = get_filenames_by_prefix(source_dir, "valid")
test_filenames = get_filenames_by_prefix(source_dir, "test")


#读取csv文件
def parse_csv_line(line, n_fields = 9):
    defs = [tf.constant(np.nan)] * n_fields
    parsed_fields = tf.io.decode_csv(line, record_defaults=defs)
    x = tf.stack(parsed_fields[0:-1])
    y = tf.stack(parsed_fields[-1:])
    return x, y


def csv_reader_dataset(filenames, n_readers=5,
                       batch_size=32, n_parse_threads=5,
                       shuffle_buffer_size=10000):
    dataset = tf.data.Dataset.list_files(filenames)
    dataset = dataset.repeat()
    dataset = dataset.interleave(
        lambda filename: tf.data.TextLineDataset(filename).skip(1),
        cycle_length = n_readers
    )
    dataset.shuffle(shuffle_buffer_size)
    dataset = dataset.map(parse_csv_line,
                          num_parallel_calls=n_parse_threads)
    dataset = dataset.batch(batch_size)
    return dataset

batch_size = 32
train_set = csv_reader_dataset(train_filenames,
                               batch_size = batch_size)
valid_set = csv_reader_dataset(valid_filenames,
                               batch_size = batch_size)
test_set = csv_reader_dataset(test_filenames,
                              batch_size = batch_size)

#接下来遍历这三个dataset,把取到的数据放到tfrecord中去
def serialize_example(x, y):
    """Converts x, y to tf.train.Example and serialize"""
    input_feautres = tf.train.FloatList(value = x)
    label = tf.train.FloatList(value = y)
    features = tf.train.Features(
        feature = {
            "input_features": tf.train.Feature(
                float_list = input_feautres),
            "label": tf.train.Feature(float_list = label)
        }
    )
    example = tf.train.Example(features = features)
    return example.SerializeToString()


#将从csv中读取的dataset转化成tf.example，再写到tf.record文件中。
def csv_dataset_to_tfrecords(base_filename, dataset,
                             n_shards, #存成多少个文件
                             steps_per_shard,
                             compression_type = None):
    options = tf.io.TFRecordOptions(
        compression_type = compression_type)
    all_filenames = []
    
    for shard_id in range(n_shards):#遍历每一个要生成的小文件
        filename_fullpath = '{}_{:05d}-of-{:05d}'.format(
            base_filename, shard_id, n_shards)
        with tf.io.TFRecordWriter(filename_fullpath, options) as writer:
            #for x_batch, y_batch in dataset.take(steps_per_shard):
            for x_batch, y_batch in dataset.skip(shard_id * steps_per_shard).take(steps_per_shard):#取得的每个数据都是一个batch
                for x_example, y_example in zip(x_batch, y_batch):#解batch
                    writer.write(
                        serialize_example(x_example, y_example))
        all_filenames.append(filename_fullpath)
    return all_filenames

#生成不压缩的tfrecord文件
n_shards = 20
train_steps_per_shard = 11610 // batch_size // n_shards #得到在每一个shard上，需要有多少个batch
valid_steps_per_shard = 3880 // batch_size // n_shards
test_steps_per_shard = 5170 // batch_size // n_shards

#输出文件夹
output_dir = "generate_tfrecords"
if not os.path.exists(output_dir):
    os.mkdir(output_dir)

train_basename = os.path.join(output_dir, "train")
valid_basename = os.path.join(output_dir, "valid")
test_basename = os.path.join(output_dir, "test")

train_tfrecord_filenames = csv_dataset_to_tfrecords(
    train_basename, train_set, n_shards, train_steps_per_shard, None)
valid_tfrecord_filenames = csv_dataset_to_tfrecords(
    valid_basename, valid_set, n_shards, valid_steps_per_shard, None)
test_tfrecord_fielnames = csv_dataset_to_tfrecords(
    test_basename, test_set, n_shards, test_steps_per_shard, None)

#生成压缩后的tfrecord文件
n_shards = 20
train_steps_per_shard = 11610 // batch_size // n_shards
valid_steps_per_shard = 3880 // batch_size // n_shards
test_steps_per_shard = 5170 // batch_size // n_shards

output_dir = "generate_tfrecords_zip"
if not os.path.exists(output_dir):
    os.mkdir(output_dir)

train_basename = os.path.join(output_dir, "train")
valid_basename = os.path.join(output_dir, "valid")
test_basename = os.path.join(output_dir, "test")

train_tfrecord_filenames = csv_dataset_to_tfrecords(
    train_basename, train_set, n_shards, train_steps_per_shard,
    compression_type = "GZIP")
valid_tfrecord_filenames = csv_dataset_to_tfrecords(
    valid_basename, valid_set, n_shards, valid_steps_per_shard,
    compression_type = "GZIP")
test_tfrecord_fielnames = csv_dataset_to_tfrecords(
    test_basename, test_set, n_shards, test_steps_per_shard,
    compression_type = "GZIP")

expected_features = {
    "input_features": tf.io.FixedLenFeature([8], dtype=tf.float32),
    "label": tf.io.FixedLenFeature([1], dtype=tf.float32)
}

def parse_example(serialized_example):
    example = tf.io.parse_single_example(serialized_example,
                                         expected_features)
    return example["input_features"], example["label"]

def tfrecords_reader_dataset(filenames, n_readers=5,
                             batch_size=32, n_parse_threads=5,
                             shuffle_buffer_size=10000):
    dataset = tf.data.Dataset.list_files(filenames)
    dataset = dataset.repeat()
    dataset = dataset.interleave(
        lambda filename: tf.data.TFRecordDataset(
            filename, compression_type = "GZIP"),
        cycle_length = n_readers
    )
    dataset.shuffle(shuffle_buffer_size)
    dataset = dataset.map(parse_example,
                          num_parallel_calls=n_parse_threads)
    dataset = dataset.batch(batch_size)
    return dataset

batch_size = 32
tfrecords_train_set = tfrecords_reader_dataset(
    train_tfrecord_filenames, batch_size = batch_size)
tfrecords_valid_set = tfrecords_reader_dataset(
    valid_tfrecord_filenames, batch_size = batch_size)
tfrecords_test_set = tfrecords_reader_dataset(
    test_tfrecord_fielnames, batch_size = batch_size)

model = keras.models.Sequential([
    keras.layers.Dense(30, activation='relu',
                       input_shape=[8]),
    keras.layers.Dense(1),
])
model.compile(loss="mean_squared_error", optimizer="sgd")
callbacks = [keras.callbacks.EarlyStopping(
    patience=5, min_delta=1e-2)]

history = model.fit(tfrecords_train_set,
                    validation_data = tfrecords_valid_set,
                    steps_per_epoch = 11160 // batch_size,
                    validation_steps = 3870 // batch_size,
                    epochs = 100,
                    callbacks = callbacks)

model.evaluate(tfrecords_test_set, steps = 5160 // batch_size)

 

兰钧
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
video2tfrecord:轻松将RGB视频数据（例如.avi）转换为TensorFlow tfrecords文件格式，以便在TensorFlow中训练例如NN。 此实现允许限制要存储在tfrecord中的每个视频的帧数
05-02
描述 轻松地将RGB视频数据（例如，使用.avi和.mp4测试）转换为TensorFlow tfrecords文件格式，以进行培训，例如在TensorFlow中进行NN训练。 由于深度学习中常见的硬件/ GPU RAM限制，此实现允许限制要存储在tfrecord中的每个视频的帧数，或仅使用所有视频帧。 该代码自动选择帧步长，其中各个视频帧的间隔分布相等。 该实现提供了将光学流（当前为OpenCVcalcOpticalFlowFarneback）作为tfrecords数据的附加通道的选项（例如，通过将当前使用的光学流算法交换为其他算法，可以很容易地对其进行扩展）。 在代码旁边，我们还添加了一个小示例，其中包含两个.mp4文件，可从中创建两个tfrecords批处理（每个tfrecords文件一个视频）。 要访问示例，请确保使用GitHub repo而不是pip包。 该实现是在一个研究项目
tfrecord格式文件生成和读取
qq_32172681的博客
07-06 1041
一般情况下的数据集分为train、test等多个文件夹，每个文件夹有很多个文件，依次读取非常不方便。tensorflow的tfrecord数据文件是一种将图像数据和标签统一存储的二进制文件，只需一次性加载一个二进制文件，就可以实现快速的复制，移动，读取，存储。 tfrecord格式文件生成和读取地址：https://www.jianshu.com/p/b480e5fcb638 ...
tf.record文件生成与读取
rocking_struggling的博客
03-08 1180
一.tf.record文件的优点 它是一个统一的不同文件的输出框架，
tfRecords文件的生成和读取
青春正年少我要大声笑lamusique
08-03 695
在本文中，你将学习到以下内容： 将图片数据制作成tfrecord格式 将tfrecord格式数据还原成图片 前言 tfrecord是TensorFlow官方推荐的标准格式，能够将图片数据和标签一起存储成二进制文件，在TensorFlow中实现快速地复制、移动、读取和存储操作。训练网络的时候，通过建立队列系统，可以预先将tfrecord格式的数据加载进队列，队列会自动实现数据随机或有序地进出栈...
使用video2tfrecord 将视频文件生成tfrecord数据集
旭峰的博客
06-12 1664
逛stackflow发现一个好用的库，虽然现在用不着，但是可以记下来，说不定有机会用呢。 Description 这个库能很容易的将RGB视频文件（如：avi，mp4）转换为用于神经网络训练的tensorflow tfrecords 文件格式。由于深度学习中gpu和内存都是稀缺资源，所以这个项目中也允许限制每个视频保存到tfrecord中的图片数，同样也可以全部保存下来。代码自动决定步长，...
实战csv文件的生成与读取
12-21
将加利福尼亚房价预测数据集（回归问题）生成csv文件，并读取生成的csv文件。 1、csv文件的生成 csv文件：“，”分割，按行存储的文件。 output_dir = "generate_csv" #定义文件夹存储生成的数据文件 if not os....
从多个tfrecord文件中无限读取文件的例子
09-17
今天小编就为大家分享一篇从多个tfrecord文件中无限读取文件的例子，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
tfrecord数据集读取
06-18
可以读取制作好的tfrecord文件，并且显示出来。这里的数据集是图片，所以直接显示出图片
php生成与读取excel文件
10-21
在网站的管理后台经常会使用到报表的生成和读取，CSV和Excel都是常用的报表格式，本文是介绍php生成与读取excel文件，需要的朋友可以来了解一下。
读写tf_record文件
狐小九的博客
09-02 397
tf_record是什么 是谷歌推荐的一种二进制文件格式，整个文件由文件长度信息、长度校验码、数据、数据校验码组成。 代码 代码基于tensorflow2.6.0，python3.7环境 # -*- coding: utf-8 -*- """ @Description: tf_record文件读写 """ from loguru import logger import pandas as pd import tensorflow as tf import numpy as np def w
Tensorflow——TFRecord文件的制作及读取
weixin_43424744的博客
11-20 271
Tensorflow——TFRecord文件的制作及读取 一、TFRecord文件的制作 TFRecord是TensorFlow提供的统一存储数据的一种格式。在训练一个深度学习的模型之前，往往需要先制作数据集。这里主要介绍在TensorFlow框架下，将图像数据库及其对应的标签制作成TFRecord文件，便于图像数据的输入。直接贴个样例代码讲解吧。 import tensorflow as tf ...
使用 tfrecord 制作自己的数据集 （附上源代码）
qq_24193303的博客
04-19 1601
相信很多刚入手深度学习的人，最早接触的程序就是Mnist 手写数字的识别。Mnist 数据集都已被事先整理好，我们只有拿来用即可。但是如何制作自己的数据集，相信很多刚入门的人还是会一团雾水。作为刚入门不就的小白，我也花了很长时间才完整的制作了自己的数据集。制作自己的数据集，大概可以分为这么几步：Step1.首先要去收集自己的数据吧，可以是自己拍的图片，也可以是那种网上爬虫爬下来的图片。Step2....
报错：InternalError: Blas GEMM launch failed : a.shape=(32, 8), b.shape=(8, 30), m=32, n=30, k=8
兰钧的博客
09-09 4567
报错：InternalError: Blas GEMM launch failed : a.shape=(32, 8), b.shape=(8, 30), m=32, n=30, k=8 [Op:MatMul] 解决办法：在import后添加如下代码并restart： physical_devices = tf.config.experimental.list_physical_devic...
模型构建时的input_shape
兰钧的博客
09-09 3838
当我们想要构建一个模型时，通常会使用tf.keras.Sequential的方法进行层次堆叠，在添加第一层网络结构时，我们要指定模型的input_shape，在这里有一个简便方法：如果数据格式是[num_examples, data_dim1, data_dim2, data_dim3,...]，这样的形式的话，它的input_shape都可以统一写成：x_train.shape[1:]，这种方法...
Tensorflow Keras模型和Estimator有什么区别？
兰钧的博客
09-09 3151
对于整个tensorflow2.0框架，tensorflow Keras模型和Tensorflow Estimators都能够训练神经网络模型并使用它们来预测新的数据。 它们都是TensorFlow 的高级API。 那么什么时候应该用一个来代替另一个呢？，它们两者的区别是什么？又有什么联系？工程实战中怎么区分二者的使用？ Background： Estimators API是在版本1.1中添加...
实战sklearn超参数搜索(随机化)
兰钧的博客
09-09 2517
待补充
模型训练过程小结（适合小白）
兰钧的博客
09-09 2245
为了让自己更清楚模型的训练过程，在这里对训练过程进行一下记录，欢迎大佬补充与指正。 1、fit函数训练过程： model.compile(loss="sparse_categorical_crossentropy", optimizer = keras.optimizers.SGD(0.001), metrics = ["accurac...
TF1.0与TF2.0的区别？，怎样将TF1.0代码转为TF2.0代码？
兰钧的博客
09-09 1727
1、TF1.0与TF2.0的区别 2、API变动 3、如何升级 示例： TF1.0代码: TF2.0代码：
python如何读取tfrecord文件_Python如何读取tfrecord文件使用pytorch读取tfrecord文件而不依赖tensordflow,python,PyTorch,TensorD...
最新发布
06-08
Python读取TFRecord文件的方法如下： ```python import tensorflow as tf # 创建一个TFRecordDataset对象 dataset = tf.data.TFRecordDataset('data.tfrecord') # 定义读取函数 def parser(record): features = { 'image': tf.io.FixedLenFeature([], dtype=tf.string), 'label': tf.io.FixedLenFeature([], dtype=tf.int64) } parsed = tf.io.parse_single_example(record, features) image = tf.io.decode_jpeg(parsed['image'], channels=3) label = parsed['label'] return image, label # 应用读取函数到每个record dataset = dataset.map(parser) # 创建迭代器 iterator = dataset.make_one_shot_iterator() # 获取数据 image, label = iterator.get_next() ``` 以上代码演示了如何读取名为`data.tfrecord`的TFRecord文件，并解析其中的图像和标签信息。在解析函数`parser`中，我们先定义了TFRecord文件中包含的特征信息，然后使用`tf.io.parse_single_example`函数解析单个record，并对图像数据进行解码。最后，我们使用`map`函数将解析函数应用到每个record上。 当然，如果您使用的是PyTorch，也可以使用以下代码读取TFRecord文件： ```python import torch import torchvision.datasets as datasets import torchvision.transforms as transforms # 定义解析函数 def parser(record): features = { 'image': tf.io.FixedLenFeature([], dtype=tf.string), 'label': tf.io.FixedLenFeature([], dtype=tf.int64) } parsed = tf.io.parse_single_example(record, features) image = tf.io.decode_jpeg(parsed['image'], channels=3) label = parsed['label'] return image, label # 创建数据集对象 dataset = datasets.DatasetFolder( 'data.tfrecord', loader=lambda x: torch.load(x), extensions=('tfrecord') ) # 应用解析函数到每个record dataset.transform = transforms.Compose([ parser ]) # 创建数据加载器 dataloader = torch.utils.data.DataLoader( dataset, batch_size=32, shuffle=True ) # 获取数据 for images, labels in dataloader: # 使用数据进行训练或预测 pass ``` 以上代码演示了如何使用PyTorch的`DatasetFolder`读取TFRecord文件，并使用解析函数`parser`解析图像和标签信息。最后，我们创建了一个数据加载器，并使用其中的数据进行训练或预测。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值