o i eu@spdZddlZddlZddlZddlZddlZddlZddlm m Z ddl m Z ddlmZddlmZddlmZddlmZddlmZeeeefZeZeZ d Z!d Z"Gd d d Z#Gd ddZ$edddZ%ddZ&GdddZ'ddZ(ddZ)ddZ*eddddZ+d d!Z,d1d"d#Z-d1d$d%Z.d&d'Z/d(d)Z0ed*d+ ,d2d-d.Z1 d1d/d0Z2dS)3z6Object config serialization and deserialization logic.N)object_registration) serialization)in_tf_saved_model_scope) generic_utils) tf_export) keras_export)z%tensorflow.python.ops.custom_gradient) activations constraints initializerslossesmetrics optimizers regularizersc@seZdZddZddZdS)ConfigcK ||_dSNconfig)selfrrQ/var/www/myenv/lib/python3.10/site-packages/keras/src/saving/serialization_lib.py__init__7 zConfig.__init__cCs t|jSr)serialize_keras_objectrrrrr serialize:rzConfig.serializeN)__name__ __module__ __qualname__rrrrrrr6s rc@s*eZdZdZd ddZddZddZd S) SafeModeScopezBScope to propagate safe mode flag to nested deserialization calls.TcCrr) safe_mode)rr rrrrArzSafeModeScope.__init__cCst|_|jt_dSr) in_safe_modeoriginal_valuer SAFE_MODErrrr __enter__Ds zSafeModeScope.__enter__cOs |jt_dSr)r"r#r rargskwargsrrr__exit__H zSafeModeScope.__exit__N)T)rrr__doc__rr$r(rrrrr>s   rz0keras.__internal__.enable_unsafe_deserializationcCs dt_dS)zADisables safe mode globally, allowing deserialization of lambdas.FN)r#r rrrrenable_unsafe_deserializationLs r+cCs ttddS)Nr )getattrr#rrrrr!Rr)r!c@s eZdZdZddZddZdS)ObjectSharingScopez?Scope to enable detection and reuse of previously seen objects.cCdt_it_it_dSNTSHARED_OBJECTSenabled id_to_obj_mapid_to_config_maprrrrr$Y zObjectSharingScope.__enter__cOr.)NFr0r%rrrr(^r5zObjectSharingScope.__exit__N)rrrr*r$r(rrrrr-Vs r-cCsttddr tj|dSdS)z:Retrieve an object previously seen during deserialization.r2FN)r,r1r3get)obj_idrrrget_shared_objectds r8cCsf|ddkr d|d<ttddsdStt|}|tjvr$|tj|<dS||d<tj|}||d<dS)z>Call after serializing an object, to keep track of its config.module__main__Nr2Fshared_object_id)r,r1intidr4)objrr7 prev_configrrr!record_object_after_serializationjs      r@cCsttddsdS|tj|<dS)zFCall after deserializing an object, to keep track of it in the future.r2FN)r,r1r3)r>r7rrr#record_object_after_deserializationys rAz#keras.saving.serialize_keras_objectz"keras.utils.serialize_keras_objectc stjjr trt|S|dur|St|tr|St|t t fr4dd|D}t|t r2t |S|St|t r=t |St|t rLdd|didSt|tjr]|jdur[|SdSt|tjrqd||jjd dSt|jtjkrt|tjr|jd krd ||jjd dS|St|tjr|jSt|tjj j!r|j"St|t#j$r|jd krt%j&d t'(|ddddt)*|idSt|tj+r|,}t t-dd|}|j.j}d}t/|drtj0j12|}t |}t34|j.}d||j.j||dSt5|}t6|j.|t|t7r|dkr|Sdur:t8fddt9Dr.|St:|t;|St|t#j$rE|j}n|j.j}|j.j}|dkrUd}nt|t#j$rbt34|}nt34|j.}||||d}t:||t;|||S)aRetrieve the config dict by serializing the Keras object. `serialize_keras_object()` serializes a Keras object to a python dictionary that represents the object, and is a reciprocal function of `deserialize_keras_object()`. See `deserialize_keras_object()` for more information about the config format. Args: obj: the Keras object to serialize. Returns: A python dict that represents the object. The python dict can be deserialized via `deserialize_keras_object()`. NcSsg|]}t|qSrr.0xrrr sz*serialize_keras_object.. __bytes__valueutf-8) class_namer __tensor__)rHdtyper __numpy__zaThe object being serialized includes a `lambda`. This is unsafe. In order to reload the object, you will have to pass `safe_mode=False` to the loading function. Please avoid using `lambda` in the future, and use named Python functions instead. This is the `lambda` being serialized: ) stacklevel __lambda__cSs*t|tjr |St|tjr|jS|Sr) isinstancetf TensorShapeas_listDTypenamerErrrs  z(serialize_keras_object.._tf_extension_type_fields __typespec__)rJ spec_namer9rregistered_nameop_dispatch_handlerc3s|] }|dvVqdS)r9Nr)rDmodconfig_with_public_classrr s  z)serialize_keras_object..builtinsr9rJrr\) config_arr ts_configr[r\ inner_configr9rJrrr_rrs                    rcCsPt|dr|}|durt||d<t|dr&|}|dur&t||d<dS)Nget_build_config build_configget_compile_configcompile_config)rrrkr)r>rrrrrrr$s    rcCshtj|dd}|durt|}|durdS|j|j||dS|d}d|dd|d|ddS)zSerializes classes from public Keras API or object registration. Called to check and retrieve the config of any class that has a public Keras API or has been registered as serializable via `keras.saving.register_keras_serializable()`. kerasapi_nameNrc.)rget_canonical_name_for_symbolrrrrsplitjoin)clsrkeras_api_namer\partsrrrr0s$  rcCsv|r |d||dStj|dd}|r%|d}d|ddd||dSt|}|s3|jdks3dS|jd||dS) aOSerializes functions from public Keras API or object registration. Called to check and retrieve the config of any function that has a public Keras API or has been registered as serializable via `keras.saving.register_keras_serializable()`. If function's module name is already known, returns corresponding config. functionrcrrrNrrb)rrrrrrr)fnrfn_module_namerrr\rrrserialize_with_public_fnTs0  rcCsxt|tjr |jSt|dr%|}t|ts!td|d|t|St|dr/t |Std|dt |d)z1Return the object's config depending on its type. get_configzThe `get_config()` method of z$ should return a dict. It returned: rzCannot serialize object z of type zG. To be serializable, a class must implement the `get_config()` method.) rQrzr{rrrrj TypeErrorrkrrrr)r>rrrrrzs     rcCsdd|DS)NcSsi|] \}}|t|qSrrBrDkeyrHrrr sz"serialize_dict..)items)r>rrrrksrkz%keras.saving.deserialize_keras_objectz$keras.utils.deserialize_keras_objectTc st}|dur |n|dd}pitjj}tj}i|||dd}|r7tdt|t j j r@t rHt|||S|durNdSt|tr`r`|dur`|St|ttfrqfdd|DS|dur d\} } } t|trd |vr|d } d |vrtd |r|d vs|d vst| tr| vrd } n3|d dkr|d} | dkr|d }n |d }n|dddurtd|d d|d d|d }| s ||vr|St||tjrtt|||| dStt||| ddSt|tr|St|tstd|d |vs)d |vr5fdd|DS|d } |d p?i} pDi| dkrUt j| d| ddS| dkretj| d| ddS|d dkrs| dd S|d d!krrtd"t !| dS|d d#krt"|d$|d |dd%|d&} t#| d'rfd(d| D} | d1i| S|d dur| $| St%d)d*| } | &t| S|dd}|d | }| dkr| }t"|||d|d&Sd+|vrt'|d+}|dur|St"| ||d%|d&} t| tjr| St#| d,s$td-| d.|t(}t)}|<|)| $| }|d/d}|rF|*||d0d}|rT|+|Wdn 1s_wYWdn 1sowYd+|vrt,||d+|S)2aRetrieve the object by deserializing the config dict. The config dict is a Python dictionary that consists of a set of key-value pairs, and represents a Keras object, such as an `Optimizer`, `Layer`, `Metrics`, etc. The saving and loading library uses the following keys to record information of a Keras object: - `class_name`: String. This is the name of the class, as exactly defined in the source code, such as "LossesContainer". - `config`: Dict. Library-defined or user-defined key-value pairs that store the configuration of the object, as obtained by `object.get_config()`. - `module`: String. The path of the python module, such as "keras.engine.compile_utils". Built-in Keras classes expect to have prefix `keras`. - `registered_name`: String. The key the class is registered under via `keras.saving.register_keras_serializable(package, name)` API. The key has the format of '{package}>{name}', where `package` and `name` are the arguments passed to `register_keras_serializable()`. If `name` is not provided, it uses the class name. If `registered_name` successfully resolves to a class (that was registered), the `class_name` and `config` values in the dict will not be used. `registered_name` is only used for non-built-in classes. For example, the following dictionary represents the built-in Adam optimizer with the relevant config: ```python dict_structure = { "class_name": "Adam", "config": { "amsgrad": false, "beta_1": 0.8999999761581421, "beta_2": 0.9990000128746033, "decay": 0.0, "epsilon": 1e-07, "learning_rate": 0.0010000000474974513, "name": "Adam" }, "module": "keras.optimizers", "registered_name": None } # Returns an `Adam` instance identical to the original one. deserialize_keras_object(dict_structure) ``` If the class does not have an exported Keras namespace, the library tracks it by its `module` and `class_name`. For example: ```python dict_structure = { "class_name": "LossesContainer", "config": { "losses": [...], "total_loss_mean": {...}, }, "module": "keras.engine.compile_utils", "registered_name": "LossesContainer" } # Returns a `LossesContainer` instance identical to the original one. deserialize_keras_object(dict_structure) ``` And the following dictionary represents a user-customized `MeanSquaredError` loss: ```python @keras.saving.register_keras_serializable(package='my_package') class ModifiedMeanSquaredError(keras.losses.MeanSquaredError): ... dict_structure = { "class_name": "ModifiedMeanSquaredError", "config": { "fn": "mean_squared_error", "name": "mean_squared_error", "reduction": "auto" }, "registered_name": "my_package>ModifiedMeanSquaredError" } # Returns the `ModifiedMeanSquaredError` object deserialize_keras_object(dict_structure) ``` Args: config: Python dict describing the object. custom_objects: Python dict containing a mapping between custom object names the corresponding classes or functions. safe_mode: Boolean, whether to disallow unsafe `lambda` deserialization. When `safe_mode=False`, loading an object has the potential to trigger arbitrary code execution. This argument is only applicable to the Keras v3 model format. Defaults to `True`. Returns: The object described by the `config` dictionary. Nmodule_objectsprintable_module_nameobjectz-The following argument(s) are not supported: csg|] }t|dqScustom_objectsr deserialize_keras_objectrCrrrrF%s z,deserialize_keras_object..)NNFrrJz%Unknown `config` as a `dict`, config=r\Trr9rb_z#Cannot deserialize object of type `z`. If `zj` is a custom class, please register it using the `@keras.saving.register_keras_serializable()` decorator.r)rzCould not parse config: c i|] \}}|t|dqSrrrrrrrn z,deserialize_keras_object..rKrHrL)rLrMrGrIrPaRequested the deserialization of a `lambda` object. This carries a potential risk of arbitrary code execution and thus it is disallowed by default. If you trust the source of the saved model, you can pass `safe_mode=False` to the loading function in order to allow `lambda` loading.rZr[class)obj_type full_configrrYcrrrrrrrrrcSs2t|tr t|Sttjt|rtt|S|Sr)rQrhrRrSrdtypesrr,rWrrrrXs z*deserialize_keras_object..r; from_configz&Unable to reconstruct an instance of 'zM' because the class is missing a `from_config()` method. Full object config: rrr)-r!popr_THREAD_LOCAL_CUSTOM_OBJECTS__dict___GLOBAL_CUSTOM_OBJECTS ValueErrorrhkeysrRrdrer2rrfrrQrr6rirjrrzr{rrrgrconstantrsarrayencoder func_load_retrieve_class_or_fnrrr _deserializer8custom_object_scoperbuild_from_configcompile_from_configrA)rrr r'safe_scope_argrtlcogcorrrhas_custom_objectrJrr9r\fn_namer>custom_obj_scopesafe_mode_scopeinstancerrrrrrsVi                                   rc s|dkr tj||d}ntj||d}|dur|S|r|dks$|dr=|d|}d|vr2d|}t|}|dur=|S|dkrr|dkrrtD]} td| d|}|dur\|SqGfd d |D} | rrtt| Szt |} Wnt yt d |d |d |dwt| |d}|dur|durt| |d}|ddkr|d\} } t| | d} | durt| | dnd}|dur|St d|d |d)Nrrrzkeras.rz__internal__.legacyz compat.v1.rbcs$i|]\}}|dr||qSr)endswith)rDkvrrrrs  z)_retrieve_class_or_fn..zCould not deserialize z 'z' because its parent module z) cannot be imported. Full object config: zCould not locate zr'. Make sure custom classes are decorated with `@keras.saving.register_keras_serializable()`. Full object config: )rget_registered_object startswithrget_symbol_from_nameBUILTIN_MODULESrnextitervalues importlib import_moduleModuleNotFoundErrorrvarsr6countrr,)rVr\r9rrr custom_objrr>r^ filtered_dict outer_name inner_name outer_objrrrrsv     rrr/)3r*rr~ threadingrzr|rprstensorflow.compat.v2rwv2rRkeras.src.savingrkeras.src.saving.legacyrrf)keras.src.saving.legacy.saved_model.utilsrkeras.src.utilsrtensorflow.python.utilr tensorflow.python.util.tf_exportrrr<floatboolrglocalr1r#rrrrr+r!r-r8r@rArrrrrrkrrrrrrs`          " $& P