【CV】第 6 章：使用迁移学习的视觉搜索

请注意，本节不需要训练，因为我们没有构建模型，而是使用已经构建的模型（即具有预训练权重的模型）来预测图像类别。

from tensorflow.keras.applications import VGG16
from keras.applications.vgg16 import preprocess_input
from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input
from tensorflow.keras.applications import InceptionV3
from keras.applications.inception_v3 import preprocess_input

from tensorflow.keras.applications.vgg16 import decode_predictions
from tensorflow.keras.applications.resnet50 import decode_predictions
from tensorflow.keras.applications.inception_v3 import decode_predictions

from keras.preprocessing import image 
import numpy as np 
import matplotlib.pyplot as plt 
import os 
from os import listdir

model = Modelx(weights='imagenet', include_top=True,input_shape=(img_height, img_width, 3)) 
Modelx = VGG16 or ResNet50 or InceptionV3

folder_path = '/home/.../visual_search/imagecnn/' 
images = os.listdir(folder_path) 
fig = plt.figure(figsize=(8,8))

for image1 in images:
    i+=1
    im = image.load_img(folder_path+image1, target_size=(224, 224))
    img_data = image.img_to_array(im) 
    img_data = np.expand_dims(img_data, axis=0)
    img_data = preprocess_input(img_data)
    resnet_feature = model_resnet.predict(img_data,verbose=0)
    label = decode_predictions(resnet_feature)
    label = label[0][0]
    fig.add_subplot(rows,columns,i)
    fig.subplots_adjust(hspace=.5)
    plt.imshow(im)
    stringprint ="%.1f" % round(label[2]*100,1)
    plt.title(label[1] + " " + str(stringprint) + "%")
    plt.show()

请注意，完整的代码可以在本书的 GitHub 链接中找到：Mastering-Computer-Vision-with-TensorFlow-2.0/Chapter6_CNN_PretrainedModel.ipynb at master · PacktPublishing/Mastering-Computer-Vision-with-TensorFlow-2.0 · GitHub

注意图像的数量只是一个例子；它在任何情况下都是独一无二的。需要注意的重要一点是，为了进行良好的检测，我们需要每类大约 1,000 张图像以及 90%:10% 的训练和验证拆分。

导入 TensorFlow 库

我们的下一步是导入 TensorFlow 库。以下代码导入 ResNet 模型权重和预处理输入，类似于我们在上一节中所做的。我们在第 5 章“神经网络架构和模型”中了解了这些概念：

from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input 
from tensorflow.keras.layers import Dense, Activation, Flatten, Dropout 
from tensorflow.keras.models import Sequential, Model 
from tensorflow.keras.optimizers import SGD, Adam 
img_width, img_height = 224, 224

该代码还导入了​​几个深度学习参数，例如Dense（全连接层）Activation、、、Flatten和Dropout。然后，我们导入 Sequential 模型 API 以创建逐层模型、随机梯度下降( SGD ) 和 Adam 优化器。图像高度和宽度适用224于 ResNet 和 VGG 以及299Inception 模型。

设置模型参数

对于我们的分析，我们设置模型参数，如以下代码块所示：

NUM_EPOCHS = 5
batchsize = 10
num_train_images = 900
num_val_images = 100

然后构建基本模型，类似于我们在上一节中的示例，除了我们不通过设置 include_top=False包含顶层模型：

base_model = ResNet50(weights='imagenet',include_top=False,input_shape=(img_height, img_width, 3))

在此代码中，我们使用基础模型仅使用卷积层生成特征向量。

构建输入数据管道

我们将导入一个图像数据生成器，该生成器使用旋转、水平翻转、垂直翻转和数据预处理等数据增强来生成张量图像。数据生成器将重复训练和验证数据。

训练数据生成器

让我们看一下训练数据生成器的以下代码：

from keras.preprocessing.image import ImageDataGenerator
train_dir = '/home/…/visual_search/furniture_images/train'
train_datagen =  ImageDataGenerator(preprocessing_function=preprocess_input,rotation_range=90,horizontal_flip=True,vertical_flip=True)

Flow for directory API——用于从目录导入数据。它具有以下参数：

• Directory：这是一个文件夹路径，应该设置为所有三个类的图像都存在的路径。在这种情况下，一个示例是train目录的路径。要获取路径，您可以将文件夹拖到终端，它会显示路径，然后您可以复制和粘贴。
• Target_size: 将其设置为模型拍摄的图像大小，例如 Inception 为 299 x 299，ResNet 和 VGG16 为 224 x 224。
• Color_mode：设置grayscale为黑白图像和RGB彩色图像。
• Batch_size：每批次的图像数量。
• class_mode：如果您只有两个类要预测，则设置为二进制；如果没有，请设置为categorical.
• shuffle：True如果要重新排序图像，请设置为；否则，设置为False。
• seed：用于应用随机图像增强和打乱图像顺序的随机种子。

下面的代码展示了如何编写最终的训练数据生成器，它将被导入到模型中：

train_generator = train_datagen.flow_from_directory(train_dir,target_size=(img_height, img_width), batch_size=batchsize)

验证数据生成器

接下来，我们将在以下代码中重复验证过程。该过程与训练生成器的过程相同，除了我们将验证图像目录而不是训练图像目录：

from keras.preprocessing.image import ImageDataGenerator
val_dir = '/home/…/visual_search/furniture_images/val'
val_datagen =  ImageDataGenerator(preprocessing_function=preprocess_input,rotation_range=90,horizontal_flip=True,vertical_flip=True)
val_generator = val_datagen.flow_from_directory(val_dir,target_size=(img_height, img_width),batch_size=batchsize)

前面的代码显示了最终的验证数据生成器。

使用迁移学习构建最终模型

我们首先定义一个名为 的函数build_final_model()，该函数接受基本模型和模型参数，例如 dropout、全连接层和类数。我们首先使用layer.trainable = False. 然后我们将基本模型输出特征向量展平以进行后续处理。接下来，我们添加一个全连接层和 dropout 到展平的特征向量，以使用 softmax 层预测新类：

def build_final_model(base_model, dropout, fc_layers, num_classes):
    for layer in base_model.layers:
        layer.trainable = False
        x = base_model.output
        x = Flatten()(x)
    for fc in fc_layers:
        # New FC layer, random init
        x = Dense(fc, activation='relu')(x)
        x = Dropout(dropout)(x)
        # New softmax layer
        predictions = Dense(num_classes, activation='softmax')(x)
        final_model = Model(inputs=base_model.input, outputs=predictions)
            return final_model
class_list = ["bed", "chair", "sofa"]
FC_LAYERS = [1024, 1024]
dropout = 0.3
 
final_model=build_final_model(base_model,dropout=dropout,fc_layers=FC_LAYERS,num_classes=len(class_list))

该模型是使用adam具有分类交叉熵损失的优化器编译的：

adam = Adam(lr=0.00001) 
final_model.compile(adam, loss='categorical_crossentropy', metrics=['accuracy'])

使用该model.fit_generator命令开发和运行最终模型。历史记录存储时期、每步时间、损失、准确度、验证损失和验证准确度：

history = final_model.fit(train_dir,epochs=NUM_EPOCHS,steps_per_epoch=num_train_images // batchsize,callbacks=[checkpoint_callback],validation_data=val_dir, validation_steps=num_val_images // batchsize)

model.fit()这里解释了的各种参数。Notemode.fit_generator将在未来被弃用，并将被model.fit()前面所示的函数取代：

• train_dir：这输入训练数据；其操作细节已在上一节中进行了说明。
• epochs: 一个整数，表示训练模型的 epoch 数。纪元从1增加到 的值epochs。
• steps_per_epoch: 这是一个整数。它显示了训练完成和下一个 epoch 开始训练之前的总步数（样本批次）。它的最大值等于（训练图像数/ batch_size）。因此，如果有 900 张训练图像并且批量大小为 10，则每个 epoch 的步数为 90。
• workers：较高的值可确保 CPU 创建足够的批次供 GPU 处理，并且 GPU 永远不会保持空闲状态。
• shuffle: 这是一个布尔类型。它表示在每个 epoch 开始时对批次进行重新排序。它仅与Sequence( keras.utils.Sequence) 一起使用。is not时steps_per_epoch无效None。
• Validation_data: 这是一个验证生成器。
• validation_steps：这是生成器中使用的步骤总数（样本批次），validation_data等于验证数据集中的样本数量除以批次大小。

保存带有检查点的模型

TensorFlow 模型可以运行很长时间，因为每个 epoch 需要几分钟才能完成。TensorFlow 有一个名为的命令Checkpoint，它使我们能够在每个 epoch 完成时保存中间模型。因此，如果您必须在中间中断模型，因为损失已经饱和或将您的 PC 用于其他目的，那么您不必从头开始 - 您可以使用迄今为止开发的模型进行分析。以下代码块显示了对前一个代码块的添加以执行检查点：

from tensorflow.keras.callbacks import ModelCheckpoint 
filecheckpath="modelfurn_weight.hdf5" 
checkpointer = ModelCheckpoint(filecheckpath, verbose=1, save_best_only=True) 
 
history = final_model.fit_generator(train_generator, epochs=NUM_EPOCHS, workers=0,steps_per_epoch=num_train_images // batchsize, shuffle=True, validation_data=val_generator,validation_steps=num_val_images // batchsize, callbacks = [checkpointer])

上述代码的输出如下：

89/90 [============================>.] - ETA: 2s - loss: 1.0830 - accuracy: 0.4011 Epoch 00001: val_loss improved from inf to 1.01586, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 257s 3s/step - loss: 1.0834 - accuracy: 0.4022 - val_loss: 1.0159 - val_accuracy: 0.4800
 Epoch 2/5 89/90 [============================>.] - ETA: 2s - loss: 1.0229 - accuracy: 0.5067 Epoch 00002: val_loss improved from 1.01586 to 0.87938, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 253s 3s/step - loss: 1.0220 - accuracy: 0.5067 - val_loss: 0.8794 - val_accuracy: 0.7300
 Epoch 3/5 89/90 [============================>.] - ETA: 2s - loss: 0.9404 - accuracy: 0.5719 Epoch 00003: val_loss improved from 0.87938 to 0.79207, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 256s 3s/step - loss: 0.9403 - accuracy: 0.5700 - val_loss: 0.7921 - val_accuracy: 0.7900
 Epoch 4/5 89/90 [============================>.] - ETA: 2s - loss: 0.8826 - accuracy: 0.6326 Epoch 00004: val_loss improved from 0.79207 to 0.69984, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 254s 3s/step - loss: 0.8824 - accuracy: 0.6322 - val_loss: 0.6998 - val_accuracy: 0.8300
 Epoch 5/5 89/90 [============================>.] - ETA: 2s - loss: 0.7865 - accuracy: 0.7090 Epoch 00005: val_loss improved from 0.69984 to 0.66693, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 250s 3s/step - loss: 0.7865 - accuracy: 0.7089 - val_loss: 0.6669 - val_accuracy: 0.7700

输出显示每个 epoch 的损失和准确性，并将相应的文件保存为hdf5文件。

绘制训练历史

matplotlib使用 Python函数显示了显示每个 epoch 的训练精度和训练损失的线图。我们将matplotlib首先导入，然后定义训练和验证损失和准确性的参数：

以下代码是使用 Keras 和 TensorFlow 绘制模型输出的标准代码。我们首先定义图形大小（8 x 8）并使用 subplot 函数显示(2,1,1)和(2,1,2)。然后我们定义标签、限制和标题：

plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1])
plt.title('Training and Validation Accuracy')
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([0,5.0])
plt.title('Training and Validation Loss')
plt.xlabel('epoch')
plt.show()

让我们看一下前面代码的输出。不同模型之间的精度比较如下图所示。它显示了 Inception 的训练参数：

在前面的屏幕截图中，您可以观察到Inception 的准确率在五个 epoch 内达到了大约 90%。接下来，我们绘制 VGG16 的训练参数：

上图显示 VGG16 的准确率在五个 epoch 内达到了 80% 左右。接下来，我们绘制 ResNet 的训练参数：

前面的屏幕截图显示，ResNet 的准确率在四个 epoch 内达到了 80% 左右。

对于所有三个模型，准确率在四个 epoch 中始终达到至少80%。Inception 模型的结果具有最高的准确性。

了解视觉搜索的架构和应用

视觉搜索使用深度神经网络技术对图像及其内容进行检测和分类，并使用它在图像数据库中进行搜索以返回匹配结果列表。视觉搜索与零售行业特别相关，因为它允许零售商显示大量与客户上传的图像相似的图像以增加销售收入。视觉搜索可以与语音搜索相结合以进一步增强搜索。视觉信息比文本信息更相关，这导致视觉搜索更受欢迎。许多不同的公司，包括谷歌、亚马逊、Pinterest、Wayfair、沃尔玛、必应、ASOS、Neiman Marcus、宜家、Argos 等都建立了强大的视觉搜索引擎来改善他们的客户体验。

视觉搜索的架构

ResNet、VGG16 和 Inception 等深度神经网络模型基本上可以分解为两个组件：

• 第一个组件识别图像的低级内容，例如特征向量（边缘）。
• 第二个分量表示图像的高级内容，例如最终的图像特征，它是各种低级内容的集合。下图说明了一个分类七类的卷积神经网络：

从上图可以看出，整个图像分类神经网络模型可以分为两层：卷积层和顶层。全连接层之前的最后一个卷积层是一个形状为 ( # of images, X, Y, # of channels ) 的特征向量，它被展平 ( # of images, X*Y*# of channels ) 以生成一个 n-维向量。

在视觉搜索中，我们通过使用欧几里得距离或余弦相似度等工具比较它们的特征向量的相似度来计算两幅图像的相似度。视觉搜索的架构如下所示：

此处列出了各个步骤：

1. 使用迁移学习来开发新模型，方法是将顶层从 ResNet、VGG16 或 Inception 等知名模型中分离出来，然后添加自定义顶层，包括全连接层、dropout、激活和 softmax 层。
2. 使用新数据集训练新模型。
3. 通过我们刚刚开发的新模型运行图像，上传图像并找到其特征向量和图像类。
4. 为了节省搜索时间，请仅在与上传图像对应的目录类中搜索。
5. 使用诸如欧几里得距离或余弦相似度之类的算法进行搜索。
6. 如果余弦相似度 > 0.999，则显示搜索结果；如果没有，请使用上传的图像重新训练模型或调整模型参数并重新运行该过程。
7. 为了进一步加快搜索速度，请使用生成的边界框检测上传图像和搜索图像数据库和目录中对象的位置。

上述流程图有几个关键组成部分：

• 模型开发：这包括选择一个合适的预训练模型，删除其顶部附近的层，冻结之前的所有层，并添加一个新的顶层以匹配我们的类。这意味着，如果我们使用在 1,000 个类的 ImageNet 数据集上训练的预训练模型，我们将移除它的顶层并用我们的新顶层替换它，只有 3 个类bed—— 、chair和sofa。
• 模型训练：这涉及首先编译模型，然后开始使用该model.fit()函数进行训练。
• 模型输出：上传的图片和测试图片库中的每张图片都经过模型生成特征向量。上传的图像也用于确定模型类。
• 搜索算法：搜索算法在给定类指定的测试图像文件夹中执行，而不是在整个测试图像集内执行，从而节省时间。搜索算法依赖于 CNN 模型选择的正确类别。如果类匹配不正确，那么最终的视觉搜索将导致不正确的结果。为了解决这个问题，可以采取几个步骤：

1. 使用新图像集重新运行模型，增加训练图像大小，或改进模型参数。

1. 然而，无论使用多少数据， CNN 模型永远不会有 100% 的准确率。因此，为了解决这个问题，视觉搜索结果通常由文本关键字搜索来补充。例如，客户可能会写道，您能找到一张与上传图片中显示的床相似的床吗？在这种情况下，我们知道上传的类是一张床。这是使用自然语言处理( NLP ) 完成的。
2. 解决该问题的另一种方法是针对多个预训练模型运行相同的上传图像，如果类预测彼此不同，则采用模式值。

接下来，我们将详细解释用于视觉搜索的代码。

视觉搜索代码及解释

在本节中，我们将解释用于视觉搜索的 TensorFlow 代码及其功能：

1.首先，我们将为上传的图像指定一个文件夹（共有三个文件夹，我们为每种图像类型切换）。请注意，此处显示的图像只是示例；您的图像可能不同：

#img_path = '/home/…/visual_search/ test/bed/bed1.jpg'
#img_path ='/home/…/visual_search/test/chair/chair1.jpg'
#img_path ='/home/…/visual_search/test/sofa/sofa1.jpg'

2.然后，我们将上传图像，将图像转换为数组，并像之前一样对图像进行预处理：

img = image.load_img(img_path, target_size=(224, 224)) 
img_data = image.img_to_array(img) 
img_data = np.expand_dims(img_data, axis=0) 
img_data = preprocess_input(img_data)

上述代码是在进一步处理之前将图像转换为数组的标准代码。

预测上传图片的类别

上传新图像后，我们的任务将是找出它属于哪个类。为此，我们计算图像可能属于的每个类别的概率，并选择概率最高的类别。此处的示例说明了使用 VGG 预训练模型的计算，但相同的概念适用于其他地方：

vgg_feature = final_model.predict(img_data,verbose=0)
vgg_feature_np = np.array(vgg_feature)
vgg_feature1D = vgg_feature_np.flatten()
print (vgg_feature1D)
y_prob = final_model.predict(img_data)
y_classes = y_prob.argmax(axis=-1)
print (y_classes)

model.predict()在前面的代码中，我们使用函数和类名来计算图像属于特定类的概率，probability.argmax用于指示概率最高的类。

预测所有图像的类别

以下函数导入必要的包以从目录中获取文件并进行相似度计算。然后，我们根据上传图像的输入类指定要定位的文件夹：

import os
from scipy.spatial import distance as dist
from sklearn.metrics.pairwise import cosine_similarity
if y_classes == [0]:
    path = 'furniture_images/val/bed'
elif y_classes == [1]:
    path = 'furniture_images/val/chair'
else:
    path = 'furniture_images/val/sofa'

以下函数循环遍历测试目录中的每个图像，并将图像转换为一个数组，然后使用该数组来使用训练好的模型预测特征向量：

mindist=10000
maxcosine =0
i=0
for filename in os.listdir(path):
    image_train = os.path.join(path, filename)
    i +=1
    imgtrain = image.load_img(image_train, target_size=(224, 224))
    img_data_train = image.img_to_array(imgtrain)
    img_data_train = np.expand_dims(img_data_train, axis=0)
    img_data_train = preprocess_input(img_data_train)
    vgg_feature_train = final_model.predict(img_data_train)
    vgg_feature_np_train = np.array(vgg_feature_train)
    vgg_feature_train1D = vgg_feature_np_train.flatten()
    eucldist = dist.euclidean(vgg_feature1D,vgg_feature_train1D)
    if mindist > eucldist:
        mindist=eucldist
        minfilename = filename
        #print (vgg16_feature_np)
    dot_product = np.dot(vgg_feature1D,vgg_feature_train1D)#normalize the results, to achieve     similarity measures independent #of the scale of the vectors
    norm_Y = np.linalg.norm(vgg_feature1D)
    norm_X = np.linalg.norm(vgg_feature_train1D)
    cosine_similarity = dot_product / (norm_X * norm_Y)
    if maxcosine < cosine_similarity:
        maxcosine=cosine_similarity
        cosfilename = filename
    print ("%s filename %f euclediandist %f cosine_similarity" %(filename,eucldist,cosine_similarity))
    print ("%s minfilename %f mineuclediandist %s cosfilename %f maxcosinesimilarity" %(minfilename,mindist, cosfilename, maxcosine))

您可以在前面的代码中观察到以下内容：

• 每个特征向量与上传的图像特征向量进行比较，计算欧几里得距离和余弦相似度。
• 通过确定欧几里得距离的最小值和余弦相似度的最大值来计算图像相似度。
• 确定并显示与最小距离对应的图像文件。

包括迁移学习和视觉搜索在内的完整代码可以在本书的 GitHub存储库中找到，地址为： https ://github.com/PacktPublishing/Mastering-Computer-Vision-with-TensorFlow-2.0/blob/master/Chapter06/ Chapter6_Transferlearning_VisualSearch.ipynb。

下图展示了使用三种不同的模型和两种不同的搜索算法——欧几里得距离和余弦相似度对上传的一张床的图像进行视觉搜索预测：

在上图中，可以观察到以下内容：

• Inception 模型预测了一个不准确的类别，这导致视觉搜索模型预测了错误的类别。
• 请注意，视觉搜索模型无法捕捉到预测错误类别的神经网络。我们还可以使用其他模型检查相同上传图像的类别预测，以查看模式（多数）值——在这种情况下，它是bedResNet 和 VGG 预测bed的，而 Inception 预测sofa的。
• 总而言之，由于我们不知道给定模型是否能正确预测类别，我们推荐的方法是同时使用三个或更多不同的模型来预测上传图像的类别，然后选择具有多数值的预测类别。使用这种方法，我们将增加对预测的信心。

下图显示了使用不同上传图像的预测，这似乎是正确的：

下图显示了使用三种不同的模型和两种不同的搜索算法——欧几里得距离和余弦相似度对上传的椅子图像进行视觉搜索预测：

您可以在上图中观察到以下内容：

• 尽管余弦相似度函数显示的图像与欧几里得距离函数显示的图像不同，但预测在所有情况下都是正确的。
• 两者似乎都非常接近，两种显示方法为我们提供了一种显示多个图像的方法。这意味着如果用户上传一张椅子的图片并想在在线目录中找到类似的椅子，我们的系统将显示两张图片供用户选择，而不是一张图片，这将增加我们销售的机会椅子。如果两幅图像相同，算法将只显示一幅图像，否则将显示两幅图像。另一种选择是使用相同的算法显示前两个匹配项。

下图显示了使用三种不同模型和两种不同搜索算法（欧几里得距离和余弦相似度）对上传的沙发图像进行视觉搜索预测：

您可以在上图中观察到以下内容：

• 尽管余弦相似度函数显示的图像与欧几里得距离函数显示的图像不同，但预测在所有情况下都是正确的。
• 两者似乎都非常接近，两种显示方法为我们提供了一种显示多张图像的方法。如前所述，使用与上传图像相似的两个图像，用户有更多选项可供选择。

使用 tf.data 处理视觉搜索输入管道

TensorFlow tf.dataAPI 是一种高效的数据管道，它处理数据的速度比 Keras 数据输入过程快一个数量级。它在分布式文件系统中聚合数据并对其进行批处理。有关详细信息，请参阅：https ://www.tensorflow.org/guide/data 。

以下屏幕截图显示了tf.data与 Keras 图像输入过程的图像上传时间比较：

请注意，1000 张图像大约需要 1.58 秒，这比 Keras 图像输入过程快了大约 90 倍。

以下是一些常见的功能tf.data：

• 要使此 API 正常工作，您需要导入该pathlib库。
• tf.data.Dataset.list_files用于创建与模式匹配的所有文件的数据集。
• tf.strings.splot根据分隔符拆分文件路径。
• tf.image.decode_jpeg将 JPEG 图像解码为张量（注意转换不能有文件路径）。
• tf.image.convert_image_dtype将图像转换为 dtype float 32。

以下链接提供了更新的视觉搜索代码：

Mastering-Computer-Vision-with-TensorFlow-2.0/Chapter6_Transferlearning_VisualSearch_tfdata_tensor.ipynb at master · PacktPublishing/Mastering-Computer-Vision-with-TensorFlow-2.0 · GitHub

tf.data如前所述，此代码包括。此外tf.data，它还通过在 中进行以下更改来解冻模型的顶部build_final_model：

layer.trainable = True 
layer_adjust = 100 
for layer in base_model.layers[:layer_adjust]: 
    layer.trainable = False

前面的更改使模型能够在第 100 层之后开始训练，而不是只训练最后几层。此更改提高了准确性，如下图所示：

训练需要更多时间，但模型准确率接近 100%，而不是大约 90%。

概括

在本章中，我们学习了如何使用 TensorFlow/Keras 为上一章学习的深度学习模型开发迁移学习代码。我们学习了如何从包含多个类的目录中导入经过训练的图像，并使用它们来训练模型并使用它们进行预测。然后，我们学习了如何保持模型的基础层冻结，移除顶层，并用我们自己的顶层替换它，并用它训练生成的模型。

我们研究了视觉搜索的重要性以及如何使用迁移学习来增强视觉搜索方法。我们的示例包含三种不同类别的家具——我们了解模型的准确性以及如何改善由此产生的损失。在本章中，我们还学习了如何使用 TensorFlowtf.data输入管道在训练期间进行更快的图像处理。