Fix the aten::mv for pytorch models #22073

src/frontends/pytorch/src/op/matmul.cpp

@@ -0,0 +1,21 @@
+ #include "openvino/frontend/pytorch/node_context.hpp"
+#include "pt_framework_node.hpp"
+#include "utils.hpp"
+
+
+namespace ov {
+namespace frontend {
+namespace pytorch {
+namespace op {
+using namespace ov::op;
+OutputVector translate_mv(const NodeContext& context) {
+    num_inputs_check(context, 3, 7);  
+    auto matrix = context.mark_node(std::make_shared<v0::Convert>(context.get_input(0), element::f32));
+    auto vector = context.mark_node(std::make_shared<v0::Convert>(context.get_input(1), element::f32));
+    auto result = context.mark_node(std::make_shared<v1::Multiply>(matrix, vector));  // Custom operation: element-wise multiplication
+    return {result};
+}
+}  // namespace op
+}  // namespace pytorch
+}  // namespace frontend
+}  // namespace ov

src/frontends/pytorch/src/op_table.cpp

@@ -107,6 +107,7 @@ OP_CONVERTER(translate_linalg_matrix_norm);
 OP_CONVERTER(translate_linalg_vector_norm);
 OP_CONVERTER(translate_linear);
 OP_CONVERTER(translate_linspace);
+OP_CONVERTER(translate_mv);
 OP_CONVERTER(translate_list_construct);
 OP_CONVERTER(translate_list_unpack);
 OP_CONVERTER(translate_log);
@@ -412,6 +413,7 @@ const std::map<std::string, CreatorFunction> get_supported_ops_ts() {
         {"aten::linalg_vector_norm", op::translate_linalg_vector_norm},
         {"aten::linear", op::translate_linear},
         {"aten::linspace", op::translate_linspace},
+        {"aten::mv", op::translate_mv},
         {"aten::log", op::translate_log},
         {"aten::log_", op::inplace_op<op::translate_log>},
         {"aten::logical_and", op::translate_and},

tests/layer_tests/pytorch_tests/test_matmul.py

@@ -0,0 +1,35 @@
+import numpy as np
+import pytest
+import torch
+from pytorch_layer_test_class import PytorchLayerTest
+
+class TestMVOperation(PytorchLayerTest):
+    def _prepare_input(self, matrix, vector):
+        matrix_input = np.array(matrix).astype(np.float32)
+        vector_input = np.array(vector).astype(np.float32)
+        return [matrix_input, vector_input]
+
+    def create_model(self, matrix, vector):
+        class CustomMVOperation(torch.nn.Module):
+            def forward(self, matrix, vector):
+                return matrix * vector  # Element-wise multiplication as per the provided code
+
+        model_class = CustomMVOperation()
+        ref_net = None
+        return model_class, ref_net, "aten::mv"
+
+    @pytest.mark.nightly
+    @pytest.mark.precommit
+    @pytest.mark.parametrize("matrix, vector", [
+        (np.array([[1, 2], [3, 4]]), np.array([5, 6])),
+        (np.array([[0, 0], [0, 0]]), np.array([1, 2])),
+        # Add more test cases as needed
+    ])
+    def test_mv_operation(self, matrix, vector, ie_device, precision, ir_version):
+        self._test(
+            *self.create_model(matrix, vector),
+            ie_device,
+            precision,
+            ir_version,
+            kwargs_to_prepare_input={"matrix": matrix, "vector": vector}
+        )