Acosh ref impl (openvinotoolkit#6664)

* minor changes in Op class and add ref impl for acosh

* acosh in new test framework

* add Acosh type test

* add SLT for Acosh

* run more test

* new acosh plugin test

* add visitor test

* fix test utils

* add template test for all supported types in Acosh

* add builder to template tests

* update grn template_plugin test

* update maste to feature branch

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

@@ -0,0 +1,81 @@
+// 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 <vector>
+
+#include "base_reference_test.hpp"
+
+using namespace ngraph;
+
+namespace reference_tests {
+namespace {
+
+struct AcoshParams {
+    Tensor input;
+    Tensor expected;
+};
+
+struct Builder : ParamsBuilder<AcoshParams> {
+    REFERENCE_TESTS_ADD_SET_PARAM(Builder, input);
+    REFERENCE_TESTS_ADD_SET_PARAM(Builder, expected);
+};
+
+class ReferenceAcoshLayerTest : public testing::TestWithParam<AcoshParams>, public CommonReferenceTest {
+public:
+    void SetUp() override {
+        auto params = GetParam();
+        function = CreateFunction(params.input.shape, params.input.type);
+        inputData = {params.input.data};
+        refOutData = {params.expected.data};
+    }
+    static std::string getTestCaseName(const testing::TestParamInfo<AcoshParams>& obj) {
+        auto param = obj.param;
+        std::ostringstream result;
+        result << "shape=" << param.input.shape << "_";
+        result << "type=" << param.input.type;
+        return result.str();
+    }
+
+private:
+    static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
+        const auto in = std::make_shared<op::Parameter>(type, shape);
+        const auto acosh = std::make_shared<op::Acosh>(in);
+        return std::make_shared<Function>(NodeVector {acosh}, ParameterVector {in});
+    }
+};
+
+TEST_P(ReferenceAcoshLayerTest, AcoshWithHardcodedRefs) {
+    Exec();
+}
+
+}  // namespace
+
+INSTANTIATE_TEST_SUITE_P(
+    smoke_Acosh_With_Hardcoded_Refs, ReferenceAcoshLayerTest,
+    ::testing::Values(Builder {}
+                          .input({{8}, element::f16, std::vector<ngraph::float16> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}})
+                          .expected({{8}, element::f16, std::vector<ngraph::float16> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}),
+                      Builder {}
+                          .input({{8}, element::f32, std::vector<float> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}})
+                          .expected({{8}, element::f32, std::vector<float> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}),
+                      Builder {}
+                          .input({{8}, element::i32, std::vector<int32_t> {1, 2, 3, 4, 5, 10, 100, 1000}})
+                          .expected({{8}, element::i32, std::vector<int32_t> {0, 1, 2, 2, 2, 3, 5, 8}}),
+                      Builder {}
+                          .input({{8}, element::i64, std::vector<int64_t> {1, 2, 3, 4, 5, 10, 100, 1000}})
+                          .expected({{8}, element::i64, std::vector<int64_t> {0, 1, 2, 2, 2, 3, 5, 8}}),
+                      Builder {}
+                          .input({{8}, element::u32, std::vector<uint32_t> {1, 2, 3, 4, 5, 10, 100, 1000}})
+                          .expected({{8}, element::u32, std::vector<uint32_t> {0, 1, 2, 2, 2, 3, 5, 8}}),
+                      Builder {}
+                          .input({{8}, element::u64, std::vector<uint64_t> {1, 2, 3, 4, 5, 10, 100, 1000}})
+                          .expected({{8}, element::u64, std::vector<uint64_t> {0, 1, 2, 2, 2, 3, 5, 8}})),
+    ReferenceAcoshLayerTest::getTestCaseName);
+}  // namespace reference_tests

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

@@ -9,6 +9,8 @@
 
 using namespace InferenceEngine;
 
+namespace reference_tests {
+
 CommonReferenceTest::CommonReferenceTest(): targetDevice("TEMPLATE") {
     core = PluginCache::get().ie(targetDevice);
 }
@@ -171,3 +173,5 @@ void CommonReferenceTest::ValidateBlobs(const InferenceEngine::Blob::Ptr& refBlo
         FAIL() << "Comparator for " << precision << " precision isn't supported";
     }
 }
+
+}  // namespace reference_tests

docs/template_plugin/tests/functional/op_reference/base_reference_test.hpp

@@ -5,8 +5,12 @@
 #include <ie_core.hpp>
 #include <ie_ngraph_utils.hpp>
 #include <ngraph/ngraph.hpp>
+#include <ngraph/shape.hpp>
+#include <ngraph/type/element_type.hpp>
 #include <shared_test_classes/base/layer_test_utils.hpp>
 
+namespace reference_tests {
+
 class CommonReferenceTest {
 public:
     CommonReferenceTest();
@@ -51,3 +55,55 @@ InferenceEngine::Blob::Ptr CreateBlob(const ngraph::element::Type& element_type,
     return blob;
 }
 
+///
+/// Class which should help to build data for single input
+///
+struct Tensor {
+    Tensor() = default;
+
+    Tensor(const ngraph::Shape& shape, ngraph::element::Type type, const InferenceEngine::Blob::Ptr& data): shape {shape}, type {type}, data {data} {}
+
+    template <typename T>
+    Tensor(const ngraph::Shape& shape, ngraph::element::Type type, const std::vector<T>& data_elements)
+        : Tensor {shape, type, CreateBlob(type, data_elements)} {}
+
+    ngraph::Shape shape;
+    ngraph::element::Type type;
+    InferenceEngine::Blob::Ptr data;
+};
+
+///
+/// Class which should helps build test parameters.
+///
+/// e.g.:
+/// struct Params {
+///     Tensor i,o;
+///     int mul;
+/// };
+/// struct TestParamsBuilder : ParamsBuilder<Params>
+///     REFERENCE_TESTS_ADD_SET_PARAM(TestParamsBuilder, i);
+///     REFERENCE_TESTS_ADD_SET_PARAM(TestParamsBuilder, o);
+///     REFERENCE_TESTS_ADD_SET_PARAM(TestParamsBuilder, mul);
+/// };
+///
+/// const Params p = TestParamsBuilder{}
+///                  .i(Tensor{{0}, i32, {1}})
+///                  .o(Tensor{{0}, i32, {1}})
+///                  .mul(10);
+template <typename Params>
+class ParamsBuilder {
+protected:
+    Params params;
+
+public:
+    operator Params() const {
+        return params;
+    }
+};
+#define REFERENCE_TESTS_ADD_SET_PARAM(builder_type, param_to_set) \
+    builder_type& param_to_set(decltype(params.param_to_set) t) { \
+        params.param_to_set = std::move(t);                       \
+        return *this;                                             \
+    }
+
+}  // namespace reference_tests

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

@@ -12,6 +12,7 @@
 
 #include "base_reference_test.hpp"
 
+using namespace reference_tests;
 using namespace ngraph;
 using namespace InferenceEngine;
 

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

@@ -12,21 +12,22 @@
 
 #include "base_reference_test.hpp"
 
+using namespace reference_tests;
 using namespace ngraph;
 using namespace InferenceEngine;
 
 namespace {
 struct GrnParams {
     template <class IT>
-    GrnParams(const float bias, const ngraph::PartialShape& shape, const ngraph::element::Type& iType, const std::vector<IT>& iValues,
+    GrnParams(const float bias, const PartialShape& shape, const element::Type& iType, const std::vector<IT>& iValues,
               const std::vector<IT>& oValues)
         : bias(bias), pshape(shape), inType(iType), outType(iType), inputData(CreateBlob(iType, iValues)), refData(CreateBlob(iType, oValues)) {}
     float bias;
-    ngraph::PartialShape pshape;
-    ngraph::element::Type inType;
-    ngraph::element::Type outType;
-    InferenceEngine::Blob::Ptr inputData;
-    InferenceEngine::Blob::Ptr refData;
+    PartialShape pshape;
+    element::Type inType;
+    element::Type outType;
+    Blob::Ptr inputData;
+    Blob::Ptr refData;
 };
 
 class ReferenceGrnLayerTest : public testing::TestWithParam<GrnParams>, public CommonReferenceTest {
@@ -60,39 +61,39 @@ TEST_P(ReferenceGrnLayerTest, CompareWithHardcodedRefs) {
 }
 
 template <element::Type_t IN_ET>
-std::vector<GrnParams> generateGrnParams(const ngraph::element::Type& type) {
+std::vector<GrnParams> generateGrnParams(const element::Type& type) {
     using T = typename element_type_traits<IN_ET>::value_type;
     std::vector<GrnParams> grnParams {
         // bias 1e-6 // 2D // 3D // 4D
-        GrnParams(1e-6, ngraph::PartialShape {3, 4}, type, std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
+        GrnParams(1e-6, PartialShape {3, 4}, type, std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
                   std::vector<T> {0.182574, 0.365148, 0.547723, 0.730297, 0.379049, 0.454859, 0.530669, 0.606478, 0.426162, 0.473514, 0.520865, 0.568217}),
-        GrnParams(1e-6, ngraph::PartialShape {2, 3, 4}, type,
+        GrnParams(1e-6, PartialShape {2, 3, 4}, type,
                   std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24},
                   std::vector<T> {0.0966737, 0.169031, 0.224231, 0.267261, 0.483368, 0.507093, 0.523205, 0.534522, 0.870063, 0.845154, 0.822179, 0.801784,
                                   0.433574,  0.441836, 0.449215, 0.455842, 0.566982, 0.568075, 0.569005, 0.569803, 0.700389, 0.694314, 0.688796, 0.683763}),
-        GrnParams(1e-6, ngraph::PartialShape {1, 2, 3, 4}, type,
+        GrnParams(1e-6, PartialShape {1, 2, 3, 4}, type,
                   std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24},
                   std::vector<T> {0.0766965, 0.141421, 0.196116, 0.242536, 0.282166, 0.316228, 0.345705, 0.371391, 0.393919, 0.413803, 0.431455, 0.447214,
                                   0.997055,  0.989949, 0.980581, 0.970143, 0.959365, 0.948683, 0.938343, 0.928477, 0.919145, 0.910366, 0.902134, 0.894427}),
-        GrnParams(1e-6, ngraph::PartialShape {2, 2, 3, 4}, type,
+        GrnParams(1e-6, PartialShape {2, 2, 3, 4}, type,
                   std::vector<T> {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
                                   25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48},
                   std::vector<T> {0.0766965, 0.141421, 0.196116, 0.242536, 0.282166, 0.316228, 0.345705, 0.371391, 0.393919, 0.413803, 0.431455, 0.447214,
                                   0.997055,  0.989949, 0.980581, 0.970143, 0.959365, 0.948683, 0.938343, 0.928477, 0.919145, 0.910366, 0.902134, 0.894427,
                                   0.559857,  0.564684, 0.56921,  0.573462, 0.577465, 0.581238, 0.584802, 0.588172, 0.591364, 0.594391, 0.597266, 0.6,
                                   0.828589,  0.825307, 0.822192, 0.819232, 0.816416, 0.813733, 0.811176, 0.808736, 0.806405, 0.804176, 0.802043, 0.8}),
         // bias 100.25 // 2D // 3D // 4D
-        GrnParams(100.25, ngraph::PartialShape {3, 4}, type, std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
+        GrnParams(100.25, PartialShape {3, 4}, type, std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
                   std::vector<T> {0.0876216, 0.175243, 0.262865, 0.350486, 0.301923, 0.362308, 0.422693, 0.483077, 0.385076, 0.427863, 0.470649, 0.513435}),
-        GrnParams(100.25, ngraph::PartialShape {2, 3, 4}, type,
+        GrnParams(100.25, PartialShape {2, 3, 4}, type,
                   std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24},
                   std::vector<T> {0.0694629, 0.129032, 0.179525, 0.222137, 0.347314, 0.387097, 0.418891, 0.444273, 0.625166, 0.645161, 0.658258, 0.66641,
                                   0.41125,   0.421303, 0.430287, 0.438356, 0.537789, 0.541675, 0.54503,  0.547945, 0.664327, 0.662047, 0.659774, 0.657534}),
-        GrnParams(100.25, ngraph::PartialShape {1, 2, 3, 4}, type,
+        GrnParams(100.25, PartialShape {1, 2, 3, 4}, type,
                   std::vector<T> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24},
                   std::vector<T> {0.0608299, 0.115422, 0.164091, 0.207321, 0.245662, 0.279675, 0.309889, 0.336786, 0.360795, 0.38229,  0.401596, 0.418994,
                                   0.790789,  0.807954, 0.820457, 0.829283, 0.835252, 0.839026, 0.841128, 0.841965, 0.841854, 0.841037, 0.839701, 0.837989f}),
-        GrnParams(100.25, ngraph::PartialShape {2, 2, 3, 4}, type,
+        GrnParams(100.25, PartialShape {2, 2, 3, 4}, type,
                   std::vector<T> {1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
                                   25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48},
                   std::vector<T> {0.0608299, 0.115422, 0.164091, 0.207321, 0.245662, 0.279675, 0.309889, 0.336786, 0.360795, 0.38229,  0.401596, 0.418994,
@@ -103,9 +104,9 @@ std::vector<GrnParams> generateGrnParams(const ngraph::element::Type& type) {
 }
 
 std::vector<GrnParams> generateGrnCombinedParams() {
-    const std::vector<std::vector<GrnParams>> grnTypeParams {generateGrnParams<element::Type_t::bf16>(ngraph::element::bf16),
-                                                             generateGrnParams<element::Type_t::f16>(ngraph::element::f16),
-                                                             generateGrnParams<element::Type_t::f32>(ngraph::element::f32)};
+    const std::vector<std::vector<GrnParams>> grnTypeParams {generateGrnParams<element::Type_t::bf16>(element::bf16),
+                                                             generateGrnParams<element::Type_t::f16>(element::f16),
+                                                             generateGrnParams<element::Type_t::f32>(element::f32)};
     std::vector<GrnParams> combinedParams;
     std::for_each(grnTypeParams.begin(), grnTypeParams.end(), [&](std::vector<GrnParams> params) {
         combinedParams.insert(combinedParams.end(), params.begin(), params.end());

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

@@ -12,6 +12,7 @@
 
 #include "base_reference_test.hpp"
 
+using namespace reference_tests;
 using namespace ngraph;
 using namespace InferenceEngine;
 
@@ -33,12 +34,12 @@ struct SelectParams {
     element::Type data_type;
     op::AutoBroadcastSpec broadcast;
     PartialShape select_input_pshape;
-    InferenceEngine::Blob::Ptr select_input;
+    Blob::Ptr select_input;
     PartialShape if_input_pshape;
-    InferenceEngine::Blob::Ptr if_input;
+    Blob::Ptr if_input;
     PartialShape else_input_pshape;
-    InferenceEngine::Blob::Ptr else_input;
-    InferenceEngine::Blob::Ptr expected_output;
+    Blob::Ptr else_input;
+    Blob::Ptr expected_output;
 };
 
 class ReferenceSelectLayerTest : public testing::TestWithParam<SelectParams>, public CommonReferenceTest {

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

@@ -12,19 +12,20 @@
 
 #include "base_reference_test.hpp"
 
+using namespace reference_tests;
 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,
+    SignParams(const PartialShape& shape, const element::Type& iType, const 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;
+    PartialShape pshape;
+    element::Type inType;
+    element::Type outType;
+    Blob::Ptr inputData;
+    Blob::Ptr refData;
 };
 
 class ReferenceSignLayerTest : public testing::TestWithParam<SignParams>, public CommonReferenceTest {
@@ -59,22 +60,22 @@ TEST_P(ReferenceSignLayerTest, CompareWithHardcodedRefs) {
 INSTANTIATE_TEST_SUITE_P(
     smoke_Sign_With_Hardcoded_Refs, ReferenceSignLayerTest,
     ::testing::Values(
-        SignParams(ngraph::PartialShape {6}, ngraph::element::f32, ngraph::element::f32,
+        SignParams(PartialShape {6}, element::f32, 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,
+        SignParams(PartialShape {6}, element::f16, 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,
+        SignParams(PartialShape {6}, element::u64, 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,
+        SignParams(PartialShape {6}, element::u32, 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,
+        SignParams(PartialShape {6}, element::i32, 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,
+        SignParams(PartialShape {6}, element::i64, 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/inference_engine/serialization/single_layer/activation.cpp

@@ -36,6 +36,7 @@ const std::map<ActivationTypes, std::vector<std::vector<float>>> activationTypes
         {Clamp,                 {{-2.0f, 2.0f}}},
         {Negative,              {}},
         {Acos,                  {}},
+        {Acosh,                 {}},
         {Asin,                  {}},
         {Asinh,                  {}},
         {Atan,                  {}},

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

@@ -37,6 +37,7 @@ const std::map<ActivationTypes, std::vector<std::vector<float>>> activationTypes
         {Clamp,                 {{-2.0f, 2.0f}}},
         {Negative,              {}},
         {Acos,                  {}},
+        {Acosh,                  {}},
         {Asin,                  {}},
         {Asinh,                 {}},
         {Atan,                  {}},
@@ -66,6 +67,7 @@ const std::map<ActivationTypes, std::vector<std::vector<float>>> activationTypes
 
 // List of operations that should be tested also with integer precision
 const std::map<ActivationTypes, std::vector<std::vector<float>>> intActivationTypes = {
+        {Acosh,                 {}},
         {Asinh,                 {}},
         {Atan,                  {}},
         {Negative,              {}},

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

@@ -34,6 +34,7 @@ const std::map<ActivationTypes, std::vector<std::vector<float>>> activationTypes
         {Clamp,                 {{-2.0f, 2.0f}}},
         {Negative,              {}},
         {Acos,                  {}},
+        {Acosh,                 {}},
         {Asin,                  {}},
         {Asinh,                  {}},
         {Atan,                  {}},

inference-engine/tests/functional/shared_test_classes/include/shared_test_classes/single_layer/activation.hpp

@@ -39,6 +39,7 @@ static std::map<ngraph::helpers::ActivationTypes, std::string> activationNames =
         {ngraph::helpers::ActivationTypes::Clamp,                 "Clamp"},
         {ngraph::helpers::ActivationTypes::Negative,              "Negative"},
         {ngraph::helpers::ActivationTypes::Acos,                  "Acos"},
+        {ngraph::helpers::ActivationTypes::Acosh,                 "Acosh"},
         {ngraph::helpers::ActivationTypes::Asin,                  "Asin"},
         {ngraph::helpers::ActivationTypes::Asinh,                 "Asinh"},
         {ngraph::helpers::ActivationTypes::Atan,                  "Atan"},

inference-engine/tests/functional/shared_test_classes/src/single_layer/activation.cpp

@@ -84,6 +84,12 @@ InferenceEngine::Blob::Ptr ActivationLayerTest::GenerateInput(const InferenceEng
             resolution = 32768;
             break;
         }
+        case ngraph::helpers::ActivationTypes::Acosh: {
+            data_start_from = 1;
+            data_range = 200;
+            resolution = 32768;
+            break;
+        }
         case ngraph::helpers::ActivationTypes::Ceiling: {
             data_start_from = -1000;
             data_range = 2000;