tico 0.4.0.dev261021__tar.gz → 0.4.0.dev261024__tar.gz

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

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

tico-0.4.0.dev261024/tico/_version.py

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

{tico-0.4.0.dev261021 → tico-0.4.0.dev261024}/tico/circle/analysis/tensor_contract.py

@@ -26,6 +26,7 @@ from tico.circle._object import (
     vector_as_tuple,
 )
 from tico.circle.errors import CircleValueError
+from tico.circle.value.dtype import is_mx_tensor_type
 from tico.circle.value.tensor import TensorQuantization, TensorValue
 
 
@@ -252,6 +253,14 @@ class TensorContract:
                     raise CircleValueError(
                         "Static shape signature dimensions must match shape values."
                     )
+        if (
+            self.quantization is not None
+            and is_mx_tensor_type(self.tensor_type)
+            and self.quantization.quantized_dimension >= self.rank
+        ):
+            raise CircleValueError(
+                "MX quantized_dimension must be within the tensor rank."
+            )
         if self.quantization is not None and self.quantization.scale:
             if self.rank == 0 and len(self.quantization.scale) > 1:
                 raise CircleValueError(

{tico-0.4.0.dev261021 → tico-0.4.0.dev261024}/tico/circle/passes/optimization/simplify/transpose_region.py

@@ -29,6 +29,7 @@ from tico.circle.passes.optimization.simplify._layout_utils import (
     _is_transpose_op,
 )
 from tico.circle.rewrite import replace_tensor_uses
+from tico.circle.value.dtype import is_mx_tensor_type
 from .transpose_region_rules import (
     _ADD_BUILTIN_CODE,
     _OperatorRewritePlan,
@@ -171,9 +172,13 @@ def _permuted_shape(
 
 
 def _per_tensor_encoding(tensor: Any) -> _PerTensorEncoding | None:
-    """Return one tensor encoding, or None for per-channel activation qparams."""
+    """Return one encoding, excluding per-channel and MX activation qparams."""
 
     tensor_type = int(getattr(tensor, "type", 0))
+    # MX has no affine scale vector, but its block axis is layout-sensitive.
+    # Keep these regions until their internal qparams can be remapped safely.
+    if is_mx_tensor_type(tensor_type):
+        return None
     quantization = getattr(tensor, "quantization", None)
     if quantization is None:
         return _PerTensorEncoding(tensor_type, None, None)

{tico-0.4.0.dev261021 → tico-0.4.0.dev261024}/tico/circle/value/dtype.py

@@ -151,6 +151,16 @@ def circle_tensor_type_value(name: str) -> int:
     return int(getattr(enum_type, name))
 
 
+@lru_cache(maxsize=None)
+def is_mx_tensor_type(tensor_type: int) -> bool:
+    """Return whether a Circle tensor uses axis-sensitive MX block encoding."""
+
+    return int(tensor_type) in (
+        circle_tensor_type_value("MXINT8"),
+        circle_tensor_type_value("MXFP4"),
+    )
+
+
 @lru_cache(maxsize=1)
 def default_tensor_type_registry() -> TensorTypeRegistry:
     """Return codecs for the dense and four-bit tensor types used by TICO."""

{tico-0.4.0.dev261021 → tico-0.4.0.dev261024}/tico/quantization/passes/fold_quant_ops.py

@@ -18,10 +18,12 @@ if TYPE_CHECKING:
     import torch.fx
 
 import copy
+import operator
 
 import torch
 from torch.export import ExportedProgram
 
+from tico.quantization.passes.mx_qparam import remap_mx_qparam
 from tico.serialize.quant_param import QPARAM_KEY, QuantParam
 from tico.utils import logging
 from tico.utils.errors import NotYetSupportedError
@@ -29,6 +31,7 @@ from tico.utils.mx.dtypes import (
     assert_supported_mx_export_options,
     is_mx_dtype,
     mx_dtype_from_elem_format,
+    normalize_mx_axis,
     normalize_mx_elem_format,
 )
 from tico.utils.passes import PassBase, PassResult
@@ -45,6 +48,7 @@ _QPARAM_PRESERVING_VIEW_TARGETS = frozenset(
         torch.ops.aten.permute.default,
         torch.ops.aten.reshape.default,
         torch.ops.aten.slice.Tensor,
+        torch.ops.aten.expand.default,
     }
 )
 
@@ -101,7 +105,7 @@ def _restore_float_inputs(graph: torch.fx.Graph) -> None:
 
 
 def _inherit_qparam_from_view_chain(node: torch.fx.Node) -> bool:
-    """Seed an unfused per-tensor view chain with its source qparams.
+    """Seed a view chain with its source's affine or remapped MX domain.
 
     ``FoldQuantOps`` runs before ``PropagateQParamForward``.  A
     requantization after a slice/view chain must therefore discover
@@ -110,8 +114,8 @@ def _inherit_qparam_from_view_chain(node: torch.fx.Node) -> bool:
     the target Q-DQ pair can be folded into RESHAPE and the required Quantize
     operation disappears.
 
-    Only per-tensor qparams are propagated.  Per-channel propagation
-    would require axis remapping through PERMUTE and RESHAPE.
+    MX views must preserve the shared-exponent blocks. Affine per-channel
+    propagation is not handled here.
     """
     if QPARAM_KEY in node.meta:
         return False
@@ -134,30 +138,52 @@ def _inherit_qparam_from_view_chain(node: torch.fx.Node) -> bool:
                 _inherit_qparam_from_view_chain(source)
             qparams = [source.meta.get(QPARAM_KEY) for source in sources]
             first_qparam = qparams[0]
+            if first_qparam is None or any(qparam is None for qparam in qparams):
+                return False
+            if is_mx_dtype(first_qparam.dtype):
+                current.meta[QPARAM_KEY] = remap_mx_qparam(first_qparam, current)
+            else:
+                if first_qparam.quantized_dimension is not None or any(
+                    qparam != first_qparam for qparam in qparams[1:]
+                ):
+                    return False
+                current.meta[QPARAM_KEY] = copy.deepcopy(first_qparam)
+            break
+        if current.target == operator.getitem:
+            split = current.args[0]
             if (
-                first_qparam is None
-                or first_qparam.quantized_dimension is not None
-                or any(qparam != first_qparam for qparam in qparams[1:])
+                not isinstance(split, torch.fx.Node)
+                or split.target != torch.ops.aten.split_with_sizes.default
             ):
                 return False
-            current.meta[QPARAM_KEY] = copy.deepcopy(first_qparam)
-            break
-        if current.target not in _QPARAM_PRESERVING_VIEW_TARGETS:
-            return False
-        if not current.args:
+            source = split.args[0]
+        elif current.target in _QPARAM_PRESERVING_VIEW_TARGETS or current.target == (
+            torch.ops.aten.constant_pad_nd.default
+        ):
+            source = current.args[0]
+        else:
             return False
-
-        source = current.args[0]
         if not isinstance(source, torch.fx.Node):
             return False
         chain.append(current)
         current = source
 
     source_qparam: QuantParam = current.meta[QPARAM_KEY]
-    if source_qparam.quantized_dimension is not None:
+    if source_qparam.quantized_dimension is not None and not is_mx_dtype(
+        source_qparam.dtype
+    ):
+        return False
+    if not is_mx_dtype(source_qparam.dtype) and any(
+        view.target in {operator.getitem, torch.ops.aten.constant_pad_nd.default}
+        for view in chain
+    ):
         return False
 
     for view in reversed(chain):
+        if is_mx_dtype(source_qparam.dtype):
+            mapped = remap_mx_qparam(source_qparam, view)
+            assert mapped is not None
+            source_qparam = mapped
         view.meta[QPARAM_KEY] = copy.deepcopy(source_qparam)
     return bool(chain)
 
@@ -167,7 +193,14 @@ def _mx_op_params(node) -> tuple[str, int, str, str]:
     assert len(node.args) >= 3
     elem_format = normalize_mx_elem_format(node.args[1])
     axis = node.args[2]
-    assert isinstance(axis, int)
+    source = node.args[0]
+    assert isinstance(source, torch.fx.Node)
+    # DecomposeFakeQuantize may not have refreshed the new Q node's value
+    # metadata yet. Q/DQ preserve shape, so use the quantizer's real input.
+    if node.target == torch.ops.circle_custom.dequantize_mx.default:
+        source = source.args[0]
+        assert isinstance(source, torch.fx.Node)
+    axis = normalize_mx_axis(axis, source.meta["val"].ndim)
     shared_exp_method = node.kwargs.get(
         "shared_exp_method", node.args[3] if len(node.args) > 3 else "max"
     )
@@ -202,6 +235,51 @@ def _same_mx_qparam(lhs: QuantParam, rhs: QuantParam) -> bool:
     )
 
 
+def _fold_mx_qdq(dq: torch.fx.Node) -> None:
+    """Fold an MX pair only after resolving its producer's existing domain."""
+    q = dq.args[0]
+    if not isinstance(q, torch.fx.Node):
+        return
+    if q.target != torch.ops.circle_custom.quantize_mx.default:
+        return
+    op = q.args[0]
+    if not isinstance(op, torch.fx.Node):
+        return
+    if _mx_op_params(q) != _mx_op_params(dq):
+        return
+
+    _inherit_qparam_from_view_chain(op)
+    qparam = _mx_qparam_from_quant_node(q)
+    existing = op.meta.get(QPARAM_KEY)
+    if existing is None:
+        # An explicit quantizer on a shared float value must not change its
+        # other users. Layout ops also cannot quantize their own inputs.
+        layout_output = op.target in _QPARAM_PRESERVING_VIEW_TARGETS or op.target in {
+            torch.ops.aten.cat.default,
+            torch.ops.aten.constant_pad_nd.default,
+            operator.getitem,
+        }
+        if (
+            layout_output
+            or op.target == torch.ops.aten.embedding.default
+            or any(user is not q for user in op.users)
+        ):
+            if not layout_output:
+                op.meta[_PRESERVE_FLOAT_INPUTS_KEY] = True
+            q.meta[QPARAM_KEY] = qparam
+            dq.replace_all_uses_with(q, propagate_meta=False)
+        else:
+            op.meta[QPARAM_KEY] = qparam
+            dq.replace_all_uses_with(op, propagate_meta=False)
+    elif _same_mx_qparam(existing, qparam):
+        dq.replace_all_uses_with(op, propagate_meta=False)
+    else:
+        # A different axis or element format requires an explicit QUANTIZE,
+        # even when both sides use the same MX dtype.
+        q.meta[QPARAM_KEY] = qparam
+        dq.replace_all_uses_with(q, propagate_meta=False)
+
+
 @trace_graph_diff_on_pass
 class FoldQuantOps(PassBase):
     """
@@ -227,7 +305,8 @@ class FoldQuantOps(PassBase):
 
     Algorithm
     ---------
-    1. Iterate over *all* Dequantize nodes.
+    1. Iterate over affine and MX Dequantize nodes in graph order, so mixed
+       quantization boundaries see the preceding domain.
     2. For each DQ, verify it is driven by a Quantize node `q` and that
        `q` and `dq` share identical (scale, zero-point, dtype).
     3. a) If the producer op has **no** QPARAM, attach one, then replace
@@ -251,7 +330,8 @@ class FoldQuantOps(PassBase):
 
     Discover an existing source domain through slices, views, and same-domain
     concatenations before deciding whether a trailing Q is a requantization.
-    A float producer behind a layout view can still adopt its first Q domain.
+    A float producer behind a layout view can still adopt its first affine Q
+    domain. MX keeps an explicit Q after an unquantized layout operation.
     """
 
     def __init__(self):
@@ -265,6 +345,9 @@ class FoldQuantOps(PassBase):
         for dq in graph.nodes:
             if dq.op != "call_function":
                 continue
+            if dq.target == torch.ops.circle_custom.dequantize_mx.default:
+                _fold_mx_qdq(dq)
+                continue
             if (
                 dq.target
                 != torch.ops.quantized_decomposed.dequantize_per_tensor.default
@@ -344,44 +427,6 @@ class FoldQuantOps(PassBase):
                     dq.replace_all_uses_with(op, propagate_meta=False)
                     logger.debug(f"Removed redundant {dq.name}")
 
-        for dq in graph.nodes:
-            if dq.op != "call_function":
-                continue
-            if dq.target != torch.ops.circle_custom.dequantize_mx.default:
-                continue
-
-            q = dq.args[0]
-            if not isinstance(q, torch.fx.Node):
-                continue
-            if q.target != torch.ops.circle_custom.quantize_mx.default:
-                continue
-
-            source = q.args[0]
-            if not isinstance(source, torch.fx.Node):
-                continue
-            op = source
-
-            if _mx_op_params(q) != _mx_op_params(dq):
-                continue
-
-            qparam = _mx_qparam_from_quant_node(q)
-
-            if QPARAM_KEY not in op.meta:
-                op.meta[QPARAM_KEY] = qparam
-                dq.replace_all_uses_with(op, propagate_meta=False)
-                logger.debug(f"{q.name} and {dq.name} are folded to {op.name}.")
-            else:
-                op_qparam = op.meta[QPARAM_KEY]
-                if not _same_mx_qparam(op_qparam, qparam):
-                    if QPARAM_KEY not in q.meta:
-                        q.meta[QPARAM_KEY] = qparam
-                        assert len(q.users) == 1, "Fix me unless"
-                    dq.replace_all_uses_with(q, propagate_meta=False)
-                    logger.debug(f"{dq.name} is folded ({q.name} is left).")
-                else:
-                    dq.replace_all_uses_with(op, propagate_meta=False)
-                    logger.debug(f"Removed redundant {dq.name}")
-
         _restore_float_inputs(graph)
         graph.eliminate_dead_code()
         graph.lint()

tico-0.4.0.dev261024/tico/quantization/passes/mx_qparam.py

@@ -0,0 +1,270 @@
+# Copyright (c) 2026 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.
+
+"""Preserve MX block membership when tensor layouts change."""
+
+from __future__ import annotations
+
+import copy
+import math
+import operator
+from typing import cast
+
+import torch
+
+from tico.serialize.quant_param import QPARAM_KEY, QuantParam
+from tico.utils.errors import NotYetSupportedError
+from tico.utils.mx.dtypes import is_mx_dtype, normalize_mx_axis
+from tico.utils.validate_args_kwargs import (
+    CatArgs,
+    PermuteArgs,
+    SliceArgs,
+    SplitWithSizesArgs,
+)
+
+
+_MX_BLOCK_SIZE = 32
+
+
+def _axis(qparam: QuantParam, rank: int) -> int:
+    if qparam.quantized_dimension is None:
+        raise ValueError("MX qparams require an explicit quantized dimension.")
+    return normalize_mx_axis(qparam.quantized_dimension, rank)
+
+
+def _shape(node: torch.fx.Node, *, static: bool = False) -> tuple:
+    shape = getattr(node.meta.get("val"), "shape", None)
+    if shape is None:
+        raise NotYetSupportedError(
+            f"MX axis propagation requires tensor shape metadata for {node.name}."
+        )
+    shape = tuple(shape)
+    if static and any(type(size) is not int or size <= 0 for size in shape):
+        raise NotYetSupportedError(
+            "MX block-preserving layout changes require positive static dimensions; "
+            f"{node.name} has shape {shape}."
+        )
+    return shape
+
+
+def _unsupported(node: torch.fx.Node, reason: str) -> NotYetSupportedError:
+    return NotYetSupportedError(
+        f"Cannot preserve MX blocks through {node.name} ({node.target}): {reason}. "
+        "An explicit dequantize/requantize boundary is required."
+    )
+
+
+def _reshape_axis(
+    input_shape: tuple,
+    output_shape: tuple,
+    axis: int,
+    node: torch.fx.Node,
+) -> int:
+    """Find an output axis with exactly the same flat-index block partition.
+
+    The trailing-element stride fixes the spacing between block members. Axis
+    lengths may differ only when both reset at complete 32-element boundaries.
+    This permits splitting/merging heads with aligned head dimensions without
+    allowing an arbitrary reshape to regroup already quantized values.
+    """
+    if math.prod(input_shape) != math.prod(output_shape):
+        raise _unsupported(node, "reshape changes the number of elements")
+    length = input_shape[axis]
+    stride = math.prod(input_shape[axis + 1 :])
+    for output_axis, output_length in enumerate(output_shape):
+        if math.prod(output_shape[output_axis + 1 :]) != stride:
+            continue
+        if length == output_length or (
+            length % _MX_BLOCK_SIZE == 0 and output_length % _MX_BLOCK_SIZE == 0
+        ):
+            return output_axis
+    raise _unsupported(
+        node,
+        f"reshape {input_shape} -> {output_shape} changes the groups on axis {axis}",
+    )
+
+
+def _check_slice(
+    node: torch.fx.Node, length: int, start: int, end: int, step: int
+) -> None:
+    if (
+        step != 1
+        or start % _MX_BLOCK_SIZE != 0
+        or (end % _MX_BLOCK_SIZE != 0 and end != length)
+    ):
+        raise _unsupported(
+            node,
+            f"slice [{start}:{end}:{step}] cuts or regroups an MX block",
+        )
+
+
+def _cat_axis(qparam: QuantParam, node: torch.fx.Node, *, backward: bool) -> int:
+    args = CatArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+    output_shape = _shape(node, static=True)
+    axis = _axis(qparam, len(output_shape))
+    dim = normalize_mx_axis(args.dim, len(output_shape))
+    if not args.tensors:
+        raise _unsupported(node, "concatenation has no tensor inputs")
+    for index, source in enumerate(args.tensors):
+        shape = _shape(source, static=True)
+        if len(shape) != len(output_shape):
+            raise _unsupported(node, "concatenation input ranks differ")
+        if not backward:
+            source_qparam = source.meta.get(QPARAM_KEY)
+            if (
+                source_qparam is None
+                or source_qparam.dtype != qparam.dtype
+                or _axis(source_qparam, len(shape)) != axis
+            ):
+                raise _unsupported(
+                    node, "concatenation inputs use different MX domains"
+                )
+        if (
+            dim == axis
+            and index < len(args.tensors) - 1
+            and shape[axis] % _MX_BLOCK_SIZE != 0
+        ):
+            raise _unsupported(node, "concatenation joins incomplete MX blocks")
+    return axis
+
+
+def remap_mx_split_output(
+    qparam: QuantParam,
+    split: torch.fx.Node,
+    index: int,
+) -> QuantParam | None:
+    """Return one split output's MX domain, including an unused output slot."""
+    if not is_mx_dtype(qparam.dtype):
+        return None
+    if split.target != torch.ops.aten.split_with_sizes.default:
+        raise _unsupported(split, "only split_with_sizes outputs are supported")
+    args = SplitWithSizesArgs(*split.args, **split.kwargs)  # type: ignore[arg-type]
+    shape = _shape(args.input, static=True)
+    axis = _axis(qparam, len(shape))
+    dim = normalize_mx_axis(args.dim, len(shape))
+    if any(type(size) is not int or size <= 0 for size in args.split_sizes):
+        raise _unsupported(split, "split requires positive static sizes")
+    sizes = cast(list[int], args.split_sizes)
+    if sum(sizes) != shape[dim]:
+        raise _unsupported(split, "split sizes do not cover its input dimension")
+    if type(index) is not int or not -len(sizes) <= index < len(sizes):
+        raise _unsupported(split, "split output index is invalid")
+    index %= len(sizes)
+    if dim == axis:
+        start = sum(sizes[:index])
+        _check_slice(split, shape[axis], start, start + sizes[index], 1)
+    result = copy.deepcopy(qparam)
+    result.quantized_dimension = axis
+    return result
+
+
+def remap_mx_qparam(
+    qparam: QuantParam,
+    node: torch.fx.Node,
+    *,
+    backward: bool = False,
+) -> QuantParam | None:
+    """Copy MX metadata across a proven block-preserving layout operation.
+
+    ``qparam`` belongs to the input in the forward direction, or to ``node``
+    in the backward direction. Affine qparams return ``None`` so callers retain
+    their existing affine policy. Unsupported MX transformations raise rather
+    than silently losing quantization or assigning a different block partition.
+
+    Split outputs are represented by their ``getitem`` nodes. Concatenation
+    requires matching input domains in the forward direction. The returned
+    metadata always uses a nonnegative tensor axis and never aliases the input.
+    """
+    if not is_mx_dtype(qparam.dtype):
+        return None
+
+    if node.target == torch.ops.aten.cat.default:
+        axis = _cat_axis(qparam, node, backward=backward)
+    elif node.target == operator.getitem:
+        split = node.args[0]
+        if (
+            backward
+            or not isinstance(split, torch.fx.Node)
+            or split.target != torch.ops.aten.split_with_sizes.default
+        ):
+            raise _unsupported(node, "only forward split outputs are supported")
+        index = node.args[1]
+        if not isinstance(index, int):
+            raise _unsupported(node, "split output index is invalid")
+        return remap_mx_split_output(qparam, split, index)
+    else:
+        source = node.args[0] if node.args else None
+        if not isinstance(source, torch.fx.Node):
+            raise _unsupported(node, "tensor input is unavailable")
+        input_shape = _shape(source)
+        output_shape = _shape(node)
+        shape = output_shape if backward else input_shape
+        axis = _axis(qparam, len(shape))
+
+        if node.target == torch.ops.aten.permute.default:
+            permute_args = PermuteArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+            rank = len(input_shape)
+            dims = [normalize_mx_axis(dim, rank) for dim in permute_args.dims]
+            if len(dims) != rank or len(set(dims)) != rank:
+                raise _unsupported(node, "permutation is not a bijection")
+            axis = dims[axis] if backward else dims.index(axis)
+        elif node.target == torch.ops.aten.reshape.default:
+            input_shape = _shape(source, static=True)
+            output_shape = _shape(node, static=True)
+            if backward:
+                input_shape, output_shape = output_shape, input_shape
+            axis = _reshape_axis(input_shape, output_shape, axis, node)
+        elif node.target == torch.ops.aten.slice.Tensor and not backward:
+            slice_args = SliceArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+            input_shape = _shape(source, static=True)
+            dim = normalize_mx_axis(slice_args.dim, len(input_shape))
+            if dim == axis:
+                start, end, step = slice(
+                    slice_args.start, slice_args.end, slice_args.step
+                ).indices(input_shape[axis])
+                _check_slice(node, input_shape[axis], start, end, step)
+        elif node.target == torch.ops.aten.expand.default and not backward:
+            input_shape = _shape(source, static=True)
+            output_shape = _shape(node, static=True)
+            offset = len(output_shape) - len(input_shape)
+            if offset < 0 or any(
+                size != 1 and size != output_shape[index + offset]
+                for index, size in enumerate(input_shape)
+            ):
+                raise _unsupported(node, "expand is not a broadcast of its input")
+            # Expanding a singleton MX axis repeats the same value in each new
+            # block; its exponent and rounded value therefore remain unchanged.
+            axis += offset
+        elif node.target == torch.ops.aten.constant_pad_nd.default and not backward:
+            input_shape = _shape(source, static=True)
+            pads = node.args[1]
+            value = node.kwargs.get("value", node.args[2] if len(node.args) > 2 else 0)
+            if (
+                not isinstance(pads, (tuple, list))
+                or len(pads) % 2
+                or len(pads) > 2 * len(input_shape)
+                or any(type(pad) is not int or pad < 0 for pad in pads)
+                or value != 0
+            ):
+                raise _unsupported(node, "only nonnegative zero padding is supported")
+            pads = cast(list[int], pads)
+            pair = len(input_shape) - 1 - axis
+            if pair < len(pads) // 2 and pads[2 * pair] % _MX_BLOCK_SIZE != 0:
+                raise _unsupported(node, "padding shifts the start of an MX block")
+        else:
+            raise _unsupported(node, "operation has no MX block-preservation rule")
+
+    result = copy.deepcopy(qparam)
+    result.quantized_dimension = axis
+    return result