BVhPdZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z ddl m Z ddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z#ddl$m%Z&ddl$m'Z'ddl$m(Z(ddl$m)Z)ddl*m+Z+ddl*m,Z,ddl*m"Z-ddl*m.Z.ddl*m/Z/ddl*m0Z0ddl*m1Z1ddl2m3Z3dd l4m5Z5dd!l4m6Z6dd"l4m7Z7dd#l8m9Z9dd$l8m:Z:dd%l8m;Z;dd&l8mZ>dd)l8m?Z?dd*l8m@Z@dd+l8mAZAdd,l8mBZBdd-l8mCZCdd.l8mDZDdd/l8mEZEdd0l8mFZFdd1l8mGZGdd2lHmIZIdd3lHmJZJdd4lKmLZLdd5lKmMZMdd6lKmNZNdd7lKmOZOdd8lPmQZQdd9lRmSZTdd:lUmVZVdd;lUmWZWddd?d@gZ_dAZ`dBZaGdCdDejZcGdEdFedZedGeWjdHeWjfdIZgdJZhdKeidLeifdMZj d|dNe edKeidOekfdPZl d|dQemeiedReffdSeWjfdTZnejdUgdVZodWeodXe7jfdYZqdZedReffd[ZrdZedRefd\e_d]e e/jedRefffd^Ztd_e/jd`eefdaZudbejdHdfdcZw d|dbejd`eedQe eiedReffdde eideexdfexdgexdHe eoe/jffdhZydiejfdjZ{d`eefdkZ|d`eefdlZ}dmejfdnZdoe/jdpeifdqZeZdrdrdsgt d}dpeidueAjfdvZ d~dueAjfdwZ d}dxeidueAjfdyZ d|dueAjfdzZ d|dueAjdbejfd{Zy)z4Exports a SavedModel from a Trackable Python object.N)AnyCallableDictListTuple)logging) function_pb2) graph_pb2) node_def_pb2) versions_pb2)meta_graph_pb2)saved_model_pb2)saved_object_graph_pb2) checkpoint)checkpoint_options)functional_saver) graph_view) save_util_v1)util)context) def_function)function)concrete_function)polymorphic_function)saved_model_exported_concrete)saved_model_utils)dtypes)errors) meta_graph)ops) tensor_util)versions)file_io) array_ops)control_flow_ops)resource_variable_ops) builder_impl)fingerprinting_utils)function_serialization) path_helpers)pywrap_saved_model) registration) revived_types) save_context) save_options)signature_constants)signature_def_utils)signature_serialization) tag_constants) tracing_utils) utils_impl) constants)metrics)asset)base)resource)trackable_utils)trace_saveable_util)core)compat)object_identity)tf_stack) tf_export_CapturedTensornamersave_v2ceZdZdZfdZdej deede fede fffdZ fdZ fdZ d e fd Zd ej fd Zd ZxZS)_AugmentedGraphViewaAn extendable graph which also tracks functions attached to objects. Extensions through `add_object` appear in the object graph and any checkpoints generated from it, even if they are not dependencies of the node they were attached to in the saving program. For example a `.signatures` attribute is added to exported SavedModel root objects without modifying the root object itself. Also tracks functions attached to objects in the graph, through the caching `_list_functions` method. Enumerating functions only through this method ensures that we get a consistent view of functions, even if object attributes create new functions every time they are accessed. ctt| |tj|_tj|_i|_g|_yN) superrG__init__r?ObjectIdentityDictionary_children_cache_serialization_cache_wrapped_functionsuntraced_functions)selfroot __class__s R/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/saved_model/save.pyrKz_AugmentedGraphView.__init__ssK t-d3+CCED!0 H H JD!D D signature_mapwrapped_functions.c|j|jtj}||j|j|<|j j |y)a9Attach signature to the root object. Args: signature_map: An object that contains signature functions. wrapped_functions: A dictionary mapping functions to functions that are guaranteed to not capture cached variables (functions that capture cached variables can't be saved). N) list_childrenrRr2SIGNATURE_ATTRIBUTE_NAMErMrOupdate)rQrVrWrCs rT set_signaturez!_AugmentedGraphView.set_signaturesO tyy! " ; ;D,9D#D)""#45rUc`tt| \}}tjtj|D]U}t |t jr||j<t |tjsG||j<Wfd}t|jjD]W}|||ur|j|=|j|jD]\}}|||j||<Ytt| S)z6Returns all trackable objects in the SavedObjectGraph.ct|tjr|jSt|tj r,|j vr|j S|j S|SrI) isinstancer8Asset asset_pathrTrackableConstantcapture)x asset_pathsconstant_capturess rT_get_merged_trackablezK_AugmentedGraphView._breadth_first_traversal.._get_merged_trackables` Au{{ #1<<(( A(:: ; 99 #QYY' '"199- - hrU)rJrG_breadth_first_traversalr?rLr_r8r`rarrbrclistrMkeysitems) rQtrackable_objects_objrgrCchildrerfrSs @@rTrhz,_AugmentedGraphView._breadth_first_traversals' !4ACq"::%  C.. / &&sxx0++C06681 e  # #D% 001sDDrCc&|j||SrI)rM)rQrnrCs rT get_childz_AugmentedGraphView.get_childs    $T **rUrc||jvr|j|S|jD]E}t|ds||jvstj|x}|j|<|cS|S)N_cached_variable)rOcaptured_inputshasattrr)wrap_cached_variables)rQrrcwrappeds rTrwz4_AugmentedGraphView._maybe_uncache_variable_capturessD333  $ $%6 77$44 , - D$;$; ;$::;LM 'D++,=>.  rUc#K||jvri}n|j|}|j|jD]@\}}t|tj st dt|d|d||fByw)aYields `Trackables` that must be loaded before `obj`. Dependencies and children are both dictionaries of `Trackables`. Children define the object graph structure (used in both checkpoints and SavedModel), while dependency defines the order used to load the SavedModel Args: obj: A `Trackable` object Yields: Tuple of dependency names and trackable objects. Raises: TypeError: if any of the returned dependencies are not instances of `Trackable`. zThe dependency of type z is not an instance `Trackable`, and can't be saved to SavedModel. Please check the implementation of `_deserialization_dependencies` in the parent object .N)rM_deserialization_dependenciesrkr_r9 Trackable TypeErrortype)rQrnr{rCdeps rTlist_dependenciesz%_AugmentedGraphView.list_dependenciess" $&&&h%%c*h66x@FFH c T^^ ,%d3i[1U!   #IosBB)__name__ __module__ __qualname____doc__rKr2 _SignatureMaprrrr\rhrYstrr}cfrvrwr __classcell__)rSs@rTrGrGdsv ! 6,::6hsCx0(382DDE6&!GF1(++ !22 rUrGceZdZdZdedej fdZdZdZ e dZ e dZ d e jfd Zd Zd Zd Zy) _SaveableViewaProvides a frozen view over a trackable root. This class helps to create a single stable view over an object to save. The saving code should access properties and functions via this class and not via the original object as there are cases where an object construct their trackable attributes and functions dynamically per call and will yield different objects if invoked more than once. Changes to the graph, for example adding objects, must happen in `augmented_graph_view` (an `_AugmentedGraphView`) before the `_SaveableView` is constructed. Changes after the `_SaveableView` has been constructed will be ignored. augmented_graph_viewoptionsc ||_||_tj|j\|_|_|_|_|_|jj}|rNtjddj|dtttt|t||j!|j#t%j&|_y)zInitializes a SaveableView. Args: augmented_graph_view: A GraphView object. options: A SaveOptions instance. zFound untraced functions such as %s while saving (showing %d of %d). These functions will not be directly callable after loading.z, N)rrcheckpoint_util(objects_ids_and_slot_variables_and_paths_trackable_objects node_pathsnode_ids_slot_variables object_namesrPrinfojoin_NUM_DISPLAY_UNTRACED_FUNCTIONSminlen&_initialize_save_and_restore_functions(_initialize_nodes_and_concrete_functionsr?rLcaptured_tensor_node_ids)rQrrrPs rTrKz_SaveableView.__init__ s!5DDL  A A  & & (.Tdot} 4,22EE ll J ))&'G(GH I -s3E/F G  ! # //1113$3$L$L$ND!rUctj|j\}}tj|_|j D])\}}|jD]}||j |<+t||_ y)aGenerates all checkpoint save/restore functions. The save and restore functions are generated in the eager context (or in the user's Graph/Session) before being copied to the exported GraphDef. These functions record the ops for saving/restoring the entire object or individual objects (e.g. variables and hash tables). The global save and restore functions are generated for compatibility with TF1 and loading from C++, and is saved in the `MetaGraphDef.saver_def`. The individual functions are generated for the Python TF2 use case, where users use the loaded SavedModel as-is, or compose new models using parts of the object loaded from the SavedModel. These functions are recorded in the `saveable_objects` map in the `SavedObject` proto. N) r!get_checkpoint_factories_and_keysrr?rL_obj_to_registered_saverrkvalues_gen_save_and_restore_functions_saveable_objects_map)rQcheckpoint_factory_mapregistered_savers saver_name trackables trackables rTrz4_SaveableView._initialize_save_and_restore_functions.s" 66t7H7HI.-$3$L$L$ND!"3"9"9";> J!((*>)3=%%i0>> ((>? rUcPt|j|_g|_g|_|jD]}||j vs|j |j D]\}}t|j|j|<|jj|t|j|j|<|jj||jDcgc]}t|tjs|!c}|_ ycc}w)zCreates graph with nodes for trackable objects and functions. Adds functions for each trackable object to `self.nodes` and associated concrete functions to `self.concrete_functions` for serialization. N)rirnodesgradient_functions gradient_defsrrrrryr_rurvconcrete_functions)rQrnsave_fn restore_fns rTrz6_SaveableView._initialize_nodes_and_concrete_functionsGs d--.DJ DDzz( ** *#'#=#=c#B#I#I#K ( GZ#&tzz?$-- **  G $&)$**o$-- # **  J '  ((zzZU5K5K%LDs 6D#D#c4|j|jzSrI)rrrQs rTconcrete_and_gradient_functionsz-_SaveableView.concrete_and_gradient_functions^s  " "T%<%< <Objects can't have both SaveableObjects and a registered saverN) enumeraterraddslot_variablesextendrgetr_rBrrYr{refnode_idrC local_namer dependenciesrrrksaveable_objects save_functionrestore_functionregistered_saver) rQrrnode object_protoro child_protorCrrrrsaveable_object_protos rTfill_object_graph_protoz%_SaveableView.fill_object_graph_protofs#4::.L  ]]4 G ++ +[[__&l!!(()=)=)A)A$)KL D/ *,,::4@,%"++//1 "mmEII6 !& ,00BB4H&)$"//335 "mmC0 !% & ++ +4888 N L N8  & &t , 2 2 4 M -J-*"."?"? "K 04 g0F  -37==3L  0  M 400 0(,(E(Ed(K %5LrUctjrJtj}tj}t gtjii}t |D]|}|j |}|j|||j}t|tjrt||||j|sg|D]}||j|<~|||fS)a?Makes new resource handle ops corresponding to existing resource tensors. Creates resource handle ops in the current default graph, whereas `accessible_objects` will be from an eager context. Resource mapping adds resource handle ops to the main GraphDef of a SavedModel, which allows the C++ loader API to interact with resources. Returns: A tuple of (object_map, tensor_map, asset_info): object_map: A dictionary mapping from object in `accessible_objects` to replacement objects created to hold the new resource tensors. tensor_map: A dictionary mapping from resource tensors extracted from `accessible_objects` to newly created resource tensors. asset_info: An _AssetInfo tuple describing external assets referenced from accessible_objects.  asset_defsasset_initializers_by_resourceasset_filename_map asset_index) object_map tensor_mapr)rexecuting_eagerlyr?rL _AssetInfo_dependency_sorted_node_idsr_export_to_saved_model_graphrr_r8r`_add_asset_inforar)rQrr asset_inforrntensorstensors rT map_resourcesz_SaveableView.map_resourcess$((** *!99;J 99;J'6'O'O'Q J /t4 : JJw c00J 1g C %ZCNN)CD  :F29$ ' ' / : : z: --rUct|j}|jj|||j|<||j|<||j|<|SrI)rrryrr)rQrcrrs rTadd_capture_and_nodez"_SaveableView.add_capture_and_nodesR$**oGJJd$DMM'!DMM$-4D!!'* NrUcg}|jD]V}t|tjs|j |j j |djX|S)N _initialize)rr_r:CapturableResourceryrr}get_concrete_function)rQconcrete_initializersrns rT"get_concrete_resource_initializersz0_SaveableView.get_concrete_resource_initializerssczz= C44 5$$  % % / /] $$9$9$; == ! rUN)rrrrrGr/ SaveOptionsrKrrpropertyrrRrSavedObjectGraphrrrrrrUrTrrs O/O''OBA2. = =  L)::L@(.T!rUrrreturncrtj}|jD]\}}tj|s|s|dj t jk(r9t|dk(sJt jtj|i||<wtj||||<|S)aGenerates global and individual save/restore concrete functions. The global functions records the ops to save and restore the entire object to a file prefix, while the individual functions save and restore value tensors for resources. This function is intended to run on the output of `save_util_v1.get_checkpoint_factories_and_keys(object_names)`, which returns the generated a map of `_CheckpointFactoryData`. Args: checkpoint_factory_map: A dictionary mapping trackable objects to a list of `_CheckpointFactoryData`. Returns: Tuple of ( saveable_fn_map: Maps obj -> factory name -> (concrete save, restore) ) r) r?rLrkr&is_resource_variablerCr;SERIALIZE_TO_TENSORS_NAMErr4trace_save_and_restorer<trace_save_restore_function_map)rsaveable_fn_maprnfactory_data_lists rTrrs0$<<>/ 6 < < >'c 11#6>O  O$M$MM " #q (( (-GG  . .s 36oc  = =$ &c' rUc||jDcic]\}}|tj|c}}Scc}}wrI)rkr5build_tensor_info_internal) tensor_dictkeyvalues rT_tensor_dict_to_tensorinforsA$))+  #u : 0 0 77  s 8 signature_keyuser_input_namecdj||}tjd|r|Stjdd|}tjdd|S)awCreates a sanitized name scope from user signature and input names. Concatenates signature and input names, sanitizing as needed to be a valid scope name. Args: signature_key: The user-provided key for the signature. user_input_name: The user-provided name for the input placeholder. Returns: A name scope that is safe to be used in tf.name_scope(). z{}_{}z^[A-Za-z0-9.][A-Za-z0-9_.\\-]*$z^[^A-Za-z0-9.]*z[^A-Za-z0-9_.\\-]rm)formatrematchsub)rr name_scopeinvalid_prefix_strippeds rT_to_safe_name_scopersR~~m_=*XX0*= FF#5r:F $c+B CCrUfunction_arguments function_namec i}g}|D]2}tj|jjd}||jjk7r(t d|dtj|d|d|j |ij |}|Qtj|j|jt||} | ||<|j| tj|j|jt||} | ||<|j| 5||fS)aCreates exterior placeholders in the exported graph for function arguments. Functions have two types of inputs: tensors captured from the outside (eager) context, and arguments to the function which we expect to receive from the user at each call. `_map_captures_to_created_tensors` replaces captured tensors with stand-ins (typically these are resource dtype tensors associated with variables). `_map_function_inputs_to_created_inputs` runs over every argument, creating a new placeholder for each which will belong to the exported graph rather than the function body. Args: function_arguments: A list of argument placeholders in the function body. signature_key: The name of the signature being exported, for error messages. function_name: The name of the function, for error messages. defaults: A dictionary mapping signature_key to dictionary of user_specified_name to Tensor representing default values. Returns: A tuple of (mapped_inputs, exterior_placeholders) mapped_inputs: A list with entries corresponding to `function_arguments` containing all of the inputs of the function gathered from the exported graph (both captured resources and arguments). exterior_argument_placeholders: A dictionary mapping from argument names to placeholders in the exported graph, containing the explicit arguments to the function which a user is expected to provide. Raises: ValueError: If argument names are not unique. _user_specified_namezAGot non-flat/non-unique argument names for SavedModel signature 'z': more than one argument to 'z ' was named 'a%'. Signatures have one Tensor per named input, so to have predictable names Python functions used to generate these signatures should avoid *args and Tensors in nested structures unless unique names are specified for each. Use tf.TensorSpec(..., name=...) to provide a name for a Tensor input.)inputshaperC)rdtyperC)r> as_str_anyopget_attrrC ValueErrorrr$placeholder_with_defaultnumpyrrry placeholderr) r rr defaultsexterior_argument_placeholders mapped_inputsrr default_valuerarg_placeholders rT)_map_function_arguments_to_created_inputsr sdR$& -'(,k'' 679O+..---  _ . /0    LL377HM !*!C!C##%!!"=/B" 9Q$_534!--!!!!"=/Bo 9H$_5?+Q(,R 6 66rUsignature_functions.rc i}t|jD]6\}}|jjr8|jjdt |jj }n|jj}t |||j|\}}tt||jjdj} ||dit| |D cic]\} } | |  c} } } tjt|t| t j"|j%|d||<9|Scc} } w)aValidates and calls `signature_functions` in the exported graph. Args: signature_functions: A dictionary mapping string keys to concrete TensorFlow functions (e.g. from `signature_serialization.canonicalize_signatures`) which will be used to generate SignatureDefs. object_map: A dictionary that contains mappings from signature functions to concrete functions in the exported graph. defaults: A dictionary mapping signature_key to dictionary of user_specified_name to Tensor representing default values. Returns: Each function in the `signature_functions` dictionary is called with placeholder Tensors, generating a function call operation and output Tensors. The placeholder Tensors, the function call operation, and the output Tensors from the function call are part of the default Graph. This function then returns a dictionary with the same structure as `signature_functions`, with the concrete functions replaced by SignatureDefs implicitly containing information about how to call each function from a TensorFlow 1.x Session / the C++ Loader API. These SignatureDefs reference the generated placeholders and Tensor outputs by name. The caller is expected to include the default Graph set while calling this function as a MetaGraph in a SavedModel, including the returned SignatureDefs as part of that MetaGraph. Nr) method_namerr)sortedrkgraphcapturesinputsrrrCrirstructured_input_signaturerjzipr1build_signature_defrr0PREDICT_METHOD_NAMEr) rrr signaturesrrargument_inputsrr kwarg_names kwarg_name mapped_inputoutputss rT_generate_signaturesr.`sS@*!'(;(A(A(C!DmX~~ --.LHNN4K4K0L/LMo --o1 ]HMM8 2M1  x ) ) D DQ G L L N PQK#j"(+K(G& $J  L &G!4 G G"#AB"7+';;mT2 !J}#. &s4 Errrmapped_path_variablec4|j}tj|} t|j t}t j||j}||j|<tj}||_ |jj|j_ |jj!||j"|j$|<t'|jdz |j(|<y#t $rYwxYw)z&Add `trackable_asset` to `asset_info`.)asset_filepathrrN)rar!constant_valuerastypeAttributeErrorr'get_asset_filename_to_addrr AssetFileDeffilename initial_valuerC tensor_inforry initializerrrr)trackable_assetrr/original_path_tensor original_pathpath asset_defs rTrrs )33,,-AB-  ,,S12M  / /"#66 8$)6*%))+))3AAFF) y)&& ++,@A,/ 0E0E,F,J*)   sD DDfnc#PKt|tjrB|jjD](}|j dj }|stdy|jjD]} |jd}||fy#t$rY)wxYww)zHIterates through each op in the function and returns the op type and op._gradient_op_typezUnable to save gradient functions when exporting a _DefinedFunction (generally created through graph freezing utils or through V1 graph importers). Please save with `options=tf.SaveOptions(experimental_custom_gradients=False)`N) r_ framework_fn_DefinedFunction definitionnode_defattrsrr!get_operationsr)r@rop_typers rT_iterate_op_typesrKsL112 &&M -.00g  LM MMhh%%'++12 RK s0AB&*B&=B B& B# B&"B##B&rcfunc_graph_mapc|}|t|tjs|j|jur&|j |jj }nd |jj j|}|jj|}|j |jj }|t|tjs||fS#t$rY||fSwxYw)zETries to find the original captured tensor if capture more than once.) r_r EagerTensorr!r outer_graphinternal_capturesindexrexternal_captures)r@rcrLouter_fn capture_indexs rT_get_outer_most_capturerUs (Z%I}}HNN*##HNN$>$>?h 88>>wG 00?g##HNN$>$>?h Z%I 7    7  s%C"" C10C1r! saveable_viewc t|jj}|Dcic]}t|ds|j|}}t }|D]}t |D]\}}||vr |j| tjj|} tj| jdg|j} |j+5g} | j,D]U} | j.t0vrt3|| |\}}|t5|tj6r:||j8vrt'd|d|j8||j8| <}|j|jur|j(}t5|t:j<rV |jjj?|}|j@jBjD|j(dz}tG||j(}|jI| |;| jK| j(X| s| jM|nt'd|d |d |  ddd|jNjK| | || j<tQjR}| j(|_*||_+|jXjK|ycc}w#t$rYwxYw#t $r?} t#j$t'd|j(d|j| d} ~ wwxYw#t&$rY]wxYw#1swYxYw) z?Traces gradient functions and records them in the SaveableView.r!NaNError when tracing gradients for SavedModel. Check the error log to see the error that was raised when converting a gradient function to a concrete function. You may need to update the custom gradient, or disable saving gradients with the option tf.saved_model.SaveOptions(experimental_custom_gradients=False). Problematic op name: z Gradient inputs: zFound invalid capture z when saving custom gradients.z:0zCannot save custom gradient z called in function z@ because SavedModel is unable to serialize the captured inputs: )-ri _functionsrrr!setrKrr gradient_registrylookup LookupErrorrrrr# Exception traceback print_excrrC as_defaultrr_UNCOPIABLE_DTYPESrUr_rNrruAtomicFunctionrQcached_definition signature input_argrBrry add_to_graphrr RegisteredGradient gradient_funcregistered_op_typer)r!rV functionsfrL seen_op_typesr@rJrcustom_gradientgrad_fnexc bad_capturesrcrS outer_capture capture_name arg_indexrgrad_defs rT_trace_gradient_functionsrusu5##**,-)(1I1WQ5HAGGQJI.I%- W3b(,V3  M ! //66w?% HL ! !/ 2 H H "yy "     4  ..' .G ]]0 0  %<'>% !(M M3??!KM$J$JJ*=/:-- 66}E  2 27 ;""hnn4(--L(E$8$89 $NN1177 F ..88BB!d#<?D  . .w =    -O' .P   u %,WI5I"N%(   &]4 l&&--g6&-nW]]#002h&||h$+h!!!((2mV3W3J % ) *, 1Fyyk "% % %d M4 4 sgK5K5K:$0L $C M%/AMA0M%: LL M:M  M M" M%!M" "M%%M. meta_graph_defcdtjddfddtjddfddtdtfddtdtfddtjddffd }|jjD] }|| |jj j D]}|jD] }|| y) a\An experimental function to remove debug nodes from the final graph. This function removes all Assert and CheckNumerics nodes from the meta_graph. It strips the operators in both the nodes and in all of the function defs, with the Assert ops being replaced by `NoOp`s and the CheckNumerics ops being transformed into `Identity` ops. In addition to this, it creates control inputs for the nodes that are not relevant for the op. For more information about control inputs please see go/how-tensors-flow#control-dependencies. Args: meta_graph_def: The meta_graph that will be exported. rrNc|jjDcgc]}|jds|}}|D]}|jj|ycc}w)zErases regular node attributes.rmN)rGrj startswithpop)r attributeattributes_to_removes rTerase_regular_node_attributesz9_strip_debug_nodes..erase_regular_node_attributes\sa) ##C(  *  iimmI sAcd|jvr?|jd}|jd|jdj|y|jdy)z'Prunes all attributes that are not `T`.TrGN)rG ClearFieldCopyFrom)rt_values rTprune_all_non_t_attributesz6_strip_debug_nodes..prune_all_non_t_attributesfsI dii #g oof iing& oofrUrCc|xr|ddk(S)z4Returns whether or not the input is a control input.r^rrCs rTis_control_inputz,_strip_debug_nodes..is_control_inputos  "DGsN"rUc0d|jddzS)z*Returns the input as a control dependency.r:r)splitrs rTas_control_depz*_strip_debug_nodes..as_control_depss C# ##rUcV|jdk(s|jdk(rd|_|g}|jD]3}|s|j|#|j|5|jd|jj |y |jdk(s|jdk(rld|_|t dt |jD]:}|j|r|j||j|<<y y ) aStrips the graph from Assert and CheckNumerics ops. For Assert ops, this function also rewrites all of the inputs to the nodes that were transformed by making them into control dependencies. It also removes all of the regular node attributes, that is all node attributes that do not start with `_`. For CheckNumerics ops, this function turns the op into an Identity op, which will be pruned later (according to the original implementation in grappler's `debug_stripper.cc`. Then, since Identity ops only take one input, it leaves the first input as is while transforming the other ones into control dependencies. Args: node: The node to potentally strip. AssertPrintV2NoOpr  CheckNumericsPrintIdentityrN)rr ryrrranger)r new_inputsinpirr}rrs rTmaybe_do_stripz*_strip_debug_nodes..maybe_do_stripws" ww(dgg2dg#D)j!#$   N3/ 0   C !  oog jj # O #tww''9dg &QDJJ(8! 1 .(A7$**Q-8 (:rU)r NodeDefr graph_defrlibraryrrF)rvrrfuncrr}rrs @@@@rT_strip_debug_nodesrNs,*>*>4|';';#S#S#$3$3$$8<//$8D$8$8N&&++d4&&..77d TrUnamespace_whitelistsave_custom_gradients create_saverenable_debug_stripperc~ |j}tj} g} | j5|j \} t ||} ddd|r t | || j5|D]} g}| jjD]2} jj|d}|"|j|4tj|5| }| j|ddd| j jjtj| 5tj }ddd|j"t$j&j(j*jj,|j.t$j0j3t5j6|t$j0dddfd}jD]}|j9t;j<|j>| |\}}|ret@jBjE|||}| j5|jG}|jHj3|dddtK|| jMdd\}}|jNjPj|jRtU|||jVj3||jXjZjt\j^|j`jbr@|j`jbD]'}|jXjZj|)tdjf|jX_4tdjj|jX_6d|jX_7|jpj jr juD]#\}}|j.|j3|%twjx|tzj|dk(rtj|dd|r t||jXjjtwj|jV| | fS#1swYxYw#1swYxYw#1swYxYw#1swY%xYw#1swYzxYw) ajGenerates a MetaGraph which calls `signature_functions`. Args: meta_graph_def: The MetaGraphDef proto to fill. saveable_view: The _SaveableView being exported. signature_functions: A dictionary mapping signature keys to concrete functions containing signatures to add to the MetaGraph. namespace_whitelist: List of strings containing whitelisted op namespaces. save_custom_gradients: Whether to save custom gradients. create_saver: Whether to add SavedModel's native save and restore ops. enable_debug_stripper: Whether to strip the debug nodes from the graph. defaults: A dictionary mapping signature_key to dictionary of user_specified_name to Tensor representing default values. Returns: A tuple of (_AssetInfo, Graph) containing the captured assets and exported Graph generated from tracing the saveable_view. NcN|vr||Stj||SrI)rExportedConcreteFunction)rargsrrs rTcall_with_mapped_capturesz7_fill_meta_graph_def..call_with_mapped_capturessB: !Z !4 ((  ( A A* # %%rU)rrto_graphrTF) add_shapesuse_pybind11_protobiglittle)Err Graphr`rr.rur!rRrrrycontrol_dependenciesrrr%no_opcollection_defr6 MAIN_OP_KEY node_listrrC signature_defINIT_OP_SIGNATURE_KEYrr1op_signature_def_maybe_initialize_trackablerfrozen_saveables_and_saversrrMultiDeviceSaverfrom_saveablesto_proto saver_defr _as_graph_defrregistered_gradientsr _verify_opsr meta_info_deftagsr3SERVINGr extra_tagsr" __version__tensorflow_version__git_version__tensorflow_git_versionstripped_default_attrsasset_file_defrrkr strip_graph_default_valued_attrssys byteorderr5swap_function_tensor_contentrstripped_op_list MergeFromstripped_op_list_for_graph) rvrVrrrrrrresource_initializersexported_graphresource_initializer_opsrr(resource_initializer_functionasset_dependenciesrcasset_initializermapped_initializerinit_oprrnnamed_saveable_objectsrsaverrrrmtagrrdrrs @@rT_fill_meta_graph_defrs<(JJL99;.  "Q)6)D)D)F&J J%&9:xPJQnm<  "O)> >%288JJ7'&EEII T  (  # #$5 6 7  # #$6 7>'(EF ''(:(<=>> >##1188:< ! !": ;) &&(g) !!)"7"78BBHHOO   !@!@AJJ,,W-6-L-L NO+O:%   &c##%&.."77!$= ?,+  - - < < 13L E  " " $3.."i'' 23 m,--%.1,)Q ((// 0K0KL i,-##I.##**=+@+@A%%$$//4""''..s344<4H4H.159=.5&&z'<'<=","2"2"4DmY  /88CD --n=]]e++NE8L~&//99++N,D,DEG ^ ##yQQ >> ))OOf33s["S>?T%(T%)T AT% T"B T%,T2>T T T%T" T%%T/2T<rc$|yg}t}g}|jtj||D]B}d|vs|j dd}||vs!|j ||j |D|rtd|d|dy)aVVerifies that all namespaced ops in the graph are whitelisted. Args: graph_def: the GraphDef to validate. namespace_whitelist: a list of namespaces to allow. If `None`, all will be allowed. If an op does not have a namespace, it will be allowed. Raises: ValueError: If the graph contains ops that violate the whitelist. N>rzEAttempted to save ops from non-whitelisted namespaces to SavedModel: ae. Please verify that these ops should be saved, since they must be available when loading the SavedModel. If loading from Python, you must import the library defining these ops. From C++, link the custom ops to the serving binary. Once you've confirmed this, add the following namespaces to the `namespace_whitelist` argument in tf.saved_model.SaveOptions: r)rYrrops_used_by_graph_defrryrr)rr invalid_opsinvalid_namespacesall_operationsr namespaces rTrr's  +u. 88CD *b by((3-"i - -2y) *  O -3 4F2Fa  I JJrUc ~i}|jD]}|j|}gx}||<t|tr*|jj |D]e\}}||jvr4t j|j|}td|d|d|j|j|g t j|S#t j$r}g} g} |jjD]|\} }t j|j|j| }| jd| d|dt|j| d| jd| d|~d j!| } d j!| } td | d | d }~wwxYw) z;Returns topologically sorted nodes, sorted by dependencies.z&Found an untracked dependency. Object z depends on z, but this dependency isn't listed as a child. Please track this child by overriding `_trackable_children` or use `._track_trackable`.z Node z = z (type )z depends on nodes  zThere is one or more dependency cycle in the saved Trackable object. Saving cannot continue until this cycle is resolved. >> Unresolved nodes: z$ >> Unresolved cyclic dependencies: N)rrr_rBrrr;pretty_print_node_pathrrryorder_by_dependencyCyclicDependencyErrorleftover_dependency_maprkrr) rVdependency_maprrdepsrmr node_patherrpretty_printed_nodespretty_printed_dependenciesrds rTrrPs.!!/d$$T*G%''D>' "$(44FFtL /3 M** *#::  $ $T *, 4YK@* *+ +  kk-((-. / / P  . .~ >>  . .P"$..446P4!88  " "=#6#6q#9 :as_textrCr)serialize_concrete_functionrrrr%r_write_object_protorrY)rVasset_file_def_indexrrrC serializedrn obj_protos rT_serialize_object_graphrxs ! 1 1 3%''.(HH: >>+00 1D'CC=AAJ t$--j9 :M//=nc9 **88  ,rUrc t|tjr0|jj|||j_nt j |r(tj}|j||nt|tjrO|jjtj|||Dcgc]}|j c}n/t|t"j$r/|j&jtj(|nt|t*r7|j,|j._|j0|j._nt|t2j4r|j6|j2_nit;j<|}|7t?j@|jBtEjFddg}|jHj|tKjL|}|r8||_'|jQ|}||jRjU|yyycc}w)z'Saves an object into SavedObject proto.Nr)producer min_consumer bad_consumers) identifierversion)r)+r_r8r` SetInParentrr&rr.get_save_optionsrrrxrrr)serialize_functionrrurvbare_concrete_function serialize_bare_concrete_functionrBrCcaptured_tensorrr:r_resource_devicedevicer- serializerSavedUserObject_object_identifierr VersionDef user_objectr,get_registered_class_nameregistered_name_serialize_to_protoserialized_user_protoPack) rnrrlist_children_fnrrdregistered_type_protor r s rTrrsU[[! KK';C'@EKK$11#6++-GE7+#|,,- NN11 !1#!67A!%%7 9:#u--.   ))??DF#'!$E.1.C.CE+#x22300ENN)33C8$5DD++))q<=  45 ::3?/+E333G( !!&&'<=)-8sI0r export_dirctj}|jD]J}|j|}t |t j s/|j||jL|j}tjtjtj|tj |j#dy)a1Exports debug information from graph to file. Creates and writes GraphDebugInfo with traces for ops in all functions of the exported_graph. Args: exported_graph: A Graph that has been created by tracing a saveable view. export_dir: SavedModel directory in which to write the debug info. T deterministicN)r@GraphDebugInfoBuilderrX _get_functionr_rurbAppendGraphDebugInfograph_debug_infoBuildr#atomic_write_string_to_filerr*get_or_create_debug_dirr6DEBUG_INFO_FILENAME_PBSerializeToString)rr debug_builderfn_namer@rs rT_export_debug_infors002-**Eg  % %g .B b%.. /&&w0C0CD E #((* %% ll  . .z :  * *,((t(< >rUzsaved_model.savezsaved_model.experimental.save)v1rct|tjrtj|}t j t t||||t jdy)aExports a [tf.Module](https://www.tensorflow.org/api_docs/python/tf/Module) (and subclasses) `obj` to [SavedModel format](https://www.tensorflow.org/guide/saved_model#the_savedmodel_format_on_disk). The `obj` must inherit from the [`Trackable` class](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/trackable/base.py#L278). Example usage: >>> class Adder(tf.Module): ... @tf.function(input_signature=[tf.TensorSpec(shape=[], dtype=tf.float32)]) ... def add(self, x): ... return x + x >>> model = Adder() >>> tf.saved_model.save(model, '/tmp/adder') The resulting SavedModel is then servable with an input named "x", a scalar with dtype float32. _Signatures_ Signatures define the input and output types for a computation. The optional save `signatures` argument controls which methods in `obj` will be available to programs which consume `SavedModel`s, for example, serving APIs. Python functions may be decorated with `@tf.function(input_signature=...)` and passed as signatures directly, or lazily with a call to `get_concrete_function` on the method decorated with `@tf.function`. Example: >>> class Adder(tf.Module): ... @tf.function ... def add(self, x): ... return x + x >>> model = Adder() >>> tf.saved_model.save( ... model, '/tmp/adder',signatures=model.add.get_concrete_function( ... tf.TensorSpec([], tf.float32))) If a `@tf.function` does not have an input signature and `get_concrete_function` is not called on that method, the function will not be directly callable in the restored SavedModel. Example: >>> class Adder(tf.Module): ... @tf.function ... def add(self, x): ... return x + x >>> model = Adder() >>> tf.saved_model.save(model, '/tmp/adder') >>> restored = tf.saved_model.load('/tmp/adder') >>> restored.add(1.) Traceback (most recent call last): ... ValueError: Found zero restored functions for caller function. If the `signatures` argument is omitted, `obj` will be searched for `@tf.function`-decorated methods. If exactly one traced `@tf.function` is found, that method will be used as the default signature for the SavedModel. Else, any `@tf.function` attached to `obj` or its dependencies will be exported for use with `tf.saved_model.load`. When invoking a signature in an exported SavedModel, `Tensor` arguments are identified by name. These names will come from the Python function's argument names by default. They may be overridden by specifying a `name=...` argument in the corresponding `tf.TensorSpec` object. Explicit naming is required if multiple `Tensor`s are passed through a single argument to the Python function. The outputs of functions used as `signatures` must either be flat lists, in which case outputs will be numbered, or a dictionary mapping string keys to `Tensor`, in which case the keys will be used to name outputs. Signatures are available in objects returned by `tf.saved_model.load` as a `.signatures` attribute. This is a reserved attribute: `tf.saved_model.save` on an object with a custom `.signatures` attribute will raise an exception. _Using `tf.saved_model.save` with Keras models_ While Keras has its own [saving and loading API](https://www.tensorflow.org/guide/keras/save_and_serialize), this function can be used to export Keras models. For example, exporting with a signature specified: >>> class Adder(tf.keras.Model): ... @tf.function(input_signature=[tf.TensorSpec(shape=[], dtype=tf.string)]) ... def concat(self, x): ... return x + x >>> model = Adder() >>> tf.saved_model.save(model, '/tmp/adder') Exporting from a function without a fixed signature: >>> class Adder(tf.keras.Model): ... @tf.function ... def concat(self, x): ... return x + x >>> model = Adder() >>> tf.saved_model.save( ... model, '/tmp/adder', ... signatures=model.concat.get_concrete_function( ... tf.TensorSpec(shape=[], dtype=tf.string, name="string_input"))) `tf.keras.Model` instances constructed from inputs and outputs already have a signature and so do not require a `@tf.function` decorator or a `signatures` argument. If neither are specified, the model's forward pass is exported. >>> x = tf.keras.layers.Input((4,), name="x") >>> y = tf.keras.layers.Dense(5, name="out")(x) >>> model = tf.keras.Model(x, y) >>> tf.saved_model.save(model, '/tmp/saved_model/') The exported SavedModel takes "x" with shape [None, 4] and returns "out" with shape [None, 5] _Variables and Checkpoints_ Variables must be tracked by assigning them to an attribute of a tracked object or to an attribute of `obj` directly. TensorFlow objects (e.g. layers from `tf.keras.layers`, optimizers from `tf.train`) track their variables automatically. This is the same tracking scheme that `tf.train.Checkpoint` uses, and an exported `Checkpoint` object may be restored as a training checkpoint by pointing `tf.train.Checkpoint.restore` to the SavedModel's "variables/" subdirectory. `tf.function` does not hard-code device annotations from outside the function body, instead of using the calling context's device. This means for example that exporting a model that runs on a GPU and serving it on a CPU will generally work, with some exceptions: * `tf.device` annotations inside the body of the function will be hard-coded in the exported model; this type of annotation is discouraged. * Device-specific operations, e.g. with "cuDNN" in the name or with device-specific layouts, may cause issues. * For `ConcreteFunctions`, active distribution strategies will cause device placements to be hard-coded in the function. SavedModels exported with `tf.saved_model.save` [strip default-valued attributes](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/saved_model/README.md#stripping-default-valued-attributes) automatically, which removes one source of incompatibilities when the consumer of a SavedModel is running an older TensorFlow version than the producer. There are however other sources of incompatibilities which are not handled automatically, such as when the exported model contains operations which the consumer does not have definitions for. Args: obj: A trackable object (e.g. tf.Module or tf.train.Checkpoint) to export. export_dir: A directory in which to write the SavedModel. signatures: Optional, one of three types: * A `tf.function` with an input signature specified, which will use the default serving signature key. * The result of `f.get_concrete_function` on a `@tf.function`-decorated function `f`, in which case `f` will be used to generate a signature for the SavedModel under the default serving signature key. * A dictionary, which maps signature keys to either `tf.function` instances with input signatures or concrete functions. Keys of such a dictionary may be arbitrary strings, but will typically be from the `tf.saved_model.signature_constants` module. options: `tf.saved_model.SaveOptions` object for configuring save options. Raises: ValueError: If `obj` is not trackable. @compatibility(eager) Not well supported when graph building. From TensorFlow 1.x, `tf.compat.v1.enable_eager_execution()` should run first. Calling tf.saved_model.save in a loop when graph building from TensorFlow 1.x will add new save operations to the default graph each iteration. May not be called from within a function body. @end_compatibility 2) write_versionN) r_osPathLikefspathr7IncrementWriteApi_SAVE_V2_LABELsave_and_return_nodesIncrementWrite)rnrr(rs rTsaver+sKv BKK(:&J N+ZW= s+rUc |xstj}tj}|jj }t ||||\}}} } } } tj|_ |sftj|tj|j|j} | j!tj"|| t%j&| j(|t+j,r t+j.t7j8||j:rNt=j>tAjB|d}tDjG|jI|npt=j>tAjB|tAjBtjJ}t=jL||jOdtQjR||jTr tW||tYjZt]|t_j`|| | fS#t0j2$r}t5|d|d}~wwxYw) aSaves a SavedModel while returning all saved nodes and their paths. Please see `tf.saved_model.save` for details. Args: obj: A trackable object to export. export_dir: A directory in which to write the SavedModel. signatures: A function or dictionary of functions to save in the SavedModel as signatures. options: `tf.saved_model.SaveOptions` object for configuring save options. experimental_skip_checkpoint: If set to `True`, the checkpoint will not be written. Returns: A tuple of (a list of saved nodes in the order they are serialized to the `SavedObjectGraph`, dictionary mapping nodes to one possible path from the root node to the key node) )experimental_io_deviceexperimental_sharding_callback)rz You may be trying to save on a different device from the computational device. Consider setting the `experimental_io_device` option in `tf.saved_model.SaveOptions` to the io_device such as '/job:localhost'.N saved_modelTr)saved_model_path)1r/rr SavedModel meta_graphsr_build_meta_graphr6SAVED_MODEL_SCHEMA_VERSIONsaved_model_schema_versionr*get_or_create_variables_dirrCheckpointOptionsr-r.r+get_variables_pathr'copy_assets_to_destination_dirrrr async_waitr NotFoundErrorFileNotFoundErrorr+Saveexperimental_image_formatr#rr>as_strproto_splitterSavedModelSplitterwriteSAVED_MODEL_FILENAME_PBrrr(write_fingerprintsave_debug_inforr7 SetWritePathrr dismantle_graph)rnrr(rexperimental_skip_checkpointr/rvrmr object_saverr saved_nodesr ckpt_optionsrprefixr>s rTr)r)s42  1|//1'**,+**..0.Z.AG!^\:{J**( &,,Z8%77&=='.'M'MOL'' 3\K--j.K.K.8:   A *% && \\ j!F%%k288@ << j! i778 :D '' k++$+?A((4 ~z2 J8n% j  G   A  E7 7 8>A AAsI&&J 9JJ r7c@|xstj}tjj |}t |||\}}}}}}t j||jd|jr t||tj|y)aExports the MetaGraph proto of the `obj` to a file. This function goes through the same procedures saved_model.save goes to produce the given object's MetaGraph, then saves it to the given file. It skips saving checkpoint information, and is useful when all one wants is the graph defining the model. Args: obj: A trackable object to build the MetaGraph from. filename: The file into which to write the MetaGraph. signatures: Optional, either a `tf.function` with an input signature specified or the result of `f.get_concrete_function` on a `@tf.function`-decorated function `f`, in which case `f` will be used to generate a signature for the SavedModel under the default serving signature key. `signatures` may also be a dictionary, in which case it maps from signature keys to either `tf.function` instances with input signatures or concrete functions. The keys of such a dictionary may be arbitrary strings, but will typically be from the `tf.saved_model.signature_constants` module. options: Optional, `tf.saved_model.SaveOptions` object that specifies options for saving. TrN) r/rr$r>dirnamer3r#rrrErr rG)rnr7r(rrrvrrms rTexport_meta_graphrOs8  1|//1'wwx(*/@ :w0 ,..!Q1 %%00t0DF ~z2 n%rUc Ftjr tdt|tj st d|dt|d|xstj}t|}|tj|}tj|\}}}tj|tj|}|j!||t#||}t%j&|} t)||||j*|j,|j. |j0|\} } |j2r|j4j2} |j2j7D]\} }t|t8j:r| | |j<<0t|t>j@r%|jCD]}| | |j<<ot|tDjFjHr)tKd|Dr|D]}| | |j<<tMdt|dtO|| jP}|jRjU||| | | |jV|jXfS) zHCreates a MetaGraph containing the resources and functions of an object.zy`tf.saved_model.save` is not supported inside a traced @tf.function. Move the call to the outer eagerly-executed context.ztExpected an object of type `Trackable`, such as `tf.Module` or a subclass of the `Trackable` class, for export. Got z with type r)rvrVrrrrrrc3PK|]}t|tj ywrI)r_ types_corerv).0rds rT z)_build_meta_graph_impl..Xs">9:*Q 33 4>s$&zUnsupported type fz. Functions in `function_aliases` should be created by tf.function, or concrete functions, or collections of concrete functions.)-r inside_functionAssertionErrorr_r9rrrr MetaGraphDefrGr2find_function_to_exportcanonicalize_signaturesvalidate_augmented_graph_viewcreate_signature_mapr\rrTrackableSaverrrexperimental_custom_gradientsexperimental_skip_saverexperimental_debug_stripperfunction_aliasesrrkrRrvrCrrx_list_all_concrete_functions collectionsabcIterableallrrrobject_graph_defrrr)rnr(rrvrrWrrVrVrIrrr`aliasrfdefentryobject_graph_protos rT_build_meta_graph_implrk$s   ?  C (  >>AUC#YKq "  "B^%@%@%B.,S1(@@J 55jA**778LM)>>zJ-$$]4EF 4g>-**+?@,3#!$!55#AA666#?? *n %33DD//557 t D*55 6&+# d099 :557 .D(- 499 % . dKOO44 5#>>B>; /E). 5:: & / d -2 2   "/Z++!!**+=>  rUcttj|5t||||cdddS#1swYyxYw)ayCreates a MetaGraph under a save context. Args: obj: A trackable object to build the MetaGraph from. signatures: Can be a `tf.function` with an input signature specified or the result of `f.get_concrete_function` on a `@tf.function`-decorated function `f`. `signatures` may also be a dictionary, in which case it maps from signature keys to `tf.function` instances. If None, finds signature to export from the `@tf.function`-decorated methods in `obj`. options: `tf.saved_model.SaveOptions` object that specifies options for saving. meta_graph_def: Optional, the MetaGraphDef proto fill. Raises: AssertionError: If `export_meta_graph` is executing inside a `tf.function`. ValueError: If `obj` is not trackable. Returns: meta_graph_def: Filled MetaGraphDef proto exported_graph: `tf.Graph` object generated from `obj`. object_saver: `checkpoint.TrackableSaver` of the `obj` and its dependencies. asset_info: `_AssetInfo` tuple containing external assets in the `obj`. saveable_view.nodes: _SaveableView nodes. saveable_view.node_paths: _SaveableView paths. N)r.rk)rnr(rrvs rTr3r3qs:@  )L !#z7N KLLLs.7rI)NN)NNF)rrbr$rrr^typingrrrrrabslrtensorflow.core.frameworkr r r r tensorflow.core.protobufr rrtensorflow.python.checkpointrrrrrrrtensorflow.python.eagerrrrru,tensorflow.python.eager.polymorphic_functionrrrrrtensorflow.python.frameworkrrrCrr r!r"tensorflow.python.lib.ior#tensorflow.python.opsr$r%r&tensorflow.python.saved_modelr'r(r)r*r+r,r-r.r/r0r1r2r3r4r50tensorflow.python.saved_model.pywrap_saved_modelr6r7tensorflow.python.trackabler8r9r:r;!tensorflow.python.training.savingr<tensorflow.python.typesr=rRtensorflow.python.utilr>r?r@ tensorflow.python.util.tf_exportrA frozensetvariantra namedtuplerBrr(ObjectGraphViewrGobjectrrLrrrrbytesrdictr.rResourceVariablerrKrrUrurWrboolrGraphDefrrr SavedObjectrrrr+r)rOrkr3rrUrTrsh; 332/2234;3;935@+05PMVJ..@2+30,+276>@6<6766==A774FD-,07A6)2+6@A)+(():*02E)FH#$W*44WtA!FA!H)+DD)--)XDsDSD0 T7S T7T7T7t8c8CH#5568888v$[ # #   KK0@@K6(38,(c HS#X$667*]3SYY]3}]3@V~'B'BVtVB}$"//}$ }$c8CH#556}$c }$  }$  }$ }$ :syy !}$@&J9--&JR%P}%PP 6*> ! - -*>Z>syy>c>2 ;<> (, ~,~, % % ~,>~,H(,!& V! % % V!x(, +&+& % % +&^HLJ*66Jb37 !L % %!L#// !LrU