diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml index 567c6e9a14c038..900d29a34d7fd7 100644 --- a/.github/workflows/linux.yml +++ b/.github/workflows/linux.yml @@ -745,7 +745,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 \ diff --git a/src/frontends/paddle/include/openvino/frontend/paddle/decoder.hpp b/src/frontends/paddle/include/openvino/frontend/paddle/decoder.hpp index 1934352e3c01b1..a687f137ca0e03 100644 --- a/src/frontends/paddle/include/openvino/frontend/paddle/decoder.hpp +++ b/src/frontends/paddle/include/openvino/frontend/paddle/decoder.hpp @@ -40,6 +40,9 @@ class DecoderBase { virtual size_t get_output_size() const = 0; virtual size_t get_output_size(const std::string& port_name) const = 0; + /// \brief Get the version + virtual int64_t get_version() const = 0; + /// \brief Get output port type /// /// Current API assumes that output port has only one output type. diff --git a/src/frontends/paddle/include/openvino/frontend/paddle/node_context.hpp b/src/frontends/paddle/include/openvino/frontend/paddle/node_context.hpp index d571af6ddddf44..dde7df0770c2ff 100644 --- a/src/frontends/paddle/include/openvino/frontend/paddle/node_context.hpp +++ b/src/frontends/paddle/include/openvino/frontend/paddle/node_context.hpp @@ -98,6 +98,10 @@ class NodeContext : public ov::frontend::NodeContext { return decoder->get_output_port_infos(port_name); } + int64_t get_version() const { + return decoder->get_version(); + } + private: ov::Any apply_additional_conversion_rules(const ov::Any& any, const std::type_info& type_info) const override { auto res = decoder->convert_attribute(any, type_info); diff --git a/src/frontends/paddle/src/decoder_proto.cpp b/src/frontends/paddle/src/decoder_proto.cpp index f286bfcf1f81fc..41da414db6a23e 100644 --- a/src/frontends/paddle/src/decoder_proto.cpp +++ b/src/frontends/paddle/src/decoder_proto.cpp @@ -75,6 +75,10 @@ ov::Any DecoderProto::get_attribute(const std::string& name) const { } } +int64_t DecoderProto::get_version() const { + return get_place()->get_version(); +} + ov::Any DecoderProto::convert_attribute(const Any& data, const std::type_info& type_info) const { if (data.is() && type_info == typeid(ov::element::Type)) { return get_ov_type(static_cast(data.as())); diff --git a/src/frontends/paddle/src/decoder_proto.hpp b/src/frontends/paddle/src/decoder_proto.hpp index 11627c6fba6ab9..cfad67bbc4ff2d 100644 --- a/src/frontends/paddle/src/decoder_proto.hpp +++ b/src/frontends/paddle/src/decoder_proto.hpp @@ -55,6 +55,8 @@ class DecoderProto : public paddle::DecoderBase { std::map map_for_each_output( const std::function(const std::string&, size_t)>& func) const; + int64_t get_version() const override; + private: std::vector<::paddle::framework::proto::OpDesc_Attr> decode_attribute_helper(const std::string& name) const; std::weak_ptr op_place; diff --git a/src/frontends/paddle/src/input_model.cpp b/src/frontends/paddle/src/input_model.cpp index 287fa5e54ad743..8518db040eea39 100644 --- a/src/frontends/paddle/src/input_model.cpp +++ b/src/frontends/paddle/src/input_model.cpp @@ -34,6 +34,9 @@ class InputModel::InputModelImpl { const std::shared_ptr& telemetry); std::vector get_inputs() const; std::vector get_outputs() const; + int64_t get_version() const { + return m_fw_ptr->version().version(); + } Place::Ptr get_place_by_tensor_name(const std::string& tensorName) const; void override_all_outputs(const std::vector& outputs); void override_all_inputs(const std::vector& inputs); @@ -589,6 +592,10 @@ std::vector InputModel::get_outputs() const { return _impl->get_outputs(); } +int64_t InputModel::get_version() const { + return _impl->get_version(); +} + Place::Ptr InputModel::get_place_by_tensor_name(const std::string& tensorName) const { return _impl->get_place_by_tensor_name(tensorName); } diff --git a/src/frontends/paddle/src/input_model.hpp b/src/frontends/paddle/src/input_model.hpp index 069e7a94c98b34..8607cf30134129 100644 --- a/src/frontends/paddle/src/input_model.hpp +++ b/src/frontends/paddle/src/input_model.hpp @@ -32,6 +32,7 @@ class InputModel : public ov::frontend::InputModel { ov::PartialShape get_partial_shape(const Place::Ptr& place) const override; void set_element_type(const Place::Ptr& place, const ov::element::Type&) override; void set_tensor_value(const Place::Ptr& place, const void* value) override; + int64_t get_version() const; private: friend class ov::frontend::paddle::FrontEnd; diff --git a/src/frontends/paddle/src/op/argmax.cpp b/src/frontends/paddle/src/op/argmax.cpp index 10029a385eb08d..7ec245a8c2ffbe 100644 --- a/src/frontends/paddle/src/op/argmax.cpp +++ b/src/frontends/paddle/src/op/argmax.cpp @@ -28,9 +28,17 @@ NamedOutputs argmax(const NodeContext& node) { const Output reshape_flatten = ov::opset6::Constant::create(ov::element::i64, {1}, {-1}); auto node_reshape = std::make_shared(data, reshape_flatten, true); auto node_topk = std::make_shared(node_reshape, k, axis, "max", "index", index_element_type); - return node.default_single_output_mapping( - {std::make_shared(node_topk->output(1), element::i64)}, - {"Out"}); + const auto output_info = node.get_output_port_infos("Out"); + size_t output_size = output_info[0].second.size(); + if (output_size == 0) { + auto out = std::make_shared(node_topk->output(1)); + return node.default_single_output_mapping({std::make_shared(out, element::i64)}, + {"Out"}); + } else { + return node.default_single_output_mapping( + {std::make_shared(node_topk->output(1), element::i64)}, + {"Out"}); + } } } diff --git a/src/frontends/paddle/src/op/elementwise_ops.cpp b/src/frontends/paddle/src/op/elementwise_ops.cpp index d0c3a12c48b60b..edbe9564883a99 100644 --- a/src/frontends/paddle/src/op/elementwise_ops.cpp +++ b/src/frontends/paddle/src/op/elementwise_ops.cpp @@ -42,15 +42,15 @@ NamedOutputs elementwise_pow(const NodeContext& node_context) { return elementwise_ops(node_context); } -NamedOutputs elementwise_equal(const NodeContext& node_context) { +NamedOutputs equal(const NodeContext& node_context) { return elementwise_ops(node_context); } -NamedOutputs elementwise_greater_equal(const NodeContext& node_context) { +NamedOutputs greater_equal(const NodeContext& node_context) { return elementwise_ops(node_context); } -NamedOutputs elementwise_not_equal(const NodeContext& node_context) { +NamedOutputs not_equal(const NodeContext& node_context) { return elementwise_ops(node_context); } @@ -61,10 +61,17 @@ NamedOutputs elementwise_floordiv(const NodeContext& node_context) { if (node_context.has_attribute("axis")) { axis = node_context.get_attribute("axis"); } + + int64_t pd_version = node_context.get_version(); + + bool python_div = false; + if (pd_version >= 2005000 || pd_version == 0) { + python_div = true; + } return node_context.default_single_output_mapping( {std::make_shared(x, y, - false, + python_div, ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, axis))}, {"Out"}); } diff --git a/src/frontends/paddle/src/op/fill_constant_batch_size_like.cpp b/src/frontends/paddle/src/op/fill_constant_batch_size_like.cpp index 4f5c3c891c4c4f..cf23a4a2e151b6 100644 --- a/src/frontends/paddle/src/op/fill_constant_batch_size_like.cpp +++ b/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 \ No newline at end of file diff --git a/src/frontends/paddle/src/op/grid_sampler.cpp b/src/frontends/paddle/src/op/grid_sampler.cpp index 148ad60cfd7d1e..b78c3ea345ad1e 100644 --- a/src/frontends/paddle/src/op/grid_sampler.cpp +++ b/src/frontends/paddle/src/op/grid_sampler.cpp @@ -4,11 +4,15 @@ #include "default_opset.hpp" #include "openvino/frontend/paddle/node_context.hpp" +#include "openvino/op/grid_sample.hpp" namespace ov { namespace frontend { namespace paddle { namespace op { + +using namespace ov::op; + NamedOutputs grid_sampler(const NodeContext& node) { auto data = node.get_input("X"); auto grid = node.get_input("Grid"); diff --git a/src/frontends/paddle/src/op/matmul_v2.cpp b/src/frontends/paddle/src/op/matmul_v2.cpp index 12dc2eee018072..2a096569d0335b 100644 --- a/src/frontends/paddle/src/op/matmul_v2.cpp +++ b/src/frontends/paddle/src/op/matmul_v2.cpp @@ -16,7 +16,9 @@ NamedOutputs matmul_v2(const NodeContext& node) { const auto mm = std::make_shared(x, y, transpose_a, transpose_b); std::shared_ptr result = mm; - if (is_scalar(mm->get_output_partial_shape(0))) { + const auto output_info = node.get_output_port_infos("Out"); + size_t output_size = output_info[0].second.size(); + if (is_scalar(mm->get_output_partial_shape(0)) && output_size) { auto unsqueeze_scalar = default_opset::Constant::create(ov::element::i64, {}, {0}); result = std::make_shared(mm, unsqueeze_scalar); } diff --git a/src/frontends/paddle/src/op/p_norm.cpp b/src/frontends/paddle/src/op/p_norm.cpp index 3023700e5e57ee..645bd9e53c9b11 100644 --- a/src/frontends/paddle/src/op/p_norm.cpp +++ b/src/frontends/paddle/src/op/p_norm.cpp @@ -18,22 +18,20 @@ NamedOutputs p_norm(const NodeContext& node) { const auto absNode = std::make_shared(data); const auto axisNode = default_opset::Constant::create(ov::element::i32, {1}, {axis}); + std::shared_ptr p_norm_node; + const auto input_shape = data.get_partial_shape(); + if (p == std::numeric_limits::infinity()) { - return node.default_single_output_mapping( - {std::make_shared(absNode, axisNode, keepdim)}, - {"Out"}); + p_norm_node = std::make_shared(absNode, axisNode, keepdim); } else if (p == -std::numeric_limits::infinity()) { - return node.default_single_output_mapping( - {std::make_shared(absNode, axisNode, keepdim)}, - {"Out"}); + p_norm_node = std::make_shared(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(absNode, zero); const auto converted_non_zero = std::make_shared(non_zero, input_dtype); - const auto reduce_sum = std::make_shared(converted_non_zero, axisNode, keepdim); - const auto input_shape = data.get_partial_shape(); + p_norm_node = std::make_shared(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,23 @@ 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(reduce_sum, one, false); - return node.default_single_output_mapping({out}, {"Out"}); + p_norm_node = std::make_shared(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(absNode, power_factor); const auto reduce_sum = std::make_shared(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(reduce_sum, extract_factor)}, - {"Out"}); + p_norm_node = std::make_shared(reduce_sum, extract_factor); + } + + const auto output_info = node.get_output_port_infos("Out"); + size_t output_size = output_info[0].second.size(); + if ((axis == -1 || input_shape.size() == 1) && !keepdim && !output_size) { + p_norm_node = std::make_shared(p_norm_node); } + return node.default_single_output_mapping({p_norm_node}, {"Out"}); } } // namespace op diff --git a/src/frontends/paddle/src/op/reduce_ops.hpp b/src/frontends/paddle/src/op/reduce_ops.hpp index bc700c1ed0327e..0944d1081ff759 100644 --- a/src/frontends/paddle/src/op/reduce_ops.hpp +++ b/src/frontends/paddle/src/op/reduce_ops.hpp @@ -40,6 +40,12 @@ NamedOutputs reduce_ops(const NodeContext& node) { auto unsqueeze_scalar = default_opset::Constant::create(ov::element::i64, {}, {0}); result = std::make_shared(reduceNode, unsqueeze_scalar); } + + const auto output_info = node.get_output_port_infos("Out"); + size_t output_size = output_info[0].second.size(); + if (reduce_all && !output_size) { + result = std::make_shared(reduceNode); + } return node.default_single_output_mapping({result}, {"Out"}); } diff --git a/src/frontends/paddle/src/op/reverse.cpp b/src/frontends/paddle/src/op/reverse.cpp index 097e13b401986b..bf986055dab067 100644 --- a/src/frontends/paddle/src/op/reverse.cpp +++ b/src/frontends/paddle/src/op/reverse.cpp @@ -14,4 +14,4 @@ NamedOutputs reverse(const NodeContext& node) { } // namespace op } // namespace paddle } // namespace frontend -} // namespace ov +} // namespace ov \ No newline at end of file diff --git a/src/frontends/paddle/src/op_table.cpp b/src/frontends/paddle/src/op_table.cpp index f701065569517e..4ed557a4edd13e 100644 --- a/src/frontends/paddle/src/op_table.cpp +++ b/src/frontends/paddle/src/op_table.cpp @@ -29,25 +29,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); @@ -152,22 +152,22 @@ std::map 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}, @@ -175,7 +175,7 @@ std::map get_supported_ops() { {"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}, @@ -202,7 +202,7 @@ std::map 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}, @@ -255,8 +255,7 @@ std::map 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 diff --git a/src/frontends/paddle/src/place.hpp b/src/frontends/paddle/src/place.hpp index fc2fe9eb29efe0..583d5191feab81 100644 --- a/src/frontends/paddle/src/place.hpp +++ b/src/frontends/paddle/src/place.hpp @@ -44,6 +44,10 @@ class Place : public ov::frontend::Place { return m_names; } + int64_t get_version() const { + return dynamic_cast(m_input_model).get_version(); + } + private: const ov::frontend::InputModel& m_input_model; std::vector m_names; diff --git a/src/frontends/paddle/src/proto/framework.proto b/src/frontends/paddle/src/proto/framework.proto index 22112cba29667d..cfcc10c6ee692f 100644 --- a/src/frontends/paddle/src/proto/framework.proto +++ b/src/frontends/paddle/src/proto/framework.proto @@ -41,8 +41,31 @@ enum AttrType { VAR = 13; VARS = 14; FLOAT64 = 15; + SCALAR = 16; + SCALARS = 17; } + +message Complex { + required double r = 1; + required double i = 2; +}; + +message Scalar { + enum Type { + BOOLEAN = 1; + LONG = 2; + FLOAT64 = 3; + COMPLEX128 = 4; + } + required Type type = 1; + + optional bool b = 2; + optional int64 i = 3; + optional double r = 4; + optional Complex c = 5; +}; + // OpDesc describes an instance of a C++ framework::OperatorBase // derived class type. message OpDesc { @@ -66,6 +89,8 @@ message OpDesc { optional string var_name = 17; repeated string vars_name = 18; optional double float64 = 19; + optional Scalar scalar = 20; + repeated Scalar scalars = 21; }; message Var { @@ -126,7 +151,7 @@ message VarType { FP16 = 4; FP32 = 5; FP64 = 6; - // Tensor is used in C++. + // phi::DenseTensor is used in C++. SIZE_T = 19; UINT8 = 20; INT8 = 21; diff --git a/src/frontends/paddle/tests/CMakeLists.txt b/src/frontends/paddle/tests/CMakeLists.txt index 6d373e67c0a663..078a133138aa45 100644 --- a/src/frontends/paddle/tests/CMakeLists.txt +++ b/src/frontends/paddle/tests/CMakeLists.txt @@ -21,9 +21,6 @@ else() set(paddlepaddle_FOUND ON) endif() -# PDPD 2.5.1 is not compatible with tests models we use -set(paddlepaddle_FOUND OFF) - if(paddlepaddle_FOUND) set(ctest_labels OV UNIT) endif() diff --git a/src/frontends/paddle/tests/op_fuzzy.cpp b/src/frontends/paddle/tests/op_fuzzy.cpp index 8487bed8827af3..d99862ceb69490 100644 --- a/src/frontends/paddle/tests/op_fuzzy.cpp +++ b/src/frontends/paddle/tests/op_fuzzy.cpp @@ -192,22 +192,21 @@ static const std::vector models{ std::string("flip_5"), std::string("flip_dynamic_1"), std::string("flip_dynamic_2"), - std::string("fill_any_like"), - std::string("fill_any_like_f16"), - std::string("fill_any_like_f32"), - std::string("fill_any_like_f64"), - std::string("fill_any_like_i16"), - std::string("fill_any_like_i32"), - std::string("fill_any_like_i64"), - std::string("fill_any_like_bool"), - std::string("fill_any_like_bool_2"), - std::string("fill_constant"), - std::string("fill_constant_batch_size_like"), - std::string("fill_constant_int32"), - std::string("fill_constant_int64"), - std::string("fill_constant_tensor"), - std::string("fill_constant_shape_tensor"), - std::string("fill_constant_shape_tensor_list"), + std::string("full_like"), + std::string("full_like_f16"), + std::string("full_like_f32"), + std::string("full_like_f64"), + std::string("full_like_i16"), + std::string("full_like_i32"), + std::string("full_like_i64"), + std::string("full_like_bool"), + std::string("full_like_bool_2"), + std::string("full"), + std::string("full_int32"), + std::string("full_int64"), + std::string("full_tensor"), + std::string("full_shape_tensor"), + std::string("full_shape_tensor_list"), std::string("flatten_contiguous_range_test1"), std::string("floor_float32"), std::string("floor_mod1"), @@ -244,7 +243,8 @@ static const std::vector models{ std::string("greater_than_int64"), std::string("grid_sampler_1"), std::string("grid_sampler_2"), - std::string("grid_sampler_dyn"), + // std::string("grid_sampler_3"), + // std::string("grid_sampler_dyn"), std::string("group_norm_1/group_norm_1.pdmodel"), std::string("group_norm_2/group_norm_2.pdmodel"), std::string("group_norm_3/group_norm_3.pdmodel"), @@ -282,15 +282,15 @@ static const std::vector models{ std::string("loop/loop.pdmodel"), std::string("loop_dyn/loop_dyn.pdmodel"), std::string("loop_dyn_x/loop_dyn_x.pdmodel"), - std::string("loop_if/loop_if.pdmodel"), - std::string("loop_if_loop/loop_if_loop.pdmodel"), - std::string("loop_if_loop_if/loop_if_loop_if.pdmodel"), - std::string("loop_if_loop_complex/loop_if_loop_complex.pdmodel"), + // std::string("loop_if/loop_if.pdmodel"), + // std::string("loop_if_loop/loop_if_loop.pdmodel"), + // std::string("loop_if_loop_if/loop_if_loop_if.pdmodel"), + // std::string("loop_if_loop_complex/loop_if_loop_complex.pdmodel"), // disabed due to slice could not produce full dynamic shape // std::string("loop_if_tensor_array/loop_if_tensor_array.pdmodel"), + // std::string("loop_x/loop_x.pdmodel"), std::string("loop_t/loop_t.pdmodel"), std::string("loop_tensor_array/loop_tensor_array.pdmodel"), - std::string("loop_x/loop_x.pdmodel"), std::string("matmul_xt/matmul_xt.pdmodel"), std::string("matmul_xt_yt/matmul_xt_yt.pdmodel"), std::string("matmul_yt/matmul_yt.pdmodel"), @@ -446,14 +446,6 @@ static const std::vector models{ std::string("reshape"), std::string("reshape_tensor"), std::string("reshape_tensor_list"), - std::string("reverse_static_1"), - std::string("reverse_static_2"), - std::string("reverse_static_3"), - std::string("reverse_static_4"), - std::string("reverse_dynamic_1"), - std::string("reverse_dynamic_2"), - std::string("reverse_dynamic_3"), - std::string("reverse_dynamic_4"), std::string("rnn_lstm_layer_1_bidirectional/rnn_lstm_layer_1_bidirectional.pdmodel"), std::string("rnn_lstm_layer_1_forward/rnn_lstm_layer_1_forward.pdmodel"), std::string("rnn_lstm_layer_2_bidirectional/rnn_lstm_layer_2_bidirectional.pdmodel"), diff --git a/src/frontends/paddle/tests/places.cpp b/src/frontends/paddle/tests/places.cpp index 17f0df7e2d7aed..655d3941d69a66 100644 --- a/src/frontends/paddle/tests/places.cpp +++ b/src/frontends/paddle/tests/places.cpp @@ -3,6 +3,8 @@ // #include +#include +#include #include #include "gtest/gtest.h" @@ -10,50 +12,42 @@ using namespace ov::frontend; -const std::string model_file = std::string(TEST_PADDLE_MODELS_DIRNAME) + "place_test_model/place_test_model.pdmodel"; - -/*** -model: - - [input] - | - [const] [const] [transpose] - \ | / - [ RNN (LSTM) ] - / | \ - [transpose] [scale_{1,2}] [relu_{0,1,2}] - | | | - [scale_0] [out_{1,2}] [scale_{3,4,5}] - | | - [out_1] [out_{3,4,5}] - -***/ - -std::vector tensor_names = { - "x", - "const_1.tmp_0", - "const_2.tmp_0", - "transpose_0.tmp_0", - "transpose_0.tmp_1", - "lstm_0.tmp_0", - "lstm_0._generated_var_0", - "lstm_0.tmp_3", - "lstm_0.tmp_1", - "lstm_0.tmp_2", - "transpose_1.tmp_0", - "transpose_1.tmp_1", - "relu_1.tmp_0", - "relu_2.tmp_0", - "relu_3.tmp_0", - "save_infer_model/scale_0.tmp_0", - "save_infer_model/scale_1.tmp_0", - "save_infer_model/scale_2.tmp_0", - "save_infer_model/scale_3.tmp_0", - "save_infer_model/scale_4.tmp_0", - "save_infer_model/scale_5.tmp_0", +const std::string model_file = FrontEndTestUtils::make_model_path(std::string(TEST_PADDLE_MODELS_DIRNAME) + + "place_test_model/place_test_model.pdmodel"); +const std::string vars_name_file = + FrontEndTestUtils::make_model_path(std::string(TEST_PADDLE_MODELS_DIRNAME) + "place_test_model/vars_name.txt"); +const std::string outputs_name_file = + FrontEndTestUtils::make_model_path(std::string(TEST_PADDLE_MODELS_DIRNAME) + "place_test_model/outputs_name.txt"); + +class Paddle_Places : public ::testing::Test { +protected: + void SetUp() override { + std::fstream name_file; + name_file.open(vars_name_file, std::ios::in); + if (name_file.is_open()) { + std::string name; + while (std::getline(name_file, name)) + tensor_names.push_back(name); + name_file.close(); + } else + FRONT_END_THROW("Can not open " + vars_name_file); + + std::fstream output_file; + output_file.open(outputs_name_file, std::ios::in); + if (output_file.is_open()) { + std::string name; + while (std::getline(output_file, name)) + output_names.push_back(name); + output_file.close(); + } else + FRONT_END_THROW("Can not open " + outputs_name_file); + } + + std::vector tensor_names; + std::vector output_names; }; -TEST(Paddle_Places, check_tensor_names) { +TEST_F(Paddle_Places, check_tensor_names) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -66,7 +60,7 @@ TEST(Paddle_Places, check_tensor_names) { } } -TEST(Paddle_Places, check_input_outputs) { +TEST_F(Paddle_Places, check_input_outputs) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -82,13 +76,6 @@ TEST(Paddle_Places, check_input_outputs) { auto tensor_place = input_model->get_place_by_tensor_name("x"); tensor_place->is_equal(inputs[0]); - std::vector output_names = {"save_infer_model/scale_0.tmp_0", - "save_infer_model/scale_1.tmp_0", - "save_infer_model/scale_2.tmp_0", - "save_infer_model/scale_3.tmp_0", - "save_infer_model/scale_4.tmp_0", - "save_infer_model/scale_5.tmp_0"}; - for (const auto& name : output_names) { const auto output_place = input_model->get_place_by_tensor_name(name); auto it = std::find_if(outputs.begin(), outputs.end(), [&output_place](const Place::Ptr& place) { @@ -99,7 +86,7 @@ TEST(Paddle_Places, check_input_outputs) { } // all existed in the model ops have "Out" port -TEST(Paddle_Places, check_out_port_of_all_ops) { +TEST_F(Paddle_Places, check_out_port_of_all_ops) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -121,7 +108,7 @@ TEST(Paddle_Places, check_out_port_of_all_ops) { } } -TEST(Paddle_Places, check_in_out_ports_of_model_outputs) { +TEST_F(Paddle_Places, check_in_out_ports_of_model_outputs) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -155,7 +142,7 @@ TEST(Paddle_Places, check_in_out_ports_of_model_outputs) { } } -TEST(Paddle_Places, check_source_target_tensors_of_model_outputs) { +TEST_F(Paddle_Places, check_source_target_tensors_of_model_outputs) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -189,7 +176,7 @@ TEST(Paddle_Places, check_source_target_tensors_of_model_outputs) { } } -TEST(Paddle_Places, check_producing_consuming_ops_of_model_outputs) { +TEST_F(Paddle_Places, check_producing_consuming_ops_of_model_outputs) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -224,7 +211,7 @@ TEST(Paddle_Places, check_producing_consuming_ops_of_model_outputs) { } // check data flow [ output port -> tensor -> input port ] -TEST(Paddle_Places, check_data_flow) { +TEST_F(Paddle_Places, check_data_flow) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -263,7 +250,7 @@ TEST(Paddle_Places, check_data_flow) { // -> input_port_2 // -> input_port_N] // input_port, input_port_2, ... input_port_N are equal data -TEST(Paddle_Places, check_tensor_to_multiple_ports) { +TEST_F(Paddle_Places, check_tensor_to_multiple_ports) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -289,7 +276,7 @@ TEST(Paddle_Places, check_tensor_to_multiple_ports) { } // consuming ops should be equal for tensor place and producing output port -TEST(Paddle_Places, check_consuming_ops) { +TEST_F(Paddle_Places, check_consuming_ops) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -330,7 +317,7 @@ TEST(Paddle_Places, check_consuming_ops) { } } -TEST(Paddle_Places, check_consuming_ops_2) { +TEST_F(Paddle_Places, check_consuming_ops_2) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -369,7 +356,7 @@ TEST(Paddle_Places, check_consuming_ops_2) { } } -TEST(Paddle_Places, check_producing_ops) { +TEST_F(Paddle_Places, check_producing_ops) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); @@ -391,20 +378,13 @@ TEST(Paddle_Places, check_producing_ops) { } } -TEST(Paddle_Places, check_input_output_ports_dy_idx) { +TEST_F(Paddle_Places, check_input_output_ports_dy_idx) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); InputModel::Ptr input_model; ASSERT_NO_THROW(input_model = frontend->load(FrontEndTestUtils::make_model_path(model_file))); - std::vector output_names = {"save_infer_model/scale_0.tmp_0", - "save_infer_model/scale_1.tmp_0", - "save_infer_model/scale_2.tmp_0", - "save_infer_model/scale_3.tmp_0", - "save_infer_model/scale_4.tmp_0", - "save_infer_model/scale_5.tmp_0"}; - for (const auto& tensor_name : output_names) { auto tensor_place = input_model->get_place_by_tensor_name(tensor_name); EXPECT_NE(tensor_place, nullptr); @@ -417,20 +397,13 @@ TEST(Paddle_Places, check_input_output_ports_dy_idx) { } } -TEST(Paddle_Places, check_ops_tensors_by_idx) { +TEST_F(Paddle_Places, check_ops_tensors_by_idx) { auto fem = FrontEndManager(); FrontEnd::Ptr frontend; ASSERT_NO_THROW(frontend = fem.load_by_framework(PADDLE_FE)); InputModel::Ptr input_model; ASSERT_NO_THROW(input_model = frontend->load(FrontEndTestUtils::make_model_path(model_file))); - std::vector output_names = {"save_infer_model/scale_0.tmp_0", - "save_infer_model/scale_1.tmp_0", - "save_infer_model/scale_2.tmp_0", - "save_infer_model/scale_3.tmp_0", - "save_infer_model/scale_4.tmp_0", - "save_infer_model/scale_5.tmp_0"}; - for (const auto& tensor_name : output_names) { auto tensor_place = input_model->get_place_by_tensor_name(tensor_name); EXPECT_NE(tensor_place, nullptr); diff --git a/src/frontends/paddle/tests/read_paddle_model_test.cpp b/src/frontends/paddle/tests/read_paddle_model_test.cpp index b362566f52af11..08beac86b67f24 100644 --- a/src/frontends/paddle/tests/read_paddle_model_test.cpp +++ b/src/frontends/paddle/tests/read_paddle_model_test.cpp @@ -20,8 +20,10 @@ #include "openvino/pass/serialize.hpp" TEST(Paddle_Reader_Tests, LoadModelMemoryToCore) { - auto model = std::string(TEST_PADDLE_MODELS_DIRNAME) + "conv2d_relu/conv2d_relu.pdmodel"; - auto param = std::string(TEST_PADDLE_MODELS_DIRNAME) + "conv2d_relu/conv2d_relu.pdiparams"; + auto model = + FrontEndTestUtils::make_model_path(std::string(TEST_PADDLE_MODELS_DIRNAME) + "conv2d_relu/conv2d_relu.pdmodel"); + auto param = FrontEndTestUtils::make_model_path(std::string(TEST_PADDLE_MODELS_DIRNAME) + + "conv2d_relu/conv2d_relu.pdiparams"); ov::Core core; auto read_file = [&](const std::string& file_name, size_t& size) { @@ -73,7 +75,7 @@ TEST(Paddle_Reader_Tests, LoadModelMemoryToCore) { } TEST(Paddle_Reader_Tests, ImportBasicModelToCore) { - auto model = std::string(TEST_PADDLE_MODELS_DIRNAME) + "relu/relu.pdmodel"; + auto model = FrontEndTestUtils::make_model_path(std::string(TEST_PADDLE_MODELS_DIRNAME) + "relu/relu.pdmodel"); ov::Core core; auto function = core.read_model(FrontEndTestUtils::make_model_path(model)); diff --git a/src/frontends/paddle/tests/skip_tests_config.cpp b/src/frontends/paddle/tests/skip_tests_config.cpp index 144e9d001ae276..c5ca1227a9a693 100644 --- a/src/frontends/paddle/tests/skip_tests_config.cpp +++ b/src/frontends/paddle/tests/skip_tests_config.cpp @@ -11,7 +11,8 @@ std::vector disabledTestPatterns() { return { #ifdef OPENVINO_STATIC_LIBRARY // Disable tests for static libraries - ".*FrontendLibCloseTest.*" + ".*FrontendLibCloseTest.*", #endif + ".*testUnloadLibBeforeDeletingDependentObject.*", }; } diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out.py index 5d6cd952189692..54911ebdc59443 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out.py @@ -14,24 +14,45 @@ inp_blob1 = np.random.randn(1, 1, 3, 3).astype(np.float32) inp_blob2 = np.random.randn(1, 2, 3, 3).astype(np.float32) -x1 = fluid.data(name='inputX1', shape=[1, 1, 3, 3], dtype='float32') -x2 = fluid.data(name='inputX2', shape=[1, 2, 3, 3], dtype='float32') +if paddle.__version__ >= '2.0.0': + x1 = paddle.static.data(name='inputX1', shape=[1, 1, 3, 3], dtype='float32') + x2 = paddle.static.data(name='inputX2', shape=[1, 2, 3, 3], dtype='float32') +else: + x1 = fluid.data(name='inputX1', shape=[1, 1, 3, 3], dtype='float32') + x2 = fluid.data(name='inputX2', shape=[1, 2, 3, 3], dtype='float32') -conv2d1 = fluid.layers.conv2d(input=x1, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), +if paddle.__version__ >= '2.0.0': + conv2d1 = paddle.static.nn.conv2d(input=x1, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), + dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX1") + + conv2d2 = paddle.static.nn.conv2d(input=x2, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), + dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX2") + + add1 = paddle.add(conv2d1, conv2d2, name="add1.tmp_0") + + relu2a = paddle.nn.functional.relu(add1, name="relu2a") + relu2b = paddle.nn.functional.relu(add1, name="relu2b") + + add2 = paddle.add(relu2a, relu2b, name="add2.tmp_0") + + relu3a = paddle.nn.functional.relu(add2, name="relu3a") + relu3b = paddle.nn.functional.relu(add2, name="relu3b") +else: + conv2d1 = fluid.layers.conv2d(input=x1, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX1") -conv2d2 = fluid.layers.conv2d(input=x2, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), - dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX2") + conv2d2 = fluid.layers.conv2d(input=x2, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), + dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX2") -add1 = fluid.layers.elementwise_add(conv2d1, conv2d2, name="add1") + add1 = fluid.layers.elementwise_add(conv2d1, conv2d2, name="add1") -relu2a = fluid.layers.relu(add1, name="relu2a") -relu2b = fluid.layers.relu(add1, name="relu2b") + relu2a = fluid.layers.relu(add1, name="relu2a") + relu2b = fluid.layers.relu(add1, name="relu2b") -add2 = fluid.layers.elementwise_add(relu2a, relu2b, name="add2") + add2 = fluid.layers.elementwise_add(relu2a, relu2b, name="add2") -relu3a = fluid.layers.relu(add2, name="relu3a") -relu3b = fluid.layers.relu(add2, name="relu3b") + relu3a = fluid.layers.relu(add2, name="relu3a") + relu3b = fluid.layers.relu(add2, name="relu3b") exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out_dynbatch.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out_dynbatch.py index d3fc8c95207d0f..b49b4ad6e5d182 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out_dynbatch.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_2in_2out_dynbatch.py @@ -13,24 +13,44 @@ inp_blob1 = np.random.randn(1, 1, 3, 3).astype(np.float32) inp_blob2 = np.random.randn(1, 2, 3, 3).astype(np.float32) -x1 = fluid.data(name='inputX1', shape=[-1, 1, 3, 3], dtype='float32') -x2 = fluid.data(name='inputX2', shape=[-1, 2, 3, 3], dtype='float32') +if paddle.__version__ >= '2.0.0': + x1 = paddle.static.data(name='inputX1', shape=[-1, 1, 3, 3], dtype='float32') + x2 = paddle.static.data(name='inputX2', shape=[-1, 2, 3, 3], dtype='float32') -conv2d1 = fluid.layers.conv2d(input=x1, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), - dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX1") + conv2d1 = paddle.static.nn.conv2d(input=x1, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), + dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX1") -conv2d2 = fluid.layers.conv2d(input=x2, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), - dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX2") + conv2d2 = paddle.static.nn.conv2d(input=x2, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), + dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX2") -add1 = fluid.layers.elementwise_add(conv2d1, conv2d2, name="add1") + add1 = paddle.add(conv2d1, conv2d2, name="add1") -relu2a = fluid.layers.relu(add1, name="relu2a") -relu2b = fluid.layers.relu(add1, name="relu2b") + relu2a = paddle.nn.functional.relu(add1, name="relu2a") + relu2b = paddle.nn.functional.relu(add1, name="relu2b") -add2 = fluid.layers.elementwise_add(relu2a, relu2b, name="add2") + add2 = paddle.add(relu2a, relu2b, name="add2") -relu3a = fluid.layers.relu(add2, name="relu3a") -relu3b = fluid.layers.relu(add2, name="relu3b") + relu3a = paddle.nn.functional.relu(add2, name="relu3a") + relu3b = paddle.nn.functional.relu(add2, name="relu3b") +else: + x1 = fluid.data(name='inputX1', shape=[-1, 1, 3, 3], dtype='float32') + x2 = fluid.data(name='inputX2', shape=[-1, 2, 3, 3], dtype='float32') + + conv2d1 = fluid.layers.conv2d(input=x1, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), + dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX1") + + conv2d2 = fluid.layers.conv2d(input=x2, num_filters=1, filter_size=(1, 1), stride=(1, 1), padding=(0, 0), + dilation=(1, 1), groups=1, bias_attr=False, name="conv2dX2") + + add1 = fluid.layers.elementwise_add(conv2d1, conv2d2, name="add1") + + relu2a = fluid.layers.relu(add1, name="relu2a") + relu2b = fluid.layers.relu(add1, name="relu2b") + + add2 = fluid.layers.elementwise_add(relu2a, relu2b, name="add2") + + relu3a = fluid.layers.relu(add2, name="relu3a") + relu3b = fluid.layers.relu(add2, name="relu3b") exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_clip.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_clip.py index 39979ee1d0787f..5fe76bf6a0e0a8 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_clip.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_clip.py @@ -14,7 +14,10 @@ def clip(name: str, x, min, max): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype='float32') - out = paddle.fluid.layers.clip(node_x, min=min, max=max) + if paddle.__version__ >= '2.0.0': + out = paddle.clip(node_x, min=min, max=max) + else: + out = paddle.fluid.layers.clip(node_x, min=min, max=max) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_relu.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_relu.py index d28ed1d52fa366..ebd06b34e9002f 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_relu.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_relu.py @@ -12,17 +12,26 @@ inp_blob = np.random.randn(1, 3, 4, 4).astype(np.float32) -x = fluid.data(name='xxx', shape=[1, 3, 4, 4], dtype='float32') -test_layer = fluid.layers.conv2d(input=x, num_filters=5, filter_size=(1, 1), stride=(1, 1), padding=(1, 1), +if paddle.__version__ >= '2.0.0': + x = paddle.static.data(name='xxx', shape=[1, 3, 4, 4], dtype='float32') + test_layer = paddle.static.nn.conv2d(input=x, num_filters=5, filter_size=(1, 1), stride=(1, 1), padding=(1, 1), + dilation=(1, 1), groups=1, bias_attr=False) +else: + x = fluid.data(name='xxx', shape=[1, 3, 4, 4], dtype='float32') + test_layer = fluid.layers.conv2d(input=x, num_filters=5, filter_size=(1, 1), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, bias_attr=False) -relu = fluid.layers.relu(test_layer) +if paddle.__version__ >= '2.0.0': + relu = paddle.nn.functional.relu(test_layer) +else: + relu = fluid.layers.relu(test_layer) exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) inp_dict = {'xxx': inp_blob} var = [relu] -res_paddle = exe.run(fluid.default_main_program(), fetch_list=var, feed=inp_dict) +res_paddle = exe.run(fluid.default_main_program(), + fetch_list=var, feed=inp_dict) -fluid.io.save_inference_model(os.path.join(sys.argv[1], "conv2d_relu"), list(inp_dict.keys()), var, exe, - model_filename="conv2d_relu.pdmodel", params_filename="conv2d_relu.pdiparams") +paddle.fluid.io.save_inference_model(os.path.join(sys.argv[1], "conv2d_relu"), list(inp_dict.keys()), var, exe, + model_filename="conv2d_relu.pdmodel", params_filename="conv2d_relu.pdiparams") diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_s.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_s.py index 2568bc6bfe217e..1463cb5a43e88a 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_s.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_conv2d_s.py @@ -11,15 +11,21 @@ inp_blob = np.random.randn(1, 3, 4, 4).astype(np.float32) -x = fluid.data(name='x', shape=[1, 3, 4, 4], dtype='float32') -test_layer = fluid.layers.conv2d(input=x, num_filters=5, filter_size=(1, 1), stride=(1, 1), padding=(1, 1), - dilation=(1, 1), groups=1, bias_attr=False) +if paddle.__version__ >= '2.0.0': + x = paddle.static.data(name='x', shape=[1, 3, 4, 4], dtype='float32') + test_layer = paddle.static.nn.conv2d(input=x, num_filters=5, filter_size=(1, 1), stride=(1, 1), padding=(1, 1), + dilation=(1, 1), groups=1, bias_attr=False) +else: + x = fluid.data(name='x', shape=[1, 3, 4, 4], dtype='float32') + test_layer = fluid.layers.conv2d(input=x, num_filters=5, filter_size=(1, 1), stride=(1, 1), padding=(1, 1), + dilation=(1, 1), groups=1, bias_attr=False) exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) inp_dict = {'x': inp_blob} var = [test_layer] -res_paddle = exe.run(fluid.default_main_program(), fetch_list=var, feed=inp_dict) +res_paddle = exe.run(fluid.default_main_program(), + fetch_list=var, feed=inp_dict) -fluid.io.save_inference_model(os.path.join(sys.argv[1], "conv2d_s"), list(inp_dict.keys()), var, exe, - model_filename="conv2d.pdmodel", params_filename="conv2d.pdiparams") +paddle.fluid.io.save_inference_model(os.path.join(sys.argv[1], "conv2d_s"), list(inp_dict.keys()), var, exe, + model_filename="conv2d.pdmodel", params_filename="conv2d.pdiparams") diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_dynamic_pool2d.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_dynamic_pool2d.py index 515fec958ec6af..e967cd06d6d716 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_dynamic_pool2d.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_dynamic_pool2d.py @@ -15,13 +15,21 @@ paddle.enable_static() inp_blob1 = np.random.randn(1, 1, 224, 224).astype(np.float32) -x1 = fluid.data(name='inputX1', shape=[1, 1, -1, -1], dtype='float32') - -adative_pool2d = paddle.fluid.layers.adaptive_pool2d( - input=x1, - pool_size=[3,3], - pool_type='avg', - require_index=False) +if paddle.__version__ >= '2.0.0': + x1 = paddle.static.data(name='inputX1', shape=[ + 1, 1, -1, -1], dtype='float32') + + adative_pool2d = paddle.nn.functional.adaptive_avg_pool2d( + x=x1, + output_size=[3, 3]) +else: + x1 = fluid.data(name='inputX1', shape=[1, 1, -1, -1], dtype='float32') + + adative_pool2d = paddle.fluid.layers.adaptive_pool2d( + input=x1, + pool_size=[3, 3], + pool_type='avg', + require_index=False) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -32,4 +40,5 @@ feed={'inputX1': inp_blob1}, fetch_list=[adative_pool2d]) -saveModel("pool2d_dyn_hw", exe, feedkeys=['inputX1'], fetchlist=adative_pool2d, inputs=[inp_blob1], outputs=outs, target_dir=sys.argv[1]) +saveModel("pool2d_dyn_hw", exe, feedkeys=['inputX1'], fetchlist=adative_pool2d, inputs=[ + inp_blob1], outputs=outs, target_dir=sys.argv[1]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_elementwise_ops.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_elementwise_ops.py index 844ff58b963413..37f556e298b74f 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_elementwise_ops.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_elementwise_ops.py @@ -7,16 +7,21 @@ import numpy as np import sys from save_model import saveModel +import paddle -def elementwise_add(name : str, x, y, axis, in_dtype): +def elementwise_add(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) - out = paddle.fluid.layers.nn.elementwise_add(node_x, node_y, axis=axis) + if paddle.__version__ >= '2.0.0': + out = paddle.add(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_add( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -24,21 +29,26 @@ def elementwise_add(name : str, x, y, axis, in_dtype): # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) outs = exe.run( - feed={'x': x, 'y': y}, - fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + feed={'x': x, 'y': y}, + fetch_list=[out]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_sub(name : str, x, y, axis, in_dtype): +def elementwise_sub(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) - out = paddle.fluid.layers.nn.elementwise_sub(node_x, node_y, axis=axis) + if paddle.__version__ >= '2.0.0': + out = paddle.subtract(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_sub( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -46,21 +56,26 @@ def elementwise_sub(name : str, x, y, axis, in_dtype): # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) outs = exe.run( - feed={'x': x, 'y': y}, - fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + feed={'x': x, 'y': y}, + fetch_list=[out]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_div(name : str, x, y, axis, in_dtype): +def elementwise_div(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name = 'x', shape = x.shape, dtype = in_dtype) - node_y = paddle.static.data(name = 'y', shape = y.shape, dtype = in_dtype) - out = paddle.fluid.layers.nn.elementwise_div(node_x, node_y, axis=axis) + node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) + node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) + if paddle.__version__ >= '2.0.0': + out = paddle.divide(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_div( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -68,24 +83,29 @@ def elementwise_div(name : str, x, y, axis, in_dtype): # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) outs = exe.run( - feed={'x': x, 'y': y}, - fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + feed={'x': x, 'y': y}, + fetch_list=[out]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_mod(name : str, x, y, axis, in_dtype, is_api=False): +def elementwise_mod(name: str, x, y, in_dtype, is_api=False, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) - if is_api: + if paddle.__version__ >= '2.0.0': out = paddle.floor_mod(node_x, node_y) else: - out = paddle.fluid.layers.elementwise_mod(node_x, node_y, axis=axis) + if is_api: + out = paddle.floor_mod(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_mod( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -93,21 +113,26 @@ def elementwise_mod(name : str, x, y, axis, in_dtype, is_api=False): # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) outs = exe.run( - feed={'x': x, 'y': y}, - fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + feed={'x': x, 'y': y}, + fetch_list=[out]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_mul(name : str, x, y, axis, in_dtype): +def elementwise_mul(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name = 'x', shape = x.shape, dtype = in_dtype) - node_y = paddle.static.data(name = 'y', shape = y.shape, dtype = in_dtype) - out = paddle.fluid.layers.nn.elementwise_mul(node_x, node_y, axis=axis) + node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) + node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) + if paddle.__version__ >= '2.0.0': + out = paddle.multiply(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_mul( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -115,19 +140,21 @@ def elementwise_mul(name : str, x, y, axis, in_dtype): # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) outs = exe.run( - feed={'x': x, 'y': y}, - fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + feed={'x': x, 'y': y}, + fetch_list=[out]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_mul_bool(name : str, x, y, in_dtype='bool'): + +def elementwise_mul_bool(name: str, x, y, in_dtype='bool'): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name = 'x', shape = x.shape, dtype = in_dtype) - node_y = paddle.static.data(name = 'y', shape = y.shape, dtype = in_dtype) + node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) + node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) mul = node_x * node_y out = paddle.cast(mul, 'float32') @@ -137,21 +164,26 @@ def elementwise_mul_bool(name : str, x, y, in_dtype='bool'): # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) outs = exe.run( - feed={'x': x, 'y': y}, - fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + feed={'x': x, 'y': y}, + fetch_list=[out]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_min(name : str, x, y, axis, in_dtype): +def elementwise_min(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name = 'x', shape = x.shape, dtype = in_dtype) - node_y = paddle.static.data(name = 'y', shape = y.shape, dtype = in_dtype) - out = paddle.fluid.layers.nn.elementwise_min(node_x, node_y, axis=axis) + node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) + node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) + if paddle.__version__ >= '2.0.0': + out = paddle.minimum(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_min( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -161,19 +193,24 @@ def elementwise_min(name : str, x, y, axis, in_dtype): outs = exe.run( feed={'x': x, 'y': y}, fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_max(name : str, x, y, axis, in_dtype): +def elementwise_max(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name = 'x', shape = x.shape, dtype = in_dtype) - node_y = paddle.static.data(name = 'y', shape = y.shape, dtype = in_dtype) - out = paddle.fluid.layers.nn.elementwise_max(node_x, node_y, axis=axis) + node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) + node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) + if paddle.__version__ >= '2.0.0': + out = paddle.maximum(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_max( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -183,19 +220,24 @@ def elementwise_max(name : str, x, y, axis, in_dtype): outs = exe.run( feed={'x': x, 'y': y}, fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_pow(name : str, x, y, axis, in_dtype): +def elementwise_pow(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name = 'x', shape = x.shape, dtype = in_dtype) - node_y = paddle.static.data(name = 'y', shape = y.shape, dtype = in_dtype) - out = paddle.fluid.layers.nn.elementwise_pow(node_x, node_y, axis=axis) + node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) + node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) + if paddle.__version__ >= '2.0.0': + out = paddle.pow(node_x, node_y) + else: + out = paddle.fluid.layers.elementwise_pow( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -205,24 +247,24 @@ def elementwise_pow(name : str, x, y, axis, in_dtype): outs = exe.run( feed={'x': x, 'y': y}, fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_floordiv(name : str, x, y, axis, in_dtype): +def elementwise_floordiv(name: str, x, y, in_dtype, axis=-1): import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name = 'x', shape = x.shape, dtype = in_dtype) - node_y = paddle.static.data(name = 'y', shape = y.shape, dtype = in_dtype) - if paddle.__version__ == "1.8": - out = paddle.fluid.layers.nn.elementwise_floordiv(node_x, node_y, axis=axis) - else: - if axis != -1: - pass + node_x = paddle.static.data(name='x', shape=x.shape, dtype=in_dtype) + node_y = paddle.static.data(name='y', shape=y.shape, dtype=in_dtype) + if paddle.__version__ >= '2.0.0': out = paddle.floor_divide(node_x, node_y) + else: + out = paddle.fluid.layers.nn.elementwise_floordiv( + node_x, node_y, axis=axis) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -232,20 +274,21 @@ def elementwise_floordiv(name : str, x, y, axis, in_dtype): outs = exe.run( feed={'x': x, 'y': y}, fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[x, y], outputs=[outs[0]], target_dir=sys.argv[1]) + saveModel(name, exe, feedkeys=['x', 'y'], fetchlist=[out], inputs=[ + x, y], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] -def elementwise_ops(name : str, data_x, data_y, axis, in_dtype): - elementwise_add("elementwise_add" + name, data_x, data_y, axis, in_dtype) - elementwise_sub("elementwise_sub" + name, data_x, data_y, axis, in_dtype) - elementwise_div("elementwise_div" + name, data_x, data_y, axis, in_dtype) - elementwise_mod("elementwise_mod" + name, data_x, data_y, axis, in_dtype) - elementwise_mul("elementwise_mul" + name, data_x, data_y, axis, in_dtype) - elementwise_min("elementwise_min" + name, data_x, data_y, axis, in_dtype) - elementwise_max("elementwise_max" + name, data_x, data_y, axis, in_dtype) - elementwise_pow("elementwise_pow" + name, data_x, data_y, axis, in_dtype) +def elementwise_ops(name: str, data_x, data_y, in_dtype, axis=-1): + elementwise_add("elementwise_add" + name, data_x, data_y, in_dtype, axis) + elementwise_sub("elementwise_sub" + name, data_x, data_y, in_dtype, axis) + elementwise_div("elementwise_div" + name, data_x, data_y, in_dtype, axis) + elementwise_mod("elementwise_mod" + name, data_x, data_y, in_dtype, axis) + elementwise_mul("elementwise_mul" + name, data_x, data_y, in_dtype, axis) + elementwise_min("elementwise_min" + name, data_x, data_y, in_dtype, axis) + elementwise_max("elementwise_max" + name, data_x, data_y, in_dtype, axis) + elementwise_pow("elementwise_pow" + name, data_x, data_y, in_dtype, axis) def main(): @@ -253,52 +296,56 @@ def main(): in_dtype = 'float32' data_x = np.array([2, 3, 4]).astype(in_dtype) data_y = np.array([1, 5, 2]).astype(in_dtype) - axis = -1 - elementwise_ops("1", data_x, data_y, axis, in_dtype) - elementwise_mod('floor_mod1', data_x, data_y, -1, in_dtype, True) + elementwise_ops("1", data_x, data_y, in_dtype) + elementwise_mod('floor_mod1', data_x, data_y, in_dtype, True) # data_y's shape is the continuous subsequence of data_x's shape data_x = np.random.rand(2, 5, 3, 4).astype(np.float32) data_y = (0.1 + np.random.rand(3, 4).astype(np.float32)) / 1.1 - elementwise_ops("2", data_x, data_y, axis, in_dtype) - elementwise_mod('floor_mod2', data_x, data_y, -1, in_dtype, True) + elementwise_ops("2", data_x, data_y, in_dtype) + elementwise_mod('floor_mod2', data_x, data_y, in_dtype, True) + + data_y = (0.1 + np.random.rand(4).astype(np.float32)) / 1.1 - data_y = (0.1 + np.random.rand(5).astype(np.float32)) / 1.1 - axis = 1 - elementwise_ops("3", data_x, data_y, axis, in_dtype) + if paddle.__version__ >= '2.0.0': + elementwise_ops("3", data_x, data_y, in_dtype) + else: + elementwise_ops("3", data_x, data_y, in_dtype, 1) - data_y = (0.1 + np.random.rand(2, 5, 3).astype(np.float32)) / 1.1 - axis = 0 - elementwise_ops("4", data_x, data_y, axis, in_dtype) + data_y = (0.1 + np.random.rand(5, 3, 4).astype(np.float32)) / 1.1 + if paddle.__version__ >= '2.0.0': + elementwise_ops("4", data_x, data_y, in_dtype) + else: + elementwise_ops("4", data_x, data_y, in_dtype, 0) # test for elementwise_floordiv, support int and int64 # paddle1.8 support axis = [0, x_last_dims] # paddle2.x only support axis = -1 floordiv_support_dtype = ['int64', 'int32'] data_x = np.array([-4, 0, -8]) - + data_y = np.array([3, 5, 3]) - axis = -1 for dtype in floordiv_support_dtype: - elementwise_floordiv("elementwise_floordiv_" + dtype + "_1", - data_x.astype(dtype), data_y.astype(dtype), axis, dtype) + elementwise_floordiv("elementwise_floordiv_" + dtype + "_1", + data_x.astype(dtype), data_y.astype(dtype), dtype) data_x = np.random.randint(-10, 10, [2, 5, 3, 4]) data_y = np.random.randint(1, 5, [3, 4]) for dtype in floordiv_support_dtype: - elementwise_floordiv("elementwise_floordiv_" + dtype + "_2", - data_x.astype(dtype), data_y.astype(dtype), axis, dtype) + elementwise_floordiv("elementwise_floordiv_" + dtype + "_2", + data_x.astype(dtype), data_y.astype(dtype), dtype) data_y = np.random.randint(1, 5, [5, 3, 4]) for dtype in floordiv_support_dtype: - elementwise_floordiv("elementwise_floordiv_" + dtype + "_3", - data_x.astype(dtype), data_y.astype(dtype), axis, dtype) + elementwise_floordiv("elementwise_floordiv_" + dtype + "_3", + data_x.astype(dtype), data_y.astype(dtype), dtype) # test for elementwise_mul with bool data type sample_arr = [True, False] - data_x = np.random.choice(sample_arr, size=(2,3,4)) - data_y = np.random.choice(sample_arr, size=(1,3,4)) + data_x = np.random.choice(sample_arr, size=(2, 3, 4)) + data_y = np.random.choice(sample_arr, size=(1, 3, 4)) elementwise_mul_bool("elementwise_mul_bool1", data_x, data_y) + if __name__ == "__main__": main() diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_embedding.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_embedding.py index 1808a613f5d142..576c08b2b87a1d 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_embedding.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_embedding.py @@ -6,9 +6,10 @@ # for lookup_table_v2 # https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/nn/Embedding_cn.html#embedding # equal to "gather" -# +# import numpy as np import sys +import paddle from save_model import saveModel @@ -21,21 +22,22 @@ def ov_embedding(ids, vocab_embeddings, vocab_size, embedding_dim, padding_idx, from openvino import Core if vocab_embeddings is None: - # - vocab_embeddings = np.zeros((vocab_size, embedding_dim)).astype("float32") + # + vocab_embeddings = np.zeros( + (vocab_size, embedding_dim)).astype("float32") node_ids = opset8.parameter(shape=ids.shape, name='ids', dtype=ids.dtype) node_w = opset8.parameter(shape=vocab_embeddings.shape, name='w', dtype=vocab_embeddings.dtype) if padding_idx == -1: padding_idx += vocab_size - + if padding_idx is not None: ''' mask W ''' masked_embeddings = np.ones(vocab_embeddings.shape, dtype='int64') - masked_embeddings[padding_idx,:] = 0 # mask + masked_embeddings[padding_idx, :] = 0 # mask node_mask = opset8.constant(masked_embeddings, name='mask', dtype=vocab_embeddings.dtype) node_masked_w = opset8.multiply(node_w, node_mask) @@ -56,21 +58,24 @@ def ov_embedding(ids, vocab_embeddings, vocab_size, embedding_dim, padding_idx, return output -def embedding(name : str, ids, vocab_size, embedding_dim, padding_idx=None, sparse=False, vocab_embeddings=None, compare=False): + +def embedding(name: str, ids, vocab_size, embedding_dim, padding_idx=None, sparse=False, vocab_embeddings=None, compare=False): """ padding_idx (int|long|None) """ - import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_ids = paddle.static.data(name = 'Ids', shape = ids.shape, dtype = ids.dtype) + node_ids = paddle.static.data( + name='Ids', shape=ids.shape, dtype=ids.dtype) pretrained_attr = paddle.ParamAttr(name='W', - initializer=paddle.nn.initializer.Assign(vocab_embeddings), - trainable=False) if vocab_embeddings is not None else None + initializer=paddle.nn.initializer.Assign( + vocab_embeddings), + trainable=False) if vocab_embeddings is not None else None - node_embedding = paddle.nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim, padding_idx=padding_idx, sparse=sparse, weight_attr=pretrained_attr, name=name) + node_embedding = paddle.nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim, + padding_idx=padding_idx, sparse=sparse, weight_attr=pretrained_attr, name=name) node_out = node_embedding(node_ids) cpu = paddle.static.cpu_places(1) @@ -78,15 +83,16 @@ def embedding(name : str, ids, vocab_size, embedding_dim, padding_idx=None, spar # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) - + input_dict = {'Ids': ids} output_vars_list = [node_out] infer_results = exe.run( - feed=input_dict, - fetch_list=output_vars_list ) + feed=input_dict, + fetch_list=output_vars_list) - saveModel(name, exe, feedkeys=[node_ids], fetchlist=output_vars_list, inputs=list(input_dict.values()), outputs=infer_results, target_dir=sys.argv[1], use_static_api=True) + saveModel(name, exe, feedkeys=[node_ids], fetchlist=output_vars_list, inputs=list( + input_dict.values()), outputs=infer_results, target_dir=sys.argv[1], use_static_api=True) # outputs = dict() @@ -98,30 +104,29 @@ def embedding(name : str, ids, vocab_size, embedding_dim, padding_idx=None, spar ng_result = ov_embedding(ids, vocab_embeddings, vocab_size, embedding_dim, padding_idx, sparse) ng_result = list(ng_result.values())[0] paddle_result = list(outputs.values())[0] - + match = np.all(np.isclose( paddle_result, ng_result, rtol=1e-4, atol=1e-5)) prefix_color = '\n\033[92m' if match else '\n\033[91m' - print(prefix_color + - 'TestCase {} Result {} '.format(name, match) + '\033[0m\n') + print(prefix_color + + 'TestCase {} Result {} '.format(name, match) + '\033[0m\n') if not match: np.set_printoptions(precision=2) np.set_printoptions(suppress=True) - print(prefix_color + - 'paddle_result: {}'.format(paddle_result) + '\033[0m\n') - print(prefix_color + - 'ng_result: {}'.format(ng_result) + '\033[0m\n') + print(prefix_color + + 'paddle_result: {}'.format(paddle_result) + '\033[0m\n') + print(prefix_color + + 'ng_result: {}'.format(ng_result) + '\033[0m\n') raise ValueError(name + ': OV result does not match paddle!') return outputs - + if __name__ == "__main__": - import paddle.compat as cpt vocab_size = 17 embedding_dim = 31 @@ -129,42 +134,55 @@ def embedding(name : str, ids, vocab_size, embedding_dim, padding_idx=None, spar # ids = np.random.randint(0, vocab_size, 4).astype("int32") - embedding("embedding_0", ids, vocab_size, embedding_dim, vocab_embeddings=table, compare=False) + embedding("embedding_0", ids, vocab_size, embedding_dim, + vocab_embeddings=table, compare=False) # ids = np.random.randint(0, vocab_size, 4).astype("int32") - embedding("embedding_sparse", ids, vocab_size, embedding_dim, sparse=True, vocab_embeddings=table, compare=False) + embedding("embedding_sparse", ids, vocab_size, embedding_dim, + sparse=True, vocab_embeddings=table, compare=False) # # compare fail ids = np.random.randint(0, vocab_size, 4).astype("int32") - embedding("embedding_none_weight", ids, vocab_size, embedding_dim, compare=False) + embedding("embedding_none_weight", ids, + vocab_size, embedding_dim, compare=False) # ids = np.random.randint(0, vocab_size, 4).astype("int32") ids = np.squeeze(ids) padding_idx = np.random.choice(ids, 1)[0] # print('padding_idx {}, ids {}'.format(padding_idx, ids)) - outputs = embedding("embedding_paddings", ids, vocab_size, embedding_dim, padding_idx=int(padding_idx), vocab_embeddings=table, compare=False) + outputs = embedding("embedding_paddings", ids, vocab_size, embedding_dim, padding_idx=int( + padding_idx), vocab_embeddings=table, compare=False) # print('outputs {}'.format(outputs)) # corner case ids = np.random.randint(0, vocab_size, 4).astype("int32") - pick = np.random.choice(4, 1)[0] # pick randomly to be max vacab_size -1 - ids[pick] = vocab_size-1 + pick = np.random.choice(4, 1)[0] # pick randomly to be max vacab_size -1 + ids[pick] = vocab_size - 1 padding_idx = -1 # print('padding_idx {}, ids {}'.format(padding_idx, ids)) - outputs = embedding("embedding_paddings_neg1", ids, vocab_size, embedding_dim, padding_idx=int(padding_idx), vocab_embeddings=table, compare=False) - # print('outputs {}'.format(outputs)) + outputs = embedding("embedding_paddings_neg1", ids, vocab_size, embedding_dim, + padding_idx=int(padding_idx), vocab_embeddings=table, compare=False) + # print('outputs {}'.format(outputs)) # - ids = np.random.randint(low=0, high=vocab_size, size=(2, 4, 5)).astype("int32") - embedding("embedding_tensorIds", ids, vocab_size, embedding_dim, vocab_embeddings=table, compare=False) - + ids = np.random.randint(low=0, high=vocab_size, + size=(2, 4, 5)).astype("int32") + embedding("embedding_tensorIds", ids, vocab_size, + embedding_dim, vocab_embeddings=table, compare=False) + # - ids = np.random.randint(low=0, high=vocab_size, size=(2, 4, 5)).astype("int32") + ids = np.random.randint(low=0, high=vocab_size, + size=(2, 4, 5)).astype("int32") flatten_idx = ids.flatten() padding_idx = np.random.choice(flatten_idx, 1)[0] # print('padding_idx {}'.format(padding_idx)) - outputs = embedding("embedding_tensorIds_paddings", ids, vocab_size, embedding_dim, padding_idx=cpt.long_type(padding_idx), vocab_embeddings=table, compare=False) - # print('outputs {}'.format(outputs)) - + + if paddle.__version__ >= '2.0.0': + outputs = embedding("embedding_tensorIds_paddings", ids, vocab_size, embedding_dim, + padding_idx=np.compat.long(padding_idx), vocab_embeddings=table, compare=False) + else: + import paddle.compat as cpt + outputs = embedding("embedding_tensorIds_paddings", ids, vocab_size, embedding_dim, + padding_idx=cpt.long_type(padding_idx), vocab_embeddings=table, compare=False) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_exp.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_exp.py index 344351c9bc790f..e1bc08053b3be8 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_exp.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_exp.py @@ -4,6 +4,8 @@ # # exp paddle model generator # + +import paddle import numpy as np from save_model import saveModel import sys @@ -15,7 +17,10 @@ def exp(name: str, x): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) - out = paddle.fluid.layers.exp(x=node_x) + if paddle.__version__ >= '2.0.0': + out = paddle.exp(x=node_x) + else: + out = paddle.fluid.layers.exp(x=node_x) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_constant.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_constant.py deleted file mode 100644 index f1b2f250dd0345..00000000000000 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_constant.py +++ /dev/null @@ -1,100 +0,0 @@ -# Copyright (C) 2018-2023 Intel Corporation -# SPDX-License-Identifier: Apache-2.0 - -# -# fill_const paddle model generator -# -import numpy as np -from save_model import saveModel -import paddle -import sys - - -def fill_constant(name : str, shape : list, dtype, value): - paddle.enable_static() - with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - x1 = paddle.fluid.layers.fill_constant(shape=shape, value=value, dtype=dtype, name='fill_constant') - x2 = paddle.fluid.layers.fill_constant(shape=shape, value=value, dtype=dtype, name='fill_constant') - out = paddle.add(paddle.cast(x1, np.float32), paddle.cast(x2, np.float32)) - cpu = paddle.static.cpu_places(1) - exe = paddle.static.Executor(cpu[0]) - # startup program will call initializer to initialize the parameters. - exe.run(paddle.static.default_startup_program()) - - outs = exe.run( - fetch_list=[out]) - - saveModel(name, exe, feedkeys=[], fetchlist=[out], inputs=[], outputs=[outs[0]], target_dir=sys.argv[1]) - - return outs[0] - - -def fill_constant_tensor(name : str, shape : list, dtype, value): - paddle.enable_static() - with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_value = paddle.static.data(name='value', shape=[1], dtype=dtype) - x1 = paddle.fluid.layers.fill_constant(shape=shape, value=node_value, dtype=dtype, name='fill_constant1') - out = paddle.cast(x1, np.float32) - cpu = paddle.static.cpu_places(1) - exe = paddle.static.Executor(cpu[0]) - # startup program will call initializer to initialize the parameters. - exe.run(paddle.static.default_startup_program()) - - outs = exe.run( - feed={"value": value}, - fetch_list=[out]) - - saveModel(name, exe, feedkeys=["value"], fetchlist=[out], inputs=[np.array([value]).astype(dtype)], outputs=[outs[0]], target_dir=sys.argv[1]) - - return outs[0] - - -def fill_constant_shape_tensor(name : str, shape, dtype, value): - paddle.enable_static() - with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_shape = paddle.fluid.layers.fill_constant(shape=[2], value=shape, dtype='int32', name='shape') - x1 = paddle.fluid.layers.fill_constant(shape=node_shape, value=value, dtype=dtype, name='fill_constant') - out = paddle.cast(x1, np.float32) - cpu = paddle.static.cpu_places(1) - exe = paddle.static.Executor(cpu[0]) - # startup program will call initializer to initialize the parameters. - exe.run(paddle.static.default_startup_program()) - - outs = exe.run( - fetch_list=[out]) - - saveModel(name, exe, feedkeys=[], fetchlist=[out], inputs=[], outputs=[outs[0]], target_dir=sys.argv[1]) - - return outs[0] - - -def fill_constant_shape_tensor_list(name : str, shape: list, dtype, value): - paddle.enable_static() - with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_shape = paddle.fluid.layers.fill_constant(shape=[1], value=shape, dtype='int32', name='shape') - x1 = paddle.fluid.layers.fill_constant(shape=[2, node_shape], value=value, dtype=dtype, name='fill_constant') - out = paddle.cast(x1, np.float32) - cpu = paddle.static.cpu_places(1) - exe = paddle.static.Executor(cpu[0]) - # startup program will call initializer to initialize the parameters. - exe.run(paddle.static.default_startup_program()) - - outs = exe.run( - fetch_list=[out]) - - saveModel(name, exe, feedkeys=[], fetchlist=[out], inputs=[], outputs=[outs[0]], target_dir=sys.argv[1]) - - return outs[0] - - -def main(): - fill_constant("fill_constant", [2, 3, 4], 'float32', 0.03) - fill_constant("fill_constant_int32", [2, 3, 4], "int32", 2) - fill_constant("fill_constant_int64", [2, 3, 4], "int64", 4) - fill_constant_tensor("fill_constant_tensor", [2, 3, 4], 'float32', 0.05) - fill_constant_shape_tensor("fill_constant_shape_tensor", 2, 'float32', 0.05) - fill_constant_shape_tensor_list("fill_constant_shape_tensor_list", 2, 'float32', 0.05) - - -if __name__ == "__main__": - main() diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_constant_batch_size_like.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_constant_batch_size_like.py deleted file mode 100644 index 7701eba8121395..00000000000000 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_constant_batch_size_like.py +++ /dev/null @@ -1,42 +0,0 @@ -# Copyright (C) 2018-2023 Intel Corporation -# SPDX-License-Identifier: Apache-2.0 - -# -# fill_constant_batch_size_like paddle model generator -# -import numpy as np -from save_model import saveModel -import paddle -import sys - -data_type = 'float32' - -def fill_constant_batch_size_like(name : str, x, shape, dtype, value, input_dim_idx=0, output_dim_idx=0): - paddle.enable_static() - - with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - like = paddle.static.data(name='x', shape=x.shape, dtype = data_type) - out = paddle.fluid.layers.fill_constant_batch_size_like(input=like, shape=shape, \ - value=value, dtype=dtype, \ - output_dim_idx=output_dim_idx, input_dim_idx=input_dim_idx) - - cpu = paddle.static.cpu_places(1) - exe = paddle.static.Executor(cpu[0]) - # startup program will call initializer to initialize the parameters. - exe.run(paddle.static.default_startup_program()) - - outs = exe.run( - feed={'x': x}, - fetch_list=[out]) - - saveModel(name, exe, feedkeys=['x'], fetchlist=[out], inputs=[x], outputs=[outs[0]], target_dir=sys.argv[1]) - - return outs[0] - -def main(): - x = np.random.rand(4, 3, 2).astype(data_type) - fill_constant_batch_size_like("fill_constant_batch_size_like", \ - x, [1, -1, 3], data_type, 0.03, 2, 1) - -if __name__ == "__main__": - main() diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_full.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_full.py new file mode 100644 index 00000000000000..2bbcbaf7836e12 --- /dev/null +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_full.py @@ -0,0 +1,118 @@ +# Copyright (C) 2018-2023 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +# +# fill_const paddle model generator +# +import numpy as np +from save_model import saveModel +import paddle +import sys + + +def full(name : str, shape : list, dtype, value): + paddle.enable_static() + with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): + if paddle.__version__ >= '2.0.0': + x1 = paddle.full(shape=shape, fill_value=value, dtype=dtype, name='fill') + x2 = paddle.full(shape=shape, fill_value=value, dtype=dtype, name='fill') + else: + x1 = paddle.fluid.layers.fill_constant(shape=shape, value=value, dtype=dtype, name='fill_constant') + x2 = paddle.fluid.layers.fill_constant(shape=shape, value=value, dtype=dtype, name='fill_constant') + out = paddle.add(paddle.cast(x1, np.float32), paddle.cast(x2, np.float32)) + cpu = paddle.static.cpu_places(1) + exe = paddle.static.Executor(cpu[0]) + # startup program will call initializer to initialize the parameters. + exe.run(paddle.static.default_startup_program()) + + outs = exe.run( + fetch_list=[out]) + + saveModel(name, exe, feedkeys=[], fetchlist=[out], inputs=[], outputs=[outs[0]], target_dir=sys.argv[1]) + + return outs[0] + + +def full_tensor(name : str, shape : list, dtype, value): + paddle.enable_static() + with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): + if paddle.__version__ >= '2.5.1': + node_value = paddle.static.data(name='value', shape=[], dtype=dtype) + x1 = paddle.full(shape=shape, fill_value=node_value, dtype=dtype, name='full1') + elif paddle.__version__ >= '2.0.0': + node_value = paddle.static.data(name='value', shape=[1], dtype=dtype) + x1 = paddle.full(shape=shape, fill_value=node_value, dtype=dtype, name='full1') + else: + node_value = paddle.static.data(name='value', shape=[1], dtype=dtype) + x1 = paddle.fluid.layers.fill_constant(shape=shape, value=node_value, dtype=dtype, name='fill_constant1') + out = paddle.cast(x1, np.float32) + cpu = paddle.static.cpu_places(1) + exe = paddle.static.Executor(cpu[0]) + # startup program will call initializer to initialize the parameters. + exe.run(paddle.static.default_startup_program()) + + outs = exe.run( + feed={"value": value}, + fetch_list=[out]) + + if paddle.__version__ >= '2.5.1': + saveModel(name, exe, feedkeys=["value"], fetchlist=[out], inputs=[np.array(value).astype(dtype)], outputs=[outs[0]], target_dir=sys.argv[1]) + else: + saveModel(name, exe, feedkeys=["value"], fetchlist=[out], inputs=[np.array([value]).astype(dtype)], outputs=[outs[0]], target_dir=sys.argv[1]) + + return outs[0] + + +def full_shape_tensor(name : str, shape, dtype, value): + paddle.enable_static() + with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): + if paddle.__version__ >= '2.0.0': + node_shape = paddle.full(shape=[2], fill_value=shape, dtype='int32', name='shape') + x1 = paddle.full(shape=node_shape, fill_value=value, dtype=dtype, name='full') + else: + node_shape = paddle.fluid.layers.fill_constant(shape=[1], value=shape, dtype='int32', name='shape') + x1 = paddle.fluid.layers.fill_constant(shape=[2, node_shape], value=value, dtype=dtype, name='fill_constant') + out = paddle.cast(x1, np.float32) + cpu = paddle.static.cpu_places(1) + exe = paddle.static.Executor(cpu[0]) + # startup program will call initializer to initialize the parameters. + exe.run(paddle.static.default_startup_program()) + + outs = exe.run( + fetch_list=[out]) + + saveModel(name, exe, feedkeys=[], fetchlist=[out], inputs=[], outputs=[outs[0]], target_dir=sys.argv[1]) + + return outs[0] + + +def full_shape_tensor_list(name : str, shape: list, dtype, value): + paddle.enable_static() + with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): + node_shape = paddle.full(shape=[1], fill_value=shape, dtype='int32', name='shape') + x1 = paddle.full(shape=[2, node_shape], fill_value=value, dtype=dtype, name='full') + out = paddle.cast(x1, np.float32) + cpu = paddle.static.cpu_places(1) + exe = paddle.static.Executor(cpu[0]) + # startup program will call initializer to initialize the parameters. + exe.run(paddle.static.default_startup_program()) + + outs = exe.run( + fetch_list=[out]) + + saveModel(name, exe, feedkeys=[], fetchlist=[out], inputs=[], outputs=[outs[0]], target_dir=sys.argv[1]) + + return outs[0] + + +def main(): + full("full", [2, 3, 4], 'float32', 0.03) + full("full_int32", [2, 3, 4], "int32", 2) + full("full_int64", [2, 3, 4], "int64", 4) + full_tensor("full_tensor", [2, 3, 4], 'float32', 0.05) + full_shape_tensor("full_shape_tensor", 2, 'float32', 0.05) + full_shape_tensor_list("full_shape_tensor_list", 2, 'float32', 0.05) + + +if __name__ == "__main__": + main() diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_any_like.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_full_like.py similarity index 63% rename from src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_any_like.py rename to src/frontends/paddle/tests/test_models/gen_scripts/generate_full_like.py index ab32b20a8e6898..71a2d634ba624a 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_fill_any_like.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_full_like.py @@ -2,7 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 # -# fill_any_like paddle model generator +# full_like paddle model generator # import numpy as np from save_model import saveModel @@ -11,7 +11,7 @@ data_type = 'float32' -def fill_any_like(name:str, x, value, dtype=None): +def full_like(name:str, x, value, dtype=None): paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): @@ -35,18 +35,18 @@ def fill_any_like(name:str, x, value, dtype=None): def main(): x = np.random.rand(8, 24, 32).astype(data_type) - fill_any_like("fill_any_like", x, 1.2) - fill_any_like("fill_any_like_f16", x, 1.0, dtype='float16') - fill_any_like("fill_any_like_f32", x, 1.2, dtype='float32') - fill_any_like("fill_any_like_f64", x, 1.2, dtype='float64') - fill_any_like("fill_any_like_i16", x, 3, dtype='int16') - fill_any_like("fill_any_like_i32", x, 2, dtype='int32') - fill_any_like("fill_any_like_i64", x, 10, dtype='int64') - fill_any_like("fill_any_like_bool", x, True, dtype='bool') + full_like("full_like", x, 1.2) + full_like("full_like_f16", x, 1.0, dtype='float16') + full_like("full_like_f32", x, 1.2, dtype='float32') + full_like("full_like_f64", x, 1.2, dtype='float64') + full_like("full_like_i16", x, 3, dtype='int16') + full_like("full_like_i32", x, 2, dtype='int32') + full_like("full_like_i64", x, 10, dtype='int64') + full_like("full_like_bool", x, True, dtype='bool') sample_arr = [True, False] x = np.random.choice(sample_arr, size=(13,17,11)) - fill_any_like("fill_any_like_bool_2", x, False, dtype=None) + full_like("full_like_bool_2", x, False, dtype=None) if __name__ == "__main__": main() diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_gelu.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_gelu.py index b67959ef0ed439..a17fadc9c10bcb 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_gelu.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_gelu.py @@ -16,7 +16,10 @@ def gelu(name:str, x, approximate=False): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): data = paddle.static.data(name='x', shape=x.shape, dtype = data_type) - out = paddle.fluid.layers.gelu(data, approximate=approximate) + if paddle.__version__ >= '2.0.0': + out = paddle.nn.functional.gelu(data, approximate=approximate) + else: + out = paddle.fluid.layers.gelu(data, approximate=approximate) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_equal.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_equal.py index c3a82914fc0427..f540c0ea8302ec 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_equal.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_equal.py @@ -16,7 +16,10 @@ def greater_equal(name : str, x, y, data_type, cast_to_fp32=False): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='input_x', shape=x.shape, dtype=data_type) node_y = paddle.static.data(name='input_y', shape=y.shape, dtype=data_type) - out = paddle.fluid.layers.greater_equal(x=node_x, y=node_y, name='greater_equal') + if paddle.__version__ >= '2.0.0': + out = paddle.greater_equal(x=node_x, y=node_y, name='greater_equal') + else: + out = paddle.fluid.layers.greater_equal(x=node_x, y=node_y, name='greater_equal') # FuzzyTest framework doesn't support boolean so cast to fp32/int32 if cast_to_fp32: diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_than.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_than.py index 045f80c341b411..7ca2b6ad95f9a5 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_than.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_greater_than.py @@ -15,8 +15,12 @@ def greater_than(name: str, x, y, data_type, cast_to_fp32=False): name='input_x', shape=x.shape, dtype=data_type) node_y = pdpd.static.data( name='input_y', shape=y.shape, dtype=data_type) - out = pdpd.fluid.layers.greater_than( - x=node_x, y=node_y, name='greater_than') + if pdpd.__version__ >= '2.0.0': + out = pdpd.greater_than( + x=node_x, y=node_y, name='greater_than') + else: + out = pdpd.fluid.layers.greater_than( + x=node_x, y=node_y, name='greater_than') # FuzzyTest framework doesn't support boolean so cast to fp32/int32 if cast_to_fp32: diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_grid_sampler.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_grid_sampler.py index 4dec54ad32c223..d3c404fb88108b 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_grid_sampler.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_grid_sampler.py @@ -51,6 +51,8 @@ def main(): x = np.random.randn(2, 3, 128, 128).astype(dtype) grid = np.random.uniform(-1, 1, [2, 130, 130, 2]).astype(dtype) padding_mode = "border" + grid_sampler(name='grid_sampler_3', x=x, grid=grid, mode=mode, padding_mode=padding_mode, + align_corners=align_corners) grid_sampler(name='grid_sampler_dyn', x=x, grid=grid, mode=mode, padding_mode=padding_mode, align_corners=align_corners, is_dynamic=True) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_sigmoid.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_sigmoid.py index 68c9179421c788..9ccdb623094107 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_sigmoid.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_sigmoid.py @@ -15,7 +15,7 @@ def hard_sigmoid(name: str, x, slope: float = 0.2, offset: float = 0.5, data_typ with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype = data_type) - out = paddle.fluid.layers.hard_sigmoid(node_x, slope=slope, offset=offset, name='hard_sigmoid') + out = paddle.nn.functional.hardsigmoid(node_x, slope=slope, offset=offset, name='hard_sigmoid') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_swish.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_swish.py index 2fdf4a3ee29f66..c86eab1877abe3 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_swish.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_hard_swish.py @@ -15,7 +15,10 @@ def hard_swish(name: str, x, threshold=6.0, scale=6.0, offset=3.0, data_type='fl with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.hard_swish(node_x, threshold=threshold, scale=scale, offset=offset, name='hard_swish') + if paddle.__version__ >= '2.0.0': + out = paddle.nn.functional.hardswish(node_x, name='hard_swish') + else: + out = paddle.fluid.layers.hard_swish(node_x, threshold=threshold, scale=scale, offset=offset, name='hard_swish') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_index_select.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_index_select.py index f1f2bdcd39e1f8..476471daed2070 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_index_select.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_index_select.py @@ -5,7 +5,6 @@ # index_select paddle model generator # import numpy as np -from paddle.fluid import param_attr from save_model import saveModel import paddle import sys diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_layer_norm.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_layer_norm.py index 593f019f2fba87..25d90cae8f981b 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_layer_norm.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_layer_norm.py @@ -36,8 +36,12 @@ def layer_norm(name:str, x, begin_norm_axis, scale=True, shift=True, param_attr= def main(): x = np.random.rand(8, 24, 32).astype(data_type) random_data = np.random.rand(24 * 32).astype(data_type) - attr = paddle.ParamAttr( - initializer=paddle.fluid.initializer.NumpyArrayInitializer(random_data)) + if paddle.__version__ >= '2.0.0': + attr = paddle.ParamAttr( + initializer=paddle.nn.initializer.Assign(random_data)) + else: + attr = paddle.ParamAttr( + initializer=paddle.fluid.initializer.NumpyArrayInitializer(random_data)) layer_norm("layer_norm", x, begin_norm_axis=1, param_attr=attr, bias_attr=attr) layer_norm("layer_norm_noscale", x, scale=False, begin_norm_axis=2) layer_norm("layer_norm_noshift", x, shift=False, begin_norm_axis=1) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_leaky_relu.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_leaky_relu.py index 580a0a0a7acbb0..71740e7961382e 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_leaky_relu.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_leaky_relu.py @@ -10,12 +10,15 @@ import sys -def leaky_relu(name: str, x, alpha: float = 0.02, data_type='float32'): +def leaky_relu(name: str, x, alpha: float = 0.01, data_type='float32'): paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype = data_type) - out = paddle.fluid.layers.leaky_relu(node_x, alpha=alpha, name='leaky_relu') + if paddle.__version__ >= '2.0.0': + out = paddle.nn.functional.leaky_relu(node_x, negative_slope=alpha, name='leaky_relu') + else: + out = paddle.fluid.layers.leaky_relu(node_x, alpha=alpha, name='leaky_relu') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_less_than.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_less_than.py index 187f920df297c8..91749fffdd3f84 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_less_than.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_less_than.py @@ -3,29 +3,32 @@ # import numpy as np from save_model import saveModel -import paddle as pdpd +import paddle import sys def less_than(name: str, x, y, data_type, cast_to_fp32=False): - pdpd.enable_static() + paddle.enable_static() - with pdpd.static.program_guard(pdpd.static.Program(), pdpd.static.Program()): - node_x = pdpd.static.data( + with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): + node_x = paddle.static.data( name='input_x', shape=x.shape, dtype=data_type) - node_y = pdpd.static.data( + node_y = paddle.static.data( name='input_y', shape=y.shape, dtype=data_type) - out = pdpd.fluid.layers.less_than(x=node_x, y=node_y, name='less_than') + if paddle.__version__ >= '2.0.0': + out = paddle.less_than(x=node_x, y=node_y, name='less_than') + else: + out = paddle.fluid.layers.less_than(x=node_x, y=node_y, name='less_than') # FuzzyTest framework doesn't support boolean so cast to fp32/int32 if cast_to_fp32: data_type = "float32" - out = pdpd.cast(out, data_type) - cpu = pdpd.static.cpu_places(1) - exe = pdpd.static.Executor(cpu[0]) + out = paddle.cast(out, data_type) + cpu = paddle.static.cpu_places(1) + exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. - exe.run(pdpd.static.default_startup_program()) + exe.run(paddle.static.default_startup_program()) outs = exe.run( feed={'input_x': x, 'input_y': y}, diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_log.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_log.py index 7cd9196172d551..1fd2cbde20a3f5 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_log.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_log.py @@ -15,7 +15,10 @@ def log(name: str, x, data_type='float32'): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.log(node_x, name='log') + if paddle.__version__ >= '2.0.0': + out = paddle.log(node_x, name='log') + else: + out = paddle.fluid.layers.log(node_x, name='log') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_loop.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_loop.py index 2cb59b42e45320..72185ba530cb3d 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_loop.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_loop.py @@ -23,7 +23,10 @@ def body(i, dummy): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) node_i = paddle.full(shape=[1], fill_value=0, dtype='int64', name='i') - node_i = paddle.fluid.layers.nn.elementwise_add(node_i, node_x) + if paddle.__version__ >= '2.0.0': + node_i = paddle.add(node_i, node_x) + else: + node_i = paddle.fluid.layers.nn.elementwise_add(node_i, node_x) node_ten = paddle.full(shape=[1], fill_value=10, dtype='int64', name='ten') out, dummy = paddle.static.nn.while_loop(cond, body, [node_i, node_ten], name='while_loop') @@ -49,7 +52,10 @@ def body(i, t): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) node_i = paddle.full(shape=[1], fill_value=0, dtype='int64', name='i') - node_i = paddle.fluid.layers.nn.elementwise_add(node_i, node_x) + if paddle.__version__ >= '2.0.0': + node_i = paddle.add(node_i, node_x) + else: + node_i = paddle.fluid.layers.nn.elementwise_add(node_i, node_x) node_ten = paddle.full(shape=[1], fill_value=10, dtype='int64', name='ten') out, dummy = paddle.static.nn.while_loop(cond, body, [node_i, node_ten], name='while_loop') @@ -76,7 +82,10 @@ def body(i, t): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) node_i = paddle.full(shape=[1], fill_value=0, dtype='int64', name='i') - node_i = paddle.fluid.layers.nn.elementwise_add(node_i, node_x) + if paddle.__version__ >= '2.0.0': + node_i = paddle.add(node_i, node_x) + else: + paddle.fluid.layers.nn.elementwise_add(node_i, node_x) node_ten = paddle.full(shape=[1], fill_value=10, dtype='int64', name='ten') out_i,out_t = paddle.static.nn.while_loop(cond, body, [node_i, node_ten], name='while_loop') diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_mul.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_mul.py index dbc8c818d2f8c4..f198178ae4a2c8 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_mul.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_mul.py @@ -12,7 +12,10 @@ def paddle_matmul(name, x1, x2, x_transpose=False, y_transpose=False): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x1 = paddle.static.data(name='x1', shape=x1.shape, dtype=x1.dtype) node_x2 = paddle.static.data(name='x2', shape=x2.shape, dtype=x2.dtype) - mul_node = paddle.fluid.layers.matmul(node_x1, node_x2, x_transpose, y_transpose) + if paddle.__version__ >= '2.0.0': + mul_node = paddle.matmul(node_x1, node_x2, x_transpose, y_transpose) + else: + mul_node = paddle.fluid.layers.matmul(node_x1, node_x2, x_transpose, y_transpose) result = paddle.static.nn.batch_norm(mul_node, use_global_stats=True) cpu = paddle.static.cpu_places(1) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_multi_tensor_split.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_multi_tensor_split.py index 8ec25d91c40f17..b98c4a4325810e 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_multi_tensor_split.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_multi_tensor_split.py @@ -15,12 +15,19 @@ def create_multi_output_model(): num_splits = 20 inp_blob_1 = np.random.randn(2, num_splits, 4, 4).astype(np.float32) - x = fluid.data(name='x', shape=[2, num_splits, 4, 4], dtype='float32') - test_layer = fluid.layers.split(x, num_or_sections=num_splits, dim=1) - + if paddle.__version__ >= '2.0.0': + x = paddle.static.data(name='x', shape=[2, num_splits, 4, 4], dtype='float32') + test_layer = paddle.split(x, num_or_sections=num_splits, axis=1) + else: + x = fluid.data(name='x', shape=[2, num_splits, 4, 4], dtype='float32') + test_layer = paddle.split(x, num_or_sections=num_splits, axis=1) + var = [] for i in range(num_splits//2): - add = fluid.layers.elementwise_add(test_layer[2*i], test_layer[2*i+1]) + if paddle.__version__ >= '2.0.0': + add = paddle.add(test_layer[2*i], test_layer[2*i+1]) + else: + add = fluid.layers.elementwise_add(test_layer[2*i], test_layer[2*i+1]) var.append(add) exe = fluid.Executor(fluid.CPUPlace()) @@ -28,7 +35,7 @@ def create_multi_output_model(): inp_dict = {'x': inp_blob_1} res_paddle = exe.run(fluid.default_main_program(), fetch_list=var, feed=inp_dict) - fluid.io.save_inference_model(os.path.join(sys.argv[1], "multi_tensor_split"), + paddle.fluid.io.save_inference_model(os.path.join(sys.argv[1], "multi_tensor_split"), list(inp_dict.keys()), var, exe, model_filename="multi_tensor_split.pdmodel", params_filename="multi_tensor_split.pdiparams") diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_place_test_model.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_place_test_model.py index da4a7f901d2aef..a7e92ca264a6e8 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_place_test_model.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_place_test_model.py @@ -1,10 +1,11 @@ # Copyright (C) 2018-2023 Intel Corporation # SPDX-License-Identifier: Apache-2.0 +import paddle import numpy as np from save_model import saveModel import sys - +import os def paddle_rnn_lstm(input_size, hidden_size, layers, direction): import paddle @@ -34,11 +35,40 @@ def paddle_rnn_lstm(input_size, hidden_size, layers, direction): feed={'x': np.ones([4, 3, input_size]).astype(np.float32)}, fetch_list=[y, h, c], program=main_program) - saveModel("place_test_model", exe, feedkeys=[data], - fetchlist=[y, h, c, relu_1, relu_2, relu_3], - inputs=[np.ones([4, 3, input_size]).astype(np.float32)], - outputs=[outs[0], outs[1], outs[2]], target_dir=sys.argv[1], - use_static_api=True) + + if paddle.__version__ >= '2.0.0': + feed_vars = [data] + fetch_vars = [y, h, c, relu_1, relu_2, relu_3] + saveModel("place_test_model", exe, feedkeys=feed_vars, + fetchlist=fetch_vars, + inputs=[np.ones([4, 3, input_size]).astype(np.float32)], + outputs=[outs[0], outs[1], outs[2]], target_dir=sys.argv[1], + use_static_api=True) + path_prefix = os.path.join(sys.argv[1], "place_test_model", "place_test_model") + program, feed_target_names, fetch_targets = paddle.static.io.load_inference_model(path_prefix, exe) + + from paddle.fluid import core + condition = lambda v : not v.persistable and v.name != "transpose_1.tmp_1" and v.name != "transpose_0.tmp_1" + vars_ = list(filter(condition, program.list_vars())) + vars_name = [v.name for v in vars_] + vars_name_file = os.path.join(sys.argv[1], "place_test_model", "vars_name.txt") + with open(vars_name_file, 'w') as f: + for name in vars_name: + f.writelines(f"{name}\n") + + fetch_targets_name = [ft.name for ft in fetch_targets] + outputs_name_file = os.path.join(sys.argv[1], "place_test_model", "outputs_name.txt") + with open(outputs_name_file, 'w') as f: + for name in fetch_targets_name: + f.writelines(f"{name}\n") + + else: + saveModel("place_test_model", exe, feedkeys=[data], + fetchlist=[y, h, c, relu_1, relu_2, relu_3], + inputs=[np.ones([4, 3, input_size]).astype(np.float32)], + outputs=[outs[0], outs[1], outs[2]], target_dir=sys.argv[1], + use_static_api=True) + return outs[0] diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_pool2d.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_pool2d.py index afec1e06243691..45aa60862d1c79 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_pool2d.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_pool2d.py @@ -8,70 +8,102 @@ import sys from save_model import saveModel -data_type = 'float32' +data_type = "float32" -def pool2d(name : str, x, attrs : dict): + +def pool2d(name: str, x, attrs: dict): import paddle + paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.pool2d(node_x, - pool_size=attrs['pool_size'], - pool_type=attrs['pool_type'], - pool_stride=attrs['pool_stride'], - pool_padding=attrs['pool_padding'], - global_pooling=attrs['global_pooling'], - ceil_mode=attrs['ceil_mode'], - exclusive=attrs['exclusive'], - data_format=attrs['data_format']) + node_x = paddle.static.data(name="x", shape=x.shape, dtype=data_type) + + if attrs["pool_type"] == "max": + out = paddle.nn.functional.max_pool2d( + node_x, + kernel_size=attrs["pool_size"], + stride=attrs["pool_stride"], + padding=attrs["pool_padding"], + ceil_mode=attrs["ceil_mode"], + data_format=attrs["data_format"] + ) + else: + out = paddle.nn.functional.avg_pool2d( + node_x, + kernel_size=attrs["pool_size"], + stride=attrs["pool_stride"], + padding=attrs["pool_padding"], + ceil_mode=attrs["ceil_mode"], + data_format=attrs["data_format"] + ) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) - outs = exe.run( - feed={'x': x}, - fetch_list=[out]) + outs = exe.run(feed={"x": x}, fetch_list=[out]) - saveModel(name, exe, feedkeys=['x'], fetchlist=[out], inputs=[x], outputs=[outs[0]], target_dir=sys.argv[1]) + saveModel( + name, + exe, + feedkeys=["x"], + fetchlist=[out], + inputs=[x], + outputs=[outs[0]], + target_dir=sys.argv[1], + ) return outs[0] -def adaptive_pool2d(name : str, x, attrs : dict): + +def adaptive_pool2d(name: str, x, attrs: dict): import paddle + paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.adaptive_pool2d( - input=node_x, - pool_size=attrs['pool_size'], - pool_type=attrs['pool_type'], - require_index=attrs['require_index']) + node_x = paddle.static.data(name="x", shape=x.shape, dtype=data_type) + if attrs["pool_type"] == "max": + out = paddle.nn.functional.adaptive_max_pool2d( + x=node_x, + output_size=attrs["pool_size"] + ) + else: + out = paddle.nn.functional.adaptive_avg_pool2d( + x=node_x, + output_size=attrs["pool_size"] + ) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) - outs = exe.run( - feed={'x': x}, - fetch_list=[out]) + outs = exe.run(feed={"x": x}, fetch_list=[out]) - saveModel(name, exe, feedkeys=['x'], fetchlist=[out], inputs=[x], outputs=[outs[0]], target_dir=sys.argv[1]) + saveModel( + name, + exe, + feedkeys=["x"], + fetchlist=[out], + inputs=[x], + outputs=[outs[0]], + target_dir=sys.argv[1], + ) return outs[0] + def main(): N, C, H, W = 2, 3, 4, 4 - data = np.arange(N*C*H*W).astype(data_type) + data = np.arange(N * C * H * W).astype(data_type) data_NCHW = data.reshape(N, C, H, W) data_NHWC = data.reshape(N, H, W, C) - #print(data_NCHW, data_NCHW.shape) + # print(data_NCHW, data_NCHW.shape) - pooling_types = ['max', 'avg'] + pooling_types = ["max", "avg"] # pool2d for i, pooling_type in enumerate(pooling_types): @@ -79,185 +111,193 @@ def main(): # ceil_mode = False paddle_attrs = { # input=data_NCHW, # shape: [2, 3, 8, 8] - 'pool_size' : [3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding' : [2,1], # it is same as pool_padding = [2,2,1,1] - 'global_pooling' : False, - 'ceil_mode' : False, - 'exclusive' : True, - 'data_format' : "NCHW" + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [2, 1], # it is same as pool_padding = [2,2,1,1] + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } # shape of out_1: [2, 3, 4, 3] - pool2d(pooling_type+'Pool_test1', data_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test1", data_NCHW, paddle_attrs) # Cecilia: there is a bug of PaddlePaddle in this case. # example 2: # ceil_mode = True (different from example 1) paddle_attrs = { - #input=data_NCHW, - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':[[0,0], [0,0], [2,2], [1,1]], # it is same as pool_padding = [2,2,1,1] - 'global_pooling':False, - 'ceil_mode':True, - 'exclusive':True, - 'data_format':"NCHW" + # input=data_NCHW, + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [ + [0, 0], + [0, 0], + [2, 2], + [1, 1], + ], # it is same as pool_padding = [2,2,1,1] + "global_pooling": False, + "ceil_mode": True, + "exclusive": True, + "data_format": "NCHW", } # shape of out_2: [2, 3, 4, 4] which is different from out_1 - pool2d(pooling_type+'Pool_test2', data_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test2", data_NCHW, paddle_attrs) # example 3: # pool_padding = "SAME" (different from example 1) paddle_attrs = { - #input=data_NCHW, - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':"SAME", - 'global_pooling':False, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NCHW" + # input=data_NCHW, + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": "SAME", + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } # shape of out_3: [2, 3, 3, 3] which is different from out_1 - pool2d(pooling_type+'Pool_test3', data_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test3", data_NCHW, paddle_attrs) # example 4: # pool_padding = "VALID" (different from example 1) paddle_attrs = { - #input=data_NCHW, - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':"VALID", - 'global_pooling':False, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NCHW" + # input=data_NCHW, + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": "VALID", + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } # shape of out_4: [2, 3, 2, 2] which is different from out_1 - pool2d(pooling_type+'Pool_test4', data_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test4", data_NCHW, paddle_attrs) # example 5: # global_pooling = True (different from example 1) # It will be set pool_size = [8,8] and pool_padding = [0,0] actually. paddle_attrs = { - #input=data_NCHW, - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':[2,1], - 'global_pooling':True, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NCHW" + # input=data_NCHW, + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [2, 1], + "global_pooling": True, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } # shape of out_5: [2, 3, 1, 1] which is different from out_1 - pool2d(pooling_type+'Pool_test5', data_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test5", data_NCHW, paddle_attrs) # example 6: # data_format = "NHWC" (different from example 1) paddle_attrs = { - #input=data_NHWC, # shape: [2, 8, 8, 3] - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':[2,1], - 'global_pooling':False, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NHWC" + # input=data_NHWC, # shape: [2, 8, 8, 3] + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [2, 1], + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NHWC", } # shape of out_6: [2, 4, 3, 3] which is different from out_1 - pool2d(pooling_type+'Pool_test6', data_NHWC, paddle_attrs) + pool2d(pooling_type + "Pool_test6", data_NHWC, paddle_attrs) # example 7: # pool_size is [9, 9] paddle_attrs = { - #input=data_NCHW, - 'pool_size':[9,9], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':[[0,0], [0,0], [2,2], [1,1]], # it is same as pool_padding = [2,2,1,1] - 'global_pooling':False, - 'ceil_mode':True, - 'exclusive':True, - 'data_format':"NCHW" + # input=data_NCHW, + "pool_size": [9, 9], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [ + [0, 0], + [0, 0], + [2, 2], + [1, 1], + ], # it is same as pool_padding = [2,2,1,1] + "global_pooling": False, + "ceil_mode": True, + "exclusive": True, + "data_format": "NCHW", } - pool2d(pooling_type+'Pool_test7', data_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test7", data_NCHW, paddle_attrs) # example 8: # pool_padding size is 1 paddle_attrs = { - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':2, - 'global_pooling':False, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NCHW" + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": 2, + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } - pool2d(pooling_type+'Pool_test8', data_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test8", data_NCHW, paddle_attrs) - #input data for test9 and test10 + # input data for test9 and test10 N_data1, C_data1, H_data1, W_data1 = 2, 3, 8, 8 - data1 = np.arange(N_data1*C_data1*H_data1*W_data1).astype(data_type) + data1 = np.arange(N_data1 * C_data1 * H_data1 * W_data1).astype(data_type) data1_NCHW = data1.reshape(N_data1, C_data1, H_data1, W_data1) # example 9: # pool_padding size is 4: [pad_height_top, pad_height_bottom, pad_width_left, pad_width_right] paddle_attrs = { - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':[2, 1, 2, 1], - 'global_pooling':False, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NCHW" + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [2, 1, 2, 1], + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } - pool2d(pooling_type+'Pool_test9', data1_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test9", data1_NCHW, paddle_attrs) # example 10: # input=data_NCHW and pool_padding is [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]] paddle_attrs = { - 'pool_size':[3,3], - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':[[0,0], [0,0], [2, 1], [2, 1]], - 'global_pooling':False, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NCHW" + "pool_size": [3, 3], + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [[0, 0], [0, 0], [2, 1], [2, 1]], + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } - pool2d(pooling_type+'Pool_test10', data1_NCHW, paddle_attrs) + pool2d(pooling_type + "Pool_test10", data1_NCHW, paddle_attrs) # example 11: # input=data_NCHW and poolsize is the multiply by width & height. pool_padding is [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]] paddle_attrs = { - 'pool_size': 9, - 'pool_type' : pooling_type, - 'pool_stride' : [3,3], - 'pool_padding':[[0,0], [0,0], [2, 1], [2, 1]], - 'global_pooling':False, - 'ceil_mode':False, - 'exclusive':True, - 'data_format':"NCHW" + "pool_size": 9, + "pool_type": pooling_type, + "pool_stride": [3, 3], + "pool_padding": [[0, 0], [0, 0], [2, 1], [2, 1]], + "global_pooling": False, + "ceil_mode": False, + "exclusive": True, + "data_format": "NCHW", } - pool2d(pooling_type+'Pool_test11', data1_NCHW, paddle_attrs) - + pool2d(pooling_type + "Pool_test11", data1_NCHW, paddle_attrs) # adaptive_pool2d for i, pooling_type in enumerate(pooling_types): paddle_attrs = { - 'pool_size': [3,3], - 'pool_type': pooling_type, - 'require_index': False + "pool_size": [3, 3], + "pool_type": pooling_type } - adaptive_pool2d(pooling_type+'AdaptivePool2D_test1', data_NCHW, paddle_attrs) + adaptive_pool2d(pooling_type + "AdaptivePool2D_test1", data_NCHW, paddle_attrs) if __name__ == "__main__": - main() + main() diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_pow.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_pow.py index c845fac78d3337..c762c8a6506f92 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_pow.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_pow.py @@ -15,7 +15,11 @@ def paddle_pow(name : str, x, y, data_type): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.pow(node_x, y, name='pow') + if paddle.__version__ >= '2.0.0': + y = paddle.to_tensor(y, dtype=data_type) + out = paddle.pow(node_x, y, name='pow') + else: + out = paddle.fluid.layers.pow(node_x, y, name='pow') #FuzzyTest supports int32 & float32 if data_type == "int64": out = paddle.cast(out, "float32") @@ -40,7 +44,10 @@ def paddle_pow_tensor(name : str, x, y, data_type): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) node_y = paddle.static.data(name='y', shape=y.shape, dtype=data_type) - out = paddle.fluid.layers.pow(node_x, node_y, name='pow') + if paddle.__version__ >= '2.0.0': + out = paddle.pow(node_x, node_y, name='pow') + else: + out = paddle.fluid.layers.pow(node_x, node_y, name='pow') out = paddle.cast(out, "float32") cpu = paddle.static.cpu_places(1) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_prior_box.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_prior_box.py index 12088009701c0f..b0f1c6b12aacbb 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_prior_box.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_prior_box.py @@ -19,18 +19,32 @@ def prior_box(name: str, input_data, image_data, attrs: dict): Image = paddle.static.data( name='Image', shape=image_data.shape, dtype=image_data.dtype) - box, var = paddle.fluid.layers.prior_box(Input, - Image, - min_sizes=attrs['min_sizes'], - max_sizes=attrs['max_sizes'], - aspect_ratios=attrs['aspect_ratios'], - variance=attrs['variance'], - flip=attrs['flip'], - clip=attrs['clip'], - steps=attrs['steps'], - offset=attrs['offset'], - name=None, - min_max_aspect_ratios_order=attrs['min_max_aspect_ratios_order']) + if paddle.__version__ >= '2.0.0': + box, var = paddle.vision.ops.prior_box(Input, + Image, + min_sizes=attrs['min_sizes'], + max_sizes=attrs['max_sizes'], + aspect_ratios=attrs['aspect_ratios'], + variance=attrs['variance'], + flip=attrs['flip'], + clip=attrs['clip'], + steps=attrs['steps'], + offset=attrs['offset'], + name=None, + min_max_aspect_ratios_order=attrs['min_max_aspect_ratios_order']) + else: + box, var = paddle.fluid.layers.prior_box(Input, + Image, + min_sizes=attrs['min_sizes'], + max_sizes=attrs['max_sizes'], + aspect_ratios=attrs['aspect_ratios'], + variance=attrs['variance'], + flip=attrs['flip'], + clip=attrs['clip'], + steps=attrs['steps'], + offset=attrs['offset'], + name=None, + min_max_aspect_ratios_order=attrs['min_max_aspect_ratios_order']) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_range.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_range.py index 0b1dde6c1fa8b2..dee96b6874fe27 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_range.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_range.py @@ -16,7 +16,10 @@ def paddle_range(name : str, x, start, end, step, out_type): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype='float32') # Range op only support fill_constant input, since dynamic op is not supported in ov - out = paddle.fluid.layers.range(start, end, step, out_type) + if paddle.__version__ >= '2.0.0': + out = paddle.arange(start, end, step, out_type) + else: + out = paddle.fluid.layers.range(start, end, step, out_type) out = paddle.cast(out, np.float32) out = paddle.add(node_x, out) #out = paddle.cast(out, np.float32) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_reduce_all.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_reduce_all.py index c24f9fd3eaef74..6f11265a760bfd 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_reduce_all.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_reduce_all.py @@ -16,7 +16,10 @@ def reduce_all(name : str, x, axis=None, keepdim=False): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): data_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) - reduced = paddle.fluid.layers.reduce_all(data_x, dim=axis, keep_dim=keepdim) + if paddle.__version__ >= '2.0.0': + reduced = paddle.all(data_x, axis=axis, keepdim=keepdim) + else: + reduced = paddle.fluid.layers.reduce_all(data_x, dim=axis, keep_dim=keepdim) out = paddle.cast(reduced, 'int32') cpu = paddle.static.cpu_places(1) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_relu6.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_relu6.py index 2c79c0332a7698..0af6c04ea2d5af 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_relu6.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_relu6.py @@ -15,8 +15,11 @@ def relu6(name: str, x, threshold: float = 6.0, data_type='float32'): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.relu6(node_x, threshold=threshold, name='relu6') - + + if paddle.__version__ >= '2.0.0': + out = paddle.nn.functional.relu6(node_x, name='relu6') + else: + out = paddle.fluid.layers.relu6(node_x, name='relu6') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_reshape.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_reshape.py index 289c2128a0d972..24fbc3f3af351a 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_reshape.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_reshape.py @@ -17,7 +17,10 @@ def reshape(name : str, x, out_shape): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.reshape(x=node_x, shape=out_shape) + if paddle.__version__ >= '2.0.0': + out = paddle.reshape(x=node_x, shape=out_shape) + else: + out = paddle.fluid.layers.reshape(x=node_x, shape=out_shape) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -42,11 +45,14 @@ def reshape_tensor(name : str, x, out_shape, use_tensor_in_list): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) if use_tensor_in_list: out_shape[0] = paddle.assign(np.array((out_shape[0],)).astype('int32')) - out = paddle.fluid.layers.reshape(x=node_x, shape=out_shape) + if paddle.__version__ >= '2.0.0': + out = paddle.reshape(x=node_x, shape=out_shape) + else: + out = paddle.fluid.layers.reshape(x=node_x, shape=out_shape) else: out_shape = np.array(out_shape).astype('int32') node_shape = paddle.assign(out_shape) - out = paddle.fluid.layers.reshape(x=node_x, shape=node_shape) + out = paddle.reshape(x=node_x, shape=node_shape) out = paddle.pow(out, 1) cpu = paddle.static.cpu_places(1) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_reverse.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_reverse.py deleted file mode 100644 index e993057df8389d..00000000000000 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_reverse.py +++ /dev/null @@ -1,61 +0,0 @@ -# Copyright (C) 2018-2023 Intel Corporation -# SPDX-License-Identifier: Apache-2.0 - -# -# reverse paddle model generator -# -import numpy as np -from save_model import saveModel -import sys -import paddle - -def reverse(name: str, x, axis, use_static=True, dtype="float32"): - paddle.enable_static() - - with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): - if use_static: - node_x = paddle.static.data(name='x', shape=x.shape, dtype=dtype) - else: - node_x = paddle.fluid.data(name='x', shape=[1, 1, -1, -1], dtype=dtype) - out = paddle.fluid.layers.reverse(node_x, axis) - - cpu = paddle.static.cpu_places(1) - exe = paddle.static.Executor(cpu[0]) - # startup program will call initializer to initialize the parameters. - exe.run(paddle.static.default_startup_program()) - - outs = exe.run( - feed={'x': x}, - fetch_list=[out]) - - saveModel(name, exe, feedkeys=['x'], fetchlist=[out], inputs=[x], outputs=[outs[0]], target_dir=sys.argv[1]) - - return outs[0] - -def main(): - data1 = np.array([0,2], dtype='int64') - reverse("reverse_static_1", data1, 0, True, 'int64') - - data2 = np.array([[0,1,2], [3,4,5], [6,7,8]], dtype='float32') - reverse("reverse_static_2", data2, 1, True, 'float32') - - data3 = np.array([[0,1,2], [3,4,5], [6,7,8]], dtype='float32') - reverse("reverse_static_3", data3, [0, 1], True, 'float32') - - data4 = np.array([[0,1,2], [3,4,5], [6,7,8]], dtype='int32') - reverse("reverse_static_4", data4, -1, True, 'int32') - - data5 = np.random.randn(1, 1, 32, 32).astype('int32') - reverse("reverse_dynamic_1", data5, [2], False, dtype='int32') - - data6 = np.random.randn(1, 1, 64, 64).astype('float32') - reverse("reverse_dynamic_2", data6, [3], False, dtype='float32') - - data7 = np.random.randn(1, 1, 112, 112).astype('float32') - reverse("reverse_dynamic_3", data7, [2,3], False, dtype='float32') - - data8 = np.random.randn(1, 1, 224, 224).astype('int32') - reverse("reverse_dynamic_4", data8, [-2, -1], False, dtype='int32') - -if __name__ == "__main__": - main() diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_scale.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_scale.py index 2cea7f87e15a12..cacd230574e1d5 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_scale.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_scale.py @@ -34,12 +34,15 @@ def paddle_scale(name : str, x, scale, bias, attrs : dict, data_type): def paddle_scale_tensor(name : str, x, scale, bias, attrs : dict, data_type): - import paddle as paddle + import paddle paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - node_scale = paddle.static.data(name='scale', shape=[1], dtype='float32') + if paddle.__version__ >= '2.5.1': + node_scale = paddle.static.data(name='scale', shape=[], dtype='float32') + else: + node_scale = paddle.static.data(name='scale', shape=[1], dtype='float32') out = paddle.scale(x=node_x, scale=node_scale, bias=bias, bias_after_scale=attrs['bias_after_scale']) #FuzzyTest only support FP32 now, so cast result to fp32 @@ -53,7 +56,10 @@ def paddle_scale_tensor(name : str, x, scale, bias, attrs : dict, data_type): feed={'x': x, 'scale': scale}, fetch_list=[out]) - saveModel(name, exe, feedkeys=['x', 'scale'], fetchlist=[out], inputs=[x, np.array([scale]).astype('float32')], outputs=[outs[0]], target_dir=sys.argv[1]) + if paddle.__version__ >= '2.5.1': + saveModel(name, exe, feedkeys=['x', 'scale'], fetchlist=[out], inputs=[x, np.array(scale).astype('float32')], outputs=[outs[0]], target_dir=sys.argv[1]) + else: + saveModel(name, exe, feedkeys=['x', 'scale'], fetchlist=[out], inputs=[x, np.array([scale]).astype('float32')], outputs=[outs[0]], target_dir=sys.argv[1]) return outs[0] diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_set_value.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_set_value.py index a3266684a7dcfa..876eb03825bbf1 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_set_value.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_set_value.py @@ -167,4 +167,4 @@ def set_value7(x, value, *slice): paddle_set_value("set_value_dynamic2", data, value, set_value7, dtype, starts, ends, steps, is_dynamic=True) if __name__ == "__main__": - main() + main() \ No newline at end of file diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_sigmoid.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_sigmoid.py index 7b6bc715e6a54f..09c8327f277350 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_sigmoid.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_sigmoid.py @@ -15,7 +15,10 @@ def sigmoid(name: str, x, data_type): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=data_type) - out = paddle.fluid.layers.sigmoid(node_x, name='sigmoid') + if paddle.__version__ >= '2.0.0': + out = paddle.nn.functional.sigmoid(node_x, name='sigmoid') + else: + out = paddle.fluid.layers.sigmoid(node_x, name='sigmoid') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_split.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_split.py index 639ab5b51d14c1..d92d286ec6c57b 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_split.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_split.py @@ -15,8 +15,11 @@ def split(name : str, x, attrs : dict): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) - out = paddle.fluid.layers.split(node_x, num_or_sections=attrs['num_or_sections'], dim=attrs['axis']) - + + if paddle.__version__ >= '2.0.0': + out = paddle.split(node_x, num_or_sections=attrs['num_or_sections'], axis=attrs['axis']) + else: + out = paddle.fluid.layers.split(node_x, num_or_sections=attrs['num_or_sections'], dim=attrs['axis']) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. @@ -40,7 +43,10 @@ def split_dim_tensor(name : str, x, attrs : dict, dim): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) dim_node = paddle.assign(dim) - out = paddle.fluid.layers.split(node_x, num_or_sections=attrs['num_or_sections'], dim=dim_node) + if paddle.__version__ >= '2.0.0': + out = paddle.split(node_x, num_or_sections=attrs['num_or_sections'], axis=dim_node) + else: + out = paddle.fluid.layers.split(node_x, num_or_sections=attrs['num_or_sections'], dim=dim_node) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) @@ -66,8 +72,10 @@ def split_test_list_tensor(name : str, x, attrs : dict): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) section = attrs['num_or_sections'] section[0] = paddle.assign(np.array((section[0],)).astype('int32')) - out = paddle.fluid.layers.split(node_x, num_or_sections=section, dim=attrs['axis']) - + if paddle.__version__ >= '2.0.0': + out = paddle.split(node_x, num_or_sections=section, axis=attrs['axis']) + else: + out = paddle.fluid.layers.split(node_x, num_or_sections=section, dim=attrs['axis']) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_squeeze.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_squeeze.py index 08f99ddc3dcdd3..855646d795372d 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_squeeze.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_squeeze.py @@ -16,8 +16,10 @@ def squeeze(name : str, x, axes : list): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype = data_type) - out = paddle.fluid.layers.squeeze(node_x, axes=axes, name='squeeze') - + if paddle.__version__ >= '2.0.0': + out = paddle.squeeze(node_x, axis=axes, name='squeeze') + else: + out = paddle.fluid.layers.squeeze(node_x, axes=axes, name='squeeze') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_strided_slice.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_strided_slice.py index b9517b6add48c4..d651da8dfb0774 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_strided_slice.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_strided_slice.py @@ -11,124 +11,145 @@ def strided_slice(name: str, input_data, attrs: dict): import paddle + paddle.enable_static() with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): Input = paddle.static.data( - name='x', shape=input_data.shape, dtype=input_data.dtype) - - out = paddle.fluid.layers.strided_slice(Input, axes=attrs['axes'], - starts=attrs['starts'], - ends=attrs['ends'], - strides=attrs['strides']) + name="x", shape=input_data.shape, dtype=input_data.dtype + ) + + if paddle.__version__ >= '2.0.0': + out = paddle.strided_slice( + Input, + axes=attrs["axes"], + starts=attrs["starts"], + ends=attrs["ends"], + strides=attrs["strides"], + ) + else: + out = paddle.fluid.layers.strided_slice(Input, axes=attrs['axes'], + starts=attrs['starts'], + ends=attrs['ends'], + strides=attrs['strides']) cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. exe.run(paddle.static.default_startup_program()) - outs = exe.run( - feed={'x': input_data}, - fetch_list=[out]) + outs = exe.run(feed={"x": input_data}, fetch_list=[out]) # Save inputs in order of OpenVINO model, to facilite Fuzzy test, # which accepts inputs and outputs in this order as well. - saveModel(name, exe, feedkeys=['x'], fetchlist=[out], - inputs=[input_data], outputs=[outs[0]], target_dir=sys.argv[1]) + saveModel( + name, + exe, + feedkeys=["x"], + fetchlist=[out], + inputs=[input_data], + outputs=[outs[0]], + target_dir=sys.argv[1], + ) return outs if __name__ == "__main__": - strided_slice_input1_1 = { - 'name': "strided_slice_input1_1", - 'axes': np.array([0]).astype('int32').tolist(), - 'starts': np.array([-4]).astype('int32').tolist(), - 'ends': np.array([-3]).astype('int32').tolist(), - 'strides': np.array([1]).astype('int32').tolist() + "name": "strided_slice_input1_1", + "axes": np.array([0]).astype("int32").tolist(), + "starts": np.array([-4]).astype("int32").tolist(), + "ends": np.array([-3]).astype("int32").tolist(), + "strides": np.array([1]).astype("int32").tolist(), } strided_slice_input1_2 = { - 'name': "strided_slice_input1_2", - 'axes': np.array([0]).astype('int32').tolist(), - 'starts': np.array([3]).astype('int32').tolist(), - 'ends': np.array([8]).astype('int32').tolist(), - 'strides': np.array([1]).astype('int32').tolist() + "name": "strided_slice_input1_2", + "axes": np.array([0]).astype("int32").tolist(), + "starts": np.array([3]).astype("int32").tolist(), + "ends": np.array([8]).astype("int32").tolist(), + "strides": np.array([1]).astype("int32").tolist(), } strided_slice_input1_3 = { - 'name': "strided_slice_input1_3", - 'axes': np.array([0]).astype('int32').tolist(), - 'starts': np.array([5]).astype('int32').tolist(), - 'ends': np.array([0]).astype('int32').tolist(), - 'strides': np.array([-1]).astype('int32').tolist() + "name": "strided_slice_input1_3", + "axes": np.array([0]).astype("int32").tolist(), + "starts": np.array([5]).astype("int32").tolist(), + "ends": np.array([0]).astype("int32").tolist(), + "strides": np.array([-1]).astype("int32").tolist(), } strided_slice_input1_4 = { - 'name': "strided_slice_input1_4", - 'axes': np.array([0]).astype('int32').tolist(), - 'starts': np.array([-1]).astype('int32').tolist(), - 'ends': np.array([-3]).astype('int32').tolist(), - 'strides': np.array([-1]).astype('int32').tolist() + "name": "strided_slice_input1_4", + "axes": np.array([0]).astype("int32").tolist(), + "starts": np.array([-1]).astype("int32").tolist(), + "ends": np.array([-3]).astype("int32").tolist(), + "strides": np.array([-1]).astype("int32").tolist(), } strided_slice_input2_1 = { - 'name': "strided_slice_input2_1", - 'axes': np.array([0, 1, 2]).astype('int32').tolist(), - 'starts': np.array([1, 0, 0]).astype('int32').tolist(), - 'ends': np.array([2, 1, 3]).astype('int32').tolist(), - 'strides': np.array([1, 1, 1]).astype('int32').tolist() + "name": "strided_slice_input2_1", + "axes": np.array([0, 1, 2]).astype("int32").tolist(), + "starts": np.array([1, 0, 0]).astype("int32").tolist(), + "ends": np.array([2, 1, 3]).astype("int32").tolist(), + "strides": np.array([1, 1, 1]).astype("int32").tolist(), } strided_slice_input2_2 = { - 'name': "strided_slice_input2_2", - 'axes': np.array([0, 1, 2]).astype('int32').tolist(), - 'starts': np.array([1, -1, 0]).astype('int32').tolist(), - 'ends': np.array([2, -3, 3]).astype('int32').tolist(), - 'strides': np.array([1, -1, 1]).astype('int32').tolist() + "name": "strided_slice_input2_2", + "axes": np.array([0, 1, 2]).astype("int32").tolist(), + "starts": np.array([1, -1, 0]).astype("int32").tolist(), + "ends": np.array([2, -3, 3]).astype("int32").tolist(), + "strides": np.array([1, -1, 1]).astype("int32").tolist(), } strided_slice_input2_3 = { - 'name': "strided_slice_input2_3", - 'axes': np.array([0, 1, 2]).astype('int32').tolist(), - 'starts': np.array([1, 0, 0]).astype('int32').tolist(), - 'ends': np.array([2, 2, 3]).astype('int32').tolist(), - 'strides': np.array([1, 1, 1]).astype('int32').tolist() + "name": "strided_slice_input2_3", + "axes": np.array([0, 1, 2]).astype("int32").tolist(), + "starts": np.array([1, 0, 0]).astype("int32").tolist(), + "ends": np.array([2, 2, 3]).astype("int32").tolist(), + "strides": np.array([1, 1, 1]).astype("int32").tolist(), } strided_slice_input3_1 = { - 'name': "strided_slice_input3_1", - 'axes': np.array([1]).astype('int32').tolist(), - 'starts': np.array([1]).astype('int32').tolist(), - 'ends': np.array([2]).astype('int32').tolist(), - 'strides': np.array([1]).astype('int32').tolist() + "name": "strided_slice_input3_1", + "axes": np.array([1]).astype("int32").tolist(), + "starts": np.array([1]).astype("int32").tolist(), + "ends": np.array([2]).astype("int32").tolist(), + "strides": np.array([1]).astype("int32").tolist(), } strided_slice_input3_2 = { - 'name': "strided_slice_input3_2", - 'axes': np.array([1]).astype('int32').tolist(), - 'starts': np.array([-1]).astype('int32').tolist(), - 'ends': np.array([-2]).astype('int32').tolist(), - 'strides': np.array([-1]).astype('int32').tolist() + "name": "strided_slice_input3_2", + "axes": np.array([1]).astype("int32").tolist(), + "starts": np.array([-1]).astype("int32").tolist(), + "ends": np.array([-2]).astype("int32").tolist(), + "strides": np.array([-1]).astype("int32").tolist(), } - strided_slice_input1_list = [strided_slice_input1_1, - strided_slice_input1_2, strided_slice_input1_3, strided_slice_input1_4] + strided_slice_input1_list = [ + strided_slice_input1_1, + strided_slice_input1_2, + strided_slice_input1_3, + strided_slice_input1_4, + ] - strided_slice_input2_list = [strided_slice_input2_1, - strided_slice_input2_2, strided_slice_input2_3] + strided_slice_input2_list = [ + strided_slice_input2_1, + strided_slice_input2_2, + strided_slice_input2_3, + ] - strided_slice_input3_list = [ - strided_slice_input3_1, strided_slice_input3_2] + strided_slice_input3_list = [strided_slice_input3_1, strided_slice_input3_2] - input1 = np.random.rand(100).astype('float32') + input1 = np.random.rand(100).astype("float32") for item in strided_slice_input1_list: - pred_paddle = strided_slice(item['name'], input1, item) + pred_paddle = strided_slice(item["name"], input1, item) - input2 = np.random.rand(5, 5, 5).astype('int32') + input2 = np.random.rand(5, 5, 5).astype("int32") for item in strided_slice_input2_list: - pred_paddle = strided_slice(item['name'], input2, item) + pred_paddle = strided_slice(item["name"], input2, item) - input3 = np.random.rand(1, 100, 1).astype('float32') + input3 = np.random.rand(1, 100, 1).astype("float32") for item in strided_slice_input3_list: - pred_paddle = strided_slice(item['name'], input3, item) + pred_paddle = strided_slice(item["name"], input3, item) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_swish.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_swish.py index 9d7d68ae0ec8ed..cd83bc22a16652 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_swish.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_swish.py @@ -3,22 +3,25 @@ # import numpy as np from save_model import saveModel -import paddle as pdpd +import paddle import sys -def swish(name: str, x, data_type, input_beta): - pdpd.enable_static() +def swish(name: str, x, data_type): + paddle.enable_static() - with pdpd.static.program_guard(pdpd.static.Program(), pdpd.static.Program()): - node_x = pdpd.static.data( + with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): + node_x = paddle.static.data( name='input_x', shape=x.shape, dtype=data_type) - out = pdpd.fluid.layers.swish(x=node_x, beta=input_beta, name='swish') + if paddle.__version__ >= '2.0.0': + out = paddle.nn.functional.swish(x=node_x, name='swish') + else: + out = paddle.fluid.layers.swish(x=node_x, name='swish') - cpu = pdpd.static.cpu_places(1) - exe = pdpd.static.Executor(cpu[0]) + cpu = paddle.static.cpu_places(1) + exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. - exe.run(pdpd.static.default_startup_program()) + exe.run(paddle.static.default_startup_program()) outs = exe.run( feed={'input_x': x}, @@ -34,11 +37,11 @@ def main(): data_type = 'float32' input_beta = 1.0 x = np.random.randn(2, 3).astype(data_type) - swish("swish_default_params", x, data_type, input_beta) + swish("swish_default_params", x, data_type) input_beta = 2.0 x = np.random.randn(2, 3).astype(data_type) - swish("swish_beta", x, data_type, input_beta) + swish("swish_beta", x, data_type) if __name__ == "__main__": diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_tile.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_tile.py index bf9089d5c710fb..84174906b39609 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_tile.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_tile.py @@ -8,7 +8,6 @@ from save_model import saveModel import paddle import sys -from paddle.fluid.layers.tensor import fill_constant def paddle_tile(name: str, x, repeat_times, to_tensor=False, tensor_list=False): @@ -24,7 +23,11 @@ def paddle_tile(name: str, x, repeat_times, to_tensor=False, tensor_list=False): repeat_times_list = [] if tensor_list: for i in repeat_times: - temp_out = fill_constant([1], "int32", i, force_cpu=True) + if paddle.__version__ >= '2.0.0': + temp_out = paddle.full([1], i, "int32").cpu() + else: + temp_out = paddle.fluid.layers.tensor.fill_constant([1], "int32", i, force_cpu=True) + repeat_times_list.append(temp_out) else: repeat_times_list = repeat_times diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_unsqueeze.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_unsqueeze.py index 1260e2cb2040ca..50ef4693635514 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_unsqueeze.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_unsqueeze.py @@ -16,7 +16,10 @@ def unsqueeze(name : str, x, axes : list): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype = data_type) - out = paddle.fluid.layers.unsqueeze(node_x, axes = axes, name = 'unsqueeze') + if paddle.__version__ >= '2.0.0': + out = paddle.unsqueeze(node_x, axis=axes, name='unsqueeze') + else: + out = paddle.fluid.layers.unsqueeze(node_x, axes=axes, name='unsqueeze') cpu = paddle.static.cpu_places(1) exe = paddle.static.Executor(cpu[0]) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_where.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_where.py index 3f6a8d89903917..3dbde8def410d3 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_where.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_where.py @@ -22,7 +22,10 @@ def where(name, test_x, test_y, test_cond): Cond_Node = paddle.static.data( name='cond', shape=test_cond.shape, dtype=test_cond.dtype) - Cond_Node_bl = paddle.fluid.layers.cast(Cond_Node, "bool") + if paddle.__version__ >= '2.0.0': + Cond_Node_bl = paddle.cast(Cond_Node, "bool") + else: + Cond_Node_bl = paddle.fluid.layers.cast(Cond_Node, "bool") out = paddle.where(Cond_Node_bl, X_Node, Y_Node) cpu = paddle.static.cpu_places(1) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/generate_where_index.py b/src/frontends/paddle/tests/test_models/gen_scripts/generate_where_index.py index 369162cbdba38e..b7c1ee8258f294 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/generate_where_index.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/generate_where_index.py @@ -16,7 +16,10 @@ def where_index(name: str, x, force_boolean=False): with paddle.static.program_guard(paddle.static.Program(), paddle.static.Program()): node_x = paddle.static.data(name='x', shape=x.shape, dtype=x.dtype) if force_boolean: - node_x_bl = paddle.fluid.layers.cast(node_x, "bool") + if paddle.__version__ >= '2.0.0': + node_x_bl = paddle.cast(node_x, "bool") + else: + node_x_bl = paddle.fluid.layers.cast(node_x, "bool") out = paddle.nonzero(node_x_bl) else: out = paddle.nonzero(node_x) diff --git a/src/frontends/paddle/tests/test_models/gen_scripts/nms.py b/src/frontends/paddle/tests/test_models/gen_scripts/nms.py index d4123e239f6f3d..fc74071799814d 100644 --- a/src/frontends/paddle/tests/test_models/gen_scripts/nms.py +++ b/src/frontends/paddle/tests/test_models/gen_scripts/nms.py @@ -9,30 +9,32 @@ import sys from save_model import saveModel, exportModel, print_alike +from paddle.fluid import data_feeder + # bboxes shape (N, M, 4) if shared else (M, C, 4) # scores shape (N, C, M) if shared else (M, C) def NMS(name: str, bboxes, scores, attrs: dict, rois_num=None, verbose=False): - import paddle as pdpd + import paddle from ops import multiclass_nms as multiclass_nms from ops import matrix_nms as matrix_nms - pdpd.enable_static() + paddle.enable_static() - with pdpd.static.program_guard(pdpd.static.Program(), - pdpd.static.Program()): + with paddle.static.program_guard(paddle.static.Program(), + paddle.static.Program()): # make model with inputs of dynamic shape - node_boxes = pdpd.static.data(name='bboxes', + node_boxes = paddle.static.data(name='bboxes', shape=[-1, -1, 4], dtype=bboxes.dtype, lod_level=1) - node_scores = pdpd.static.data(name='scores', + node_scores = paddle.static.data(name='scores', shape=[-1] * len(scores.shape), dtype=scores.dtype, lod_level=1) node_rois_num = None if rois_num is not None: - node_rois_num = pdpd.static.data(name='rois_num', + node_rois_num = paddle.static.data(name='rois_num', shape=rois_num.shape, dtype=rois_num.dtype, lod_level=1) @@ -67,14 +69,14 @@ def NMS(name: str, bboxes, scores, attrs: dict, rois_num=None, verbose=False): output = [] for x in nms_outputs: if x is not None: - if x.dtype==pdpd.int32 or x.dtype==pdpd.int64: - x = pdpd.cast(x, "float32") + if x.dtype==paddle.int32 or x.dtype==paddle.int64: + x = paddle.cast(x, "float32") output.append(x) - cpu = pdpd.static.cpu_places(1) - exe = pdpd.static.Executor(cpu[0]) + cpu = paddle.static.cpu_places(1) + exe = paddle.static.Executor(cpu[0]) # startup program will call initializer to initialize the parameters. - exe.run(pdpd.static.default_startup_program()) + exe.run(paddle.static.default_startup_program()) fetch_vars = [x for x in output if x is not None] feed_dict = {'bboxes': bboxes, 'scores': scores} @@ -92,9 +94,12 @@ def NMS(name: str, bboxes, scores, attrs: dict, rois_num=None, verbose=False): out = np.array(output_lod.pop(0)) nms_rois_num = np.array( output_lod.pop(0)) if output[1] is not None else None - index = np.array(output_lod.pop(0)).astype(pdpd.fluid.data_feeder.convert_dtype( - output[2].dtype)) if output[2] is not None else None - + if paddle.__version__ >= '2.0.0': + index = np.array(output_lod.pop(0)).astype(data_feeder.convert_dtype( + output[2].dtype)) if output[2] is not None else None + else: + index = np.array(output_lod.pop(0)).astype(paddle.fluid.data_feeder.convert_dtype( + output[2].dtype)) if output[2] is not None else None # Save inputs in order of OpenVINO model, to facilite Fuzzy test, # which accepts inputs and outputs in this order as well. output_np = [out, nms_rois_num, index]