详解AlexNet模型结构及其代码

ERROR~~~

于 2024-07-30 17:15:04 发布

阅读量326

点赞数 6

文章标签：深度学习神经网络机器学习 python 人工智能

本文链接：https://blog.csdn.net/qq_57283101/article/details/140797363

版权

AlexNet

模型结构

模型代码

import torch
import torch.nn as nn
from torchsummary import summary

class AlexNet(nn.Module):
        def __init__(self,num_classes):
            super(AlexNet, self).__init__()
            #第一层：卷积+ReLU+批次标准化+最大池化+随机失活
            self.conv1 = nn.Sequential(
                nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=0),
                nn.ReLU(inplace=True),
                nn.BatchNorm2d(96),
                nn.MaxPool2d(kernel_size=3, stride=2),
                nn.Dropout(0.5)
            )
            # 第二层：卷积+ReLU+批次标准化+最大池化+随机失活
            self.conv2 = nn.Sequential(
                nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),
                nn.ReLU(inplace=True),
                nn.BatchNorm2d(256),
                nn.MaxPool2d(kernel_size=3, stride=2),
                nn.Dropout(0.5)
            )
            # 第三层：卷积+ReLU+批次标准化
            self.conv3 = nn.Sequential(
                nn.Conv2d(256,384 , kernel_size=3, stride=1, padding=1),
                nn.ReLU(inplace=True),
                nn.BatchNorm2d(384),
            )
            # 第四层：卷积+ReLU+批次标准化
            self.conv4 = nn.Sequential(
                nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
                nn.ReLU(inplace=True),
                nn.BatchNorm2d(384),
            )
            # 第六层：卷积+ReLU+批次标准化+最大池化+随机失活
            self.conv5 = nn.Sequential(
                nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
                nn.ReLU(inplace=True),
                nn.BatchNorm2d(256),
                nn.MaxPool2d(kernel_size=3, stride=2),
                nn.Dropout(0.5)
            )
            # 第七层：全连接+ReLU+批次标准化+随机失活
            self.fc1 = nn.Sequential(
                nn.Linear(6*6*256, 4096),
                nn.ReLU(inplace=True),
                nn.BatchNorm1d(4096),
                nn.Dropout(0.5)
            )
            # 第八层：全连接+ReLU+批次标准化+随机失活
            self.fc2 = nn.Sequential(
                nn.Linear(4096, 4096),
                nn.ReLU(inplace=True),
                nn.BatchNorm1d(4096),
                nn.Dropout(0.5)
            )
            # 第九层：全连接+ReLU
            self.fc3 = nn.Sequential(
                nn.Linear(4096, 1000),
                nn.ReLU(inplace=True),
            )
        def forward(self, x):
            out = self.conv1(x)
            out = self.conv2(out)
            out = self.conv3(out)
            out = self.conv4(out)
            out = self.conv5(out)
            out = torch.flatten(out, 1)#扁平化，将多维张量（out）展平为一维张量
            out = self.fc1(out)
            out = self.fc2(out)
            out = self.fc3(out)
            
net = AlexNet(num_classes = 1000)#实例化模型
summary(net, (3, 227, 227))#可视化模型

代码解释

self.conv1 = nn.Sequential(
                nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=0),
                nn.ReLU(inplace=True),
                nn.BatchNorm2d(96),
                nn.MaxPool2d(kernel_size=3, stride=2),
                nn.Dropout(0.5)
            )

1、Conv2d（）：3（输入通道数），96（输出通道数），kernel_size=11（卷积核大小），stride=4（卷积步长），padding=0（填充大小）。

注意：此处padding为什么等于0？

对于padding的计算，我们需要通过两个公式联立求解：

公式一（卷积求解）：

公式二（池化求解）：

未指定padding的情况下，默认为0

2、ReLU（）：inplace=True 是一个参数，用于指定是否在原地修改张量。使用 inplace=True 使得操作直接修改原始张量，而不是创建一个新的张量。这可以减少内存开销，因为不需要额外的内存来存储中间结果。但是如果需要保存操作前的中间结果（例如在计算梯度时），使 inplace=True 可能会导致问题，因为原始数据被覆盖，导致梯度计算不正确或计算图丢失。

3、BatchNorm2d(96)：参数默认为当前层的输出通道数。

4、Dropout(0.5)：0.5表示将随机选定的50%的神经元的输出置为0。

其余代码基本是重复上述所解释的代码，在此不再赘述！！