keras-nightly 3.12.0.dev2025092403__py3-none-any.whl → 3.14.0.dev2026010104__py3-none-any.whl

keras/src/quantizers/quantizers.py

@@ -73,6 +73,23 @@ def abs_max_quantize(
     epsilon=backend.epsilon(),
     to_numpy=False,
 ):
+    """
+    Quantizes the input tensor using the absolute maximum quantization scheme.
+
+    Args:
+        inputs: Input tensor to quantize.
+        axis: Axis along which to compute the quantization range.
+        value_range: Tuple of the minimum and maximum values of the quantization
+            range.
+        dtype: Data type of the quantized output.
+        epsilon: Small value to avoid division by zero.
+        to_numpy: Whether to perform the quantization in numpy. This performs
+            the computation on the host CPU and can be useful for saving memory
+            on the device. If False, the computation is performed on the device.
+
+    Returns:
+        A tuple of the quantized tensor and the scale.
+    """
     if to_numpy:
         # Save memory on the device using numpy
         original_dtype = backend.standardize_dtype(inputs.dtype)
@@ -105,31 +122,69 @@ def abs_max_quantize(
 class AbsMaxQuantizer(Quantizer):
     def __init__(
         self,
-        axis,
+        axis=None,  # Deprecated, provide axis in __call__ instead.
         value_range=(-127, 127),
         epsilon=backend.epsilon(),
         output_dtype="int8",
     ):
         Quantizer.__init__(self, output_dtype=output_dtype)
-        if isinstance(axis, int):
-            axis = (axis,)
-        self.axis = tuple(axis)
+        if axis is not None:
+            if isinstance(axis, int):
+                axis = (axis,)
+            self.axis = tuple(axis)
+        else:
+            self.axis = None
         self.value_range = value_range
         self.epsilon = epsilon
+        if output_dtype == "int8":
+            if value_range[0] < -128 or value_range[1] > 127:
+                raise ValueError(
+                    f"Quantizer with output_dtype='int8' requires value_range "
+                    f"to be within the interval [-128, 127]. Received: "
+                    f"value_range={value_range}"
+                )
 
-    def __call__(self, x):
+    def __call__(self, x, axis=None, to_numpy=False):
+        """
+        Quantizes the input tensor.
+
+        Args:
+            x: Input tensor to quantize.
+            axis: Axis along which to compute the quantization range. If None,
+                uses the axis specified in the constructor. If None and no axis
+                was specified in the constructor, defaults to -1.
+            to_numpy: Whether to perform the quantization in numpy. This
+                performs the computation on the host CPU and can be useful for
+                saving memory on the device. If False, the computation is
+                performed on the device.
+
+        Returns:
+            A tuple of the quantized tensor and the scale.
+        """
+        if axis is None:
+            axis = self.axis
+        if axis is None:
+            # Default to -1 if no axis is specified
+            axis = -1
         quantized_x, scale = abs_max_quantize(
-            x, self.axis, self.value_range, self.output_dtype, self.epsilon
+            x,
+            axis,
+            self.value_range,
+            self.output_dtype,
+            self.epsilon,
+            to_numpy,
         )
         return quantized_x, scale
 
     def get_config(self):
-        return {
-            "axis": self.axis,
+        config = {
             "value_range": self.value_range,
             "epsilon": self.epsilon,
             "output_dtype": self.output_dtype,
         }
+        if self.axis is not None:
+            config["axis"] = self.axis
+        return config
 
 
 def adjust_and_nudge(min_range, max_range, num_bits, narrow_range):
@@ -281,7 +336,7 @@ def fake_quant_with_min_max_vars(
             ops.add(ops.multiply(-nudged_min, inv_scale), 0.5)
         )
         x_clamped = ops.clip(
-            x, ops.cast(nudged_min, x.dtype), ops.cast(nudged_max, x.dtype)
+            ops.cast(x, nudged_min.dtype), nudged_min, nudged_max
         )
         x_clamped_shifted = ops.subtract(x_clamped, nudged_min)
         result = ops.multiply(
@@ -318,6 +373,7 @@ def fake_quant_with_min_max_vars(
                 grad_min = ops.sum(grad_min, axis=axes)
             else:
                 grad_min = ops.sum(grad_min)
+            grad_min = ops.reshape(grad_min, ops.shape(min_val))
 
             # Gradient for max_val
             # When x is clipped to max, the gradient flows to max_val
@@ -327,6 +383,7 @@ def fake_quant_with_min_max_vars(
                 grad_max = ops.sum(grad_max, axis=axes)
             else:
                 grad_max = ops.sum(grad_max)
+            grad_max = ops.reshape(grad_max, ops.shape(max_val))
 
             return dx, grad_min, grad_max
 
@@ -378,7 +435,7 @@ def quantize_and_dequantize(inputs, scale, quantized_dtype, compute_dtype):
 
 
 @keras_export("keras.quantizers.pack_int4")
-def pack_int4(arr, axis=0):
+def pack_int4(arr, axis=0, dtype="int8"):
     """Pack an int4 tensor into an int8 tensor with packed nibbles.
 
     The input values must already be int8 in the signed range `[-8, 7]` and
@@ -390,8 +447,11 @@ def pack_int4(arr, axis=0):
     the value from the second row.
 
     Args:
-        arr: An int8 tensor containing int4 values in the range `[-8, 7]`.
+        arr: An `int8` or `uint8` tensor containing int4 values in the range
+            `[-8, 7]`.
         axis: The axis along which to pack the tensor. Defaults to 0.
+        dtype: The data type of the input and packed tensor. Can be
+            `"int8"` or `"uint8"`. Defaults to `"int8"`.
 
     Returns:
         tuple: A tuple `(packed, packed_shape, orig_rows)` where `packed` is
@@ -451,9 +511,14 @@ def pack_int4(arr, axis=0):
     True
     ```
     """
-    if backend.standardize_dtype(arr.dtype) != "int8":
+    if dtype not in ("int8", "uint8"):
+        raise ValueError(
+            f"Expected dtype to be 'int8' or 'uint8', but got '{dtype}'."
+        )
+    if backend.standardize_dtype(arr.dtype) != dtype:
         raise TypeError(
-            "Expected int8 tensor for packing, got {}".format(arr.dtype)
+            f"Expected {dtype} tensor for packing, got "
+            f"{backend.standardize_dtype(arr.dtype)}."
         )
 
     rank = getattr(arr.shape, "rank", None) or len(arr.shape)
@@ -487,12 +552,12 @@ def pack_int4(arr, axis=0):
     low = padded[::2, ...]
     high = padded[1::2, ...]
 
-    mask = ops.array(0x0F, dtype="int8")
+    mask = ops.array(0x0F, dtype=dtype)
     low_u = ops.bitwise_and(low, mask)
     high_u = ops.bitwise_and(high, mask)
 
     packed = ops.bitwise_or(low_u, ops.left_shift(high_u, 4))
-    packed = ops.cast(packed, "int8")
+    packed = ops.cast(packed, dtype)
 
     # 5-6. Restore shape.
     packed = ops.transpose(packed, inv_perm)  # back to original order
@@ -501,7 +566,7 @@ def pack_int4(arr, axis=0):
 
 
 @keras_export("keras.quantizers.unpack_int4")
-def unpack_int4(packed, orig_len, axis=0):
+def unpack_int4(packed, orig_len, axis=0, dtype="int8"):
     """Unpack a packed int4 back to an int8 tensor in the range [-8, 7].
 
     This function reverses the packing performed by `pack_int4`, restoring
@@ -519,6 +584,8 @@ def unpack_int4(packed, orig_len, axis=0):
             packed. This is used to remove any padding that may have
             been added during packing to ensure an even number of rows.
         axis: The axis along which the tensor was packed. Defaults to 0.
+        dtype: The data type of the input and unpacked tensor. Can be
+            `"int8"` or `"uint8"`. Defaults to `"int8"`.
 
     Returns:
         unpacked: An int8 tensor with the same shape as the original
@@ -575,13 +642,24 @@ def unpack_int4(packed, orig_len, axis=0):
     True
     ```
     """
-    if backend.standardize_dtype(packed.dtype) != "int8":
+    if dtype not in ("int8", "uint8"):
+        raise ValueError(
+            f"Expected dtype to be 'int8' or 'uint8', but got '{dtype}'."
+        )
+
+    if backend.standardize_dtype(packed.dtype) not in ("int8", "uint8"):
         raise TypeError(
-            f"Expected int8 tensor for unpacking, got {packed.dtype}"
+            f"Expected int8 or uint8 tensor for unpacking, got {packed.dtype}"
         )
 
-    rank = getattr(packed.shape, "rank", None) or len(packed.shape)
+    def to_signed(x):
+        """Converts unpacked nibbles [0, 15] to signed int4 [-8, 7]."""
+        dtype_x = backend.standardize_dtype(x.dtype)
+        eight = ops.cast(8, dtype_x)
+        sixteen = ops.cast(16, dtype_x)
+        return ops.where(x < eight, x, x - sixteen)
 
+    rank = getattr(packed.shape, "rank", None) or len(packed.shape)
     if axis < 0:
         axis += rank
 
@@ -592,16 +670,15 @@ def unpack_int4(packed, orig_len, axis=0):
         low_unpacked = ops.bitwise_and(packed, mask)
         high_unpacked = ops.bitwise_and(ops.right_shift(packed, 4), mask)
 
-        # Convert values from [0, 15] to [-8, 7].
-        low_signed = ops.where(
-            low_unpacked < 8, low_unpacked, low_unpacked - 16
-        )
-        high_signed = ops.where(
-            high_unpacked < 8, high_unpacked, high_unpacked - 16
-        )
+        if dtype == "int8":
+            low_unpacked = to_signed(low_unpacked)
+            high_unpacked = to_signed(high_unpacked)
+
+        low_final = ops.cast(low_unpacked, dtype)
+        high_final = ops.cast(high_unpacked, dtype)
 
         # Interleave and reshape
-        stacked = ops.stack([low_signed, high_signed], axis=1)
+        stacked = ops.stack([low_final, high_final], axis=1)
         unpacked = ops.reshape(stacked, (-1,) + tuple(ops.shape(packed)[1:]))
 
         # Remove padding and return
@@ -613,28 +690,27 @@ def unpack_int4(packed, orig_len, axis=0):
     transposed = ops.transpose(packed, perm)
 
     # 1. Split nibbles.
-    mask = ops.array(0x0F, dtype="int8")  # int8 arrays
+    mask = ops.array(0x0F, dtype=packed.dtype)
     low = ops.bitwise_and(transposed, mask)
     high = ops.bitwise_and(ops.right_shift(transposed, 4), mask)
 
-    eight = ops.array(8, dtype="int8")
-    sixteen = ops.array(16, dtype="int8")
-
-    def to_signed(x):
-        return ops.where(x < eight, x, x - sixteen)
+    # 2. Conditionally convert to signed.
+    if dtype == "int8":
+        low = to_signed(low)
+        high = to_signed(high)
 
-    low = to_signed(low)
-    high = to_signed(high)
+    low = ops.cast(low, dtype)
+    high = ops.cast(high, dtype)
 
-    # 2. Interleave and reshape.
-    stacked = ops.stack([low, high], axis=1)  # (pairs, 2, ...)
+    # 3. Interleave and reshape.
+    stacked = ops.stack([low, high], axis=1)
     unpacked = ops.reshape(stacked, (-1,) + tuple(ops.shape(transposed)[1:]))
 
     # 4. Remove padding and restore original layout.
     unpacked = unpacked[:orig_len, ...]
     unpacked = ops.transpose(unpacked, inv_perm)
 
-    return unpacked  # dtype is int8
+    return unpacked
 
 
 class GPTQQuantizer(Quantizer):

keras/src/quantizers/utils.py

@@ -0,0 +1,23 @@
+import re
+
+
+def should_quantize_layer(layer, filters):
+    """Determines if a layer should be quantized based on filters.
+
+    Args:
+        layer: The layer to check.
+        filters: A regex string, a list of regex strings, or a callable.
+            If None, returns True.
+
+    Returns:
+        True if the layer should be quantized, False otherwise.
+    """
+    if filters is None:
+        return True
+    if isinstance(filters, str):
+        return bool(re.search(filters, layer.name))
+    if isinstance(filters, (list, tuple)):
+        return any(re.search(pat, layer.name) for pat in filters)
+    if callable(filters):
+        return filters(layer)
+    return True

keras/src/random/seed_generator.py

@@ -8,6 +8,8 @@ from keras.src.backend.common import global_state
 from keras.src.utils import jax_utils
 from keras.src.utils.naming import auto_name
 
+GLOBAL_SEED_GENERATOR = "global_seed_generator"
+
 
 @keras_export("keras.random.SeedGenerator")
 class SeedGenerator:
@@ -133,10 +135,10 @@ def global_seed_generator():
             "out = keras.random.normal(shape=(1,), seed=self.seed_generator)\n"
             "```"
         )
-    gen = global_state.get_global_attribute("global_seed_generator")
+    gen = global_state.get_global_attribute(GLOBAL_SEED_GENERATOR)
     if gen is None:
         gen = SeedGenerator()
-        global_state.set_global_attribute("global_seed_generator", gen)
+        global_state.set_global_attribute(GLOBAL_SEED_GENERATOR, gen)
     return gen
 
 

keras/src/saving/file_editor.py

@@ -455,6 +455,9 @@ class KerasFileEditor:
     def _extract_weights_from_store(self, data, metadata=None, inner_path=""):
         metadata = metadata or {}
 
+        # ------------------------------------------------------
+        # Collect metadata for this HDF5 group
+        # ------------------------------------------------------
         object_metadata = {}
         for k, v in data.attrs.items():
             object_metadata[k] = v
@@ -462,26 +465,98 @@ class KerasFileEditor:
             metadata[inner_path] = object_metadata
 
         result = collections.OrderedDict()
+
+        # ------------------------------------------------------
+        # Iterate over all keys in this HDF5 group
+        # ------------------------------------------------------
         for key in data.keys():
-            inner_path = f"{inner_path}/{key}"
+            # IMPORTANT:
+            # Never mutate inner_path; use local variable.
+            current_inner_path = f"{inner_path}/{key}"
             value = data[key]
+
+            # ------------------------------------------------------
+            # CASE 1 — HDF5 GROUP → RECURSE
+            # ------------------------------------------------------
             if isinstance(value, h5py.Group):
+                # Skip empty groups
                 if len(value) == 0:
                     continue
+
+                # Skip empty "vars" groups
                 if "vars" in value.keys() and len(value["vars"]) == 0:
                     continue
 
-            if hasattr(value, "keys"):
+                # Recurse into "vars" subgroup when present
                 if "vars" in value.keys():
                     result[key], metadata = self._extract_weights_from_store(
-                        value["vars"], metadata=metadata, inner_path=inner_path
+                        value["vars"],
+                        metadata=metadata,
+                        inner_path=current_inner_path,
                     )
                 else:
+                    # Recurse normally
                     result[key], metadata = self._extract_weights_from_store(
-                        value, metadata=metadata, inner_path=inner_path
+                        value,
+                        metadata=metadata,
+                        inner_path=current_inner_path,
                     )
-            else:
-                result[key] = value[()]
+
+                continue  # finished processing this key
+
+            # ------------------------------------------------------
+            # CASE 2 — HDF5 DATASET → SAFE LOADING
+            # ------------------------------------------------------
+
+            # Skip any objects that are not proper datasets
+            if not hasattr(value, "shape") or not hasattr(value, "dtype"):
+                continue
+
+            shape = value.shape
+            dtype = value.dtype
+
+            # ------------------------------------------------------
+            # Validate SHAPE (avoid malformed / malicious metadata)
+            # ------------------------------------------------------
+
+            # No negative dimensions
+            if any(dim < 0 for dim in shape):
+                raise ValueError(
+                    "Malformed HDF5 dataset shape encountered in .keras file; "
+                    "negative dimension detected."
+                )
+
+            # Prevent absurdly high-rank tensors
+            if len(shape) > 64:
+                raise ValueError(
+                    "Malformed HDF5 dataset shape encountered in .keras file; "
+                    "tensor rank exceeds safety limit."
+                )
+
+            # Safe product computation (Python int is unbounded)
+            num_elems = int(np.prod(shape))
+
+            # ------------------------------------------------------
+            # Validate TOTAL memory size
+            # ------------------------------------------------------
+            MAX_BYTES = 1 << 32  # 4 GiB
+
+            size_bytes = num_elems * dtype.itemsize
+
+            if size_bytes > MAX_BYTES:
+                raise ValueError(
+                    f"HDF5 dataset too large to load safely "
+                    f"({size_bytes} bytes; limit is {MAX_BYTES})."
+                )
+
+            # ------------------------------------------------------
+            # SAFE — load dataset (guaranteed ≤ 4 GiB)
+            # ------------------------------------------------------
+            result[key] = value[()]
+
+        # ------------------------------------------------------
+        # Return final tree and metadata
+        # ------------------------------------------------------
         return result, metadata
 
     def _generate_filepath_info(self, rich_style=False):

keras/src/saving/saving_lib.py

@@ -943,7 +943,7 @@ class DiskIOStore:
         if self.archive:
             self.tmp_dir = get_temp_dir()
             if self.mode == "r":
-                self.archive.extractall(path=self.tmp_dir)
+                file_utils.extract_open_archive(self.archive, self.tmp_dir)
             self.working_dir = file_utils.join(
                 self.tmp_dir, self.root_path
             ).replace("\\", "/")

keras/src/testing/__init__.py

@@ -3,3 +3,4 @@ from keras.src.testing.test_case import jax_uses_gpu
 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
+from keras.src.testing.test_case import uses_tpu

keras/src/testing/test_case.py

@@ -40,7 +40,20 @@ class TestCase(parameterized.TestCase, unittest.TestCase):
         self.addCleanup(lambda: shutil.rmtree(temp_dir))
         return temp_dir
 
-    def assertAllClose(self, x1, x2, atol=1e-6, rtol=1e-6, msg=None):
+    def assertAllClose(
+        self,
+        x1,
+        x2,
+        atol=1e-6,
+        rtol=1e-6,
+        tpu_atol=None,
+        tpu_rtol=None,
+        msg=None,
+    ):
+        if tpu_atol is not None and uses_tpu():
+            atol = tpu_atol
+        if tpu_rtol is not None and uses_tpu():
+            rtol = tpu_rtol
         if not isinstance(x1, np.ndarray):
             x1 = backend.convert_to_numpy(x1)
         if not isinstance(x2, np.ndarray):
@@ -57,7 +70,9 @@ class TestCase(parameterized.TestCase, unittest.TestCase):
             f"The two values are close at all elements. \n{msg}.\nValues: {x1}"
         )
 
-    def assertAlmostEqual(self, x1, x2, decimal=3, msg=None):
+    def assertAlmostEqual(self, x1, x2, decimal=3, tpu_decimal=None, msg=None):
+        if tpu_decimal is not None and uses_tpu():
+            decimal = tpu_decimal
         msg = msg or ""
         if not isinstance(x1, np.ndarray):
             x1 = backend.convert_to_numpy(x1)
@@ -195,6 +210,8 @@ class TestCase(parameterized.TestCase, unittest.TestCase):
         run_training_check=True,
         run_mixed_precision_check=True,
         assert_built_after_instantiation=False,
+        tpu_atol=None,
+        tpu_rtol=None,
     ):
         """Run basic checks on a layer.
 
@@ -376,7 +393,9 @@ class TestCase(parameterized.TestCase, unittest.TestCase):
                     msg="Unexpected number of torch_params",
                 )
 
-        def run_output_asserts(layer, output, eager=False):
+        def run_output_asserts(
+            layer, output, eager=False, tpu_atol=None, tpu_rtol=None
+        ):
             if expected_output_shape is not None:
 
                 def verify_shape(expected_shape, x):
@@ -422,7 +441,11 @@ class TestCase(parameterized.TestCase, unittest.TestCase):
                         tree.flatten(expected_output), tree.flatten(output)
                     ):
                         self.assertAllClose(
-                            ref_v, v, msg="Unexpected output value"
+                            ref_v,
+                            v,
+                            msg="Unexpected output value",
+                            tpu_atol=tpu_atol,
+                            tpu_rtol=tpu_rtol,
                         )
                 if expected_num_losses is not None:
                     self.assertLen(layer.losses, expected_num_losses)
@@ -551,7 +574,13 @@ class TestCase(parameterized.TestCase, unittest.TestCase):
                 output_data = layer(**input_data, **call_kwargs)
             else:
                 output_data = layer(input_data, **call_kwargs)
-            run_output_asserts(layer, output_data, eager=True)
+            run_output_asserts(
+                layer,
+                output_data,
+                eager=True,
+                tpu_atol=tpu_atol,
+                tpu_rtol=tpu_rtol,
+            )
 
             if run_training_check:
                 run_training_step(layer, input_data, output_data)
@@ -621,6 +650,17 @@ def uses_gpu():
     return False
 
 
+def uses_tpu():
+    # Condition used to skip tests when using the TPU
+    try:
+        devices = distribution.list_devices()
+        if any(d.startswith("tpu") for d in devices):
+            return True
+    except AttributeError:
+        return False
+    return False
+
+
 def uses_cpu():
     devices = distribution.list_devices()
     if any(d.startswith("cpu") for d in devices):

keras/src/trainers/compile_utils.py

@@ -148,6 +148,7 @@ class CompileMetrics(metrics_module.Metric):
         self.built = False
         self.name = "compile_metrics"
         self.output_names = output_names
+        self._resolved_output_names = None
 
     @property
     def metrics(self):
@@ -175,10 +176,16 @@ class CompileMetrics(metrics_module.Metric):
 
     def build(self, y_true, y_pred):
         num_outputs = 1  # default
-        if self.output_names:
+        # Resolve output names. If y_pred is a dict, prefer its keys.
+        if isinstance(y_pred, dict):
+            keys = sorted(list(y_pred.keys()))
+            if self.output_names and set(self.output_names) == set(keys):
+                # If there is a perfect match, use the user-provided order.
+                output_names = self.output_names
+            else:
+                output_names = keys
+        elif self.output_names:
             output_names = self.output_names
-        elif isinstance(y_pred, dict):
-            output_names = sorted(list(y_pred.keys()))
         elif isinstance(y_pred, (list, tuple)):
             num_outputs = len(y_pred)
             if all(hasattr(x, "_keras_history") for x in y_pred):
@@ -187,6 +194,7 @@ class CompileMetrics(metrics_module.Metric):
                 output_names = None
         else:
             output_names = None
+        self._resolved_output_names = output_names
         if output_names:
             num_outputs = len(output_names)
 
@@ -316,9 +324,10 @@ class CompileMetrics(metrics_module.Metric):
         return flat_metrics
 
     def _flatten_y(self, y):
-        if isinstance(y, dict) and self.output_names:
+        names = self._resolved_output_names
+        if isinstance(y, dict) and names:
             result = []
-            for name in self.output_names:
+            for name in names:
                 if name in y:
                     result.append(y[name])
             return result

keras/src/utils/backend_utils.py

@@ -3,6 +3,7 @@ import importlib
 import inspect
 import os
 import sys
+import warnings
 
 from keras.src import backend as backend_module
 from keras.src.api_export import keras_export
@@ -124,9 +125,22 @@ def set_backend(backend):
 
     Example:
 
-    ```python
-    keras.config.set_backend("jax")
-    ```
+    >>> import os
+    >>> os.environ["KERAS_BACKEND"] = "tensorflow"
+    >>>
+    >>> import keras
+    >>> from keras import ops
+    >>> type(ops.ones(()))
+    <class 'tensorflow.python.framework.ops.EagerTensor'>
+    >>>
+    >>> keras.config.set_backend("jax")
+    UserWarning: Using `keras.config.set_backend` is dangerous...
+    >>> del keras, ops
+    >>>
+    >>> import keras
+    >>> from keras import ops
+    >>> type(ops.ones(()))
+    <class 'jaxlib.xla_extension.ArrayImpl'>
 
     ⚠️ WARNING ⚠️: Using this function is dangerous and should be done
     carefully. Changing the backend will **NOT** convert
@@ -138,7 +152,7 @@ def set_backend(backend):
 
     This includes any function or class instance that uses any Keras
     functionality. All such code needs to be re-executed after calling
-    `set_backend()`.
+    `set_backend()` and re-importing all imported `keras` modules.
     """
     os.environ["KERAS_BACKEND"] = backend
     # Clear module cache.
@@ -159,3 +173,16 @@ def set_backend(backend):
                 module_name = module_name[module_name.find("'") + 1 :]
                 module_name = module_name[: module_name.find("'")]
                 globals()[key] = importlib.import_module(module_name)
+
+    warnings.warn(
+        "Using `keras.config.set_backend` is dangerous and should be done "
+        "carefully. Already-instantiated objects will not be converted. Thus, "
+        "any layers / tensors / etc. already created will no longer be usable "
+        "without errors. It is strongly recommended not to keep around any "
+        "Keras-originated objects instances created before calling "
+        "`set_backend()`. This includes any function or class instance that "
+        "uses any Keras functionality. All such code needs to be re-executed "
+        "after calling `set_backend()` and re-importing all imported `keras` "
+        "modules.",
+        stacklevel=2,
+    )