[PT FE]: support aten::view_as and aten::std (#18960)

* [PT FE]: support aten::view_as and aten::std

* fix tests

tests/layer_tests/pytorch_tests/test_reshape_as.py

@@ -8,26 +8,32 @@ import torch
 from pytorch_layer_test_class import PytorchLayerTest
 
 
-@pytest.mark.parametrize('input_tesnors', ((np.ones((3, 6)), np.ones((2, 9))),
-                                           (np.ones((2, 2, 3)), np.ones((6, 2))),
-                                           (np.ones((6, 2)), np.ones((2, 2, 3)))))
 class TestReshapeAs(PytorchLayerTest):
 
-    def _prepare_input(self):
-        return self.input_tesnors
+    def _prepare_input(self, shape1, shape2):
+        return (np.ones(shape1, dtype=np.float32), np.ones(shape2, dtype=np.float32))
 
-    def create_model(self):
+    def create_model(self, op):
         class aten_reshape_as(torch.nn.Module):
+            def __init__(self, op) -> None:
+                super().__init__()
+                if op == "view_as":
+                    self.forward = self.forward_view
 
             def forward(self, input_tensor, shape_tensor):
                 return input_tensor.reshape_as(shape_tensor)
 
+            def forward_view(self, input_tensor, shape_tensor):
+                return input_tensor.view_as(shape_tensor)
+
         ref_net = None
 
-        return aten_reshape_as(), ref_net, "aten::reshape_as"
+        return aten_reshape_as(op), ref_net, f"aten::{op}"
 
     @pytest.mark.nightly
     @pytest.mark.precommit
-    def test_reshape_as(self, ie_device, precision, ir_version, input_tesnors):
-        self.input_tesnors = input_tesnors
-        self._test(*self.create_model(), ie_device, precision, ir_version)
+    @pytest.mark.parametrize("op", ["reshape_as", "view_as"])
+    @pytest.mark.parametrize('input_tensor_shapes',( ((3, 6), (2, 9)), ((2, 2, 3), (6, 2)), ((6, 2), (2, 2, 3))))
+    def test_reshape_as(self, op, input_tensor_shapes, ie_device, precision, ir_version):
+        self._test(*self.create_model(op), ie_device, precision, ir_version, 
+                   kwargs_to_prepare_input={"shape1": input_tensor_shapes[0], "shape2": input_tensor_shapes[1]})

tests/layer_tests/pytorch_tests/test_var_mean.py

@@ -11,47 +11,55 @@ class TestVar(PytorchLayerTest):
         import numpy as np
         return (np.random.randn(1, 3, 224, 224).astype(np.float32),)
 
-    def create_model(self, unbiased, dim=None, keepdim=True, two_args_case=True, return_mean=False):
+    def create_model(self, unbiased, dim=None, keepdim=True, two_args_case=True, op_type="var"):
         import torch
 
+        ops = {
+            "var": torch.var,
+            "var_mean": torch.var_mean,
+            "std": torch.std,
+            "std_mean": torch.std_mean
+        }
+
+        op = ops[op_type]
+
         class aten_var(torch.nn.Module):
-            def __init__(self, dim, unbiased, keepdim, return_mean):
+            def __init__(self, dim, unbiased, keepdim, op):
                 super(aten_var, self).__init__()
                 self.unbiased = unbiased
                 self.dim = dim
                 self.keepdim = keepdim
-                self.op = torch.var if not return_mean else torch.var_mean
+                self.op = op
 
             def forward(self, x):
                 return self.op(x, self.dim, unbiased=self.unbiased, keepdim=self.keepdim)
 
         class aten_var2args(torch.nn.Module):
-            def __init__(self, unbiased, return_mean):
+            def __init__(self, unbiased, op):
                 super(aten_var2args, self).__init__()
                 self.unbiased = unbiased
-                self.op =  torch.var if not return_mean else torch.var_mean
-
+                self.op =  op
             def forward(self, x):
-                return torch.var(x, self.unbiased)
+                return self.op(x, self.unbiased)
 
         ref_net = None
-        op_name = "aten::var" if not return_mean else "aten::var_mean"
+        op_name = f"aten::{op_type}"
         if two_args_case:
-            return aten_var2args(unbiased, return_mean), ref_net, op_name
-        return aten_var(dim, unbiased, keepdim, return_mean), ref_net, op_name
+            return aten_var2args(unbiased, op), ref_net, op_name
+        return aten_var(dim, unbiased, keepdim, op), ref_net, op_name
 
     @pytest.mark.nightly
     @pytest.mark.precommit
     @pytest.mark.parametrize("unbiased", [True, False])
-    @pytest.mark.parametrize("return_mean", [True, False])
-    def test_var2args(self, unbiased, return_mean, ie_device, precision, ir_version):
-        self._test(*self.create_model(unbiased, return_mean), ie_device, precision, ir_version)
+    @pytest.mark.parametrize("op_type", ["var", "var_mean", "std", "std_mean"])
+    def test_var2args(self, unbiased, op_type, ie_device, precision, ir_version):
+        self._test(*self.create_model(unbiased, op_type=op_type), ie_device, precision, ir_version)
 
     @pytest.mark.nightly
     @pytest.mark.precommit
     @pytest.mark.parametrize("unbiased", [False, True])
     @pytest.mark.parametrize("dim", [None, 0, 1, 2, 3, -1, -2, (0, 1), (-1, -2), (0, 1, -1), (0, 1, 2, 3)])
     @pytest.mark.parametrize("keepdim", [True, False])
-    @pytest.mark.parametrize("return_mean", [True, False])
-    def test_var(self, unbiased, dim, keepdim, return_mean, ie_device, precision, ir_version):
-        self._test(*self.create_model(unbiased, dim, keepdim, two_args_case=False, return_mean=return_mean), ie_device, precision, ir_version)
+    @pytest.mark.parametrize("op_type", ["var", "var_mean", "std", "std_mean"])
+    def test_var(self, unbiased, dim, keepdim, op_type, ie_device, precision, ir_version):
+        self._test(*self.create_model(unbiased, dim, keepdim, two_args_case=False, op_type=op_type), ie_device, precision, ir_version)