0hudZddlZddlZddlZddlZddlZddlZddlm cm Z ddl m Z ddlmZddlmZddlmZddlmZddlmZeeeefZej<Zej<Z d Z!d Z"Gd d Z#Gd dZ$eddZ%dZ&GddZ'dZ(dZ)dZ*edddZ+dZ,d#dZ-d#dZ.dZ/dZ0edd  d$d!Z1 d#d"Z2y)%z6Object 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 regularizersceZdZdZdZy)Configc ||_yN)config)selfrs _/var/www/html/engine/venv/lib/python3.12/site-packages/tf_keras/src/saving/serialization_lib.py__init__zConfig.__init__7s  c,t|jSr)serialize_keras_objectrrs r serializezConfig.serialize:s%dkk22rN)__name__ __module__ __qualname__rrrrrr6s 3rrc$eZdZdZddZdZdZy) SafeModeScopezBScope to propagate safe mode flag to nested deserialization calls.c||_yr) safe_mode)rr$s rrzSafeModeScope.__init__As "rcLt|_|jt_yr) in_safe_modeoriginal_valuer$ SAFE_MODErs r __enter__zSafeModeScope.__enter__Ds*n"nn rc.|jt_yr)r'r(r$rargskwargss r__exit__zSafeModeScope.__exit__Hs"11 rN)T)rrr__doc__rr)r.r rrr"r">sL#-2rr"z0keras.__internal__.enable_unsafe_deserializationcdt_y)zADisables safe mode globally, allowing deserialization of lambdas.FN)r(r$r rrenable_unsafe_deserializationr1Ls  Irc$ttddS)Nr$)getattrr(r rrr&r&Rs 9k4 00rceZdZdZdZdZy)ObjectSharingScopez?Scope to enable detection and reuse of previously seen objects.cFdt_it_it_yNTSHARED_OBJECTSenabled id_to_obj_mapid_to_config_maprs rr)zObjectSharingScope.__enter__Ys!%')$*,'rcFdt_it_it_y)NFr8r+s rr.zObjectSharingScope.__exit__^s!&')$*,'rN)rrrr/r)r.r rrr5r5VsI- -rr5cfttddr tjj|dSy)z:Retrieve an object previously seen during deserialization.r:FN)r3r9r;get)obj_ids rget_shared_objectrAds,~y%0++//==1rc|ddk(rd|d<ttddsytt|}|tjvr|tj|<y||d<tj|}||d<y)z>Call after serializing an object, to keep track of its config.module__main__Nr:Fshared_object_id)r3r9intidr<)objrr@ prev_configs r!record_object_after_serializationrJjsy h:%x >9e 4 C\F ^44428''/%+!"$55f= *0 &'rcNttddsy|tj|<y)zFCall after deserializing an object, to keep track of it in the future.r:FN)r3r9r;)rHr@s r#record_object_after_deserializationrLys! >9e 4+.N  (rz#keras.saving.serialize_keras_objectz"keras.utils.serialize_keras_objectc tjjjr t rt j |S||St|tr|St|ttfr5|Dcgc] }t |}}t|tr t|S|St|tr t|St|trdd|jdidSt|tjr|j |j#SdSt|tj$r8d|j'j)|j*j,ddSt/|j0t2j4k(rct|t2j6r9|j8dkDr*d |j)|j*j,ddS|j;St|tj<r |j,St|tj>j@jBr |jDSt|tFjHrV|j4d k(rGtKjLd tOjP|d ddtSjT|idSt|tjVr|jY}tt[d|}|j\j4}d}t_|drStj`jbje|}t|}tgjh|j\}d||j\j0||dStk|}tm|j\| t|tnr|dk(r|S 4tq fdtrDr|Stu| tw|  St|tFjHr |j0}n|j\j0}|j\j4}|dk(rd}nOt|tFjHrtgjh|}ntgjh|j\}||||d} tu|| tw|| | Scc}w)a Retrieve the config dict by serializing the TF-Keras object. `serialize_keras_object()` serializes a TF-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 TF-Keras object to serialize. Returns: A python dict that represents the object. The python dict can be deserialized via `deserialize_keras_object()`. N __bytes__valueutf-8) class_namer __tensor__)rOdtyper __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__ct|tjr|jSt|tjr |j S|Sr) isinstancetf TensorShapeas_listDTypenamexs rz(serialize_keras_object..s>a0))+ *1bhh 7aff=>r_tf_extension_type_fields __typespec__)rQ spec_namerCrregistered_nameop_dispatch_handlerc3,K|] }|dv yw)rCNr ).0modconfig_with_public_classs r z)serialize_keras_object..s$  +H5 5 sbuiltinsrCrQrre)6G6G6L5M  O  '005  #r{{#NN$  @   MM**  33 466>>sCI&y1I1EE O)"mm...   +3/L: | ,$9N)N +  5  J$S*BC)#/GH''#u))*))''J  c5-- .1EEcJO1EE O  * F !f-%c62 MC>s9Sct|dr |j}|t||d<t|dr |j}|t||d<y)Nget_build_config build_configget_compile_configcompile_config)rrrur)rHrrrs rrr#sbs&'++-  #%3L%AF> "s()//1  %'5n'EF# $ rctj|d}|3tj|}|y|j|j ||dS|j d}dj|dd|d|ddS)aSerializes classes from public TF-Keras API or object registration. Called to check and retrieve the config of any class that has a public TF-Keras API or has been registered as serializable via `keras.saving.register_keras_serializable()`. kerasapi_nameNrm.)rget_canonical_name_for_symbolrrrrsplitjoin)clsrkeras_api_namerepartss rrr/s<< gN -AA#F  "nn,,".      %E((5":&Bi  rc |r|d||dStj|d}|r*|jd}dj|ddd||dSt j |}|s|j dk(sy|j d||dS) aUSerializes functions from public TF-Keras API or object registration. Called to check and retrieve the config of any function that has a public TF-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. functionrmrrrNrrl)rrrrrrr)fnrfn_module_namerrres rserialize_with_public_fnrSs$$%   << WN$$S)hhuSbz*$%   .AA"Er}} 'Bmm$.   rcht|tjrtj|St |dr<|j }t|tstd|d|t|St |drtj|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.) rYrrrrrrrt TypeErrorrur|)rHrs rrrys#u))*"66s;;sL!!&$'/u5((.x1 f%% j !"66s;;&se9T#YK@@ @  rch|jDcic]\}}|t|c}}Scc}}wr)itemsr)rHkeyrOs rrurus+AD M:3C'. . MM Ms.z%keras.saving.deserialize_keras_objectz$keras.utils.deserialize_keras_objectc t}||n|}|jdd}|xsi}tjj}tj }i|||}|jdd}|r%t dt|jtjjjr trtj||||S|yt!|t"r|r|j%|||St!|tt&fr|D cgc]} t| ||c} S| d\} } } t!|t(rd|vr|d} d |vrt d ||r1|d |vs'|j%d |vst!| t"r| |vrd } nM|d d k(r|d} | dk(r|d}n5|d }n/|j%ddt+d|d d|d d|d }| sY||vr|St!||t,j.rtt1|||| |Stt3||| |St!|t4r|St!|t(st+d|d |vsd|vr0|j7D cic]\} }| t|||c}} S|d }|dxsi} |xsi}|dk(rtj8| d| dS|dk(rt;j<| d| dS|d dk(r| dj?dS|d dk(r%|r t dtAjB| dS|d d k(rtE|d!|d |dd"||#}tG|d$r7| j7D cic]\} }| t|||} } }|d,i| S|d |jI| StKd%| } |jMt'| S|j%dd}|j%d |}|d k(r| }tE|||d ||#Sd&|vrtO|d&}||StE|||d"||#}t!|t,j.r|StG|d'st+d(|d)|tjP|}tS|}|5|5|jI| }|j%d*d}|r|jU||j%d+d}|r|jW|ddddddd&|vrtY|d&Scc} wcc}} wcc}} w#1swY7xYw#1swY;xYw)-aRetrieve 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 TF-Keras object, such as an `Optimizer`, `Layer`, `Metrics`, etc. The saving and loading library uses the following keys to record information of a TF-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 TF-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 TF-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 TF-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: )custom_objectsr$)NNFrrQz%Unknown `config` as a `dict`, config=reTrrCrl_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: rRrOrS)rSrTrNrPrWaRequested 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.rcrdclass)obj_type full_configrrbct|trtj|St tj t |rtt|S|Sr)rYrrrZr[rdtypesrr3r_s rraz*deserialize_keras_object..sC!T"nnQ'$+BIIs1v$>'"a.DErrE 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 ValueErrorrrkeysrZrnror:rrpdeserialize_keras_objectrYrr?rsrtrrrrrrqrconstantr}arrayencoder func_load_retrieve_class_or_fnrrr _deserializerAcustom_object_scoper"build_from_configcompile_from_configrL)rrr$r-safe_scope_argrtlcogcorr`rrhas_custom_objectrrOrQrrCrefn_namerHcustom_obj_scopesafe_mode_scopeinstancerrs rrrsR"^N"0"<)IZZ 0$7N#)rN  ; ; D DD  4 4C66$6#6N#JJ'>I  ;FKKM"# %   ??   & & (,C,E#<< NN4I  ~ 63    v & 2f%%&4-(    %.I   !:K7 n&7 fd #6!%h/ 6) ;F8D |$6::/0NB|S1$6%)! %3!'!1!Z/#H-F#$56F::h,4#"<012"<012%% - ^+ .0%2D2DE/,&v.$2  ,+"6* .  &+& fd #26(;<<6!XV%; %lln  U )n     %J(#)rL#)rN\!{{<0 W8MNN[ xx W-\'5JKK l{*G$++G44 l|+ K &&|G'<== l~-# ;  $ % 8 )   33 4 #/"4"4"6 C-.IL && & # $ 0??<0 0 G   l 344ZZ$ 'Fjj!2J?OZ$   )   V#'9 :; ?J %  C#u))* 3 &4ZLA##)( ,  +>>~N#I.O 9?9??<0zz.$7   & &| 4$4d;   ( ( 899V#+ f/0  O R R@9999s7#T7T<U3U6AUUU UUc |dk(rtj||}ntj||}||S|rM|dk(s'|dk(s"|jds|jdr*|dz|z}d|vrd |z}tj|}||S|dk(r4|d k(r/t D]&} tjd| zdz|z}|$|cS |jdrd |z}t j|} t| j|d}|q|t| j|d}|jddk(r@|jd\} } t| j| d} | t| | dnd}||Std|d |d|#t$rtd |d |d|d|wxYw)Nrrtf_kerasrzkeras.z tf_keras.rz__internal__.legacyz compat.v1.rltf_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_MODULES importlib import_moduleModuleNotFoundErrorrvarsr?countrr3) r^rerCrrr custom_objrrHri outer_name inner_name outer_objs rrrs2 :(>>  )>> N  j    *  -|d*H%0'(200:C z !f &:& 44sNS(4/?J     )))&1C3immD$' ;*3immOT:zz#!#)-C& J IMM*d; !,Iz48 ?J  H:Rv. +m - 5# ( "TF;%%+H-''2m5  s +F!F>rr7)3r/rr threadingrrrzr}tensorflow.compat.v2rv2rZtf_keras.src.savingrtf_keras.src.saving.legacyrrp,tf_keras.src.saving.legacy.saved_model.utilsrtf_keras.src.utilsrtensorflow.python.utilr tensorflow.python.util.tf_exportrrrFfloatboolrqlocalr9r(rrrr"r1r&r5rArJrLrrrrrrurrr rrrs/= !!3LP,-9C%  " IOO  "L33 2 2@A B 1 - -> 1/)+O]]@  !H# L 0N+* ,0J J\ JNXr