callbacks回调函数(Checkpoint、TensorBoard)、tf.data、ImageDataGenerator

本是古典何须时尚 2023-07-17 06:45 6阅读 0赞

# ![20191009191333910.png][][日萌社][Link 1] #

[人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）][AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]

--------------------

# 4.6 TF常用功能模块 #

## 4.6.1 fit的callbacks详解 ##

回调是在训练过程的给定阶段应用的一组函数。可以使用回调来获取培训期间内部状态和模型统计信息的视图。您可以将回调列表（作为关键字参数`callbacks`）传递给或类的`fit()`方法。然后将在训练的每个阶段调用回调的相关方法。

*  定制化保存模型
 *  保存events文件

### 4.6.1.1 ModelCheckpoint ###

from tensorflow.python.keras.callbacks import ModelCheckpoint

*  keras.callbacks.ModelCheckpoint(filepath, monitor='val\_loss', save\_best\_only=False, save\_weights\_only=False, mode='auto', period=1)
    
     *  Save the model after every epoch：每隔多少次迭代保存模型
     *  filepath: 保存模型字符串
        
         *  如果设置 weights.\{epoch:02d\}-\{val\_loss:.2f\}.hdf5格式，将会每隔epoch number数量并且将验证集的损失保存在该位置
         *  如果设置weights.\{epoch:02d\}-\{val\_acc:.2f\}.hdf5，将会按照val\_acc的值进行保存模型
     *  monitor: quantity to monitor.设置为'val\_acc'或者'val\_loss'
     *  save\_best\_only: if save\_best\_only=True, 只保留比上次模型更好的结果
     *  save\_weights\_only: if True, 只保存去那种(model.save\_weights(filepath)), else the full model is saved (model.save(filepath)).
     *  mode: one of \{auto, min, max\}. 如果save\_best\_only=True, 对于val\_acc, 要设置max, 对于val\_loss要设置min
     *  period: 迭代保存checkpoints的间隔

check = ModelCheckpoint('./ckpt/singlenn_{epoch:02d}-{val_acc:.2f}.h5',
                                    monitor='val_acc',
                                    save_best_only=True,
                                    save_weights_only=True,
                                    mode='auto',
                                    period=1)
    
    SingleNN.model.fit(self.train, self.train_label, epochs=5, callbacks=[check], validation_data=(x, y))

注意：使用ModelCheckpoint一定要在fit当中指定验证集才能使用，否则报错误。

--------------------

metrics 是 sparse_categorical_crossentropy，则ModelCheckpoint中的第一个路劲字符串信息中和monitor参数中都需要用val_sparse_categorical_crossentropy
    metrics 是 acc，则ModelCheckpoint中的第一个路劲字符串信息中和monitor参数中都需要用val_acc
    metrics 是 accuracy，则ModelCheckpoint中的第一个路劲字符串信息中和monitor参数中都需要用val_accuracy

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1][]

--------------------

### 4.6.1.2 Tensorboard ###

*  添加Tensorboard观察损失等情况
 *  keras.callbacks.TensorBoard(log\_dir='./logs', histogram\_freq=0, batch\_size=32, write\_graph=True, write\_grads=False, write\_images=False, embeddings\_freq=0, embeddings\_layer\_names=None, embeddings\_metadata=None, embeddings\_data=None, update\_freq='epoch')
    
     *  log\_dir:保存事件文件目录
     *  write\_graph=True：是否显示图结构
     *  write\_images=False：是否显示图片
     *  write\_grads=True:是否显示梯度`histogram_freq` 必须大于0

# 添加tensoboard观察
     tensorboard = keras.callbacks.TensorBoard(log_dir='./graph', histogram_freq=1,
                                                      write_graph=True, write_images=True)
    
    SingleNN.model.fit(self.train, self.train_label, epochs=5, callbacks=[tensorboard])

*  打开终端查看：

# 指定存在文件的目录，打开下面命令
    tensorboard --logdir="./"

### 4.6.2 tf.data ：数据集的构建与预处理 ###

*  问题引入：

在大部分时候，我们希望使用自己的数据集来训练模型。然而，面对一堆格式不一的原始数据文件，将其预处理并读入程序的过程往往十分繁琐，甚至比模型的设计还要耗费精力。比如，为了读入一批图像文件，我们可能需要纠结于 python 的各种图像处理包（比如 pillow ），自己设计 Batch 的生成方式，最后还可能在运行的效率上不尽如人意。为此，TensorFlow 提供了 tf.data 这一模块，包括了一套灵活的数据集构建 API，能够帮助我们快速、高效地构建数据输入的流水线，尤其适用于数据量巨大的场景。

4.6.2.1 数据集对象的建立

*  tf.data 的核心是 tf.data.Dataset 类，提供了对数据集的高层封装。
    
     *  **tf.data.Dataset 由一系列的可迭代访问的元素（element）组成，每个元素包含一个或多个张量。**比如说，对于一个由图像组成的数据集，每个元素可以是一个形状为 长×宽×通道数 的图片张量，也可以是由图片张量和图片标签张量组成的元组（Tuple）。

1、tf.data.Dataset.from\_tensor\_slices()

最基础的建立 tf.data.Dataset 的方法是使用 tf.data.Dataset.from\_tensor\_slices() ，适用于数据量较小（能够整个装进内存）的情况。

import tensorflow as tf
    import numpy as np
    
    X = tf.constant([2015, 2016, 2017, 2018, 2019])
    Y = tf.constant([12000, 14000, 15000, 16500, 17500])
    
    # 也可以使用NumPy数组，效果相同
    # X = np.array([2015, 2016, 2017, 2018, 2019])
    # Y = np.array([12000, 14000, 15000, 16500, 17500])
    
    dataset = tf.data.Dataset.from_tensor_slices((X, Y))
    
    for x, y in dataset:
        print(x.numpy(), y.numpy())

输出

2013 12000
    2014 14000
    2015 15000
    2016 16500
    2017 17500

同样类似地，我们可以载入前章的 MNIST 数据集：

import matplotlib.pyplot as plt 
    
    (train_data, train_label), (_, _) = tf.keras.datasets.mnist.load_data()
    # [60000, 28, 28, 1]
    train_data = np.expand_dims(train_data.astype(np.float32) / 255.0, axis=-1)
    mnist_dataset = tf.data.Dataset.from_tensor_slices((train_data, train_label))
    
    for image, label in mnist_dataset:
        print(label.numpy())
        print(image.numpy())

4.6.2.2 数据集对象的预处理

tf.data.Dataset 类为我们提供了多种数据集预处理方法。最常用的如：

*  1、Dataset.map(f) ：
 *  对数据集中的每个元素应用函数 f ，得到一个新的数据集（这部分往往结合 tf.io 进行读写和解码文件， tf.image 进行图像处理）；
 *  2、Dataset.shuffle(buffer\_size) ：
 *  将数据集打乱（设定一个固定大小的缓冲区（Buffer），取出前 buffer\_size 个元素放入，并从缓冲区中随机采样，采样后的数据用后续数据替换）；
 *  3、Dataset.batch(batch\_size) ：
 *  将数据集分成批次，即对每 batch\_size 个元素，使用 tf.stack() 在第 0 维合并，成为一个元素。
 *  4、Dataset.prefetch() ：
    
     *  预取出数据集中的若干个元素
 *  5、除此以外，还有 Dataset.repeat() （重复数据集的元素）、 Dataset.reduce() （与 Map 相对的聚合操作）、 Dataset.take ()等，可参考 API 文档 进一步了解。

4.6.4.3 使用案例

1、使用 Dataset.map() 将所有图片旋转 90 度：

def rot90(image, label):
        image = tf.image.rot90(image)
        return image, label
    
    mnist_dataset = mnist_dataset.map(rot90)
    
    for image, label in mnist_dataset:
        plt.title(label.numpy())
        plt.imshow(image.numpy()[:, :, 0])
        plt.show()

2、使用 Dataset.batch() 将数据集划分批次，每个批次的大小为 4：

# 获取批次数据
    mnist_dataset = mnist_dataset.batch(4)
    
    for images, labels in mnist_dataset:
        fig, axs = plt.subplots(1, 4)
        for i in range(4):
            axs[i].set_title(labels.numpy()[i])
            axs[i].imshow(images.numpy()[i, :, :, 0])
        plt.show()

3、使用 Dataset.shuffle() 将数据打散后再设置批次，缓存大小设置为 10000

*  设定一个固定大小为 buffer\_size 的缓冲区（Buffer）；初始化时，取出数据集中的前 buffer\_size 个元素放入缓冲区；
 *  每次需要从数据集中取元素时，即从缓冲区中随机采样一个元素并取出，然后从后续的元素中取出一个放回到之前被取出的位置，以维持缓冲区的大小。

mnist_dataset = mnist_dataset.shuffle(buffer_size=10000).batch(4)
    
    for images, labels in mnist_dataset:
        fig, axs = plt.subplots(1, 4)
        for i in range(4):
            axs[i].set_title(labels.numpy()[i])
            axs[i].imshow(images.numpy()[i, :, :, 0])
        plt.show()

注：Dataset.shuffle() 时缓冲区大小 buffer\_size 的设置，每次的数据都会被随机打散。当 buffer\_size 设置为 1 时，其实等价于没有进行任何打散。

*  当数据集的标签顺序分布极为不均匀（例如二元分类时数据集前 N 个的标签为 0，后 N 个的标签为 1）时，较小的缓冲区大小会使得训练时取出的 Batch 数据很可能全为同一标签，从而影响训练效果。一般而言，数据集的顺序分布若较为随机，则缓冲区的大小可较小，否则则需要设置较大的缓冲区。

4.6.4.3 数据集元素的获取与使用

1、构建好数据并预处理后，我们需要从其中迭代获取数据以用于训练。tf.data.Dataset 是一个 Python 的可迭代对象，因此可以使用 For 循环迭代获取数据，即：

dataset = tf.data.Dataset.from_tensor_slices((A, B, C, ...))
    for a, b, c, ... in dataset:
        # 对张量a, b, c等进行操作，例如送入模型进行训练

2、可以使用 iter() 显式创建一个 Python 迭代器并使用 next() 获取下一个元素，即：

dataset = tf.data.Dataset.from_tensor_slices((A, B, C, ...))
    it = iter(dataset)
    a_0, b_0, c_0, ... = next(it)
    a_1, b_1, c_1, ... = next(it)

3、Keras 支持使用 tf.data.Dataset 直接作为输入。当调用 tf.keras.Model 的 fit() 和 evaluate() 方法时，可以将参数中的输入数据 x 指定为一个元素格式为 (输入数据, 标签数据) 的 Dataset ，并忽略掉参数中的标签数据 y 。例如，对于上述的 MNIST 数据集，常规的 Keras 训练方式是：

model.fit(x=train_data, y=train_label, epochs=num_epochs, batch_size=batch_size)

使用 tf.data.Dataset 后，我们可以直接传入 Dataset ：

model.fit(mnist_dataset, epochs=num_epochs)

**如果已经通过 Dataset.batch() 方法划分了数据集的批次，所以这里fit中也无需提供批次的大小。**

4.6.4.4 使用tf.data的并行化策略提高训练流程效率

当训练模型时，我们希望充分利用计算资源，减少 CPU/GPU 的空载时间。然而有时，数据集的准备处理非常耗时，使得我们在每进行一次训练前都需要花费大量的时间准备待训练的数据，而此时 GPU 只能空载而等待数据，造成了计算资源的浪费。

tf.data 的数据集对象为我们提供了 Dataset.prefetch() 方法，使得我们可以让数据集对象 Dataset 在训练时预取出若干个元素，使得在 GPU 训练的同时 CPU 可以准备数据，从而提升训练流程的效率

![2020032011501129.png][]

使用：

mnist_dataset = mnist_dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)

*  参数 buffer\_size 既可手工设置，也可设置为 tf.data.experimental.AUTOTUNE 从而由 TensorFlow 自动选择合适的数值。
 *  2、还有一种方式也能够提高利用CPU资源
    
     *  Dataset.map() 也可以利用多 GPU 资源，并行化地对数据项进行变换，从而提高效率。

通过设置 Dataset.map() 的 num\_parallel\_calls 参数实现数据转换的并行化。上面的是未并行化的图示，下面是两核并行的图示，时间会缩小

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2][]

# 添加参数使用，num_parallel_calls 设置为 tf.data.experimental.AUTOTUNE 以让 TensorFlow 自动选择合适的数值
    train_dataset = train_dataset.map(
            map_func=_decode_and_resize, 
            num_parallel_calls=tf.data.experimental.AUTOTUNE)

通过 prefetch() 的使用和在 map() 过程中加入 num\_parallel\_calls 参数，模型训练的时间可缩减至原来的一半甚至更低。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 3][]

### 4.6.5 案例：实现猫狗图像分类 ###

数据集来自 kaggle 上的一个竞赛：[Dogs vs. Cats][]，训练集有25000张，猫狗各占一半。测试集12500张，没有标定是猫还是狗。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 4][]

*  目的：猫狗图片二分类任务为示例
    
     *  使用 tf.data 结合 tf.io 和 tf.image 建立Dataset 数据集
     *  数据集可取这里下载：[https://www.floydhub.com/fastai/datasets/cats-vs-dogs][https_www.floydhub.com_fastai_datasets_cats-vs-dogs]
 *  步骤：
    
     *  1、数据集的获取和构建
     *  2、模型构建和封装
     *  3、训练以及测试过程实现

1、数据集的获取和构建

class CatOrDog(object):
        """猫狗分类
        """
        num_epochs = 1
        batch_size = 32
        learning_rate = 0.001
            # 训练目录
        train_cats_dir = '/root/cv_project/tf_example/cats_vs_dogs/train/cats/'
        train_dogs_dir = '/root/cv_project/tf_example/cats_vs_dogs/train/dogs/'
        # 验证目录
        test_cats_dir = '/root/cv_project/tf_example/cats_vs_dogs/valid/cats/'
        test_dogs_dir = '/root/cv_project/tf_example/cats_vs_dogs/valid/dogs/'
    
        def __init__(self):
            # 1、读取训练集的猫狗文件
            self.train_cat_filenames = tf.constant([CatOrDog.train_cats_dir + filename
                                                    for filename in os.listdir(CatOrDog.train_cats_dir)])
            self.train_dog_filenames = tf.constant([CatOrDog.train_dogs_dir + filename
                                                    for filename in os.listdir(CatOrDog.train_dogs_dir)])
            # 2、猫狗文件列表合并，并且初始化猫狗的目标值，0为猫，1为狗
            self.train_filenames = tf.concat([self.train_cat_filenames, self.train_dog_filenames], axis=-1)
            self.train_labels = tf.concat([
                tf.zeros(self.train_cat_filenames.shape, dtype=tf.int32),
                tf.ones(self.train_dog_filenames.shape, dtype=tf.int32)],
                axis=-1)

定义数据的获取方法，通过tf.data指定

def get_batch(self):
            """获取dataset批次数据
            :return:
            """
            train_dataset = tf.data.Dataset.from_tensor_slices((self.train_filenames, self.train_labels))
            # 进行数据的map, 随机，批次和预存储
            train_dataset = train_dataset.map(
                map_func=_decode_and_resize,
                num_parallel_calls=tf.data.experimental.AUTOTUNE)
            train_dataset = train_dataset.shuffle(buffer_size=20000)
            train_dataset = train_dataset.batch(CatOrDog.batch_size)
            train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)
            return train_dataset
    
    # 图片处理函数，读取，解码并且进行输入形状修改
    def _decode_and_resize(filename, label):
        image_string = tf.io.read_file(filename)
        image_decoded = tf.image.decode_jpeg(image_string)
        image_resized = tf.image.resize(image_decoded, [256, 256]) / 255.0
        return image_resized, label

2、模型构建和封装

通过构造两层卷积+两个全连接层的网络

self.model = tf.keras.Sequential([
                tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(256, 256, 3)),
                tf.keras.layers.MaxPooling2D(),
                tf.keras.layers.Conv2D(32, 5, activation='relu'),
                tf.keras.layers.MaxPooling2D(),
                tf.keras.layers.Flatten(),
                tf.keras.layers.Dense(64, activation='relu'),
                tf.keras.layers.Dense(2, activation='softmax')
            ])

3、训练以及测试过程实现

模型训练过程,这里就免去指定ckpt以及tensorboard的callbacks了，可以自己去指定实验

def train(self, train_dataset):
            """训练过程
            :return:
            """
            self.model.compile(
                optimizer=tf.keras.optimizers.Adam(learning_rate=CatOrDog.learning_rate),
                loss=tf.keras.losses.sparse_categorical_crossentropy,
                metrics=[tf.keras.metrics.sparse_categorical_accuracy]
            )
    
            self.model.fit(train_dataset, epochs=CatOrDog.num_epochs)
            self.model.save_weights("./ckpt/cat_or_dogs.h5")

测试过程

*  1、需要提供一个读取测试数据及的dataset数据集
 *  2、进行model的预测，可以先进行模型保存之后，再次读取进行预测

def test(self):
    
            # 1、构建测试数据集
            test_cat_filenames = tf.constant([CatOrDog.test_cats_dir + filename
                                              for filename in os.listdir(CatOrDog.test_cats_dir)])
            test_dog_filenames = tf.constant([CatOrDog.test_dogs_dir + filename
                                              for filename in os.listdir(CatOrDog.test_dogs_dir)])
            test_filenames = tf.concat([test_cat_filenames, test_dog_filenames], axis=-1)
            test_labels = tf.concat([
                tf.zeros(test_cat_filenames.shape, dtype=tf.int32),
                tf.ones(test_dog_filenames.shape, dtype=tf.int32)],
                axis=-1)
                    # 2、构建dataset
            test_dataset = tf.data.Dataset.from_tensor_slices((test_filenames, test_labels))
            test_dataset = test_dataset.map(_decode_and_resize)
            test_dataset = test_dataset.batch(batch_size)
    
            # 3、加载模型进行评估
            if os.path.exists("./ckpt/cat_or_dogs.h5"):
                self.model.load_weights("./ckpt/cat_or_dogs.h5")
    
            print(self.model.metrics_names)
            print(self.model.evaluate(test_dataset))

### 4.6.6 ImageDataGenerator介绍 ###

当存在大量本地图片的时候，我们需要通过实时数据增强生成张量图像数据批次。数据将不断循环（按批次）。下面就介绍一个强大的工具

1、训练的时候读取本地图片以及类别

tf.keras.preprocessing.image.ImageDataGenerator(featurewise_center=False,  
                                                 samplewise_center=False, 
                                                 featurewise_std_normalization=False, 
                                                 samplewise_std_normalization=False, 
                                                 zca_whitening=False, 
                                                 zca_epsilon=1e-06, 
                                                 rotation_range=0, 
                                                 width_shift_range=0.0, 
                                                 height_shift_range=0.0, 
                                                 brightness_range=None, 
                                                 shear_range=0.0, 
                                                 zoom_range=0.0, 
                                                 channel_shift_range=0.0, 
                                                 fill_mode='nearest', 
                                                 cval=0.0, 
                                                 horizontal_flip=False, 
                                                 vertical_flip=False, 
                                                 rescale=None, 
                                                 preprocessing_function=None, 
                                                 data_format=None, 
                                                 validation_split=0.0, 
                                                 dtype=None)

*  完整参数介绍参考TensorFlow官网文档：[https://www.tensorflow.org/api\_docs/python/tf/keras/preprocessing/image/ImageDataGenerator\#view-aliases][https_www.tensorflow.org_api_docs_python_tf_keras_preprocessing_image_ImageDataGenerator_view-aliases]
 *  train\_generator = ImageDataGenerator()
    
     *  **生产图片的批次张量值并且提供数据增强功能**
     *  rescale=1.0 / 255,:标准化
     *  zca\_whitening=False: \# zca白化的作用是针对图片进行PCA降维操作，减少图片的冗余信息
     *  rotation\_range=20:默认0， 旋转角度，在这个角度范围随机生成一个值
     *  width\_shift\_range=0.2,:默认0，水平平移
     *  height\_shift\_range=0.2:默认0， 垂直平移
     *  shear\_range=0.2:\# 平移变换
     *  zoom\_range=0.2:
     *  horizontal\_flip=True:水平翻转

2、使用方法介绍

*  使用flow(x, y, batch\_size)

(x_train, y_train), (x_test, y_test) = cifar10.load_data()
    
    datagen = ImageDataGenerator(
            featurewise_center=True,
            featurewise_std_normalization=True,
            rotation_range=20,
            width_shift_range=0.2,
            height_shift_range=0.2,
            horizontal_flip=True)
    
    for e in range(epochs):
            print('Epoch', e)
            batches = 0
            for x_batch, y_batch in datagen.flow(x_train, y_train, batch_size=32):
                model.fit(x_batch, y_batch)

*  使用train\_generator.flow\_from\_directory(
    
     *  directory=path,\# 读取目录
     *  target\_size=(h,w),\# 目标形状
     *  batch\_size=size,\# 批数量大小
     *  class\_mode='binary', \# 目标值格式，One of "categorical", "binary", "sparse",
        
         *  "categorical" ：2D one-hot encoded labels
         *  "binary" will be 1D binary labels
     *  shuffle=True
     *  这个API固定了读取的目录格式，参考：
     *      data/
                train/
                    dogs/
                        dog001.jpg
                        dog002.jpg
                        ...
                    cats/
                        cat001.jpg
                        cat002.jpg
                        ...
                validation/
                    dogs/
                        dog001.jpg
                        dog002.jpg
                        ...
                    cats/
                        cat001.jpg
                        cat002.jpg
                        ...

### 4.6.7 案例：ImageDataGenerator与迁移学习结合（基于VGG） ###

4.6.7.1 案例效果

![20200320115121977.png][]

Epoch 1/2
     1/13 [=>............................] - ETA: 3:20 - loss: 1.6811 - acc: 0.1562
     2/13 [===>..........................] - ETA: 3:01 - loss: 1.5769 - acc: 0.2500
     3/13 [=====>........................] - ETA: 2:44 - loss: 1.4728 - acc: 0.3958
     4/13 [========>.....................] - ETA: 2:27 - loss: 1.3843 - acc: 0.4531
     5/13 [==========>...................] - ETA: 2:14 - loss: 1.3045 - acc: 0.4938
     6/13 [============>.................] - ETA: 1:58 - loss: 1.2557 - acc: 0.5156
     7/13 [===============>..............] - ETA: 1:33 - loss: 1.1790 - acc: 0.5759
     8/13 [=================>............] - ETA: 1:18 - loss: 1.1153 - acc: 0.6211
     9/13 [===================>..........] - ETA: 1:02 - loss: 1.0567 - acc: 0.6562
    10/13 [======================>.......] - ETA: 46s - loss: 1.0043 - acc: 0.6875 
    11/13 [========================>.....] - ETA: 31s - loss: 0.9580 - acc: 0.7159
    12/13 [==========================>...] - ETA: 15s - loss: 0.9146 - acc: 0.7344
    13/13 [==============================] - 249s 19s/step - loss: 0.8743 - acc: 0.7519 - val_loss: 0.3906 - val_acc: 0.9000
    Epoch 2/2
     1/13 [=>............................] - ETA: 2:56 - loss: 0.3862 - acc: 1.0000
     2/13 [===>..........................] - ETA: 2:44 - loss: 0.3019 - acc: 1.0000
     3/13 [=====>........................] - ETA: 2:35 - loss: 0.2613 - acc: 1.0000
     4/13 [========>.....................] - ETA: 2:01 - loss: 0.2419 - acc: 0.9844
     5/13 [==========>...................] - ETA: 1:49 - loss: 0.2644 - acc: 0.9688
     6/13 [============>.................] - ETA: 1:36 - loss: 0.2494 - acc: 0.9688
     7/13 [===============>..............] - ETA: 1:24 - loss: 0.2362 - acc: 0.9732
     8/13 [=================>............] - ETA: 1:10 - loss: 0.2234 - acc: 0.9766
     9/13 [===================>..........] - ETA: 58s - loss: 0.2154 - acc: 0.9757 
    10/13 [======================>.......] - ETA: 44s - loss: 0.2062 - acc: 0.9781
    11/13 [========================>.....] - ETA: 29s - loss: 0.2007 - acc: 0.9801
    12/13 [==========================>...] - ETA: 14s - loss: 0.1990 - acc: 0.9792
    
    
    13/13 [==============================] - 243s 19s/step - loss: 0.1923 - acc: 0.9809 - val_loss: 0.1929 - val_acc: 0.9300

4.6.7.2 数据集以及迁移需求

数据集是某场景下5个类别图片的识别

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 5][]

我们利用现有的VGG模型去进行微调

4.6.7.3 思路和步骤

*  读取本地的图片数据以及类别
    
     *  keras.preprocessing.image import ImageDataGenerator提供了读取转换功能
 *  模型的结构修改（添加我们自定的分类层）
 *  freeze掉原始VGG模型
 *  编译以及训练和保存模型方式
 *  输入数据进行预测

4.6.7.4 训练的时候读取本地图片以及类别

*  基于上面工具的读取代码

train_datagen = ImageDataGenerator(
                rescale=1./255,
                shear_range=0.2,
                zoom_range=0.2,
                horizontal_flip=True)
    
    test_datagen = ImageDataGenerator(rescale=1./255)
    
    train_generator = train_datagen.flow_from_directory(
                                                        'data/train',
                                                        target_size=(150, 150),
                                                        batch_size=32,
                                                        class_mode='binary')
    
    validation_generator = test_datagen.flow_from_directory(
                                                            'data/validation',
                                                            target_size=(150, 150),
                                                            batch_size=32,
                                                            class_mode='binary')
    # 使用fit_generator
    model.fit_generator(
    train_generator,
    steps_per_epoch=2000,
    epochs=50,
    validation_data=validation_generator,
    validation_steps=800)

代码：

首先导入包

import tensorflow as tf
    from tensorflow import keras
    from tensorflow.python.keras.preprocessing.image import ImageDataGenerator

我们定义一个迁移学习的类，然后进行相关属性设置和读取代码

class TransferModel(object):
    
        def __init__(self):
    
            self.model_size = (224, 224)
            self.train_dir = "./data/train/"
            self.test_dir = "./data/test/"
            self.batch_size = 32
    
            self.train_generator = ImageDataGenerator(rescale=1.0 / 255)
            self.test_generator = ImageDataGenerator(rescale=1.0 / 255)
    
        def read_img_to_generator(self):
            """
            读取本地固定格式数据
            :return:
            """
            train_gen = self.train_generator.flow_from_directory(directory=self.train_dir,
                                                                 target_size=self.model_size,
                                                                 batch_size=self.batch_size,
                                                                 class_mode='binary',
                                                                 shuffle=True)
            test_gen = self.test_generator.flow_from_directory(directory=self.test_dir,
                                                               target_size=self.model_size,
                                                               batch_size=self.batch_size,
                                                               class_mode='binary',
                                                               shuffle=True)
            return train_gen, test_gen

打印结果为

<keras_preprocessing.image.DirectoryIterator object at 0x12f52cf28>

4.6.7.5 VGG模型的修改添加全连接层-GlobalAveragePooling2D

*  notop模型：
    
     *  **是否包含最后的3个全连接层（whether to include the 3 fully-connected layers at the top of the network）。用来做fine-tuning专用，专门开源了这类模型。**

‘weights='imagenet'’，意思是VGG在imagenet比赛中预训练的权重，使用resnet训练

# 在__init__中添加
    self.base_model = VGG16(weights='imagenet', include_top=False)

base\_model会有相关属性，模型的输入结构：inputs，模型的输出结构，我们修改需要得到已有VGG的输入和自定义模型的输出构建成一个新的模型。

模型源码：

if include_top:
            # Classification block
            x = layers.Flatten(name='flatten')(x)
            x = layers.Dense(4096, activation='relu', name='fc1')(x)
            x = layers.Dense(4096, activation='relu', name='fc2')(x)
            x = layers.Dense(classes, activation='softmax', name='predictions')(x)
        else:
            if pooling == 'avg':
                x = layers.GlobalAveragePooling2D()(x)
            elif pooling == 'max':
                x = layers.GlobalMaxPooling2D()(x)

*  **一个GlobalAveragePooling2D + 两个全连接层**
    
     *  在图像分类任务中，模型经过最后CNN层后的尺寸为\[bath\_size, img\_width, img\_height, channels\]，通常的做法是：接一个flatten layer，将尺寸变为\[batch\_size, w *h *channels\]再至少接一个FC layer，这样做的最大问题是：**模型参数多，且容易过拟合。**
     *  **利用pooling layer来替代最后的FC layer**

解释如下：

from keras.layers import Dense, Input, Conv2D
    from keras.layers import MaxPooling2D, GlobalAveragePooling2D
    
    x = Input(shape=[8, 8, 2048])  
    # 假定最后一层CNN的层输出为(None, 8, 8, 2048)
    x = GlobalAveragePooling2D(name='avg_pool')(x)  # shape=(?, 2048)
    # 取每一个特征图的平均值作为输出，用以替代全连接层
    x = Dense(1000, activation='softmax', name='predictions')(x)  # shape=(?, 1000)
    # 1000为类别

*  5类图片识别模型修改

我们需要拿到基础VGG模型，并且VGG提供所有层参数训练好的模型和没有全连接层参数的模型notop模型

from tensorflow.python.keras import Model

def refine_vgg_model(self):
        """
            添加尾部全连接层
            :return:
            """
        # [<tf.Tensor 'block5_pool/MaxPool:0' shape=(?, ?, ?, 512) dtype=float32>]
        x = self.base_model.outputs[0]
    
        # 输出到全连接层，加上全局池化 [None, ?, ?, 512]---->[None, 1 * 512]
        x = keras.layers.GlobalAveragePooling2D()(x)
        x = keras.layers.Dense(1024, activation=tf.nn.relu)(x)
        y_predict = keras.layers.Dense(5, activation=tf.nn.softmax)(x)
    
        model = keras.Model(inputs=self.base_model.inputs, outputs=y_predict)
    
        return model

4.6.7.6 freeze VGG模型结构

目的：让VGG结构当中的权重参数不参与训练,只训练我们添加的最后两层全连接网络的权重参数

*  通过使用每一层的layer.trainable=False

def freeze_vgg_model(self):
            """
            freeze掉VGG的结构
            :return:
            """
            for layer in self.base_model.layers:
                layer.trainable = False

4.6.7.7 编译和训练

*  编译

同样还是进行编译， 在迁移学习中算法：学习率初始化较小的值，0.001,0.0001，因为已经在已训练好的模型基础之上更新，所以不需要太大学习率去学习

def compile(self, model):
    
            model.compile(optimizer=keras.optimizers.Adam(),
                          loss=keras.losses.sparse_categorical_crossentropy,
                          metrics=['accuracy'])

*  main函数

if __name__ == '__main__':
        tm = TransferModel()
    
        train_gen, test_gen = tm.read_img_to_generator()
        model = tm.refine_vgg_model()
    
        tm.freeze_vgg_model()
        tm.compile(model)
        tm.fit(model, train_gen, test_gen)

4.6.7.8 进行预测

预测的步骤就是读取图片以及处理到模型中预测，加载我们训练的模型

def predict(self, model):
    
            model.load_weights("./Transfer.h5")
    
            # 2、对图片进行加载和类型修改
            image = load_img("./data/test/dinosaurs/402.jpg", target_size=(224, 224))
    
            print(image)
            # 转换成numpy array数组
            image = img_to_array(image)
            print("图片的形状：", image.shape)
    
            # 形状从3维度修改成4维
            img = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
            print("改变形状结果:", img.shape)
    
            # 3、处理图像内容，归一化处理等，进行预测
            img = preprocess_input(img)
            print(img.shape)
            y_predict = model.predict(img)
    
            index = np.argmax(y_predict, axis=1)
    
            print(self.label_dict[str(index[0])])

建立图片类别的字典

self.label_dict = {
                '0': 'bus',
                '1': 'dinosaurs',
                '2': 'elephants',
                '3': 'flowers',
                '4': 'horse'
            }

### 4.6.6 总结 ###

*  Checkpoint使用
 *  TensorBoard使用
 *  tf.data模块使用
 *  ImageDataGenerator的使用

--------------------

keras\_tool.py

import tensorflow as tf
    import numpy as np
    import os
    os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
    
    
    def function_tool():
    
        (train_data, train_label), (_, _) = tf.keras.datasets.mnist.load_data()
        # [60000, 28, 28, 1]
        train_data = np.expand_dims(train_data.astype(np.float32) / 255.0, axis=-1)
        mnist_dataset = tf.data.Dataset.from_tensor_slices((train_data, train_label))
    
        # 1、翻转处理
        def rot90(image, label):
            image = tf.image.rot90(image)
            return image, label
    
        mnist_dataset = mnist_dataset.map(rot90)
        mnist_dataset = mnist_dataset.batch(4)
    
        for images, labels in mnist_dataset:
            print(labels.numpy())
            print(images)
    
    
    def _decode_and_resize(filename, label):
        """对于输入的datset中图片做解析
        :param filename: 图片完整路径
        :param label: 目标值
        :return:
        """
        image_string = tf.io.read_file(filename)
        image_decoded = tf.image.decode_jpeg(image_string)
        image_resized = tf.image.resize(image_decoded, [256, 256]) / 255.0
        return image_resized, label
    
    
    # 1、数据集的获取和构建
    # 2、模型构建和封装
    # 3、训练以及测试过程实现
    class CatOrDog(object):
        """猫狗分类案例，使用tf.data读取数据
        """
        num_epochs = 1
        batch_size = 32
        learning_rate = 0.001
        # 训练目录
        train_cats_dir = '/root/cv_project/tf_example/cats_vs_dogs/train/cats/'
        train_dogs_dir = '/root/cv_project/tf_example/cats_vs_dogs/train/dogs/'
        # 验证目录
        test_cats_dir = '/root/cv_project/tf_example/cats_vs_dogs/valid/cats/'
        test_dogs_dir = '/root/cv_project/tf_example/cats_vs_dogs/valid/dogs/'
    
        def __init__(self):
            # 1、数据集的获取和构建
            # 读取目录下的文件名称，把猫狗文件合并
            self.train_cat_filenames = tf.constant([CatOrDog.train_cats_dir + filename for
                                                    filename in os.listdir(CatOrDog.train_cats_dir)])
            self.train_dog_filenames = tf.constant([CatOrDog.train_dogs_dir + filename for
                                                    filename in os.listdir(CatOrDog.train_dogs_dir)])
    
            self.train_filenames = tf.concat([self.train_cat_filenames, self.train_dog_filenames], axis=-1)
            # 构造出猫0，狗1的目标值结果
            self.train_labels = tf.concat([tf.zeros(self.train_cat_filenames.shape, dtype=tf.int32),
                                          tf.ones(self.train_dog_filenames.shape, dtype=tf.int32)],
                                          axis=-1)
    
            self.model = tf.keras.Sequential([
                tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(256, 256, 3)),
                tf.keras.layers.MaxPooling2D(),
                tf.keras.layers.Conv2D(32, 5, activation='relu'),
                tf.keras.layers.MaxPooling2D(),
                tf.keras.layers.Flatten(),
                tf.keras.layers.Dense(64, activation='relu'),
                tf.keras.layers.Dense(2, activation='softmax')
            ])
    
        def get_batch(self):
            """获取dataset类型的训练数据过程
            :return:
            """
            # from_tensor_slices
            train_dataset = tf.data.Dataset.from_tensor_slices((self.train_filenames, self.train_labels))
            # map, shuffle, batch, prefetch
            train_dataset = train_dataset.map(_decode_and_resize)
            train_dataset = train_dataset.shuffle(buffer_size=20000)
            train_dataset = train_dataset.batch(CatOrDog.batch_size)
            train_dataset = train_dataset.repeat(1)
            train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)
            return train_dataset
    
        def train(self, train_dataset):
            """训练过程
            :return:
            """
            self.model.compile(
                optimizer=tf.keras.optimizers.Adam(learning_rate=CatOrDog.learning_rate),
                loss=tf.keras.losses.sparse_categorical_crossentropy,
                metrics=[tf.keras.metrics.sparse_categorical_accuracy]
            )
    
            self.model.fit(train_dataset)
            self.model.save_weights("./ckpt/cat_or_dogs.h5")
    
        def test(self):
            # 1、构建测试数据集
            test_cat_filenames = tf.constant([CatOrDog.test_cats_dir + filename
                                              for filename in os.listdir(CatOrDog.test_cats_dir)])
            test_dog_filenames = tf.constant([CatOrDog.test_dogs_dir + filename
                                              for filename in os.listdir(CatOrDog.test_dogs_dir)])
            test_filenames = tf.concat([test_cat_filenames, test_dog_filenames], axis=-1)
            test_labels = tf.concat([
                tf.zeros(test_cat_filenames.shape, dtype=tf.int32),
                tf.ones(test_dog_filenames.shape, dtype=tf.int32)],
                axis=-1)
            # 2、构建dataset
            test_dataset = tf.data.Dataset.from_tensor_slices((test_filenames, test_labels))
            test_dataset = test_dataset.map(_decode_and_resize)
            test_dataset = test_dataset.batch(CatOrDog.batch_size)
    
            # 3、加载模型进行评估
            if os.path.exists("./ckpt/cat_or_dogs.h5"):
                self.model.load_weights("./ckpt/cat_or_dogs.h5")
    
            print(self.model.metrics_names)
            print(self.model.evaluate(test_dataset))
    
    
    if __name__ == '__main__':
        # function_tool()
        cod = CatOrDog()
        train_dataset = cod.get_batch()
        print(train_dataset)
        # cod.train(train_dataset)
        cod.test_v2()

tfrecords\_example.py

import os
    import tensorflow as tf
    import os
    os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
    
    train_cats_dir = './cats_vs_dogs/train/cats/'
    train_dogs_dir = './cats_vs_dogs/train/dogs/'
    tfrecord_file = './cats_vs_dogs/train.tfrecords'
    
    
    def main():
    
        train_cat_filenames = [train_cats_dir + filename for filename in os.listdir(train_cats_dir)]
        train_dog_filenames = [train_dogs_dir + filename for filename in os.listdir(train_dogs_dir)]
        train_filenames = train_cat_filenames + train_dog_filenames
        # 将 cat 类的标签设为0，dog 类的标签设为1
        train_labels = [0] * len(train_cat_filenames) + [1] * len(train_dog_filenames)
    
        with tf.io.TFRecordWriter(tfrecord_file) as writer:
            for filename, label in zip(train_filenames, train_labels):
                # 1、读取数据集图片到内存，image 为一个 Byte 类型的字符串
                image = open(filename, 'rb').read()
                # 2、建立 tf.train.Feature 字典
                feature = {
                    'image': tf.train.Feature(bytes_list=tf.train.BytesList(value=[image])),  # 图片是一个 Bytes 对象
                    'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[label]))  # 标签是一个 Int 对象
                }
                # 3、通过字典建立 Example
                example = tf.train.Example(features=tf.train.Features(feature=feature))
                # 4\将Example序列化并写入 TFRecord 文件
                writer.write(example.SerializeToString())
    
    
    def read():
    
        # 1、读取 TFRecord 文件
        raw_dataset = tf.data.TFRecordDataset(tfrecord_file)
    
        # 2、定义Feature结构，告诉解码器每个Feature的类型是什么
        feature_description = {
            'image': tf.io.FixedLenFeature([], tf.string),
            'label': tf.io.FixedLenFeature([], tf.int64),
        }
    
        # 3、将 TFRecord 文件中的每一个序列化的 tf.train.Example 解码
        def _parse_example(example_string):
            feature_dict = tf.io.parse_single_example(example_string, feature_description)
            feature_dict['image'] = tf.io.decode_jpeg(feature_dict['image'])  # 解码JPEG图片
            return feature_dict['image'], feature_dict['label']
    
        dataset = raw_dataset.map(_parse_example)
    
        for image, label in dataset:
            print(image, label)
    
    
    if __name__ == '__main__':
        # main()
        read()

model\_serving.py

import tensorflow as tf
    import os
    os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
    
    
    def main():
        num_epochs = 1
        batch_size = 32
        learning_rate = 0.001
    
        model = tf.keras.models.Sequential([
            tf.keras.layers.Flatten(),
            tf.keras.layers.Dense(120, activation=tf.nn.relu),
            tf.keras.layers.Dense(100),
            tf.keras.layers.Softmax()
        ])
    
        (train, train_label), (test, test_label) = \
                    tf.keras.datasets.cifar100.load_data()
    
        model.compile(
            optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
            loss=tf.keras.losses.sparse_categorical_crossentropy,
            metrics=[tf.keras.metrics.sparse_categorical_accuracy]
        )
        model.fit(train, train_label, epochs=num_epochs, batch_size=batch_size)
    
        tf.saved_model.save(model, "./saved/mlp/2")
    
    
    def test():
    
        model = tf.saved_model.load("./saved/mlp/2")
    
        (_, _), (test, test_label) = \
            tf.keras.datasets.cifar100.load_data()
    
        y_predict = model(test)
    
        sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
        sparse_categorical_accuracy.update_state(y_true=test_label, y_pred=y_predict)
        print("测试集的准确率为: %f" % sparse_categorical_accuracy.result())
    
    
    def client():
        import json
        import numpy as np
        import requests
    
        (_, _), (test, test_label) = \
            tf.keras.datasets.cifar100.load_data()
    
        # 1、构造好请求
        data = json.dumps({"instances": test[:10].tolist()})
        headers = {"content-type": "application/json"}
    
        json_response = requests.post('http://localhost:8501/v1/models/mlp:predict',
                                      data=data, headers=headers)
    
        predictions = np.array(json.loads(json_response.text)['predictions'])
        print(predictions)
        print(np.argmax(predictions, axis=-1))
        print(test_label[:10])
    
    
    if __name__ == '__main__':
        # main()
        # test()
        client()

[20191009191333910.png]: /images/20230528/376300bff6ef4de7b31d2440ad766ff5.png
[Link 1]: http://www.rimengshe.com/
[AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]: https://blog.csdn.net/zimiao552147572/article/details/88867161
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70]: /images/20230528/48bfd774aaef425d92ac4d0b6439566d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1]: /images/20230528/851a02c48a3848a09f843d24eb6884ee.png
[2020032011501129.png]: /images/20230528/d1cb2cf358ab437d939b935ff9eefbf0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2]: /images/20230528/a177d57b4e1b4f8fb6f57a077a38e68d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 3]: /images/20230528/7c69740e621141f79324e405dc084d88.png
[Dogs vs. Cats]: https://www.kaggle.com/c/dogs-vs-cats-redux-kernels-edition
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 4]: /images/20230528/df9820589bcc457ab656f5da1b6a9abf.png
[https_www.floydhub.com_fastai_datasets_cats-vs-dogs]: https://www.floydhub.com/fastai/datasets/cats-vs-dogs
[https_www.tensorflow.org_api_docs_python_tf_keras_preprocessing_image_ImageDataGenerator_view-aliases]: https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/image/ImageDataGenerator#view-aliases
[20200320115121977.png]: /images/20230528/d5b64b6c71634f8c9cf22c0f5611c0d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 5]: /images/20230528/8bbba6b3eb894decae39c5dd822183ff.png