tico 0.1.0.dev250921__py3-none-any.whl → 0.1.0.dev250923__py3-none-any.whl

tico/__init__.py

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

tico/config/v1.py

@@ -23,6 +23,7 @@ class CompileConfigV1(CompileConfigBase):
     remove_constant_input: bool = False
     convert_lhs_const_mm_to_fc: bool = False
     convert_rhs_const_mm_to_fc: bool = True
+    convert_single_batch_lhs_const_bmm_to_fc: bool = False
 
     def get(self, name: str):
         return super().get(name)

tico/experimental/quantization/algorithm/gptq/quantizer.py

@@ -27,6 +27,7 @@ from tico.experimental.quantization.algorithm.gptq.utils import (
 )
 from tico.experimental.quantization.config.gptq import GPTQConfig
 from tico.experimental.quantization.quantizer import BaseQuantizer
+from tico.experimental.quantization.quantizer_registry import register_quantizer
 
 
 class StopForward(Exception):
@@ -35,6 +36,7 @@ class StopForward(Exception):
     pass
 
 
+@register_quantizer(GPTQConfig)
 class GPTQQuantizer(BaseQuantizer):
     """
     Quantizer for applying the GPTQ algorithm (typically for weight quantization).

tico/experimental/quantization/algorithm/pt2e/quantizer.py

@@ -22,9 +22,12 @@ from tico.experimental.quantization.algorithm.pt2e.annotation.annotator import (
     get_asymmetric_quantization_config,
     PT2EAnnotator,
 )
+from tico.experimental.quantization.config.pt2e import PT2EConfig
 from tico.experimental.quantization.quantizer import BaseQuantizer
+from tico.experimental.quantization.quantizer_registry import register_quantizer
 
 
+@register_quantizer(PT2EConfig)
 class PT2EQuantizer(BaseQuantizer):
     """
     Quantizer for applying pytorch 2.0 export quantization (typically for activation quantization).

tico/experimental/quantization/algorithm/smoothquant/quantizer.py

@@ -25,8 +25,10 @@ from tico.experimental.quantization.algorithm.smoothquant.smooth_quant import (
 )
 from tico.experimental.quantization.config.smoothquant import SmoothQuantConfig
 from tico.experimental.quantization.quantizer import BaseQuantizer
+from tico.experimental.quantization.quantizer_registry import register_quantizer
 
 
+@register_quantizer(SmoothQuantConfig)
 class SmoothQuantQuantizer(BaseQuantizer):
     """
     Quantizer for applying the SmoothQuant algorithm

tico/experimental/quantization/config/smoothquant.py

@@ -38,4 +38,4 @@ class SmoothQuantConfig(BaseConfig):
 
     @property
     def name(self) -> str:
-        return "smooth_quant"
+        return "smoothquant"

tico/experimental/quantization/ptq/wrappers/fairseq/quant_decoder.py

@@ -0,0 +1,431 @@
+# 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.
+#
+# -----------------------------------------------------------------------------
+# This file includes modifications based on fairseq
+#  (https://github.com/facebookresearch/fairseq), originally licensed under
+# the MIT License. See the LICENSE file in the fairseq repository for details.
+# -----------------------------------------------------------------------------
+
+import math
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+
+from tico.experimental.quantization.ptq.quant_config import QuantConfig
+from tico.experimental.quantization.ptq.wrappers.ptq_wrapper import PTQWrapper
+from tico.experimental.quantization.ptq.wrappers.quant_module_base import (
+    QuantModuleBase,
+)
+from tico.experimental.quantization.ptq.wrappers.registry import try_register
+
+
+@try_register("fairseq.models.transformer.TransformerDecoderBase")
+class QuantFairseqDecoder(QuantModuleBase):
+    """
+    Quant-aware drop-in replacement for Fairseq TransformerDecoderBase.
+
+    Design (inference-only):
+    - Keep embeddings, positional embeddings, LayerNorms, output_projection in FP.
+    - PTQ-wrap all TransformerDecoderLayerBase items via PTQWrapper (uses QuantFairseqDecoderLayer).
+    - Drop training-only logic (dropout, activation-dropout, quant-noise, checkpoint wrappers).
+    - Preserve Fairseq forward/extract_features contract, shapes, and incremental decoding behavior.
+
+    I/O:
+    - Forward(prev_output_tokens, encoder_out, incremental_state, ...) -> (logits, extra) like the original.
+    - `features_only=True` returns features without output projection.
+    """
+
+    def __init__(
+        self,
+        fp_decoder: nn.Module,
+        *,
+        qcfg: Optional[QuantConfig] = None,
+        fp_name: Optional[str] = None,
+    ):
+        super().__init__(qcfg, fp_name=fp_name)
+
+        # ---- carry config/meta (read-only views) --------------------------
+        assert hasattr(fp_decoder, "cfg")
+        self.cfg = fp_decoder.cfg
+        self.share_input_output_embed: bool = bool(
+            getattr(fp_decoder, "share_input_output_embed", False)
+        )
+
+        # Version buffer (parity with original)
+        version = getattr(fp_decoder, "version", None)
+        if isinstance(version, torch.Tensor):
+            self.register_buffer("version", version.clone(), persistent=False)
+        else:
+            self.register_buffer("version", torch.tensor([3.0]), persistent=False)
+
+        # Embeddings / positional encodings (FP; reuse modules)
+        assert hasattr(fp_decoder, "embed_tokens") and isinstance(
+            fp_decoder.embed_tokens, nn.Module
+        )
+        self.embed_tokens = fp_decoder.embed_tokens  # (B,T)->(B,T,C)
+
+        self.padding_idx: int = int(fp_decoder.padding_idx)  # type: ignore[arg-type]
+        self.max_target_positions: int = int(fp_decoder.max_target_positions)  # type: ignore[arg-type]
+
+        self.embed_positions = getattr(fp_decoder, "embed_positions", None)
+        self.layernorm_embedding = getattr(fp_decoder, "layernorm_embedding", None)
+
+        # Dimensions / projections (reuse)
+        self.embed_dim: int = int(getattr(fp_decoder, "embed_dim"))
+        self.output_embed_dim: int = int(getattr(fp_decoder, "output_embed_dim"))
+        self.project_in_dim = getattr(fp_decoder, "project_in_dim", None)
+        self.project_out_dim = getattr(fp_decoder, "project_out_dim", None)
+
+        # Scale factor (sqrt(embed_dim) unless disabled)
+        no_scale = bool(getattr(self.cfg, "no_scale_embedding", False))
+        self.embed_scale: float = 1.0 if no_scale else math.sqrt(self.embed_dim)
+
+        # Final decoder LayerNorm (may be None depending on cfg)
+        self.layer_norm = getattr(fp_decoder, "layer_norm", None)
+
+        # Output projection / adaptive softmax (reuse FP modules)
+        self.adaptive_softmax = getattr(fp_decoder, "adaptive_softmax", None)
+        self.output_projection = getattr(fp_decoder, "output_projection", None)
+
+        # ---- wrap decoder layers ------------------------------------------
+        assert hasattr(fp_decoder, "layers")
+        fp_layers = list(fp_decoder.layers)  # type: ignore[arg-type]
+        self.layers = nn.ModuleList()
+
+        # Safe prefix to avoid None-based name collisions in KV cache keys
+        def _safe_prefix(name: Optional[str]) -> str:
+            return (
+                name
+                if (name is not None and name != "" and name != "None")
+                else f"{self.__class__.__name__}_{id(self)}"
+            )
+
+        prefix = _safe_prefix(fp_name)
+
+        # Prepare child QuantConfig namespaces: layers/<idx>
+        layers_qcfg = qcfg.child("layers") if qcfg else None
+        for i, layer in enumerate(fp_layers):
+            child_cfg = layers_qcfg.child(str(i)) if layers_qcfg else None
+            # Not every item is necessarily a TransformerDecoderLayerBase (e.g., BaseLayer).
+            # If there's no registered wrapper for a layer type, keep it FP.
+            try:
+                wrapped = PTQWrapper(
+                    layer, qcfg=child_cfg, fp_name=f"{prefix}.layers.{i}"
+                )
+            except NotImplementedError:
+                wrapped = layer  # keep as-is (FP)
+            self.layers.append(wrapped)
+        self.num_layers = len(self.layers)
+
+        # choose a generous upper-bound; you can wire this from cfg if you like
+        self.mask_fill_value: float = -120.0
+        max_tgt = int(getattr(self.cfg, "max_target_positions", 2048))  # fallback: 2048
+
+        mask = torch.full((1, 1, max_tgt, max_tgt), float(self.mask_fill_value))
+        mask.triu_(1)  # upper triangle set to fill_value; diagonal/lower are zeros
+        self.register_buffer("causal_mask_template", mask, persistent=False)
+
+    def forward(
+        self,
+        prev_output_tokens: Tensor,  # [B, T]
+        encoder_out: Optional[Dict[str, List[Tensor]]] = None,
+        incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
+        features_only: bool = False,
+        full_context_alignment: bool = False,
+        alignment_layer: Optional[int] = None,
+        alignment_heads: Optional[int] = None,
+        src_lengths: Optional[Any] = None,
+        return_all_hiddens: bool = False,
+    ):
+        """
+        Match the original API.
+        Returns:
+            (logits_or_features, extra_dict)
+        """
+        x, extra = self.extract_features_scriptable(
+            prev_output_tokens=prev_output_tokens,
+            encoder_out=encoder_out,
+            incremental_state=incremental_state,
+            full_context_alignment=full_context_alignment,
+            alignment_layer=alignment_layer,
+            alignment_heads=alignment_heads,
+        )
+        if not features_only:
+            x = self.output_layer(x)
+        return x, extra
+
+    def extract_features_scriptable(
+        self,
+        prev_output_tokens: Tensor,  # [B,T]
+        encoder_out: Optional[Dict[str, List[Tensor]]],
+        incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
+        full_context_alignment: bool = False,
+        alignment_layer: Optional[int] = None,
+        alignment_heads: Optional[int] = None,
+    ) -> Tuple[Tensor, Dict[str, List[Optional[Tensor]]]]:
+        """
+        Feature path that mirrors Fairseq's implementation (minus training-only code).
+
+        Returns:
+            x: [B, T, C]
+            extra: {"attn": [attn or None], "inner_states": [T x B x C tensors]}
+        """
+        B, T = prev_output_tokens.size()
+        if alignment_layer is None:
+            alignment_layer = self.num_layers - 1
+
+        # Unpack encoder outputs in Fairseq dict format
+        enc: Optional[Tensor] = None
+        padding_mask: Optional[Tensor] = None
+        if encoder_out is not None and len(encoder_out.get("encoder_out", [])) > 0:
+            enc = encoder_out["encoder_out"][0]  # [S,B,Ce]
+        if (
+            encoder_out is not None
+            and len(encoder_out.get("encoder_padding_mask", [])) > 0
+        ):
+            padding_mask = encoder_out["encoder_padding_mask"][0]  # [B,S] (bool)
+
+        # Positional embeddings (support incremental decoding)
+        positions = None
+        if self.embed_positions is not None:
+            positions = self.embed_positions(
+                prev_output_tokens, incremental_state=incremental_state
+            )
+
+        # In incremental mode, only the last step is consumed
+        if incremental_state is not None:
+            prev_output_tokens = prev_output_tokens[:, -1:]
+            if positions is not None:
+                positions = positions[:, -1:]
+
+        # Prevent view quirks (TorchScript parity in original)
+        prev_output_tokens = prev_output_tokens.contiguous()
+
+        # Token embeddings (+ optional proj-in), + positions, + optional LN
+        x = self.embed_scale * self.embed_tokens(prev_output_tokens)  # [B,T,C]
+        if self.project_in_dim is not None:
+            x = self.project_in_dim(x)
+        if positions is not None:
+            x = x + positions
+        if self.layernorm_embedding is not None:
+            x = self.layernorm_embedding(x)
+
+        # No dropout / quant_noise (inference-only)
+
+        # B x T x C -> T x B x C
+        x = x.transpose(0, 1)
+
+        # Build self-attn masks
+        self_attn_padding_mask: Optional[Tensor] = None
+        if (
+            getattr(self.cfg, "cross_self_attention", False)
+            or prev_output_tokens.eq(self.padding_idx).any()
+        ):
+            self_attn_padding_mask = prev_output_tokens.eq(self.padding_idx)  # [B,T]
+
+        attn: Optional[Tensor] = None
+        inner_states: List[Optional[Tensor]] = [x]
+
+        for idx, layer in enumerate(self.layers):
+            # Causal mask unless full-context alignment or incremental decoding
+            if incremental_state is None and not full_context_alignment:
+                Tq = x.size(0)
+                self_attn_mask = self.buffered_future_mask(
+                    Tq, Tq, x=x
+                )  # [Tq,Tq] additive float
+            else:
+                self_attn_mask = None
+
+            x, layer_attn, _ = layer(
+                x,
+                enc,
+                padding_mask,
+                incremental_state,
+                self_attn_mask=self_attn_mask,
+                self_attn_padding_mask=self_attn_padding_mask,
+                need_attn=bool(idx == alignment_layer),
+                need_head_weights=bool(idx == alignment_layer),
+            )
+
+            inner_states.append(x)
+            if layer_attn is not None and idx == alignment_layer:
+                attn = layer_attn.float().to(x)
+
+        # Average heads if needed
+        if attn is not None and alignment_heads is not None:
+            attn = attn[:alignment_heads]
+        if attn is not None:
+            attn = attn.mean(dim=0)  # [B,T,S]
+
+        # Optional final layer norm
+        if self.layer_norm is not None:
+            x = self.layer_norm(x)
+
+        # T x B x C -> B x T x C
+        x = x.transpose(0, 1)
+
+        # Optional proj-out
+        if self.project_out_dim is not None:
+            assert self.project_out_dim is not None
+            x = self.project_out_dim(x)
+
+        return x, {"attn": [attn], "inner_states": inner_states}
+
+    def output_layer(self, features: Tensor) -> Tensor:
+        """Project features to vocabulary size (or return features with adaptive softmax)."""
+        if self.adaptive_softmax is None:
+            assert self.output_projection is not None
+            return self.output_projection(features)  # type: ignore[operator]
+        else:
+            return features
+
+    def buffered_future_mask(
+        self, Tq: int, Ts: int, *, x: torch.Tensor
+    ) -> torch.Tensor:
+        """
+        Return additive float mask [Tq, Ts]: zeros on allowed, large-neg on disallowed.
+        Uses the prebuilt template; will re-build if you exceed template size.
+        """
+        assert isinstance(self.causal_mask_template, torch.Tensor)
+        Mmax = self.causal_mask_template.size(-1)
+        assert Tq <= Mmax and Ts <= Mmax
+        cm = self.causal_mask_template[..., :Tq, :Ts].to(device=x.device, dtype=x.dtype)
+        return cm.squeeze(0).squeeze(0)  # [Tq, Ts]
+
+    def max_positions(self) -> int:
+        """Maximum output length supported by the decoder (same policy as the original)."""
+        if self.embed_positions is None:
+            return self.max_target_positions
+        return min(self.max_target_positions, self.embed_positions.max_positions)
+
+    def get_normalized_probs(
+        self,
+        net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],
+        log_probs: bool,
+        sample: Optional[Dict[str, Tensor]] = None,
+    ):
+        """Get normalized probabilities (or log probs) from a net's output."""
+        return self.get_normalized_probs_scriptable(net_output, log_probs, sample)
+
+    def get_normalized_probs_scriptable(
+        self,
+        net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]],
+        log_probs: bool,
+        sample: Optional[Dict[str, Tensor]] = None,
+    ):
+        """Get normalized probabilities (or log probs) from a net's output."""
+
+        if hasattr(self, "adaptive_softmax") and self.adaptive_softmax is not None:
+            if sample is not None:
+                assert "target" in sample
+                target = sample["target"]
+            else:
+                target = None
+            out = self.adaptive_softmax.get_log_prob(net_output[0], target=target)
+            return out.exp_() if not log_probs else out
+
+        logits = net_output[0]
+        if log_probs:
+            return F.log_softmax(logits, dim=-1, dtype=torch.float32)
+        else:
+            return F.softmax(logits, dim=-1, dtype=torch.float32)
+
+    def reorder_incremental_state_scripting(
+        self,
+        incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
+        new_order: Tensor,
+    ):
+        """Main entry point for reordering the incremental state.
+
+        Due to limitations in TorchScript, we call this function in
+        :class:`fairseq.sequence_generator.SequenceGenerator` instead of
+        calling :func:`reorder_incremental_state` directly.
+        """
+        for module in self.modules():
+            if hasattr(module, "reorder_incremental_state"):
+                result = module.reorder_incremental_state(incremental_state, new_order)  # type: ignore[operator]
+                if result is not None:
+                    incremental_state = result
+
+    def forward_external_step(
+        self,
+        prev_output_x: Tensor,  # [1, B, C]
+        *,
+        encoder_out_x: Tensor,  # [S, B, Ce]
+        encoder_padding_mask: Optional[
+            Tensor
+        ] = None,  # [B,S] or [B,1,S] additive-float
+        self_attn_mask: Optional[
+            Tensor
+        ] = None,  # [1,S_hist+1] or [B,1,S_hist+1] additive-float
+        prev_self_k_list: Optional[
+            List[Tensor]
+        ] = None,  # length=L; each [B,H,Tprev,Dh]
+        prev_self_v_list: Optional[
+            List[Tensor]
+        ] = None,  # length=L; each [B,H,Tprev,Dh]
+        need_attn: bool = False,
+        need_head_weights: bool = False,
+    ) -> Tuple[Tensor, List[Tensor], List[Tensor]]:
+        """
+        Export-only single-step decoder.
+        Returns:
+          - x_out: [1, B, C]
+          - new_self_k_list/new_self_v_list: lists of length L; each [B*H, Tnew, Dh]
+        """
+        assert (
+            prev_output_x.dim() == 3 and prev_output_x.size(0) == 1
+        ), "prev_output_x must be [1,B,C]"
+        L = self.num_layers
+        if prev_self_k_list is None:
+            prev_self_k_list = [None] * L  # type: ignore[list-item]
+        if prev_self_v_list is None:
+            prev_self_v_list = [None] * L  # type: ignore[list-item]
+        assert len(prev_self_k_list) == L and len(prev_self_v_list) == L
+
+        assert encoder_out_x.dim() == 3, "encoder_out_x must be [S,B,C]"
+        x = prev_output_x  # [1,B,C]
+        enc = encoder_out_x
+
+        new_k_list: List[Tensor] = []
+        new_v_list: List[Tensor] = []
+
+        for li, layer in enumerate(self.layers):
+            assert isinstance(layer, PTQWrapper)
+            x, _, k_new, v_new = layer.wrapped.forward_external(  # type: ignore[attr-defined, operator]
+                x,
+                encoder_out=enc,
+                encoder_padding_mask=encoder_padding_mask,
+                prev_self_k=prev_self_k_list[li],
+                prev_self_v=prev_self_v_list[li],
+                self_attn_mask=self_attn_mask,
+                need_attn=need_attn and (li == L - 1),
+                need_head_weights=need_head_weights and (li == L - 1),
+            )
+            new_k_list.append(k_new)  # [B*H, Tnew, Dh]
+            new_v_list.append(v_new)  # [B*H, Tnew, Dh]
+
+        if self.layer_norm is not None:
+            x = self.layer_norm(x.transpose(0, 1)).transpose(0, 1)
+
+        return x, new_k_list, new_v_list  # [1,B,C], lists of [B*H, Tnew, Dh]
+
+    def _all_observers(self) -> Iterable:
+        """Yield all observers from wrapped decoder layers (if any)."""
+        for m in self.layers:
+            if isinstance(m, QuantModuleBase):
+                yield from m._all_observers()

tico/experimental/quantization/public_interface.py

@@ -13,25 +13,17 @@
 # limitations under the License.
 
 import copy
-from typing import Any, Dict, Optional, Type
+from typing import Any, Dict, Optional
 
 import torch
 
 from tico.experimental.quantization.algorithm.gptq.quantizer import GPTQQuantizer
 from tico.experimental.quantization.algorithm.pt2e.quantizer import PT2EQuantizer
-from tico.experimental.quantization.algorithm.smoothquant.quantizer import (
-    SmoothQuantQuantizer,
-)
 from tico.experimental.quantization.config.base import BaseConfig
 from tico.experimental.quantization.quantizer import BaseQuantizer
+from tico.experimental.quantization.quantizer_registry import get_quantizer
 
 
-config_to_quantizer: Dict[str, Type[BaseQuantizer]] = {
-    "pt2e": PT2EQuantizer,
-    "gptq": GPTQQuantizer,
-    "smooth_quant": SmoothQuantQuantizer,
-}
-
 QUANTIZER_ATTRIBUTE_NAME = "tico_quantizer"
 
 
@@ -61,14 +53,15 @@ def prepare(
     """
     if hasattr(model, QUANTIZER_ATTRIBUTE_NAME):
         raise RuntimeError("prepare() already has been called.")
-    if quant_config.name == "pt2e" and inplace:
+    quantizer = get_quantizer(quant_config)
+
+    if isinstance(quantizer, PT2EQuantizer) and inplace:
         raise RuntimeError(
             "In-place is not supported for PT2E quantization due to limitation in the underlying Torch APIs. Please set 'inplace=False' to proceed."
         )
 
     model = model if inplace else copy.deepcopy(model)
 
-    quantizer = config_to_quantizer[quant_config.name](quant_config)
     model = quantizer.prepare(model, args, kwargs)
     setattr(model, QUANTIZER_ATTRIBUTE_NAME, quantizer)
 

tico/experimental/quantization/quantizer_registry.py

@@ -0,0 +1,72 @@
+# 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 Dict, Optional, Type, TypeVar
+
+from tico.experimental.quantization.config.base import BaseConfig
+from tico.experimental.quantization.quantizer import BaseQuantizer
+
+TQ = TypeVar("TQ", bound=BaseQuantizer)
+
+# Mapping: Config type -> Quantizer type
+_REGISTRY: Dict[Type[BaseConfig], Type[BaseQuantizer]] = {}
+
+
+def register_quantizer(config_cls: Type[BaseConfig]):
+    """
+    Decorator to register a quantizer for a given config class.
+    Usage:
+        @register_quantizer(GPTQConfig)
+        class GPTQQuantizer(BaseQuantizer): ...
+    """
+
+    def wrapper(quantizer_cls: Type[TQ]) -> Type[TQ]:
+        _REGISTRY[config_cls] = quantizer_cls
+        return quantizer_cls
+
+    return wrapper
+
+
+def _lookup(cfg: BaseConfig) -> Optional[Type[BaseQuantizer]]:
+    """Return a quantizer class only if the exact config type is registered."""
+    return _REGISTRY.get(type(cfg))
+
+
+def get_quantizer(cfg: BaseConfig) -> BaseQuantizer:
+    """Factory to return a quantizer instance for the given config."""
+    qcls = _lookup(cfg)
+    if qcls is not None:
+        return qcls(cfg)
+
+    # Lazy import by naming convention
+    name = getattr(cfg, "name", None)
+    if name:
+        try:
+            importlib.import_module(
+                f"tico.experimental.quantization.algorithm.{name}.quantizer"
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to import quantizer module for config name='{name}': {e}"
+            )
+
+    qcls = _lookup(cfg)
+    if qcls is not None:
+        return qcls(cfg)
+
+    raise RuntimeError(
+        f"No quantizer registered for config type {type(cfg).__name__} "
+        f"(name='{getattr(cfg,'name',None)}')."
+    )

tico/passes/convert_matmul_to_linear.py

@@ -20,11 +20,13 @@ import torch
 from torch._export.utils import is_buffer, is_lifted_tensor_constant, is_param
 from torch.export import ExportedProgram
 
+from tico.serialize.circle_mapping import extract_shape
+
 from tico.utils import logging
 from tico.utils.graph import create_node
 from tico.utils.passes import PassBase, PassResult
 from tico.utils.trace_decorators import trace_graph_diff_on_pass
-from tico.utils.validate_args_kwargs import MatmulArgs
+from tico.utils.validate_args_kwargs import BmmArgs, MatmulArgs
 
 
 class Converter:  # type: ignore[empty-body]
@@ -57,14 +59,14 @@ class MatmulToLinearConverter(Converter):
                 torch.ops.aten.permute.default,
                 args=(rhs, [1, 0]),
             )
-            fc_node = create_node(
+            linear_node = create_node(
                 graph,
                 torch.ops.aten.linear.default,
                 args=(lhs, transpose_node),
             )
-            node.replace_all_uses_with(fc_node, propagate_meta=True)
+            node.replace_all_uses_with(linear_node, propagate_meta=True)
 
-        return fc_node
+        return linear_node
 
 
 class RhsConstMatmulToLinearConverter(MatmulToLinearConverter):
@@ -110,18 +112,125 @@ class LhsConstMatmulToLinearConverter(MatmulToLinearConverter):
                 return True
             elif is_buffer(exported_program, lhs):
                 return True
-            else:
-                return False
         return False
 
     def convert(self, exported_program, node) -> torch.fx.Node:
         return super().convert(exported_program, node)
 
 
+class SingleBatchLhsConstBmmToLinearConverter(Converter):
+    """
+    Convert `single-batched & lhs-const BatchMatMul` to `linear` operation.
+
+    [1] exchange lhs and rhs
+    [2] transpose rhs
+    [3] transpose output
+
+    **Before**
+
+    lhs[1,a,b](const)   rhs[1,b,c]
+    |                   |
+    |                   |
+    ---------bmm---------
+              |
+            output[1,a,c]
+
+
+    **After**
+
+    rhs[1,b,c]
+    |
+    tr                  lhs'[a,b](const-folded)
+    |[1,c,b]            |
+    |                   |
+    ---------fc--------
+             |[1,c,a]
+             tr
+             |
+            output[1,a,c]
+
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def match(self, exported_program, node) -> bool:
+        if not node.target == torch.ops.aten.bmm.default:
+            return False
+
+        bmm_args = BmmArgs(*node.args, **node.kwargs)
+        lhs = bmm_args.input
+        rhs = bmm_args.mat2
+
+        # [1] Single-batch
+        lhs_shape = extract_shape(lhs)
+        rhs_shape = extract_shape(rhs)
+
+        assert len(lhs_shape) == len(
+            rhs_shape
+        ), f"Bmm input's ranks must be the same but got {lhs_shape} and {rhs_shape}"
+
+        if not (lhs_shape[0] == rhs_shape[0] == 1):
+            return False
+
+        # [2] Lhs is constant
+        if not isinstance(lhs, torch.fx.Node):
+            return False
+        if not (
+            is_lifted_tensor_constant(exported_program, lhs)
+            or is_param(exported_program, lhs)
+            or is_buffer(exported_program, lhs)
+        ):
+            return False
+
+        return True
+
+    def convert(self, exported_program, node) -> torch.fx.Node:
+        graph_module = exported_program.graph_module
+        graph = graph_module.graph
+
+        bmm_args = BmmArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+
+        lhs = bmm_args.input  # const
+        rhs = bmm_args.mat2  # non-const
+        lhs_shape = extract_shape(lhs)
+        rhs_shape = extract_shape(rhs)
+        assert rhs_shape[0] == 1
+        assert lhs_shape[0] == 1
+
+        with graph.inserting_before(node):
+            rhs_tr = create_node(
+                graph,
+                torch.ops.aten.permute.default,
+                args=(rhs, [0, 2, 1]),
+            )
+            lhs_reshape = create_node(
+                graph,
+                torch.ops.aten.view.default,
+                args=(lhs, list(lhs_shape[1:])),
+            )
+
+            linear_node = create_node(
+                graph,
+                torch.ops.aten.linear.default,
+                args=(rhs_tr, lhs_reshape),
+            )
+
+            tr_linear_node = create_node(
+                graph,
+                torch.ops.aten.permute.default,
+                args=(linear_node, [0, 2, 1]),
+            )
+
+            node.replace_all_uses_with(tr_linear_node, propagate_meta=False)
+
+        return tr_linear_node
+
+
 @trace_graph_diff_on_pass
 class ConvertMatmulToLinear(PassBase):
     """
-    This pass converts matmul to linear selectively
+    This pass converts matmul(partially includes single-batch bmm) to linear selectively
 
     How to select between `matmul` and `linear`?
 
@@ -164,6 +273,7 @@ class ConvertMatmulToLinear(PassBase):
         self,
         enable_lhs_const: Optional[bool] = False,
         enable_rhs_const: Optional[bool] = True,
+        enable_single_batch_lhs_const_bmm: Optional[bool] = False,
     ):
         super().__init__()
         self.converters: List[Converter] = []
@@ -171,6 +281,8 @@ class ConvertMatmulToLinear(PassBase):
             self.converters.append(LhsConstMatmulToLinearConverter())
         if enable_rhs_const:
             self.converters.append(RhsConstMatmulToLinearConverter())
+        if enable_single_batch_lhs_const_bmm:
+            self.converters.append(SingleBatchLhsConstBmmToLinearConverter())
 
     def call(self, exported_program: ExportedProgram) -> PassResult:
         logger = logging.getLogger(__name__)

tico/serialize/operators/op_constant_pad_nd.py

@@ -28,6 +28,42 @@ from tico.utils.errors import InvalidArgumentError
 from tico.utils.validate_args_kwargs import ConstantPadNdArgs
 
 
+def convert_to_circle_padding(pad, input_shape_len):
+    MAX_RANK = 4
+
+    if not (1 <= input_shape_len <= MAX_RANK):
+        raise InvalidArgumentError(
+            f"Input rank must be between 1 and {MAX_RANK}, got {input_shape_len}"
+        )
+
+    if len(pad) % 2 != 0 or len(pad) < 2 or len(pad) > 8:
+        raise InvalidArgumentError(
+            f"Pad length must be an even number between 2 and 8, got {len(pad)}"
+        )
+
+    if len(pad) == 2:
+        padding = [[pad[0], pad[1]]]
+    elif len(pad) == 4:
+        padding = [[pad[2], pad[3]], [pad[0], pad[1]]]
+    elif len(pad) == 6:
+        padding = [[pad[4], pad[5]], [pad[2], pad[3]], [pad[0], pad[1]]]
+    elif len(pad) == 8:
+        padding = [
+            [pad[6], pad[7]],
+            [pad[4], pad[5]],
+            [pad[2], pad[3]],
+            [pad[0], pad[1]],
+        ]
+    else:
+        assert False, "Cannot reach here"
+
+    # Fill [0, 0] padding for the rest of dimension
+    while len(padding) < input_shape_len:
+        padding.insert(0, [0, 0])
+
+    return padding
+
+
 @register_node_visitor
 class ConstantPadNdVisitor(NodeVisitor):
     target: List[torch._ops.OpOverload] = [torch.ops.aten.constant_pad_nd.default]
@@ -45,19 +81,13 @@ class ConstantPadNdVisitor(NodeVisitor):
         val = args.value
 
         if val != 0:
-            raise InvalidArgumentError("Only support 0 value padding.")
+            raise InvalidArgumentError(f"Only support 0 value padding. pad:{pad}")
 
         input_shape_len = len(extract_shape(input_))
-        padding_size = [[pad[2], pad[3]], [pad[0], pad[1]]]
-        if input_shape_len == 3:
-            padding_size = [[0, 0]] + padding_size
-        elif input_shape_len == 4:
-            padding_size = [[0, 0], [0, 0]] + padding_size
-        else:
-            raise InvalidArgumentError("Only support 3D/4D inputs.")
-
-        paddings = torch.tensor(padding_size, dtype=torch.int32)
-        inputs = [input_, paddings]
+
+        padding = convert_to_circle_padding(pad, input_shape_len)
+
+        inputs = [input_, torch.tensor(padding, dtype=torch.int32)]
         outputs = [node]
 
         op_index = get_op_index(

tico/utils/convert.py

@@ -253,6 +253,9 @@ def convert_exported_module_to_circle(
             ConvertMatmulToLinear(
                 enable_lhs_const=config.get("convert_lhs_const_mm_to_fc"),
                 enable_rhs_const=config.get("convert_rhs_const_mm_to_fc"),
+                enable_single_batch_lhs_const_bmm=config.get(
+                    "convert_single_batch_lhs_const_bmm_to_fc"
+                ),
             ),
             LowerToResizeNearestNeighbor(),
             LegalizePreDefinedLayoutOperators(),

{tico-0.1.0.dev250921.dist-info → tico-0.1.0.dev250923.dist-info}/METADATA

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

{tico-0.1.0.dev250921.dist-info → tico-0.1.0.dev250923.dist-info}/RECORD

@@ -1,21 +1,22 @@
-tico/__init__.py,sha256=SJrnDNsVJlIf-r1ZVzi2Kj_xI68YVwAjm83FWgbiWLE,1883
+tico/__init__.py,sha256=SQIp1AUtHO6svZTLOBdHKzr7ss9Z3l9yh8cyySsGZOo,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
 tico/config/factory.py,sha256=il0zqB6Lm5NX2LnG-TUhmiP9vVeZ_3TucJMorVZIodY,1324
-tico/config/v1.py,sha256=AVgOck-HxR1R1FZPVjtN5J82hPLJvUxwzbnyWXIQZWE,1237
+tico/config/v1.py,sha256=lEyKemeKGrJ0bA5w-LPkMWVlnAiJRDm9mM48TJle-e4,1296
 tico/experimental/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/experimental/quantization/__init__.py,sha256=IaJPZegVJp0P3luutBo907Kp5sOJensE1Mm-XBG_jBs,122
-tico/experimental/quantization/public_interface.py,sha256=y-iwaeuedBvHwTh5hflQg4u2ZCdqf46IlTl9ntHq8pU,4425
+tico/experimental/quantization/public_interface.py,sha256=TGo3bTapwLA8KpsoEwBhuzI0LQUO6y3-sUM1VZvkLo8,4220
 tico/experimental/quantization/quantizer.py,sha256=pDTQGzR-BcQJeGZ7O4cXRQdCme4q_POpxHetwnv0bYg,2370
+tico/experimental/quantization/quantizer_registry.py,sha256=7wm2JcuPRribu7c8dCSZeYVcVqWQO1S-tHoinDDt11s,2345
 tico/experimental/quantization/algorithm/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/experimental/quantization/algorithm/gptq/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/experimental/quantization/algorithm/gptq/gptq.py,sha256=Qn9b_2ki7B64DcVEY25NMkww3PdZ5EqYQQXfYhNDQ6I,5555
 tico/experimental/quantization/algorithm/gptq/quant.py,sha256=Rl4wAOCmlE0U09BtNCDbccaSNohRHCNLwFi3zCqZfNo,5127
-tico/experimental/quantization/algorithm/gptq/quantizer.py,sha256=ZKeQQWm6eMUyRgntQxVR-QVjxJOc2pW4Dc_mrEPZA64,11686
+tico/experimental/quantization/algorithm/gptq/quantizer.py,sha256=CDAo7M5Xi8Oa2EjzNtCb9i6IWwpkxWzfP2fe8_VTM8M,11799
 tico/experimental/quantization/algorithm/gptq/utils.py,sha256=leGKayf-xbSjVwwAGTA5RsxUKrhDiklOQdlsLifjdrs,1811
 tico/experimental/quantization/algorithm/pt2e/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
-tico/experimental/quantization/algorithm/pt2e/quantizer.py,sha256=mdTvsG87bo8fu0GaWqSM8iBCs-4f4EfUlVtk-Ko6M34,2546
+tico/experimental/quantization/algorithm/pt2e/quantizer.py,sha256=PXfCQWCDYjMHTmEA6txHKh5miwruEZwDGsgjPYFBB9o,2725
 tico/experimental/quantization/algorithm/pt2e/utils.py,sha256=URjTGgsnDdhUC2Nr0-YJ9GWbVOKmjElfLr83Y8eCz-M,4806
 tico/experimental/quantization/algorithm/pt2e/annotation/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/experimental/quantization/algorithm/pt2e/annotation/annotator.py,sha256=lFfblxglPxcN2IcrjAVYq7GOECIAQ4rr7M4euPp3yWc,7551
@@ -37,13 +38,13 @@ tico/experimental/quantization/algorithm/pt2e/transformation/__init__.py,sha256=
 tico/experimental/quantization/algorithm/pt2e/transformation/convert_scalars_to_attrs.py,sha256=Idtoya2RcGKlgUJgC9WqNz0jH3gf6ViuPmsD9ySHbls,2253
 tico/experimental/quantization/algorithm/smoothquant/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/experimental/quantization/algorithm/smoothquant/observer.py,sha256=OWBKQ3ox6PqeqgevxOjpXvb7uApoqE4YbUBelGhVSN8,3435
-tico/experimental/quantization/algorithm/smoothquant/quantizer.py,sha256=14-QrKAW-Rw6pIbbNaD5eORcH2fqi40-TNFGaWVakIg,3649
+tico/experimental/quantization/algorithm/smoothquant/quantizer.py,sha256=VHc-_23VZWKCKZlcZvG5ESRKALgH4zU_Q9Tr-EEW4mk,3769
 tico/experimental/quantization/algorithm/smoothquant/smooth_quant.py,sha256=fxCy4m-BsSjraciSVPFlPhgsOT46RjrOgczQGb7B9TA,11561
 tico/experimental/quantization/config/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/experimental/quantization/config/base.py,sha256=xg_HCDSuMgYvMd6ENZe4Sm2SYJgMaCBj4cmqaz_lhAs,816
 tico/experimental/quantization/config/gptq.py,sha256=IUIEz5bLhsTXqoBCE1rfPec99zsRjwgpDbPW5YJqOPg,973
 tico/experimental/quantization/config/pt2e.py,sha256=9HCrraTGGZeKEN9puKV-ODi7ncV2Wjc3oe_JCO1D_Rs,850
-tico/experimental/quantization/config/smoothquant.py,sha256=fcyhu3YlOTM7fDW9lGTXh-uJOUD6CeykZj7AMCNVbak,1415
+tico/experimental/quantization/config/smoothquant.py,sha256=b92dz4-MiBbkaLzXb47bVoO29d2P416woFQUZ1wpO_s,1414
 tico/experimental/quantization/evaluation/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/experimental/quantization/evaluation/backend.py,sha256=CZL9rZOA0t8cH7PHp6u9l7dGqWNvTj9bKOvwo0PVul0,692
 tico/experimental/quantization/evaluation/evaluate.py,sha256=kfa_GvFaX6DoSTAmuCImMJqF2jgqtnor5UpC7wVmGPI,7877
@@ -90,6 +91,7 @@ tico/experimental/quantization/ptq/wrappers/quant_elementwise.py,sha256=LhEoobfv
 tico/experimental/quantization/ptq/wrappers/quant_module_base.py,sha256=vkcDos_knGSS29rIZuEIWkAJLHrENbGz8nCH2-iara8,5969
 tico/experimental/quantization/ptq/wrappers/registry.py,sha256=OVO5nev6J8Br9zsIX-Ut7ZgWzA9f_jk0Np9bGioXgQM,5171
 tico/experimental/quantization/ptq/wrappers/fairseq/__init__.py,sha256=Mc8FLd9DusyB_IT1vk1OYrRkngOYnYd05IvtA9ORVQc,160
+tico/experimental/quantization/ptq/wrappers/fairseq/quant_decoder.py,sha256=CILYvxPhW7xLkroWW_hunQBGAYGexLqnPnO5xmMnK-E,17877
 tico/experimental/quantization/ptq/wrappers/fairseq/quant_decoder_layer.py,sha256=JT79shxOhDtRFgm8jrrN6HKvyVotiytLjMjAxX-Cztg,20416
 tico/experimental/quantization/ptq/wrappers/fairseq/quant_encoder.py,sha256=r9DPUAbL2KRJ8zpMJ39Y9n6Oe79nte-mFcdjG2qEP-w,13809
 tico/experimental/quantization/ptq/wrappers/fairseq/quant_encoder_layer.py,sha256=aGr80Ku75j2H-UZ0elEa0mOQEyaAs2YJ4WJCN0lonn0,6412
@@ -112,7 +114,7 @@ tico/passes/cast_mixed_type_args.py,sha256=Wd3sCDKJZwdb8GiMWKljm8X5CLFRd8eCz-dmW
 tico/passes/const_prop_pass.py,sha256=hDxGgJNiRjsgOArdaoeAOcOOA-nKBvA1W1zcMZQA5yg,11531
 tico/passes/convert_conv1d_to_conv2d.py,sha256=ktS3h158y9rg1sQiW8BZZbflV_dk_UdjBPQnuiOKyzg,5303
 tico/passes/convert_layout_op_to_reshape.py,sha256=sCAFjkmVtiKjvDQSAgnjNBHl3_hWXJZElGDXQiTH-7s,2963
-tico/passes/convert_matmul_to_linear.py,sha256=Y_Me8YqrNumfMrB08WT4wwAoKIfKNak5y8Y10ekWe5s,6611
+tico/passes/convert_matmul_to_linear.py,sha256=WATtsHk_GzsU0HYovc3UMyEj8ApF2qLbInAsNlQj0nE,9759
 tico/passes/convert_repeat_to_expand_copy.py,sha256=JbtFTmWyfJS2SSd_higP1IEhQeh7wHdN5dmTbbiFVCs,3237
 tico/passes/convert_to_relu6.py,sha256=9B6OLyF72tMvD-ugV7aBx6l1szwERufNBUaX34pkZ4c,6445
 tico/passes/decompose_addmm.py,sha256=KjnpZjSuA0uvNmKaTN_EMwobcOi3CAB81buORzTDxro,3979
@@ -162,7 +164,7 @@ tico/serialize/operators/op_bmm.py,sha256=AELjHC9ISFPIzEEl5Kr1s4GSNLZElwZmVZJWkE
 tico/serialize/operators/op_cat.py,sha256=XDYOh0XAyrM0TlxVm6Sa0OFFGrKk7aSDcGXC-hYX4gs,2204
 tico/serialize/operators/op_clamp.py,sha256=RRQVrzayDfN3PioCVJqa_yYOtcYwb5HHwkMe4E_YPmE,4408
 tico/serialize/operators/op_clone.py,sha256=vzDYJ8TS3tc2BAyd_z8nt5VqT1inpymSseMEhd9dva0,2394
-tico/serialize/operators/op_constant_pad_nd.py,sha256=OpP4AP-d1IFcWZolNa-o9ZxzXJQkMdG9WQ66soX3s-E,2675
+tico/serialize/operators/op_constant_pad_nd.py,sha256=nGWqYWNbj2E9ChQuoHsN-d8AO7UyVexnPil7qTqWZp8,3444
 tico/serialize/operators/op_conv2d.py,sha256=1_vouWXaF51gDLYg8z5Zlup0Tecq_ggAzvguiHzFffw,6828
 tico/serialize/operators/op_copy.py,sha256=boXHfl0bcvdBVl0tpzPMA_KBonh80vVqv61N3H5-PRU,6941
 tico/serialize/operators/op_cos.py,sha256=N12bNyuTQIxRnD0eHRPdFVzRQPMy1NFM4iM8oQ4lYzw,2034
@@ -234,7 +236,7 @@ tico/serialize/operators/utils.py,sha256=lXGpEJW1h8U_-gfc6EWjvvSiq3yJ9P-v1v3EMRT
 tico/serialize/operators/adapters/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
 tico/serialize/operators/adapters/llama_rmsnorm.py,sha256=6t3dhfNpR03eIjsmhymF2JKd6lCf7PvInqMf77c_BOE,1139
 tico/utils/__init__.py,sha256=IO6FP_xYbGy0dW0HL26GXD3ouxARaxCK7bz9dn4blPQ,26
-tico/utils/convert.py,sha256=bgk-a_gdRrrcDFFQHS_ElPdzORmfAZAgNendfzEpHOk,13501
+tico/utils/convert.py,sha256=XbogVXO-QS0UTFNvEDyADvhCp87kTUpGAUalN8I8eRQ,13645
 tico/utils/define.py,sha256=Ypgp7YffM4pgPl4Zh6TmogSn1OxGBMRw_e09qYGflZk,1467
 tico/utils/diff_graph.py,sha256=_eDGGPDPYQD4b--MXX0DLoVgSt_wLfNPt47UlolLLR4,5272
 tico/utils/dtype.py,sha256=L5Qb7qgbt0eQ5frUTvHYrRtTJb1dg4-JNEopcxCNg1U,1389
@@ -258,9 +260,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.dev250921.dist-info/LICENSE,sha256=kp4JLII7bzRhPb0CPD5XTDZMh22BQ7h3k3B7t8TiSbw,12644
-tico-0.1.0.dev250921.dist-info/METADATA,sha256=PKokhTsAtNxesEROg_vhfa6pIcl8WyFzlx-5H7RBcGk,8450
-tico-0.1.0.dev250921.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-tico-0.1.0.dev250921.dist-info/entry_points.txt,sha256=kBKYSS_IYrSXmUYevmmepqIVPScq5vF8ulQRu3I_Zf0,59
-tico-0.1.0.dev250921.dist-info/top_level.txt,sha256=oqs7UPoNSKZEwqsX8B-KAWdQwfAa7i60pbxW_Jk7P3w,5
-tico-0.1.0.dev250921.dist-info/RECORD,,
+tico-0.1.0.dev250923.dist-info/LICENSE,sha256=kp4JLII7bzRhPb0CPD5XTDZMh22BQ7h3k3B7t8TiSbw,12644
+tico-0.1.0.dev250923.dist-info/METADATA,sha256=YFowPhlSZB_-sCJe9E7tmXhQdMo0EWQ-H9fPL57i6SQ,8450
+tico-0.1.0.dev250923.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+tico-0.1.0.dev250923.dist-info/entry_points.txt,sha256=kBKYSS_IYrSXmUYevmmepqIVPScq5vF8ulQRu3I_Zf0,59
+tico-0.1.0.dev250923.dist-info/top_level.txt,sha256=oqs7UPoNSKZEwqsX8B-KAWdQwfAa7i60pbxW_Jk7P3w,5
+tico-0.1.0.dev250923.dist-info/RECORD,,