tico 0.1.0__py3-none-any.whl

tico/serialize/operators/op_expand.py

@@ -0,0 +1,91 @@
+# 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_mapping import circle_legalize_dtype_to
+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 ExpandArgs
+
+
+@register_node_visitor
+class ExpandVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.expand.default,
+        torch.ops.aten.expand_copy.default,
+    ]
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph):
+        super().__init__(op_codes, graph)
+
+    def define_expand_copy_node(self, inputs, outputs) -> circle.Operator.OperatorT:
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.BROADCAST_TO, self._op_codes
+        )
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+        operator.builtinOptionsType = (
+            circle.BuiltinOptions.BuiltinOptions.BroadcastToOptions
+        )
+        option = circle.BroadcastToOptions.BroadcastToOptionsT()
+        operator.builtinOptions = option
+        return operator
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+    ) -> circle.Operator.OperatorT:
+        args = ExpandArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        size = args.size
+
+        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
+
+        extending_rank = len(size) - len(input_shape)
+
+        size_i32 = circle_legalize_dtype_to(size, dtype=torch.int32)
+        for idx, dim in enumerate(size_i32):
+            if idx < extending_rank:
+                assert (
+                    dim >= 1
+                ), "A dim value(less than 1) isn't allowed in the extending_rank."
+
+            """
+            In pytorch, passing -1 as the size for a dimension means that the size of that dimension won't be changed.
+            But, circle in ONE does not support this. 
+            So, dim value(-1) in the non-extending_rank is supported to convert to the size for the dimension.
+            """
+            if dim == -1:
+                size_i32[idx] = input_shape[idx - extending_rank]
+
+        for idx, dim in enumerate(input_shape):
+            assert (
+                dim == 1 or dim == size_i32[extending_rank + idx]
+            ), f"The size of dimension to be expanded ({dim}) must be 1 or the expanded size ({size_i32[extending_rank + idx]})."
+
+        inputs = [input, size_i32]
+        outputs = [node]
+        operator = self.define_expand_copy_node(inputs, outputs)
+
+        return operator

tico/serialize/operators/op_full.py

@@ -0,0 +1,48 @@
+# 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.utils.validate_args_kwargs import FullArgs
+
+
+@register_node_visitor
+class FullVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [torch.ops.aten.full.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:
+        args = FullArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        size = args.size
+        fill_value = args.fill_value
+
+        output_data = torch.full(size, fill_value)
+
+        self.graph.update_tensor_buffer(output_data, node.name)
+
+        return None  # type: ignore[return-value]

tico/serialize/operators/op_full_like.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.circle_mapping import 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 FullLikeArgs
+
+
+@register_node_visitor
+class FullLikeVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [torch.ops.aten.full_like.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:
+        args = FullLikeArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        fill_value = args.fill_value
+
+        # can calculate full_like tensor before inference.
+        output_data = torch.full(
+            size=input.meta["val"].size(),
+            fill_value=fill_value,
+            dtype=input.meta["val"].dtype,
+        )
+
+        self.graph.update_tensor_buffer(output_data, node.name)
+
+        return None  # type: ignore[return-value]

tico/serialize/operators/op_ge.py

@@ -0,0 +1,54 @@
+# 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 GeArgs
+
+
+@register_node_visitor
+class GeVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.ge.Scalar,
+        torch.ops.aten.ge.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:
+        args = GeArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        other = args.other
+
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.GREATER_EQUAL, self._op_codes
+        )
+
+        inputs = [input, other]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        return operator

tico/serialize/operators/op_gelu.py

@@ -0,0 +1,59 @@
+# 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 GeluArgs
+
+
+@register_node_visitor
+class GeluVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.gelu.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:
+        args = GeluArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+
+        inputs = [input]
+        outputs = [node]
+
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.GELU, self._op_codes
+        )
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+        operator.builtinOptionsType = circle.BuiltinOptions.BuiltinOptions.GeluOptions
+        option = circle.GeluOptions.GeluOptionsT()
+        if "approximate" in node.kwargs and node.kwargs["approximate"] == "tanh":
+            option.approximate = True
+        operator.builtinOptions = option
+
+        return operator

tico/serialize/operators/op_gt.py

@@ -0,0 +1,54 @@
+# 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 GtArgs
+
+
+@register_node_visitor
+class GtVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.gt.Scalar,
+        torch.ops.aten.gt.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:
+        args = GtArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        other = args.other
+
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.GREATER, self._op_codes
+        )
+
+        inputs = [input, other]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        return operator

tico/serialize/operators/op_index.py

@@ -0,0 +1,82 @@
+# 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.errors import NotYetSupportedError
+from tico.utils.validate_args_kwargs import IndexArgs
+
+
+@register_node_visitor
+class IndexTensorVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [torch.ops.aten.index.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:
+        args = IndexArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        tensor = args.input
+        indices = args.indices
+
+        # TODO Support multiple indices
+        if len(indices) - indices.count(None) > 1:  # type: ignore[arg-type]
+            raise NotYetSupportedError(
+                "Multiple indices is not supported yet in aten.index.Tensor"
+            )
+
+        # find the lonely index
+        # ex. indices = [None, tensor, None] # index: tensor, axis: 1
+        # ex. indices = [1] # index: 1, axis 0
+        # ex. indices = [tensor] # index: tensor, axis 0
+        index = None
+        axis = None
+        for axis_, index_ in enumerate(indices):
+            if index_ is not None:
+                index = index_  # type: ignore[assignment]
+                axis = axis_  # type: ignore[assignment]
+                break
+
+        assert index is not None, index
+        assert axis is not None, axis
+
+        inputs = [tensor, index]
+        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 = axis  # type: ignore[assignment]
+        # TODO option.batchDims
+        operator.builtinOptions = option
+
+        return operator

tico/serialize/operators/op_index_select.py

@@ -0,0 +1,64 @@
+# 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.circle_mapping import circle_legalize_dtype_to
+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 IndexSelectArgs
+
+
+@register_node_visitor
+class IndexSelectVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.aten.index_select.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:
+        args = IndexSelectArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+
+        input = args.input
+        dim = args.dim
+        index = args.index
+
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.GATHER,
+            self._op_codes,
+        )
+
+        dim_i32 = circle_legalize_dtype_to(dim, dtype=torch.int32)
+        inputs = [input, index]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+
+        operator.builtinOptionsType = circle.BuiltinOptions.BuiltinOptions.GatherOptions
+        option = circle.GatherOptions.GatherOptionsT()
+        option.axis = dim_i32
+
+        operator.builtinOptions = option
+
+        return operator

tico/serialize/operators/op_instance_norm.py

@@ -0,0 +1,91 @@
+# 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_mapping import extract_shape
+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 InstanceNormArgs
+
+
+@register_node_visitor
+class InstanceNormVisitor(NodeVisitor):
+    """
+    Input [NHWC] ---- circle_cumstom.instance_norm [NHWC] ---- OUTPUT[NHWC]
+    Weight   -------/
+    Bias    -------/
+    """
+
+    target: List[torch._ops.OpOverload] = [
+        torch.ops.circle_custom.instance_norm,
+    ]
+
+    def define_instance_norm_node(
+        self, eps, inputs, outputs
+    ) -> circle.Operator.OperatorT:
+        def set_option(operator, eps):
+            operator.builtinOptionsType = (
+                circle.BuiltinOptions.BuiltinOptions.InstanceNormOptions
+            )
+            option = circle.InstanceNormOptions.InstanceNormOptionsT()
+            option.epsilon = eps
+            option.fusedActivationFunction = (
+                circle.ActivationFunctionType.ActivationFunctionType.NONE
+            )
+            operator.builtinOptions = option
+
+        op_index = get_op_index(
+            circle.BuiltinOperator.BuiltinOperator.INSTANCE_NORM, self._op_codes
+        )
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+        set_option(operator, eps)
+        return operator
+
+    def __init__(self, op_codes: Dict[OpCode, int], graph):
+        super().__init__(op_codes, graph)
+
+    def define_node(self, node: torch.fx.Node) -> circle.Operator.OperatorT:
+        args = InstanceNormArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+
+        input = args.input
+        weight = args.weight
+        bias = args.bias
+        eps = args.eps
+
+        # Ignore training-related args
+        running_mean = args.running_mean
+        running_var = args.running_var
+        use_input_stats = args.use_input_stats
+        momentum = args.momentum
+        cudnn_enabled = args.cudnn_enabled
+
+        input_shape = list(extract_shape(input))
+        assert len(input_shape) == 4, len(input_shape)
+
+        instance_norm_operator = self.define_instance_norm_node(
+            eps,
+            [input, weight, bias],
+            [node],
+        )
+
+        return instance_norm_operator

tico/serialize/operators/op_leaky_relu.py

@@ -0,0 +1,60 @@
+# 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 LeakyReluArgs
+
+
+@register_node_visitor
+class LeakyReluVisitor(NodeVisitor):
+    target: List[torch._ops.OpOverload] = [torch.ops.aten.leaky_relu.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.LEAKY_RELU, self._op_codes
+        )
+
+        args = LeakyReluArgs(*node.args, **node.kwargs)  # type: ignore[arg-type]
+        input = args.input
+        negative_slope = args.negative_slope
+
+        inputs = [input]
+        outputs = [node]
+
+        operator = create_builtin_operator(self.graph, op_index, inputs, outputs)
+        operator.builtinOptionsType = (
+            circle.BuiltinOptions.BuiltinOptions.LeakyReluOptions
+        )
+        option = circle.LeakyReluOptions.LeakyReluOptionsT()
+        option.alpha = negative_slope
+        operator.builtinOptions = option
+
+        return operator