def build(self, input_shape):
self.kernel = self.add_weight(
name='kernel',
shape=(input_shape[1], self.field_num, self.factor_dim),
initializer=tf.random_normal_initializer(),
regularizer=l2(self.kernel_reg),
trainable=True)
self.weight = self.add_weight(
name='weight',
shape=(input_shape[1], 1),
initializer=tf.random_normal_initializer(),
regularizer=l2(self.weight_reg),
trainable=True)
self.bias = self.add_weight(name='bias',
shape=(1, ),
initializer=tf.zeros_initializer(),
trainable=True)
self.activate_layer = activations.get(self.activation)
def __init__(self,
units,
activation=None,
kernel_initializer=None,
batch_normalization=False,
**kwargs):
super(HyperDense, self).__init__(**kwargs)
batch_norm = batch_normalization
use_bias = not batch_normalization
dense_linear_layer = partial(Dense,
activation=None,
use_bias=use_bias,
kernel_initializer=kernel_initializer)
batch_norm_layer = BatchNormalization
self.dl_layer = dense_linear_layer(units)
self.bn_layer = batch_norm_layer() if batch_norm else None
self.activation = activations.get(activation)
self.batch_norm = batch_norm
def __init__(self,
filters,
kernel_size,
strides=(1, 1),
padding='valid',
data_format=None,
dilation_rate=(1, 1),
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
spectral_normalization=True,
bias_constraint=None,
**kwargs):
if data_format is None:
data_format = K.image_data_format()
super(Conv2D, self).__init__(
filters=filters,
kernel_size=kernel_size,
strides=strides,
padding=padding,
data_format=data_format,
dilation_rate=dilation_rate,
activation=activations.get(activation),
use_bias=use_bias,
kernel_initializer=initializers.get(kernel_initializer),
bias_initializer=initializers.get(bias_initializer),
kernel_regularizer=regularizers.get(kernel_regularizer),
bias_regularizer=regularizers.get(bias_regularizer),
activity_regularizer=regularizers.get(activity_regularizer),
kernel_constraint=constraints.get(kernel_constraint),
bias_constraint=constraints.get(bias_constraint),
**kwargs)
self.u = K.random_normal_variable(
[1, filters], 0, 1, dtype=self.dtype, name="sn_estimate") # [1, out_channels]
self.spectral_normalization = spectral_normalization
def __init__(self,
head_num,
name="attention",
activation='relu',
use_bias=True,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
history_only=False,
**kwargs):
"""Initialize the layer.
:param head_num: Number of heads.
:param activation: Activations for linear mappings.
:param use_bias: Whether to use bias term.
:param kernel_initializer: Initializer for linear mappings.
:param bias_initializer: Initializer for linear mappings.
:param kernel_regularizer: Regularizer for linear mappings.
:param bias_regularizer: Regularizer for linear mappings.
:param kernel_constraint: Constraints for linear mappings.
:param bias_constraint: Constraints for linear mappings.
:param history_only: Whether to only use history in attention layer.
"""
self.supports_masking = True
self.head_num = head_num
self.activation = activations.get(activation)
self.use_bias = use_bias
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.history_only = history_only
self.Wq, self.Wk, self.Wv, self.Wo = None, None, None, None
self.bq, self.bk, self.bv, self.bo = None, None, None, None
super(MultiHeadAttention, self).__init__(name=name, **kwargs)
def __init__(self,
rank,
filters,
kernel_size,
strides=1,
padding='valid',
data_format=None,
dilation_rate=1,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
spectral_normalization=True,
**kwargs):
super(_ConvSN, self).__init__(**kwargs)
self.rank = rank
self.filters = filters
self.kernel_size = conv_utils.normalize_tuple(kernel_size, rank,
'kernel_size')
self.strides = conv_utils.normalize_tuple(strides, rank, 'strides')
self.padding = conv_utils.normalize_padding(padding)
self.data_format = conv_utils.normalize_data_format(data_format)
self.dilation_rate = conv_utils.normalize_tuple(
dilation_rate, rank, 'dilation_rate')
self.activation = activations.get(activation)
self.use_bias = use_bias
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.input_spec = InputSpec(ndim=self.rank + 2)
self.spectral_normalization = spectral_normalization
self.u = None
def __init__(self,
filters,
kernel_size,
activation=None,
use_bias=True,
kernel_initializer='uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
normalize=False,
offset=None,
in_channels=None,
**kwargs):
from tensorflow.keras import activations, initializers, regularizers
self.filters = filters
self.kernel_size = kernel_size
self.activation = activations.get(activation)
self.use_bias = use_bias
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.normalize = normalize
if not (np.asarray(kernel_size) == kernel_size[0]).all():
raise Exception("Only cubic kernel sizes are supported.")
if offset is None:
if kernel_size[0] % 2:
self.offset = tf.zeros(shape=(3, ))
else:
self.offset = tf.fill([3], -0.5)
else:
self.offset = offset
self.fixed_radius_search = FixedRadiusSearch(metric='Linf',
ignore_query_point=False,
return_distances=False)
super().__init__(**kwargs)
def __init__(self,
units,
dropout_list:list = None,
activation=None,
kernel_initializer='glorot_norm',
bias_initializers='zeros',
l2_reg_list=None,
use_bn=False,
use_gate=False,
**kwargs):
self.units = list(map(int, units))
self.dropout_list = dropout_list
self.activation = activations.get(activation)
self.kernel_initializer = initializers.get(get_initializer(kernel_initializer))
self.bias_initializer = initializers.get(bias_initializers)
self.l2_reg_list = l2_reg_list
self.use_bn = use_bn
self.use_gate = use_gate
super(Mlp, self).__init__(**kwargs)
def __init__(self,
exp_base: int,
num_nodes: int,
use_bias: Optional[bool] = True,
activation: Optional[Text] = None,
kernel_initializer: Optional[Text] = 'glorot_uniform',
bias_initializer: Optional[Text] = 'zeros',
**kwargs) -> None:
if 'input_shape' not in kwargs and 'input_dim' in kwargs:
kwargs['input_shape'] = (kwargs.pop('input_dim'),)
super().__init__(**kwargs)
self.exp_base = exp_base
self.num_nodes = num_nodes
self.nodes = []
self.use_bias = use_bias
self.activation = activations.get(activation)
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
def build(self, input_shape):
self.kernel = self.add_weight(name='kernel',
shape=(input_shape[1], self.factor_dim),
initializer='glorot_uniform',
regularizer=l2(self.kernel_reg),
trainable=True)
if self.use_weight:
self.weight = self.add_weight(name='weight',
shape=(input_shape[1],
self.output_dim),
initializer='glorot_uniform',
regularizer=l2(self.weight_reg),
trainable=True)
if self.use_bias:
self.bias = self.add_weight(name='bias',
shape=(self.output_dim, ),
initializer='zeros',
trainable=True)
self.activate_layer = activations.get(self.activate)
super(FactorizationMachine, self).build(input_shape)
def __init__(
self,
k,
channels=None,
return_selection=False,
activation=None,
kernel_initializer="glorot_uniform",
kernel_regularizer=None,
kernel_constraint=None,
**kwargs
):
super().__init__(
return_selection=return_selection,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer,
kernel_constraint=kernel_constraint,
**kwargs
)
self.k = k
self.channels = channels
self.activation = activations.get(activation)
def __init__(self,
filters,
kernel_size,
kernel_initializer='glorot_uniform',
activation=None,
weights=None,
padding='valid',
strides=(1, 1),
data_format=None,
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
use_bias=True,
**kwargs):
if data_format is None:
data_format = K.image_data_format()
if padding not in {'valid', 'same', 'full'}:
raise ValueError('Invalid border mode for CosineConvolution2D:',
padding)
self.filters = filters
self.kernel_size = kernel_size
self.nb_row, self.nb_col = self.kernel_size
self.kernel_initializer = initializers.get(kernel_initializer)
self.activation = activations.get(activation)
self.padding = padding
self.strides = tuple(strides)
self.data_format = normalize_data_format(data_format)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.use_bias = use_bias
self.input_spec = [InputSpec(ndim=4)]
self.initial_weights = weights
super(CosineConvolution2D, self).__init__(**kwargs)
def __init__(self,
units,
use_bias=True,
activation="linear",
gate_kernel_regularizer=None,
gate_activity_regularizer=None,
gate_bias_regularizer=None,
linear_kernel_regularizer=None,
linear_activity_regularizer=None,
linear_bias_regularizer=None,
name="gated_unit",
**kwargs):
super(GatedUnit, self).__init__(name=name, **kwargs)
self.units = units
self.use_bias = use_bias
self.activation = activations.get(activation)
self.gate_kernel_regularizer = gate_kernel_regularizer
self.gate_activity_regularizer = gate_activity_regularizer
self.gate_bias_regularizer = gate_bias_regularizer
self.linear_kernel_regularizer = linear_kernel_regularizer
self.linear_activity_regularizer = linear_activity_regularizer
self.linear_bias_regularizer = linear_bias_regularizer
self.linear = layers.Dense(
units,
activation=activation,
use_bias=use_bias,
kernel_regularizer=linear_kernel_regularizer,
activity_regularizer=linear_activity_regularizer,
bias_regularizer=linear_bias_regularizer,
name=f"{name}/linear")
self.sigmoid = layers.Dense(
units,
activation="sigmoid",
use_bias=True,
kernel_regularizer=gate_kernel_regularizer,
activity_regularizer=gate_activity_regularizer,
bias_regularizer=gate_bias_regularizer,
name=f"{name}/sigmoid")
def __init__(self,
activation=None,
use_bias=False,
real_kernel_initializer='uniform',
imag_kernel_initializer='zeros',
kernel_regularizer=None,
bias_initializer='zeros',
seed=None,
**kwargs):
super(Complex_deconv, self).__init__(**kwargs)
self.use_bias = use_bias
self.activation = activations.get(activation)
self.real_kernel_initializer = initializers.get(
real_kernel_initializer)
self.imag_kernel_initializer = initializers.get(
imag_kernel_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_initializer = initializers.get(bias_initializer)
if seed == None:
self.seed = np.random.randint(1, 10e6)
else:
self.seed = seed
def __init__(
self,
units,
num_relationships,
num_bases=0,
activation=None,
use_bias=True,
final_layer=False,
**kwargs
):
if "input_shape" not in kwargs and "input_dim" in kwargs:
kwargs["input_shape"] = (kwargs.get("input_dim"),)
super().__init__(**kwargs)
if not isinstance(num_bases, int):
raise TypeError("num_bases should be an int")
if not isinstance(units, int):
raise TypeError("units should be an int")
if units <= 0:
raise ValueError("units should be positive")
if not isinstance(num_relationships, int):
raise TypeError("num_relationships should be an int")
if num_relationships <= 0:
raise ValueError("num_relationships should be positive")
self.units = units
self.num_relationships = num_relationships
self.num_bases = num_bases
self.activation = activations.get(activation)
self.use_bias = use_bias
self._get_regularisers_from_keywords(kwargs)
self.final_layer = final_layer
super().__init__(**kwargs)
def __init__(self,
filters,
kernel_size,
groups,
strides=(1, 1),
padding='valid',
data_format=None,
dilation_rate=(1, 1),
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs):
super(GroupConv2D, self).__init__(
rank=2,
filters=filters,
kernel_size=kernel_size,
groups=groups,
strides=strides,
padding=padding.upper(),
data_format=data_format,
dilation_rate=dilation_rate,
activation=activations.get(activation),
use_bias=use_bias,
kernel_initializer=initializers.get(kernel_initializer),
bias_initializer=initializers.get(bias_initializer),
kernel_regularizer=regularizers.get(kernel_regularizer),
bias_regularizer=regularizers.get(bias_regularizer),
activity_regularizer=regularizers.get(activity_regularizer),
kernel_constraint=constraints.get(kernel_constraint),
bias_constraint=constraints.get(bias_constraint),
**kwargs)
def __init__(self,
units,
concat=False,
use_bias=True,
agg_method='mean',
activation=None,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs):
super().__init__(**kwargs)
self.units = units
self.concat = concat
self.use_bias = use_bias
self.agg_method = agg_method
self.aggregator = {'mean': tf.reduce_mean, 'sum': tf.reduce_sum,
'max': tf.reduce_max, 'min': tf.reduce_min}[agg_method]
self.activation = activations.get(activation)
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
if concat:
self.output_dim = units * 2
else:
self.output_dim = units
def __init__(self, in_channels, out_channels,
hiddens=[16],
activations=['relu'],
dropout=0.5,
weight_decay=5e-4,
lr=0.01, use_bias=True):
super().__init__()
self.convs = []
inc = in_channels
for hidden, activation in zip(hiddens, activations):
layer = GraphConv(inc, hidden, bias=use_bias,
activation=get(activation))
self.convs.append(layer)
inc = hidden
layer = GraphConv(inc, out_channels, bias=use_bias)
self.convs.append(layer)
self.dropout = layers.Dropout(dropout)
self.compile(loss=SparseCategoricalCrossentropy(from_logits=True),
optimizer=Adam(lr=lr), metrics=['accuracy'])
self.weight_decay = weight_decay
self.metric = SparseCategoricalAccuracy()
def __init__(self,
output_dim: int,
decomp_size: int,
use_bias: Optional[bool] = True,
activation: Optional[Text] = None,
kernel_initializer: Optional[Text] = 'glorot_uniform',
bias_initializer: Optional[Text] = 'zeros',
**kwargs) -> None:
# Allow specification of input_dim instead of input_shape,
# for compatability with Keras layers that support this
if 'input_shape' not in kwargs and 'input_dim' in kwargs:
kwargs['input_shape'] = (kwargs.pop('input_dim'), )
super().__init__(**kwargs)
self.output_dim = output_dim
self.decomp_size = decomp_size
self.use_bias = use_bias
self.activation = activations.get(activation)
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
def __init__(self,
units,
m_w,
m_b,
activation=None,
kernel_initializer='glorot_uniform',
kernel_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
**kwargs):
if 'input_shape' not in kwargs and 'input_dim' in kwargs:
kwargs['input_shape'] = (kwargs.pop('input_dim'), )
super(CBFD, self).__init__(**kwargs)
self.units = units
self.mw = m_w
self.mb = m_b
self.activation = activations.get(activation)
self.kernel_initializer = initializers.get(kernel_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.input_spec = InputSpec(min_ndim=2)
self.supports_masking = True
def __init__(self,
units,
use_bias=True,
agg_method='mean',
activation=None,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs):
kwargs.pop('concat',
None) # in order to be compatible with `MeanAggregator`
super().__init__(**kwargs)
self.units = units
self.use_bias = use_bias
self.agg_method = agg_method
self.aggregator = {
'mean': tf.reduce_mean,
'sum': tf.reduce_sum,
'max': tf.reduce_max,
'min': tf.reduce_min
}[agg_method]
self.activation = activations.get(activation)
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
def __init__(
self,
channels,
order=1,
iterations=1,
share_weights=False,
gcn_activation="relu",
dropout_rate=0.0,
activation=None,
use_bias=True,
kernel_initializer="glorot_uniform",
bias_initializer="zeros",
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs
):
super().__init__(
activation=activation,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer,
kernel_regularizer=kernel_regularizer,
bias_regularizer=bias_regularizer,
activity_regularizer=activity_regularizer,
kernel_constraint=kernel_constraint,
bias_constraint=bias_constraint,
**kwargs
)
self.channels = channels
self.iterations = iterations
self.order = order
self.share_weights = share_weights
self.gcn_activation = activations.get(gcn_activation)
self.dropout_rate = dropout_rate
def __init__(
self,
channels,
epsilon=None,
mlp_hidden=None,
mlp_activation="relu",
mlp_batchnorm=True,
aggregate="sum",
activation=None,
use_bias=True,
kernel_initializer="glorot_uniform",
bias_initializer="zeros",
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs
):
super().__init__(
aggregate=aggregate,
activation=activation,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer,
kernel_regularizer=kernel_regularizer,
bias_regularizer=bias_regularizer,
activity_regularizer=activity_regularizer,
kernel_constraint=kernel_constraint,
bias_constraint=bias_constraint,
**kwargs
)
self.channels = channels
self.epsilon = epsilon
self.mlp_hidden = mlp_hidden if mlp_hidden else []
self.mlp_activation = activations.get(mlp_activation)
self.mlp_batchnorm = mlp_batchnorm
def __init__(self,
filters,
kernel_size,
alpha=0.5,
strides=1,
padding='valid',
data_format='channels_last',
dilation_rate=1,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs):
super(OctConv1D, self).__init__(
rank=1,
filters=filters,
kernel_size=kernel_size,
alpha=alpha,
strides=strides,
padding=padding,
data_format=data_format,
dilation_rate=dilation_rate,
activation=activations.get(activation),
use_bias=use_bias,
kernel_initializer=initializers.get(kernel_initializer),
bias_initializer=initializers.get(bias_initializer),
kernel_regularizer=regularizers.get(kernel_regularizer),
bias_regularizer=regularizers.get(bias_regularizer),
activity_regularizer=regularizers.get(activity_regularizer),
kernel_constraint=constraints.get(kernel_constraint),
bias_constraint=constraints.get(bias_constraint),
**kwargs)
def __init__(self,
state_sync=False,
decode=False,
output_length=None,
return_states=False,
readout=False,
readout_activation='linear',
teacher_force=False,
state_initializer=None,
**kwargs):
self.state_sync = state_sync
self.cells = []
if decode and output_length is None:
raise Exception('output_length should be specified for decoder')
self.decode = decode
self.output_length = output_length
if decode:
if output_length is None:
raise Exception(
'output_length should be specified for decoder')
kwargs['return_sequences'] = True
self.return_states = return_states
super(RecurrentModel, self).__init__(**kwargs)
self.readout = readout
self.readout_activation = activations.get(readout_activation)
self.teacher_force = teacher_force
self._optional_input_placeholders = {}
if state_initializer:
if type(state_initializer) in [list, tuple]:
state_initializer = [
initializers.get(init)
if init else initializers.get('zeros')
for init in state_initializer
]
else:
state_initializer = initializers.get(state_initializer)
self._state_initializer = state_initializer
def __init__(self,
units,
activation=None,
use_bias=True,
sigma_init=0.017,
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
std_func=None,
sigma_func=None,
**kwargs):
if 'input_shape' not in kwargs and 'input_dim' in kwargs:
kwargs['input_shape'] = (kwargs.pop('input_dim'),)
super(NoisyDense, self).__init__(activity_regularizer=regularizers.get(activity_regularizer), **kwargs)
self.units = int(units) if not isinstance(units, int) else units
self.activation = activations.get(activation)
self.use_bias = use_bias
self.sigma_init = sigma_init
self.std_func = std_func
self.sigma_func = sigma_func
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.supports_masking = True
self.input_spec = InputSpec(min_ndim=2)
# pylint was complaining
self.mu_weights = None
self.sigma_weights = None
self.mu_bias = None
self.sigma_bias = None
def __init__(self,
units,
activation=None,
use_bias=True,
init_criterion='he',
kernel_initializer='complex',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
seed=None,
**kwargs):
if 'input_shape' not in kwargs and 'input_dim' in kwargs:
kwargs['input_shape'] = (kwargs.pop('input_dim'), )
super(ComplexDense, self).__init__(**kwargs)
self.units = units
self.activation = activations.get(activation)
self.use_bias = use_bias
self.init_criterion = init_criterion
if kernel_initializer in {'complex'}:
self.kernel_initializer = kernel_initializer
else:
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
if seed is None:
self.seed = np.random.randint(1, 10e6)
else:
self.seed = seed
self.input_spec = InputSpec(ndim=2)
self.supports_masking = True
def __init__(
self,
channels=256,
batch_norm=True,
dropout=0.0,
aggregate="sum",
activation="prelu",
use_bias=True,
kernel_initializer="glorot_uniform",
bias_initializer="zeros",
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs
):
super().__init__(
aggregate=aggregate,
activation=None,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer,
kernel_regularizer=kernel_regularizer,
bias_regularizer=bias_regularizer,
activity_regularizer=activity_regularizer,
kernel_constraint=kernel_constraint,
bias_constraint=bias_constraint,
**kwargs
)
self.channels = channels
self.dropout_rate = dropout
self.use_batch_norm = batch_norm
if activation == "prelu" or "prelu" in kwargs:
self.activation = PReLU()
else:
self.activation = activations.get(activation)
def __init__(self, units,
use_bias=False,
activation=None,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs):
super().__init__(**kwargs)
self.units = units
self.use_bias = use_bias
self.activation = activations.get(activation)
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
def __init__(self,
channels,
activation=None,
use_bias=True,
kernel_initializer='glorot_uniform',
bias_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
**kwargs):
super().__init__(activity_regularizer=activity_regularizer, **kwargs)
self.channels = channels
self.activation = activations.get(activation)
self.use_bias = use_bias
self.kernel_initializer = initializers.get(kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.supports_masking = False
def __init__(self,
implementation=3,
kernel_regularizer=None,
activity_regularizer=None,
nonneg=False,
activation="linear",
use_bias=False,
name="local_lasso",
**kwargs):
super(LocalLasso, self).__init__(name=name, **kwargs)
self.implementation = implementation
self.kernel_regularizer = kernel_regularizer
self.activity_regularizer = activity_regularizer
self.nonneg = nonneg
self.activation = activations.get(activation)
self.use_bias = use_bias
if kernel_regularizer is None and (activity_regularizer is not None):
kernel_regularizer = tf.keras.regularizers.L1(1e-3)
if nonneg:
weight_constraint = tf.keras.constraints.NonNeg()
else:
weight_constraint = None
self.lasso = tf.keras.layers.LocallyConnected1D(
1,
1,
activation=activation,
implementation=implementation,
use_bias=use_bias,
kernel_regularizer=kernel_regularizer,
activity_regularizer=activity_regularizer,
kernel_constraint=weight_constraint,
name=f"{name}/lasso")
return
