code: def _deserialize_dict(self, dict):
      def _param_deserializer_fn(
          name, param_val, keras_utils, custom_objects, model=None
      ):
          if param_val is None:
              return param_val
  
          if name == EstimatorParams.model.name:
  
              def load_model_fn(x):
                  with keras_utils.keras().utils.custom_object_scope(
                      custom_objects
                  ):
                      return keras_utils.keras().models.load_model(
                          x, compile=True
                      )
  
              return keras_utils.deserialize_model(
                  param_val, load_model_fn=load_model_fn
              )
          elif name == KerasEstimator.optimizer.name:
              opt_base64_encoded = codec.loads_base64(param_val)
              return keras_utils.deserialize_optimizer(
                  opt_base64_encoded, model=model
              )
          else:
              return codec.loads_base64(param_val)
  
      # In order to deserialize the model, we need to deserialize the custom_objects param
      # first.
      custom_objects = {}
      if KerasEstimator.custom_objects.name in dict:
          custom_objects = _param_deserializer_fn(
              KerasEstimator.custom_objects.name,
              dict[KerasEstimator.custom_objects.name],
              None,
              None,
          )
  
      model = None
      model_name = EstimatorParams.model.name
      if model_name in dict:
          model = _param_deserializer_fn(
              model_name, dict[model_name], TFKerasUtil, custom_objects
          )
  
      for key, val in dict.items():
          if key == model_name:
              dict[model_name] = model
          dict[key] = _param_deserializer_fn(
              key, val, TFKerasUtil, custom_objects, model
          )
      return dict
  
imports: import numbers
  import time
  import os
  import numpy
  import tensorflow
  from packaging import version
  from pyspark import keyword_only
  from pyspark.ml.util import MLWritable, MLReadable
  from pyspark.ml.param.shared import Param, Params, TypeConverters
  from pyspark.sql import SparkSession
  from horovod.runner.common.util import codec
  from horovod.spark.common import util
  from horovod.spark.common.estimator import HorovodEstimator, HorovodModel
  from horovod.spark.common.params import EstimatorParams
  from horovod.spark.common.serialization import HorovodParamsWriter, HorovodParamsReader
  from horovod.spark.keras import remote
  from horovod.spark.keras.util import TFKerasUtil
  from horovod.spark.keras.datamodule import PetastormDataModule
label_desc: Use image node_id 1 for calling the KerasEstimatorParamsReader obj's underlying member method code with example usage: obj._deserialize_dict(dict) and returns: dict, param_val, keras_utils, keras_utils, codec, keras_utils