【Hackathon 5th No.113】Support paddle 2.5.1

.ci/azure/linux.yml

@@ -372,7 +372,6 @@ jobs:
   # TODO Reenable PDPD after paddlepaddle==2.5.1 with compliant protobuf is released (ticket 95904)
   - script: $(RUN_PREFIX) $(INSTALL_TEST_DIR)/paddle_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-Paddle.xml
     displayName: 'Paddle Frontend UT'
-    enabled: 'false'
 
   - script: $(RUN_PREFIX) $(INSTALL_TEST_DIR)/ov_tensorflow_frontend_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-Tensorflow.xml
     displayName: 'TensorFlow Frontend Unit Tests'

.ci/azure/linux_debian.yml

@@ -291,7 +291,6 @@ jobs:
     env:
       LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
     displayName: 'Paddle Frontend UT'
-    enabled: 'false'
 
   - script: $(INSTALL_TEST_DIR)/ov_tensorflow_frontend_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-Tensorflow.xml
     env:

.ci/azure/windows.yml

@@ -267,7 +267,6 @@ jobs:
   # TODO Reenable PDPD after paddlepaddle==2.5.1 with compliant protobuf is released (ticket 95904)
   - script: call $(SETUPVARS) && $(INSTALL_TEST_DIR)\paddle_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)\TEST-Paddle.xml
     displayName: 'Paddle Frontend UT'
-    enabled: 'false'
 
   - script: call $(SETUPVARS) && $(INSTALL_TEST_DIR)\ov_tensorflow_frontend_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)\TEST-Tensorflow.xml
     displayName: 'TensorFlow Frontend Unit Tests'

.github/workflows/linux.yml

@@ -462,7 +462,6 @@ jobs:
                 --gtest_output=xml:${INSTALL_TEST_DIR}/TEST-IRFrontend.xml
 
       - name: PaddlePaddle frontend tests
-        if: ${{ 'false' }}
         run: |
           source ${INSTALL_DIR}/setupvars.sh
           ${INSTALL_TEST_DIR}/paddle_tests --gtest_print_time=1 \

src/frontends/paddle/src/op/argmax.cpp

@@ -28,9 +28,8 @@ NamedOutputs argmax(const NodeContext& node) {
         const Output<ov::Node> reshape_flatten = ov::opset6::Constant::create(ov::element::i64, {1}, {-1});
         auto node_reshape = std::make_shared<ov::opset6::Reshape>(data, reshape_flatten, true);
         auto node_topk = std::make_shared<ov::opset6::TopK>(node_reshape, k, axis, "max", "index", index_element_type);
-        return node.default_single_output_mapping(
-            {std::make_shared<ov::opset6::Convert>(node_topk->output(1), element::i64)},
-            {"Out"});
+        auto out = std::make_shared<ov::opset6::Squeeze>(node_topk->output(1));
+        return node.default_single_output_mapping({std::make_shared<ov::opset6::Convert>(out, element::i64)}, {"Out"});
     }
 }
 

src/frontends/paddle/src/op/elementwise_ops.cpp

@@ -42,15 +42,15 @@ NamedOutputs elementwise_pow(const NodeContext& node_context) {
     return elementwise_ops<default_opset::Power>(node_context);
 }
 
-NamedOutputs elementwise_equal(const NodeContext& node_context) {
+NamedOutputs equal(const NodeContext& node_context) {
     return elementwise_ops<default_opset::Equal>(node_context);
 }
 
-NamedOutputs elementwise_greater_equal(const NodeContext& node_context) {
+NamedOutputs greater_equal(const NodeContext& node_context) {
     return elementwise_ops<default_opset::GreaterEqual>(node_context);
 }
 
-NamedOutputs elementwise_not_equal(const NodeContext& node_context) {
+NamedOutputs not_equal(const NodeContext& node_context) {
     return elementwise_ops<default_opset::NotEqual>(node_context);
 }
 
@@ -64,7 +64,7 @@ NamedOutputs elementwise_floordiv(const NodeContext& node_context) {
     return node_context.default_single_output_mapping(
         {std::make_shared<default_opset::Divide>(x,
                                                  y,
-                                                 false,
+                                                 true,
                                                  ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, axis))},
         {"Out"});
 }

src/frontends/paddle/src/op/fill_constant_batch_size_like.cpp

@@ -121,4 +121,4 @@ NamedOutputs fill_constant_batch_size_like(const NodeContext& node) {
 }  // namespace op
 }  // namespace paddle
 }  // namespace frontend
-}  // namespace ov
+}  // namespace ov

src/frontends/paddle/src/op/matmul_v2.cpp

@@ -16,10 +16,6 @@ NamedOutputs matmul_v2(const NodeContext& node) {
     const auto mm = std::make_shared<default_opset::MatMul>(x, y, transpose_a, transpose_b);
 
     std::shared_ptr<Node> result = mm;
-    if (is_scalar(mm->get_output_partial_shape(0))) {
-        auto unsqueeze_scalar = default_opset::Constant::create(ov::element::i64, {}, {0});
-        result = std::make_shared<default_opset::Unsqueeze>(mm, unsqueeze_scalar);
-    }
     return node.default_single_output_mapping({result}, {"Out"});
 }
 

src/frontends/paddle/src/op/p_norm.cpp

@@ -18,22 +18,20 @@ NamedOutputs p_norm(const NodeContext& node) {
     const auto absNode = std::make_shared<default_opset::Abs>(data);
     const auto axisNode = default_opset::Constant::create(ov::element::i32, {1}, {axis});
 
+    std::shared_ptr<Node> p_norm_node;
+    const auto input_shape = data.get_partial_shape();
+
     if (p == std::numeric_limits<float>::infinity()) {
-        return node.default_single_output_mapping(
-            {std::make_shared<default_opset::ReduceMax>(absNode, axisNode, keepdim)},
-            {"Out"});
+        p_norm_node = std::make_shared<default_opset::ReduceMax>(absNode, axisNode, keepdim);
     } else if (p == -std::numeric_limits<float>::infinity()) {
-        return node.default_single_output_mapping(
-            {std::make_shared<default_opset::ReduceMin>(absNode, axisNode, keepdim)},
-            {"Out"});
+        p_norm_node = std::make_shared<default_opset::ReduceMin>(absNode, axisNode, keepdim);
     } else if (p == 0.0) {
         const auto input_dtype = data.get_element_type();
         const auto zero = default_opset::Constant::create(input_dtype, {1}, {0});
         const auto non_zero = std::make_shared<default_opset::NotEqual>(absNode, zero);
         const auto converted_non_zero = std::make_shared<default_opset::Convert>(non_zero, input_dtype);
 
-        const auto reduce_sum = std::make_shared<default_opset::ReduceSum>(converted_non_zero, axisNode, keepdim);
-        const auto input_shape = data.get_partial_shape();
+        p_norm_node = std::make_shared<default_opset::ReduceSum>(converted_non_zero, axisNode, keepdim);
         // process 1-d input and keepdim=false, output shape is [1], instead of scalar.
         if (!keepdim) {
             PADDLE_OP_CHECK(node,
@@ -42,19 +40,21 @@ NamedOutputs p_norm(const NodeContext& node) {
             const auto input_rank = input_shape.rank().get_length();
             if (input_rank == 1) {
                 const auto one = default_opset::Constant::create(ov::element::i64, {1}, {1});
-                auto out = std::make_shared<default_opset::Reshape>(reduce_sum, one, false);
-                return node.default_single_output_mapping({out}, {"Out"});
+                p_norm_node = std::make_shared<default_opset::Reshape>(p_norm_node, one, false);
             }
         }
-        return node.default_single_output_mapping({reduce_sum}, {"Out"});
     } else {
         const auto power_factor = default_opset::Constant::create(ov::element::f32, Shape{1}, {p});
         const auto powNode = std::make_shared<default_opset::Power>(absNode, power_factor);
         const auto reduce_sum = std::make_shared<default_opset::ReduceSum>(powNode, axisNode, keepdim);
         const auto extract_factor = default_opset::Constant::create(ov::element::f32, Shape{1}, {1.0 / p});
-        return node.default_single_output_mapping({std::make_shared<default_opset::Power>(reduce_sum, extract_factor)},
-                                                  {"Out"});
+        p_norm_node = std::make_shared<default_opset::Power>(reduce_sum, extract_factor);
+    }
+
+    if ((axis == -1 || input_shape.size() == 1) && !keepdim) {
+        p_norm_node = std::make_shared<default_opset::Squeeze>(p_norm_node);
     }
+    return node.default_single_output_mapping({p_norm_node}, {"Out"});
 }
 
 }  // namespace op

src/frontends/paddle/src/op/reduce_ops.hpp

@@ -40,6 +40,9 @@ NamedOutputs reduce_ops(const NodeContext& node) {
         auto unsqueeze_scalar = default_opset::Constant::create(ov::element::i64, {}, {0});
         result = std::make_shared<default_opset::Unsqueeze>(reduceNode, unsqueeze_scalar);
     }
+    if (reduce_all) {
+        result = std::make_shared<default_opset::Squeeze>(reduceNode);
+    }
     return node.default_single_output_mapping({result}, {"Out"});
 }
 

src/frontends/paddle/src/op/relu6.cpp

@@ -12,8 +12,7 @@ namespace paddle {
 namespace op {
 NamedOutputs relu6(const NodeContext& node) {
     auto data = node.get_input("X");
-    auto threshold = node.get_attribute<float>("threshold", 6.0f);
-    return node.default_single_output_mapping({std::make_shared<ov::opset6::Clamp>(data, 0.0, threshold)}, {"Out"});
+    return node.default_single_output_mapping({std::make_shared<ov::opset6::Clamp>(data, 0.0, 6.0f)}, {"Out"});
 }
 
 }  // namespace op

src/frontends/paddle/src/op_table.cpp

@@ -8,6 +8,7 @@ namespace frontend {
 namespace paddle {
 namespace op {
 #define OP_CONVERTER(op) NamedOutputs op(const NodeContext& node)
+OP_CONVERTER(add);
 OP_CONVERTER(argmax);
 OP_CONVERTER(assign);
 OP_CONVERTER(assign_value);
@@ -29,25 +30,25 @@ OP_CONVERTER(dequantize_linear);
 OP_CONVERTER(dropout);
 OP_CONVERTER(elementwise_add);
 OP_CONVERTER(elementwise_div);
-OP_CONVERTER(elementwise_equal);
 OP_CONVERTER(elementwise_floordiv);
-OP_CONVERTER(elementwise_greater_equal);
 OP_CONVERTER(elementwise_max);
 OP_CONVERTER(elementwise_min);
 OP_CONVERTER(elementwise_mod);
 OP_CONVERTER(elementwise_mul);
-OP_CONVERTER(elementwise_not_equal);
 OP_CONVERTER(elementwise_pow);
 OP_CONVERTER(elementwise_sub);
+OP_CONVERTER(equal);
+OP_CONVERTER(greater_equal);
+OP_CONVERTER(not_equal);
 OP_CONVERTER(embedding);
 OP_CONVERTER(exp);
 OP_CONVERTER(expand_v2);
 OP_CONVERTER(flip);
-OP_CONVERTER(fill_any_like);
-OP_CONVERTER(fill_constant_batch_size_like);
-OP_CONVERTER(fill_constant);
 OP_CONVERTER(flatten_contiguous_range);
 OP_CONVERTER(floor);
+OP_CONVERTER(fill_any_like);
+OP_CONVERTER(fill_constant);
+OP_CONVERTER(fill_constant_batch_size_like);
 OP_CONVERTER(gather);
 OP_CONVERTER(gather_nd);
 OP_CONVERTER(gelu);
@@ -91,7 +92,6 @@ OP_CONVERTER(reduce_sum);
 OP_CONVERTER(relu);
 OP_CONVERTER(relu6);
 OP_CONVERTER(reshape2);
-OP_CONVERTER(reverse);
 OP_CONVERTER(rnn);
 OP_CONVERTER(roi_align);
 OP_CONVERTER(scale);
@@ -151,30 +151,30 @@ std::map<std::string, CreatorFunction> get_supported_ops() {
             {"depthwise_conv2d", op::conv2d},
             {"depthwise_conv2d_transpose", op::conv2d_transpose},
             {"dequantize_linear", op::dequantize_linear},
-            {"dropout", op::dropout},
             {"elementwise_add", op::elementwise_add},
             {"elementwise_div", op::elementwise_div},
             {"elementwise_floordiv", op::elementwise_floordiv},
-            {"elementwise_max", op::elementwise_max},
-            {"elementwise_min", op::elementwise_min},
             {"elementwise_mod", op::elementwise_mod},
             {"elementwise_mul", op::elementwise_mul},
-            {"elementwise_pow", op::elementwise_pow},
+            {"elementwise_max", op::elementwise_max},
+            {"elementwise_min", op::elementwise_min},
             {"elementwise_sub", op::elementwise_sub},
-            {"equal", op::elementwise_equal},
+            {"dropout", op::dropout},
+            {"elementwise_pow", op::elementwise_pow},
+            {"equal", op::equal},
             {"exp", op::exp},
             {"expand_v2", op::expand_v2},
             {"fill_any_like", op::fill_any_like},
-            {"fill_constant_batch_size_like", op::fill_constant_batch_size_like},
             {"fill_constant", op::fill_constant},
+            {"fill_constant_batch_size_like", op::fill_constant_batch_size_like},
             {"flatten_contiguous_range", op::flatten_contiguous_range},
             {"flip", op::flip},
             {"floor", op::floor},
             {"gather", op::gather},
             {"gather_nd", op::gather_nd},
             {"gelu", op::gelu},
             {"generate_proposals_v2", op::generate_proposals_v2},
-            {"greater_equal", op::elementwise_greater_equal},
+            {"greater_equal", op::greater_equal},
             {"greater_than", op::greater_than},
             {"grid_sampler", op::grid_sampler},
             {"group_norm", op::group_norm},
@@ -201,7 +201,7 @@ std::map<std::string, CreatorFunction> get_supported_ops() {
             {"multiclass_nms3", op::multiclass_nms},
             {"nearest_interp_v2", op::nearest_interp_v2},
             {"nearest_interp", op::nearest_interp_v2},
-            {"not_equal", op::elementwise_not_equal},
+            {"not_equal", op::not_equal},
             {"one_hot_v2", op::one_hot_v2},
             {"p_norm", op::p_norm},
             {"pad3d", op::pad3d},
@@ -219,7 +219,6 @@ std::map<std::string, CreatorFunction> get_supported_ops() {
             {"relu", op::relu},
             {"relu6", op::relu6},
             {"reshape2", op::reshape2},
-            {"reverse", op::reverse},
             {"rnn", op::rnn},
             {"roi_align", op::roi_align},
             {"scale", op::scale},
@@ -253,8 +252,7 @@ std::map<std::string, CreatorFunction> get_supported_ops() {
             {"while", op::while_},
             {"write_to_array", op::write_to_array},
             {"where_index", op::where_index},
-            {"yolo_box", op::yolo_box},
-            {"generate_proposals_v2", op::generate_proposals_v2}};
+            {"yolo_box", op::yolo_box}};
 };
 
 }  // namespace paddle

src/frontends/paddle/tests/CMakeLists.txt

@@ -41,9 +41,6 @@ else()
     set(paddlepaddle_FOUND ON)
 endif()
 
-# PDPD 2.5.1 is not compatible with tests models we use
-set(paddlepaddle_FOUND OFF)
-
 set(TEST_PADDLE_MODELS_DIRNAME ${TEST_MODEL_ZOO}/paddle_test_models)
 target_compile_definitions(${TARGET_NAME} PRIVATE -D TEST_PADDLE_MODELS_DIRNAME=\"${TEST_PADDLE_MODELS_DIRNAME}/\")