Unique Operator. (#2072)

Ref Unique Operator only

src/CMakeLists.txt

@@ -241,6 +241,7 @@ register_migraphx_ops(
     transpose
     unary_not
     undefined
+    unique
     unknown
     unsqueeze
     where

src/include/migraphx/op/unique.hpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MIGRAPHX_GUARD_OPERATORS_UNIQUE_HPP
+#define MIGRAPHX_GUARD_OPERATORS_UNIQUE_HPP
+
+#include <migraphx/shape_for_each.hpp>
+#include <migraphx/check_shapes.hpp>
+#include <migraphx/config.hpp>
+#include <migraphx/argument.hpp>
+#include <migraphx/tune_axis.hpp>
+#include <utility>
+#include <map>
+#include <limits>
+#include <optional>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace op {
+
+// https://onnx.ai/onnx/operators/onnx__Unique.html
+// The Onnx spec refers to numpy specification, used as a reference:
+// https://numpy.org/doc/stable/reference/generated/numpy.unique.html
+
+// Input : Given an array of elements : X.
+
+// Output(s) :
+// 1. Find the unique elements (Y) of input (X).
+//
+// There are three outputs in addition to the unique elements in Y:
+// 2. the indices of the input array that give the unique values
+// 3. the indices of the unique array that reconstruct the input array
+// 4. the number of times each unique value comes up in the input array
+
+// Optional Attribute: 'Sorted' = 1 for sorted; = 0 for unsorted.
+// Onnx specification makes 'sorted' a default, while Numpy always sorts.
+//
+// Optional Attribute: 'Axis' is 'None' (default) or a valid int < rank(X).
+// Negative values are allowed.
+//
+// Numpy has the following important note on Axis:
+// ------------------------------------------------------------------
+// When an axis is specified the subarrays indexed by the axis are
+// sorted. This is done by making the specified axis the first
+// dimension of the array (move the axis to the first dimension to
+// keep the order of the other axes) and then flattening the subarrays
+// in C order. The flattened subarrays are then viewed as a structured
+// type with each element given a label, with the effect that we end
+// up with a 1-D array of structured types that can be treated in the
+// same way as any other 1-D array. The result is that the flattened
+// subarrays are sorted in lexicographic order starting with the first
+// element.
+// ------------------------------------------------------------------
+
+struct unique
+{
+
+    template <class T>
+    auto make_idx_less_fn(const T& data, size_t chunk_sz) const
+    {
+        return [&data, chunk_sz](auto idx1, auto idx2) {
+            return std::lexicographical_compare(data.begin() + idx1,
+                                                data.begin() + idx1 + chunk_sz,
+                                                data.begin() + idx2,
+                                                data.begin() + idx2 + chunk_sz);
+        };
+    }
+
+    // CASE SORTED:
+    //
+    // To process into a sorted unique series of elements/chunks:
+    // Chunk size == 1 means a simple element; >1 means a flat representation.
+    // Steps: first go through the input elements/chunks for uniqueness.
+    // At the end of this processing, per the sorted sequence of unique elements:
+    // update/create data structures: y, y_indices, x_rev_indices, y_count
+    //
+    // INPUT x: [2, 1, 1, 3, 4, 3], attr_sorted = 1;
+
+    // OUTPUT(s): indices..
+    // y_indices: [1, 0, 3, 4]  --- first incidence, in terms of index in sequence x
+    // x_rev_indices: [1, 0, 0, 2, 3, 2] --- x seen in terms of indices of unique sequence y
+    // y_count: [2, 1, 2, 1] -- count at each y_index. sum = len(x)
+
+    // NOTE: y [1, 2, 3, 4]   --- the unique output is constructed from x[y_indices[...]]
+
+    template <class T>
+    auto sorted_uniq_indices(const T& input_data, size_t chunk_sz) const
+    {
+        struct y_info
+        {
+            size_t y_idx;
+            size_t x_idx;
+            size_t ct = 0;
+        };
+
+        auto idx_less_fn = make_idx_less_fn(input_data, chunk_sz);
+        std::map<size_t, y_info, decltype(idx_less_fn)> uniq_val_map(idx_less_fn);
+
+        std::tuple<std::vector<std::size_t>, std::vector<std::size_t>, std::vector<std::size_t>> rv;
+        auto& [y_indices, x_rev_indices, y_count] = rv;
+
+        // go through all the elements and find the unique elements..
+        size_t count_x = input_data.size();
+        for(size_t f_idx = 0, x_idx = 0; f_idx < count_x; f_idx += chunk_sz, x_idx++)
+        {
+            y_info entry          = {.y_idx = uniq_val_map.size(), .x_idx = x_idx};
+            auto [itr, added_new] = uniq_val_map.insert({f_idx, entry});
+            itr->second.ct++;
+            x_rev_indices.push_back(itr->second.y_idx);
+        }
+
+        std::vector<std::size_t> y2x_indices(uniq_val_map.size());
+        y_indices.resize(uniq_val_map.size());
+        y_count.resize(uniq_val_map.size());
+        size_t idx = 0;
+        // the unique elements are now sorted:
+        // post-processing for all the return indices.
+        for(const auto& v : uniq_val_map)
+        {
+            y2x_indices[v.second.y_idx] = idx;
+            y_indices[idx]              = v.second.x_idx;
+            y_count[idx]                = v.second.ct;
+            idx++;
+        }
+        // update x_rev_indices as per the sorted order of y_indices
+        for(auto& i : x_rev_indices)
+            i = y2x_indices[i];
+
+        return rv;
+    }
+
+    // CASE UNSORTED:
+    //
+    // To process into an un-sorted unique series of elements/chunks:
+    // For chunk size = 1 is a simple element, else use a flat representation of a tensor obj
+    // Go through the input elements/chunks one by one with inline processing of indices..
+
+    // INPUT x: [2, 1, 1, 3, 4, 3], attr_sorted = 0;
+
+    // OUTPUT(s): indices..
+    // y_indices: [0, 1, 3, 4]  --- first incidence, in terms of index in sequence x
+    // x_rev_indices: [0, 1, 1, 2, 3, 2] --- x seen in terms of indices of unique sequence y
+    // y_count: [1, 2, 2, 1] -- count at each y_index. sum = len(x)
+
+    // NOTE: y [2, 1, 3, 4]   --- the unique output is constructed from x[y_indices[...]]
+    // Output data structures: y_indices, x_rev_indices, y_count are processed inline.
+
+    template <class T>
+    auto unsorted_uniq_indices(const T& input_data, size_t chunk_sz) const
+    {
+        auto idx_less_fn = make_idx_less_fn(input_data, chunk_sz);
+        std::map<size_t, size_t, decltype(idx_less_fn)> uniq_val_map(idx_less_fn);
+
+        // rv is used for NVRO below..
+        std::tuple<std::vector<std::size_t>, std::vector<std::size_t>, std::vector<std::size_t>> rv;
+        auto& [y_indices, x_rev_indices, y_count] = rv;
+
+        // go through all the elements and add the unique elements into the map..
+        // inline processing for outputs: y_indices, x_rev_indices, y_count
+        size_t count_x = input_data.size();
+        for(size_t f_idx = 0; f_idx < count_x; f_idx += chunk_sz)
+        {
+            auto [itr, added_new] = uniq_val_map.insert({f_idx, y_indices.size()});
+            if(added_new)
+            {
+                y_count.push_back(0);
+                y_indices.push_back(x_rev_indices.size());
+            }
+            y_count[itr->second]++;
+            x_rev_indices.push_back(itr->second);
+        }
+
+        return rv;
+    }
+
+    // Axis. Default: none. Range: [-rank, rank-1]
+    std::optional<int64_t> axis;
+
+    // Sorted, Default: 1= sorted. 0 = unsorted.
+    bool sorted = true;
+
+    template <class Self, class F>
+    static auto reflect(Self& self, F f)
+    {
+        return pack(f(self.axis, "axis"), f(self.sorted, "sorted"));
+    }
+
+    std::string name() const { return "unique"; }
+
+    shape compute_shape(std::vector<shape> inputs) const
+    {
+        check_shapes{inputs, *this}.has(1);
+
+        auto& sh_x         = inputs[0];
+        auto lens_x        = sh_x.lens();
+        size_t dim_x       = sh_x.ndim();
+        size_t max_uniq_ct = sh_x.elements();
+        std::vector<shape::dynamic_dimension> d_out;
+
+        if(axis)
+        {
+            int64_t t_axis = migraphx::tune_axis(dim_x, *axis, name());
+            if(t_axis != 0)
+                MIGRAPHX_THROW("Unique: Only supports axis = 0 or None");
+
+            d_out = sh_x.to_dynamic().dyn_dims();
+            // only axis = 0 is supported:
+            max_uniq_ct = lens_x[0];
+            // min = 1 unique element; max = full dimension along axis 0
+            d_out[0] = {1, max_uniq_ct};
+        }
+        else
+        {
+            d_out.push_back({1, max_uniq_ct});
+        }
+
+        shape sh_y = {sh_x.type(), d_out};
+        // The three outputted Indices are just 1-D:
+        shape sh_idx{shape::int64_type, {d_out[0]}};
+
+        return {{sh_y, sh_idx, sh_idx, sh_idx}};
+    }
+
+    argument compute(const dyn_output& dyn_out, std::vector<argument> args) const
+    {
+        auto sh_x          = args.front().get_shape();
+        auto lens_x        = sh_x.lens();
+        shape output_shape = dyn_out.computed_shape;
+        auto vec_ss        = output_shape.sub_shapes();
+        auto ct_x          = sh_x.elements();
+        shape sh_y         = {vec_ss[0].type(), {ct_x}};
+        shape sh_idx       = {vec_ss[1].type(), {ct_x}};
+        shape sh_x_idx     = {vec_ss[1].type(), {ct_x}};
+
+        argument res_y{sh_y};
+        argument res_y_idx{sh_idx};
+        argument res_x_rev_idx{sh_idx};
+        argument res_y_ct_idx{sh_idx};
+
+        std::vector<size_t> out_y_idx;
+        std::vector<size_t> out_x_rev_idx;
+        std::vector<size_t> out_y_ct;
+
+        // If axis is not none, for >1D tensors, we have to consider
+        // then, the uniqueness of chunks of sub-tensors: a subsequence of built-ins..
+        // For a built-in type, chunk_sz is of course = 1
+        size_t chunk_sz = 1;
+        if(axis)
+            chunk_sz = ct_x / lens_x[0]; // axis = 0 is supported.
+
+        visit_all(args.front(), res_y)([&](auto x, auto y_flat) {
+            using o_type = typename decltype(x)::value_type;
+            std::vector<o_type> x_in(x.begin(), x.end());
+
+            std::tie(out_y_idx, out_x_rev_idx, out_y_ct) =
+                sorted ? sorted_uniq_indices(x_in, chunk_sz)
+                       : unsorted_uniq_indices(x_in, chunk_sz);
+
+            const auto uniq_ct = out_y_idx.size();
+
+            // construct y from x[indices] in flattened form
+            // later we reshape y to the final shape..
+            auto y_dst = y_flat.begin();
+            for(size_t idx = 0; idx < uniq_ct; idx++)
+                y_dst = copy_n(x_in.begin() + out_y_idx[idx] * chunk_sz, chunk_sz, y_dst);
+
+            std::vector<size_t> lens_y;
+            // if axis is specified:
+            // the output shape keeps the n-1 dimensions of x
+            if(axis)
+            {
+                lens_y    = lens_x;
+                lens_y[0] = uniq_ct;
+            }
+            else
+            {
+                lens_y = {uniq_ct};
+            }
+            sh_y   = {sh_y.type(), lens_y};
+            sh_idx = {sh_idx.type(), {uniq_ct}};
+        });
+
+        visit_all(res_y_idx, res_x_rev_idx, res_y_ct_idx)(
+            [&](auto y_indices, auto x_rev_indices, auto y_count) {
+                std::copy(out_y_idx.begin(), out_y_idx.end(), y_indices.begin());
+                std::copy(out_x_rev_idx.begin(), out_x_rev_idx.end(), x_rev_indices.begin());
+                std::copy(out_y_ct.begin(), out_y_ct.end(), y_count.begin());
+                sh_x_idx = {sh_idx.type(), {out_x_rev_idx.size()}};
+            });
+
+        return {{res_y.reshape(sh_y),
+                 res_y_idx.reshape(sh_idx),
+                 res_x_rev_idx.reshape(sh_x_idx),
+                 res_y_ct_idx.reshape(sh_idx)}};
+    }
+};
+
+} // namespace op
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/operators.hpp

@@ -139,6 +139,7 @@
 #include <migraphx/op/unary.hpp>
 #include <migraphx/op/unary_not.hpp>
 #include <migraphx/op/undefined.hpp>
+#include <migraphx/op/unique.hpp>
 #include <migraphx/op/unknown.hpp>
 #include <migraphx/op/unsqueeze.hpp>
 #include <migraphx/op/where.hpp>

src/include/migraphx/tune_axis.hpp

 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,21 +24,21 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_TUNE_AXIS_HPP
 #define MIGRAPHX_GUARD_OPERATORS_TUNE_AXIS_HPP
 
-#include <utility>
-#include <cstdint>
 #include <migraphx/stringutils.hpp>
 #include <migraphx/errors.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 
-inline int tune_axis(const int n_dim, const int axis, const std::string& op_name = "OPERATOR")
+inline int tune_axis(int n_dim, int axis, const std::string& op_name = "OPERATOR")
 {
-    if(axis >= n_dim or std::abs(axis) > n_dim)
-    {
+    if(axis < 0)
+        axis += n_dim;
+
+    if(axis < 0 or axis >= n_dim)
         MIGRAPHX_THROW(to_upper(op_name) + ": axis is out of range.");
-    }
-    return (axis < 0) ? axis + n_dim : axis;
+
+    return axis;
 }
 
 } // namespace MIGRAPHX_INLINE_NS

src/onnx/parse_unique.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <migraphx/onnx/op_parser.hpp>
+#include <migraphx/ranges.hpp>
+#include <migraphx/instruction.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/tune_axis.hpp>
+#include <optional>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+namespace onnx {
+
+// generate unique output stream y, given input stream x;
+//
+// case unsorted:
+// input x: [2, 1, 1, 3, 4, 3], attr_sorted = 0;
+// output(s):
+// y: [2, 1, 3, 4]   --- the unique output
+// y_indices: [0, 1, 3, 4]  --- first incidence, in terms of indices of x
+// x_rev_indices: [0, 1, 1, 2, 3, 2] --- x seen in terms of indices of y
+// y_count: [1, 2, 2, 1] -- count at each y_index. sum = len(x)
+//
+// case sorted:
+// input x: [2, 1, 1, 3, 4, 3], attr_sorted = 1;
+// output(s):
+// y: [1, 2, 3, 4]   --- the unique output
+// y_indices: [1, 0, 3, 4]  --- first incidence, in terms of indices of x
+// x_rev_indices: [1, 0, 0, 2, 3, 2] --- x seen in terms of indices of y
+// y_count: [2, 1, 2, 1] -- count at each y_index. sum = len(x)
+
+struct parse_unique : op_parser<parse_unique>
+{
+
+    std::vector<op_desc> operators() const { return {{"Unique"}}; }
+
+    std::vector<instruction_ref> parse(const op_desc& opd,
+                                       const onnx_parser& parser,
+                                       const onnx_parser::node_info& info,
+                                       std::vector<instruction_ref> args) const
+    {
+        int64_t sorted = 1; // default = sorted.
+
+        if(contains(info.attributes, "sorted"))
+            sorted = parser.parse_value(info.attributes.at("sorted")).at<int>();
+
+        std::optional<int64_t> axis;
+        if(contains(info.attributes, "axis"))
+        {
+            auto n_dim = args[0]->get_shape().ndim();
+            axis       = parser.parse_value(info.attributes.at("axis")).at<int>();
+            axis       = tune_axis(n_dim, *axis, opd.op_name);
+        }
+        migraphx::argument data_arg = args.back()->eval();
+
+        auto opr     = axis ? migraphx::make_op("unique", {{"axis", *axis}, {"sorted", sorted}})
+                            : migraphx::make_op("unique", {{"sorted", sorted}});
+        auto u_opr   = info.add_instruction(opr, args.at(0));
+        auto i_y     = info.add_instruction(make_op("get_tuple_elem", {{"index", 0}}), u_opr);
+        auto i_y_idx = info.add_instruction(make_op("get_tuple_elem", {{"index", 1}}), u_opr);
+        auto i_x_idx = info.add_instruction(make_op("get_tuple_elem", {{"index", 2}}), u_opr);
+        auto i_count = info.add_instruction(make_op("get_tuple_elem", {{"index", 3}}), u_opr);
+
+        return {i_y, i_y_idx, i_x_idx, i_count};
+    }
+};
+
+} // namespace onnx
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

test/onnx/gen_onnx.py

@@ -9543,6 +9543,97 @@ def undefined_test():
     return ([node], [x], [y])
 
 
+@onnx_test()
+def unique_dynamic_sorted_test():
+    x = helper.make_tensor_value_info('X', TensorProto.FLOAT, [6])
+    y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [4])
+    y_ind = helper.make_tensor_value_info('indices', TensorProto.INT64, [4])
+    x_ind = helper.make_tensor_value_info('inverse_indices', TensorProto.INT64,
+                                          [6])
+    count = helper.make_tensor_value_info('counts', TensorProto.INT64, [4])
+
+    node = onnx.helper.make_node(
+        'Unique',
+        inputs=['X'],
+        outputs=['Y', 'indices', 'inverse_indices', 'counts'],
+        axis=0,
+        sorted=1)
+    return ([node], [x], [y, y_ind, x_ind, count])
+
+
+@onnx_test()
+def unique_dynamic_sorted_3D_test():
+    x = helper.make_tensor_value_info('X', TensorProto.INT64, [4, 4, 4])
+    y = helper.make_tensor_value_info('Y', TensorProto.INT64, [16])
+    y_ind = helper.make_tensor_value_info('indices', TensorProto.INT64, [16])
+    x_ind = helper.make_tensor_value_info('inverse_indices', TensorProto.INT64,
+                                          [64])
+    count = helper.make_tensor_value_info('counts', TensorProto.INT64, [16])
+
+    node = onnx.helper.make_node(
+        'Unique',
+        inputs=['X'],
+        outputs=['Y', 'indices', 'inverse_indices', 'counts'],
+        sorted=1)
+    return ([node], [x], [y, y_ind, x_ind, count])
+
+
+@onnx_test()
+def unique_dynamic_unsorted_test():
+    x = helper.make_tensor_value_info('X', TensorProto.FLOAT, [6])
+    y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [4])
+    y_ind = helper.make_tensor_value_info('indices', TensorProto.INT64, [4])
+    x_ind = helper.make_tensor_value_info('inverse_indices', TensorProto.INT64,
+                                          [6])
+    count = helper.make_tensor_value_info('counts', TensorProto.INT64, [4])
+
+    node = onnx.helper.make_node(
+        'Unique',
+        inputs=['X'],
+        outputs=['Y', 'indices', 'inverse_indices', 'counts'],
+        axis=0,
+        sorted=0)
+    return ([node], [x], [y, y_ind, x_ind, count])
+
+
+@onnx_test()
+def unique_sorted_test():
+    x = helper.make_tensor('X', TensorProto.FLOAT, [6], [2, 1, 1, 3, 4, 3])
+
+    y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [4])
+    y_ind = helper.make_tensor_value_info('indices', TensorProto.INT64, [4])
+    x_ind = helper.make_tensor_value_info('inverse_indices', TensorProto.INT64,
+                                          [6])
+    count = helper.make_tensor_value_info('counts', TensorProto.INT64, [4])
+
+    node = onnx.helper.make_node(
+        'Unique',
+        inputs=['X'],
+        outputs=['Y', 'indices', 'inverse_indices', 'counts'],
+        axis=0,
+        sorted=1)
+    return ([node], [], [y, y_ind, x_ind, count], [x])
+
+
+@onnx_test()
+def unique_unsorted_test():
+    x = helper.make_tensor('X', TensorProto.FLOAT, [6], [2, 1, 1, 3, 4, 3])
+
+    y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [4])
+    y_ind = helper.make_tensor_value_info('indices', TensorProto.INT64, [4])
+    x_ind = helper.make_tensor_value_info('inverse_indices', TensorProto.INT64,
+                                          [6])
+    count = helper.make_tensor_value_info('counts', TensorProto.INT64, [4])
+
+    node = onnx.helper.make_node(
+        'Unique',
+        inputs=['X'],
+        outputs=['Y', 'indices', 'inverse_indices', 'counts'],
+        axis=0,
+        sorted=0)
+    return ([node], [], [y, y_ind, x_ind, count], [x])
+
+
 @onnx_test()
 def unknown_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])

test/onnx/onnx_test.cpp

@@ -8606,6 +8606,86 @@ TEST_CASE(undefined_test)
     EXPECT(p == prog);
 }
 
+TEST_CASE(unique_dynamic_sorted_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    migraphx::shape s{migraphx::shape::float_type, {6}};
+    auto x = mm->add_parameter("X", s);
+
+    auto out   = mm->add_instruction(migraphx::make_op("unique", {{"sorted", 1}, {"axis", 0}}), x);
+    auto y     = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), out);
+    auto y_ind = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), out);
+    auto x_ind = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), out);
+    auto count = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 3}}), out);
+
+    mm->add_return({y, y_ind, x_ind, count});
+    auto prog = migraphx::parse_onnx("unique_dynamic_sorted_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+TEST_CASE(unique_dynamic_sorted_3D_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    migraphx::shape s{migraphx::shape::int64_type, {4, 4, 4}};
+    auto x = mm->add_parameter("X", s);
+
+    auto out   = mm->add_instruction(migraphx::make_op("unique", {{"sorted", 1}}), x);
+    auto y     = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), out);
+    auto y_ind = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), out);
+    auto x_ind = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), out);
+    auto count = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 3}}), out);
+
+    mm->add_return({y, y_ind, x_ind, count});
+    auto prog = migraphx::parse_onnx("unique_dynamic_sorted_3D_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+TEST_CASE(unique_sorted_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    migraphx::shape s_x{migraphx::shape::float_type, {6}};
+    std::vector<float> x_data = {2, 1, 1, 3, 4, 3};
+    auto x                    = mm->add_literal(migraphx::literal(s_x, x_data));
+
+    auto out   = mm->add_instruction(migraphx::make_op("unique", {{"sorted", 1}, {"axis", 0}}), x);
+    auto y     = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), out);
+    auto y_idx = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), out);
+    auto x_idx = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), out);
+    auto count = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 3}}), out);
+    mm->add_return({y, y_idx, x_idx, count});
+    auto prog = migraphx::parse_onnx("unique_sorted_test.onnx");
+
+    EXPECT(p == prog);
+}
+
+TEST_CASE(unique_unsorted_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+
+    migraphx::shape s_x{migraphx::shape::float_type, {6}};
+    std::vector<float> x_data = {2, 1, 1, 3, 4, 3};
+    auto x                    = mm->add_literal(migraphx::literal(s_x, x_data));
+
+    auto out   = mm->add_instruction(migraphx::make_op("unique", {{"sorted", 0}, {"axis", 0}}), x);
+    auto y     = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), out);
+    auto y_idx = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), out);
+    auto x_idx = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), out);
+    auto count = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 3}}), out);
+    mm->add_return({y, y_idx, x_idx, count});
+    auto prog = migraphx::parse_onnx("unique_unsorted_test.onnx");
+
+    EXPECT(p == prog);
+}
+
 TEST_CASE(unknown_test)
 {
     migraphx::program p;

test/onnx/unique_dynamic_sorted_3D_test.onnx

+	unique_dynamic_sorted_3D_test:Ö

+?
+
X
Yindicesinverse_indicescounts"Unique*
+sorted
 
unique_dynamic_sorted_3D_testZ
+
X
+
+
+
+b
+
Y
+
+
+b
+indices
+
+
+b
+inverse_indices
+
+
+@b
+counts
+
+
+B
\ No newline at end of file

test/onnx/verify_onnx.cpp

 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -2735,67 +2735,6 @@ TEST_CASE(softsign_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
-TEST_CASE(upsample_test)
-{
-    migraphx::program p = migraphx::parse_onnx("upsample_test.onnx");
-
-    std::vector<float> x_data = {1, 2, 3, 4};
-    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
-
-    migraphx::parameter_map pp;
-    pp["X"] = migraphx::argument(sx, x_data.data());
-
-    auto result = p.eval(pp).back();
-    std::vector<float> result_vector;
-    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
-
-    std::vector<float> gold = {1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2,
-                               3, 3, 3, 4, 4, 4, 3, 3, 3, 4, 4, 4};
-    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
-}
-
-TEST_CASE(where_test)
-{
-    migraphx::program p = migraphx::parse_onnx("where_test.onnx");
-    p.compile(migraphx::make_target("ref"));
-
-    migraphx::shape c_shape{migraphx::shape::bool_type, {2}};
-    std::vector<int8_t> c_data = {1, 0};
-
-    migraphx::shape x_shape{migraphx::shape::float_type, {2, 2, 2}};
-    std::vector<float> x_data(8, 1.0f);
-
-    migraphx::shape y_shape{migraphx::shape::float_type, {2, 1, 2, 2}};
-    std::vector<float> y_data(8, 2.0f);
-
-    migraphx::parameter_map pp;
-    pp["c"] = migraphx::argument(c_shape, c_data.data());
-    pp["x"] = migraphx::argument(x_shape, x_data.data());
-    pp["y"] = migraphx::argument(y_shape, y_data.data());
-
-    auto result = p.eval(pp).back();
-    std::vector<float> result_vector;
-    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
-
-    std::vector<float> gold = {1.0f,
-                               2.0f,
-                               1.0f,
-                               2.0f,
-                               1.0f,
-                               2.0f,
-                               1.0f,
-                               2.0f,
-                               1.0f,
-                               2.0f,
-                               1.0f,
-                               2.0f,
-                               1.0f,
-                               2.0f,
-                               1.0f,
-                               2.0f};
-    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
-}
-
 std::vector<float> gen_trilu_test(const migraphx::shape& s, const migraphx::program& p)
 {
     // input data filled with values 1 to nelements
@@ -2921,4 +2860,131 @@ TEST_CASE(tril_row_one_test)
     EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
 }
 
+TEST_CASE(upsample_test)
+{
+    migraphx::program p = migraphx::parse_onnx("upsample_test.onnx");
+
+    std::vector<float> x_data = {1, 2, 3, 4};
+    migraphx::shape sx{migraphx::shape::float_type, {1, 1, 2, 2}};
+
+    migraphx::parameter_map pp;
+    pp["X"] = migraphx::argument(sx, x_data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    std::vector<float> gold = {1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2,
+                               3, 3, 3, 4, 4, 4, 3, 3, 3, 4, 4, 4};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
+TEST_CASE(unique_dynamic_sorted_test)
+{
+    migraphx::program p = migraphx::parse_onnx("unique_dynamic_sorted_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> x{2, 1, 1, 3, 4, 3};
+    std::vector<float> y_gold      = {1, 2, 3, 4};
+    std::vector<size_t> y_idx_gold = {1, 0, 3, 4};
+    std::vector<size_t> x_idx_gold = {1, 0, 0, 2, 3, 2};
+    std::vector<size_t> y_ct_gold  = {2, 1, 2, 1};
+    migraphx::shape s{migraphx::shape::float_type, {x.size()}};
+
+    migraphx::parameter_map pm;
+    pm["X"]     = migraphx::argument(s, x.data());
+    auto result = p.eval(pm);
+
+    std::vector<float> yvec;
+    result[0].visit([&](auto out) { yvec.assign(out.begin(), out.end()); });
+    EXPECT(yvec == y_gold);
+
+    std::vector<size_t> y_idx_vec;
+    result[1].visit([&](auto out) { y_idx_vec.assign(out.begin(), out.end()); });
+    EXPECT(y_idx_vec == y_idx_gold);
+
+    std::vector<size_t> x_idx_vec;
+    result[2].visit([&](auto out) { x_idx_vec.assign(out.begin(), out.end()); });
+    EXPECT(x_idx_vec == x_idx_gold);
+
+    std::vector<size_t> y_ct_vec;
+    result[3].visit([&](auto out) { y_ct_vec.assign(out.begin(), out.end()); });
+    EXPECT(y_ct_vec == y_ct_gold);
+}
+
+TEST_CASE(unique_dynamic_unsorted_test)
+{
+    migraphx::program p = migraphx::parse_onnx("unique_dynamic_unsorted_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    std::vector<float> x{2, 1, 1, 3, 4, 3};
+    std::vector<float> y_gold      = {2, 1, 3, 4};
+    std::vector<size_t> y_idx_gold = {0, 1, 3, 4};
+    std::vector<size_t> x_idx_gold = {0, 1, 1, 2, 3, 2};
+    std::vector<size_t> y_ct_gold  = {1, 2, 2, 1};
+    migraphx::shape s{migraphx::shape::float_type, {x.size()}};
+
+    migraphx::parameter_map pm;
+    pm["X"]     = migraphx::argument(s, x.data());
+    auto result = p.eval(pm);
+
+    std::vector<float> yvec;
+    result[0].visit([&](auto out) { yvec.assign(out.begin(), out.end()); });
+    EXPECT(yvec == y_gold);
+
+    std::vector<size_t> y_idx_vec;
+    result[1].visit([&](auto out) { y_idx_vec.assign(out.begin(), out.end()); });
+    EXPECT(y_idx_vec == y_idx_gold);
+
+    std::vector<size_t> x_idx_vec;
+    result[2].visit([&](auto out) { x_idx_vec.assign(out.begin(), out.end()); });
+    EXPECT(x_idx_vec == x_idx_gold);
+
+    std::vector<size_t> y_ct_vec;
+    result[3].visit([&](auto out) { y_ct_vec.assign(out.begin(), out.end()); });
+    EXPECT(y_ct_vec == y_ct_gold);
+}
+
+TEST_CASE(where_test)
+{
+    migraphx::program p = migraphx::parse_onnx("where_test.onnx");
+    p.compile(migraphx::make_target("ref"));
+
+    migraphx::shape c_shape{migraphx::shape::bool_type, {2}};
+    std::vector<int8_t> c_data = {1, 0};
+
+    migraphx::shape x_shape{migraphx::shape::float_type, {2, 2, 2}};
+    std::vector<float> x_data(8, 1.0f);
+
+    migraphx::shape y_shape{migraphx::shape::float_type, {2, 1, 2, 2}};
+    std::vector<float> y_data(8, 2.0f);
+
+    migraphx::parameter_map pp;
+    pp["c"] = migraphx::argument(c_shape, c_data.data());
+    pp["x"] = migraphx::argument(x_shape, x_data.data());
+    pp["y"] = migraphx::argument(y_shape, y_data.data());
+
+    auto result = p.eval(pp).back();
+    std::vector<float> result_vector;
+    result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
+
+    std::vector<float> gold = {1.0f,
+                               2.0f,
+                               1.0f,
+                               2.0f,
+                               1.0f,
+                               2.0f,
+                               1.0f,
+                               2.0f,
+                               1.0f,
+                               2.0f,
+                               1.0f,
+                               2.0f,
+                               1.0f,
+                               2.0f,
+                               1.0f,
+                               2.0f};
+    EXPECT(migraphx::verify::verify_rms_range(result_vector, gold));
+}
+
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/op_shape_test.cpp

@@ -4166,6 +4166,40 @@ TEST_CASE(test_squeeze_wrong_axis)
     throws_shape(migraphx::make_op("squeeze", {{"axes", {0}}}), s1);
 }
 
+TEST_CASE(test_unique_axis_invalid)
+{
+    migraphx::shape x_shape{migraphx::shape::float_type, {10, 4, 3}};
+    throws_shape(migraphx::make_op("unique", {{"axis", -1}}), x_shape);
+}
+
+TEST_CASE(test_unique_axis_negative)
+{
+    migraphx::shape x_shape{migraphx::shape::float_type, {10, 4, 3}};
+
+    std::vector<migraphx::shape::dynamic_dimension> y_dims{{1, 10}, {4, 4}, {3, 3}};
+    std::vector<migraphx::shape::dynamic_dimension> idx_dims{{1, 10}};
+    std::vector<migraphx::shape> y_dyn_shape{{migraphx::shape::float_type, y_dims},
+                                             {migraphx::shape::int64_type, idx_dims},
+                                             {migraphx::shape::int64_type, idx_dims},
+                                             {migraphx::shape::int64_type, idx_dims}};
+
+    expect_shape(y_dyn_shape, migraphx::make_op("unique", {{"axis", -3}}), x_shape);
+}
+
+TEST_CASE(test_unique_axis_none)
+{
+    migraphx::shape x_shape{migraphx::shape::half_type, {10, 4, 3}};
+
+    std::vector<migraphx::shape::dynamic_dimension> y_dims{{1, 120}};
+    std::vector<migraphx::shape::dynamic_dimension> idx_dims{{1, 120}};
+    std::vector<migraphx::shape> y_dyn_shape{{migraphx::shape::half_type, y_dims},
+                                             {migraphx::shape::int64_type, idx_dims},
+                                             {migraphx::shape::int64_type, idx_dims},
+                                             {migraphx::shape::int64_type, idx_dims}};
+
+    expect_shape(y_dyn_shape, migraphx::make_op("unique"), x_shape);
+}
+
 TEST_CASE(test_unsqueeze)
 {
     migraphx::shape s1{migraphx::shape::float_type, {4, 5, 3}};

test/ref/unique.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <migraphx/instruction.hpp>
+#include <migraphx/literal.hpp>
+#include <migraphx/make_op.hpp>
+#include <migraphx/onnx.hpp>
+#include <migraphx/register_target.hpp>
+#include <migraphx/verify.hpp>
+#include <optional>
+#include <test.hpp>
+
+namespace {
+
+migraphx::program
+create_program(const migraphx::shape& data_shape, int64_t sorted, std::optional<int64_t> axis)
+{
+    migraphx::program p;
+    auto* mm  = p.get_main_module();
+    auto data = mm->add_parameter("X", data_shape);
+    auto op   = axis ? migraphx::make_op("unique", {{"axis", *axis}, {"sorted", sorted}})
+                     : migraphx::make_op("unique", {{"sorted", sorted}});
+
+    auto r = mm->add_instruction(op, data);
+
+    auto r0 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 0}}), r);
+    auto r1 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 1}}), r);
+    auto r2 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 2}}), r);
+    auto r3 = mm->add_instruction(migraphx::make_op("get_tuple_elem", {{"index", 3}}), r);
+    mm->add_return({r0, r1, r2, r3});
+    return p;
+};
+
+template <typename T>
+auto run_program(T& data,
+                 const migraphx::shape& data_shape,
+                 int sorted,
+                 std::optional<int64_t> axis = std::nullopt)
+{
+    auto p = create_program(data_shape, sorted, axis);
+    p.compile(migraphx::make_target("ref"));
+    migraphx::parameter_map pp;
+    pp["X"]   = migraphx::argument(data_shape, data.data());
+    auto rets = p.eval(pp);
+    std::vector<typename std::remove_reference_t<decltype(data)>::value_type> y;
+    rets[0].visit([&](auto v) { y.assign(v.begin(), v.end()); });
+    std::vector<int64_t> y_idx;
+    rets[1].visit([&](auto v) { y_idx.assign(v.begin(), v.end()); });
+    std::vector<int64_t> x_rev_idx;
+    rets[2].visit([&](auto v) { x_rev_idx.assign(v.begin(), v.end()); });
+    std::vector<int64_t> y_ct;
+    rets[3].visit([&](auto v) { y_ct.assign(v.begin(), v.end()); });
+
+    return std::make_tuple(y, y_idx, x_rev_idx, y_ct);
+}
+} // namespace
+
+// sorted. single entry
+TEST_CASE(unique_sorted_single_entry_test)
+{
+    std::vector<int> data    = {2};
+    int64_t axis             = 0;
+    int64_t sorted           = 1;
+    std::vector<size_t> lens = {1};
+    migraphx::shape data_shape{migraphx::shape::int32_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<int> gold_val = {2};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1};
+    EXPECT(ct == gold_ct);
+}
+
+// unsorted. single entry
+TEST_CASE(unique_unsorted_single_entry_test)
+{
+    std::vector<float> data  = {3.33};
+    int64_t axis             = -1;
+    int64_t sorted           = 0;
+    std::vector<size_t> lens = {1};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {3.33};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1};
+    EXPECT(ct == gold_ct);
+}
+
+// case 2  sorted. all unique input..
+TEST_CASE(unique_sorted_all_unique_test)
+{
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9};
+    int64_t axis             = 0;
+    int64_t sorted           = 1;
+    std::vector<size_t> lens = {5};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {1.9, 2.1, 2.3, 2.4, 2.5};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {4, 0, 1, 2, 3};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {1, 2, 3, 4, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1, 1, 1, 1, 1};
+    EXPECT(ct == gold_ct);
+}
+
+// case 3  unsorted. all unique input
+TEST_CASE(unique_unsorted_all_unique_test)
+{
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9};
+    int64_t axis             = 0;
+    int64_t sorted           = 0;
+    std::vector<size_t> lens = {5};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {2.1, 2.3, 2.4, 2.5, 1.9};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 1, 2, 3, 4};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 1, 2, 3, 4};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {1, 1, 1, 1, 1};
+    EXPECT(ct == gold_ct);
+}
+
+// case 4  sorted (with dup entries)
+TEST_CASE(unique_sorted_dupes_test)
+{
+    std::vector<double> data = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.5};
+    int64_t axis             = 0;
+    int64_t sorted           = 1;
+    std::vector<size_t> lens = {8};
+    migraphx::shape data_shape{migraphx::shape::double_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<double> gold_val = {1.9, 2.1, 2.3, 2.4, 2.5};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_ct = {1, 1, 2, 1, 3};
+    EXPECT(ct == gold_ct);
+}
+
+// case 5  unsorted (with dup entries)
+TEST_CASE(unique_unsorted_dupes_test)
+{
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.1};
+    int64_t axis             = -1;
+    int64_t sorted           = 0;
+    std::vector<size_t> lens = {8};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {2.1, 2.3, 2.4, 2.5, 1.9};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 1, 2, 3, 4};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 1, 2, 3, 4, 3, 1, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 2, 1, 2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+TEST_CASE(unique_3D_no_axis_test)
+{
+    // sorted 3D (with dup entries). no axis
+    int sorted                  = 1;
+    std::vector<double> data_3d = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.5};
+    std::vector<size_t> lens    = {2, 2, 2}; // 3D data. type double
+    migraphx::shape data_shape{migraphx::shape::double_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data_3d, data_shape, sorted);
+
+    std::vector<double> gold_val = {1.9, 2.1, 2.3, 2.4, 2.5};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_ct = {1, 1, 2, 1, 3};
+    EXPECT(ct == gold_ct);
+}
+
+TEST_CASE(unique_3D_no_axis_unsorted_test)
+//  unsorted 3D (with dup entries). no axis
+{
+    int sorted               = 0;
+    std::vector<float> data  = {2.1, 2.3, 2.4, 2.5, 1.9, 2.5, 2.3, 2.1};
+    std::vector<size_t> lens = {2, 1, 4}; // 3D data. type float
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted);
+
+    std::vector<float> gold_val = {2.1, 2.3, 2.4, 2.5, 1.9};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 1, 2, 3, 4};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 1, 2, 3, 4, 3, 1, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 2, 1, 2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+//  unique integer sub-tensors: sorted (with dup entries)
+TEST_CASE(unique_subtensors_sorted_test)
+{
+    /*
+      input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
+      attribute_sorted = 1
+      attribute_axis = 0
+      output_Y = [[1, 0, 0], [2, 3, 4]]
+      output_indices = [0, 2]
+      output_inverse_indices = [0, 0, 1]
+      output_counts = [2, 1]
+    */
+
+    int axis                  = 0;
+    int sorted                = 1;
+    std::vector<int32_t> data = {1, 0, 0, 1, 0, 0, 2, 3, 4};
+    std::vector<size_t> lens  = {3, 3};
+    migraphx::shape data_shape{migraphx::shape::int32_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<int32_t> gold_val = {1, 0, 0, 2, 3, 4};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 2};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 0, 1};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+//  unique integer sub-tensors: un-sorted (with dup entries)
+TEST_CASE(unique_subtensors_neg_axis_test)
+{
+    /*
+      input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
+      attribute_sorted = 0
+      attribute_axis = 0
+      output_Y = [[1, 0, 0], [2, 3, 4]]
+      output_indices = [0, 2]
+      output_inverse_indices = [0, 0, 1]
+      output_counts = [2, 1]
+    */
+
+    int axis                  = -2; // == 0
+    int sorted                = 0;
+    std::vector<int32_t> data = {1, 0, 0, 1, 0, 0, 2, 3, 4};
+    std::vector<size_t> lens  = {3, 3};
+    migraphx::shape data_shape{migraphx::shape::int32_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<int32_t> gold_val = {1, 0, 0, 2, 3, 4};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0, 2};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 0, 1};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2, 1};
+    EXPECT(ct == gold_ct);
+}
+
+//  unique float sub-tensors: sorted (with dup entries)  axis = 0
+TEST_CASE(unique_subtensors_zero_axis_test)
+{
+    /*
+      input_x = [[[1., 1.], [0., 1.], [2., 1.], [0., 1.]],
+      [[1., 1.], [0., 1.], [2., 1.], [0., 1.]]]
+      attribute_sorted = 1
+      attribute_axis = 0
+    */
+
+    int axis                 = 0;
+    int sorted               = 1;
+    std::vector<float> data  = {1., 1., 0., 1., 2., 1., 0., 1., 1., 1., 0., 1., 2., 1., 0., 1.};
+    std::vector<size_t> lens = {2, 4, 2};
+    migraphx::shape data_shape{migraphx::shape::float_type, lens};
+    const auto& [y, idx, x_rev, ct] = run_program(data, data_shape, sorted, axis);
+
+    std::vector<float> gold_val = {1., 1., 0., 1., 2., 1., 0., 1.};
+    EXPECT(y == gold_val);
+
+    std::vector<int64_t> gold_y_idx = {0};
+    EXPECT(idx == gold_y_idx);
+
+    std::vector<int64_t> gold_x_rev = {0, 0};
+    EXPECT(x_rev == gold_x_rev);
+
+    std::vector<int64_t> gold_ct = {2};
+    EXPECT(ct == gold_ct);
+}