AVhvdZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZdZGddZGddZdZdZej*dZdZdZy)zHUtilities for managing state of v1 control flow for computing gradients.) constant_op)dtypes)ops) tensor_util) array_ops)control_flow_ops)control_flow_util)control_flow_v2_func_graphs)default_gradient)gen_data_flow_ops)gen_resource_variable_ops)resource_variable_opsc r|j}tjj}| |jnd}t j d}|d|fvr|j }|td|d|jd|jj}tj||r||z}nUtj|}|9td|d|jd|jd |d |jd ||z}tj|j| }|d|fvr|S) aCalculate a max_size for use by stack ops inside an XLA while_loop. Args: value: The value inside the while_loop forward context. Used for printing error messages. while_ctxt: The forward context inside which value resides. This does not always match the value's immediate context, as `value` may be inside e.g. a cond context inside the while_loop. Returns: A tensor containing the `max_size` to feed to a Stack initializer. Raises: ValueError: If `value` is nested inside a `while_loop` that either lacks a `maximum_iterations` parameter, or the `maximum_iterations` parameter: - is inside a `while_loop` that is a parent of the calling context, and - cannot be evaluated at graph build time to a constant. Nz1Cannot create a gradient accumulator for tensor 'z^' inside XLA while_loop because maximum_iterations was not passed to the tf.while_loop call ('z').z4' inside XLA while_loop. maximum_iterations tensor 'z' for while_loop context 'z' must be statically known (e.g. a constant value or known shape dimension), or be defined at or outside the while loop context 'z' (currently defined in ') stop_ctxt)namerget_default_graph_get_control_flow_contextrconstantmaximum_iterations ValueErroroputilIsContainingContextrconstant_valueGetContainingWhileContext outer_context) value while_ctxt value_name curr_ctxtcurr_ctxt_namemax_sizemax_iter max_iter_ctxtconst_max_iters X/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/control_flow_state.py&_GetMaxSizeFromNestedMaximumIterationsr)!s;*zz*##%??A)%.%:9>>.  ! !! $( 4++,,H /9*// K LL KK99;M  =9(h #11(;n         !" ". h//  I7JE 4++J /c"eZdZdZdZedZedZedZedZ edZ edZ ed Z ed Z ed Zed Zed ZedZedZej&dZddZ ddZdZy)_GradLoopStateaThe state used for constructing the gradient graph for a while loop. We create a _GradLoopState for each while loop in forward and its corresponding while loop in backprop. This gives us access to both the forward and the backprop WhileContexts. During the construction of gradient graph, any time when we detect a forward value that is needed for backprop, we create a history accumulator and add it to `history_map`. Any time when we backprop a loop switch op (in _SwitchGrad), we add the grad merge op in `switch_map`. cTd|_d|_d|_d|_d|_d|_d|_i|_i|_g|_ g|_ t|j|_ t|j|_||_|r |j }n#t#|ds t%d|j&}|j(j+5|r|j-|j/|\}}|r|j1ddd||_|_|r|j3j4|j7|}|j8}|j-t;j<|j>|j@|jB|jD|j4||_|jG||}|jjI|||_|j1y|r|j-t;j<|j>|j@|jB|jD|j4||_|jjI||_|r|j1yy#1swYxYw)Nrz[Failed to call gradients on a while loop withoutproperly serializing graph via MetaGraphDef)rparallel_iterations back_prop swap_memoryr grad_state)%_outer_grad_state_forward_context_forward_index _forward_sync _grad_context _grad_index _grad_sync _history_map _switch_map _unused_exits_deferred_exitslist loop_exits_forward_loop_exitslen_pending_exits_countforward_contexthasattrrr_graph as_defaultEnterAddForwardLoopCounterExitAddNamerAddForwardAccumulator grad_contextr WhileContextrr.r/r0AddBackpropAccumulatedValueAddBackpropLoopCounter) self forward_ctxtouter_grad_stateouter_forward_ctxtcnt forward_index history_cntouter_grad_ctxtreal_cnts r(__init__z_GradLoopState.__init__vs!D!DDDDDDODDDD#L$;$;NOc= ! " )D'D  *$::3?k(55o+88)<<*>> **"..   d"==k3Oh++BB $&d   "+88)<<*>> **"..   d++BB !d ! S""s 9JJ'c|jS)z#The grad loop state for outer loop.)r2rOs r(rQz_GradLoopState.outer_grad_states  ! !!r*c|jS)z#The while loop context for forward.)r3rZs r(rBz_GradLoopState.forward_contexts   r*c|jS)zThe loop index of forward loop.)r4rZs r(rTz_GradLoopState.forward_indexs   r*cd|jtjd5tjd|_ddd|jj |j |jjj|j|jS#1swYixYw)zA control trigger node for synchronization in the forward loop. One main use is to keep the push ops of a stack executed in the iteration order. Nf_syncr) r5rcontrol_dependenciesrcontrol_trigger_set_control_flow_contextr3r4r_add_control_inputrZs r( forward_syncz_GradLoopState.forward_syncs !  # #D )M-==8LM 2243H3HI //0B0BC    MMs B&&B/c|jS)z,The corresponding WhileContext for gradient.)r6rZs r(rKz_GradLoopState.grad_context   r*c|jS)z The loop index of backprop loop.)r7rZs r( grad_indexz_GradLoopState.grad_index   r*c|jtjd5tjd|_ddd|jj |j |jjj|j|j jr/|j jj|j|jS#1swYxYw)zA control trigger node for synchronization in the grad loop. One main use is to keep the pop ops of a stack executed in the iteration order. Nb_syncr_) r8rr`rrarbr6r7rrcr AddInnerOprZs r( grad_syncz_GradLoopState.grad_syncs   # #D )J*::IJ oo//0B0BC ,,T__=   ) ) ((33DOOD ?? JJs C++C4c|jS)z9The map that records all the tensors needed for backprop.)r9rZs r( history_mapz_GradLoopState.history_maps   r*c|jS)z;The map that records all the Switch ops for the while loop.)r:rZs r( switch_mapz_GradLoopState.switch_maprir*c|jS)zThe list of "unused" exits.)r;rZs r( unused_exitsz_GradLoopState.unused_exits rfr*c|jS)zThe list of "deferred" exits.)r<rZs r(deferred_exitsz_GradLoopState.deferred_exitss   r*c|jS)z&The list of exits of the forward loop.)r?rZs r(forward_loop_exitsz!_GradLoopState.forward_loop_exitss  # ##r*c|jS)z1The number of exits we expect to see but haven't.rArZs r(pending_exits_countz"_GradLoopState.pending_exits_counts  $ $$r*c||_y)zSet the pending count to cnt.Nry)rOrSs r(rzz"_GradLoopState.pending_exits_count!s !$Dr*c|jjj5tjj }tj d5|r|jtj|5tj|js%tjdtj}nt!||j"}t%j&||j(j*d}ddd|r|j-|j"j/}|j"j0}tj2|j}||j"k(r||j"jt%j4|||} |j"j-|j6jj9| jnt;|t<j>stAd|z|rh|jBjt%j4|||} |jBj-| jjE|n8|jt%j4|||} |j-|jFj9| j|j6jjHdj} | jj9| |cdddcdddS#1swYBxYw#1swYnxYw dddy#1swYyxYw)aAdd an accumulator for each forward tensor that is needed in backprop. This is added to the forward loop at the first time when a tensor in the forward loop is used by backprop gradient computation loop. We create an accumulator that accumulates the value of tensor at each iteration. Called in the control flow context where gradients() is called. The pseudocode is: ``` acc = stack(); while (_pivot) { acc = stack_push(acc, value); } ``` We make sure that the stack push op in one iteration is executed before next iteration. This is achieved by adding a control edge from `forward_index.op.inputs[0].op` to the push op, and another control edge from the push op to either `forward_index.op` or `forward_sync`. Args: value: The source tensor in forward that is to be accumulated. dead_branch: True iff the tensor is on a dead branch of a cond. Returns: The stack that contains the accumulated history of the tensor. Raises: TypeError: For internal errors involving the value condition context. ValueError: If `value` is inside a XLA scope and a valid max size for the stack can't be found. Nf_acc)r$ elem_typer)r0z#value_ctxt is not a CondContext: %sr)%r4graphrErrrr`rF colocate_withrIsInXLAContextrrrrint32r)rBr stack_v2dtype base_dtyperHAddValuer0GetOutputContext stack_push_v2rTrc isinstancer CondContext TypeErrorrrbrdinputs) rOr dead_branchr"r$acc enter_acc swap_enabled value_ctxtpushadd_ops r(rJz$_GradLoopState.AddForwardAccumulator&sD    " " - - /6'')CCEi  # #D )4  //    u % Q$$UXX."++B =H=t++-H!**5;;+A+AQ# Q  .. ((11#6 ++77 **5884 -- -    $ $ &"00L:$    # # %      2 2477 ;J(8(D(DEAJNO O   $ $ * * ,$225l>yI-    " " $ 5 8  #?? 9& T !))22:>*&0d # r*N)F)__name__ __module__ __qualname____doc__rXpropertyrQrBrTrdrKrhrmrorqrsrurwrzsetterrJrMrr*r(r,r,hsC T"l " " ! !                         $ $ % %$$Xv/4/b6r*r,c`eZdZdZdZdej fdZdZdZ dZ dZ d Z d Z d Zy ) _ControlFlowStatez9Maintain the mapping from the loops to their grad states.ci|_y)N)_maprZs r(rXz_ControlFlowState.__init__s DIr*rc|rDtj|r/|j}|j}|r&|j }ntj|}|r|j j |Sy)zDReturn the grad state for this op if it's in a forward loop context.N)r IsLoopExitrrGetWhileContextrr)rOrbeforerPs r( GetGradStatez_ControlFlowState.GetGradStatesc $//"%113l!//l #335 ))"-l YY]]< (( r*cg}|jjD]}|jD]~}||jdk(s|xjdzc_|j|vr|j j ||jdk(sd|j|j |jjD]$}||jdk(sd||j<&|S)aNProcess all the "unused" loop exits. The "unused" exits of the loops are added to `unused_exits`. An exit is unused if its pending_count is 0. If there is an exit with real gradient, all these deferred exits will enter the backprop loop with zero gradient. Otherwise, they will enter the backprop loop with None. As an example, people often write: ```python v1, _ = tf.while_loop(p, b, [x1, x2]) result = gradients(v1, x1) ``` The exit node for x2 is not included by the betweenness analysis. But we need to backprop x2 if x2 is involved in computing v1. Args: pending_count: The number of backprop inputs for every op. to_ops_set: The set of ops for ys in gradients(ys, xs) Returns: The set of unused loop exits that we know at this point we need to backprop. rr) rvaluesrwrrzrsappendextendrB loop_enters)rO pending_count to_ops_setr>r1ys r(ProcessUnusedLoopExitsz(_ControlFlowState.ProcessUnusedLoopExitss2Jii&&( " ,,7!  ! #  ( (A - ( TT #  # # * *1 -  + +q 0   j55 6 7))55"!  ! # !- " " r*cb|j||}|r|jjyy)z0Enter the WhileContext for gradient computation.N)rrKrFrOrrr1s r(EnterGradWhileContextz'_ControlFlowState.EnterGradWhileContext%s.""2v.J##%r*cb|j||}|r|jjyy)z/Exit the WhileContext for gradient computation.N)rrKrHrs r(ExitGradWhileContextz&_ControlFlowState.ExitGradWhileContext+s.""2v.J""$r*ctj|}|jj|}||j}|r|j}d}|r|jj|}t ||}||j|<|j D]G}|j|vs|j|j|j|jIyy)aAdd the grad state for the while loop that op belongs to. Note that op is an Exit, and this method must be called in the control flow context where gradients() is called. Note that this method modifies `between_op_list` and `between_ops`. N) rrrrrr,rwraddr) rOrbetween_op_list between_opsrPr1rRrQ loop_exits r(AddWhileContextz!_ControlFlowState.AddWhileContext1s''+L|,J'55 /??A 99==);<!,0@Aj *dii "44/) <<{ * //),, '   ./r*c|j}|jj}|j}|r|j }d}|r|j j |}|r,|jr`|jjtj|j|j}|jj|S|jjtj|d}|jj|j!|}|j} | j|j#||} tj| |j}| j|S|jr,tj|j|j}|Stj$|d}|S)aCreate zeros_like gradient for a loop exit. If the result of a loop variable is not used but is involved in computing the result of some needed loop variable, we create a zero-valued tensor that is fed as gradient for the Exit node of that loop variable. Note that val.op is an Exit, and this method must be called in the control flow context where gradients() is called. Args: val: The output tensor of an Exit op. Returns: A zero tensor of the same shape of val. NFoptimize)rrrrrrris_fully_definedrKrFrzerosdimsrrHshape_internalrJrM zeros_like) rOval val_shaperPrRrQresultshape history_shaperV real_shapes r(ZerosLikeForExitz"_ControlFlowState.ZerosLikeForExitLs I66335L%33-==?'9:  # # % %%++-;%%**,. M) ""((*((u=""'')(>>uE *77%AA 5" SYY7 M  # # %; M%%cE: Mr*ctj|ry|jjr"t j |j |Stj|}tj|}|jj|}| t||S|j}tj|j |d}|j}|j!r|j"t$j&k(r>t j(t+j,|t/j0|} n,t3j4d|j6|j"} |rW|j8j|j:j<} |j>} tAjB| | d| z } | S|r|j:} |j>} |jDjGtAjB|jHd| d| z }t jJ|d } |jDjM|jNjQ|| jNjQ|n7|jGt jJ|d } |jM|jRjM|jU| | } |jRjG|jW| | |}t j(||j"} | S) a\Create zeros_like for the specified output of an op. If op is in a while loop that is part of gradients(), this method must be called in its grad loop context. Args: op: A tensorflow operation. index: the index for a specific output of the op. Returns: A zero tensor of the same shape of op.outputs[index]. Ntensorr_rrrrrFr)r),r IsLoopSwitchrbuilding_functionrroutputsIsSwitchrrr ZerosLikerrconvert_to_tensorrrrrresourcerrvariable_shaper get_zeros_dtyperrrrorrrrrrrFrrrHrrbrKrJrM)rOrindexrrPr1op_ctxtrrrrr zeros_shapehistory_zeros_shapes r(ZerosLikeV1WhileLoopz&_ControlFlowState.ZerosLikeV1WhileLoops   xx!!  ! !"**U"3 44--#K''+L|,J r5 !!**,G   5 1 AC MMOE  foo % ! 0 0 5"22379%%auzzK %%))',,*;*;<!44VTB1v:N: M5 ||##%11"))A,26889F D..sUC ""$ ((1009 ..sUC  ""$&<< ;=0##%445H5@+Oeucii0f Mr*cn|jjD]\}}|jjD]\}}|jjd|jjdk(s;|jjdj }|jjdj }|jrb|jjtjd||}tj|}|jjn|jj}|r|j|jjdj} | jd} t!j"| d} t!j$| }|r|j|jjtj|}|jj|jj'd|y)acPerform postprocessing at the end of gradients(). We have created the gradient graph at this point. So this function can be used to perform any postprocessing on the gradient graph. We currently perform the following postprocessing: 1. Patch the gradient graph if the output of a loop variable doesn't depend on its input. rr)rrFrN)ritemsrqrrrrrrKrFrrr_NextIterationrHrrrr _update_input) rO_r1b_mergerrgrad_val next_grad_valrV enter_grad_op enter_grad grad_shapes r(PostProcessingz _ControlFlowState.PostProcessings*5 :"--3355*!W ::  Q 7::#4#4Q#7 7**##A&,,%**##A&002%  # # %  # # ) ) +"++AU%HH,;;HEM  # # ( ( *)55CCO##%#JJ--a033M&--a0J"11*uMJ z2H""$  # # ) ) +,;;HEM  # # ( ( * ** " "1m 4;55r*N)rrrrrXr Operationrrrrrrrrrr*r(rrsAA S]] &P& % /65nEN'5r*rcd}|D]k}tj|s| t}|r2tj|5|j |||dddY|j |||m|S#1swYyxYw)aCCreate the state for all the while loops involved in one gradients(). We create a _ControlFlowState when there are while loops involved in gradients(). In gradients(), control flow logic is only invoked when the _ControlFlowState is not None. Note that this method modifies `between_op_list` and `between_ops`. N)rrrrrr)rrcolocate_gradients_with_ops loop_staters r(MaybeCreateControlFlowStaters* Eb r  &( $   r " G  $ $R+ F G G ""2 DE   G Gs A55A> c|j|}|j}|r(|j}|j}t j |j d|d|z }tj|}|jtjk(r]tj|g5tjtj |t#j$|cdddStj&|d}tj|g5tj||jcdddStj(|dS#1swYxxYw#1swYyxYw)zBranch of ZerosLike for TF1.rrrNFr)rrrrrswitchrridentityrrrrr`rr rr rrr) rrrrrr switch_valpivotrs r( _ZerosLikeV1r s1 5#  ( ( *' <rs~O3.+3+2;=23;7 DND G5G5V.54 ;; 50#r*