BVh&dZddlZddlmZmZmZmZddlZddlm Z ddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm 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-m.Z.ej^j`ej^jbej^jde jfe jhgZ5Gd d!e6Z7 d3d"Z8e.d#g$Gd%d&ejrZ:e)jvd'e:d(eejrfd)Z< d4d*Z=d+Z>d,Z?d-Z@d.ZAd/ZBd5d0ZCd1ZDd2ZEy)6z$FuncGraph and related functionality.N)AnyCallableContextManagerHashable) trace_type)capture_container)context)execute)composite_tensor_utils)auto_control_deps)composite_tensor) constant_op)dtypes)errors)indexed_slices)ops)tensor) type_spec) array_ops)resource_variable_ops)tensor_array_ops)variable_scope) save_context)core)compat)nest)object_identity) tf_contextlib) tf_decorator) tf_inspect)variable_utils) tf_exportceZdZdZy)UnknownArgumentz5Signifies an argument which is not currently handled.N)__name__ __module__ __qualname____doc__V/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/func_graph.pyr$r$<s=r*r$cFfd}tj|}|rHt|t|k7rtd|z|Dcgc]\}}||df|ddz|f}}}|Dcgc]\}}|||}}}tj||Scc}}wcc}}w)a?Convert a potentially nested structure to a signature. Args: structure: Structure to convert, where top level collection is a list or a tuple. arg_names: Optional list of arguments that has equal number of elements as `structure` and is used for naming corresponding TensorSpecs. signature_context: TraceType InternalTracingContext to generate alias_ids for mutable objects, like ResourceVariables. Returns: Identical structure that has TensorSpec objects instead of Tensors and UnknownArgument instead of any unsupported types. c t|tjrd} tj|j j d}|r |r ||dk7r|}n+tjdjd|D}tj|j|j|St|tjrt!j"|St|t$j&r |j(St|t*t,t.t0t3dt4j6tjt8j:fr|St=S#ttf$rY0wxYw)zCA representation for this argument, for converting into signatures.N_user_specified_namer_c32K|]}t|ywN)str).0ps r+ zEconvert_structure_to_signature..encode_arg..`s5Kc!f5Ks) isinstance tensor_libTensorras_stropget_attr ValueErrorAttributeErrorsanitize_spec_namejoin TensorSpecshapedtyperResourceVariabler from_valuer CompositeTensor _type_specintfloatboolr2typerDTyperTypeSpecr$)argpathuser_specified_namenamesignature_contexts r+ encode_argz2convert_structure_to_signature..encode_argQs9#z(()  $mm FFOO2 35 %*=a*H#,,SXX5Kd5K-KL  " "399cii >>#,==>  " "3(9 ::#'778 ^^#     T    j  5. )   s.E++E>=E>z6Passed in arg_names don't match actual signature (%s).rN)rflatten_with_tuple_pathslenr<pack_sequence_as) structure arg_namesrQrR flattenedrNrMmappeds ` r+convert_structure_to_signaturer[@s"!J++I6) 9~Y'  BY N PP BK4=D#)DG  ab )3/I4= =idCJsD ! =& =  y& 11  >s B+Bz__internal__.FuncGraph)v1ceZdZdZ d'fd ZdZdZ d(dZfdZfdZ e dZ e jd Z e d Z e d Ze d Ze d ZejdZ d)dZ d*fd Zd+dZdZdZdedegefddfdZe dZdZdZ d,dZe dZe dZe dZ e d Z!e d!Z"e d"Z#d#Z$e d$Z%e d%Z&d&Z'xZ(S)- FuncGraphaGraph representing a function body. Attributes: name: The name of the function. inputs: Placeholder tensors representing the inputs to this function. The tensors are in this FuncGraph. This represents "regular" inputs as well as captured inputs (i.e. the values of self.captures), with the regular inputs coming first. outputs: Tensors that will be returned by this function. The tensors are in this FuncGraph. control_outputs: Operations that must be executed before the function represented by this graph can be said to have been executed. structured_input_signature: A tuple of (args, kwargs), which are both possibly-nested python objects that were received by this function. Note that these structures might contain Python `None`s. structured_outputs: A possibly-nested python object which will be returned by this function. The Tensors in this structure are the same as those of self.outputs. Note that this structure might contain Python `None`s. variables: Variables that should be watched during function execution. outer_graph: The graph this function is defined in. May be another FuncGraph or the global default Graph. captures: Maps external tensor -> internal tensor (i.e. input placeholder). The entries are in the order they were captured. seed: The graph-level random seed. capture_by_value: If True, the func graph will capture Variables by value instead of reference. ct |||_g|_g|_g|_||_||_tj|_ g|_ tj|_ d|_tj |_t%j&}t)j*||_|j.r|j0}|j.r||_d|_|||_nI|j06t9|j0t:r|j0j6|_nd|_d|_|j0}t?j@r!t?jB|_"d|_#n7|jD|_"d|_#|jHjK|_$|f|jMD])}|tNvs |jQ||jR|<+tND] }|jU||jR|<"n||_)d|_+tY|_-d|_.y)aConstruct a new FuncGraph. The graph will inherit its graph key, collections, seed, and distribution strategy stack from the current context or graph. Args: name: the name of the function. collections: a dictionary of collections this FuncGraph should start with. If not specified (None), the FuncGraph will read (but not write to) the outer graph's collections that are not allowlisted, and both read and write to the outer graph's collections that are allowlisted. The current allowlisted collections are the global variables, the local variables, and the trainable variables. Defaults to None. capture_by_value: An optional boolean. If True, the func graph will capture Variables by value instead of reference. By default inherit from outer graphs, and failing that will default to False. structured_input_signature: Optional. The structured input signature to use for initializing the FuncGraph. See the docstring for FuncGraph for more information. structured_outputs: Optional. The structured outputs to use for initializing the FuncGraph. See the docstring for FuncGraph for more information. FNT)/super__init__rPinputsoutputscontrol_outputsstructured_input_signaturestructured_outputsrObjectIdentitySet_resource_tensor_inputs_weak_variablesObjectIdentityWeakSet_watched_variablesis_control_flow_graphrFunctionCaptures_function_capturesrget_default_graphweakrefref_weak_outer_graphbuilding_function outer_graph_fallback_outer_graph _output_namescapture_by_valuer6r^_building_functionr executing_eagerly global_seedseed _seed_used_colocation_stackcopyget_all_collection_keysALLOWLIST_COLLECTIONSget_collection _collectionsget_collection_ref _saveableset_saving_errors_scope_exit_callbacks) selfrP collectionsrwrerfrtgraphcollection_name __class__s r+razFuncGraph.__init__s: GDIDKDLD&@D#0D#2#D#D#FD D-CCED!&D/@@BD'')K$[[5D  ' '++k  ' '"-DD#.d   %*T5E5E5>+@"..??d#d"D   E  "%%'dido**dido %66;;=d"::</ "7 7/4/C/C0$  O ,3/-2-E-E ./*&d DN%D"&Dr*c:d|jdt|dS)NzFuncGraph(name=z, id=))rPidrs r+__str__zFuncGraph.__str__s*.))RX >>r*ct|tjr|j|jvry|Mt|t r<|j j||j}|t|t r:yyyy)z;Marks the variable v as accessed while building this graph.N) r6rrChandlerhr^rkaddrt)rvs r+watch_variablezFuncGraph.watch_variable sr 1+<<= D000  z$ : !!!$   d  z$ : : r*c t|jjvrtjd}tj ||&tj |}j|}fd}|_|jj||d|jjS)aG Returns a placeholder which at call time has the value closure(). The `tf.function` supports the notion of captures, that is, it allows Python functions to have closure variables, which bind over some value outside the function. However, this name binding is "early binding" performed before the program is run, i.e., ``` @tf.function def f(): return x x = tf.constant(1) f() # returns 1 x = tf.constant(2) f() # still returns 1! ``` while in Python, name binding is performed as the program is running. ``` def f(): return x x = 1 f() # returns 1 x = 2 f() # returns 2 ``` `capture_call_time_value` allows tf.function to mimic late binding as a Python function does, by passing in a `closure` callable argument to be executed when the tf.function is invoked eagerly. E.g. ``` @tf.function def f(): return ops.get_default_graph.capture_call_time_value(lambda: x) x = tf.constant(1) f() # returns 1 x = tf.constant(2) f() # returns 2 ``` Note that a `capture_call_time_value` function itself does not work well in the saving process (since the tf.function in which it's called is not invoked eagerly) unless passed a `default_value` argument. At saving time, the `default_value` argument is returned instead. Args: closure: function which takes no arguments, to be evaluated at function call time, returning a nest of tensors compatible with `spec`. spec: nest of TypeSpec for the value to capture. key: optional. If not None, multiple calls to lazy_capture with the same key in the same graph will return the same placeholder, and the first closure will be used at function call time. default_value: optional value to return in environments that cannot safely evaluate closure. placeholder: optional. If not None, the graph will take the passed-in `placeholder` as the internal capture instead of creating a new one. This is useful when loading from a SavedModel. Returns: Nest of placeholders which, at function call time, will be fed with the result of calling closure(). Raises: ValueError: at function call time, if the return value of closure() is not compatible with `spec`. TctjrStjsZt j }t |tsJd|j5|j}dddn}jtj}j|S#1swY:xYw)Nz/This API should only be used in TF2 enviroment.)key default_value)rin_save_contextr ryrror6r^ as_defaultcapture_call_time_valuecastrInternalCastContext to_tensors)rret_nestclosurerrspecs r+wrapped_closurez:FuncGraph.capture_call_time_value..wrapped_closureis  ' ' )m.G ((*'')% LK L! E443m5EH E EY(99Xz'E'EFx(( E Es )CC )rexternalinternal tracetype is_by_ref) objectrnby_ref_internalrInternalTracingContextrDInternalPlaceholderContextplaceholder_value output_specadd_or_replace) rrrrr placeholder trace_ctxplaceholder_ctxrs ```` r+rz!FuncGraph.capture_call_time_valuesT { Hc $))99933D9i  " "4 3d  $??E,,_= )@%)o! ,," -  " " 2 23 77r*c|t||Sg}|D]}t|tjst |drt |dr |j }tj|}||}|5t|dd|ur&|jjj||j|t||S)a Handles control dependencies. FuncGraph wraps Graph's control_dependencies logic by first filtering out any external tensors / operations and storing them in the graph's control_captures member. Any consumers of this function graph must then decide how to handle the control captures. Args: control_inputs: A list of `Operation` or `Tensor` objects which must be executed or computed before running the operations defined in the context. Can also be `None` to clear the control dependencies. Returns: A context manager that specifies control dependencies for all operations constructed within the context. Raises: TypeError: If `control_inputs` is not a list of `Operation` or `Tensor` objects. N_handler:r)r`control_dependenciesr6r IndexedSliceshasattrr:r_as_graph_elementgetattrrncontrolrappend)rcontrol_inputsfiltered_control_inputsc graph_elementrs r+rzFuncGraph.control_dependenciess* W ). 99   6 Q44 5 1i WQ%5 DD++A.m    "w}g/3(5<@(A ''++M:&&}5 6 7 '(? @@r*c8t|}t||Sr1)r`r_func_graph_as_default_inner_cm)router_cmrs r+rzFuncGraph.as_defaultsw!#H *4 ::r*cB|j}| |jS|S)aThe Graph this FuncGraph is nested in. Functions may capture Tensors from graphs they are nested in (transitive). Returns: A Graph object. Initially set to the current default graph when the FuncGraph was created. If the previous `outer_graph` was deleted because the function that owns it was deleted, `outer_graph` is reset to the outermost default graph active when the FuncGraph was created. This FuncGraph won't have captured anything from the new `outer_graph` (and likely not from the previous setting, since that would have created a strong reference), but it is returned so that FuncGraphs always have a parent. )rrru)rcurrents r+rtzFuncGraph.outer_graphs( $$&G  ' '' Nr*c8tj||_y)z(Sets `outer_graph` to `new_outer_graph`.N)rprqrr)rnew_outer_graphs r+rtzFuncGraph.outer_graphs%[[9Dr*cT|jDcgc]}|jc}Scc}wr1)rcrBrts r+ output_typeszFuncGraph.output_types!\\ *AGG ** *%cT|jDcgc]}|jc}Scc}wr1)rcrArs r+ output_shapeszFuncGraph.output_shapesrrc:td|jDS)a A sequence of trainable variables accessed by this FuncGraph. Note that functions keep only weak references to variables. Calling the function after a variable it accesses has been deleted is an error. Returns: Sequence of trainable variables for this func graph. c3:K|]}|js|ywr1) trainable)r3rs r+r5z0FuncGraph.trainable_variables..s:qakk:s)tuple variablesrs r+trainable_variableszFuncGraph.trainable_variabless :DNN: ::r*cFdtfd|jDS)a A sequence of variables accessed by this FuncGraph. Note that functions keep only weak references to variables. Calling the function after a variable it accesses has been deleted is an error. Returns: Sequence of variables for this func graph. c.|}| td|S)NaCalled a function referencing variables which have been deleted. This likely means that function-local variables were created and not referenced elsewhere in the program. This is generally a mistake; consider storing variables in an object attribute on first call.)AssertionError)weak_vrs r+derefz"FuncGraph.variables..derefs' (a    hr*c3.K|] }|ywr1r))r3rrs r+r5z&FuncGraph.variables..s8aq8s)rri)rrs @r+rzFuncGraph.variabless!  84#7#78 88r*c^|Dcgc]}tj|c}|_ycc}wr1)rprqri)rvar_listrs r+rzFuncGraph.variabless 4<=qGKKN=D=s*c ptd|jD} |D cgc]} | jt| | } } t j 5t jr[dt|djf} tjtj|d| | t j \} n9t jj|| ||||||}|jd} ddd|j! }|j"Scc} w#1swY+xYw)Nc3<K|]\}}t||fywr1)r)r3krs r+r5z.FuncGraph._capture_by_value..sA41aRUAJAsrBrSr)dictcapturesgetrr init_scoper ryrGrJr ras_bytesro_create_op_internalrccapturer:)rop_typerbr input_typesrPattrsop_defcompute_devicereverse_capturesruncaptured_inputs attr_listvaluer:captured_values r+_capture_by_valuezFuncGraph._capture_by_value sA4==AAAGHA)--beQ7HH     " " $c%."5"567  OOG $a):I OO  " " $ 8 8 & T5 N$ 1  \\%(N   I  s"D'B)D,,D5c  |jr|dvr|j||||||||S|dk(rY|djjdk(r=|djj d|dj k(r|djSt jj} g} |D]C} | t| dr| j| } |j| } | j| Et |9|| ||||||S)a3Like Graph.create_op, except handles external input tensors. This overload adds functionality to create_op to "capture" any external input tensors, i.e. tensors from the eager context or outer function graphs if this is a nested function. See `capture` for more information. Args: op_type: The `Operation` type to create. This corresponds to the `OpDef.name` field for the proto that defines the operation. inputs: A list of `Tensor` objects that will be inputs to the `Operation`. dtypes: (Optional) A list of `DType` objects that will be the types of the tensors that the operation produces. input_types: (Optional.) A list of `DType`s that will be the types of the tensors that the operation consumes. By default, uses the base `DType` of each input in `inputs`. Operations that expect reference-typed inputs must specify `input_types` explicitly. name: (Optional.) A string name for the operation. If not specified, a name is generated based on `op_type`. attrs: (Optional.) A dictionary where the key is the attribute name (a string) and the value is the respective `attr` attribute of the `NodeDef` proto that will represent the operation (an `AttrValue` proto). op_def: (Optional.) The `OpDef` proto that describes the `op_type` that the operation will have. compute_device: (Optional.) If True, device functions will be executed to compute the device property of the Operation. Returns: An `Operation` object. )ReadVariableOpResourceGatherEnterr frame_nameAddValue)rwrr:rJr;srro_control_flow_contextrrrrr`r) rrrbrrrPrrrctxtcaptured_inputsinprs r+rzFuncGraph._create_op_internal$sP -" # #GVV[$$)6>CC'fQill//7:   | ,l0C0E0E Eay||  " 8 8DO" gdJ7mmC  LL cS! " 7 &&+tUF r*c<|jj|||Sr1)rnrw)rrrPrAs r+rzFuncGraph.capturejs  " " 3 3D&$ GGr*cB|j}|t|tr||ur |jj}g}t j |j D]D}|j|jdDcgc]}|jsd|c}Fdj|}tj|d|d|d|d|d|jd |j}|t|tryyyycc}w#t$rd}YfwxYw) N z z z is out of scope and cannot be used here. Use return values, explicit Python locals or TensorFlow collections to access it. Please see https://www.tensorflow.org/guide/function#all_outputs_of_a_tffunction_must_be_return_values for more information. z was defined here: z The tensor z cannot be accessed from z, because it was defined in z, which is out of scope.)rr6r^r: traceback format_listget_user_framesextendsplitstripr?r=rInaccessibleTensorErrorrt)rr inner_graphtbtensor_traceback_listframelinetensor_tracebacks r+_validate_in_scopezFuncGraph._validate_in_scopemsG,,K  !ji&H   >yy"""#%  ,,R-?-?-AB Me ! ( ().T):Kdjjl2dVK M M"YY'<= ,,j( j,-=,>? #.maybe_convert_to_tensors:fe +z%/M$$U+ lr*)r ryrn_capture_by_ref)rrrrrs ` r+'_experimental_capture_side_input_by_refz1FuncGraph._experimental_capture_side_input_by_refsDx  " Vm ))99 %z3K r*c.|jjS)z?Order list of tuples containing external and internal captures.)rnby_val_capture_tuplesrs r+rzFuncGraph.capturess  " " 8 88r*c|jjt|||d|jj |y)zCapture a specific tensor and utilize the provided placeholder. Args: tensor: Tensor to captures. placeholder: Provided placeholder for the tensor. FrrrrN)rnrrrbrrrrs r+ add_capturezFuncGraph.add_capturesA ** vJ +  KK{#r*cT|jjt|||dy)z!Replace already existing capture.FrN)rnrrr s r+replace_capturezFuncGraph.replace_captures+** vJ +r*c|jjt|d|j||t|||y)arReplaces existing capture `tensor` with a deferred capture `closure`. Caution: It is the caller's responsibility to make sure that, after calling this function, the TypeSpec of the `inputs` (i.e. internal placeholders) and the `_captured_inputs` (i.e. external captures) of a concrete function that wraps this function graph are still compatible. Thus user should pairing usage of this function with `ConcreteFunction.set_external_captures` to make sure the order still matches. For example, ``` # concrete_fn._captured_inputs == [tensor1, tensor2, tensor3] # concrete_fn.inputs == [placeholder1, placeholder2, placeholder3] # replace external capture `tensor2` with a deferred_capture, i.e., a # closure, `closure2` concrete_fn.graph.replace_capture_with_deferred_capture(tensor2, closure2, placeholder2, some_spec, some_default) concrete_fn.set_external_captures([tensor1, closure2, tensor3]) ``` Args: tensor: Tensor already captured. closure: function which takes no arguments, to be evaluated at function call time, returning a nest of tensors compatible with `spec`. spec: nest of TypeSpec for the value to capture. placeholder: the internal placeholder corresponding to the captured `tensor`. default_value: optional value to use in environments that cannot safely evaluate closure. F)r)rrrN)rnpoprr)rrrrrrs r+%replace_capture_with_deferred_capturez/FuncGraph.replace_capture_with_deferred_capturesHJ 6 e<   vJ# !!r*c\t|jjjS)z+External tensors captured by this function.)listrnby_val_externalvaluesrs r+external_captureszFuncGraph.external_captures$ ''77>>@ AAr*c\t|jjjS)z=Placeholders in this function corresponding captured tensors.)r(rnby_val_internalr*rs r+internal_captureszFuncGraph.internal_captures#r,r*c\t|jjjS)zDOrdered nest of tensors whose placeholders will be fed at call time.)r(rnby_ref_externalr*rs r+deferred_external_capturesz$FuncGraph.deferred_external_captures(r,r*c\t|jjjS)z>r*c|jSr1)rnrs r+function_captureszFuncGraph.function_captures7s  " ""r*cnd|_t|tr|g}|jj |y)aMarks this FuncGraph as unsaveable. Any attempts to export this FuncGraph will raise an error with the specified message. Args: error_message: List or string containing the error message to be raised when saving this FuncGraph to SavedModel. FN)rr6r2rupdate)r error_messages r+mark_as_unsaveablezFuncGraph.mark_as_unsaveable;s0DN-%$om}-r*c|jS)z+Returns whether this FuncGraph is saveable.)rrs r+saveablezFuncGraph.saveableJr7r*c|jS)zAReturns set of errors preventing this FuncGraph from being saved.)rrs r+ saving_errorszFuncGraph.saving_errorsOs   r*ct|stdj||j t d|jj |y)z?Add a function to call when this graph exits the default scope.zfn is not callable: {}NzAttempting to add a scope exit callback, but the default graph is not the context scope graph. Did you forget to call 'with graph.as_default(): ...'?)callable TypeErrorformatr RuntimeErrorr)rfns r+_add_scope_exit_callbackz"FuncGraph._add_scope_exit_callbackTsT B< .55b9 :: !!)  , -- %%b)r*)NNNN)NNN)NNNNT)NNNNNTNNr1))r%r&r'r(rarrrrrpropertyrtsetterrrrrrrrr rrrrrrr!r#r&r+r/r2r4r6r9r=r?rArH __classcell__)rs@r+r^r^s#< $*."& b&H? #',0*. {8z&AP;   (:: + + + +  ;  ; 9 9. >>   >   DLH,8GG4>,0 ((-**) 66  # # % !=!=>//  3 3 5(-(D(D(I(I(KJ% 88','D'D*$''-***'==%'*" .1 . g.22 B $ ,D (2D /,< )-> * -  . .,D (2D /,< )-> * - .22 B $ ,D (2D /,< )-> * -  ,D (2D /,< )-> * -  . .s`C>G+GE5E  #G G+ %E22G5G7F4$G4%G GGG($G+c !ttjsJt|| | ttsJrt j } nt j} j5| 5tj} | j}| jd||}i}| rt|||\}}n||}}tj||g}|j!||g_t%j&_j"D];}|j*t,j.k(s!j0j3|=tj4}t7|||t7||f_t;j<|t;j>|dd}t;j<|t;j>|dd}fd}tAjB\}}|i|}tEjF|}t;jH||d}t;j<|t;j>|dd}t;j<|t;j>|dd}tK|||||| j|g}tMjN||gD]}t|tPjRrYjTjWtY|jZd}t]|dk\sJ|d }|d|j_|vt|tjs|j_||j`zt;j>jbdz_|_2jfjifd t?jdDj(_5ddddddr6jlji| jn| jp_8S#1swYKxYw#1swYOxYw) aG Returns a `FuncGraph` generated from `python_func`. Args: name: an identifier for the function. python_func: the Python function to trace. args: the positional args with which the Python function should be called; ignored if a signature is provided. kwargs: the keyword args with which the Python function should be called; ignored if a signature is provided. signature: a possibly nested sequence of `TensorSpecs` specifying the shapes and dtypes of the arguments. When a signature is provided, `args` and `kwargs` are ignored, and `python_func` is traced with Tensors conforming to `signature`. If `None`, the shapes and dtypes are inferred from the inputs. func_graph: Optional. An instance of FuncGraph. If provided, we will use this graph else a new one is built and returned. add_control_dependencies: If True, automatically adds control dependencies to ensure program order matches execution order and stateful ops always execute. arg_names: Optional list of argument names, used to give input placeholders recognizable names. op_return_value: Optional. A Tensor. If set and `python_func` returns Operations, those return values will be replaced with this value. If not set, returning an Operation triggers an error. collections: a dictionary of collections this FuncGraph should start with. If not specified (None), the FuncGraph will read (but not write to) the outer graph's collections that are not allowlisted, and both read and write to the outer graph's collections that are allowlisted. The current allowlisted collections are the global variables, the local variables, and the trainable variables. Defaults to None. capture_by_value: An optional boolean. If True, the func graph will capture Variables by value instead of reference. By default inherit from outer graphs, and failing that will default to False. create_placeholders: An optional boolean. If True, then func graph will create placeholders for the inputs as graph ops. If False, the input args and kwargs will be treated as the input placeholders. Returns: A FuncGraph. Raises: TypeError: If any of `python_func`'s return values is neither `None`, a `Tensor` or a `tf.experimental.ExtensionType`. N)rrwT)rQexpand_compositesc |yOt|tjr5tj|g5t j }dddn0t|t js tj|}rj|}|S#1swYxYw#ttf$r/tdtdt|jdwxYw)z'Converts a function output to a Tensor.NzTo be compatible with tf.function, Python functions must return zero or more Tensors or ExtensionTypes or None values; in compilation of z, found return value of type z), which is not a Tensor or ExtensionType.)r6r Operationrridentityr TensorArrayconvert_to_tensor_or_compositer<rDr2rJr%mark_as_return)xadd_control_dependenciesdeps_ctxop_return_value python_funcs r+convertz(func_graph_from_py_func..convert s   $As}})E % %qc * 2  1! 2 2!-99: 003! "  # #A & h 2 2 I& ++.{+;*<=#Aw//01   sB1B'B$'>C%FrSc3DK|]}|j|ywr1)r)r3rdrMs r+r5z*func_graph_from_py_func..Ns) = 1s )9r6r7r8r^r AutomaticControlDependenciesrNullContextmanagerrrget_variable_scope use_resourceset_use_resource_create_placeholdersrrDrrbrrjrkrBrresourcerhrrr[rerrVflattenrunwrapr!convert_variables_to_tensors map_structurecheck_func_mutationr flatten_with_variablesrBaseResourceVariablernr%rrrUrr/r4rfrcrrrdops_which_must_runcollective_manager_ids_used)rPrhargskwargs signaturerMrerXrgrrwcreate_placeholdersdeps_control_manager current_scopedefault_use_resource func_args func_kwargsinput_trace_typesrMrQfunc_args_beforefunc_kwargs_beforerir/ original_func func_outputsrbrresource_placeholderrfs ` `` ` @r+func_graph_from_py_funcrs8p oz'8'8 9J?J 9 +8HJJ J ** *,IIK113w9 4w9"557M(55""4( df3D&)Li#Vi"--y+.FG)44i5MNJ%4$I$I$KJ!  4 foo %**..s34#99; ' y4E G& +< >-?J),, Y$7 .. [D9  0$**;7A} 9[9L">>|LL%%7L %% Y$7 I'' [D9 K(*I>KL  C.CC D//33BszzNEJ7|q   &qz  '  *+ c:,, - c  ---  1 1T1K K%1J!667 &88Jow9w9r%%&:&M&MN88* }w9w9w9w9s3Q CQ H#Q1BQ QQ QQ(cBtd|jDS)z2Checks whether a device stack contains a callable.c3FK|]}t|jywr1)rC_device_name_or_function)r3rs r+r5z,device_stack_has_callable.._s# , t,,- ,s!)any peek_objs) device_stacks r+rQrQ]s%  ,((* , ,,r*c tj||dttj|dtj|dD] \}}||us yy#t$rYywxYw)zGReturns true if n1 and n2 are different (using `is` to compare leaves).Tr\F)rassert_same_structurer<ziprs)n1n2arg1arg2s r+ has_mutationrdsur2> ll2. ll2.0jdD 4     sA A+*A+c t||f||fsyt|dt|d|}tj|} |j|i|j }|j|i|j }t|t|k(sJ|D cgc]} t|| || r| } } dj| } t||d| #t $r} t||d| d} ~ wwxYwcc} w)z9Checks that the arguments to a function are not modified.Nr'r%z should not modify its Python input arguments. Check if it modifies any lists or dicts passed as arguments. Modifying a copy is allowed.z, zv should not modify its Python input arguments. Modifying a copy is allowed. The following parameter(s) were modified: ) rrr r~bind argumentsrDr<rr?) old_args old_kwargsnew_args new_kwargsr func_namer~ old_bound new_boundearg_name modified_argschangess r+rwrwts: x,x.D E dNGD*d,KL)""4() ; 7J7AAI 7J7AAI Y3y> )) )( i)9X+> ?- IIm $'i[ ,<@mA@   y-4 PPr*ctjd}tjt||}tj||}|j }tj t j|}|dgt|jz}g}t||jD]8\} } |j| | j|} |j| :i} tt|jj!D],\} } |j| | j|} | | | <.t|| fS)z;Create placeholders given positional args and keyword args.T)is_legacy_signatureN)rrrDrget_placeholder_mappingrrrorU componentsrupdate_naming_scoperrsortedmappingitems)r|r}rXrQarg_trace_typeskwarg_trace_typesplaceholder_mappingplaceholder_contextrrPtrace_type_argrrtrace_type_kwargs r+rqrqsU 77 ))%+7HI/ ++F4EF)AAC"== 24_7788I)!)_-G-GH"dN++D1 223FGK [!" + #V,=,E,E,K,K,M%N O$d ++D1"445HIK#K$ y ; &&r*cb|jjtj|y)ayRemoves reference cycles in `func_graph` FuncGraph. Helpful for making sure the garbage collector doesn't need to run when the FuncGraph goes out of scope, e.g. in tests using defun with @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True). Args: func_graph: A `FuncGraph` object to destroy. `func_graph` is unusable after this function. N)rnclearrdismantle_graph)rMs r+dismantle_func_graphrs$ %%'j!r*c||_yr1) _name_stack)rM name_scopes r+override_func_graph_name_scopers %*r*rI)NNTNNNNTr1)Fr(rtypingrrrrrptensorflow.core.functionr tensorflow.core.function.capturertensorflow.python.eagerr r ,tensorflow.python.eager.polymorphic_functionr tensorflow.python.frameworkr r rrrrrrr7rtensorflow.python.opsrrrrtensorflow.python.saved_modelrtensorflow.python.typesrtensorflow.python.utilrrrrrr r! tensorflow.python.util.tf_exportr" GraphKeysGLOBAL_VARIABLESLOCAL_VARIABLESTRAINABLE_VARIABLES _VARSTORE_KEY_VARSCOPESTORE_KEYrrr$r[Graphr^contextmanagerrrrQrrwrsrVrqrrr)r*r+rss+::/>++O983..6+<1+7206()'20/-16MM""MM!!MM%%  %% >f>9=59B2J #+W * W *,W *t5.5.%3CII%>5.5.x'+'+59&*,0(,-104AH,  G@ "Q2'< "&r*