def __init__(self, batch_norm=False):
super(fba_decoder, self).__init__()
pool_scales = (1, 2, 3, 6)
self.batch_norm = batch_norm
self.ppm = []
for scale in pool_scales:
self.ppm.append(
nn.Sequential(
nn.AdaptiveAvgPool2d(scale),
L.Conv2d(2048, 256, kernel_size=1, bias=True),
norm(256, self.batch_norm),
nn.LeakyReLU(),
), )
self.ppm = nn.ModuleList(self.ppm)
self.conv_up1 = nn.Sequential(
L.Conv2d(
2048 + len(pool_scales) * 256,
256,
kernel_size=3,
padding=1,
bias=True,
),
norm(256, self.batch_norm),
nn.LeakyReLU(),
L.Conv2d(256, 256, kernel_size=3, padding=1),
norm(256, self.batch_norm),
nn.LeakyReLU(),
)
self.conv_up2 = nn.Sequential(
L.Conv2d(256 + 256, 256, kernel_size=3, padding=1, bias=True),
norm(256, self.batch_norm),
nn.LeakyReLU(),
)
if self.batch_norm:
d_up3 = 128
else:
d_up3 = 64
self.conv_up3 = nn.Sequential(
L.Conv2d(256 + d_up3, 64, kernel_size=3, padding=1, bias=True),
norm(64, self.batch_norm),
nn.LeakyReLU(),
)
self.unpool = nn.MaxUnpool2d(2, stride=2)
self.conv_up4 = nn.Sequential(
nn.Conv2d(64 + 3 + 3 + 2, 32, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(32, 16, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(16, 7, kernel_size=1, padding=0, bias=True),
)
def conv1x1(in_planes, out_planes, stride=1):
"""1x1 convolution"""
return L.Conv2d(in_planes,
out_planes,
kernel_size=1,
stride=stride,
bias=False)
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return L.Conv2d(in_planes,
out_planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
def __init__(self, args):
super(Decoder, self).__init__()
self.args = args.arch
self.batch_norm = True
middle_chn = 2048
self.global_module = ASPP(middle_chn, self.args.atrous_rates,
self.args.aspp_channel)
en_chn = middle_chn + self.args.aspp_channel
self.conv_up1 = nn.Sequential(
L.Conv2d(en_chn, 256, kernel_size=3, padding=1, bias=True),
norm(256, self.batch_norm), nn.LeakyReLU(),
L.Conv2d(256, 256, kernel_size=3, padding=1),
norm(256, self.batch_norm), nn.LeakyReLU())
self.conv_up2 = nn.Sequential(
L.Conv2d(256 + 256, 256, kernel_size=3, padding=1, bias=True),
norm(256, self.batch_norm), nn.LeakyReLU())
self.conv_up3 = nn.Sequential(
L.Conv2d(256 + 128, 64, kernel_size=3, padding=1, bias=True),
norm(64, self.batch_norm), nn.LeakyReLU())
self.conv_up4_alpha = nn.Sequential(
nn.Conv2d(64 + 3 + 3 + 2, 32, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(32, 16, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(16, 1, kernel_size=1, padding=0, bias=False))
self.conv_up4_fb = nn.Sequential(
nn.Conv2d(64 + 3 + 3 + 2, 32, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(32, 16, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(16, 6, kernel_size=1, padding=0, bias=False))
self.conv_up4_attn = nn.Sequential(
nn.Conv2d(64, 32, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(32, 16, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(16, 3, kernel_size=1, padding=0, bias=False))
def __init__(self, block, layers, num_classes=1000):
super(ResNet, self).__init__()
self.inplanes = 64
self.conv1 = L.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = L.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(
kernel_size=3, stride=2, padding=1, return_indices=True,
)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
def __init__(self,
pool_scales=(1, 2, 3, 6),
use_mask_input=True,
use_usr_encoder=True,
gf=True):
super(InteractiveSegNet, self).__init__()
self.use_usr_encoder = use_usr_encoder
self.gf = gf
if (self.use_usr_encoder):
self.use_mask_input = use_mask_input
usr_inp_dim = 6
if self.use_mask_input:
usr_inp_dim += 1
self.usr_encoder = usr_encoder2(input_dim=usr_inp_dim)
usr_encoder_dims = [256, 256, 64]
else:
usr_encoder_dims = [0, 0, 0]
conv_2_C = 256
self.ppm = []
for scale in pool_scales:
self.ppm.append(
nn.Sequential(
nn.AdaptiveAvgPool2d(scale),
L.Conv2d(2048 + usr_encoder_dims[0],
256,
kernel_size=1,
bias=True), nn.GroupNorm(32, 256),
nn.LeakyReLU()))
self.ppm = nn.ModuleList(self.ppm)
self.conv_up1 = nn.Sequential(
L.Conv2d(2048 + len(pool_scales) * 256 + usr_encoder_dims[0],
256,
kernel_size=3,
padding=1,
bias=True), nn.GroupNorm(32, 256), nn.LeakyReLU(),
L.Conv2d(256, 256, kernel_size=3, padding=1),
nn.GroupNorm(32, 256), nn.LeakyReLU())
self.conv_up2 = nn.Sequential(
L.Conv2d(conv_2_C + 256 + usr_encoder_dims[1],
256,
kernel_size=3,
padding=1,
bias=True), nn.GroupNorm(32, 256), nn.LeakyReLU())
self.conv_up3 = nn.Sequential(
L.Conv2d(256 + 64 + usr_encoder_dims[2],
64,
kernel_size=3,
padding=1,
bias=True), nn.GroupNorm(32, 64), nn.LeakyReLU())
self.conv_up4 = nn.Sequential(
nn.Conv2d(64 + 3 + 6, 32, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(32, 16, kernel_size=3, padding=1, bias=True),
nn.LeakyReLU(),
nn.Conv2d(16, 1, kernel_size=1, padding=0, bias=True))
if (self.gf):
self.guided_map_conv1 = nn.Conv2d(5, 64, 1)
self.guided_map_relu1 = nn.ReLU(inplace=True)
self.guided_map_conv2 = nn.Conv2d(64, 1, 1)
self.guided_filter = GuidedFilter(2, 1e-8)
