tico 0.2.0.dev260415__tar.gz → 0.2.0.dev260417__tar.gz

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/PKG-INFO

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

tico-0.2.0.dev260417/tico/_version.py

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

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/tico/quantization/algorithm/gptq/quantizer.py

@@ -361,6 +361,13 @@ class GPTQQuantizer(BaseQuantizer):
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
 
+        if (
+            hasattr(model, "model")
+            and hasattr(model.model, "norm")
+            and hasattr(model, "lm_head")
+        ):  # quantize lm_head
+            self._quantize_lm_head(model, quantizers)
+
         # Restore the original cache configuration.
         if orig_use_cache is not None:
             model.config.use_cache = orig_use_cache
@@ -373,3 +380,89 @@ class GPTQQuantizer(BaseQuantizer):
         model.quantizers = quantizers
 
         return model
+
+    def _quantize_lm_head(self, model, quantizers):
+        gptq_conf = self.config
+        assert isinstance(gptq_conf, GPTQConfig)
+        # TODO reduce code duplication with layer-wise quantization
+
+        # prepare data for lm_head
+        batch_num = self.num_batches
+        device = next(model.parameters()).device
+        for batch_idx in tqdm(
+            range(batch_num),
+            desc=f"[model.norm] re-forward",
+            leave=False,
+            unit="batch",
+            disable=not gptq_conf.show_progress,
+        ):
+            hidden_states = gather_single_batch_from_list(self.cache_args, batch_idx)[0]
+            hidden_states = move_to_device(hidden_states, device)
+
+            hidden_states = model.model.norm(hidden_states)
+            if len(self.cache_args) > 0:
+                self.cache_args[0][batch_idx] = move_to_cpu(hidden_states)
+
+        layer = model.lm_head
+        gptq = GPTQ(layer)
+        full_module_name = "lm_head"
+        weight_bits = self._resolve_weight_bits(
+            gptq_conf,
+            full_module_name=full_module_name,
+            local_module_name="lm_head",
+        )
+        if (
+            gptq_conf.sensitivity is not None
+            and isinstance(gptq_conf.sensitivity, dict)
+            and full_module_name in gptq_conf.sensitivity
+        ):
+            cur_sensitivity = gptq_conf.sensitivity[full_module_name]
+        else:
+            cur_sensitivity = None
+        gptq.quantizer.configure(
+            bits=weight_bits,
+            perchannel=gptq_conf.perchannel,
+            sym=gptq_conf.symmetric,
+            mse=gptq_conf.mse,
+            sensitivity=cur_sensitivity,
+        )
+
+        # Hook to collect (inp, out) for GPTQ
+        def add_batch():
+            def _hook(_, inp, out):
+                gptq.add_batch(inp[0].data, out.data)
+
+            return _hook
+
+        handles = [layer.register_forward_hook(add_batch())]
+
+        # Run layer forward over all cached batches to build Hessian/statistics
+        device = next(layer.parameters()).device  # in case lm_head is located on cpu
+        for batch_idx in tqdm(
+            range(batch_num),
+            desc=f"[lm_head] collecting",
+            leave=False,
+            unit="batch",
+            disable=not gptq_conf.show_progress,
+        ):
+            hidden_states = gather_single_batch_from_list(self.cache_args, batch_idx)[0]
+            hidden_states = move_to_device(hidden_states, device)
+
+            layer(hidden_states)
+
+        # Remove handles
+        for h in handles:
+            h.remove()
+
+        # Quantize
+        if gptq_conf.verbose:
+            print(f"[lm_head] -> Quantizing ...")
+        gptq.fasterquant(
+            percdamp=gptq_conf.percdamp,
+            groupsize=gptq_conf.groupsize,
+            actorder=gptq_conf.actorder,
+            static_groups=gptq_conf.static_groups,
+            verbose=gptq_conf.verbose,
+        )
+        quantizers[f"lm_head"] = gptq.quantizer
+        gptq.free()

tico-0.2.0.dev260417/tico/quantization/wrapq/examples/nn/quantize_layernorm.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# 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 copy
+import sys
+
+import torch
+import torch.nn as nn
+
+import tico
+import tico.quantization
+import tico.quantization.config.ptq
+from tico.quantization.evaluation.metric import compute_peir
+from tico.quantization.evaluation.utils import plot_two_outputs
+
+
+torch.manual_seed(123)
+
+
+def generate_calibration_data(
+    num_batches: int,
+    batch_size: int,
+    normalized_shape: tuple,
+) -> list:
+    """Generate calibration data for PTQ"""
+    calibration_data = []
+    for i in range(num_batches):
+        x = torch.randn(batch_size, *normalized_shape)
+        calibration_data.append(x)
+    return calibration_data
+
+
+def main():
+    # Create LayerNorm model
+    # Using a common configuration for transformer models
+    normalized_shape = (768,)  # Hidden dimension size
+    model = nn.LayerNorm(
+        normalized_shape=normalized_shape,
+        eps=1e-5,
+        elementwise_affine=True,
+    )
+    orig_model = copy.deepcopy(model)
+    model.eval()
+
+    # Generate calibration data
+    # Input shape: (batch_size, *normalized_shape)
+    # Example: (10, 768) - 10 samples, 768 features
+    batch_size = 10
+    calibration_data = generate_calibration_data(
+        num_batches=5,
+        batch_size=batch_size,
+        normalized_shape=normalized_shape,
+    )
+    example_input = calibration_data[0]
+
+    # Configure PTQ
+    ptq_config = tico.quantization.config.ptq.PTQConfig()
+
+    # Prepare the model for quantization
+    prepared_model = tico.quantization.prepare(
+        model, ptq_config, inplace=True  # Transform the model in place
+    )
+
+    # Calibrate the model (collect statistics)
+    with torch.no_grad():
+        for i, batch in enumerate(calibration_data):
+            prepared_model(batch)
+
+    # Convert to quantized model
+    quantized_model = tico.quantization.convert(prepared_model, inplace=True)
+
+    # Compute PEIR (Peak Error-to-Interval Ratio) between quantized model and original model
+    with torch.no_grad():
+        quant_out = quantized_model(example_input)
+        fp_out = orig_model(example_input)
+
+    print(f"Input shape:              {example_input.shape}")
+    print(f"Output shape (FP32):      {fp_out.shape}")
+    print(f"Output shape (Quantized): {quant_out.shape}")
+    print(f"┌───────────── Quantization Error Summary ─────────────")
+    print(f"│ Mean |diff|: {(quant_out - fp_out).abs().mean().item():.6f}")
+    print(f"│ PEIR       : {compute_peir(fp_out, quant_out) * 100:.6f} %")
+    print(f"└──────────────────────────────────────────────────────")
+    print(plot_two_outputs(fp_out, quant_out))
+
+    # Convert to Circle format
+    circle_model = tico.convert(quantized_model.eval(), (example_input,))
+
+    # Save the Circle model
+    filename = "quantized_layernorm.circle"
+    circle_model.save(filename)
+    print(f"Circle model saved as '{filename}'")
+
+
+if __name__ == "__main__":
+    main()

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/tico/quantization/wrapq/examples/quantize_full_qmodel_with_gptq.py

@@ -72,26 +72,59 @@ def inject_gptq_qparams(
     root: torch.nn.Module,
     gptq_quantizers: dict[str, Any],  # {fp_name: quantizer}
     weight_obs_name: str = "weight",
+    *,
+    verbose: bool = False,
 ):
     """
-    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.
+    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)
-        if quantizer is None:
-            continue
         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)
-        # GPTQ quantizer attributes
         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)
 
 
 # -------------------------------------------------------------------------
@@ -172,13 +205,13 @@ def quantize_using_PTQ(q_m, calib_inputs, args):
 
     # Overwrite weight observers with GPTQ statistics
     if hasattr(q_m, "quantizers") and isinstance(q_m.quantizers, dict):
-        inject_gptq_qparams(q_m, q_m.quantizers)
+        inject_gptq_qparams(q_m, q_m.quantizers, verbose=args.verbose)
     elif (
         hasattr(q_m, "wrapped")
         and hasattr(q_m.wrapped, "quantizers")
         and isinstance(q_m.wrapped.quantizers, dict)
     ):
-        inject_gptq_qparams(q_m.wrapped, q_m.wrapped.quantizers)
+        inject_gptq_qparams(q_m.wrapped, q_m.wrapped.quantizers, verbose=args.verbose)
     else:
         print(
             "[Warn] q_m.quantizers not found or not a dict; skipping GPTQ qparam injection."
@@ -376,6 +409,11 @@ def main():
         type=str,
         default=None,
     )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Verbose logging for debugging (e.g., GPTQ injection coverage)",
+    )
     args = parser.parse_args()
     print(args)
 

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/tico/quantization/wrapq/observers/affine_base.py

@@ -106,26 +106,22 @@ class AffineObserverBase(ObserverBase):
             self._cached_scale, self._cached_zp = scale, zp
             return scale, zp
 
-        if self.channel_axis is None:
-            if torch.all(rng.abs() < 1e-8):
-                C = self.min_val
-                if torch.allclose(C, torch.zeros_like(C)):
-                    scale = torch.ones_like(C)
-                    zp = torch.zeros_like(C, dtype=torch.int)
-                elif (C > 0).all():
-                    scale = torch.clamp(C, min=eps)
-                    zp = torch.zeros_like(C, dtype=torch.int)
-                else:
-                    scale = torch.clamp(C.abs(), min=eps)
-                    zp = torch.full_like(C, qmax, dtype=torch.int)
+        if (self.channel_axis is None) and torch.all(rng.abs() < 1e-8):
+            C = self.min_val
+            if torch.allclose(C, torch.zeros_like(C)):
+                scale = torch.ones_like(C)
+                zp = torch.zeros_like(C, dtype=torch.int)
+            elif (C > 0).all():
+                scale = torch.clamp(C, min=eps)
+                zp = torch.zeros_like(C, dtype=torch.int)
             else:
-                scale = torch.clamp(rng, min=eps) / (qmax - qmin)
-                zp = (
-                    torch.round(qmin - self.min_val / scale)
-                    .clamp(qmin, qmax)
-                    .to(torch.int)
-                )
+                scale = torch.clamp(C.abs(), min=eps)
+                zp = torch.full_like(C, qmax, dtype=torch.int)
         else:
+            # Force the range to include 0
+            rng = torch.where(0 < self.min_val, self.max_val, rng)
+            rng = torch.where(0 > self.max_val, -self.min_val, rng)
+
             scale = torch.clamp(rng, min=eps) / (qmax - qmin)
             zp = (
                 torch.round(qmin - self.min_val / scale).clamp(qmin, qmax).to(torch.int)

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/tico/quantization/wrapq/wrappers/llama/quant_model.py

@@ -78,7 +78,7 @@ class QuantLlamaModel(QuantModuleBase):
 
         new_list = nn.ModuleList()
         for idx, layer in enumerate(model_fp.layers):
-            child_scope = f"{idx}"
+            child_scope = f"{fp_name}.layers.{idx}"
             child_cfg = layers_cfg.child(child_scope) if layers_cfg is not None else None  # type: ignore[union-attr]
             new_list.append(
                 PTQWrapper(

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/tico/quantization/wrapq/wrappers/llama/quant_model_for_causal_lm.py

@@ -54,12 +54,10 @@ class QuantLlamaForCausalLM(QuantModuleBase):
             model_fp.lm_head, torch.nn.Module
         )
 
-        self.model = PTQWrapper(
-            model_fp.model, qcfg=model_cfg, fp_name=f"{fp_name}.model"
-        )
+        self.model = PTQWrapper(model_fp.model, qcfg=model_cfg, fp_name=f"model")
 
         self.lm_head = PTQWrapper(
-            model_fp.lm_head, qcfg=lm_head_cfg, fp_name=f"{fp_name}.lm_head"
+            model_fp.lm_head, qcfg=lm_head_cfg, fp_name=f"lm_head"
         )
 
         # `rotate_lm_head` exists only for SpinQuant-style custom models.

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/tico.egg-info/PKG-INFO

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

{tico-0.2.0.dev260415 → tico-0.2.0.dev260417}/tico.egg-info/SOURCES.txt

@@ -139,6 +139,7 @@ tico/quantization/wrapq/examples/llama/quantize_mlp.py
 tico/quantization/wrapq/examples/nn/__init__.py
 tico/quantization/wrapq/examples/nn/quantize_conv3d.py
 tico/quantization/wrapq/examples/nn/quantize_conv3d_special_case.py
+tico/quantization/wrapq/examples/nn/quantize_layernorm.py
 tico/quantization/wrapq/examples/nn/quantize_linear.py
 tico/quantization/wrapq/examples/qwen/__init__.py
 tico/quantization/wrapq/examples/qwen/quantize_for_conditional_generation.py

tico-0.2.0.dev260415/tico/_version.py

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