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

{keras_nightly-3.14.0.dev2026012804.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.dev2026012804
+Version: 3.14.0.dev2026012904
 Summary: Multi-backend Keras
 Author-email: Keras team <keras-users@googlegroups.com>
 License: Apache License 2.0

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

@@ -35,7 +35,7 @@ keras/_tf_keras/keras/datasets/mnist/__init__.py,sha256=tCUxwxWlcOGsTQzgysuC2kVv
 keras/_tf_keras/keras/datasets/reuters/__init__.py,sha256=aY43YfZVbCRMIRNfycxdKPDjq8BW8MZSA_fYQjonuY0,330
 keras/_tf_keras/keras/distillation/__init__.py,sha256=7pnduBNlDNCQFxm8yhGeYw8jKjOhK2l-F3iOjIFCmNk,497
 keras/_tf_keras/keras/distribution/__init__.py,sha256=sPbRKFpWd8mZypqWAId06KJzznVpkT_4Ae5QTcBJxa8,1063
-keras/_tf_keras/keras/dtype_policies/__init__.py,sha256=c8mnzGQbn3b5EQ6v6zBnrkgs9EFcrPRi5Zv4TEVcolg,969
+keras/_tf_keras/keras/dtype_policies/__init__.py,sha256=o10diNOYl4_umVihjLtgkBbCqgpKOddw5vWczArATjg,1063
 keras/_tf_keras/keras/export/__init__.py,sha256=Qtde9Kh4AUm-pBmKL4L90ooJxo5EFVEW8i7LYxA_mVQ,194
 keras/_tf_keras/keras/initializers/__init__.py,sha256=Bg5r2XRraWXldFSlWNu1kNnp0g1sQt9vfcT8fvmXaeg,3371
 keras/_tf_keras/keras/layers/__init__.py,sha256=w0Av9SmIfUOFvKiDXV5t7IWfpoagNwLX2hgg3C-pTSs,16237
@@ -57,7 +57,7 @@ keras/_tf_keras/keras/preprocessing/__init__.py,sha256=8gjf16CnMiBJFp2E05iRJaHze
 keras/_tf_keras/keras/preprocessing/image/__init__.py,sha256=MEyK0JU7piXc1ql8ZTtHJuC907Q6DV5uOQqpivKKTn4,1656
 keras/_tf_keras/keras/preprocessing/sequence/__init__.py,sha256=TymwLKMEwqR6JhVFDhU80Hf8GVMMwg2vD6-pJqh5NuA,479
 keras/_tf_keras/keras/preprocessing/text/__init__.py,sha256=g3ej5_e86BY1AhlQwjalIQq_xgCMmCcDMtsh27diUNw,543
-keras/_tf_keras/keras/quantizers/__init__.py,sha256=kDf-LP5ola_TxzeClJTqSS42k4mzF-BcP5zh7Xh7miE,1652
+keras/_tf_keras/keras/quantizers/__init__.py,sha256=KBYALSRrerYJSd_Rht8etlSdY5tKo8nAbDgvVrfF9CU,1790
 keras/_tf_keras/keras/random/__init__.py,sha256=qDZQXrw0oYVNc2KTmcmcgon61lQJBOXqF-6PMInBvec,763
 keras/_tf_keras/keras/regularizers/__init__.py,sha256=542Shphw7W8h4Dyf2rmqMKUECVZ8IVBvN9g1LWhz-b4,923
 keras/_tf_keras/keras/saving/__init__.py,sha256=KvL2GZxjvgFgEhvEnkvqjIR9JSNHKz-NWZacXajsjLI,1298
@@ -101,7 +101,7 @@ keras/datasets/mnist/__init__.py,sha256=tCUxwxWlcOGsTQzgysuC2kVvX01zkGOa9ABEb1Ek
 keras/datasets/reuters/__init__.py,sha256=aY43YfZVbCRMIRNfycxdKPDjq8BW8MZSA_fYQjonuY0,330
 keras/distillation/__init__.py,sha256=7pnduBNlDNCQFxm8yhGeYw8jKjOhK2l-F3iOjIFCmNk,497
 keras/distribution/__init__.py,sha256=sPbRKFpWd8mZypqWAId06KJzznVpkT_4Ae5QTcBJxa8,1063
-keras/dtype_policies/__init__.py,sha256=c8mnzGQbn3b5EQ6v6zBnrkgs9EFcrPRi5Zv4TEVcolg,969
+keras/dtype_policies/__init__.py,sha256=o10diNOYl4_umVihjLtgkBbCqgpKOddw5vWczArATjg,1063
 keras/export/__init__.py,sha256=Qtde9Kh4AUm-pBmKL4L90ooJxo5EFVEW8i7LYxA_mVQ,194
 keras/initializers/__init__.py,sha256=Bg5r2XRraWXldFSlWNu1kNnp0g1sQt9vfcT8fvmXaeg,3371
 keras/layers/__init__.py,sha256=mteqKdCYQq1NWH-XOYoy1B2uJFmJkG2XPHJIOnUjLOg,16069
@@ -122,13 +122,13 @@ keras/optimizers/schedules/__init__.py,sha256=pQF3rQiAPuUSTUdflTr-fpL77oyGIv9xzG
 keras/preprocessing/__init__.py,sha256=N-_Rr6pYag2H_kEn6imVuol_hNL3NL65YL_zvdOV1mU,580
 keras/preprocessing/image/__init__.py,sha256=AmkgEp_-MvtIefySVEXv1IQ5_LyojjBfnIlRcUvNc40,451
 keras/preprocessing/sequence/__init__.py,sha256=zTMj_m6LWipe_hVq6SjE4JPj7eYKuUOZyh45g756cFg,196
-keras/quantizers/__init__.py,sha256=kDf-LP5ola_TxzeClJTqSS42k4mzF-BcP5zh7Xh7miE,1652
+keras/quantizers/__init__.py,sha256=KBYALSRrerYJSd_Rht8etlSdY5tKo8nAbDgvVrfF9CU,1790
 keras/random/__init__.py,sha256=qDZQXrw0oYVNc2KTmcmcgon61lQJBOXqF-6PMInBvec,763
 keras/regularizers/__init__.py,sha256=542Shphw7W8h4Dyf2rmqMKUECVZ8IVBvN9g1LWhz-b4,923
 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=19dG5h6eOc-VKk0odlobQO7lPSyHV89NVu3r2Y6bzco,204
+keras/src/version.py,sha256=L6aU5qNyjfVqWFQMoyXdfGkHRVpx3Z4Axvr6FTCf4N8,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
@@ -163,7 +163,7 @@ keras/src/backend/common/symbolic_scope.py,sha256=RfrfOAv2cbiZai-L6tHwir2WUpJhS6
 keras/src/backend/common/tensor_attributes.py,sha256=X5sYeGDu9YmVBIn8oX31IeE-v-bxjq2ovmIjLrVOa8g,1161
 keras/src/backend/common/variables.py,sha256=ENq8lbwCGoIggC3Ef92Ea9G7ej4NZJnomvJZYwp8BaI,24467
 keras/src/backend/jax/__init__.py,sha256=l_HMwAZ3oAV4Etnw9RPqbvLYPPs3CZYbgaLd_qy36ps,1495
-keras/src/backend/jax/core.py,sha256=C6uwztGtL2j0vCDslroAv9P4yTxVxuHfBiSpguNuGeE,22721
+keras/src/backend/jax/core.py,sha256=pwsVWZF63o47StwMdwm9tRQapX_EHNnMt4r8Xe37gIg,23132
 keras/src/backend/jax/distribution_lib.py,sha256=pwUsC_p_z73-5pG0_nI1tbJ9cqMqd93-ROIteEEbY7w,9258
 keras/src/backend/jax/export.py,sha256=jV2yKQLzYjK72vTJmdNomWPLeNS_lDTCEKzQx_5D_-E,7368
 keras/src/backend/jax/image.py,sha256=RiYIalbIaUQdDOGpDZUBk5KNsX94Xqg7iyXGATN9V58,30482
@@ -254,7 +254,7 @@ keras/src/callbacks/lambda_callback.py,sha256=q-nNr_k7MyYRP3HIetFsutcLkq78cUYxDD
 keras/src/callbacks/learning_rate_scheduler.py,sha256=II0SLxltUX3omRbGTYffd9KTWLRKtzW57SDRe70_t7E,2965
 keras/src/callbacks/model_checkpoint.py,sha256=Jt2mMKHKx0isrQnhiHADDOmwu72J594m93PBHy-zpV8,18570
 keras/src/callbacks/monitor_callback.py,sha256=-QBKqkKJ7Rg6L40Q80IScpvybmLoodLWcJoAgnTe_c4,4184
-keras/src/callbacks/orbax_checkpoint.py,sha256=hG_OClsm4lYQVTyCLWLJqgdYl6OXtFjz0J6z5eUtsmY,12529
+keras/src/callbacks/orbax_checkpoint.py,sha256=aO138hfFOsU48GiYNYy0r__9DpmpbMxG9CGMX2CSc9Y,13931
 keras/src/callbacks/progbar_logger.py,sha256=BqddKoOyc8vxxtKriq5QD3n5JhVPUxkuWF2u1UlCriQ,3104
 keras/src/callbacks/reduce_lr_on_plateau.py,sha256=isJ9EzVo8jIu-_kWTFHpM_gaI5PbHTcUBM0keR9FRHA,4766
 keras/src/callbacks/remote_monitor.py,sha256=VDbNzCdddCDe_ZoeVvwV50oJkwOehhT_IDDYD8LzFOg,2727
@@ -278,8 +278,8 @@ keras/src/distillation/distillation_loss.py,sha256=3hhDKWhNHoLMa-EaBbJfa0flS6QoU
 keras/src/distillation/distiller.py,sha256=GI_yJ5RTgdXPEZoQwNe4Ds04UXP7obB0tJTqmUbTOa4,22984
 keras/src/distribution/__init__.py,sha256=pseLHx387oTmXROr95tU7kNWjPL8-JB4kZs8nUHsOiU,718
 keras/src/distribution/distribution_lib.py,sha256=zZbKxdL0sHJXSJNCd02qG3sVrq1F3x_JPota9Jlk6iM,34542
-keras/src/dtype_policies/__init__.py,sha256=8Ju8ICwTDdBfBrSoL6kmMzrcgMwMg6dPa1UPMDZKTqc,3717
-keras/src/dtype_policies/dtype_policy.py,sha256=3e2J589g0NUALz0LycSb3anh47g5LWIgn0jKR26B-Cs,19143
+keras/src/dtype_policies/__init__.py,sha256=0K3I6VkP6XZ60srUSitXA9Z2PxKsYEbJKFv_xs1Gi1I,3804
+keras/src/dtype_policies/dtype_policy.py,sha256=Wfg6P4PRYH7p2QS_TvySpGOjRvcm-G-Q3fsohEwXYfY,21922
 keras/src/dtype_policies/dtype_policy_map.py,sha256=DqDYlssUGSiTqawPpaVRvR6ljYD8DJrFERCxXVVFvBE,10840
 keras/src/export/__init__.py,sha256=wQfjXEPN1YO2n0gz-7Eme0y_vq86s3SEWkZgs534sns,366
 keras/src/export/export_utils.py,sha256=DpfA5yI37gaMjyESxGTlf7aQ8FhYp0u8LQKxyKiFaoU,5585
@@ -324,14 +324,14 @@ keras/src/layers/convolutional/depthwise_conv2d.py,sha256=rnCd_S3UVeNdVotjKW1Wlo
 keras/src/layers/convolutional/separable_conv1d.py,sha256=vL5qzdaSOOTgyn1A6y9IZZbQOEeB6FedPk9JJI5wqSY,6452
 keras/src/layers/convolutional/separable_conv2d.py,sha256=ZkLOnA6l5UV3GuJufwlOHMOm1S-xkt6sdF-qmP4PDjw,6533
 keras/src/layers/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-keras/src/layers/core/dense.py,sha256=oe0vpcYAMeulF39TrQAeSm-PrNafrpqj6GPlOFQ-eq4,40477
-keras/src/layers/core/einsum_dense.py,sha256=XM58eGQjLSSPIbOdzFmcehJ12eBSGPdRnZ04Qjzwvqs,69554
-keras/src/layers/core/embedding.py,sha256=88x_dkaDlGD-3WtGJf58Us68q2ub8SY36ln9Cz3G75Q,22646
+keras/src/layers/core/dense.py,sha256=JqnencNYXdXt94pG0JUlE_iKY7pviJuZS_TGDl5nKeM,48253
+keras/src/layers/core/einsum_dense.py,sha256=9f8_ipGJKyJpqSvVQhH5UIUi2pUQXfv0Mh6cDCyCDtw,76601
+keras/src/layers/core/embedding.py,sha256=y5IebiVSmVWRTVV0qcwENSSVUC-G2WMtaK79YBgY9e0,30709
 keras/src/layers/core/identity.py,sha256=o0gLHlXL7eNJEbXIgIsgBsZX97K6jN9n3qPXprkXQ9Y,848
 keras/src/layers/core/input_layer.py,sha256=RQn1KHtUd6fPBPL9rs46X8KHmr1eGo7moLg8U5tlVl0,8168
 keras/src/layers/core/lambda_layer.py,sha256=Wplek4hOwh_rwXz4_bpz0pXzKe26ywz52glh5uD0l4w,9272
 keras/src/layers/core/masking.py,sha256=g-RrZ_P50Surh_KGlZQwy2kPNLsop0F8voU4SG2MQkw,2856
-keras/src/layers/core/reversible_embedding.py,sha256=nDQ7b-xi9YlHxYZv0Vif0qr3bfu3LAWR_d1KrDsMawI,16155
+keras/src/layers/core/reversible_embedding.py,sha256=2Cqu4kPC7HoHgDBEaxUuggylZoTdBfNjOSPm3SpxJ84,22446
 keras/src/layers/core/wrapper.py,sha256=KIdDBuk24V9rAn97-HUUKQ0JMx9Eyd0q9W4qQFaYNt8,1509
 keras/src/layers/merging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras/src/layers/merging/add.py,sha256=icbh3RwZ3QUP3bFNCi7GbrHj2hFdKu1Dsv8djSa13co,2150
@@ -375,7 +375,7 @@ keras/src/layers/pooling/max_pooling3d.py,sha256=xVsJd6KPyu1m9jCVuwT3MZwpwT27TSx
 keras/src/layers/preprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keras/src/layers/preprocessing/category_encoding.py,sha256=RjgVkFi9og1hHNmDu2DuKVQOO2Yd-LSXKJDSSzG876M,6927
 keras/src/layers/preprocessing/data_layer.py,sha256=5bO2Pjs-mOzn4z5OnwBbbF3shOczLmimYVym9UL0Mcc,5766
-keras/src/layers/preprocessing/discretization.py,sha256=vsBQbIqlore_NlU0LvtqiDriCXguD_CZH7tK91LBhGM,14056
+keras/src/layers/preprocessing/discretization.py,sha256=jggZ3irXWaybPGH6jdmbohHo6krl48II-RtsLYa-0Vk,15154
 keras/src/layers/preprocessing/feature_space.py,sha256=YcHzD8C5eqUDRF8khLapwc8qCmbJSfix16KyzqEu1II,30568
 keras/src/layers/preprocessing/hashed_crossing.py,sha256=uwOTKPsv2UweHuGiF4V5HFRgYnjP8N0_S6qT3JP5KeQ,8481
 keras/src/layers/preprocessing/hashing.py,sha256=3k1L_2d_bROHxZNjDbfURRBSFzFBIHFj0tEXCobcS8w,11188
@@ -527,15 +527,15 @@ keras/src/optimizers/rmsprop.py,sha256=DCbmmViUnYCHMCO9YCtC2wGzPXxNPBJhkpwAmROOz
 keras/src/optimizers/sgd.py,sha256=_3xanWOI0s2dISxEVT7i_tehsWakQQz2y480Iwkonas,4396
 keras/src/optimizers/schedules/__init__.py,sha256=vuUuHNTev8sD2-swsuq7zqyYbmaOhDyiIE6F3dGGSZU,546
 keras/src/optimizers/schedules/learning_rate_schedule.py,sha256=WI5QuaWFsEFJhRfLy0KCmkxKwGBMnmgMLYsWC_4YbCo,35828
-keras/src/quantizers/__init__.py,sha256=3LlZ1Z5G5mYVdrZ2xnoFgW28OFneYc_Ys2dzuJ3S0nk,2459
+keras/src/quantizers/__init__.py,sha256=3nlkoq0aJsR-6OA23MA4WAjebCOIXT4ZH73JPg69esQ,2761
 keras/src/quantizers/awq.py,sha256=i7loWty9LEzfP04_FAyrRbKEXShkoQeScLNSuxRVKu8,13334
 keras/src/quantizers/awq_config.py,sha256=jPD8-SRmWn_uHd1YtUEfI6V8fxmylOF8btUJMerVaEs,5701
 keras/src/quantizers/awq_core.py,sha256=AJgbySMvSwENM1u-e08qb00mX5ub3egUrs677UdYKeQ,7640
 keras/src/quantizers/gptq.py,sha256=ph6e-mzjxD0gGn98KiDS48muiScnfFvLnKFCbo1Ik7o,20123
 keras/src/quantizers/gptq_config.py,sha256=zpPWsbfAdYZArhk_alSnFK-nBj92bdJZBzkSM1MKl5g,8925
 keras/src/quantizers/gptq_core.py,sha256=EKhdTXZQ1uo45KYJcO0h9bMTbVZH4pmqs4irQy9r47o,16945
-keras/src/quantizers/quantization_config.py,sha256=8jGV1lzLC-gk37U4By2ol0QJ9T3LNuMynet40xWlxjg,8117
-keras/src/quantizers/quantizers.py,sha256=QzImbGjVaa6pISxhOJPwq7seQC4s_EToI5JHKp0gbkk,36698
+keras/src/quantizers/quantization_config.py,sha256=sdYwrwO-KGHVKYbbzIMI6tbKJ80CDT9GzCBqOWSVACg,12026
+keras/src/quantizers/quantizers.py,sha256=4K4Sh6EqHQ4atFn6sDsEce3WKX1e0iZaGGaZgCaB1WE,45390
 keras/src/quantizers/utils.py,sha256=i6e5MobXrQeKA6zFenjzUNoDDWRGL9bcfgdbE_-0IeM,672
 keras/src/random/__init__.py,sha256=BmXVYPzxbhADohoLtAEEzB3cesP7YBFDsp1qc6BWWlg,420
 keras/src/random/random.py,sha256=bUADZIVDuCghwIWTk0qBxXTxUdiNGWIdsRi8QJ3ePg4,17581
@@ -547,7 +547,7 @@ keras/src/saving/file_editor.py,sha256=mNlXakl58wPC7nWRAVTh-esQ0UN2x-q5piI2ZXYQ8
 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_api.py,sha256=X-zsTum57M3AWf_cYqhq_o5wgLcFxNh1ditoxbL_0LY,14694
 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
@@ -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.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,,
+keras_nightly-3.14.0.dev2026012904.dist-info/METADATA,sha256=0pSnPO1OPi8catYTDRABuendG3SeP4dMURreOSKYJRQ,6339
+keras_nightly-3.14.0.dev2026012904.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+keras_nightly-3.14.0.dev2026012904.dist-info/top_level.txt,sha256=ptcw_-QuGZ4ZDjMdwi_Z0clZm8QAqFdvzzFnDEOTs9o,6
+keras_nightly-3.14.0.dev2026012904.dist-info/RECORD,,