AVhdZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd l m Z dd l mZdd l mZdd l mZddl mZddl mZddlmZddlmZddlmZddlmZddlmZddlmZedgej: d.dZedgej:ej>dddd d.dZ edgej: d.d Z!edgej:ej>dd!dd d.d"Z"ed#gej: d/d$Z#ed#gej:ej>dd%dd d/d&Z$d0d'Z%d0d(Z&d)Z'd*Z(d1d+Z) d1d,Z* d2d-Z+y)3zFunctional operations.)attr_value_pb2)context) constant_op)dtypes)function)ops)tensor) tensor_shape) array_ops)gen_functional_ops)math_ops)tensor_array_ops)variable_scope) while_loop) remote_call)symbolic_gradient) deprecation)dispatch)nest) tf_exportfoldl)v1NTFc tstjdfd}tj }t j |d|g5|r6tj} d} | j| jdd} tj|D cgc]} t j| d } } tj| d j d xst#j | d d tj$|||-tj$d } t'j(d }n|} t'j(d }fd }t+j*fd||| g|||\}}|r r jd|cdddScc} w#1swYyxYw)afoldl on the list of tensors unpacked from `elems` on dimension 0. This foldl operator repeatedly applies the callable `fn` to a sequence of elements from first to last. The elements are made of the tensors unpacked from `elems` on dimension 0. The callable fn takes two tensors as arguments. The first argument is the accumulated value computed from the preceding invocation of fn, and the second is the value at the current position of `elems`. If `initializer` is None, `elems` must contain at least one element, and its first element is used as the initializer. Suppose that `elems` is unpacked into `values`, a list of tensors. The shape of the result tensor is fn(initializer, values[0]).shape`. This method also allows multi-arity `elems` and output of `fn`. If `elems` is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The signature of `fn` may match the structure of `elems`. That is, if `elems` is `(t1, [t2, t3, [t4, t5]])`, then an appropriate signature for `fn` is: `fn = lambda (t1, [t2, t3, [t4, t5]]):`. Args: fn: The callable to be performed. elems: A tensor or (possibly nested) sequence of tensors, each of which will be unpacked along their first dimension. The nested sequence of the resulting slices will be the first argument to `fn`. initializer: (optional) A tensor or (possibly nested) sequence of tensors, as the initial value for the accumulator. parallel_iterations: (optional) The number of iterations allowed to run in parallel. back_prop: (optional) True enables support for back propagation. swap_memory: (optional) True enables GPU-CPU memory swapping. name: (optional) Name prefix for the returned tensors. Returns: A tensor or (possibly nested) sequence of tensors, resulting from applying `fn` consecutively to the list of tensors unpacked from `elems`, from first to last. Raises: TypeError: if `fn` is not callable. Example: ```python elems = tf.constant([1, 2, 3, 4, 5, 6]) sum = foldl(lambda a, x: a + x, elems) # sum == 21 ``` 5 is not callable. Please provide a callable function.chtj|jddj|SNFT)dtypesize dynamic_size infer_shaper TensorArrayrunstackelemns T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/functional_ops.py create_tazfoldl..create_tag-  ' 'jjqu !'$-(rFNc|jSNdeviceops r'zfoldl..x ryyr*Tr%namerc$|jdSNrread)r%s r'r1zfoldl..s$))A,r*cXtjfd}||}dz|gS)Nc&|jSr,r7r%is r'r1z(foldl..compute..styy|r*r9r map_structure)r=aelem_ielems_tafns` r'computezfoldl..computes/!!";XFf Q-a!eQZr*c|kSr,)r=r@r&s r'r1zfoldl..s QUr*parallel_iterations back_prop swap_memorymaximum_iterations)callable TypeError__name__rexecuting_eagerlyr name_scopevsget_variable_scopecaching_deviceset_caching_devicerflattenconvert_to_tensorr dimension_valueshaper r?rconstantr)rCelems initializerrHrIrJr4r( in_graph_modevarscope varscope_caching_device_was_noner% elems_flatr@r=rD_r_arBr&s` @@r'rr*sr "  ;;-LM OO( //11- ~~dGeW-1&&(h).&  ( ##$89+/(>B\\%=P59d0J $$Z]%8%8%;< * 1 &q)!!)U3H   6 Aa   q !a a   q !a  " "!Q/ FAs9!!$' c1111s AF6)F1C F61F66F?zback_prop=False is deprecated. Consider using tf.stop_gradient instead. Instead of: results = tf.foldl(fn, elems, back_prop=False) Use: results = tf.nest.map_structure(tf.stop_gradient, tf.foldl(fn, elems))) warn_oncerIc &t|||||||S)afoldl on the list of tensors unpacked from `elems` on dimension 0. This foldl operator repeatedly applies the callable `fn` to a sequence of elements from first to last. The elements are made of the tensors unpacked from `elems` on dimension 0. The callable fn takes two tensors as arguments. The first argument is the accumulated value computed from the preceding invocation of fn, and the second is the value at the current position of `elems`. If `initializer` is None, `elems` must contain at least one element, and its first element is used as the initializer. Suppose that `elems` is unpacked into `values`, a list of tensors. The shape of the result tensor is fn(initializer, values[0]).shape`. This method also allows multi-arity `elems` and output of `fn`. If `elems` is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The signature of `fn` may match the structure of `elems`. That is, if `elems` is `(t1, [t2, t3, [t4, t5]])`, then an appropriate signature for `fn` is: `fn = lambda (t1, [t2, t3, [t4, t5]]):`. Args: fn: The callable to be performed. elems: A tensor or (possibly nested) sequence of tensors, each of which will be unpacked along their first dimension. The nested sequence of the resulting slices will be the first argument to `fn`. initializer: (optional) A tensor or (possibly nested) sequence of tensors, as the initial value for the accumulator. parallel_iterations: (optional) The number of iterations allowed to run in parallel. back_prop: (optional) Deprecated. False disables support for back propagation. Prefer using `tf.stop_gradient` instead. swap_memory: (optional) True enables GPU-CPU memory swapping. name: (optional) Name prefix for the returned tensors. Returns: A tensor or (possibly nested) sequence of tensors, resulting from applying `fn` consecutively to the list of tensors unpacked from `elems`, from first to last. Raises: TypeError: if `fn` is not callable. Example: ```python elems = tf.constant([1, 2, 3, 4, 5, 6]) sum = tf.foldl(lambda a, x: a + x, elems) # sum == 21 ``` rCrZr[rHrIrJr4)rrds r'foldl_v2re'F  -  r*foldrc @tstjdfd}tj }t j |d|g5|r6tj} d} | j| jdd} tj|D cgc]} t j| d } } tj| d j d xst#j | d d tj$|||d z tj$fd } n|} fd }t'j&d|| g|||\}}|r r jd|cdddScc} w#1swYyxYw)ajfoldr on the list of tensors unpacked from `elems` on dimension 0. This foldr operator repeatedly applies the callable `fn` to a sequence of elements from last to first. The elements are made of the tensors unpacked from `elems`. The callable fn takes two tensors as arguments. The first argument is the accumulated value computed from the preceding invocation of fn, and the second is the value at the current position of `elems`. If `initializer` is None, `elems` must contain at least one element, and its first element is used as the initializer. Suppose that `elems` is unpacked into `values`, a list of tensors. The shape of the result tensor is `fn(initializer, values[0]).shape`. This method also allows multi-arity `elems` and output of `fn`. If `elems` is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The signature of `fn` may match the structure of `elems`. That is, if `elems` is `(t1, [t2, t3, [t4, t5]])`, then an appropriate signature for `fn` is: `fn = lambda (t1, [t2, t3, [t4, t5]]):`. Args: fn: The callable to be performed. elems: A tensor or (possibly nested) sequence of tensors, each of which will be unpacked along their first dimension. The nested sequence of the resulting slices will be the first argument to `fn`. initializer: (optional) A tensor or (possibly nested) sequence of tensors, as the initial value for the accumulator. parallel_iterations: (optional) The number of iterations allowed to run in parallel. back_prop: (optional) True enables support for back propagation. swap_memory: (optional) True enables GPU-CPU memory swapping. name: (optional) Name prefix for the returned tensors. Returns: A tensor or (possibly nested) sequence of tensors, resulting from applying `fn` consecutively to the list of tensors unpacked from `elems`, from last to first. Raises: TypeError: if `fn` is not callable. Example: ```python elems = [1, 2, 3, 4, 5, 6] sum = foldr(lambda a, x: a + x, elems) # sum == 21 ``` rchtj|jddj|Srr!r$s r'r(zfoldr..create_ta+r)r*rgFNc|jSr,r-r/s r'r1zfoldr..<r2r*Tr%r3rr9c&|jSr,r7r<s r'r1zfoldr..Ks$))A,r*c\dztjfd}||}|gS)Nr9c&|jSr,r7r<s r'r1z(foldr..compute..RsTYYq\r*r>)r=r@r%a_outrBrCs` r'rDzfoldr..computePs41fa    98 DdDkeZr*c |dkDSr6rF)r=r@s r'r1zfoldr..Ws QUr*rG)rLrMrNrrOrrPrQrRrSrTrrUrVr rWrXr r?r)rCrZr[rHrIrJr4r(r\r]r^r%r_r@rDr`rarBr=r&s` @@@r'rgrgsr "  ;;-LM OO( //11- ~~dGeW-2&&(h).&  ( ##$89+/(>B\\%=P59d0J $$Z]%8%8%;< * 1 &q)!!)U3H a%a   6 Aa a a  " "!Q/ FAs9!!$' e2222s AF*FB=FFFzback_prop=False is deprecated. Consider using tf.stop_gradient instead. Instead of: results = tf.foldr(fn, elems, back_prop=False) Use: results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))c &t|||||||S)afoldr on the list of tensors unpacked from `elems` on dimension 0. This foldr operator repeatedly applies the callable `fn` to a sequence of elements from last to first. The elements are made of the tensors unpacked from `elems`. The callable fn takes two tensors as arguments. The first argument is the accumulated value computed from the preceding invocation of fn, and the second is the value at the current position of `elems`. If `initializer` is None, `elems` must contain at least one element, and its first element is used as the initializer. Suppose that `elems` is unpacked into `values`, a list of tensors. The shape of the result tensor is `fn(initializer, values[0]).shape`. This method also allows multi-arity `elems` and output of `fn`. If `elems` is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The signature of `fn` may match the structure of `elems`. That is, if `elems` is `(t1, [t2, t3, [t4, t5]])`, then an appropriate signature for `fn` is: `fn = lambda (t1, [t2, t3, [t4, t5]]):`. Args: fn: The callable to be performed. elems: A tensor or (possibly nested) sequence of tensors, each of which will be unpacked along their first dimension. The nested sequence of the resulting slices will be the first argument to `fn`. initializer: (optional) A tensor or (possibly nested) sequence of tensors, as the initial value for the accumulator. parallel_iterations: (optional) The number of iterations allowed to run in parallel. back_prop: (optional) Deprecated. False disables support for back propagation. Prefer using `tf.stop_gradient` instead. swap_memory: (optional) True enables GPU-CPU memory swapping. name: (optional) Name prefix for the returned tensors. Returns: A tensor or (possibly nested) sequence of tensors, resulting from applying `fn` consecutively to the list of tensors unpacked from `elems`, from last to first. Raises: TypeError: if `fn` is not callable. Example: ```python elems = [1, 2, 3, 4, 5, 6] sum = tf.foldr(lambda a, x: a + x, elems) # sum == 21 ``` rd)rgrds r'foldr_v2rqfrfr*scanc p !"#$%tstjdtj fd}  fd! $| #!%n tj$$fd#$fd%| } t j } tj|d| 5| r6tj} d} | j| jd d } | Dcgc]}tj|d } }tj| d j d ""t#j | d d "| Dcgc]3}t%j&|j("d|j ddd 5c}t+| Dcgc]\}}|j-|c}}(Dcgc]}|j/r"dz nd }}d}n,#}|Dcgc]}tj|}}d }|Dcgc]4}t%j&|j("|r |j ndd|6}}5t+||Dcgc]\}}|j1r"dz nd | }}}!#%fd}r "dz |z }d}n|}"fd}t3j2|||||f|||"\}}}|Dcgc]}|j5}}tj6tj| d j9j;dd }| ddD]Y}|j=tj6tj|j9j;dd [|D]F}|j?tj@|jC|j9ddH| r r jd%|cdddScc}wcc}wcc}}wcc}wcc}wcc}wcc}}wcc}w#1swYyxYw)ascan on the list of tensors unpacked from `elems` on dimension 0. See also `tf.map_fn`. The simplest version of `scan` repeatedly applies the callable `fn` to a sequence of elements from first to last. The elements are made of the tensors unpacked from `elems` on dimension 0. The callable fn takes two tensors as arguments. The first argument is the accumulated value computed from the preceding invocation of fn, and the second is the value at the current position of `elems`. If `initializer` is None, `elems` must contain at least one element, and its first element is used as the initializer. Suppose that `elems` is unpacked into `values`, a list of tensors. The shape of the result tensor is `[len(values)] + fn(initializer, values[0]).shape`. If reverse=True, it's fn(initializer, values[-1]).shape. This method also allows multi-arity `elems` and accumulator. If `elems` is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The second argument of `fn` must match the structure of `elems`. If no `initializer` is provided, the output structure and dtypes of `fn` are assumed to be the same as its input; and in this case, the first argument of `fn` must match the structure of `elems`. If an `initializer` is provided, then the output of `fn` must have the same structure as `initializer`; and the first argument of `fn` must match this structure. For example, if `elems` is `(t1, [t2, t3])` and `initializer` is `[i1, i2]` then an appropriate signature for `fn` in `python2` is: `fn = lambda (acc_p1, acc_p2), (t1, [t2, t3]):` and `fn` must return a list, `[acc_n1, acc_n2]`. An alternative correct signature for `fn`, and the one that works in `python3`, is: `fn = lambda a, t:`, where `a` and `t` correspond to the input tuples. Args: fn: The callable to be performed. It accepts two arguments. The first will have the same structure as `initializer` if one is provided, otherwise it will have the same structure as `elems`. The second will have the same (possibly nested) structure as `elems`. Its output must have the same structure as `initializer` if one is provided, otherwise it must have the same structure as `elems`. elems: A tensor or (possibly nested) sequence of tensors, each of which will be unpacked along their first dimension. The nested sequence of the resulting slices will be the first argument to `fn`. initializer: (optional) A tensor or (possibly nested) sequence of tensors, initial value for the accumulator, and the expected output type of `fn`. parallel_iterations: (optional) The number of iterations allowed to run in parallel. back_prop: (optional) True enables support for back propagation. swap_memory: (optional) True enables GPU-CPU memory swapping. infer_shape: (optional) False disables tests for consistent output shapes. reverse: (optional) True scans the tensor last to first (instead of first to last). name: (optional) Name prefix for the returned tensors. Returns: A tensor or (possibly nested) sequence of tensors. Each tensor packs the results of applying `fn` to tensors unpacked from `elems` along the first dimension, and the previous accumulator value(s), from first to last (or last to first, if `reverse=True`). Raises: TypeError: if `fn` is not callable or the structure of the output of `fn` and `initializer` do not match. ValueError: if the lengths of the output of `fn` and `initializer` do not match. Examples: ```python elems = np.array([1, 2, 3, 4, 5, 6]) sum = scan(lambda a, x: a + x, elems) # sum == [1, 3, 6, 10, 15, 21] sum = scan(lambda a, x: a + x, elems, reverse=True) # sum == [21, 20, 18, 15, 11, 6] ``` ```python elems = np.array([1, 2, 3, 4, 5, 6]) initializer = np.array(0) sum_one = scan( lambda a, x: x[0] - x[1] + a, (elems + 1, elems), initializer) # sum_one == [1, 2, 3, 4, 5, 6] ``` ```python elems = np.array([1, 0, 0, 0, 0, 0]) initializer = (np.array(0), np.array(1)) fibonaccis = scan(lambda a, _: (a[1], a[0] + a[1]), elems, initializer) # fibonaccis == ([1, 1, 2, 3, 5, 8], [1, 2, 3, 5, 8, 13]) ``` rc8rtj|S|gSr,rrU)xinput_is_sequences r'r1zscan.. s/@DLLOqcr*c>rtj|S|dSr6rpack_sequence_as)rvrZrws r' input_packzscan..input_pack"s!.?4  *IQqTIr*Nc8rtj|S|gSr,ru)rvoutput_is_sequences r'r1zscan..+s2Dt||A1#r*c>rtj|S|dSr6ry)rvr[r}s r' output_packzscan..output_pack-s)###K3/)*1/r*rrFc|jSr,r-r/s r'r1zscan..?r2r*Tr%r3rr9)rrr element_shaper )rrrrr cJ Dcgc]}|j|c}}|} ||}tj n||}t||D cgc]\}} |j || }}} r|dz } n|dz} | ||fScc}wcc} }w)aThe loop body of scan. Args: i: the loop counter. a_flat: the accumulator value(s), flattened. tas: the output accumulator TensorArray(s), flattened. Returns: [i + 1, a_flat, tas]: the updated counter + new accumulator values + updated TensorArrays Raises: TypeError: if initializer and fn() output structure do not match ValueType: if initializer and fn() output lengths do not match r9)r8rassert_same_structurezipwrite)r=a_flattaselem_ta packed_elemspacked_arn flat_a_outtavaluenext_irZrBrCr[r{output_flattenrreverses r'rDzscan..computers   IWa IJlV$h<(e   +*=;!&(!%(j36sJ3G HKRRXXa  Hc H QQj# &&!J Is B)Bc |dk\Sr6rF)r=_1_2s r'r1zscan..s AFr*c|kSr,rF)r=rrr&s r'r1zscan..s AEr*rG)"rLrMrNr is_nestedrrOrrPrQrRrSrTrVr rWrXr rr"rrr#r8rrstack Dimension get_shapewith_rank_at_leastassert_is_compatible_with set_shape TensorShape concatenate)&rCrZr[rHrIrJr rr4 input_flattenr_r\r]r^r%rrr=initializer_flatinitaccs_taacc_tar@rD initial_i conditionr`rar results_flatn_staticrBrwr{r&rr}rs&``` ` @@@@@@@r'rrrrsgP "  ;;-LM OOnnU+I-J*"NK 4MN/U#*//11- ~~dFJ/|%&&(h).&  ( ##$89+/(>H59d0J $$Z]%8%8%; @AH12?((  **.."55a8;= >?? Mkk  " "8 , 8 8qr9J KMM 9!!$' | $y|%|% IJ`,S|%|%su,=P,)PAP,8PP,P 4 P,>PP,.P P,9P P,#P!A P, P'#DP,*P,,P5zback_prop=False is deprecated. Consider using tf.stop_gradient instead. Instead of: results = tf.scan(fn, elems, back_prop=False) Use: results = tf.nest.map_structure(tf.stop_gradient, tf.scan(fn, elems))c *t||||||||| S)a2scan on the list of tensors unpacked from `elems` on dimension 0. The simplest version of `scan` repeatedly applies the callable `fn` to a sequence of elements from first to last. The elements are made of the tensors unpacked from `elems` on dimension 0. The callable fn takes two tensors as arguments. The first argument is the accumulated value computed from the preceding invocation of fn, and the second is the value at the current position of `elems`. If `initializer` is None, `elems` must contain at least one element, and its first element is used as the initializer. Suppose that `elems` is unpacked into `values`, a list of tensors. The shape of the result tensor is `[len(values)] + fn(initializer, values[0]).shape`. If reverse=True, it's fn(initializer, values[-1]).shape. This method also allows multi-arity `elems` and accumulator. If `elems` is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The second argument of `fn` must match the structure of `elems`. If no `initializer` is provided, the output structure and dtypes of `fn` are assumed to be the same as its input; and in this case, the first argument of `fn` must match the structure of `elems`. If an `initializer` is provided, then the output of `fn` must have the same structure as `initializer`; and the first argument of `fn` must match this structure. For example, if `elems` is `(t1, [t2, t3])` and `initializer` is `[i1, i2]` then an appropriate signature for `fn` in `python2` is: `fn = lambda (acc_p1, acc_p2), (t1, [t2, t3]):` and `fn` must return a list, `[acc_n1, acc_n2]`. An alternative correct signature for `fn`, and the one that works in `python3`, is: `fn = lambda a, t:`, where `a` and `t` correspond to the input tuples. Args: fn: The callable to be performed. It accepts two arguments. The first will have the same structure as `initializer` if one is provided, otherwise it will have the same structure as `elems`. The second will have the same (possibly nested) structure as `elems`. Its output must have the same structure as `initializer` if one is provided, otherwise it must have the same structure as `elems`. elems: A tensor or (possibly nested) sequence of tensors, each of which will be unpacked along their first dimension. The nested sequence of the resulting slices will be the first argument to `fn`. initializer: (optional) A tensor or (possibly nested) sequence of tensors, initial value for the accumulator, and the expected output type of `fn`. parallel_iterations: (optional) The number of iterations allowed to run in parallel. back_prop: (optional) Deprecated. False disables support for back propagation. Prefer using `tf.stop_gradient` instead. swap_memory: (optional) True enables GPU-CPU memory swapping. infer_shape: (optional) False disables tests for consistent output shapes. reverse: (optional) True scans the tensor last to first (instead of first to last). name: (optional) Name prefix for the returned tensors. Returns: A tensor or (possibly nested) sequence of tensors. Each tensor packs the results of applying `fn` to tensors unpacked from `elems` along the first dimension, and the previous accumulator value(s), from first to last (or last to first, if `reverse=True`). Raises: TypeError: if `fn` is not callable or the structure of the output of `fn` and `initializer` do not match. ValueError: if the lengths of the output of `fn` and `initializer` do not match. Examples: ```python elems = np.array([1, 2, 3, 4, 5, 6]) sum = scan(lambda a, x: a + x, elems) # sum == [1, 3, 6, 10, 15, 21] sum = scan(lambda a, x: a + x, elems, reverse=True) # sum == [21, 20, 18, 15, 11, 6] ``` ```python elems = np.array([1, 2, 3, 4, 5, 6]) initializer = np.array(0) sum_one = scan( lambda a, x: x[0] - x[1] + a, (elems + 1, elems), initializer) # sum_one == [1, 2, 3, 4, 5, 6] ``` ```python elems = np.array([1, 0, 0, 0, 0, 0]) initializer = (np.array(0), np.array(1)) fibonaccis = scan(lambda a, _: (a[1], a[0] + a[1]), elems, initializer) # fibonaccis == ([1, 1, 2, 3, 5, 8], [1, 2, 3, 5, 8, 13]) ``` rCrZr[rHrIrJr rr4)rrrs r'scan_v2rs-`  -   r*ct|tjrR|jjj Dcgc]}|j }}tj||||||S|j}|j}tj||dtj|j}tj||||||} tj|| dScc}w)aGoutput = Cond(inputs) ? then_branch(inputs) : else_branch(inputs). Args: cond: A `Tensor`. A scalar. If the scalar is not a boolean, the scalar is converted to a boolean according to the following rule: if the scalar is a numerical value, non-zero means True and zero means False; if the scalar is a string, non-empty means True and empty means False. inputs: A list of input tensors. then_branch: A function takes 'inputs' and returns a list of tensors, whose types are the same as what else_branch returns. else_branch: A function takes 'inputs' and returns a list of tensors. whose types are the same as what then_branch returns. name: A name for the operation (optional). Returns: A list of tensors returned by either then_branch(inputs) or else_branch(inputs). r3T)expand_composites) isinstancer_DefinedFunction definition signature output_argtyper _ifstructured_outputsrrrU output_dtypesrz) condinputs then_branch else_branchr4r`tlistthen_outelse_outrets r'Ifr0s0 X667(33==HH IQVV IE I  ! ! fe[+D BB + +(  + +(Xx4H ,,{00 1% FE; $ @#   x EE# JsC/c|jjjDcgc]}|j}}t ||||Scc}w)aComputes the gradient function for function f via backpropagation. Args: inputs: A list of tensors of size N + M. f: The function we want to compute the gradient for. The function 'f' must be a numerical function which takes N inputs and produces M outputs. Its gradient function 'g', which is a function taking N + M inputs and produces N outputs. I.e. if we have (y1, y2, ..., yM) = f(x1, x2, ..., xN), then, g is (dL/dx1, dL/dx2, ..., dL/dxN) = g(x1, x2, ..., xN, dL/dy1, dL/dy2, ..., dL/dyM), where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the loss function). dL/dxi is the partial derivative of L with respect to xi. name: A name for the operation (optional). Returns: A list of tensors of size N. )inputToutfr4)rr input_argrr)rrr4r`rs r'Gradientr]sA(<<11;; .Wrappersj4[Fx..01J&#--(  u .Y ##ld6l:. ..r*)rDefunrr4)rrs` r'_LoopBodyCaptureWrapperrs; >>?4(ML4994LM /N / .r*c jrtdjt}t| | k7rtd|d |jrt |jDcgc]}|jc}z}t j |ddjzi fd}tj||jz|t||} | dt|j } ntj|||} |rtj} | jjj|| d j j#d | tj} | jjj|| d j j#d | | Scc}w) aboutput = input; While (Cond(output)) { output = Body(output) }. Args: input_: A list of `Tensor` objects. A list of input tensors whose types are T. cond: . A function takes 'input' and returns a tensor. If the tensor is a scalar of non-boolean, the scalar is converted to a boolean according to the following rule: if the scalar is a numerical value, non-zero means True and zero means False; if the scalar is a string, non-empty means True and empty means False. If the tensor is not a scalar, non-emptiness means True and False otherwise. body: . A function takes a list of tensors and returns another list tensors. Both lists have the same types as specified by T. name: A name for the operation (optional). hostmem: A list of integer. If i is in the list, input[i] is a host memory tensor. Raises: ValueError: if `cond` has implicitly captured inputs or if `cond` and `body` have different signatures. Returns: A list of `Tensor` objects. Has the same type as `input`. A list of output tensors whose types are T. zWThe 'cond' argument can not have implicitly captured inputs. Received captured_inputs: zJThe 'cond' and 'body' signatures do not match. Received: cond_input_types=z, body_input_types=rrc&|dtS)rN)r)rbody_input_typesrs r' CondWrapperzWhile..CondWrappers4.-./ 00r*r3Nr_input_hostmem_output_hostmem)r ValueErrorrrrrrr4r _whilerrr AttrValuer=extendr0 _set_attr) input_rbodyr4hostmemcond_input_typesr cond_dtypesrr input_attr output_attrrs ` @r'Whilers4    001 3 44%T*$T*))  ,--@      '(--,,K^^[EL499,DE1F1  # #%%%%   C )D(()) *C  # #FD$T BC ))+JOOW%FII(*5 **,Kg&FII);7 *5,s7Gctj|}tjtjtj||z |zdz tjtj|tjz tj }tj gdzt jddz} djz} tj| d| id} djz} tj| d| ifd} |gd |Dcgc]}d|z c}z}ngd }td |||g|z| | || }t |dt|Scc}w) z-Helper to implement a For loop using a While.r9Nz%s_Condrc~||kSr,rF)r=r&rs r' WhileCondz!_ForUsingWhile..WhileConds q5Lr*z%s_Bodyc|||zzg|}t|tjrd}nt|tjr|f}|dz|||ft |zS)zFA While wrapper for forbody that handles loop-carried captured inputs.rFr9)rrrr Tensorr)r=r&startdeltar for_resultforbodys r' WhileBodyz!_ForUsingWhile..WhileBodysdU*2T2J*cmm,j J .=j E1eU #eJ&7 77r*)rr9r)rrrr4r) r abscastrfloat32int32rrr4rrrr)rlimitrrrr4rdr&body_sig cond_namer body_namerr`resultss ` r'_ForUsingWhilersYll5!mmmmX\\%%-014q86>>JmmAv~~&'(. 6!ll^a $w'C'C"DQR"H H(',,&) >>81y12',,&) >>81y1 82 8 w7!q1u77GG E5 !F *     ' gaG % &&8s* E.c |rt|||||||S|jrKtj|||||jzt ||}|dt |j }ntj||||||}|rd} t j} | jjj|D cgc]} | | z c} |djjd| t j} | jjj||djjd| |Scc} w)aMout = input; for i in range(start, limit, delta) out = body(i, out). Args: start: A `Tensor` of type `int32`. limit: A `Tensor` of type `int32`. delta: A `Tensor` of type `int32`. inputs: A list of `Tensor` objects. A list of input tensors whose types are T. body: A function takes a list of tensors and returns another list of tensors. Both lists have the same types as (int32, T...). name: A name for the operation (optional). hostmem: A list of integer. If i is in the list, inputs[i] is a host memory tensor. In other words, (i+1)-th argument of the body function is expecting a host memory. rewrite_with_while: If True, using While op to implement the For. Returns: A list of `Tensor` objects. Has the same type as `input`. A list of output tensors whose types are T. r3Nrrrr) rrr _forrrrrrr=rr0r) rrrrrr4rrewrite_with_whilernum_for_paramsrr=rs r'Forr +s38 %vtT7 KK   ! !   %%%%   C )D(()) *C  ! !%vt$ OC N))+JOO'BQnq0BCFII(*5 **,Kg&FII);7 * Cs E )N TFN)Nr TFTFNr,)NN)NNN),__doc__tensorflow.core.frameworkrtensorflow.python.eagerrtensorflow.python.frameworkrrrrr r tensorflow.python.opsr r r rrrQr(tensorflow.python.ops.gen_functional_opsrrtensorflow.python.utilrrr tensorflow.python.util.tf_exportradd_dispatch_supportrdeprecated_arg_valuesrergrqrrrrrrrrrr rFr*r'rsj4+3.0+.4+4*26,@F.+'6 wi   rrj 7r """J !# ??D wi   ssl 7r """J !# ??D vh {%{%| 6b """I  "nnd*FZE0 4.C p ;'F4 r*