BVhTdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z dd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZdZGddeZGddeZGddeZ GddeZ!GddejDZ# dEdZ$dZ%d Z&dFd!Z'd"Z(d#Z)d$Z*d%Z+d&Z,d'Z-d(Z.d)Z/ie j`d*e jbd+e jdd,e jfd-e jhd.e jjd/e jld0e jnd1e jpd2e jrd.e jtd3e jvd4e jxd5e jzd6e j|d7e j~d8e jd9e jd:e jd;e jde jd?e jd@e jdAe jdBe jdCe jdDi ZLy)GzPython front-end supports for functions. NOTE: At this time, functions are experimental and subject to change!. Proceed with caution. N)attr_value_pb2) function_pb2)pywrap_tf_session)context) c_api_util)dtypes)graph_to_function_def)ops)tensor) array_ops)resource_variable_ops)variable_scope)compat)function_utils) tf_contextlib) tf_inspectTceZdZdZdZdZy)Defunu Obsolete. Slated for deletion. Please use tf.function instead. Known feature gaps while migrating to tf.function (could be outdated): - tf.function doesn’t support Send/Recv capability since it doesn’t share rendezvous with the main graph but always creates a new one. - tf.function doesn’t support custom gradient function directly, instead you need to define the function inside a tf.custom_gradient wrapper together with the gradient function. - Unlike Defun, Keras layers used inside a tf.function need to be created only once to avoid variable recreation. - Defun respects the device assignments and applies them to the function body but tf.function needs it to be done manually. - Defun might prune out unused ops automatically but tf.function doesn't. Limitations of Defun: - Original source locations are not preserved so errors do not include full/valid stack traces. - Only supports linear sequence of arguments and return values, putting the burden on the caller to pack/unpack everything across a Defun boundary into tuples (as opposed to passing list and dict-like structures directly). - Does not support overloading or late-bound specializations. - Has its own way for defining gradient overrides which does not follow current conventions. - Cannot support imperative control flow or automatic control dependencies. - Does not reflect statefulness in the graph and has a calling convention that differs from how more modern tools interact. - Is only compatible with graph building mode. Decorator used to define TensorFlow functions. Use this decorator to make a Python function usable directly as a TensorFlow function. The decorated function must add ops to the default graph and return zero or more `Tensor` objects. Call the decorator with named arguments, one for each argument of the function to decorate, with the expected type of the argument as value. For example if the function to decorate accepts two `tf.float32` arguments named `x` and `y`, call the decorator with: @Defun(tf.float32, tf.float32) def foo(x, y): ... When you call the decorated function, it adds the `call` ops to the default graph. In addition, it adds the definition of the function into the default graph. Because the addition of the function into the graph is deferred, the decorator can be used anywhere in the program. Any variables created inside of the function are hoisted into the outer graph. Note that the variables are created in the variable scope that was active during the first call to the function. Subsequent function calls will refer to the same set of variables. Definitions of functions in a graph are frozen as soon as the graph is used to create a session. However, new functions and new calls to existing functions may be added to the graph, with the new functions themselves becoming immediately frozen. Example, but also see the [How To on functions](link_needed). ```python # Defining the function. @tf.Defun(tf.float32, tf.float32) def MyFunc(x, y): return x + y, x - y # Building the graph. a = tf.constant([1.0]) b = tf.constant([2.0]) c, d = MyFunc(a, b, name='mycall') ``` c||_|jdd|_|jdd|_|jdd|_|jdd|_||_y)aCreate a `Defun` decorator. Args: *input_types: A list of `tf.DType` **kwargs: Optional keyword arguments, including func_name - (optional). A python string, the name to use to declare this `Function` in the graph. grad_func - (optional). A function implementing the gradient of the function-to-register. This is must be a `_DefinedFunction` object. The gradient function must satisfy the criterion defined in function.proto:GradientDef. python_grad_func - (optional). A function implementing the gradient of the function python-side. This function must take the current op and the gradients w.r.t. its outputs, and return the gradients w.r.t. the inputs. That is it must implement the interface expected by `tf.RegisterGradient`). This will be called by tf.gradients to add the gradient ops to the graph. At most one of grad_func and python_grad_func can be specified. out_names = (optional). A list of strings, one per output tensor. shape_func - (optional). A function taking the op and returning a list of static shapes to set for the function's outputs. func_nameN grad_funcpython_grad_func out_names) _input_typespop _func_name _grad_func_python_grad_func _out_names _extra_kwargs)self input_typeskwargss T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/function.py__init__zDefun.__init__ys^<$Djjd3DOjjd3DO#ZZ(:DADjjd3DODc t|std|dtj|}|js |j r)td|d|j d|jdt |j}|}|jrd}|j}tj|r |dz}|dd}|jrt |j}||ks||kDrtd |d |d |d |d t|||j|j|j|jfd|ji|j S|dk(rJ|dk(rEt|gg|j|j|jfd|ji|j St#|||j|j|jfd|ji|j S)N Function z must be a callable.zJFunctions with argument defaults or keywords arguments are not supported. z has defaults z and keywords .i@BzVThe number of tf.function input types is not compatible with the allowed arguments of z. The tf.function have z7 input types, while the python function allows minimum z and maximum z arguments.rr)callable ValueErrorr getargspeckeywordsdefaultslenargsvarargsismethodr_DefinedFunctionrrrrr _OverloadedFunction)r!funcargspecmin_argsmax_argsargnamesnums r$__call__zDefun.__call__s D> 4&(<= >>##D)G7++  v^G,<,<+=^    a ! "" 7<< HHh||H4 !mh!"h  !! "c x3> $$(6)@F??GjIj  -. .       // //   OO      1}Q  B // //   OO               //      r&N)__name__ __module__ __qualname____doc__r%r<r&r$rr-sIV# J?r&rc"eZdZdZdgZdZdZy)_DefinedFunctionDeleterz'Unregister function from eager context.namec||_yNrD)r!rDs r$r%z _DefinedFunctionDeleter.__init__s DIr&cv tj|jy#t$rYyt$rYywxYwrF)rremove_functionrD TypeErrorAttributeErrorr!s r$__del__z_DefinedFunctionDeleter.__del__s8   dii(      s" 888N)r=r>r?r@ __slots__r%rMrAr&r$rCrCs/h)  r&rCceZdZdZ ddZedZedZedZedZ dZ ed Z ed Z ed Z ed Zed ZdZdZdZdZdZdZy)r4a_DefinedFunction encapsulates a function definition and its properties. Attributes: name: The function name. definition: The definition of this function. A FunctionDef proto. cached_definition: Same as definition. Needed to match AtomicFunction API. grad_func_name: If not None, the name of this function's gradient function. python_grad_func: A python callable implementing the gradient of the function python-side. Nc  4||_||_||_||_||_||_||_| |_| |_|jt|_| |_ | |_ d|_ d|_ d|_i|_t!j"j$} | r| dnd|_d|_t+|t,t.fsJ||_t3t5|Dcgc]}|t5|kr||nd|zc}|_ycc}w)a4Creates _DefinedFunction. Args: func: A python callable which constructs a tf function body. argnames: A list of strings for function argument names. input_types: The function's argument types. Can be a tuple, list of tf data types. func_name: The function name. Defaults to None, in which derives from 'func'. grad_func: This function's gradient function, if not None. Defaults to None. python_grad_func: A python callable implementing the gradient of the function python-side. out_names: An optional list of strings for the function return value names. shape_func: An optional function mapping an op to a list of static output shapes. capture_by_value: Boolean (defaults to False). If True, captured values will be copied into the function body. allowlisted_stateful_ops: A set of ops that if stateful we ignore and copy into the function body, when `capture_by_value` is True. capture_resource_var_by_value: Boolean (defaults to True). If False, captured resource variable returns the handle instead of value. **kwargs: The keyword arguments. **kwargs is passed to every call site of this function. Raises: ValueError: The function definition is invalid. Nzarg%d)_funcrrrrr _shape_func_capture_by_value_allowlisted_stateful_opsset_capture_resource_var_by_valuer _definition_c_func_function_deleter_sub_functionsr get_default_graph _device_functions_outer_to_inner_caller_device_op_def isinstancelisttuple _arg_typesranger0 _arg_names)r!r6r:r"rrrr shape_funccapture_by_valueallowlisted_stateful_opscapture_resource_var_by_valuer# device_funcsis r$r%z_DefinedFunction.__init__sVDJ#DDODO-DDO!D-D%=D" %%-'*ud$*GD'DDDL!DD((*KKL/;,r*D DL kD%= 11 1!DO %c+&6 79'(#h-&7x{gkJ9DO9s-Dc:|j|jS)zFunction name.)_create_definition_if_neededrrLs r$rDz_DefinedFunction.nameTs %%' ??r&c|jSrF) definitionrLs r$cached_definitionz"_DefinedFunction.cached_definitionZs ??r&c|j|jrtj5}|jj 5}t j ||tj}t j|}|jtj|tj5tj r9tj"|t%|j&j(|_dddddddddS|j,S#1swY'xYw#1swY+xYw#1swYSxYw)zFunction definition proto.N)rmrYr tf_buffergetc_apiTF_FunctionToFunctionDefr FunctionDef TF_GetBufferParseFromStringras_bytesr init_scoperexecuting_eagerlyadd_c_functionrC signaturerDrZrX)r!bufr6fdef proto_datas r$roz_DefinedFunction.definition^s %%' ||    ! 'S \\    '4  ( (s 3))+$))#.*   vz: ;~~ '((*$$T*'>..%%('d$ ' ' 'k     ' ' ' ' 'ks=E A8EAD9EE9E >EE EEc:|j|jSrF)rmr_rLs r$ _signaturez_DefinedFunction._signatureqs%%' <<r&cR|jrJt|tsJ||_y)z1Specifies the gradient function of this function.N)rr`r4)r!rs r$ set_grad_funcz_DefinedFunction.set_grad_funcvs'  i!1 22 2DOr&cJ|jr|jjSdS)z*Returns the name of the gradient function.N)rrDrLs r$grad_func_namez_DefinedFunction.grad_func_name|s$(??4??  <||jA|jB|jD|jF|_|D]-}|jjH|jK||/|jM|jjNjP|jjNjR|jjT|_+|js"djY||jVg|_|j|jjN_|jjZr/|jjZ|jjN_.|jjN|_/n|jFr-|jFD cgc]} tajb| c} ng} |jjZxsd} |j<je5} tgjh| ||jdud|jBD cgc]} | jkc} |jDD cgc]} | jkc} | ggd| }dddtmjn||_|jq||jrjN|_/|jr%|j|j^j6k(s0Jtajt|j^j6|_|jADcgc]&}|jvr|j6|jxf(c}|_=ycc}wcc} wcc} wcc} w#1swY xYwcc}w)zrXrYextendr GraphKeys_VARIABLE_COLLECTIONSappendvs _VARSTORE_KEYr\get_collection_reffunc_graph_from_py_funcrRrercrrTr^rUrW extra_inputsr _functionsr[r get_func_namerrD_parse_kwargs_as_attrsr _c_graphr get_operationsinputsoutputsrattrCopyFrom_create_hash_strr} input_arg output_argnode_def _hash_strjoinr@ descriptionr_rryrsrtTF_GraphToFunction_wrapper _as_tf_outputrScopedTFFunction _set_c_attrsroas_str _is_statefultyper)r! variable_keys parent_graphkeyr temp_graphbase_func_name kwargs_attrkx output_namesrc_graphtc_funcops r$rz2_DefinedFunction._create_definition_if_needed_impls- #t||'? M<<=))*((*L=JL69\ , ,S 11LOL)      '!%!?!?&*&I&I KJ$00D$//D n%33DJJ?n 54??#7#778(N4;M;MNK   .DD   # # %      OO %d:! a ))+a.9:,,    $ $ . .    $ $ / /1A1A1J1JLdn __((NDNN#CD(,d  %   151C1C"".%%//dl48??Cavq)C.0JJ&&.$k    " " $ 11   OOt # (2(9(9 :1Q__  :(2(:(: ;1Q__  ;        00Hdl  $__..dl $,,"3"3333 -- (9(9:%/$=$=$?. __77BGG,.DiLpD ; ;  0.s<<TT).T)T.T)>T$ T)!+T6 T))T3c|jD]b\}}|j}|jj5}t j |t j||ddddy#1swYoxYw)zSets `attrs` as attributes of self._c_func. Requires that self._c_func is not None. Args: attrs: a dictionary from attribute name to attribute proto value N)itemsSerializeToStringrYrsrtTF_FunctionSetAttrValueProtorr)r!attrsrD attr_value serializedr6s r$rz_DefinedFunction._set_c_attrssx"KKM7j//1j <<   7 **4t1D+5 777 777s +A77B c> tjfd  fd fd}|D]} |j|D]} |jt|dD]} |j |j ||j  t|jt|jD]-} | |j|j/jddS)aCreates an 8-character string unique to this input. Args: input_arg: the input_arg field of an OpDef (e.g. self._definition.signature.input_arg) output_arg: the output_arg field of an OpDef (e.g. self._definition.signature.output_arg) node_def: the node_def field of a FunctionDef (e.g. self._definition.node_def) Returns: The unique string for this input cTjtjd|zy)Nz%x)updaterry)nhashers r$ update_numz5_DefinedFunction._create_hash_str..update_num%s mmFOOD1H-.r&cpt|jtj|yrF)r0rrry)srrs r$ update_strz5_DefinedFunction._create_hash_str..update_str(s$Q mmFOOA&'r&cFt||D] }| yrF)r0)slistrrrs r$ update_strsz6_DefinedFunction._create_hash_str..update_strs,s%U!1 r&c|jSrFrG)rs r$z3_DefinedFunction._create_hash_str..7s AFFr&)rN) hashlibsha1rsortedrDrinputr0r hexdigest) r!rrrradefrrrrrs @@@r$rz!_DefinedFunction._create_hash_strs\\^F/( +'')*++'')*+H"2 32!''QVVaff~2!1 166!9..012 2    bq !!r&cz|jtjr.tjj|jn|j ||j jD]}|j||jr|jj|yy)z$Adds this function into the graph g.N) rmrr{add_function_defro _add_functionr[values_add_function_recursiver add_to_graph)r!gfs r$rz_DefinedFunction.add_to_graphCs%%'  " oo((9ood ' ' )#"#  oo""1%r&c |jtj|Dcgc]}tj|c}|jz}t |j g|i|\}}t|tjsJt|d||j|j|}t|t|jk7rr?r@r%propertyrDrprorrrrrrrrmrrrrr<rAr&r$r4r4s  $ %(,-1N9`       $    = = " "       / c.J7 ,"\&(r&r4c,eZdZdZ ddZdZdZy)r5z_OverloadedFunction encapsulates an overloaded function. _OverloadedFunction maintains a mapping from input types to instantiated _DefinedFunction in self._overload. Nc ||_||_||_|t|tsJ||_||_||_||_i|_ y)aCreates _DefinedFunction. Args: func: A python callable which constructs a tf function body. argnames: A list of strings for function argument names. func_name: The function name. Defaults to None, in which derives from 'func'. grad_func: This function's gradient function, if not None. Defaults to None. python_grad_func: A python callable implementing the gradient of the function python-side. out_names: A list of strings for the function return value names. **kwargs: The keyword arguments. **kwargs is passed to every call site of this function. Raises: ValueError: The function definition is invalid. N) rR _argnamesrr`r5rrrr _overload)r!r6r:rrrrr#s r$r%z_OverloadedFunction.__init__tsT6DJDNDO   96I JJ JDO-DDODDNr&c@t|}|jj|}|s|j}|dj ||g}t |j |j||d|jfd|ji|j}|j}|jrc|jjDcgc]!}tj |j"#}}|jj%||z|_ ||j|<|Scc}w)zInstantiate this function given input argument types. Args: input_types: A list of data types for the inputs. Returns: _DefinedFunction for the given input types. Nrr)_type_list_to_strrrsrrr4rRrrrr rDrrrrDTyper instantiate)r!r"rdefinedrDr output_typess r$rz_OverloadedFunction.instantiates K (Cnn  %G  __d xxs $ ** ..      OO     g ,,a  +2*<*<*G*G %&FLL   "__889E:FG$dnnS N s?&Dc Dg}t|}t|D]o\}}tj|}t |t j std|dt|d|j|j|||<q|j||i|S)NzExpected a Tensor but got z with type r)) ra enumerater rr` tensor_libTensorr,rrdtyper)r!r1r#r"rkrs r$r<z_OverloadedFunction.__call__sK :DD/A   "a :,, -5aS DG9ANOO!d1g  )4  K ($ 9& 99r&)NNNN)r=r>r?r@r%rr<rAr&r$r5r5ls& $ #J(T :r&r5ceZdZdZfdZedZejdZ d dZ dfd Z ddZ edZ dd Zd Zd ej"fd ZxZS) _FuncGraphaA helper for constructing a function. _FuncGraph overrides ops.Graph's create_op() so that we can keep track of all inputs into every op created inside the function. If any input is from other graphs, we keep track of it in self.capture and substitute the input with a place holder. Each captured input's corresponding place holder is converted into a function argument and the caller passes in the captured tensor. c`tt| |i|||_||_||_d|_tj|_ tj|_ |jj|_||_g|_g|_i|_g|_g|_g|_y)NT)superrr%rTrUrW_building_functionr r\ _outer_graphrget_variable_scope_vscope custom_getter_old_custom_getterrDrr _capturedr extra_args extra_vars)r!rDrgrhrir1r# __class__s r$r%z_FuncGraph.__init__s *d$d5f5-D%=D"*GD'"D--/D((*DL"ll88DDIDKDLDNDDODOr&c|jS)z2The graph active when this _FuncGraph was created.)r rLs r$ outer_graphz_FuncGraph.outer_graphrr&c#K|j}tj5tjj}ddd ||_tj5|tj_ddd|j||_tj5tj_dddy#1swYxYw#1swYaxYw#1swYyxYw#||_tj5tj_dddw#1swYwxYwxYww)aReturns a context manager that specifies the resource container to use. Overridden from `tf.Graph` to update both the init_scope container and the present inner container. This is necessary to make sure setting containers applies correctly both to created variables and to stateful ops. Args: container_name: container name string. Returns: A context manager for defining resource containers for stateful ops, yields the container name. N) _containerr rzr\)r!container_nameoriginal_containeroriginal_init_containers r$ containerz_FuncGraph.containers   C # 5 5 7 B BCE&do >> <-;*< OO*do >> E-D*EECC<< EE+do >> E-D*EEEs|!ECE C8&C C8E1C, ECE C)%C8,C51E8ED7. E7E <EEc |jj5|jjt j ||||||||  } |j j| t| tjr%|jr| jcdddS| cdddS#1swYyxYw)zA custom variable getter.)rr initializerreuse trainable collections use_resourceN) r  as_defaultr  get_variabler_get_default_variable_storerrr`r BaseResourceVariablerWvalue) r!getterrDrrrrrrrr#vars r$getvarz_FuncGraph.getvar#s(    % % ' LL % % ( ( * !!# & %c ooS! S/DD E  - - yy{'()sBB7,B77Cc t|D]B\} } t| tjs| j|us/|j | || <Dt t|#||||||||S)N)rr"rDrop_defcompute_device) rr`r EagerTensorgraphcapturerr_create_op_internal) r!op_typerrr"rDrr)r*rkrrs r$r.z_FuncGraph._create_op_internalMsz&!$1 As '177$+>LLOq $ T 6 % 7 ''r&c|j|jvr|j|jS|jr|j|S|j ||S)zDAdds the given tensor to this graph and returns the captured tensor.)refrrT_add_tensor_and_parents_capture_tensor_as_extra_input)r!r rDs r$r-z_FuncGraph.capturedsV zz|t~~% ^^FJJL ))    ) )& 11  0 0 >>r&c|jjDcgc]\}}|j|fc}}Scc}}w)z%Pairs of tensors and captured tensor.)rrderef)r!rvs r$capturesz_FuncGraph.capturesns3(,~~';';'= >tq!QWWYN >> >s>cB|jj|tjd5t j |j |j|}dddt|tjr|j}|rb|j}nQ|jjj5}tj ||j#}dddrejjj5}tj$||j#t'j(|ddd|j*j||j,|j/<|j0j|t3|r4tjd5t j4|cdddS|S#1swYxYw#1swYxYw#1swYxYw#1swYyxYw)NrrD)rrr control_dependenciesr placeholderr get_shaper`r+ _handle_datarr,rrsrtGetHandleShapeAndTyperSetHandleShapeAndTyperryrrr1r_is_guaranteed_constguarantee_const)r!r rDph handle_datars r$r3z)_FuncGraph._capture_tensor_as_extra_inputssV$ ! !$ '=  ,,f..0t =b=&#//*''k !335 << $ $ &J'11'282F2F2HJ J 88   "Bg ##GR-=-=-?$*OOK$@ BB KKr#%DNN6::< OO2F#  # #D )-((,--i3==JJ BB--s/1G/%G<9H H/G9<H HHcj|j|j}|j|jSrF)_add_op_and_parentsrr value_index)r!r rs r$r2z"_FuncGraph._add_tensor_and_parentss+ ! !&)) ,B ::f(( ))r&rctj|}|jr4||jvr&t d|j d|j d|j dvr&t d|j d|j d|jDcgc]}|j|}}|j|j ||jDcgc]}|jc}|j |jj|}t|j|jD]"\}}||j|j!<$|Scc}wcc}w)Nz%Cannot capture a stateful node (name:z, type:z ) by value.) Placeholder PlaceholderV2z#Cannot capture a placeholder (name:rDrr))r _get_op_defrrUr,rDrrr2r.rrrrrrr1) r!rr)rro captured_opr captured_ts r$rEz_FuncGraph._add_op_and_parentssM " . .r 2F 2T%C%CC >rwwiH!wwi{4 55 4 4 r?r@r%rrrcontextmanagerrr'r.r-r7r3r2r rrE __classcell__)rs@r$rrs D  E EH   (\   '.? ? ?@*CMMr&rc |stj|}t||| | } | j5t j |5||| _||| _||| _| dgt|z} t||| D]9\} }}tj||| }| jj|;tj d| j"5|| j}dddg}n:t%|t&t(fs|f}t+d|Drt-d|d|Dcgc]}t j.|}}|Dcgc]#}|j0| ur| j3|n|%}}|| _dddddd| S#1swYxYwcc}wcc}w#1swY)xYw#1swY| SxYw)aReturns a _FuncGraph generated from `func`. Args: func: A Python callable which constructs a TF function body. The arguments must correspond to `arg_types`. Returns a value or list/tuple of values. No returned value can be None. arg_names: A sequence of strings for the function argument names. arg_types: A sequence of the function's argument types. name: The function name. If None, the name is derived from `func`. capture_by_value: boolean. If True, captured values will be copied into the function body. device: device name or function. colocation_stack: A colocation stack (list) the _FuncGraph should use. container: A container name the _FuncGraph should start with. collections_ref: A reference to a collections dict the _FuncGraph should use internally. arg_shapes: A sequence of the function's argument shapes. allowlisted_stateful_ops: A set of ops that if stateful we ignore and re-create. capture_resource_var_by_value: Boolean (defaults to True). If False, captured resource variable returns the handle instead of value. Returns: A _FuncGraph. Raises: ValueError: if func returns None. Nr9)r c3$K|]}|du ywrFrA.0rs r$ z*func_graph_from_py_func..s (1Q$Y (sr(z can not return None.)rrrr r device _collectionsr_colocation_stackr0rr r;rrrrr'r`rarbanyr,rr,r-r)r6 arg_names arg_typesrDrgrWcolocation_stackrr arg_shapesrhri func_graphargnameargtypeargshape argholderrrs r$rrsP   ' ' -D$ 02J79*)! 6 2)!" /j'j#%5j"6C N*j),Iy*(M*$'8''xgNiy)*  2Z->-> ?)j''(g)g$ /* ( ( (9TF*?@AA189As$$Q'9G9!)*z(Az!!!$qH!G! JS)!)!T 1))(:!O)!)!)!T sUG BF9#F#3A F9>F/F9 (F4 F9G#F, (F99G >GGct|tjryGddt}d}t gdtj ffd }t g}||j dg}|r|j}|jr.||j rj|j M|j|j ||j rj|j |j||j d|j jD]4}|j |vs|j||j d6|r|j vS) aoDetermines whether `tensor` is guaranteed to be a constant. A tensor is guaranteed to be a constant if either it was produced by a `GuaranteeConst` op or if all of its children are guaranteed to be constants. Args: tensor: The tensor for which to determine const-ness. Returns: True if `tensor` is guaranteed to be a constant, False otherwise. Fc,eZdZdejfdZy)"_is_guaranteed_const..Workrc ||_||_yrF)rleaving)r!rrhs r$r%z+_is_guaranteed_const..Work.__init__sdgdlr&N)r=r>r?r rr%rAr&r$Workrfs3==r&ric4|jjdk(S)NGuaranteeConst)rrrs r$rz&_is_guaranteed_const.."s2;;>>5E#Er&rc\|jxrtfd|jDS)Nc3:K|]}|jvywrFrl)rUinp constantss r$rVzA_is_guaranteed_const..all_inputs_const..'sFSSVVy0Fs)rall)rrps r$all_inputs_constz._is_guaranteed_const..all_inputs_const$s# 99 FFBIIFFFr&)rhT) r`r r+objectrVrrrrhaddrr) r riis_guaranteed_constrrvisitedstackworkrorps @r$r@r@ s0( V F"g)G3==G G'  5 ) *% 99;D || $'' " dgg KK477#mmDGG LLdggt,-ww~~2 w  T#&&%012  i r&ct|t|jk7r0tdt|jddt|dd|jdd}t j }|j }||}t|fi|}|jDcgc]!}tj|j#}}|j|t|||||} | jrDt| jdk(r| jd } | | fSt| j} | | fS| } | | fScc}w) aAdds a node calling a function. This adds a `call` op to the default graph that calls the function of signature `sig`, passing the tensors in `inputs` as arguments. It returns the outputs of the call, which are one or more tensors. `sig` is OpDefArg.a `_DefinedFunction` object. You can pass an optional keyword parameter `name=string` to name the added operation. You can pass an optional keyword parameter `noinline=True|False` to instruct the runtime not to inline the function body into the call site. Args: sig: OpDefArg. The signature of the function. *inputs: arguments to the function. **kwargs: Optional keyword arguments. Can only contain 'name' or 'noinline'. Returns: A 2-element tuple. First element: a Tensor if the function returns a single value; a list of Tensors if the function returns multiple value; the Operation if the function returns no values. Second element: the Operation. Raises: ValueError: if the arguments are invalid. z Expected rz arguments, got r)rDNrJr*r)r0rr,rr r\rDrrrrrr.rarrb) sigrr#rDrrrrrrrs r$rr>s8< [C && yS]]!3A 66FF Aa) ** FD !$ !hh) \ D  5f 5%03?1&,,qvv&?,?f|$eCQ"ZZ 2::! JJqMc b. "** c b. C b.@s"&Ec Xd}|jjDcgc]}|j}}td|jjD}|jj}d}|jjDcgc]}|j}}t |||||||} t r&|j} tj| } ntj|} tj| || _ g| _|j| _| Scc}wcc}w)zCreates a _DefinedFunction initialized from a FunctionDef proto. Args: fdef: a FunctionDef grad_func: a _DefinedFunction or None Returns: A _DefinedFunction representing fdef Nc3ZK|]#}tj|j%ywrF)ras_dtyper)rUargs r$rVz#_from_definition..s$E$'foochhEs)+)r}rrDrbrr4is_ossrrtTF_FunctionImportFunctionDef+TF_FunctionImportFunctionDefNoSerializationrrrYrr_) rrr6r~r:r"rrrresultrrs r$_from_definitionrrs  $"&..":": ;3chh ;( ;E+/>>+C+CEE+nn!!)#'>>#<#<=Csxx=)= D(KI,i 9& '')J  / / ;F  > >t DF..vyA&.&>>&. -+<>s D"D'c  |js|jsgS|jDcic]}|jj|c} |jD]T}|j vrt d|jd||j vs;t d|j d|tjd}tjt}|jD]C}|j ||j<||j j|jE|jDcgc]}||jj| }}|st d|i}|ru|j}|jj}|j||} ||r| sJt|| } | ||<|j fd||D|ru|jScc}wcc}w)aCreates _DefinedFunctions initialized from a FunctionDefLibrary proto. This method handles assigning the correct gradient functions to each function. Args: lib: a FunctionDefLibrary Returns: A list of _DefinedFunctions Raises: ValueError: `lib` is invalid zFunctionDefLibrary missing 'z' FunctionDef cyrFrArAr&r$rzfrom_library..sr&z7FunctionDefLibrary contains cyclic gradient functions! )rc3(K|] }| ywrFrA)rUrfuncss r$rVzfrom_library..s7aq7s)functiongradientr}rD function_namer, gradient_funcr defaultdictrarrrsrrr) librr func_to_grad grad_to_funcsgdefready initializedrDgrad defined_funcrs @r$ from_libraryrs  cll I25 >4>>   $ >% <<.ae# 5aoo5FG''*e- ..e# 5aoo5FG''*e- .. .((6,))$/-llAd'+'9'9L##$$$$%,,T-?-?@A || |DNN4G4G'H'Pd %    B3%H JJ+ 99;D >>  D ??<- .DD kT#DD9L$K LL7=#677     U ?* sG;=HHct|trtj|St|trtj|St|t rtj|St|t r)tjtj|Std|dt|d))Creates an AttrValue for a python object.b)rk)rr Attribute z' must be bool, int, float, or str. Got r)) r`boolr AttrValueintfloatstrrryr,r attr_namer$s r$_get_experimental_kwarg_as_attrrst  # #e ,,%  # #e ,,%  # #e ,,%  # #fooe&< == z)-!!%e Q0 11r&ct|tr)tjt j |St d|dt|d)rrrz must be str. Got r))r`rrrrryr,rrs r$_get_kwarg_as_str_attrrsEs  # #fooe&< == z),>tE{m1M NNr&c fi}|jdd}|"tjt||d<tjd|d<|jdd}|jdd}|tjt||d <tjt||d <d t j j vr%t j j d |d <n*tjd |zj |d <t|j}|D]I}|jdrt|||||<||=*|dk(s|dk(s5t|||||<||=K|rtd|jd|S)z)Parses **kwargs into a node's attributes.noinlineNr _noinlineT_disable_call_shape_inferencecompiledseparate_compiled_gradients _XlaCompile_XlaSeparateCompiledGradients _XlaScopez function_%sr experimental_ _implements _referencezUnknown keyword arguments: r))rrrrr r\_attr_scope_mapencoderakeys startswithrrr,)rr#rrrr kwargs_keysrs r$rrs % ZZ D )( '11DNCE+,:+C+Cd+K%'( ZZ D )( & +H$ O )33d8nEE--;-E-E * +.-E )*c++-===002BB;OeK)33 Y & . . 02eKV[[]#+ c ~~o&23s DeCj +  !4)#vc{;eCj + 26;;=/C DD ,r&cftj}t|tr |jSgS)zReturns the captured variables by the function. Returns: If the default graph is being used to define a function, the returned list of variables are those created inside the function body so far. Otherwise, returns an empty list. )r r\r`rrrs r$get_extra_varsrs+ !: << Ir&cftj}t|tr |jSgS)a$Returns the captured input tensors by the function. Returns: If the default graph is being used to define a function, the returned list of tensors are those accessed inside the function body but defined outside the function body so far. Otherwise, returns an empty list. )r r\r`rrrs r$get_extra_inputsr*s+ !: >> Ir&cftj}t|tr |jSgS)a>Returns the corresponding function arguments for the captured inputs. Returns: If the default graph is being used to define a function, the returned list of place holders are those used inside the function body corresponding those returned by get_extra_inputs(). Otherwise, returns an empty list. )r r\r`rrrs r$get_extra_argsr:s+ !: << Ir&ctd|Dr<|Dcgc] }|tvs |}}td|dtjddj d|DScc}w)Nc3,K|] }|tvywrF _DTYPE_TO_STRrTs r$rVz$_type_list_to_str..Ks/A- /szUnsupported dtypes z" in `types`. Supported dtypes are r)rRc3.K|] }t|ywrFrrTs r$rVz$_type_list_to_str..Ps1aq!1s)rZrr,rr)typestype_unsupported_typess r$rrJsy///,1P5U-5OPP *+<*=>6%**,-Q0 11 151 11 Qs A'A'f16f32f64i32i8u16u32u64i16rc64c128i64rqi8qu8qi16qu16qi32b16f8e5m2f8e4m3fn f8e4m3fnuz f8e4m3b11fnuz f8e5m2fnuzi4u4) NFNNNNNNTrF)Mr@rrtensorflow.core.frameworkrrtensorflow.python.clientrrttensorflow.python.eagerrtensorflow.python.frameworkrrr r r rtensorflow.python.opsr r rrtensorflow.python.utilrrrrrrsrrCr4r5Graphrrr@rrrrrrrrrrfloat16float32float64int32uint8uint16uint32uint64int16int8string complex64 complex128int64rqint8quint8qint16quint16qint32bfloat16 float8_e5m2 float8_e4m3fnfloat8_e4m3fnuzfloat8_e4m3b11fnuzfloat8_e5m2fnuzint4uint4rrAr&r$rs 42?+2.=+<+76)10- pFpf f 0qvqh `:&`:F__J"&-2#'-1&*,0'+59:>Wt0 f1h&R=@ 1O&R    2 NNE NNE NNE LL%   LL$   MM5  MM5 MM5 LL% KK MM3 e v LL% KK  LL%!" MM5#$ MM6 NNF MM6 OOU  * L  L KK LL$9 r&