tico 0.1.0.dev250904__py3-none-any.whl → 0.1.0.dev251109__py3-none-any.whl

tico/{experimental/quantization/ptq → quantization/wrapq}/wrappers/nn/quant_silu.py

@@ -17,18 +17,17 @@ from typing import Optional
 import torch
 import torch.nn as nn
 
-from tico.experimental.quantization.ptq.quant_config import QuantConfig
-from tico.experimental.quantization.ptq.wrappers.quant_module_base import (
-    QuantModuleBase,
-)
-from tico.experimental.quantization.ptq.wrappers.registry import register
+from tico.quantization.config.ptq import PTQConfig
+from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
+from tico.quantization.wrapq.wrappers.registry import try_register
 
 
-@register(nn.SiLU)
+@try_register("torch.nn.SiLU", "transformers.activations.SiLUActivation")
 class QuantSiLU(QuantModuleBase):
     """
-    QuantSiLU — drop-in replacement for nn.SiLU that quantizes
-    both intermediate tensors:
+    QuantSiLU — drop-in quantized implementation of the SiLU operation.
+
+    This module quantizes both intermediate tensors:
         • s  = sigmoid(x)   (logistic)
         • y  = x * s        (mul)
     """
@@ -37,7 +36,7 @@ class QuantSiLU(QuantModuleBase):
         self,
         fp: nn.SiLU,
         *,
-        qcfg: Optional[QuantConfig] = None,
+        qcfg: Optional[PTQConfig] = None,
         fp_name: Optional[str] = None
     ):
         super().__init__(qcfg, fp_name=fp_name)

tico/{experimental/quantization/ptq → quantization/wrapq}/wrappers/ptq_wrapper.py

@@ -16,11 +16,9 @@ from typing import Optional
 
 import torch
 
-from tico.experimental.quantization.ptq.quant_config import QuantConfig
-from tico.experimental.quantization.ptq.wrappers.quant_module_base import (
-    QuantModuleBase,
-)
-from tico.experimental.quantization.ptq.wrappers.registry import lookup
+from tico.quantization.config.ptq import PTQConfig
+from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
+from tico.quantization.wrapq.wrappers.registry import lookup
 
 
 class PTQWrapper(QuantModuleBase):
@@ -34,7 +32,7 @@ class PTQWrapper(QuantModuleBase):
     def __init__(
         self,
         module: torch.nn.Module,
-        qcfg: Optional[QuantConfig] = None,
+        qcfg: Optional[PTQConfig] = None,
         *,
         fp_name: Optional[str] = None,
     ):

tico/{experimental/quantization/ptq → quantization/wrapq}/wrappers/quant_elementwise.py

@@ -12,16 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable, Optional
+from typing import Any, Optional
 
 import torch
 import torch.nn as nn
 
-from tico.experimental.quantization.ptq.quant_config import QuantConfig
-from tico.experimental.quantization.ptq.wrappers.quant_module_base import (
-    QuantModuleBase,
-)
-from tico.experimental.quantization.ptq.wrappers.registry import register
+from tico.quantization.config.ptq import PTQConfig
+from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
+from tico.quantization.wrapq.wrappers.registry import register
 
 
 class QuantElementwise(QuantModuleBase):
@@ -33,7 +31,7 @@ class QuantElementwise(QuantModuleBase):
     """
 
     # subclass must set this
-    FUNC: Callable[[torch.Tensor], torch.Tensor] | None = None
+    FUNC: Any = None
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
@@ -48,7 +46,7 @@ class QuantElementwise(QuantModuleBase):
         self,
         fp_module: nn.Module,
         *,
-        qcfg: Optional[QuantConfig] = None,
+        qcfg: Optional[PTQConfig] = None,
         fp_name: Optional[str] = None,
     ):
         super().__init__(qcfg, fp_name=fp_name)
@@ -70,7 +68,7 @@ class QuantElementwise(QuantModuleBase):
 
 
 """
-Why `FUNC` is a `staticmethod`
+Q1) Why `FUNC` is a `staticmethod`
 
 - Prevents automatic binding: calling `self.FUNC(x)` will not inject `self`,
   so the callable keeps the expected signature `Tensor -> Tensor`
@@ -87,27 +85,67 @@ Why `FUNC` is a `staticmethod`
   than an `nn.Module` instance that would appear in the module tree.
 
 - Small perf/alloc win: no bound-method objects are created on each call.
+
+Q2) Why we define small Python wrappers (_relu, _tanh, etc.)
+
+- torch.relu / torch.tanh / torch.sigmoid are CPython built-ins.
+  Their type is `builtin_function_or_method`, not a Python `FunctionType`.
+  This causes `torch.export` (and FX tracing) to fail with:
+    "expected FunctionType, found builtin_function_or_method".
+
+- By defining a thin Python wrapper (e.g., `def _tanh(x): return torch.tanh(x)`),
+  we convert it into a normal Python function object (`FunctionType`),
+  which satisfies export/tracing requirements.
+
+- Functionally, this adds zero overhead and preserves semantics,
+  but makes the callable introspectable (has __code__, __name__, etc.)
+  and compatible with TorchDynamo / FX graph capture.
+
+- It also keeps FUNC pure and stateless, ensuring the elementwise op
+  is represented as `call_function(_tanh)` in the traced graph
+  rather than a bound `call_method` or module attribute access.
 """
 
-# Sigmoid
+
+def _relu(x: torch.Tensor) -> torch.Tensor:
+    return torch.relu(x)
+
+
+def _tanh(x: torch.Tensor) -> torch.Tensor:
+    return torch.tanh(x)
+
+
+def _sigmoid(x: torch.Tensor) -> torch.Tensor:
+    return torch.sigmoid(x)
+
+
+def _gelu(x: torch.Tensor) -> torch.Tensor:
+    return torch.nn.functional.gelu(x)
+
+
 @register(nn.Sigmoid)
 class QuantSigmoid(QuantElementwise):
-    FUNC = staticmethod(torch.sigmoid)
+    @staticmethod
+    def FUNC(x: torch.Tensor) -> torch.Tensor:
+        return _sigmoid(x)
 
 
-# Tanh
 @register(nn.Tanh)
 class QuantTanh(QuantElementwise):
-    FUNC = staticmethod(torch.tanh)
+    @staticmethod
+    def FUNC(x: torch.Tensor) -> torch.Tensor:
+        return _tanh(x)
 
 
-# ReLU
 @register(nn.ReLU)
 class QuantReLU(QuantElementwise):
-    FUNC = staticmethod(torch.relu)
+    @staticmethod
+    def FUNC(x: torch.Tensor) -> torch.Tensor:
+        return _relu(x)
 
 
-# GELU (approximate)
 @register(nn.GELU)
 class QuantGELU(QuantElementwise):
-    FUNC = staticmethod(torch.nn.functional.gelu)
+    @staticmethod
+    def FUNC(x: torch.Tensor) -> torch.Tensor:
+        return _gelu(x)

tico/{experimental/quantization/ptq → quantization/wrapq}/wrappers/quant_module_base.py

@@ -17,9 +17,10 @@ from typing import Iterable, Optional, Tuple
 
 import torch.nn as nn
 
-from tico.experimental.quantization.ptq.mode import Mode
-from tico.experimental.quantization.ptq.observers.base import ObserverBase
-from tico.experimental.quantization.ptq.quant_config import QuantConfig
+from tico.quantization.config.ptq import PTQConfig
+
+from tico.quantization.wrapq.mode import Mode
+from tico.quantization.wrapq.observers.base import ObserverBase
 
 
 class QuantModuleBase(nn.Module, ABC):
@@ -29,7 +30,7 @@ class QuantModuleBase(nn.Module, ABC):
     Responsibilities
     ----------------
     • Own *one* Mode enum (`NO_QUANT / CALIB / QUANT`)
-    • Own a QuantConfig describing default / per-observer dtypes
+    • Own a PTQConfig describing default / per-observer dtypes
     • Expose a canonical lifecycle:
           enable_calibration()
           freeze_qparams()
@@ -38,10 +39,10 @@ class QuantModuleBase(nn.Module, ABC):
     """
 
     def __init__(
-        self, qcfg: Optional[QuantConfig] = None, *, fp_name: Optional[str] = None
+        self, qcfg: Optional[PTQConfig] = None, *, fp_name: Optional[str] = None
     ) -> None:
         super().__init__()
-        self.qcfg = qcfg or QuantConfig()
+        self.qcfg = qcfg or PTQConfig()
         self._mode: Mode = Mode.NO_QUANT  # default state
         self.fp_name = fp_name
 
@@ -118,9 +119,9 @@ class QuantModuleBase(nn.Module, ABC):
         Instantiate an observer named *name*.
 
         Precedence (3-tier) for keys:
-           • observer:  user > wrapper-default > QuantConfig.default_observer
-           • dtype:     user > wrapper-default > QuantConfig.default_dtype
-           • qscheme:   user > wrapper-default > QuantConfig.default_qscheme
+           • observer:  user > wrapper-default > PTQConfig.default_observer
+           • dtype:     user > wrapper-default > PTQConfig.default_dtype
+           • qscheme:   user > wrapper-default > PTQConfig.default_qscheme
 
         Other kwargs (e.g., qscheme, channel_axis, etc.) remain:
            user override > wrapper-default

tico/{experimental/quantization/ptq → quantization/wrapq}/wrappers/registry.py

@@ -17,20 +17,27 @@ from typing import Callable, Dict, Type
 
 import torch.nn as nn
 
-from tico.experimental.quantization.ptq.wrappers.quant_module_base import (
-    QuantModuleBase,
-)
+from tico.quantization.wrapq.wrappers.quant_module_base import QuantModuleBase
 
 _WRAPPERS: Dict[Type[nn.Module], Type[QuantModuleBase]] = {}
 _IMPORT_ONCE = False
 _CORE_MODULES = (
-    "tico.experimental.quantization.ptq.wrappers.quant_elementwise",
-    "tico.experimental.quantization.ptq.wrappers.nn.quant_layernorm",
-    "tico.experimental.quantization.ptq.wrappers.nn.quant_linear",
-    "tico.experimental.quantization.ptq.wrappers.nn.quant_silu",
-    "tico.experimental.quantization.ptq.wrappers.llama.quant_attn",
-    "tico.experimental.quantization.ptq.wrappers.llama.quant_decoder_layer",
-    "tico.experimental.quantization.ptq.wrappers.llama.quant_mlp",
+    "tico.quantization.wrapq.wrappers.quant_elementwise",
+    ## nn ##
+    "tico.quantization.wrapq.wrappers.nn.quant_layernorm",
+    "tico.quantization.wrapq.wrappers.nn.quant_linear",
+    # This includes not only `nn.SiLU` but also `SiLUActivation` from transformers
+    # as they are same operation.
+    "tico.quantization.wrapq.wrappers.nn.quant_silu",
+    ## llama ##
+    "tico.quantization.wrapq.wrappers.llama.quant_attn",
+    "tico.quantization.wrapq.wrappers.llama.quant_decoder_layer",
+    "tico.quantization.wrapq.wrappers.llama.quant_mlp",
+    ## fairseq ##
+    "tico.quantization.wrapq.wrappers.fairseq.quant_decoder_layer",
+    "tico.quantization.wrapq.wrappers.fairseq.quant_encoder",
+    "tico.quantization.wrapq.wrappers.fairseq.quant_encoder_layer",
+    "tico.quantization.wrapq.wrappers.fairseq.quant_mha",
     # add future core wrappers here
 )
 

tico/serialize/circle_serializer.py

@@ -20,6 +20,7 @@ import torch
 from circle_schema import circle
 from torch.export.exported_program import ConstantArgument, ExportedProgram, InputKind
 
+from tico.config import CompileConfigBase, get_default_config
 from tico.serialize.circle_mapping import to_circle_dtype, to_circle_shape
 from tico.serialize.operators import *
 from tico.serialize.circle_graph import CircleModel, CircleSubgraph
@@ -47,7 +48,9 @@ def _initialize_model() -> tuple[CircleModel, CircleSubgraph]:
     return model, graph
 
 
-def build_circle(ep: ExportedProgram) -> bytes:
+def build_circle(
+    ep: ExportedProgram, config: CompileConfigBase = get_default_config()
+) -> bytes:
     """Convert ExportedProgram to Circle format.
 
     Args:
@@ -68,9 +71,13 @@ def build_circle(ep: ExportedProgram) -> bytes:
     for in_spec in ep.graph_signature.input_specs:
         if in_spec.kind != InputKind.USER_INPUT:
             continue
-        # NoneType ConstantArgument is ignored.
-        if isinstance(in_spec.arg, ConstantArgument) and in_spec.arg.value == None:
-            continue
+        if isinstance(in_spec.arg, ConstantArgument):
+            # ConstantArgument is ignored when option is given
+            if config.get("remove_constant_input"):
+                continue
+            # NoneType ConstantArgument is ignored.
+            if in_spec.arg.value == None:
+                continue
         arg_name = in_spec.arg.name
         graph.add_input(arg_name)
         logger.debug(f"Registered input: {arg_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/serialize/operators/op_le.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.validate_args_kwargs import LeArgs
+
+
+@register_node_visitor
+class LeVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.le.Scalar,
+        torch.ops.aten.le.Tensor,
+    ]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(self, node: torch.fx.Node) -> circle.Operator.OperatorT:
+        args = LeArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        other = args.other
+
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.LESS_EQUAL, self._op_codes
+        )
+
+        inputs = [input, other]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        return operator

tico/serialize/operators/op_mm.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 import torch
 from circle_schema import circle
 
-from tico.serialize.circle_graph import CircleSubgraph, is_const
+from tico.serialize.circle_graph import CircleSubgraph
 from tico.serialize.operators.hashable_opcode import OpCode
 from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
 from tico.serialize.operators.utils import create_builtin_operator, get_op_index
@@ -28,9 +28,9 @@ from tico.utils.validate_args_kwargs import MatmulArgs
 
 
 @register_node_visitor
-class MatmulDefaultVisitor(NodeVisitor):
+class MatmulVisitor(NodeVisitor):
     """
-    Convert matmul to equavalent BatchMatMul or FullyConnected with Transpose.
+    Convert matmul to Circle BatchMatMul
     """
 
     target: List[torch._ops.OpOverload] = [torch.ops.aten.mm.default]
@@ -38,131 +38,7 @@ class MatmulDefaultVisitor(NodeVisitor):
     def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
         super().__init__(op_codes, graph)
 
-    # NOTE: Matmul is equivalent to Batch MatMul (batch=1)
-    def define_bmm_node(self, inputs, outputs) -> circle.Operator.OperatorT:
-        def set_bmm_option(operator):
-            operator.builtinOptionsType = (
-                circle.BuiltinOptions.BuiltinOptions.BatchMatMulOptions
-            )
-            option = circle.BatchMatMulOptions.BatchMatMulOptionsT()
-            option.adjointLhs, option.adjointRhs = False, False
-            option.asymmetricQuantizeInputs = False
-            operator.builtinOptions = option
-
-        op_index = get_op_index(
-            circle.BuiltinOperator.BuiltinOperator.BATCH_MATMUL, self._op_codes
-        )
-        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
-        set_bmm_option(operator)
-
-        return operator
-
-    def define_transpose_node(self, inputs, outputs) -> circle.Operator.OperatorT:
-        def set_transpose_option(operator):
-            operator.builtinOptionsType = (
-                circle.BuiltinOptions.BuiltinOptions.TransposeOptions
-            )
-            option = circle.TransposeOptions.TransposeOptionsT()
-            operator.builtinOptions = option
-
-        transpose_op_index = get_op_index(
-            circle.BuiltinOperator.BuiltinOperator.TRANSPOSE, self._op_codes
-        )
-        operator = create_builtin_operator(
-            self.graph, transpose_op_index, inputs, outputs
-        )
-        set_transpose_option(operator)
-        return operator
-
-    def define_fc_node(self, inputs, outputs) -> circle.Operator.OperatorT:
-        def set_fc_option(operator):
-            operator.builtinOptionsType = (
-                circle.BuiltinOptions.BuiltinOptions.FullyConnectedOptions
-            )
-            option = circle.FullyConnectedOptions.FullyConnectedOptionsT()
-
-            option.fusedActivationFunction = (
-                circle.ActivationFunctionType.ActivationFunctionType.NONE
-            )
-            option.weightsFormat = (
-                circle.FullyConnectedOptionsWeightsFormat.FullyConnectedOptionsWeightsFormat.DEFAULT
-            )
-            option.keepNumDims = False
-            option.asymmetricQuantizeInputs = False
-            option.quantizedBiasType = circle.TensorType.TensorType.FLOAT32
-
-            operator.builtinOptions = option
-
-        fc_op_index = get_op_index(
-            circle.BuiltinOperator.BuiltinOperator.FULLY_CONNECTED, self._op_codes
-        )
-        operator = create_builtin_operator(self.graph, fc_op_index, inputs, outputs)
-        set_fc_option(operator)
-        return operator
-
-    """
-    Define FullyConnnected with Tranpose operator.
-    Note that those sets of operators are equivalent.
-    (1) Matmul
-    matmul( lhs[H, K], rhs[K, W'] ) -> output(H, W')
-    
-    (2) Transpose + FullyConneccted
-    transpose( rhs[K, W'] ) -> trs_output[W', K]
-    fullyconnected( lhs[H, K], trs_output[W', K] ) -> output(H, W')
-    """
-
-    def define_fc_with_transpose(
-        self, node, inputs, outputs
-    ) -> circle.Operator.OperatorT:
-        lhs, rhs = inputs
-
-        # get transpose shape
-        rhs_tid: int = self.graph.get_tid_registered(rhs)
-        rhs_tensor: circle.Tensor.TensorT = self.graph.tensors[rhs_tid]
-        rhs_name: str = rhs.name
-        rhs_type: int = rhs_tensor.type
-        rhs_shape: List[int] = rhs_tensor.shape
-        assert len(rhs_shape) == 2, len(rhs_shape)
-        rhs_shape_transpose = [rhs_shape[1], rhs_shape[0]]
-
-        # create transpose output tensor
-        trs_output = self.graph.add_tensor_from_scratch(
-            prefix=f"{rhs_name}_transposed_output",
-            shape=rhs_shape_transpose,
-            shape_signature=None,
-            dtype=rhs_type,
-            source_node=node,
-        )
-        trs_perm = self.graph.add_const_tensor(data=[1, 0], source_node=node)
-        trs_operator = self.define_transpose_node([rhs, trs_perm], [trs_output])
-        self.graph.add_operator(trs_operator)
-
-        # define fc node
-        fc_input = lhs
-        fc_weight = trs_output
-        fc_shape = [fc_weight.shape[0]]
-        fc_bias = self.graph.add_const_tensor(
-            data=[0.0] * fc_shape[0], source_node=node
-        )
-
-        operator = self.define_fc_node([fc_input, fc_weight, fc_bias], outputs)
-
-        return operator
-
-    def define_node(
-        self, node: torch.fx.Node, prior_latency=True
-    ) -> circle.Operator.OperatorT:
-        """
-        NOTE: Possibility of accuracy-latency trade-off
-        From ONE compiler's perspective:
-        - BMM uses per-tensor quantization for both rhs and lhs.
-        - FC uses per-channel quantization for weight and per-tensor for input.
-        Thus, FC is better in terms of accuracy.
-        FC necessarily involves an additional transpose operation to be identical with mm.
-        If transposed operand is const, it can be optimized by constant folding.
-        Thus, convert FC only if tranpose can be folded.
-        TODO set prior_latency outside
-        """
+    def define_node(self, node: torch.fx.Node) -> circle.Operator.OperatorT:
         args = MatmulArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
         input = args.input
         other = args.other
@@ -170,9 +46,16 @@ class MatmulDefaultVisitor(NodeVisitor):
         inputs = [input, other]
         outputs = [node]
 
-        if not is_const(other) and prior_latency:
-            operator = self.define_bmm_node(inputs, outputs)
-        else:
-            operator = self.define_fc_with_transpose(node, inputs, outputs)
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.BATCH_MATMUL, self._op_codes
+        )
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+        operator.builtinOptionsType = (
+            circle.BuiltinOptions.BuiltinOptions.BatchMatMulOptions
+        )
+        option = circle.BatchMatMulOptions.BatchMatMulOptionsT()
+        option.adjointLhs, option.adjointRhs = False, False
+        option.asymmetricQuantizeInputs = False
+        operator.builtinOptions = option
 
         return operator

tico/utils/convert.py

@@ -20,26 +20,14 @@ import torch
 from torch.export import export, ExportedProgram
 
 from tico.config import CompileConfigBase, get_default_config
-from tico.experimental.quantization.passes.fold_quant_ops import FoldQuantOps
-from tico.experimental.quantization.passes.insert_quantize_on_dtype_mismatch import (
-    InsertQuantizeOnDtypeMismatch,
-)
-from tico.experimental.quantization.passes.propagate_qparam_backward import (
-    PropagateQParamBackward,
-)
-from tico.experimental.quantization.passes.propagate_qparam_forward import (
-    PropagateQParamForward,
-)
-from tico.experimental.quantization.passes.quantize_bias import QuantizeBias
-from tico.experimental.quantization.passes.remove_weight_dequant_op import (
-    RemoveWeightDequantOp,
-)
 from tico.passes.cast_aten_where_arg_type import CastATenWhereArgType
 from tico.passes.cast_clamp_mixed_type_args import CastClampMixedTypeArgs
 from tico.passes.cast_mixed_type_args import CastMixedTypeArgs
 from tico.passes.const_prop_pass import ConstPropPass
 from tico.passes.convert_conv1d_to_conv2d import ConvertConv1dToConv2d
+from tico.passes.convert_expand_to_slice_cat import ConvertExpandToSliceCat
 from tico.passes.convert_layout_op_to_reshape import ConvertLayoutOpToReshape
+from tico.passes.convert_matmul_to_linear import ConvertMatmulToLinear
 from tico.passes.convert_repeat_to_expand_copy import ConvertRepeatToExpandCopy
 from tico.passes.convert_to_relu6 import ConvertToReLU6
 from tico.passes.decompose_addmm import DecomposeAddmm
@@ -72,6 +60,14 @@ from tico.passes.remove_redundant_slice import RemoveRedundantSlice
 from tico.passes.remove_redundant_to_copy import RemoveRedundantToCopy
 from tico.passes.restore_linear import RestoreLinear
 from tico.passes.segment_index_select import SegmentIndexSelectConst
+from tico.quantization.passes.fold_quant_ops import FoldQuantOps
+from tico.quantization.passes.insert_quantize_on_dtype_mismatch import (
+    InsertQuantizeOnDtypeMismatch,
+)
+from tico.quantization.passes.propagate_qparam_backward import PropagateQParamBackward
+from tico.quantization.passes.propagate_qparam_forward import PropagateQParamForward
+from tico.quantization.passes.quantize_bias import QuantizeBias
+from tico.quantization.passes.remove_weight_dequant_op import RemoveWeightDequantOp
 from tico.serialize.circle_serializer import build_circle
 from tico.serialize.operators.node_visitor import get_support_targets
 from tico.utils import logging
@@ -141,6 +137,7 @@ def traced_run_decompositions(exported_program: ExportedProgram):
         or torch.__version__.startswith("2.7")
         or torch.__version__.startswith("2.8")
         or torch.__version__.startswith("2.9")
+        or torch.__version__.startswith("2.10")
     ):
         return run_decompositions(exported_program)
     else:
@@ -249,6 +246,14 @@ def convert_exported_module_to_circle(
             ConstPropPass(),
             SegmentIndexSelectConst(),
             LegalizeCausalMaskValue(enabled=config.get("legalize_causal_mask_value")),
+            ConvertExpandToSliceCat(enabled=config.get("convert_expand_to_slice_cat")),
+            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(),
             LowerPow2ToMul(),
@@ -287,7 +292,7 @@ def convert_exported_module_to_circle(
 
     check_unsupported_target(exported_program)
     check_training_ops(exported_program)
-    circle_program = build_circle(exported_program)
+    circle_program = build_circle(exported_program, config)
 
     return circle_program