Migrate Movement 1 (Broadcast-1, Concat-1, Tile-1) (#8388)
* Migrate Movement 1 (Broadcast-1, Concat-1, Tile-1) * Add Broadcast-3 * Update to namespace opset * Add broadcast_test_helper
This commit is contained in:
Steve Yoo
GitHub
528
docs/template_plugin/tests/functional/op_reference/broadcast.cpp
Normal file
528
docs/template_plugin/tests/functional/op_reference/broadcast.cpp
Normal file
@@ -0,0 +1,528 @@
|
||||
// Copyright (C) 2021 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#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<BroadcastParams>, 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<BroadcastParams>& 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<Function> CreateFunction(const BroadcastParams& params) {
|
||||
const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
|
||||
const auto f = std::make_shared<Function>(
|
||||
std::make_shared<opset1::Broadcast>(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<Function> CreateFunction(const BroadcastParams& params) {
|
||||
const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
|
||||
const auto f = std::make_shared<Function>(
|
||||
std::make_shared<opset3::Broadcast>(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<BroadcastParamsExplicitAxis>, 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<BroadcastParamsExplicitAxis>& 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<Function> CreateFunction(const BroadcastParamsExplicitAxis& params) {
|
||||
const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
|
||||
const auto f = std::make_shared<Function>(
|
||||
std::make_shared<opset1::Broadcast>(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<BroadcastParamsTestHelper>, public CommonReferenceTest {
|
||||
public:
|
||||
void SetUp() override {
|
||||
auto params = GetParam();
|
||||
function = CreateFunction(params);
|
||||
std::vector<float> inpData(shape_size<const Shape>(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<float> inpData(shape_size<const Shape>(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<BroadcastParamsTestHelper>& 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<Function> CreateFunction(const BroadcastParamsTestHelper& params) {
|
||||
const auto A = std::make_shared<opset1::Parameter>(element::f32, params.shapeA);
|
||||
const auto shape_const = opset1::Constant::create(element::u64, Shape{params.shapeR.size()}, params.shapeR);
|
||||
std::shared_ptr<Node> 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<opset1::Broadcast>(A, shape_const, axes_const);
|
||||
} else {
|
||||
broadcast = std::make_shared<opset1::Broadcast>(A, shape_const);
|
||||
}
|
||||
auto f = std::make_shared<Function>(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<Function> CreateFunction(const BroadcastParamsExplicitAxis& params) {
|
||||
const auto A = std::make_shared<opset1::Parameter>(params.dataTensor.type, params.dataTensor.shape);
|
||||
auto broadcast = std::make_shared<opset1::Broadcast>(
|
||||
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<opset1::Reverse>(broadcast,
|
||||
opset1::Constant::create(element::i64, {1}, {1}),
|
||||
opset1::Reverse::Mode::INDEX);
|
||||
auto f = std::make_shared<Function>(NodeVector{reverse}, ParameterVector{A});
|
||||
return f;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_P(ReferenceBroadcastTestExplicitAxisReversed, CompareWithRefs) {
|
||||
Exec();
|
||||
}
|
||||
|
||||
template <element::Type_t ET>
|
||||
std::vector<BroadcastParams> generateParams() {
|
||||
using T = typename element_type_traits<ET>::value_type;
|
||||
std::vector<BroadcastParams> params {
|
||||
BroadcastParams(
|
||||
Tensor(ET, {}, std::vector<T>{6}),
|
||||
Tensor(element::u64, {1}, std::vector<uint64_t>{4}),
|
||||
Tensor(ET, {4}, std::vector<T>{6, 6, 6, 6}),
|
||||
"broadcast_scalar_vector"),
|
||||
BroadcastParams(
|
||||
Tensor(ET, {}, std::vector<T>{6}),
|
||||
Tensor(element::u64, {2}, std::vector<uint64_t>{2, 2}),
|
||||
Tensor(ET, {2, 2}, std::vector<T>{6, 6, 6, 6}),
|
||||
"broadcast_scalar_matrix"),
|
||||
BroadcastParams(
|
||||
Tensor(ET, {}, std::vector<T>{6}),
|
||||
Tensor(element::u64, {3}, std::vector<uint64_t>{2, 2, 2}),
|
||||
Tensor(ET, {2, 2, 2}, std::vector<T>{6, 6, 6, 6, 6, 6, 6, 6}),
|
||||
"broadcast_scalar_tensor"),
|
||||
BroadcastParams(
|
||||
Tensor(ET, {2, 2, 2}, std::vector<T>{2, 4, 6, 8, 16, 32, 64, 127}),
|
||||
Tensor(element::u64, {3}, std::vector<uint64_t>{2, 2, 2}),
|
||||
Tensor(ET, {2, 2, 2}, std::vector<T>{2, 4, 6, 8, 16, 32, 64, 127}),
|
||||
"broadcast_trivial"),
|
||||
BroadcastParams(
|
||||
Tensor(ET, {2, 2}, std::vector<T>{1, 2, 3, 4}),
|
||||
Tensor(element::u64, {3}, std::vector<uint64_t>{2, 2, 2}),
|
||||
Tensor(ET, {2, 2, 2}, std::vector<T>{1, 2, 3, 4, 1, 2, 3, 4}),
|
||||
"broadcast_matrix_0"),
|
||||
};
|
||||
return params;
|
||||
}
|
||||
|
||||
std::vector<BroadcastParams> generateCombinedParams() {
|
||||
const std::vector<std::vector<BroadcastParams>> generatedParams {
|
||||
generateParams<element::Type_t::i8>(),
|
||||
generateParams<element::Type_t::i16>(),
|
||||
generateParams<element::Type_t::i32>(),
|
||||
generateParams<element::Type_t::i64>(),
|
||||
generateParams<element::Type_t::u8>(),
|
||||
generateParams<element::Type_t::u16>(),
|
||||
generateParams<element::Type_t::u32>(),
|
||||
generateParams<element::Type_t::u64>(),
|
||||
generateParams<element::Type_t::bf16>(),
|
||||
generateParams<element::Type_t::f16>(),
|
||||
generateParams<element::Type_t::f32>(),
|
||||
generateParams<element::Type_t::f64>(),
|
||||
};
|
||||
std::vector<BroadcastParams> 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 <element::Type_t ET>
|
||||
std::vector<BroadcastParamsExplicitAxis> generateParamsExplicitAxis() {
|
||||
using T = typename element_type_traits<ET>::value_type;
|
||||
std::vector<BroadcastParamsExplicitAxis> params {
|
||||
BroadcastParamsExplicitAxis(
|
||||
Tensor(ET, {}, std::vector<T>{6}),
|
||||
Tensor(element::u64, {2}, std::vector<uint64_t>{1, 2}),
|
||||
Tensor(element::i64, {1}, std::vector<int64_t>{0}),
|
||||
Tensor(ET, {1, 2}, std::vector<T>{6, 6}),
|
||||
"broadcast_scalar_vector_explicit_axis_0"),
|
||||
BroadcastParamsExplicitAxis(
|
||||
Tensor(ET, {3}, std::vector<T>{1, 2, 3}),
|
||||
Tensor(element::u64, {2}, std::vector<uint64_t>{3, 4}),
|
||||
Tensor(element::i64, {1}, std::vector<int64_t>{0}),
|
||||
Tensor(ET, {3, 4}, std::vector<T>{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3}),
|
||||
"broadcast_vector_colwise"),
|
||||
BroadcastParamsExplicitAxis(
|
||||
Tensor(ET, {4}, std::vector<T>{1, 2, 3, 4}),
|
||||
Tensor(element::u64, {2}, std::vector<uint64_t>{3, 4}),
|
||||
Tensor(element::i64, {1}, std::vector<int64_t>{1}),
|
||||
Tensor(ET, {3, 4}, std::vector<T>{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}),
|
||||
"broadcast_vector_rowwise"),
|
||||
BroadcastParamsExplicitAxis(
|
||||
Tensor(ET, {1}, std::vector<T>{4}),
|
||||
Tensor(element::u64, {2}, std::vector<uint64_t>{3, 1}),
|
||||
Tensor(element::i64, {1}, std::vector<int64_t>{1}),
|
||||
Tensor(ET, {3, 1}, std::vector<T>{4, 4, 4}),
|
||||
"broadcast_scalar_to_matrix"),
|
||||
BroadcastParamsExplicitAxis(
|
||||
Tensor(ET, {2, 2}, std::vector<T>{1, 2, 3, 4}),
|
||||
Tensor(element::u64, {3}, std::vector<uint64_t>{2, 2, 2}),
|
||||
Tensor(element::i64, {2}, std::vector<int64_t>{0, 2}),
|
||||
Tensor(ET, {2, 2, 2}, std::vector<T>{1, 2, 1, 2, 3, 4, 3, 4}),
|
||||
"broadcast_matrix_1"),
|
||||
BroadcastParamsExplicitAxis(
|
||||
Tensor(ET, {2, 2}, std::vector<T>{1, 2, 3, 4}),
|
||||
Tensor(element::u64, {3}, std::vector<uint64_t>{2, 2, 2}),
|
||||
Tensor(element::i64, {2}, std::vector<int64_t>{0, 1}),
|
||||
Tensor(ET, {2, 2, 2}, std::vector<T>{1, 1, 2, 2, 3, 3, 4, 4}),
|
||||
"broadcast_matrix_2"),
|
||||
};
|
||||
return params;
|
||||
}
|
||||
|
||||
std::vector<BroadcastParamsExplicitAxis> generateCombinedParamsExplicitAxis() {
|
||||
const std::vector<std::vector<BroadcastParamsExplicitAxis>> generatedParams {
|
||||
generateParamsExplicitAxis<element::Type_t::i8>(),
|
||||
generateParamsExplicitAxis<element::Type_t::i16>(),
|
||||
generateParamsExplicitAxis<element::Type_t::i32>(),
|
||||
generateParamsExplicitAxis<element::Type_t::i64>(),
|
||||
generateParamsExplicitAxis<element::Type_t::u8>(),
|
||||
generateParamsExplicitAxis<element::Type_t::u16>(),
|
||||
generateParamsExplicitAxis<element::Type_t::u32>(),
|
||||
generateParamsExplicitAxis<element::Type_t::u64>(),
|
||||
generateParamsExplicitAxis<element::Type_t::bf16>(),
|
||||
generateParamsExplicitAxis<element::Type_t::f16>(),
|
||||
generateParamsExplicitAxis<element::Type_t::f32>(),
|
||||
generateParamsExplicitAxis<element::Type_t::f64>(),
|
||||
};
|
||||
std::vector<BroadcastParamsExplicitAxis> 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<BroadcastParamsTestHelper> generateParamsTestHelper() {
|
||||
std::vector<BroadcastParamsTestHelper> 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<BroadcastParamsTestHelper> generateCombinedParamsTestHelper() {
|
||||
const std::vector<std::vector<BroadcastParamsTestHelper>> generatedParams {
|
||||
generateParamsTestHelper(),
|
||||
};
|
||||
std::vector<BroadcastParamsTestHelper> 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 <element::Type_t ET>
|
||||
std::vector<BroadcastParamsExplicitAxis> generateParamsExplicitAxisReversed() {
|
||||
using T = typename element_type_traits<ET>::value_type;
|
||||
std::vector<BroadcastParamsExplicitAxis> params {
|
||||
BroadcastParamsExplicitAxis(
|
||||
Tensor(ET, {4}, std::vector<T>{1, 2, 3, 4}),
|
||||
Tensor(element::u64, {2}, std::vector<uint64_t>{3, 4}),
|
||||
Tensor(element::i64, {1}, std::vector<int64_t>{1}),
|
||||
Tensor(ET, {3, 4}, std::vector<T>{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}),
|
||||
"broadcast_vector_rowwise_reversed"),
|
||||
};
|
||||
return params;
|
||||
}
|
||||
|
||||
std::vector<BroadcastParamsExplicitAxis> generateCombinedParamsExplicitAxisReversed() {
|
||||
const std::vector<std::vector<BroadcastParamsExplicitAxis>> generatedParams {
|
||||
generateParamsExplicitAxisReversed<element::Type_t::i8>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::i16>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::i32>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::i64>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::u8>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::u16>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::u32>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::u64>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::bf16>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::f16>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::f32>(),
|
||||
generateParamsExplicitAxisReversed<element::Type_t::f64>(),
|
||||
};
|
||||
std::vector<BroadcastParamsExplicitAxis> 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
|
||||
1433
docs/template_plugin/tests/functional/op_reference/concat.cpp
Normal file
1433
docs/template_plugin/tests/functional/op_reference/concat.cpp
Normal file
File diff suppressed because it is too large
Load Diff
110
docs/template_plugin/tests/functional/op_reference/tile.cpp
Normal file
110
docs/template_plugin/tests/functional/op_reference/tile.cpp
Normal file
@@ -0,0 +1,110 @@
|
||||
// Copyright (C) 2021 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#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<TileParams>, 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<TileParams>& 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<Function> CreateFunction(const TileParams& params) {
|
||||
const auto A = std::make_shared<opset1::Parameter>(params.A.type, params.A.shape);
|
||||
const auto repeats = std::make_shared<opset1::Constant>(params.repeats.type, params.repeats.shape,
|
||||
params.repeats.data.data());
|
||||
const auto tile = std::make_shared<opset1::Tile>(A, repeats);
|
||||
const auto f = std::make_shared<Function>(NodeVector{tile}, ParameterVector{A});
|
||||
return f;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_P(ReferenceTileTest, CompareWithRefs) {
|
||||
Exec();
|
||||
}
|
||||
|
||||
template <element::Type_t ET>
|
||||
std::vector<TileParams> generateParams() {
|
||||
using T = typename element_type_traits<ET>::value_type;
|
||||
std::vector<TileParams> params {
|
||||
TileParams(
|
||||
Tensor(ET, {3}, std::vector<T>{1, 2, 3}),
|
||||
Tensor(element::i64, {3}, std::vector<int64_t>{2, 2, 1}),
|
||||
Tensor(ET, {2, 2, 3}, std::vector<T>{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<T>{1, 2, 3, 4, 5, 6}),
|
||||
Tensor(element::i64, {2}, std::vector<int64_t>{2, 1}),
|
||||
Tensor(ET, {2, 2, 3}, std::vector<T>{1, 2, 3, 1, 2, 3, 4, 5, 6, 4, 5, 6}),
|
||||
"tile_3d_few_repeats"),
|
||||
};
|
||||
return params;
|
||||
}
|
||||
|
||||
std::vector<TileParams> generateCombinedParams() {
|
||||
const std::vector<std::vector<TileParams>> generatedParams {
|
||||
generateParams<element::Type_t::i8>(),
|
||||
generateParams<element::Type_t::i16>(),
|
||||
generateParams<element::Type_t::i32>(),
|
||||
generateParams<element::Type_t::i64>(),
|
||||
generateParams<element::Type_t::u8>(),
|
||||
generateParams<element::Type_t::u16>(),
|
||||
generateParams<element::Type_t::u32>(),
|
||||
generateParams<element::Type_t::u64>(),
|
||||
generateParams<element::Type_t::bf16>(),
|
||||
generateParams<element::Type_t::f16>(),
|
||||
generateParams<element::Type_t::f32>(),
|
||||
generateParams<element::Type_t::f64>(),
|
||||
};
|
||||
std::vector<TileParams> 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
|
||||
@@ -98,6 +98,8 @@ std::vector<std::string> disabledTestPatterns() {
|
||||
R"(.*ReferenceTopKTest.*aType=u16.*)",
|
||||
R"(.*ReferenceTopKTest.*aType=bf16.*)",
|
||||
R"(.*ReferenceTopKTest.*aType=f64.*)",
|
||||
// CVS-63947
|
||||
R"(.*ReferenceConcatTest.*concat_zero_.*)",
|
||||
};
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
Reference in New Issue
Block a user