786 lines
30 KiB
C++
786 lines
30 KiB
C++
//*****************************************************************************
|
|
// Copyright 2017-2020 Intel Corporation
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//*****************************************************************************
|
|
|
|
#include <algorithm>
|
|
#include <cinttypes>
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <numeric>
|
|
#include <random>
|
|
#include <string>
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "ngraph/ngraph.hpp"
|
|
#include "ngraph/runtime/tensor.hpp"
|
|
#include "runtime/backend.hpp"
|
|
#include "util/all_close.hpp"
|
|
#include "util/all_close_f.hpp"
|
|
#include "util/ndarray.hpp"
|
|
#include "util/random.hpp"
|
|
#include "util/test_control.hpp"
|
|
#include "util/test_tools.hpp"
|
|
|
|
static std::mt19937_64 random_generator;
|
|
|
|
NGRAPH_SUPPRESS_DEPRECATED_START
|
|
|
|
using namespace std;
|
|
using namespace ngraph;
|
|
|
|
static string s_manifest = "${MANIFEST}";
|
|
|
|
// Trivial case with no summed axes.
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_trivial)
|
|
{
|
|
Shape shape{2, 2};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape);
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{}), 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, 3, 4});
|
|
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, 2, 3, 4}), read_vector<float>(result)));
|
|
}
|
|
|
|
// Failure has been reported at 5D for some reason
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_trivial_5d)
|
|
{
|
|
Shape shape{2, 2, 2, 2, 2};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape);
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{}), 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1});
|
|
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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}),
|
|
read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_to_scalar)
|
|
{
|
|
Shape shape{2, 2};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape);
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1}), 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, 3, 4});
|
|
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>{10}), read_vector<float>(result)));
|
|
|
|
// For some reason I'm feeling extra paranoid about making sure reduction doesn't clobber the
|
|
// input tensors, so let's do this too.
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{1, 2, 3, 4}), read_vector<float>(a)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_large_1d_to_scalar)
|
|
{
|
|
Shape shape{1000000};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape);
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
random_generator.seed(2);
|
|
vector<float> v_a(1000000, 0);
|
|
double r = 0;
|
|
for (int i = 0; i < 1000000; i++)
|
|
{
|
|
v_a[i] = static_cast<float>(random_generator() % 255);
|
|
r += static_cast<double>(v_a[i]);
|
|
}
|
|
auto a = backend->create_tensor(element::f32, shape);
|
|
copy_data(a, v_a);
|
|
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>{static_cast<float>(r)}, read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_matrix_columns)
|
|
{
|
|
Shape shape_a{3, 2};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{2};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{1, 2, 3, 4, 5, 6});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{9, 12}), read_vector<float>(result)));
|
|
|
|
// For some reason I'm feeling extra paranoid about making sure reduction doesn't clobber the
|
|
// input tensors, so let's do this too.
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{1, 2, 3, 4, 5, 6}), read_vector<float>(a)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_matrix_6d)
|
|
{
|
|
Shape shape_a{2, 6, 4, 5, 7, 3};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{2, 4, 5, 3};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1, 4}), ParameterVector{A});
|
|
|
|
auto backend_wrk = runtime::Backend::create("${BACKEND_NAME}");
|
|
auto backend_ref = runtime::Backend::create("INTERPRETER");
|
|
|
|
// Create some tensors for input/output
|
|
auto a_wrk = backend_wrk->create_tensor(element::f32, shape_a);
|
|
auto a_ref = backend_ref->create_tensor(element::f32, shape_a);
|
|
auto result_wrk = backend_wrk->create_tensor(element::f32, shape_rt);
|
|
auto result_ref = backend_ref->create_tensor(element::f32, shape_rt);
|
|
|
|
vector<float> inp_data(shape_size<const Shape>(shape_a));
|
|
iota(inp_data.begin(), inp_data.end(), 1.f);
|
|
copy_data(a_wrk, inp_data);
|
|
copy_data(a_ref, inp_data);
|
|
|
|
auto handle_wrk = backend_wrk->compile(f);
|
|
auto handle_ref = backend_ref->compile(f);
|
|
handle_wrk->call_with_validate({result_wrk}, {a_wrk});
|
|
handle_ref->call_with_validate({result_ref}, {a_ref});
|
|
|
|
EXPECT_TRUE(test::all_close_f(read_vector<float>(result_ref), read_vector<float>(result_wrk)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_matrix_rows)
|
|
{
|
|
Shape shape_a{3, 2};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{3};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{1, 2, 3, 4, 5, 6});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{3, 7, 11}), read_vector<float>(result)));
|
|
|
|
// For some reason I'm feeling extra paranoid about making sure reduction doesn't clobber the
|
|
// input tensors, so let's do this too.
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{1, 2, 3, 4, 5, 6}), read_vector<float>(a)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_matrix_rows_zero)
|
|
{
|
|
Shape shape_a{3, 0};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{3};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
copy_data(result, vector<float>({3, 3, 3}));
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{0, 0, 0}), read_vector<float>(result)));
|
|
|
|
// For some reason I'm feeling extra paranoid about making sure reduction doesn't clobber the
|
|
// input tensors, so let's do this too.
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{}), read_vector<float>(a)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_matrix_cols_zero)
|
|
{
|
|
// Now the reduction (g(x:float32[2,2],y:float32[]) = reduce(x,y,f,axes={})).
|
|
Shape shape_a{0, 2};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{2};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
copy_data(result, vector<float>({3, 3}));
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{0, 0}), read_vector<float>(result)));
|
|
|
|
// For some reason I'm feeling extra paranoid about making sure reduction doesn't clobber the
|
|
// input tensors, so let's do this too.
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{}), read_vector<float>(a)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_vector_zero)
|
|
{
|
|
Shape shape_a{0};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
copy_data(result, vector<float>({3}));
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{0}), read_vector<float>(result)));
|
|
|
|
// For some reason I'm feeling extra paranoid about making sure reduction doesn't clobber the
|
|
// input tensors, so let's do this too.
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{}), read_vector<float>(a)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_matrix_to_scalar_zero_by_zero)
|
|
{
|
|
Shape shape_a{0, 0};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
copy_data(result, vector<float>({3}));
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{0}), read_vector<float>(result)));
|
|
|
|
// For some reason I'm feeling extra paranoid about making sure reduction doesn't clobber the
|
|
// input tensors, so let's do this too.
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{}), read_vector<float>(a)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_3d_to_matrix_most_sig)
|
|
{
|
|
Shape shape_a{3, 3, 3};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{3, 3};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{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});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{1 + 10 + 19,
|
|
2 + 11 + 20,
|
|
3 + 12 + 21,
|
|
4 + 13 + 22,
|
|
5 + 14 + 23,
|
|
6 + 15 + 24,
|
|
7 + 16 + 25,
|
|
8 + 17 + 26,
|
|
9 + 18 + 27}),
|
|
read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_3d_to_matrix_least_sig)
|
|
{
|
|
Shape shape_a{3, 3, 3};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{3, 3};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{2}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{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});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{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}),
|
|
read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_3d_to_vector)
|
|
{
|
|
Shape shape_a{3, 3, 3};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{3};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{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});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25,
|
|
2 + 11 + 20 + 5 + 14 + 23 + 8 + 17 + 26,
|
|
3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27}),
|
|
read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_3d_to_scalar)
|
|
{
|
|
Shape shape_a{3, 3, 3};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1, 2}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{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});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f(
|
|
(vector<float>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25 + 2 + 11 + 20 + 5 + 14 + 23 + 8 +
|
|
17 + 26 + 3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27}),
|
|
read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_3d_to_scalar_int32)
|
|
{
|
|
Shape shape_a{3, 3, 3};
|
|
auto A = make_shared<op::Parameter>(element::i32, shape_a);
|
|
Shape shape_rt{};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1, 2}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::i32, shape_a);
|
|
copy_data(a, vector<int32_t>{0x40000001, 10, 19, 4, 13, 22, 7, 16, 25, 2, 11, 20, 5, 14,
|
|
23, 8, 17, 26, 3, 12, 21, 6, 15, 24, 9, 18, 27});
|
|
auto result = backend->create_tensor(element::i32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_EQ((vector<int32_t>{0x40000001 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25 + 2 + 11 + 20 + 5 +
|
|
14 + 23 + 8 + 17 + 26 + 3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27}),
|
|
read_vector<int32_t>(result));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_3d_eliminate_zero_dim)
|
|
{
|
|
Shape shape_a{3, 0, 2};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{3, 2};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, vector<float>{});
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
// Overwrite the initial result vector to make sure we're not just coincidentally getting the
|
|
// right value.
|
|
copy_data(result, vector<float>{2112, 2112, 2112, 2112, 2112, 2112});
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<float>{0, 0, 0, 0, 0, 0}), read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_3d_eliminate_zero_dim_int32)
|
|
{
|
|
Shape shape_a{3, 0, 2};
|
|
auto A = make_shared<op::Parameter>(element::i32, shape_a);
|
|
Shape shape_rt{3, 2};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::i32, shape_a);
|
|
copy_data(a, vector<int32_t>{});
|
|
auto result = backend->create_tensor(element::i32, shape_rt);
|
|
|
|
// Overwrite the initial result vector to make sure we're not just coincidentally getting the
|
|
// right value.
|
|
copy_data(result, vector<int32_t>{2112, 2112, 2112, 2112, 2112, 2112});
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_EQ((vector<int32_t>{0, 0, 0, 0, 0, 0}), read_vector<int32_t>(result));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_5d_to_scalar)
|
|
{
|
|
Shape shape_a{3, 3, 3, 3, 3};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
Shape shape_rt{};
|
|
auto f =
|
|
make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1, 2, 3, 4}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape_a);
|
|
copy_data(a, std::vector<float>(std::pow(3, 5), 1));
|
|
auto result = backend->create_tensor(element::f32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f(std::vector<float>{243.}, read_vector<float>(result)));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_5d_to_scalar_int32)
|
|
{
|
|
Shape shape_a{3, 3, 3, 3, 3};
|
|
auto A = make_shared<op::Parameter>(element::i32, shape_a);
|
|
Shape shape_rt{};
|
|
auto f =
|
|
make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1, 2, 3, 4}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::i32, shape_a);
|
|
copy_data(a, std::vector<int32_t>(std::pow(3, 5), 1));
|
|
auto result = backend->create_tensor(element::i32, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_EQ(std::vector<int32_t>{243}, read_vector<int32_t>(result));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_2d_to_scalar_int8)
|
|
{
|
|
Shape shape_a{3, 3};
|
|
auto A = make_shared<op::Parameter>(element::i8, shape_a);
|
|
Shape shape_rt{};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0, 1}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::i8, shape_a);
|
|
copy_data(a, std::vector<int8_t>{1, 2, 3, 4, 5, 6, 7, 8, 9});
|
|
auto result = backend->create_tensor(element::i8, shape_rt);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_EQ(std::vector<int8_t>{45}, read_vector<int8_t>(result));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_trivial_in_double)
|
|
{
|
|
Shape shape{4, 3};
|
|
Shape rshape{3};
|
|
auto A = make_shared<op::Parameter>(element::f64, shape);
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f64, shape);
|
|
copy_data(a, vector<double>{12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7});
|
|
auto result = backend->create_tensor(element::f64, rshape);
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
EXPECT_TRUE(test::all_close_f((vector<double>{30, 22, 26}), read_vector<double>(result)));
|
|
}
|
|
|
|
#if NGRAPH_INTERPRETER_ENABLE
|
|
|
|
#ifndef _WIN32
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_stable_acc)
|
|
{
|
|
std::string backend_name = "${BACKEND_NAME}";
|
|
if (backend_name == "INTERPRETER")
|
|
{
|
|
return;
|
|
}
|
|
Shape shape_a{10, 10, 10, 30};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
|
|
Shape shape_rt{10};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1, 2, 3}), ParameterVector{A});
|
|
|
|
test::Uniform<float> rng(1000.0f, 1000.1f, 2112);
|
|
vector<vector<float>> args;
|
|
for (shared_ptr<op::Parameter> param : f->get_parameters())
|
|
{
|
|
vector<float> tensor_val(shape_size(param->get_shape()));
|
|
rng.initialize(tensor_val);
|
|
args.push_back(tensor_val);
|
|
}
|
|
|
|
auto ref_func = clone_function(*f);
|
|
auto bk_func = clone_function(*f);
|
|
|
|
auto ref_results = execute(ref_func, args, "INTERPRETER");
|
|
auto bk_results = execute(bk_func, args, "${BACKEND_NAME}");
|
|
|
|
EXPECT_TRUE(
|
|
test::all_close_f(ref_results.at(0), bk_results.at(0), DEFAULT_FLOAT_TOLERANCE_BITS + 1));
|
|
}
|
|
#endif
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_stable_acc_double)
|
|
{
|
|
std::string backend_name = "${BACKEND_NAME}";
|
|
if (backend_name == "INTERPRETER")
|
|
{
|
|
return;
|
|
}
|
|
Shape shape_a{10, 10, 20, 300};
|
|
auto A = make_shared<op::Parameter>(element::f64, shape_a);
|
|
|
|
Shape shape_rt{10};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1, 2, 3}), ParameterVector{A});
|
|
|
|
test::Uniform<double> rng(1000000000.0L, 1000000000.001L, 2112);
|
|
vector<vector<double>> args;
|
|
for (shared_ptr<op::Parameter> param : f->get_parameters())
|
|
{
|
|
vector<double> tensor_val(shape_size(param->get_shape()));
|
|
rng.initialize(tensor_val);
|
|
args.push_back(tensor_val);
|
|
}
|
|
|
|
auto ref_func = clone_function(*f);
|
|
auto bk_func = clone_function(*f);
|
|
|
|
auto ref_results = execute(ref_func, args, "INTERPRETER");
|
|
auto bk_results = execute(bk_func, args, "${BACKEND_NAME}");
|
|
|
|
EXPECT_TRUE(test::all_close(ref_results.at(0), bk_results.at(0), 0.0, 1e-5));
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_stable_simple_float)
|
|
{
|
|
std::string backend_name = "${BACKEND_NAME}";
|
|
if (backend_name == "INTERPRETER")
|
|
{
|
|
return;
|
|
}
|
|
Shape shape_a{20};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape_a);
|
|
|
|
Shape shape_rt{};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
vector<vector<float>> args;
|
|
args.push_back(vector<float>{10000000.0f, 0.9f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f,
|
|
0.8f, 0.1f, 0.9f, 0.5f, 0.2f, 0.3f, 0.4f,
|
|
0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 0.1f});
|
|
|
|
auto ref_func = clone_function(*f);
|
|
auto bk_func = clone_function(*f);
|
|
|
|
auto ref_results = execute(ref_func, args, "INTERPRETER");
|
|
auto bk_results = execute(bk_func, args, "${BACKEND_NAME}");
|
|
|
|
EXPECT_TRUE(
|
|
test::all_close_f(ref_results.at(0), bk_results.at(0), DEFAULT_FLOAT_TOLERANCE_BITS - 1));
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_stable_simple_double)
|
|
{
|
|
std::string backend_name = "${BACKEND_NAME}";
|
|
if (backend_name == "INTERPRETER")
|
|
{
|
|
return;
|
|
}
|
|
Shape shape_a{20};
|
|
auto A = make_shared<op::Parameter>(element::f64, shape_a);
|
|
|
|
Shape shape_rt{};
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{0}), ParameterVector{A});
|
|
|
|
vector<vector<double>> args;
|
|
args.push_back(vector<double>{10000000000000000.0L,
|
|
0.2L,
|
|
0.3L,
|
|
0.4L,
|
|
0.5L,
|
|
0.6L,
|
|
0.7L,
|
|
0.8L,
|
|
0.9L,
|
|
0.7L,
|
|
0.9L,
|
|
0.7L,
|
|
0.3L,
|
|
0.6L,
|
|
0.8L,
|
|
0.4L,
|
|
0.6L,
|
|
0.5L,
|
|
0.8L,
|
|
0.7L});
|
|
|
|
auto ref_func = clone_function(*f);
|
|
auto bk_func = clone_function(*f);
|
|
|
|
auto ref_results = execute(ref_func, args, "INTERPRETER");
|
|
auto bk_results = execute(bk_func, args, "${BACKEND_NAME}");
|
|
|
|
EXPECT_TRUE(test::all_close(ref_results.at(0), bk_results.at(0), 0.0, 2.0));
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_dynamic)
|
|
{
|
|
// Create a graph for f(x,axes:int32) = Sum(x,Convert<int64>(axes)).
|
|
auto x = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
|
|
auto axes = make_shared<op::Parameter>(element::i32, PartialShape{Dimension::dynamic()});
|
|
auto axes_i64 = make_shared<op::Convert>(axes, element::i64);
|
|
|
|
auto sum = make_shared<op::Sum>(x, axes_i64);
|
|
ASSERT_TRUE(sum->get_output_partial_shape(0).rank().is_dynamic());
|
|
|
|
auto f = make_shared<Function>(NodeVector{sum}, ParameterVector{x, axes});
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}", true);
|
|
|
|
auto ex = backend->compile(f);
|
|
|
|
auto t_r = backend->create_dynamic_tensor(element::f32, PartialShape::dynamic());
|
|
|
|
std::vector<Shape> x_shapes{
|
|
Shape{2, 3}, Shape{2, 3}, Shape{2, 3}, Shape{2, 3}, Shape{5}, Shape{5}};
|
|
std::vector<std::vector<int32_t>> axeses{{}, {0}, {1}, {0, 1}, {}, {0}};
|
|
std::vector<std::vector<float>> inputs{{1, 2, 3, 4, 5, 6},
|
|
{1, 2, 3, 4, 5, 6},
|
|
{1, 2, 3, 4, 5, 6},
|
|
{1, 2, 3, 4, 5, 6},
|
|
{1, 2, 3, 4, 5},
|
|
{1, 2, 3, 4, 5}};
|
|
std::vector<Shape> expected_result_shapes{
|
|
Shape{2, 3}, Shape{3}, Shape{2}, Shape{}, Shape{5}, Shape{}};
|
|
std::vector<std::vector<float>> expected_results{
|
|
{1, 2, 3, 4, 5, 6}, {5, 7, 9}, {6, 15}, {21}, {1, 2, 3, 4, 5}, {15}};
|
|
|
|
for (size_t i = 0; i < x_shapes.size(); i++)
|
|
{
|
|
auto t_x = backend->create_tensor(element::f32, x_shapes[i]);
|
|
auto t_axes = backend->create_tensor(element::i32, Shape{axeses[i].size()});
|
|
|
|
copy_data(t_x, inputs[i]);
|
|
copy_data(t_axes, axeses[i]);
|
|
|
|
ex->call_with_validate({t_r}, {t_x, t_axes});
|
|
|
|
ASSERT_EQ(t_r->get_shape(), expected_result_shapes[i]);
|
|
|
|
auto results = read_vector<float>(t_r);
|
|
|
|
ASSERT_TRUE(test::all_close_f(results, expected_results[i], MIN_FLOAT_TOLERANCE_BITS));
|
|
}
|
|
}
|
|
|
|
NGRAPH_TEST(${BACKEND_NAME}, sum_inf)
|
|
{
|
|
Shape shape{7, 4};
|
|
auto A = make_shared<op::Parameter>(element::f32, shape);
|
|
auto f = make_shared<Function>(make_shared<op::Sum>(A, AxisSet{1}), ParameterVector{A});
|
|
|
|
auto infi = std::numeric_limits<float>::infinity();
|
|
|
|
auto backend = runtime::Backend::create("${BACKEND_NAME}");
|
|
|
|
// Create some tensors for input/output
|
|
auto a = backend->create_tensor(element::f32, shape);
|
|
copy_data(a,
|
|
test::NDArray<float, 2>({{-infi, 0, 0, infi},
|
|
{infi, 100, -100, -infi},
|
|
{infi, 0, 100, infi},
|
|
{-infi, -100, 0, -infi},
|
|
{infi, infi, infi, infi},
|
|
{infi, infi, infi, -infi},
|
|
{infi, std::nanf(""), 42, infi}})
|
|
.get_vector());
|
|
auto result = backend->create_tensor(element::f32, Shape{7});
|
|
|
|
auto handle = backend->compile(f);
|
|
handle->call_with_validate({result}, {a});
|
|
auto r = read_vector<float>(result);
|
|
ASSERT_EQ(r.size(), 7);
|
|
EXPECT_TRUE(isnan(r[0]));
|
|
EXPECT_TRUE(isnan(r[1]));
|
|
EXPECT_TRUE(r[2] > 0 && isinf(r[2]));
|
|
EXPECT_TRUE(r[3] < 0 && isinf(r[3]));
|
|
EXPECT_TRUE(r[4] > 0 && isinf(r[4]));
|
|
EXPECT_TRUE(isnan(r[5]));
|
|
EXPECT_TRUE(isnan(r[6]));
|
|
}
|