BVh|mdZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd l m Z dd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#ddl$m%Z%Gdde&Z'dZ(dZ)dZ*Gdde jVZ,d Z-Gd!d"e&Z.e%d#g$d'd%Z/d'd&Z0y)(z=Prototype decorator for defining legacy-graph-mode functions.N) function_type)meta_graph_pb2) struct_pb2)context)function) lift_to_graph)atomic_function)composite_tensor) func_graph)importer)ops) sparse_tensor)tensor) tensor_shape) tensor_util)resource_variable_ops)variable_scope) tf_logging)nested_structure_coder)data_structures)nest) tf_exportc:eZdZdZddZedZdZdZdZ y) VariableHolderz&Holds variables for a python function.NcR||_||_tj|_yN)_fn_share_variablesrMapping_variables_by_name)selffnshare_variabless U/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/eager/wrap_function.py__init__zVariableHolder.__init__/s"DH+D-557Dc|jSr)r r!s r$ variableszVariableHolder.variables5s  " ""r&c b|jdd}d}tj|jdddd5}tj|}||d<ddd|j r|j jd}||di|}||j <|tjjg}|jrCtjj|vr't|tjjgz}tj|||S#1swYxYw)zBCreates variables & adds them to collections to match legacy code. collectionsNnameVariableF) skip_on_eager) popr name_scopegetname_from_scope_namerr GraphKeysGLOBAL_VARIABLES trainableTRAINABLE_VARIABLESlistadd_to_collections)r! next_creatorkwargsr+vr, variable_names r$variable_creator_scopez%VariableHolder.variable_creator_scope9s**]D1K A  64 *E CFJ..t4mfVn    ! ! % %mT :ay   a/0dm,]]334k{{s}}88 K%)J)J(KKk;* H's D%%D.cD|j|j|i|Sr) call_with_variable_creator_scoper)r!argsr;s r$__call__zVariableHolder.__call__Ts# :4 0 0 :D KF KKr&cfd}|S)Nc~tjj5|i|cdddS#1swYyxYwr)rr>)rAr;r"r!s r$wrappedz@VariableHolder.call_with_variable_creator_scope..wrappedYs9  0 01L1L M#4"6"###s3<r/)r!r"rEs`` r$r@z/VariableHolder.call_with_variable_creator_scopeWs# Nr&)NF) __name__ __module__ __qualname____doc__r%propertyr)r>rBr@r/r&r$rr,s..8  # # 6Lr&rc|jd}|dk(r|j|jS|dk(rtj|j |j j|j |j j|j |j jS|dk(rtj|jj}tj|}|jj Dcgc]}|j |j}}|j#|St%d|dcc}w)z@Simplified copy of the deprecated `get_tensor_from_tensor_info`.encodingr, coo_sparser )type_spec_valuezInvalid TensorInfo.encoding: zC. Valid encodings are 'name', 'coo_sparse', and 'composite_tensor'.) WhichOneofas_graph_elementr,r SparseTensorget_tensor_by_namerMindices_tensor_namevalues_tensor_namedense_shape_tensor_namerStructuredValuer type_specr decode_proto components_from_components ValueError) tensor_infographrL spec_protospec componentrYs r$_get_element_from_tensor_infora`sB  # #J /(   ! !+"2"2 33<  % %   !7!7!K!KL   !7!7!J!JK    " " : : < == %%++#44>>@J ! . .z :D..99;y%**9>>:;J;   ,, 4XJ?++ ,, ;s"Ec.tj|j|j|jj |j |j}|j|_|j|j|j|j|j|j jdd}||j|<|jjtj ||j#||S)z4Lifts `old_variable` out of the `FuncGraph` `graph`.)shapedtyper,r6extra_handle_data:r)rUninitializedVariablercrdopr,r6handle_initializer_op add_capturecapturesplitr _weak_variablesappendweakrefrefwatch_variable) old_variabler]variable_holder new_variabler=s r$_lift_single_variablervzs&<<       ??  &&$++ -, ".!=!=,L'')<)<=-- ##$##))#.q1-6B/$$]3w{{<89|$ r&c 8|j5tjtjj}tjtjj }|j Dchc] }t|c}i}fd}|D]J}||s t|||}||t|<jt|jL|D]}||s t|||}||t|<jt|j|jsX|j} | jtjj} | j|| jtjj |tjjtjj fD]} tj| } t!| D]s\} }|j#t||| | <t%j&| | r=t)j*t(j,dj/| | du dddycc}w#1swYyxYw)aFinds resource variables and lifts them into the outer context. When we import a GraphDef inside a wrap_function, no Python graph building code runs. This means we get VarHandleOps which create variable resources, but no corresponding Python objects. Leaving them like this works but gives the user no way to interact with or modify the variables outside the graph. This method searches for variables and lifts them out as regular variable objects when possible, indicating to the FuncGraph that they are captures. Args: graph: The FuncGraph to lift variables from. variable_holder: A VariableHolder to record the lifted variables in. c|jxr|jjxr3t|tj xrt |jvSr)_in_graph_moder]building_function isinstancerBaseResourceVariableidri)r<existing_capturess r$_should_lift_variablez7_lift_unlifted_variables.._should_lift_variablesQ-77,,8Q 5 J JK8QXX,&779r&zUnable to create a python object for variable {} because it is a reference variable. It may not be visible to training APIs. If this is a problem, consider rebuilding the SavedModel after running tf.compat.v1.enable_resource_variables().N) as_defaultr get_collectionr4r5LOCAL_VARIABLESinternal_capturesr}rvaddriryr]get_collection_refremoveadd_to_collection enumerater2ris_resource_variablelogging log_first_nWARNformat)r]rtglobal_collection_variableslocal_collection_variablesclifted_variablesrrsru outer_graphglobal_collectioncollection_namemutable_collectionindexcurrentr~s @r$_lift_unlifted_variablesrsX 7"%"4"4 &&#(!$!3!3 %%"'(-(?(?@1A@9 47 | ,, %2 -9L)*b!4!456 73; | ,, %2 -9L)*b!4!456  & &$**+*<<mm,,.   " "< 0  ' 'mm++\ ;;( && (E(E11/B%&89 .%$4$8$8Gg$N5!$99 u %'   llBCI&$U+C-   Q77 A 77s9A)J;J  J%AJ4A JDJ;J JJcBeZdZdZ dfd ZfdZ ddZxZS)WrappedFunctionz*Wraps a tf V1 piece of code in a function.c||_t|||jdjjD]%}t j j |'||_tj|j|j|jj|}tjt j |j"|||}t$ |M|y)NT)use_pybind11_proto) are_keyword_args_also_positional)_variable_holderr as_graph_deflibraryrradd_function_def _signaturefunction_type_libfrom_structured_signaturestructured_input_signaturestructured_outputsfunction_captures capture_typesr from_func_graph_inference_namer,superr%) r!fn_graphrtattrs signaturerfr atomic_fn __class__s r$r%zWrappedFunction.__init__s,DX7 " "d " ; C C L L, oo((+,DO%??++##""00)I M  //  /5-I GYr&c|j|rtd|d|jvt|}t |D]]\}}t |j|t js.tj||j|j||<_|j||jSt|9||S)NzYKeyword arguments are not supported when calling a wrap_function-decorated function. Got .) _arg_keywordsNotImplementedErrorrr8rr{ tensor_lib DenseSpecr convert_to_tensorrd _call_flatcaptured_inputsr _call_impl)r!rAr;iargrs r$rzWrappedFunction._call_impls ! ! 55;HA ?@ @  $Dzo KFAs *J,@,@ A++C1C1I1IJDG K__T4#7#7 88 W f --r&c |xsd}tj|d}|Dcgc]}jj|}}|D]7}t |t j rtd|dt|djjD chc] } t| } } |Dcgc]}t|| vs|}}gggfdtj|}tjd|zzD]C}|jjustdjd |d |jdjj5tj|} d d d t!j z |jjzj | j"j%fd D| j&j%D cgc]} |  c} | j(j%fd|Djj*D]\} }| j-| |D]v}|j/ddk(s| j|j0}t3j4|sI|j7t9j:|j8xjj<j?D]}| jA|jjB| _!fd}tj||d| _"|r|\}}|dn|}||f}|| _#tI| jJ|}tM||_'|Dcgc]}|jPj0c}|_)|Scc}wcc} wcc}w#1swYZxYwcc} wcc}w)auExtract a subgraph of this function's underlying graph. Wraps the subgraph in a new `WrappedFunction` object. Args: feeds: Input tensors to the subgraph to extract, as `Tensor` objects. fetches: Possibly-nested Python data structure containing information about outputs of the target subgraph. Each entry can either be a `Tensor` object (for data outputs), an `Operation` object (for control outputs), or a `TensorInfo` proto. Any additional shape/dtype information provided in a `TensorInfo` and not present in the original graph will be added to the returned subgraph. name: (optional) Name to give to the underlying `FuncGraph` of the returned object. If no name is provided, the graph's name will be `"pruned"`. input_signature: (optional) possibly-nested Python data structure containing `TensorSpec` objects, with which to populate the returned functions's `FuncGraph`'s `structured_input_signature` field. are_keyword_args_also_positional: whether the keyword arguments in `input_signature` are `POSITIONAL_OR_KEYWORD` arguments. If `False` (default), they are treated as `KEYWORD_ONLY` arguments. Returns: A new `WrappedFunction` object containing a copy of the portion of this object's graph that goes from `feeds` to `fetches`. prunedT)expand_compositesz5All members of argument `feeds` must be tensors. Got z with type rcJt|tjrj||St|tj r|j|t |j}tj|st|tjrj||Sj||St|tjtjfrj||Sjj|}|S)awExtract out lists of ops, tensors, and tensor type info. Turns TensorInfos into Tensors in the original `fetches` structure. Also extracts ops from `fetches`. Args: fetch: The fetch to preprocess: Tensor, TensorInfo, or Operation, or string identifying a Tensor or Operation. Returns: `fetch` converted to a Tensor. )r{r Operationror TensorInfora _func_graphr is_tf_typer CompositeTensorrTensorr]rP)fetchdecoded graph_element_fetch_preprocessing_callbackoperation_fetchesr!tensor_fetches tensor_infoss r$rz._fetch_preprocessing_callback>s E3== )  ' e^66 7E"/t7G7GH  " "7 + w 0 @ @ A    (  " "7 +  *##%5%E%EF He$  33E: ,];;r&z;Can only prune function whose feeds and fetches from graph z. Input z is from a different graph N)sources base_graphc3(K|] }| ywrr/.0xlift_maps r$ z(WrappedFunction.prune..tsD Dc3(K|] }| ywrr/rs r$rz(WrappedFunction.prune..ws?qx{?rrLr,cH|}t|tjry|S)z#callback for `nest.map_structure()`N)r{r r)fetchedliftedrs r$_structured_output_mappingz9WrappedFunction.prune.._structured_output_mappings# f FCMM * mr&r/)rtr)*rflattenr]rPr{rrr[typerr} map_structurerrr FuncGraphroutputsextendcontrol_outputsinputscapturesrkrOr,rr set_shaper TensorShape _functionsvalues _add_functionr)rrrrlen_num_positional_argsrhr)r!feedsfetchesr,input_signaturer flat_feedstrrr pruned_graph operationexternal_captureinternal_capturetirrAr; pruned_fnrrrrrrs` @@@@@r$prunezWrappedFunction.prunesH  8DetHG\\.DIN . (+< <F (( (''+'7'7&839!''!EF FF    $ $ &0))$/l0**N*TZZ999## %HD^DD  ''.?@) @B?J??.2jj.A.AM**/:J1KLMA z "f ,  ) )"'' 2  ! !! $ ++l..r? @ A ZZ " " ) ) +$  #$"ZZ11L'+&8&8"Gt'EL#$ldF.wrap_and_filter_returned_opssw$!&!G<<(L 3|$ %Af FCMM * Q Q   , 77r&r/)r"rrs` @r$_filter_returned_opsrs,8 &| 33r&cPeZdZdZddZedZedZddZ d dZ y) WrappedGraphaClass for wrapping multiple TF 1.X functions in a single graph. Maintains a dictionary mapping names to wrapped functions. See `tf.compat.v1.wrap_function` to learn more about wrapping V1 functions. Functions wrapped using this class have access to variables and collections created in other wrapped functions, using the standard TF 1.X API ( `tf.compat.v1.get_variable` or `tf.compat.v1.get_default_graph().get_collection(...)`) Outside a function, variables and collections may be accessed using the `variables` and `graph` properties. Example: ``` def add_v1(x): with tf.compat.v1.variable_scope('vars', reuse=tf.compat.v1.AUTO_REUSE): v = tf.compat.v1.get_variable('v', shape=[], dtype=tf.int32) return v + x def increment_var_v1(x): with tf.compat.v1.variable_scope('vars', reuse=tf.compat.v1.AUTO_REUSE): v = tf.compat.v1.get_variable('v', shape=[], dtype=tf.int32) return v.assign_add(x) g = WrappedGraph() add = g.wrap_function(add_v1, [tf.TensorSpec([], tf.int32)]) increment_var = g.wrap_function(increment_var_v1, [tf.TensorSpec([], tf.int32)]) assert len(g.variables) == 1 assert g.variables[0].numpy() == 0 increment_var(tf.constant(5)) assert g.variables[0].numpy() == 5 ``` Nc |xs td|_|jdd}|jdi}tj|fd|i||_t |j |j|_i|_y)NT)r#r,wrapped_function_graphr+) rrr0r rr]r_wrapped_functionr)r!rtr;r,r+s r$r%zWrappedGraph.__init__sx?>$?  ::f6 7D**]B/K%%dN NvNDJ,TZZ9N9NODDOr&c|jSr)rr(s r$ functionszWrappedGraph.functionss ??r&c.|jjSr)rr)r(s r$r)zWrappedGraph.variabless  * **r&c*|j|||S)aDWraps a TF 1.X function and returns an eager-compatible function. All functions wrapped in the same `WrappedGraph` will have access to the same graph (`tf.compat.v1.get_default_graph` to get the graph object within a function, or `WrappedGraph.graph` to get the graph outside a function). Variables created within the function will be added to the `variables` list. Function inputs: All inputs to the function must be tensors (nested ok), with their shapes and dtypes defined in the `signature` argument. Function outputs: * The 1.X function may return tensors, variables, and ops. The wrapped eager-compatible function will always return tensors in the same nested structure. * Variables are replaced with a tensor containing the latest read values. * Returned ops are executed, and replaced with None. * The order of op execution and variable reads in the return is nondeterministic. For example: ``` def update_var(x): v = tf.Variable(0) op = tf.compat.v1.assign(v, x).op return v, op g = WrappedGraph() fn = g.wrap_function(update_var) read_value, _ = fn(tf.constant(3)) print(read_value.numpy()) # could be 0 or 3 print(g.variables[0].numpy()) # always 3 ``` To ensure that ops in the function are executed (e.g. ops added to the `tf.GraphKeys.UPDATE_OPS` collection), include them in the function returns. Args: fn: a 1.X tensorflow function. signature: a possibly nested sequence of `TensorSpecs` specifying the shapes and dtypes of the arguments. name: an optional string name for the function. The function will be saved with key `name` in the `functions` dictionary. Returns: An eager-compatible function. )rr,)_wrap_function)r!r"rr,s r$ wrap_functionzWrappedGraph.wrap_functions`   rYT  BBr&c t|jj|\}}tjd||||d|j |j j dt|j j }tj|j j} |jD] \} } | | | < tj|j j| } |xs |j}|jj!|| ||j j"} | |j$|<| S)zAInternal wrap function method with extended func_graph arguments.NF)rAr;radd_control_dependenciesr )rrr@r func_graph_from_py_funcr]rrrrrritemsrrFr rrr)r!r"rAr;rr,fn_with_filter_and_scoper fn_inputsflat_fn_outputsrrh fn_outputswrapped_functions r$rzWrappedGraph._wrap_function/s,.B >>rB.D*l&&  !&:: !!"._imports_graph_defsd ib1  ! ! #EP! (1+u'?'?A 'NOPr&)rr]rrrrP)r$rrrr%wrapped_import import_graphs` ` r$function_from_graph_defr(sd"P!!3R8.%%,    66? 66@ BBr&r)1rIrp%tensorflow.core.function.polymorphismrrtensorflow.core.protobufrrtensorflow.python.eagerrrr,tensorflow.python.eager.polymorphic_functionr tensorflow.python.frameworkr r r r rrrrrtensorflow.python.opsrrtensorflow.python.platformrrtensorflow.python.saved_modelrtensorflow.python.trackablertensorflow.python.utilr tensorflow.python.util.tf_exportrobjectrrarvrConcreteFunctionrrrrr(r/r&r$r6s DT3/+,1H820+5<4370<@7'61V1h,4.FTGh//GT46S6Sl  F!FRBr&