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)