def deserialize(config, custom_objects=None): """Return an `Initializer` object from its config.""" return generic_utils.deserialize_keras_object( config, module_objects=_ALL_INITIALIZERS, custom_objects=custom_objects, printable_module_name='initializer')
def _parse_function_from_config(cls, config, custom_objects, func_attr_name, module_attr_name, func_type_attr_name): globs = globals().copy() module = config.pop(module_attr_name, None) if module in sys.modules: globs.update(sys.modules[module].__dict__) elif module is not None: # Note: we don't know the name of the function if it's a lambda. warnings.warn('{} is not loaded, but a Lambda layer uses it. ' 'It may cause errors.'.format(module), UserWarning, stacklevel=2) if custom_objects: globs.update(custom_objects) function_type = config.pop(func_type_attr_name) if function_type == 'function': # Simple lookup in custom objects function = generic_utils.deserialize_keras_object( config[func_attr_name], custom_objects=custom_objects, printable_module_name='function in Lambda layer') elif function_type == 'lambda': # Unsafe deserialization from bytecode function = generic_utils.func_load(config[func_attr_name], globs=globs) elif function_type == 'raw': function = config[func_attr_name] else: supported_types = ['function', 'lambda', 'raw'] raise TypeError( f'Unsupported value for `function_type` argument. Received: ' f'function_type={function_type}. Expected one of {supported_types}' ) return function
def deserialize(config, custom_objects=None): """Instantiates a `LearningRateSchedule` object from a serialized form. Args: config: The serialized form of the `LearningRateSchedule`. Dictionary of the form {'class_name': str, 'config': dict}. custom_objects: A dictionary mapping class names (or function names) of custom (non-Keras) objects to class/functions. Returns: A `LearningRateSchedule` object. Example: ```python # Configuration for PolynomialDecay config = { 'class_name': 'PolynomialDecay', 'config': {'cycle': False, 'decay_steps': 10000, 'end_learning_rate': 0.01, 'initial_learning_rate': 0.1, 'name': None, 'power': 0.5}} lr_schedule = tf.keras.optimizers.schedules.deserialize(config) ``` """ return generic_utils.deserialize_keras_object( config, module_objects=globals(), custom_objects=custom_objects, printable_module_name="decay")
def test_metrics(): expect = [0.0, 2.0, 1.0, 2.0] y_pred = np.array([0, 0.2, 0.6, 0.4, 1, 0]) y_true = np.array([1, 0, -1, 1, 0, 0]) y_true_mask = y_true[y_true != MASK_VALUE] y_pred_mask = y_pred[y_true != MASK_VALUE] y_true_r = y_true.reshape((-1, 2)) y_pred_r = y_pred.reshape((-1, 2)) y_true_mask_r = y_true_mask.reshape((-1, 1)) y_pred_mask_r = y_pred_mask.reshape((-1, 1)) res1 = [K.eval(x) for x in cm.contingency_table(y_true, y_pred)] res2 = [K.eval(x) for x in cm.contingency_table(y_true_mask, y_pred_mask)] res3 = [K.eval(x) for x in cm.contingency_table(y_true_r, y_pred_r)] res4 = [ K.eval(x) for x in cm.contingency_table(y_true_mask_r, y_pred_mask_r) ] assert sum(res1) == 5 assert sum(res2) == 5 assert sum(res3) == 5 assert sum(res4) == 5 assert res1 == expect assert res2 == expect assert res3 == expect assert res4 == expect assert np.allclose(K.eval(cm.tpr(y_true, y_pred)), cem.tpr(y_true, y_pred)) assert np.allclose(K.eval(cm.accuracy(y_true, y_pred)), cem.accuracy(y_true, y_pred)) # test serialization s = serialize_keras_object(cm.accuracy) a = deserialize_keras_object(s) assert a == cm.accuracy
def deserialize(config, custom_objects=None): """Inverse of the `serialize` function. # Arguments config: Optimizer configuration dictionary. custom_objects: Optional dictionary mapping names (strings) to custom objects (classes and functions) to be considered during deserialization. # Returns A Keras Optimizer instance. """ all_classes = { 'sgd': optimizers.SGD, 'rmsprop': optimizers.RMSprop, 'adagrad': optimizers.Adagrad, 'adadelta': optimizers.Adadelta, 'adam': optimizers.Adam, 'adamax': optimizers.Adamax, 'nadam': optimizers.Nadam, 'tfoptimizer': optimizers.TFOptimizer } # Make deserialization case-insensitive for built-in optimizers. if config['class_name'].lower() in all_classes: config['class_name'] = config['class_name'].lower() return deserialize_keras_object(config, module_objects=all_classes, custom_objects=custom_objects, printable_module_name='optimizer')
def deserialize(config, custom_objects=None): return deserialize_keras_object( config, module_objects=globals(), custom_objects=custom_objects, printable_module_name="constraint", )
def _parse_config_to_function(config, custom_objects, func_attr_name, func_type_attr_name, module_attr_name): """Reconstruct the function from the config.""" globs = globals() module = config.pop(module_attr_name, None) if module in sys.modules: globs.update(sys.modules[module].__dict__) elif module is not None: # Note: we don't know the name of the function if it's a lambda. warnings.warn("{} is not loaded, but a layer uses it. " "It may cause errors.".format(module), UserWarning) if custom_objects: globs.update(custom_objects) function_type = config.pop(func_type_attr_name) if function_type == "function": # Simple lookup in custom objects function = generic_utils.deserialize_keras_object( config[func_attr_name], custom_objects=custom_objects, printable_module_name="function in wrapper") elif function_type == "lambda": # Unsafe deserialization from bytecode function = generic_utils.func_load( config[func_attr_name], globs=globs) else: raise TypeError("Unknown function type:", function_type) return function
def deserialize(config, custom_objects=None): """Inverse of the `serialize` function. # Arguments config: Optimizer configuration dictionary. custom_objects: Optional dictionary mapping names (strings) to custom objects (classes and functions) to be considered during deserialization. # Returns A Keras Optimizer instance. """ all_classes = { 'sgd': optimizers.SGD, 'rmsprop': optimizers.RMSprop, 'adagrad': optimizers.Adagrad, 'adadelta': optimizers.Adadelta, 'adam': optimizers.Adam, 'adamax': optimizers.Adamax, 'nadam': optimizers.Nadam, 'tfoptimizer': optimizers.TFOptimizer } # Make deserialization case-insensitive for built-in optimizers. if config['class_name'].lower() in all_classes: config['class_name'] = config['class_name'].lower() return deserialize_keras_object(config, module_objects=all_classes, custom_objects=custom_objects, printable_module_name='optimizer')
def deserialize(config, custom_objects=None): """Return an `Initializer` object from its config.""" populate_deserializable_objects() return generic_utils.deserialize_keras_object( config, module_objects=LOCAL.ALL_OBJECTS, custom_objects=custom_objects, printable_module_name='initializer')
def from_config(cls, config, custom_objects=None): config_cp = config.copy() columns_by_name = {} config_cp['feature_columns'] = [tf.__internal__.feature_column.deserialize_feature_column( c, custom_objects, columns_by_name) for c in config['feature_columns']] config_cp['partitioner'] = generic_utils.deserialize_keras_object( config['partitioner'], custom_objects) return cls(**config_cp)
def deserialize(config, custom_objects=None): if config == 'l1_l2': # Special case necessary since the defaults used for "l1_l2" (string) # differ from those of the L1L2 class. return L1L2(l1=0.01, l2=0.01) return deserialize_keras_object(config, module_objects=globals(), custom_objects=custom_objects, printable_module_name='regularizer')
def from_config(cls, config, custom_objects=None): # Import here to avoid circular imports. from tensorflow.python.feature_column import serialization # pylint: disable=g-import-not-at-top config_cp = config.copy() config_cp['feature_columns'] = serialization.deserialize_feature_columns( config['feature_columns'], custom_objects=custom_objects) config_cp['partitioner'] = generic_utils.deserialize_keras_object( config['partitioner'], custom_objects) return cls(**config_cp)
def deserialize(config, custom_objects=None): loss_scale_module_objects = { 'FixedLossScale': tf.mixed_precision.experimental.FixedLossScale, 'DynamicLossScale': tf.mixed_precision.experimental.DynamicLossScale, } return generic_utils.deserialize_keras_object( config, module_objects=loss_scale_module_objects, custom_objects=custom_objects, printable_module_name='loss scale')
def deserialize(config, custom_objects=None): if isinstance(config, str) and _is_convertible_to_dtype(config): return Policy(config) if config is None: return Policy('_infer') module_objects = {'Policy': Policy, 'PolicyV1': Policy} return generic_utils.deserialize_keras_object( config, module_objects=module_objects, custom_objects=custom_objects, printable_module_name='dtype policy')
def _decode_helper( obj, deserialize=False, module_objects=None, custom_objects=None ): """A decoding helper that is TF-object aware. Args: obj: A decoded dictionary that may represent an object. deserialize: Boolean, defaults to False. When True, deserializes any Keras objects found in `obj`. module_objects: A dictionary of built-in objects to look the name up in. Generally, `module_objects` is provided by midlevel library implementers. custom_objects: A dictionary of custom objects to look the name up in. Generally, `custom_objects` is provided by the end user. Returns: The decoded object. """ if isinstance(obj, dict) and "class_name" in obj: if obj["class_name"] == "TensorShape": return tf.TensorShape(obj["items"]) elif obj["class_name"] == "TypeSpec": return type_spec.lookup( obj["type_spec"] )._deserialize( # pylint: disable=protected-access _decode_helper(obj["serialized"]) ) elif obj["class_name"] == "CompositeTensor": spec = obj["spec"] tensors = [] for dtype, tensor in obj["tensors"]: tensors.append( tf.constant(tensor, dtype=tf.dtypes.as_dtype(dtype)) ) return tf.nest.pack_sequence_as( _decode_helper(spec), tensors, expand_composites=True ) elif obj["class_name"] == "__tuple__": return tuple(_decode_helper(i) for i in obj["items"]) elif obj["class_name"] == "__ellipsis__": return Ellipsis elif deserialize and "__passive_serialization__" in obj: # __passive_serialization__ is added by the JSON encoder when encoding # an object that has a `get_config()` method. try: return generic_utils.deserialize_keras_object( obj, module_objects=module_objects, custom_objects=custom_objects, ) except ValueError: pass return obj
def deserialize(config, custom_objects=None): if isinstance(config, str) and _is_convertible_to_dtype(config): return Policy(config) if config is None: return Policy('_infer') # PolicyV1 was an old version of Policy that was removed. Deserializing it # turns it into a (non-V1) Policy. module_objects = {'Policy': Policy, 'PolicyV1': Policy} return generic_utils.deserialize_keras_object( config, module_objects=module_objects, custom_objects=custom_objects, printable_module_name='dtype policy')
def recursively_deserialize_keras_object(config, module_objects=None): """Deserialize Keras object from a nested structure.""" if isinstance(config, dict): if 'class_name' in config: return generic_utils.deserialize_keras_object( config, module_objects=module_objects) else: return {key: recursively_deserialize_keras_object(config[key], module_objects) for key in config} if isinstance(config, (tuple, list)): return [recursively_deserialize_keras_object(x, module_objects) for x in config] else: raise ValueError('Unable to decode config: {}'.format(config))
def deserialize(config, custom_objects=None): """Deserializes a serialized metric class/function instance. Args: config: Metric configuration. custom_objects: Optional dictionary mapping names (strings) to custom objects (classes and functions) to be considered during deserialization. Returns: A Keras `Metric` instance or a metric function. """ return deserialize_keras_object( config, module_objects=globals(), custom_objects=custom_objects, printable_module_name='metric function')
def recursively_deserialize_keras_object(config, module_objects=None): """Deserialize Keras object from a nested structure.""" if isinstance(config, dict): if 'class_name' in config: return generic_utils.deserialize_keras_object( config, module_objects=module_objects) else: return {key: recursively_deserialize_keras_object(config[key], module_objects) for key in config} elif isinstance(config, (tuple, list)): return [recursively_deserialize_keras_object(x, module_objects) for x in config] else: raise ValueError( f'Unable to decode Keras layer config. Config should be a dictionary, ' f'tuple or list. Received: config={config}')
def test_init_serialization(kernel_initializer, bias_initializer): pwm_list = [PWM([[1, 2, 3, 4], [2, 4, 4, 5]]), PWM([[1, 2, 1, 4], [2, 10, 4, 5]])] # should work out of the box # get_custom_objects()['PWMKernelInitializer'] = PWMKernelInitializer # get_custom_objects()['PWMBiasInitializer'] = PWMBiasInitializer seq_length = 100 input_shape = (None, seq_length, 4) # (batch_size, steps, input_dim) # input_shape = (seq_length, 4) # (batch_size, steps, input_dim) # output_shape = (None, steps, filters) conv_l = kl.Conv1D(filters=15, kernel_size=11, kernel_regularizer=L1L2(l1=1, l2=1), # Regularization padding="valid", activation="relu", kernel_initializer=kernel_initializer(pwm_list, stddev=0.1), bias_initializer=bias_initializer(pwm_list, kernel_size=11), batch_input_shape=input_shape, ) # output_shape: (batch_size, new_steps, filters) # (new_)steps = length along the sequence, might changed due to padding model = Sequential() model.add(conv_l) model.compile(optimizer="adam", loss="mse", metrics=["mse"]) js = model.to_json() js # a = model_from_json(js, custom_objects={"Conv1D": kl.Conv1D}) a = model_from_json(js) assert np.all(a.layers[0].kernel_initializer.pwm_list[0].pwm == pwm_list[0].pwm) # check just layer serialization: conv_l.build(input_shape) s = serialize_keras_object(conv_l) a = deserialize_keras_object(s, custom_objects={"Conv1D": kl.Conv1D}) conv_l.get_config() # serialization was successfull assert np.all(a.kernel_initializer.pwm_list[0].pwm == pwm_list[0].pwm)
def deserialize(config, custom_objects=None): """Instantiates a layer from a config dictionary. Args: config: dict of the form {'class_name': str, 'config': dict} custom_objects: dict mapping class names (or function names) of custom (non-Keras) objects to class/functions Returns: Layer instance (may be Model, Sequential, Network, Layer...) """ populate_deserializable_objects() return generic_utils.deserialize_keras_object( config, module_objects=LOCAL.ALL_OBJECTS, custom_objects=custom_objects, printable_module_name='layer')
def deserialize(config, custom_objects=None): """Inverse of the `serialize` function. Args: config: Optimizer configuration dictionary. custom_objects: Optional dictionary mapping names (strings) to custom objects (classes and functions) to be considered during deserialization. Returns: A Keras Optimizer instance. """ # loss_scale_optimizer has a direct dependency of optimizer, import here # rather than top to avoid the cyclic dependency. from keras.mixed_precision import ( loss_scale_optimizer, ) all_classes = { "adadelta": adadelta_v2.Adadelta, "adagrad": adagrad_v2.Adagrad, "adam": adam_v2.Adam, "adamax": adamax_v2.Adamax, "experimentaladadelta": adadelta_experimental.Adadelta, "experimentaladagrad": adagrad_experimental.Adagrad, "experimentaladam": adam_experimental.Adam, "experimentalsgd": sgd_experimental.SGD, "nadam": nadam_v2.Nadam, "rmsprop": rmsprop_v2.RMSprop, "sgd": gradient_descent_v2.SGD, "ftrl": ftrl.Ftrl, "lossscaleoptimizer": loss_scale_optimizer.LossScaleOptimizer, "lossscaleoptimizerv3": loss_scale_optimizer.LossScaleOptimizerV3, # LossScaleOptimizerV1 was an old version of LSO that was removed. # Deserializing it turns it into a LossScaleOptimizer "lossscaleoptimizerv1": loss_scale_optimizer.LossScaleOptimizer, } # Make deserialization case-insensitive for built-in optimizers. if config["class_name"].lower() in all_classes: config["class_name"] = config["class_name"].lower() return deserialize_keras_object( config, module_objects=all_classes, custom_objects=custom_objects, printable_module_name="optimizer", )
def deserialize(config, custom_objects=None): """Instantiates a layer from a config dictionary. Args: config: dict of the form {'class_name': str, 'config': dict} custom_objects: dict mapping class names (or function names) of custom (non-Keras) objects to class/functions Returns: Layer instance (may be Model, Sequential, Network, Layer...) Example: ```python # Configuration of Dense(32, activation='relu') config = { 'class_name': 'Dense', 'config': { 'activation': 'relu', 'activity_regularizer': None, 'bias_constraint': None, 'bias_initializer': {'class_name': 'Zeros', 'config': {}}, 'bias_regularizer': None, 'dtype': 'float32', 'kernel_constraint': None, 'kernel_initializer': {'class_name': 'GlorotUniform', 'config': {'seed': None}}, 'kernel_regularizer': None, 'name': 'dense', 'trainable': True, 'units': 32, 'use_bias': True } } dense_layer = tf.keras.layers.deserialize(config) ``` """ populate_deserializable_objects() return generic_utils.deserialize_keras_object( config, module_objects=LOCAL.ALL_OBJECTS, custom_objects=custom_objects, printable_module_name="layer", )
def deserialize(name, custom_objects=None): """Returns activation function given a string identifier. Args: name: The name of the activation function. custom_objects: Optional `{function_name: function_obj}` dictionary listing user-provided activation functions. Returns: Corresponding activation function. For example: >>> tf.keras.activations.deserialize('linear') <function linear at 0x1239596a8> >>> tf.keras.activations.deserialize('sigmoid') <function sigmoid at 0x123959510> >>> tf.keras.activations.deserialize('abcd') Traceback (most recent call last): ... ValueError: Unknown activation function:abcd Raises: ValueError: `Unknown activation function` if the input string does not denote any defined Tensorflow activation function. """ activation_functions = {} current_module = sys.modules[__name__] # we put 'current_module' after 'activation_layers' to prefer the local one # if there is a collision generic_utils.populate_dict_with_module_objects( activation_functions, (activation_layers, current_module), obj_filter=callable, ) return generic_utils.deserialize_keras_object( name, module_objects=activation_functions, custom_objects=custom_objects, printable_module_name="activation function", )
def deserialize(config, custom_objects=None): """Inverse of the `serialize` function. Args: config: Optimizer configuration dictionary. custom_objects: Optional dictionary mapping names (strings) to custom objects (classes and functions) to be considered during deserialization. Returns: A Keras Optimizer instance. """ # loss_scale_optimizer has a direct dependency of optimizer, import here # rather than top to avoid the cyclic dependency. from keras.mixed_precision import loss_scale_optimizer # pylint: disable=g-import-not-at-top all_classes = { 'adadelta': adadelta_v2.Adadelta, 'adagrad': adagrad_v2.Adagrad, 'adam': adam_v2.Adam, 'adamax': adamax_v2.Adamax, 'experimentaladadelta': adadelta_experimental.Adadelta, 'experimentaladagrad': adagrad_experimental.Adagrad, 'experimentaladam': adam_experimental.Adam, 'experimentalsgd': sgd_experimental.SGD, 'nadam': nadam_v2.Nadam, 'rmsprop': rmsprop_v2.RMSprop, 'sgd': gradient_descent_v2.SGD, 'ftrl': ftrl.Ftrl, 'lossscaleoptimizer': loss_scale_optimizer.LossScaleOptimizer, 'lossscaleoptimizerv3': loss_scale_optimizer.LossScaleOptimizerV3, # LossScaleOptimizerV1 deserializes into LossScaleOptimizer, as # LossScaleOptimizerV1 will be removed soon but deserializing it will # still be supported. 'lossscaleoptimizerv1': loss_scale_optimizer.LossScaleOptimizer, } # Make deserialization case-insensitive for built-in optimizers. if config['class_name'].lower() in all_classes: config['class_name'] = config['class_name'].lower() return deserialize_keras_object(config, module_objects=all_classes, custom_objects=custom_objects, printable_module_name='optimizer')
def deserialize(name, custom_objects=None): """Returns activation function given a string identifier. Args: name: The name of the activation function. custom_objects: Optional `{function_name: function_obj}` dictionary listing user-provided activation functions. Returns: Corresponding activation function. For example: >>> tf.keras.activations.deserialize('linear') <function linear at 0x1239596a8> >>> tf.keras.activations.deserialize('sigmoid') <function sigmoid at 0x123959510> >>> tf.keras.activations.deserialize('abcd') Traceback (most recent call last): ... ValueError: Unknown activation function:abcd Raises: ValueError: `Unknown activation function` if the input string does not denote any defined Tensorflow activation function. """ globs = globals() # only replace missing activations advanced_activations_globs = advanced_activations.get_globals() for key, val in advanced_activations_globs.items(): if key not in globs: globs[key] = val return deserialize_keras_object( name, module_objects=globs, custom_objects=custom_objects, printable_module_name='activation function')
def _decode_helper(obj, deserialize=False, module_objects=None, custom_objects=None): """A decoding helper that is TF-object aware. Args: obj: A decoded dictionary that may represent an object. deserialize: Boolean, defaults to False. When True, deserializes any Keras objects found in `obj`. module_objects: A dictionary of built-in objects to look the name up in. Generally, `module_objects` is provided by midlevel library implementers. custom_objects: A dictionary of custom objects to look the name up in. Generally, `custom_objects` is provided by the end user. Returns: The decoded object. """ if isinstance(obj, dict) and 'class_name' in obj: if obj['class_name'] == 'TensorShape': return tf.TensorShape(obj['items']) elif obj['class_name'] == 'TypeSpec': return type_spec.lookup(obj['type_spec'])._deserialize( # pylint: disable=protected-access _decode_helper(obj['serialized'])) elif obj['class_name'] == '__tuple__': return tuple(_decode_helper(i) for i in obj['items']) elif obj['class_name'] == '__ellipsis__': return Ellipsis elif deserialize and '__passive_serialization__' in obj: # __passive_serialization__ is added by the JSON encoder when encoding # an object that has a `get_config()` method. try: return generic_utils.deserialize_keras_object( obj, module_objects=module_objects, custom_objects=custom_objects) except ValueError: pass return obj
def test_MaskLoss(): l = closs.binary_crossentropy_masked y_pred = np.array([0, 0.2, 0.6, 0.4, 1]) y_true = np.array([1, 0, -1, 1, 0.0]) y_true_mask = K.cast(y_true[y_true != MASK_VALUE], K.floatx()) y_pred_mask = K.cast(y_pred[y_true != MASK_VALUE], K.floatx()) y_true_cast = K.cast(y_true, K.floatx()) y_pred_cast = K.cast(y_pred, K.floatx()) res = K.eval(l(y_true, y_pred)) res_mask = K.eval(kloss.binary_crossentropy(y_true_mask, y_pred_mask)) assert np.allclose(res, res_mask) # test serialization s = serialize_keras_object(l) a = deserialize_keras_object(s) # assert a.loss == l.loss # assert a.mask_value == l.mask_value res2 = K.eval(a(y_true, y_pred)) assert np.allclose(res, res2)
def test_serialization(): seq_length = 100 input_shape = (None, seq_length, 4) # (batch_size, steps, input_dim) # input_shape = (seq_length, 4) # (batch_size, steps, input_dim) # output_shape = (None, steps, filters) conv_l = kl.Conv1D( filters=15, kernel_size=11, padding="valid", activation="relu", batch_input_shape=input_shape, ) # output_shape: (batch_size, new_steps, filters) # (new_)steps = length along the sequence, might changed due to padding model = Sequential() model.add(conv_l) model.add(cl.GAMSmooth()) model.compile(optimizer="adam", loss="mse", metrics=["mse"]) js = model.to_json() js # a = model_from_json(js, custom_objects={"Conv1D": kl.Conv1D}) a = model_from_json(js) assert np.all(a.layers[1].get_weights()[0] == 0) # check just layer serialization: conv_l.build(input_shape) s = serialize_keras_object(cl.GAMSmooth()) a = deserialize_keras_object(s, custom_objects={"Conv1D": kl.Conv1D}) a.get_config() # serialization was successfull assert isinstance(a.get_config(), dict)
def deserialize(name, custom_objects=None): return deserialize_keras_object(name, module_objects=globals(), custom_objects=custom_objects, printable_module_name='loss function')
def from_config(cls, config): return cls(generic_utils.deserialize_keras_object( config['inner_layer']))
def deserialize(name, custom_objects=None): return deserialize_keras_object(name, module_objects=globals(), custom_objects=custom_objects, printable_module_name='loss function')