AVh@dZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd l m Z dd l mZdd l mZdd l mZdd l mZddlmZddlmZddlmZddlmZddlmZddlmZedgej<ej>dddd ddZ edgej<d dZ!dZ"dZ#dZ$y)!z*Cond function for Control Flow Operations.)context)eager_function_run)dtypes)indexed_slices)ops)tensor) tensor_util) array_ops)cond_v2)control_flow_ops)control_flow_util)math_ops) tf_logging)core) deprecation)dispatch)nest) tf_exportcond)v1NzBfn1/fn2 are deprecated in favor of the true_fn/false_fn arguments.fn1fn2c  || td|}n | td|| td|}n | tdt|s tdt|s tdtjrt |||||St j tjrtj||||Stj|d|g5t|tr td tj||\}}tj |d } tj |d } tj |d }||| | |fD]1} | j"j$j'| j"3tj(|| d} | j+| j-|\} }| t/d| j1|| j3tj(|| d} |j+|j-|\}}| t/d|j1||j3|st5| } t5|} t7j8| |d|s t/dt7j>|d}t7j>|d}tA||D]\}}t|tBjDrt|tBjDsJ|jFjH|jFjHk7sjt/d|jFjJd|jFjJdtA||Dcgc]}tjL|d}}t7j:tjNt7j>| d|}| jP|jPk(sJ| jP\tjRtjTjV| tjRtjTjV|t7jX| |d}|s t5|}|cdddS#| j3wxYw#|j3wxYw#tt.f$rt7j:t<| |t7j:t<|| t7j8| |dn9#t$r}td|d}~wt.$r}t/d|d}~wwxYwYwxYwcc}w#1swYyxYw)ah Return `true_fn()` if the predicate `pred` is true else `false_fn()`. `true_fn` and `false_fn` both return lists of output tensors. `true_fn` and `false_fn` must have the same non-zero number and type of outputs. **WARNING**: Any Tensors or Operations created outside of `true_fn` and `false_fn` will be executed regardless of which branch is selected at runtime. Although this behavior is consistent with the dataflow model of TensorFlow, it has frequently surprised users who expected a lazier semantics. Consider the following simple program: ```python z = tf.multiply(a, b) result = tf.cond(x < y, lambda: tf.add(x, z), lambda: tf.square(y)) ``` If `x < y`, the `tf.add` operation will be executed and `tf.square` operation will not be executed. Since `z` is needed for at least one branch of the `cond`, the `tf.multiply` operation is always executed, unconditionally. Note that `cond` calls `true_fn` and `false_fn` *exactly once* (inside the call to `cond`, and not at all during `Session.run()`). `cond` stitches together the graph fragments created during the `true_fn` and `false_fn` calls with some additional graph nodes to ensure that the right branch gets executed depending on the value of `pred`. `tf.cond` supports nested structures as implemented in `tensorflow.python.util.nest`. Both `true_fn` and `false_fn` must return the same (possibly nested) value structure of lists, tuples, and/or named tuples. Singleton lists and tuples form the only exceptions to this: when returned by `true_fn` and/or `false_fn`, they are implicitly unpacked to single values. This behavior is disabled by passing `strict=True`. Args: pred: A scalar determining whether to return the result of `true_fn` or `false_fn`. true_fn: The callable to be performed if pred is true. false_fn: The callable to be performed if pred is false. strict: A boolean that enables/disables 'strict' mode; see above. name: Optional name prefix for the returned tensors. Returns: Tensors returned by the call to either `true_fn` or `false_fn`. If the callables return a singleton list, the element is extracted from the list. Raises: TypeError: if `true_fn` or `false_fn` is not callable. ValueError: if `true_fn` and `false_fn` do not return the same number of tensors, or return tensors of different types. Example: ```python x = tf.constant(2) y = tf.constant(5) def f1(): return tf.multiply(x, 17) def f2(): return tf.add(y, 23) r = tf.cond(tf.less(x, y), f1, f2) # r is set to f1(). # Operations in f2 (e.g., tf.add) are not executed. ``` Nz:cond(): 'true_fn' and 'fn1' may not be set simultaneously.z#cond(): 'true_fn' argument requiredz;cond(): 'false_fn' and 'fn2' may not be set simultaneously.z$cond(): 'false_fn' argument requiredz'true_fn' must be callable.z'false_fn' must be callable.rz!'pred' must not be a Python bool.switch_t)nameswitch_fpred_id)branchz#'true_fn' must have a return value.rz$'false_fn' must have a return value.T)expand_compositesz7Incompatible return types of 'true_fn' and 'false_fn': z8Incompatible return values of 'true_fn' and 'false_fn': z9'true_fn' and 'false_fn' must return at least one result.zIOutputs of 'true_fn' and 'false_fn' must have the same type(s). Received z from 'true_fn' and z from 'false_fn'.) structure flat_sequencer )- TypeErrorcallablerexecuting_eagerly_eager_cond_implementationutilEnableControlFlowV2rget_default_graphr name_scope isinstanceboolr switchr identityopgraphprevent_fetching CondContextEnterBuildCondBranch ValueError ExitResultExit_UnpackIfSingletonrassert_same_structure map_structure_cast_indexed_slice_indicesflattenzip tensor_libTensordtype base_dtypermerge_convert_flow_to_tensorarray outer_contextadd_to_collection GraphKeys COND_CONTEXTpack_sequence_as)predtrue_fnfalse_fnstrictrrrp_2p_1pivot_1pivot_2r context_t orig_res_tres_t context_f orig_res_fres_fe res_t_flat res_f_flatxypairmergess J/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/cond.pyrr's%d _  F HHG 9 ::_  G IIH : ;; '  1 22 (  2 33  %dGXvt LL c3356 ??4(D 99 ~~dFTF+\$ 9 ::&&tT2HC  :6G  :6G   d 3DWgt42 iioo&&vyy12!,,T71EIoo#33G<j%  >??5!nn!,,T71EIoo#33H=j%  ?@@5!nn %j1j%j1j L   Z4P   E GGetQQ\\s%C U73AR)5(U7AR> (U7 S!B0U7A U7U2:C%U7)R;;U7>SU7AU/T21U/2 U(;U  U(U##U((U/+U7.U//U77Vc"t|||d|S)a Return `true_fn()` if the predicate `pred` is true else `false_fn()`. Note: This op is automatically used in a `tf.function` to convert Python if-statements when the predicate is a `tf.Tensor`, unless `autograph=False` is explicitly specified in `tf.function` args. For example, the following are equivalent: >>> @tf.function ... def fun1(x,y): ... if x > 0: # AutoGraph converts if-statement to tf.cond(). ... z = y+1 ... else: ... z = y-1 ... return z >>> print(fun1(tf.constant(7), tf.constant(3)).numpy()) 4 >>> @tf.function ... def fun2(x,y): ... pred = x > 0 ... true_fn = lambda: y+1 ... false_fn = lambda: y-1 ... return tf.cond(pred, true_fn, false_fn) # Use tf.cond() explicitly. >>> print(fun1(tf.constant(7), tf.constant(3)).numpy()) 4 For more information, see [tf.function and AutoGraph guide]( https://www.tensorflow.org/guide/function#autograph_transformations). `true_fn` and `false_fn` both return lists of output tensors. `true_fn` and `false_fn` must have the same non-zero number and type of outputs. **WARNING**: Any Tensors or Operations created outside of `true_fn` and `false_fn` will be executed regardless of which branch is selected at runtime. Although this behavior is consistent with the dataflow model of TensorFlow, it has frequently surprised users who expected a lazier semantics. Consider the following simple program: >>> x, y = tf.constant(2, dtype=tf.int32), tf.constant(4, dtype=tf.int32) >>> z = tf.multiply(x, y) >>> r = tf.cond(x < y, lambda: tf.add(x, z), lambda: tf.square(y)) >>> print(r.numpy()) 10 If `x < y`, the `tf.add` operation will be executed and `tf.square` operation will not be executed. Since `z` is needed for at least one branch of the `cond`, the `tf.multiply` operation is always executed, unconditionally. Note that `cond` calls `true_fn` and `false_fn` *exactly once* (inside the call to `cond`, and not at all during `Session.run()`). `cond` stitches together the graph fragments created during the `true_fn` and `false_fn` calls with some additional graph nodes to ensure that the right branch gets executed depending on the value of `pred`. `tf.cond` supports nested structures as implemented in `tensorflow.python.util.nest`. Both `true_fn` and `false_fn` must return the same (possibly nested) value structure of lists, tuples, and/or named tuples. Singleton lists and tuples form the only exceptions to this: when returned by `true_fn` and/or `false_fn`, they are implicitly unpacked to single values. Note: It is illegal to "directly" use tensors created inside a cond branch outside it, e.g. by storing a reference to a branch tensor in the python state. If you need to use a tensor created in a branch function you should return it as an output of the branch function and use the output from `tf.cond` instead. Args: pred: A scalar determining whether to return the result of `true_fn` or `false_fn`. true_fn: The callable to be performed if pred is true. false_fn: The callable to be performed if pred is false. name: Optional name prefix for the returned tensors. Returns: Tensors returned by the call to either `true_fn` or `false_fn`. If the callables return a singleton list, the element is extracted from the list. Raises: TypeError: if `true_fn` or `false_fn` is not callable. ValueError: if `true_fn` and `false_fn` do not return the same number of tensors, or return tensors of different types. Example: >>> x = tf.constant(2) >>> y = tf.constant(5) >>> def f1(): return tf.multiply(x, 7) >>> def f2(): return tf.add(y, 3) >>> r = tf.cond(tf.less(x, y), f1, f2) >>> # r is set to f1(). >>> # Operations in f2 (e.g., tf.add) are not executed. >>> print(r.numpy()) 14 T)rJrKrLr)r)rIrJrKrs r^cond_for_tf_v2r`sH dGht$ OOcXt|ttfrt|dk(r|dS|S)Nrr)r+listtuplelen)ress r^r8r8Zs(dE]#CA q6M Jractj|}tj|}|t |t j rt |t j s tdtj}|rtjdtjd tj|||||tj|SStj|d|g5|r|}n|}|s t|}|cdddS#|tj|wwxYw#1swYyxYw)z0Special cases for `cond` when executing eagerly.NziWhen running tf.cond on a parallel device, 'true_fn' and 'false_fn' must be decorated with `tf.function`.zIt looks like tf.function behavior was disabled, perhaps using tf.config.run_functions_eagerly. Parallelized tf.cond requires tf.function to work. This primitive will override the disable.Fr)rconvert_to_tensorr constant_valuer+rPolymorphicFunctionr#rfunctions_run_eagerlyloggingwarningrun_functions_eagerlyr r*r8)rIrJrKrLrpred_constant_valuerkresults r^r&r&as6  t $$#2248  w 8 8 9(D$<$<= M NN.DDFoo KL,,U3H __T7Hd ;  *001FG + ftf -  #F+   *001FG + s-D5 D<D9<Ect|tjrt|tjr|jj|jjk7rgt j |jtj|_ t j |jtj|_ yyyy)aaCast IndexedSlice.indices from int32 to int64 where necessary. If `a` and `b` are both IndexedSlices, and their indices have different dtypes, then cast both their dtypes to `int64` (modifies `a` and `b` in-place). Otherwise, does nothing. Args: a: A value, which may be an IndexedSlices. b: A value, which may be an IndexedSlices. N) r+r IndexedSlicesindicesr@rcastrint64_indices)abs r^r;r;sN001N001iioo(qyy&,,7AJqyy&,,7AJ)22ra)NNFNNN)NNN)%__doc__tensorflow.python.eagerr,tensorflow.python.eager.polymorphic_functionrtensorflow.python.frameworkrrrrr>r tensorflow.python.opsr r r r r'rtensorflow.python.platformrrltensorflow.python.typesrtensorflow.python.utilrrr tensorflow.python.util.tf_exportradd_dispatch_supportdeprecated_argsrr`r8r&r;rar^rs1+K.6+<3+)2;*<(.+'6  vh  N 5   D DN 6b bPbPJ%P8ra