update

openvinotoolkit · Jan 16, 2025 · 9ac73ff · 9ac73ff
1 parent 3813234
commit 9ac73ff
Show file tree

Hide file tree

Showing 7 changed files with 21 additions and 24 deletions.
diff --git a/src/frontends/paddle/src/op/elementwise_ops.cpp b/src/frontends/paddle/src/op/elementwise_ops.cpp
@@ -74,8 +74,8 @@ NamedOutputs elementwise_floordiv(const NodeContext& node_context) {
     if (pd_version >= 2005000 || pd_version == 0) {
         python_div = true;
     }
-    x = get_1d_tensor(x);
-    y = get_1d_tensor(y);
+    x = get_tensor_safe(x);
+    y = get_tensor_safe(y);
     return node_context.default_single_output_mapping(
         {std::make_shared<default_opset::Divide>(x,
                                                  y,

diff --git a/src/frontends/paddle/src/op/fill_any_like.cpp b/src/frontends/paddle/src/op/fill_any_like.cpp
@@ -26,7 +26,7 @@ NamedOutputs fill_any_like(const NodeContext& node) {
         });
     PADDLE_OP_CHECK(node, valid_type, "Invalid dtype! Fill_any_like supports boolean, i16, i32, i64, f16, f32, f64");
     const auto value_node = default_opset::Constant::create(dtype, {1}, {value});
-    x = get_1d_tensor(x);
+    x = get_tensor_safe(x);
     const auto shape_node = std::make_shared<default_opset::ShapeOf>(x);
     return node.default_single_output_mapping({std::make_shared<default_opset::Broadcast>(value_node, shape_node)},
                                               {"Out"});

diff --git a/src/frontends/paddle/src/op/scatter.cpp b/src/frontends/paddle/src/op/scatter.cpp
@@ -4,7 +4,6 @@
 #include "default_opset.hpp"
 #include "openvino/frontend/paddle/node_context.hpp"
 #include "openvino/opsets/opset15.hpp"
-#include "openvino/opsets/opset4.hpp"
 
 namespace ov {
 namespace frontend {

diff --git a/src/frontends/paddle/src/op/set_value.cpp b/src/frontends/paddle/src/op/set_value.cpp
@@ -26,10 +26,10 @@ std::shared_ptr<Node> handle_maximum_index(Output<Node>& node, const Output<Node
     return std::make_shared<default_opset::Select>(mask, update_node, node);
 }
 
-void normalize(std::vector<int64_t>& vec, const Output<Node> intput, const std::vector<int64_t> axes_vec) {
+void normalize(std::vector<int64_t>& vec, const Output<Node> input, const std::vector<int64_t> axes_vec) {
     for (size_t i = 0; i < axes_vec.size(); i++) {
         if (vec[i] < 0) {
-            auto x_dim = std::stoll(intput.get_partial_shape()[axes_vec[i]].to_string());
+            auto x_dim = std::stoll(input.get_partial_shape()[axes_vec[i]].to_string());
             vec[i] = vec[i] + x_dim;
         }
     }
@@ -53,46 +53,44 @@ NamedOutputs set_value(const NodeContext& node) {
         value_node = node.get_input("ValueTensor");
     } else {
         auto value_shape = node.get_attribute<std::vector<int64_t>>("shape");
-        auto intput_type = node.get_attribute<ov::element::Type>("dtype");
+        auto input_type = node.get_attribute<ov::element::Type>("dtype");
 
-        if (intput_type == ov::element::i32) {
+        if (input_type == ov::element::i32) {
             if (node.has_attribute("int32_values")) {
                 auto value_arrt = node.get_attribute<std::vector<int32_t>>("int32_values");
-                value_node = {default_opset::Constant::create(intput_type,
+                value_node = {default_opset::Constant::create(input_type,
                                                               Shape{value_shape.begin(), value_shape.end()},
                                                               value_arrt)};
             } else {
                 auto value_arrt = node.get_attribute<std::vector<int64_t>>("values");
                 auto int32_value = std::vector<int32_t>(value_arrt.begin(), value_arrt.end());
-                value_node = {default_opset::Constant::create(intput_type,
+                value_node = {default_opset::Constant::create(input_type,
                                                               Shape{value_shape.begin(), value_shape.end()},
                                                               int32_value)};
             }
-        } else if (intput_type == ov::element::i64) {
+        } else if (input_type == ov::element::i64) {
             auto value_arrt = node.has_attribute("values") ? node.get_attribute<std::vector<int64_t>>("values")
                                                            : node.get_attribute<std::vector<int64_t>>("int64_values");
-            value_node = {default_opset::Constant::create(intput_type,
-                                                          Shape{value_shape.begin(), value_shape.end()},
-                                                          value_arrt)};
-        } else if (intput_type == ov::element::f32) {
+            value_node = {
+                default_opset::Constant::create(input_type, Shape{value_shape.begin(), value_shape.end()}, value_arrt)};
+        } else if (input_type == ov::element::f32) {
             if (node.has_attribute("fp32_values")) {
                 auto value_arrt = node.get_attribute<std::vector<float>>("fp32_values");
-                value_node = {default_opset::Constant::create(intput_type,
+                value_node = {default_opset::Constant::create(input_type,
                                                               Shape{value_shape.begin(), value_shape.end()},
                                                               value_arrt)};
             } else {
                 auto value_arrt = node.get_attribute<std::vector<double>>("values");
                 auto fp32_value = std::vector<float>(value_arrt.begin(), value_arrt.end());
-                value_node = {default_opset::Constant::create(intput_type,
+                value_node = {default_opset::Constant::create(input_type,
                                                               Shape{value_shape.begin(), value_shape.end()},
                                                               fp32_value)};
             }
-        } else if (intput_type == ov::element::f64) {
+        } else if (input_type == ov::element::f64) {
             auto value_arrt = node.has_attribute("values") ? node.get_attribute<std::vector<double>>("values")
                                                            : node.get_attribute<std::vector<double>>("fp64_values");
-            value_node = {default_opset::Constant::create(intput_type,
-                                                          Shape{value_shape.begin(), value_shape.end()},
-                                                          value_arrt)};
+            value_node = {
+                default_opset::Constant::create(input_type, Shape{value_shape.begin(), value_shape.end()}, value_arrt)};
         } else {
             PADDLE_OP_CHECK(node, false, "assign_value only supports int32, int64, float32, float64");
         }

diff --git a/src/frontends/paddle/src/op/tile.cpp b/src/frontends/paddle/src/op/tile.cpp
@@ -12,7 +12,7 @@ namespace paddle {
 namespace op {
 NamedOutputs tile(const NodeContext& node) {
     auto x = node.get_input("X");
-    x = get_1d_tensor(x);
+    x = get_tensor_safe(x);
     auto x_dims = static_cast<int64_t>(x.get_partial_shape().rank().get_length());
     Output<Node> repeats;
     if (node.has_input("RepeatTimes")) {

diff --git a/src/frontends/paddle/src/op_utils.cpp b/src/frontends/paddle/src/op_utils.cpp
@@ -29,7 +29,7 @@ Output<Node> get_tensor_list(const OutputVector& node) {
     return res;
 }
 
-Output<Node> get_1d_tensor(const Output<Node>& node) {
+Output<Node> get_tensor_safe(const Output<Node>& node) {
     auto node_dim = node.get_partial_shape().rank().get_length();
     if (node_dim == 0) {
         return std::make_shared<op::default_opset::Unsqueeze>(

diff --git a/src/frontends/paddle/src/op_utils.hpp b/src/frontends/paddle/src/op_utils.hpp
@@ -11,7 +11,7 @@ namespace frontend {
 namespace paddle {
 
 Output<Node> get_tensor_list(const OutputVector& node);
-Output<Node> get_1d_tensor(const Output<Node>& node);
+Output<Node> get_tensor_safe(const Output<Node>& node);
 }  // namespace paddle
 }  // namespace frontend
 }  // namespace ov