经典卷积神经网络--AlexNet的详解

╰+哭是因爲堅強的太久メ 2023-10-04 11:11 116阅读 0赞

## 一.AlexNet的概述 ##

AlexNet由Geoffrey和他的学生Alex提出，并在2012年的ILSVRC竞赛中获得了第一名。**Alexnet共有8层结构，前5层为卷积层，后三层为全连接层。**

AlexNet网络结构具有如下特点：

1.AlexNet在激活函数上选取了非线性非饱和的relu函数，在训练阶段梯度衰减快慢方面，relu函数比传统神经网络所选取的非线性饱和函数（如sigmoid函数，tanh函数）要快许多。

2.AlexNet在双gpu上运行，每个gpu负责一半网络的运算

3.采用局部响应归一化（LRN）。对于非饱和函数relu来说，不需要对其输入进行标准化，但Alex等人发现，在relu层加入LRN，可形成某种形式的横向抑制，从而提高网络的泛华能力。

4.池化方式采用overlapping pooling。即池化窗口的大小大于步长，使得每次池化都有重叠的部分。（ps:这种重叠的池化方式比传统无重叠的池化方式有着更好的效果，且可以避免过拟合现象的发生）

## 二.AlexNet网络结构 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTg3MzM5Nw_size_16_color_FFFFFF_t_70][]

**第一个卷积层**

输入的图片大小为:224\*224\*3，为后续处理方便，普遍改为227\*227\*3

第一个卷积层为:11\*11\*3即卷积核尺寸为11\*11,有96个卷积核,步长为4,卷积层后跟ReLU,因此输出的尺寸为 （227-11）/4+1=55,因此其输出的每个特征图 为 55\*55\*96,同时后面经过LRN层处理,尺寸不变.

最大池化层,池化核大小为3\*3,步长为2,输出的尺寸为 （55-3）/2+1=27，因此特征图的大小为:27\*27\*96。由于双gpu处理，故每组数据有27\*27\*48个特征图，共两组数据，分别在两个gpu中进行运算

**第二层卷积层**

每组输入的数据为27\*27\*48，共两组数据

每组数据都被128个卷积核大小为: 5\*5\*48进行卷积运算,步长为1,尺寸不会改变,同样紧跟ReLU,和LRN层进行处理.

最大池化层,核大小为3\*3,步长为2,因此输出两组特征图:13\*13\*128

**第三层至第五层卷积层**

输入的数据为13\*13\*128，共两组

第三层每组数据都被尺寸为 3\*3\*192的卷积核进行卷积运算,步长为1,加上ReLU，得到两组13\*13\*192的像素层

第四层经过padding=1填充后，每组数据都被尺寸大小为 3\*3\*192的卷积核卷积运算,步长为1,加上ReLU，输出两组13\*13\*192的像素层

第五层经过padding=1填充后，每组数据都被尺寸大小为 3\*3\*128的卷积核进行卷积运算,步长为1,加上ReLU，输出两组13\*13\*128的像素层

经过3\*3池化窗口，步长为2，池化后输出两组6\*6\*256的像素层

**第六层至第八层全连接层**

接下来的三层为全连接层,分别为:  
6层. 4096 个神经元+ ReLU  
7层. 4096个神经元 + ReLU  
8层. 1000 个神经元，最后一层为softmax为1000类的概率值.

## 三.AlexNet的代码实现 ##

**该代码是用搭建好的AlexNet网络来实现MNIST手写体数字的识别（采用keras框架）**

from keras.datasets import mnist
    from matplotlib import pyplot as plt
    from keras.utils import np_utils
    from keras.layers import Dense,Dropout,Flatten,Conv2D,MaxPool2D,BatchNormalization
    from keras.models import Sequential
    from matplotlib import pyplot as plt
    
    (X_train,Y_train),(X_test,Y_test)=mnist.load_data()
    X_test1=X_test
    Y_test1=Y_test
    #处理图像特征
    X_train=X_train.reshape(-1,28,28,1).astype("float32")/255.0
    X_test=X_test.reshape(-1,28,28,1).astype("float32")/255.0
    #处理标签
    Y_train=np_utils.to_categorical(Y_train,10)
    Y_test=np_utils.to_categorical(Y_test,10)
    #print(X_train)
    #print("-----------")
    #print(Y_train)
    
    #搭建AlexNet网络模型
    #建立第一层卷积
    model=Sequential()
    model.add(Conv2D(
        filters=96,
        kernel_size=(11,11),
        strides=4,
        padding="same",
        input_shape=(28,28,1),
        activation="relu"
    ))
    
    #搭建BN层
    model.add(BatchNormalization())
    #搭建第一层重叠最大池化层
    model.add(MaxPool2D(
        pool_size=(3,3),
        strides=2,
        padding="same"
    ))
    
    #建立第二层卷积
    model.add(Conv2D(
        filters=256,
        kernel_size=(5,5),
        strides=1,
        padding="same",
        activation="relu"
    ))
    #搭建BN层
    model.add(BatchNormalization())
    #搭建第二层池化层
    model.add(MaxPool2D(
        pool_size=(3,3),
        strides=2,
        padding="same",
    ))
    
    #搭建第三层卷积
    model.add(Conv2D(
        filters=384,
        kernel_size=(3,3),
        strides=1,
        padding="same",
        activation="relu",
    ))
    
    #搭建第四层卷积
    model.add(Conv2D(
        filters=384,
        kernel_size=(3,3),
        strides=1,
        padding="same",
        activation="relu"
    ))
    
    #搭建第五卷积层
    model.add(Conv2D(
        filters=256,
        kernel_size=(3,3),
        strides=1,
        padding='same',
        activation="relu"
    ))
    model.add(MaxPool2D(
        pool_size=(3,3),
        strides=2,
        padding="same"
    ))
    
    #搭建第六层：全连接层
    #在搭建全连接层之前，必须使用Flatten()降维
    model.add(Flatten())
    #全连接层
    model.add(Dense(4096,activation="relu"))
    model.add(Dropout(0.5))
    #搭建第七层：全连接层
    model.add(Dense(2048,activation="relu"))
    model.add(Dropout(0.5))
    #搭建第八层：全连接层即输出层
    model.add(Dense(10,activation="softmax"))
    model.summary()
    
    #编译
    model.compile(
        loss="categorical_crossentropy",
        optimizer="sgd",
        metrics=["accuracy"]
    )
    
    #训练
    n_epoch=10
    n_batch=128
    training = model.fit(
        X_train,
        Y_train,
        epochs=n_epoch,
        batch_size=n_batch,
        verbose=1,
        validation_split=0.20
    )
    
    #画出准确率随着epoch的变化图
    def show_train(tr,train,validation):
        plt.plot(training.history[train],linestyle="-",color="b")
        plt.plot(training.history[validation],linestyle="--",color="r")
        plt.title("trianing_history")
        plt.xlabel("epoch")
        plt.ylabel("accuracy")
        plt.legend(["train","validation"],loc="lower right")
        plt.show()
    show_train(training,"accuracy","val_accuracy")
    #画出误差随着epoch的变化图
    def show_train(tr,train,validation):
        plt.plot(training.history[train],linestyle="-",color="b")
        plt.plot(training.history[validation],linestyle="--",color="r")
        plt.title("trianing_history")
        plt.xlabel("epoch")
        plt.ylabel("accuracy")
        plt.legend(["train","validation"],loc="upper right")
        plt.show()
    show_train(training,"loss","val_loss")
    
    #评估
    test=model.evaluate(X_train,Y_train,verbose=1)
    print("误差：",test[0])
    print("准确率：",test[1])
    
    #预测
    def image_show(image):  #画图
        fig=plt.gcf()
        fig.set_size_inches(2,2)
        plt.imshow(image,cmap="binary")
        plt.show()
    prediction=model.predict_classes(X_test)
    def pre_result(i):
        image_show(X_test1[i])
        print("Y-test:",Y_test1[i])
        print("预测值：",prediction[i])
    pre_result(0)
    pre_result(1)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTg3MzM5Nw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20181127165515227.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTg3MzM5Nw==,size_16,color_FFFFFF,t_70