def __init__(self, *args, axis=1, activation='relu'): """ Parameters ---------- layer_defs : object """ super(ConcateBlock, self).__init__() self.activation = get_activation(activation) self.axis = axis self.has_identity = False for i in range(len(args)): arg = args[i] if isinstance(arg, (Layer, list, dict)): if isinstance(arg, list): arg = Sequential(*arg) elif isinstance(arg, dict) and len(args) == 1: for k, v in arg.items(): if isinstance(v, Identity): self.has_identity = True self.add_module('Identity', v) else: self.add_module(k, v) elif isinstance(arg, dict) and len(args) > 1: raise ValueError( 'more than one dict argument is not support.') elif isinstance(arg, Identity): self.has_identity = True self.add_module('Identity', arg) else: self.add_module('branch{0}'.format(i + 1), arg) if len(self._modules) == 1 and self.has_identity == False: self.add_module('Identity', Identity())
def __init__(self, kernel_size=(3, 3), num_filters=None, strides=1, auto_pad=True, padding_mode='zero', activation=None, normalization=None, use_spectral=False, use_bias=False, dilation=1, groups=1, add_noise=False, noise_intensity=0.005, dropout_rate=0, name=None, depth_multiplier=None, sequence_rank='cna', **kwargs): super(TransConv2d_Block, self).__init__(name=name) if sequence_rank in ['cna', 'nac']: self.sequence_rank = sequence_rank self.kernel_size = kernel_size self.num_filters = num_filters self.strides = strides self.auto_pad = auto_pad self.use_bias = use_bias self.dilation = dilation self.groups = groups self.add_noise = add_noise self.noise_intensity = noise_intensity self.dropout_rate = dropout_rate self.depth_multiplier = depth_multiplier self.use_spectral = use_spectral if not self.use_spectral: self.conv = TransConv2d(kernel_size=self.kernel_size, num_filters=self.num_filters, strides=self.strides, auto_pad=self.auto_pad, activation=None, use_bias=self.use_bias, dilation=self.dilation, groups=self.groups, name=self._name, depth_multiplier=self.depth_multiplier) self.norm = get_normalization(normalization) self.activation = get_activation(activation) self.droupout = None
def __init__(self, kernel_size=(3, 3), depth_multiplier=1, strides=1, auto_pad=True, padding=None, padding_mode='zero', activation=None, normalization=None, use_spectral=False, use_bias=False, dilation=1, groups=1, add_noise=False, noise_intensity=0.005, dropout_rate=0, name=None, keep_output=False, sequence_rank='cna', **kwargs): super(DepthwiseConv2d_Block, self).__init__(name=name) if sequence_rank in ['cna', 'nac']: self.sequence_rank = sequence_rank self.kernel_size = kernel_size self.depth_multiplier = depth_multiplier self.strides = strides self.auto_pad = auto_pad self.padding = 0 self.padding_mode = padding_mode # if self.auto_pad == False: # self.padding = 0 # else: # self.padding= tuple([n-2 for n in list(self.kernel_size)]) if hasattr(self.kernel_size,'__len__') else # self.kernel_size-2 self.use_bias = use_bias self.dilation = dilation self.add_noise = add_noise self.noise_intensity = noise_intensity self.dropout_rate = dropout_rate self.conv = None self.norm = get_normalization(normalization) self.use_spectral = use_spectral self.activation = get_activation(activation) self.droupout = None self.keep_output = keep_output self._name = name
def __init__(self, se_filters, num_filters, is_gather_excite=False, use_bias=False, name=''): super(SqueezeExcite, self).__init__(name=name) self.se_filters = se_filters self.num_filters = num_filters self.squeeze = None self.excite = None self.is_gather_excite = is_gather_excite self.activation = get_activation('swish') self.pool = GlobalAvgPool2d(keepdim=True) self.use_bias = use_bias
def __init__(self, kernel_size=(3, 3, 3), num_filters=32, strides=1, input_shape=None, auto_pad=True, activation='leaky_relu', normalization=None, use_bias=False, dilation=1, groups=1, add_noise=False, noise_intensity=0.001, dropout_rate=0, name=None, sequence_rank='cna', **kwargs): super(TransConv3d_Block, self).__init__(name=name) if sequence_rank in ['cna', 'nac']: self.sequence_rank = sequence_rank if add_noise: noise = tf.keras.layers.GaussianNoise(noise_intensity) self.add(noise) self._conv = TransConv3d(kernel_size=kernel_size, num_filters=num_filters, strides=strides, input_shape=input_shape, auto_pad=auto_pad, activation=None, use_bias=use_bias, dilation=dilation, groups=groups) self.add(self._conv) self.norm = get_normalization(normalization) if self.norm is not None: self.add(self.norm) self.activation = get_activation(snake2camel(activation)) if self.activation is not None: self.add(self.activation) if dropout_rate > 0: self.drop = Dropout(dropout_rate) self.add(self.drop)
def __init__(self, *args, axis=-1, branch_from=None, activation=None, mode='add', name=None, keep_output=False, **kwargs): """ Args layer_defs : object """ super(ShortCut2d, self).__init__(name=name) self.activation = get_activation(activation) self.has_identity = False self.mode = mode if isinstance(mode, str) else mode self.axis = axis self.branch_from = branch_from self.branch_from_uuid = None self.keep_output = keep_output for i in range(len(args)): arg = args[i] if isinstance(arg, (Layer, tf.Tensor, list, dict)): if isinstance(arg, list): arg = Sequential(*arg) elif isinstance(arg, OrderedDict) and len(args) == 1: for k, v in arg.items(): if isinstance(v, Identity): self.has_identity = True self.add_module('Identity', v) else: self.add_module(k, v) elif isinstance(arg, dict) and len(args) == 1: keys = sorted(list(arg.keys())) for k in keys: v = arg[k] if isinstance(v, Identity): self.has_identity = True self.add_module('Identity', v) else: self.add_module(str(k), v) elif isinstance(arg, (dict, OrderedDict)) and len(args) > 1: raise ValueError( 'more than one dict argument is not support.') elif isinstance(arg, Identity): self.has_identity = True self.add_module('Identity', arg) elif isinstance(arg, Layer): if len(arg.name) > 0 and arg.name != arg._name: self.add_module(arg.name, arg) else: self.add_module('branch{0}'.format(i + 1), arg) else: raise ValueError('{0} is not support.'.format( arg.__class__.__name)) if len( self._modules ) == 1 and self.has_identity == False and self.branch_from is None: self.has_identity = True self.add_module('Identity', Identity())
def __init__(self, kernel_size=3, num_filters=None, strides=1, auto_pad=True, padding_mode='zero', activation=None, normalization=None, use_spectral=False, use_bias=False, dilation=1, groups=1, add_noise=False, noise_intensity=0.005, dropout_rate=0, name=None, depth_multiplier=None, keep_output=False, sequence_rank='cna', **kwargs): super(Conv1d_Block, self).__init__(name=name, keep_output=keep_output) if sequence_rank in ['cna', 'nac']: self.sequence_rank = sequence_rank else: self.sequence_rank = 'cna' self.kernel_size = kernel_size self.num_filters = num_filters self.strides = strides self.auto_pad = auto_pad self.padding = 0 self.padding_mode = padding_mode # if self.auto_pad == False: # self.padding = 0 # else: # self.padding= tuple([n-2 for n in list(self.kernel_size)]) if hasattr(self.kernel_size,'__len__') else # self.kernel_size-2 self.use_bias = use_bias self.dilation = dilation self.groups = groups self.depth_multiplier = depth_multiplier self.add_noise = add_noise self.noise_intensity = noise_intensity self.dropout_rate = dropout_rate norm = get_normalization(normalization) conv = Conv1d(kernel_size=self.kernel_size, num_filters=self.num_filters, strides=self.strides, auto_pad=self.auto_pad, padding_mode=self.padding_mode, activation=None, use_bias=self.use_bias, dilation=self.dilation, groups=self.groups, name=self._name, depth_multiplier=self.depth_multiplier) self.use_spectral = use_spectral # if isinstance(norm, SpectralNorm): # self.use_spectral = True # norm = None # conv= nn.utils.spectral_norm(conv) if (hasattr(self, 'sequence_rank') and self.sequence_rank == 'cna') or not hasattr(self, 'sequence_rank'): self.conv = conv self.norm = norm self.activation = get_activation(activation) elif self.sequence_rank == 'nac': self.norm = norm self.activation = get_activation(activation) self.conv = conv
def __init__(self, kernel_size=(3, 3), num_filters=None, strides=1, auto_pad=True, padding_mode='zero', activation=None, normalization=None, use_spectral=False, use_bias=False, dilation=1, groups=1, add_noise=False, noise_intensity=0.005, dropout_rate=0, name=None, depth_multiplier=None, keep_output=False, sequence_rank='cna', **kwargs): super(Conv2d_Block, self).__init__(name=name) if sequence_rank in ['cna', 'nac']: self.sequence_rank = sequence_rank self.kernel_size = kernel_size self.num_filters = num_filters self.strides = strides self.keep_output = keep_output padding = kwargs.get('padding', None) if 'padding' in kwargs: kwargs.pop('padding') if isinstance(padding, str) and auto_pad == False: auto_pad = (padding.lower() == 'same') elif isinstance(padding, int) and padding > 0: padding = _pair(padding) auto_pad = False elif isinstance(padding, tuple): auto_pad = False pass self.auto_pad = auto_pad self.padding = padding self.use_bias = use_bias self.dilation = dilation self.groups = groups self.add_noise = add_noise self.noise_intensity = noise_intensity self.dropout_rate = dropout_rate self.depth_multiplier = depth_multiplier self.use_spectral = use_spectral if not self.use_spectral: self.conv = Conv2d(kernel_size=self.kernel_size, num_filters=self.num_filters, strides=self.strides, auto_pad=self.auto_pad, activation=None, use_bias=self.use_bias, dilation=self.dilation, groups=self.groups, depth_multiplier=self.depth_multiplier, padding=self.padding, **kwargs) self.norm = get_normalization(normalization) self.activation = get_activation(activation) self.droupout = None
def __init__(self, num_filters=None, activation=None, normalization=None, use_spectral=False, use_bias=False, add_noise=False, noise_intensity=0.005, dropout_rate=0, name=None, depth_multiplier=None, keep_output=False, sequence_rank='cna', **kwargs): super(FullConnect_Block, self).__init__(name=name, keep_output=keep_output) if sequence_rank in ['fna', 'naf', 'afn']: self.sequence_rank = sequence_rank else: self.sequence_rank = 'fna' self.num_filters = num_filters self.use_bias = use_bias self.add_noise = add_noise self.noise_intensity = noise_intensity self.dropout_rate = dropout_rate self.droupout = None self.depth_multiplier = depth_multiplier self.keep_output = keep_output norm = get_normalization(normalization) fc = Dense(num_filters=self.num_filters, activation=None, use_bias=self.use_bias, depth_multiplier=self.depth_multiplier).to(self.device) self.use_spectral = use_spectral if isinstance(norm, SpectralNorm): self.use_spectral = True norm = None fc = SpectralNorm(module=fc) if (hasattr(self, 'sequence_rank') and self.sequence_rank == 'fna') or not hasattr(self, 'sequence_rank'): self.add_module('fc', fc) self.add_module('norm', norm) self.add_module('activation', get_activation(activation, only_layer=True)) elif self.sequence_rank == 'naf': self.add_module('norm', norm) self.add_module('activation', get_activation(activation, only_layer=True)) self.add_module('fc', fc) elif self.sequence_rank == 'afn': self.add_module('activation', get_activation(activation, only_layer=True)) self.add_module('fc', fc) self.add_module('norm', norm) self._name = name
def __init__(self, *args, axis=-1, branch_from=None, activation=None, mode='add', name=None, keep_output=False, **kwargs): """ Args: *args (): axis (): branch_from (): activation (): mode (str): 'add' 'dot' 'concate' name (str): keep_output (bool): **kwargs (): """ super(ShortCut, self).__init__(name=name, keep_output=keep_output) valid_mode = ['add', 'subtract', 'concate', 'dot', 'maxout'] if mode in valid_mode: self.mode = mode else: raise ValueError( '{0} is not valid mode. please use one of {1}'.format( mode, valid_mode)) self.activation = get_activation(activation) self.has_identity = False self.axis = axis self.branch_from = branch_from self.branch_from_uuid = None self.keep_output = keep_output for i in range(len(args)): arg = args[i] if isinstance(arg, (Layer, Tensor, list, dict)): if isinstance(arg, list): arg = Sequential(*arg) elif isinstance(arg, OrderedDict) and len(args) == 1: for k, v in arg.items(): if isinstance(v, Identity): self.has_identity = True self.add_module('Identity', v) else: self.add_module(k, v) elif isinstance(arg, dict) and len(args) == 1: keys = sorted(list(arg.keys())) for k in keys: v = arg[k] if isinstance(v, Identity): self.has_identity = True self.add_module('Identity', v) else: self.add_module(str(k), v) elif isinstance(arg, (dict, OrderedDict)) and len(args) > 1: raise ValueError( 'more than one dict argument is not support.') elif isinstance(arg, Identity): self.has_identity = True self.add_module('Identity', arg) elif isinstance(arg, Layer): if len(arg.name) > 0 and arg.name != arg.default_name: self.add_module(arg.name, arg) else: self.add_module('branch{0}'.format(i + 1), arg) else: raise ValueError('{0} is not support.'.format( arg.__class__.__name)) if len( self._modules ) == 1 and self.has_identity == False and self.branch_from is None and mode != 'concate': self.has_identity = True self.add_module('Identity', Identity()) self.to(self.device)