def __init__(self):
super(Vgg, self).__init__()
self.vgg = models.vgg16() # vgg16模型
del self.vgg.avgpool
del self.vgg.classifier # 分别去掉已有vgg16的模型中的池化层和分类器
self.vgg_1 = models.vgg16() # 将输入通道改为1的vgg16模型
del self.vgg_1.avgpool
del self.vgg_1.classifier # 分别去掉已有vgg16的模型中的池化层和分类器
origin_dicts = torch.load('pth/vgg16-397923af.pth') # 预训练模型中vgg网络的参数
model_dicts = self.vgg.state_dict() # 自定义的去掉后面几层的网络的参数列表
pretrained_dicts = {
k: v
for k, v in origin_dicts.items() if k in model_dicts
} # 预训练模型参数在自定义模型中有的参数列表
model_dicts.update(pretrained_dicts) # 更新自定义的模型参数
self.vgg_se = nn.Sequential()
for i, fea in enumerate(self.vgg.features):
print(i, fea)
self.vgg_se.add_module(str(i), fea)
if i == 16:
self.vgg_se.add_module('se1', SELayer(256))
if i == 23:
self.vgg_se.add_module('se2', SELayer(512))
if i == 30:
self.vgg_se.add_module('se3', SELayer(512))
model_dicts_se = self.vgg_se.state_dict()
pretrained_dicts_se = {
k[9:]: v
for k, v in origin_dicts.items() if k[9:] in model_dicts_se
}
model_dicts_se.update(pretrained_dicts_se)
self.vgg_se.load_state_dict(model_dicts_se)
print(self.vgg_se[0])
def __init__(self, planes=576, scale=1.0, reduction=16):
super(InceptionResC, self).__init__()
self.scale = scale
self.relu = nn.ReLU(inplace=False)
self.branch_0 = BasicConv2d(planes,
planes // 8,
kernel_size=1,
stride=1)
self.branch_1 = nn.Sequential(
BasicConv2d(planes, planes // 8, kernel_size=1, stride=1),
BasicConv2d(planes // 8,
planes // 7,
kernel_size=(1, 3),
stride=1,
padding=(0, 1)),
BasicConv2d(planes // 7,
planes // 6,
kernel_size=(3, 1),
stride=1,
padding=(1, 0)))
self.branch_all = BasicConv2d(planes // 8 + planes // 6,
planes,
kernel_size=1,
stride=1)
self.se = SELayer(planes, reduction)
def __init__(self, planes=96, scale=1.0, reduction=16):
super(InceptionResA, self).__init__()
self.relu = nn.ReLU(inplace=False)
self.scale = scale
self.branch_0 = BasicConv2d(planes,
planes // 12,
kernel_size=1,
stride=1)
self.branch_1 = nn.Sequential(
BasicConv2d(planes, planes // 12, kernel_size=1, stride=1),
BasicConv2d(planes // 12,
planes // 12,
kernel_size=3,
stride=1,
padding=1))
self.branch_2 = nn.Sequential(
BasicConv2d(planes, planes // 12, kernel_size=1, stride=1),
BasicConv2d(planes // 12,
planes // 8,
kernel_size=3,
stride=1,
padding=1),
BasicConv2d(planes // 8,
planes // 6,
kernel_size=3,
stride=1,
padding=1))
self.branch_all = BasicConv2d(planes // 3,
planes,
kernel_size=1,
stride=1)
self.se = SELayer(planes, reduction)
def __init__(self, inplanes, planes, stride=1, downsample=None, kernel_size=1, conv_num=3):
super(BasicBlock2d, self).__init__()
self.bn1 = nn.BatchNorm2d(inplanes)
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Conv2d(planes, planes, kernel_size=(1, kernel_size),
stride=stride, bias=False, padding=(0, kernel_size // 2))
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride = stride
self.layers1 = nn.Sequential()
self.layers1.add_module("BatchNorm2d", self.bn1)
self.layers1.add_module('relu', self.relu)
self.layers1.add_module('conv1', self.conv1)
self.layers2 = None
if downsample is not None:
self.layers2 = nn.Sequential()
self.layers2.add_module('downsample', self.downsample)
for i in range(1, conv_num):
self.layers2.add_module('downsample', self.downsample)
for i in range(1, conv_num):
if conv_num == i - 1:
self.layers1.add_module('dropout',
nn.Dropout(.2)
)
self.layers1.add_module("BatchNorm2d", self.bn2)
self.layers1.add_module('relu', self.relu2)
self.layers1.add_module('conv1',
# self.conv1
nn.Conv2d(planes, planes, kernel_size=(1, kernel_size),
stride=1, bias=False, padding=(0, kernel_size // 2))
)
self.se = SELayer(planes, reduction=16)
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
groups=1,
base_width=64,
dilation=1,
norm_layer=None,
*,
reduction=16):
super(SEBottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
self.bn3 = nn.BatchNorm2d(planes * 4)
self.relu = nn.ReLU(inplace=True)
self.se = SELayer(planes * 4, reduction)
self.downsample = downsample
self.stride = stride
def __init__(self, num_classes=3):
super(WzmModel2, self).__init__()
self.fusion_upchannel = nn.Conv2d(5, 16, kernel_size=3, stride=1, padding=1)
self.se = SELayer(16, reduction=4)
self.conv_up = nn.Conv2d(16, 3, kernel_size=1)
self.relu_up = nn.ReLU(inplace=True)
self.conv_down1 = nn.Conv2d(512, 256, kernel_size=1)
self.conv_down2 = nn.Conv2d(256, 64, kernel_size=1)
self.relu_down = nn.ReLU(inplace=True)
self.vgg = models.vgg16()
del self.vgg.classifier
origin_dicts = torch.load('pth/vgg16-397923af.pth') # 预训练模型中vgg网络的参数
model_dicts = self.vgg.state_dict() # 自定义的去掉后面几层的网络的参数列表
pretrained_dicts = {k: v for k, v in origin_dicts.items() if k in model_dicts} # 预训练模型参数在自定义模型中有的参数列表
model_dicts.update(pretrained_dicts) # 更新自定义的模型参数
self.vgg.load_state_dict(model_dicts) # 加载更新后的自定义的网络模型参数
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(64 * 4 * 4, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
def __init__(self, inplanes, planes, stride=1, downsample=None, reduction=16):
super(SEBasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes, 1)
self.bn2 = nn.BatchNorm2d(planes)
self.se = SELayer(planes, reduction)
self.downsample = downsample
self.stride = stride
def __init__(self, inplanes, planes, stride=1, reduction=16):
super(CifarSEBasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = nn.BatchNorm2d(planes)
self.se = SELayer(planes, reduction)
if inplanes != planes:
self.downsample = nn.Sequential(nn.Conv2d(inplanes, planes, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(planes))
else:
self.downsample = lambda x: x
self.stride = stride
def __init__(self,
inplanes,
planes,
cfg,
stride=1,
downsample=None,
reduction=16):
# cfg should be a number in this case
super(SEBasicBlock, self).__init__()
self.conv1 = conv3x3(cfg, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.se = SELayer(planes, reduction)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, cfg)
self.bn2 = nn.BatchNorm2d(cfg)
self.downsample = downsample
self.stride = stride
def __init__(self,
inplanes,
planes,
cfg,
stride=1,
downsample=None,
reduction=16):
super(SEBottleneck, self).__init__()
self.conv1 = conv1x1(inplanes, cfg)
self.bn1 = nn.BatchNorm2d(cfg)
self.conv2 = conv3x3(cfg, cfg, stride)
self.bn2 = nn.BatchNorm2d(cfg)
self.se = SELayer(cfg, reduction)
self.conv3 = conv1x1(cfg, cfg * 4)
self.bn3 = nn.BatchNorm2d(cfg * 4)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self, num_classes=3):
super(WzmModel2, self).__init__()
self.fusion_upchannel = nn.Conv2d(5,
16,
kernel_size=3,
stride=1,
padding=1)
self.se = SELayer(16, reduction=4)
self.conv_up = nn.Conv2d(3, 16, kernel_size=1)
self.relu_up = nn.ReLU(inplace=True)
self.features1 = nn.Sequential(
# [16, 3, 128, 128]
nn.Conv2d(16,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(64,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(128,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(256,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False))
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(128 * 4 * 4, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
def __init__(self, num_classes, aux_logits=True, transform_input=False):
super(SEInception3, self).__init__()
model = Inception3(num_classes=num_classes,
aux_logits=aux_logits,
transform_input=transform_input)
model.Mixed_5b.add_module("SELayer", SELayer(192))
model.Mixed_5c.add_module("SELayer", SELayer(256))
model.Mixed_5d.add_module("SELayer", SELayer(288))
model.Mixed_6a.add_module("SELayer", SELayer(288))
model.Mixed_6b.add_module("SELayer", SELayer(768))
model.Mixed_6c.add_module("SELayer", SELayer(768))
model.Mixed_6d.add_module("SELayer", SELayer(768))
model.Mixed_6e.add_module("SELayer", SELayer(768))
if aux_logits:
model.AuxLogits.add_module("SELayer", SELayer(768))
model.Mixed_7a.add_module("SELayer", SELayer(768))
model.Mixed_7b.add_module("SELayer", SELayer(1280))
model.Mixed_7c.add_module("SELayer", SELayer(2048))
self.model = model
def __init__(self, num_classes=3, num_level=3, pool_type='max_pool', use_spp=False, use_se=False):
super(VggModel, self).__init__()
self.vgg = models.vgg16() # vgg16模型
del self.vgg.avgpool
del self.vgg.classifier # 分别去掉已有vgg16的模型中的池化层和分类器
self.vgg_1 = models.vgg16() # 将输入通道改为1的vgg16模型
del self.vgg_1.avgpool
del self.vgg_1.classifier # 分别去掉已有vgg16的模型中的池化层和分类器
origin_dicts = torch.load('pth/vgg16-397923af.pth') # 预训练模型中vgg网络的参数
model_dicts = self.vgg.state_dict() # 自定义的去掉后面几层的网络的参数列表
pretrained_dicts = {k: v for k, v in origin_dicts.items() if k in model_dicts} # 预训练模型参数在自定义模型中有的参数列表
model_dicts.update(pretrained_dicts) # 更新自定义的模型参数
self.vgg.load_state_dict(model_dicts) # 加载更新后的自定义的网络模型参数
self.vgg_1.features[0] = nn.Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) # 将输入通道改为1
model_dicts = self.vgg_1.state_dict() # 自定义的去掉后面几层的网络的参数列表
pretrained_dicts = {k: v for k, v in origin_dicts.items() if k in model_dicts} # 预训练模型参数在自定义模型中有的参数列表
layer1 = pretrained_dicts['features.0.weight']
new = torch.zeros(64, 1, 3, 3)
for i, output_channel in enumerate(layer1):
new[i] = 0.299 * output_channel[0] + 0.587 * output_channel[1] + 0.114 * output_channel[2]
pretrained_dicts['features.0.weight'] = new
model_dicts.update(pretrained_dicts) # 更新自定义的模型参数
# print(model_dicts.keys())
self.vgg_1.load_state_dict(model_dicts) # 加载更新后的自定义的网络模型参数
# print(self.vgg_1.features)
self.use_se = use_se
if self.use_se:
self.vgg_se = nn.Sequential()
for i, fea in enumerate(self.vgg.features):
# print(i, fea)
self.vgg_se.add_module(str(i), fea)
if i == 16:
self.vgg_se.add_module('se1', SELayer(256))
if i == 23:
self.vgg_se.add_module('se2', SELayer(512))
if i == 30:
self.vgg_se.add_module('se3', SELayer(512))
model_dicts_se = self.vgg_se.state_dict()
pretrained_dicts_se = {k[9:]: v for k, v in origin_dicts.items() if k[9:] in model_dicts_se}
model_dicts_se.update(pretrained_dicts_se)
self.vgg_se.load_state_dict(model_dicts_se)
self.vgg_1_se = nn.Sequential()
for i, fea in enumerate(self.vgg_1.features):
# print(i, fea)
self.vgg_1_se.add_module(str(i), fea)
if i == 16:
self.vgg_1_se.add_module('se1', SELayer(256))
if i == 23:
self.vgg_1_se.add_module('se2', SELayer(512))
if i == 30:
self.vgg_1_se.add_module('se3', SELayer(512))
model_dicts_1_se = self.vgg_1_se.state_dict()
pretrained_dicts_1_se = {k[9:]: v for k, v in origin_dicts.items() if k[9:] in model_dicts_1_se}
model_dicts_1_se.update(pretrained_dicts_1_se)
self.vgg_1_se.load_state_dict(model_dicts_1_se)
self.conv1_fusion = nn.Conv2d(1536, 256, kernel_size=3, stride=1, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(256)
self.relu1_fusion = nn.ReLU(inplace=True)
self.conv2_fusion = nn.Conv2d(256, 128, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(128)
self.relu2_fusion = nn.ReLU(inplace=True)
self.downsample = nn.Sequential(
nn.Conv2d(1536, 128, kernel_size=1, stride=1, padding=0, bias=False),
nn.BatchNorm2d(128),
)
self.conv_fusion = nn.Sequential(
nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0, bias=False),
nn.ReLU(inplace=True),
)
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(64 * 4 * 4, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
self.use_spp = use_spp
if use_spp:
self.num_level = num_level
self.pool_type = pool_type
self.num_grid = self._cal_num_grids(num_level)
self.spp_layer = SpatialPyramidPooling2d(num_level)
self.classifier_spp = nn.Sequential(
nn.Dropout(),
nn.Linear(64 * self.num_grid, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
def __init__(self,
num_classes=3,
num_level=3,
pool_type='max_pool',
use_spp=False,
use_se=False):
super(VggModel, self).__init__()
# pre = torch.load("vgg16-397923af.pth")
# model = models.vgg16(pretrained=False)
# model.load_state_dict(pre)
self.features1 = nn.Sequential(
# [16, 3, 128, 128]
nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(64,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(128,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(256,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False))
if use_se:
self.features1_se = nn.Sequential(
# [16, 3, 128, 128]
nn.Conv2d(3,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(64,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(128,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
SELayer(256),
nn.Conv2d(256,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
SELayer(512),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.Conv2d(512,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
SELayer(128))
self.features2 = nn.Sequential(
nn.Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(64,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(128,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(256,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False))
if use_se:
self.features2_se = nn.Sequential(
nn.Conv2d(1,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(64,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False),
nn.Conv2d(128,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False), SELayer(256),
nn.Conv2d(256,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False), SELayer(512),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
512,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.Conv2d(512,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,
stride=2,
padding=0,
dilation=1,
ceil_mode=False), SELayer(128))
self.conv1_fusion = nn.Conv2d(384,
256,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(256)
self.relu1_fusion = nn.ReLU(inplace=True)
self.conv2_fusion = nn.Conv2d(256,
128,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(128)
self.relu2_fusion = nn.ReLU(inplace=True)
self.downsample = nn.Sequential(
nn.Conv2d(384, 128, kernel_size=1, stride=1, padding=0,
bias=False),
nn.BatchNorm2d(128),
)
self.conv_fusion = nn.Sequential(
nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0, bias=False),
nn.ReLU(inplace=True),
)
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(64 * 4 * 4, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
self.use_spp = use_spp
self.use_se = use_se
if use_spp:
self.num_level = num_level
self.pool_type = pool_type
self.num_grid = self._cal_num_grids(num_level)
self.spp_layer = SpatialPyramidPooling2d(num_level)
self.classifier_spp = nn.Sequential(
nn.Dropout(),
nn.Linear(64 * self.num_grid, 512),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(512, 256),
nn.ReLU(inplace=True),
nn.Linear(256, num_classes),
)
