~WhmNdZddlZddlZddlZddlZddlZddlZddlm cm Z ddl m Z ddlmZddlmZddlmZddlmZddlmZeeeefZejZejZ Gd d Z!Gd d Z"ed dZ#dZ$GddZ%dZ&dZ'dZ(dZ)dZ*dZ+ ddZ, ddZ-dS)z6Object config serialization and deserialization logic.N)object_registration) serialization)in_tf_saved_model_scope) generic_utils) tf_export) keras_exportceZdZdZdZdS)Configc ||_dSN)config)selfr s d/var/www/html/movieo_spanner_bot/venv/lib/python3.11/site-packages/keras/saving/serialization_lib.py__init__zConfig.__init__)s  c*t|jSr )serialize_keras_objectr rs r serializezConfig.serialize,s%dk222rN)__name__ __module__ __qualname__rrrrr r (s233333rr c&eZdZdZddZdZdZdS) SafeModeScopezBScope to propagate safe mode flag to nested deserialization calls.Tc||_dSr ) safe_mode)rrs rrzSafeModeScope.__init__3s "rcNt|_|jt_dSr ) in_safe_modeoriginal_valuer SAFE_MODErs r __enter__zSafeModeScope.__enter__6s*nn"n rc(|jt_dSr )r r!rrargskwargss r__exit__zSafeModeScope.__exit__:s"1 rN)T)rrr__doc__rr"r'rrrrr0sLLL####---22222rrz0keras.__internal__.enable_unsafe_deserializationcdt_dS)zADisables safe mode globally, allowing deserialization of lambdas.FN)r!rrrrenable_unsafe_deserializationr*>s Irc.ttddS)Nr)getattrr!rrrrrDs 9k4 0 00rceZdZdZdZdZdS)ObjectSharingScopez?Scope to enable detection and reuse of previously seen objects.cNdt_it_it_dSNTSHARED_OBJECTSenabled id_to_obj_mapid_to_config_maprs rr"zObjectSharingScope.__enter__Ks !%')$*,'''rcNdt_it_it_dS)NFr1r$s rr'zObjectSharingScope.__exit__Ps !&')$*,'''rN)rrrr(r"r'rrrr.r.Hs8II--- -----rr.crttddr tj|dSdS)z:Retrieve an object previously seen during deserialization.r3FN)r,r2r4get)obj_ids rget_shared_objectr:Vs9~y%00>+//===>>rcttddsdStt|}|tjvr|tj|<dS||d<tj|}||d<dS)z>Call after serializing an object, to keep track of its config.r3FNshared_object_id)r,r2intidr5)objr r9 prev_configs r!record_object_after_serializationrA\sv >9e 4 4 C\\F ^44428'///%+!"$5f= *0 &'''rcTttddsdS|tj|<dS)zFCall after deserializing an object, to keep track of it in the future.r3FN)r,r2r4)r?r9s r#record_object_after_deserializationrCis. >9e 4 4+.N (((rcvtjjrt rt j|S||St|tr|St|ttfr d|DSt|trt|St|trdd|didSt|tjr|St|tjr6d||jjddSt-|jt0jkrRt|t0jr$d ||jjddS|St|tjr|jSt|t:jrO|jd krDt?j d tCj"|d ddtGj$|idSt|tj%rN|&}ttOd|}d|j(j|j(j|ddStSj*|j(d}|t|t:jr|j}n |j(j}|j(j}|dkrd}nt|t:jrtWj,|}nVtWj,|j(}n<|-d}d.|dd}|d}d}||t_||d}ta|dr(|1}|t||d<ta|dr(|2} | t| |d<tg|||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()`. Nc,g|]}t|Srr).0xs r z*serialize_keras_object..s!777a&q))777r __bytes__valueutf-8) class_namer __tensor__)rKdtype __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|n"t|tjr|jn|Sr ) isinstancetf TensorShapeas_listDTypenamerHs rz(serialize_keras_object..sBa00@!))+++ *1bh 7 7>affQr __typespec__)rM spec_namemoduler registered_namekeras)api_namebuiltins.)r_rMr r`get_build_config build_configget_compile_configcompile_config)4rV __internal__tf2r3rlegacy_serializationrrU PLAIN_TYPESlisttupledictserialize_dictbytesdecoderWrXTensornumpytolistrOrZtypernprndarrayitemrYtypes FunctionTypewarningswarninspect getsourcer func_dumpTypeSpec _serializemap __class__rget_canonical_name_for_symbolrget_registered_namesplitjoin_get_class_or_fn_confighasattrrfrhrA) r? ts_configkeras_api_namer_rMr`partsr rgris rrrpsz$ ?  & & ( (@,C,E,E@#:3??? { #{## #e}%%87737777#t#c"""#u % 7 3 34   #r~&&{{}}#ry!! &++--    Cyyr{** c2: & & ) ZZ\\ Y^ 88:: #rx  x#u)** s|z/I/I  O 7>6G6L6L  O O     '055   #r{## NN$$  @@     )/m.#    < N c5- . . .^FF]-F]+ Z  "OO#u122 "5"I#"N"N"5"IM## $$S))%*%%2Y  )#..* F s&''B++--  #%3L%A%AF> "s())F//11  %'5n'E'EF# $%c6222 MrcDt|tjr|jSt |drM|}t|t std|d|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: zCannot serialize object z of type zG. To be serializable, a class must implement the `get_config()` method.) rUr{r|rrrrp TypeErrorrqrw)r?r s rrrs#u)**|sL!!  !!&$'' 111(.11 f%%% @s @ @T#YY @ @ @   rc>d|DS)Nc4i|]\}}|t|SrrF)rGkeyrKs r z"serialize_dict..s' M M M:3C'.. M M Mr)items)r?s rrqrqs M M M M MMrTc t}||n|dd}pitjjrt rtj||S|dSt|tr4t|tr ||S|St|ttfrfd|DSt|tst!d|d|vsd|vr!fd|DS|d}|d}|dkr"tj|d |d  S|d kr"t'j|d |d  S|dd kr|d dS|ddkr+rt-dt/j|d S|ddkrZt3|d|d|dd|}t5d|}|t|S| dd} | d|} |dkr|} t3| | | d|Sd|vrt9|d}||St3|| | d|} t;| dst!d|d|t=j} tA}| 5|5| !|}| dd}|r|"|| dd}|r|#|dddn #1swxYwYdddn #1swxYwYd|vrtI||d|S)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 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.utils.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 defaults to 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.utils.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_objectsc4g|]}t|S)custom_objectsrdeserialize_keras_object)rGrHrrs rrIz,deserialize_keras_object..sA    %.I      rzCould not parse config: rMr c<i|]\}}|t|Srr)rGrrKrrs rrz,deserialize_keras_object..sH   U )n    rrNrKrO)rOrPrJrLrSaRequested 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.r]r^r`r_class)obj_type full_configrct|trtj|n=t tjt |rtt|n|Sr )rUrnrVrWrdtypesstrr,r[s rr\z*deserialize_keras_object..sO!T""GbnQ'''$+BIs1vv$>$>E'"a...Arfunctionr< from_configz&Unable to reconstruct an instance of 'zM' because the class is missing a `from_config()` method. Full object config: rgri)%rpoprVrjrkr3rrlrrUrmrr8rnrorprrconstantrxarrayencode ValueErrorr func_load_retrieve_class_or_fnr _deserializer:rrcustom_object_scoperrbuild_from_configcompile_from_configrC)r rrr&safe_scope_argrrM inner_configr?r_r`fn_nameclscustom_obj_scopesafe_mode_scopeinstancergris `` rrrsgJ"^^N"0"<)IZZ 0$77N#)rN ?  & & ( ( ,C,E,E #< NN   ~t&+&& fc " " *~'9'9&'A'A'M"&) ) &4-((           fd # #=;6;;<<<6!!XV%;%;     %llnn      %J(#L\!!{<0 W8MNNNN[  x W-\'5JKKKK l{**G$++G444 l|++  K &|G'<=== l~--# ;  $ % 8 )     G G    l 3 3444 ZZ$ ' 'Fjj!2J??OZ$   )     V##'9 :;; ?J %    C 3 & &  ,Z , ,#) , ,   +>~NN#I..O 99?99??<00zz.$77  5  & &| 4 4 4$4d;;  9  ( ( 8 8 8999999999999999999999999999999V##+ f/0    Os7)N?,A0N( N?(N, ,N?/N, 0N??OOc tj||}||S|r|dks|drtj|dz|z}||S t j|}n)#t$rtd|d|d|d|wxYwt| |d}||Std |d|d |) N)rrazkeras.rdzCould not deserialize z 'z' because its parent module z) cannot be imported. Full object config: zCould not locate zo'. Make sure custom classes are decorated with `@keras.utils.register_keras_serializable`. Full object config: ) rget_registered_object startswithrget_symbol_from_name importlib import_moduleModuleNotFoundErrorrvarsr8) rZr`r_rrr custom_objr?mods rrrsW %:J  W   1 1( ; ; 0#1DEEC  )&11CC"   555T55%+55'255   3iimmD$'' ?J  -H - - - - + - -  s A,,&Br0r ).r(rr threadingr{r}rurxtensorflow.compat.v2compatv2rV keras.savingrkeras.saving.legacyrrl%keras.saving.legacy.saved_model.utilsr keras.utilsrtensorflow.python.utilr tensorflow.python.util.tf_exportrrr=floatboolrmlocalr2r!r rr*rr.r:rArCrrrqrrrrrrsT=< !!!!!!!!!,,,,,,EEEEEEIIIIII%%%%%%-,,,,,999999C%  "" IO   33333333 2 2 2 2 2 2 2 2@AA  BA 111 - - - - - - - ->>> 1 1 1///IIIX   ,NNN ,0llll`JN((((((r