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),
'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 = {'filters': self.filters,
'kernel_size': self.kernel_size,
'cov_kernel_size': self.cov_kernel_size,
'extra_cov_number':self.extra_cov_number
'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_2, 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,
'implementation': self.implementation,
'reset_after': self.reset_after
}
base_config = super(GRUCell, 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
}
base_config = super(MGUCell, self).get_config()
return dict(list(base_config.items()) + list(config.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),
'dropout':
self.dropout,
'recurrent_dropout':
self.recurrent_dropout
}
base_config = super(AttenIConvLSTM2D, 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),
}
base_config = super(ResidualLSTM, 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),
'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(ConvGRU2D, self).get_config()
del base_config['cell']
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'forward': activations.serialize(self.forward),
'backward': activations.serialize(self.backward),
'Tin': dtype_serialize(self.Tin),
'Tout': dtype_serialize(self.Tout),
'output_shape': activations.serialize(self._output_shape),
'id': self._id,
}
base_config = super(External, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
"""Gets the configuration of the layer for further serialization.
"""
# Defining a dictionary holding the configuration
config = {
'n_slots':
self.n_slots,
'slot_size':
self.slot_size,
'n_heads':
self.n_heads,
'head_size':
self.head_size,
'n_blocks':
self.n_blocks,
'n_layers':
self.n_layers,
'activation':
activations.serialize(self.activation),
'recurrent_activation':
activations.serialize(self.recurrent_activation),
'forget_bias':
self.forget_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),
'units':
self.units,
'n_gates':
self.n_gates
}
# Overring the base configuration
base_config = super(RelationalMemoryCell, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'units':
self.units,
'relations':
self.relations,
'heads':
self.heads,
'head_aggregation':
self.head_aggregation,
'attention_mode':
self.attention_mode,
'attention_style':
self.attention_style,
'attention_units':
self.attention_units,
'attn_use_edge_features':
self.attn_use_edge_features,
'kernel_basis_size':
self.kernel_basis_size,
'attn_kernel_basis_size':
self.attn_kernel_basis_size,
'activation':
activations.serialize(self.activation),
'attn_activation':
activations.serialize(self.attn_activation),
'use_bias':
self.use_bias,
'batch_normalisation':
self.batch_normalisation,
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
'bias_initializer':
initializers.serialize(self.bias_initializer),
'attn_kernel_initializer':
initializers.serialize(self.attn_kernel_initializer),
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'attn_kernel_regularizer':
regularizers.serialize(self.attn_kernel_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'feature_dropout':
self.feature_dropout,
'support_dropout':
self.support_dropout,
'edge_feature_dropout':
self.edge_feature_dropout
}
base_config = super(RelationalGraphAttention, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
"""
Method for returning the configuration of the MMoE layer.
:return: Config dictionary
"""
config = {
'units':
self.units,
'num_experts':
self.num_experts,
'num_tasks':
self.num_tasks,
'use_expert_bias':
self.use_expert_bias,
'use_gate_bias':
self.use_gate_bias,
'expert_activation':
activations.serialize(self.expert_activation),
'gate_activation':
activations.serialize(self.gate_activation),
'expert_bias_initializer':
initializers.serialize(self.expert_bias_initializer),
'gate_bias_initializer':
initializers.serialize(self.gate_bias_initializer),
'expert_bias_regularizer':
regularizers.serialize(self.expert_bias_regularizer),
'gate_bias_regularizer':
regularizers.serialize(self.gate_bias_regularizer),
'expert_bias_constraint':
constraints.serialize(self.expert_bias_constraint),
'gate_bias_constraint':
constraints.serialize(self.gate_bias_constraint),
'expert_kernel_initializer':
initializers.serialize(self.expert_kernel_initializer),
'gate_kernel_initializer':
initializers.serialize(self.gate_kernel_initializer),
'expert_kernel_regularizer':
regularizers.serialize(self.expert_kernel_regularizer),
'gate_kernel_regularizer':
regularizers.serialize(self.gate_kernel_regularizer),
'expert_kernel_constraint':
constraints.serialize(self.expert_kernel_constraint),
'gate_kernel_constraint':
constraints.serialize(self.gate_kernel_constraint),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer)
}
base_config = super(MMoE, 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),
'attention_activation':
activations.serialize(self.attention_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),
'attention_initializer':
initializers.serialize(self.attention_initializer),
'use_chrono_initialization':
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),
'attention_regularizer':
regularizers.serialize(self.attention_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'recurrent_constraint':
constraints.serialize(self.recurrent_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint),
'attention_constraint':
constraints.serialize(self.attention_constraint),
'dropout':
self.dropout,
'recurrent_dropout':
self.recurrent_dropout,
'return_attention':
self.return_attention
}
base_config = super(AttentionLSTM, self).get_config()
del base_config['cell']
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 = {
'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,
'depthwise_initializer': initializers.serialize(
self.depthwise_initializer),
'pointwise_initializer': initializers.serialize(
self.pointwise_initializer),
'bias_initializer': initializers.serialize(self.bias_initializer),
'depthwise_regularizer': regularizers.serialize(
self.depthwise_regularizer),
'pointwise_regularizer': regularizers.serialize(
self.pointwise_regularizer),
'bias_regularizer': regularizers.serialize(self.bias_regularizer),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
'depthwise_constraint': constraints.serialize(
self.depthwise_constraint),
'pointwise_constraint': constraints.serialize(
self.pointwise_constraint),
'bias_constraint': constraints.serialize(self.bias_constraint)
}
base_config = super(SeparableConv2DKeras, 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),
'implementation':
self.implementation
}
base_config = super(LocallyConnected2D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def _get_config(self, conv_config):
"""All shared get_config logic for fused layers."""
batchnorm_config = self.batchnorm.get_config()
# Both BatchNorm and Conv2D have config items from base layer. Since
# _ConvBatchNorm2D inherits from Conv2D, we should use base layer config
# items from self, rather than self.batchnorm.
# For now, deleting 'name', but ideally all base_config items should be
# removed.
# TODO(pulkitb): Raise error if base_configs in both layers incompatible.
batchnorm_config.pop('name')
is_advanced_activation = isinstance(self.post_activation,
keras.layers.Layer)
if is_advanced_activation:
serialized_activation = keras.utils.serialize_keras_object(
self.post_activation)
else:
serialized_activation = activations.serialize(self.post_activation)
config = {
'is_quantized': self.is_quantized,
'post_activation': serialized_activation
}
return dict(
list(conv_config.items()) + list(batchnorm_config.items()) +
list(config.items()))
def get_config(self):
config = super(Covn2DBaseLayer, self).get_config()
config.update({
'kernel_size':
self.kernel_size,
'strides':
self.strides,
'padding':
self.padding,
'dilation_rate':
self.dilation_rate,
'activation':
activations.serialize(self.activation),
'use_bias':
self.use_bias,
'kernel_initializer':
initializers.serialize(self.kernel_initializer),
'kernel_regularizer':
regularizers.serialize(self.kernel_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'bias_initializer':
initializers.serialize(self.bias_initializer),
'bias_regularizer':
regularizers.serialize(self.bias_regularizer),
'bias_constraint':
constraints.serialize(self.bias_constraint),
'activity_regularizer':
regularizers.serialize(self.activity_regularizer),
})
return config
def get_config(self):
# From parent
config = super(ScaledLinear, self).get_config()
# From current
config.update({
'units':
self.units,
'use_bias':
self.use_bias,
'scale':
self.scale,
'scf_min':
self.scf_min,
'scf_max':
self.scf_max,
'dropconnect_prob':
self.dropconnect_prob,
'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.activity_regularizer),
'kernel_constraint':
constraints.serialize(self.kernel_constraint),
'bias_constraint':
constraints.serialize(self.bias_constraint)
})
return config
def get_config(self):
if isinstance(self.activation, Activation):
activation = self.activation.get_config()
else:
activation = activations.serialize(self.activation)
config = \
{
"rank": self.rank,
"filters": self.filters,
"basic_block_count": self.basic_block_count,
"basic_block_depth": self.basic_block_depth,
"kernel_size": self.kernel_size,
"strides": self.strides,
"padding": self.padding,
"data_format": self.data_format,
"dilation_rate": self.dilation_rate,
"activation": activation,
"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(ResBlockND, self).get_config()
return {**base_config, **config}
def get_config(self):
config = {
'filters':
self.filters,
'kernel_size':
self.kernel_size,
'octave':
self.octave,
'ratio_out':
self.ratio_out,
'strides':
self.strides,
'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)
}
base_config = super(OctaveConv1D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
"num_units":
self._num_units_v,
"num_modules":
self._num_modules,
"tau":
self._tau,
"sigma":
self._sigma,
"connectivity":
self._connectivity,
"kernel_initializer":
initializers.serialize(self._kernel_initializer),
"bias_initializer":
initializers.serialize(self._bias_initializer),
"w_tau_initializer":
initializers.serialize(self._w_tau_initializer),
"w_sigma_initializer":
initializers.serialize(self._w_sigma_initializer),
"activation":
activations.serialize(self._activation),
"reuse":
self._reuse,
}
base_config = super(AVCTRNNCell, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
'norm_method':
self.norm_method,
'filter_size':
self.filter_size,
'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(ImageNormalization3D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = \
{
"rank": self.rank,
"kernel_size": self.kernel_size,
"growth_rate": self.growth_rate,
"output_filters": self.output_filters,
"depth": self.depth,
"use_bottleneck": self.use_bottleneck,
"bottleneck_filters_multiplier": self.bottleneck_filters_multiplier,
"use_batch_normalization": self.use_batch_normalization,
"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(DenseBlockND, self).get_config()
return {**base_config, **config}
def get_config(self):
config = {
'units':
self.units,
'relations':
self.relations,
'rank':
self.kernel_basis_size,
'activation':
activations.serialize(self.activation),
'use_bias':
self.use_bias,
'batch_normalisation':
self.batch_normalisation,
'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),
'feature_dropout':
self.feature_dropout,
'support_dropout':
self.support_dropout
}
base_config = super(RelationalGraphConv, 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,
'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(quant_train_Conv, 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),
'implementation':
self.implementation
}
base_config = super(LocallyConnected2D, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self): # delete this?
config = {
'filters':
self.filters,
'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(LocallyDirected1D, 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)
}
base_config = super(Dense, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def test_serialization_v2(self):
activation_map = {nn.softmax_v2: 'softmax'}
for fn_v2_key in activation_map:
fn_v2 = activations.get(fn_v2_key)
config = activations.serialize(fn_v2)
fn = activations.deserialize(config)
assert fn.__name__ == activation_map[fn_v2_key]
def get_config(self):
config = super(Dense, self).get_config()
config.update({
'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)
})
return config
def get_config(self):
config = {
"num_units": self._num_units,
"activation": activations.serialize(self._activation),
"reuse": self._reuse,
}
base_config = super(TfLiteRNNCell, self).get_config()
return dict(itertools.chain(base_config.items(), config.items()))
def get_config(self):
config = {
'units': self.units,
'activation': activations.serialize(self.activation),
'kernel_initializer': initializers.serialize(self.kernel_initializer),
}
base_config = super(SNNDense, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
"num_units": self._num_units,
"activation": activations.serialize(self._activation),
"reuse": self._reuse,
}
base_config = super(TfLiteRNNCell, self).get_config()
return dict(itertools.chain(base_config.items(), 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)
}
base_config = super(Dense, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {
"num_units": self._num_units,
"use_peepholes": self._use_peepholes,
"cell_clip": self._cell_clip,
"initializer": initializers.serialize(self._initializer),
"num_proj": self._num_proj,
"proj_clip": self._proj_clip,
"num_unit_shards": self._num_unit_shards,
"num_proj_shards": self._num_proj_shards,
"forget_bias": self._forget_bias,
"state_is_tuple": self._state_is_tuple,
"activation": activations.serialize(self._activation),
"reuse": self._reuse,
}
base_config = super(TFLiteLSTMCell, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def get_config(self):
config = {'activation': activations.serialize(self.activation)}
base_config = super(Activation, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
