import builtins

import re

import numpy as np

from keras.src import backend

from keras.src.api_export import keras_export

from keras.src.backend import KerasTensor

from keras.src.backend import any_symbolic_tensors

from keras.src.backend.common import dtypes

from keras.src.backend.common.backend_utils import canonicalize_axis

from keras.src.backend.common.backend_utils import to_tuple_or_list

from keras.src.ops import operation_utils

from keras.src.ops.operation import Operation

from keras.src.ops.operation_utils import broadcast_shapes

from keras.src.ops.operation_utils import reduce_shape

def shape_equal(shape1, shape2, axis=None, allow_none=True):

"""Check 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

"""

if len(shape1) != len(shape2):

return False

shape1 = list(shape1)

shape2 = list(shape2)

if axis is not None:

if isinstance(axis, int):

axis = [axis]

for ax in axis:

shape1[ax] = -1

shape2[ax] = -1

if allow_none:

for i in range(len(shape1)):

if shape1[i] is None:

shape1[i] = shape2[i]

if shape2[i] is None:

shape2[i] = shape1[i]

return shape1 == shape2

class Absolute(Operation):

def call(self, x):

return backend.numpy.absolute(x)

def compute_output_spec(self, x):

sparse = getattr(x, "sparse", False)

return KerasTensor(x.shape, dtype=x.dtype, sparse=sparse)

@keras_export(["keras.ops.absolute", "keras.ops.numpy.absolute"])

def absolute(x):

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

"""

if any_symbolic_tensors((x,)):

return Absolute().symbolic_call(x)

return backend.numpy.absolute(x)

class Abs(Absolute):

pass

@keras_export(["keras.ops.abs", "keras.ops.numpy.abs"])

def abs(x):

"""Shorthand for `keras.ops.absolute`."""

return absolute(x)

class Add(Operation):

def call(self, x1, x2):

return backend.numpy.add(x1, x2)

def compute_output_spec(self, x1, x2):

x1_shape = getattr(x1, "shape", [])

x2_shape = getattr(x2, "shape", [])

output_shape = broadcast_shapes(x1_shape, x2_shape)

output_dtype = dtypes.result_type(

getattr(x1, "dtype", type(x1)),

getattr(x2, "dtype", type(x2)),

)

x1_sparse = getattr(x1, "sparse", False)

x2_sparse = getattr(x2, "sparse", False)

output_sparse = x1_sparse and x2_sparse

return KerasTensor(

output_shape, dtype=output_dtype, sparse=output_sparse

)

@keras_export(["keras.ops.add", "keras.ops.numpy.add"])

def add(x1, x2):

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

"""

if any_symbolic_tensors((x1, x2)):

return Add().symbolic_call(x1, x2)

return backend.numpy.add(x1, x2)

class All(Operation):

def __init__(self, axis=None, keepdims=False):

super().__init__()

if isinstance(axis, int):

self.axis = [axis]

else:

self.axis = axis

self.keepdims = keepdims

def call(self, x):

return backend.numpy.all(

x,

axis=self.axis,

keepdims=self.keepdims,

)

def compute_output_spec(self, x):

return KerasTensor(

reduce_shape(

x.shape,

axis=self.axis,

keepdims=self.keepdims,

),

dtype="bool",

)

@keras_export(["keras.ops.all", "keras.ops.numpy.all"])

def all(x, axis=None, keepdims=False):

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

"""

if any_symbolic_tensors((x,)):

return All(axis=axis, keepdims=keepdims).symbolic_call(x)

return backend.numpy.all(x, axis=axis, keepdims=keepdims)

class Any(Operation):

def __init__(self, axis=None, keepdims=False):

super().__init__()

if isinstance(axis, int):

self.axis = [axis]

else:

self.axis = axis

self.keepdims = keepdims

def call(self, x):

return backend.numpy.any(

x,

axis=self.axis,

keepdims=self.keepdims,

)

def compute_output_spec(self, x):

return KerasTensor(

reduce_shape(

x.shape,

axis=self.axis,

keepdims=self.keepdims,

),

dtype="bool",

)

@keras_export(["keras.ops.any", "keras.ops.numpy.any"])

def any(x, axis=None, keepdims=False):

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

"""

if any_symbolic_tensors((x,)):

return Any(axis=axis, keepdims=keepdims).symbolic_call(x)

return backend.numpy.any(x, axis=axis, keepdims=keepdims)

class Amax(Operation):

def __init__(self, axis=None, keepdims=False):

super().__init__()

if isinstance(axis, int):

axis = [axis]

self.axis = axis

self.keepdims = keepdims

def call(self, x):

return backend.numpy.amax(

x,

axis=self.axis,

keepdims=self.keepdims,

)

def compute_output_spec(self, x):

return KerasTensor(

reduce_shape(x.shape, axis=self.axis, keepdims=self.keepdims),

dtype=x.dtype,

)

@keras_export(["keras.ops.amax", "keras.ops.numpy.amax"])

def amax(x, axis=None, keepdims=False):

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

"""

if any_symbolic_tensors((x,)):

return Amax(axis=axis, keepdims=keepdims).symbolic_call(x)

return backend.numpy.amax(x, axis=axis, keepdims=keepdims)

class Amin(Operation):

def __init__(self, axis=None, keepdims=False):

super().__init__()

if isinstance(axis, int):

axis = [axis]

self.axis = axis

self.keepdims = keepdims

def call(self, x):

return backend.numpy.amin(x, axis=self.axis, keepdims=self.keepdims)

def compute_output_spec(self, x):

return KerasTensor(

reduce_shape(x.shape, axis=self.axis, keepdims=self.keepdims),

dtype=x.dtype,

)

@keras_export(["keras.ops.amin", "keras.ops.numpy.amin"])

def amin(x, axis=None, keepdims=False):

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

"""

if any_symbolic_tensors((x,)):

return Amin(axis=axis, keepdims=keepdims).symbolic_call(x)

return backend.numpy.amin(x, axis=axis, keepdims=keepdims)

class Append(Operation):

def __init__(self, axis=None):

super().__init__()

self.axis = axis

def call(self, x1, x2):

return backend.numpy.append(x1, x2, axis=self.axis)

def compute_output_spec(self, x1, x2):

x1_shape = x1.shape

x2_shape = x2.shape

dtype = dtypes.result_type(

getattr(x1, "dtype", type(x1)),

getattr(x2, "dtype", type(x2)),

)

if self.axis is None:

if None in x1_shape or None in x2_shape:

output_shape = [None]

else:

output_shape = [int(np.prod(x1_shape) + np.prod(x2_shape))]

return KerasTensor(output_shape, dtype=dtype)

if not shape_equal(x1_shape, x2_shape, [self.axis]):

raise ValueError(

"`append` requires inputs to have the same shape except the "

f"`axis={self.axis}`, but received shape {x1_shape} and "

f"{x2_shape}."

)

output_shape = list(x1_shape)

output_shape[self.axis] = x1_shape[self.axis] + x2_shape[self.axis]

return KerasTensor(output_shape, dtype=dtype)

@keras_export(["keras.ops.append", "keras.ops.numpy.append"])

def append(

x1,

x2,

axis=None,

):

"""Append tensor `x2` to the end of tensor `x1`.

Args:

x1: First input tensor.

x2: Second input tensor.

axis: Axis along which tensor `x2` is appended to tensor `x1`.

If `None`, both tensors are flattened before use.

Returns:

A tensor with the values of `x2` appended to `x1`.

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)

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

"""

if any_symbolic_tensors((x1, x2)):

return Append(axis=axis).symbolic_call(x1, x2)

return backend.numpy.append(x1, x2, axis=axis)

class Arange(Operation):

def call(self, start, stop=None, step=1, dtype=None):

return backend.numpy.arange(start, stop, step=step, dtype=dtype)

def compute_output_spec(self, start, stop=None, step=1, dtype=None):

if stop is None:

start, stop = 0, start

output_shape = [int(np.ceil((stop - start) / step))]

if dtype is None:

dtypes_to_resolve = [

getattr(start, "dtype", type(start)),

getattr(step, "dtype", type(step)),

]

if stop is not None:

dtypes_to_resolve.append(getattr(stop, "dtype", type(stop)))

dtype = dtypes.result_type(*dtypes_to_resolve)

return KerasTensor(output_shape, dtype=dtype)

@keras_export(["keras.ops.arange", "keras.ops.numpy.arange"])

def arange(start, stop=None, step=1, 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.

Args:

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 where

`step` is not an integer and floating point round-off affects the

length of `out`. Defaults to `None`.

step: Integer or real, represent the spacing between values. For any

output `out`, this is the distance between two adjacent values,

`out[i+1] - out[i]`. The default step size is 1. If `step` is

specified as a position argument, `start` must also be given.

dtype: The type of the output array. If `dtype` 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 is

`ceil((stop - start)/step)`. Because of floating point overflow, this

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

"""

return backend.numpy.arange(start, stop, step=step, dtype=dtype)

class Arccos(Operation):

def call(self, x):

return backend.numpy.arccos(x)

def compute_output_spec(self, x):

dtype = backend.standardize_dtype(getattr(x, "dtype", backend.floatx()))

if dtype == "int64":

dtype = backend.floatx()

else:

dtype = dtypes.result_type(dtype, float)

return KerasTensor(x.shape, dtype=dtype)

@keras_export(["keras.ops.arccos", "keras.ops.numpy.arccos"])

def arccos(x):

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

"""

if any_symbolic_tensors((x,)):

return Arccos().symbolic_call(x)

return backend.numpy.arccos(x)

class Arccosh(Operation):

def call(self, x):

return backend.numpy.arccosh(x)

def compute_output_spec(self, x):

dtype = backend.standardize_dtype(getattr(x, "dtype", backend.floatx()))

if dtype == "int64":

dtype = backend.floatx()

else:

dtype = dtypes.result_type(dtype, float)

return KerasTensor(x.shape, dtype=dtype)

@keras_export(["keras.ops.arccosh", "keras.ops.numpy.arccosh"])

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

"""

if any_symbolic_tensors((x,)):

return Arccosh().symbolic_call(x)

return backend.numpy.arccosh(x)

class Arcsin(Operation):

def call(self, x):

return backend.numpy.arcsin(x)

def compute_output_spec(self, x):

dtype = backend.standardize_dtype(getattr(x, "dtype", backend.floatx()))

if dtype == "int64":

dtype = backend.floatx()

else:

dtype = dtypes.result_type(dtype, float)

sparse = getattr(x, "sparse", False)

return KerasTensor(x.shape, dtype=dtype, sparse=sparse)

@keras_export(["keras.ops.arcsin", "keras.ops.numpy.arcsin"])

def arcsin(x):

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

"""

if any_symbolic_tensors((x,)):

return Arcsin().symbolic_call(x)

return backend.numpy.arcsin(x)

class Arcsinh(Operation):

def call(self, x):

return backend.numpy.arcsinh(x)

def compute_output_spec(self, x):

dtype = backend.standardize_dtype(getattr(x, "dtype", backend.floatx()))

if dtype == "int64":

dtype = backend.floatx()

else:

dtype = dtypes.result_type(dtype, float)

sparse = getattr(x, "sparse", False)

return KerasTensor(x.shape, dtype=dtype, sparse=sparse)

@keras_export(["keras.ops.arcsinh", "keras.ops.numpy.arcsinh"])

def arcsinh(x):

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

"""

if any_symbolic_tensors((x,)):

return Arcsinh().symbolic_call(x)

return backend.numpy.arcsinh(x)

class Arctan(Operation):

def call(self, x):

return backend.numpy.arctan(x)

def compute_output_spec(self, x):

dtype = backend.standardize_dtype(getattr(x, "dtype", backend.floatx()))

if dtype == "int64":

dtype = backend.floatx()

else:

dtype = dtypes.result_type(dtype, float)

sparse = getattr(x, "sparse", False)

return KerasTensor(x.shape, dtype=dtype, sparse=sparse)

@keras_export(["keras.ops.arctan", "keras.ops.numpy.arctan"])

def arctan(x):

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

"""

if any_symbolic_tensors((x,)):

return Arctan().symbolic_call(x)

return backend.numpy.arctan(x)

class Arctan2(Operation):

def call(self, x1, x2):

return backend.numpy.arctan2(x1, x2)

def compute_output_spec(self, x1, x2):

x1_shape = getattr(x1, "shape", [])

x2_shape = getattr(x2, "shape", [])

outputs_shape = broadcast_shapes(x1_shape, x2_shape)

x1_dtype = backend.standardize_dtype(

getattr(x1, "dtype", backend.floatx())

)

x2_dtype = backend.standardize_dtype(

getattr(x2, "dtype", backend.floatx())

)

dtype = dtypes.result_type(x1_dtype, x2_dtype, float)

return KerasTensor(outputs_shape, dtype=dtype)

@keras_export(["keras.ops.arctan2", "keras.ops.numpy.arctan2"])

def arctan2(x1, x2):

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

"""

if any_symbolic_tensors((x1, x2)):

return Arctan2().symbolic_call(x1, x2)

return backend.numpy.arctan2(x1, x2)

class Arctanh(Operation):

def call(self, x):

return backend.numpy.arctanh(x)

def compute_output_spec(self, x):

dtype = backend.standardize_dtype(getattr(x, "dtype", backend.floatx()))

if dtype == "int64":

dtype = backend.floatx()

else:

dtype = dtypes.result_type(dtype, float)

sparse = getattr(x, "sparse", False)

return KerasTensor(x.shape, dtype=dtype, sparse=sparse)

@keras_export(["keras.ops.arctanh", "keras.ops.numpy.arctanh"])

def arctanh(x):

"""Inverse hyperbolic tangent, element-wise.

Arguments:

x: Input tensor.

Returns:

Output tensor of same shape as `x`.

"""

if any_symbolic_tensors((x,)):

return Arctanh().symbolic_call(x)

return backend.numpy.arctanh(x)

class Argmax(Operation):

def __init__(self, axis=None, keepdims=False):

super().__init__()

self.axis = axis

self.keepdims = keepdims

def call(self, x):

return backend.numpy.argmax(x, axis=self.axis, keepdims=self.keepdims)

def compute_output_spec(self, x):

if self.keepdims:

return KerasTensor(x.shape, dtype="int32")

if self.axis is None:

return KerasTensor([], dtype="int32")

return KerasTensor(

reduce_shape(x.shape, axis=[self.axis]), dtype="int32"

)

@keras_export(["keras.ops.argmax", "keras.ops.numpy.argmax"])

def argmax(x, axis=None, keepdims=False):

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

"""

if any_symbolic_tensors((x,)):

return Argmax(axis=axis, keepdims=keepdims).symbolic_call(x)

return backend.numpy.argmax(x, axis=axis, keepdims=keepdims)

class Argmin(Operation):

def __init__(self, axis=None, keepdims=False):

super().__init__()

self.axis = axis

self.keepdims = keepdims

def call(self, x):

return backend.numpy.argmin(x, axis=self.axis, keepdims=self.keepdims)

def compute_output_spec(self, x):

if self.keepdims:

return KerasTensor(x.shape, dtype="int32")

if self.axis is None:

return KerasTensor([], dtype="int32")

return KerasTensor(

reduce_shape(x.shape, axis=[self.axis]), dtype="int32"

)

@keras_export(["keras.ops.argmin", "keras.ops.numpy.argmin"])

def argmin(x, axis=None, keepdims=False):

"""Returns the indices of the minium 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)

"""

if any_symbolic_tensors((x,)):

return Argmin(axis=axis, keepdims=keepdims).symbolic_call(x)

return backend.numpy.argmin(x, axis=axis, keepdims=keepdims)

class Argsort(Operation):

def __init__(self, axis=-1):

super().__init__()

self.axis = axis

def call(self, x):

return backend.numpy.argsort(x, axis=self.axis)

def compute_output_spec(self, x):

if self.axis is None:

return KerasTensor([int(np.prod(x.shape))], dtype="int32")

return KerasTensor(x.shape, dtype="int32")

@keras_export(["keras.ops.argsort", "keras.ops.numpy.argsort"])

def argsort(x, axis=-1):

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

"""

if any_symbolic_tensors((x,)):

return Argsort(axis=axis).symbolic_call(x)

return backend.numpy.argsort(x, axis=axis)

class Array(Operation):

def call(self, x, dtype=None):

return backend.numpy.array(x, dtype=dtype)

def compute_output_spec(self, x, dtype=None):

return KerasTensor(x.shape, dtype=dtype)

@keras_export(["keras.ops.array", "keras.ops.numpy.array"])

def array(x, dtype=None):

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

"""