AVh&dZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd l mZd Z dd ZedgddZedddZy )z(Switch case for Control Flow Operations.)context)ops)tensor) array_ops)cond_v2)control_flow_util)gen_functional_ops)math_ops) tf_exportc t|tjs#tdj t ||j js$tdj |j |s tdt|tttfs tdt|tr|j}td|Drtt|}|D]}t|trt|dk7rtd|d|\}}t|t s#td j t |t#|rttd j ||Dcgc]}|d  }}t%|d ks7t'|t|k\s tt)|t|k7rJtd j t|d j+t-t.t1|t1|Dcgc]}|d }}||j3||Scc}wcc}w)aVerifies input arguments for the case function. Args: branch_fns: Dict or list of pairs of an `int` and a callable which returns a list of tensors. default: Optional callable that returns a list of tensors. branch_index: Optional int `Tensor`, which selects for the corresponding pred_fn_pair. Raises: TypeError: If `branch_fns` is not a list/dictionary. TypeError: If `branch_fns` is a list but does not contain 2-tuples or callables. TypeError: If `fns[i]` is not callable for any i, or `default` is not callable. Returns: branch_fns: validated list of callables for each branch (default last). z''branch_index' must be a Tensor, got {}z0'branch_index' must be an integer Tensor, got {}z.Must provide at least one item in 'branch_fns'z+'branch_fns' must be a list, tuple, or dictc32K|]}t|ywN)callable).0fns ^/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/control_flow_switch_case.py z=_indexed_case_verify_and_canonicalize_args..@s+""+sz7Each entry in 'branch_fns' must be a 2-tuple. Received .z"key must be a Python `int`, got {}zfn for key {} must be callable.rzNbranch indices (keys) must form contiguous range of [0 to {}) but found {{{}}},) isinstancerTensor TypeErrorformattypedtype is_integer ValueErrorlisttupledictitemsall enumeratelenintrminmaxsetjoinmapstrsortedappend) branch_fnsdefault branch_index key_fn_pairkey branch_fnpkeysactionss r*_indexed_case_verify_and_canonicalize_argsr9s* L&-- 0 =DD \     & & FMM   E FF Jud 3 4 A BB D!!!#J+ ++i +,J Ek k5 )S-=-B ""-a1 22 NC c3  :AA$s)L MM I  7>>sC DD E# #1!A$ #$ #Y]c$i3t9,CI#d)0K  vc$i#c6$<2H)IJ LL"*- .aQqT .' .  NN7 . $ /s  I0 INc t|||}tj|d|g5tjrt |dsst jtj|dtj|t|zt|dz |}|t|cdddStj|||cdddS#1swYyxYw)alImplementation of case that emits the n-way indexed Case op. Args: branch_fns: Dict or list of pairs of a boolean scalar tensor, and a callable which returns a list of tensors. default: Optional callable that returns a list of tensors. branch_index: Optional int `Tensor`, which selects for the corresponding pred_fn_pair. name: A name for this operation (optional). lower_using_switch_merge: Lower this op using switch merge ops (optional). Returns: The tensors returned by the pair whose key matched branch_index, or those returned by `default` if none does. Raises: TypeError: If `branch_fns` is not a list/dictionary. TypeError: If `branch_fns` is a list but does not contain 2-tuples or callables. TypeError: If `fns[i]` is not callable for any i, or `default` is not callable. casegraphrrNlower_using_switch_merge)r9r name_scoperexecuting_eagerlyhasattrrwherer less greater_equalr&r'r indexed_case)r0r1r2namer>s r_indexed_case_helperrGZs6:'<)* ~~dF\N3 ;  "7<+I__ -- a (  " "<Z A B j/A |-l+ZL) * , ; ;   !9 ; ; ; ;sB C:CC$z"__internal__.execute_fn_for_device)v1ctjtj}|r|S|j Dcic]\}}|j |}}}t |j}t |j}tj|} t||| |dScc}}w)aExecutes one of the provided callables based on the device placement. This API is used when the implementations for high level function depend on the underlying device placement. It takes a dictionary of device type to callables. The device type includes "CPU", "GPU", "TPU", etc. When the type of the device where to run this op matches the key in 'device_branch_fns', the corresponding callable is executed, falling back to 'default_fn' if none matches. **Example:** ```python def f1(): return tf.constant(1) def f2(): return tf.constant(2) r = tf.execute_fn_for_device({"CPU": f1, "GPU": f2}, default_fn=f1) ``` 'r' is evaluated as 1 when it runs on CPU, 2 running on GPU, 1 running on any other device types. Args: device_branch_fns: a dictionary of device types to the callables. Each callable must return a matching structure of tensors. default_fn: fallback callable when the underlying device does not match any key in the 'device_branch_fns'. name: A name for this operation (optional). Returns: The tensors returned by the callable identified by device type during execution, or those returned by 'default_fn' if no key matches. ) device_namesFr=) utilGraphOrParentsInXlaContextrget_default_graphr#upperr valuesr7r device_indexrG) device_branch_fns default_fnrF is_in_xlakvdevice_branch_fns_upperr0devicesrPs rexecute_fn_for_devicerXsD--c.C.C.EF) <6G6M6M6OPdaQWWY\PP+2245* (--/ 0'#00gF,  $  && QsB: switch_casect||||S)a Create a switch/case operation, i.e. an integer-indexed conditional. See also `tf.case`. This op can be substantially more efficient than `tf.case` when exactly one branch will be selected. `tf.switch_case` is more like a C++ switch/case statement than `tf.case`, which is more like an if/elif/elif/else chain. The `branch_fns` parameter is either a dict from `int` to callables, or list of (`int`, callable) pairs, or simply a list of callables (in which case the index is implicitly the key). The `branch_index` `Tensor` is used to select an element in `branch_fns` with matching `int` key, falling back to `default` if none match, or `max(keys)` if no `default` is provided. The keys must form a contiguous set from `0` to `len(branch_fns) - 1`. `tf.switch_case` supports nested structures as implemented in `tf.nest`. All callables must return the same (possibly nested) value structure of lists, tuples, and/or named tuples. **Example:** Pseudocode: ```c++ switch (branch_index) { // c-style switch case 0: return 17; case 1: return 31; default: return -1; } ``` or ```python branches = {0: lambda: 17, 1: lambda: 31} branches.get(branch_index, lambda: -1)() ``` Expressions: ```python def f1(): return tf.constant(17) def f2(): return tf.constant(31) def f3(): return tf.constant(-1) r = tf.switch_case(branch_index, branch_fns={0: f1, 1: f2}, default=f3) # Equivalent: tf.switch_case(branch_index, branch_fns={0: f1, 1: f2, 2: f3}) ``` Args: branch_index: An int Tensor specifying which of `branch_fns` should be executed. branch_fns: A `dict` mapping `int`s to callables, or a `list` of (`int`, callable) pairs, or simply a list of callables (in which case the index serves as the key). Each callable must return a matching structure of tensors. default: Optional callable that returns a structure of tensors. name: A name for this operation (optional). Returns: The tensors returned by the callable identified by `branch_index`, or those returned by `default` if no key matches and `default` was provided, or those returned by the max-keyed `branch_fn` if no `default` is provided. Raises: TypeError: If `branch_fns` is not a list/dictionary. TypeError: If `branch_fns` is a list but does not contain 2-tuples or callables. TypeError: If `fns[i]` is not callable for any i, or `default` is not callable. )rG)r2r0r1rFs rrYrYsP j'< FFr) execute_fn)NrY)__doc__tensorflow.python.eagerrtensorflow.python.frameworkrrtensorflow.python.opsrrrrKr r tensorflow.python.util.tf_exportr r9rGrXrYr[rrcsp/++.+);4*6;D37 ';T /B7-&8-&` =GGGGr[