这TensorFlow Lite 转换器适用于多种不同的文件格式，包括SavedModel（首选）和凯拉斯 H5 格式。对于本练习，我们将使用SavedModel。

为此，只需指定保存模型的目录并调用tf.saved_model.save，将模型和目录传递给它：

export_dir = 'saved_model/1'
tf.saved_model.save(model, export_dir)

模型将被保存为资产和变量以及saved_model.pb文件，如图 12-2所示。

图 12-2。SavedModel结构

 保存模型后，您可以使用 TensorFlow Lite 转换器对其进行转换。

步骤 2. 转换并保存模型

这TensorFlow Lite 转换器在tf.lite包中。您可以通过首先调用它来调用它来转换保存的模型 from_saved_model方法，将包含已保存模型的目录传递给它，然后调用它的convert方法：

# Convert the model.
converter = tf.lite.TFLiteConverter.from_saved_model(export_dir)
tflite_model = converter.convert()

import pathlib
tflite_model_file = pathlib.Path('model.tflite')
tflite_model_file.write_bytes(tflite_model)

这下一步是将模型加载到解释器中，将用于输入数据的张量分配给模型进行预测，然后读取模型输出的预测。从程序员的角度来看，这就是使用 TensorFlow Lite 与使用 TensorFlow 有很大不同的地方。使用 TensorFlow，您可以直接说出并获得结果，但由于 TensorFlow Lite 没有 TensorFlow 所具有的许多依赖项，尤其是在非 Python 环境中，您现在必须获得更底层的信息并处理输入并输出张量，格式化您的数据以适合它们并以对您的设备有意义的方式解析输出。model.predict(something)

首先，加载模型并分配张量：

interpreter = tf.lite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()

然后您可以从模型中获取输入和输出的详细信息，这样您就可以开始了解它期望的数据格式，以及它将返回给您的数据格式：

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
print(input_details)
print(output_details)

你会得到很多输出！

首先，让我们检查输入参数。请注意shape设置，它是 type 的数组[1,1]。还要注意类，它是numpy.float32. 这些设置将决定输入数据的形状及其格式：

[{'name': 'dense_input', 'index': 0, 'shape': array([1, 1], dtype=int32), 
  'shape_signature': array([1, 1], dtype=int32), 'dtype': <class 
  'numpy.float32'>, 'quantization': (0.0, 0), 'quantization_parameters': 
  {'scales': array([], dtype=float32), 'zero_points': array([], dtype=int32), 
  'quantized_dimension': 0}, 'sparsity_parameters': {}}]

所以，为了格式化输入数据，如果你想预测yfor ，你需要使用这样的代码来定义输入数组的形状和类型x=10.0：

to_predict = np.array([[10.0]], dtype=np.float32)
print(to_predict)

周围的双括号10.0可能会引起一些混淆——我在array[1,1]这里使用的助记符是说有一个列表，给我们第一组[]，而该列表只包含一个值，即[10.0]，因此给出[[10.0]]。dtype=int32形状定义为，而您使用的是 ，这也可能令人困惑numpy.float32。参数是定义形状的dtype数据类型，而不是封装在该形状中的列表的内容。为此，您将使用该类。

输出细节非常相似，这里要注意的是形状。因为它也是 type 的数组[1,1]，所以您可以预期答案[[y]]与输入的方式大致相同[[x]]：

步骤 4. 执行预测

至让解释器进行预测，将输入张量设置为要预测的值，告诉它要使用的输入值：

interpreter.set_tensor(input_details[0]['index'], to_predict)
interpreter.invoke()

输入张量使用输入详细信息数组的索引指定。在这种情况下，您有一个非常简单的模型，它只有一个输入选项，所以它是input_details[0]，您将在索引处解决它。输入详细信息项 0 只有一个索引，索引为 0，并且它需要一个[1,1]如前定义的形状。所以，你把to_predict价值放在那里。然后使用该invoke方法调用解释器。

然后，您可以通过调用get_tensor并提供您想要读取的张量的详细信息来读取预测：

tflite_results = interpreter.get_tensor(output_details[0]['index'])
print(tflite_results)

同样，只有一个输出张量，因此它将是output_details[0]，并且您指定索引以获取其下方的详细信息，它将具有输出值。

因此，例如，如果您运行此代码：

to_predict = np.array([[10.0]], dtype=np.float32)
print(to_predict)
interpreter.set_tensor(input_details[0]['index'], to_predict)
interpreter.invoke()
tflite_results = interpreter.get_tensor(output_details[0]['index'])
print(tflite_results)

你应该看到如下输出：

[[10.]]
[[18.975412]]

其中10是输入值，18.97是预测值，非常接近19，即X=10时2X-1。为什么不是19，请回头看第一章！

鉴于这是一个非常简单的例子，接下来让我们看一些更复杂的东西——在一个著名的图像分类模型上使用迁移学习，然后将其转换为 TensorFlow Lite。从那里我们也将能够更好地探索优化和量化模型的影响。

首先，得到所有数据：

import numpy as np
import matplotlib.pylab as plt

import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_datasets as tfds


def format_image(image, label):
    image = tf.image.resize(image, IMAGE_SIZE) / 255.0
    return  image, label


(raw_train, raw_validation, raw_test), metadata = tfds.load(
    'cats_vs_dogs',
    split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
    with_info=True,
    as_supervised=True,
)

num_examples = metadata.splits['train'].num_examples
num_classes = metadata.features['label'].num_classes
print(num_examples)
print(num_classes)

BATCH_SIZE = 32
train_batches = 
raw_train.shuffle(num_examples // 4)
.map(format_image).batch(BATCH_SIZE).prefetch(1)

validation_batches = raw_validation.map(format_image)
.batch(BATCH_SIZE).prefetch(1)
test_batches = raw_test.map(format_image).batch(1)

这将下载 Dogs vs. Cats 数据集并将其拆分为训练集、测试集和验证集。

接下来，你将使用mobilenet_v2来自 TensorFlow Hub 的模型创建一个名为feature_extractor：

module_selection = ("mobilenet_v2", 224, 1280) 
handle_base, pixels, FV_SIZE = module_selection

MODULE_HANDLE ="https://tfhub.dev/google/tf2-preview/{}/feature_vector/4"
.format(handle_base)

IMAGE_SIZE = (pixels, pixels)

feature_extractor = hub.KerasLayer(MODULE_HANDLE,
                                   input_shape=IMAGE_SIZE + (3,), 
                                   output_shape=[FV_SIZE],
                                   trainable=False)

现在您有了特征提取器，您可以将其作为神经网络的第一层，并添加一个输出层，其中的神经元数量与您的类数量（在本例中为两个）相同。然后你可以编译和训练它：

model = tf.keras.Sequential([
            feature_extractor,
            tf.keras.layers.Dense(num_classes, activation='softmax')
        ])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

hist = model.fit(train_batches,
                 epochs=5,
                 validation_data=validation_batches)

仅需五个时期的训练，这应该给出一个在训练集上具有 99% 准确率和在验证集上具有 98% 以上准确率的模型。现在您可以简单地保存模型：

CATS_VS_DOGS_SAVED_MODEL = "exp_saved_model"
tf.saved_model.save(model, CATS_VS_DOGS_SAVED_MODEL)

保存模型后，您可以对其进行转换。

步骤 2. 将模型转换为 TensorFlow Lite

作为以前，您现在可以使用保存的模型并将其转换为.tflite模型。您将其保存为converted_model.tflite：

converter = tf.lite.TFLiteConverter.from_saved_model(CATS_VS_DOGS_SAVED_MODEL)
tflite_model = converter.convert()
tflite_model_file = 'converted_model.tflite'

with open(tflite_model_file, "wb") as f:
    f.write(tflite_model)

一旦你有了这个文件，你就可以用它实例化一个解释器。完成后，您应该像以前一样获得输入和输出详细信息。分别将它们加载到名为input_index和output_index的变量中。这使代码更具可读性！

interpreter = tf.lite.Interpreter(model_path=tflite_model_file)
interpreter.allocate_tensors()

input_index = interpreter.get_input_details()[0]["index"]
output_index = interpreter.get_output_details()[0]["index"]

predictions = []

数据集在 中有很多测试图像test_batches，所以如果你想拍摄一百张图像并测试它们，你可以这样做（随意将 更改100为任何其他值）：

test_labels, test_imgs = [], []
for img, label in test_batches.take(100):
    interpreter.set_tensor(input_index, img)
    interpreter.invoke()
    predictions.append(interpreter.get_tensor(output_index))
    test_labels.append(label.numpy()[0])
    test_imgs.append(img)

早些时候，在读取图像时，它们被调用的映射函数重新格式化format_image为适合训练和推理的大小，因此您现在要做的就是将解释器的张量设置为图像的输入索引。调用解释器后，您可以在输出索引处获取张量。

如果您想查看预测对标签的效果如何，您可以运行如下代码：

score = 0
for item in range(0,99):
    prediction=np.argmax(predictions[item])
    label = test_labels[item]
    if prediction==label:
        score=score+1

print("Out of 100 predictions I got " + str(score) + " correct")

这应该会给您 99 分或 100 分正确预测。

您还可以使用以下代码根据测试数据可视化模型的输出：

for index in range(0,99):
    plt.figure(figsize=(6,3))
    plt.subplot(1,2,1)
    plot_image(index, predictions, test_labels, test_imgs)
    plt.show()

您可以在图 12-3中看到其中的一些结果。（请注意，本书的GitHub 存储库中提供了所有代码，因此如果您需要，请查看那里。）

图 12-3。推理结果

这只是简单的转换模型，没有添加任何针对移动设备的优化。在下一步中，您将探索如何针对移动设备优化此模型。

步骤 3. 优化模型

现在如果您已经了解了训练、转换和使用带有 TensorFlow Lite 解释器的模型的端到端过程，让我们看看如何开始优化和量化模型。

这第一种优化称为动态范围量化，是通过optimizations在执行转换之前设置转换器的属性来实现的。这是代码：

converter = tf.lite.>TFLiteConverter.from_saved_model(CATS_VS_DOGS_SAVED_MODEL)
converter.optimizations = [tf.lite.>Optimize.DEFAULT]

tflite_model = converter.convert()
tflite_model_file = >'converted_model.tflite'

>with open(tflite_model_file, >"wb") >as f:
    f.write(tflite_model)

 在撰写本文时，有几个可用的优化选项（稍后可能会添加更多）。这些包括：

OPTIMIZE_FOR_SIZE：执行使模型尽可能小的优化。

OPTIMIZE_FOR_LATENCY：执行优化以尽可能减少推理时间。

DEFAULT：在大小和延迟之间找到最佳平衡点。

在这种情况下，模型大小在这一步之前接近 9 MB，但之后只有 2.3 MB——减少了近 70%。各种实验表明，模型可以缩小 4 倍，加速 2-3 倍。但是，根据模型类型，准确性可能会有所下降，因此如果您像这样进行量化，最好彻底测试模型。在这种情况下，我发现模型的准确率从 99% 下降到 94% 左右。

你可以通过全整数量化或 float16 量化以利用特定硬件。全整数量化将模型中的权重从 32 位浮点数更改为 8 位整数，这（特别是对于较大的模型）会对模型大小和延迟产生巨大影响，而对准确性的影响相对较小。

converter = tf.lite.TFLiteConverter.from_saved_model(CATS_VS_DOGS_SAVED_MODEL)

converter.optimizations = [tf.lite.Optimize.DEFAULT]

def representative_data_gen():
    for input_value, _ in test_batches.take(100):
        yield [input_value]

converter.representative_dataset = representative_data_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]

tflite_model = converter.convert()
tflite_model_file = 'converted_model.tflite'

with open(tflite_model_file, "wb") as f:
    f.write(tflite_model)