PyTorch实现：经典网络 AlexNet

最新推荐文章于 2024-09-10 10:03:08 发布

峡谷的小鱼

最新推荐文章于 2024-09-10 10:03:08 发布

阅读量2k

点赞数 4

分类专栏： PyTorch使用经典深度模型文章标签： pytorch 神经网络深度学习人工智能机器学习

本文链接：https://blog.csdn.net/weixin_43276033/article/details/124520338

版权

PyTorch使用同时被 2 个专栏收录

21 篇文章 1 订阅

订阅专栏

经典深度模型

6 篇文章 0 订阅

订阅专栏

本文详细介绍了AlexNet网络的结构和工作原理，包括卷积、池化、ReLU激活函数等组件，以及其在图像处理领域的应用。网络通过多层卷积和全连接层进行特征学习，并使用Dropout缓解过拟合。最后，给出了AlexNet的PyTorch实现代码。

摘要由CSDN通过智能技术生成

PyTorch实现：经典网络 AlexNet

1. AlexNet 网络介绍

卷积神经网络从诞生之处就是为图像处理，直接原始图像的像素数据简单处理作为模型的输入的。而传统的神经网络和其它机器学习方法不会这样做，而是在图像数据进入模型之前，需要经过人手工精心设计特征提取方法，最后将提取的特征再作为模型的输入。
在卷积神经网络出现的早期，由于计算设备的原因，能用于训练的数据想对较少，而且有因为大型的卷积神经网络的大量参数，导致模型很难被有效训练。因此，在很长一段时间，神经网络都落后于其它的机器学习方法。
传统的机器学习方法，在收集到数据集之后，需要使用光学、几何学等领域的知识来指导手工对数据的预处理，然后通过标准的特征提取算法获取特征，最后将提取的特征送入选择的分类器中。随着技术的发展，另一种想法开始出现：特征的提取本身，也应该由模型通过学习来提取；特征可以有多个神经网络层来共同学习。由此，诞生的 AlexNet 最终使得卷积神经网络开始在图像领域超越其它机器学习方法。

2. AlexNet 网络架构

网络支持的输入的尺寸为：3×224×224。

2.1 特征提取网络

2.1.1 `Conv2d(3, 96, kernel_size=11, stride=4, padding=1)`

 使用一个11*11的卷积核窗口来捕捉对象，
 padding=1 边缘都向外扩充1，
 同时，步幅为4，以减少输出的高度和宽度，
 最后，在尺寸减小的同时，增加输出通道的数目。

Conv2d output shape: torch.Size([1, 96, 54, 54])

2.1.2 `nn.ReLU()`

使用 ReLU 激活函数，一方面，ReLU激活函数的计算更简单，它不需要如sigmoid激活函数那般复杂的求幂运算。另一方面，当使用不同的参数初始化方法时，ReLU激活函数使训练模型更加容易。当sigmoid激活函数的输出非常接近于0或1时，这些区域的梯度几乎为0，因此反向传播无法继续更新一些模型参数。相反，ReLU激活函数在正区间的梯度总是1。因此，如果模型参数没有正确初始化，sigmoid函数可能在正区间内得到几乎为0的梯度，从而使模型无法得到有效的训练。

ReLU output shape: torch.Size([1, 96, 54, 54])

2.1.3 `nn.MaxPool2d(kernel_size=3, stride=2)`

最大池化，使用 3*3 的窗口，步幅为2。

MaxPool2d output shape: torch.Size([1, 96, 26, 26])

2.1.4 `nn.Conv2d(96, 256, kernel_size=5, padding=2)`

 使用一个 5*5 的卷积核窗口来捕捉对象，
 padding=2 边缘都向外扩充2，保持输出尺寸不变，
 最后，在尺寸减小的同时，增加输出通道的数目。

torch.Size([1, 256, 26, 26])

2.1.5 `nn.ReLU()`

使用 ReLU 激活函数。

ReLU output shape: torch.Size([1, 256, 26, 26])

2.1.6 `nn.MaxPool2d(kernel_size=3, stride=2)`

最大池化，使用 3*3 的窗口，步幅为2。

MaxPool2d output shape: torch.Size([1, 256, 12, 12])

2.1.7 `nn.Conv2d(256, 384, kernel_size=3, padding=1)`

 使用一个 3*3 的卷积核窗口来捕捉对象，
 padding=2 边缘都向外扩充2，保持输出尺寸不变，
 最后，在尺寸减小的同时，增加输出通道的数目。

Conv2d output shape: torch.Size([1, 384, 12, 12])

2.1.8 `nn.ReLU()`

使用 ReLU 激活函数。

ReLU output shape: torch.Size([1, 384, 12, 12])

2.1.9 `nn.Conv2d(384, 384, kernel_size=3, padding=1)`

 使用一个 3*3 的卷积核窗口来捕捉对象，
 padding=2 边缘都向外扩充2，保持输出尺寸不变，
 最后，保持输出通道的数目不变。

Conv2d output shape: torch.Size([1, 384, 12, 12])

2.1.10 `nn.ReLU()`

使用 ReLU 激活函数。

ReLU output shape: torch.Size([1, 384, 12, 12])

2.1.11 `nn.Conv2d384, 256, kernel_size=3, padding=1)`

 使用一个 3*3 的卷积核窗口来捕捉对象，
 padding=2 边缘都向外扩充2，保持输出尺寸不变，
 最后，降低输出通道的数目。

Conv2d output shape: torch.Size([1, 256, 12, 12])

2.1.12 `nn.ReLU()`

使用 ReLU 激活函数。

ReLU output shape: torch.Size([1, 256, 12, 12])

2.1.13 `nn.MaxPool2d(kernel_size=3, stride=2)`

最大池化，使用 3*3 的窗口，步幅为2。

MaxPool2d output shape: torch.Size([1, 256, 5, 5])

2.1.14 `nn.Flatten()`

展开为一维特征。

Flatten output shape: torch.Size([1, 6400])

2.2 分类器

2.2.1 `nn.Linear(6400, 4096),`

线性层。

Linear output shape: torch.Size([1, 4096])

2.2.2 `nn.ReLU()`

使用 ReLU 激活函数。

ReLU output shape: torch.Size([1, 4096])

2.2.3 `nn.Dropout(p=0.5)`

连接层的输出数量很高，使用dropout层来减轻过拟合。

Dropout output shape: torch.Size([1, 4096])

2.2.4 `nn.Linear(4096, 4096)`

线性层。

Linear output shape: torch.Size([1, 4096])

2.2.5 `nn.ReLU()`

使用 ReLU 激活函数。

ReLU output shape: torch.Size([1, 4096])

2.2.6 `nn.Dropout(p=0.5)`

连接层的输出数量很高，使用dropout层来减轻过拟合。

Dropout output shape: torch.Size([1, 4096])

2.2.7 `nn.Linear(4096, 10)`

输出层。

Linear output shape: torch.Size([1, 10])

3. AlexNet 网络实现

class AlexNet(nn.Module):
    
    def __init__(self, num_classes):
        super(AlexNet, self).__init__()
        self.feature_extr = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2), 

            nn.Conv2d(96, 256, kernel_size=5, padding=2),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2),

            nn.Conv2d(256, 384, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(384, 384, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2),

            nn.Flatten()
            
        )
        self.classifier = nn.Sequential(
            nn.Linear(6400, 4096), 
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(4096, num_classes)
        )

    def forward(self, x):
        x = self.feature_extr(x)
        x = self.classifier(x)
        return x