tico 0.1.0.dev250411__py3-none-any.whl

tico/serialize/operators/op_select_copy.py

@@ -0,0 +1,65 @@
+# 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 Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.validate_args_kwargs import SelectCopyIntArgs
+
+
+@register_node_visitor
+class SelectCopyIntVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.select_copy.int,
+        torch.ops.aten.select.int,
+    ]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        args = SelectCopyIntArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        dim = args.dim
+        index = args.index
+
+        indices = torch.as_tensor(index, dtype=torch.int32)
+        inputs = [input, indices]
+        outputs = [node]
+
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.GATHER, self._op_codes
+        )
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        # Op-specific option
+        operator.builtinOptionsType = circle.BuiltinOptions.BuiltinOptions.GatherOptions
+        option = circle.GatherOptions.GatherOptionsT()
+        option.axis = dim
+        # TODO option.batchDims
+        operator.builtinOptions = option
+
+        return operator

tico/serialize/operators/op_sigmoid.py

@@ -0,0 +1,56 @@
+# 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 Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.validate_args_kwargs import SigmoidArgs
+
+
+@register_node_visitor
+class SigmoidVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [torch.ops.aten.sigmoid.default]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            # `Sigmoid` operation is implemented as a `Logistic` operation in circle.
+            # https://github.com/Samsung/ONE/blob/170382a/nnpackage/schema/circle_schema.fbs#L288
+            circle.BuiltinOperator.BuiltinOperator.LOGISTIC,
+            self._op_codes,
+        )
+
+        args = SigmoidArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+
+        inputs = [input]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        return operator

tico/serialize/operators/op_sin.py

@@ -0,0 +1,53 @@
+# 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 Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.validate_args_kwargs import SinArgs
+
+
+@register_node_visitor
+class SinVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [torch.ops.aten.sin.default]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.SIN, self._op_codes
+        )
+
+        args = SinArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+
+        inputs = [input]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        return operator

tico/serialize/operators/op_slice.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import copy
+from typing import Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.errors import InvalidArgumentError
+from tico.utils.validate_args_kwargs import SliceArgs
+
+
+@register_node_visitor
+class SliceCopyVisitor(NodeVisitor):
+    """
+    NOTE `torch.slice_copy`'s behavior matches with `strided slice` of CIRCLE, not `slice`.
+    """
+
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.slice.Tensor,
+        torch.ops.aten.slice_copy.Tensor,
+    ]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.STRIDED_SLICE, self._op_codes
+        )
+
+        args = SliceArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        dim = args.dim
+        start = args.start
+        end = args.end
+        step = args.step
+
+        input_tensor: circle.Tensor.TensorT = self.graph.get_tensor(input)
+        input_shape: List[int] = input_tensor.shape
+
+        if start is None:
+            start = 0
+        if end is None:
+            end = input_shape[dim]
+        if step is None:
+            step = 1
+
+        assert dim is not None
+        assert (
+            -len(input_shape) <= dim < len(input_shape)
+        ), "Cannot reach here (Dimension Out of Range error must be thrown by torch)"
+
+        if dim < 0:
+            dim = dim % len(input_shape)
+
+        assert isinstance(start, int), type(start)
+        assert isinstance(end, int), type(end)
+        assert isinstance(step, int), type(step)
+
+        if start < -input_shape[dim]:  # (-inf, -M)
+            """
+            WHY is 0?
+            start = -input_shape[dim] % input_shape[dim]
+            """
+            start = 0
+        elif -input_shape[dim] <= start < 0:  # [-M, 0)
+            start %= input_shape[dim]
+        elif 0 <= start < input_shape[dim]:  # [0, M)
+            start = start
+        elif input_shape[dim] <= start:  # [M, +inf)
+            start = input_shape[dim]
+        else:
+            assert False, "Cannot reach here"
+
+        if end < -input_shape[dim]:  # (-inf, -M)
+            """
+            WHY is 0?
+            end = -input_shape[dim] % input_shape[dim]
+            """
+            end = 0
+        elif -input_shape[dim] <= end < 0:  # [-M, 0)
+            end %= input_shape[dim]
+        elif 0 <= end < input_shape[dim]:  # [0, M)
+            end = end
+        elif input_shape[dim] <= end:  # [M, +inf)
+            end = input_shape[dim]
+        else:
+            assert False, "Cannot reach here"
+
+        assert 0 <= dim and dim < len(input_shape), dim
+        assert 0 <= start and start < input_shape[dim], start
+        assert 0 <= end and end <= input_shape[dim], end
+        assert 0 < step, "Restriction of torch.slice_copy"
+
+        if end <= start:
+            """
+            CONSTRAINTS
+            In torch, 'end <= start' condition generates zero tensor with a peculiar shape - ex. tensor([], size=(5,0,5))
+            In circle, it's not accepted at all.
+            """
+            raise InvalidArgumentError(
+                f"end({end}) must be greater than start ({start})"
+            )
+
+        # Build new arguments
+        rank = len(input_shape)
+
+        begin_shape = [0] * rank
+        begin_shape[dim] = start
+        begin_shape_tensor = torch.as_tensor(begin_shape, dtype=torch.int32)
+
+        end_shape = copy.deepcopy(input_shape)
+        end_shape[dim] = end
+        end_shape_tensor = torch.as_tensor(end_shape, dtype=torch.int32)
+
+        stride_shape = [1] * rank
+        stride_shape[dim] = step
+        stride_shape_tensor = torch.as_tensor(stride_shape, dtype=torch.int32)
+
+        inputs = [input, begin_shape_tensor, end_shape_tensor, stride_shape_tensor]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        operator.builtinOptionsType = (
+            circle.BuiltinOptions.BuiltinOptions.StridedSliceOptions
+        )
+
+        option = circle.StridedSliceOptions.StridedSliceOptionsT()
+
+        operator.builtinOptions = option
+        return operator

tico/serialize/operators/op_softmax.py

@@ -0,0 +1,100 @@
+# 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 Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.errors import NotYetSupportedError
+from tico.utils.utils import HAS_TORCH_OVER_25
+from tico.utils.validate_args_kwargs import SafeSoftmaxArgs, SoftmaxArgs
+
+
+@register_node_visitor
+class SoftMaxVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = (
+        [
+            torch.ops.aten._softmax.default,
+            # NOTE: Let's treat _safe_softmax as normal _softmax as its usage is for training.
+            # In order for optimization during inference, it can be replaced to softmax.
+            # ref: https://github.com/pytorch/pytorch/pull/133882
+            torch.ops.aten._safe_softmax.default,
+        ]
+        if HAS_TORCH_OVER_25
+        else [
+            torch.ops.aten._softmax.default,
+        ]
+    )
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph):
+        super().__init__(op_codes, graph)
+
+    def define_softmax_node(self, inputs, outputs) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.SOFTMAX, self._op_codes
+        )
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+        operator.builtinOptionsType = (
+            circle.BuiltinOptions.BuiltinOptions.SoftmaxOptions
+        )
+        option = circle.SoftmaxOptions.SoftmaxOptionsT()
+        option.beta = 1.0
+        operator.builtinOptions = option
+        return operator
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        """
+        Note that Currently, Softmax operator is supported only when `dim` is last dimension and `half_to_float` is False.
+        """
+        if node.target == torch.ops.aten._softmax.default:
+            # aten._softmax
+            args = SoftmaxArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+            half_to_float: bool = args.half_to_float
+            if half_to_float:
+                raise NotYetSupportedError(
+                    "softmax with half to float conversion is not supported on circle."
+                )
+        elif node.target == torch.ops.aten._safe_softmax.default:
+            # aten._safe_softmax
+            args = SafeSoftmaxArgs(*node.args, **node.kwargs)  # type: ignore[arg-type, assignment]
+
+        input: torch.fx.Node = args.input
+        dim: int = args.dim
+
+        input_tid: int = self.graph.get_tid_registered(input)
+        input_tensor: circle.Tensor.TensorT = self.graph.tensors[input_tid]
+        input_shape: List[int] = input_tensor.shape
+
+        if dim < 0:
+            dim = dim % len(input_shape)
+
+        if dim == len(input_shape) - 1:
+            inputs = [input]
+            outputs = [node]
+            operator = self.define_softmax_node(inputs, outputs)
+        else:
+            raise NotYetSupportedError("softmax only supports last dimension for now.")
+
+        return operator

tico/serialize/operators/op_split_with_sizes.py

@@ -0,0 +1,96 @@
+# 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 Dict, List, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+from torch._subclasses.fake_tensor import FakeTensor
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.circle_mapping import circle_legalize_dtype_to, to_circle_dtype
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.validate_args_kwargs import SplitWithSizesArgs
+
+
+@register_node_visitor
+class SplitWithSizesVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.split_with_sizes.default,
+    ]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.SPLIT_V, self._op_codes
+        )
+        args = SplitWithSizesArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        split_sizes = args.split_sizes
+        axis = args.dim
+
+        split_sizes_i32 = [
+            circle_legalize_dtype_to(split_size, dtype=torch.int32)
+            for split_size in split_sizes
+        ]
+        axis_i32 = circle_legalize_dtype_to(axis, dtype=torch.int32)
+        inputs = [input, split_sizes_i32, axis_i32]
+
+        """
+        `split_with_sizes` has multiple output tensors and they are represented as `getitem`.
+        Therefore, unlike other ops, node itself doesn't become a circle tensor. Instead, each `getitem` will be
+        a circle tensor.
+        Further, torch module having `split_with_sizes` may somtimes return selected outputs. At that time, `getitem`
+        nodes are generated only for the ouptut selected. Since one-compiler assumes that `CircleSplitV` always has 
+        all the outputs, let's add unused output tensors to compensate this restriction.
+        """
+        outputs: List[Union[circle.Tensor.TensorT, torch.fx.node.Node]] = []
+        sorted_users = sorted(node.users.keys(), key=lambda x: x.args[1])  # type: ignore[arg-type, return-value]
+        users_indices = list(usrnode.args[1] for usrnode in sorted_users)
+        user_it = iter(sorted_users)
+        for idx, _ in enumerate(split_sizes):
+            if idx in users_indices:
+                user_node = next(user_it)
+                outputs.append(user_node)
+            else:
+                # Let's add unused output tensor to satisfy circle split_v operator scheme
+                node_val = node.meta.get("val")
+                assert isinstance(node_val, list)
+                fake_tensor = node_val[idx]
+                assert isinstance(fake_tensor, FakeTensor)
+                shape = list(fake_tensor.size())
+                dtype = to_circle_dtype(fake_tensor.dtype)
+                tensor = self.graph.add_tensor_from_scratch(
+                    f"{node.name}_unused_{idx}", shape, dtype
+                )
+                outputs.append(tensor)
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        operator.builtinOptionsType = circle.BuiltinOptions.BuiltinOptions.SplitVOptions
+        option = circle.SplitVOptions.SplitVOptionsT()
+        option.numSplits = len(split_sizes)
+        operator.builtinOptions = option
+
+        return operator

tico/serialize/operators/op_sqrt.py

@@ -0,0 +1,55 @@
+# 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 Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.validate_args_kwargs import SqrtArgs
+
+
+@register_node_visitor
+class SqrtVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [torch.ops.aten.sqrt.default]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.SQRT, self._op_codes
+        )
+
+        args = SqrtArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+
+        inputs = [input]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        # `sqrt` does not have option
+
+        return operator

tico/serialize/operators/op_squeeze.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch._ops
+    import torch.fx
+import torch
+from circle_schema import circle
+
+from tico.serialize.circle_graph import CircleSubgraph
+from tico.serialize.operators.hashable_opcode import OpCode
+from tico.serialize.operators.node_visitor import NodeVisitor, register_node_visitor
+from tico.serialize.operators.utils import create_builtin_operator, get_op_index
+from tico.utils.validate_args_kwargs import SqueezeArgs
+
+
+@register_node_visitor
+class SqueezeVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.squeeze.dims,
+        torch.ops.aten.squeeze_copy.dims,
+    ]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph: CircleSubgraph):
+        super().__init__(op_codes, graph)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.SQUEEZE,
+            self._op_codes,
+        )
+
+        args = SqueezeArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        dims = args.dims
+
+        inputs = [input]
+        outputs = [node]
+
+        squeeze_dims: List = []
+        shape = input.meta["val"].size()
+        if dims:
+            squeeze_dims += [axis for axis in dims if shape[axis] == 1]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        # Op-specific option
+        operator.builtinOptionsType = (
+            circle.BuiltinOptions.BuiltinOptions.SqueezeOptions
+        )
+        option = circle.SqueezeOptions.SqueezeOptionsT()
+        if squeeze_dims:
+            option.squeezeDims = squeeze_dims
+
+        operator.builtinOptions = option
+
+        return operator