From ad668d6ac61f95d172b8db9da956706f7a528e2a Mon Sep 17 00:00:00 2001 From: Alexandra Sidorova Date: Tue, 7 Dec 2021 09:44:33 +0300 Subject: [PATCH] [CPU] Added MaxPool-8 support (#8788) --- .../src/mkldnn_plugin/mkldnn_descriptor.cpp | 8 +- .../src/mkldnn_plugin/mkldnn_descriptor.h | 4 +- .../nodes/mkldnn_pooling_node.cpp | 161 ++++++++----- .../mkldnn_plugin/nodes/mkldnn_pooling_node.h | 23 +- .../single_layer_tests/pooling.cpp | 211 +++++++++++++++++- .../plugin/cpu/single_layer_tests/pooling.cpp | 154 ++++++++++++- .../include/single_layer_tests/pooling.hpp | 5 + .../single_layer/pooling.hpp | 30 +++ .../src/single_layer/pooling.cpp | 56 +++++ .../include/ngraph_functions/builders.hpp | 9 + .../ngraph_functions/src/pooling.cpp | 13 ++ 11 files changed, 580 insertions(+), 94 deletions(-) diff --git a/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.cpp b/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.cpp index d4daf57fd38..a08c640e4c1 100644 --- a/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.cpp +++ b/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.cpp @@ -94,12 +94,12 @@ MKLDNNDescriptor::operator std::shared_ptr() { return typeDesc->getPtr(); } -MKLDNNDescriptor::MKLDNNDescriptor(std::shared_ptr desc) { - this->desc.reset(new DescFwdImpl(desc)); +MKLDNNDescriptor::MKLDNNDescriptor(std::shared_ptr desc) { + this->desc.reset(new DescFwdImpl(desc)); } -MKLDNNDescriptor::operator std::shared_ptr() { - auto typeDesc = std::dynamic_pointer_cast>(desc); +MKLDNNDescriptor::operator std::shared_ptr() { + auto typeDesc = std::dynamic_pointer_cast>(desc); if (typeDesc == nullptr) { IE_THROW() << "Cannot cast descriptor!"; } diff --git a/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.h b/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.h index d02f9c3da70..d85d447ca6c 100644 --- a/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.h +++ b/inference-engine/src/mkldnn_plugin/mkldnn_descriptor.h @@ -28,8 +28,8 @@ public: explicit MKLDNNDescriptor(std::shared_ptr desc); operator std::shared_ptr(); - explicit MKLDNNDescriptor(std::shared_ptr desc); - operator std::shared_ptr(); + explicit MKLDNNDescriptor(std::shared_ptr desc); + operator std::shared_ptr(); explicit MKLDNNDescriptor(std::shared_ptr desc); operator std::shared_ptr(); diff --git a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.cpp b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.cpp index 32b0fd6aaee..379253233ee 100644 --- a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.cpp +++ b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.cpp @@ -20,10 +20,15 @@ using namespace mkldnn; using namespace MKLDNNPlugin; using namespace InferenceEngine; -bool MKLDNNPoolingNode::isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept { +bool MKLDNNPoolingNode::isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept { try { - if (!ngraph::as_type_ptr(op) && !ngraph::as_type_ptr(op)) { - errorMessage = "Only opset1 MaxPool and AvgPool operations are supported"; + if (ov::is_type(op)) { + if (!op->get_output_target_inputs(1).empty()) { + errorMessage = "MaxPool from opset8 is supported only with one output"; + return false; + } + } else if (!ov::is_type(op) && !ov::is_type(op)) { + errorMessage = "MaxPool and AvgPool from opset1 and MaxPool from opset8 are supported"; return false; } } catch (...) { @@ -32,48 +37,52 @@ bool MKLDNNPoolingNode::isSupportedOperation(const std::shared_ptr& op, const mkldnn::engine& eng, MKLDNNWeightsSharing::Ptr &cache) +MKLDNNPoolingNode::MKLDNNPoolingNode(const std::shared_ptr& op, const mkldnn::engine& eng, MKLDNNWeightsSharing::Ptr &cache) : MKLDNNNode(op, eng, cache) { std::string errorMessage; if (!isSupportedOperation(op, errorMessage)) { IE_THROW(NotImplemented) << errorMessage; } - auto maxPoolOp = ngraph::as_type_ptr(op); - auto avgPoolOp = ngraph::as_type_ptr(op); - if (maxPoolOp) { + auto get_attributes = [](std::vector& internal_attribute, const std::vector external_attribute) { + for (size_t i = 0; i < external_attribute.size(); i++) { + internal_attribute.push_back(static_cast(external_attribute[i])); + } + }; + + if (auto maxPoolOp_v8 = ov::as_type_ptr(op)) { + isMaxPool8 = true; algorithm = PoolingMax; exclude_pad = false; - for (int i = 0; i < maxPoolOp->get_strides().size(); i++) { - stride.push_back(static_cast(maxPoolOp->get_strides()[i])); - } - for (int i = 0; i < maxPoolOp->get_kernel().size(); i++) { - kernel.push_back(static_cast(maxPoolOp->get_kernel()[i])); - } - for (int i = 0; i < maxPoolOp->get_pads_begin().size(); i++) { - data_pad_begin.push_back(static_cast(maxPoolOp->get_pads_begin()[i])); - } - for (int i = 0; i < maxPoolOp->get_pads_end().size(); i++) { - data_pad_end.push_back(static_cast(maxPoolOp->get_pads_end()[i])); - } - auto_pad = (maxPoolOp->get_auto_pad() == ov::op::PadType::SAME_LOWER || maxPoolOp->get_auto_pad() == ov::op::PadType::SAME_UPPER); - } else if (avgPoolOp) { + get_attributes(dilation, maxPoolOp_v8->get_dilations()); + get_attributes(stride, maxPoolOp_v8->get_strides()); + get_attributes(kernel, maxPoolOp_v8->get_kernel()); + get_attributes(data_pad_begin, maxPoolOp_v8->get_pads_begin()); + get_attributes(data_pad_end, maxPoolOp_v8->get_pads_end()); + + auto_pad = (maxPoolOp_v8->get_auto_pad() == ov::op::PadType::SAME_LOWER || maxPoolOp_v8->get_auto_pad() == ov::op::PadType::SAME_UPPER); + } else if (auto maxPoolOp_v1 = ov::as_type_ptr(op)) { + algorithm = PoolingMax; + exclude_pad = false; + + get_attributes(stride, maxPoolOp_v1->get_strides()); + get_attributes(kernel, maxPoolOp_v1->get_kernel()); + get_attributes(data_pad_begin, maxPoolOp_v1->get_pads_begin()); + get_attributes(data_pad_end, maxPoolOp_v1->get_pads_end()); + dilation.resize(kernel.size(), 1); + + auto_pad = (maxPoolOp_v1->get_auto_pad() == ov::op::PadType::SAME_LOWER || maxPoolOp_v1->get_auto_pad() == ov::op::PadType::SAME_UPPER); + } else if (auto avgPoolOp = ov::as_type_ptr(op)) { algorithm = PoolingAvg; exclude_pad = avgPoolOp->get_exclude_pad(); - for (int i = 0; i < avgPoolOp->get_strides().size(); i++) { - stride.push_back(static_cast(avgPoolOp->get_strides()[i])); - } - for (int i = 0; i < avgPoolOp->get_kernel().size(); i++) { - kernel.push_back(static_cast(avgPoolOp->get_kernel()[i])); - } - for (int i = 0; i < avgPoolOp->get_pads_begin().size(); i++) { - data_pad_begin.push_back(static_cast(avgPoolOp->get_pads_begin()[i])); - } - for (int i = 0; i < avgPoolOp->get_pads_end().size(); i++) { - data_pad_end.push_back(static_cast(avgPoolOp->get_pads_end()[i])); - } + get_attributes(stride, avgPoolOp->get_strides()); + get_attributes(kernel, avgPoolOp->get_kernel()); + get_attributes(data_pad_begin, avgPoolOp->get_pads_begin()); + get_attributes(data_pad_end, avgPoolOp->get_pads_end()); + dilation.resize(kernel.size(), 1); + auto_pad = (avgPoolOp->get_auto_pad() == ov::op::PadType::SAME_LOWER || avgPoolOp->get_auto_pad() == ov::op::PadType::SAME_UPPER); } } @@ -94,20 +103,23 @@ std::vector MKLDNNPoolingNode::getAvailableFormatsForDims(co return {memory::format_tag::any}; } -void MKLDNNPoolingNode::initEffectivePad(const Shape &inShape, const Shape &outShape) { +void MKLDNNPoolingNode::initEffectiveAttributes(const Shape &inShape, const Shape &outShape) { effective_pad_begin = data_pad_begin; effective_pad_end.resize(data_pad_end.size()); + effective_dilation.resize(dilation.size(), 0); const auto &inDims = inShape.getStaticDims(); const auto &outDims = outShape.getStaticDims(); for (int i = 0; i < effective_pad_end.size(); i++) { int krn = kernel[i]; + int dil = dilation[i]; int src = inDims[2 + i]; int dst = outDims[2 + i]; - int calc_dst = (src - krn + data_pad_begin[i]) / stride[i] + 1; + int calc_dst = (src - (1 + (krn - 1) * dil) + data_pad_begin[i]) / stride[i] + 1; effective_pad_end[i] = (dst - calc_dst) * stride[i]; + effective_dilation[i] = dil - 1; } } @@ -120,8 +132,8 @@ void MKLDNNPoolingNode::getSupportedDescriptors() { if (getChildEdges().empty()) IE_THROW() << "Incorrect number of output edges for layer " << getName(); - inputPrecision = getOriginalInputPrecisionAtPort(0); - outputPrecision = getOriginalOutputPrecisionAtPort(0); + InferenceEngine::Precision inputPrecision = getOriginalInputPrecisionAtPort(0); + InferenceEngine::Precision outputPrecision = getOriginalOutputPrecisionAtPort(0); // WA: LPT transformation has WA which allows average pooling has I8/U8 output precision instead of FP32, // so we explicitly set output precision as FP32 @@ -151,8 +163,8 @@ void MKLDNNPoolingNode::getSupportedDescriptors() { if ((inputRank < 3) || (inputRank > 5)) IE_THROW() << "Pooling layer. Unsupported mode. Only 3D, 4D and 5D blobs are supported as input."; - initEffectivePad(MemoryDescUtils::makeDummyShape(parentShape), - MemoryDescUtils::makeDummyShape(childShape)); + initEffectiveAttributes(MemoryDescUtils::makeDummyShape(parentShape), + MemoryDescUtils::makeDummyShape(childShape)); if (inputPrecision == Precision::I8 || inputPrecision == Precision::U8) { // We have to extend i8i8_pooling_fwd_t from oneDNN to support BF16 output data type @@ -185,7 +197,7 @@ void MKLDNNPoolingNode::getSupportedDescriptors() { } } -std::pair, std::vector> MKLDNNPoolingNode::getPaddingFromNode(std::shared_ptr node) const { +std::pair, std::vector> MKLDNNPoolingNode::getPaddingFromNode(std::shared_ptr node) const { const auto convertPadding = [](const VectorDims &newPads) { std::vector pads(newPads.size()); for (int i = 0; i < newPads.size(); i++) { @@ -195,12 +207,16 @@ std::pair, std::vector> MKLDNNPoolingNode::get }; VectorDims padsBegin, padsEnd; - if (getAlgorithm() == PoolingMax) { - const auto pool = ngraph::as_type_ptr(opToShapeInfer); + if (isMaxPool8) { + const auto pool = ov::as_type_ptr(opToShapeInfer); + padsBegin = pool->get_pads_begin(); + padsEnd = pool->get_pads_end(); + } else if (getAlgorithm() == PoolingMax) { + const auto pool = ov::as_type_ptr(opToShapeInfer); padsBegin = pool->get_pads_begin(); padsEnd = pool->get_pads_end(); } else if (getAlgorithm() == PoolingAvg) { - const auto pool = ngraph::as_type_ptr(opToShapeInfer); + const auto pool = ov::as_type_ptr(opToShapeInfer); padsBegin = pool->get_pads_begin(); padsEnd = pool->get_pads_end(); } @@ -231,15 +247,15 @@ void MKLDNNPoolingNode::prepareParams() { if (auto_pad) { std::tie(data_pad_begin, data_pad_end) = getPaddingFromNode(opToShapeInfer); } - initEffectivePad(inDesc->getShape(), outDesc->getShape()); + initEffectiveAttributes(inDesc->getShape(), outDesc->getShape()); } mkldnn::algorithm alg = getPoolingAlgorithm(); MKLDNNDescriptor desc{createDescriptorInternal(in_candidate, out_candidate, alg)}; - pooling_forward::primitive_desc prim_desc; + pooling_v2_forward::primitive_desc prim_desc; primitive_desc_iterator itpd = desc.createPrimitiveDescriptorIterator(getEngine(), *attr); - while (static_cast(itpd)) { + while (static_cast(itpd)) { impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str()); if (impl_type == selected_pd->getImplementationType()) { @@ -250,7 +266,7 @@ void MKLDNNPoolingNode::prepareParams() { IE_THROW() << "Primitive descriptor was not found for node " << getName() << "."; } - prim.reset(new pooling_forward(prim_desc)); + prim.reset(new pooling_v2_forward(prim_desc)); auto src = getParentEdgesAtPort(0)[0]->getMemoryPtr()->GetPrimitive(); auto dst = getChildEdgesAtPort(0)[0]->getMemoryPtr()->GetPrimitive(); @@ -296,9 +312,9 @@ mkldnn::algorithm MKLDNNPoolingNode::getPoolingAlgorithm() const { } } -std::shared_ptr MKLDNNPoolingNode::createDescriptorInternal(const mkldnn::memory::desc& in_candidate, - const mkldnn::memory::desc& out_candidate, - const mkldnn::algorithm alg) const { +std::shared_ptr MKLDNNPoolingNode::createDescriptorInternal(const mkldnn::memory::desc& in_candidate, + const mkldnn::memory::desc& out_candidate, + const mkldnn::algorithm alg) const { if (alg == mkldnn::algorithm::undef) { IE_THROW() << "Unsupported pooling type"; } @@ -306,13 +322,14 @@ std::shared_ptr MKLDNNPoolingNode::createDescriptorIntern auto convert = [] (std::vector orig_dims) { return memory::dims(orig_dims.begin(), orig_dims.end()); }; - std::shared_ptr desc_ptr( - new pooling_forward::desc(prop_kind::forward_scoring, alg, - in_candidate, out_candidate, - convert(stride), - convert(kernel), - convert(effective_pad_begin), - convert(effective_pad_end))); + std::shared_ptr desc_ptr( + new pooling_v2_forward::desc(prop_kind::forward_scoring, alg, + in_candidate, out_candidate, + convert(stride), + convert(kernel), + convert(effective_dilation), + convert(effective_pad_begin), + convert(effective_pad_end))); if (alg == mkldnn::algorithm::pooling_avg_include_padding) { // In case of AVG including paddings the norm coeff should be calculated @@ -343,14 +360,12 @@ void MKLDNNPoolingNode::createDescriptor(const std::vector &input if (auto_pad) { std::tie(data_pad_begin, data_pad_end) = getPaddingFromNode(opToShapeInfer); } - initEffectivePad(inDesc->getShape(), outDesc->getShape()); + initEffectiveAttributes(inDesc->getShape(), outDesc->getShape()); } auto dnnlOutDesc = MemoryDescUtils::convertToDnnlBlockedMemoryDesc(*outDesc); auto out_candidate = dnnlOutDesc.getDnnlDesc(); - mkldnn::algorithm alg = getPoolingAlgorithm(); - auto desc_ptr = createDescriptorInternal(in_candidate, out_candidate, alg); - + auto desc_ptr = createDescriptorInternal(in_candidate, out_candidate, getPoolingAlgorithm()); descs.emplace_back(desc_ptr); } @@ -383,6 +398,18 @@ void MKLDNNPoolingNode::initSupportedPrimitiveDescriptors() { config.outConfs.push_back(dataConfig); } + + // CPU plugin doesn't support second output of MaxPool-8, but anyway we should have out config for second port as stub + if (isMaxPool8) { + auto& creatorsMap = BlockedDescCreator::getCommonCreators(); + PortConfig dataConfig; + dataConfig.inPlace = -1; + dataConfig.constant = false; + dataConfig.desc = creatorsMap.at(LayoutType::ncsp)->createSharedDesc(config.outConfs.front().desc->getPrecision(), getOutputShapeAtPort(1)); + + config.outConfs.push_back(dataConfig); + } + impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str()); supportedPrimitiveDescriptors.emplace_back(config, impl_type); @@ -434,6 +461,18 @@ void MKLDNNPoolingNode::initDescriptor(const NodeConfig& config) { dataConfig.desc = getDstMemDesc(itpd, i); cfg.outConfs.push_back(dataConfig); } + + // CPU plugin doesn't support second output of MaxPool-8, but anyway we should have out config for second port as stub + if (isMaxPool8) { + auto& creatorsMap = BlockedDescCreator::getCommonCreators(); + PortConfig dataConfig; + dataConfig.inPlace = -1; + dataConfig.constant = false; + dataConfig.desc = creatorsMap.at(LayoutType::ncsp)->createSharedDesc(cfg.outConfs.front().desc->getPrecision(), getOutputShapeAtPort(1)); + + cfg.outConfs.push_back(dataConfig); + } + impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str()); if (selected_count == selectedPrimitiveDescriptorIndex) { if (impl_type != selectedPD->getImplementationType()) { diff --git a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.h b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.h index 1d91199f95a..f3a6fc781cc 100644 --- a/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.h +++ b/inference-engine/src/mkldnn_plugin/nodes/mkldnn_pooling_node.h @@ -14,7 +14,7 @@ namespace MKLDNNPlugin { class MKLDNNPoolingNode : public MKLDNNNode { public: - MKLDNNPoolingNode(const std::shared_ptr& op, const mkldnn::engine& eng, MKLDNNWeightsSharing::Ptr &cache); + MKLDNNPoolingNode(const std::shared_ptr& op, const mkldnn::engine& eng, MKLDNNWeightsSharing::Ptr &cache); void createDescriptor(const std::vector& inputDesc, const std::vector& outputDesc) override; @@ -31,7 +31,7 @@ public: void prepareParams() override; void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } - static bool isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept; + static bool isSupportedOperation(const std::shared_ptr& op, std::string& errorMessage) noexcept; protected: AttrPtr initPrimitiveAttr() const override; @@ -39,17 +39,19 @@ protected: private: void setPostOps(mkldnn::primitive_attr &attr, bool initWeights = false) const; - std::pair, std::vector> getPaddingFromNode(std::shared_ptr node) const; - void initEffectivePad(const Shape &inDims, const Shape &outDims); + std::pair, std::vector> getPaddingFromNode(std::shared_ptr node) const; + void initEffectiveAttributes(const Shape &inDims, const Shape &outDims); mkldnn::algorithm getPoolingAlgorithm() const; - std::shared_ptr createDescriptorInternal(const mkldnn::memory::desc& in_candidate, - const mkldnn::memory::desc& out_candidate, - const mkldnn::algorithm alg) const; + std::shared_ptr createDescriptorInternal(const mkldnn::memory::desc& in_candidate, + const mkldnn::memory::desc& out_candidate, + const mkldnn::algorithm alg) const; AttrPtr pAttr; + bool isMaxPool8 = false; bool auto_pad = false; bool exclude_pad = false; + std::vector dilation; std::vector stride; std::vector kernel; @@ -59,15 +61,16 @@ private: std::vector effective_pad_begin; std::vector effective_pad_end; + /// Effective dilation. Used to define correct dilation for OneDNN. + /// For OneDNN default dilation is vector of zero + std::vector effective_dilation; + /// Effective pad value. Describe how much zero element added to input /// data tensor. May be less than "Effective padding" values. /// If pooling window is out of this padding, the region of averaging /// is decreased. std::vector data_pad_begin; std::vector data_pad_end; - - InferenceEngine::Precision inputPrecision = InferenceEngine::Precision::FP32; - InferenceEngine::Precision outputPrecision = InferenceEngine::Precision::FP32; }; } // namespace MKLDNNPlugin diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/pooling.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/pooling.cpp index a3053fb6809..7b7e79da274 100644 --- a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/pooling.cpp +++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/pooling.cpp @@ -351,8 +351,174 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_SameLowerPad_CeilRounding_5Dinput, Poolin ::testing::Values(CommonTestUtils::DEVICE_CPU)), PoolingLayerTest::getTestCaseName); +////* ========== Max Pooling V8 ========== */ + +const std::vector> dilation = {{1, 1}, {2, 2}}; +const std::vector> dilation3D = {{1, 1, 1}, {2, 2, 2}}; + +/* ========== Explicit Pad Floor Rounding ========== */ +const auto maxPoolv8_ExplicitPad_FloorRounding_Params = ::testing::Combine( + ::testing::ValuesIn(kernels), + ::testing::ValuesIn(strides), + ::testing::ValuesIn(dilation), + ::testing::ValuesIn(padBegins), + ::testing::ValuesIn(padEnds), + ::testing::Values(ngraph::op::RoundingType::FLOOR), + ::testing::Values(ngraph::op::PadType::EXPLICIT) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_ExplicitPad_FloorRounding, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_ExplicitPad_FloorRounding_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({1, 3, 30, 30})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + +/* ========== Same Upper Pad Floor Rounding ========== */ +const auto maxPoolv8_SameUpperPad_FloorRounding_Params = ::testing::Combine( + ::testing::ValuesIn(kernels), + ::testing::ValuesIn(strides), + ::testing::ValuesIn(dilation), + ::testing::ValuesIn(padBegins), + ::testing::ValuesIn(padEnds), + ::testing::Values(ngraph::op::RoundingType::FLOOR), + ::testing::Values(ngraph::op::PadType::SAME_UPPER) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolv8_SameUpperPad_FloorRounding, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_SameUpperPad_FloorRounding_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({1, 3, 30, 30})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + +/* ========== Same Lower Pad Floor Rounding ========== */ +const auto maxPoolv8_SameLowerPad_FloorRounding_Params = ::testing::Combine( + ::testing::ValuesIn(kernels), + ::testing::ValuesIn(strides), + ::testing::ValuesIn(dilation), + ::testing::ValuesIn(padBegins), + ::testing::ValuesIn(padEnds), + ::testing::Values(ngraph::op::RoundingType::FLOOR), + ::testing::Values(ngraph::op::PadType::SAME_LOWER) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolv8_SameLowerPad_FloorRounding, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_SameLowerPad_FloorRounding_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({1, 3, 30, 30})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + +/* ========= Explicit Pad Floor Rounding 5D input========== */ +const auto maxPoolv8_ExplicitPad_FloorRounding_5Dinput_Params = ::testing::Combine( + ::testing::ValuesIn(kernel3D), + ::testing::ValuesIn(strides3D), + ::testing::Values(dilation3D[0]), + ::testing::ValuesIn(padBegins3D), + ::testing::ValuesIn(padEnds3D), + ::testing::Values(ngraph::op::RoundingType::FLOOR), + ::testing::Values(ngraph::op::PadType::EXPLICIT) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolv8_ExplicitPad_FloorRounding_5Dinput, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_ExplicitPad_FloorRounding_5Dinput_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({32, 32, 2, 2, 2})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + +/* ========= Same Upper Pad Floor Rounding 5D input========== */ +const auto maxPoolv8_SameUpperPad_FloorRounding_5Dinput_Params = ::testing::Combine( + ::testing::ValuesIn(kernel3D), + ::testing::ValuesIn(strides3D), + ::testing::ValuesIn(dilation3D), + ::testing::ValuesIn(padBegins3D), + ::testing::ValuesIn(padEnds3D), + ::testing::Values(ngraph::op::RoundingType::FLOOR), + ::testing::Values(ngraph::op::PadType::SAME_UPPER) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolv8_SameUpperPad_FloorRounding_5Dinput, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_SameUpperPad_FloorRounding_5Dinput_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({32, 32, 2, 2, 2})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + +/* ========= Same Lower Pad Ceil Rounding 5D input========== */ +const auto maxPoolv8_SameLowerPad_CeilRounding_5Dinput_Params = ::testing::Combine( + ::testing::ValuesIn(kernel3D), + ::testing::ValuesIn(strides3D), + ::testing::ValuesIn(dilation3D), + ::testing::ValuesIn(padBegins3D), + ::testing::ValuesIn(padEnds3D), + ::testing::Values(ngraph::op::RoundingType::CEIL), + ::testing::Values(ngraph::op::PadType::SAME_LOWER) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolv8_SameLowerPad_CeilRounding_5Dinput, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_SameLowerPad_CeilRounding_5Dinput_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({32, 32, 2, 2, 2})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + +/* ========= Explicit Pad Ceil Rounding ========== */ +const auto maxPoolv8_ExplicitPad_CeilRounding_Params = ::testing::Combine( + ::testing::ValuesIn(kernels), + ::testing::ValuesIn(strides), + ::testing::ValuesIn(dilation), + ::testing::ValuesIn(padBegins), + ::testing::ValuesIn(padEnds), + ::testing::Values(ngraph::op::RoundingType::CEIL), + ::testing::Values(ngraph::op::PadType::EXPLICIT) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolv8_ExplicitPad_CeilRounding, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_ExplicitPad_CeilRounding_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({1, 3, 30, 30})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + ////* ========== Avg and Max Polling Cases ========== */ -/* ========== Valid Pad Rounding Not Applicable ========== */ +/* ========== Valid Pad Rounding Not Applicable ========== */ const auto allPools_ValidPad_Params = ::testing::Combine( ::testing::Values(ngraph::helpers::PoolingTypes::MAX, ngraph::helpers::PoolingTypes::AVG), ::testing::ValuesIn(kernels), @@ -366,14 +532,37 @@ const auto allPools_ValidPad_Params = ::testing::Combine( ); INSTANTIATE_TEST_SUITE_P(smoke_MAX_and_AVGPool_ValidPad, PoolingLayerTest, - ::testing::Combine( - allPools_ValidPad_Params, - ::testing::ValuesIn(netPrecisions), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(InferenceEngine::Layout::ANY), - ::testing::Values(std::vector({1, 3, 30, 30})), - ::testing::Values(CommonTestUtils::DEVICE_CPU)), - PoolingLayerTest::getTestCaseName); + ::testing::Combine( + allPools_ValidPad_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({1, 3, 30, 30})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + PoolingLayerTest::getTestCaseName); + +const auto maxPoolv8_ValidPad_Params = ::testing::Combine( + ::testing::ValuesIn(kernels), + ::testing::ValuesIn(strides), + ::testing::ValuesIn(dilation), + ::testing::Values(std::vector({0, 0})), + ::testing::Values(std::vector({0, 0})), + ::testing::Values(ngraph::op::RoundingType::FLOOR), // placeholder value - Rounding Type not applicable for Valid pad type + ::testing::Values(ngraph::op::PadType::VALID) +); + +INSTANTIATE_TEST_SUITE_P(smoke_MAXPoolv8_ValidPad, MaxPoolingV8LayerTest, + ::testing::Combine( + maxPoolv8_ValidPad_Params, + ::testing::ValuesIn(netPrecisions), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Precision::UNSPECIFIED), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(InferenceEngine::Layout::ANY), + ::testing::Values(std::vector({1, 3, 30, 30})), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + MaxPoolingV8LayerTest::getTestCaseName); + } // namespace diff --git a/inference-engine/tests/functional/plugin/cpu/single_layer_tests/pooling.cpp b/inference-engine/tests/functional/plugin/cpu/single_layer_tests/pooling.cpp index 7b77296facc..191d35e33ab 100644 --- a/inference-engine/tests/functional/plugin/cpu/single_layer_tests/pooling.cpp +++ b/inference-engine/tests/functional/plugin/cpu/single_layer_tests/pooling.cpp @@ -20,6 +20,11 @@ using poolLayerCpuTestParamsSet = std::tuple; +using maxPoolV8LayerCpuTestParamsSet = std::tuple; + class PoolingLayerCPUTest : public testing::WithParamInterface, virtual public SubgraphBaseTest, public CpuTestWithFusing { public: @@ -68,8 +73,6 @@ public: results << CPUTestsBase::getTestCaseName(cpuParams); results << CpuTestWithFusing::getTestCaseName(fusingParams); return results.str(); - - return results.str(); } protected: @@ -98,7 +101,10 @@ protected: if (selectedType.empty()) { selectedType = getPrimitiveType(); } - selectedType = selectedType + "_" + InferenceEngine::details::convertPrecision(inPrc).name(); + if (isInt8) + selectedType = selectedType + "_I8"; + else + selectedType = makeSelectedTypeStr(selectedType, inPrc); init_input_shapes({inputShapes}); @@ -124,11 +130,87 @@ protected: } }; +class MaxPoolingV8LayerCPUTest : public testing::WithParamInterface, + virtual public SubgraphBaseTest, public CPUTestsBase { +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj) { + LayerTestsDefinitions::maxPoolV8SpecificParams basicParamsSet; + InputShape inputShapes; + ElementType inPrc; + CPUSpecificParams cpuParams; + std::tie(basicParamsSet, inputShapes, inPrc, cpuParams) = obj.param; + + std::vector kernel, stride, dilation; + std::vector padBegin, padEnd; + ngraph::op::PadType padType; + ngraph::op::RoundingType roundingType; + std::tie(kernel, stride, dilation, padBegin, padEnd, roundingType, padType) = basicParamsSet; + + std::ostringstream results; + results << "IS=("; + results << CommonTestUtils::partialShape2str({inputShapes.first}) << ")_"; + results << "TS="; + for (const auto& shape : inputShapes.second) { + results << CommonTestUtils::vec2str(shape) << "_"; + } + results << "Prc=" << inPrc << "_"; + results << "MaxPool_"; + results << "K" << CommonTestUtils::vec2str(kernel) << "_"; + results << "S" << CommonTestUtils::vec2str(stride) << "_"; + results << "D" << CommonTestUtils::vec2str(dilation) << "_"; + results << "PB" << CommonTestUtils::vec2str(padBegin) << "_"; + results << "PE" << CommonTestUtils::vec2str(padEnd) << "_"; + results << "Rounding=" << roundingType << "_"; + results << "AutoPad=" << padType << "_"; + + results << CPUTestsBase::getTestCaseName(cpuParams); + return results.str(); + } + +protected: + void SetUp() override { + targetDevice = CommonTestUtils::DEVICE_CPU; + + LayerTestsDefinitions::maxPoolV8SpecificParams basicParamsSet; + InputShape inputShapes; + ElementType inPrc; + CPUSpecificParams cpuParams; + std::tie(basicParamsSet, inputShapes, inPrc, cpuParams) = this->GetParam(); + + std::vector kernel, stride, dilation; + std::vector padBegin, padEnd; + ngraph::op::PadType padType; + ngraph::op::RoundingType roundingType; + std::tie(kernel, stride, dilation, padBegin, padEnd, roundingType, padType) = basicParamsSet; + std::tie(inFmts, outFmts, priority, selectedType) = cpuParams; + if (selectedType.empty()) { + selectedType = getPrimitiveType(); + } + selectedType = makeSelectedTypeStr(selectedType, inPrc); + + init_input_shapes({inputShapes}); + + auto params = ngraph::builder::makeDynamicParams(inPrc, inputDynamicShapes); + std::shared_ptr pooling = ngraph::builder::makeMaxPoolingV8(params[0], stride, dilation, padBegin, padEnd, + kernel, roundingType, padType); + pooling->get_rt_info() = getCPUInfo(); + ngraph::ResultVector results{std::make_shared(pooling->output(0))}; + function = std::make_shared(results, params, "MaxPooling"); + } +}; + TEST_P(PoolingLayerCPUTest, CompareWithRefs) { SKIP_IF_CURRENT_TEST_IS_DISABLED() run(); -// CheckPluginRelatedResults(executableNetwork, "Pooling"); + CheckPluginRelatedResults(executableNetwork, "Pooling"); +} + +TEST_P(MaxPoolingV8LayerCPUTest, CompareWithRefs) { + SKIP_IF_CURRENT_TEST_IS_DISABLED() + + run(); + CheckPluginRelatedResults(executableNetwork, "Pooling"); } namespace { @@ -291,6 +373,20 @@ const std::vector paramsMax4D = { ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT, false }, }; +const std::vector paramsMaxV84D = { + LayerTestsDefinitions::maxPoolV8SpecificParams{ {2, 2}, {2, 2}, {1, 1}, {0, 0}, {0, 0}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::SAME_LOWER }, +}; + +const std::vector paramsMaxV84D_ref = { + LayerTestsDefinitions::maxPoolV8SpecificParams{ {2, 2}, {2, 2}, {2, 2}, {0, 0}, {0, 0}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::SAME_UPPER }, + LayerTestsDefinitions::maxPoolV8SpecificParams{ {4, 2}, {2, 2}, {1, 2}, {0, 0}, {0, 0}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT }, + LayerTestsDefinitions::maxPoolV8SpecificParams{ {4, 2}, {2, 1}, {2, 2}, {0, 0}, {0, 0}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT }, +}; + const std::vector paramsAvg4D = { LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::AVG, {2, 2}, {2, 2}, {1, 0}, {0, 0}, ngraph::op::RoundingType::CEIL, ngraph::op::PadType::SAME_LOWER, true }, @@ -321,6 +417,22 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_4D, PoolingLayerCPUTest, ::testing::Values(emptyFusingSpec)), PoolingLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_4D, MaxPoolingV8LayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(paramsMaxV84D), + ::testing::ValuesIn(inputShapes4D), + ::testing::ValuesIn(inpOutPrecision), + ::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigs))), + MaxPoolingV8LayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_4D_ref, MaxPoolingV8LayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(paramsMaxV84D_ref), + ::testing::ValuesIn(inputShapes4D), + ::testing::ValuesIn(inpOutPrecision), + ::testing::Values(ref)), + MaxPoolingV8LayerCPUTest::getTestCaseName); + INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D, PoolingLayerCPUTest, ::testing::Combine( ::testing::ValuesIn(paramsAvg4D), @@ -349,10 +461,24 @@ const std::vector paramsMax5D = { ngraph::op::RoundingType::CEIL, ngraph::op::PadType::SAME_UPPER, false }, LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::MAX, {2, 2, 2}, {1, 1, 1}, {1, 1, 1}, {1, 1, 1}, ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT, false }, - LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::MAX, {2, 3, 4}, {2, 2, 2}, {1, 1, 1}, {1, 2, 3}, + LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::MAX, {3, 3, 3}, {2, 2, 2}, {1, 1, 1}, {1, 1, 1}, ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT, false }, }; +const std::vector paramsMaxV85D = { + LayerTestsDefinitions::maxPoolV8SpecificParams{ {2, 2, 2}, {1, 1, 1}, {1, 1, 1}, {0, 0, 0}, {0, 0, 0}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::SAME_LOWER }, +}; + +const std::vector paramsMaxV85D_ref = { + LayerTestsDefinitions::maxPoolV8SpecificParams{ {2, 2, 2}, {1, 1, 1}, {2, 2, 2}, {0, 0, 0}, {0, 0, 0}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::SAME_UPPER }, + LayerTestsDefinitions::maxPoolV8SpecificParams{ {2, 2, 2}, {1, 1, 1}, {2, 2, 2}, {1, 1, 1}, {1, 1, 1}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT }, + LayerTestsDefinitions::maxPoolV8SpecificParams{ {2, 3, 4}, {2, 2, 2}, {2, 1, 1}, {1, 1, 1}, {1, 2, 2}, + ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT }, +}; + const std::vector paramsAvg5D = { LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::AVG, {2, 2, 2}, {2, 2, 2}, {1, 0, 0}, {0, 0, 0}, ngraph::op::RoundingType::CEIL, ngraph::op::PadType::SAME_LOWER, true }, @@ -366,7 +492,7 @@ const std::vector paramsAvg5D = { ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT, true }, LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::AVG, {3, 3, 3}, {3, 3, 3}, {1, 1, 1}, {0, 0, 0}, ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT, true }, - LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::AVG, {4, 4, 4}, {4, 4, 4}, {2, 2, 2}, {2, 2, 2}, + LayerTestsDefinitions::poolSpecificParams{ ngraph::helpers::PoolingTypes::AVG, {4, 4, 4}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}, ngraph::op::RoundingType::CEIL, ngraph::op::PadType::EXPLICIT, true }, }; @@ -385,6 +511,22 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_5D, PoolingLayerCPUTest, ::testing::Values(emptyFusingSpec)), PoolingLayerCPUTest::getTestCaseName); +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D, MaxPoolingV8LayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(paramsMaxV85D), + ::testing::ValuesIn(inputShapes5D), + ::testing::ValuesIn(inpOutPrecision), + ::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigs))), + MaxPoolingV8LayerCPUTest::getTestCaseName); + +INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D_ref, MaxPoolingV8LayerCPUTest, + ::testing::Combine( + ::testing::ValuesIn(paramsMaxV85D_ref), + ::testing::ValuesIn(inputShapes5D), + ::testing::ValuesIn(inpOutPrecision), + ::testing::Values(ref)), + MaxPoolingV8LayerCPUTest::getTestCaseName); + INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_5D, PoolingLayerCPUTest, ::testing::Combine( ::testing::ValuesIn(paramsAvg5D), diff --git a/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/pooling.hpp b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/pooling.hpp index f8bd0907fa5..165096fd069 100644 --- a/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/pooling.hpp +++ b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/pooling.hpp @@ -19,4 +19,9 @@ TEST_P(GlobalPoolingLayerTest, CompareWithRefs) { PluginCache::get().reset(); } } + +TEST_P(MaxPoolingV8LayerTest, CompareWithRefs) { + Run(); +} + } // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/shared_test_classes/include/shared_test_classes/single_layer/pooling.hpp b/inference-engine/tests/functional/shared_test_classes/include/shared_test_classes/single_layer/pooling.hpp index 12417959d22..6730e6c2b56 100644 --- a/inference-engine/tests/functional/shared_test_classes/include/shared_test_classes/single_layer/pooling.hpp +++ b/inference-engine/tests/functional/shared_test_classes/include/shared_test_classes/single_layer/pooling.hpp @@ -48,6 +48,27 @@ typedef std::tuple< std::string // Device name > globalPoolLayerTestParamsSet; +typedef std::tuple< + std::vector, // Kernel size + std::vector, // Stride + std::vector, // Dilation + std::vector, // Pad begin + std::vector, // Pad end + ngraph::op::RoundingType, // Rounding type + ngraph::op::PadType // Pad type +> maxPoolV8SpecificParams; + +typedef std::tuple< + maxPoolV8SpecificParams, + InferenceEngine::Precision, // Net precision + InferenceEngine::Precision, // Input precision + InferenceEngine::Precision, // Output precision + InferenceEngine::Layout, // Input layout + InferenceEngine::Layout, // Output layout + std::vector, // Input shape + std::string // Device name +> maxPoolV8LayerTestParamsSet; + class PoolingLayerTest : public testing::WithParamInterface, virtual public LayerTestsUtils::LayerTestsCommon { public: @@ -66,4 +87,13 @@ protected: void SetUp() override; }; +class MaxPoolingV8LayerTest : public testing::WithParamInterface, + virtual public LayerTestsUtils::LayerTestsCommon { +public: + static std::string getTestCaseName(const testing::TestParamInfo& obj); + +protected: + void SetUp() override; +}; + } // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/shared_test_classes/src/single_layer/pooling.cpp b/inference-engine/tests/functional/shared_test_classes/src/single_layer/pooling.cpp index 276fc2bfb6f..3dc2b2c7a36 100644 --- a/inference-engine/tests/functional/shared_test_classes/src/single_layer/pooling.cpp +++ b/inference-engine/tests/functional/shared_test_classes/src/single_layer/pooling.cpp @@ -94,6 +94,38 @@ std::string GlobalPoolingLayerTest::getTestCaseName(const testing::TestParamInfo return result.str(); } +std::string MaxPoolingV8LayerTest::getTestCaseName(const testing::TestParamInfo& obj) { + maxPoolV8SpecificParams poolParams; + InferenceEngine::Precision netPrecision; + InferenceEngine::Precision inPrc, outPrc; + InferenceEngine::Layout inLayout, outLayout; + std::vector inputShapes; + std::string targetDevice; + std::tie(poolParams, netPrecision, inPrc, outPrc, inLayout, outLayout, inputShapes, targetDevice) = obj.param; + std::vector kernel, stride, dilation; + std::vector padBegin, padEnd; + ngraph::op::PadType padType; + ngraph::op::RoundingType roundingType; + std::tie(kernel, stride, dilation, padBegin, padEnd, roundingType, padType) = poolParams; + + std::ostringstream result; + result << "IS=" << CommonTestUtils::vec2str(inputShapes) << "_"; + result << "K" << CommonTestUtils::vec2str(kernel) << "_"; + result << "S" << CommonTestUtils::vec2str(stride) << "_"; + result << "D" << CommonTestUtils::vec2str(dilation) << "_"; + result << "PB" << CommonTestUtils::vec2str(padBegin) << "_"; + result << "PE" << CommonTestUtils::vec2str(padEnd) << "_"; + result << "Rounding=" << roundingType << "_"; + result << "AutoPad=" << padType << "_"; + result << "netPRC=" << netPrecision.name() << "_"; + result << "inPRC=" << inPrc.name() << "_"; + result << "outPRC=" << outPrc.name() << "_"; + result << "inL=" << inLayout << "_"; + result << "outL=" << outLayout << "_"; + result << "trgDev=" << targetDevice; + return result.str(); +} + void PoolingLayerTest::SetUp() { poolSpecificParams poolParams; std::vector inputShape; @@ -159,4 +191,28 @@ void GlobalPoolingLayerTest::SetUp() { ngraph::ResultVector results{std::make_shared(pooling)}; function = std::make_shared(results, params, "pooling"); } + +void MaxPoolingV8LayerTest::SetUp() { + maxPoolV8SpecificParams poolParams; + std::vector inputShape; + InferenceEngine::Precision netPrecision; + std::tie(poolParams, netPrecision, inPrc, outPrc, inLayout, outLayout, inputShape, targetDevice) = this->GetParam(); + std::vector kernel, stride, dilation; + std::vector padBegin, padEnd; + ngraph::op::PadType padType; + ngraph::op::RoundingType roundingType; + std::tie(kernel, stride, dilation, padBegin, padEnd, roundingType, padType) = poolParams; + + auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision); + auto params = ngraph::builder::makeParams(ngPrc, {inputShape}); + auto paramOuts = ngraph::helpers::convert2OutputVector( + ngraph::helpers::castOps2Nodes(params)); + + std::shared_ptr maxPool = ngraph::builder::makeMaxPoolingV8(paramOuts[0], stride, dilation, padBegin, padEnd, + kernel, roundingType, padType); + + ngraph::ResultVector results{std::make_shared(maxPool->output(0))}; + function = std::make_shared(results, params, "MaxPoolV8"); +} + } // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/ngraph_helpers/ngraph_functions/include/ngraph_functions/builders.hpp b/inference-engine/tests/ngraph_helpers/ngraph_functions/include/ngraph_functions/builders.hpp index 66ca6fb334a..b790b831c23 100644 --- a/inference-engine/tests/ngraph_helpers/ngraph_functions/include/ngraph_functions/builders.hpp +++ b/inference-engine/tests/ngraph_helpers/ngraph_functions/include/ngraph_functions/builders.hpp @@ -428,6 +428,15 @@ std::shared_ptr makePooling(const ngraph::Output &in, bool excludePad, const ngraph::helpers::PoolingTypes &poolType); +std::shared_ptr makeMaxPoolingV8(const ngraph::Output &in, + const std::vector &strides, + const std::vector &dilation, + const std::vector &padsBegin, + const std::vector &padsEnd, + const std::vector &kernel, + const op::RoundingType &roundingType, + const op::PadType &padType); + std::shared_ptr makeROIPooling(const Output& input, const Output& coords, const Shape& output_size, diff --git a/inference-engine/tests/ngraph_helpers/ngraph_functions/src/pooling.cpp b/inference-engine/tests/ngraph_helpers/ngraph_functions/src/pooling.cpp index b486ab8e1fe..43f26ba0272 100644 --- a/inference-engine/tests/ngraph_helpers/ngraph_functions/src/pooling.cpp +++ b/inference-engine/tests/ngraph_helpers/ngraph_functions/src/pooling.cpp @@ -35,5 +35,18 @@ std::shared_ptr makePooling(const ngraph::Output &in, return pooling; } +std::shared_ptr makeMaxPoolingV8(const ngraph::Output &in, + const std::vector &strides, + const std::vector &dilation, + const std::vector &padsBegin, + const std::vector &padsEnd, + const std::vector &kernel, + const op::RoundingType &roundingType, + const op::PadType &padType) { + std::shared_ptr pooling = std::make_shared(in, strides, dilation, padsBegin, padsEnd, + kernel, roundingType, padType); + return pooling; +} + } // namespace builder } // namespace ngraph