1998-2015经典卷积神经网络简介

网络索引：

1.LeNet - 1998
2.AlexNet - 2012
3.VGGNet - 2014
4.InceptionNet- 2014
5.ResNet- 2015

---

1.LeNet - 1998

简介：Yann LeCun在1998年提出，是始祖卷积网络

特点：通过共享卷积核减少了网络的参数

网络模型 ↓

class LeNet5(tf.keras.Model):
    def __init__(self):
        '''
        LeNet神经网络模型
        CP CP FLATTEN F F F 
        '''
        super(LeNet5, self).__init__()

        # 6个5*5的卷积核，不保持图片大小，采用sigmoid激活
        self.c1 = tf.keras.layers.Conv2D(filters=6, kernel_size=(5, 5), activation="sigmoid")
        # 2*2的最大池化层，步长为2
        self.p1 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2)
        # 16个5*5的卷积核，不保持图片大小，采用sigmoid激活
        self.c2 = tf.keras.layers.Conv2D(filters=16, kernel_size=(5, 5), activation='sigmoid')
        # 2*2的最大池化层，步长为2
        self.p1 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2)

        # 将参数拉直成一维数组
        self.flatten = tf.keras.layers.Flatten()
        # 120个神经元的全连接层，sigmoid激活
        self.f1 = tf.keras.layers.Dense(120, activation='sigmoid')
        # 84个神经元的全连接层，sigmoid激活
        self.f2 = tf.keras.layers.Dense(84, activation='sigmoid')
        # 10个神经元的全连接层，softmax激活
        self.f3 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, x):
        '''
        call函数执行一遍反向传播
        :param x:
        :return:
        '''
        x = self.c1(x)
        x = self.p1(x)

        x = self.c2(x)
        x = self.p2(x)

        x = self.flatten(x)
        x = self.f1(x)
        x = self.f2(x)
        y = self.f3(x)
        return y

---

2.AlexNet - 2012

简介：AlexNet诞生于2012年，是当年ImageNet竞赛的冠军，Top5错误率为16.4%

特点：使用relu激活函数提升了训练速度，使用Dropout缓解了过拟合

网络模型 ↓

class AlexNet8(tf.keras.Model):
    def __init__(self):
        '''
        神经网络模型
        CBAP CBAP C C CP FLATTEN FD FD F
        '''
        super(AlexNet8, self).__init__()

        # 96个3*3的卷积核，不保持图片大小
        self.c1 = tf.keras.layers.Conv2D(filters=96, kernel_size=(3, 3))
        # 标准化处理 输出值以0为均值1为标准差
        self.b1 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a1 = tf.keras.layers.Activation('relu')
        # 3*3的最大池化层，步长为2
        self.p1 = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=2)

        # 256个3*3的卷积核，不保持图片大小
        self.c2 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3))
        # 标准化处理 输出值以0为均值1为标准差
        self.b2 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a2 = tf.keras.layers.Activation('relu')
        # 3*3的最大池化层，步长为2
        self.p2 = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=2)

        # 384个3*3的卷积核，保持图片大小，采用relu激活
        self.c3 = tf.keras.layers.Conv2D(filters=384, kernel_size=(3, 3), padding='same', activation='relu')

        # 384个3*3的卷积核，保持图片大小，采用relu激活
        self.c4 = tf.keras.layers.Conv2D(filters=384, kernel_size=(3, 3), padding='same', activation='relu')

        # 256个3*3的卷积核，保持图片大小，采用relu激活
        self.c5 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same', activation='relu')

        # 3*3的最大池化层，步长为2
        self.p3 = tf.keras.layers.MaxPool2D(pool_size=(3, 3), strides=2)

        # 将参数拉直成一维数组
        self.flatten = tf.keras.layers.Flatten()
        # 120个神经元的全连接层，relu激活
        self.f1 = tf.keras.layers.Dense(2048, activation='relu')
        # 舍弃一半神经元
        self.d1 = tf.keras.layers.Dropout(0.5)
        # 84个神经元的全连接层，relu激活
        self.f2 = tf.keras.layers.Dense(2048, activation='relu')
        # 舍弃一半神经元
        self.d2 = tf.keras.layers.Dropout(0.5)
        # 10个神经元的全连接层，softmax激活
        self.f3 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, x):
        '''
        call函数执行一遍反向传播
        :param x:
        :return:
        '''
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)
        x = self.p1(x)

        x = self.c2(x)
        x = self.b2(x)
        x = self.a2(x)
        x = self.p2(x)

        x = self.c3(x)

        x = self.c4(x)

        x = self.c5(x)

        x = self.p3(x)

        x = self.flatten(x)
        x = self.f1(x)
        x = self.d1(x)
        x = self.f2(x)
        x = self.d2(x)
        y = self.f3(x)
        return y

---

3.VGGNet - 2014

简介：VGGNet诞生于2014年，是当年ImageNet竞赛的亚军，Top5错误率减小到了7.3%

特点：减少参数的同时提高了识别准确率，VGG网络结构规整，非常适合硬件加速

网络模型 ↓

class VGGNet16(tf.keras.Model):
    def __init__(self):
        '''
        神经网络模型
        CBA CBAPD CBA CBAPD CBA CBA CBAPD CBA CBA CBAPD CBA CBA CBAPD FLATTEN FD FD F
        '''
        super(VGGNet16, self).__init__()

        # 第一层 ----------------------------------------
        # 64个3*3的卷积核，保持图片大小
        self.c1 = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b1 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a1 = tf.keras.layers.Activation('relu')

        # 第二层 ----------------------------------------
        # 64个3*3的卷积核，保持图片大小
        self.c2 = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b2 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a2 = tf.keras.layers.Activation('relu')
        # 2*2的最大池化层，步长为2
        self.p1 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        # 舍弃20%参数
        self.d1 = tf.keras.layers.Dropout(0.2)

        # 第三层 ----------------------------------------
        # 128个3*3的卷积核，保持图片大小
        self.c3 = tf.keras.layers.Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b3 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a3 = tf.keras.layers.Activation('relu')

        # 第四层 ----------------------------------------
        # 128个3*3的卷积核，保持图片大小
        self.c4 = tf.keras.layers.Conv2D(filters=128, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b4 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a4 = tf.keras.layers.Activation('relu')
        # 2*2的最大池化层，步长为2
        self.p2 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        # 舍弃20%参数
        self.d2 = tf.keras.layers.Dropout(0.2)

        # 第五层 ----------------------------------------
        # 256个3*3的卷积核，保持图片大小
        self.c5 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b5 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a5 = tf.keras.layers.Activation('relu')

        # 第六层 ----------------------------------------
        # 256个3*3的卷积核，保持图片大小
        self.c6 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b6 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a6 = tf.keras.layers.Activation('relu')

        # 第七层 ----------------------------------------
        # 256个3*3的卷积核，保持图片大小
        self.c7 = tf.keras.layers.Conv2D(filters=256, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b7 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a7 = tf.keras.layers.Activation('relu')
        # 2*2的最大池化层，步长为2
        self.p3 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        # 舍弃20%参数
        self.d3 = tf.keras.layers.Dropout(0.2)

        # 第八层 ----------------------------------------
        # 512个3*3的卷积核，保持图片大小
        self.c8 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b8 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a8 = tf.keras.layers.Activation('relu')

        # 第九层 ----------------------------------------
        # 512个3*3的卷积核，保持图片大小
        self.c9 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b9 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a9 = tf.keras.layers.Activation('relu')

        # 第十层 ----------------------------------------
        # 512个3*3的卷积核，保持图片大小
        self.c10 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b10 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a10 = tf.keras.layers.Activation('relu')
        # 2*2的最大池化层，步长为2
        self.p4 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        # 舍弃20%参数
        self.d4 = tf.keras.layers.Dropout(0.2)

        # 第十一层 ----------------------------------------
        # 512个3*3的卷积核，保持图片大小
        self.c11 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b11 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a11 = tf.keras.layers.Activation('relu')

        # 第十二层 ----------------------------------------
        # 512个3*3的卷积核，保持图片大小
        self.c12 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b12 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a12 = tf.keras.layers.Activation('relu')

        # 第十三层 ----------------------------------------
        # 512个3*3的卷积核，保持图片大小
        self.c13 = tf.keras.layers.Conv2D(filters=512, kernel_size=(3, 3), padding='same')
        # 标准化处理 输出值以0为均值1为标准差
        self.b13 = tf.keras.layers.BatchNormalization()
        # relu激活层
        self.a13 = tf.keras.layers.Activation('relu')
        # 2*2的最大池化层，步长为2
        self.p5 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same')
        # 舍弃20%参数
        self.d5 = tf.keras.layers.Dropout(0.2)

        # 拉直参数
        self.flatten = tf.keras.layers.Flatten()

        # 第十四层 ----------------------------------------
        # 512个神经元的全连接层，relu激活
        self.f1 = tf.keras.layers.Dense(512, activation='relu')
        # 舍弃20%参数
        self.d6 = tf.keras.layers.Dropout(0.2)

        # 第十五层 ----------------------------------------
        # 512个神经元的全连接层，relu激活
        self.f2 = tf.keras.layers.Dense(512, activation='relu')
        # 舍弃20%参数
        self.d7 = tf.keras.layers.Dropout(0.2)

        # 第十六层 ----------------------------------------
        # 10个神经元的全连接层，softmax输出
        self.f3 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, x):
        '''
        call函数执行一遍反向传播
        :param x:
        :return:
        '''
        x = self.c1(x)
        x = self.b1(x)
        x = self.a1(x)

        x = self.c2(x)
        x = self.b2(x)
        x = self.a2(x)
        x = self.p1(x)
        x = self.d1(x)

        x = self.c3(x)
        x = self.b3(x)
        x = self.a3(x)

        x = self.c4(x)
        x = self.b4(x)
        x = self.a4(x)
        x = self.p2(x)
        x = self.d2(x)

        x = self.c5(x)
        x = self.b5(x)
        x = self.a5(x)

        x = self.c6(x)
        x = self.b6(x)
        x = self.a6(x)

        x = self.c7(x)
        x = self.b7(x)
        x = self.a7(x)
        x = self.p3(x)
        x = self.d3(x)

        x = self.c8(x)
        x = self.b8(x)
        x = self.a8(x)

        x = self.c9(x)
        x = self.b9(x)
        x = self.a9(x)

        x = self.c10(x)
        x = self.b10(x)
        x = self.a10(x)
        x = self.p4(x)
        x = self.d4(x)

        x = self.c11(x)
        x = self.b11(x)
        x = self.a11(x)

        x = self.c12(x)
        x = self.b12(x)
        x = self.a12(x)

        x = self.c13(x)
        x = self.b13(x)
        x = self.a13(x)
        x = self.p5(x)
        x = self.d5(x)

        x = self.flatten(x)
        
        x = self.f1(x)
        x = self.d6(x)
        
        x = self.f2(x)
        x = self.d7(x)
        
        y = self.f3(x)
        return y

---

4.InceptionNet - 2014

简介：InceptionNet 也是诞生于2014，是当年ImageNet竞赛冠军，Top5错误率为6.67%

特点：InceptionNet 引入了Inception 结构快，在同一层网络内使用不同尺寸的卷积核，提升了模型感知力，使用了批标准化缓解了梯度消失

网络模型 ↓

更新中---

---

5.ResNet - 2015

简介：InceptionNet 诞生于2015，是当年ImageNet竞赛冠军，Top5错误率为3.57%

特点：ResNet 提出了层间残差跳连，引入了前方信息，缓解了梯度消失，使神经网络层数增加成为可能

网络模型 ↓

更新中---

---