keras-nightly 3.12.0.dev2025082903__tar.gz → 3.12.0.dev2025083103__tar.gz

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/PKG-INFO

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

{keras_nightly-3.12.0.dev2025082903/keras/api → keras_nightly-3.12.0.dev2025083103/keras/api/_tf_keras/keras}/ops/__init__.py

@@ -187,6 +187,7 @@ from keras.src.ops.numpy import floor as floor
 from keras.src.ops.numpy import floor_divide as floor_divide
 from keras.src.ops.numpy import full as full
 from keras.src.ops.numpy import full_like as full_like
+from keras.src.ops.numpy import gcd as gcd
 from keras.src.ops.numpy import get_item as get_item
 from keras.src.ops.numpy import greater as greater
 from keras.src.ops.numpy import greater_equal as greater_equal

{keras_nightly-3.12.0.dev2025082903/keras/api → keras_nightly-3.12.0.dev2025083103/keras/api/_tf_keras/keras}/ops/numpy/__init__.py

@@ -75,6 +75,7 @@ from keras.src.ops.numpy import floor as floor
 from keras.src.ops.numpy import floor_divide as floor_divide
 from keras.src.ops.numpy import full as full
 from keras.src.ops.numpy import full_like as full_like
+from keras.src.ops.numpy import gcd as gcd
 from keras.src.ops.numpy import get_item as get_item
 from keras.src.ops.numpy import greater as greater
 from keras.src.ops.numpy import greater_equal as greater_equal

{keras_nightly-3.12.0.dev2025082903/keras/api/_tf_keras/keras → keras_nightly-3.12.0.dev2025083103/keras/api}/ops/__init__.py

@@ -187,6 +187,7 @@ from keras.src.ops.numpy import floor as floor
 from keras.src.ops.numpy import floor_divide as floor_divide
 from keras.src.ops.numpy import full as full
 from keras.src.ops.numpy import full_like as full_like
+from keras.src.ops.numpy import gcd as gcd
 from keras.src.ops.numpy import get_item as get_item
 from keras.src.ops.numpy import greater as greater
 from keras.src.ops.numpy import greater_equal as greater_equal

{keras_nightly-3.12.0.dev2025082903/keras/api/_tf_keras/keras → keras_nightly-3.12.0.dev2025083103/keras/api}/ops/numpy/__init__.py

@@ -75,6 +75,7 @@ from keras.src.ops.numpy import floor as floor
 from keras.src.ops.numpy import floor_divide as floor_divide
 from keras.src.ops.numpy import full as full
 from keras.src.ops.numpy import full_like as full_like
+from keras.src.ops.numpy import gcd as gcd
 from keras.src.ops.numpy import get_item as get_item
 from keras.src.ops.numpy import greater as greater
 from keras.src.ops.numpy import greater_equal as greater_equal

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/backend/jax/numpy.py

@@ -736,6 +736,12 @@ def full_like(x, fill_value, dtype=None):
     return jnp.full_like(x, fill_value, dtype=dtype)
 
 
+def gcd(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return jnp.gcd(x1, x2)
+
+
 def greater(x1, x2):
     x1 = convert_to_tensor(x1)
     x2 = convert_to_tensor(x2)

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/backend/numpy/numpy.py

@@ -662,6 +662,14 @@ def full_like(x, fill_value, dtype=None):
     return np.full_like(x, fill_value, dtype=dtype)
 
 
+def gcd(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    return np.gcd(x1, x2).astype(dtype)
+
+
 def greater(x1, x2):
     return np.greater(x1, x2)
 

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/backend/openvino/numpy.py

@@ -863,6 +863,10 @@ def full_like(x, fill_value, dtype=None):
     return OpenVINOKerasTensor(res)
 
 
+def gcd(x1, x2):
+    raise NotImplementedError("`gcd` is not supported with openvino backend")
+
+
 def greater(x1, x2):
     element_type = None
     if isinstance(x1, OpenVINOKerasTensor):
@@ -1101,9 +1105,47 @@ def median(x, axis=None, keepdims=False):
 
 
 def meshgrid(*x, indexing="xy"):
-    raise NotImplementedError(
-        "`meshgrid` is not supported with openvino backend"
-    )
+    if len(x) < 2:
+        raise ValueError(
+            "meshgrid requires at least 2 input arrays. "
+            f"Received: {len(x)} input array(s)."
+        )
+    if indexing not in ("xy", "ij"):
+        raise ValueError("indexing must be either 'xy' or 'ij'")
+
+    tensors = [get_ov_output(xi) for xi in x]
+    n = len(tensors)
+
+    shapes = [
+        ov_opset.shape_of(t, Type.i64).output(0) for t in tensors
+    ]  # each is [Ni]
+    one = ov_opset.constant([1], Type.i64).output(0)
+
+    if indexing == "xy":
+        shape_list = [shapes[1], shapes[0]] + shapes[2:]
+        out_shape = ov_opset.concat(shape_list, axis=0).output(0)
+    else:
+        out_shape = ov_opset.concat(shapes, axis=0).output(0)
+
+    outputs = []
+    for i, t in enumerate(tensors):
+        reshape_parts = [one] * n
+        if indexing == "xy":
+            if i == 0:
+                reshape_parts[1] = shapes[0]
+            elif i == 1:
+                reshape_parts[0] = shapes[1]
+            else:
+                reshape_parts[i] = shapes[i]
+        else:
+            reshape_parts[i] = shapes[i]
+
+        reshape_shape = ov_opset.concat(reshape_parts, axis=0).output(0)
+        reshaped = ov_opset.reshape(t, reshape_shape, False).output(0)
+        broadcasted = ov_opset.broadcast(reshaped, out_shape).output(0)
+        outputs.append(OpenVINOKerasTensor(broadcasted))
+
+    return outputs
 
 
 def min(x, axis=None, keepdims=False, initial=None):

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/backend/tensorflow/numpy.py

@@ -1531,6 +1531,43 @@ def full_like(x, fill_value, dtype=None):
     return tf.broadcast_to(fill_value, tf.shape(x))
 
 
+def gcd(x1, x2):
+    x1 = tf.convert_to_tensor(x1)
+    x2 = tf.convert_to_tensor(x2)
+
+    dtype = dtypes.result_type(x1.dtype, x2.dtype)
+    x1 = tf.cast(x1, dtype)
+    x2 = tf.cast(x2, dtype)
+
+    if not x1.dtype.is_integer:
+        raise TypeError("Arguments to gcd must be integers.")
+
+    target_shape = tf.broadcast_static_shape(x1.shape, x2.shape)
+    x1 = tf.broadcast_to(x1, target_shape)
+    x2 = tf.broadcast_to(x2, target_shape)
+
+    def cond(a, b):
+        return tf.reduce_any(b != 0)
+
+    def body(a, b):
+        b_safe = tf.where(tf.equal(b, 0), tf.ones_like(b), b)
+        return (
+            tf.where(tf.not_equal(b, 0), b, a),
+            tf.where(
+                tf.not_equal(b, 0),
+                tf.math.floormod(a, b_safe),
+                tf.zeros_like(b),
+            ),
+        )
+
+    if dtype not in [tf.uint8, tf.uint16, tf.uint32, tf.uint64]:
+        x1 = tf.abs(x1)
+        x2 = tf.abs(x2)
+
+    gcd_val, _ = tf.while_loop(cond, body, [x1, x2])
+    return gcd_val
+
+
 def greater(x1, x2):
     x1 = convert_to_tensor(x1)
     x2 = convert_to_tensor(x2)

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/backend/torch/numpy.py

@@ -839,6 +839,12 @@ def full_like(x, fill_value, dtype=None):
     return full(shape=x.shape, fill_value=fill_value, dtype=dtype)
 
 
+def gcd(x1, x2):
+    x1 = convert_to_tensor(x1)
+    x2 = convert_to_tensor(x2)
+    return torch.gcd(x1, x2)
+
+
 def greater(x1, x2):
     x1, x2 = convert_to_tensor(x1), convert_to_tensor(x2)
     return torch.greater(x1, x2)

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/dtype_policies/dtype_policy_map.py

@@ -35,29 +35,54 @@ class DTypePolicyMap(DTypePolicy, MutableMapping):
     However, it is also possible to set a regex as the key. See the docstring of
     `get` for more details.
 
-    See below for a usage example. You can define the naming schema
-    of the `DTypePolicy`, and then retrieve the corresponding `DTypePolicy`
-    instance.
-
-    ```python
-    dtype_policy_map = DTypePolicyMap()
-    dtype_policy_map["layer/dense_0"] = DTypePolicy("bfloat16")
-    dtype_policy_map["layer/dense_1"] = QuantizedDTypePolicy("int8", "bfloat16")
-
-    policy_0 = dtype_policy_map["layer/dense_0"]
-    policy_1 = dtype_policy_map["layer/dense_1"]
-    policy_2 = dtype_policy_map["layer/dense_2"]  # No hit
-    assert policy_0 == DTypePolicy("bfloat16")
-    assert policy_1 == QuantizedDTypePolicy("int8", "bfloat16")
-    assert policy_2 == keras.config.dtype_policy()
-    ```
-
     Args:
         default_policy: An optional `DTypePolicy` instance specifying the
             default dtype policy. If not specified, the value will default to
             `keras.config.dtype_policy()`.
         policy_map: An optional dict that maps string to `DTypePolicy`
             instances. Defaults to `None`
+
+    Example:
+
+    ```python
+    >>> from keras.src import dtype_policies
+    >>> bfloat16 = dtype_policies.DTypePolicy("bfloat16")
+    >>> float16 = dtype_policies.DTypePolicy("float16")
+    >>> float32 = dtype_policies.DTypePolicy("float32")
+    >>> policy_map = DTypePolicyMap(default_policy=float32)
+
+    # Set policies using an exact path and a regex pattern.
+    # Note: "decoder" will only match the exact path, not its children.
+    >>> policy_map["encoder/layer_0/dense"] = bfloat16
+    >>> policy_map["encoder/.*"] = float16
+    >>> policy_map["decoder"] = bfloat16
+
+    # 1. An exact match is found and returned directly.
+    >>> policy_map["encoder/layer_0/dense"].name
+    'bfloat16'
+
+    # 2. A regex match is found for a child layer.
+    # It matches the "encoder/.*" pattern.
+    >>> policy_map["encoder/attention/query"].name
+    'float16'
+
+    # 3. No implicit prefix matching occurs.
+    # "decoder/attention" does not match the key "decoder".
+    # The default policy is returned.
+    >>> policy_map["decoder/attention"].name
+    'float32'
+
+    # 4. A ValueError is raised if a path matches multiple patterns.
+    >>> policy_map["encoder/attention/.*"] = bfloat16
+    # "encoder/attention/query" now matches two patterns:
+    # - "encoder/.*"
+    # - "encoder/attention/.*"
+    >>> try:
+    ...     policy_map["encoder/attention/query"]
+    ... except ValueError as e:
+    ...     print(e)
+    Path 'encoder/attention/query' matches multiple dtype policy ..
+    ```
     """
 
     def __init__(self, default_policy=None, policy_map=None):
@@ -100,24 +125,79 @@ class DTypePolicyMap(DTypePolicy, MutableMapping):
     def __getitem__(self, key):
         """Retrieves the corresponding `DTypePolicy` by the string key.
 
-        When there isn't an exact match, all the existing keys in the map
-        will be treated as a regex and map against the input key again. When
-        there are multiple matches for the regex, an `ValueError` will be
-        raised. Returns `self.default_policy` if there isn't any match found.
+        This method first attempts an exact key match. If no exact match is
+        found, it treats all keys in the map as regular expression patterns
+        and uses `re.fullmatch` to find a policy.
+
+        For example, to apply a policy to all sublayers of an `encoder` block,
+        the key should be explicitly set to `"encoder/.*"`. A key of
+        `"encoder"` will only match the layer with that exact path.
 
         Args:
-            key: String key to query a `DTypePolicy`.
+            key: str. The key to query for a `DTypePolicy`.
 
         Returns:
-            Corresponding `DTypePolicy` based on the query.
+            The corresponding `DTypePolicy`. If no match is found, this method
+            returns `self.default_policy`.
+
+        Raises:
+            ValueError: If the `key` matches more than one regex pattern in the
+            map.
+
+        Example:
+
+        ```python
+        >>> from keras.src import dtype_policies
+        >>> bfloat16 = dtype_policies.DTypePolicy("bfloat16")
+        >>> float16 = dtype_policies.DTypePolicy("float16")
+        >>> float32 = dtype_policies.DTypePolicy("float32")
+        >>> policy_map = DTypePolicyMap(default_policy=float32)
+
+        # Set policies using an exact path and a regex pattern.
+        # Note: "decoder" will only match the exact path, not its children.
+        >>> policy_map["encoder/layer_0/dense"] = bfloat16
+        >>> policy_map["encoder/.*"] = float16
+        >>> policy_map["decoder"] = bfloat16
+
+        # 1. An exact match is found and returned directly.
+        >>> policy_map["encoder/layer_0/dense"].name
+        'bfloat16'
+
+        # 2. A regex match is found for a child layer.
+        # It matches the "encoder/.*" pattern.
+        >>> policy_map["encoder/attention/query"].name
+        'float16'
+
+        # 3. No implicit prefix matching occurs.
+        # "decoder/attention" does not match the key "decoder".
+        # The default policy is returned.
+        >>> policy_map["decoder/attention"].name
+        'float32'
+
+        # 4. A ValueError is raised if a path matches multiple patterns.
+        >>> policy_map["encoder/attention/.*"] = bfloat16
+        # "encoder/attention/query" now matches two patterns:
+        # - "encoder/.*"
+        # - "encoder/attention/.*"
+        >>> try:
+        ...     policy_map["encoder/attention/query"]
+        ... except ValueError as e:
+        ...     print(e)
+        Path 'encoder/attention/query' matches multiple dtype policy ..
+        ```
         """
+        # 1. Check for an exact match.
         if key in self._policy_map:
             return self._policy_map[key]
 
-        matching_keys = []
-        for k in self._policy_map:
-            if re.search(k, key):
-                matching_keys.append(k)
+        # 2. Fallback to a full regex match.
+        matching_keys = [
+            pattern
+            for pattern in self._policy_map
+            if re.fullmatch(pattern, key)
+        ]
+
+        # 3. Handle cases based on the number of matches found.
         if len(matching_keys) > 1:
             raise ValueError(
                 f"Path '{key}' matches multiple dtype policy "
@@ -127,6 +207,8 @@ class DTypePolicyMap(DTypePolicy, MutableMapping):
             )
         elif len(matching_keys) == 1:
             return self._policy_map[matching_keys[0]]
+
+        # 4. If there were no matches, return the default.
         return self.default_policy
 
     def __setitem__(self, key, policy):

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/layers/preprocessing/integer_lookup.py

@@ -111,9 +111,12 @@ class IntegerLookup(IndexLookup):
                 appeared in the sample.
             - `"tf_idf"`: As `"multi_hot"`, but the TF-IDF algorithm is
                 applied to find the value in each token slot.
-            For `"int"` output, any shape of input and output is supported.
-            For all other output modes, currently only output up to rank 2
-            is supported. Defaults to `"int"`.
+            For `"int"` output, the output shape matches the input shape.
+            For `"one_hot"` output, the output shape is
+            `input_shape + (vocabulary_size,)`, where `input_shape` may
+            have arbitrary rank. For other output modes (`"multi_hot"`,
+            `"count"`, `"tf_idf"`), the output shape is `(batch_size,
+            vocabulary_size)`. Defaults to `"int"`.
         pad_to_max_tokens: Only applicable when `output_mode` is `"multi_hot"`,
             `"count"`, or `"tf_idf"`. If `True`, the output will have
             its feature axis padded to `max_tokens` even if the number

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/layers/preprocessing/string_lookup.py

@@ -6,6 +6,9 @@ from keras.src.layers.preprocessing.index_lookup import IndexLookup
 from keras.src.utils import backend_utils
 from keras.src.utils.module_utils import tensorflow as tf
 
+if backend.backend() == "torch":
+    import torch
+
 
 @keras_export("keras.layers.StringLookup")
 class StringLookup(IndexLookup):
@@ -382,13 +385,39 @@ class StringLookup(IndexLookup):
         return {**base_config, **config}
 
     def call(self, inputs):
-        if isinstance(inputs, (tf.Tensor, tf.RaggedTensor, tf.SparseTensor)):
-            tf_inputs = True
-        else:
-            tf_inputs = False
-            if not isinstance(inputs, (np.ndarray, list, tuple)):
-                inputs = tf.convert_to_tensor(backend.convert_to_numpy(inputs))
-        outputs = super().call(inputs)
-        if not tf_inputs:
-            outputs = backend_utils.convert_tf_tensor(outputs)
-        return outputs
+        is_torch_backend = backend.backend() == "torch"
+
+        # Handle input conversion
+        inputs_for_processing = inputs
+        was_tf_input = isinstance(
+            inputs, (tf.Tensor, tf.RaggedTensor, tf.SparseTensor)
+        )
+
+        if is_torch_backend and isinstance(inputs, torch.Tensor):
+            inputs_for_processing = tf.convert_to_tensor(
+                inputs.detach().cpu().numpy()
+            )
+        elif isinstance(inputs, (np.ndarray, list, tuple)):
+            inputs_for_processing = tf.convert_to_tensor(inputs)
+        elif not was_tf_input:
+            inputs_for_processing = tf.convert_to_tensor(
+                backend.convert_to_numpy(inputs)
+            )
+
+        output = super().call(inputs_for_processing)
+
+        # Handle torch backend output conversion
+        if is_torch_backend and isinstance(
+            inputs, (torch.Tensor, np.ndarray, list, tuple)
+        ):
+            numpy_outputs = output.numpy()
+            if self.invert:
+                return [n.decode(self.encoding) for n in numpy_outputs]
+            else:
+                return torch.from_numpy(numpy_outputs)
+
+        # other backends
+        if not was_tf_input:
+            output = backend_utils.convert_tf_tensor(output)
+
+        return output

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras/src/ops/numpy.py

@@ -3329,6 +3329,37 @@ def full_like(x, fill_value, dtype=None):
     return backend.numpy.full_like(x, fill_value, dtype=dtype)
 
 
+class Gcd(Operation):
+    def call(self, x1, x2):
+        return backend.numpy.gcd(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)
+        return KerasTensor(output_shape, dtype=dtype)
+
+
+@keras_export(["keras.ops.gcd", "keras.ops.numpy.gcd"])
+def gcd(x1, x2):
+    """Greatest common divisor of `x1` and `x2`, element-wise.
+
+    Args:
+        x1: First input tensor (integer type).
+        x2: Second input tensor (integer type).
+
+    Returns:
+        Output tensor, element-wise greatest common divisor of `x1` and `x2`.
+    """
+    if any_symbolic_tensors((x1, x2)):
+        return Gcd().symbolic_call(x1, x2)
+    return backend.numpy.gcd(x1, x2)
+
+
 class GetItem(Operation):
     def call(self, x, key):
         if isinstance(key, list):

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/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.12.0.dev2025082903"
+__version__ = "3.12.0.dev2025083103"
 
 
 @keras_export("keras.version")

{keras_nightly-3.12.0.dev2025082903 → keras_nightly-3.12.0.dev2025083103}/keras_nightly.egg-info/PKG-INFO

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