IntenseWebs/openvino
3
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Migrate ngraph backend test of arithmetic2 operations (#7500)

Browse Source 
* Remove fp16 of Convert layer test from skip_tests.config.cpp as it works now

* update repo

* add sin asin template plugin reference test

* add cos template plugin reference test and remove asin/sin/cos ngraph backend test

* update CMakeList.txt

* add template plugin reference test for asinh, cosh, sinh, tanh

* remove ngraph backend test for asinh, cosh, sinh, tanh

* update CMakeList.txt

* add ngraph type prop test for tanh

* add ngraph visitor api test for asin, sin

* add atanh type in activation SLT

* remove boolean from sin/cos/tan/asin/sinh/cosh evaluate
This commit is contained in:
Wilson Seok authored and GitHub committed 2021-09-27 05:23:52 +03:00
1 parent ef028a567e
commit 8262aed30c
31 files changed
+763 -470
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

ngraph/core/src/op/asin.cpp
-2
View File
@@ -47,7 +47,6 @@ bool evaluate_asin(const HostTensorPtr& arg0, const HostTensorPtr& out, const si
out->set_unary(arg0);
switch (arg0->get_element_type()) {
NGRAPH_TYPE_CASE(evaluate_asin, boolean, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_asin, i32, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_asin, i64, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_asin, u32, arg0, out, count);
@@ -70,7 +69,6 @@ bool op::Asin::evaluate(const HostTensorVector& outputs, const HostTensorVector&
bool op::Asin::has_evaluate() const {
NGRAPH_OP_SCOPE(v1_Asin_has_evaluate);
switch (get_input_element_type(0)) {
case ngraph::element::boolean:
case ngraph::element::i32:
case ngraph::element::i64:
case ngraph::element::u32:
ngraph/core/src/op/cos.cpp
-2
View File
@@ -42,7 +42,6 @@ bool evaluate_cos(const HostTensorPtr& arg0, const HostTensorPtr& out, const siz
out->set_unary(arg0);
switch (arg0->get_element_type()) {
NGRAPH_TYPE_CASE(evaluate_cos, boolean, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_cos, i32, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_cos, i64, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_cos, u32, arg0, out, count);
@@ -66,7 +65,6 @@ bool op::Cos::evaluate(const HostTensorVector& outputs, const HostTensorVector&
bool op::Cos::has_evaluate() const {
NGRAPH_OP_SCOPE(v0_Cos_has_evaluate);
switch (get_input_element_type(0)) {
case ngraph::element::boolean:
case ngraph::element::i32:
case ngraph::element::i64:
case ngraph::element::u32:
ngraph/core/src/op/cosh.cpp
-2
View File
@@ -42,7 +42,6 @@ bool evaluate_cosh(const HostTensorPtr& arg0, const HostTensorPtr& out, const si
out->set_unary(arg0);
switch (arg0->get_element_type()) {
NGRAPH_TYPE_CASE(evaluate_cosh, boolean, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_cosh, i32, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_cosh, i64, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_cosh, u32, arg0, out, count);
@@ -66,7 +65,6 @@ bool op::Cosh::evaluate(const HostTensorVector& outputs, const HostTensorVector&
bool op::Cosh::has_evaluate() const {
NGRAPH_OP_SCOPE(v0_Cosh_has_evaluate);
switch (get_input_element_type(0)) {
case ngraph::element::boolean:
case ngraph::element::i32:
case ngraph::element::i64:
case ngraph::element::u32:
ngraph/core/src/op/sin.cpp
-2
View File
@@ -43,7 +43,6 @@ bool evaluate_sin(const HostTensorPtr& arg0, const HostTensorPtr& out, const siz
out->set_unary(arg0);
switch (arg0->get_element_type()) {
NGRAPH_TYPE_CASE(evaluate_sin, boolean, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_sin, i32, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_sin, i64, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_sin, u32, arg0, out, count);
@@ -66,7 +65,6 @@ bool op::Sin::evaluate(const HostTensorVector& outputs, const HostTensorVector&
bool op::Sin::has_evaluate() const {
NGRAPH_OP_SCOPE(v0_Sin_has_evaluate);
switch (get_input_element_type(0)) {
case ngraph::element::boolean:
case ngraph::element::i32:
case ngraph::element::i64:
case ngraph::element::u32:
ngraph/core/src/op/sinh.cpp
-2
View File
@@ -42,7 +42,6 @@ bool evaluate_sinh(const HostTensorPtr& arg0, const HostTensorPtr& out, const si
out->set_unary(arg0);
switch (arg0->get_element_type()) {
NGRAPH_TYPE_CASE(evaluate_sinh, boolean, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_sinh, i32, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_sinh, i64, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_sinh, u32, arg0, out, count);
@@ -66,7 +65,6 @@ bool op::Sinh::evaluate(const HostTensorVector& outputs, const HostTensorVector&
bool op::Sinh::has_evaluate() const {
NGRAPH_OP_SCOPE(v0_Sinh_has_evaluate);
switch (get_input_element_type(0)) {
case ngraph::element::boolean:
case ngraph::element::i32:
case ngraph::element::i64:
case ngraph::element::u32:
ngraph/core/src/op/tan.cpp
-2
View File
@@ -44,7 +44,6 @@ bool evaluate_tan(const HostTensorPtr& arg0, const HostTensorPtr& out, const siz
out->set_unary(arg0);
switch (arg0->get_element_type()) {
NGRAPH_TYPE_CASE(evaluate_tan, boolean, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_tan, i32, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_tan, i64, arg0, out, count);
NGRAPH_TYPE_CASE(evaluate_tan, u32, arg0, out, count);
@@ -67,7 +66,6 @@ bool op::Tan::evaluate(const HostTensorVector& outputs, const HostTensorVector&
bool op::Tan::has_evaluate() const {
NGRAPH_OP_SCOPE(v0_Tan_has_evaluate);
switch (get_input_element_type(0)) {
case ngraph::element::boolean:
case ngraph::element::i32:
case ngraph::element::i64:
case ngraph::element::u32:
ngraph/test/CMakeLists.txt
+3 -7
View File
@@ -234,6 +234,7 @@ set(SRC
type_prop/squeeze.cpp
type_prop/swish.cpp
type_prop/tan.cpp
type_prop/tanh.cpp
type_prop/ti.cpp
type_prop/tile.cpp
type_prop/top_k.cpp
@@ -250,6 +251,7 @@ set(SRC
visitors/op/adaptive_avg_pool.cpp
visitors/op/adaptive_max_pool.cpp
visitors/op/add.cpp
visitors/op/asin.cpp
visitors/op/asinh.cpp
visitors/op/atan.cpp
visitors/op/atanh.cpp
@@ -345,6 +347,7 @@ set(SRC
visitors/op/selu.cpp
visitors/op/shuffle_channels.cpp
visitors/op/sign.cpp
visitors/op/sin.cpp
visitors/op/sinh.cpp
visitors/op/slice.cpp
visitors/op/softmax.cpp
@@ -418,8 +421,6 @@ set(MULTI_TEST_SRC
backend/add.in.cpp
backend/aliased_output.in.cpp
backend/api.in.cpp
backend/asin.in.cpp
backend/asinh.in.cpp
backend/auto_broadcast.in.cpp
backend/avg_pool.in.cpp
backend/batch_norm.in.cpp
@@ -434,8 +435,6 @@ set(MULTI_TEST_SRC
backend/convolution.in.cpp
backend/binary_convolution.in.cpp
backend/clamp.in.cpp
backend/cos.in.cpp
backend/cosh.in.cpp
backend/ctc_greedy_decoder.in.cpp
backend/ctc_greedy_decoder_seq_len.in.cpp
backend/deformable_psroi_pooling.in.cpp
@@ -510,8 +509,6 @@ set(MULTI_TEST_SRC
backend/shape_of.in.cpp
backend/shuffle_channels.in.cpp
backend/sigmoid.in.cpp
backend/sin.in.cpp
backend/sinh.in.cpp
backend/softmax.in.cpp
backend/softplus.in.cpp
backend/space_to_batch.in.cpp
@@ -521,7 +518,6 @@ set(MULTI_TEST_SRC
backend/squeeze.in.cpp
backend/subtract.in.cpp
backend/swish.in.cpp
backend/tanh.in.cpp
backend/tile.in.cpp
backend/topk.in.cpp
backend/transpose.in.cpp
ngraph/test/backend/asin.in.cpp
-54
View File
@@ -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 "ngraph/ngraph.hpp"
#include "util/engine/test_engines.hpp"
#include "util/test_case.hpp"
#include "util/test_control.hpp"
using namespace std;
using namespace ngraph;
static string s_manifest = "${MANIFEST}";
using TestEngine = test::ENGINE_CLASS_NAME(${BACKEND_NAME});
NGRAPH_TEST(${BACKEND_NAME}, asin) {
Shape shape{11};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Asin>(A), ParameterVector{A});
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>({-1.f, -0.75f, -0.5f, -0.25f, -0.125f, 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f});
test_case.add_expected_output<float>(shape,
{-1.57079633f,
-0.84806208f,
-0.52359878f,
-0.25268026f,
-0.12532783f,
0.00000000f,
0.12532783f,
0.25268026f,
0.52359878f,
0.84806208f,
1.57079633f});
test_case.run();
}
ngraph/test/backend/asinh.in.cpp
-63
View File
@@ -1,63 +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 "ngraph/ngraph.hpp"
#include "util/engine/test_engines.hpp"
#include "util/test_case.hpp"
#include "util/test_control.hpp"
using namespace std;
using namespace ngraph;
static string s_manifest = "${MANIFEST}";
using TestEngine = test::ENGINE_CLASS_NAME(${BACKEND_NAME});
NGRAPH_TEST(${BACKEND_NAME}, asinh) {
Shape shape{11};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Asinh>(A), ParameterVector{A});
vector<float> input{0.f, 1.f, -1.f, 2.f, -2.f, 3.f, -3.f, 4.f, 5.f, 10.f, 100.f};
vector<float> expected;
for (float f : input) {
expected.push_back(std::asinh(f));
}
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>(input);
test_case.add_expected_output<float>(shape, expected);
test_case.run();
}
NGRAPH_TEST(${BACKEND_NAME}, asinh_i32) {
Shape shape{11};
auto A = make_shared<op::Parameter>(element::i32, shape);
auto f = make_shared<Function>(make_shared<op::Asinh>(A), ParameterVector{A});
vector<int> input{-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
vector<int> expected{-2, -2, -2, -1, -1, 0, 1, 1, 2, 2, 2};
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<int>(input);
test_case.add_expected_output<int>(shape, expected);
test_case.run();
}
ngraph/test/backend/cos.in.cpp
-48
View File
@@ -1,48 +0,0 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "util/engine/test_engines.hpp"
#include "util/test_case.hpp"
#include "util/test_control.hpp"
using namespace std;
using namespace ngraph;
static string s_manifest = "${MANIFEST}";
using TestEngine = test::ENGINE_CLASS_NAME(${BACKEND_NAME});
NGRAPH_TEST(${BACKEND_NAME}, cos_float) {
Shape shape{11};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Cos>(A), ParameterVector{A});
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>({0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f});
test_case.add_expected_output<float>(shape,
{1.00000000f,
0.96891242f,
0.96891242f,
0.87758256f,
0.87758256f,
0.54030231f,
0.54030231f,
-0.41614684f,
-0.41614684f,
-0.65364362f,
-0.65364362f});
test_case.run();
}
NGRAPH_TEST(${BACKEND_NAME}, cos_int) {
Shape shape{5};
auto A = make_shared<op::Parameter>(element::i32, shape);
auto f = make_shared<Function>(make_shared<op::Cos>(A), ParameterVector{A});
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<int32_t>({1, 2, 3, 4, 5});
test_case.add_expected_output<int32_t>(shape, {1, 0, -1, -1, 0});
test_case.run();
}
ngraph/test/backend/cosh.in.cpp
-43
View File
@@ -1,43 +0,0 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "gtest/gtest.h"
#include "ngraph/ngraph.hpp"
#include "util/engine/test_engines.hpp"
#include "util/test_case.hpp"
#include "util/test_control.hpp"
using namespace std;
using namespace ngraph;
static string s_manifest = "${MANIFEST}";
using TestEngine = test::ENGINE_CLASS_NAME(${BACKEND_NAME});
NGRAPH_TEST(${BACKEND_NAME}, cosh_float) {
Shape shape{6};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Cosh>(A), ParameterVector{A});
vector<float> input{1.0f, 0.0f, -0.0f, -1.0f, 5.0f, -5.0f};
vector<float> expected;
for (float f : input) {
expected.push_back(coshf(f));
}
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>(input);
test_case.add_expected_output<float>(shape, expected);
test_case.run();
}
NGRAPH_TEST(${BACKEND_NAME}, cosh_int) {
Shape shape{5};
auto A = make_shared<op::Parameter>(element::i32, shape);
auto f = make_shared<Function>(make_shared<op::Cosh>(A), ParameterVector{A});
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<int32_t>({1, 5, 2, 3, 3});
test_case.add_expected_output<int32_t>(shape, {2, 74, 4, 10, 10});
test_case.run();
}
ngraph/test/backend/sin.in.cpp
-63
View File
@@ -1,63 +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}, sin) {
Shape shape{11};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Sin>(A), ParameterVector{A});
auto backend = runtime::Backend::create("${BACKEND_NAME}");
// Create some tensors for input/output
auto a = backend->create_tensor(element::f32, shape);
vector<float> input{0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f};
copy_data(a, input);
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>{0.00000000f,
0.24740396f,
-0.24740396f,
0.47942554f,
-0.47942554f,
0.84147098f,
-0.84147098f,
0.90929743f,
-0.90929743f,
-0.75680250f,
0.75680250f},
read_vector<float>(result)));
}
ngraph/test/backend/sinh.in.cpp
-100
View File
@@ -1,100 +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 "ngraph/ngraph.hpp"
#include "util/engine/test_engines.hpp"
#include "util/test_case.hpp"
#include "util/test_control.hpp"
using namespace std;
using namespace ngraph;
static string s_manifest = "${MANIFEST}";
using TestEngine = test::ENGINE_CLASS_NAME(${BACKEND_NAME});
NGRAPH_TEST(${BACKEND_NAME}, sinh) {
Shape shape{8};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Sinh>(A), ParameterVector{A});
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>({-4, -3, -2, -1, 0, 1, 2, 3});
test_case.add_expected_output<float>(
shape,
{sinhf(-4), sinhf(-3), sinhf(-2), sinhf(-1), sinhf(0), sinhf(1), sinhf(2), sinhf(3)});
test_case.run();
}
NGRAPH_TEST(${BACKEND_NAME}, sinh_negative) {
Shape shape{5};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Sinh>(A), ParameterVector{A});
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>({-4, -3, -2, -1, -5});
test_case.add_expected_output<float>(shape, {sinhf(-4), sinhf(-3), sinhf(-2), sinhf(-1), sinhf(-5)});
test_case.run();
}
NGRAPH_TEST(${BACKEND_NAME}, sinh_scalar) {
Shape shape{};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Sinh>(A), ParameterVector{A});
const vector<float> a{13};
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>({a});
test_case.add_expected_output<float>(shape, {sinhf(13)});
test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 2);
}
NGRAPH_TEST(${BACKEND_NAME}, sinh_in_place) {
Shape shape{2};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto T = make_shared<op::Sinh>(A);
auto T2 = make_shared<op::Sinh>(T);
auto f = make_shared<Function>(T2, ParameterVector{A});
const vector<float> a{1, 3};
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<float>({a});
test_case.add_expected_output<float>(shape, {sinhf(sinhf(1)), sinhf(sinhf(3))});
test_case.run(DEFAULT_FLOAT_TOLERANCE_BITS + 2);
}
NGRAPH_TEST(${BACKEND_NAME}, sinh_i32) {
Shape shape{5};
auto A = make_shared<op::Parameter>(element::i32, shape);
;
auto f = make_shared<Function>(make_shared<op::Sinh>(A), ParameterVector{A});
const vector<int32_t> input{2, 1, 0, -1, -2};
const vector<int32_t> expected{4, 1, 0, -1, -4};
auto test_case = test::TestCase<TestEngine>(f);
test_case.add_input<int32_t>({input});
test_case.add_expected_output<int32_t>(shape, {expected});
test_case.run();
}
ngraph/test/backend/tanh.in.cpp
-79
View File
@@ -1,79 +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}, tanh_f32) {
Shape shape{8};
auto A = make_shared<op::Parameter>(element::f32, shape);
auto f = make_shared<Function>(make_shared<op::Tanh>(A), ParameterVector{A});
auto backend = runtime::Backend::create("${BACKEND_NAME}");
// Create some tensors for input/output
auto a = backend->create_tensor(element::f32, shape);
const vector<float> input{2.f, 1.f, 0.5f, 0.f, -0.f, -0.5f, -1.f, -2.f};
const auto expected = [&] {
vector<float> e(input.size(), 0);
std::transform(begin(input), end(input), begin(e), [](float v) {
return std::tanh(v);
});
return e;
}();
copy_data(a, input);
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(expected, read_vector<float>(result)));
}
NGRAPH_TEST(${BACKEND_NAME}, tanh_int32) {
Shape shape{5};
auto A = make_shared<op::Parameter>(element::i32, shape);
auto f = make_shared<Function>(make_shared<op::Tanh>(A), ParameterVector{A});
auto backend = runtime::Backend::create("${BACKEND_NAME}");
// Create some tensors for input/output
auto a = backend->create_tensor(element::i32, shape);
const vector<int32_t> input{2, 1, 0, -1, -2};
const vector<int32_t> expected{1, 1, 0, -1, -1};
copy_data(a, input);
auto result = backend->create_tensor(element::i32, shape);
auto handle = backend->compile(f);
handle->call_with_validate({result}, {a});
EXPECT_EQ(expected, read_vector<int32_t>(result));
}
ngraph/test/type_prop/tanh.cpp
+9
View File
@@ -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::Tanh>;
INSTANTIATE_TYPED_TEST_SUITE_P(type_prop_tanh, UnaryOperator, Type);
ngraph/test/visitors/op/asin.cpp
+8
View File
@@ -0,0 +1,8 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "unary_ops.hpp"
using Type = ::testing::Types<UnaryOperatorType<ngraph::op::Asin, ngraph::element::f32>>;
INSTANTIATE_TYPED_TEST_SUITE_P(visitor_without_attribute, UnaryOperatorVisitor, Type, UnaryOperatorTypeName);
ngraph/test/visitors/op/sin.cpp
+9
View File
@@ -0,0 +1,9 @@
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "unary_ops.hpp"
using Type = ::testing::Types<UnaryOperatorType<ngraph::op::v0::Sin, ngraph::element::f32>>;
INSTANTIATE_TYPED_TEST_SUITE_P(visitor_without_attribute, UnaryOperatorVisitor, Type, UnaryOperatorTypeName);