tico 0.1.0__py3-none-any.whl

tico/passes/decompose_grouped_conv2d.py

@@ -0,0 +1,209 @@
+# 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 torch
+from torch.export import ExportedProgram
+
+from tico.passes import ops
+from tico.serialize.circle_mapping import extract_shape
+from tico.utils import logging
+from tico.utils.errors import InvalidArgumentError, NotYetSupportedError
+from tico.utils.graph import add_placeholder, 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 is_target_node
+from tico.utils.validate_args_kwargs import Conv2DArgs
+
+
+@trace_graph_diff_on_pass
+class DecomposeGroupedConv2d(PassBase):
+    """
+    This pass decomposes grouped Conv2d operator as multiple Conv2d operator whose groups=1.
+
+    Grouped Conv2d denotes a Conv2d operator whose `groups` argument is not equal to input channels nor 1.
+
+    [before]
+
+        input       weight       bias
+          |           |           |
+          +-----------+-----------+
+                      |
+                    Conv2d (groups != IN_CHANNEL && groups != 1)
+                      |
+                    output
+
+    [after]
+
+    The below `slice` operators slice the input tensor, weight and bias along the channel axis by the number of `groups`.
+    In addition, the numbered input, weight and bias denotes sliced input tensor, weight and bias respectively.
+
+        input
+          |       weight
+        slice       |        bias
+          |       slice       |
+          |         |       slice
+          |         |         |
+          +---------------------------+---------------------------+
+          |         |         |       |                           |
+          |         +---------------------------+---------------------------+
+          |         |         |       |         |                 |         |
+          |         |         +---------------------------+---------------------------+
+          |         |         |       |         |         |       |         |         |
+        input_1     |         |      ...        |         |     input_N     |         |
+          |      weight_1     |       |        ...        |       |      weight_N     |
+          |         |       bias_1    |         |        ...      |         |       bias_N
+          +---------+---------+       +---------+---------+       +---------+---------+
+                    |                           |                           |
+                Conv2d_1                       ...                      Conv2d_N
+                    |                           |                           |
+                    +---------------------------+---------------------------+
+                                                |
+                                              concat
+                                                |
+                                              output
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def call(self, exported_program: ExportedProgram) -> PassResult:
+        logger = logging.getLogger(__name__)
+
+        gm = exported_program.graph_module
+        graph: torch.fx.Graph = gm.graph
+        modified = False
+
+        for node in graph.nodes:
+            if not is_target_node(node, ops.aten.conv2d):
+                continue
+
+            args = Conv2DArgs(*node.args)
+            input_ = args.input
+            weight = args.weight
+            bias = args.bias
+            stride = args.stride
+            padding = args.padding
+            dilation = args.dilation
+            groups = args.groups
+
+            input_shape = extract_shape(input_)
+            if not len(input_shape) == 4:
+                raise NotYetSupportedError(
+                    f"Only support 4D input tensor: node's input shape: {input_shape}"
+                )
+
+            in_channels = input_shape[1]
+            if groups == 1 or groups == in_channels:
+                continue
+            assert (
+                in_channels % groups == 0
+            ), f"in_channels should be divisible by groups: in_channels: {in_channels}, groups: {groups}"
+
+            output_shape = extract_shape(node)
+            assert len(output_shape) == 4, len(output_shape)
+
+            out_channels = output_shape[1]
+            assert (
+                out_channels % groups == 0
+            ), f"out_channels should be divisible by groups: out_channels: {out_channels}, groups: {groups}"
+
+            weight_shape = extract_shape(weight)
+            assert len(weight_shape) == 4, len(weight_shape)
+            assert (
+                weight_shape[0] == out_channels
+            ), f"weight shape[0]: {weight_shape[0]}, out channels: {out_channels}"
+            assert (
+                weight_shape[1] == in_channels // groups
+            ), f"weight shape[1]: {weight_shape[1]}, in channels: {in_channels}"
+
+            if bias is not None:
+                bias_shape = extract_shape(bias)
+                assert (
+                    bias_shape[0] == out_channels
+                ), f"bias shape[0]: {bias_shape[0]}, out channels: {out_channels}"
+            else:  # Make dummy bias tensor
+                bias = add_placeholder(
+                    exported_program, torch.zeros(out_channels), "bias"
+                )
+
+            group_size = in_channels // groups
+            out_group_size = out_channels // groups
+
+            with gm.graph.inserting_before(node):
+                conv2d_op = None
+                if isinstance(padding, list) and all(
+                    isinstance(element, int) for element in padding
+                ):
+                    conv2d_op = torch.ops.aten.conv2d.default
+                elif isinstance(padding, str):
+                    conv2d_op = torch.ops.aten.conv2d.padding
+                else:
+                    raise InvalidArgumentError(
+                        f"Unsupported padding type: {padding}"
+                    )  # Unreachable to here
+
+                conv2d_tensors = []
+                for i in range(groups):
+                    sliced_input = create_node(
+                        graph,
+                        torch.ops.aten.slice.Tensor,
+                        (input_, 1, group_size * i, group_size * (i + 1), 1),
+                        origin=node,
+                    )
+                    sliced_weight = create_node(
+                        graph,
+                        torch.ops.aten.slice.Tensor,
+                        (weight, 0, out_group_size * i, out_group_size * (i + 1), 1),
+                        origin=node,
+                    )
+                    sliced_bias = create_node(
+                        graph,
+                        torch.ops.aten.slice.Tensor,
+                        (bias, 0, out_group_size * i, out_group_size * (i + 1), 1),
+                        origin=node,
+                    )
+                    conv2d_tensor = create_node(
+                        graph,
+                        conv2d_op,
+                        (
+                            sliced_input,
+                            sliced_weight,
+                            sliced_bias,
+                            stride,
+                            padding,
+                            dilation,
+                            1,
+                        ),
+                        origin=node,
+                    )
+                    conv2d_tensors.append(conv2d_tensor)
+
+                concat_output = create_node(
+                    graph, torch.ops.aten.cat.default, (conv2d_tensors, 1)
+                )
+
+                node.replace_all_uses_with(concat_output, propagate_meta=True)
+
+            modified = True
+            logger.debug(
+                f"{node.name} is replaced with groups of conv2d: The number of groups: {groups}, groups size: {group_size}"
+            )
+
+        graph.eliminate_dead_code()
+        gm.recompile()
+        return PassResult(modified)

tico/passes/decompose_slice_scatter.py

@@ -0,0 +1,169 @@
+# 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 dataclasses import dataclass
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch.fx
+import torch
+from torch.export import ExportedProgram
+
+from tico.serialize.circle_mapping import extract_shape
+
+from tico.utils import logging
+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 enforce_type, is_target_node
+
+
+@trace_graph_diff_on_pass
+class DecomposeSliceScatter(PassBase):
+    """
+    Let's decompose slice_scatter.default to cat.
+
+    slice_scatter with step=1 embeds src tensor to input tensor
+    We can replace it with (1) slicing input tensors and (2) concatenating all tensors
+
+    [1] When step = 1,
+
+        (1) Split input to input_0 and input_1 (either of them can be zero-size)
+        (2) Concatenate input_0, src, input_1
+
+        Before)
+
+            input                  src
+            |                      |
+            |                      |
+            |                      |
+            +--> slice_scatter <---+
+
+        After)
+
+            input
+            |-------------------------
+            |                         |
+            |                         |
+            |                         |
+            slice_copy                slice_copy
+            |                         |
+            |                         |
+            |                         |
+            slice_0*      src          slice_1*
+            |            |            |
+            |            |            |
+            |            |            |
+            +---------> cat <---------+
+
+            *Either of slice_0 or slice_1 could be empty. Then it's ignored.
+
+    [2] When step > 1, not supported yet. (TBD)
+    """
+
+    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
+        modified = False
+
+        for node in graph.nodes:
+            if not is_target_node(node, torch.ops.aten.slice_scatter.default):
+                continue
+
+            @enforce_type
+            @dataclass
+            class Args:
+                """
+                input (Tensor) the input tensor.
+                src (Tensor) The tensor to embed into input
+                dim (int) the dimension to insert the slice into
+                start (Optional[int]) the start index of where to insert the slice
+                end (Optional[int]) the end index of where to insert the slice
+                step (int) the how many elements to skip in
+                """
+
+                input: torch.fx.Node
+                src: torch.fx.Node
+                dim: int = 0
+                start: Optional[int] = None
+                end: Optional[int] = None
+                step: int = 1
+
+            args = Args(*node.args, **node.kwargs)  # type: ignore[arg-type]
+
+            input = args.input
+            src = args.src
+            dim = args.dim
+            s = args.start
+            e = args.end
+            step = args.step
+
+            # TODO Support step > 1 cases
+            if step > 1:
+                raise RuntimeError(
+                    f"slice_scatter with step > 1 is not yet supported. Node: {node}"
+                )
+
+            start: int = 0 if s is None else s
+            end: int = (
+                extract_shape(src)[dim]
+                if e is None
+                else min(extract_shape(src)[dim], e)
+            )
+
+            with graph.inserting_before(node):
+                slices = []
+
+                if 0 < start:
+                    slice_0 = create_node(
+                        graph,
+                        torch.ops.aten.slice_copy.Tensor,
+                        args=(input, dim, 0, start, 1),
+                        origin=node,
+                    )
+                    slices.append(slice_0)
+
+                slices.append(src)
+
+                if start + end < extract_shape(input)[dim]:
+                    slice_1 = create_node(
+                        graph,
+                        torch.ops.aten.slice_copy.Tensor,
+                        args=(
+                            input,
+                            dim,
+                            start + end,
+                            extract_shape(input)[dim],
+                            1,
+                        ),
+                        origin=node,
+                    )
+                    slices.append(slice_1)
+
+                concat = create_node(
+                    graph, torch.ops.aten.cat.default, args=(slices, dim)
+                )
+                node.replace_all_uses_with(concat, propagate_meta=True)
+
+            modified = True
+            logger.debug(f"{node.name} is replaced with slice_copy + concat")
+
+        graph.eliminate_dead_code()
+        graph_module.recompile()
+        return PassResult(modified)

tico/passes/extract_dtype_kwargs.py

@@ -0,0 +1,122 @@
+# 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 torch
+from torch.export import ExportedProgram
+from torch.utils import _pytree as pytree
+
+from tico.utils import logging
+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
+
+
+def _extract_to_output(node: torch.fx.Node, graph: torch.fx.Graph) -> bool:
+    """
+    This extracts dtype kwargs to node's output direction
+
+    So, op(..., dtype = X) is converted to op(...).to(X)
+
+    Return true if modified
+
+    NOTE
+
+    [1] This function always returns true. Return value is introduced for extension
+    [2] This conversion is not safe for some Ops whose inputs should also be casted to X (ex: Mean).
+
+    """
+    logger = logging.getLogger(__name__)
+
+    node_kwargs = node.kwargs
+    # Remove "dtype" from node's kwargs
+    new_kwargs = {}
+    for k, v in node_kwargs.items():
+        if k == "dtype":
+            continue
+        new_kwargs[k] = v
+    node.kwargs = new_kwargs
+    # Create new val for node
+    # `node.target()` needs only `Tensor` for its arguments. Therefore, let's retrieve `FakeTensor` if it is `torch.fx.Node`.
+    args, kwargs = pytree.tree_map_only(
+        torch.fx.Node, lambda x: x.meta["val"], (node.args, node.kwargs)
+    )
+    new_val = node.target(*args, **kwargs)  # type: ignore[operator]
+    # Set args, kwargs of `to_copy`
+    to_args = (node,)
+    to_kwargs = {"dtype": node_kwargs["dtype"]}
+    with graph.inserting_after(node):
+        to_copy = graph.call_function(torch.ops.aten._to_copy.default, (), {})
+        node.replace_all_uses_with(to_copy, propagate_meta=True)
+        # Q) Why lazy-update args, kwargs of the `to_copy`?
+        # A) `replace_all_uses_with` replace all the uses of `node`. If `to_copy` args is set to
+        #   (node, ) before `replace_all_uses_with`, the function would even replace the args of
+        #   `to_copy` with `to_copy`.
+        to_copy.args = to_args
+        to_copy.kwargs = to_kwargs
+        # Update meta["val"] to change dtype
+        node.meta["val"] = new_val
+
+    logger.debug(f"{node.name}'s dtype kwargs is extracted into {to_copy.name}")
+
+    return True
+
+
+@trace_graph_diff_on_pass
+class ExtractDtypeKwargsPass(PassBase):
+    """
+    This pass extracts "dtype" keyword argument from nodes.
+
+    Sometimes, torch api receives "dtype" keyword argument.
+
+    E.g. x_bool = torch.full_like(x, 0, dtype=torch.bool)
+
+    But, this argument makes circle build logic complicated because many operators has
+      same type with their inputs'.
+
+    So, this pass changes `op(dtype)` to `op + to(dtype)`.
+
+    NOTE
+
+    [1] There are some ops that are natural to have "dtype" kwargs. The pass is not applied to those ops.
+    [2] If node.kwargs["dtype"] is redundant `op(dtype).dtype == op().dtype`, the pass is not applied.
+
+    """
+
+    def __init__(self):
+        super().__init__()
+        # List of Ops whose "dtype" kwargs is extracted
+        self.target_ops = dict()
+        self.target_ops[torch.ops.aten.full_like.default] = _extract_to_output
+
+    def call(self, exported_program: ExportedProgram) -> PassResult:
+        graph_module = exported_program.graph_module
+        graph: torch.fx.Graph = graph_module.graph
+        modified = False
+        for node in graph.nodes:
+            if not is_target_node(node, list(self.target_ops.keys())):
+                continue
+            if "dtype" not in node.kwargs:
+                continue
+
+            modified |= self.target_ops[node.target](node, graph)
+
+        graph.eliminate_dead_code()
+        graph.lint()
+        graph_module.recompile()
+
+        return PassResult(modified)

tico/passes/fill_meta_val.py

@@ -0,0 +1,57 @@
+# 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 torch.export import ExportedProgram
+
+from tico.utils import logging
+from tico.utils.passes import PassBase, PassResult
+from tico.utils.trace_decorators import trace_graph_diff_on_pass
+from tico.utils.utils import set_new_meta_val
+
+
+@trace_graph_diff_on_pass
+class FillMetaVal(PassBase):
+    """
+    Let's set new meta['val'] for nodes which don't have meta['val']
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def call(self, exported_program: ExportedProgram) -> PassResult:
+        logger = logging.getLogger(__name__)
+
+        graph_module = exported_program.graph_module
+        graph = graph_module.graph
+        modified = False
+        # To make sure graph is topologically sorted
+        graph.lint()
+        for node in graph.nodes:
+            if not node.op == "call_function":
+                continue
+
+            if hasattr(node, "meta") and "val" in node.meta:
+                continue
+
+            set_new_meta_val(node)
+
+            modified = True
+
+            logger.debug(f"{node.name} has new meta values.")
+
+        graph.eliminate_dead_code()
+        graph.lint()
+        graph_module.recompile()
+
+        return PassResult(modified)

tico/passes/fuse_leading_unsqueeze_reshape.py

@@ -0,0 +1,112 @@
+# 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 Sequence
+
+import torch
+from torch.export import ExportedProgram
+
+from tico.passes import ops
+from tico.serialize.circle_mapping import extract_shape
+from tico.utils import logging
+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 is_target_node
+from tico.utils.validate_args_kwargs import PermuteArgs, ReshapeArgs
+
+
+def _is_leading_unsqueeze(target: Sequence[int], permuted: Sequence[int]) -> bool:
+    """
+    True if `target` == [1]*k + permuted,  k>=1.
+    """
+    k = len(target) - len(permuted)
+    return (
+        k > 0 and all(d == 1 for d in target[:k]) and list(target[k:]) == list(permuted)
+    )
+
+
+@trace_graph_diff_on_pass
+class FuseLeadingUnsqueezeReshape(PassBase):
+    """
+    Fuse reshape → permute → reshape where the second reshape only
+    prepends one-sized dims (unsqueeze) to the permuted tensor.
+
+    [BEFORE]
+        x - aten.reshape(s1) - aten.permute(p) - aten.reshape([1]*k + p(s1))
+    [AFTER]
+        x - aten.reshape([1]*k + s1) - aten.permute(list(range(k)) + [d+k for d in p])
+    """
+
+    def call(self, ep: ExportedProgram) -> PassResult:
+        logger = logging.getLogger(__name__)
+
+        gm = ep.graph_module
+        graph = gm.graph
+        modified = False
+        for reshape_back in graph.nodes:
+            if not is_target_node(reshape_back, ops.aten.reshape):
+                continue
+            reshape_back_args = ReshapeArgs(*reshape_back.args, **reshape_back.kwargs)  # type: ignore[arg-type]
+            permute = reshape_back_args.input
+
+            if not is_target_node(permute, ops.aten.permute):
+                continue
+            permute_args = PermuteArgs(*permute.args, **permute.kwargs)  # type: ignore[arg-type]
+            reshape_front, permute_dims = permute_args.input, permute_args.dims
+
+            if not is_target_node(reshape_front, ops.aten.reshape):
+                continue
+            reshape_front_args = ReshapeArgs(*reshape_front.args, **reshape_front.kwargs)  # type: ignore[arg-type]
+            reshape_front_input, reshape_front_size = (
+                reshape_front_args.input,
+                reshape_front_args.shape,
+            )
+
+            # ---- condition: only leading unsqueeze ------------------------
+            back_shape = extract_shape(reshape_back)
+            permute_shape = extract_shape(permute)
+
+            if not _is_leading_unsqueeze(back_shape, permute_shape):
+                continue
+
+            # ---- create new reshape & new permute -------------------------
+            k = len(back_shape) - len(permute_shape)
+            with graph.inserting_before(permute):
+                new_shape = [1] * k + list(reshape_front_size)
+                r_new = create_node(
+                    graph,
+                    torch.ops.aten.reshape.default,
+                    args=(reshape_front_input, new_shape),
+                    origin=reshape_back,
+                )
+                new_p_dims = list(range(k)) + [
+                    d + k for d in permute_dims
+                ]  # shift by k
+                p_new = create_node(
+                    graph,
+                    torch.ops.aten.permute.default,
+                    args=(r_new, new_p_dims),
+                )
+
+            reshape_back.replace_all_uses_with(p_new, propagate_meta=True)
+            modified = True
+            logger.debug(f"{reshape_back.name} is fused to {r_new.name}")
+
+        if modified:
+            graph.eliminate_dead_code()
+            graph.lint()
+            gm.recompile()
+
+        return PassResult(modified)