/** Mask **/
inline int v_signmask(const v_uint8x16& a)
{
- vec_uchar16 sv = vec_sr(a.val, vec_uchar16_sp(7));
- static const vec_uchar16 slm = {0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7};
- sv = vec_sl(sv, slm);
- vec_uint4 sv4 = vec_sum4s(sv, vec_uint4_z);
- static const vec_uint4 slm4 = {0, 0, 8, 8};
- sv4 = vec_sl(sv4, slm4);
- return vec_extract(vec_sums((vec_int4) sv4, vec_int4_z), 3);
+ static const vec_uchar16 qperm = {120, 112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0};
+ return vec_extract((vec_int4)vec_vbpermq(v_reinterpret_as_u8(a).val, qperm), 2);
}
inline int v_signmask(const v_int8x16& a)
{ return v_signmask(v_reinterpret_as_u8(a)); }
inline int v_signmask(const v_int16x8& a)
{
- static const vec_ushort8 slm = {0, 1, 2, 3, 4, 5, 6, 7};
- vec_short8 sv = vec_sr(a.val, vec_ushort8_sp(15));
- sv = vec_sl(sv, slm);
- vec_int4 svi = vec_int4_z;
- svi = vec_sums(vec_sum4s(sv, svi), svi);
- return vec_extract(svi, 3);
+ static const vec_uchar16 qperm = {112, 96, 80, 64, 48, 32, 16, 0, 128, 128, 128, 128, 128, 128, 128, 128};
+ return vec_extract((vec_int4)vec_vbpermq(v_reinterpret_as_u8(a).val, qperm), 2);
}
inline int v_signmask(const v_uint16x8& a)
{ return v_signmask(v_reinterpret_as_s16(a)); }
inline int v_signmask(const v_int32x4& a)
{
- static const vec_uint4 slm = {0, 1, 2, 3};
- vec_int4 sv = vec_sr(a.val, vec_uint4_sp(31));
- sv = vec_sl(sv, slm);
- sv = vec_sums(sv, vec_int4_z);
- return vec_extract(sv, 3);
+ static const vec_uchar16 qperm = {96, 64, 32, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128};
+ return vec_extract((vec_int4)vec_vbpermq(v_reinterpret_as_u8(a).val, qperm), 2);
}
inline int v_signmask(const v_uint32x4& a)
{ return v_signmask(v_reinterpret_as_s32(a)); }
CV_Assert(numChannels <= 4);
// Scale
- auto weights = InferenceEngine::make_shared_blob<float>(InferenceEngine::Precision::FP32,
- {numChannels});
+ InferenceEngine::TensorDesc td(InferenceEngine::Precision::FP32, {numChannels},
+ InferenceEngine::Layout::C);
+ auto weights = InferenceEngine::make_shared_blob<float>(td);
weights->allocate();
- weights->set(std::vector<float>(numChannels, scaleFactors[0]));
+
+ float* weight_buf = weights->buffer().as<float*>();
+ std::fill(weight_buf, weight_buf + numChannels, scaleFactors[0]);
// Mean subtraction
- auto biases = InferenceEngine::make_shared_blob<float>(InferenceEngine::Precision::FP32,
- {numChannels});
+ auto biases = InferenceEngine::make_shared_blob<float>(td);
biases->allocate();
- std::vector<float> biasesVec(numChannels);
+ float* bias_buf = biases->buffer().as<float*>();
+
for (int i = 0; i < numChannels; ++i)
{
- biasesVec[i] = -means[0][i] * scaleFactors[0];
+ bias_buf[i] = -means[0][i] * scaleFactors[0];
}
- biases->set(biasesVec);
InferenceEngine::Builder::Layer ieLayer = InferenceEngine::Builder::ScaleShiftLayer(name);
addConstantData("weights", weights, ieLayer);
for (int i = 0; i < ld.outputBlobsWrappers.size(); ++i)
{
InferenceEngine::DataPtr dataPtr = infEngineDataNode(ld.outputBlobsWrappers[i]);
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2019010000)
dataPtr->name = netInputLayer->outNames.empty() ? ld.name : netInputLayer->outNames[i];
+#else
+ dataPtr->setName(netInputLayer->outNames.empty() ? ld.name : netInputLayer->outNames[i]);
+#endif
}
}
else
for (int i = 0; i < ld.outputBlobsWrappers.size(); ++i)
{
InferenceEngine::DataPtr dataPtr = infEngineDataNode(ld.outputBlobsWrappers[i]);
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2019010000)
dataPtr->name = ld.name;
+#else
+ dataPtr->setName(ld.name);
+#endif
}
}
}
for (int i = 0; i < ld.inputBlobsWrappers.size(); ++i)
{
InferenceEngine::DataPtr dataPtr = infEngineDataNode(ld.inputBlobsWrappers[i]);
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2019010000)
dataPtr->name = netInputLayer->outNames[i];
+#else
+ dataPtr->setName(netInputLayer->outNames[i]);
+#endif
}
}
else
for (int i = 0; i < ld.outputBlobsWrappers.size(); ++i)
{
InferenceEngine::DataPtr dataPtr = infEngineDataNode(ld.outputBlobsWrappers[i]);
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2019010000)
dataPtr->name = ld.name;
+#else
+ dataPtr->setName(ld.name);
+#endif
}
}
ieNode->net->addBlobs(ld.inputBlobsWrappers);
virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> >& inputs) CV_OVERRIDE
{
InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);
- CV_Assert(!input->dims.empty());
+ std::vector<size_t> dims = input->getDims();
+ CV_Assert(!dims.empty());
InferenceEngine::Builder::Layer ieLayer(name);
ieLayer.setName(name);
else
{
ieLayer.setType("Split");
- ieLayer.getParameters()["axis"] = input->dims.size() - 1;
- ieLayer.getParameters()["out_sizes"] = input->dims[0];
+ ieLayer.getParameters()["axis"] = dims.size() - 1;
+ ieLayer.getParameters()["out_sizes"] = dims[0];
}
- std::vector<size_t> shape(input->dims);
- std::reverse(shape.begin(), shape.end());
- ieLayer.setInputPorts({InferenceEngine::Port(shape)});
+ ieLayer.setInputPorts({InferenceEngine::Port(dims)});
ieLayer.setOutputPorts(std::vector<InferenceEngine::Port>(1));
return Ptr<BackendNode>(new InfEngineBackendNode(ieLayer));
}
InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);
InferenceEngine::Builder::ConcatLayer ieLayer(name);
- ieLayer.setAxis(clamp(axis, input->dims.size()));
+ ieLayer.setAxis(clamp(axis, input->getDims().size()));
ieLayer.setInputPorts(std::vector<InferenceEngine::Port>(inputs.size()));
return Ptr<BackendNode>(new InfEngineBackendNode(ieLayer));
}
virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
{
InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);
- CV_Assert(input->dims.size() == 4 || input->dims.size() == 5);
-
- const int inpCn = input->dims[input->dims.size() - 2]; // NOTE: input->dims are reversed (WHIO or WHDIO)
+ std::vector<size_t> dims = input->getDims();
+ CV_Assert(dims.size() == 4 || dims.size() == 5);
+ const int inpCn = dims[1];
const int outCn = blobs[0].size[0];
const int inpGroupCn = blobs[0].size[1];
const int group = inpCn / inpGroupCn;
-
- InferenceEngine::Layout layout = (input->dims.size() == 4) ? InferenceEngine::Layout::OIHW :
- InferenceEngine::Layout::NCDHW;
+ InferenceEngine::Layout layout = (dims.size() == 4) ? InferenceEngine::Layout::OIHW :
+ InferenceEngine::Layout::NCDHW;
auto ieWeights = wrapToInfEngineBlob(blobs[0], layout);
if (fusedWeights)
}
else
{
- ieWeights = InferenceEngine::make_shared_blob<float>(
- InferenceEngine::Precision::FP32, layout,
- ieWeights->dims());
+ ieWeights = InferenceEngine::make_shared_blob<float>({
+ InferenceEngine::Precision::FP32,
+ ieWeights->getTensorDesc().getDims(), layout
+ });
ieWeights->allocate();
Mat newWeights = infEngineBlobToMat(ieWeights).reshape(1, outCn);
auto ieWeights = wrapToInfEngineBlob(blobs[0], layout);
if (fusedWeights)
{
- ieWeights = InferenceEngine::make_shared_blob<float>(
- InferenceEngine::Precision::FP32, layout,
- ieWeights->dims());
+ ieWeights = InferenceEngine::make_shared_blob<float>({
+ InferenceEngine::Precision::FP32,
+ ieWeights->getTensorDesc().getDims(), layout
+ });
ieWeights->allocate();
int inpCn = blobs[0].size[0];
virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> >& inputs) CV_OVERRIDE
{
InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);
- if (input->dims.size() == 4)
+ std::vector<size_t> dims = input->getDims();
+ if (dims.size() == 4)
{
InferenceEngine::Builder::NormalizeLayer ieLayer(name);
ieLayer.setEpsilon(epsilon);
InferenceEngine::Builder::Layer l = ieLayer;
- const int numChannels = input->dims[2]; // NOTE: input->dims are reversed (whcn)
+ const int numChannels = dims[1];
InferenceEngine::Blob::Ptr weights;
if (blobs.empty())
{
- weights = InferenceEngine::make_shared_blob<float>(InferenceEngine::Precision::FP32,
- InferenceEngine::Layout::C,
- {(size_t)numChannels});
+ weights = InferenceEngine::make_shared_blob<float>({
+ InferenceEngine::Precision::FP32,
+ {(size_t)numChannels}, InferenceEngine::Layout::C
+ });
weights->allocate();
Mat weightsMat = infEngineBlobToMat(weights).reshape(1, numChannels);
if (kernel_size.size() == 3)
return preferableTarget == DNN_TARGET_CPU;
if (preferableTarget == DNN_TARGET_MYRIAD) {
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
if (type == MAX && (pad_l == 1 && pad_t == 1) && stride == Size(2, 2) ) {
return !isMyriadX();
}
+#endif
return type == MAX || type == AVE;
}
else
}
else
{
- auto weights = InferenceEngine::make_shared_blob<float>(InferenceEngine::Precision::FP32,
- {numChannels});
+ auto weights = InferenceEngine::make_shared_blob<float>({
+ InferenceEngine::Precision::FP32, {(size_t)numChannels},
+ InferenceEngine::Layout::C
+ });
weights->allocate();
-
- std::vector<float> ones(numChannels, 1);
- weights->set(ones);
+ float* buf = weights->buffer().as<float*>();
+ std::fill(buf, buf + numChannels, 1);
addConstantData("weights", weights, l);
}
if (hasBias)
{
std::vector<size_t> outShape(numDims);
for (int i = 0; i < numDims; ++i)
- outShape[numDims - 1 - i] = sliceRanges[0][i].size();
+ outShape[i] = sliceRanges[0][i].size();
ieLayer.getInputPorts()[1].setParameter("type", "weights");
- // Fake blob which will be moved to inputs (as weights).
- auto shapeSource = InferenceEngine::make_shared_blob<float>(
- InferenceEngine::Precision::FP32,
- InferenceEngine::Layout::ANY, outShape);
+ auto shapeSource = InferenceEngine::make_shared_blob<float>({
+ InferenceEngine::Precision::FP32, outShape,
+ InferenceEngine::Layout::ANY
+ });
shapeSource->allocate();
addConstantData("weights", shapeSource, ieLayer);
}
InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);
InferenceEngine::Builder::SoftMaxLayer ieLayer(name);
- ieLayer.setAxis(clamp(axisRaw, input->dims.size()));
+ ieLayer.setAxis(clamp(axisRaw, input->getDims().size()));
+
return Ptr<BackendNode>(new InfEngineBackendNode(ieLayer));
}
#endif // HAVE_INF_ENGINE
InfEngineBackendNet::InfEngineBackendNet() : netBuilder("")
{
hasNetOwner = false;
- targetDevice = InferenceEngine::TargetDevice::eCPU;
+ device_name = "CPU";
}
InfEngineBackendNet::InfEngineBackendNet(InferenceEngine::CNNNetwork& net) : netBuilder(""), cnn(net)
{
hasNetOwner = true;
- targetDevice = InferenceEngine::TargetDevice::eCPU;
+ device_name = "CPU";
}
void InfEngineBackendNet::connect(const std::vector<Ptr<BackendWrapper> >& inputs,
for (size_t i = 0; i < inpWrappers.size(); ++i)
{
const auto& inp = inpWrappers[i];
- const std::string& inpName = inp->dataPtr->name;
+ const std::string& inpName = inp->dataPtr->getName();
int inpId;
it = layers.find(inpName);
if (it == layers.end())
{
InferenceEngine::Builder::InputLayer inpLayer(!inpName.empty() ? inpName : kDefaultInpLayerName);
-
- std::vector<size_t> shape(inp->blob->dims());
- std::reverse(shape.begin(), shape.end());
-
+ std::vector<size_t> shape(inp->blob->getTensorDesc().getDims());
inpLayer.setPort(InferenceEngine::Port(shape));
inpId = netBuilder.addLayer(inpLayer);
}
CV_Assert(!outputs.empty());
InferenceEngine::DataPtr dataPtr = infEngineDataNode(outputs[0]);
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
dataPtr->name = layerName;
+#else
+ dataPtr->setName(layerName);
+#endif
}
void InfEngineBackendNet::init(int targetId)
switch (targetId)
{
- case DNN_TARGET_CPU:
- targetDevice = InferenceEngine::TargetDevice::eCPU;
- break;
- case DNN_TARGET_OPENCL: case DNN_TARGET_OPENCL_FP16:
- targetDevice = InferenceEngine::TargetDevice::eGPU;
- break;
- case DNN_TARGET_MYRIAD:
- targetDevice = InferenceEngine::TargetDevice::eMYRIAD;
- break;
- case DNN_TARGET_FPGA:
- targetDevice = InferenceEngine::TargetDevice::eFPGA;
- break;
- default:
- CV_Error(Error::StsError, format("Unknown target identifier: %d", targetId));
- }
+ case DNN_TARGET_CPU:
+ device_name = "CPU";
+ break;
+ case DNN_TARGET_OPENCL:
+ case DNN_TARGET_OPENCL_FP16:
+ device_name = "GPU";
+ break;
+ case DNN_TARGET_MYRIAD:
+ device_name = "MYRIAD";
+ break;
+ case DNN_TARGET_FPGA:
+ device_name = "FPGA";
+ break;
+ default:
+ CV_Error(Error::StsNotImplemented, "Unknown target");
+ };
for (const auto& name : requestedOutputs)
{
const std::string& name = it.first;
auto blobIt = allBlobs.find(name);
CV_Assert(blobIt != allBlobs.end());
- it.second->setPrecision(blobIt->second->precision());
+ it.second->setPrecision(blobIt->second->getTensorDesc().getPrecision());
}
for (const auto& it : cnn.getOutputsInfo())
{
const std::string& name = it.first;
auto blobIt = allBlobs.find(name);
CV_Assert(blobIt != allBlobs.end());
- it.second->setPrecision(blobIt->second->precision()); // Should be always FP32
+ it.second->setPrecision(blobIt->second->getTensorDesc().getPrecision()); // Should be always FP32
}
initPlugin(cnn);
static InferenceEngine::DataPtr wrapToInfEngineDataNode(const Mat& m, const std::string& name = "")
{
- std::vector<size_t> reversedShape(&m.size[0], &m.size[0] + m.dims);
- std::reverse(reversedShape.begin(), reversedShape.end());
+ std::vector<size_t> shape(&m.size[0], &m.size[0] + m.dims);
if (m.type() == CV_32F)
- return InferenceEngine::DataPtr(
- new InferenceEngine::Data(name, reversedShape, InferenceEngine::Precision::FP32, estimateLayout(m))
- );
+ return InferenceEngine::DataPtr(new InferenceEngine::Data(name,
+ {InferenceEngine::Precision::FP32, shape, estimateLayout(m)}));
else if (m.type() == CV_8U)
- return InferenceEngine::DataPtr(
- new InferenceEngine::Data(name, reversedShape, InferenceEngine::Precision::U8, estimateLayout(m))
- );
+ return InferenceEngine::DataPtr(new InferenceEngine::Data(name,
+ {InferenceEngine::Precision::U8, shape, estimateLayout(m)}));
else
CV_Error(Error::StsNotImplemented, format("Unsupported data type %d", m.type()));
}
InferenceEngine::Layout layout)
{
if (m.type() == CV_32F)
- return InferenceEngine::make_shared_blob<float>(InferenceEngine::Precision::FP32,
- layout, shape, (float*)m.data);
+ return InferenceEngine::make_shared_blob<float>(
+ {InferenceEngine::Precision::FP32, shape, layout}, (float*)m.data);
else if (m.type() == CV_8U)
- return InferenceEngine::make_shared_blob<uint8_t>(InferenceEngine::Precision::U8,
- layout, shape, (uint8_t*)m.data);
+ return InferenceEngine::make_shared_blob<uint8_t>(
+ {InferenceEngine::Precision::U8, shape, layout}, (uint8_t*)m.data);
else
CV_Error(Error::StsNotImplemented, format("Unsupported data type %d", m.type()));
}
InferenceEngine::Blob::Ptr wrapToInfEngineBlob(const Mat& m, InferenceEngine::Layout layout)
{
- std::vector<size_t> reversedShape(&m.size[0], &m.size[0] + m.dims);
- std::reverse(reversedShape.begin(), reversedShape.end());
- return wrapToInfEngineBlob(m, reversedShape, layout);
+ std::vector<size_t> shape(&m.size[0], &m.size[0] + m.dims);
+ return wrapToInfEngineBlob(m, shape, layout);
}
InferenceEngine::Blob::Ptr cloneBlob(const InferenceEngine::Blob::Ptr& blob)
{
- InferenceEngine::Precision precision = blob->precision();
InferenceEngine::Blob::Ptr copy;
+ auto description = blob->getTensorDesc();
+ InferenceEngine::Precision precision = description.getPrecision();
if (precision == InferenceEngine::Precision::FP32)
{
- copy = InferenceEngine::make_shared_blob<float>(precision, blob->layout(), blob->dims());
+ copy = InferenceEngine::make_shared_blob<float>(description);
}
else if (precision == InferenceEngine::Precision::U8)
{
- copy = InferenceEngine::make_shared_blob<uint8_t>(precision, blob->layout(), blob->dims());
+ copy = InferenceEngine::make_shared_blob<uint8_t>(description);
}
else
CV_Error(Error::StsNotImplemented, "Unsupported blob precision");
Ptr<InfEngineBackendWrapper> ieWrapper = wrapper.dynamicCast<InfEngineBackendWrapper>();
CV_Assert(!ieWrapper.empty());
InferenceEngine::DataPtr srcData = ieWrapper->dataPtr;
- dataPtr = InferenceEngine::DataPtr(
- new InferenceEngine::Data(srcData->name, srcData->dims, srcData->precision,
- srcData->layout)
- );
+
+ dataPtr = InferenceEngine::DataPtr(new InferenceEngine::Data(srcData->getName(), srcData->getTensorDesc()));
blob = ieWrapper->blob;
}
}
-static std::map<InferenceEngine::TargetDevice, InferenceEngine::InferenceEnginePluginPtr>& getSharedPlugins()
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
+static std::map<std::string, InferenceEngine::InferenceEnginePluginPtr>& getSharedPlugins()
{
- static std::map<InferenceEngine::TargetDevice, InferenceEngine::InferenceEnginePluginPtr> sharedPlugins;
+ static std::map<std::string, InferenceEngine::InferenceEnginePluginPtr> sharedPlugins;
return sharedPlugins;
}
-
+#else
+static InferenceEngine::Core& getCore()
+{
+ static InferenceEngine::Core core;
+ return core;
+}
+#endif
#if !defined(OPENCV_DNN_IE_VPU_TYPE_DEFAULT)
static bool detectMyriadX_()
InferenceEngine::CNNNetwork cnn = InferenceEngine::CNNNetwork(
InferenceEngine::Builder::convertToICNNNetwork(builder.build()));
- InferenceEngine::TargetDevice device = InferenceEngine::TargetDevice::eMYRIAD;
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
InferenceEngine::InferenceEnginePluginPtr enginePtr;
{
AutoLock lock(getInitializationMutex());
auto& sharedPlugins = getSharedPlugins();
- auto pluginIt = sharedPlugins.find(device);
+ auto pluginIt = sharedPlugins.find("MYRIAD");
if (pluginIt != sharedPlugins.end()) {
enginePtr = pluginIt->second;
} else {
auto dispatcher = InferenceEngine::PluginDispatcher({""});
- enginePtr = dispatcher.getSuitablePlugin(device);
- sharedPlugins[device] = enginePtr;
+ enginePtr = dispatcher.getPluginByDevice("MYRIAD");
+ sharedPlugins["MYRIAD"] = enginePtr;
}
}
auto plugin = InferenceEngine::InferencePlugin(enginePtr);
try
{
auto netExec = plugin.LoadNetwork(cnn, {{"VPU_PLATFORM", "VPU_2480"}});
+#else
+ try
+ {
+ auto netExec = getCore().LoadNetwork(cnn, "MYRIAD", {{"VPU_PLATFORM", "VPU_2480"}});
+#endif
auto infRequest = netExec.CreateInferRequest();
} catch(...) {
return false;
}
#endif // !defined(OPENCV_DNN_IE_VPU_TYPE_DEFAULT)
-void InfEngineBackendNet::initPlugin(InferenceEngine::ICNNNetwork& net)
+void InfEngineBackendNet::initPlugin(InferenceEngine::CNNNetwork& net)
{
CV_Assert(!isInitialized());
try
{
AutoLock lock(getInitializationMutex());
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
auto& sharedPlugins = getSharedPlugins();
- auto pluginIt = sharedPlugins.find(targetDevice);
+ auto pluginIt = sharedPlugins.find(device_name);
if (pluginIt != sharedPlugins.end())
{
enginePtr = pluginIt->second;
}
else
+#endif
{
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
auto dispatcher = InferenceEngine::PluginDispatcher({""});
- if (targetDevice == InferenceEngine::TargetDevice::eFPGA)
+ if (device_name == "FPGA")
enginePtr = dispatcher.getPluginByDevice("HETERO:FPGA,CPU");
else
- enginePtr = dispatcher.getSuitablePlugin(targetDevice);
- sharedPlugins[targetDevice] = enginePtr;
-
+ enginePtr = dispatcher.getPluginByDevice(device_name);
+ sharedPlugins[device_name] = enginePtr;
+#else
+ isInit = true;
+#endif
std::vector<std::string> candidates;
-
std::string param_pluginPath = utils::getConfigurationParameterString("OPENCV_DNN_IE_EXTRA_PLUGIN_PATH", "");
if (!param_pluginPath.empty())
{
candidates.push_back(param_pluginPath);
}
- if (targetDevice == InferenceEngine::TargetDevice::eCPU ||
- targetDevice == InferenceEngine::TargetDevice::eFPGA)
+ if (device_name == "CPU" || device_name == "FPGA")
{
std::string suffixes[] = {"_avx2", "_sse4", ""};
bool haveFeature[] = {
{
InferenceEngine::IExtensionPtr extension =
InferenceEngine::make_so_pointer<InferenceEngine::IExtension>(libName);
+
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
enginePtr->AddExtension(extension, 0);
+#else
+ getCore().AddExtension(extension, "CPU");
+#endif
CV_LOG_INFO(NULL, "DNN-IE: Loaded extension plugin: " << libName);
found = true;
break;
// Some of networks can work without a library of extra layers.
#ifndef _WIN32
// Limit the number of CPU threads.
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
enginePtr->SetConfig({{
InferenceEngine::PluginConfigParams::KEY_CPU_THREADS_NUM, format("%d", getNumThreads()),
}}, 0);
+#else
+ if (device_name == "CPU")
+ getCore().SetConfig({{
+ InferenceEngine::PluginConfigParams::KEY_CPU_THREADS_NUM, format("%d", getNumThreads()),
+ }}, device_name);
+#endif
#endif
}
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
plugin = InferenceEngine::InferencePlugin(enginePtr);
-
netExec = plugin.LoadNetwork(net, {});
+#else
+ netExec = getCore().LoadNetwork(net, device_name);
+#endif
}
catch (const std::exception& ex)
{
bool InfEngineBackendNet::isInitialized()
{
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
return (bool)enginePtr;
+#else
+ return isInit;
+#endif
}
void InfEngineBackendNet::addBlobs(const std::vector<cv::Ptr<BackendWrapper> >& ptrs)
auto wrappers = infEngineWrappers(ptrs);
for (const auto& wrapper : wrappers)
{
- std::string name = wrapper->dataPtr->name;
+ std::string name = wrapper->dataPtr->getName();
name = name.empty() ? kDefaultInpLayerName : name;
allBlobs.insert({name, wrapper->blob});
}
for (int i = 0; i < outs.size(); ++i)
{
outs[i]->futureMat = outProms[i].getArrayResult();
- outsNames[i] = outs[i]->dataPtr->name;
+ outsNames[i] = outs[i]->dataPtr->getName();
}
}
Mat infEngineBlobToMat(const InferenceEngine::Blob::Ptr& blob)
{
// NOTE: Inference Engine sizes are reversed.
- std::vector<size_t> dims = blob->dims();
- std::vector<int> size(dims.rbegin(), dims.rend());
+ std::vector<size_t> dims = blob->getTensorDesc().getDims();
+ std::vector<int> size(dims.begin(), dims.end());
+ auto precision = blob->getTensorDesc().getPrecision();
int type = -1;
- switch (blob->precision())
+ switch (precision)
{
case InferenceEngine::Precision::FP32: type = CV_32F; break;
case InferenceEngine::Precision::U8: type = CV_8U; break;
InferenceEngine::Blob::Ptr convertFp16(const InferenceEngine::Blob::Ptr& blob)
{
- auto halfs = InferenceEngine::make_shared_blob<int16_t>(InferenceEngine::Precision::FP16, blob->layout(), blob->dims());
+ auto halfs = InferenceEngine::make_shared_blob<int16_t>({
+ InferenceEngine::Precision::FP16, blob->getTensorDesc().getDims(),
+ blob->getTensorDesc().getLayout()
+ });
halfs->allocate();
Mat floatsData(1, blob->size(), CV_32F, blob->buffer());
Mat halfsData(1, blob->size(), CV_16SC1, halfs->buffer());
{
#ifdef HAVE_INF_ENGINE
AutoLock lock(getInitializationMutex());
- getSharedPlugins().erase(InferenceEngine::TargetDevice::eMYRIAD);
+#if INF_ENGINE_VER_MAJOR_LE(INF_ENGINE_RELEASE_2019R1)
+ getSharedPlugins().erase("MYRIAD");
+#else
+ getCore().UnregisterPlugin("MYRIAD");
+#endif
#endif // HAVE_INF_ENGINE
}
void forward(const std::vector<Ptr<BackendWrapper> >& outBlobsWrappers,
bool isAsync);
- void initPlugin(InferenceEngine::ICNNNetwork& net);
+ void initPlugin(InferenceEngine::CNNNetwork& net);
void addBlobs(const std::vector<cv::Ptr<BackendWrapper> >& ptrs);
private:
InferenceEngine::Builder::Network netBuilder;
- InferenceEngine::InferenceEnginePluginPtr enginePtr;
- InferenceEngine::InferencePlugin plugin;
InferenceEngine::ExecutableNetwork netExec;
InferenceEngine::BlobMap allBlobs;
- InferenceEngine::TargetDevice targetDevice;
+ std::string device_name;
+#if INF_ENGINE_VER_MAJOR_LE(2019010000)
+ InferenceEngine::InferenceEnginePluginPtr enginePtr;
+ InferenceEngine::InferencePlugin plugin;
+#else
+ bool isInit = false;
+#endif
struct InfEngineReqWrapper
{
static inline void genData(const std::vector<size_t>& dims, Mat& m, Blob::Ptr& dataPtr)
{
- std::vector<int> reversedDims(dims.begin(), dims.end());
- std::reverse(reversedDims.begin(), reversedDims.end());
-
- m.create(reversedDims, CV_32F);
+ m.create(std::vector<int>(dims.begin(), dims.end()), CV_32F);
randu(m, -1, 1);
- dataPtr = make_shared_blob<float>(Precision::FP32, dims, (float*)m.data);
+ dataPtr = make_shared_blob<float>({Precision::FP32, dims, Layout::ANY}, (float*)m.data);
}
void runIE(Target target, const std::string& xmlPath, const std::string& binPath,
CNNNetwork net = reader.getNetwork();
+ std::string device_name;
+
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GT(2019010000)
+ Core ie;
+#else
InferenceEnginePluginPtr enginePtr;
InferencePlugin plugin;
+#endif
ExecutableNetwork netExec;
InferRequest infRequest;
+
try
{
- auto dispatcher = InferenceEngine::PluginDispatcher({""});
switch (target)
{
case DNN_TARGET_CPU:
- enginePtr = dispatcher.getSuitablePlugin(TargetDevice::eCPU);
+ device_name = "CPU";
break;
case DNN_TARGET_OPENCL:
case DNN_TARGET_OPENCL_FP16:
- enginePtr = dispatcher.getSuitablePlugin(TargetDevice::eGPU);
+ device_name = "GPU";
break;
case DNN_TARGET_MYRIAD:
- enginePtr = dispatcher.getSuitablePlugin(TargetDevice::eMYRIAD);
+ device_name = "MYRIAD";
break;
case DNN_TARGET_FPGA:
- enginePtr = dispatcher.getPluginByDevice("HETERO:FPGA,CPU");
+ device_name = "FPGA";
break;
default:
CV_Error(Error::StsNotImplemented, "Unknown target");
};
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2019010000)
+ auto dispatcher = InferenceEngine::PluginDispatcher({""});
+ enginePtr = dispatcher.getPluginByDevice(device_name);
+#endif
if (target == DNN_TARGET_CPU || target == DNN_TARGET_FPGA)
{
std::string suffixes[] = {"_avx2", "_sse4", ""};
try
{
IExtensionPtr extension = make_so_pointer<IExtension>(libName);
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GT(2019010000)
+ ie.AddExtension(extension, device_name);
+#else
enginePtr->AddExtension(extension, 0);
+#endif
break;
}
catch(...) {}
}
// Some of networks can work without a library of extra layers.
}
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GT(2019010000)
+ netExec = ie.LoadNetwork(net, device_name);
+#else
plugin = InferencePlugin(enginePtr);
-
netExec = plugin.LoadNetwork(net, {});
+#endif
infRequest = netExec.CreateInferRequest();
}
catch (const std::exception& ex)
BlobMap inputBlobs;
for (auto& it : net.getInputsInfo())
{
- genData(it.second->getDims(), inputsMap[it.first], inputBlobs[it.first]);
+ genData(it.second->getTensorDesc().getDims(), inputsMap[it.first], inputBlobs[it.first]);
}
infRequest.SetInput(inputBlobs);
BlobMap outputBlobs;
for (auto& it : net.getOutputsInfo())
{
- genData(it.second->dims, outputsMap[it.first], outputBlobs[it.first]);
+ genData(it.second->getTensorDesc().getDims(), outputsMap[it.first], outputBlobs[it.first]);
}
infRequest.SetOutput(outputBlobs);
Values(CV_32F, CV_8U),
testing::ValuesIn(getAvailableTargets(DNN_BACKEND_INFERENCE_ENGINE))
));
+
+typedef testing::TestWithParam<Target> Test_Model_Optimizer;
+TEST_P(Test_Model_Optimizer, forward_two_nets)
+{
+ const int target = GetParam();
+
+ const std::string suffix = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? "_fp16" : "";
+ const std::string& model = findDataFile("dnn/layers/layer_convolution" + suffix + ".bin");
+ const std::string& proto = findDataFile("dnn/layers/layer_convolution" + suffix + ".xml");
+
+ Net net0 = readNet(model, proto);
+ net0.setPreferableTarget(target);
+
+ Net net1 = readNet(model, proto);
+ net1.setPreferableTarget(target);
+
+ // Generate inputs.
+ int blobSize[] = {2, 6, 75, 113};
+ Mat input(4, &blobSize[0], CV_32F);
+ randu(input, 0, 255);
+
+ net0.setInput(input);
+ Mat ref0 = net0.forward().clone();
+
+ net1.setInput(input);
+ Mat ref1 = net1.forward();
+
+ net0.setInput(input);
+ Mat ref2 = net0.forward();
+
+ normAssert(ref0, ref2, 0, 0);
+}
+INSTANTIATE_TEST_CASE_P(/**/, Test_Model_Optimizer,
+ testing::ValuesIn(getAvailableTargets(DNN_BACKEND_INFERENCE_ENGINE))
+);
+
#endif // HAVE_INF_ENGINE
}} // namespace
double r2d(AVRational r) const;
int64_t dts_to_frame_number(int64_t dts);
- double dts_to_sec(int64_t dts);
+ double dts_to_sec(int64_t dts) const;
AVFormatContext * ic;
AVCodec * avcodec;
switch( property_id )
{
case CV_FFMPEG_CAP_PROP_POS_MSEC:
- return 1000.0*(double)frame_number/get_fps();
+ if (picture_pts == AV_NOPTS_VALUE_)
+ {
+ return 0;
+ }
+ return (dts_to_sec(picture_pts) * 1000);
case CV_FFMPEG_CAP_PROP_POS_FRAMES:
return (double)frame_number;
case CV_FFMPEG_CAP_PROP_POS_AVI_RATIO:
return (int64_t)(get_fps() * sec + 0.5);
}
-double CvCapture_FFMPEG::dts_to_sec(int64_t dts)
+double CvCapture_FFMPEG::dts_to_sec(int64_t dts) const
{
return (double)(dts - ic->streams[video_stream]->start_time) *
r2d(ic->streams[video_stream]->time_base);