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 = {
'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),
'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(ExtendedRNNCell, self).get_config()
config.update(base_config)
return config
def get_config(self):
base_config = super(LayerNormalization, self).get_config()
base_config.update({"center": self.center,
"scale": self.scale,
"epsilon": self.epsilon,
"conditional": self.conditional,
"condition_hidden_units": self.condition_hidden_units,
"condition_hidden_activation": activations.serialize(self.condition_hidden_activation),
"condition_hidden_initializer": initializers.serialize(self.condition_hidden_initializer)})
return base_config
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),
'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(JANetCell, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = super().get_config()
return dict(
config,
activation=activations.serialize(self.activation),
add_biases=self.add_biases,
projection_regularizer=regularizers.serialize(
self.projection_regularizer),
projection_dropout=self.projection_dropout,
scaled_attention=self.scaled_attention)
def get_config(self):
config = super().get_config()
config.update({
'mid_features': self.mid_features,
'out_features': self.out_features,
'stride': self.stride,
'activation': activations.serialize(self.activation)
})
return config
def get_config(self):
config = {
'output_dim': self.output_dim,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
'l2_normalize': self.l2_normalize,
'output_raw_logits': self.output_raw_logits,
}
base_config = super(HadamardClassifier, 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),
'features_initializer':
initializers.serialize(self.features_initializer),
'recurrent_initializer':
initializers.serialize(self.recurrent_initializer),
'average_initializer':
initializers.serialize(self.average_initializer),
'initial_attention_initializer':
initializers.serialize(self.initial_attention_initializer),
'bias_initializer':
initializers.serialize(self.bias_initializer),
'features_regularizer':
regularizers.serialize(self.features_regularizer),
'recurrent_regularizer':
regularizers.serialize(self.recurrent_regularizer),
'average_regularizer':
regularizers.serialize(self.average_regularizer),
'initial_attention_regularizer':
regularizers.serialize(self.initial_attention_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'features_constraint':
constraints.serialize(self.features_constraint),
'recurrent_constraint':
constraints.serialize(self.recurrent_constraint),
'average_constraint':
constraints.serialize(self.average_constraint),
'initial_attention_constraint':
constraints.serialize(self.initial_attention_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint),
# 'dropout': self.dropout,
# 'recurrent_dropout': self.recurrent_dropout
}
base_config = super(RWA, 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),
'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),
'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,
'clock_periods' : self.clock_periods}
base_config = super(CWRNNCell, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'conditional': self.conditional,
'hidden_units': self.hidden_units,
'hidden_activation': activations.serialize(self.hidden_activation),
'hidden_initializer':
initializers.serialize(self.hidden_initializer),
}
base_config = super(LayerNormalization, 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),
"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,
}
config.update(rnn_utils.config_for_enable_caching_device(self.cell))
base_config = super().get_config()
del base_config["cell"]
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units': self.units,
'groups': self.groups,
'activation': activations.serialize(self.activation),
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
}
base_config = super(GroupDense, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units':
self.units,
'weight_dim':
self.weight_dim,
'interval_dim':
self.interval_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),
'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(BLSTMCell, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'inner_dim': self.inner_dim,
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'use_bias': self.use_bias,
'activation': activations.serialize(self.activation)
}
base_config = super(Switch, 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),
}
base_config = super(FeedForward, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units':
self.units,
'n_experts':
self.n_experts,
'expert_activation':
activations.serialize(self.expert_activation),
'gating_activation':
activations.serialize(self.gating_activation),
'use_expert_bias':
self.use_expert_bias,
'use_gating_bias':
self.use_gating_bias,
'expert_kernel_initializer_scale':
self.expert_kernel_initializer_scale,
'gating_kernel_initializer_scale':
self.gating_kernel_initializer_scale,
'expert_bias_initializer':
initializers.serialize(self.expert_bias_initializer),
'gating_bias_initializer':
initializers.serialize(self.gating_bias_initializer),
'expert_kernel_regularizer':
regularizers.serialize(self.expert_kernel_regularizer),
'gating_kernel_regularizer':
regularizers.serialize(self.gating_kernel_regularizer),
'expert_bias_regularizer':
regularizers.serialize(self.expert_bias_regularizer),
'gating_bias_regularizer':
regularizers.serialize(self.gating_bias_regularizer),
'expert_kernel_constraint':
constraints.serialize(self.expert_kernel_constraint),
'gating_kernel_constraint':
constraints.serialize(self.gating_kernel_constraint),
'expert_bias_constraint':
constraints.serialize(self.expert_bias_constraint),
'gating_bias_constraint':
constraints.serialize(self.gating_bias_constraint),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer)
}
base_config = super(DenseMoE, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = super().get_config()
config.update({
'filters': self.filters,
'sizes': self.sizes,
'activation': activations.serialize(self.activation),
'standardized': self.standardized
})
return config
def get_config(self):
config = {
'pooling':
"s2s",
'output_dim':
self.output_dim,
'step':
self.step,
'activation_lstm':
activations.serialize(self.activation_lstm),
'activation_recurrent':
activations.serialize(self.activation_recurrent),
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
'recurrent_initializer':
initializers.serialize(self.recurrent_initializer)
}
base_config = super(Set2SetV, self).get_config()
return {**base_config, **config}
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 = {'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}
base_config = super(GraphConvLSTM, 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),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'recurrent_constraint':
constraints.serialize(self.recurrent_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint)
}
base_config = super(BottleneckLSTM2DCell, 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),
'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,
'implementation':
self.implementation,
'reset_after':
self.reset_after
}
config.update(rnn_utils.config_for_enable_caching_device(self.cell))
base_config = super().get_config()
del base_config['cell']
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
linear_config = generic_utils.serialize_keras_object(self.linear_model)
dnn_config = generic_utils.serialize_keras_object(self.dnn_model)
config = {
'linear_model': linear_config,
'dnn_model': dnn_config,
'activation': activations.serialize(self.activation),
}
base_config = base_layer.Layer.get_config(self)
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
if self.kernel_initializer in {'quaternion'}:
ki = self.kernel_initializer
else:
ki = initializers.serialize(self.kernel_initializer)
config = {
'rank':
self.rank,
'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':
ki,
'bias_initializer':
initializers.serialize(self.bias_initializer),
'gamma_diag_initializer':
initializers.serialize(self.gamma_diag_initializer),
'gamma_off_initializer':
initializers.serialize(self.gamma_off_initializer),
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'gamma_diag_regularizer':
regularizers.serialize(self.gamma_diag_regularizer),
'gamma_off_regularizer':
regularizers.serialize(self.gamma_off_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint),
'gamma_diag_constraint':
constraints.serialize(self.gamma_diag_constraint),
'gamma_off_constraint':
constraints.serialize(self.gamma_off_constraint),
'init_criterion':
self.init_criterion,
}
base_config = super(QuaternionConv, 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),
'use_bias':
self.use_bias,
'preslice':
self.preslice,
'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),
'attention_function':
self.attention_function,
'mu1_regularizer':
regularizers.serialize(self.mu1_regularizer),
'sig1_regularizer':
regularizers.serialize(self.sig1_regularizer),
'mu2_regularizer':
regularizers.serialize(self.mu2_regularizer),
'sig2_regularizer':
regularizers.serialize(self.sig2_regularizer),
'mu1_constraint':
constraints.serialize(self.mu1_constraint),
'sig1_constraint':
constraints.serialize(self.sig1_constraint),
'mu2_constraint':
constraints.serialize(self.mu2_constraint),
'sig2_constraint':
constraints.serialize(self.sig2_constraint)
}
base_config = super(Target2D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'rank':
self.rank,
'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,
'normalize_weight':
self.normalize_weight,
'kernel_initializer':
sanitizedInitSer(self.kernel_initializer),
'bias_initializer':
sanitizedInitSer(self.bias_initializer),
'gamma_diag_initializer':
sanitizedInitSer(self.gamma_diag_initializer),
'gamma_off_initializer':
sanitizedInitSer(self.gamma_off_initializer),
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'gamma_diag_regularizer':
regularizers.serialize(self.gamma_diag_regularizer),
'gamma_off_regularizer':
regularizers.serialize(self.gamma_off_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint),
'gamma_diag_constraint':
constraints.serialize(self.gamma_diag_constraint),
'gamma_off_constraint':
constraints.serialize(self.gamma_off_constraint),
'init_criterion':
self.init_criterion,
'spectral_parametrization':
self.spectral_parametrization,
}
base_config = super(ComplexConv, 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),
'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(LSTMPEEP, self).get_config()
del base_config['cell']
return dict(list(base_config.items()) + list(config.items()))
def test_serialization():
all_activations = ['softmax', 'relu', 'elu', 'tanh',
'sigmoid', 'hard_sigmoid', 'linear',
'softplus', 'softsign', 'selu']
for name in all_activations:
fn = activations.get(name)
ref_fn = getattr(activations, name)
assert fn == ref_fn
config = activations.serialize(fn)
fn = activations.deserialize(config)
assert fn == ref_fn
def get_config(self):
config = {
'tt_input_shape':
self.tt_input_shape,
'tt_output_shape':
self.tt_output_shape,
'tt_ranks':
self.tt_ranks,
'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),
'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_GRU, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'hidden': self.hidden,
'activation': activations.serialize(self.activation),
'init': initializers.serialize(self.init),
'W_regularizer': regularizers.serialize(self.W_regularizer),
'W0_regularizer': regularizers.serialize(self.W0_regularizer),
'W_constraint': constraints.serialize(self.W_constraint),
'W0_constraint': constraints.serialize(self.W0_constraint)
}
base_config = super(Attention, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'filters': self.filters,
'data_format': self.data_format,
'activation': activations.serialize(self.activation),
'use_bias': self.use_bias,
#'bias_initializer': initializers.serialize(self.bias_initializer),
#'bias_regularizer': regularizers.serialize(self.bias_regularizer),
#'bias_constraint': constraints.serialize(self.bias_constraint),
}
return config
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 = {'output_dim': self.output_dim,
'W_initializer':initializers.serialize(self.W_initializer),
'b_initializer':initializers.serialize(self.W_initializer),
'activation': activations.serialize(self.activation),
'W_regularizer': self.W_regularizer.get_config() if self.W_regularizer else None,
'b_regularizer': self.b_regularizer.get_config() if self.b_regularizer else None,
'activity_regularizer': self.activity_regularizer.get_config() if self.activity_regularizer else None,
'W_constraint': self.W_constraint.get_config() if self.W_constraint else None,
'b_constraint': self.b_constraint.get_config() if self.b_constraint else None,
'input_dim': self.input_dim}
base_config = super(SparseFullyConnectedLayer, 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()))
