keras-nightly 3.14.0.dev2026011404__py3-none-any.whl → 3.14.0.dev2026011504__py3-none-any.whl

keras/src/quantizers/awq_core.py

@@ -0,0 +1,217 @@
+"""AWQ core functionality for layer-wise quantization.
+
+This module provides the orchestration logic for applying AWQ quantization
+to transformer models in a layer-by-layer fashion.
+"""
+
+from contextlib import contextmanager
+
+from absl import logging
+
+from keras.src import ops
+from keras.src import utils as keras_utils
+from keras.src.dtype_policies.dtype_policy import AWQDTypePolicy
+from keras.src.dtype_policies.dtype_policy_map import DTypePolicyMap
+from keras.src.quantizers.awq import AWQ
+from keras.src.quantizers.awq_config import AWQConfig
+from keras.src.quantizers.gptq_core import find_layers_in_block
+from keras.src.quantizers.gptq_core import get_dataloader
+from keras.src.quantizers.utils import should_quantize_layer
+
+
+@contextmanager
+def stream_activations(layers_map, awq_objects):
+    """Context manager to capture activations for AWQ calibration.
+
+    Temporarily patches layer.call methods to capture activation statistics
+    for computing per-channel scaling factors.
+
+    Args:
+        layers_map: Dict[str, Layer]. Mapping from layer names to layers.
+        awq_objects: Dict[str, AWQ]. Mapping from names to AWQ instances.
+
+    Yields:
+        None: The patched state is active only within the `with` block.
+    """
+    original_calls = {}
+
+    def create_hook(name, original_call_func):
+        def hook(*args, **kwargs):
+            inp = args[0] if args else kwargs["inputs"]
+            num_features = awq_objects[name].rows
+            input_2d = ops.reshape(inp, (-1, num_features))
+            awq_objects[name].update_activation_magnitudes(input_2d)
+            return original_call_func(*args, **kwargs)
+
+        return hook
+
+    try:
+        for name, layer in layers_map.items():
+            original_calls[name] = layer.call
+            layer.call = create_hook(name, layer.call)
+        yield
+    finally:
+        for name, layer in layers_map.items():
+            layer.call = original_calls[name]
+
+
+def apply_awq_layerwise(dataloader, config, structure, filters=None):
+    """Apply AWQ quantization layer-by-layer to a Keras model.
+
+    This function processes the model sequentially, one block at a time:
+    1. Captures activation statistics through calibration data forward pass
+    2. Uses activation magnitudes to determine weight saliency
+    3. Finds optimal per-channel scales via grid search
+    4. Quantizes weights with AWQ scaling
+
+    Args:
+        dataloader: Calibration data as numpy array.
+        config: AWQConfig instance.
+        structure: Dict with 'pre_block_layers' and 'sequential_blocks'.
+        filters: Optional layer filters.
+    """
+    num_samples = config.num_samples
+    logging.info("Starting AWQ quantization...")
+
+    pre_layers = structure.get("pre_block_layers", [])
+    transformer_blocks = structure.get("sequential_blocks", [])
+
+    if not transformer_blocks:
+        raise ValueError(
+            "No sequential blocks found in the structure to quantize."
+        )
+
+    # Process inputs through pre-block layers (e.g., embedding)
+    inputs = []
+    for batch in dataloader:
+        batch = ops.convert_to_tensor(batch, dtype="int32")
+        for layer in pre_layers:
+            batch = layer(batch)
+        inputs.append(batch)
+
+    num_samples = min(num_samples, len(inputs))
+    progbar = keras_utils.Progbar(target=len(transformer_blocks))
+
+    for block_idx, block in enumerate(transformer_blocks):
+        logging.info(f"Quantizing Block {block_idx}")
+        sub_layers_map = find_layers_in_block(block)
+
+        # Apply filters
+        final_sub_layers_map = {}
+        for name, layer in sub_layers_map.items():
+            if not should_quantize_layer(layer, filters):
+                continue
+            final_sub_layers_map[name] = layer
+
+        sub_layers_map = final_sub_layers_map
+
+        if not sub_layers_map:
+            logging.info(
+                f"  No quantizable layers found in block {block_idx}. Skipping."
+            )
+        else:
+            logging.info(f"Found layers: {list(sub_layers_map.keys())}")
+
+            # Create AWQ objects for each layer
+            awq_objects = {
+                name: AWQ(layer, config)
+                for name, layer in sub_layers_map.items()
+            }
+
+            # Capture activation statistics
+            with stream_activations(sub_layers_map, awq_objects):
+                for sample_idx in range(num_samples):
+                    current_input = inputs[sample_idx]
+                    if len(current_input.shape) == 2:
+                        current_input = ops.expand_dims(current_input, axis=0)
+                    _ = block(current_input)
+
+            # Quantize each layer
+            for name, awq_object in awq_objects.items():
+                logging.info(f"Quantizing {name}...")
+                awq_object.quantize_layer()
+                awq_object.free()
+
+            del awq_objects
+
+        # Generate inputs for next block
+        if block_idx < len(transformer_blocks) - 1:
+            logging.info(f"Generating inputs for block {block_idx + 1}...")
+            next_block_inputs = []
+            for sample_idx in range(num_samples):
+                current_input = inputs[sample_idx]
+                if len(current_input.shape) == 2:
+                    current_input = ops.expand_dims(current_input, axis=0)
+                output = block(current_input)[0]
+                next_block_inputs.append(output)
+            inputs = next_block_inputs
+
+        progbar.update(current=block_idx + 1)
+
+    logging.info("AWQ quantization complete.")
+
+
+def awq_quantize(config, quantization_layer_structure, filters=None):
+    """Main entry point for AWQ quantization.
+
+    Args:
+        config: AWQConfig instance.
+        quantization_layer_structure: Model structure dictionary.
+        filters: Optional layer filters.
+    """
+    if config.dataset is None or config.tokenizer is None:
+        raise ValueError(
+            "AWQ quantization requires a dataset and tokenizer. "
+            "Please provide them in the AWQConfig."
+        )
+
+    if quantization_layer_structure is None:
+        raise ValueError(
+            "For 'awq' mode, a valid quantization structure must be provided "
+            "either via `config.quantization_layer_structure` or by overriding "
+            "`model.get_quantization_layer_structure(mode)`. The structure "
+            "should be a dictionary with keys 'pre_block_layers' and "
+            "'sequential_blocks'."
+        )
+
+    # Load calibration data
+    dataloader = get_dataloader(
+        config.tokenizer,
+        config.sequence_length,
+        config.dataset,
+        num_samples=config.num_samples,
+    )
+
+    apply_awq_layerwise(
+        dataloader[: config.num_samples],
+        config,
+        quantization_layer_structure,
+        filters=filters,
+    )
+
+
+def get_group_size_for_layer(layer, config):
+    """Get group size from config or dtype policy.
+
+    Args:
+        layer: The layer to get group size for.
+        config: Optional AWQConfig instance.
+
+    Returns:
+        int: The group size for quantization.
+
+    Raises:
+        ValueError: If group size cannot be determined.
+    """
+    if config and isinstance(config, AWQConfig):
+        return config.group_size
+    elif isinstance(layer.dtype_policy, AWQDTypePolicy):
+        return layer.dtype_policy.group_size
+    elif isinstance(layer.dtype_policy, DTypePolicyMap):
+        policy = layer.dtype_policy[layer.path]
+        if isinstance(policy, AWQDTypePolicy):
+            return policy.group_size
+    raise ValueError(
+        "For AWQ quantization, group_size must be specified "
+        "through AWQConfig or AWQDTypePolicy."
+    )

keras/src/quantizers/gptq.py

@@ -1,5 +1,4 @@
 import types
-from functools import partial
 
 from keras.src import ops
 from keras.src import quantizers
@@ -466,7 +465,7 @@ class GPTQ:
             group_size=self.config.group_size,
             activation_order=self.config.activation_order,
             order_metric=ops.diagonal(hessian_matrix),
-            compute_scale_zero=partial(self.quantizer.find_params, weight=True),
+            compute_scale_zero=self.quantizer.find_params,
         )
         quantized = ops.cast(
             quantized, self.original_layer.quantized_kernel.dtype

keras/src/quantizers/gptq_core.py

@@ -131,7 +131,7 @@ def get_dataloader(
     pieces = []
     if isinstance(dataset_list[0], str):
         for i, s in enumerate(dataset_list):
-            toks = np.asarray(tokenizer.tokenize(s)).reshape(-1)
+            toks = ops.convert_to_numpy(tokenizer.tokenize(s)).reshape(-1)
             pieces.append(toks)
             # avoid windows that span document boundaries
             if eos_id is not None and i < len(dataset_list) - 1:

keras/src/quantizers/quantization_config.py

@@ -182,6 +182,11 @@ def validate_and_resolve_config(mode, config):
                 "For GPTQ, you must pass a `GPTQConfig` object in the "
                 "`config` argument."
             )
+        elif mode == "awq":
+            raise ValueError(
+                "For AWQ, you must pass an `AWQConfig` object in the "
+                "`config` argument."
+            )
         else:
             if mode is not None:
                 raise ValueError(
@@ -220,6 +225,15 @@ def validate_and_resolve_config(mode, config):
                 f"`GPTQConfig`. Received: {type(config)}"
             )
 
+    if mode == "awq":
+        from keras.src.quantizers.awq_config import AWQConfig
+
+        if not isinstance(config, AWQConfig):
+            raise ValueError(
+                "Mode 'awq' requires a valid `config` argument of type "
+                f"`AWQConfig`. Received: {type(config)}"
+            )
+
     return config
 
 

keras/src/quantizers/quantizers.py

@@ -653,11 +653,14 @@ def unpack_int4(packed, orig_len, axis=0, dtype="int8"):
         )
 
     def to_signed(x):
-        """Converts unpacked nibbles [0, 15] to signed int4 [-8, 7]."""
+        """Converts unpacked nibbles [0, 15] to signed int4 [-8, 7].
+
+        Uses a branchless XOR approach: (x ^ 8) - 8
+        This maps: 0->0, 1->1, ..., 7->7, 8->-8, 9->-7, ..., 15->-1
+        """
         dtype_x = backend.standardize_dtype(x.dtype)
         eight = ops.cast(8, dtype_x)
-        sixteen = ops.cast(16, dtype_x)
-        return ops.where(x < eight, x, x - sixteen)
+        return ops.subtract(ops.bitwise_xor(x, eight), eight)
 
     rank = getattr(packed.shape, "rank", None) or len(packed.shape)
     if axis < 0:
@@ -748,7 +751,7 @@ class GPTQQuantizer(Quantizer):
         self.zero = None
         self.maxq = None
 
-    def find_params(self, input_tensor, weight=True):
+    def find_params(self, input_tensor):
         """Finds quantization parameters (scale and zero) for a given tensor."""
         self.scale, self.zero, self.maxq = compute_quantization_parameters(
             input_tensor,
@@ -756,7 +759,6 @@ class GPTQQuantizer(Quantizer):
             symmetric=self.symmetric,
             per_channel=self.per_channel,
             group_size=self.group_size,
-            weight=weight,
             compute_dtype=self.compute_dtype,
         )
         return self.scale, self.zero, self.maxq
@@ -793,98 +795,105 @@ def compute_quantization_parameters(
     symmetric=False,
     per_channel=False,
     group_size=-1,
-    weight=False,
     compute_dtype="float32",
 ):
     """
-    Computes the scale and zero-point for quantization.
+    Computes the scale and zero-point for quantizing weight tensors.
 
     This function calculates the scale and zero-point required for quantizing
-    a given tensor `x` based on the specified parameters. It supports grouped,
-    per-channel, per-tensor, symmetric, and asymmetric quantization - along
-    with any combinations of these.
+    a given weight tensor `x` based on the specified parameters. It supports
+    grouped, per-channel, per-tensor, symmetric, and asymmetric quantization.
+
+    For grouped quantization (per_channel=True, group_size > 0), the output
+    shapes are [out_features, n_groups] where n_groups is the number of groups
+    along the in_features dimension.
 
     Args:
-        x: KerasTensor. The input tensor to quantize.
+        x: KerasTensor. The weight tensor to quantize with shape
+            [out_features, in_features].
         bits: int. The number of bits to quantize to (e.g., 4).
         symmetric: bool. Whether to use symmetric quantization.
         per_channel: bool. Whether to quantize per channel.
-        group_size: int. The group size for quantization.
-        weight: bool. Whether the input tensor is a weight tensor.
+        group_size: int. The group size for quantization. -1 means no grouping.
+        compute_dtype: str. The dtype for computation. Defaults to "float32".
 
     Returns:
         scale: KerasTensor. The scale tensor for quantization.
         zero: KerasTensor. The zero tensor for quantization.
         maxq: scalar. The maximum quantization value.
     """
+    # Input validation
     if x is None:
         raise ValueError(f"Input tensor {x} cannot be None.")
-
-    # For weights, we typically expect at least a 2D tensor.
-    if weight and len(x.shape) < 2:
+    if len(x.shape) < 2:
         raise ValueError(
             f"Input weight tensor {x} must have a rank of at "
             f"least 2, but got rank {len(x.shape)}."
         )
-
     if ops.size(x) == 0:
         raise ValueError("Input tensor 'x' cannot be empty.")
 
-    original_shape = x.shape
-
-    if per_channel:
-        if weight:
-            if group_size != -1:
-                input_reshaped = ops.reshape(x, [-1, group_size])
-            else:
-                input_reshaped = ops.reshape(x, [original_shape[0], -1])
-    else:  # per-tensor
-        input_reshaped = ops.reshape(x, [1, -1])
+    out_features, in_features = x.shape[0], x.shape[1]
 
-    # Find min/max values
-    min_values = ops.min(input_reshaped, axis=1)
-    max_values = ops.max(input_reshaped, axis=1)
+    # Determine number of groups for quantization
+    if per_channel and group_size > 0:
+        n_groups = (in_features + group_size - 1) // group_size
+    else:
+        n_groups = 1
+
+    # Compute min/max values based on quantization mode
+    if n_groups > 1:
+        # Grouped quantization: output shape [out_features, n_groups]
+        remainder = in_features % group_size
+        if remainder != 0:
+            pad_size = group_size - remainder
+            x = ops.pad(x, [[0, 0], [0, pad_size]], constant_values=0.0)
+
+        x_grouped = ops.reshape(x, [out_features, n_groups, group_size])
+        min_values = ops.min(x_grouped, axis=2)
+        max_values = ops.max(x_grouped, axis=2)
+    else:
+        # Per-channel or per-tensor: compute stats along rows
+        reduction_shape = [out_features, -1] if per_channel else [1, -1]
+        x_reshaped = ops.reshape(x, reduction_shape)
+        min_values = ops.min(x_reshaped, axis=1)
+        max_values = ops.max(x_reshaped, axis=1)
 
-    # Apply symmetric quantization logic if enabled
+    # Symmetric quantization: make range symmetric around zero
     if symmetric:
-        max_values = ops.maximum(ops.abs(min_values), max_values)
+        max_abs = ops.maximum(ops.abs(min_values), max_values)
         min_values = ops.where(
-            ops.less(min_values, 0), ops.negative(max_values), min_values
+            ops.less(min_values, 0), ops.negative(max_abs), min_values
         )
+        max_values = max_abs
 
-    # Ensure range is not zero to avoid division errors
+    # Ensure non-zero range to avoid division errors
     zero_range = ops.equal(min_values, max_values)
     min_values = ops.where(zero_range, ops.subtract(min_values, 1), min_values)
     max_values = ops.where(zero_range, ops.add(max_values, 1), max_values)
 
+    # Compute scale and zero-point
     maxq = ops.cast(ops.subtract(ops.power(2, bits), 1), compute_dtype)
-
-    # Calculate scale and zero-point
     scale = ops.divide(ops.subtract(max_values, min_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))
     else:
         zero = ops.round(ops.divide(ops.negative(min_values), scale))
 
-    # Ensure scale is non-zero
-    scale = ops.where(ops.less_equal(scale, 0), 1e-8, scale)
-
-    if weight:
-        # Per-channel, non-grouped case: simple reshape is correct.
-        if per_channel and group_size == -1:
-            scale = ops.reshape(scale, [-1, 1])
-            zero = ops.reshape(zero, [-1, 1])
-        elif not per_channel:
-            num_rows = original_shape[0]
-            scale = ops.tile(ops.reshape(scale, (1, 1)), (num_rows, 1))
-            zero = ops.tile(ops.reshape(zero, (1, 1)), (num_rows, 1))
-    if per_channel:
+    # Reshape output to [out_features, n_groups] or [out_features, 1]
+    if n_groups > 1:
+        pass  # Already [out_features, n_groups]
+    elif per_channel:
         scale = ops.reshape(scale, [-1, 1])
         zero = ops.reshape(zero, [-1, 1])
+    else:
+        # Per-tensor: tile single value to [out_features, 1]
+        scale = ops.tile(ops.reshape(scale, (1, 1)), (out_features, 1))
+        zero = ops.tile(ops.reshape(zero, (1, 1)), (out_features, 1))
 
-    zero = ops.cast(zero, "uint8")
-
-    return scale, zero, maxq
+    return scale, ops.cast(zero, "uint8"), maxq
 
 
 def quantize_with_zero_point(input_tensor, scale, zero, maxq):

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

{keras_nightly-3.14.0.dev2026011404.dist-info → keras_nightly-3.14.0.dev2026011504.dist-info}/METADATA

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

{keras_nightly-3.14.0.dev2026011404.dist-info → keras_nightly-3.14.0.dev2026011504.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=6Qd7KpNMMtqO5FV__5Vte12ig0fK0_j3jKCF6nQUarI,877
+keras/_tf_keras/keras/dtype_policies/__init__.py,sha256=c8mnzGQbn3b5EQ6v6zBnrkgs9EFcrPRi5Zv4TEVcolg,969
 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=S5jh1Gir4TVjUwFcpnQZta9gH6hxkuLlsGmVRPItRVs,1585
+keras/_tf_keras/keras/quantizers/__init__.py,sha256=kDf-LP5ola_TxzeClJTqSS42k4mzF-BcP5zh7Xh7miE,1652
 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=6Qd7KpNMMtqO5FV__5Vte12ig0fK0_j3jKCF6nQUarI,877
+keras/dtype_policies/__init__.py,sha256=c8mnzGQbn3b5EQ6v6zBnrkgs9EFcrPRi5Zv4TEVcolg,969
 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=S5jh1Gir4TVjUwFcpnQZta9gH6hxkuLlsGmVRPItRVs,1585
+keras/quantizers/__init__.py,sha256=kDf-LP5ola_TxzeClJTqSS42k4mzF-BcP5zh7Xh7miE,1652
 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=w8F4qXHXwmNxkt7YJdj-CSjcFul2E8ddmb8Thwa2k5c,204
+keras/src/version.py,sha256=9qMnmtF-qZTXfhu_aYy3T9wAf18rbTFfpRqEiny8QSU,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
@@ -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=iRzcXqc8Aq_sLh5TgFiLCtgHLfotvI-S29KGwocIN68,103924
+keras/src/backend/openvino/numpy.py,sha256=sSPcjNoUxP9qsIEOf3m37I8rqV0MrGPtPEijeQpp0yk,105535
 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
@@ -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=BxFBq8xa6Cb-LndCZhIACX1ubym7Ky8tUQ8rxIVdeKg,3632
-keras/src/dtype_policies/dtype_policy.py,sha256=0gE6tGKUDRcrNCi-4_UU2sMFO_zMc8QGd3gzPBI-Rfs,16005
+keras/src/dtype_policies/__init__.py,sha256=8Ju8ICwTDdBfBrSoL6kmMzrcgMwMg6dPa1UPMDZKTqc,3717
+keras/src/dtype_policies/dtype_policy.py,sha256=3e2J589g0NUALz0LycSb3anh47g5LWIgn0jKR26B-Cs,19143
 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
@@ -295,7 +295,7 @@ keras/src/initializers/initializer.py,sha256=kNAyRA8CzBdtknT6ZUt5XIO2_Z9NzpN119C
 keras/src/initializers/random_initializers.py,sha256=AuUeQ3YZGakDKTCs8njQLhozE6iWYHwP6-VstnEMOaQ,23631
 keras/src/layers/__init__.py,sha256=s7jrOesk0YMUKCxe5BTdQ5cxqrnkYbA-GWRoCXuqpsg,12103
 keras/src/layers/input_spec.py,sha256=cjBUBmgdneJfhvbI-WLqSapJInCsxliWBygyfMWgkj4,10010
-keras/src/layers/layer.py,sha256=KOgSWAzj4fe3_ohIKPFStMw3r20ED9vzqYTq_e-SeLw,79436
+keras/src/layers/layer.py,sha256=Nbs9ke8ecAhTffiHyZ2cJUIt-3yaJb5fcjXKJAnOCHE,79634
 keras/src/layers/activations/__init__.py,sha256=MhPBye8WWLSf_iDel3BuuqYk4nx6Sym8s4dZKb1KTqQ,272
 keras/src/layers/activations/activation.py,sha256=c_Q5gUjCTD70a9-I1m5eEPcrWPpE-5iAlkDMt4lxRgA,1287
 keras/src/layers/activations/elu.py,sha256=jtszCDe6Cs_L3jITK3ascKouqgYUxdbGvT60kxQbcHM,840
@@ -324,9 +324,9 @@ 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=pCNxqIhUFZpAGicg7ls8fN2FunM-RP02CwSsCO22MfA,36378
-keras/src/layers/core/einsum_dense.py,sha256=tOvrYyRWSGh1JxIxpPgCFRydqdIht82WUznM9BEqe08,64507
-keras/src/layers/core/embedding.py,sha256=V-ZiIsL0uMpuv9nBqF4PwilU0ajsjnuN3XbBjy29kFM,22639
+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/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
@@ -492,7 +492,7 @@ keras/src/metrics/regression_metrics.py,sha256=eLacV_8CKtzA26BJDJuncUDATuL1x8O6S
 keras/src/models/__init__.py,sha256=DPbBPSfIGgsufTfJH5U5xJOeN_Ef4FMadT7KKYg3Kjg,143
 keras/src/models/cloning.py,sha256=P0gMH3H9nyz6SMsdt4BQO05rXFa4qiqZk44rFpEnHsM,15945
 keras/src/models/functional.py,sha256=uD-qH9WwAUhaBrAEWAKnsVvKo0tvdHxa1M0dbBOE96Y,34086
-keras/src/models/model.py,sha256=9kM6rbiAZOx3ycq2qM7QV6h2P1di57rA2HlljstSkh8,42215
+keras/src/models/model.py,sha256=szseM7sjfNkdOGytF25nijhjERBu_66WPSYaJ719VBY,42408
 keras/src/models/sequential.py,sha256=CC9Q1BNB9m7TkgMHRyjOzhQvneng576wJpmdgHrACKY,14352
 keras/src/models/variable_mapping.py,sha256=FVtcgjBRqOxtvkzOE6kjG9SpcB9keDg2gS5LOTlXvG0,2181
 keras/src/ops/__init__.py,sha256=aORlvnrqY_eQl0EFLWdpHsXHnQ6JLSw1qhwJMr-VXJ0,644
@@ -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=H-OdMMkMsbVTfha0zceIMGQN8Nr2S5iNAT0oKwLjB10,256861
+keras/src/ops/numpy.py,sha256=6oaYtC0HDCPAKjn3lG4Yd9SjYKL8nRySC0IA9aXsKbg,257233
 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
@@ -527,12 +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=P5AJBRuL-4K75JGeONRb0WxQpJxEA6dCGdQgst_GBoc,2390
-keras/src/quantizers/gptq.py,sha256=fKrmT_pxpTCMXhNt34m9K4NWGdUXX-1SUX6I4buE2Vg,20175
+keras/src/quantizers/__init__.py,sha256=3LlZ1Z5G5mYVdrZ2xnoFgW28OFneYc_Ys2dzuJ3S0nk,2459
+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=u-kb58KfmcYg4-TNFPqvBJ9z8a7Yqgu6Qz87tvsOEgI,16935
-keras/src/quantizers/quantization_config.py,sha256=9bxhF9EwG9Q49rpMiHh8PLwMF0Gxc5JyNCNKPwLx5uQ,7631
-keras/src/quantizers/quantizers.py,sha256=BDD3vi_15lmOY_ybI7oQDgINYlM9CF0QSQuP6kzjXH4,35964
+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/utils.py,sha256=i6e5MobXrQeKA6zFenjzUNoDDWRGL9bcfgdbE_-0IeM,672
 keras/src/random/__init__.py,sha256=BmXVYPzxbhADohoLtAEEzB3cesP7YBFDsp1qc6BWWlg,420
 keras/src/random/random.py,sha256=bUADZIVDuCghwIWTk0qBxXTxUdiNGWIdsRi8QJ3ePg4,17581
@@ -615,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.dev2026011404.dist-info/METADATA,sha256=kQdBx6UVd9ve6T2k1-rLnycFlcoNFSJWmzXOerCw39g,6339
-keras_nightly-3.14.0.dev2026011404.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-keras_nightly-3.14.0.dev2026011404.dist-info/top_level.txt,sha256=ptcw_-QuGZ4ZDjMdwi_Z0clZm8QAqFdvzzFnDEOTs9o,6
-keras_nightly-3.14.0.dev2026011404.dist-info/RECORD,,
+keras_nightly-3.14.0.dev2026011504.dist-info/METADATA,sha256=6s-lhD6ZQgn-dl1KiHGJMLNttJ4ir79glEAKZAMn6fI,6339
+keras_nightly-3.14.0.dev2026011504.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+keras_nightly-3.14.0.dev2026011504.dist-info/top_level.txt,sha256=ptcw_-QuGZ4ZDjMdwi_Z0clZm8QAqFdvzzFnDEOTs9o,6
+keras_nightly-3.14.0.dev2026011504.dist-info/RECORD,,