NumPy ops

[source]

abs function

keras.ops.abs(x)

Shorthand forkeras.ops.absolute.

[source]

absolute function

keras.ops.absolute(x)

Compute the absolute value element-wise.

keras.ops.abs is a shorthand for this function.

Arguments

• x: Input tensor.

Returns

An array containing the absolute value of each element inx.

Example

>>>x=keras.ops.convert_to_tensor([-1.2,1.2])>>>keras.ops.absolute(x)array([1.2,1.2],dtype=float32)

[source]

add function

keras.ops.add(x1,x2)

Add arguments element-wise.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

The tensor containing the element-wise sum ofx1 andx2.

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([[1010][1012]],shape=(2,2),dtype=int32)

[source]

all function

keras.ops.all(x,axis=None,keepdims=False)

Test whether all array elements along a given axis evaluate toTrue.

Arguments

• 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: IfTrue, 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 toFalse.

Returns

The tensor containing the logical AND reduction over theaxis.

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([TrueFalse],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)

[source]

amax function

keras.ops.amax(x,axis=None,keepdims=False)

Returns the maximum of an array or maximum value along an axis.

Arguments

• 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: IfTrue, axes which are reduced are left in the result as dimensions that are broadcast to the size of the original input tensor. Defaults toFalse.

Returns

An array with the maximum value. Ifaxis=None, the result is a scalarvalue representing the maximum element in the entire array. Ifaxis isgiven, the result is an array with the maximum values alongthe 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)

[source]

amin function

keras.ops.amin(x,axis=None,keepdims=False)

Returns the minimum of an array or minimum value along an axis.

Arguments

• 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: IfTrue, axes which are reduced are left in the result as dimensions that are broadcast to the size of the original input tensor. Defaults toFalse.

Returns

An array with the minimum value. Ifaxis=None, the result is a scalarvalue representing the minimum element in the entire array. Ifaxis isgiven, the result is an array with the minimum values alongthe 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)

[source]

angle function

keras.ops.angle(x)

Element-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)

[source]

any function

keras.ops.any(x,axis=None,keepdims=False)

Test whether any array element along a given axis evaluates toTrue.

Arguments

• 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: IfTrue, 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 toFalse.

Returns

The tensor containing the logical OR reduction over theaxis.

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([TrueTrue],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)

[source]

append function

keras.ops.append(x1,x2,axis=None)

Append tensorx2 to the end of tensorx1.

Arguments

• x1: First input tensor.
• x2: Second input tensor.
• axis: Axis along which tensorx2 is appended to tensorx1. IfNone, both tensors are flattened before use.

Returns

A tensor with the values ofx2 appended tox1.

Examples

>>>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)

Whenaxis is specified,x1 andx2 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(mostrecentcalllast):...TypeError:Cannotconcatenatearrayswithdifferentnumbersofdimensions:got(2,3),(3,).

[source]

arange function

keras.ops.arange(start,stop=None,step=None,dtype=None)

Return evenly spaced values within a given interval.

arange can be called with a varying number of positional arguments:*arange(stop): Values are generated within the half-open interval[0, stop) (in other words, the interval including start but excluding stop).*arange(start, stop): Values are generated within the half-open interval[start, stop).*arange(start, stop, step): Values are generated within the half-open interval[start, stop), with spacing between values given by step.

Arguments

• start: Integer or real, representing the start of the interval. The interval includes this value.
• stop: Integer or real, representing the end of the interval. The interval does not include this value, except in some cases wherestep is not an integer and floating point round-off affects the length ofout. Defaults toNone.
• step: Integer or real, represent the spacing between values. For any outputout, this is the distance between two adjacent values,out[i+1] - out[i]. The default step size is 1. Ifstep is specified as a position argument,start must also be given.
• dtype: The type of the output array. Ifdtype is not given, infer the data type from the other input arguments.

Returns

Tensor of evenly spaced values.For floating point arguments, the length of the result isceil((stop - start)/step). Because of floating point overflow, thisrule may result in the last element of out being greater than stop.

Examples

>>>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)

[source]

arccos function

keras.ops.arccos(x)

Trigonometric inverse cosine, element-wise.

The inverse ofcos so that, ify = cos(x), thenx = arccos(y).

Arguments

• x: Input tensor.

Returns

Tensor of the angle of the ray intersecting the unit circle at the givenx-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)

[source]

arccosh function

keras.ops.arccosh(x)

Inverse 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)

[source]

arcsin function

keras.ops.arcsin(x)

Inverse sine, element-wise.

Arguments

• x: Input tensor.

Returns

Tensor of the inverse sine of each element inx, in radians and inthe 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)

[source]

arcsinh function

keras.ops.arcsinh(x)

Inverse hyperbolic sine, element-wise.

Arguments

• x: Input tensor.

Returns

Output tensor of same shape asx.

Example

>>>x=keras.ops.convert_to_tensor([1,-1,0])>>>keras.ops.arcsinh(x)array([0.88137364,-0.88137364,0.0],dtype=float32)

[source]

arctan function

keras.ops.arctan(x)

Trigonometric inverse tangent, element-wise.

Arguments

• x: Input tensor.

Returns

Tensor of the inverse tangent of each element inx, 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)

[source]

arctan2 function

keras.ops.arctan2(x1,x2)

Element-wise arc tangent ofx1/x2 choosing the quadrant correctly.

The quadrant (i.e., branch) is chosen so thatarctan2(x1, x2) is thesigned angle in radians between the ray ending at the origin and passingthrough the point(1, 0), and the ray ending at the origin and passingthrough the point(x2, x1). (Note the role reversal: the "y-coordinate"is the first function parameter, the "x-coordinate" is the second.) By IEEEconvention, this function is defined forx2 = +/-0 and for either or bothofx1 andx2= +/-inf.

Arguments

• 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.piarray([-135.,-45.,45.,135.],dtype=float32)

Note the order of the parameters.arctan2 is defined also when x2=0 andat 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)

[source]

arctanh function

keras.ops.arctanh(x)

Inverse hyperbolic tangent, element-wise.

Arguments

• x: Input tensor.

Returns

Output tensor of same shape asx.

[source]

argmax function

keras.ops.argmax(x,axis=None,keepdims=False)

Returns the indices of the maximum values along an axis.

Arguments

• x: Input tensor.
• axis: By default, the index is into the flattened tensor, otherwise along the specified axis.
• keepdims: If this is set toTrue, the axes which are reduced are left in the result as dimensions with size one. Defaults toFalse.

Returns

Tensor of indices. It has the same shape asx, with the dimensionalongaxis removed.

Example

>>>x=keras.ops.arange(6).reshape(2,3)+10>>>xarray([[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)

[source]

argmin function

keras.ops.argmin(x,axis=None,keepdims=False)

Returns the indices of the minimum values along an axis.

Arguments

• x: Input tensor.
• axis: By default, the index is into the flattened tensor, otherwise along the specified axis.
• keepdims: If this is set toTrue, the axes which are reduced are left in the result as dimensions with size one. Defaults toFalse.

Returns

Tensor of indices. It has the same shape asx, with the dimensionalongaxis removed.

Example

>>>x=keras.ops.arange(6).reshape(2,3)+10>>>xarray([[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)

[source]

argpartition function

keras.ops.argpartition(x,kth,axis=-1)

Performs an indirect partition along the given axis.

It returns an arrayof indices of the same shape asx that index data along the given axisin partitioned order.

Arguments

• 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). IfNone, the flattened array is used.

Returns

Array of indices that partitionx along the specifiedaxis.

[source]

argsort function

keras.ops.argsort(x,axis=-1)

Returns the indices that would sort a tensor.

Arguments

• x: Input tensor.
• axis: Axis along which to sort. Defaults to-1 (the last axis). IfNone, the flattened tensor is used.

Returns

Tensor of indices that sortx along the specifiedaxis.

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]])>>>xarray([[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)

[source]

array function

keras.ops.array(x,dtype=None)

Create a tensor.

Arguments

• 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)

[source]

average function

keras.ops.average(x,axis=None,weights=None)

Compute the weighted average along the specified axis.

Arguments

• x: Input tensor.
• axis: Integer along which to averagex. 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 inx. Each value inx 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 asx. Ifweights=None (default), then all data inx 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 thatsum(weights) must not be 0.

Returns

Return the average along the specified axis.

Examples

>>>data=keras.ops.arange(1,5)>>>dataarray([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))>>>dataarray([[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(mostrecentcalllast):...ValueError:Axismustbespecifiedwhenshapesofaandweightsdiffer.

[source]

bartlett function

keras.ops.bartlett(x)

Bartlett window function.The Bartlett window is a triangular window that rises then falls linearly.

Arguments

• x: Scalar or 1D Tensor. Window length.

Returns

A 1D tensor containing the Bartlett window values.

Example

>>>x=keras.ops.convert_to_tensor(5)>>>keras.ops.bartlett(x)array([0.,0.5,1.,0.5,0.],dtype=float32)

[source]

bincount function

keras.ops.bincount(x,weights=None,minlength=0,sparse=False)

Count the number of occurrences of each value in a tensor of integers.

Arguments

• 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 asx. The default value isNone. If specified,x is weighted by it, i.e. ifn = x[i],out[n] += weight[i] instead of the default behaviorout[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 thanmax(x) + 1, each value of the output at an index higher thanmax(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 itsindex value in x. Its length is the maximum betweenmax(x) + 1 andminlength.

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>>>weightsarray([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)

[source]

bitwise_and function

keras.ops.bitwise_and(x,y)

Compute the bit-wise AND of two arrays element-wise.

Computes the bit-wise AND of the underlying binary representation of theintegers in the input arrays. This ufunc implements the C/Python operator&.

Arguments

• x: Input integer tensor.
• y: Input integer tensor.

Returns

Result tensor.

[source]

bitwise_invert function

keras.ops.bitwise_invert(x)

Compute bit-wise inversion, or bit-wise NOT, element-wise.

Computes the bit-wise NOT of the underlying binary representation of theintegers in the input arrays. This ufunc implements the C/Python operator~.

Arguments

• x: Input integer tensor.

Returns

Result tensor.

[source]

bitwise_left_shift function

keras.ops.bitwise_left_shift(x,y)

Shift the bits of an integer to the left.

Bits are shifted to the left by appendingy 0s at the right ofx.Since the internal representation of numbers is in binary format, thisoperation is equivalent to multiplyingx by2**y.

Arguments

• x: Input integer tensor.
• y: Input integer tensor.

Returns

Result tensor.

[source]

bitwise_not function

keras.ops.bitwise_not(x)

Compute bit-wise inversion, or bit-wise NOT, element-wise.

Computes the bit-wise NOT of the underlying binary representation of theintegers in the input arrays. This ufunc implements the C/Python operator~.

Arguments

• x: Input integer tensor.

Returns

Result tensor.

[source]

bitwise_or function

keras.ops.bitwise_or(x,y)

Compute the bit-wise OR of two arrays element-wise.

Computes the bit-wise OR of the underlying binary representation of theintegers in the input arrays. This ufunc implements the C/Python operator|.

Arguments

• x: Input integer tensor.
• y: Input integer tensor.

Returns

Result tensor.

[source]

bitwise_right_shift function

keras.ops.bitwise_right_shift(x,y)

Shift the bits of an integer to the right.

Bits are shifted to the righty. Because the internal representation ofnumbers is in binary format, this operation is equivalent to dividingx by2**y.

Arguments

• x: Input integer tensor.
• y: Input integer tensor.

Returns

Result tensor.

[source]

bitwise_xor function

keras.ops.bitwise_xor(x,y)

Compute the bit-wise XOR of two arrays element-wise.

Computes the bit-wise XOR of the underlying binary representation of theintegers in the input arrays. This ufunc implements the C/Python operator^.

Arguments

• x: Input integer tensor.
• y: Input integer tensor.

Returns

Result tensor.

[source]

blackman function

keras.ops.blackman(x)

Blackman window function.The Blackman window is a taper formed by using a weighted cosine.

Arguments

• 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)

[source]

broadcast_to function

keras.ops.broadcast_to(x,shape)

Broadcast a tensor to a new shape.

Arguments

• x: The tensor to broadcast.
• shape: The shape of the desired tensor. A single integeri 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]])

[source]

cbrt function

keras.ops.cbrt(x)

Computes the cube root of the input tensor, element-wise.

This operation returns the real-valued cube root ofx, handlingnegative numbers properly in the real domain.

Arguments

• x: Input tensor.

Returns

A tensor containing the cube root of each element inx.

[source]

ceil function

keras.ops.ceil(x)

Return the ceiling of the input, element-wise.

The ceil of the scalarx is the smallest integeri, such thati >= x.

Arguments

• x: Input tensor.

Returns

The ceiling of each element inx, with float dtype.

[source]

clip function

keras.ops.clip(x,x_min,x_max)

Clip (limit) the values in a tensor.

Given an interval, values outside the interval are clipped to theinterval edges. For example, if an interval of[0, 1] is specified,values smaller than 0 become 0, and values larger than 1 become 1.

Arguments

• x: Input tensor.
• x_min: Minimum value.
• x_max: Maximum value.

Returns

The clipped tensor.

[source]

concatenate function

keras.ops.concatenate(xs,axis=0)

Join a sequence of tensors along an existing axis.

Arguments

• xs: The sequence of tensors to concatenate.
• axis: The axis along which the tensors will be joined. Defaults to0.

Returns

The concatenated tensor.

[source]

conj function

keras.ops.conj(x)

Shorthand forkeras.ops.conjugate.

[source]

conjugate function

keras.ops.conjugate(x)

Returns the complex conjugate, element-wise.

The complex conjugate of a complex number is obtained by changing the signof its imaginary part.

keras.ops.conj is a shorthand for this function.

Arguments

• x: Input tensor.

Returns

The complex conjugate of each element inx.

[source]

copy function

keras.ops.copy(x)

Returns a copy ofx.

Arguments

• x: Input tensor.

Returns

A copy ofx.

[source]

corrcoef function

keras.ops.corrcoef(x)

Compute the Pearson correlation coefficient matrix.

Arguments

• x: A 2D tensor of shape(N, D), where N is the number of variables and D is the number of observations.

Returns

A tensor of shape(N, N) representing the correlation matrix.

[source]

correlate function

keras.ops.correlate(x1,x2,mode="valid")

Compute the cross-correlation of two 1-dimensional tensors.

Arguments

• x1: First 1-dimensional input tensor of length M.
• x2: Second 1-dimensional input tensor of length N.
• mode: Eithervalid,same orfull. By default the mode is set tovalid, which returns an output of length max(M, N) - min(M, N) + 1.same returns an output of length max(M, N).full mode returns the convolution at each point of overlap, with an output length of N+M-1

Returns

Output tensor, cross-correlation ofx1 andx2.

[source]

cos function

keras.ops.cos(x)

Cosine, element-wise.

Arguments

• x: Input tensor.

Returns

The corresponding cosine values.

[source]

cosh function

keras.ops.cosh(x)

Hyperbolic cosine, element-wise.

Arguments

• x: Input tensor.

Returns

Output tensor of same shape asx.

[source]

count_nonzero function

keras.ops.count_nonzero(x,axis=None)

Counts the number of non-zero values inx along the givenaxis.

If no axis is specified then all non-zeros in the tensor are counted.

Arguments

• x: Input tensor.
• axis: Axis or tuple of axes along which to count the number of non-zeros. Defaults toNone.

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)

[source]

cross function

keras.ops.cross(x1,x2,axisa=-1,axisb=-1,axisc=-1,axis=None)

Returns the cross product of two (arrays of) vectors.

The cross product ofx1 andx2 in R^3 is a vectorperpendicular to bothx1 andx2. Ifx1 andx2 are arrays ofvectors, the vectors are defined by the last axis ofx1 andx2by default, and these axes can have dimensions 2 or 3.

Where the dimension of eitherx1 orx2 is 2, the third component ofthe input vector is assumed to be zero and the cross product calculatedaccordingly.

In cases where both input vectors have dimension 2, the z-component ofthe cross product is returned.

Arguments

• x1: Components of the first vector(s).
• x2: Components of the second vector(s).
• axisa: Axis ofx1 that defines the vector(s). Defaults to-1.
• axisb: Axis ofx2 that defines the vector(s). Defaults to-1.
• axisc: Axis of the result containing the cross product vector(s). Ignored if both input vectors have dimension 2, as the return is scalar. By default, the last axis.
• axis: If defined, the axis ofx1,x2 and the result that defines the vector(s) and cross product(s). Overridesaxisa,axisb andaxisc.

Note: Torch backend does not support two dimensional vectors, or the argumentsaxisa,axisb andaxisc. Useaxis instead.

Returns

Vector cross product(s).

[source]

cumprod function

keras.ops.cumprod(x,axis=None,dtype=None)

Return the cumulative product of elements along a given axis.

Arguments

• 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.

[source]

cumsum function

keras.ops.cumsum(x,axis=None,dtype=None)

Returns the cumulative sum of elements along a given axis.

Arguments

• 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.

[source]

deg2rad function

keras.ops.deg2rad(x)

Convert angles from degrees to radians.

The conversion is defined as:rad = deg * (π / 180)

Arguments

• x: Input tensor of angles in degrees.

Returns

A tensor containing angles converted to radians.

Examples

>>>fromkerasimportops>>>ops.deg2rad(180.0)3.141592653589793>>>ops.deg2rad([0.0,90.0,180.0])array([0.,1.57079633,3.14159265])

[source]

diag function

keras.ops.diag(x,k=0)

Extract a diagonal or construct a diagonal array.

Arguments

• x: Input tensor. Ifx is 2-D, returns the k-th diagonal ofx. Ifx is 1-D, return a 2-D tensor withx on the k-th diagonal.
• k: The diagonal to consider. Defaults to0. Usek > 0 for diagonals above the main diagonal, andk < 0 for diagonals below the main diagonal.

Returns

The extracted diagonal or constructed diagonal tensor.

Examples

>>>fromkeras.srcimportops>>>x=ops.arange(9).reshape((3,3))>>>xarray([[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]])

[source]

diagflat function

keras.ops.diagflat(x,k=0)

Create a two-dimensional array with the flattened input on the k-th diagonal.

Arguments

• x: Input tensor to be flattened and placed on the diagonal.
• k: The diagonal to place the flattened input. Defaults to0. Usek > 0 for diagonals above the main diagonal, andk < 0 for diagonals below the main diagonal.

Returns

A 2-D tensor with the flattened input on the specified diagonal.

[source]

diagonal function

keras.ops.diagonal(x,offset=0,axis1=0,axis2=1)

Return specified diagonals.

Ifx is 2-D, returns the diagonal ofx with the given offset, i.e., thecollection of elements of the formx[i, i+offset].

Ifx has more than two dimensions, the axes specified byaxis1andaxis2 are used to determine the 2-D sub-array whose diagonalis returned.

The shape of the resulting array can be determined by removingaxis1andaxis2 and appending an index to the right equal to the size ofthe resulting diagonals.

Arguments

• x: Input tensor.
• offset: Offset of the diagonal from the main diagonal. Can be positive or negative. Defaults to0.(main diagonal).
• axis1: Axis to be used as the first axis of the 2-D sub-arrays. Defaults to0.(first axis).
• axis2: Axis to be used as the second axis of the 2-D sub-arrays. Defaults to1 (second axis).

Returns

Tensor of diagonals.

Examples

>>>fromkeras.srcimportops>>>x=ops.arange(4).reshape((2,2))>>>xarray([[0,1],[2,3]])>>>x.diagonal()array([0,3])>>>x.diagonal(1)array([1])

>>>x=ops.arange(8).reshape((2,2,2))>>>xarray([[[0,1],[2,3]],[[4,5],[6,7]]])>>>x.diagonal(0,0,1)array([[0,6],[1,7]])

[source]

diff function

keras.ops.diff(a,n=1,axis=-1)

Calculate the n-th discrete difference along the given axis.

The first difference is given byout[i] = a[i+1] - a[i] alongthe given axis, higher differences are calculated by usingdiffrecursively.

Arguments

• a: Input tensor.
• n: The number of times values are differenced. Defaults to1.
• axis: Axis to compute discrete difference(s) along. Defaults to-1.(last axis).

Returns

Tensor of diagonals.

Examples

>>>fromkeras.srcimportops>>>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]])

[source]

digitize function

keras.ops.digitize(x,bins)

Returns the indices of the bins to which each value inx belongs.

Arguments

• x: Input array to be binned.
• bins: Array of bins. It has to be one-dimensional and monotonically increasing.

Returns

Output array of indices, of same shape asx.

Example

>>>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])

[source]

divide function

keras.ops.divide(x1,x2)

Divide arguments element-wise.

keras.ops.true_divide is an alias for this function.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

Output tensor, the quotientx1/x2, element-wise.

[source]

divide_no_nan function

keras.ops.divide_no_nan(x1,x2)

Safe element-wise division which returns 0 where the denominator is 0.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

The quotientx1/x2, element-wise, with zero where x2 is zero.

[source]

dot function

keras.ops.dot(x1,x2)

Dot product of two tensors.

• If bothx1 andx2 are 1-D tensors, it is inner product of vectors (without complex conjugation).
• If bothx1 andx2 are 2-D tensors, it is matrix multiplication.
• If eitherx1 orx2 is 0-D (scalar), it is equivalent tox1 * x2.
• Ifx1 is an N-D tensor andx2 is a 1-D tensor, it is a sum product over the last axis ofx1 andx2.
• Ifx1 is an N-D tensor andx2 is an M-D tensor (whereM>=2), it is a sum product over the last axis ofx1 and the second-to-last axis ofx2:dot(x1, x2)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]).

Arguments

• x1: First argument.
• x2: Second argument.

Note: Torch backend does not accept 0-D tensors as arguments.

Returns

Dot product ofx1 andx2.

[source]

einsum function

keras.ops.einsum(subscripts,*operands,**kwargs)

Evaluates the Einstein summation convention on the operands.

Arguments

• subscripts: Specifies the subscripts for summation as comma separated list of subscript labels. An implicit (classical Einstein summation) calculation is performed unless the explicit indicator-> 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

>>>fromkeras.srcimportops>>>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 donewith 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])

[source]

empty function

keras.ops.empty(shape,dtype=None)

Return a tensor of given shape and type filled with uninitialized data.

Arguments

• shape: Shape of the empty tensor.
• dtype: Desired data type of the empty tensor.

Returns

The empty tensor.

[source]

equal function

keras.ops.equal(x1,x2)

Returns(x1 == x2) element-wise.

Arguments

• x1: Tensor to compare.
• x2: Tensor to compare.

Returns

Output tensor, element-wise comparison ofx1 andx2.

[source]

exp function

keras.ops.exp(x)

Calculate the exponential of all elements in the input tensor.

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise exponential ofx.

[source]

exp2 function

keras.ops.exp2(x)

Calculate the base-2 exponential of all elements in the input tensor.

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise base-2 exponential ofx.

[source]

expand_dims function

keras.ops.expand_dims(x,axis)

Expand the shape of a tensor.

Insert a new axis at theaxis position in the expanded tensor shape.

Arguments

• x: Input tensor.
• axis: Position in the expanded axes where the new axis (or axes) is placed.

Returns

Output tensor with the number of dimensions increased.

[source]

expm1 function

keras.ops.expm1(x)

Calculateexp(x) - 1 for all elements in the tensor.

Arguments

• x: Input values.

Returns

Output tensor, element-wise exponential minus one.

[source]

eye function

keras.ops.eye(N,M=None,k=0,dtype=None)

Return a 2-D tensor with ones on the diagonal and zeros elsewhere.

Arguments

• N: Number of rows in the output.
• M: Number of columns in the output. IfNone, defaults toN.
• 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.

[source]

flip function

keras.ops.flip(x,axis=None)

Reverse the order of elements in the tensor along the given axis.

The shape of the tensor is preserved, but the elements are reordered.

Arguments

• 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 ofaxis reversed.

[source]

floor function

keras.ops.floor(x)

Return the floor of the input, element-wise.

The floor of the scalarx is the largest integeri, such thati <= x.

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise floor ofx.

[source]

floor_divide function

keras.ops.floor_divide(x1,x2)

Returns the largest integer smaller or equal to the division of inputs.

Arguments

• x1: Numerator.
• x2: Denominator.

Returns

Output tensor,y = floor(x1/x2)

[source]

full function

keras.ops.full(shape,fill_value,dtype=None)

Return a new tensor of given shape and type, filled withfill_value.

Arguments

• shape: Shape of the new tensor.
• fill_value: Fill value.
• dtype: Desired data type of the tensor.

Returns

Output tensor.

[source]

full_like function

keras.ops.full_like(x,fill_value,dtype=None)

Return a full tensor with the same shape and type as the given tensor.

Arguments

• x: Input tensor.
• fill_value: Fill value.
• dtype: Overrides data type of the result.

Returns

Tensor offill_value with the same shape and type asx.

[source]

gcd function

keras.ops.gcd(x1,x2)

Greatest common divisor ofx1 andx2, element-wise.

Arguments

• x1: First input tensor (integer type).
• x2: Second input tensor (integer type).

Returns

Output tensor, element-wise greatest common divisor ofx1 andx2.

[source]

get_item function

keras.ops.get_item(x,key)

Returnx[key].

[source]

greater function

keras.ops.greater(x1,x2)

Return the truth value ofx1 > x2 element-wise.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

Output tensor, element-wise comparison ofx1 andx2.

[source]

greater_equal function

keras.ops.greater_equal(x1,x2)

Return the truth value ofx1 >= x2 element-wise.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

Output tensor, element-wise comparison ofx1 andx2.

[source]

hamming function

keras.ops.hamming(x)

Hamming window function.

The Hamming window is defined as:w[n] = 0.54 - 0.46 * cos(2 * pi * n / (N - 1)) for0 <= n <= N - 1.

Arguments

• x: Scalar or 1D Tensor. The window length.

Returns

A 1D tensor containing the Hamming window values.

Example

>>>x=keras.ops.convert_to_tensor(5)>>>keras.ops.hamming(x)array([0.08,0.54,1.,0.54,0.08],dtype=float32)

[source]

hanning function

keras.ops.hanning(x)

Hanning window function.

The Hanning window is defined as:w[n] = 0.5 - 0.5 * cos(2 * pi * n / (N - 1)) for0 <= n <= N - 1.

Arguments

• x: Scalar or 1D Tensor. The window length.

Returns

A 1D tensor containing the Hanning window values.

Example

>>>x=keras.ops.convert_to_tensor(5)>>>keras.ops.hanning(x)array([0.,0.5,1.,0.5,0.],dtype=float32)

[source]

heaviside function

keras.ops.heaviside(x1,x2)

Heaviside step function.

The Heaviside step function is defined as:heaviside(x1, x2) = 0 if x1 < 0, 1 if x1 > 0, x2 if x1 == 0

Arguments

• x1: A tensor input.
• x2: A scalar or tensor, the value to return whenx1 == 0.

Returns

A tensor with a shape determined by broadcastingx1 andx2.

Example

>>>x1=keras.ops.convert_to_tensor([-2.0,0.0,3.0])>>>x2=0.5>>>keras.ops.heaviside(x1,x2)array([0.,0.5,1.],dtype=float32)

[source]

histogram function

keras.ops.histogram(x,bins=10,range=None)

Computes a histogram of the data tensorx.

Arguments

• 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 ofx.

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]))

[source]

hstack function

keras.ops.hstack(xs)

Stack tensors in sequence horizontally (column wise).

This is equivalent to concatenation along the first axis for 1-D tensors,and along the second axis for all other tensors.

Arguments

• xs: Sequence of tensors.

Returns

The tensor formed by stacking the given tensors.

[source]

hypot function

keras.ops.hypot(x1,x2)

Element-wise hypotenuse of right triangles with legsx1 andx2.

This is equivalent to computingsqrt(x1**2 + x2**2) element-wise,with shape determined by broadcasting.

Arguments

• x1: A tensor, representing the first leg of the right triangle.
• x2: A tensor, representing the second leg of the right triangle.

Returns

A tensor with a shape determined by broadcastingx1 andx2.

Example

>>>x1=keras.ops.convert_to_tensor([3.0,4.0,5.0])>>>x2=keras.ops.convert_to_tensor([4.0,3.0,12.0])>>>keras.ops.hypot(x1,x2)array([5.,5.,13.],dtype=float32)

>>>x1=keras.ops.convert_to_tensor([[1,2],[3,4]])>>>x2=keras.ops.convert_to_tensor([1,1])>>>keras.ops.hypot(x1,x2)array([[1.414213562.23606798],[3.162277664.12310563]],dtype=float32)

[source]

identity function

keras.ops.identity(n,dtype=None)

Return the identity tensor.

The identity tensor is a square tensor with ones on the main diagonal andzeros elsewhere.

Arguments

• n: Number of rows (and columns) in then x n output tensor.
• dtype: Data type of the output tensor.

Returns

The identity tensor.

[source]

imag function

keras.ops.imag(x)

Return the imaginary part of the complex argument.

Arguments

• x: Input tensor.

Returns

The imaginary component of the complex argument.

[source]

inner function

keras.ops.inner(x1,x2)

Return the inner product of two tensors.

Ordinary inner product of vectors for 1-D tensors(without complex conjugation), in higher dimensionsa sum product over the last axes.

Multidimensional arrays are treated as vectors by flatteningall but their last axes. The resulting dot product is performedover their last axes.

Arguments

• x1: First input tensor.
• x2: Second input tensor. The last dimension ofx1 andx2 must match.

Returns

Output tensor. The shape of the output is determined bybroadcasting the shapes ofx1 andx2 after removingtheir last axes.

[source]

isclose function

keras.ops.isclose(x1,x2,rtol=1e-05,atol=1e-08,equal_nan=False)

Return whether two tensors are element-wise almost equal.

Arguments

• x1: First input tensor.
• x2: Second input tensor.
• rtol: Relative tolerance.
• atol: Absolute tolerance.
• equal_nan: IfTrue, element-wise NaNs are considered equal.

Returns

Output boolean tensor.

[source]

isfinite function

keras.ops.isfinite(x)

Return whether a tensor is finite, element-wise.

Real values are finite when they are not NaN, not positive infinity, andnot negative infinity. Complex values are finite when both their realand imaginary parts are finite.

Arguments

• x: Input tensor.

Returns

Output boolean tensor.

[source]

isinf function

keras.ops.isinf(x)

Test element-wise for positive or negative infinity.

Arguments

• x: Input tensor.

Returns

Output boolean tensor.

[source]

isnan function

keras.ops.isnan(x)

Test element-wise for NaN and return result as a boolean tensor.

Arguments

• x: Input tensor.

Returns

Output boolean tensor.

[source]

isneginf function

keras.ops.isneginf(x)

Test element-wise for negative infinity.

Arguments

• x: Input tensor.

Returns

Output boolean tensor.

[source]

isposinf function

keras.ops.isposinf(x)

Test element-wise for positive infinity.

Arguments

• x: Input tensor.

Returns

Output boolean tensor.

[source]

isreal function

keras.ops.isreal(x)

Test element-wise for real numbers.

Arguments

• x: Input tensor.

Returns

Output boolean tensor.

Example

from keras import opsx = ops.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype="complex64")ops.isreal(x)array([False, True, True, True, True, False])

[source]

kaiser function

keras.ops.kaiser(x,beta)

Kaiser window function.

The Kaiser window is defined as:w[n] = I0(beta * sqrt(1 - (2n / (N - 1) - 1)^2)) / I0(beta)where I0 is the modified zeroth-order Bessel function of the first kind.

Arguments

• x: Scalar or 1D Tensor. The window length.
• beta: Float. Shape parameter for the Kaiser window.

Returns

A 1D tensor containing the Kaiser window values.

Example

>>>x=keras.ops.convert_to_tensor(5)>>>keras.ops.kaiser(x,beta=14.0)array([7.7268669e-06,1.6493219e-01,1.0000000e+00,1.6493219e-01,7.7268669e-06],dtype=float32)

[source]

kron function

keras.ops.kron(x1,x2)

Kronecker product ofx1 andx2.

Computes the Kronecker product of two input tensors. Ifx1 has shape(a0, a1, ..., an) andx2 has shape(b0, b1, ..., bn), then theoutput will have shape(a0*b0, a1*b1, ..., an*bn).

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

A tensor representing the Kronecker product ofx1 andx2.

[source]

lcm function

keras.ops.lcm(x1,x2)

Least common multiple ofx1 andx2, element-wise.

Arguments

• x1: First input tensor (integer type).
• x2: Second input tensor (integer type).

Returns

Output tensor, element-wise least common multiple ofx1 andx2.

Example

>>>x1=keras.ops.convert_to_tensor([2,3,4])>>>x2=keras.ops.convert_to_tensor([5,6,7])>>>keras.ops.lcm(x1,x2)array([10,6,28],dtype=int32)

[source]

left_shift function

keras.ops.left_shift(x,y)

Shift the bits of an integer to the left.

Bits are shifted to the left by appendingy 0s at the right ofx.Since the internal representation of numbers is in binary format, thisoperation is equivalent to multiplyingx by2**y.

Arguments

• x: Input integer tensor.
• y: Input integer tensor.

Returns

Result tensor.

[source]

less function

keras.ops.less(x1,x2)

Return the truth value ofx1 < x2 element-wise.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

Output tensor, element-wise comparison ofx1 andx2.

[source]

less_equal function

keras.ops.less_equal(x1,x2)

Return the truth value ofx1 <= x2 element-wise.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

Output tensor, element-wise comparison ofx1 andx2.

[source]

linspace function

keras.ops.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None,axis=0)

Return evenly spaced numbers over a specified interval.

Returnsnum evenly spaced samples, calculated over the interval[start, stop].

The endpoint of the interval can optionally be excluded.

Arguments

• start: The starting value of the sequence.
• stop: The end value of the sequence, unlessendpoint is set toFalse. In that case, the sequence consists of all but the last ofnum + 1 evenly spaced samples, so thatstop is excluded. Note that the step size changes whenendpoint isFalse.
• num: Number of samples to generate. Defaults to50. Must be non-negative.
• endpoint: IfTrue,stop is the last sample. Otherwise, it is not included. Defaults toTrue.
• retstep: IfTrue, return(samples, step), wherestep is the spacing between samples.
• dtype: The type of the output tensor.
• axis: The axis in the result to store the samples. Relevant only if start or stop are array-like. Defaults to0.

Note: Torch backend does not supportaxis argument.

Returns

A tensor of evenly spaced numbers.Ifretstep isTrue, returns(samples, step)

[source]

log function

keras.ops.log(x)

Natural logarithm, element-wise.

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise natural logarithm ofx.

[source]

log10 function

keras.ops.log10(x)

Return the base 10 logarithm of the input tensor, element-wise.

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise base 10 logarithm ofx.

[source]

log1p function

keras.ops.log1p(x)

Returns the natural logarithm of one plus thex, element-wise.

Calculateslog(1 + x).

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise natural logarithm of1 + x.

[source]

log2 function

keras.ops.log2(x)

Base-2 logarithm ofx, element-wise.

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise base-2 logarithm ofx.

[source]

logaddexp function

keras.ops.logaddexp(x1,x2)

Logarithm of the sum of exponentiations of the inputs.

Calculateslog(exp(x1) + exp(x2)).

Arguments

• x1: Input tensor.
• x2: Input tensor.

Returns

Output tensor, element-wise logarithm of the sum of exponentiationsof the inputs.

[source]

logical_and function

keras.ops.logical_and(x1,x2)

Computes the element-wise logical AND of the given input tensors.

Zeros are treated asFalse and non-zeros are treated asTrue.

Arguments

• x1: Input tensor.
• x2: Input tensor.

Returns

Output tensor, element-wise logical AND of the inputs.

[source]

logical_not function

keras.ops.logical_not(x)

Computes the element-wise NOT of the given input tensor.

Zeros are treated asFalse and non-zeros are treated asTrue.

Arguments

• x: Input tensor.

Returns

Output tensor, element-wise logical NOT of the input.

[source]

logical_or function

keras.ops.logical_or(x1,x2)

Computes the element-wise logical OR of the given input tensors.

Zeros are treated asFalse and non-zeros are treated asTrue.

Arguments

• x1: Input tensor.
• x2: Input tensor.

Returns

Output tensor, element-wise logical OR of the inputs.

[source]

logical_xor function

keras.ops.logical_xor(x1,x2)

Compute the truth value ofx1 XOR x2, element-wise.

Arguments

• x1: First input tensor.
• x2: Second input tensor.

Returns

Output boolean tensor.

[source]

logspace function

keras.ops.logspace(start,stop,num=50,endpoint=True,base=10,dtype=None,axis=0)

Returns numbers spaced evenly on a log scale.

In linear space, the sequence starts atbase ** start and ends withbase ** stop (seeendpoint below).

Arguments

• start: The starting value of the sequence.
• stop: The final value of the sequence, unlessendpoint isFalse. In that case,num + 1 values are spaced over the interval in log-space, of which all but the last (a sequence of lengthnum) are returned.
• num: Number of samples to generate. Defaults to50.
• endpoint: IfTrue,stop is the last sample. Otherwise, it is not included. Defaults toTrue.
• base: The base of the log space. Defaults to10.
• dtype: The type of the output tensor.
• axis: The axis in the result to store the samples. Relevant only if start or stop are array-like.

Note: Torch backend does not supportaxis argument.

Returns

A tensor of evenly spaced samples on a log scale.

[source]

matmul function

keras.ops.matmul(x1,x2)

Matrix product of two tensors.

• If both tensors are 1-dimensional, the dot product (scalar) is returned.
• If either tensor is N-D, N > 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.

Arguments

• x1: First tensor.
• x2: Second tensor.

Returns

Output tensor, matrix product of the inputs.

[source]

max function

keras.ops.max(x,axis=None,keepdims=False,initial=None)