tico 0.4.0.dev261024__tar.gz → 0.4.0.dev261026__tar.gz

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tico
-Version: 0.4.0.dev261024
+Version: 0.4.0.dev261026
 Summary: Convert Exported Torch Module To Circle
 License: This file provides full text of licenses used in this project
         

tico-0.4.0.dev261026/tico/_version.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev261026"

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/circle/analysis/effects.py

@@ -23,7 +23,6 @@ from tico.circle._schema import circle_schema, object_api_type
 from tico.circle.errors import CircleRewriteError
 from tico.circle.graph import as_indices, as_list, CircleGraph, OPTIONAL_TENSOR_INDEX
 
-
 DEFAULT_EFFECTFUL_BUILTIN_NAMES = (
     "ASSIGN_VARIABLE",
     "BIDIRECTIONAL_SEQUENCE_LSTM",

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/circle/cli/main.py

@@ -413,8 +413,9 @@ def _extract_command(args: argparse.Namespace) -> int:
 def _parse_passes(
     value: str,
     *,
-    constant_folding_profile: ConstantFoldingProfile
-    | str = (ConstantFoldingProfile.BASIC),
+    constant_folding_profile: ConstantFoldingProfile | str = (
+        ConstantFoldingProfile.BASIC
+    ),
 ) -> list[CirclePass]:
     """Create Circle pass instances from canonical comma-separated names."""
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/circle/io.py

@@ -204,9 +204,9 @@ def write_circle_bytes(
         raise TypeError(f"Expected bytes, received {type(data).__name__}.")
     _write_destination(
         destination,
-        lambda stream: _write_all(stream, memoryview(data))
-        if data
-        else stream.write(data),
+        lambda stream: (
+            _write_all(stream, memoryview(data)) if data else stream.write(data)
+        ),
         atomic=atomic,
     )
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/circle/passes/optimization/cse.py

@@ -152,9 +152,11 @@ class CommonSubexpressionEliminationPass(CirclePass):
                         continue
                     outputs = tuple(as_indices(getattr(operator, "outputs", None)))
                     canonical_inputs = tuple(
-                        _representative(representatives, tensor_index)
-                        if tensor_index != OPTIONAL_TENSOR_INDEX
-                        else tensor_index
+                        (
+                            _representative(representatives, tensor_index)
+                            if tensor_index != OPTIONAL_TENSOR_INDEX
+                            else tensor_index
+                        )
                         for tensor_index in as_indices(
                             getattr(operator, "inputs", None)
                         )

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/circle/passes/optimization/fold/evaluators/heavy.py

@@ -755,10 +755,13 @@ def _input_buffer_payload(
 def _parse_sparsity(
     sparsity: Any,
     dense_shape: Sequence[int],
-) -> tuple[
-    tuple[int, ...],
-    tuple[tuple[str, int, tuple[int, ...], tuple[int, ...]], ...],
-] | None:
+) -> (
+    tuple[
+        tuple[int, ...],
+        tuple[tuple[str, int, tuple[int, ...], tuple[int, ...]], ...],
+    ]
+    | None
+):
     """Parse an unblocked Circle sparsity record into traversal-level metadata."""
 
     rank = len(dense_shape)

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/circle/passes/optimization/simplify/transpose_region_rules.py

@@ -25,7 +25,6 @@ from tico.circle.passes.optimization.simplify._layout_utils import (
     _get_const_data,
 )
 
-
 _ADD_BUILTIN_CODE = _builtin_operator_value("ADD")
 _ADD_N_BUILTIN_CODE = _builtin_operator_value("ADD_N")
 _CONCATENATION_BUILTIN_CODE = _builtin_operator_value("CONCATENATION")

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/interpreter/interpreter.py

@@ -56,8 +56,7 @@ class Interpreter:
             ) from error
 
         self.ffi = FFI()
-        self.ffi.cdef(
-            """
+        self.ffi.cdef("""
           typedef struct InterpreterWrapper InterpreterWrapper;
 
           const char *get_last_error(void);
@@ -67,8 +66,7 @@ class Interpreter:
           void Interpreter_interpret(InterpreterWrapper *intp);
           void Interpreter_writeInputTensor(InterpreterWrapper *intp, const int input_idx, const void *data, size_t input_size);
           void Interpreter_readOutputTensor(InterpreterWrapper *intp, const int output_idx, void *output, size_t output_size);
-        """
-        )
+        """)
         self.C = self.ffi.dlopen(str(self.LIB_PATH))
 
         # Initialize interpreter

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/passes/cast_aten_where_arg_type.py

@@ -30,7 +30,6 @@ from tico.utils.trace_decorators import (
 from tico.utils.utils import is_target_node, set_new_meta_val
 from tico.utils.validate_args_kwargs import WhereSelfArgs
 
-
 dtype_ranking = {
     torch.int32: 0,
     torch.int64: 1,

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/passes/cast_mixed_type_args.py

@@ -31,7 +31,6 @@ from tico.utils.passes import PassBase, PassResult
 from tico.utils.trace_decorators import trace_graph_diff_on_pass
 from tico.utils.utils import is_target_node, set_new_meta_val
 
-
 ops_to_promote = {
     torch.ops.aten.add.Tensor: ELEMENTWISE_TYPE_PROMOTION_KIND.DEFAULT,
     torch.ops.aten.div.Tensor: ELEMENTWISE_TYPE_PROMOTION_KIND.DEFAULT,

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/passes/const_prop_pass.py

@@ -48,7 +48,6 @@ from tico.utils.trace_decorators import (
 )
 from tico.utils.utils import get_fake_mode
 
-
 _MISSING = object()
 
 TensorStorageIdentityKey = tuple[
@@ -590,12 +589,12 @@ class ConstPropPass(PassBase):
         graph: torch.fx.Graph = graph_module.graph
 
         # [1], [2]
-        const_node_to_tensor: OrderedDict[
-            torch.fx.Node, torch.Tensor
-        ] = propagate_constants(
-            exported_program,
-            fold_filter=self._fold_filter,
-            folded_node_callback=self._folded_node_callback,
+        const_node_to_tensor: OrderedDict[torch.fx.Node, torch.Tensor] = (
+            propagate_constants(
+                exported_program,
+                fold_filter=self._fold_filter,
+                folded_node_callback=self._folded_node_callback,
+            )
         )
         # [3]
         placeholders = create_constant_placeholder(

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/passes/ops.py

@@ -14,7 +14,6 @@
 
 import torch
 
-
 """
 This module contains Op lists used for finding the target Ops in passes.
 The module is introduced to reduce duplicate codes.

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/passes/remove_redundant_assert_nodes.py

@@ -19,7 +19,6 @@ from tico.utils.passes import PassBase, PassResult
 from tico.utils.trace_decorators import trace_graph_diff_on_pass
 from tico.utils.utils import is_target_node
 
-
 assert_node_targets = [
     torch.ops.aten._assert_scalar.default,
     torch.ops.aten._assert_tensor_metadata.default,

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/adaround/discrete_refinement.py

@@ -56,7 +56,6 @@ from tico.quantization.wrapq.control import (
 from tico.quantization.wrapq.observers.affine_base import AffineObserverBase
 from tico.quantization.wrapq.observers.base import ObserverBase
 
-
 MetricsEvaluator = Callable[[], OutputMetrics]
 ProgressCallback = Callable[["DiscreteCodeRoundResult"], None]
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/adaround/global_refinement.py

@@ -47,7 +47,6 @@ from tico.quantization.wrapq.control import (
 from tico.quantization.wrapq.observers.affine_base import AffineObserverBase
 from tico.quantization.wrapq.observers.base import ObserverBase
 
-
 MetricsEvaluator = Callable[[], OutputMetrics]
 ProgressCallback = Callable[["GlobalWeightRefinementCheckpoint"], None]
 
@@ -1086,7 +1085,7 @@ class GlobalWeightRefinementCheckpoint:
     train_checkpoint_anchor_loss: float | None = None
     checkpoint_anchor_weight: float | None = None
     alpha_absolute_histogram: GlobalRefinementTensorHistogram | None = None
-    alpha_gradient_absolute_histogram: (GlobalRefinementTensorHistogram | None) = None
+    alpha_gradient_absolute_histogram: GlobalRefinementTensorHistogram | None = None
     flip_budget_statistics: GlobalRefinementFlipBudgetStatistics | None = None
 
     def to_dict(self) -> dict[str, object]:

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/adaround/joint.py

@@ -32,7 +32,6 @@ from tico.quantization.wrapq.control import (
 from tico.quantization.wrapq.observers.affine_base import AffineObserverBase
 from tico.quantization.wrapq.observers.base import ObserverBase
 
-
 _SUPPORTED_FAMILIES = frozenset({"regular_conv", "depthwise_conv"})
 
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/adaround/screened_refinement.py

@@ -51,7 +51,6 @@ from tico.quantization.algorithm.block_reconstruction.selection import (
 from tico.quantization.analysis import OutputAdapter
 from tico.quantization.wrapq.control import FakeQuantState
 
-
 MetricsEvaluator = Callable[[], OutputMetrics]
 ProgressCallback = Callable[["ScreenedCodeRoundResult"], None]
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/block_reconstruction/cache.py

@@ -22,7 +22,6 @@ from typing import Any, TypeAlias
 
 import torch
 
-
 TensorTree: TypeAlias = (
     torch.Tensor
     | tuple["TensorTree", ...]

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/block_reconstruction/qdrop.py

@@ -31,7 +31,6 @@ from tico.quantization.algorithm.block_reconstruction.cache import (
     TensorTree,
 )
 
-
 _ACTIVE_QDROP: ContextVar[QDropController | None] = ContextVar(
     "block_reconstruction_qdrop",
     default=None,

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/block_reconstruction/selection.py

@@ -21,7 +21,6 @@ import math
 from collections.abc import Mapping
 from dataclasses import dataclass, field
 
-
 OutputMetrics = Mapping[str, Mapping[str, float | int | None]]
 
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/cle/cle.py

@@ -21,7 +21,6 @@ from tqdm import tqdm
 
 from tico.quantization.config.cle import CLEConfig
 
-
 SupportedLayer: TypeAlias = nn.Conv2d | nn.Linear
 
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/gemma4_gptq/quantizer.py

@@ -40,7 +40,6 @@ from tico.quantization.config.gemma4_gptq import Gemma4GPTQConfig
 from tico.quantization.quantizer import BaseQuantizer
 from tico.quantization.quantizer_registry import register_quantizer
 
-
 ModelT = TypeVar("ModelT", bound=nn.Module)
 
 

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/gptq/quantizer.py

@@ -112,6 +112,7 @@ class GPTQQuantizer(BaseQuantizer):
         Returns:
             torch.nn.Module: The model with the catcher attached
         """
+
         # Define the catcher to store inputs/kwargs and stop the execution
         def forward(layer, *args, **kwargs):
             """

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/gptq/utils.py

@@ -119,10 +119,9 @@ def gather_single_batch_from_list(data_list, idx):
 
 
 def get_numerical_padding(
-    layer: torch.nn.Conv1d
-    | torch.nn.Conv2d
-    | torch.nn.Conv3d
-    | torch.nn.ConvTranspose2d,
+    layer: (
+        torch.nn.Conv1d | torch.nn.Conv2d | torch.nn.Conv3d | torch.nn.ConvTranspose2d
+    ),
 ) -> int | tuple[int, ...]:
     padding: str | int | tuple[int, ...] = layer.padding
     if isinstance(padding, str):

{tico-0.4.0.dev261024 → tico-0.4.0.dev261026}/tico/quantization/algorithm/qwen3_vl_gptq/gptq.py

@@ -320,6 +320,8 @@ class GPTQ:
             dtype=self.hessian_dtype,
         )
         self.nsamples = 0
+        self.effective_observation_count = 0.0
+        self.percdamp_used: Optional[float] = None
         self.quantizer: Quantizer = Quantizer()
 
         # GPTQv2: for tracking FP vs quantized input difference
@@ -407,6 +409,9 @@ class GPTQ:
         elif isinstance(self.layer, nn.Conv3d):
             inp = _conv3d_input_to_unfolded(self.layer, inp)
 
+        observations = int(inp.shape[1])
+        self.effective_observation_count += float(observations)
+
         # GPTQv2: Apply the same reshaping to native_inp
         native_inp = None
         if native_inp_raw is not None:
@@ -444,9 +449,11 @@ class GPTQ:
                     dilation=(1, self.layer.dilation[0]),
                     padding=(
                         0,
-                        0
-                        if self.layer.padding == "valid"
-                        else int(self.layer.padding[0]),
+                        (
+                            0
+                            if self.layer.padding == "valid"
+                            else int(self.layer.padding[0])
+                        ),
                     ),
                     stride=(1, self.layer.stride[0]),
                 )
@@ -502,11 +509,141 @@ class GPTQ:
             del native_inp_raw, native_inp
             native_inp_raw = native_inp = None
 
+    def _validate_hinv(
+        self,
+        hinv: torch.Tensor,
+        percdamp: float,
+        instability_ratio: float = 1e8,
+    ) -> None:
+        """
+        Validate the inverse-Hessian Cholesky factor used by GPTQ updates.
+        """
+        if not torch.isfinite(hinv).all():
+            raise RuntimeError(
+                "GPTQ Hessian inverse Cholesky produced non-finite values "
+                f"with percdamp={percdamp}."
+            )
+
+        diag = torch.diag(hinv)
+        if not torch.isfinite(diag).all() or torch.any(diag <= 0):
+            raise RuntimeError(
+                "GPTQ Hessian inverse Cholesky has an invalid diagonal "
+                f"with percdamp={percdamp}."
+            )
+
+        median_diag = diag.abs().median().clamp_min(torch.finfo(hinv.dtype).tiny)
+        max_abs = hinv.abs().max()
+        if max_abs / median_diag > instability_ratio:
+            raise RuntimeError(
+                "GPTQ Hessian inverse Cholesky appears numerically unstable: "
+                f"max_abs={max_abs.item():.4e}, "
+                f"median_diag={median_diag.item():.4e}, "
+                f"percdamp={percdamp}."
+            )
+
+    def _damping_precheck(
+        self, h: torch.Tensor, percdamp: float
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Validate damping inputs; return the diagonal index and its mean."""
+        if percdamp <= 0:
+            raise ValueError(f"percdamp must be positive. got {percdamp}")
+        diag = torch.arange(self.columns, device=self.dev)
+        diag_mean = torch.mean(torch.diag(h))
+        if not torch.isfinite(diag_mean) or diag_mean <= 0:
+            raise RuntimeError(
+                "GPTQ Hessian has a non-positive or non-finite diagonal mean "
+                f"before damping: {diag_mean.item()}."
+            )
+        return diag, diag_mean
+
+    def _factorize_hessian_inverse_once(
+        self,
+        h: torch.Tensor,
+        diag: torch.Tensor,
+        diag_mean: torch.Tensor,
+        percdamp: float,
+    ) -> torch.Tensor:
+        """Run one attempt; keep its temporary tensors in this frame only."""
+        h_try = h.clone()
+        h_try[diag, diag] += percdamp * diag_mean
+        chol = torch.linalg.cholesky(h_try)
+        del h_try
+        hinv = torch.cholesky_inverse(chol)
+        del chol
+        hinv = torch.linalg.cholesky(hinv, upper=True)
+        self._validate_hinv(hinv, percdamp)
+        return hinv
+
+    def _factorize_hessian_inverse(
+        self,
+        h: torch.Tensor,
+        percdamp: float,
+        percdamp_max: Optional[float] = None,
+        retry_factor: float = 2.5,
+        max_retries: int = 5,
+    ) -> torch.Tensor:
+        """Retry auto-mode factorization without retaining failed attempts."""
+        if percdamp_max is None:
+            raise ValueError(
+                "percdamp_max is required for the retry path; the static "
+                "single-attempt path is inlined in fasterquant."
+            )
+        if percdamp_max < percdamp:
+            raise ValueError(
+                "percdamp_max must be >= percdamp. " f"got {percdamp_max} < {percdamp}"
+            )
+
+        diag, diag_mean = self._damping_precheck(h, percdamp)
+
+        cur_percdamp = float(percdamp)
+        ceiling = float(percdamp_max)
+        attempts = 0
+        last_error_text = ""
+
+        while True:
+            attempts += 1
+            try:
+                hinv = self._factorize_hessian_inverse_once(
+                    h, diag, diag_mean, cur_percdamp
+                )
+            except torch.OutOfMemoryError:
+                # Damping cannot fix an OOM. Preserve the original exception.
+                raise
+            except RuntimeError as exc:
+                # Keep diagnostic text only, not the exception or traceback.
+                # Python clears `exc` when this handler exits, allowing the
+                # failed helper frame and its temporaries to be released
+                # before the next attempt allocates anything.
+                last_error_text = f"{type(exc).__name__}: {exc}"
+            else:
+                self.percdamp_used = cur_percdamp
+                return hinv
+
+            # Keep the existing escalation policy and final ceiling attempt.
+            if cur_percdamp >= ceiling:
+                break
+            if attempts >= max_retries:
+                cur_percdamp = ceiling
+            else:
+                cur_percdamp = min(ceiling, cur_percdamp * retry_factor)
+
+        raise RuntimeError(
+            "GPTQ Hessian factorization failed or became numerically unstable "
+            f"after {attempts} attempt(s). "
+            f"start_percdamp={percdamp}, last_percdamp={cur_percdamp}, "
+            f"retry_ceiling={percdamp_max}. "
+            "The final attempt used the configured retry ceiling. "
+            "Increase percdamp or raise the retry ceiling "
+            "(auto_percdamp_retry_max). "
+            f"Last error: {last_error_text}"
+        ) from None
+
     @torch.no_grad()
     def fasterquant(
         self,
         blocksize: int = 128,
         percdamp: float = 0.01,
+        percdamp_max: Optional[float] = None,
         groupsize: int = -1,
         actorder: bool = False,
         static_groups: bool = False,
@@ -517,7 +654,12 @@ class GPTQ:
 
         Args:
             blocksize: Number of columns processed at a time.
-            percdamp: Damping factor relative to the average Hessian diagonal.
+            percdamp: Starting damping factor relative to the average Hessian
+                diagonal.
+            percdamp_max: Optional retry ceiling. If factorization fails or
+                the inverse looks unstable, damping is increased geometrically
+                up to this value. This is a retry ceiling, independent of any
+                clamp the caller applied to ``percdamp``.
             groupsize: Group size for grouped quantization. -1 disables grouping.
             actorder: Whether to reorder columns by Hessian diagonal magnitude.
             static_groups: Whether to precompute group quantizers.
@@ -587,13 +729,36 @@ class GPTQ:
         losses = torch.zeros_like(w)
         q_all = 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)
-        h = torch.cholesky_inverse(h)
-        h = torch.linalg.cholesky(h, upper=True)
-        hinv = h
+        if percdamp_max is None:
+            # Static single attempt: in-place factorization.
+            diag, diag_mean = self._damping_precheck(h, percdamp)
+            try:
+                h[diag, diag] += percdamp * diag_mean
+                chol = torch.linalg.cholesky(h)
+                del h  # release the damped Hessian before building the inverse
+                hinv = torch.cholesky_inverse(chol)
+                del chol  # release the lower factor before the final Cholesky
+                hinv = torch.linalg.cholesky(hinv, upper=True)
+                self._validate_hinv(hinv, percdamp)
+                self.percdamp_used = float(percdamp)
+            except torch.OutOfMemoryError:
+                raise
+            except RuntimeError as exc:
+                raise RuntimeError(
+                    "GPTQ Hessian factorization failed or became numerically "
+                    f"unstable after 1 attempt(s). start_percdamp={percdamp}, "
+                    f"last_percdamp={percdamp}, retry_ceiling=None. "
+                    "No retry ceiling was provided (static percdamp_mode). "
+                    "Increase percdamp or enable percdamp_mode='auto' with "
+                    "auto_percdamp_retry_max."
+                ) from exc
+        else:
+            hinv = self._factorize_hessian_inverse(
+                h,
+                percdamp=percdamp,
+                percdamp_max=percdamp_max,
+            )
+            del h  # the undamped original is no longer needed after retries
 
         # GPTQv2: Compute P correction matrix from dXXT
         P = None