o ?e@@sLdZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd l m Z dd l mZdd l mZdd l mZdd l mZddlmZddlmZddlmZddlmZddlmZddlmZedgdejedddd      d$ddZ edgdejd%ddZ!ddZ"d d!Z#d"d#Z$dS)&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.fn1fn2FcCs|dur|dur td|}n|durtd|dur&|dur#td|}n|dur.tdt|s6tdt|s>tdtrJt|||||SttrYt ||||St |d|gt |t rltd t ||\}}tj|d d } tj|d d } tj|d d }||| | |fD] } | jj| jqt j|| dd} z| | |\} }| durtd| |W| n| wt j|| dd}z|||\}}|durtd||W|n|w|st| } t|}z tj| |ddWnLttfyStt| |tt||z tj| |ddWn'ty=}ztd|d}~wtyP}ztd|d}~wwYnw|s[tdtj|dd}tj|dd}t ||D]-\}}t |t!j"rt |t!j"sJ|j#j$|j#j$krtd|j#j%d|j#j%dqnddt ||D}tt j&tj| dd|}| j'|j'ksJ| j'durt(tj)j*| t(tj)j*|tj+| |dd}|st|}|WdS1swYdS)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.Zswitch_t)nameZswitch_fZpred_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'.cSsg|] }t|dqS)r)r merge).0pairr[/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/tensorflow/python/ops/cond.py szcond..)Z structureZ flat_sequencer), TypeErrorcallablerZexecuting_eagerly_eager_cond_implementationutilZEnableControlFlowV2rZget_default_graphr name_scope isinstanceboolr switchr identityopgraphZprevent_fetchingZ CondContextZEnterZBuildCondBranch ValueErrorZ ExitResultZExit_UnpackIfSingletonrZassert_same_structureZ map_structure_cast_indexed_slice_indicesflattenzip tensor_libZTensordtypeZ base_dtyperZ_convert_flow_to_tensorarrayZ outer_contextZadd_to_collectionZ GraphKeysZ COND_CONTEXTZpack_sequence_as)predtrue_fnfalse_fnstrictrrrZp_2Zp_1Zpivot_1Zpivot_2rZ context_tZ orig_res_tZres_tZ context_fZ orig_res_fZres_feZ res_t_flatZ res_f_flatxyZmergesrrr r'sR        &cCst|||d|dS)aReturn `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 >>> 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. >>> 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)) >>> 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. >>> r.numpy() 14 T)r5r6r7r)r)r4r5r6rrrr cond_for_tf_v2sdr;cCs&t|ttfrt|dkr|dS|S)Nrr)r'listtuplelen)resrrr r.Zsr.c Cst|}t|}|durMt|tjrt|tjstdt }|r)t dt dzt ||||W|durAt |SS|durLt |wwt|d|g|r\|}n|}|set|}|WdS1sqwYdS)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)rZconvert_to_tensorrZconstant_valuer'rZGenericFunctionr"rfunctions_run_eagerlyloggingwarningZrun_functions_eagerlyr r&r.)r4r5r6r7rZpred_constant_valuer@resultrrr r$as8       $r$cCs\t|tjr(t|tjr*|jj|jjkr,t|jtj|_ t|jtj|_ dSdSdSdS)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'rZ IndexedSlicesindicesr3r castrZint64Z_indices)abrrr r/s  r/)NNFNNN)NNN)%__doc__Ztensorflow.python.eagerrZ,tensorflow.python.eager.polymorphic_functionrZtensorflow.python.frameworkrrrrr2rZtensorflow.python.opsr r r r r%r Ztensorflow.python.platformrrAZtensorflow.python.typesrZtensorflow.python.utilrrrZ tensorflow.python.util.tf_exportrZadd_dispatch_supportZdeprecated_argsrr;r.r$r/rrrr sN                    He (