def get_config(self):
config = {'units': self.units,
'projection_units': self.projection_units,
'activation': activations.serialize(self.activation),
'recurrent_activation': activations.serialize(self.recurrent_activation),
'projection_activation': activations.serialize(self.projection_activation),
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'recurrent_initializer': initializers.serialize(self.recurrent_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'projection_initializer': initializers.serialize(self.projection_initializer),
'unit_forget_bias': self.unit_forget_bias,
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'projection_regularizer': regularizers.serialize(self.projection_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'recurrent_constraint': constraints.serialize(self.recurrent_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint),
'projection_constraint': constraints.serialize(self.projection_constraint),
'dropout': self.dropout,
'recurrent_dropout': self.recurrent_dropout,
'implementation': self.implementation}
base_config = super(NASRNN, self).get_config()
del base_config['cell']
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'filters': self.filters,
'kernel_size': self.kernel_size,
'strides': self.strides,
'padding': self.padding,
'data_format': self.data_format,
'dilation_rate': self.dilation_rate,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint),
'input_dim': self.input_dim,
'learnedKernel': self.tied_to.get_weights()[0],
'input_length': self.input_length}
config2 = {'layer_inner': {'bias': np.asarray(self.tied_to.get_weights()[1]),
'weights': np.asarray(self.tied_to.get_weights()[0]),
'class_name': self.tied_to.__class__.__name__,
'config': self.tied_to.get_config()}}
base_config = super(Convolution1D_tied, self).get_config()
return dict(list(base_config.items()) + list(config.items()) + list(config2.items()))
def get_config(self):
config = {
'alpha_initializer': initializers.serialize(self.alpha_initializer),
'alpha_regularizer': regularizers.serialize(self.alpha_regularizer),
'alpha_constraint': constraints.serialize(self.alpha_constraint),
'beta_initializer': initializers.serialize(self.beta_initializer),
'beta_regularizer': regularizers.serialize(self.beta_regularizer),
'beta_constraint': constraints.serialize(self.beta_constraint),
'shared_axes': self.shared_axes
}
base_config = super(ParametricSoftplus, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'init': initializers.serialize(self.init),
'activation': activations.serialize(self.activation),
'W_regularizer': regularizers.serialize(self.W_regularizer),
'b_regularizer': regularizers.serialize(self.b_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'W_constraint': constraints.serialize(self.W_constraint),
'b_constraint': constraints.serialize(self.b_constraint),
'bias': self.bias,
'input_dim': self.input_dim}
base_config = super(Highway, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'axis': self.axis,
'epsilon': self.epsilon,
'center': self.center,
'scale': self.scale,
'beta_initializer': initializers.serialize(self.beta_initializer),
'gamma_initializer': initializers.serialize(self.gamma_initializer),
'beta_regularizer': regularizers.serialize(self.beta_regularizer),
'gamma_regularizer': regularizers.serialize(self.gamma_regularizer),
'beta_constraint': constraints.serialize(self.beta_constraint),
'gamma_constraint': constraints.serialize(self.gamma_constraint)
}
base_config = super(InstanceNormalization, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'name': self.__class__.__name__,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'downsampling_factor': self.downsampling_factor}
base_config = super().get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units': self.units,
'bond_classes': self.bond_classes,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint)
}
base_config = super(EdgeNetwork, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'activation': activations.serialize(self.activation),
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
}
return dict(config)
def get_config(self):
config = {'epsilon': self.epsilon,
'axis': self.axis,
'center': self.center,
'scale': self.scale,
'momentum': self.momentum,
'gamma_regularizer': initializers.serialize(self.gamma_regularizer),
'beta_regularizer': initializers.serialize(self.beta_regularizer),
'moving_mean_initializer': initializers.serialize(self.moving_mean_initializer),
'moving_variance_initializer': initializers.serialize(self.moving_variance_initializer),
'beta_constraint': constraints.serialize(self.beta_constraint),
'gamma_constraint': constraints.serialize(self.gamma_constraint),
'r_max_value': self.r_max_value,
'd_max_value': self.d_max_value,
't_delta': self.t_delta}
base_config = super(BatchRenormalization, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'nb_complex': self.nb_complex,
'filter_delays':self.filter_delays,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint)}
base_config = super(SpatioTemporalFilterComplex, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units':
self.units,
# 'kernel_size': self.kernel_size,
'strides':
self.strides,
'padding':
self.padding,
'data_format':
self.data_format,
'dilation_rate':
self.dilation_rate,
'activation':
activations.serialize(self.activation),
'recurrent_activation':
activations.serialize(self.recurrent_activation),
'use_bias':
self.use_bias,
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
'recurrent_initializer':
initializers.serialize(self.recurrent_initializer),
'bias_initializer':
initializers.serialize(self.bias_initializer),
'unit_forget_bias':
self.unit_forget_bias,
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'recurrent_regularizer':
regularizers.serialize(self.recurrent_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'recurrent_constraint':
constraints.serialize(self.recurrent_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint),
'dropout':
self.dropout,
'recurrent_dropout':
self.recurrent_dropout
}
base_config = super(ConvLSTM2DCell, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units': self.units,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint),
'is_placeholder': False
}
base_config = super(Smooth, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units':
self.units,
'activation':
activations.serialize(self.activation),
'recurrent_activation':
activations.serialize(self.recurrent_activation),
'beta':
self.beta,
'use_bias':
self.use_bias,
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
'recurrent_initializer':
initializers.serialize(self.recurrent_initializer),
'bias_initializer':
initializers.serialize(self.bias_initializer),
'use_chrono_initialization':
self.use_chrono_initialization,
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'recurrent_regularizer':
regularizers.serialize(self.recurrent_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'recurrent_constraint':
constraints.serialize(self.recurrent_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint),
'dropout':
self.dropout,
'recurrent_dropout':
self.recurrent_dropout,
'implementation':
self.implementation,
'max_timesteps':
self.max_timesteps
}
base_config = super(JANet, self).get_config()
del base_config['cell']
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'kernel_initializer': initializers.serialize(self.kernel_initializer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'axis': self.axis}
base_config = super(AutoPool, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'activation': self.activation,
'model_size': self.model_size,
'W1_regularizer': regularizers.serialize(self.W1_regularizer),
'W2_regularizer': regularizers.serialize(self.W2_regularizer),
'b1_regularizer': regularizers.serialize(self.b1_regularizer),
'b2_regularizer': regularizers.serialize(self.b2_regularizer),
'W1_constraint': constraints.serialize(self.W1_constraint),
'W2_constraint': constraints.serialize(self.W2_constraint),
'b1_constraint': constraints.serialize(self.b1_constraint),
'b2_constraint': constraints.serialize(self.b2_constraint),
'bias1': self.bias1,
'bias2': self.bias2
}
base_config = super(RemappedCoAttentionWeight, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'filters':
self.filters,
'kernel_size':
self.kernel_size,
'strides':
self.strides,
'padding':
self.padding,
'data_format':
self.data_format,
'dilation_rate':
self.dilation_rate,
'activation':
activations.serialize(self.activation),
'recurrent_activation':
activations.serialize(self.recurrent_activation),
'use_bias':
self.use_bias,
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
'recurrent_initializer':
initializers.serialize(self.recurrent_initializer),
'bias_initializer':
initializers.serialize(self.bias_initializer),
'unit_forget_bias':
self.unit_forget_bias,
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'recurrent_regularizer':
regularizers.serialize(self.recurrent_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'recurrent_constraint':
constraints.serialize(self.recurrent_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint)
}
base_config = super(BottleneckLSTM2D, self).get_config()
del base_config['cell']
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
"axis": self.axis,
"epsilon": self.epsilon,
"center": self.center,
"scale": self.scale,
"beta_initializer": initializers.serialize(self.beta_initializer),
"gamma_initializer":
initializers.serialize(self.gamma_initializer),
"beta_regularizer": regularizers.serialize(self.beta_regularizer),
"gamma_regularizer":
regularizers.serialize(self.gamma_regularizer),
"beta_constraint": constraints.serialize(self.beta_constraint),
"gamma_constraint": constraints.serialize(self.gamma_constraint),
}
base_config = super().get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'tau_initializer': initializers.serialize(self.tau_initializer),
'tau_regularizer': regularizers.serialize(self.tau_regularizer),
'tau_constraint': constraints.serialize(self.tau_constraint)
}
base_config = super(TLU, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'output_dim': self.output_dim,
'num_filters': self.num_filters,
'graph_conv_filters': self.graph_conv_filters,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint)
}
base_config = super(GraphCNN, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'axis': self.axis,
'epsilon': self.epsilon,
'center': self.center,
'scale': self.scale,
'beta_initializer': initializers.serialize(self.beta_initializer),
'gamma_initializer':
initializers.serialize(self.gamma_initializer),
'beta_regularizer': regularizers.serialize(self.beta_regularizer),
'gamma_regularizer':
regularizers.serialize(self.gamma_regularizer),
'beta_constraint': constraints.serialize(self.beta_constraint),
'gamma_constraint': constraints.serialize(self.gamma_constraint)
}
base_config = super(InstanceNormalization, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
"output_shape": self.partial_output_shape,
"equation": self.equation,
"activation": activations.serialize(self.activation),
"bias_axes": self.bias_axes,
"kernel_initializer": initializers.serialize(self.kernel_initializer),
"bias_initializer": initializers.serialize(self.bias_initializer),
"kernel_regularizer": regularizers.serialize(self.kernel_regularizer),
"bias_regularizer": regularizers.serialize(self.bias_regularizer),
"activity_regularizer":
regularizers.serialize(self.activity_regularizer),
"kernel_constraint": constraints.serialize(self.kernel_constraint),
"bias_constraint": constraints.serialize(self.bias_constraint),
}
base_config = super(EinsumDense, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'kernel_initializer': initializers.serialize(self.kernel_initializer),
'activation': activations.serialize(self.activation),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
}
base_config = super(O2Transform, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units':
self.units,
'interval_dim':
self.interval_dim,
'weight_dim':
self.weight_dim,
'activation':
activations.serialize(self.activation),
'recurrent_activation':
activations.serialize(self.recurrent_activation),
'use_bias':
self.use_bias,
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
'recurrent_initializer':
initializers.serialize(self.recurrent_initializer),
'bias_initializer':
initializers.serialize(self.bias_initializer),
'unit_forget_bias':
self.unit_forget_bias,
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'recurrent_regularizer':
regularizers.serialize(self.recurrent_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'recurrent_constraint':
constraints.serialize(self.recurrent_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint),
'dropout':
self.dropout,
'recurrent_dropout':
self.recurrent_dropout,
'implementation':
self.implementation
}
base_config = super(BLSTM, self).get_config()
del base_config['cell']
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'input_dim': self.input_dim,
'output_dim': self.output_dim,
'data_format': self.data_format,
'activation': self.activation,
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint)
}
base_config = super(TensorProd2D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units': self.units,
'initializer': initializers.serialize(self.initializer),
'regularizer': regularizers.serialize(self.regularizer),
'constraint': constraints.serialize(self.constraint)
}
base_config = super(Constant, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'a_initializer': initializers.serialize(self.a_initializer),
'a_regularizer': regularizers.serialize(self.a_regularizer),
'a_constraint': constraints.serialize(self.a_constraint),
'k_initializer': initializers.serialize(self.k_initializer),
'k_regularizer': regularizers.serialize(self.k_regularizer),
'k_constraint': constraints.serialize(self.k_constraint),
'n_initializer': initializers.serialize(self.n_initializer),
'n_regularizer': regularizers.serialize(self.n_regularizer),
'n_constraint': constraints.serialize(self.n_constraint),
'z_initializer': initializers.serialize(self.z_initializer),
'z_regularizer': regularizers.serialize(self.z_regularizer),
'z_constraint': constraints.serialize(self.z_constraint),
'shared_axes': self.shared_axes
}
base_config = super(Hill, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'alpha_initializer': initializers.serialize(self.alpha_initializer),
'alpha_regularizer': regularizers.serialize(self.alpha_regularizer),
'alpha_constraint': constraints.serialize(self.alpha_constraint),
'shared_axes': self.shared_axes
}
base_config = super(PReLU, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def test_serialization(self):
all_activations = ["max_norm", "non_neg", "unit_norm", "min_max_norm"]
for name in all_activations:
fn = constraints.get(name)
ref_fn = getattr(constraints, name)()
assert fn.__class__ == ref_fn.__class__
config = constraints.serialize(fn)
fn = constraints.deserialize(config)
assert fn.__class__ == ref_fn.__class__
def get_config(self):
config = {
'axis': self.axis,
'momentum': self.momentum,
'epsilon': self.epsilon,
'center': self.center,
'scale': self.scale,
'beta_initializer': initializers.serialize(self.beta_initializer),
'gamma_initializer': initializers.serialize(self.gamma_initializer),
'moving_mean_initializer': initializers.serialize(self.moving_mean_initializer),
'moving_variance_initializer': initializers.serialize(self.moving_variance_initializer),
'beta_regularizer': regularizers.serialize(self.beta_regularizer),
'gamma_regularizer': regularizers.serialize(self.gamma_regularizer),
'beta_constraint': constraints.serialize(self.beta_constraint),
'gamma_constraint': constraints.serialize(self.gamma_constraint)
}
base_config = super(BatchNormGAN, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'gamma_initializer': initializers.serialize(self.gamma_initializer),
'gamma_regularizer': regularizers.serialize(self.gamma_regularizer),
'gamma_constraint': constraints.serialize(self.gamma_constraint),
'epsilon': self.epsilon
}
base_config = super(WeightNorm_Conv, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'units': self.units,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'recurrent_initializer': initializers.serialize(self.recurrent_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'recurrent_regularizer': regularizers.serialize(self.recurrent_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'recurrent_constraint': constraints.serialize(self.recurrent_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint),
'dropout': self.dropout,
'recurrent_dropout': self.recurrent_dropout}
base_config = super(TT_RNN, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'param_initializer': initializers.serialize(self.param_initializer),
'param_regularizer': regularizers.serialize(self.param_regularizer),
'param_constraint': constraints.serialize(self.param_constraint),
'shared_axes': self.shared_axes
}
base_config = super(ParameterBase, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'output_dim': self.output_dim,
'window_size': self.window_size,
'init': self.init.get_config(),
'stride': self.strides[0],
'activation': activations.serialize(self.activation),
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer': regularizers.serialize(self.activy_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint),
'use_bias': self.use_bias,
'input_dim': self.input_dim,
'input_length': self.input_length}
base_config = super(GCNN, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def test_serialization():
all_activations = ['max_norm', 'non_neg', 'unit_norm', 'min_max_norm']
for name in all_activations:
fn = constraints.get(name)
ref_fn = getattr(constraints, name)()
assert fn.__class__ == ref_fn.__class__
config = constraints.serialize(fn)
fn = constraints.deserialize(config)
assert fn.__class__ == ref_fn.__class__
def get_config(self):
config = {
'filters': self.filters,
'kernel_size': self.kernel_size,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'activation': activations.serialize(self.activation),
'padding': self.padding,
'strides': self.strides,
'data_format': self.data_format,
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint),
'use_bias': self.use_bias}
base_config = super(CosineConvolution2D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
"alpha_initializer": initializers.serialize(self.alpha_initializer),
"alpha_regularizer": regularizers.serialize(self.alpha_regularizer),
"alpha_constraint": constraints.serialize(self.alpha_constraint),
"shared_axes": self.shared_axes,
}
base_config = super().get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'a_initializer': initializers.serialize(self.a_initializer),
'a_regularizer': regularizers.serialize(self.a_regularizer),
'a_constraint': constraints.serialize(self.a_constraint),
'k_initializer': initializers.serialize(self.k_initializer),
'k_regularizer': regularizers.serialize(self.k_regularizer),
'k_constraint': constraints.serialize(self.k_constraint),
'n_initializer': initializers.serialize(self.n_initializer),
'n_regularizer': regularizers.serialize(self.n_regularizer),
'n_constraint': constraints.serialize(self.n_constraint),
'z_initializer': initializers.serialize(self.z_initializer),
'z_regularizer': regularizers.serialize(self.z_regularizer),
'z_constraint': constraints.serialize(self.z_constraint),
'shared_axes': self.shared_axes
}
base_config = super(Hill, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'filters': self.filters,
'kernel_size': self.kernel_size,
'strides': self.strides,
'padding': self.padding,
'data_format': self.data_format,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
'kernel_initializer': initializers.serialize(self.kernel_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer': regularizers.serialize(self.activity_regularizer),
'kernel_constraint': constraints.serialize(self.kernel_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint)
}
base_config = super(LocallyConnected2D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'vv_theta': self.vv,
'axis': self.axis,
'momentum': self.momentum,
'epsilon': self.epsilon,
'center': self.center,
'scale': self.scale,
'beta_initializer': initializers.serialize(self.beta_initializer),
'gamma_initializer': initializers.serialize(self.gamma_initializer),
'moving_mean_initializer': initializers.serialize(self.moving_mean_initializer),
'moving_variance_initializer': initializers.serialize(self.moving_variance_initializer),
'beta_regularizer': regularizers.serialize(self.beta_regularizer),
'gamma_regularizer': regularizers.serialize(self.gamma_regularizer),
'beta_constraint': constraints.serialize(self.beta_constraint),
'gamma_constraint': constraints.serialize(self.gamma_constraint)
}
base_config = super(RProjFWH_BatchNormalization, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def test_serialization():
all_activations = ['max_norm', 'non_neg',
'unit_norm', 'min_max_norm']
for name in all_activations:
fn = constraints.get(name)
ref_fn = getattr(constraints, name)()
assert fn.__class__ == ref_fn.__class__
config = constraints.serialize(fn)
fn = constraints.deserialize(config)
assert fn.__class__ == ref_fn.__class__
def get_config(self):
config = super(DepthwiseConv2D, self).get_config()
config.pop('filters')
config.pop('kernel_initializer')
config.pop('kernel_regularizer')
config.pop('kernel_constraint')
config['depth_multiplier'] = self.depth_multiplier
config['depthwise_initializer'] = initializers.serialize(self.depthwise_initializer)
config['depthwise_regularizer'] = regularizers.serialize(self.depthwise_regularizer)
config['depthwise_constraint'] = constraints.serialize(self.depthwise_constraint)
return config
def get_config(self):
config = {
'alpha_pos_initializer': initializers.serialize(self.alpha_pos_initializer),
'alpha_neg_initializer': initializers.serialize(self.alpha_neg_initializer),
'beta_pos_initializer': initializers.serialize(self.beta_pos_initializer),
'beta_neg_initializer': initializers.serialize(self.beta_neg_initializer),
'rho_pos_initializer': initializers.serialize(self.rho_pos_initializer),
'rho_neg_initializer': initializers.serialize(self.rho_neg_initializer),
'alpha_pos_constraint': constraints.serialize(self.alpha_pos_constraint),
'alpha_neg_constraint': constraints.serialize(self.alpha_neg_constraint),
'beta_pos_constraint': constraints.serialize(self.beta_pos_constraint),
'beta_neg_constraint': constraints.serialize(self.beta_neg_constraint),
'rho_pos_constraint': constraints.serialize(self.rho_pos_constraint),
'rho_neg_constraint': constraints.serialize(self.rho_neg_constraint),
'alpha_pos_regularizer': regularizers.serialize(self.alpha_pos_regularizer),
'alpha_neg_regularizer': regularizers.serialize(self.alpha_neg_regularizer),
'beta_pos_regularizer': regularizers.serialize(self.beta_pos_regularizer),
'beta_neg_regularizer': regularizers.serialize(self.beta_neg_regularizer),
'rho_pos_regularizer': regularizers.serialize(self.rho_pos_regularizer),
'rho_neg_regularizer': regularizers.serialize(self.rho_neg_regularizer),
}
base_config = super(PowerPReLU, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
