TensorFlow深度学习实战（41）——TensorFlow生态系统

0. 前言

在本节中，我们将学习 TensorFlow 生态系统的不同组件，包括 TensorFlow Hub、TensorFlow Datasets、TensorFlow JS 和 TensorFlow Lite 等。详细介绍 TensorFlow Hub，一个用于预训练深度学习模型的仓库，以及 TensorFlow Datasets，一个提供预定义数据集的集合。我们还将介绍 TensorFlow Lite，一个用于移动和边缘设备的开源深度学习框架。

1. TensorFlow Hub

1.1 TensorFlow Hub 简介

即使我们拥有一台性能强大的计算机，训练一个机器学习模型也可能需要数天到数月的时间。而且，模型训练完成后，将其部署到不同设备上同样可能会遇到各种困难。根据部署的平台不同，可能需要不同的格式。
可以把 TensorFlow Hub (TF Hub) 看作是一个包含大量预训练模型的库。它包含了数百个训练好的、可以进行部署的深度学习模型。TF Hub 提供了用于图像分类、图像分割、物体检测、文本嵌入、文本分类、视频分类和生成等多种任务的预训练模型。TF Hub 中的模型可用格式包括 SavedModel、TFLite 和 TF.js，可以直接使用这些预训练模型进行推理，也可以对其进行微调。随着其用户和开发者社区的不断壮大，TF Hub 已成为寻找和分享机器学习模型的首选平台。要使用 TF Hub，首先需要进行安装：

$ pip install tensorflow_hub

安装后，可以使用以下代码进行导入：

import tensorflow_hub as hub

使用 load() 函数加载模型：

model = hub.load(handle)

其中 handle 是一个字符串，包含想要使用的模型链接。如果希望将其作为现有模型的一部分使用，可以将其封装为 Keras 层：

hub.KerasLayer(handle,trainable=False,arguments=None,_sentinel=None,tags=None,signature=None,signature_outputs_as_dict=None,output_key=None,output_shape=None,load_options=None,**kwargs
)

通过将参数 trainable 设为 True，可以根据特定数据对模型进行微调。下图展示了 tfhub.dev 网站的界面，可以选择不同的模型。我们可以轻松找到能够解决我们问题的模型，并选择需要的类型和格式。

1.2 使用预训练模型进行推理

接下来，我们介绍如何利用 TF Hub 上的预训练模型，为了进行说明，使用图像分类任务作为示例。

(1) 导入所需库模块：

import tensorflow as tf
import tensorflow_hub as hubimport requests
from PIL import Image
from io import BytesIOimport matplotlib.pyplot as plt
import numpy as np

(2) 定义函数 load_image_from_url()，根据 URL 加载图像。load_image_from_url() 函数获取图像，并通过添加批次索引进行推理。同时，图像会根据所选的预训练模型进行归一化并调整大小：

def load_image_from_url(img_url, image_size):"""Get the image from url. The image return has shape [1, height, width, num_channels]."""response = requests.get(img_url, headers={'User-agent': 'Colab Sample (https://tensorflow.org)'})image = Image.open(BytesIO(response.content))image = np.array(image)# reshape imageimg_reshaped = tf.reshape(image, [1, image.shape[0], image.shape[1], image.shape[2]]) # Normalize by convert to float between [0,1]image = tf.image.convert_image_dtype(img_reshaped, tf.float32) image_padded = tf.image.resize_with_pad(image, image_size, image_size)return image_padded, image

(3) 定义辅助函数 show_image() 用于显示图像：

def show_image(image, title=''):image_size = image.shape[1]w = (image_size * 6) // 320plt.figure(figsize=(w, w))plt.imshow(image[0], aspect='equal')plt.axis('off')plt.title(title)plt.show()

(4) 使用 EfficientNet-B2 模型，EfficientNet-B2 模型在 ImageNet 数据集上进行了训练，具有更好的准确性、更小的模型尺寸和更快的推理速度。将图像尺寸调整为 330 x 330 像素，使用函数 load_image_from_url() 下载指定图像：

image_size = 330
print(f"Images will be converted to {image_size}x{image_size}")
img_url =  "http://images.cocodataset.org/val2017/000000039769.jpg"
image, original_image = load_image_from_url(img_url, image_size) 
show_image(image, 'Scaled image')

(5) 从 TensorFlow 的公共存储库获取 ImageNet 数据的所有标签，以便从模型预测中获取标签：

labels_file = "https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt"#download labels and creates a maps
downloaded_file = tf.keras.utils.get_file("labels.txt", origin=labels_file)classes = []with open(downloaded_file) as f:labels = f.readlines()classes = [l.strip() for l in labels]

(6) 下载模型：

# Run model on image
classifier = hub.load("https://www.kaggle.com/models/tensorflow/efficientnet/tensorFlow2/b2-classification/1")

(7) 获取图像的所有类别的 softmax 概率：

probabilities = tf.nn.softmax(classifier(image)).numpy()

预测结果如下所示：

top_5 = tf.argsort(probabilities, axis=-1, direction="DESCENDING")[0][:5].numpy()show_image(image, f'{classes[top_5[0]+1]}: {probabilities[0][top_5][0]:.4f}')

可以看到，使用少量代码就可以得到优秀的推理结果。通过使用 TF Hub 的预训练模型，我们可以专注于任务工作流，从而获得更好的模型和更快的生产速度。

2. TensorFlow Datasets

2.1 TensorFlow Datasets 简介

TensorFlow Datasets (TFDS) 是一个强大的工具，提供了一系列现成的可用数据集，可以轻松地与 TensorFlow 或其他 Python 机器学习框架配合使用。数据集格式为 tf.data.Dataset 形式，使其易于在输入管道中的使用。
使用 TFDS，可以快速开始机器学习项目，节省时间而无需自己收集和准备数据。该库当前包含多种类型的数据集，包括图像分类、目标检测、文本分类等。此外，还提供了从头创建新数据集的工具，用于为自己的项目创建自定义数据集。要使用 TFDS，首先需要进行安装：

$ pip install tensorflow-datasets

安装后，可以按以下方式导入：

import tensorflow_datasets as tfds

TFDS 包含大量公共数据集，适用于广泛的任务：

datasets = tfds.list_builders()
print(f"TFDS contains {len(datasets)} datasets")

接下来，我们将介绍 TFDS，并将其用于简化训练过程，同时介绍有效加载大量数据到机器学习模型的最佳实践。

2.2 加载 TFDS 数据集

TFDS 中的每个数据集都有一个唯一的名称，并且每个数据集都有与之相关联的发布者和数据集版本。要获取数据，可以使用 TFDS 的 load 函数：

tfds.load(name: str,*,split: Optional[Tree[splits_lib.SplitArg]] = None,data_dir: Optional[str] = None,batch_size: tfds.typing.Dim = None,shuffle_files: bool = False,download: bool = True,as_supervised: bool = False,decoders: Optional[TreeDict[decode.partial_decode.DecoderArg]] = None,read_config: Optional[tfds.ReadConfig] = None,with_info: bool = False,builder_kwargs: Optional[Dict[str, Any]] = None,download_and_prepare_kwargs: Optional[Dict[str, Any]] = None,as_dataset_kwargs: Optional[Dict[str, Any]] = None,try_gcs: bool = False)

只需要指定数据集名称，其余参数是可选的。例如，下载 MNIST 数据集：

data, info  = tfds.load(name="mnist", as_supervised=True, split=['train', 'test'], with_info=True)

使用变量 data 存储下载的 MNIST 训练集和测试集，由于 as_supervised 参数值为 True，因此会同步下载标签，使用变量 info 存储数据集的详细信息。
首先，检查 info：

print(info)
tfds.core.DatasetInfo(name='mnist',version=3.0.1,description='The MNIST database of handwritten digits.',homepage='http://yann.lecun.com/exdb/mnist/',features=FeaturesDict({'image': Image(shape=(28, 28, 1), dtype=tf.uint8),'label': ClassLabel(shape=(), dtype=tf.int64, num_classes=10),}),total_num_examples=70000,splits={'test': 10000,'train': 60000,},supervised_keys=('image', 'label'),citation="""@article{lecun2010mnist,title={MNIST handwritten digit database},author={LeCun, Yann and Cortes, Corinna and Burges, CJ},journal={ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist},volume={2},year={2010}}""",redistribution_info=,
)

可以看到，信息非常详尽。输出了拆分情况以及每个拆分中的样本总数，适用于监督学习的键，引用详情等。变量 data 是包含两个 TFDS 数据集对象的列表，第一个对应于测试数据集，第二个对应于训练数据集。TFDS 数据集对象默认为字典格式。从训练数据集中取出一个样本并查看：

data_train = data[1].take(1)
for sample, lable in data_train:print(sample.shape)
print(lable)
# (28, 28, 1)
# tf.Tensor(2, shape=(), dtype=int64)

可以看到样本是一个 28 x 28 x 1 的手写数字图像，其标签为 2。对于图像数据，TFDS 还提供了一个 show_examples 方法，可以用于查看数据集中的样本图像：

fig = tfds.show_examples(data[0], info)

2.3 使用 TFDS 构建数据管道

接下来，使用 TFDS 数据管道构建一个完整的端到端神经网络模型。

(1) 首先，导入所需模块。使用 TensorFlow 构建模型，并使用 TFDS 获取数据集：

import tensorflow as tf
import tensorflow_datasets as tfds

(2) 使用 Sequential API，构建一个简单的卷积神经网络，包含三层卷积层和两层全连接层：

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.Flatten(), tf.keras.layers.Dense(256, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid')
])

(3) 构建二分类器，因选择二元交叉熵作为损失函数，并选择 Adam 作为优化器：

model.compile(optimizer='Adam', loss='binary_crossentropy',metrics=['accuracy'])

(4) 加载 horses_or_humans 数据集，使用 tfds.load 函数获取训练和验证数据：

data = tfds.load('horses_or_humans', split='train', as_supervised=True) 
val_data = tfds.load('horses_or_humans', split='test', as_supervised=True)

(5) 图像需要进行归一化，此外，为了更好的性能，在训练过程中使用数据增强：

def normalize_img(image, label):"""Normalizes images: `uint8` -> `float32`."""return tf.cast(image, tf.float32) / 255., labeldef augment_img(image, label):image, label = normalize_img(image, label)image = tf.image.random_flip_left_right(image)return image, label

(6) 构建数据管道。首先使用缓存函数 cache() 来提高内存效率，应用预处理步骤(归一化和增强)，打乱训练数据，定义批大小，并使用预加载函数 prefetch()，以便在当前批数据训练时加载下一个批数据。对验证数据执行相同的步骤，但验证数据不需要进行增强和打乱：

data = data.cache()
data = data.map(augment_img, num_parallel_calls=tf.data.AUTOTUNE)
train_data = data.shuffle(1024).batch(32)
train_data = train_data.prefetch(tf.data.AUTOTUNE)
val_data = val_data.map(normalize_img, num_parallel_calls=tf.data.AUTOTUNE)
val_data = val_data.batch(32)
val_data = val_data.cache()
val_data = val_data.prefetch(tf.data.AUTOTUNE)

(7) 最后，训练模型：

history = model.fit(train_data, epochs=10, validation_data=val_data, validation_steps=1)

尝试不同的数据管道参数，观察对训练时间的影响。例如，可以尝试移除预加载 (prefetch) 或缓存 (cache)，或指定不同的 num_parallel_calls 参数值。

3. TensorFlow Lite

TensorFlow Lite 是由 TensorFlow 设计的轻量级平台，专注于移动设备和嵌入式设备，如 Android、iOS 和 Raspberry Pi，电池和内存是移动和嵌入式设备的重要资源。TensorFlow Lite 的主要目标是在设备上直接进行机器学习推理，重点关注三个特性：

• 低模型大小以节省内存
• 低能耗以节省电池
• 低延迟以提高效率

为了实现以上特性，TensorFlow Lite 使用了量化、FlatBuffers、移动解释器和移动转换器等多种技术。

3.1 量化

量化是指将由连续值(如实数)组成的输入约束为离散集合(如整数)的技术。其核心思想是通过用整数代替实数表示模型内部权重，减少深度学习模型的空间占用。当然，这意味着需要在空间节省与模型性能之间进行权衡。但实践已经证明，量化模型在性能上并不会显著下降。TensorFlow Lite 内部围绕支持量化和浮点运算的一组核心操作符构建。
模型量化是应用量化的工具。该操作应用于权重的表示，并且可以选择性地应用于激活值，以用于存储和计算。量化有两种类型：

• 训练后量化 (Post-training quantization)：对训练后的权重和激活结果进行量化
• 量化感知训练 (Quantization-aware training)：允许训练能够以最小精度损失进行量化的网络(仅适用于特定的卷积神经网络)

TensorFlow Lite 支持将数值的精度从全精度浮点数降低到半精度浮点数 (float16) 或 8 位整数。

3.2 FlatBuffers

FlatBuffers 是一种开源格式，专门优化用于在移动和嵌入式设备上序列化数据。该格式最初由 Google 为游戏开发和其他性能关键应用创建。FlatBuffers 支持在不解析/解包的情况下访问序列化数据，以实现快速处理。该格式通过避免内存中不必要的多重副本来设计，以提高内存效率和速度。FlatBuffers 可在多个平台和语言中使用，如 C++、C#、C、Go、Java、JavaScript、Lobster、Lua、TypeScript、PHP、Python 和 Rust 等。

3.3 移动转换器

使用 TensorFlow 生成的模型需要转换为 TensorFlow Lite 模型。转换器可以引入优化以提高二进制大小和性能。例如，转换器可以修剪掉计算图中与推理不直接相关但用于训练的所有节点。

3.4 移动优化解释器

TensorFlow Lite 运行在一个高度优化的解释器上，用于优化底层计算图，这些计算图用于描述机器学习模型。在内部，解释器使用多种技术来优化计算图，包括引入静态图顺序和确保更好的内存分配。解释器核心本身大小约为 100 KB，包含所有支持的内核时约为 300 KB。
计算图是学习算法的图形表示；其中，节点描述要执行的操作，连接节点的边表示数据流。计算图为深度学习框架提供了性能效率，而如果用纯 NumPy 构建神经网络，则无法实现这些效率。

3.5 支持的平台

在 Android 上，TensorFlow Lite 推理可以使用 Java 或 C++ 进行。在 iOS 上，TensorFlow Lite 推理可以在 Swift 和 Objective-C 中运行。在 Linux 平台(如树莓派)上，推理可以在 C++ 和 Python 中运行。TensorFlow Lite for microcontrollers 是 TensorFlow Lite 的一个移植版，旨在在基于 Arm Cortex-M 和系列处理器的微控制器上运行机器学习模型，包括 Arduino Nano 33 BLE Sense、SparkFun Edge 和 STM32F746 Discovery kit，这些微控制器通常用于物联网应用。

3.6 架构

TensorFlow Lite 的架构如下图所示。支持 tf.keras 和低级 API。一个标准的 TensorFlow 2.x 模型可以通过使用 TFLite Converter 进行转换，然后保存为 TFLite FlatBuffer 格式( .tflite 文件)，该文件随后由 TFLite 解释器在可用的设备( GPU 和 CPU )以及本地设备 API 上执行。下图中的具体函数定义了一个图，可以被转换为 TensorFlow Lite 模型或导出为 SavedModel。

3.7 使用 TensorFlow Lite

使用 TensorFlow Lite 通常需要以下步骤：

• 模型选择：选择一个标准的 TensorFlow 模型来解决特定任务，可以是自定义模型或预训练模型
• 模型转换：使用 TensorFlow Lite 转换器将选定的模型进行转换，通常只需几行 Python 代码
• 模型部署：将转换后的模型部署到选择的设备上，可以是手机或物联网设备，然后通过 TensorFlow Lite 解释器运行，该 API 可用于多种语言
• 模型优化：可以选择使用 TensorFlow Lite 优化框架来优化模型。

3.8 应用程序的通用示例

在本节中，我们将学习如何将模型转换为 TensorFlow Lite 并运行。需要注意的是，训练仍然可以在合适的环境中由 TensorFlow 执行，但推理将在移动设备上进行：

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

使用一个标准的 TensorFlow 模型通过 tf.lite.TFLiteConverter.from_saved_model(saved_model_dir) 打开并转换。需要注意的是，不需要特定的安装，只需使用 tf.lite API。还可以应用多种优化。例如，默认情况下可以应用后训练量化：

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_quant_model)

模型转换完成后，可以部署到特定的设备上。当然，这一步对于每种设备来说是不同的，之后可以使用合适的语言运行模型。例如，在 Java 中，通过以下代码调用：

try (Interpreter interpreter = new Interpreter(tensorflow_lite_model_file)) {interpreter.run(input, output);
}

上述步骤可以用于各种移动和物联网设备。

3.9 使用 GPU 和加速器

手机通常会配备加速器，可以更快地执行浮点矩阵运算。在这种情况下，解释器可以使用 Delegate 的概念，特别是 GpuDelegate()，以利用 GPU。使用 Java 进行演示：

GpuDelegate delegate = new GpuDelegate();
Interpreter.Options options = (new Interpreter.Options()).
addDelegate(delegate);
Interpreter interpreter = new Interpreter(tensorflow_lite_model_file, options);
try {interpreter.run(input, output);
}

创建一个新的 GpuDelegate()，然后由解释器使用，以在 GPU 上运行模型。

小结

在本节中，我们讨论了 TensorFlow 生态系统的不同组件。从 TensorFlow Hub 开始，介绍了多个预训练模型。接着，我们介绍了 TensorFlow Datasets，并学习了如何使用 TFDS 构建数据管道。学习了如何使用 TensorFlow Lite 构建移动设备和物联网应用。

系列链接

TensorFlow深度学习实战（1）——神经网络与模型训练过程详解
TensorFlow深度学习实战（2）——使用TensorFlow构建神经网络
TensorFlow深度学习实战（3）——深度学习中常用激活函数详解
TensorFlow深度学习实战（4）——正则化技术详解
TensorFlow深度学习实战（5）——神经网络性能优化技术详解
TensorFlow深度学习实战（6）——回归分析详解
TensorFlow深度学习实战（7）——分类任务详解
TensorFlow深度学习实战（8）——卷积神经网络
TensorFlow深度学习实战（9）——构建VGG模型实现图像分类
TensorFlow深度学习实战（10）——迁移学习详解
TensorFlow深度学习实战（11）——风格迁移详解
TensorFlow深度学习实战（12）——词嵌入技术详解
TensorFlow深度学习实战（13）——神经嵌入详解
TensorFlow深度学习实战（14）——循环神经网络详解
TensorFlow深度学习实战（15）——编码器-解码器架构
TensorFlow深度学习实战（16）——注意力机制详解
TensorFlow深度学习实战（17）——主成分分析详解
TensorFlow深度学习实战（18）——K-means 聚类详解
TensorFlow深度学习实战（19）——受限玻尔兹曼机
TensorFlow深度学习实战（20）——自组织映射详解
TensorFlow深度学习实战（21）——Transformer架构详解与实现
TensorFlow深度学习实战（22）——从零开始实现Transformer机器翻译
TensorFlow深度学习实战（23）——自编码器详解与实现
TensorFlow深度学习实战（24）——卷积自编码器详解与实现
TensorFlow深度学习实战（25）——变分自编码器详解与实现
TensorFlow深度学习实战（26）——生成对抗网络详解与实现
TensorFlow深度学习实战（27）——CycleGAN详解与实现
TensorFlow深度学习实战（28）——扩散模型（Diffusion Model）
TensorFlow深度学习实战（29）——自监督学习（Self-Supervised Learning）
TensorFlow深度学习实战（30）——强化学习（Reinforcement learning，RL）
TensorFlow深度学习实战（31）——强化学习仿真库Gymnasium
TensorFlow深度学习实战（32）——深度Q网络（Deep Q-Network，DQN）
TensorFlow深度学习实战（33）——深度确定性策略梯度
TensorFlow深度学习实战（34）——TensorFlow Probability
TensorFlow深度学习实战（35）——概率神经网络
TensorFlow深度学习实战（36）——自动机器学习（AutoML）
TensorFlow深度学习实战（37）——深度学习的数学原理
TensorFlow深度学习实战（38）——常用深度学习库
TensorFlow深度学习实战（39）——机器学习实践指南
TensorFlow深度学习实战（40）——图神经网络（GNN）