深度学习入门（五）：经典网络Alexnet实现

介绍

AlexNet是一个深度卷积神经网络架构，于2010年代初在深度学习重新引起人们关注时发挥了重要作用。它因在2012年的ImageNet大规模视觉识别挑战（ILSVRC）中获胜而闻名。

实现

创建了一个AlexNet网络的实例，并将一个随机生成的输入张量（即一张随机的图像）传递给这个网络。随后，代码打印出通过该网络得到的输出张量，以及输出张量的大小。

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, ReLU


class Alexnet(nn.Module):
    # 定义了架构中使用的各个层
    def __init__(self, num_classes=1000):
        super().__init__()
        # out_channels:输出通道
        # kernel_size:内核大小
        # stride:步幅

        #input=3*227*227,ouput=96*55*55   (227-11)/4 + 1 = 55
        self.conv1 = Conv2d(in_channels=3, out_channels=96, kernel_size=11,stride=4)
        self.relu1 = ReLU(inplace=True)

        #input 96*55*55  output=96*27*27
        self.pool1 = MaxPool2d(kernel_size=3, stride=2)

        #input=96*27*27  output=256*27*27
        self.conv2 = Conv2d(in_channels=96, out_channels=256, kernel_size=5,
                            padding=2,stride=1)
        self.relu2 = ReLU(inplace=True)
        #input=256*27*27 output=256*13*13
        self.pool2 = MaxPool2d(kernel_size=3, stride=2)

        #input=256*13*13   output=384*13*13
        self.conv3 = Conv2d(in_channels=256, out_channels=384, kernel_size=3, padding=1,
                            stride=1)
        self.relu3 = ReLU(inplace=True)
        #input=384*13*13  output=384*13*13
        self.conv4 = Conv2d(in_channels=384, out_channels=384, kernel_size=3,
                            padding=1,stride=1)
        self.relu4 = ReLU(inplace=True)

        #input=384*13*13  output= 256*13*13
        self.conv5 = Conv2d(in_channels=384, out_channels=256, kernel_size=3, padding=1)
        self.relu5 = ReLU(inplace=True)

        #input=256*13*13 output=256*6*6
        self.pool5 = MaxPool2d(kernel_size=3,stride=2)

        # 全连接层
        self.fc1 = nn.Linear(in_features=256*6*6, out_features=4096)
        self.fc2 = nn.Linear(in_features=4096, out_features=4096)
        self.fc3 = nn.Linear(in_features=4096, out_features=num_classes)

    # 网络的前向传播，按顺序将定义的层应用于输入数据
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.pool1(x)

        x = self.conv2(x)
        x = self.relu2(x)
        x = self.pool2(x)

        x = self.conv3(x)
        x = self.relu3(x)

        x = self.conv4(x)
        x = self.relu4(x)

        x = self.conv5(x)
        x = self.relu5(x)
        x = self.pool5(x)

        x = x.view(-1, 256*6*6)
        x = self.fc1(x)
        x = self.fc2(x)
        x = self.fc3(x)
        return x

if __name__ == '__main__':
    net = Alexnet(num_classes=1000)
    # print(net)
    # 随机生成输入张量（一张随机的图像）
    x = torch.randn(20, 3, 227, 227)
    y3 = net(x)
    print("y3的维度是:{}".format(y3.size()))
    print(y3)

# y3的维度是:torch.Size([20, 1000])
# 20表示批量中的图像数量，1000表示每个图像的预测类别分数。这是因为你同时将20张图像输入网络，所以输出是20个预测结果的向量。

输出

20表示批量中的图像数量，1000表示每个图像的预测类别分数。同时将20张图像输入网络，所以输出是20个预测结果的向量。