卷积神经网络(CNN)实现CIFAR100类别分类

卷积神经网络(CNN)实现CIFAR100类别分类 1. CIFAR100数据集介绍

这个数据集就像CIFAR-10，除了它有100个类，每个类包含600个图像。，每类各有500个训练图像和100个测试图像。CIFAR-100中的100个类被分成20个超类。每个图像都带有一个“精细”标签（它所属的类）和一个“粗糙”标签（它所属的超类） 以下是CIFAR-100中的类别列表：

等等...

2. API 使用

• 用于构建CNN模型的API
  • Conv2D：实现卷积，kernel_size,strides,padding,dataformat,'NHWC'和'NCHW'
  • MaxPool2D：池化操作

keras.layers.Conv2D(32, kernel_size=5, strides=1,
                            padding='same', data_format='channels_last', activation=tf.nn.relu),
        keras.layers.MaxPool2D(pool_size=2, strides=2, padding='same'),

【在池化层写入padding='same'不起作用，不会保留原来的大小，仍然会根据前面的pool_size和stride改变之前形状的大小】

3. 步骤分析以及代码实现(缩减版LeNet5)

• 读取数据集:
  • 从datasets中获取相应的数据集，直接有训练集和测试集
  • 需要进行形状处理以及归一化

class CNNMnist(object):
    def __init__(self):

        (self.train, self.train_label), (self.test, self.test_label) = \
            keras.datasets.cifar100.load_data()

        self.train = self.train.reshape(-1, 32, 32, 3) / 255.0
        self.test = self.test.reshape(-1, 32, 32, 3) / 255.0

• 进行模型编写

  • 两层卷积层+两个神经网络层
  • 网络设计：

• 第一层

  • 卷积：32个filter、大小5*5、strides=1、padding="SAME"
  • 激活：Relu
  • 池化：大小2x2、strides2
• 第二层
  • 卷积：64个filter、大小5*5、strides=1、padding="SAME"
  • 激活：Relu
  • 池化：大小2x2、strides2
• 全连接层

经过每一层图片数据大小的变化需要确定，CIFAR100输入的每批次若干图片数据大小为[None, 32 * 32]，如果要进过卷积计算，需要变成[None, 32, 32, 3]

• 第一层
  • 卷积：[None, 32, 32, 3]———>[None, 32, 32, 32]
    • 权重数量：[5, 5, 3 ,32]
    • 偏置数量：[32]
  • 激活：[None, 32, 32, 32]———>[None, 32, 32, 32]
  • 池化：[None, 32, 32, 32]———>[None, 16, 16, 32]
• 第二层
  • 卷积：[None, 16, 16, 32]———>[None, 16, 16, 64]
    • 权重数量：[5, 5, 32 ,64]
    • 偏置数量：[64]
  • 激活：[None, 16, 16, 64]———>[None, 16, 16, 64]
  • 池化：[None, 16, 16, 64]———>[None, 8, 8, 64]
• 全连接层
  • [None, 8, 8, 64]——>[None, 8 8 64]
  • [None, 8 8 64] x [8 8 64, 1024] = [None, 1024]
  • [None,1024] x [1024, 100]——>[None, 100]
  • 权重数量：[8 8 64, 1024] + [1024, 100]，由分类别数而定
  • 偏置数量：[1024] + [100]，由分类别数而定

model = keras.Sequential([
        keras.layers.Conv2D(32, kernel_size=5, strides=1,
                            padding='same', data_format='channels_last', activation=tf.nn.relu),
        keras.layers.MaxPool2D(pool_size=2, strides=2, padding='same'),
        keras.layers.Conv2D(64, kernel_size=5, strides=1,
                            padding='same', data_format='channels_last', activation=tf.nn.relu),
        keras.layers.MaxPool2D(pool_size=2, strides=2, padding='same'),
        keras.layers.Flatten(),
        keras.layers.Dense(1024, activation=tf.nn.relu),
        keras.layers.Dense(100, activation=tf.nn.softmax),
    ])

• 其它完整代码

 def compile(self):

        CNNMnist.model.compile(optimizer=keras.optimizers.Adam(),
                               loss=tf.keras.losses.sparse_categorical_crossentropy,
                               metrics=['accuracy'])
        return None

    def fit(self):

        CNNMnist.model.fit(self.train, self.train_label, epochs=1, batch_size=32)

        return None

    def evaluate(self):

        test_loss, test_acc = CNNMnist.model.evaluate(self.test, self.test_label)

        print(test_loss, test_acc)
        return None


if __name__ == '__main__':

    cnn = CNNMnist()

    cnn.compile()

    cnn.fit()

    cnn.predict()

    print(CNNMnist.model.summary())

全部示例代码：

import tensorflow as tf
from tensorflow.python.keras.datasets import cifar100
from tensorflow.python.keras.models import Sequential
from keras import losses, optimizers
from tensorflow.python.keras.layers import Flatten, Conv2D, MaxPool2D, Dense


class CNNMnist(object):
    """
    使用卷积神经网络实现CIFAR100类别分类
    """
    #  编写两层+两层全连接层网络模型
    model = Sequential([
        #  卷积层1：32个 5*5*3的filter，strides=1，padding="same"
        Conv2D(32, kernel_size=5, strides=1, padding="same", data_format="channels_last", activation=tf.nn.relu),
        #  池化层：2*2窗口，strides=2
        MaxPool2D(pool_size=2, strides=2, padding='same'),
        #  卷积层2：64个，5*5*32的filter，strides=1,padding="same"
        Conv2D(64, kernel_size=5, strides=1, padding='same', data_format='channels_last', activation=tf.nn.relu),
        #  池化层2：2*2窗口，strides=2，[None, 8,8,64]
        MaxPool2D(pool_size=2, strides=2, padding='same'),
        #  [None,8,8,64]  --- > [None, 8*8*64]
        Flatten(),  # 会有默认值的
        #  全连接层神经网络
        #  1024个神经元网络层
        Dense(1024, activation=tf.nn.relu),
        #  100个神经元神经网络
        Dense(100, activation=tf.nn.softmax)
    ])

    def __init__(self):
        #  获取训练测试数据
        (self.x_train, self.y_train), (self.x_test, self.y_test) = cifar100.load_data()
        print(self.x_train.shape)
        print(self.x_test.shape)
        print(self.y_train.shape)
        print(self.y_test.shape)

        #  进行数据归一化
        self.x_train = self.x_train / 255.0
        self.x_test = self.x_test / 255.0

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

        return None

    def fit(self):
        CNNMnist.model.fit(self.x_train, self.y_train, epochs=1, batch_size=32)

        return None

    def evaluate(self):
        test_loss, test_acc = CNNMnist.model.evaluate(self.x_test, self.y_test)
        print(test_loss, test_acc)

        return None


if __name__ == '__main__':
    cnn = CNNMnist()
    cnn.compile()
    cnn.fit()
    cnn.evaluate()

运行结果：

(50000, 32, 32, 3)
(10000, 32, 32, 3)
(50000, 1)
(10000, 1)
1563/1563 [==============================] - 67s 43ms/step - loss: 3.5395 - accuracy: 0.1694
313/313 [==============================] - 3s 9ms/step - loss: 2.9754 - accuracy: 0.2700
2.9753782749176025 0.27000001072883606