o ij@s ddlmZddlmZddlmZddlmZddlmZddl Z ddd Z edd d e d ed ee BdBdej dee edfBf ddZde dde_ddZddZedddd e dededBd ee BdBdej def ddZeddd e_edddd e dededBd ee BdBdej def d!d"Zed"d#d$e_edddd e dededBd ee BdBdej def d%d&Zed&d'd(e_edddd e dededBd ee BdBdej def d)d*Zed*d+d,e_edddd e dededBd ee BdBdej def d-d.Zed.d/d0e_edddd e dededBd ee BdBdej def d1d2Zed2d3d4e_edddd e dededBd ee BdBdej def d5d6Zed6d7d8e_edddd e dededBd ee BdBdej def d9d:Zed:d;d<e_edddd e dededBd ee BdBdej def d=d>Zed>d?d@e_edddd e dededBd ee BdBdej def dAdBZedBdCdDe_edddd e dededBd ee BdBdej def dEdFZedFdGdHe_edd d e d ed ee BdBdej def dIdJZdKe ddLe_dMdNZedd d e d ed ee BdBdej def dOdPZ edPdQdRdSe _edd d e d ed ee BdBdej def dTdUZ!edUdVdWdSe!_edd d e d ed ee BdBdej def dXdYZ"edYdZd[dSe"_edd d e d ed ee BdBdej def d\d]Z#ed]d^d_dSe#_edd d e d ed ee BdBdej def d`daZ$edadbd_dSe$_edd d e d ed ee BdBdej def dcddZ%eddded_dSe%_edd d e d ed ee BdBdej def dfdgZ&edgdhdidSe&_edd d e d ed ee BdBdej def djdkZ'edkdldmdSe'_edd d e dnedoedped ee BdBdej defdqdrZ(edrdsdtdue(_edd d e d ed ee BdBdej def dvdwZ)edwdxdydSe)_edd d e d ed ee BdBdej def dzd{Z*ed{d|d}dSe*_edd d e d ed ee BdBdej def d~dZ+eddddSe+_edd d e d ed ee BdBdej def ddZ,eddddSe,_edd d e d ed ee BdBdej def ddZ-eddddSe-_edd d e d ed ee BdBdej def ddZ.eddddSe._edd d e d ed ee BdBdej def ddZ/eddddSe/_edd d e d ed ee BdBdej def ddZ0eddddSe0_edd d e d ed ee BdBdej def ddZ1eddddSe1_edd d e d ed ee BdBdej def ddZ2de dde2_ddZ3edd d e d ed ee BdBdej def ddZ4e3dddde4_edd d e d ed ee BdBdej def ddZ5e3dddde5_edd d e d ed ee BdBdej def ddZ6e3dddde6_edd d e ded ee BdBdej def ddZ7de dde7_edd d e ded ee BdBdej def ddZ8de dde8_edd d e ded ee BdBdej def ddZ9de dde9_edd d e ded ee BdBdej def ddZ:de dde:_edd d e ded ee BdBdej def ddZ;de dde;_edd d e dedej d ee BdBdej def ddZe=ddwe>_edd d e ded ee BdBdej def ddƄZ?e=dd{e?_ddȄe@DZAdS))api)Tensor)BackendN)Unionc Cs>|rdnd}|r dnd}d|rdndd|d |d |d S) NrsyieszRArgs: description: Description string for the operation in einx notation. tensorz*tensorsz: Input tensorz or tensor factoraO matching the description string. backend: Backend to use for all operations. If None, uses the :doc:`default backend ` for the given setting. Defaults to None. graph: Whether to return the compiled code representation of this operation instead of computing the result. Defaults to False. z **parameters: Additional parameters that specify dimension sizes, e.g. ``a=4``. Returns: The result of the operation if ``graph=False``, otherwise the compiled code representation of the operation. )singlekwargsrr r r J/home/ubuntu/.local/lib/python3.10/site-packages/einx/_src/frontend/ops.py _args_return s   r)backend descriptiontensorsr parametersreturn.cO|j|g|Ri|SN)idrrrrr r rrraCompute the identity-map of values in the given tensor. In the simplest case, the elementary operation has the signature ``[] -> []`` and returns the input as-is. If there are more than one input/ output or concatenated inputs/ outputs, the ordered tuple of inputs is returned as-is. F cCs2|d|d|d|d|d|dtddS) NzB. The elementary operation has the signature ``[...] -> []`` and z. If there is no output expression, it is determined implicitly by removing all bracketed expressions from the input expression. For example, the following operations compute the same output: .. code-block:: python y = einx.z("a [b]", x) y = einx.a("a [b] -> a", x) If there are no brackets in the expression, brackets are implicitly placed around all axes that do not appear in the output expression. For example, the following operations compute the same output: .. code-block:: python y = einx.z("a b -> a", x) y = einx.z("a [b] -> a", x) Trr)opline1outputr r r_make_reduction_doc)s  r cCs |durtjdtdddSdS)NzThe 'keepdims' argument in einx reduction operations is deprecated and will be removed in a future version. Please use a flattened axis instead. For example, instead of einx.{op}("a [b]", x, keepdims=True) write einx.{op}("a ([b])", x). ) stacklevel)warningswarnDeprecationWarning)keepdimsr r r_keepdims_warningBs r')r&rr r&cK t||j||fd|i|SNr&)r'sumrr r&rrr r rr*Mr*z-Compute the sum of values in the given tensorz2computes the sum of all values of the input tensorcKr(r))r'meanr+r r rr-Vr,r-z.Compute the mean of values in the given tensorz3computes the mean of all values of the input tensorcKr(r))r'varr+r r rr._r,r.z2Compute the variance of values in the given tensorz7computes the variance of all values of the input tensorcKr(r))r'stdr+r r rr/hr,r/z []`` and computes the dot-product over the two input vectors. If more than two tensors or more than two axes are passed to the elementary operation, the dot-product is applied sequentially in an unspecified order to all pairs of dimensions with the same name. If there are no brackets in the expression, brackets are placed implicitly around all axes that do not appear in the output expression. For example, the following operations compute the same output: .. code-block:: python z = einx.dot("a b, b c -> a c", x, y) z = einx.dot("a [b], [b] c -> a c", x, y)  c Cs|dkrd|d|d|d|d|d }n|dkr.d |d |d |d |d |d }ntd|d|d|dtddS)Nz z = einx.z("a b, a", x, y) z = einx.z&("a b, a -> a b", x, y) z = einx.z ("a b, a b", x, y) z = einx.z(("a b, a b -> a b", x, y) z = einx.zP("a b, b a", x, y) # raises an exception due to ambiguous output expression z w = einx.z$("a b, a, b", x, y, z) w = einx.z,("a b, a, b -> a b", x, y, z) w = einx.z(("a b, a b, a b", x, y, z) w = einx.z0("a b, a b, a b -> a b", x, y, z) w = einx.zX("a b, b a, a b", x, y, z) # raises an exception due to ambiguous output expression z Invalid nargsz. The elementary operation a . If there is no output expression, one of the input expressions is implicitly used as output expression if it contains the axis names of all other inputs and if this choice is unique. For example, the following pairs of operations compute the same output: .. code-block:: python z Fr) ValueErrorr)rrrnargscoder r r_make_elwise_docs@      r>cOrr)addrr r rr?rr?z3Compute the sum of values of multiple given tensorsz:takes any number of scalars as input and returns their sumr9cOrr)subtractrr r rr@rr@z;Computes the difference between values of two given tensorszBtakes two scalars as input and subtracts the second from the firstcOrr)multiplyrr r rrArrAz7Compute the product of values of multiple given tensorsz>takes any number of scalars as input and returns their productcOrr) true_dividerr r rrBrrBz>Computes the true division between values of two given tensorsz>takes two scalars as input and divides the first by the secondcOrr) floor_dividerr r rrC"rrCz?Computes the floor division between values of two given tensorscOrr)dividerr r rrD,rrDz9Computes the division between values of two given tensorscOrr) logical_andrr r rrE6rrEzICompute the logical conjunction (AND) of values of multiple given tensorszPtakes any number of scalars as input and returns their logical conjunction (AND)cOrr) logical_orrr r rrFCrrFzHCompute the logical disjunction (OR) of values of multiple given tensorszOtakes any number of scalars as input and returns their logical disjunction (OR)maskxr cKs|j||||fi|Sr)where)rrGrHr rrr r rrIPrrIzDConditionally select values from two tensors based on a boolean maskzrtakes three scalars as input (mask, true_val, false_val) and returns true_val if mask is true, otherwise false_valr:cOrr)maximumrr r rrJ]rrJz7Compute the maximum of values of multiple given tensorsz>takes any number of scalars as input and returns their maximumcOrr)minimumrr r rrKgrrKz7Compute the minimum of values of multiple given tensorsz>takes any number of scalars as input and returns their minimumcOrr)lessrr r rrLqrrLzEComputes the less-than comparison between values of two given tensorszatakes two scalars as input and returns true if the first is less than the second, otherwise falsecOrr) less_equalrr r rrM~rrMzNComputes the less-than-or-equal comparison between values of two given tensorszmtakes two scalars as input and returns true if the first is less than or equal to the second, otherwise falsecOrr)greaterrr r rrNrrNzHComputes the greater-than comparison between values of two given tensorszdtakes two scalars as input and returns true if the first is greater than the second, otherwise falsecOrr) greater_equalrr r rrOrrOzQComputes the greater-than-or-equal comparison between values of two given tensorszptakes two scalars as input and returns true if the first is greater than or equal to the second, otherwise falsecOrr)equalrr r rrPrrPzDComputes the equality comparison between values of two given tensorszNtakes two scalars as input and returns true if they are equal, otherwise falsecOrr) not_equalrr r rrQrrQzHComputes the non-equality comparison between values of two given tensorszNtakes two scalars as input and returns false if they are equal, otherwise truecOrr) logaddexprr r rrRrrRz;Compute the log-sum-exp of values of multiple given tensorszBtakes any number of scalars as input and returns their log-sum-expcOrr)get_atrr r rrSrrSaARetrieves values from a tensor at the coordinates specified by another tensor. The elementary operation has the signature ``[...] , [n] -> []``. The first argument is the n-dimensional value tensor, the second argument specifies a single n-dimensional coordinate, and the result is the value at that coordinate. For 1-dimensional value tensors, the elementary operation also accepts the signature ``[...] , [] -> []``. For example, the following two operations compute the same output: .. code-block:: python y = einx.get_at("[h], p [1] -> p", x, idx) y = einx.get_at("[h], p -> p", x, idx[:, 0]) The elementary operation also accepts multiple coordinate tensors as input, in which case they are concatenated first. The length of the resulting coordinate vector must equal the number of dimensions of the value tensor. For example, the following two operations compute the same output: .. code-block:: python y = einx.get_at("[a b c d], p [n] -> p", x, idx) y = einx.get_at("[a b c d], p, p [2], p [1] -> p", x, idx[:, 0], idx[:, 1:3], idx[:, 3:4]) cCsD|d|d|d|d|d|d|d|d|d td d S) Na at the coordinates specified by an indexing tensor. The elementary operation has the signature ``[...] , [n], [] -> [...]``. The first argument is the n-dimensional value tensor, the second argument specifies a single n-dimensional coordinate, the third argument is the z: value, and the result is the value tensor with the value z at that coordinate. For 1-dimensional value tensors, the elementary operation also accepts the signature ``[...] , [], [] -> []``. For example, the following two operations compute the same output: .. code-block:: python y = einx.z@("p [h], p [1], p -> p [h]", x, idx, update) y = einx.a("p [h], p, p -> p [h]", x, idx[:, 0], update) The elementary operation also accepts multiple coordinate tensors as input, in which case they are concatenated first. The length of the resulting coordinate vector must equal the number of dimensions of the value tensor. The update tensor always is the last argument. For example, the following two operations compute the same output: .. code-block:: python y = einx.zf("p [a b c d], p [n], p -> p", x, idx, update) y = einx.a:("p [a b c d], p, p [2], p [1], p -> p", x, idx[:, 0], idx[:, 1:3], idx[:, 3:4], update) If no output expression is given, it is implicitly chosen to be the same as the input expression of the value tensor. For example, the following two operations compute the same output: .. code-block:: python y = einx.z;("b [h w] c, b p [2], b p c", x, idx, update) y = einx.a("b [h w] c, b p [2], b p c -> b [h w] c", x, idx, update) The order in which the updates are applied depends on the chosen backend. The operation also may or may not update the target tensor inplace. Please check by inspecting the code representation (by passing ``graph=True``). Fr8r)rrvalue1value2r r r_update_at_docs&  "rVcOrr)set_atrr r rrWrrWz4Sets values in a target tensor from an update tensornew overwrittencOrr)add_atrr r rrZrrZz4Adds values from an update tensor to a target tensoraddedcOrr) subtract_atrr r rr\rr\z9Subtracts values from a target tensor by an update tensor subtractedcK|j||fi|Sr)softmaxrr rrr r rr_&r_aCompute the softmax of values in the given tensor. The elementary operation has the signature ``[...] -> [...]`` and computes the softmax over all input values. If there is no output expression, it is chosen to be the same as the input expression. For example, the following operations compute the same output: .. code-block:: python y = einx.softmax("a [b]", x) y = einx.softmax("a [b] -> a [b]", x) TcKr^r) log_softmaxr`r r rrb:rarbaCompute the log-softmax of values in the given tensor. The elementary operation has the signature ``[...] -> [...]`` and computes the log-softmax over all input values. If there is no output expression, it is chosen to be the same as the input expression. For example, the following operations compute the same output: .. code-block:: python y = einx.log_softmax("a [b]", x) y = einx.log_softmax("a [b] -> a [b]", x) cKr^r)sortr`r r rrcNrarcaReturns values in the given tensor sorted in ascending order. The elementary operation has the signature ``[a] -> [a]`` and returns the values sorted along the single axis in ascending order. If there is no output expression, it is chosen to be the same as the input expression. For example, the following operations compute the same output: .. code-block:: python y = einx.sort("a [b]", x) y = einx.sort("a [b] -> a [b]", x) cKr^r)argsortr`r r rrdbrardaReturns the indices that would sort values in the given tensor in ascending order. The elementary operation has the signature ``[a] -> [a]`` and returns the indices that would sort values along the single axis in ascending order. If there is no output expression, it is chosen to be the same as the input expression. For example, the following operations compute the same output: .. code-block:: python y = einx.argsort("a [b]", x) y = einx.argsort("a [b] -> a [b]", x) cKr^r)flipr`r r rrevrareaReverse the order of elements in the given tensor. The elementary operation has the signature ``[...] -> [...]`` and reverses the order of elements along all axes. If there is no output expression, it is chosen to be the same as the input expression. For example, the following operations compute the same output: .. code-block:: python y = einx.flip("a [b]", x) y = einx.flip("a [b] -> a [b]", x) shiftcKs|j||fd|i|S)Nrf)roll)rr rfrrr r rrgrrgaRolls the elements in the given tensor by the specified shift amounts. The elementary operation has the signature ``[...] -> [...]`` and rolls elements separately along all axes. Elements that are rolled beyond the last position are re-introduced at the first position. If there is no output expression, it is chosen to be the same as the input expression. For example, the following operations compute the same output: .. code-block:: python y = einx.roll("a [b]", x, shift=4) y = einx.roll("a [b] -> a [b]", x, shift=4) zshift: Amounts by which elements are shifted along each axis. Can be a single integer or a list of integers matching the number of axes in the tensor.cCs4d|d|d|d|d|d|dtdd S) NzFind the coordinates of the z values in the given tensor. The elementary operation has the signature ``[...] -> [n]``. It takes an n-dimensional tensor as input and returns the n-dimensional coordinate vector of the z value. For 1-dimensional tensors, the elementary operation also accepts the signature ``[a] -> []``. For example, the following two operations compute the same output: .. code-block:: python y = einx.argmaz$x("a [b] -> a [1]", x) y = einx.z("a [b] -> a ", x) If no output is given, it is determined implicitly by replacing a single bracketed expression in the input with ``[n]``. For example, the following two operations compute the same output: .. code-block:: python y = einx.z("a [b c]", x) y = einx.z("a [b c] -> a [2]", x) Trr)rfindr r r_make_argfind_docs  ricKr^r)argmaxr`r r rrjrarjcKr^r)argminr`r r rrkrarkcCs8g|]}|dr|dvrtt|rt|qS)r)rnptrrrTuple)islowercallableglobals).0namer r r s $rs)r)Brtypesrrr numpy.typingtypingrlrr#rstr ArrayLiketupler__doc__r r'boolr*r-r.r/r0r1r2r3r4r5r6r7r>r?r@rArBrCrDrErFrIrJrKrLrMrNrOrPrQrRrSrVrWrZr\r_rbrcrdrergrirjrkdiropsr r r rs     <   :::::  :::::0 )0000000080000000000 '0000 0 0 0 0 6  0 0