def __init__(self, n_classes=21, in_channels=512):
#def __init__(self, n_classes=21, in_channels=512,agent_num=5):
super(n_segnet_decoder, self).__init__()
self.in_channels = in_channels
# Decoder
self.deconv1= deconv2DBatchNormRelu(self.in_channels, 512, k_size=3, stride=2, padding=1,output_padding=1)
self.deconv2= conv2DBatchNormRelu(512 , 512, k_size=3, stride=1, padding=1)
self.deconv3= conv2DBatchNormRelu(512 , 512, k_size=3, stride=1, padding=1)
# up 4
self.deconv4= deconv2DBatchNormRelu(512 , 512, k_size=3, stride=2, padding=1,output_padding=1)
self.deconv5= conv2DBatchNormRelu(512 , 512, k_size=3, stride=1, padding=1)
self.deconv6= conv2DBatchNormRelu(512 , 256, k_size=3, stride=1, padding=1)
# up 3
self.deconv7= deconv2DBatchNormRelu(256 , 256, k_size=3, stride=2, padding=1,output_padding=1)
self.deconv8= conv2DBatchNormRelu(256 , 128, k_size=3, stride=1, padding=1)
# up 2
self.deconv9= deconv2DBatchNormRelu(128 , 128, k_size=3, stride=2, padding=1,output_padding=1)
self.deconv10= conv2DBatchNormRelu(128 , 64, k_size=3, stride=1, padding=1)
# up 1
self.deconv11= deconv2DBatchNormRelu(64 , 64, k_size=3, stride=2, padding=1,output_padding=1)
self.deconv12= conv2DBatchNormRelu(64 , n_classes, k_size=3, stride=1, padding=1)
def __init__(
self,
n_classes=19,
block_config=[3, 4, 6, 3],
input_size=(1025, 2049),
version=None,
is_batchnorm=True,
):
super(icnet, self).__init__()
bias = not is_batchnorm
self.block_config = (icnet_specs[version]["block_config"]
if version is not None else block_config)
self.n_classes = icnet_specs[version][
"n_classes"] if version is not None else n_classes
self.input_size = icnet_specs[version][
"input_size"] if version is not None else input_size
# Encoder
self.convbnrelu1_1 = conv2DBatchNormRelu(
in_channels=3,
k_size=3,
n_filters=32,
padding=1,
stride=2,
bias=bias,
is_batchnorm=is_batchnorm,
)
self.convbnrelu1_2 = conv2DBatchNormRelu(
in_channels=32,
k_size=3,
n_filters=32,
padding=1,
stride=1,
bias=bias,
is_batchnorm=is_batchnorm,
)
self.convbnrelu1_3 = conv2DBatchNormRelu(
in_channels=32,
k_size=3,
n_filters=64,
padding=1,
stride=1,
bias=bias,
is_batchnorm=is_batchnorm,
)
# Vanilla Residual Blocks
self.res_block2 = residualBlockPSP(self.block_config[0],
64,
32,
128,
1,
1,
is_batchnorm=is_batchnorm)
self.res_block3_conv = residualBlockPSP(
self.block_config[1],
128,
64,
256,
2,
1,
include_range="conv",
is_batchnorm=is_batchnorm,
)
self.res_block3_identity = residualBlockPSP(
self.block_config[1],
128,
64,
256,
2,
1,
include_range="identity",
is_batchnorm=is_batchnorm,
)
# Dilated Residual Blocks
self.res_block4 = residualBlockPSP(self.block_config[2],
256,
128,
512,
1,
2,
is_batchnorm=is_batchnorm)
self.res_block5 = residualBlockPSP(self.block_config[3],
512,
256,
1024,
1,
4,
is_batchnorm=is_batchnorm)
# Pyramid Pooling Module
self.pyramid_pooling = pyramidPooling(1024, [6, 3, 2, 1],
model_name="icnet",
fusion_mode="sum",
is_batchnorm=is_batchnorm)
# Final conv layer with kernel 1 in sub4 branch
self.conv5_4_k1 = conv2DBatchNormRelu(
in_channels=1024,
k_size=1,
n_filters=256,
padding=0,
stride=1,
bias=bias,
is_batchnorm=is_batchnorm,
)
# High-resolution (sub1) branch
self.convbnrelu1_sub1 = conv2DBatchNormRelu(
in_channels=3,
k_size=3,
n_filters=32,
padding=1,
stride=2,
bias=bias,
is_batchnorm=is_batchnorm,
)
self.convbnrelu2_sub1 = conv2DBatchNormRelu(
in_channels=32,
k_size=3,
n_filters=32,
padding=1,
stride=2,
bias=bias,
is_batchnorm=is_batchnorm,
)
self.convbnrelu3_sub1 = conv2DBatchNormRelu(
in_channels=32,
k_size=3,
n_filters=64,
padding=1,
stride=2,
bias=bias,
is_batchnorm=is_batchnorm,
)
self.classification = nn.Conv2d(128, self.n_classes, 1, 1, 0)
# Cascade Feature Fusion Units
self.cff_sub24 = cascadeFeatureFusion(self.n_classes,
256,
256,
128,
is_batchnorm=is_batchnorm)
self.cff_sub12 = cascadeFeatureFusion(self.n_classes,
128,
64,
128,
is_batchnorm=is_batchnorm)
# Define auxiliary loss function
self.loss = multi_scale_cross_entropy2d
def __init__(self,
n_classes=21,
block_config=[3, 4, 23, 3],
input_size=(473, 473),
version=None):
super(pspnet, self).__init__()
self.block_config = (pspnet_specs[version]["block_config"]
if version is not None else block_config)
self.n_classes = pspnet_specs[version][
"n_classes"] if version is not None else n_classes
self.input_size = pspnet_specs[version][
"input_size"] if version is not None else input_size
# Encoder
self.convbnrelu1_1 = conv2DBatchNormRelu(in_channels=3,
k_size=3,
n_filters=64,
padding=1,
stride=2,
bias=False)
self.convbnrelu1_2 = conv2DBatchNormRelu(in_channels=64,
k_size=3,
n_filters=64,
padding=1,
stride=1,
bias=False)
self.convbnrelu1_3 = conv2DBatchNormRelu(in_channels=64,
k_size=3,
n_filters=128,
padding=1,
stride=1,
bias=False)
# Vanilla Residual Blocks
self.res_block2 = residualBlockPSP(self.block_config[0], 128, 64, 256,
1, 1)
self.res_block3 = residualBlockPSP(self.block_config[1], 256, 128, 512,
2, 1)
# Dilated Residual Blocks
self.res_block4 = residualBlockPSP(self.block_config[2], 512, 256,
1024, 1, 2)
self.res_block5 = residualBlockPSP(self.block_config[3], 1024, 512,
2048, 1, 4)
# Pyramid Pooling Module
self.pyramid_pooling = pyramidPooling(2048, [6, 3, 2, 1])
# Final conv layers
self.cbr_final = conv2DBatchNormRelu(4096, 512, 3, 1, 1, False)
self.dropout = nn.Dropout2d(p=0.1, inplace=False)
self.classification = nn.Conv2d(512, self.n_classes, 1, 1, 0)
# Auxiliary layers for training
self.convbnrelu4_aux = conv2DBatchNormRelu(in_channels=1024,
k_size=3,
n_filters=256,
padding=1,
stride=1,
bias=False)
self.aux_cls = nn.Conv2d(256, self.n_classes, 1, 1, 0)
# Define auxiliary loss function
self.loss = multi_scale_cross_entropy2d
def __init__(self, n_classes=21, in_channels=3):
super(n_segnet_encoder, self).__init__()
self.in_channels = in_channels
# Encoder
# down 1
self.conv1 = conv2DBatchNormRelu(self.in_channels, 64, k_size=3, stride=1, padding=1)
self.conv2 = conv2DBatchNormRelu(64 , 64, k_size=3, stride=2, padding=1)
# down 2
self.conv3 = conv2DBatchNormRelu(64 ,128, k_size=3, stride=1, padding=1)
self.conv4 = conv2DBatchNormRelu(128 ,128, k_size=3, stride=2, padding=1)
# down 3
self.conv5 = conv2DBatchNormRelu(128 , 256, k_size=3, stride=1, padding=1)
self.conv6 = conv2DBatchNormRelu(256 , 256, k_size=3, stride=1, padding=1)
self.conv7 = conv2DBatchNormRelu(256 , 256, k_size=3, stride=2, padding=1)
# down 4
self.conv8 = conv2DBatchNormRelu(256 , 512, k_size=3, stride=1, padding=1)
self.conv9 = conv2DBatchNormRelu(512 , 512, k_size=3, stride=1, padding=1)
self.conv10= conv2DBatchNormRelu(512 , 512, k_size=3, stride=2, padding=1)
# down 5
self.conv11= conv2DBatchNormRelu(512 , 512, k_size=3, stride=1, padding=1)
self.conv12= conv2DBatchNormRelu(512 , 512, k_size=3, stride=1, padding=1)
self.conv13= conv2DBatchNormRelu(512 , 512, k_size=3, stride=2, padding=1)
def __init__(self,
feature_scale=4,
n_classes=21,
is_deconv=True,
in_channels=3,
is_batchnorm=True):
super(linknet, self).__init__()
self.is_deconv = is_deconv
self.in_channels = in_channels
self.is_batchnorm = is_batchnorm
self.feature_scale = feature_scale
self.layers = [2, 2, 2, 2] # Currently hardcoded for ResNet-18
filters = [64, 128, 256, 512]
filters = [x / self.feature_scale for x in filters]
self.inplanes = filters[0]
# Encoder
self.convbnrelu1 = conv2DBatchNormRelu(in_channels=3,
k_size=7,
n_filters=64,
padding=3,
stride=2,
bias=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
block = residualBlock
self.encoder1 = self._make_layer(block, filters[0], self.layers[0])
self.encoder2 = self._make_layer(block,
filters[1],
self.layers[1],
stride=2)
self.encoder3 = self._make_layer(block,
filters[2],
self.layers[2],
stride=2)
self.encoder4 = self._make_layer(block,
filters[3],
self.layers[3],
stride=2)
self.avgpool = nn.AvgPool2d(7)
# Decoder
self.decoder4 = linknetUp(filters[3], filters[2])
self.decoder4 = linknetUp(filters[2], filters[1])
self.decoder4 = linknetUp(filters[1], filters[0])
self.decoder4 = linknetUp(filters[0], filters[0])
# Final Classifier
self.finaldeconvbnrelu1 = nn.Sequential(
nn.ConvTranspose2d(filters[0], 32 / feature_scale, 3, 2, 1),
nn.BatchNorm2d(32 / feature_scale),
nn.ReLU(inplace=True),
)
self.finalconvbnrelu2 = conv2DBatchNormRelu(
in_channels=32 / feature_scale,
k_size=3,
n_filters=32 / feature_scale,
padding=1,
stride=1,
)
self.finalconv3 = nn.Conv2d(32 / feature_scale, n_classes, 2, 2, 0)
def __init__(self,
n_classes=21,
model_type=None,
group_norm=False,
n_groups=16):
super(frrn, self).__init__()
self.n_classes = n_classes
self.model_type = model_type
self.group_norm = group_norm
self.n_groups = n_groups
if self.group_norm:
self.conv1 = conv2DGroupNormRelu(3, 48, 5, 1, 2)
else:
self.conv1 = conv2DBatchNormRelu(3, 48, 5, 1, 2)
self.up_residual_units = []
self.down_residual_units = []
for i in range(3):
self.up_residual_units.append(
RU(
channels=48,
kernel_size=3,
strides=1,
group_norm=self.group_norm,
n_groups=self.n_groups,
))
self.down_residual_units.append(
RU(
channels=48,
kernel_size=3,
strides=1,
group_norm=self.group_norm,
n_groups=self.n_groups,
))
self.up_residual_units = nn.ModuleList(self.up_residual_units)
self.down_residual_units = nn.ModuleList(self.down_residual_units)
self.split_conv = nn.Conv2d(48,
32,
kernel_size=1,
padding=0,
stride=1,
bias=False)
# each spec is as (n_blocks, channels, scale)
self.encoder_frru_specs = frrn_specs_dic[self.model_type]["encoder"]
self.decoder_frru_specs = frrn_specs_dic[self.model_type]["decoder"]
# encoding
prev_channels = 48
self.encoding_frrus = {}
for n_blocks, channels, scale in self.encoder_frru_specs:
for block in range(n_blocks):
key = "_".join(
map(str,
["encoding_frru", n_blocks, channels, scale, block]))
setattr(
self,
key,
FRRU(
prev_channels=prev_channels,
out_channels=channels,
scale=scale,
group_norm=self.group_norm,
n_groups=self.n_groups,
),
)
prev_channels = channels
# decoding
self.decoding_frrus = {}
for n_blocks, channels, scale in self.decoder_frru_specs:
# pass through decoding FRRUs
for block in range(n_blocks):
key = "_".join(
map(str,
["decoding_frru", n_blocks, channels, scale, block]))
setattr(
self,
key,
FRRU(
prev_channels=prev_channels,
out_channels=channels,
scale=scale,
group_norm=self.group_norm,
n_groups=self.n_groups,
),
)
prev_channels = channels
self.merge_conv = nn.Conv2d(prev_channels + 32,
48,
kernel_size=1,
padding=0,
stride=1,
bias=False)
self.classif_conv = nn.Conv2d(48,
self.n_classes,
kernel_size=1,
padding=0,
stride=1,
bias=True)