Executorch initial support (#28425)

### Details:
 - OV side changes for initial ExecuTorch OV backend

### Tickets:
 - [*ticket-id*](https://jira.devtools.intel.com/browse/CVS-157257)

---------

Co-authored-by: ynimmaga <yamini.nimmagadda@intel.com>
Co-authored-by: Roman Kazantsev <roman.kazantsev@intel.com>
Co-authored-by: Maxim Vafin <maxim.vafin@intel.com>

Author: 4 people

src/bindings/python/src/openvino/frontend/pytorch/fx_decoder.py

@@ -178,7 +178,7 @@ def __init__(self, pt_module, fx_gm=None, nodes=None,
         self._input_signature = []
         self._example_input = None
 
-        if issubclass(type(pt_module), torch.fx.graph_module.GraphModule):
+        if isinstance(pt_module, torch.fx.graph_module.GraphModule):
             self._input_is_list = None
             self._nodes = list(pt_module.graph.nodes)
             found_types = []
@@ -187,38 +187,34 @@ def __init__(self, pt_module, fx_gm=None, nodes=None,
                 if value.op == 'placeholder':
                     self._inputs.append(i)
                     self._input_signature.append(value.name)
-                    if hasattr(value, "meta") and ('tensor_meta' in value.meta.keys()) and value.meta['tensor_meta']:
-                        found_shapes.append(value.meta['tensor_meta'].shape)
-                        found_types.append(
-                            OVAny(pt_to_ov_type_map[str(value.meta['tensor_meta'].dtype)]))
-                    else:
-                        found_shapes.append(None)
-                        found_types.append(None)
+
+                    found_shapes.append(self.get_found_shape(value))
+                    found_types.append(self.get_found_dtype(value))
+                    if found_shapes[-1] is not None:
+                        new_shape = []
+                        for dim in found_shapes[-1]:
+                            if (dynamic_shapes or type(dim).__name__ == "SymInt"):
+                                new_shape.append(-1)
+                            else:
+                                new_shape.append(dim)
+                        found_shapes[-1] = torch.Size(new_shape)
+
                 elif value.op == 'output':
                     # Instead of putting output index, refer to its target
                     uargs = self.unpack_containers(value.args)
                     self._outputs = [(arg[0], self._nodes.index(arg[1]))
                                      for arg in uargs if arg[1] is not None]
-            for idx, shape in enumerate(found_shapes):
-                if shape is not None:
-                    new_shape = []
-                    for dim in shape:
-                        if (dynamic_shapes or type(dim).__name__ == "SymInt"):
-                            new_shape.append(-1)
-                        else:
-                            new_shape.append(dim)
-                    found_shapes[idx] = torch.Size(new_shape)
 
             if not input_shapes or len(input_shapes) == 0:
                 self.input_shapes = found_shapes
             if not input_types or len(input_types) == 0:
                 self.input_types = found_types
 
-            if hasattr(pt_module, "forward"):
-                input_params = inspect.signature(pt_module.forward).parameters
+            if hasattr(self.pt_module, "forward"):
+                input_params = inspect.signature(self.pt_module.forward).parameters
                 self._input_signature = list(input_params)
 
-        elif issubclass(type(pt_module), torch.fx.Node):
+        elif isinstance(pt_module, torch.fx.Node):
             self._nodes = nodes  # passed from outer context
 
             # FIXME: Quadratic complexity nodes*nodes considering the outer loop over all nodes
@@ -234,6 +230,23 @@ def __init__(self, pt_module, fx_gm=None, nodes=None,
                 self.input_types.append(
                     BaseFXDecoder.get_type_for_value(arg))
 
+    @staticmethod
+    def get_found_shape(value) -> str:
+        # If input is a tensor, read the shape from meta data
+        if hasattr(value, "meta"):
+            if ('tensor_meta' in value.meta.keys()) and value.meta['tensor_meta']:
+                return value.meta['tensor_meta'].shape
+            if ('val' in value.meta.keys()) and isinstance(value.meta["val"], torch.Tensor):
+                return value.meta['val'].shape
+        return None
+
+    @staticmethod
+    def get_found_dtype(value) -> str:
+        # If input is a tensor, read the data type from meta data
+        if hasattr(value, "meta") and ('tensor_meta' in value.meta.keys()) and value.meta['tensor_meta']:
+            return OVAny(pt_to_ov_type_map[str(value.meta['tensor_meta'].dtype)])
+        return None
+
     def get_input_signature_name(self, index: int) -> str:
         if self._input_signature is not None and index < len(self._input_signature):
             return self._input_signature[index]
@@ -331,6 +344,8 @@ def get_subgraph_decoder(self, index):
 
     def get_op_type(self):
         if self.pt_module.op == 'call_function':
+            if type(self.pt_module.target).__name__ == "EdgeOpOverload":
+                return self.pt_module.target.__name__
             return str(self.pt_module.target)
         elif self.pt_module.op == 'get_attr':
             return 'get_attr'  # FIXME should be aligned with get_attr from TS implementation

src/bindings/python/src/openvino/frontend/pytorch/torchdynamo/op_support.py

@@ -75,6 +75,7 @@ def __init__(self, options):
             "torch.ops.aten.argmin.default": None,
             "torch.ops.aten.as_strided.default": None,
             "torch.ops.aten.as_strided_.default": None,
+            "torch.ops.aten.as_strided_copy.default": None,
             "torch.ops.aten.asin.default": None,
             "torch.ops.aten.asinh.default": None,
             "torch.ops.aten.asinh.default": None,
@@ -118,6 +119,7 @@ def __init__(self, options):
             "torch.ops.aten.erf.default": None,
             "torch.ops.aten.exp.default": None,
             "torch.ops.aten.expand.default": None,
+            "torch.ops.aten.expand_copy.default": None,
             "torch.ops.aten.fake_quantize_per_channel_affine_cachemask.default": None,
             "torch.ops.aten.fill.Scalar": None,
             "torch.ops.aten.fill_.Scalar": None,
@@ -196,6 +198,7 @@ def __init__(self, options):
             "torch.ops.aten.new_zeros.default": None,
             "torch.ops.aten.ones.default": None,
             "torch.ops.aten.permute.default": None,
+            "torch.ops.aten.permute_copy.default": None,
             "torch.ops.aten.pow.Scalar": None,
             "torch.ops.aten.pow.Tensor_Scalar": None,
             "torch.ops.aten.pow.Tensor_Tensor": None,
@@ -213,6 +216,7 @@ def __init__(self, options):
             "torch.ops.aten.scatter.src": None,
             "torch.ops.aten.scatter.value": None,
             "torch.ops.aten.select.int": None,
+            "torch.ops.aten.select_copy.int": None,
             "torch.ops.aten.select_scatter.default": None,
             "torch.ops.aten.sigmoid.default": None,
             "torch.ops.aten.sigmoid_.default": None,
@@ -222,13 +226,16 @@ def __init__(self, options):
             "torch.ops.aten.sin.default": None,
             "torch.ops.aten.sinh.default": None,
             "torch.ops.aten.slice.Tensor": None,
+            "torch.ops.aten.slice_copy.Tensor": None,
             "torch.ops.aten.slice_scatter.default": None,
             "torch.ops.aten.sort.default": None,
             "torch.ops.aten.split.Tensor": None,
             "torch.ops.aten.split_with_sizes.default": None,
+            "torch.ops.aten.split_with_sizes_copy.default": None,
             "torch.ops.aten.sqrt.default": None,
             "torch.ops.aten.squeeze.dim": None,
             "torch.ops.aten.squeeze.dims": None,
+            "torch.ops.aten.squeeze_copy.dims": None,
             "torch.ops.aten.stack.default": None,
             "torch.ops.aten.std.correction": None,
             "torch.ops.aten.sub.default": None,
@@ -246,10 +253,12 @@ def __init__(self, options):
             "torch.ops.aten.unbind.int": None,
             "torch.ops.aten.unfold.default": None,
             "torch.ops.aten.unsqueeze.default": None,
+            "torch.ops.aten.unsqueeze_copy.default": None,
             "torch.ops.aten.upsample_nearest2d.default": None,
             "torch.ops.aten.var.correction": None,
             "torch.ops.aten.var_mean.correction": None,
             "torch.ops.aten.view.default": None,
+            "torch.ops.aten.view_copy.default": None,
             "torch.ops.aten.where.self": None,
             "torch.ops.aten.zeros.default": None,
             "torch.ops.aten.zeros_like.default": None,

src/frontends/pytorch/src/op_table.cpp

@@ -804,6 +804,7 @@ const std::unordered_map<std::string, CreatorFunction> get_supported_ops_fx() {
         {"aten.argmin.default", op::translate_argmin},
         {"aten.as_strided.default", op::translate_as_strided},
         {"aten.as_strided_.default", op::translate_as_strided},
+        {"aten.as_strided_copy.default", op::translate_as_strided},
         {"aten.asin.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Asin>},
         {"aten.asinh.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Asinh>},
         {"aten.atan.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Atan>},
@@ -854,6 +855,7 @@ const std::unordered_map<std::string, CreatorFunction> get_supported_ops_fx() {
         {"aten.exp.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Exp>},
         {"aten.expm1.default", op::translate_expm1},
         {"aten.expand.default", op::translate_expand},
+        {"aten.expand_copy.default", op::translate_expand},
         {"aten.eye.m", op::translate_eye_fx},
         {"aten.fake_quantize_per_channel_affine_cachemask.default", op::translate_fake_quantize_per_channel_affine_fx},
         {"aten.fill.Scalar", op::translate_fill},
@@ -936,6 +938,7 @@ const std::unordered_map<std::string, CreatorFunction> get_supported_ops_fx() {
         {"aten.ones.names", op::translate_ones_fx},
         {"aten.ones_like.default", op::translate_ones_like_fx},
         {"aten.permute.default", op::translate_permute},
+        {"aten.permute_copy.default", op::translate_1to1_match_2_inputs<opset10::Transpose>},
         {"aten.pow.Scalar", op::translate_pow},
         {"aten.pow.Tensor_Scalar", op::translate_pow},
         {"aten.pow.Tensor_Tensor", op::translate_pow},
@@ -958,6 +961,7 @@ const std::unordered_map<std::string, CreatorFunction> get_supported_ops_fx() {
         {"aten.scatter.value", op::translate_scatter},
         {"aten.scatter_add.default", op::translate_scatter_add},
         {"aten.select.int", op::translate_select},
+        {"aten.select_copy.int", op::translate_select},
         {"aten.select_scatter.default", op::translate_select_scatter_fx},
         {"aten.sigmoid.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Sigmoid>},
         {"aten.sigmoid_.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Sigmoid>},
@@ -967,13 +971,16 @@ const std::unordered_map<std::string, CreatorFunction> get_supported_ops_fx() {
         {"aten.sin.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Sin>},
         {"aten.sinh.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Sinh>},
         {"aten.slice.Tensor", op::translate_slice_fx},
+        {"aten.slice_copy.Tensor", op::translate_slice_fx},
         {"aten.slice_scatter.default", op::translate_slice_scatter_fx},
         {"aten.sort.default", op::translate_sort_fx},
         {"aten.split.Tensor", op::translate_chunk_fx},
         {"aten.split_with_sizes.default", op::translate_split_with_sizes_fx},
+        {"aten.split_with_sizes_copy.default", op::translate_split_with_sizes_fx},
         {"aten.sqrt.default", op::translate_1to1_match_1_inputs_with_fp32_type_alignment<opset10::Sqrt>},
         {"aten.squeeze.dim", op::translate_squeeze},
         {"aten.squeeze.dims", op::translate_squeeze},
+        {"aten.squeeze_copy.dims", op::translate_squeeze},
         {"aten.stack.default", op::translate_stack_fx},
         {"aten.std.correction", op::translate_std_fx},
         {"aten.sub.default", op::translate_sub_fx},
@@ -991,10 +998,12 @@ const std::unordered_map<std::string, CreatorFunction> get_supported_ops_fx() {
         {"aten.unbind.int", op::translate_unbind_int_fx},
         {"aten.unfold.default", op::translate_unfold},
         {"aten.unsqueeze.default", op::translate_1to1_match_2_inputs<opset10::Unsqueeze>},
+        {"aten.unsqueeze_copy.default", op::translate_1to1_match_2_inputs<opset10::Unsqueeze>},
         {"aten.upsample_nearest2d.default", op::translate_upsample_nearest2d},
         {"aten.var.correction", op::translate_var_fx},
         {"aten.var_mean.correction", op::translate_var_mean_fx},
         {"aten.view.default", op::translate_reshape},
+        {"aten.view_copy.default", op::translate_reshape},
         {"aten.view_as_complex.default", op::translate_view_as_complex},
         {"aten.view_as_real.default", op::translate_view_as_real},
         {"aten.where.self", op::translate_where},

tests/layer_tests/pytorch_tests/test_as_strided.py

@@ -45,6 +45,40 @@ def forward(self, x):
     def test_as_strided(self, size, stride, offset, ie_device, precision, ir_version):
         self._test(*self.create_model(size, stride, offset), ie_device, precision, ir_version, trace_model=True)
 
+class TestAsStridedCopy(PytorchLayerTest):
+    def _prepare_input(self):
+        return (np.random.randn(8, 8).astype(np.float32),)
+
+    def create_model(self, size, stride, offset):
+        class aten_as_strided_copy(torch.nn.Module):
+            def __init__(self, size, stride, offset):
+                super().__init__()
+                self.size = size
+                self.stride = stride
+                self.offset = offset
+
+            def forward(self, x):
+                return torch.as_strided_copy(x, self.size, self.stride, self.offset)
+
+        ref_net = None
+
+        return aten_as_strided_copy(size, stride, offset), ref_net, "aten::as_strided_copy"
+
+    @pytest.mark.parametrize(
+        "size,stride",
+        [
+            ([1], [1]),
+            ([2, 2], [1, 1]),
+            ([5, 4, 3], [1, 3, 7]),
+            ([5, 5, 5], [5, 0, 5]),
+            ([1, 2, 3, 4], [4, 3, 2, 1]),
+        ],
+    )
+    @pytest.mark.parametrize("offset", [None, 1, 3, 7])
+    @pytest.mark.precommit_fx_backend
+    def test_as_strided_copy(self, size, stride, offset, ie_device, precision, ir_version):
+        self._test(*self.create_model(size, stride, offset), ie_device, precision, ir_version, trace_model=True)
+
 
 class TestAsStridedListConstruct(PytorchLayerTest):
     def _prepare_input(self, size_shape_tensor=[1], stride_shape_tensor=[1]):

tests/layer_tests/pytorch_tests/test_expand.py

@@ -41,6 +41,31 @@ def forward_broadcast(self, x):
     def test_expand(self, dims, op_type, ie_device, precision, ir_version):
         self._test(*self.create_model(dims, op_type), ie_device, precision, ir_version)
 
+class TestExpandCopy(PytorchLayerTest):
+    def _prepare_input(self):
+        import numpy as np
+        return (np.random.randn(1, 3).astype(np.float32),)
+
+    def create_model(self, dim):
+        import torch
+
+        class aten_expand_copy(torch.nn.Module):
+            def __init__(self, dims):
+                super(aten_expand_copy, self).__init__()
+                self.dims = dims
+
+            def forward(self, x):
+                return torch.expand_copy(x, self.dims)
+
+        ref_net = None
+
+        return aten_expand_copy(dim), ref_net, f"aten::expand_copy"
+
+    @pytest.mark.parametrize("dims", [(4, 3), (-1, -1), (1, 2, 3), (1, 2, 2, 3)])
+    @pytest.mark.precommit_fx_backend
+    def test_expand_copy(self, dims, ie_device, precision, ir_version):
+        self._test(*self.create_model(dims), ie_device, precision, ir_version)
+
 class TestExpandList(PytorchLayerTest):
     def _prepare_input(self, broadcast_shape):
         import numpy as np

tests/layer_tests/pytorch_tests/test_permute.py

@@ -38,9 +38,35 @@ def forward(self, x):
     @pytest.mark.nightly
     @pytest.mark.precommit
     @pytest.mark.precommit_torch_export
+    @pytest.mark.precommit_fx_backend
     def test_permute(self, order, complex_type, ie_device, precision, ir_version):
         self._test(*self.create_model(order, complex_type), ie_device, precision, ir_version)
 
+class TestPermuteCopy(PytorchLayerTest):
+    def _prepare_input(self):
+        import numpy as np
+        return (np.random.randn(1, 3, 224, 224).astype(np.float32),)
+
+    def create_model(self, order):
+        import torch
+
+        class aten_permute_copy(torch.nn.Module):
+            def __init__(self, order):
+                super(aten_permute_copy, self).__init__()
+                self.order = order
+
+            def forward(self, x):
+                return torch.permute_copy(x, self.order)
+
+        ref_net = None
+
+        return aten_permute_copy(order), ref_net, "aten::permute_copy"
+
+    @pytest.mark.parametrize("order", [[0, 2, 3, 1], [0, 3, 1, 2], [0, -1, 1, -2]])
+    @pytest.mark.precommit_fx_backend
+    def test_permute_copy(self, order, ie_device, precision, ir_version):
+        self._test(*self.create_model(order), ie_device, precision, ir_version)
+
 
 class TestPermuteList(PytorchLayerTest):
     def _prepare_input(self, permute_shape):

tests/layer_tests/pytorch_tests/test_select.py

@@ -33,6 +33,34 @@ def forward(self, input_tensor):
     @pytest.mark.nightly
     @pytest.mark.precommit
     @pytest.mark.precommit_torch_export
+    @pytest.mark.precommit_fx_backend
     def test_select(self, ie_device, precision, ir_version, input_dim, input_index):
         self._test(*self.create_model(input_dim, input_index),
                    ie_device, precision, ir_version)
+
+@pytest.mark.parametrize('input_dim', list(range(-3, 4)))
+@pytest.mark.parametrize('input_index', list(range(-3, 4)))
+class TestSelectCopy(PytorchLayerTest):
+
+    def _prepare_input(self):
+        return (np.random.randn(4, 4, 5, 5).astype(np.float32),)
+
+    def create_model(self, input_dim, input_index):
+        class aten_select_copy(torch.nn.Module):
+
+            def __init__(self, input_dim, input_index) -> None:
+                super().__init__()
+                self.dim = input_dim
+                self.index = input_index
+
+            def forward(self, input_tensor):
+                return torch.select_copy(input_tensor, int(self.dim), int(self.index))
+
+        ref_net = None
+
+        return aten_select_copy(input_dim, input_index), ref_net, "aten::select_copy"
+
+    @pytest.mark.precommit_fx_backend
+    def test_select_copy(self, ie_device, precision, ir_version, input_dim, input_index):
+        self._test(*self.create_model(input_dim, input_index),
+                   ie_device, precision, ir_version)

tests/layer_tests/pytorch_tests/test_split.py

@@ -99,6 +99,31 @@ def forward(self, x, y):
 
     @pytest.mark.nightly
     @pytest.mark.precommit
+    @pytest.mark.precommit_fx_backend
     def test_split_with_sizes(self, ie_device, precision, ir_version):
         self._test(*self.create_model(),
                    ie_device, precision, ir_version, trace_model=True)
+
+class TestSplitWithSizesCopy(PytorchLayerTest):
+    def _prepare_input(self):
+        import numpy as np
+        return (np.random.randn(20).astype(np.float32),np.random.randn(20).astype(np.float32))
+
+    def create_model(self):
+        import torch
+
+        class aten_split_with_sizes_copy(torch.nn.Module):
+            def __init__(self):
+                super(aten_split_with_sizes_copy, self).__init__()                
+
+            def forward(self, x, y):
+                return torch.split_with_sizes_copy(x, [y.shape[0]], dim=0)
+
+        ref_net = None
+
+        return aten_split_with_sizes_copy(), ref_net, ["aten::split_with_sizes", "prim::ListConstruct"]
+
+    @pytest.mark.precommit_fx_backend
+    def test_split_with_sizes_copy(self, ie_device, precision, ir_version):
+        self._test(*self.create_model(),
+                   ie_device, precision, ir_version, trace_model=True)