-// Copyright (C) 2018 Intel Corporation
+// Copyright (C) 2018-2019 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
TEST_P(BuiltInShapeInferImplTest, impl) {
auto impl = getShapeInferImpl(type);
ASSERT_NE(nullptr, impl);
- ASSERT_NO_THROW(sts = impl->inferShapes(newInOutShapes.inDims, layerParams.data, blobs, outShapes, &resp));
+ ASSERT_NO_THROW(
+ sts = impl->inferShapes(getBlobs(newInOutShapes.inDims), layerParams.data, blobs, outShapes, &resp));
if (canInfer) {
ASSERT_EQ(int(OK), sts) << resp.msg;
auto cnnNetworkImplPtr = buildSingleLayerNetwork<3>(type, inOutShapes, &layerParams.data, layerDataName);
auto reshaper = std::make_shared<Reshaper>(*cnnNetworkImplPtr);
auto inputShapes = setInputShapes(*cnnNetworkImplPtr.get(), newInOutShapes.inDims);
-
if (canInfer) {
reshaper->run(inputShapes);
checkNetworkInOut(*cnnNetworkImplPtr, newInOutShapes);
);
INSTANTIATE_TEST_CASE_P(
+ BuiltInMultiImpls, BuiltInShapeInferImplTest,
+ ::testing::Combine(
+ ::testing::Values(LayerType("Mul"), LayerType("Eltwise"), LayerType("Add"), LayerType("Div")),
+ ::testing::Values(InOutShapes({{{1, 1, 1, 1}, {1, 1, 1, 1}},
+ {{1, 1, 1, 1}}})),
+ ::testing::Values(NewInOutShapes({{{1, 3, 228, 228}, {1, 3, 228, 228}},
+ {{1, 3, 228, 228}}})),
+ ::testing::Values(MapParams(MapStrStr())),
+ ::testing::Values(LayerDataName("data")),
+ ::testing::Values(CanInfer(true)))
+);
+
+INSTANTIATE_TEST_CASE_P(
BuiltInGeneralImpls, BuiltInShapeInferImplTest,
::testing::Values(
::testing::make_tuple(LayerType("LRN"),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Reshape"),
- InOutShapes({{{1, 1, 300, 4}},
+ InOutShapes({{{1, 1, 300, 4}},
{{300, 4}}}),
- NewInOutShapes({{{1, 1, 500, 4}},
+ NewInOutShapes({{{1, 1, 500, 4}},
{{500, 4}}}),
MapParams(MapStrStr(std::map<std::string, std::string>{{"dim", "-1,4"}})),
LayerDataName("data"),
MapParams(MapParams(MapStrStr())),
LayerDataName("data"),
CanInfer(true)),
- ::testing::make_tuple(LayerType("PriorBoxClustered"),
- InOutShapes({{{2, 1, 4, 5}},
+ ::testing::make_tuple(LayerType("PriorBoxClustered"), // TODO 5D test
+ InOutShapes({ {{2, 1, 4, 5}, {2, 4, 5, 6}},
{{1, 2, 400}}}),
- NewInOutShapes({{{4, 1, 5, 5}},
- {{1, 2, 500}}}),
+ NewInOutShapes({ {{4, 1, 5, 5}, {3, 5, 6, 3}},
+ {{1, 2, 500}} }),
MapParams(MapStrStr(
std::map<std::string, std::string>{{"width", "86.000000,13.000000,57.000000,39.000000,68.000000"},
{"clip", "0"},
{"max_size", "315"},
{"clip", "0"},
{"flip", "1"},
+ { "offset", "0.5" },
{"aspect_ratio", "2"}})),
LayerDataName("data"),
CanInfer(true)),
InOutShapes({{{2, 512, 32, 32}, {2, 3, 512, 512}},
{{1, 2, 16384}}}),
NewInOutShapes({{{2, 512, 32, 32}, {2, 3, 512, 512}},
- {{1, 2, 16384}}}),
+ {{1, 2, 16384}}}),
MapParams(MapStrStr(
- std::map<std::string, std::string>{{"min_size", "35.84,52.46464"},
- {"max_size", ""},
- {"clip", "0"},
- {"step", "16"},
- {"flip", "0"},
- {"offset", "0.5"},
- {"aspect_ratio", "1.0,2.0,0.5"},
- {"scale_all_sizes", "0"}})),
+ std::map<std::string, std::string>{{"min_size", "35.84,52.46464"},
+ {"max_size", ""},
+ {"clip", "0"},
+ {"step", "16"},
+ {"flip", "0"},
+ {"offset", "0.5"},
+ {"aspect_ratio", "1.0,2.0,0.5"},
+ {"scale_all_sizes", "0"}})),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("PriorBox"),
NewInOutShapes({{{2, 512, 32, 32}, {2, 3, 512, 512}},
{{1, 2, 28672}}}),
MapParams(MapStrStr(
- std::map<std::string, std::string>{{"min_size", "35.84,52.46464"},
- {"max_size", ""},
- {"clip", "0"},
- {"step", "16"},
- {"offset", "0.5"},
- {"flip", "1"},
- {"aspect_ratio", "1.0,2.0,0.5"},
- {"scale_all_sizes", "0"}})),
+ std::map<std::string, std::string>{{"min_size", "35.84,52.46464"},
+ {"max_size", ""},
+ {"clip", "0"},
+ {"step", "16"},
+ {"offset", "0.5"},
+ {"flip", "1"},
+ {"aspect_ratio", "1.0,2.0,0.5"},
+ {"scale_all_sizes", "0"}})),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("DetectionOutput"),
- InOutShapes({{{2, 1, 4, 5}},
+ InOutShapes({{{2, 1, 4, 5}, { 2, 1, 4, 5 }, { 2, 1, 4, 5 }},
{{2, 1, 200, 7}}}),
- NewInOutShapes({{{4, 1, 5, 5}},
+ NewInOutShapes({{{4, 1, 5, 5}, { 4, 1, 5, 5 }, { 4, 1, 5, 5 }},
{{1, 1, 800, 7}}}),
MapParams(MapStrStr(std::map<std::string, std::string>{{"keep_top_k", "200"},
{"num_classes", "21"},
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Interp"),
- InOutShapes({{{2, 2, 33, 65}},
+ InOutShapes({{{2, 2, 33, 65}},
{{2, 2, 257, 513}}}),
- NewInOutShapes({{{2, 2, 33, 65}},
+ NewInOutShapes({{{2, 2, 33, 65}},
{{2, 2, 257, 513}}}),
MapParams(MapStrStr(std::map<std::string, std::string>{{"align_corners", "1"},
- {"height", "257"},
- {"pad_beg", "0"},
- {"pad_end", "0"},
- {"width", "513"}})),
+ {"height", "257"},
+ {"pad_beg", "0"},
+ {"pad_end", "0"},
+ {"width", "513"}})),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Interp"),
- InOutShapes({{{2, 2, 33, 65}},
+ InOutShapes({{{2, 2, 33, 65}},
{{2, 2, 66, 513}}}),
- NewInOutShapes({{{2, 2, 33, 65}},
+ NewInOutShapes({{{2, 2, 33, 65}},
{{2, 2, 66, 513}}}),
MapParams(MapStrStr(std::map<std::string, std::string>{{"align_corners", "1"},
- {"factor", "2"},
- {"width", "513"},
- {"pad_beg", "0"},
- {"pad_end", "0"}})),
+ {"factor", "2"},
+ {"width", "513"},
+ {"pad_beg", "0"},
+ {"pad_end", "0"}})),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Interp"),
- InOutShapes({{{2, 2, 33, 65}},
+ InOutShapes({{{2, 2, 33, 65}},
{{2, 2, 257, 130}}}),
- NewInOutShapes({{{2, 2, 33, 65}},
+ NewInOutShapes({{{2, 2, 33, 65}},
{{2, 2, 257, 130}}}),
MapParams(MapStrStr(std::map<std::string, std::string>{{"align_corners", "1"},
- {"factor", "2"},
- {"height", "257"},
- {"pad_beg", "0"},
- {"pad_end", "0"}})),
+ {"factor", "2"},
+ {"height", "257"},
+ {"pad_beg", "0"},
+ {"pad_end", "0"}})),
LayerDataName("data"),
CanInfer(true)),
- ::testing::make_tuple(LayerType("Interp"),
- InOutShapes({{{2, 2, 33, 65}},
- {{2, 2, 257, 130}}}),
- NewInOutShapes({{{2, 2, 33, 65}},
- {{2, 2, 257, 130}}}),
- MapParams(MapStrStr(std::map<std::string, std::string>{{"align_corners", "1"},
- {"width", "513"},
- {"pad_beg", "0"},
- {"pad_end", "0"}})),
- LayerDataName("data"),
- CanInfer(false)),
::testing::make_tuple(LayerType("ROIPooling"),
InOutShapes({{{2, 3, 4, 5}, {150, 5}},
{{150, 3, 6, 6}}}),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("PSROIPooling"),
- InOutShapes({{{1, 3, 4, 5}, {150, 5}},
+ InOutShapes({{{1, 3, 4, 5}, {150, 5}},
{{150, 2, 6, 6}}}),
NewInOutShapes({{{2, 1, 5, 5}, {200, 5}},
{{200, 2, 6, 6}}}),
{"out_sizes", "2,4"}})),
LayerDataName("data"),
CanInfer(true)),
- ::testing::make_tuple(LayerType("CTCGreedyDecoder"),
- InOutShapes({{{88, 1, 48, 1}},
- {{1, 88, 1, 1}}}),
- NewInOutShapes({{{88, 2, 48, 1}},
- {{2, 88, 1, 1}}}),
- MapParams(MapStrStr()),
- LayerDataName("data"),
- CanInfer(true)),
::testing::make_tuple(LayerType("Proposal"),
InOutShapes({{{1, 12, 34, 62}, {1, 24, 34, 62}, {1, 6}},
{{200, 5}}}),
{{1, 21125}}}),
NewInOutShapes({{{20, 125, 16, 13}},
{{20, 26000}}}),
- MapParams(MapStrStr()),
+ MapParams(MapStrStr({{"axis", "1"},
+ {"end_axis", "-1"},
+ {"do_softmax", "1"}})),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("ArgMax"),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Pad"),
- InOutShapes({{{3, 3, 15, 10}},
+ InOutShapes({{{3, 3, 15, 10}},
{{9, 11, 25, 22}}}),
- NewInOutShapes({{{4, 2, 20, 15}},
+ NewInOutShapes({{{4, 2, 20, 15}},
{{10, 10, 30, 27}}}),
- MapParams(MapStrStr({{"pads_begin", "1,2,3,4"},
- {"pads_end", "5,6,7,8"},
- {"pad_mode", "edge"},
- {"pad_value", "1.0f"}})),
+ MapParams(MapStrStr({{"pads_begin", "1,2,3,4"},
+ {"pads_end", "5,6,7,8"},
+ {"pad_mode", "edge"},
+ {"pad_value", "1.0f"}})),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Pad"),
{{16, 18, 25, 22}}}),
NewInOutShapes({{{20, 30, 40, 50}},
{{26, 38, 40, 50}}}),
- MapParams(MapStrStr({{"pads_begin", "1,2,0,0"},
- {"pads_end", "5,6,0,0"},
- {"pad_mode", "reflect"},
- {"pad_value", "1.0f"}})),
+ MapParams(MapStrStr({{"pads_begin", "1,2,0,0"},
+ {"pads_end", "5,6,0,0"},
+ {"pad_mode", "reflect"},
+ {"pad_value", "1.0f"}})),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Pad"),
InOutShapes({{{10, 10, 15, 10}},
{{16, 18, 25, 22}}}),
- NewInOutShapes({{{4, 2, 20, 15}},
+ NewInOutShapes({{{4, 2, 20, 15}},
{{10, 10, 30, 27}}}),
- MapParams(MapStrStr({{"pads_begin", "1,2,3,4"},
- {"pads_end", "5,6,7,8"},
- {"pad_mode", "reflect"},
- {"pad_value", "1.0f"}})),
+ MapParams(MapStrStr({{"pads_begin", "1,2,3,4"},
+ {"pads_end", "5,6,7,8"},
+ {"pad_mode", "reflect"},
+ {"pad_value", "1.0f"}})),
LayerDataName("data"),
CanInfer(false))
)
);
+// There are gtest limitation on tests number: 50
INSTANTIATE_TEST_CASE_P(
BuiltInGeneralImpls2, BuiltInShapeInferImplTest,
::testing::Values(
::testing::make_tuple(LayerType("Gather"),
InOutShapes({{{7, 16}, {1, 25}},
{{1, 25, 16}}}),
- NewInOutShapes({{{7, 16}, {12, 25}},
+ NewInOutShapes({{{7, 16}, {12, 25}},
{{12, 25, 16}}}),
MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "0"}})),
LayerDataName("data"),
MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "-1"}})),
LayerDataName("data"),
CanInfer(true)),
+ ::testing::make_tuple(LayerType("CTCGreedyDecoder"),
+ InOutShapes({{{88, 1, 48, 1}},
+ {{1, 88, 1, 1}}}),
+ NewInOutShapes({{{88, 2, 48, 1}},
+ {{2, 88, 1, 1}}}),
+ MapParams(MapStrStr()),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("CTCGreedyDecoder"),
+ InOutShapes({{{88, 1, 71}, {88, 1}},
+ {{1, 88, 1, 1}}}),
+ NewInOutShapes({{{88, 2, 71}, {88, 2}},
+ {{2, 88, 1, 1}}}),
+ MapParams(MapStrStr()),
+ LayerDataName("data"),
+ CanInfer(true)),
::testing::make_tuple(LayerType("Reshape"),
InOutShapes({{{1, 2}},
{{1, 1}}}),
NewInOutShapes({{{1, 2}},
{{1, 1}}}),
- MapParams(MapStrStr(std::map<std::string, std::string>{{"dim", "1,1"}})), // dim doesn't match input
+ MapParams(MapStrStr(
+ std::map<std::string, std::string>{{"dim", "1,1"}})), // dim doesn't match input
LayerDataName("data"),
CanInfer(false)),
::testing::make_tuple(LayerType("Flatten"),
{{40}}}),
NewInOutShapes({{{4, 1, 4, 5}},
{{80}}}),
- MapParams(MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "0"},
+ MapParams(MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "0"},
{"end_axis", "-1"}}))),
LayerDataName("data"),
CanInfer(true)),
{{2, 8, 5}}}),
NewInOutShapes({{{4, 2, 4, 5}},
{{4, 8, 5}}}),
- MapParams(MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "1"},
+ MapParams(MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "1"},
{"end_axis", "2"}}))),
LayerDataName("data"),
CanInfer(true)),
{{2, 40}}}),
NewInOutShapes({{{4, 2, 4, 5}},
{{4, 40}}}),
- MapParams(MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "1"}}))),
+ MapParams(
+ MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "1"}}))),
LayerDataName("data"),
CanInfer(true)),
::testing::make_tuple(LayerType("Flatten"),
{{4, 4, 5}}}),
NewInOutShapes({{{4, 2, 4, 5}},
{{8, 4, 5}}}),
- MapParams(MapParams(MapStrStr(std::map<std::string, std::string>{{"end_axis", "1"}}))),
+ MapParams(MapParams(
+ MapStrStr(std::map<std::string, std::string>{{"end_axis", "1"}}))),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("Interp"),
+ InOutShapes({{{2, 2, 100, 16}},
+ {{2, 2, 25, 4}}}),
+ NewInOutShapes({{{2, 2, 201, 33}},
+ {{2, 2, 50, 8}}}),
+ MapParams(MapStrStr(std::map<std::string, std::string>{{"align_corners", "1"},
+ {"factor", "0.25"},
+ {"pad_beg", "0"},
+ {"pad_end", "0"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("Interp"),
+ InOutShapes({{{2, 2, 100, 16}},
+ {{2, 2, 100, 16}}}),
+ NewInOutShapes({{{2, 2, 101, 33}},
+ {{2, 2, 101, 33}}}),
+ MapParams(MapStrStr(std::map<std::string, std::string>{{"align_corners", "1"},
+ {"shrink_factor", "1.5"},
+ {"zoom_factor", "1.5"},
+ {"pad_beg", "0"},
+ {"pad_end", "0"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("ShuffleChannels"),
+ InOutShapes({{{1, 2, 3, 4}},
+ {{1, 2, 3, 4}}}),
+ NewInOutShapes({{{2, 4, 4, 7}},
+ {{2, 4, 4, 7}}}),
+ MapParams(MapStrStr(std::map<std::string, std::string>{{"axis", "1"},
+ {"group", "2"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("DepthToSpace"),
+ InOutShapes({{{4, 2, 3}},
+ {{1, 4, 6}}}),
+ NewInOutShapes({{{8, 3, 4}},
+ {{2, 6, 8}}}),
+ MapParams(MapStrStr(std::map<std::string, std::string>{{"block_size", "2"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("SpaceToDepth"),
+ InOutShapes({ { { 1, 4, 6 } },
+ { { 4, 2, 3 } } }),
+ NewInOutShapes({ { { 2, 6, 8 } },
+ { { 8, 3, 4 } } }),
+ MapParams(MapStrStr(std::map<std::string, std::string>{ {"block_size", "2"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("ReverseSequence"),
+ InOutShapes({{{3, 4, 5}, {3}},
+ {{3, 4, 5}}}),
+ NewInOutShapes({{{4, 8, 9}, {4}},
+ {{4, 8, 9}}}),
+ MapParams(MapStrStr(std::map<std::string, std::string>{{"seq_axis", "1"},
+ {"batch_axis", "0"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("RegionYolo"),
+ InOutShapes({{{1, 125, 13, 13}},
+ {{1 * 125, 13, 13}}}),
+ NewInOutShapes({{{20, 125, 16, 13}},
+ {{20 * 125, 16, 13}}}),
+ MapParams(MapStrStr({{"axis", "0"},
+ {"end_axis", "1"},
+ {"do_softmax", "1"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("RegionYolo"),
+ InOutShapes({{{1, 125, 13, 13}},
+ {{1 * 125 * 13, 13}}}),
+ NewInOutShapes({{{20, 125, 16, 13}},
+ {{20 * 125 * 16, 13}}}),
+ MapParams(MapStrStr({{"axis", "0"},
+ {"end_axis", "2"},
+ {"do_softmax", "1"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("RegionYolo"),
+ InOutShapes({{{1, 125, 13, 13}},
+ {{1, (80 + 4 + 1) * 125, 13, 13}}}),
+ NewInOutShapes({{{20, 125, 16, 13}},
+ {{20, (80 + 4 + 1) * 3, 16, 13}}}),
+ MapParams(MapStrStr({{"axis", "1"},
+ {"end_axis", "-1"},
+ {"do_softmax", "0"},
+ {"classes", "80"},
+ {"coords", "4"},
+ {"mask", "6,7,8"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("Upsampling"),
+ InOutShapes({{{1, 3, 4, 5, 6}},
+ {{1, 3, 8, 10, 12}}}),
+ NewInOutShapes({{{2, 1, 7, 5, 5}},
+ {{2, 1, 14, 10, 10}}}),
+ MapParams(MapStrStr(std::map<std::string, std::string>{{"scale", "2"}})),
+ LayerDataName("data"),
+ CanInfer(true)),
+ ::testing::make_tuple(LayerType("Quantize"),
+ InOutShapes({{{1, 64, 10, 10}, {1, 64, 1, 1}, {1, 64, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
+ {{1, 64, 10, 10}}}),
+ NewInOutShapes({{{2, 128, 10, 10}, {1, 128, 1, 1}, {1, 128, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}},
+ {{2, 128, 10, 10}}}),
+ MapParams(MapStrStr(std::map<std::string, std::string>{ {"levels", "2"}})),
LayerDataName("data"),
CanInfer(true))
)
::testing::Values(CanInfer())
)
);
+
projects / platform / upstream / dldt.git / blobdiff