【pytorch】实现VGGNet 对照网络结构图手动编写

VGGNet最常见的VGG16，其特点是，除最后一层，每经过一个池化层，其特征图尺寸减半，通道加深一倍。其结构图为：

pytorch的代码为：

# This is a sample Python script.
import os.path
from typing import Iterator
import numpy as np
import torch
import cv2
from PIL import Image
from torch.utils.data import Dataset,DataLoader,Subset,random_split
import re
from functools import reduce
from torch.utils.tensorboard import SummaryWriter as Writer
from torchvision import transforms,datasets
import torchvision as tv
from torch import nn
import torch.nn.functional as F
import time

#可用pycharm中code中的generater功能实现：
class myCustomerVGGNet(nn.Module):
    #classNum为最后输出的分类数：
    def __init__(self,classNum):
        super().__init__()
        #一般将卷积层及全连接层分开构造，方便后期修改：
        self.classNum=classNum
        self.features=[]
        self.classifier=[]
        #开始进行循环构造：定义初始的输入及输出维度
        dim_in=3
        dim_out=64
        for layer in range(13):
            #inplace=True不占用新变量并节约内存
            self.features+=[nn.Conv2d(dim_in,dim_out,(3,3),(1,1)),nn.ReLU(inplace=True)]
            #输入输出的维度进行交换
            dim_in=dim_out
            #在第2，4..层后新增池化层并改变输出维度
            if (layer+1) in [2,4,7,10,13]:
                self.features += [nn.MaxPool2d(2)]
                #除10层外，输入通道加倍
                if (layer+1)!=10:
                   dim_out*=2
        #解析列表转化为层
        self.features =nn.Sequential(*self.features)
        #下面构造分类用的全连接层：
        self.classifier=nn.Sequential(nn.Linear(512*7*7,4096),nn.ReLU(inplace=True),nn.Dropout(),
                                       nn.Linear(4096,4096),nn.ReLU(inplace=True),nn.Dropout(),
                                       nn.Linear(4096,self.classNum))
    def forward(self,x):
        x=self.features(x)
        #原始第一维是批数，用此函数将向量拉平
        x.view(x.size(0),-1)
        return self.classfired(self.features(x))

myNet=myCustomerVGGNet(20)
print(myNet)

输出结果：

myCustomerVGGNet(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=20, bias=True)
  )
)

Process finished with exit code 0