def __init__(self, in_channels, output_stride):
super(ASSP, self).__init__()
assert output_stride in [
8, 16
], "Only output strides of 8 or 16 are suported"
if output_stride == 16:
dilations = [1, 6, 12, 18]
elif output_stride == 8:
dilations = [1, 12, 24, 36]
self.aspp1 = assp_branch(in_channels, 256, 1, dilation=dilations[0])
self.aspp2 = assp_branch(in_channels, 256, 3, dilation=dilations[1])
self.aspp3 = assp_branch(in_channels, 256, 3, dilation=dilations[2])
self.aspp4 = assp_branch(in_channels, 256, 3, dilation=dilations[3])
self.avg_pool = nn.Sequential(
nn.AdaptiveAvgPool2d((1, 1)),
nn.Conv2d(in_channels, 256, 1, bias=False),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True),
)
self.conv1 = nn.Conv2d(256 * 5, 256, 1, bias=False)
self.bn1 = nn.BatchNorm2d(256)
self.relu = nn.ReLU(inplace=True)
self.dropout = nn.Dropout(0.5)
initialize_weights(self)
def __init__(self,
in_channels,
backbone,
out_channels_gcn=(85, 128),
pretrained=True,
kernel_sizes=(5, 7)):
super(Resnet, self).__init__()
resnet = getattr(torchvision.models, backbone)(pretrained)
if in_channels == 3: conv1 = resnet.conv1
else:
conv1 = nn.Conv2d(in_channels,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.initial = nn.Sequential(conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
self.layer1 = resnet.layer1
self.layer2 = resnet.layer2
self.layer3 = resnet.layer3
self.layer4 = resnet.layer4
if not pretrained: initialize_weights(self)
def __init__(self, output_stride=16, in_channels=3, pretrained=True):
super(Xception, self).__init__()
# Stride for block 3 (entry flow), and the dilation rates for middle flow and exit flow
if output_stride == 16: b3_s, mf_d, ef_d = 2, 1, (1, 2)
if output_stride == 8: b3_s, mf_d, ef_d = 1, 2, (2, 4)
# Entry Flow
self.conv1 = nn.Conv2d(in_channels, 32, 3, 2, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(32)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(32, 64, 3, 1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(64)
self.block1 = Block(64, 128, stride=2, dilation=1, use_1st_relu=False)
self.block2 = Block(128, 256, stride=2, dilation=1)
self.block3 = Block(256, 728, stride=b3_s, dilation=1)
# Middle Flow
for i in range(16):
exec(f'self.block{i+4} = Block(728, 728, stride=1, dilation=mf_d)')
# Exit flow
self.block20 = Block(728, 1024, stride=1, dilation=ef_d[0], exit_flow=True)
self.conv3 = SeparableConv2d(1024, 1536, 3, stride=1, dilation=ef_d[1])
self.bn3 = nn.BatchNorm2d(1536)
self.conv4 = SeparableConv2d(1536, 1536, 3, stride=1, dilation=ef_d[1])
self.bn4 = nn.BatchNorm2d(1536)
self.conv5 = SeparableConv2d(1536, 2048, 3, stride=1, dilation=ef_d[1])
self.bn5 = nn.BatchNorm2d(2048)
initialize_weights(self)
if pretrained: self._load_pretrained_model()
def __init__(self,
num_classes,
in_channels=3,
backbone="resnet50",
pretrained=True,
freeze_bn=False,
freeze_backbone=False,
**kwargs):
super(UNetResnet, self).__init__()
model = getattr(resnet, backbone)(pretrained,
norm_layer=nn.BatchNorm2d)
self.initial = list(model.children())[:4]
if in_channels != 3:
self.initial[0] = nn.Conv2d(in_channels,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.initial = nn.Sequential(*self.initial)
# encoder
self.layer1 = model.layer1
self.layer2 = model.layer2
self.layer3 = model.layer3
self.layer4 = model.layer4
# decoder
self.conv1 = nn.Conv2d(2048, 192, kernel_size=3, stride=1, padding=1)
self.upconv1 = nn.ConvTranspose2d(192, 128, 4, 2, 1, bias=False)
self.conv2 = nn.Conv2d(1152, 128, kernel_size=3, stride=1, padding=1)
self.upconv2 = nn.ConvTranspose2d(128, 96, 4, 2, 1, bias=False)
self.conv3 = nn.Conv2d(608, 96, kernel_size=3, stride=1, padding=1)
self.upconv3 = nn.ConvTranspose2d(96, 64, 4, 2, 1, bias=False)
self.conv4 = nn.Conv2d(320, 64, kernel_size=3, stride=1, padding=1)
self.upconv4 = nn.ConvTranspose2d(64, 48, 4, 2, 1, bias=False)
self.conv5 = nn.Conv2d(48, 48, kernel_size=3, stride=1, padding=1)
self.upconv5 = nn.ConvTranspose2d(48, 32, 4, 2, 1, bias=False)
self.conv6 = nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1)
self.conv7 = nn.Conv2d(32, num_classes, kernel_size=1, bias=False)
initialize_weights(self)
if freeze_bn:
self.freeze_bn()
if freeze_backbone:
set_trainable(
[
self.initial, self.layer1, self.layer2, self.layer3,
self.layer4
],
False,
)
def __init__(self, num_classes, in_channels=3, freeze_bn=False, **_):
super(ENet, self).__init__()
self.initial = InitalBlock(in_channels)
# Stage 1
self.bottleneck10 = BottleNeck(16, 64, downsample=True, p_drop=0.01)
self.bottleneck11 = BottleNeck(64, p_drop=0.01)
self.bottleneck12 = BottleNeck(64, p_drop=0.01)
self.bottleneck13 = BottleNeck(64, p_drop=0.01)
self.bottleneck14 = BottleNeck(64, p_drop=0.01)
# Stage 2
self.bottleneck20 = BottleNeck(64, 128, downsample=True, p_drop=0.1)
self.bottleneck21 = BottleNeck(128, p_drop=0.1)
self.bottleneck22 = BottleNeck(128, dilation=2, p_drop=0.1)
self.bottleneck23 = BottleNeck(128, asymetric=True, p_drop=0.1)
self.bottleneck24 = BottleNeck(128, dilation=4, p_drop=0.1)
self.bottleneck25 = BottleNeck(128, p_drop=0.1)
self.bottleneck26 = BottleNeck(128, dilation=8, p_drop=0.1)
self.bottleneck27 = BottleNeck(128, asymetric=True, p_drop=0.1)
self.bottleneck28 = BottleNeck(128, dilation=16, p_drop=0.1)
# Stage 3
self.bottleneck31 = BottleNeck(128, p_drop=0.1)
self.bottleneck32 = BottleNeck(128, dilation=2, p_drop=0.1)
self.bottleneck33 = BottleNeck(128, asymetric=True, p_drop=0.1)
self.bottleneck34 = BottleNeck(128, dilation=4, p_drop=0.1)
self.bottleneck35 = BottleNeck(128, p_drop=0.1)
self.bottleneck36 = BottleNeck(128, dilation=8, p_drop=0.1)
self.bottleneck37 = BottleNeck(128, asymetric=True, p_drop=0.1)
self.bottleneck38 = BottleNeck(128, dilation=16, p_drop=0.1)
# Stage 4
self.bottleneck40 = BottleNeck(128,
64,
upsample=True,
p_drop=0.1,
use_prelu=False)
self.bottleneck41 = BottleNeck(64, p_drop=0.1, use_prelu=False)
self.bottleneck42 = BottleNeck(64, p_drop=0.1, use_prelu=False)
# Stage 5
self.bottleneck50 = BottleNeck(64,
16,
upsample=True,
p_drop=0.1,
use_prelu=False)
self.bottleneck51 = BottleNeck(16, p_drop=0.1, use_prelu=False)
# Stage 6
self.fullconv = nn.ConvTranspose2d(16,
num_classes,
kernel_size=3,
padding=1,
output_padding=1,
stride=2,
bias=False)
initialize_weights(self)
if freeze_bn: self.freeze_bn()
def __init__(self, shape, r, learn_rate=0.1, beta=0., momentum=0.):
m, n = shape[0], shape[1]
self.U = initialize_weights(m,r)
self.G = initialize_weights(r,n)
self.bias = zeros((m,n))
self.shape = (m, n)
self.r = r
self.prevgrad = zeros(len(self.params))
self.trainer = ActivationTrainer()
def __init__(self, num_channels):
super(BR_Block, self).__init__()
self.bn1 = nn.BatchNorm2d(num_channels)
self.relu1 = nn.ReLU(inplace=True)
self.conv1 = nn.Conv2d(num_channels, num_channels, 3, padding=1)
self.bn2 = nn.BatchNorm2d(num_channels)
self.relu2 = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(num_channels, num_channels, 3, padding=1)
initialize_weights(self)
def __init__(self,
num_classes=8,
in_channels=3,
backbone='resnet152',
pretrained=False,
use_aux=True,
freeze_bn=False,
freeze_backbone=False):
super(PSPNet, self).__init__()
# TODO: Use synch batchnorm
norm_layer = nn.BatchNorm2d
model = getattr(resnet, backbone)(
pretrained=False,
norm_layer=norm_layer,
)
m_out_sz = model.fc.in_features
self.use_aux = use_aux
self.initial = nn.Sequential(*list(model.children())[:4])
if in_channels != 3:
self.initial[0] = nn.Conv2d(in_channels,
128,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.initial = nn.Sequential(*self.initial)
self.layer1 = model.layer1
self.layer2 = model.layer2
self.layer3 = model.layer3
self.layer4 = model.layer4
self.master_branch = nn.Sequential(
_PSPModule(m_out_sz, bin_sizes=[1, 2, 3, 6],
norm_layer=norm_layer),
nn.Conv2d(m_out_sz // 4, num_classes, kernel_size=1))
self.auxiliary_branch = nn.Sequential(
nn.Conv2d(m_out_sz // 2,
m_out_sz // 4,
kernel_size=3,
padding=1,
bias=False), norm_layer(m_out_sz // 4),
nn.ReLU(inplace=True), nn.Dropout2d(0.1),
nn.Conv2d(m_out_sz // 4, num_classes, kernel_size=1))
initialize_weights(self.master_branch, self.auxiliary_branch)
if freeze_bn:
self.freeze_bn()
if freeze_backbone:
set_trainable([
self.initial, self.layer1, self.layer2, self.layer3,
self.layer4
], False)
def __init__(self, num_classes, in_channels=3, backbone='densenet201', pretrained=True, use_aux=True, freeze_bn=False, **_):
super(PSPDenseNet, self).__init__()
self.use_aux = use_aux
model = getattr(models, backbone)(pretrained)
m_out_sz = model.classifier.in_features
aux_out_sz = model.features.transition3.conv.out_channels
if not pretrained or in_channels != 3:
# If we're training from scratch, better to use 3x3 convs
block0 = [nn.Conv2d(in_channels, 64, 3, stride=2, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True)]
block0.extend(
[nn.Conv2d(64, 64, 3, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True)] * 2
)
self.block0 = nn.Sequential(
*block0,
nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
)
initialize_weights(self.block0)
else:
self.block0 = nn.Sequential(*list(model.features.children())[:4])
self.block1 = model.features.denseblock1
self.block2 = model.features.denseblock2
self.block3 = model.features.denseblock3
self.block4 = model.features.denseblock4
self.transition1 = model.features.transition1
# No pooling
self.transition2 = nn.Sequential(
*list(model.features.transition2.children())[:-1])
self.transition3 = nn.Sequential(
*list(model.features.transition3.children())[:-1])
for n, m in self.block3.named_modules():
if 'conv2' in n:
m.dilation, m.padding = (2,2), (2,2)
for n, m in self.block4.named_modules():
if 'conv2' in n:
m.dilation, m.padding = (4,4), (4,4)
self.master_branch = nn.Sequential(
_PSPModule(m_out_sz, bin_sizes=[1, 2, 3, 6], norm_layer=nn.BatchNorm2d),
nn.Conv2d(m_out_sz//4, num_classes, kernel_size=1)
)
self.auxiliary_branch = nn.Sequential(
nn.Conv2d(aux_out_sz, m_out_sz//4, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(m_out_sz//4),
nn.ReLU(inplace=True),
nn.Dropout2d(0.1),
nn.Conv2d(m_out_sz//4, num_classes, kernel_size=1)
)
initialize_weights(self.master_branch, self.auxiliary_branch)
if freeze_bn: self.freeze_bn()
def __init__(self, in_channels, out_channles, upscale):
super(DUC, self).__init__()
out_channles = out_channles * (upscale**2)
self.conv = nn.Conv2d(in_channels, out_channles, 1, bias=False)
self.bn = nn.BatchNorm2d(out_channles)
self.relu = nn.ReLU(inplace=True)
self.pixl_shf = nn.PixelShuffle(upscale_factor=upscale)
initialize_weights(self)
kernel = self.icnr(self.conv.weight, scale=upscale)
self.conv.weight.data.copy_(kernel)
def __init__(self,
in_channels,
output_stride,
pretrained=True,
dilation_bigger=False):
super(ResNet_HDC_DUC, self).__init__()
model = models.resnet101(pretrained=pretrained)
if not pretrained or in_channels != 3:
self.layer0 = nn.Sequential(
nn.Conv2d(in_channels, 64, 7, stride=2, padding=3, bias=False),
nn.BatchNorm2d(64), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
initialize_weights(self.layer0)
else:
self.layer0 = nn.Sequential(*list(model.children())[:4])
self.layer1 = model.layer1
self.layer2 = model.layer2
self.layer3 = model.layer3
self.layer4 = model.layer4
if output_stride == 4: list(self.layer0.children())[0].stride = (1, 1)
d_res4b = []
if dilation_bigger:
d_res4b.extend([1, 2, 5, 9] * 5 + [1, 2, 5])
d_res5b = [5, 9, 17]
else:
# Dialtion-RF
d_res4b.extend([1, 2, 3] * 7 + [2, 2])
d_res5b = [3, 4, 5]
l_index = 0
for n, m in self.layer3.named_modules():
if 'conv2' in n:
d = d_res4b[l_index]
m.dilation, m.padding, m.stride = (d, d), (d, d), (1, 1)
l_index += 1
elif 'downsample.0' in n:
m.stride = (1, 1)
l_index = 0
for n, m in self.layer4.named_modules():
if 'conv2' in n:
d = d_res5b[l_index]
m.dilation, m.padding, m.stride = (d, d), (d, d), (1, 1)
l_index += 1
elif 'downsample.0' in n:
m.stride = (1, 1)
def __init__(self,
in_channels=3,
output_stride=16,
backbone="resnet101",
pretrained=True):
super(ResNet, self).__init__()
model = getattr(models, backbone)(pretrained)
if not pretrained or in_channels != 3:
self.layer0 = nn.Sequential(
nn.Conv2d(in_channels, 64, 7, stride=2, padding=3, bias=False),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
)
initialize_weights(self.layer0)
else:
self.layer0 = nn.Sequential(*list(model.children())[:4])
self.layer1 = model.layer1
self.layer2 = model.layer2
self.layer3 = model.layer3
self.layer4 = model.layer4
if output_stride == 16:
s3, s4, d3, d4 = (2, 1, 1, 2)
elif output_stride == 8:
s3, s4, d3, d4 = (1, 1, 2, 4)
if output_stride == 8:
for n, m in self.layer3.named_modules():
if "conv1" in n and (backbone == "resnet34"
or backbone == "resnet18"):
m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3,
s3)
elif "conv2" in n:
m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3,
s3)
elif "downsample.0" in n:
m.stride = (s3, s3)
for n, m in self.layer4.named_modules():
if "conv1" in n and (backbone == "resnet34"
or backbone == "resnet18"):
m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4)
elif "conv2" in n:
m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4)
elif "downsample.0" in n:
m.stride = (s4, s4)
def __init__(self, visible_size, hidden_size, epochs=1, learn_rate=0.1,
trainfn='cdn', n=1, beta=0.0001, momentum=0., batch_size=10,
visible_layer='binary', hidden_layer='binary', dropout=0.0,
verbose=0):
# Initialize args
self.trainfn = trainfn
self.epochs = epochs
self.n = n
self.learn_rate = learn_rate
self.beta = beta
self.batch_size = batch_size
self.momentum = momentum
self.verbose = verbose
self.visible_size = visible_size
self.hidden_size = hidden_size
self.visible_layer = visible_layer
self.hidden_layer = hidden_layer
self.dropout = dropout
# Initialize Biases and Weights
self.vbias = zeros(visible_size)
self.hbias = zeros(hidden_size)
self.W = initialize_weights(visible_size, hidden_size)
self.prevgrad = {'W': zeros(self.W.shape),
'hbias': zeros(hidden_size),
'vbias': zeros(visible_size)}
self.p = np.zeros((self.batch_size, self.hidden_size))
if self.trainfn == 'fpcd':
self.fW = zeros(self.W.shape)
self.flr = self.learn_rate*exp(1) #fast learn rate heuristic
self.fWd = 49./50 #fast weight decay heuristic
# Initialize Trainer instance
self.trainer = Trainer()
def __init__(self, in_channels, bin_sizes, norm_layer=nn.BatchNorm2d):
super().__init__()
out_channels = in_channels // len(bin_sizes)
self.bin_sizes = bin_sizes
self.stages = nn.ModuleList([
self._make_stages(in_channels, out_channels, b_s, norm_layer)
for b_s in bin_sizes
])
self.bottleneck = nn.Sequential(
nn.Conv2d(in_channels + (out_channels * len(bin_sizes)),
out_channels,
kernel_size=3,
padding=1,
bias=False), norm_layer(out_channels),
nn.ReLU(inplace=True), nn.Dropout2d(0.1))
initialize_weights(self)
def __init__(self, low_level_channels, num_classes):
super(Decoder, self).__init__()
self.conv1 = nn.Conv2d(low_level_channels, 48, 1, bias=False)
self.bn1 = nn.BatchNorm2d(48)
self.relu = nn.ReLU(inplace=True)
self.DUC = DUC(256, 256, upscale=2)
self.output = nn.Sequential(
nn.Conv2d(48 + 256, 256, 3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, 3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True),
nn.Dropout(0.1),
nn.Conv2d(256, num_classes, 1, stride=1),
)
initialize_weights(self)
def __init__(self, in_channels, output_stride, assp_channels=6):
super(ASSP, self).__init__()
assert output_stride in [
4, 8
], 'Only output strides of 8 or 16 are suported'
assert assp_channels in [
4, 6
], 'Number of suported ASSP branches are 4 or 6'
dilations = [1, 6, 12, 18, 24, 36]
dilations = dilations[:assp_channels]
self.assp_channels = assp_channels
self.aspp1 = assp_branch(in_channels, 256, 1, dilation=dilations[0])
self.aspp2 = assp_branch(in_channels, 256, 3, dilation=dilations[1])
self.aspp3 = assp_branch(in_channels, 256, 3, dilation=dilations[2])
self.aspp4 = assp_branch(in_channels, 256, 3, dilation=dilations[3])
if self.assp_channels == 6:
self.aspp5 = assp_branch(in_channels,
256,
3,
dilation=dilations[4])
self.aspp6 = assp_branch(in_channels,
256,
3,
dilation=dilations[5])
self.avg_pool = nn.Sequential(
nn.AdaptiveAvgPool2d((1, 1)),
nn.Conv2d(in_channels, 256, 1, bias=False), nn.BatchNorm2d(256),
nn.ReLU(inplace=True))
self.conv1 = nn.Conv2d(256 * (self.assp_channels + 1),
256,
1,
bias=False)
self.bn1 = nn.BatchNorm2d(256)
self.relu = nn.ReLU(inplace=True)
self.dropout = nn.Dropout(0.5)
initialize_weights(self)
def __init__(self, size_in, size_out, learn_rate=0.1, epochs=1,
batch_size=100, momentum=0.9, verbose=0):
self.size_in = size_in
self.size_out = size_out
self.learn_rate = learn_rate
self.epochs = epochs
self.batch_size = batch_size
self.verbose = verbose
self.momentum = momentum
self.W = initialize_weights(size_in, size_out)
self._prevgrad = zeros(self.W.flatten().shape)
self.trainer = Trainer()
def __init__(self, kernel_size, in_channels, out_channels):
super(GCN_Block, self).__init__()
assert kernel_size % 2 == 1, 'Kernel size must be odd'
self.conv11 = nn.Conv2d(in_channels,
out_channels,
kernel_size=(kernel_size, 1),
padding=(kernel_size // 2, 0))
self.conv12 = nn.Conv2d(out_channels,
out_channels,
kernel_size=(1, kernel_size),
padding=(0, kernel_size // 2))
self.conv21 = nn.Conv2d(in_channels,
out_channels,
kernel_size=(1, kernel_size),
padding=(0, kernel_size // 2))
self.conv22 = nn.Conv2d(out_channels,
out_channels,
kernel_size=(kernel_size, 1),
padding=(kernel_size // 2, 0))
initialize_weights(self)
def __init__(self,
in_channels,
backbone,
out_channels_gcn=(85, 128),
kernel_sizes=(5, 7)):
super(ResnetGCN, self).__init__()
resnet = getattr(torchvision.models, backbone)(pretrained=False)
if in_channels == 3: conv1 = resnet.conv1
else:
conv1 = nn.Conv2d(in_channels,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.initial = nn.Sequential(conv1, resnet.bn1, resnet.relu,
resnet.maxpool)
self.layer1 = resnet.layer1
self.layer2 = resnet.layer2
self.layer3 = nn.Sequential(
BottleneckGCN(512,
1024,
kernel_sizes[0],
out_channels_gcn[0],
stride=2),
*[BottleneckGCN(1024, 1024, kernel_sizes[0], out_channels_gcn[0])
] * 5)
self.layer4 = nn.Sequential(
BottleneckGCN(1024,
2048,
kernel_sizes[1],
out_channels_gcn[1],
stride=2),
*[BottleneckGCN(1024, 1024, kernel_sizes[1], out_channels_gcn[1])
] * 5)
initialize_weights(self)
def __init__(self,
in_channels=3,
output_stride=16,
backbone='resnet101',
pretrained=True):
super(ResNetFuse, self).__init__()
# Encoder Depth
model_d = getattr(models, backbone)(pretrained)
in_channels_d = 1
state_dict = model_d.state_dict()
conv1_weight = state_dict['conv1.weight']
conv1_weight = conv1_weight.mean(dim=1, keepdim=True)
conv2d_first = nn.Conv2d(in_channels_d,
64,
7,
stride=2,
padding=3,
bias=False)
conv2d_first.weight.data = conv1_weight
#print("backbone {}".format(backbone))
#_load_pretrained(model_d, model_urls[backbone], inchans=in_channels_d)
# self.layer0_d = nn.Sequential(*list(model_d.children())[:4])
self.layer0_d = nn.Sequential(
conv2d_first, nn.BatchNorm2d(64), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
#initialize_weights(self.layer0_d)
self.layer1_d = model_d.layer1
self.layer2_d = model_d.layer2
self.layer3_d = model_d.layer3
self.layer4_d = model_d.layer4
if output_stride == 16:
s3, s4, d3, d4 = (2, 1, 1, 2)
elif output_stride == 8:
s3, s4, d3, d4 = (1, 1, 2, 4)
if output_stride == 8:
for n, m in self.layer3_d.named_modules():
if 'conv1' in n and (backbone == 'resnet34'
or backbone == 'resnet18'):
m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3,
s3)
elif 'conv2' in n:
m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3,
s3)
elif 'downsample.0' in n:
m.stride = (s3, s3)
for n, m in self.layer4_d.named_modules():
if 'conv1' in n and (backbone == 'resnet34'
or backbone == 'resnet18'):
m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4)
elif 'conv2' in n:
m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4)
elif 'downsample.0' in n:
m.stride = (s4, s4)
#Encoder RGB
model = getattr(models, backbone)(pretrained)
if not pretrained or in_channels != 3:
self.layer0 = nn.Sequential(
nn.Conv2d(in_channels, 64, 7, stride=2, padding=3, bias=False),
nn.BatchNorm2d(64), nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
initialize_weights(self.layer0)
else:
self.layer0 = nn.Sequential(*list(model.children())[:4])
self.layer1 = model.layer1
self.layer2 = model.layer2
self.layer3 = model.layer3
self.layer4 = model.layer4
if output_stride == 16: s3, s4, d3, d4 = (2, 1, 1, 2)
elif output_stride == 8: s3, s4, d3, d4 = (1, 1, 2, 4)
if output_stride == 8:
for n, m in self.layer3.named_modules():
if 'conv1' in n and (backbone == 'resnet34'
or backbone == 'resnet18'):
m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3,
s3)
elif 'conv2' in n:
m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3,
s3)
elif 'downsample.0' in n:
m.stride = (s3, s3)
for n, m in self.layer4.named_modules():
if 'conv1' in n and (backbone == 'resnet34'
or backbone == 'resnet18'):
m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4)
elif 'conv2' in n:
m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4)
elif 'downsample.0' in n:
m.stride = (s4, s4)
def __init__(self,
num_classes,
in_channels=3,
backbone='resnet152',
pretrained=True,
use_aux=True,
freeze_bn=False,
freeze_backbone=False):
super().__init__()
# TODO: Use synch batchnorm
norm_layer = nn.BatchNorm2d
# model = getattr(resnet, backbone)(pretrained, norm_layer=norm_layer)
model = getattr(models, backbone)(pretrained)
self.initial = nn.Sequential(*list(model.children())[:4])
if in_channels != 3:
self.initial[0] = nn.Conv2d(in_channels,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.initial = nn.Sequential(*self.initial)
self.layer1 = model.layer1
self.layer2 = model.layer2
self.layer3 = model.layer3
self.layer4 = model.layer4
out_size1 = model.layer1[-1].bn3.num_features
out_size2 = model.layer2[-1].bn3.num_features
out_size3 = model.layer3[-1].bn3.num_features
out_size4 = model.layer4[-1].bn3.num_features
bin_sizes = [1, 2, 3, 6]
self.ppm4 = nn.Sequential(
PPM(out_size4, bin_sizes, norm_layer=norm_layer),
nn.Conv2d(out_size4 // len(bin_sizes), num_classes, kernel_size=1))
self.ppm3 = nn.Sequential(
PPM(out_size3, bin_sizes, norm_layer=norm_layer),
nn.Conv2d(out_size3 // len(bin_sizes), num_classes, kernel_size=1))
self.ppm2 = nn.Sequential(
PPM(out_size2, bin_sizes, norm_layer=norm_layer),
nn.Conv2d(out_size2 // len(bin_sizes), num_classes, kernel_size=1))
self.daum = DAUM(in_channels, (9, 9))
self.daum1 = AUM(in_channels, (5, 5))
self.daum2 = AUM(in_channels, (5, 5))
self.daum3 = AUM(in_channels, (5, 5))
# self.daum4 = DAUM(512, (5, 5))
self.smoother = GaussianSmoother()
initialize_weights(self.ppm4, self.ppm3, self.ppm2, self.daum1,
self.daum2, self.daum3)
if freeze_bn:
self.freeze_bn()
if freeze_backbone:
set_trainable([
self.initial, self.layer1, self.layer2, self.layer3,
self.layer4
], False)
def __init__(self, size_in=10, size_out=10, modelfn='sigmoid', dropout=0.0):
self._W = initialize_weights(size_in+1, size_out).astype(np.float128)
self._size_in = size_in
self._size_out = size_out
self._modelfn = modelfn
self.dropout = dropout
