tico 0.3.0.dev261008__tar.gz → 0.3.0.dev261013__tar.gz

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tico
-Version: 0.3.0.dev261008
+Version: 0.3.0.dev261013
 Summary: Convert Exported Torch Module To Circle
 License: This file provides full text of licenses used in this project
         

tico-0.3.0.dev261013/tico/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.0.dev261013"

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico/quantization/algorithm/gemma4_gptq/quantizer.py

@@ -35,6 +35,7 @@ from tico.quantization.algorithm.gemma4_gptq.utils import (
     should_quantize_text_stage,
     should_quantize_vision_stage,
 )
+from tico.quantization.algorithm.gptq.utils import resolve_weight_bits
 from tico.quantization.config.gemma4_gptq import Gemma4GPTQConfig
 from tico.quantization.quantizer import BaseQuantizer
 from tico.quantization.quantizer_registry import register_quantizer
@@ -104,27 +105,15 @@ class Gemma4GPTQQuantizer(BaseQuantizer):
         """
         Resolve the effective bit-width for a quantized submodule.
 
-        Override keys are matched in the following order:
-            1) Full module name.
-            2) Stage-local module name.
-            3) Full-name suffix.
+        Delegates to :func:`resolve_weight_bits`, which documents the
+        full name -> stage-local name -> suffix (last match) -> default policy.
         """
-        if full_module_name in gptq_conf.weight_bits_overrides:
-            return gptq_conf.weight_bits_overrides[full_module_name]
-
-        if local_module_name in gptq_conf.weight_bits_overrides:
-            return gptq_conf.weight_bits_overrides[local_module_name]
-
-        suffix_matches = [
-            bits
-            for pattern, bits in gptq_conf.weight_bits_overrides.items()
-            if full_module_name.endswith(f".{pattern}")
-        ]
-
-        if suffix_matches:
-            return suffix_matches[-1]
-
-        return gptq_conf.weight_bits
+        return resolve_weight_bits(
+            default_bits=gptq_conf.weight_bits,
+            weight_bits_overrides=gptq_conf.weight_bits_overrides,
+            full_module_name=full_module_name,
+            local_module_name=local_module_name,
+        )
 
     @torch.no_grad()
     def prepare(

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico/quantization/algorithm/gptq/quantizer.py

@@ -25,6 +25,7 @@ from tico.quantization.algorithm.gptq.utils import (
     find_layers,
     gather_single_batch_from_dict,
     gather_single_batch_from_list,
+    resolve_weight_bits,
 )
 from tico.quantization.config.gptq import GPTQConfig
 from tico.quantization.quantizer import BaseQuantizer
@@ -73,23 +74,18 @@ class GPTQQuantizer(BaseQuantizer):
         full_module_name: str,
         local_module_name: str,
     ) -> int:
-        """Resolve the effective bit-width for a quantized submodule."""
-        if full_module_name in gptq_conf.weight_bits_overrides:
-            return gptq_conf.weight_bits_overrides[full_module_name]
-
-        if local_module_name in gptq_conf.weight_bits_overrides:
-            return gptq_conf.weight_bits_overrides[local_module_name]
-
-        suffix_matches = [
-            bits
-            for pattern, bits in gptq_conf.weight_bits_overrides.items()
-            if full_module_name.endswith(f".{pattern}")
-        ]
-
-        if suffix_matches:
-            return suffix_matches[-1]
+        """
+        Resolve the effective bit-width for a quantized submodule.
 
-        return gptq_conf.weight_bits
+        Delegates to :func:`resolve_weight_bits`, which documents the
+        full name -> local name -> suffix (last match) -> default policy.
+        """
+        return resolve_weight_bits(
+            default_bits=gptq_conf.weight_bits,
+            weight_bits_overrides=gptq_conf.weight_bits_overrides,
+            full_module_name=full_module_name,
+            local_module_name=local_module_name,
+        )
 
     @torch.no_grad()
     def prepare(

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico/quantization/algorithm/gptq/utils.py

@@ -13,10 +13,54 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Mapping
+
 import torch
 import tqdm
 
 
+def resolve_weight_bits(
+    *,
+    default_bits: int,
+    weight_bits_overrides: Mapping[str, int],
+    full_module_name: str,
+    local_module_name: str,
+) -> int:
+    """
+    Resolve the effective weight bit-width for one quantized submodule.
+
+    This is the single implementation of the ``weight_bits_overrides`` key
+    matching policy shared by the GPTQ-family quantizers. Keys are matched in
+    the following order and the first branch that yields a match wins:
+
+        1) ``full_module_name`` is a key (exact match).
+        2) ``local_module_name`` is a key (exact match).
+        3) ``full_module_name`` ends with ``"." + key`` (dot-delimited suffix).
+           When several keys match, the one iterated last in
+           ``weight_bits_overrides`` order wins; pattern length is irrelevant.
+        4) Otherwise ``default_bits``.
+
+    Names and keys are compared as given; no normalization is applied and the
+    selected override value is returned unchanged. The mapping is not modified.
+    """
+    if full_module_name in weight_bits_overrides:
+        return weight_bits_overrides[full_module_name]
+
+    if local_module_name in weight_bits_overrides:
+        return weight_bits_overrides[local_module_name]
+
+    suffix_matches = [
+        bits
+        for pattern, bits in weight_bits_overrides.items()
+        if full_module_name.endswith(f".{pattern}")
+    ]
+
+    if suffix_matches:
+        return suffix_matches[-1]
+
+    return default_bits
+
+
 def find_layers(module, layers=[torch.nn.Linear], name=""):
     if type(module) in layers:
         return {name: module}

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico/quantization/algorithm/qwen3_vl_gptq/quantizer.py

@@ -27,6 +27,7 @@ import torch
 import torch.nn as nn
 from tqdm.auto import tqdm
 
+from tico.quantization.algorithm.gptq.utils import resolve_weight_bits
 from tico.quantization.algorithm.qwen3_vl_gptq.gptq import GPTQ
 from tico.quantization.algorithm.qwen3_vl_gptq.utils import (
     append_batch_to_cache,
@@ -166,27 +167,15 @@ class Qwen3VLGPTQQuantizer(BaseQuantizer):
         """
         Resolve the effective bit-width for a quantized submodule.
 
-        Override keys are matched in the following order:
-            1) Full module name.
-            2) Stage-local module name.
-            3) Full-name suffix.
+        Delegates to :func:`resolve_weight_bits`, which documents the
+        full name -> stage-local name -> suffix (last match) -> default policy.
         """
-        if full_module_name in gptq_conf.weight_bits_overrides:
-            return gptq_conf.weight_bits_overrides[full_module_name]
-
-        if local_module_name in gptq_conf.weight_bits_overrides:
-            return gptq_conf.weight_bits_overrides[local_module_name]
-
-        suffix_matches = [
-            bits
-            for pattern, bits in gptq_conf.weight_bits_overrides.items()
-            if full_module_name.endswith(f".{pattern}")
-        ]
-
-        if suffix_matches:
-            return suffix_matches[-1]
-
-        return gptq_conf.weight_bits
+        return resolve_weight_bits(
+            default_bits=gptq_conf.weight_bits,
+            weight_bits_overrides=gptq_conf.weight_bits_overrides,
+            full_module_name=full_module_name,
+            local_module_name=local_module_name,
+        )
 
     @torch.no_grad()
     def prepare(

tico-0.3.0.dev261013/tico/quantization/recipes/qparams.py

@@ -0,0 +1,284 @@
+# Copyright (c) 2026 Samsung Electronics Co., Ltd. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from typing import Any
+
+import torch
+
+from tico.quantization.wrapq.dtypes import DType
+from tico.quantization.wrapq.observers.affine_base import AffineObserverBase
+from tico.quantization.wrapq.observers.base import ObserverBase
+from tico.quantization.wrapq.qscheme import QScheme
+from tico.quantization.wrapq.utils.linear_folding import (
+    reused_weight_qparam_scale_multiplier,
+)
+from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
+
+
+def find_gptq_quantizers(
+    root: torch.nn.Module,
+) -> tuple[torch.nn.Module | None, dict[str, Any] | None]:
+    """Find GPTQ quantizers attached to a model or one of common wrapper owners."""
+    candidates: list[Any] = [root]
+    if hasattr(root, "wrapped"):
+        candidates.append(root.wrapped)
+        if hasattr(root.wrapped, "module"):
+            candidates.append(root.wrapped.module)
+        if hasattr(root.wrapped, "wrapped"):
+            candidates.append(root.wrapped.wrapped)
+
+    for owner in candidates:
+        quantizers = getattr(owner, "quantizers", None)
+        if isinstance(quantizers, dict):
+            return owner, quantizers
+    return None, None
+
+
+def _validated_gptq_qparams(
+    module: QuantModuleBase,
+    obs: ObserverBase,
+    quantizer: Any,
+) -> tuple[AffineObserverBase, torch.Tensor, torch.Tensor]:
+    """Validate standard per-tensor/per-output-channel GPTQ affine metadata.
+
+    GPTQ quantizers do not retain a complete grouped-quantization mapping, so
+    these checks do not establish compatibility for grouped GPTQ artifacts.
+    """
+    maxq = getattr(quantizer, "maxq", None)
+    source = f"GPTQ maxq={maxq!r}"
+    dtype = getattr(obs, "dtype", None)
+    target = f"PTQ dtype={dtype!r}, observer={type(obs).__name__}"
+
+    def incompatible(reason: str) -> ValueError:
+        return ValueError(
+            f"Incompatible GPTQ -> PTQ weight qparams for {module.fp_name!r}: "
+            f"{source}; {target}. {reason}"
+        )
+
+    if not isinstance(obs, AffineObserverBase):
+        raise incompatible("GPTQ qparam reuse requires an affine weight observer.")
+    if (
+        not isinstance(dtype, DType)
+        or isinstance(dtype.bits, bool)
+        or not isinstance(dtype.bits, int)
+        or dtype.bits <= 0
+        or not isinstance(dtype.signed, bool)
+    ):
+        raise incompatible("PTQ weight dtype must have a positive integer bit width.")
+    target = (
+        f"PTQ {dtype} range=[{dtype.qmin}, {dtype.qmax}], "
+        f"qscheme={obs.qscheme}, axis={obs.channel_axis}"
+    )
+
+    if isinstance(maxq, torch.Tensor):
+        if maxq.numel() != 1 or maxq.dtype == torch.bool or maxq.is_complex():
+            raise incompatible("GPTQ maxq must be a finite positive integer scalar.")
+        maxq = maxq.item()
+    if (
+        isinstance(maxq, bool)
+        or not isinstance(maxq, (int, float))
+        or not math.isfinite(maxq)
+        or maxq <= 0
+        or int(maxq) != maxq
+    ):
+        raise incompatible("GPTQ maxq must be a finite positive integer scalar.")
+    maxq = int(maxq)
+    if maxq & (maxq + 1):
+        raise incompatible("GPTQ maxq must describe a full unsigned 2**bits - 1 range.")
+    source = f"GPTQ {maxq.bit_length()}-bit unsigned range=[0, {maxq}] (maxq={maxq})"
+    if dtype.signed or dtype.qmin != 0 or dtype.qmax != maxq:
+        raise incompatible(
+            "Weight bit width and integer range must match exactly; "
+            "qparam reuse does not convert bit widths or signedness."
+        )
+    if obs.qscheme not in {QScheme.PER_CHANNEL_ASYMM, QScheme.PER_TENSOR_ASYMM}:
+        raise incompatible("Unsigned PTQ weights require an asymmetric affine qscheme.")
+
+    perchannel = getattr(quantizer, "perchannel", None)
+    if not isinstance(perchannel, bool):
+        raise incompatible("GPTQ perchannel metadata must be a boolean.")
+    owner = getattr(module, "module", module)
+    if isinstance(owner, torch.nn.Linear):
+        source_channels, channel_axis = owner.out_features, 0
+    elif isinstance(owner, (torch.nn.Conv1d, torch.nn.Conv2d, torch.nn.Conv3d)):
+        source_channels, channel_axis = owner.out_channels, 0
+    elif isinstance(owner, torch.nn.ConvTranspose2d):
+        # GPTQ uses an output-major Conv2d view; PTQ observes the original weight.
+        source_channels, channel_axis = owner.out_channels, 1
+    else:
+        raise incompatible(
+            f"Cannot establish the GPTQ weight channel mapping for {type(owner).__name__}."
+        )
+    weight = owner.weight
+    if not isinstance(weight, torch.Tensor) or weight.ndim <= channel_axis:
+        raise incompatible("The wrapped weight has no valid output-channel dimension.")
+
+    scale = getattr(quantizer, "scale", None)
+    zero = getattr(quantizer, "zero", None)
+    for name, value in (("scale", scale), ("zero-point", zero)):
+        if (
+            not isinstance(value, torch.Tensor)
+            or value.numel() == 0
+            or value.is_complex()
+            or value.dtype == torch.bool
+        ):
+            raise incompatible(f"GPTQ {name} must be a nonempty real tensor.")
+        valid_counts = {source_channels} if perchannel else {1, source_channels}
+        if value.numel() not in valid_counts or any(
+            dim != 1 for dim in value.shape[1:]
+        ):
+            raise incompatible(
+                f"GPTQ {name} shape {tuple(value.shape)} does not map to "
+                f"{source_channels} output channels (perchannel={perchannel})."
+            )
+        if not bool(torch.isfinite(value).all().item()):
+            raise incompatible(f"GPTQ {name} must contain only finite values.")
+    assert isinstance(scale, torch.Tensor) and isinstance(zero, torch.Tensor)
+    if not scale.is_floating_point() or not bool((scale > 0).all().item()):
+        raise incompatible("GPTQ scales must be floating-point and strictly positive.")
+    if not bool(((zero >= 0) & (zero <= maxq)).all().item()) or (
+        zero.is_floating_point() and not bool((zero == zero.round()).all().item())
+    ):
+        raise incompatible(
+            "GPTQ zero-points must be integral and within the shared range."
+        )
+
+    uniform = bool((scale == scale.reshape(-1)[0]).all().item()) and bool(
+        (zero == zero.reshape(-1)[0]).all().item()
+    )
+    if not perchannel and not uniform:
+        raise incompatible(
+            "GPTQ per-tensor metadata requires identical repeated qparams."
+        )
+    if obs.qscheme.is_per_channel():
+        if (
+            isinstance(obs.channel_axis, bool)
+            or not isinstance(obs.channel_axis, int)
+            or obs.channel_axis != channel_axis
+        ):
+            raise incompatible(
+                f"PTQ weight channel axis must be {channel_axis} for {type(owner).__name__}."
+            )
+        if scale.dtype != torch.float32:
+            raise incompatible(
+                "PTQ per-channel fake quantization requires float32 scales."
+            )
+        target_channels = weight.shape[channel_axis]
+        if target_channels <= 0:
+            raise incompatible("PTQ weight output-channel dimension must be nonempty.")
+        if scale.numel() != target_channels or zero.numel() != target_channels:
+            if not uniform:
+                raise incompatible(
+                    f"GPTQ qparams cannot map to {target_channels} PTQ weight channels."
+                )
+            scale = scale.reshape(-1)[0].expand(target_channels)
+            zero = zero.reshape(-1)[0].expand(target_channels)
+    else:
+        if obs.channel_axis is not None or not uniform:
+            raise incompatible(
+                "PTQ per-tensor weights require one identical GPTQ grid."
+            )
+        scale = scale.reshape(-1)[0]
+        zero = zero.reshape(-1)[0]
+
+    try:
+        scale_multiplier = reused_weight_qparam_scale_multiplier(module)
+    except (RuntimeError, TypeError, ValueError) as exc:
+        raise incompatible(str(exc)) from exc
+    if not math.isfinite(scale_multiplier) or scale_multiplier <= 0:
+        raise incompatible(
+            "Folded weight scale multiplier must be finite and positive."
+        )
+    if scale_multiplier != 1.0:
+        scale = scale * scale_multiplier
+        if not bool(torch.isfinite(scale).all().item()) or not bool(
+            (scale > 0).all().item()
+        ):
+            raise incompatible(
+                "Folded GPTQ scales must remain finite and strictly positive."
+            )
+    return obs, scale, zero
+
+
+def inject_gptq_qparams(
+    root: torch.nn.Module,
+    gptq_quantizers: dict[str, Any],
+    weight_obs_name: str = "weight",
+    *,
+    verbose: bool = False,
+) -> dict[str, int]:
+    """Validate every matched GPTQ grid, then inject and lock its PTQ qparams."""
+    seen: set[str] = set()
+    missed: list[str] = []
+    pending: list[tuple[AffineObserverBase, torch.Tensor, torch.Tensor]] = []
+
+    for module in root.modules():
+        if not isinstance(module, QuantModuleBase):
+            continue
+        if module.fp_name is None:
+            continue
+
+        obs = module.get_observer(weight_obs_name)
+        if obs is None:
+            continue
+
+        quantizer = gptq_quantizers.get(module.fp_name)
+        if quantizer is None:
+            missed.append(module.fp_name)
+            continue
+
+        pending.append(_validated_gptq_qparams(module, obs, quantizer))
+        seen.add(module.fp_name)
+
+    # A later invalid pair (including an unsupported fold) must not leave earlier
+    # observers locked with only part of the requested handoff applied.
+    for obs, scale, zero in pending:
+        obs.load_qparams(scale, zero, lock=True)
+
+    unused = set(gptq_quantizers.keys()) - seen
+
+    if verbose:
+        print("\n[GPTQ → PTQ injection summary]")
+        print(f"  matched : {len(seen)}")
+        print(f"  missed  : {len(missed)}")
+        print(f"  unused  : {len(unused)}")
+        for title, items in [
+            ("missed modules", missed),
+            ("unused GPTQ entries", sorted(unused)),
+        ]:
+            if not items:
+                continue
+            print(f"\n  {title}:")
+            for name in list(items)[:10]:
+                print(f"    - {name}")
+            if len(items) > 10:
+                print(f"    ... and {len(items) - 10} more")
+
+    return {"matched": len(seen), "missed": len(missed), "unused": len(unused)}
+
+
+def clear_gptq_quantizers(root: torch.nn.Module) -> None:
+    """Drop attached GPTQ quantizer dictionaries after PTQ qparam injection."""
+    candidates: list[Any] = [root]
+    if hasattr(root, "wrapped"):
+        candidates.append(root.wrapped)
+        if hasattr(root.wrapped, "module"):
+            candidates.append(root.wrapped.module)
+        if hasattr(root.wrapped, "wrapped"):
+            candidates.append(root.wrapped.wrapped)
+
+    for owner in candidates:
+        if hasattr(owner, "quantizers"):
+            delattr(owner, "quantizers")

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico/quantization/wrapq/examples/quantize_full_qmodel_with_gptq.py

@@ -65,8 +65,10 @@ from tico.quantization.config.llama_attention import (
 from tico.quantization.config.specs import affine
 from tico.quantization.config.spinquant import SpinQuantConfig
 from tico.quantization.evaluation.script.llm_tasks_eval import evaluate_llm_on_tasks
+from tico.quantization.recipes.qparams import (
+    inject_gptq_qparams as _inject_gptq_qparams,
+)
 from tico.quantization.wrapq.dtypes import DType
-from tico.quantization.wrapq.observers.affine_base import AffineObserverBase
 from tico.quantization.wrapq.utils.metrics import perplexity
 from tico.quantization.wrapq.wrappers.llama.export_adapters import (
     LlamaLMHeadExportAdapter,
@@ -75,7 +77,6 @@ from tico.quantization.wrapq.wrappers.llama.export_adapters import (
     make_token_embedding_example_input,
     register_fake_quant_meta_kernels_for_dynamic_export,
 )
-from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
 
 from tico.utils.utils import SuppressWarning
 
@@ -354,56 +355,8 @@ def inject_gptq_qparams(
     *,
     verbose: bool = False,
 ):
-    """
-    Inject GPTQ (scale, zero-point) into PTQ observers.
-
-    When verbose=True, prints a summary of matched / missed / unused entries.
-    """
-    seen = set()
-    missed_modules = []
-
-    for m in root.modules():
-        if not isinstance(m, QuantModuleBase):
-            continue
-        if m.fp_name is None:
-            continue
-
-        quantizer = gptq_quantizers.get(m.fp_name)
-        obs = m.get_observer(weight_obs_name)
-
-        # Only care about modules that should have weight observers
-        if obs is None:
-            continue
-
-        if quantizer is None:
-            missed_modules.append(m.fp_name)
-            continue
-
-        assert isinstance(obs, AffineObserverBase)
-        obs.load_qparams(quantizer.scale, quantizer.zero, lock=True)
-        seen.add(m.fp_name)
-
-    unused = set(gptq_quantizers.keys()) - seen
-
-    if verbose:
-        print("\n[GPTQ → PTQ injection summary]")
-        print(f"  matched : {len(seen)}")
-        print(f"  missed  : {len(missed_modules)}")
-        print(f"  unused  : {len(unused)}")
-
-        # Print samples (not all, to avoid spam)
-        def _print_sample(title, items):
-            items = list(items)
-            if not items:
-                return
-            print(f"\n  {title}:")
-            for name in items[:10]:
-                print(f"    - {name}")
-            if len(items) > 10:
-                print(f"    ... and {len(items) - 10} more")
-
-        _print_sample("missed modules", missed_modules)
-        _print_sample("unused GPTQ entries", unused)
+    """Validate and lock GPTQ qparams with the shared recipe handoff."""
+    _inject_gptq_qparams(root, gptq_quantizers, weight_obs_name, verbose=verbose)
 
 
 # -------------------------------------------------------------------------

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico/quantization/wrapq/examples/quantize_qwen3_vl_with_gptq.py

@@ -54,9 +54,10 @@ from tico.quantization.evaluation.vlm_eval_utils import (
     get_mixed_calib_inputs,
 )
 from tico.quantization.recipes.data.dataset_usage import EVALUATION_ROLE
+from tico.quantization.recipes.qparams import (
+    inject_gptq_qparams as _inject_gptq_qparams,
+)
 from tico.quantization.wrapq.dtypes import DType
-from tico.quantization.wrapq.observers.affine_base import AffineObserverBase
-from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
 
 DTYPE_MAP = {
     "float32": torch.float32,
@@ -821,6 +822,11 @@ def build_qwen3_vl_gptq_config(
     """
     weight_bits_overrides: dict[str, int] = {}
 
+    if args.gptq_vision:
+        weight_bits_overrides[
+            "model.visual.patch_embed.proj"
+        ] = args.vision_patch_embed_weight_bits
+
     if args.gptq_lm_head:
         weight_bits_overrides["lm_head"] = args.lm_head_weight_bits
 
@@ -855,26 +861,8 @@ def inject_gptq_qparams(
     gptq_quantizers: dict[str, Any],  # {fp_name: quantizer}
     weight_obs_name: str = "weight",
 ):
-    """
-    For every `QuantModuleBase` whose `fp_name` matches a GPTQ key,
-    locate the observer called `weight_obs_name` and overwrite its
-    (scale, zero-point), then lock them against further updates.
-    """
-    for m in root.modules():
-        if not isinstance(m, QuantModuleBase):
-            continue
-        if m.fp_name is None:
-            continue
-
-        quantizer = gptq_quantizers.get(m.fp_name)
-        if quantizer is None:
-            continue
-        obs = m.get_observer(weight_obs_name)
-        if obs is None:
-            continue
-        assert isinstance(obs, AffineObserverBase)
-        # GPTQ quantizer attributes
-        obs.load_qparams(quantizer.scale, quantizer.zero, lock=True)
+    """Validate and lock GPTQ qparams with the shared recipe handoff."""
+    _inject_gptq_qparams(root, gptq_quantizers, weight_obs_name)
 
 
 def quantize_using_PTQ(

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico/quantization/wrapq/examples/quantize_with_gptq.py

@@ -36,11 +36,12 @@ from transformers import AutoModelForCausalLM, AutoTokenizer
 from tico.quantization import convert, prepare
 from tico.quantization.config.gptq import GPTQConfig
 from tico.quantization.config.ptq import PTQConfig
-from tico.quantization.wrapq.observers.affine_base import AffineObserverBase
+from tico.quantization.recipes.qparams import (
+    inject_gptq_qparams as _inject_gptq_qparams,
+)
 from tico.quantization.wrapq.utils.introspection import build_fqn_map
 from tico.quantization.wrapq.utils.metrics import perplexity
 from tico.quantization.wrapq.wrappers.ptq_wrapper import PTQWrapper
-from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
 
 # Token-budget presets for activation calibration
 TOKENS: dict[str, int] = {
@@ -74,25 +75,8 @@ def inject_gptq_qparams(
     gptq_quantizers: dict[str, Any],  # {fp_name: quantizer}
     weight_obs_name: str = "weight",
 ):
-    """
-    For every `QuantModuleBase` whose `fp_name` matches a GPTQ key,
-    locate the observer called `weight_obs_name` and overwrite its
-    (scale, zero-point), then lock them against further updates.
-    """
-    for m in root.modules():
-        if not isinstance(m, QuantModuleBase):
-            continue
-        if m.fp_name is None:
-            continue
-        quantizer = gptq_quantizers.get(m.fp_name)
-        if quantizer is None:
-            continue
-        obs = m.get_observer(weight_obs_name)
-        if obs is None:
-            continue
-        assert isinstance(obs, AffineObserverBase)
-        # GPTQ quantizer attributes
-        obs.load_qparams(quantizer.scale, quantizer.zero, lock=True)
+    """Validate and lock GPTQ qparams with the shared recipe handoff."""
+    _inject_gptq_qparams(root, gptq_quantizers, weight_obs_name)
 
 
 def main():

{tico-0.3.0.dev261008 → tico-0.3.0.dev261013}/tico.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tico
-Version: 0.3.0.dev261008
+Version: 0.3.0.dev261013
 Summary: Convert Exported Torch Module To Circle
 License: This file provides full text of licenses used in this project
         

tico-0.3.0.dev261008/tico/_version.py

@@ -1 +0,0 @@
-__version__ = "0.3.0.dev261008"