tico 0.2.0.dev260331__tar.gz → 0.2.0.dev260403__tar.gz

{tico-0.2.0.dev260331 → tico-0.2.0.dev260403}/PKG-INFO

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

tico-0.2.0.dev260403/tico/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0.dev260403"

{tico-0.2.0.dev260331 → tico-0.2.0.dev260403}/tico/quantization/algorithm/gptq/quantizer.py

@@ -60,6 +60,31 @@ class GPTQQuantizer(BaseQuantizer):
         self._orig_layer_forward: Optional[Callable[..., Any]] = None
         self._first_layer_ref: Optional[torch.nn.Module] = None
 
+    def _resolve_weight_bits(
+        self,
+        gptq_conf: GPTQConfig,
+        *,
+        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]
+
+        return gptq_conf.weight_bits
+
     @torch.no_grad()
     def prepare(
         self,
@@ -220,18 +245,22 @@ class GPTQQuantizer(BaseQuantizer):
                 gptq: Dict[str, GPTQ] = {}
                 for name in subset:
                     gptq[name] = GPTQ(subset[name])
+                    full_module_name = module_name[subset[name]]
+                    weight_bits = self._resolve_weight_bits(
+                        gptq_conf,
+                        full_module_name=full_module_name,
+                        local_module_name=name,
+                    )
                     if (
                         gptq_conf.sensitivity is not None
                         and isinstance(gptq_conf.sensitivity, dict)
-                        and module_name[subset[name]] in gptq_conf.sensitivity
+                        and full_module_name in gptq_conf.sensitivity
                     ):
-                        cur_sensitivity = gptq_conf.sensitivity[
-                            module_name[subset[name]]
-                        ]
+                        cur_sensitivity = gptq_conf.sensitivity[full_module_name]
                     else:
                         cur_sensitivity = None
                     gptq[name].quantizer.configure(
-                        bits=gptq_conf.weight_bits,
+                        bits=weight_bits,
                         perchannel=gptq_conf.perchannel,
                         sym=gptq_conf.symmetric,
                         mse=gptq_conf.mse,

{tico-0.2.0.dev260331 → tico-0.2.0.dev260403}/tico/quantization/config/builders.py

@@ -13,10 +13,13 @@
 # limitations under the License.
 
 import copy
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple, Type
 
 from tico.quantization.config.ptq import PTQConfig, WrapperVariant
+from tico.quantization.config.utils import auto_qscheme_for
 from tico.quantization.wrapq.dtypes import DType
+from tico.quantization.wrapq.observers.base import ObserverBase
+from tico.quantization.wrapq.observers.minmax import MinMaxObserver
 from tico.quantization.wrapq.qscheme import QScheme
 
 
@@ -121,6 +124,10 @@ def _build_weight_override(weight_dtype: Optional[DType]) -> Dict[str, Any]:
     """
     Build a weight override dictionary.
 
+    The override explicitly carries both dtype and qscheme so that local dtype
+    changes do not accidentally inherit an incompatible or less suitable
+    qscheme from an outer scope.
+
     Parameters
     ----------
     weight_dtype : Optional[DType]
@@ -134,7 +141,12 @@ def _build_weight_override(weight_dtype: Optional[DType]) -> Dict[str, Any]:
     """
     if weight_dtype is None:
         return {}
-    return {"weight": {"dtype": weight_dtype}}
+    return {
+        "weight": {
+            "dtype": weight_dtype,
+            "qscheme": auto_qscheme_for(weight_dtype, "weight"),
+        }
+    }
 
 
 def _build_norm_override(
@@ -162,9 +174,13 @@ def _build_norm_override(
 
     if norm_dtype is not None:
         override["dtype"] = norm_dtype
+        override["qscheme"] = auto_qscheme_for(norm_dtype)
 
     if norm_weight_dtype is not None:
-        override["weight"] = {"dtype": norm_weight_dtype}
+        override["weight"] = {
+            "dtype": norm_weight_dtype,
+            "qscheme": auto_qscheme_for(norm_weight_dtype, "weight"),
+        }
 
     return override
 
@@ -309,6 +325,7 @@ def build_llm_ptq_config(
     wrapper_variant: WrapperVariant = "prefill",
     activation_dtype: DType = DType.int(16),
     default_qscheme: QScheme = QScheme.PER_TENSOR_SYMM,
+    default_observer: Type[ObserverBase] = MinMaxObserver,
     linear_weight_bits: Optional[int] = None,
     linear_weight_dtype: Optional[DType] = None,
     embedding_weight_bits: Optional[int] = None,
@@ -346,6 +363,11 @@ def build_llm_ptq_config(
     default_qscheme : QScheme, default=QScheme.PER_TENSOR_SYMM
         Default quantization scheme for observers that do not receive an
         explicit override.
+    default_observer : Type[ObserverBase], default=MinMaxObserver
+        Observer class to instantiate when no explicit observer is provided
+        via overrides.
+        This should be a subclass of `ObserverBase` (e.g., MinMaxObserver,
+        EMAObserver). The class itself (not an instance) must be passed.
     linear_weight_bits : Optional[int], default=None
         Convenience bit-width for decoder-layer linear projection weights.
         Used only when `linear_weight_dtype` is not provided.
@@ -416,6 +438,7 @@ def build_llm_ptq_config(
     return PTQConfig(
         default_dtype=activation_dtype,
         default_qscheme=default_qscheme,
+        default_observer=default_observer,
         wrapper_variant=wrapper_variant,
         overrides=overrides,
         strict_wrap=strict_wrap,

{tico-0.2.0.dev260331 → tico-0.2.0.dev260403}/tico/quantization/config/gptq.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 import torch
 
@@ -23,6 +23,21 @@ from tico.quantization.config.base import BaseConfig
 class GPTQConfig(BaseConfig):
     """
     Configuration for GPTQ weight quantization.
+
+    Attributes
+    ----------
+    weight_bits : int
+        Default bit-width applied to quantized weights.
+    weight_bits_overrides : dict[str, int]
+        Optional per-module bit-width overrides.
+
+        Supported keys are matched in the following order:
+          1) Full module name, for example `model.layers.0.self_attn.o_proj`
+          2) Layer-local module name, for example `self_attn.o_proj`
+          3) Full-name suffix, for example `self_attn.o_proj` or `down_proj`
+
+        This makes it possible to keep a default bit-width for most modules
+        while selectively increasing precision for specific projections.
     """
 
     # general
@@ -31,6 +46,7 @@ class GPTQConfig(BaseConfig):
 
     # quantizer.configure params (weight quantization spec)
     weight_bits: int = 8
+    weight_bits_overrides: dict[str, int] = field(default_factory=dict)
     perchannel: bool = True
     symmetric: bool = False
     mse: str | None = None
@@ -49,6 +65,11 @@ class GPTQConfig(BaseConfig):
     def validate(self) -> None:
         if self.weight_bits <= 0:
             raise ValueError(f"weight_bits must be positive. got {self.weight_bits}")
+        for module_name, bits in self.weight_bits_overrides.items():
+            if bits <= 0:
+                raise ValueError(
+                    f"weight_bits_overrides[{module_name!r}] must be positive. got {bits}"
+                )
         if self.groupsize != -1 and self.groupsize <= 0:
             raise ValueError(f"groupsize must be -1 or positive. got {self.groupsize}")
         if not (0.0 < self.percdamp <= 1.0):

{tico-0.2.0.dev260331 → tico-0.2.0.dev260403}/tico/quantization/config/ptq.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from copy import deepcopy
 from dataclasses import dataclass, field
-from typing import Any, Dict, Literal, Mapping, Type
+from typing import Any, Dict, Iterable, Literal, Mapping, MutableMapping, Optional, Type
 
 from tico.quantization.config.base import BaseConfig
+from tico.quantization.config.utils import auto_qscheme_for, dtype_is_unsigned
 from tico.quantization.wrapq.dtypes import DType
 from tico.quantization.wrapq.observers.base import ObserverBase
 from tico.quantization.wrapq.observers.minmax import MinMaxObserver
@@ -24,6 +26,92 @@ from tico.quantization.wrapq.qscheme import QScheme
 WrapperVariant = Literal["common", "prefill", "decode"]
 
 
+def _resolve_qscheme(
+    *,
+    dtype: DType,
+    qscheme: Optional[QScheme],
+    context: str,
+    obs_name: Optional[str] = None,
+) -> QScheme:
+    """
+    Resolve a dtype/qscheme pair using the option-C policy.
+
+    Resolution policy:
+      1. If `qscheme` is None, infer it from `dtype` and `obs_name`.
+      2. If the caller explicitly provides an incompatible pair, raise.
+    """
+    resolved_qscheme = qscheme or auto_qscheme_for(dtype, obs_name)
+
+    if dtype_is_unsigned(dtype) and resolved_qscheme.is_symmetric():
+        raise ValueError(
+            f"Invalid quantization config at {context}: unsigned dtype "
+            f"{dtype!r} cannot be paired with symmetric qscheme "
+            f"{resolved_qscheme!r}."
+        )
+
+    return resolved_qscheme
+
+
+def _normalize_overrides(
+    mapping: Mapping[str, Any],
+    *,
+    inherited_dtype: DType,
+    inherited_qscheme: QScheme,
+    context: str,
+    current_name: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Recursively normalize and validate nested override mappings.
+
+    Any node that provides `dtype` but omits `qscheme` receives an inferred
+    qscheme derived from that dtype. Explicit incompatible pairs are rejected
+    immediately.
+
+    The current mapping key is tracked as `current_name` so that special
+    observer names such as `weight` can receive a more suitable automatic
+    default qscheme.
+    """
+    normalized: Dict[str, Any] = dict(mapping)
+
+    local_dtype = normalized.get("dtype", inherited_dtype)
+    local_qscheme = normalized.get("qscheme", inherited_qscheme)
+
+    if "dtype" in normalized:
+        normalized["qscheme"] = _resolve_qscheme(
+            dtype=local_dtype,
+            qscheme=normalized.get("qscheme"),
+            context=context,
+            obs_name=current_name,
+        )
+        local_qscheme = normalized["qscheme"]
+    elif "qscheme" in normalized:
+        local_qscheme = _resolve_qscheme(
+            dtype=local_dtype,
+            qscheme=normalized["qscheme"],
+            context=context,
+            obs_name=current_name,
+        )
+    else:
+        _resolve_qscheme(
+            dtype=local_dtype,
+            qscheme=local_qscheme,
+            context=context,
+            obs_name=current_name,
+        )
+
+    for key, value in list(normalized.items()):
+        if isinstance(value, Mapping):
+            normalized[key] = _normalize_overrides(
+                value,
+                inherited_dtype=local_dtype,
+                inherited_qscheme=local_qscheme,
+                context=f"{context}.{key}",
+                current_name=key,
+            )
+
+    return normalized
+
+
 @dataclass
 class PTQConfig(BaseConfig):
     """
@@ -38,10 +126,19 @@ class PTQConfig(BaseConfig):
     default_observer : Type[ObserverBase], optional
         Observer class to instantiate when the caller (or an override) does
          not provide a `observer` key.
-    default_qscheme : QScheme
-        Fallback quantization scheme (per-tensor / per-channel,
-        asymmetric / symmetric) for observers that DO NOT receive an explicit
-        override.
+    default_qscheme : Optional[QScheme]
+        Fallback quantization scheme for observers that do not receive an
+        explicit override.
+
+        When set to `None`, the qscheme is inferred automatically from the
+        effective dtype and, for special observer names such as `weight`,
+        from the observer role:
+            - unsigned activation-like dtype -> `QScheme.PER_TENSOR_ASYMM`
+            - unsigned weight dtype          -> `QScheme.PER_CHANNEL_ASYMM`
+            - signed dtype                   -> `QScheme.PER_TENSOR_SYMM`
+
+        When explicitly provided, the pair is validated. Incompatible pairs,
+        such as unsigned dtype with symmetric qscheme, raise immediately.
     wrapper_variant : str
         Execution specialization used when resolving quantization wrappers.
 
@@ -114,17 +211,111 @@ class PTQConfig(BaseConfig):
 
     default_dtype: DType = DType.uint(8)
     default_observer: Type[ObserverBase] = MinMaxObserver  # type: ignore[type-abstract]
-    default_qscheme: QScheme = QScheme.PER_TENSOR_ASYMM
+    default_qscheme: Optional[QScheme] = None
     wrapper_variant: WrapperVariant = "common"
     overrides: Mapping[str, Mapping[str, Any]] = field(default_factory=dict)
     model_args: Mapping[str, Any] = field(default_factory=dict)
     # If True, any module that cannot be wrapped will raise.
     strict_wrap: bool = True
 
+    def __post_init__(self) -> None:
+        """
+        Resolve automatic qscheme defaults and validate nested overrides.
+        """
+        self.default_qscheme = _resolve_qscheme(
+            dtype=self.default_dtype,
+            qscheme=self.default_qscheme,
+            context="PTQConfig.default_qscheme",
+        )
+        self.normalize_overrides()
+
     @property
     def name(self) -> str:
         return "ptq"
 
+    def normalize_overrides(self) -> None:
+        """
+        Normalize and validate the entire override tree in-place.
+
+        This method is useful when callers directly mutate `self.overrides`
+        after construction and want to retroactively apply automatic qscheme
+        inference and compatibility checks.
+        """
+        assert self.default_qscheme is not None
+        self.overrides = _normalize_overrides(
+            self.overrides,
+            inherited_dtype=self.default_dtype,
+            inherited_qscheme=self.default_qscheme,
+            context="PTQConfig.overrides",
+        )
+
+    def set_override(
+        self,
+        path: Iterable[str],
+        value: Mapping[str, Any],
+    ) -> None:
+        """
+        Set a nested override and normalize only the affected subtree.
+
+        Parameters
+        ----------
+        path : Iterable[str]
+            Hierarchical path inside `self.overrides`.
+            Example: `("model", "layers", "0", "self_attn", "o_proj", "weight")`
+        value : Mapping[str, Any]
+            Override payload to assign at the target path.
+
+        Notes
+        -----
+        The inserted subtree is normalized immediately, so callers may provide
+        only `dtype` and rely on automatic qscheme inference.
+        """
+        keys = tuple(path)
+        if not keys:
+            raise ValueError("Override path must not be empty.")
+
+        root: MutableMapping[str, Any] = dict(self.overrides)
+        current: MutableMapping[str, Any] = root
+        parent_dtype = self.default_dtype
+        parent_qscheme = self.default_qscheme
+        context = "PTQConfig.overrides"
+
+        for key in keys[:-1]:
+            context = f"{context}.{key}"
+            next_value = current.get(key)
+            if isinstance(next_value, Mapping):
+                child = dict(next_value)
+            elif next_value is None:
+                child = {}
+            else:
+                raise ValueError(
+                    f"Cannot create nested override under non-mapping node at {context}."
+                )
+
+            current[key] = child
+            current = child
+
+            local_dtype = current.get("dtype", parent_dtype)
+            parent_qscheme = _resolve_qscheme(
+                dtype=local_dtype,
+                qscheme=current.get("qscheme", parent_qscheme),
+                context=context,
+                obs_name=key,
+            )
+            parent_dtype = local_dtype
+
+        assert parent_qscheme is not None
+        leaf_key = keys[-1]
+        leaf_context = f"{context}.{leaf_key}"
+        current[leaf_key] = _normalize_overrides(
+            deepcopy(value),
+            inherited_dtype=parent_dtype,
+            inherited_qscheme=parent_qscheme,
+            context=leaf_context,
+            current_name=leaf_key,
+        )
+        self.overrides = root
+
     def get_kwargs(self, obs_name: str) -> Dict[str, Any]:
         """
         Return user-specified kwargs for *obs_name* inside **this** wrapper.

tico-0.2.0.dev260403/tico/quantization/config/utils.py

@@ -0,0 +1,41 @@
+# 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.
+
+from typing import Optional
+
+from tico.quantization.wrapq.dtypes import DType
+from tico.quantization.wrapq.qscheme import QScheme
+
+
+def dtype_is_unsigned(dtype: DType) -> bool:
+    """
+    Return True when the dtype is unsigned.
+    """
+    return not dtype.signed
+
+
+def auto_qscheme_for(dtype: DType, obs_name: Optional[str] = None) -> QScheme:
+    """
+    Choose the default qscheme associated with a dtype and observer name.
+
+    Default policy:
+      - signed dtype    -> symmetric per-tensor
+      - unsigned dtype  -> asymmetric per-tensor
+      - unsigned weight -> asymmetric per-channel
+    """
+    if dtype_is_unsigned(dtype):
+        if obs_name == "weight":
+            return QScheme.PER_CHANNEL_ASYMM
+        return QScheme.PER_TENSOR_ASYMM
+    return QScheme.PER_TENSOR_SYMM