keras-nightly 3.14.0.dev2026012704__py3-none-any.whl → 3.14.0.dev2026012904__py3-none-any.whl

keras/src/quantizers/quantizers.py

@@ -1,3 +1,5 @@
+import math
+
 import ml_dtypes
 import numpy as np
 
@@ -118,6 +120,190 @@ def abs_max_quantize(
     return outputs, scale
 
 
+@keras_export("keras.quantizers.abs_max_quantize_grouped_with_zero_point")
+def abs_max_quantize_grouped_with_zero_point(
+    inputs,
+    block_size,
+    value_range=(-8, 7),
+    dtype="int8",
+    epsilon=backend.epsilon(),
+    to_numpy=False,
+):
+    """Quantizes a 2D tensor using grouped asymmetric quantization with
+    zero point.
+
+    Groups are formed along axis 0 (the input/contracting dimension).
+    Each group of `block_size` rows gets its own scale factor and zero point
+    per column. This is useful for weight distributions that are not centered
+    around zero.
+
+    Args:
+        inputs: Input tensor to quantize. Shape: `(input_dim, output_dim)`.
+        block_size: Number of elements per group along axis 0.
+        value_range: Tuple of `(min, max)` quantization range.
+        dtype: Data type of quantized output.
+        epsilon: Small value to avoid division by zero.
+        to_numpy: Whether to perform computation in numpy for memory
+            efficiency.
+
+    Returns:
+        A tuple `(quantized_tensor, scale, zero_point)` where:
+            - `quantized_tensor`: Same shape as inputs, dtype=`dtype`.
+            - `scale`: Shape `(n_groups, output_dim)` where
+              `n_groups = ceil(input_dim / block_size)`.
+            - `zero_point`: Shape `(n_groups, output_dim)`, dtype=`uint8`.
+
+    Example:
+
+    ```python
+    >>> import numpy as np
+    >>> from keras.quantizers import abs_max_quantize_grouped_with_zero_point
+    >>> kernel = np.random.randn(512, 256).astype("float32")
+    >>> quantized, scale, zero_point = abs_max_quantize_grouped_with_zero_point(
+    ...     kernel, block_size=128, value_range=(-8, 7)
+    ... )
+    >>> quantized.shape
+    (512, 256)
+    >>> scale.shape  # 512 / 128 = 4 groups
+    (4, 256)
+    >>> zero_point.shape
+    (4, 256)
+    ```
+    """
+    if to_numpy:
+        return _abs_max_quantize_grouped_with_zero_point_numpy(
+            inputs, block_size, value_range, dtype, epsilon
+        )
+    return _abs_max_quantize_grouped_with_zero_point_tensor(
+        inputs, block_size, value_range, dtype, epsilon
+    )
+
+
+def _abs_max_quantize_grouped_with_zero_point_numpy(
+    inputs, block_size, value_range, dtype, epsilon
+):
+    """NumPy implementation of grouped asymmetric quantization.
+
+    Uses NumPy for computation to reduce GPU memory usage during
+    model quantization.
+    """
+    original_dtype = backend.standardize_dtype(inputs.dtype)
+    inputs = ops.convert_to_numpy(inputs)
+
+    input_dim, output_dim = inputs.shape
+    n_groups = math.ceil(input_dim / block_size)
+    qmin, qmax = value_range
+
+    # Zero-pad rows so input_dim is divisible by block_size
+    padded_input_dim = n_groups * block_size
+    if padded_input_dim > input_dim:
+        padding = np.zeros(
+            (padded_input_dim - input_dim, output_dim), dtype=inputs.dtype
+        )
+        inputs_padded = np.concatenate([inputs, padding], axis=0)
+    else:
+        inputs_padded = inputs
+
+    inputs_reshaped = inputs_padded.reshape(n_groups, block_size, output_dim)
+
+    # Compute per-group min/max for asymmetric quantization
+    min_val = np.min(inputs_reshaped, axis=1, keepdims=True)
+    max_val = np.max(inputs_reshaped, axis=1, keepdims=True)
+
+    # Scale maps the [min, max] range to [qmin, qmax]
+    scale = np.divide(np.subtract(max_val, min_val) + epsilon, qmax - qmin)
+
+    # Zero point shifts the quantized range to include the original zero
+    zero_point = np.round(np.divide(-min_val, scale)) + qmin
+    zero_point = np.clip(zero_point, qmin, qmax)
+
+    # Quantize: q = round(input / scale) + zero_point
+    outputs = np.round(np.divide(inputs_reshaped, scale)) + zero_point
+    outputs = np.clip(outputs, qmin, qmax)
+    outputs = outputs.astype(dtype)
+
+    # Remove padding and squeeze to (n_groups, output_dim)
+    outputs = outputs.reshape(padded_input_dim, output_dim)[:input_dim, :]
+    scale = np.squeeze(scale, axis=1)
+    zero_point = np.squeeze(zero_point, axis=1).astype("int8")
+
+    return (
+        ops.convert_to_tensor(outputs),
+        ops.convert_to_tensor(scale, dtype=original_dtype),
+        ops.convert_to_tensor(zero_point),
+    )
+
+
+def _abs_max_quantize_grouped_with_zero_point_tensor(
+    inputs, block_size, value_range, dtype, epsilon
+):
+    """Tensor backend implementation of grouped asymmetric quantization."""
+    original_dtype = backend.standardize_dtype(inputs.dtype)
+    inputs = ops.convert_to_tensor(inputs)
+
+    input_shape = ops.shape(inputs)
+    input_dim = input_shape[0]
+    output_dim = input_shape[1]
+    qmin, qmax = value_range
+
+    # Infer bit-width from quantization range (e.g., [-8, 7] -> 4 bits)
+    num_levels = qmax - qmin + 1
+    bits = int(math.log2(num_levels))
+
+    n_groups = int(math.ceil(int(input_dim) / block_size))
+    padded_input_dim = n_groups * block_size
+
+    # Transpose to [out_features, in_features] for
+    # compute_quantization_parameters
+    inputs_t = ops.transpose(inputs)
+
+    # Compute scale and zero point using the unified quantization function
+    scale_t, zero_point_t, _ = compute_quantization_parameters(
+        inputs_t,
+        bits=bits,
+        symmetric=False,
+        per_channel=True,
+        group_size=block_size,
+        compute_dtype=original_dtype,
+        epsilon=epsilon,
+        signed=True,
+    )
+
+    # Transpose results back to (n_groups, output_dim)
+    scale = ops.transpose(scale_t)
+    zero_point = ops.transpose(zero_point_t)
+
+    # Zero-pad rows so input_dim is divisible by block_size
+    pad_size = padded_input_dim - int(input_dim)
+    if pad_size > 0:
+        padding = ops.zeros((pad_size, output_dim), dtype=inputs.dtype)
+        inputs_padded = ops.concatenate([inputs, padding], axis=0)
+    else:
+        inputs_padded = inputs
+
+    inputs_reshaped = ops.reshape(
+        inputs_padded, (n_groups, block_size, output_dim)
+    )
+
+    # Expand scale and zero_point for broadcasting across block_size
+    scale_expanded = ops.expand_dims(scale, axis=1)
+    zero_point_expanded = ops.expand_dims(zero_point, axis=1)
+
+    # Quantize: q = round(input / scale) + zero_point
+    outputs = ops.add(
+        ops.round(ops.divide(inputs_reshaped, scale_expanded)),
+        zero_point_expanded,
+    )
+    outputs = ops.clip(outputs, qmin, qmax)
+    outputs = ops.cast(outputs, dtype)
+
+    # Remove padding
+    outputs = ops.reshape(outputs, (padded_input_dim, output_dim))
+    outputs = outputs[:input_dim, :]
+
+    return outputs, scale, zero_point
+
+
 @keras_export("keras.quantizers.AbsMaxQuantizer")
 class AbsMaxQuantizer(Quantizer):
     def __init__(
@@ -796,6 +982,8 @@ def compute_quantization_parameters(
     per_channel=False,
     group_size=-1,
     compute_dtype="float32",
+    epsilon=0.0,
+    signed=False,
 ):
     """
     Computes the scale and zero-point for quantizing weight tensors.
@@ -816,10 +1004,17 @@ def compute_quantization_parameters(
         per_channel: bool. Whether to quantize per channel.
         group_size: int. The group size for quantization. -1 means no grouping.
         compute_dtype: str. The dtype for computation. Defaults to "float32".
+        epsilon: float. Small value added to (max - min) before computing
+            scale to avoid division by zero. Defaults to 0.0.
+        signed: bool. Whether to use signed quantization range. If True, uses
+            range [-2^(bits-1), 2^(bits-1)-1] (e.g., [-8, 7] for 4-bit).
+            If False, uses range [0, 2^bits-1] (e.g., [0, 15] for 4-bit).
+            Defaults to False.
 
     Returns:
         scale: KerasTensor. The scale tensor for quantization.
-        zero: KerasTensor. The zero tensor for quantization.
+        zero: KerasTensor. The zero tensor for quantization (int8 if signed,
+            uint8 if unsigned).
         maxq: scalar. The maximum quantization value.
     """
     # Input validation
@@ -874,13 +1069,31 @@ def compute_quantization_parameters(
 
     # Compute scale and zero-point
     maxq = ops.cast(ops.subtract(ops.power(2, bits), 1), compute_dtype)
-    scale = ops.divide(ops.subtract(max_values, min_values), maxq)
+    range_values = ops.subtract(max_values, min_values)
+    if epsilon > 0:
+        range_values = ops.add(range_values, epsilon)
+    scale = ops.divide(range_values, maxq)
     scale = ops.where(ops.less_equal(scale, 0), 1e-8, scale)
 
-    if symmetric:
-        zero = ops.full_like(scale, ops.divide(ops.add(maxq, 1), 2))
+    # Compute zero-point based on signed/unsigned mode
+    if signed:
+        # For signed range [-2^(bits-1), 2^(bits-1)-1], e.g., [-8, 7] for 4-bit
+        qmin = -(2 ** (bits - 1))  # e.g., -8 for 4-bit
+        qmax_signed = 2 ** (bits - 1) - 1  # e.g., 7 for 4-bit
+        if symmetric:
+            zero = ops.full_like(scale, ops.divide(ops.add(maxq, 1), 2) + qmin)
+        else:
+            # zero_signed = round(-min / scale) + qmin
+            zero = ops.add(
+                ops.round(ops.divide(ops.negative(min_values), scale)), qmin
+            )
+        zero = ops.clip(zero, qmin, qmax_signed)
     else:
-        zero = ops.round(ops.divide(ops.negative(min_values), scale))
+        # For unsigned range [0, 2^bits-1], e.g., [0, 15] for 4-bit
+        if symmetric:
+            zero = ops.full_like(scale, ops.divide(ops.add(maxq, 1), 2))
+        else:
+            zero = ops.round(ops.divide(ops.negative(min_values), scale))
 
     # Reshape output to [out_features, n_groups] or [out_features, 1]
     if n_groups > 1:
@@ -893,7 +1106,8 @@ def compute_quantization_parameters(
         scale = ops.tile(ops.reshape(scale, (1, 1)), (out_features, 1))
         zero = ops.tile(ops.reshape(zero, (1, 1)), (out_features, 1))
 
-    return scale, ops.cast(zero, "uint8"), maxq
+    zero_dtype = "int8" if signed else "uint8"
+    return scale, ops.cast(zero, zero_dtype), maxq
 
 
 def quantize_with_zero_point(input_tensor, scale, zero, maxq):
@@ -942,51 +1156,67 @@ def dequantize_with_zero_point(input_tensor, scale, zero):
     )
 
 
-def quantize_with_sz_map(weights_matrix, scale, zero, g_idx, maxq):
+def quantize_with_sz_map(
+    weights_matrix, scale, zero, g_idx, maxq, group_axis=-1
+):
     """Quantize the weight matrix from group params.
 
     This function uses the provided scale and zero tensors to quantize the
-    input weights_matrix according to the group indices. It maps each column
-    of the weights_matrix to its corresponding group parameters and performs
-    the quantization operation.
+    input weights_matrix according to the group indices. It maps each position
+    along group_axis of the weights_matrix to its corresponding group
+    parameters and performs the quantization operation.
 
     Args:
-        weights_matrix: 2D tensor of shape [out_features, in_features].
-        scale: Per-group scale tensor of shape [out_features, n_groups].
-        zero: Per-group zero-point tensor of shape [out_features, n_groups].
-        g_idx: Integer tensor of shape [in_features,] mapping each column to
-            its group index.
+        weights_matrix: Tensor to quantize.
+        scale: Per-group scale tensor with n_groups along group_axis.
+        zero: Per-group zero-point tensor with n_groups along group_axis.
+        g_idx: 1D integer tensor of length equal to the size of
+            `weights_matrix` along the dimension being quantized. Each
+            element specifies which group index (0 to n_groups-1) that
+            position belongs to. For example, with 128 columns and
+            group_size=32, g_idx would be
+            `[0,0,...,0, 1,1,...,1, 2,2,...,2, 3,3,...,3]` (32 of each).
         maxq: Scalar (float) representing the maximum integer quantization
             level (e.g., 2^bits - 1).
+        group_axis: The axis in `scale` and `zero` along which to index
+            using `g_idx`. This determines which dimension of the
+            scale/zero tensors contains the per-group values. Default: -1
+            (last axis).
 
     Returns:
         A tensor with the same shape as `weights_matrix` containing the
         quantized weights produced using the provided group parameters.
     """
     groups = ops.cast(g_idx, "int32")
-    scale_cols = ops.take(scale, groups, axis=1)  # [out_features, in_features]
-    zero_cols = ops.take(zero, groups, axis=1)  # [out_features, in_features]
+    scale_cols = ops.take(scale, groups, axis=group_axis)
+    zero_cols = ops.take(zero, groups, axis=group_axis)
 
     # Quantize elementwise, then cast to int
     return quantize_with_zero_point(weights_matrix, scale_cols, zero_cols, maxq)
 
 
-def dequantize_with_sz_map(weights_matrix, scale, zero, g_idx):
+def dequantize_with_sz_map(weights_matrix, scale, zero, g_idx, group_axis=-1):
     """Rebuild a dequantized weight matrix from group params.
 
     This function uses the provided scale and zero tensors to dequantize the
-    input weights_matrix according to the group indices. It maps each column
-    of the weights_matrix to its corresponding group parameters and performs
-    the dequantization operation.
+    input weights_matrix according to the group indices. It maps each position
+    along group_axis of the weights_matrix to its corresponding group
+    parameters and performs the dequantization operation.
 
     Args:
-        weights_matrix: 2D tensor of shape [out_features, in_features].
-        scale: Per-group scale tensor of shape [out_features, n_groups].
-        zero: Per-group zero-point tensor of shape [out_features, n_groups].
-        g_idx: Integer tensor of shape [in_features,] mapping each column to
-            its group index.
-        maxq: Scalar (float) representing the maximum integer quantization
-            level (e.g., 2^bits - 1).
+        weights_matrix: Tensor to dequantize.
+        scale: Per-group scale tensor with n_groups along group_axis.
+        zero: Per-group zero-point tensor with n_groups along group_axis.
+        g_idx: 1D integer tensor of length equal to the size of
+            `weights_matrix` along the dimension being dequantized. Each
+            element specifies which group index (0 to n_groups-1) that
+            position belongs to. For example, with 128 columns and
+            group_size=32, g_idx would be
+            `[0,0,...,0, 1,1,...,1, 2,2,...,2, 3,3,...,3]` (32 of each).
+        group_axis: The axis in `scale` and `zero` along which to index
+            using `g_idx`. This determines which dimension of the
+            scale/zero tensors contains the per-group values. Default: -1
+            (last axis).
 
     Returns:
         A tensor with the same shape as `weights_matrix` containing the
@@ -994,12 +1224,12 @@ def dequantize_with_sz_map(weights_matrix, scale, zero, g_idx):
     """
     # Map group indices to scales and zeros
     groups = ops.cast(g_idx, "int32")
-    scales_mapped = ops.take(scale, groups, axis=1)
-    zeros_mapped = ops.take(zero, groups, axis=1)
+    scales_mapped = ops.take(scale, groups, axis=group_axis)
+    zeros_mapped = ops.take(zero, groups, axis=group_axis)
     zeros_mapped = ops.cast(zeros_mapped, scales_mapped.dtype)
 
-    quantized = ops.multiply(
+    dequantized = ops.multiply(
         ops.subtract(weights_matrix, zeros_mapped), scales_mapped
     )
 
-    return quantized
+    return dequantized

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_api.py

@@ -121,10 +121,11 @@ def save_model(model, filepath, overwrite=True, zipped=None, **kwargs):
 
 @keras_export(["keras.saving.load_model", "keras.models.load_model"])
 def load_model(filepath, custom_objects=None, compile=True, safe_mode=True):
-    """Loads a model saved via `model.save()`.
+    """Loads a model saved via `model.save()` or from an Orbax checkpoint.
 
     Args:
-        filepath: `str` or `pathlib.Path` object, path to the saved model file.
+        filepath: `str` or `pathlib.Path` object, path to the saved model file
+            or Orbax checkpoint directory.
         custom_objects: Optional dictionary mapping names
             (strings) to custom classes or functions to be
             considered during deserialization.
@@ -195,6 +196,16 @@ def load_model(filepath, custom_objects=None, compile=True, safe_mode=True):
             compile=compile,
             safe_mode=safe_mode,
         )
+
+    # Check for Orbax checkpoint directory using utility function
+    if is_orbax_checkpoint(filepath):
+        return _load_model_from_orbax_checkpoint(
+            filepath,
+            custom_objects=custom_objects,
+            compile=compile,
+            safe_mode=safe_mode,
+        )
+
     elif str(filepath).endswith(".keras"):
         raise ValueError(
             f"File not found: filepath={filepath}. "
@@ -337,3 +348,56 @@ def load_weights(model, filepath, skip_mismatch=False, **kwargs):
             "`.weights.h5` files, legacy H5 format files "
             "(`.h5` extension), or Orbax checkpoints."
         )
+
+
+def _load_model_from_orbax_checkpoint(
+    filepath, custom_objects=None, compile=True, safe_mode=True
+):
+    """Load a model from an Orbax checkpoint directory."""
+
+    from keras.src.utils.module_utils import ocp
+
+    # Ensure orbax is available
+    ocp.initialize()
+
+    # Find the latest checkpoint step using the utility function
+    checkpoint_path = find_latest_orbax_checkpoint(filepath)
+    step = int(os.path.basename(checkpoint_path))
+
+    # Load the composite state efficiently
+    checkpointer = ocp.training.Checkpointer(directory=filepath)
+    with ocp.Context():
+        composite_state = checkpointer.load_pytree(step)
+
+    # Validate and extract model config
+    if "model_config" not in composite_state:
+        raise ValueError(
+            "Checkpoint does not contain model configuration. "
+            "This checkpoint may have been saved with save_weights_only=True."
+        )
+
+    # Create and build model from config using saving_lib helper
+    # This properly handles shared objects and compile_config
+    model = saving_lib._model_from_config(
+        composite_state["model_config"],
+        custom_objects=custom_objects,
+        compile=compile,
+        safe_mode=safe_mode,
+    )
+
+    # Prepare state tree with only variable keys for set_state_tree
+    variable_keys = [
+        "trainable_variables",
+        "non_trainable_variables",
+        "optimizer_variables",
+        "metrics_variables",
+    ]
+    state_tree = {
+        key: composite_state[key]
+        for key in variable_keys
+        if key in composite_state
+    }
+
+    # Apply the loaded state to the model
+    model.set_state_tree(state_tree)
+    return model

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

{keras_nightly-3.14.0.dev2026012704.dist-info → keras_nightly-3.14.0.dev2026012904.dist-info}/METADATA

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