diff --git a/docs/template_plugin/tests/functional/op_reference/gather.cpp b/docs/template_plugin/tests/functional/op_reference/gather.cpp new file mode 100644 index 00000000000..a76021ab692 --- /dev/null +++ b/docs/template_plugin/tests/functional/op_reference/gather.cpp @@ -0,0 +1,880 @@ +// Copyright (C) 2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "openvino/op/gather.hpp" +#include "openvino/op/constant.hpp" +#include "base_reference_test.hpp" + +using namespace reference_tests; +using namespace ov; + +namespace { +struct GatherParams { + GatherParams( + const Tensor& dataTensor, const Tensor& indicesTensor, const Tensor& axisTensor, + const Tensor& expectedTensor, const std::string& testcaseName = "") : + dataTensor(dataTensor), indicesTensor(indicesTensor), axisTensor(axisTensor), + expectedTensor(expectedTensor), testcaseName(testcaseName) {} + + Tensor dataTensor; + Tensor indicesTensor; + Tensor axisTensor; + Tensor expectedTensor; + std::string testcaseName; +}; + +class ReferenceGatherTest : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.dataTensor.data, params.indicesTensor.data}; + refOutData = {params.expectedTensor.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "dType=" << param.dataTensor.type; + result << "_dShape=" << param.dataTensor.shape; + result << "_iType=" << param.indicesTensor.type; + result << "_iShape=" << param.indicesTensor.shape; + result << "_aType=" << param.axisTensor.type; + result << "_aShape=" << param.axisTensor.shape; + result << "_eType=" << param.expectedTensor.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expectedTensor.shape; + result << "_=" << param.testcaseName; + } else { + result << "_eShape=" << param.expectedTensor.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const GatherParams& params) { + const auto P = std::make_shared(params.dataTensor.type, params.dataTensor.shape); + const auto I = std::make_shared(params.indicesTensor.type, params.indicesTensor.shape); + const auto A = op::v0::Constant::create(params.axisTensor.type, params.axisTensor.shape, + params.axisTensor.data.data()); + const auto G = std::make_shared(P, I, A); + const auto f = std::make_shared(G, ParameterVector{P, I}); + return f; + } +}; + +TEST_P(ReferenceGatherTest, CompareWithRefs) { + Exec(); +} + +struct GatherParamsV7 { + GatherParamsV7( + const Tensor& dataTensor, const Tensor& indicesTensor, const Tensor& axisTensor, int64_t batchDims, + const Tensor& expectedTensor, const std::string& testcaseName = "") : + dataTensor(dataTensor), indicesTensor(indicesTensor), axisTensor(axisTensor), batchDims(batchDims), + expectedTensor(expectedTensor), testcaseName(testcaseName) {} + + Tensor dataTensor; + Tensor indicesTensor; + Tensor axisTensor; + int64_t batchDims; + Tensor expectedTensor; + std::string testcaseName; +}; + +class ReferenceGatherTestV7 : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.dataTensor.data, params.indicesTensor.data}; + refOutData = {params.expectedTensor.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "dType=" << param.dataTensor.type; + result << "_dShape=" << param.dataTensor.shape; + result << "_iType=" << param.indicesTensor.type; + result << "_iShape=" << param.indicesTensor.shape; + result << "_aType=" << param.axisTensor.type; + result << "_aShape=" << param.axisTensor.shape; + result << "_batchDims=" << param.batchDims; + result << "_eType=" << param.expectedTensor.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expectedTensor.shape; + result << "_=" << param.testcaseName; + } else { + result << "_eShape=" << param.expectedTensor.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const GatherParamsV7& params) { + const auto P = std::make_shared(params.dataTensor.type, params.dataTensor.shape); + const auto I = std::make_shared(params.indicesTensor.type, params.indicesTensor.shape); + const auto A = op::v0::Constant::create(params.axisTensor.type, params.axisTensor.shape, + params.axisTensor.data.data()); + const auto G = std::make_shared(P, I, A, params.batchDims); + const auto f = std::make_shared(G, ParameterVector{P, I}); + return f; + } +}; + +TEST_P(ReferenceGatherTestV7, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParams() { + using T = typename element_type_traits::value_type; + using T_I = typename element_type_traits::value_type; + using T_A = typename element_type_traits::value_type; + std::vector params { + GatherParams( + Tensor(ET, {3, 2}, std::vector{ + 10, 11, 20, 21, 30, 31}), + Tensor(ET_I, {2, 2, 3, 4}, std::vector{ + 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, + 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2, 2, 3, 4, 2}, std::vector{ + 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, + 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, + 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, + 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31}), + "gather_4d_indices_axis_0"), + GatherParams( + Tensor(ET, {3, 2}, std::vector{ + 10, 11, 20, 21, 30, 31}), + Tensor(ET_I, {2, 2}, std::vector{ + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2, 2, 2}, std::vector{ + 10, 11, 20, 21, 20, 21, 30, 31}), + "gather_axis_0"), + }; + return params; +} + +template +std::vector generateParamsFloatValue() { + using T = typename element_type_traits::value_type; + using T_I = typename element_type_traits::value_type; + using T_A = typename element_type_traits::value_type; + std::vector params { + GatherParams( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 2, 3, 4}, std::vector{ + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2, 2, 3, 4, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_4d_indices_axis_0_2d_input"), + GatherParams( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 3, 4}, std::vector{ + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2, 3, 4, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_3d_indices_axis_0_2d_input"), + GatherParams( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 2}, std::vector{ + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2, 2, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_2d_indices_axis_0_2d_input"), + GatherParams( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 2}, std::vector{ + 0, -2, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2, 2, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_2d_negative_and_positive_indices_axis_0_2d_input"), + GatherParams( + Tensor(ET, {3}, std::vector{ + 1.0f, 2.0f, 3.0f}), + Tensor(ET_I, {2}, std::vector{ + 1, 0}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2}, std::vector{ + 2.0f, 1.0f}), + "gather_1d_indices_axis_0_1d_input"), + GatherParams( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, 2.0f, 2.1f, 3.0f, 3.1f}), + Tensor(ET_I, {}, std::vector{1}), + Tensor(ET_A, {}, std::vector{0}), + Tensor(ET, {2}, std::vector{ + 2.0f, 2.1f}), + "gather_scalar_indices_axis_0_2d_input"), + GatherParams( + Tensor(ET, {3, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, + 2.0f, 2.1f, 2.2f, + 3.0f, 3.1f, 3.2f}), + Tensor(ET_I, {1, 2}, std::vector{ + 0, 2}), + Tensor(ET_A, {}, std::vector{1}), + Tensor(ET, {3, 1, 2}, std::vector{ + 1.0f, 1.2f, + 2.0f, 2.2f, + 3.0f, 3.2f}), + "gather_2d_indices_axis_1_2d_input"), + GatherParams( + Tensor(ET, {2, 2, 3, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, + 2.0f, 2.1f, 2.2f, + 3.0f, 3.1f, 3.2f, + + 11.0f, 11.1f, 11.2f, + 12.0f, 12.1f, 12.2f, + 13.0f, 13.1f, 13.2f, + + + 101.0f, 101.1f, 101.2f, + 102.0f, 102.1f, 102.2f, + 103.0f, 103.1f, 103.2f, + + 111.0f, 111.1f, 111.2f, + 112.0f, 112.1f, 112.2f, + 113.0f, 113.1f, 113.2f}), + Tensor(ET_I, {2}, std::vector{ + 0, 2}), + Tensor(ET_A, {}, std::vector{2}), + Tensor(ET, {2, 2, 2, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, + 3.0f, 3.1f, 3.2f, + + 11.0f, 11.1f, 11.2f, + 13.0f, 13.1f, 13.2f, + + + 101.0f, 101.1f, 101.2f, + 103.0f, 103.1f, 103.2f, + + 111.0f, 111.1f, 111.2f, + 113.0f, 113.1f, 113.2f}), + "gather_1d_indices_axis_2_4d_input"), + GatherParams( + Tensor(ET, {3, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f, 3.0f, 3.1f, 3.2f}), + Tensor(ET_I, {}, std::vector{0}), + Tensor(ET_A, {}, std::vector{1}), + Tensor(ET, {3}, std::vector{ + 1.0f, 2.0f, 3.0f}), + "gather_scalar_indices_axis_1_2d_input"), + }; + return params; +} + +std::vector generateCombinedParams() { + const std::vector> generatedParams { + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParamsFloatValue(), + generateParamsFloatValue(), + generateParamsFloatValue(), + generateParamsFloatValue(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Gather_With_Hardcoded_Refs, ReferenceGatherTest, + testing::ValuesIn(generateCombinedParams()), ReferenceGatherTest::getTestCaseName); + +template +std::vector generateParamsV7() { + using T = typename element_type_traits::value_type; + using T_I = typename element_type_traits::value_type; + using T_A = typename element_type_traits::value_type; + std::vector params { + GatherParamsV7( + Tensor(ET, {3}, std::vector{ + 1, 2, 3}), + Tensor(ET_I, {2}, std::vector{ + 2, 0}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2}, std::vector{ + 3, 1}), + "gather_v7_1d"), + GatherParamsV7( + Tensor(ET, {3, 2}, std::vector{ + 10, 11, 20, 21, 30, 31}), + Tensor(ET_I, {2, 2}, std::vector{ + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2, 2, 2}, std::vector{ + 10, 11, 20, 21, 20, 21, 30, 31}), + "gather_v7_axis_0"), + GatherParamsV7( + Tensor(ET, {2, 3}, std::vector{ + 1, 2, 3, + 4, 5, 6}), + Tensor(ET_I, {2, 2, 2}, std::vector{ + 0, 1, + 1, 2, + + 2, 0, + 1, 2}), + Tensor(ET_A, {}, std::vector{1}), + 1, + Tensor(ET, {2, 2, 2}, std::vector{ + 1, 2, + 2, 3, + + 6, 4, + 5, 6}), + "gather_v7_data_int32_3d_indices_axis_1_batch_dims_1"), + GatherParamsV7( + Tensor(ET, {2, 5}, std::vector{ + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10}), + Tensor(ET_I, {2, 3}, std::vector{ + 0, 0, 4, + 4, 0, 0}), + Tensor(ET_A, {}, std::vector{1}), + 1, + Tensor(ET, {2, 3}, std::vector{ + 1, 1, 5, + 10, 6, 6}), + "gather_v7_data_int32_2d_indices_axis_1_batch_dims_1"), + GatherParamsV7( + Tensor(ET, {2, 5}, std::vector{ + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10}), + Tensor(ET_I, {2, 3}, std::vector{ + 0, 0, 4, + 4, 0, 0}), + Tensor(ET_A, {}, std::vector{1}), + -1, + Tensor(ET, {2, 3}, std::vector{ + 1, 1, 5, + 10, 6, 6}), + "gather_v7_data_int32_2d_indices_axis_1_negative_batch_dims"), + GatherParamsV7( + Tensor(ET, {2, 1, 5, 4}, std::vector{ + 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}), + Tensor(ET_I, {2, 3}, std::vector{ + 1, 2, 4, + 4, 3, 2}), + Tensor(ET_A, {}, std::vector{2}), + 1, + Tensor(ET, {2, 1, 3, 4}, std::vector{ + 5, 6, 7, 8, + 9, 10, 11, 12, + 17, 18, 19, 20, + + 37, 38, 39, 40, + 33, 34, 35, 36, + 29, 30, 31, 32}), + "gather_v7_4d_data_axis_2_batch_dims_1_int32"), + }; + return params; +} + +template <> +std::vector generateParamsV7() { + std::vector params { + GatherParamsV7( + Tensor(element::boolean, {3, 2}, std::vector{ + 1, 1, 1, 0, 0, 1}), + Tensor(element::i32, {2, 2}, std::vector{ + 0, 1, 1, 2}), + Tensor(element::i64, {}, std::vector{0}), + 0, + Tensor(element::boolean, {2, 2, 2}, std::vector{ + 1, 1, 1, 0, 1, 0, 0, 1}), + "gather_v7_axis_0_bool"), + }; + return params; +} + +template +std::vector generateParamsFloatValueV7() { + using T = typename element_type_traits::value_type; + using T_I = typename element_type_traits::value_type; + using T_A = typename element_type_traits::value_type; + std::vector params { + GatherParamsV7( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 2, 3, 4}, std::vector{ + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2, 2, 3, 4, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_v7_4d_indices_axis_0_2d_input"), + GatherParamsV7( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 3, 4}, std::vector{ + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2, + + 0, 1, 1, 2, + 0, 1, 1, 2, + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2, 3, 4, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f, + + 1.0f, 1.1f, + 2.0f, 2.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_v7_3d_indices_axis_0_2d_input"), + GatherParamsV7( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 2}, std::vector{ + 0, 1, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2, 2, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_v7_2d_indices_axis_0_2d_input"), + GatherParamsV7( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + 3.0f, 3.1f}), + Tensor(ET_I, {2, 2}, std::vector{ + 0, -2, 1, 2}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2, 2, 2}, std::vector{ + 1.0f, 1.1f, + 2.0f, 2.1f, + + 2.0f, 2.1f, + 3.0f, 3.1f}), + "gather_v7_2d_negative_and_positive_indices_axis_0_2d_input"), + GatherParamsV7( + Tensor(ET, {3}, std::vector{ + 1.0f, 2.0f, 3.0f}), + Tensor(ET_I, {2}, std::vector{ + 1, 0}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2}, std::vector{ + 2.0f, 1.0f}), + "gather_v7_1d_indices_axis_0_1d_input"), + GatherParamsV7( + Tensor(ET, {3, 2}, std::vector{ + 1.0f, 1.1f, 2.0f, 2.1f, 3.0f, 3.1f}), + Tensor(ET_I, {}, std::vector{1}), + Tensor(ET_A, {}, std::vector{0}), + 0, + Tensor(ET, {2}, std::vector{ + 2.0f, 2.1f}), + "gather_v7_scalar_indices_axis_0_2d_input"), + GatherParamsV7( + Tensor(ET, {3, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, + 2.0f, 2.1f, 2.2f, + 3.0f, 3.1f, 3.2f}), + Tensor(ET_I, {1, 2}, std::vector{ + 0, 2}), + Tensor(ET_A, {}, std::vector{1}), + 0, + Tensor(ET, {3, 1, 2}, std::vector{ + 1.0f, 1.2f, + 2.0f, 2.2f, + 3.0f, 3.2f}), + "gather_v7_2d_indices_axis_1_2d_input"), + GatherParamsV7( + Tensor(ET, {2, 2, 3, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, + 2.0f, 2.1f, 2.2f, + 3.0f, 3.1f, 3.2f, + + 11.0f, 11.1f, 11.2f, + 12.0f, 12.1f, 12.2f, + 13.0f, 13.1f, 13.2f, + + + 101.0f, 101.1f, 101.2f, + 102.0f, 102.1f, 102.2f, + 103.0f, 103.1f, 103.2f, + + 111.0f, 111.1f, 111.2f, + 112.0f, 112.1f, 112.2f, + 113.0f, 113.1f, 113.2f}), + Tensor(ET_I, {2}, std::vector{ + 0, 2}), + Tensor(ET_A, {}, std::vector{2}), + 0, + Tensor(ET, {2, 2, 2, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, + 3.0f, 3.1f, 3.2f, + + 11.0f, 11.1f, 11.2f, + 13.0f, 13.1f, 13.2f, + + + 101.0f, 101.1f, 101.2f, + 103.0f, 103.1f, 103.2f, + + 111.0f, 111.1f, 111.2f, + 113.0f, 113.1f, 113.2f}), + "gather_v7_1d_indices_axis_2_4d_input"), + GatherParamsV7( + Tensor(ET, {3, 3}, std::vector{ + 1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f, 3.0f, 3.1f, 3.2f}), + Tensor(ET_I, {}, std::vector{0}), + Tensor(ET_A, {}, std::vector{1}), + 0, + Tensor(ET, {3}, std::vector{ + 1.0f, 2.0f, 3.0f}), + "gather_v7_scalar_indices_axis_1_2d_input"), + GatherParamsV7( + Tensor(ET, {2, 5, 2}, std::vector{ + 1.0f, 2.0f, + 3.0f, 4.0f, + 5.0f, 6.0f, + 7.0f, 8.0f, + 9.0f, 10.0f, + + 11.0f, 12.0f, + 13.0f, 14.0f, + 15.0f, 16.0f, + 17.0f, 18.0f, + 19.0f, 20.0f}), + Tensor(ET_I, {2, 2, 3}, std::vector{ + 0, 0, 4, + 4, 0, 0, + + 1, 2, 4, + 4, 3, 2}), + Tensor(ET_A, {}, std::vector{1}), + 1, + Tensor(ET, {2, 2, 3, 2}, std::vector{ + 1.0f, 2.0f, + 1.0f, 2.0f, + 9.0f, 10.0f, + + 9.0f, 10.0f, + 1.0f, 2.0f, + 1.0f, 2.0f, + + + 13.0f, 14.0f, + 15.0f, 16.0f, + 19.0f, 20.0f, + + 19.0f, 20.0f, + 17.0f, 18.0f, + 15.0f, 16.0f}), + "gather_v7_3d_indices_axis_1_batch_dims_1"), + }; + return params; +} + +std::vector generateCombinedParamsV7() { + const std::vector> generatedParams { + generateParamsV7(), + generateParamsV7(), + generateParamsV7(), + generateParamsV7(), + generateParamsV7(), + generateParamsV7(), + generateParamsV7(), + generateParamsV7(), + generateParamsV7(), + generateParamsFloatValueV7(), + generateParamsFloatValueV7(), + generateParamsFloatValueV7(), + generateParamsFloatValueV7(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Gather_With_Hardcoded_Refs, ReferenceGatherTestV7, + testing::ValuesIn(generateCombinedParamsV7()), ReferenceGatherTestV7::getTestCaseName); +} // namespace \ No newline at end of file diff --git a/docs/template_plugin/tests/functional/op_reference/pad.cpp b/docs/template_plugin/tests/functional/op_reference/pad.cpp new file mode 100644 index 00000000000..36cad51fea2 --- /dev/null +++ b/docs/template_plugin/tests/functional/op_reference/pad.cpp @@ -0,0 +1,1099 @@ +// Copyright (C) 2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "openvino/op/pad.hpp" +#include "openvino/op/constant.hpp" +#include "base_reference_test.hpp" + +using namespace reference_tests; +using namespace ov; + +namespace { +struct PadParams { + PadParams( + const Tensor& inputData, const Tensor& padsBegin, const Tensor& padsEnd, + const Tensor& expectedOutput, op::PadMode padMode, const Tensor& constantValue, + const std::string& testcaseName = "") : + inputData(inputData), padsBegin(padsBegin), padsEnd(padsEnd), + expectedOutput(expectedOutput), padMode(padMode), + useConstValue{true}, constantValue(constantValue), + testcaseName(testcaseName) {} + + PadParams( + const Tensor& inputData, const Tensor& padsBegin, const Tensor& padsEnd, + const Tensor& expectedOutput, op::PadMode padMode, + const std::string& testcaseName = "") : + inputData(inputData), padsBegin(padsBegin), padsEnd(padsEnd), + expectedOutput(expectedOutput), padMode(padMode), + testcaseName(testcaseName) {} + + Tensor inputData; + Tensor padsBegin; + Tensor padsEnd; + Tensor expectedOutput; + op::PadMode padMode; + bool useConstValue{false}; + Tensor constantValue; + std::string testcaseName; +}; + +class ReferencePadTest : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.inputData.data}; + refOutData = {params.expectedOutput.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "iType=" << param.inputData.type; + result << "_iShape=" << param.inputData.shape; + result << "_pbType=" << param.padsBegin.type; + result << "_pbShape=" << param.padsBegin.shape; + result << "_peType=" << param.padsEnd.type; + result << "_peShape=" << param.padsEnd.shape; + result << "_oType=" << param.expectedOutput.type; + result << "_oShape=" << param.expectedOutput.shape; + result << "_=" << param.testcaseName; + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const PadParams& params) { + const auto data = std::make_shared(params.inputData.type, + params.inputData.shape); + const auto padsBegin = op::v0::Constant::create(params.padsBegin.type, + params.padsBegin.shape, + params.padsBegin.data.data()); + const auto padsEnd = op::v0::Constant::create(params.padsEnd.type, + params.padsEnd.shape, + params.padsEnd.data.data()); + const auto f = [&] { + if (params.useConstValue) { + // pad_value should be used only in CONSTANT mode + const auto padVal = op::v0::Constant::create(params.constantValue.type, + params.constantValue.shape, + params.constantValue.data.data()); + return std::make_shared(std::make_shared(data, + padsBegin, + padsEnd, + padVal, + params.padMode), + ParameterVector{data}); + } + + return std::make_shared(std::make_shared(data, + padsBegin, + padsEnd, + params.padMode), + ParameterVector{data}); + }(); + return f; + } +}; + +TEST_P(ReferencePadTest, CompareWithRefs) { + Exec(); +} + +class ReferencePadTestParamsTooLarge : public ReferencePadTest {}; + +TEST_P(ReferencePadTestParamsTooLarge, CompareWithRefs) { + EXPECT_ANY_THROW(Exec()); +} + +class ReferencePadTestParamsOk : public ReferencePadTest {}; + +TEST_P(ReferencePadTestParamsOk, CompareWithRefs) { + EXPECT_NO_THROW(Exec()); +} + +template +std::vector generateParams() { + using T = typename element_type_traits::value_type; + using T_INT = typename element_type_traits::value_type; + std::vector params { + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{4}), + Tensor(ET_INT, {1}, std::vector{5}), + Tensor(ET, {15}, std::vector{ + 2112, 2112, 2112, 2112, 1, 2, 3, 4, 5, 6, 2112, 2112, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_1d_constant_const_value_provided_0"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{4}), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET, {10}, std::vector{ + 2112, 2112, 2112, 2112, 1, 2, 3, 4, 5, 6, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_1d_constant_const_value_provided_1"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {9}, std::vector{ + 1, 2, 3, 4, 5, 6, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_1d_constant_const_value_provided_2"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{4}), + Tensor(ET_INT, {1}, std::vector{5}), + Tensor(ET, {15}, std::vector{ + 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, + }), + op::PadMode::CONSTANT, + "pad_1d_constant_use_default_const_0"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{4}), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET, {10}, std::vector{ + 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, + }), + op::PadMode::CONSTANT, + "pad_1d_constant_use_default_const_1"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {9}, std::vector{ + 1, 2, 3, 4, 5, 6, 0, 0, 0, + }), + op::PadMode::CONSTANT, + "pad_1d_constant_use_default_const_2"), + + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{3, 4}), + Tensor(ET, {6, 8}, std::vector{ + 2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 1, 2, 2112, 2112, 2112, 2112, + 2112, 2112, 3, 4, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_2d_constant_const_value_provided_0"), + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {3, 4}, std::vector{ + 2112, 2112, 2112, 2112, + 2112, 2112, 1, 2, + 2112, 2112, 3, 4, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_2d_constant_const_value_provided_1"), + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {3, 4}, std::vector{ + 1, 2, 2112, 2112, + 3, 4, 2112, 2112, + 2112, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_2d_constant_const_value_provided_2"), + + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{3, 4}), + Tensor(ET, {6, 8}, std::vector{ + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 0, 0, 0, 0, + 0, 0, 3, 4, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + }), + op::PadMode::CONSTANT, + "pad_2d_constant_use_default_const_0"), + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {3, 4}, std::vector{ + 0, 0, 0, 0, + 0, 0, 1, 2, + 0, 0, 3, 4, + }), + op::PadMode::CONSTANT, + "pad_2d_constant_use_default_const_1"), + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {3, 4}, std::vector{ + 1, 2, 0, 0, + 3, 4, 0, 0, + 0, 0, 0, 0, + }), + op::PadMode::CONSTANT, + "pad_2d_constant_use_default_const_2"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {11}, std::vector{ + 1, 1, 1, 2, 3, 4, 5, 6, 6, 6, 6, + }), + op::PadMode::EDGE, + "pad_1d_edge_0"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{1}), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET, {7}, std::vector{ + 1, 1, 2, 3, 4, 5, 6, + }), + op::PadMode::EDGE, + "pad_1d_edge_1"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET, {8}, std::vector{ + 1, 2, 3, 4, 5, 6, 6, 6, + }), + op::PadMode::EDGE, + "pad_1d_edge_2"), + + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{2, 1}), + Tensor(ET, {5, 5}, std::vector{ + 1, 1, 1, 2, 2, + 1, 1, 1, 2, 2, + 3, 3, 3, 4, 4, + 3, 3, 3, 4, 4, + 3, 3, 3, 4, 4, + }), + op::PadMode::EDGE, + "pad_2d_edge_0"), + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {3, 4}, std::vector{ + 1, 1, 1, 2, + 1, 1, 1, 2, + 3, 3, 3, 4, + }), + op::PadMode::EDGE, + "pad_2d_edge_1"), + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 3, 4, + }), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET_INT, {2}, std::vector{2, 1}), + Tensor(ET, {4, 3}, std::vector{ + 1, 2, 2, + 3, 4, 4, + 3, 4, 4, + 3, 4, 4, + }), + op::PadMode::EDGE, + "pad_2d_edge_2"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {11}, std::vector{ + 3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3, + }), + op::PadMode::REFLECT, + "pad_1d_reflect_0"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{1}), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET, {7}, std::vector{ + 2, 1, 2, 3, 4, 5, 6, + }), + op::PadMode::REFLECT, + "pad_1d_reflect_1"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET, {8}, std::vector{ + 1, 2, 3, 4, 5, 6, 5, 4, + }), + op::PadMode::REFLECT, + "pad_1d_reflect_2"), + + PadParams( + Tensor(ET, {3, 3}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{2, 1}), + Tensor(ET, {6, 6}, std::vector{ + 6, 5, 4, 5, 6, 5, + 3, 2, 1, 2, 3, 2, + 6, 5, 4, 5, 6, 5, + 9, 8, 7, 8, 9, 8, + 6, 5, 4, 5, 6, 5, + 3, 2, 1, 2, 3, 2, + }), + op::PadMode::REFLECT, + "pad_2d_reflect_0"), + PadParams( + Tensor(ET, {3, 3}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {4, 5}, std::vector{ + 6, 5, 4, 5, 6, + 3, 2, 1, 2, 3, + 6, 5, 4, 5, 6, + 9, 8, 7, 8, 9, + }), + op::PadMode::REFLECT, + "pad_2d_reflect_1"), + PadParams( + Tensor(ET, {3, 3}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, + }), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET_INT, {2}, std::vector{2, 1}), + Tensor(ET, {5, 4}, std::vector{ + 1, 2, 3, 2, + 4, 5, 6, 5, + 7, 8, 9, 8, + 4, 5, 6, 5, + 1, 2, 3, 2, + }), + op::PadMode::REFLECT, + "pad_2d_reflect_2"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {11}, std::vector{ + 2, 1, 1, 2, 3, 4, 5, 6, 6, 5, 4, + }), + op::PadMode::SYMMETRIC, + "pad_1d_symmetric_0"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{1}), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET, {7}, std::vector{ + 1, 1, 2, 3, 4, 5, 6, + }), + op::PadMode::SYMMETRIC, + "pad_1d_symmetric_1"), + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{0}), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET, {8}, std::vector{ + 1, 2, 3, 4, 5, 6, 6, 5, + }), + op::PadMode::SYMMETRIC, + "pad_1d_symmetric_2"), + + PadParams( + Tensor(ET, {3, 3}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{2, 1}), + Tensor(ET, {6, 6}, std::vector{ + 2, 1, 1, 2, 3, 3, + 2, 1, 1, 2, 3, 3, + 5, 4, 4, 5, 6, 6, + 8, 7, 7, 8, 9, 9, + 8, 7, 7, 8, 9, 9, + 5, 4, 4, 5, 6, 6, + }), + op::PadMode::SYMMETRIC, + "pad_2d_symmetric_0"), + PadParams( + Tensor(ET, {3, 3}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {4, 5}, std::vector{ + 2, 1, 1, 2, 3, + 2, 1, 1, 2, 3, + 5, 4, 4, 5, 6, + 8, 7, 7, 8, 9, + }), + op::PadMode::SYMMETRIC, + "pad_2d_symmetric_1"), + PadParams( + Tensor(ET, {3, 3}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, + }), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET_INT, {2}, std::vector{2, 1}), + Tensor(ET, {5, 4}, std::vector{ + 1, 2, 3, 3, + 4, 5, 6, 6, + 7, 8, 9, 9, + 7, 8, 9, 9, + 4, 5, 6, 6, + }), + op::PadMode::SYMMETRIC, + "pad_2d_symmetric"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{4}), + Tensor(ET_INT, {1}, std::vector{5}), + Tensor(ET, {15}, std::vector{ + 2112, 2112, 2112, 2112, 1, 2, 3, 4, 5, 6, 2112, 2112, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_exterior_1d"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{4}), + Tensor(ET_INT, {1}, std::vector{-2}), + Tensor(ET, {8}, std::vector{ + 2112, 2112, 2112, 2112, 1, 2, 3, 4, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_negative_exterior_1d"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{4}), + Tensor(ET_INT, {1}, std::vector{-7}), + Tensor(ET, {3}, std::vector{ + 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_negative_exterior_1d_check_limits"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {11}, std::vector{ + 1, 1, 1, 2, 3, 4, 5, 6, 6, 6, 6, + }), + op::PadMode::EDGE, + Tensor(ET, {}, std::vector{2112}), + "pad_edge_1d"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{-3}), + Tensor(ET, {5}, std::vector{ + 1, 1, 1, 2, 3, + }), + op::PadMode::EDGE, + Tensor(ET, {}, std::vector{2112}), + "pad_edge_1d_top_neg"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{-7}), + Tensor(ET, {1}, std::vector{ + 1, + }), + op::PadMode::EDGE, + Tensor(ET, {}, std::vector{2112}), + "pad_edge_1d_top_neg_bigger_than_tensor"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{-2}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {7}, std::vector{ + 3, 4, 5, 6, 6, 6, 6, + }), + op::PadMode::EDGE, + Tensor(ET, {}, std::vector{2112}), + "pad_edge_1d_bottom_neg"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{-7}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {2}, std::vector{ + 6, 6, + }), + op::PadMode::EDGE, + Tensor(ET, {}, std::vector{2112}), + "pad_edge_1d_bottom_neg_bigger_than_tensor"), + + PadParams( + Tensor(ET, {3, 4}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + }), + Tensor(ET_INT, {2}, std::vector{2, 3}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {6, 9}, std::vector{ + 1, 1, 1, 1, 2, 3, 4, 4, 4, + 1, 1, 1, 1, 2, 3, 4, 4, 4, + 1, 1, 1, 1, 2, 3, 4, 4, 4, + 5, 5, 5, 5, 6, 7, 8, 8, 8, + 9, 9, 9, 9, 10, 11, 12, 12, 12, + 9, 9, 9, 9, 10, 11, 12, 12, 12, + }), + op::PadMode::EDGE, + Tensor(ET, {}, std::vector{2112}), + "pad_edge_2d"), + + PadParams( + Tensor(ET, {3, 4}, std::vector{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + }), + Tensor(ET_INT, {2}, std::vector{2, -1}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {6, 5}, std::vector{ + 2, 3, 4, 4, 4, + 2, 3, 4, 4, 4, + 2, 3, 4, 4, 4, + 6, 7, 8, 8, 8, + 10, 11, 12, 12, 12, + 10, 11, 12, 12, 12, + }), + op::PadMode::EDGE, + Tensor(ET, {}, std::vector{2112}), + "pad_edge_2d_with_neg"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {11}, std::vector{ + 3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3, + }), + op::PadMode::REFLECT, + Tensor(ET, {}, std::vector{2112}), + "pad_reflect_1d"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{-3}), + Tensor(ET, {5}, std::vector{ + 3, 2, 1, 2, 3, + }), + op::PadMode::REFLECT, + Tensor(ET, {}, std::vector{2112}), + "pad_reflect_1d_top_neg"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{2}), + Tensor(ET_INT, {1}, std::vector{-7}), + Tensor(ET, {1}, std::vector{ + 3, + }), + op::PadMode::REFLECT, + Tensor(ET, {}, std::vector{2112}), + "pad_reflect_1d_top_neg_bigger_than_tensor"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{-2}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {7}, std::vector{ + 3, 4, 5, 6, 5, 4, 3, + }), + op::PadMode::REFLECT, + Tensor(ET, {}, std::vector{2112}), + "pad_reflect_1d_bottom_neg"), + + PadParams( + Tensor(ET, {6}, std::vector{ + 1, 2, 3, 4, 5, 6, + }), + Tensor(ET_INT, {1}, std::vector{-7}), + Tensor(ET_INT, {1}, std::vector{3}), + Tensor(ET, {2}, std::vector{ + 4, 3, + }), + op::PadMode::REFLECT, + Tensor(ET, {}, std::vector{2112}), + "pad_reflect_1d_bottom_neg_bigger_than_tensor"), + + PadParams( + Tensor(ET, {3, 4}, std::vector{ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + }), + Tensor(ET_INT, {2}, std::vector{2, 3}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {6, 9}, std::vector{ + 12, 11, 10, 9, 10, 11, 12, 11, 10, + 8, 7, 6, 5, 6, 7, 8, 7, 6, + 4, 3, 2, 1, 2, 3, 4, 3, 2, + 8, 7, 6, 5, 6, 7, 8, 7, 6, + 12, 11, 10, 9, 10, 11, 12, 11, 10, + 8, 7, 6, 5, 6, 7, 8, 7, 6, + }), + op::PadMode::REFLECT, + Tensor(ET, {}, std::vector{2112}), + "pad_reflect_2d"), + + PadParams( + Tensor(ET, {3, 4}, std::vector{ + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + }), + Tensor(ET_INT, {2}, std::vector{2, -1}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {6, 5}, std::vector{ + 10, 11, 12, 11, 10, + 6, 7, 8, 7, 6, + 2, 3, 4, 3, 2, + 6, 7, 8, 7, 6, + 10, 11, 12, 11, 10, + 6, 7, 8, 7, 6, + }), + op::PadMode::REFLECT, + Tensor(ET, {}, std::vector{2112}), + "pad_reflect_2d_with_neg"), + + PadParams( + Tensor(ET, {2, 3}, std::vector{ + 1, 2, 3, + 4, 5, 6, + }), + Tensor(ET_INT, {2}, std::vector{1, -1}), + Tensor(ET_INT, {2}, std::vector{2, 0}), + Tensor(ET, {5, 2}, std::vector{ + 9, 9, + 2, 3, + 5, 6, + 9, 9, + 9, 9, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{9}), + "pad_negative_exterior_2d"), + + PadParams( + Tensor(ET, {3, 3}, std::vector{ + 1, 2, 3, + 4, 5, 6, + }), + Tensor(ET_INT, {2}, std::vector{-1, -1}), + Tensor(ET_INT, {2}, std::vector{-1, -1}), + Tensor(ET, {1, 1}, std::vector{5}), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{9}), + "pad_negative_exterior_2d_all_negative"), + + PadParams( + Tensor(ET, {0, 0}, std::vector{}), + Tensor(ET_INT, {2}, std::vector{2, 3}), + Tensor(ET_INT, {2}, std::vector{3, 2}), + Tensor(ET, {5, 5}, std::vector{ + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_exterior_2d_0x0"), + + PadParams( + Tensor(ET, {0, 3}, std::vector{}), + Tensor(ET_INT, {2}, std::vector{2, 1}), + Tensor(ET_INT, {2}, std::vector{3, 1}), + Tensor(ET, {5, 5}, std::vector{ + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_exterior_2d_0x3"), + + PadParams( + Tensor(ET, {3, 0}, std::vector{}), + Tensor(ET_INT, {2}, std::vector{1, 3}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {5, 5}, std::vector{ + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + 2112, 2112, 2112, 2112, 2112, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{2112}), + "pad_exterior_2d_3x0"), + + PadParams( + Tensor(ET, {2, 2, 4, 4}, std::vector{ + 0, 1, 0, 2, + 0, 3, 2, 0, + 2, 0, 0, 0, + 0, 2, 1, 0, + + 0, 0, 0, 2, + 0, 2, 3, 0, + 2, 0, 1, 0, + 2, 0, 0, 0, + + 0, 2, 1, 1, + 0, 0, 2, 0, + 0, 0, 1, 2, + 0, 0, 0, 0, + + 2, 1, 0, 0, + 0, 2, 0, 0, + 1, 1, 2, 0, + 1, 0, 0, 0, + }), + Tensor(ET_INT, {4}, std::vector{0, 0, 0, 0}), + Tensor(ET_INT, {4}, std::vector{0, 0, 2, 2}), + Tensor(ET, {2, 2, 6, 6}, std::vector{ + 0, 1, 0, 2, 42, 42, + 0, 3, 2, 0, 42, 42, + 2, 0, 0, 0, 42, 42, + 0, 2, 1, 0, 42, 42, + 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, + + 0, 0, 0, 2, 42, 42, + 0, 2, 3, 0, 42, 42, + 2, 0, 1, 0, 42, 42, + 2, 0, 0, 0, 42, 42, + 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, + + 0, 2, 1, 1, 42, 42, + 0, 0, 2, 0, 42, 42, + 0, 0, 1, 2, 42, 42, + 0, 0, 0, 0, 42, 42, + 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, + + 2, 1, 0, 0, 42, 42, + 0, 2, 0, 0, 42, 42, + 1, 1, 2, 0, 42, 42, + 1, 0, 0, 0, 42, 42, + 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{42}), + "pad_2channel_2image_asym"), + + PadParams( + Tensor(ET, {2, 3}, std::vector{ + 1, 2, 3, + 4, 5, 6, + }), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET_INT, {2}, std::vector{1, 2}), + Tensor(ET, {4, 7}, std::vector{ + 2, 1, 1, 2, 3, 3, 2, + 2, 1, 1, 2, 3, 3, 2, + 5, 4, 4, 5, 6, 6, 5, + 5, 4, 4, 5, 6, 6, 5, + }), + op::PadMode::SYMMETRIC, + Tensor(ET, {}, std::vector{2112}), + "pad_symmetric"), + }; + return params; +} + +template +std::vector generateParamsFloatValue() { + using T = typename element_type_traits::value_type; + using T_INT = typename element_type_traits::value_type; + std::vector params { + PadParams( + Tensor(ET, {1, 2, 2, 2}, std::vector{ + 0.0f, 0.0f, + 0.0f, 0.0f, + 0.0f, 0.0f, + 0.0f, 0.0f, + }), + Tensor(ET_INT, {4}, std::vector{0, 0, 1, 1}), + Tensor(ET_INT, {4}, std::vector{0, 0, 1, 1}), + Tensor(ET, {1, 2, 4, 4}, std::vector{ + 42.0f, 42.0f, 42.0f, 42.0f, + 42.0f, 0.0f, 0.0f, 42.0f, + 42.0f, 0.0f, 0.0f, 42.0f, + 42.0f, 42.0f, 42.0f, 42.0f, + 42.0f, 42.0f, 42.0f, 42.0f, + 42.0f, 0.0f, 0.0f, 42.0f, + 42.0f, 0.0f, 0.0f, 42.0f, + 42.0f, 42.0f, 42.0f, 42.0f, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{42}), + "pad_exterior_4d_1x2x2x2"), + + PadParams( + Tensor(ET, {1, 3, 2, 2}, std::vector{ + 0.0f, 0.0f, + 0.0f, 0.0f, + 1.0f, 1.0f, + 1.0f, 1.0f, + 2.0f, 2.0f, + 2.0f, 2.0f, + }), + Tensor(ET_INT, {4}, std::vector{0, -1, 1, 1}), + Tensor(ET_INT, {4}, std::vector{0, -1, 1, 1}), + Tensor(ET, {1, 1, 4, 4}, std::vector{ + 42.0f, 42.0f, 42.0f, 42.0f, + 42.0f, 1.0f, 1.0f, 42.0f, + 42.0f, 1.0f, 1.0f, 42.0f, + 42.0f, 42.0f, 42.0f, 42.0f, + }), + op::PadMode::CONSTANT, + Tensor(ET, {}, std::vector{42}), + "pad_negative_exterior_4d"), + }; + return params; +} + +std::vector generateCombinedParams() { + const std::vector> generatedParams { + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParamsFloatValue(), + generateParamsFloatValue(), + generateParamsFloatValue(), + generateParamsFloatValue(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Pad_With_Hardcoded_Refs, ReferencePadTest, + testing::ValuesIn(generateCombinedParams()), ReferencePadTest::getTestCaseName); + +template +std::vector generateParamsTooLarge() { + using T = typename element_type_traits::value_type; + using T_INT = typename element_type_traits::value_type; + std::vector params { + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 4, 5, + }), + Tensor(ET_INT, {2}, std::vector{0, 3}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {2, 5}, std::vector{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }), + op::PadMode::SYMMETRIC, + "pad_to_large_symmetric_padding"), + + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 4, 5, + }), + Tensor(ET_INT, {2}, std::vector{0, 2}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {2, 4}, std::vector{ + 0, 0, 0, 0, 0, 0, 0, 0, + }), + op::PadMode::REFLECT, + "pad_to_large_reflect_padding"), + }; + return params; +} + +std::vector generateCombinedParamsTooLarge() { + const std::vector> generatedParams { + generateParamsTooLarge(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Pad_With_Hardcoded_Refs, ReferencePadTestParamsTooLarge, + testing::ValuesIn(generateCombinedParamsTooLarge()), ReferencePadTest::getTestCaseName); + +template +std::vector generateParamsOk() { + using T = typename element_type_traits::value_type; + using T_INT = typename element_type_traits::value_type; + std::vector params { + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 4, 5, + }), + Tensor(ET_INT, {2}, std::vector{0, 2}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {2, 4}, std::vector{ + 2, 1, 1, 2, 5, 4, 4, 5, + }), + op::PadMode::SYMMETRIC, + "pad_ok_symmetric_padding"), + + PadParams( + Tensor(ET, {2, 2}, std::vector{ + 1, 2, 4, 5, + }), + Tensor(ET_INT, {2}, std::vector{0, 1}), + Tensor(ET_INT, {2}, std::vector{0, 0}), + Tensor(ET, {2, 3}, std::vector{ + 2, 1, 2, 5, 4, 5, + }), + op::PadMode::REFLECT, + "pad_ok_reflect_padding"), + }; + return params; +} + +std::vector generateCombinedParamsOk() { + const std::vector> generatedParams { + generateParamsOk(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Pad_With_Hardcoded_Refs, ReferencePadTestParamsOk, + testing::ValuesIn(generateCombinedParamsOk()), ReferencePadTest::getTestCaseName); +} // namespace \ No newline at end of file diff --git a/docs/template_plugin/tests/functional/skip_tests_config.cpp b/docs/template_plugin/tests/functional/skip_tests_config.cpp index 51e3a9eda91..d28fe056619 100644 --- a/docs/template_plugin/tests/functional/skip_tests_config.cpp +++ b/docs/template_plugin/tests/functional/skip_tests_config.cpp @@ -61,6 +61,20 @@ std::vector disabledTestPatterns() { R"(.*ReferenceGatherElementsTestNegative.*)", // CVS-64052 R"(.*ReferenceStridedSliceLayerTest.*strided_slice_stride_optional_dynamic)", + // CVS-64017 + R"(.*ReferenceGatherTest.*dType=i16.*)", + R"(.*ReferenceGatherTest.*dType=u16.*)", + R"(.*ReferenceGatherTest.*dType=bf16.*)", + R"(.*ReferenceGatherTest.*dType=f64.*)", + // CVS-64110 + R"(.*ReferenceGatherTestV7.*dType=i16.*)", + R"(.*ReferenceGatherTestV7.*dType=u16.*)", + R"(.*ReferenceGatherTestV7.*dType=bf16.*)", + R"(.*ReferenceGatherTestV7.*dType=f64.*)", + // CVS-64037 + R"(.*ReferencePadTest.*pad_exterior_2d_0x0)", + R"(.*ReferencePadTest.*pad_exterior_2d_0x3)", + R"(.*ReferencePadTest.*pad_exterior_2d_3x0)", }; #ifdef _WIN32 diff --git a/ngraph/test/CMakeLists.txt b/ngraph/test/CMakeLists.txt index 56e411d8596..593324a9740 100644 --- a/ngraph/test/CMakeLists.txt +++ b/ngraph/test/CMakeLists.txt @@ -487,7 +487,6 @@ set(MULTI_TEST_SRC backend/dynamic.in.cpp backend/experimental_detectron_prior_grid.in.cpp backend/function_name.in.cpp - backend/gather.in.cpp backend/interpolate.in.cpp backend/matrix_nms.in.cpp backend/multiclass_nms.in.cpp @@ -496,7 +495,6 @@ set(MULTI_TEST_SRC backend/node_name.in.cpp backend/non_max_suppression.in.cpp backend/one_hot.in.cpp - backend/pad.in.cpp backend/recurrent_cells.in.cpp backend/region_yolo.in.cpp backend/roll.in.cpp diff --git a/ngraph/test/backend/gather.in.cpp b/ngraph/test/backend/gather.in.cpp deleted file mode 100644 index 51f11d18221..00000000000 --- a/ngraph/test/backend/gather.in.cpp +++ /dev/null @@ -1,1272 +0,0 @@ -// Copyright (C) 2018-2021 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include -#include -#include -#include -#include - -#include "engines_util/test_case.hpp" -#include "engines_util/test_engines.hpp" -#include "gtest/gtest.h" -#include "ngraph/ngraph.hpp" -#include "util/test_control.hpp" - -NGRAPH_SUPPRESS_DEPRECATED_START - -using namespace std; -using namespace ngraph; - -static string s_manifest = "${MANIFEST}"; -using TestEngine = test::ENGINE_CLASS_NAME(${BACKEND_NAME}); - -NGRAPH_TEST(${BACKEND_NAME}, gather_4d_indices_axis_0_uint8) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2, 3, 4}; - Shape out_shape{2, 2, 3, 4, 2}; - auto P = make_shared(element::u8, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, - 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2}); - test_case.add_expected_output( - out_shape, - {10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, - 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, - 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, - 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_4d_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2, 3, 4}; - Shape out_shape{2, 2, 3, 4, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - - test_case.add_input({0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2}); - test_case.add_expected_output( - out_shape, - { 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_3d_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 3, 4}; - Shape out_shape{2, 3, 4, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - test_case.add_input( - {0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2}); - test_case.add_expected_output( - out_shape, {1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_2d_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.add_input({0, 1, 1, 2}); - // clang-format off - test_case.add_expected_output(out_shape, - {1.0f, 1.1f, - 2.0f, 2.1f, - - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_2d_negative_and_positive_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - - test_case.add_input({0, -2, 1, 2}); - - // clang-format off - test_case.add_expected_output(out_shape, - {1.0f, 1.1f, - 2.0f, 2.1f, - - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_1d_indices_axis_0_1d_input) { - Shape data_shape{3}; - Shape indices_shape{2}; - Shape out_shape{2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({1.0f, 2.0f, 3.0f}); - test_case.add_input({1, 0}); - test_case.add_expected_output(out_shape, {2.0f, 1.0f}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_scalar_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{}; - Shape out_shape{2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({1.0f, 1.1f, 2.0f, 2.1f, 3.0f, 3.1f}); - test_case.add_input({1}); - test_case.add_expected_output(out_shape, {2.0f, 2.1f}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_2d_indices_axis_1_2d_input) { - Shape data_shape{3, 3}; - Shape indices_shape{1, 2}; - Shape out_shape{3, 1, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {1}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - - // clang-format off - test_case.add_input({1.0f, 1.1f, 1.2f, - 2.0f, 2.1f, 2.2f, - 3.0f, 3.1f, 3.2f}); - // clang-format on - test_case.add_input({0, 2}); - - // clang-format off - test_case.add_expected_output(out_shape, {1.0f, 1.2f, - 2.0f, 2.2f, - 3.0f, 3.2f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_1d_indices_axis_2_4d_input) { - Shape data_shape{2, 2, 3, 3}; - Shape indices_shape{2}; - Shape out_shape{2, 2, 2, 3}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {2}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - // clang-format off - test_case.add_input({ 1.0f, 1.1f, 1.2f, - 2.0f, 2.1f, 2.2f, - 3.0f, 3.1f, 3.2f, - - 11.0f, 11.1f, 11.2f, - 12.0f, 12.1f, 12.2f, - 13.0f, 13.1f, 13.2f, - - - 101.0f, 101.1f, 101.2f, - 102.0f, 102.1f, 102.2f, - 103.0f, 103.1f, 103.2f, - - 111.0f, 111.1f, 111.2f, - 112.0f, 112.1f, 112.2f, - 113.0f, 113.1f, 113.2f}); - // clang-format on - test_case.add_input({0, 2}); - // clang-format off - test_case.add_expected_output( - out_shape, { 1.0f, 1.1f, 1.2f, - 3.0f, 3.1f, 3.2f, - - 11.0f, 11.1f, 11.2f, - 13.0f, 13.1f, 13.2f, - - - 101.0f, 101.1f, 101.2f, - 103.0f, 103.1f, 103.2f, - - 111.0f, 111.1f, 111.2f, - 113.0f, 113.1f, 113.2f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_scalar_indices_axis_1_2d_input) { - Shape data_shape{3, 3}; - Shape indices_shape{}; - Shape out_shape{3}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {1}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f, 3.0f, 3.1f, 3.2f}); - test_case.add_input({0}); - test_case.add_expected_output(out_shape, {1.0f, 2.0f, 3.0f}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_int8) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i8, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_int16) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i16, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_int32) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - // clang-format off - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, - 20, 21, - 30, 31}); - test_case.add_input({0, 1, - 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, - 20, 21, - - 20, 21, - 30, 31}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_int64) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i64, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_uint8) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u8, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_uint16) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u16, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_uint32) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_axis_0_uint64) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u64, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_4d_indices_axis_0_uint8) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2, 3, 4}; - Shape out_shape{2, 2, 3, 4, 2}; - auto P = make_shared(element::u8, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, - 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2}); - test_case.add_expected_output( - out_shape, - {10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, - 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, - 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, - 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31, 10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_4d_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2, 3, 4}; - Shape out_shape{2, 2, 3, 4, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - - test_case.add_input({0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2}); - test_case.add_expected_output( - out_shape, - { 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_3d_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 3, 4}; - Shape out_shape{2, 3, 4, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - test_case.add_input( - {0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2, - - 0, 1, 1, 2, - 0, 1, 1, 2, - 0, 1, 1, 2}); - test_case.add_expected_output( - out_shape, {1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f, - - 1.0f, 1.1f, - 2.0f, 2.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_1d_int32) { - Shape data_shape{3}; - Shape indices_shape{2}; - Shape out_shape{2}; - auto P = make_shared(element::i32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - // clang-format off - test_case.add_input({1, 2, 3}); - test_case.add_input({2, 0}); - test_case.add_expected_output(out_shape, {3, 1}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_2d_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.add_input({0, 1, 1, 2}); - // clang-format off - test_case.add_expected_output(out_shape, - {1.0f, 1.1f, - 2.0f, 2.1f, - - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_2d_negative_and_positive_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - - // clang-format off - test_case.add_input({1.0f, 1.1f, - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - - test_case.add_input({0, -2, 1, 2}); - - // clang-format off - test_case.add_expected_output(out_shape, - {1.0f, 1.1f, - 2.0f, 2.1f, - - 2.0f, 2.1f, - 3.0f, 3.1f}); - // clang-format on - - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_1d_indices_axis_0_1d_input) { - Shape data_shape{3}; - Shape indices_shape{2}; - Shape out_shape{2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({1.0f, 2.0f, 3.0f}); - test_case.add_input({1, 0}); - test_case.add_expected_output(out_shape, {2.0f, 1.0f}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_scalar_indices_axis_0_2d_input) { - Shape data_shape{3, 2}; - Shape indices_shape{}; - Shape out_shape{2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({1.0f, 1.1f, 2.0f, 2.1f, 3.0f, 3.1f}); - test_case.add_input({1}); - test_case.add_expected_output(out_shape, {2.0f, 2.1f}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_2d_indices_axis_1_2d_input) { - Shape data_shape{3, 3}; - Shape indices_shape{1, 2}; - Shape out_shape{3, 1, 2}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {1}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - - // clang-format off - test_case.add_input({1.0f, 1.1f, 1.2f, - 2.0f, 2.1f, 2.2f, - 3.0f, 3.1f, 3.2f}); - // clang-format on - test_case.add_input({0, 2}); - - // clang-format off - test_case.add_expected_output(out_shape, {1.0f, 1.2f, - 2.0f, 2.2f, - 3.0f, 3.2f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_1d_indices_axis_2_4d_input) { - Shape data_shape{2, 2, 3, 3}; - Shape indices_shape{2}; - Shape out_shape{2, 2, 2, 3}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {2}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - // clang-format off - test_case.add_input({ 1.0f, 1.1f, 1.2f, - 2.0f, 2.1f, 2.2f, - 3.0f, 3.1f, 3.2f, - - 11.0f, 11.1f, 11.2f, - 12.0f, 12.1f, 12.2f, - 13.0f, 13.1f, 13.2f, - - - 101.0f, 101.1f, 101.2f, - 102.0f, 102.1f, 102.2f, - 103.0f, 103.1f, 103.2f, - - 111.0f, 111.1f, 111.2f, - 112.0f, 112.1f, 112.2f, - 113.0f, 113.1f, 113.2f}); - // clang-format on - test_case.add_input({0, 2}); - // clang-format off - test_case.add_expected_output( - out_shape, { 1.0f, 1.1f, 1.2f, - 3.0f, 3.1f, 3.2f, - - 11.0f, 11.1f, 11.2f, - 13.0f, 13.1f, 13.2f, - - - 101.0f, 101.1f, 101.2f, - 103.0f, 103.1f, 103.2f, - - 111.0f, 111.1f, 111.2f, - 113.0f, 113.1f, 113.2f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_scalar_indices_axis_1_2d_input) { - Shape data_shape{3, 3}; - Shape indices_shape{}; - Shape out_shape{3}; - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {1}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f, 3.0f, 3.1f, 3.2f}); - test_case.add_input({0}); - test_case.add_expected_output(out_shape, {1.0f, 2.0f, 3.0f}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_int8) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i8, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_int16) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i16, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_int32) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - // clang-format off - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, - 20, 21, - 30, 31}); - test_case.add_input({0, 1, - 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, - 20, 21, - - 20, 21, - 30, 31}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_int64) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::i64, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_uint8) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u8, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_uint16) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u16, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_uint32) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_uint64) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::u64, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({10, 11, 20, 21, 30, 31}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {10, 11, 20, 21, 20, 21, 30, 31}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_axis_0_bool) { - Shape data_shape{3, 2}; - Shape indices_shape{2, 2}; - Shape out_shape{2, 2, 2}; - auto P = make_shared(element::boolean, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {0}); - auto G = make_shared(P, I, A); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - test_case.add_input({1, 1, 1, 0, 0, 1}); - test_case.add_input({0, 1, 1, 2}); - test_case.add_expected_output(out_shape, {1, 1, 1, 0, 1, 0, 0, 1}); - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_data_int32_3d_indices_axis_1_batch_dims_1) { - Shape data_shape{2, 3}; - Shape indices_shape{2, 2, 2}; - Shape out_shape{2, 2, 2}; - int64_t batch_dims = 1; - int64_t axis = 1; - - auto P = make_shared(element::i32, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {axis}); - auto G = make_shared(P, I, A, batch_dims); - auto f = make_shared(G, ParameterVector{P, I}); - - // clang-format off - auto test_case = test::TestCase(f); - test_case.add_input({1, 2, 3, // batch 0 - 4, 5, 6}); // batch 1 - - test_case.add_input({0, 1, // batch 0 - 1, 2, - - 2, 0, // batch 1 - 1, 2}); - test_case.add_expected_output(out_shape, {1, 2, // batch 1 - 2, 3, - - 6, 4, // batch 1 - 5, 6}); - test_case.run(); - // clang-format on -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_data_int32_2d_indices_axis_1_batch_dims_1) { - Shape data_shape{2, 5}; - Shape indices_shape{2, 3}; - Shape out_shape{2, 3}; - int64_t batch_dims = 1; - int64_t axis = 1; - - auto P = make_shared(element::i32, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {axis}); - auto G = make_shared(P, I, A, batch_dims); - auto f = make_shared(G, ParameterVector{P, I}); - - // clang-format off - auto test_case = test::TestCase(f); - test_case.add_input({1, 2, 3, 4, 5, // batch 0 - 6, 7, 8, 9, 10}); // batch 1 - - test_case.add_input({0, 0, 4, // batch 0 - 4, 0, 0}); // batch 1 - test_case.add_expected_output(out_shape, {1, 1, 5, // batch 0 - 10, 6, 6}); // batch 1 - test_case.run(); - // clang-format on -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_data_int32_2d_indices_axis_1_negative_batch_dims) { - Shape data_shape{2, 5}; - Shape indices_shape{2, 3}; - Shape out_shape{2, 3}; - int64_t batch_dims = -1; - int64_t axis = 1; - - auto P = make_shared(element::i32, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {axis}); - auto G = make_shared(P, I, A, batch_dims); - auto f = make_shared(G, ParameterVector{P, I}); - - // clang-format off - auto test_case = test::TestCase(f); - test_case.add_input({1, 2, 3, 4, 5, // batch 0 - 6, 7, 8, 9, 10}); // batch 1 - - test_case.add_input({0, 0, 4, // batch 0 - 4, 0, 0}); // batch 1 - test_case.add_expected_output(out_shape, {1, 1, 5, // batch 0 - 10, 6, 6}); // batch 1 - test_case.run(); - // clang-format on -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_4d_data_axis_2_batch_dims_1_int32) { - Shape data_shape{2, 1, 5, 4}; - Shape indices_shape{2, 3}; - Shape out_shape{2, 1, 3, 4}; - int64_t batch_dims = 1; - int64_t axis = 2; - - auto P = make_shared(element::i32, data_shape); - auto I = make_shared(element::i64, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {axis}); - auto G = make_shared(P, I, A, batch_dims); - auto f = make_shared(G, ParameterVector{P, I}); - - // clang-format off - auto test_case = test::TestCase(f); - test_case.add_input({ - 1, 2, 3, 4, // first batch - 5, 6, 7, 8, - 9, 10, 11, 12, - 13, 14, 15, 16, - 17, 18, 19, 20, - - 21, 22, 23, 24, // second batch - 25, 26, 27, 28, - 29, 30, 31, 32, - 33, 34, 35, 36, - 37, 38, 39, 40 - }); - - test_case.add_input({ - 1, 2, 4, // first batch - 4, 3, 2 // second batch - }); - test_case.add_expected_output(out_shape, { - 5, 6, 7, 8, - 9, 10, 11, 12, - 17, 18, 19, 20, - - 37, 38, 39, 40, - 33, 34, 35, 36, - 29, 30, 31, 32 - }); - test_case.run(); - // clang-format on -} - -NGRAPH_TEST(${BACKEND_NAME}, gather_v7_3d_indices_axis_1_batch_dims_1) { - Shape data_shape{2, 5, 2}; - Shape indices_shape{2, 2, 3}; - Shape out_shape{2, 2, 3, 2}; - int64_t batch_dims = 1; - int64_t axis = 1; - - auto P = make_shared(element::f32, data_shape); - auto I = make_shared(element::i32, indices_shape); - auto A = op::Constant::create(element::i64, Shape{}, {axis}); - - auto G = make_shared(P, I, A, batch_dims); - auto f = make_shared(G, ParameterVector{P, I}); - - auto test_case = test::TestCase(f); - - // clang-format off - test_case.add_input({1.0f, 2.0f, - 3.0f, 4.0f, - 5.0f, 6.0f, - 7.0f, 8.0f, - 9.0f, 10.0f, - - 11.0f, 12.0f, - 13.0f, 14.0f, - 15.0f, 16.0f, - 17.0f, 18.0f, - 19.0f, 20.0f}); - - test_case.add_input({0, 0, 4, - 4, 0, 0, - - 1, 2, 4, - 4, 3, 2}); - test_case.add_expected_output({1.0f, 2.0f, - 1.0f, 2.0f, - 9.0f, 10.0f, - - 9.0f, 10.0f, - 1.0f, 2.0f, - 1.0f, 2.0f, - - - 13.0f, 14.0f, - 15.0f, 16.0f, - 19.0f, 20.0f, - - 19.0f, 20.0f, - 17.0f, 18.0f, - 15.0f, 16.0f}); - // clang-format on - test_case.run(MIN_FLOAT_TOLERANCE_BITS); -} diff --git a/ngraph/test/backend/pad.in.cpp b/ngraph/test/backend/pad.in.cpp deleted file mode 100644 index c506e843ab8..00000000000 --- a/ngraph/test/backend/pad.in.cpp +++ /dev/null @@ -1,1306 +0,0 @@ -// Copyright (C) 2018-2021 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include "engines_util/execute_tools.hpp" -#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/test_control.hpp" - -using namespace std; -using namespace ngraph; - -static string s_manifest = "${MANIFEST}"; - -namespace { -template -struct Params { - using Data = ::ngraph::test::NDArrayBase; - using Pads = ::ngraph::test::NDArrayBase; - - Params(Data input_data, - Pads pads_begin, - Pads pads_end, - Data expected_output, - op::PadMode pad_mode, - ValueType constant_value) - : input_data{std::move(input_data)}, - pads_begin{std::move(pads_begin)}, - pads_end{std::move(pads_end)}, - expected_output{std::move(expected_output)}, - pad_mode{pad_mode}, - use_const_value{true}, - constant_value{constant_value} {} - - Params(Data input_data, Pads pads_begin, Pads pads_end, Data expected_output, op::PadMode pad_mode) - : input_data{std::move(input_data)}, - pads_begin{std::move(pads_begin)}, - pads_end{std::move(pads_end)}, - expected_output{std::move(expected_output)}, - pad_mode{pad_mode} {} - - Data input_data; - Pads pads_begin; - Pads pads_end; - Data expected_output; - op::PadMode pad_mode; - bool use_const_value{false}; - ValueType constant_value{}; -}; - -class PadBackendTest : public ::testing::TestWithParam> { -public: - static void execute_test(const Params& params) { - const auto data = make_shared(element::f32, params.input_data.get_shape()); - - const auto pads_begin = - op::Constant::create(element::i64, params.pads_begin.get_shape(), params.pads_begin.get_vector()); - - const auto pads_end = - op::Constant::create(element::i64, params.pads_end.get_shape(), params.pads_end.get_vector()); - - auto f = [&] { - if (params.use_const_value) { - // pad_value should be used only in CONSTANT mode - const auto pad_val = op::Constant::create(element::f32, Shape{}, {params.constant_value}); - - return make_shared( - make_shared(data, pads_begin, pads_end, pad_val, params.pad_mode), - ParameterVector{data}); - } - - return make_shared(make_shared(data, pads_begin, pads_end, params.pad_mode), - ParameterVector{data}); - }(); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, params.input_data.get_shape()); - copy_data(a, params.input_data.get_vector()); - auto result = backend->create_tensor(element::f32, params.expected_output.get_shape()); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(params.expected_output.get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); - } -}; -} // namespace - -NGRAPH_TEST_P(${BACKEND_NAME}, PadBackendTest, PadBackendTestForSpec) { - execute_test(GetParam()); -} - -NGRAPH_INSTANTIATE_TEST_SUITE_P( - ${BACKEND_NAME}, - pad_1d_constant_const_value_provided, - PadBackendTest, - testing::Values( - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({4}), - test::NDArray({5}), - test::NDArray({2112, 2112, 2112, 2112, 1, 2, 3, 4, 5, 6, 2112, 2112, 2112, 2112, 2112}), - op::PadMode::CONSTANT, - 2112}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({4}), - test::NDArray({0}), - test::NDArray({2112, 2112, 2112, 2112, 1, 2, 3, 4, 5, 6}), - op::PadMode::CONSTANT, - 2112}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({0}), - test::NDArray({3}), - test::NDArray({1, 2, 3, 4, 5, 6, 2112, 2112, 2112}), - op::PadMode::CONSTANT, - 2112})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P( - ${BACKEND_NAME}, - pad_1d_constant_use_default_const, - PadBackendTest, - testing::Values(Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({4}), - test::NDArray({5}), - test::NDArray({0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0}), - op::PadMode::CONSTANT}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({4}), - test::NDArray({0}), - test::NDArray({0, 0, 0, 0, 1, 2, 3, 4, 5, 6}), - op::PadMode::CONSTANT}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({0}), - test::NDArray({3}), - test::NDArray({1, 2, 3, 4, 5, 6, 0, 0, 0}), - op::PadMode::CONSTANT})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P(${BACKEND_NAME}, - pad_2d_constant_const_value_provided, - PadBackendTest, - testing::Values(Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({1, 2}), - test::NDArray({3, 4}), - test::NDArray({ - {2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 1, 2, 2112, 2112, 2112, 2112}, - {2112, 2112, 3, 4, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112, 2112, 2112, 2112}, - }), - op::PadMode::CONSTANT, - 2112}, - Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({1, 2}), - test::NDArray({0, 0}), - test::NDArray({ - {2112, 2112, 2112, 2112}, - {2112, 2112, 1, 2}, - {2112, 2112, 3, 4}, - }), - op::PadMode::CONSTANT, - 2112}, - Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({0, 0}), - test::NDArray({1, 2}), - test::NDArray({ - {1, 2, 2112, 2112}, - {3, 4, 2112, 2112}, - {2112, 2112, 2112, 2112}, - }), - op::PadMode::CONSTANT, - 2112})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P(${BACKEND_NAME}, - pad_2d_constant_use_default_const, - PadBackendTest, - testing::Values(Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({1, 2}), - test::NDArray({3, 4}), - test::NDArray({ - {0, 0, 0, 0, 0, 0, 0, 0}, - {0, 0, 1, 2, 0, 0, 0, 0}, - {0, 0, 3, 4, 0, 0, 0, 0}, - {0, 0, 0, 0, 0, 0, 0, 0}, - {0, 0, 0, 0, 0, 0, 0, 0}, - {0, 0, 0, 0, 0, 0, 0, 0}, - }), - op::PadMode::CONSTANT}, - Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({1, 2}), - test::NDArray({0, 0}), - test::NDArray({ - {0, 0, 0, 0}, - {0, 0, 1, 2}, - {0, 0, 3, 4}, - }), - op::PadMode::CONSTANT}, - Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({0, 0}), - test::NDArray({1, 2}), - test::NDArray({ - {1, 2, 0, 0}, - {3, 4, 0, 0}, - {0, 0, 0, 0}, - }), - op::PadMode::CONSTANT})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P( - ${BACKEND_NAME}, - pad_1d_edge, - PadBackendTest, - testing::Values(Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({2}), - test::NDArray({3}), - test::NDArray({1, 1, 1, 2, 3, 4, 5, 6, 6, 6, 6}), - op::PadMode::EDGE}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({1}), - test::NDArray({0}), - test::NDArray({1, 1, 2, 3, 4, 5, 6}), - op::PadMode::EDGE}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({0}), - test::NDArray({2}), - test::NDArray({1, 2, 3, 4, 5, 6, 6, 6}), - op::PadMode::EDGE})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P(${BACKEND_NAME}, - pad_2d_edge, - PadBackendTest, - testing::Values(Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({1, 2}), - test::NDArray({2, 1}), - test::NDArray({ - {1, 1, 1, 2, 2}, - {1, 1, 1, 2, 2}, - {3, 3, 3, 4, 4}, - {3, 3, 3, 4, 4}, - {3, 3, 3, 4, 4}, - }), - op::PadMode::EDGE}, - Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({1, 2}), - test::NDArray({0, 0}), - test::NDArray({ - {1, 1, 1, 2}, - {1, 1, 1, 2}, - {3, 3, 3, 4}, - }), - op::PadMode::EDGE}, - Params{test::NDArray({ - {1, 2}, - {3, 4}, - }), - test::NDArray({0, 0}), - test::NDArray({2, 1}), - test::NDArray({ - {1, 2, 2}, - {3, 4, 4}, - {3, 4, 4}, - {3, 4, 4}, - }), - op::PadMode::EDGE})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P( - ${BACKEND_NAME}, - pad_1d_reflect, - PadBackendTest, - testing::Values(Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({2}), - test::NDArray({3}), - test::NDArray({3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3}), - op::PadMode::REFLECT}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({1}), - test::NDArray({0}), - test::NDArray({2, 1, 2, 3, 4, 5, 6}), - op::PadMode::REFLECT}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({0}), - test::NDArray({2}), - test::NDArray({1, 2, 3, 4, 5, 6, 5, 4}), - op::PadMode::REFLECT})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P(${BACKEND_NAME}, - pad_2d_reflect, - PadBackendTest, - testing::Values(Params{test::NDArray({ - {1, 2, 3}, - {4, 5, 6}, - {7, 8, 9}, - }), - test::NDArray({1, 2}), - test::NDArray({2, 1}), - test::NDArray({ - {6, 5, 4, 5, 6, 5}, - {3, 2, 1, 2, 3, 2}, - {6, 5, 4, 5, 6, 5}, - {9, 8, 7, 8, 9, 8}, - {6, 5, 4, 5, 6, 5}, - {3, 2, 1, 2, 3, 2}, - }), - op::PadMode::REFLECT}, - Params{test::NDArray({ - {1, 2, 3}, - {4, 5, 6}, - {7, 8, 9}, - }), - test::NDArray({1, 2}), - test::NDArray({0, 0}), - test::NDArray({ - {6, 5, 4, 5, 6}, - {3, 2, 1, 2, 3}, - {6, 5, 4, 5, 6}, - {9, 8, 7, 8, 9}, - }), - op::PadMode::REFLECT}, - Params{test::NDArray({ - {1, 2, 3}, - {4, 5, 6}, - {7, 8, 9}, - }), - test::NDArray({0, 0}), - test::NDArray({2, 1}), - test::NDArray({ - {1, 2, 3, 2}, - {4, 5, 6, 5}, - {7, 8, 9, 8}, - {4, 5, 6, 5}, - {1, 2, 3, 2}, - }), - op::PadMode::REFLECT})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P( - ${BACKEND_NAME}, - pad_1d_symmetric, - PadBackendTest, - testing::Values(Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({2}), - test::NDArray({3}), - test::NDArray({2, 1, 1, 2, 3, 4, 5, 6, 6, 5, 4}), - op::PadMode::SYMMETRIC}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({1}), - test::NDArray({0}), - test::NDArray({1, 1, 2, 3, 4, 5, 6}), - op::PadMode::SYMMETRIC}, - Params{test::NDArray({1, 2, 3, 4, 5, 6}), - test::NDArray({0}), - test::NDArray({2}), - test::NDArray({1, 2, 3, 4, 5, 6, 6, 5}), - op::PadMode::SYMMETRIC})); - -NGRAPH_INSTANTIATE_TEST_SUITE_P(${BACKEND_NAME}, - pad_2d_symmetric, - PadBackendTest, - testing::Values(Params{test::NDArray({ - {1, 2, 3}, - {4, 5, 6}, - {7, 8, 9}, - }), - test::NDArray({1, 2}), - test::NDArray({2, 1}), - test::NDArray({ - {2, 1, 1, 2, 3, 3}, - {2, 1, 1, 2, 3, 3}, - {5, 4, 4, 5, 6, 6}, - {8, 7, 7, 8, 9, 9}, - {8, 7, 7, 8, 9, 9}, - {5, 4, 4, 5, 6, 6}, - }), - op::PadMode::SYMMETRIC}, - Params{test::NDArray({ - {1, 2, 3}, - {4, 5, 6}, - {7, 8, 9}, - }), - test::NDArray({1, 2}), - test::NDArray({0, 0}), - test::NDArray({ - {2, 1, 1, 2, 3}, - {2, 1, 1, 2, 3}, - {5, 4, 4, 5, 6}, - {8, 7, 7, 8, 9}, - - }), - op::PadMode::SYMMETRIC}, - Params{test::NDArray({ - {1, 2, 3}, - {4, 5, 6}, - {7, 8, 9}, - }), - test::NDArray({0, 0}), - test::NDArray({2, 1}), - test::NDArray({ - {1, 2, 3, 3}, - {4, 5, 6, 6}, - {7, 8, 9, 9}, - {7, 8, 9, 9}, - {4, 5, 6, 6}, - }), - op::PadMode::SYMMETRIC})); - -NGRAPH_TEST(${BACKEND_NAME}, pad_to_large_symmetric_padding) { - const auto params_to_large = Params{test::NDArray({ - {1, 2}, - {4, 5}, - }), - test::NDArray({0, 3}), - test::NDArray({0, 0}), - test::NDArray({ - {0, 0, 0, 0, 0}, - {0, 0, 0, 0, 0}, - }), - op::PadMode::SYMMETRIC}; - - EXPECT_ANY_THROW(PadBackendTest::execute_test(params_to_large)); - - const auto params_ok = Params{test::NDArray({ - {1, 2}, - {4, 5}, - }), - test::NDArray({0, 2}), - test::NDArray({0, 0}), - test::NDArray({ - {2, 1, 1, 2}, - {5, 4, 4, 5}, - }), - op::PadMode::SYMMETRIC}; - - EXPECT_NO_THROW(PadBackendTest::execute_test(params_ok)); -} -NGRAPH_TEST(${BACKEND_NAME}, pad_to_large_reflect_padding) { - const auto params_to_large = Params{test::NDArray({ - {1, 2}, - {4, 5}, - }), - test::NDArray({0, 2}), - test::NDArray({0, 0}), - test::NDArray({ - {0, 0, 0, 0}, - {0, 0, 0, 0}, - }), - op::PadMode::REFLECT}; - - EXPECT_ANY_THROW(PadBackendTest::execute_test(params_to_large)); - - const auto params_ok = Params{test::NDArray({ - {1, 2}, - {4, 5}, - }), - test::NDArray({0, 1}), - test::NDArray({0, 0}), - test::NDArray({ - {2, 1, 2}, - {5, 4, 5}, - }), - op::PadMode::REFLECT}; - - EXPECT_NO_THROW(PadBackendTest::execute_test(params_ok)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_exterior_1d) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {4}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {5}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{15}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f({2112, 2112, 2112, 2112, 1, 2, 3, 4, 5, 6, 2112, 2112, 2112, 2112, 2112}, - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_negative_exterior_1d) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {4}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {-2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{8}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE( - test::all_close_f({2112, 2112, 2112, 2112, 1, 2, 3, 4}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_negative_exterior_1d_check_limits) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {4}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {-7}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{3}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f({2112, 2112, 2112}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_edge_1d) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::EDGE), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{11}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE( - test::all_close_f({1, 1, 1, 2, 3, 4, 5, 6, 6, 6, 6}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_edge_1d_top_neg) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {-3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::EDGE), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{5}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f({1, 1, 1, 2, 3}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_edge_1d_top_neg_bigger_than_tensor) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {-7}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::EDGE), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{1}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f({1}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_edge_1d_bottom_neg) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {-2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::EDGE), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{7}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f({3, 4, 5, 6, 6, 6, 6}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_edge_1d_bottom_neg_bigger_than_tensor) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {-7}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::EDGE), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{2}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f({6, 6}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_edge_2d) { - const Shape data_shape{3, 4}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {2, 3}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {1, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::EDGE), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12})); - auto result = backend->create_tensor(element::f32, Shape{6, 9}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{1, 1, 1, 1, 2, 3, 4, 4, 4}, - {1, 1, 1, 1, 2, 3, 4, 4, 4}, - {1, 1, 1, 1, 2, 3, 4, 4, 4}, - {5, 5, 5, 5, 6, 7, 8, 8, 8}, - {9, 9, 9, 9, 10, 11, 12, 12, 12}, - {9, 9, 9, 9, 10, 11, 12, 12, 12}}) - .get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_edge_2d_with_neg) { - const Shape data_shape{3, 4}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {2, -1}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {1, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::EDGE), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12})); - auto result = backend->create_tensor(element::f32, Shape{6, 5}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{2, 3, 4, 4, 4}, - {2, 3, 4, 4, 4}, - {2, 3, 4, 4, 4}, - {6, 7, 8, 8, 8}, - {10, 11, 12, 12, 12}, - {10, 11, 12, 12, 12}}) - .get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_reflect_1d) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{11}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(std::vector({3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_reflect_1d_top_neg) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {-3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{5}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE( - test::all_close_f(std::vector({3, 2, 1, 2, 3}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_reflect_1d_top_neg_bigger_than_tensor) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {-7}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{1}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(std::vector({3}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_reflect_1d_bottom_neg) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {-2}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{7}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(std::vector({3, 4, 5, 6, 5, 4, 3}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_reflect_1d_bottom_neg_bigger_than_tensor) { - const Shape data_shape{6}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {-7}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {3}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3, 4, 5, 6})); - auto result = backend->create_tensor(element::f32, Shape{2}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(std::vector({4, 3}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, DISABLED_pad_reflect_1d_multi_reflect) { - const Shape data_shape{3}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{1}, {10}); - const auto pads_end = op::Constant::create(element::i64, Shape{1}, {9}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, std::vector({1, 2, 3})); - auto result = backend->create_tensor(element::f32, Shape{22}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE( - test::all_close_f(std::vector({3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_reflect_2d) { - const Shape data_shape{3, 4}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {2, 3}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {1, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, test::NDArray({{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}).get_vector()); - auto result = backend->create_tensor(element::f32, Shape{6, 9}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{12, 11, 10, 9, 10, 11, 12, 11, 10}, - {8, 7, 6, 5, 6, 7, 8, 7, 6}, - {4, 3, 2, 1, 2, 3, 4, 3, 2}, - {8, 7, 6, 5, 6, 7, 8, 7, 6}, - {12, 11, 10, 9, 10, 11, 12, 11, 10}, - {8, 7, 6, 5, 6, 7, 8, 7, 6}}) - .get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_reflect_2d_with_neg) { - const Shape data_shape{3, 4}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {2, -1}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {1, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::REFLECT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, test::NDArray({{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}).get_vector()); - auto result = backend->create_tensor(element::f32, Shape{6, 5}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{10, 11, 12, 11, 10}, - {6, 7, 8, 7, 6}, - {2, 3, 4, 3, 2}, - {6, 7, 8, 7, 6}, - {10, 11, 12, 11, 10}, - {6, 7, 8, 7, 6}}) - .get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_negative_exterior_2d) { - const Shape data_shape{2, 3}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {1, -1}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {2, 0}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {9}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, test::NDArray({{1, 2, 3}, {4, 5, 6}}).get_vector()); - auto result = backend->create_tensor(element::f32, Shape{5, 2}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{9, 9}, {2, 3}, {5, 6}, {9, 9}, {9, 9}}).get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_negative_exterior_2d_all_negative) { - const Shape data_shape{3, 3}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {-1, -1}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {-1, -1}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {9}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, test::NDArray({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}).get_vector()); - auto result = backend->create_tensor(element::f32, Shape{1, 1}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{5}}).get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_exterior_2d_0x0) { - const Shape data_shape{0, 0}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {2, 3}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {3, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - auto result = backend->create_tensor(element::f32, Shape{5, 5}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}}) - .get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_exterior_2d_0x3) { - const Shape data_shape{0, 3}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {2, 1}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {3, 1}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - auto result = backend->create_tensor(element::f32, Shape{5, 5}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}}) - .get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_exterior_2d_3x0) { - const Shape data_shape{3, 0}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {1, 3}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {1, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - auto result = backend->create_tensor(element::f32, Shape{5, 5}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(test::NDArray({{2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}, - {2112, 2112, 2112, 2112, 2112}}) - .get_vector(), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_exterior_4d_1x2x2x2) { - const Shape data_shape{1, 2, 2, 2}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{4}, {0, 0, 1, 1}); - const auto pads_end = op::Constant::create(element::i64, Shape{4}, {0, 0, 1, 1}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {42}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - // clang-format off - copy_data(a, test::NDArray( - { - { - { - {0.0f, 0.0f}, - {0.0f, 0.0f} - }, - { - {0.0f, 0.0f}, - {0.0f, 0.0f} - } - } - }).get_vector()); - // clang-format on - auto result = backend->create_tensor(element::f32, Shape{1, 2, 4, 4}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - // clang-format off - EXPECT_TRUE(test::all_close_f((test::NDArray( - { - { - { - {42.0f, 42.0f, 42.0f, 42.0f}, - {42.0f, 0.0f, 0.0f, 42.0f}, - {42.0f, 0.0f, 0.0f, 42.0f}, - {42.0f, 42.0f, 42.0f, 42.0f} - }, - { - {42.0f, 42.0f, 42.0f, 42.0f}, - {42.0f, 0.0f, 0.0f, 42.0f}, - {42.0f, 0.0f, 0.0f, 42.0f}, - {42.0f, 42.0f, 42.0f, 42.0f} - } - } - }).get_vector()), - read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); - // clang-format on -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_negative_exterior_4d) { - const Shape data_shape{1, 3, 2, 2}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{4}, {0, -1, 1, 1}); - const auto pads_end = op::Constant::create(element::i64, Shape{4}, {0, -1, 1, 1}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {42}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - // clang-format off - copy_data(a, test::NDArray( - { - { - { - {0.0f, 0.0f}, - {0.0f, 0.0f} - }, - { - {1.0f, 1.0f}, - {1.0f, 1.0f} - }, - { - {2.0f, 2.0f}, - {2.0f, 2.0f} - } - } - }).get_vector()); - // clang-format on - - auto result = backend->create_tensor(element::f32, Shape{1, 1, 4, 4}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - - // clang-format off - EXPECT_TRUE(test::all_close_f((test::NDArray( - { - { - { - {42.0f, 42.0f, 42.0f, 42.0f}, - {42.0f, 1.0f, 1.0f, 42.0f}, - {42.0f, 1.0f, 1.0f, 42.0f}, - {42.0f, 42.0f, 42.0f, 42.0f} - } - } - }).get_vector()), - read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); - // clang-format on -} - -// This test covers the case with multiple image and with asymetric pad -// bug has been found on nvGPU side now covered by this test -NGRAPH_TEST(${BACKEND_NAME}, pad_2channel_2image_asym) { - const Shape data_shape{2, 2, 4, 4}; - const auto window_movement_strides = Strides{2, 2}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{4}, {0, 0, 0, 0}); - const auto pads_end = op::Constant::create(element::i64, Shape{4}, {0, 0, 2, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {42}); - - auto f = make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::CONSTANT), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, - test::NDArray({{{{0, 1, 0, 2}, // img 0 chan 0 - {0, 3, 2, 0}, - {2, 0, 0, 0}, - {0, 2, 1, 0}}, - - {{0, 0, 0, 2}, // img 0 chan 1 - {0, 2, 3, 0}, - {2, 0, 1, 0}, - {2, 0, 0, 0}}}, - - {{{0, 2, 1, 1}, // img 1 chan 0 - {0, 0, 2, 0}, - {0, 0, 1, 2}, - {0, 0, 0, 0}}, - - {{2, 1, 0, 0}, // img 1 chan 1 - {0, 2, 0, 0}, - {1, 1, 2, 0}, - {1, 0, 0, 0}}}}) - .get_vector()); - - auto result = backend->create_tensor(element::f32, Shape{2, 2, 6, 6}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - - EXPECT_TRUE(test::all_close_f((test::NDArray({{{{0, 1, 0, 2, 42, 42}, // img 0 chan 0 - {0, 3, 2, 0, 42, 42}, - {2, 0, 0, 0, 42, 42}, - {0, 2, 1, 0, 42, 42}, - {42, 42, 42, 42, 42, 42}, - {42, 42, 42, 42, 42, 42}}, - - {{0, 0, 0, 2, 42, 42}, // img 1 chan 0 - {0, 2, 3, 0, 42, 42}, - {2, 0, 1, 0, 42, 42}, - {2, 0, 0, 0, 42, 42}, - {42, 42, 42, 42, 42, 42}, - {42, 42, 42, 42, 42, 42}}}, - - {{{0, 2, 1, 1, 42, 42}, // img 1 chan 0 - {0, 0, 2, 0, 42, 42}, - {0, 0, 1, 2, 42, 42}, - {0, 0, 0, 0, 42, 42}, - {42, 42, 42, 42, 42, 42}, - {42, 42, 42, 42, 42, 42}}, - - {{2, 1, 0, 0, 42, 42}, // img 1 chan 1 - {0, 2, 0, 0, 42, 42}, - {1, 1, 2, 0, 42, 42}, - {1, 0, 0, 0, 42, 42}, - {42, 42, 42, 42, 42, 42}, - {42, 42, 42, 42, 42, 42}}}}) - .get_vector()), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, pad_symmetric) { - const Shape data_shape{2, 3}; - const auto data = make_shared(element::f32, data_shape); - - const auto pads_begin = op::Constant::create(element::i64, Shape{2}, {1, 2}); - const auto pads_end = op::Constant::create(element::i64, Shape{2}, {1, 2}); - const auto pad_val = op::Constant::create(element::f32, Shape{}, {2112}); - - auto f = - make_shared(make_shared(data, pads_begin, pads_end, pad_val, op::PadMode::SYMMETRIC), - ParameterVector{data}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, data_shape); - copy_data(a, test::NDArray({{1, 2, 3}, {4, 5, 6}}).get_vector()); - auto result = backend->create_tensor(element::f32, Shape{4, 7}); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f( - (test::NDArray( - {{2, 1, 1, 2, 3, 3, 2}, {2, 1, 1, 2, 3, 3, 2}, {5, 4, 4, 5, 6, 6, 5}, {5, 4, 4, 5, 6, 6, 5}}) - .get_vector()), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -}