tico 0.2.0.dev260707__tar.gz → 0.2.0.dev260709__tar.gz

{tico-0.2.0.dev260707 → tico-0.2.0.dev260709}/PKG-INFO

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

tico-0.2.0.dev260709/tico/_version.py

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

{tico-0.2.0.dev260707 → tico-0.2.0.dev260709}/tico/quantization/evaluation/vlm_eval_utils.py

@@ -273,7 +273,7 @@ DATASETS: dict[str, dict[str, Any]] = {
     "wikitext2": {
         "default_split": "test",
         "adapter": get_item_wikitext2,
-        "candidates": ["wikitext"],
+        "candidates": ["Salesforce/wikitext"],
         "config": "wikitext-2-raw-v1",
         "is_text_only": True,
     },

{tico-0.2.0.dev260707 → tico-0.2.0.dev260709}/tico/quantization/recipes/adapters/__init__.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from tico.quantization.recipes.adapters.base import ModelAdapter
+from tico.quantization.recipes.adapters.gemma4 import Gemma4Adapter
 from tico.quantization.recipes.adapters.llama import LlamaAdapter
 from tico.quantization.recipes.adapters.qwen3_vl import Qwen3VLAdapter
 
@@ -20,6 +21,7 @@ _ADAPTERS = {
     "llama": LlamaAdapter(),
     "qwen3_vl": Qwen3VLAdapter(),
     "qwen3-vl": Qwen3VLAdapter(),
+    "gemma4": Gemma4Adapter(),
 }
 
 

tico-0.2.0.dev260709/tico/quantization/recipes/adapters/gemma4.py

@@ -0,0 +1,330 @@
+# 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 contextlib import contextmanager
+from typing import Any, Iterator, Mapping, Sequence
+
+import torch
+import tqdm
+from transformers import AutoProcessor
+
+from tico.quantization import convert, prepare
+from tico.quantization.config.gemma4_builders import build_gemma4_e2b_ptq_config
+from tico.quantization.recipes.adapters.base import ModelAdapter
+from tico.quantization.recipes.context import RecipeContext
+from tico.quantization.recipes.data.vlm import build_vlm_calibration_inputs
+from tico.quantization.recipes.evaluation.llava_bench_judge import (
+    evaluate_and_print_llava_bench_judge,
+)
+from tico.quantization.recipes.evaluation.vlm import (
+    evaluate_llava_bench,
+    print_coco_score_results,
+)
+from tico.quantization.recipes.utils import (
+    move_to_device,
+    quant_spec_from_config,
+    torch_dtype_from_name,
+)
+from tico.quantization.wrapq.wrappers.gemma4.utils import assert_gemma4_e2b_no_moe
+
+
+class Gemma4Adapter(ModelAdapter):
+    """Model adapter for Gemma4 E2B PTQ and static runtime experiments."""
+
+    family = "gemma4"
+
+    def load_model(self, ctx: RecipeContext) -> RecipeContext:
+        """Load the Gemma4 E2B model and processor."""
+        cfg = ctx.cfg
+        model_cfg = cfg.get("model", {})
+        runtime_cfg = cfg.get("runtime", {})
+
+        ctx.device = torch.device(
+            runtime_cfg.get("device", "cuda" if torch.cuda.is_available() else "cpu")
+        )
+        ctx.dtype = torch_dtype_from_name(runtime_cfg.get("dtype", "float32"))
+
+        name = model_cfg["name_or_path"]
+        trust_remote_code = bool(model_cfg.get("trust_remote_code", True))
+        hf_token = model_cfg.get("hf_token")
+        cache_dir = model_cfg.get("cache_dir")
+        device_map = runtime_cfg.get("device_map")
+        if device_map is None:
+            if ctx.device.type == "cpu":
+                device_map = "cpu"
+            else:
+                # Use specific device index instead of "auto" to avoid
+                # multi-GPU model split during PTQ calibration.
+                device_map = str(ctx.device)
+
+        ctx.processor = AutoProcessor.from_pretrained(
+            name,
+            trust_remote_code=trust_remote_code,
+            token=hf_token,
+            cache_dir=cache_dir,
+        )
+
+        try:
+            from transformers import AutoModelForImageTextToText
+
+            ctx.model = AutoModelForImageTextToText.from_pretrained(
+                name,
+                dtype=ctx.dtype,
+                trust_remote_code=trust_remote_code,
+                token=hf_token,
+                cache_dir=cache_dir,
+                device_map=device_map,
+            )
+        except Exception:
+            from transformers import AutoModelForVision2Seq
+
+            ctx.model = AutoModelForVision2Seq.from_pretrained(
+                name,
+                dtype=ctx.dtype,
+                trust_remote_code=trust_remote_code,
+                token=hf_token,
+                cache_dir=cache_dir,
+                device_map=device_map,
+            )
+
+        ctx.model.eval()
+        self._disable_cache(ctx.model)
+        assert_gemma4_e2b_no_moe(ctx.model)
+        return ctx
+
+    @staticmethod
+    def _disable_cache(model: Any) -> None:
+        """Disable HF dynamic cache paths during PTQ calibration."""
+        if hasattr(model, "config") and hasattr(model.config, "use_cache"):
+            model.config.use_cache = False
+        text_config = getattr(getattr(model, "config", None), "text_config", None)
+        if text_config is not None and hasattr(text_config, "use_cache"):
+            text_config.use_cache = False
+
+    @staticmethod
+    def _static_calibration_image_size(
+        cfg: Mapping[str, Any],
+    ) -> tuple[int, int] | None:
+        """Return the configured static image size for calibration samples."""
+        model_args = cfg.get("model_args", {})
+        if not isinstance(model_args, Mapping):
+            return None
+
+        vision_cfg = model_args.get("vision", {})
+        if not isinstance(vision_cfg, Mapping):
+            return None
+
+        height = vision_cfg.get("image_height")
+        width = vision_cfg.get("image_width")
+        if height is None and width is None:
+            return None
+        if height is None or width is None:
+            raise ValueError(
+                "Both model_args.vision.image_height and "
+                "model_args.vision.image_width must be set for static Gemma4 "
+                "calibration resizing."
+            )
+
+        parsed_height = int(height)
+        parsed_width = int(width)
+        if parsed_height <= 0 or parsed_width <= 0:
+            raise ValueError(
+                "Gemma4 static calibration image dimensions must be positive: "
+                f"image_height={parsed_height}, image_width={parsed_width}."
+            )
+        return parsed_height, parsed_width
+
+    @staticmethod
+    @contextmanager
+    def _fixed_image_processor_size(
+        processor: Any,
+        image_size: tuple[int, int] | None,
+    ) -> Iterator[None]:
+        """Temporarily force processor image resizing for static calibration."""
+        if image_size is None:
+            yield
+            return
+
+        image_processor = getattr(processor, "image_processor", None)
+        if image_processor is None:
+            yield
+            return
+
+        height, width = image_size
+        updates: dict[str, Any] = {
+            "do_resize": True,
+            "size": {"height": height, "width": width},
+        }
+        if hasattr(image_processor, "crop_size"):
+            updates["crop_size"] = {"height": height, "width": width}
+
+        originals: dict[str, tuple[bool, Any]] = {}
+        for attr, value in updates.items():
+            originals[attr] = (
+                hasattr(image_processor, attr),
+                getattr(image_processor, attr, None),
+            )
+            setattr(image_processor, attr, value)
+
+        try:
+            yield
+        finally:
+            for attr, (had_attr, original) in originals.items():
+                if had_attr:
+                    setattr(image_processor, attr, original)
+                elif hasattr(image_processor, attr):
+                    delattr(image_processor, attr)
+
+    def build_calibration_inputs(self, ctx: RecipeContext) -> list[dict]:
+        """Build VLM calibration inputs for fixed image-text PTQ."""
+        calib = ctx.cfg.get("calibration", {})
+        runtime = ctx.cfg.get("runtime", {})
+        image_size = self._static_calibration_image_size(ctx.cfg)
+        with self._fixed_image_processor_size(ctx.processor, image_size):
+            return build_vlm_calibration_inputs(
+                processor=ctx.processor,
+                dataset=calib.get("dataset", "vqav2"),
+                datasets=calib.get("datasets"),
+                n_samples=int(calib.get("n_samples", 128)),
+                split=calib.get("split", "testdev"),
+                max_seq_len=calib.get("seq_len"),
+                seed=int(runtime.get("seed", 42)),
+            )
+
+    def forward_calibration(
+        self,
+        ctx: RecipeContext,
+        model: torch.nn.Module,
+        calibration_inputs: Sequence[Any],
+        *,
+        desc: str,
+    ) -> None:
+        """Run calibration samples through the prepared Gemma4 model."""
+        show_progress = bool(ctx.cfg.get("runtime", {}).get("show_progress", True))
+        iterator = tqdm.tqdm(calibration_inputs, desc=desc, disable=not show_progress)
+        model.eval()
+        with torch.no_grad():
+            for batch in iterator:
+                model(**move_to_device(batch, ctx.device))
+
+    def calibrate_prepared_model(
+        self,
+        ctx: RecipeContext,
+        prepared_model: torch.nn.Module,
+        stage_cfg: Mapping[str, Any],
+    ) -> None:
+        """Calibrate a prepared PTQ model."""
+        self.forward_calibration(
+            ctx, prepared_model, ctx.calibration_inputs, desc="Gemma4 PTQ calibration"
+        )
+
+    def build_ptq_config(self, ctx: RecipeContext, stage_cfg: Mapping[str, Any]):
+        """Build the Gemma4 E2B PTQConfig from recipe stage settings."""
+        text_config = ctx.model.config.get_text_config()
+        vision_config = ctx.model.config.vision_config
+        model_args = dict(ctx.cfg.get("model_args", {}))
+
+        return build_gemma4_e2b_ptq_config(
+            num_text_layers=int(text_config.num_hidden_layers),
+            num_vision_layers=int(vision_config.num_hidden_layers),
+            model_args=model_args,
+            activation=quant_spec_from_config(stage_cfg.get("activation", "int16")),
+            weight=quant_spec_from_config(stage_cfg.get("weight")),
+            linear_weight=quant_spec_from_config(stage_cfg.get("linear_weight")),
+            embedding_weight=quant_spec_from_config(stage_cfg.get("embedding_weight")),
+            lm_head_weight=quant_spec_from_config(stage_cfg.get("lm_head_weight")),
+            vision_patch_embed_weight=quant_spec_from_config(
+                stage_cfg.get("vision_patch_embed_weight")
+            ),
+            norm_weight=quant_spec_from_config(stage_cfg.get("norm_weight")),
+            strict_wrap=bool(stage_cfg.get("strict_wrap", True)),
+        )
+
+    def apply_ptq(
+        self, ctx: RecipeContext, stage_cfg: Mapping[str, Any]
+    ) -> torch.nn.Module:
+        """Prepare, calibrate, and convert Gemma4 E2B with PTQ."""
+        qcfg = self.build_ptq_config(ctx, stage_cfg)
+        prepared = prepare(
+            ctx.require_model(), qcfg, inplace=bool(stage_cfg.get("inplace", True))
+        )
+        self.calibrate_prepared_model(ctx, prepared, stage_cfg)
+        return convert(prepared, inplace=True)
+
+    def evaluate(self, ctx: RecipeContext) -> None:
+        """Evaluate Gemma4 E2B via LLaVA-Bench judge and other VLM tasks."""
+        eval_cfg = ctx.cfg.get("evaluation", {})
+        if not eval_cfg.get("enabled", False):
+            return
+
+        max_seq_len = eval_cfg.get("max_seq_len")
+        n_samples = int(eval_cfg.get("n_samples", 50))
+
+        llava_bench_cfg = eval_cfg.get("llava_bench", False)
+        if isinstance(llava_bench_cfg, Mapping):
+            if llava_bench_cfg.get("enabled", False):
+                mode = str(llava_bench_cfg.get("mode", "judge")).lower()
+                if mode in {"judge", "llm_judge"}:
+                    evaluate_and_print_llava_bench_judge(
+                        model=ctx.model,
+                        processor=ctx.processor,
+                        device=str(ctx.device),
+                        llava_cfg=llava_bench_cfg,
+                        model_cfg=ctx.cfg.get("model", {}),
+                        runtime_cfg=ctx.cfg.get("runtime", {}),
+                        default_n_samples=n_samples,
+                        default_max_seq_len=max_seq_len,
+                    )
+                elif mode in {"legacy", "coco", "caption"}:
+                    llava_results = evaluate_llava_bench(
+                        model=ctx.model,
+                        processor=ctx.processor,
+                        device=str(ctx.device),
+                        n_samples=int(llava_bench_cfg.get("n_samples", n_samples)),
+                        max_seq_len=llava_bench_cfg.get("max_seq_len", max_seq_len),
+                    )
+                    print_coco_score_results(
+                        "\n=== LLaVA Bench Legacy COCO-style Evaluation ===",
+                        llava_results,
+                    )
+                else:
+                    raise ValueError(
+                        "evaluation.llava_bench.mode must be one of "
+                        "{'judge', 'llm_judge', 'legacy', 'coco', 'caption'}, "
+                        f"got {mode!r}."
+                    )
+        elif llava_bench_cfg:
+            print(
+                "[WARNING] evaluation.llava_bench=true uses the legacy "
+                "COCO-style CIDEr/BLEU path. Prefer the nested judge config: "
+                "evaluation.llava_bench.enabled=true, mode=judge."
+            )
+            llava_results = evaluate_llava_bench(
+                model=ctx.model,
+                processor=ctx.processor,
+                device=str(ctx.device),
+                n_samples=n_samples,
+                max_seq_len=max_seq_len,
+            )
+            print_coco_score_results("\n=== Llava Bench Evaluation ===", llava_results)
+
+    def export(self, ctx: RecipeContext) -> None:
+        """Export Gemma4 E2B artifacts.
+
+        TODO: Implement Circle export via the static runtime submodule adapters.
+        """
+        export_cfg = ctx.cfg.get("export", {})
+        if not export_cfg.get("enabled", False):
+            return
+        raise NotImplementedError("Gemma4 E2B export adapter is not wired yet.")

{tico-0.2.0.dev260707 → tico-0.2.0.dev260709}/tico/quantization/recipes/adapters/llama.py

@@ -212,7 +212,7 @@ class LlamaAdapter(ModelAdapter):
             seq_len=seq_len,
             seed=int(runtime.get("seed", 42)),
             device=ctx.device,
-            dataset_name=calib.get("dataset", "wikitext"),
+            dataset_name=calib.get("dataset", "Salesforce/wikitext"),
             dataset_config=calib.get("dataset_config", "wikitext-2-raw-v1"),
             split=calib.get("split", "train"),
         )
@@ -326,7 +326,7 @@ class LlamaAdapter(ModelAdapter):
                 device=str(ctx.device),
                 cache_dir=ctx.cfg.get("model", {}).get("cache_dir"),
                 max_seq_len=max_seq_len,
-                dataset_name=ppl_cfg.get("dataset", "wikitext"),
+                dataset_name=ppl_cfg.get("dataset", "Salesforce/wikitext"),
                 dataset_config=ppl_cfg.get("dataset_config", "wikitext-2-raw-v1"),
                 split=ppl_cfg.get("split", "test"),
             )

{tico-0.2.0.dev260707 → tico-0.2.0.dev260709}/tico/quantization/recipes/data/llm.py

@@ -27,7 +27,7 @@ def build_wikitext_calibration_inputs(
     seq_len: int,
     seed: int,
     device: torch.device | str,
-    dataset_name: str = "wikitext",
+    dataset_name: str = "Salesforce/wikitext",
     dataset_config: str = "wikitext-2-raw-v1",
     split: str = "train",
 ) -> list[torch.Tensor]:

{tico-0.2.0.dev260707 → tico-0.2.0.dev260709}/tico/quantization/recipes/debug/wrapper_smoke/cases/qwen3_vl.py

@@ -464,14 +464,14 @@ class QwenTextMLPCase(QwenBaseCase):
         return ForwardInput((torch.randn(2, 8, self.text_cfg.hidden_size),))
 
 
-class QwenTextDecoderLayerCase(QwenBaseCase):
-    """Smoke case for qwen/quantize_text_decoder_layer.py."""
+class QwenTextDecoderLayerBaseCase(QwenBaseCase):
+    """Base class for Qwen3-VL text decoder-layer smoke cases."""
 
-    name = "qwen3_vl_text_decoder_layer"
-    description = "Quantize one tiny Qwen3-VL text decoder layer."
-    tags = ("qwen3_vl", "text", "decoder_layer")
+    tags: tuple[str, ...] = ("qwen3_vl", "text", "decoder_layer")
     max_mean_abs_diff = 3.0
     inplace_convert = True
+    seq_len = 8
+    export_mode = "prefill"
 
     def build(self, cfg: Mapping[str, Any]) -> tuple[torch.nn.Module, torch.nn.Module]:
         """Build a tiny text decoder layer and reference copy."""
@@ -484,16 +484,92 @@ class QwenTextDecoderLayerCase(QwenBaseCase):
         module = Qwen3VLTextDecoderLayer(self.text_cfg, layer_idx=0).eval()
         return module, clone_module(module)
 
+    def export_module(
+        self, quantized: torch.nn.Module, cfg: Mapping[str, Any]
+    ) -> torch.nn.Module:
+        """Export the wrapped text decoder layer in the case-specific mode."""
+        wrapped = getattr(quantized, "wrapped", quantized)
+        return (
+            wrapped.as_export_module(self.export_mode).eval()
+            if hasattr(wrapped, "as_export_module")
+            else quantized
+        )
+
+
+class QwenTextDecoderLayerPrefillCase(QwenTextDecoderLayerBaseCase):
+    """Smoke case for the Qwen3-VL text decoder-layer prefill wrapper path."""
+
+    name = "qwen3_vl_text_decoder_layer_prefill"
+    description = "Quantize one tiny Qwen3-VL text decoder layer in prefill mode."
+    tags = ("qwen3_vl", "text", "decoder_layer", "prefill")
+    export_mode = "prefill"
+
     def _sample(self) -> ForwardInput:
-        """Create one synthetic text decoder-layer input."""
-        seq_len = 8
-        hidden = torch.randn(1, seq_len, self.text_cfg.hidden_size)
-        pos = (
-            torch.randn(1, seq_len, self.text_cfg.head_dim),
-            torch.randn(1, seq_len, self.text_cfg.head_dim),
+        """Create one synthetic text decoder-layer prefill input."""
+        hidden = torch.randn(1, self.seq_len, self.text_cfg.hidden_size)
+        pos = _text_rope(1, self.seq_len, self.text_cfg.head_dim)
+        mask = _causal_mask(self.seq_len)
+        position_ids = torch.arange(self.seq_len).unsqueeze(0)
+        return ForwardInput(
+            (),
+            {
+                "hidden_states": hidden,
+                "position_embeddings": pos,
+                "attention_mask": mask,
+                "position_ids": position_ids,
+            },
         )
-        mask = torch.zeros(1, 1, seq_len, seq_len)
-        position_ids = torch.arange(seq_len).unsqueeze(0)
+
+    def calibration_inputs(
+        self, prepared: torch.nn.Module, cfg: Mapping[str, Any]
+    ) -> list[ForwardInput]:
+        """Create text decoder-layer prefill calibration samples."""
+        return [self._sample() for _ in range(5)]
+
+    def eval_input(
+        self, prepared: torch.nn.Module, cfg: Mapping[str, Any]
+    ) -> ForwardInput:
+        """Create the text decoder-layer prefill evaluation sample."""
+        return self._sample()
+
+    def export_input(
+        self, eval_sample: ForwardInput, cfg: Mapping[str, Any]
+    ) -> ForwardInput:
+        """Create positional prefill inputs expected by the export adapter."""
+        hidden = eval_sample.kwargs["hidden_states"]
+        mask = eval_sample.kwargs["attention_mask"]
+        pos = eval_sample.kwargs["position_embeddings"]
+        return ForwardInput((hidden, mask, pos))
+
+
+class QwenTextDecoderLayerDecodeCase(QwenTextDecoderLayerBaseCase):
+    """Smoke case for the Qwen3-VL text decoder-layer decode wrapper path."""
+
+    name = "qwen3_vl_text_decoder_layer_decode"
+    description = "Quantize one tiny Qwen3-VL text decoder layer in static decode mode."
+    tags = ("qwen3_vl", "text", "decoder_layer", "decode")
+    compare_reference_source = "prepared"
+    export_mode = "decode"
+
+    def after_prepare(self, prepared: torch.nn.Module, cfg: Mapping[str, Any]) -> None:
+        """Force tuple return so hidden states and cache tensors are available."""
+        wrapped = getattr(prepared, "wrapped", prepared)
+        if hasattr(wrapped, "return_type"):
+            wrapped.return_type = "tuple"
+
+    def _sample(self) -> ForwardInput:
+        """Create one synthetic static decode text decoder-layer input."""
+        hidden = torch.randn(1, 1, self.text_cfg.hidden_size)
+        pos = _text_rope(1, 1, self.text_cfg.head_dim)
+        mask = torch.zeros(1, 1, 1, self.seq_len)
+        position_ids = torch.full((1, 1), self.seq_len - 1, dtype=torch.long)
+        past_k = torch.randn(
+            1,
+            self.text_cfg.num_key_value_heads,
+            self.seq_len - 1,
+            self.text_cfg.head_dim,
+        )
+        past_v = torch.randn_like(past_k)
         return ForwardInput(
             (),
             {
@@ -501,21 +577,33 @@ class QwenTextDecoderLayerCase(QwenBaseCase):
                 "position_embeddings": pos,
                 "attention_mask": mask,
                 "position_ids": position_ids,
+                "past_key_values": (past_k, past_v),
+                "use_cache": True,
             },
         )
 
     def calibration_inputs(
         self, prepared: torch.nn.Module, cfg: Mapping[str, Any]
     ) -> list[ForwardInput]:
-        """Create text decoder-layer calibration samples."""
+        """Create text decoder-layer decode calibration samples."""
         return [self._sample() for _ in range(3)]
 
     def eval_input(
         self, prepared: torch.nn.Module, cfg: Mapping[str, Any]
     ) -> ForwardInput:
-        """Create the text decoder-layer evaluation sample."""
+        """Create the text decoder-layer decode evaluation sample."""
         return self._sample()
 
+    def export_input(
+        self, eval_sample: ForwardInput, cfg: Mapping[str, Any]
+    ) -> ForwardInput:
+        """Create positional static decode inputs expected by the export adapter."""
+        hidden = eval_sample.kwargs["hidden_states"]
+        mask = eval_sample.kwargs["attention_mask"]
+        pos = eval_sample.kwargs["position_embeddings"]
+        past = eval_sample.kwargs["past_key_values"]
+        return ForwardInput((hidden, mask, pos, past))
+
 
 class QwenTextModelCase(QwenBaseCase):
     """Smoke case for qwen/quantize_text_model.py."""
@@ -871,7 +959,8 @@ QWEN3_VL_CASES: tuple[WrapperSmokeCase, ...] = (
     QwenTextAttentionPrefillCase(),
     QwenTextAttentionDecodeCase(),
     QwenTextMLPCase(),
-    QwenTextDecoderLayerCase(),
+    QwenTextDecoderLayerPrefillCase(),
+    QwenTextDecoderLayerDecodeCase(),
     QwenTextModelCase(),
     QwenVisionAttentionCase(),
     QwenVisionMLPCase(),

{tico-0.2.0.dev260707 → tico-0.2.0.dev260709}/tico/quantization/recipes/evaluation/llm.py

@@ -27,7 +27,7 @@ def evaluate_perplexity(
     device: str,
     cache_dir: str | None,
     max_seq_len: int,
-    dataset_name: str = "wikitext",
+    dataset_name: str = "Salesforce/wikitext",
     dataset_config: str = "wikitext-2-raw-v1",
     split: str = "test",
 ) -> float: