def serialize(optimizer): return serialize_keras_object(optimizer)
def serialize(initializer): return serialize_keras_object(initializer)
def serialize(regularizer): return serialize_keras_object(regularizer)
def serialize(metric): return serialize_keras_object(metric)
def get_config(self): base_config = super(QuantizeWrapper, self).get_config() config = { 'quantize_provider': serialize_keras_object(self.quantize_provider) } return dict(list(base_config.items()) + list(config.items()))
def serialize(regularizer): return serialize_keras_object(regularizer)
def serialize(initializer): return serialize_keras_object(initializer)
def serialize(constraint): return serialize_keras_object(constraint)
def serialize(loss): return serialize_keras_object(loss)
def get_config(self): config = {'layer': generic_utils.serialize_keras_object(self.layer)} base_config = super(Wrapper, self).get_config() return dict(list(base_config.items()) + list(config.items()))
def serialize(metric): return serialize_keras_object(metric)
def __init__(self, layer, merge_mode='concat', weights=None, backward_layer=None, **kwargs): if not isinstance(layer, Layer): raise ValueError( 'Please initialize `Bidirectional` layer with a ' '`Layer` instance. You passed: {input}'.format(input=layer)) if backward_layer is not None and not isinstance(backward_layer, Layer): raise ValueError('`backward_layer` need to be a `Layer` instance. ' 'You passed: {input}'.format(input=backward_layer)) if merge_mode not in ['sum', 'mul', 'ave', 'concat', None]: raise ValueError('Invalid merge mode. ' 'Merge mode should be one of ' '{"sum", "mul", "ave", "concat", None}') # We don't want to track `layer` since we're already tracking the two copies # of it we actually run. self._setattr_tracking = False super(Bidirectional, self).__init__(layer, **kwargs) self._setattr_tracking = True # Recreate the forward layer from the original layer config, so that it will # not carry over any state from the layer. self.forward_layer = self._recreate_layer_from_config(layer) if backward_layer is None: self.backward_layer = self._recreate_layer_from_config( layer, go_backwards=True) else: self.backward_layer = backward_layer # Keep the custom backward layer config, so that we can save it later. The # layer's name might be updated below with prefix 'backward_', and we want # to preserve the original config. self._backward_layer_config = generic_utils.serialize_keras_object( backward_layer) self.forward_layer._name = 'forward_' + self.forward_layer.name self.backward_layer._name = 'backward_' + self.backward_layer.name self._verify_layer_config() def force_zero_output_for_mask(layer): # Force the zero_output_for_mask to be True if returning sequences. if getattr(layer, 'zero_output_for_mask', None) is not None: layer.zero_output_for_mask = layer.return_sequences force_zero_output_for_mask(self.forward_layer) force_zero_output_for_mask(self.backward_layer) self.merge_mode = merge_mode if weights: nw = len(weights) self.forward_layer.initial_weights = weights[:nw // 2] self.backward_layer.initial_weights = weights[nw // 2:] self.stateful = layer.stateful self.return_sequences = layer.return_sequences self.return_state = layer.return_state self.supports_masking = True self._trainable = True self._num_constants = 0 self.input_spec = layer.input_spec
def serialize(learning_rate_schedule): return generic_utils.serialize_keras_object(learning_rate_schedule)
def get_serialized(obj): with generic_utils.skip_failed_serialization(): # Store the config dictionary, which may be used when reviving the object. # When loading, the program will attempt to revive the object from config, # and if that fails, the object will be revived from the SavedModel. return generic_utils.serialize_keras_object(obj)
def serialize(constraint): return serialize_keras_object(constraint)
def serialize(layer): return generic_utils.serialize_keras_object(layer)
def serialize(loss_scale): return serialize_keras_object(loss_scale)
def _serialize_fn(obj): if callable(obj): return generic_utils.serialize_keras_object(obj) return obj
def serialize(loss): return serialize_keras_object(loss)
def serialize(loss_scale): return serialize_keras_object(loss_scale)
def serialize(optimizer): return serialize_keras_object(optimizer)
def serialize(nets_fn): return serialize_keras_object(nets_fn)
def serialize(learning_rate_schedule): return generic_utils.serialize_keras_object(learning_rate_schedule)
def get_config(self): return { 'inner_layer': generic_utils.serialize_keras_object(self.inner_layer) }