Revise sign (#6581)

* update docs

* add sign to intActivationTypes

* add RTTI macro

* update backend test

* add type prp test

* add visitor test

* add visitor and type_prop test to CMakeList

* add sign to constants.py

* delete backend tests and create new reference tests

* style fix

* remoove sign backend test from CMakeList

* create reference test for all supported types

* remove boolean type from evaluate method

docs/ops/arithmetic/Sign_1.md

@@ -4,33 +4,30 @@
 
 **Category**: Arithmetic unary operation
 
-**Short description**: *Sign* performs element-wise sign operation with given tensor.
+**Short description**: *Sign* performs element-wise sign operation on a given input tensor.
 
-**Attributes**:
+**Detailed description**: *Sign* performs element-wise sign operation on a given input tensor, based on the following mathematical formula:
-
-    No attributes available.
-
-**Inputs**
-
-* **1**: An tensor of type *T*. **Required.**
-
-**Outputs**
-
-* **1**: The result of element-wise sign operation. A tensor of type *T* with mapped elements of the input tensor to -1 (if it is negative), 0 (if it is zero), or 1 (if it is positive).
-
-**Types**
-
-* *T*: any numeric type.
-
-*Sign* does the following with the input tensor *a*:
 
 \f[
 a_{i} = sign(a_{i})
 \f]
 
-**Examples**
+**Attributes**: *Sign* operation has no attributes.
 
-*Example 1*
+**Inputs**
+
+* **1**: A tensor of type *T* and arbitrary shape. **Required.**
+
+**Outputs**
+
+* **1**: The result of element-wise *Sign* operation. A tensor of type *T* with mapped elements of the input tensor to -1 (if it is negative), 0 (if it is zero), or 1 (if it is positive).
+
+**Types**
+
+* *T*: any numeric type.
+
+
+**Example**
 
 ```xml
 <layer ... type="Sign">

docs/template_plugin/tests/functional/op_reference/sign.cpp

@@ -0,0 +1,80 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+
+#include <ie_core.hpp>
+#include <ie_ngraph_utils.hpp>
+#include <ngraph/ngraph.hpp>
+#include <shared_test_classes/base/layer_test_utils.hpp>
+#include <tuple>
+
+#include "base_reference_test.hpp"
+
+using namespace ngraph;
+using namespace InferenceEngine;
+
+struct SignParams {
+    template <class IT, class OT>
+    SignParams(const ngraph::PartialShape& shape, const ngraph::element::Type& iType, const ngraph::element::Type& oType, const std::vector<IT>& iValues,
+                  const std::vector<OT>& oValues)
+        : pshape(shape), inType(iType), outType(oType), inputData(CreateBlob(iType, iValues)), refData(CreateBlob(oType, oValues)) {}
+    ngraph::PartialShape pshape;
+    ngraph::element::Type inType;
+    ngraph::element::Type outType;
+    InferenceEngine::Blob::Ptr inputData;
+    InferenceEngine::Blob::Ptr refData;
+};
+
+class ReferenceSignLayerTest : public testing::TestWithParam<SignParams>, public CommonReferenceTest {
+public:
+    void SetUp() override {
+        auto params = GetParam();
+        function = CreateFunction(params.pshape, params.inType);
+        inputData = {params.inputData};
+        refOutData = {params.refData};
+    }
+    static std::string getTestCaseName(const testing::TestParamInfo<SignParams>& obj) {
+        auto param = obj.param;
+        std::ostringstream result;
+        result << "shape=" << param.pshape << "_";
+        result << "iType=" << param.inType << "_";
+        result << "oType=" << param.outType;
+        return result.str();
+    }
+
+private:
+    static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type) {
+        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
+        const auto sign = std::make_shared<op::Sign>(in);
+        return std::make_shared<Function>(NodeVector {sign}, ParameterVector {in});
+    }
+};
+
+TEST_P(ReferenceSignLayerTest, CompareWithHardcodedRefs) {
+    Exec();
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    smoke_Sign_With_Hardcoded_Refs, ReferenceSignLayerTest,
+    ::testing::Values(
+        SignParams(ngraph::PartialShape {6}, ngraph::element::f32, ngraph::element::f32,
+                      std::vector<float> {1, -2, 0, -4.8f, 4.8f, -0.0f},
+                      std::vector<float> {1, -1, 0, -1, 1, 0}),
+        SignParams(ngraph::PartialShape {6}, ngraph::element::f16, ngraph::element::f16,
+                      std::vector<float16> {1, -2, 0, -4.8f, 4.8f, -0.0f},
+                      std::vector<float16> {1, -1, 0, -1, 1, 0}),
+        SignParams(ngraph::PartialShape {6}, ngraph::element::u64, ngraph::element::u64,
+                      std::vector<uint64_t> {1, 2, 0, 4, 4, 0},
+                      std::vector<uint64_t> {1, 1, 0, 1, 1, 0}),
+        SignParams(ngraph::PartialShape {6}, ngraph::element::u32, ngraph::element::u32,
+                      std::vector<uint32_t> {1, 2, 0, 4, 4, 0},
+                      std::vector<uint32_t> {1, 1, 0, 1, 1, 0}),
+        SignParams(ngraph::PartialShape {6}, ngraph::element::i32, ngraph::element::i32,
+                      std::vector<int32_t> {1, -2, 0, -4, 4, -0},
+                      std::vector<int32_t> {1, -1, 0, -1, 1, 0}),
+        SignParams(ngraph::PartialShape {6}, ngraph::element::i64, ngraph::element::i64,
+                      std::vector<int64_t> {1, -2, 0, -4, 4, -0},
+                      std::vector<int64_t> {1, -1, 0, -1, 1, 0})),
+    ReferenceSignLayerTest::getTestCaseName);

inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/activation.cpp

@@ -71,6 +71,7 @@ const std::map<ActivationTypes, std::vector<std::vector<float>>> intActivationTy
         {Negative,              {}},
         {Ceiling,               {}},
         {Cos,                   {}},
+        {Sign,                  {}},
         {Sinh,                  {}},
         {Sqrt,                  {}},
         {Tanh,                  {}},

inference-engine/tests/ie_test_utils/functional_test_utils/layer_tests_summary/utils/constants.py

@@ -97,6 +97,7 @@ VERIFIED_OP_REFERENCES = [
     'ShapeOf-3',
     'ShuffleChannels-1',
     'Sigmoid-1',
+    'Sign-1',
     'Sin-1',
     'Sinh-1'
     'SoftPlus-4',

ngraph/core/include/ngraph/op/sign.hpp

@@ -17,8 +17,8 @@ namespace ngraph
             class NGRAPH_API Sign : public util::UnaryElementwiseArithmetic
             {
             public:
-                static constexpr NodeTypeInfo type_info{"Sign", 0};
+                NGRAPH_RTTI_DECLARATION;
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
+
                 Sign() = default;
                 /// \brief Constructs an elementwise sign operation.
                 ///

ngraph/core/src/op/sign.cpp

@@ -12,7 +12,9 @@ using namespace ngraph;
 #include "ngraph/runtime/host_tensor.hpp"
 #include "ngraph/runtime/reference/sign.hpp"
 
-constexpr NodeTypeInfo op::Sign::type_info;
+#include "ngraph/validation_util.hpp"
+
+NGRAPH_RTTI_DEFINITION(op::v0::Sign, "Sign", 0, util::UnaryElementwiseArithmetic);
 
 op::Sign::Sign(const Output<Node>& arg)
     : UnaryElementwiseArithmetic(arg)
@@ -50,7 +52,6 @@ namespace signop
 
         switch (arg0->get_element_type())
         {
-            NGRAPH_TYPE_CASE(evaluate_sign, boolean, arg0, out, count);
             NGRAPH_TYPE_CASE(evaluate_sign, i32, arg0, out, count);
             NGRAPH_TYPE_CASE(evaluate_sign, i64, arg0, out, count);
             NGRAPH_TYPE_CASE(evaluate_sign, u32, arg0, out, count);
@@ -66,6 +67,7 @@ namespace signop
 bool op::Sign::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
 {
     NGRAPH_OP_SCOPE(v0_Sign_evaluate);
+    NGRAPH_CHECK(validate_host_tensor_vector(outputs, 1) && validate_host_tensor_vector(inputs, 1));
     return signop::evaluate_sign(inputs[0], outputs[0], shape_size(get_output_shape(0)));
 }
 

ngraph/test/CMakeLists.txt

@@ -156,7 +156,7 @@ set(SRC
     type_prop/lstm_sequence.cpp
     type_prop/loop.cpp
     type_prop/matmul.cpp
-    type_prop/matrix_nms.cpp    
+    type_prop/matrix_nms.cpp
     type_prop/maximum.cpp
     type_prop/max_pool.cpp
     type_prop/minimum.cpp
@@ -207,6 +207,7 @@ set(SRC
     type_prop/selu.cpp
     type_prop/shape_of.cpp
     type_prop/shuffle_channels.cpp
+    type_prop/sign.cpp
     type_prop/sin.cpp
     type_prop/sinh.cpp
     type_prop/softmax.cpp
@@ -302,6 +303,7 @@ set(SRC
     visitors/op/space_to_depth.cpp
     visitors/op/selu.cpp
     visitors/op/shuffle_channels.cpp
+    visitors/op/sign.cpp
     visitors/op/sinh.cpp
     visitors/op/softmax.cpp
     visitors/op/softplus.cpp
@@ -490,7 +492,6 @@ set(MULTI_TEST_SRC
     backend/shape_of.in.cpp
     backend/shuffle_channels.in.cpp
     backend/sigmoid.in.cpp
-    backend/sign.in.cpp
     backend/sin.in.cpp
     backend/sinh.in.cpp
     backend/softmax.in.cpp

ngraph/test/backend/sign.in.cpp

@@ -1,54 +0,0 @@
-// Copyright (C) 2018-2021 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-#include <algorithm>
-#include <cinttypes>
-#include <cmath>
-#include <cstdlib>
-#include <random>
-#include <string>
-
-// clang-format off
-#ifdef ${BACKEND_NAME}_FLOAT_TOLERANCE_BITS
-#define DEFAULT_FLOAT_TOLERANCE_BITS ${BACKEND_NAME}_FLOAT_TOLERANCE_BITS
-#endif
-
-#ifdef ${BACKEND_NAME}_DOUBLE_TOLERANCE_BITS
-#define DEFAULT_DOUBLE_TOLERANCE_BITS ${BACKEND_NAME}_DOUBLE_TOLERANCE_BITS
-#endif
-// clang-format on
-
-#include "gtest/gtest.h"
-#include "runtime/backend.hpp"
-#include "ngraph/runtime/tensor.hpp"
-#include "ngraph/ngraph.hpp"
-#include "util/all_close.hpp"
-#include "util/all_close_f.hpp"
-#include "util/ndarray.hpp"
-#include "util/test_control.hpp"
-#include "util/test_tools.hpp"
-
-using namespace std;
-using namespace ngraph;
-
-static string s_manifest = "${MANIFEST}";
-
-NGRAPH_TEST(${BACKEND_NAME}, sign)
-{
-    Shape shape{2, 3};
-    auto A = make_shared<op::Parameter>(element::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Sign>(A), ParameterVector{A});
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape);
-    copy_data(a, vector<float>{1, -2, 0, -4.8f, 4.8f, -0.0f});
-    auto result = backend->create_tensor(element::f32, shape);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f(
-        (vector<float>{1, -1, 0, -1, 1, 0}), read_vector<float>(result), MIN_FLOAT_TOLERANCE_BITS));
-}

ngraph/test/type_prop/sign.cpp

@@ -0,0 +1,9 @@
+// Copyright (C) 2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "unary_ops.hpp"
+
+using Type = ::testing::Types<ngraph::op::Sign>;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_sign, UnaryOperator, Type);

ngraph/test/visitors/op/sign.cpp

@@ -0,0 +1,11 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "unary_ops.hpp"
+using Type = ::testing::Types<UnaryOperatorType<ngraph::op::v0::Sign, element::f32>>;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(visitor_without_attribute,
+                               UnaryOperatorVisitor,
+                               Type,
+                               UnaryOperatorTypeName);