def __init__(self, nfilters, nheads=1, _norm_type='BatchNorm', norm_groups=None, ftdepth=5, **kwards): HybridBlock.__init__(self, **kwards) with self.name_scope(): self.conv1 = Conv2DNormed(channels=nfilters, kernel_size=3, padding=1, groups=nheads, _norm_type=_norm_type, norm_groups=norm_groups, **kwards) # restore help self.conv3 = Fusion(nfilters=nfilters, kernel_size=3, padding=1, nheads=nheads, norm=_norm_type, norm_groups=norm_groups, ftdepth=ftdepth, **kwards) # process
def __init__(self, _nfilters, _norm_type='BatchNorm', **kwards): HybridBlock.__init__(self, **kwards) self.nfilters = _nfilters # This is used as a container (list) of layers self.convs = gluon.nn.HybridSequential() with self.name_scope(): self.convs.add( Conv2DNormed(self.nfilters // 4, kernel_size=(1, 1), padding=(0, 0), prefix="_conv1_")) self.convs.add( Conv2DNormed(self.nfilters // 4, kernel_size=(1, 1), padding=(0, 0), prefix="_conv2_")) self.convs.add( Conv2DNormed(self.nfilters // 4, kernel_size=(1, 1), padding=(0, 0), prefix="_conv3_")) self.convs.add( Conv2DNormed(self.nfilters // 4, kernel_size=(1, 1), padding=(0, 0), prefix="_conv4_")) self.conv_norm_final = Conv2DNormed(channels=self.nfilters, kernel_size=(1, 1), padding=(0, 0), _norm_type=_norm_type)
def __init__(self, channels, kernel_size, strides=(1, 1), padding=(0, 0), dilation=(1, 1), activation=None, weight_initializer=None, in_channels=0, _norm_type = 'BatchNorm', axis =1 ,**kwards): HybridBlock.__init__(self,**kwards) if (_norm_type == 'BatchNorm'): self.norm = gluon.nn.BatchNorm elif (_norm_type == 'SyncBatchNorm'): self.norm = gluon.contrib.nn.SyncBatchNorm _prefix = "_SyncBN" elif (_norm_type == 'InstanceNorm'): self.norm = gluon.nn.InstanceNorm elif (_norm_type == 'LayerNorm'): self.norm = gluon.nn.LayerNorm else: raise NotImplementedError with self.name_scope(): self.conv2d = gluon.nn.Conv2D(channels, kernel_size = kernel_size, strides= strides, padding=padding, dilation= dilation, activation=activation, use_bias=False, weight_initializer = weight_initializer, in_channels=0) self.norm_layer = self.norm(axis=axis)
def __init__(self, num_init_features, growth_rate, block_config, reduction, bn_size, downsample, initial_layers="imagenet", dropout=0, classes=1000, dilated=False, config_string="DIDIDIDITDIDIDIDIDITDIDIDIDITDIDIDIDI", **kwargs): HybridBlock.__init__(self, **kwargs) self.num_blocks = len(block_config) self.dilation = (1, 1, 2, 4) if dilated else (1, 1, 1, 1) self.downsample_struct = downsample self.bn_size = bn_size self.growth_rate = growth_rate self.dropout = dropout self.reduction_rates = reduction self.config_string = config_string if block_config is not [-1, -1, -1, -1]: warnings.warn( "Attention, the MeliusNetCustom block_config constructor parameter is not [-1,-1,-1,-1]." " This parameter only exists for backward compatibility but isn't used anymore" " because the configuration is read from the config_string. Make sure you understand how the" " MeliusNetCustom class should be used.") with self.name_scope(): self.features = nn.HybridSequential(prefix='') add_initial_layers(initial_layers, self.features, num_init_features) # Add dense blocks self.num_features = num_init_features if self.config_string.count("T") != 3: raise Exception( "config_string must contain exactly 3 tansition layers") self.meliusnet_block_configs = self.config_string.split('T') for i, block_string in enumerate(self.meliusnet_block_configs): self._make_repeated_base_blocks(block_string, i) if i != len(block_config) - 1: self._make_transition(i) self.finalize = nn.HybridSequential(prefix='') self.finalize.add(nn.BatchNorm()) self.finalize.add(nn.Activation('relu')) if dilated: self.finalize.add(nn.AvgPool2D(pool_size=28)) else: self.finalize.add( nn.AvgPool2D( pool_size=4 if initial_layers == "thumbnail" else 7)) self.finalize.add(nn.Flatten()) self.output = nn.Dense(classes)
def __init__(self, _nfilters, _norm_type='BatchNorm', **kwards): HybridBlock.__init__(self, **kwards) with self.name_scope(): # This performs convolution, no BatchNormalization. No need for bias. self.up = UpSample(_nfilters, _norm_type=_norm_type) self.conv_normed = Conv2DNormed(channels=_nfilters, kernel_size=(1, 1), padding=(0, 0), _norm_type=_norm_type)
def __init__(self,_nfilters, factor = 2, _norm_type='BatchNorm', **kwards): HybridBlock.__init__(self,**kwards) self.factor = factor self.nfilters = _nfilters // self.factor with self.name_scope(): self.convup_normed = Conv2DNormed(self.nfilters, kernel_size = (1,1), _norm_type = _norm_type, prefix="_convdn_")
def __init__(self, nfilters, factor=2, _norm_type='BatchNorm', norm_groups=None, **kwards): HybridBlock.__init__(self, **kwards) self.factor = factor self.nfilters = nfilters // self.factor self.convup_normed = Conv2DNormed(self.nfilters, kernel_size=(1, 1), _norm_type=_norm_type, norm_groups=norm_groups)
def __init__(self, _nfilters, _kernel_size=(3, 3), _dilation_rate=(1, 1), _norm_type='BatchNorm', **kwards): HybridBlock.__init__(self, **kwards) self.nfilters = _nfilters self.kernel_size = _kernel_size self.dilation_rate = _dilation_rate if (_norm_type == 'BatchNorm'): self.norm = gluon.nn.BatchNorm _prefix = "_BN" elif (_norm_type == 'InstanceNorm'): self.norm = gluon.nn.InstanceNorm _prefix = "_IN" elif (norm_type == 'LayerNorm'): self.norm = gluon.nn.LayerNorm _prefix = "_LN" else: raise NotImplementedError with self.name_scope(): # Ensures padding = 'SAME' for ODD kernel selection p0 = self.dilation_rate[0] * (self.kernel_size[0] - 1) / 2 p1 = self.dilation_rate[1] * (self.kernel_size[1] - 1) / 2 p = (int(p0), int(p1)) self.BN1 = self.norm(axis=1, prefix=_prefix + "1_") self.conv1 = gluon.nn.Conv2D(self.nfilters, kernel_size=self.kernel_size, padding=p, dilation=self.dilation_rate, use_bias=False, prefix="_conv1_") self.BN2 = self.norm(axis=1, prefix=_prefix + "2_") self.conv2 = gluon.nn.Conv2D(self.nfilters, kernel_size=self.kernel_size, padding=p, dilation=self.dilation_rate, use_bias=True, prefix="_conv2_")
def __init__(self,_nfilters, _factor=2, _norm_type='BatchNorm', **kwards): HybridBlock.__init__(self, **kwards) # Double the size of filters, since you will downscale by 2. self.factor = _factor self.nfilters = _nfilters * self.factor # I was using a kernel size of 1x1, this is notthing to do with max pooling, or selecting the most dominant number. Now changing that. # There is bug somewhere, if I use kernel_size = 2, code crashes with memory-illegal access. # Am not sure it is my bug, or something mxnet related # Kernel = 3, padding = 1 works fine, no bug here in latest version of mxnet. self.kernel_size = (3,3) self.strides = (2,2) self.pad = (1,1) with self.name_scope(): self.convdn = gluon.nn.Conv2D(self.nfilters, kernel_size=self.kernel_size, strides=self.strides, padding = self.pad, use_bias=False, prefix="_convdn_")
def __init__(self, _nfilters_init, _NClasses, verbose=True, _norm_type='BatchNorm', **kwards): HybridBlock.__init__(self, **kwards) self.model_name = "ResUNet_d6_encoder" self.depth = 6 self.nfilters = _nfilters_init # Initial number of filters self.NClasses = _NClasses with self.name_scope(): # First convolution Layer # Starting with first convolutions to make the input "channel" dim equal to the number of initial filters self.conv_first_normed = Conv2DNormed(channels=self.nfilters, kernel_size=(1, 1), _norm_type=_norm_type, prefix="_conv_first_") # Progressively reducing the dilation_rate of Atrous convolutions (the deeper the smaller). # Usually 32 nfilters = self.nfilters * 2**(0) if verbose: print("depth:= {0}, nfilters: {1}".format(0, nfilters)) self.Dn1 = ResNet_atrous_unit(nfilters, _norm_type=_norm_type) self.pool1 = DownSample(nfilters, _norm_type=_norm_type) # Usually 64 nfilters = self.nfilters * 2**(1) if verbose: print("depth:= {0}, nfilters: {1}".format(1, nfilters)) self.Dn2 = ResNet_atrous_unit(nfilters, _norm_type=_norm_type) self.pool2 = DownSample(nfilters, _norm_type=_norm_type) # Usually 128 nfilters = self.nfilters * 2**(2) if verbose: print("depth:= {0}, nfilters: {1}".format(2, nfilters)) self.Dn3 = ResNet_atrous_2_unit(nfilters, _norm_type=_norm_type) self.pool3 = DownSample(nfilters, _norm_type=_norm_type) # Usually 256 nfilters = self.nfilters * 2**(3) if verbose: print("depth:= {0}, nfilters: {1}".format(3, nfilters)) self.Dn4 = ResNet_atrous_2_unit(nfilters, _dilation_rates=[3, 5], _norm_type=_norm_type) self.pool4 = DownSample(nfilters, _norm_type=_norm_type) # Usually 512 nfilters = self.nfilters * 2**(4) if verbose: print("depth:= {0}, nfilters: {1}".format(4, nfilters)) self.Dn5 = ResNet_v2_unit(nfilters, _norm_type=_norm_type) self.pool5 = DownSample(nfilters) # Usually 1024 nfilters = self.nfilters * 2**(5) if verbose: print("depth:= {0}, nfilters: {1}".format(5, nfilters)) self.Dn6 = ResNet_v2_unit(nfilters) # Same number of filters, with new definition self.middle = PSP_Pooling(nfilters, _norm_type=_norm_type)
def __init__(self, _nfilters_init, _NClasses, verbose=True, _norm_type='BatchNorm', **kwards): HybridBlock.__init__(self, **kwards) self.model_name = "ResUNet_d7_cmtskc" self.depth = 7 self.nfilters = _nfilters_init # Initial number of filters self.NClasses = _NClasses with self.name_scope(): self.encoder = ResUNet_d7_encoder(self.nfilters, self.NClasses, _norm_type=_norm_type) nfilters = self.nfilters * 2**(self.depth - 1 - 1) if verbose: print("depth:= {0}, nfilters: {1}".format(7, nfilters)) self.UpComb1 = combine_layers(nfilters, _norm_type=_norm_type) self.UpConv1 = ResNet_v2_unit(nfilters, _norm_type=_norm_type) nfilters = self.nfilters * 2**(self.depth - 1 - 2) if verbose: print("depth:= {0}, nfilters: {1}".format(8, nfilters)) self.UpComb2 = combine_layers(nfilters, _norm_type=_norm_type) self.UpConv2 = ResNet_atrous_2_unit(nfilters, _norm_type=_norm_type) nfilters = self.nfilters * 2**(self.depth - 1 - 3) if verbose: print("depth:= {0}, nfilters: {1}".format(9, nfilters)) self.UpComb3 = combine_layers(nfilters, _norm_type=_norm_type) self.UpConv3 = ResNet_atrous_unit(nfilters, _norm_type=_norm_type) nfilters = self.nfilters * 2**(self.depth - 1 - 4) if verbose: print("depth:= {0}, nfilters: {1}".format(10, nfilters)) self.UpComb4 = combine_layers(nfilters, _norm_type=_norm_type) self.UpConv4 = ResNet_atrous_unit(nfilters, _norm_type=_norm_type) nfilters = self.nfilters * 2**(self.depth - 1 - 5) if verbose: print("depth:= {0}, nfilters: {1}".format(11, nfilters)) self.UpComb5 = combine_layers(nfilters, _norm_type=_norm_type) self.UpConv5 = ResNet_atrous_unit(nfilters, _norm_type=_norm_type) nfilters = self.nfilters * 2**(self.depth - 1 - 6) if verbose: print("depth:= {0}, nfilters: {1}".format(12, nfilters)) self.UpComb6 = combine_layers(nfilters, _norm_type=_norm_type) self.UpConv6 = ResNet_atrous_unit(nfilters, _norm_type=_norm_type) self.psp_2ndlast = PSP_Pooling(self.nfilters, _norm_type=_norm_type) # Segmenetation logits -- deeper for better reconstruction self.logits = gluon.nn.HybridSequential() self.logits.add( Conv2DNormed(channels=self.nfilters, kernel_size=(3, 3), padding=(1, 1))) self.logits.add(gluon.nn.Activation('relu')) self.logits.add( Conv2DNormed(channels=self.nfilters, kernel_size=(3, 3), padding=(1, 1))) self.logits.add(gluon.nn.Activation('relu')) self.logits.add( gluon.nn.Conv2D(self.NClasses, kernel_size=1, padding=0)) # bound logits self.bound_logits = gluon.nn.HybridSequential() self.bound_logits.add( Conv2DNormed(channels=self.nfilters, kernel_size=(3, 3), padding=(1, 1))) self.bound_logits.add(gluon.nn.Activation('relu')) self.bound_logits.add( gluon.nn.Conv2D(self.NClasses, kernel_size=1, padding=0)) # distance logits -- deeper for better reconstruction self.distance_logits = gluon.nn.HybridSequential() self.distance_logits.add( Conv2DNormed(channels=self.nfilters, kernel_size=(3, 3), padding=(1, 1))) self.distance_logits.add(gluon.nn.Activation('relu')) self.distance_logits.add( Conv2DNormed(channels=self.nfilters, kernel_size=(3, 3), padding=(1, 1))) self.distance_logits.add(gluon.nn.Activation('relu')) self.distance_logits.add( gluon.nn.Conv2D(self.NClasses, kernel_size=1, padding=0)) # This layer is trying to identify the exact coloration on HSV scale (cv2 devined) self.color_logits = gluon.nn.Conv2D(3, kernel_size=1, padding=0) # Last activation, customization for binary results if (self.NClasses == 1): self.ChannelAct = gluon.nn.HybridLambda( lambda F, x: F.sigmoid(x)) else: self.ChannelAct = gluon.nn.HybridLambda( lambda F, x: F.softmax(x, axis=1))