tico 0.1.0.dev250818__py3-none-any.whl → 0.1.0.dev250820__py3-none-any.whl

tico/__init__.py

@@ -29,7 +29,7 @@ __all__ = [
 ]
 
 # THIS LINE IS AUTOMATICALLY GENERATED BY setup.py
-__version__ = "0.1.0.dev250818"
+__version__ = "0.1.0.dev250820"
 
 MINIMUM_SUPPORTED_VERSION = "2.5.0"
 SECURE_TORCH_VERSION = "2.6.0"

tico/experimental/quantization/ptq/observers/__init__.py

@@ -3,6 +3,7 @@ from tico.experimental.quantization.ptq.observers.base import ObserverBase
 from tico.experimental.quantization.ptq.observers.ema import EMAObserver
 from tico.experimental.quantization.ptq.observers.identity import IdentityObserver
 from tico.experimental.quantization.ptq.observers.minmax import MinMaxObserver
+from tico.experimental.quantization.ptq.observers.mx import MXObserver
 
 __all__ = [
     "AffineObserverBase",
@@ -10,4 +11,5 @@ __all__ = [
     "EMAObserver",
     "IdentityObserver",
     "MinMaxObserver",
+    "MXObserver",
 ]

tico/experimental/quantization/ptq/observers/ema.py

@@ -31,7 +31,7 @@ class EMAObserver(AffineObserverBase):
 
         ema = momentum * ema + (1 - momentum) * new_value
 
-    With momentum → 0: *fast* adaptation, momentum → 1: *slow* adaptation.
+    With momentum → 0: FAST adaptation, momentum → 1: SLOW adaptation.
     """
 
     def __init__(

tico/experimental/quantization/ptq/observers/identity.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 """
-IdentityObserver: a *no-op* observer for FP-only modules.
+IdentityObserver: a "no-op" observer for FP-only modules.
 
 Motivation
 ----------
@@ -29,11 +29,11 @@ from tico.experimental.quantization.ptq.observers.affine_base import AffineObser
 
 class IdentityObserver(AffineObserverBase):
     """
-    Passthrough observer that **never** alters the tensor.
+    Passthrough observer that NEVER alters the tensor.
 
     • `_update_stats()`   → does nothing
-    • `compute_qparams()` → returns (1.0, 0) *dummy* q-params
-    • `fake_quant()`      → returns *x* unchanged
+    • `compute_qparams()` → returns (1.0, 0) "dummy" q-params
+    • `fake_quant()`      → returns `x` unchanged
     """
 
     def __init__(self, **kwargs):
@@ -67,7 +67,7 @@ class IdentityObserver(AffineObserverBase):
         return self._cached_scale, self._cached_zp
 
     def fake_quant(self, x: torch.Tensor):
-        """Identity mapping — leaves *x* in FP."""
+        """Identity mapping — leaves `x` in FP."""
         return x
 
     def __repr__(self) -> str:

tico/experimental/quantization/ptq/observers/mx.py

@@ -0,0 +1,60 @@
+# Copyright (c) 2025 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 torch
+
+from tico.experimental.quantization.ptq.observers.base import ObserverBase
+from tico.utils.mx.mx_ops import quantize_mx
+
+
+class MXObserver(ObserverBase):
+    """MX (micro-scaling) observer: no min/max, no affine qparams."""
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        elem_format: str = "int8",
+        axis: int = 0,
+        shared_exp_method: str = "max",
+        round: str = "nearest",
+        **base_kwargs,
+    ):
+        super().__init__(name=name, **base_kwargs)
+        self.elem_format = elem_format
+        self.axis = axis
+        self.shared_exp_method = shared_exp_method
+        self.round = round
+
+    def reset(self) -> None:
+        # No state to reset
+        return
+
+    @torch.no_grad()
+    def _update_stats(self, x: torch.Tensor) -> None:
+        # No stats required
+        return None
+
+    def compute_qparams(self):
+        # MX path does not produce affine qparams; keep interface contract.
+        return None
+
+    def fake_quant(self, x: torch.Tensor) -> torch.Tensor:
+        return quantize_mx(
+            x,
+            elem_format=self.elem_format,
+            axis=self.axis,
+            shared_exp_method=self.shared_exp_method,
+            round=self.round,
+        )

tico/experimental/quantization/ptq/quant_config.py

@@ -0,0 +1,111 @@
+# Copyright (c) 2025 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 dataclasses import dataclass, field
+from typing import Any, Dict, Mapping, Type
+
+from tico.experimental.quantization.ptq.dtypes import DType
+from tico.experimental.quantization.ptq.observers.base import ObserverBase
+from tico.experimental.quantization.ptq.observers.minmax import MinMaxObserver
+from tico.experimental.quantization.ptq.qscheme import QScheme
+
+
+@dataclass
+class QuantConfig:
+    """
+    One object describes the quantization preferences for a single wrapper
+    and its descendants.
+
+    Parameters
+    ----------
+    default_dtype : DType
+        Fallback dtype for every observer that DOES NOT receive an explicit
+        override.
+    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.
+    overrides : Mapping[str, Mapping[str, Any]]
+        Two-level mapping of scopes → observer-kwargs.
+
+        • SCOPE can be either
+            - the attribute name of a child wrapper
+              (e.g. "gate_proj" or "up_proj"), or
+            - an observer logical name inside this wrapper
+              (e.g. "mul", "act_in").
+
+        • "Observer-kwargs" is forwarded verbatim to the observer constructor
+          (`dtype`, `qscheme`, `channel_axis`, `observer`, …).
+
+    Example
+    -------
+    ```python
+    from ptq.observers import PercentileObserver
+
+    cfg = QuantConfig(
+        default_dtype   = DType.uint(8),
+        default_qscheme  = QScheme.PER_TENSOR_SYMM,        # <- global scheme
+        default_observer = PercentileObserver,             # <- global algorithm
+        overrides={
+            # local override: input observer now MinMax & 4-bit, per-channel asymmetric
+            "act_in": {"observer": MinMaxObserver,
+                       "dtype":    DType.uint(4),
+                       "qscheme":  QScheme.PER_CHANNEL_ASYMM},
+        },
+    )
+    ```
+    """
+
+    default_dtype: DType = DType.uint(8)
+    default_observer: Type[ObserverBase] = MinMaxObserver
+    default_qscheme: QScheme = QScheme.PER_TENSOR_ASYMM
+    overrides: Mapping[str, Mapping[str, Any]] = field(default_factory=dict)
+
+    def get_kwargs(self, obs_name: str) -> Dict[str, Any]:
+        """
+        Return user-specified kwargs for *obs_name* inside **this** wrapper.
+
+        NOTE:
+        Do NOT inject a dtype/qscheme here. `_make_obs()` resolves precedence:
+            1) user override (kw_cfg["dtype" | "qscheme"])
+            2) wrapper's default passed to `_make_obs(..., dtype=..., qscheme=...)`
+            3) self.default_dtype / `self.default_qscheme`
+        """
+        return dict(self.overrides.get(obs_name, {}))
+
+    def child(self, scope: str) -> "QuantConfig":
+        """
+        Produce a *view* for a child wrapper.
+
+        The child inherits:
+          • same `default_dtype`
+          • same `default_observer`
+          • same `default_qscheme`
+          • overrides under `self.overrides.get(scope, {})`
+
+        Other scopes remain invisible to the child.
+        """
+        sub_overrides = self.overrides.get(scope, {})
+        return QuantConfig(
+            self.default_dtype,
+            self.default_observer,
+            default_qscheme=self.default_qscheme,
+            overrides=sub_overrides,
+        )
+
+    def __repr__(self):
+        return f"QuantConfig(default_dtype={self.default_dtype}, default_observer={self.default_observer}, default_qscheme={self.default_qscheme}, overrides={dict(self.overrides)})"

tico/experimental/quantization/ptq/wrappers/nn/__init__.py

@@ -0,0 +1,5 @@
+from tico.experimental.quantization.ptq.wrappers.nn.quant_linear import QuantLinear
+
+__all__ = [
+    "QuantLinear",
+]

tico/experimental/quantization/ptq/wrappers/nn/quant_linear.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2025 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
+
+import torch.nn as nn
+import torch.nn.functional as F
+
+from tico.experimental.quantization.ptq.mode import Mode
+from tico.experimental.quantization.ptq.qscheme import QScheme
+from tico.experimental.quantization.ptq.quant_config import QuantConfig
+from tico.experimental.quantization.ptq.wrappers.quant_module_base import (
+    QuantModuleBase,
+)
+from tico.experimental.quantization.ptq.wrappers.registry import register
+
+
+@register(nn.Linear)
+class QuantLinear(QuantModuleBase):
+    """Per-channel weight fake-quant, eager-output activation fake-quant."""
+
+    def __init__(
+        self,
+        fp: nn.Linear,
+        *,
+        qcfg: Optional[QuantConfig] = None,
+        fp_name: Optional[str] = None
+    ):
+        super().__init__(qcfg, fp_name=fp_name)
+        self.weight_obs = self._make_obs(
+            "weight", qscheme=QScheme.PER_CHANNEL_ASYMM, channel_axis=0
+        )
+        self.act_in_obs = self._make_obs("act_in")
+        self.act_out_obs = self._make_obs("act_out")
+        self.module = fp
+
+    def enable_calibration(self) -> None:
+        super().enable_calibration()
+        # immediately capture the fixed weight range
+        self.weight_obs.collect(self.module.weight)
+
+    def forward(self, x):
+        x_q = self._fq(x, self.act_in_obs)
+
+        w = self.module.weight
+        if self._mode is Mode.QUANT:
+            w = self.weight_obs.fake_quant(w)
+        b = self.module.bias
+
+        out = F.linear(x_q, w, b)
+
+        return self._fq(out, self.act_out_obs)
+
+    def _all_observers(self):
+        return (self.weight_obs, self.act_in_obs, self.act_out_obs)

tico/experimental/quantization/ptq/wrappers/quant_module_base.py

@@ -0,0 +1,153 @@
+# Copyright (c) 2025 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 abc import ABC, abstractmethod
+from typing import Iterable, Optional, Tuple
+
+import torch.nn as nn
+
+from tico.experimental.quantization.ptq.mode import Mode
+from tico.experimental.quantization.ptq.observers.base import ObserverBase
+from tico.experimental.quantization.ptq.quant_config import QuantConfig
+
+
+class QuantModuleBase(nn.Module, ABC):
+    """
+    Abstract parent for EVERY wrapper.
+
+    Responsibilities
+    ----------------
+    • Own *one* Mode enum (`NO_QUANT / CALIB / QUANT`)
+    • Own a QuantConfig describing default / per-observer dtypes
+    • Expose a canonical lifecycle:
+          enable_calibration()
+          freeze_qparams()
+    • Provide helper `_fq(x, observer)` (“fake-quant or collect”) so
+      subclasses write arithmetic code without boilerplate.
+    """
+
+    def __init__(
+        self, qcfg: Optional[QuantConfig] = None, *, fp_name: Optional[str] = None
+    ) -> None:
+        super().__init__()
+        self.qcfg = qcfg or QuantConfig()
+        self._mode: Mode = Mode.NO_QUANT  # default state
+        self.fp_name = fp_name
+
+    def _child_quant_modules(self):
+        """Yield direct children that are QuantModuleBase."""
+        for m in self.children():
+            if isinstance(m, QuantModuleBase):
+                yield m
+
+    def enable_calibration(self) -> None:
+        self._mode = Mode.CALIB
+        for obs in self._all_observers():
+            obs.enabled = True
+            obs.reset()
+
+        # propagate to children
+        for child in self._child_quant_modules():
+            child.enable_calibration()
+
+    def freeze_qparams(self) -> None:
+        self._mode = Mode.QUANT
+        for obs in self._all_observers():
+            obs.enabled = False
+            obs.compute_qparams()
+
+        # propagate to children
+        for child in self._child_quant_modules():
+            child.freeze_qparams()
+
+    def _fq(self, x, obs: ObserverBase):
+        """Fake-quant or collect."""
+        if self._mode is Mode.CALIB:
+            obs.collect(x.detach())
+            return x
+        if self._mode is Mode.QUANT:
+            return obs.fake_quant(x)
+        return x  # NO_QUANT
+
+    @abstractmethod
+    def _all_observers(self) -> Iterable[ObserverBase]:
+        """Return every observer owned by this module."""
+        ...
+
+    def named_observers(self) -> Iterable[Tuple[str, ObserverBase]]:
+        for obs in self._all_observers():
+            yield obs.name, obs
+
+    def get_observer(self, name: str) -> Optional[ObserverBase]:
+        for obs in self._all_observers():
+            if obs.name == name:
+                return obs
+        return None
+
+    def _make_obs(
+        self,
+        name: str,
+        **default_kwargs,
+    ) -> ObserverBase:
+        """
+        Instantiate an observer named *name*.
+
+        Precedence (3-tier) for keys:
+           • observer:  user > wrapper-default > QuantConfig.default_observer
+           • dtype:     user > wrapper-default > QuantConfig.default_dtype
+           • qscheme:   user > wrapper-default > QuantConfig.default_qscheme
+
+        Other kwargs (e.g., qscheme, channel_axis, etc.) remain:
+           user override > wrapper-default
+        """
+        _UNSPEC = object()
+
+        wrapper_defaults = default_kwargs.copy()
+        user_cfg = self.qcfg.get_kwargs(name).copy()
+
+        def pick3(user_val, wrap_val, global_val):
+            return (
+                user_val
+                if user_val is not _UNSPEC
+                else wrap_val
+                if wrap_val is not _UNSPEC
+                else global_val
+            )
+
+        # 1) resolve observer class
+        user_observer = user_cfg.pop("observer", _UNSPEC)
+        wrapper_observer = wrapper_defaults.pop("observer", _UNSPEC)
+        obs_cls = pick3(user_observer, wrapper_observer, self.qcfg.default_observer)
+
+        # 2) resolve dtype
+        user_dtype = user_cfg.pop("dtype", _UNSPEC)
+        wrapper_dtype = wrapper_defaults.pop("dtype", _UNSPEC)
+        final_dtype = pick3(user_dtype, wrapper_dtype, self.qcfg.default_dtype)
+
+        # 3) resolve qscheme
+        user_qscheme = user_cfg.pop("qscheme", _UNSPEC)
+        wrapper_qscheme = wrapper_defaults.pop("qscheme", _UNSPEC)
+        final_qscheme = pick3(user_qscheme, wrapper_qscheme, self.qcfg.default_qscheme)
+
+        # 4) merge remaining kwargs: user_cfg wins
+        final_kw = wrapper_defaults
+        final_kw.update(user_cfg)
+        final_kw["dtype"] = final_dtype
+        final_kw["qscheme"] = final_qscheme
+
+        return obs_cls(**final_kw, name=name)
+
+    # nice repr
+    def extra_repr(self) -> str:
+        return f"mode={self._mode.name.lower()}"

tico/experimental/quantization/ptq/wrappers/registry.py

@@ -0,0 +1,112 @@
+# Copyright (c) 2025 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 importlib
+from typing import Callable, Dict, Type
+
+import torch.nn as nn
+
+from tico.experimental.quantization.ptq.wrappers.quant_module_base import (
+    QuantModuleBase,
+)
+
+_WRAPPERS: Dict[Type[nn.Module], Type[QuantModuleBase]] = {}
+_IMPORT_ONCE = False
+_CORE_MODULES = (
+    "tico.experimental.quantization.ptq.wrappers.nn.quant_linear",
+    # add future core wrappers here
+)
+
+
+def _lazy_init():
+    """
+    Deferred one-shot import of "core wrapper modules".
+
+    Why not import everything when the program first starts?
+    --------------------------------------------------
+    * **Avoid circular-import hell**
+      Core wrappers often import `PTQWrapper`, which in turn calls
+      `registry.lookup()`.  Importing those files eagerly here would create a
+      cycle (`registry → wrapper → registry`).  Delaying the import until the
+      *first* `lookup()` call lets Python finish constructing the registry
+      module before any wrapper files are touched.
+
+    * **Cold-start speed**
+      Most user code never wraps layers explicitly; they only hit
+      `PTQWrapper` if they are doing quantization.  Deferring half-a-dozen
+      heavyweight `import torch …` files until they are really needed
+      reduces library start-up latency in the common path.
+
+    * **Optional dependencies**
+      Core wrappers listed in `_CORE_MODULES` are chosen to be dependency-free
+      (pure PyTorch).  Anything that needs `transformers`, `torchvision`,
+      etc. uses the `@try_register()` decorator inside its own module.  Those
+      optional modules are *not* imported here, so users without the extra
+      packages still get a clean import.
+
+    Implementation notes
+    --------------------
+    * `_IMPORT_ONCE` guard ensures we execute the import loop only once,
+      even if `lookup()` is called from multiple threads.
+    * Each path in `_CORE_MODULES` is a "fully-qualified module string"
+      (e.g. "ptq.wrappers.linear_quant").  Importing the module runs all
+      its `@register(nn.Layer)` decorators, populating `_WRAPPERS`.
+    * After the first call the function becomes a cheap constant-time no-op.
+    """
+    global _IMPORT_ONCE
+    if _IMPORT_ONCE:
+        return
+    for mod in _CORE_MODULES:
+        __import__(mod)  # triggers decorators
+    _IMPORT_ONCE = True
+
+
+# ───────────────────────────── decorator for always-present classes
+def register(
+    fp_cls: Type[nn.Module],
+) -> Callable[[Type[QuantModuleBase]], Type[QuantModuleBase]]:
+    def _decorator(quant_cls: Type[QuantModuleBase]):
+        _WRAPPERS[fp_cls] = quant_cls
+        return quant_cls
+
+    return _decorator
+
+
+# ───────────────────────────── conditional decorator
+def try_register(path: str) -> Callable[[Type[QuantModuleBase]], Type[QuantModuleBase]]:
+    """
+    @try_register("transformers.models.llama.modeling_llama.LlamaMLP")
+
+    • If import succeeds → behave like `@register`
+    • If module/class not found → become a NO-OP
+    """
+
+    def _decorator(quant_cls: Type[QuantModuleBase]):
+        module_name, _, cls_name = path.rpartition(".")
+        try:
+            mod = importlib.import_module(module_name)
+            fp_cls = getattr(mod, cls_name)
+            _WRAPPERS[fp_cls] = quant_cls
+        except (ModuleNotFoundError, AttributeError):
+            # transformers not installed or class renamed – silently skip
+            pass
+        return quant_cls
+
+    return _decorator
+
+
+# ───────────────────────────── lookup
+def lookup(fp_cls: Type[nn.Module]) -> Type[QuantModuleBase] | None:
+    _lazy_init()
+    return _WRAPPERS.get(fp_cls)

{tico-0.1.0.dev250818.dist-info → tico-0.1.0.dev250820.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tico
-Version: 0.1.0.dev250818
+Version: 0.1.0.dev250820
 Summary: Convert exported Torch module to circle
 Home-page: UNKNOWN
 License: UNKNOWN

{tico-0.1.0.dev250818.dist-info → tico-0.1.0.dev250820.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tico/__init__.py,sha256=F5RC38a-ZZxFrkWvxR7fW7_kwfHNb7ufnnJVqJ4Ib6w,1883
+tico/__init__.py,sha256=I2l2YkiyVNNCBv8PmWOlk2OxIDiMcpubxCENlSiOh8E,1883
 tico/pt2_to_circle.py,sha256=gu3MD4Iqc0zMZcCZ2IT8oGbyj21CTSbT3Rgd9s2B_9A,2767
 tico/config/__init__.py,sha256=xZzCXjZ84qE-CsBi-dfaL05bqpQ3stKKfTXhnrJRyVs,142
 tico/config/base.py,sha256=q5xMqGxTUZs4mFqt5c7i_y9U00fYgdMGl9nUqIVMlCo,1248
@@ -60,14 +60,21 @@ tico/experimental/quantization/ptq/__init__.py,sha256=ZoPdEwZ1i1n5pBFChx8GuUrkfR
 tico/experimental/quantization/ptq/dtypes.py,sha256=xfCBtq6mQmUYRwsoFgII6gvRl1raQi0Inj9pznDuKwQ,2236
 tico/experimental/quantization/ptq/mode.py,sha256=lT-T8vIv8YWcwrjT7xXVhOw1g7aoAdh_3PWB-ptPKaI,1052
 tico/experimental/quantization/ptq/qscheme.py,sha256=uwhv7bCxOOXB3I-IKlRyr_u4eXOq48uIqGy4TLDqGxY,1301
-tico/experimental/quantization/ptq/observers/__init__.py,sha256=wyrO0KTZve78aFWTwvsOE82Vu2kbCxJv8aqjiO1QL2s,524
+tico/experimental/quantization/ptq/quant_config.py,sha256=nm7570Y1X2mOT_8s27ilWid04otor6cVTi9GwgAEaKc,4300
+tico/experimental/quantization/ptq/observers/__init__.py,sha256=WF2MvL9M_jl-B1FqcY9zic34NOCRp17HkRYv-TMxMr4,613
 tico/experimental/quantization/ptq/observers/affine_base.py,sha256=e2Eba64nrxKQyE4F_WJ7WTSsk3xe6bkdGUKaoLFWGFw,4638
 tico/experimental/quantization/ptq/observers/base.py,sha256=Wons1MzpqK1mfcy-ppl-B2Dum0edXg2dWW2Lw3V18tw,3280
-tico/experimental/quantization/ptq/observers/ema.py,sha256=WZiYWEHrkgizAwnRCtfOm9JPHfZrjZTxMr6X9Wuovmo,2061
-tico/experimental/quantization/ptq/observers/identity.py,sha256=jdlNH52z8ANOZbs_0KFZ4iEstVfNC1OUzQsm1a9FFpM,2595
+tico/experimental/quantization/ptq/observers/ema.py,sha256=MAMdBmjVNMg_vsqXrcBzbw_1nFJ-j4Gz651k3-VlaMQ,2057
+tico/experimental/quantization/ptq/observers/identity.py,sha256=vkec8Or-7VwM4zkFEvEKROQJk8XEHMVX8mBNDnxSyS8,2591
 tico/experimental/quantization/ptq/observers/minmax.py,sha256=mLHkwIzWFzQXev7EU7w1333KckwRjukc3_cUPJOnUfs,1486
+tico/experimental/quantization/ptq/observers/mx.py,sha256=aP4qmBgeiRIYZJksShN5gs6UyYOFi2-Sbk5k5xvPQ4w,1863
 tico/experimental/quantization/ptq/utils/__init__.py,sha256=PL9IZgiWoMtsXVljeOy7KymmLVP238SXEFRLXYK72WQ,126
 tico/experimental/quantization/ptq/utils/reduce_utils.py,sha256=3kWawLB91EcvvHlCrNqqfZF7tpgr22htBSA049mKw_4,973
+tico/experimental/quantization/ptq/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tico/experimental/quantization/ptq/wrappers/quant_module_base.py,sha256=6RK4bn9G1pzFmkIdBdFf7liBOpb-b7rpthgD83AgkbQ,5256
+tico/experimental/quantization/ptq/wrappers/registry.py,sha256=exXl2wNNzVgC2P9gMjpF_-PqIBgYERGruzh0u1Pril0,4367
+tico/experimental/quantization/ptq/wrappers/nn/__init__.py,sha256=q4A9BiGlsa8ZdGV3y0SDiSkzkdVugsK2iz2daiJqBCY,118
+tico/experimental/quantization/ptq/wrappers/nn/quant_linear.py,sha256=xW-VEPB7RJoslS3xLVCdhIuMjppknvpkZleRGK4JFVQ,2240
 tico/interpreter/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/interpreter/infer.py,sha256=1ZFe3DVMR2mlwBosoedqoL0-CGN_01CKLgMgxuw62KA,4861
 tico/interpreter/interpreter.py,sha256=tGbluCbrehTCqBu8mtGDNzby_ieJ2ry8_RH_eC0CQxk,3828
@@ -222,9 +229,9 @@ tico/utils/mx/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/utils/mx/elemwise_ops.py,sha256=V6glyAHsVR1joqpsgnNytatCD_ew92xNWZ19UFDoMTA,10281
 tico/utils/mx/formats.py,sha256=uzNWyu-1onUlwQfX5cZ6fZSUfHMRqorper7_T1k3jfk,3404
 tico/utils/mx/mx_ops.py,sha256=RcfUTYVi-wilGB2sC35OeARdwDqnixv7dG5iyZ-fQT8,8555
-tico-0.1.0.dev250818.dist-info/LICENSE,sha256=kp4JLII7bzRhPb0CPD5XTDZMh22BQ7h3k3B7t8TiSbw,12644
-tico-0.1.0.dev250818.dist-info/METADATA,sha256=Bs6fCtyNDV7ZuntvZeoHsUDsc11tyng4NGTYYShFmUA,8450
-tico-0.1.0.dev250818.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-tico-0.1.0.dev250818.dist-info/entry_points.txt,sha256=kBKYSS_IYrSXmUYevmmepqIVPScq5vF8ulQRu3I_Zf0,59
-tico-0.1.0.dev250818.dist-info/top_level.txt,sha256=oqs7UPoNSKZEwqsX8B-KAWdQwfAa7i60pbxW_Jk7P3w,5
-tico-0.1.0.dev250818.dist-info/RECORD,,
+tico-0.1.0.dev250820.dist-info/LICENSE,sha256=kp4JLII7bzRhPb0CPD5XTDZMh22BQ7h3k3B7t8TiSbw,12644
+tico-0.1.0.dev250820.dist-info/METADATA,sha256=SF_FvVX_JdbjpMAN2-VJGo7zsYU2_nEPXCHap296J3Y,8450
+tico-0.1.0.dev250820.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+tico-0.1.0.dev250820.dist-info/entry_points.txt,sha256=kBKYSS_IYrSXmUYevmmepqIVPScq5vF8ulQRu3I_Zf0,59
+tico-0.1.0.dev250820.dist-info/top_level.txt,sha256=oqs7UPoNSKZEwqsX8B-KAWdQwfAa7i60pbxW_Jk7P3w,5
+tico-0.1.0.dev250820.dist-info/RECORD,,