TensorFlow2.0学习笔记----利用自定义类方式的CNN来识别mnist数据集

 Keras Pipeline *
# 使用了 Keras 的 Subclassing API 建立模型，即对 tf.keras.Model 类进行扩展以定义自己的新模型，同时手工编写了训练和评估模型的流程。
# 这种方式灵活度高，且与其他流行的深度学习框架（如 PyTorch、Chainer）共通，是本手册所推荐的方法。
# 不过在很多时候，我们只需要建立一个结构相对简单和典型的神经网络（比如上文中的 MLP 和 CNN），并使用常规的手段进行训练。
# 这时，Keras 也给我们提供了另一套更为简单高效的内置方法来建立、训练和评估模型。
# Keras Sequential/Functional API 模式建立模型

import tensorflow as tf
import numpy as np


class MNISTLoader():
    def __init__(self):
        mnist = tf.keras.datasets.mnist
        (self.train_data, self.train_label), (self.test_data, self.test_label) = mnist.load_data()
        # mnist数据集有四个文件，上行代码的意思是把数据集的四个文件导入到变量
        # self.train_data, self.train_label, self.test_data, self.test_label中
        # (self.train_data, self.train_label), (self.test_data, self.test_label) 是两个元组
        # MNIST中的图像默认为uint8（0-255的数字）。以下代码将其归一化到0-1之间的浮点数，并在最后增加一维作为颜色通道数目
        self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)      # [60000, 28, 28, 1]
        self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)        # [10000, 28, 28, 1]
        self.train_label = self.train_label.astype(np.int32)
        # [60000] 将label转化为np.int32类型，print train_label为[7 2 1 ... 4 5 6]
        self.test_label = self.test_label.astype(np.int32)      # [10000]
        self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]

    def get_batch(self, batch_sizes):
        # 从60000个数据集中随机取出batch_size个元素并返回
        # 在训练时要计算损失，不能一张图片一张图片来计算损失，因为可能个别图片偏差太大，所以一组一组来计算损失
        index = np.random.randint(0, self.num_train_data, batch_sizes)
        return self.train_data[index, :], self.train_label[index]
        # 表示取train_data第一维下标为index的所有值，其中index是一串数字


class CNN(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = tf.keras.layers.Conv2D(
            filters=32,             # 卷积层神经元（卷积核）数目，每一个的里面的参数时需要学习的，会先自动生成一个随机的参数，
                                    # 一个图片n x n x 1经过32个卷积核卷积后，得到一个n x n x 32
            kernel_size=[5, 5],     # 感受野（卷积核）的大小
            padding='same',         # padding策略（vaild 或 same），当padding为same时，使输入图像与卷积输出的feature map的尺寸通过补零保持一致
            activation=tf.nn.relu   # 激活函数
        )
        self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
        self.conv2 = tf.keras.layers.Conv2D(
            filters=64,
            kernel_size=[5, 5],
            padding='same',
            activation=tf.nn.relu
        )
        self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
        self.flatten = tf.keras.layers.Reshape(target_shape=(7 * 7 * 64,))
        self.dense1 = tf.keras.layers.Dense(units=1024, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=10)

    def call(self, inputs):
        x = self.conv1(inputs)                  # 输出为[batch_size, 28, 28, 32]因为补零（padding），所以卷积后图像尺寸不变
        x = self.pool1(x)                       # [batch_size, 14, 14, 32]
        x = self.conv2(x)                       # [batch_size, 14, 14, 64]   64个filters
        x = self.pool2(x)                       # [batch_size, 7, 7, 64]
        x = self.flatten(x)                     # [batch_size, 7 * 7 * 64]
        x = self.dense1(x)                      # [batch_size, 1024] dense相当于全连接层
        x = self.dense2(x)                      # [batch_size, 10]
        output = tf.nn.softmax(x)
        return output


# 训练模型的搭建

# 定义一些超参数
num_epochs = 5          # 学习五轮
batch_size = 50         # 每一批50个样本
learning_rate = 0.001

model = CNN()           # 创建类的实例
data_loader = MNISTLoader()      # 创建类的实例
print(data_loader.train_data.shape)
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)     # 使用Adam优化器
# 当我们求出了loss以后，对loss求梯度，把kernel和bias的梯度（偏导数）函数交给optimizer

num_batches = int(data_loader.num_train_data // batch_size * num_epochs)
# 计算下面for循环的次数，data_loader.num_train_data是总共的训练图片数60000
# 每一批50张，一共迭代五轮，" / "就表示 浮点数除法，返回浮点结果;" // "表示整数除法
# 所以需要循环data_loader.num_train_data // batch_size * num_epochs次

# 开始训练
for batch_index in range(num_batches):
    X, y = data_loader.get_batch(batch_size)     # X是图像，y是标签
    with tf.GradientTape() as tape:
        y_pred = model(X)                        # y_pred是一个50行，10列的向量

        loss = tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred)
        # 交叉熵损失函数，例如每个图片的y_pred是[0,0.1,0,0.2,0.5,0.1,0.1,0,0,0]，y为[0,1,0,0,0,0,0,0,0,0]，经过交叉熵损失函数使得输出为一个数
        # 因为是50张，所以输出为50维向量

        loss = tf.reduce_mean(loss)          # 对输出为50维的向量求平均
        print("batch %d: loss %f" % (batch_index, loss.numpy()))
    grads = tape.gradient(loss, model.variables)      # 对loss中每一个变量model.variables即kernel = [w1,w2,w3....w784]和bias求偏导
    # 对录像带的功能，我自己的理解是上面循环输出的loss是一个一个的浮点数，录像带让这些数变成函数

    optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))     # 梯度下降过程


# 模型的测试
sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()    # 定义一个测试对象
num_batches = int(data_loader.num_test_data // batch_size)                    # 循环的次数
for batch_index in range(num_batches):
    start_index, end_index = batch_index * batch_size, (batch_index + 1) * batch_size
    y_predict = model.predict(data_loader.test_data[start_index: end_index])     # 取50张图片进行预测
    sparse_categorical_accuracy.update_state(y_true=data_loader.test_label[start_index: end_index], y_pred=y_predict)
print("test accuracy: %f" % sparse_categorical_accuracy.result())

1. 20-21行

self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)      # [60000, 28, 28, 1]
self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)        # [10000, 28, 28, 1]

这两行如果替换成：

self.train_image = self.train_image / 255.0
self.test_image = self.test_image / 255.0
self.train_image = np.expand_dims(self.train_image, axis=-1)
self.test_image = np.expand_dims(self.test_image, axis=-1)

那么train_image.shape就变成了（60000,1），但是原本应该是（60000,28,28,1）。是因为张量进行逻辑运算的时候数据类型必须一致。

改成这样就可以运行了，即train_image.shape为（60000,28,281）但是loss一值降不下来，所以说这样的写法应该也不标准吧

self.train_image = self.train_image / tf.constant(255.0)
self.test_image = self.test_image / tf.constant(255.0)
self.train_image = np.expand_dims(self.train_image, axis=-1)
self.test_image = np.expand_dims(self.test_image, axis=-1)

第35行

继承了tf.keras.Model的模型就能继承其内部的参数，比如后面求导用到的variables参数

第53行：

在经过全连接层前首先要把输入图像打平，因为上面经过两个【2,2】的池化层，且最后一个卷积是64核，所以reshape的参数为7x7x64

全连接层也称为dense层，稠密层。因为最后分类为十种，所以最后的全连接的unit为10

57-66行：

卷积网络的卷积层的输出的feature map的个数只与卷积核的个数有关，与输入图像的色彩通道个数无关。假如输入图像时三通道rgb，经过一个卷积核后产生的三个矩阵会求和平均为一个矩阵