Add files using upload-large-folder tool

.gitattributes

@@ -1084,3 +1084,6 @@ infer_4_37_2/lib/libquadmath.so filter=lfs diff=lfs merge=lfs -text
 infer_4_33_0/lib/python3.10/site-packages/scipy/sparse/_csparsetools.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 infer_4_33_0/lib/python3.10/site-packages/keras/src/ops/__pycache__/numpy.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_33_0/lib/python3.10/site-packages/skimage/filters/rank/generic_cy.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/libubsan.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/libtinfow.so.6 filter=lfs diff=lfs merge=lfs -text
+infer_4_33_0/lib/python3.10/site-packages/scipy/ndimage/_ni_label.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

infer_4_33_0/lib/python3.10/site-packages/certifi/__init__.py

@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2024.12.14"

infer_4_33_0/lib/python3.10/site-packages/certifi/__main__.py

@@ -0,0 +1,12 @@
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())

infer_4_33_0/lib/python3.10/site-packages/certifi/core.py

@@ -0,0 +1,114 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import sys
+import atexit
+
+def exit_cacert_ctx() -> None:
+    _CACERT_CTX.__exit__(None, None, None)  # type: ignore[union-attr]
+
+
+if sys.version_info >= (3, 11):
+
+    from importlib.resources import as_file, files
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = as_file(files("certifi").joinpath("cacert.pem"))
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return files("certifi").joinpath("cacert.pem").read_text(encoding="ascii")
+
+elif sys.version_info >= (3, 7):
+
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the
+        # file in cases where we're inside of a zipimport situation until
+        # someone actually calls where(), but we don't want to re-extract
+        # the file on every call of where(), so we'll do it once then store
+        # it in a global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you
+            # to manage the cleanup of this file, so it doesn't actually
+            # return a path, it returns a context manager that will give
+            # you the path when you enter it and will do any cleanup when
+            # you leave it. In the common case of not needing a temporary
+            # file, it will just return the file system location and the
+            # __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")
+
+else:
+    import os
+    import types
+    from typing import Union
+
+    Package = Union[types.ModuleType, str]
+    Resource = Union[str, "os.PathLike"]
+
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(
+        package: Package,
+        resource: Resource,
+        encoding: str = 'utf-8',
+        errors: str = 'strict'
+    ) -> str:
+        with open(where(), encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where() -> str:
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")

infer_4_33_0/lib/python3.10/site-packages/gast-0.6.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

infer_4_33_0/lib/python3.10/site-packages/gast-0.6.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: gast
+Version: 0.6.0
+Summary: Python AST that abstracts the underlying Python version
+Home-page: https://github.com/serge-sans-paille/gast/
+Author: serge-sans-paille
+Author-email: [email protected]
+License: BSD 3-Clause
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+License-File: LICENSE
+
+
+A generic AST to represent Python2 and Python3's Abstract Syntax Tree(AST).
+
+GAST provides a compatibility layer between the AST of various Python versions,
+as produced by ``ast.parse`` from the standard ``ast`` module.

infer_4_33_0/lib/python3.10/site-packages/gast-0.6.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+gast-0.6.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+gast-0.6.0.dist-info/LICENSE,sha256=agS7q9m0i-pr98C9PzoGLhR2s8QDp0ZEj9abDZAuFI8,1490
+gast-0.6.0.dist-info/METADATA,sha256=ZaEdD89-rroMy_gAkTanC3FMB0W3BU6LMKo-ZJXDg60,1327
+gast-0.6.0.dist-info/RECORD,,
+gast-0.6.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gast-0.6.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+gast-0.6.0.dist-info/top_level.txt,sha256=OZY5DvDNAf17-SMBR1pXPV7iJyIpR-6sFAgOfFc_Vz8,5
+gast/__init__.py,sha256=qebTP3aM9LOaOeilaPxUlcP_PkcatAuS7_Q6uaLpsHQ,111
+gast/__pycache__/__init__.cpython-310.pyc,,
+gast/__pycache__/ast2.cpython-310.pyc,,
+gast/__pycache__/ast3.cpython-310.pyc,,
+gast/__pycache__/astn.cpython-310.pyc,,
+gast/__pycache__/gast.cpython-310.pyc,,
+gast/__pycache__/unparser.cpython-310.pyc,,
+gast/__pycache__/version.cpython-310.pyc,,
+gast/ast2.py,sha256=RP9OQ3D_cWmSyf36oWCQkbY2vfGhMVMbsQHXmbvu9nM,13446
+gast/ast3.py,sha256=FHd_8TJL_NBQTYDETWkKJiobJM83O2ZjZZIZLnTF6Ss,17275
+gast/astn.py,sha256=ucrgL8OMGAfWVpPwVUOVTA2ckSlTE83D67UU0rp94Q4,1057
+gast/gast.py,sha256=aCT_jFyXCiT_e-YcwqDqSJH0O22qu6zpYTnpxmSVJZA,22465
+gast/unparser.py,sha256=KwwXCWvZ2nu-XJc11SAPJHj2EQzMQC4Ow5pbH_KULV8,39633
+gast/version.py,sha256=CBY3jsC-9HCm7eZ6CKD-sYLCejqOJ1pYWPQM4LGIXcI,22

infer_4_33_0/lib/python3.10/site-packages/gast-0.6.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.2.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

infer_4_33_0/lib/python3.10/site-packages/gast-0.6.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gast

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/core.py

@@ -0,0 +1,407 @@
+import jax
+import jax.experimental.sparse as jax_sparse
+import jax.numpy as jnp
+import ml_dtypes
+import numpy as np
+
+from keras.src import tree
+from keras.src.backend.common import KerasVariable
+from keras.src.backend.common import global_state
+from keras.src.backend.common import standardize_dtype
+from keras.src.backend.common.keras_tensor import KerasTensor
+from keras.src.backend.common.name_scope import name_scope as base_name_scope
+from keras.src.backend.common.stateless_scope import StatelessScope
+from keras.src.backend.common.symbolic_scope import SymbolicScope
+from keras.src.backend.jax import distribution_lib
+
+SUPPORTS_SPARSE_TENSORS = True
+IS_THREAD_SAFE = True
+
+
+class Variable(KerasVariable):
+    def _initialize(self, value):
+        # Note that variable.shape is needed by distribution_lib
+        self._shape = self._validate_shape(value.shape)
+        # We can't import the keras/distribution/distribution_lib
+        # due to circular dependency.
+        distribution = global_state.get_global_attribute("distribution")
+        if distribution is not None:
+            self._layout = distribution_lib._to_jax_layout(
+                distribution.get_variable_layout(self)
+            )
+        else:
+            self._layout = None
+        self._direct_assign(value)
+
+    def _direct_assign(self, value):
+        if getattr(self, "_layout", None) is not None:
+            value = distribution_lib.distribute_variable(value, self._layout)
+        self._value = value
+
+    def _convert_to_tensor(self, value, dtype=None):
+        return convert_to_tensor(value, dtype=dtype, sparse=False)
+
+    # Overload native accessor.
+    def __jax_array__(self):
+        return self.value
+
+
+def convert_to_tensor(x, dtype=None, sparse=True):
+    if dtype is not None:
+        dtype = standardize_dtype(dtype)
+    if isinstance(x, (jnp.ndarray, jax.Array)) and (
+        dtype is None or x.dtype == dtype
+    ):
+        # Skip the conversion early if the instance is already a JAX array.
+        # This is important in the multi-process context since jax.array(x) for
+        # an existing distributed jax array will raise error.
+        return x
+
+    if isinstance(x, Variable):
+        if dtype is not None and x.dtype != dtype:
+            return x.value.astype(dtype)
+        return x.value
+
+    if isinstance(x, jax_sparse.JAXSparse):
+        if sparse is not None and not sparse:
+            x = x.todense()
+        elif dtype is not None and x.dtype != dtype:
+            return x.astype(dtype)
+        else:
+            return x
+
+    if not is_tensor(x) and standardize_dtype(dtype) == "bfloat16":
+        # Can't create bfloat16 arrays on the fly (e.g. from a h5 Dataset).
+        # Instead we convert "as is" (to stored dtype) and cast.
+        return jnp.asarray(x).astype(dtype)
+    return jnp.asarray(x, dtype=dtype)
+
+
+def convert_to_numpy(x):
+    if isinstance(x, jax_sparse.JAXSparse):
+        x = x.todense()
+    if is_tensor(x) and x.dtype == "bfloat16":
+        return np.array(x, dtype=ml_dtypes.bfloat16)
+    return np.array(x)
+
+
+def is_tensor(x):
+    if isinstance(x, (jnp.ndarray, jax_sparse.JAXSparse)):
+        return True
+    return False
+
+
+def shape(x):
+    # This will work as long as we disallow
+    # dynamic shapes in JAX.
+    return x.shape
+
+
+def cast(x, dtype):
+    return convert_to_tensor(x, dtype=dtype)
+
+
+# Shape / dtype / sparseness inference util
+def compute_output_spec(fn, *args, **kwargs):
+    with StatelessScope(), SymbolicScope():
+        built_in_types = (type(None), int, float, str, bool, complex, bytes)
+
+        # First, separate symbolic args from other args
+        static_args_idx = []
+        static_args = []
+        maybe_symbolic_args = []
+        static_kwargs = {}
+        maybe_symbolic_kwargs = {}
+        for idx, arg in enumerate(args):
+            if isinstance(arg, built_in_types):
+                static_args_idx.append(idx)
+                static_args.append(arg)
+            else:
+                maybe_symbolic_args.append(arg)
+        maybe_symbolic_args = tuple(maybe_symbolic_args)
+        for k, v in kwargs.items():
+            if isinstance(v, built_in_types):
+                static_kwargs[k] = v
+            else:
+                maybe_symbolic_kwargs[k] = v
+
+        # Second, find out if there are dynamic shapes
+        has_none = False
+        for x in tree.flatten((maybe_symbolic_args, maybe_symbolic_kwargs)):
+            if isinstance(x, KerasTensor) and any(d is None for d in x.shape):
+                has_none = True
+
+        def convert_keras_tensor_to_jax(x, fill_value=None):
+            if isinstance(x, KerasTensor):
+                shape = list(x.shape)
+                if fill_value:
+                    for i, e in enumerate(shape):
+                        if e is None:
+                            shape[i] = fill_value
+                jax_tensor = jax.ShapeDtypeStruct(shape, dtype=x.dtype)
+                return jax_tensor
+            if isinstance(x, dict):
+                return {
+                    k: convert_keras_tensor_to_jax(v, fill_value=fill_value)
+                    for k, v in x.items()
+                }
+            if isinstance(x, list):
+                return [
+                    convert_keras_tensor_to_jax(xi, fill_value=fill_value)
+                    for xi in x
+                ]
+            return x
+
+        def wrapped_fn(*args, **kwargs):
+            # Turn inputs that are sparse to BCOO tensors
+            def to_bcoo_if_sparse(x, maybe_symbolic_x):
+                if (
+                    isinstance(maybe_symbolic_x, KerasTensor)
+                    and maybe_symbolic_x.sparse
+                ):
+                    return jax_sparse.BCOO.fromdense(x, nse=1)
+                return x
+
+            args, kwargs = tree.map_structure(
+                to_bcoo_if_sparse,
+                (args, kwargs),
+                (maybe_symbolic_args, maybe_symbolic_kwargs),
+            )
+
+            rec_args = []
+            idx_static = 0
+            idx_sym = 0
+            i = 0
+            while idx_static < len(static_args) or idx_sym < len(args):
+                if i in static_args_idx:
+                    rec_args.append(static_args[idx_static])
+                    idx_static += 1
+                else:
+                    rec_args.append(args[idx_sym])
+                    idx_sym += 1
+
+                i += 1
+            with StatelessScope():
+                return fn(*rec_args, **kwargs, **static_kwargs)
+
+        if has_none:
+            ms_args_1, ms_kwargs_1 = tree.map_structure(
+                lambda x: convert_keras_tensor_to_jax(x, fill_value=83),
+                (maybe_symbolic_args, maybe_symbolic_kwargs),
+            )
+            _, jax_out_1 = jax.make_jaxpr(wrapped_fn, return_shape=True)(
+                *ms_args_1, **ms_kwargs_1
+            )
+
+            ms_args_2, ms_kwargs_2 = tree.map_structure(
+                lambda x: convert_keras_tensor_to_jax(x, fill_value=89),
+                (maybe_symbolic_args, maybe_symbolic_kwargs),
+            )
+            _, jax_out_2 = jax.make_jaxpr(wrapped_fn, return_shape=True)(
+                *ms_args_2, **ms_kwargs_2
+            )
+
+            def merge_shapes(shape1, shape2):
+                return tuple(
+                    [d1 if d1 == d2 else None for d1, d2 in zip(shape1, shape2)]
+                )
+
+            def convert_jax_specs_to_keras_tensor(x1, x2):
+                if isinstance(x1, jax.ShapeDtypeStruct):
+                    if not isinstance(x2, jax.ShapeDtypeStruct):
+                        raise ValueError("Indeterministic output ordering.")
+                    return KerasTensor(
+                        merge_shapes(x1.shape, x2.shape), dtype=x1.dtype
+                    )
+                elif isinstance(x1, jax_sparse.BCOO):
+                    if not isinstance(x2, jax_sparse.BCOO):
+                        raise ValueError("Indeterministic output ordering.")
+                    return KerasTensor(
+                        merge_shapes(x1.shape, x2.shape),
+                        dtype=x1.dtype,
+                        sparse=True,
+                    )
+                else:
+                    return x1
+
+            return tree.map_structure(
+                convert_jax_specs_to_keras_tensor, jax_out_1, jax_out_2
+            )
+
+        maybe_symbolic_args, maybe_symbolic_kwargs = tree.map_structure(
+            convert_keras_tensor_to_jax,
+            (maybe_symbolic_args, maybe_symbolic_kwargs),
+        )
+        _, jax_out = jax.make_jaxpr(wrapped_fn, return_shape=True)(
+            *maybe_symbolic_args, **maybe_symbolic_kwargs
+        )
+
+        def convert_jax_spec_to_keras_tensor(x):
+            if isinstance(x, jax.ShapeDtypeStruct):
+                return KerasTensor(x.shape, x.dtype)
+            elif isinstance(x, jax_sparse.BCOO):
+                return KerasTensor(x.shape, x.dtype, sparse=True)
+            return x
+
+        return tree.map_structure(convert_jax_spec_to_keras_tensor, jax_out)
+
+
+def cond(pred, true_fn, false_fn):
+    return jax.lax.cond(pred, true_fun=true_fn, false_fun=false_fn)
+
+
+def vectorized_map(function, elements):
+    return jax.vmap(function)(elements)
+
+
+def map(f, xs):
+    return jax.lax.map(f, xs)
+
+
+def scan(f, init, xs=None, length=None, reverse=False, unroll=1):
+    if not isinstance(unroll, bool):
+        if not isinstance(unroll, int) or unroll < 1:
+            raise ValueError(
+                "`unroll` must be an positive integer or boolean. "
+                f"Received: unroll={unroll}"
+            )
+    return jax.lax.scan(
+        f, init=init, xs=xs, length=length, reverse=reverse, unroll=unroll
+    )
+
+
+def associative_scan(f, elems, reverse=False, axis=0):
+    return jax.lax.associative_scan(f, elems, reverse, axis)
+
+
+def scatter(indices, values, shape):
+    zeros = jnp.zeros(shape, values.dtype)
+    key = tuple(jnp.moveaxis(indices, -1, 0))
+    return zeros.at[key].add(values)
+
+
+def scatter_update(inputs, indices, updates):
+    inputs = convert_to_tensor(inputs)
+    indices = jnp.array(indices)
+    indices = jnp.transpose(indices)
+    inputs = inputs.at[tuple(indices)].set(updates)
+    return inputs
+
+
+def slice(inputs, start_indices, shape):
+    return jax.lax.dynamic_slice(inputs, start_indices, shape)
+
+
+def slice_update(inputs, start_indices, updates):
+    return jax.lax.dynamic_update_slice(inputs, updates, start_indices)
+
+
+def switch(index, branches, *operands):
+    return jax.lax.switch(index, branches, *operands)
+
+
+def while_loop(
+    cond,
+    body,
+    loop_vars,
+    maximum_iterations=None,
+):
+    is_tuple = isinstance(loop_vars, (tuple, list))
+    loop_vars = tuple(loop_vars) if is_tuple else (loop_vars,)
+    if maximum_iterations is not None:
+        current_iter = 0
+        loop_vars = loop_vars + (current_iter,)
+
+        # Unpack list/tuple args. The last argument is `current_iter`.
+        def _cond(args):
+            return cond(*args[:-1]) & (args[-1] < maximum_iterations)
+
+        def _body(args):
+            outputs = body(*args[:-1])
+            outputs = tuple(outputs) if is_tuple else (outputs,)
+            return outputs + (args[-1] + 1,)
+
+    else:
+
+        def _cond(args):
+            return cond(*args)
+
+        def _body(args):
+            outputs = body(*args)
+            return tuple(outputs) if is_tuple else (outputs,)
+
+    outputs = jax.lax.while_loop(_cond, _body, loop_vars)
+    if maximum_iterations is not None:
+        outputs = outputs[:-1]
+    return outputs if is_tuple else outputs[0]
+
+
+def fori_loop(lower, upper, body_fun, init_val):
+    return jax.lax.fori_loop(lower, upper, body_fun, init_val)
+
+
+def stop_gradient(variable):
+    if isinstance(variable, Variable):
+        variable = variable.value
+    return jax.lax.stop_gradient(variable)
+
+
+def unstack(x, num=None, axis=0):
+    return [
+        jax.lax.index_in_dim(x, i, axis, keepdims=False)
+        for i in range(x.shape[axis])
+    ]
+
+
+def random_seed_dtype():
+    # jax random seed uses uint32.
+    return "uint32"
+
+
+def custom_gradient(fun):
+    return jax.custom_gradient(fun=fun)
+
+
+class name_scope(base_name_scope):
+    def __init__(self, name, **kwargs):
+        super().__init__(name, **kwargs)
+        self._jax_name_scope = jax.named_scope(name)
+
+    def __enter__(self):
+        name_scope_stack = global_state.get_global_attribute(
+            "name_scope_stack", default=[], set_to_default=True
+        )
+        if self.deduplicate and name_scope_stack:
+            parent_caller = name_scope_stack[-1].caller
+            parent_name = name_scope_stack[-1].name
+            if (
+                self.caller is not None
+                and self.caller is parent_caller
+                and self.name == parent_name
+            ):
+                return self
+        name_scope_stack.append(self)
+        self._pop_on_exit = True
+        self._jax_name_scope.__enter__()
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        super().__exit__(*args, **kwargs)
+        if self._pop_on_exit:
+            self._jax_name_scope.__exit__(*args, **kwargs)
+
+
+def device_scope(device_name):
+    if isinstance(device_name, str):
+        # We support string value like "cpu:0", "gpu:1", etc.
+        device_name = device_name.lower()
+        jax_device = distribution_lib._to_jax_device(device_name)
+    elif not isinstance(device_name, jax.Device):
+        raise ValueError(
+            "Invalid value for argument `device_name`. "
+            "Expected a string like 'gpu:0' or a `jax.Device` instance. "
+            f"Received: device_name='{device_name}'"
+        )
+    else:
+        jax_device = device_name
+    return jax.default_device(jax_device)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/distribution_lib.py

@@ -0,0 +1,265 @@
+"""Utilities for distribution strategy with JAX backend."""
+
+import jax
+import numpy as np
+
+from keras.src.utils import jax_utils
+
+
+def list_devices(device_type=None):
+    """Return all the available devices based on the device type.
+
+    Note that this should return the global devices in a distributed setting.
+
+    Args:
+        device_type: string of `"cpu"`, `"gpu"` or `"tpu"`. Defaults to `"gpu"`
+            or `"tpu"` if available when device_type is not provided. Otherwise
+            will return the `"cpu"` devices.
+
+    Return:
+        List of devices that are available for distribute computation.
+    """
+    device_type = device_type.lower() if device_type else None
+    jax_devices = jax.devices(backend=device_type)
+    return [f"{device.platform}:{device.id}" for device in jax_devices]
+
+
+def distribute_variable(value, layout):
+    """Create a distributed variable for JAX.
+
+    Since JAX doesn't have a variable class, this will just return a `jax.Array`
+    with the corresponding layout/sharding specified.
+
+    Note that this function should be used in eager context, not in jitted
+    function.
+
+    Args:
+        value: the initial value of the variable.
+        layout: `TensorLayout` for the created variable, or a
+            `jax.sharding.Sharding` instance.
+
+    Returns:
+        jax.Array which is the distributed variable.
+    """
+    if not isinstance(layout, jax.sharding.Sharding):
+        layout = _to_jax_layout(layout)
+    if isinstance(
+        value, (jax.Array, jax.numpy.ndarray)
+    ) and value.sharding.is_equivalent_to(layout, ndim=len(value.shape)):
+        # Skip the relayout if the value is already having the proper sharding
+        return value
+
+    if layout.is_fully_addressable:
+        return jax.device_put(value, layout)
+    else:
+        # Need to only distribute the value to local addressable devices, and
+        # repack them back into global format.
+        mapping = layout.addressable_devices_indices_map(value.shape)
+        local_values = jax.device_put(
+            [value[i] for i in mapping.values()], list(mapping.keys())
+        )
+        global_value = jax.make_array_from_single_device_arrays(
+            value.shape, layout, local_values
+        )
+        return global_value
+
+
+def distribute_tensor(tensor, layout):
+    """Distribute the tensor based on the layout.
+
+    Note that this function can be used both in eager context, or within a
+    jitted function.
+
+    Args:
+        tensor: `jax.Array` that need to be distributed.
+        layout: `TensorLayout` for the distribution information, or a
+            `jax.sharding.Sharding` instance.
+
+    Returns:
+        Distributed value.
+    """
+    if not isinstance(layout, jax.sharding.Sharding):
+        layout = _to_jax_layout(layout)
+    # TODO(scottzhu): This might not be a cheap check, we should consider
+    # have some proper JAX API for doing this check.
+    if jax_utils.is_in_jax_tracing_scope():
+        return jax.lax.with_sharding_constraint(tensor, layout)
+
+    if layout.is_fully_addressable:
+        return jax.device_put(tensor, layout)
+    else:
+        # Need to only distribute the value to local addressable devices, and
+        # repack them back into global format.
+        mapping = layout.addressable_devices_indices_map(tensor.shape)
+        local_values = jax.device_put(
+            [tensor[i] for i in mapping.values()], list(mapping.keys())
+        )
+        global_value = jax.make_array_from_single_device_arrays(
+            tensor.shape, layout, local_values
+        )
+        return global_value
+
+
+def distribute_data_input(per_process_batch, layout, batch_dim_name):
+    """Distribute the input data with the corresponding layout.
+
+    Note that the inputs here is a local worker batch. Within the local worker,
+    the data need to be further partitioned to map to the each of the devices.
+
+    Args:
+        inputs: `jax.Array` that is already sharded to a local process size.
+        layout: `TensorLayout` for the distribution information, or a
+            `jax.sharding.Sharding` instance.
+
+    Returns:
+        A global batch distributed according to `layout`.
+    """
+    if not isinstance(layout, jax.sharding.Sharding):
+        layout = _to_jax_layout(layout)
+
+    num_model_replicas_total = layout.mesh.shape[batch_dim_name]
+
+    mesh_model_dim_size = 1
+    for name, dim_size in layout.mesh.shape.items():
+        if not name == batch_dim_name:
+            mesh_model_dim_size *= dim_size
+
+    num_model_replicas_per_process = num_model_replicas_total / num_processes()
+    per_process_batch_size = per_process_batch.shape[0]
+
+    if num_model_replicas_per_process >= 1:
+        # If there is more than one model replica per process, we need to
+        # further shard the data to each of the model replicas.
+        if num_model_replicas_total % num_processes() != 0:
+            raise ValueError(
+                "If there is more than one replica per process, the batch "
+                "dimension of the mesh should be divisible "
+                "by the number of processes. Here, "
+                f"batch dimension = {num_model_replicas_total}, while "
+                f"number of processes = {num_processes()}"
+            )
+
+        per_replica_batch_size = int(
+            per_process_batch_size // num_model_replicas_per_process
+        )
+        if per_process_batch_size % per_replica_batch_size != 0:
+            raise ValueError(
+                "`per_process_batch_size` should be divisible by `"
+                "per_replica_batch_size`. "
+                f"per_process_batch_size={per_process_batch_size} and "
+                f"per_replica_batch_size = {per_replica_batch_size}"
+            )
+        per_replica_batches = np.split(
+            per_process_batch, num_model_replicas_per_process
+        )
+        # Replicate data along the model_dim.
+        per_device_batches = [
+            per_replica_batch
+            for per_replica_batch in per_replica_batches
+            for _ in range(mesh_model_dim_size)
+        ]
+        batches_on_devices = [
+            jax.device_put(batch, device)
+            for batch, device in zip(
+                per_device_batches, layout.addressable_devices
+            )
+        ]
+    else:
+        # If there are less than one model replicas per process, we need to
+        # replicate the data to each of the model replicas. No further data
+        # sharding is needed.
+        per_replica_batch_size = per_process_batch_size
+        batches_on_devices = [
+            jax.device_put(per_process_batch, device)
+            for device in layout.addressable_devices
+        ]
+
+    global_batch_size = per_replica_batch_size * num_model_replicas_total
+    global_batch_shape = (global_batch_size,) + per_process_batch.shape[1:]
+    global_batch_array = jax.make_array_from_single_device_arrays(
+        shape=global_batch_shape,
+        sharding=layout,
+        arrays=batches_on_devices,
+    )
+
+    return global_batch_array
+
+
+def initialize(job_addresses, num_processes, process_id):
+    if job_addresses and "," in job_addresses:
+        # When user provide all the job addresses, we will split and get the
+        # first one, which is the coordinator.
+        job_addresses = job_addresses.split(",")
+        # Do a sanity check to make sure the number of addresses also match
+        # the num_processes.
+        if num_processes is not None and num_processes != len(job_addresses):
+            raise ValueError(
+                f"The provided job_addresses {job_addresses} has "
+                f"{len(job_addresses)} jobs, but num_processes is "
+                f"{num_processes}"
+            )
+        coordinator_address = job_addresses[0]
+    else:
+        coordinator_address = job_addresses
+
+    jax.distributed.initialize(
+        coordinator_address=coordinator_address,
+        num_processes=num_processes,
+        process_id=process_id,
+    )
+
+
+def num_processes():
+    """Return the number of processes for the current distribution setting."""
+    return jax.process_count()
+
+
+def process_id():
+    """Return the current process ID for the distribution setting."""
+    return jax.process_index()
+
+
+def _to_jax_device(device_name):
+    if isinstance(device_name, jax.Device):
+        return device_name
+    device_type, device_id = device_name.split(":")
+
+    devices = jax.devices(backend=device_type)
+    for device in devices:
+        if device.platform == device_type and device.id == int(device_id):
+            return device
+    raise ValueError(f"Device not found: {device_name}")
+
+
+def _to_jax_mesh(device_mesh):
+    """Convert the DeviceMesh to JAX backend specific Mesh.
+
+    Args:
+        device_mesh: DeviceMesh instance to convert.
+
+    Returns:
+        A `jax.sharding.Mesh` instance.
+    """
+    shape = device_mesh.devices.shape
+    devices = [_to_jax_device(d) for d in device_mesh.devices.flatten()]
+    devices = np.array(devices).reshape(shape)
+    return jax.sharding.Mesh(devices, device_mesh.axis_names)
+
+
+def _to_jax_layout(tensor_layout):
+    """Convert the TensorLayout to JAX backend specific Sharding.
+
+    Args:
+        tensor_layout: TensorLayout instance to convert.
+
+    Returns:
+        A `jax.sharding.NamedSharding` instance.
+    """
+    if tensor_layout.device_mesh is None:
+        raise ValueError(
+            "Cannot create sharding when device mesh is not set "
+            "for TensorLayout."
+        )
+    partition_spec = jax.sharding.PartitionSpec(*tensor_layout.axes)
+    jax_mesh = _to_jax_mesh(tensor_layout.device_mesh)
+    return jax.sharding.NamedSharding(jax_mesh, partition_spec)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/linalg.py

@@ -0,0 +1,89 @@
+import jax
+import jax.numpy as jnp
+import jax.scipy as jsp
+
+from keras.src.backend import config
+from keras.src.backend import standardize_dtype
+from keras.src.backend.common import dtypes
+from keras.src.backend.jax.core import cast
+from keras.src.backend.jax.core import convert_to_tensor
+
+
+def cholesky(a):
+    out = jnp.linalg.cholesky(a)
+    try:
+        # In eager mode, raise for nan to
+        # achieve behavior consistency with numpy
+        if jnp.any(jnp.isnan(out)):
+            raise ValueError(
+                "Cholesky decomposition failed. "
+                "The input might not be a valid "
+                "positive definite matrix."
+            )
+    except jax.errors.TracerBoolConversionError:
+        # Cannot raise for nan in tracing mode
+        pass
+    return out
+
+
+def det(a):
+    return jnp.linalg.det(a)
+
+
+def eig(x):
+    return jnp.linalg.eig(x)
+
+
+def eigh(x):
+    return jnp.linalg.eigh(x)
+
+
+def inv(a):
+    return jnp.linalg.inv(a)
+
+
+def lu_factor(x):
+    lu_factor_fn = jsp.linalg.lu_factor
+    if x.ndim > 2:
+        for i in range(x.ndim - 2):
+            lu_factor_fn = jax.vmap(lu_factor_fn)
+
+    return lu_factor_fn(x)
+
+
+def norm(x, ord=None, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims)
+
+
+def qr(x, mode="reduced"):
+    if mode not in {"reduced", "complete"}:
+        raise ValueError(
+            "`mode` argument value not supported. "
+            "Expected one of {'reduced', 'complete'}. "
+            f"Received: mode={mode}"
+        )
+    return jnp.linalg.qr(x, mode=mode)
+
+
+def solve(a, b):
+    return jnp.linalg.solve(a, b)
+
+
+def solve_triangular(a, b, lower=False):
+    return jsp.linalg.solve_triangular(a, b, lower=lower)
+
+
+def svd(x, full_matrices=True, compute_uv=True):
+    return jnp.linalg.svd(x, full_matrices=full_matrices, compute_uv=compute_uv)
+
+
+def lstsq(a, b, rcond=None):
+    a = convert_to_tensor(a)
+    b = convert_to_tensor(b)
+    return jnp.linalg.lstsq(a, b, rcond=rcond)[0]

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/math.py

@@ -0,0 +1,298 @@
+import math
+
+import jax
+import jax.numpy as jnp
+
+from keras.src.backend import config
+from keras.src.backend import standardize_dtype
+from keras.src.backend.common import dtypes
+from keras.src.backend.jax.core import cast
+from keras.src.backend.jax.core import convert_to_tensor
+from keras.src.utils.module_utils import scipy
+
+
+def segment_sum(data, segment_ids, num_segments=None, sorted=False):
+    if num_segments is None:
+        raise ValueError(
+            "Argument `num_segments` must be set when using the JAX backend. "
+            "Received: num_segments=None"
+        )
+    return jax.ops.segment_sum(
+        data, segment_ids, num_segments, indices_are_sorted=sorted
+    )
+
+
+def segment_max(data, segment_ids, num_segments=None, sorted=False):
+    if num_segments is None:
+        raise ValueError(
+            "Argument `num_segments` must be set when using the JAX backend. "
+            "Received: num_segments=None"
+        )
+    return jax.ops.segment_max(
+        data, segment_ids, num_segments, indices_are_sorted=sorted
+    )
+
+
+def top_k(x, k, sorted=True):
+    # Jax does not supported `sorted`, but in the case where `sorted=False`,
+    # order is not guaranteed, so OK to return sorted output.
+    return jax.lax.top_k(x, k)
+
+
+def in_top_k(targets, predictions, k):
+    preds_at_label = jnp.take_along_axis(
+        predictions, jnp.expand_dims(targets, axis=-1), axis=-1
+    )
+    # `nan` shouldn't be considered as large probability.
+    preds_at_label = jnp.where(
+        jnp.isnan(preds_at_label), -jnp.inf, preds_at_label
+    )
+    rank = 1 + jnp.sum(jnp.greater(predictions, preds_at_label), axis=-1)
+    return jnp.less_equal(rank, k)
+
+
+def logsumexp(x, axis=None, keepdims=False):
+    return jax.scipy.special.logsumexp(x, axis=axis, keepdims=keepdims)
+
+
+def qr(x, mode="reduced"):
+    if mode not in {"reduced", "complete"}:
+        raise ValueError(
+            "`mode` argument value not supported. "
+            "Expected one of {'reduced', 'complete'}. "
+            f"Received: mode={mode}"
+        )
+    return jnp.linalg.qr(x, mode=mode)
+
+
+def extract_sequences(x, sequence_length, sequence_stride):
+    *batch_shape, signal_length = x.shape
+    batch_shape = list(batch_shape)
+    x = jnp.reshape(x, (math.prod(batch_shape), signal_length, 1))
+    x = jax.lax.conv_general_dilated_patches(
+        x,
+        (sequence_length,),
+        (sequence_stride,),
+        "VALID",
+        dimension_numbers=("NTC", "OIT", "NTC"),
+    )
+    return jnp.reshape(x, (*batch_shape, *x.shape[-2:]))
+
+
+def _get_complex_tensor_from_tuple(x):
+    if not isinstance(x, (tuple, list)) or len(x) != 2:
+        raise ValueError(
+            "Input `x` should be a tuple of two tensors - real and imaginary."
+            f"Received: x={x}"
+        )
+    # `convert_to_tensor` does not support passing complex tensors. We separate
+    # the input out into real and imaginary and convert them separately.
+    real, imag = x
+    # Check shapes.
+    if real.shape != imag.shape:
+        raise ValueError(
+            "Input `x` should be a tuple of two tensors - real and imaginary."
+            "Both the real and imaginary parts should have the same shape. "
+            f"Received: x[0].shape = {real.shape}, x[1].shape = {imag.shape}"
+        )
+    # Ensure dtype is float.
+    if not jnp.issubdtype(real.dtype, jnp.floating) or not jnp.issubdtype(
+        imag.dtype, jnp.floating
+    ):
+        raise ValueError(
+            "At least one tensor in input `x` is not of type float."
+            f"Received: x={x}."
+        )
+    complex_input = jax.lax.complex(real, imag)
+    return complex_input
+
+
+def fft(x):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    complex_output = jnp.fft.fft(complex_input)
+    return jnp.real(complex_output), jnp.imag(complex_output)
+
+
+def fft2(x):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    complex_output = jnp.fft.fft2(complex_input)
+    return jnp.real(complex_output), jnp.imag(complex_output)
+
+
+def ifft2(x):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    complex_output = jnp.fft.ifft2(complex_input)
+    return jnp.real(complex_output), jnp.imag(complex_output)
+
+
+def rfft(x, fft_length=None):
+    complex_output = jnp.fft.rfft(x, n=fft_length, axis=-1, norm="backward")
+    return jnp.real(complex_output), jnp.imag(complex_output)
+
+
+def irfft(x, fft_length=None):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    return jnp.fft.irfft(complex_input, n=fft_length, axis=-1, norm="backward")
+
+
+def stft(
+    x, sequence_length, sequence_stride, fft_length, window="hann", center=True
+):
+    if standardize_dtype(x.dtype) not in {"float32", "float64"}:
+        raise TypeError(
+            "Invalid input type. Expected `float32` or `float64`. "
+            f"Received: input type={x.dtype}"
+        )
+    if fft_length < sequence_length:
+        raise ValueError(
+            "`fft_length` must equal or larger than `sequence_length`. "
+            f"Received: sequence_length={sequence_length}, "
+            f"fft_length={fft_length}"
+        )
+    if isinstance(window, str):
+        if window not in {"hann", "hamming"}:
+            raise ValueError(
+                "If a string is passed to `window`, it must be one of "
+                f'`"hann"`, `"hamming"`. Received: window={window}'
+            )
+    x = convert_to_tensor(x)
+
+    if center:
+        pad_width = [(0, 0) for _ in range(len(x.shape))]
+        pad_width[-1] = (fft_length // 2, fft_length // 2)
+        x = jnp.pad(x, pad_width, mode="reflect")
+
+    l_pad = (fft_length - sequence_length) // 2
+    r_pad = fft_length - sequence_length - l_pad
+
+    if window is not None:
+        if isinstance(window, str):
+            win = convert_to_tensor(
+                scipy.signal.get_window(window, sequence_length), dtype=x.dtype
+            )
+        else:
+            win = convert_to_tensor(window, dtype=x.dtype)
+        if len(win.shape) != 1 or win.shape[-1] != sequence_length:
+            raise ValueError(
+                "The shape of `window` must be equal to [sequence_length]."
+                f"Received: window shape={win.shape}"
+            )
+        win = jnp.pad(win, [[l_pad, r_pad]])
+    else:
+        win = jnp.ones((sequence_length + l_pad + r_pad), dtype=x.dtype)
+
+    result = jax.scipy.signal.stft(
+        x,
+        fs=1.0,
+        window=win,
+        nperseg=(sequence_length + l_pad + r_pad),
+        noverlap=(sequence_length + l_pad + r_pad - sequence_stride),
+        nfft=fft_length,
+        boundary=None,
+        padded=False,
+    )[-1]
+    # scale and swap to (..., num_sequences, fft_bins)
+    scale = jnp.sqrt(1.0 / win.sum() ** 2)
+    result = result / scale
+    result = jnp.swapaxes(result, -2, -1)
+    return jnp.real(result), jnp.imag(result)
+
+
+def istft(
+    x,
+    sequence_length,
+    sequence_stride,
+    fft_length,
+    length=None,
+    window="hann",
+    center=True,
+):
+    x = _get_complex_tensor_from_tuple(x)
+    dtype = jnp.real(x).dtype
+
+    if len(x.shape) < 2:
+        raise ValueError(
+            f"Input `x` must have at least 2 dimensions. "
+            f"Received shape: {x.shape}"
+        )
+
+    expected_output_len = fft_length + sequence_stride * (x.shape[-2] - 1)
+    l_pad = (fft_length - sequence_length) // 2
+    r_pad = fft_length - sequence_length - l_pad
+
+    if window is not None:
+        if isinstance(window, str):
+            win = convert_to_tensor(
+                scipy.signal.get_window(window, sequence_length), dtype=dtype
+            )
+        else:
+            win = convert_to_tensor(window, dtype=dtype)
+        if len(win.shape) != 1 or win.shape[-1] != sequence_length:
+            raise ValueError(
+                "The shape of `window` must be equal to [sequence_length]."
+                f"Received: window shape={win.shape}"
+            )
+        win = jnp.pad(win, [[l_pad, r_pad]])
+    else:
+        win = jnp.ones((sequence_length + l_pad + r_pad), dtype=dtype)
+
+    x = jax.scipy.signal.istft(
+        x,
+        fs=1.0,
+        window=win,
+        nperseg=(sequence_length + l_pad + r_pad),
+        noverlap=(sequence_length + l_pad + r_pad - sequence_stride),
+        nfft=fft_length,
+        boundary=False,
+        time_axis=-2,
+        freq_axis=-1,
+    )[-1]
+
+    # scale
+    x = x / win.sum() if window is not None else x / sequence_stride
+
+    start = 0 if center is False else fft_length // 2
+    if length is not None:
+        end = start + length
+    elif center is True:
+        end = -(fft_length // 2)
+    else:
+        end = expected_output_len
+    return x[..., start:end]
+
+
+def rsqrt(x):
+    return jax.lax.rsqrt(x)
+
+
+def erf(x):
+    return jax.lax.erf(x)
+
+
+def erfinv(x):
+    return jax.lax.erf_inv(x)
+
+
+def solve(a, b):
+    a = convert_to_tensor(a)
+    b = convert_to_tensor(b)
+    return jnp.linalg.solve(a, b)
+
+
+def norm(x, ord=None, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims)
+
+
+def logdet(x):
+    from keras.src.backend.jax.numpy import slogdet
+
+    # In JAX (like in NumPy) slogdet is more stable than
+    # `np.log(np.linalg.det(x))`. See
+    # https://numpy.org/doc/stable/reference/generated/numpy.linalg.slogdet.html
+    return slogdet(x)[1]

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/nn.py

@@ -0,0 +1,1197 @@
+import builtins
+import math
+
+import jax
+import jax.experimental.sparse as jax_sparse
+import jax.numpy as jnp
+from jax import lax
+from jax import nn as jnn
+from jax.experimental.pallas.ops.tpu import (
+    flash_attention as flash_attention_tpu,
+)
+
+from keras.src import backend
+from keras.src.backend.common.backend_utils import (
+    compute_conv_transpose_padding_args_for_jax,
+)
+from keras.src.backend.jax.core import cast
+from keras.src.backend.jax.core import convert_to_tensor
+
+
+def relu(x):
+    x = convert_to_tensor(x)
+    return jnn.relu(x)
+
+
+def relu6(x):
+    x = convert_to_tensor(x)
+    return jnn.relu6(x)
+
+
+def sigmoid(x):
+    x = convert_to_tensor(x)
+    return jnn.sigmoid(x)
+
+
+def tanh(x):
+    x = convert_to_tensor(x)
+    return jnn.tanh(x)
+
+
+def tanh_shrink(x):
+    x = convert_to_tensor(x)
+    return x - jnp.tanh(x)
+
+
+def softplus(x):
+    x = convert_to_tensor(x)
+    return jnn.softplus(x)
+
+
+def softsign(x):
+    x = convert_to_tensor(x)
+    return jnn.soft_sign(x)
+
+
+def soft_shrink(x, threshold=0.5):
+    x = convert_to_tensor(x)
+    return jnp.where(
+        x > threshold,
+        x - threshold,
+        jnp.where(x < -threshold, x + threshold, 0.0),
+    )
+
+
+def sparse_plus(x):
+    x = convert_to_tensor(x)
+    return jnn.sparse_plus(x)
+
+
+def silu(x):
+    x = convert_to_tensor(x)
+    return jnn.silu(x)
+
+
+def squareplus(x, b=4):
+    x = convert_to_tensor(x)
+    return jnn.squareplus(x, b=b)
+
+
+def log_sigmoid(x):
+    x = convert_to_tensor(x)
+    return jnn.log_sigmoid(x)
+
+
+def leaky_relu(x, negative_slope=0.2):
+    x = convert_to_tensor(x)
+    return jnn.leaky_relu(x, negative_slope=negative_slope)
+
+
+def hard_sigmoid(x):
+    x = convert_to_tensor(x)
+    return jnn.hard_sigmoid(x)
+
+
+def hard_silu(x):
+    x = convert_to_tensor(x)
+    return jnn.hard_silu(x)
+
+
+def elu(x, alpha=1.0):
+    x = convert_to_tensor(x)
+    return jnn.elu(x, alpha=alpha)
+
+
+def selu(x):
+    x = convert_to_tensor(x)
+    return jnn.selu(x)
+
+
+def gelu(x, approximate=True):
+    x = convert_to_tensor(x)
+    return jnn.gelu(x, approximate)
+
+
+def celu(x, alpha=1.0):
+    x = convert_to_tensor(x)
+    return jnn.celu(x, alpha=alpha)
+
+
+def glu(x, axis=-1):
+    x = convert_to_tensor(x)
+    return jnn.glu(x, axis=axis)
+
+
+def hard_tanh(x):
+    x = convert_to_tensor(x)
+    return jnn.hard_tanh(x)
+
+
+def hard_shrink(x, threshold=0.5):
+    x = convert_to_tensor(x)
+    return jnp.where(jnp.abs(x) > threshold, x, 0.0)
+
+
+def threshold(x, threshold, default_value):
+    x = convert_to_tensor(x)
+    return jnp.where(x > threshold, x, default_value)
+
+
+def softmax(x, axis=-1):
+    x = convert_to_tensor(x)
+    return jnn.softmax(x, axis=axis)
+
+
+def log_softmax(x, axis=-1):
+    x = convert_to_tensor(x)
+    return jnn.log_softmax(x, axis=axis)
+
+
+def sparsemax(logits, axis=-1):
+    # Sort logits along the specified axis in descending order
+    logits = convert_to_tensor(logits)
+    logits_sorted = -1.0 * jnp.sort(logits * -1.0, axis=axis)
+    logits_cumsum = jnp.cumsum(logits_sorted, axis=axis)  # find cumulative sum
+    r = jnp.arange(1, logits.shape[axis] + 1)  # Determine the sparsity
+    r_shape = [1] * logits.ndim
+    r_shape[axis] = -1  # Broadcast to match the target axis
+    r = r.reshape(r_shape)
+    support = logits_sorted - (logits_cumsum - 1) / r > 0
+    # Find the threshold
+    k = jnp.sum(support, axis=axis, keepdims=True)
+    logits_cumsum_safe = jnp.where(support, logits_cumsum, 0.0)
+    tau = (jnp.sum(logits_cumsum_safe, axis=axis, keepdims=True) - 1) / k
+    output = jnp.maximum(logits - tau, 0.0)
+    return output
+
+
+def _convert_to_spatial_operand(
+    x,
+    num_spatial_dims,
+    data_format="channels_last",
+    include_batch_and_channels=True,
+):
+    # Helper function that converts an operand to a spatial operand.
+    x = (x,) * num_spatial_dims if isinstance(x, int) else x
+    if not include_batch_and_channels:
+        return x
+    if data_format == "channels_last":
+        x = (1,) + x + (1,)
+    else:
+        x = (1,) + (1,) + x
+    return x
+
+
+def _pool(
+    inputs,
+    initial_value,
+    reduce_fn,
+    pool_size,
+    strides=None,
+    padding="valid",
+):
+    """Helper function to define pooling functions.
+
+    Args:
+        inputs: input data of shape `N+2`.
+        initial_value: the initial value for the reduction.
+        reduce_fn: a reduce function of the form `(T, T) -> T`.
+        pool_size: a sequence of `N` integers, representing the window size to
+            reduce over.
+        strides: a sequence of `N` integers, representing the inter-window
+            strides (default: `(1, ..., 1)`).
+        padding: either the string `same` or `valid`.
+
+    Returns:
+        The output of the reduction for each window slice.
+    """
+    if padding not in ("same", "valid"):
+        raise ValueError(
+            f"Invalid padding '{padding}', must be 'same' or 'valid'."
+        )
+    padding = padding.upper()
+    return lax.reduce_window(
+        inputs,
+        initial_value,
+        reduce_fn,
+        pool_size,
+        strides,
+        padding,
+    )
+
+
+def max_pool(
+    inputs,
+    pool_size,
+    strides=None,
+    padding="valid",
+    data_format=None,
+):
+    data_format = backend.standardize_data_format(data_format)
+    num_spatial_dims = inputs.ndim - 2
+    pool_size = _convert_to_spatial_operand(
+        pool_size, num_spatial_dims, data_format
+    )
+    strides = pool_size if strides is None else strides
+    strides = _convert_to_spatial_operand(
+        strides, num_spatial_dims, data_format
+    )
+    return _pool(inputs, -jnp.inf, lax.max, pool_size, strides, padding)
+
+
+def average_pool(
+    inputs,
+    pool_size,
+    strides,
+    padding,
+    data_format=None,
+):
+    data_format = backend.standardize_data_format(data_format)
+    num_spatial_dims = inputs.ndim - 2
+    pool_size = _convert_to_spatial_operand(
+        pool_size, num_spatial_dims, data_format
+    )
+    strides = pool_size if strides is None else strides
+    strides = _convert_to_spatial_operand(
+        strides, num_spatial_dims, data_format
+    )
+
+    pooled = _pool(inputs, 0.0, lax.add, pool_size, strides, padding)
+    if padding == "valid":
+        # Avoid the extra reduce_window.
+        return pooled / math.prod(pool_size)
+    else:
+        # Count the number of valid entries at each input point, then use that
+        # for computing average. Assumes that any two arrays of same shape will
+        # be padded the same. Avoid broadcasting on axis where pooling is
+        # skipped.
+        shape = [
+            (a if b != 1 else 1) for (a, b) in zip(inputs.shape, pool_size)
+        ]
+        window_counts = _pool(
+            jnp.ones(shape, inputs.dtype),
+            0.0,
+            lax.add,
+            pool_size,
+            strides,
+            padding,
+        )
+        return pooled / window_counts
+
+
+def _convert_to_lax_conv_dimension_numbers(
+    num_spatial_dims,
+    data_format="channels_last",
+    transpose=False,
+):
+    """Create a `lax.ConvDimensionNumbers` for the given inputs."""
+    num_dims = num_spatial_dims + 2
+
+    if data_format == "channels_last":
+        spatial_dims = tuple(range(1, num_dims - 1))
+        inputs_dn = (0, num_dims - 1) + spatial_dims
+    else:
+        spatial_dims = tuple(range(2, num_dims))
+        inputs_dn = (0, 1) + spatial_dims
+
+    if transpose:
+        kernel_dn = (num_dims - 2, num_dims - 1) + tuple(range(num_dims - 2))
+    else:
+        kernel_dn = (num_dims - 1, num_dims - 2) + tuple(range(num_dims - 2))
+
+    return lax.ConvDimensionNumbers(
+        lhs_spec=inputs_dn, rhs_spec=kernel_dn, out_spec=inputs_dn
+    )
+
+
+def conv(
+    inputs,
+    kernel,
+    strides=1,
+    padding="valid",
+    data_format=None,
+    dilation_rate=1,
+):
+    data_format = backend.standardize_data_format(data_format)
+    num_spatial_dims = inputs.ndim - 2
+    dimension_numbers = _convert_to_lax_conv_dimension_numbers(
+        num_spatial_dims,
+        data_format,
+        transpose=False,
+    )
+    strides = _convert_to_spatial_operand(
+        strides,
+        num_spatial_dims,
+        data_format,
+        include_batch_and_channels=False,
+    )
+    dilation_rate = _convert_to_spatial_operand(
+        dilation_rate,
+        num_spatial_dims,
+        data_format,
+        include_batch_and_channels=False,
+    )
+    if data_format == "channels_last":
+        channels = inputs.shape[-1]
+    else:
+        channels = inputs.shape[1]
+    kernel_in_channels = kernel.shape[-2]
+    if channels % kernel_in_channels > 0:
+        raise ValueError(
+            "The number of input channels must be evenly divisible by "
+            f"kernel's in_channels. Received input channels {channels} and "
+            f"kernel in_channels {kernel_in_channels}. "
+        )
+    feature_group_count = channels // kernel_in_channels
+    kernel = convert_to_tensor(kernel)
+    inputs = convert_to_tensor(inputs, dtype=kernel.dtype)
+    return jax.lax.conv_general_dilated(
+        inputs,
+        kernel,
+        strides,
+        padding,
+        rhs_dilation=dilation_rate,
+        dimension_numbers=dimension_numbers,
+        feature_group_count=feature_group_count,
+    )
+
+
+def depthwise_conv(
+    inputs,
+    kernel,
+    strides=1,
+    padding="valid",
+    data_format=None,
+    dilation_rate=1,
+):
+    data_format = backend.standardize_data_format(data_format)
+    num_spatial_dims = inputs.ndim - 2
+    dimension_numbers = _convert_to_lax_conv_dimension_numbers(
+        num_spatial_dims,
+        data_format,
+        transpose=False,
+    )
+    strides = _convert_to_spatial_operand(
+        strides,
+        num_spatial_dims,
+        data_format,
+        include_batch_and_channels=False,
+    )
+    dilation_rate = _convert_to_spatial_operand(
+        dilation_rate,
+        num_spatial_dims,
+        data_format,
+        include_batch_and_channels=False,
+    )
+    feature_group_count = (
+        inputs.shape[-1] if data_format == "channels_last" else inputs.shape[1]
+    )
+    kernel = jnp.reshape(
+        kernel,
+        kernel.shape[:-2] + (1, feature_group_count * kernel.shape[-1]),
+    )
+    return jax.lax.conv_general_dilated(
+        inputs,
+        kernel,
+        strides,
+        padding,
+        rhs_dilation=dilation_rate,
+        dimension_numbers=dimension_numbers,
+        feature_group_count=feature_group_count,
+    )
+
+
+def separable_conv(
+    inputs,
+    depthwise_kernel,
+    pointwise_kernel,
+    strides=1,
+    padding="valid",
+    data_format=None,
+    dilation_rate=1,
+):
+    data_format = backend.standardize_data_format(data_format)
+    depthwise_conv_output = depthwise_conv(
+        inputs,
+        depthwise_kernel,
+        strides,
+        padding,
+        data_format,
+        dilation_rate,
+    )
+    return conv(
+        depthwise_conv_output,
+        pointwise_kernel,
+        strides=1,
+        padding="valid",
+        data_format=data_format,
+        dilation_rate=dilation_rate,
+    )
+
+
+def conv_transpose(
+    inputs,
+    kernel,
+    strides=1,
+    padding="valid",
+    output_padding=None,
+    data_format=None,
+    dilation_rate=1,
+):
+    data_format = backend.standardize_data_format(data_format)
+    num_spatial_dims = inputs.ndim - 2
+    padding_values = compute_conv_transpose_padding_args_for_jax(
+        input_shape=inputs.shape,
+        kernel_shape=kernel.shape,
+        strides=strides,
+        padding=padding,
+        output_padding=output_padding,
+        dilation_rate=dilation_rate,
+    )
+    dimension_numbers = _convert_to_lax_conv_dimension_numbers(
+        num_spatial_dims,
+        data_format,
+        transpose=False,
+    )
+    strides = _convert_to_spatial_operand(
+        strides,
+        num_spatial_dims,
+        data_format,
+        include_batch_and_channels=False,
+    )
+    dilation_rate = _convert_to_spatial_operand(
+        dilation_rate,
+        num_spatial_dims,
+        data_format,
+        include_batch_and_channels=False,
+    )
+
+    return jax.lax.conv_transpose(
+        inputs,
+        kernel,
+        strides,
+        padding=padding_values,
+        rhs_dilation=dilation_rate,
+        dimension_numbers=dimension_numbers,
+        transpose_kernel=True,
+    )
+
+
+def one_hot(x, num_classes, axis=-1, dtype="float32", sparse=False):
+    x = convert_to_tensor(x)
+    if sparse:
+        if axis < 0:
+            axis = axis + len(x.shape) + 1
+        if dtype is None:
+            dtype = "float32"
+        # We deal with negative inputs by having zeros in the output although
+        # it's useless. It makes shapes static.
+        values = jnp.greater_equal(jnp.ravel(x), 0).astype(dtype)
+        values_count = values.shape[0]
+        indices = [jnp.arange(dim) for dim in x.shape]
+        indices = jnp.meshgrid(*indices, indexing="ij")
+        indices.insert(axis, jnp.maximum(x, 0))  # Deal with negative indices
+        indices = [a.reshape(values_count, 1).astype("int32") for a in indices]
+        indices = jnp.concatenate(indices, axis=1)
+        shape = list(x.shape)
+        shape.insert(axis, num_classes)
+        shape = tuple(shape)
+        return jax_sparse.BCOO(
+            (values, indices),
+            shape=shape,
+            indices_sorted=True,
+            unique_indices=True,
+        )
+    return jnn.one_hot(x, num_classes, axis=axis, dtype=dtype)
+
+
+def multi_hot(x, num_classes, axis=-1, dtype="float32", sparse=False):
+    x = convert_to_tensor(x)
+    reduction_axis = 1 if len(x.shape) > 1 else 0
+    if sparse:
+        result = one_hot(
+            x, num_classes, axis=axis, dtype="int32", sparse=sparse
+        )
+        # JAX's BCOO does not support max reduction, use sum and compare with 0.
+        result = jax_sparse.bcoo_reduce_sum(result, axes=(reduction_axis,))
+        result = jax_sparse.bcoo_sum_duplicates(result)
+        values = jnp.greater_equal(result.data, 0).astype(dtype)
+        return jax_sparse.BCOO(
+            (values, result.indices),
+            shape=result.shape,
+            indices_sorted=True,
+            unique_indices=True,
+        )
+    return jnp.max(
+        one_hot(cast(x, "int32"), num_classes, axis=axis, dtype=dtype),
+        axis=reduction_axis,
+    )
+
+
+def categorical_crossentropy(target, output, from_logits=False, axis=-1):
+    target = jnp.array(target)
+    output = jnp.array(output)
+
+    if target.shape != output.shape:
+        raise ValueError(
+            "Arguments `target` and `output` must have the same shape. "
+            "Received: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+    if len(target.shape) < 1:
+        raise ValueError(
+            "Arguments `target` and `output` must be at least rank 1. "
+            "Received: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+
+    if from_logits:
+        log_prob = jax.nn.log_softmax(output, axis=axis)
+    else:
+        output = output / jnp.sum(output, axis, keepdims=True)
+        output = jnp.clip(output, backend.epsilon(), 1.0 - backend.epsilon())
+        log_prob = jnp.log(output)
+    return -jnp.sum(target * log_prob, axis=axis)
+
+
+def sparse_categorical_crossentropy(target, output, from_logits=False, axis=-1):
+    target = jnp.array(target, dtype="int32")
+    output = jnp.array(output)
+    if len(target.shape) == len(output.shape) and target.shape[-1] == 1:
+        target = jnp.squeeze(target, axis=-1)
+
+    if len(output.shape) < 1:
+        raise ValueError(
+            "Argument `output` must be at least rank 1. "
+            "Received: "
+            f"output.shape={output.shape}"
+        )
+    if target.shape != output.shape[:-1]:
+        raise ValueError(
+            "Arguments `target` and `output` must have the same shape "
+            "up until the last dimension: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+    if from_logits:
+        log_prob = jax.nn.log_softmax(output, axis=axis)
+    else:
+        output = output / jnp.sum(output, axis, keepdims=True)
+        output = jnp.clip(output, backend.epsilon(), 1.0 - backend.epsilon())
+        log_prob = jnp.log(output)
+    target = jnn.one_hot(target, output.shape[axis], axis=axis)
+    return -jnp.sum(target * log_prob, axis=axis)
+
+
+def binary_crossentropy(target, output, from_logits=False):
+    target = jnp.array(target)
+    output = jnp.array(output)
+
+    if target.shape != output.shape:
+        raise ValueError(
+            "Arguments `target` and `output` must have the same shape. "
+            "Received: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+
+    if from_logits:
+        log_logits = jax.nn.log_sigmoid(output)
+        log_neg_logits = jax.nn.log_sigmoid(-output)
+        return -1.0 * target * log_logits - (1.0 - target) * log_neg_logits
+
+    output = jnp.clip(output, backend.epsilon(), 1.0 - backend.epsilon())
+    bce = target * jnp.log(output)
+    bce += (1.0 - target) * jnp.log(1.0 - output)
+    return -bce
+
+
+def moments(x, axes, keepdims=False, synchronized=False):
+    if synchronized:
+        raise NotImplementedError(
+            "Argument synchronized=True is not supported with JAX."
+        )
+    # The dynamic range of float16 is too limited for statistics. As a
+    # workaround, we simply perform the operations on float32 and convert back
+    # to float16
+    need_cast = False
+    ori_dtype = backend.standardize_dtype(x.dtype)
+    if ori_dtype in ("float16", "bfloat16"):
+        need_cast = True
+        x = cast(x, "float32")
+
+    mean = jnp.mean(x, axes, keepdims=True)
+    variance = jnp.var(x, axis=axes, keepdims=True)
+
+    if not keepdims:
+        mean = jnp.squeeze(mean, axes)
+        variance = jnp.squeeze(variance, axes)
+    if need_cast:
+        # avoid overflow and underflow when casting from float16 to float32
+        mean = jnp.clip(
+            mean, jnp.finfo(jnp.float16).min, jnp.finfo(jnp.float16).max
+        )
+        variance = jnp.clip(
+            variance, jnp.finfo(jnp.float16).min, jnp.finfo(jnp.float16).max
+        )
+        mean = cast(mean, ori_dtype)
+        variance = cast(variance, ori_dtype)
+    return mean, variance
+
+
+def batch_normalization(
+    x, mean, variance, axis, offset=None, scale=None, epsilon=1e-3
+):
+    shape = [1] * len(x.shape)
+    shape[axis] = mean.shape[0]
+    mean = jnp.reshape(mean, shape)
+    variance = jnp.reshape(variance, shape)
+
+    inv = jax.lax.rsqrt(variance + epsilon)
+    if scale is not None:
+        scale = jnp.reshape(scale, shape)
+        inv = inv * scale
+
+    res = -mean * inv
+    if offset is not None:
+        offset = jnp.reshape(offset, shape)
+        res = res + offset
+
+    return jnp.add(x * inv, res)
+
+
+def ctc_loss(target, output, target_length, output_length, mask_index=0):
+    # Ref: https://github.com/google-deepmind/optax
+    # optax.ctc_loss_with_forward_probs
+    target = convert_to_tensor(target, dtype="int32")
+    output = convert_to_tensor(output)
+    target_length = convert_to_tensor(target_length, "int32")
+    output_length = convert_to_tensor(output_length, "int32")
+    batch_size, max_input_length, num_classes = output.shape
+    batch_size, max_label_length = target.shape
+    log_epsilon = -1e5
+
+    # Ensure that the dtype promotion behavior matches that of `tf.nn.ctc_loss`
+    dtype = backend.result_type(output.dtype, "float32")
+    output = cast(output, dtype)
+
+    def _lengths_to_paddings(lengths, max_length):
+        indices = jnp.arange(max_length).reshape(
+            (1,) * lengths.ndim + (max_length,)
+        )
+        lengths = jnp.expand_dims(lengths, axis=-1)
+        elem_valid = indices < lengths
+        return jnp.logical_not(elem_valid)
+
+    target_paddings = _lengths_to_paddings(target_length, max_label_length)
+    output_paddings = _lengths_to_paddings(output_length, max_input_length)
+    target_paddings = target_paddings.astype(output.dtype)
+    output_paddings = output_paddings.astype(output.dtype)
+
+    logprobs = jnn.log_softmax(output)
+    label_lengths = max_label_length - jnp.sum(target_paddings, axis=1).astype(
+        jnp.int32
+    )
+
+    # repeat[b, n] == 1.0 when label[b, n] == label[b, n+1].
+    repeat = (target[:, :-1] == target[:, 1:]).astype(jnp.float32)
+    repeat = jnp.pad(repeat, ((0, 0), (0, 1)))
+
+    logprobs_phi = logprobs[:, :, mask_index : mask_index + 1]  # [B, T, 1]
+    logprobs_phi = jnp.transpose(logprobs_phi, (1, 0, 2))  # [T, B, 1]
+
+    _one_hot = jax.nn.one_hot(target, num_classes=num_classes)  # [B, N, K]
+    logprobs_emit = jnp.einsum("btk,bnk->btn", logprobs, _one_hot)
+    logprobs_emit = jnp.transpose(logprobs_emit, (1, 0, 2))  # [T, B, N]
+
+    # [B, N]
+    logalpha_phi_init = (
+        jnp.ones((batch_size, max_label_length + 1), dtype=output.dtype)
+        * log_epsilon
+    )
+    logalpha_phi_init = logalpha_phi_init.at[:, 0].set(0.0)
+    logalpha_emit_init = (
+        jnp.ones((batch_size, max_label_length), dtype=output.dtype)
+        * log_epsilon
+    )
+
+    def update_phi_score(phi, added_score):
+        # Update `phi[:, 1:]`` with adding `added_score` in log space.
+        return jnp.concatenate(
+            [phi[:, :1], jnp.logaddexp(phi[:, 1:], added_score)], axis=-1
+        )
+
+    def loop_body(prev, x):
+        prev_phi, prev_emit = prev
+        # emit-to-phi epsilon transition, except if the next label is repetition
+        prev_phi_orig = prev_phi
+        prev_phi = update_phi_score(prev_phi, prev_emit + log_epsilon * repeat)
+
+        logprob_emit, logprob_phi, pad = x
+
+        # phi-to-emit transition
+        next_emit = jnp.logaddexp(
+            prev_phi[:, :-1] + logprob_emit, prev_emit + logprob_emit
+        )
+        # self-loop transition
+        next_phi = prev_phi + logprob_phi
+        # emit-to-phi blank transition only when the next label is repetition
+        next_phi = update_phi_score(
+            next_phi, prev_emit + logprob_phi + log_epsilon * (1.0 - repeat)
+        )
+
+        pad = pad.reshape((batch_size, 1))
+        next_emit = pad * prev_emit + (1.0 - pad) * next_emit
+        next_phi = pad * prev_phi_orig + (1.0 - pad) * next_phi
+
+        return (next_phi, next_emit), (next_phi, next_emit)
+
+    xs = (logprobs_emit, logprobs_phi, output_paddings.transpose((1, 0)))
+    _, (logalpha_phi, logalpha_emit) = jax.lax.scan(
+        loop_body, (logalpha_phi_init, logalpha_emit_init), xs
+    )
+
+    # last row needs to be updated with the last epsilon transition
+    logalpha_phi_last = update_phi_score(logalpha_phi[-1], logalpha_emit[-1])
+    logalpha_phi = logalpha_phi.at[-1].set(logalpha_phi_last)
+
+    # extract per_seq_loss
+    # [B, N+1]
+    _one_hot = jax.nn.one_hot(label_lengths, num_classes=max_label_length + 1)
+    per_seq_loss = -jnp.einsum("bn,bn->b", logalpha_phi_last, _one_hot)
+    return per_seq_loss
+
+
+def _ctc_greedy_decode(
+    inputs,
+    sequence_lengths,
+    merge_repeated=True,
+    mask_index=None,
+):
+    inputs = convert_to_tensor(inputs)
+    sequence_lengths = convert_to_tensor(sequence_lengths, dtype="int32")
+    batch_size, max_length, num_classes = inputs.shape
+
+    if mask_index is None:
+        mask_index = num_classes - 1
+
+    indices = jnp.argmax(inputs, axis=-1)
+    scores = jnp.max(inputs, axis=-1)
+
+    seqlen_mask = jnp.arange(max_length)[None, :]
+    seqlen_mask = seqlen_mask >= sequence_lengths[:, None]
+
+    indices = jnp.where(seqlen_mask, mask_index, indices)
+    scores = jnp.where(seqlen_mask, 0.0, scores)
+
+    if merge_repeated:
+        repeat_mask = indices[:, 1:] == indices[:, :-1]
+        repeat_mask = jnp.pad(repeat_mask, ((0, 0), (1, 0)))
+        indices = jnp.where(repeat_mask, mask_index, indices)
+
+    # We set to -1 for blank labels
+    invalid_mask = indices == mask_index
+    indices = jnp.where(invalid_mask, -1, indices)
+
+    # We rearrange the indices by moving `mask_index` to the end of the array
+    order = jnp.expand_dims(jnp.arange(max_length), axis=0)  # [1, N]
+    order = jnp.tile(order, (batch_size, 1))  # [B, N]
+    order = jnp.where(invalid_mask, max_length, order)
+    order = jnp.argsort(order, axis=-1)
+    indices = jnp.take_along_axis(indices, order, axis=-1)
+
+    scores = -jnp.sum(scores, axis=1)[:, None]
+    indices = jnp.expand_dims(indices, axis=0)
+    return indices, scores
+
+
+def _ctc_beam_search_decode(
+    inputs,
+    sequence_lengths,
+    beam_width=100,
+    top_paths=1,
+    mask_index=None,
+):
+    inputs = convert_to_tensor(inputs)
+    sequence_lengths = convert_to_tensor(sequence_lengths)
+
+    batch_size, max_seq_len, num_classes = inputs.shape
+    inputs = jnn.log_softmax(inputs)
+    seqlen_mask = jnp.arange(max_seq_len)[None, :] >= sequence_lengths[:, None]
+
+    if mask_index is None:
+        mask_index = num_classes - 1
+
+    # This is a workaround for the fact that jnp.argsort does not support
+    # the order parameter which is used to break ties when scores are equal.
+    # For compatibility with the tensorflow implementation, we flip the inputs
+    # and the mask_index, and then flip the classes back to the correct indices
+    inputs = jnp.flip(inputs, axis=2)
+    mask_index = num_classes - mask_index - 1
+
+    _pad = -1
+
+    init_paths = jnp.full(
+        (batch_size, 2 * beam_width, max_seq_len), _pad, dtype=jnp.int32
+    )
+
+    num_init_paths = builtins.min(num_classes, beam_width)
+    max_classes = jnp.argsort(inputs[:, 0], axis=1)[:, -num_init_paths:]
+    init_classes = jnp.where(max_classes == mask_index, _pad, max_classes)
+    init_paths = init_paths.at[:, :num_init_paths, 0].set(init_classes)
+
+    init_scores = (
+        jnp.full((batch_size, 2 * beam_width), -jnp.inf, dtype=inputs.dtype)
+        .at[:, :num_init_paths]
+        .set(jnp.take_along_axis(inputs[:, 0], max_classes, axis=1))
+    )
+    init_masked = init_paths[:, :, 0] == _pad
+
+    def _extend_paths(paths, scores, masked, x):
+        paths = jnp.repeat(paths, num_classes, axis=0)
+        scores = jnp.repeat(scores, num_classes)
+        masked = jnp.repeat(masked, num_classes)
+
+        path_tail_index = jnp.argmax(paths == _pad, axis=1)
+        paths_arange = jnp.arange(2 * beam_width * num_classes)
+        path_tails = paths[paths_arange, path_tail_index - 1]
+        path_tails = jnp.where(path_tail_index == 0, _pad, path_tails)
+
+        classes = jnp.arange(num_classes).at[mask_index].set(_pad)
+        classes = jnp.tile(classes, 2 * beam_width)
+
+        prev_masked = masked
+        masked = classes == _pad
+
+        masked_repeat = ~prev_masked & (path_tails == classes)
+        classes = jnp.where(masked_repeat, _pad, classes)
+        paths = paths.at[paths_arange, path_tail_index].set(classes)
+
+        x = jnp.tile(x, 2 * beam_width)
+        scores = scores + x
+
+        return paths, scores, masked
+
+    def _merge_scores(unique_inverse, scores):
+        scores_max = jnp.max(scores)
+        scores_exp = jnp.exp(scores - scores_max)
+        scores = jnp.zeros_like(scores).at[unique_inverse].add(scores_exp)
+        scores = jnp.log(scores) + scores_max
+        return scores
+
+    def _prune_paths(paths, scores, masked):
+        paths, unique_inverse = jnp.unique(
+            paths,
+            return_inverse=True,
+            size=2 * num_classes * beam_width,
+            axis=0,
+            fill_value=_pad,
+        )
+        if len(unique_inverse.shape) >= 2:
+            unique_inverse = jnp.squeeze(unique_inverse, axis=1)
+
+        emit_scores = jnp.where(masked, -jnp.inf, scores)
+        mask_scores = jnp.where(masked, scores, -jnp.inf)
+
+        emit_scores = _merge_scores(unique_inverse, emit_scores)
+        mask_scores = _merge_scores(unique_inverse, mask_scores)
+
+        total_scores = jnp.logaddexp(emit_scores, mask_scores)
+        top_indices = jnp.argsort(total_scores)[-beam_width:]
+
+        paths = paths[top_indices]
+        emit_scores = emit_scores[top_indices]
+        mask_scores = mask_scores[top_indices]
+
+        paths = jnp.tile(paths, (2, 1))
+        scores = jnp.concatenate([emit_scores, mask_scores])
+        masked = jnp.concatenate(
+            [jnp.zeros(beam_width, bool), jnp.ones(beam_width, bool)]
+        )
+
+        return paths, scores, masked
+
+    def _decode_step(paths, scores, masked, x):
+        paths, scores, masked = _extend_paths(paths, scores, masked, x)
+        paths, scores, masked = _prune_paths(paths, scores, masked)
+        return paths, scores, masked
+
+    def _step(prev, x):
+        paths, scores, masked = prev
+        x, seqlen_mask = x
+
+        paths, scores, masked = lax.cond(
+            seqlen_mask,
+            lambda paths, scores, masked, x: (paths, scores, masked),
+            _decode_step,
+            paths,
+            scores,
+            masked,
+            x,
+        )
+
+        return (paths, scores, masked), None
+
+    def _decode_batch(
+        init_paths, init_scores, init_masked, inputs, seqlen_mask
+    ):
+        (paths, scores, masked), _ = lax.scan(
+            _step,
+            (init_paths, init_scores, init_masked),
+            (inputs[1:], seqlen_mask[1:]),
+        )
+
+        paths, unique_inverse = jnp.unique(
+            paths,
+            return_inverse=True,
+            size=2 * num_classes * beam_width,
+            axis=0,
+            fill_value=_pad,
+        )
+        if len(unique_inverse.shape) >= 2:
+            unique_inverse = jnp.squeeze(unique_inverse, axis=1)
+        scores = _merge_scores(unique_inverse, scores)
+
+        top_indices = jnp.argsort(scores)[-top_paths:][::-1]
+        paths = paths[top_indices]
+        scores = scores[top_indices]
+
+        return paths, scores
+
+    paths, scores = jax.vmap(_decode_batch)(
+        init_paths, init_scores, init_masked, inputs, seqlen_mask
+    )
+
+    # convert classes back to the correct indices
+    paths = jnp.where(paths == _pad, _pad, num_classes - paths - 1)
+    paths = jnp.transpose(paths, [1, 0, 2])
+    return paths, scores
+
+
+def ctc_decode(
+    inputs,
+    sequence_lengths,
+    strategy="greedy",
+    beam_width=100,
+    top_paths=1,
+    merge_repeated=True,
+    mask_index=0,
+):
+    inputs = convert_to_tensor(inputs)
+    dtype = backend.result_type(inputs.dtype, "float32")
+    inputs = cast(inputs, dtype)
+
+    if strategy == "greedy":
+        return _ctc_greedy_decode(
+            inputs,
+            sequence_lengths,
+            merge_repeated=merge_repeated,
+            mask_index=mask_index,
+        )
+    elif strategy == "beam_search":
+        return _ctc_beam_search_decode(
+            inputs,
+            sequence_lengths,
+            beam_width=beam_width,
+            top_paths=top_paths,
+            mask_index=mask_index,
+        )
+    else:
+        raise ValueError(
+            f"Invalid strategy {strategy}. Supported values are "
+            "'greedy' and 'beam_search'."
+        )
+
+
+def psnr(x1, x2, max_val):
+    if x1.shape != x2.shape:
+        raise ValueError(
+            f"Input shapes {x1.shape} and {x2.shape} must "
+            "match for PSNR calculation. "
+        )
+
+    max_val = convert_to_tensor(max_val, dtype=x2.dtype)
+    mse = jnp.mean(jnp.square(x1 - x2))
+    psnr = 20 * jnp.log10(max_val) - 10 * jnp.log10(mse)
+    return psnr
+
+
+def _can_use_flash_attention(query, key, value, bias, raise_error=False):
+    """Verify the availability of flash attention."""
+    try:
+        from jax._src.cudnn.fused_attention_stablehlo import _normalize_layout
+        from jax._src.cudnn.fused_attention_stablehlo import (
+            check_compute_capability,
+        )
+        from jax._src.cudnn.fused_attention_stablehlo import check_cudnn_version
+        from jax._src.cudnn.fused_attention_stablehlo import (
+            check_is_flash_attention,
+        )
+        from jax._src.cudnn.fused_attention_stablehlo import check_layout
+        from jax.nn import dot_product_attention as dot_product_attention
+    except ImportError:
+        if raise_error:
+            raise ImportError(
+                "Flash attention is not supported in your current JAX version. "
+                "Please update it by following the official guide: "
+                "https://jax.readthedocs.io/en/latest/installation.html"
+            )
+        return False
+
+    try:
+        # Check if cuDNN is installed and raise RuntimeError if cuDNN is not
+        # detected
+        cudnn_version = check_cudnn_version()
+        # Only support at least Ampere
+        if not check_compute_capability("8.0"):
+            raise RuntimeError("Require at least Ampere arch to run")
+        # Check inputs layout
+        check_layout(
+            query,
+            key,
+            value,
+            bias,
+            q_seqlen=None,
+            kv_seqlen=None,
+            layout=_normalize_layout("BTNH"),
+        )
+        check_is_flash_attention(
+            query,
+            key,
+            _normalize_layout("BTNH"),
+            cudnn_version,
+            bias is not None,
+            is_training=False,
+        )
+        return True
+    except:
+        if raise_error:
+            raise
+        return False
+
+
+def _apply_masks(logits, mask, is_causal):
+    if mask is None and not is_causal:
+        return logits
+
+    combined_mask = jnp.ones_like(logits, dtype="bool")
+    if mask is not None:
+        combined_mask = jnp.logical_and(combined_mask, mask)
+
+    if is_causal:
+        T, S = logits.shape[2], logits.shape[3]
+        mask = jnp.tril(jnp.ones((T, S), dtype="bool"))
+        mask = mask[None, None, :, :]
+        combined_mask = jnp.logical_and(combined_mask, mask)
+
+    large_negative_number = jnp.asarray(
+        -0.7 * jnp.finfo(logits.dtype).max, dtype=logits.dtype
+    )
+    padded_logits = jnp.where(combined_mask, logits, large_negative_number)
+    return padded_logits
+
+
+def _dot_product_attention_core(
+    query, key, value, bias, mask, is_causal, scale
+):
+    logits_dtype = jnp.promote_types(query.dtype, jnp.float32)
+    logits = jnp.einsum(
+        "BTNH,BSNH->BNTS", query, key, preferred_element_type=logits_dtype
+    )
+    logits *= jnp.array(scale, dtype=logits.dtype)
+
+    if bias is not None:
+        logits = (logits + bias).astype(logits.dtype)
+
+    padded_logits = _apply_masks(logits, mask, is_causal)
+
+    # Softmax and it is always carried out in fp32.
+    padded_logits = padded_logits.astype(jnp.float32)
+    probs = jax.nn.softmax(padded_logits, axis=-1).astype(key.dtype)
+    return jnp.einsum("BNTS,BSNH->BTNH", probs, value)
+
+
+def dot_product_attention(
+    query,
+    key,
+    value,
+    bias=None,
+    mask=None,
+    scale=None,
+    is_causal=False,
+    flash_attention=None,
+):
+    query = convert_to_tensor(query)
+    key = convert_to_tensor(key)
+    value = convert_to_tensor(value)
+    if len(query.shape) != 4 or len(key.shape) != 4 or len(value.shape) != 4:
+        raise ValueError(
+            "`dot_product_attention` only supports 4D inputs. "
+            f"Received: query.shape={query.shape}, key.shape={key.shape}, "
+            f"value.shape={value.shape}."
+        )
+    if flash_attention is None:
+        flash_attention = _can_use_flash_attention(query, key, value, bias)
+    elif flash_attention is True:
+        # Use `raise_error=True` to provide more details if the inputs failed to
+        # use flash attention
+        _can_use_flash_attention(query, key, value, bias, raise_error=True)
+    if jax.devices()[0].platform == "tpu" and flash_attention:
+        # Use TPU-optimized flash attention from Pallas
+        return flash_attention_tpu(
+            query,
+            key,
+            value,
+            ab=bias,
+            segment_ids=mask,
+            causal=is_causal,
+            sm_scale=scale,
+        )
+    # `dot_product_attention` is only available in jax>=0.4.31
+    if hasattr(jax.nn, "dot_product_attention"):
+        return jax.nn.dot_product_attention(
+            query,
+            key,
+            value,
+            bias=bias,
+            mask=mask,
+            scale=scale,
+            is_causal=is_causal,
+            implementation="cudnn" if flash_attention else "xla",
+        )
+
+    if flash_attention:
+        raise RuntimeError(
+            "Flash attention is not supported in your current JAX version. "
+            "Please update it by following the official guide: "
+            "https://jax.readthedocs.io/en/latest/installation.html"
+        )
+    # Ref: jax.nn.dot_product_attention
+    # https://github.com/jax-ml/jax/blob/jax-v0.4.33/jax/_src/nn/functions.py#L886
+    # Not support `query_seq_lengths` and `key_value_seq_lengths` args
+    output_shape = query.shape
+    _, _, K, H = key.shape
+    scale = (1.0 / jnp.sqrt(H)) if scale is None else scale
+
+    # _dot_product_attention_xla
+    B, T, N, H = query.shape
+    G = N // K
+    query = jnp.reshape(query, (B, T, K, G, H))
+
+    def _reshape_to_grouped(t):
+        if t is not None:
+            tB, tN, tT, tS = t.shape
+            if tN == 1:
+                t = jnp.broadcast_to(t[:, :, None, :, :], (tB, tN, G, tT, tS))
+            else:
+                assert tN == N
+                t = jnp.reshape(t, (tB, K, G, tT, tS))
+        return t
+
+    bias = _reshape_to_grouped(bias)
+    mask = _reshape_to_grouped(mask)
+    vmapped_fn = jax.vmap(
+        _dot_product_attention_core,
+        in_axes=(3, None, None, 2, 2, None, None),
+        out_axes=3,
+    )
+    encoded = vmapped_fn(query, key, value, bias, mask, is_causal, scale)
+    return jnp.reshape(encoded, output_shape)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/numpy.py

@@ -0,0 +1,1277 @@
+import builtins
+import math
+
+import jax.experimental.sparse as jax_sparse
+import jax.numpy as jnp
+
+from keras.src.backend import config
+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.backend.common.variables import standardize_dtype
+from keras.src.backend.jax import nn
+from keras.src.backend.jax import sparse
+from keras.src.backend.jax.core import cast
+from keras.src.backend.jax.core import convert_to_tensor
+
+
+@sparse.elementwise_binary_union(linear=True, use_sparsify=True)
+def add(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.add(x1, x2)
+
+
+def bincount(x, weights=None, minlength=0, sparse=False):
+    # Note: bincount is never tracable / jittable because the output shape
+    # depends on the values in x.
+    if sparse or isinstance(x, jax_sparse.BCOO):
+        if isinstance(x, jax_sparse.BCOO):
+            if weights is not None:
+                if not isinstance(weights, jax_sparse.BCOO):
+                    raise ValueError("`x` and `weights` must both be BCOOs")
+                if x.indices is not weights.indices:
+                    # This test works in eager mode only
+                    if not jnp.all(jnp.equal(x.indices, weights.indices)):
+                        raise ValueError(
+                            "`x` and `weights` BCOOs must have the same indices"
+                        )
+                weights = weights.data
+            x = x.data
+        reduction_axis = 1 if len(x.shape) > 1 else 0
+        maxlength = jnp.maximum(jnp.max(x) + 1, minlength)
+        one_hot_encoding = nn.one_hot(x, maxlength, sparse=True)
+        if weights is not None:
+            expanded_weights = jnp.expand_dims(weights, reduction_axis + 1)
+            one_hot_encoding = one_hot_encoding * expanded_weights
+
+        outputs = jax_sparse.bcoo_reduce_sum(
+            one_hot_encoding,
+            axes=(reduction_axis,),
+        )
+        return outputs
+    if len(x.shape) == 2:
+        if weights is None:
+
+            def bincount_fn(arr):
+                return jnp.bincount(arr, minlength=minlength)
+
+            bincounts = list(map(bincount_fn, x))
+        else:
+
+            def bincount_fn(arr_w):
+                return jnp.bincount(
+                    arr_w[0], weights=arr_w[1], minlength=minlength
+                )
+
+            bincounts = list(map(bincount_fn, zip(x, weights)))
+
+        return jnp.stack(bincounts)
+    return jnp.bincount(x, weights=weights, minlength=minlength)
+
+
+def einsum(subscripts, *operands, **kwargs):
+    operands = [convert_to_tensor(x) for x in operands]
+    # When all operands are of int8, specifying `preferred_element_type` as
+    # int32 to enable hardware-accelerated einsum
+    dtypes = list(set(standardize_dtype(x.dtype) for x in operands))
+    if len(dtypes) == 1 and dtypes[0] == "int8":
+        preferred_element_type = "int32"
+    else:
+        preferred_element_type = None
+    kwargs["preferred_element_type"] = preferred_element_type
+    return jnp.einsum(subscripts, *operands, **kwargs)
+
+
+@sparse.elementwise_binary_union(linear=True, use_sparsify=True)
+def subtract(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.subtract(x1, x2)
+
+
+def matmul(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    # When both x1 and x2 are of int8, specifying `preferred_element_type` as
+    # int32 to enable hardware-accelerated matmul
+    x1_dtype = standardize_dtype(x1.dtype)
+    x2_dtype = standardize_dtype(x2.dtype)
+    if x1_dtype == "int8" and x2_dtype == "int8":
+        preferred_element_type = "int32"
+    else:
+        preferred_element_type = None
+    if isinstance(x1, jax_sparse.JAXSparse) or isinstance(
+        x2, jax_sparse.JAXSparse
+    ):
+        if not hasattr(matmul, "sparse_matmul"):
+            matmul.sparse_matmul = jax_sparse.sparsify(jnp.matmul)
+        if isinstance(x1, jax_sparse.BCOO):
+            x1 = jax_sparse.bcoo_update_layout(
+                x1, n_batch=len(x1.shape) - 2, on_inefficient="warn"
+            )
+        if isinstance(x2, jax_sparse.BCOO):
+            x2 = jax_sparse.bcoo_update_layout(
+                x2, n_batch=len(x2.shape) - 2, on_inefficient="warn"
+            )
+        return matmul.sparse_matmul(
+            x1, x2, preferred_element_type=preferred_element_type
+        )
+
+    return jnp.matmul(x1, x2, preferred_element_type=preferred_element_type)
+
+
+def multiply(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    if isinstance(x1, jax_sparse.BCOO):
+        if isinstance(x2, jax_sparse.BCOO):
+            # x1 is sparse, x2 is sparse.
+            if x1.indices is x2.indices:
+                # `bcoo_multiply_sparse` will not detect that the indices are
+                # the same, optimize this case here.
+                if not x1.unique_indices:
+                    x1 = jax_sparse.bcoo_sum_duplicates(x1)
+                    x2 = jax_sparse.bcoo_sum_duplicates(x2)
+                return jax_sparse.BCOO(
+                    (jnp.multiply(x1.data, x2.data), x1.indices),
+                    shape=x1.shape,
+                    indices_sorted=True,
+                    unique_indices=True,
+                )
+            else:
+                return jax_sparse.bcoo_multiply_sparse(x1, x2)
+        else:
+            # x1 is sparse, x2 is dense.
+            out_data = jax_sparse.bcoo_multiply_dense(x1, x2)
+            return jax_sparse.BCOO(
+                (out_data, x1.indices),
+                shape=x1.shape,
+                indices_sorted=x1.indices_sorted,
+                unique_indices=x1.unique_indices,
+            )
+    elif isinstance(x2, jax_sparse.BCOO):
+        # x1 is dense, x2 is sparse.
+        out_data = jax_sparse.bcoo_multiply_dense(x2, x1)
+        return jax_sparse.BCOO(
+            (out_data, x2.indices),
+            shape=x2.shape,
+            indices_sorted=x2.indices_sorted,
+            unique_indices=x2.unique_indices,
+        )
+    return jnp.multiply(x1, x2)
+
+
+def mean(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    # `jnp.mean` does not handle low precision (e.g., float16) overflow
+    # correctly, so we compute with float32 and cast back to the original type.
+    compute_dtype = dtypes.result_type(x.dtype, "float32")
+    if "int" in ori_dtype or ori_dtype == "bool":
+        result_dtype = compute_dtype
+    else:
+        result_dtype = ori_dtype
+    if isinstance(x, jax_sparse.BCOO):
+        if axis is None:
+            axis = tuple(range(len(x.shape)))
+        (
+            canonical_axis,
+            keep_dims_shape,
+            broadcast_dimensions,
+        ) = sparse.axis_shape_dims_for_broadcast_in_dim(
+            axis, x.shape, insert_dims=False
+        )
+        divisor = math.prod(x.shape[i] for i in canonical_axis)
+        output = jax_sparse.bcoo_reduce_sum(x, axes=canonical_axis)
+        output = jax_sparse.BCOO(
+            (output.data.astype(result_dtype) / divisor, output.indices),
+            shape=output.shape,
+        )
+        if keepdims:
+            # `bcoo_reduce_sum` does not support keepdims, neither does
+            # sparsify(jnp.sum), so we recreate the empty dimensions.
+            output = jax_sparse.bcoo_broadcast_in_dim(
+                output,
+                shape=keep_dims_shape,
+                broadcast_dimensions=broadcast_dimensions,
+            )
+        return output
+    else:
+        output = jnp.mean(x, axis=axis, keepdims=keepdims, dtype=compute_dtype)
+        return cast(output, result_dtype)
+
+
+def max(x, axis=None, keepdims=False, initial=None):
+    x = convert_to_tensor(x)
+    return jnp.max(x, axis=axis, keepdims=keepdims, initial=initial)
+
+
+def ones(shape, dtype=None):
+    dtype = dtype or config.floatx()
+    return jnp.ones(shape, dtype=dtype)
+
+
+def zeros(shape, dtype=None):
+    dtype = dtype or config.floatx()
+    return jnp.zeros(shape, dtype=dtype)
+
+
+@sparse.elementwise_unary(linear=False)
+def absolute(x):
+    x = convert_to_tensor(x)
+    return jnp.absolute(x)
+
+
+def abs(x):
+    return absolute(x)
+
+
+def all(x, axis=None, keepdims=False):
+    return jnp.all(x, axis=axis, keepdims=keepdims)
+
+
+def any(x, axis=None, keepdims=False):
+    return jnp.any(x, axis=axis, keepdims=keepdims)
+
+
+def amax(x, axis=None, keepdims=False):
+    return jnp.amax(x, axis=axis, keepdims=keepdims)
+
+
+def amin(x, axis=None, keepdims=False):
+    return jnp.amin(x, axis=axis, keepdims=keepdims)
+
+
+def append(x1, x2, axis=None):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.append(x1, x2, axis=axis)
+
+
+def arange(start, stop=None, step=1, dtype=None):
+    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)
+    dtype = standardize_dtype(dtype)
+    return jnp.arange(start, stop, step=step, dtype=dtype)
+
+
+@sparse.densifying_unary
+def arccos(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.arccos(x)
+
+
+@sparse.densifying_unary
+def arccosh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.arccosh(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def arcsin(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.arcsin(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def arcsinh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.arcsinh(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def arctan(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.arctan(x)
+
+
+def arctan2(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype, float)
+    x1 = cast(x1, dtype)
+    x2 = cast(x2, dtype)
+    return jnp.arctan2(x1, x2)
+
+
+@sparse.elementwise_unary(linear=False)
+def arctanh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.arctanh(x)
+
+
+def argmax(x, axis=None, keepdims=False):
+    return jnp.argmax(x, axis=axis, keepdims=keepdims)
+
+
+def argmin(x, axis=None, keepdims=False):
+    return jnp.argmin(x, axis=axis, keepdims=keepdims)
+
+
+def argsort(x, axis=-1):
+    x = convert_to_tensor(x)
+    if x.ndim == 0:
+        return jnp.argsort(x, axis=None)
+    return jnp.argsort(x, axis=axis)
+
+
+def array(x, dtype=None):
+    return jnp.array(x, dtype=dtype)
+
+
+def average(x, axis=None, weights=None):
+    x = convert_to_tensor(x)
+    dtypes_to_resolve = [x.dtype, float]
+    if weights is not None:
+        weights = convert_to_tensor(weights)
+        dtypes_to_resolve.append(weights.dtype)
+    dtype = dtypes.result_type(*dtypes_to_resolve)
+    x = cast(x, dtype)
+    if weights is not None:
+        weights = cast(weights, dtype)
+    return jnp.average(x, weights=weights, axis=axis)
+
+
+def bitwise_and(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    return jnp.bitwise_and(x, y)
+
+
+def bitwise_invert(x):
+    x = convert_to_tensor(x)
+    return jnp.invert(x)
+
+
+def bitwise_not(x):
+    return bitwise_invert(x)
+
+
+def bitwise_or(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    return jnp.bitwise_or(x, y)
+
+
+def bitwise_xor(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    return jnp.bitwise_xor(x, y)
+
+
+def bitwise_left_shift(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    return jnp.left_shift(x, y)
+
+
+def left_shift(x, y):
+    return bitwise_left_shift(x, y)
+
+
+def bitwise_right_shift(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    return jnp.right_shift(x, y)
+
+
+def right_shift(x, y):
+    return bitwise_right_shift(x, y)
+
+
+def broadcast_to(x, shape):
+    x = convert_to_tensor(x)
+    return jnp.broadcast_to(x, shape)
+
+
+@sparse.elementwise_unary(linear=False)
+def ceil(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.ceil(x)
+
+
+def clip(x, x_min, x_max):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "bool":
+        x = cast(x, "int32")
+    return jnp.clip(x, x_min, x_max)
+
+
+def concatenate(xs, axis=0):
+    bcoo_count = builtins.sum(isinstance(x, jax_sparse.BCOO) for x in xs)
+    if bcoo_count:
+        if bcoo_count == len(xs):
+            axis = canonicalize_axis(axis, len(xs[0].shape))
+            return jax_sparse.bcoo_concatenate(xs, dimension=axis)
+        else:
+            xs = [
+                x.todense() if isinstance(x, jax_sparse.JAXSparse) else x
+                for x in xs
+            ]
+    return jnp.concatenate(xs, axis=axis)
+
+
+@sparse.elementwise_unary(linear=True)
+def conjugate(x):
+    x = convert_to_tensor(x)
+    return jnp.conjugate(x)
+
+
+@sparse.elementwise_unary(linear=True)
+def conj(x):
+    x = convert_to_tensor(x)
+    return jnp.conjugate(x)
+
+
+@sparse.elementwise_unary(linear=True)
+def copy(x):
+    x = convert_to_tensor(x)
+    return jnp.copy(x)
+
+
+@sparse.densifying_unary
+def cos(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.cos(x)
+
+
+@sparse.densifying_unary
+def cosh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.cosh(x)
+
+
+def count_nonzero(x, axis=None):
+    return cast(jnp.count_nonzero(x, axis=axis), "int32")
+
+
+def cross(x1, x2, axisa=-1, axisb=-1, axisc=-1, axis=None):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.cross(
+        x1,
+        x2,
+        axisa=axisa,
+        axisb=axisb,
+        axisc=axisc,
+        axis=axis,
+    )
+
+
+def cumprod(x, axis=None, dtype=None):
+    x = convert_to_tensor(x)
+    return jnp.cumprod(x, axis=axis, dtype=dtype)
+
+
+def cumsum(x, axis=None, dtype=None):
+    x = convert_to_tensor(x)
+    return jnp.cumsum(x, axis=axis, dtype=dtype)
+
+
+def diag(x, k=0):
+    x = convert_to_tensor(x)
+    return jnp.diag(x, k=k)
+
+
+def diagflat(x, k=0):
+    x = convert_to_tensor(x)
+    return jnp.diagflat(x, k=k)
+
+
+def diagonal(x, offset=0, axis1=0, axis2=1):
+    x = convert_to_tensor(x)
+    return jnp.diagonal(
+        x,
+        offset=offset,
+        axis1=axis1,
+        axis2=axis2,
+    )
+
+
+def diff(a, n=1, axis=-1):
+    a = convert_to_tensor(a)
+    return jnp.diff(a, n=n, axis=axis)
+
+
+@sparse.elementwise_unary(linear=False)
+def digitize(x, bins):
+    x = convert_to_tensor(x)
+    bins = convert_to_tensor(bins)
+    return jnp.digitize(x, bins)
+
+
+def dot(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    return jnp.dot(x, y)
+
+
+def empty(shape, dtype=None):
+    dtype = dtype or config.floatx()
+    return jnp.empty(shape, dtype=dtype)
+
+
+def equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.equal(x1, x2)
+
+
+@sparse.densifying_unary
+def exp(x):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    if "int" in ori_dtype or ori_dtype == "bool":
+        x = cast(x, config.floatx())
+    return jnp.exp(x)
+
+
+@sparse.densifying_unary
+def exp2(x):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    if "int" in ori_dtype or ori_dtype == "bool":
+        x = cast(x, config.floatx())
+    return jnp.exp2(x)
+
+
+def expand_dims(x, axis):
+    x = convert_to_tensor(x)
+    if isinstance(x, jax_sparse.BCOO):
+        (
+            _,
+            result_shape,
+            broadcast_dimensions,
+        ) = sparse.axis_shape_dims_for_broadcast_in_dim(
+            axis, x.shape, insert_dims=True
+        )
+        return jax_sparse.bcoo_broadcast_in_dim(
+            x, shape=result_shape, broadcast_dimensions=broadcast_dimensions
+        )
+    return jnp.expand_dims(x, axis)
+
+
+@sparse.elementwise_unary(linear=False)
+def expm1(x):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    if "int" in ori_dtype or ori_dtype == "bool":
+        x = cast(x, config.floatx())
+    return jnp.expm1(x)
+
+
+def flip(x, axis=None):
+    return jnp.flip(x, axis=axis)
+
+
+@sparse.elementwise_unary(linear=False)
+def floor(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.floor(x)
+
+
+def full(shape, fill_value, dtype=None):
+    dtype = dtype or config.floatx()
+    return jnp.full(shape, fill_value, dtype=dtype)
+
+
+def full_like(x, fill_value, dtype=None):
+    return jnp.full_like(x, fill_value, dtype=dtype)
+
+
+def greater(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.greater(x1, x2)
+
+
+def greater_equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.greater_equal(x1, x2)
+
+
+def hstack(xs):
+    return jnp.hstack(xs)
+
+
+def identity(n, dtype=None):
+    dtype = dtype or config.floatx()
+    return jnp.identity(n, dtype=dtype)
+
+
+@sparse.elementwise_unary(linear=True)
+def imag(x):
+    x = convert_to_tensor(x)
+    return jnp.imag(x)
+
+
+def isclose(x1, x2, rtol=1e-5, atol=1e-8, equal_nan=False):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.isclose(x1, x2, rtol, atol, equal_nan)
+
+
+@sparse.densifying_unary
+def isfinite(x):
+    x = convert_to_tensor(x)
+    return jnp.isfinite(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def isinf(x):
+    x = convert_to_tensor(x)
+    return jnp.isinf(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def isnan(x):
+    x = convert_to_tensor(x)
+    return jnp.isnan(x)
+
+
+def less(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.less(x1, x2)
+
+
+def less_equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.less_equal(x1, x2)
+
+
+def linspace(
+    start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0
+):
+    return jnp.linspace(
+        start,
+        stop,
+        num=num,
+        endpoint=endpoint,
+        retstep=retstep,
+        dtype=dtype,
+        axis=axis,
+    )
+
+
+@sparse.densifying_unary
+def log(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+    return jnp.log(x)
+
+
+@sparse.densifying_unary
+def log10(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+    return jnp.log10(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def log1p(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+    return jnp.log1p(x)
+
+
+@sparse.densifying_unary
+def log2(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+    return jnp.log2(x)
+
+
+def logaddexp(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype, float)
+    x1 = cast(x1, dtype)
+    x2 = cast(x2, dtype)
+    return jnp.logaddexp(x1, x2)
+
+
+def logical_and(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.logical_and(x1, x2)
+
+
+def logical_not(x):
+    x = convert_to_tensor(x)
+    return jnp.logical_not(x)
+
+
+def logical_or(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.logical_or(x1, x2)
+
+
+def logspace(start, stop, num=50, endpoint=True, base=10, dtype=None, axis=0):
+    return jnp.logspace(
+        start,
+        stop,
+        num=num,
+        endpoint=endpoint,
+        base=base,
+        dtype=dtype,
+        axis=axis,
+    )
+
+
+@sparse.elementwise_binary_union(linear=False, use_sparsify=False)
+def maximum(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.maximum(x1, x2)
+
+
+def median(x, axis=None, keepdims=False):
+    # axis of jnp.median must be hashable
+    if isinstance(axis, list):
+        axis = tuple(axis)
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+
+    result = jnp.median(x, axis=axis, keepdims=keepdims)
+
+    # TODO: with jax < 0.4.26 jnp.median failed to keepdims when axis is None
+    if keepdims is True and axis is None:
+        while result.ndim < x.ndim:
+            result = jnp.expand_dims(result, axis=-1)
+    return result
+
+
+def meshgrid(*x, indexing="xy"):
+    return jnp.meshgrid(*x, indexing=indexing)
+
+
+def min(x, axis=None, keepdims=False, initial=None):
+    x = convert_to_tensor(x)
+    return jnp.min(x, axis=axis, keepdims=keepdims, initial=initial)
+
+
+@sparse.elementwise_binary_union(linear=False, use_sparsify=False)
+def minimum(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.minimum(x1, x2)
+
+
+def mod(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.mod(x1, x2)
+
+
+def moveaxis(x, source, destination):
+    return jnp.moveaxis(x, source=source, destination=destination)
+
+
+def nan_to_num(x, nan=0.0, posinf=None, neginf=None):
+    x = convert_to_tensor(x)
+    return jnp.nan_to_num(x, nan=nan, posinf=posinf, neginf=neginf)
+
+
+def ndim(x):
+    return jnp.ndim(x)
+
+
+def nonzero(x):
+    return jnp.nonzero(x)
+
+
+def not_equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.not_equal(x1, x2)
+
+
+def ones_like(x, dtype=None):
+    return jnp.ones_like(x, dtype=dtype)
+
+
+def zeros_like(x, dtype=None):
+    return jnp.zeros_like(x, dtype=dtype)
+
+
+def outer(x1, x2):
+    return jnp.outer(x1, x2)
+
+
+def pad(x, pad_width, mode="constant", constant_values=None):
+    x = convert_to_tensor(x)
+    kwargs = {}
+    if constant_values is not None:
+        if mode != "constant":
+            raise ValueError(
+                "Argument `constant_values` can only be "
+                "provided when `mode == 'constant'`. "
+                f"Received: mode={mode}"
+            )
+        kwargs["constant_values"] = constant_values
+    return jnp.pad(x, pad_width, mode=mode, **kwargs)
+
+
+def prod(x, axis=None, keepdims=False, dtype=None):
+    x = convert_to_tensor(x)
+    return jnp.prod(x, axis=axis, keepdims=keepdims, dtype=dtype)
+
+
+def quantile(x, q, axis=None, method="linear", keepdims=False):
+    x = convert_to_tensor(x)
+    q = convert_to_tensor(q)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+
+    result = jnp.quantile(x, q, axis=axis, method=method, keepdims=keepdims)
+
+    # TODO: with jax < 0.4.26 jnp.quantile failed to keepdims when axis is None
+    if keepdims is True and axis is None:
+        result_ndim = x.ndim + (1 if len(q.shape) > 0 else 0)
+        while result.ndim < result_ndim:
+            result = jnp.expand_dims(result, axis=-1)
+    return result
+
+
+def ravel(x):
+    x = convert_to_tensor(x)
+    return jnp.ravel(x)
+
+
+def unravel_index(x, shape):
+    x = convert_to_tensor(x)
+    return jnp.unravel_index(x, shape)
+
+
+@sparse.elementwise_unary(linear=True)
+def real(x):
+    x = convert_to_tensor(x)
+    return jnp.real(x)
+
+
+@sparse.densifying_unary
+def reciprocal(x):
+    x = convert_to_tensor(x)
+    return jnp.reciprocal(x)
+
+
+def repeat(x, repeats, axis=None):
+    x = convert_to_tensor(x)
+    return jnp.repeat(x, repeats, axis=axis)
+
+
+def reshape(x, newshape):
+    if isinstance(x, jax_sparse.BCOO):
+        from keras.src.ops import operation_utils
+
+        # Resolve the -1 in `new_shape` if applicable and possible
+        output_shape = operation_utils.compute_reshape_output_shape(
+            x.shape, newshape, "new_shape"
+        )
+        if None not in output_shape:
+            newshape = output_shape
+        return jax_sparse.bcoo_reshape(x, new_sizes=newshape)
+    return jnp.reshape(x, newshape)
+
+
+def roll(x, shift, axis=None):
+    return jnp.roll(x, shift, axis=axis)
+
+
+def searchsorted(sorted_sequence, values, side="left"):
+    if ndim(sorted_sequence) != 1:
+        raise ValueError(
+            "`searchsorted` only supports 1-D sorted sequences. "
+            "You can use `keras.ops.vectorized_map` "
+            "to extend it to N-D sequences. Received: "
+            f"sorted_sequence.shape={sorted_sequence.shape}"
+        )
+    return jnp.searchsorted(sorted_sequence, values, side=side)
+
+
+@sparse.elementwise_unary(linear=False)
+def sign(x):
+    x = convert_to_tensor(x)
+    return jnp.sign(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def sin(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.sin(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def sinh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.sinh(x)
+
+
+def size(x):
+    return jnp.size(x)
+
+
+def sort(x, axis=-1):
+    x = convert_to_tensor(x)
+    return jnp.sort(x, axis=axis)
+
+
+def split(x, indices_or_sections, axis=0):
+    return jnp.split(x, indices_or_sections, axis=axis)
+
+
+def stack(x, axis=0):
+    return jnp.stack(x, axis=axis)
+
+
+def std(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+    return jnp.std(x, axis=axis, keepdims=keepdims)
+
+
+def swapaxes(x, axis1, axis2):
+    x = convert_to_tensor(x)
+    return jnp.swapaxes(x, axis1=axis1, axis2=axis2)
+
+
+def take(x, indices, axis=None):
+    x = convert_to_tensor(x)
+    indices = convert_to_tensor(indices, sparse=False)
+    return jnp.take(x, indices, axis=axis)
+
+
+def take_along_axis(x, indices, axis=None):
+    return jnp.take_along_axis(x, indices, axis=axis)
+
+
+@sparse.elementwise_unary(linear=False)
+def tan(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.tan(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def tanh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+    return jnp.tanh(x)
+
+
+def tensordot(x1, x2, axes=2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.tensordot(x1, x2, axes=axes)
+
+
+@sparse.elementwise_unary(linear=False)
+def round(x, decimals=0):
+    x = convert_to_tensor(x)
+
+    # jnp.round doesn't support decimals < 0 for integers
+    x_dtype = standardize_dtype(x.dtype)
+    if "int" in x_dtype and decimals < 0:
+        factor = cast(math.pow(10, decimals), config.floatx())
+        x = cast(x, config.floatx())
+        x = jnp.multiply(x, factor)
+        x = jnp.round(x)
+        x = jnp.divide(x, factor)
+        return cast(x, x_dtype)
+    else:
+        return jnp.round(x, decimals=decimals)
+
+
+def tile(x, repeats):
+    return jnp.tile(x, repeats)
+
+
+def trace(x, offset=0, axis1=0, axis2=1):
+    x = convert_to_tensor(x)
+    dtype = None
+    # TODO: Remove the condition of uint8 and uint16 once we have jax>=0.4.27
+    # for both CPU & GPU environments.
+    # uint8 and uint16 will be casted to uint32 when jax>=0.4.27 but to int32
+    # otherwise.
+    if standardize_dtype(x.dtype) in ("bool", "uint8", "uint16"):
+        dtype = "int32"
+    return jnp.trace(x, offset=offset, axis1=axis1, axis2=axis2, dtype=dtype)
+
+
+def tri(N, M=None, k=0, dtype=None):
+    dtype = dtype or config.floatx()
+    return jnp.tri(N, M=M, k=k, dtype=dtype)
+
+
+def tril(x, k=0):
+    x = convert_to_tensor(x)
+    return jnp.tril(x, k=k)
+
+
+def triu(x, k=0):
+    x = convert_to_tensor(x)
+    return jnp.triu(x, k=k)
+
+
+def trunc(x):
+    x = convert_to_tensor(x)
+    dtype = standardize_dtype(x.dtype)
+    if "int" in dtype or "bool" == dtype:
+        return x
+    return jnp.trunc(x)
+
+
+def vdot(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.vdot(x1, x2)
+
+
+def inner(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.inner(x1, x2)
+
+
+def vstack(xs):
+    return jnp.vstack(xs)
+
+
+def vectorize(pyfunc, *, excluded=None, signature=None):
+    if excluded is None:
+        excluded = set()
+    return jnp.vectorize(pyfunc, excluded=excluded, signature=signature)
+
+
+def where(condition, x1, x2):
+    return jnp.where(condition, x1, x2)
+
+
+@sparse.elementwise_division
+def divide(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.divide(x1, x2)
+
+
+def divide_no_nan(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    safe_x2 = jnp.where(x2 == 0, 1, x2)
+    return jnp.where(x2 == 0, 0, jnp.divide(x1, safe_x2))
+
+
+def true_divide(x1, x2):
+    return divide(x1, x2)
+
+
+def power(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.power(x1, x2)
+
+
+@sparse.elementwise_unary(linear=True)
+def negative(x):
+    x = convert_to_tensor(x)
+    return jnp.negative(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def square(x):
+    x = convert_to_tensor(x)
+    return jnp.square(x)
+
+
+@sparse.elementwise_unary(linear=False)
+def sqrt(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        x = cast(x, config.floatx())
+    return jnp.sqrt(x)
+
+
+def squeeze(x, axis=None):
+    if isinstance(x, jax_sparse.BCOO):
+        if axis is None:
+            axis = tuple(i for i, d in enumerate(x.shape) if d == 1)
+        axis = to_tuple_or_list(axis)
+        return jax_sparse.bcoo_squeeze(x, dimensions=axis)
+    return jnp.squeeze(x, axis=axis)
+
+
+def transpose(x, axes=None):
+    x = convert_to_tensor(x)
+    if isinstance(x, jax_sparse.BCOO):
+        num_dims = len(x.shape)
+        if axes is None:
+            permutation = tuple(range(num_dims)[::-1])
+        else:
+            permutation = []
+            for a in axes:
+                a = canonicalize_axis(a, num_dims)
+                permutation.append(a)
+        return jax_sparse.bcoo_transpose(x, permutation=permutation)
+    return jnp.transpose(x, axes=axes)
+
+
+def var(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    # `jnp.var` does not handle low precision (e.g., float16) overflow
+    # correctly, so we compute with float32 and cast back to the original type.
+    compute_dtype = dtypes.result_type(x.dtype, "float32")
+    result_dtype = dtypes.result_type(x.dtype, float)
+    return cast(
+        jnp.var(x, axis=axis, keepdims=keepdims, dtype=compute_dtype),
+        result_dtype,
+    )
+
+
+def sum(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    if isinstance(x, jax_sparse.BCOO):
+        if axis is None:
+            axis = tuple(range(len(x.shape)))
+        (
+            canonical_axis,
+            keep_dims_shape,
+            broadcast_dimensions,
+        ) = sparse.axis_shape_dims_for_broadcast_in_dim(
+            axis, x.shape, insert_dims=False
+        )
+        output = jax_sparse.bcoo_reduce_sum(x, axes=canonical_axis)
+        if keepdims:
+            # `bcoo_reduce_sum` does not support keepdims, neither does
+            # sparsify(jnp.sum), so we recreate the empty dimensions.
+            output = jax_sparse.bcoo_broadcast_in_dim(
+                output,
+                shape=keep_dims_shape,
+                broadcast_dimensions=broadcast_dimensions,
+            )
+        return output
+    return jnp.sum(x, axis=axis, keepdims=keepdims)
+
+
+def eye(N, M=None, k=0, dtype=None):
+    dtype = dtype or config.floatx()
+    return jnp.eye(N, M=M, k=k, dtype=dtype)
+
+
+def floor_divide(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.floor_divide(x1, x2)
+
+
+def logical_xor(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.logical_xor(x1, x2)
+
+
+def correlate(x1, x2, mode="valid"):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.correlate(x1, x2, mode)
+
+
+def select(condlist, choicelist, default=0):
+    return jnp.select(condlist, choicelist, default=default)
+
+
+def slogdet(x):
+    x = convert_to_tensor(x)
+    return tuple(jnp.linalg.slogdet(x))
+
+
+def argpartition(x, kth, axis=-1):
+    return jnp.argpartition(x, kth, axis)
+
+
+def histogram(x, bins, range):
+    return jnp.histogram(x, bins=bins, range=range)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/optimizer.py

@@ -0,0 +1,112 @@
+"""A class for JAX specific optimizer logic.
+
+Its purpose is to route around statelessness
+requirements in cond ops used for EMA handling
+and gradient accumulation handling. We do this
+by skipping conditionals entirely.
+"""
+
+import jax
+from jax import numpy as jnp
+
+from keras.src.optimizers import base_optimizer
+
+
+class JaxOptimizer(base_optimizer.BaseOptimizer):
+    def _backend_apply_gradients(self, grads, trainable_variables):
+        if self.gradient_accumulation_steps:
+            is_update_step = (
+                self._iterations + 1
+            ) % self.gradient_accumulation_steps == 0
+            steps = self.gradient_accumulation_steps
+
+            current_trainable_vars_value = [
+                v.value for v in trainable_variables
+            ]
+            current_optimizer_vars_value = [v.value for v in self.variables]
+
+            # `trainable_variables` might have been filtered in previous
+            # processing steps, so we need to ensure the correct mapping between
+            # `self._accumulated_gradients` and `trainable_variables`
+            acc_grads = [
+                self._accumulated_gradients[self._get_variable_index(v)]
+                for v in trainable_variables
+            ]
+
+            new_g_accs = jax.lax.cond(
+                is_update_step,
+                lambda: [jnp.zeros(g.shape, dtype=g.dtype) for g in acc_grads],
+                lambda: [g + acc_g for g, acc_g in zip(grads, acc_grads)],
+            )
+
+            grads = jax.lax.cond(
+                is_update_step,
+                lambda: [
+                    (g + acc_g) / steps for g, acc_g in zip(grads, acc_grads)
+                ],
+                lambda: list(grads),
+            )
+
+            # Apply clipping and weight decay.
+            grads = self._clip_gradients(grads)
+            self._apply_weight_decay(trainable_variables)
+
+            self._backend_update_step(
+                grads, trainable_variables, self.learning_rate
+            )
+            new_trainable_vars = jax.lax.cond(
+                is_update_step,
+                lambda: [v.value for v in trainable_variables],
+                lambda: current_trainable_vars_value,
+            )
+            new_opt_vars = jax.lax.cond(
+                is_update_step,
+                lambda: [v.value for v in self.variables],
+                lambda: current_optimizer_vars_value,
+            )
+
+            for value, v in zip(new_trainable_vars, trainable_variables):
+                v.assign(value)
+
+            for value, v in zip(new_opt_vars, self.variables):
+                v.assign(value)
+
+            for n_g_acc, g_acc in zip(new_g_accs, acc_grads):
+                g_acc.assign(n_g_acc)
+
+        else:
+            # Apply clipping and weight decay.
+            grads = self._clip_gradients(grads)
+            self._apply_weight_decay(trainable_variables)
+
+            self._backend_update_step(
+                grads, trainable_variables, self.learning_rate
+            )
+
+        if self.use_ema:
+            self._update_model_variables_moving_average(
+                self._trainable_variables
+            )
+            if self.ema_overwrite_frequency is not None:
+                should_overwrite_model_vars = (
+                    self.iterations + 1
+                ) % self.ema_overwrite_frequency == 0
+                should_overwrite_model_vars_int = (
+                    should_overwrite_model_vars.astype("int32")
+                )
+                should_not_overwrite_model_vars_int = jnp.logical_not(
+                    should_overwrite_model_vars
+                ).astype("int32")
+                current_trainable_vars_value = [
+                    v.value for v in self._trainable_variables
+                ]
+                for var, average_var in zip(
+                    self._trainable_variables,
+                    self._model_variables_moving_average,
+                ):
+                    var.assign(
+                        average_var * should_overwrite_model_vars_int
+                        + var.value * should_not_overwrite_model_vars_int
+                    )
+
+        self._iterations.assign_add(1)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/rnn.py

@@ -0,0 +1,226 @@
+import contextlib
+
+from jax import lax
+from jax import numpy as jnp
+
+from keras.src import tree
+from keras.src.backend.common import stateless_scope
+
+
+def rnn(
+    step_function,
+    inputs,
+    initial_states,
+    go_backwards=False,
+    mask=None,
+    constants=None,
+    unroll=False,
+    input_length=None,
+    time_major=False,
+    zero_output_for_mask=False,
+    return_all_outputs=True,
+):
+    def swap_batch_timestep(input_t):
+        # Swap the batch and timestep dim for the incoming tensor.
+        axes = list(range(len(input_t.shape)))
+        axes[0], axes[1] = 1, 0
+        return jnp.transpose(input_t, axes)
+
+    if not time_major:
+        inputs = tree.map_structure(swap_batch_timestep, inputs)
+
+    flattened_inputs = tree.flatten(inputs)
+    time_steps = flattened_inputs[0].shape[0]
+
+    if mask is not None:
+        if mask.dtype != "bool":
+            mask = mask.astype("bool")
+        if len(mask.shape) == 2:
+            mask = jnp.expand_dims(mask, axis=-1)
+        if not time_major:
+            mask = swap_batch_timestep(mask)
+
+    if constants is None:
+        constants = []
+
+    def _expand_mask(mask_t, input_t, fixed_dim=1):
+        if tree.is_nested(mask_t):
+            raise ValueError(
+                f"mask_t is expected to be tensor, but got {mask_t}"
+            )
+        if tree.is_nested(input_t):
+            raise ValueError(
+                f"input_t is expected to be tensor, but got {input_t}"
+            )
+        rank_diff = len(input_t.shape) - len(mask_t.shape)
+        for _ in range(rank_diff):
+            mask_t = jnp.expand_dims(mask_t, -1)
+        multiples = [1] * fixed_dim + list(input_t.shape[fixed_dim:])
+        return jnp.tile(mask_t, multiples)
+
+    if unroll:
+        if not time_steps:
+            raise ValueError("Unrolling requires a fixed number of timesteps.")
+        states = tuple(initial_states)
+        successive_states = []
+        successive_outputs = []
+
+        # Process the input tensors. The input tensor need to be split on the
+        # time_step dim, and reverse if go_backwards is True. In the case of
+        # nested input, the input is flattened and then transformed
+        # individually.  The result of this will be a tuple of lists, each of
+        # the item in tuple is list of the tensor with shape (batch, feature)
+        def _process_single_input_t(input_t):
+            input_t = unstack(input_t)  # unstack for time_step dim
+            if go_backwards:
+                input_t.reverse()
+            return input_t
+
+        if tree.is_nested(inputs):
+            processed_input = tree.map_structure(
+                _process_single_input_t, inputs
+            )
+        else:
+            processed_input = (_process_single_input_t(inputs),)
+
+        def _get_input_tensor(time):
+            inp = [t_[time] for t_ in processed_input]
+            return tree.pack_sequence_as(inputs, inp)
+
+        if mask is not None:
+            mask_list = unstack(mask)
+            if go_backwards:
+                mask_list.reverse()
+
+            for i in range(time_steps):
+                inp = _get_input_tensor(i)
+                mask_t = mask_list[i]
+                output, new_states = step_function(
+                    inp, tuple(states) + tuple(constants)
+                )
+                tiled_mask_t = _expand_mask(mask_t, output)
+
+                if not successive_outputs:
+                    prev_output = jnp.zeros_like(output)
+                else:
+                    prev_output = successive_outputs[-1]
+
+                output = jnp.where(tiled_mask_t, output, prev_output)
+
+                flat_states = tree.flatten(states)
+                flat_new_states = tree.flatten(new_states)
+                tiled_mask_t = tuple(
+                    _expand_mask(mask_t, s) for s in flat_states
+                )
+                flat_final_states = tuple(
+                    jnp.where(m, s, ps)
+                    for m, s, ps in zip(
+                        tiled_mask_t, flat_new_states, flat_states
+                    )
+                )
+                states = tree.pack_sequence_as(states, flat_final_states)
+
+                if return_all_outputs:
+                    successive_outputs.append(output)
+                    successive_states.append(states)
+                else:
+                    successive_outputs = [output]
+                    successive_states = [states]
+            last_output = successive_outputs[-1]
+            new_states = successive_states[-1]
+            outputs = jnp.stack(successive_outputs)
+
+        else:  # mask is None
+            for i in range(time_steps):
+                inp = _get_input_tensor(i)
+                output, states = step_function(
+                    inp, tuple(states) + tuple(constants)
+                )
+                if return_all_outputs:
+                    successive_outputs.append(output)
+                    successive_states.append(states)
+                else:
+                    successive_outputs = [output]
+                    successive_states = [states]
+            last_output = successive_outputs[-1]
+            new_states = successive_states[-1]
+            outputs = jnp.stack(successive_outputs)
+
+    else:  # Unroll == False
+        if mask is not None:
+
+            def _step(states, current_input):
+                current_input, current_mask = current_input
+                is_masked = jnp.all(
+                    jnp.logical_not(current_mask), axis=-1, keepdims=True
+                )
+
+                output_t, new_states = step_function(current_input, states)
+
+                if zero_output_for_mask:
+                    masked_outs = jnp.where(
+                        is_masked, jnp.zeros_like(output_t), output_t
+                    )
+                else:
+                    # Assume the first state is the previous output.
+                    output_tm1 = states[0]
+                    masked_outs = jnp.where(is_masked, output_tm1, output_t)
+
+                new_states = [
+                    jnp.where(is_masked, s, ns)
+                    for s, ns in zip(states, new_states)
+                ]
+                return (new_states, masked_outs)
+
+            scan_xs = (inputs, mask)
+
+        else:
+
+            def _step(states, current_input):
+                output_t, new_states = step_function(current_input, states)
+                return new_states, output_t
+
+            scan_xs = inputs
+
+        if stateless_scope.in_stateless_scope():
+            # Reuse the existing parent stateless scope.
+            scope = contextlib.nullcontext()
+        else:
+            scope = stateless_scope.StatelessScope()
+        with scope:
+            # We must use a stateless scope because `scan` will involve
+            # JAX tracing -- any variable update at this stage would
+            # be a leak.
+            new_states, outputs = lax.scan(
+                f=_step,
+                init=initial_states,
+                xs=scan_xs,
+                reverse=go_backwards,
+            )
+        if go_backwards:
+            outputs = jnp.flip(outputs, axis=0)
+        last_output = outputs[-1]
+
+    if not time_major:
+        outputs = tree.map_structure(swap_batch_timestep, outputs)
+
+    return last_output, outputs, new_states
+
+
+def cudnn_ok(*args, **kwargs):
+    return False
+
+
+def lstm(*args, **kwargs):
+    raise NotImplementedError
+
+
+def gru(*args, **kwargs):
+    raise NotImplementedError
+
+
+def unstack(x, axis=0):
+    return [
+        lax.index_in_dim(x, i, axis, keepdims=False)
+        for i in range(x.shape[axis])
+    ]

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/jax/tensorboard.py

@@ -0,0 +1,23 @@
+from keras.src.utils.module_utils import jax
+
+
+def start_trace(logdir):
+    if logdir:
+        jax.profiler.start_trace(logdir)
+
+
+def stop_trace(save):
+    if save:
+        jax.profiler.stop_trace()
+
+
+def start_batch_trace(batch):
+    batch_trace_context = jax.profiler.TraceAnnotation(
+        f"Profiled batch {batch}"
+    )
+    batch_trace_context.__enter__()
+    return batch_trace_context
+
+
+def stop_batch_trace(batch_trace_context):
+    batch_trace_context.__exit__(None, None, None)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/openvino/random.py

@@ -0,0 +1,103 @@
+import numpy as np
+import openvino.runtime.opset14 as ov_opset
+from openvino import Type
+
+from keras.src.backend.config import floatx
+from keras.src.backend.openvino.core import OPENVINO_DTYPES
+from keras.src.backend.openvino.core import OpenVINOKerasTensor
+from keras.src.backend.openvino.core import convert_to_numpy
+from keras.src.random.seed_generator import SeedGenerator
+from keras.src.random.seed_generator import draw_seed
+from keras.src.random.seed_generator import make_default_seed
+
+
+def normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None):
+    dtype = dtype or floatx()
+    seed = draw_seed(seed)
+    rng = np.random.default_rng(seed.data)
+    normal_const = rng.normal(size=shape, loc=mean, scale=stddev).astype(dtype)
+    return OpenVINOKerasTensor(ov_opset.constant(normal_const).output(0))
+
+
+def uniform(shape, minval=0.0, maxval=1.0, dtype=None, seed=None):
+    dtype = dtype or floatx()
+    ov_type = OPENVINO_DTYPES[dtype]
+    seed = draw_seed(seed)
+    if isinstance(seed, OpenVINOKerasTensor):
+        seed1, seed2 = convert_to_numpy(seed)
+    else:
+        seed1, seed2 = draw_seed(seed).data
+    minval_const = ov_opset.constant(minval, dtype=dtype)
+    maxval_const = ov_opset.constant(maxval, dtype=dtype)
+    if isinstance(shape, tuple):
+        shape = list(shape)
+    output_shape_const = ov_opset.constant(shape, dtype=Type.i32)
+    random_uniform = ov_opset.random_uniform(
+        output_shape_const, minval_const, maxval_const, ov_type, seed1, seed2
+    )
+    return OpenVINOKerasTensor(random_uniform.output(0))
+
+
+def categorical(logits, num_samples, dtype="int64", seed=None):
+    raise NotImplementedError(
+        "`categorical` is not supported with openvino backend"
+    )
+
+
+def randint(shape, minval, maxval, dtype="int32", seed=None):
+    raise NotImplementedError(
+        "`randint` is not supported with openvino backend"
+    )
+
+
+def truncated_normal(shape, mean=0.0, stddev=1.0, dtype=None, seed=None):
+    dtype = dtype or floatx()
+    seed = draw_seed(seed)
+    rng = np.random.default_rng(seed.data)
+
+    lower_bound = mean - 2 * stddev
+    upper_bound = mean + 2 * stddev
+
+    flat_shape = np.prod(shape)
+    random_numbers = np.empty(0)
+
+    # loop until we have enough valid numbers to fill our desired shape
+    while random_numbers.shape[0] < flat_shape:
+        # Generate a batch of random numbers from a normal distribution
+        batch = rng.normal(loc=mean, scale=stddev, size=flat_shape)
+
+        # Filter the numbers to keep only those within the specified bounds
+        valid = batch[(batch >= lower_bound) & (batch <= upper_bound)]
+
+        # Append the valid numbers to the result array
+        random_numbers = np.append(random_numbers, valid)
+
+    # Truncate the result array to the desired size and reshape it
+    np_array_res = random_numbers[:flat_shape].astype(dtype).reshape(shape)
+    return OpenVINOKerasTensor(ov_opset.constant(np_array_res).output(0))
+
+
+def dropout(inputs, rate, noise_shape=None, seed=None):
+    raise NotImplementedError(
+        "`dropout` is not supported with openvino backend"
+    )
+
+
+def shuffle(x, axis=0, seed=None):
+    raise NotImplementedError(
+        "`shuffle` is not supported with openvino backend"
+    )
+
+
+def gamma(shape, alpha, dtype=None, seed=None):
+    raise NotImplementedError("`gamma` is not supported with openvino backend")
+
+
+def binomial(shape, counts, probabilities, dtype=None, seed=None):
+    raise NotImplementedError(
+        "`binomial` is not supported with openvino backend"
+    )
+
+
+def beta(shape, alpha, beta, dtype=None, seed=None):
+    raise NotImplementedError("`beta` is not supported with openvino backend")

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/openvino/trainer.py

@@ -0,0 +1,272 @@
+import numpy as np
+import openvino as ov
+import openvino.runtime.opset14 as ov_opset
+
+from keras.src import backend
+from keras.src import callbacks as callbacks_module
+from keras.src import tree
+from keras.src.backend.openvino.core import OPENVINO_DTYPES
+from keras.src.backend.openvino.core import OpenVINOKerasTensor
+from keras.src.backend.openvino.core import get_device
+from keras.src.trainers import trainer as base_trainer
+from keras.src.trainers.data_adapters import data_adapter_utils
+from keras.src.trainers.epoch_iterator import EpochIterator
+from keras.src.utils import traceback_utils
+
+
+class OpenVINOTrainer(base_trainer.Trainer):
+    def __init__(self):
+        super().__init__()
+        self.test_function = None
+        self.predict_function = None
+        self.ov_compiled_model = None
+        self.ov_device = None
+        self.struct_params = None
+        self.struct_outputs = None
+
+    def _unpack_singleton(self, x):
+        if isinstance(x, (list, tuple)) and len(x) == 1:
+            return x[0]
+        return x
+
+    def test_step(self, data):
+        raise NotImplementedError(
+            "`test_step` is not supported with openvino backend"
+        )
+
+    def predict_step(self, data):
+        x, _, _ = data_adapter_utils.unpack_x_y_sample_weight(data)
+        ov_compiled_model = self._get_compiled_model(x)
+        flatten_x = tree.flatten(x)
+        y_pred = ov_compiled_model(flatten_x)
+        # recover structure of the model output
+        y_pred = self._unpack_singleton(
+            tree.pack_sequence_as(self.struct_outputs, y_pred.to_tuple())
+        )
+        return y_pred
+
+    def make_test_function(self, force=False):
+        if self.test_function is not None and not force:
+            return self.test_function
+
+        def one_test_step(data):
+            data = data[0]
+            return self.test_step(data)
+
+        def multi_test_steps(data):
+            for single_step_data in data:
+                logs = one_test_step([single_step_data])
+            return logs
+
+        if self.steps_per_execution > 1:
+            test_step = multi_test_steps
+        else:
+            test_step = one_test_step
+
+        self.test_function = test_step
+
+    def _parameterize_data(self, data):
+        if isinstance(data, (list, tuple)):
+            parametrize_data = []
+            for elem in data:
+                param_elem = self._parameterize_data(elem)
+                parametrize_data.append(param_elem)
+        elif isinstance(data, dict):
+            parametrize_data = dict()
+            for elem_name, elem in data.items():
+                param_elem = self._parameterize_data(elem)
+                parametrize_data[elem_name] = param_elem
+        elif isinstance(data, np.ndarray) or np.isscalar(data):
+            ov_type = OPENVINO_DTYPES[str(data.dtype)]
+            ov_shape = list(data.shape)
+            param = ov_opset.parameter(shape=ov_shape, dtype=ov_type)
+            parametrize_data = OpenVINOKerasTensor(param.output(0))
+        elif isinstance(data, int):
+            param = ov_opset.parameter(shape=[], dtype=ov.Type.i32)
+            parametrize_data = OpenVINOKerasTensor(param.output(0))
+        elif isinstance(data, float):
+            param = ov_opset.parameter(shape=[], dtype=ov.Type.f32)
+            parametrize_data = OpenVINOKerasTensor(param.output(0))
+        else:
+            raise "Unknown type of input data {}".format(type(data))
+        return parametrize_data
+
+    def _get_compiled_model(self, data):
+        if (
+            self.ov_compiled_model is not None
+            and get_device() == self.ov_device
+        ):
+            return self.ov_compiled_model
+
+        # remove the previous cached compiled model if exists
+        del self.ov_compiled_model
+
+        # prepare parameterized input
+        self.struct_params = self._parameterize_data(data)
+        # construct OpenVINO graph during calling Keras Model
+        self.struct_outputs = self(self.struct_params)
+
+        parameters = []
+        for p in tree.flatten(self.struct_params):
+            parameters.append(p.output.get_node())
+        results = []
+        for r in tree.flatten(self.struct_outputs):
+            results.append(ov_opset.result(r.output))
+
+        # prepare compiled model from scratch
+        ov_model = ov.Model(results=results, parameters=parameters)
+        self.ov_compiled_model = ov.compile_model(ov_model, get_device())
+        self.ov_device = get_device()
+        return self.ov_compiled_model
+
+    def make_predict_function(self, force=False):
+        if self.predict_function is not None and not force:
+            return self.predict_function
+
+        def one_predict_step(data):
+            data = data[0]
+            return self.predict_step(data)
+
+        def multi_predict_steps(data):
+            outputs = one_predict_step(data[:1])
+
+            for single_step_data in data[1:]:
+                step_outputs = one_predict_step([single_step_data])
+                outputs = tree.map_structure(
+                    lambda t1, t2: np.concatenate([t1, t2]),
+                    outputs,
+                    step_outputs,
+                )
+            return outputs
+
+        if self.steps_per_execution > 1:
+            predict_step = multi_predict_steps
+        else:
+            predict_step = one_predict_step
+
+        self.predict_function = predict_step
+
+    def fit(
+        self,
+        x=None,
+        y=None,
+        batch_size=None,
+        epochs=1,
+        verbose="auto",
+        callbacks=None,
+        validation_split=0.0,
+        validation_data=None,
+        shuffle=True,
+        class_weight=None,
+        sample_weight=None,
+        initial_epoch=0,
+        steps_per_epoch=None,
+        validation_steps=None,
+        validation_batch_size=None,
+        validation_freq=1,
+    ):
+        raise NotImplementedError(
+            "`fit` is not supported with openvino backend"
+        )
+
+    @traceback_utils.filter_traceback
+    def predict(
+        self, x, batch_size=None, verbose="auto", steps=None, callbacks=None
+    ):
+        # Create an iterator that yields batches of input data.
+        epoch_iterator = EpochIterator(
+            x=x,
+            batch_size=batch_size,
+            steps_per_epoch=steps,
+            shuffle=False,
+            steps_per_execution=self.steps_per_execution,
+        )
+
+        # Container that configures and calls callbacks.
+        if not isinstance(callbacks, callbacks_module.CallbackList):
+            callbacks = callbacks_module.CallbackList(
+                callbacks,
+                add_history=True,
+                add_progbar=verbose != 0,
+                verbose=verbose,
+                epochs=1,
+                steps=epoch_iterator.num_batches,
+                model=self,
+            )
+
+        def append_to_outputs(batch_outputs, outputs):
+            if outputs is None:
+                outputs = tree.map_structure(
+                    lambda batch_output: [batch_output],
+                    batch_outputs,
+                )
+            else:
+                tree.map_structure_up_to(
+                    batch_outputs,
+                    lambda output, batch_output: output.append(batch_output),
+                    outputs,
+                    batch_outputs,
+                )
+            return outputs
+
+        self.make_predict_function()
+        self.stop_predicting = False
+        callbacks.on_predict_begin()
+        outputs = None
+        for step, data in epoch_iterator.enumerate_epoch():
+            callbacks.on_predict_batch_begin(step)
+            batch_outputs = self.predict_function(data)
+            outputs = append_to_outputs(batch_outputs, outputs)
+            callbacks.on_predict_batch_end(step, {"outputs": batch_outputs})
+            if self.stop_predicting:
+                break
+        callbacks.on_predict_end()
+        return tree.map_structure_up_to(batch_outputs, np.concatenate, outputs)
+
+    @traceback_utils.filter_traceback
+    def evaluate(
+        self,
+        x=None,
+        y=None,
+        batch_size=None,
+        verbose="auto",
+        sample_weight=None,
+        steps=None,
+        callbacks=None,
+        return_dict=False,
+        **kwargs,
+    ):
+        raise NotImplementedError(
+            "`evaluate` is not supported with openvino backend"
+        )
+
+    def train_on_batch(
+        self,
+        x,
+        y=None,
+        sample_weight=None,
+        class_weight=None,
+        return_dict=False,
+    ):
+        raise NotImplementedError(
+            "`train_on_batch` is not supported with openvino backend"
+        )
+
+    def test_on_batch(
+        self,
+        x,
+        y=None,
+        sample_weight=None,
+        return_dict=False,
+    ):
+        raise NotImplementedError(
+            "`test_on_batch` is not supported with openvino backend"
+        )
+
+    def predict_on_batch(self, x):
+        self.make_predict_function()
+        batch_outputs = self.predict_function([(x,)])
+        batch_outputs = tree.map_structure(
+            backend.convert_to_numpy, batch_outputs
+        )
+        return batch_outputs

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/__init__.py

@@ -0,0 +1,29 @@
+from keras.src.backend.tensorflow import core
+from keras.src.backend.tensorflow import distribution_lib
+from keras.src.backend.tensorflow import image
+from keras.src.backend.tensorflow import linalg
+from keras.src.backend.tensorflow import math
+from keras.src.backend.tensorflow import nn
+from keras.src.backend.tensorflow import numpy
+from keras.src.backend.tensorflow import random
+from keras.src.backend.tensorflow import tensorboard
+from keras.src.backend.tensorflow.core import IS_THREAD_SAFE
+from keras.src.backend.tensorflow.core import SUPPORTS_SPARSE_TENSORS
+from keras.src.backend.tensorflow.core import Variable
+from keras.src.backend.tensorflow.core import cast
+from keras.src.backend.tensorflow.core import compute_output_spec
+from keras.src.backend.tensorflow.core import cond
+from keras.src.backend.tensorflow.core import convert_to_numpy
+from keras.src.backend.tensorflow.core import convert_to_tensor
+from keras.src.backend.tensorflow.core import device_scope
+from keras.src.backend.tensorflow.core import is_tensor
+from keras.src.backend.tensorflow.core import name_scope
+from keras.src.backend.tensorflow.core import random_seed_dtype
+from keras.src.backend.tensorflow.core import scatter
+from keras.src.backend.tensorflow.core import shape
+from keras.src.backend.tensorflow.core import stop_gradient
+from keras.src.backend.tensorflow.core import vectorized_map
+from keras.src.backend.tensorflow.rnn import cudnn_ok
+from keras.src.backend.tensorflow.rnn import gru
+from keras.src.backend.tensorflow.rnn import lstm
+from keras.src.backend.tensorflow.rnn import rnn

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/core.py

@@ -0,0 +1,670 @@
+import builtins
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.compiler.tf2xla.python.xla import dynamic_update_slice
+
+from keras.src import tree
+from keras.src.backend.common import KerasVariable
+from keras.src.backend.common import global_state
+from keras.src.backend.common import is_int_dtype
+from keras.src.backend.common import standardize_dtype
+from keras.src.backend.common.backend_utils import slice_along_axis
+from keras.src.backend.common.keras_tensor import KerasTensor
+from keras.src.backend.common.name_scope import name_scope as base_name_scope
+from keras.src.backend.common.stateless_scope import StatelessScope
+from keras.src.backend.common.stateless_scope import in_stateless_scope
+from keras.src.backend.common.symbolic_scope import SymbolicScope
+from keras.src.backend.tensorflow.sparse import sparse_to_dense
+from keras.src.utils.naming import auto_name
+
+SUPPORTS_SPARSE_TENSORS = True
+# https://github.com/tensorflow/tensorflow/issues/78338
+IS_THREAD_SAFE = False
+
+
+class Variable(
+    KerasVariable,
+    tf.__internal__.types.Tensor,
+    tf.__internal__.tracking.Trackable,
+):
+    _should_act_as_resource_variable = True
+
+    @property
+    def handle(self):
+        return self.value.handle
+
+    def _initialize(self, value):
+        self._value = tf.Variable(
+            value,
+            dtype=self._dtype,
+            trainable=self.trainable,
+            name=self.name,
+            aggregation=self._map_aggregation(self.aggregation),
+        )
+
+    def _initialize_with_initializer(self, initializer):
+        self._initialize(lambda: initializer(self._shape, dtype=self._dtype))
+
+    def _deferred_initialize(self):
+        if self._value is not None:
+            raise ValueError(f"Variable {self.path} is already initialized.")
+
+        if in_stateless_scope():
+            raise ValueError(
+                "You are attempting to initialize a variable "
+                "while in a stateless scope. This is disallowed. "
+                "Make sure that all variables are initialized "
+                "before you start using your layer/model objects."
+            )
+        with tf.init_scope():
+            self._initialize_with_initializer(self._initializer)
+            self._initializer = None
+
+    def _direct_assign(self, value):
+        self._value.assign(tf.cast(value, self._value.dtype))
+
+    def _convert_to_tensor(self, value, dtype=None):
+        return convert_to_tensor(value, dtype=dtype)
+
+    def numpy(self):  # noqa: F811
+        return self.value.numpy()
+
+    @property
+    def shape(self):
+        return tf.TensorShape(super().shape)
+
+    # Overload native accessor.
+    def __tf_tensor__(self, dtype=None, name=None):
+        return tf.convert_to_tensor(self.value, dtype=dtype, name=name)
+
+    # Methods below are for SavedModel support
+    @property
+    def _shared_name(self):
+        return self.value._shared_name
+
+    def _serialize_to_tensors(self):
+        try:
+            return self.value._serialize_to_tensors()
+        except NotImplementedError:
+            return {"VARIABLE_VALUE": self.value}
+
+    def _restore_from_tensors(self, restored_tensors):
+        try:
+            return self.value._restore_from_tensors(restored_tensors)
+        except NotImplementedError:
+            self.assign(restored_tensors["VARIABLE_VALUE"])
+            return self.value
+
+    def _copy_trackable_to_cpu(self, object_map):
+        self.value._copy_trackable_to_cpu(object_map)
+        object_map[self] = tf.Variable(object_map[self.value])
+
+    def _export_to_saved_model_graph(
+        self, object_map, tensor_map, options, **kwargs
+    ):
+        resource_list = self.value._export_to_saved_model_graph(
+            object_map, tensor_map, options, **kwargs
+        )
+        object_map[self] = tf.Variable(object_map[self.value])
+        return resource_list
+
+    def _write_object_proto(self, proto, options):
+        return self.value._write_object_proto(proto, options)
+
+    def _map_aggregation(self, aggregation):
+        mapping = {
+            "none": tf.VariableAggregation.NONE,
+            "sum": tf.VariableAggregation.SUM,
+            "mean": tf.VariableAggregation.MEAN,
+            "only_first_replica": tf.VariableAggregation.ONLY_FIRST_REPLICA,
+        }
+        return mapping[aggregation]
+
+
+def convert_to_tensor(x, dtype=None, sparse=None):
+    if isinstance(x, tf.SparseTensor) and sparse is not None and not sparse:
+        x = sparse_to_dense(x)
+    if dtype is not None:
+        dtype = standardize_dtype(dtype)
+    if not tf.is_tensor(x):
+        if dtype == "bool" or is_int_dtype(dtype):
+            # TensorFlow conversion is stricter than other backends, it does not
+            # allow ints for bools or floats for ints. We convert without dtype
+            # and cast instead.
+            x = tf.convert_to_tensor(x)
+            return tf.cast(x, dtype)
+        return tf.convert_to_tensor(x, dtype=dtype)
+    elif dtype is not None and not x.dtype == dtype:
+        if isinstance(x, tf.SparseTensor):
+            x_shape = x.shape
+            x = tf.cast(x, dtype)
+            x.set_shape(x_shape)
+            return x
+        return tf.cast(x, dtype=dtype)
+    return x
+
+
+def convert_to_numpy(x):
+    if isinstance(x, tf.SparseTensor):
+        x = sparse_to_dense(x)
+    elif isinstance(x, tf.IndexedSlices):
+        x = tf.convert_to_tensor(x)
+    elif isinstance(x, tf.RaggedTensor):
+        x = x.to_tensor()
+    return np.array(x)
+
+
+def is_tensor(x):
+    return tf.is_tensor(x)
+
+
+def shape(x):
+    """Always return a tuple shape.
+
+    `tf.shape` will return a `tf.Tensor`, which differs from the tuple return
+    type on the torch and jax backends. We write our own method instead which
+    always returns a tuple, with integer values when the shape is known, and
+    tensor values when the shape is unknown (this is tf specific, as dynamic
+    shapes do not apply in other backends).
+    """
+    if isinstance(x, KerasTensor):
+        return x.shape
+    if not tf.is_tensor(x):
+        x = tf.convert_to_tensor(x)
+    if x.shape == tf.TensorShape(None):
+        raise ValueError(
+            "All tensors passed to `ops.shape` must have a statically known "
+            f"rank. Received: x={x} with unknown rank."
+        )
+    shape = x.shape.as_list()
+    dynamic = tf.shape(x)
+    for i in range(len(shape)):
+        if shape[i] is None:
+            try:
+                shape[i] = dynamic[i]
+            except:
+                # With RaggedTensors, accessing a ragged dimension will fail,
+                # we leave it as None.
+                pass
+    return tuple(shape)
+
+
+def cast(x, dtype):
+    dtype = standardize_dtype(dtype)
+    if isinstance(x, tf.SparseTensor):
+        x_shape = x.shape
+        x = tf.cast(x, dtype)
+        x.set_shape(x_shape)
+        return x
+    else:
+        return tf.cast(x, dtype=dtype)
+
+
+def compute_output_spec(fn, *args, **kwargs):
+    with StatelessScope(), SymbolicScope():
+        graph_name = auto_name("scratch_graph")
+        with tf.__internal__.FuncGraph(graph_name).as_default():
+
+            def convert_keras_tensor_to_tf(x):
+                if isinstance(x, KerasTensor):
+                    if x.sparse:
+                        return tf.compat.v1.sparse_placeholder(
+                            shape=x.shape, dtype=x.dtype
+                        )
+                    else:
+                        return tf.compat.v1.placeholder(
+                            shape=x.shape, dtype=x.dtype
+                        )
+                return x
+
+            args, kwargs = tree.map_structure(
+                convert_keras_tensor_to_tf, (args, kwargs)
+            )
+            tf_out = fn(*args, **kwargs)
+
+            def convert_tf_to_keras_tensor(x):
+                if tf.is_tensor(x):
+                    return KerasTensor(
+                        x.shape, x.dtype, sparse=isinstance(x, tf.SparseTensor)
+                    )
+                return x
+
+            output_spec = tree.map_structure(convert_tf_to_keras_tensor, tf_out)
+    return output_spec
+
+
+def cond(pred, true_fn, false_fn):
+    if isinstance(pred, tf.Variable):
+        return tf.cond(pred, true_fn=true_fn, false_fn=false_fn)
+    return tf.__internal__.smart_cond.smart_cond(
+        pred, true_fn=true_fn, false_fn=false_fn
+    )
+
+
+def vectorized_map(function, elements):
+    return tf.vectorized_map(function, elements)
+
+
+def map(f, xs):
+    xs = tree.map_structure(convert_to_tensor, xs)
+
+    def get_fn_output_signature(x):
+        out = f(x)
+        return tree.map_structure(tf.TensorSpec.from_tensor, out)
+
+    if tree.is_nested(xs):
+        input = tree.pack_sequence_as(xs, [x[0] for x in tree.flatten(xs)])
+        fn_output_signature = get_fn_output_signature(input)
+        return tf.map_fn(f, xs, fn_output_signature=fn_output_signature)
+    else:
+        fn_output_signature = get_fn_output_signature(xs[0])
+        return tf.map_fn(f, xs, fn_output_signature=fn_output_signature)
+
+
+def scan(f, init, xs=None, length=None, reverse=False, unroll=1):
+    # We have reimplemented `scan` to match the behavior of `jax.lax.scan`
+    # Ref: tf.scan, jax.lax.scan
+    if not callable(f):
+        raise TypeError(f"`f` should be a callable. Received: f={f}")
+    if not isinstance(unroll, bool):
+        if not isinstance(unroll, int) or unroll < 1:
+            raise ValueError(
+                "`unroll` must be an positive integer or boolean. "
+                f"Received: unroll={unroll}"
+            )
+    if xs is None and length is None:
+        raise ValueError("Got no `xs` to scan over and `length` not provided.")
+
+    input_is_sequence = tree.is_nested(xs)
+    output_is_sequence = tree.is_nested(init)
+
+    def pack_input(x):
+        return tree.pack_sequence_as(xs, x) if input_is_sequence else x[0]
+
+    def pack_output(x):
+        return tree.pack_sequence_as(init, x) if output_is_sequence else x[0]
+
+    if xs is None:
+        xs_flat = []
+        n = int(length)
+    else:
+        # xs_flat = flatten_input(xs)
+        xs_flat = tree.flatten(xs)
+        xs_flat = [tf.convert_to_tensor(elem) for elem in xs_flat]
+        n = int(length) if length is not None else tf.shape(xs_flat[0])[0]
+
+    # TensorArrays are always flat
+    xs_array = [
+        tf.TensorArray(
+            dtype=x.dtype,
+            size=n,
+            dynamic_size=False,
+            element_shape=x.shape[1:],
+            infer_shape=True,
+        )
+        for x in xs_flat
+    ]
+    xs_array = [x_a.unstack(x) for x_a, x in zip(xs_array, xs_flat)]
+
+    init_flat = tree.flatten(init)
+    carry_flat = [tf.convert_to_tensor(init) for init in init_flat]
+
+    # Store the intermediate values
+    # Note: there is a constraint that the output of `f` must have the same
+    # shape and dtype as carry (`init`).
+    ys_array = [
+        tf.TensorArray(
+            dtype=carry.dtype,
+            size=n,
+            dynamic_size=False,
+            element_shape=carry.shape,
+            infer_shape=True,
+        )
+        for carry in carry_flat
+    ]
+    carry_array = [
+        tf.TensorArray(
+            dtype=carry.dtype,
+            size=1,
+            dynamic_size=False,
+            clear_after_read=False,
+            element_shape=carry.shape,
+            infer_shape=True,
+        )
+        for carry in carry_flat
+    ]
+    carry_array = [
+        carry.write(0, c) for (carry, c) in zip(carry_array, carry_flat)
+    ]
+
+    def loop_body(i, carry_array, ys_array):
+        packed_xs = (
+            pack_input([xs.read(i) for xs in xs_array])
+            if len(xs_array) > 0
+            else None
+        )
+        packed_carry = pack_output([carry.read(0) for carry in carry_array])
+
+        carry, ys = f(packed_carry, packed_xs)
+
+        if ys is not None:
+            flat_ys = tree.flatten(ys)
+            ys_array = [ys.write(i, v) for (ys, v) in zip(ys_array, flat_ys)]
+        if carry is not None:
+            flat_carry = tree.flatten(carry)
+            carry_array = [
+                carry.write(0, v) for (carry, v) in zip(carry_array, flat_carry)
+            ]
+        next_i = i + 1 if not reverse else i - 1
+        return (next_i, carry_array, ys_array)
+
+    if isinstance(unroll, bool):
+        unroll = max(n, 1) if unroll else 1
+
+    _, carry_array, ys_array = tf.while_loop(
+        lambda i, _1, _2: i >= 0 if reverse else i < n,
+        loop_body,
+        (n - 1 if reverse else 0, carry_array, ys_array),
+        parallel_iterations=unroll,
+    )
+
+    ys_flat = [ys.stack() for ys in ys_array]
+    carry_flat = [carry.read(0) for carry in carry_array]
+    if xs is not None:
+        n_static = xs_flat[0].get_shape().with_rank_at_least(1)[0]
+        if not isinstance(n_static, int):
+            for x in xs_flat[1:]:
+                n_static.assert_is_compatible_with(
+                    x.get_shape().with_rank_at_least(1)[0]
+                )
+        for r in ys_flat:
+            r.set_shape(tf.TensorShape(n_static).concatenate(r.get_shape()[1:]))
+    return pack_output(carry_flat), pack_output(ys_flat)
+
+
+def associative_scan(f, elems, reverse=False, axis=0):
+    # Implementation is the same as tfp.math.scan_associative
+    # with additional checks to ensure similar behavior with jax
+    if not callable(f):
+        raise TypeError(f"`f` should be a callable. Received: f={f}")
+    elems_flat = tree.flatten(elems)
+    elems_flat = [tf.convert_to_tensor(elem) for elem in elems_flat]
+    if reverse:
+        elems_flat = [tf.reverse(elem, [axis]) for elem in elems_flat]
+
+    def _combine(a_flat, b_flat):
+        a = tree.pack_sequence_as(elems, a_flat)
+        b = tree.pack_sequence_as(elems, b_flat)
+        c = f(a, b)
+        c_flat = tree.flatten(c)
+        return c_flat
+
+    def _get_dim(x):
+        return shape(x)[axis]
+
+    # TODO add constant dim check
+    num_elems = _get_dim(elems_flat[0])
+    if not all(_get_dim(elem) == num_elems for elem in elems_flat[1:]):
+        raise ValueError(
+            "Array inputs to associative_scan must have the same "
+            "first dimension. (saw: {})".format(
+                [tf.shape(elem) for elem in elems_flat]
+            )
+        )
+
+    def _interleave(a, b, axis):
+        # [a b c ...] [d e f ...] -> [a d b e c f ...]
+        num_elems_a = _get_dim(a)
+        num_elems_b = _get_dim(b)
+
+        # Note that interleaving implies rank(a)==rank(b).
+        axis = tf.where(axis >= 0, axis, tf.rank(a) + axis)
+        axis = (
+            int(axis)  # Avoid ndarray values.
+            if tf.get_static_value(axis) is not None
+            else axis
+        )
+
+        def _interleave_with_b(a):
+            return tf.reshape(
+                # Work around lack of support for Tensor axes in
+                # `tf.stack` by using `concat` and `expand_dims` instead.
+                tf.concat(
+                    [
+                        tf.expand_dims(a, axis=axis + 1),
+                        tf.expand_dims(b, axis=axis + 1),
+                    ],
+                    axis=axis + 1,
+                ),
+                tf.concat(
+                    [
+                        a.get_shape()[:axis],
+                        [2 * num_elems_b],
+                        a.get_shape()[axis + 1 :],
+                    ],
+                    axis=0,
+                ),
+            )
+
+        return tf.cond(
+            tf.equal(num_elems_a, num_elems_b + 1),
+            lambda: tf.concat(
+                [
+                    _interleave_with_b(
+                        slice_along_axis(a, None, -1, axis=axis)
+                    ),
+                    slice_along_axis(a, -1, None, axis=axis),
+                ],
+                axis=axis,
+            ),
+            lambda: _interleave_with_b(a),
+        )
+
+    def _scan(elems):
+        elem_length = _get_dim(elems[0])
+        a = [slice_along_axis(elem, 0, -1, step=2, axis=axis) for elem in elems]
+        b = [
+            slice_along_axis(elem, 1, None, step=2, axis=axis) for elem in elems
+        ]
+        reduced_elems = _combine(a, b)
+
+        def _handle_base_case_elem_length_two():
+            return [
+                tf.concat(
+                    [slice_along_axis(elem, 0, 1, axis=axis), reduced_elem],
+                    axis=axis,
+                )
+                for (reduced_elem, elem) in zip(reduced_elems, elems)
+            ]
+
+        def _handle_base_case_elem_length_three():
+            reduced_reduced_elems = _combine(
+                reduced_elems,
+                [slice_along_axis(elem, 2, 3, axis=axis) for elem in elems],
+            )
+            return [
+                tf.concat(
+                    [
+                        slice_along_axis(elem, 0, 1, axis=axis),
+                        reduced_elem,
+                        reduced_reduced_elem,
+                    ],
+                    axis=axis,
+                )
+                for (reduced_reduced_elem, reduced_elem, elem) in zip(
+                    reduced_reduced_elems, reduced_elems, elems
+                )
+            ]
+
+        at_base_case = tf.logical_or(
+            tf.equal(elem_length, 2), tf.equal(elem_length, 3)
+        )
+
+        def _base_case():
+            return tf.cond(
+                tf.equal(elem_length, 2),
+                _handle_base_case_elem_length_two,
+                _handle_base_case_elem_length_three,
+            )
+
+        def _recursive_case():
+            odd_elems = _scan(reduced_elems)
+
+            def _even_length_case():
+                return _combine(
+                    [
+                        slice_along_axis(odd_elem, 0, -1, axis=axis)
+                        for odd_elem in odd_elems
+                    ],
+                    [
+                        slice_along_axis(elem, 2, None, 2, axis=axis)
+                        for elem in elems
+                    ],
+                )
+
+            def _odd_length_case():
+                return _combine(
+                    [odd_elem for odd_elem in odd_elems],
+                    [
+                        slice_along_axis(elem, 2, None, 2, axis=axis)
+                        for elem in elems
+                    ],
+                )
+
+            results = tf.cond(
+                tf.equal(elem_length % 2, 0),
+                _even_length_case,
+                _odd_length_case,
+            )
+
+            even_elems = [
+                tf.concat(
+                    [slice_along_axis(elem, 0, 1, axis=axis), result], axis=axis
+                )
+                for (elem, result) in zip(elems, results)
+            ]
+            return list(
+                builtins.map(
+                    lambda a, b: _interleave(a, b, axis=axis),
+                    even_elems,
+                    odd_elems,
+                )
+            )
+
+        return tf.cond(at_base_case, _base_case, _recursive_case)
+
+    scans = _scan(elems_flat)
+    if reverse:
+        scans = [tf.reverse(scanned, [axis]) for scanned in scans]
+
+    return tree.pack_sequence_as(elems, scans)
+
+
+def scatter(indices, values, shape):
+    return tf.scatter_nd(indices, values, shape)
+
+
+def scatter_update(inputs, indices, updates):
+    return tf.tensor_scatter_nd_update(inputs, indices, updates)
+
+
+def slice(inputs, start_indices, shape):
+    return tf.slice(inputs, start_indices, shape)
+
+
+def slice_update(inputs, start_indices, updates):
+    return dynamic_update_slice(inputs, updates, start_indices)
+
+
+def switch(index, branches, *operands):
+    index = convert_to_tensor(index, "int32")
+    index = tf.clip_by_value(index, 0, len(branches) - 1)
+
+    # Workaround to deal with python closures. More details:
+    # https://github.com/tensorflow/tensorflow/issues/8776#issuecomment-311383887
+    def gen_fn(i):
+        return lambda: branches[i](*operands)
+
+    branch_fns = [gen_fn(i) for i in range(len(branches))]
+    return tf.switch_case(index, branch_fns)
+
+
+def while_loop(
+    cond,
+    body,
+    loop_vars,
+    maximum_iterations=None,
+):
+    is_tuple = isinstance(loop_vars, (tuple, list))
+    loop_vars = tuple(loop_vars) if is_tuple else (loop_vars,)
+
+    def _body(*args):
+        outputs = body(*args)
+        return tuple(outputs) if is_tuple else (outputs,)
+
+    outputs = tf.while_loop(
+        cond,
+        _body,
+        loop_vars,
+        maximum_iterations=maximum_iterations,
+    )
+    return outputs if is_tuple else outputs[0]
+
+
+def fori_loop(lower, upper, body_fun, init_val):
+    return tf.while_loop(
+        lambda i, val: i < upper,
+        lambda i, val: (i + 1, body_fun(i, val)),
+        (lower, init_val),
+    )[1]
+
+
+def stop_gradient(variable):
+    return tf.stop_gradient(variable)
+
+
+def unstack(x, num=None, axis=0):
+    return tf.unstack(x, num=num, axis=axis)
+
+
+def random_seed_dtype():
+    # tensorflow random operation only works on int32/int64, not uint32.
+    return "int64"
+
+
+def custom_gradient(fun):
+    return tf.custom_gradient(f=fun)
+
+
+class name_scope(base_name_scope):
+    def __init__(self, name, **kwargs):
+        super().__init__(name, **kwargs)
+        self._tf_name_scope = tf.name_scope(name)
+
+    def __enter__(self):
+        name_scope_stack = global_state.get_global_attribute(
+            "name_scope_stack", default=[], set_to_default=True
+        )
+        if self.deduplicate and name_scope_stack:
+            parent_caller = name_scope_stack[-1].caller
+            parent_name = name_scope_stack[-1].name
+            if (
+                self.caller is not None
+                and self.caller is parent_caller
+                and self.name == parent_name
+            ):
+                return self
+        name_scope_stack.append(self)
+        self._pop_on_exit = True
+        self._tf_name_scope.__enter__()
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        super().__exit__(*args, **kwargs)
+        if self._pop_on_exit:
+            self._tf_name_scope.__exit__(*args, **kwargs)
+
+
+def device_scope(device_name):
+    return tf.device(device_name)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/distribution_lib.py

@@ -0,0 +1,87 @@
+"""!!!DO NOT USE!!!
+
+Distribution related class for Tensorflow backend.
+
+This is just a prototype and we might want to unify it
+with other backends in the future.
+"""
+
+import tensorflow as tf
+from tensorflow.experimental import dtensor
+
+
+def list_devices(device_type=None):
+    """Return all the available devices based on the device type.
+
+    Note that this should return the global devices in a distributed setting.
+
+    Args:
+        device_type: string of `"cpu"`, `"gpu"` or `"tpu"`. Default to `gpu` or
+        `tpu` if available when device_type is not provided. Otherwise will
+        return the `cpu` devices.
+
+    Return:
+        List of devices that are available for distribute computation.
+    """
+    device_type = device_type.upper() if device_type else None
+
+    # DTensor doesn't support getting global devices, even when knowing the
+    # Mesh. Use TF API instead to get global devices. Coordinator service is
+    # enabled by default with DTensor, so that list_logical_devices() returns
+    # a list of global devices. More context can be found in b/254911601.
+    tf_devices = tf.config.list_logical_devices(device_type=device_type)
+    cpu_devices = []
+    other_devices = []
+    for device in tf_devices:
+        if device.device_type.lower() == "cpu":
+            cpu_devices.append(device)
+        else:
+            other_devices.append(device)
+    if device_type is None:
+        tf_devices = other_devices if len(other_devices) > 0 else cpu_devices
+    return [
+        f"{device.device_type.lower()}:{device.name.split(':')[-1]}"
+        for device in tf_devices
+    ]
+
+
+def distribute_value(value, tensor_layout):
+    # TODO
+    pass
+
+
+def _to_dtensor_mesh(device_mesh):
+    """Convert the DeviceMesh to Tensorflow backend specific Mesh.
+
+    Args:
+        device_mesh: DeviceMesh instance to convert.
+
+    Returns:
+        A `tf.dtensor.Mesh` instance.
+    """
+    mesh_dims = list(zip(device_mesh.axis_names, device_mesh.shape))
+    return dtensor.create_distributed_mesh(
+        mesh_dims=mesh_dims, local_devices=device_mesh.devices.flatten()
+    )
+
+
+def _to_dtensor_layout(tensor_layout):
+    """Convert the TensorLayout to Tensorflow backend specific Sharding.
+
+    Args:
+        tensor_layout: TensorLayout instance to convert.
+
+    Returns:
+        A `tf.dtensor.Layout` instance.
+    """
+    if tensor_layout.device_mesh is None:
+        raise ValueError(
+            "Cannot create sharding when device mesh is not set for "
+            "TensorLayout."
+        )
+
+    sharding_specs = [
+        axis if axis else dtensor.UNSHARDED for axis in tensor_layout.axes
+    ]
+    dtensor_mesh = _to_dtensor_mesh(tensor_layout.device_mesh)
+    return dtensor.Layout(sharding_specs=sharding_specs, mesh=dtensor_mesh)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/export.py

@@ -0,0 +1,32 @@
+import tensorflow as tf
+
+from keras.src import layers
+
+
+class TFExportArchive:
+    def track(self, resource):
+        if not isinstance(resource, tf.__internal__.tracking.Trackable):
+            raise ValueError(
+                "Invalid resource type. Expected an instance of a "
+                "TensorFlow `Trackable` (such as a Keras `Layer` or `Model`). "
+                f"Received instead an object of type '{type(resource)}'. "
+                f"Object received: {resource}"
+            )
+
+        if isinstance(resource, layers.Layer):
+            # Variables in the lists below are actually part of the trackables
+            # that get saved, because the lists are created in __init__.
+            variables = resource.variables
+            trainable_variables = resource.trainable_variables
+            non_trainable_variables = resource.non_trainable_variables
+            self._tf_trackable.variables += variables
+            self._tf_trackable.trainable_variables += trainable_variables
+            self._tf_trackable.non_trainable_variables += (
+                non_trainable_variables
+            )
+
+    def add_endpoint(self, name, fn, input_signature=None, **kwargs):
+        decorated_fn = tf.function(
+            fn, input_signature=input_signature, autograph=False
+        )
+        return decorated_fn

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/image.py

@@ -0,0 +1,493 @@
+import functools
+import itertools
+import operator
+
+import tensorflow as tf
+
+from keras.src import backend
+from keras.src.backend.tensorflow.core import convert_to_tensor
+
+RESIZE_INTERPOLATIONS = (
+    "bilinear",
+    "nearest",
+    "lanczos3",
+    "lanczos5",
+    "bicubic",
+    "area",
+)
+
+
+def rgb_to_grayscale(images, data_format=None):
+    images = convert_to_tensor(images)
+    data_format = backend.standardize_data_format(data_format)
+    channels_axis = -1 if data_format == "channels_last" else -3
+    if len(images.shape) not in (3, 4):
+        raise ValueError(
+            "Invalid images rank: expected rank 3 (single image) "
+            "or rank 4 (batch of images). Received input with shape: "
+            f"images.shape={images.shape}"
+        )
+    # Convert to floats
+    original_dtype = images.dtype
+    compute_dtype = backend.result_type(images.dtype, float)
+    images = tf.cast(images, compute_dtype)
+
+    # Ref: tf.image.rgb_to_grayscale
+    rgb_weights = convert_to_tensor(
+        [0.2989, 0.5870, 0.1140], dtype=images.dtype
+    )
+    images = tf.tensordot(images, rgb_weights, axes=(channels_axis, -1))
+    images = tf.expand_dims(images, axis=channels_axis)
+    return tf.cast(images, original_dtype)
+
+
+def rgb_to_hsv(images, data_format=None):
+    images = convert_to_tensor(images)
+    dtype = images.dtype
+    data_format = backend.standardize_data_format(data_format)
+    if len(images.shape) not in (3, 4):
+        raise ValueError(
+            "Invalid images rank: expected rank 3 (single image) "
+            "or rank 4 (batch of images). Received input with shape: "
+            f"images.shape={images.shape}"
+        )
+    if not backend.is_float_dtype(dtype):
+        raise ValueError(
+            "Invalid images dtype: expected float dtype. "
+            f"Received: images.dtype={backend.standardize_dtype(dtype)}"
+        )
+    if data_format == "channels_first":
+        if len(images.shape) == 4:
+            images = tf.transpose(images, (0, 2, 3, 1))
+        else:
+            images = tf.transpose(images, (1, 2, 0))
+    images = tf.image.rgb_to_hsv(images)
+    if data_format == "channels_first":
+        if len(images.shape) == 4:
+            images = tf.transpose(images, (0, 3, 1, 2))
+        elif len(images.shape) == 3:
+            images = tf.transpose(images, (2, 0, 1))
+    return images
+
+
+def hsv_to_rgb(images, data_format=None):
+    images = convert_to_tensor(images)
+    dtype = images.dtype
+    data_format = backend.standardize_data_format(data_format)
+    if len(images.shape) not in (3, 4):
+        raise ValueError(
+            "Invalid images rank: expected rank 3 (single image) "
+            "or rank 4 (batch of images). Received input with shape: "
+            f"images.shape={images.shape}"
+        )
+    if not backend.is_float_dtype(dtype):
+        raise ValueError(
+            "Invalid images dtype: expected float dtype. "
+            f"Received: images.dtype={backend.standardize_dtype(dtype)}"
+        )
+    if data_format == "channels_first":
+        if len(images.shape) == 4:
+            images = tf.transpose(images, (0, 2, 3, 1))
+        else:
+            images = tf.transpose(images, (1, 2, 0))
+    images = tf.image.hsv_to_rgb(images)
+    if data_format == "channels_first":
+        if len(images.shape) == 4:
+            images = tf.transpose(images, (0, 3, 1, 2))
+        elif len(images.shape) == 3:
+            images = tf.transpose(images, (2, 0, 1))
+    return images
+
+
+def resize(
+    images,
+    size,
+    interpolation="bilinear",
+    antialias=False,
+    crop_to_aspect_ratio=False,
+    pad_to_aspect_ratio=False,
+    fill_mode="constant",
+    fill_value=0.0,
+    data_format=None,
+):
+    data_format = backend.standardize_data_format(data_format)
+    if interpolation not in RESIZE_INTERPOLATIONS:
+        raise ValueError(
+            "Invalid value for argument `interpolation`. Expected of one "
+            f"{RESIZE_INTERPOLATIONS}. Received: interpolation={interpolation}"
+        )
+    if fill_mode != "constant":
+        raise ValueError(
+            "Invalid value for argument `fill_mode`. Only `'constant'` "
+            f"is supported. Received: fill_mode={fill_mode}"
+        )
+    if pad_to_aspect_ratio and crop_to_aspect_ratio:
+        raise ValueError(
+            "Only one of `pad_to_aspect_ratio` & `crop_to_aspect_ratio` "
+            "can be `True`."
+        )
+    if not len(size) == 2:
+        raise ValueError(
+            "Argument `size` must be a tuple of two elements "
+            f"(height, width). Received: size={size}"
+        )
+    size = tuple(size)
+    if len(images.shape) not in (3, 4):
+        raise ValueError(
+            "Invalid images rank: expected rank 3 (single image) "
+            "or rank 4 (batch of images). Received input with shape: "
+            f"images.shape={images.shape}"
+        )
+    if data_format == "channels_first":
+        if len(images.shape) == 4:
+            images = tf.transpose(images, (0, 2, 3, 1))
+        else:
+            images = tf.transpose(images, (1, 2, 0))
+
+    if crop_to_aspect_ratio:
+        shape = tf.shape(images)
+        height, width = shape[-3], shape[-2]
+        target_height, target_width = size
+        crop_height = tf.cast(
+            tf.cast(width * target_height, "float32") / target_width,
+            "int32",
+        )
+        crop_height = tf.maximum(tf.minimum(height, crop_height), 1)
+        crop_height = tf.cast(crop_height, "int32")
+        crop_width = tf.cast(
+            tf.cast(height * target_width, "float32") / target_height,
+            "int32",
+        )
+        crop_width = tf.maximum(tf.minimum(width, crop_width), 1)
+        crop_width = tf.cast(crop_width, "int32")
+
+        crop_box_hstart = tf.cast(
+            tf.cast(height - crop_height, "float32") / 2, "int32"
+        )
+        crop_box_wstart = tf.cast(
+            tf.cast(width - crop_width, "float32") / 2, "int32"
+        )
+        if len(images.shape) == 4:
+            images = images[
+                :,
+                crop_box_hstart : crop_box_hstart + crop_height,
+                crop_box_wstart : crop_box_wstart + crop_width,
+                :,
+            ]
+        else:
+            images = images[
+                crop_box_hstart : crop_box_hstart + crop_height,
+                crop_box_wstart : crop_box_wstart + crop_width,
+                :,
+            ]
+    elif pad_to_aspect_ratio:
+        shape = tf.shape(images)
+        height, width = shape[-3], shape[-2]
+        target_height, target_width = size
+        pad_height = tf.cast(
+            tf.cast(width * target_height, "float32") / target_width,
+            "int32",
+        )
+        pad_height = tf.maximum(height, pad_height)
+        pad_height = tf.cast(pad_height, "int32")
+        pad_width = tf.cast(
+            tf.cast(height * target_width, "float32") / target_height,
+            "int32",
+        )
+        pad_width = tf.maximum(width, pad_width)
+        pad_width = tf.cast(pad_width, "int32")
+
+        img_box_hstart = tf.cast(
+            tf.cast(pad_height - height, "float32") / 2, "int32"
+        )
+        img_box_wstart = tf.cast(
+            tf.cast(pad_width - width, "float32") / 2, "int32"
+        )
+        if len(images.shape) == 4:
+            batch_size = tf.shape(images)[0]
+            channels = tf.shape(images)[3]
+            padded_img = tf.cond(
+                img_box_hstart > 0,
+                lambda: tf.concat(
+                    [
+                        tf.ones(
+                            (batch_size, img_box_hstart, width, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                        images,
+                        tf.ones(
+                            (batch_size, img_box_hstart, width, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                    ],
+                    axis=1,
+                ),
+                lambda: images,
+            )
+            padded_img = tf.cond(
+                img_box_wstart > 0,
+                lambda: tf.concat(
+                    [
+                        tf.ones(
+                            (batch_size, height, img_box_wstart, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                        padded_img,
+                        tf.ones(
+                            (batch_size, height, img_box_wstart, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                    ],
+                    axis=2,
+                ),
+                lambda: padded_img,
+            )
+        else:
+            channels = tf.shape(images)[2]
+            padded_img = tf.cond(
+                img_box_hstart > 0,
+                lambda: tf.concat(
+                    [
+                        tf.ones(
+                            (img_box_hstart, width, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                        images,
+                        tf.ones(
+                            (img_box_hstart, width, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                    ],
+                    axis=0,
+                ),
+                lambda: images,
+            )
+            padded_img = tf.cond(
+                img_box_wstart > 0,
+                lambda: tf.concat(
+                    [
+                        tf.ones(
+                            (height, img_box_wstart, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                        padded_img,
+                        tf.ones(
+                            (height, img_box_wstart, channels),
+                            dtype=images.dtype,
+                        )
+                        * fill_value,
+                    ],
+                    axis=1,
+                ),
+                lambda: padded_img,
+            )
+        images = padded_img
+
+    resized = tf.image.resize(
+        images, size, method=interpolation, antialias=antialias
+    )
+    if data_format == "channels_first":
+        if len(images.shape) == 4:
+            resized = tf.transpose(resized, (0, 3, 1, 2))
+        elif len(images.shape) == 3:
+            resized = tf.transpose(resized, (2, 0, 1))
+    return resized
+
+
+AFFINE_TRANSFORM_INTERPOLATIONS = (
+    "nearest",
+    "bilinear",
+)
+AFFINE_TRANSFORM_FILL_MODES = (
+    "constant",
+    "nearest",
+    "wrap",
+    # "mirror", not supported by TF
+    "reflect",
+)
+
+
+def affine_transform(
+    images,
+    transform,
+    interpolation="bilinear",
+    fill_mode="constant",
+    fill_value=0,
+    data_format=None,
+):
+    data_format = backend.standardize_data_format(data_format)
+    if interpolation not in AFFINE_TRANSFORM_INTERPOLATIONS:
+        raise ValueError(
+            "Invalid value for argument `interpolation`. Expected of one "
+            f"{AFFINE_TRANSFORM_INTERPOLATIONS}. Received: "
+            f"interpolation={interpolation}"
+        )
+    if fill_mode not in AFFINE_TRANSFORM_FILL_MODES:
+        raise ValueError(
+            "Invalid value for argument `fill_mode`. Expected of one "
+            f"{AFFINE_TRANSFORM_FILL_MODES}. Received: fill_mode={fill_mode}"
+        )
+    if len(images.shape) not in (3, 4):
+        raise ValueError(
+            "Invalid images rank: expected rank 3 (single image) "
+            "or rank 4 (batch of images). Received input with shape: "
+            f"images.shape={images.shape}"
+        )
+    if len(transform.shape) not in (1, 2):
+        raise ValueError(
+            "Invalid transform rank: expected rank 1 (single transform) "
+            "or rank 2 (batch of transforms). Received input with shape: "
+            f"transform.shape={transform.shape}"
+        )
+    # unbatched case
+    need_squeeze = False
+    if len(images.shape) == 3:
+        images = tf.expand_dims(images, axis=0)
+        need_squeeze = True
+    if len(transform.shape) == 1:
+        transform = tf.expand_dims(transform, axis=0)
+
+    if data_format == "channels_first":
+        images = tf.transpose(images, (0, 2, 3, 1))
+
+    affined = tf.raw_ops.ImageProjectiveTransformV3(
+        images=images,
+        transforms=tf.cast(transform, dtype=tf.float32),
+        output_shape=tf.shape(images)[1:-1],
+        fill_value=fill_value,
+        interpolation=interpolation.upper(),
+        fill_mode=fill_mode.upper(),
+    )
+    affined = tf.ensure_shape(affined, images.shape)
+
+    if data_format == "channels_first":
+        affined = tf.transpose(affined, (0, 3, 1, 2))
+    if need_squeeze:
+        affined = tf.squeeze(affined, axis=0)
+    return affined
+
+
+def _mirror_index_fixer(index, size):
+    s = size - 1  # Half-wavelength of triangular wave
+    # Scaled, integer-valued version of the triangular wave |x - round(x)|
+    return tf.abs((index + s) % (2 * s) - s)
+
+
+def _reflect_index_fixer(index, size):
+    return tf.math.floordiv(
+        _mirror_index_fixer(2 * index + 1, 2 * size + 1) - 1, 2
+    )
+
+
+_INDEX_FIXERS = {
+    "constant": lambda index, size: index,
+    "nearest": lambda index, size: tf.clip_by_value(index, 0, size - 1),
+    "wrap": lambda index, size: index % size,
+    "mirror": _mirror_index_fixer,
+    "reflect": _reflect_index_fixer,
+}
+
+
+def _nearest_indices_and_weights(coordinate):
+    coordinate = (
+        coordinate if coordinate.dtype.is_integer else tf.round(coordinate)
+    )
+    index = tf.cast(coordinate, tf.int32)
+    weight = tf.constant(1, coordinate.dtype)
+    return [(index, weight)]
+
+
+def _linear_indices_and_weights(coordinate):
+    lower = tf.floor(coordinate)
+    upper_weight = coordinate - lower
+    lower_weight = 1 - upper_weight
+    index = tf.cast(lower, tf.int32)
+    return [(index, lower_weight), (index + 1, upper_weight)]
+
+
+def map_coordinates(
+    inputs, coordinates, order, fill_mode="constant", fill_value=0.0
+):
+    input_arr = convert_to_tensor(inputs)
+    coordinate_arrs = convert_to_tensor(coordinates)
+
+    if coordinate_arrs.shape[0] != len(input_arr.shape):
+        raise ValueError(
+            "First dim of `coordinates` must be the same as the rank of "
+            "`inputs`. "
+            f"Received inputs with shape: {input_arr.shape} and coordinate "
+            f"leading dim of {coordinate_arrs.shape[0]}"
+        )
+    if len(coordinate_arrs.shape) < 2:
+        raise ValueError(
+            "Invalid coordinates rank: expected at least rank 2."
+            f" Received input with shape: {coordinate_arrs.shape}"
+        )
+
+    # unstack into a list of tensors for following operations
+    coordinate_arrs = tf.unstack(coordinate_arrs, axis=0)
+    fill_value = convert_to_tensor(tf.cast(fill_value, input_arr.dtype))
+
+    index_fixer = _INDEX_FIXERS.get(fill_mode)
+    if index_fixer is None:
+        raise ValueError(
+            "Invalid value for argument `fill_mode`. Expected one of "
+            f"{set(_INDEX_FIXERS.keys())}. Received: "
+            f"fill_mode={fill_mode}"
+        )
+
+    def is_valid(index, size):
+        if fill_mode == "constant":
+            return (0 <= index) & (index < size)
+        else:
+            return True
+
+    if order == 0:
+        interp_fun = _nearest_indices_and_weights
+    elif order == 1:
+        interp_fun = _linear_indices_and_weights
+    else:
+        raise NotImplementedError("map_coordinates currently requires order<=1")
+
+    valid_1d_interpolations = []
+    for coordinate, size in zip(coordinate_arrs, input_arr.shape):
+        interp_nodes = interp_fun(coordinate)
+        valid_interp = []
+        for index, weight in interp_nodes:
+            fixed_index = index_fixer(index, size)
+            valid = is_valid(index, size)
+            valid_interp.append((fixed_index, valid, weight))
+        valid_1d_interpolations.append(valid_interp)
+
+    outputs = []
+    for items in itertools.product(*valid_1d_interpolations):
+        indices, validities, weights = zip(*items)
+        indices = tf.transpose(tf.stack(indices))
+
+        def fast_path():
+            return tf.transpose(tf.gather_nd(input_arr, indices))
+
+        def slow_path():
+            all_valid = functools.reduce(operator.and_, validities)
+            return tf.where(
+                all_valid,
+                tf.transpose(tf.gather_nd(input_arr, indices)),
+                fill_value,
+            )
+
+        contribution = tf.cond(tf.reduce_all(validities), fast_path, slow_path)
+        outputs.append(
+            functools.reduce(operator.mul, weights)
+            * tf.cast(contribution, weights[0].dtype)
+        )
+    result = functools.reduce(operator.add, outputs)
+    if input_arr.dtype.is_integer:
+        result = result if result.dtype.is_integer else tf.round(result)
+    return tf.cast(result, input_arr.dtype)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/layer.py

@@ -0,0 +1,114 @@
+import tensorflow as tf
+
+from keras.src import tree
+from keras.src.backend.tensorflow.trackable import KerasAutoTrackable
+from keras.src.utils import tf_utils
+from keras.src.utils import tracking
+
+
+class TFLayer(KerasAutoTrackable):
+    def __init__(self, *args, **kwargs):
+        # Export-related attributes
+        self._saved_model_inputs_spec = None
+        self._saved_model_arg_spec = None
+        self._tracked = []
+
+    @tf.__internal__.tracking.no_automatic_dependency_tracking
+    def _set_save_spec(self, inputs, args=None, kwargs=None):
+        """Defines the save spec so that serialization can trace layer calls.
+
+        The TensorSpecs of the call function `inputs`, `args`, and `kwargs` are
+        saved into a tuple of `([inputs] + args, kwargs)`.
+
+        Args:
+          inputs: possibly nested inputs passed into the call function.
+          args: a list of positional arguments passed into call.
+          kwargs: a dictionary of keyword arguments passed into call.
+        """
+        if self._saved_model_inputs_spec is not None:
+            return  # Already set.
+
+        inputs_spec = tree.map_structure(tf_utils.get_tensor_spec, inputs)
+        args_spec = tree.map_structure(tf_utils.get_tensor_spec, args or [])
+        kwargs_spec = {}
+        # Filter out non-tensor arguments from kwargs.
+        for key, kwarg in kwargs.items():
+            flat_kwarg = tree.flatten(kwarg)
+            flat_specs = [tf_utils.get_tensor_spec(x) for x in flat_kwarg]
+            if any(s is None for s in flat_specs):
+                continue
+            kwargs_spec[key] = tree.pack_sequence_as(kwarg, flat_specs)
+
+        self._saved_model_inputs_spec = inputs_spec
+        self._saved_model_arg_spec = (
+            [inputs_spec] + list(args_spec),
+            kwargs_spec,
+        )
+
+    def _trackable_children(self, save_type="checkpoint", **kwargs):
+        if save_type == "savedmodel":
+            # SavedModel needs to ignore the execution functions.
+            train_function = getattr(self, "train_function", None)
+            test_function = getattr(self, "test_function", None)
+            predict_function = getattr(self, "predict_function", None)
+            self.train_function = None
+            self.test_function = None
+            self.predict_function = None
+
+        children = super()._trackable_children(save_type, **kwargs)
+
+        if save_type == "savedmodel":
+            self.train_function = train_function
+            self.test_function = test_function
+            self.predict_function = predict_function
+
+            for tracked_attr in self._tracked:
+                tracked_item = getattr(self, tracked_attr)
+                if isinstance(tracked_item, tracking.TrackedList):
+                    children[tracked_attr] = list(tracked_item)
+                if isinstance(tracked_item, tracking.TrackedDict):
+                    children[tracked_attr] = dict(tracked_item)
+                if isinstance(tracked_item, tracking.TrackedSet):
+                    children[tracked_attr] = list(tracked_item)
+
+        return children
+
+    @property
+    def _default_save_signature(self):
+        """For SavedModel support: returns the default serving signature."""
+
+        from keras.src.models.functional import Functional
+        from keras.src.models.model import Model
+        from keras.src.models.sequential import Sequential
+
+        if not isinstance(self, Model):
+            return None
+
+        inputs = None
+        if (
+            isinstance(self, Sequential)
+            and getattr(self, "_functional", None) is not None
+        ):
+            inputs = self._functional.input
+        elif isinstance(self, Functional):
+            inputs = self.input
+
+        if inputs is not None:
+            input_signature = (
+                tree.map_structure(
+                    lambda x: tf.TensorSpec(x.shape, x.dtype), inputs
+                ),
+            )
+        else:
+            input_signature = tuple(
+                tree.map_shape_structure(
+                    lambda s: tf.TensorSpec(s, self.input_dtype), value
+                )
+                for value in self._build_shapes_dict.values()
+            )
+
+        @tf.function(input_signature=input_signature)
+        def serving_default(inputs):
+            return self(inputs)
+
+        return serving_default

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/linalg.py

@@ -0,0 +1,234 @@
+import tensorflow as tf
+
+from keras.src.backend import config
+from keras.src.backend import standardize_dtype
+from keras.src.backend.common import dtypes
+from keras.src.backend.tensorflow.core import cast
+from keras.src.backend.tensorflow.core import convert_to_tensor
+
+
+def cholesky(a):
+    out = tf.linalg.cholesky(a)
+    # tf.linalg.cholesky simply returns NaNs for non-positive definite matrices
+    return tf.debugging.check_numerics(out, "Cholesky")
+
+
+def det(a):
+    return tf.linalg.det(a)
+
+
+def eig(a):
+    return tf.linalg.eig(a)
+
+
+def eigh(a):
+    return tf.linalg.eigh(a)
+
+
+def inv(a):
+    return tf.linalg.inv(a)
+
+
+def lu_factor(a):
+    lu, p = tf.linalg.lu(a)
+    return lu, tf.math.invert_permutation(p)
+
+
+def norm(x, ord=None, axis=None, keepdims=False):
+    from keras.src.backend.tensorflow.numpy import moveaxis
+
+    x = convert_to_tensor(x)
+    x_shape = x.shape
+    ndim = x_shape.rank
+
+    if axis is None:
+        axis = tuple(range(ndim))
+    elif isinstance(axis, int):
+        axis = (axis,)
+    if any(a < -ndim or a >= ndim for a in axis):
+        raise ValueError(
+            "All `axis` values must be in the range [-ndim, ndim). "
+            f"Received inputs with ndim={ndim}, while axis={axis}"
+        )
+    axis = axis[0] if len(axis) == 1 else axis
+    num_axes = 1 if isinstance(axis, int) else len(axis)
+
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+
+    # Ref: jax.numpy.linalg.norm
+    if num_axes == 1:
+        if ord is None or ord == 2:
+            return tf.sqrt(
+                tf.reduce_sum(x * tf.math.conj(x), axis=axis, keepdims=keepdims)
+            )
+        elif ord == float("inf"):
+            return tf.math.reduce_max(
+                tf.math.abs(x), axis=axis, keepdims=keepdims
+            )
+        elif ord == float("-inf"):
+            return tf.math.reduce_min(
+                tf.math.abs(x), axis=axis, keepdims=keepdims
+            )
+        elif ord == 0:
+            return tf.math.reduce_sum(
+                tf.cast(tf.not_equal(x, 0), dtype=x.dtype),
+                axis=axis,
+                keepdims=keepdims,
+            )
+        elif isinstance(ord, str):
+            raise ValueError(
+                f"Invalid `ord` argument for vector norm. Received: ord={ord}"
+            )
+        else:
+            ord = convert_to_tensor(ord, dtype=x.dtype)
+            out = tf.math.reduce_sum(
+                tf.pow(tf.math.abs(x), ord), axis=axis, keepdims=keepdims
+            )
+            return tf.pow(out, 1.0 / ord)
+    elif num_axes == 2:
+        row_axis, col_axis = axis[0], axis[1]
+        row_axis = row_axis + ndim if row_axis < 0 else row_axis
+        col_axis = col_axis + ndim if col_axis < 0 else col_axis
+        if ord is None or ord == "fro":
+            return tf.sqrt(
+                tf.reduce_sum(x * tf.math.conj(x), axis=axis, keepdims=keepdims)
+            )
+        elif ord == 1:
+            if not keepdims and col_axis > row_axis:
+                col_axis -= 1
+            x = tf.math.reduce_max(
+                tf.reduce_sum(tf.math.abs(x), axis=row_axis, keepdims=keepdims),
+                axis=col_axis,
+                keepdims=keepdims,
+            )
+        elif ord == -1:
+            if not keepdims and col_axis > row_axis:
+                col_axis -= 1
+            x = tf.math.reduce_min(
+                tf.reduce_sum(tf.math.abs(x), axis=row_axis, keepdims=keepdims),
+                axis=col_axis,
+                keepdims=keepdims,
+            )
+        elif ord == float("inf"):
+            if not keepdims and row_axis > col_axis:
+                row_axis -= 1
+            x = tf.math.reduce_max(
+                tf.reduce_sum(tf.math.abs(x), axis=col_axis, keepdims=keepdims),
+                axis=row_axis,
+                keepdims=keepdims,
+            )
+        elif ord == float("-inf"):
+            if not keepdims and row_axis > col_axis:
+                row_axis -= 1
+            x = tf.math.reduce_min(
+                tf.reduce_sum(tf.math.abs(x), axis=col_axis, keepdims=keepdims),
+                axis=row_axis,
+                keepdims=keepdims,
+            )
+        elif ord in ("nuc", 2, -2):
+            x = moveaxis(x, axis, (-2, -1))
+            if ord == -2:
+                x = tf.math.reduce_min(
+                    tf.linalg.svd(x, compute_uv=False), axis=-1
+                )
+            elif ord == 2:
+                x = tf.math.reduce_max(
+                    tf.linalg.svd(x, compute_uv=False), axis=-1
+                )
+            else:
+                x = tf.math.reduce_sum(
+                    tf.linalg.svd(x, compute_uv=False), axis=-1
+                )
+            if keepdims:
+                x = tf.expand_dims(x, axis[0])
+                x = tf.expand_dims(x, axis[1])
+        else:
+            raise ValueError(
+                f"Invalid `ord` argument for matrix norm. Received: ord={ord}"
+            )
+        return x
+    else:
+        raise ValueError(f"Invalid axis values. Received: axis={axis}")
+
+
+def qr(x, mode="reduced"):
+    if mode not in {"reduced", "complete"}:
+        raise ValueError(
+            "`mode` argument value not supported. "
+            "Expected one of {'reduced', 'complete'}. "
+            f"Received: mode={mode}"
+        )
+    if mode == "reduced":
+        return tf.linalg.qr(x)
+    return tf.linalg.qr(x, full_matrices=True)
+
+
+def solve(a, b):
+    # tensorflow.linalg.solve only supports same rank inputs
+    if tf.rank(b) == tf.rank(a) - 1:
+        b = tf.expand_dims(b, axis=-1)
+        return tf.squeeze(tf.linalg.solve(a, b), axis=-1)
+    return tf.linalg.solve(a, b)
+
+
+def solve_triangular(a, b, lower=False):
+    if b.shape.ndims == a.shape.ndims - 1:
+        b = tf.expand_dims(b, axis=-1)
+        return tf.squeeze(
+            tf.linalg.triangular_solve(a, b, lower=lower), axis=-1
+        )
+    return tf.linalg.triangular_solve(a, b, lower=lower)
+
+
+def svd(x, full_matrices=True, compute_uv=True):
+    if compute_uv is False:
+        return tf.linalg.svd(x, full_matrices=full_matrices, compute_uv=False)
+    s, u, v = tf.linalg.svd(
+        x, full_matrices=full_matrices, compute_uv=compute_uv
+    )
+    return u, s, tf.linalg.adjoint(v)
+
+
+def lstsq(a, b, rcond=None):
+    a = convert_to_tensor(a)
+    b = convert_to_tensor(b)
+    if a.shape[0] != b.shape[0]:
+        raise ValueError("Leading dimensions of input arrays must match")
+    b_orig_ndim = b.ndim
+    if b_orig_ndim == 1:
+        b = b[:, None]
+    if a.ndim != 2:
+        raise TypeError(
+            f"{a.ndim}-dimensional array given. "
+            "Array must be two-dimensional"
+        )
+    if b.ndim != 2:
+        raise TypeError(
+            f"{b.ndim}-dimensional array given. "
+            "Array must be one or two-dimensional"
+        )
+    m, n = a.shape
+    dtype = a.dtype
+    eps = tf.experimental.numpy.finfo(dtype).eps
+    if a.shape == ():
+        s = tf.zeros(0, dtype=a.dtype)
+        x = tf.zeros((n, *b.shape[1:]), dtype=a.dtype)
+    else:
+        if rcond is None:
+            rcond = eps * max(n, m)
+        else:
+            rcond = tf.where(rcond < 0, eps, rcond)
+        u, s, vt = svd(a, full_matrices=False)
+        mask = s >= tf.convert_to_tensor(rcond, dtype=s.dtype) * s[0]
+        safe_s = tf.cast(tf.where(mask, s, 1), dtype=a.dtype)
+        s_inv = tf.where(mask, 1 / safe_s, 0)[:, tf.newaxis]
+        u_t_b = tf.matmul(tf.transpose(tf.math.conj(u)), b)
+        x = tf.matmul(tf.transpose(tf.math.conj(vt)), s_inv * u_t_b)
+
+    if b_orig_ndim == 1:
+        x = tf.reshape(x, [-1])
+    return x

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/math.py

@@ -0,0 +1,381 @@
+import tensorflow as tf
+
+from keras.src.backend import config
+from keras.src.backend import standardize_dtype
+from keras.src.backend.common import dtypes
+from keras.src.backend.tensorflow.core import cast
+from keras.src.backend.tensorflow.core import convert_to_tensor
+
+
+def segment_sum(data, segment_ids, num_segments=None, sorted=False):
+    if sorted:
+        if num_segments is not None:
+            raise ValueError(
+                "Argument `num_segments` cannot be set when sorted is True "
+                "when using the tensorflow backend."
+                f"Received: num_segments={num_segments}, sorted={sorted}."
+            )
+        return tf.math.segment_sum(data, segment_ids)
+    else:
+        if num_segments is None:
+            unique_segment_ids, _ = tf.unique(segment_ids)
+            num_segments = tf.shape(unique_segment_ids)[0]
+        return tf.math.unsorted_segment_sum(data, segment_ids, num_segments)
+
+
+def segment_max(data, segment_ids, num_segments=None, sorted=False):
+    if sorted:
+        if num_segments is not None:
+            raise ValueError(
+                "Argument `num_segments` cannot be set when sorted is True "
+                "when using the tensorflow backend."
+                f"Received: num_segments={num_segments}, sorted={sorted}."
+            )
+        return tf.math.segment_max(data, segment_ids)
+    else:
+        if num_segments is None:
+            unique_segment_ids, _ = tf.unique(segment_ids)
+            num_segments = tf.shape(unique_segment_ids)[0]
+        return tf.math.unsorted_segment_max(data, segment_ids, num_segments)
+
+
+def top_k(x, k, sorted=True):
+    return tf.math.top_k(x, k, sorted=sorted)
+
+
+def in_top_k(targets, predictions, k):
+    return tf.math.in_top_k(targets, predictions, k)
+
+
+def logsumexp(x, axis=None, keepdims=False):
+    return tf.math.reduce_logsumexp(x, axis=axis, keepdims=keepdims)
+
+
+def qr(x, mode="reduced"):
+    if mode not in {"reduced", "complete"}:
+        raise ValueError(
+            "`mode` argument value not supported. "
+            "Expected one of {'reduced', 'complete'}. "
+            f"Received: mode={mode}"
+        )
+    if mode == "reduced":
+        return tf.linalg.qr(x)
+    return tf.linalg.qr(x, full_matrices=True)
+
+
+def extract_sequences(x, sequence_length, sequence_stride):
+    return tf.signal.frame(
+        x,
+        frame_length=sequence_length,
+        frame_step=sequence_stride,
+        axis=-1,
+        pad_end=False,
+    )
+
+
+def _get_complex_tensor_from_tuple(x):
+    if not isinstance(x, (tuple, list)) or len(x) != 2:
+        raise ValueError(
+            "Input `x` should be a tuple of two tensors - real and imaginary."
+            f"Received: x={x}"
+        )
+    # `convert_to_tensor` does not support passing complex tensors. We separate
+    # the input out into real and imaginary and convert them separately.
+    real, imag = x
+    real = convert_to_tensor(real)
+    imag = convert_to_tensor(imag)
+    # Check shapes.
+    if real.shape != imag.shape:
+        raise ValueError(
+            "Input `x` should be a tuple of two tensors - real and imaginary."
+            "Both the real and imaginary parts should have the same shape. "
+            f"Received: x[0].shape = {real.shape}, x[1].shape = {imag.shape}"
+        )
+    # Ensure dtype is float.
+    if not real.dtype.is_floating or not imag.dtype.is_floating:
+        raise ValueError(
+            "At least one tensor in input `x` is not of type float."
+            f"Received: x={x}."
+        )
+    complex_input = tf.dtypes.complex(real, imag)
+    return complex_input
+
+
+def fft(x):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    complex_output = tf.signal.fft(complex_input)
+    return tf.math.real(complex_output), tf.math.imag(complex_output)
+
+
+def fft2(x):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    complex_output = tf.signal.fft2d(complex_input)
+    return tf.math.real(complex_output), tf.math.imag(complex_output)
+
+
+def ifft2(x):
+    real, imag = x
+    h = cast(tf.shape(real)[-2], "float32")
+    w = cast(tf.shape(real)[-1], "float32")
+    real_conj, imag_conj = real, -imag
+    fft_real, fft_imag = fft2((real_conj, imag_conj))
+    return fft_real / (h * w), -fft_imag / (h * w)
+
+
+def rfft(x, fft_length=None):
+    if fft_length is not None:
+        fft_length = [fft_length]
+    complex_output = tf.signal.rfft(x, fft_length=fft_length)
+    return tf.math.real(complex_output), tf.math.imag(complex_output)
+
+
+def irfft(x, fft_length=None):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    if fft_length is not None:
+        fft_length = [fft_length]
+    return tf.signal.irfft(complex_input, fft_length)
+
+
+def stft(
+    x, sequence_length, sequence_stride, fft_length, window="hann", center=True
+):
+    if standardize_dtype(x.dtype) not in {"float32", "float64"}:
+        raise TypeError(
+            "Invalid input type. Expected `float32` or `float64`. "
+            f"Received: input type={x.dtype}"
+        )
+    if fft_length < sequence_length:
+        raise ValueError(
+            "`fft_length` must equal or larger than `sequence_length`. "
+            f"Received: sequence_length={sequence_length}, "
+            f"fft_length={fft_length}"
+        )
+    if isinstance(window, str):
+        if window not in {"hann", "hamming"}:
+            raise ValueError(
+                "If a string is passed to `window`, it must be one of "
+                f'`"hann"`, `"hamming"`. Received: window={window}'
+            )
+    x = convert_to_tensor(x)
+
+    if center:
+        pad_width = [(0, 0) for _ in range(len(x.shape))]
+        pad_width[-1] = (fft_length // 2, fft_length // 2)
+        x = tf.pad(x, pad_width, mode="reflect")
+
+    l_pad = (fft_length - sequence_length) // 2
+    r_pad = fft_length - sequence_length - l_pad
+
+    if window is not None:
+        if isinstance(window, str):
+            if window == "hann":
+                win_array = tf.signal.hann_window(
+                    sequence_length, periodic=True, dtype=x.dtype
+                )
+            else:
+                win_array = tf.signal.hamming_window(
+                    sequence_length, periodic=True, dtype=x.dtype
+                )
+        else:
+            win_array = convert_to_tensor(window, dtype=x.dtype)
+        if len(win_array.shape) != 1 or win_array.shape[-1] != sequence_length:
+            raise ValueError(
+                "The shape of `window` must be equal to [sequence_length]."
+                f"Received: window shape={win_array.shape}"
+            )
+        win_array = tf.pad(win_array, [[l_pad, r_pad]])
+
+        def win(frame_step, dtype):
+            return win_array
+
+    else:
+        win = None
+
+    result = tf.signal.stft(
+        x,
+        frame_length=(sequence_length + l_pad + r_pad),
+        frame_step=sequence_stride,
+        fft_length=fft_length,
+        window_fn=win,
+    )
+    return tf.math.real(result), tf.math.imag(result)
+
+
+def istft(
+    x,
+    sequence_length,
+    sequence_stride,
+    fft_length,
+    length=None,
+    window="hann",
+    center=True,
+):
+    complex_input = _get_complex_tensor_from_tuple(x)
+    dtype = tf.math.real(complex_input).dtype
+
+    expected_output_len = fft_length + sequence_stride * (
+        tf.shape(complex_input)[-2] - 1
+    )
+    l_pad = (fft_length - sequence_length) // 2
+    r_pad = fft_length - sequence_length - l_pad
+
+    if window is not None:
+        if isinstance(window, str):
+            if window == "hann":
+                win_array = tf.signal.hann_window(
+                    sequence_length, periodic=True, dtype=dtype
+                )
+            else:
+                win_array = tf.signal.hamming_window(
+                    sequence_length, periodic=True, dtype=dtype
+                )
+        else:
+            win_array = convert_to_tensor(window, dtype=dtype)
+        if len(win_array.shape) != 1 or win_array.shape[-1] != sequence_length:
+            raise ValueError(
+                "The shape of `window` must be equal to [sequence_length]."
+                f"Received: window shape={win_array.shape}"
+            )
+        win_array = tf.pad(win_array, [[l_pad, r_pad]])
+        win = tf.signal.inverse_stft_window_fn(
+            sequence_stride, lambda frame_step, dtype: win_array
+        )
+    else:
+        win = None
+
+    x = tf.signal.inverse_stft(
+        complex_input,
+        frame_length=(sequence_length + l_pad + r_pad),
+        frame_step=sequence_stride,
+        fft_length=fft_length,
+        window_fn=win,
+    )
+
+    start = 0 if center is False else fft_length // 2
+    if length is not None:
+        end = start + length
+    elif center is True:
+        end = -(fft_length // 2)
+    else:
+        end = expected_output_len
+    return x[..., start:end]
+
+
+def rsqrt(x):
+    return tf.math.rsqrt(x)
+
+
+def erf(x):
+    return tf.math.erf(x)
+
+
+def erfinv(x):
+    return tf.math.erfinv(x)
+
+
+def solve(a, b):
+    a = convert_to_tensor(a)
+    b = convert_to_tensor(b)
+    return tf.linalg.solve(a, b)
+
+
+def norm(x, ord=None, axis=None, keepdims=False):
+    from keras.src.backend.tensorflow.numpy import moveaxis
+
+    x = convert_to_tensor(x)
+    x_shape = x.shape
+    ndim = x_shape.rank
+
+    if axis is None:
+        axis = tuple(range(ndim))
+    elif isinstance(axis, int):
+        axis = (axis,)
+
+    axis = axis[0] if len(axis) == 1 else axis
+    num_axes = 1 if isinstance(axis, int) else len(axis)
+
+    if num_axes == 1 and ord is None:
+        ord = "euclidean"
+    elif num_axes == 2 and ord is None:
+        ord = "fro"
+
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = cast(x, dtype)
+
+    # Fast path to utilize `tf.linalg.norm`
+    if (num_axes == 1 and ord in ("euclidean", 1, 2, float("inf"))) or (
+        num_axes == 2 and ord in ("euclidean", "fro", 1, 2, float("inf"))
+    ):
+        return tf.linalg.norm(x, ord=ord, axis=axis, keepdims=keepdims)
+
+    # Ref: jax.numpy.linalg.norm
+    if num_axes == 1 and ord not in ("fro", "nuc"):
+        if ord == float("-inf"):
+            return tf.math.reduce_min(
+                tf.math.abs(x), axis=axis, keepdims=keepdims
+            )
+        elif ord == 0:
+            return tf.math.reduce_sum(
+                tf.cast(tf.not_equal(x, 0), dtype=x.dtype),
+                axis=axis,
+                keepdims=keepdims,
+            )
+        else:
+            ord = convert_to_tensor(ord, dtype=x.dtype)
+            out = tf.math.reduce_sum(
+                tf.pow(tf.math.abs(x), ord), axis=axis, keepdims=keepdims
+            )
+            return tf.pow(out, 1.0 / ord)
+    elif num_axes == 2 and ord in ("nuc", float("-inf"), -2, -1):
+        row_axis, col_axis = axis[0], axis[1]
+        row_axis = row_axis + ndim if row_axis < 0 else row_axis
+        col_axis = col_axis + ndim if col_axis < 0 else col_axis
+        if ord == float("-inf"):
+            if not keepdims and row_axis > col_axis:
+                row_axis -= 1
+            x = tf.math.reduce_min(
+                tf.reduce_sum(tf.math.abs(x), axis=col_axis, keepdims=keepdims),
+                axis=row_axis,
+                keepdims=keepdims,
+            )
+        elif ord == -1:
+            if not keepdims and col_axis > row_axis:
+                col_axis -= 1
+            x = tf.math.reduce_min(
+                tf.reduce_sum(tf.math.abs(x), axis=row_axis, keepdims=keepdims),
+                axis=col_axis,
+                keepdims=keepdims,
+            )
+        else:
+            x = moveaxis(x, axis, (-2, -1))
+            if ord == -2:
+                x = tf.math.reduce_min(
+                    tf.linalg.svd(x, compute_uv=False), axis=-1
+                )
+            else:
+                x = tf.math.reduce_sum(
+                    tf.linalg.svd(x, compute_uv=False), axis=-1
+                )
+            if keepdims:
+                x = tf.expand_dims(x, axis[0])
+                x = tf.expand_dims(x, axis[1])
+        return x
+
+    if num_axes == 1:
+        raise ValueError(
+            f"Invalid `ord` argument for vector norm. Received: ord={ord}"
+        )
+    elif num_axes == 2:
+        raise ValueError(
+            f"Invalid `ord` argument for matrix norm. Received: ord={ord}"
+        )
+    else:
+        raise ValueError(f"Invalid axis values. Received: axis={axis}")
+
+
+def logdet(x):
+    x = convert_to_tensor(x)
+    return tf.linalg.logdet(x)

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/nn.py

@@ -0,0 +1,1068 @@
+import math
+import warnings
+
+import tensorflow as tf
+
+from keras.src import backend
+from keras.src.backend.common.backend_utils import (
+    compute_conv_transpose_output_shape,
+)
+from keras.src.backend.tensorflow.core import cast
+from keras.src.backend.tensorflow.core import convert_to_tensor
+
+
+def relu(x):
+    return tf.nn.relu(x)
+
+
+def relu6(x):
+    return tf.nn.relu6(x)
+
+
+def sigmoid(x):
+    logits = x
+    output = tf.nn.sigmoid(x)
+    output._keras_logits = logits
+    return output
+
+
+def tanh(x):
+    return tf.nn.tanh(x)
+
+
+def tanh_shrink(x):
+    return x - tf.math.tanh(x)
+
+
+def softplus(x):
+    return tf.math.softplus(x)
+
+
+def softsign(x):
+    return tf.nn.softsign(x)
+
+
+def soft_shrink(x, threshold=0.5):
+    return tf.where(
+        x > threshold,
+        x - threshold,
+        tf.where(x < -threshold, x + threshold, tf.zeros_like(x)),
+    )
+
+
+def sparse_plus(x):
+    return tf.where(
+        x <= -1,
+        tf.zeros_like(x),
+        tf.where(x < 1, (1 / 4) * tf.pow(x + 1, 2), x),
+    )
+
+
+def silu(x):
+    return tf.nn.silu(x)
+
+
+def squareplus(x, b=4):
+    x = convert_to_tensor(x)
+    b = convert_to_tensor(b, dtype=x.dtype)
+    y = x + tf.sqrt(tf.square(x) + b)
+    return y / 2
+
+
+def log_sigmoid(x):
+    return tf.math.log_sigmoid(x)
+
+
+def leaky_relu(x, negative_slope=0.2):
+    return tf.nn.leaky_relu(x, alpha=negative_slope)
+
+
+def hard_sigmoid(x):
+    x = convert_to_tensor(x)
+    return relu6(x + tf.constant(3.0, x.dtype)) / tf.constant(6.0, x.dtype)
+
+
+def hard_silu(x):
+    return x * hard_sigmoid(x)
+
+
+def elu(x, alpha=1.0):
+    res = tf.nn.elu(x)
+    if alpha == 1:
+        return res
+    else:
+        return tf.where(x > 0, res, alpha * res)
+
+
+def selu(x):
+    return tf.nn.selu(x)
+
+
+def gelu(x, approximate=True):
+    x = convert_to_tensor(x)
+    return tf.nn.gelu(x, approximate=approximate)
+
+
+def celu(x, alpha=1.0):
+    return tf.maximum(x, 0.0) + alpha * tf.math.expm1(
+        tf.minimum(x, 0.0) / alpha
+    )
+
+
+def glu(x, axis=-1):
+    if x.shape[axis] % 2 != 0:
+        raise ValueError(
+            "axis size must be divisible by 2. "
+            f"Received: x.shape={x.shape} with axis={axis}"
+        )
+    x1, x2 = tf.split(x, num_or_size_splits=2, axis=axis)
+    return x1 * tf.sigmoid(x2)
+
+
+def hard_tanh(x):
+    return tf.clip_by_value(x, clip_value_min=-1.0, clip_value_max=1.0)
+
+
+def hard_shrink(x, threshold=0.5):
+    return tf.where(tf.abs(x) > threshold, x, tf.zeros_like(x))
+
+
+def threshold(x, threshold, default_value):
+    return tf.where(x > threshold, x, default_value)
+
+
+def softmax(x, axis=-1):
+    logits = x
+    if axis is None:
+        # Unlike numpy, tf will handle axis=None as axis=-1.
+        # We need this workaround for the reduction on every dim.
+        output = tf.reshape(x, [-1])
+        output = tf.nn.softmax(output, axis=-1)
+        output = tf.reshape(output, tf.shape(x))
+    else:
+        output = tf.nn.softmax(x, axis=axis)
+    output._keras_logits = logits
+    return output
+
+
+def log_softmax(x, axis=-1):
+    if axis is None:
+        # Unlike numpy, tf will handle axis=None as axis=-1.
+        # We need this workaround for the reduction on every dim.
+        output = tf.reshape(x, [-1])
+        output = tf.nn.log_softmax(output, axis=-1)
+        return tf.reshape(output, tf.shape(x))
+    return tf.nn.log_softmax(x, axis=axis)
+
+
+def sparsemax(logits, axis=-1):
+    # Sort logits along the specified axis in descending order
+    logits = convert_to_tensor(logits)
+    logits_sorted = tf.sort(logits, direction="DESCENDING", axis=axis)
+    logits_cumsum = tf.cumsum(logits_sorted, axis=axis)
+    r = tf.range(1, tf.shape(logits)[axis] + 1, dtype=logits.dtype)
+    r_shape = [1] * len(logits.shape)
+    r_shape[axis] = -1  # Broadcast to match the target axis
+    r = tf.reshape(r, r_shape)  # Reshape for broadcasting
+    support = logits_sorted - (logits_cumsum - 1) / r > 0
+    # Find the threshold
+    logits_cumsum_safe = tf.where(support, logits_cumsum, 0.0)
+    k = tf.reduce_sum(tf.cast(support, logits.dtype), axis=axis, keepdims=True)
+    tau = (tf.reduce_sum(logits_cumsum_safe, axis=axis, keepdims=True) - 1) / k
+    output = tf.maximum(logits - tau, 0.0)
+    return output
+
+
+def _transpose_spatial_inputs(inputs):
+    num_spatial_dims = len(inputs.shape) - 2
+    # Tensorflow pooling does not support `channels_first` format, so
+    # we need to transpose to `channels_last` format.
+    if num_spatial_dims == 1:
+        inputs = tf.transpose(inputs, (0, 2, 1))
+    elif num_spatial_dims == 2:
+        inputs = tf.transpose(inputs, (0, 2, 3, 1))
+    elif num_spatial_dims == 3:
+        inputs = tf.transpose(inputs, (0, 2, 3, 4, 1))
+    else:
+        raise ValueError(
+            "Pooling inputs's shape must be 3, 4 or 5, corresponding to 1D, 2D "
+            f"and 3D inputs. But received shape: {inputs.shape}."
+        )
+    return inputs
+
+
+def _transpose_spatial_outputs(outputs):
+    # Undo the transpose in `_transpose_spatial_inputs`.
+    num_spatial_dims = len(outputs.shape) - 2
+    if num_spatial_dims == 1:
+        outputs = tf.transpose(outputs, (0, 2, 1))
+    elif num_spatial_dims == 2:
+        outputs = tf.transpose(outputs, (0, 3, 1, 2))
+    elif num_spatial_dims == 3:
+        outputs = tf.transpose(outputs, (0, 4, 1, 2, 3))
+    return outputs
+
+
+def max_pool(
+    inputs,
+    pool_size,
+    strides=None,
+    padding="valid",
+    data_format=None,
+):
+    data_format = backend.standardize_data_format(data_format)
+    strides = pool_size if strides is None else strides
+    padding = padding.upper()
+    tf_data_format = _convert_data_format("channels_last", len(inputs.shape))
+    if data_format == "channels_first":
+        # Tensorflow pooling does not support `channels_first` format, so
+        # we need to transpose to `channels_last` format.
+        inputs = _transpose_spatial_inputs(inputs)
+
+    outputs = tf.nn.max_pool(
+        inputs,
+        pool_size,
+        strides,
+        padding,
+        tf_data_format,
+    )
+    if data_format == "channels_first":
+        outputs = _transpose_spatial_outputs(outputs)
+    return outputs
+
+
+def average_pool(
+    inputs,
+    pool_size,
+    strides=None,
+    padding="valid",
+    data_format=None,
+):
+    data_format = backend.standardize_data_format(data_format)
+    strides = pool_size if strides is None else strides
+    padding = padding.upper()
+    tf_data_format = _convert_data_format("channels_last", len(inputs.shape))
+    if data_format == "channels_first":
+        # Tensorflow pooling does not support `channels_first` format, so
+        # we need to transpose to `channels_last` format.
+        inputs = _transpose_spatial_inputs(inputs)
+
+    outputs = tf.nn.avg_pool(
+        inputs,
+        pool_size,
+        strides,
+        padding,
+        tf_data_format,
+    )
+    if data_format == "channels_first":
+        outputs = _transpose_spatial_outputs(outputs)
+    return outputs
+
+
+def _convert_data_format(data_format, ndim):
+    if data_format == "channels_last":
+        if ndim == 3:
+            return "NWC"
+        elif ndim == 4:
+            return "NHWC"
+        elif ndim == 5:
+            return "NDHWC"
+        else:
+            raise ValueError(
+                f"Input rank not supported: {ndim}. "
+                "Expected values are [3, 4, 5]"
+            )
+    elif data_format == "channels_first":
+        if ndim == 3:
+            return "NCW"
+        elif ndim == 4:
+            return "NCHW"
+        elif ndim == 5:
+            return "NCDHW"
+        else:
+            raise ValueError(
+                f"Input rank not supported: {ndim}. "
+                "Expected values are [3, 4, 5]"
+            )
+    else:
+        raise ValueError(
+            f"Invalid data_format: {data_format}. "
+            'Expected values are ["channels_first", "channels_last"]'
+        )
+
+
+def conv(
+    inputs,
+    kernel,
+    strides=1,
+    padding="valid",
+    data_format=None,
+    dilation_rate=1,
+):
+    def _conv():
+        tf_data_format = _convert_data_format(data_format, len(inputs.shape))
+        return tf.nn.convolution(
+            inputs,
+            kernel,
+            strides,
+            padding.upper(),
+            data_format=tf_data_format,
+            dilations=dilation_rate,
+        )
+
+    # Certain ops are are broken in Tensorflow on CPU only.
+    # We can work around by compiling the op with XLA.
+    @tf.function(jit_compile=True)
+    def _conv_xla():
+        return _conv()
+
+    # Channels first "NCDHW" (3d convolutions) are broken on CPU without XLA.
+    needs_xla = data_format == "channels_first" and len(inputs.shape) == 5
+    # grouped convolutions are broken on CPU without XLA.
+    data_format = backend.standardize_data_format(data_format)
+    if data_format == "channels_last":
+        channels = inputs.shape[-1]
+    else:
+        channels = inputs.shape[1]
+    needs_xla = needs_xla or channels != kernel.shape[-2]
+    if needs_xla:
+        return _conv_xla()
+    else:
+        return _conv()
+
+
+def depthwise_conv(
+    inputs,
+    kernel,
+    strides=1,
+    padding="valid",
+    data_format=None,
+    dilation_rate=1,
+):
+    data_format = backend.standardize_data_format(data_format)
+    num_spatial_dims = len(inputs.shape) - 2
+    if num_spatial_dims > 2:
+        raise ValueError(
+            "`inputs` rank must be 3 (1D conv) or 4 (2D conv). Received: "
+            "{inputs.ndim}."
+        )
+    # Because we use `tf.nn.depthwise_conv2d` for both 1D and 2D convs, we set
+    # `tf_data_format` using 2D conv format.
+    tf_data_format = _convert_data_format(data_format, 4)
+    padding = padding.upper()
+    if isinstance(strides, int):
+        strides = (strides,) * num_spatial_dims
+    if isinstance(dilation_rate, int):
+        dilation_rate = (dilation_rate,) * num_spatial_dims
+    if num_spatial_dims == 1:
+        # 1D depthwise conv.
+        if data_format == "channels_last":
+            strides = (1,) + strides * 2 + (1,)
+            spatial_start_dim = 1
+        else:
+            strides = (1, 1) + strides * 2
+            spatial_start_dim = 2
+        inputs = tf.expand_dims(inputs, spatial_start_dim)
+        kernel = tf.expand_dims(kernel, axis=0)
+
+        dilation_rate = None if dilation_rate is None else (1,) + dilation_rate
+
+        outputs = tf.nn.depthwise_conv2d(
+            inputs,
+            kernel,
+            strides,
+            padding,
+            data_format=tf_data_format,
+            dilations=dilation_rate,
+        )
+        return tf.squeeze(outputs, [spatial_start_dim])
+
+    if data_format == "channels_last":
+        strides = (1,) + strides + (1,)
+        spatial_start_dim = 1
+    else:
+        strides = (1, 1) + strides
+        spatial_start_dim = 2
+    return tf.nn.depthwise_conv2d(
+        inputs,
+        kernel,
+        strides,
+        padding,
+        data_format=tf_data_format,
+        dilations=dilation_rate,
+    )
+
+
+def separable_conv(
+    inputs,
+    depthwise_kernel,
+    pointwise_kernel,
+    strides=1,
+    padding="valid",
+    data_format=None,
+    dilation_rate=1,
+):
+    data_format = backend.standardize_data_format(data_format)
+    num_spatial_dims = len(inputs.shape) - 2
+    if num_spatial_dims > 2:
+        raise ValueError(
+            "`num_spatial_dims` must be 1 or 2. Received: "
+            f"num_spatial_dims={num_spatial_dims}."
+        )
+    # Because we use `tf.nn.separable_conv2d` for both 1D and 2D convs, we set
+    # `tf_data_format` using 2D conv format.
+    tf_data_format = _convert_data_format(data_format, 4)
+    padding = padding.upper()
+    if isinstance(strides, int):
+        strides = (strides,) * num_spatial_dims
+    if isinstance(dilation_rate, int):
+        dilation_rate = (dilation_rate,) * num_spatial_dims
+    if num_spatial_dims == 1:
+        # 1D depthwise conv.
+        if data_format == "channels_last":
+            strides = (1,) + strides * 2 + (1,)
+            spatial_start_dim = 1
+        else:
+            strides = (1, 1) + strides * 2
+            spatial_start_dim = 2
+        inputs = tf.expand_dims(inputs, spatial_start_dim)
+        depthwise_kernel = tf.expand_dims(depthwise_kernel, axis=0)
+        pointwise_kernel = tf.expand_dims(pointwise_kernel, axis=0)
+        dilation_rate = None if dilation_rate is None else (1,) + dilation_rate
+
+        outputs = tf.nn.separable_conv2d(
+            inputs,
+            depthwise_kernel,
+            pointwise_kernel,
+            strides,
+            padding,
+            data_format=tf_data_format,
+            dilations=dilation_rate,
+        )
+        return tf.squeeze(outputs, [spatial_start_dim])
+
+    if data_format == "channels_last":
+        strides = (1,) + strides + (1,)
+    else:
+        strides = (1, 1) + strides
+    return tf.nn.separable_conv2d(
+        inputs,
+        depthwise_kernel,
+        pointwise_kernel,
+        strides,
+        padding,
+        data_format=tf_data_format,
+        dilations=dilation_rate,
+    )
+
+
+def conv_transpose(
+    inputs,
+    kernel,
+    strides=1,
+    padding="valid",
+    output_padding=None,
+    data_format=None,
+    dilation_rate=1,
+):
+    data_format = backend.standardize_data_format(data_format)
+    tf_data_format = _convert_data_format(data_format, len(inputs.shape))
+    kernel_size = kernel.shape[:-2]
+    filters = kernel.shape[-2]
+    input_shape = list(inputs.shape)
+    symbolic_shape = tf.shape(inputs)
+    for i, e in enumerate(input_shape):
+        if e is None:
+            input_shape[i] = symbolic_shape[i]
+    output_shape = compute_conv_transpose_output_shape(
+        input_shape,
+        kernel_size,
+        filters,
+        strides,
+        padding,
+        output_padding,
+        data_format,
+        dilation_rate,
+    )
+
+    return tf.nn.conv_transpose(
+        inputs,
+        kernel,
+        output_shape,
+        strides,
+        padding=padding.upper(),
+        data_format=tf_data_format,
+        dilations=dilation_rate,
+    )
+
+
+def one_hot(x, num_classes, axis=-1, dtype="float32", sparse=False):
+    x = convert_to_tensor(x, dtype="int64")
+    if dtype is None:
+        dtype = "float32"
+    else:
+        dtype = backend.standardize_dtype(dtype)
+    if sparse:
+        # We don't use `tf.sparse.bincount`, it doesn't handle negative indices
+        # and only support rank 1 and 2 tensors (`one_hot` adds a dimension).
+        if axis < 0:
+            axis = axis + len(x.shape) + 1
+        values_count = math.prod(x.shape)
+        values = tf.reshape(x, (values_count,))
+        # We deal with negative inputs by having zeros in the output although
+        # it's useless. It makes shapes static.
+        values = tf.cast(tf.greater_equal(values, 0), dtype=dtype)
+        indices = [tf.range(dim) for dim in x.shape]
+        indices = tf.meshgrid(*indices, indexing="ij")
+        indices.insert(axis, tf.maximum(x, 0))  # Deal with negative indices
+        indices = [tf.reshape(a, (values_count, 1)) for a in indices]
+        indices = [tf.cast(a, tf.int64) for a in indices]
+        indices = tf.concat(indices, axis=1)
+        shape = list(x.shape)
+        shape.insert(axis, num_classes)
+        return tf.SparseTensor(indices, values, shape)
+    on_value, off_value = (True, False) if dtype == "bool" else (None, None)
+    return tf.one_hot(
+        x,
+        num_classes,
+        on_value=on_value,
+        off_value=off_value,
+        axis=axis,
+        dtype=dtype,
+    )
+
+
+def multi_hot(x, num_classes, axis=-1, dtype="float32", sparse=False):
+    reduction_axis = 1 if len(x.shape) > 1 else 0
+    if backend.standardize_dtype(dtype) == "bool":
+        if sparse:
+            # `tf.sparse.reduce_max` doesn't work on bool and there is no
+            # `tf.sparse.reduce_any`.
+            outputs = one_hot(
+                x, num_classes, axis=axis, dtype="int8", sparse=True
+            )
+            outputs = tf.sparse.reduce_max(
+                outputs, axis=reduction_axis, output_is_sparse=True
+            )
+            outputs_shape = outputs.shape
+            outputs = tf.cast(outputs, dtype)
+            outputs.set_shape(outputs_shape)
+            return outputs
+        else:
+            outputs = one_hot(x, num_classes, axis=axis, dtype=dtype)
+            return tf.reduce_any(outputs, axis=reduction_axis)
+    else:
+        if sparse:
+            # We don't use `tf.sparse.bincount`, it doesn't handle negative
+            # indices and has a rank limitation.
+            outputs = one_hot(
+                x, num_classes, axis=axis, dtype=dtype, sparse=True
+            )
+            return tf.sparse.reduce_max(
+                outputs, axis=reduction_axis, output_is_sparse=True
+            )
+        else:
+            outputs = one_hot(x, num_classes, axis=axis, dtype=dtype)
+            return tf.reduce_max(outputs, axis=reduction_axis)
+
+
+def _get_logits(output, from_logits, op_type, fn_name):
+    """Retrieves logits tensor from maybe-softmax or maybe-sigmoid tensor."""
+    output_ = output
+    from_logits_ = from_logits
+
+    has_keras_logits = hasattr(output, "_keras_logits")
+    if has_keras_logits:
+        output_ = output._keras_logits
+        from_logits_ = True
+
+    from_expected_op_type = (
+        hasattr(output, "op")
+        and not isinstance(output, (tf.__internal__.EagerTensor, tf.Variable))
+        and output.op.type == op_type
+    ) and not has_keras_logits
+
+    if from_expected_op_type:
+        # When softmax activation function is used for output operation, we
+        # use logits from the softmax function directly to compute loss in order
+        # to prevent collapsing zero when training.
+        assert len(output.op.inputs) == 1
+        output_ = output.op.inputs[0]
+        from_logits_ = True
+
+    if from_logits and (has_keras_logits or from_expected_op_type):
+        warnings.warn(
+            f'"`{fn_name}` received `from_logits=True`, but '
+            f"the `output` argument was produced by a {op_type} "
+            "activation and thus does not represent logits. "
+            "Was this intended?",
+            stacklevel=2,
+        )
+    return output_, from_logits_
+
+
+def categorical_crossentropy(target, output, from_logits=False, axis=-1):
+    """Categorical crossentropy between an output tensor and a target tensor.
+
+    Args:
+        target: A tensor of the same shape as `output`.
+        output: A tensor resulting from a softmax
+            (unless `from_logits` is `True`, in which
+            case `output` is expected to be the logits).
+        from_logits: Boolean, whether `output` is the
+            result of a softmax, or is a tensor of logits.
+        axis: Int specifying the channels axis. `axis=-1` corresponds to data
+            format `channels_last`, and `axis=1` corresponds to data format
+            `channels_first`.
+
+    Returns:
+        Output tensor.
+
+    Example:
+
+    >>> a = tf.constant([1., 0., 0., 0., 1., 0., 0., 0., 1.], shape=[3,3])
+    >>> print(a)
+    tf.Tensor(
+      [[1. 0. 0.]
+       [0. 1. 0.]
+       [0. 0. 1.]], shape=(3, 3), dtype=float32)
+    >>> b = tf.constant([.9, .05, .05, .05, .89, .06, .05, .01, .94],
+    ...                 shape=[3, 3])
+    >>> print(b)
+    tf.Tensor(
+      [[0.9  0.05 0.05]
+       [0.05 0.89 0.06]
+       [0.05 0.01 0.94]], shape=(3, 3), dtype=float32)
+    >>> loss = categorical_crossentropy(a, b)
+    >>> print(np.around(loss, 5))
+    [0.10536 0.11653 0.06188]
+    >>> loss = categorical_crossentropy(a, a)
+    >>> print(np.around(loss, 5))
+    [0. 0. 0.]
+    """
+    target = tf.convert_to_tensor(target)
+    output = tf.convert_to_tensor(output)
+
+    if len(target.shape) < 1:
+        raise ValueError(
+            "Arguments `target` and `output` must be at least rank 1. "
+            "Received: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+    if len(target.shape) != len(output.shape):
+        raise ValueError(
+            "Arguments `target` and `output` must have the same rank "
+            "(ndim). Received: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+    for e1, e2 in zip(target.shape, output.shape):
+        if e1 is not None and e2 is not None and e1 != e2:
+            raise ValueError(
+                "Arguments `target` and `output` must have the same shape. "
+                "Received: "
+                f"target.shape={target.shape}, output.shape={output.shape}"
+            )
+
+    output, from_logits = _get_logits(
+        output, from_logits, "Softmax", "categorical_crossentropy"
+    )
+    if from_logits:
+        return tf.nn.softmax_cross_entropy_with_logits(
+            labels=target, logits=output, axis=axis
+        )
+
+    # Adjust the predictions so that the probability of
+    # each class for every sample adds up to 1
+    # This is needed to ensure that the cross entropy is
+    # computed correctly.
+    output = output / tf.reduce_sum(output, axis, keepdims=True)
+
+    # Compute cross entropy from probabilities.
+    output = tf.clip_by_value(
+        output, backend.epsilon(), 1.0 - backend.epsilon()
+    )
+    return -tf.reduce_sum(target * tf.math.log(output), axis)
+
+
+def sparse_categorical_crossentropy(target, output, from_logits=False, axis=-1):
+    """Categorical crossentropy with integer targets.
+
+    Args:
+        target: An integer tensor.
+        output: A tensor resulting from a softmax
+            (unless `from_logits` is True, in which
+            case `output` is expected to be the logits).
+        from_logits: Boolean, whether `output` is the
+            result of a softmax, or is a tensor of logits.
+        axis: Int specifying the channels axis. `axis=-1` corresponds to data
+            format `channels_last`, and `axis=1` corresponds to data format
+            `channels_first`.
+
+    Returns:
+        Output tensor.
+    """
+    if axis != -1 and axis != len(output.shape) - 1:
+        raise ValueError(
+            f"Only axis=-1 is currently supported. Received: axis={axis}"
+        )
+    output, from_logits = _get_logits(
+        output, from_logits, "Softmax", "sparse_categorical_crossentropy"
+    )
+
+    target = tf.convert_to_tensor(target)
+    target = tf.cast(target, dtype="int64")
+    output = tf.convert_to_tensor(output)
+    if len(target.shape) == len(output.shape) and target.shape[-1] == 1:
+        target = tf.squeeze(target, axis=-1)
+
+    if len(output.shape) < 1:
+        raise ValueError(
+            "Argument `output` must be at least rank 1. "
+            "Received: "
+            f"output.shape={output.shape}"
+        )
+    if len(target.shape) != len(output.shape[:-1]):
+        raise ValueError(
+            "Argument `output` must have rank (ndim) `target.ndim - 1`. "
+            "Received: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+    for e1, e2 in zip(target.shape, output.shape[:-1]):
+        if e1 is not None and e2 is not None and e1 != e2:
+            raise ValueError(
+                "Arguments `target` and `output` must have the same shape "
+                "up until the last dimension: "
+                f"target.shape={target.shape}, output.shape={output.shape}"
+            )
+
+    if not from_logits:
+        output = tf.clip_by_value(
+            output, backend.epsilon(), 1 - backend.epsilon()
+        )
+        output = tf.math.log(output)
+
+    result = tf.nn.sparse_softmax_cross_entropy_with_logits(
+        labels=target, logits=output
+    )
+    return result
+
+
+def binary_crossentropy(target, output, from_logits=False):
+    """Binary crossentropy between an output tensor and a target tensor.
+
+    Args:
+        target: A tensor with the same shape as `output`.
+        output: A tensor.
+        from_logits: Whether `output` is expected to be a logits tensor.
+            By default, we consider that `output`
+            encodes a probability distribution.
+
+    Returns:
+        A tensor.
+    """
+    target = tf.convert_to_tensor(target)
+    output = tf.convert_to_tensor(output)
+
+    if len(target.shape) != len(output.shape):
+        raise ValueError(
+            "Arguments `target` and `output` must have the same rank "
+            "(ndim). Received: "
+            f"target.shape={target.shape}, output.shape={output.shape}"
+        )
+    for e1, e2 in zip(target.shape, output.shape):
+        if e1 is not None and e2 is not None and e1 != e2:
+            raise ValueError(
+                "Arguments `target` and `output` must have the same shape. "
+                "Received: "
+                f"target.shape={target.shape}, output.shape={output.shape}"
+            )
+
+    output, from_logits = _get_logits(
+        output, from_logits, "Sigmoid", "binary_crossentropy"
+    )
+
+    if from_logits:
+        return tf.nn.sigmoid_cross_entropy_with_logits(
+            labels=target, logits=output
+        )
+
+    # Compute cross entropy from probabilities.
+    output = tf.clip_by_value(
+        output, backend.epsilon(), 1.0 - backend.epsilon()
+    )
+    bce = target * tf.math.log(output)
+    bce += (1 - target) * tf.math.log(1 - output)
+    return -bce
+
+
+def moments(x, axes, keepdims=False, synchronized=False):
+    # The dynamic range of float16 is too limited for statistics. As a
+    # workaround, we simply perform the operations on float32 and convert back
+    # to float16
+    need_cast = False
+    ori_dtype = backend.standardize_dtype(x.dtype)
+    if ori_dtype in ("float16", "bfloat16"):
+        need_cast = True
+        x = cast(x, "float32")
+
+    if synchronized:
+        mean, variance = _compute_moments_sync(x, axes, keepdims)
+    else:
+        mean, variance = _compute_moments(x, axes, keepdims)
+    if need_cast:
+        # avoid overflow and underflow when casting from float16 to float32
+        mean = tf.clip_by_value(mean, tf.float16.min, tf.float16.max)
+        variance = tf.clip_by_value(variance, tf.float16.min, tf.float16.max)
+        mean = cast(mean, ori_dtype)
+        variance = cast(variance, ori_dtype)
+    return mean, variance
+
+
+def _compute_moments_sync(x, axes, keepdims):
+    replica_ctx = tf.distribute.get_replica_context()
+    if not replica_ctx:
+        return _compute_moments(x, axes, keepdims)
+
+    local_count = tf.ones_like(x, name="count")
+
+    local_sum = tf.reduce_sum(x, axis=axes, keepdims=True)
+    local_squared_sum = tf.reduce_sum(tf.square(x), axis=axes, keepdims=True)
+    local_count = tf.reduce_sum(local_count, axis=axes, keepdims=True)
+
+    # TODO(b/163099951): batch the all-reduces once we sort out the
+    # ordering issue for NCCL. We don't have a mechanism to launch
+    # NCCL in the same order in each replica nowadays, so we limit
+    # NCCL to batch all-reduces.
+    y_sum = replica_ctx.all_reduce(tf.distribute.ReduceOp.SUM, local_sum)
+    y_squared_sum = replica_ctx.all_reduce(
+        tf.distribute.ReduceOp.SUM, local_squared_sum
+    )
+    count_sum = replica_ctx.all_reduce(tf.distribute.ReduceOp.SUM, local_count)
+
+    mean = tf.math.divide_no_nan(y_sum, count_sum)
+    y_squared_mean = tf.math.divide_no_nan(y_squared_sum, count_sum)
+    # var = E(x^2) - E(x)^2
+    variance = tf.maximum(y_squared_mean - tf.square(mean), 0.0)
+    if not keepdims:
+        mean = tf.squeeze(mean, axes)
+        variance = tf.squeeze(variance, axes)
+
+    return mean, variance
+
+
+def _compute_moments(x, axes, keepdims):
+    return tf.nn.moments(x, axes, keepdims=keepdims)
+
+
+def batch_normalization(
+    x, mean, variance, axis, offset=None, scale=None, epsilon=1e-3
+):
+    if axis != -1:
+        shape = [1] * len(x.shape)
+        shape[axis] = mean.shape[0]
+        mean = tf.reshape(mean, shape)
+        variance = tf.reshape(variance, shape)
+        if offset is not None:
+            offset = tf.reshape(offset, shape)
+        if scale is not None:
+            scale = tf.reshape(scale, shape)
+
+    return tf.nn.batch_normalization(
+        x=x,
+        mean=mean,
+        variance=variance,
+        offset=offset,
+        scale=scale,
+        variance_epsilon=epsilon,
+    )
+
+
+def ctc_loss(
+    target,
+    output,
+    target_length,
+    output_length,
+    mask_index=0,
+):
+    target = convert_to_tensor(target)
+    output = convert_to_tensor(output)
+    target = tf.cast(target, dtype="int32")
+
+    # `tf.nn.ctc_loss` will internally cast to float32 when the input is float16
+    # or bfloat16. Additionally, it will raise an error when the input is
+    # float64. As a result, we perform the casting externally and add support
+    # for float64.
+    result_dtype = backend.result_type(output.dtype, "float32")
+    compute_dtype = "float32" if result_dtype == "float64" else result_dtype
+    output = tf.cast(output, compute_dtype)
+    loss = tf.nn.ctc_loss(
+        labels=target,
+        logits=output,
+        label_length=target_length,
+        logit_length=output_length,
+        blank_index=mask_index,
+        logits_time_major=False,
+    )
+    return tf.cast(loss, result_dtype)
+
+
+def ctc_decode(
+    inputs,
+    sequence_lengths,
+    strategy="greedy",
+    beam_width=100,
+    top_paths=1,
+    merge_repeated=True,
+    mask_index=0,
+):
+    inputs = convert_to_tensor(inputs)
+    input_shape = tf.shape(inputs)
+    num_samples, num_steps = input_shape[0], input_shape[1]
+    inputs = tf.transpose(inputs, (1, 0, 2))
+
+    dtype = backend.result_type(inputs.dtype, "float32")
+    inputs = tf.cast(inputs, dtype)
+
+    sequence_lengths = convert_to_tensor(sequence_lengths, dtype="int32")
+    if strategy == "greedy":
+        (decoded, scores) = tf.nn.ctc_greedy_decoder(
+            inputs=inputs,
+            sequence_length=sequence_lengths,
+            merge_repeated=merge_repeated,
+            blank_index=mask_index,
+        )
+    elif strategy == "beam_search":
+        # Move `mask_index` column to the last position since this is the
+        # default for `tf.nn.ctc_beam_search_decoder`
+        if mask_index is not None:
+            inputs_before = inputs[..., :mask_index]
+            inputs_mask = inputs[..., mask_index : mask_index + 1]
+            inputs_after = inputs[..., mask_index + 1 :]
+            inputs = tf.concat(
+                [inputs_before, inputs_after, inputs_mask], axis=-1
+            )
+        (decoded, scores) = tf.nn.ctc_beam_search_decoder(
+            inputs=inputs,
+            sequence_length=sequence_lengths,
+            beam_width=beam_width,
+            top_paths=top_paths,
+        )
+    else:
+        raise ValueError(
+            f"Invalid strategy {strategy}. Supported values are "
+            "'greedy' and 'beam_search'."
+        )
+
+    # Postprocess sparse tensor
+    decoded_dense = []
+    for st in decoded:
+        st = tf.SparseTensor(st.indices, st.values, (num_samples, num_steps))
+        decoded_dense.append(tf.sparse.to_dense(sp_input=st, default_value=-1))
+    decoded_dense = tf.stack(decoded_dense, axis=0)
+    decoded_dense = tf.cast(decoded_dense, "int32")
+
+    # We need to recover the labels because we swapped the indices earlier
+    if strategy == "beam_search" and mask_index is not None:
+        if mask_index < 0:
+            mask_index = mask_index + input_shape[-1]
+        decoded_dense = tf.where(
+            decoded_dense >= mask_index, decoded_dense + 1, decoded_dense
+        )
+    return decoded_dense, scores
+
+
+def psnr(x1, x2, max_val):
+    from keras.src.backend.tensorflow.numpy import log10
+
+    if x1.shape != x2.shape:
+        raise ValueError(
+            f"Input shapes {x1.shape} and {x2.shape} must "
+            "match for PSNR calculation. "
+        )
+
+    max_val = convert_to_tensor(max_val, dtype=x2.dtype)
+    mse = tf.reduce_mean(tf.square(x1 - x2))
+    psnr = 20 * log10(max_val) - 10 * log10(mse)
+    return psnr
+
+
+def _get_large_negative(dtype):
+    dtype = backend.standardize_dtype(dtype)
+    val = 65500.0 if dtype == "float16" else 3.38953e38
+    return tf.constant(val * -0.7, dtype=dtype)
+
+
+def _apply_masks(logits, mask, is_causal):
+    if mask is None and not is_causal:
+        return logits
+
+    combined_mask = tf.ones_like(logits, dtype="bool")
+    if mask is not None:
+        combined_mask = tf.logical_and(combined_mask, mask)
+
+    if is_causal:
+        logits_shape = tf.shape(logits)
+        T, S = logits_shape[2], logits_shape[3]
+        mask = tf.linalg.band_part(tf.ones((T, S), "bool"), -1, 0)
+        mask = mask[None, None, :, :]
+        combined_mask = tf.logical_and(combined_mask, mask)
+
+    padded_logits = tf.where(
+        combined_mask, logits, _get_large_negative(logits.dtype)
+    )
+    return padded_logits
+
+
+def _dot_product_attention_xla(query, key, value, bias, mask, is_causal, scale):
+    logits_dtype = backend.result_type(query.dtype, "float32")
+    logits = tf.einsum("BTNH,BSNH->BNTS", query, key, optimize="optimal")
+    logits = tf.cast(logits, logits_dtype)
+    logits = tf.multiply(logits, tf.cast(scale, logits.dtype))
+
+    if bias is not None:
+        logits = tf.add(logits, tf.cast(bias, logits.dtype))
+
+    padded_logits = _apply_masks(logits, mask, is_causal)
+
+    # Softmax is always carried out in high precision.
+    probs_dtype = backend.result_type(padded_logits.dtype, "float32")
+    probs = tf.cast(
+        tf.nn.softmax(tf.cast(padded_logits, probs_dtype), axis=-1), key.dtype
+    )
+    return tf.einsum("BNTS,BSNH->BTNH", probs, value, optimize="optimal")
+
+
+def dot_product_attention(
+    query,
+    key,
+    value,
+    bias=None,
+    mask=None,
+    scale=None,
+    is_causal=False,
+    flash_attention=None,
+):
+    if flash_attention is None:
+        flash_attention = False
+    if flash_attention:
+        raise ValueError(
+            "Flash attention is not supported in tensorflow backend."
+        )
+
+    # Ref: jax.nn.dot_product_attention
+    # https://github.com/jax-ml/jax/blob/jax-v0.4.32/jax/_src/nn/functions.py#L828
+    # Not support `query_seq_lengths` and `key_value_seq_lengths` args
+    query = convert_to_tensor(query)
+    key = convert_to_tensor(key)
+    value = convert_to_tensor(value)
+    if len(query.shape) != 4:
+        raise ValueError(
+            "`dot_product_attention` only supports 4D inputs. "
+            f"Received: query.shape={query.shape}, key.shape={key.shape}, "
+            f"value.shape={value.shape}."
+        )
+    H = tf.shape(key)[-1]
+    scale = (1.0 / tf.sqrt(tf.cast(H, "float32"))) if scale is None else scale
+    return _dot_product_attention_xla(
+        query, key, value, bias, mask, is_causal, scale
+    )

infer_4_33_0/lib/python3.10/site-packages/keras/src/backend/tensorflow/numpy.py

@@ -0,0 +1,2658 @@
+import builtins
+import collections
+import functools
+import math
+import string
+import warnings
+
+import numpy as np
+import tensorflow as tf
+from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_ops
+from tensorflow.python.ops.math_ops import is_nan
+
+from keras.src import tree
+from keras.src.backend import config
+from keras.src.backend import standardize_dtype
+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.backend.common.backend_utils import vectorize_impl
+from keras.src.backend.tensorflow import sparse
+from keras.src.backend.tensorflow.core import cast
+from keras.src.backend.tensorflow.core import convert_to_tensor
+from keras.src.backend.tensorflow.core import shape as shape_op
+
+
+@sparse.elementwise_binary_union(tf.sparse.add)
+def add(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+
+    # Special case of `tf.add`: `tf.nn.bias_add`
+    # `BiasAdd` can be fused with `MatMul` and `Conv*` kernels
+    # Expecting `x1` to be `inputs` and `x2` to be `bias` (no swapping)
+    x2_squeeze_shape = [d for d in x2.shape.as_list() if d is None or d > 1]
+    if (
+        # `x2` looks like bias (can be squeezed to vector)
+        1 == len(x2_squeeze_shape)
+        # `x1` looks like input tensor (rank >= 2)
+        and len(x1.shape) > 1
+        # `x2` non-squeezable dimension defined
+        and x2_squeeze_shape[0] is not None
+        # `x2` non-squeezable dimension match `x1` channel dimension
+        and x2_squeeze_shape[0]
+        in {x1.shape.as_list()[1], x1.shape.as_list()[-1]}
+    ):
+        if x1.shape[-1] == x2_squeeze_shape[0]:
+            data_format = "NHWC"
+        else:
+            data_format = "NCHW"
+        if len(x2.shape) > 1:
+            x2 = tf.squeeze(x2)
+        return tf.nn.bias_add(x1, x2, data_format=data_format)
+
+    return tf.add(x1, x2)
+
+
+def bincount(x, weights=None, minlength=0, sparse=False):
+    x = convert_to_tensor(x)
+    dtypes_to_resolve = [x.dtype]
+    if standardize_dtype(x.dtype) not in ["int32", "int64"]:
+        x = tf.cast(x, tf.int32)
+    if weights is not None:
+        weights = convert_to_tensor(weights)
+        dtypes_to_resolve.append(weights.dtype)
+        dtype = dtypes.result_type(*dtypes_to_resolve)
+        if standardize_dtype(weights.dtype) not in [
+            "int32",
+            "int64",
+            "float32",
+            "float64",
+        ]:
+            if "int" in standardize_dtype(weights.dtype):
+                weights = tf.cast(weights, tf.int32)
+            else:
+                weights = tf.cast(weights, tf.float32)
+    else:
+        dtype = "int32"
+    if sparse or isinstance(x, tf.SparseTensor):
+        output = tf.sparse.bincount(
+            x,
+            weights=weights,
+            minlength=minlength,
+            axis=-1,
+        )
+        actual_length = output.shape[-1]
+        if actual_length is None:
+            actual_length = tf.shape(output)[-1]
+        output = cast(output, dtype)
+        if x.shape.rank == 1:
+            output_shape = (actual_length,)
+        else:
+            batch_size = output.shape[0]
+            if batch_size is None:
+                batch_size = tf.shape(output)[0]
+            output_shape = (batch_size, actual_length)
+        return tf.SparseTensor(
+            indices=output.indices,
+            values=output.values,
+            dense_shape=output_shape,
+        )
+    return tf.cast(
+        tf.math.bincount(x, weights=weights, minlength=minlength, axis=-1),
+        dtype,
+    )
+
+
+@functools.lru_cache(512)
+def _normalize_einsum_subscripts(subscripts):
+    # string.ascii_letters
+    mapping = {}
+    normalized_subscripts = ""
+    for c in subscripts:
+        if c in string.ascii_letters:
+            if c not in mapping:
+                mapping[c] = string.ascii_letters[len(mapping)]
+            normalized_subscripts += mapping[c]
+        else:
+            normalized_subscripts += c
+    return normalized_subscripts
+
+
+def einsum(subscripts, *operands, **kwargs):
+    operands = tree.map_structure(convert_to_tensor, operands)
+    subscripts = _normalize_einsum_subscripts(subscripts)
+
+    def is_valid_for_custom_ops(subscripts, *operands):
+        # Check that `subscripts` is supported and the shape of operands is not
+        # `None`.
+        if subscripts in [
+            "a,b->ab",
+            "ab,b->a",
+            "ab,bc->ac",
+            "ab,cb->ac",
+            "abc,cd->abd",
+            "abc,dc->abd",
+            "abcd,abde->abce",
+            "abcd,abed->abce",
+            "abcd,acbe->adbe",
+            "abcd,adbe->acbe",
+            "abcd,aecd->acbe",
+            "abcd,aecd->aceb",
+        ]:
+            # These subscripts don't require the shape information
+            return True
+        elif subscripts == "abc,cde->abde":
+            _, b1, c1 = operands[0].shape
+            c2, d2, e2 = operands[1].shape
+            b, c, d, e = b1, c1 or c2, d2, e2
+            if None in (b, c, d, e):
+                return False
+            return True
+        elif subscripts == "abc,dce->abde":
+            _, b1, c1 = operands[0].shape
+            d2, c2, e2 = operands[1].shape
+            b, c, d, e = b1, c1 or c2, d2, e2
+            if None in (b, c, d, e):
+                return False
+            return True
+        elif subscripts == "abc,dec->abde":
+            _, b1, c1 = operands[0].shape
+            d2, e2, c2 = operands[1].shape
+            b, c, d, e = b1, c1 or c2, d2, e2
+            if None in (b, c, d, e):
+                return False
+            return True
+        elif subscripts == "abcd,cde->abe":
+            _, b1, c1, d1 = operands[0].shape
+            c2, d2, e2 = operands[1].shape
+            b, c, d, e = b1, c1 or c2, d1 or d2, e2
+            if None in (b, c, d, e):
+                return False
+            return True
+        elif subscripts == "abcd,ced->abe":
+            _, b1, c1, d1 = operands[0].shape
+            c2, e2, d2 = operands[1].shape
+            b, c, d, e = b1, c1 or c2, d1 or d2, e2
+            if None in (b, c, d, e):
+                return False
+            return True
+        elif subscripts == "abcd,ecd->abe":
+            _, b1, c1, d1 = operands[0].shape
+            e2, c2, d2 = operands[1].shape
+            b, c, d, e = b1, c1 or c2, d1 or d2, e2
+            if None in (b, c, d, e):
+                return False
+            return True
+        elif subscripts == "abcde,aebf->adbcf":
+            _, b1, c1, d1, e1 = operands[0].shape
+            _, e2, b2, f2 = operands[1].shape
+            b, c, d, e, f = b1 or b2, c1, d1, e1 or e2, f2
+            if None in (b, c, d, e, f):
+                return False
+            return True
+        elif subscripts == "abcde,afce->acdbf":
+            _, b1, c1, d1, e1 = operands[0].shape
+            _, f2, c2, e2 = operands[1].shape
+            b, c, d, e, f = b1, c1 or c2, d1, e1 or e2, f2
+            if None in (b, c, d, e, f):
+                return False
+            return True
+        else:
+            # No match in subscripts
+            return False
+
+    def use_custom_ops(subscripts, *operands, output_type):
+        # Replace tf.einsum with custom ops to utilize hardware-accelerated
+        # matmul
+        x, y = operands[0], operands[1]
+        if subscripts == "a,b->ab":
+            x = tf.expand_dims(x, axis=-1)
+            y = tf.expand_dims(y, axis=0)
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "ab,b->a":
+            y = tf.expand_dims(y, axis=-1)
+            result = tf.matmul(x, y, output_type=output_type)
+            return tf.squeeze(result, axis=-1)
+        elif subscripts == "ab,bc->ac":
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "ab,cb->ac":
+            y = tf.transpose(y, [1, 0])
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abc,cd->abd":
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abc,cde->abde":
+            _, b1, c1 = x.shape
+            c2, d2, e2 = y.shape
+            b, c, d, e = b1, c1 or c2, d2, e2
+            y = tf.reshape(y, [c, -1])
+            result = tf.matmul(x, y, output_type=output_type)
+            return tf.reshape(result, [-1, b, d, e])
+        elif subscripts == "abc,dc->abd":
+            y = tf.transpose(y, [1, 0])
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abc,dce->abde":
+            _, b1, c1 = x.shape
+            d2, c2, e2 = y.shape
+            b, c, d, e = b1, c1 or c2, d2, e2
+            y = tf.transpose(y, [1, 0, 2])  # cde
+            y = tf.reshape(y, [c, -1])
+            result = tf.matmul(x, y, output_type=output_type)
+            return tf.reshape(result, [-1, b, d, e])
+        elif subscripts == "abc,dec->abde":
+            _, b1, c1 = x.shape
+            d2, e2, c2 = y.shape
+            b, c, d, e = b1, c1 or c2, d2, e2
+            y = tf.transpose(y, [2, 0, 1])  # cde
+            y = tf.reshape(y, [c, -1])
+            result = tf.matmul(x, y, output_type=output_type)
+            return tf.reshape(result, [-1, b, d, e])
+        elif subscripts == "abcd,abde->abce":
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abcd,abed->abce":
+            y = tf.transpose(y, [0, 1, 3, 2])
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abcd,acbe->adbe":
+            x = tf.transpose(x, [0, 1, 3, 2])
+            y = tf.transpose(y, [0, 2, 1, 3])
+            result = tf.matmul(x, y, output_type=output_type)
+            return tf.transpose(result, [0, 2, 1, 3])
+        elif subscripts == "abcd,adbe->acbe":
+            y = tf.transpose(y, [0, 2, 1, 3])  # abde
+            result = tf.matmul(x, y, output_type=output_type)  # abce
+            return tf.transpose(result, [0, 2, 1, 3])
+        elif subscripts == "abcd,aecd->acbe":
+            x = tf.transpose(x, [0, 2, 1, 3])  # acbd
+            y = tf.transpose(y, [0, 2, 3, 1])  # acde
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abcd,aecd->aceb":
+            x = tf.transpose(x, [0, 2, 1, 3])
+            y = tf.transpose(y, [0, 2, 3, 1])
+            result = tf.matmul(x, y, output_type=output_type)  # acbe
+            return tf.transpose(result, [0, 1, 3, 2])
+        elif subscripts == "abcd,cde->abe":
+            _, b1, c1, d1 = x.shape
+            c2, d2, e2 = y.shape
+            b, c, d, e = b1, c1 or c2, d1 or d2, e2
+            x = tf.reshape(x, [-1, b, c * d])
+            y = tf.reshape(y, [-1, e])
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abcd,ced->abe":
+            _, b1, c1, d1 = x.shape
+            c2, e2, d2 = y.shape
+            b, c, d, e = b1, c1 or c2, d1 or d2, e2
+            x = tf.reshape(x, [-1, b, c * d])
+            y = tf.transpose(y, [0, 2, 1])
+            y = tf.reshape(y, [-1, e])
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abcd,ecd->abe":
+            _, b1, c1, d1 = x.shape
+            e2, c2, d2 = y.shape
+            b, c, d, e = b1, c1 or c2, d1 or d2, e2
+            x = tf.reshape(x, [-1, b, c * d])
+            y = tf.transpose(y, [1, 2, 0])
+            y = tf.reshape(y, [-1, e])
+            return tf.matmul(x, y, output_type=output_type)
+        elif subscripts == "abcde,aebf->adbcf":
+            _, b1, c1, d1, e1 = x.shape
+            _, e2, b2, f2 = y.shape
+            b, c, d, e, f = b1 or b2, c1, d1, e1 or e2, f2
+            x = tf.reshape(x, [-1, b, c * d, e])  # ab(cd)e
+            y = tf.transpose(y, [0, 2, 1, 3])  # abef
+            result = tf.matmul(x, y, output_type=output_type)  # ab(cd)f
+            result = tf.reshape(result, [-1, b, c, d, f])  # abcdf
+            return tf.transpose(result, [0, 3, 1, 2, 4])
+        elif subscripts == "abcde,afce->acdbf":
+            _, b1, c1, d1, e1 = x.shape
+            _, f2, c2, e2 = y.shape
+            b, c, d, e, f = b1, c1 or c2, d1, e1 or e2, f2
+            x = tf.transpose(x, [0, 2, 3, 1, 4])  # acdbe
+            x = tf.reshape(x, [-1, c, d * b, e])  # ac(db)e
+            y = tf.transpose(y, [0, 2, 3, 1])  # acef
+            result = tf.matmul(x, y, output_type=output_type)  # ac(db)f
+            return tf.reshape(result, [-1, c, d, b, f])
+        else:
+            raise NotImplementedError
+
+    dtypes_to_resolve = list(set(standardize_dtype(x.dtype) for x in operands))
+    # When operands are of int8, we cast the result to int32 to align with
+    # the behavior of jax.
+    if len(dtypes_to_resolve) == 1 and dtypes_to_resolve[0] == "int8":
+        compute_dtype = "int8"
+        result_dtype = "int32"
+        output_type = "int32"
+    else:
+        result_dtype = dtypes.result_type(*dtypes_to_resolve)
+        compute_dtype = result_dtype
+        output_type = None
+
+    # TODO: Remove the condition once `tf.einsum` supports int8xint8->int32
+    if is_valid_for_custom_ops(subscripts, *operands) and not kwargs:
+        # TODO: tf.matmul doesn't support integer dtype if not specifying
+        # output_type="int32"
+        if "int" in compute_dtype and output_type is None:
+            compute_dtype = config.floatx()
+        operands = tree.map_structure(
+            lambda x: tf.cast(x, compute_dtype), operands
+        )
+        result = use_custom_ops(subscripts, *operands, output_type=output_type)
+    else:
+        # TODO: tf.einsum doesn't support integer dtype with gpu
+        if "int" in compute_dtype:
+            compute_dtype = config.floatx()
+        operands = tree.map_structure(
+            lambda x: tf.cast(x, compute_dtype), operands
+        )
+        result = tf.einsum(subscripts, *operands, **kwargs)
+    return tf.cast(result, result_dtype)
+
+
+@sparse.elementwise_binary_union(sparse.sparse_subtract)
+def subtract(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.subtract(x1, x2)
+
+
+def matmul(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    x1_shape = x1.shape
+    x2_shape = x2.shape
+    x1_sparse = isinstance(x1, tf.SparseTensor)
+    x2_sparse = isinstance(x2, tf.SparseTensor)
+    # When both x1 and x2 are of int8 and dense tensor, specifying `output_type`
+    # as int32 to enable hardware-accelerated matmul
+    x1_dtype = standardize_dtype(x1.dtype)
+    x2_dtype = standardize_dtype(x2.dtype)
+    if (
+        x1_dtype == "int8"
+        and x2_dtype == "int8"
+        and not x1_sparse
+        and not x2_sparse
+        and x1_shape.rank != 1  # TODO: support tf.tensordot
+        and x2_shape.rank != 1  # TODO: support tf.tensordot
+    ):
+        compute_dtype = "int8"
+        result_dtype = "int32"
+        output_type = result_dtype
+    else:
+        # TODO: Typically, GPU and XLA only support float types
+        compute_dtype = dtypes.result_type(x1.dtype, x2.dtype, float)
+        result_dtype = dtypes.result_type(x1.dtype, x2.dtype)
+        output_type = None
+    x1 = tf.cast(x1, compute_dtype)
+    x2 = tf.cast(x2, compute_dtype)
+
+    def with_combined_batch_dimensions(a, b, output_shape, fn_3d):
+        a_sparse = isinstance(a, tf.SparseTensor)
+        b_sparse = isinstance(b, tf.SparseTensor)
+        batch_shape = b.shape[:-2] if b_sparse else a.shape[:-2]
+        batch_size = math.prod(batch_shape)
+        a3d_shape = [batch_size] + a.shape[-2:]
+        a_3d = (
+            tf.sparse.reshape(a, a3d_shape)
+            if a_sparse
+            else tf.reshape(a, a3d_shape)
+        )
+        b3d_shape = [batch_size] + b.shape[-2:]
+        b_3d = (
+            tf.sparse.reshape(b, b3d_shape)
+            if b_sparse
+            else tf.reshape(b, b3d_shape)
+        )
+        result_3d = fn_3d(a_3d, b_3d)
+        return (
+            tf.sparse.reshape(result_3d, output_shape)
+            if isinstance(result_3d, tf.SparseTensor)
+            else tf.reshape(result_3d, output_shape)
+        )
+
+    def sparse_sparse_matmul(a, b):
+        dtype = a.values.dtype
+        # Convert SparseTensors to CSR SparseMatrix.
+        a_csr = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
+            a.indices, a.values, a.dense_shape
+        )
+        b_csr = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
+            b.indices, b.values, b.dense_shape
+        )
+        # Compute the CSR SparseMatrix matrix multiplication.
+        result_csr = sparse_csr_matrix_ops.sparse_matrix_sparse_mat_mul(
+            a_csr, b_csr, dtype
+        )
+        # Convert the CSR SparseMatrix to a SparseTensor.
+        res = sparse_csr_matrix_ops.csr_sparse_matrix_to_sparse_tensor(
+            result_csr, dtype
+        )
+        return tf.SparseTensor(res.indices, res.values, res.dense_shape)
+
+    def embedding_lookup_sparse_dense_matmul(a, b):
+        # We need at least one id per rows for embedding_lookup_sparse,
+        # otherwise there will be missing rows in the output.
+        a, _ = tf.sparse.fill_empty_rows(a, 0)
+        # We need to split x1 into separate ids and weights tensors. The ids
+        # should be the column indices of x1 and the values of the weights
+        # can continue to be the actual x1. The column arrangement of ids
+        # and weights does not matter as we sum over columns. See details in
+        # the documentation for sparse_ops.sparse_tensor_dense_matmul.
+        ids = tf.SparseTensor(
+            indices=a.indices,
+            values=a.indices[:, 1],
+            dense_shape=a.dense_shape,
+        )
+        return tf.nn.embedding_lookup_sparse(b, ids, a, combiner="sum")
+
+    # Either a or b is sparse
+    def sparse_dense_matmul_3d(a, b):
+        return tf.map_fn(
+            lambda x: tf.sparse.sparse_dense_matmul(x[0], x[1]),
+            elems=(a, b),
+            fn_output_signature=a.dtype,
+        )
+
+    if x1_sparse or x2_sparse:
+        from keras.src.ops.operation_utils import compute_matmul_output_shape
+
+        output_shape = compute_matmul_output_shape(x1_shape, x2_shape)
+        if x1_sparse and x2_sparse:
+            if x1_shape.rank <= 3:
+                output = sparse_sparse_matmul(x1, x2)
+            else:
+                output = with_combined_batch_dimensions(
+                    x1, x2, output_shape, sparse_sparse_matmul
+                )
+        else:
+            # Sparse * dense or dense * sparse
+            sparse_rank = x1_shape.rank if x1_sparse else x2_shape.rank
+
+            # Special case: embedding_lookup_sparse for sparse * dense, rank 2
+            if x1_sparse and sparse_rank == 2:
+                output = embedding_lookup_sparse_dense_matmul(x1, x2)
+            elif sparse_rank == 2:
+                output = tf.sparse.sparse_dense_matmul(x1, x2)
+            elif sparse_rank == 3:
+                output = sparse_dense_matmul_3d(x1, x2)
+            else:
+                output = with_combined_batch_dimensions(
+                    x1, x2, output_shape, sparse_dense_matmul_3d
+                )
+        output = tf.cast(output, result_dtype)
+        output.set_shape(output_shape)
+        return output
+    else:
+        if x1_shape.rank == 2 and x2_shape.rank == 2:
+            output = tf.matmul(x1, x2, output_type=output_type)
+        elif x2_shape.rank == 1:
+            output = tf.tensordot(x1, x2, axes=1)
+        elif x1_shape.rank == 1:
+            output = tf.tensordot(x1, x2, axes=[[0], [-2]])
+        else:
+            output = tf.matmul(x1, x2, output_type=output_type)
+        return tf.cast(output, result_dtype)
+
+
+@sparse.elementwise_binary_intersection
+def multiply(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.multiply(x1, x2)
+
+
+def mean(x, axis=None, keepdims=False):
+    if isinstance(x, tf.IndexedSlices):
+        if axis is None:
+            # Reduce against all axes, result is a single value and dense.
+            # The denominator has to account for `dense_shape`.
+            sum = tf.reduce_sum(x.values, keepdims=keepdims)
+            return sum / tf.cast(tf.reduce_prod(x.dense_shape), dtype=sum.dtype)
+
+        axis = to_tuple_or_list(axis)
+        if not axis:
+            # Empty axis tuple, this is a no-op
+            return x
+
+        dense_shape = tf.convert_to_tensor(x.dense_shape)
+        rank = tf.shape(dense_shape)[0]
+        # Normalize axis: convert negative values and sort
+        axis = [canonicalize_axis(a, rank) for a in axis]
+        axis.sort()
+
+        if axis == [0]:
+            # Reduce against `axis=0` only, result is dense.
+            # The denominator has to account for `dense_shape[0]`.
+            sum = tf.reduce_sum(x.values, axis=0, keepdims=keepdims)
+            return sum / tf.cast(dense_shape[0], dtype=sum.dtype)
+        elif axis[0] == 0:
+            # Reduce against axis 0 and other axes, result is dense.
+            # We do `axis=0` separately first. The denominator has to account
+            # for `dense_shape[0]`.
+            # We use `keepdims=True` in `reduce_sum`` so that we can leave the
+            # 0 in axis and do `reduce_mean` with `keepdims` to apply it for all
+            # axes.
+            sum = tf.reduce_sum(x.values, axis=0, keepdims=True)
+            axis_0_mean = sum / tf.cast(dense_shape[0], dtype=sum.dtype)
+            return tf.reduce_mean(axis_0_mean, axis=axis, keepdims=keepdims)
+        elif keepdims:
+            # With `keepdims=True`, result is an `IndexedSlices` with the same
+            # indices since axis 0 is not touched. The only thing to do is to
+            # correct `dense_shape` to account for dimensions that became 1.
+            new_values = tf.reduce_mean(x.values, axis=axis, keepdims=True)
+            new_dense_shape = tf.concat(
+                [dense_shape[0:1], new_values.shape[1:]], axis=0
+            )
+            return tf.IndexedSlices(new_values, x.indices, new_dense_shape)
+        elif rank == len(axis) + 1:
+            # `keepdims=False` and reducing against all axes except 0, result is
+            # a 1D tensor, which cannot be `IndexedSlices`. We have to scatter
+            # the computed means to construct the correct dense tensor.
+            return tf.scatter_nd(
+                tf.expand_dims(x.indices, axis=1),
+                tf.reduce_mean(x.values, axis=axis),
+                [dense_shape[0]],
+            )
+        else:
+            # `keepdims=False`, not reducing against axis 0 and there is at
+            # least one other axis we are not reducing against. We simply need
+            # to fix `dense_shape` to remove dimensions that were reduced.
+            gather_indices = [i for i in range(rank) if i not in axis]
+            return tf.IndexedSlices(
+                tf.reduce_mean(x.values, axis=axis),
+                x.indices,
+                tf.gather(x.dense_shape, gather_indices, axis=0),
+            )
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    compute_dtype = dtypes.result_type(x.dtype, "float32")
+    # `tf.reduce_mean` does not handle low precision (e.g., float16) overflow
+    # correctly, so we compute with float32 and cast back to the original type.
+    if "int" in ori_dtype or ori_dtype == "bool":
+        result_dtype = compute_dtype
+    else:
+        result_dtype = ori_dtype
+    output = tf.reduce_mean(
+        tf.cast(x, compute_dtype), axis=axis, keepdims=keepdims
+    )
+    return tf.cast(output, result_dtype)
+
+
+def max(x, axis=None, keepdims=False, initial=None):
+    x = convert_to_tensor(x)
+
+    # The TensorFlow numpy API implementation doesn't support `initial` so we
+    # handle it manually here.
+    if initial is not None:
+        if standardize_dtype(x.dtype) == "bool":
+            x = tf.reduce_any(x, axis=axis, keepdims=keepdims)
+            x = tf.math.maximum(tf.cast(x, "int32"), tf.cast(initial, "int32"))
+            return tf.cast(x, "bool")
+        else:
+            x = tf.reduce_max(x, axis=axis, keepdims=keepdims)
+            return tf.math.maximum(x, initial)
+
+    # TensorFlow returns -inf by default for an empty list, but for consistency
+    # with other backends and the numpy API we want to throw in this case.
+    if tf.executing_eagerly():
+        size_x = size(x)
+        tf.assert_greater(
+            size_x,
+            tf.constant(0, dtype=size_x.dtype),
+            message="Cannot compute the max of an empty tensor.",
+        )
+
+    if standardize_dtype(x.dtype) == "bool":
+        return tf.reduce_any(x, axis=axis, keepdims=keepdims)
+    else:
+        return tf.reduce_max(x, axis=axis, keepdims=keepdims)
+
+
+def ones(shape, dtype=None):
+    dtype = dtype or config.floatx()
+    return tf.ones(shape, dtype=dtype)
+
+
+def zeros(shape, dtype=None):
+    dtype = dtype or config.floatx()
+    return tf.zeros(shape, dtype=dtype)
+
+
+@sparse.elementwise_unary
+def absolute(x):
+    x = convert_to_tensor(x)
+    # uintx and bool are always non-negative
+    dtype = standardize_dtype(x.dtype)
+    if "uint" in dtype or dtype == "bool":
+        return x
+    return tf.abs(x)
+
+
+def abs(x):
+    return absolute(x)
+
+
+def all(x, axis=None, keepdims=False):
+    x = tf.cast(x, "bool")
+    return tf.reduce_all(x, axis=axis, keepdims=keepdims)
+
+
+def any(x, axis=None, keepdims=False):
+    x = tf.cast(x, "bool")
+    return tf.reduce_any(x, axis=axis, keepdims=keepdims)
+
+
+def amax(x, axis=None, keepdims=False):
+    return max(x, axis=axis, keepdims=keepdims)
+
+
+def amin(x, axis=None, keepdims=False):
+    return min(x, axis=axis, keepdims=keepdims)
+
+
+def append(x1, x2, axis=None):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    if axis is None:
+        return tf.concat([tf.reshape(x1, [-1]), tf.reshape(x2, [-1])], axis=0)
+    else:
+        return tf.concat([x1, x2], axis=axis)
+
+
+def arange(start, stop=None, step=1, dtype=None):
+    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)
+    dtype = standardize_dtype(dtype)
+    try:
+        out = tf.range(start, stop, delta=step, dtype=dtype)
+    except tf.errors.NotFoundError:
+        # Some dtypes may not work in eager mode on CPU or GPU.
+        out = tf.range(start, stop, delta=step, dtype="float32")
+        out = tf.cast(out, dtype)
+    return out
+
+
+@sparse.densifying_unary(0.5 * np.pi)
+def arccos(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.acos(x)
+
+
+@sparse.densifying_unary(np.nan)
+def arccosh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.acosh(x)
+
+
+@sparse.elementwise_unary
+def arcsin(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.asin(x)
+
+
+@sparse.elementwise_unary
+def arcsinh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.asinh(x)
+
+
+@sparse.elementwise_unary
+def arctan(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.atan(x)
+
+
+def arctan2(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype, float)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.math.atan2(x1, x2)
+
+
+@sparse.elementwise_unary
+def arctanh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.atanh(x)
+
+
+def _keepdims(x, y, axis):
+    if axis is None:
+        shape = [1 for _ in range(len(x.shape))]
+    else:
+        shape = list(shape_op(x))
+        for axis in tree.flatten(axis):
+            shape[axis] = 1
+    y = tf.reshape(y, shape)
+    return y
+
+
+def argmax(x, axis=None, keepdims=False):
+    _x = x
+    if axis is None:
+        x = tf.reshape(x, [-1])
+    y = tf.argmax(x, axis=axis, output_type="int32")
+    if keepdims:
+        y = _keepdims(_x, y, axis)
+    return y
+
+
+def argmin(x, axis=None, keepdims=False):
+    _x = x
+    if axis is None:
+        x = tf.reshape(x, [-1])
+    y = tf.argmin(x, axis=axis, output_type="int32")
+    if keepdims:
+        y = _keepdims(_x, y, axis)
+    return y
+
+
+def argsort(x, axis=-1):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "bool":
+        x = tf.cast(x, "uint8")
+
+    x_shape = x.shape
+    if x_shape.rank == 0:
+        return tf.cast([0], "int32")
+
+    if axis is None:
+        x = tf.reshape(x, [-1])
+        axis = 0
+    return tf.argsort(x, axis=axis)
+
+
+def array(x, dtype=None):
+    return convert_to_tensor(x, dtype=dtype)
+
+
+def average(x, axis=None, weights=None):
+    x = convert_to_tensor(x)
+
+    if weights is None:  # Treat all weights as 1
+        dtype = dtypes.result_type(x.dtype, float)
+        x = tf.cast(x, dtype)
+        avg = tf.reduce_mean(x, axis=axis)
+    else:
+        weights = convert_to_tensor(weights)
+        dtype = dtypes.result_type(x.dtype, weights.dtype, float)
+        x = tf.cast(x, dtype)
+        weights = tf.cast(weights, dtype)
+
+        def _rank_equal_case():
+            weights_sum = tf.reduce_sum(weights, axis=axis)
+            return tf.reduce_sum(x * weights, axis=axis) / weights_sum
+
+        def _rank_not_equal_case():
+            weights_sum = tf.reduce_sum(weights)
+            axes = tf.convert_to_tensor([[axis], [0]])
+            return tf.tensordot(x, weights, axes) / weights_sum
+
+        if axis is None:
+            avg = _rank_equal_case()
+        else:
+            if len(x.shape) == len(weights.shape):
+                avg = _rank_equal_case()
+            else:
+                avg = _rank_not_equal_case()
+    return avg
+
+
+def bitwise_and(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = tf.cast(x, dtype)
+    y = tf.cast(y, dtype)
+    return tf.bitwise.bitwise_and(x, y)
+
+
+def bitwise_invert(x):
+    x = convert_to_tensor(x)
+    return tf.bitwise.invert(x)
+
+
+def bitwise_not(x):
+    return bitwise_invert(x)
+
+
+def bitwise_or(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = tf.cast(x, dtype)
+    y = tf.cast(y, dtype)
+    return tf.bitwise.bitwise_or(x, y)
+
+
+def bitwise_xor(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = tf.cast(x, dtype)
+    y = tf.cast(y, dtype)
+    return tf.bitwise.bitwise_xor(x, y)
+
+
+def bitwise_left_shift(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = tf.cast(x, dtype)
+    y = tf.cast(y, dtype)
+    return tf.bitwise.left_shift(x, y)
+
+
+def left_shift(x, y):
+    return bitwise_left_shift(x, y)
+
+
+def bitwise_right_shift(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    dtype = dtypes.result_type(x.dtype, y.dtype)
+    x = tf.cast(x, dtype)
+    y = tf.cast(y, dtype)
+    return tf.bitwise.right_shift(x, y)
+
+
+def right_shift(x, y):
+    return bitwise_right_shift(x, y)
+
+
+def broadcast_to(x, shape):
+    return tf.broadcast_to(x, shape)
+
+
+@sparse.elementwise_unary
+def ceil(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.ceil(x)
+
+
+def clip(x, x_min, x_max):
+    dtype = standardize_dtype(x.dtype)
+    if dtype == "bool":
+        x = tf.cast(x, "int32")
+    return tf.clip_by_value(x, x_min, x_max)
+
+
+def concatenate(xs, axis=0):
+    sparse_count = builtins.sum(isinstance(x, tf.SparseTensor) for x in xs)
+    if sparse_count:
+        if sparse_count == len(xs):
+            return tf.sparse.concat(axis=axis, sp_inputs=xs)
+        else:
+            xs = [
+                (
+                    convert_to_tensor(x, sparse=False)
+                    if isinstance(x, tf.SparseTensor)
+                    else x
+                )
+                for x in xs
+            ]
+    xs = tree.map_structure(convert_to_tensor, xs)
+    dtype_set = set([x.dtype for x in xs])
+    if len(dtype_set) > 1:
+        dtype = dtypes.result_type(*dtype_set)
+        xs = tree.map_structure(lambda x: tf.cast(x, dtype), xs)
+    return tf.concat(xs, axis=axis)
+
+
+@sparse.elementwise_unary
+def conjugate(x):
+    return tf.math.conj(x)
+
+
+@sparse.elementwise_unary
+def conj(x):
+    return tf.math.conj(x)
+
+
+@sparse.elementwise_unary
+def copy(x):
+    x = convert_to_tensor(x)
+    return tf.identity(x)
+
+
+@sparse.densifying_unary(1)
+def cos(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.cos(x)
+
+
+@sparse.densifying_unary(1)
+def cosh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.cosh(x)
+
+
+def count_nonzero(x, axis=None):
+    return tf.math.count_nonzero(x, axis=axis, dtype="int32")
+
+
+def cross(x1, x2, axisa=-1, axisb=-1, axisc=-1, axis=None):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+
+    if axis is not None:
+        axisa = axis
+        axisb = axis
+        axisc = axis
+    x1 = moveaxis(x1, axisa, -1)
+    x2 = moveaxis(x2, axisb, -1)
+
+    def maybe_pad_zeros(x, size_of_last_dim):
+        def pad_zeros(x):
+            return tf.pad(
+                x,
+                tf.concat(
+                    [
+                        tf.zeros([tf.rank(x) - 1, 2], "int32"),
+                        tf.constant([[0, 1]], "int32"),
+                    ],
+                    axis=0,
+                ),
+            )
+
+        if isinstance(size_of_last_dim, int):
+            if size_of_last_dim == 2:
+                return pad_zeros(x)
+            return x
+
+        return tf.cond(
+            tf.equal(size_of_last_dim, 2), lambda: pad_zeros(x), lambda: x
+        )
+
+    x1_dim = shape_op(x1)[-1]
+    x2_dim = shape_op(x2)[-1]
+
+    x1 = maybe_pad_zeros(x1, x1_dim)
+    x2 = maybe_pad_zeros(x2, x2_dim)
+
+    # Broadcast each other
+    shape = shape_op(x1)
+
+    shape = tf.broadcast_dynamic_shape(shape, shape_op(x2))
+    x1 = tf.broadcast_to(x1, shape)
+    x2 = tf.broadcast_to(x2, shape)
+
+    c = tf.linalg.cross(x1, x2)
+
+    if isinstance(x1_dim, int) and isinstance(x2_dim, int):
+        if (x1_dim == 2) & (x2_dim == 2):
+            return c[..., 2]
+        return moveaxis(c, -1, axisc)
+
+    return tf.cond(
+        (x1_dim == 2) & (x2_dim == 2),
+        lambda: c[..., 2],
+        lambda: moveaxis(c, -1, axisc),
+    )
+
+
+def cumprod(x, axis=None, dtype=None):
+    x = convert_to_tensor(x, dtype=dtype)
+    # tf.math.cumprod doesn't support bool
+    if standardize_dtype(x.dtype) == "bool":
+        x = tf.cast(x, "int32")
+    if axis is None:
+        x = tf.reshape(x, [-1])
+        axis = 0
+    return tf.math.cumprod(x, axis=axis)
+
+
+def cumsum(x, axis=None, dtype=None):
+    x = convert_to_tensor(x, dtype=dtype)
+    # tf.math.cumprod doesn't support bool
+    if standardize_dtype(x.dtype) == "bool":
+        x = tf.cast(x, "int32")
+    if axis is None:
+        x = tf.reshape(x, [-1])
+        axis = 0
+    return tf.math.cumsum(x, axis=axis)
+
+
+def diag(x, k=0):
+    x = convert_to_tensor(x)
+    if len(x.shape) == 1:
+        return tf.cond(
+            tf.equal(tf.size(x), 0),
+            lambda: tf.zeros([builtins.abs(k), builtins.abs(k)], dtype=x.dtype),
+            lambda: tf.linalg.diag(x, k=k),
+        )
+    elif len(x.shape) == 2:
+        return diagonal(x, offset=k)
+    else:
+        raise ValueError(f"`x` must be 1d or 2d. Received: x.shape={x.shape}")
+
+
+def diagflat(x, k=0):
+    x = convert_to_tensor(x)
+    return diag(tf.reshape(x, [-1]), k)
+
+
+def diagonal(x, offset=0, axis1=0, axis2=1):
+    x = convert_to_tensor(x)
+    x_rank = x.ndim
+    if (
+        offset == 0
+        and (axis1 == x_rank - 2 or axis1 == -2)
+        and (axis2 == x_rank - 1 or axis2 == -1)
+    ):
+        return tf.linalg.diag_part(x)
+
+    x = moveaxis(x, (axis1, axis2), (-2, -1))
+    x_shape = shape_op(x)
+
+    def _zeros():
+        return tf.zeros(tf.concat([x_shape[:-1], [0]], 0), dtype=x.dtype)
+
+    if isinstance(x_shape[-1], int) and isinstance(x_shape[-2], int):
+        if offset <= -1 * x_shape[-2] or offset >= x_shape[-1]:
+            x = _zeros()
+    else:
+        x = tf.cond(
+            tf.logical_or(
+                tf.less_equal(offset, -1 * x_shape[-2]),
+                tf.greater_equal(offset, x_shape[-1]),
+            ),
+            lambda: _zeros(),
+            lambda: x,
+        )
+    return tf.linalg.diag_part(x, k=offset)
+
+
+def diff(a, n=1, axis=-1):
+    a = convert_to_tensor(a)
+    if n == 0:
+        return a
+    elif n < 0:
+        raise ValueError(f"Order `n` must be non-negative. Received n={n}")
+    elif a.ndim == 0:
+        raise ValueError(
+            "`diff` requires input that is at least one dimensional. "
+            f"Received: a={a}"
+        )
+    axis = canonicalize_axis(axis, a.ndim)
+    slice1 = [slice(None)] * a.ndim
+    slice2 = [slice(None)] * a.ndim
+    slice1[axis] = slice(1, None)
+    slice2[axis] = slice(None, -1)
+    slice1_tuple = tuple(slice1)
+    slice2_tuple = tuple(slice2)
+    for _ in range(n):
+        if standardize_dtype(a.dtype) == "bool":
+            a = tf.not_equal(a[slice1_tuple], a[slice2_tuple])
+        else:
+            a = tf.subtract(a[slice1_tuple], a[slice2_tuple])
+    return a
+
+
+def digitize(x, bins):
+    x = convert_to_tensor(x)
+    bins = list(bins)
+
+    # bins must be float type
+    bins = tree.map_structure(lambda x: float(x), bins)
+
+    # TODO: tf.raw_ops.Bucketize doesn't support bool, bfloat16, float16, int8
+    # int16, uint8, uint16, uint32
+    ori_dtype = standardize_dtype(x.dtype)
+    if ori_dtype in ("bool", "int8", "int16", "uint8", "uint16"):
+        x = cast(x, "int32")
+    elif ori_dtype == "uint32":
+        x = cast(x, "int64")
+    elif ori_dtype in ("bfloat16", "float16"):
+        x = cast(x, "float32")
+
+    if isinstance(x, tf.RaggedTensor):
+        return tf.ragged.map_flat_values(
+            lambda y: tf.raw_ops.Bucketize(input=y, boundaries=bins), x
+        )
+    elif isinstance(x, tf.SparseTensor):
+        output = tf.SparseTensor(
+            indices=tf.identity(x.indices),
+            values=tf.raw_ops.Bucketize(input=x.values, boundaries=bins),
+            dense_shape=tf.identity(x.dense_shape),
+        )
+        output.set_shape(x.shape)
+        return output
+    return tf.raw_ops.Bucketize(input=x, boundaries=bins)
+
+
+def dot(x, y):
+    x = convert_to_tensor(x)
+    y = convert_to_tensor(y)
+    result_dtype = dtypes.result_type(x.dtype, y.dtype)
+    # GPU only supports float types
+    compute_dtype = dtypes.result_type(result_dtype, float)
+    x = tf.cast(x, compute_dtype)
+    y = tf.cast(y, compute_dtype)
+
+    x_shape = x.shape
+    y_shape = y.shape
+    if x_shape.rank == 0 or y_shape.rank == 0:
+        output = x * y
+    elif y_shape.rank == 1:
+        output = tf.tensordot(x, y, axes=[[-1], [-1]])
+    else:
+        output = tf.tensordot(x, y, axes=[[-1], [-2]])
+    return tf.cast(output, result_dtype)
+
+
+def empty(shape, dtype=None):
+    dtype = dtype or config.floatx()
+    return tf.zeros(shape, dtype=dtype)
+
+
+def equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.equal(x1, x2)
+
+
+@sparse.densifying_unary(1)
+def exp(x):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    if "int" in ori_dtype or ori_dtype == "bool":
+        x = tf.cast(x, config.floatx())
+    return tf.exp(x)
+
+
+@sparse.densifying_unary(1)
+def exp2(x):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    if "int" in ori_dtype or ori_dtype == "bool":
+        x = tf.cast(x, config.floatx())
+    return tf.math.pow(2.0, x)
+
+
+def expand_dims(x, axis):
+    x = convert_to_tensor(x)
+    axis = to_tuple_or_list(axis)
+    out_ndim = len(x.shape) + len(axis)
+    axis = sorted([canonicalize_axis(a, out_ndim) for a in axis])
+    if isinstance(x, tf.SparseTensor):
+        from keras.src.ops.operation_utils import (
+            compute_expand_dims_output_shape,
+        )
+
+        output_shape = compute_expand_dims_output_shape(x.shape, axis)
+        for a in axis:
+            x = tf.sparse.expand_dims(x, a)
+        x.set_shape(output_shape)
+        return x
+    for a in axis:
+        x = tf.expand_dims(x, a)
+    return x
+
+
+@sparse.elementwise_unary
+def expm1(x):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    if "int" in ori_dtype or ori_dtype == "bool":
+        x = tf.cast(x, config.floatx())
+    return tf.math.expm1(x)
+
+
+def flip(x, axis=None):
+    x = convert_to_tensor(x)
+    if axis is None:
+        return tf.reverse(x, tf.range(tf.rank(x)))
+    return tf.reverse(x, [axis])
+
+
+@sparse.elementwise_unary
+def floor(x):
+    x = convert_to_tensor(x)
+    dtype = (
+        config.floatx()
+        if standardize_dtype(x.dtype) == "int64"
+        else dtypes.result_type(x.dtype, float)
+    )
+    x = tf.cast(x, dtype)
+    return tf.floor(x)
+
+
+def full(shape, fill_value, dtype=None):
+    dtype = dtype or config.floatx()
+    fill_value = convert_to_tensor(fill_value, dtype)
+    return tf.broadcast_to(fill_value, shape)
+
+
+def full_like(x, fill_value, dtype=None):
+    x = convert_to_tensor(x)
+    dtype = dtypes.result_type(dtype or x.dtype)
+    fill_value = convert_to_tensor(fill_value, dtype)
+    return tf.broadcast_to(fill_value, tf.shape(x))
+
+
+def greater(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.greater(x1, x2)
+
+
+def greater_equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.greater_equal(x1, x2)
+
+
+def hstack(xs):
+    dtype_set = set([getattr(x, "dtype", type(x)) for x in xs])
+    if len(dtype_set) > 1:
+        dtype = dtypes.result_type(*dtype_set)
+        xs = tree.map_structure(lambda x: convert_to_tensor(x, dtype), xs)
+    if len(xs[0].shape) == 1:
+        return tf.concat(xs, axis=0)
+    return tf.concat(xs, axis=1)
+
+
+def identity(n, dtype=None):
+    return eye(N=n, M=n, dtype=dtype)
+
+
+@sparse.elementwise_unary
+def imag(x):
+    return tf.math.imag(x)
+
+
+def isclose(x1, x2, rtol=1e-5, atol=1e-8, equal_nan=False):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    if "float" in dtype:
+        result = tf.abs(x1 - x2) <= (atol + rtol * tf.abs(x2))
+        if equal_nan:
+            result = result | (is_nan(x1) & is_nan(x2))
+        return result
+    else:
+        return tf.equal(x1, x2)
+
+
+@sparse.densifying_unary(True)
+def isfinite(x):
+    x = convert_to_tensor(x)
+    dtype_as_dtype = tf.as_dtype(x.dtype)
+    if dtype_as_dtype.is_integer or not dtype_as_dtype.is_numeric:
+        return tf.ones(x.shape, tf.bool)
+    return tf.math.is_finite(x)
+
+
+def isinf(x):
+    x = convert_to_tensor(x)
+    dtype_as_dtype = tf.as_dtype(x.dtype)
+    if dtype_as_dtype.is_integer or not dtype_as_dtype.is_numeric:
+        return tf.zeros(x.shape, tf.bool)
+    return tf.math.is_inf(x)
+
+
+def isnan(x):
+    x = convert_to_tensor(x)
+    dtype_as_dtype = tf.as_dtype(x.dtype)
+    if dtype_as_dtype.is_integer or not dtype_as_dtype.is_numeric:
+        return tf.zeros(x.shape, tf.bool)
+    return tf.math.is_nan(x)
+
+
+def less(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.less(x1, x2)
+
+
+def less_equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.less_equal(x1, x2)
+
+
+def linspace(
+    start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0
+):
+    if num < 0:
+        raise ValueError(
+            f"`num` must be a non-negative integer. Received: num={num}"
+        )
+    if dtype is None:
+        dtypes_to_resolve = [
+            getattr(start, "dtype", type(start)),
+            getattr(stop, "dtype", type(stop)),
+            float,
+        ]
+        dtype = dtypes.result_type(*dtypes_to_resolve)
+    else:
+        dtype = standardize_dtype(dtype)
+    start = convert_to_tensor(start, dtype=dtype)
+    stop = convert_to_tensor(stop, dtype=dtype)
+    step = convert_to_tensor(np.nan)
+    if endpoint:
+        result = tf.linspace(start, stop, num, axis=axis)
+        if num > 1:
+            step = (stop - start) / (tf.cast(num, dtype) - 1)
+    else:
+        # tf.linspace doesn't support endpoint=False, so we manually handle it
+        if num > 0:
+            step = (stop - start) / tf.cast(num, dtype)
+        if num > 1:
+            new_stop = tf.cast(stop, step.dtype) - step
+            start = tf.cast(start, new_stop.dtype)
+            result = tf.linspace(start, new_stop, num, axis=axis)
+        else:
+            result = tf.linspace(start, stop, num, axis=axis)
+    if dtype is not None:
+        if "int" in dtype:
+            result = tf.floor(result)
+        result = tf.cast(result, dtype)
+    if retstep:
+        return (result, step)
+    else:
+        return result
+
+
+@sparse.densifying_unary(-np.inf)
+def log(x):
+    x = convert_to_tensor(x)
+    dtype = (
+        config.floatx()
+        if standardize_dtype(x.dtype) == "int64"
+        else dtypes.result_type(x.dtype, float)
+    )
+    x = tf.cast(x, dtype)
+    return tf.math.log(x)
+
+
+@sparse.densifying_unary(-np.inf)
+def log10(x):
+    x = convert_to_tensor(x)
+    dtype = (
+        config.floatx()
+        if standardize_dtype(x.dtype) == "int64"
+        else dtypes.result_type(x.dtype, float)
+    )
+    x = tf.cast(x, dtype)
+    return tf.math.log(x) / tf.math.log(tf.constant(10, x.dtype))
+
+
+@sparse.elementwise_unary
+def log1p(x):
+    x = convert_to_tensor(x)
+    dtype = (
+        config.floatx()
+        if standardize_dtype(x.dtype) == "int64"
+        else dtypes.result_type(x.dtype, float)
+    )
+    x = tf.cast(x, dtype)
+    return tf.math.log1p(x)
+
+
+@sparse.densifying_unary(-np.inf)
+def log2(x):
+    x = convert_to_tensor(x)
+    dtype = (
+        config.floatx()
+        if standardize_dtype(x.dtype) == "int64"
+        else dtypes.result_type(x.dtype, float)
+    )
+    x = tf.cast(x, dtype)
+    return tf.math.log(x) / tf.math.log(tf.constant(2, x.dtype))
+
+
+def logaddexp(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype, float)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    delta = x1 - x2
+    return tf.where(
+        tf.math.is_nan(delta),
+        x1 + x2,
+        tf.maximum(x1, x2) + tf.math.log1p(tf.math.exp(-tf.abs(delta))),
+    )
+
+
+def logical_and(x1, x2):
+    x1 = tf.cast(x1, "bool")
+    x2 = tf.cast(x2, "bool")
+    return tf.logical_and(x1, x2)
+
+
+def logical_not(x):
+    x = tf.cast(x, "bool")
+    return tf.logical_not(x)
+
+
+def logical_or(x1, x2):
+    x1 = tf.cast(x1, "bool")
+    x2 = tf.cast(x2, "bool")
+    return tf.logical_or(x1, x2)
+
+
+def logspace(start, stop, num=50, endpoint=True, base=10, dtype=None, axis=0):
+    result = linspace(
+        start=start,
+        stop=stop,
+        num=num,
+        endpoint=endpoint,
+        dtype=dtype,
+        axis=axis,
+    )
+    return tf.pow(tf.cast(base, result.dtype), result)
+
+
+@sparse.elementwise_binary_union(tf.sparse.maximum, densify_mixed=True)
+def maximum(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.maximum(x1, x2)
+
+
+def median(x, axis=None, keepdims=False):
+    return quantile(x, 0.5, axis=axis, keepdims=keepdims)
+
+
+def meshgrid(*x, indexing="xy"):
+    return tf.meshgrid(*x, indexing=indexing)
+
+
+def min(x, axis=None, keepdims=False, initial=None):
+    x = convert_to_tensor(x)
+
+    # The TensorFlow numpy API implementation doesn't support `initial` so we
+    # handle it manually here.
+    if initial is not None:
+        if standardize_dtype(x.dtype) == "bool":
+            x = tf.reduce_all(x, axis=axis, keepdims=keepdims)
+            x = tf.math.minimum(tf.cast(x, "int32"), tf.cast(initial, "int32"))
+            return tf.cast(x, "bool")
+        else:
+            x = tf.reduce_min(x, axis=axis, keepdims=keepdims)
+        return tf.math.minimum(x, initial)
+
+    # TensorFlow returns inf by default for an empty list, but for consistency
+    # with other backends and the numpy API we want to throw in this case.
+    if tf.executing_eagerly():
+        size_x = size(x)
+        tf.assert_greater(
+            size_x,
+            tf.constant(0, dtype=size_x.dtype),
+            message="Cannot compute the min of an empty tensor.",
+        )
+
+    if standardize_dtype(x.dtype) == "bool":
+        return tf.reduce_all(x, axis=axis, keepdims=keepdims)
+    else:
+        return tf.reduce_min(x, axis=axis, keepdims=keepdims)
+
+
+@sparse.elementwise_binary_union(tf.sparse.minimum, densify_mixed=True)
+def minimum(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.minimum(x1, x2)
+
+
+def mod(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    if dtype == "bool":
+        dtype = "int32"
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.math.mod(x1, x2)
+
+
+def moveaxis(x, source, destination):
+    x = convert_to_tensor(x)
+
+    _source = to_tuple_or_list(source)
+    _destination = to_tuple_or_list(destination)
+    _source = tuple(canonicalize_axis(i, x.ndim) for i in _source)
+    _destination = tuple(canonicalize_axis(i, x.ndim) for i in _destination)
+    if len(_source) != len(_destination):
+        raise ValueError(
+            "Inconsistent number of `source` and `destination`. "
+            f"Received: source={source}, destination={destination}"
+        )
+    # Directly return x if no movement is required
+    if _source == _destination:
+        return x
+    perm = [i for i in range(x.ndim) if i not in _source]
+    for dest, src in sorted(zip(_destination, _source)):
+        perm.insert(dest, src)
+    return tf.transpose(x, perm)
+
+
+def nan_to_num(x, nan=0.0, posinf=None, neginf=None):
+    x = convert_to_tensor(x)
+
+    dtype = x.dtype
+    dtype_as_dtype = tf.as_dtype(dtype)
+    if dtype_as_dtype.is_integer or not dtype_as_dtype.is_numeric:
+        return x
+
+    # Replace NaN with `nan`
+    x = tf.where(tf.math.is_nan(x), tf.constant(nan, dtype), x)
+
+    # Replace positive infinity with `posinf` or `dtype.max`
+    if posinf is None:
+        posinf = dtype.max
+    x = tf.where(tf.math.is_inf(x) & (x > 0), tf.constant(posinf, dtype), x)
+
+    # Replace negative infinity with `neginf` or `dtype.min`
+    if neginf is None:
+        neginf = dtype.min
+    x = tf.where(tf.math.is_inf(x) & (x < 0), tf.constant(neginf, dtype), x)
+
+    return x
+
+
+def ndim(x):
+    x = convert_to_tensor(x)
+    return x.ndim
+
+
+def nonzero(x):
+    x = convert_to_tensor(x)
+    result = tf.unstack(tf.where(tf.cast(x, "bool")), x.shape.rank, axis=1)
+    return tree.map_structure(lambda indices: tf.cast(indices, "int32"), result)
+
+
+def not_equal(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.not_equal(x1, x2)
+
+
+def ones_like(x, dtype=None):
+    return tf.ones_like(x, dtype=dtype)
+
+
+def zeros_like(x, dtype=None):
+    return tf.zeros_like(x, dtype=dtype)
+
+
+def outer(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+    return tf.reshape(x1, [-1, 1]) * tf.reshape(x2, [-1])
+
+
+def pad(x, pad_width, mode="constant", constant_values=None):
+    x = convert_to_tensor(x)
+    kwargs = {}
+    if constant_values is not None:
+        if mode != "constant":
+            raise ValueError(
+                "Argument `constant_values` can only be "
+                "provided when `mode == 'constant'`. "
+                f"Received: mode={mode}"
+            )
+        kwargs["constant_values"] = constant_values
+    pad_width = convert_to_tensor(pad_width, "int32")
+    return tf.pad(x, pad_width, mode.upper(), **kwargs)
+
+
+def prod(x, axis=None, keepdims=False, dtype=None):
+    x = convert_to_tensor(x)
+    if dtype is None:
+        dtype = dtypes.result_type(x.dtype)
+        if dtype == "bool":
+            dtype = "int32"
+        elif dtype in ("int8", "int16"):
+            dtype = "int32"
+        elif dtype in ("uint8", "uint16"):
+            dtype = "uint32"
+        x = tf.cast(x, dtype)
+    return tf.reduce_prod(x, axis=axis, keepdims=keepdims)
+
+
+def _quantile(x, q, axis=None, method="linear", keepdims=False):
+    # ref: tfp.stats.percentile
+    # float64 is needed here and below, else we get the wrong index if the array
+    # is huge along axis.
+    q = tf.cast(q, "float64")
+
+    # Move `axis` dims of `x` to the rightmost, call it `y`.
+    if axis is None:
+        y = tf.reshape(x, [-1])
+    else:
+        x_ndims = len(x.shape)
+        # _make_static_axis_non_negative_list
+        axis = [canonicalize_axis(a, x_ndims) for a in axis]
+
+        # _move_dims_to_flat_end
+        other_dims = sorted(set(range(x_ndims)).difference(axis))
+        perm = other_dims + list(axis)
+        x_permed = tf.transpose(a=x, perm=perm)
+        if None not in x.shape:
+            x_shape = list(x.shape)
+            other_shape = [x_shape[i] for i in other_dims]
+            end_shape = [math.prod([x_shape[i] for i in axis])]
+            full_shape = other_shape + end_shape
+        else:
+            other_shape = tf.gather(tf.shape(x), tf.cast(other_dims, tf.int64))
+            full_shape = tf.concat([other_shape, [-1]], axis=0)
+        y = tf.reshape(x_permed, shape=full_shape)
+
+    # Sort (in ascending order) everything which allows multiple calls to sort
+    # only once (under the hood) and use CSE.
+    sorted_y = tf.sort(y, axis=-1, direction="ASCENDING")
+
+    d = tf.cast(tf.shape(y)[-1], "float64")
+
+    def _get_indices(method):
+        """Get values of y at the indices implied by method."""
+        if method == "lower":
+            indices = tf.math.floor((d - 1) * q)
+        elif method == "higher":
+            indices = tf.math.ceil((d - 1) * q)
+        elif method == "nearest":
+            indices = tf.round((d - 1) * q)
+        # d - 1 will be distinct from d in int32, but not necessarily double.
+        # So clip to avoid out of bounds errors.
+        return tf.clip_by_value(
+            tf.cast(indices, "int32"), 0, tf.shape(y)[-1] - 1
+        )
+
+    if method in ["nearest", "lower", "higher"]:
+        gathered_y = tf.gather(sorted_y, _get_indices(method), axis=-1)
+    elif method == "midpoint":
+        gathered_y = 0.5 * (
+            tf.gather(sorted_y, _get_indices("lower"), axis=-1)
+            + tf.gather(sorted_y, _get_indices("higher"), axis=-1)
+        )
+    elif method == "linear":
+        larger_y_idx = _get_indices("higher")
+        exact_idx = (d - 1) * q
+        # preserve_gradients
+        smaller_y_idx = tf.maximum(larger_y_idx - 1, 0)
+        larger_y_idx = tf.minimum(smaller_y_idx + 1, tf.shape(y)[-1] - 1)
+        fraction = tf.cast(larger_y_idx, tf.float64) - exact_idx
+        fraction = tf.cast(fraction, y.dtype)
+        gathered_y = (
+            tf.gather(sorted_y, larger_y_idx, axis=-1) * (1 - fraction)
+            + tf.gather(sorted_y, smaller_y_idx, axis=-1) * fraction
+        )
+
+    # Propagate NaNs
+    if x.dtype in (tf.bfloat16, tf.float16, tf.float32, tf.float64):
+        # Apparently tf.is_nan doesn't like other dtypes
+        nan_batch_members = tf.reduce_any(tf.math.is_nan(x), axis=axis)
+        right_rank_matched_shape = tf.pad(
+            tf.shape(nan_batch_members),
+            paddings=[[0, tf.rank(q)]],
+            constant_values=1,
+        )
+        nan_batch_members = tf.reshape(
+            nan_batch_members, shape=right_rank_matched_shape
+        )
+        nan_value = tf.constant(float("NaN"), dtype=x.dtype)
+        gathered_y = tf.where(nan_batch_members, nan_value, gathered_y)
+
+    # Expand dimensions if requested
+    if keepdims:
+        if axis is None:
+            ones_vec = tf.ones(shape=[tf.rank(x) + tf.rank(q)], dtype="int32")
+            gathered_y *= tf.ones(ones_vec, dtype=gathered_y.dtype)
+        else:
+            for i in sorted(axis):
+                gathered_y = tf.expand_dims(gathered_y, axis=i)
+
+    # rotate_transpose
+    shift_value_static = tf.get_static_value(tf.rank(q))
+    ndims = tf.TensorShape(gathered_y.shape).rank
+    if ndims < 2:
+        return gathered_y
+    shift_value_static = int(
+        math.copysign(1, shift_value_static)
+        * (builtins.abs(shift_value_static) % ndims)
+    )
+    if shift_value_static == 0:
+        return gathered_y
+    perm = collections.deque(range(ndims))
+    perm.rotate(shift_value_static)
+    return tf.transpose(a=gathered_y, perm=perm)
+
+
+def quantile(x, q, axis=None, method="linear", keepdims=False):
+    x = convert_to_tensor(x)
+    q = convert_to_tensor(q)
+    axis = to_tuple_or_list(axis)
+    compute_dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, compute_dtype)
+    return _quantile(x, q, axis=axis, method=method, keepdims=keepdims)
+
+
+def ravel(x):
+    x = convert_to_tensor(x)
+    return tf.reshape(x, [-1])
+
+
+def unravel_index(x, shape):
+    x = tf.convert_to_tensor(x)
+    input_dtype = x.dtype
+
+    if None in shape:
+        raise ValueError(
+            "`shape` argument cannot contain `None`. Received: shape={shape}"
+        )
+
+    if x.ndim == 1:
+        coords = []
+        for dim in reversed(shape):
+            coords.append(tf.cast(x % dim, input_dtype))
+            x = x // dim
+        return tuple(reversed(coords))
+
+    x_shape = x.shape
+    coords = []
+    for dim in shape:
+        coords.append(tf.reshape(tf.cast(x % dim, input_dtype), x_shape))
+        x = x // dim
+
+    return tuple(reversed(coords))
+
+
+@sparse.elementwise_unary
+def real(x):
+    x = convert_to_tensor(x)
+    return tf.math.real(x)
+
+
+@sparse.densifying_unary(np.inf)
+def reciprocal(x):
+    x = convert_to_tensor(x)
+    return tf.math.reciprocal(x)
+
+
+def repeat(x, repeats, axis=None):
+    x = convert_to_tensor(x)
+    # TODO: tf.repeat doesn't support uint16
+    if standardize_dtype(x.dtype) == "uint16":
+        x = tf.cast(x, "uint32")
+        return tf.cast(tf.repeat(x, repeats, axis=axis), "uint16")
+    return tf.repeat(x, repeats, axis=axis)
+
+
+def reshape(x, newshape):
+    x = convert_to_tensor(x)
+    if isinstance(x, tf.SparseTensor):
+        from keras.src.ops.operation_utils import compute_reshape_output_shape
+
+        output_shape = compute_reshape_output_shape(
+            x.shape, newshape, "newshape"
+        )
+        output = tf.sparse.reshape(x, newshape)
+        output.set_shape(output_shape)
+        return output
+    return tf.reshape(x, newshape)
+
+
+def roll(x, shift, axis=None):
+    x = convert_to_tensor(x)
+    if axis is not None:
+        return tf.roll(x, shift=shift, axis=axis)
+
+    # If axis is None, the roll happens as a 1-d tensor.
+    original_shape = tf.shape(x)
+    x = tf.roll(tf.reshape(x, [-1]), shift, 0)
+    return tf.reshape(x, original_shape)
+
+
+def searchsorted(sorted_sequence, values, side="left"):
+    if ndim(sorted_sequence) != 1:
+        raise ValueError(
+            "`searchsorted` only supports 1-D sorted sequences. "
+            "You can use `keras.ops.vectorized_map` "
+            "to extend it to N-D sequences. Received: "
+            f"sorted_sequence.shape={sorted_sequence.shape}"
+        )
+    out_type = (
+        "int32" if len(sorted_sequence) <= np.iinfo(np.int32).max else "int64"
+    )
+    return tf.searchsorted(
+        sorted_sequence, values, side=side, out_type=out_type
+    )
+
+
+@sparse.elementwise_unary
+def sign(x):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    # TODO: tf.sign doesn't support uint8, uint16, uint32
+    if ori_dtype in ("uint8", "uint16", "uint32"):
+        x = tf.cast(x, "int32")
+        return tf.cast(tf.sign(x), ori_dtype)
+    return tf.sign(x)
+
+
+@sparse.elementwise_unary
+def sin(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.sin(x)
+
+
+@sparse.elementwise_unary
+def sinh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.sinh(x)
+
+
+def size(x):
+    x = convert_to_tensor(x)
+    return tf.size(x)
+
+
+def sort(x, axis=-1):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    # TODO: tf.sort doesn't support bool
+    if ori_dtype == "bool":
+        x = tf.cast(x, "int8")
+        return tf.cast(tf.sort(x, axis=axis), ori_dtype)
+    return tf.sort(x, axis=axis)
+
+
+def split(x, indices_or_sections, axis=0):
+    if not isinstance(indices_or_sections, int):
+        # `tf.split` requires `num_or_size_splits`, so we need to convert
+        # `indices_or_sections` to the appropriate format.
+        total_size = x.shape[axis]
+        indices_or_sections = convert_to_tensor(indices_or_sections)
+        start_size = indices_or_sections[0:1]
+        end_size = total_size - indices_or_sections[-1:]
+        num_or_size_splits = tf.concat(
+            [start_size, diff(indices_or_sections), end_size], axis=0
+        )
+    else:
+        num_or_size_splits = indices_or_sections
+    return tf.split(x, num_or_size_splits, axis=axis)
+
+
+def stack(x, axis=0):
+    dtype_set = set([getattr(a, "dtype", type(a)) for a in x])
+    if len(dtype_set) > 1:
+        dtype = dtypes.result_type(*dtype_set)
+        x = tree.map_structure(lambda a: convert_to_tensor(a, dtype), x)
+    return tf.stack(x, axis=axis)
+
+
+def std(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    ori_dtype = standardize_dtype(x.dtype)
+    if "int" in ori_dtype or ori_dtype == "bool":
+        x = tf.cast(x, config.floatx())
+    return tf.math.reduce_std(x, axis=axis, keepdims=keepdims)
+
+
+def swapaxes(x, axis1, axis2):
+    x = convert_to_tensor(x)
+
+    if (
+        x.shape.rank is not None
+        and isinstance(axis1, int)
+        and isinstance(axis2, int)
+    ):
+        # This branch makes sure `perm` is statically known, to avoid a
+        # not-compile-time-constant XLA error.
+        axis1 = canonicalize_axis(axis1, x.ndim)
+        axis2 = canonicalize_axis(axis2, x.ndim)
+
+        # Directly return x if no movement is required
+        if axis1 == axis2:
+            return x
+
+        perm = list(range(x.ndim))
+        perm[axis1] = axis2
+        perm[axis2] = axis1
+    else:
+        x_rank = tf.rank(x)
+        axis1 = tf.where(axis1 < 0, tf.add(axis1, x_rank), axis1)
+        axis2 = tf.where(axis2 < 0, tf.add(axis2, x_rank), axis2)
+        perm = tf.range(x_rank)
+        perm = tf.tensor_scatter_nd_update(
+            perm, [[axis1], [axis2]], [axis2, axis1]
+        )
+    return tf.transpose(x, perm)
+
+
+def take(x, indices, axis=None):
+    if isinstance(indices, tf.SparseTensor):
+        if x.dtype not in (tf.float16, tf.float32, tf.float64, tf.bfloat16):
+            warnings.warn(
+                "`take` with the TensorFlow backend does not support "
+                f"`x.dtype={x.dtype}` when `indices` is a sparse tensor; "
+                "densifying `indices`."
+            )
+            return take(x, convert_to_tensor(indices, sparse=False), axis=axis)
+        if axis is None:
+            x = tf.reshape(x, (-1,))
+        elif axis != 0:
+            warnings.warn(
+                "`take` with the TensorFlow backend does not support "
+                f"`axis={axis}` when `indices` is a sparse tensor; "
+                "densifying `indices`."
+            )
+            return take(x, convert_to_tensor(indices, sparse=False), axis=axis)
+        output = tf.nn.safe_embedding_lookup_sparse(
+            embedding_weights=tf.convert_to_tensor(x),
+            sparse_ids=tf.sparse.expand_dims(indices, axis=-1),
+            default_id=0,
+        )
+        output.set_shape(indices.shape + output.shape[len(indices.shape) :])
+        return output
+
+    x = convert_to_tensor(x)
+    indices = convert_to_tensor(indices)
+    if axis is None:
+        x = tf.reshape(x, [-1])
+        axis = 0
+    # Correct the indices using "fill" mode which is the same as in jax
+    indices = tf.where(
+        indices < 0,
+        indices + tf.cast(tf.shape(x)[axis], indices.dtype),
+        indices,
+    )
+    return tf.gather(x, indices, axis=axis)
+
+
+def take_along_axis(x, indices, axis=None):
+    from keras.src.ops.operation_utils import (
+        compute_take_along_axis_output_shape,
+    )
+
+    x = convert_to_tensor(x)
+    indices = convert_to_tensor(indices, "int64")
+    if axis is None:
+        if indices.ndim != 1:
+            raise ValueError(
+                "`indices` must be 1D if axis=None. "
+                f"Received: indices.shape={indices.shape}"
+            )
+        return take_along_axis(tf.reshape(x, [-1]), indices, 0)
+
+    # Compute the static output shape as later on, all shapes manipulations
+    # use dynamic shapes.
+    static_output_shape = compute_take_along_axis_output_shape(
+        x.shape, indices.shape, axis
+    )
+    rank = x.ndim
+    static_axis = axis
+    axis = axis + rank if axis < 0 else axis
+
+    # Broadcast shapes to match, ensure that the axis of interest is not
+    # broadcast.
+    x_shape_original = tf.shape(x, out_type=indices.dtype)
+    indices_shape_original = tf.shape(indices, out_type=indices.dtype)
+    x_shape = tf.tensor_scatter_nd_update(x_shape_original, [[axis]], [1])
+    indices_shape = tf.tensor_scatter_nd_update(
+        indices_shape_original, [[axis]], [1]
+    )
+    broadcasted_shape = tf.broadcast_dynamic_shape(x_shape, indices_shape)
+    x_shape = tf.tensor_scatter_nd_update(
+        broadcasted_shape, [[axis]], [x_shape_original[axis]]
+    )
+    indices_shape = tf.tensor_scatter_nd_update(
+        broadcasted_shape, [[axis]], [indices_shape_original[axis]]
+    )
+    x = tf.broadcast_to(x, x_shape)
+    indices = tf.broadcast_to(indices, indices_shape)
+
+    # Correct the indices using "fill" mode which is the same as in jax
+    indices = tf.where(indices < 0, indices + x_shape[static_axis], indices)
+
+    x = swapaxes(x, static_axis, -1)
+    indices = swapaxes(indices, static_axis, -1)
+
+    x_shape = tf.shape(x)
+    x = tf.reshape(x, [-1, x_shape[-1]])
+    indices_shape = tf.shape(indices)
+    indices = tf.reshape(indices, [-1, indices_shape[-1]])
+
+    result = tf.gather(x, indices, batch_dims=1)
+    result = tf.reshape(result, indices_shape)
+    result = swapaxes(result, static_axis, -1)
+    result.set_shape(static_output_shape)
+    return result
+
+
+@sparse.elementwise_unary
+def tan(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.tan(x)
+
+
+@sparse.elementwise_unary
+def tanh(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "int64":
+        dtype = config.floatx()
+    else:
+        dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, dtype)
+    return tf.math.tanh(x)
+
+
+def tensordot(x1, x2, axes=2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    result_dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    # TODO: tf.tensordot only supports float types
+    compute_dtype = dtypes.result_type(result_dtype, float)
+    x1 = tf.cast(x1, compute_dtype)
+    x2 = tf.cast(x2, compute_dtype)
+    return tf.cast(tf.tensordot(x1, x2, axes=axes), dtype=result_dtype)
+
+
+@sparse.elementwise_unary
+def round(x, decimals=0):
+    if decimals == 0:
+        return tf.round(x)
+    x_dtype = x.dtype
+    if tf.as_dtype(x_dtype).is_integer:
+        # int
+        if decimals > 0:
+            return x
+        # temporarily convert to floats
+        factor = tf.cast(math.pow(10, decimals), config.floatx())
+        x = tf.cast(x, config.floatx())
+    else:
+        # float
+        factor = tf.cast(math.pow(10, decimals), x.dtype)
+    x = tf.multiply(x, factor)
+    x = tf.round(x)
+    x = tf.divide(x, factor)
+    return tf.cast(x, x_dtype)
+
+
+def tile(x, repeats):
+    x = convert_to_tensor(x)
+    repeats = tf.reshape(convert_to_tensor(repeats, dtype="int32"), [-1])
+    repeats_size = tf.size(repeats)
+    repeats = tf.pad(
+        repeats,
+        [[tf.maximum(x.shape.rank - repeats_size, 0), 0]],
+        constant_values=1,
+    )
+    x_shape = tf.pad(
+        tf.shape(x),
+        [[tf.maximum(repeats_size - x.shape.rank, 0), 0]],
+        constant_values=1,
+    )
+    x = tf.reshape(x, x_shape)
+    return tf.tile(x, repeats)
+
+
+def trace(x, offset=0, axis1=0, axis2=1):
+    x = convert_to_tensor(x)
+    dtype = standardize_dtype(x.dtype)
+    if dtype not in ("int64", "uint32", "uint64"):
+        dtype = dtypes.result_type(dtype, "int32")
+    x_shape = tf.shape(x)
+    x = moveaxis(x, (axis1, axis2), (-2, -1))
+    # Mask out the diagonal and reduce.
+    x = tf.where(
+        eye(x_shape[axis1], x_shape[axis2], k=offset, dtype="bool"),
+        x,
+        tf.zeros_like(x),
+    )
+    # The output dtype is set to "int32" if the input dtype is "bool"
+    if standardize_dtype(x.dtype) == "bool":
+        x = tf.cast(x, "int32")
+    return tf.cast(tf.reduce_sum(x, axis=(-2, -1)), dtype)
+
+
+def tri(N, M=None, k=0, dtype=None):
+    M = M if M is not None else N
+    dtype = standardize_dtype(dtype or config.floatx())
+    if k < 0:
+        lower = -k - 1
+        if lower > N:
+            r = tf.zeros([N, M], dtype=dtype)
+        else:
+            o = tf.ones([N, M], dtype="bool")
+            r = tf.cast(
+                tf.logical_not(tf.linalg.band_part(o, lower, -1)), dtype=dtype
+            )
+    else:
+        o = tf.ones([N, M], dtype=dtype)
+        if k > M:
+            r = o
+        else:
+            r = tf.linalg.band_part(o, -1, k)
+    return r
+
+
+def tril(x, k=0):
+    x = convert_to_tensor(x)
+
+    def _negative_k_branch():
+        shape = tf.shape(x)
+        rows, cols = shape[-2], shape[-1]
+        i, j = tf.meshgrid(tf.range(rows), tf.range(cols), indexing="ij")
+        mask = i >= j - k
+        return tf.where(tf.broadcast_to(mask, shape), x, tf.zeros_like(x))
+
+    return tf.cond(
+        k >= 0, lambda: tf.linalg.band_part(x, -1, k), _negative_k_branch
+    )
+
+
+def triu(x, k=0):
+    x = convert_to_tensor(x)
+
+    def _positive_k_branch():
+        shape = tf.shape(x)
+        rows, cols = shape[-2], shape[-1]
+        i, j = tf.meshgrid(tf.range(rows), tf.range(cols), indexing="ij")
+        mask = i <= j - k
+        return tf.where(tf.broadcast_to(mask, shape), x, tf.zeros_like(x))
+
+    return tf.cond(
+        k <= 0, lambda: tf.linalg.band_part(x, -k, -1), _positive_k_branch
+    )
+
+
+def trunc(x):
+    x = convert_to_tensor(x)
+    dtype = standardize_dtype(x.dtype)
+    if dtype == "bool" or "int" in dtype:
+        return x
+    return tf.where(x < 0, tf.math.ceil(x), tf.math.floor(x))
+
+
+def vdot(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    result_dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    compute_dtype = dtypes.result_type(result_dtype, float)
+    x1 = tf.cast(x1, compute_dtype)
+    x2 = tf.cast(x2, compute_dtype)
+    x1 = tf.reshape(x1, [-1])
+    x2 = tf.reshape(x2, [-1])
+    return tf.cast(dot(x1, x2), result_dtype)
+
+
+def inner(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    result_dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    compute_dtype = dtypes.result_type(result_dtype, float)
+    x1 = tf.cast(x1, compute_dtype)
+    x2 = tf.cast(x2, compute_dtype)
+    x = tf.cond(
+        tf.math.logical_or(
+            tf.math.equal(tf.rank(x1), 0),
+            tf.math.equal(tf.rank(x2), 0),
+        ),
+        lambda: x1 * x2,
+        lambda: tf.tensordot(x1, x2, axes=[[-1], [-1]]),
+    )
+    return tf.cast(x, result_dtype)
+
+
+def vstack(xs):
+    dtype_set = set([getattr(x, "dtype", type(x)) for x in xs])
+    if len(dtype_set) > 1:
+        dtype = dtypes.result_type(*dtype_set)
+        xs = tree.map_structure(lambda x: convert_to_tensor(x, dtype), xs)
+    return tf.concat(xs, axis=0)
+
+
+def _vmap_fn(fn, in_axes=0):
+    if in_axes != 0:
+        raise ValueError(
+            "Not supported with `vectorize()` with the TensorFlow backend."
+        )
+
+    @functools.wraps(fn)
+    def wrapped(x):
+        return tf.vectorized_map(fn, x)
+
+    return wrapped
+
+
+def vectorize(pyfunc, *, excluded=None, signature=None):
+    return vectorize_impl(
+        pyfunc, _vmap_fn, excluded=excluded, signature=signature
+    )
+
+
+def where(condition, x1, x2):
+    condition = tf.cast(condition, "bool")
+    if x1 is not None and x2 is not None:
+        if not isinstance(x1, (int, float)):
+            x1 = convert_to_tensor(x1)
+        if not isinstance(x2, (int, float)):
+            x2 = convert_to_tensor(x2)
+        dtype = dtypes.result_type(
+            getattr(x1, "dtype", type(x1)),
+            getattr(x2, "dtype", type(x2)),
+        )
+        x1 = convert_to_tensor(x1, dtype)
+        x2 = convert_to_tensor(x2, dtype)
+        return tf.where(condition, x1, x2)
+    if x1 is None and x2 is None:
+        return nonzero(condition)
+    raise ValueError(
+        "`x1` and `x2` either both should be `None`"
+        " or both should have non-None value."
+    )
+
+
+@sparse.elementwise_division
+def divide(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+        float,
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.divide(x1, x2)
+
+
+def divide_no_nan(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+        float,
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.math.divide_no_nan(x1, x2)
+
+
+def true_divide(x1, x2):
+    return divide(x1, x2)
+
+
+def power(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    # TODO: tf.pow doesn't support uint* types
+    if "uint" in dtype:
+        x1 = convert_to_tensor(x1, "int32")
+        x2 = convert_to_tensor(x2, "int32")
+        return tf.cast(tf.pow(x1, x2), dtype)
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.pow(x1, x2)
+
+
+@sparse.elementwise_unary
+def negative(x):
+    return tf.negative(x)
+
+
+@sparse.elementwise_unary
+def square(x):
+    x = convert_to_tensor(x)
+    if standardize_dtype(x.dtype) == "bool":
+        x = tf.cast(x, "int32")
+    return tf.square(x)
+
+
+@sparse.elementwise_unary
+def sqrt(x):
+    x = convert_to_tensor(x)
+    dtype = (
+        config.floatx()
+        if standardize_dtype(x.dtype) == "int64"
+        else dtypes.result_type(x.dtype, float)
+    )
+    x = tf.cast(x, dtype)
+    return tf.math.sqrt(x)
+
+
+def squeeze(x, axis=None):
+    x = convert_to_tensor(x)
+    axis = to_tuple_or_list(axis)
+    static_shape = x.shape.as_list()
+    if axis is not None:
+        for a in axis:
+            if static_shape[a] != 1:
+                raise ValueError(
+                    f"Cannot squeeze axis={a}, because the "
+                    "dimension is not 1."
+                )
+        axis = sorted([canonicalize_axis(a, len(static_shape)) for a in axis])
+    if isinstance(x, tf.SparseTensor):
+        dynamic_shape = tf.shape(x)
+        new_shape = []
+        gather_indices = []
+        for i, dim in enumerate(static_shape):
+            if not (dim == 1 if axis is None else i in axis):
+                new_shape.append(dim if dim is not None else dynamic_shape[i])
+                gather_indices.append(i)
+        new_indices = tf.gather(x.indices, gather_indices, axis=1)
+        return tf.SparseTensor(new_indices, x.values, tuple(new_shape))
+    return tf.squeeze(x, axis=axis)
+
+
+def transpose(x, axes=None):
+    if isinstance(x, tf.SparseTensor):
+        from keras.src.ops.operation_utils import compute_transpose_output_shape
+
+        output = tf.sparse.transpose(x, perm=axes)
+        output.set_shape(compute_transpose_output_shape(x.shape, axes))
+        return output
+    return tf.transpose(x, perm=axes)
+
+
+def var(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    compute_dtype = dtypes.result_type(x.dtype, "float32")
+    result_dtype = dtypes.result_type(x.dtype, float)
+    x = tf.cast(x, compute_dtype)
+    return tf.cast(
+        tf.math.reduce_variance(x, axis=axis, keepdims=keepdims),
+        result_dtype,
+    )
+
+
+def sum(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    dtype = standardize_dtype(x.dtype)
+    # follow jax's rule
+    if dtype in ("bool", "int8", "int16"):
+        dtype = "int32"
+    elif dtype in ("uint8", "uint16"):
+        dtype = "uint32"
+    x = cast(x, dtype)
+    if isinstance(x, tf.SparseTensor):
+        return tf.sparse.reduce_sum(
+            x, axis=axis, keepdims=keepdims, output_is_sparse=True
+        )
+    return tf.reduce_sum(x, axis=axis, keepdims=keepdims)
+
+
+def eye(N, M=None, k=0, dtype=None):
+    dtype = dtype or config.floatx()
+    M = N if M is None else M
+    if isinstance(k, int) and k == 0:
+        return tf.eye(N, M, dtype=dtype)
+    # Create a smaller square eye and pad appropriately.
+    return tf.pad(
+        tf.eye(tf.minimum(M - k, N + k), dtype=dtype),
+        paddings=(
+            (tf.maximum(-k, 0), tf.maximum(N - M + k, 0)),
+            (tf.maximum(k, 0), tf.maximum(M - N - k, 0)),
+        ),
+    )
+
+
+def floor_divide(x1, x2):
+    if not isinstance(x1, (int, float)):
+        x1 = convert_to_tensor(x1)
+    if not isinstance(x2, (int, float)):
+        x2 = convert_to_tensor(x2)
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    x1 = convert_to_tensor(x1, dtype)
+    x2 = convert_to_tensor(x2, dtype)
+    return tf.math.floordiv(x1, x2)
+
+
+def logical_xor(x1, x2):
+    x1 = tf.cast(x1, "bool")
+    x2 = tf.cast(x2, "bool")
+    return tf.math.logical_xor(x1, x2)
+
+
+def correlate(x1, x2, mode="valid"):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+
+    dtype = dtypes.result_type(
+        getattr(x1, "dtype", type(x1)),
+        getattr(x2, "dtype", type(x2)),
+    )
+    if dtype == tf.int64:
+        dtype = tf.float64
+    elif dtype not in [tf.bfloat16, tf.float16, tf.float64]:
+        dtype = tf.float32
+
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+
+    x1_len, x2_len = int(x1.shape[0]), int(x2.shape[0])
+
+    if mode == "full":
+        full_len = x1_len + x2_len - 1
+
+        x1_pad = (full_len - x1_len) / 2
+        x2_pad = (full_len - x2_len) / 2
+
+        x1 = tf.pad(
+            x1, paddings=[[tf.math.floor(x1_pad), tf.math.ceil(x1_pad)]]
+        )
+        x2 = tf.pad(
+            x2, paddings=[[tf.math.floor(x2_pad), tf.math.ceil(x2_pad)]]
+        )
+
+        x1 = tf.reshape(x1, (1, full_len, 1))
+        x2 = tf.reshape(x2, (full_len, 1, 1))
+
+        return tf.squeeze(tf.nn.conv1d(x1, x2, stride=1, padding="SAME"))
+
+    x1 = tf.reshape(x1, (1, x1_len, 1))
+    x2 = tf.reshape(x2, (x2_len, 1, 1))
+
+    return tf.squeeze(tf.nn.conv1d(x1, x2, stride=1, padding=mode.upper()))
+
+
+def select(condlist, choicelist, default=0):
+    return tf.experimental.numpy.select(condlist, choicelist, default=default)
+
+
+def slogdet(x):
+    x = convert_to_tensor(x)
+    return tuple(tf.linalg.slogdet(x))
+
+
+def argpartition(x, kth, axis=-1):
+    x = convert_to_tensor(x, tf.int32)
+
+    x = swapaxes(x, axis, -1)
+    bottom_ind = tf.math.top_k(-x, kth + 1).indices
+
+    n = tf.shape(x)[-1]
+
+    mask = tf.reduce_sum(tf.one_hot(bottom_ind, n, dtype=tf.int32), axis=0)
+
+    indices = tf.where(mask)
+    updates = tf.squeeze(tf.zeros(tf.shape(indices)[0], dtype=tf.int32))
+
+    final_mask = tf.tensor_scatter_nd_update(x, indices, updates)
+
+    top_ind = tf.math.top_k(final_mask, tf.shape(x)[-1] - kth - 1).indices
+
+    out = tf.concat([bottom_ind, top_ind], axis=x.ndim - 1)
+    return swapaxes(out, -1, axis)
+
+
+def histogram(x, bins, range):
+    """Computes a histogram of the data tensor `x`.
+
+    Note: the `tf.histogram_fixed_width()` and
+    `tf.histogram_fixed_width_bins()` functions
+    yield slight numerical differences for some edge cases.
+    """
+
+    x = tf.convert_to_tensor(x, dtype=x.dtype)
+
+    # Handle the range argument
+    if range is None:
+        min_val = tf.reduce_min(x)
+        max_val = tf.reduce_max(x)
+    else:
+        min_val, max_val = range
+
+    x = tf.boolean_mask(x, (x >= min_val) & (x <= max_val))
+    bin_edges = tf.linspace(min_val, max_val, bins + 1)
+    bin_edges_list = bin_edges.numpy().tolist()
+    bin_indices = tf.raw_ops.Bucketize(input=x, boundaries=bin_edges_list[1:-1])
+
+    bin_counts = tf.math.bincount(
+        bin_indices, minlength=bins, maxlength=bins, dtype=x.dtype
+    )
+    return bin_counts, bin_edges