keras-nightly 3.12.0.dev2025082103__py3-none-any.whl → 3.12.0.dev2025082303__py3-none-any.whl

keras/src/legacy/backend.py

@@ -68,11 +68,7 @@ def batch_dot(x, y, axes=None):
         raise ValueError(
             "Cannot do batch_dot on inputs "
             "with rank < 2. "
-            "Received inputs with tf.shapes "
-            + str(x_shape)
-            + " and "
-            + str(y_shape)
-            + "."
+            f"Received inputs with tf.shapes {x_shape} and {y_shape}."
         )
 
     x_batch_size = x_shape[0]
@@ -84,10 +80,7 @@ def batch_dot(x, y, axes=None):
                 "Cannot do batch_dot on inputs "
                 "with different batch sizes. "
                 "Received inputs with tf.shapes "
-                + str(x_shape)
-                + " and "
-                + str(y_shape)
-                + "."
+                f"{x_shape} and {y_shape}."
             )
     if isinstance(axes, int):
         axes = [axes, axes]
@@ -101,9 +94,8 @@ def batch_dot(x, y, axes=None):
     if py_any(isinstance(a, (list, tuple)) for a in axes):
         raise ValueError(
             "Multiple target dimensions are not supported. "
-            + "Expected: None, int, (int, int), "
-            + "Provided: "
-            + str(axes)
+            "Expected: None, int, (int, int), "
+            f"Provided: {axes}"
         )
 
     # if tuple, convert to list.
@@ -130,12 +122,8 @@ def batch_dot(x, y, axes=None):
     if d1 is not None and d2 is not None and d1 != d2:
         raise ValueError(
             "Cannot do batch_dot on inputs with tf.shapes "
-            + str(x_shape)
-            + " and "
-            + str(y_shape)
-            + " with axes="
-            + str(axes)
-            + ". x.shape[%d] != y.shape[%d] (%d != %d)."
+            f"{x_shape} and {y_shape} with axes={axes}. "
+            "x.shape[%d] != y.shape[%d] (%d != %d)."
             % (axes[0], axes[1], d1, d2)
         )
 
@@ -1129,7 +1117,7 @@ def pool2d(
             x, pool_size, strides, padding=padding, data_format=tf_data_format
         )
     else:
-        raise ValueError("Invalid pooling mode: " + str(pool_mode))
+        raise ValueError(f"Invalid pooling mode: {str(pool_mode)}")
 
     if data_format == "channels_first" and tf_data_format == "NHWC":
         x = tf.transpose(x, (0, 3, 1, 2))  # NHWC -> NCHW
@@ -1169,7 +1157,7 @@ def pool3d(
             x, pool_size, strides, padding=padding, data_format=tf_data_format
         )
     else:
-        raise ValueError("Invalid pooling mode: " + str(pool_mode))
+        raise ValueError(f"Invalid pooling mode: {str(pool_mode)}")
 
     if data_format == "channels_first" and tf_data_format == "NDHWC":
         x = tf.transpose(x, (0, 4, 1, 2, 3))
@@ -2150,9 +2138,7 @@ def switch(condition, then_expression, else_expression):
                 "Rank of `condition` should be less than or"
                 " equal to rank of `then_expression` and "
                 "`else_expression`. ndim(condition)="
-                + str(cond_ndim)
-                + ", ndim(then_expression)="
-                + str(expr_ndim)
+                f"{cond_ndim}, ndim(then_expression)={expr_ndim}"
             )
         if cond_ndim > 1:
             ndim_diff = expr_ndim - cond_ndim

keras/src/legacy/preprocessing/image.py

@@ -617,17 +617,12 @@ class NumpyArrayIterator(Iterator):
         channels_axis = 3 if data_format == "channels_last" else 1
         if self.x.shape[channels_axis] not in {1, 3, 4}:
             warnings.warn(
-                'NumpyArrayIterator is set to use the data format convention "'
-                + data_format
-                + '" (channels on axis '
-                + str(channels_axis)
-                + "), i.e. expected either 1, 3, or 4 channels on axis "
-                + str(channels_axis)
-                + ". However, it was passed an array with shape "
-                + str(self.x.shape)
-                + " ("
-                + str(self.x.shape[channels_axis])
-                + " channels)."
+                f"NumpyArrayIterator is set to use the data format convention"
+                f' "{data_format}" (channels on axis {channels_axis})'
+                ", i.e. expected either 1, 3, or 4 channels "
+                f"on axis {channels_axis}. "
+                f"However, it was passed an array with shape {self.x.shape}"
+                f" ({self.x.shape[channels_axis]} channels)."
             )
         if y is not None:
             self.y = np.asarray(y)
@@ -1494,17 +1489,11 @@ class ImageDataGenerator:
         if x.shape[self.channel_axis] not in {1, 3, 4}:
             warnings.warn(
                 "Expected input to be images (as Numpy array) "
-                'following the data format convention "'
-                + self.data_format
-                + '" (channels on axis '
-                + str(self.channel_axis)
-                + "), i.e. expected either 1, 3 or 4 channels on axis "
-                + str(self.channel_axis)
-                + ". However, it was passed an array with shape "
-                + str(x.shape)
-                + " ("
-                + str(x.shape[self.channel_axis])
-                + " channels)."
+                f'following the data format convention "{self.data_format}'
+                f'" (channels on axis {self.channel_axis})'
+                ", i.e. expected either 1, 3 or 4 channels on axis "
+                f"{self.channel_axis}. However, it was passed an array with"
+                f" shape {x.shape} ({x.shape[self.channel_axis]} channels)."
             )
 
         if seed is not None:

keras/src/legacy/preprocessing/text.py

@@ -102,7 +102,7 @@ class Tokenizer:
             num_words = kwargs.pop("nb_words")
         document_count = kwargs.pop("document_count", 0)
         if kwargs:
-            raise TypeError("Unrecognized keyword arguments: " + str(kwargs))
+            raise TypeError(f"Unrecognized keyword arguments: {str(kwargs)}")
 
         self.word_counts = collections.OrderedDict()
         self.word_docs = collections.defaultdict(int)

keras/src/models/functional.py

@@ -773,7 +773,7 @@ def is_input_keras_tensor(x):
 
 def clone_single_keras_tensor(x):
     return backend.KerasTensor(
-        shape=x.shape, dtype=x.dtype, sparse=x.sparse, name=x.name + "_clone"
+        shape=x.shape, dtype=x.dtype, sparse=x.sparse, name=f"{x.name}_clone"
     )
 
 
@@ -836,7 +836,7 @@ def clone_graph_nodes(inputs, outputs):
                 batch_shape=kt_input.shape,
                 dtype=kt_input.dtype,
                 sparse=kt_input.sparse,
-                name=kt_input.name + "CLONE",
+                name=f"{kt_input.name}CLONE",
             )
             cloned_inputs.append(cloned_input)
             kt_id_mapping[id(kt_input)] = cloned_input

keras/src/models/model.py

@@ -8,6 +8,7 @@ from keras.src import utils
 from keras.src.api_export import keras_export
 from keras.src.layers.layer import Layer
 from keras.src.models.variable_mapping import map_saveable_variables
+from keras.src.quantizers.gptq_config import GPTQConfig
 from keras.src.saving import saving_api
 from keras.src.trainers import trainer as base_trainer
 from keras.src.utils import summary_utils
@@ -420,7 +421,7 @@ class Model(Trainer, base_trainer.Trainer, Layer):
             **kwargs,
         )
 
-    def quantize(self, mode, **kwargs):
+    def quantize(self, mode, config=None, **kwargs):
         """Quantize the weights of the model.
 
         Note that the model must be built first before calling this method.
@@ -433,6 +434,23 @@ class Model(Trainer, base_trainer.Trainer, Layer):
         """
         from keras.src.dtype_policies import QUANTIZATION_MODES
 
+        if mode == "gptq":
+            if not isinstance(config, GPTQConfig):
+                raise ValueError(
+                    "The `config` argument must be of type "
+                    "`keras.quantizers.GPTQConfig`."
+                )
+            # The config object's own quantize method drives the process
+            config.quantize(self)
+            return
+
+        # For all other modes, verify that a config object was not passed.
+        if config is not None:
+            raise ValueError(
+                f"The `config` argument is only supported for 'gptq' mode, "
+                f"but received mode='{mode}'."
+            )
+
         type_check = kwargs.pop("type_check", True)
         if kwargs:
             raise ValueError(
@@ -854,9 +872,9 @@ class Model(Trainer, base_trainer.Trainer, Layer):
         def _flatten(current_dict, prefix=""):
             for key, value in current_dict.items():
                 if isinstance(value, dict):
-                    _flatten(value, prefix + key + "/")
+                    _flatten(value, f"{prefix}{key}/")
                 else:
-                    flat_dict[prefix + key] = value
+                    flat_dict[f"{prefix}{key}"] = value
 
         _flatten(nested_dict)
         return flat_dict

keras/src/ops/function.py

@@ -244,7 +244,7 @@ class Function(Operation):
 
 
 def make_node_key(op, node_index):
-    return str(id(op)) + "_ib-" + str(node_index)
+    return f"{id(op)}_ib-{node_index}"
 
 
 def map_graph(inputs, outputs):

keras/src/ops/numpy.py

@@ -2872,7 +2872,7 @@ class Einsum(Operation):
         kept_dims = sorted(kept_dims)
 
         if output_spec is None:
-            target_broadcast_spec = "..." + "".join(kept_dims)
+            target_broadcast_spec = f"...{''.join(kept_dims)}"
         else:
             target_broadcast_spec = output_spec
 
@@ -2894,18 +2894,18 @@ class Einsum(Operation):
                     )
                 for size, s in zip(x_shape, split_spec[0]):
                     # Replace the letter with the right shape.
-                    expanded_shape = expanded_shape.replace(s, str(size) + " ")
+                    expanded_shape = expanded_shape.replace(s, f"{str(size)} ")
                 expanded_shape = expanded_shape.replace("...", "")
             else:
                 # In this case, the input spec has "...", e.g., "i...j", "i...",
                 # or "...j".
                 for i in range(len(split_spec[0])):
                     expanded_shape = expanded_shape.replace(
-                        split_spec[0][i], str(x_shape[i]) + " "
+                        split_spec[0][i], f"{x_shape[i]} "
                     )
                 for i in range(len(split_spec[1])):
                     expanded_shape = expanded_shape.replace(
-                        split_spec[1][-i - 1], str(x_shape[-i - 1]) + " "
+                        split_spec[1][-i - 1], f"{x_shape[-i - 1]} "
                     )
                 # Shape matched by "..." will be inserted to the position of
                 # "...".
@@ -2919,7 +2919,7 @@ class Einsum(Operation):
                     wildcard_shape_start_index:wildcard_shape_end_index
                 ]
                 wildcard_shape_str = (
-                    " ".join([str(size) for size in wildcard_shape]) + " "
+                    f"{' '.join([str(size) for size in wildcard_shape])} "
                 )
                 expanded_shape = expanded_shape.replace(
                     "...", wildcard_shape_str
@@ -3514,6 +3514,50 @@ def hstack(xs):
     return backend.numpy.hstack(xs)
 
 
+class Hypot(Operation):
+    def call(self, x1, x2):
+        return backend.numpy.hypot(x1, x2)
+
+    def compute_output_spec(self, x1, x2):
+        dtype = dtypes.result_type(x1.dtype, x2.dtype)
+        if dtype in ["int8", "int16", "int32", "uint8", "uint16", "uint32"]:
+            dtype = backend.floatx()
+        elif dtype == "int64":
+            dtype = "float64"
+        return KerasTensor(broadcast_shapes(x1.shape, x2.shape), dtype=dtype)
+
+
+@keras_export(["keras.ops.hypot", "keras.ops.numpy.hypot"])
+def hypot(x1, x2):
+    """Element-wise hypotenuse of right triangles with legs `x1` and `x2`.
+
+    This is equivalent to computing `sqrt(x1**2 + x2**2)` element-wise,
+    with shape determined by broadcasting.
+
+    Args:
+        x1: A tensor, representing the first leg of the right triangle.
+        x2: A tensor, representing the second leg of the right triangle.
+
+    Returns:
+        A tensor with a shape determined by broadcasting `x1` and `x2`.
+
+    Example:
+    >>> x1 = keras.ops.convert_to_tensor([3.0, 4.0, 5.0])
+    >>> x2 = keras.ops.convert_to_tensor([4.0, 3.0, 12.0])
+    >>> keras.ops.hypot(x1, x2)
+    array([5., 5., 13.], dtype=float32)
+
+    >>> x1 = keras.ops.convert_to_tensor([[1, 2], [3, 4]])
+    >>> x2 = keras.ops.convert_to_tensor([1, 1])
+    >>> keras.ops.hypot(x1, x2)
+    array([[1.41421356 2.23606798],
+          [3.16227766 4.12310563]], dtype=float32)
+    """
+    if any_symbolic_tensors((x1, x2)):
+        return Hypot().symbolic_call(x1, x2)
+    return backend.numpy.hypot(x1, x2)
+
+
 @keras_export(["keras.ops.identity", "keras.ops.numpy.identity"])
 def identity(n, dtype=None):
     """Return the identity tensor.

keras/src/ops/operation.py

@@ -1,4 +1,5 @@
 import inspect
+import os.path
 import textwrap
 
 from keras.src import backend
@@ -19,10 +20,10 @@ class Operation(KerasSaveable):
     def __init__(self, name=None):
         if name is None:
             name = auto_name(self.__class__.__name__)
-        if not isinstance(name, str) or "/" in name:
+        if not isinstance(name, str) or os.path.sep in name:
             raise ValueError(
                 "Argument `name` must be a string and "
-                "cannot contain character `/`. "
+                f"cannot contain character `{os.path.sep}`. "
                 f"Received: name={name} (of type {type(name)})"
             )
         self.name = name

keras/src/optimizers/base_optimizer.py

@@ -310,13 +310,12 @@ class BaseOptimizer(KerasSaveable):
         """
         name = name or "var"
         if hasattr(reference_variable, "path"):
-            name = reference_variable.path.replace("/", "_") + "_" + name
+            name = f"{reference_variable.path.replace('/', '_')}_{name}"
         else:
-            name = (
+            sanitised_ref_name = (
                 str(reference_variable.name).replace("/", "_").replace(":", "_")
-                + "_"
-                + name
             )
+            name = f"{sanitised_ref_name}_{name}"
         return self.add_variable(
             shape=reference_variable.shape,
             initializer=initializer,

keras/src/optimizers/schedules/learning_rate_schedule.py

@@ -692,9 +692,11 @@ class CosineDecay(LearningRateSchedule):
 
     def _decay_function(self, step, decay_steps, decay_from_lr, dtype):
         with ops.name_scope(self.name):
-            completed_fraction = step / decay_steps
+            completed_fraction = ops.divide(step, decay_steps)
             pi = ops.array(math.pi, dtype=dtype)
-            cosine_decayed = 0.5 * (1.0 + ops.cos(pi * completed_fraction))
+            cosine_decayed = 0.5 * (
+                1.0 + ops.cos(ops.multiply(pi, completed_fraction))
+            )
             decayed = (1 - self.alpha) * cosine_decayed + self.alpha
             return ops.multiply(decay_from_lr, decayed)
 
@@ -866,10 +868,13 @@ class CosineDecayRestarts(LearningRateSchedule):
                         / ops.log(t_mul)
                     )
 
-                    sum_r = (1.0 - t_mul**i_restart) / (1.0 - t_mul)
-                    completed_fraction = (
-                        completed_fraction - sum_r
-                    ) / t_mul**i_restart
+                    sum_r = ops.divide(
+                        1.0 - ops.power(t_mul, i_restart), (1.0 - t_mul)
+                    )
+                    completed_fraction = ops.divide(
+                        ops.subtract(completed_fraction, sum_r),
+                        ops.power(t_mul, i_restart),
+                    )
 
                 else:
                     i_restart = ops.floor(completed_fraction)
@@ -883,18 +888,20 @@ class CosineDecayRestarts(LearningRateSchedule):
                 lambda: compute_step(completed_fraction, geometric=True),
             )
 
-            m_fac = m_mul**i_restart
+            m_fac = ops.power(m_mul, i_restart)
             cosine_decayed = (
                 0.5
                 * m_fac
                 * (
                     1.0
                     + ops.cos(
-                        ops.array(math.pi, dtype=dtype) * completed_fraction
+                        ops.multiply(
+                            ops.array(math.pi, dtype=dtype), completed_fraction
+                        )
                     )
                 )
             )
-            decayed = (1 - alpha) * cosine_decayed + alpha
+            decayed = ops.add(ops.multiply((1 - alpha), cosine_decayed), alpha)
 
             return ops.multiply(initial_learning_rate, decayed)