keras-nightly 3.14.0.dev2026012604__py3-none-any.whl → 3.14.0.dev2026012804__py3-none-any.whl

keras/_tf_keras/keras/ops/__init__.py

@@ -246,6 +246,7 @@ from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
+from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim

keras/_tf_keras/keras/ops/numpy/__init__.py

@@ -130,6 +130,7 @@ from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
+from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim

keras/ops/__init__.py

@@ -246,6 +246,7 @@ from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
+from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim

keras/ops/numpy/__init__.py

@@ -130,6 +130,7 @@ from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
 from keras.src.ops.numpy import nanmax as nanmax
+from keras.src.ops.numpy import nanmean as nanmean
 from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim

keras/src/backend/jax/numpy.py

@@ -1018,6 +1018,11 @@ def nanmax(x, axis=None, keepdims=False):
     return jnp.nanmax(x, axis=axis, keepdims=keepdims)
 
 
+def nanmean(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    return jnp.nanmean(x, axis=axis, keepdims=keepdims)
+
+
 def nanmin(x, axis=None, keepdims=False):
     x = convert_to_tensor(x)
     return jnp.nanmin(x, axis=axis, keepdims=keepdims)

keras/src/backend/numpy/numpy.py

@@ -964,6 +964,11 @@ def nanmax(x, axis=None, keepdims=False):
     return np.nanmax(x, axis=axis, keepdims=keepdims)
 
 
+def nanmean(x, axis=None, keepdims=False):
+    dtype = dtypes.result_type(standardize_dtype(x.dtype), float)
+    return np.nanmean(x, axis=axis, keepdims=keepdims).astype(dtype)
+
+
 def nanmin(x, axis=None, keepdims=False):
     return np.nanmin(x, axis=axis, keepdims=keepdims)
 

keras/src/backend/openvino/numpy.py

@@ -2111,6 +2111,12 @@ def nanmax(x, axis=None, keepdims=False):
     raise NotImplementedError("`nanmax` is not supported with openvino backend")
 
 
+def nanmean(x, axis=None, keepdims=False):
+    raise NotImplementedError(
+        "`nanmean` is not supported with openvino backend"
+    )
+
+
 def nanmin(x, axis=None, keepdims=False):
     raise NotImplementedError("`nanmin` is not supported with openvino backend")
 
@@ -2270,7 +2276,16 @@ def prod(x, axis=None, keepdims=False, dtype=None):
 
 
 def ptp(x, axis=None, keepdims=False):
-    raise NotImplementedError("`ptp` is not supported with openvino backend")
+    if axis == ():
+        return zeros_like(x)
+    x = get_ov_output(x)
+
+    x_resolved, resolved_axis = _resolve_axis(x, axis)
+
+    max_val = ov_opset.reduce_max(x_resolved, resolved_axis, keepdims)
+    min_val = ov_opset.reduce_min(x_resolved, resolved_axis, keepdims)
+
+    return OpenVINOKerasTensor(ov_opset.subtract(max_val, min_val).output(0))
 
 
 def quantile(x, q, axis=None, method="linear", keepdims=False):
@@ -2682,7 +2697,23 @@ def tensordot(x1, x2, axes=2):
 
 
 def round(x, decimals=0):
-    raise NotImplementedError("`round` is not supported with openvino backend")
+    x = get_ov_output(x)
+    x_type = x.get_element_type()
+    if x_type.is_integral() or x_type == Type.boolean:
+        x = ov_opset.convert(x, OPENVINO_DTYPES[config.floatx()])
+
+    if decimals == 0:
+        result = ov_opset.round(x, "half_to_even")
+    else:
+        factor = ov_opset.constant(10.0**decimals, x.get_element_type())
+        scaled = ov_opset.multiply(x, factor)
+        rounded = ov_opset.round(scaled, "half_to_even")
+        result = ov_opset.divide(rounded, factor)
+
+    if x_type.is_integral():
+        result = ov_opset.convert(result, x_type)
+
+    return OpenVINOKerasTensor(result.output(0))
 
 
 def tile(x, repeats):
@@ -2803,7 +2834,17 @@ def vdot(x1, x2):
 
 
 def vstack(xs):
-    raise NotImplementedError("`vstack` is not supported with openvino backend")
+    if not isinstance(xs, (list, tuple)):
+        xs = (xs,)
+    elems = [convert_to_tensor(elem) for elem in xs]
+    element_type = elems[0].output.get_element_type()
+    elems = [get_ov_output(elem, element_type) for elem in elems]
+    axis = 0
+    for i in range(1, len(elems)):
+        elems[0], elems[i] = _align_operand_types(
+            elems[0], elems[i], "vstack()"
+        )
+    return OpenVINOKerasTensor(ov_opset.concat(elems, axis).output(0))
 
 
 def vectorize(pyfunc, *, excluded=None, signature=None):
@@ -2859,9 +2900,20 @@ def divide(x1, x2):
 
 
 def divide_no_nan(x1, x2):
-    raise NotImplementedError(
-        "`divide_no_nan` is not supported with openvino backend"
-    )
+    element_type = None
+    if isinstance(x1, OpenVINOKerasTensor):
+        element_type = x1.output.get_element_type()
+    if isinstance(x2, OpenVINOKerasTensor):
+        element_type = x2.output.get_element_type()
+    x1 = get_ov_output(x1, element_type)
+    x2 = get_ov_output(x2, element_type)
+    x1, x2 = _align_operand_types(x1, x2, "divide_no_nan()")
+
+    zero = ov_opset.constant(0, x2.get_element_type())
+    div = ov_opset.divide(x1, x2)
+    is_zero = ov_opset.equal(x2, zero)
+    result = ov_opset.select(is_zero, zero, div)
+    return OpenVINOKerasTensor(result.output(0))
 
 
 def true_divide(x1, x2):

keras/src/backend/tensorflow/numpy.py

@@ -2145,6 +2145,27 @@ def nanmax(x, axis=None, keepdims=False):
     )
 
 
+def nanmean(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+
+    if axis == () or axis == []:
+        return x
+
+    if not x.dtype.is_floating:
+        return tf.reduce_mean(
+            tf.cast(x, "float32"), axis=axis, keepdims=keepdims
+        )
+
+    dtype = dtypes.result_type(standardize_dtype(x.dtype), float)
+    total_sum = cast(nansum(x, axis=axis, keepdims=keepdims), dtype)
+    normalizer = tf.reduce_sum(
+        cast(~tf.math.is_nan(x), dtype),
+        axis=axis,
+        keepdims=keepdims,
+    )
+    return tf.divide(total_sum, normalizer)
+
+
 def nanmin(x, axis=None, keepdims=False):
     x = convert_to_tensor(x)
 

keras/src/backend/torch/export.py

@@ -36,15 +36,31 @@ class TorchExportArchive:
             )
 
         sample_inputs = tree.map_structure(
-            lambda x: convert_spec_to_tensor(x, replace_none_number=1),
+            lambda x: convert_spec_to_tensor(x, replace_none_number=2),
             input_signature,
         )
         sample_inputs = tuple(sample_inputs)
 
+        # Build dynamic_shapes from input_signature where shape has None
+        # Use a shared "batch" dim for dimension 0 across all inputs
+        batch_dim = torch.export.Dim("batch", min=1)
+        dynamic_shapes = []
+        for spec in input_signature:
+            dim_spec = {}
+            for dim_idx, dim_val in enumerate(spec.shape):
+                if dim_val is None:
+                    if dim_idx == 0:
+                        dim_spec[dim_idx] = batch_dim
+                    else:
+                        dim_spec[dim_idx] = torch.export.Dim(
+                            f"dim_{len(dynamic_shapes)}_{dim_idx}", min=1
+                        )
+            dynamic_shapes.append(dim_spec if dim_spec else None)
+        dynamic_shapes = tuple(dynamic_shapes) if any(dynamic_shapes) else None
+
         # Ref: torch_xla.tf_saved_model_integration
-        # TODO: Utilize `dynamic_shapes`
         exported = torch.export.export(
-            resource, sample_inputs, dynamic_shapes=None, strict=False
+            resource, sample_inputs, dynamic_shapes=dynamic_shapes, strict=False
         )
         options = torch_xla.stablehlo.StableHLOExportOptions(
             override_tracing_arguments=sample_inputs

keras/src/backend/torch/numpy.py

@@ -1290,6 +1290,16 @@ def nanmax(x, axis=None, keepdims=False):
     )
 
 
+def nanmean(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+
+    if axis == () or axis == []:
+        return x
+
+    dtype = dtypes.result_type(standardize_dtype(x.dtype), float)
+    return torch.nanmean(cast(x, dtype), dim=axis, keepdim=keepdims)
+
+
 def nanmin(x, axis=None, keepdims=False):
     x = convert_to_tensor(x)
     if not torch.is_floating_point(x):

keras/src/layers/normalization/batch_normalization.py

@@ -8,6 +8,26 @@ from keras.src.layers.input_spec import InputSpec
 from keras.src.layers.layer import Layer
 
 
+# TODO(abheesht17): Move this to utils?
+def _clone_initializer(initializer):
+    """Clones an initializer to ensure a new seed.
+
+    Args:
+        initializer: The initializer to clone.
+
+    Returns:
+        A cloned initializer if it is clonable, otherwise the original one.
+
+    As of tensorflow 2.10, we need to clone user passed initializers when
+    invoking them twice to avoid creating the same randomized initialization.
+    """
+    if isinstance(initializer, initializers.Initializer):
+        config = initializer.get_config()
+        return initializer.__class__.from_config(config)
+    # If we get a string or dict, just return as we cannot and should not clone.
+    return initializer
+
+
 @keras_export("keras.layers.BatchNormalization")
 class BatchNormalization(Layer):
     """Layer that normalizes its inputs.
@@ -72,6 +92,22 @@ class BatchNormalization(Layer):
             variance) for the layer across all devices at each training step
             in a distributed training strategy.
             If `False`, each replica uses its own local batch statistics.
+        renorm: Whether to use
+            [Batch Renormalization](https://arxiv.org/abs/1702.03275). This
+            adds extra variables during training. The inference is the same
+            for either value of this parameter.
+        renorm_clipping: Dictionary, valid only if `renorm = True`.
+            Maps optional keys `"rmax"`, `"rmin"`, `"dmax"` to floats used to
+            clip the renorm correction. The correction `(r, d)` is used as
+            `corrected_value = normalized_value * r + d`, with `r` clipped to
+            `[rmin, rmax]`, and `d` to `[-dmax, dmax]`. Missing `rmax`, `rmin`,
+            `dmax` are set to `inf`, `0`, `inf`, respectively.
+        renorm_momentum: Momentum used to update the moving means and standard
+            deviations with renorm. Valid only if `renorm= True`. Unlike
+            `momentum`, this affects training and should be neither too small
+            (which would add noise) nor too large (which would give stale
+            estimates). Note that `momentum` is still applied to get the means
+            and variances for inference.
         **kwargs: Base layer keyword arguments (e.g. `name` and `dtype`).
 
     Call arguments:
@@ -136,6 +172,9 @@ class BatchNormalization(Layer):
         gamma_regularizer=None,
         beta_constraint=None,
         gamma_constraint=None,
+        renorm=False,
+        renorm_clipping=None,
+        renorm_momentum=0.99,
         synchronized=False,
         **kwargs,
     ):
@@ -165,6 +204,33 @@ class BatchNormalization(Layer):
         self.gamma_constraint = constraints.get(gamma_constraint)
         self.supports_masking = True
 
+        self.renorm = renorm
+        if renorm:
+            renorm_clipping = renorm_clipping or {}
+            keys = ["rmax", "rmin", "dmax"]
+            if set(renorm_clipping) - set(keys):
+                raise ValueError(
+                    "Received invalid keys for `renorm_clipping` argument: "
+                    f"{renorm_clipping}. Supported values: {keys}."
+                )
+            rmax = renorm_clipping.get("rmax")
+            rmin = renorm_clipping.get("rmin")
+            dmax = renorm_clipping.get("dmax")
+
+            if rmax is not None and rmin is not None and rmax < rmin:
+                raise ValueError(
+                    "rmax should be greater than rmin in the `renorm_clipping` "
+                    "argument. Received: rmax={rmax}, rmin={rmin}."
+                )
+            if dmax is not None and dmax < 0:
+                raise ValueError(
+                    "dmax should be non-negative in the `renorm_clipping` "
+                    """argument. Received: dmax={dmax}."""
+                )
+
+        self.renorm_clipping = renorm_clipping
+        self.renorm_momentum = renorm_momentum
+
         self.gamma = None
         self.beta = None
         self.moving_mean = None
@@ -208,6 +274,40 @@ class BatchNormalization(Layer):
             autocast=False,
         )
 
+        if self.renorm:
+            # In batch renormalization we track the inference moving stddev
+            # instead of the moving variance to more closely align with the
+            # paper. The stddev is initialized as sqrt of the variance
+            # initializer.
+            def moving_stddev_initializer(shape, dtype=None):
+                cloned = _clone_initializer(self.moving_variance_initializer)
+                return ops.sqrt(cloned(shape, dtype=dtype))
+
+            self.moving_stddev = self.add_weight(
+                shape=shape,
+                name="moving_stddev",
+                initializer=moving_stddev_initializer,
+                trainable=False,
+                autocast=False,
+            )
+            # Create variables to maintain the moving mean and standard
+            # deviation. These are used in training and thus are different
+            # from the moving averages above.
+            self.renorm_mean = self.add_weight(
+                shape=shape,
+                name="renorm_mean",
+                initializer=_clone_initializer(self.moving_mean_initializer),
+                trainable=False,
+                autocast=False,
+            )
+            self.renorm_stddev = self.add_weight(
+                shape=shape,
+                name="renorm_stddev",
+                initializer=moving_stddev_initializer,
+                trainable=False,
+                autocast=False,
+            )
+
         self.input_spec = InputSpec(
             ndim=len(input_shape), axes={self.axis: input_shape[self.axis]}
         )
@@ -250,20 +350,6 @@ class BatchNormalization(Layer):
         moving_mean = ops.cast(self.moving_mean, inputs.dtype)
         moving_variance = ops.cast(self.moving_variance, inputs.dtype)
 
-        if training and self.trainable:
-            mean, variance = self._moments(inputs, mask)
-
-            self.moving_mean.assign(
-                moving_mean * self.momentum + mean * (1.0 - self.momentum)
-            )
-            self.moving_variance.assign(
-                moving_variance * self.momentum
-                + variance * (1.0 - self.momentum)
-            )
-        else:
-            mean = moving_mean
-            variance = moving_variance
-
         if self.scale:
             gamma = ops.cast(self.gamma, inputs.dtype)
         else:
@@ -274,6 +360,39 @@ class BatchNormalization(Layer):
         else:
             beta = None
 
+        if training and self.trainable:
+            mean, variance = self._moments(inputs, mask)
+
+            if self.renorm:
+                # Compute renorm corrections (r and d).
+                (
+                    r,
+                    d,
+                    mean,
+                    variance,
+                ) = self._renorm_correction_and_moments(mean, variance)
+
+                # x = x * gamma + beta without renorm, and
+                # (x * r + d) * gamma + beta = x * (r * gamma) + (d * gamma +
+                # beta) with renorm.
+                gamma, beta = self._compose_transforms(
+                    r, d, gamma, beta, inputs.dtype
+                )
+
+                # Update moving statistics.
+                self._update_renorm_statistics(mean, variance)
+            else:
+                self.moving_mean.assign(
+                    moving_mean * self.momentum + mean * (1.0 - self.momentum)
+                )
+                self.moving_variance.assign(
+                    moving_variance * self.momentum
+                    + variance * (1.0 - self.momentum)
+                )
+        else:
+            mean = moving_mean
+            variance = moving_variance
+
         outputs = ops.batch_normalization(
             x=inputs,
             mean=mean,
@@ -306,6 +425,9 @@ class BatchNormalization(Layer):
             "beta_constraint": constraints.serialize(self.beta_constraint),
             "gamma_constraint": constraints.serialize(self.gamma_constraint),
             "synchronized": self.synchronized,
+            "renorm": self.renorm,
+            "renorm_clipping": self.renorm_clipping,
+            "renorm_momentum": self.renorm_momentum,
         }
         return {**base_config, **config}
 
@@ -346,3 +468,115 @@ class BatchNormalization(Layer):
         variance = weighted_distsq / (sum_of_weights + backend.epsilon())
 
         return ops.squeeze(mean), ops.squeeze(variance)
+
+    def _renorm_correction_and_moments(self, mean, variance):
+        """Computes the correction for batch renormalization.
+
+        This method computes the r and d correction factors.
+
+        Args:
+            mean: The mean of the current batch.
+            variance: The variance of the current batch.
+
+        Returns:
+            A tuple (r, s, mean, variance) where r and d are the correction
+            factors, and mean/variance are passed through unchanged.
+        """
+        stddev = ops.sqrt(variance + self.epsilon)
+
+        # Get the renorm moving statistics.
+        renorm_mean = ops.cast(self.renorm_mean, mean.dtype)
+        # Avoid divide by zero early on in training.
+        renorm_stddev = ops.maximum(
+            ops.cast(self.renorm_stddev, mean.dtype),
+            ops.sqrt(ops.cast(self.epsilon, mean.dtype)),
+        )
+
+        # Compute the corrections for batch renorm.
+        r = ops.divide(stddev, renorm_stddev)
+        d = ops.divide(ops.subtract(mean, renorm_mean), renorm_stddev)
+
+        # Apply clipping.
+        rmin = self.renorm_clipping.get("rmin")
+        rmax = self.renorm_clipping.get("rmax")
+        dmax = self.renorm_clipping.get("dmax")
+
+        if rmin is not None:
+            r = ops.maximum(r, rmin)
+        if rmax is not None:
+            r = ops.minimum(r, rmax)
+        if dmax is not None:
+            d = ops.clip(d, -dmax, dmax)
+
+        return r, d, mean, variance
+
+    def _compose_transforms(self, r, d, gamma, beta, dtype):
+        """Composes the renorm correction with gamma and beta.
+
+        When training with renorm, the normalized values (x) are transformed
+        as: (x * r + d) * gamma + beta = x * (r * gamma) + (d * gamma + beta).
+        This method computes the effective scale and offset.
+
+        Args:
+            r: The r correction factor.
+            d: The d correction factor.
+            gamma: The gamma (scale) parameter, or None.
+            beta: The beta (offset) parameter, or None.
+            dtype: The dtype for the output.
+
+        Returns:
+            A tuple (effective_gamma, effective_beta).
+        """
+        r = ops.stop_gradient(r)
+        d = ops.stop_gradient(d)
+
+        if gamma is not None:
+            effective_gamma = ops.multiply(r, gamma)
+            effective_beta = ops.multiply(d, gamma)
+        else:
+            effective_gamma = ops.cast(r, dtype)
+            effective_beta = ops.cast(d, dtype)
+
+        if beta is not None:
+            effective_beta = ops.add(effective_beta, beta)
+
+        return effective_gamma, effective_beta
+
+    def _update_renorm_statistics(self, mean, variance):
+        """Updates the renorm and moving statistics.
+        Args:
+            mean: The mean of the current batch.
+            variance: The variance of the current batch.
+        """
+        stddev = ops.sqrt(variance + self.epsilon)
+
+        # Update renorm moving mean and stddev.
+        renorm_mean = ops.cast(self.renorm_mean, mean.dtype)
+        renorm_stddev = ops.cast(self.renorm_stddev, mean.dtype)
+
+        self.renorm_mean.assign(
+            renorm_mean * self.renorm_momentum
+            + mean * (1.0 - self.renorm_momentum)
+        )
+        self.renorm_stddev.assign(
+            renorm_stddev * self.renorm_momentum
+            + stddev * (1.0 - self.renorm_momentum)
+        )
+
+        moving_mean = ops.cast(self.moving_mean, mean.dtype)
+        moving_stddev = ops.cast(self.moving_stddev, mean.dtype)
+
+        self.moving_mean.assign(
+            moving_mean * self.momentum + mean * (1.0 - self.momentum)
+        )
+
+        new_moving_stddev = moving_stddev * self.momentum + stddev * (
+            1.0 - self.momentum
+        )
+        self.moving_stddev.assign(new_moving_stddev)
+
+        # Derive `moving_variance` from `moving_stddev`, applying ReLU in case
+        # floating point rounding causes it to go negative.
+        self.moving_variance.assign(
+            ops.relu(new_moving_stddev * new_moving_stddev - self.epsilon)
+        )

keras/src/ops/numpy.py

@@ -5121,6 +5121,60 @@ def nanmax(x, axis=None, keepdims=False):
     return backend.numpy.nanmax(x, axis=axis, keepdims=keepdims)
 
 
+class Nanmean(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.nanmean(x, axis=self.axis, keepdims=self.keepdims)
+
+    def compute_output_spec(self, x):
+        dtype = dtypes.result_type(x.dtype, float)
+        return KerasTensor(
+            reduce_shape(x.shape, axis=self.axis, keepdims=self.keepdims),
+            dtype=dtype,
+        )
+
+
+@keras_export(["keras.ops.nanmean", "keras.ops.numpy.nanmean"])
+def nanmean(x, axis=None, keepdims=False):
+    """Mean of a tensor over the given axes, ignoring NaNs.
+
+    Args:
+        x: Input tensor.
+        axis: Axis or axes along which the mean is computed.
+            The default is to compute the mean 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. Defaults
+            to `False`.
+
+    Returns:
+        Output tensor containing the mean, with NaN values ignored.
+        If all values along a reduced axis are NaN, the result is NaN.
+
+    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.nanmean(x)
+    1.75
+
+    >>> ops.nanmean(x, axis=1)
+    array([2., 1.5])
+
+    >>> ops.nanmean(x, axis=1, keepdims=True)
+    array([[2. ],
+           [1.5]])
+    """
+    if any_symbolic_tensors((x,)):
+        return Nanmean(axis=axis, keepdims=keepdims).symbolic_call(x)
+
+    return backend.numpy.nanmean(x, axis=axis, keepdims=keepdims)
+
+
 class Nanmin(Operation):
     def __init__(self, axis=None, keepdims=False, *, name=None):
         super().__init__(name=name)

keras/src/saving/file_editor.py

@@ -509,9 +509,15 @@ class KerasFileEditor:
             # ------------------------------------------------------
 
             # Skip any objects that are not proper datasets
-            if not hasattr(value, "shape") or not hasattr(value, "dtype"):
+            if not isinstance(value, h5py.Dataset):
                 continue
 
+            if value.external:
+                raise ValueError(
+                    "Not allowed: H5 file Dataset with external links: "
+                    f"{value.external}"
+                )
+
             shape = value.shape
             dtype = value.dtype
 

keras/src/saving/saving_lib.py

@@ -796,7 +796,8 @@ def _load_state(
             try:
                 saveable.load_own_variables(weights_store.get(inner_path))
             except Exception as e:
-                failed_saveables.add(id(saveable))
+                if failed_saveables is not None:
+                    failed_saveables.add(id(saveable))
                 error_msgs[id(saveable)] = saveable, e
                 failure = True
         else:
@@ -807,7 +808,8 @@ def _load_state(
             try:
                 saveable.load_assets(assets_store.get(inner_path))
             except Exception as e:
-                failed_saveables.add(id(saveable))
+                if failed_saveables is not None:
+                    failed_saveables.add(id(saveable))
                 error_msgs[id(saveable)] = saveable, e
                 failure = True
         else:
@@ -855,7 +857,7 @@ def _load_state(
     if not failure:
         if visited_saveables is not None and newly_failed <= 0:
             visited_saveables.add(id(saveable))
-        if id(saveable) in failed_saveables:
+        if failed_saveables is not None and id(saveable) in failed_saveables:
             failed_saveables.remove(id(saveable))
             error_msgs.pop(id(saveable))
 
@@ -1035,6 +1037,25 @@ class H5IOStore:
         # will mistakenly using `__len__` to determine the value.
         return self.h5_file.__bool__()
 
+    def _verify_group(self, group):
+        if not isinstance(group, h5py.Group):
+            raise ValueError(
+                f"Invalid H5 file, expected Group but received {type(group)}"
+            )
+        return group
+
+    def _verify_dataset(self, dataset):
+        if not isinstance(dataset, h5py.Dataset):
+            raise ValueError(
+                f"Invalid H5 file, expected Dataset, received {type(dataset)}"
+            )
+        if dataset.external:
+            raise ValueError(
+                "Not allowed: H5 file Dataset with external links: "
+                f"{dataset.external}"
+            )
+        return dataset
+
     def _get_h5_file(self, path_or_io, mode=None):
         mode = mode or self.mode
         if mode not in ("r", "w", "a"):
@@ -1094,15 +1115,19 @@ class H5IOStore:
         self._h5_entry_group = {}  # Defaults to an empty dict if not found.
         if not path:
             if "vars" in self.h5_file:
-                self._h5_entry_group = self.h5_file["vars"]
+                self._h5_entry_group = self._verify_group(self.h5_file["vars"])
         elif path in self.h5_file and "vars" in self.h5_file[path]:
-            self._h5_entry_group = self.h5_file[path]["vars"]
+            self._h5_entry_group = self._verify_group(
+                self._verify_group(self.h5_file[path])["vars"]
+            )
         else:
             # No hit. Fix for 2.13 compatibility.
             if "_layer_checkpoint_dependencies" in self.h5_file:
                 path = path.replace("layers", "_layer_checkpoint_dependencies")
                 if path in self.h5_file and "vars" in self.h5_file[path]:
-                    self._h5_entry_group = self.h5_file[path]["vars"]
+                    self._h5_entry_group = self._verify_group(
+                        self._verify_group(self.h5_file[path])["vars"]
+                    )
         self._h5_entry_initialized = True
         return self
 
@@ -1134,25 +1159,15 @@ class H5IOStore:
     def keys(self):
         return self._h5_entry_group.keys()
 
-    def items(self):
-        return self._h5_entry_group.items()
-
-    def values(self):
-        return self._h5_entry_group.values()
-
     def __getitem__(self, key):
-        value = self._h5_entry_group[key]
+        value = self._verify_dataset(self._h5_entry_group[key])
         if (
             hasattr(value, "attrs")
             and "dtype" in value.attrs
             and value.attrs["dtype"] == "bfloat16"
         ):
             value = np.array(value, dtype=ml_dtypes.bfloat16)
-        elif (
-            hasattr(value, "shape")
-            and hasattr(value, "dtype")
-            and not isinstance(value, np.ndarray)
-        ):
+        elif not isinstance(value, np.ndarray):
             value = np.array(value)
         return value
 
@@ -1355,15 +1370,13 @@ class ShardedH5IOStore(H5IOStore):
         self._get_h5_group(self._h5_entry_path)
 
     def _restore_h5_file(self):
-        """Ensure the current shard is the last one created.
-
-        We use mode="a" to avoid truncating the file during the switching.
-        """
+        """Ensure the current shard is the last one created."""
         if (
             pathlib.Path(self.h5_file.filename).name
             != self.current_shard_path.name
         ):
-            self._switch_h5_file(self.current_shard_path.name, mode="a")
+            mode = "a" if self.mode == "w" else "r"
+            self._switch_h5_file(self.current_shard_path.name, mode=mode)
 
     # H5 entry level methods.
 
@@ -1371,9 +1384,11 @@ class ShardedH5IOStore(H5IOStore):
         """Get the H5 entry group. If it doesn't exist, return an empty dict."""
         try:
             if not path:
-                self._h5_entry_group = self.h5_file["vars"]
+                self._h5_entry_group = self._verify_group(self.h5_file["vars"])
             else:
-                self._h5_entry_group = self.h5_file[path]["vars"]
+                self._h5_entry_group = self._verify_group(
+                    self._verify_group(self.h5_file[path])["vars"]
+                )
             self._h5_entry_initialized = True
         except KeyError:
             self._h5_entry_group = {}
@@ -1392,33 +1407,17 @@ class ShardedH5IOStore(H5IOStore):
         return total_len
 
     def keys(self):
-        keys = set(self._h5_entry_group.keys())
+        keys = []
+        current_shard_keys = list(self._h5_entry_group.keys())
         for filename in self.current_shard_filenames:
             if filename == self.current_shard_path.name:
-                continue
-            self._switch_h5_file(filename, mode="r")
-            keys.update(self._h5_entry_group.keys())
+                keys += current_shard_keys
+            else:
+                self._switch_h5_file(filename, mode="r")
+                keys += list(self._h5_entry_group.keys())
         self._restore_h5_file()
         return keys
 
-    def items(self):
-        yield from self._h5_entry_group.items()
-        for filename in self.current_shard_filenames:
-            if filename == self.current_shard_path.name:
-                continue
-            self._switch_h5_file(filename, mode="r")
-            yield from self._h5_entry_group.items()
-        self._restore_h5_file()
-
-    def values(self):
-        yield from self._h5_entry_group.values()
-        for filename in self.current_shard_filenames:
-            if filename == self.current_shard_path.name:
-                continue
-            self._switch_h5_file(filename, mode="r")
-            yield from self._h5_entry_group.values()
-        self._restore_h5_file()
-
     def __getitem__(self, key):
         if key in self._h5_entry_group:
             return super().__getitem__(key)

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.14.0.dev2026012604"
+__version__ = "3.14.0.dev2026012804"
 
 
 @keras_export("keras.version")

{keras_nightly-3.14.0.dev2026012604.dist-info → keras_nightly-3.14.0.dev2026012804.dist-info}/METADATA

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

{keras_nightly-3.14.0.dev2026012604.dist-info → keras_nightly-3.14.0.dev2026012804.dist-info}/RECORD

@@ -45,11 +45,11 @@ keras/_tf_keras/keras/losses/__init__.py,sha256=xBc_KOtSLwp3h3CKQ0EnCuIy-Bsak2SP
 keras/_tf_keras/keras/metrics/__init__.py,sha256=_wF31PTvua5ahF9JEW4Hx1UVNjVCLqVI8J5JNrZCBf8,6546
 keras/_tf_keras/keras/mixed_precision/__init__.py,sha256=AM51CzHqzcY75tqdpQiuVcTRUEpUzBqeb-EfLeSDSV8,727
 keras/_tf_keras/keras/models/__init__.py,sha256=83pyA0pzytqin8JLV6FEbPreCb-V64ToebxFGrHsVdQ,501
-keras/_tf_keras/keras/ops/__init__.py,sha256=j1hmnwcCXYOBqSaKHODKVyBwwS6N38KfC-W8_t9_GmU,15716
+keras/_tf_keras/keras/ops/__init__.py,sha256=q6oC17b27vXFUPbuWYjiA4_dVvXeyZwz0LBfOK2vVOQ,15767
 keras/_tf_keras/keras/ops/image/__init__.py,sha256=oM_PLh5Jk9OGfi1bbJcfWkjoq0Ye5JQG9a7v_KzDfoc,1034
 keras/_tf_keras/keras/ops/linalg/__init__.py,sha256=0ab6icK3yuIm4khSfAksGRFLEAJhaOu6gGgarau4iEQ,822
 keras/_tf_keras/keras/ops/nn/__init__.py,sha256=2eD8IlkfBrsmJjHpzsxMM3_058oGeZVgohdBd27iDnI,2992
-keras/_tf_keras/keras/ops/numpy/__init__.py,sha256=EEX_wcRRiw4E4Tq8Bm-n5AVi-OotP8FMdLRni12oEZQ,9778
+keras/_tf_keras/keras/ops/numpy/__init__.py,sha256=Ap9vHiPPbJTmGIXYBsq1-mxHqWP_lQDPgJu6u1M2CJo,9829
 keras/_tf_keras/keras/optimizers/__init__.py,sha256=1fx0vEB-oGu-9dumxoIvX4qVHdgJvf74OLyYoBkE2y0,1267
 keras/_tf_keras/keras/optimizers/legacy/__init__.py,sha256=uIMQESCV80Q0FY-9ikQUjXYPyZqmTfAM3dfohQ5DzYs,516
 keras/_tf_keras/keras/optimizers/schedules/__init__.py,sha256=pQF3rQiAPuUSTUdflTr-fpL77oyGIv9xzGdjae3M3kw,1120
@@ -111,11 +111,11 @@ keras/losses/__init__.py,sha256=VIXBHQFNdLUPZ7JuwtIKj_4E-xf2yvNyrmdklvjr_xM,3667
 keras/metrics/__init__.py,sha256=qeEwtqpSCAaCr8BMUv1eVaqJl2Zb83OB5K0BG3JB0nI,6245
 keras/mixed_precision/__init__.py,sha256=AM51CzHqzcY75tqdpQiuVcTRUEpUzBqeb-EfLeSDSV8,727
 keras/models/__init__.py,sha256=83pyA0pzytqin8JLV6FEbPreCb-V64ToebxFGrHsVdQ,501
-keras/ops/__init__.py,sha256=j1hmnwcCXYOBqSaKHODKVyBwwS6N38KfC-W8_t9_GmU,15716
+keras/ops/__init__.py,sha256=q6oC17b27vXFUPbuWYjiA4_dVvXeyZwz0LBfOK2vVOQ,15767
 keras/ops/image/__init__.py,sha256=oM_PLh5Jk9OGfi1bbJcfWkjoq0Ye5JQG9a7v_KzDfoc,1034
 keras/ops/linalg/__init__.py,sha256=0ab6icK3yuIm4khSfAksGRFLEAJhaOu6gGgarau4iEQ,822
 keras/ops/nn/__init__.py,sha256=2eD8IlkfBrsmJjHpzsxMM3_058oGeZVgohdBd27iDnI,2992
-keras/ops/numpy/__init__.py,sha256=EEX_wcRRiw4E4Tq8Bm-n5AVi-OotP8FMdLRni12oEZQ,9778
+keras/ops/numpy/__init__.py,sha256=Ap9vHiPPbJTmGIXYBsq1-mxHqWP_lQDPgJu6u1M2CJo,9829
 keras/optimizers/__init__.py,sha256=1fx0vEB-oGu-9dumxoIvX4qVHdgJvf74OLyYoBkE2y0,1267
 keras/optimizers/legacy/__init__.py,sha256=uIMQESCV80Q0FY-9ikQUjXYPyZqmTfAM3dfohQ5DzYs,516
 keras/optimizers/schedules/__init__.py,sha256=pQF3rQiAPuUSTUdflTr-fpL77oyGIv9xzGdjae3M3kw,1120
@@ -128,7 +128,7 @@ keras/regularizers/__init__.py,sha256=542Shphw7W8h4Dyf2rmqMKUECVZ8IVBvN9g1LWhz-b
 keras/saving/__init__.py,sha256=KvL2GZxjvgFgEhvEnkvqjIR9JSNHKz-NWZacXajsjLI,1298
 keras/src/__init__.py,sha256=Gi4S7EiCMkE03PbdGNpFdaUYySWDs_FcAJ8Taz9Y1BE,684
 keras/src/api_export.py,sha256=gXOkBOnmscV013WAc75lc4Up01-Kkg9EylIAT_QWctg,1173
-keras/src/version.py,sha256=IO1BtTEdIsNKjrOQPKMlR2VK-1cLzdW1S-Ep5EqpM-g,204
+keras/src/version.py,sha256=19dG5h6eOc-VKk0odlobQO7lPSyHV89NVu3r2Y6bzco,204
 keras/src/activations/__init__.py,sha256=0nL3IFDB9unlrMz8ninKOWo-uCHasTUpTo1tXZb2u44,4433
 keras/src/activations/activations.py,sha256=mogPggtp4CGldI3VOPNmesRxp6EbiR1_i4KLGaVwzL8,17614
 keras/src/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -171,7 +171,7 @@ keras/src/backend/jax/layer.py,sha256=o6CicT06udwamTRQIjNSDLZLyYHFzBXNbxewXgWe0i
 keras/src/backend/jax/linalg.py,sha256=LDaLZYz49ChE2kJR3YpaM9xuwusvd3krV7nNAAazTWA,2642
 keras/src/backend/jax/math.py,sha256=1IEDpdoF8e5ltu3D4wbDQuihzvJHhMXz8W9Z_E-eJqU,9391
 keras/src/backend/jax/nn.py,sha256=mrRawNvf9EWe8rdTwK_Auz6xdLkVG6hH0nIAP7hyUDE,60271
-keras/src/backend/jax/numpy.py,sha256=XMBWC4MM3eOCm2tePDT1J-Bj8h6SH0VWvArGGe0-2X8,39125
+keras/src/backend/jax/numpy.py,sha256=9d3zfOWJYO-BaIWXpUi-etaRkwbrb3wzFfjWPOoV9pI,39255
 keras/src/backend/jax/optimizer.py,sha256=5DeXQHcYmUI6F9i1m1VHn3sBt4LEStOeBXnKdESevLM,4134
 keras/src/backend/jax/random.py,sha256=Uk2huGIk_dlzMrx5eDVrrr2TeCEMitn2vr4yzA0NXjs,3594
 keras/src/backend/jax/rnn.py,sha256=Ycq0qfLY4M4jhltvztpLQyywjEM17T7CZQFh4hhHOUE,7767
@@ -186,7 +186,7 @@ keras/src/backend/numpy/layer.py,sha256=dTk7W7ql7vRgll7JbOXK5PlIhQw5VHdpSjKciHd8
 keras/src/backend/numpy/linalg.py,sha256=uzLTxEyuX_gDcnoA5Q59GdTg33py0WooKK5T6T9Td6c,2543
 keras/src/backend/numpy/math.py,sha256=HdkEA5ro7dtQBTP78GFIgqTFLgNQ49PXHhqI1vLRGfo,10169
 keras/src/backend/numpy/nn.py,sha256=P9JAnTlwSTI7bVv8WIv1pDQJHpjML_WJ0RsJWy-LJMc,46200
-keras/src/backend/numpy/numpy.py,sha256=UlqAexse7-DskEkQWw5mW2mXI-vBo6NO3jAoPwMzMM4,38266
+keras/src/backend/numpy/numpy.py,sha256=FbT39wJdKezY_rHGTQEOTUTnkpn-VGWV6fMDI83vliU,38446
 keras/src/backend/numpy/random.py,sha256=wx2nE75q7L2cBMjtQlQx8yKMj4Ie3puFMDQsbrZO8SA,3961
 keras/src/backend/numpy/rnn.py,sha256=thOsMung1qR3lQsR4_D6hqKMFollQgrB0KwsJLk4BMY,7867
 keras/src/backend/numpy/trainer.py,sha256=MzWr8_LLHa1P6fxdUWirGw_lQwHGF_vkZ7RUGLUzjUs,11126
@@ -198,7 +198,7 @@ keras/src/backend/openvino/layer.py,sha256=5RdvaH1yOyPAphjKiuQAK1H_yZFYKE1Hp7c5b
 keras/src/backend/openvino/linalg.py,sha256=L6a4MFGND2wWzPVCh44cwuOgkcC4wJTo8Xy3HwW04lg,1614
 keras/src/backend/openvino/math.py,sha256=qw9kX2sJ2qr0dBJF12Ey0E2GcwixPUqoev6UcNra4NI,3944
 keras/src/backend/openvino/nn.py,sha256=zULPxdwVO7JDZUUtsuoEEPCLQ09ew8z8T6G_i_NEqrM,23741
-keras/src/backend/openvino/numpy.py,sha256=qmw4X3u0oJZptzqNHM33FPjTd_Ku6xY9dxxYFqW8c0g,109966
+keras/src/backend/openvino/numpy.py,sha256=KzwfF8A1RPvmZCiZZqM0B5XELQNfyCYMAnb60Cxn2Jw,111780
 keras/src/backend/openvino/random.py,sha256=4hRUtIP6qJxO3Qy9uH1x6jSuJna3nWPdUf4x2QU8-ew,5575
 keras/src/backend/openvino/rnn.py,sha256=ErmuZLPSgG9qU-NfYPPvBZ6Ysy8k-fA4g19Vhqq7OVQ,866
 keras/src/backend/openvino/trainer.py,sha256=bMmtSALqydqdS6ke-5sYW5fgxZDshDH810p_C0xCRTg,9087
@@ -211,7 +211,7 @@ keras/src/backend/tensorflow/layer.py,sha256=69d40LwL4HhKRsCjj1VRpjfrQXXF8VV3vh0
 keras/src/backend/tensorflow/linalg.py,sha256=_lZVfdY1tFvrN7xwbt3INGoTR0yC5v-kI1Q0XppVibY,8773
 keras/src/backend/tensorflow/math.py,sha256=zTu_7Ff6B2Ro862z_xH0OCmIWbV74DjsO5UnfjYuOUQ,12370
 keras/src/backend/tensorflow/nn.py,sha256=6vtZHzUED6_blUPE1Tnc3GAxPpJ2ebxoaiMn80tTL9k,51328
-keras/src/backend/tensorflow/numpy.py,sha256=NHaXiWpFYVIUrZDTz3XaUKcN1AYsI9PGnlJmksOIOY8,106315
+keras/src/backend/tensorflow/numpy.py,sha256=8yiH61_ML4JRkZIYVysVnH3XdVaUVIWG1NG8dNrONWc,106883
 keras/src/backend/tensorflow/optimizer.py,sha256=kFlyEOnGjEYdLpd8mpwhUeku78__xBfZbbrDWpJrq60,9307
 keras/src/backend/tensorflow/random.py,sha256=iO8V_soaDXZm9ewyAVbjudhsMj08C348c9Bz64nxXC4,6475
 keras/src/backend/tensorflow/rnn.py,sha256=JbOSpt48cm612c7YwiTYOQCQsNXyI_6QeRhtUn8qEvM,34829
@@ -221,13 +221,13 @@ keras/src/backend/tensorflow/trackable.py,sha256=QZn0JvpBJ7Kx4e6zM2IVIWz9ADcWDB-
 keras/src/backend/tensorflow/trainer.py,sha256=otJ4CciSmE2-QH17bEyjaL-oQxiCD5eWgbkEglxjt4w,37191
 keras/src/backend/torch/__init__.py,sha256=0SiJ91WMaE_tO5q1zUsLEnU6hmPTpGKPIOkmIWaHlhk,2131
 keras/src/backend/torch/core.py,sha256=cMo5dCDxWicWgezOargrq1qx-tlS1GJzzYXm--PS1l0,24506
-keras/src/backend/torch/export.py,sha256=yYc5-4JxSiaCkbFWpfCIdcm4dDBv_9uG_uH6JR6oGx0,4909
+keras/src/backend/torch/export.py,sha256=9efHPdN_xvSWB0pndr_X9JJmQNwWyvrGBQOr_xOQDHc,5685
 keras/src/backend/torch/image.py,sha256=eer8LZwDMz3k2Dh5gxeTQfwrxPemM_H6eHMIP3AwRss,39149
 keras/src/backend/torch/layer.py,sha256=htECdpv9ioHWM8_zqQkEdxgDsgLu8XJi5yXgnLl-JFw,2084
 keras/src/backend/torch/linalg.py,sha256=wgPCfnscp5HOBmX9_-m-57lzxs1ttLNzmHqj2VYYq7k,2108
 keras/src/backend/torch/math.py,sha256=g-ElDii2Y_o1-t6BAu2nbS7JH-aPqVS5Fqds8aYzIlg,14324
 keras/src/backend/torch/nn.py,sha256=80MdDzkN7wV3MJbNsGh9B8IkdBoXC36wQcV8_o13y-8,37688
-keras/src/backend/torch/numpy.py,sha256=19zGj9Yr98Aejtv_GLiqeDQjAd_MrBedpWTqGed_gYw,59093
+keras/src/backend/torch/numpy.py,sha256=j686g4KwZjQqxH3ww2ioZrqZVyC8SeqKGRUuMOjWC5I,59354
 keras/src/backend/torch/random.py,sha256=YhLfC7qkGpzlU_i6gGPVormo3BMSo7OUA3TC3GCehrA,8292
 keras/src/backend/torch/rnn.py,sha256=MJIVbHKsUA2dZm4Gu2NvRxlrFCWeWSxSZRmFxSsC3Zg,26041
 keras/src/backend/torch/trainer.py,sha256=dcikz1c5O0FHNzRKSi6WhIHsHfLV2HDlrXPElSd1cgE,17985
@@ -344,7 +344,7 @@ keras/src/layers/merging/minimum.py,sha256=f8RN1O5yYzDqJbXuVTBKC0TKdEw_VU4bC4pZX
 keras/src/layers/merging/multiply.py,sha256=WvBX5gOpouqfQYnpioKMw2Tj6HRQQ2LNBuvKsRo_6P0,3185
 keras/src/layers/merging/subtract.py,sha256=ijpJDomo1JSMCw97Rn55LXiVLsI50lcvUxmZiv_HIzo,2684
 keras/src/layers/normalization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-keras/src/layers/normalization/batch_normalization.py,sha256=Hov8hKKqAOl1TDRtmH0S6jn8iutjdcVlw_Q_EcElDBc,14138
+keras/src/layers/normalization/batch_normalization.py,sha256=RXvCB4Nq0I9c5qPtL9UlhuOaomfsjBtrs7B-sAUYZhg,23453
 keras/src/layers/normalization/group_normalization.py,sha256=S8w40kMCi_aEN079vwDPxaV7K02Ny0HocZJ1ATX4SpA,9367
 keras/src/layers/normalization/layer_normalization.py,sha256=4GHBLQf2BSRLv2-73rPRWTgLKwYU7V0wXKZ99dA2jhw,8622
 keras/src/layers/normalization/rms_normalization.py,sha256=IJMNWEg41ELWWd_V5PfUZaseB2lIKKpE0KC-M-T4INY,3008
@@ -504,7 +504,7 @@ keras/src/ops/linalg.py,sha256=3V8S_cgNxZZCIFcFj-FBHTdRqWNbimDtumMvfoc0f30,26736
 keras/src/ops/math.py,sha256=4qYMJ5qAPmeSyeF63YWoGbUkQt6f4_VX0enOChU4mXU,37233
 keras/src/ops/nn.py,sha256=04gjHB2BWusy4tWm59EO5Ns1paJC5umDNGwNCKzaJWQ,104658
 keras/src/ops/node.py,sha256=aJgn9D-GkteE--Bbt2cZ9JjVxb2W2uS1OWEKoeLsl3Y,5583
-keras/src/ops/numpy.py,sha256=1rIBEmWGxdHUSoSjy-JRaC-GAHPCa-MZ50bfoIdUvRE,262690
+keras/src/ops/numpy.py,sha256=VmjIuyjZYDu37AO0PaJ6fpw8MnVKcFUJ5IDx_nnPxps,264374
 keras/src/ops/operation.py,sha256=A7sh9Hi6kZb7wkeMmhrDQIq770ofANXuP-Qg-kwCM3o,15485
 keras/src/ops/operation_utils.py,sha256=C6eThl-haKzlDH0fC1rn5-P1P-pCfIfXs-fy-ADR534,14523
 keras/src/ops/symbolic_arguments.py,sha256=MKwXxZYkyouD9BPmQ1uUNxILdcwPvTayAqXaUV3P3o4,1628
@@ -543,12 +543,12 @@ keras/src/random/seed_generator.py,sha256=-a0CQa7--Xt0g0nfdjLmUzlFElY9Y838VcCx05
 keras/src/regularizers/__init__.py,sha256=GzK9FTKL2Xxd5H55GfG9gxDqt4eZoVHFWICgb2VW8qM,1731
 keras/src/regularizers/regularizers.py,sha256=MDtsiFjLgI1sl9z036XcQhZH9OnUmMHM74l27dspum0,11802
 keras/src/saving/__init__.py,sha256=vnrtfvnzW7Gwtxe5COhaMoEnVYB5iDe2YlqJ-DvqFIk,614
-keras/src/saving/file_editor.py,sha256=tsUo9mQbMa8433tHTnOKWFhDeathYwDb0CeWcDTTTBQ,32089
+keras/src/saving/file_editor.py,sha256=mNlXakl58wPC7nWRAVTh-esQ0UN2x-q5piI2ZXYQ80k,32263
 keras/src/saving/keras_saveable.py,sha256=aGIt1ajtsaamfUq18LM6ql8JEoQzi3HwzJEuwQ9bmKE,1285
 keras/src/saving/object_registration.py,sha256=OOO-7-SNfPoFkFsR_c5jzE6aSIDIlHlnMcm9IlI_Gbs,7357
 keras/src/saving/orbax_util.py,sha256=ArJI9hQODUyyvzCiXt8AS3VH6E4SL0vF02-RHBk30gU,1621
 keras/src/saving/saving_api.py,sha256=PMkxXhtNNKX8GlwIsCP8-Plt19M012wNEk7i8BhxWzo,12670
-keras/src/saving/saving_lib.py,sha256=-uSXsojqzSl19FtW5FogCclvnu_nnVU3S-Si293DNq0,58723
+keras/src/saving/saving_lib.py,sha256=bRI8TeNOlflTfX3njSkkwNv-VYip-OW7ienIm0lL96I,58920
 keras/src/saving/serialization_lib.py,sha256=yzCTm8hin__MGA2N5M5F-8Zbts5ZJVmINbrH4wEtIwI,30334
 keras/src/testing/__init__.py,sha256=7vVsV7Rn3rG99DdURgnH8ncpxagRwIE0uhH-R4qDyok,315
 keras/src/testing/test_case.py,sha256=ZisRWfnbKiRdAee59wsq9PsDJGsAMGQKxMtELyERok0,31852
@@ -618,7 +618,7 @@ keras/utils/bounding_boxes/__init__.py,sha256=jtvQll4u8ZY0Z96HwNhP1nxWEG9FM3gI-6
 keras/utils/legacy/__init__.py,sha256=oSYZz6uS8UxSElRaaJYWJEoweJ4GAasZjnn7fNaOlog,342
 keras/visualization/__init__.py,sha256=UKWmiy6sps4SWlmQi9WX8_Z53cPpLlphz2zIeHdwJpQ,722
 keras/wrappers/__init__.py,sha256=QkS-O5K8qGS7C3sytF8MpmO6PasATpNVGF8qtb7Ojsw,407
-keras_nightly-3.14.0.dev2026012604.dist-info/METADATA,sha256=hoMrMEDlNy-ToYdBIMoJjk-t3RxmNa9C_cq04cnPQcc,6339
-keras_nightly-3.14.0.dev2026012604.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-keras_nightly-3.14.0.dev2026012604.dist-info/top_level.txt,sha256=ptcw_-QuGZ4ZDjMdwi_Z0clZm8QAqFdvzzFnDEOTs9o,6
-keras_nightly-3.14.0.dev2026012604.dist-info/RECORD,,
+keras_nightly-3.14.0.dev2026012804.dist-info/METADATA,sha256=PHIKEROkWa1oJK381wl7eaROrHFpk2-e2N8yNGMRLfI,6339
+keras_nightly-3.14.0.dev2026012804.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+keras_nightly-3.14.0.dev2026012804.dist-info/top_level.txt,sha256=ptcw_-QuGZ4ZDjMdwi_Z0clZm8QAqFdvzzFnDEOTs9o,6
+keras_nightly-3.14.0.dev2026012804.dist-info/RECORD,,