import torch
import torch.nn as nn
import torch.nn.functional as Fclass VGG16(nn.Module):def __init__(self):super(VGG16, self).__init__()#输入图片大小为：3 * 224 * 224    self.conv1_1 = nn.Conv2d(3, 64, 3) # 64 * 222 * 222                               (224 - 3 + 2*0)/1 + 1 = 222      self.conv1_2 = nn.Conv2d(64, 64, 3, padding=(1, 1)) # 64 * 222* 222               (222 - 3 + 2*1)/1 + 1 = 222self.maxpool1 = nn.MaxPool2d((2, 2), padding=(1, 1)) # pooling 64 * 112 * 112     (222 - 2 + 2*1)/2 + 1 = 112self.conv2_1 = nn.Conv2d(64, 128, 3) # 128 * 110 * 110                            (112 - 3 + 2*0)/1 + 1 =110self.conv2_2 = nn.Conv2d(128, 128, 3, padding=(1, 1)) # 128 * 110 * 110           (110 - 3 + 2*1)/1 + 1 =110self.maxpool2 = nn.MaxPool2d((2, 2), padding=(1, 1)) # pooling 128 * 56 * 56      (110 - 2 + 2*1)/2 + 1 = 56self.conv3_1 = nn.Conv2d(128, 256, 3) # 256 * 54 * 54                             (56 - 3 + 2*0)/1 + 1 = 54self.conv3_2 = nn.Conv2d(256, 256, 3, padding=(1, 1)) # 256 * 54 * 54             (54 - 3 + 2*1)/1 + 1 = 54self.conv3_3 = nn.Conv2d(256, 256, 3, padding=(1, 1)) # 256 * 54 * 54             (54 - 3 + 2*1)/1 + 1 = 54self.maxpool3 = nn.MaxPool2d((2, 2), padding=(1, 1)) # pooling 256 * 28 * 28      (54 - 2 + 2*1)/2 + 1 = 28self.conv4_1 = nn.Conv2d(256, 512, 3) # 512 * 26 * 26                             (28 - 3 + 2*0)/1 + 1 = 26self.conv4_2 = nn.Conv2d(512, 512, 3, padding=(1, 1)) # 512 * 26 * 26             (26 - 3 + 2*1)/1 + 1 = 26self.conv4_3 = nn.Conv2d(512, 512, 3, padding=(1, 1)) # 512 * 26 * 26             (26 - 3 + 2*1)/1 + 1 = 26self.maxpool4 = nn.MaxPool2d((2, 2), padding=(1, 1)) # pooling 512 * 14 * 14      (26 - 2 + 2*1)/2 + 1 = 14self.conv5_1 = nn.Conv2d(512, 512, 3) # 512 * 12 * 12                             (14 - 3 + 2*0)/1 + 1 = 12self.conv5_2 = nn.Conv2d(512, 512, 3, padding=(1, 1)) # 512 * 12 * 12             (12 - 3 + 2*1)/1 + 1 = 12 self.conv5_3 = nn.Conv2d(512, 512, 3, padding=(1, 1)) # 512 * 12 * 12             (12 - 3 + 2*1)/1 + 1 = 12self.maxpool5 = nn.MaxPool2d((2, 2), padding=(1, 1)) # pooling 512 * 7 * 7        (12 - 2 + 2*1)/2 + 1 =7# viewself.fc1 = nn.Linear(512 * 7 * 7, 4096)    #512 * 7 * 7 = 25088 ————> 4096self.fc2 = nn.Linear(4096, 4096)           #4096 ————> 4096self.fc3 = nn.Linear(4096, 1000)           #4096 ————> 1000# softmax 1 * 1 * 1000def forward(self, x):# x.size(0)即为batch_sizein_size = x.size(0)out = self.conv1_1(x) # 222out = F.relu(out)out = self.conv1_2(out) # 222out = F.relu(out)out = self.maxpool1(out) # 112out = self.conv2_1(out) # 110out = F.relu(out)out = self.conv2_2(out) # 110out = F.relu(out)out = self.maxpool2(out) # 56out = self.conv3_1(out) # 54out = F.relu(out)out = self.conv3_2(out) # 54out = F.relu(out)out = self.conv3_3(out) # 54out = F.relu(out)out = self.maxpool3(out) # 28out = self.conv4_1(out) # 26out = F.relu(out)out = self.conv4_2(out) # 26out = F.relu(out)out = self.conv4_3(out) # 26out = F.relu(out)out = self.maxpool4(out) # 14out = self.conv5_1(out) # 12out = F.relu(out)out = self.conv5_2(out) # 12out = F.relu(out)out = self.conv5_3(out) # 12out = F.relu(out)out = self.maxpool5(out) # 7# 展平out = out.view(in_size, -1)out = self.fc1(out)out = F.relu(out)out = self.fc2(out)out = F.relu(out)out = self.fc3(out)out = F.log_softmax(out, dim=1)return out

1. 输入图像尺寸为224x224x3，经64个通道为3的3x3的卷积核，步长为1，padding=same填充，卷积两次，再经ReLU激活，输出的尺寸大小为224x224x64
2. 经max pooling（最大化池化），滤波器为2x2，步长为2，图像尺寸减半，池化后的尺寸变为112x112x64
3. 经128个3x3的卷积核，两次卷积，ReLU激活，尺寸变为112x112x128
4. max pooling池化，尺寸变为56x56x128
5. 经256个3x3的卷积核，三次卷积，ReLU激活，尺寸变为56x56x256
6. max pooling池化，尺寸变为28x28x256
7. 经512个3x3的卷积核，三次卷积，ReLU激活，尺寸变为28x28x512
8. max pooling池化，尺寸变为14x14x512
9. 经512个3x3的卷积核，三次卷积，ReLU，尺寸变为14x14x512
10. max pooling池化，尺寸变为7x7x512
11. 然后view()，将数据拉平成向量，变成一维51277=25088。
12. 再经过两层1x1x4096，一层1x1x1000的全连接层（共三层），经ReLU激活
13. 最后通过softmax输出1000个预测结果