2VhLi*ddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddl m Z ddl mZddl mZdd lmZdd lmZdd lmZdd lmZGd deZeddgdLdZdMdZGddeZeddgdZGddeZeddgdZGddeZedd gd!ZGd"d#eZ ed$d%gdNd&Z!Gd'd(eZ"Gd)d*eZ#ed+d,gd-Z$ed.d/gdNd0Z%Gd1d2eZ&ed3d4gdNd5Z'Gd6d7eZ(ed8d9gdNd:Z)Gd;dg dOd?Z+Gd@dAeZ,edBdCgdPdDZ-GdEdFeZ.edGdHgdIZ/GdJdKeZ0edLdMgdNZ1GdOdPeZ2edQdRgdSZ3GdTdUeZ4edVdWgdXZ5GdYdZeZ6ed[d\gd]Z7Gd^d_eZ8ed`dagdbZ9GdcddeZ:ededfgdgZ;GdhdieZ<edjdkgdNdlZ=GdmdneZ>edodpgdNdqZ?GdrdseZ@edtdugdQdvZAGdwdxeZBedydzgdOd{ZCGd|d}eZDed~dgdRdZEGddeZFeddgdZGGddeZHeddgdZIGddeZJeddgdSdZKGddeZLeddgdZMGddeZNeddgdZOGddeZPeddgdZQGddeZReddgdZSGddeZTeddgdZUGddeZVeddgdZWGddeZXeddgdZYGddeZZeddgdZ[GddeZ\eddgdZ]GddeZ^eddgdZ_Gd„deZ`eddgdƄZaGdDŽdeZbeddgd˄ZcGd̄deZdeddgdЄZeGdфdeZfeddgdTdՄZgGdքdeZheddgdڄZiGdۄdehZjeddgd߄ZkGddeZleddgdZmGddeZneddgdZoGddeZpeddgdZqGddeZreddgdOdZsGddeZteddgdUdZuGddeZveddgdRdZwGddeZxeddgdRdZyGddeZzeddgdTdZ{Gdd eZ|ed d gdTd Z}Gd deZ~eddgdVdZGddeZeddgdWdZGddeZeddgdZGddeZeddgd ZGd!d"eZed#d$gd%ZGd&d'eZed(d)gdOd*ZGd+d,eZed-d.gd/ZGd0d1eZed2d3gd4ZGd5d6eZed7d8gd9ZGd:d;eZed<d=gd>ZGd?d@eZedAdBgdCZGdDdEeZedFdGgdOdHZGdIdJeZedKdLgdMZGdNdOeZedPdQgdOdRZGdSdTeZedUdVgdOdWZGdXdYeZedZd[gd\ZGd]d^eZed_d`gdaZGdbdceZedddegdfZGdgdheZedidjgdkZGdldmeZedndogdOdpZGdqdreZedsdtgduZGdvdweZedxdygdXdzZGd{d|eZed}d~gdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddg dYdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZedÐdgdZdńZGdƄdeZedȐdgdʄZGd˄deZed͐dgd[dτZGdЄdeZedҐdgdԄZGdՄdeZedאdgdNdلZGdڄdeZedܐdgdސdߜdZGddeZeddgd[dZGddeZeddgdZGddeZeddgdZGddeZeddgdZGddeZeddgd\dZGddeZeddgdZGddeZeddgdZGddeZeddgdZGd d eZed d gdOd ZGddeZeddgdOdZGddeZeddgdZGddeZeddgd]dZGddeZedd gd[d!ZGd"d#eZed$d%gd^d&ZGd'd(eZed)d*gd+ZGd,d-eZed.d/gd0ZGd1d2eZed3d4gd5ZGd6d7eZed8d9gd:ZGd;dgdOd?ZGd@dAeZedBdCgdDZGdEdFeZedGdHgdOdIZGdJdKeZedLdMgdTdNZGdOdPeZedQgd_dRZGdSdTeZedUdVgdWZGdXdYeZedZd[gd\ZGd]d^eZed_d`gdaZGdbdceZedddegdfZGdgdheZedidjgdkZ GdldmeZ edndogdQdpZ GdqdreZ edsdtgdTduZ GdvdweZedxdygdTdzZGd{d|eZed}d~gdNdZGddeZeddgdZGddeZeddgdOdZGddeZeddgdOdZGddeZeddgdZGddeZeddgdZGddeZeddgd`dZGddeZeddgdZGddeZ eddgdVdZ!GddeZ"eddgdadZ#GddeZ$eddgdTdZ%GddeZ&eddgdTdZ'GddeZ(eddgdZ)GddeZ*eddgdZ+GddeZ,edÐdgdńZ-edƐdgdddȜdɄZ.GdʄdeZ/ed̐dgd΄Z0GdτdeZ1edѐdgdRdӄZ2GdԄdeZ3ed֐dgd؄Z4GdلdeZ5edېdgd݄Z6GdބdeZ7eddgdZ8GddeZ9eddgdZ:GddeZ;eddgdZ<GddeZ=eddgdZ>GddeZ?eddgdZ@GddeZAeddgdZBGddeZCeddgdZDGddeZEeddgdOdZFGddeZGedd gdOd ZHGd d eZIed dgdNdZJGddeZKeddgdNdZLGddeZMeddgdNdZNGddeZOeddgdOdZPGdd eZQed!d"gdOd#ZRGd$d%eZSed&d'gdad(ZTGd)d*eZUed+d,gd-ZVGd.d/eZWed0d1gd2ZXGd3d4eZYed5d6gdbd7ZZGd8d9eZ[ed:d;gdTd<Z\Gd=d>eZ]ed?d@gdAZ^GdBdCeZ_edDdEgdQdFZ`GdGdHeZaedIdJgdcdKZby(dN)backend) keras_export KerasTensor)any_symbolic_tensors)dtypes)canonicalize_axis)to_tuple_or_list)operation_utils) Operation)broadcast_shapes) reduce_shapec,eZdZdfd ZdZdZxZS)Rot90c>t|||_||_yN)super__init__kaxes)selfrr __class__s C/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/ops/numpy.pyrzRot90.__init__  cntjj||j|jS)Nrr)rnumpyrot90rr)rarrays rcallz Rot90.calls&}}""5DFF"CCrcrt|j}t|dkrtd|t|jdk7s|jd|jdk(rtd|jd|j\}}||||c||<||<t ||j S)NzCInput array must have at least 2 dimensions. Received: array.shape=rzInvalid axes: z3. Axes must be a tuple of two different dimensions.shapedtype)listr&len ValueErrorrrr')rr array_shapeaxis1axis2s rcompute_output_speczRot90.compute_output_specs5;;' { a ))4 7  tyy>Q $))A,$))A,">  ,DD yy u     / EK.EKK@@rr$)rr$__name__ __module__ __qualname__rr!r. __classcell__rs@rrrs DArrzkeras.ops.rot90zkeras.ops.numpy.rot90ct|frt||j|Stjj |||S)akRotate an array by 90 degrees in the plane specified by axes. This function rotates an array counterclockwise by 90 degrees `k` times in the plane specified by `axes`. Supports arrays of two or more dimensions. Args: array: Input array to rotate. k: Number of times the array is rotated by 90 degrees. axes: A tuple of two integers specifying the plane of rotation (defaults to `(0, 1)`). Returns: Rotated array. Examples: >>> import numpy as np >>> from keras import ops >>> m = np.array([[1, 2], [3, 4]]) >>> rotated = ops.rot90(m) >>> rotated array([[2, 4], [1, 3]]) >>> m = np.arange(8).reshape((2, 2, 2)) >>> rotated = ops.rot90(m, k=1, axes=(1, 2)) >>> rotated array([[[1, 3], [0, 2]], [[5, 7], [4, 6]]]) r)rr symbolic_callrrr)r rrs rrr0sCFUH%qt$22599 ==  u  55rc t|t|k7ryt|}t|}|$t|tr|g}|D] }d||<d||<|r4t t|D]}||||||<||||||<||k(S)aCheck if two shapes are equal. Args: shape1: A list or tuple of integers for first shape to be compared. shape2: A list or tuple of integers for second shape to be compared. axis: An integer, list, or tuple of integers (optional): Axes to ignore during comparison. Defaults to `None`. allow_none (bool, optional): If `True`, allows `None` in a shape to match any value in the corresponding position of the other shape. Defaults to `True`. Returns: bool: `True` if shapes are considered equal based on the criteria, `False` otherwise. Examples: >>> shape_equal((32, 64, 128), (32, 64, 128)) True >>> shape_equal((32, 64, 128), (32, 64, 127)) False >>> shape_equal((32, 64, None), (32, 64, 128), allow_none=True) True >>> shape_equal((32, 64, None), (32, 64, 128), allow_none=False) False >>> shape_equal((32, 64, 128), (32, 63, 128), axis=1) True >>> shape_equal((32, 64, 128), (32, 63, 127), axis=(1, 2)) True >>> shape_equal((32, 64, 128), (32, 63, 127), axis=[1,2]) True >>> shape_equal((32, 64), (32, 64, 128)) False F)r)r( isinstanceintrange)shape1shape2axis allow_noneaxis r shape_equalrCXsF 6{c&k! &\F &\F  dC 6D BF2JF2J s6{# &Aay "1Iq ay "1Iq  & V rceZdZdZdZy)Absolutec@tjj|Sr)rrabsoluterxs rr!z Absolute.call}}%%a((rc`t|dd}t|j|j|SNsparseFr'rMgetattrrr&r'rrIrMs rr.zAbsolute.compute_output_spec'He,177!''&AArNr1r2r3r!r.rrrErE )BrrEzkeras.ops.absolutezkeras.ops.numpy.absolutect|frtj|Stjj |S)adCompute the absolute value element-wise. `keras.ops.abs` is a shorthand for this function. Args: x: Input tensor. Returns: An array containing the absolute value of each element in `x`. Example: >>> x = keras.ops.convert_to_tensor([-1.2, 1.2]) >>> keras.ops.absolute(x) array([1.2, 1.2], dtype=float32) )rrEr7rrrGrIs rrGrGs6$QD!z''** == ! !! $$rc eZdZy)AbsNr1r2r3rTrrrYrYrrYz keras.ops.abszkeras.ops.numpy.absct|S)z#Shorthand for `keras.ops.absolute`.)rGrWs rabsr]s A;rceZdZdZdZy)AddcBtjj||Sr)rraddrx1x2s rr!zAdd.call}}  R((rc &t|dg}t|dg}t||}tjt|dt |t|dt |}t|dd}t|dd}|xr|} t ||| SNr&r'rMFrNrPr r result_typetyper rrcrdx1_shapex2_shape output_shape output_dtype x1_sparse x2_sparse output_sparses rr.zAdd.compute_output_spec2w+2w+'(; )) Bb * Bb * B%0 B%0 !/i   ]  rNrSrTrrr_r_s )  rr_z keras.ops.addzkeras.ops.numpy.addct||frtj||Stjj ||S)aAdd arguments element-wise. Args: x1: First input tensor. x2: Second input tensor. Returns: The tensor containing the element-wise sum of `x1` and `x2`. Examples: >>> x1 = keras.ops.convert_to_tensor([1, 4]) >>> x2 = keras.ops.convert_to_tensor([5, 6]) >>> keras.ops.add(x1, x2) array([6, 10], dtype=int32) `keras.ops.add` also broadcasts shapes: >>> x1 = keras.ops.convert_to_tensor( ... [[5, 4], ... [5, 6]] ... ) >>> x2 = keras.ops.convert_to_tensor([5, 6]) >>> keras.ops.add(x1, x2) array([[10 10] [10 12]], shape=(2, 2), dtype=int32) )rr_r7rrrarcrds rraras<6RH%u""2r** ==  R $$rc,eZdZdfd ZdZdZxZS)Allc~t|t|tr|g|_||_y||_||_yrrrr:r;r?keepdimsrr?rzrs rrz All.__init__:  dC DI! DI  rcntjj||j|jSNr?rz)rrallr?rzrHs rr!zAll.call/}}  ]]!  rcptt|j|j|jdSNrboolr'rrr&r?rzrHs rr.zAll.compute_output_spec1 YY     rNFr0r5s@rrwrw!  rrwz keras.ops.allzkeras.ops.numpy.allct|frt||j|Stjj |||S)aTest whether all array elements along a given axis evaluate to `True`. Args: x: Input tensor. axis: An integer or tuple of integers that represent the axis along which a logical AND reduction is performed. The default (`axis=None`) is to perform a logical AND over all the dimensions of the input array. `axis` may be negative, in which case it counts for the last to the first axis. keepdims: If `True`, axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array. Defaults to `False`. Returns: The tensor containing the logical AND reduction over the `axis`. Examples: >>> x = keras.ops.convert_to_tensor([True, False]) >>> keras.ops.all(x) array(False, shape=(), dtype=bool) >>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.all(x, axis=0) array([ True False], shape=(2,), dtype=bool) `keepdims=True` outputs a tensor with dimensions reduced to one. >>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.all(x, keepdims=True) array([[False]], shape=(1, 1), dtype=bool) r)rrwr7rrrrIr?rzs rrr C@QD!x0>>qAA ==  QTH  ==rc,eZdZdfd ZdZdZxZS)Anyc~t|t|tr|g|_||_y||_||_yrryr{s rrz Any.__init__1r|rcntjj||j|jSr~)rranyr?rzrHs rr!zAny.call9rrcptt|j|j|jdSrrrHs rr.zAny.compute_output_spec@rrrr0r5s@rrr0rrrceZdZdZdZy)Anglec@tjj|Sr)rranglerHs rr!z Angle.callL}}""1%%rctjt|dtj}|dk(rtj}nt j |t }t|j|SNr'int64r rstandardize_dtyperPfloatxrrifloatrr&rrIr's rr.zAngle.compute_output_specOY))'!Wgnn>N*OP G NN$E&&ue4E177%00rNrSrTrrrrK &1rrzkeras.ops.anglezkeras.ops.numpy.anglect|frtj|Stjj |S)aElement-wise angle of a complex tensor. Arguments: x: Input tensor. Can be real or complex. Returns: Output tensor of same shape as x. containing the angle of each element (in radians). Example: >>> x = keras.ops.convert_to_tensor([[1 + 3j, 2 - 5j], [4 - 3j, 3 + 2j]]) >>> keras.ops.angle(x) array([[ 1.2490457, -1.19029 ], [-0.6435011, 0.5880026]], dtype=float32) )rrr7rrrrWs rrrXs6"QD!w$$Q'' ==  q !!rz keras.ops.anyzkeras.ops.numpy.anyct|frt||j|Stjj |||S)aTest whether any array element along a given axis evaluates to `True`. Args: x: Input tensor. axis: An integer or tuple of integers that represent the axis along which a logical OR reduction is performed. The default (`axis=None`) is to perform a logical OR over all the dimensions of the input array. `axis` may be negative, in which case it counts for the last to the first axis. keepdims: If `True`, axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array. Defaults to `False`. Returns: The tensor containing the logical OR reduction over the `axis`. Examples: >>> x = keras.ops.convert_to_tensor([True, False]) >>> keras.ops.any(x) array(True, shape=(), dtype=bool) >>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.any(x, axis=0) array([ True True], shape=(2,), dtype=bool) `keepdims=True` outputs a tensor with dimensions reduced to one. >>> x = keras.ops.convert_to_tensor([[True, False], [True, True]]) >>> keras.ops.all(x, keepdims=True) array([[False]], shape=(1, 1), dtype=bool) r)rrr7rrrrs rrrnrrc,eZdZdfd ZdZdZxZS)Amaxcdt|t|tr|g}||_||_yrryr{s rrz Amax.__init__-  dC 6D   rcntjj||j|jSr~)rramaxr?rzrHs rr!z Amax.calls/}}!! ]]"  rctt|j|j|j|j SNrrrrr&r?rzr'rHs rr.zAmax.compute_output_spec. tyy4== I''  rrr0r5s@rrrs!  rrzkeras.ops.amaxzkeras.ops.numpy.amaxct|frt||j|Stjj |||S)aReturns the maximum of an array or maximum value along an axis. Args: x: Input tensor. axis: Axis along which to compute the maximum. By default (`axis=None`), find the maximum value in all the dimensions of the input array. keepdims: If `True`, axes which are reduced are left in the result as dimensions that are broadcast to the size of the original input tensor. Defaults to `False`. Returns: An array with the maximum value. If `axis=None`, the result is a scalar value representing the maximum element in the entire array. If `axis` is given, the result is an array with the maximum values along the specified axis. Examples: >>> x = keras.ops.convert_to_tensor([[1, 3, 5], [2, 3, 6]]) >>> keras.ops.amax(x) array(6, dtype=int32) >>> x = keras.ops.convert_to_tensor([[1, 6, 8], [1, 5, 2]]) >>> keras.ops.amax(x, axis=0) array([1, 6, 8], dtype=int32) >>> x = keras.ops.convert_to_tensor([[1, 6, 8], [1, 5, 2]]) >>> keras.ops.amax(x, axis=1, keepdims=True) array([[8], [5]], dtype=int32) r)rrr7rrrrs rrrC@QD!1??BB ==  adX  >>rc,eZdZdfd ZdZdZxZS)Amincdt|t|tr|g}||_||_yrryr{s rrz Amin.__init__rrcntjj||j|jSr~)rraminr?rzrHs rr!z Amin.call&}}!!!$))dmm!LLrctt|j|j|j|j SrrrHs rr.zAmin.compute_output_specrrrr0r5s@rrrs!M rrzkeras.ops.aminzkeras.ops.numpy.aminct|frt||j|Stjj |||S)azReturns the minimum of an array or minimum value along an axis. Args: x: Input tensor. axis: Axis along which to compute the minimum. By default (`axis=None`), find the minimum value in all the dimensions of the input array. keepdims: If `True`, axes which are reduced are left in the result as dimensions that are broadcast to the size of the original input tensor. Defaults to `False`. Returns: An array with the minimum value. If `axis=None`, the result is a scalar value representing the minimum element in the entire array. If `axis` is given, the result is an array with the minimum values along the specified axis. Examples: >>> x = keras.ops.convert_to_tensor([1, 3, 5, 2, 3, 6]) >>> keras.ops.amin(x) array(1, dtype=int32) >>> x = keras.ops.convert_to_tensor([[1, 6, 8], [7, 5, 3]]) >>> keras.ops.amin(x, axis=0) array([1,5,3], dtype=int32) >>> x = keras.ops.convert_to_tensor([[1, 6, 8], [7, 5, 3]]) >>> keras.ops.amin(x, axis=1, keepdims=True) array([[1],[3]], dtype=int32) r)rrr7rrrrs rrrrrc,eZdZdfd ZdZdZxZS)Appendc0t|||_yrrrr?rr?rs rrzAppend.__init__  rcZtjj|||jSNr?)rrappendr?rbs rr!z Append.call s"}}##B#;;rc X|j}|j}tjt|dt |t|dt |}|j Nd|vsd|vrdg}n5t tj|tj|zg}t||St|||j gstd|j d|d|dt|}||j ||j z||j <t||S)Nr'rzA`append` requires inputs to have the same shape except the `axis=z`, but received shape  and .) r&rrirPrjr?r;npprodrrCr*r()rrcrdrlrmr'rns rr.zAppend.compute_output_spec s8888"" Bb * Bb *  99 x48#3 $v #BGGH$58I$I JK |59 98X {; #9(5*A  H~ "*499"58K"K TYY>> x1 = keras.ops.convert_to_tensor([1, 2, 3]) >>> x2 = keras.ops.convert_to_tensor([[4, 5, 6], [7, 8, 9]]) >>> keras.ops.append(x1, x2) array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32) When `axis` is specified, `x1` and `x2` must have compatible shapes. >>> x1 = keras.ops.convert_to_tensor([[1, 2, 3], [4, 5, 6]]) >>> x2 = keras.ops.convert_to_tensor([[7, 8, 9]]) >>> keras.ops.append(x1, x2, axis=0) array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=int32) >>> x3 = keras.ops.convert_to_tensor([7, 8, 9]) >>> keras.ops.append(x1, x3, axis=0) Traceback (most recent call last): ... TypeError: Cannot concatenate arrays with different numbers of dimensions: got (2, 3), (3,). r)rrr7rrr)rcrdr?s rrr'sEJRH%4 ..r266 ==  BT  22rceZdZddZddZy)ArangeNcHtjj||||S)Nstepr'rrarange)rstartstoprr's rr!z Arange.callRs }}##E4d%#HHrc @|d|}}ttj||z |z g}|et|dt |t|dt |g}|%|j t|dt |t j|}t||S)Nrr'r) r;rceilrPrjrrrir)rrrrr'rndtypes_to_resolves rr.zArange.compute_output_specUs <U4EBGGTE\T$9:;< =wU 4gtDz2! !((wT )KL&&(9:E>> keras.ops.arange(3) array([0, 1, 2], dtype=int32) >>> keras.ops.arange(3.0) array([0., 1., 2.], dtype=float32) >>> keras.ops.arange(3, 7) array([3, 4, 5, 6], dtype=int32) >>> keras.ops.arange(3, 7, 2) array([3, 5], dtype=int32) rr)rrrr's rrrds#\ ==  t$e  DDrceZdZdZdZy)Arccosc@tjj|Sr)rrarccosrHs rr!z Arccos.call}}##A&&rctjt|dtj}|dk(rtj}nt j |t }t|j|Srrrs rr.zArccos.compute_output_specrrNrSrTrrrrs '1rrzkeras.ops.arccoszkeras.ops.numpy.arccosct|frtj|Stjj |S)aTrigonometric inverse cosine, element-wise. The inverse of `cos` so that, if `y = cos(x)`, then `x = arccos(y)`. Args: x: Input tensor. Returns: Tensor of the angle of the ray intersecting the unit circle at the given x-coordinate in radians `[0, pi]`. Example: >>> x = keras.ops.convert_to_tensor([1, -1]) >>> keras.ops.arccos(x) array([0.0, 3.1415927], dtype=float32) )rrr7rrrrWs rrrs6$QD!x%%a(( ==   ""rceZdZdZdZy)Arccoshc@tjj|Sr)rrarccoshrHs rr!z Arccosh.call}}$$Q''rctjt|dtj}|dk(rtj}nt j |t }t|j|Srrrs rr.zArccosh.compute_output_specrrNrSrTrrrrs (1rrzkeras.ops.arccoshzkeras.ops.numpy.arccoshct|frtj|Stjj |S)aInverse hyperbolic cosine, element-wise. Arguments: x: Input tensor. Returns: Output tensor of same shape as x. Example: >>> x = keras.ops.convert_to_tensor([10, 100]) >>> keras.ops.arccosh(x) array([2.993223, 5.298292], dtype=float32) )rrr7rrrrWs rrr6QD!y&&q)) ==  ##rceZdZdZdZy)Arcsinc@tjj|Sr)rrarcsinrHs rr!z Arcsin.callrrctjt|dtj}|dk(rtj}nt j |t }t|dd}t|j||SNr'rrMFrNrrrIr'rMs rr.zArcsin.compute_output_speci))'!Wgnn>N*OP G NN$E&&ue4EHe,177%??rNrSrTrrrr '@rrzkeras.ops.arcsinzkeras.ops.numpy.arcsinct|frtj|Stjj |S)abInverse sine, element-wise. Args: x: Input tensor. Returns: Tensor of the inverse sine of each element in `x`, in radians and in the closed interval `[-pi/2, pi/2]`. Example: >>> x = keras.ops.convert_to_tensor([1, -1, 0]) >>> keras.ops.arcsin(x) array([ 1.5707964, -1.5707964, 0.], dtype=float32) )rrr7rrrrWs rrr6 QD!x%%a(( ==   ""rceZdZdZdZy)Arcsinhc@tjj|Sr)rrarcsinhrHs rr!z Arcsinh.callrrctjt|dtj}|dk(rtj}nt j |t }t|dd}t|j||Srrrs rr.zArcsinh.compute_output_specrrNrSrTrrrr (@rrzkeras.ops.arcsinhzkeras.ops.numpy.arcsinhct|frtj|Stjj |S)a&Inverse hyperbolic sine, element-wise. Arguments: x: Input tensor. Returns: Output tensor of same shape as `x`. Example: >>> x = keras.ops.convert_to_tensor([1, -1, 0]) >>> keras.ops.arcsinh(x) array([0.88137364, -0.88137364, 0.0], dtype=float32) )rrr7rrrrWs rrr rrceZdZdZdZy)Arctanc@tjj|Sr)rrarctanrHs rr!z Arctan.call rrctjt|dtj}|dk(rtj}nt j |t }t|dd}t|j||Srrrs rr.zArctan.compute_output_spec#rrNrSrTrrrrrrrzkeras.ops.arctanzkeras.ops.numpy.arctanct|frtj|Stjj |S)aNTrigonometric inverse tangent, element-wise. Args: x: Input tensor. Returns: Tensor of the inverse tangent of each element in `x`, in the interval `[-pi/2, pi/2]`. Example: >>> x = keras.ops.convert_to_tensor([0, 1]) >>> keras.ops.arctan(x) array([0., 0.7853982], dtype=float32) )rrr7rrrrWs rrr-rrceZdZdZdZy)Arctan2cBtjj||Sr)rrarctan2rbs rr!z Arctan2.callC}}$$R,,rcft|dg}t|dg}t||}tjt|dtj}tjt|dtj}t j ||t}t||SNr&r'r) rPr rrrrrirr) rrcrdrlrm outputs_shapex1_dtypex2_dtyper's rr.zArctan2.compute_output_specFs2w+2w+(8< ,, B!1 2 ,, B!1 2 ""8Xu==66rNrSrTrrrrBs - 7rrzkeras.ops.arctan2zkeras.ops.numpy.arctan2ct||frtj||Stjj ||S)aElement-wise arc tangent of `x1/x2` choosing the quadrant correctly. The quadrant (i.e., branch) is chosen so that `arctan2(x1, x2)` is the signed angle in radians between the ray ending at the origin and passing through the point `(1, 0)`, and the ray ending at the origin and passing through the point `(x2, x1)`. (Note the role reversal: the "y-coordinate" is the first function parameter, the "x-coordinate" is the second.) By IEEE convention, this function is defined for `x2 = +/-0` and for either or both of `x1` and `x2` `= +/-inf`. Args: x1: First input tensor. x2: Second input tensor. Returns: Tensor of angles in radians, in the range `[-pi, pi]`. Examples: Consider four points in different quadrants: >>> x = keras.ops.convert_to_tensor([-1, +1, +1, -1]) >>> y = keras.ops.convert_to_tensor([-1, -1, +1, +1]) >>> keras.ops.arctan2(y, x) * 180 / numpy.pi array([-135., -45., 45., 135.], dtype=float32) Note the order of the parameters. `arctan2` is defined also when x2=0 and at several other points, obtaining values in the range `[-pi, pi]`: >>> keras.ops.arctan2( ... keras.ops.array([1., -1.]), ... keras.ops.array([0., 0.]), ... ) array([ 1.5707964, -1.5707964], dtype=float32) >>> keras.ops.arctan2( ... keras.ops.array([0., 0., numpy.inf]), ... keras.ops.array([+0., -0., numpy.inf]), ... ) array([0., 3.1415925, 0.7853982], dtype=float32) )rrr7rrrrus rrrTs=NRH%y&&r2.. == R ((rceZdZdZdZy)Arctanhc@tjj|Sr)rrarctanhrHs rr!z Arctanh.callrrctjt|dtj}|dk(rtj}nt j |t }t|dd}t|j||Srrrs rr.zArctanh.compute_output_specrrNrSrTrrr r rrr zkeras.ops.arctanhzkeras.ops.numpy.arctanhct|frtj|Stjj |S)zInverse hyperbolic tangent, element-wise. Arguments: x: Input tensor. Returns: Output tensor of same shape as `x`. )rr r7rrr rWs rr r 6QD!y&&q)) ==  ##rc,eZdZdfd ZdZdZxZS)Argmaxc>t|||_||_yrrrr?rzr{s rrzArgmax.__init__    rcntjj||j|jSr~)rrargmaxr?rzrHs rr!z Argmax.call&}}##ADII #NNrc|jrt|jdS|j tgdStt |j|jgdSNint32rrrzrr&r?rrHs rr.zArgmax.compute_output_specT ==qwwg6 6 99 r1 1  { 37  rrr0r5s@rrr! O rrzkeras.ops.argmaxzkeras.ops.numpy.argmaxct|frt||j|Stjj |||S)a1Returns the indices of the maximum values along an axis. Args: x: Input tensor. axis: By default, the index is into the flattened tensor, otherwise along the specified axis. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Defaults to `False`. Returns: Tensor of indices. It has the same shape as `x`, with the dimension along `axis` removed. Example: >>> x = keras.ops.arange(6).reshape(2, 3) + 10 >>> x array([[10, 11, 12], [13, 14, 15]], dtype=int32) >>> keras.ops.argmax(x) array(5, dtype=int32) >>> keras.ops.argmax(x, axis=0) array([1, 1, 1], dtype=int32) >>> keras.ops.argmax(x, axis=1) array([2, 2], dtype=int32) r)rrr7rrrrs rrrB6QD!4(3AA!DD ==  x  @@rc,eZdZdfd ZdZdZxZS)Argminc>t|||_||_yrrr{s rrzArgmin.__init__rrcntjj||j|jSr~)rrargminr?rzrHs rr!z Argmin.callrrc|jrt|jdS|j tgdStt |j|jgdSrrrHs rr.zArgmin.compute_output_specrrrr0r5s@rr r rrr zkeras.ops.argminzkeras.ops.numpy.argminct|frt||j|Stjj |||S)a1Returns the indices of the minimum values along an axis. Args: x: Input tensor. axis: By default, the index is into the flattened tensor, otherwise along the specified axis. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Defaults to `False`. Returns: Tensor of indices. It has the same shape as `x`, with the dimension along `axis` removed. Example: >>> x = keras.ops.arange(6).reshape(2, 3) + 10 >>> x array([[10, 11, 12], [13, 14, 15]], dtype=int32) >>> keras.ops.argmin(x) array(0, dtype=int32) >>> keras.ops.argmin(x, axis=0) array([0, 0, 0], dtype=int32) >>> keras.ops.argmin(x, axis=1) array([0, 0], dtype=int32) r)rr r7rrr#rs rr#r#rrc,eZdZdfd ZdZdZxZS)Argsortc0t|||_yrrrs rrzArgsort.__init__rrcXtjj||jSr)rrargsortr?rHs rr!z Argsort.call }}$$QTYY$77rc|j4tttj|j gdSt|j dSNrr)r?rr;rrr&rHs rr.zArgsort.compute_output_spec s? 99 BGGAGG$4 56gF F177'22rr9r0r5s@rr'r's83rr'zkeras.ops.argsortzkeras.ops.numpy.argsortct|frt|j|Stjj ||S)a2Returns the indices that would sort a tensor. Args: x: Input tensor. axis: Axis along which to sort. Defaults to `-1` (the last axis). If `None`, the flattened tensor is used. Returns: Tensor of indices that sort `x` along the specified `axis`. Examples: One dimensional array: >>> x = keras.ops.array([3, 1, 2]) >>> keras.ops.argsort(x) array([1, 2, 0], dtype=int32) Two-dimensional array: >>> x = keras.ops.array([[0, 3], [3, 2], [4, 5]]) >>> x array([[0, 3], [3, 2], [4, 5]], dtype=int32) >>> keras.ops.argsort(x, axis=0) array([[0, 1], [1, 0], [2, 2]], dtype=int32) >>> keras.ops.argsort(x, axis=1) array([[0, 1], [1, 0], [0, 1]], dtype=int32) r)rr'r7rrr*rIr?s rr*r*s?BQD!D!//22 ==  ..rceZdZddZddZy)ArrayNcDtjj||SNr)rrr rs rr!z Array.call8s}}""1E"22rc0t|j|Sr4rr&rs rr.zArray.compute_output_spec;s177%00rrrSrTrrr2r27s 31rr2zkeras.ops.arrayzkeras.ops.numpy.arrayct|frtj||Stjj ||S)a>Create a tensor. Args: x: Input tensor. dtype: The desired data-type for the tensor. Returns: A tensor. Examples: >>> keras.ops.array([1, 2, 3]) array([1, 2, 3], dtype=int32) >>> keras.ops.array([1, 2, 3], dtype="float32") array([1., 2., 3.], dtype=float32) r)rr2r7rrr rIr's rr r ?s@$QD!w$$Qe$44 ==  q  ..rc0eZdZdfd ZddZddZxZS)Averagec0t|||_yrrrs rrzAverage.__init__Ws  rcZtjj|||jS)Nweightsr?)rraverager?)rrIr>s rr!z Average.call]s"}}$$Qdii$HHrc t|dt|tg}|t|j|jd}|j 0t|j|j g|jd}|j t|dt|tj|}|j 7|r tg|Std|jd|jd|sr-tt|j|j g|Std |j d |jd |j d |j|j d ) Nr'Tr@rzX`weights` must have the same shape as `x` when `axis=None`, but received `weights.shape=z` and `x.shape=`.rz2`weights` must have the same size as `x` at `axis=z` but received `weights.shape=z` while x.shape at `z` is `) rPrjrrCr&r?rrrirr*r)rrIr>r shape_matchshape_match_on_axisr's rr.zAverage.compute_output_spec`sg$Qa95A  %aggw}}NKyy$&1WWTYY'('--D'#  $ $WWgtG}%M N""$56 99 +"2U33 @@G O%%&WWIR1 ?1[QWWDII;7u   $"")--1II;fQWWTYY%7$8< rrr0r5s@rr:r:Vs I rr:zkeras.ops.averagezkeras.ops.numpy.averagect|frt|j||Stjj |||S)a,Compute the weighted average along the specified axis. Args: x: Input tensor. axis: Integer along which to average `x`. The default, `axis=None`, will average over all of the elements of the input tensor. If axis is negative it counts from the last to the first axis. weights: Tensor of weights associated with the values in `x`. Each value in `x` contributes to the average according to its associated weight. The weights array can either be 1-D (in which case its length must be the size of a along the given axis) or of the same shape as `x`. If `weights=None` (default), then all data in `x` are assumed to have a weight equal to one. The 1-D calculation is: `avg = sum(a * weights) / sum(weights)`. The only constraint on weights is that `sum(weights)` must not be 0. Returns: Return the average along the specified axis. Examples: >>> data = keras.ops.arange(1, 5) >>> data array([1, 2, 3, 4], dtype=int32) >>> keras.ops.average(data) array(2.5, dtype=float32) >>> keras.ops.average( ... keras.ops.arange(1, 11), ... weights=keras.ops.arange(10, 0, -1) ... ) array(4., dtype=float32) >>> data = keras.ops.arange(6).reshape((3, 2)) >>> data array([[0, 1], [2, 3], [4, 5]], dtype=int32) >>> keras.ops.average( ... data, ... axis=1, ... weights=keras.ops.array([1./4, 3./4]) ... ) array([0.75, 2.75, 4.75], dtype=float32) >>> keras.ops.average( ... data, ... weights=keras.ops.array([1./4, 3./4]) ... ) Traceback (most recent call last): ... ValueError: Axis must be specified when shapes of a and weights differ. r)r>r=)rr:r7rrr?)rIr?r>s rr?r?sFjQD!D!//7/CC == G$ ??rceZdZdZdZy)Bartlettc@tjj|Sr)rrbartlettrHs rr!z Bartlett.callrJrcTt|jtjSr4rr&rrrHs rr.zBartlett.compute_output_spec177'..*:;;rNrSrTrrrGrG )>> x = keras.ops.convert_to_tensor(5) >>> keras.ops.bartlett(x) array([0. , 0.5, 1. , 0.5, 0. ], dtype=float32) )rrGr7rrrIrWs rrIrIs6 QD!z''** == ! !! $$rceZdZdZdZy)Hammingc@tjj|Sr)rrhammingrHs rr!z Hamming.callrrcTt|jtjSr4rKrHs rr.zHamming.compute_output_specrLrNrSrTrrrPrPs (>> x = keras.ops.convert_to_tensor(5) >>> keras.ops.hamming(x) array([0.08, 0.54, 1. , 0.54, 0.08], dtype=float32) )rrPr7rrrRrWs rrRrRs6$QD!y&&q)) ==  ##rc,eZdZdfd ZdZdZxZS)BincountcLt|||_||_||_yr)rrr> minlengthrM)rr>rXrMrs rrzBincount.__init__s#  " rctjj||j|j|j S)Nr>rXrM)rrbincountr>rXrMrHs rr!z Bincount.calls6}}%% LLnn;; &  rcX|jg}|jMtj|j}|j |jt j |}nd}t|dd}tt|jdddgz||xs |jS)NrrMFr9rN) r'r>rconvert_to_tensorrrrirPrr(r&rM)rrIrr>r'x_sparses rr.zBincount.compute_output_specsWWI << #// =G  $ $W]] 3&&(9:EE1h. " $ '*t{{  rNrFr0r5s@rrVrVs    rrVzkeras.ops.bincountzkeras.ops.numpy.bincountct|frt|||j|Stjj ||||S)aCount the number of occurrences of each value in a tensor of integers. Args: x: Input tensor. It must be of dimension 1, and it must only contain non-negative integer(s). weights: Weight tensor. It must have the same length as `x`. The default value is `None`. If specified, `x` is weighted by it, i.e. if `n = x[i]`, `out[n] += weight[i]` instead of the default behavior `out[n] += 1`. minlength: An integer. The default value is 0. If specified, there will be at least this number of bins in the output tensor. If greater than `max(x) + 1`, each value of the output at an index higher than `max(x)` is set to 0. sparse: Whether to return a sparse tensor; for backends that support sparse tensors. Returns: 1D tensor where each element gives the number of occurrence(s) of its index value in x. Its length is the maximum between `max(x) + 1` and minlength. Examples: >>> x = keras.ops.array([1, 2, 2, 3], dtype="uint8") >>> keras.ops.bincount(x) array([0, 1, 2, 1], dtype=int32) >>> weights = x / 2 >>> weights array([0.5, 1., 1., 1.5], dtype=float64) >>> keras.ops.bincount(x, weights=weights) array([0., 0.5, 2., 1.5], dtype=float64) >>> minlength = (keras.ops.max(x).numpy() + 1) + 2 # 6 >>> keras.ops.bincount(x, minlength=minlength) array([0, 1, 2, 1, 0, 0], dtype=int32) rZ)rrVr7rrr[)rIr>rXrMs rr[r[sTLQD!y -   == ! ! 7i " rc*eZdZfdZdZdZxZS) BitwiseAndc"t|yrrrrrs rrzBitwiseAnd.__init__H rcBtjj||Sr)rr bitwise_andrrIys rr!zBitwiseAnd.callK}}((A..rctj|j|j}t|j|Sr4rrir'rr&rrIrjr's rr.zBitwiseAnd.compute_output_specN-""177AGG4177%00rr0r5s@rrbrbG/1rrbzkeras.ops.bitwise_andzkeras.ops.numpy.bitwise_andct||frtj||Stjj ||S)aPCompute the bit-wise AND of two arrays element-wise. Computes the bit-wise AND of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator `&`. Args: x: Input integer tensor. y: Input integer tensor. Returns: Result tensor. )rrbr7rrrhrIrjs rrhrhS<QF#|))!Q// == $ $Q **rc*eZdZfdZdZdZxZS) BitwiseInvertc"t|yrrdres rrzBitwiseInvert.__init__hrfrc@tjj|Sr)rrbitwise_invertrHs rr!zBitwiseInvert.callks}}++A..rcDt|j|jSr4rr&r'rHs rr.z!BitwiseInvert.compute_output_specn177!''22rr0r5s@rrurugs/3rruzkeras.ops.bitwise_invertzkeras.ops.numpy.bitwise_invertct|frtj|Stjj |Sa5Compute bit-wise inversion, or bit-wise NOT, element-wise. Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator `~`. Args: x: Input integer tensor. Returns: Result tensor. )rrur7rrrxrWs rrxrxrs6QD!,,Q// == ' ' **rc*eZdZfdZdZdZxZS) BitwiseNotc"t|yrrdres rrzBitwiseNot.__init__rfrc@tjj|Sr)rr bitwise_notrHs rr!zBitwiseNot.call}}((++rcDt|j|jSr4rzrHs rr.zBitwiseNot.compute_output_specr{rr0r5s@rrrs,3rrzkeras.ops.bitwise_notzkeras.ops.numpy.bitwise_notct|frtj|Stjj |Sr})rrr7rrrrWs rrrs6QD!|))!,, == $ $Q ''rc*eZdZfdZdZdZxZS) BitwiseOrc"t|yrrdres rrzBitwiseOr.__init__rfrcBtjj||Sr)rr bitwise_orris rr!zBitwiseOr.call}}''1--rctj|j|j}t|j|Sr4rmrns rr.zBitwiseOr.compute_output_specrorr0r5s@rrrs.1rrzkeras.ops.bitwise_orzkeras.ops.numpy.bitwise_orct||frtj||Stjj ||S)aNCompute the bit-wise OR of two arrays element-wise. Computes the bit-wise OR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator `|`. Args: x: Input integer tensor. y: Input integer tensor. Returns: Result tensor. )rrr7rrrrrs rrr<QF#{((A.. == # #Aq ))rc*eZdZfdZdZdZxZS) BitwiseXorc"t|yrrdres rrzBitwiseXor.__init__rfrcBtjj||Sr)rr bitwise_xorris rr!zBitwiseXor.callrkrctj|j|j}t|j|Sr4rmrns rr.zBitwiseXor.compute_output_specrorr0r5s@rrrrprrzkeras.ops.bitwise_xorzkeras.ops.numpy.bitwise_xorct||frtj||Stjj ||S)aPCompute the bit-wise XOR of two arrays element-wise. Computes the bit-wise XOR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator `^`. Args: x: Input integer tensor. y: Input integer tensor. Returns: Result tensor. )rrr7rrrrrs rrrrsrc*eZdZfdZdZdZxZS)BitwiseLeftShiftc"t|yrrdres rrzBitwiseLeftShift.__init__rfrcBtjj||Sr)rrbitwise_left_shiftris rr!zBitwiseLeftShift.calls}}//155rct|tr |j}n*tj|j|j}t |j |Sr4r:r;r'rrirr&rns rr.z$BitwiseLeftShift.compute_output_spec@ a GGE&&qww8E177%00rr0r5s@rrrs61rrzkeras.ops.bitwise_left_shiftz"keras.ops.numpy.bitwise_left_shiftct||frtj||Stjj ||SapShift the bits of an integer to the left. Bits are shifted to the left by appending `y` 0s at the right of `x`. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying `x` by `2**y`. Args: x: Input integer tensor. y: Input integer tensor. Returns: Result tensor. )rrr7rrrrrs rrrs="QF#!//155 == + +Aq 11rc*eZdZfdZdZdZxZS) LeftShiftc"t|yrrdres rrzLeftShift.__init__ rfrcBtjj||Sr)rr left_shiftris rr!zLeftShift.call rrct|tr |j}n*tj|j|j}t |j |Sr4rrns rr.zLeftShift.compute_output_specrrr0r5s@rrrs.1rrzkeras.ops.left_shiftzkeras.ops.numpy.left_shiftct||frtj||Stjj ||Sr)rrr7rrrrrs rrrrrc*eZdZfdZdZdZxZS)BitwiseRightShiftc"t|yrrdres rrzBitwiseRightShift.__init__,rfrcBtjj||Sr)rrbitwise_right_shiftris rr!zBitwiseRightShift.call/s}}00A66rct|tr |j}n*tj|j|j}t |j |Sr4rrns rr.z%BitwiseRightShift.compute_output_spec2rrr0r5s@rrr+s71rrzkeras.ops.bitwise_right_shiftz#keras.ops.numpy.bitwise_right_shiftct||frtj||Stjj ||SaMShift the bits of an integer to the right. Bits are shifted to the right `y`. Because the internal representation of numbers is in binary format, this operation is equivalent to dividing `x` by `2**y`. Args: x: Input integer tensor. y: Input integer tensor. Returns: Result tensor. )rrr7rrrrrs rrr:s="QF# "00A66 == , ,Q 22rc*eZdZfdZdZdZxZS) RightShiftc"t|yrrdres rrzRightShift.__init__QrfrcBtjj||Sr)rr right_shiftris rr!zRightShift.callTrkrct|tr |j}n*tj|j|j}t |j |Sr4rrns rr.zRightShift.compute_output_specWrrr0r5s@rrrPs/1rrzkeras.ops.right_shiftzkeras.ops.numpy.right_shiftct||frtj||Stjj ||Sr)rrr7rrrrrs rrr_rsrceZdZdZdZy)Blackmanc@tjj|Sr)rrblackmanrHs rr!z Blackman.calltrJrcTt|jtjSr4rKrHs rr.zBlackman.compute_output_specwrLrNrSrTrrrrsrMrrzkeras.ops.blackmanzkeras.ops.numpy.blackmanct|frtj|Stjj |S)aBlackman window function. The Blackman window is a taper formed by using a weighted cosine. Args: x: Scalar or 1D Tensor. Window length. Returns: A 1D tensor containing the Blackman window values. Example: >>> x = keras.ops.convert_to_tensor(5) >>> keras.ops.blackman(x) array([-1.3877788e-17, 3.4000000e-01, 1.0000000e+00, 3.4000000e-01, -1.3877788e-17], dtype=float32) )rrr7rrrrWs rrr{s6"QD!z''** == ! !! $$rc*eZdZfdZdZdZxZS) BroadcastToc0t|||_yr)rrr&)rr&rs rrzBroadcastTo.__init__s  rcVtjj||jSr)rr broadcast_tor&rHs rr!zBroadcastTo.calls}}))!TZZ88rct|j|jt|j|jSr4)r r&rr'rHs rr.zBroadcastTo.compute_output_specs)$**-4::QWW55rr0r5s@rrrs96rrzkeras.ops.broadcast_tozkeras.ops.numpy.broadcast_toct|frt|j|Stjj ||S)aBroadcast a tensor to a new shape. Args: x: The tensor to broadcast. shape: The shape of the desired tensor. A single integer `i` is interpreted as `(i,)`. Returns: A tensor with the desired shape. Examples: >>> x = keras.ops.array([1, 2, 3]) >>> keras.ops.broadcast_to(x, (3, 3)) array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) )r&)rrr7rrr)rIr&s rrrs;0QD!'55a88 == % %a //rceZdZdZdZy)Ceilc@tjj|Sr)rrrrHs rr!z Ceil.call}}!!!$$rctj|jdk(rtj}n$t j |jt }t|dd}t|j||SNrrMFrN rrr'rrrirrPrr&rs rr.zCeil.compute_output_specs\  $ $QWW - 8NN$E&&qww6EHe,177%??rNrSrTrrrrs %@rrzkeras.ops.ceilzkeras.ops.numpy.ceilct|frtj|Stjj |S)zReturn the ceiling of the input, element-wise. The ceil of the scalar `x` is the smallest integer `i`, such that `i >= x`. Args: x: Input tensor. Returns: The ceiling of each element in `x`, with float dtype. )rrr7rrrrWs rrrs6QD!v##A&& ==  a  rc*eZdZfdZdZdZxZS)Clipc>t|||_||_yr)rrx_minx_max)rrrrs rrz Clip.__init__s   rcltjj||j|jSr)rrcliprrrHs rr!z Clip.calls#}}!!!TZZ< rrzkeras.ops.count_nonzerozkeras.ops.numpy.count_nonzeroct|frt|j|Stjj ||S)acCounts the number of non-zero values in `x` along the given `axis`. If no axis is specified then all non-zeros in the tensor are counted. Args: x: Input tensor. axis: Axis or tuple of axes along which to count the number of non-zeros. Defaults to `None`. Returns: int or tensor of ints. Examples: >>> x = keras.ops.array([[0, 1, 7, 0], [3, 0, 2, 19]]) >>> keras.ops.count_nonzero(x) 5 >>> keras.ops.count_nonzero(x, axis=0) array([1, 1, 2, 1], dtype=int64) >>> keras.ops.count_nonzero(x, axis=1) array([2, 3], dtype=int64) r)rrr7rrr r0s rr r s>8QD!&44Q77 == & &qt & 44rc,eZdZdfd ZdZdZxZS)Crossc|t||||_||_||_y||_||_||_yr)rraxisaaxisbaxisc)rrrrr?rs rrzCross.__init__s>   DJDJDJDJDJDJrctjj|||j|j|j Sr)rrcrossrrrrbs rr!z Cross.calls+}}""2r4::tzz4::NNrct|j}t|j}||j}||j}||j=||j=t ||}||dvrt d|||dvrt d||dk(s|dk(rdg}ng}|d|j |z||j dz}tj|j|j} t|| S)N)r#zB`x1`'s dim on `axis={axisa}` must be either 2 or 3, but received: zB`x2`'s dim on `axis={axisb}` must be either 2 or 3, but received: rr) r(r&rrr r*rrrir'r) rrcrdrlrm x1_value_size x2_value_sizern value_sizer's rr.zCross.compute_output_specs >> ,  , TZZ TZZ '(;  $f)D*O-   $f)D*O-  A !!3JJ 4:: & 3l4::<6P P ""288RXX6t|||_||_yrrrr?r'rr?r'rs rrzCumprod.__init__F   rcntjj||j|jSNr?r')rrcumprodr?r'rHs rr!z Cumprod.callKs&}}$$QTYYdjj$IIrc(|j;d|jvrd}n6ttj|jf}n |j}t j |jxs |j}|dk(rd}t||SNrrr r?r&r;rrrrr'rrrIrnros rr.zCumprod.compute_output_specNv 99 qww& #BGGAGG$4 57 77L001FqwwG 6 !"L<66rNNr0r5s@rrrEs J 7rrzkeras.ops.cumprodzkeras.ops.numpy.cumprodc(t|||S)a;Return the cumulative product of elements along a given axis. Args: x: Input tensor. axis: Axis along which the cumulative product is computed. By default the input is flattened. dtype: dtype of returned tensor. Defaults to x.dtype. Returns: Output tensor. r$)rrIr?r's rr%r%\s +7E *1 --rc,eZdZdfd ZdZdZxZS)Cumsumc>t|||_||_yrrr s rrzCumsum.__init__mr!rcntjj||j|jSr#)rrcumsumr?r'rHs rr!z Cumsum.callrs&}}##ADIITZZ#HHrc(|j;d|jvrd}n6ttj|jf}n |j}t j |jxs |j}|dk(rd}t||Sr'r(r)s rr.zCumsum.compute_output_specur*rr+r0r5s@rr/r/ls I 7rr/zkeras.ops.cumsumzkeras.ops.numpy.cumsumc(t|||S)a4Returns the cumulative sum of elements along a given axis. Args: x: Input tensor. axis: Axis along which the cumulative sum is computed. By default the input is flattened. dtype: dtype of returned tensor. Defaults to x.dtype. Returns: Output tensor. r$)r/r-s rr2r2s *6t5 )! ,,rc,eZdZdfd ZdZdZxZS)Diagc0t|||_yrrrrrrrs rrz Diag.__init__ rcXtjj||jSNr)rrdiagrrHs rr!z Diag.call }}!!!tvv!..rc |j}t|dk(rh|dddg}n|dttj|j z|dttj|j zg}nt|dk(rd|vrdg}ntj |d|d}|j dkDr|d|j z }n|d|j z}ttjdtj ||g}ntd|jdt||jS)Nr$rr#z+`x` must be 1-D or 2-D, but received shape rr) r&r)r;rr]rminimummaximumr*rr')rrIx_shapern shorter_side remainings rr.zDiag.compute_output_specs''' w<1 qz! $d| AJRVVDFF^!44AJRVVDFF^!44  \Q w $v !zz'!*gajA 66A: ' TVV 3I ' TVV 3I 1bjjL&IJK  =aggYaH  0` for diagonals above the main diagonal, and `k < 0` for diagonals below the main diagonal. Returns: The extracted diagonal or constructed diagonal tensor. Examples: >>> from keras.src import ops >>> x = ops.arange(9).reshape((3, 3)) >>> x array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> ops.diag(x) array([0, 4, 8]) >>> ops.diag(x, k=1) array([1, 5]) >>> ops.diag(x, k=-1) array([3, 7]) >>> ops.diag(ops.diag(x))) array([[0, 0, 0], [0, 4, 0], [0, 0, 8]]) r=)rr6r7rrr>rIrs rr>r>s>DQD!ay&&q)) ==  a1  %%rc,eZdZdfd ZdZdZxZS)Diagflatc0t|||_yrr8r9s rrzDiagflat.__init__r:rcXtjj||jSr<)rrdiagflatrrHs rr!z Diagflat.calls }}%%a466%22rc|j}t|dk(rd}n4t|dk(r |d|dnd}nd}|D]}|d}n ||}||z}|ddg}nV|ttj|j z|ttj|j zg}t ||jS)Nrr$r)r&r)r;rr]rrr')rrIrC flat_sizesrns rr.zDiagflat.compute_output_specs'' w<1 I \Q &-aj&< $II #9 $I& !INI #   $ 0` for diagonals above the main diagonal, and `k < 0` for diagonals below the main diagonal. Returns: A 2-D tensor with the flattened input on the specified diagonal. r=)rrIr7rrrLrGs rrLrL s=QD!!}**1-- == ! !!q ! ))rc,eZdZdfd ZdZdZxZS)DiagonalcLt|||_||_||_yrrroffsetr,r-rrUr,r-rs rrzDiagonal.__init__ #    rctjj||j|j|j SNrUr,r-)rrdiagonalrUr,r-rHs rr!z Diagonal.call s6}}%% ;;**** &  rc t|j}t|dkrtd|jd||j||j g}d||j<d||j <tt dj|}d|vrdg}ntj|d|d}|jdkDr|d|jz }n|d|jz}ttjdtj||g}||z}t||jS)Nr#zM`diagonal` requires an array of at least two dimensions, but `x` is of shape rr9rr$r)r(r&r)r*r,r-filter__ne__rrArUr;rBrr')rrIrCshape_2drn diag_shaperDrEs rr.zDiagonal.compute_output_spec& s$qww- w>> from keras.src import ops >>> x = ops.arange(4).reshape((2, 2)) >>> x array([[0, 1], [2, 3]]) >>> x.diagonal() array([0, 3]) >>> x.diagonal(1) array([1]) >>> x = ops.arange(8).reshape((2, 2, 2)) >>> x array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]) >>> x.diagonal(0, 0, 1) array([[0, 6], [1, 7]]) rZ)rrRr7rrr[rIrUr,r-s rr[r[A s[`QD!  -    == ! !  " rc,eZdZdfd ZdZdZxZS)Diffc>t|||_||_yr)rrnr?)rrgr?rs rrz Diff.__init__ rrcntjj||j|jS)Nrgr?)rrdiffrgr?)ras rr!z Diff.call s&}}!!!tvvDII!>>rct|j}||j}|0tj||j z d||j<t ||jSNrr)r(r&r?builtinsmaxrgrr')rrkr&sizes rr.zDiff.compute_output_spec sUQWW TYY  '||D466M1=E$)) 500rr$r9r0r5s@rrere s ?1rrezkeras.ops.diffzkeras.ops.numpy.diffc(t|||S)a_Calculate the n-th discrete difference along the given axis. The first difference is given by `out[i] = a[i+1] - a[i]` along the given axis, higher differences are calculated by using `diff` recursively. Args: a: Input tensor. n: The number of times values are differenced. Defaults to `1`. axis: Axis to compute discrete difference(s) along. Defaults to `-1`.(last axis). Returns: Tensor of diagonals. Examples: >>> from keras.src import ops >>> x = ops.convert_to_tensor([1, 2, 4, 7, 0]) >>> ops.diff(x) array([ 1, 2, 3, -7]) >>> ops.diff(x, n=2) array([ 1, 1, -10]) >>> x = ops.convert_to_tensor([[1, 3, 6, 10], [0, 5, 6, 8]]) >>> ops.diff(x) array([[2, 3, 4], [5, 1, 2]]) >>> ops.diff(x, axis=0) array([[-1, 2, 0, -2]]) ri)re)rkrgr?s rrjrj s@ 4!$  ""rceZdZdZdZy)DigitizecBtjj||Sr)rrdigitize)rrIbinss rr!z Digitize.call s}}%%a..rc|j}t|dkDrtd|d|t|dd}t |jd|S)Nr$z*`bins` must be a 1D array. Received: bins=z with shape bins.shape=rMFrrN)r&r)r*rPr)rrIrw bins_shaperMs rr.zDigitize.compute_output_spec s^ZZ z?Q >> x = np.array([0.0, 1.0, 3.0, 1.6]) >>> bins = np.array([0.0, 3.0, 4.5, 7.0]) >>> keras.ops.digitize(x, bins) array([1, 1, 2, 1]) )rrtr7rrrv)rIrws rrvrv s<$QI&z''400 == ! !!T **rceZdZdZdZy)DotcBtjj||Sr)rrdotrbs rr!zDot.call rerc tt|dg}tt|dg}tjt|dt |t|dt |}|gk(s|gk(r t ||St |dk(rt |dk(r tg|St |dk(rA|d|dk7r&td|jd|jd t|dd|S|d|d  |d|d k(r|d=|d =t||z|Std |jd|jd ) Nr&r'r$rr9rzyShape must match on the last axis of `x1` and `x2` when `x1` is N-d array while `x2` is 1-D, but receive shape `x1.shape=z` and x2.shape=`rBzShape must match on the last axis of `x1` and second last axis of `x2` when `x1` is N-d array while `x2` is M-D, but received `x1.shape=) r(rPrrirjmultiplyr)rr*r&)rrcrdrlrmr's rr.zDot.compute_output_spec skGR01GR01"" Bb * Bb *  r>X^B# # x=A #h-1"4r/ / x=A |x{* !!# *:288*BH x}E: : RL |#|x|+  x(2%@ @ ""$((+;BHH:R I  rNrSrTrrr|r| s )! rr|z keras.ops.dotzkeras.ops.numpy.dotct||frtj||Stjj ||S)a@Dot product of two tensors. - If both `x1` and `x2` are 1-D tensors, it is inner product of vectors (without complex conjugation). - If both `x1` and `x2` are 2-D tensors, it is matrix multiplication. - If either `x1` or `x2` is 0-D (scalar), it is equivalent to `x1 * x2`. - If `x1` is an N-D tensor and `x2` is a 1-D tensor, it is a sum product over the last axis of `x1` and `x2`. - If `x1` is an N-D tensor and `x2` is an M-D tensor (where `M>=2`), it is a sum product over the last axis of `x1` and the second-to-last axis of `x2`: `dot(x1, x2)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])`. Args: x1: First argument. x2: Second argument. Note: Torch backend does not accept 0-D tensors as arguments. Returns: Dot product of `x1` and `x2`. )rr|r7rrr~rus rr~r~ s<0RH%u""2r** ==  R $$rc*eZdZfdZdZdZxZS)Einsumc0t|||_yr)rr subscripts)rrrs rrzEinsum.__init__ s $rcVtjj|jg|Sr)rreinsumr)roperandss rr!z Einsum.call# s }}##DOO?h??rc  |jjd}t|dkDrtd|jdt|dk(r |d}|d}n|j}d}|jd}t|t|k7r1td t|d t|d |jdt }t }|D]T}|j s||vr||vr|j |.||vs3|j||j |V||j} |j} |D])} | |vs| j| | j | +|D])} | |vs| j| | j | +| }| }t|}t|}|d d j|z} n|} g} t||D]\}}t|dg}|Dcgc]}|dn| }}|jd }| }t|dk(rut|t|dk7rtd|d|dt||dD]#\}}|j|t|dz}%|jd d }n tt|dD])}|j|d|t||dz}+tt|dD]1}|j|d| dz t|| dz dz}3t|d}t|ddk(r t|nt|d }|||}dj|Dcgc] }t|c}dz}|jd |}t!j"dd|}|j}|Dcgc]}|dk(rdn t%|}}| j'|| d}| ddD]}t)||}t+t d|D}t|dk(r |ddk(rd}nt-j.|}t1||Scc}wcc}wcc}w)a) Compute the output shape of `einsum`. The shape computation follows the steps below: 1. Find all letters in the input specs (left part of "->"), and break them into two categories: letters appearing more than once go to `reduced_dims`, otherwise go to `kept_dims`. 2. Adjust `reduced_dims` and `kept_dims` based on the output spec (right part of "->"). The rule is if the letter appears in the output spec, then move it to `kept_dims`, otherwise move it to `reduced_dims`. 3. Compute the target output shape. If no output spec is set, then the target output shape will be "...{kept_dims}", e.g., "...ijk", else it will be the same as output spec. "..." is a wildcard that could map shape of arbitrary length. 4. For each operand in `operands`, map the shape specified in the input spec to the output target, e.g, if operand is of shape [2,3,4], input spec is "i..." and output target is "i...jk", then 2 will go the index 0. For dims not represented by any letter, insert to the wildcard part. For each letter in output target not appearing in input spec, the dim will be 1 for broadcasting. After 4, each operand should have a target shape containing only number and `None`. 5. Broadcast all shapes computed from 4, and the result is the output shape. Let's take an example to illustrate the steps above. Let's define: ```python x = KerasTensor([None, 3, 4]) y = KerasTensor(2, 4, 3) z = knp.einsum("...ij, kji->...k", x, y) ``` 1. `reduced_dims` is {"i", "j"}, `kept_dims` is {"k"}. 2. `reduced_dims` is still {"i", "j"}, and `kept_dims` is {"k"}. 3. Output target is "...k". 4. For `x`, the input spec is "...ij", and the output target is "...k". "i" and "j" do not appear in the output target, so no replacement happens, and [None] goes to wildcard. Afterwards, "k" is replaced by 1, so we get shape [None, 1]. Applying the same logic to `y`, we get shape [2]. 5. Broadcast [None, 1] and [2], and we get [None, 2], which is the output shape. z->r#zCAt most one '->' is supported in `einsum` subscripts, but received rrr$N,zNumber of operands (z,) does not match the number of input specs (z#) in `einsum`, received subscripts=z...r&r9zrNumber of dimensions in the subscript does not match the number of dimensions in the operand, received subscript `z` and operand of shape  z[a-z]z1 z-1c 3nK|]-}tjt|dt|/yw)r'N)rrrPrj).0rIs r z-Einsum.compute_output_spec.. s0))'!Wd1g*FGs35int8rr)rsplitr)r*setisalphararemoversortedjoinziprPreplacestrr<resubr;rr r(rrir)rrsplit_subscriptsr output_spec input_specs reduced_dims kept_dimsrOkept_dims_copyreduced_dims_copydimtarget_broadcast_specexpanded_operands_shapesrIspecrCrp split_specexpanded_shaperBwildcard_shape_start_indexwildcard_shape_end_indexwildcard_shapewildcard_shape_strrnr&rr's rr.zEinsum.compute_output_spec& s;X ??006  1 $ OO,A/   A %)!,J*1-KJK &&s+ { s8} ,&s8}o6**-k*:);<''+&7q:  u E  $A99; $)); a i  #  # $  "'^^-N , 1 1 3   /k)"))#.%))#. /$ ,+%%,,S1"&&s+ ,'I,Ll+ 9%  $)BGGI,>$> !$/ !#% 8[15 BN+113N@N8< #d)3N % + +N ;k5 ` is included as well as subscript labels of the precise output form. operands: The operands to compute the Einstein sum of. Returns: The calculation based on the Einstein summation convention. Example: >>> from keras.src import ops >>> a = ops.arange(25).reshape(5, 5) >>> b = ops.arange(5) >>> c = ops.arange(6).reshape(2, 3) Trace of a matrix: >>> ops.einsum("ii", a) 60 >>> ops.einsum(a, [0, 0]) 60 >>> ops.trace(a) 60 Extract the diagonal: >>> ops.einsum("ii -> i", a) array([ 0, 6, 12, 18, 24]) >>> ops.einsum(a, [0, 0], [0]) array([ 0, 6, 12, 18, 24]) >>> ops.diag(a) array([ 0, 6, 12, 18, 24]) Sum over an axis: >>> ops.einsum("ij -> i", a) array([ 10, 35, 60, 85, 110]) >>> ops.einsum(a, [0, 1], [0]) array([ 10, 35, 60, 85, 110]) >>> ops.sum(a, axis=1) array([ 10, 35, 60, 85, 110]) For higher dimensional tensors summing a single axis can be done with ellipsis: >>> ops.einsum("...j -> ...", a) array([ 10, 35, 60, 85, 110]) >>> np.einsum(a, [..., 1], [...]) array([ 10, 35, 60, 85, 110]) Compute a matrix transpose or reorder any number of axes: >>> ops.einsum("ji", c) array([[0, 3], [1, 4], [2, 5]]) >>> ops.einsum("ij -> ji", c) array([[0, 3], [1, 4], [2, 5]]) >>> ops.einsum(c, [1, 0]) array([[0, 3], [1, 4], [2, 5]]) >>> ops.transpose(c) array([[0, 3], [1, 4], [2, 5]]) Matrix vector multiplication: >>> ops.einsum("ij, j", a, b) array([ 30, 80, 130, 180, 230]) >>> ops.einsum(a, [0, 1], b, [1]) array([ 30, 80, 130, 180, 230]) >>> ops.einsum("...j, j", a, b) array([ 30, 80, 130, 180, 230]) )rrr7rrr)rrs rrr s?hH%/vj!//:: ==   6X 66rceZdZddZddZy)EmptyNcDtjj||Sr4rremptyrr&r's rr!z Empty.call+ }}""5"66rcL|xstj}t||Sr4rrrrs rr.zEmpty.compute_output_spec. ))5..rrrSrTrrrr* 7/rrzkeras.ops.emptyzkeras.ops.numpy.emptycDtjj||S)zReturn a tensor of given shape and type filled with uninitialized data. Args: shape: Shape of the empty tensor. dtype: Desired data type of the empty tensor. Returns: The empty tensor. rrr%s rrr3  ==  uE  22rceZdZdZdZy)EqualcBtjj||Sr)rrequalrbs rr!z Equal.callB }}""2r**rcht|dg}t|dg}t||}t|dSNr&rrrPr rrrcrdrlrmrns rr.zEqual.compute_output_specE 72w+2w+'(; Uf_NN$E177%00rNrSrTrrrr\ s $1rrz keras.ops.expzkeras.ops.numpy.expct|frtj|Stjj |S)zCalculate the exponential of all elements in the input tensor. Args: x: Input tensor. Returns: Output tensor, element-wise exponential of `x`. )rrr7rrrrWs rrrg rrceZdZdZdZy)Exp2c@tjj|Sr)rrexp2rHs rr!z Exp2.callw rrctj|j}d|vs|dk(rtj}t |j |Srrrs rr.zExp2.compute_output_specz rrNrSrTrrrrv s %1rrzkeras.ops.exp2zkeras.ops.numpy.exp2ct|frtj|Stjj |S)zCalculate the base-2 exponential of all elements in the input tensor. Args: x: Input tensor. Returns: Output tensor, element-wise base-2 exponential of `x`. )rrr7rrrrWs rrr rrc*eZdZfdZdZdZxZS) ExpandDimsct|t|ttt fst d|||_y)NzXThe `axis` argument to `expand_dims` should be an integer, tuple or list. Received axis=)rrr:r;tupler(r*r?rs rrzExpandDims.__init__ sD $eT 23004v7  rcVtjj||jSr)rr expand_dimsr?rHs rr!zExpandDims.call s}}((DII66rctj|j|j}t |dd}t ||j |SrL)r compute_expand_dims_output_shaper&r?rPrr'rrIrnrMs rr.zExpandDims.compute_output_spec sB&GG GGTYY He,Uf_NN$EHe,177%??rNrSrTrrrr s &@rrzkeras.ops.expm1zkeras.ops.numpy.expm1ct|frtj|Stjj |S)zCalculate `exp(x) - 1` for all elements in the tensor. Args: x: Input values. Returns: Output tensor, element-wise exponential minus one. )rrr7rrrrWs rrr 6QD!w$$Q'' ==  q !!rc,eZdZdfd ZdZdZxZS)Flipc0t|||_yrrrs rrz Flip.__init__ rrcXtjj||jSr)rrflipr?rHs rr!z Flip.call }}!!!$))!44rcDt|j|jSr4rzrHs rr.zFlip.compute_output_spec r{rrr0r5s@rrr s53rrzkeras.ops.flipzkeras.ops.numpy.flipct|frt|j|Stjj ||S)aReverse the order of elements in the tensor along the given axis. The shape of the tensor is preserved, but the elements are reordered. Args: x: Input tensor. axis: Axis or axes along which to flip the tensor. The default, `axis=None`, will flip over all of the axes of the input tensor. Returns: Output tensor with entries of `axis` reversed. r)rrr7rrrr0s rrr s=QD!,,Q// ==  ad  ++rceZdZdZdZy)Floorc@tjj|Sr)rrfloorrHs rr!z Floor.call rrct|dd}tj|jdk(rtjn#t j |jt}t|j||S)NrMFrrN) rPrrr'rrrirrr&rrIrMr's rr.zFloor.compute_output_spec scHe,((1W< NN ##AGGU3  177%??rNrSrTrrrr &@rrzkeras.ops.floorzkeras.ops.numpy.floorct|frtj|Stjj |S)zReturn the floor of the input, element-wise. The floor of the scalar `x` is the largest integer `i`, such that `i <= x`. Args: x: Input tensor. Returns: Output tensor, element-wise floor of `x`. )rrr7rrrrWs rrr 6QD!w$$Q'' ==  q !!rceZdZddZddZy)FullNcFtjj|||Sr4rrfullrr& fill_valuer's rr!z Full.call s}}!!%5!AArcL|xstj}t||Sr4rrs rr.zFull.compute_output_spec rrrrSrTrrrr s B/rrzkeras.ops.fullzkeras.ops.numpy.fullcFtjj|||S)zReturn a new tensor of given shape and type, filled with `fill_value`. Args: shape: Shape of the new tensor. fill_value: Fill value. dtype: Desired data type of the tensor. Returns: Output tensor. rr)r&rr's rrr s  ==  eZu  ==rceZdZddZddZy)FullLikeNcFtjj|||Sr4)rr full_likerrIrr's rr!z FullLike.call/ s}}&&q*E&BBrcP|xs |j}t|j|Sr4r'rr&rs rr.zFullLike.compute_output_spec2 s! 177%00rrrSrTrrrr. s C1rrzkeras.ops.full_likezkeras.ops.numpy.full_likect|frtj|||Stjj |||S)aReturn a full tensor with the same shape and type as the given tensor. Args: x: Input tensor. fill_value: Fill value. dtype: Overrides data type of the result. Returns: Tensor of `fill_value` with the same shape and type as `x`. r)rrr7rrr)rIrr's rrr7 sDQD!z'':U'CC == " "1j " >>rceZdZdZdZy)GetItemcBt|tr t|}||Sr)r:r(r)rrIkeys rr!z GetItem.callI s c4 *Cv rct|j}g}t|tr|g}nLt|tr t|}n0t|tr|j }nt d|d|jt}|dkDrt d|d|dk(r|jt |sn`|jd}|tk(rGt||jtjz }t||z } ||d| z }|| d}f|tjk(r|jd|st d|jd|d|jd} t|tr4| |dk\r|n|| z} | dks| | k\rt d|jd|d t|trF| 2tt|j!| } |j| n!|j| nt d|ddt#t ||j$ S) Nz1Unsupported key type for array slice. Received: ``r$z0Slice should only have one ellipsis. Received: `rzArray has shape z+ but slice has to many indices. Received: `z but out-of-bounds index z was requested.r)r(r&r:r;rrr*countEllipsisrpopr)rnewaxisslicer<indicesrr') rrIr remaining_shape new_shape remaining_key num_ellipsessubkeyneededconsumedlengthindex new_lengths rr.zGetItem.compute_output_specN sOqww- c3  EM U # IM T "HHJMCC5J %**84 ! B3%qI Q    * "&&q)F!]+m.A.A"**.MM/&8_Yh77 "1()"<#  #" &qwwi077:e1>%((+F&#&%&,kFvEqyEVO(.qwwi8%%(E:FE*%!$UFNN6,B%C!DJ$$Z0$$V, GuANOT5+177;;rNrSrTrrr r H s  @ x2` element-wise. Args: x1: First input tensor. x2: Second input tensor. Returns: Output tensor, element-wise comparison of `x1` and `x2`. )rr#r7rrr%rus rr%r% <RH%y&&r2.. == R ((rceZdZdZdZy) GreaterEqualcBtjj||Sr)rr greater_equalrbs rr!zGreaterEqual.call }}**2r22rcht|dg}t|dg}t||}t|dSrrrs rr.z GreaterEqual.compute_output_spec rrNrSrTrrr*r* s 37rr*zkeras.ops.greater_equalzkeras.ops.numpy.greater_equalct||frtj||Stjj ||S)zReturn the truth value of `x1 >= x2` element-wise. Args: x1: First input tensor. x2: Second input tensor. Returns: Output tensor, element-wise comparison of `x1` and `x2`. )rr*r7rrr,rus rr,r, s< RH%~++B33 == & &r2 ..rceZdZdZdZy)Hstackc@tjj|Sr)rrhstackrs rr!z Hstack.call }}##B''rc |dj}d}g}|D]}t|j|dgdstd|jd|d||jdd}n||jdz }|jt |dt |t |}||d<tj|}t|| S) Nrr$Trrrrr'r r&rCr*rrPrjr(rrir)rrrrrrIrnr's rr.zHstack.compute_output_spec sekk  CAqww 1#$O BBC''K(M, ")QWWQZ-?%)""aggaj0"  $ $WQa%A B CK( , Q""$56s rr.zIdentity.compute_output_spec s$))Aq6//rrrSrTrrr:r: s 60rr:zkeras.ops.identityzkeras.ops.numpy.identitycDtjj||S)a/Return the identity tensor. The identity tensor is a square tensor with ones on the main diagonal and zeros elsewhere. Args: n: Number of rows (and columns) in the `n x n` output tensor. dtype: Data type of the output tensor. Returns: The identity tensor. rr<)rgr's rr=r= s == ! !!5 ! 11rceZdZdZdZy)Imagc@tjj|Sr)rrimagrHs rr!z Imag.call rrc`t|dd}t|j|j|SrLrOrQs rr.zImag.compute_output_spec rRrNrSrTrrrBrB rrrBzkeras.ops.imagzkeras.ops.numpy.imagct|frtj|Stjj |S)zReturn the imaginary part of the complex argument. Args: x: Input tensor. Returns: The imaginary component of the complex argument. )rrBr7rrrDrWs rrDrD$ rrceZdZddZ ddZy)IsclosecHtjj|||||Sr)rrisclose)rrcrdrtolatol equal_nans rr!z Isclose.call4 s}}$$RT4CCrcht|dg}t|dg}t||}t|dSrr) rrcrdrKrLrMrlrmrns rr.zIsclose.compute_output_spec7 s92w+2w+'(; g:0yE>FrSrTrrrHrH3 sD7<7rrHzkeras.ops.isclosezkeras.ops.numpy.isclosect||frtj|||||Stjj |||||S)aAReturn whether two tensors are element-wise almost equal. Args: x1: First input tensor. x2: Second input tensor. rtol: Relative tolerance. atol: Absolute tolerance. equal_nan: If `True`, element-wise NaNs are considered equal. Returns: Output boolean tensor. )rrHr7rrrJ)rcrdrKrLrMs rrJrJ@ sHRH%y&&r2tT9EE == RtY ??rceZdZdZdZy)Isfinitec@tjj|Sr)rrisfiniterHs rr!z Isfinite.callT rJrc0t|jdSNrrr6rHs rr.zIsfinite.compute_output_specW 177&11rNrSrTrrrRrRS s )2rrRzkeras.ops.isfinitezkeras.ops.numpy.isfinitect|frtj|Stjj |S)aBReturn whether a tensor is finite, element-wise. Real values are finite when they are not NaN, not positive infinity, and not negative infinity. Complex values are finite when both their real and imaginary parts are finite. Args: x: Input tensor. Returns: Output boolean tensor. )rrRr7rrrTrWs rrTrT[ s6QD!z''** == ! !! $$rceZdZdZdZy)Isinfc@tjj|Sr)rrisinfrHs rr!z Isinf.callo rrc0t|jdSrVr6rHs rr.zIsinf.compute_output_specr rWrNrSrTrrrZrZn &2rrZzkeras.ops.isinfzkeras.ops.numpy.isinfct|frtj|Stjj |S)zTest element-wise for positive or negative infinity. Args: x: Input tensor. Returns: Output boolean tensor. )rrZr7rrr\rWs rr\r\v rrceZdZdZdZy)Isnanc@tjj|Sr)rrisnanrHs rr!z Isnan.call rrc0t|jdSrVr6rHs rr.zIsnan.compute_output_spec rWrNrSrTrrrara r^rrazkeras.ops.isnanzkeras.ops.numpy.isnanct|frtj|Stjj |S)zTest element-wise for NaN and return result as a boolean tensor. Args: x: Input tensor. Returns: Output boolean tensor. )rrar7rrrcrWs rrcrc rrceZdZdZdZy)LesscBtjj||Sr)rrlessrbs rr!z Less.call }}!!"b))rcht|dg}t|dg}t||}t|dSrrrs rr.zLess.compute_output_spec rrNrSrTrrrgrg s *7rrgzkeras.ops.lesszkeras.ops.numpy.lessct||frtj||Stjj ||S)zReturn the truth value of `x1 < x2` element-wise. Args: x1: First input tensor. x2: Second input tensor. Returns: Output tensor, element-wise comparison of `x1` and `x2`. )rrgr7rrrirus rriri s<RH%v##B++ ==  b" %%rceZdZdZdZy) LessEqualcBtjj||Sr)rr less_equalrbs rr!zLessEqual.call }}''B//rcht|dg}t|dg}t||}t|dSrrrs rr.zLessEqual.compute_output_spec rrNrSrTrrrnrn 07rrnzkeras.ops.less_equalzkeras.ops.numpy.less_equalct||frtj||Stjj ||S)zReturn the truth value of `x1 <= x2` element-wise. Args: x1: First input tensor. x2: Second input tensor. Returns: Output tensor, element-wise comparison of `x1` and `x2`. )rrnr7rrrprus rrprp s< RH%{((R00 == # #B ++rc6eZdZdddedffd ZdZdZxZS)Linspace2TFrcht|||_||_||_||_||_yr)rrnumendpointretstepr'r?)rryrzr{r'r?rs rrzLinspace.__init__ s3      rc tjj|||j|j|j |j |jS)Nryrzr{r'r?)rrlinspaceryrzr{r'r?rrrs rr!z Linspace.call sG}}%%  ]]LL**&  rcNt|dg}t|dg}t||}|jdk(r||jgz}np|jdk\r.|d|j|jgz||jdz}n3|d|jdz|jgz||jdzdz}|j |jnt|dt |}t j|t}|jrt||dfSt||SNr&r9rr$r'r) rPr r?ryr'rjrrirr{rrrr start_shape stop_shapernr's rr.zLinspace.compute_output_spec s&eWb1 T7B/ ' Z@ 99?'488*4L YY!^[tyy)88*tyy{+, _tyy1}-88*tyy1}/0 zz% JJe5  ##E51 << E:DA AS((1W< NN ##AGGU3  177%00rNrSrTrrrr:rrrz keras.ops.logzkeras.ops.numpy.logct|frtj|Stjj |S)zNatural logarithm, element-wise. Args: x: Input tensor. Returns: Output tensor, element-wise natural logarithm of `x`. )rrr7rrrrWs rrrGrrceZdZdZdZy)Log10c@tjj|Sr)rrlog10rHs rr!z Log10.callWrrctj|jdk(rtjn#t j |jt }t|j|Srrrs rr.zLog10.compute_output_specZrrNrSrTrrrrVrrrzkeras.ops.log10zkeras.ops.numpy.log10ct|frtj|Stjj |S)zReturn the base 10 logarithm of the input tensor, element-wise. Args: x: Input tensor. Returns: Output tensor, element-wise base 10 logarithm of `x`. )rrr7rrrrWs rrrcrrceZdZdZdZy)Log1pc@tjj|Sr)rrlog1prHs rr!z Log1p.callsrrctj|jdk(rtjn#t j |jt }t|dd}t|j||Srrrs rr.zLog1p.compute_output_specvc((1W< NN ##AGGU3  He,177%??rNrSrTrrrrrrrrzkeras.ops.log1pzkeras.ops.numpy.log1pct|frtj|Stjj |S)zReturns the natural logarithm of one plus the `x`, element-wise. Calculates `log(1 + x)`. Args: x: Input tensor. Returns: Output tensor, element-wise natural logarithm of `1 + x`. )rrr7rrrrWs rrrrrceZdZdZdZy)Log2c@tjj|Sr)rrlog2rHs rr!z Log2.callrrctj|jdk(rtjn#t j |jt }t|j|Srrrs rr.zLog2.compute_output_specrrNrSrTrrrrrrrzkeras.ops.log2zkeras.ops.numpy.log2ct|frtj|Stjj |S)zBase-2 logarithm of `x`, element-wise. Args: x: Input tensor. Returns: Output tensor, element-wise base-2 logarithm of `x`. )rrr7rrrrWs rrrrrceZdZdZdZy) LogaddexpcBtjj||Sr)rr logaddexprbs rr!zLogaddexp.call}}&&r2..rc t|dg}t|dg}t||}tjt|dt |t|dt |t }t ||SrrPr rrirjrr)rrcrdrlrmrnr's rr.zLogaddexp.compute_output_specsl2w+2w+'(; "" Bb * Bb *    2, it is treated as a stack of matrices residing in the last two indexes and broadcast accordingly. - If the first tensor is 1-D, it is promoted to a matrix by prepending a 1 to its dimensions. After matrix multiplication the prepended 1 is removed. - If the second tensor is 1-D, it is promoted to a matrix by appending a 1 to its dimensions. After matrix multiplication the appended 1 is removed. Args: x1: First tensor. x2: Second tensor. Returns: Output tensor, matrix product of the inputs. )rrr7rrrrus rrrs<(RH%x%%b"-- ==  B ''rc,eZdZdfd ZdZdZxZS)Maxc~t|t|tr |g|_n||_||_||_yrrrr:r;r?rzinitialrr?rzrrs rrz Max.__init__6  dC DIDI   rctjj||j|j|j SNr?rzr)rrror?rzrrHs rr!zMax.call3}}  DII t||!  rctt|j|j|j|j SrrrHs rr.zMax.compute_output_specrrNFNr0r5s@rrr  rrz keras.ops.maxzkeras.ops.numpy.maxct|frt|||j|Stjj ||||S)aReturn the maximum of a tensor or maximum along an axis. Args: x: Input tensor. axis: Axis or axes along which to operate. By default, flattened input is used. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Defaults to `False`. initial: The minimum value of an output element. Defaults to `None`. Returns: Maximum of `x`. r)rrr7rrrorIr?rzrs rroroMQD!xAOO    ==  QTHg  NNrceZdZdZdZy)MaximumcBtjj||Sr)rrrBrbs rr!z Maximum.callrrc &t|dg}t|dg}t||}tjt|dt |t|dt |}t|dd}t|dd}|xr|} t ||| Srgrhrks rr.zMaximum.compute_output_specrsrNrSrTrrrr -  rrzkeras.ops.maximumzkeras.ops.numpy.maximumct||frtj||Stjj ||S)zElement-wise maximum of `x1` and `x2`. Args: x1: First tensor. x2: Second tensor. Returns: Output tensor, element-wise maximum of `x1` and `x2`. )rrr7rrrBrus rrBrBr(rc,eZdZdfd ZdZdZxZS)Mediancdt|t|tr|g}||_||_yrryr{s rrzMedian.__init__ rrcntjj||j|jSr~)rrmedianr?rzrHs rr!z Median.callrrc*t|j|j|j}t j |j dk(rt j}n$tj|j t}t||S)Nrrr) rr&r?rzrrr'rrrirr)rrIrnr's rr.zMedian.compute_output_specsg# GG$))dmm   $ $QWW - 8NN$E&&qww6E>> from keras.src import ops >>> x = ops.array([1, 2, 3]) >>> y = ops.array([4, 5, 6]) >>> grid_x, grid_y = ops.meshgrid(x, y, indexing="ij") >>> grid_x array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) >>> grid_y array([[4, 5, 6], [4, 5, 6], [4, 5, 6]]) rr)rrr7rrr)rrIs rrrTs?@A8x*88!<< == ! !1 8x 88rc,eZdZdfd ZdZdZxZS)Minc~t|t|tr |g|_n||_||_||_yrrrs rrz Min.__init__zrrctjj||j|j|j Sr)rrminr?rzrrHs rr!zMin.callrrctt|j|j|j|j SrrrHs rr.zMin.compute_output_specrrrr0r5s@rrryrrrz keras.ops.minzkeras.ops.numpy.minct|frt|||j|Stjj ||||S)aReturn the minimum of a tensor or minimum along an axis. Args: x: Input tensor. axis: Axis or axes along which to operate. By default, flattened input is used. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Defaults to `False`. initial: The maximum value of an output element. Defaults to `None`. Returns: Minimum of `x`. r)rrr7rrrrs rrrrrceZdZdZdZy)MinimumcBtjj||Sr)rrrArbs rr!z Minimum.callrrc &t|dg}t|dg}t||}tjt|dt |t|dt |}t|dd}t|dd}|xr|} t ||| Srgrhrks rr.zMinimum.compute_output_specrsrNrSrTrrrrrrrzkeras.ops.minimumzkeras.ops.numpy.minimumct||frtj||Stjj ||S)zElement-wise minimum of `x1` and `x2`. Args: x1: First tensor. x2: Second tensor. Returns: Output tensor, element-wise minimum of `x1` and `x2`. )rrr7rrrArus rrArAr(rceZdZdZdZy)ModcBtjj||Sr)rrmodrbs rr!zMod.callrerc t|dg}t|dg}t||}tjt|dt |t|dt |}|dk(rd}t ||S)Nr&r'rrrrhrrcrdrlrmrnros rr.zMod.compute_output_specsv2w+2w+'(; )) Bb * Bb *  6 !"L<|<LLQOO == # #A3vf # MMrceZdZdZdZy)Ndimc@tjj|Sr)rrndimrHs rr!z Ndim.callTs}}!!   rc@tt|jgSr)rr)r&rHs rr.zNdim.compute_output_specYsCL>**rNrSrTrrr)r)Ss  +rr)zkeras.ops.ndimzkeras.ops.numpy.ndimct|frtj|Stjj |S)zReturn the number of dimensions of a tensor. Args: x: Input tensor. Returns: The number of dimensions in `x`. )rr)r7rrr+rWs rr+r+]rrceZdZdZdZy)Nonzeroc@tjj|Sr)rrnonzerorHs rr!z Nonzero.callmrrc ttt|jDcgc]}t ddc}Scc}w)Nrrr)rr<r)r&r)rrIrs rr.zNonzero.compute_output_specps4:?AGG :M NQ[ 0 N  NsANrSrTrrr/r/ls ( rr/zkeras.ops.nonzerozkeras.ops.numpy.nonzeroct|frtj|Stjj |S)zReturn the indices of the elements that are non-zero. Args: x: Input tensor. Returns: Indices of elements that are non-zero. )rr/r7rrr1rWs rr1r1vrrceZdZdZdZy)NotEqualcBtjj||Sr)rr not_equalrbs rr!z NotEqual.callrrcht|dg}t|dg}t||}t|dSrrrs rr.zNotEqual.compute_output_specrrNrSrTrrr5r5s /7rr5zkeras.ops.not_equalzkeras.ops.numpy.not_equalct||frtj||Stjj ||S)zReturn `(x1 != x2)` element-wise. Args: x1: First input tensor. x2: Second input tensor. Returns: Output tensor, element-wise comparison of `x1` and `x2`. )rr5r7rrr7rus rr7r7s<RH%z''B// == " "2r **rceZdZddZddZy)OnesLikeNcDtjj||Sr4)rr ones_likers rr!z OnesLike.calls}}&&q&66rcL| |j}t|j|Sr4rrs rr.zOnesLike.compute_output_spec! =GGE177%00rrrSrTrrr;r;s 71rr;zkeras.ops.ones_likezkeras.ops.numpy.ones_likect|frtj||Stjj ||S)zReturn a tensor of ones with the same shape and type of `x`. Args: x: Input tensor. dtype: Overrides the data type of the result. Returns: A tensor of ones with the same shape and type as `x`. r)rr;r7rrr=r8s rr=r=s@QD!z'''77 == " "1E " 22rceZdZddZddZy) ZerosLikeNcDtjj||Sr4)rr zeros_likers rr!zZerosLike.calls}}'''77rcL| |j}t|j|Sr4rrs rr.zZerosLike.compute_output_specr?rrrSrTrrrBrBs 81rrBzkeras.ops.zeros_likezkeras.ops.numpy.zeros_likect|frtj||Stjj ||S)zReturn a tensor of zeros with the same shape and type as `x`. Args: x: Input tensor. dtype: Overrides the data type of the result. Returns: A tensor of zeros with the same shape and type as `x`. r)rrBr7rrrDr8s rrDrDs@ QD!{((%(88 == # #AU # 33rceZdZdZdZy)OutercBtjj||Sr)rrouterrbs rr!z Outer.callrrc lt|ddg}t|ddg}d|vrd}nttj|}d|vrd}nttj|}||g}t j t|dt |t|dt |}t||S)Nr&r$r'r)rPr;rrrrirjr) rrcrdrlrmx1_flatten_shapex2_flatten_shapernros rr.zOuter.compute_output_specs2w,2w, 8 # "2778#45  8 # "2778#45 (*:; ** Bb * Bb * <|<>':c!''l'J''+~~&67!$..12. J!!''l^1.  }}  nn+ !  rc rt|j}t|jdk(r/t t|Dcgc]}|jd}}nt|jt|k(r |j}nRt d|jdt|jd|jdt|jd t t|D])}||d||<||xx||d||dzz cc<+t ||jScc}w)Nr$rrZr[r\r]r)r(r&r)rSr<r*rr')rrIr^rnrrSrBs rr.zPad.compute_output_spec-s%AGG} t~~ ! #49#l:K4LMq*MIM  C $5 5I''+~~&67!$..12. J!!''l^1. s<() EAA&"& QQ9Q<?Yq\!_#DD  E LLQOO ==  adXU  KKrc,eZdZdfd ZdZdZxZS)Quantilecrt|t|tr|g}||_||_||_yr)rrr:r;r?methodrz)rr?rtrzrs rrzQuantile.__init__s4  dC 6D    rcptjj|||j|jSr~)rrquantiler?rz)rrIqs rr!z Quantile.calls/}}%% qtyy4==&  rct|j|j|j}t |dr+t |jdkDr|jdf|z}t j|jdk(rt j}n$tj|jt}t||S)Nrr&rrr)rr&r?rzhasattrr)rrr'rrrirr)rrIrwrnr's rr.zQuantile.compute_output_specs# GG$))dmm  1g 177|a ! }|;  $ $QWW - 8NN$E&&qww6EBjj Igmm!4 I IA$&HHW$5MBF**$MQT-%8$MM$M BO 8=KW]] 3  9!: I%N A59ZZ$@dV$@$@M$@A sG C+ C0/C5#C?2C:C? D.:C??D+ D! D+*D+N)r1r2r3rr!r.rTrrrrs!@ rrzkeras.ops.unravel_indexzkeras.ops.numpy.unravel_indexct|frt|j|Stjj ||S)aConvert flat indices to coordinate arrays in a given array shape. Args: indices: An integer or array of integers representing flat indices. shape: The shape of the array to unravel into. Returns: Tuple of arrays for each dimension with unraveled indices. Example: >>> indices = 5 >>> shape = (3, 3) >>> unravel_index(indices, shape) (1, 2) # 5 is at row 1, column 2 in a 3x3 array )rrr7rrr)rr&s rrr s;"WJ'E"0099 == & &w 66rceZdZdZdZy)Realc@tjj|Sr)rrrealrHs rr!z Real.call8rrc`t|dd}t|j|j|SrLrOrQs rr.zReal.compute_output_spec;rRrNrSrTrrrr7rrrzkeras.ops.realzkeras.ops.numpy.realct|frtj|Stjj |S)zReturn the real part of the complex argument. Args: x: Input tensor. Returns: The real component of the complex argument. )rrr7rrrrWs rrr@rrceZdZdZdZy) Reciprocalc@tjj|Sr)rr reciprocalrHs rr!zReciprocal.callPs}}''**rc,t|jSrr6rHs rr.zReciprocal.compute_output_specSs177##rNrSrTrrrrOs +$rrzkeras.ops.reciprocalzkeras.ops.numpy.reciprocalct|frtj|Stjj |S)zReturn the reciprocal of the argument, element-wise. Calculates `1/x`. Args: x: Input tensor. Returns: Output tensor, element-wise reciprocal of `x`. )rrr7rrrrWs rrrWs6"QD!|))!,, == # #A &&rc,eZdZdfd ZdZdZxZS)Repeatc>t|||_||_yr)rrr?repeats)rrr?rs rrzRepeat.__init__ns   rcntjj||j|jSr)rrrepeatrr?rHs rr!z Repeat.callss&}}##At||$))#DDrct|j}|j}t|tr|g}t |}|dk(}|j d|vrtdg|jSt tj|}|r ||dzg}n5||k7rtd|d|t tj|g}t||jS||j }|t||jS|}|r||dz||j <nN||k7rtd|j d|d|t tj|||j <t||jS)Nr$rrzYSize of `repeats` and dimensions of `x` after flattening should be compatible. Received: rz*Size of `repeats` and dimensions of `axis z' of x` should be compatible. Received: ) r(r&rr:r;r)r?rr'rrr*sum) rrIrCr repeats_size broadcastx_flatten_sizern size_on_axs rr.zRepeat.compute_output_specvsqww-,, gs #iG7|  A% 99 w"D699 !12N . ;< / !!-eN3CE !$BFF7O 45 |177; ;TYY'  wagg6 6 &071:&=L # < '''+yyk2)N%y:  '*"&&/&:L #t|||_||_yr)rrshiftr?)rrr?rs rrz Roll.__init__s   rcltjj||j|jSr)rrrollrr?rHs rr!z Roll.calls#}}!!!TZZ;;rcDt|j|jSr4rzrHs rr.zRoll.compute_output_specr{rrr0r5s@rrrs <3rrzkeras.ops.rollzkeras.ops.numpy.rollct|frt||j|Stjj |||S)aRoll tensor elements along a given axis. Elements that roll beyond the last position are re-introduced at the first. Args: x: Input tensor. shift: The number of places by which elements are shifted. axis: The axis along which elements are shifted. By default, the array is flattened before shifting, after which the original shape is restored. Returns: Output tensor. r)rrr7rrr)rIrr?s rrrsB QD!E%33A66 ==  aT  22rc,eZdZdfd ZdZdZxZS)Roundc0t|||_yr)rrdecimals)rrrs rrzRound.__init__rrcVtjj||jSr)rrroundrrHs rr!z Round.calls}}""1dmm44rc`t|dd}t|j|j|SrLrOrQs rr.zRound.compute_output_specrRrrr0r5s@rrrs!5Brrzkeras.ops.roundzkeras.ops.numpy.roundct|frt|j|Stjj ||S)zEvenly round to the given number of decimals. Args: x: Input tensor. decimals: Number of decimal places to round to. Defaults to `0`. Returns: Output tensor. )rrr7rrr)rIrs rrrs:QD!X,,Q// ==  q( ++rceZdZddZddZy) SearchSortedctj|}tj|}tjj|||S)Nside)rr]r searchsorted)rsorted_sequencevaluesrs rr!zSearchSorted.calls>!33OD**62}}))/6)MMrct|jdk7r td|jdtjtj j krdnd}t|j|S)Nr$zhsearchsorted only supports 1-D sorted sequences. Usekeras.ops.vectorized_map to extend to N-D sequences.rrrr)r)r&r*riinforror)rrrrout_types rr.z SearchSorted.compute_output_specsp $$ % *G  $$Q'288BHH+=+A+AA   6<&>TYY"OOrcnt|j}||j}t|jt r|Gd||j<t |jDcgc]}t||jc}Stj||jdk7rtd|d|jd||jz}|||j<t |jDcgc]}t||jc}Sdg|j|}tj|}g}t t|D]N} t|} t || | |j<|jt| |jP|Scc}wcc}w)Nrrzw`x` size on given `axis` must be dividible by `indices_or_sections` when `indices_or_sections` is an int. But received rr)r(r&r?r:rr;r<rr'rr r*rjr)r) rrIrCx_size_on_axisrrpr output_sizeoutputsrBrns rr.zSplit.compute_output_specsqww- + d.. 4%%) "#4#;#;< qww7vvnd&>&>?1D ))7(8//03 "T%=%==D!%GDII t778G1773  !L4#;#;L^Lgg12 s;'( EA=L&)+a.&9L # NN;|177C D E3s 'F-<F2rr0r5s@rrrsPrrzkeras.ops.splitzkeras.ops.numpy.splitct|frt||j|Stjj |||S)aSplit a tensor into chunks. Args: x: Input tensor. indices_or_sections: If an integer, N, the tensor will be split into N equal sections along `axis`. If a 1-D array of sorted integers, the entries indicate indices at which the tensor will be split along `axis`. axis: Axis along which to split. Defaults to `0`. Note: A split does not have to result in equal division when using Torch backend. Returns: A list of tensors. r)rrr7rrr)rIrr?s rrr sD&QD!(t4BB1EE ==  q"5D  AArc,eZdZdfd ZdZdZxZS)Stackc0t|||_yrrrs rrzStack.__init__&rrcXtjj||jSr)rrstackr?rs rr!z Stack.call*s }}""2DII"66rc |dj}g}|D]\}t|j|gdstd|jd|d|jt |dt |^t |}t|}|jdk(r||gz}nK|jdk\r|j|j|n|j|jd z|tj|}t|| S) NrTrzIEvery value in `xs` must have the same shape. But found element of shape z5, which is different from the first element's shape rr'r9r$r) r&rCr*rrPrjr)r(r?insertrrir)rrrrrI size_on_axisrnros rr.zStack.compute_output_spec-sekk  CAqww "N (()y1--8M<  $ $WQa%A B C2w K( 99?'<.8L YY!^    < 8    A | <))+<= <|<QD!$--a00 ==  qt  ,,rc,eZdZdfd ZdZdZxZS)Stdc~t|t|tr|g|_||_y||_||_yrryr{s rrz Std.__init__Yr|rcntjj||j|jSr~)rrstdr?rzrHs rr!zStd.calla&}}  T]] KKrctj|j}d|vs|dk(rtj}t t |j |j|j|S)Nr;rrr) rrr'rrrr&r?rzrrIros rr.zStd.compute_output_specdsY009 L LF$:">>+L tyy4== I  rrr0r5s@rr r Xs!L rr z keras.ops.stdzkeras.ops.numpy.stdct|frt||j|Stjj |||S)aCompute the standard deviation along the specified axis. Args: x: Input tensor. axis: Axis along which to compute standard deviation. Default is to compute the standard deviation of the flattened tensor. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Returns: Output tensor containing the standard deviation values. r)rr r7rrr rs rr r nsBQD!x0>>qAA ==  QTH  ==rc*eZdZfdZdZdZxZS)Swapaxesc>t|||_||_yr)rrr,r-)rr,r-rs rrzSwapaxes.__init__s   rcltjj||j|jSr)rrswapaxesr,r-rHs rr!z Swapaxes.calls#}}%%aTZZ@@rct|j}||j}||j||j<|||j<t ||j Sr4)r(r&r,r-rr')rrIrCrs rr.zSwapaxes.compute_output_specsSqww-djj!%djj1 ! 7!''22rr0r5s@rrrs A3rrzkeras.ops.swapaxeszkeras.ops.numpy.swapaxesct|frt||j|Stjj |||S)zInterchange two axes of a tensor. Args: x: Input tensor. axis1: First axis. axis2: Second axis. Returns: A tensor with the axes swapped. )r,r-)rrr7rrr)rIr,r-s rrrsBQD!u%33A66 == ! !!5 ! >>rc,eZdZdfd ZdZdZxZS)Takec0t|||_yrrrs rrz Take.__init__rrcZtjj|||jSr)rrtaker?rrIrs rr!z Take.calls"}}!!!W499!==rct|j}t|tr"t|j}|j}n+tt t j|dg}d}|jt||jS|jdkrt||jzn |j}|d||z||dzdz}t||j|S)Nr&Frrr$)r'ragged) r(r&r:rrrPrr r?r'r))rrIrrCrrr?rns rr.zTake.compute_output_specsqww- g{ + /M^^F '):GR!HIMF 99 }AGG< <,099q=s7|dii'diiu~ 5q 8KK Grrzkeras.ops.takezkeras.ops.numpy.takect||frt|j||Stjj |||S)a5Take elements from a tensor along an axis. Args: x: Source tensor. indices: The indices of the values to extract. axis: The axis over which to select values. By default, the flattened input tensor is used. Returns: The corresponding tensor of values. r)rrr7rrrrIrr?s rrrsCQL),,Q88 ==  at  44rc,eZdZdfd ZdZdZxZS) TakeAlongAxisc0t|||_yrrrs rrzTakeAlongAxis.__init__rrcZtjj|||jSr)rrtake_along_axisr?rs rr!zTakeAlongAxis.calls"}},,Qdii,HHrctj|j|j|j}t ||j Sr4)r $compute_take_along_axis_output_shaper&r?rr')rrIrrns rr.z!TakeAlongAxis.compute_output_specs8&KK GGW]]DII >rc btt|dg}tt|dg}tjt|dt |t|dt |}t |j ts|j dDcgc]}|| }}|j dDcgc]}|| }}t||dstd|d|d |j dD]}d ||< |j dD]}d ||< ttd j|}ttd j|}||z} t| | S|j dkr||z} n |d|j ||j dz} t| | Scc}wcc}w) Nr&r'rr$TrAz#h.L#Ltyyj1HTYY[4IIL)rcrdrs rr>r>]D"RH%d#11"b99 == " "2r " 55rc*eZdZfdZdZdZxZS)Tilec0t|||_yr)rrr)rrrs rrz Tile.__init__ts  rcVtjj||jSr)rrtilerrHs rr!z Tile.callxs}}!!!T\\22rct|j}|j}t|tr|g}t |t |kDrdgt |t |z z|z}ndgt |t |z z|z}g}t ||D]-\}}||jd|j||z/t||jS)Nr$r) r(r&rr:r;r)rrrr')rrIrCrrnx_sizers rr.zTile.compute_output_spec{sqww-,, gs #iG w<#g, &cS\CL89GCGcS\CL89GCG !'73 5NFF~##D)##FVO4  5  d`, `repeats` is promoted to `x.ndim` by prepending 1's to it. Args: x: Input tensor. repeats: The number of repetitions of `x` along each axis. Returns: The tiled output tensor. )rrGr7rrrJ)rIrs rrJrJsA&QD!  -   ==  a ))rc,eZdZdfd ZdZdZxZS)TracecLt|||_||_||_yrrTrVs rrzTrace.__init__rWrctjj||j|j|j SrY)rrtracerUr,r-rHs rr!z Trace.calls3}}"" dkk4::#  rc2t|j}d||j<d||j<tt dj |}t j|j}|dvrtj|d}t||S)Nr9)rrnuint64rr) r(r&r,r-r]r^rrr'rrir)rrIrCrnros rr.zTrace.compute_output_specs|qww-    FB;;89 009 < <!--lGDL<|< 0` is above. The default is 0. dtype: Data type of the returned tensor. The default is "float32". Returns: Tensor with its lower triangle filled with ones and zeros elsewhere. `T[i, j] == 1` for `j <= i + k`, 0 otherwise. r_rr')rrr`r]s rr`r`s" ==  Q!q  66rc,eZdZdfd ZdZdZxZS)Trilc0t|||_yrr8r9s rrz Tril.__init__r:rcXtjj||jSr<)rrtrilrrHs rr!z Tril.callr?rcDt|j|jSr4rzrHs rr.zTril.compute_output_spec r{rrr0r5s@rriri/3rrizkeras.ops.trilzkeras.ops.numpy.trilct|frt|j|Stjj ||S)aReturn lower triangle of a tensor. For tensors with `ndim` exceeding 2, `tril` will apply to the final two axes. Args: x: Input tensor. k: Diagonal above which to zero elements. Defaults to `0`. the main diagonal. `k < 0` is below it, and `k > 0` is above it. Returns: Lower triangle of `x`, of same shape and data type as `x`. r=)rrir7rrrlrGs rrlrl=QD!ay&&q)) ==  a1  %%rc,eZdZdfd ZdZdZxZS)Triuc0t|||_yrr8r9s rrz Triu.__init__#r:rcXtjj||jSr<)rrtriurrHs rr!z Triu.call'r?rcDt|j|jSr4rzrHs rr.zTriu.compute_output_spec*r{rrr0r5s@rrrrr"rnrrrzkeras.ops.triuzkeras.ops.numpy.triuct|frt|j|Stjj ||S)aReturn upper triangle of a tensor. For tensors with `ndim` exceeding 2, `triu` will apply to the final two axes. Args: x: Input tensor. k: Diagonal below which to zero elements. Defaults to `0`. the main diagonal. `k < 0` is below it, and `k > 0` is above it. Returns: Upper triangle of `x`, of same shape and data type as `x`. r=)rrrr7rrrurGs rruru.rprc*eZdZfdZdZdZxZS)Truncc"t|yrrdres rrzTrunc.__init__Crfrc@tjj|Sr)rrtruncrHs rr!z Trunc.callFrrcDt|j|jSr4rzrHs rr.zTrunc.compute_output_specIr{rr0r5s@rryryBs&3rryzkeras.ops.trunczkeras.ops.numpy.truncct|frtj|Stjj |S)aReturn the truncated value of the input, element-wise. The truncated value of the scalar `x` is the nearest integer `i` which is closer to zero than `x` is. In short, the fractional part of the signed number `x` is discarded. Args: x: Input tensor. Returns: The truncated value of each element in `x`. Example: >>> x = ops.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) >>> ops.trunc(x) array([-1.0, -1.0, -0.0, 0.0, 1.0, 1.0, 2.0]) )rryr7rrr|rWs rr|r|Ms6&QD!w$$Q'' ==  q !!rceZdZdZdZy)VdotcBtjj||Sr)rrvdotrbs rr!z Vdot.callfrjrc tjt|dt|t|dt|}t g|SNr'rrrirPrjrrrcrdr's rr.zVdot.compute_output_speciA"" Bb * Bb * 2U++rNrSrTrrrres *,rrzkeras.ops.vdotzkeras.ops.numpy.vdotct||frtj||Stjj ||S)aReturn the dot product of two vectors. If the first argument is complex, the complex conjugate of the first argument is used for the calculation of the dot product. Multidimensional tensors are flattened before the dot product is taken. Args: x1: First input tensor. If complex, its complex conjugate is taken before calculation of the dot product. x2: Second input tensor. Returns: Output tensor. )rrr7rrrrus rrrqs<"RH%v##B++ ==  b" %%rceZdZdZdZy)InnercBtjj||Sr)rrinnerrbs rr!z Inner.callrrc tjt|dt|t|dt|}t g|Srrrs rr.zInner.compute_output_specrrNrSrTrrrrs +,rrzkeras.ops.innerzkeras.ops.numpy.innerct||frtj||Stjj ||S)aReturn the inner product of two tensors. Ordinary inner product of vectors for 1-D tensors (without complex conjugation), in higher dimensions a sum product over the last axes. Multidimensional arrays are treated as vectors by flattening all but their last axes. The resulting dot product is performed over their last axes. Args: x1: First input tensor. x2: Second input tensor. The last dimension of `x1` and `x2` must match. Returns: Output tensor. The shape of the output is determined by broadcasting the shapes of `x1` and `x2` after removing their last axes. )rrr7rrrrus rrrs<,RH%w$$R,, ==  r2 &&rzkeras.ops.vectorizezkeras.ops.numpy.vectorizeexcluded signaturecxt|std|tjj |||S)a*Turn a function into a vectorized function. Example: ```python def myfunc(a, b): return a + b vfunc = keras.ops.vectorize(myfunc) y = vfunc([1, 2, 3, 4], 2) # Returns Tensor([3, 4, 5, 6]) ``` Args: pyfunc: Callable of a single tensor argument. excluded: Optional set of integers representing positional arguments for which the function will not be vectorized. These will be passed directly to `pyfunc` unmodified. signature: Optional generalized universal function signature, e.g., `"(m,n),(n)->(m)"` for vectorized matrix-vector multiplication. If provided, `pyfunc` will be called with (and expected to return) arrays with shapes given by the size of corresponding core dimensions. By default, `pyfunc` is assumed to take scalars tensors as input and output. Returns: A new function that applies `pyfunc` to every element of its input along axis 0 (the batch axis). z>Expected argument `pyfunc` to be a callable. Received: pyfunc=r)callabler*rr vectorize)pyfuncrrs rrrsN@ F  &x )   == " "Y # rceZdZdZdZy)Vstackc@tjj|Sr)rrvstackrs rr!z Vstack.callr4rc |dj}d}g}|D]}t|j|dgdstd|jd|d||jdd}n||jdz }|jt |dt |t |}||d<tj|}t||S)NrTrrrrr'r6)rrrrrrIrnros rr.zVstack.compute_output_specsekk  CAqww 1#$O BBC''K(M, ")QWWQZ-?%)""aggaj0"  $ $WQa%A B CK( , Q))+<= <66rNrSrTrrrrs (7rrzkeras.ops.vstackzkeras.ops.numpy.vstackct|frtj|Stjj |S)zStack tensors in sequence vertically (row wise). Args: xs: Sequence of tensors. Returns: Tensor formed by stacking the given tensors. )rrr7rrrr8s rrrs6RE"x%%b)) ==   ##rceZdZddZdZy)WhereNcDtjj|||Sr)rrwhere)r conditionrcrds rr!z Where.calls}}""9b"55rc &t|dg}t|dg}t|dg}t||}t||}tjt|d| t |ndt|d| t |nd}t ||S)Nr&r'r;rrh) rrrcrdcondition_shaperlrmrnros rr.zWhere.compute_output_specs!)Wb92w+2w+'B ' h? )) BR^b G BR^b G <|<bj 3  YB/0w$$YB77 ==  y"b 11rceZdZdZdZy)SubtractcBtjj||Sr)rrsubtractrbs rr!z Subtract.call+}}%%b"--rc &t|dg}t|dg}t||}t|dd}t|dd}|xr|}tjt|dt |t|dt |} t || |S)Nr&rMFr'rNrh rrcrdrlrmrnrprqrrr's rr.zSubtract.compute_output_spec.s2w+2w+'(; B%0 B%0 !/i "" Bb * Bb * Q&$.qc2$$  EIIq%a[)9:IDID$/ #N #{!''&I IJsCrr0r5s@rrrLs8Jrrzkeras.ops.squeezezkeras.ops.numpy.squeezect|frt|j|Stjj ||S)aRemove axes of length one from `x`. Args: x: Input tensor. axis: Select a subset of the entries of length one in the shape. Returns: The input tensor with all or a subset of the dimensions of length 1 removed. r)rrr7rrrr0s rrrhs>QD!D!//22 ==  ..rc,eZdZdfd ZdZdZxZS) Transposec0t|||_yrr9r:s rrzTranspose.__init__zrrcXtjj||jSr<)rr transposerrHs rr!zTranspose.call~s }}&&qtyy&99rctj|j|j}t |dd}t ||j |SrL)r compute_transpose_output_shaper&rrPrr'rs rr.zTranspose.compute_output_specsB&EE GGTYY He,QD!d#11!44 == " "14 " 00rc,eZdZdfd ZdZdZxZS)Meancdt|t|tr|g}||_||_yrryr{s rrz Mean.__init__rrcntjj||j|jSr~)rrmeanr?rzrHs rr!z Mean.callrrc&tj|j}tj|jd}d|vs|dk(r|}n|}t |dd}t t|j|j|j||S)Nfloat32r;rrMFrrN) rrr'rrirPrrr&r?rz)rrI ori_dtype compute_dtype result_dtyperMs rr.zMean.compute_output_specs~--agg6 **177I> I f!4(L$LHe, tyy4== I  rrr0r5s@rrrs!M  rrzkeras.ops.meanzkeras.ops.numpy.meanct|frt||j|Stjj |||S)aCompute the arithmetic mean along the specified axes. Args: x: Input tensor. axis: Axis or axes along which the means are computed. The default is to compute the mean of the flattened tensor. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Returns: Output tensor containing the mean values. r)rrr7rrrrs rrrsBQD!1??BB ==  adX  >>rc,eZdZdfd ZdZdZxZS)Varcdt|t|tr|g}||_||_yrryr{s rrz Var.__init__rrcntjj||j|jSr~)rrvarr?rzrHs rr!zVar.callr rc tjt|dt|t}t t |j|j|j|S)Nr'rr) rrirPrjrrrr&r?rzrs rr.zVar.compute_output_specsI**71gtAw+GO  tyy4== I  rrr0r5s@rrrs!L rrz keras.ops.varzkeras.ops.numpy.varct|frt||j|Stjj |||S)aCompute the variance along the specified axes. Args: x: Input tensor. axis: Axis or axes along which the variance is computed. The default is to compute the variance of the flattened tensor. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Returns: Output tensor containing the variance. r)rrr7rrrrs rrrBQD!x0>>qAA ==  QTH  ==rc,eZdZdfd ZdZdZxZS)Sumcdt|t|tr|g}||_||_yrryr{s rrz Sum.__init__rrcntjj||j|jSr~)rrrr?rzrHs rr!zSum.callr rcFtjt|dtj}|dvrd}n|dvrd}tjdk(r|dk(rd}t|dd}t t |j|j|j || S) Nr')rrrjrrkrnrorMFrrN) rrirPrrrrr&r?rzrs rr.zSum.compute_output_specs""71gw~~7G#HI - -E ) )E ??  'EX,=EHe, tyy4== I  rrr0r5s@rrrs!L rrz keras.ops.sumzkeras.ops.numpy.sumct|frt||j|Stjj |||S)aSum of a tensor over the given axes. Args: x: Input tensor. axis: Axis or axes along which the sum is computed. The default is to compute the sum of the flattened tensor. keepdims: If this is set to `True`, the axes which are reduced are left in the result as dimensions with size one. Returns: Output tensor containing the sum. r)rrr7rrrrs rrr rrceZdZddZddZy)ZerosNcDtjj||Sr4rrzerosrs rr!z Zeros.callrrcL|xstj}t||Sr4rrs rr.zZeros.compute_output_spec!rrrrSrTrrr r rrr zkeras.ops.zeroszkeras.ops.numpy.zeroscDtjj||S)zReturn a new tensor of given shape and type, filled with zeros. Args: shape: Shape of the new tensor. dtype: Desired data type of the tensor. Returns: Tensor of zeros with the given shape and dtype. rr r%s rr r &rrceZdZddZddZy)OnesNcDtjj||Sr4rronesrs rr!z Ones.call5s}}!!%u!55rcL|xstj}t||Sr4rrs rr.zOnes.compute_output_spec8rrrrSrTrrrr4s 6/rrzkeras.ops.oneszkeras.ops.numpy.onescDtjj||S)zReturn a new tensor of given shape and type, filled with ones. Args: shape: Shape of the new tensor. dtype: Desired data type of the tensor. Returns: Tensor of ones with the given shape and dtype. rrr%s rrr=s ==  e5  11rc0eZdZdfd ZddZddZxZS)Eyecjt|||_|xstj|_yrrYrZs rrz Eye.__init__Lr[rcptjj|||j|jS)Nrg)rreyerr'ras rr!zEye.callQs(}}  a466 DDrc<||}t||f|jSr4rcras rr.zEye.compute_output_specTrdrrerr0r5s@rrrKs/ E5rrz keras.ops.eyezkeras.ops.numpy.eyecHtjj||||S)aReturn a 2-D tensor with ones on the diagonal and zeros elsewhere. Args: N: Number of rows in the output. M: Number of columns in the output. If `None`, defaults to `N`. k: Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal. dtype: Data type of the returned tensor. Returns: Tensor with ones on the k-th diagonal and zeros elsewhere. rg)rrrr]s rrrZs" ==  Q!q  66rceZdZdZdZy) FloorDividecBtjj||Sr)rr floor_dividerbs rr!zFloorDivide.callms}}))"b11rc t|dg}t|dg}t||}tjt|dt |t|dt |}t ||Srrhrs rr.zFloorDivide.compute_output_specpsi2w+2w+'(; )) Bb * Bb * <|<r? first_elements rr.zSelect.compute_output_specs$"1 =..m6I6IJJrrr0r5s@rr9r9sCKrr9zkeras.ops.selectzkeras.ops.numpy.selectct|ttfrt|ttfs#tdt |dt |t|}t|}|r|std|d|t ||z|gzrt j|||Stjj|||S)a]Return elements from `choicelist`, based on conditions in `condlist`. Args: condlist: List of boolean tensors. The list of conditions which determine from which array in choicelist the output elements are taken. When multiple conditions are satisfied, the first one encountered in condlist is used. choicelist: List of tensors. The list of tensors from which the output elements are taken. This list has to be of the same length as `condlist`. defaults: Optional scalar value. The element inserted in the output when all conditions evaluate to `False`. Returns: Tensor where the output at position `m` is the `m`-th element of the tensor in `choicelist` where the `m`-th element of the corresponding tensor in `condlist` is `True`. Example: ```python from keras import ops x = ops.arange(6) condlist = [x<3, x>3] choicelist = [x, x**2] ops.select(condlist, choicelist, 42) # Returns: tensor([0, 1, 2, 42, 16, 25]) ``` zBcondlist and choicelist must be lists. Received: type(condlist) = z, type(choicelist) = z@condlist and choicelist must not be empty. Received: condlist = z, choicelist = ) r:r(rr*rjrr9r7rrr<)r=r>r?s rr<r<sD hu .jT5M7 $X/0""&z"2!3 5  H~Hj!J : "$&< )  Hz1WI=>x%%h GDD ==  *g >>rc*eZdZfdZdZdZxZS)Slogdetc"t|yrrdres rrzSlogdet.__init__-rfrc@tjj|Sr)rrslogdetrHs rr!z Slogdet.call0rrctd|j}t|jdd|j}||fS)NrTrr)rr'r&)rrIr logabsdets rr.zSlogdet.compute_output_spec3s72QWW- AGG< i  rr0r5s@rrDrD,s(!rrDzkeras.ops.slogdetzkeras.ops.numpy.slogdetct|frtj|Stjj |S)aCompute the sign and natural logarithm of the determinant of a matrix. Args: x: Input matrix. It must 2D and square. Returns: A tuple `(sign, logabsdet)`. `sign` is a number representing the sign of the determinant. For a real matrix, this is 1, 0, or -1. For a complex matrix, this is a complex number with absolute value 1 (i.e., it is on the unit circle), or else 0. `logabsdet` is the natural log of the absolute value of the determinant. )rrDr7rrrGrWs rrGrG9s6QD!y&&q)) ==  ##rc,eZdZdfd ZdZdZxZS) Argpartitionczt|t|tst d|||_||_y)Nz'kth must be an integer. Received:kth = )rrr:r;r*kthr?)rrNr?rs rrzArgpartition.__init__Ms9 #s#FseLM M rcntjj||j|jS)N)rNr?)rr argpartitionrNr?rHs rr!zArgpartition.callTs&}}))! )JJrc0t|jdSr-r6rHs rr.z Argpartition.compute_output_specWs177'22rr.r0r5s@rrLrLLsK3rrLzkeras.ops.argpartitionzkeras.ops.numpy.argpartitionct|frt||j|Stjj |||S)aEPerforms an indirect partition along the given axis. It returns an array of indices of the same shape as `x` that index data along the given axis in partitioned order. Args: a: Array to sort. kth: Element index to partition by. The k-th element will be in its final sorted position and all smaller elements will be moved before it and all larger elements behind it. The order of all elements in the partitions is undefined. If provided with a sequence of k-th it will partition all of them into their sorted position at once. axis: Axis along which to sort. The default is -1 (the last axis). If `None`, the flattened array is used. Returns: Array of indices that partition `x` along the specified `axis`. )rrLr7rrrP)rIrNr?s rrPrP[s?,QD!C&44Q77 == % %ad 33rc,eZdZdfd ZdZdZxZS) Histogramct|t|ts t d|dkr t d|r?t |dkst|ts t d|d|dkr t d||_||_ y)Nzbins must be of type `int`rz'`bins` should be a non-negative integerr#z%range must be a tuple of two elementsr$z:The second element of range must be greater than the first) rrr:r; TypeErrorr*r)rrwr<)rrwr<rs rrzHistogram.__init__ws $$89 9 !8FG G 5zA~Zu%= !HIIQx%(" P  rctj|}t|jdkDr t dtj j ||j|jS)Nr$z"Input tensor must be 1-dimensionalrwr<) rr]r)r&r*math histogramrwr<rHs rr!zHistogram.callsR  % %a ( qww  rrNr0r5s@rrTrTvs(K  rrTzkeras.ops.histogramzkeras.ops.numpy.histogramct|tstd||dkrtd||rEt |dkst|t std||d|dkrtd|t |frt||j|Stj|}t |jdkDrtd |jtjj|||S) a+Computes a histogram of the data tensor `x`. Args: x: Input tensor. bins: An integer representing the number of histogram bins. Defaults to 10. range: A tuple representing the lower and upper range of the bins. If not specified, it will use the min and max of `x`. Returns: A tuple containing: - A tensor representing the counts of elements in each bin. - A tensor representing the bin edges. Example: ``` >>> input_tensor = np.random.rand(8) >>> keras.ops.histogram(input_tensor) (array([1, 1, 1, 0, 0, 1, 2, 1, 0, 1], dtype=int32), array([0.0189519 , 0.10294958, 0.18694726, 0.27094494, 0.35494262, 0.43894029, 0.52293797, 0.60693565, 0.69093333, 0.77493101, 0.85892869])) ``` z6Argument `bins` must be of type `int`. Received: bins=rzAArgument `bins` should be a non-negative integer. Received: bins=r#zBArgument `range` must be a tuple of two elements. Received: range=r$zNThe second element of `range` must be greater than the first. Received: range=rXz:Input tensor must be 1-dimensional. Received: input.shape=)r:r;rVr*r)rrrTr7rr]r&rrZ)rIrwr<s rrZrZs/6 dC DTF K   ax "V %   u:>E5!9##('+  8eAh ##('+  QD!d%0>>qAA!!!$A 177|a %%&WWI /   == " "14u " ==rr/)NTrrrr.r+r_rrrarqrO)rwTFNr)rwTrNrrr&)raNrzrrC)NrNr6r\(crnrrr keras.srcrkeras.src.api_exportrkeras.src.backendrrkeras.src.backend.commonr&keras.src.backend.common.backend_utilsr r keras.src.opsr keras.src.ops.operationr keras.src.ops.operation_utilsr rrrrCrErGrYr]r_rarwrrrrrrrrrrrrrrrrrrrrrrrrrr r rrr r#r'r*r2r r:r?rGrIrPrRrVr[rbrhrurxrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrr%r/r2r6r>rIrLrRr[rerjrtrvr|r~rrrrrrrrrrrrrrrrrrrrrrr r!r#r%r*r,r1r3r:r=rBrDrHrJrRrTrZr\rarcrgrirnrprvr~rrrrrrrrrrrrrrrrrrrrrrorrBrrrrrrrrAr r rrrr$r)r+r/r1r5r7r;r=rBrDrHrJrPr_rerrrrvr~rrrrrrrrrrrrrrrrrrrrrrrrrrrprrrrrrr r rrrrr#r&r+r-r1r3r7r>rGrJrOrRrWr`rirlrrruryr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrr r$r&r*r-r9r<rDrGrLrPrTrZrTrrrfs -)2+DC)-:6AIA: "9:;$6<$6N7tByB#%?@A%B%, (  5678  ) ( 567%8%> ) 6 567!>8!>H ) 6 1I 1 "9:;"<"* 567!>8!>H 9 ,!789!?:!?H 9 $!789!?:!?H6Y6D!#;<= &3>&3R6Y6&!#;<=-E>-E` 1Y 1!#;<=#>#, 1i 1"$=>?$@$& @Y @!#;<=#>#( @i @"$=>?$@$& @Y @!#;<=#>#(7i7$"$=>?()@()V @i @"$=>? $@ $ Y &!#;<=A>A> Y &!#;<=A>A> 3i 3"$=>?"/@"/J1I1 "9:;/</,*i*Z"$=>?6@@6@r?$@$, y >#%?@A+B+\ 1 1&(EFG+H+&3I3)+KLM+N+$33&(EFG(H($ 1 1%'CDE*F*& 1 1&(EFG+H+& 1y 1#%IJ22& 1 1%'CDE*F*& 1 1$&KL33& 1 1&(EFG+H+&? .@ .7Y7.!#;<= -> -"89"8J!789#&:#&L"8y"8J#%?@A*B*$'8y'8T#%?@A:B:z191"!789#:#D By B#%?@A+B+,% )% P 567%8%8p6Yp6f!#;<=U7>U7p/I/ "9:; 3< 37I7 "9:; '< '1)1 567  8  191!789 !: !GG*% .  .$ @I @ "9:; "< " 39 3!789,:,$ @I @ "9:; "< " /9/!789 >: >1y1$&ABC ?D ? F? )@ )797!' /  /6Y66!#;<=$>$"0y0#%?@A 2B 2 B9B!789 !: ! 7i 7"$=>?@@@$2y2#%?@A%B%$2I2 "9:; "< "2I2 "9:; "< "797!789 &: &7 7$ ,  ,16y16h#%?@AHI+B+\ 1) 1 567  8   1I 1 "9:; "< " @I @ "9:; "< " 19 1!789 !: ! 6 6 $&ABC+D+$77% -  -"22% (  ( 7 7$ ,  ,",6y,6^#%?@A$B$NLYL,!#;<=(>(0 ) , 567O8O* i ("$=>? )@ )6Y6,!#;<=A>A& y D#%?@A!9B!9H ) , 567O8O* i ("$=>? )@ )=)=" 567 %8 %)8y)8X#%?@AMBM& 3y 3 $ N  N&+9+!789 !: ! i "$=>? $@ $7y7$&ABC +D +1y1$&ABC 3D 31 1$ 4  4=I=. "9:;'<'*:8):8z 567 I8 IF# 9# L!789L:L(6y68#%?@A#B#L 8I 8 "9:; "< "  9 8(*IJK7L7,B9B!789 !: !$$$ '  ' 18Y18h!#;<=7>7" Gi G "$=>?.@." 39 3!7893:3( BI B "9:; ,< ,999('()J*J,B9B!789 !: !AiA"$=>?$@$" @) @ 567  8   @9 @!789 !: !.9.!789 !: ! -9 -!789 ,: , *I*Z "9:;B<B.=I=@ "9:;-<-$ ) , 567>8>&3y3$#%?@A ?B ? G9G2!7895:5" 8I 8#) @  @" @) @ 567  8   @9 @!789 !: !*6 *6Z$&ABC6D6*8986!789*:*2=I=. "9:;K<K@ 5) 5 567787$ 39 3!789&:&& 39 3!789&:&&3I3 "9:;"<". ,9 ,!789&:&* ,I , "9:;'<'4$&ABC"&$&D&R7Y76!#;<= $> $=I=" "9:;2<2,LyL$#%?@A *B *LyL$#%?@A *B * Y *!#;<=(>(" ) *(*IJK /L /  *% -  - =I = "9:; '< 'ByB#%?@A %B % @Y @!#;<= #> # @9 @!789 !: !JiJ8"$=>? /@ / G G $&ABC 1D 1  9 4!789?:?$ ) & 567>8>$ ) : 567>8>$/I/ "9:; 3< 3/9/!789 2: 2 5) 5 567787" =) =')GHI .J .77&(EFG -H -*= *=Z$&ABC6D6* KY K!#;<=3?>3?l !i !"$=>?$@$$ 39 3')GHI4J44  D$&ABC:>D:>r