keras-nightly 3.14.0.dev2025122704__py3-none-any.whl → 3.14.0.dev2026012204__py3-none-any.whl

keras/src/ops/image.py

@@ -565,6 +565,9 @@ class ExtractPatches(Operation):
         if isinstance(size, int):
             size = (size, size)
         self.size = size
+        self.is_3d = len(self.size) == 3
+        if strides is None:
+            strides = size
         self.strides = strides
         self.dilation_rate = dilation_rate
         self.padding = padding
@@ -583,29 +586,51 @@ class ExtractPatches(Operation):
     def compute_output_spec(self, images):
         images_shape = list(images.shape)
         original_ndim = len(images_shape)
-        if not self.strides:
-            strides = (self.size[0], self.size[1])
         if self.data_format == "channels_last":
             channels_in = images_shape[-1]
         else:
-            channels_in = images_shape[-3]
-        if original_ndim == 3:
-            images_shape = [1] + images_shape
-        filters = self.size[0] * self.size[1] * channels_in
-        kernel_size = (self.size[0], self.size[1])
+            channels_in = images_shape[-4] if self.is_3d else images_shape[-3]
+
+        if self.is_3d:
+            # 3D patch extraction
+            if original_ndim == 4:
+                images_shape = [1] + images_shape
+            filters = self.size[0] * self.size[1] * self.size[2] * channels_in
+            kernel_size = (self.size[0], self.size[1], self.size[2])
+        else:
+            # 2D patch extraction
+            if original_ndim == 3:
+                images_shape = [1] + images_shape
+            filters = self.size[0] * self.size[1] * channels_in
+            kernel_size = (self.size[0], self.size[1])
+
         out_shape = compute_conv_output_shape(
             images_shape,
             filters,
             kernel_size,
-            strides=strides,
+            strides=self.strides,
             padding=self.padding,
             data_format=self.data_format,
             dilation_rate=self.dilation_rate,
         )
-        if original_ndim == 3:
-            out_shape = out_shape[1:]
+
+        if self.is_3d:
+            if original_ndim == 4:
+                out_shape = out_shape[1:]
+        else:
+            if original_ndim == 3:
+                out_shape = out_shape[1:]
         return KerasTensor(shape=out_shape, dtype=images.dtype)
 
+    def get_config(self):
+        return {
+            "size": self.size,
+            "strides": self.strides,
+            "dilation_rate": self.dilation_rate,
+            "padding": self.padding,
+            "data_format": self.data_format,
+        }
+
 
 @keras_export("keras.ops.image.extract_patches")
 def extract_patches(
@@ -616,42 +641,78 @@ def extract_patches(
     padding="valid",
     data_format=None,
 ):
-    """Extracts patches from the image(s).
+    """Extracts patches from the image(s) or volume(s).
+
+    This function supports both 2D and 3D patch extraction based on the
+    `size` argument length, similar to how `keras.ops.conv` handles
+    different dimensions.
 
     Args:
-        images: Input image or batch of images. Must be 3D or 4D.
-        size: Patch size int or tuple (patch_height, patch_width)
-        strides: strides along height and width. If not specified, or
-            if `None`, it defaults to the same value as `size`.
-        dilation_rate: This is the input stride, specifying how far two
-            consecutive patch samples are in the input. For value other than 1,
-            strides must be 1. NOTE: `strides > 1` is not supported in
-            conjunction with `dilation_rate > 1`
+        images: Input image/volume or batch of images/volumes.
+            For 2D patches: 3D `(H, W, C)` or 4D `(N, H, W, C)`.
+            For 3D patches: 4D `(D, H, W, C)` or 5D `(N, D, H, W, C)`.
+        size: Patch size as int or tuple.
+            Length 2 tuple `(patch_height, patch_width)` or int for 2D patches.
+            Length 3 tuple `(patch_depth, patch_height, patch_width)` for
+            3D patches.
+        strides: Strides for patch extraction. If not specified, defaults
+            to `size` (non-overlapping patches).
+        dilation_rate: Dilation rate for patch extraction. Note that
+            `dilation_rate > 1` is not supported with `strides > 1`.
         padding: The type of padding algorithm to use: `"same"` or `"valid"`.
         data_format: A string specifying the data format of the input tensor.
             It can be either `"channels_last"` or `"channels_first"`.
-            `"channels_last"` corresponds to inputs with shape
-            `(batch, height, width, channels)`, while `"channels_first"`
-            corresponds to inputs with shape `(batch, channels, height, width)`.
-            If not specified, the value will default to
-            `keras.config.image_data_format`.
+            If not specified, defaults to `keras.config.image_data_format`.
 
     Returns:
-        Extracted patches 3D (if not batched) or 4D (if batched)
+        Extracted patches with shape depending on input and `size`:
+        - 2D patches: 3D (unbatched) or 4D (batched)
+        - 3D patches: 4D (unbatched) or 5D (batched)
 
     Examples:
 
+    >>> # 2D patches from batch of images
     >>> image = np.random.random(
     ...     (2, 20, 20, 3)
-    ... ).astype("float32") # batch of 2 RGB images
+    ... ).astype("float32")
     >>> patches = keras.ops.image.extract_patches(image, (5, 5))
     >>> patches.shape
     (2, 4, 4, 75)
-    >>> image = np.random.random((20, 20, 3)).astype("float32") # 1 RGB image
+
+    >>> # 2D patches from single image
+    >>> image = np.random.random((20, 20, 3)).astype("float32")
     >>> patches = keras.ops.image.extract_patches(image, (3, 3), (1, 1))
     >>> patches.shape
     (18, 18, 27)
+
+    >>> # 3D patches from batch of volumes
+    >>> volumes = np.random.random(
+    ...     (2, 10, 10, 10, 3)
+    ... ).astype("float32")
+    >>> patches = keras.ops.image.extract_patches(volumes, (3, 3, 3))
+    >>> patches.shape
+    (2, 3, 3, 3, 81)
+
+    >>> # 3D patches from single volume
+    >>> volume = np.random.random((10, 10, 10, 3)).astype("float32")
+    >>> patches = keras.ops.image.extract_patches(volume, (3, 3, 3))
+    >>> patches.shape
+    (3, 3, 3, 81)
     """
+    # Validate size argument
+    if not isinstance(size, int):
+        if not isinstance(size, (tuple, list)):
+            raise TypeError(
+                "Invalid `size` argument. Expected an int or a tuple. "
+                f"Received: size={size} of type {type(size).__name__}"
+            )
+        if len(size) not in (2, 3):
+            raise ValueError(
+                "Invalid `size` argument. Expected a tuple of length 2 or 3. "
+                f"Received: size={size} with length {len(size)}"
+            )
+
+    # 2D patch extraction (default)
     if any_symbolic_tensors((images,)):
         return ExtractPatches(
             size=size,
@@ -673,6 +734,23 @@ def _extract_patches(
     dilation_rate=1,
     padding="valid",
     data_format=None,
+):
+    if not isinstance(size, int) and len(size) == 3:
+        return _extract_patches_3d(
+            images, size, strides, dilation_rate, padding, data_format
+        )
+    return _extract_patches_2d(
+        images, size, strides, dilation_rate, padding, data_format
+    )
+
+
+def _extract_patches_2d(
+    images,
+    size,
+    strides=None,
+    dilation_rate=1,
+    padding="valid",
+    data_format=None,
 ):
     if isinstance(size, int):
         patch_h = patch_w = size
@@ -712,74 +790,6 @@ def _extract_patches(
     return patches
 
 
-class ExtractPatches3D(Operation):
-    def __init__(
-        self,
-        size,
-        strides=None,
-        dilation_rate=1,
-        padding="valid",
-        data_format=None,
-        *,
-        name=None,
-    ):
-        super().__init__(name=name)
-        if isinstance(size, int):
-            size = (size, size, size)
-        elif len(size) != 3:
-            raise TypeError(
-                "Invalid `size` argument. Expected an "
-                f"int or a tuple of length 3. Received: size={size}"
-            )
-        self.size = size
-        if strides is not None:
-            if isinstance(strides, int):
-                strides = (strides, strides, strides)
-            elif len(strides) != 3:
-                raise ValueError(f"Invalid `strides` argument. Got: {strides}")
-        else:
-            strides = size
-        self.strides = strides
-        self.dilation_rate = dilation_rate
-        self.padding = padding
-        self.data_format = backend.standardize_data_format(data_format)
-
-    def call(self, volumes):
-        return _extract_patches_3d(
-            volumes,
-            self.size,
-            self.strides,
-            self.dilation_rate,
-            self.padding,
-            self.data_format,
-        )
-
-    def compute_output_spec(self, volumes):
-        volumes_shape = list(volumes.shape)
-        original_ndim = len(volumes_shape)
-        strides = self.strides
-        if self.data_format == "channels_last":
-            channels_in = volumes_shape[-1]
-        else:
-            channels_in = volumes_shape[-4]
-        if original_ndim == 4:
-            volumes_shape = [1] + volumes_shape
-        filters = self.size[0] * self.size[1] * self.size[2] * channels_in
-        kernel_size = (self.size[0], self.size[1], self.size[2])
-        out_shape = compute_conv_output_shape(
-            volumes_shape,
-            filters,
-            kernel_size,
-            strides=strides,
-            padding=self.padding,
-            data_format=self.data_format,
-            dilation_rate=self.dilation_rate,
-        )
-        if original_ndim == 4:
-            out_shape = out_shape[1:]
-        return KerasTensor(shape=out_shape, dtype=volumes.dtype)
-
-
 def _extract_patches_3d(
     volumes,
     size,
@@ -879,8 +889,11 @@ def extract_patches_3d(
     >>> patches.shape
     (3, 3, 3, 81)
     """
+    # Convert int to 3-tuple for 3D
+    if isinstance(size, int):
+        size = (size, size, size)
     if any_symbolic_tensors((volumes,)):
-        return ExtractPatches3D(
+        return ExtractPatches(
             size=size,
             strides=strides,
             dilation_rate=dilation_rate,

keras/src/ops/numpy.py

@@ -5064,6 +5064,67 @@ def moveaxis(x, source, destination):
     return backend.numpy.moveaxis(x, source=source, destination=destination)
 
 
+class Nansum(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.nansum(x, axis=self.axis, keepdims=self.keepdims)
+
+    def compute_output_spec(self, x):
+        dtype = dtypes.result_type(getattr(x, "dtype", backend.floatx()))
+
+        if dtype in ("bool", "int8", "int16"):
+            dtype = "int32"
+        elif dtype in ("uint8", "uint16"):
+            dtype = "uint32"
+
+        if backend.backend() == "torch" and dtype == "uint32":
+            dtype = "int32"
+        sparse = getattr(x, "sparse", False)
+        return KerasTensor(
+            reduce_shape(x.shape, axis=self.axis, keepdims=self.keepdims),
+            dtype=dtype,
+            sparse=sparse,
+        )
+
+
+@keras_export(["keras.ops.nansum", "keras.ops.numpy.nansum"])
+def nansum(x, axis=None, keepdims=False):
+    """Sum of a tensor over the given axes, ignoring NaNs.
+
+    Args:
+        x: Input tensor.
+        axis: Axis or axes along which the sum is computed. The default is to
+            compute the sum of the flattened tensor.
+        keepdims: If this is set to `True`, the axes which are reduced are left
+            in the result as dimensions with size one.
+
+    Returns:
+        Output tensor containing the sum, 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.nansum(x)
+    7.0
+
+    >>> ops.nansum(x, axis=1)
+    array([4., 3.])
+
+    >>> ops.nansum(x, axis=1, keepdims=True)
+    array([[4.],
+           [3.]])
+    """
+    if any_symbolic_tensors((x,)):
+        return Nansum(axis=axis, keepdims=keepdims).symbolic_call(x)
+    return backend.numpy.nansum(x, axis=axis, keepdims=keepdims)
+
+
 class NanToNum(Operation):
     def __init__(self, nan=0.0, posinf=None, neginf=None, *, name=None):
         super().__init__(name=name)
@@ -5456,6 +5517,74 @@ def prod(x, axis=None, keepdims=False, dtype=None):
     return backend.numpy.prod(x, axis=axis, keepdims=keepdims, dtype=dtype)
 
 
+class Ptp(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.ptp(
+            x,
+            axis=self.axis,
+            keepdims=self.keepdims,
+        )
+
+    def compute_output_spec(self, x):
+        dtype = backend.standardize_dtype(x.dtype)
+        return KerasTensor(
+            reduce_shape(x.shape, axis=self.axis, keepdims=self.keepdims),
+            dtype=dtype,
+        )
+
+
+@keras_export(["keras.ops.ptp", "keras.ops.numpy.ptp"])
+def ptp(x, axis=None, keepdims=False):
+    """Return the peak-to-peak (max - min) value of tensor elements
+    over a given axis.
+
+    The peak-to-peak value is defined as the difference between the
+    maximum and minimum values along the specified axis.
+
+    Args:
+        x: Input tensor.
+        axis: Axis or axes along which the peak-to-peak value is computed.
+            The default, `axis=None`, will compute the peak-to-peak value
+            over all elements in the input tensor.
+        keepdims: If this is set to `True`, the axes which are reduced
+            are left in the result as dimensions with size one.
+
+    Returns:
+        A tensor containing the peak-to-peak values of `x` over the
+        given axis or axes.
+
+    Examples:
+    >>> x = keras.ops.array([[1., 3., 2.],
+    ...                      [4., 0., 5.]])
+
+    >>> # Peak-to-peak over all elements
+    >>> keras.ops.ptp(x)
+    5.0
+
+    >>> # Peak-to-peak along axis 1
+    >>> keras.ops.ptp(x, axis=1)
+    array([2., 5.], dtype=float32)
+
+    >>> # Peak-to-peak over multiple axes
+    >>> x = keras.ops.reshape(x, (1, 2, 3))
+    >>> keras.ops.ptp(x, axis=(1, 2))
+    array([5.], dtype=float32)
+
+    >>> # Keep reduced dimensions
+    >>> keras.ops.ptp(x, axis=2, keepdims=True)
+    array([[[2.],
+            [5.]]], dtype=float32)
+    """
+    if any_symbolic_tensors((x,)):
+        return Ptp(axis=axis, keepdims=keepdims).symbolic_call(x)
+    return backend.numpy.ptp(x, axis=axis, keepdims=keepdims)
+
+
 class Quantile(Operation):
     def __init__(
         self, axis=None, method="linear", keepdims=False, *, name=None
@@ -7104,6 +7233,49 @@ def negative(x):
     return backend.numpy.negative(x)
 
 
+class Nextafter(Operation):
+    def call(self, x1, x2):
+        return backend.numpy.nextafter(x1, x2)
+
+    def compute_output_spec(self, x1, x2):
+        x1_shape = getattr(x1, "shape", [])
+        x2_shape = getattr(x2, "shape", [])
+        output_shape = broadcast_shapes(x1_shape, x2_shape)
+
+        x1_type = backend.standardize_dtype(getattr(x1, "dtype", type(x1)))
+        x2_type = backend.standardize_dtype(getattr(x2, "dtype", type(x2)))
+        dtype = dtypes.result_type(x1_type, x2_type, float)
+        return KerasTensor(output_shape, dtype=dtype)
+
+
+@keras_export(["keras.ops.nextafter", "keras.ops.numpy.nextafter"])
+def nextafter(x1, x2):
+    """
+    Return the next representable floating-point value after `x1` towards `x2`.
+
+    This function computes the next floating-point value
+    following `x1` in the direction of `x2`, element-wise.
+
+    Args:
+        x1: Input tensor whose values will be moved to the next
+            representable floating-point value.
+        x2: Input tensor indicating the direction toward which
+            `x1` is moved.
+
+    Returns:
+        Output tensor
+
+    Example:
+    >>> x1 = keras.ops.convert_to_tensor([1.0, 1.0])
+    >>> x2 = keras.ops.convert_to_tensor([2.0, 0.0])
+    >>> keras.ops.nextafter(x1, x2)
+    array([1.0000001, 0.99999994], dtype=float32)
+    """
+    if any_symbolic_tensors((x1, x2)):
+        return Nextafter().symbolic_call(x1, x2)
+    return backend.numpy.nextafter(x1, x2)
+
+
 class Square(Operation):
     def call(self, x):
         return backend.numpy.square(x)
@@ -7691,6 +7863,15 @@ def correlate(x1, x2, mode="valid"):
 
     Returns:
         Output tensor, cross-correlation of `x1` and `x2`.
+
+    Notes:
+        Complex-valued inputs are currently not fully supported on the
+        TensorFlow and PyTorch backends. When complex tensors are passed,
+        they are cast to floating-point types and the imaginary component
+        is discarded.
+
+        This behavior is documented for clarity and may change in the
+        future. See discussion in issue #21617.
     """
     if any_symbolic_tensors((x1, x2)):
         return Correlate(mode=mode).symbolic_call(x1, x2)

keras/src/quantizers/__init__.py

@@ -1,6 +1,7 @@
 import inspect
 
 from keras.src.api_export import keras_export
+from keras.src.quantizers.awq_config import AWQConfig
 from keras.src.quantizers.quantization_config import Float8QuantizationConfig
 from keras.src.quantizers.quantization_config import Int4QuantizationConfig
 from keras.src.quantizers.quantization_config import Int8QuantizationConfig
@@ -24,6 +25,7 @@ ALL_OBJECTS = {
     Int8QuantizationConfig,
     Int4QuantizationConfig,
     Float8QuantizationConfig,
+    AWQConfig,
 }
 ALL_OBJECTS_DICT = {cls.__name__: cls for cls in ALL_OBJECTS}
 ALL_OBJECTS_DICT.update(