【Hackathon 5th No.95】add paddle unique op

src/frontends/paddle/src/op/unique.cpp

@@ -0,0 +1,41 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "default_opset.hpp"
+#include "openvino/frontend/paddle/node_context.hpp"
+#include "openvino/opsets/opset10.hpp"
+
+namespace ov {
+namespace frontend {
+namespace paddle {
+namespace op {
+NamedOutputs unique(const NodeContext& node) {
+    auto x = node.get_input("X");
+
+    std::vector<Output<Node>> outputs;
+    NamedOutputs named_outputs;
+
+    auto axis = node.get_attribute<std::vector<int32_t>>("axis");
+
+    auto dtype_str = node.get_attribute<std::string>("dtype");
+    auto dtype = dtype_str == "int32" ? element::i32 : element::i64;
+
+    if (axis.size() != 0) {
+        auto axis_node = std::make_shared<default_opset::Constant>(element::i32, Shape{}, axis);
+        outputs = std::make_shared<ov::opset10::Unique>(x, axis_node, true, dtype, dtype)->outputs();
+    } else {
+        outputs = std::make_shared<ov::opset10::Unique>(x, true, dtype, dtype)->outputs();
+    }
+
+    named_outputs["Index"] = {outputs[2]};
+    named_outputs["Indices"] = {outputs[1]};
+    named_outputs["Counts"] = {outputs[3]};
+    named_outputs["Out"] = {outputs[0]};
+    return named_outputs;
+}
+
+}  // namespace op
+}  // namespace paddle
+}  // namespace frontend
+}  // namespace ov

src/frontends/paddle/src/op_table.cpp

@@ -120,6 +120,7 @@ OP_CONVERTER(top_k_v2);
 OP_CONVERTER(transpose2);
 OP_CONVERTER(trilinear_interp_v2);
 OP_CONVERTER(unsqueeze);
+OP_CONVERTER(unique);
 OP_CONVERTER(where);
 OP_CONVERTER(while_);
 OP_CONVERTER(write_to_array);
@@ -249,6 +250,7 @@ std::map<std::string, CreatorFunction> get_supported_ops() {
             {"transpose2", op::transpose2},
             {"trilinear_interp_v2", op::trilinear_interp_v2},
             {"unsqueeze2", op::unsqueeze},
+            {"unique", op::unique},
             {"where", op::where},
             {"while", op::while_},
             {"write_to_array", op::write_to_array},

src/frontends/paddle/tests/op_fuzzy.cpp

@@ -6,9 +6,9 @@
 
 #include <fstream>
 
+#include "common_test_utils/test_control.hpp"
 #include "ngraph/ngraph.hpp"
 #include "paddle_utils.hpp"
-#include "common_test_utils/test_control.hpp"
 
 using namespace ngraph;
 using namespace InferenceEngine;
@@ -565,6 +565,16 @@ static const std::vector<std::string> models{
     std::string("trilinear_upsample_scales2/trilinear_upsample_scales2.pdmodel"),
     std::string("trilinear_upsample_true_0/trilinear_upsample_true_0.pdmodel"),
     std::string("unsqueeze"),
+    std::string("unique"),
+    std::string("unique_ret_index"),
+    std::string("unique_ret_inverse"),
+    std::string("unique_ret_counts"),
+    std::string("unique_ret_index_inverse"),
+    std::string("unique_ret_index_counts"),
+    std::string("unique_ret_inverse_counts"),
+    std::string("unique_ret_index_inverse_counts"),
+    std::string("unique_ret_index_axis"),
+    std::string("unique_ret_index_i32"),
     std::string("where_1"),
     std::string("where_2"),
     std::string("where_3"),

src/frontends/paddle/tests/test_models/gen_scripts/generate_unique.py

@@ -0,0 +1,90 @@
+# Copyright (C) 2018-2023 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+#
+# unique paddle model generator
+#
+import numpy as np
+from save_model import saveModel
+import paddle
+import sys
+
+data_type = "float32"
+
+
+def unique(
+    name: str,
+    x,
+    reture_index=False,
+    reture_inverse=False,
+    reture_counts=False,
+    dtype="int64",
+    axes=None,
+):
+    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)
+
+        unique_outs = paddle.unique(
+            node_x,
+            return_index=reture_index,
+            return_inverse=reture_inverse,
+            return_counts=reture_counts,
+            dtype=dtype,
+            axis=axes,
+        )
+        if reture_counts or reture_inverse or reture_index:
+            outputs = []
+            for out in unique_outs:
+                if out is not None:
+                    if out.dtype == paddle.int64 or out.dtype == paddle.int32:
+                        out = paddle.cast(out, "float32")
+                outputs.append(out)
+        else:
+            outputs = [unique_outs]
+
+        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())
+
+        fetch_vars = [x for x in outputs if x is not None]
+
+        outs = exe.run(feed={"x": x}, fetch_list=fetch_vars)
+
+        saveModel(
+            name,
+            exe,
+            feedkeys=["x"],
+            fetchlist=fetch_vars,
+            inputs=[x],
+            outputs=outs,
+            target_dir=sys.argv[1],
+        )
+
+
+def main():
+    data = np.array([2, 3, 3, 1, 5, 3]).astype(data_type)
+    unique("unique", data)
+    unique("unique_ret_index", data, reture_index=True)
+    unique("unique_ret_inverse", data, reture_inverse=True)
+    unique("unique_ret_counts", data, reture_counts=True)
+    unique("unique_ret_index_inverse", data, reture_index=True, reture_inverse=True)
+    unique("unique_ret_index_counts", data, reture_index=True, reture_counts=True)
+    unique("unique_ret_inverse_counts", data, reture_inverse=True, reture_counts=True)
+    unique(
+        "unique_ret_index_inverse_counts",
+        data,
+        reture_index=True,
+        reture_inverse=True,
+        reture_counts=True,
+    )
+
+    data = np.array([[2, 1, 3], [3, 0, 1], [2, 1, 3]]).astype(data_type)
+    unique("unique_ret_index_axis", data, reture_index=True, axes=0)
+    unique("unique_ret_index_i32", data, reture_index=True, dtype="int32")
+
+
+if __name__ == "__main__":
+    main()