Initialize common ops and support ic3/resnet models

Initialize the ops in inception v3 and resnet.
Keep necessary codes in aot_compiler. Use the aot_compiler to generate
ic3, like
```
  python -m executorch.examples.samsung.aot_compiler --chipset e9955 -m ic3
```
About the on-device test, more information can be found in README which
is in the same level directory of aot_compiler.py

Co-authored-by: chong-chen <[email protected]>

Author: chong-chen01

backends/samsung/builders/__init__.py

@@ -4,8 +4,44 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-from . import node_visitor
+from . import (
+    node_visitor,
+    op_add,
+    op_avg_pool2d,
+    op_batch_norm,
+    op_cat,
+    op_clamp,
+    op_conv2d,
+    op_getitem,
+    op_hardtanh,
+    op_linear,
+    op_max_pool2d,
+    op_mean_dim,
+    op_mul,
+    op_permute,
+    op_relu,
+    op_reshape,
+    op_select,
+    op_unsqueeze,
+)
 
 __all__ = [
     node_visitor,
+    op_add,
+    op_avg_pool2d,
+    op_batch_norm,
+    op_cat,
+    op_clamp,
+    op_conv2d,
+    op_getitem,
+    op_hardtanh,
+    op_linear,
+    op_max_pool2d,
+    op_mean_dim,
+    op_mul,
+    op_permute,
+    op_relu,
+    op_reshape,
+    op_select,
+    op_unsqueeze,
 ]

backends/samsung/builders/node_visitor.py

@@ -13,6 +13,7 @@
     get_tensor_type,
 )
 from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+from executorch.backends.transforms.utils import is_param_node
 from torch.export import ExportedProgram
 
 
@@ -52,6 +53,10 @@ def define_tensor(
         data_type = get_map_dtype(tensor.dtype)
 
         const_data = None
+        if is_param_node(self.exported_program, node):
+            if swap_nc_for_weights:
+                tensor = torch.swapdims(tensor, 0, 1)
+            const_data = tensor.contiguous().detach().numpy()
 
         dims = [1] if len(tensor.size()) == 0 else list(tensor.size())
 

backends/samsung/builders/op_add.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+from typing import Dict
+
+import torch
+from executorch.backends.samsung.builders.node_visitor import (
+    NodeVisitor,
+    register_node_visitor,
+)
+from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+
+
+@register_node_visitor
+class AddVisitor(NodeVisitor):
+    target = "aten.add.Tensor"
+
+    def __init__(self, *args) -> None:
+        super().__init__(*args)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+        enn_graph: EnnGraph,
+        vals_to_ids: Dict[torch.Tensor, int],
+    ) -> None:
+        input1 = node.args[0]
+        input_id_1 = self.define_tensor(input1, enn_graph, vals_to_ids)
+        input2 = node.args[1]
+        input_id_2 = self.define_tensor(input2, enn_graph, vals_to_ids)
+
+        output_id = self.define_tensor(node, enn_graph, vals_to_ids)
+
+        enn_graph.define_op(node.name, "ELTSUM", [input_id_1, input_id_2], [output_id])

backends/samsung/builders/op_avg_pool2d.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+from typing import cast, Dict, List
+
+import torch
+from executorch.backends.samsung.builders.node_visitor import (
+    NodeVisitor,
+    register_node_visitor,
+)
+from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+
+
+@register_node_visitor
+class AvgPool2dVisitor(NodeVisitor):
+    target = "aten.avg_pool2d.default"
+
+    def __init__(self, *args) -> None:
+        super().__init__(*args)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+        enn_graph: EnnGraph,
+        vals_to_ids: Dict[torch.Tensor, int],
+    ) -> None:
+        input = node.args[0]
+        input_id = self.define_tensor(input, enn_graph, vals_to_ids)
+
+        kernel_size = cast(List[int], node.args[1])
+        if len(kernel_size) == 1:
+            kernel_size = kernel_size * 2
+
+        stride = cast(List[int], node.args[2]) if len(node.args) > 2 else kernel_size
+        if len(stride) == 1:
+            stride = stride * 2
+
+        padding = cast(List[int], node.args[3]) if len(node.args) > 3 else [0, 0]
+        if len(padding) == 1:
+            padding = padding * 2
+        explicit_padding = [padding[0], padding[1], padding[0], padding[1]]
+
+        params = {}
+        params["kernel_h"] = kernel_size[0]
+        params["kernel_w"] = kernel_size[1]
+        params["stride_h"] = stride[0]
+        params["stride_w"] = stride[1]
+        params["padding"] = "EXPLICIT"
+        params["explicit_padding"] = explicit_padding
+
+        if len(node.args) > 4:
+            ceil_mode = cast(bool, node.args[4])
+            assert not ceil_mode, "Not support ceil_mode = True."
+
+        if len(node.args) > 5:
+            params["count_include_pad"] = cast(bool, node.args[5])
+        else:
+            params["count_include_pad"] = True
+
+        if len(node.args) > 6:
+            divisor_override = cast(int, node.args[6])
+            assert divisor_override == kernel_size[0] * kernel_size[1], "Not supported divisor_override which is not equal to pooling region."
+
+        output_id = self.define_tensor(node, enn_graph, vals_to_ids)
+
+        enn_graph.define_op(node.name, "AVGPOOL2D", [input_id], [output_id], params)

backends/samsung/builders/op_batch_norm.py

@@ -0,0 +1,56 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+from typing import Dict
+
+import torch
+from executorch.backends.samsung.builders.node_visitor import (
+    NodeVisitor,
+    register_node_visitor,
+)
+from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+
+
+@register_node_visitor
+class BatchNormVisitor(NodeVisitor):
+    target = "aten._native_batch_norm_legit_no_training.default"
+
+    def __init__(self, *args) -> None:
+        super().__init__(*args)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+        enn_graph: EnnGraph,
+        vals_to_ids: Dict[torch.Tensor, int],
+    ) -> None:
+        all_input_tensors = []
+        input = node.args[0]
+        input_id = self.define_tensor(input, enn_graph, vals_to_ids)
+        all_input_tensors.append(input_id)
+
+        weight_node, bias_node, mean_node, var_node = (
+            node.args[1],
+            node.args[2],
+            node.args[3],
+            node.args[4],
+        )
+        weight_id = self.define_tensor(weight_node, enn_graph, vals_to_ids)
+        all_input_tensors.append(weight_id)
+        bias_id = self.define_tensor(bias_node, enn_graph, vals_to_ids)
+        all_input_tensors.append(bias_id)
+        mean_id = self.define_tensor(mean_node, enn_graph, vals_to_ids)
+        all_input_tensors.append(mean_id)
+        var_id = self.define_tensor(var_node, enn_graph, vals_to_ids)
+        all_input_tensors.append(var_id)
+
+        eps = node.args[-1]
+        params = {"epsilon": eps}
+
+        output_id = self.define_tensor(node, enn_graph, vals_to_ids, output_idx=0)
+
+        enn_graph.define_op(
+            node.name, "BatchNormalization", all_input_tensors, [output_id], params
+        )

backends/samsung/builders/op_cat.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+from typing import cast, Dict, List
+
+import torch
+from executorch.backends.samsung.builders.node_visitor import (
+    NodeVisitor,
+    register_node_visitor,
+)
+from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+from executorch.backends.transforms import get_shape
+
+
+@register_node_visitor
+class CatVisitor(NodeVisitor):
+    target = "aten.cat.default"
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+        enn_graph: EnnGraph,
+        vals_to_ids: Dict[torch.Tensor, int],
+    ) -> None:
+        tensors = cast(List[torch.fx.Node], node.args[0])
+        input_tensor_ids = []
+
+        for in_tensor in tensors:
+            input_id = self.define_tensor(in_tensor, enn_graph, vals_to_ids)
+            input_tensor_ids.append(input_id)
+
+        in_shape = get_shape(node)
+        axis = cast(int, node.args[1]) % len(in_shape) if len(node.args) >= 2 else 0
+        params = {"axis": axis}
+
+        output_id = self.define_tensor(node, enn_graph, vals_to_ids)
+        enn_graph.define_op(node.name, "CONCAT", input_tensor_ids, [output_id], params)

backends/samsung/builders/op_clamp.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2025 Samsung Electronics Co. LTD
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+from typing import cast, Dict
+
+import torch
+from executorch.backends.samsung.builders.node_visitor import (
+    NodeVisitor,
+    register_node_visitor,
+)
+from executorch.backends.samsung.serialization.enn_graph_schema import EnnGraph
+
+
+@register_node_visitor
+class ClampVisitor(NodeVisitor):
+    target = "aten.clamp.default"
+
+    def __init__(self, *args) -> None:
+        super().__init__(*args)
+
+    def define_node(
+        self,
+        node: torch.fx.Node,
+        enn_graph: EnnGraph,
+        vals_to_ids: Dict[torch.Tensor, int],
+    ) -> None:
+        input = node.args[0]
+        input_id = self.define_tensor(input, enn_graph, vals_to_ids)
+
+        # The default value of lower bound and upper bound
+        output_min = torch.finfo(torch.float32).min
+        output_max = torch.finfo(torch.float32).max
+        if node.args[1] is not None:
+            output_min = cast(float, node.args[1])
+        if len(node.args) > 2 and node.args[2] is not None:
+            output_max = cast(float, node.args[2])
+
+        params = {
+            "minimum": output_min,
+            "maximum": output_max
+        }
+        output_id = self.define_tensor(node, enn_graph, vals_to_ids)
+
+        enn_graph.define_op(node.name, "CLIP", [input_id], [output_id], params)