Keras 实现卷积神经网络识别手写数字、迁移学习以及tf.keras.applications使用

短命女 2023-07-17 04:45 54阅读 0赞

日萌社" class="reference-link">20191009191333910.png日萌社

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

4.4 案例：CNN进行分类

4.4.1 卷积神经网络构建识别手写数字

卷积神经网络包含一个或多个卷积层（Convolutional Layer）、池化层（Pooling Layer）和全连接层（Fully-connected Layer）。

4.4.1.1 使用 Keras 实现卷积神经网络

卷积神经网络的一个实现现如下所示，新加入了一些卷积层和池化层。当然这个网络可以增加、删除或调整 CNN 的网络结构和参数，以达到更好效果。

  1. class CNN(tf.keras.Model):
  2.     def __init__(self):
  3.         super().__init__()
  4.         self.conv1 = tf.keras.layers.Conv2D(
  5.             filters=32,             # 卷积层神经元（卷积核）数目
  6.             kernel_size=[5, 5],     # 卷积核大小
  7.             padding='same',         # padding策略（vaild 或 same）
  8.             activation=tf.nn.relu   # 激活函数
  9.         )
  10.         self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
  11.         self.conv2 = tf.keras.layers.Conv2D(
  12.             filters=64,
  13.             kernel_size=[5, 5],
  14.             padding='same',
  15.             activation=tf.nn.relu
  16.         )
  17.         self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
  18.         self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
  19.         self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu)
  20.         self.dense2 = tf.keras.layers.Dense(units=10)
  22.     def call(self, inputs):
  23.         x = self.conv1(inputs)                  # [batch_size, 28, 28, 32]
  24.         x = self.pool1(x)                       # [batch_size, 14, 14, 32]
  25.         x = self.conv2(x)                       # [batch_size, 14, 14, 64]
  26.         x = self.pool2(x)                       # [batch_size, 7, 7, 64]
  27.         x = self.flatten(x)                     # [batch_size, 7 * 7 * 64]
  28.         x = self.dense1(x)                      # [batch_size, 1024]
  29.         x = self.dense2(x)                      # [batch_size, 10]
  30.         output = tf.nn.softmax(x)
  31.         return output

将前节的 model = MLP() 更换成 model = CNN() ，训练结束以及预测输出：

  1. 批次 4682: 损失 0.010545
  2. 批次 4683: 损失 0.003783
  3. 批次 4684: 损失 0.000980
  4. 测试准确率: 0.990600

可以发现准确率相较于之前的多层感知机有非常显著的提高。

我们来看一个个问题如果我们要做一个具体场景的计算机视觉任务，那么从头开始训练一个网络是合适的选择吗？怎么样才能避免浪费过多的计算时间？

keras_mlp.py

  1. import tensorflow as tf
  2. import numpy as np
  3. import os
  4. os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
  6. num_epochs = 5
  7. batch_size = 64
  8. learning_rate = 0.001
  11. class MnistLoader(object):
  12.     """数据加载处理类
  13.     """
  14.     def __init__(self):
  15.         # 1、获取数据
  16.         (self.train_data, self.train_label), (self.test_data, self.test_label) = \
  17.             tf.keras.datasets.mnist.load_data()
  19.         # 2、处理数据， 归一化，维度拓展，类型
  20.         self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)
  21.         self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)
  23.         self.train_label = self.train_label.astype(np.int32)
  24.         self.test_label = self.test_label.astype(np.int32)
  26.         # 获取一个变量接收数据量
  27.         self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]
  29.     def get_batch(self, batch_size):
  30.         """按照训练获取指定大小数据的批次数据
  31.         :param batch_size: 每批次数据的大小
  32.         :return:
  33.         """
  34.         # 获取随机生成的batch_size大小的下标
  35.         index = np.random.randint(0, self.train_data.shape[0], batch_size)
  36.         return self.train_data[index, :], self.train_label[index]
  39. class MLP(tf.keras.Model):
  40.     """自定义MLP类
  41.     """
  42.     def __init__(self):
  43.         super().__init__()
  44.         # 卷积到全连接层的数据形状处理
  45.         self.flatten = tf.keras.layers.Flatten()
  46.         self.dense1 = tf.keras.layers.Dense(units=100, activation=tf.nn.relu)
  47.         self.dense2 = tf.keras.layers.Dense(units=10)
  49.     def call(self, inputs):
  50.         """
  51.         :param inputs: 模型的输入
  52.         :return:
  53.         """
  54.         # 此例子中输入[batch_size, 28 ,28, 1]
  55.         x = self.flatten(inputs)
  56.         x = self.dense1(x)
  57.         x = self.dense2(x)
  59.         # 经过softmax计算[batch_size, 10]
  60.         output = tf.nn.softmax(x)
  61.         return output
  64. class CNN(tf.keras.Model):
  65.     """自定义CNN类，两层卷积池化+两个全连接层
  66.     """
  67.     def __init__(self):
  68.         super().__init__()
  69.         # 两层卷积池化+两个全连接层
  70.         # [batch_size, 28 ,28, 1]--->[batch_size, 14, 14, 32]
  71.         # 第一层：32个filter, 5 * 5, padding=same
  72.         self.conv1 = tf.keras.layers.Conv2D(
  73.             filters=32,  # 卷积核数量
  74.             kernel_size=[5, 5],  # 卷积核大小
  75.             padding='same',  # 领填充方式
  76.             activation=tf.nn.relu  # 激活函数
  77.         )
  78.         self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
  80.         # 第二层：64个filter, 5 * 5, padding=same
  81.         # [batch_size, 14 ,14, 32]--->[batch_size, 7, 7, 64]
  82.         self.conv2 = tf.keras.layers.Conv2D(
  83.             filters=64,  # 卷积核数量
  84.             kernel_size=[5, 5],  # 卷积核大小
  85.             padding='same',  # 领填充方式
  86.             activation=tf.nn.relu  # 激活函数
  87.         )
  88.         self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
  90.         # 经过一个形状变化在输入到全连接层网络
  91.         self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
  92.         self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu)
  93.         self.dense2 = tf.keras.layers.Dense(units=10)
  95.     def call(self, inputs):
  96.         """模型输入输出构建
  97.         :param inputs: 输入[batch_size, 28 ,28, 1]
  98.         :return:
  99.         """
  100.         x = self.conv1(inputs)
  101.         x = self.pool1(x)
  102.         x = self.conv2(x)
  103.         x = self.pool2(x)
  104.         x = self.flatten(x)
  105.         x = self.dense1(x)
  106.         x = self.dense2(x)
  107.         output = tf.nn.softmax(x)
  108.         return output
  111. def train():
  112.     """模型训练逻辑
  113.     :return:
  114.     """
  116.     # 1、从 DataLoader 中随机取一批训练数据，并且初始化模型
  117.     mnist = MnistLoader()
  118.     # model = MLP()
  119.     model = CNN()
  120.     optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
  122.     # 2、将这批数据送入模型，计算出模型的预测值；
  123.     # 总共样本len(train_data), 迭代次数epoches表示所有数据过几遍，batch_size:每批次训练的样本32， 64
  124.     # 一共需要多少批次 len(train_data)/ batch_size * epoches举例 1000/10 = 10批次才训练完成，10 * 5
  125.     num_batches = int(mnist.num_train_data // batch_size * num_epochs)
  126.     for batch_index in range(num_batches):
  127.         X, y = mnist.get_batch(batch_size)
  128.         with tf.GradientTape() as tape:
  129.             y_pred = model(X)
  131.             # 3、将模型预测值与真实值进行比较，计算损失函数（loss）。这里使用
  132.             # tf.keras.losses 中的交叉熵函数作为损失函数；
  133.             loss = tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred))
  134.             print("批次 %d: 损失 %f" % (batch_index, loss.numpy()))
  136.         # 4、计算损失函数关于模型变量的导数；
  137.         grads = tape.gradient(loss, model.variables)
  139.         # 5、将求出的导数值传入优化器，使用优化器的 apply_gradients 方法更新模型参数以最小化损失函数（优化器的详细使用方法见 前章 ）。
  140.         optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))
  142.     # 3、对测试数据及进行评估
  143.     y_pred = model.predict(mnist.test_data)
  144.     # 初始化一个metrics
  145.     sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
  146.     sparse_categorical_accuracy.update_state(y_true=mnist.test_label, y_pred=y_pred)
  147.     print("测试准确率：%f" % (sparse_categorical_accuracy.result()))
  149.     return None
  152. if __name__ == '__main__':
  153.     # mnist = MnistLoader()
  154.     # train_data, train_label = mnist.get_batch(64)
  155.     # print(train_data, train_label)
  156.     train()

4.4.2 迁移学习(Transfer Learning)-Keras 中预定义的经典卷积神经网络结构

4.4.2.1 介绍

  • 定义

    • 迁移学习就是利用数据、任务或模型之间的相似性，将在旧的领域学习过或训练好的模型，应用于新的领域这样的一个过程。
    • 两个任务的输入属于同一性质：要么同是图像、要么同是语音或其他

迁移学习到底在什么情况下使用呢？有两个方面需要我们考虑的

  • 1、当我们有海量的数据资源时，可以不需要迁移学习，机器学习系统很容易从海量数据中学习到一个鲁棒性很强的模型。但通常情况下，我们需要研究的领域可获得的数据极为有限，在少量的训练样本上精度极高，但是泛化效果极差。
  • 2、训练成本，很少去从头开始训练一整个深度卷积网络，从头开始训练一个卷积网络通常需要较长时间且依赖于强大的 GPU 计算资源。

4.4.2.2 方法

  • 最常见的称呼叫做fine tuning,即微调

    • 已训练好的模型，称之为Pre-trained model

通常我们需要加载以训练好的模型，这些可以是一些机构或者公司在ImageNet等类似比赛上进行训练过的模型。TensorFlow同样也提供了相关模型地址以及API：https://www.tensorflow.org/api_docs/python/tf/keras/applications

下图是其中包含的一些模型：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70

2.5.1.3 过程

这里我们举一个例子，假设有两个任务A和B，任务 A 拥有海量的数据资源且已训练好，但并不是我们的目标任务，任务 B 是我们的目标任务。下面的网络模型假设是已训练好的1000个类别模型

20200319162009375.png

而B任务假设是某个具体场景如250个类别的食物识别，那么该怎么去做

  • 1、建立自己的网络，在A的基础上，修改最后输出结构，并加载A的模型参数

  • 2、根据数据大小调整

    • 如果B任务数据量小，那么我们可以选择将A模型的所有的层进行freeze(可以通过Tensorflow的trainable=False参数实现)，而剩下的输出层部分可以选择调整参数训练
    • 如果B任务的数据量大，那么我们可以将A中一半或者大部分的层进行freeze,而剩下部分的layer可以进行新任务数据基础上的微调

4.4.2 使用

tf.keras.applications 中有一些预定义好的经典卷积神经网络结构，如 VGG16 、 VGG19 、 ResNet 、 MobileNet 等。我们可以直接调用这些经典的卷积神经网络结构（甚至载入预训练的参数），而无需手动定义网络结构。

  • 支持以下结构：

    • densenet module: DenseNet models for Keras.
    • imagenet_utils module: Utilities for ImageNet data preprocessing & prediction decoding.
    • inception_resnet_v2 module: Inception-ResNet V2 model for Keras.
    • inception_v3 module: Inception V3 model for Keras.
    • mobilenet module: MobileNet v1 models for Keras.
    • mobilenet_v2 module: MobileNet v2 models for Keras.
    • nasnet module: NASNet-A models for Keras.
    • resnet module: ResNet models for Keras.
    • resnet50 module: Public API for tf.keras.applications.resnet50 namespace.
    • resnet_v2 module: ResNet v2 models for Keras.
    • vgg16 module: VGG16 model for Keras.
    • vgg19 module: VGG19 model for Keras.
    • xception module: Xception V1 model for Keras.

  • 我们可以使用以下代码来实例化一个 MobileNetV2 网络结构：

    • model = tf.keras.applications.MobileNetV2()
    • input_shape ：输入张量的形状（不含第一维的 Batch），大多默认为 224 × 224 × 3 。一般而言，模型对输入张量的大小有下限，长和宽至少为 32 × 32 或 75 × 75 ；
    • include_top ：在网络的最后是否包含全连接层，默认为 True ；
    • weights ：预训练权值，默认为 ‘imagenet’ ，即为当前模型载入在 ImageNet 数据集上预训练的权值。如需随机初始化变量可设为 None ；
    • classes ：分类数，默认为 1000。修改该参数需要 include_top 参数为 True 且 weights 参数为 None 。

当执行以上代码时，TensorFlow 会自动从网络上下载 MobileNetV2 网络结构，因此在第一次执行代码时需要具备网络连接。

可以使用 MobileNetV2 网络对相关数据集进行训练看看效果

  1. model = tf.keras.applications.MobileNetV2(weights=None, classes=5)

4.4.3 总结

  • 掌握keras卷积网络相关API
  • 卷机网络的构建
  • 迁移学习以及tf.keras.applications使用

transfer_learning.py 

  1. import tensorflow as tf
  2. from tensorflow.keras.preprocessing.image import ImageDataGenerator
  3. from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input
  4. import numpy as np
  5. import os
  6. os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
  9. class TransferModel(object):
  10.     """VGG迁移学习做5个类别图片识别
  11.     """
  12.     def __init__(self):
  13.         # 初始化训练集和测试集的迭代器
  14.         self.train_generator = ImageDataGenerator(rescale=1.0 / 255.0,
  15.                                                   shear_range=0.2,
  16.                                                   zoom_range=0.2,
  17.                                                   horizontal_flip=True)
  19.         self.test_generator = ImageDataGenerator(rescale=1.0 / 255.0)
  21.         # 数据目录
  22.         self.train_dir = "./data/train"
  23.         self.test_dir = "./data/test"
  25.         # 定义输入数据的大小和批次大小
  26.         self.image_size = (224, 224)
  27.         self.batch_size = 32
  29.         # 初始化VGG基础模型，
  30.         self.base_model = VGG16(weights='imagenet', include_top=False)
  32.         self.label_dict = {
  33.             '0': 'bus',
  34.             '1': 'dinosaurs',
  35.             '2': 'elephants',
  36.             '3': 'flowers',
  37.             '4': 'horse'
  38.         }
  40.     def get_local_data(self):
  41.         """读取本地的图片数据以及类别标签
  42.         :return:
  43.         """
  44.         # 1、datagen.flow_from_directory
  45.         train_gen = self.train_generator.flow_from_directory(self.train_dir,
  46.                                                              target_size=self.image_size,
  47.                                                              batch_size=self.batch_size,
  48.                                                              class_mode='binary',
  49.                                                              shuffle=True)
  51.         test_gen = self.train_generator.flow_from_directory(self.test_dir,
  52.                                                              target_size=self.image_size,
  53.                                                              batch_size=self.batch_size,
  54.                                                              class_mode='binary',
  55.                                                              shuffle=True)
  57.         return train_gen, test_gen
  59.     def refine_base_model(self):
  60.         """
  61.         修改VGG的模型，在VGG的5个block，[None, ?, ?, 512]--->全局平均池化-->两个全连接层1024, 5
  62.         :return: 新的迁移学习模型
  63.         """
  64.         # 1、获取VGG模型的输出，不包含原有模型的top结构
  65.         x = self.base_model.outputs[0]
  67.         # 2、在VGG的输出之后定义自己的模型
  68.         x = tf.keras.layers.GlobalAveragePooling2D()(x)
  70.         # 两个全连接层
  71.         x = tf.keras.layers.Dense(1024, activation=tf.nn.relu)(x)
  72.         y_predict = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x)
  74.         # 3、使用Model封装新的模型返回
  75.         transfer_model = tf.keras.models.Model(inputs=self.base_model.inputs, outputs=y_predict)
  77.         return transfer_model
  79.     def freeze_vgg_model(self):
  80.         """
  81.         冻结VGG的前面卷积结构，不参与训练
  82.         :return:
  83.         """
  84.         # 循环获取base_model当中的层
  85.         for layer in self.base_model.layers:
  86.             layer.trainable = False
  88.         return None
  90.     def compile(self, model):
  91.         """
  92.         编译模型，指定优化器损失计算方式，准确率衡量
  93.         :return:
  94.         """
  95.         model.compile(optimizer=tf.keras.optimizers.Adam(),
  96.                       loss=tf.keras.losses.sparse_categorical_crossentropy,
  97.                       metrics=['accuracy'])
  98.         return None
  100.     def fit_generator(self, model, train_gen, test_gen):
  101.         """进行模型训练，注意使用fit_generator,不是fit
  102.         :param model:
  103.         :param train_gen:
  104.         :param test_gen:
  105.         :return:
  106.         """
  107.         modelckpt = tf.keras.callbacks.ModelCheckpoint('./ckpt/transfer_{epoch:02d}-{val_accuracy:.2f}.h5',
  108.                                                        monitor='val_accuracy',
  109.                                                        save_best_only=True,
  110.                                                        save_weights_only=False,
  111.                                                        mode='auto',
  112.                                                        period=1)
  114.         model.fit_generator(train_gen, epochs=3, validation_data=test_gen, callbacks=[modelckpt])
  116.         return None
  118.     def predict(self, model):
  119.         """预测输入图片的类别
  120.         :return:
  121.         """
  122.         # 1、加载模型训练好的权重
  123.         model.load_weights("./ckpt/transfer_01-0.84.h5")
  125.         # 2、读取图片处理图片数据，形状，数据归一化
  126.         image = tf.io.read_file("./data/test/dinosaurs/402.jpg")
  127.         image_decoded = tf.image.decode_jpeg(image)
  128.         image_resized = tf.image.resize(image_decoded, [224, 224]) / 255.0
  129.         # 3维-->4维的形状改变
  130.         img = tf.reshape(image_resized, (1, image_resized.shape[0], image_resized.shape[1], image_resized.shape[2]))
  131.         print("修改之后的形状：", img.shape)
  133.         # 3、输入数据做预测
  134.         y_predict = model.predict(img)
  136.         index = np.argmax(y_predict, axis=1)
  138.         print(self.label_dict[str(index[0])])
  140.         return None
  143. if __name__ == '__main__':
  145.     tm = TransferModel()
  146.     # # 训练模型步骤
  147.     # # 1、读取数据
  148.     # train_gen, test_gen = tm.get_local_data()
  149.     # # print(train_gen, test_gen)
  150.     # # 2、定义模型去微调模型和冻结模型
  151.     # # 3、模型的compile和训练
  152.     # model = tm.refine_base_model()
  153.     # print(model.summary())
  154.     # tm.freeze_vgg_model()
  155.     # tm.compile(model)
  156.     # tm.fit_generator(model, train_gen, test_gen)
  158.     # 测试数据
  159.     transfer_model = tm.refine_base_model()
  160.     tm.predict(transfer_model)

fashion_mnist.py

  1. import tensorflow as tf
  2. import numpy as np
  3. import os
  4. os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
  6. num_epochs = 10
  7. batch_size = 64
  8. learning_rate = 0.001
  11. class MnistLoader(object):
  12.     """数据加载处理类
  13.     """
  14.     def __init__(self):
  15.         # 1、获取数据
  16.         (self.train_data, self.train_label), (self.test_data, self.test_label) = \
  17.             tf.keras.datasets.fashion_mnist.load_data()
  19.         # 2、处理数据， 归一化，维度拓展，类型
  20.         self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)
  21.         self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)
  23.         self.train_label = self.train_label.astype(np.int32)
  24.         self.test_label = self.test_label.astype(np.int32)
  26.         # 获取一个变量接收数据量
  27.         self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]
  29.     def get_batch(self, batch_size):
  30.         """按照训练获取指定大小数据的批次数据
  31.         :param batch_size: 每批次数据的大小
  32.         :return:
  33.         """
  34.         # 获取随机生成的batch_size大小的下标
  35.         index = np.random.randint(0, self.train_data.shape[0], batch_size)
  36.         return self.train_data[index, :], self.train_label[index]
  39. class MLP(tf.keras.Model):
  40.     """自定义MLP类
  41.     """
  42.     def __init__(self):
  43.         super().__init__()
  44.         # 卷积到全连接层的数据形状处理
  45.         self.flatten = tf.keras.layers.Flatten()
  46.         self.dense1 = tf.keras.layers.Dense(units=128, activation=tf.nn.relu)
  47.         self.dense2 = tf.keras.layers.Dense(units=10)
  49.     def call(self, inputs):
  50.         """
  51.         :param inputs: 模型的输入
  52.         :return:
  53.         """
  54.         # 此例子中输入[batch_size, 28 ,28, 1]
  55.         x = self.flatten(inputs)
  56.         x = self.dense1(x)
  57.         x = self.dense2(x)
  59.         # 经过softmax计算[batch_size, 10]
  60.         output = tf.nn.softmax(x)
  61.         return output
  64. class CNN(tf.keras.Model):
  65.     """自定义CNN类，两层卷积池化+两个全连接层
  66.     """
  67.     def __init__(self):
  68.         super().__init__()
  69.         # 两层卷积池化+两个全连接层
  70.         # [batch_size, 28 ,28, 1]--->[batch_size, 14, 14, 32]
  71.         # 第一层：32个filter, 5 * 5, padding=same
  72.         self.conv1 = tf.keras.layers.Conv2D(
  73.             filters=32,  # 卷积核数量
  74.             kernel_size=[3, 3],  # 卷积核大小
  75.             padding='same',  # 领填充方式
  76.             activation=tf.nn.relu,  # 激活函数
  77.             kernel_regularizer=tf.keras.regularizers.l2(0.0001)
  78.         )
  79.         self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
  81.         # 第二层：64个filter, 5 * 5, padding=same
  82.         # [batch_size, 14 ,14, 32]--->[batch_size, 7, 7, 64]
  83.         self.conv2 = tf.keras.layers.Conv2D(
  84.             filters=64,  # 卷积核数量
  85.             kernel_size=[3, 3],  # 卷积核大小
  86.             padding='same',  # 领填充方式
  87.             activation=tf.nn.relu,  # 激活函数
  88.             kernel_regularizer=tf.keras.regularizers.l2(0.0001)
  89.         )
  90.         self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
  92.         # 经过一个形状变化在输入到全连接层网络
  93.         self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
  94.         self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu, kernel_regularizer=tf.keras.regularizers.l2(0.0001))
  95.         self.dropout = tf.keras.layers.Dropout(rate=0.4)
  96.         self.dense2 = tf.keras.layers.Dense(units=10)
  98.     def call(self, inputs):
  99.         """模型输入输出构建
  100.         :param inputs: 输入[batch_size, 28 ,28, 1]
  101.         :return:
  102.         """
  103.         x = self.conv1(inputs)
  104.         x = self.pool1(x)
  105.         x = self.conv2(x)
  106.         x = self.pool2(x)
  107.         x = self.flatten(x)
  108.         x = self.dense1(x)
  109.         # x = self.dropout(x, training=True)
  110.         x = self.dense2(x)
  111.         output = tf.nn.softmax(x)
  112.         return output
  115. def train():
  116.     """模型训练逻辑
  117.     :return:
  118.     """
  120.     # 1、从 DataLoader 中随机取一批训练数据，并且初始化模型
  121.     mnist = MnistLoader()
  122.     # model = MLP()
  123.     model = CNN()
  124.     optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
  126.     # 2、将这批数据送入模型，计算出模型的预测值；
  127.     # 总共样本len(train_data), 迭代次数epoches表示所有数据过几遍，batch_size:每批次训练的样本32， 64
  128.     # 一共需要多少批次 len(train_data)/ batch_size * epoches举例 1000/10 = 10批次才训练完成，10 * 5
  129.     num_batches = int(mnist.num_train_data // batch_size * num_epochs)
  130.     for batch_index in range(num_batches):
  132.         X, y = mnist.get_batch(batch_size)
  133.         with tf.GradientTape() as tape:
  134.             y_pred = model(X)
  136.             # 3、将模型预测值与真实值进行比较，计算损失函数（loss）。这里使用
  137.             # tf.keras.losses 中的交叉熵函数作为损失函数；
  138.             loss = tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred))
  139.             print("批次 %d: 损失 %f" % (batch_index, loss.numpy()))
  141.         # 4、计算损失函数关于模型变量的导数；
  142.         grads = tape.gradient(loss, model.variables)
  144.         # 5、将求出的导数值传入优化器，使用优化器的 apply_gradients 方法更新模型参数以最小化损失函数（优化器的详细使用方法见 前章 ）。
  145.         optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))
  147.     # 3、对测试数据及进行评估
  148.     y_pred = model.predict(mnist.test_data)
  149.     # 初始化一个metrics
  150.     sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
  151.     sparse_categorical_accuracy.update_state(y_true=mnist.test_label, y_pred=y_pred)
  152.     print("测试准确率：%f" % (sparse_categorical_accuracy.result()))
  154.     return None
  157. if __name__ == '__main__':
  158.     # mnist = MnistLoader()
  159.     # train_data, train_label = mnist.get_batch(64)
  160.     # print(train_data, train_label)
  161.     train()

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 1

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ppbWlhbzU1MjE0NzU3Mg_size_16_color_FFFFFF_t_70 2

发表评论

表情：
评论列表 （有 0 条评论，54人围观）

还没有评论，来说两句吧...

相关阅读