[PT FE]: support aten::outer op (openvinotoolkit#18903)

Author: eaidova

src/frontends/pytorch/src/op/outer.cpp

@@ -0,0 +1,41 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "openvino/frontend/pytorch/node_context.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/convert_like.hpp"
+#include "openvino/op/matmul.hpp"
+#include "openvino/op/unsqueeze.hpp"
+#include "utils.hpp"
+
+namespace ov {
+namespace frontend {
+namespace pytorch {
+namespace op {
+
+using namespace ov::op;
+
+OutputVector translate_outer(const NodeContext& context) {
+    // aten::outer(Tensor self, Tensor vec2) -> Tensor
+    // aten::outer.out(Tensor self, Tensor vec2, *, Tensor(a!) out) -> Tensor(a!)
+    num_inputs_check(context, 2, 3);
+    auto vec1 = context.get_input(0);
+    auto vec2 = context.get_input(1);
+    align_eltwise_input_types(context, vec1, vec2, true);
+    auto const_zero = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {0}));
+    auto const_minus_one = context.mark_node(v0::Constant::create(element::i32, Shape{1}, {-1}));
+    vec1 = context.mark_node(std::make_shared<v0::Unsqueeze>(vec1, const_minus_one));
+    vec2 = context.mark_node(std::make_shared<v0::Unsqueeze>(vec2, const_zero));
+    auto out = context.mark_node(std::make_shared<v0::MatMul>(vec1, vec2));
+    if (!context.input_is_none(2)) {
+        out = context.mark_node(std::make_shared<v1::ConvertLike>(out, context.get_input(2)));
+        context.mutate_input(2, out);
+    }
+    return {out};
+};
+
+}  // namespace op
+}  // namespace pytorch
+}  // namespace frontend
+}  // namespace ov

src/frontends/pytorch/src/op_table.cpp

@@ -109,6 +109,7 @@ OP_CONVERTER(translate_norm);
 OP_CONVERTER(translate_numel);
 OP_CONVERTER(translate_ones);
 OP_CONVERTER(translate_ones_like);
+OP_CONVERTER(translate_outer);
 OP_CONVERTER(translate_pad);
 OP_CONVERTER(translate_pairwise_distance);
 OP_CONVERTER(translate_pow);
@@ -361,6 +362,7 @@ const std::map<std::string, CreatorFunction> get_supported_ops_ts() {
         {"aten::numel", op::translate_numel},
         {"aten::ones", op::translate_ones},
         {"aten::ones_like", op::translate_ones_like},
+        {"aten::outer", op::translate_outer},
         {"aten::pad", op::translate_pad},
         {"aten::pairwise_distance", op::translate_pairwise_distance},
         {"aten::permute", op::translate_1to1_match_2_inputs<opset10::Transpose>},

tests/layer_tests/pytorch_tests/test_outer.py

@@ -0,0 +1,56 @@
+# Copyright (C) 2018-2023 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import pytest
+
+from pytorch_layer_test_class import PytorchLayerTest
+
+
+class TestOuter(PytorchLayerTest):
+    def _prepare_input(self, x_shape, y_shape, x_dtype, y_dtype, out=False):
+        import numpy as np
+        x = np.random.randn(*x_shape).astype(x_dtype)
+        y = np.random.randn(*y_shape).astype(y_dtype)
+        if not out:
+            return (x, y)
+        out = np.zeros((x_shape[0], y_shape[0]))
+        return (x, y, out)
+
+    def create_model(self, out=False, x_dtype="float32", y_dtype="float32"):
+        import torch
+
+        dtypes = {
+            "float32": torch.float32,
+            "float64": torch.float64,
+            "int32": torch.int32
+        }
+        x_dtype = dtypes[x_dtype]
+        y_dtype = dtypes[y_dtype]
+        class aten_outer(torch.nn.Module):
+            def __init__(self, out, x_dtype, y_dtype) -> None:
+                super().__init__()
+                self.x_dtype = x_dtype
+                self.y_dtype = y_dtype
+                if out:
+                    self.forward = self.forward_out
+
+            def forward(self, x, y):
+                return torch.outer(x.to(self.x_dtype), y.to(self.y_dtype))
+    
+            def forward_out(self, x, y, out):
+                return torch.outer(x.to(self.x_dtype), y.to(self.y_dtype), out=out), out
+
+        ref_net = None
+
+        return aten_outer(out, x_dtype, y_dtype), ref_net, 'aten::outer'
+
+    @pytest.mark.parametrize("x_shape", ([1], [2], [3]))
+    @pytest.mark.parametrize("y_shape", ([1], [7], [5]))
+    @pytest.mark.parametrize("x_dtype", ("float32", "float64", "int32"))
+    @pytest.mark.parametrize("y_dtype", ("float32", "float64", "int32"))
+    @pytest.mark.parametrize("out", [True, False])
+    @pytest.mark.nightly
+    @pytest.mark.precommit
+    def test_numel(self, x_shape, y_shape, x_dtype, y_dtype, out, ie_device, precision, ir_version):
+        self._test(*self.create_model(out, x_dtype, y_dtype), ie_device, precision, ir_version,
+                   kwargs_to_prepare_input={"out": out, "x_shape": x_shape, "y_shape": y_shape, "x_dtype": x_dtype, "y_dtype": y_dtype})