让不懂建站的用户快速建站，让会建站的提高建站效率！
上一篇：《构建东谈主工智能模子基础：TFDS和Keras的齐备搭配》
前言：在东谈主工智能模子的进修过程中，怎样高效料理和处理无数数据是一个垂危的课题。TensorFlow 的 TFRecord 形态为大界限数据存储和处理提供了一种天真且高效的责罚决策。在本节学问中，咱们将先容怎样行使 TFRecord 结合 TensorFlow 的 Dataset API 进行数据的提真金不怕火、转念和加载（ETL），从而更好地复旧东谈主工智能模子的进修和优化。通过 TFRecord，您不错将原始数据存储为一种轻量且易于处理的二进制形态，从而在大界限数据集的加载息争析上取得权贵的性能升迁。咱们将翔实探索怎样构建 ETL 数据管谈，通过并行处理、批处理和预取等本事，让数据加载与模子进修过程愈加运动、快速。这种数据处理方式不仅在单台机器上线路出色，还能在多核 CPU、GPU 或 TPU 上彭胀，齐全更大界限的东谈主工智能模子进修。不管您是处理图像、文本，照旧其他类型的大界限数据，相识并掌持 TFRecord 偏执优化本事将为构建高效的数据管谈奠定基础，使您粗略更快速、智能地进修东谈主工智能模子。
相识 TFRecord
当您使用 TFDS 时，数据会被下载并缓存到磁盘，因此您无需每次使用时齐从头下载。TFDS 使用 TFRecord 形态进行缓存。若是您仔细不雅察下载过程，就会发现这少量——举例，图 4-1 展示了 cnn_dailymail 数据集怎样被下载、打乱并写入 TFRecord 文献。
图 4-1. 将 cnn_dailymail 数据集下载
图 4-1. 将 cnn_dailymail 数据集下载为 TFRecord 文献
在 TensorFlow 中，TFRecord 是存储和检索无数数据的首选形态。这是一种相称简便的文献结构，按限定读取以提高性能。在磁盘上，文献的结构相对平直，每札纪录由一个暗示纪录长度的整数、其对应的轮回冗余校验（CRC）、一个数据的字节数组及该字节数组的 CRC 构成。这些纪录被衔接成一个文献，若是数据集很大，则会进行分片。
举例，图 4-2 败露了 cnn_dailymail 的
举例，图 4-2 败露了 cnn_dailymail 的进修集不才载后被分红了 16 个文献。
为了更直不雅地了解一个简便的示例，不错下载 MNIST 数据集并打印其信息：
data, info = tfds.load("mnist", with_info=True)
print(info)
在 info 中，您会看到其特征是这样存储的：
features=FeaturesDict({
'image': Image(shape=(28, 28, 1), dchk=1&type=tf.uint8),
'label': ClassLabel(shape=(), dchk=1&type=tf.int64, num_classes=10),
}),
与 CNN/DailyMail 的示例雷同，文献会被下载到 /root/tensorflow_datasets/mnist/<version>/files 目次。
您不错像这样将原始纪录作为 TFRecordDataset 加载：
filename="/root/tensorflow_datasets/mnist/3.0.0/mnist-test.tfrecord-00000-of-00001"
raw_dataset = tf.data.TFRecordDataset(filename)
for raw_record in raw_dataset.take(1):
print(repr(raw_record))
请珍摄，文献名的位置可能会字据您的操作系统而有所不同。
<tf.Tensor: shape=(), dchk=1&type=string, numpy=b"\n\x85\x03\n\xf2\x02\n\x05image\x12\xe8\x02\n\xe5\x02\n\xe2\x02\x89PNG\r \n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x1c\x00\x00\x00\x1c\x08\x00\x00\x00\x00Wf \x80H\x00\x00\x01)IDAT(\x91\xc5\xd2\xbdK\xc3P\x14\x05\xf0S(v\x13)\x04,.\x82\xc5A q\xac\xedb\x1d\xdc\n.\x12\x87n\x0e\x82\x93\x7f@Q\xb2\x08\xba\tbQ0.\xe2\xe2\xd4\x b1\xa2h\x9c\x82\xba\x8a(\nq\xf0\x83Fh\x95\n6\x88\xe7R\x87\x88\xf9\xa8Y\xf5\x0e\x 8f\xc7\xfd\xdd\x0b\x87\xc7\x03\xfe\xbeb\x9d\xadT\x927Q\xe3\xe9\x07:\xab\xbf\xf4\ xf3\xcf\xf6\x8a\xd9\x14\xd29\xea\xb0\x1eKH\xde\xab\xea%\xaba\x1b=\xa4P/\xf5\x02\ xd7\\\x07\x00\xc4=,L\xc0,>\x01@2\xf6\x12\xde\x9c\xde[t/\xb3\x0e\x87\xa2\xe2\ xc2\xe0A<\xca\xb26\xd5(\x1b\xa9\xd3\xe8\x0e\xf5\x86\x17\xceE\xdarV\xae\xb7_\xf3 I\xf7(\x06m\xaaE\xbb\xb6\xac\r*\x9b$e<\xb8\xd7\xa2\x0e\x00\xd0l\x92\xb2\xd5\x15\ xcc\xae'\x00\xf4m\x08O'+\xc2y\x9f\x8d\xc9\x15\x80\xfe\x99[q\x962@CN|i\xf7\xa9!=\ \xab\x19\x00\xc8\xd6\xb8\xeb\xa1\xf0\xd8l\xca\xfb]\xee\xfb]*\x9fV\xe1\x07\xb7\xc 9\x8b55\xe7M\xef\xb0\x04\xc0\xfd&\x89\x01<\xbe\xf9\x03*\x8a\xf5\x81\x7f\xaa/2y\x 87ks\xec\x1e\xc1\x00\x00\x00\x00IEND\xaeB`\x82\n\x0e\n\x05label\x12\x05\x1a\x03\ n\x01\x02">
它是一个包含纪录翔实信息的长字符串，内部还包括校验和等实践。然而若是咱们也曾知谈特征，咱们就不错创建一个特征形色，然后用它来认识数据。代码如下：
# 创建特征形色
feature_description = {
'image': tf.io.FixedLenFeature([], dchk=1&type=tf.string),
'label': tf.io.FixedLenFeature([], dchk=1&type=tf.int64),
}
def _parse_function(example_proto):
# 使用上头的字典认识输入的 `tf.Example` proto
return tf.io.parse_single_example(example_proto, feature_description)
parsed_dataset = raw_dataset.map(_parse_function)
for parsed_record in parsed_dataset.take(1):
print((parsed_record))
这样输出的实践就友许多了！最初，您不错看到图像是一个 Tensor，何况它包含一个 PNG。PNG 是一种压缩图像形态，头部由 IHDR 界说，图像数据位于 IDAT 和 IEND 之间。若是仔细不雅察字节流，您不错看到它们。同期也有标签，它以整数方式存储，包含值 2：
{
'image': <tf.Tensor: shape=(), dchk=1&type=string,
numpy=b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x1c\x00\x00\x00\x1c\x08\x00\x00\x00\x00Wf\x80H\x00\x00\x01)IDAT(\x91\xc5\xd2\xbdK\xc3P\x14\x05\xf0S(v\x13)\x04,.\x82\xc5Aq\xac\xedb\x1d\xdc\n.\x12\x87n\x0e\x82\x93\x7f@Q\xb2\x08\xba\tbQ0.\xe2\xe2\xd4\xb1\xa2h\x9c\x82\xba\x8a(\nq\xf0\x83Fh\x95\n6\x88\xe7R\x87\x88\xf9\xa8Y\xf5\x0e\x8f\xc7\xfd\xdd\x0b\x87\xc7\x03\xfe\xbeb\x9d\xadT\x927Q\xe3\xe9\x07:\xab\xbf\xf4\xf3\xcf\xf6\x8a\xd9\x14\xd29\xea\xb0\x1eKH\xde\xab\xea%\xaba\x1b=\xa4P/\xf5\x02\xd7\\\x07\x00\xc4=,L\xc0,>\x01@2\xf6\x12\xde\x9c\xde[t/\xb3\x0e\x87\xa2\xe2\xc2\xe0A<\xca\xb26\xd5(\x1b\xa9\xd3\xe8\x0e\xf5\x86\x17\xceE\xdarV\xae\xb7_\xf3AR\r!I\xf7(\x06m\xaaE\xbb\xb6\xac\r*\x9b$e<\xb8\xd7\xa2\x0e\x00\xd0l\x92\xb2\xd5\x15\xcc\xae'\x00\xf4m\x08O'+\xc2y\x9f\x8d\xc9\x15\x80\xfe\x99[q\x962@CN|i\xf7\xa9!=\xd7
\xab\x19\x00\xc8\xd6\xb8\xeb\xa1\xf0\xd8l\xca\xfb]\xee\xfb]*\x9fV\xe1\x07\xb7\xc9\x8b55\xe7M\xef\xb0\x04\xc0\xfd&\x89\x01<\xbe\xf9\x03*\x8a\xf5\x81\x7f\xaa/2y\x87ks\xec\x1e\xc1\x00\x00\x00\x00IEND\xaeB`\x82">,
'label': <tf.Tensor: shape=(), dchk=1&type=int64, numpy=2>
}
到这里，您不错读取原始的 TFRecord 并使用雷同 Pillow 的 PNG 解码库将其解码为 PNG。
在 TensorFlow 中料理数据的 ETL 过程
不管界限大小，ETL 齐是 TensorFlow 用于进修的中枢模式。咱们在本书中探索了小界限的单台策画机模子构建，但换取的本事不错用于大界限进修，跨多台机器并处理海量数据集。
ETL 过程的提真金不怕火阶段是将原始数据从存储位置加载，并准备成不错转念的方式。转念阶段是对数据进行操作，使其稳妥或优化用于进修。举例，将数据进行批处理、图像增强、映射到特征列等逻辑，齐不错作为转念阶段的一部分。加载阶段则是将数据加载到神经采聚合进行进修。
来看一下完整的代码，用来进修“马匹或东谈主类”分类器。这里我添加了注目，展示提真金不怕火、转念和加载阶段的地点位置：
import tensorflow as tf
import tensorflow_datasets as tfds
import tensorflow_addons as tfa
# 模子界说开动 #
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(300, 300, 3)),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(32, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(512, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(optimizer='Adam', loss='binary_crossentropy', metrics=['accuracy'])
# 模子界说限定 #
# 提真金不怕火阶段开动 #
data = tfds.load('horses_or_humans', split='train', as_supervised=True)
val_data = tfds.load('horses_or_humans', split='test', as_supervised=True)
# 提真金不怕火阶段限定 #
# 转念阶段开动 #
def augmentimages(image, label):
image = tf.cast(image, tf.float32)
image = (image/255)
image = tf.image.random_flip_left_right(image)
image = tfa.image.rotate(image, 40, interpolation='NEAREST')
return image, label
train = data.map(augmentimages)
train_batches = train.shuffle(100).batch(32)
validation_batches = val_data.batch(32)
# 转念阶段限定 #
python
# 转念阶段限定
# 加载阶段开动
history = model.fit(train_batches, epochs=10, validation_data=validation_batches, validation_steps=1)
# 加载阶段限定
通过这样的进程，您的数据管谈不错更少地受到数据和底层模式变化的影响。当您使用 TFDS 提真金不怕火数据时，不管数据是小到不错放入内存，照旧大到无法放入简便的机器中，齐不错使用换取的底层结构。用于转念的 tf.data API 亦然一致的，因此不管底层数据源是什么，齐不错使用雷同的 API。虽然，一朝数据被转念，加载数据的过程亦然一致的，不管您是在单个 CPU、GPU、多个 GPU 集群，致使是 TPU 群组上进行进修。
有关词，加载数据的方式可能对进修速率产生庞大影响。接下来，咱们来望望怎样优化加载阶段。
优化加载阶段
在进修模子时，咱们不错潜入了解提真金不怕火-转念-加载（ETL）过程。咱们不错以为数据的提真金不怕火和转念不错在职那里理器上进行，包括 CPU。事实上，这些阶段的代码扩充诸如下载数据、解压缩数据、逐札纪录处理等任务，这些齐不是 GPU 或 TPU 的封锁，是以这部分代码频繁会在 CPU 上运行。然而在进修阶段，GPU 或 TPU 能权贵升迁性能，因此若是有要求，最佳在这一阶段使用 GPU 或 TPU。
因此，在有 GPU 或 TPU 的情况下，理思的作念法是将职责负载分派到 CPU 和 GPU/TPU 上：提真金不怕火和转念在 CPU 上完成，而加载则在 GPU/TPU 上完成。
假定您正在处理一个大型数据集。由于数据量大，必须以批次方式准备数据（即，扩充提真金不怕火和转念），这样就会出现雷同图 4-3 所示的情况。当第一个批次正在准备时，GPU/TPU 处于振作现象。当这个批次准备好时，它会被发送到 GPU/TPU 进行进修，但此时 CPU 则振作，直到进修完成，CPU 才智开动准备第二个批次。在这里会有无数的振作时分，因此咱们不错看到优化的空间。
图 4-3. 在 CPU/GPU 上进修
逻辑上的责罚决策是并行处理，让数据准备和进修同期进行。这种过程称为活水线处理，见图 4-4。
图 4-4. 活水线处理
在这种情况下，当 CPU 准备第一个批次时，GPU/TPU 仍然莫得任务，因此处于振作现象。当第一个批次准备好后，GPU/TPU 不错开动进修——同期，CPU 开动准备第二个批次。虽然，进修第 n-1 批次和准备第 n 批次所需的时分并不老是换取的。若是进修时分更快，GPU/TPU 会有一段振作时分；若是进修时分更慢，CPU 会有一段振作时分。遴荐合适的批次大小不错匡助优化这里的性能——由于 GPU/TPU 的时分通常更腾贵，您可能会尽量减少它们的振作时分。
您可能也曾珍摄到，当咱们从 Keras 中的简便数据集（如 Fashion MNIST）转向使用 TFDS 版块时，必须在进修之前对它们进行批处理。这等于原因：活水线模子的存在使得不管数据集有多大，您齐不错使用一致的 ETL 模式来处理它。
并行 ETL 以提高进修性能
TensorFlow 为您提供了扫数并行化提真金不怕火和转念过程所需的 API。让咱们通过 Dogs vs. Cats 数据集和底层 TFRecord 结构来望望它们的容貌。
最初，使用 tfds.load 获取数据集：
train_data = tfds.load('cats_vs_dogs', split='train', with_info=True)
若是您思使用底层的 TFRecords，您需要看望下载的原始文献。由于数据集较大，它被分红多个文献（在 4.0.0 版块均分为 8 个）。
您不错创建这些文献的列表，并使用 tf.data.Dataset.list_files 来加载它们：
file_pattern = f'/root/tensorflow_datasets/cats_vs_dogs/4.0.0/cats_vs_dogs-train.tfrecord*'
files = tf.data.Dataset.list_files(file_pattern)
获取文献后，不错使用 files.interleave 将它们加载到数据衔尾，如下所示：
train_dataset = files.interleave(
tf.data.TFRecordDataset,
cycle_length=4,
num_parallel_calls=tf.data.experimental.AUTOTUNE
)
这里有几个新主见，咱们来花点时分讲明一下。
cycle_length 参数指定同期处理的输入元素数目。稍后您会看到解码纪录的映射函数，它会在从磁盘加载时解码纪录。因为 cycle_length 成立为 4，是以这个过程会一次处理四札纪录。若是不指定该值，它会字据可用的 CPU 中枢数目自动详情。
num_parallel_calls 参数用于指定要扩充的并行调用数目。在这里成立为 tf.data.experimental.AUTOTUNE 不错使代码更具可移植性，因为值会字据可用的 CPU 动态调治。结合 cycle_length 参数，您就成立了并行度的最大值。举例，若是在自动调治后 num_parallel_calls 成立为 6 而 cycle_length 是 4，那么会有六个零丁线程，每个线程一次加载四札纪录。
现在提真金不怕火过程也曾并行化了，咱们来望望怎样并行化数据的转念。最初，创建加载原始 TFRecord 并将其转念为可用实践的映射函数——举例，将 JPEG 图像解码成图像缓冲区：
def read_tfrecord(serialized_example):
feature_description = {
"image": tf.io.FixedLenFeature((), tf.string, ""),
"label": tf.io.FixedLenFeature((), tf.int64, -1),
}
example = tf.io.parse_single_example(serialized_example, feature_description)
image = tf.io.decode_jpeg(example['image'], channels=3)
image = tf.cast(image, tf.float32)
image = image / 255
image = tf.image.resize(image, (300, 300))
return image, example['label']
如您所见，这是一个典型的映射函数，莫得作念任何特定的职责来使它并行化。并行化将在调用映射函数时完成。以下是齐全方法：
import multiprocessing
cores = multiprocessing.cpu_count()
print(cores)
train_dataset = train_dataset.map(read_tfrecord, num_parallel_calls=cores)
train_dataset = train_dataset.cache()
最初，若是您不思自动调优，不错使用 multiprocessing 库获取 CPU 的数目。然后，在调用映射函数时，您不错将此 CPU 数目作为并行调用的数目传入。等于这样简便。
cache 方法会将数据集缓存到内存中。若是您的 RAM 实足多，这会权贵加速速率。不外，若是在 Colab 中使用 Dogs vs. Cats 数据集尝试此操作，可能会导致臆造机崩溃，因为数据集无法实足装入内存。在这种情况下，Colab 的基础行为会为您提供一个新的、更高 RAM 的机器。
加载和进修过程相似不错并行化。在对数据进行打乱和批处理时，还不错字据可用 CPU 中枢数目进行预取。代码如下：
train_dataset = train_dataset.shuffle(1024).batch(32)
train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)
当进修集实足并行化后，您不错像夙昔一样进修模子：
model.fit(train_dataset, epochs=10, verbose=1)
我在 Google Colab 中磨练了这少量，发现这些用于并行化 ETL 过程的迥殊代码将每个 epoch 的进修时分从 75 秒减少到约 40 秒。如斯简便的蜕变险些将我的进修时分减半！
转头
到此为止咱们完成了先容谷歌的 TensorFlow Datasets，这是一个不错让您看望各式数据集的库，从小界限学习数据集到用于酌量的全界限数据集。您看到它们使用了通用 API 和形态，以减少您获取数据时所需编写的代码量。咱们还酌量了 ETL 过程，它是 TFDS 假想的中枢，终点是咱们探索了并行化提真金不怕火、转念和加载数据以提高进修性能。在接下来的学问中，咱们将细分学习目下最热的东谈主工智能主题，当然谈话处理本事。