def __init__(self, block, layers, num_classes=21):
self.inplanes = 64
super(Refine_pspNet, self).__init__()
self.do = nn.Dropout(p=0.5)
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
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.p_ims1d2_outl1_dimred = conv3x3(2048, 512, bias=False)
self.adapt_stage1_b = self._make_rcu(512, 512, 2, 2)
self.mflow_conv_g1_pool = self._make_crp(512, 512, 4)
self.mflow_conv_g1_b = self._make_rcu(512, 512, 3, 2)
self.mflow_conv_g1_b3_joint_varout_dimred = conv3x3(512, 256, bias=False)
self.p_ims1d2_outl2_dimred = conv3x3(1024, 256, bias=False)
self.adapt_stage2_b = self._make_rcu(256, 256, 2, 2)
self.adapt_stage2_b2_joint_varout_dimred = conv3x3(256, 256, bias=False)
self.mflow_conv_g2_pool = self._make_crp(256, 256, 4)
self.mflow_conv_g2_b = self._make_rcu(256, 256, 3, 2)
self.mflow_conv_g2_b3_joint_varout_dimred = conv3x3(256, 256, bias=False)
self.p_ims1d2_outl3_dimred = conv3x3(512, 256, bias=False)
self.adapt_stage3_b = self._make_rcu(256, 256, 2, 2)
self.adapt_stage3_b2_joint_varout_dimred = conv3x3(256, 256, bias=False)
self.mflow_conv_g3_pool = self._make_crp(256, 256, 4)
self.mflow_conv_g3_b = self._make_rcu(256, 256, 3, 2)
self.mflow_conv_g3_b3_joint_varout_dimred = conv3x3(256, 256, bias=False)
self.p_ims1d2_outl4_dimred = conv3x3(256, 256, bias=False)
self.adapt_stage4_b = self._make_rcu(256, 256, 2, 2)
self.adapt_stage4_b2_joint_varout_dimred = conv3x3(256, 256, bias=False)
self.mflow_conv_g4_pool = self._make_crp(256, 256, 4)
self.mflow_conv_g4_b = self._make_rcu(256, 256, 3, 2)
self.clf_conv = nn.Conv2d(256, num_classes, kernel_size=3, stride=1,
padding=1, bias=True)
self.pyramid_pooling = pyramidPooling(2048, [6, 3, 2, 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