tico 0.1.0.dev250924__py3-none-any.whl → 0.1.0.dev251111__py3-none-any.whl

tico/__init__.py

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

tico/quantization/__init__.py

@@ -0,0 +1,6 @@
+from tico.quantization.public_interface import convert, prepare
+
+__all__ = [
+    "convert",
+    "prepare",
+]

tico/quantization/algorithm/fpi_gptq/fpi_gptq.py

@@ -0,0 +1,161 @@
+# Copyright IST-DASLab. 2025. (commit: 2d65066). GitHub repository.
+# Retrieved from https://github.com/IST-DASLab/gptq. Licensed under the
+# Apache License 2.0.
+
+# 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.
+
+# https://github.com/IST-DASLab/gptq/blob/2d65066/gptq.py
+
+import math
+import time
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+from tico.quantization.algorithm.gptq.quant import quantize, Quantizer
+
+
+def iterate_GPTQ(scale, zero, maxq, W, Hinv, max_num_of_iters=50):
+
+    cur_weights = W.clone()
+    mults = torch.pow(torch.diag(Hinv), -1)
+    Hinv_U = torch.triu(Hinv, diagonal=1)
+
+    init_weights = W.clone()
+    for _ in range(max_num_of_iters):
+        cur_Q = quantize(cur_weights, scale, zero, maxq)
+
+        d_W = torch.mul((cur_weights - cur_Q), mults)
+        cur_weights = init_weights - torch.matmul(d_W, Hinv_U)
+        del d_W, cur_Q
+        d_W = cur_Q = None
+
+    del init_weights
+    init_weights = None
+
+    cur_Q = quantize(cur_weights, scale, zero, maxq)
+
+    return cur_Q, cur_weights
+
+
+class FPI_GPTQ:
+    def __init__(self, layer):
+        self.layer = layer
+        self.dev = self.layer.weight.device
+        W = layer.weight.data.clone()
+        if isinstance(self.layer, nn.Conv2d):
+            W = W.flatten(1)
+
+        if isinstance(self.layer, nn.Conv1d):
+            W = W.t()
+        self.rows = W.shape[0]
+        self.columns = W.shape[1]
+        self.H: Optional[torch.Tensor] = torch.zeros(
+            (self.columns, self.columns), device=self.dev
+        )
+        self.nsamples = 0
+        self.quantizer: Quantizer = Quantizer()
+
+    def add_batch(self, inp, out):
+        if len(inp.shape) == 2:
+            inp = inp.unsqueeze(0)
+        tmp = inp.shape[0]
+        if isinstance(self.layer, nn.Linear) or isinstance(self.layer, nn.Conv1d):
+            if len(inp.shape) > 2:
+                inp = inp.reshape((-1, inp.shape[-1]))
+            inp = inp.t()
+        if isinstance(self.layer, nn.Conv2d):
+            unfold = nn.Unfold(
+                self.layer.kernel_size,
+                dilation=self.layer.dilation,
+                padding=self.layer.padding,
+                stride=self.layer.stride,
+            )
+
+            inp = unfold(inp)
+            inp = inp.permute([1, 0, 2])
+            inp = inp.flatten(1)
+
+        self.H *= self.nsamples / (self.nsamples + tmp)
+        self.nsamples += tmp
+        inp = math.sqrt(2 / self.nsamples) * inp.float()
+        self.H += inp.matmul(inp.t())
+
+    def fasterquant(
+        self,
+        percdamp=0.01,
+        verbose=False,
+    ):
+        W = self.layer.weight.data.clone()
+        if isinstance(self.layer, nn.Conv2d):
+            W = W.flatten(1)
+        if isinstance(self.layer, nn.Conv1d):
+            W = W.t()
+        W = W.float()
+        tick = time.time()
+        if not self.quantizer.ready():
+            self.quantizer.find_params(W, weight=True)
+
+        H = self.H
+        del self.H
+        assert isinstance(H, torch.Tensor)
+        dead = torch.diag(H) == 0
+        H[dead, dead] = 1
+        W[:, dead] = 0
+
+        # actorder
+        perm = torch.argsort(torch.diag(H), descending=True)
+        W = W[:, perm]
+        H = H[perm][:, perm]
+        invperm = torch.argsort(perm)
+
+        Q = torch.zeros_like(W)
+
+        damp = percdamp * torch.mean(torch.diag(H))
+        diag = torch.arange(self.columns, device=self.dev)
+        H[diag, diag] += damp
+        H = torch.linalg.cholesky(H)
+        assert isinstance(H, torch.Tensor)
+        H = torch.cholesky_inverse(H)
+        H = torch.linalg.cholesky(H, upper=True)
+        Hinv = H
+
+        Q, W = iterate_GPTQ(
+            self.quantizer.scale,
+            self.quantizer.zero,
+            self.quantizer.maxq,
+            W,
+            Hinv=Hinv,
+            max_num_of_iters=50,
+        )
+
+        if torch.cuda.is_available():
+            torch.cuda.synchronize()
+        if verbose:
+            print("time %.2f" % (time.time() - tick))
+            Losses = 0.5 * ((Q - W) / torch.diag(Hinv)) ** 2
+            print("error", torch.sum(Losses).item())
+
+        Q = Q[:, invperm]
+
+        self.layer.weight.data = Q.reshape(self.layer.weight.shape).to(
+            self.layer.weight.data.dtype
+        )
+
+    def free(self):
+        self.H = None
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()

tico/quantization/algorithm/fpi_gptq/quantizer.py

@@ -0,0 +1,179 @@
+# Copyright (c) 2024 Intel Corporation
+# 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 Any, Dict
+
+import torch
+from tqdm.auto import tqdm
+
+from tico.quantization.algorithm.fpi_gptq.fpi_gptq import FPI_GPTQ
+from tico.quantization.algorithm.gptq.quantizer import GPTQQuantizer
+from tico.quantization.algorithm.gptq.utils import (
+    find_layers,
+    gather_single_batch_from_dict,
+    gather_single_batch_from_list,
+)
+from tico.quantization.config.fpi_gptq import FPIGPTQConfig
+from tico.quantization.quantizer_registry import register_quantizer
+
+
+@register_quantizer(FPIGPTQConfig)
+class FPIGPTQQuantizer(GPTQQuantizer):
+    """
+    Quantizer for applying the Fixed Point Iteration GPTQ algorithm (FPIGPTQ)
+    This implementation expects the same steps as GPTQQuantizer.
+    It should produce results very close to reference GPTQ but much faster when running on cuda.
+    """
+
+    def __init__(self, config: FPIGPTQConfig):
+        super().__init__(config)
+
+    @torch.no_grad()
+    def convert(self, model):
+
+        # Restore original forwards (we no longer want to stop after first layer)
+        assert self._orig_model_forward is not None
+        model.forward = self._orig_model_forward
+        assert (
+            self._first_layer_ref is not None and self._orig_layer_forward is not None
+        )
+        self._first_layer_ref.forward = self._orig_layer_forward
+
+        gptq_conf = self.config
+        assert isinstance(gptq_conf, FPIGPTQConfig)
+        # Disable use_cache during calibration
+        if hasattr(model, "config") and hasattr(model.config, "use_cache"):
+            orig_use_cache = model.config.use_cache
+            model.config.use_cache = False
+        else:
+            orig_use_cache = None
+
+        # Identify layers
+        if hasattr(model, "model"):
+            target_layers = model.model.layers
+        else:
+            target_layers = [model]
+
+        quantizers: Dict[str, Any] = {}
+        for l_idx, layer in enumerate(
+            tqdm(
+                target_layers,
+                desc="Quantizing layers",
+                unit="layer",
+                disable=not gptq_conf.show_progress,
+            )
+        ):
+            # 1) Identify quantizable submodules within the layer
+            full = find_layers(layer, layers=[torch.nn.Linear, torch.nn.Conv2d])
+            # filter out depthwise convolutions and alike
+            full = {
+                key: full[key]
+                for key in full.keys()
+                if not isinstance(full[key], torch.nn.Conv2d) or full[key].groups == 1
+            }
+
+            sequential = [list(full.keys())]
+
+            # 2) Set up (as in GPTQ)
+            for names in sequential:
+                subset = {n: full[n] for n in names}
+
+                gptq: Dict[str, FPI_GPTQ] = {}
+                for name in subset:
+                    gptq[name] = FPI_GPTQ(subset[name])
+                    gptq[name].quantizer.configure(
+                        bits=8, perchannel=True, sym=False, mse=False
+                    )
+
+                # Hook to collect (inp, out) for GPTQ
+                def add_batch(name):
+                    def _hook(_, inp, out):
+                        gptq[name].add_batch(inp[0].data, out.data)
+
+                    return _hook
+
+                handles = []
+                for name in subset:
+                    handles.append(subset[name].register_forward_hook(add_batch(name)))
+
+                # Run layer forward over all cached batches to build Hessian/statistics
+                batch_num = self.num_batches
+                for batch_idx in tqdm(
+                    range(batch_num),
+                    desc=f"[L{l_idx}] collecting",
+                    leave=False,
+                    unit="batch",
+                    disable=not gptq_conf.show_progress,
+                ):
+                    cache_args_batch = gather_single_batch_from_list(
+                        self.cache_args, batch_idx
+                    )
+                    cache_kwargs_batch = gather_single_batch_from_dict(
+                        self.cache_kwargs, batch_idx
+                    )
+                    layer(*cache_args_batch, **cache_kwargs_batch)
+
+                # Remove handles
+                for h in handles:
+                    h.remove()
+
+                # 3) Quantize each submodule
+                for name in subset:
+                    if gptq_conf.verbose:
+                        print(f"[Layer {l_idx}] {name} -> Quantizing ...")
+                    gptq[name].fasterquant(
+                        percdamp=0.01,
+                        verbose=gptq_conf.verbose,
+                    )
+                    quantizers[f"model.layers.{l_idx}.{name}"] = gptq[name].quantizer
+                    gptq[name].free()
+
+            # 4) After quantization, re-run the layer to produce outputs for the next layer
+            for batch_idx in tqdm(
+                range(batch_num),
+                desc=f"[L{l_idx}] re-forward",
+                leave=False,
+                unit="batch",
+                disable=not gptq_conf.show_progress,
+            ):
+                cache_args_batch = gather_single_batch_from_list(
+                    self.cache_args, batch_idx
+                )
+                cache_kwargs_batch = gather_single_batch_from_dict(
+                    self.cache_kwargs, batch_idx
+                )
+                outs = layer(*cache_args_batch, **cache_kwargs_batch)
+                # LLaMA's decoder layer return type differs across Transformers versions:
+                # some return a tuple (hidden_states, ...), others return just a tensor.
+                # This line ensures we always take the first element when it's a tuple.
+                outs = outs[0] if isinstance(outs, tuple) else outs
+                # Update inputs for next iteration.
+                self.cache_args[0][batch_idx] = outs
+
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+        # Restore the original cache configuration.
+        if orig_use_cache is not None:
+            model.config.use_cache = orig_use_cache
+
+        # Clear caches to free memory
+        self.cache_args.clear()
+        self.cache_kwargs.clear()
+        self.num_batches = 0
+
+        model.quantizers = quantizers
+
+        return model

tico/{experimental/quantization → quantization}/algorithm/gptq/gptq.py

@@ -25,7 +25,7 @@ from typing import Optional
 import torch
 import torch.nn as nn
 
-from tico.experimental.quantization.algorithm.gptq.quant import quantize, Quantizer
+from tico.quantization.algorithm.gptq.quant import quantize, Quantizer
 
 torch.backends.cuda.matmul.allow_tf32 = False
 torch.backends.cudnn.allow_tf32 = False
@@ -36,6 +36,11 @@ class GPTQ:
         self.layer = layer
         self.dev = self.layer.weight.device
         W = layer.weight.data.clone()
+        if isinstance(self.layer, nn.Conv2d):
+            W = W.flatten(1)
+
+        if isinstance(self.layer, nn.Conv1d):
+            W = W.t()
         self.rows = W.shape[0]
         self.columns = W.shape[1]
         self.H: Optional[torch.Tensor] = torch.zeros(
@@ -48,10 +53,22 @@ class GPTQ:
         if len(inp.shape) == 2:
             inp = inp.unsqueeze(0)
         tmp = inp.shape[0]
-        if isinstance(self.layer, nn.Linear):
-            if len(inp.shape) == 3:
+        if isinstance(self.layer, nn.Linear) or isinstance(self.layer, nn.Conv1d):
+            if len(inp.shape) > 2:
                 inp = inp.reshape((-1, inp.shape[-1]))
             inp = inp.t()
+        if isinstance(self.layer, nn.Conv2d):
+            unfold = nn.Unfold(
+                self.layer.kernel_size,
+                dilation=self.layer.dilation,
+                padding=self.layer.padding,
+                stride=self.layer.stride,
+            )
+
+            inp = unfold(inp)
+            inp = inp.permute([1, 0, 2])
+            inp = inp.flatten(1)
+
         self.H *= self.nsamples / (self.nsamples + tmp)
         self.nsamples += tmp
         inp = math.sqrt(2 / self.nsamples) * inp.float()
@@ -67,6 +84,10 @@ class GPTQ:
         verbose=False,
     ):
         W = self.layer.weight.data.clone()
+        if isinstance(self.layer, nn.Conv2d):
+            W = W.flatten(1)
+        if isinstance(self.layer, nn.Conv1d):
+            W = W.t()
         W = W.float()
         tick = time.time()
         if not self.quantizer.ready():

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

@@ -19,15 +19,15 @@ from typing import Any, Callable, Dict, List, Optional
 import torch
 from tqdm.auto import tqdm
 
-from tico.experimental.quantization.algorithm.gptq.gptq import GPTQ
-from tico.experimental.quantization.algorithm.gptq.utils import (
+from tico.quantization.algorithm.gptq.gptq import GPTQ
+from tico.quantization.algorithm.gptq.utils import (
     find_layers,
     gather_single_batch_from_dict,
     gather_single_batch_from_list,
 )
-from tico.experimental.quantization.config.gptq import GPTQConfig
-from tico.experimental.quantization.quantizer import BaseQuantizer
-from tico.experimental.quantization.quantizer_registry import register_quantizer
+from tico.quantization.config.gptq import GPTQConfig
+from tico.quantization.quantizer import BaseQuantizer
+from tico.quantization.quantizer_registry import register_quantizer
 
 
 class StopForward(Exception):
@@ -193,7 +193,13 @@ class GPTQQuantizer(BaseQuantizer):
             )
         ):
             # 1) Identify quantizable submodules within the layer
-            full = find_layers(layer)
+            full = find_layers(layer, layers=[torch.nn.Linear, torch.nn.Conv2d])
+            # filter out depthwise convolutions and alike
+            full = {
+                key: full[key]
+                for key in full.keys()
+                if not isinstance(full[key], torch.nn.Conv2d) or full[key].groups == 1
+            }
             sequential = [list(full.keys())]
 
             # 2) Set up GPTQ objects and gather stats

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/annotator.py

@@ -25,14 +25,12 @@ from torch.ao.quantization.observer import MinMaxObserver, PerChannelMinMaxObser
 from torch.ao.quantization.quantizer import QuantizationSpec, Quantizer
 from torch.ao.quantization.quantizer.utils import _get_module_name_filter
 
-from tico.experimental.quantization.algorithm.pt2e.annotation.op import *
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
-from tico.experimental.quantization.algorithm.pt2e.transformation.convert_scalars_to_attrs import (
+from tico.quantization.algorithm.pt2e.annotation.op import *
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
+from tico.quantization.algorithm.pt2e.transformation.convert_scalars_to_attrs import (
     convert_scalars_to_attrs,
 )
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/adaptive_avg_pool2d.py

@@ -19,12 +19,10 @@ if TYPE_CHECKING:
 import torch
 from torch.ao.quantization.quantizer import SharedQuantizationSpec
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import AdaptiveAvgPool2dArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/add.py

@@ -18,12 +18,10 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import AddTensorArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/conv2d.py

@@ -19,12 +19,10 @@ if TYPE_CHECKING:
 import torch
 from torch.ao.quantization.quantizer import DerivedQuantizationSpec
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import Conv2DArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/div.py

@@ -18,12 +18,10 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import DivTensorArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/linear.py

@@ -19,12 +19,10 @@ if TYPE_CHECKING:
 import torch
 from torch.ao.quantization.quantizer import DerivedQuantizationSpec
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import LinearArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/mean.py

@@ -18,12 +18,10 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import MeanDimArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/mul.py

@@ -18,12 +18,10 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import MulTensorArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/relu6.py

@@ -18,12 +18,10 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import Relu6Args
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/rsqrt.py

@@ -18,12 +18,10 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import RsqrtArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/op/sub.py

@@ -18,12 +18,10 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
-import tico.experimental.quantization.algorithm.pt2e.annotation.utils as annot_utils
-import tico.experimental.quantization.algorithm.pt2e.utils as quant_utils
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.utils as annot_utils
+import tico.quantization.algorithm.pt2e.utils as quant_utils
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 from tico.utils.validate_args_kwargs import SubTensorArgs
 
 

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/spec.py

@@ -18,9 +18,7 @@ if TYPE_CHECKING:
     import torch.fx
 import torch
 
-from tico.experimental.quantization.algorithm.pt2e.annotation.config import (
-    QuantizationConfig,
-)
+from tico.quantization.algorithm.pt2e.annotation.config import QuantizationConfig
 
 AnnotatorType = Callable[
     [

tico/{experimental/quantization → quantization}/algorithm/pt2e/annotation/utils.py

@@ -22,7 +22,7 @@ from torch.ao.quantization.quantizer import (
     SharedQuantizationSpec,
 )
 
-import tico.experimental.quantization.algorithm.pt2e.annotation.spec as annot_spec
+import tico.quantization.algorithm.pt2e.annotation.spec as annot_spec
 
 
 def annotate_input_qspec_map(node: torch.fx.Node, input_node: torch.fx.Node, qspec):