50b0dc1182
* Deprecated old evaluate methods * Suppress node * Fixed some warnings * Fixed documentation and warnings * Fixed some warnings * Disable some warnings
261 lines
12 KiB
C++
261 lines
12 KiB
C++
// Copyright (C) 2018-2021 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
#include "ngraph/op/variadic_split.hpp"
|
|
|
|
#include <numeric>
|
|
#include <vector>
|
|
|
|
#include "engines_util/execute_tools.hpp"
|
|
#include "gtest/gtest.h"
|
|
#include "ngraph/runtime/host_tensor.hpp"
|
|
#include "ngraph/validation_util.hpp"
|
|
#include "runtime/backend.hpp"
|
|
#include "util/test_tools.hpp"
|
|
#include "util/type_prop.hpp"
|
|
|
|
using namespace std;
|
|
using namespace ngraph;
|
|
OPENVINO_SUPPRESS_DEPRECATED_START
|
|
|
|
TEST(op_eval, variadic_split_same_lengths) {
|
|
const auto data_shape = Shape{3, 8, 3};
|
|
const auto data = make_shared<op::Parameter>(element::i64, data_shape);
|
|
const auto axis = make_shared<op::Parameter>(element::i64, Shape{});
|
|
const auto split_lengths = make_shared<op::Parameter>(element::i64, Shape{4});
|
|
|
|
auto var_split = make_shared<op::v1::VariadicSplit>(data, axis, split_lengths);
|
|
|
|
auto f = make_shared<Function>(var_split, ParameterVector{data, axis, split_lengths});
|
|
|
|
std::vector<int64_t> data_vec(shape_size(data_shape));
|
|
std::iota(data_vec.begin(), data_vec.end(), 0);
|
|
|
|
std::vector<std::vector<int64_t>> expected_results{
|
|
{0, 1, 2, 3, 4, 5, 24, 25, 26, 27, 28, 29, 48, 49, 50, 51, 52, 53},
|
|
{6, 7, 8, 9, 10, 11, 30, 31, 32, 33, 34, 35, 54, 55, 56, 57, 58, 59},
|
|
{12, 13, 14, 15, 16, 17, 36, 37, 38, 39, 40, 41, 60, 61, 62, 63, 64, 65},
|
|
{18, 19, 20, 21, 22, 23, 42, 43, 44, 45, 46, 47, 66, 67, 68, 69, 70, 71}};
|
|
|
|
const vector<int64_t> split_lengths_vec{2, 2, 2, 2};
|
|
HostTensorVector results(split_lengths_vec.size());
|
|
for (auto& result : results) {
|
|
result = make_shared<HostTensor>();
|
|
}
|
|
ASSERT_TRUE(f->evaluate(results,
|
|
{make_host_tensor<element::Type_t::i64>(data_shape, data_vec),
|
|
make_host_tensor<element::Type_t::i64>({}, std::vector<int64_t>{1}),
|
|
make_host_tensor<element::Type_t::i64>({4}, split_lengths_vec)}));
|
|
|
|
for (size_t i = 0; i < split_lengths_vec.size(); ++i) {
|
|
EXPECT_EQ(results[i]->get_element_type(), element::i64);
|
|
EXPECT_EQ(results[i]->get_shape(), (Shape{3, static_cast<size_t>(split_lengths_vec[i]), 3}));
|
|
EXPECT_EQ(read_vector<int64_t>(results[i]), expected_results[i]);
|
|
}
|
|
}
|
|
|
|
TEST(op_eval, variadic_split_different_lengths) {
|
|
const auto data_shape = Shape{6, 2, 3};
|
|
const auto data = make_shared<op::Parameter>(element::i64, data_shape);
|
|
const auto axis = make_shared<op::Parameter>(element::i64, Shape{});
|
|
const auto split_lengths = make_shared<op::Parameter>(element::i64, Shape{3});
|
|
|
|
auto var_split = make_shared<op::v1::VariadicSplit>(data, axis, split_lengths);
|
|
|
|
auto f = make_shared<Function>(var_split, ParameterVector{data, axis, split_lengths});
|
|
|
|
std::vector<int64_t> data_vec(shape_size(data_shape));
|
|
std::iota(data_vec.begin(), data_vec.end(), 0);
|
|
|
|
std::vector<std::vector<int64_t>> expected_results{
|
|
{0, 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}};
|
|
|
|
const vector<int64_t> split_lengths_vec{1, 2, 3};
|
|
HostTensorVector results(split_lengths_vec.size());
|
|
for (auto& result : results) {
|
|
result = make_shared<HostTensor>();
|
|
}
|
|
ASSERT_TRUE(f->evaluate(results,
|
|
{make_host_tensor<element::Type_t::i64>(data_shape, data_vec),
|
|
make_host_tensor<element::Type_t::i64>({}, std::vector<int64_t>{0}),
|
|
make_host_tensor<element::Type_t::i64>({3}, split_lengths_vec)}));
|
|
|
|
for (size_t i = 0; i < split_lengths_vec.size(); ++i) {
|
|
EXPECT_EQ(results[i]->get_element_type(), element::i64);
|
|
EXPECT_EQ(results[i]->get_shape(), (Shape{static_cast<size_t>(split_lengths_vec[i]), 2, 3}));
|
|
EXPECT_EQ(read_vector<int64_t>(results[i]), expected_results[i]);
|
|
}
|
|
}
|
|
|
|
TEST(op_eval, variadic_split_neg_length) {
|
|
const auto data_shape = Shape{2, 7, 1};
|
|
const auto data = make_shared<op::Parameter>(element::i64, data_shape);
|
|
const auto axis = make_shared<op::Parameter>(element::i64, Shape{});
|
|
const auto split_lengths = make_shared<op::Parameter>(element::i64, Shape{3});
|
|
|
|
auto var_split = make_shared<op::v1::VariadicSplit>(data, axis, split_lengths);
|
|
|
|
auto f = make_shared<Function>(var_split, ParameterVector{data, axis, split_lengths});
|
|
|
|
std::vector<int64_t> data_vec(shape_size(data_shape));
|
|
std::iota(data_vec.begin(), data_vec.end(), 0);
|
|
|
|
std::vector<std::vector<int64_t>> expected_results{{0, 1, 2, 7, 8, 9}, {3, 10}, {4, 5, 6, 11, 12, 13}};
|
|
|
|
const vector<int64_t> split_lengths_vec{-1, 1, 3};
|
|
HostTensorVector results(split_lengths_vec.size());
|
|
for (auto& result : results) {
|
|
result = make_shared<HostTensor>();
|
|
}
|
|
ASSERT_TRUE(f->evaluate(results,
|
|
{make_host_tensor<element::Type_t::i64>(data_shape, data_vec),
|
|
make_host_tensor<element::Type_t::i64>({}, std::vector<int64_t>{1}),
|
|
make_host_tensor<element::Type_t::i64>({3}, split_lengths_vec)}));
|
|
|
|
const vector<size_t> expected_lengths{3, 1, 3};
|
|
for (size_t i = 0; i < split_lengths_vec.size(); ++i) {
|
|
EXPECT_EQ(results[i]->get_element_type(), element::i64);
|
|
EXPECT_EQ(results[i]->get_shape(), (Shape{2, expected_lengths[i], 1}));
|
|
EXPECT_EQ(read_vector<int64_t>(results[i]), expected_results[i]);
|
|
}
|
|
}
|
|
|
|
TEST(op_eval, variadic_split_neg_length_neg_axis) {
|
|
const auto data_shape = Shape{2, 1, 5, 2};
|
|
const auto data = make_shared<op::Parameter>(element::i64, data_shape);
|
|
const auto axis = make_shared<op::Parameter>(element::i64, Shape{});
|
|
const auto split_lengths = make_shared<op::Parameter>(element::i64, Shape{3});
|
|
|
|
auto var_split = make_shared<op::v1::VariadicSplit>(data, axis, split_lengths);
|
|
|
|
auto f = make_shared<Function>(var_split, ParameterVector{data, axis, split_lengths});
|
|
|
|
std::vector<int64_t> data_vec(shape_size(data_shape));
|
|
std::iota(data_vec.begin(), data_vec.end(), 0);
|
|
|
|
std::vector<std::vector<int64_t>> expected_results{{0, 1, 10, 11},
|
|
{2, 3, 4, 5, 12, 13, 14, 15},
|
|
{6, 7, 8, 9, 16, 17, 18, 19}};
|
|
|
|
const vector<int64_t> split_lengths_vec{1, 2, -1};
|
|
HostTensorVector results(split_lengths_vec.size());
|
|
for (auto& result : results) {
|
|
result = make_shared<HostTensor>();
|
|
}
|
|
ASSERT_TRUE(f->evaluate(results,
|
|
{make_host_tensor<element::Type_t::i64>(data_shape, data_vec),
|
|
make_host_tensor<element::Type_t::i64>({}, std::vector<int64_t>{-2}),
|
|
make_host_tensor<element::Type_t::i64>(Shape{3}, split_lengths_vec)}));
|
|
|
|
const vector<size_t> expected_lengths{1, 2, 2};
|
|
for (size_t i = 0; i < split_lengths_vec.size(); ++i) {
|
|
EXPECT_EQ(results[i]->get_element_type(), element::i64);
|
|
EXPECT_EQ(results[i]->get_shape(), (Shape{2, 1, expected_lengths[i], 2}));
|
|
EXPECT_EQ(read_vector<int64_t>(results[i]), expected_results[i]);
|
|
}
|
|
}
|
|
|
|
TEST(op_eval, variadic_split_neg_length_bool_data_type) {
|
|
const auto data_shape = Shape{2, 1, 5};
|
|
const auto data = make_shared<op::Parameter>(element::boolean, data_shape);
|
|
const auto axis = make_shared<op::Parameter>(element::i64, Shape{});
|
|
const auto split_lengths = make_shared<op::Parameter>(element::i64, Shape{3});
|
|
|
|
auto var_split = make_shared<op::v1::VariadicSplit>(data, axis, split_lengths);
|
|
|
|
auto f = make_shared<Function>(var_split, ParameterVector{data, axis, split_lengths});
|
|
|
|
std::vector<char> data_vec{true, true, false, false, true, false, true, false, true, false};
|
|
|
|
std::vector<std::vector<char>> expected_results{{true, false},
|
|
{true, false, true, false},
|
|
{false, true, true, false}};
|
|
|
|
const vector<int64_t> split_lengths_vec{1, -1, 2};
|
|
HostTensorVector results(split_lengths_vec.size());
|
|
for (auto& result : results) {
|
|
result = make_shared<HostTensor>();
|
|
}
|
|
ASSERT_TRUE(f->evaluate(results,
|
|
{make_host_tensor<element::Type_t::boolean>(data_shape, data_vec),
|
|
make_host_tensor<element::Type_t::i64>({}, std::vector<int64_t>{2}),
|
|
make_host_tensor<element::Type_t::i64>({3}, split_lengths_vec)}));
|
|
|
|
const vector<size_t> expected_lengths{1, 2, 2};
|
|
for (size_t i = 0; i < split_lengths_vec.size(); ++i) {
|
|
EXPECT_EQ(results[i]->get_element_type(), element::boolean);
|
|
EXPECT_EQ(results[i]->get_shape(), (Shape{2, 1, expected_lengths[i]}));
|
|
EXPECT_EQ(read_vector<char>(results[i]), expected_results[i]);
|
|
}
|
|
}
|
|
|
|
TEST(op_eval, variadic_split_neg_length_axis_ui64) {
|
|
const auto data_shape = Shape{2, 1, 4, 2};
|
|
const auto data = make_shared<op::Parameter>(element::i64, data_shape);
|
|
const auto axis = make_shared<op::Parameter>(element::u64, Shape{});
|
|
const auto split_lengths = make_shared<op::Parameter>(element::i64, Shape{2});
|
|
|
|
auto var_split = make_shared<op::v1::VariadicSplit>(data, axis, split_lengths);
|
|
|
|
auto f = make_shared<Function>(var_split, ParameterVector{data, axis, split_lengths});
|
|
|
|
std::vector<int64_t> data_vec(shape_size(data_shape));
|
|
std::iota(data_vec.begin(), data_vec.end(), 0);
|
|
|
|
std::vector<std::vector<int64_t>> expected_results{{0, 1, 2, 3, 8, 9, 10, 11}, {4, 5, 6, 7, 12, 13, 14, 15}};
|
|
|
|
const vector<int64_t> split_lengths_vec{2, -1};
|
|
HostTensorVector results(split_lengths_vec.size());
|
|
for (auto& result : results) {
|
|
result = make_shared<HostTensor>();
|
|
}
|
|
ASSERT_TRUE(f->evaluate(results,
|
|
{make_host_tensor<element::Type_t::i64>(data_shape, data_vec),
|
|
make_host_tensor<element::Type_t::u64>({}, std::vector<uint64_t>{2}),
|
|
make_host_tensor<element::Type_t::i64>({split_lengths_vec.size()}, split_lengths_vec)}));
|
|
|
|
const vector<size_t> expected_lengths{2, 2};
|
|
for (size_t i = 0; i < split_lengths_vec.size(); ++i) {
|
|
EXPECT_EQ(results[i]->get_element_type(), element::i64);
|
|
EXPECT_EQ(results[i]->get_shape(), (Shape{2, 1, expected_lengths[i], 2}));
|
|
EXPECT_EQ(read_vector<int64_t>(results[i]), expected_results[i]);
|
|
}
|
|
}
|
|
|
|
TEST(op_eval, variadic_split_data_float_length_i32) {
|
|
const auto data_shape = Shape{2, 3, 3};
|
|
const auto data = make_shared<op::Parameter>(element::f32, data_shape);
|
|
const auto axis = make_shared<op::Parameter>(element::i64, Shape{});
|
|
const auto split_lengths = make_shared<op::Parameter>(element::i32, Shape{3});
|
|
|
|
auto var_split = make_shared<op::v1::VariadicSplit>(data, axis, split_lengths);
|
|
|
|
auto f = make_shared<Function>(var_split, ParameterVector{data, axis, split_lengths});
|
|
|
|
std::vector<float> data_vec(shape_size(data_shape));
|
|
std::iota(data_vec.begin(), data_vec.end(), 0.0f);
|
|
|
|
std::vector<std::vector<float>> expected_results{{0.0f, 3.0f, 6.0f, 9.0f, 12.0f, 15.0f},
|
|
{1.0f, 4.0f, 7.0f, 10.0f, 13.0f, 16.0f},
|
|
{2.0f, 5.0f, 8.0f, 11.0f, 14.0f, 17.0f}};
|
|
|
|
const vector<int32_t> split_lengths_vec{1, 1, -1};
|
|
HostTensorVector results(split_lengths_vec.size());
|
|
for (auto& result : results) {
|
|
result = make_shared<HostTensor>();
|
|
}
|
|
ASSERT_TRUE(f->evaluate(results,
|
|
{make_host_tensor<element::Type_t::f32>(data_shape, data_vec),
|
|
make_host_tensor<element::Type_t::i64>({}, std::vector<int64_t>{-1}),
|
|
make_host_tensor<element::Type_t::i32>({3}, split_lengths_vec)}));
|
|
|
|
const vector<size_t> expected_lengths{1, 1, 1};
|
|
for (size_t i = 0; i < split_lengths_vec.size(); ++i) {
|
|
EXPECT_EQ(results[i]->get_element_type(), element::f32);
|
|
EXPECT_EQ(results[i]->get_shape(), (Shape{2, 3, expected_lengths[i]}));
|
|
EXPECT_EQ(read_vector<float>(results[i]), expected_results[i]);
|
|
}
|
|
}
|