keras-nightly 3.12.0.dev2025083103__py3-none-any.whl → 3.14.0.dev2026011604__py3-none-any.whl

keras/src/quantizers/quantizers.py

@@ -9,6 +9,7 @@ from keras.src.backend import any_symbolic_tensors
 from keras.src.backend.common.backend_utils import canonicalize_axis
 from keras.src.backend.common.backend_utils import standardize_axis_for_numpy
 from keras.src.ops.operation import Operation
+from keras.src.quantizers.gptq_config import GPTQConfig
 
 """Int8-related classes and methods"""
 
@@ -72,6 +73,23 @@ def abs_max_quantize(
     epsilon=backend.epsilon(),
     to_numpy=False,
 ):
+    """
+    Quantizes the input tensor using the absolute maximum quantization scheme.
+
+    Args:
+        inputs: Input tensor to quantize.
+        axis: Axis along which to compute the quantization range.
+        value_range: Tuple of the minimum and maximum values of the quantization
+            range.
+        dtype: Data type of the quantized output.
+        epsilon: Small value to avoid division by zero.
+        to_numpy: Whether to perform the quantization in numpy. This performs
+            the computation on the host CPU and can be useful for saving memory
+            on the device. If False, the computation is performed on the device.
+
+    Returns:
+        A tuple of the quantized tensor and the scale.
+    """
     if to_numpy:
         # Save memory on the device using numpy
         original_dtype = backend.standardize_dtype(inputs.dtype)
@@ -104,31 +122,69 @@ def abs_max_quantize(
 class AbsMaxQuantizer(Quantizer):
     def __init__(
         self,
-        axis,
+        axis=None,  # Deprecated, provide axis in __call__ instead.
         value_range=(-127, 127),
         epsilon=backend.epsilon(),
         output_dtype="int8",
     ):
         Quantizer.__init__(self, output_dtype=output_dtype)
-        if isinstance(axis, int):
-            axis = (axis,)
-        self.axis = tuple(axis)
+        if axis is not None:
+            if isinstance(axis, int):
+                axis = (axis,)
+            self.axis = tuple(axis)
+        else:
+            self.axis = None
         self.value_range = value_range
         self.epsilon = epsilon
+        if output_dtype == "int8":
+            if value_range[0] < -128 or value_range[1] > 127:
+                raise ValueError(
+                    f"Quantizer with output_dtype='int8' requires value_range "
+                    f"to be within the interval [-128, 127]. Received: "
+                    f"value_range={value_range}"
+                )
 
-    def __call__(self, x):
+    def __call__(self, x, axis=None, to_numpy=False):
+        """
+        Quantizes the input tensor.
+
+        Args:
+            x: Input tensor to quantize.
+            axis: Axis along which to compute the quantization range. If None,
+                uses the axis specified in the constructor. If None and no axis
+                was specified in the constructor, defaults to -1.
+            to_numpy: Whether to perform the quantization in numpy. This
+                performs the computation on the host CPU and can be useful for
+                saving memory on the device. If False, the computation is
+                performed on the device.
+
+        Returns:
+            A tuple of the quantized tensor and the scale.
+        """
+        if axis is None:
+            axis = self.axis
+        if axis is None:
+            # Default to -1 if no axis is specified
+            axis = -1
         quantized_x, scale = abs_max_quantize(
-            x, self.axis, self.value_range, self.output_dtype, self.epsilon
+            x,
+            axis,
+            self.value_range,
+            self.output_dtype,
+            self.epsilon,
+            to_numpy,
         )
         return quantized_x, scale
 
     def get_config(self):
-        return {
-            "axis": self.axis,
+        config = {
             "value_range": self.value_range,
             "epsilon": self.epsilon,
             "output_dtype": self.output_dtype,
         }
+        if self.axis is not None:
+            config["axis"] = self.axis
+        return config
 
 
 def adjust_and_nudge(min_range, max_range, num_bits, narrow_range):
@@ -280,7 +336,7 @@ def fake_quant_with_min_max_vars(
             ops.add(ops.multiply(-nudged_min, inv_scale), 0.5)
         )
         x_clamped = ops.clip(
-            x, ops.cast(nudged_min, x.dtype), ops.cast(nudged_max, x.dtype)
+            ops.cast(x, nudged_min.dtype), nudged_min, nudged_max
         )
         x_clamped_shifted = ops.subtract(x_clamped, nudged_min)
         result = ops.multiply(
@@ -317,6 +373,7 @@ def fake_quant_with_min_max_vars(
                 grad_min = ops.sum(grad_min, axis=axes)
             else:
                 grad_min = ops.sum(grad_min)
+            grad_min = ops.reshape(grad_min, ops.shape(min_val))
 
             # Gradient for max_val
             # When x is clipped to max, the gradient flows to max_val
@@ -326,6 +383,7 @@ def fake_quant_with_min_max_vars(
                 grad_max = ops.sum(grad_max, axis=axes)
             else:
                 grad_max = ops.sum(grad_max)
+            grad_max = ops.reshape(grad_max, ops.shape(max_val))
 
             return dx, grad_min, grad_max
 
@@ -377,7 +435,7 @@ def quantize_and_dequantize(inputs, scale, quantized_dtype, compute_dtype):
 
 
 @keras_export("keras.quantizers.pack_int4")
-def pack_int4(arr, axis=0):
+def pack_int4(arr, axis=0, dtype="int8"):
     """Pack an int4 tensor into an int8 tensor with packed nibbles.
 
     The input values must already be int8 in the signed range `[-8, 7]` and
@@ -389,8 +447,11 @@ def pack_int4(arr, axis=0):
     the value from the second row.
 
     Args:
-        arr: An int8 tensor containing int4 values in the range `[-8, 7]`.
+        arr: An `int8` or `uint8` tensor containing int4 values in the range
+            `[-8, 7]`.
         axis: The axis along which to pack the tensor. Defaults to 0.
+        dtype: The data type of the input and packed tensor. Can be
+            `"int8"` or `"uint8"`. Defaults to `"int8"`.
 
     Returns:
         tuple: A tuple `(packed, packed_shape, orig_rows)` where `packed` is
@@ -450,9 +511,14 @@ def pack_int4(arr, axis=0):
     True
     ```
     """
-    if backend.standardize_dtype(arr.dtype) != "int8":
+    if dtype not in ("int8", "uint8"):
+        raise ValueError(
+            f"Expected dtype to be 'int8' or 'uint8', but got '{dtype}'."
+        )
+    if backend.standardize_dtype(arr.dtype) != dtype:
         raise TypeError(
-            "Expected int8 tensor for packing, got {}".format(arr.dtype)
+            f"Expected {dtype} tensor for packing, got "
+            f"{backend.standardize_dtype(arr.dtype)}."
         )
 
     rank = getattr(arr.shape, "rank", None) or len(arr.shape)
@@ -486,12 +552,12 @@ def pack_int4(arr, axis=0):
     low = padded[::2, ...]
     high = padded[1::2, ...]
 
-    mask = ops.array(0x0F, dtype="int8")
+    mask = ops.array(0x0F, dtype=dtype)
     low_u = ops.bitwise_and(low, mask)
     high_u = ops.bitwise_and(high, mask)
 
     packed = ops.bitwise_or(low_u, ops.left_shift(high_u, 4))
-    packed = ops.cast(packed, "int8")
+    packed = ops.cast(packed, dtype)
 
     # 5-6. Restore shape.
     packed = ops.transpose(packed, inv_perm)  # back to original order
@@ -500,7 +566,7 @@ def pack_int4(arr, axis=0):
 
 
 @keras_export("keras.quantizers.unpack_int4")
-def unpack_int4(packed, orig_len, axis=0):
+def unpack_int4(packed, orig_len, axis=0, dtype="int8"):
     """Unpack a packed int4 back to an int8 tensor in the range [-8, 7].
 
     This function reverses the packing performed by `pack_int4`, restoring
@@ -518,6 +584,8 @@ def unpack_int4(packed, orig_len, axis=0):
             packed. This is used to remove any padding that may have
             been added during packing to ensure an even number of rows.
         axis: The axis along which the tensor was packed. Defaults to 0.
+        dtype: The data type of the input and unpacked tensor. Can be
+            `"int8"` or `"uint8"`. Defaults to `"int8"`.
 
     Returns:
         unpacked: An int8 tensor with the same shape as the original
@@ -574,13 +642,27 @@ def unpack_int4(packed, orig_len, axis=0):
     True
     ```
     """
-    if backend.standardize_dtype(packed.dtype) != "int8":
+    if dtype not in ("int8", "uint8"):
+        raise ValueError(
+            f"Expected dtype to be 'int8' or 'uint8', but got '{dtype}'."
+        )
+
+    if backend.standardize_dtype(packed.dtype) not in ("int8", "uint8"):
         raise TypeError(
-            f"Expected int8 tensor for unpacking, got {packed.dtype}"
+            f"Expected int8 or uint8 tensor for unpacking, got {packed.dtype}"
         )
 
-    rank = getattr(packed.shape, "rank", None) or len(packed.shape)
+    def to_signed(x):
+        """Converts unpacked nibbles [0, 15] to signed int4 [-8, 7].
+
+        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)
+        return ops.subtract(ops.bitwise_xor(x, eight), eight)
 
+    rank = getattr(packed.shape, "rank", None) or len(packed.shape)
     if axis < 0:
         axis += rank
 
@@ -591,16 +673,15 @@ def unpack_int4(packed, orig_len, axis=0):
         low_unpacked = ops.bitwise_and(packed, mask)
         high_unpacked = ops.bitwise_and(ops.right_shift(packed, 4), mask)
 
-        # Convert values from [0, 15] to [-8, 7].
-        low_signed = ops.where(
-            low_unpacked < 8, low_unpacked, low_unpacked - 16
-        )
-        high_signed = ops.where(
-            high_unpacked < 8, high_unpacked, high_unpacked - 16
-        )
+        if dtype == "int8":
+            low_unpacked = to_signed(low_unpacked)
+            high_unpacked = to_signed(high_unpacked)
+
+        low_final = ops.cast(low_unpacked, dtype)
+        high_final = ops.cast(high_unpacked, dtype)
 
         # Interleave and reshape
-        stacked = ops.stack([low_signed, high_signed], axis=1)
+        stacked = ops.stack([low_final, high_final], axis=1)
         unpacked = ops.reshape(stacked, (-1,) + tuple(ops.shape(packed)[1:]))
 
         # Remove padding and return
@@ -612,25 +693,313 @@ def unpack_int4(packed, orig_len, axis=0):
     transposed = ops.transpose(packed, perm)
 
     # 1. Split nibbles.
-    mask = ops.array(0x0F, dtype="int8")  # int8 arrays
+    mask = ops.array(0x0F, dtype=packed.dtype)
     low = ops.bitwise_and(transposed, mask)
     high = ops.bitwise_and(ops.right_shift(transposed, 4), mask)
 
-    eight = ops.array(8, dtype="int8")
-    sixteen = ops.array(16, dtype="int8")
-
-    def to_signed(x):
-        return ops.where(x < eight, x, x - sixteen)
+    # 2. Conditionally convert to signed.
+    if dtype == "int8":
+        low = to_signed(low)
+        high = to_signed(high)
 
-    low = to_signed(low)
-    high = to_signed(high)
+    low = ops.cast(low, dtype)
+    high = ops.cast(high, dtype)
 
-    # 2. Interleave and reshape.
-    stacked = ops.stack([low, high], axis=1)  # (pairs, 2, ...)
+    # 3. Interleave and reshape.
+    stacked = ops.stack([low, high], axis=1)
     unpacked = ops.reshape(stacked, (-1,) + tuple(ops.shape(transposed)[1:]))
 
     # 4. Remove padding and restore original layout.
     unpacked = unpacked[:orig_len, ...]
     unpacked = ops.transpose(unpacked, inv_perm)
 
-    return unpacked  # dtype is int8
+    return unpacked
+
+
+class GPTQQuantizer(Quantizer):
+    """A class that handles the quantization of weights using GPTQ method.
+
+    This class provides methods to find quantization parameters (scale and zero)
+    for a given tensor and can be used to quantize weights in a GPTQ context.
+
+    Args:
+        weight_bits: (int) The number of bits to quantize to (e.g., 4).
+        per_channel: (bool) A flag indicating whether quantization is
+            applied per-channel (`True`) or per-tensor (`False`).
+            Defaults to `False`.
+        symmetric: (bool) A flag indicating whether symmetric (`True`) or
+            asymmetric (`False`) quantization is used. Defaults to `False`.
+        group_size: (int) The size of weight groups for quantization. A
+            value of -1 indicates that grouping is not used.
+            Defaults to -1.
+    """
+
+    def __init__(
+        self,
+        config=GPTQConfig(tokenizer=None, dataset=None),
+        compute_dtype="float32",
+    ):
+        Quantizer.__init__(self)
+        self.weight_bits = config.weight_bits
+        self.per_channel = config.per_channel
+        self.symmetric = config.symmetric
+        self.group_size = config.group_size
+        self.compute_dtype = compute_dtype
+
+        # These are now determined later by `find_params`
+        self.scale = None
+        self.zero = None
+        self.maxq = None
+
+    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,
+            bits=self.weight_bits,
+            symmetric=self.symmetric,
+            per_channel=self.per_channel,
+            group_size=self.group_size,
+            compute_dtype=self.compute_dtype,
+        )
+        return self.scale, self.zero, self.maxq
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "weight_bits": self.weight_bits,
+                "per_channel": self.per_channel,
+                "symmetric": self.symmetric,
+                "group_size": self.group_size,
+            }
+        )
+        return config
+
+    @classmethod
+    def from_config(cls, config):
+        gptq = GPTQConfig(
+            tokenizer=None,
+            dataset=None,
+            weight_bits=config["weight_bits"],
+            per_channel=config["per_channel"],
+            symmetric=config["symmetric"],
+            group_size=config["group_size"],
+        )
+        return cls(gptq)
+
+
+def compute_quantization_parameters(
+    x,
+    *,
+    bits,
+    symmetric=False,
+    per_channel=False,
+    group_size=-1,
+    compute_dtype="float32",
+):
+    """
+    Computes the scale and zero-point for quantizing weight tensors.
+
+    This function calculates the scale and zero-point required for quantizing
+    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 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. -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.")
+    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.")
+
+    out_features, in_features = x.shape[0], x.shape[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)
+
+    # Symmetric quantization: make range symmetric around zero
+    if symmetric:
+        max_abs = ops.maximum(ops.abs(min_values), max_values)
+        min_values = ops.where(
+            ops.less(min_values, 0), ops.negative(max_abs), min_values
+        )
+        max_values = max_abs
+
+    # 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)
+    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))
+
+    # 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))
+
+    return scale, ops.cast(zero, "uint8"), maxq
+
+
+def quantize_with_zero_point(input_tensor, scale, zero, maxq):
+    """Quantize a float tensor into discrete levels [0, maxq] using
+    per-tensor/per-channel/grouped scaling.
+
+    Returns `q` (same dtype as inputs/scales; float is fine) where values are in
+    [0, maxq].
+
+    Args:
+        input_tensor: KerasTensor. The input tensor to quantize.
+        scale: KerasTensor. The scale tensor for quantization.
+        zero: KerasTensor. The zero tensor for quantization.
+        maxq: KerasTensor. The maximum quantization value.
+
+    Returns:
+        KerasTensor. The quantized tensor.
+    """
+    # Guard against divide-by-zero
+    epsilon = ops.cast(1e-8, dtype=scale.dtype)
+    safe_scale = ops.where(ops.equal(scale, 0), epsilon, scale)
+
+    quantized_tensor = ops.round(
+        ops.add(
+            ops.divide(input_tensor, safe_scale), ops.cast(zero, scale.dtype)
+        )
+    )
+    quantized_tensor = ops.clip(quantized_tensor, 0, maxq)
+    return quantized_tensor
+
+
+def dequantize_with_zero_point(input_tensor, scale, zero):
+    """
+    Dequantizes a quantized tensor using the provided scale and zero tensors.
+
+    Args:
+        input_tensor: KerasTensor. The quantized tensor to dequantize.
+        scale: KerasTensor. The scale tensor for dequantization.
+        zero: KerasTensor. The zero tensor for dequantization.
+
+    Returns:
+        KerasTensor. The dequantized tensor.
+    """
+    return ops.multiply(
+        scale, ops.subtract(input_tensor, ops.cast(zero, scale.dtype))
+    )
+
+
+def quantize_with_sz_map(weights_matrix, scale, zero, g_idx, maxq):
+    """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.
+
+    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).
+
+    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]
+
+    # 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):
+    """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.
+
+    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).
+
+    Returns:
+        A tensor with the same shape as `weights_matrix` containing the
+        dequantized weights produced using the provided group parameters.
+    """
+    # 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)
+    zeros_mapped = ops.cast(zeros_mapped, scales_mapped.dtype)
+
+    quantized = ops.multiply(
+        ops.subtract(weights_matrix, zeros_mapped), scales_mapped
+    )
+
+    return quantized

keras/src/quantizers/utils.py

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

keras/src/random/seed_generator.py

@@ -8,6 +8,8 @@ from keras.src.backend.common import global_state
 from keras.src.utils import jax_utils
 from keras.src.utils.naming import auto_name
 
+GLOBAL_SEED_GENERATOR = "global_seed_generator"
+
 
 @keras_export("keras.random.SeedGenerator")
 class SeedGenerator:
@@ -27,7 +29,7 @@ class SeedGenerator:
     a local `StateGenerator` with either a deterministic or random initial
     state.
 
-    Remark concerning the JAX backen: Note that the use of a local
+    Remark concerning the JAX backend: Note that the use of a local
     `StateGenerator` as seed argument is required for JIT compilation of
     RNG with the JAX backend, because the use of global state is not
     supported.
@@ -109,7 +111,7 @@ class SeedGenerator:
         return new_seed_value
 
     def get_config(self):
-        return {"seed": self._initial_seed}
+        return {"seed": self._initial_seed, "name": self.name}
 
     @classmethod
     def from_config(cls, config):
@@ -133,10 +135,10 @@ def global_seed_generator():
             "out = keras.random.normal(shape=(1,), seed=self.seed_generator)\n"
             "```"
         )
-    gen = global_state.get_global_attribute("global_seed_generator")
+    gen = global_state.get_global_attribute(GLOBAL_SEED_GENERATOR)
     if gen is None:
         gen = SeedGenerator()
-        global_state.set_global_attribute("global_seed_generator", gen)
+        global_state.set_global_attribute(GLOBAL_SEED_GENERATOR, gen)
     return gen