tico 0.1.0.dev250714__py3-none-any.whl → 0.1.0.dev251102__py3-none-any.whl

tico/quantization/passes/insert_quantize_on_dtype_mismatch.py

@@ -0,0 +1,459 @@
+# 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 TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch.fx
+import copy
+
+from collections import defaultdict
+from typing import Any
+
+import torch
+from torch.export import ExportedProgram
+
+from tico.serialize.quant_param import QPARAM_KEY, QuantParam
+from tico.utils import logging
+from tico.utils.errors import NotYetSupportedError
+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.utils import quant_min_max, set_new_meta_val
+from tico.utils.validate_args_kwargs import (
+    AddTensorArgs,
+    BmmArgs,
+    CatArgs,
+    LinearArgs,
+    MulTensorArgs,
+    PermuteArgs,
+    ReluArgs,
+    ReshapeArgs,
+)
+
+
+def qparam_dtype(node: torch.fx.Node) -> str:
+    assert QPARAM_KEY in node.meta
+    return node.meta[QPARAM_KEY].dtype
+
+
+# Convert i16 qparam to u8 qparam
+# scale and zero_point are inferred from i16 qparam
+def _i16_to_u8(qparam: QuantParam) -> QuantParam:
+    # Assume per-tensor quantization
+    assert qparam.scale is not None and len(qparam.scale) == 1
+    assert qparam.dtype == "int16"
+
+    s16_scale = qparam.scale[0]
+    max_ = s16_scale * 32767  # numeric_limits<int16>
+    min_ = -max_
+
+    u8_scale = (max_ - min_) / 255
+    u8_zerop = round(-min_ / u8_scale)
+
+    new_qparam = QuantParam()
+    new_qparam.scale = [u8_scale]
+    new_qparam.zero_point = [u8_zerop]
+    new_qparam.dtype = "uint8"
+
+    return new_qparam
+
+
+# Convert u8 qparam to i16 qparam
+# scale is inferred from u8 qparam
+def _u8_to_i16(qparam: QuantParam) -> QuantParam:
+    # Assume per-tensor quantization
+    assert qparam.scale is not None and len(qparam.scale) == 1
+    assert qparam.zero_point is not None and len(qparam.zero_point) == 1
+    assert qparam.dtype == "uint8"
+
+    u8_scale = qparam.scale[0]
+    u8_zerop = qparam.zero_point[0]
+    max_ = u8_scale * (255 - u8_zerop)
+    min_ = u8_scale * (-u8_zerop)
+
+    abs_max = max(abs(max_), abs(min_))
+    s16_scale = abs_max / 32767
+    s16_zerop = 0
+
+    new_qparam = QuantParam()
+    new_qparam.scale = [s16_scale]
+    new_qparam.zero_point = [s16_zerop]
+    new_qparam.dtype = "int16"
+
+    return new_qparam
+
+
+def _insert_quantize_op_before(node, inp):
+    graph = node.graph
+    qparam: QuantParam = node.meta[QPARAM_KEY]
+    assert qparam.scale is not None
+    assert qparam.zero_point is not None
+    scale = qparam.scale[0]
+    zerop = qparam.zero_point[0]
+    min_, max_ = quant_min_max(qparam.dtype)
+    dtype = getattr(torch, qparam.dtype)
+
+    with graph.inserting_before(node):
+        q_args = (inp, scale, zerop, min_, max_, dtype)
+        quantize = create_node(
+            graph,
+            torch.ops.quantized_decomposed.quantize_per_tensor.default,
+            args=q_args,
+            origin=node,
+        )
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(qparam)
+        set_new_meta_val(quantize)
+
+    node.replace_input_with(inp, quantize)
+
+    return quantize
+
+
+def _insert_quantize_op_after(node):
+    graph = node.graph
+    qparam: QuantParam = node.meta[QPARAM_KEY]
+    assert qparam.scale is not None
+    assert qparam.zero_point is not None
+    scale = qparam.scale[0]
+    zerop = qparam.zero_point[0]
+    min_, max_ = quant_min_max(qparam.dtype)
+    dtype = getattr(torch, qparam.dtype)
+    with graph.inserting_after(node):
+        q_args = (node, scale, zerop, min_, max_, dtype)
+        quantize = create_node(
+            graph,
+            torch.ops.quantized_decomposed.quantize_per_tensor.default,
+            args=q_args,
+        )
+
+    node.replace_all_uses_with(quantize, propagate_meta=True)
+    quantize.replace_input_with(quantize, node)
+
+    quantize.meta[QPARAM_KEY] = copy.deepcopy(qparam)
+
+    return quantize
+
+
+def _linear_handler(node, logger):
+    lin_args = LinearArgs(*node.args, **node.kwargs)
+    inp = lin_args.input
+
+    if QPARAM_KEY not in inp.meta:
+        return
+
+    if QPARAM_KEY not in node.meta:
+        return
+
+    if qparam_dtype(inp) == qparam_dtype(node):
+        return
+
+    if qparam_dtype(inp) == "uint8" and qparam_dtype(node) == "int16":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+
+        # Update node's qparam from i16 to u8
+        # NOTE This would severely degrade accuracy. It is
+        # important to mitigate this accuracy drop in backend.
+        node.meta[QPARAM_KEY] = _i16_to_u8(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError(
+            f"Unsupported dtype: From {qparam_dtype(inp)} to {qparam_dtype(node)}"
+        )
+
+
+def _add_handler(node, logger):
+    add_args = AddTensorArgs(*node.args, **node.kwargs)
+    x = add_args.input
+    y = add_args.other
+
+    if not isinstance(x, torch.fx.Node):
+        return
+    if not isinstance(y, torch.fx.Node):
+        return
+
+    if QPARAM_KEY not in x.meta:
+        return
+    if QPARAM_KEY not in y.meta:
+        return
+    if QPARAM_KEY not in node.meta:
+        return
+
+    if qparam_dtype(x) == qparam_dtype(node):
+        return
+
+    if qparam_dtype(x) != qparam_dtype(y):
+        return
+
+    if qparam_dtype(x) == "int16" and qparam_dtype(node) == "uint8":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _u8_to_i16(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError("Unsupported dtype")
+
+
+def _mul_handler(node, logger):
+    mul_args = MulTensorArgs(*node.args, **node.kwargs)
+    x = mul_args.input
+    y = mul_args.other
+
+    if not isinstance(x, torch.fx.Node):
+        return
+    if not isinstance(y, torch.fx.Node):
+        return
+
+    if QPARAM_KEY not in x.meta:
+        return
+    if QPARAM_KEY not in y.meta:
+        return
+    if QPARAM_KEY not in node.meta:
+        return
+
+    if qparam_dtype(x) == qparam_dtype(node):
+        return
+
+    if qparam_dtype(x) == "int16" and qparam_dtype(node) == "uint8":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _u8_to_i16(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError("Unsupported dtype")
+
+
+def _cat_handler(node, logger):
+    cat_args = CatArgs(*node.args, **node.kwargs)
+    tensors = cat_args.tensors
+
+    if any(QPARAM_KEY not in x.meta for x in tensors):
+        return
+
+    if QPARAM_KEY not in node.meta:
+        return
+
+    assert len(tensors) > 0
+    in_dtype = qparam_dtype(tensors[0])
+    if in_dtype == qparam_dtype(node):
+        return
+
+    if any(qparam_dtype(x) != in_dtype for x in tensors):
+        return
+
+    if in_dtype == "int16" and qparam_dtype(node) == "uint8":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _u8_to_i16(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError("Unsupported dtype")
+
+
+def _bmm_handler(node, logger):
+    bmm_args = BmmArgs(*node.args, **node.kwargs)
+    x = bmm_args.input
+    y = bmm_args.mat2
+
+    if QPARAM_KEY not in x.meta:
+        return
+    if QPARAM_KEY not in y.meta:
+        return
+    if QPARAM_KEY not in node.meta:
+        return
+
+    if qparam_dtype(x) == qparam_dtype(node):
+        return
+
+    if qparam_dtype(x) == "int16" and qparam_dtype(node) == "uint8":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _u8_to_i16(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    elif qparam_dtype(x) == "uint8" and qparam_dtype(node) == "int16":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _i16_to_u8(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError("Unsupported dtype")
+
+
+def _permute_handler(node, logger):
+    per_args = PermuteArgs(*node.args, **node.kwargs)
+    inp = per_args.input
+
+    if QPARAM_KEY not in inp.meta:
+        return
+
+    if QPARAM_KEY not in node.meta:
+        return
+
+    if qparam_dtype(inp) == qparam_dtype(node):
+        return
+
+    if qparam_dtype(inp) == "int16" and qparam_dtype(node) == "uint8":
+        # A new Quantize Op (s16 to u8) is inserted before (not after)
+        # permute Op to reduce tensor size ealier
+        quantize = _insert_quantize_op_before(node, inp)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted before {node.name}.")
+    elif qparam_dtype(inp) == "uint8" and qparam_dtype(node) == "int16":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _i16_to_u8(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError("Unsupported dtype")
+
+
+def _reshape_handler(node, logger):
+    reshape_args = ReshapeArgs(*node.args, **node.kwargs)
+    inp = reshape_args.input
+
+    if QPARAM_KEY not in inp.meta:
+        return
+
+    if QPARAM_KEY not in node.meta:
+        return
+
+    if qparam_dtype(inp) == qparam_dtype(node):
+        return
+
+    if qparam_dtype(inp) == "int16" and qparam_dtype(node) == "uint8":
+        # A new Quantize Op (s16 to u8) is inserted before (not after)
+        # reshape Op to reduce tensor size ealier
+        quantize = _insert_quantize_op_before(node, inp)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted before {node.name}.")
+    elif qparam_dtype(inp) == "uint8" and qparam_dtype(node) == "int16":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _i16_to_u8(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError("Unsupported dtype")
+
+
+def _relu_handler(node, logger):
+    relu_args = ReluArgs(*node.args, **node.kwargs)
+    inp = relu_args.input
+
+    if QPARAM_KEY not in inp.meta:
+        return
+
+    if QPARAM_KEY not in node.meta:
+        return
+
+    if qparam_dtype(inp) == qparam_dtype(node):
+        return
+
+    if qparam_dtype(inp) == "int16" and qparam_dtype(node) == "uint8":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _u8_to_i16(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    elif qparam_dtype(inp) == "uint8" and qparam_dtype(node) == "int16":
+        quantize = _insert_quantize_op_after(node)
+
+        quantize.meta[QPARAM_KEY] = copy.deepcopy(node.meta[QPARAM_KEY])
+        node.meta[QPARAM_KEY] = _i16_to_u8(node.meta[QPARAM_KEY])
+        logger.debug(f"quantize_per_tensor.default is inserted after {node.name}.")
+    else:
+        raise NotYetSupportedError("Unsupported dtype")
+
+
+_op_handler: defaultdict[Any, Any | None] = defaultdict(lambda: None)
+_op_handler[torch.ops.aten.linear.default] = _linear_handler
+_op_handler[torch.ops.aten.add.Tensor] = _add_handler
+_op_handler[torch.ops.aten.mul.Tensor] = _mul_handler
+_op_handler[torch.ops.aten.cat.default] = _cat_handler
+_op_handler[torch.ops.aten.bmm.default] = _bmm_handler
+_op_handler[torch.ops.aten.permute.default] = _permute_handler
+_op_handler[torch.ops.aten.reshape.default] = _reshape_handler
+_op_handler[torch.ops.aten.relu.default] = _relu_handler
+
+
+@trace_graph_diff_on_pass
+class InsertQuantizeOnDtypeMismatch(PassBase):
+    """
+    Insert quantize Op in the operators where circle's type inference is violated.
+    Example. FullyConnected
+    [BEFORE]
+      Op (uint8) -  aten.linear.default (int16)
+    [AFTER]
+      Op (uint8) -  aten.linear.default (uint8) - quantized_decomposed.quantize_per_tensor.default (int16)
+    Why is this pass necessary?
+    - For some operators, circle's type inference pass overwrites the input's dtype to
+    the output's dtype. For the above example, fully-connected layer (aten.linear.default)'s
+    output dtype (int16) is updated to the input dtype (uint8), which breaks the semantics.
+    This problem can occur in the tools (ex: circle2circle) that automatically apply type inference.
+    - To resolve the issue, we insert quantize operators not to violate circle's type inference logic.
+    - NOTE For some cases, Quantize Op is inserted before the operators.
+
+    Let's assume Reshape Op's input is int16 and output is uint8. There are two possible places to insert
+    Quantize Op.
+
+    1. Insert Quantize before Reshape.
+
+    ```
+    Predecessor (int16)-> Quantize (uint8) -> Reshape (uint8) -> ...
+    ```
+
+    2. Insert Quantize after Reshape.
+
+    ```
+    Predecessor (int16)-> Reshape (int16) -> Quantize (uint8) -> ...
+    ```
+
+    Comparing 1) and 2), the difference is that Reshape operation is conducted in uint8 or int16.
+    We go with 1), which does Reshape in uint8, for faster execution. Note that Reshape Op does not
+    change the value, so its dytpe does not affect accuracy.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def call(self, exported_program: ExportedProgram) -> PassResult:
+        logger = logging.getLogger(__name__)
+
+        graph_module = exported_program.graph_module
+        graph: torch.fx.Graph = graph_module.graph
+
+        for node in graph.nodes:
+            if node.op != "call_function":
+                continue
+
+            handler = _op_handler[node.target]
+            if handler is not None:
+                handler(node, logger)
+
+        graph.eliminate_dead_code()
+        graph.lint()
+        graph_module.recompile()
+
+        # Run only once.
+        return PassResult(False)

tico/{experimental/quantization → quantization}/passes/quantize_bias.py

@@ -16,7 +16,6 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import torch.fx
-import copy
 
 import torch
 from torch.export import ExportedProgram

tico/{experimental/quantization → quantization}/passes/remove_weight_dequant_op.py

@@ -53,7 +53,7 @@ class ValRange:
         if isinstance(val, torch.Tensor):
             self.max = torch.max(val).item()
             self.min = torch.min(val).item()
-        elif type(val) == list:
+        elif isinstance(val, list):
             self.max = max(val)
             self.min = min(val)
         else:

tico/{experimental/quantization → 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 import BaseConfig
-from tico.experimental.quantization.quantizer import BaseQuantizer
+from tico.quantization.algorithm.gptq.quantizer import GPTQQuantizer
+from tico.quantization.algorithm.pt2e.quantizer import PT2EQuantizer
+from tico.quantization.config.base import BaseConfig
+from tico.quantization.quantizer import BaseQuantizer
+from tico.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"
 
 
@@ -40,7 +32,7 @@ def prepare(
     quant_config: BaseConfig,
     args: Optional[Any] = None,
     kwargs: Optional[Dict[str, Any]] = None,
-    inplace: Optional[bool] = False,
+    inplace: Optional[bool] = True,
 ):
     """
     Prepare the model for quantization using the provided configuration.
@@ -59,21 +51,24 @@ def prepare(
     Returns:
         The model prepared for quantization.
     """
-    if quant_config.name == "pt2e" and inplace:
+    if hasattr(model, QUANTIZER_ATTRIBUTE_NAME):
+        raise RuntimeError("prepare() already has been called.")
+    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)
 
     return model
 
 
-def convert(model, inplace: Optional[bool] = False):
+def convert(model, inplace: Optional[bool] = True):
     """
     Convert the prepared model to a quantized model using the provided configuration.
 
@@ -99,6 +94,12 @@ def convert(model, inplace: Optional[bool] = False):
         raise RuntimeError(
             "In-place is not supported for PT2E quantization due to limitation in the underlying Torch APIs. Please set 'inplace=False' to proceed."
         )
+    # deepcopy prevents the quantizer from restoring the catcher used for calibration.
+    # TODO Revisit `inplace` policy.
+    if isinstance(quantizer, GPTQQuantizer) and not inplace:
+        raise RuntimeError(
+            "GPTQ quantization only supports `in-place=True`. Please set 'inplace=True' to proceed."
+        )
 
     model = model if inplace else copy.deepcopy(model)
 

tico/{experimental/quantization → quantization}/quantizer.py

@@ -17,7 +17,7 @@ from typing import Any, Dict, Optional
 
 import torch
 
-from tico.experimental.quantization.config import BaseConfig
+from tico.quantization.config.base import BaseConfig
 
 
 class BaseQuantizer(ABC):

tico/quantization/quantizer_registry.py

@@ -0,0 +1,73 @@
+# 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.quantization.config.base import BaseConfig
+from tico.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:
+        if name == "ptq":
+            importlib.import_module(f"tico.quantization.wrapq.quantizer")
+        else:
+            try:
+                importlib.import_module(f"tico.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/quantization/wrapq/__init__.py

@@ -0,0 +1 @@
+# DO NOT REMOVE THIS FILE