AVh6;dZddlZddlZddlmZddlmZddl m Z ddl m Z ddl m Z ddl m Z dd l mZdd l mZdd l mZdd l mZdd l mZddl mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl ddl!m"Z#ddl$m%Z%ddl$mZddl$m&Z&ddl$m'Z'ddl$m(Z(ddl)m*Z*dd l+m,Z,ejZZ.e,d!d"d!g#e'j^e&j`d"dDd$Z1e1Z2e&jfdd%e4Z4e&jfdd&e5Z5e,d'g#e'j^e4e,d(g#e'j^e5d)Z6e,d*d+g#e'j^e&jndd,d-e6ejhjjqd.d/jqd-d0ddde jrfd1Z:e,d*d+g#e'j^de jrdfd2Z;e,d3d4g#e'j^e&jndd,d-e6ejjjjqd.d/jqd-d0ddde jrfd5Z<e,d3d4g#e'j^de jrdfd6Z=e,d7d8e'j|e'j^dEd9Z?dEd:Z@Gd;d<ZAe,d=d>e'je'j^dEd?ZCe,d@dAe'je'j^dEdBZDe&jfdCdDdEdEZEejjeEjdFn eEjzeE_e,dGdHe'je'j^dEdIZGejjeG_e&jfdCdJdEdKZIejjeIjdFn eIjzeI_ejZKe&jfdCdLdEdMZLe,dNdOg#e'je'j^dEdPZMe,dQdRdQdRg#e'j|e'j^dEdSZNe,dNdOg#e'je'j^e6eMjdEdTZOe,dUdVe'je'j^dEdWZPe,dXdYe'je'j^dEdZZQe,d[d\e'j|e'j^dEd]ZRe,d^d^d_g#e'j|e'j^e&j`d_dEd`ZSe,dadadbg#e'j|e'j^e&j`dbdEdcZTe,dddddeg#e'j|e'j^e&j`dedEdfZUe,dgdhe'j|e'j^dEdiZVe,djdke'j|e'j^dEdlZWe,dmdne'j|e'j^dEdoZXe,dpg#e'j|e'j^e&jfddqrdFdsZYe,dtg#e'j|e'j^e&jfddqrdGduZZe,dvg#e'j|e'j^e&jfddqrdHdwZ[e,dxg#e'j|e'j^e&jfddqrdIdyZ\e,dzg#e'j|e'j^e&jfddqrdJd{Z]e,d|g#e'j|e'j^e&jfddqrdKd}Z^e,d~g#e'j|e'j^e&jfddqrdLdZ_e je je je je je je je je je je je je je je jre je jde jde jde jde jde jdiZmdEdZndEdZoe,dde'je'j^dEdZpe,dg#e'je'j^e&jfddrdEdZqe,dddg#e'je'j^e&j`ddEdZre,de'je'j^dEdZsdEdZte,dddg#e'je'j^e&j`ddEdZuejZwejZyejZzejZ|ejZ~e,dg#e'j^dEdZdEdZe,dddg#e'je'j^e&j`ddMdZdEdZdEdZdEdZdEdZe,dde'je'j^dEdZe,dde'je'j^dEdZe,dg#e'j^dZe,dg#e'j^dZe,de'j^dNdZ dOdZejejedZdZdZe,ddg#e'j^e&jnddd dPdZe,ddg#e'j^dQdZ dRdZe,de'j^dQdZe,ddg#e'j^e&jnddde&jndddddde jrddddfdZe,dg#e'j^dde jrdfdZe,ddg#e'j^ dPdZe,ddg#e'j^dQdZe,de'j^dQdZe,de'j^dQdZe,ddg#e'j^dQdĄZe,ddg#e'j^e&jnddd dPdńZe,ddg#e'j^e&jnddd dPdȄZe,ddg#e'j^dQdɄZe,ddg#e'j^e&jnddd dPd̄Ze,ddg#e'j^dQd̈́Z dRd΄Ze,ddg#e'j^e&jnddd dPdфZe,ddg#e'j^dQd҄Ze,ddg#e'j^e&jnddd dPdՄZe,ddg#e'j^dQdքZe,ddg#e'j^e&jnddd dPdلZe,ddg#e'j^dQdڄZe,dddg#e'j^e&j`dܫdEd݄Ze,dd߫e'j^ dSdZe,de'j^ dTdZdEdZeje_e&jfddejVZe,dg#ee'j^dUdZdUdZe,dde'je'j^dEdZe,dde'j^dgdEdZe,dddg#e'j^e&jfdddVdZe jdddZe,ddde'j|e'j^dEdZe,dddg#e'j|e'j^e&j`ddEdZe,dde'j^dWdZe,dddg#e'j^e&j`ddWdZe,ddg#e'j^dWdZe,dddg#e'j|e'j^e&j`ddEdZdZd Ze,d d d g#e'j^e&j`d dEd Ze,d d dg#e'j^e&j`ddEdZe,ddg#e&j`d dOdZe,dg#dde jfdZe,dg# dOdZe,ddg#e&j`d dOdZe,dg# dOdZe,ddg#e&j`d dOdZe,dg# dOdZe,dd e'j^dEd!Ze,d"e'j^dEd#Ze,d$e'j|e'j^dEd%Ze,d&e'je'j^dEd'Ze,d(e'je'j^dEd)Ze,d*e'j|e'j^dEd+Ze,d,e'j|e'j^dEd-Ze,d.e'j|e'j^dEd/Ze,d0d0d1g#e'j|e'j^e&j`d1dEd2Ze,d3d4e'j|e'j^dEd5Ze,d6d7e'j|e'j^dEd8Ze,d9e'j^de jdfd:Ze,d;d;dd?e'j|e'j^dEd@Ze,dAdBe'j|e'j^dEdCZe'jeje'jeje'jeje'jeje'jeje'j|eje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'jeje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|ejZe'j|eje'j|eje'j|eje'j|eje'j|eje'j|eje'j|ejy(XaiMath Operations. Note: Functions taking `Tensor` arguments can also take anything accepted by `tf.convert_to_tensor`. Note: Elementwise binary operations in TensorFlow follow [numpy-style broadcasting](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html). TensorFlow provides a variety of math functions including: * Basic arithmetic operators and trigonometric functions. * Special math functions (like: `tf.math.igamma` and `tf.math.zeta`) * Complex number functions (like: `tf.math.imag` and `tf.math.angle`) * Reductions and scans (like: `tf.math.reduce_mean` and `tf.math.cumsum`) * Segment functions (like: `tf.math.segment_sum`) See: `tf.linalg` for matrix and tensor functions. ## About Segmentation TensorFlow provides several operations that you can use to perform common math computations on tensor segments. Here a segmentation is a partitioning of a tensor along the first dimension, i.e. it defines a mapping from the first dimension onto `segment_ids`. The `segment_ids` tensor should be the size of the first dimension, `d0`, with consecutive IDs in the range `0` to `k`, where `k [[0 0 0 0] # [5 6 7 8]] ``` The standard `segment_*` functions assert that the segment indices are sorted. If you have unsorted indices use the equivalent `unsorted_segment_` function. These functions take an additional argument `num_segments` so that the output tensor can be efficiently allocated. ``` python c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]]) tf.math.unsorted_segment_sum(c, tf.constant([0, 1, 0]), num_segments=2) # ==> [[ 6, 8, 10, 12], # [-1, -2, -3, -4]] ``` API docstring: tensorflow.math N)compat)context) constant_op)dtypes)indexed_slices)ops)override_binary_operator) sparse_tensortensor)tensor_conversion_registry) tensor_shape) tensor_util) array_ops)array_ops_stack) gen_array_ops)gen_bitwise_ops)gen_data_flow_ops)gen_logging_ops) gen_math_ops) gen_nn_ops)gen_sparse_ops)tensor_math_operator_overrides)*) tf_logging) _pywrap_utils) deprecation)dispatch)nest)collections_abc) tf_exportlinspace lin_space)v1ctj|d||g5tj|d}tj|d|j}t j |d}t ||j}t jt j|t j|}t j||}t j||}t j||}t j||}t j|} t j| d } t j|d k\|| |z}tj|d z d } tj|d z d } ||z t | |jz } t || j}t || j}t j|d k\| d }t td |tj | j}tj"|t| }t j|| d }t j$||}|| |zz}|||f}t j&||}t j(| }t j&| d |t j$|d g| |d zd fd }t j*|||cd d d S#1swYy xYw)aGenerates evenly-spaced values in an interval along a given axis. A sequence of `num` evenly-spaced values are generated beginning at `start` along a given `axis`. If `num > 1`, the values in the sequence increase by `(stop - start) / (num - 1)`, so that the last one is exactly `stop`. If `num <= 0`, `ValueError` is raised. Matches [np.linspace](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html)'s behaviour except when `num == 0`. For example: ``` tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0 11.0 12.0] ``` `Start` and `stop` can be tensors of arbitrary size: >>> tf.linspace([0., 5.], [10., 40.], 5, axis=0) `Axis` is where the values will be generated (the dimension in the returned tensor which corresponds to the axis will be equal to `num`) >>> tf.linspace([0., 5.], [10., 40.], 5, axis=-1) Args: start: A `Tensor`. Must be one of the following types: `bfloat16`, `float32`, `float64`. N-D tensor. First entry in the range. stop: A `Tensor`. Must have the same type and shape as `start`. N-D tensor. Last entry in the range. num: A `Tensor`. Must be one of the following types: `int32`, `int64`. 0-D tensor. Number of values to generate. name: A name for the operation (optional). axis: Axis along which the operation is performed (used only when N-D tensors are provided). Returns: A `Tensor`. Has the same type as `start`. r"startnamestopr(dtypenumr+axisrN)r name_scopeconvert_to_tensorr+rconvert_to_int_tensorcastbroadcast_dynamic_shapeshape broadcast_to expand_dimswhere_v2rmaximumrangerint64equalreshapeconcat zeros_likeslice)r&r)r,r(r/num_intbroadcast_shapeexpanded_start expanded_stopr8ndimsnum_filln_stepsdelta range_end desired_rangemaskdesired_range_shaperes all_tensors concatenatedbeginsizes N/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/math_ops.py linspace_ndrVqst ~~dJ 676  ! !%g 6E  F%++ FD--c>G wekk *C77  57O  " "5/ :E  ! !$ 8D**5t._decoratorsDL K)r^r_s` rU_set_docrbs r`z math.argmaxargmaxzUse the `axis` argument instead dimension dimensionsaxesr/cNtjd|d|}t||||SNr/rd)rdeprecated_argument_lookup argmax_v2inputr/r(rd output_types rUrcrc.  / /k09 ;$ 5$ T 22r`c<|d}tj||||S)aReturns the index with the largest value across axes of a tensor. In case of identity returns the smallest index. For example: >>> A = tf.constant([2, 20, 30, 3, 6]) >>> tf.math.argmax(A) # A[2] is maximum in tensor A >>> B = tf.constant([[2, 20, 30, 3, 6], [3, 11, 16, 1, 8], ... [14, 45, 23, 5, 27]]) >>> tf.math.argmax(B, 0) >>> tf.math.argmax(B, 1) >>> C = tf.constant([0, 0, 0, 0]) >>> tf.math.argmax(C) # Returns smallest index in case of ties Args: input: A `Tensor`. axis: An integer, the axis to reduce across. Default to 0. output_type: An optional output dtype (`tf.int32` or `tf.int64`). Defaults to `tf.int64`. name: An optional name for the operation. Returns: A `Tensor` of type `output_type`. rr(rm)rrWrlr/rmr(s rUrjrjs&@ \ D   eT+ NNr`z math.argminargmincNtjd|d|}t||||Srh)rri argmin_v2rks rUrrrr-rnr`c<|d}tj||||S)aReturns the index with the smallest value across axes of a tensor. Returns the smallest index in case of ties. Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `complex64`, `int64`, `qint8`, `quint8`, `qint32`, `bfloat16`, `uint16`, `complex128`, `half`, `uint32`, `uint64`. axis: A `Tensor`. Must be one of the following types: `int32`, `int64`. int32 or int64, must be in the range `-rank(input), rank(input))`. Describes which axis of the input Tensor to reduce across. For vectors, use axis = 0. output_type: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A `Tensor` of type `output_type`. Usage: ```python import tensorflow as tf a = [1, 10, 26.9, 2.8, 166.32, 62.3] b = tf.math.argmin(input = a) c = tf.keras.backend.eval(b) # c = 0 # here a[0] = 1 which is the smallest element of a across axis 0 ``` rrp)rrXrqs rUrtrt>s&B \ D   eT+ NNr`zmath.absabscPtj|d|g5}tj|d}|jjr5t j ||jj|cdddSt j||cdddS#1swYyxYw)aComputes the absolute value of a tensor. Given a tensor of integer or floating-point values, this operation returns a tensor of the same type, where each element contains the absolute value of the corresponding element in the input. Given a tensor `x` of complex numbers, this operation returns a tensor of type `float32` or `float64` that is the absolute value of each element in `x`. For a complex number \\(a + bj\\), its absolute value is computed as \\(\sqrt{a^2 + b^2}\\). For example: >>> # real number >>> x = tf.constant([-2.25, 3.25]) >>> tf.abs(x) >>> # complex number >>> x = tf.constant([[-2.25 + 4.75j], [-3.25 + 5.75j]]) >>> tf.abs(x) Args: x: A `Tensor` or `SparseTensor` of type `float16`, `float32`, `float64`, `int32`, `int64`, `complex64` or `complex128`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` of the same size, type and sparsity as `x`, with absolute values. Note, for `complex64` or `complex128` input, the returned `Tensor` will be of type `float32` or `float64`, respectively. Absxr'Toutr(N) rr3r4r+ is_complexr complex_abs real_dtype_absryr(s rUrvrvisP ~~dEA3'+4 ac*Aww  % %aagg.@.@t L++   QT * +++sAB<BB%c2tj|||S)Nrl boundariesr()r bucketizers rU _bucketizers   e  NNr`c(eZdZdZdZdZdZdZy)DivideDelegateWithNamezHUse Python2/Python3 division delegation to implement divide for tensors.c ||_||_y)zConstruct DivideDelegateWithName. Args: x: Tensor to use as left operand in operator overloads name: The name that is preferred for the op created. Nr)selfryr(s rU__init__zDivideDelegateWithName.__init__sDFDIr`cDt|j||jSr[)_truediv_python3ryr(rys rU __truediv__z"DivideDelegateWithName.__truediv__s DFFAtyy 11r`cDt|j||jSr[)floordivryr(rs rU __floordiv__z#DivideDelegateWithName.__floordiv__s DFFAtyy ))r`cDt|j||jSr[) _div_python2ryr(rs rU__div__zDivideDelegateWithName.__div__s 499 --r`N)__name__ __module__ __qualname__r\rrrrrar`rUrrsP2*.r`rz math.dividedividec|t|||z Stj|sDtj|r|jjnd}t j ||}||z S)atComputes Python style division of `x` by `y`. For example: >>> x = tf.constant([16, 12, 11]) >>> y = tf.constant([4, 6, 2]) >>> tf.divide(x,y) Args: x: A `Tensor` y: A `Tensor` name: A name for the operation (optional). Returns: A `Tensor` with same shape as input Nr-)rr is_tf_typer+ base_dtyperr4)ryrr(r+s rUrrsg.  "!T *Q ..  ! !! $$/$:$:1$=agg  4e   /a q5Lr`z math.multiplymultiplyc0tj|||S)a5Returns an element-wise x * y. For example: >>> x = tf.constant(([1, 2, 3, 4])) >>> tf.math.multiply(x, x) Since `tf.math.multiply` will convert its arguments to `Tensor`s, you can also pass in non-`Tensor` arguments: >>> tf.math.multiply(7,6) If `x.shape` is not the same as `y.shape`, they will be broadcast to a compatible shape. (More about broadcasting [here](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html).) For example: >>> x = tf.ones([1, 2]); >>> y = tf.ones([2, 1]); >>> x * y # Taking advantage of operator overriding The reduction version of this elementwise operation is `tf.math.reduce_prod` Args: x: A Tensor. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `uint8`, `int8`, `uint16`, `int16`, `int32`, `int64`, `complex64`, `complex128`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. Raises: * InvalidArgumentError: When `x` and `y` have incompatible shapes or types. rmulryrr(s rUrrsb   !Q %%r`z 2016-12-30zE`tf.mul(x, y)` is deprecated; use `tf.math.multiply(x, y)` or `x * y`c0tj|||Sr[rrs rU_mulr   !Q %%r`z math.subtractsubtractc0tj|||Sr[rsubrs rUrrrr`zG`tf.sub(x, y)` is deprecated, please use `tf.subtract(x, y)` or `x - y`c0tj|||Sr[rrs rU_subr(rr`z>`tf.neg(x)` is deprecated, please use `tf.negative(x)` or `-x`ct||S)aoComputes numerical negative value element-wise. I.e., \(y = -x\). Args: x: A `Tensor` or `SparseTensor`. Must be one of the following types: `half`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor`, respectively. Has the same type as `x`. )negativers rU_negr6s !T r`zmath.scalar_mul scalar_mulctj|jj}t j ||d}|j }|jdk(r{t|tjrJtjtj||j||j|jStj|||St!d|d)aMultiplies a scalar times a `Tensor` or `IndexedSlices` object. This is a special case of `tf.math.multiply`, where the first value must be a `scalar`. Unlike the general form of `tf.math.multiply`, this is operation is guaranteed to be efficient for `tf.IndexedSlices`. >>> x = tf.reshape(tf.range(30, dtype=tf.float32), [10, 3]) >>> with tf.GradientTape() as g: ... g.watch(x) ... y = tf.gather(x, [1, 2]) # IndexedSlices ... z = tf.math.scalar_mul(10.0, y) Args: scalar: A 0-D scalar `Tensor`. Must have known shape. x: A `Tensor` or `IndexedSlices` to be scaled. name: A name for the operation (optional). Returns: `scalar * x` of the same type (`Tensor` or `IndexedSlices`) as `x`. Raises: ValueError: if scalar is not a 0-D `scalar`. scalarr+r(rz5The input scalar must be a 0-D value. Received shape .)ras_dtyper+rrr4 get_shaperH isinstancer IndexedSlicesrrvaluesindices dense_shape ValueError)rryr(rr8s rUrrLs6qww'22*   JX /&    % [[A!^112  ) )   6188T 2AIIq}}NN  fa ..  ?waH JJr`z math.softplusz nn.softplusc.tj||S)aComputes elementwise softplus: `softplus(x) = log(exp(x) + 1)`. `softplus` is a smooth approximation of `relu`. Like `relu`, `softplus` always takes on positive values. Example: >>> import tensorflow as tf >>> tf.math.softplus(tf.range(0, 2, dtype=tf.float32)).numpy() array([0.6931472, 1.3132616], dtype=float32) Args: features: `Tensor` name: Optional: name to associate with this operation. Returns: `Tensor` )rsoftplus)featuresr(s rUrrvs.   Xt ,,r`cxtj|d|g5}t|||cdddS#1swYyxYw)Nr)rr3r)rryr(s rU scalar_mul_v2rs9  ~~dL1#.'$ fa &'''s 09zmath.powpowctj|d|g5}tj|||cdddS#1swYyxYw)anComputes the power of one value to another. Given a tensor `x` and a tensor `y`, this operation computes \\(x^y\\) for corresponding elements in `x` and `y`. For example: ```python x = tf.constant([[2, 2], [3, 3]]) y = tf.constant([[8, 16], [2, 3]]) tf.pow(x, y) # [[256, 65536], [9, 27]] ``` Args: x: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`, `complex64`, or `complex128`. y: A `Tensor` of type `float16`, `float32`, `float64`, `int32`, `int64`, `complex64`, or `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Powr'N)rr3r_powrs rUrrs?2 ~~dEA3'.4   Q -...s ;Azdtypes.complexcomplexc tj|d}tj|d}tj|d||g5}|j|jf}|tj tj fk(rtj }n|tjtjfk(rtj}nZtd|jjd|jjdtjtj gtj||||cd d d S#1swYy xYw) aConverts two real numbers to a complex number. Given a tensor `real` representing the real part of a complex number, and a tensor `imag` representing the imaginary part of a complex number, this operation returns complex numbers elementwise of the form \\(a + bj\\), where *a* represents the `real` part and *b* represents the `imag` part. The input tensors `real` and `imag` must have the same shape. For example: ```python real = tf.constant([2.25, 3.25]) imag = tf.constant([4.75, 5.75]) tf.complex(real, imag) # [[2.25 + 4.75j], [3.25 + 5.75j]] ``` Args: real: A `Tensor`. Must be one of the following types: `float32`, `float64`. imag: A `Tensor`. Must have the same type as `real`. name: A name for the operation (optional). Returns: A `Tensor` of type `complex64` or `complex128`. Raises: TypeError: Real and imag must be correct types realr'imagComplexz7The `real` and `imag` components have incorrect types:  z&. They must be consistent, and one of rzN) rr4r3r+rfloat64 complex128float32 complex64 TypeErrorr(r_complex)rrr( input_typesr{s rUrrs @  t& 1$  t& 1$ ~~dId|4 C::tzz*Kv~~v~~66   d 8 8   d  C ZZ__ Qtzz/0^^V^^45 7 88  t$T B C C Cs C3EEz math.signsignc tj|}|jjr}t j |t t j||jtjk(rtjntj|j|St j||S)adReturns an element-wise indication of the sign of a number. `y = sign(x) = -1 if x < 0; 0 if x == 0; 1 if x > 0`. For complex numbers, `y = sign(x) = x / |x| if x != 0, otherwise y = 0`. Example usage: >>> # real number >>> tf.math.sign([0., 2., -3.]) >>> # complex number >>> tf.math.sign([1 + 1j, 0 + 0j]) Args: x: A Tensor. Must be one of the following types: bfloat16, half, float32, float64, int32, int64, complex64, complex128. name: A name for the operation (optional). Returns: A Tensor. Has the same type as x. If x is a SparseTensor, returns SparseTensor(x.indices, tf.math.sign(x.values, ...), x.dense_shape). r{r-r') rr4r+r|r div_no_nanr6r}rrrrrrs rUrrsB A!WW  " "   $ $77f...^^4:NN D''       14 ((r`z math.realrctj|d|g5}tj|d}|jjr7|jj }t j|||cdddS|jjr |cdddStdj|j#1swYyxYw)a'Returns the real part of a complex (or real) tensor. Given a tensor `input`, this operation returns a tensor of type `float` that is the real part of each element in `input` considered as a complex number. For example: ```python x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j]) tf.math.real(x) # [-2.25, 3.25] ``` If `input` is already real, it is returned unchanged. Args: input: A `Tensor`. Must have numeric type. name: A name for the operation (optional). Returns: A `Tensor` of type `float32` or `float64`. Realrlr'rzNzC$CC z math.imagrcLtj|d|g5}tj|d}|jjr5t j ||jj|cdddStj|cdddS#1swYyxYw)apReturns the imaginary part of a complex (or real) tensor. Given a tensor `input`, this operation returns a tensor of type `float` that is the imaginary part of each element in `input` considered as a complex number. If `input` is real, a tensor of all zeros is returned. For example: ```python x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j]) tf.math.imag(x) # [4.75, 5.75] ``` Args: input: A `Tensor`. Must be one of the following types: `float`, `double`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor` of type `float32` or `float64`. Imagrlr'rzN) rr3r4r+r|rrr~rrBrlr(s rUrr?s4 ~~dFUG,)  ! !%g 6E {{   u5;;+A+A M))  ! !% ( )))sAB<BB#z math.angleanglectj|d|g5}tj|d}|jjr5t j ||jj|cdddStj|dktjtj|ztj|cdddS#1swYyxYw)aReturns the element-wise argument of a complex (or real) tensor. Given a tensor `input`, this operation returns a tensor of type `float` that is the argument of each element in `input` considered as a complex number. The elements in `input` are considered to be complex numbers of the form \\(a + bj\\), where *a* is the real part and *b* is the imaginary part. If `input` is real then *b* is zero by definition. The argument returned by this function is of the form \\(atan2(b, a)\\). If `input` is real, a tensor of all zeros is returned. For example: ``` input = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j], dtype=tf.complex64) tf.math.angle(input).numpy() # ==> array([2.0131705, 1.056345 ], dtype=float32) ``` Args: input: A `Tensor`. Must be one of the following types: `float`, `double`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor` of type `float32` or `float64`. Anglerlr'rzNr)rr3r4r+r|rrr~rwherenppi ones_likerBrs rUrrasB ~~dGeW-:  ! !%g 6E {{   EKK,B,B N:: __UQY 0C0CE0J(J&11%8: :::sAC>> x = tf.constant([1.8, 2.2], dtype=tf.float32) >>> tf.cast(x, tf.int32) Notice `tf.cast` has an alias `tf.dtypes.cast`: >>> x = tf.constant([1.8, 2.2], dtype=tf.float32) >>> tf.dtypes.cast(x, tf.int32) The operation supports data types (for `x` and `dtype`) of `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`. In case of casting from complex types (`complex64`, `complex128`) to real types, only the real part of `x` is returned. In case of casting from real types to complex types (`complex64`, `complex128`), the imaginary part of the returned value is set to `0`. The handling of complex types here matches the behavior of numpy. Note casting nan and inf values to integral types has undefined behavior. Note this operation can lead to a loss of precision when converting native Python `float` and `complex` variables to `tf.float64` or `tf.complex128` tensors, since the input is first converted to the `float32` data type and then widened. It is recommended to use `tf.convert_to_tensor` instead of `tf.cast` for any non-tensor inputs. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices` of numeric type. It could be `uint8`, `uint16`, `uint32`, `uint64`, `int8`, `int16`, `int32`, `int64`, `float16`, `float32`, `float64`, `complex64`, `complex128`, `bfloat16`. dtype: The destination type. The list of supported dtypes is the same as `x`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` and same type as `dtype`. Raises: TypeError: If `x` cannot be cast to the `dtype`. Castr'ryz!You are casting an input of type z to an incompatible dtype zI. This will discard the imaginary part and may not be what you intended.N)rrrr tensor_libTensorrIsResourceVariabler+rr3r SparseTensorr6rrrrrr4r| is_floatingloggingwarnr(r)ryr+r( base_type values_casts rUr6r6snnooe$//)J%%&-*J*J1*MQWW H ~~dFQC( D!]//0948k  $ $QYY Q]] Ka A~33 4948k  & &{AIIq}} Ma    ,a    5 5 / ~>""+..!12  I    a 6 -   s 8EGG#zdtypes.saturate_cast saturate_castc tj|d|g5}tj|d}tj|j }|j }|jr,|jr|j}|j}|j|jks|j|jkDrtj|tjtj|j|j|tjtj|j|j|d}t|||cdddSt!|}t#j$d|j}|j}t'j(dd d s3|j|jks|j|jkDrh|j*} t-j.||j*}|t-j4|j|j} t-j6| |jg|} | d | d krt-j8| |d |} |t-j:|j|j} t-j6| |jg|} | d | d kDrt-j8| |d |} tj|tj| |tj| |d}t|||cdddS#t0$r t2}YdwxYw#1swYyxYw) aPerforms a safe saturating cast of `value` to `dtype`. This function casts the input to `dtype` without overflow. If there is a danger that values would over or underflow in the cast, this op applies the appropriate clamping before the cast. See `tf.cast` for more details. Args: value: A `Tensor`. dtype: The desired output `DType`. name: A name for the operation (optional). Returns: `value` safely cast to `dtype`. rvaluer'r-clampNz0Casting complex to real discards imaginary part.i r1r)rr3r4rrrr+r|r~minmaxr_clip_by_valuebuiltinsrr6rrrforward_compatforward_compatibleas_numpy_dtyper promote_typesrfloatr<array nextafterminimum) rr+r(in_dtype real_in_dtypereal_out_dtypeout_real_dtypenp_dtype promoted_type min_limitpromoted max_limits rUrrs* ~~dOeW5O)  ! !%g 6E OOE " - -E{{H    ++ ))    2 2 2  >#5#55--##"">#5#5~7I7IJ "##"">#5#5~7I7IJ "%E5t,/O)O)4U  GH&&%%N ))$A6 <<.,, , <<.,, ,((h (( n33 2::hllN4F4FGHi9n&8&89Oh !x{ "LLHQKxH 2::hllN4F4FGHi9n&8&89Oh !x{ "LLHQKxH ))     :    : e u4 (_O)O)r sO)O)s8EN)BN8 M*EN*M=9N<M==NN to_floatzUse `tf.cast` instead.)date instructionsc:t|tj|S)aCasts a tensor to type `float32`. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with type `float32`. Raises: TypeError: If `x` cannot be cast to the `float32`. @compatibility(TF2) This name was deprecated and removed in TF2, but has an exact replacement `tf.cast(..., tf.float32)`. There are no further issues with eager execution or tf.function. Before: >>> tf.compat.v1.to_float(tf.constant(3.14, dtype=tf.double)) After: >>> tf.cast(tf.constant(3.14, dtype=tf.double), tf.float32) @end_compatibility r')r6rrrs rUr r hJ ad ++r` to_doublec:t|tj|S)aCasts a tensor to type `float64`. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with type `float64`. Raises: TypeError: If `x` cannot be cast to the `float64`. @compatibility(TF2) This name was deprecated and removed in TF2, but has an exact replacement `tf.cast(..., tf.double)`. There are no further issues with eager execution or tf.function. Before: >>> tf.compat.v1.to_double(tf.constant(3.14, dtype=tf.float32)) After: >>> tf.cast(tf.constant(3.14, dtype=tf.float32), tf.double) @end_compatibility r')r6rrrs rUrrrr`to_int32c:t|tj|S)aCasts a tensor to type `int32`. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with type `int32`. Raises: TypeError: If `x` cannot be cast to the `int32`. @compatibility(TF2) This name was deprecated and removed in TF2, but has an exact replacement `tf.cast(..., tf.int32)`. There are no further issues with eager execution or tf.function. Before: >>> tf.compat.v1.to_int32(tf.constant(1, dtype=tf.int64)) After: >>> tf.cast(tf.constant(1, dtype=tf.int64), tf.int32) @end_compatibility r')r6rint32rs rUrrJ aD ))r`to_int64c:t|tj|S)aCasts a tensor to type `int64`. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with type `int64`. Raises: TypeError: If `x` cannot be cast to the `int64`. @compatibility(TF2) This name was deprecated and removed in TF2, but has an exact replacement `tf.cast(..., tf.int64)`. There are no further issues with eager execution or tf.function. Before: >>> tf.compat.v1.to_int64(tf.constant(1, dtype=tf.int32)) After: >>> tf.cast(tf.constant(1, dtype=tf.int32), tf.int64) @end_compatibility r')r6rr>rs rUrrrr` to_bfloat16c:t|tj|S)a)Casts a tensor to type `bfloat16`. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with type `bfloat16`. Raises: TypeError: If `x` cannot be cast to the `bfloat16`. @compatibility(TF2) This name was deprecated and removed in TF2, but has an exact replacement `tf.cast(..., tf.bfloat16)`. There are no further issues with eager execution or tf.function. Before: >>> tf.compat.v1.to_bfloat16(tf.constant(3.14, dtype=tf.float32)) After: >>> tf.cast(tf.constant(3.14, dtype=tf.float32), tf.bfloat16) @end_compatibility r')r6rbfloat16rs rUrrsJ at ,,r` to_complex64c:t|tj|S)aCCasts a tensor to type `complex64`. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with type `complex64`. Raises: TypeError: If `x` cannot be cast to the `complex64`. @compatibility(TF2) This name was deprecated and removed in TF2, but has an exact replacement `tf.cast(..., tf.complex64)`. There are no further issues with eager execution or tf.function. Before: >>> tf.compat.v1.to_complex64(tf.constant(1. + 2.j, dtype=tf.complex128)) After: >>> tf.cast(tf.constant(1. + 2.j, dtype=tf.complex128), tf.complex64) @end_compatibility r')r6rrrs rUrr0sJ a!! --r` to_complex128c:t|tj|S)aICasts a tensor to type `complex128`. Args: x: A `Tensor` or `SparseTensor` or `IndexedSlices`. name: A name for the operation (optional). Returns: A `Tensor` or `SparseTensor` or `IndexedSlices` with same shape as `x` with type `complex128`. Raises: TypeError: If `x` cannot be cast to the `complex128`. @compatibility(TF2) This name was deprecated and removed in TF2, but has an exact replacement `tf.cast(..., tf.complex128)`. There are no further issues with eager execution or tf.function. Before: >>> tf.compat.v1.to_complex128(tf.constant(1. + 2.j, dtype=tf.complex64)) After: >>> tf.cast(tf.constant(1. + 2.j, dtype=tf.complex64), tf.complex128) @end_compatibility r')r6rrrs rUrrXsJ a"" ..r`ctj|d||g5}tj|d}tj||jjd}|jj}|jj}||k7rt d|d|d t |}|t||}t||}tj|||cdddS#t$rQt d |d d jt jDcgc] }t|ncc}wc}d wxYw#1swYyxYw) Ntruedivryr'r dtype_hintr(*`x` and `y` must have the same dtype, got  != rInvalid dtype z" in __truediv__. Expected one of {, }.)rr3r4r+rr_TRUEDIV_TABLEKeyErrorjoinkeysreprr6rreal_div)ryrr(x_dtypey_dtyper+s rUrrsL ~~dI1v.2$ ac*A aAGG,>,>SIAgg  Ggg  G' $KtG;a9 ::LW%e   q%.a q%.a  AD 1#22 L  7+&))n.A.A.CDT!WDDEFc K LLL22s0BE" C&+1E&3ED,+EEE ctj|d||g5}tj|d}tj|d|jj}|jj}|jj}||k7rt d|d|d|j s |jr!tj|||cd d d Stj|||cd d d S#1swYy xYw) aDivide two values using Python 2 semantics. Used for Tensor.__div__. Args: x: `Tensor` numerator of real numeric type. y: `Tensor` denominator of real numeric type. name: A name for the operation (optional). Returns: `x / y` returns the quotient of x and y. divryr'rr*r$r%rN) rr3r4r+rrrr|rr. floor_divryrr(r/r0s rUrrs ~~dEAq6* 5d ac*A ac1C1CDAgg  Ggg  G' $KtG;a9 ::g00  " "1ad 3 5 5 # #Aqt 4 5 5 5sB6C;C;;Dz math.truedivr!ct|||S)aDivides x / y elementwise (using Python 3 division operator semantics). NOTE: Prefer using the Tensor operator or tf.divide which obey Python division operator semantics. This function forces Python 3 division operator semantics where all integer arguments are cast to floating types first. If you want integer division that rounds down, use `x // y` or `tf.math.floordiv`. `x` and `y` must have the same numeric type. If the inputs are floating point, the output will have the same type. If the inputs are integral, the inputs are cast to `float32` for `int8` and `int16` and `float64` for `int32` and `int64` (matching the behavior of Numpy). Example: >>> # Division with integer tensors (returns float) >>> x1 = tf.constant([10, 20, 30], dtype=tf.int32) >>> y1 = tf.constant([2, 4, 5], dtype=tf.int32) >>> result1 = tf.math.truediv(x1, y1) >>> # Division with different shaped tensors (broadcasting) >>> x2 = tf.constant([[10, 20], [30, 40]], dtype=tf.float64) >>> y2 = tf.constant([2, 5], dtype=tf.float64) >>> result2 = tf.math.truediv(x2, y2) # Handling potential division by zero (returns inf) >>> x3 = tf.constant(5, dtype=tf.float32) >>> y3 = tf.constant(0, dtype=tf.float32) >>> result3 = tf.math.truediv(x3, y3) Args: x: `Tensor` numerator of numeric type. y: `Tensor` denominator of numeric type. name: A name for the operation (optional). Returns: `x / y` evaluated in floating point. Raises: TypeError: If `x` and `y` have different dtypes. )rrs rUr!r!sh !Q %%r`r2z2Deprecated in favor of operator or tf.math.divide.ct|||S)aDivides x / y elementwise (using Python 2 division operator semantics). @compatibility(TF2) This function is deprecated in TF2. Prefer using the Tensor division operator, `tf.divide`, or `tf.math.divide`, which obey the Python 3 division operator semantics. @end_compatibility This function divides `x` and `y`, forcing Python 2 semantics. That is, if `x` and `y` are both integers then the result will be an integer. This is in contrast to Python 3, where division with `/` is always a float while division with `//` is always an integer. Args: x: `Tensor` numerator of real numeric type. y: `Tensor` denominator of real numeric type. name: A name for the operation (optional). Returns: `x / y` returns the quotient of x and y. )rrs rUr2r2s: aD !!r`zmath.divide_no_nanrctj|d||g5}tj|sYtj|rDtj|d}tj||j j d}nCtj|d}tj||j j d}|j j }|j j }||k7rtd|d|d  t|}|t||}t||}tj|||cdddS#t$rV}td |d d jtjDcgc] }t|ncc}wc}d |d}~wwxYw#1swYyxYw)aComputes a safe divide which returns 0 if `y` (denominator) is zero. For example: >>> tf.constant(3.0) / 0.0 >>> tf.math.divide_no_nan(3.0, 0.0) Note that 0 is returned if `y` is 0 even if `x` is nonfinite: >>> tf.math.divide_no_nan(np.nan, 0.0) Args: x: A `Tensor` of a floating or integer dtype. y: A `Tensor` with the same dtype as `x` and a compatible shape. name: A name for the operation (optional). Returns: The element-wise quotient as in `tf.math.divide(x, y)`, except that division by zero produces `0.0`, not `nan`. rrr'ryrr"r$r%rr&z, in tf.math.divide_no_nan. Expected one of {r'r(N)rr3rrr4r+rrr)r*r+r,r-r6rr)ryrr(r/r0r+es rUrrs: ~~dL1a&14T  ! !! $)?)?)B   ,a  ););# Fa   ,a  agg.@.@s Kagg  Ggg  G' $KtG;a9 ::W%e   q%.a q%.a  " "1ad 3/44   7+&))n.A.A.CDT!WDDEFc K 44s<C5F6 E1F6 F3*F.FF..F33F66F?zmath.multiply_no_nanctj|d||g5}tj|d}tj|d|jj}|jj}|jj}||k7rt d|d|t j|||cdddS#1swYyxYw) aComputes the product of x and y and returns 0 if the y is zero, even if x is NaN or infinite. Note this is noncommutative: if y is NaN or infinite and x is 0, the result will be NaN. Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`. y: A `Tensor` whose dtype is compatible with `x`. name: A name for the operation (optional). Returns: The element-wise value of the x times y. multiply_no_nanryr'rr*r$r%N)rr3r4r+rrr mul_no_nanr4s rUr:r:Rs$ ~~d-1v64$ ac*A ac1C1CDAgg  Ggg  G' $KtG;8 99  " "1ad 3444s BCC ctj|d||g5}tj|||cdddS#1swYyxYw)aReturns element-wise remainder of division. This follows Python semantics in that the result here is consistent with a flooring divide. E.g. `floor(x / y) * y + floormod(x, y) = x`, regardless of the signs of x and y. *NOTE*: `math.floormod` supports broadcasting. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) Args: x: A `Tensor`. Must be one of the following types: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`, `bfloat16`, `half`, `float32`, `float64`. y: A `Tensor`. Must have the same type as `x`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. modr'N)rr3r floor_modrs rUr=r=osA( ~~dEAq6*3d  ! !!QT 2333 <Az math.floordivrctj|d||g5}tj|||cdddS#1swYyxYw)aDivides `x / y` elementwise, rounding toward the most negative integer. Mathematically, this is equivalent to floor(x / y). For example: floor(8.4 / 4.0) = floor(2.1) = 2.0 floor(-8.4 / 4.0) = floor(-2.1) = -3.0 This is equivalent to the '//' operator in Python 3.0 and above. Note: `x` and `y` must have the same type, and the result will have the same type as well. Args: x: `Tensor` numerator of real numeric type. y: `Tensor` denominator of real numeric type. name: A name for the operation (optional). Returns: `x / y` rounded toward -infinity. Raises: TypeError: If the inputs are complex. rr'N)rr3rr3rs rUrrsA4 ~~dJA/34  ! !!QT 2333r?z__operators__.addctjrt|||St|tj sFt|t js,tj||jjd}|jtjk(rtj|||Stj|||S)alThe operation invoked by the `Tensor.__add__` operator. Purpose in the API: This method is exposed in TensorFlow's API so that library developers can register dispatching for `Tensor.__add__` to allow it to handle custom composite tensors & other custom objects. The API symbol is not intended to be called by users directly and does appear in TensorFlow's generated documentation. Args: x: The left-hand side of the `+` operator. y: The right-hand side of the `+` operator. name: an optional name for the operation. Returns: The result of the elementwise `+` operation. r'rr")r is_auto_dtype_conversion_enabledaddrrrr rr4r+rrstringradd_v2rs rU _add_dispatchrFs, ))+ q!$  Az(( )* # #3% aAGG,>,>SIAWW    Aqt ,,   q!$ //r`ct|tjrbtj|j |j |j||}tj|j ||jSt|||S)z:Dispatches cwise mul for "Dense*Dense" and "Dense*Sparse".r') rr rrsparse_dense_cwise_mulrrrr)ryrr(new_valss rU _mul_dispatchrJsf=--.44QYY56]]AtMH  % %aii1== II Aqt $$r`zmath.logical_xor logical_xorc tjtj||tjtj|||S)a~Logical XOR function. x ^ y = (x | y) & ~(x & y) Requires that `x` and `y` have the same shape or have [broadcast-compatible](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) shapes. For example, `x` and `y` can be: - Two single elements of type `bool` - One `tf.Tensor` of type `bool` and one single `bool`, where the result will be calculated by applying logical XOR with the single element to each element in the larger Tensor. - Two `tf.Tensor` objects of type `bool` of the same shape. In this case, the result will be the element-wise logical XOR of the two input tensors. Usage: >>> a = tf.constant([True]) >>> b = tf.constant([False]) >>> tf.math.logical_xor(a, b) >>> c = tf.constant([True]) >>> x = tf.constant([False, True, True, False]) >>> tf.math.logical_xor(c, x) >>> y = tf.constant([False, False, True, True]) >>> z = tf.constant([False, True, False, True]) >>> tf.math.logical_xor(y, z) Args: x: A `tf.Tensor` type bool. y: A `tf.Tensor` of type bool. name: A name for the operation (optional). Returns: A `tf.Tensor` of type bool with the same size as that of x or y. r')r logical_and logical_or logical_notrs rUrKrKsF\  ! !a#|771=>  r`c|jtjk(rtj|||St j ||Sr[)r+rboolrrMr bitwise_andrs rUand_rS s:WW   # #Aq$ //  $ $Q **r`c|jtjk(rtj|||St j ||Sr[)r+rrQrrNr bitwise_orrs rUor_rVs:WW   " "1a ..  # #Aq ))r`c|jtjk(r t|||St j ||Sr[)r+rrQrKr bitwise_xorrs rUxor_rYs4WW  q!T ""  $ $Q **r`c|jtjk(rtj||St j ||SNr')r+rrQrrOrinvertrs rUinvert_r]s8WW   # #AD 11    --r`z math.equalr?c2tj|||S)aJReturns the truth value of (x == y) element-wise. Performs a [broadcast]( https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) with the arguments and then an element-wise equality comparison, returning a Tensor of boolean values. For example: >>> x = tf.constant([2, 4]) >>> y = tf.constant(2) >>> tf.math.equal(x, y) >>> x = tf.constant([2, 4]) >>> y = tf.constant([2, 4]) >>> tf.math.equal(x, y) Args: x: A `tf.Tensor`. y: A `tf.Tensor`. name: A name for the operation (optional). Returns: A `tf.Tensor` of type bool with the same size as that of x or y. Raises: `tf.errors.InvalidArgumentError`: If shapes of arguments are incompatible r')rr?rs rUr?r?#sD   Aqt ,,r`zmath.not_equal not_equalc2tj|||S)aTReturns the truth value of (x != y) element-wise. Performs a [broadcast]( https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) with the arguments and then an element-wise inequality comparison, returning a Tensor of boolean values. For example: >>> x = tf.constant([2, 4]) >>> y = tf.constant(2) >>> tf.math.not_equal(x, y) >>> x = tf.constant([2, 4]) >>> y = tf.constant([2, 4]) >>> tf.math.not_equal(x, y) Args: x: A `tf.Tensor`. y: A `tf.Tensor`. name: A name for the operation (optional). Returns: A `tf.Tensor` of type bool with the same size as that of x or y. Raises: `tf.errors.InvalidArgumentError`: If shapes of arguments are incompatible r')rr_rs rUr_r_HsD   14 00r`z__operators__.eqc|yt|dd}tjjrSt j r?| |j r1tj||\}}tj||dS||uS)aThe operation invoked by the `Tensor.__eq__` operator. Compares two tensors element-wise for equality if they are broadcast-compatible; or returns False if they are not broadcast-compatible. (Note that this behavior differs from `tf.math.equal`, which raises an exception if the two tensors are not broadcast-compatible.) Purpose in the API: This method is exposed in TensorFlow's API so that library developers can register dispatching for `Tensor.__eq__` to allow it to handle custom composite tensors & other custom objects. The API symbol is not intended to be called by users directly and does appear in TensorFlow's generated documentation. Args: self: The left-hand side of the `==` operator. other: The right-hand side of the `==` operator. Returns: The result of the elementwise `==` operation, or `False` if the arguments are not broadcast-compatible. NFgraphincompatible_shape_error) getattrrr _USE_EQUALITYr#executing_eagerly_outside_functionsbuilding_functionr maybe_promote_tensorsrr?)rothergs rU tensor_equalsrlmsy6 ]  dGT"!%% 1 1 3 9++*@@uMKD%   dEE JJ 5=r`z__operators__.nec|ytjjrEtjr1t j ||\}}tj||dS||uS)aThe operation invoked by the `Tensor.__ne__` operator. Compares two tensors element-wise for inequality if they are broadcast-compatible; or returns True if they are not broadcast-compatible. (Note that this behavior differs from `tf.math.not_equal`, which raises an exception if the two tensors are not broadcast-compatible.) Purpose in the API: This method is exposed in TensorFlow's API so that library developers can register dispatching for `Tensor.__ne__` to allow it to handle custom composite tensors & other custom objects. The API symbol is not intended to be called by users directly and does appear in TensorFlow's generated documentation. Args: self: The left-hand side of the `!=` operator. other: The right-hand side of the `!=` operator. Returns: The result of the elementwise `!=` operation, or `True` if the arguments are not broadcast-compatible. TFrc) rrrfrrgr rirr_)rrjs rUtensor_not_equalsrns_6 ] %% 1 1 3*@@uMKD%  ! !$ NN u r`r=cx|d|}}tj|d|||g5}t|tjstj ||d}t|tjstj ||d}t|tjstj ||d}|t jt jt jt jt jt jgtfd|||fDsJt|||fDcgc]}|jc}j }n|}t#||}t#||}t#||}t%j&|||| cdddScc}w#1swYyxYw) aCreates a sequence of numbers. Creates a sequence of numbers that begins at `start` and extends by increments of `delta` up to but not including `limit`. The dtype of the resulting tensor is inferred from the inputs unless it is provided explicitly. Like the Python builtin `range`, `start` defaults to 0, so that `range(n) = range(0, n)`. For example: >>> start = 3 >>> limit = 18 >>> delta = 3 >>> tf.range(start, limit, delta) >>> start = 3 >>> limit = 1 >>> delta = -0.5 >>> tf.range(start, limit, delta) >>> limit = 5 >>> tf.range(limit) Args: start: A 0-D `Tensor` (scalar). Acts as first entry in the range if `limit` is not None; otherwise, acts as range limit and first entry defaults to 0. limit: A 0-D `Tensor` (scalar). Upper limit of sequence, exclusive. If None, defaults to the value of `start` while the first entry of the range defaults to 0. delta: A 0-D `Tensor` (scalar). Number that increments `start`. Defaults to 1. dtype: The type of the elements of the resulting tensor. name: A name for the operation. Defaults to "range". Returns: An 1-D `Tensor` of type `dtype`. @compatibility(numpy) Equivalent to np.arange @end_compatibility NrRanger&rlimitrKc3:K|]}|jvywr[r-).0argdtype_hierarchys rU zrange.. sO#o-Os)keyr')rr3rrrr4rrr>float16rrrallrr+indexr6r_range)r&rqrKr+r(rtinferred_dtyperus @rUr=r=szj ]e5E ~~dGeUE%:;?t eZ.. /##EWEe eZ.. /##EWEe eZ.. /##EWEe } ,, ,, .. // .. .. oO%9NO OO O%1FG#CIIG.446nn  'E  'E  'E   ueU >=??&H'??sDF0<F+ AF0+F00F9c`~t|j|j|j||S)Nr)r=r&r)step)rr+r(as_refs rU!_range_tensor_conversion_functionrs$ u{{EJJ %d KKr`c ||S |jj}|r8tjt j |t jStdtj|S#t$rd}YfwxYw)z*Returns range(0, rank(x)) if axis is None.Nr-r) r8rankAttributeErrorrconstantrarangerr=r)ryr/x_ranks rU_ReductionDimsr#sr  Kww||f   ! !"))F"(("C DD1innQ' (( fsA55 BBcnt|tjxs|jj S)z1Returns true if tensor has a fully defined shape.)rr EagerTensorr8is_fully_definedr s rU_has_fully_defined_shaper5s% FCOO , O 0M0M0OOr`cFt|s|s||jd|S)z@Set a reduction's output shape to be a scalar if we are certain.ra)r set_shape)keepdimsr/outputs rU_may_reduce_to_scalarr:s$ !& )8 l R -r`zmath.reduce_sum reduce_sumz-keep_dims is deprecated, use keepdims instead keep_dimsc~tjd|d|}tjd|d|}t||||S)aComputes the sum of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.add` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> # x has a shape of (2, 3) (two rows and three columns): >>> x = tf.constant([[1, 1, 1], [1, 1, 1]]) >>> x.numpy() array([[1, 1, 1], [1, 1, 1]], dtype=int32) >>> # sum all the elements >>> # 1 + 1 + 1 + 1 + 1+ 1 = 6 >>> tf.reduce_sum(x).numpy().item() 6 >>> # reduce along the first dimension >>> # the result is [1, 1, 1] + [1, 1, 1] = [2, 2, 2] >>> tf.reduce_sum(x, 0).numpy() array([2, 2, 2], dtype=int32) >>> # reduce along the second dimension >>> # the result is [1, 1] + [1, 1] + [1, 1] = [3, 3] >>> tf.reduce_sum(x, 1).numpy() array([3, 3], dtype=int32) >>> # keep the original dimensions >>> tf.reduce_sum(x, 1, keepdims=True).numpy() array([[3], [3]], dtype=int32) >>> # reduce along both dimensions >>> # the result is 1 + 1 + 1 + 1 + 1 + 1 = 6 >>> # or, equivalently, reduce along rows, then reduce the resultant array >>> # [1, 1, 1] + [1, 1, 1] = [2, 2, 2] >>> # 2 + 2 + 2 = 6 >>> tf.reduce_sum(x, [0, 1]).numpy().item() 6 Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor, of the same dtype as the input_tensor. @compatibility(numpy) Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to int64 while tensorflow returns the same dtype as the input. @end_compatibility r/reduction_indicesrr)rrir input_tensorr/rr(rrs rU reduce_sum_v1rBsMP  / /0C0A C$ 3 3J4?L( L$$ 77r`c 4t||||t||S)aComputes the sum of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.add` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> # x has a shape of (2, 3) (two rows and three columns): >>> x = tf.constant([[1, 1, 1], [1, 1, 1]]) >>> x.numpy() array([[1, 1, 1], [1, 1, 1]], dtype=int32) >>> # sum all the elements >>> # 1 + 1 + 1 + 1 + 1+ 1 = 6 >>> tf.reduce_sum(x).numpy().item() 6 >>> # reduce along the first dimension >>> # the result is [1, 1, 1] + [1, 1, 1] = [2, 2, 2] >>> tf.reduce_sum(x, 0).numpy() array([2, 2, 2], dtype=int32) >>> # reduce along the second dimension >>> # the result is [1, 1] + [1, 1] + [1, 1] = [3, 3] >>> tf.reduce_sum(x, 1).numpy() array([3, 3], dtype=int32) >>> # keep the original dimensions >>> tf.reduce_sum(x, 1, keepdims=True).numpy() array([[3], [3]], dtype=int32) >>> # reduce along both dimensions >>> # the result is 1 + 1 + 1 + 1 + 1 + 1 = 6 >>> # or, equivalently, reduce along rows, then reduce the resultant array >>> # [1, 1, 1] + [1, 1, 1] = [2, 2, 2] >>> # 2 + 2 + 2 = 6 >>> tf.reduce_sum(x, [0, 1]).numpy().item() 6 Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor)]`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor, of the same dtype as the input_tensor. @compatibility(numpy) Equivalent to np.sum apart the fact that numpy upcast uint8 and int32 to int64 while tensorflow returns the same dtype as the input. @end_compatibility )reduce_sum_with_dimsrrr/rr(s rUrrs&~ lD(D,\4@ BBr`c h|dn t|}t||tj||||SNFr')rQrr_sumrr/rr(dimss rUrr< &UDN(  dH4@ BBr`zmath.reduce_euclidean_normc tt|}t||tj|t ||||S)aComputes the Euclidean norm of elements across dimensions of a tensor. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: ```python x = tf.constant([[1, 2, 3], [1, 1, 1]]) # x.dtype is tf.int32 tf.math.reduce_euclidean_norm(x) # returns 4 as dtype is tf.int32 y = tf.constant([[1, 2, 3], [1, 1, 1]], dtype = tf.float32) tf.math.reduce_euclidean_norm(y) # returns 4.1231055 which is sqrt(17) tf.math.reduce_euclidean_norm(y, 0) # [sqrt(2), sqrt(5), sqrt(10)] tf.math.reduce_euclidean_norm(y, 1) # [sqrt(14), sqrt(3)] tf.math.reduce_euclidean_norm(y, 1, keepdims=True) # [[sqrt(14)], [sqrt(3)]] tf.math.reduce_euclidean_norm(y, [0, 1]) # sqrt(17) ``` Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor, of the same dtype as the input_tensor. r')rQrreuclidean_normrrs rUreduce_euclidean_normrs?J(^( !! |T:H r`zmath.count_nonzero count_nonzeroz1reduction_indices is deprecated, use axis insteadrctjd|d|}tjd|d|}tjd|d|}t|||||S)a,Computes number of nonzero elements across dimensions of a tensor. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` has no entries, all dimensions are reduced, and a tensor with a single element is returned. **NOTE** Floating point comparison to zero is done by exact floating point equality check. Small values are **not** rounded to zero for purposes of the nonzero check. For example: ```python x = tf.constant([[0, 1, 0], [1, 1, 0]]) tf.math.count_nonzero(x) # 3 tf.math.count_nonzero(x, 0) # [1, 2, 0] tf.math.count_nonzero(x, 1) # [1, 2] tf.math.count_nonzero(x, 1, keepdims=True) # [[1], [2]] tf.math.count_nonzero(x, [0, 1]) # 3 ``` **NOTE** Strings are compared against zero-length empty string `""`. Any string with a size greater than zero is already considered as nonzero. For example: ```python x = tf.constant(["", "a", " ", "b", ""]) tf.math.count_nonzero(x) # 3, with "a", " ", and "b" as nonzero strings. ``` Args: input_tensor: The tensor to reduce. Should be of numeric type, `bool`, or `string`. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. dtype: The output dtype; defaults to `tf.int64`. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. input: Overrides input_tensor. For compatibility. Returns: The reduced tensor (number of nonzero values). rrrlrr/r)rricount_nonzero_v2)rr/rr+r(rrrls rUrr slD 3 3J4?L(778F8DF,  / /0C0A C$ ,ht DDr`c |d}tj|d|g5tj|d}|jtj k(r|}n7t jg|j}tj||}ttt|tj|||cdddS#1swYyxYw)acComputes number of nonzero elements across dimensions of a tensor. Reduces `input` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` has no entries, all dimensions are reduced, and a tensor with a single element is returned. **NOTE** Floating point comparison to zero is done by exact floating point equality check. Small values are **not** rounded to zero for purposes of the nonzero check. For example: ```python x = tf.constant([[0, 1, 0], [1, 1, 0]]) tf.math.count_nonzero(x) # 3 tf.math.count_nonzero(x, 0) # [1, 2, 0] tf.math.count_nonzero(x, 1) # [1, 2] tf.math.count_nonzero(x, 1, keepdims=True) # [[1], [2]] tf.math.count_nonzero(x, [0, 1]) # 3 ``` **NOTE** Strings are compared against zero-length empty string `""`. Any string with a size greater than zero is already considered as nonzero. For example: ```python x = tf.constant(["", "a", " ", "b", ""]) tf.math.count_nonzero(x) # 3, with "a", " ", and "b" as nonzero strings. ``` Args: input: The tensor to reduce. Should be of numeric type, `bool`, or `string`. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input), rank(input))`. keepdims: If true, retains reduced dimensions with length 1. dtype: The output dtype; defaults to `tf.int64`. name: A name for the operation (optional). Returns: The reduced tensor (number of nonzero values). NFrrlr'r-r/r) rr3r4r+rrQrzerosrr_r6rr>)rlr/rr+r( predicatezeros rUrr[ sjH ~~dOeW5  ! !%g 6E {{fkk!i__Ru{{ 3d((5i  FLL )   s BCCzmath.reduce_mean reduce_meanc~tjd|d|}tjd|d|}t||||S)aSComputes the mean of elements across dimensions of a tensor. Reduces `input_tensor` along the dimensions given in `axis` by computing the mean of elements across the dimensions in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[1., 1.], [2., 2.]]) >>> tf.reduce_mean(x) >>> tf.reduce_mean(x, 0) >>> tf.reduce_mean(x, 1) Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.mean Please note that `np.mean` has a `dtype` parameter that could be used to specify the output type. By default this is `dtype=float64`. On the other hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`, for example: >>> x = tf.constant([1, 0, 1, 0]) >>> tf.reduce_mean(x) >>> y = tf.constant([1., 0., 1., 0.]) >>> tf.reduce_mean(y) @end_compatibility r/rrr)rrirrs rUreduce_mean_v1r sMv  / /0C0A C$ 3 3J4?L( \44 88r`c ||dn t|}t||tj|t ||||S)aComputes the mean of elements across dimensions of a tensor. Reduces `input_tensor` along the dimensions given in `axis` by computing the mean of elements across the dimensions in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[1., 1.], [2., 2.]]) >>> tf.reduce_mean(x) >>> tf.reduce_mean(x, 0) >>> tf.reduce_mean(x, 1) Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.mean Please note that `np.mean` has a `dtype` parameter that could be used to specify the output type. By default this is `dtype=float64`. On the other hand, `tf.reduce_mean` has an aggressive type inference from `input_tensor`, for example: >>> x = tf.constant([1, 0, 1, 0]) >>> tf.reduce_mean(x) >>> y = tf.constant([1., 0., 1., 0.]) >>> tf.reduce_mean(y) @end_compatibility Fr')rQrrmeanrrs rUrr sFh&UDN(  |T:H r`zmath.reduce_variancec.|r|nd}tj|5tj|}t||d}|jj rt d|jd||z }|jjrU|jj}tjtjtj|||}ntj|}t|||cdddS#1swYyxYw)aComputes the variance of elements across dimensions of a tensor. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[1., 2.], [3., 4.]]) >>> tf.math.reduce_variance(x) >>> tf.math.reduce_variance(x, 0) >>> tf.math.reduce_variance(x, 1) Args: input_tensor: The tensor to reduce. Should have real or complex type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name scope for the associated operations (optional). Returns: The reduced tensor, of the same dtype as the input_tensor. Note, for `complex64` or `complex128` input, the returned `Tensor` will be of type `float32` or `float64`, respectively. @compatibility(numpy) Equivalent to np.var Please note `np.var` has a `dtype` parameter that could be used to specify the output type. By default this is `dtype=float64`. On the other hand, `tf.math.reduce_variance` has aggressive type inference from `input_tensor`. @end_compatibility reduce_varianceTrz ?? % D zz::((j',,   <,,T2D 9 L(..t4 )x HIIIs C%D  Dzmath.reduce_stdc|r|nd}tj|5tj|}t|||}t j |cdddS#1swYyxYw)aComputes the standard deviation of elements across dimensions of a tensor. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[1., 2.], [3., 4.]]) >>> tf.math.reduce_std(x) >>> tf.math.reduce_std(x, 0) >>> tf.math.reduce_std(x, 1) Args: input_tensor: The tensor to reduce. Should have real or complex type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name scope for the associated operations (optional). Returns: The reduced tensor, of the same dtype as the input_tensor. Note, for `complex64` or `complex128` input, the returned `Tensor` will be of type `float32` or `float64`, respectively. @compatibility(numpy) Equivalent to np.std Please note `np.std` has a `dtype` parameter that could be used to specify the output type. By default this is `dtype=float64`. On the other hand, `tf.math.reduce_std` has aggressive type inference from `input_tensor`. @end_compatibility reduce_stdrN)rr3r4rrsqrt)rr/rr(variances rUrre s[X<$ ~~d'((6L|$JH   X &'''s 8AA'zmath.reduce_prod reduce_prodc ||dn t|}t||tj|t ||||S)a,Computes `tf.math.multiply` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.multiply` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each entry in `axis`. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[1., 2.], [3., 4.]]) >>> tf.math.reduce_prod(x) >>> tf.math.reduce_prod(x, 0) >>> tf.math.reduce_prod(x, 1) Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.prod @end_compatibility Fr')rQrrprodrrs rUrr sFR&UDN(  |T:H r`c~tjd|d|}tjd|d|}t||||S)aComputes `tf.math.multiply` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.multiply` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[1., 2.], [3., 4.]]) >>> tf.math.reduce_prod(x) >>> tf.math.reduce_prod(x, 0) >>> tf.math.reduce_prod(x, 1) Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.prod @end_compatibility r/rrr)rrirrs rUreduce_prod_v1r sMf  / /0C0A C$ 3 3J4?L( \44 88r`zmath.reduce_min reduce_minc~tjd|d|}tjd|d|}t||||S)aComputes the `tf.math.minimum` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.minimum` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. Usage example: >>> x = tf.constant([5, 1, 2, 4]) >>> tf.reduce_min(x) >>> x = tf.constant([-5, -1, -2, -4]) >>> tf.reduce_min(x) >>> x = tf.constant([4, float('nan')]) >>> tf.reduce_min(x) >>> x = tf.constant([float('nan'), float('nan')]) >>> tf.reduce_min(x) >>> x = tf.constant([float('-inf'), float('inf')]) >>> tf.reduce_min(x) See the numpy docs for `np.amin` and `np.nanmin` behavior. Args: input_tensor: The tensor to reduce. Should have real numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor. r/rrr)rrirrs rU reduce_min_v1r Mp  / /0C0A C$ 3 3J4?L( L$$ 77r`c ||dn t|}t||tj|t ||||S)a Computes the `tf.math.minimum` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.minimum` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> a = tf.constant([ ... [[1, 2], [3, 4]], ... [[1, 2], [3, 4]] ... ]) >>> tf.reduce_min(a) Choosing a specific axis returns minimum element in the given axis: >>> b = tf.constant([[1, 2, 3], [4, 5, 6]]) >>> tf.reduce_min(b, axis=0) >>> tf.reduce_min(b, axis=1) Setting `keepdims` to `True` retains the dimension of `input_tensor`: >>> tf.reduce_min(a, keepdims=True) >>> tf.math.reduce_min(a, axis=0, keepdims=True) Args: input_tensor: The tensor to reduce. Should have real numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.min @end_compatibility Fr')rQrr_minrrs rUrrD sFp&UDN(  |T:H r`zmath.reduce_max reduce_maxc~tjd|d|}tjd|d|}t||||S)aComputes `tf.math.maximum` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.maximum` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. Usage example: >>> x = tf.constant([5, 1, 2, 4]) >>> tf.reduce_max(x) >>> x = tf.constant([-5, -1, -2, -4]) >>> tf.reduce_max(x) >>> x = tf.constant([4, float('nan')]) >>> tf.reduce_max(x) >>> x = tf.constant([float('nan'), float('nan')]) >>> tf.reduce_max(x) >>> x = tf.constant([float('-inf'), float('inf')]) >>> tf.reduce_max(x) See the numpy docs for `np.amax` and `np.nanmax` behavior. Args: input_tensor: The tensor to reduce. Should have real numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor. r/rrr)rrirrs rU reduce_max_v1r rr`c 4t||||t||S)a>Computes `tf.math.maximum` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.maximum` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. Usage example: >>> x = tf.constant([5, 1, 2, 4]) >>> tf.reduce_max(x) >>> x = tf.constant([-5, -1, -2, -4]) >>> tf.reduce_max(x) >>> x = tf.constant([4, float('nan')]) >>> tf.reduce_max(x) >>> x = tf.constant([float('nan'), float('nan')]) >>> tf.reduce_max(x) >>> x = tf.constant([float('-inf'), float('inf')]) >>> tf.reduce_max(x) See the numpy docs for `np.amax` and `np.nanmax` behavior. Args: input_tensor: The tensor to reduce. Should have real numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor. )reduce_max_with_dimsrrs rUrr s&\ lD(D,\4@ BBr`c h|dn t|}t||tj||||Sr)rQrr_maxrs rUrr rr`zmath.reduce_all reduce_allc~tjd|d|}tjd|d|}t||||S)aComputes `tf.math.logical_and` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.logical_and` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[True, True], [False, False]]) >>> tf.math.reduce_all(x) >>> tf.math.reduce_all(x, 0) >>> tf.math.reduce_all(x, 1) Args: input_tensor: The boolean tensor to reduce. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.all @end_compatibility r/rrr)rrirrs rU reduce_all_v1r Md  / /0C0A C$ 3 3J4?L( L$$ 77r`c ||dn t|}t||tj|t ||||S)a(Computes `tf.math.logical_and` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.logical_and` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[True, True], [False, False]]) >>> tf.math.reduce_all(x) >>> tf.math.reduce_all(x, 0) >>> tf.math.reduce_all(x, 1) Args: input_tensor: The boolean tensor to reduce. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.all @end_compatibility Fr')rQrr_allrrs rUrr; FP&UDN(  |T:H r`zmath.reduce_any reduce_anyc~tjd|d|}tjd|d|}t||||S)aComputes `tf.math.logical_or` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.logical_or` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[True, True], [False, False]]) >>> tf.reduce_any(x) >>> tf.reduce_any(x, 0) >>> tf.reduce_any(x, 1) Args: input_tensor: The boolean tensor to reduce. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.any @end_compatibility r/rrr)rrirrs rU reduce_any_v1rk rr`c ||dn t|}t||tj|t ||||S)aComputes `tf.math.logical_or` of elements across dimensions of a tensor. This is the reduction operation for the elementwise `tf.math.logical_or` op. Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` is None, all dimensions are reduced, and a tensor with a single element is returned. For example: >>> x = tf.constant([[True, True], [False, False]]) >>> tf.reduce_any(x) >>> tf.reduce_any(x, 0) >>> tf.reduce_any(x, 1) Args: input_tensor: The boolean tensor to reduce. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor. @compatibility(numpy) Equivalent to np.any @end_compatibility Fr')rQrr_anyrrs rUrr rr`zmath.reduce_logsumexpreduce_logsumexpc~tjd|d|}tjd|d|}t||||S)aComputes log(sum(exp(elements across dimensions of a tensor))). Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` has no entries, all dimensions are reduced, and a tensor with a single element is returned. This function is more numerically stable than log(sum(exp(input))). It avoids overflows caused by taking the exp of large inputs and underflows caused by taking the log of small inputs. For example: ```python x = tf.constant([[0., 0., 0.], [0., 0., 0.]]) tf.reduce_logsumexp(x) # log(6) tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)] tf.reduce_logsumexp(x, 1) # [log(3), log(3)] tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]] tf.reduce_logsumexp(x, [0, 1]) # log(6) ``` Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). reduction_indices: The old (deprecated) name for axis. keep_dims: Deprecated alias for `keepdims`. Returns: The reduced tensor. r/rrr)rrirrs rUreduce_logsumexp_v1r sMb  / /0C0A C$ 3 3J4?L( ,h ==r`c tj|d|g5}t||d}tjt j t j||d}t jttt||||}|s)tj|tj|}t|||}t!|||cdddS#1swYyxYw)aGComputes log(sum(exp(elements across dimensions of a tensor))). Reduces `input_tensor` along the dimensions given in `axis`. Unless `keepdims` is true, the rank of the tensor is reduced by 1 for each of the entries in `axis`, which must be unique. If `keepdims` is true, the reduced dimensions are retained with length 1. If `axis` has no entries, all dimensions are reduced, and a tensor with a single element is returned. This function is more numerically stable than log(sum(exp(input))). It avoids overflows caused by taking the exp of large inputs and underflows caused by taking the log of small inputs. For example: ```python x = tf.constant([[0., 0., 0.], [0., 0., 0.]]) tf.reduce_logsumexp(x) # log(6) tf.reduce_logsumexp(x, 0) # [log(2), log(2), log(2)] tf.reduce_logsumexp(x, 1) # [log(3), log(3)] tf.reduce_logsumexp(x, 1, keepdims=True) # [[log(3)], [log(3)]] tf.reduce_logsumexp(x, [0, 1]) # log(6) ``` Args: input_tensor: The tensor to reduce. Should have numeric type. axis: The dimensions to reduce. If `None` (the default), reduces all dimensions. Must be in the range `[-rank(input_tensor), rank(input_tensor))`. keepdims: If true, retains reduced dimensions with length 1. name: A name for the operation (optional). Returns: The reduced tensor. ReduceLogSumExpTrrr'N)rr3rr stop_gradientr select_v2 is_finitelogrexprr@rr8rCr)rr/rr(raw_maxmy_maxresults rUrr sN ~~d- ~>9$D4@G  $ $  " "7 +W  F   v. /  F   )<)t$j&t$j(g}|j|vxr|j|v}|jt$j&k(r,|jt$j*t$j,fvsI|jt$j&k(rG|jt$j*t$j,fvr|j|jk7rd}|rqt/||||||| }|jt$j&k(r7|jt$j&k(rt1|t$j&}|cd d d S|r2|xs|}|xs|}tj |||||| | | cd d d Stj2||||| | | cd d d S#1swYy xYw)aMultiplies matrix `a` by matrix `b`, producing `a` * `b`. The inputs must, following any transpositions, be tensors of rank >= 2 where the inner 2 dimensions specify valid matrix multiplication dimensions, and any further outer dimensions specify matching batch size. Both matrices must be of the same type. The supported types are: `bfloat16`, `float16`, `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`. Either matrix can be transposed or adjointed (conjugated and transposed) on the fly by setting one of the corresponding flag to `True`. These are `False` by default. If one or both of the matrices contain a lot of zeros, a more efficient multiplication algorithm can be used by setting the corresponding `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default. This optimization is only available for plain matrices (rank-2 tensors) with datatypes `bfloat16` or `float32`. A simple 2-D tensor matrix multiplication: >>> a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3]) >>> a # 2-D tensor >>> b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2]) >>> b # 2-D tensor >>> c = tf.matmul(a, b) >>> c # `a` * `b` A batch matrix multiplication with batch shape [2]: >>> a = tf.constant(np.arange(1, 13, dtype=np.int32), shape=[2, 2, 3]) >>> a # 3-D tensor >>> b = tf.constant(np.arange(13, 25, dtype=np.int32), shape=[2, 3, 2]) >>> b # 3-D tensor >>> c = tf.matmul(a, b) >>> c # `a` * `b` Since python >= 3.5 the @ operator is supported (see [PEP 465](https://www.python.org/dev/peps/pep-0465/)). In TensorFlow, it simply calls the `tf.matmul()` function, so the following lines are equivalent: >>> d = a @ b @ [[10], [11]] >>> d = tf.matmul(tf.matmul(a, b), [[10], [11]]) Args: a: `tf.Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128` and rank > 1. b: `tf.Tensor` with same type and rank as `a`. transpose_a: If `True`, `a` is transposed before multiplication. transpose_b: If `True`, `b` is transposed before multiplication. adjoint_a: If `True`, `a` is conjugated and transposed before multiplication. adjoint_b: If `True`, `b` is conjugated and transposed before multiplication. a_is_sparse: If `True`, `a` is treated as a sparse matrix. Notice, this **does not support `tf.sparse.SparseTensor`**, it just makes optimizations that assume most values in `a` are zero. See `tf.sparse.sparse_dense_matmul` for some support for `tf.sparse.SparseTensor` multiplication. b_is_sparse: If `True`, `b` is treated as a sparse matrix. Notice, this **does not support `tf.sparse.SparseTensor`**, it just makes optimizations that assume most values in `b` are zero. See `tf.sparse.sparse_dense_matmul` for some support for `tf.sparse.SparseTensor` multiplication. output_type: The output datatype if needed. Defaults to None in which case the output_type is the same as input type. Currently only works when input tensors are type (u)int8 and output_type can be int32. grad_a: Set it to `True` to hint that Tensor `a` is for the backward pass. grad_b: Set it to `True` to hint that Tensor `b` is for the backward pass. name: Name for the operation (optional). Returns: A `tf.Tensor` of the same type as `a` and `b` where each inner-most matrix is the product of the corresponding matrices in `a` and `b`, e.g. if all transpose or adjoint attributes are `False`: `output[..., i, j] = sum_k (a[..., i, k] * b[..., k, j])`, for all indices `i`, `j`. Note: This is matrix product, not element-wise product. Raises: ValueError: If `transpose_a` and `adjoint_a`, or `transpose_b` and `adjoint_b` are both set to `True`. TypeError: If output_type is specified but the types of `a`, `b` and `output_type` is not (u)int8, (u)int8 and int32. MatMulzNOnly one of `transpose_a` and `adjoint_a` can be True. Received `transpose_a`=z, `adjoint_a`=rzNOnly one of `transpose_b` and `adjoint_b` can be True. Received `transpose_b`=z, `adjoint_b`=ar'br"Nr0FT)adj_xadj_yr{grad_xgrad_yr()rrrrr() transpose_a transpose_b a_is_sparse b_is_sparser()rrgrad_agrad_br()rr3rrexecuting_eagerlyrrrrr4r+r _shape_tuplelenrrbatch_mat_mul_v3batch_mat_mul_v2rrrint8uint8 sparse_matmulr6mat_mul)rrrr adjoint_a adjoint_brrrmrrr(a_shapeb_shape%output_may_have_non_empty_batch_shapeuse_batch_matmul_v3use_sparse_matmulsparse_matmul_typesrets rUrrr sL ~~dHq!f-C y  $$/=1" 1 & ''y  $$/=1" 1 & ''   " Q (M,L,LQ,O  ! !!# . 3?? +}/O/O 0  ! !!0B0B M   ,a  agg.@.@s KannGnnG D ,CL1, . D ,CL1,*  qww.+2H   B  G  G ,,   eC C z,,  {C C T q'ak q'akk#__fnn= ''( ( KQWW8K-K ''V__ $ ''&++v||4 4 ''V__ $ ''&++v||4 4177agg;M  !!!! c FOO #6??(B3( WC C Z , , ,,   aC C v## ## wC C C s%GO::O:E8O:!*O:O::Pz linalg.matvecc tj|d||g5}t|tj|d||||}tj |dcdddS#1swYyxYw)a Multiplies matrix `a` by vector `b`, producing `a` * `b`. The matrix `a` must, following any transpositions, be a tensor of rank >= 2, with `shape(a)[-1] == shape(b)[-1]`, and `shape(a)[:-2]` able to broadcast with `shape(b)[:-1]`. Both `a` and `b` must be of the same type. The supported types are: `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`. Matrix `a` can be transposed or adjointed (conjugated and transposed) on the fly by setting one of the corresponding flag to `True`. These are `False` by default. If one or both of the inputs contain a lot of zeros, a more efficient multiplication algorithm can be used by setting the corresponding `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default. This optimization is only available for plain matrices/vectors (rank-2/1 tensors) with datatypes `bfloat16` or `float32`. For example: ```python # 2-D tensor `a` # [[1, 2, 3], # [4, 5, 6]] a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3]) # 1-D tensor `b` # [7, 9, 11] b = tf.constant([7, 9, 11], shape=[3]) # `a` * `b` # [ 58, 139] c = tf.linalg.matvec(a, b) # 3-D tensor `a` # [[[ 1, 2, 3], # [ 4, 5, 6]], # [[ 7, 8, 9], # [10, 11, 12]]] a = tf.constant(np.arange(1, 13, dtype=np.int32), shape=[2, 2, 3]) # 2-D tensor `b` # [[13, 14, 15], # [16, 17, 18]] b = tf.constant(np.arange(13, 19, dtype=np.int32), shape=[2, 3]) # `a` * `b` # [[ 86, 212], # [410, 563]] c = tf.linalg.matvec(a, b) ``` Args: a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128` and rank > 1. b: `Tensor` with same type as `a` and compatible dimensions. transpose_a: If `True`, `a` is transposed before multiplication. adjoint_a: If `True`, `a` is conjugated and transposed before multiplication. a_is_sparse: If `True`, `a` is treated as a sparse matrix. b_is_sparse: If `True`, `b` is treated as a sparse matrix. name: Name for the operation (optional). Returns: A `Tensor` of the same type as `a` and `b` where each inner-most vector is the product of the corresponding matrices in `a` and vectors in `b`, e.g. if all transpose or adjoint attributes are `False`: `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i. Note: This is matrix-vector product, not element-wise product. Raises: ValueError: If transpose_a and adjoint_a are both set to True. MatVecr2r.)rrrrN)rr3rrr:squeeze)rrrrrrr(rs rUmatvecr~skr ~~dHq!f-.  ab) !F   V" -...s =A!!A*chtjr|j|St|||Sr[)ris_numpy_style_type_promotion_matmulr)rrr(s rUmatmul_wrapperrs+&&( 99Q< 14  r`zUse `tf.linalg.matmul` insteadrc4t|tjtjfst dt |dt|tjr|Stj||}tj|td|d|S)aWConvert 'x' to IndexedSlices. Convert a dense Tensor to a block-sparse IndexedSlices. Args: x: Either a Tensor object, or an IndexedSlices object. optimize: if true, attempt to optimize the conversion of 'x'. Returns: An IndexedSlices object. Raises: TypeError: If 'x' is not a Tensor or an IndexedSlices object. zNot a Tensor or IndexedSlices: roptimizer) rrrrrrtypershape_internalr=)ryrx_shapes rU_as_indexed_slicesrs& A ))>+G+GH I 5d1gYa@ AA>//0 H  $ $Q :'  % %aq'!*)=w GGr`c t|ttfstdt |d|Dcgc]}t ||}}|Dcgc]6}|j jtjk(s+|j 8}}|rt|t|k(r|Sg}|D]}|j jtjk(r]|jtj|jt|j tj |j"|j||Scc}wcc}w)aConvert all elements of 'inputs' to IndexedSlices. Additionally, homogenize the types of all the indices to either int32 or int64. Args: inputs: List containing either Tensor or IndexedSlices objects. optimize: if true, attempt to optimize the conversion of each input. Returns: A list of IndexedSlices objects. Raises: TypeError: If 'inputs' is not a list or a tuple. zExpected a list or tuple, not rr)rlisttuplerrrrr+rrrappendrrrr6r>r)inputsrioutputsowith_int32_indexcasted_outputss rU_as_indexed_slices_listr%s FT5M * 4T&\N!D EE?E F! H 5 F' F AIIOOv||$Caii S!12c'lB N. ayy&,,&  & &qxxaii1N'(}} 67A   GsE ,E :E zmath.addrCctj|d|g5}tj|d}tj||jjd}|jt j k(r!tj|||cdddStj|||cdddS#1swYyxYw)a*Returns x + y element-wise. Example usages below. Add a scalar and a list: >>> x = [1, 2, 3, 4, 5] >>> y = 1 >>> tf.add(x, y) Note that binary `+` operator can be used instead: >>> x = tf.convert_to_tensor([1, 2, 3, 4, 5]) >>> y = tf.convert_to_tensor(1) >>> x + y Add a tensor and a list of same shape: >>> x = [1, 2, 3, 4, 5] >>> y = tf.constant([1, 2, 3, 4, 5]) >>> tf.add(x, y) **Warning**: If one of the inputs (`x` or `y`) is a tensor and the other is a non-tensor, the non-tensor input will adopt (or get casted to) the data type of the tensor input. This can potentially cause unwanted overflow or underflow conversion. For example, >>> x = tf.constant([1, 2], dtype=tf.int8) >>> y = [2**7 + 1, 2**7 + 2] >>> tf.add(x, y) When adding two input values of different shapes, `Add` follows NumPy broadcasting rules. The two input array shapes are compared element-wise. Starting with the trailing dimensions, the two dimensions either have to be equal or one of them needs to be `1`. For example, >>> x = np.ones(6).reshape(1, 2, 1, 3) >>> y = np.ones(6).reshape(2, 1, 3, 1) >>> tf.add(x, y).shape.as_list() [2, 2, 3, 3] Another example with two arrays of different dimension. >>> x = np.ones([1, 2, 1, 4]) >>> y = np.ones([3, 4]) >>> tf.add(x, y).shape.as_list() [1, 2, 3, 4] The reduction version of this elementwise operation is `tf.math.reduce_sum` Args: x: A `tf.Tensor`. Must be one of the following types: bfloat16, half, float16, float32, float64, uint8, uint16, uint32, uint64, int8, int16, int32, int64, complex64, complex128, string. y: A `tf.Tensor`. Must have the same type as x. name: A name for the operation (optional) Addryr'rr"N) rr3r4r+rrrDrrCrErs rUrCrC+sP ~~dEA3'24 ac*A aAGG,>,>SIAww&--   a . 22  AD 1 222sA8B<B<<Cz math.add_nadd_nr)iterable_parametersc|rt|tjs tdt j |}t d|Ds tdt|dk(rVt|dtjrtj|d}n|d}|rtj||S|Stj||S)aReturns the element-wise sum of a list of tensors. All inputs in the list must have the same shape. This op does not [broadcast](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html) its inputs. If you need broadcasting, use `tf.math.add` (or the `+` operator) instead. For example: >>> a = tf.constant([[3, 5], [4, 8]]) >>> b = tf.constant([[1, 6], [2, 9]]) >>> tf.math.add_n([a, b, a]).numpy() array([[ 7, 16], [10, 25]], dtype=int32) See Also: * `tf.reduce_sum(inputs, axis=0)` - This performs the same mathematical operation, but `tf.add_n` may be more efficient because it sums the tensors directly. `reduce_sum` on the other hand calls `tf.convert_to_tensor` on the list of tensors, unnecessarily stacking them into a single tensor before summing. Args: inputs: A list of `tf.Tensor` or `tf.IndexedSlices` objects, each with the same shape and type. `tf.IndexedSlices` objects will be converted into dense tensors prior to adding. name: A name for the operation (optional). Returns: A `tf.Tensor` of the same shape and type as the elements of `inputs`. Raises: ValueError: If `inputs` don't all have same shape and dtype or the shape cannot be inferred. z^Inputs must be an iterable of at least one Tensor/IndexedSlices with the same dtype and shape.c3pK|].}t|tjtjf0ywr[)rrrrrrsrys rUrvzadd_n..s0  Z&&(D(DEF s46r1rr')rr Iterablerr%convert_n_to_tensor_or_indexed_slicesryrrrr4ridentityrr()rr(rs rUr(r(|sN z&/*B*BC K LL  ? ? G&     K LL [A&)^99:$$VAY/fayf   T 22 M   F ..r`zmath.accumulate_n accumulate_nzUse `tf.math.add_n` Insteadcd}rtttfs|tjt dDs|t fdDs||t j|}nt j}D]<}t|tjs|j|j}>|1|djk7rtd|ddjdtdk(r|dStdk(r|t!j"d| St%| S) aReturns the element-wise sum of a list of tensors. Optionally, pass `shape` and `tensor_dtype` for shape and type checking, otherwise, these are inferred. For example: >>> a = tf.constant([[1, 2], [3, 4]]) >>> b = tf.constant([[5, 0], [0, 6]]) >>> tf.math.accumulate_n([a, b, a]).numpy() array([[ 7, 4], [ 6, 14]], dtype=int32) >>> # Explicitly pass shape and type >>> tf.math.accumulate_n( ... [a, b, a], shape=[2, 2], tensor_dtype=tf.int32).numpy() array([[ 7, 4], [ 6, 14]], dtype=int32) Note: The input must be a list or tuple. This function does not handle `IndexedSlices` See Also: * `tf.reduce_sum(inputs, axis=0)` - This performe the same mathematical operation, but `tf.add_n` may be more efficient because it sums the tensors directly. `reduce_sum` on the other hand calls `tf.convert_to_tensor` on the list of tensors, unncessairly stacking them into a single tensor before summing. * `tf.add_n` - This is another python wrapper for the same Op. It has nearly identical functionality. Args: inputs: A list of `Tensor` objects, each with same shape and type. shape: Expected shape of elements of `inputs` (optional). Also controls the output shape of this op, which may affect type inference in other ops. A value of `None` means "infer the input shape from the shapes in `inputs`". tensor_dtype: Expected data type of `inputs` (optional). A value of `None` means "infer the input dtype from `inputs[0]`". name: A name for the operation (optional). Returns: A `Tensor` of same shape and type as the elements of `inputs`. Raises: ValueError: If `inputs` don't all have same shape and dtype or the shape cannot be inferred. ctdS)NzJinputs must be a list of at least one Tensor with the same dtype and shape)rrar`rU _input_errorz"accumulate_n.._input_errors - ..r`c3PK|]}t|tj ywr[)rrrr,s rUrvzaccumulate_n..s >!Z:,, - >s$&c3VK|] }|jdjk("yw)rNr-)rsryrs rUrvzaccumulate_n..s" 8AQWWq  ' 8s&)rzThe `tensor_dtype` argument is z, but `input` is of type zA. These must be equal. Try casting the input to the desired type.r1r')rrrrr.ryras_shape unknown_shaperr merge_withrr+rrrr/r()rr8 tensor_dtyper(r3rs` rUr0r0sTj. z&4-8 .  ? ? G& >v > > . 8 8 8 .   ! !% (E  & & (E9l, 1 12|5578e9 ,&)//"A  ),8q  !  !!  [A$, !9 6{aD,   fQid 33 vD !!r` AccumulateNV2c4|gt|jzS)z=Same as gradient for AddN. Copies the gradient to all inputs.)rr)opgrads rU_accumulate_n_gradr>s #bii.  r`z math.sigmoidz nn.sigmoidsigmoidctj|d|g5}tj|d}tj||cdddS#1swYyxYw)a Computes sigmoid of `x` element-wise. Formula for calculating $\mathrm{sigmoid}(x) = y = 1 / (1 + \exp(-x))$. For $x \in (-\infty, \infty)$, $\mathrm{sigmoid}(x) \in (0, 1)$. Example Usage: If a positive number is large, then its sigmoid will approach to 1 since the formula will be `y = / (1 + )` >>> x = tf.constant([0.0, 1.0, 50.0, 100.0]) >>> tf.math.sigmoid(x) If a negative number is large, its sigmoid will approach to 0 since the formula will be `y = 1 / (1 + )` >>> x = tf.constant([-100.0, -50.0, -1.0, 0.0]) >>> tf.math.sigmoid(x) Args: x: A Tensor with type `float16`, `float32`, `float64`, `complex64`, or `complex128`. name: A name for the operation (optional). Returns: A Tensor with the same type as `x`. Usage Example: >>> x = tf.constant([-128.0, 0.0, 128.0], dtype=tf.float32) >>> tf.sigmoid(x) @compatibility(scipy) Equivalent to scipy.special.expit @end_compatibility Sigmoidryr'N)rr3r4rr?rs rUr?r?sP` ~~dIs+.t ac*A    -...s .AAzmath.log_sigmoid log_sigmoidctj|d|g5}tj|d}tjt j | |cdddS#1swYyxYw)aComputes log sigmoid of `x` element-wise. Specifically, `y = log(1 / (1 + exp(-x)))`. For numerical stability, we use `y = -tf.nn.softplus(-x)`. Args: x: A Tensor with type `float32` or `float64`. name: A name for the operation (optional). Returns: A Tensor with the same type as `x`. Usage Example: If a positive number is large, then its log_sigmoid will approach to 0 since the formula will be `y = log( / (1 + ) )` which approximates to `log (1)` which is 0. >>> x = tf.constant([0.0, 1.0, 50.0, 100.0]) >>> tf.math.log_sigmoid(x) If a negative number is large, its log_sigmoid will approach to the number itself since the formula will be `y = log( 1 / (1 + ) )` which is `log (1) - log ( (1 + ) )` which approximates to `- ` that is the number itself. >>> x = tf.constant([-100.0, -50.0, -1.0, 0.0]) >>> tf.math.log_sigmoid(x) LogSigmoidryr'N)rr3r4rnegrrrs rUrBrBJsaP ~~dL1#.@$ ac*A   J//3$ ?@@@s AA%%A.z math.cumsumcumsumctj|d|g5}tj|d}tj|||||cdddS#1swYyxYw)a Compute the cumulative sum of the tensor `x` along `axis`. By default, this op performs an inclusive cumsum, which means that the first element of the input is identical to the first element of the output: For example: >>> # tf.cumsum([a, b, c]) # [a, a + b, a + b + c] >>> x = tf.constant([2, 4, 6, 8]) >>> tf.cumsum(x) >>> # using varying `axis` values >>> y = tf.constant([[2, 4, 6, 8], [1,3,5,7]]) >>> tf.cumsum(y, axis=0) >>> tf.cumsum(y, axis=1) By setting the `exclusive` kwarg to `True`, an exclusive cumsum is performed instead: >>> # tf.cumsum([a, b, c], exclusive=True) => [0, a, a + b] >>> x = tf.constant([2, 4, 6, 8]) >>> tf.cumsum(x, exclusive=True) By setting the `reverse` kwarg to `True`, the cumsum is performed in the opposite direction: >>> # tf.cumsum([a, b, c], reverse=True) # [a + b + c, b + c, c] >>> x = tf.constant([2, 4, 6, 8]) >>> tf.cumsum(x, reverse=True) This is more efficient than using separate `tf.reverse` ops. The `reverse` and `exclusive` kwargs can also be combined: >>> # tf.cumsum([a, b, c], exclusive=True, reverse=True) # [b + c, c, 0] >>> x = tf.constant([2, 4, 6, 8]) >>> tf.cumsum(x, exclusive=True, reverse=True) Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. axis: A `Tensor` of type `int32` (default: 0). Must be in the range `[-rank(x), rank(x))`. exclusive: If `True`, perform exclusive cumsum. reverse: A `bool` (default: False). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. Cumsumryr' exclusivereverser(N)rr3r4rrFryr/rJrKr(s rUrFrFws^D ~~dHqc*Bd ac*A    49gD BBBB 1AAz math.cumprodcumprodctj|d|g5}tj|d}tj|||||cdddS#1swYyxYw)agCompute the cumulative product of the tensor `x` along `axis`. By default, this op performs an inclusive cumprod, which means that the first element of the input is identical to the first element of the output: ```python tf.math.cumprod([a, b, c]) # [a, a * b, a * b * c] ``` By setting the `exclusive` kwarg to `True`, an exclusive cumprod is performed instead: ```python tf.math.cumprod([a, b, c], exclusive=True) # [1, a, a * b] ``` By setting the `reverse` kwarg to `True`, the cumprod is performed in the opposite direction: ```python tf.math.cumprod([a, b, c], reverse=True) # [a * b * c, b * c, c] ``` This is more efficient than using separate `tf.reverse` ops. The `reverse` and `exclusive` kwargs can also be combined: ```python tf.math.cumprod([a, b, c], exclusive=True, reverse=True) # [b * c, c, 1] ``` Args: x: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int64`, `int32`, `uint8`, `uint16`, `int16`, `int8`, `complex64`, `complex128`, `qint8`, `quint8`, `qint32`, `half`. axis: A `Tensor` of type `int32` (default: 0). Must be in the range `[-rank(x), rank(x))`. exclusive: If `True`, perform exclusive cumprod. reverse: A `bool` (default: False). name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as `x`. Cumprodryr'rIN)rr3r4rrNrLs rUrNrNs^` ~~dIs+Bt ac*A    49gD BBBBrMzmath.cumulative_logsumexpctj|d|g5}tj|d}tj|||||cdddS#1swYyxYw)aCompute the cumulative log-sum-exp of the tensor `x` along the `axis`. By default, this operation performs an inclusive cumulative log-sum-exp, which means that the first element of the input is identical to the first element of the output. This operation is significantly more numerically stable than the equivalent Tensorflow operation `tf.math.log(tf.math.cumsum(tf.math.exp(x)))`, although it computes the same result given infinite numerical precision. However, note that in some cases, it may be less stable than `tf.math.reduce_logsumexp` for a given element, as it applies the "log-sum-exp trick" in a different way. More precisely, where `tf.math.reduce_logsumexp` uses the following trick: ``` log(sum(exp(x))) == log(sum(exp(x - max(x)))) + max(x) ``` it cannot be directly used here as there is no fast way of applying it to each prefix `x[:i]`. Instead, this function implements a prefix scan using pairwise log-add-exp, which is a commutative and associative (up to floating point precision) operator: ``` log_add_exp(x, y) = log(exp(x) + exp(y)) = log(1 + exp(min(x, y) - max(x, y))) + max(x, y) ``` However, reducing using the above operator leads to a different computation tree (logs are taken repeatedly instead of only at the end), and the maximum is only computed pairwise instead of over the entire prefix. In general, this leads to a different and slightly less precise computation. Args: x: A `Tensor`. Must be one of the following types: `float16`, `float32`, `float64`. axis: A `Tensor` of type `int32` or `int64` (default: 0). Must be in the range `[-rank(x), rank(x))`. exclusive: If `True`, perform exclusive cumulative log-sum-exp. reverse: If `True`, performs the cumulative log-sum-exp in the reverse direction. name: A name for the operation (optional). Returns: A `Tensor`. Has the same shape and type as `x`. CumulativeLogsumexpryr'rIN)rr3r4rcumulative_logsumexprLs rUrSrSs_d ~~d1A37B4 ac*A  , , 49gD BBBBrMz math.conjrc@t|tjr&|j}|js |j r|St j|d|g5}t j|d}|jjs|jtjk(r tj||cdddS|jjs|jj r |cdddStd|jd#1swYyxYw)afReturns the complex conjugate of a complex number. Given a tensor `x` of complex numbers, this operation returns a tensor of complex numbers that are the complex conjugate of each element in `x`. The complex numbers in `x` must be of the form \\(a + bj\\), where `a` is the real part and `b` is the imaginary part. The complex conjugate returned by this operation is of the form \\(a - bj\\). For example: >>> x = tf.constant([-2.25 + 4.75j, 3.25 + 5.75j]) >>> tf.math.conj(x) If `x` is real, it is returned unchanged. For example: >>> x = tf.constant([-2.25, 3.25]) >>> tf.math.conj(x) Args: x: `Tensor` to conjugate. Must have numeric or variant type. name: A name for the operation (optional). Returns: A `Tensor` that is the conjugate of `x` (with the same type). Raises: TypeError: If `x` is not a numeric tensor. @compatibility(numpy) Equivalent to numpy.conj. @end_compatibility Conjryr'Nz.Expected numeric or variant tensor, got dtype r)rrrr+rrrr3r4r|rvariantrrr)ryr(dts rUrr-sX:$$% B ~~ h ~~dFQC(ID ac*AwwQWW6   qt ,II    2 2  II  :177+Q G IIIIsA!D-D;DDc*tj|}|htj|}|Qtj|tj}tj|tj}d||<|St j |}tj||j}||z|z}tj|}tjt||g|tj||jgS)zHelper function for reduction ops. Args: input_shape: 1-D Tensor, the shape of the Tensor being reduced. axes: 1-D Tensor, the reduction axes. Returns: A 1-D Tensor, the output shape as if keepdims were set to True. r-r1)out_type)rconstant_valuerrrrr4rrTr+r8rdynamic_stitchr=ones) input_shaperfconstant_input_shape constant_axes input_rank axes_shapes rU reduced_shaperbhs%33K@%..t4M hh}BHH=mXX&:"((K,-=) !!  t $$~~kDJJ?*  z )$t$*  ) ) Z$  ..;+<+< = r`c tj|}tj|}tj||j }t j|||}tj|tjtjtj|tj|z g|j gd}tj||}t j|dS)amHelper function for unsorted_segment_mean/_sqrtN. Computes the number of segment entries with 0-entries set to 1 to allow division by N. Args: data: A `Tensor` with data that will be assembled in the output. segment_ids: An integer tensor whose shape is a prefix of `data.shape`. The values must be in the range `[0, num_segments)`. The values are always validated to be in range on CPU, never validated on TPU/GPU. num_segments: An integer scalar `Tensor`. The number of distinct segment IDs. Returns: A `Tensor` with the number of segment entries with 0-entries set to 1. r-rr.r1) rr4rrr\r+runsorted_segment_sumrAnewaxisrr@r<)data segment_ids num_segmentssegment_ids_shape ones_tensornbroadcastable_shapes rU_unsorted_segment_Nrms"&&|4,..{;0 C+'' [,O!!((I%%&~~y~~d+" 456(..01  ./!   a ##r`zmath.unsorted_segment_meanunsorted_segment_meanctj|d5tj|}tj|}t|||}t j |||}||z cdddS#1swYyxYw)aComputes the mean along segments of a tensor. Read [the section on segmentation](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/math#about_segmentation) for an explanation of segments. This operator is similar to the `tf.math.unsorted_segment_sum` operator. Instead of computing the sum over segments, it computes the mean of all entries belonging to a segment such that: \\(output_i = 1/N_i \sum_{j...} data[j...]\\) where the sum is over tuples `j...` such that `segment_ids[j...] == i` with \\N_i\\ being the number of occurrences of id \\i\\. If there is no entry for a given segment ID `i`, it outputs 0. If the given segment ID `i` is negative, the value is dropped and will not be added to the sum of the segment. Caution: On CPU, values in `segment_ids` are always validated to be less than `num_segments`, and an error is thrown for out-of-bound indices. On GPU, this does not throw an error for out-of-bound indices. On Gpu, out-of-bound indices result in safe but unspecified behavior, which may include ignoring out-of-bound indices or outputting a tensor with a 0 stored in the first dimension of its shape if `num_segments` is 0. Args: data: A `Tensor` with floating point or complex dtype. segment_ids: An integer tensor whose shape is a prefix of `data.shape`. The values must be less than `num_segments`. The values are always validated to be in range on CPU, never validated on GPU. num_segments: An integer scalar `Tensor`. The number of distinct segment IDs. name: A name for the operation (optional). Returns: A `Tensor`. Has same shape as data, except for the first `segment_ids.rank` dimensions, which are replaced with a single dimension which has size `num_segments`. UnsortedSegmentMeanN)rr3r4rmrrdrfrgrhr(Nsummeds rUrnrnsr^ ~~d12   &D'' 4KD+| [[0 0 0 0]] # Select two rows, two segment. tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1])) # => [[ 1 2 3 4] # [-1 -2 -3 -4]] # With missing segment ids. tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]), num_segments=4) # => [[ 1 2 3 4] # [ 0 0 0 0] # [-1 -2 -3 -4] # [ 0 0 0 0]] # Select all rows, two segments. tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1])) # => [[0 0 0 0] # [5 6 7 8]] # Which is equivalent to: tf.math.segment_sum(c, tf.constant([0, 0, 1])) ``` Args: data: A `Tensor` with data that will be assembled in the output. indices: A 1-D `Tensor` with indices into `data`. Has same rank as `segment_ids`. segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values should be sorted and can be repeated. name: A name for the operation (optional). num_segments: An optional int32 scalar. Indicates the size of the output `Tensor`. sparse_gradient: An optional `bool`. Defaults to `False`. If `True`, the gradient of this function will be sparse (`IndexedSlices`) instead of dense (`Tensor`). The sparse gradient will contain one non-zero row for each unique index in `indices`. Returns: A `tensor` of the shape as data, except for dimension 0 which has size `k`, the number of segments specified via `num_segments` or inferred for the last element in `segments_ids`. )rfrrgrhsparse_gradientr()rfrrgryr()r$sparse_segment_sum_with_num_segmentsrwrfrrgr(rhrys rUrwrwsTP  < < !'     * * '   r`zsparse.sampled_addmmg?ctj|}tj||}tj|tj}tj||}tj||}t j t j|}t j t j|} |d} | d} tj| | g} tt|| } tjr| std|d| t j |}t j | }|>|= 2 where the inner 2 dimensions specify valid matrix multiplication dimensions, and any further dimensions specify matching batch size. The `indices`, `values`, and `dense_shape` inputs make up the components of a `SparseTensor` which defines the sparsity pattern of the output. The sparsity pattern has values of 1 at the positions defined by the `SparseTensor`, and 0 elsewhere. The `alpha` and `beta` inputs are the scaling factors. The supported types for `values`, `mat1`, and `mat2` are: `bfloat16`, `float16`, `float32`, `float64`. A simple 2-D tensor operation: >>> indices = tf.constant([0, 0, 1, 1], shape=[2, 2]) >>> indices >>> values = tf.constant([0.5, 0.3]) >>> values >>> dense_shape = tf.constant([2, 2]) >>> dense_shape >>> mat1 = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3], dtype=tf.float32) >>> mat1 >>> mat2 = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2], dtype=tf.float32) >>> mat2 >>> tf.sparse.sampled_addmm(indices, values, dense_shape, mat1, mat2, ... alpha=0.75, beta=0.25) (, , ) A batch operation: >>> indices = tf.constant([0, 1, 1, 0, 0, 0, 1, 0], shape=[2, 2, 2]) >>> indices >>> values = tf.constant([3, 5, 2, 7], shape=[2, 2], dtype=tf.float32) >>> values >>> dense_shape = tf.constant([2, 2]) >>> dense_shape >>> mat1 = tf.constant(np.arange(1, 13), shape=[2, 2, 3], dtype=tf.float32) >>> mat1 >>> mat2 = tf.constant(np.arange(13, 25), shape=[2, 3, 2], dtype=tf.float32) >>> mat2 >>> tf.sparse.sampled_addmm(indices, values, dense_shape, mat1, mat2, ... alpha=0.75, beta=0.25) (, , ) Args: indices: `tf.Tensor` containing coordinates for the rows and columns to be multiplied. Must have rank > 1. values: `tf.Tensor` containing the values to be scaled and added to the sampled dot product. dense_shape: `tf.Tensor` defining the dense shape of the output. mat1: `tf.Tensor` to be multiplied. Must have rank > 1. mat2: `tf.Tensor` to be multiplied. Must have rank > 1. beta: Number to be multiplied with `values`. Defaults to 1.0. alpha: Number to be multiplied with the sampled dot product of `mat1` and `mat2`. Defaults to 1.0. output_type: The output datatype if needed. Defaults to float32. Returns: A tuple representing the `SparseTensor` components of the result of the operation. Raises: ValueError: If `dense_shape` does not match the shape of the product. r-r2z Dense shape: z does not match output shape: NAssertr'.r.r0) batch_dims)rr4rrrrZrr8rstackrr?rrrrryr_assertrAr gather_ndmatrix_transposer)rrrmat1mat2betaalpharm mat1_shape mat2_shape dense_rows dense_cols output_shape conditiondense_shape_staticoutput_shape_staticcondition_staticrf batch_indices row_indices col_indicesrrrowscolsdots rU sampled_addmmrysqD  ! !' *'  { ;&%%kF+  t; 7$  t; 7$)))//$*?@*)))//$*?@*"~*"~* && J'?@,{L9:)    +''. *  %33K@%44\B%*=*I ((%': ;K=))N ,  (  DItTA#ss(#-SbS!+  -bc1B!C"M+  # #INN4$8 9$ax*   T;: F$     &  $ 4$;R(# 3;$. < [[0 0 0 0]] # Select two rows, two segment. tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1])) # => [[ 1 2 3 4] # [-1 -2 -3 -4]] # With missing segment ids. tf.sparse.segment_sum(c, tf.constant([0, 1]), tf.constant([0, 2]), num_segments=4) # => [[ 1 2 3 4] # [ 0 0 0 0] # [-1 -2 -3 -4] # [ 0 0 0 0]] # Select all rows, two segments. tf.sparse.segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1])) # => [[0 0 0 0] # [5 6 7 8]] # Which is equivalent to: tf.math.segment_sum(c, tf.constant([0, 0, 1])) ``` Args: data: A `Tensor` with data that will be assembled in the output. indices: A 1-D `Tensor` with indices into `data`. Has same rank as `segment_ids`. segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values should be sorted and can be repeated. num_segments: An optional int32 scalar. Indicates the size of the output `Tensor`. name: A name for the operation (optional). sparse_gradient: An optional `bool`. Defaults to `False`. If `True`, the gradient of this function will be sparse (`IndexedSlices`) instead of dense (`Tensor`). The sparse gradient will contain one non-zero row for each unique index in `indices`. Returns: A `tensor` of the shape as data, except for dimension 0 which has size `k`, the number of segments specified via `num_segments` or inferred for the last element in `segments_ids`. r(rhry)rwrfrrgrhr(rys rUsparse_segment_sum_v2r;s$N    %  r`zsparse.segment_meansparse_segment_meancp|tj||||||Stj|||||S)aComputes the mean along sparse segments of a tensor. Read [the section on segmentation](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/math#about_segmentation) for an explanation of segments. Like `tf.math.segment_mean`, but `segment_ids` can have rank less than `data`'s first dimension, selecting a subset of dimension 0, specified by `indices`. `segment_ids` is allowed to have missing ids, in which case the output will be zeros at those indices. In those cases `num_segments` is used to determine the size of the output. Args: data: A `Tensor` with data that will be assembled in the output. indices: A 1-D `Tensor` with indices into `data`. Has same rank as `segment_ids`. segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values should be sorted and can be repeated. name: A name for the operation (optional). num_segments: An optional int32 scalar. Indicates the size of the output `Tensor`. sparse_gradient: An optional `bool`. Defaults to `False`. If `True`, the gradient of this function will be sparse (`IndexedSlices`) instead of dense (`Tensor`). The sparse gradient will contain one non-zero row for each unique index in `indices`. Returns: A `tensor` of the shape as data, except for dimension 0 which has size `k`, the number of segments specified via `num_segments` or inferred for the last element in `segments_ids`. rrfrrgr(ry)r%sparse_segment_mean_with_num_segmentsrr{s rUrrsTT  = = ! '    + +  '  r`c$t||||||S)aComputes the mean along sparse segments of a tensor. Read [the section on segmentation](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/math#about_segmentation) for an explanation of segments. Like `tf.math.segment_mean`, but `segment_ids` can have rank less than `data`'s first dimension, selecting a subset of dimension 0, specified by `indices`. `segment_ids` is allowed to have missing ids, in which case the output will be zeros at those indices. In those cases `num_segments` is used to determine the size of the output. Args: data: A `Tensor` with data that will be assembled in the output. indices: A 1-D `Tensor` with indices into `data`. Has same rank as `segment_ids`. segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values should be sorted and can be repeated. num_segments: An optional int32 scalar. Indicates the size of the output `Tensor`. name: A name for the operation (optional). sparse_gradient: An optional `bool`. Defaults to `False`. If `True`, the gradient of this function will be sparse (`IndexedSlices`) instead of dense (`Tensor`). The sparse gradient will contain one non-zero row for each unique index in `indices`. Returns: A `tensor` of the shape as data, except for dimension 0 which has size `k`, the number of segments specified via `num_segments` or inferred for the last element in `segments_ids`. r)rrs rUsparse_segment_mean_v2rs$R    %  r`zsparse.segment_sqrt_nsparse_segment_sqrt_ncp|tj||||||Stj|||||S)aComputes the sum along sparse segments of a tensor divided by the sqrt(N). `N` is the size of the segment being reduced. Args: data: A `Tensor` with data that will be assembled in the output. indices: A 1-D `Tensor` with indices into `data`. Has same rank as `segment_ids`. segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values should be sorted and can be repeated. name: A name for the operation (optional). num_segments: An optional int32 scalar. Indicates the size of the output `Tensor`. sparse_gradient: An optional `bool`. Defaults to `False`. If `True`, the gradient of this function will be sparse (IndexedSlices) instead of dense (Tensor). Returns: A `tensor` of the shape as data, except for dimension 0 which has size `k`, the number of segments specified via `num_segments` or inferred for the last element in `segments_ids`. rr)r'sparse_segment_sqrt_n_with_num_segmentsrr{s rUrrsT@  ? ? ! '    - -  '  r`c$t||||||S)aComputes the sum along sparse segments of a tensor divided by the sqrt(N). Read [the section on segmentation](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf/math#about_segmentation) for an explanation of segments. Like `tf.sparse.segment_mean`, but instead of dividing by the size of the segment, `N`, divide by `sqrt(N)` instead. Args: data: A `Tensor` with data that will be assembled in the output. indices: A 1-D `Tensor` with indices into `data`. Has same rank as `segment_ids`. segment_ids: A 1-D `Tensor` with indices into the output `Tensor`. Values should be sorted and can be repeated. num_segments: An optional int32 scalar. Indicates the size of the output `Tensor`. name: A name for the operation (optional). sparse_gradient: An optional `bool`. Defaults to `False`. If `True`, the gradient of this function will be sparse (`IndexedSlices`) instead of dense (`Tensor`). The sparse gradient will contain one non-zero row for each unique index in `indices`. Returns: A `tensor` of the shape as data, except for dimension 0 which has size `k`, the number of segments specified via `num_segments` or inferred for the last element in `segments_ids`. r)rrs rUsparse_segment_sqrt_n_v2r/s$J    %  r` tensordotzlinalg.tensordotcxd d}d}tj|d|||g5}tj|d}tj|d}|||\}}|||\}} } |||d\} } } t|| }t | t rt | t rq|j jr/|j j| | zk(r |cdddStj|| | z|cdddStj| tj } tj| tj } tj|tj| | gd |}| | |j| | z|cdddS#1swYyxYw) a Tensor contraction of a and b along specified axes and outer product. Tensordot (also known as tensor contraction) sums the product of elements from `a` and `b` over the indices specified by `axes`. This operation corresponds to `numpy.tensordot(a, b, axes)`. Example 1: When `a` and `b` are matrices (order 2), the case `axes=1` is equivalent to matrix multiplication. Example 2: When `a` and `b` are matrices (order 2), the case `axes = [[1], [0]]` is equivalent to matrix multiplication. Example 3: When `a` and `b` are matrices (order 2), the case `axes=0` gives the outer product, a tensor of order 4. Example 4: Suppose that \\(a_{ijk}\\) and \\(b_{lmn}\\) represent two tensors of order 3. Then, `contract(a, b, [[0], [2]])` is the order 4 tensor \\(c_{jklm}\\) whose entry corresponding to the indices \\((j,k,l,m)\\) is given by: \\( c_{jklm} = \sum_i a_{ijk} b_{lmi} \\). In general, `order(c) = order(a) + order(b) - 2*len(axes[0])`. For example: ```python import numpy as np import tensorflow as tf a = np.arange(60).reshape(3,4,5) b = np.arange(24).reshape(4,3,2) c = tf.tensordot(a,b, axes=([1,0],[0,1])) c # Another example d = tf.random.uniform((3,4,5)) e = tf.random.uniform((5,3,2)) f = tf.tensordot(d,e, axes=([2,0],[0,1])) f ``` Args: a: `Tensor` of type `float32` or `float64`. b: `Tensor` with the same type as `a`. axes: Either a scalar `N`, or a list or an `int32` `Tensor` of shape [2, k]. If axes is a scalar, sum over the last N axes of a and the first N axes of b in order. If axes is a list or `Tensor` the first and second row contain the set of unique integers specifying axes along which the contraction is computed, for `a` and `b`, respectively. The number of axes for `a` and `b` must be equal. If `axes=0`, computes the outer product between `a` and `b`. name: A name for the operation (optional). Returns: A `Tensor` with the same type as `a`. Raises: ValueError: If the shapes of `a`, `b`, and `axes` are incompatible. IndexError: If the values in axes exceed the rank of the corresponding tensor. c  |jjrt|ttfr|jj }|Dcgc]}|dk\r|n |t |z}}tjt |Dcgc] }||vs| }}|Dcgc]}|| }}ttj|Dcgc]}|| c}}ttj|Dcgc]}|| c}}|rt||zn |t|z} |r||gn||g} | tjt |k7jrtj|| } n|} | jj | k7rtj | | } n| } | ||fS|jj"t|ttfr|jj }|Dcgc]}|dk\r|n |t |z}}tjt |Dcgc] }||vs| }}|Dcgc]}|| } }|Dcgc]}|| }}|}t%j&|t(j*d}t%j&|t(j*d}tj,|}nd}tj,|}tj.|}t%j&|t(j*d}tj0|dk\|||z}t3j4t||t(j*\}}tj6||}tj6||} t9|}t9| }|r0tj:||gd} t=j>||g} n/tj:||gd} t=j>||g} tj tj|| | } | ||fScc}wcc}wcc}wcc}wcc}wcc}wcc}wcc}wcc}w)aHelper method to perform transpose and reshape for contraction op. This method is helpful in reducing `math_ops.tensordot` to `math_ops.matmul` using `array_ops.transpose` and `array_ops.reshape`. The method takes a tensor and performs the correct transpose and reshape operation for a given set of indices. It returns the reshaped tensor as well as a list of indices necessary to reshape the tensor again after matrix multiplication. Args: a: `Tensor`. axes: List or `int32` `Tensor` of unique indices specifying valid axes of `a`. flipped: An optional `bool`. Defaults to `False`. If `True`, the method assumes that `a` is the second argument in the contraction operation. Returns: A tuple `(reshaped_a, free_dims, free_dims_static)` where `reshaped_a` is the tensor `a` reshaped to allow contraction via `matmul`, `free_dims` is either a list of integers or an `int32` `Tensor`, depending on whether the shape of a is fully specified, and free_dims_static is either a list of integers and None values, or None, representing the inferred static shape of the free dimensions rNrfrfree) rrrrras_listrrr=intrrranyr transposer@rHrr4rrr8rrr list_diffgatherrrArr)rrfflippedshape_ar r free_dims prod_free prod_axesperm new_shapea_trans reshaped_a axes_dimsfree_dims_staticrank_a_prod_free_dimsprod_axes_dimss rU_tensordot_reshapez%tensordot.._tensordot_reshapes0 {{}%%'JtdE],K %%'g9= >A16aq3w<// >d >!G 5 GA$a Gd G'+,!71:,i,bgg48awqz89:ibgg48awqz89:i")T$Z$ td4j/@d,39i()Y9Oi "))CL) ) . . 0%%a.     $ $ &) 3&&w :  I --    (ZtUm-L++-'');?@aQ!VS\!11@@#>>#g,7Ia1D=II)-.AWQZ. .)-.AWQZ. .$$$TFK$$TFK//!$//!$"$$TFKtqy$v >))%-v||La""7D1i""7D1i"9-n"9-n t a0#))>>*JK t a0#))>>*JK $$Y%8%8D%A9Mj $4 44[? G,88AI..sBQ! Q&!Q&+ Q+ Q0 Q5 Q: Q?!Q?+ R= R c |j}t|tjr|dkrt d|d|j ||j kDrt d|d|d|j dt tj|j |z |j t tj|fStj|}t||z |tjt|tjfSt|t tfrt|dk7rt d |d|d}|d }t|tjr t|tjr|g}|g}t|t|k7r$t d t|d t|d||fStj |d tj}|d|d fS)zDGenerates two sets of contraction axes for the two tensor arguments.rz%`axes` must be at least 0. Received: rzB`axes` must not be larger than the number of dimensions of tensor z . Received z, vs tensor dimensions r-r0z5`axes` must be an integer or have length 2. Received r1z2Different number of contraction axes `a` and `b`, r%rfr*)rrrintegral_typesrrHrrr=rrrrrrrr4)rrfrra_axesb_axess rU_tensordot_axesz"tensordot.._tensordot_axesskkmG$--. @aHII  " '-- 334#\$H007 aAB BX^^GMMD$8$+MM3459(..:N5OQ Q~~a dTk4"LL*+0V\\+JL L D4- ( TaCD6 KM MAwfAwf FF11 2 VV22 3 VF #MK=S[M<= = V^  " "4fFLL Id !Wd1g r` Tensordotrr'rTNr-r)F)rr3r4rrrrrrrr@rrrAr)rrrfr(rrrr a_reshape a_free_dimsa_free_dims_static b_reshape b_free_dimsb_free_dims_static ab_matmulproducts rUrr^sbG5R!F ~~dK!Q6$ ac*A ac*A$Q-NFF1CAv1N.I{.1C 642.I{.y),I+t$K)F     0 0 2     ' ' )[;-F F  {[0t= ))+V\\Jk))+V\\Jk!! Y%%{K&@!D4Qg  ',>,J,/AAB -sCF01F0BF00F9z math.polyvalc  t|tstdt|dt j |dt j||gz5}t j|d}t|dkr tj||cdddSt|Dcgc]\}}t j|d|z!}}}|d }|ddD] }|||zz} |cdddScc}}w#1swYyxYw) a0Computes the elementwise value of a polynomial. If `x` is a tensor and `coeffs` is a list n + 1 tensors, this function returns the value of the n-th order polynomial `p(x) = coeffs[n-1] + coeffs[n-2] * x + ... + coeffs[0] * x**(n-1)` evaluated using Horner's method, i.e. ```python p(x) = coeffs[n-1] + x * (coeffs[n-2] + ... + x * (coeffs[1] + x * coeffs[0])) ``` Usage Example: >>> coefficients = [1.0, 2.5, -4.2] >>> x = 5.0 >>> y = tf.math.polyval(coefficients, x) >>> y Usage Example: >>> tf.math.polyval([2, 1, 0], 3) # evaluates 2 * (3**2) + 1 * (3**1) + 0 * (3**0) `tf.math.polyval` can also be used in polynomial regression. Taking advantage of this function can facilitate writing a polynomial equation as compared to explicitly writing it out, especially for higher degree polynomials. >>> x = tf.constant(3) >>> theta1 = tf.Variable(2) >>> theta2 = tf.Variable(1) >>> theta3 = tf.Variable(0) >>> tf.math.polyval([theta1, theta2, theta3], x) Args: coeffs: A list of `Tensor` representing the coefficients of the polynomial. x: A `Tensor` representing the variable of the polynomial. name: A name for the operation (optional). Returns: A `tensor` of the shape as the expression p(x) with usual broadcasting rules for element-wise addition and multiplication applied. @compatibility(numpy) Equivalent to numpy.polyval. @end_compatibility z1Argument coeffs must be list type. Received type rpolyvalryr'r1Nzcoeff_%dr) rrrrrr3rflattenr4rrrB enumerate)coeffsryr(rzcoeffpcs rUrr4sl FD !  ;DL>K MM ~~dIt||F';qc'AB  d ac*A 6{Q  ! !!$ /   &f- E5 e:+=?F q A ABZ a!e)a       s$>Bz math.xdivyctj|d|g5tj||cdddS#1swYyxYw)aComputes `x / y`. Given `x` and `y`, computes `x / y`. This function safely returns zero when `x = 0`, no matter what the value of `y` is. Example: >>> tf.math.xdivy(1., 2.) >>> tf.math.xdivy(0., 1.) >>> tf.math.xdivy(0., 0.) >>> tf.math.xdivy(1., 0.) Args: x: A `tf.Tensor` of type `half`, `float32`, `float64`, `complex64`, `complex128` y: A `tf.Tensor` of type `half`, `float32`, `float64`, `complex64`, `complex128` name: A name for the operation (optional). Returns: `x / y`. xdivyN)rr3rrrs rUrrs;< ~~dGaS)$   a #$$$ 9Az math.xlog1pyctj|d|g5tj||cdddS#1swYyxYw)aVCompute x * log1p(y). Given `x` and `y`, compute `x * log1p(y)`. This function safely returns zero when `x = 0`, no matter what the value of `y` is. Example: >>> tf.math.xlog1py(0., 1.) >>> tf.math.xlog1py(1., 1.) >>> tf.math.xlog1py(2., 2.) >>> tf.math.xlog1py(0., -1.) Args: x: A `tf.Tensor` of type `half`, `float32`, `float64`, `complex64`, `complex128` y: A `tf.Tensor` of type `half`, `float32`, `float64`, `complex64`, `complex128` name: A name for the operation (optional). Returns: `x * log1p(y)`. @compatibility(scipy) Equivalent to scipy.special.xlog1py @end_compatibility xlog1pyN)rr3rrrs rUrrs<D ~~dIs+&   1 %&&&rz math.erfinvctj|d|g5tj|cdddS#1swYyxYw)a!Compute inverse error function. Given `x`, compute the inverse error function of `x`. This function is the inverse of `tf.math.erf`. Args: x: `Tensor` with type `float` or `double`. name: A name for the operation (optional). Returns: Inverse error function of `x`. erfinvN)rr3rrrs rUrrs9 ~~dHqc*"   q !""" 8Az math.ndtrictj|d|g5tj|cdddS#1swYyxYw)zCompute quantile of Standard Normal. Args: x: `Tensor` with type `float` or `double`. name: A name for the operation (optional). Returns: Inverse error function of `x`. ndtriN)rr3rrrs rUrrs9 ~~dGaS)!   a !!!rz math.erfcinvctj|d|g5tj|d}td|z t j dzcdddS#1swYyxYw)aComputes the inverse of complementary error function. Given `x`, compute the inverse complementary error function of `x`. This function is the inverse of `tf.math.erfc`, and is defined on `[0, 2]`. >>> tf.math.erfcinv([0., 0.2, 1., 1.5, 2.]) Args: x: `Tensor` with type `float` or `double`. name: A name for the operation (optional). Returns: Inverse complementary error function of `x`. @compatibility(numpy) Equivalent to scipy.special.erfcinv @end_compatibility erfcinvr&r'g?N)rr3r4rrrrs rUrr sW2 ~~dIs+* ag.A #'N?RWWS\ )***s >> tf.math.ceil([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) Args: x: A `tf.Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. `int32` name: A name for the operation (optional). Returns: A `tf.Tensor`. Has the same type as `x`. @compatibility(numpy) Equivalent to np.ceil @end_compatibility )rrrs rUrr's2   1d ##r`z math.sqrtrc.tj||S)aComputes element-wise square root of the input tensor. Note: This operation does not support integer types. >>> x = tf.constant([[4.0], [16.0]]) >>> tf.sqrt(x) >>> y = tf.constant([[-4.0], [16.0]]) >>> tf.sqrt(y) >>> z = tf.constant([[-1.0], [16.0]], dtype=tf.complex128) >>> tf.sqrt(z) Note: In order to support complex type, please provide an input tensor of `complex64` or `complex128`. Args: x: A `tf.Tensor` of type `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128` name: A name for the operation (optional). Returns: A `tf.Tensor` of same size, type and sparsity as `x`. )rrrs rUrrCsF   1d ##r`zmath.exprc.tj||S)aComputes exponential of x element-wise. \\(y = e^x\\). This function computes the exponential of the input tensor element-wise. i.e. `math.exp(x)` or \\(e^x\\), where `x` is the input tensor. \\(e\\) denotes Euler's number and is approximately equal to 2.718281. Output is positive for any real input. >>> x = tf.constant(2.0) >>> tf.math.exp(x) >>> x = tf.constant([2.0, 8.0]) >>> tf.math.exp(x) For complex numbers, the exponential value is calculated as $$ e^{x+iy} = {e^x} {e^{iy}} = {e^x} ({\cos (y) + i \sin (y)}) $$ For `1+1j` the value would be computed as: $$ e^1 (\cos (1) + i \sin (1)) = 2.7182817 \times (0.5403023+0.84147096j) $$ >>> x = tf.constant(1 + 1j) >>> tf.math.exp(x) Args: x: A `tf.Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `tf.Tensor`. Has the same type as `x`. @compatibility(numpy) Equivalent to np.exp @end_compatibility )rrrs rUrrjs^   !T ""r`zmath.sobol_samplectj|d|||g5tj||||cdddS#1swYyxYw)a*Generates points from the Sobol sequence. Creates a Sobol sequence with `num_results` samples. Each sample has dimension `dim`. Skips the first `skip` samples. Args: dim: Positive scalar `Tensor` representing each sample's dimension. num_results: Positive scalar `Tensor` of dtype int32. The number of Sobol points to return in the output. skip: (Optional) Positive scalar `Tensor` of dtype int32. The number of initial points of the Sobol sequence to skip. Default value is 0. dtype: (Optional) The `tf.Dtype` of the sample. One of: `tf.float32` or `tf.float64`. Defaults to `tf.float32`. name: (Optional) Python `str` name prefixed to ops created by this function. Returns: `Tensor` of samples from Sobol sequence with `shape` [num_results, dim]. sobolr-N)rr3r sobol_sample)dim num_resultsskipr+r(s rUrrsH* ~~dGc;%=>J  $ $S+t5 IJJJs >Az math.rsqrtrsqrtc.tj||S)aComputes reciprocal of square root of x element-wise. For example: >>> x = tf.constant([2., 0., -2.]) >>> tf.math.rsqrt(x) Args: x: A `tf.Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `tf.Tensor`. Has the same type as `x`. )rrrs rUrrs,   At $$r`z math.acosacosc.tj||S)aComputes acos of x element-wise. Provided an input tensor, the `tf.math.acos` operation returns the inverse cosine of each element of the tensor. If `y = tf.math.cos(x)` then, `x = tf.math.acos(y)`. Input range is `[-1, 1]` and the output has a range of `[0, pi]`. For example: >>> x = tf.constant([1.0, -0.5, 3.4, 0.2, 0.0, -2], dtype = tf.float32) >>> tf.math.acos(x) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`, `complex64`, `complex128`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as x. )rrrs rUrrs8   1d ##r`z math.floorfloorc.tj||S)aReturns element-wise largest integer not greater than x. Both input range is `(-inf, inf)` and the output range consists of all integer values. For example: >>> x = tf.constant([1.3324, -1.5, 5.555, -2.532, 0.99, float("inf")]) >>> tf.floor(x).numpy() array([ 1., -2., 5., -3., 0., inf], dtype=float32) Args: x: A `Tensor`. Must be one of the following types: `bfloat16`, `half`, `float32`, `float64`. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type as x. )rrrs rUrrs.   At $$r`)Nrr[)ToFloat)ToDouble)ToInt32)ToInt64) ToBFloat16) ToComplex64) ToComplex128) LogicalXor)Nr1Nr=)NNF)NNNNN)NFN)NFNN) FFFFFFNFFN)FFFFN)T)NNN)rFFN)r\rnumpyrtensorflow.python.compatrrtensorflow.python.eagerrtensorflow.python.frameworkrrrrr r r rr rrtensorflow.python.opsrrrrrrrrrr"tensorflow.python.ops.gen_math_opstensorflow.python.platformrrtensorflow.python.utilrrrrtensorflow.python.util.compatr tensorflow.python.util.tf_exportr! next_afterradd_dispatch_supportdeprecated_endpointsrVr" deprecatedrWrXrbdeprecated_argsreplacer>rcrjrrrtregister_unary_elementwise_apirvrrregister_binary_elementwise_apirrrrrrrrErrrrrrrrrrrrr6rr rrrrrrrrruint16int16uint32rruint64rrxrrr)rrr!r2rr:r=rr.realdiv truncate_div truncatedivr3 truncate_mod truncatemodr>floormodrFrJrKrSrVrYr]r?r_rlrnr=r#register_tensor_conversion_functionrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsparse_mat_mulrrr%rCr(r0RegisterGradientr>r?rBrFrNrSrrbrmrnrtrwrrrrrrrrrrrrrrrrrrrrrrRrUrX left_shift right_shiftr\atan2greater greater_equalless less_equalrMrNr<rsquared_differencexlogyzetaacoshasinasinhatanatanhcoscoshdigammaerferfcexpm1ris_infis_nanlgammarlog1prO reciprocalrintsinsinhrtantanhrar`rUr=s,!6n=+3.6+@5<B43+1/131.,0@1<0).+'96  # #  :; 34 !!!+.n6/5n6b  F + 'E Fw O F + 'E Fw O i[7(77@A i[7(77@A }h'( T#D(*   (()/118f1MO|| 3O*)3 =(r* FLLt O+ OF }h'( T#D(*   (()/118f1MO|| 3O*)3 =(r* FLLt!O+!OR :u (( )+))+`O... =(# )) *$@ ?J' )) .&*(.&dKM&M& dll&: M  ?J' )) &*(& ##++MO&O& dll&: M    DF F &  ,/0 )) $J*1$JN ?M .NO (( -)P-. lr2 ))  *  '*3'  :u )) .*.6 Y' )) *C*(*CZ ; (( ))) ))X ;K01 (( !!!&)"*)2"J ;K01 (( !!!&))*)2)< <\734 (( !!!'*#:+)5#:R <! (( ,)",6 6=! (( O )"O d !?3 (( a))4a)H zl (( T0HI!,J)!,H {m (( T0HI!,J)!,H zl (( T0HI!*J)!*H zl (( T0HI!*J)!*H }o (( T0HI!-J)!-H ~ (( T0HI!.J) !.H   (( T0HI!/J)!!/L LL&.. KK MM6>> LL&.. MM6>> LL&.. MM6>> LL&.. OOT NND NND NND d t$2*58 >9% )) 1&*&1&h ug ))  EG"G* "4 %9<$HI )) !!!,/040*J04f !" )) 4*#4430 ?<= )) !!!*-3.*>34   ''  " " ''  ! ! 2& 0'0>% #5}"EF )) !!!-0-1*G-`+ * + .  <! )) -*"-D [) )) 1**1D "% %&%P "% #&#L 7 T?T?n?C-2L ?>> NN57 )$P   ,/0 TL(*$( H8*1 H8V lr2 >B3>BD#"'"" B '( ()(V #_56 TL(* = $ $( CE*7CEL B'    ,, G(GT !=12  %)! >93>9B }4 757t !" :I#:Iz  .'.'b }4 ,5,^ !=12 TL(* %)! 39*3 39l  ,/0 TL(*$( 88*1 88v lr2 ;3;|  ,/0 TL(*$( 88*1 88v lr2 -B3-Bb#"'"" B  ,/0 TL(*$( 28*1 28j lr2 +3+\  ,/0 TL(*$( 28*1 28j lr2 +3+\ &(:;< TL(*"!%!*."& 1>*= 1>h "$62> 39?39l >~w78 !!!'*&F+9&FR ?H%    G &G T ?  _._.H! N& &&t-MN!  o  . HH0 F :u )) K2*K2\ <!H:>7/?"7/t $7#HI ;<P"=JP"fo&!'!  ><3 (( /.)4/.d #5}"EF (( !!!-0&@1)G&@R =(# CB$CBL >~y9: !!!),0B-;0Bf &,G+HI 3BJ3Bl ;K01 (( !!!&)4I*)24In!H$B  $&=>@ !!!"9:/;@ /d "&(ABD !!!";<2)=D 2)j #%9:;!!!"67  V8<Vr !b) ~=*~=B B'   M(M` $&;<=!!!"78  89>8v R(   /)/d &(?@A!!!"9:  .;B.b "r*   +++\ ;*+ Q,Qh > C C L #$ (( 7)%7> < )) $*$> > ))  &* &F = ((  ") "  < ((  !) ! > (( *)*6 ;K01 (( !!!&)$*)2$0 ; ((  $)  $H :u (( ,#),#d  ()dJ J. <\734 (( !!!'*%+)5%* ; (( $) $8 <! (( %)"%2)(()D)DE((()C)CD((()D)DE((()C)CD((()D)DE'''(>(>?(((););<((()?)?@((()?)?@((()=)=>((()C)CD((():):;((()@)@A((()A)AB((()@)@A((()=)=>((()=)=>((()>)>?((()H)HI((()B)BC((()B)BC(((););<((():):;('' (:(:;''' (9(9:''' (:(:;''' (9(9:''' (:(:;''' (8(89''' (9(9:''' (<(<=''' (8(89''' (9(9:''' (:(:;''' (>(>?''' (;(;<''' (;(;<''' (;(;<''' (8(89''' (:(:;''' (@(@A''' (8(89''' (?(?@''' (?(?@''' (9(9:''' (8(89''' (9(9:''' (;(;<''' (8(89''' (9(9:r`