tensorflow 2.0 学习 （十二）卷积神经网络 （二） CIFAR10数据集与改进VGG13网络 + CoLab

网络结构如下：

 代码如下：

# encoding: utf-8
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, Sequential, losses, optimizers, datasets
import matplotlib.pyplot as plt

# load data
(x, y), (x_test, y_test) = datasets.cifar10.load_data()
y = tf.squeeze(y, axis=1)
y_test = tf.squeeze(y_test, axis=1)


# print(x.shape, y.shape, x_test.shape, y_test.shape)
# (50000, 32, 32, 3) (50000,) (10000, 32, 32, 3) (10000,)


def pre_process(X, Y):
    x_reshape = tf.cast(X, dtype=tf.float32) / 255.  # 先将类型转化为float32，再归一到0-1
    # x = tf.reshape(x, [-1, 32 * 32])                  # 不知道x数量，用-1代替，转化为一维1024个数据
    y_reshape = tf.cast(Y, dtype=tf.int32)  # 转化为整型32
    y_onehot = tf.one_hot(y_reshape, depth=10)  # 训练数据所需的one-hot编码
    return x_reshape, y_onehot


# create data_set
train_db = tf.data.Dataset.from_tensor_slices((x, y))
train_db = train_db.shuffle(1000).map(pre_process).batch(128)

test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test))
test_db = test_db.shuffle(1000).map(pre_process).batch(128)

# 观察
# sample = next(iter(train_db))
# print('sample: ', sample[0].shape, sample[1].shape,
#                  tf.reduce_min(sample[0]), tf.reduce_max(sample[0]))
# sample:  (128, 3, 1024) (128, 10)
#           tf.Tensor(0.0, shape=(), dtype=float32)
#           tf.Tensor(1.0, shape=(), dtype=float32)


# 卷积子网络
CONV_Net = Sequential([
    # 1
    layers.Conv2D(64, kernel_size=3, padding='SAME', activation='relu'),
    layers.Conv2D(64, kernel_size=3, padding='SAME', activation='relu'),
    layers.MaxPooling2D(pool_size=[2, 2], strides=2, padding='SAME'),
    # 2
    layers.Conv2D(128, kernel_size=3, padding='SAME', activation='relu'),
    layers.Conv2D(128, kernel_size=3, padding='SAME', activation='relu'),
    layers.MaxPooling2D(pool_size=[2, 2], strides=2, padding='SAME'),
    # 3
    layers.Conv2D(256, kernel_size=3, padding='SAME', activation='relu'),
    layers.Conv2D(256, kernel_size=3, padding='SAME', activation='relu'),
    layers.MaxPooling2D(pool_size=[2, 2], strides=2, padding='SAME'),
    # 4
    layers.Conv2D(512, kernel_size=3, padding='SAME', activation='relu'),
    layers.Conv2D(512, kernel_size=3, padding='SAME', activation='relu'),
    layers.MaxPooling2D(pool_size=[2, 2], strides=2, padding='SAME'),
    # 5
    layers.Conv2D(512, kernel_size=3, padding='SAME', activation='relu'),
    layers.Conv2D(512, kernel_size=3, padding='SAME', activation='relu'),
    layers.MaxPooling2D(pool_size=[2, 2], strides=2, padding='SAME'),
])

FC_Net = Sequential([
    layers.Dense(256, activation='relu'),
    layers.Dense(128, activation='relu'),
    layers.Dense(10, activation=None),
])

CONV_Net.build(input_shape=[None, 32, 32, 3])
CONV_Net.summary()

FC_Net.build(input_shape=[None, 512])
FC_Net.summary()


def main():
    optimizer = tf.keras.optimizers.RMSprop(0.001)  # 创建优化器，指定学习率
    criteon = losses.CategoricalCrossentropy(from_logits=True)
    Epoch = 50
    # 保存训练和测试过程中的误差情况
    train_tot_loss = []
    test_tot_loss = []

    for epoch in range(Epoch):
        cor, tot = 0, 0
        for step, (x, y) in enumerate(train_db):  # (128, 32, 32, 3), (128, 10)
            with tf.GradientTape() as tape:  # 构建梯度环境
                # train
                out_conv = CONV_Net(x)  # (128, 1, 1, 512)
                out = tf.reshape(out_conv, [-1, 512])  # (128, 512)
                out_fc = FC_Net(out)  # (128, 10) tf.float32

                # calculate loss
                y = tf.cast(y, dtype=tf.float32)
                loss = criteon(y, out_fc)
                variables = CONV_Net.trainable_variables + FC_Net.trainable_variables
                grads = tape.gradient(loss, variables)
                optimizer.apply_gradients(zip(grads, variables))

                # train var
                train_out = tf.nn.softmax(out_fc, axis=1)
                train_out = tf.argmax(train_out, axis=1)
                train_out = tf.cast(train_out, dtype=tf.int64)

                train_y = tf.nn.softmax(y, axis=1)
                train_y = tf.argmax(train_y, axis=1)

                # calculate train var loss
                train_cor = tf.equal(train_y, train_out)
                train_cor = tf.cast(train_cor, dtype=tf.float32)
                train_cor = tf.reduce_sum(train_cor)
                cor += train_cor
                tot += x.shape[0]

        print('After %d Epoch' % epoch)
        print('training acc is ', cor / tot)
        train_tot_loss.append(cor / tot)

        correct, total = 0, 0
        for x, y in test_db:
            # test
            pred_conv = CONV_Net(x)
            pred_conv = tf.reshape(pred_conv, [-1, 512])
            pred = FC_Net(pred_conv)

            # test var
            test_out = tf.nn.softmax(pred, axis=1)
            test_out = tf.argmax(test_out, axis=1)
            test_out = tf.cast(test_out, dtype=tf.int64)

            test_y = tf.nn.softmax(y, axis=1)
            test_y = tf.argmax(test_y, axis=1)

            test_cor = tf.equal(test_y, test_out)
            test_cor = tf.cast(test_cor, dtype=tf.float32)
            test_cor = tf.reduce_sum(test_cor)
            correct += test_cor
            total += x.shape[0]

        print('testing acc is : ', correct / total)
        test_tot_loss.append(correct / total)

    plt.figure()
    plt.plot(train_tot_loss, 'b', label='train')
    plt.plot(test_tot_loss, 'r', label='test')
    plt.xlabel('Epoch')
    plt.ylabel('ACC')
    plt.legend()
    # plt.savefig('exam8.3_train_test_CNN1.png')
    plt.show()


if __name__ == "__main__":
    main()

注释：

（1）由于笔记本配置的原因，程序没有跑完，今后有合适的机器再跑；

（2）对CIFAR数据集的理解不够！需要进一步加深；

（3）下次更新ResNet18网络与CIFAR10数据集实战。

 2020.5.16 --------更新------

（1）采用谷歌CoLab在线跑代码，解决了机器配置不足的问题

训练和测试结果如下：

最后测试准确率到78.95%，与书上77.5%近似。