6bivSrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ s J r SSK J r SSKJr SSKJr SSKJr SSKJr SSKJr \\\\4r\R<"5r\R<"5r S r!S r""S S 5r#"S S5r$\"S5S5r%Sr&"SS5r'Sr(Sr)Sr*\"SS5S5r+Sr,S#Sjr-S#Sjr.Sr/Sr0\"SS 5S$S!j5r1S#S"jr2g)%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 regularizersc \rSrSrSrSrSrg)Config6c XlgNconfig)selfrs _/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/saving/serialization_lib.py__init__Config.__init__7s c,[UR5$r)serialize_keras_objectrrs r serializeConfig.serialize:s%dkk22rrN)__name__ __module__ __qualname____firstlineno__rr__static_attributes__rrrr6s 3rrc.\rSrSrSrSSjrSrSrSrg) SafeModeScope>zBScope to propagate safe mode flag to nested deserialization calls.cXlgr) safe_mode)rr+s rrSafeModeScope.__init__As"rcL[5UlUR[lgr) in_safe_modeoriginal_valuer+ SAFE_MODErs r __enter__SafeModeScope.__enter__Ds*n"nn rc.UR[lgr)r/r0r+rargskwargss r__exit__SafeModeScope.__exit__Hs"11 r)r/r+N)T) r!r"r#r$__doc__rr1r7r%r&rrr(r(>sL#-2rr(z0keras.__internal__.enable_unsafe_deserializationcS[lg)zADisables safe mode globally, allowing deserialization of lambdas.FN)r0r+r&rrenable_unsafe_deserializationr;Ls  Irc$[[SS5$)Nr+)getattrr0r&rrr.r.Rs 9k4 00rc$\rSrSrSrSrSrSrg)ObjectSharingScopeVz?Scope to enable detection and reuse of previously seen objects.cFS[l0[l0[lgNTSHARED_OBJECTSenabled id_to_obj_mapid_to_config_maprs rr1ObjectSharingScope.__enter__Ys!%')$*,'rcFS[l0[l0[lg)NFrCr4s rr7ObjectSharingScope.__exit__^s!&')$*,'rr&N)r!r"r#r$r9r1r7r%r&rrr?r?VsI- -rr?cp[[SS5(a [RRUS5$g)z:Retrieve an object previously seen during deserialization.rEFN)r=rDrFget)obj_ids rget_shared_objectrNds/~y%00++//==1rcUSS:XaSUS'[[SS5(dg[[U55nU[R;aU[RU'gX!S'[RUnX#S'g)z>Call after serializing an object, to keep track of its config.module__main__NrEFshared_object_id)r=rDintidrG)objrrM prev_configs r!record_object_after_serializationrWjsx h:%x >9e 4 4 C\F ^44428''/%+!"$55f= *0&'rcX[[SS5(dgU[RU'g)zFCall after deserializing an object, to keep track of it in the future.rEFN)r=rDrF)rUrMs r#record_object_after_deserializationrYys$ >9e 4 4+.N  (rz#keras.saving.serialize_keras_objectz"keras.utils.serialize_keras_objectc ^ [RRR5(a[ 5(a[ R "U5$UcU$[U[5(aU$[U[[45(a=UVs/sHn[ U5PM nn[U[5(a [U5$U$[U[5(a [U5$[U[5(aSSURS50S.$[U[R5(aUR bUR#5$S$[U[R$5(a8SUR'5R)5UR*R,S.S.$[/U5R0[2R4:Xai[U[2R65(a:UR8S:a*S UR)5UR*R,S.S.$UR;5$[U[R<5(a UR,$[U[R>R@RB5(a URD$[U[FRH5(aWUR4S :XaG[JRL"S [NRP"U53S S 9 SS[RRT"U50S.$[U[RV5(aURY5n[[[SU55nUR\R4nSn[_US5(aT[R`RbReU5n[U5n[fRh"UR\5nSUUR\R0UUS.$[kU5n[mUR\U5m [U[n5(aUS:XaU$T b:[qU 4Sj[r55(aU$[uUT 5 [wUT 5 T $[U[FRH5(a UR0nOUR\R0nUR\R4nUS:XaSnOV[U[FRH5(a[fRh"U5nO [fRh"UR\5nUUUUS.n [uX 5 [wX 5 U $s snf)aRetrieve 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__)r\dtyper __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__c[U[R5(aUR5$[U[R5(a UR $U$r) isinstancetf TensorShapeas_listDTypenamexs r(serialize_keras_object..sJa00))+@ *1bhh 7 7aff@=>@r_tf_extension_type_fields __typespec__)r^ spec_namerPrregistered_nameop_dispatch_handlerc34># UH nUTS;v M g7f)rPNr&).0modconfig_with_public_classs r )serialize_keras_object..s# 5 +H5 55sbuiltinsrPr^rrs)6G6G6L5M  O  '005  #r{{##NN$  @   MM**  33 4 466>>sCI&y1I1EE O)"mm...   +3/L: | ,$$9N)N +  5   J$S*BC)#/GH''#u))**))''J  c5-- . .1EEcJO1EE O  * F !-%c2 MC>sUc[US5(a!UR5nUb[U5US'[US5(a!UR5nUb[U5US'g)Nget_build_config build_configget_compile_configcompile_config)rrrr)rUrrrs rrr#shs&''++-  #%3L%AF> "s())//1  %'5n'EF# $ rc[R"USS9nUc5[R"U5nUcgURUR UUS.$UR S5nSRUSS5USUSS.$)zSerializes 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_nameNr|.)rget_canonical_name_for_symbolrrr"r!splitjoin)clsrkeras_api_namerspartss rrr/s<< gN -AA#F  "nn,,".      %E((5":&Bi  rc(U(aUSUUS.$[R"USS9nU(a*URS5nSRUSS5SUUS.$[R "U5nU(dUR S:XdgUR SUUS.$) aASerializes 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. functionr|rrrNrr{)rrrrrrr")fnrfn_module_namerrrss rserialize_with_public_fnrSs$$%   << WN$$S)hhuSbz*$%   .AA"Er}} 'Bmm$.   rc[U[R5(a UR$[ US5(aAUR 5n[U[ 5(d[SUSU35e[U5$[ US5(a[R"U5$[SUS[U5S35e)z1Return the object's config depending on its type. get_configzThe `get_config()` method of z$ should return a dict. It returned: r!zCannot serialize object z of type zG. To be serializable, a class must implement the `get_config()` method.) rfrrr!rrr TypeErrorrrrr)rUrs rrrys#u))**||sL!!!&$''/u5((.x1 f%% j ! !"66s;;&se9T#YK@@ @  rclUR5VVs0sHupU[U5_M snn$s snnfr)itemsr)rUkeyr\s rrrs-AD M:3C'. . MM Ms0z%keras.saving.deserialize_keras_objectz$keras.utils.deserialize_keras_objectc [5nUbUOUnURSS5nU=(d 0n[RRn[R n0UEUEUEnURSS5nU(a%[ S[UR5535e[RRR5(a[5(a[R"XX5$Ucg[!U["5(aU(aUR%U5bX$[!U[[&45(aUV s/sH n [XUS9PM sn $UGb$Supn [!U[(5(aSU;aUSn S U;a[ S U35eU(a;US U;d/UR%S 5U;d[!U ["5(aX;aS n OPUS S :XaUSn U S:XaUSnO6US nO0UR%SS5c[+SUS SUS S35eUS nU (dRX;aU$[!XP[,R.5(a[[1XPX 5US9$[[3XPU S9US9$[!U[45(aU$[!U[(5(d[+SU35eS U;dSU;a.UR75V Vs0sHupU [XUS9_M snn $US nUS=(d 0n U=(d 0nUS:Xa[R8"U SU SS9$US:Xa[:R<"U SU SS9$US S:XaU SR?S5$US S:Xa+U(a [ S5e[@RB"U S5$US S :Xa[EUS!US USS"UUS#9n[GUS$5(a5U R75V Vs0sHupU [XUS9_M n n nU"S,0U D6$US bURIU 5$[KS%U 5n URM['U 55$UR%SS5nUR%S U5nUS :XaU n[EUUUS UUS#9$S&U;a[OUS&5nUbU$[EUUUS"UUS#9n[!U[,R.5(aU$[GUS'5(d[+S(US)U35e[RP"U5n[SU5nU U URIU 5nUR%S*S5nU(aURUU5 UR%S+S5nU(aURWU5 SSS5 SSS5 S&U;a[YWUS&5 W$s sn fs snn fs snn f!,(df  N>=f!,(df  NG=f)-a_ Retrieve 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+)NNFrr^z%Unknown `config` as a `dict`, config=rsTrrPr{_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: r_r\r`)r`rar[r]rdaRequested 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.rqrrclass)obj_type full_configrrpc[U[5(a[R"U5$[ [R [ U55(a[[U5$U$r)rfrrgrhrdtypesrr=rls rrn*deserialize_keras_object..sO!T""nnQ'G$+BIIs1v$>$>'"a.GDEGrrR 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 ValueErrorrkeysrgr}r~rErrdeserialize_keras_objectrfrrLrrrrrrrrrconstantrarrayencoder func_load_retrieve_class_or_fnrrr _deserializerNcustom_object_scoper(build_from_configcompile_from_configrY)rrr+r6safe_scope_argrtlcogcorrmrrhas_custom_objectrr\r^rrPrsfn_namerUcustom_obj_scopesafe_mode_scopeinstancerrs rrrsR"^N"0"<)IZZ 0$7N#)rN  ; ; D DD  4 4C66$6#6N#JJ'>I  ;FKKM"# %   ??   & & ( (,C,E,E#<< N  ~ 63    v & 2%%&4-((    %I    !:K7 &7 fd # #6!%h/ 6) ;F8D |$6::/0NB|S11$6%)! %3!'!1!Z/#H-F#$56F::h,4#"<012"<012%% - + .0%2D2DEE/,&.$2  ,+"* .  &+&& fd # #26(;<<6!XV%; %lln  -  )  -    %J(#)rL#)rN\!{{<0 W8MNN[ xx W-\'5JKK l{*G$++G44 l|+ K &&|G'<== l~-# ;  $ % 8 )   33 4 4 #/"4"4"6 #7JC-I#7  && & # $ 0??<0 0 G   l 344ZZ$ 'Fjj!2J?OZ$   )   V#'9 :; ?J %  C#u))** 3 & &4ZLA##)( ,  +>>~N#I.O ???<0zz.$7   & &| 4$4d;   ( ( 8+ V#+ f/0  O R R@+?  s7V&V+/V1WA&V7?W7 W W Wc US:Xa[R"XS9nO[R"XS9nUbU$U(GaUS:Xd2US:Xd,URS5(dURS5(a.US-U-nSU;aS U-n[R"U5nUbU$US:XaUS :Xa[ H)n [R"SU -S-U-5nUcM'Us $ UR 5V V s0sH"upU RUS 5(dM X_M$ n n n U (a"[[U R555$URS5(aS U-n[R"U5n [U 5R!US5nUcrUb[U 5R!US5nUR#S5S:Xa?UR%S5up[U 5R!U S5nUb ['XS5OSnUbU$[SUSUSU35es sn n f![a [S USUSUSU35ef=f)Nrrtf_kerasrzkeras.z tf_keras.rz__internal__.legacyz compat.v1.r{rtf_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_MODULESrendswithnextitervalues importlib import_moduleModuleNotFoundErrorrvarsrLcountrr=)rkrsrPrrr custom_objrrUrwkv filtered_dict outer_name inner_name outer_objs rrrs :(>>  )>>   j    **  --|d*H%0'(200:C z !f &:&44sNS(4/?J '+0022DA::k(342  D!5!5!7899   ))))&1C3immD$' ;*3immOT:zz#!#)-C&  IMM*d; !,I48 ?J  H:Rv. +m - S# ( "TF;%%+H-''2m5  s5H%H% 1H++"I rrB)3r9rr threadingrrrrtensorflow.compat.v2rv2rgtf_keras.src.savingrtf_keras.src.saving.legacyrr,tf_keras.src.saving.legacy.saved_model.utilsrtf_keras.src.utilsrtensorflow.python.utilr tensorflow.python.util.tf_exportrrrSfloatboolrlocalrDr0rrrr(r;r.r?rNrWrYrrrrrrrrr&rrrs+= !!3LP,-9C% " OO  "L33 2 2@A B 1 - -> 1/)+O]]@  !H# L 0N+* ,0J J\ JNar