tensorflow 2.0 学习 （十三）卷积神经网络 （三） CIFAR10数据集与修改的ResNet18网络 + CoLab

ResNet网络结构如下：

采用模型和数据分离的代码方式，模型如下：

# encoding: utf-8
import tensorflow as tf
from tensorflow.keras import optimizers, datasets, Model, layers, Sequential, losses
from tensorflow.keras.layers import Conv2D, Dense, add, BatchNormalization, GlobalAveragePooling2D
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.
    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


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, 32, 32, 3) (128, 10)
# tf.Tensor(0.0, shape=(), dtype=float32) tf.Tensor(1.0, shape=(), dtype=float32)
# ----------------------


# Net ------------------------
class ResNet(Model):
    def __init__(self):
        super(ResNet, self).__init__()
        self.conv1 = Sequential([
            Conv2D(64, kernel_size=3, strides=1, padding='same', activation='relu')
        ])
        self.conv2 = Sequential([
            Conv2D(64, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(64, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization()
        ])
        self.conv3 = Sequential([
            Conv2D(64, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(64, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization()
        ])
        self.conv4 = Sequential([
            Conv2D(128, kernel_size=3, strides=2, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(128, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization()
        ])
        self.conv5 = Sequential([
            Conv2D(128, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(128, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization()
        ])
        self.conv6 = Sequential([
            Conv2D(256, kernel_size=3, strides=2, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(256, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization(),
        ])
        self.conv7 = Sequential([
            Conv2D(256, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(256, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization()
        ])
        self.conv8 = Sequential([
            Conv2D(512, kernel_size=3, strides=2, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(512, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization()
        ])
        self.conv9 = Sequential([
            Conv2D(512, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization(),
            Conv2D(512, kernel_size=3, strides=1, padding='same', activation='relu'),
            BatchNormalization()
        ])

        self.avgPool = GlobalAveragePooling2D()

        self.fc10 = Dense(10)

        self.conv_128 = Conv2D(128, kernel_size=1, strides=2, padding='same', activation='relu')
        self.conv_256 = Conv2D(256, kernel_size=1, strides=2, padding='same', activation='relu')
        self.conv_512 = Conv2D(512, kernel_size=1, strides=2, padding='same', activation='relu')

    def call(self, inputs):
        layer1 = self.conv1(inputs)
        layer2 = self.conv2(layer1)
        layer_one = add([layer1, layer2])

        layer3 = self.conv3(layer_one)
        layer_two = add([layer_one, layer3])

        layer4 = self.conv4(layer_two)
        layer4_1 = self.conv_128(layer_two)
        layer_thi = add([layer4, layer4_1])

        layer5 = self.conv5(layer_thi)
        layer6 = self.conv6(layer5)
        layer6_1 = self.conv_256(layer5)
        layer_fou = add([layer6, layer6_1])

        layer7 = self.conv7(layer_fou)
        layer8 = self.conv8(layer7)
        layer8_1 = self.conv_512(layer7)
        layer_fiv = add([layer8, layer8_1])

        layer9 = self.conv9(layer_fiv)
        layer9_1 = self.avgPool(layer9)
        layer10 = self.fc10(layer9_1)

        return layer10
# --------------------------


def main():
    model = ResNet()
    model.build(input_shape=(None, 32, 32, 3))
    model.summary()

    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 = model(x)  # (128, 10)

                # calculate loss
                y = tf.cast(y, dtype=tf.float32)
                loss = criteon(y, out)

                variables = model.trainable_variables
                grads = tape.gradient(loss, variables)
                optimizer.apply_gradients(zip(grads, variables))

                # train var
                train_out = tf.nn.softmax(out, 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 = model(x)

            # 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()

程序调试成功，没有训练，测试数据，

数据量太大，目前的机器不行，待有合适的时机再做预测。

下次更新：RNN网络实战IMDB数据集

2020.5.17 重新更新代码 用CoLab跑代码

训练效果：

预测效果在75%左右，但有小幅度的波动。