keras-nightly 3.14.0.dev2026013104__tar.gz → 3.14.0.dev2026020304__tar.gz

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keras-nightly
-Version: 3.14.0.dev2026013104
+Version: 3.14.0.dev2026020304
 Summary: Multi-backend Keras
 Author-email: Keras team <keras-users@googlegroups.com>
 License: Apache License 2.0

{keras_nightly-3.14.0.dev2026013104/keras/api → keras_nightly-3.14.0.dev2026020304/keras/api/_tf_keras/keras}/ops/__init__.py

@@ -248,6 +248,7 @@ from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
 from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
+from keras.src.ops.numpy import nanprod as nanprod
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

{keras_nightly-3.14.0.dev2026013104/keras/api → keras_nightly-3.14.0.dev2026020304/keras/api/_tf_keras/keras}/ops/numpy/__init__.py

@@ -132,6 +132,7 @@ from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
 from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
+from keras.src.ops.numpy import nanprod as nanprod
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

{keras_nightly-3.14.0.dev2026013104/keras/api/_tf_keras/keras → keras_nightly-3.14.0.dev2026020304/keras/api}/ops/__init__.py

@@ -248,6 +248,7 @@ from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
 from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
+from keras.src.ops.numpy import nanprod as nanprod
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

{keras_nightly-3.14.0.dev2026013104/keras/api/_tf_keras/keras → keras_nightly-3.14.0.dev2026020304/keras/api}/ops/numpy/__init__.py

@@ -132,6 +132,7 @@ from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
 from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
+from keras.src.ops.numpy import nanprod as nanprod
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/backend/jax/numpy.py

@@ -1,6 +1,7 @@
 import builtins
 import math
 
+import jax
 import jax.experimental.sparse as jax_sparse
 import jax.numpy as jnp
 from jax import export as jax_export
@@ -16,6 +17,18 @@ from keras.src.backend.jax.core import cast
 from keras.src.backend.jax.core import convert_to_tensor
 
 
+def _uses_cpu(x):
+    if hasattr(x, "device"):
+        device = x.device
+        if not isinstance(device, jax.Device):
+            # Array is sharded.
+            return False
+        return device.platform == "cpu"
+    else:
+        # This is a Tracer, not a concrete Array.
+        return jax.default_backend() == "cpu"
+
+
 def rot90(array, k=1, axes=(0, 1)):
     """Rotate an array by 90 degrees in the specified plane."""
     if array.ndim < 2:
@@ -402,11 +415,9 @@ def arctanh(x):
 
 
 def argmax(x, axis=None, keepdims=False):
-    from keras.src.testing.test_case import uses_cpu
-
     x = convert_to_tensor(x)
     dtype = standardize_dtype(x.dtype)
-    if "float" not in dtype or not uses_cpu() or x.ndim == 0:
+    if "float" not in dtype or x.ndim == 0 or not _uses_cpu(x):
         return jnp.argmax(x, axis=axis, keepdims=keepdims)
 
     # Fix the flush-to-zero (FTZ) issue based on this issue:
@@ -419,11 +430,9 @@ def argmax(x, axis=None, keepdims=False):
 
 
 def argmin(x, axis=None, keepdims=False):
-    from keras.src.testing.test_case import uses_cpu
-
     x = convert_to_tensor(x)
     dtype = standardize_dtype(x.dtype)
-    if "float" not in dtype or not uses_cpu() or x.ndim == 0:
+    if "float" not in dtype or x.ndim == 0 or not _uses_cpu(x):
         return jnp.argmin(x, axis=axis, keepdims=keepdims)
 
     # Fix the flush-to-zero (FTZ) issue based on this issue:
@@ -1028,6 +1037,11 @@ def nanmin(x, axis=None, keepdims=False):
     return jnp.nanmin(x, axis=axis, keepdims=keepdims)
 
 
+def nanprod(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    return jnp.nanprod(x, axis=axis, keepdims=keepdims)
+
+
 def nansum(x, axis=None, keepdims=False):
     x = convert_to_tensor(x)
     return jnp.nansum(x, axis=axis, keepdims=keepdims)

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/backend/numpy/numpy.py

@@ -973,6 +973,19 @@ def nanmin(x, axis=None, keepdims=False):
     return np.nanmin(x, axis=axis, keepdims=keepdims)
 
 
+def nanprod(x, axis=None, keepdims=False):
+    axis = standardize_axis_for_numpy(axis)
+
+    x = convert_to_tensor(x)
+
+    dtype = dtypes.result_type(x.dtype)
+    if dtype in ("bool", "int8", "int16"):
+        dtype = "int32"
+    elif dtype in ("uint8", "uint16"):
+        dtype = "uint32"
+    return np.nanprod(x, axis=axis, keepdims=keepdims, dtype=dtype)
+
+
 def nansum(x, axis=None, keepdims=False):
     axis = standardize_axis_for_numpy(axis)
     dtype = standardize_dtype(x.dtype)

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/backend/openvino/numpy.py

@@ -366,6 +366,10 @@ def arctan2(x1, x2):
     x1 = ov_opset.convert(x1, result_type)
     x2 = ov_opset.convert(x2, result_type)
 
+    nan_x1 = ov_opset.is_nan(x1)
+    nan_x2 = ov_opset.is_nan(x2)
+    nan_mask = ov_opset.logical_or(nan_x1, nan_x2)
+
     x = ov_opset.divide(x1, x2)
     y = ov_opset.atan(x)
 
@@ -375,12 +379,12 @@ def arctan2(x1, x2):
     neg_half_pi = ov_opset.constant(-float(np.pi / 2), ov_type)
     zero_const = ov_opset.constant(0.0, ov_type)
 
-    cond_x2_gt0 = ov_opset.greater(x2, zero_const).output(0)
-    cond_x2_lt0 = ov_opset.less(x2, zero_const).output(0)
+    cond_x2_gt0 = ov_opset.greater(x2, zero_const)
+    cond_x2_lt0 = ov_opset.less(x2, zero_const)
 
-    cond_x1_ge0 = ov_opset.greater_equal(x1, zero_const).output(0)
-    cond_x1_gt0 = ov_opset.greater(x1, zero_const).output(0)
-    cond_x1_eq0 = ov_opset.equal(x1, zero_const).output(0)
+    cond_x1_ge0 = ov_opset.greater_equal(x1, zero_const)
+    cond_x1_gt0 = ov_opset.greater(x1, zero_const)
+    cond_x1_eq0 = ov_opset.equal(x1, zero_const)
 
     out_x2_lt0 = ov_opset.select(
         cond_x1_ge0,
@@ -393,7 +397,11 @@ def arctan2(x1, x2):
 
     out_not_pos = ov_opset.select(cond_x2_lt0, out_x2_lt0, out_x2_zero)
 
-    final_out = ov_opset.select(cond_x2_gt0, y, out_not_pos)
+    value_out = ov_opset.select(cond_x2_gt0, y, out_not_pos)
+
+    # Generate NaN safely for all floating dtypes (including bf16)
+    nan_value = ov_opset.divide(zero_const, zero_const)
+    final_out = ov_opset.select(nan_mask, nan_value, value_out)
     return OpenVINOKerasTensor(final_out.output(0))
 
 
@@ -2121,6 +2129,12 @@ def nanmin(x, axis=None, keepdims=False):
     raise NotImplementedError("`nanmin` is not supported with openvino backend")
 
 
+def nanprod(x, axis=None, keepdims=False):
+    raise NotImplementedError(
+        "`nanprod` is not supported with openvino backend"
+    )
+
+
 def nansum(x, axis=None, keepdims=False):
     x = get_ov_output(x)
     x_type = x.get_element_type()

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/backend/tensorflow/numpy.py

@@ -949,11 +949,9 @@ def argmax(x, axis=None, keepdims=False):
 
 
 def argmin(x, axis=None, keepdims=False):
-    from keras.src.testing.test_case import uses_cpu
-
     x = convert_to_tensor(x)
     dtype = standardize_dtype(x.dtype)
-    if "float" not in dtype or not uses_cpu() or x.ndim == 0:
+    if "float" not in dtype or x.ndim == 0:
         _x = x
         if axis is None:
             x = tf.reshape(x, [-1])
@@ -2186,6 +2184,16 @@ def nanmin(x, axis=None, keepdims=False):
     )
 
 
+def nanprod(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+
+    if not x.dtype.is_floating:
+        return prod(x, axis=axis, keepdims=keepdims)
+
+    x_safe = tf.where(tf.math.is_nan(x), tf.ones((), dtype=x.dtype), x)
+    return prod(x_safe, axis=axis, keepdims=keepdims)
+
+
 def nansum(x, axis=None, keepdims=False):
     x = convert_to_tensor(x)
     dtype = standardize_dtype(x.dtype)

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/backend/torch/numpy.py

@@ -1318,6 +1318,25 @@ def nanmin(x, axis=None, keepdims=False):
     )
 
 
+def nanprod(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+
+    if axis == () or axis == []:
+        return torch.nan_to_num(x, nan=1)
+
+    if isinstance(axis, (list, tuple)):
+        axis = sorted(axis, reverse=True)
+
+    if not torch.is_floating_point(x):
+        return prod(x, axis=axis, keepdims=keepdims)
+
+    return prod(
+        torch.where(torch.isnan(x), torch.ones((), dtype=x.dtype), x),
+        axis=axis,
+        keepdims=keepdims,
+    )
+
+
 def nansum(x, axis=None, keepdims=False):
     if isinstance(x, (list, tuple)):
         x = stack(x)

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/export/onnx.py

@@ -76,13 +76,19 @@ def export_onnx(
     if input_signature is None:
         input_signature = get_input_signature(model)
         if not input_signature or not model._called:
-            raise ValueError(
-                "The model provided has never called. "
-                "It must be called at least once before export."
-            )
+            raise ValueError("The model provided has never called. ")
+
+    # Extract specs for proper input name generation
+    if len(input_signature) == 1 and isinstance(input_signature[0], list):
+        # Multi-input case: input_signature = [[spec1, spec2, ...]]
+        specs_for_names = input_signature[0]
+    else:
+        # Single input case: input_signature = [spec]
+        specs_for_names = input_signature
+
     input_names = [
         getattr(spec, "name", None) or f"input_{i}"
-        for i, spec in enumerate(input_signature)
+        for i, spec in enumerate(specs_for_names)
     ]
 
     if backend.backend() in ("tensorflow", "jax"):
@@ -105,10 +111,37 @@ def export_onnx(
     elif backend.backend() == "torch":
         import torch
 
+        """Generate dynamic_axes format for ONNX export."""
+        dynamic_axes = {}
+
+        for input_idx, spec in enumerate(specs_for_names):
+            if not hasattr(spec, "shape"):
+                continue
+
+            shape = spec.shape
+            dynamic_dims = {}
+
+            for dim_idx, dim_size in enumerate(shape):
+                if dim_size is None:
+                    if dim_idx == 0:
+                        dim_name = "batch"
+                    else:
+                        dim_name = f"dim_{input_idx}_{dim_idx}"
+                    dynamic_dims[dim_idx] = dim_name
+
+            if dynamic_dims:
+                input_name = (
+                    input_names[input_idx]
+                    if input_idx < len(input_names)
+                    else f"input_{input_idx}"
+                )
+                dynamic_axes[input_name] = dynamic_dims
+
         sample_inputs = tree.map_structure(
             lambda x: convert_spec_to_tensor(x, replace_none_number=1),
             input_signature,
         )
+
         sample_inputs = tuple(sample_inputs)
         # TODO: Make dict model exportable.
         if any(isinstance(x, dict) for x in sample_inputs):
@@ -140,34 +173,80 @@ def export_onnx(
             warnings.filterwarnings(
                 "ignore", message=r".*suppressed about get_attr references.*"
             )
+            # Suppress TorchScript tracing warnings
+            warnings.filterwarnings(
+                "ignore",
+                message=r".*Converting a tensor to a Python boolean.*",
+                category=torch.jit.TracerWarning,
+            )
+            warnings.filterwarnings(
+                "ignore",
+                message=r".*Converting a tensor to a Python integer.*",
+                category=torch.jit.TracerWarning,
+            )
+            warnings.filterwarnings(
+                "ignore",
+                message=r".*Iterating over a tensor.*",
+                category=torch.jit.TracerWarning,
+            )
+            warnings.filterwarnings(
+                "ignore",
+                message=r".*Using len to get tensor shape.*",
+                category=torch.jit.TracerWarning,
+            )
+            warnings.filterwarnings(
+                "ignore",
+                message=r".*torch.tensor results are registered as constants.*",
+                category=torch.jit.TracerWarning,
+            )
+
+        # When dynamic shapes are present, prefer TorchScript over
+        # TorchDynamo because TorchDynamo has constraint inference issues
+        # with dynamic dimensions
+        if not dynamic_axes:
             try:
-                # Try the TorchDynamo-based ONNX exporter first.
+                # Try the TorchDynamo-based ONNX exporter first for static
+                # shapes
+                export_kwargs = {
+                    "verbose": actual_verbose,
+                    "opset_version": opset_version,
+                    "input_names": input_names,
+                    "dynamo": True,
+                }
+
                 onnx_program = torch.onnx.export(
-                    model,
-                    sample_inputs,
-                    verbose=actual_verbose,
-                    opset_version=opset_version,
-                    input_names=input_names,
-                    dynamo=True,
+                    model, sample_inputs, **export_kwargs
                 )
                 if hasattr(onnx_program, "optimize"):
                     onnx_program.optimize()  # Only supported by torch>=2.6.0.
                 onnx_program.save(filepath)
-            except:
-                if verbose is None:
-                    # Set to `False` due to file system leakage issue:
-                    # https://github.com/keras-team/keras/issues/20826
-                    actual_verbose = False
-
-                # Fall back to the TorchScript-based ONNX exporter.
-                torch.onnx.export(
-                    model,
-                    sample_inputs,
-                    filepath,
-                    verbose=actual_verbose,
-                    opset_version=opset_version,
-                    input_names=input_names,
-                )
+
+                return
+            except Exception:
+                pass
+
+        """Export using TorchScript-based ONNX exporter."""
+        # Set verbose to False for TorchScript due to file system leakage
+        torchscript_verbose = verbose
+        if verbose is None:
+            # Set to `False` due to file system leakage issue:
+            # https://github.com/keras-team/keras/issues/20826
+            torchscript_verbose = False
+
+        export_kwargs = {
+            "verbose": torchscript_verbose,
+            "opset_version": opset_version,
+            "input_names": input_names,
+            "export_params": True,
+            "do_constant_folding": True,
+            "dynamo": False,
+        }
+
+        # For TorchScript (dynamo=False), use dynamic_axes parameter
+        if dynamic_axes:
+            export_kwargs["dynamic_axes"] = dynamic_axes
+
+        torch.onnx.export(model, sample_inputs, filepath, **export_kwargs)
     else:
         raise NotImplementedError(
             "`export_onnx` is only compatible with TensorFlow, JAX and "

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/ops/image.py

@@ -342,6 +342,10 @@ def resize(
             "Expected `size` to be a tuple of 2 integers. "
             f"Received: size={size}"
         )
+    if size[0] <= 0 or size[1] <= 0:
+        raise ValueError(
+            f"`size` must have positive height and width. Received: size={size}"
+        )
     if len(images.shape) < 3 or len(images.shape) > 4:
         raise ValueError(
             "Invalid images rank: expected rank 3 (single image) "

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/ops/numpy.py

@@ -5231,6 +5231,72 @@ def nanmin(x, axis=None, keepdims=False):
     return backend.numpy.nanmin(x, axis=axis, keepdims=keepdims)
 
 
+class Nanprod(Operation):
+    def __init__(self, axis=None, keepdims=False, *, name=None):
+        super().__init__(name=name)
+        self.axis = axis
+        self.keepdims = keepdims
+
+    def call(self, x):
+        return backend.numpy.nanprod(
+            x,
+            axis=self.axis,
+            keepdims=self.keepdims,
+        )
+
+    def compute_output_spec(self, x):
+        dtype = backend.standardize_dtype(x.dtype)
+
+        if dtype == "bool":
+            dtype = "int32"
+        elif dtype in ("int8", "int16"):
+            dtype = "int32"
+        elif dtype in ("uint8", "uint16"):
+            dtype = "uint32"
+
+        if backend.backend() == "torch" and dtype == "uint32":
+            dtype = "int32"
+
+        return KerasTensor(
+            reduce_shape(x.shape, axis=self.axis, keepdims=self.keepdims),
+            dtype=dtype,
+        )
+
+
+@keras_export(["keras.ops.nanprod", "keras.ops.numpy.nanprod"])
+def nanprod(x, axis=None, keepdims=False):
+    """Product of a tensor over the given axes, ignoring NaNs.
+
+    Args:
+        x: Input tensor.
+        axis: Axis or axes along which the product is computed. The default is
+            to compute the product of the flattened tensor.
+        keepdims: If this is set to `True`, the axes which are reduced are left
+            in the result as dimensions with size one.
+
+    Returns:
+        Output tensor containing the product, with NaN values ignored.
+
+    Examples:
+    >>> import numpy as np
+    >>> from keras import ops
+    >>> x = np.array([[1.0, np.nan, 3.0],
+    ...               [np.nan, 2.0, 1.0]])
+    >>> ops.nanprod(x)
+    6.0
+
+    >>> ops.nanprod(x, axis=1)
+    array([3., 2.])
+
+    >>> ops.nanprod(x, axis=1, keepdims=True)
+    array([[3.],
+           [2.]])
+    """
+    if any_symbolic_tensors((x,)):
+        return Nanprod(axis=axis, keepdims=keepdims).symbolic_call(x)
+    return backend.numpy.nanprod(x, axis=axis, keepdims=keepdims)
+
+
 class Nansum(Operation):
     def __init__(self, axis=None, keepdims=False, *, name=None):
         super().__init__(name=name)

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/testing/__init__.py

@@ -1,5 +1,6 @@
 from keras.src.testing.test_case import TestCase
 from keras.src.testing.test_case import jax_uses_gpu
+from keras.src.testing.test_case import jax_uses_tpu
 from keras.src.testing.test_case import tensorflow_uses_gpu
 from keras.src.testing.test_case import torch_uses_gpu
 from keras.src.testing.test_case import uses_gpu

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/testing/test_case.py

@@ -650,6 +650,10 @@ def uses_gpu():
     return False
 
 
+def jax_uses_tpu():
+    return backend.backend() == "jax" and uses_tpu()
+
+
 def uses_tpu():
     # Condition used to skip tests when using the TPU
     try:
@@ -661,13 +665,6 @@ def uses_tpu():
     return False
 
 
-def uses_cpu():
-    devices = distribution.list_devices()
-    if any(d.startswith("cpu") for d in devices):
-        return True
-    return False
-
-
 def create_keras_tensors(input_shape, dtype, sparse, ragged):
     if isinstance(input_shape, dict):
         return {

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras/src/version.py

@@ -1,7 +1,7 @@
 from keras.src.api_export import keras_export
 
 # Unique source of truth for the version number.
-__version__ = "3.14.0.dev2026013104"
+__version__ = "3.14.0.dev2026020304"
 
 
 @keras_export("keras.version")

{keras_nightly-3.14.0.dev2026013104 → keras_nightly-3.14.0.dev2026020304}/keras_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keras-nightly
-Version: 3.14.0.dev2026013104
+Version: 3.14.0.dev2026020304
 Summary: Multi-backend Keras
 Author-email: Keras team <keras-users@googlegroups.com>
 License: Apache License 2.0