def __init__(self,
num_classes,
trunk='resnet-101',
criterion=None,
variant='D',
skip='m1',
skip_num=48,
fpn_dsn=False):
super(AlignNetResNet, self).__init__()
self.criterion = criterion
self.variant = variant
self.skip = skip
self.skip_num = skip_num
self.fpn_dsn = fpn_dsn
if trunk == trunk == 'resnet-50-deep':
resnet = Resnet_Deep.resnet50()
elif trunk == 'resnet-101-deep':
resnet = Resnet_Deep.resnet101()
elif trunk == 'resnet-18-deep':
resnet = Resnet_Deep.resnet18()
else:
raise ValueError("Not a valid network arch")
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
self.layer0 = resnet.layer0
self.layer1, self.layer2, self.layer3, self.layer4 = \
resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
del resnet
if self.variant == 'D':
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding = (2, 2), (2, 2)
elif 'downsample.0' in n:
m.stride = (2, 2)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding = (4, 4), (4, 4)
elif 'downsample.0' in n:
m.stride = (2, 2)
else:
print("Not using Dilation ")
if trunk == 'resnet-18-deep':
inplane_head = 512
self.head = UperNetAlignHead(inplane_head,
num_class=num_classes,
norm_layer=Norm2d,
fpn_inplanes=[64, 128, 256, 512],
fpn_dim=128,
fpn_dsn=fpn_dsn)
else:
inplane_head = 2048
self.head = UperNetAlignHead(inplane_head,
num_class=num_classes,
norm_layer=Norm2d,
fpn_dsn=fpn_dsn)
def __init__(self,
num_classes,
trunk='seresnext-50',
criterion=None,
variant='D'):
super(SRNet, self).__init__()
self.criterion = criterion
self.variant = variant
if trunk == 'resnet-50-deep':
resnet = Resnet_Deep.resnet50()
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk == 'resnet-101':
resnet = Resnet_Deep.resnet101()
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk == 'resnet-101-deep':
resnet = Resnet_Deep.resnet101()
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
else:
raise ValueError("Not a valid network arch")
self.layer0 = resnet.layer0
self.layer1, self.layer2, self.layer3, self.layer4 = \
resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if self.variant == 'D':
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
elif self.variant == 'D16':
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
else:
print("Not using Dilation ")
self.head = ModuleHead(2048,
512,
512,
num_classes,
module=ChannelReasonModule(512, 256))
self.aux_layer = Aux_Module(1024, num_classes, norm_layer=Norm2d)
initialize_weights(self.head)
initialize_weights(self.aux_layer)
def __init__(self, num_classes, trunk='resnet-101', criterion=None, variant='D', skip='m1', skip_num=48,
fpn_dsn=False, inplanes=128, reduce_dim=64, ignore_background=False,
max_pool_size=8, avgpool_size=8, edge_points=32):
super(AlignNetResNetMaxAvgpool, self).__init__()
self.criterion = criterion
self.variant = variant
self.skip = skip
self.skip_num = skip_num
self.fpn_dsn = fpn_dsn
if trunk == trunk == 'resnet-50-deep':
resnet = Resnet_Deep.resnet50()
elif trunk == 'resnet-101-deep':
resnet = Resnet_Deep.resnet101()
else:
raise ValueError("Not a valid network arch")
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool)
self.layer0 = resnet.layer0
self.layer1, self.layer2, self.layer3, self.layer4 = \
resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
del resnet
if self.variant == 'D':
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding = (2, 2), (2, 2)
elif 'downsample.0' in n:
m.stride = (2, 2)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding = (4, 4), (4, 4)
elif 'downsample.0' in n:
m.stride = (2, 2)
else:
print("Not using Dilation ")
inplane_head = 2048
self.head = UperNetAlignHeadMaxAvgpool(inplane_head, num_class=num_classes, norm_layer=Norm2d,
fpn_dsn=fpn_dsn, reduce_dim=reduce_dim,
ignore_background=ignore_background, max_pool_size=max_pool_size,
avgpool_size=avgpool_size, edge_points=edge_points)
def __init__(self,
num_classes,
trunk='seresnext-50',
criterion=None,
variant='D',
skip='m1',
skip_num=48):
super(PSPNet, self).__init__()
self.criterion = criterion
self.variant = variant
self.skip = skip
self.skip_num = skip_num
if trunk == 'resnet-50-deep':
resnet = Resnet_Deep.resnet50()
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk == 'resnet-101-deep':
resnet = Resnet_Deep.resnet101()
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
else:
raise ValueError("Not a valid network arch")
self.layer0 = resnet.layer0
self.layer1, self.layer2, self.layer3, self.layer4 = \
resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if self.variant == 'D':
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
elif self.variant == 'D16':
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
else:
print("Not using Dilation ")
self.ppm = PSPModule(2048, 256, norm_layer=Norm2d)
if self.skip == 'm1':
self.bot_fine = nn.Conv2d(256,
self.skip_num,
kernel_size=1,
bias=False)
elif self.skip == 'm2':
self.bot_fine = nn.Conv2d(512,
self.skip_num,
kernel_size=1,
bias=False)
else:
raise Exception('Not a valid skip')
# body_edge module
self.squeeze_body_edge = SqueezeBodyEdge(256, Norm2d)
# fusion different edge part
self.edge_fusion = nn.Conv2d(256 + 48, 256, 1, bias=False)
self.sigmoid_edge = nn.Sigmoid()
self.edge_out = nn.Sequential(
nn.Conv2d(256, 48, kernel_size=3, padding=1, bias=False),
Norm2d(48), nn.ReLU(inplace=True),
nn.Conv2d(48, 1, kernel_size=1, bias=False))
# DSN for seg body part
self.dsn_seg_body = nn.Sequential(
nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),
Norm2d(256), nn.ReLU(inplace=True),
nn.Conv2d(256, num_classes, kernel_size=1, bias=False))
# Final segmentation part
self.final_seg = nn.Sequential(
nn.Conv2d(512, 256, kernel_size=3, padding=1, bias=False),
Norm2d(256), nn.ReLU(inplace=True),
nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),
Norm2d(256), nn.ReLU(inplace=True),
nn.Conv2d(256, num_classes, kernel_size=1, bias=False))
def __init__(self, num_classes, trunk='seresnext-50', criterion=None, variant='D',
skip='m1', skip_num=48):
super(DeepFCN, self).__init__()
self.criterion = criterion
self.variant = variant
self.skip = skip
self.skip_num = skip_num
if trunk == 'resnet-50-deep':
resnet = Resnet_Deep.resnet50()
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool)
elif trunk == 'resnet-101-deep':
resnet = Resnet_Deep.resnet101()
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool)
else:
raise ValueError("Not a valid network arch")
self.layer0 = resnet.layer0
self.layer1, self.layer2, self.layer3, self.layer4 = \
resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if self.variant == 'D':
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
elif self.variant == 'D16':
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
else:
print("Not using Dilation ")
self.fcn_head = nn.Sequential(
nn.Conv2d(2048, 256, kernel_size=3, padding=1, bias=False),
Norm2d(256),
nn.ReLU(inplace=True),
)
if self.skip == 'm1':
self.bot_fine = nn.Conv2d(256, self.skip_num, kernel_size=1, bias=False)
elif self.skip == 'm2':
self.bot_fine = nn.Conv2d(512, self.skip_num, kernel_size=1, bias=False)
else:
raise Exception('Not a valid skip')
self.final = nn.Sequential(
nn.Conv2d(256 + self.skip_num, 256, kernel_size=3, padding=1, bias=False),
Norm2d(256),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),
Norm2d(256),
nn.ReLU(inplace=True),
nn.Conv2d(256, num_classes, kernel_size=1, bias=False))
initialize_weights(self.fcn_head)
initialize_weights(self.bot_fine)
initialize_weights(self.final)