Can't save and load lattice model

[win13676]

hello, I'm having a problem with loading premade models (https://www.tensorflow.org/lattice/tutorials/premade_models)

when I save the model as .tf format and load the model I would get

KeyError: 'layers' 

when I save the model as keras format and load the model I would get

ValueError: Unknown object: 'CalibratedLatticeEnsembleConfig'. Please ensure you are using a `keras.utils.custom_object_scope` and that this object is included in the scope. See https://www.tensorflow.org/guide/keras/save_and_serialize#registering_the_custom_object for details.

I'm seeing this issue running on the colab given by the page (https://colab.research.google.com/github/tensorflow/lattice/blob/master/docs/tutorials/premade_models.ipynb), on Databricks, and also local run

code I use to save and load the model (https://www.tensorflow.org/lattice/api_docs/python/tfl/premade/CalibratedLattice#save)

rtl_layer_ensemble_model.save("model.keras")
loaded_model = tf.keras.models.load_model("model.keras")

rtl_layer_ensemble_model.save("model.tf")
loaded_model = tf.keras.models.load_model("model.tf")

rtl_layer_ensemble_model.save("/")
loaded_model = tf.keras.models.load_model("/")

all the models in the example can't be loaded

linear_model, lattice_model, explicit_ensemble_model, random_ensemble_model, rtl_layer_ensemble_model, prefitting_model, crystals_ensemble_model

full stacktrace error:

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
[<ipython-input-40-bc47832831ee>](https://localhost:8080/#) in <cell line: 2>()
      1 rtl_layer_ensemble_model.save("model.tf")
----> 2 loaded_model = tf.keras.models.load_model("model.tf")

2 frames
[/usr/local/lib/python3.10/dist-packages/keras/src/saving/saving_api.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode, **kwargs)
    236 
    237     # Legacy case.
--> 238     return legacy_sm_saving_lib.load_model(
    239         filepath, custom_objects=custom_objects, compile=compile, **kwargs
    240     )

[/usr/local/lib/python3.10/dist-packages/keras/src/utils/traceback_utils.py](https://localhost:8080/#) in error_handler(*args, **kwargs)
     68             # To get the full stack trace, call:
     69             # `tf.debugging.disable_traceback_filtering()`
---> 70             raise e.with_traceback(filtered_tb) from None
     71         finally:
     72             del filtered_tb

[/usr/local/lib/python3.10/dist-packages/keras/src/engine/functional.py](https://localhost:8080/#) in reconstruct_from_config(config, custom_objects, created_layers)
   1487 
   1488     # First, we create all layers and enqueue nodes to be processed
-> 1489     for layer_data in config["layers"]:
   1490         process_layer(layer_data)
   1491     # Then we process nodes in order of layer depth.

KeyError: 'layers'

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
[<ipython-input-39-c20ad91f21ca>](https://localhost:8080/#) in <cell line: 2>()
      1 rtl_layer_ensemble_model.save("model.keras")
----> 2 loaded_model = tf.keras.models.load_model("model.keras")

6 frames
[/usr/local/lib/python3.10/dist-packages/keras/src/saving/saving_api.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode, **kwargs)
    228                 f"with the native Keras format: {list(kwargs.keys())}"
    229             )
--> 230         return saving_lib.load_model(
    231             filepath,
    232             custom_objects=custom_objects,

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/saving_lib.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode)
    273 
    274     except Exception as e:
--> 275         raise e
    276     else:
    277         return model

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/saving_lib.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode)
    238             # Construct the model from the configuration file in the archive.
    239             with ObjectSharingScope():
--> 240                 model = deserialize_keras_object(
    241                     config_dict, custom_objects, safe_mode=safe_mode
    242                 )

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/serialization_lib.py](https://localhost:8080/#) in deserialize_keras_object(config, custom_objects, safe_mode, **kwargs)
    702     safe_mode_scope = SafeModeScope(safe_mode)
    703     with custom_obj_scope, safe_mode_scope:
--> 704         instance = cls.from_config(inner_config)
    705         build_config = config.get("build_config", None)
    706         if build_config:

[/usr/local/lib/python3.10/dist-packages/tensorflow_lattice/python/premade.py](https://localhost:8080/#) in from_config(cls, config, custom_objects)
    146   @classmethod
    147   def from_config(cls, config, custom_objects=None):
--> 148     model_config = tf.keras.utils.legacy.deserialize_keras_object(
    149         config.get('model_config'), custom_objects=custom_objects
    150     )

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/legacy/serialization.py](https://localhost:8080/#) in deserialize_keras_object(identifier, module_objects, custom_objects, printable_module_name)
    478         # In this case we are dealing with a Keras config dictionary.
    479         config = identifier
--> 480         (cls, cls_config) = class_and_config_for_serialized_keras_object(
    481             config, module_objects, custom_objects, printable_module_name
    482         )

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/legacy/serialization.py](https://localhost:8080/#) in class_and_config_for_serialized_keras_object(config, module_objects, custom_objects, printable_module_name)
    363     )
    364     if cls is None:
--> 365         raise ValueError(
    366             f"Unknown {printable_module_name}: '{class_name}'. "
    367             "Please ensure you are using a `keras.utils.custom_object_scope` "

ValueError: Unknown object: 'CalibratedLatticeEnsembleConfig'. Please ensure you are using a `keras.utils.custom_object_scope` and that this object is included in the scope. See https://www.tensorflow.org/guide/keras/save_and_serialize#registering_the_custom_object for details.

[win13676]

when I changed the version to 2.0.11, the keras failed with the error below and tf passed
I think the issue happens in all version after 2.0.11

!pip install tensorflow-lattice==2.0.11 pydot

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
[<ipython-input-23-c20ad91f21ca>](https://localhost:8080/#) in <cell line: 2>()
      1 rtl_layer_ensemble_model.save("model.keras")
----> 2 loaded_model = tf.keras.models.load_model("model.keras")

6 frames
[/usr/local/lib/python3.10/dist-packages/keras/src/saving/saving_api.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode, **kwargs)
    228                 f"with the native Keras format: {list(kwargs.keys())}"
    229             )
--> 230         return saving_lib.load_model(
    231             filepath,
    232             custom_objects=custom_objects,

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/saving_lib.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode)
    273 
    274     except Exception as e:
--> 275         raise e
    276     else:
    277         return model

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/saving_lib.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode)
    238             # Construct the model from the configuration file in the archive.
    239             with ObjectSharingScope():
--> 240                 model = deserialize_keras_object(
    241                     config_dict, custom_objects, safe_mode=safe_mode
    242                 )

[/usr/local/lib/python3.10/dist-packages/keras/src/saving/serialization_lib.py](https://localhost:8080/#) in deserialize_keras_object(config, custom_objects, safe_mode, **kwargs)
    702     safe_mode_scope = SafeModeScope(safe_mode)
    703     with custom_obj_scope, safe_mode_scope:
--> 704         instance = cls.from_config(inner_config)
    705         build_config = config.get("build_config", None)
    706         if build_config:

[/usr/local/lib/python3.10/dist-packages/tensorflow_lattice/python/premade.py](https://localhost:8080/#) in from_config(cls, config, custom_objects)
    145   @classmethod
    146   def from_config(cls, config, custom_objects=None):
--> 147     model = super(CalibratedLatticeEnsemble, cls).from_config(
    148         config, custom_objects=custom_objects)
    149     try:

[/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py](https://localhost:8080/#) in from_config(cls, config, custom_objects)
   3242                 # constructor of the class.
   3243                 try:
-> 3244                     model = cls(**config)
   3245                 except TypeError as e:
   3246                     raise TypeError(

[/usr/local/lib/python3.10/dist-packages/tensorflow_lattice/python/premade.py](https://localhost:8080/#) in __init__(self, model_config, dtype, **kwargs)
     98     # Check that proper config has been given.
     99     if not isinstance(model_config, configs.CalibratedLatticeEnsembleConfig):
--> 100       raise ValueError('Invalid config type: {}'.format(type(model_config)))
    101     # Verify that the config is fully specified.
    102     premade_lib.verify_config(model_config)

ValueError: Invalid config type: <class 'dict'>

[siriuz42]

Try

rtl_layer_ensemble_model.save("model_keras")
loaded_model = tf.keras.models.load_model(
    "model_keras",
     custom_objects=tfl.premade.get_custom_objects(),
)

1. tf.keras.models.load_model reconstructs the Keras model, thus you need to pass in the custom objects used by the model in order to be able to recompile it. tfl.premade.get_custom_objects() returns all Tensorflow Lattice custom objects. If you only need the model for inference, i.e. a functional __call__, you can instead use

rtl_layer_ensemble_model.save("model_keras")
loaded_model = tf.saved_model.load("model_keras")

2. The period in keras.model is likely causing problems during variable name matching / parsing. Escaping it solves the problem.

[win13676]

thank you for the suggestion

load_model with custom_objects=tfl.premade.get_custom_objects() doesn't throw error for when load model save with .save("model.tf") and .save("model")
.save("model.keras") gave the error

ValueError: Input keypoints are invalid for feature age: {'class_name': '__numpy__', 'config': {'value': [29.0, 44.0, 54.0, 65.0, 100.0], 'dtype': 'float64'}}

however in version 2.0.13, the loaded model with custom_objects gave the following error when call .evaluate(x, y), .predict(x) seems to work

RuntimeError: You must compile your model before training/testing. Use `model.compile(optimizer, loss)`.

in version 2.0.11, saved and loaded model can call .evaluate(x, y)

escaping period doesn't seems to do anything or is there any special syntax for escape period besides
"model\.keras"

[expeon07]

Hi, I am also having a problem with loading my tensorflow model with a Lattice layer. My model was able to compile and predict without a problem, and I saved it to json. I used model_from_json to load the saved model but I am getting an error about the lattice sizes:

ValueError: If lattice input is provided as list of tensors their number must match lattice_sizes. 'input list': [None, 5, 5], 'lattice_sizes': ListWrapper([5, 5, 5, 5, 5])

[siriuz42]

Hi @expeon07 in case the problem still persists could you provide a full stack trace?

[mmilanifard]

Hi, I am also having a problem with loading my tensorflow model with a Lattice layer. My model was able to compile and predict without a problem, and I saved it to json. I used model_from_json to load the saved model but I am getting an error about the lattice sizes:

ValueError: If lattice input is provided as list of tensors their number must match lattice_sizes. 'input list': [None, 5, 5], 'lattice_sizes': ListWrapper([5, 5, 5, 5, 5])

We just release TFL 2.1.1 with a fix for this. Can you please try to see if you can load without an issue?

[win13676]

still having issue
i'm using
tensorflow==2.18.0
tensorflow-lattice==2.1.1
tf_keras==2.18.0
numpy==1.26.4
pandas==2.2.3

model = models.load_model("/tmp/model_name.keras")
results in
Unknown object: 'CalibratedLatticeEnsembleConfig'. Please ensure you are using a `keras.utils.custom_object_scope` and that this object is included in the scope. See https://www.tensorflow.org/guide/keras/save_and_serialize#registering_the_custom_object for details.

model = models.load_model("/tmp/model_name.keras", custom_objects=tfl.premade.get_custom_objects())
results in
ValueError: Input keypoints are invalid for feature feature_col: {'class_name': '__numpy__', 'config': {'value': [0.02442835299181345, 0.0790848638895223, 0.09296951312518031, 0.10147207585854956, 0.10788361151872317, 0.11417949527172577, 0.11996251403529101, 0.12540401821428893, 0.13155855885153456, 0.13784611959466708, 0.14544631503007932, 0.1527995720812788, 0.1589628980611293, 0.1651052735795714, 0.17064506017280823, 0.17635640540850472, 0.1826197519956434, 0.1897089725777007, 0.19739058969957957, 0.20503942560141608, 0.21338362174994907, 0.22188554210478884, 0.23245046952487602, 0.24413035561659946, 0.2570732382293477, 0.27290837473735463, 0.29064636215122597, 0.31370804542055764, 0.35865937814344695, 0.49565526227185164], 'dtype': 'float64'}}

File /local_disk0/.ephemeral_nfs/cluster_libraries/python/lib/python3.11/site-packages/tf_keras/src/saving/saving_api.py:254, in load_model(filepath, custom_objects, compile, safe_mode, **kwargs)
    249     if kwargs:
    250         raise ValueError(
    251             "The following argument(s) are not supported "
    252             f"with the native TF-Keras format: {list(kwargs.keys())}"
    253         )
--> 254     return saving_lib.load_model(
    255         filepath,
    256         custom_objects=custom_objects,
    257         compile=compile,
    258         safe_mode=safe_mode,
    259     )
    261 # Legacy case.
    262 return legacy_sm_saving_lib.load_model(
    263     filepath, custom_objects=custom_objects, compile=compile, **kwargs
    264 )
File /local_disk0/.ephemeral_nfs/cluster_libraries/python/lib/python3.11/site-packages/tf_keras/src/saving/saving_lib.py:271, in load_model(filepath, custom_objects, compile, safe_mode)
    268             asset_store.close()
    270 except Exception as e:
--> 271     raise e
    272 else:
    273     return model
File /local_disk0/.ephemeral_nfs/cluster_libraries/python/lib/python3.11/site-packages/tf_keras/src/saving/saving_lib.py:236, in load_model(filepath, custom_objects, compile, safe_mode)
    234 # Construct the model from the configuration file in the archive.
    235 with ObjectSharingScope():
--> 236     model = deserialize_keras_object(
    237         config_dict, custom_objects, safe_mode=safe_mode
    238     )
    240 all_filenames = zf.namelist()
    241 if _VARS_FNAME + ".h5" in all_filenames:
File /local_disk0/.ephemeral_nfs/cluster_libraries/python/lib/python3.11/site-packages/tf_keras/src/saving/serialization_lib.py:727, in deserialize_keras_object(config, custom_objects, safe_mode, **kwargs)
    725 safe_mode_scope = SafeModeScope(safe_mode)
    726 with custom_obj_scope, safe_mode_scope:
--> 727     instance = cls.from_config(inner_config)
    728     build_config = config.get("build_config", None)
    729     if build_config:
File /local_disk0/.ephemeral_nfs/cluster_libraries/python/lib/python3.11/site-packages/tensorflow_lattice/python/premade.py:157, in CalibratedLatticeEnsemble.from_config(cls, config, custom_objects)
    152 @classmethod
    153 def from_config(cls, config, custom_objects=None):
    154   model_config = keras.utils.legacy.deserialize_keras_object(
    155       config.get('model_config'), custom_objects=custom_objects
    156   )
--> 157   premade_lib.verify_config(model_config)
    158   return cls(model_config,
    159              name=config.get('name', None),
    160              trainable=config.get('trainable', True))
File /local_disk0/.ephemeral_nfs/cluster_libraries/python/lib/python3.11/site-packages/tensorflow_lattice/python/premade_lib.py:1812, in verify_config(model_config)
   1810   _verify_aggregate_function_config(model_config)
   1811 for feature_config in model_config.feature_configs:
-> 1812   _verify_feature_config(feature_config)
   1813 if (not np.iterable(model_config.output_initialization) or
   1814     any(not isinstance(x, (int, float))
   1815         for x in model_config.output_initialization)):
   1816   raise ValueError('Output initilization is invalid: {}'.format(
   1817       model_config.output_initialization))
File /local_disk0/.ephemeral_nfs/cluster_libraries/python/lib/python3.11/site-packages/tensorflow_lattice/python/premade_lib.py:1764, in _verify_feature_config(feature_config)
   1759 if not feature_config.num_buckets:
   1760   # Validate PWL Calibration configuration.
   1761   if (not np.iterable(feature_config.pwl_calibration_input_keypoints) or
   1762       any(not isinstance(x, (int, float))
   1763           for x in feature_config.pwl_calibration_input_keypoints)):
-> 1764     raise ValueError('Input keypoints are invalid for feature {}: {}'.format(
   1765         feature_config.name, feature_config.pwl_calibration_input_keypoints))
   1766 elif feature_config.monotonicity and feature_config.monotonicity != 'none':
   1767   # Validate Categorical Calibration configuration.
   1768   if not np.iterable(feature_config.monotonicity):

[win13676]

all the model in the example notebook also give the same error
https://www.tensorflow.org/lattice/tutorials/premade_models
https://colab.research.google.com/github/tensorflow/lattice/blob/master/docs/tutorials/premade_models.ipynb

ValueError: Input keypoints are invalid for feature age: {'class_name': '__numpy__', 'config': {'value': [29.0, 44.0, 54.0, 65.0, 100.0], 'dtype': 'float64'}}

the code

path = "/tmp/model.keras"
# linear_model, lattice_model, explicit_ensemble_model, random_ensemble_model, crystals_ensemble_model, rtl_layer_ensemble_model, random_ensemble_model
linear_model.save(path)
loaded_model = keras.models.load_model(path, custom_objects=tfl.premade.get_custom_objects())

full stack

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
[<ipython-input-41-39ddd834d613>](https://localhost:8080/#) in <cell line: 0>()
      2 # linear_model, lattice_model, explicit_ensemble_model, random_ensemble_model, crystals_ensemble_model, rtl_layer_ensemble_model, random_ensemble_model
      3 linear_model.save(path)
----> 4 loaded_model = keras.models.load_model(path, custom_objects=tfl.premade.get_custom_objects())

6 frames
[/usr/local/lib/python3.11/dist-packages/tf_keras/src/saving/saving_api.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode, **kwargs)
    252                 f"with the native TF-Keras format: {list(kwargs.keys())}"
    253             )
--> 254         return saving_lib.load_model(
    255             filepath,
    256             custom_objects=custom_objects,

[/usr/local/lib/python3.11/dist-packages/tf_keras/src/saving/saving_lib.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode)
    269 
    270     except Exception as e:
--> 271         raise e
    272     else:
    273         return model

[/usr/local/lib/python3.11/dist-packages/tf_keras/src/saving/saving_lib.py](https://localhost:8080/#) in load_model(filepath, custom_objects, compile, safe_mode)
    234             # Construct the model from the configuration file in the archive.
    235             with ObjectSharingScope():
--> 236                 model = deserialize_keras_object(
    237                     config_dict, custom_objects, safe_mode=safe_mode
    238                 )

[/usr/local/lib/python3.11/dist-packages/tf_keras/src/saving/serialization_lib.py](https://localhost:8080/#) in deserialize_keras_object(config, custom_objects, safe_mode, **kwargs)
    725     safe_mode_scope = SafeModeScope(safe_mode)
    726     with custom_obj_scope, safe_mode_scope:
--> 727         instance = cls.from_config(inner_config)
    728         build_config = config.get("build_config", None)
    729         if build_config:

[/usr/local/lib/python3.11/dist-packages/tensorflow_lattice/python/premade.py](https://localhost:8080/#) in from_config(cls, config, custom_objects)
    378         config.get('model_config'), custom_objects=custom_objects
    379     )
--> 380     premade_lib.verify_config(model_config)
    381     return cls(model_config,
    382                name=config.get('name', None),

[/usr/local/lib/python3.11/dist-packages/tensorflow_lattice/python/premade_lib.py](https://localhost:8080/#) in verify_config(model_config)
   1810     _verify_aggregate_function_config(model_config)
   1811   for feature_config in model_config.feature_configs:
-> 1812     _verify_feature_config(feature_config)
   1813   if (not np.iterable(model_config.output_initialization) or
   1814       any(not isinstance(x, (int, float))

[/usr/local/lib/python3.11/dist-packages/tensorflow_lattice/python/premade_lib.py](https://localhost:8080/#) in _verify_feature_config(feature_config)
   1762         any(not isinstance(x, (int, float))
   1763             for x in feature_config.pwl_calibration_input_keypoints)):
-> 1764       raise ValueError('Input keypoints are invalid for feature {}: {}'.format(
   1765           feature_config.name, feature_config.pwl_calibration_input_keypoints))
   1766   elif feature_config.monotonicity and feature_config.monotonicity != 'none':

ValueError: Input keypoints are invalid for feature age: {'class_name': '__numpy__', 'config': {'value': [29.0, 44.0, 54.0, 65.0, 100.0], 'dtype': 'float64'}}

[win13676]

from quick investigation my guess the issue is with validating the serialized np array in the model config
https://github.com/keras-team/tf-keras/blob/v2.18.0/tf_keras/saving/serialization_lib.py#L180
the pwl_calibration_input_keypoints value is a dict instead of list/array
the config.json in keras file:

{'class_name': 'FeatureConfig',
      'config': {'name': 'age',
       'is_missing_name': None,
       'default_value': None,
       'lattice_size': 3,
       'monotonicity': 'increasing',
       'unimodality': 'none',
       'reflects_trust_in': None,
       'dominates': None,
       'pwl_calibration_always_monotonic': False,
       'pwl_calibration_convexity': 0,
       'pwl_calibration_num_keypoints': 5,
       'pwl_calibration_input_keypoints': {'class_name': '__numpy__',
        'config': {'value': [29.0, 44.0, 54.0, 65.0, 100.0],
         'dtype': 'float64'}},
       'pwl_calibration_input_keypoints_type': 'fixed',
       'pwl_calibration_clip_min': None,
       'pwl_calibration_clip_max': 100,
       'pwl_calibration_clamp_min': False,
       'pwl_calibration_clamp_max': False,
       'num_buckets': 0,
       'vocabulary_list': None,
       'regularizer_configs': [{'class_name': 'RegularizerConfig',
         'config': {'name': 'calib_wrinkle', 'l1': 0.0, 'l2': 0.1}}]}},

vs the model.get_config():

    {'class_name': 'FeatureConfig',
     'config': {'name': 'age',
      'is_missing_name': None,
      'default_value': None,
      'lattice_size': 3,
      'monotonicity': 'increasing',
      'unimodality': 'none',
      'reflects_trust_in': None,
      'dominates': None,
      'pwl_calibration_always_monotonic': False,
      'pwl_calibration_convexity': 0,
      'pwl_calibration_num_keypoints': 5,
      'pwl_calibration_input_keypoints': array([ 29.,  44.,  54.,  65., 100.]),
      'pwl_calibration_input_keypoints_type': 'fixed',
      'pwl_calibration_clip_min': None,
      'pwl_calibration_clip_max': 100,
      'pwl_calibration_clamp_min': False,
      'pwl_calibration_clamp_max': False,
      'num_buckets': 0,
      'vocabulary_list': None,
      'regularizer_configs': [{'class_name': 'RegularizerConfig',
        'config': {'name': 'calib_wrinkle', 'l1': 0.0, 'l2': 0.1}}]}},

to test things out i try modifying the cp feature
if i try move age down and add .tolist() to cp and the code didn't complain about cp

    tfl.configs.FeatureConfig(
        name='cp',
        monotonicity='increasing',
        # Keypoints that are uniformly spaced.
        pwl_calibration_num_keypoints=4,
        pwl_calibration_input_keypoints=np.linspace(
            np.min(heart_train_xs[feature_name_indices['cp']]),
            np.max(heart_train_xs[feature_name_indices['cp']]),
            num=4).tolist(),
    ),

a potential fix could be for _verify_feature_config to handle the dictionary and check the config.value assuming that the base tf can deserialize the dictionary
alternately, serialize the config differently
alternately, make pwl_calibration_input_keypoints internally converts np array to list

[paulsendavidjay]

I'm wondering if anyone has made headway on this issue. Using GCP workbook instance with pre-installed tensorflow 2-11 kernel

numpy==1.26.4
tensorflow==2.19.0
tensorflow-cloud==0.1.16
tensorflow-datasets==4.9.0
tensorflow-estimator==2.11.0
tensorflow-hub==0.16.1
tensorflow-io==0.29.0
tensorflow-io-gcs-filesystem==0.29.0
tensorflow-lattice==2.1.1
tensorflow-metadata==1.16.1
tensorflow-probability==0.25.0
tensorflow-serving-api==2.16.1
tensorflow-transform==1.16.0

---

ValueError Traceback (most recent call last)
Cell In[75], line 3
1 latt_config = lattice_model.get_config()
----> 3 reconstructed_model = tf.keras.models.load_model(
4 os.path.join(model_dir, 'latice_base.keras'),
5 custom_objects={"CalibratedLattice": lattice_model},
6 )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_api.py:189, in load_model(filepath, custom_objects, compile, safe_mode)
186 is_keras_zip = True
188 if is_keras_zip or is_keras_dir or is_hf:
--> 189 return saving_lib.load_model(
190 filepath,
191 custom_objects=custom_objects,
192 compile=compile,
193 safe_mode=safe_mode,
194 )
195 if str(filepath).endswith((".h5", ".hdf5")):
196 return legacy_h5_format.load_model_from_hdf5(
197 filepath, custom_objects=custom_objects, compile=compile
198 )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:367, in load_model(filepath, custom_objects, compile, safe_mode)
362 raise ValueError(
363 "Invalid filename: expected a .keras extension. "
364 f"Received: filepath={filepath}"
365 )
366 with open(filepath, "rb") as f:
--> 367 return _load_model_from_fileobj(
368 f, custom_objects, compile, safe_mode
369 )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:444, in _load_model_from_fileobj(fileobj, custom_objects, compile, safe_mode)
441 with zf.open(_CONFIG_FILENAME, "r") as f:
442 config_json = f.read()
--> 444 model = _model_from_config(
445 config_json, custom_objects, compile, safe_mode
446 )
448 all_filenames = zf.namelist()
449 extract_dir = None

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:433, in _model_from_config(config_json, custom_objects, compile, safe_mode)
431 # Construct the model from the configuration file in the archive.
432 with ObjectSharingScope():
--> 433 model = deserialize_keras_object(
434 config_dict, custom_objects, safe_mode=safe_mode
435 )
436 return model

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/serialization_lib.py:718, in deserialize_keras_object(config, custom_objects, safe_mode, **kwargs)
716 with custom_obj_scope, safe_mode_scope:
717 try:
--> 718 instance = cls.from_config(inner_config)
719 except TypeError as e:
720 raise TypeError(
721 f"{cls} could not be deserialized properly. Please"
722 " ensure that components that are Python object"
(...)
726 f"\n\nconfig={config}.\n\nException encountered: {e}"
727 )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/tensorflow_lattice/python/premade.py:264, in CalibratedLattice.from_config(cls, config, custom_objects)
262 @classmethod
263 def from_config(cls, config, custom_objects=None):
--> 264 model_config = keras.utils.legacy.deserialize_keras_object(
265 config.get('model_config'), custom_objects=custom_objects
266 )
267 premade_lib.verify_config(model_config)
268 return cls(model_config,
269 name=config.get('name', None),
270 trainable=config.get('trainable', True))

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/tf_keras/src/saving/legacy/serialization.py:481, in deserialize_keras_object(identifier, module_objects, custom_objects, printable_module_name)
478 if isinstance(identifier, dict):
479 # In this case we are dealing with a TF-Keras config dictionary.
480 config = identifier
--> 481 (cls, cls_config) = class_and_config_for_serialized_keras_object(
482 config, module_objects, custom_objects, printable_module_name
483 )
485 # If this object has already been loaded (i.e. it's shared between
486 # multiple objects), return the already-loaded object.
487 shared_object_id = config.get(SHARED_OBJECT_KEY)

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/tf_keras/src/saving/legacy/serialization.py:365, in class_and_config_for_serialized_keras_object(config, module_objects, custom_objects, printable_module_name)
361 cls = object_registration.get_registered_object(
362 class_name, custom_objects, module_objects
363 )
364 if cls is None:
--> 365 raise ValueError(
366 f"Unknown {printable_module_name}: '{class_name}'. "
367 "Please ensure you are using a keras.utils.custom_object_scope "
368 "and that this object is included in the scope. See "
369 "https://www.tensorflow.org/guide/keras/save_and_serialize"
370 "#registering_the_custom_object for details."
371 )
373 cls_config = config["config"]
374 # Check if cls_config is a list. If it is a list, return the class and the
375 # associated class configs for recursively deserialization. This case will
376 # happen on the old version of sequential model (e.g. keras_version ==
377 # "2.0.6"), which is serialized in a different structure, for example
378 # "{'class_name': 'Sequential',
379 # 'config': [{'class_name': 'Embedding', 'config': ...}, {}, ...]}".

ValueError: Unknown object: 'CalibratedLatticeConfig'. Please ensure you are using a keras.utils.custom_object_scope and that this object is included in the scope. See https://www.tensorflow.org/guide/keras/save_and_serialize#registering_the_custom_object for details.

[win13676]

@paulsendavidjay
for your case could you try just registering all of tfl custom objects?

tf.keras.models.load_model(model_dir, custom_objects=tfl.premade.get_custom_objects())

if u see issue with "Input keypoints are invalid ..." try converting np array to list in the model config

[paulsendavidjay]

Thanks @win13676. I took care of the np array and have tried two ways of specifying the custom objects.

The first:

import tensorflow_lattice # to find the objects as defined in get_custom_objects()

reconstructed_model = tf.keras.models.load_model(
    os.path.join(model_dir, 'latice_test.keras'),
    custom_objects = tfl.premade.get_custom_objects()
)

I get the following trace:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[69], line 3
      1 import tensorflow_lattice
----> 3 reconstructed_model = tf.keras.models.load_model(
      4     os.path.join(model_dir, 'latice_test.keras'),
      5     custom_objects = tfl.premade.get_custom_objects()
      6 )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_api.py:189, in load_model(filepath, custom_objects, compile, safe_mode)
    186         is_keras_zip = True
    188 if is_keras_zip or is_keras_dir or is_hf:
--> 189     return saving_lib.load_model(
    190         filepath,
    191         custom_objects=custom_objects,
    192         compile=compile,
    193         safe_mode=safe_mode,
    194     )
    195 if str(filepath).endswith((".h5", ".hdf5")):
    196     return legacy_h5_format.load_model_from_hdf5(
    197         filepath, custom_objects=custom_objects, compile=compile
    198     )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:367, in load_model(filepath, custom_objects, compile, safe_mode)
    362     raise ValueError(
    363         "Invalid filename: expected a `.keras` extension. "
    364         f"Received: filepath={filepath}"
    365     )
    366 with open(filepath, "rb") as f:
--> 367     return _load_model_from_fileobj(
    368         f, custom_objects, compile, safe_mode
    369     )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:444, in _load_model_from_fileobj(fileobj, custom_objects, compile, safe_mode)
    441 with zf.open(_CONFIG_FILENAME, "r") as f:
    442     config_json = f.read()
--> 444 model = _model_from_config(
    445     config_json, custom_objects, compile, safe_mode
    446 )
    448 all_filenames = zf.namelist()
    449 extract_dir = None

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:433, in _model_from_config(config_json, custom_objects, compile, safe_mode)
    431 # Construct the model from the configuration file in the archive.
    432 with ObjectSharingScope():
--> 433     model = deserialize_keras_object(
    434         config_dict, custom_objects, safe_mode=safe_mode
    435     )
    436 return model

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/serialization_lib.py:718, in deserialize_keras_object(config, custom_objects, safe_mode, **kwargs)
    716 with custom_obj_scope, safe_mode_scope:
    717     try:
--> 718         instance = cls.from_config(inner_config)
    719     except TypeError as e:
    720         raise TypeError(
    721             f"{cls} could not be deserialized properly. Please"
    722             " ensure that components that are Python object"
   (...)
    726             f"\n\nconfig={config}.\n\nException encountered: {e}"
    727         )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/tensorflow_lattice/python/premade.py:264, in CalibratedLattice.from_config(cls, config, custom_objects)
    262 @classmethod
    263 def from_config(cls, config, custom_objects=None):
--> 264   model_config = keras.utils.legacy.deserialize_keras_object(
    265       config.get('model_config'), custom_objects=custom_objects
    266   )
    267   premade_lib.verify_config(model_config)
    268   return cls(model_config,
    269              name=config.get('name', None),
    270              trainable=config.get('trainable', True))

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/tf_keras/src/saving/legacy/serialization.py:481, in deserialize_keras_object(identifier, module_objects, custom_objects, printable_module_name)
    478 if isinstance(identifier, dict):
    479     # In this case we are dealing with a TF-Keras config dictionary.
    480     config = identifier
--> 481     (cls, cls_config) = class_and_config_for_serialized_keras_object(
    482         config, module_objects, custom_objects, printable_module_name
    483     )
    485     # If this object has already been loaded (i.e. it's shared between
    486     # multiple objects), return the already-loaded object.
    487     shared_object_id = config.get(SHARED_OBJECT_KEY)

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/tf_keras/src/saving/legacy/serialization.py:365, in class_and_config_for_serialized_keras_object(config, module_objects, custom_objects, printable_module_name)
    361 cls = object_registration.get_registered_object(
    362     class_name, custom_objects, module_objects
    363 )
    364 if cls is None:
--> 365     raise ValueError(
    366         f"Unknown {printable_module_name}: '{class_name}'. "
    367         "Please ensure you are using a `keras.utils.custom_object_scope` "
    368         "and that this object is included in the scope. See "
    369         "https://www.tensorflow.org/guide/keras/save_and_serialize"
    370         "#registering_the_custom_object for details."
    371     )
    373 cls_config = config["config"]
    374 # Check if `cls_config` is a list. If it is a list, return the class and the
    375 # associated class configs for recursively deserialization. This case will
    376 # happen on the old version of sequential model (e.g. `keras_version` ==
    377 # "2.0.6"), which is serialized in a different structure, for example
    378 # "{'class_name': 'Sequential',
    379 #   'config': [{'class_name': 'Embedding', 'config': ...}, {}, ...]}".

ValueError: Unknown object: 'CalibratedLatticeConfig'. Please ensure you are using a `keras.utils.custom_object_scope` and that this object is included in the scope. See https://www.tensorflow.org/guide/keras/save_and_serialize#registering_the_custom_object for details.

The second, based on the error in the first:

with keras.utils.custom_object_scope(get_tfl_custom_objects()):
    reconstructed_model = tf.keras.models.load_model(
        os.path.join(model_dir, 'latice_test.keras')
    )

which gives the trace:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[72], line 2
      1 with keras.utils.custom_object_scope(get_tfl_custom_objects()):
----> 2     reconstructed_model = tf.keras.models.load_model(
      3         os.path.join(model_dir, 'latice_test.keras')
      4     )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_api.py:189, in load_model(filepath, custom_objects, compile, safe_mode)
    186         is_keras_zip = True
    188 if is_keras_zip or is_keras_dir or is_hf:
--> 189     return saving_lib.load_model(
    190         filepath,
    191         custom_objects=custom_objects,
    192         compile=compile,
    193         safe_mode=safe_mode,
    194     )
    195 if str(filepath).endswith((".h5", ".hdf5")):
    196     return legacy_h5_format.load_model_from_hdf5(
    197         filepath, custom_objects=custom_objects, compile=compile
    198     )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:367, in load_model(filepath, custom_objects, compile, safe_mode)
    362     raise ValueError(
    363         "Invalid filename: expected a `.keras` extension. "
    364         f"Received: filepath={filepath}"
    365     )
    366 with open(filepath, "rb") as f:
--> 367     return _load_model_from_fileobj(
    368         f, custom_objects, compile, safe_mode
    369     )

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:444, in _load_model_from_fileobj(fileobj, custom_objects, compile, safe_mode)
    441 with zf.open(_CONFIG_FILENAME, "r") as f:
    442     config_json = f.read()
--> 444 model = _model_from_config(
    445     config_json, custom_objects, compile, safe_mode
    446 )
    448 all_filenames = zf.namelist()
    449 extract_dir = None

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/saving_lib.py:433, in _model_from_config(config_json, custom_objects, compile, safe_mode)
    431 # Construct the model from the configuration file in the archive.
    432 with ObjectSharingScope():
--> 433     model = deserialize_keras_object(
    434         config_dict, custom_objects, safe_mode=safe_mode
    435     )
    436 return model

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/serialization_lib.py:694, in deserialize_keras_object(config, custom_objects, safe_mode, **kwargs)
    691     if obj is not None:
    692         return obj
--> 694 cls = _retrieve_class_or_fn(
    695     class_name,
    696     registered_name,
    697     module,
    698     obj_type="class",
    699     full_config=config,
    700     custom_objects=custom_objects,
    701 )
    703 if isinstance(cls, types.FunctionType):
    704     return cls

File /opt/conda/envs/tensorflow/lib/python3.10/site-packages/keras/src/saving/serialization_lib.py:810, in _retrieve_class_or_fn(name, registered_name, module, obj_type, full_config, custom_objects)
    803         except ModuleNotFoundError:
    804             raise TypeError(
    805                 f"Could not deserialize {obj_type} '{name}' because "
    806                 f"its parent module {module} cannot be imported. "
    807                 f"Full object config: {full_config}"
    808             )
--> 810 raise TypeError(
    811     f"Could not locate {obj_type} '{name}'. "
    812     "Make sure custom classes are decorated with "
    813     "`@keras.saving.register_keras_serializable()`. "
    814     f"Full object config: {full_config}"
    815 )

TypeError: Could not locate class 'CalibratedLattice'. Make sure custom classes are decorated with `@keras.saving.register_keras_serializable()`. Full object config: {'module': 'tensorflow_lattice.python.premade', 'class_name': 'CalibratedLattice', 'config': {'name': 'calibrated_lattice', 'trainable': True, 'model_config': {'class_name': 'CalibratedLatticeConfig', 'config': {'feature_configs': [{'class_name': 'FeatureConfig', 'config': {'name': 'epd2score', 'is_missing_name': None, 'default_value': None, 'lattice_size': 5, 'monotonicity': 'increasing', 'unimodality': 'none', 'reflects_trust_in': None, 'dominates': None, 'pwl_calibration_always_monotonic': False, 'pwl_calibration_convexity': 0, 'pwl_calibration_num_keypoints': 7, 'pwl_calibration_input_keypoints': [-7.549870014190674, -2.790522336959839, -1.980574131011963, -1.4232773780822754, -0.9233340620994568, -0.2753908336162567, 5.391552448272705], 'pwl_calibration_input_keypoints_type': 'fixed', 'pwl_calibration_clip_min': None, 'pwl_calibration_clip_max': None, 'pwl_calibration_clamp_min': False, 'pwl_calibration_clamp_max': False, 'num_buckets': 0, 'vocabulary_list': None, 'regularizer_configs': [{'class_name': 'RegularizerConfig', 'config': {'name': 'calib_wrinkle', 'l1': 0.0, 'l2': 0.1}}]}}, {'class_name': 'FeatureConfig', 'config': {'name': 'pmiscore', 'is_missing_name': None, 'default_value': None, 'lattice_size': 5, 'monotonicity': 'increasing', 'unimodality': 'none', 'reflects_trust_in': None, 'dominates': None, 'pwl_calibration_always_monotonic': False, 'pwl_calibration_convexity': 0, 'pwl_calibration_num_keypoints': 7, 'pwl_calibration_input_keypoints': [-6.929022409375414, -2.364221376644908, -1.5275734258532245, -0.9588624956012133, -0.47616547656655617, 0.0891870716573956, 1.0], 'pwl_calibration_input_keypoints_type': 'fixed', 'pwl_calibration_clip_min': None, 'pwl_calibration_clip_max': 1, 'pwl_calibration_clamp_min': False, 'pwl_calibration_clamp_max': False, 'num_buckets': 0, 'vocabulary_list': None, 'regularizer_configs': [{'class_name': 'RegularizerConfig', 'config': {'name': 'calib_wrinkle', 'l1': 0.0, 'l2': 0.1}}]}}, {'class_name': 'FeatureConfig', 'config': {'name': 'fico_logrev', 'is_missing_name': None, 'default_value': None, 'lattice_size': 5, 'monotonicity': 'increasing', 'unimodality': 'none', 'reflects_trust_in': None, 'dominates': None, 'pwl_calibration_always_monotonic': False, 'pwl_calibration_convexity': 0, 'pwl_calibration_num_keypoints': 7, 'pwl_calibration_input_keypoints': [0.48215044559386533, 0.507856496176607, 0.5324543063873187, 0.5572478545985556, 0.5814117428629063, 0.605191203120483, 0.6357911951701147], 'pwl_calibration_input_keypoints_type': 'fixed', 'pwl_calibration_clip_min': None, 'pwl_calibration_clip_max': None, 'pwl_calibration_clamp_min': True, 'pwl_calibration_clamp_max': True, 'num_buckets': 0, 'vocabulary_list': None, 'regularizer_configs': [{'class_name': 'RegularizerConfig', 'config': {'name': 'calib_wrinkle', 'l1': 0.0, 'l2': 0.1}}]}}, {'class_name': 'FeatureConfig', 'config': {'name': 'selfemp_flag', 'is_missing_name': None, 'default_value': None, 'lattice_size': 2, 'monotonicity': 'none', 'unimodality': 'none', 'reflects_trust_in': None, 'dominates': None, 'pwl_calibration_always_monotonic': False, 'pwl_calibration_convexity': 0, 'pwl_calibration_num_keypoints': 10, 'pwl_calibration_input_keypoints': 'quantiles', 'pwl_calibration_input_keypoints_type': 'fixed', 'pwl_calibration_clip_min': None, 'pwl_calibration_clip_max': None, 'pwl_calibration_clamp_min': False, 'pwl_calibration_clamp_max': False, 'num_buckets': 2, 'vocabulary_list': None, 'regularizer_configs': None}}], 'interpolation': 'hypercube', 'parameterization': 'all_vertices', 'num_terms': 2, 'regularizer_configs': [{'class_name': 'RegularizerConfig', 'config': {'name': 'calib_hessian', 'l1': 0.0, 'l2': 0.01}}], 'output_min': None, 'output_max': None, 'output_calibration': False, 'output_calibration_num_keypoints': 10, 'output_initialization': [-2.0, 2.0], 'output_calibration_input_keypoints_type': 'fixed', 'random_seed': 0}}}, 'registered_name': 'CalibratedLattice', 'build_config': {'input_shape': [[None, 1], [None, 1], [None, 1], [None, 1]]}, 'compile_config': {'optimizer': {'module': 'keras.optimizers', 'class_name': 'Adam', 'config': {'name': 'Adam', 'weight_decay': None, 'clipnorm': None, 'global_clipnorm': None, 'clipvalue': None, 'use_ema': False, 'ema_momentum': 0.99, 'ema_overwrite_frequency': None, 'jit_compile': False, 'is_legacy_optimizer': False, 'learning_rate': 0.009999999776482582, 'beta_1': 0.9, 'beta_2': 0.999, 'epsilon': 1e-07, 'amsgrad': False}, 'registered_name': None}, 'loss': {'module': 'keras.losses', 'class_name': 'BinaryCrossentropy', 'config': {'reduction': 'auto', 'name': 'binary_crossentropy', 'from_logits': True, 'label_smoothing': 0.0, 'axis': -1, 'fn': 'binary_crossentropy'}, 'registered_name': None}, 'metrics': [{'module': 'keras.metrics', 'class_name': 'AUC', 'config': {'name': 'auc', 'dtype': 'float32', 'num_thresholds': 200, 'curve': 'ROC', 'summation_method': 'interpolation', 'multi_label': False, 'num_labels': None, 'label_weights': None, 'from_logits': True}, 'registered_name': None}], 'loss_weights': None, 'weighted_metrics': None, 'run_eagerly': None, 'steps_per_execution': None, 'jit_compile': None}}

I've seen the decorator suggestion several places, but am not sure how to implement that given these classes are predefined.

Thoughts?

[win13676]

@paulsendavidjay
just to double check, did u define tfl?
import tensorflow_lattice as tfl

also are you using keras 2 or 3?
u can check keras version by running tf.keras.__version__
i think tf lattice only supports keras 2
if keras 2, u can keep tf.keras as is
if keras 3, u might need to install tf-keras
and use tf_keras instead of tf.keras
so either

import tf_keras
tf_keras.models.load_model 

or

import tf_keras as keras
keras.models.load_model 

[paulsendavidjay]

@win13676

Thank you. This information helped. I will answer the question and post my error for anyone else having this silly mistake.

Yes, I defined
import tensorflow_lattice as tfl

keras version is '3.9.0'. I am also using the code block from the Lattice Premade Models example notebook:

# Use Keras 2.
version_fn = getattr(tf.keras, "version", None)
if version_fn and version_fn().startswith("3."):
    import tf_keras as keras
else:
    keras = tf.keras

The minor code change to make this work was to remove tf. in the load function (which was copied from another example not within the lattice demo):

# does not work
lattice_model.save(os.path.join(model_dir, 'latice_test.keras'))

reconstructed_model = tf.keras.models.load_model(
    os.path.join(model_dir, 'latice_test.keras'),
    custom_objects = tfl.premade.get_custom_objects()
)

# works
lattice_model.save(os.path.join(model_dir, 'latice_test.keras'))

reconstructed_model = keras.models.load_model(
    os.path.join(model_dir, 'latice_test.keras'),
    custom_objects = tfl.premade.get_custom_objects()
)