diff --git a/docs/template_plugin/tests/functional/op_reference/broadcast.cpp b/docs/template_plugin/tests/functional/op_reference/broadcast.cpp new file mode 100644 index 00000000000..befdcd44e67 --- /dev/null +++ b/docs/template_plugin/tests/functional/op_reference/broadcast.cpp @@ -0,0 +1,528 @@ +// Copyright (C) 2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "openvino/opsets/opset1.hpp" +#include "openvino/opsets/opset3.hpp" +#include "base_reference_test.hpp" + +using namespace reference_tests; +using namespace ov; + +namespace { +struct BroadcastParams { + BroadcastParams( + const Tensor& dataTensor, const Tensor& targetShapeTensor, + const Tensor& expectedTensor, const std::string& testcaseName = "") : + dataTensor(dataTensor), targetShapeTensor(targetShapeTensor), + expectedTensor(expectedTensor), testcaseName(testcaseName) {} + + Tensor dataTensor; + Tensor targetShapeTensor; + Tensor expectedTensor; + std::string testcaseName; +}; + +class ReferenceBroadcastTest : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.dataTensor.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 << "_tsType=" << param.targetShapeTensor.type; + result << "_tsShape=" << param.targetShapeTensor.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 BroadcastParams& params) { + const auto A = std::make_shared(params.dataTensor.type, params.dataTensor.shape); + const auto f = std::make_shared( + std::make_shared(A, opset1::Constant::create(params.targetShapeTensor.type, + params.targetShapeTensor.shape, + params.targetShapeTensor.data.data())), + ParameterVector{A}); + return f; + } +}; + +TEST_P(ReferenceBroadcastTest, CompareWithRefs) { + Exec(); +} + +class ReferenceBroadcastTestV3 : public ReferenceBroadcastTest { +private: + static std::shared_ptr CreateFunction(const BroadcastParams& params) { + const auto A = std::make_shared(params.dataTensor.type, params.dataTensor.shape); + const auto f = std::make_shared( + std::make_shared(A, opset1::Constant::create(params.targetShapeTensor.type, + params.targetShapeTensor.shape, + params.targetShapeTensor.data.data())), + ParameterVector{A}); + return f; + } +}; + +TEST_P(ReferenceBroadcastTestV3, CompareWithRefs) { + Exec(); +} + +struct BroadcastParamsExplicitAxis : BroadcastParams { + BroadcastParamsExplicitAxis( + const Tensor& dataTensor, const Tensor& targetShapeTensor, const Tensor& axesMappingTensor, + const Tensor& expectedTensor, const std::string& testcaseName = "") : + BroadcastParams(dataTensor, targetShapeTensor, expectedTensor, testcaseName), + axesMappingTensor(axesMappingTensor) {} + + Tensor axesMappingTensor; +}; + +class ReferenceBroadcastTestExplicitAxis : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.dataTensor.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 << "_tsType=" << param.targetShapeTensor.type; + result << "_tsShape=" << param.targetShapeTensor.shape; + result << "_amType=" << param.axesMappingTensor.type; + result << "_amShape=" << param.axesMappingTensor.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 BroadcastParamsExplicitAxis& params) { + const auto A = std::make_shared(params.dataTensor.type, params.dataTensor.shape); + const auto f = std::make_shared( + std::make_shared(A, + opset1::Constant::create(params.targetShapeTensor.type, + params.targetShapeTensor.shape, + params.targetShapeTensor.data.data()), + opset1::Constant::create(params.axesMappingTensor.type, + params.axesMappingTensor.shape, + params.axesMappingTensor.data.data())), + ParameterVector{A}); + return f; + } +}; + +TEST_P(ReferenceBroadcastTestExplicitAxis, CompareWithRefs) { + Exec(); +} + +struct BroadcastParamsTestHelper { + BroadcastParamsTestHelper( + const Shape& shapeA, + const Shape& shapeR, + const AxisSet& axes, const std::string& testcaseName = "") : + shapeA(shapeA), shapeR(shapeR), + axes(axes), testcaseName(testcaseName) {} + + Shape shapeA; + Shape shapeR; + AxisSet axes; + std::string testcaseName; +}; + +class ReferenceBroadcastTestTestHelper : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + std::vector inpData(shape_size(params.shapeA)); + iota(inpData.begin(), inpData.end(), 1.f); + const auto refA = CreateTensor(params.shapeA, element::f32, inpData); + inputData = {refA}; + } + + void SetUp1() { + auto params = GetParam(); + function = CreateFunction(params); + std::vector inpData(shape_size(params.shapeA)); + iota(inpData.begin(), inpData.end(), 1.f); + const auto wrkA = CreateTensor(params.shapeA, element::f32, inpData); + inputData = {wrkA}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aShape=" << param.shapeA; + result << "_rShape=" << param.shapeR; + if (param.testcaseName != "") { + result << "_axes=" << param.axes; + result << "_=" << param.testcaseName; + } else { + result << "_axes=" << param.axes; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const BroadcastParamsTestHelper& params) { + const auto A = std::make_shared(element::f32, params.shapeA); + const auto shape_const = opset1::Constant::create(element::u64, Shape{params.shapeR.size()}, params.shapeR); + std::shared_ptr broadcast; + if (params.axes.size() > 0) { + auto axes_const = opset1::Constant::create(element::i64, Shape{params.axes.size()}, params.axes.to_vector()); + broadcast = std::make_shared(A, shape_const, axes_const); + } else { + broadcast = std::make_shared(A, shape_const); + } + auto f = std::make_shared(broadcast, ParameterVector{A}); + return f; + } + +protected: + void GenerateRefOutData() { + actualOutData.clear(); + for (const auto &output : executableNetwork.outputs()) { + actualOutData.emplace_back(inferRequest.get_tensor(output)); + } + refOutData = actualOutData; + } +}; + +TEST_P(ReferenceBroadcastTestTestHelper, CompareWithRefs) { + LoadNetwork(); + FillInputs(); + Infer(); + GenerateRefOutData(); + SetUp1(); + Exec(); +} + +class ReferenceBroadcastTestExplicitAxisReversed : public ReferenceBroadcastTestExplicitAxis { +private: + static std::shared_ptr CreateFunction(const BroadcastParamsExplicitAxis& params) { + const auto A = std::make_shared(params.dataTensor.type, params.dataTensor.shape); + auto broadcast = std::make_shared( + A, + opset1::Constant::create(params.targetShapeTensor.type, + params.targetShapeTensor.shape, + params.targetShapeTensor.data.data()), + opset1::Constant::create(params.axesMappingTensor.type, + params.axesMappingTensor.shape, + params.axesMappingTensor.data.data())); + auto reverse = std::make_shared(broadcast, + opset1::Constant::create(element::i64, {1}, {1}), + opset1::Reverse::Mode::INDEX); + auto f = std::make_shared(NodeVector{reverse}, ParameterVector{A}); + return f; + } +}; + +TEST_P(ReferenceBroadcastTestExplicitAxisReversed, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParams() { + using T = typename element_type_traits::value_type; + std::vector params { + BroadcastParams( + Tensor(ET, {}, std::vector{6}), + Tensor(element::u64, {1}, std::vector{4}), + Tensor(ET, {4}, std::vector{6, 6, 6, 6}), + "broadcast_scalar_vector"), + BroadcastParams( + Tensor(ET, {}, std::vector{6}), + Tensor(element::u64, {2}, std::vector{2, 2}), + Tensor(ET, {2, 2}, std::vector{6, 6, 6, 6}), + "broadcast_scalar_matrix"), + BroadcastParams( + Tensor(ET, {}, std::vector{6}), + Tensor(element::u64, {3}, std::vector{2, 2, 2}), + Tensor(ET, {2, 2, 2}, std::vector{6, 6, 6, 6, 6, 6, 6, 6}), + "broadcast_scalar_tensor"), + BroadcastParams( + Tensor(ET, {2, 2, 2}, std::vector{2, 4, 6, 8, 16, 32, 64, 127}), + Tensor(element::u64, {3}, std::vector{2, 2, 2}), + Tensor(ET, {2, 2, 2}, std::vector{2, 4, 6, 8, 16, 32, 64, 127}), + "broadcast_trivial"), + BroadcastParams( + Tensor(ET, {2, 2}, std::vector{1, 2, 3, 4}), + Tensor(element::u64, {3}, std::vector{2, 2, 2}), + Tensor(ET, {2, 2, 2}, std::vector{1, 2, 3, 4, 1, 2, 3, 4}), + "broadcast_matrix_0"), + }; + return params; +} + +std::vector generateCombinedParams() { + const std::vector> generatedParams { + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Broadcast_With_Hardcoded_Refs, ReferenceBroadcastTest, + testing::ValuesIn(generateCombinedParams()), ReferenceBroadcastTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_Broadcast_With_Hardcoded_Refs, ReferenceBroadcastTestV3, + testing::ValuesIn(generateCombinedParams()), ReferenceBroadcastTest::getTestCaseName); + +template +std::vector generateParamsExplicitAxis() { + using T = typename element_type_traits::value_type; + std::vector params { + BroadcastParamsExplicitAxis( + Tensor(ET, {}, std::vector{6}), + Tensor(element::u64, {2}, std::vector{1, 2}), + Tensor(element::i64, {1}, std::vector{0}), + Tensor(ET, {1, 2}, std::vector{6, 6}), + "broadcast_scalar_vector_explicit_axis_0"), + BroadcastParamsExplicitAxis( + Tensor(ET, {3}, std::vector{1, 2, 3}), + Tensor(element::u64, {2}, std::vector{3, 4}), + Tensor(element::i64, {1}, std::vector{0}), + Tensor(ET, {3, 4}, std::vector{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3}), + "broadcast_vector_colwise"), + BroadcastParamsExplicitAxis( + Tensor(ET, {4}, std::vector{1, 2, 3, 4}), + Tensor(element::u64, {2}, std::vector{3, 4}), + Tensor(element::i64, {1}, std::vector{1}), + Tensor(ET, {3, 4}, std::vector{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}), + "broadcast_vector_rowwise"), + BroadcastParamsExplicitAxis( + Tensor(ET, {1}, std::vector{4}), + Tensor(element::u64, {2}, std::vector{3, 1}), + Tensor(element::i64, {1}, std::vector{1}), + Tensor(ET, {3, 1}, std::vector{4, 4, 4}), + "broadcast_scalar_to_matrix"), + BroadcastParamsExplicitAxis( + Tensor(ET, {2, 2}, std::vector{1, 2, 3, 4}), + Tensor(element::u64, {3}, std::vector{2, 2, 2}), + Tensor(element::i64, {2}, std::vector{0, 2}), + Tensor(ET, {2, 2, 2}, std::vector{1, 2, 1, 2, 3, 4, 3, 4}), + "broadcast_matrix_1"), + BroadcastParamsExplicitAxis( + Tensor(ET, {2, 2}, std::vector{1, 2, 3, 4}), + Tensor(element::u64, {3}, std::vector{2, 2, 2}), + Tensor(element::i64, {2}, std::vector{0, 1}), + Tensor(ET, {2, 2, 2}, std::vector{1, 1, 2, 2, 3, 3, 4, 4}), + "broadcast_matrix_2"), + }; + return params; +} + +std::vector generateCombinedParamsExplicitAxis() { + const std::vector> generatedParams { + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + generateParamsExplicitAxis(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Broadcast_With_Hardcoded_Refs, ReferenceBroadcastTestExplicitAxis, + testing::ValuesIn(generateCombinedParamsExplicitAxis()), ReferenceBroadcastTestExplicitAxis::getTestCaseName); + +std::vector generateParamsTestHelper() { + std::vector params { + BroadcastParamsTestHelper( + {2}, + {3, 2, 4}, + {1}, + "broadcast_algo_vector_middle"), + BroadcastParamsTestHelper( + {2}, + {3, 2}, + {1}, + "broadcast_algo_vector_forward_2"), + BroadcastParamsTestHelper( + {2}, + {4, 3, 2}, + {2}, + "broadcast_algo_vector_forward_3"), + BroadcastParamsTestHelper( + {2}, + {5, 4, 3, 2}, + {3}, + "broadcast_algo_vector_forward_4"), + BroadcastParamsTestHelper( + {}, + {5, 4, 3, 2}, + {}, + "broadcast_algo_scalar"), + BroadcastParamsTestHelper( + {2}, + {2, 3}, + {0}, + "broadcast_algo_vector_backward_2"), + BroadcastParamsTestHelper( + {2}, + {2, 3, 4}, + {0}, + "broadcast_algo_vector_backward_3"), + BroadcastParamsTestHelper( + {2}, + {2, 3, 4, 5}, + {0}, + "broadcast_algo_vector_backward_4"), + BroadcastParamsTestHelper( + {4, 5}, + {2, 3, 4, 5}, + {2, 3}, + "broadcast_algo_matrix_backward_4"), + BroadcastParamsTestHelper( + {3, 5}, + {2, 3, 4, 5}, + {1, 3}, + "broadcast_algo_matrix_stride_1"), + BroadcastParamsTestHelper( + {3, 4}, + {2, 3, 4, 5}, + {1, 2}, + "broadcast_algo_matrix_stride_2"), + BroadcastParamsTestHelper( + {2, 4}, + {2, 3, 4, 5}, + {0, 2}, + "broadcast_algo_matrix_stride_3"), + BroadcastParamsTestHelper( + {2, 3, 4}, + {5, 2, 3, 4}, + {1, 2, 3}, + "broadcast_algo_3d_backward"), + BroadcastParamsTestHelper( + {2, 3, 4}, + {2, 5, 3, 4}, + {0, 2, 3}, + "broadcast_algo_3d_stride_1"), + BroadcastParamsTestHelper( + {2, 3, 4}, + {2, 3, 5, 4}, + {0, 1, 3}, + "broadcast_algo_3d_stride_2"), + BroadcastParamsTestHelper( + {3, 1}, + {2, 3, 3}, + {1, 2}, + "broadcast_algo_3d_diffrent_rank"), + BroadcastParamsTestHelper( + {2, 3, 1, 1}, + {2, 3, 4, 5}, + {0, 1, 2, 3}, + "broadcast_algo_4d_same_rank"), + }; + return params; +} + +std::vector generateCombinedParamsTestHelper() { + const std::vector> generatedParams { + generateParamsTestHelper(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Broadcast_With_Hardcoded_Refs, ReferenceBroadcastTestTestHelper, + testing::ValuesIn(generateCombinedParamsTestHelper()), ReferenceBroadcastTestTestHelper::getTestCaseName); + +template +std::vector generateParamsExplicitAxisReversed() { + using T = typename element_type_traits::value_type; + std::vector params { + BroadcastParamsExplicitAxis( + Tensor(ET, {4}, std::vector{1, 2, 3, 4}), + Tensor(element::u64, {2}, std::vector{3, 4}), + Tensor(element::i64, {1}, std::vector{1}), + Tensor(ET, {3, 4}, std::vector{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}), + "broadcast_vector_rowwise_reversed"), + }; + return params; +} + +std::vector generateCombinedParamsExplicitAxisReversed() { + const std::vector> generatedParams { + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + generateParamsExplicitAxisReversed(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Broadcast_With_Hardcoded_Refs, ReferenceBroadcastTestExplicitAxisReversed, + testing::ValuesIn(generateCombinedParamsExplicitAxisReversed()), ReferenceBroadcastTestExplicitAxis::getTestCaseName); +} // namespace \ No newline at end of file diff --git a/docs/template_plugin/tests/functional/op_reference/concat.cpp b/docs/template_plugin/tests/functional/op_reference/concat.cpp new file mode 100644 index 00000000000..be7ffefe8c7 --- /dev/null +++ b/docs/template_plugin/tests/functional/op_reference/concat.cpp @@ -0,0 +1,1433 @@ +// Copyright (C) 2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "openvino/opsets/opset1.hpp" +#include "base_reference_test.hpp" + +using namespace reference_tests; +using namespace ov; + +namespace { +struct ConcatParams { + ConcatParams( + const PartialShape& dynamicShape, + const Tensor& A, const Tensor& B, const Tensor& C, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + dynamicShape(dynamicShape), A(A), B(B), C(C), axis(axis), expected(expected), testcaseName(testcaseName) {} + + PartialShape dynamicShape; + Tensor A; + Tensor B; + Tensor C; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTest : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data, params.C.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "dynShape=" << param.dynamicShape; + result << "_aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_cType=" << param.C.type; + result << "_cShape=" << param.C.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParams& params) { + std::shared_ptr A, B, C; + if (params.dynamicShape.is_dynamic()) { + A = std::make_shared(params.A.type, params.dynamicShape); + B = std::make_shared(params.B.type, params.dynamicShape); + C = std::make_shared(params.C.type, params.dynamicShape); + } else { + A = std::make_shared(params.A.type, params.A.shape); + B = std::make_shared(params.B.type, params.B.shape); + C = std::make_shared(params.C.type, params.C.shape); + } + auto f = std::make_shared(std::make_shared(NodeVector{A, B, C}, params.axis), ParameterVector{A, B, C}); + return f; + } +}; + +TEST_P(ReferenceConcatTest, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParams() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParams( + PartialShape::dynamic(), + Tensor(ET, {2, 2}, std::vector{2, 4, 8, 16}), + Tensor(ET, {2, 3}, std::vector{1, 2, 4, 8, 16, 32}), + Tensor(ET, {2, 3}, std::vector{2, 3, 5, 7, 11, 13}), + -1, + Tensor(ET, {2, 8}, std::vector{2, 4, 1, 2, 4, 2, 3, 5, 8, 16, 8, 16, 32, 7, 11, 13}), + "concat_negative_axis"), + ConcatParams( + {}, + Tensor(ET, {2, 2}, std::vector{2, 4, 8, 16}), + Tensor(ET, {2, 3}, std::vector{1, 2, 4, 8, 16, 32}), + Tensor(ET, {2, 3}, std::vector{2, 3, 5, 7, 11, 13}), + 1, + Tensor(ET, {2, 8}, std::vector{2, 4, 1, 2, 4, 2, 3, 5, 8, 16, 8, 16, 32, 7, 11, 13}), + "concat_matrix_colwise"), + ConcatParams( + {}, + Tensor(ET, {2, 2}, std::vector{2, 4, 8, 16}), + Tensor(ET, {3, 2}, std::vector{1, 2, 4, 8, 16, 32}), + Tensor(ET, {3, 2}, std::vector{2, 3, 5, 7, 11, 13}), + 0, + Tensor(ET, {8, 2}, std::vector{2, 4, 8, 16, 1, 2, 4, 8, 16, 32, 2, 3, 5, 7, 11, 13}), + "concat_matrix_rowwise"), + ConcatParams( + {}, + Tensor(ET, {4}, std::vector{2, 4, 8, 16}), + Tensor(ET, {6}, std::vector{1, 2, 4, 8, 16, 32}), + Tensor(ET, {2}, std::vector{18, 19}), + 0, + Tensor(ET, {12}, std::vector{2, 4, 8, 16, 1, 2, 4, 8, 16, 32, 18, 19}), + "concat_vector"), + ConcatParams( + {}, + Tensor(ET, {1, 1, 1, 1}, std::vector{1}), + Tensor(ET, {1, 1, 1, 1}, std::vector{2}), + Tensor(ET, {1, 1, 1, 1}, std::vector{3}), + 0, + Tensor(ET, {3, 1, 1, 1}, std::vector{1, 2, 3}), + "concat_4d_tensor"), + ConcatParams( + {}, + Tensor(ET, {1, 1}, std::vector{1}), + Tensor(ET, {1, 1}, std::vector{2}), + Tensor(ET, {1, 1}, std::vector{3}), + 0, + Tensor(ET, {3, 1}, std::vector{1, 2, 3}), + "concat_2d_tensor"), + }; + return params; +} + +std::vector generateCombinedParams() { + const std::vector> generatedParams { + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTest, + testing::ValuesIn(generateCombinedParams()), ReferenceConcatTest::getTestCaseName); + +//// concat_vector_params, concat_vector_large + +struct ConcatParamsVectorLarge { + ConcatParamsVectorLarge(const uint32_t numInputs, const std::string& testcaseName = "") : + numInputs(numInputs), testcaseName(testcaseName) {} + + uint32_t numInputs; + std::string testcaseName; +}; + +class ReferenceConcatTestVectorLarge : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + + Shape shape_a{1}; + NodeVector inputs; + ParameterVector inputs_param; + for (uint32_t i = 0; i < params.numInputs; i++) { + auto A = std::make_shared(element::f32, shape_a); + inputs_param.push_back(A); + inputs.push_back(A); + } + function = std::make_shared(std::make_shared(inputs, 0), inputs_param); + + std::vector ref_result; + for (uint32_t i = 0; i < params.numInputs; i++) { + auto a = CreateTensor(shape_a, element::f32, std::vector{static_cast(i)}); + ref_result.push_back(static_cast(i)); + inputData.push_back(a); + } + refOutData = {CreateTensor(Shape{params.numInputs}, element::f32, ref_result)}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + if (param.testcaseName != "") { + result << "numInputs=" << param.numInputs; + result << "_=" << param.testcaseName; + } else { + result << "numInputs=" << param.numInputs; + } + return result.str(); + } +}; + +TEST_P(ReferenceConcatTestVectorLarge, CompareWithRefs) { + Exec(); +} + +std::vector generateParamsVectorLarge() { + std::vector params { + ConcatParamsVectorLarge(100, "concat_vector_large_100"), + ConcatParamsVectorLarge(128, "concat_vector_large_128"), + ConcatParamsVectorLarge(999, "concat_vector_large_999"), + }; + return params; +} + +std::vector generateCombinedParamsVectorLarge() { + const std::vector> generatedParams { + generateParamsVectorLarge(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestVectorLarge, + testing::ValuesIn(generateCombinedParamsVectorLarge()), ReferenceConcatTestVectorLarge::getTestCaseName); + +//// concat_in_place_2d_tensor + +struct ConcatParamsInPlace2dTensor { + ConcatParamsInPlace2dTensor( + const Tensor& A, const Tensor& B, const Tensor& C, const Tensor& D, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), C(C), D(D), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + Tensor C; + Tensor D; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestInPlace2dTensor : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data, params.C.data, params.D.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_cType=" << param.C.type; + result << "_cShape=" << param.C.shape; + result << "_dType=" << param.D.type; + result << "_dShape=" << param.D.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsInPlace2dTensor& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto add1 = std::make_shared(A, B); + const auto C = std::make_shared(params.C.type, params.C.shape); + const auto D = std::make_shared(params.D.type, params.D.shape); + const auto add2 = std::make_shared(C, D); + const auto subtract = std::make_shared(C, A); + const auto f = std::make_shared( + std::make_shared(NodeVector{add1, add2, subtract}, params.axis), + ParameterVector{A, B, C, D}); + return f; + } +}; + +TEST_P(ReferenceConcatTestInPlace2dTensor, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsInPlace2dTensor() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsInPlace2dTensor( + Tensor(ET, {1, 1}, std::vector{1}), + Tensor(ET, {1, 1}, std::vector{2}), + Tensor(ET, {1, 1}, std::vector{3}), + Tensor(ET, {1, 1}, std::vector{4}), + 0, + Tensor(ET, {3, 1}, std::vector{3, 7, 2}), + "concat_in_place_2d_tensor"), + }; + return params; +} + +std::vector generateCombinedParamsInPlace2dTensor() { + const std::vector> generatedParams { + generateParamsInPlace2dTensor(), + generateParamsInPlace2dTensor(), + generateParamsInPlace2dTensor(), + generateParamsInPlace2dTensor(), + generateParamsInPlace2dTensor(), + generateParamsInPlace2dTensor(), + generateParamsInPlace2dTensor(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestInPlace2dTensor, + testing::ValuesIn(generateCombinedParamsInPlace2dTensor()), ReferenceConcatTestInPlace2dTensor::getTestCaseName); + +//// concat_in_place_propagate_2d_tensor + +struct ConcatParamsInPlacePropagate2dTensor { + ConcatParamsInPlacePropagate2dTensor( + const Tensor& A, const Tensor& B, const Tensor& C, const Tensor& D, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), C(C), D(D), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + Tensor C; + Tensor D; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestInPlacePropagate2dTensor : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data, params.C.data, params.D.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_cType=" << param.C.type; + result << "_cShape=" << param.C.shape; + result << "_dType=" << param.D.type; + result << "_dShape=" << param.D.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsInPlacePropagate2dTensor& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto add1 = std::make_shared(A, B); + const auto C = std::make_shared(params.C.type, params.C.shape); + const auto D = std::make_shared(params.D.type, params.D.shape); + const auto add2 = std::make_shared(C, D); + const auto concat1 = std::make_shared(NodeVector{add1, add2}, params.axis); + const auto subtract = std::make_shared(C, A); + const auto f = std::make_shared( + std::make_shared(NodeVector{concat1, subtract}, params.axis), + ParameterVector{A, B, C, D}); + return f; + } +}; + +TEST_P(ReferenceConcatTestInPlacePropagate2dTensor, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsInPlacePropagate2dTensor() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsInPlacePropagate2dTensor( + Tensor(ET, {1, 1}, std::vector{1}), + Tensor(ET, {1, 1}, std::vector{2}), + Tensor(ET, {1, 1}, std::vector{3}), + Tensor(ET, {1, 1}, std::vector{4}), + 0, + Tensor(ET, {3, 1}, std::vector{3, 7, 2}), + "concat_in_place_2d_tensor"), + }; + return params; +} + +std::vector generateCombinedParamsInPlacePropagate2dTensor() { + const std::vector> generatedParams { + generateParamsInPlacePropagate2dTensor(), + generateParamsInPlacePropagate2dTensor(), + generateParamsInPlacePropagate2dTensor(), + generateParamsInPlacePropagate2dTensor(), + generateParamsInPlacePropagate2dTensor(), + generateParamsInPlacePropagate2dTensor(), + generateParamsInPlacePropagate2dTensor(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestInPlacePropagate2dTensor, + testing::ValuesIn(generateCombinedParamsInPlacePropagate2dTensor()), ReferenceConcatTestInPlacePropagate2dTensor::getTestCaseName); + +//// concat_in_place_tree_1 + +struct ConcatParamsInPlaceTree1 { + ConcatParamsInPlaceTree1( + const Tensor& A, const Tensor& B, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestInPlaceTree1 : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsInPlaceTree1& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto add1 = std::make_shared(A, B); + const auto add2 = std::make_shared(A, B); + const auto concat = std::make_shared(NodeVector{add1, add2}, params.axis); + const auto f = std::make_shared(std::make_shared(concat, concat), + ParameterVector{A, B}); + return f; + } +}; + +TEST_P(ReferenceConcatTestInPlaceTree1, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsInPlaceTree1() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsInPlaceTree1( + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + 1, + Tensor(ET, {1, 4, 2}, std::vector{4, 4, 4, 4, 4, 4, 4, 4}), + "concat_in_place_tree_1"), + }; + return params; +} + +std::vector generateCombinedParamsInPlaceTree1() { + const std::vector> generatedParams { + generateParamsInPlaceTree1(), + generateParamsInPlaceTree1(), + generateParamsInPlaceTree1(), + generateParamsInPlaceTree1(), + generateParamsInPlaceTree1(), + generateParamsInPlaceTree1(), + generateParamsInPlaceTree1(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestInPlaceTree1, + testing::ValuesIn(generateCombinedParamsInPlaceTree1()), ReferenceConcatTestInPlaceTree1::getTestCaseName); + +//// concat_in_place_tree_2 + +struct ConcatParamsInPlaceTree2 { + ConcatParamsInPlaceTree2( + const Tensor& A, const Tensor& B, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestInPlaceTree2 : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsInPlaceTree2& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto add1 = std::make_shared(A, B); + const auto add2 = std::make_shared(A, B); + const auto concat1 = std::make_shared(NodeVector{add1, add2}, params.axis); + const auto concat2 = std::make_shared(NodeVector{add1, add2}, params.axis); + const auto concat12 = std::make_shared(NodeVector{concat1, concat2}, params.axis); + const auto f = std::make_shared(std::make_shared(concat12, concat12), + ParameterVector{A, B}); + return f; + } +}; + +TEST_P(ReferenceConcatTestInPlaceTree2, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsInPlaceTree2() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsInPlaceTree2( + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + 1, + Tensor(ET, {1, 8, 2}, std::vector{4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4}), + "concat_in_place_tree_2"), + }; + return params; +} + +std::vector generateCombinedParamsInPlaceTree2() { + const std::vector> generatedParams { + generateParamsInPlaceTree2(), + generateParamsInPlaceTree2(), + generateParamsInPlaceTree2(), + generateParamsInPlaceTree2(), + generateParamsInPlaceTree2(), + generateParamsInPlaceTree2(), + generateParamsInPlaceTree2(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestInPlaceTree2, + testing::ValuesIn(generateCombinedParamsInPlaceTree2()), ReferenceConcatTestInPlaceTree2::getTestCaseName); + +//// concat_in_place_tree_3 + +struct ConcatParamsInPlaceTree3 { + ConcatParamsInPlaceTree3( + const Tensor& A, const Tensor& B, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestInPlaceTree3 : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsInPlaceTree3& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto concat1 = std::make_shared(NodeVector{A, B}, params.axis); + const auto concat2 = std::make_shared(NodeVector{A, B}, params.axis); + const auto concat3 = std::make_shared(NodeVector{A, B}, params.axis); + const auto concat4 = std::make_shared(NodeVector{A, B}, params.axis); + const auto concat12 = std::make_shared(NodeVector{concat1, concat2}, params.axis); + const auto concat34 = std::make_shared(NodeVector{concat3, concat4}, params.axis); + const auto concat14 = std::make_shared(NodeVector{concat12, concat34}, params.axis); + const auto f = std::make_shared(std::make_shared(concat14, concat14), + ParameterVector{A, B}); + return f; + } +}; + +TEST_P(ReferenceConcatTestInPlaceTree3, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsInPlaceTree3() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsInPlaceTree3( + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + 1, + Tensor(ET, {1, 16, 2}, std::vector{2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2}), + "concat_in_place_tree_3"), + }; + return params; +} + +std::vector generateCombinedParamsInPlaceTree3() { + const std::vector> generatedParams { + generateParamsInPlaceTree3(), + generateParamsInPlaceTree3(), + generateParamsInPlaceTree3(), + generateParamsInPlaceTree3(), + generateParamsInPlaceTree3(), + generateParamsInPlaceTree3(), + generateParamsInPlaceTree3(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestInPlaceTree3, + testing::ValuesIn(generateCombinedParamsInPlaceTree3()), ReferenceConcatTestInPlaceTree3::getTestCaseName); + +//// concat_in_place_add_concat + +struct ConcatParamsInPlaceAddConcat { + ConcatParamsInPlaceAddConcat( + const Tensor& A, const Tensor& B, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestInPlaceAddConcat : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsInPlaceAddConcat& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto add1 = std::make_shared(A, B); + const auto add2 = std::make_shared(add1, add1); + const auto concat = std::make_shared(NodeVector{add1, add2}, params.axis); + const auto add3 = std::make_shared(concat, concat); + const auto f = std::make_shared(add3, ParameterVector{A, B}); + return f; + } +}; + +TEST_P(ReferenceConcatTestInPlaceAddConcat, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsInPlaceAddConcat() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsInPlaceAddConcat( + Tensor(ET, {2, 2}, std::vector{1, 1, 1, 1}), + Tensor(ET, {2, 2}, std::vector{1, 1, 1, 1}), + 0, + Tensor(ET, {4, 2}, std::vector{4, 4, 4, 4, 8, 8, 8, 8}), + "concat_in_place_add_concat"), + }; + return params; +} + +std::vector generateCombinedParamsInPlaceAddConcat() { + const std::vector> generatedParams { + generateParamsInPlaceAddConcat(), + generateParamsInPlaceAddConcat(), + generateParamsInPlaceAddConcat(), + generateParamsInPlaceAddConcat(), + generateParamsInPlaceAddConcat(), + generateParamsInPlaceAddConcat(), + generateParamsInPlaceAddConcat(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestInPlaceAddConcat, + testing::ValuesIn(generateCombinedParamsInPlaceAddConcat()), ReferenceConcatTestInPlaceAddConcat::getTestCaseName); + +//// concat_in_place_add_concat_2 + +struct ConcatParamsInPlaceAddConcat2 { + ConcatParamsInPlaceAddConcat2( + const Tensor& A, const Tensor& B, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestInPlaceAddConcat2 : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsInPlaceAddConcat2& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto add1 = std::make_shared(A, B); + const auto add2 = std::make_shared(A, B); + const auto add3 = std::make_shared(A, B); + const auto add4 = std::make_shared(A, B); + const auto add5 = std::make_shared(A, B); + const auto concat1 = std::make_shared(NodeVector{add1, add2, add3}, params.axis); + const auto concat2 = std::make_shared(NodeVector{add4, add2, add5}, params.axis); + const auto add6 = std::make_shared(concat1, concat2); + const auto f = std::make_shared(add6, ParameterVector{A, B}); + return f; + } +}; + +TEST_P(ReferenceConcatTestInPlaceAddConcat2, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsInPlaceAddConcat2() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsInPlaceAddConcat2( + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + Tensor(ET, {1, 2, 2}, std::vector{1, 1, 1, 1}), + 1, + Tensor(ET, {1, 6, 2}, std::vector{4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}), + "concat_in_place_add_concat_2"), + }; + return params; +} + +std::vector generateCombinedParamsInPlaceAddConcat2() { + const std::vector> generatedParams { + generateParamsInPlaceAddConcat2(), + generateParamsInPlaceAddConcat2(), + generateParamsInPlaceAddConcat2(), + generateParamsInPlaceAddConcat2(), + generateParamsInPlaceAddConcat2(), + generateParamsInPlaceAddConcat2(), + generateParamsInPlaceAddConcat2(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestInPlaceAddConcat2, + testing::ValuesIn(generateCombinedParamsInPlaceAddConcat2()), ReferenceConcatTestInPlaceAddConcat2::getTestCaseName); + +//// concat_5d + +struct ConcatParams5d { + ConcatParams5d( + const Tensor& A, const Tensor& B, const Tensor& C, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), C(C), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + Tensor C; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTest5d : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data, params.C.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_cType=" << param.C.type; + result << "_cShape=" << param.C.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParams5d& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto C = std::make_shared(params.C.type, params.C.shape); + const auto concat = std::make_shared(NodeVector{A, B, C}, params.axis); + const auto f = std::make_shared(concat, ParameterVector{A, B, C}); + return f; + } +}; + +TEST_P(ReferenceConcatTest5d, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParams5d() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParams5d( + Tensor(ET, {2, 3, 4, 3, 2}, []() -> std::vector { + std::vector data(2 * 3 * 4 * 3 * 2); + for (int i = 0; i < 2 * 3 * 4 * 3 * 2; i++) { + data[i] = static_cast(i + 1); + } + return data; + }()), + Tensor(ET, {2, 3, 3, 3, 2}, []() -> std::vector { + std::vector data(2 * 3 * 3 * 3 * 2); + for (int i = 0; i < 2 * 3 * 3 * 3 * 2; i++) { + data[i] = 1000 + static_cast(i + 1); + } + return data;}()), + Tensor(ET, {2, 3, 2, 3, 2}, []() -> std::vector { + std::vector data(2 * 3 * 2 * 3 * 2); + for (int i = 0; i < 2 * 3 * 2 * 3 * 2; i++) { + data[i] = 2000 + static_cast(i + 1); + } + return data;}()), + 2, + Tensor(ET, {2, 3, 9, 3, 2}, 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., 1001., 1002., 1003., 1004., 1005., 1006., + 1007., 1008., 1009., 1010., 1011., 1012., 1013., 1014., 1015., 1016., 1017., 1018., 2001., 2002., 2003., + 2004., 2005., 2006., 2007., 2008., 2009., 2010., 2011., 2012., 25., 26., 27., 28., 29., 30., + 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45., + 46., 47., 48., 1019., 1020., 1021., 1022., 1023., 1024., 1025., 1026., 1027., 1028., 1029., 1030., + 1031., 1032., 1033., 1034., 1035., 1036., 2013., 2014., 2015., 2016., 2017., 2018., 2019., 2020., 2021., + 2022., 2023., 2024., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60., + 61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72., 1037., 1038., 1039., + 1040., 1041., 1042., 1043., 1044., 1045., 1046., 1047., 1048., 1049., 1050., 1051., 1052., 1053., 1054., + 2025., 2026., 2027., 2028., 2029., 2030., 2031., 2032., 2033., 2034., 2035., 2036., 73., 74., 75., + 76., 77., 78., 79., 80., 81., 82., 83., 84., 85., 86., 87., 88., 89., 90., + 91., 92., 93., 94., 95., 96., 1055., 1056., 1057., 1058., 1059., 1060., 1061., 1062., 1063., + 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072., 2037., 2038., 2039., 2040., 2041., 2042., + 2043., 2044., 2045., 2046., 2047., 2048., 97., 98., 99., 100., 101., 102., 103., 104., 105., + 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120., + 1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1081., 1082., 1083., 1084., 1085., 1086., 1087., + 1088., 1089., 1090., 2049., 2050., 2051., 2052., 2053., 2054., 2055., 2056., 2057., 2058., 2059., 2060., + 121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., + 136., 137., 138., 139., 140., 141., 142., 143., 144., 1091., 1092., 1093., 1094., 1095., 1096., + 1097., 1098., 1099., 1100., 1101., 1102., 1103., 1104., 1105., 1106., 1107., 1108., 2061., 2062., 2063., + 2064., 2065., 2066., 2067., 2068., 2069., 2070., 2071., 2072.}), + "concat_5d"), + }; + return params; +} + +std::vector generateCombinedParams5d() { + const std::vector> generatedParams { + generateParams5d(), + generateParams5d(), + generateParams5d(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTest5d, + testing::ValuesIn(generateCombinedParams5d()), ReferenceConcatTest5d::getTestCaseName); + +//// concat_zero_length_1d_last + +struct ConcatParamsZeroLength1dLast { + ConcatParamsZeroLength1dLast( + const Tensor& A, const Tensor& B, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestZeroLength1dLast : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsZeroLength1dLast& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto concat = std::make_shared(NodeVector{A, B}, params.axis); + const auto f = std::make_shared(concat, ParameterVector{A, B}); + return f; + } +}; + +TEST_P(ReferenceConcatTestZeroLength1dLast, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsZeroLength1dLast() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsZeroLength1dLast( + Tensor(ET, {4}, std::vector{1, 2, 3, 4}), + Tensor(ET, {0}, std::vector{0}), + 0, + Tensor(ET, {4}, std::vector{1, 2, 3, 4}), + "concat_zero_length_1d_last"), + }; + return params; +} + +std::vector generateCombinedParamsZeroLength1dLast() { + const std::vector> generatedParams { + generateParamsZeroLength1dLast(), + generateParamsZeroLength1dLast(), + generateParamsZeroLength1dLast(), + generateParamsZeroLength1dLast(), + generateParamsZeroLength1dLast(), + generateParamsZeroLength1dLast(), + generateParamsZeroLength1dLast(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestZeroLength1dLast, + testing::ValuesIn(generateCombinedParamsZeroLength1dLast()), ReferenceConcatTestZeroLength1dLast::getTestCaseName); + +//// concat_zero_length_1d_middle + +struct ConcatParamsZeroLength1dMiddle { + ConcatParamsZeroLength1dMiddle( + const Tensor& A, const Tensor& B, const Tensor& C, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), C(C), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + Tensor C; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestZeroLength1dMiddle : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data, params.C.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_cType=" << param.C.type; + result << "_cShape=" << param.C.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsZeroLength1dMiddle& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto C = std::make_shared(params.C.type, params.C.shape); + const auto concat = std::make_shared(NodeVector{A, B, C}, params.axis); + const auto f = std::make_shared(concat, ParameterVector{A, B, C}); + return f; + } +}; + +TEST_P(ReferenceConcatTestZeroLength1dMiddle, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsZeroLength1dMiddle() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsZeroLength1dMiddle( + Tensor(ET, {4}, std::vector{1, 2, 3, 4}), + Tensor(ET, {0}, std::vector{0}), + Tensor(ET, {4}, std::vector{5, 6, 7, 8}), + 0, + Tensor(ET, {8}, std::vector{1, 2, 3, 4, 5, 6, 7, 8}), + "concat_zero_length_1d_middle"), + }; + return params; +} + +std::vector generateCombinedParamsZeroLength1dMiddle() { + const std::vector> generatedParams { + generateParamsZeroLength1dMiddle(), + generateParamsZeroLength1dMiddle(), + generateParamsZeroLength1dMiddle(), + generateParamsZeroLength1dMiddle(), + generateParamsZeroLength1dMiddle(), + generateParamsZeroLength1dMiddle(), + generateParamsZeroLength1dMiddle(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestZeroLength1dMiddle, + testing::ValuesIn(generateCombinedParamsZeroLength1dMiddle()), ReferenceConcatTestZeroLength1dMiddle::getTestCaseName); + +//// concat_zero_zero + +struct ConcatParamsZeroZero { + ConcatParamsZeroZero( + const Tensor& A, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestZeroZero : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsZeroZero& params) { + const auto constant_1 = std::make_shared(params.A.type, params.A.shape, params.A.data.data()); + const auto concat_1 = std::make_shared(NodeVector{constant_1, constant_1}, params.axis); + const auto f = std::make_shared(concat_1, ParameterVector{}); + return f; + } +}; + +TEST_P(ReferenceConcatTestZeroZero, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsZeroZero() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsZeroZero( + Tensor(ET, {0}, std::vector{1}), + 0, + Tensor(ET, {0}, std::vector{}), + "concat_zero_zero"), + }; + return params; +} + +std::vector generateCombinedParamsZeroZero() { + const std::vector> generatedParams { + generateParamsZeroZero(), + generateParamsZeroZero(), + generateParamsZeroZero(), + generateParamsZeroZero(), + generateParamsZeroZero(), + generateParamsZeroZero(), + generateParamsZeroZero(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestZeroZero, + testing::ValuesIn(generateCombinedParamsZeroZero()), ReferenceConcatTestZeroZero::getTestCaseName); + +//// concat_zero_length_4d_middle + +struct ConcatParamsZeroLength4dMiddle { + ConcatParamsZeroLength4dMiddle( + const Tensor& A, const Tensor& B, const Tensor& C, const int32_t axis, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), B(B), C(C), axis(axis), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor B; + Tensor C; + int32_t axis; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceConcatTestZeroLength4dMiddle : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data, params.B.data, params.C.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_bType=" << param.B.type; + result << "_bShape=" << param.B.shape; + result << "_cType=" << param.C.type; + result << "_cShape=" << param.C.shape; + result << "_axis=" << param.axis; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const ConcatParamsZeroLength4dMiddle& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto B = std::make_shared(params.B.type, params.B.shape); + const auto C = std::make_shared(params.C.type, params.C.shape); + const auto concat = std::make_shared(NodeVector{A, B, C}, params.axis); + const auto f = std::make_shared(concat, ParameterVector{A, B, C}); + return f; + } +}; + +TEST_P(ReferenceConcatTestZeroLength4dMiddle, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParamsZeroLength4dMiddle() { + using T = typename element_type_traits::value_type; + std::vector params { + ConcatParamsZeroLength4dMiddle( + Tensor(ET, {2, 2, 1, 1}, std::vector{1, 2, 3, 4}), + Tensor(ET, {2, 2, 0, 1}, std::vector{0}), + Tensor(ET, {2, 2, 1, 1}, std::vector{5, 6, 7, 8}), + 2, + Tensor(ET, {2, 2, 2, 1}, std::vector{1, 5, 2, 6, 3, 7, 4, 8}), + "concat_zero_length_4d_middle"), + }; + return params; +} + +std::vector generateCombinedParamsZeroLength4dMiddle() { + const std::vector> generatedParams { + generateParamsZeroLength4dMiddle(), + generateParamsZeroLength4dMiddle(), + generateParamsZeroLength4dMiddle(), + generateParamsZeroLength4dMiddle(), + generateParamsZeroLength4dMiddle(), + generateParamsZeroLength4dMiddle(), + generateParamsZeroLength4dMiddle(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Concat_With_Hardcoded_Refs, ReferenceConcatTestZeroLength4dMiddle, + testing::ValuesIn(generateCombinedParamsZeroLength4dMiddle()), ReferenceConcatTestZeroLength4dMiddle::getTestCaseName); + + +} // namespace \ No newline at end of file diff --git a/docs/template_plugin/tests/functional/op_reference/tile.cpp b/docs/template_plugin/tests/functional/op_reference/tile.cpp new file mode 100644 index 00000000000..c6382a38639 --- /dev/null +++ b/docs/template_plugin/tests/functional/op_reference/tile.cpp @@ -0,0 +1,110 @@ +// Copyright (C) 2021 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "openvino/opsets/opset1.hpp" +#include "base_reference_test.hpp" + +using namespace reference_tests; +using namespace ov; + +namespace { +struct TileParams { + TileParams( + const Tensor& A, const Tensor& repeats, + const Tensor& expected, const std::string& testcaseName = "") : + A(A), repeats(repeats), expected(expected), testcaseName(testcaseName) {} + + Tensor A; + Tensor repeats; + Tensor expected; + std::string testcaseName; +}; + +class ReferenceTileTest : public testing::TestWithParam, public CommonReferenceTest { +public: + void SetUp() override { + auto params = GetParam(); + function = CreateFunction(params); + inputData = {params.A.data}; + refOutData = {params.expected.data}; + } + + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + auto param = obj.param; + std::ostringstream result; + result << "aType=" << param.A.type; + result << "_aShape=" << param.A.shape; + result << "_rType=" << param.repeats.type; + result << "_rShape=" << param.repeats.shape; + result << "_eType=" << param.expected.type; + if (param.testcaseName != "") { + result << "_eShape=" << param.expected.shape; + result << "_=" << param.testcaseName; + } else { + result << "_rShape=" << param.expected.shape; + } + return result.str(); + } + +private: + static std::shared_ptr CreateFunction(const TileParams& params) { + const auto A = std::make_shared(params.A.type, params.A.shape); + const auto repeats = std::make_shared(params.repeats.type, params.repeats.shape, + params.repeats.data.data()); + const auto tile = std::make_shared(A, repeats); + const auto f = std::make_shared(NodeVector{tile}, ParameterVector{A}); + return f; + } +}; + +TEST_P(ReferenceTileTest, CompareWithRefs) { + Exec(); +} + +template +std::vector generateParams() { + using T = typename element_type_traits::value_type; + std::vector params { + TileParams( + Tensor(ET, {3}, std::vector{1, 2, 3}), + Tensor(element::i64, {3}, std::vector{2, 2, 1}), + Tensor(ET, {2, 2, 3}, std::vector{1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3}), + "tile_3d_small_data_rank"), + TileParams( + Tensor(ET, {2, 1, 3}, std::vector{1, 2, 3, 4, 5, 6}), + Tensor(element::i64, {2}, std::vector{2, 1}), + Tensor(ET, {2, 2, 3}, std::vector{1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6}), + "tile_3d_few_repeats"), + }; + return params; +} + +std::vector generateCombinedParams() { + const std::vector> generatedParams { + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + generateParams(), + }; + std::vector combinedParams; + + for (const auto& params : generatedParams) { + combinedParams.insert(combinedParams.end(), params.begin(), params.end()); + } + return combinedParams; +} + +INSTANTIATE_TEST_SUITE_P(smoke_Tile_With_Hardcoded_Refs, ReferenceTileTest, + testing::ValuesIn(generateCombinedParams()), ReferenceTileTest::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 7f568f2d36f..bc20772d640 100644 --- a/docs/template_plugin/tests/functional/skip_tests_config.cpp +++ b/docs/template_plugin/tests/functional/skip_tests_config.cpp @@ -98,6 +98,8 @@ std::vector disabledTestPatterns() { R"(.*ReferenceTopKTest.*aType=u16.*)", R"(.*ReferenceTopKTest.*aType=bf16.*)", R"(.*ReferenceTopKTest.*aType=f64.*)", + // CVS-63947 + R"(.*ReferenceConcatTest.*concat_zero_.*)", }; #ifdef _WIN32 diff --git a/ngraph/test/CMakeLists.txt b/ngraph/test/CMakeLists.txt index 1d94437e06a..08288a1c5b6 100644 --- a/ngraph/test/CMakeLists.txt +++ b/ngraph/test/CMakeLists.txt @@ -485,9 +485,7 @@ set(MULTI_TEST_SRC backend/aliased_output.in.cpp backend/api.in.cpp backend/auto_broadcast.in.cpp - backend/broadcast.in.cpp backend/builder_reduce_ops_opset1.in.cpp - backend/concat.in.cpp backend/dyn_reshape.in.cpp backend/dynamic.in.cpp backend/experimental_detectron_prior_grid.in.cpp @@ -501,7 +499,6 @@ set(MULTI_TEST_SRC backend/non_max_suppression.in.cpp backend/region_yolo.in.cpp backend/sqrt.in.cpp - backend/tile.in.cpp backend/unhandled_op.in.cpp backend/validate_call.in.cpp backend/zero_sized.in.cpp diff --git a/ngraph/test/backend/broadcast.in.cpp b/ngraph/test/backend/broadcast.in.cpp deleted file mode 100644 index ce1b916c616..00000000000 --- a/ngraph/test/backend/broadcast.in.cpp +++ /dev/null @@ -1,498 +0,0 @@ -// Copyright (C) 2018-2021 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include -#include -#include -#include -#include -#include - -#include "engines_util/execute_tools.hpp" -#include "gtest/gtest.h" -#include "ngraph/builder/autobroadcast.hpp" -#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" - -NGRAPH_SUPPRESS_DEPRECATED_START - -using namespace std; -using namespace ngraph; - -static string s_manifest = "${MANIFEST}"; - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_scalar_vector) { - Shape shape_a{}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{4}; - auto f = make_shared( - make_shared(A, op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r)), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{6}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{6, 6, 6, 6}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_scalar_vector_explicit_axis_0) { - Shape shape_a{}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{1, 2}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{1}, {0})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{6}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{6, 6}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_scalar_matrix) { - Shape shape_a{}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{2, 2}; - auto f = make_shared( - make_shared(A, op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r)), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{6}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{6, 6, 6, 6}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_scalar_tensor) { - Shape shape_a{}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{2, 2, 2}; - auto f = make_shared( - make_shared(A, op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r)), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{6}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{6, 6, 6, 6, 6, 6, 6, 6}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_trivial) { - Shape shape{2, 2, 2}; - auto A = make_shared(element::f32, shape); - auto f = make_shared( - make_shared(A, op::Constant::create(element::u64, Shape{shape.size()}, shape)), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{2, 4, 6, 8, 16, 32, 64, 128}); - auto result = backend->create_tensor(element::f32, shape); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{2, 4, 6, 8, 16, 32, 64, 128}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_vector_colwise) { - Shape shape_a{3}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{3, 4}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{1}, {0})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_vector_rowwise) { - Shape shape_a{4}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{3, 4}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{1}, {1})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3, 4}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -// Test hybrid mechanism after broadcast -NGRAPH_TEST(${BACKEND_NAME}, broadcast_vector_rowwise_reversed) { - Shape shape_a{4}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{3, 4}; - auto broadcast = make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{1}, {1})); - auto reverse = make_shared(broadcast, - op::Constant::create(element::i64, {1}, {1}), - op::v1::Reverse::Mode::INDEX); - auto f = make_shared(reverse, ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3, 4}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_vector_rowwise_int64) { - Shape shape_a{4}; - auto A = make_shared(element::i64, shape_a); - Shape shape_r{3, 4}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{1}, {1})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::i64, shape_a); - copy_data(a, vector{1, 2, 3, 4}); - auto result = backend->create_tensor(element::i64, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_EQ((vector{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}), read_vector(result)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_scalar_to_matrix_int64) { - Shape shape_a{1}; - auto A = make_shared(element::i64, shape_a); - Shape shape_r{3, 1}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{1}, {1})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::i64, shape_a); - copy_data(a, vector{4}); - auto result = backend->create_tensor(element::i64, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_EQ((vector{4, 4, 4}), read_vector(result)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_scalar_to_matrix_int32) { - Shape shape_a{1}; - auto A = make_shared(element::i32, shape_a); - Shape shape_r{3, 1}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{1}, {1})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::i32, shape_a); - copy_data(a, vector{4}); - auto result = backend->create_tensor(element::i32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_EQ((vector{4, 4, 4}), read_vector(result)); -} - -static void broadcast_test_helper(const Shape& shape_a, const Shape& shape_r, const AxisSet& axes) { - auto A = make_shared(element::f32, shape_a); - - vector inp_data(shape_size(shape_a)); - iota(inp_data.begin(), inp_data.end(), 1.f); - auto shape_const = op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r); - std::shared_ptr broadcast; - if (axes.size() > 0) { - auto axes_const = op::Constant::create(element::i64, Shape{axes.size()}, axes.to_vector()); - broadcast = make_shared(A, shape_const, axes_const); - } else { - broadcast = make_shared(A, shape_const); - } - auto f = make_shared(broadcast, ParameterVector{A}); - - auto ref_backend = runtime::Backend::create("INTERPRETER"); - auto wrk_backend = runtime::Backend::create("${BACKEND_NAME}"); - - auto wrk_a = wrk_backend->create_tensor(element::f32, shape_a); - copy_data(wrk_a, inp_data); - - auto ref_a = ref_backend->create_tensor(element::f32, shape_a); - copy_data(ref_a, inp_data); - - auto wrk_result = wrk_backend->create_tensor(element::f32, shape_r); - auto ref_result = ref_backend->create_tensor(element::f32, shape_r); - - auto wrk_handle = wrk_backend->compile(f); - auto ref_handle = ref_backend->compile(f); - wrk_handle->call_with_validate({wrk_result}, {wrk_a}); - ref_handle->call_with_validate({ref_result}, {ref_a}); - EXPECT_TRUE( - test::all_close_f(read_vector(ref_result), read_vector(wrk_result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_vector_middle) { - Shape shape_a{2}; - Shape shape_r{3, 2, 4}; - AxisSet axis{1}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_vector_forward_2) { - Shape shape_a{2}; - Shape shape_r{3, 2}; - AxisSet axis{1}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_vector_forward_3) { - Shape shape_a{2}; - Shape shape_r{4, 3, 2}; - AxisSet axis{2}; - broadcast_test_helper(shape_a, shape_r, axis); -} -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_vector_forward_4) { - Shape shape_a{2}; - Shape shape_r{5, 4, 3, 2}; - AxisSet axis{3}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_scalar) { - Shape shape_a{}; - Shape shape_r{5, 4, 3, 2}; - AxisSet axis{}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_vector_backward_2) { - Shape shape_a{2}; - Shape shape_r{2, 3}; - AxisSet axis{0}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_vector_backward_3) { - Shape shape_a{2}; - Shape shape_r{2, 3, 4}; - AxisSet axis{0}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_vector_backward_4) { - Shape shape_a{2}; - Shape shape_r{2, 3, 4, 5}; - AxisSet axis{0}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_matrix_backward_4) { - Shape shape_a{4, 5}; - Shape shape_r{2, 3, 4, 5}; - AxisSet axis{2, 3}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_matrix_stride_1) { - Shape shape_a{3, 5}; - Shape shape_r{2, 3, 4, 5}; - AxisSet axis{1, 3}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_matrix_stride_2) { - Shape shape_a{3, 4}; - Shape shape_r{2, 3, 4, 5}; - AxisSet axis{1, 2}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_matrix_stride_3) { - Shape shape_a{2, 4}; - Shape shape_r{2, 3, 4, 5}; - AxisSet axis{0, 2}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_3d_backward) { - Shape shape_a{2, 3, 4}; - Shape shape_r{5, 2, 3, 4}; - AxisSet axis{1, 2, 3}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_3d_stride_1) { - Shape shape_a{2, 3, 4}; - Shape shape_r{2, 5, 3, 4}; - AxisSet axis{0, 2, 3}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_3d_stride_2) { - Shape shape_a{2, 3, 4}; - Shape shape_r{2, 3, 5, 4}; - AxisSet axis{0, 1, 3}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_3d_diffrent_rank) { - Shape shape_a{3, 1}; - Shape shape_r{2, 3, 3}; - AxisSet axis{1, 2}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_algo_4d_same_rank) { - Shape shape_a{2, 3, 1, 1}; - Shape shape_r{2, 3, 4, 5}; - AxisSet axis{0, 1, 2, 3}; - broadcast_test_helper(shape_a, shape_r, axis); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_matrix_0) { - Shape shape_a{2, 2}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{2, 2, 2}; - auto f = make_shared( - make_shared(A, op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r)), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3, 4}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{1, 2, 3, 4, 1, 2, 3, 4}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_matrix_1) { - Shape shape_a{2, 2}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{2, 2, 2}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{2}, {0, 2})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3, 4}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{1, 2, 1, 2, 3, 4, 3, 4}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, broadcast_matrix_2) { - Shape shape_a{2, 2}; - auto A = make_shared(element::f32, shape_a); - Shape shape_r{2, 2, 2}; - auto f = make_shared( - make_shared(A, - op::Constant::create(element::u64, Shape{shape_r.size()}, shape_r), - op::Constant::create(element::i64, Shape{2}, {0, 1})), - ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3, 4}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f((vector{1, 1, 2, 2, 3, 3, 4, 4}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} diff --git a/ngraph/test/backend/concat.in.cpp b/ngraph/test/backend/concat.in.cpp deleted file mode 100644 index b319880f776..00000000000 --- a/ngraph/test/backend/concat.in.cpp +++ /dev/null @@ -1,672 +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" - -NGRAPH_SUPPRESS_DEPRECATED_START - -using namespace std; -using namespace ngraph; - -static string s_manifest = "${MANIFEST}"; - -NGRAPH_TEST(${BACKEND_NAME}, concat_negative_axis) { - auto pshape_a = PartialShape::dynamic(); - auto A = make_shared(element::f32, pshape_a); - auto pshape_b = PartialShape::dynamic(); - auto B = make_shared(element::f32, pshape_b); - auto pshape_c = PartialShape::dynamic(); - auto C = make_shared(element::f32, pshape_c); - auto pshape_r = PartialShape::dynamic(); - auto f = make_shared(make_shared(NodeVector{A, B, C}, -1), ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}", true); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, Shape{2, 2}); - copy_data(a, vector{2, 4, 8, 16}); - auto b = backend->create_tensor(element::f32, Shape{2, 3}); - copy_data(b, vector{1, 2, 4, 8, 16, 32}); - auto c = backend->create_tensor(element::f32, Shape{2, 3}); - copy_data(c, vector{2, 3, 5, 7, 11, 13}); - auto result = backend->create_dynamic_tensor(element::f32, PartialShape::dynamic()); - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - ASSERT_EQ(result->get_shape(), (Shape{2, 8})); - EXPECT_TRUE(test::all_close_f((vector{2, 4, 1, 2, 4, 2, 3, 5, 8, 16, 8, 16, 32, 7, 11, 13}), - read_vector(result))); -} -NGRAPH_TEST(${BACKEND_NAME}, concat_matrix_colwise) { - Shape shape_a{2, 2}; - auto A = make_shared(element::f32, shape_a); - Shape shape_b{2, 3}; - auto B = make_shared(element::f32, shape_b); - Shape shape_c{2, 3}; - auto C = make_shared(element::f32, shape_c); - Shape shape_r{2, 8}; - auto f = make_shared(make_shared(NodeVector{A, B, C}, 1), ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{2, 4, 8, 16}); - auto b = backend->create_tensor(element::f32, shape_b); - copy_data(b, vector{1, 2, 4, 8, 16, 32}); - auto c = backend->create_tensor(element::f32, shape_c); - copy_data(c, vector{2, 3, 5, 7, 11, 13}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f((vector{2, 4, 1, 2, 4, 2, 3, 5, 8, 16, 8, 16, 32, 7, 11, 13}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_matrix_rowwise) { - Shape shape_a{2, 2}; - auto A = make_shared(element::f32, shape_a); - Shape shape_b{3, 2}; - auto B = make_shared(element::f32, shape_b); - Shape shape_c{3, 2}; - auto C = make_shared(element::f32, shape_c); - Shape shape_r{8, 2}; - auto f = make_shared(make_shared(NodeVector{A, B, C}, 0), ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{2, 4, 8, 16}); - auto b = backend->create_tensor(element::f32, shape_b); - copy_data(b, vector{1, 2, 4, 8, 16, 32}); - auto c = backend->create_tensor(element::f32, shape_c); - copy_data(c, vector{2, 3, 5, 7, 11, 13}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f((vector{2, 4, 8, 16, 1, 2, 4, 8, 16, 32, 2, 3, 5, 7, 11, 13}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_matrix_int64) { - Shape shape_a{2, 2}; - auto A = make_shared(element::i64, shape_a); - Shape shape_b{3, 2}; - auto B = make_shared(element::i64, shape_b); - Shape shape_c{3, 2}; - auto C = make_shared(element::i64, shape_c); - Shape shape_r{8, 2}; - auto f = make_shared(make_shared(NodeVector{A, B, C}, 0), ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::i64, shape_a); - copy_data(a, vector{2, 4, 8, 16}); - auto b = backend->create_tensor(element::i64, shape_b); - copy_data(b, vector{1, 2, 4, 8, 16, 32}); - auto c = backend->create_tensor(element::i64, shape_c); - copy_data(c, vector{2, 3, 5, 7, 11, 13}); - auto result = backend->create_tensor(element::i64, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_EQ((vector{2, 4, 8, 16, 1, 2, 4, 8, 16, 32, 2, 3, 5, 7, 11, 13}), read_vector(result)); -} - -// Params to drive concat_vector_large testing variations -class concat_vector_params : public ::testing::TestWithParam { -protected: - concat_vector_params() { - num_inputs = GetParam(); - } - uint32_t num_inputs; -}; - -NGRAPH_TEST_P(${BACKEND_NAME}, concat_vector_params, concat_vector_large) { - Shape shape_a{1}; - NodeVector inputs; - ParameterVector inputs_param; - for (uint32_t i = 0; i < num_inputs; i++) { - auto A = make_shared(element::f32, shape_a); - inputs_param.push_back(A); - inputs.push_back(A); - } - Shape shape_r{num_inputs}; - auto f = make_shared(make_shared(inputs, 0), inputs_param); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - std::vector> inputs_value; - std::vector ref_result; - for (uint32_t i = 0; i < num_inputs; i++) { - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{static_cast(i)}); - ref_result.push_back(static_cast(i)); - inputs_value.push_back(a); - } - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, inputs_value); - EXPECT_TRUE(test::all_close_f(ref_result, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -// concat_vector_large case generation -// Add thhosw tests to cover paramter space overflow: -// cuda kernel parameter space have limit, if there is large number of parameters, -// there will be overflow for parameter space. -NGRAPH_INSTANTIATE_TEST_SUITE_P(${BACKEND_NAME}, input_sizes, concat_vector_params, testing::Values(100, 128, 999)); - -NGRAPH_TEST(${BACKEND_NAME}, concat_vector) { - Shape shape_a{4}; - auto A = make_shared(element::f32, shape_a); - Shape shape_b{6}; - auto B = make_shared(element::f32, shape_b); - Shape shape_c{2}; - auto C = make_shared(element::f32, shape_c); - Shape shape_r{12}; - auto f = make_shared(make_shared(NodeVector{A, B, C}, 0), ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{2, 4, 8, 16}); - auto b = backend->create_tensor(element::f32, shape_b); - copy_data(b, vector{1, 2, 4, 8, 16, 32}); - auto c = backend->create_tensor(element::f32, shape_c); - copy_data(c, vector{18, 19}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f((vector{2, 4, 8, 16, 1, 2, 4, 8, 16, 32, 18, 19}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_4d_tensor) { - Shape shape{1, 1, 1, 1}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto C = make_shared(element::f32, shape); - Shape shape_r{3, 1, 1, 1}; - auto f = make_shared(make_shared(NodeVector{A, B, C}, 0), ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{2}); - auto c = backend->create_tensor(element::f32, shape); - copy_data(c, vector{3}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f((vector{1, 2, 3}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_2d_tensor) { - Shape shape{1, 1}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto C = make_shared(element::f32, shape); - Shape shape_r{3, 1}; - auto f = make_shared(make_shared(NodeVector{A, B, C}, 0), ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{2}); - auto c = backend->create_tensor(element::f32, shape); - copy_data(c, vector{3}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f((vector{1, 2, 3}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_2d_tensor) { - Shape shape{1, 1}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto add1 = make_shared(A, B); - auto C = make_shared(element::f32, shape); - auto D = make_shared(element::f32, shape); - auto add2 = make_shared(C, D); - auto subtract = make_shared(C, A); - Shape shape_r{3, 1}; - auto f = make_shared(make_shared(NodeVector{add1, add2, subtract}, 0), - ParameterVector{A, B, C, D}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{2}); - auto c = backend->create_tensor(element::f32, shape); - copy_data(c, vector{3}); - auto d = backend->create_tensor(element::f32, shape); - copy_data(d, vector{4}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c, d}); - EXPECT_TRUE(test::all_close_f((vector{3, 7, 2}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_propagate_2d_tensor) { - Shape shape{1, 1}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto add1 = make_shared(A, B); - auto C = make_shared(element::f32, shape); - auto D = make_shared(element::f32, shape); - auto add2 = make_shared(C, D); - auto concat1 = make_shared(NodeVector{add1, add2}, 0); - auto subtract = make_shared(C, A); - Shape shape_r{3, 1}; - auto f = - make_shared(make_shared(NodeVector{concat1, subtract}, 0), ParameterVector{A, B, C, D}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{2}); - auto c = backend->create_tensor(element::f32, shape); - copy_data(c, vector{3}); - auto d = backend->create_tensor(element::f32, shape); - copy_data(d, vector{4}); - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c, d}); - EXPECT_TRUE(test::all_close_f((vector{3, 7, 2}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_tree_1) { - Shape shape{1, 2, 2}; - Shape shape_r{1, 4, 2}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto add1 = make_shared(A, B); - auto add2 = make_shared(A, B); - auto concat = make_shared(NodeVector{add1, add2}, 1); - auto f = make_shared(make_shared(concat, concat), ParameterVector{A, B}); - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1, 1, 1, 1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{1, 1, 1, 1}); - - auto result = backend->create_tensor(element::f32, shape_r); - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b}); - vector expected; - expected.resize(8, 4); - - EXPECT_TRUE(test::all_close_f(expected, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_tree_2) { - Shape shape{1, 2, 2}; - Shape shape_r{1, 8, 2}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto add1 = make_shared(A, B); - auto add2 = make_shared(A, B); - auto concat1 = make_shared(NodeVector{add1, add2}, 1); - auto concat2 = make_shared(NodeVector{add1, add2}, 1); - auto concat12 = make_shared(NodeVector{concat1, concat2}, 1); - auto f = make_shared(make_shared(concat12, concat12), ParameterVector{A, B}); - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1, 1, 1, 1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{1, 1, 1, 1}); - auto result = backend->create_tensor(element::f32, shape_r); - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b}); - vector expected; - expected.resize(16, 4); - - EXPECT_TRUE(test::all_close_f(expected, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_tree_3) { - Shape shape{1, 2, 2}; - Shape shape_r{1, 16, 2}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto concat1 = make_shared(NodeVector{A, B}, 1); - auto concat2 = make_shared(NodeVector{A, B}, 1); - auto concat3 = make_shared(NodeVector{A, B}, 1); - auto concat4 = make_shared(NodeVector{A, B}, 1); - auto concat12 = make_shared(NodeVector{concat1, concat2}, 1); - auto concat34 = make_shared(NodeVector{concat3, concat4}, 1); - auto concat14 = make_shared(NodeVector{concat12, concat34}, 1); - auto f = make_shared(make_shared(concat14, concat14), ParameterVector{A, B}); - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1, 1, 1, 1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{1, 1, 1, 1}); - auto result = backend->create_tensor(element::f32, shape_r); - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b}); - vector expected; - expected.resize(32, 2); - - EXPECT_TRUE(test::all_close_f(expected, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_add_concat) { - Shape shape{2, 2}; - Shape shape_r{4, 2}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto add1 = make_shared(A, B); - auto add2 = make_shared(add1, add1); - auto concat = make_shared(NodeVector{add1, add2}, 0); - auto add3 = make_shared(concat, concat); - auto f = make_shared(add3, ParameterVector{A, B}); - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1, 1, 1, 1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{1, 1, 1, 1}); - auto result = backend->create_tensor(element::f32, shape_r); - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b}); - vector expected = {4, 4, 4, 4, 8, 8, 8, 8}; - EXPECT_TRUE(test::all_close_f(expected, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_in_place_add_concat_2) { - Shape shape{1, 2, 2}; - Shape shape_r{1, 6, 2}; - auto A = make_shared(element::f32, shape); - auto B = make_shared(element::f32, shape); - auto add1 = make_shared(A, B); - auto add2 = make_shared(A, B); - auto add3 = make_shared(A, B); - auto add4 = make_shared(A, B); - auto add5 = make_shared(A, B); - - auto concat1 = make_shared(NodeVector{add1, add2, add3}, 1); - - auto concat2 = make_shared(NodeVector{add4, add2, add5}, 1); - - auto add6 = make_shared(concat1, concat2); - auto f = make_shared(add6, ParameterVector{A, B}); - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - auto a = backend->create_tensor(element::f32, shape); - copy_data(a, vector{1, 1, 1, 1}); - auto b = backend->create_tensor(element::f32, shape); - copy_data(b, vector{1, 1, 1, 1}); - auto result = backend->create_tensor(element::f32, shape_r); - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b}); - vector expected = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}; - EXPECT_TRUE(test::all_close_f(expected, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} -// from numpy import * -// a=linspace(1,2*3*4*3*2,2*3*4*3*2) -// b=linspace(1000+1,1000+2*3*3*3*2,2*3*3*3*2) -// c=linspace(2000+1,2000+2*3*2*3*2,2*3*2*3*2) -// a.shape=(2,3,4,3,2) -// b.shape=(2,3,3,3,2) -// c.shape=(2,3,2,3,2) -// z=concatenate((a,b,c),axis=2) -// z.shape=(2*3*(4+3+2)*3*2) -// set_printoptions(suppress=True) -// print(z) -// -// [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. -// 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. -// 21. 22. 23. 24. 1001. 1002. 1003. 1004. 1005. 1006. -// 1007. 1008. 1009. 1010. 1011. 1012. 1013. 1014. 1015. 1016. -// 1017. 1018. 2001. 2002. 2003. 2004. 2005. 2006. 2007. 2008. -// 2009. 2010. 2011. 2012. 25. 26. 27. 28. 29. 30. -// 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. -// 41. 42. 43. 44. 45. 46. 47. 48. 1019. 1020. -// 1021. 1022. 1023. 1024. 1025. 1026. 1027. 1028. 1029. 1030. -// 1031. 1032. 1033. 1034. 1035. 1036. 2013. 2014. 2015. 2016. -// 2017. 2018. 2019. 2020. 2021. 2022. 2023. 2024. 49. 50. -// 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. -// 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. -// 71. 72. 1037. 1038. 1039. 1040. 1041. 1042. 1043. 1044. -// 1045. 1046. 1047. 1048. 1049. 1050. 1051. 1052. 1053. 1054. -// 2025. 2026. 2027. 2028. 2029. 2030. 2031. 2032. 2033. 2034. -// 2035. 2036. 73. 74. 75. 76. 77. 78. 79. 80. -// 81. 82. 83. 84. 85. 86. 87. 88. 89. 90. -// 91. 92. 93. 94. 95. 96. 1055. 1056. 1057. 1058. -// 1059. 1060. 1061. 1062. 1063. 1064. 1065. 1066. 1067. 1068. -// 1069. 1070. 1071. 1072. 2037. 2038. 2039. 2040. 2041. 2042. -// 2043. 2044. 2045. 2046. 2047. 2048. 97. 98. 99. 100. -// 101. 102. 103. 104. 105. 106. 107. 108. 109. 110. -// 111. 112. 113. 114. 115. 116. 117. 118. 119. 120. -// 1073. 1074. 1075. 1076. 1077. 1078. 1079. 1080. 1081. 1082. -// 1083. 1084. 1085. 1086. 1087. 1088. 1089. 1090. 2049. 2050. -// 2051. 2052. 2053. 2054. 2055. 2056. 2057. 2058. 2059. 2060. -// 121. 122. 123. 124. 125. 126. 127. 128. 129. 130. -// 131. 132. 133. 134. 135. 136. 137. 138. 139. 140. -// 141. 142. 143. 144. 1091. 1092. 1093. 1094. 1095. 1096. -// 1097. 1098. 1099. 1100. 1101. 1102. 1103. 1104. 1105. 1106. -// 1107. 1108. 2061. 2062. 2063. 2064. 2065. 2066. 2067. 2068. -// 2069. 2070. 2071. 2072.] -NGRAPH_TEST(${BACKEND_NAME}, concat_5d) { - vector a_data(2 * 3 * 4 * 3 * 2); - for (int i = 0; i < 2 * 3 * 4 * 3 * 2; i++) { - a_data[i] = float(i + 1); - } - - vector b_data(2 * 3 * 3 * 3 * 2); - for (int i = 0; i < 2 * 3 * 3 * 3 * 2; i++) { - b_data[i] = 1000 + float(i + 1); - } - - vector c_data(2 * 3 * 2 * 3 * 2); - for (int i = 0; i < 2 * 3 * 2 * 3 * 2; i++) { - c_data[i] = 2000 + float(i + 1); - } - - Shape shape_a{2, 3, 4, 3, 2}; - auto A = make_shared(element::f32, shape_a); - Shape shape_b{2, 3, 3, 3, 2}; - auto B = make_shared(element::f32, shape_b); - Shape shape_c{2, 3, 2, 3, 2}; - auto C = make_shared(element::f32, shape_c); - Shape shape_r{2, 3, 9, 3, 2}; - - auto r = make_shared(NodeVector{A, B, C}, 2); - auto f = make_shared(r, ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, a_data); - auto b = backend->create_tensor(element::f32, shape_b); - copy_data(b, b_data); - auto c = backend->create_tensor(element::f32, shape_c); - copy_data(c, c_data); - - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f( - (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., 1001., 1002., 1003., 1004., 1005., 1006., - 1007., 1008., 1009., 1010., 1011., 1012., 1013., 1014., 1015., 1016., 1017., 1018., 2001., 2002., 2003., - 2004., 2005., 2006., 2007., 2008., 2009., 2010., 2011., 2012., 25., 26., 27., 28., 29., 30., - 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42., 43., 44., 45., - 46., 47., 48., 1019., 1020., 1021., 1022., 1023., 1024., 1025., 1026., 1027., 1028., 1029., 1030., - 1031., 1032., 1033., 1034., 1035., 1036., 2013., 2014., 2015., 2016., 2017., 2018., 2019., 2020., 2021., - 2022., 2023., 2024., 49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60., - 61., 62., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72., 1037., 1038., 1039., - 1040., 1041., 1042., 1043., 1044., 1045., 1046., 1047., 1048., 1049., 1050., 1051., 1052., 1053., 1054., - 2025., 2026., 2027., 2028., 2029., 2030., 2031., 2032., 2033., 2034., 2035., 2036., 73., 74., 75., - 76., 77., 78., 79., 80., 81., 82., 83., 84., 85., 86., 87., 88., 89., 90., - 91., 92., 93., 94., 95., 96., 1055., 1056., 1057., 1058., 1059., 1060., 1061., 1062., 1063., - 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072., 2037., 2038., 2039., 2040., 2041., 2042., - 2043., 2044., 2045., 2046., 2047., 2048., 97., 98., 99., 100., 101., 102., 103., 104., 105., - 106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120., - 1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1081., 1082., 1083., 1084., 1085., 1086., 1087., - 1088., 1089., 1090., 2049., 2050., 2051., 2052., 2053., 2054., 2055., 2056., 2057., 2058., 2059., 2060., - 121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., - 136., 137., 138., 139., 140., 141., 142., 143., 144., 1091., 1092., 1093., 1094., 1095., 1096., - 1097., 1098., 1099., 1100., 1101., 1102., 1103., 1104., 1105., 1106., 1107., 1108., 2061., 2062., 2063., - 2064., 2065., 2066., 2067., 2068., 2069., 2070., 2071., 2072.}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_zero_length_1d_last) { - Shape shape_a{4}; - auto A = make_shared(element::f32, shape_a); - Shape shape_b{0}; - auto B = make_shared(element::f32, shape_b); - Shape shape_r{4}; - - auto r = make_shared(NodeVector{A, B}, 0); - auto f = make_shared(r, ParameterVector{A, B}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - vector a_data{1, 2, 3, 4}; - vector b_data(0); - - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, a_data); - auto b = backend->create_tensor(element::f32, shape_b); - copy_data(b, b_data); - - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b}); - EXPECT_TRUE(test::all_close_f((vector{1, 2, 3, 4}), read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_zero_length_1d_middle) { - Shape shape_a{4}; - auto A = make_shared(element::f32, shape_a); - Shape shape_b{0}; - auto B = make_shared(element::f32, shape_b); - Shape shape_c{4}; - auto C = make_shared(element::f32, shape_c); - Shape shape_r{8}; - - auto r = make_shared(NodeVector{A, B, C}, 0); - auto f = make_shared(r, ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - vector a_data{1, 2, 3, 4}; - vector b_data(0); - vector c_data{5, 6, 7, 8}; - - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, a_data); - auto b = backend->create_tensor(element::f32, shape_b); - copy_data(b, b_data); - auto c = backend->create_tensor(element::f32, shape_c); - copy_data(c, c_data); - - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f((vector{1, 2, 3, 4, 5, 6, 7, 8}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_zero_zero) { - Shape shape{0}; - auto constant_1 = op::Constant::create(element::f32, shape, {1}); - auto concat_1 = make_shared(NodeVector{constant_1, constant_1}, 0); - - auto f = make_shared(concat_1, ParameterVector{}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - auto result = backend->create_tensor(element::f32, shape); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {}); - - EXPECT_TRUE(test::all_close_f(vector{}, read_vector(result), MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, concat_zero_length_4d_middle) { - Shape shape_a{2, 2, 1, 1}; - auto A = make_shared(element::f32, shape_a); - Shape shape_b{2, 2, 0, 1}; - auto B = make_shared(element::f32, shape_b); - Shape shape_c{2, 2, 1, 1}; - auto C = make_shared(element::f32, shape_c); - Shape shape_r{2, 2, 2, 1}; - - auto r = make_shared(NodeVector{A, B, C}, 2); - auto f = make_shared(r, ParameterVector{A, B, C}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - vector a_data{1, 2, 3, 4}; - vector b_data(0); - vector c_data{5, 6, 7, 8}; - - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, a_data); - auto b = backend->create_tensor(element::f32, shape_b); - copy_data(b, b_data); - auto c = backend->create_tensor(element::f32, shape_c); - copy_data(c, c_data); - - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a, b, c}); - EXPECT_TRUE(test::all_close_f((vector{1, 5, 2, 6, 3, 7, 4, 8}), - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} diff --git a/ngraph/test/backend/tile.in.cpp b/ngraph/test/backend/tile.in.cpp deleted file mode 100644 index 94927c91dd0..00000000000 --- a/ngraph/test/backend/tile.in.cpp +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright (C) 2018-2021 Intel Corporation -// SPDX-License-Identifier: Apache-2.0 -// - -#include -#include -#include -#include -#include -#include - -#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}"; - -NGRAPH_TEST(${BACKEND_NAME}, tile_3d_small_data_rank) { - Shape shape_a{3}; - auto A = make_shared(element::f32, shape_a); - Shape shape_re{3}; - auto repeats = make_shared(element::i64, shape_re, vector{2, 2, 1}); - Shape shape_r{2, 2, 3}; - - auto tile = make_shared(A, repeats); - - auto f = make_shared(tile, ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3}); - - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(vector{1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3}, - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -} - -NGRAPH_TEST(${BACKEND_NAME}, tile_3d_few_repeats) { - Shape shape_a{2, 1, 3}; - auto A = make_shared(element::f32, shape_a); - Shape shape_re{2}; - auto repeats = make_shared(element::i64, shape_re, vector{2, 1}); - Shape shape_r{2, 2, 3}; - - auto tile = make_shared(A, repeats); - - auto f = make_shared(tile, ParameterVector{A}); - - auto backend = runtime::Backend::create("${BACKEND_NAME}"); - - // Create some tensors for input/output - auto a = backend->create_tensor(element::f32, shape_a); - copy_data(a, vector{1, 2, 3, 4, 5, 6}); - - auto result = backend->create_tensor(element::f32, shape_r); - - auto handle = backend->compile(f); - handle->call_with_validate({result}, {a}); - EXPECT_TRUE(test::all_close_f(vector{1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6}, - read_vector(result), - MIN_FLOAT_TOLERANCE_BITS)); -}