代码贡献 | 为 OpenVINO™ 支持 Paddle 2.5

    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')
        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')

def relu6(x, name=None):
    threshold = 6.0
    if in_dynamic_or_pir_mode():
        return _C_ops.relu6(x)
 
    check_variable_and_dtype(
        x, 'x', ['float16', 'uint16', 'float32', 'float64'], 'relu6'
    )
    helper = LayerHelper('relu6', **locals())
    out = helper.create_variable_for_type_inference(x.dtype)
    helper.append_op(
        type='relu6',
        inputs={'X': x},
        outputs={'Out': out},
        attrs={'threshold': threshold},
    )
    return out

// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
 
#include "default_opset.hpp"
#include "openvino/frontend/paddle/node_context.hpp"
 
namespace ov {
namespace frontend {
namespace paddle {
namespace op {
NamedOutputs top_k_v2(const NodeContext& node) {
    auto x = node.get_input("X");
    Output<Node> k_expected_node;
    if (node.has_input("K")) {
        auto k_variable = node.get_input("K");
        auto k_var_node = std::make_shared<default_opset::Convert>(k_variable, element::i32);
        k_expected_node = std::make_shared<default_opset::Squeeze>(k_var_node);
    } else {
        const auto k_expected = node.get_attribute<int>("k", 1);
        k_expected_node = default_opset::Constant::create(element::i32, {}, {k_expected});
    }
 
    auto axis = node.get_attribute<int32_t>("axis", -1);
    bool sorted = node.get_attribute<bool>("sorted", true);
    bool largest = node.get_attribute<bool>("largest", true);
 
    std::string sort_type = sorted ? "value" : "none";
    std::string mode = largest ? "max" : "min";
 
    auto node_topk = std::make_shared<default_opset::TopK>(x, k_expected_node, axis, mode, sort_type);
 
    NamedOutputs named_outputs;
    named_outputs["Out"] = OutputVector{node_topk->output(0)};
    named_outputs["Indices"] = OutputVector{node_topk->output(1)};
 
    return named_outputs;
}
}  // namespace op
}  // namespace paddle
}  // namespace frontend
}  // namespace ov

NamedOutputs argmax(const NodeContext& node) {
    auto data = node.get_input("X");
    bool flatten = node.get_attribute<bool>("flatten");
    const element::Type& index_element_type = element::i64;
    const Output<ov::Node> k = ov::opset6::Constant::create(ov::element::i64, {}, {1});
 
    if (!flatten) {
        auto axis = node.get_attribute<int64_t>("axis");
        const auto axis_to_remove = ov::opset6::Constant::create(element::u64, Shape{}, {axis});
        auto node_topk = std::make_shared<ov::opset6::TopK>(data, k, axis, "max", "index", index_element_type);
        const auto reshaped_indices = std::make_shared<ov::opset6::Squeeze>(node_topk->output(1), axis_to_remove);
        return node.default_single_output_mapping(
            {std::make_shared<ov::opset6::Convert>(reshaped_indices, element::i64)},
            {"Out"});
    } else {
        int64_t axis = 0;
        const Output<ov::Node> reshape_flatten = ov::opset6::Constant::create(ov::element::i64, {1}, {-1});
        auto node_reshape = std::make_shared<ov::opset6::Reshape>(data, reshape_flatten, true);
        auto node_topk = std::make_shared<ov::opset6::TopK>(node_reshape, k, axis, "max", "index", index_element_type);
        const auto output_info = node.get_output_port_infos("Out");
        // 获取输出的维度
        size_t output_size = output_info[0].second.size();
        // 如果输出的维度为0，那么就组合一个Slice节点返回
        if (output_size == 0) {
            auto out = std::make_shared<ov::opset6::Squeeze>(node_topk->output(1));
            return node.default_single_output_mapping({std::make_shared<ov::opset6::Convert>(out, element::i64)},
                                                      {"Out"});
        } else {
            return node.default_single_output_mapping(
                {std::make_shared<ov::opset6::Convert>(node_topk->output(1), element::i64)},
                {"Out"});
        }
    }
}