PyPI - keras-nightly - Versions diffs - 3.14.0.dev2026010504__tar.gz → 3.14.0.dev2026010704__tar.gz - Mend

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

@@ -4,6 +4,7 @@ from openvino import Type
 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.variables import standardize_dtype
 from keras.src.backend.openvino.core import DTYPES_MAX
 from keras.src.backend.openvino.core import DTYPES_MIN
@@ -893,9 +894,53 @@ def diag(x, k=0):
 def diagonal(x, offset=0, axis1=0, axis2=1):
-    raise NotImplementedError(
-        "`diagonal` is not supported with openvino backend"
-    )
+    x = get_ov_output(x)
+    shape = x.get_partial_shape()
+    rank = x.get_partial_shape().rank.get_length()
+    if rank is None:
+        raise ValueError("`diagonal` requires input tensor with static rank.")
+    if rank < 2:
+        raise ValueError(
+            f"diagonal requires input tensor with rank >= 2.Given rank: {rank}"
+        )
+    axis1 = canonicalize_axis(axis1, rank)
+    axis2 = canonicalize_axis(axis2, rank)
+    if axis1 == axis2:
+        raise ValueError("`axis1` and `axis2` cannot be the same.")
+    perm_order = [axis1, axis2] + [
+        i for i in range(rank) if i != axis1 and i != axis2
+    ]
+    perm_const = ov_opset.constant(perm_order, dtype=Type.i32).output(0)
+    x_transposed = ov_opset.transpose(x, perm_const)
+    N_dim = shape[axis1]
+    M_dim = shape[axis2]
+    if not N_dim.is_static or not M_dim.is_static:
+        raise ValueError(
+            "`diagonal` requires input tensor with static shape for axes "
+            f"`axis1` ({axis1}) and `axis2` ({axis2})."
+        )
+    N = N_dim.get_length()
+    M = M_dim.get_length()
+    if offset >= 0:
+        L = np.minimum(N, M - offset) if (M - offset) > 0 else 0
+        indices = [[i, i + offset] for i in range(L)]
+    else:
+        L = np.minimum(N + offset, M) if (N + offset) > 0 else 0
+        indices = [[i - offset, i] for i in range(L)]
+    indices = np.array(indices, dtype=np.int32).reshape(L, 2)
+    indices_const = ov_opset.constant(indices, dtype=Type.i32).output(0)
+    diag_gathered = ov_opset.gather_nd(x_transposed, indices_const)
+    out_rank = rank - 1
+    out_perm_order = list(range(1, out_rank)) + [0]
+    out_perm_const = ov_opset.constant(out_perm_order, dtype=Type.i32).output(0)
+    final_output = ov_opset.transpose(diag_gathered, out_perm_const)
+    return OpenVINOKerasTensor(final_output.output(0))
 def diff(a, n=1, axis=-1):

@@ -6,6 +6,7 @@ from keras.src import ops
 from keras.src import quantizers
 from keras.src.api_export import keras_export
 from keras.src.backend import KerasTensor
+from keras.src.backend import set_keras_mask
 from keras.src.quantizers.quantization_config import QuantizationConfig
@@ -117,7 +118,11 @@ class ReversibleEmbedding(layers.Embedding):
     def call(self, inputs, reverse=False):
         if not reverse:
-            return super().call(inputs)
+            result = super().call(inputs)
+            mask = super().compute_mask(inputs)
+            if mask is not None:
+                set_keras_mask(result, mask)
+            return result
         else:
             if self.tie_weights:
                 kernel = ops.transpose(ops.convert_to_tensor(self.embeddings))
@@ -135,6 +140,10 @@ class ReversibleEmbedding(layers.Embedding):
                 )
             return logits
+    def compute_mask(self, inputs, mask=None):
+        # Disable masking from super class, masking is done directly in call.
+        return None
     def compute_output_shape(self, input_shape, reverse=False):
         output_shape = list(input_shape)
         if reverse:

@@ -507,10 +507,14 @@ class FeatureSpace(Layer):
     def adapt(self, dataset):
         if not isinstance(dataset, tf.data.Dataset):
-            raise ValueError(
-                "`adapt()` can only be called on a tf.data.Dataset. "
-                f"Received instead: {dataset} (of type {type(dataset)})"
-            )
+            if isinstance(dataset, dict):
+                dataset = tf.data.Dataset.from_tensor_slices(dataset)
+            else:
+                raise ValueError(
+                    "`adapt()` can only be called on a tf.data.Dataset or a "
+                    "dict of arrays/lists. "
+                    f"Received instead: {dataset} (of type {type(dataset)})"
+                )
         for name in self._list_adaptable_preprocessors():
             # Call adapt() on each individual adaptable layer.

@@ -66,6 +66,16 @@ class Resizing(BaseImagePreprocessingLayer):
             `~/.keras/keras.json`. If you never set it, then it will be
             `"channels_last"`.
         **kwargs: Base layer keyword arguments, such as `name` and `dtype`.
+    Example:
+    ```python
+    (x_train, y_train), _ = keras.datasets.cifar10.load_data()
+    image = x_train[0]
+    resizer = keras.layers.Resizing(128, 128)
+    resized_image = resizer(image)
+    print("original:", image.shape, "resized:", resized_image.shape)
+    ```
     """
     _USE_BASE_FACTOR = False

@@ -31,13 +31,13 @@ def no_automatic_dependency_tracking(fn):
 class Tracker:
     """Attribute tracker, used for e.g. Variable tracking.
-    Monitors certain attribute types
-    and put them in appropriate lists in case of a match.
+    Monitors certain attribute types and places matching
+    objects into user provided tracking collections.
     Also passively tracks certain mutable collections
-    (dict, list) so that items added to them later
-    still get tracked. This is done by wrapping these
-    collections into an equivalent, tracking-aware object.
+    (e.g. dict and list) ensuring that items added after
+    initialization are still tracked. This is done by wrapping
+    these collections in tracking-aware proxy objects.
     Example:

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

keras-nightly 3.14.0.dev2026010504__tar.gz → 3.14.0.dev2026010704__tar.gz

keras-nightly 3.14.0.dev2026010504tar.gz → 3.14.0.dev2026010704tar.gz