Added support for aten::randperm and aten::polar

src/frontends/pytorch/src/op/polar.cpp

@@ -0,0 +1,31 @@
+#include "openvino/op/cos.hpp"
+#include "openvino/op/sin.hpp"
+#include "openvino/op/multiply.hpp"
+#include "openvino/op/concat.hpp"
+#include "openvino/frontend/complex_type_mark.hpp"
+#include "openvino/op/convert.hpp"
+#include "utils.hpp"
+
+namespace ov {
+namespace frontend {
+namespace pytorch {
+namespace op {
+
+using namespace ov::op;
+
+OutputVector translate_polar(const NodeContext& context) {
+    num_inputs_check(context, 2, 3);
+    auto abs = context.get_input(0);
+    auto angle = context.get_input(1);
+    auto real = context.mark_node(std::make_shared<v1::Multiply>(abs,context.mark_node(std::make_shared<v0::Cos>(angle))));
+    auto imag = context.mark_node(std::make_shared<v1::Multiply>(abs,context.mark_node(std::make_shared<v0::Sin>(angle))));
+    auto complex_concat = context.mark_node(std::make_shared<v0::Concat>(OutputVector{real, imag}, -1));
+    // wrap the tensor with ComplexTypeMark to flag it as complex for later operations.
+    auto complex_tensor = context.mark_node(std::make_shared<ComplexTypeMark>(complex_concat));
+    return {complex_tensor};
+}
+
+}  // namespace op
+}  // namespace pytorch
+}  // namespace frontend
+}  // namespace ov

src/frontends/pytorch/src/op/randperm.cpp

@@ -0,0 +1,48 @@
+#include "openvino/op/topk.hpp"
+#include "openvino/op/random_uniform.hpp"
+#include "openvino/frontend/pytorch/node_context.hpp"
+#include "openvino/op/constant.hpp"
+#include "utils.hpp"
+#include "openvino/op/shape_of.hpp"
+
+namespace ov {
+namespace frontend {
+namespace pytorch {
+namespace op {
+
+using namespace ov::op;
+
+OutputVector translate_randperm(const NodeContext& context) {
+    auto num_inputs = context.get_input_size();
+    int64_t n = context.const_input<int64_t>(0);
+    int dtype_value = 4;
+    if (num_inputs == 1) {
+    } else if (num_inputs == 2) {
+        if (!context.input_is_none(1)) {
+            dtype_value = context.const_input<int>(1);
+            OPENVINO_ASSERT(dtype_value == 4, "Only dtype value 4 (int64) is supported for aten::randperm, got: ", dtype_value);
+        }
+    } else if (num_inputs == 5) {
+        if (!context.input_is_none(1)) {
+            dtype_value = context.const_input<int>(1);
+            OPENVINO_ASSERT(dtype_value == 4, "Only dtype value 4 (int64) is supported for aten::randperm, got: ", dtype_value);
+        }
+    } else {
+            PYTORCH_OP_CONVERSION_CHECK(false, "Unexpected number of inputs for aten::randperm: ", num_inputs);
+    }
+    if (n == 0) {
+    return {context.mark_node(v0::Constant::create(element::i64, Shape{0},std::vector<int64_t>{}))};}
+    auto shape = v0::Constant::create(element::i64, Shape{1}, {n});
+    auto min_val = v0::Constant::create(element::f32, Shape{}, {0.0f});
+    auto max_val = v0::Constant::create(element::f32, Shape{}, {1.0f});
+    auto random_tensor = context.mark_node(std::make_shared<v8::RandomUniform>(shape, min_val, max_val, element::f32));
+    const int64_t axis = 0;
+    auto k = v0::Constant::create(element::i64, Shape{}, {n});
+    auto topk = context.mark_node(std::make_shared<v11::TopK>(random_tensor, k, axis, ov::op::TopKMode::MIN, ov::op::TopKSortType::SORT_VALUES, element::i64, false));
+    return {topk->output(1)};
+}
+
+}  // namespace op
+}  // namespace pytorch
+}  // namespace frontend
+}  // namespace ov

src/frontends/pytorch/src/op_table.cpp

@@ -196,6 +196,7 @@ OP_CONVERTER(translate_permute);
 OP_CONVERTER(translate_pairwise_distance);
 OP_CONVERTER(translate_pixel_shuffle);
 OP_CONVERTER(translate_pixel_unshuffle);
+OP_CONVERTER(translate_polar);
 OP_CONVERTER(translate_pow);
 OP_CONVERTER(translate_prod);
 OP_CONVERTER(translate_pythonop);
@@ -207,6 +208,7 @@ OP_CONVERTER(translate_quantized_hardswish);
 OP_CONVERTER(translate_quantized_mul);
 OP_CONVERTER(translate_range_length);
 OP_CONVERTER(translate_rand);
+OP_CONVERTER(translate_randperm);
 OP_CONVERTER(translate_randn);
 OP_CONVERTER(translate_randint);
 OP_CONVERTER(translate_rand_like);
@@ -632,12 +634,14 @@ const std::unordered_map<std::string, CreatorFunction> get_supported_ops_ts() {
         {"aten::pixel_shuffle", op::translate_pixel_shuffle},
         {"aten::pixel_unshuffle", op::translate_pixel_unshuffle},
         {"aten::prelu", op::translate_1to1_match_2_inputs<opset10::PRelu>},
+        {"aten::polar", op::translate_polar},
         {"aten::pow", op::translate_pow},
         {"aten::pow_", op::translate_pow},
         {"aten::prod", op::translate_prod},
         {"aten::quantize_per_channel", op::translate_quantize_per_channel},
         {"aten::quantize_per_tensor", op::translate_quantize_per_tensor},
         {"aten::rand", op::translate_rand},
+        {"aten::rand", op::translate_randperm},
         {"aten::rand_like", op::translate_rand_like},
         {"aten::randint", op::translate_randint},
         {"aten::randn", op::translate_randn},

tests/layer_tests/pytorch_tests/test_polar.py

@@ -0,0 +1,39 @@
+# Copyright (C) 2018-2025 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import pytest
+import torch
+import numpy as np
+from pytorch_layer_test_class import PytorchLayerTest
+
+class TestPolar(PytorchLayerTest):
+    def _prepare_input(self):
+        return (
+            np.array([1.0, 2.0, 3.0], dtype=np.float32),
+            np.array([0.1, 0.2, 0.3], dtype=np.float32)
+        )
+
+    def create_model(self):
+        class PolarModel(torch.nn.Module):
+            def forward(self, abs, angle):
+                real = abs * torch.cos(angle)
+                imag = abs * torch.sin(angle)
+                return torch.stack([real, imag], dim=-1)
+        return PolarModel(), None, None
+
+    @pytest.mark.nightly
+    @pytest.mark.precommit
+    @pytest.mark.parametrize("input_variant", ["static", "dynamic"])
+    def test_polar(self, ie_device, precision, ir_version, input_variant):
+        atol = 1e-4 if precision == "FP32" else 1e-3
+        rtol = 1e-4
+        if input_variant == "static":
+            input_data = self._prepare_input()
+        else:
+            static_input = self._prepare_input()
+            input_data = (
+                np.expand_dims(static_input[0], axis=0),
+                np.expand_dims(static_input[1], axis=0)
+            )
+        self._test(*self.create_model(), ie_device, precision, ir_version,
+                   input_data=input_data, model_trace=True, atol=atol, rtol=rtol)

tests/layer_tests/pytorch_tests/test_randperm.py

@@ -0,0 +1,79 @@
+# Copyright (C) 2018-2025 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import pytest
+import torch
+import numpy as np
+from pytorch_layer_test_class import PytorchLayerTest, flattenize_inputs
+from copy import deepcopy
+
+class TestRandperm(PytorchLayerTest):
+    def _prepare_input(self):
+        return ()
+
+    def create_model(self, n):
+        class AtenRandperm(torch.nn.Module):
+            def __init__(self, n):
+                super().__init__()
+                self.n = n
+
+            def forward(self):
+                return torch.randperm(self.n, dtype=torch.int64)
+
+        return AtenRandperm(n), None, "aten::randperm"
+
+    def is_valid_permutation(self, output, n):
+        if hasattr(output, 'detach'):
+            arr = output.detach().cpu().numpy().astype(np.int64)
+        else:
+            arr = np.array(output, dtype=np.int64)
+        sorted_arr = np.sort(arr.flatten())
+        expected = np.arange(n, dtype=np.int64)
+        return np.array_equal(sorted_arr, expected)
+
+    @pytest.mark.parametrize("n", [1, 5, 10])
+    @pytest.mark.nightly
+    @pytest.mark.precommit
+    def test_randperm_custom(self, n, ie_device, precision, ir_version):
+        model, ref_net, op = self.create_model(n)
+        inputs = self._prepare_input()
+        torch_inputs = [torch.from_numpy(x) if isinstance(x, np.ndarray) else x for x in inputs]
+        ov_inputs = flattenize_inputs(inputs)
+        trace_model = True
+        dynamic_shapes = True
+        freeze_model = True
+
+        with torch.no_grad():
+            smodel, converted_model = self.convert_directly_via_frontend(
+                model, torch_inputs, trace_model, dynamic_shapes, ov_inputs, freeze_model
+            )
+
+        from openvino import Core
+        core = Core()
+        compiled_model = core.compile_model(converted_model, ie_device).
+        ov_output_dict = compiled_model(())
+        ov_output_tensor = list(ov_output_dict.values())[0]
+
+        assert ov_output_tensor.shape[0] == n, f"Output shape {ov_output_tensor.shape} does not match expected ({n},)"
+        assert self.is_valid_permutation(ov_output_tensor, n), (
+            f"Output {ov_output_tensor} is not a valid permutation of [0, 1, ..., {n-1}]"
+        )
+
+    @pytest.mark.xfail(reason="OpenVINO doesn't support empty tensors for randperm")
+    def test_randperm_zero(self, ie_device, precision, ir_version):
+        model, ref_net, op = self.create_model(0)
+        inputs = self._prepare_input()
+        torch_inputs = [torch.from_numpy(x) if isinstance(x, np.ndarray) else x for x in inputs]
+        ov_inputs = flattenize_inputs(inputs)
+        trace_model = True
+        dynamic_shapes = True
+        freeze_model = True
+
+        with torch.no_grad():
+            smodel, converted_model = self.convert_directly_via_frontend(
+                model, torch_inputs, trace_model, dynamic_shapes, ov_inputs, freeze_model
+            )
+        from openvino import Core
+        core = Core()
+        compiled_model = core.compile_model(converted_model, ie_device)
+        _ = compiled_model(())