卷积神经网络-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)