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, 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)