tico 0.2.0.dev260702__tar.gz → 0.2.0.dev260706__tar.gz

{tico-0.2.0.dev260702 → tico-0.2.0.dev260706}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tico
-Version: 0.2.0.dev260702
+Version: 0.2.0.dev260706
 Summary: Convert Exported Torch Module To Circle
 License: This file provides full text of licenses used in this project
         
@@ -255,7 +255,12 @@ Requires-Dist: pyyaml
 Requires-Dist: tqdm
 Dynamic: license-file
 
-# TICO
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./assets/logo/banner/tico-banner-dark.png">
+    <img src="./assets/logo/banner/tico-banner-light.png" alt="TICO — Torch IR to Circle" width="640">
+  </picture>
+</p>
 
 _TICO_ (**T**orch **I**R to **C**ircle [ONE](https://github.com/Samsung/ONE)) is a Python
 library that converts PyTorch modules into Circle models — a lightweight and efficient

{tico-0.2.0.dev260702 → tico-0.2.0.dev260706}/README.md

@@ -1,4 +1,9 @@
-# TICO
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./assets/logo/banner/tico-banner-dark.png">
+    <img src="./assets/logo/banner/tico-banner-light.png" alt="TICO — Torch IR to Circle" width="640">
+  </picture>
+</p>
 
 _TICO_ (**T**orch **I**R to **C**ircle [ONE](https://github.com/Samsung/ONE)) is a Python
 library that converts PyTorch modules into Circle models — a lightweight and efficient

tico-0.2.0.dev260706/tico/_version.py

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

{tico-0.2.0.dev260702 → tico-0.2.0.dev260706}/tico/quantization/recipes/debug/wrapper_smoke/cases/gemma4.py

@@ -1550,6 +1550,270 @@ class Gemma4ModelCase(Gemma4BaseCase):
         )
 
 
+class Gemma4ForConditionalGenerationCase(Gemma4BaseCase):
+    """Smoke case for one tiny Gemma4ForConditionalGeneration."""
+
+    name = "gemma4_for_conditional_generation"
+    description = (
+        "Quantize one tiny Gemma4ForConditionalGeneration "
+        "(vision + text decoder + lm_head + softcapping)."
+    )
+    tags = ("gemma4", "e2b", "model", "conditional_generation", "image-text")
+    max_mean_abs_diff = 5.0
+    seq_len = 16
+    num_visual_tokens = 4
+
+    def ptq_config(self, cfg: Mapping[str, Any]) -> Any:
+        """Build the PTQ config used by Gemma4ForConditionalGeneration smoke checks."""
+        from tico.quantization.config.gemma4_builders import build_gemma4_e2b_ptq_config
+
+        return build_gemma4_e2b_ptq_config(
+            num_text_layers=int(self.text_cfg.num_hidden_layers),
+            num_vision_layers=int(self.vision_cfg.num_hidden_layers),
+            model_args={
+                "vision": {
+                    "visual_start_idx": 0,
+                    "num_visual_tokens": self.num_visual_tokens,
+                }
+            },
+        )
+
+    def build(self, cfg: Mapping[str, Any]) -> tuple[torch.nn.Module, torch.nn.Module]:
+        """Build a tiny Gemma4ForConditionalGeneration and reference copy."""
+        from transformers.models.gemma4.configuration_gemma4 import Gemma4Config
+        from transformers.models.gemma4.modeling_gemma4 import (
+            Gemma4ForConditionalGeneration,
+        )
+
+        torch.manual_seed(123)
+        self.text_cfg = _make_text_config(layer_types=("full_attention",))
+        # Enable logit softcapping to exercise that code path.
+        self.text_cfg.final_logit_softcapping = 30.0
+        self.vision_cfg = _make_vision_config()
+
+        config = Gemma4Config(
+            text_config=self.text_cfg,
+            vision_config=self.vision_cfg,
+            audio_config=None,
+            image_token_id=10,
+            video_token_id=11,
+            audio_token_id=12,
+        )
+        module = Gemma4ForConditionalGeneration(config).eval()
+        return module, clone_module(module)
+
+    def _sample(self) -> ForwardInput:
+        """Create one synthetic Gemma4ForConditionalGeneration text-only input.
+
+        Token IDs are kept in [0, 9] to avoid colliding with the image
+        placeholder token ID (10).
+        """
+        input_ids = torch.randint(0, 10, (1, self.seq_len))
+        return ForwardInput(
+            (),
+            {
+                "input_ids": input_ids,
+            },
+        )
+
+    def calibration_inputs(
+        self,
+        prepared: torch.nn.Module,
+        cfg: Mapping[str, Any],
+    ) -> list[ForwardInput]:
+        """Create Gemma4ForConditionalGeneration calibration samples."""
+        return [self._sample() for _ in range(3)]
+
+    def eval_input(
+        self,
+        prepared: torch.nn.Module,
+        cfg: Mapping[str, Any],
+    ) -> ForwardInput:
+        """Create the Gemma4ForConditionalGeneration evaluation sample."""
+        return self._sample()
+
+    def forward(self, module: torch.nn.Module, sample: ForwardInput) -> Any:
+        """Run the Gemma4ForConditionalGeneration without sharing mutable sample state.
+
+        The wrapper returns logits directly (not a Gemma4CausalLMOutputWithPast).
+        """
+        cloned = _clone_forward_input(sample)
+        return module(*cloned.args, **dict(cloned.kwargs))
+
+    def reference_forward(
+        self, reference: torch.nn.Module, sample: ForwardInput
+    ) -> Any:
+        """Run the original Gemma4ForConditionalGeneration without sharing mutable state."""
+        cloned = _clone_forward_input(sample)
+        output = reference(*cloned.args, **dict(cloned.kwargs))
+        return output.logits if hasattr(output, "logits") else output
+
+    def export_module(
+        self, quantized: torch.nn.Module, cfg: Mapping[str, Any]
+    ) -> torch.nn.Module:
+        """Export the wrapped Gemma4ForConditionalGeneration in prefill mode."""
+        wrapped = getattr(quantized, "wrapped", quantized)
+        if hasattr(wrapped, "as_export_module"):
+            return wrapped.as_export_module(mode="prefill").eval()
+        return quantized
+
+    def export_input(
+        self, eval_sample: ForwardInput, cfg: Mapping[str, Any]
+    ) -> ForwardInput:
+        """Create static export inputs expected by the export adapter.
+
+        The export adapter's forward_export() takes precomputed inputs:
+        - inputs_embeds: (1, S, H)
+        - per_layer_inputs: (1, S, L, P) or None
+        - attention_masks: dict[layer_type -> mask]
+        - position_embeddings: dict[layer_type -> (cos, sin)]
+        """
+        hidden_size = int(self.text_cfg.hidden_size)
+        head_dim = int(self.text_cfg.head_dim)
+        num_layers = int(self.text_cfg.num_hidden_layers)
+        ple_dim = int(getattr(self.text_cfg, "hidden_size_per_layer_input", 0) or 0)
+        layer_types = list(self.text_cfg.layer_types)
+
+        inputs_embeds = torch.randn(1, self.seq_len, hidden_size)
+
+        per_layer_inputs = None
+        if ple_dim > 0:
+            per_layer_inputs = torch.randn(1, self.seq_len, num_layers, ple_dim)
+
+        attention_masks: dict[str, torch.Tensor] = {}
+        position_embeddings: dict[str, tuple[torch.Tensor, torch.Tensor]] = {}
+        for layer_type in layer_types:
+            attention_masks[layer_type] = torch.zeros(1, 1, self.seq_len, self.seq_len)
+            cos = torch.ones(1, self.seq_len, head_dim)
+            sin = torch.zeros(1, self.seq_len, head_dim)
+            position_embeddings[layer_type] = (cos, sin)
+
+        return ForwardInput(
+            (inputs_embeds, per_layer_inputs, attention_masks, position_embeddings),
+            {},
+        )
+
+
+class Gemma4ForCausalLMCase(Gemma4BaseCase):
+    """Smoke case for one tiny Gemma4ForCausalLM (text-only)."""
+
+    name = "gemma4_for_causal_lm"
+    description = (
+        "Quantize one tiny Gemma4ForCausalLM " "(text decoder + lm_head + softcapping)."
+    )
+    tags = ("gemma4", "e2b", "model", "causal_lm", "text")
+    max_mean_abs_diff = 5.0
+    seq_len = 16
+
+    def ptq_config(self, cfg: Mapping[str, Any]) -> Any:
+        """Build the PTQ config used by Gemma4ForCausalLM smoke checks."""
+        from tico.quantization.config.gemma4_builders import build_gemma4_e2b_ptq_config
+
+        return build_gemma4_e2b_ptq_config(
+            num_text_layers=int(self.text_cfg.num_hidden_layers),
+            num_vision_layers=0,
+        )
+
+    def build(self, cfg: Mapping[str, Any]) -> tuple[torch.nn.Module, torch.nn.Module]:
+        """Build a tiny Gemma4ForCausalLM and reference copy."""
+        from transformers.models.gemma4.modeling_gemma4 import Gemma4ForCausalLM
+
+        torch.manual_seed(123)
+        self.text_cfg = _make_text_config(layer_types=("full_attention",))
+        # Enable logit softcapping to exercise that code path.
+        self.text_cfg.final_logit_softcapping = 30.0
+
+        module = Gemma4ForCausalLM(self.text_cfg).eval()
+        return module, clone_module(module)
+
+    def _sample(self) -> ForwardInput:
+        """Create one synthetic Gemma4ForCausalLM text-only input."""
+        input_ids = torch.randint(0, self.text_cfg.vocab_size, (1, self.seq_len))
+        return ForwardInput(
+            (),
+            {
+                "input_ids": input_ids,
+            },
+        )
+
+    def calibration_inputs(
+        self,
+        prepared: torch.nn.Module,
+        cfg: Mapping[str, Any],
+    ) -> list[ForwardInput]:
+        """Create Gemma4ForCausalLM calibration samples."""
+        return [self._sample() for _ in range(3)]
+
+    def eval_input(
+        self,
+        prepared: torch.nn.Module,
+        cfg: Mapping[str, Any],
+    ) -> ForwardInput:
+        """Create the Gemma4ForCausalLM evaluation sample."""
+        return self._sample()
+
+    def forward(self, module: torch.nn.Module, sample: ForwardInput) -> Any:
+        """Run the Gemma4ForCausalLM without sharing mutable sample state.
+
+        The wrapper returns logits directly (not a Gemma4CausalLMOutputWithPast).
+        """
+        cloned = _clone_forward_input(sample)
+        return module(*cloned.args, **dict(cloned.kwargs))
+
+    def reference_forward(
+        self, reference: torch.nn.Module, sample: ForwardInput
+    ) -> Any:
+        """Run the original Gemma4ForCausalLM without sharing mutable state."""
+        cloned = _clone_forward_input(sample)
+        output = reference(*cloned.args, **dict(cloned.kwargs))
+        return output.logits if hasattr(output, "logits") else output
+
+    def export_module(
+        self, quantized: torch.nn.Module, cfg: Mapping[str, Any]
+    ) -> torch.nn.Module:
+        """Export the wrapped Gemma4ForCausalLM in prefill mode."""
+        wrapped = getattr(quantized, "wrapped", quantized)
+        if hasattr(wrapped, "as_export_module"):
+            return wrapped.as_export_module(mode="prefill").eval()
+        return quantized
+
+    def export_input(
+        self, eval_sample: ForwardInput, cfg: Mapping[str, Any]
+    ) -> ForwardInput:
+        """Create static export inputs expected by the export adapter.
+
+        The export adapter's forward_export() takes precomputed inputs:
+        - inputs_embeds: (1, S, H)
+        - per_layer_inputs: (1, S, L, P) or None
+        - attention_masks: dict[layer_type -> mask]
+        - position_embeddings: dict[layer_type -> (cos, sin)]
+        """
+        hidden_size = int(self.text_cfg.hidden_size)
+        head_dim = int(self.text_cfg.head_dim)
+        num_layers = int(self.text_cfg.num_hidden_layers)
+        ple_dim = int(getattr(self.text_cfg, "hidden_size_per_layer_input", 0) or 0)
+        layer_types = list(self.text_cfg.layer_types)
+
+        inputs_embeds = torch.randn(1, self.seq_len, hidden_size)
+
+        per_layer_inputs = None
+        if ple_dim > 0:
+            per_layer_inputs = torch.randn(1, self.seq_len, num_layers, ple_dim)
+
+        attention_masks: dict[str, torch.Tensor] = {}
+        position_embeddings: dict[str, tuple[torch.Tensor, torch.Tensor]] = {}
+        for layer_type in layer_types:
+            attention_masks[layer_type] = torch.zeros(1, 1, self.seq_len, self.seq_len)
+            cos = torch.ones(1, self.seq_len, head_dim)
+            sin = torch.zeros(1, self.seq_len, head_dim)
+            position_embeddings[layer_type] = (cos, sin)
+
+        return ForwardInput(
+            (inputs_embeds, per_layer_inputs, attention_masks, position_embeddings),
+            {},
+        )
+
+
 GEMMA4_CASES = (
     Gemma4TextMLPCase(),
     Gemma4TextAttentionCase(),
@@ -1570,4 +1834,6 @@ GEMMA4_CASES = (
     Gemma4MultimodalEmbedderCase(),
     Gemma4VisionEncoderCase(),
     Gemma4ModelCase(),
+    Gemma4ForConditionalGenerationCase(),
+    Gemma4ForCausalLMCase(),
 )

tico-0.2.0.dev260706/tico/quantization/wrapq/examples/gemma4/quantize_for_causal_lm.py

@@ -0,0 +1,163 @@
+#!/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.
+
+"""Example: PTQ quantization of Gemma4ForCausalLM.
+
+The ``Gemma4ForCausalLM`` is the text-only causal LM that wraps
+``Gemma4TextModel`` (text decoder) and adds an ``lm_head`` linear layer
+to produce vocabulary logits.  It also applies logit softcapping when
+``final_logit_softcapping`` is set in the text config.
+
+This script demonstrates the full PTQ flow:
+
+1. Create a tiny Gemma4ForCausalLM with random weights.
+2. Prepare the model for quantization with a Gemma4-specific PTQ config.
+3. Calibrate with synthetic text-only data.
+4. Convert to a fake-quantized model.
+5. Compare FP vs. quantized logits.
+6. Export to Circle format via the export adapter.
+"""
+
+import copy
+import sys
+
+import torch
+
+import tico
+import tico.quantization
+import tico.quantization.config.ptq
+from tico.quantization.config.gemma4_builders import build_gemma4_e2b_ptq_config
+from tico.quantization.evaluation.metric import compute_peir
+from tico.quantization.evaluation.utils import plot_two_outputs
+from tico.quantization.wrapq.utils.version import has_transformers_for
+
+torch.manual_seed(123)
+
+
+# Check if transformers is available
+if not has_transformers_for("gemma4"):
+    print(
+        "Error: transformers package with Gemma4 support not installed. "
+        "Cannot test Gemma4ForCausalLM."
+    )
+    sys.exit(1)
+
+from transformers.models.gemma4.configuration_gemma4 import Gemma4TextConfig
+from transformers.models.gemma4.modeling_gemma4 import Gemma4ForCausalLM
+
+
+def _make_text_config() -> Gemma4TextConfig:
+    """Create a tiny Gemma4 text config for the example."""
+    cfg = Gemma4TextConfig(
+        vocab_size=256,
+        hidden_size=64,
+        intermediate_size=128,
+        num_hidden_layers=1,
+        num_attention_heads=2,
+        num_key_value_heads=2,
+        num_global_key_value_heads=2,
+        head_dim=32,
+        global_head_dim=32,
+        max_position_embeddings=128,
+        layer_types=["full_attention"],
+        rope_parameters={
+            "full_attention": {"rope_type": "default", "rope_theta": 10000.0}
+        },
+        attention_bias=False,
+        attention_dropout=0.0,
+        use_cache=False,
+        enable_moe_block=False,
+        # Enable logit softcapping to exercise that code path.
+        final_logit_softcapping=30.0,
+    )
+    if not hasattr(cfg, "_attn_implementation"):
+        setattr(cfg, "_attn_implementation", "eager")
+    else:
+        cfg._attn_implementation = "eager"
+    return cfg
+
+
+def generate_text_only_calibration_data(
+    batch_size: int,
+    seq_len: int,
+    vocab_size: int,
+    num_samples: int = 20,
+) -> list[dict]:
+    """Generate text-only calibration data for PTQ."""
+    calibration_data = []
+    for _ in range(num_samples):
+        input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
+        sample = {
+            "input_ids": input_ids,
+        }
+        calibration_data.append(sample)
+    return calibration_data
+
+
+def main():
+    # Create the model with a tiny config (no download needed).
+    text_config = _make_text_config()
+
+    model = Gemma4ForCausalLM(text_config)
+    orig_model = copy.deepcopy(model)
+    model.eval()
+
+    # Dimensions
+    batch_size = 1
+    seq_len = 16
+
+    # Build a Gemma4-specific PTQ config.
+    ptq_config = build_gemma4_e2b_ptq_config(
+        num_text_layers=int(text_config.num_hidden_layers),
+        num_vision_layers=0,
+    )
+
+    # Prepare the model for quantization
+    print("Preparing model for quantization...")
+    prepared_model = tico.quantization.prepare(model, ptq_config)
+
+    # Calibrate with text-only data
+    print("Calibrating (text-only)...")
+    calibration_data = generate_text_only_calibration_data(
+        batch_size=batch_size,
+        seq_len=seq_len,
+        vocab_size=text_config.vocab_size,
+        num_samples=20,
+    )
+    with torch.no_grad():
+        for sample in calibration_data:
+            prepared_model(**sample)
+
+    # Convert to quantized model
+    print("Converting to quantized model...")
+    quantized_model = tico.quantization.convert(prepared_model)
+
+    # Compute PEIR between quantized model and original model
+    eval_sample = calibration_data[0]
+    with torch.no_grad():
+        quant_out = quantized_model(**eval_sample)
+        fp_out = orig_model(**eval_sample).logits
+
+    print(f"\n┌───────────── Quantization Error Summary ─────────────")
+    print(f"│ FP output shape    : {tuple(fp_out.shape)}")
+    print(f"│ Quant output shape : {tuple(quant_out.shape)}")
+    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))
+
+
+if __name__ == "__main__":
+    main()

tico-0.2.0.dev260706/tico/quantization/wrapq/examples/gemma4/quantize_for_conditional_generation.py

@@ -0,0 +1,215 @@
+#!/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.
+
+"""Example: PTQ quantization of Gemma4ForConditionalGeneration.
+
+The ``Gemma4ForConditionalGeneration`` is the top-level model that wraps
+``Gemma4Model`` (vision + text decoder) and adds an ``lm_head`` linear layer
+to produce vocabulary logits.  It also applies logit softcapping when
+``final_logit_softcapping`` is set in the text config.
+
+This script demonstrates the full PTQ flow:
+
+1. Create a tiny Gemma4ForConditionalGeneration with random weights.
+2. Prepare the model for quantization with a Gemma4-specific PTQ config.
+3. Calibrate with synthetic text-only data.
+4. Convert to a fake-quantized model.
+5. Compare FP vs. quantized logits.
+6. Export to Circle format via the export adapter.
+"""
+
+import copy
+import sys
+
+import torch
+
+import tico
+import tico.quantization
+from tico.quantization.config.gemma4_builders import build_gemma4_e2b_ptq_config
+from tico.quantization.evaluation.metric import compute_peir
+from tico.quantization.evaluation.utils import plot_two_outputs
+from tico.quantization.wrapq.utils.version import has_transformers_for
+
+torch.manual_seed(123)
+
+
+# Check if transformers is available
+if not has_transformers_for("gemma4"):
+    print(
+        "Error: transformers package with Gemma4 support not installed. "
+        "Cannot test Gemma4ForConditionalGeneration."
+    )
+    sys.exit(1)
+
+from transformers.models.gemma4.configuration_gemma4 import (
+    Gemma4Config,
+    Gemma4TextConfig,
+    Gemma4VisionConfig,
+)
+from transformers.models.gemma4.modeling_gemma4 import Gemma4ForConditionalGeneration
+
+
+def _make_vision_config() -> Gemma4VisionConfig:
+    """Create a tiny Gemma4 vision config for the example."""
+    cfg = Gemma4VisionConfig(
+        hidden_size=32,
+        intermediate_size=64,
+        num_hidden_layers=1,
+        num_attention_heads=4,
+        num_key_value_heads=2,
+        head_dim=8,
+        patch_size=4,
+        position_embedding_size=8,
+        pooling_kernel_size=2,
+        attention_dropout=0.0,
+        max_position_embeddings=128,
+        rms_norm_eps=1e-6,
+        use_clipped_linears=False,
+        rope_parameters={"rope_type": "default", "rope_theta": 100.0},
+        standardize=True,
+    )
+    if not hasattr(cfg, "_attn_implementation"):
+        setattr(cfg, "_attn_implementation", "eager")
+    else:
+        cfg._attn_implementation = "eager"
+    return cfg
+
+
+def _make_text_config() -> Gemma4TextConfig:
+    """Create a tiny Gemma4 text config for the example."""
+    cfg = Gemma4TextConfig(
+        vocab_size=256,
+        hidden_size=64,
+        intermediate_size=128,
+        num_hidden_layers=1,
+        num_attention_heads=2,
+        num_key_value_heads=2,
+        num_global_key_value_heads=2,
+        head_dim=32,
+        global_head_dim=32,
+        max_position_embeddings=128,
+        layer_types=["full_attention"],
+        rope_parameters={
+            "full_attention": {"rope_type": "default", "rope_theta": 10000.0}
+        },
+        attention_bias=False,
+        attention_dropout=0.0,
+        use_cache=False,
+        enable_moe_block=False,
+        # Enable logit softcapping to exercise that code path.
+        final_logit_softcapping=30.0,
+    )
+    if not hasattr(cfg, "_attn_implementation"):
+        setattr(cfg, "_attn_implementation", "eager")
+    else:
+        cfg._attn_implementation = "eager"
+    return cfg
+
+
+def _make_gemma4_config() -> Gemma4Config:
+    """Create a tiny Gemma4 top-level config for the example."""
+    return Gemma4Config(
+        text_config=_make_text_config(),
+        vision_config=_make_vision_config(),
+        audio_config=None,
+        image_token_id=10,
+        video_token_id=11,
+        audio_token_id=12,
+    )
+
+
+def generate_text_only_calibration_data(
+    batch_size: int,
+    seq_len: int,
+    vocab_size: int,
+    num_samples: int = 20,
+) -> list[dict]:
+    """Generate text-only calibration data for PTQ."""
+    calibration_data = []
+    for _ in range(num_samples):
+        input_ids = torch.randint(0, vocab_size, (batch_size, seq_len))
+        # Avoid image placeholder token IDs to keep this text-only.
+        input_ids = input_ids.clamp(0, 9)
+        sample = {
+            "input_ids": input_ids,
+        }
+        calibration_data.append(sample)
+    return calibration_data
+
+
+def main():
+    # Create the model with a tiny config (no download needed).
+    config = _make_gemma4_config()
+    text_config = config.get_text_config()
+    vision_config = config.vision_config
+
+    model = Gemma4ForConditionalGeneration(config)
+    orig_model = copy.deepcopy(model)
+    model.eval()
+
+    # Dimensions
+    batch_size = 1
+    seq_len = 16
+    num_visual_tokens = 4
+
+    # Build a Gemma4-specific PTQ config.
+    ptq_config = 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={
+            "vision": {
+                "visual_start_idx": 0,
+                "num_visual_tokens": num_visual_tokens,
+            }
+        },
+    )
+
+    # Prepare the model for quantization
+    print("Preparing model for quantization...")
+    prepared_model = tico.quantization.prepare(model, ptq_config)
+
+    # Calibrate with text-only data
+    print("Calibrating (text-only)...")
+    calibration_data = generate_text_only_calibration_data(
+        batch_size=batch_size,
+        seq_len=seq_len,
+        vocab_size=text_config.vocab_size,
+        num_samples=20,
+    )
+    with torch.no_grad():
+        for sample in calibration_data:
+            prepared_model(**sample)
+
+    # Convert to quantized model
+    print("Converting to quantized model...")
+    quantized_model = tico.quantization.convert(prepared_model)
+
+    # Compute PEIR between quantized model and original model
+    eval_sample = calibration_data[0]
+    with torch.no_grad():
+        quant_out = quantized_model(**eval_sample)
+        fp_out = orig_model(**eval_sample).logits
+
+    print(f"\n┌───────────── Quantization Error Summary ─────────────")
+    print(f"│ FP output shape    : {tuple(fp_out.shape)}")
+    print(f"│ Quant output shape : {tuple(quant_out.shape)}")
+    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))
+
+
+if __name__ == "__main__":
+    main()