def __init__(self, layers=18, dropout=0.1, classes=2):
super(FFTNet23, self).__init__()
if layers == 18:
resnet = models.resnet18(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 34:
resnet = models.resnet34(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 50:
resnet = models.resnet50_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 1, 1),
dilations=(1, 1, 2, 4))
if layers == 18 or layers == 34:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
else:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if layers == 18 or layers == 34:
fea_dim = 512
aux_dim = 256
else:
fea_dim = 2048
aux_dim = 1024
self.freq = nn.ModuleList()
for i in range(6, 10): # the number of in_channels is 2^i
self.freq.append(
FeatureFrequencySeparationModule(
in_channels=2**i,
up_channels=2**i if i == 6 else 2**(i - 1),
smf_channels=128,
high_ratio=1 - 0.2 * (i - 5),
# high_ratio=0.5,
low_ratio=0.2,
up_flag=False if i == 6 else True,
smf_flag=True if i % 2 == 0 else False,
))
self.fa_cls_seg = nn.Sequential(nn.Dropout2d(p=dropout),
nn.Conv2d(256, classes, kernel_size=1))
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(aux_dim,
aux_dim // 4,
kernel_size=3,
padding=1,
bias=False), nn.BatchNorm2d(aux_dim // 4),
nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(aux_dim // 4, classes, kernel_size=1))
def __init__(self, layers=50, dropout=0.1, classes=2, use_dct=True, use_bise=True, vec_dim=300):
super(DCTNet, self).__init__()
assert layers in [18, 34, 50, 101]
assert classes > 1
self.use_dct = use_dct
self.use_bise = use_bise
self.vec_dim = vec_dim
if layers == 18:
resnet = models.resnet18(pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1))
elif layers == 34:
resnet = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1))
elif layers == 50:
resnet = models.resnet50_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4))
elif layers == 101:
resnet = models.resnet101_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4))
if layers == 18 or layers == 34:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool)
else:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.conv2,
resnet.bn2, resnet.relu, resnet.conv3, resnet.bn3, resnet.relu, resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if layers == 18 or layers == 34:
fea_dim = 512
aux_dim = 256
else:
fea_dim = 2048
aux_dim = 1024
down_dim = fea_dim // 4
if use_dct:
self.dct_encoding = DCTModule(vec_dim=self.vec_dim)
if use_bise:
self.ffm = FeatureFusionModule(
in_channels=self.vec_dim + 128, out_channels=fea_dim) # concat: 128+128
self.cls = nn.Sequential(
nn.Conv2d(fea_dim, down_dim, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(down_dim),
nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout),
nn.Conv2d(down_dim, classes, kernel_size=1)
)
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(aux_dim, aux_dim // 4, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(aux_dim // 4),
nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout),
nn.Conv2d(aux_dim // 4, classes, kernel_size=1)
)
def __init__(self, layers=50, dropout=0.1, classes=2, fuse=8):
super(TriSeNet1, self).__init__()
assert layers in [18, 34, 50, 101]
assert classes > 1
self.fuse = fuse
# Backbone
if layers == 18:
resnet = models.resnet18(pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1))
elif layers == 34:
resnet = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1))
elif layers == 50:
resnet = models.resnet50_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4))
elif layers == 101:
resnet = models.resnet101_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4))
if layers == 18 or layers == 34:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool)
else:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.conv2,
resnet.bn2, resnet.relu, resnet.conv3, resnet.bn3, resnet.relu, resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if layers == 18 or layers == 34:
fea_dim = 512
aux_dim = 256
else:
fea_dim = 2048
aux_dim = 1024
down_dim = fea_dim // 4
self.cls = nn.Sequential(
nn.Conv2d(fea_dim, down_dim, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(down_dim),
nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout),
nn.Conv2d(down_dim, classes, kernel_size=1)
)
if self.fuse == 16 or self.fuse == 8:
self.fuse_16 = nn.Conv2d(fea_dim//2, classes, kernel_size=1)
if self.fuse == 8:
self.fuse_8 = nn.Conv2d(fea_dim//4, classes, kernel_size=1)
def __init__(self, layers=50, dropout=0.1, classes=2, vec_dim=300):
super(DCTNet, self).__init__()
assert layers in [18, 34, 50, 101]
assert classes > 1
self.vec_dim = vec_dim
# Backbone
if layers == 18:
resnet = models.resnet18(pretrained=False,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 34:
resnet = models.resnet34(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 50:
resnet = models.resnet50_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 1, 1),
dilations=(1, 1, 2, 4))
elif layers == 101:
resnet = models.resnet101_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 1, 1),
dilations=(1, 1, 2, 4))
if layers == 18 or layers == 34:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
else:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if layers == 18 or layers == 34:
fea_dim = 512
aux_dim = 256
else:
fea_dim = 2048
aux_dim = 1024
down_dim = fea_dim // 4
self.dct = nn.ModuleList()
for i in range(6, 10): # the number of in_channels is 2^i
self.dct.append(
DCTBlock(
in_channels=2**i,
mid_channels=32, # channels can be changed if you want.
up_flag=False if i == 9 else True,
up_channels=2**i + 2**(i + 1),
out_channels=2**i,
vec_dim=self.vec_dim))
self.cls = nn.Sequential(
nn.Conv2d(self.vec_dim,
down_dim,
kernel_size=3,
padding=1,
bias=False), nn.BatchNorm2d(down_dim),
nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(down_dim, classes, kernel_size=1))
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(aux_dim,
aux_dim // 4,
kernel_size=3,
padding=1,
bias=False), nn.BatchNorm2d(aux_dim // 4),
nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(aux_dim // 4, classes, kernel_size=1))
def __init__(self, layers=50, dropout=0.1, classes=2, zoom_factor=8):
super(DANet, self).__init__()
assert layers in [18, 34, 50, 101]
assert classes > 1
assert zoom_factor in [1, 2, 4, 8]
self.zoom_factor = zoom_factor
if layers == 18:
resnet = models.resnet18(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 34:
resnet = models.resnet34(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 50:
resnet = models.resnet50_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 1, 1),
dilations=(1, 1, 2, 4))
elif layers == 101:
resnet = models.resnet101_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 1, 1),
dilations=(1, 1, 2, 4))
if layers == 18 or layers == 34:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
else:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if layers == 18 or layers == 34:
fea_dim = 512
aux_dim = 256
else:
fea_dim = 2048
aux_dim = 1024
down_dim = fea_dim // 4
self.pam_in_conv = ConvBNReLU(fea_dim,
down_dim,
ks=3,
stride=1,
padding=1)
self.pam = PAM(down_dim)
self.pam_out_conv = ConvBNReLU(down_dim,
down_dim,
ks=3,
stride=1,
padding=1)
self.pam_cls_seg = nn.Sequential(
nn.Dropout2d(p=dropout), nn.Conv2d(down_dim,
classes,
kernel_size=1))
self.cam_in_conv = ConvBNReLU(fea_dim,
down_dim,
ks=3,
stride=1,
padding=1)
self.cam = CAM(down_dim)
self.cam_out_conv = ConvBNReLU(down_dim,
down_dim,
ks=3,
stride=1,
padding=1)
self.cam_cls_seg = nn.Sequential(
nn.Dropout2d(p=dropout), nn.Conv2d(down_dim,
classes,
kernel_size=1))
self.cls_seg = nn.Sequential(
nn.Dropout2d(p=dropout), nn.Conv2d(down_dim,
classes,
kernel_size=1))
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(aux_dim,
aux_dim // 4,
kernel_size=3,
padding=1,
bias=False), nn.BatchNorm2d(aux_dim // 4),
nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(aux_dim // 4, classes, kernel_size=1))
def __init__(self,
layers=50,
dropout=0.1,
classes=2,
zoom_factor=8,
reduction=2,
use_scale=True,
mode='embedded_gaussian'):
super(Nonlocal, self).__init__()
assert layers in [18, 34, 50, 101]
assert classes > 1
assert zoom_factor in [1, 2, 4, 8]
self.zoom_factor = zoom_factor
self.reduction = reduction
self.use_scale = use_scale
self.mode = mode
if layers == 18:
resnet = models.resnet18(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 34:
resnet = models.resnet34(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 50:
resnet = models.resnet50_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 1, 1),
dilations=(1, 1, 2, 4))
elif layers == 101:
resnet = models.resnet101_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 1, 1),
dilations=(1, 1, 2, 4))
if layers == 18 or layers == 34:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
else:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if layers == 18 or layers == 34:
fea_dim = 512
aux_dim = 256
else:
fea_dim = 2048
aux_dim = 1024
down_dim = fea_dim // 4
self.conv1 = ConvBNReLU(fea_dim, down_dim, ks=3, stride=1, padding=1)
self.nl_block = NonLocal2d(in_channels=down_dim,
reduction=self.reduction,
use_scale=self.use_scale,
norm_cfg=dict(type='SyncBN',
requires_grad=True),
mode=self.mode)
self.conv2 = ConvBNReLU(down_dim, down_dim, ks=3, stride=1, padding=1)
self.cls = nn.Sequential(
nn.Conv2d(fea_dim + down_dim,
down_dim,
kernel_size=3,
padding=1,
bias=False), nn.BatchNorm2d(down_dim),
nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(down_dim, classes, kernel_size=1))
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(aux_dim,
aux_dim // 4,
kernel_size=3,
padding=1,
bias=False), nn.BatchNorm2d(aux_dim // 4),
nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(aux_dim // 4, classes, kernel_size=1))
def __init__(self,
layers=50,
bins=(1, 2, 3, 6),
dropout=0.1,
classes=2,
zoom_factor=8,
use_ppm=True):
super(PSPNet, self).__init__()
assert layers in [18, 34, 50, 101]
assert 2048 % len(bins) == 0
assert classes > 1
assert zoom_factor in [1, 2, 4, 8]
self.zoom_factor = zoom_factor
self.use_ppm = use_ppm
if layers == 18:
resnet = models.resnet18(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 34:
resnet = models.resnet34(pretrained=True,
deep_base=False,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 50:
# resnet = models.resnet50_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4))
resnet = models.resnet50_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
elif layers == 101:
# resnet = models.resnet101_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4))
resnet = models.resnet101_semseg(pretrained=True,
deep_base=True,
strides=(1, 2, 2, 2),
dilations=(1, 1, 1, 1))
if layers == 18 or layers == 34:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
else:
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if layers == 18 or layers == 34:
fea_dim = 512
aux_dim = 256
else:
fea_dim = 2048
aux_dim = 1024
down_dim = fea_dim // 4
if use_ppm:
self.ppm = PPM(fea_dim, int(fea_dim / len(bins)), bins)
fea_dim *= 2
self.cls = nn.Sequential(
nn.Conv2d(fea_dim, down_dim, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(down_dim), nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout), nn.Conv2d(down_dim,
classes,
kernel_size=1))
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(aux_dim,
aux_dim // 4,
kernel_size=3,
padding=1,
bias=False), nn.BatchNorm2d(aux_dim // 4),
nn.ReLU(inplace=True), nn.Dropout2d(p=dropout),
nn.Conv2d(aux_dim // 4, classes, kernel_size=1))