VGG16
from torch import nn
class VGG(nn.Module):
""" 一共6个版本，最常用VGG16
VGG采用五组卷积，三个全连接，最后用Softmax分类
VGG显著特点：每次经过池化层maxpool后特征图尺寸减小一倍，，通道数增加一倍（最后一个池化层除外）"""
def __init__(self, num_classes=1000):
super(VGG, self).__init__()
layers = [] # 保存所有卷积层
in_dim = 3
out_dim = 64
""" 循环构造卷积层，一共有13个卷积层 """
for i in range(13):
layers+= [nn.Conv2d(in_dim,out_dim, 3, 1, 1), nn.ReLU(inplace=True)]
in_dim= out_dim
if i in [1,3,6,9,12]: # 增加池化层
layers+= [nn.MaxPool2d(2,2)]
if i!= 9: #第10个卷积后保持和前面通道数一致
out_dim*= 2
self.features= nn.Sequential(*layers)
# VGGNet的3个全连接层，中间有ReLU和Dropout层
self.classifier= nn.Sequential(
nn.Linear(512*7*7, 4096),
nn.ReLU(True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(True),
nn.Dropout(),
nn.Linear(4096, num_classes)
)
def forward(self, x):
""" Input:224*224 RGB """
x= self.features(x)
# 这里降特征图维度从[1,512,7,7]变到[1,512*7*7]
x= x.view(x.size(0), -1)
x= self.classifier(x)
return x
DenseNet
import torch
from torch import nn
import torch.nn.functional as F
""" 实现一个Bottlenect，初始化需要输入的通道数与GrowthRate"""
class Bottleneck(nn.Module):
""" Bottlenect"""
def __init__(self, nChannels, growthRate):
super(Bottleneck, self).__init__()
#通常1x1卷积的通道数为GrowthRate的4倍
interChannels= 4*growthRate
self.bn1= nn.BatchNorm2d(nChannels)
self.conv1= nn.Conv2d(nChannels,interChannels, kernel_size=1, bias=False)
self.bn2= nn.BatchNorm2d(interChannels)
self.conv2= nn.Conv2d(interChannels,growthRate, kernel_size=3, padding=1, bias=False)
def forward(self, x):
out= self.conv1(F.relu(self.bn1(x)))
out= self.conv2(F.relu(self.bn2(out)))
#将输入x同计算的结果out进行通道拼接
out= torch.cat((x,out), 1)
return out
class Denseblock(nn.Module):
""" DenseNet"""
def __init__(self, nChannels, growthRate, nDenseBlocks):
super(Denseblock, self).__init__()
layers= []
#将每一个Bottleneck利用nn.Sequential整合，输入通道需要线性增长
for i in range(int(nDenseBlocks)):
layers.append(Bottleneck(nChannels, growthRate))
nChannels+= growthRate
self.denseblock= nn.Sequential(*layers)
def forward(self, x):
return self.denseblock(x)
inceptionV1
import torch
from torch import nn
import torch.nn.functional as F
""" 首先定义一个包含conv后relu的基础卷积类 """
class BasicConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, padding=0):
super(BasicConv2d, self).__init__()
self.conv= nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding)
def forward(self, x):
x= self.conv(x)
return F.relu(x, inplace=True)
""" InceptionV1类，初始化时需要提供各个子模块的通道数大小 """
class InceptionV1(nn.Module):
def __init__(self, in_dim, hid_1_1, hid_2_1, hid_2_3, hid_3_1, out_3_5, out_4_1):
super(InceptionV1, self).__init__()
""" 定义四个子模块 """
self.branch1x1= BasicConv2d(in_dim, hid_1_1, 1) #1×1卷积降维
self.branch3x3= nn.Sequential(
BasicConv2d(in_dim, hid_2_1, 1),
BasicConv2d(hid_2_1, hid_2_3, 3, padding=1)
)
self.branch5x5= nn.Sequential(
BasicConv2d(in_dim, hid_3_1, 1),
BasicConv2d(hid_3_1, out_3_5, 5, padding=2)
)
self.branch_pool= nn.Sequential(
nn.MaxPool2d(3, stride=1, padding=1),
BasicConv2d(in_dim, out_4_1, 1)
)
def forward(self, x):
b1= self.branch1x1(x)
b2= self.branch3x3(x)
b3= self.branch5x5(x)
b4= self.branch_pool(x)
#将这四个子模块沿着通道方向拼接
output= torch.cat((b1, b2, b3, b4), dim=1)
return output
Resnet Bottlenect
由ResNet提出的子模块，通过引入一个shortcut分支，将需要拟合的映射变为残差映射F(x):H(x)-x
ResNet假设：相较于直接优化潜在映射H(x)，优化残差映射F(x)更为容易，残差模块称为Bottlenect
ResNet50主要部分在于中间的4个大的卷积组，而这4个卷积组分别包含了3,4,5这3个Bottlenect模块，最后经过一个全局平均池化使得特征图大小变为1x1，然后进行1000维的全连接，最后softmax输出分类得分
F(x)+x是逐通道进行相加，根据通道数是否相同，存在两种Bottlenect结构，通道数不同时，例如每个卷积组的第一个Bottlenect，需要利用1x1卷积对x进行DownSample操作，将通道数变为相同，再相加，对于通道数相同情况，则直接相加
from torch import nn
class Bottlenect(nn.Module):
def __init__(self, in_dim, out_dim, stride=1):
super(Bottlenect, self).__init__()
self.bottlenect= nn.Sequential(
nn.Conv2d(in_dim, in_dim, 1, bias=False),
nn.BatchNorm2d(in_dim),
nn.ReLU(inplace= True),
nn.Conv2d(in_dim, in_dim, 3, stride, 1, bias=False),
nn.BatchNorm2d(in_dim),
nn.ReLU(inplace= True),
nn.Conv2d(in_dim, out_dim, 1, bias= False),
nn.BatchNorm2d(out_dim)
)
self.relu= nn.ReLU(inplace= True)
""" DownSample部分是由一个包含BN层的1x1卷积组成 """
self.downsample= nn.Sequential(
nn.Conv2d(in_dim, out_dim, 1, 1),
nn.BatchNorm2d(out_dim)
)
def forward(self, x):
identify= x
out= self.bottlenect(x)
identify= self.downsample(x)
#将identify恒等映射与网络堆叠层输出相加，并经过ReLU后输出
out+= identify
out= self.relu(out)
out= self.relu(out)
return out
对上述网络进行测试
"""Test"""
import torch
"""----------test VGG16----------"""
from vgg16 import VGG
vgg= VGG(21).cuda()
input= torch.randn(1, 3, 224,224).cuda()
score= vgg(input)
print(score.shape)
# 单独调用卷积模块，输出最后一张特征图
features= vgg.features(input)
print(features.shape)
print(vgg.classifier)
"""----------test InceptionV1----------"""
from inceptionV1 import InceptionV1
net_inceptionv1= InceptionV1(3, 64, 32, 64, 64, 96, 32).cuda()
print(net_inceptionv1)
input= torch.randn(1, 3, 256,256).cuda()
print("input.shape:",input.shape, "\noutput.shape:",net_inceptionv1(input).shape) #32+96+64+64
"""----------test ResNet50.Bottlenect----------"""
from resnet_bottlenect import Bottlenect
bottlenect_1_1= Bottlenect(64, 256).cuda()
print(bottlenect_1_1)
input= torch.randn(1, 64, 56, 56).cuda()
outpupt= bottlenect_1_1(input)
print("input.shape:",input.shape, "output.shape:",outpupt.shape)