卷积神经网络-AlexNet

75 阅读 0 评论 50 点赞

我是靠谱客的博主可爱大象，最近开发中收集的这篇文章主要介绍卷积神经网络-AlexNet，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

AlexNet网络共8层，5层卷积层，3层全连接。

1. C1卷积层：卷积-ReLU-pool-BN

（1）卷积

输入大小：227*227*3

卷积核大小：11*11*3

卷积核数量：96

padding:0

卷积后输出大小：55*55*48*2 #（227-11）/4+1

（2）非线性变换

（3）池化

输入大小：55*55*48*2

卷积核大小：3*3

stride步长：2

输出大小：27*27*48*2 #（55-3）/2+1=27

（4）BN局部归一化：使用k=2,n=5,α=10−4,β=0.75进行局部归一化，输出分为两组，每组的大小为27×27×48

2. C2卷积层：卷积-ReLU-pool-BN

（1）卷积（两组27×27×48）

输入大小：27×27×48*2

卷积核大小：5*5*48*2

卷积核数量：128

padding:2

stride步长：1

卷积后输出大小：27*27*128*2 #（27-5+2*2）/1+1

（2）非线性变换

（3）池化

输入大小：27*27*128*2

卷积核大小：3*3

stride步长：2

输出大小：13*13*128*2 #（27-3）/2+1=13

（4）BN局部归一化：使用k=2,n=5,α=10−4,β=0.75进行局部归一化，输出分为两组，每组的大小为13*13*128

3. C3卷积层：卷积-ReLU

（1）卷积（两组13*13*128）

输入大小：13*13*128*2

卷积核大小：3×3×128*2

卷积核数量：192

padding:1

stride步长：1

卷积后输出大小：13*13*192*2 #（13-3+2*1）/1+1

（2）非线性变换

4. C4卷积层：卷积-ReLU

（1）卷积（两组13*13*192*2）

输入大小：13*13*192*2

卷积核大小：3×3×192*2

卷积核数量：192

padding:1

stride步长：1

卷积后输出大小：13*13*192*2 #（13-3+2*1）/1+1

（2）非线性变换

5. C5卷积层：卷积-ReLU

（1）卷积（13*13*192*2）

输入大小：13*13*192*2

卷积核大小：3×3×192

卷积核数量：128

padding:1

stride步长：1

卷积后输出大小：13*13*128*2 #（13-3+2*1）/1+1

（2）非线性变换

（3）池化：

输入大小：13*13*128*2

卷积核大小：3*3

stride步长：2

输出大小：6*6*128*2 #（13-3）/2+1=13

6. FC6：（卷积）全连接 -ReLU -Dropout

输入大小：6*6*128*2

卷积核大小：6*6*2*128

卷积核数量：4096

输出大小：4096*1

7. FC7：（卷积）全连接 -ReLU -Dropout

输入大小：6*6*128*2

输出大小：4096*1

8. 输出层：

输入大小：6*6*128*2

输出大小：4096*1

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self, num_class):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, 2),
            
            nn.Conv2d(96, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, 2),
            
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),# inplace-选择是否进行覆盖运算
            
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),# inplace-选择是否进行覆盖运算
            
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),# inplace-选择是否进行覆盖运算
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(256*6*6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_class)
        
        )
        
        def forward(self, x):
            x = self.features(x)
            x = x.view(x.size(0), 256*6*6)
            x = self.classifier(x)
            return x
        
model = AlexNet(1000)
print(model)