[CPU] Pooling & FakeQuantize cache (#9503)
* [CPUCache]Impl FakeQuantize * [CPUCache]Impl Pooling * [CPUCache]Fix Pooling == * [CpuCache]apply review comments * [CpuCache]fix pooling ==
This commit is contained in:
Zhang Yi
GitHub
parent
5b40f381cb
commit
6d3f99c7db
@ -23,6 +23,7 @@
|
||||
#include "memory_desc/dnnl_blocked_memory_desc.h"
|
||||
#include "utils/ngraph_utils.hpp"
|
||||
#include "common/cpu_memcpy.h"
|
||||
#include <common/primitive_hashing_utils.hpp>
|
||||
|
||||
// Quantization ranges validation is switched off by default in order to avoid regressions on user side
|
||||
// #define VALIDATE_QUANTIZATION_RANGES
|
||||
@ -885,6 +886,31 @@ bool MKLDNNFakeQuantizeNode::isSupportedOperation(const std::shared_ptr<const ng
|
||||
return true;
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct FakeQuantKey {
|
||||
jit_quantize_params jqp;
|
||||
size_t hash() const {
|
||||
size_t seed = 0;
|
||||
seed = hash_combine(seed, jqp.c);
|
||||
seed = hash_combine(seed, jqp.is_planar);
|
||||
seed = hash_combine(seed, jqp.src_prc.getPrecVal());
|
||||
seed = hash_combine(seed, jqp.wei_prc.getPrecVal());
|
||||
seed = hash_combine(seed, jqp.dst_prc.getPrecVal());
|
||||
seed = dnnl::impl::primitive_hashing::get_vector_hash(seed, jqp.s_str);
|
||||
seed = dnnl::impl::primitive_hashing::get_vector_hash(seed, jqp.d_str);
|
||||
seed = hash_combine(seed, jqp.op_type);
|
||||
return seed;
|
||||
}
|
||||
|
||||
bool operator==(const FakeQuantKey& rhs) const {
|
||||
bool result = jqp.c == rhs.jqp.c && jqp.is_planar == rhs.jqp.is_planar && jqp.src_prc == rhs.jqp.src_prc &&
|
||||
jqp.wei_prc == rhs.jqp.wei_prc && jqp.dst_prc == rhs.jqp.dst_prc &&
|
||||
jqp.op_type == rhs.jqp.op_type && jqp.s_str == rhs.jqp.s_str && jqp.d_str == rhs.jqp.d_str;
|
||||
return result;
|
||||
}
|
||||
};
|
||||
} // namespace
|
||||
|
||||
MKLDNNFakeQuantizeNode::MKLDNNFakeQuantizeNode(const std::shared_ptr<ngraph::Node>& op, const mkldnn::engine& eng, MKLDNNWeightsSharing::Ptr &cache) :
|
||||
MKLDNNNode(op, eng, cache) {
|
||||
std::string errorMessage;
|
||||
@ -1363,27 +1389,28 @@ void MKLDNNFakeQuantizeNode::prepareParams() {
|
||||
IE_THROW() << "CPU quantize node with name '" << getName() << "' doesn't have primitive descriptors.";
|
||||
if (selectedPrimitiveDescriptor->getImplementationType() != impl_desc_type::ref) {
|
||||
const auto& config = getSelectedPrimitiveDescriptor()->getConfig();
|
||||
|
||||
const auto& inDims = getParentEdgesAtPort(0)[0]->getMemory().getStaticDims();
|
||||
|
||||
jit_quantize_params jqp = {};
|
||||
jqp.c = inDims.size() > 1 ? inDims[1] : 1;
|
||||
|
||||
jqp.src_prc = config.inConfs[0].desc->getPrecision();
|
||||
jqp.wei_prc = Precision::FP32;
|
||||
jqp.dst_prc = config.outConfs[0].desc->getPrecision();
|
||||
//Form FakeQuanKey
|
||||
FakeQuantKey key = {};
|
||||
key.jqp.c = inDims.size() > 1 ? inDims[1] : 1;
|
||||
key.jqp.src_prc = config.inConfs[0].desc->getPrecision();
|
||||
key.jqp.wei_prc = Precision::FP32;
|
||||
key.jqp.dst_prc = config.outConfs[0].desc->getPrecision();
|
||||
|
||||
auto srcDesc = getParentEdgeAt(0)->getMemory().GetDescWithType<BlockedMemoryDesc>();
|
||||
jqp.s_str = srcDesc->getStrides();
|
||||
|
||||
key.jqp.s_str = srcDesc->getStrides();
|
||||
auto dstDesc = getChildEdgeAt(0)->getMemory().GetDescWithType<BlockedMemoryDesc>();
|
||||
jqp.d_str = dstDesc->getStrides();
|
||||
|
||||
jqp.is_planar = srcDesc->hasLayoutType(LayoutType::ncsp) && one_of(srcDesc->getShape().getRank(), 3, 4, 5);
|
||||
key.jqp.d_str = dstDesc->getStrides();
|
||||
key.jqp.is_planar = srcDesc->hasLayoutType(LayoutType::ncsp) && one_of(srcDesc->getShape().getRank(), 3, 4, 5);
|
||||
key.jqp.op_type = getAlgorithm();
|
||||
|
||||
jqp.op_type = getAlgorithm();
|
||||
|
||||
execPtr = std::make_shared<FakeQuantizeJitExecutor>(jqp);
|
||||
auto cache = getRuntimeCache();
|
||||
auto buildExecutor = [](const FakeQuantKey& key) {
|
||||
return std::make_shared<FakeQuantizeJitExecutor>(key.jqp);
|
||||
};
|
||||
auto result = cache->getOrCreate(key, buildExecutor);
|
||||
execPtr = result.first;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -15,11 +15,111 @@
|
||||
#include <utils/general_utils.h>
|
||||
#include <memory_desc/cpu_memory_desc_utils.h>
|
||||
#include "memory_desc/dnnl_blocked_memory_desc.h"
|
||||
#include <common/primitive_hashing_utils.hpp>
|
||||
|
||||
using namespace mkldnn;
|
||||
using namespace MKLDNNPlugin;
|
||||
using namespace InferenceEngine;
|
||||
|
||||
namespace {
|
||||
struct PoolingKey {
|
||||
DnnlMemoryDescCPtr inp;
|
||||
DnnlMemoryDescCPtr out;
|
||||
std::vector<ptrdiff_t> stride;
|
||||
std::vector<ptrdiff_t> kernel;
|
||||
/// Effective padding. Used to define correct output shape by MKLDNN
|
||||
/// reshape formula: (iw - kernel + pad_l + pad_r) / strides[i - 2] + 1
|
||||
/// should be passed into pooling desc constructor.
|
||||
std::vector<ptrdiff_t> effective_pad_begin;
|
||||
std::vector<ptrdiff_t> effective_pad_end;
|
||||
/// Effective dilation. Used to define correct dilation for OneDNN.
|
||||
/// For OneDNN default dilation is vector of zero
|
||||
std::vector<ptrdiff_t> effective_dilation;
|
||||
std::vector<ptrdiff_t> data_pad_end;
|
||||
mkldnn::primitive_attr attr;
|
||||
algorithm alg;
|
||||
impl_desc_type implType;
|
||||
|
||||
size_t hash() const {
|
||||
using namespace dnnl::impl;
|
||||
using namespace dnnl::impl::primitive_hashing;
|
||||
size_t seed = 0;
|
||||
seed = hash_combine(seed, get_md_hash(inp->getDnnlDesc().data));
|
||||
seed = get_vector_hash(seed, stride);
|
||||
seed = get_vector_hash(seed, kernel);
|
||||
seed = get_vector_hash(seed, effective_pad_begin);
|
||||
seed = get_vector_hash(seed, effective_pad_end);
|
||||
seed = get_vector_hash(seed, effective_dilation);
|
||||
seed = get_vector_hash(seed, data_pad_end);
|
||||
seed = hash_combine(seed, get_md_hash(out->getDnnlDesc().data));
|
||||
seed = hash_combine(seed, get_attr_hash(*attr.get()));
|
||||
seed = hash_combine(seed, alg);
|
||||
seed = hash_combine(seed, implType);
|
||||
return seed;
|
||||
}
|
||||
|
||||
bool operator==(const PoolingKey& rhs) const {
|
||||
bool result = true;
|
||||
if (inp != rhs.inp) {
|
||||
result = result && inp && rhs.inp && (inp->getDnnlDesc() == rhs.inp->getDnnlDesc());
|
||||
}
|
||||
|
||||
if (out != rhs.out) {
|
||||
result = result && out && rhs.out && (out->getDnnlDesc() == rhs.out->getDnnlDesc());
|
||||
}
|
||||
|
||||
result = result && stride == rhs.stride && kernel == rhs.kernel &&
|
||||
effective_pad_begin == rhs.effective_pad_begin && effective_pad_end == rhs.effective_pad_end &&
|
||||
effective_dilation == rhs.effective_dilation && data_pad_end == rhs.data_pad_end &&
|
||||
*attr.get() == *rhs.attr.get() && alg == rhs.alg && implType == rhs.implType;
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
std::shared_ptr<pooling_v2_forward::desc> createDescriptorHelper(const mkldnn::memory::desc& in_candidate,
|
||||
const mkldnn::memory::desc& out_candidate,
|
||||
const mkldnn::algorithm alg,
|
||||
const std::vector<ptrdiff_t>& stride,
|
||||
const std::vector<ptrdiff_t>& kernel,
|
||||
const std::vector<ptrdiff_t>& effective_pad_begin,
|
||||
const std::vector<ptrdiff_t>& effective_pad_end,
|
||||
const std::vector<ptrdiff_t>& effective_dilation,
|
||||
const std::vector<ptrdiff_t>& data_pad_end) {
|
||||
if (alg == mkldnn::algorithm::undef) {
|
||||
IE_THROW() << "Unsupported pooling type";
|
||||
}
|
||||
|
||||
auto convert = [](std::vector<ptrdiff_t> orig_dims) {
|
||||
return memory::dims(orig_dims.begin(), orig_dims.end());
|
||||
};
|
||||
std::shared_ptr<pooling_v2_forward::desc> 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
|
||||
// with tacking into account original pads. So we need to restore
|
||||
// original values for end paddings.
|
||||
//
|
||||
// WA. Because mkldnn uses different formula to calculate AVG norm coeff
|
||||
// in compare with Caffe. In mkldnn coeff is always 1/(KH*KW)
|
||||
for (int i = 0; i < data_pad_end.size(); i++) {
|
||||
if (data_pad_end[i] != effective_pad_end[i])
|
||||
desc_ptr->data.padding[1][i] = static_cast<ptrdiff_t>(data_pad_end[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return desc_ptr;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
bool MKLDNNPoolingNode::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
|
||||
try {
|
||||
if (ov::is_type<const ov::op::v8::MaxPool>(op)) {
|
||||
@ -239,9 +339,7 @@ void MKLDNNPoolingNode::prepareParams() {
|
||||
}
|
||||
|
||||
auto inDesc = getParentEdgesAtPort(0)[0]->getMemory().GetDescWithType<DnnlMemoryDesc>();
|
||||
const auto& in_candidate = inDesc->getDnnlDesc();
|
||||
auto outDesc = getChildEdgesAtPort(0)[0]->getMemory().GetDescWithType<DnnlMemoryDesc>();
|
||||
const auto& out_candidate = outDesc->getDnnlDesc();
|
||||
|
||||
if (isDynamicNode()) {
|
||||
if (auto_pad) {
|
||||
@ -251,22 +349,52 @@ void MKLDNNPoolingNode::prepareParams() {
|
||||
}
|
||||
|
||||
mkldnn::algorithm alg = getPoolingAlgorithm();
|
||||
MKLDNNDescriptor desc{createDescriptorInternal(in_candidate, out_candidate, alg)};
|
||||
pooling_v2_forward::primitive_desc prim_desc;
|
||||
primitive_desc_iterator itpd = desc.createPrimitiveDescriptorIterator(getEngine(), *attr);
|
||||
PoolingKey key = {inDesc,
|
||||
outDesc,
|
||||
stride,
|
||||
kernel,
|
||||
effective_pad_begin,
|
||||
effective_pad_end,
|
||||
effective_dilation,
|
||||
data_pad_end,
|
||||
*attr,
|
||||
alg,
|
||||
selected_pd->getImplementationType()};
|
||||
auto engine = getEngine();
|
||||
auto builder = [&engine](const PoolingKey& key) -> std::shared_ptr<mkldnn::primitive> {
|
||||
auto desc_ptr = createDescriptorHelper(key.inp->getDnnlDesc(),
|
||||
key.out->getDnnlDesc(),
|
||||
key.alg,
|
||||
key.stride,
|
||||
key.kernel,
|
||||
key.effective_pad_begin,
|
||||
key.effective_pad_end,
|
||||
key.effective_dilation,
|
||||
key.data_pad_end);
|
||||
MKLDNNDescriptor desc{desc_ptr};
|
||||
pooling_v2_forward::primitive_desc prim_desc;
|
||||
primitive_desc_iterator itpd = desc.createPrimitiveDescriptorIterator(engine, key.attr);
|
||||
while (static_cast<bool>(itpd)) {
|
||||
impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str());
|
||||
|
||||
while (static_cast<bool>(itpd)) {
|
||||
impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str());
|
||||
|
||||
if (impl_type == selected_pd->getImplementationType()) {
|
||||
prim_desc = itpd.get();
|
||||
break;
|
||||
if (impl_type == key.implType) {
|
||||
prim_desc = itpd.get();
|
||||
break;
|
||||
}
|
||||
if (!itpd.next_impl())
|
||||
return nullptr;
|
||||
}
|
||||
if (!itpd.next_impl())
|
||||
IE_THROW() << "Primitive descriptor was not found for node " << getName() << ".";
|
||||
return std::make_shared<pooling_v2_forward>(prim_desc);
|
||||
};
|
||||
|
||||
auto cache = getRuntimeCache();
|
||||
auto result = cache->getOrCreate(key, builder);
|
||||
|
||||
if (!result.first) {
|
||||
IE_THROW() << "Primitive descriptor was not found for node " << getName() << ".";
|
||||
}
|
||||
|
||||
prim.reset(new pooling_v2_forward(prim_desc));
|
||||
prim = result.first;
|
||||
|
||||
auto src = getParentEdgesAtPort(0)[0]->getMemoryPtr()->GetPrimitive();
|
||||
auto dst = getChildEdgesAtPort(0)[0]->getMemoryPtr()->GetPrimitive();
|
||||
@ -308,39 +436,19 @@ mkldnn::algorithm MKLDNNPoolingNode::getPoolingAlgorithm() const {
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<pooling_v2_forward::desc> 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";
|
||||
}
|
||||
|
||||
auto convert = [] (std::vector<ptrdiff_t> orig_dims) {
|
||||
return memory::dims(orig_dims.begin(), orig_dims.end());
|
||||
};
|
||||
std::shared_ptr<pooling_v2_forward::desc> 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
|
||||
// with tacking into account original pads. So we need to restore
|
||||
// original values for end paddings.
|
||||
//
|
||||
// WA. Because mkldnn uses different formula to calculate AVG norm coeff
|
||||
// in compare with Caffe. In mkldnn coeff is always 1/(KH*KW)
|
||||
for (int i = 0; i < data_pad_end.size(); i++) {
|
||||
if (data_pad_end[i] != effective_pad_end[i])
|
||||
desc_ptr->data.padding[1][i] = static_cast<ptrdiff_t>(data_pad_end[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return desc_ptr;
|
||||
std::shared_ptr<pooling_v2_forward::desc> MKLDNNPoolingNode::createDescriptorInternal(
|
||||
const mkldnn::memory::desc& in_candidate,
|
||||
const mkldnn::memory::desc& out_candidate,
|
||||
const mkldnn::algorithm alg) const {
|
||||
return createDescriptorHelper(in_candidate,
|
||||
out_candidate,
|
||||
alg,
|
||||
stride,
|
||||
kernel,
|
||||
effective_pad_begin,
|
||||
effective_pad_end,
|
||||
effective_dilation,
|
||||
data_pad_end);
|
||||
}
|
||||
|
||||
void MKLDNNPoolingNode::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
|
||||
|
||||
@ -1,427 +1,397 @@
|
||||
//// Copyright (C) 2018-2021 Intel Corporation
|
||||
//// SPDX-License-Identifier: Apache-2.0
|
||||
////
|
||||
//
|
||||
//#include "shared_test_classes/base/layer_test_utils.hpp"
|
||||
//#include "test_utils/cpu_test_utils.hpp"
|
||||
//#include "ngraph_functions/builders.hpp"
|
||||
//
|
||||
//using namespace InferenceEngine;
|
||||
//using namespace ngraph;
|
||||
//using namespace CPUTestUtils;
|
||||
//
|
||||
//namespace CPULayerTestsDefinitions {
|
||||
//
|
||||
//using inputShapes = std::tuple<std::vector<ngraph::PartialShape>, // dynamic input shapes
|
||||
// std::vector<ngraph::Shape>, // target input shapes
|
||||
// std::vector<SizeVector>>; // range input shapes
|
||||
//
|
||||
//using fqSpecificParams = std::tuple<int64_t, // 'data' input low bounds
|
||||
// int64_t, // 'data' input high bounds
|
||||
// std::vector<float>, // output low
|
||||
// std::vector<float>, // output high
|
||||
// size_t>; // levels
|
||||
//
|
||||
//using fqLayerTestParamsSet = std::tuple<fqSpecificParams,
|
||||
// inputShapes, // input shapes
|
||||
// Precision, // input precision
|
||||
// std::pair<std::vector<float>, std::vector<float>>, // il and ih values
|
||||
// bool, // should be decomposed
|
||||
// CPUSpecificParams>;
|
||||
//
|
||||
//class FakeQuantizeLayerCPUTest : public testing::WithParamInterface<fqLayerTestParamsSet>,
|
||||
// virtual public LayerTestsUtils::LayerTestsCommon, public CPUTestsBase {
|
||||
//public:
|
||||
// static std::string getTestCaseName(testing::TestParamInfo<fqLayerTestParamsSet> obj) {
|
||||
// fqSpecificParams fqParams;
|
||||
// inputShapes testShapes;
|
||||
// Precision inPrec;
|
||||
// std::pair<std::vector<float>, std::vector<float>> inputRangesValues;
|
||||
// bool shouldBeDecomposed;
|
||||
// CPUSpecificParams cpuParams;
|
||||
// std::tie(fqParams, testShapes, inPrec, inputRangesValues, shouldBeDecomposed, cpuParams) = obj.param;
|
||||
//
|
||||
// std::vector<ngraph::PartialShape> dynamicShapes;
|
||||
// std::vector<ngraph::Shape> targetShapes;
|
||||
// std::vector<SizeVector> ranges;
|
||||
// std::tie(dynamicShapes, targetShapes, ranges) = testShapes;
|
||||
//
|
||||
// int64_t inDataLowBounds, inDataHighBounds;
|
||||
// std::vector<float> inputLow, inputHigh, outputLow, outputHigh;
|
||||
// size_t levels;
|
||||
// inputLow = inputRangesValues.first;
|
||||
// inputHigh = inputRangesValues.second;
|
||||
// std::tie(inDataLowBounds, inDataHighBounds, outputLow, outputHigh, levels) = fqParams;
|
||||
//
|
||||
// std::ostringstream result;
|
||||
// if (!dynamicShapes.empty()) {
|
||||
// result << "IS=" << CommonTestUtils::partialShape2str(dynamicShapes) << "_";
|
||||
// }
|
||||
// result << "TS=";
|
||||
// for (const auto& shape : targetShapes) {
|
||||
// result << "(" << CommonTestUtils::vec2str(shape) << ")_";
|
||||
// }
|
||||
// result << "RS=";
|
||||
// for (const auto& data : ranges) {
|
||||
// result << "(" << CommonTestUtils::vec2str(data) << ")_";
|
||||
// }
|
||||
// result << "inPrec=" << inPrec.name() << "_";
|
||||
//
|
||||
// result << "LOW_BOUNDS=" << inDataLowBounds << "_";
|
||||
// result << "HIGH_BOUNDS=" << inDataHighBounds << "_";
|
||||
// result << "IL=" << CommonTestUtils::vec2str(inputLow) << "_";
|
||||
// result << "IH=" << CommonTestUtils::vec2str(inputHigh) << "_";
|
||||
// result << "OL=" << CommonTestUtils::vec2str(outputLow) << "_";
|
||||
// result << "OH=" << CommonTestUtils::vec2str(outputHigh) << "_";
|
||||
// result << "LEVELS=" << levels;
|
||||
//
|
||||
// result << CPUTestsBase::getTestCaseName(cpuParams);
|
||||
//
|
||||
// return result.str();
|
||||
// }
|
||||
//
|
||||
// void Infer() override {
|
||||
// inferRequest = executableNetwork.CreateInferRequest();
|
||||
// inputs.clear();
|
||||
//
|
||||
// const InputsDataMap &inDataMap = cnnNetwork.getInputsInfo();
|
||||
// auto input = inDataMap.begin();
|
||||
//
|
||||
// const auto td = input->second->getTensorDesc();
|
||||
// Blob::Ptr blob = FuncTestUtils::createAndFillBlob(InferenceEngine::TensorDesc(td.getPrecision(), targetStaticShapes[index][0], td.getLayout()),
|
||||
// inDataHighBounds - inDataLowBounds, inDataLowBounds);
|
||||
// inferRequest.SetBlob(input->second->name(), blob);
|
||||
// inputs.push_back(blob);
|
||||
//
|
||||
// inferRequest.Infer();
|
||||
// }
|
||||
//
|
||||
//protected:
|
||||
// std::string layerName;
|
||||
//
|
||||
// void SetUp() override {
|
||||
// targetDevice = CommonTestUtils::DEVICE_CPU;
|
||||
// fqSpecificParams fqParams;
|
||||
// inputShapes testShapes;
|
||||
// Precision inPrec;
|
||||
// std::pair<std::vector<float>, std::vector<float>> inputRangesValues;
|
||||
// bool shouldBeDecomposed;
|
||||
// CPUSpecificParams cpuParams;
|
||||
// std::tie(fqParams, testShapes, inPrec, inputRangesValues, shouldBeDecomposed, cpuParams) = this->GetParam();
|
||||
//
|
||||
// std::tie(inFmts, outFmts, priority, selectedType) = cpuParams;
|
||||
//
|
||||
// std::vector<ngraph::Shape> targetShapes;
|
||||
// std::vector<SizeVector> ranges;
|
||||
// std::tie(inputDynamicShapes, targetShapes, ranges) = testShapes;
|
||||
//
|
||||
// for (size_t i = 0; i < targetShapes.size(); i++) {
|
||||
// targetStaticShapes.push_back(std::vector<ov::Shape>{targetShapes});
|
||||
// }
|
||||
//
|
||||
// size_t levels;
|
||||
// std::vector<std::vector<float>> rangesBounds(RANGES_INPUT_NUMBER);
|
||||
// rangesBounds[0] = inputRangesValues.first;
|
||||
// rangesBounds[1] = inputRangesValues.second;
|
||||
// std::tie(inDataLowBounds, inDataHighBounds, rangesBounds[2], rangesBounds[3], levels) = fqParams;
|
||||
//
|
||||
// auto ngInPrec = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
|
||||
// ParameterVector params = builder::makeParams(ngInPrec, {targetStaticShapes[0][0]});
|
||||
// auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset5::Parameter>(params));
|
||||
//
|
||||
// auto il = builder::makeConstant(ngInPrec, ranges[0], rangesBounds[0], rangesBounds[0].empty());
|
||||
// auto ih = builder::makeConstant(ngInPrec, ranges[1], rangesBounds[1], rangesBounds[1].empty());
|
||||
// auto ol = builder::makeConstant(ngInPrec, ranges[2], rangesBounds[2], rangesBounds[2].empty());
|
||||
// auto oh = builder::makeConstant(ngInPrec, ranges[3], rangesBounds[3], rangesBounds[3].empty());
|
||||
// auto fq = std::make_shared<opset5::FakeQuantize>(paramOuts[0], il, ih, ol, oh, levels);
|
||||
//
|
||||
// layerName = shouldBeDecomposed ? "" : "FakeQuantize";
|
||||
//
|
||||
// if (selectedType.empty()) {
|
||||
// selectedType = getPrimitiveType() + "_" + inPrec.name();
|
||||
// }
|
||||
//
|
||||
// function = makeNgraphFunction(ngInPrec, params, fq, "FakeQuantizeCPU");
|
||||
// }
|
||||
//
|
||||
//private:
|
||||
// const size_t RANGES_INPUT_NUMBER = 4;
|
||||
//
|
||||
// int64_t inDataLowBounds, inDataHighBounds;
|
||||
//};
|
||||
//
|
||||
//TEST_P(FakeQuantizeLayerCPUTest, CompareWithRefs) {
|
||||
// SKIP_IF_CURRENT_TEST_IS_DISABLED()
|
||||
// Run();
|
||||
//
|
||||
// CheckPluginRelatedResults(executableNetwork, layerName);
|
||||
//}
|
||||
//
|
||||
//
|
||||
//const std::vector<size_t> levels = {16, 255, 256};
|
||||
//
|
||||
//int64_t dataLowBounds{-10}, dataHighBounds{10};
|
||||
//
|
||||
//const std::vector<std::pair<std::vector<float>, std::vector<float>>> input_ranges = {
|
||||
// {{0.0f}, {5.f}},
|
||||
// {{-10.0f}, {-5.f}}
|
||||
//};
|
||||
//
|
||||
//const std::vector<float> outputLow{5.0f}, outputHigh{25.0f};
|
||||
//
|
||||
//const auto specificParams = ::testing::Combine(::testing::Values(dataLowBounds),
|
||||
// ::testing::Values(dataHighBounds),
|
||||
// ::testing::Values(outputLow),
|
||||
// ::testing::Values(outputHigh),
|
||||
// ::testing::ValuesIn(levels));
|
||||
//
|
||||
//namespace fqImpl {
|
||||
//
|
||||
//std::vector<CPUSpecificParams> memForm4D_jit = {
|
||||
// CPUSpecificParams({nchw}, {nchw}, {}, {}),
|
||||
// CPUSpecificParams({nhwc}, {nhwc}, {}, {}),
|
||||
// CPUSpecificParams({nChw16c}, {nChw16c}, {}, {})
|
||||
//};
|
||||
//
|
||||
//std::vector<inputShapes> rangesShapes4D_jit = {
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{1, 5, 1, 1}, {1, 5, 1, 1}, {1, 5, 1, 1}, {1, 5, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1}},
|
||||
// {{4, 5, 6, 7}, {1, 12, 1, 1}, {4, 1, 8, 2}, {1, 16, 6, 1}},
|
||||
// {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1}},
|
||||
// {{4, 16, 6, 7}, {1, 16, 1, 1}, {7, 16, 1, 2}, {1, 16, 6, 1}},
|
||||
// {{1, 16, 1, 1}, {1, 16, 1, 1}, {1, 16, 1, 1}, {1, 16, 1, 1}}
|
||||
// },
|
||||
//};
|
||||
//
|
||||
//const auto testParams4D_jit = ::testing::Combine(specificParams,
|
||||
// ::testing::ValuesIn(rangesShapes4D_jit),
|
||||
// ::testing::Values(Precision::FP32),
|
||||
// ::testing::ValuesIn(input_ranges),
|
||||
// ::testing::Values(false),
|
||||
// ::testing::ValuesIn(filterCPUSpecificParams(memForm4D_jit)));
|
||||
//INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_4D_jit, FakeQuantizeLayerCPUTest, testParams4D_jit, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
//
|
||||
//
|
||||
//std::vector<CPUSpecificParams> memForm4D_ref = {
|
||||
// CPUSpecificParams({nchw}, {nchw}, {"ref_FP32"}, {"ref_FP32"})
|
||||
//};
|
||||
//
|
||||
//std::vector<inputShapes> rangesShapes4D_ref = {
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1}},
|
||||
// {{4, 16, 6, 7}, {4, 1, 1, 1}, {4, 16, 1, 2}, {4, 16, 6, 1}},
|
||||
// {{4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}}
|
||||
// },
|
||||
//};
|
||||
//
|
||||
//const auto testParams4D_ref = ::testing::Combine(specificParams,
|
||||
// ::testing::ValuesIn(rangesShapes4D_ref),
|
||||
// ::testing::Values(Precision::FP32),
|
||||
// ::testing::ValuesIn(input_ranges),
|
||||
// ::testing::Values(false),
|
||||
// ::testing::ValuesIn(memForm4D_ref));
|
||||
//INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_4D_ref, FakeQuantizeLayerCPUTest, testParams4D_ref, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
//
|
||||
//
|
||||
//std::vector<CPUSpecificParams> memForm5D_jit = {
|
||||
// CPUSpecificParams({ncdhw}, {ncdhw}, {}, {}),
|
||||
// CPUSpecificParams({ndhwc}, {ndhwc}, {}, {}),
|
||||
// CPUSpecificParams({nCdhw16c}, {nCdhw16c}, {}, {})
|
||||
//};
|
||||
//
|
||||
//std::vector<inputShapes> rangesShapes5D_jit = {
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{1, 4, 1, 1, 1}, {1, 4, 1, 1, 1}, {1, 4, 1, 1, 1}, {1, 4, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1, -1}},
|
||||
// {{3, 4, 5, 6, 7}, {1, 12, 1, 1, 1}, {4, 1, 8, 2, 7}, {1, 16, 6, 5, 1}},
|
||||
// {{1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1, -1}},
|
||||
// {{4, 16, 6, 7, 8}, {1, 16, 1, 1, 1}, {7, 16, 1, 2, 5}, {1, 16, 6, 1, 7}},
|
||||
// {{1, 16, 1, 1, 1}, {1, 16, 1, 1, 1}, {1, 16, 1, 1, 1}, {1, 16, 1, 1, 1}}
|
||||
// },
|
||||
//};
|
||||
//
|
||||
//const auto testParams5D_jit = ::testing::Combine(specificParams,
|
||||
// ::testing::ValuesIn(rangesShapes5D_jit),
|
||||
// ::testing::Values(Precision::FP32),
|
||||
// ::testing::ValuesIn(input_ranges),
|
||||
// ::testing::Values(false),
|
||||
// ::testing::ValuesIn(filterCPUSpecificParams(memForm5D_jit)));
|
||||
//
|
||||
//INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_5D_jit, FakeQuantizeLayerCPUTest, testParams5D_jit, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
//
|
||||
//
|
||||
//std::vector<CPUSpecificParams> memForm5D_ref = {
|
||||
// CPUSpecificParams({ncdhw}, {ncdhw}, {"ref_FP32"}, {"ref_FP32"})
|
||||
//};
|
||||
//
|
||||
//std::vector<inputShapes> rangesShapes5D_ref = {
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1, -1}},
|
||||
// {{3, 16, 6, 7, 8}, {3, 16, 1, 1, 1}, {3, 16, 1, 2, 5}, {3, 16, 6, 1, 7}},
|
||||
// {{3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}}
|
||||
// },
|
||||
//};
|
||||
//
|
||||
//const auto testParams5D_ref = ::testing::Combine(specificParams,
|
||||
// ::testing::ValuesIn(rangesShapes5D_ref),
|
||||
// ::testing::Values(Precision::FP32),
|
||||
// ::testing::ValuesIn(input_ranges),
|
||||
// ::testing::Values(false),
|
||||
// ::testing::ValuesIn(memForm5D_ref));
|
||||
//
|
||||
//INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_5D_ref, FakeQuantizeLayerCPUTest, testParams5D_ref, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
//
|
||||
//const auto specificParamsBin = ::testing::Combine(::testing::Values(dataLowBounds),
|
||||
// ::testing::Values(dataHighBounds),
|
||||
// ::testing::Values(std::vector<float>{0.0f}),
|
||||
// ::testing::Values(std::vector<float>{1.0f}),
|
||||
// ::testing::Values(2));
|
||||
//
|
||||
//const auto testParamsBin4D = ::testing::Combine(specificParamsBin,
|
||||
// ::testing::ValuesIn(rangesShapes4D_jit),
|
||||
// ::testing::Values(Precision::FP32),
|
||||
// ::testing::Values(std::pair<std::vector<float>, std::vector<float>>{{3.0f}, {3.f}}),
|
||||
// ::testing::Values(false),
|
||||
// ::testing::Values(CPUSpecificParams()));
|
||||
//
|
||||
//INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_4D_bin, FakeQuantizeLayerCPUTest, testParamsBin4D, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
//
|
||||
//} // namespace fqImpl
|
||||
//
|
||||
//namespace fqDecompos {
|
||||
//
|
||||
//std::vector<inputShapes> decomposeShapes = {
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{1, 5, 1, 1}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{1, 5, 1, 1}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{3, 4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{2, 3, 4, 5, 6, 7}},
|
||||
// {{4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{2, 3, 4, 5, 6, 7}},
|
||||
// {{1, 5, 1, 1}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{2, 3, 4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{2, 3, 4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {},
|
||||
// {{2, 3, 4, 5, 6, 7}},
|
||||
// {{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1}},
|
||||
// {{4, 5, 6, 7}, {1, 5, 6, 7}, {7, 5, 6, 7}},
|
||||
// {{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
// },
|
||||
// inputShapes{
|
||||
// {{-1, -1, -1, -1, -1}},
|
||||
// {{8, 4, 5, 6, 7}, {1, 1, 5, 6, 7}, {1, 1, 1, 6, 7}},
|
||||
// {{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
// },
|
||||
//};
|
||||
//
|
||||
//const auto testParams = ::testing::Combine(specificParams,
|
||||
// ::testing::ValuesIn(decomposeShapes),
|
||||
// ::testing::Values(Precision::FP32),
|
||||
// ::testing::ValuesIn(input_ranges),
|
||||
// ::testing::Values(true),
|
||||
// ::testing::Values(CPUSpecificParams{}));
|
||||
//
|
||||
//INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_Decompos, FakeQuantizeLayerCPUTest, testParams, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
//
|
||||
//} // namespace fqDecompos
|
||||
//
|
||||
//} // namespace CPULayerTestsDefinitions
|
||||
// Copyright (C) 2018-2021 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include "test_utils/cpu_test_utils.hpp"
|
||||
#include "ngraph_functions/builders.hpp"
|
||||
#include "shared_test_classes/base/ov_subgraph.hpp"
|
||||
#include <functional_test_utils/ov_tensor_utils.hpp>
|
||||
|
||||
using namespace InferenceEngine;
|
||||
using namespace ngraph;
|
||||
using namespace CPUTestUtils;
|
||||
using namespace ov::test;
|
||||
|
||||
namespace CPULayerTestsDefinitions {
|
||||
using inputShapes = std::tuple<ov::test::InputShape, // dynamic data shape
|
||||
std::vector<SizeVector>>; // range input shapes
|
||||
|
||||
using fqSpecificParams = std::tuple<int64_t, // 'data' input low bounds
|
||||
int64_t, // 'data' input high bounds
|
||||
std::vector<float>, // output low
|
||||
std::vector<float>, // output high
|
||||
size_t>; // levels
|
||||
|
||||
using fqLayerTestParamsSet = std::tuple<fqSpecificParams,
|
||||
inputShapes, // input shapes
|
||||
Precision, // input precision
|
||||
std::pair<std::vector<float>, std::vector<float>>, // il and ih values
|
||||
bool, // should be decomposed
|
||||
CPUSpecificParams>;
|
||||
|
||||
class FakeQuantizeLayerCPUTest : public testing::WithParamInterface<fqLayerTestParamsSet>,
|
||||
virtual public SubgraphBaseTest, public CPUTestsBase {
|
||||
public:
|
||||
static std::string getTestCaseName(testing::TestParamInfo<fqLayerTestParamsSet> obj) {
|
||||
fqSpecificParams fqParams;
|
||||
inputShapes testShapes;
|
||||
Precision inPrec;
|
||||
std::pair<std::vector<float>, std::vector<float>> inputRangesValues;
|
||||
bool shouldBeDecomposed;
|
||||
CPUSpecificParams cpuParams;
|
||||
std::tie(fqParams, testShapes, inPrec, inputRangesValues, shouldBeDecomposed, cpuParams) = obj.param;
|
||||
|
||||
InputShape shapes;
|
||||
std::vector<SizeVector> ranges;
|
||||
std::tie(shapes, ranges) = testShapes;
|
||||
|
||||
int64_t inDataLowBounds, inDataHighBounds;
|
||||
std::vector<float> inputLow, inputHigh, outputLow, outputHigh;
|
||||
size_t levels;
|
||||
inputLow = inputRangesValues.first;
|
||||
inputHigh = inputRangesValues.second;
|
||||
std::tie(inDataLowBounds, inDataHighBounds, outputLow, outputHigh, levels) = fqParams;
|
||||
|
||||
std::ostringstream result;
|
||||
|
||||
result << "IS=" << CommonTestUtils::partialShape2str({shapes.first}) << "_";
|
||||
result << "TS=";
|
||||
for (const auto& shape : shapes.second) {
|
||||
result << "(" << CommonTestUtils::vec2str(shape) << ")_";
|
||||
}
|
||||
result << "RS=";
|
||||
for (const auto& data : ranges) {
|
||||
result << "(" << CommonTestUtils::vec2str(data) << ")_";
|
||||
}
|
||||
result << "inPrec=" << inPrec.name() << "_";
|
||||
|
||||
result << "LOW_BOUNDS=" << inDataLowBounds << "_";
|
||||
result << "HIGH_BOUNDS=" << inDataHighBounds << "_";
|
||||
result << "IL=" << CommonTestUtils::vec2str(inputLow) << "_";
|
||||
result << "IH=" << CommonTestUtils::vec2str(inputHigh) << "_";
|
||||
result << "OL=" << CommonTestUtils::vec2str(outputLow) << "_";
|
||||
result << "OH=" << CommonTestUtils::vec2str(outputHigh) << "_";
|
||||
result << "LEVELS=" << levels;
|
||||
|
||||
result << CPUTestsBase::getTestCaseName(cpuParams);
|
||||
|
||||
return result.str();
|
||||
}
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
std::string layerName;
|
||||
|
||||
void SetUp() override {
|
||||
targetDevice = CommonTestUtils::DEVICE_CPU;
|
||||
fqSpecificParams fqParams;
|
||||
inputShapes testShapes;
|
||||
Precision inPrec;
|
||||
std::pair<std::vector<float>, std::vector<float>> inputRangesValues;
|
||||
bool shouldBeDecomposed;
|
||||
CPUSpecificParams cpuParams;
|
||||
std::tie(fqParams, testShapes, inPrec, inputRangesValues, shouldBeDecomposed, cpuParams) = this->GetParam();
|
||||
|
||||
std::tie(inFmts, outFmts, priority, selectedType) = cpuParams;
|
||||
|
||||
InputShape shapes;
|
||||
std::vector<SizeVector> ranges;
|
||||
std::tie(shapes, ranges) = testShapes;
|
||||
|
||||
inputDynamicShapes.push_back(shapes.first);
|
||||
for (size_t i = 0; i < shapes.second.size(); i++) {
|
||||
targetStaticShapes.push_back(std::vector<ov::Shape>{shapes.second[i]});
|
||||
}
|
||||
|
||||
size_t levels;
|
||||
std::vector<std::vector<float>> rangesBounds(RANGES_INPUT_NUMBER);
|
||||
rangesBounds[0] = inputRangesValues.first;
|
||||
rangesBounds[1] = inputRangesValues.second;
|
||||
std::tie(inDataLowBounds, inDataHighBounds, rangesBounds[2], rangesBounds[3], levels) = fqParams;
|
||||
|
||||
auto ngInPrec = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(inPrec);
|
||||
ParameterVector params = builder::makeDynamicParams(ngInPrec, inputDynamicShapes);
|
||||
auto paramOuts = helpers::convert2OutputVector(helpers::castOps2Nodes<opset5::Parameter>(params));
|
||||
|
||||
auto il = builder::makeConstant(ngInPrec, ranges[0], rangesBounds[0], rangesBounds[0].empty());
|
||||
auto ih = builder::makeConstant(ngInPrec, ranges[1], rangesBounds[1], rangesBounds[1].empty());
|
||||
auto ol = builder::makeConstant(ngInPrec, ranges[2], rangesBounds[2], rangesBounds[2].empty());
|
||||
auto oh = builder::makeConstant(ngInPrec, ranges[3], rangesBounds[3], rangesBounds[3].empty());
|
||||
auto fq = std::make_shared<opset5::FakeQuantize>(paramOuts[0], il, ih, ol, oh, levels);
|
||||
|
||||
layerName = shouldBeDecomposed ? "" : "FakeQuantize";
|
||||
|
||||
if (selectedType.empty()) {
|
||||
selectedType = getPrimitiveType() + "_" + inPrec.name();
|
||||
}
|
||||
|
||||
function = makeNgraphFunction(ngInPrec, params, fq, "FakeQuantizeCPU");
|
||||
}
|
||||
|
||||
void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override {
|
||||
inputs.clear();
|
||||
const auto& funcInputs = function->inputs();
|
||||
ASSERT_EQ(funcInputs.size(), 1);
|
||||
const auto& funcInput = funcInputs[0];
|
||||
ov::runtime::Tensor tensor;
|
||||
tensor = ov::test::utils::create_and_fill_tensor(funcInput.get_element_type(),
|
||||
targetInputStaticShapes[0],
|
||||
inDataHighBounds - inDataLowBounds,
|
||||
inDataLowBounds);
|
||||
inputs.insert({funcInput.get_node_shared_ptr(), tensor});
|
||||
}
|
||||
|
||||
private:
|
||||
const size_t RANGES_INPUT_NUMBER = 4;
|
||||
|
||||
int64_t inDataLowBounds, inDataHighBounds;
|
||||
};
|
||||
|
||||
TEST_P(FakeQuantizeLayerCPUTest, CompareWithRefs) {
|
||||
SKIP_IF_CURRENT_TEST_IS_DISABLED()
|
||||
run();
|
||||
|
||||
CheckPluginRelatedResults(executableNetwork, layerName);
|
||||
}
|
||||
|
||||
|
||||
const std::vector<size_t> levels = {16, 255, 256};
|
||||
|
||||
int64_t dataLowBounds{-10}, dataHighBounds{10};
|
||||
|
||||
const std::vector<std::pair<std::vector<float>, std::vector<float>>> input_ranges = {
|
||||
{{0.0f}, {5.f}},
|
||||
{{0.0f}, {}},
|
||||
{{-10.0f}, {-5.f}}
|
||||
};
|
||||
|
||||
const std::vector<float> outputLow{5.0f}, outputHigh{25.0f};
|
||||
|
||||
const auto specificParams = ::testing::Combine(::testing::Values(dataLowBounds),
|
||||
::testing::Values(dataHighBounds),
|
||||
::testing::Values(outputLow),
|
||||
::testing::Values(outputHigh),
|
||||
::testing::ValuesIn(levels));
|
||||
|
||||
namespace fqImpl {
|
||||
|
||||
std::vector<CPUSpecificParams> memForm4D_jit = {
|
||||
CPUSpecificParams({nchw}, {nchw}, {}, {}),
|
||||
CPUSpecificParams({nhwc}, {nhwc}, {}, {}),
|
||||
CPUSpecificParams({nChw16c}, {nChw16c}, {}, {})
|
||||
};
|
||||
|
||||
std::vector<inputShapes> rangesShapes4D_jit = {
|
||||
inputShapes{
|
||||
InputShape{{{4, 5, 6, 7}}, {{4, 5, 6, 7}}},
|
||||
{{1, 5, 1, 1}, {1, 5, 1, 1}, {1, 5, 1, 1}, {1, 5, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{{4, 5, 6, 7}}, {{4, 5, 6, 7}}},
|
||||
{{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1}, {{4, 5, 6, 7}, {1, 12, 1, 1}, {4, 1, 8, 2}, {1, 16, 6, 1}, {4, 5, 6, 7}}},
|
||||
{{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1}, {{4, 16, 6, 7}, {1, 16, 1, 1}, {7, 16, 1, 2}, {1, 16, 6, 1}, {4, 16, 6, 7}}},
|
||||
{{1, 16, 1, 1}, {1, 16, 1, 1}, {1, 16, 1, 1}, {1, 16, 1, 1}}
|
||||
},
|
||||
};
|
||||
|
||||
const auto testParams4D_jit = ::testing::Combine(specificParams,
|
||||
::testing::ValuesIn(rangesShapes4D_jit),
|
||||
::testing::Values(Precision::FP32),
|
||||
::testing::ValuesIn(input_ranges),
|
||||
::testing::Values(false),
|
||||
::testing::ValuesIn(filterCPUSpecificParams(memForm4D_jit)));
|
||||
INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_4D_jit, FakeQuantizeLayerCPUTest, testParams4D_jit, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
|
||||
|
||||
std::vector<CPUSpecificParams> memForm4D_ref = {
|
||||
CPUSpecificParams({nchw}, {nchw}, {"ref_FP32"}, {"ref_FP32"})
|
||||
};
|
||||
|
||||
std::vector<inputShapes> rangesShapes4D_ref = {
|
||||
inputShapes{
|
||||
InputShape{{{4, 5, 6, 7}}, {{4, 5, 6, 7}}},
|
||||
{{4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1}, {{4, 16, 6, 7}, {4, 1, 1, 1}, {4, 16, 1, 2}, {4, 16, 6, 1}, {4, 16, 6, 7}}},
|
||||
{{4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}, {4, 1, 1, 1}}
|
||||
},
|
||||
};
|
||||
|
||||
const auto testParams4D_ref = ::testing::Combine(specificParams,
|
||||
::testing::ValuesIn(rangesShapes4D_ref),
|
||||
::testing::Values(Precision::FP32),
|
||||
::testing::ValuesIn(input_ranges),
|
||||
::testing::Values(false),
|
||||
::testing::ValuesIn(memForm4D_ref));
|
||||
INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_4D_ref, FakeQuantizeLayerCPUTest, testParams4D_ref, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
|
||||
|
||||
std::vector<CPUSpecificParams> memForm5D_jit = {
|
||||
CPUSpecificParams({ncdhw}, {ncdhw}, {}, {}),
|
||||
CPUSpecificParams({ndhwc}, {ndhwc}, {}, {}),
|
||||
CPUSpecificParams({nCdhw16c}, {nCdhw16c}, {}, {})
|
||||
};
|
||||
|
||||
std::vector<inputShapes> rangesShapes5D_jit = {
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{1, 4, 1, 1, 1}, {1, 4, 1, 1, 1}, {1, 4, 1, 1, 1}, {1, 4, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1, -1}, {{3, 4, 5, 6, 7}, {1, 12, 1, 1, 1}, {4, 1, 8, 2, 7}, {3, 4, 5, 6, 7}, {1, 16, 6, 5, 1}}},
|
||||
{{1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1, -1}, {{4, 16, 6, 7, 8}, {1, 16, 1, 1, 1}, {7, 16, 1, 2, 5}, {4, 16, 6, 7, 8}, {1, 16, 6, 1, 7}}},
|
||||
{{1, 16, 1, 1, 1}, {1, 16, 1, 1, 1}, {1, 16, 1, 1, 1}, {1, 16, 1, 1, 1}}
|
||||
},
|
||||
};
|
||||
|
||||
const auto testParams5D_jit = ::testing::Combine(specificParams,
|
||||
::testing::ValuesIn(rangesShapes5D_jit),
|
||||
::testing::Values(Precision::FP32),
|
||||
::testing::ValuesIn(input_ranges),
|
||||
::testing::Values(false),
|
||||
::testing::ValuesIn(filterCPUSpecificParams(memForm5D_jit)));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_5D_jit, FakeQuantizeLayerCPUTest, testParams5D_jit, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
|
||||
|
||||
std::vector<CPUSpecificParams> memForm5D_ref = {
|
||||
CPUSpecificParams({ncdhw}, {ncdhw}, {"ref_FP32"}, {"ref_FP32"})
|
||||
};
|
||||
|
||||
std::vector<inputShapes> rangesShapes5D_ref = {
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1, -1}, {{3, 16, 6, 7, 8}, {3, 16, 1, 1, 1}, {3, 16, 1, 2, 5}, {3, 16, 6, 1, 7}, {3, 16, 6, 7, 8}}},
|
||||
{{3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}, {3, 1, 1, 1, 1}}
|
||||
},
|
||||
};
|
||||
|
||||
const auto testParams5D_ref = ::testing::Combine(specificParams,
|
||||
::testing::ValuesIn(rangesShapes5D_ref),
|
||||
::testing::Values(Precision::FP32),
|
||||
::testing::ValuesIn(input_ranges),
|
||||
::testing::Values(false),
|
||||
::testing::ValuesIn(memForm5D_ref));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_5D_ref, FakeQuantizeLayerCPUTest, testParams5D_ref, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
|
||||
const auto specificParamsBin = ::testing::Combine(::testing::Values(dataLowBounds),
|
||||
::testing::Values(dataHighBounds),
|
||||
::testing::Values(std::vector<float>{0.0f}),
|
||||
::testing::Values(std::vector<float>{1.0f}),
|
||||
::testing::Values(2));
|
||||
|
||||
const auto testParamsBin4D = ::testing::Combine(specificParamsBin,
|
||||
::testing::ValuesIn(rangesShapes4D_jit),
|
||||
::testing::Values(Precision::FP32),
|
||||
::testing::Values(std::pair<std::vector<float>, std::vector<float>>{{3.0f}, {3.f}}),
|
||||
::testing::Values(false),
|
||||
::testing::Values(CPUSpecificParams()));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_4D_bin, FakeQuantizeLayerCPUTest, testParamsBin4D, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
|
||||
} // namespace fqImpl
|
||||
|
||||
namespace fqDecompos {
|
||||
|
||||
std::vector<inputShapes> decomposeShapes = {
|
||||
inputShapes{
|
||||
InputShape{{4, 5, 6, 7}, {{4, 5, 6, 7}}},
|
||||
{{4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{4, 5, 6, 7}, {{4, 5, 6, 7}}},
|
||||
{{1, 5, 1, 1}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{4, 5, 6, 7}, {{4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{4, 5, 6, 7}, {{4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{4, 5, 6, 7}, {{4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{1, 5, 1, 1}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{3, 4, 5, 6, 7}, {{3, 4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{2, 3, 4, 5, 6, 7}, {{2, 3, 4, 5, 6, 7}}},
|
||||
{{4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}, {4, 5, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{2, 3, 4, 5, 6, 7}, {{2, 3, 4, 5, 6, 7}}},
|
||||
{{1, 5, 1, 1}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{2, 3, 4, 5, 6, 7}, {{2, 3, 4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 6, 7}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{2, 3, 4, 5, 6, 7}, {{2, 3, 4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{2, 3, 4, 5, 6, 7}, {{2, 3, 4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1}, {{4, 5, 6, 7}, {1, 5, 6, 7}, {7, 5, 6, 7}, {4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 1}, {1, 5, 6, 7}, {1, 1, 6, 1}, {1, 1, 6, 1}}
|
||||
},
|
||||
inputShapes{
|
||||
InputShape{{-1, -1, -1, -1, -1}, {{8, 4, 5, 6, 7}, {1, 1, 5, 6, 7}, {1, 1, 1, 6, 7}, {8, 4, 5, 6, 7}}},
|
||||
{{1, 1, 6, 7}, {1, 1, 6, 7}, {1, 1, 1, 1}, {1, 1, 1, 1}}
|
||||
},
|
||||
};
|
||||
|
||||
const auto testParams = ::testing::Combine(specificParams,
|
||||
::testing::ValuesIn(decomposeShapes),
|
||||
::testing::Values(Precision::FP32),
|
||||
::testing::ValuesIn(input_ranges),
|
||||
::testing::Values(true),
|
||||
::testing::Values(CPUSpecificParams{}));
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(smoke_FakeQuantizeLayerCPUTest_Decompos, FakeQuantizeLayerCPUTest, testParams, FakeQuantizeLayerCPUTest::getTestCaseName);
|
||||
|
||||
} // namespace fqDecompos
|
||||
|
||||
} // namespace CPULayerTestsDefinitions
|
||||
|
||||
@ -593,7 +593,8 @@ const std::vector<InputShape> inputShapes4D_int8 = {
|
||||
{
|
||||
{1, 32, 8, 8},
|
||||
{1, 32, 8, 4},
|
||||
{2, 32, 8, 12}
|
||||
{2, 32, 8, 12},
|
||||
{1, 32, 8, 8}
|
||||
}
|
||||
},
|
||||
{
|
||||
@ -603,7 +604,8 @@ const std::vector<InputShape> inputShapes4D_int8 = {
|
||||
{
|
||||
{3, 16, 32, 32},
|
||||
{1, 16, 16, 12},
|
||||
{1, 16, 8, 8}
|
||||
{1, 16, 8, 8},
|
||||
{3, 16, 32, 32},
|
||||
}
|
||||
}
|
||||
};
|
||||
@ -631,7 +633,8 @@ const std::vector<InputShape> inputShapes5D_int8 = {
|
||||
{
|
||||
{2, 32, 8, 8, 8},
|
||||
{1, 32, 16, 20, 8},
|
||||
{1, 32, 16, 16, 16}
|
||||
{1, 32, 16, 16, 16},
|
||||
{2, 32, 8, 8, 8}
|
||||
}
|
||||
},
|
||||
{
|
||||
@ -641,7 +644,8 @@ const std::vector<InputShape> inputShapes5D_int8 = {
|
||||
{
|
||||
{1, 16, 16, 16, 16},
|
||||
{1, 16, 16, 8, 12},
|
||||
{2, 16, 8, 8, 8}
|
||||
{2, 16, 8, 8, 8},
|
||||
{1, 16, 16, 16, 16},
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user