Merge remote-tracking branch 'upstream/master' into debian-packages
This commit is contained in:
Ilya Lavrenov
@@ -43,7 +43,7 @@ Please report questions, issues and suggestions using:
|
||||
\* Other names and brands may be claimed as the property of others.
|
||||
|
||||
[Open Model Zoo]:https://github.com/openvinotoolkit/open_model_zoo
|
||||
[OpenVINO™ Runtime]:https://docs.openvino.ai/latest/openvino_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html
|
||||
[OpenVINO™ Runtime]:https://docs.openvino.ai/latest/openvino_docs_OV_Runtime_User_Guide.html
|
||||
[Model Optimizer]:https://docs.openvino.ai/latest/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html
|
||||
[Post-Training Optimization Tool]:https://docs.openvino.ai/latest/pot_README.html
|
||||
[tag on StackOverflow]:https://stackoverflow.com/search?q=%23openvino
|
||||
|
||||
@@ -28,12 +28,12 @@ if(COMMAND get_linux_name)
|
||||
endif()
|
||||
|
||||
if(CMAKE_CROSSCOMPILING AND CMAKE_HOST_SYSTEM_NAME MATCHES Linux AND CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
|
||||
set(protoc_version "3.9.2")
|
||||
set(protoc_version "3.18.2")
|
||||
|
||||
RESOLVE_DEPENDENCY(SYSTEM_PROTOC_ROOT
|
||||
ARCHIVE_LIN "protoc-${protoc_version}-linux-x86_64.tar.gz"
|
||||
TARGET_PATH "${TEMP}/protoc-${protoc_version}-linux-x86_64"
|
||||
SHA256 "1d6da1d97d0cbfcd333558afe24533eb3cb48dc1e0ab5e971aa1e50ede8bcf45"
|
||||
SHA256 "42fde2b6044c1f74c7e86d4e03b43aac87128ddf57ac6ed8c4eab7a1e21bbf21"
|
||||
)
|
||||
debug_message(STATUS "host protoc-${protoc_version} root path = " ${SYSTEM_PROTOC_ROOT})
|
||||
|
||||
|
||||
@@ -32,7 +32,7 @@ There are three steps to support inference of a model with custom operation(s):
|
||||
the Model Optimizer can generate the IR with the operation.
|
||||
2. Create an operation set and implement a custom nGraph operation in it as described in the
|
||||
[Custom nGraph Operation](../OV_Runtime_UG/Extensibility_DG/AddingNGraphOps.md).
|
||||
3. Implement a customer operation in one of the [Inference Engine](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md)
|
||||
3. Implement a customer operation in one of the [OpenVINO™ Runtime](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md)
|
||||
plugins to support inference of this operation using a particular target hardware (CPU, GPU or VPU).
|
||||
|
||||
To see the operations that are supported by each device plugin for the Inference Engine, refer to the
|
||||
|
||||
+6
-6
@@ -220,17 +220,17 @@ Typical transformation pipeline described below.
|
||||
### Step 1. Common optimizations
|
||||
This step is optional for LPT but typically is presented in OpenVINO™ plugins. The step doesn't use any LPT transformation. Firstly, the step disables dequantization operations constant folding on constant subgraph on weights to prevent the lost of dequantization info on the next plugin transformations. After that, it optimizes nGraph function and convert operations to operation set 1. Typically, usage of this step is the simplest way to meet LPT requirements for the input quantized model. If plugin can guarantee that LPT input requirements are met, then this step can be skipped.
|
||||
|
||||
@snippet snippets/lpt_mkldnn_plugin.cpp lpt_common
|
||||
@snippet snippets/lpt_intel_cpu_plugin.cpp lpt_common
|
||||
|
||||
### Step 2. Low precision transformations execution
|
||||
This step is mandatory. It configures and runs LPT transformations.
|
||||
|
||||
@snippet snippets/lpt_mkldnn_plugin.cpp lpt_execution
|
||||
@snippet snippets/lpt_intel_cpu_plugin.cpp lpt_execution
|
||||
|
||||
### Step 3. Plugin-specific transformations
|
||||
This step is optional. It modifies the nGraph function to a device-specific operation set.
|
||||
|
||||
@snippet snippets/lpt_mkldnn_plugin.cpp lpt_device
|
||||
@snippet snippets/lpt_intel_cpu_plugin.cpp lpt_device
|
||||
|
||||
## Result model overview
|
||||
|
||||
@@ -298,14 +298,14 @@ Low Precision Transformations can be customizable. Build-in customization option
|
||||
### Operation precision restrictions
|
||||
This option defines precisions which allowed for the operation input ports. The option value is passed as input argument for `LowPrecision` constructor. For example:
|
||||
|
||||
@snippet snippets/lpt_mkldnn_plugin.cpp lpt_supported_precisions
|
||||
@snippet snippets/lpt_intel_cpu_plugin.cpp lpt_supported_precisions
|
||||
|
||||
In provided example in result model `Convolution` operation inputs must have specific precisions: `u8` (unsigned int8) precision on input 0 (on activations) and `i8` (signed int8) precision on input 1 (on weights).
|
||||
|
||||
### Operation per tensor quantization restrictions
|
||||
This option defines if operation supports per-tensor quantization only. The option value is passed as input argument for `LowPrecision` constructor. For example:
|
||||
|
||||
@snippet snippets/lpt_mkldnn_plugin.cpp per_tensor_quantization
|
||||
@snippet snippets/lpt_intel_cpu_plugin.cpp per_tensor_quantization
|
||||
|
||||
In provided example in result model `Convolution` operations must have per-tensor quantization on input 0 (on activations).
|
||||
|
||||
@@ -316,4 +316,4 @@ This option defines if each LPT transformation updates precision or not. The opt
|
||||
|
||||
Plugin specific customization can be implemented via nGraph transformation callbacks. For example: asymmetric quantization support can be easily customizable via `LayerTransformation::isAsymmetricQuantization` and `WeightableLayerTransformation::isAsymmetricOnWeights` methods usage in callbacks. For example:
|
||||
|
||||
@snippet snippets/lpt_mkldnn_plugin.cpp asymmetric_quantization
|
||||
@snippet snippets/lpt_intel_cpu_plugin.cpp asymmetric_quantization
|
||||
|
||||
+1
-1
@@ -44,7 +44,7 @@ The original model key features:
|
||||
|
||||
Transformations are run with the following parameters:
|
||||
|
||||
@snippet snippets/lpt_mkldnn_plugin.cpp lpt_markup_pipeline
|
||||
@snippet snippets/lpt_intel_cpu_plugin.cpp lpt_markup_pipeline
|
||||
|
||||
## 1. MarkupCanBeQuantized
|
||||
The transformation marks operations that cannot be quantized. No attributes are required before the transformation.
|
||||
|
||||
@@ -22,7 +22,7 @@
|
||||
|
||||
Model Optimizer is a cross-platform command-line tool that facilitates the transition between the training and deployment environment, performs static model analysis, and adjusts deep learning models for optimal execution on end-point target devices.
|
||||
|
||||
Model Optimizer process assumes you have a network model trained using supported deep learning frameworks: Caffe*, TensorFlow*, Kaldi*, MXNet* or converted to the ONNX* format. Model Optimizer produces an Intermediate Representation (IR) of the network, which can be inferred with the [Inference Engine](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md).
|
||||
Model Optimizer process assumes you have a network model trained using supported deep learning frameworks: Caffe*, TensorFlow*, Kaldi*, MXNet* or converted to the ONNX* format. Model Optimizer produces an Intermediate Representation (IR) of the network, which can be inferred with the [OpenVINO™ Runtime](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md).
|
||||
|
||||
> **NOTE**: Model Optimizer does not infer models. Model Optimizer is an offline tool that runs before the inference takes place.
|
||||
|
||||
|
||||
@@ -10,8 +10,8 @@ A summary of the steps for optimizing and deploying a model that was trained wit
|
||||
|
||||
1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for Caffe\*.
|
||||
2. [Convert a Caffe\* Model](#Convert_From_Caffe) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases values
|
||||
3. Test the model in the Intermediate Representation format using the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md)
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in your application to deploy the model in the target environment
|
||||
3. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md)
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in your application to deploy the model in the target environment
|
||||
|
||||
## Supported Topologies
|
||||
|
||||
|
||||
@@ -16,8 +16,8 @@ A summary of the steps for optimizing and deploying a model that was trained wit
|
||||
|
||||
1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for Kaldi\*.
|
||||
2. [Convert a Kaldi\* Model](#Convert_From_Kaldi) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases values.
|
||||
3. Test the model in the Intermediate Representation format using the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in your application to deploy the model in the target environment.
|
||||
3. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in your application to deploy the model in the target environment.
|
||||
|
||||
> **NOTE**: The Model Optimizer supports the [nnet1](http://kaldi-asr.org/doc/dnn1.html) and [nnet2](http://kaldi-asr.org/doc/dnn2.html) formats of Kaldi models. Support of the [nnet3](http://kaldi-asr.org/doc/dnn3.html) format is limited.
|
||||
|
||||
|
||||
@@ -17,8 +17,8 @@ A summary of the steps for optimizing and deploying a model that was trained wit
|
||||
|
||||
1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for MXNet* (MXNet was used to train your model)
|
||||
2. [Convert a MXNet model](#ConvertMxNet) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases values
|
||||
3. Test the model in the Intermediate Representation format using the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md)
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in your application to deploy the model in the target environment
|
||||
3. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md)
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in your application to deploy the model in the target environment
|
||||
|
||||
## Supported Topologies
|
||||
|
||||
|
||||
@@ -4,8 +4,8 @@ A summary of the steps for optimizing and deploying a model trained with Paddle\
|
||||
|
||||
1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for Paddle\*.
|
||||
2. [Convert a Paddle\* Model](#Convert_From_Paddle) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases.
|
||||
3. Test the model in the Intermediate Representation format using the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in your application to deploy the model in the target environment.
|
||||
3. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in the target environment via provided Inference Engine [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
4. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in your application to deploy the model in the target environment.
|
||||
|
||||
## Supported Topologies
|
||||
|
||||
|
||||
@@ -48,7 +48,7 @@ PyTorch* framework is supported through export to ONNX\* format. A summary of th
|
||||
1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for ONNX\*.
|
||||
2. [Export PyTorch model to ONNX\*](#export-to-onnx).
|
||||
3. [Convert an ONNX\* model](Convert_Model_From_ONNX.md) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases values.
|
||||
4. Test the model in the Intermediate Representation format using the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in the target environment via provided [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
4. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in the target environment via provided [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
5. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the Inference Engine in your application to deploy the model in the target environment.
|
||||
|
||||
## Export PyTorch\* Model to ONNX\* Format <a name="export-to-onnx"></a>
|
||||
|
||||
@@ -31,7 +31,7 @@ A summary of the steps for optimizing and deploying a model that was trained wit
|
||||
1. [Configure the Model Optimizer](../../Deep_Learning_Model_Optimizer_DevGuide.md) for TensorFlow\* (TensorFlow was used to train your model).
|
||||
2. [Freeze the TensorFlow model](#freeze-the-tensorflow-model) if your model is not already frozen or skip this step and use the [instruction](#loading-nonfrozen-models) to a convert a non-frozen model.
|
||||
3. [Convert a TensorFlow\* model](#Convert_From_TF) to produce an optimized [Intermediate Representation (IR)](../../IR_and_opsets.md) of the model based on the trained network topology, weights, and biases values.
|
||||
4. Test the model in the Intermediate Representation format using the [Inference Engine](../../../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) in the target environment via provided [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
4. Test the model in the Intermediate Representation format using the [OpenVINO™ Runtime](../../../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) in the target environment via provided [sample applications](../../../OV_Runtime_UG/Samples_Overview.md).
|
||||
5. [Integrate](../../../OV_Runtime_UG/Samples_Overview.md) the Inference Engine in your application to deploy the model in the target environment.
|
||||
|
||||
## Supported Topologies
|
||||
|
||||
@@ -72,6 +72,7 @@ git checkout ed60b90
|
||||
pip install pillow
|
||||
```
|
||||
6. Run a converter:
|
||||
> **NOTE**: This converter works with TensorFlow 1.x and numpy 1.19 or lower.
|
||||
- For YOLO-v3:
|
||||
```sh
|
||||
python3 convert_weights_pb.py --class_names coco.names --data_format NHWC --weights_file yolov3.weights
|
||||
|
||||
@@ -1,756 +1,10 @@
|
||||
# Inference Engine API Changes History {#openvino_docs_IE_DG_API_Changes}
|
||||
# OpenVINO™ Runtime API Changes History {#openvino_docs_OV_Runtime_API_Changes}
|
||||
|
||||
The sections below contain detailed list of changes made to the Inference Engine API in recent releases.
|
||||
The sections below contain detailed list of changes made to the OpenVINO™ Runtime API in recent releases.
|
||||
|
||||
## 2021.4
|
||||
## 2022.1
|
||||
|
||||
### New API
|
||||
|
||||
* InferenceEngine::Core::LoadNetwork(modelPath, deviceName, config) simplified API to read and load network in one call
|
||||
* The OpenVINO™ 2.0 API was introduced.
|
||||
|
||||
### Deprecated API
|
||||
|
||||
**InferenceEngine::Parameter**
|
||||
|
||||
* InferenceEngine::Parameter(const std::shared_ptr<ngraph::Variant>&)
|
||||
* InferenceEngine::Parameter(std::shared_ptr<ngraph::Variant>& var)
|
||||
* std::shared_ptr<ngraph::Variant> InferenceEngine::Parameter::asVariant() const
|
||||
* InferenceEngine::Parameter::operator std::shared_ptr<ngraph::Variant>() const
|
||||
|
||||
**GPU plugin configuration keys**
|
||||
* KEY_CLDNN_NV12_TWO_INPUTS GPU plugin option. Use KEY_GPU_NV12_TWO_INPUTS instead
|
||||
* KEY_CLDNN_PLUGIN_PRIORITY GPU plugin option. Use KEY_GPU_PLUGIN_PRIORITY instead
|
||||
* KEY_CLDNN_PLUGIN_THROTTLE GPU plugin option. Use KEY_GPU_PLUGIN_THROTTLE instead
|
||||
* KEY_CLDNN_MEM_POOL GPU plugin option
|
||||
* KEY_CLDNN_GRAPH_DUMPS_DIR GPU plugin option
|
||||
* KEY_CLDNN_SOURCES_DUMPS_DIR GPU plugin option
|
||||
* KEY_DUMP_KERNELS GPU plugin option
|
||||
* KEY_TUNING_MODE GPU plugin option
|
||||
* KEY_TUNING_FILE GPU plugin option
|
||||
|
||||
**InferenceEngine::IInferRequest**
|
||||
* IInferRequest interface is deprecated, use InferRequest wrapper:
|
||||
* Constructor for InferRequest from IInferRequest:: Ptr is deprecated
|
||||
* Cast operator for InferRequest to IInferRequest shared pointer is deprecated
|
||||
|
||||
**InferenceEngine::ICNNNetwork**
|
||||
* ICNNNetwork interface is deprecated by means of deprecation of all its methods, use CNNNetwork wrapper
|
||||
* CNNNetwork methods working with ICNNNetwork are deprecated:
|
||||
* Cast to ICNNNetwork shared pointer
|
||||
* Cast to reference to ICNNNetwork interface
|
||||
* Constructor from ICNNNetwork shared pointer
|
||||
|
||||
**InferenceEngine::IExecutableNetwork**
|
||||
* IExecutableNetwork is deprecated, use ExecutableNetwork wrappers:
|
||||
* Constructor of ExecutableNetwork from IExecutableNetwork shared pointer is deprecated
|
||||
* The following ExecutableNetwork methods are deprecated:
|
||||
* ExecutableNetwork::reset
|
||||
* Cast operator to IExecutableNetwork shared pointer
|
||||
* ExecutableNetwork::CreateInferRequestPtr - use ExecutableNetwork::CreateInferRequest instead
|
||||
|
||||
**Extensions API**
|
||||
* InferenceEngine::make_so_pointer which is used to create Extensions library is replaced by std::make_shared<Extension>(..)
|
||||
* InferenceEngine::IExtension::Release is deprecated with no replacement
|
||||
* Use IE_DEFINE_EXTENSION_CREATE_FUNCTION helper macro instead of explicit declaration of CreateExtension function, which create extension.
|
||||
|
||||
**Other changes**
|
||||
* Version::ApiVersion structure is deprecated, Inference Engine does not have API version anymore
|
||||
* LowLatency - use lowLatency2 instead
|
||||
* CONFIG_KEY(DUMP_EXEC_GRAPH_AS_DOT) - use InferenceEngine::ExecutableNetwork::GetExecGraphInfo::serialize() instead
|
||||
* Core::ImportNetwork with no device - pass device name explicitly.
|
||||
* details::InferenceEngineException - use InferenceEngine::Exception and its derivatives instead.
|
||||
|
||||
## 2021.3
|
||||
|
||||
### New API
|
||||
|
||||
* InferenceEngine::InferRequest::Cancel to cancel inference request execution
|
||||
* InferenceEngine::Layout::HWC to support HWC layout for input or output blobs
|
||||
* InferenceEngine::Precision::F64 data precision for f64 data type
|
||||
* InferenceEngine::CNNNetwork::getOVNameForTensor to map frameworks tensor names to OpenVINO internal tensor names
|
||||
|
||||
### Deprecated API
|
||||
|
||||
* InferenceEngine::IVariableState interface is deprecated, use InferenceEngine::VariableState wrapper
|
||||
|
||||
## 2021.2
|
||||
|
||||
### New API
|
||||
|
||||
**State API**
|
||||
|
||||
* InferenceEngine::InferRequest::QueryState query state value of network on current infer request
|
||||
* InferenceEngine::IVariableState class instead of IMemoryState (rename)
|
||||
* InferenceEngine::IVariableState::GetState instead of IMemoryState::GetLastState (rename)
|
||||
|
||||
**BatchedBlob** - represents a InferenceEngine::BatchedBlob containing other blobs - one per batch.
|
||||
|
||||
**Transformations API** - added a new header `ie_transformations.hpp` which contains transformations for InferenceEngine::CNNNetwork object. Such transformations can be called prior to loading network for compilation for particular device:
|
||||
|
||||
* InferenceEngine::LowLatency
|
||||
|
||||
### Deprecated API
|
||||
|
||||
**State API**
|
||||
|
||||
* InferenceEngine::ExecutableNetwork::QueryState - use InferenceEngine::InferRequest::QueryState
|
||||
* InferenceEngine::IVariableState::GetLastState - use InferenceEngine::IVariableState::GetState
|
||||
|
||||
## 2021.1
|
||||
|
||||
### Deprecated API
|
||||
|
||||
**Utility functions to convert Unicode paths**
|
||||
|
||||
* InferenceEngine::stringToFileName - use OS-specific native conversion functions
|
||||
* InferenceEngine::fileNameToString - use OS-specific native conversion functions
|
||||
|
||||
### Removed API
|
||||
|
||||
**Plugin API:**
|
||||
|
||||
* InferenceEngine::InferencePlugin C++ plugin wrapper class
|
||||
* InferenceEngine::IInferencePlugin plugin interface
|
||||
* InferenceEngine::PluginDispatcher class
|
||||
* InferenceEngine::InferenceEnginePluginPtr typedef
|
||||
* InferenceEngine::ICNNNetReader reader interface
|
||||
* InferenceEngine::CNNNetReader class
|
||||
|
||||
**Extensibility API:**
|
||||
|
||||
* InferenceEngine::ILayerImplFactory class
|
||||
* InferenceEngine::IShapeInferImpl class
|
||||
* InferenceEngine::IShapeInferExtension class
|
||||
* InferenceEngine::IExtension::getFactoryFor(ILayerImplFactory\*& factory, const CNNLayer\* cnnLayer, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::IExtension::getPrimitiveTypes(char\*\*& types, unsigned int& size, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::ShapeInferImpl class
|
||||
* InferenceEngine::Extension::getFactoryFor(ILayerImplFactory\*& factory, const CNNLayer\* cnnLayer, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::Extension::getPrimitiveTypes(char\*\*& types, unsigned int& size, ResponseDesc\* resp) noexcept method
|
||||
|
||||
**Network API:**
|
||||
|
||||
* InferenceEngine::details::CNNNetworkIterator class
|
||||
* InferenceEngine::CNNNetwork::getPrecision() const method
|
||||
* InferenceEngine::CNNNetwork::getLayerByName(const char\* layerName) const method
|
||||
* InferenceEngine::CNNNetwork::size() const method
|
||||
* InferenceEngine::CNNNetwork::begin() const method
|
||||
* InferenceEngine::CNNNetwork::end() const method
|
||||
* InferenceEngine::CNNNetwork::AddExtension(const IShapeInferExtensionPtr& extension) method
|
||||
* InferenceEngine::ICNNNetwork::getPrecision() const noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getName(char\* pName, size_t len) const noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getData(const char\* dname) noexcept method
|
||||
* InferenceEngine::ICNNNetwork::addLayer(const CNNLayerPtr& layer) noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getLayerByName(const char\* layerName, CNNLayerPtr& out, ResponseDesc\* resp) const noexcept method
|
||||
* InferenceEngine::ICNNNetwork::AddExtension(const IShapeInferExtensionPtr& extension, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getStats(ICNNNetworkStats\*\* stats, ResponseDesc\* resp) const noexcept method
|
||||
* InferenceEngine::ICNNNetworkStats class
|
||||
* InferenceEngine::NetworkNodeStats class
|
||||
* InferenceEngine::Data::getCreatorLayer() method
|
||||
* InferenceEngine::Data::getInputTo() method
|
||||
* InferenceEngine::LayerParams class
|
||||
|
||||
**Layer API:**
|
||||
|
||||
* InferenceEngine::CNNLayer class
|
||||
* InferenceEngine::WeightableLayer class
|
||||
* InferenceEngine::BatchNormalizationLayer class
|
||||
* InferenceEngine::BatchToSpaceLayer class
|
||||
* InferenceEngine::BinaryConvolutionLayer class
|
||||
* InferenceEngine::BroadcastLayer class
|
||||
* InferenceEngine::BucketizeLayer class
|
||||
* InferenceEngine::ClampLayer class
|
||||
* InferenceEngine::ConcatLayer class
|
||||
* InferenceEngine::ConvolutionLayer class
|
||||
* InferenceEngine::CropLayer class
|
||||
* InferenceEngine::DeconvolutionLayer class
|
||||
* InferenceEngine::DeformableConvolutionLayer class
|
||||
* InferenceEngine::DepthToSpaceLayer class
|
||||
* InferenceEngine::EltwiseLayer class
|
||||
* InferenceEngine::ExperimentalDetectronPriorGridGenerator class
|
||||
* InferenceEngine::ExperimentalDetectronPriorGridGeneratorLayer class
|
||||
* InferenceEngine::ExperimentalSparseWeightedReduceLayer class
|
||||
* InferenceEngine::FillLayer class
|
||||
* InferenceEngine::FullyConnectedLayer class
|
||||
* InferenceEngine::GRNLayer class
|
||||
* InferenceEngine::GRUCell class
|
||||
* InferenceEngine::GatherLayer class
|
||||
* InferenceEngine::GemmLayer class
|
||||
* InferenceEngine::LSTMCell class
|
||||
* InferenceEngine::MVNLayer class
|
||||
* InferenceEngine::MathLayer class
|
||||
* InferenceEngine::NonMaxSuppression class
|
||||
* InferenceEngine::NormLayer class
|
||||
* InferenceEngine::OneHotLayer class
|
||||
* InferenceEngine::PReLULayer class
|
||||
* InferenceEngine::PadLayer class
|
||||
* InferenceEngine::PoolingLayer class
|
||||
* InferenceEngine::PowerLayer class
|
||||
* InferenceEngine::QuantizeLayer class
|
||||
* InferenceEngine::RNNCell class
|
||||
* InferenceEngine::RNNCellBase class
|
||||
* InferenceEngine::RNNSequenceLayer class
|
||||
* InferenceEngine::RangeLayer class
|
||||
* InferenceEngine::ReLU6Layer class
|
||||
* InferenceEngine::ReLULayer class
|
||||
* InferenceEngine::ReduceLayer class
|
||||
* InferenceEngine::ReshapeLayer class
|
||||
* InferenceEngine::ReverseSequenceLayer class
|
||||
* InferenceEngine::ScaleShiftLayer class
|
||||
* InferenceEngine::ScatterLayer class
|
||||
* InferenceEngine::SelectLayer class
|
||||
* InferenceEngine::ShuffleChannelsLayer class
|
||||
* InferenceEngine::SoftMaxLayer class
|
||||
* InferenceEngine::SpaceToBatchLayer class
|
||||
* InferenceEngine::SpaceToDepthLayer class
|
||||
* InferenceEngine::SparseFillEmptyRowsLayer class
|
||||
* InferenceEngine::SparseSegmentReduceLayer class
|
||||
* InferenceEngine::SparseToDenseLayer class
|
||||
* InferenceEngine::SplitLayer class
|
||||
* InferenceEngine::StridedSliceLayer class
|
||||
* InferenceEngine::TensorIterator class
|
||||
* InferenceEngine::TileLayer class
|
||||
* InferenceEngine::TopKLayer class
|
||||
* InferenceEngine::UniqueLayer class
|
||||
|
||||
## 2020.4
|
||||
|
||||
### New API
|
||||
|
||||
**CPU Plugin API:**
|
||||
|
||||
* InferenceEngine::PluginConfigParams::KEY_ENFORCE_BF16 config key
|
||||
|
||||
**Metrics and values for Query API:**
|
||||
|
||||
* METRIC_KEY(OPTIMIZATION_CAPABILITIES)
|
||||
* METRIC_VALUE(BF16)
|
||||
|
||||
### Deprecated API
|
||||
|
||||
**MYRIAD Plugin API:**
|
||||
|
||||
* VPU_CONFIG_KEY(IGNORE_IR_STATISTIC)
|
||||
|
||||
### Removed API
|
||||
|
||||
**Inference Engine NN Builder API:**
|
||||
|
||||
* InferenceEngine::Builder::EltwiseLayer
|
||||
* InferenceEngine::Builder::MemoryLayer
|
||||
* InferenceEngine::Builder::ROIPoolingLayer
|
||||
* InferenceEngine::Builder::DeconvolutionLayer
|
||||
* InferenceEngine::Builder::ReLULayer
|
||||
* InferenceEngine::Builder::TanHLayer
|
||||
* InferenceEngine::Builder::InputLayer
|
||||
* InferenceEngine::Builder::PoolingLayer
|
||||
* InferenceEngine::Builder::CropLayer
|
||||
* InferenceEngine::Builder::GRUSequenceLayer
|
||||
* InferenceEngine::Builder::NormLayer
|
||||
* InferenceEngine::Builder::LSTMSequenceLayer
|
||||
* InferenceEngine::Builder::ClampLayer
|
||||
* InferenceEngine::Builder::PSROIPoolingLayer
|
||||
* InferenceEngine::Builder::Layer
|
||||
* InferenceEngine::Builder::RNNSequenceLayer
|
||||
* InferenceEngine::Builder::ReorgYoloLayer
|
||||
* InferenceEngine::Builder::NormalizeLayer
|
||||
* InferenceEngine::Builder::PriorBoxClusteredLayer
|
||||
* InferenceEngine::Builder::MVNLayer
|
||||
* InferenceEngine::Builder::PermuteLayer
|
||||
* InferenceEngine::Builder::SimplerNMSLayer
|
||||
* InferenceEngine::Builder::ConstLayer
|
||||
* InferenceEngine::Builder::DeformableConvolutionLayer
|
||||
* InferenceEngine::Builder::FullyConnectedLayer
|
||||
* InferenceEngine::Builder::PriorBoxLayer
|
||||
* InferenceEngine::Builder::SoftMaxLayer
|
||||
* InferenceEngine::Builder::OutputLayer
|
||||
* InferenceEngine::Builder::TileLayer
|
||||
* InferenceEngine::Builder::SplitLayer
|
||||
* InferenceEngine::Builder::PReLULayer
|
||||
* InferenceEngine::Builder::RegionYoloLayer
|
||||
* InferenceEngine::Builder::ReshapeLayer
|
||||
* InferenceEngine::Builder::ConvolutionLayer
|
||||
* InferenceEngine::Builder::DetectionOutputLayer
|
||||
* InferenceEngine::Builder::ConcatLayer
|
||||
* InferenceEngine::Builder::ELULayer
|
||||
* InferenceEngine::Builder::GRNLayer
|
||||
* InferenceEngine::Builder::LRNLayer
|
||||
* InferenceEngine::Builder::ArgMaxLayer
|
||||
* InferenceEngine::Builder::ReLU6Layer
|
||||
* InferenceEngine::Builder::ScaleShiftLayer
|
||||
* InferenceEngine::Builder::ProposalLayer
|
||||
* InferenceEngine::Builder::SigmoidLayer
|
||||
* InferenceEngine::Builder::ResampleLayer
|
||||
* InferenceEngine::Builder::CTCGreedyDecoderLayer
|
||||
* InferenceEngine::Builder::BatchNormalizationLayer
|
||||
* InferenceEngine::Builder::LayerDecorator
|
||||
* InferenceEngine::Builder::PowerLayer
|
||||
* InferenceEngine::Builder::Network
|
||||
* InferenceEngine::Builder::PortInfo
|
||||
* InferenceEngine::Builder::Connection
|
||||
* InferenceEngine::Builder::PortData
|
||||
* InferenceEngine::Builder::Port
|
||||
* InferenceEngine::Builder::ILayer
|
||||
* InferenceEngine::Builder::INetworkIterator
|
||||
* InferenceEngine::Builder::INetwork
|
||||
* InferenceEngine::Builder::ILayer
|
||||
|
||||
## 2020.2
|
||||
|
||||
### New API
|
||||
|
||||
**Extensibility API:**
|
||||
|
||||
* InferenceEngine::IExtension::getImplTypes(const std::shared_ptr<ngraph::Node>& node) method
|
||||
* InferenceEngine::IExtension::getImplementation(const std::shared_ptr<ngraph::Node>& node, const std::string& implType) method
|
||||
|
||||
### Deprecated API
|
||||
|
||||
**Extensibility API:**
|
||||
|
||||
* InferenceEngine::ILayerImplFactory class
|
||||
* InferenceEngine::IShapeInferImpl class
|
||||
* InferenceEngine::IShapeInferImpl class
|
||||
* InferenceEngine::IShapeInferExtension class
|
||||
* InferenceEngine::IExtension::getFactoryFor(ILayerImplFactory\*& factory, const CNNLayer\* cnnLayer, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::IExtension::getPrimitiveTypes(char\*\*& types, unsigned int& size, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::ShapeInferImpl class
|
||||
* InferenceEngine::Extension::getFactoryFor(ILayerImplFactory\*& factory, const CNNLayer\* cnnLayer, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::Extension::getPrimitiveTypes(char\*\*& types, unsigned int& size, ResponseDesc\* resp) noexcept method
|
||||
|
||||
**Network API:**
|
||||
|
||||
* InferenceEngine::details::CNNNetworkIterator class
|
||||
* InferenceEngine::CNNNetwork::getPrecision() const method
|
||||
* InferenceEngine::CNNNetwork::getLayerByName(const char\* layerName) const method
|
||||
* InferenceEngine::CNNNetwork::size() const method
|
||||
* InferenceEngine::CNNNetwork::begin() const method
|
||||
* InferenceEngine::CNNNetwork::end() const method
|
||||
* InferenceEngine::CNNNetwork::AddExtension(const IShapeInferExtensionPtr& extension) method
|
||||
* InferenceEngine::ICNNNetwork::getPrecision() const noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getName(char\* pName, size_t len) const noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getData(const char\* dname) noexcept method
|
||||
* InferenceEngine::ICNNNetwork::addLayer(const CNNLayerPtr& layer) noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getLayerByName(const char\* layerName, CNNLayerPtr& out, ResponseDesc\* resp) const noexcept method
|
||||
* InferenceEngine::ICNNNetwork::AddExtension(const IShapeInferExtensionPtr& extension, ResponseDesc\* resp) noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getStats(ICNNNetworkStats\*\* stats, ResponseDesc\* resp) const noexcept method
|
||||
* InferenceEngine::ICNNNetworkStats class
|
||||
* InferenceEngine::NetworkNodeStats class
|
||||
* InferenceEngine::Data::getCreatorLayer() method
|
||||
* InferenceEngine::Data::getInputTo() method
|
||||
* InferenceEngine::LayerParams class
|
||||
|
||||
**Layer API:**
|
||||
|
||||
* InferenceEngine::CNNLayer class
|
||||
* InferenceEngine::WeightableLayer class
|
||||
* InferenceEngine::BatchNormalizationLayer class
|
||||
* InferenceEngine::BatchToSpaceLayer class
|
||||
* InferenceEngine::BinaryConvolutionLayer class
|
||||
* InferenceEngine::BroadcastLayer class
|
||||
* InferenceEngine::BucketizeLayer class
|
||||
* InferenceEngine::ClampLayer class
|
||||
* InferenceEngine::ConcatLayer class
|
||||
* InferenceEngine::ConvolutionLayer class
|
||||
* InferenceEngine::CropLayer class
|
||||
* InferenceEngine::DeconvolutionLayer class
|
||||
* InferenceEngine::DeformableConvolutionLayer class
|
||||
* InferenceEngine::DepthToSpaceLayer class
|
||||
* InferenceEngine::EltwiseLayer class
|
||||
* InferenceEngine::ExperimentalDetectronPriorGridGenerator class
|
||||
* InferenceEngine::ExperimentalDetectronPriorGridGeneratorLayer class
|
||||
* InferenceEngine::ExperimentalSparseWeightedReduceLayer class
|
||||
* InferenceEngine::FillLayer class
|
||||
* InferenceEngine::FullyConnectedLayer class
|
||||
* InferenceEngine::GRNLayer class
|
||||
* InferenceEngine::GRUCell class
|
||||
* InferenceEngine::GatherLayer class
|
||||
* InferenceEngine::GemmLayer class
|
||||
* InferenceEngine::LSTMCell class
|
||||
* InferenceEngine::MVNLayer class
|
||||
* InferenceEngine::MathLayer class
|
||||
* InferenceEngine::NonMaxSuppression class
|
||||
* InferenceEngine::NormLayer class
|
||||
* InferenceEngine::OneHotLayer class
|
||||
* InferenceEngine::PReLULayer class
|
||||
* InferenceEngine::PadLayer class
|
||||
* InferenceEngine::PoolingLayer class
|
||||
* InferenceEngine::PowerLayer class
|
||||
* InferenceEngine::QuantizeLayer class
|
||||
* InferenceEngine::RNNCell class
|
||||
* InferenceEngine::RNNCellBase class
|
||||
* InferenceEngine::RNNSequenceLayer class
|
||||
* InferenceEngine::RangeLayer class
|
||||
* InferenceEngine::ReLU6Layer class
|
||||
* InferenceEngine::ReLULayer class
|
||||
* InferenceEngine::ReduceLayer class
|
||||
* InferenceEngine::ReshapeLayer class
|
||||
* InferenceEngine::ReverseSequenceLayer class
|
||||
* InferenceEngine::ScaleShiftLayer class
|
||||
* InferenceEngine::ScatterLayer class
|
||||
* InferenceEngine::SelectLayer class
|
||||
* InferenceEngine::ShuffleChannelsLayer class
|
||||
* InferenceEngine::SoftMaxLayer class
|
||||
* InferenceEngine::SpaceToBatchLayer class
|
||||
* InferenceEngine::SpaceToDepthLayer class
|
||||
* InferenceEngine::SparseFillEmptyRowsLayer class
|
||||
* InferenceEngine::SparseSegmentReduceLayer class
|
||||
* InferenceEngine::SparseToDenseLayer class
|
||||
* InferenceEngine::SplitLayer class
|
||||
* InferenceEngine::StridedSliceLayer class
|
||||
* InferenceEngine::TensorIterator class
|
||||
* InferenceEngine::TileLayer class
|
||||
* InferenceEngine::TopKLayer class
|
||||
* InferenceEngine::UniqueLayer class
|
||||
|
||||
## 2020.1
|
||||
|
||||
### New API
|
||||
|
||||
**Integration with ngraph API:**
|
||||
|
||||
* InferenceEngine::CNNNetwork(const std::shared_ptr<ngraph::Function>& network) ctor from ngraph::Function
|
||||
* InferenceEngine::CNNNetwork::getFunction() const noexcept method
|
||||
* InferenceEngine::ICNNNetwork::getFunction() const noexcept method
|
||||
* InferenceEngine::Parameter(const std::shared_ptr<ngraph::Variant>& var) ctor
|
||||
* InferenceEngine::Parameter::asVariant() const method
|
||||
* InferenceEngine::Parameter::operator std::shared_ptr<ngraph::Variant>() const operator
|
||||
* InferenceEngine::Core::ReadNetwork(const std::wstring& modelPath, const std::wstring& binPath) method
|
||||
* InferenceEngine::Core::ReadNetwork(const std::string& modelPath, const std::string& binPath = "") method
|
||||
* InferenceEngine::Core::ReadNetwork(const std::string& model, const Blob::CPtr& weights) method
|
||||
* InferenceEngine::Code::AddExtension(const IExtensionPtr& extension) method
|
||||
* InferenceEngine::IExtension::getOpSets() method
|
||||
|
||||
|
||||
**Offline compilation: import / export to std::stream:**
|
||||
|
||||
* InferenceEngine::ExecutableNetwork::Export(std::ostream& networkModel) method
|
||||
* InferenceEngine::Core::ImportNetwork(std::istream& networkModel, const std::string& deviceName = {}, const std::map<std::string, std::string>& config = {}) method
|
||||
* InferenceEngine::IExecutableNetwork::Export(std::ostream& networkModel, ResponseDesc \*resp) noexcept method
|
||||
|
||||
|
||||
**RemoteBlob accelerator memory sharing API:**
|
||||
|
||||
* InferenceEngine::RemoteContext class
|
||||
* InferenceEngine::RemoteBlob class
|
||||
* InferenceEngine::Core::CreateContext(const std::string& deviceName, const ParamMap& params) method
|
||||
* InferenceEngine::Core::GetDefaultContext(const std::string& deviceName) method
|
||||
* InferenceEngine::Core::LoadNetwork(CNNNetwork network, RemoteContext::Ptr context, const std::map<std::string, std::string>& config = std::map<std::string, std::string>()) method
|
||||
|
||||
|
||||
**GNA firmware model image generation:**
|
||||
|
||||
* GNA_CONFIG_KEY(FIRMWARE_MODEL_IMAGE_GENERATION) config key
|
||||
* GNA_CONFIG_VALUE(GEN) value
|
||||
* GNA_CONFIG_VALUE(GEN_EXACT) value
|
||||
* GNA_CONFIG_VALUE(SSE) value
|
||||
* GNA_CONFIG_VALUE(SSE_EXACT) value
|
||||
* GNA_CONFIG_VALUE(AVX1) value
|
||||
* GNA_CONFIG_VALUE(AVX1_EXACT) value
|
||||
* GNA_CONFIG_VALUE(AVX2) value
|
||||
* GNA_CONFIG_VALUE(AVX2_EXACT) value
|
||||
|
||||
**MemoryBlob mapping of memory to the user space:**
|
||||
|
||||
* InferenceEngine::MemoryBlob::rwmap() noexcept method
|
||||
* InferenceEngine::MemoryBlob::rmap() noexcept method
|
||||
* InferenceEngine::MemoryBlob::wmap() noexcept method
|
||||
|
||||
**Memory interoperability on acceleration devices. General classes and GPU helper functions**
|
||||
* InferenceEngine::RemoteBlob class
|
||||
* InferenceEngine::RemoteContext class
|
||||
* InferenceEngine::Core::CreateContext(const std::string& deviceName, const ParamMap& params) method
|
||||
* InferenceEngine::Core::GetDefaultContext(const std::string& deviceName) method
|
||||
* InferenceEngine::make_shared_blob(const TensorDesc& desc, RemoteContext::Ptr ctx) function
|
||||
* InferenceEngine::gpu::make_shared_blob_nv12(size_t height, size_t width, RemoteContext::Ptr ctx, VASurfaceID nv12_surf) function
|
||||
* InferenceEngine::gpu::make_shared_context(Core& core, std::string deviceName, VADisplay device) function
|
||||
* InferenceEngine::gpu::make_shared_blob(const TensorDesc& desc, RemoteContext::Ptr ctx, VASurfaceID surface, uint32_t plane = 0) function
|
||||
* InferenceEngine::gpu::make_shared_blob_nv12(RemoteContext::Ptr ctx, cl::Image2D& nv12_image_plane_y, cl::Image2D& nv12_image_plane_uv) function
|
||||
* InferenceEngine::gpu::make_shared_context(Core& core, std::string deviceName, cl_context ctx) function
|
||||
* InferenceEngine::gpu::make_shared_blob(const TensorDesc& desc, ClContext::Ptr ctx) function
|
||||
* InferenceEngine::gpu::make_shared_blob(const TensorDesc& desc, RemoteContext::Ptr ctx, cl::Buffer& buffer) function
|
||||
* InferenceEngine::gpu::make_shared_blob(const TensorDesc& desc, RemoteContext::Ptr ctx, cl_mem buffer) function
|
||||
* InferenceEngine::gpu::make_shared_blob(const TensorDesc& desc, RemoteContext::Ptr ctx, cl::Image2D& image) function
|
||||
|
||||
### Deprecated API
|
||||
|
||||
**Inference Engine NN Builder API:**
|
||||
|
||||
* InferenceEngine::Builder::EltwiseLayer
|
||||
* InferenceEngine::Builder::MemoryLayer
|
||||
* InferenceEngine::Builder::ROIPoolingLayer
|
||||
* InferenceEngine::Builder::DeconvolutionLayer
|
||||
* InferenceEngine::Builder::ReLULayer
|
||||
* InferenceEngine::Builder::TanHLayer
|
||||
* InferenceEngine::Builder::InputLayer
|
||||
* InferenceEngine::Builder::PoolingLayer
|
||||
* InferenceEngine::Builder::CropLayer
|
||||
* InferenceEngine::Builder::GRUSequenceLayer
|
||||
* InferenceEngine::Builder::NormLayer
|
||||
* InferenceEngine::Builder::LSTMSequenceLayer
|
||||
* InferenceEngine::Builder::ClampLayer
|
||||
* InferenceEngine::Builder::PSROIPoolingLayer
|
||||
* InferenceEngine::Builder::Layer
|
||||
* InferenceEngine::Builder::RNNSequenceLayer
|
||||
* InferenceEngine::Builder::ReorgYoloLayer
|
||||
* InferenceEngine::Builder::NormalizeLayer
|
||||
* InferenceEngine::Builder::PriorBoxClusteredLayer
|
||||
* InferenceEngine::Builder::MVNLayer
|
||||
* InferenceEngine::Builder::PermuteLayer
|
||||
* InferenceEngine::Builder::SimplerNMSLayer
|
||||
* InferenceEngine::Builder::ConstLayer
|
||||
* InferenceEngine::Builder::DeformableConvolutionLayer
|
||||
* InferenceEngine::Builder::FullyConnectedLayer
|
||||
* InferenceEngine::Builder::PriorBoxLayer
|
||||
* InferenceEngine::Builder::SoftMaxLayer
|
||||
* InferenceEngine::Builder::OutputLayer
|
||||
* InferenceEngine::Builder::TileLayer
|
||||
* InferenceEngine::Builder::SplitLayer
|
||||
* InferenceEngine::Builder::PReLULayer
|
||||
* InferenceEngine::Builder::RegionYoloLayer
|
||||
* InferenceEngine::Builder::ReshapeLayer
|
||||
* InferenceEngine::Builder::ConvolutionLayer
|
||||
* InferenceEngine::Builder::DetectionOutputLayer
|
||||
* InferenceEngine::Builder::ConcatLayer
|
||||
* InferenceEngine::Builder::ELULayer
|
||||
* InferenceEngine::Builder::GRNLayer
|
||||
* InferenceEngine::Builder::LRNLayer
|
||||
* InferenceEngine::Builder::ArgMaxLayer
|
||||
* InferenceEngine::Builder::ReLU6Layer
|
||||
* InferenceEngine::Builder::ScaleShiftLayer
|
||||
* InferenceEngine::Builder::ProposalLayer
|
||||
* InferenceEngine::Builder::SigmoidLayer
|
||||
* InferenceEngine::Builder::ResampleLayer
|
||||
* InferenceEngine::Builder::CTCGreedyDecoderLayer
|
||||
* InferenceEngine::Builder::BatchNormalizationLayer
|
||||
* InferenceEngine::Builder::LayerDecorator
|
||||
* InferenceEngine::Builder::PowerLayer
|
||||
* InferenceEngine::Builder::Network
|
||||
* InferenceEngine::Builder::PortInfo
|
||||
* InferenceEngine::Builder::Connection
|
||||
* InferenceEngine::Builder::PortData
|
||||
* InferenceEngine::Builder::Port
|
||||
* InferenceEngine::Builder::ILayer
|
||||
* InferenceEngine::Builder::INetworkIterator
|
||||
* InferenceEngine::Builder::INetwork
|
||||
* InferenceEngine::Builder::ILayer
|
||||
|
||||
**Plugin API:**
|
||||
|
||||
* InferenceEngine::InferencePlugin C++ plugin wrapper class
|
||||
* InferenceEngine::IInferencePlugin plugin interface
|
||||
* InferenceEngine::PluginDispatcher class
|
||||
* InferenceEngine::InferenceEnginePluginPtr typedef
|
||||
* InferenceEngine::ICNNNetReader reader interface
|
||||
* InferenceEngine::CNNNetReader class
|
||||
|
||||
**Blob API:**
|
||||
|
||||
* Blob::element_size() const noexcept method
|
||||
* Blob::buffer() noexcept method
|
||||
* Blob::cbuffer() noexcept method
|
||||
* MemoryBlob::buffer() noexcept method
|
||||
* MemoryBlob::cbuffer() noexcept method
|
||||
|
||||
|
||||
### Removed API
|
||||
|
||||
Removed all [Inference Engine API which deprecated in 2019'R2](https://docs.openvino.ai/2019_R3/_docs_IE_DG_API_Changes.html#deprecated_api)
|
||||
|
||||
## 2019 R3
|
||||
|
||||
### New API
|
||||
|
||||
**New supported layers:**
|
||||
|
||||
* InferenceEngine::SparseFillEmptyRowsLayer new class
|
||||
* InferenceEngine::UniqueLayer new class
|
||||
* InferenceEngine::NonMaxSuppressionLayer new class
|
||||
* InferenceEngine::ScatterLayer new class
|
||||
|
||||
**FPGA plugin streaming support:**
|
||||
|
||||
* DLIA_METRIC_VALUE(INPUT_STREAMING) value to METRIC_KEY(OPTIMIZATION_CAPABILITIES)
|
||||
* DLIA_CONFIG_KEY(ENABLE_STREAMING) config key
|
||||
|
||||
### Removed API
|
||||
|
||||
* InferenceEngine::EltwiseLayer::Select from InferenceEngine::EltwiseLayer::eOperation enumeration
|
||||
|
||||
## 2019 R2
|
||||
|
||||
### New API
|
||||
|
||||
**Inference Engine Core API:**
|
||||
|
||||
* Introduced InferenceEngine::Core high level class to manage devices
|
||||
|
||||
**Query API extensions to InferenceEngine::ExecutableNetwork and InferenceEngine::IExecutableNetwork:**
|
||||
|
||||
* InferenceEngine::ExecutableNetwork::SetConfig method
|
||||
* InferenceEngine::ExecutableNetwork::GetConfig method
|
||||
* InferenceEngine::ExecutableNetwork::GetMetric method
|
||||
* InferenceEngine::IExecutableNetwork::SetConfig method
|
||||
* InferenceEngine::IExecutableNetwork::GetConfig method
|
||||
* InferenceEngine::IExecutableNetwork::GetMetric method
|
||||
|
||||
**Metrics and values for Query API:**
|
||||
|
||||
* METRIC_KEY(AVAILABLE_DEVICES)
|
||||
* METRIC_KEY(SUPPORTED_METRICS)
|
||||
* METRIC_KEY(SUPPORTED_CONFIG_KEYS)
|
||||
* METRIC_KEY(FULL_DEVICE_NAME)
|
||||
* METRIC_KEY(OPTIMIZATION_CAPABILITIES)
|
||||
* METRIC_VALUE(FP32)
|
||||
* METRIC_VALUE(FP16)
|
||||
* METRIC_VALUE(INT8)
|
||||
* METRIC_VALUE(BIN)
|
||||
* METRIC_VALUE(WINOGRAD)
|
||||
* DLIA_METRIC_VALUE(FP11)
|
||||
* METRIC_KEY(RANGE_FOR_STREAMS)
|
||||
* METRIC_KEY(NUMBER_OF_WAITING_INFER_REQUESTS)
|
||||
* METRIC_KEY(NUMBER_OF_EXEC_INFER_REQUESTS)
|
||||
* METRIC_KEY(DEVICE_THERMAL)
|
||||
* METRIC_KEY(RANGE_FOR_ASYNC_INFER_REQUESTS)
|
||||
* EXEC_NETWORK_METRIC_KEY(NETWORK_NAME)
|
||||
* EXEC_NETWORK_METRIC_KEY(OPTIMAL_NUMBER_OF_INFER_REQUESTS)
|
||||
|
||||
**Common API:**
|
||||
|
||||
* CLDNN_CONFIG_KEY(INT8_ENABLED) config key
|
||||
* CONFIG_KEY(GPU_THROUGHPUT_AUTO)
|
||||
* CONFIG_KEY(GPU_THROUGHPUT_STREAMS)
|
||||
* DLIA_CONFIG_KEY(IO_TRANSFORMATIONS_NATIVE) config key
|
||||
* DLIA_CONFIG_KEY(DUMP_SUPPORTED_LAYERS_INFORMATION) config key
|
||||
* GNA_CONFIG_VALUE(SW_FP32) config value for GNA_CONFIG_KEY(DEVICE_MODE) key
|
||||
* MULTI_CONFIG_KEY(DEVICE_PRIORITIES) config key for `MULTI` device
|
||||
* InferenceEngine::CNNNetReader::ReadNetwork(const std::wstring &filepath) new method
|
||||
* InferenceEngine::CNNNetReader::ReadWeights(const std::wstring &filepath) new method
|
||||
* InferenceEngine::ExecutableNetwork::ExecutableNetwork(IExecutableNetwork::Ptr actual, InferenceEnginePluginPtr plg) constructor with additional `plg` parameter
|
||||
* InferenceEngine::InferRequest::InferRequest(IInferRequest::Ptr request, InferenceEnginePluginPtr plg) constructor with additional `plg` parameter
|
||||
* InferenceEngine::Data::setName method
|
||||
* InferenceEngine::QueryNetworkResult::supportedLayersMap
|
||||
* InferenceEngine::Precision::I64 extension to InferenceEngine::Precision::ePrecision enumeration
|
||||
|
||||
**New supported primitives:**
|
||||
|
||||
* InferenceEngine::Builder::DeformableConvolutionLayer new class
|
||||
* InferenceEngine::DeformableConvolutionLayer new class
|
||||
* InferenceEngine::EltwiseLayer::Logical_NOT, InferenceEngine::EltwiseLayer::Mean, InferenceEngine::EltwiseLayer::Select extensions to InferenceEngine::EltwiseLayer::eOperation enumeration
|
||||
* InferenceEngine::OneHotLayer new class
|
||||
* InferenceEngine::SelectLayer new class
|
||||
* InferenceEngine::BroadcastLayer new class
|
||||
* InferenceEngine::MathLayer new class
|
||||
* InferenceEngine::ReduceLayer new class
|
||||
* InferenceEngine::TopKLayer new class
|
||||
|
||||
**Extensions to Blob creation API:**
|
||||
|
||||
* InferenceEngine::Blob::is method
|
||||
* InferenceEngine::Blob::is const method
|
||||
* InferenceEngine::Blob::as method
|
||||
* InferenceEngine::Blob::as const method
|
||||
* InferenceEngine::Blob::getAllocator abstract method
|
||||
* InferenceEngine::Blob::getHandle abstract method
|
||||
* InferenceEngine::MemoryBlob class
|
||||
* InferenceEngine::ColorFormat enumeration
|
||||
* InferenceEngine::PreProcessInfo::setColorFormat method
|
||||
* InferenceEngine::PreProcessInfo::getColorFormat method
|
||||
* InferenceEngine::CompoundBlob class to work with blobs consisting of several planes
|
||||
* InferenceEngine::NV12Blob class representing NV12 blob with two planes
|
||||
|
||||
### Deprecated API
|
||||
|
||||
The methods listed below are deprecated and will be removed in 2019 R4 release:
|
||||
|
||||
**Common API:**
|
||||
|
||||
* InferenceEngine::InputInfo::getInputPrecision method
|
||||
* InferenceEngine::InputInfo::setInputPrecision method
|
||||
* InferenceEngine::InputInfo::getDims method
|
||||
* InferenceEngine::CNNLayer::GetParamsAsBool method
|
||||
* InferenceEngine::CNNNetwork::CNNNetwork(ICNNNetwork* actual) constructor
|
||||
* InferenceEngine::CNNNetwork::setTargetDevice method
|
||||
* HETERO_CONFIG_KEY(DUMP_DLA_MESSAGES) config key
|
||||
* InferenceEngine::ILayerImplFactory::getShapes method
|
||||
* InferenceEngine::IShapeInferImpl::inferShapes(const std::vector<SizeVector>&, const std::map<std::string, std::string>& , const std::map<std::string, Blob::Ptr>&, std::vector<SizeVector>&, ResponseDesc\*) method
|
||||
* InferenceEngine::Data::setBatchSize method
|
||||
* InferenceEngine::QueryNetworkResult::supportedLayers field
|
||||
* InferenceEngine::ICNNNetwork::setBatchSize(const size_t size) method
|
||||
* InferenceEngine::Blob::Resize method
|
||||
* InferenceEngine::Blob::Reshape method
|
||||
* InferenceEngine::TBlob::set method
|
||||
|
||||
**InferenceEngine::IInferencePlugin and InferenceEngine:InferencePlugin obsolete methods:**
|
||||
|
||||
* InferenceEngine::InferencePlugin::LoadNetwork(ICNNNetwork &network) method
|
||||
* InferenceEngine::InferencePlugin::Infer method
|
||||
* InferenceEngine::InferencePlugin::GetPerformanceCounts method
|
||||
* InferenceEngine::InferencePlugin::QueryNetwork(const ICNNNetwork &network, QueryNetworkResult &res) const method
|
||||
* InferenceEngine::IInferencePlugin::LoadNetwork(ICNNNetwork &network, ResponseDesc \*resp) method
|
||||
* InferenceEngine::IInferencePlugin::Infer(const Blob &input, Blob &result, ResponseDesc \*resp) method
|
||||
* InferenceEngine::IInferencePlugin::Infer(const BlobMap &input, BlobMap &result, ResponseDesc \*resp) method
|
||||
* InferenceEngine::IInferencePlugin::GetPerformanceCounts method
|
||||
* InferenceEngine::IInferencePlugin::QueryNetwork(const ICNNNetwork& network, QueryNetworkResult& res) const method
|
||||
|
||||
|
||||
**Fields in InferenceEngine::Data class are replaced with appropriate methods:**
|
||||
|
||||
* InferenceEngine::Data::precision field
|
||||
* InferenceEngine::Data::layout field
|
||||
* InferenceEngine::Data::dims field
|
||||
* InferenceEngine::Data::creatorLayer field
|
||||
* InferenceEngine::Data::name field
|
||||
* InferenceEngine::Data::inputTo field
|
||||
* InferenceEngine::Data::userObject field
|
||||
|
||||
**Heterogeneous plugin:**
|
||||
|
||||
* InferenceEngine::IHeteroDeviceLoader class
|
||||
* InferenceEngine::IHeteroInferencePlugin class
|
||||
* InferenceEngine::HeteroPluginPtr class
|
||||
* operator InferenceEngine::InferencePlugin::HeteroPluginPtr operator
|
||||
|
||||
**Blob creation API with dimensions in reverse order:**
|
||||
|
||||
* InferenceEngine::Blob::Blob(Precision p) constructor
|
||||
* InferenceEngine::Blob::Blob(Precision p, Layout l) constructor
|
||||
* InferenceEngine::Blob::Blob(Precision p, const SizeVector &dims) constructor
|
||||
* InferenceEngine::Blob::Blob(Precision p, Layout l, const SizeVector &dims) constructor
|
||||
* InferenceEngine::TBlob::TBlob(Precision p, Layout l) constructor
|
||||
* InferenceEngine::TBlob::TBlob(Precision p, Layout l, const SizeVector& dims) constructor
|
||||
* InferenceEngine::TBlob::TBlob(Precision p, Layout l, const SizeVector& dims, T* ptr, size_t data_size) constructor
|
||||
* InferenceEngine::TBlob::TBlob(Precision p, Layout l, const SizeVector &dims, std::shared_ptr<IAllocator> alloc) constructor
|
||||
* InferenceEngine::Blob::type() method
|
||||
* InferenceEngine::Blob::precision() method
|
||||
* InferenceEngine::Blob::layout() method
|
||||
* InferenceEngine::Blob::dims() method
|
||||
* InferenceEngine::make_shared_blob(Precision p, Layout l, const SizeVector &dims) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, const SizeVector &dims) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, Layout l, const TArg &arg) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, const TArg &arg) function
|
||||
* InferenceEngine::make_shared_blob(TBlob<TypeTo> &&arg) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, Layout l) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, Layout l, SizeVector dims, const std::vector<TypeTo> &arg) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, Layout l, const std::vector<TypeTo> &arg) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, const std::vector<TypeTo> &arg) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, Layout l, const SizeVector &dims, TypeTo * ptr, size_t size) function
|
||||
* InferenceEngine::make_shared_blob(Precision p, const SizeVector &dims, TypeTo * ptr, size_t size) function
|
||||
* InferenceEngine::I_N variable
|
||||
* InferenceEngine::I_C variable
|
||||
* InferenceEngine::I_H variable
|
||||
* InferenceEngine::I_W variable
|
||||
* InferenceEngine::LayoutOffsetCounter class
|
||||
* InferenceEngine::ConvertLayout function
|
||||
|
||||
**API working with device enumeration:**
|
||||
|
||||
* InferenceEngine::TargetDevice enumeration
|
||||
* InferenceEngine::TargetDeviceInfo class
|
||||
* InferenceEngine::getDeviceName function
|
||||
* InferenceEngine::FindPluginRequest class
|
||||
* InferenceEngine::FindPluginResponse class
|
||||
* InferenceEngine::findPlugin(const FindPluginRequest &req, FindPluginResponse &result, ResponseDesc *resp) function
|
||||
* InferenceEngine::ICNNNetwork::setTargetDevice method
|
||||
* InferenceEngine::ICNNNetwork::getTargetDevice method
|
||||
* InferenceEngine::PluginDispatcher::getPluginByDevice method
|
||||
* InferenceEngine::PluginDispatcher::getSuitablePlugin method
|
||||
|
||||
@@ -28,7 +28,7 @@ An implementation constructor checks parameters of an nGraph operation, stores r
|
||||
|
||||
### `getSupportedConfigurations`
|
||||
|
||||
The InferenceEngine::ILayerExecImpl::getSupportedConfigurations method returns all supported configuration formats (input/output tensor layouts) for your implementation. To specify formats of data, use InferenceEngine::TensorDesc. Refer to the [Memory Primitives](../Memory_primitives.md) section for instructions.
|
||||
The InferenceEngine::ILayerExecImpl::getSupportedConfigurations method returns all supported configuration formats (input/output tensor layouts) for your implementation. To specify formats of data, use InferenceEngine::TensorDesc.
|
||||
|
||||
@snippet template_extension/old/cpu_kernel.cpp cpu_implementation:getSupportedConfigurations
|
||||
|
||||
|
||||
@@ -80,8 +80,6 @@ Optionally, configure input and output of the model using the steps below:
|
||||
|
||||
auto network = core.ReadNetwork("model.onnx");
|
||||
|
||||
You can find more information about the ONNX format support in the document `ONNX format support in the OpenVINO™ <https://docs.openvino.ai/latest/openvino_docs_IE_DG_ONNX_Support.html>`_
|
||||
|
||||
.. tab:: nGraph
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
@@ -1,58 +0,0 @@
|
||||
# Known Issues and Limitations {#openvino_docs_IE_DG_Known_Issues_Limitations}
|
||||
|
||||
## Multiple OpenMP Loadings
|
||||
|
||||
If the application uses the Inference Engine with third-party components that depend on Intel OpenMP, multiple loadings of the libiomp library may occur and cause OpenMP runtime initialization conflicts. This may happen, for example, if the application uses Intel® Math Kernel Library (Intel® MKL) through the “Single Dynamic Library” (<code>libmkl_rt.so</code>) mechanism and calls Intel MKL after loading the Inference Engine plugin.
|
||||
The error log looks like this:
|
||||
|
||||
```sh
|
||||
OMP: Error #15: Initializing libiomp5.so, but found libiomp5.so already initialized.
|
||||
OMP: Hint: This means that multiple copies of the OpenMP runtime have been linked into the program. That is dangerous, since it can degrade performance or cause incorrect results. The best thing to do is to ensure that only a single OpenMP runtime is linked into the process, e.g. by avoiding static linking of the OpenMP runtime in any library. As an unsafe, unsupported, undocumented workaround you can set the environment variable KMP_DUPLICATE_LIB_OK=TRUE to allow the program to continue to execute, but that may cause crashes or silently produce incorrect results. For more information, please see http://www.intel.com/software/products/support/.
|
||||
```
|
||||
|
||||
Possible workarounds:
|
||||
|
||||
* Preload the OpenMP runtime using the <code>LD_PRELOAD</code> variable:
|
||||
```sh
|
||||
LD_PRELOAD=<path_to_libiomp5.so> <path_to your_executable>
|
||||
```
|
||||
This eliminates multiple loadings of libiomp, and makes all the components use this specific version of OpenMP.
|
||||
|
||||
* Alternatively, you can set <code>KMP_DUPLICATE_LIB_OK=TRUE</code>. However, performance degradation or incorrect results may occur in this case.
|
||||
|
||||
|
||||
## Old proto compiler breaks protobuf library
|
||||
|
||||
With python protobuf library version 3.5.1, the following incompatibility can happen.
|
||||
The known case is for Cent OS 7.4.
|
||||
|
||||
The error log looks like this:
|
||||
|
||||
```sh
|
||||
File "../lib64/python3.5/site-packages/google/protobuf/descriptor.py", line 829, in _new_
|
||||
return _message.default_pool.AddSerializedFile(serialized_pb)
|
||||
TypeError: expected bytes, str found
|
||||
```
|
||||
|
||||
A possible workaround is to upgrade default protobuf compiler (libprotoc 2.5.0) to newer version, for example libprotoc 2.6.1.
|
||||
|
||||
[protobuf_issue]: https://github.com/google/protobuf/issues/4272
|
||||
|
||||
## Dynamic batching
|
||||
Refer to the **Limitations** section of the [Dynamic batching page](DynamicBatching.md).
|
||||
|
||||
## Static Shape Infer
|
||||
Refer to the **Limitations** section of the [Static Shape Infer page](ShapeInference.md).
|
||||
|
||||
|
||||
## Image Pre-Processing Performance Optimization Issue
|
||||
|
||||
As described in [documentation for the new API](Integrate_with_customer_application_new_API.md), you can set an image blob of any size to an
|
||||
infer request using resizable input. Resize is executed during inference using the configured resize algorithm.
|
||||
|
||||
But currently, resize algorithms are not completely optimized. So expect performance degradation if resizable input is
|
||||
specified and an input blob (to be resized) is set using `SetBlob()`. The best performance is for the
|
||||
[CPU](supported_plugins/CPU.md) plugin only (because enabled openMP* provides parallelism).
|
||||
|
||||
Another limitation is that currently, resize algorithms support NCHW layout only. So if you set NHWC layout for an input
|
||||
blob, NHWC is converted to NCHW before resize and back to NHWC after resize.
|
||||
@@ -1,60 +0,0 @@
|
||||
# Inference Engine Memory Primitives {#openvino_docs_IE_DG_Memory_primitives}
|
||||
|
||||
## Inference Memory Primitives (C++)
|
||||
|
||||
@sphinxdirective
|
||||
.. raw:: html
|
||||
|
||||
<div id="switcher-cpp" class="switcher-anchor">C++</div>
|
||||
@endsphinxdirective
|
||||
|
||||
## Blobs
|
||||
|
||||
<code>InferenceEngine::Blob</code> is the main class intended for working with memory.
|
||||
Using this class you can read and write memory, get information about the memory structure etc.
|
||||
|
||||
The right way to create <code>Blob</code> objects with a specific layout is to use constructors with <code>InferenceEngine::TensorDesc</code>.
|
||||
<pre class="brush:cpp">
|
||||
InferenceEngine::TensorDesc tdesc(FP32, {1, 3, 227, 227}, InferenceEngine::Layout::NCHW);
|
||||
InferenceEngine::Blob::Ptr blob = InferenceEngine::make_shared_blob<float>(tdesc);
|
||||
</pre>
|
||||
|
||||
## Layouts
|
||||
|
||||
<code>InferenceEngine::TensorDesc</code> is a special class that provides layout format description.
|
||||
|
||||
This class allows to create planar layouts using the standard formats (like <code>InferenceEngine::Layout::NCDHW</code>, <code>InferenceEngine::Layout::NCHW</code>, <code>InferenceEngine::Layout::NC</code>, <code>InferenceEngine::Layout::C</code> and etc) and also non-planar layouts using <code>InferenceEngine::BlockingDesc</code>.
|
||||
|
||||
In order to create a complex layout you should use <code>InferenceEngine::BlockingDesc</code>, which allows you to define the blocked memory with offsets and strides.
|
||||
|
||||
## Examples
|
||||
|
||||
1. You can define a blob with dimensions {N: 1, C: 25, H: 20, W: 20} and format NHWC with using next parameters:<br/>
|
||||
<pre class="brush:cpp">
|
||||
InferenceEngine::BlockingDesc({1, 20, 20, 25}, {0, 2, 3, 1}); // or
|
||||
InferenceEngine::BlockingDesc({1, 20, 20, 25}, InferenceEngine::Layout::NHWC);
|
||||
</pre>
|
||||
2. If you have a memory with real dimensions {N: 1, C: 25, H: 20, W: 20} but with channels that are blocked by 8, you can define it using next parameters:<br/>
|
||||
<pre class="brush:cpp">
|
||||
InferenceEngine::BlockingDesc({1, 4, 20, 20, 8}, {0, 1, 2, 3, 1})
|
||||
</pre>
|
||||
3. Also you can set strides and offsets if layout contains it.
|
||||
4. If you have a complex blob layout and you don't want to calculate the real offset to data you can use the <code>InferenceEngine::TensorDesc::offset(size_t l)</code> or <code>InferenceEngine::TensorDesc::offset(SizeVector v)</code> methods.<br/>
|
||||
For example:
|
||||
<pre class="brush:cpp">
|
||||
InferenceEngine::BlockingDesc blk({1, 4, 20, 20, 8}, {0, 1, 2, 3, 1});
|
||||
InferenceEngine::TensorDesc tdesc(FP32, {1, 25, 20, 20}, blk);
|
||||
tdesc.offset(0); // = 0
|
||||
tdesc.offset(1); // = 8
|
||||
tdesc.offset({0, 0, 0, 2}); // = 16
|
||||
tdesc.offset({0, 1, 0, 2}); // = 17
|
||||
</pre>
|
||||
5. If you would like to create a TensorDesc with a planar format and for N dimensions (N can be different 1, 2, 4 and etc), you can use the <code>InferenceEngine::TensorDesc::getLayoutByDims</code> method.
|
||||
<pre class="brush:cpp">
|
||||
InferenceEngine::TensorDesc::getLayoutByDims({1}); // InferenceEngine::Layout::C
|
||||
InferenceEngine::TensorDesc::getLayoutByDims({1, 2}); // InferenceEngine::Layout::NC
|
||||
InferenceEngine::TensorDesc::getLayoutByDims({1, 2, 3, 4}); // InferenceEngine::Layout::NCHW
|
||||
InferenceEngine::TensorDesc::getLayoutByDims({1, 2, 3}); // InferenceEngine::Layout::BLOCKED
|
||||
InferenceEngine::TensorDesc::getLayoutByDims({1, 2, 3, 4, 5}); // InferenceEngine::Layout::NCDHW
|
||||
InferenceEngine::TensorDesc::getLayoutByDims({1, 2, 3, 4, 5, ...}); // InferenceEngine::Layout::BLOCKED
|
||||
</pre>
|
||||
@@ -8,7 +8,7 @@
|
||||
<div id="switcher-cpp" class="switcher-anchor">C++</div>
|
||||
@endsphinxdirective
|
||||
|
||||
As described in the [Inference Engine Developer Guide](Deep_Learning_Inference_Engine_DevGuide.md), a common application flow consists of the following steps:
|
||||
As described in the [OpenVINO™ Runtime User Guide](OpenVINO_Runtime_User_Guide.md), a common application flow consists of the following steps:
|
||||
|
||||
1. **Create an Inference Engine Core object**: First step to manage available devices and read network objects
|
||||
|
||||
|
||||
@@ -1,91 +0,0 @@
|
||||
# ONNX Format Support {#openvino_docs_IE_DG_ONNX_Support}
|
||||
|
||||
## Introduction (C++)
|
||||
|
||||
@sphinxdirective
|
||||
.. raw:: html
|
||||
|
||||
<div id="switcher-cpp" class="switcher-anchor">C++</div>
|
||||
@endsphinxdirective
|
||||
|
||||
Starting with the 2020.4 release, OpenVINO™ supports reading native ONNX models. The `Core::ReadNetwork()` method provides a uniform way to read models from IR or ONNX format, it is a recommended approach to reading models. Example:
|
||||
|
||||
```cpp
|
||||
InferenceEngine::Core core;
|
||||
auto network = core.ReadNetwork("model.onnx");
|
||||
```
|
||||
|
||||
### Reshape Feature
|
||||
OpenVINO™ does not provide a mechanism to specify pre-processing (like mean values subtraction, reverse input channels) for the ONNX format. If an ONNX model contains dynamic shapes for input, please use the `CNNNetwork::reshape` method to reshape the model.
|
||||
|
||||
### Weights Saved in External Files
|
||||
|
||||
OpenVINO™ supports ONNX models that store weights in external files. It is especially useful for models larger than 2GB because of protobuf limitations. To read such models, use the `ReadNetwork` overload which takes `modelPath` as input parameter (both `std::string` and `std::wstring`). Note that the `binPath` argument of `ReadNetwork` should be empty in this case, because paths to external weights are saved directly in an ONNX model.
|
||||
Otherwise, a runtime exception is thrown. Reading models with external weights is not supported by the `ReadNetwork(const std::string& model, const Blob::CPtr& weights)` overload.
|
||||
|
||||
Paths to external weight files are saved in an ONNX model; these paths are relative to the model's directory path.
|
||||
It means that if a model is located at `home/user/workspace/models/model.onnx` and a file that contains external weights is in `home/user/workspace/models/data/weights.bin`, then the path saved in the model should be:
|
||||
`data/weights.bin`
|
||||
|
||||
> **NOTE**: A single model can use many external weights files.
|
||||
|
||||
> **NOTE**: Data of many tensors can be stored in a single external weights file (it is processed using offset and length values, which can be also saved in a model).
|
||||
|
||||
The described mechanism is the only way to read weights from external files. The following input parameters of the `ReadNetwork` function overloads are NOT supported for ONNX models and should be passed as empty:
|
||||
* `const std::wstring& binPath`
|
||||
* `const std::string& binPath`
|
||||
* `const Blob::CPtr& weights`
|
||||
|
||||
You can find more details about the external data mechanism in [ONNX documentation](https://github.com/onnx/onnx/blob/master/docs/ExternalData.md).
|
||||
To convert a model to use the external data feature, you can use [ONNX helper functions](https://github.com/onnx/onnx/blob/master/onnx/external_data_helper.py).
|
||||
|
||||
Unsupported types of tensors:
|
||||
* string
|
||||
* complex64
|
||||
* complex128
|
||||
|
||||
## Introduction (Python)
|
||||
|
||||
@sphinxdirective
|
||||
.. raw:: html
|
||||
|
||||
<div id="switcher-python" class="switcher-anchor">Python</div>
|
||||
@endsphinxdirective
|
||||
|
||||
Starting with the 2020.4 release, OpenVINO™ supports reading native ONNX models. The `IECore.read_network()` method provides a uniform way to read models from IR or ONNX format, it is a recommended approach to reading models. Example:
|
||||
|
||||
```python
|
||||
from openvino.inference_engine import IECore
|
||||
|
||||
ie = IECore()
|
||||
net = ie.read_network(model=path_to_onnx_file)
|
||||
```
|
||||
|
||||
### Reshape Feature
|
||||
OpenVINO™ does not provide a mechanism to specify pre-processing (like mean values subtraction, reverse input channels) for the ONNX format. If an ONNX model contains dynamic shapes for input, please use the [IENetwork.reshape](api/ie_python_api/_autosummary/openvino.inference_engine.IENetwork.html#openvino.inference_engine.IENetwork.reshape) method to reshape the model.
|
||||
|
||||
```python
|
||||
from openvino.inference_engine import IECore
|
||||
|
||||
ie = IECore()
|
||||
net = ie.read_network(model=path_to_onnx_file)
|
||||
input_layer = next(iter(net.input_info))
|
||||
net.reshape({input_layer: new_shape})
|
||||
```
|
||||
|
||||
### Weights Saved in External Files
|
||||
|
||||
OpenVINO™ supports ONNX models that store weights in external files. It is especially useful for models larger than 2GB because of protobuf limitations. To read such models, use the `model` parameter in the `IECore.read_network(model=path_to_onnx_file)` method. Note that the parameter for the path to the binary weight file, `weights=` should be empty in this case, because paths to external weights are saved directly in an ONNX model. Otherwise, a runtime exception is thrown. Reading models with external weights is **NOT** supported by the `read_network(weights=path_to_bin_file)` parameter.
|
||||
|
||||
Paths to external weight files are saved in an ONNX model; these paths are relative to the model’s directory path. It means that if a model is located at: `$HOME/workspace/models/model.onnx` and a file that contains external weights: `$HOME/workspace/models/data/weights.bin`, the path saved in model should be: data/weights.bin.
|
||||
|
||||
**NOTE**:
|
||||
* A single model can use many external weights files.
|
||||
* Data of many tensors can be stored in a single external weights file (it is processed using offset and length values, which can be also saved in a model).
|
||||
|
||||
The described mechanism is the only possibility to read weights from external files. The `weights` input parameter of the [IECore.read_network](api/ie_python_api/_autosummary/openvino.inference_engine.IECore.html#openvino.inference_engine.IECore.read_network) function is NOT supported for ONNX models and should not be passed, or set as None.
|
||||
|
||||
Unsupported types of tensors:
|
||||
* string
|
||||
* complex64
|
||||
* complex128
|
||||
+4
-9
@@ -1,4 +1,4 @@
|
||||
# OpenVINO™ Runtime User Guide {#openvino_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide}
|
||||
# OpenVINO™ Runtime User Guide {#openvino_docs_OV_Runtime_User_Guide}
|
||||
|
||||
@sphinxdirective
|
||||
|
||||
@@ -7,27 +7,22 @@
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
:hidden:
|
||||
|
||||
|
||||
openvino_2_0_transition_guide
|
||||
openvino_docs_IE_DG_Integrate_with_customer_application_new_API
|
||||
openvino_docs_OV_Runtime_UG_Model_Representation
|
||||
ngraph_transformation
|
||||
openvino_docs_deployment_optimization_guide_dldt_optimization_guide
|
||||
openvino_docs_IE_DG_Device_Plugins
|
||||
Direct ONNX Format Support <openvino_docs_IE_DG_ONNX_Support>
|
||||
openvino_docs_IE_DG_Paddle_Support
|
||||
openvino_docs_IE_DG_Int8Inference
|
||||
openvino_docs_IE_DG_Bfloat16Inference
|
||||
openvino_docs_IE_DG_DynamicBatching
|
||||
openvino_docs_IE_DG_ShapeInference
|
||||
openvino_docs_IE_DG_Model_caching_overview
|
||||
openvino_docs_IE_DG_Extensibility_DG_Intro
|
||||
openvino_docs_IE_DG_Memory_primitives
|
||||
openvino_docs_IE_DG_network_state_intro
|
||||
openvino_docs_IE_DG_API_Changes
|
||||
openvino_docs_IE_DG_Known_Issues_Limitations
|
||||
openvino_docs_IE_DG_Glossary
|
||||
|
||||
openvino_docs_OV_Runtime_API_Changes
|
||||
|
||||
@endsphinxdirective
|
||||
|
||||
## Introduction
|
||||
@@ -1,52 +0,0 @@
|
||||
# Paddle Support in OpenVINO™ {#openvino_docs_IE_DG_Paddle_Support}
|
||||
|
||||
Starting from the 2022.1 release, OpenVINO™ supports reading native Paddle models.
|
||||
The `Core::ReadNetwork()` method provides a uniform way to read models from either the Paddle format or IR, which is the recommended approach.
|
||||
|
||||
## Read Paddle Models from IR
|
||||
|
||||
The Paddle Model can be read after it is [converted](../MO_DG/prepare_model/convert_model/Convert_Model_From_Paddle.md) to [Intermediate Representation (IR)](../MO_DG/IR_and_opsets.md).
|
||||
|
||||
**C++ Example:**
|
||||
|
||||
```cpp
|
||||
InferenceEngine::Core core;
|
||||
auto network = core.ReadNetwork("model.xml");
|
||||
```
|
||||
|
||||
**Python Example:**
|
||||
|
||||
```sh
|
||||
from openvino.inference_engine import IECore
|
||||
ie = IECore()
|
||||
net = ie.read_network("model.xml")
|
||||
```
|
||||
|
||||
## Read Paddle Models from The Paddle Format (Paddle `inference model` model type)
|
||||
|
||||
**C++ Example:**
|
||||
|
||||
```cpp
|
||||
InferenceEngine::Core core;
|
||||
auto network = core.ReadNetwork("model.pdmodel");
|
||||
```
|
||||
|
||||
**Python Example:**
|
||||
|
||||
```sh
|
||||
from openvino.inference_engine import IECore
|
||||
ie = IECore()
|
||||
net = ie.read_network("model.pdmodel")
|
||||
```
|
||||
|
||||
**The Reshape feature:**
|
||||
|
||||
OpenVINO™ does not provide a mechanism to specify pre-processing, such as mean values subtraction or reverse input channels, for the Paddle format.
|
||||
If a Paddle model contains dynamic shapes for input, use the `CNNNetwork::reshape` method for shape specialization.
|
||||
|
||||
## NOTES
|
||||
|
||||
* The Paddle [`inference model`](https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.1/doc/doc_en/inference_en.md) mainly contains two kinds of files `model.pdmodel`(model file) and `model.pdiparams`(params file), which are used for inference.
|
||||
* The list of supported Paddle models and a description of how to export them can be found in [Convert a Paddle Model](../MO_DG/prepare_model/convert_model/Convert_Model_From_Paddle.md). The following Paddle models are supported by intel CPU only: `Fast-SCNN`, `Yolo v3`, `ppyolo`, `MobileNetv3-SSD`, `BERT`.
|
||||
* For `Normalize` Paddle Models, the input data should be in FP32 format.
|
||||
* When reading Paddle models from The Paddle format, make sure that `model.pdmodel` and `model.pdiparams` are in the same folder directory.
|
||||
@@ -1,14 +0,0 @@
|
||||
# OpenVINO™ Python* Package
|
||||
|
||||
OpenVINO™ Python\* package includes types to measure model and calibrate to low precision.
|
||||
|
||||
The OpenVINO™ Python\* package available in the `<INSTALL_DIR>/python/python3.X` directory.
|
||||
|
||||
The OpenVINO™ Python\* package includes the following sub-packages:
|
||||
|
||||
- [openvino.inference_engine](../../src/bindings/python/docs/api_overview.md) - Python\* wrapper on OpenVINO™ Inference Engine.
|
||||
- `openvino.tools.accuracy_checker` - Measure accuracy.
|
||||
- `openvino.tools.benchmark` - Measure latency and throughput.
|
||||
|
||||
## See Also
|
||||
* [Integrate with Customer Application New API](Integrate_with_customer_application_new_API.md)
|
||||
@@ -270,4 +270,4 @@ sample, read the sample documentation by clicking the sample name in the samples
|
||||
list above.
|
||||
|
||||
## See Also
|
||||
* [Inference Engine Developer Guide](Deep_Learning_Inference_Engine_DevGuide.md)
|
||||
* [OpenVINO™ Runtime User Guide](OpenVINO_Runtime_User_Guide.md)
|
||||
|
||||
@@ -43,8 +43,7 @@ If a model has a hard-coded batch dimension, use `InferenceEngine::CNNNetwork::s
|
||||
|
||||
Inference Engine takes three kinds of a model description as an input, which are converted into an `InferenceEngine::CNNNetwork` object:
|
||||
1. [Intermediate Representation (IR)](../MO_DG/IR_and_opsets.md) through `InferenceEngine::Core::ReadNetwork`
|
||||
2. [ONNX model](../OV_Runtime_UG/ONNX_Support.md) through `InferenceEngine::Core::ReadNetwork`
|
||||
3. [OpenVINO Model](../OV_Runtime_UG/model_representation.md) through the constructor of `InferenceEngine::CNNNetwork`
|
||||
2. [OpenVINO Model](../OV_Runtime_UG/model_representation.md) through the constructor of `InferenceEngine::CNNNetwork`
|
||||
|
||||
`InferenceEngine::CNNNetwork` keeps an `ngraph::Function` object with the model description internally.
|
||||
The object should have fully-defined input shapes to be successfully loaded to Inference Engine plugins.
|
||||
|
||||
@@ -54,7 +54,7 @@ should be called with `weights` passed as an empty `Blob`.
|
||||
- Intel® Distribution of OpenVINO™ toolkit home page: [https://software.intel.com/en-us/openvino-toolkit](https://software.intel.com/en-us/openvino-toolkit)
|
||||
- OpenVINO™ toolkit online documentation: [https://docs.openvino.ai](https://docs.openvino.ai)
|
||||
- Model Optimizer Developer Guide: [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md)
|
||||
- Inference Engine Developer Guide: [Inference Engine Developer Guide](Deep_Learning_Inference_Engine_DevGuide.md)
|
||||
- [OpenVINO™ runTime User Guide](OpenVINO_Runtime_User_Guide.md)
|
||||
- For more information on Sample Applications, see the [Inference Engine Samples Overview](Samples_Overview.md)
|
||||
- For information on a set of pre-trained models, see the [Overview of OpenVINO™ Toolkit Pre-Trained Models](@ref omz_models_group_intel)
|
||||
- For IoT Libraries and Code Samples see the [Intel® IoT Developer Kit](https://github.com/intel-iot-devkit).
|
||||
|
||||
@@ -17,7 +17,7 @@
|
||||
:caption: Deploying Inference
|
||||
:hidden:
|
||||
|
||||
openvino_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide
|
||||
openvino_docs_OV_Runtime_User_Guide
|
||||
openvino_docs_install_guides_deployment_manager_tool
|
||||
openvino_inference_engine_tools_compile_tool_README
|
||||
|
||||
@@ -93,7 +93,7 @@ This section provides reference documents that guide you through developing your
|
||||
With the [Model Downloader](@ref omz_tools_downloader) and [Model Optimizer](MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md) guides, you will learn to download pre-trained models and convert them for use with the OpenVINO™ toolkit. You can provide your own model or choose a public or Intel model from a broad selection provided in the [Open Model Zoo](model_zoo.md).
|
||||
|
||||
## Deploying Inference
|
||||
The [OpenVINO™ Runtime User Guide](OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) explains the process of creating your own application that runs inference with the OpenVINO™ toolkit. The [API Reference](./api_references.html) defines the Inference Engine API for Python, C++, and C and the nGraph API for Python and C++. The Inference Engine API is what you'll use to create an OpenVINO™ application, while the nGraph API is available for using enhanced operations sets and other features. After writing your application, you can use the [Deployment Manager](install_guides/deployment-manager-tool.md) for deploying to target devices.
|
||||
The [OpenVINO™ Runtime User Guide](OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) explains the process of creating your own application that runs inference with the OpenVINO™ toolkit. The [API Reference](./api_references.html) defines the Inference Engine API for Python, C++, and C and the nGraph API for Python and C++. The Inference Engine API is what you'll use to create an OpenVINO™ application, while the nGraph API is available for using enhanced operations sets and other features. After writing your application, you can use the [Deployment Manager](install_guides/deployment-manager-tool.md) for deploying to target devices.
|
||||
|
||||
## Tuning for Performance
|
||||
The toolkit provides a [Performance Optimization Guide](optimization_guide/dldt_optimization_guide.md) and utilities for squeezing the best performance out of your application, including [Accuracy Checker](@ref omz_tools_accuracy_checker), [Post-Training Optimization Tool](@ref pot_README), and other tools for measuring accuracy, benchmarking performance, and tuning your application.
|
||||
|
||||
@@ -60,3 +60,4 @@ openvino_docs_ie_dg_lpt_variadicsplittransformation.rst
|
||||
openvino_docs_ie_plugin_dg_lp_representation.rst
|
||||
openvino_docs_ie_dg_lpt.rst
|
||||
notebooks/notebook_utils-with-output.rst
|
||||
api/api_reference.rst
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
# Glossary {#openvino_docs_IE_DG_Glossary}
|
||||
# Glossary {#openvino_docs_OV_Glossary}
|
||||
|
||||
## Acronyms and Abbreviations
|
||||
|
||||
@@ -12,7 +12,6 @@
|
||||
| CPU | Central Processing Unit |
|
||||
| CV | Computer Vision |
|
||||
| DL | Deep Learning |
|
||||
| DLDT | Intel(R) Deep Learning Deployment Toolkit |
|
||||
| DLL | Dynamic Link Library |
|
||||
| DNN | Deep Neural Networks |
|
||||
| ELU | Exponential Linear rectification Unit |
|
||||
@@ -21,7 +20,6 @@
|
||||
| GCC | GNU Compiler Collection |
|
||||
| GPU | Graphics Processing Unit |
|
||||
| HD | High Definition |
|
||||
| IE | Inference Engine |
|
||||
| IR | Intermediate Representation |
|
||||
| JIT | Just In Time |
|
||||
| JTAG | Joint Test Action Group |
|
||||
@@ -55,31 +53,26 @@
|
||||
|
||||
## Terms
|
||||
|
||||
Glossary of terms used in the Inference Engine
|
||||
Glossary of terms used in the OpenVINO™
|
||||
|
||||
|
||||
| Term | Description |
|
||||
| :--- | :--- |
|
||||
| Batch | Number of images to analyze during one call of infer. Maximum batch size is a property of the network and it is set before loading of the network to the plugin. In NHWC, NCHW and NCDHW image data layout representation, the N refers to the number of images in the batch |
|
||||
| Blob | Memory container used for storing inputs, outputs of the network, weights and biases of the layers |
|
||||
| Tensor | Memory container used for storing inputs, outputs of the network, weights and biases of the layers |
|
||||
| Device (Affinitity) | A preferred Intel(R) hardware device to run the inference (CPU, GPU, etc.) |
|
||||
| Extensibility mechanism, Custom layers | The mechanism that provides you with capabilities to extend the Inference Engine and Model Optimizer so that they can work with topologies containing layers that are not yet supported |
|
||||
| <code>CNNNetwork</code> | A class of the Convolutional Neural Network that Inference Engine reads from IR. Consists of topology, weights and biases |
|
||||
| <code>ExecutableNetwork</code> | An instance of the loaded network which allows the Inference Engine to request (several) infer requests and perform inference synchronously or asynchronously |
|
||||
| Extensibility mechanism, Custom layers | The mechanism that provides you with capabilities to extend the OpenVINO™ Runtime and Model Optimizer so that they can work with topologies containing layers that are not yet supported |
|
||||
| <code>ov::Model</code> | A class of the Model that OpenVINO™ Runtime reads from IR. Consists of topology, weights and biases |
|
||||
| <code>ov::CompiledModel</code> | An instance of the loaded network which allows the OpenVINO™ Runtime to request (several) infer requests and perform inference synchronously or asynchronously |
|
||||
| <code>InferRequest</code> | A class that represents the end point of inference on the model loaded to the plugin and represented by executable network. Inputs are set here, outputs should be requested from this interface as well |
|
||||
| <code>InferenceEngineProfileInfo</code> | Represents basic inference profiling information per layer |
|
||||
| Inference Engine | A C++ library with a set of classes that you can use in your application to infer input data (images) and get the result |
|
||||
| Inference Engine API | The basic default API for all supported devices, which allows you to load a model from Intermediate Representation, set input and output formats and execute the model on various devices |
|
||||
| Inference Engine <code>Core</code> | Inference Engine Core is a software component that manages inference on certain Intel(R) hardware devices: CPU, GPU, MYRIAD, GNA, etc. |
|
||||
| Layer catalog or Operations specification | A list of supported layers or operations and its parameters. Sets of supported layers are different for different plugins, please check the documentation on plugins to verify if the Inference Engine supports certain layer on the dedicated hardware |
|
||||
| <code>Layout</code> | Image data layout refers to the representation of images batch. Layout shows a sequence of 4D or 5D tensor data in memory. A typical NCHW format represents pixel in horizontal direction, rows by vertical dimension, planes by channel and images into batch |
|
||||
| <code>OutputsDataMap</code> | Structure which contains information about output precisions and layouts |
|
||||
| Precision | Represents data precision. For example, FP32 is 32-bit floating point, FP16 is 16-bit floating point. Precision can be changed before loading the network to the plugin |
|
||||
| <code>PreProcessInfo</code> | Class that represents input data for the network. It contains information about input precision, its layout, and pre-processing |
|
||||
| <code>ResponseDesc</code> | Represents debug information for an error |
|
||||
| <code>ov::ProfileInfo</code> | Represents basic inference profiling information per layer |
|
||||
| OpenVINO™ Runtime | A C++ library with a set of classes that you can use in your application to infer input data (images) and get the result |
|
||||
| OpenVINO™ API | The basic default API for all supported devices, which allows you to load a model from Intermediate Representation, set input and output formats and execute the model on various devices |
|
||||
| OpenVINO™ <code>Core</code> | OpenVINO™ Core is a software component that manages inference on certain Intel(R) hardware devices: CPU, GPU, MYRIAD, GNA, etc. |
|
||||
| <code>ov::Layout</code> | Image data layout refers to the representation of images batch. Layout shows a sequence of 4D or 5D tensor data in memory. A typical NCHW format represents pixel in horizontal direction, rows by vertical dimension, planes by channel and images into batch |
|
||||
| <code>ov::element::Type</code> | Represents data element type. For example, f32 is 32-bit floating point, f16 is 16-bit floating point. Element type can be changed before loading the network to the plugin |
|
||||
|
||||
|
||||
## See Also
|
||||
* [Deep Learning Model Optimizer IR Operations Catalog](../ops/opset.md)
|
||||
* [Inference Engine Memory primitives](Memory_primitives.md)
|
||||
* [Terminology](supported_plugins/Supported_Devices.md)
|
||||
* [Available Operations Sets](ops/opset.md)
|
||||
* [Terminology](OV_Runtime_UG/supported_plugins/Supported_Devices.md)
|
||||
@@ -1,3 +1,3 @@
|
||||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:2809bbcc91bd2495c670c401bcb0a1e55c80e2075af78444169df3c8b1c86a64
|
||||
size 532493
|
||||
oid sha256:db3052021f886eabc506477693ac472c922e72311b187c22a5ad14ce1fd10c71
|
||||
size 397028
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:b65c3fc61f6a1b309ee2712910dd96285cad2750c31cb5d0cdc97f790bc0f945
|
||||
size 230040
|
||||
oid sha256:5392b91caba67a9a3b1d890f973727636e7c2895d12144c1abd59690f580b84e
|
||||
size 252956
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:57a70b183a12fe35a7c9aa6532af6e17d8690d2516d92b2a76a081f8b172de99
|
||||
size 643430
|
||||
@@ -0,0 +1,3 @@
|
||||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:5d172c42e6beea444f811d1c2d5fb11e64557a73d5f6c8bab3976051da1a72b8
|
||||
size 575493
|
||||
+1
-1
@@ -72,7 +72,7 @@ OpenVINO™ Documentation
|
||||
<h3>DL Workbench </h3>
|
||||
<p> Learn about the alternative, web-based version of OpenVINO. DL Workbench container installation Required. </p>
|
||||
</a>
|
||||
<a href="openvino_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html" >
|
||||
<a href="openvino_docs_OV_Runtime_User_Guide.html" >
|
||||
<h3>Inference Engine </h3>
|
||||
<p> Learn about OpenVINO's inference mechanism which executes the IR and ONNX models on target devices. </p>
|
||||
</a>
|
||||
|
||||
@@ -21,7 +21,7 @@ The following components are installed with the OpenVINO runtime package:
|
||||
|
||||
| Component | Description|
|
||||
|-----------|------------|
|
||||
| [Inference Engine](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md)| The engine that runs a deep learning model. It includes a set of libraries for an easy inference integration into your applications. |
|
||||
| [OpenVINO™ Runtime](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md)| The engine that runs a deep learning model. It includes a set of libraries for an easy inference integration into your applications. |
|
||||
| [OpenCV*](https://docs.opencv.org/master/) | OpenCV* community version compiled for Intel® hardware. |
|
||||
| Deep Learning Streamer (DL Streamer) | Streaming analytics framework, based on GStreamer, for constructing graphs of media analytics components. For the DL Streamer documentation, see [DL Streamer Samples](@ref gst_samples_README), [API Reference](https://openvinotoolkit.github.io/dlstreamer_gst/), [Elements](https://github.com/openvinotoolkit/dlstreamer_gst/wiki/Elements), [Tutorial](https://github.com/openvinotoolkit/dlstreamer_gst/wiki/DL-Streamer-Tutorial). |
|
||||
|
||||
@@ -32,7 +32,7 @@ The following components are installed with the OpenVINO developer package:
|
||||
| Component | Description|
|
||||
|-----------|------------|
|
||||
| [Model Optimizer](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md) | This tool imports, converts, and optimizes models that were trained in popular frameworks to a format usable by Intel tools, especially the Inference Engine. <br>Popular frameworks include Caffe\*, TensorFlow\*, MXNet\*, and ONNX\*. |
|
||||
| [Inference Engine](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) | The engine that runs a deep learning model. It includes a set of libraries for an easy inference integration into your applications.|
|
||||
| [OpenVINO™ Runtime](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) | The engine that runs a deep learning model. It includes a set of libraries for an easy inference integration into your applications.|
|
||||
| [OpenCV*](https://docs.opencv.org/master/) | OpenCV\* community version compiled for Intel® hardware |
|
||||
| [Sample Applications](../OV_Runtime_UG/Samples_Overview.md) | A set of simple console applications demonstrating how to use the Inference Engine in your applications. |
|
||||
| [Demo Applications](@ref omz_demos) | A set of console applications that demonstrate how you can use the Inference Engine in your applications to solve specific use cases. |
|
||||
@@ -158,7 +158,7 @@ sudo apt autoremove intel-openvino-<PACKAGE_TYPE>-ubuntu<OS_VERSION>-<VERSION>.<
|
||||
- Intel® Distribution of OpenVINO™ toolkit home page: [https://software.intel.com/en-us/openvino-toolkit](https://software.intel.com/en-us/openvino-toolkit).
|
||||
- OpenVINO™ toolkit online documentation: [https://docs.openvino.ai](https://docs.openvino.ai).
|
||||
- [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md).
|
||||
- [Inference Engine Developer Guide](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md).
|
||||
- [OpenVINO™ Runtime User Guide](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md).
|
||||
- For more information on Sample Applications, see the [Inference Engine Samples Overview](../OV_Runtime_UG/Samples_Overview.md).
|
||||
- For IoT Libraries & Code Samples see the [Intel® IoT Developer Kit](https://github.com/intel-iot-devkit).
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@ The **runtime package** includes the following components installed by default:
|
||||
|
||||
| Component | Description |
|
||||
|-----------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|
||||
| [Inference Engine](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md) | This is the engine that runs the deep learning model. It includes a set of libraries for an easy inference integration into your applications. |
|
||||
| [OpenVINO™ Runtime](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md) | This is the engine that runs the deep learning model. It includes a set of libraries for an easy inference integration into your applications. |
|
||||
|
||||
## System Requirements
|
||||
|
||||
@@ -81,7 +81,7 @@ Now you can start developing your application.
|
||||
- Intel® Distribution of OpenVINO™ toolkit home page: [https://software.intel.com/en-us/openvino-toolkit](https://software.intel.com/en-us/openvino-toolkit).
|
||||
- OpenVINO™ toolkit online documentation: [https://docs.openvino.ai](https://docs.openvino.ai).
|
||||
- [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md).
|
||||
- [Inference Engine Developer Guide](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md).
|
||||
- [OpenVINO™ Runtime User Guide](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md).
|
||||
- For more information on Sample Applications, see the [Inference Engine Samples Overview](../OV_Runtime_UG/Samples_Overview.md).
|
||||
- Intel® Distribution of OpenVINO™ toolkit Anaconda* home page: [https://anaconda.org/intel/openvino-ie4py](https://anaconda.org/intel/openvino-ie4py)
|
||||
|
||||
|
||||
@@ -37,5 +37,5 @@ For system requirements and more detailed steps, see <https://pypi.org/project/o
|
||||
|
||||
- [Intel® Distribution of OpenVINO™ toolkit](https://software.intel.com/en-us/openvino-toolkit)
|
||||
- [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md)
|
||||
- [Inference Engine Developer Guide](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md)
|
||||
- [OpenVINO™ Runtime User Guide](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md)
|
||||
- [Inference Engine Samples Overview](../OV_Runtime_UG/Samples_Overview.md)
|
||||
|
||||
@@ -72,7 +72,7 @@ This guide provides step-by-step instructions on how to install the Intel® Dist
|
||||
@endsphinxdirective
|
||||
|
||||
3. Follow the instructions on your screen. During the installation you will be asked to accept the license agreement. The acceptance is required to continue. Check out the installation process in the image below:<br>
|
||||
|
||||
|
||||
Click on the image to see the details.
|
||||
<br>
|
||||
<br>By default, the Intel® Distribution of OpenVINO™ is installed to the following directory, referred to as `<INSTALL_DIR>` elsewhere in the documentation: `C:\Program Files (x86)\Intel\openvino_<version>/`.
|
||||
|
||||
@@ -22,7 +22,7 @@ The following components are installed with the OpenVINO runtime package:
|
||||
|
||||
| Component | Description|
|
||||
|-----------|------------|
|
||||
| [Inference Engine](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md)| The engine that runs a deep learning model. It includes a set of libraries for an easy inference integration into your applications. |
|
||||
| [OpenVINO™ Runtime](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md)| The engine that runs a deep learning model. It includes a set of libraries for an easy inference integration into your applications. |
|
||||
| [OpenCV*](https://docs.opencv.org/master/) | OpenCV* community version compiled for Intel® hardware. |
|
||||
| Deep Learning Stream (DL Streamer) | Streaming analytics framework, based on GStreamer, for constructing graphs of media analytics components. For the DL Streamer documentation, see [DL Streamer Samples](@ref gst_samples_README), [API Reference](https://openvinotoolkit.github.io/dlstreamer_gst/), [Elements](https://github.com/openvinotoolkit/dlstreamer_gst/wiki/Elements), [Tutorial](https://github.com/openvinotoolkit/dlstreamer_gst/wiki/DL-Streamer-Tutorial). |
|
||||
|
||||
@@ -138,7 +138,7 @@ sudo yum autoremove intel-openvino-runtime-centos<OS_VERSION>-<VERSION>.<UPDATE>
|
||||
- Intel® Distribution of OpenVINO™ toolkit home page: [https://software.intel.com/en-us/openvino-toolkit](https://software.intel.com/en-us/openvino-toolkit)
|
||||
- OpenVINO™ toolkit online documentation: [https://docs.openvino.ai](https://docs.openvino.ai)
|
||||
- [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md).
|
||||
- [Inference Engine Developer Guide](../OV_Runtime_UG/Deep_Learning_Inference_Engine_DevGuide.md).
|
||||
- [OpenVINO™ Runtime User Guide](../OV_Runtime_UG/OpenVINO_Runtime_User_Guide.md).
|
||||
- For more information on Sample Applications, see the [Inference Engine Samples Overview](../OV_Runtime_UG/Samples_Overview.md).
|
||||
- For IoT Libraries & Code Samples see the [Intel® IoT Developer Kit](https://github.com/intel-iot-devkit).
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
OpenVINO™ toolkit is a comprehensive toolkit for quickly developing applications and solutions that solve a variety of tasks including emulation of human vision, automatic speech recognition, natural language processing, recommendation systems, and many others. Based on latest generations of artificial neural networks, including Convolutional Neural Networks (CNNs), recurrent and attention-based networks, the toolkit extends computer vision and non-vision workloads across Intel® hardware, maximizing performance. It accelerates applications with high-performance, AI and deep learning inference deployed from edge to cloud.
|
||||
|
||||
[OpenVINO™ Runtime](https://docs.openvino.ai/latest/openvino_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html) package for Python includes a set of libraries for an easy inference integration into your Python applications and supports of heterogeneous execution across Intel® CPU and Intel® GPU hardware.
|
||||
[OpenVINO™ Runtime](https://docs.openvino.ai/latest/openvino_docs_OV_Runtime_User_Guide.html) package for Python includes a set of libraries for an easy inference integration into your Python applications and supports of heterogeneous execution across Intel® CPU and Intel® GPU hardware.
|
||||
|
||||
## System Requirements
|
||||
The complete list of supported hardware is available in the [Release Notes](https://www.intel.com/content/www/us/en/developer/articles/release-notes/openvino-relnotes.html).
|
||||
|
||||
+1
-3
@@ -10,7 +10,7 @@
|
||||
|
||||
Release Notes <https://software.intel.com/content/www/us/en/develop/articles/openvino-relnotes.html>
|
||||
openvino_docs_IE_DG_supported_plugins_Supported_Devices
|
||||
openvino_docs_IE_DG_Glossary
|
||||
openvino_docs_OV_Glossary
|
||||
openvino_docs_Legal_Information
|
||||
|
||||
|
||||
@@ -48,7 +48,5 @@ This section includes a variety of reference information in three broad categori
|
||||
|
||||
[Broadcast Rules for Elementwise Operations](ops/broadcast_rules.md) explains the rules used for to support an arbitrary number of dimensions in neural nets.
|
||||
|
||||
[Operation Specifications](OV_Runtime_UG/Operations_specifications.md) is a detailed reference of supported operations.
|
||||
|
||||
### Case Studies
|
||||
Links to [articles](https://www.intel.com/openvino-success-stories) about real-world examples of OpenVINO™ usage.
|
||||
|
||||
@@ -4,15 +4,20 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define CLEANUP_AND_RETURN(x) \
|
||||
if (x && !image && !image->data) \
|
||||
free(image->data); \
|
||||
if (input != NULL) \
|
||||
fclose(input); \
|
||||
return x;
|
||||
|
||||
int readBmpImage(const char* fileName, BitMap* image) {
|
||||
size_t cnt;
|
||||
int status = 0;
|
||||
FILE* input = 0;
|
||||
|
||||
if (NULL == fileName || NULL == image) {
|
||||
printf("[BMP] bad arguments\n");
|
||||
status = -1;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(-1);
|
||||
}
|
||||
|
||||
memset(image, 0, sizeof(BitMap));
|
||||
@@ -20,49 +25,42 @@ int readBmpImage(const char* fileName, BitMap* image) {
|
||||
input = fopen(fileName, "rb");
|
||||
if (input == NULL) {
|
||||
printf("[BMP] file %s is not opened\n", fileName);
|
||||
status = 1;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(-1);
|
||||
}
|
||||
|
||||
cnt = fread(&image->header.type, sizeof(image->header.type), sizeof(unsigned char), input);
|
||||
if (cnt != sizeof(image->header.type)) {
|
||||
printf("[BMP] file read error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(-2);
|
||||
}
|
||||
|
||||
if (image->header.type != 'M' * 256 + 'B') {
|
||||
printf("[BMP] file is not bmp type\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
|
||||
cnt = fread(&image->header.size, sizeof(image->header.size), sizeof(unsigned char), input);
|
||||
if (cnt != sizeof(image->header.size)) {
|
||||
printf("[BMP] file read error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
|
||||
cnt = fread(&image->header.reserved, sizeof(image->header.reserved), sizeof(unsigned char), input);
|
||||
if (cnt != sizeof(image->header.reserved)) {
|
||||
printf("[BMP] file read error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
|
||||
cnt = fread(&image->header.offset, sizeof(image->header.offset), sizeof(unsigned char), input);
|
||||
if (cnt != sizeof(image->header.offset)) {
|
||||
printf("[BMP] file read error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
|
||||
cnt = fread(&image->infoHeader, sizeof(BmpInfoHeader), sizeof(unsigned char), input);
|
||||
if (cnt != sizeof(image->header.offset)) {
|
||||
printf("[BMP] file read error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
|
||||
image->width = image->infoHeader.width;
|
||||
@@ -70,12 +68,12 @@ int readBmpImage(const char* fileName, BitMap* image) {
|
||||
|
||||
if (image->infoHeader.bits != 24) {
|
||||
printf("[BMP] 24bpp only supported. But input has: %d\n", image->infoHeader.bits);
|
||||
return 3;
|
||||
CLEANUP_AND_RETURN(3);
|
||||
}
|
||||
|
||||
if (image->infoHeader.compression != 0) {
|
||||
printf("[BMP] compression not supported\n");
|
||||
return 4;
|
||||
CLEANUP_AND_RETURN(4);
|
||||
}
|
||||
|
||||
int padSize = image->width & 3;
|
||||
@@ -86,42 +84,31 @@ int readBmpImage(const char* fileName, BitMap* image) {
|
||||
image->data = malloc(sizeof(char) * size);
|
||||
if (NULL == image->data) {
|
||||
printf("[BMP] memory allocation failed\n");
|
||||
return 5;
|
||||
CLEANUP_AND_RETURN(5);
|
||||
}
|
||||
|
||||
if (0 != fseek(input, image->header.offset, SEEK_SET)) {
|
||||
printf("[BMP] file seek error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
|
||||
// reading by rows in invert vertically
|
||||
int i;
|
||||
for (i = 0; i < image->height; i++) {
|
||||
unsigned int storeAt = image->infoHeader.height < 0 ? i : (unsigned int)image->height - 1 - i;
|
||||
int image_height = image->height;
|
||||
for (i = 0; i < image_height; i++) {
|
||||
unsigned int storeAt = image->infoHeader.height < 0 ? i : (unsigned int)image_height - 1 - i;
|
||||
cnt = fread(image->data + row_size * storeAt, row_size, sizeof(unsigned char), input);
|
||||
if (cnt != row_size) {
|
||||
printf("[BMP] file read error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
|
||||
cnt = fread(pad, padSize, sizeof(unsigned char), input);
|
||||
if (cnt != padSize) {
|
||||
printf("[BMP] file read error\n");
|
||||
status = 2;
|
||||
goto Exit;
|
||||
CLEANUP_AND_RETURN(2);
|
||||
}
|
||||
}
|
||||
|
||||
Exit:
|
||||
if (0 != status && NULL != image && NULL != image->data) {
|
||||
free(image->data);
|
||||
}
|
||||
|
||||
if (NULL != input) {
|
||||
fclose(input);
|
||||
}
|
||||
|
||||
return status;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -360,6 +360,7 @@ std::string get_test_info_stream_header(benchmark_app::InputInfo& inputInfo) {
|
||||
|
||||
std::map<std::string, ov::TensorVector> get_tensors(std::map<std::string, std::vector<std::string>> inputFiles,
|
||||
std::vector<benchmark_app::InputsInfo>& app_inputs_info) {
|
||||
std::ios::fmtflags fmt(std::cout.flags());
|
||||
std::map<std::string, ov::TensorVector> tensors;
|
||||
if (app_inputs_info.empty()) {
|
||||
throw std::logic_error("Inputs Info for network is empty!");
|
||||
@@ -515,6 +516,7 @@ std::map<std::string, ov::TensorVector> get_tensors(std::map<std::string, std::v
|
||||
slog::info << std::left << std::setw(maxNameWidth + 2) << inputLog.first << inputLog.second << slog::endl;
|
||||
}
|
||||
}
|
||||
std::cout.flags(fmt);
|
||||
|
||||
return tensors;
|
||||
}
|
||||
@@ -523,6 +525,7 @@ std::map<std::string, ov::TensorVector> get_tensors_static_case(const std::vecto
|
||||
const size_t& batchSize,
|
||||
benchmark_app::InputsInfo& app_inputs_info,
|
||||
size_t requestsNum) {
|
||||
std::ios::fmtflags fmt(std::cout.flags());
|
||||
std::map<std::string, ov::TensorVector> blobs;
|
||||
|
||||
std::vector<std::pair<size_t, size_t>> net_input_im_sizes;
|
||||
@@ -687,6 +690,7 @@ std::map<std::string, ov::TensorVector> get_tensors_static_case(const std::vecto
|
||||
slog::info << std::left << std::setw(maxNameWidth + 2) << inputLog.first << inputLog.second << slog::endl;
|
||||
}
|
||||
}
|
||||
std::cout.flags(fmt);
|
||||
|
||||
return blobs;
|
||||
}
|
||||
|
||||
@@ -402,6 +402,8 @@ int main(int argc, char* argv[]) {
|
||||
setThroughputStreams();
|
||||
} else if (device.find("GNA") != std::string::npos) {
|
||||
set_infer_precision();
|
||||
} else if (device.find("AUTO") != std::string::npos) {
|
||||
device_nstreams.erase(device);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -243,8 +243,10 @@ const nlohmann::json StatisticsReportJSON::perf_counters_to_json(
|
||||
}
|
||||
|
||||
void LatencyMetrics::write_to_stream(std::ostream& stream) const {
|
||||
std::ios::fmtflags fmt(std::cout.flags());
|
||||
stream << data_shape << ";" << std::fixed << std::setprecision(2) << median_or_percentile << ";" << avg << ";"
|
||||
<< min << ";" << max;
|
||||
std::cout.flags(fmt);
|
||||
}
|
||||
|
||||
void LatencyMetrics::write_to_slog() const {
|
||||
|
||||
@@ -96,9 +96,9 @@ public:
|
||||
|
||||
std::string csv_name;
|
||||
std::string json_name;
|
||||
int i_val;
|
||||
double d_val;
|
||||
unsigned long long ull_val;
|
||||
int i_val = 0;
|
||||
double d_val = 0;
|
||||
unsigned long long ull_val = 0;
|
||||
std::string s_val;
|
||||
LatencyMetrics metrics_val;
|
||||
Type type;
|
||||
|
||||
@@ -109,12 +109,17 @@ std::vector<std::string> parse_devices(const std::string& device_string) {
|
||||
std::string comma_separated_devices = device_string;
|
||||
auto colon = comma_separated_devices.find(":");
|
||||
if (colon != std::string::npos) {
|
||||
if (comma_separated_devices.substr(0, colon) == "AUTO") {
|
||||
std::vector<std::string> result;
|
||||
result.push_back("AUTO");
|
||||
return result;
|
||||
}
|
||||
auto bracket = comma_separated_devices.find("("); // e.g. in BATCH:GPU(4)
|
||||
comma_separated_devices = comma_separated_devices.substr(colon + 1, bracket - colon - 1);
|
||||
}
|
||||
if ((comma_separated_devices == "AUTO") || (comma_separated_devices == "MULTI") ||
|
||||
(comma_separated_devices == "HETERO"))
|
||||
if ((comma_separated_devices == "MULTI") || (comma_separated_devices == "HETERO"))
|
||||
return std::vector<std::string>();
|
||||
|
||||
auto devices = split(comma_separated_devices, ',');
|
||||
return devices;
|
||||
}
|
||||
|
||||
@@ -993,7 +993,7 @@ static UNUSED void printPerformanceCounts(std::vector<ov::ProfilingInfo> perform
|
||||
if (bshowHeader) {
|
||||
stream << std::endl << "performance counts:" << std::endl << std::endl;
|
||||
}
|
||||
|
||||
std::ios::fmtflags fmt(std::cout.flags());
|
||||
for (const auto& it : performanceData) {
|
||||
std::string toPrint(it.node_name);
|
||||
const int maxLayerName = 30;
|
||||
@@ -1028,6 +1028,7 @@ static UNUSED void printPerformanceCounts(std::vector<ov::ProfilingInfo> perform
|
||||
std::cout << std::endl;
|
||||
std::cout << "Full device name: " << deviceName << std::endl;
|
||||
std::cout << std::endl;
|
||||
std::cout.flags(fmt);
|
||||
}
|
||||
|
||||
static UNUSED void printPerformanceCounts(ov::InferRequest request,
|
||||
|
||||
@@ -291,6 +291,7 @@ void print_performance_counters(std::map<std::string, ov::ProfilingInfo> const&
|
||||
const uint64_t numberOfFramesOnHw,
|
||||
std::string FLAGS_d) {
|
||||
#if !defined(__arm__) && !defined(_M_ARM) && !defined(__aarch64__) && !defined(_M_ARM64)
|
||||
std::ios::fmtflags fmt(std::cout.flags());
|
||||
stream << std::endl << "Performance counts:" << std::endl;
|
||||
stream << std::setw(10) << std::right << ""
|
||||
<< "Counter descriptions";
|
||||
@@ -307,7 +308,12 @@ void print_performance_counters(std::map<std::string, ov::ProfilingInfo> const&
|
||||
for (const auto& it : utterancePerfMap) {
|
||||
std::string const& counter_name = it.first;
|
||||
float current_units_us = static_cast<float>(it.second.real_time.count()) / freq;
|
||||
float call_units_us = current_units_us / numberOfFrames;
|
||||
float call_units_us = 0;
|
||||
if (numberOfFrames == 0) {
|
||||
throw std::logic_error("Number off frames = 0, division by zero.");
|
||||
} else {
|
||||
call_units_us = current_units_us / numberOfFrames;
|
||||
}
|
||||
if (FLAGS_d.find("GNA") != std::string::npos) {
|
||||
stream << std::setw(30) << std::left << counter_name.substr(4, counter_name.size() - 1);
|
||||
} else {
|
||||
@@ -324,6 +330,7 @@ void print_performance_counters(std::map<std::string, ov::ProfilingInfo> const&
|
||||
stream << "Number of frames delivered to GNA HW: " << numberOfFramesOnHw;
|
||||
stream << "/" << numberOfFrames;
|
||||
stream << std::endl;
|
||||
std::cout.flags(fmt);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@@ -1740,7 +1740,11 @@ cdef class IENetwork:
|
||||
if input not in net_inputs:
|
||||
raise AttributeError(f"Specified '{input}' layer not in network inputs '{net_inputs}'! ")
|
||||
for v in shape:
|
||||
c_shape.push_back(v)
|
||||
try:
|
||||
c_shape.push_back(v)
|
||||
except OverflowError:
|
||||
raise ValueError(f"Detected dynamic dimension in the shape {shape} of the `{input}` input. Dynamic shapes are supported since OpenVINO Runtime API 2022.1.")
|
||||
|
||||
c_input_shapes[input.encode()] = c_shape
|
||||
self.impl.reshape(c_input_shapes)
|
||||
|
||||
|
||||
@@ -8,14 +8,13 @@
|
||||
#include <pybind11/stl_bind.h>
|
||||
|
||||
#include "extension/json_config.hpp"
|
||||
#include "manager.hpp"
|
||||
#include "openvino/frontend/exception.hpp"
|
||||
#include "openvino/frontend/extension/conversion.hpp"
|
||||
#include "openvino/frontend/extension/decoder_transformation.hpp"
|
||||
#include "openvino/frontend/extension/op.hpp"
|
||||
#include "openvino/frontend/extension/progress_reporter.hpp"
|
||||
#include "openvino/frontend/extension/telemetry.hpp"
|
||||
#include "pyopenvino/graph/model.hpp"
|
||||
#include "pyopenvino/utils/utils.hpp"
|
||||
|
||||
namespace py = pybind11;
|
||||
|
||||
@@ -130,7 +129,7 @@ void regclass_frontend_OpExtension(py::module m) {
|
||||
const std::map<std::string, py::object>& attr_values_map) {
|
||||
std::map<std::string, ov::Any> any_map;
|
||||
for (const auto& it : attr_values_map) {
|
||||
any_map[it.first] = it.second;
|
||||
any_map[it.first] = py_object_to_any(it.second);
|
||||
}
|
||||
return std::make_shared<OpExtension<void>>(fw_type_name, attr_names_map, any_map);
|
||||
}),
|
||||
@@ -144,8 +143,9 @@ void regclass_frontend_OpExtension(py::module m) {
|
||||
const std::map<std::string, py::object>& attr_values_map) {
|
||||
std::map<std::string, ov::Any> any_map;
|
||||
for (const auto& it : attr_values_map) {
|
||||
any_map[it.first] = it.second;
|
||||
any_map[it.first] = py_object_to_any(it.second);
|
||||
}
|
||||
|
||||
return std::make_shared<OpExtension<void>>(ov_type_name, fw_type_name, attr_names_map, any_map);
|
||||
}),
|
||||
py::arg("ov_type_name"),
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
# Copyright (C) 2021 Intel Corporation
|
||||
# Copyright (C) 2018-2022 Intel Corporation
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
#
|
||||
|
||||
@@ -19,7 +19,8 @@ function(frontend_module TARGET FRAMEWORK INSTALL_COMPONENT)
|
||||
|
||||
add_dependencies(${TARGET_NAME} pyopenvino)
|
||||
|
||||
target_include_directories(${TARGET_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
|
||||
target_include_directories(${TARGET_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}"
|
||||
"${PYTHON_SOURCE_DIR}/pyopenvino/utils/")
|
||||
target_link_libraries(${TARGET_NAME} PRIVATE openvino::runtime openvino::frontend::${FRAMEWORK})
|
||||
|
||||
# Compatibility with python 2.7 which has deprecated "register" specifier
|
||||
|
||||
@@ -72,7 +72,7 @@ void regclass_frontend_NodeContext(py::module m) {
|
||||
CAST_TO_PY(any, dtype, int64_t);
|
||||
CAST_TO_PY(any, dtype, bool);
|
||||
CAST_TO_PY(any, dtype, std::string);
|
||||
CAST_TO_PY(any, dtype, float);
|
||||
CAST_TO_PY(any, dtype, double);
|
||||
CAST_TO_PY(any, dtype, ov::element::Type);
|
||||
CAST_TO_PY(any, dtype, ov::PartialShape);
|
||||
|
||||
@@ -83,7 +83,7 @@ void regclass_frontend_NodeContext(py::module m) {
|
||||
CAST_VEC_TO_PY(any, dtype, std::vector<bool>);
|
||||
#endif
|
||||
CAST_VEC_TO_PY(any, dtype, std::vector<std::string>);
|
||||
CAST_VEC_TO_PY(any, dtype, std::vector<float>);
|
||||
CAST_VEC_TO_PY(any, dtype, std::vector<double>);
|
||||
CAST_VEC_TO_PY(any, dtype, std::vector<ov::element::Type>);
|
||||
CAST_VEC_TO_PY(any, dtype, std::vector<ov::PartialShape>);
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
//
|
||||
|
||||
#include "extension.hpp"
|
||||
#include "utils.hpp"
|
||||
|
||||
#include <pybind11/functional.h>
|
||||
#include <pybind11/pybind11.h>
|
||||
@@ -52,9 +53,10 @@ void regclass_frontend_onnx_OpExtension(py::module m) {
|
||||
ext.def(py::init([](const std::string& fw_type_name,
|
||||
const std::map<std::string, std::string>& attr_names_map,
|
||||
const std::map<std::string, py::object>& attr_values_map) {
|
||||
|
||||
std::map<std::string, ov::Any> any_map;
|
||||
for (const auto& it : attr_values_map) {
|
||||
any_map[it.first] = it.second;
|
||||
any_map[it.first] = py_object_to_any(it.second);
|
||||
}
|
||||
return std::make_shared<OpExtension<void>>(fw_type_name, attr_names_map, any_map);
|
||||
}), py::arg("fw_type_name"),
|
||||
@@ -65,9 +67,10 @@ void regclass_frontend_onnx_OpExtension(py::module m) {
|
||||
const std::string& fw_type_name,
|
||||
const std::map<std::string, std::string>& attr_names_map,
|
||||
const std::map<std::string, py::object>& attr_values_map) {
|
||||
|
||||
std::map<std::string, ov::Any> any_map;
|
||||
for (const auto& it : attr_values_map) {
|
||||
any_map[it.first] = it.second;
|
||||
any_map[it.first] = py_object_to_any(it.second);
|
||||
}
|
||||
return std::make_shared<OpExtension<void>>(ov_type_name, fw_type_name, attr_names_map, any_map);
|
||||
}),
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
//
|
||||
|
||||
#include "extension.hpp"
|
||||
#include "utils.hpp"
|
||||
|
||||
#include <pybind11/functional.h>
|
||||
#include <pybind11/pybind11.h>
|
||||
@@ -52,7 +53,7 @@ void regclass_frontend_tensorflow_OpExtension(py::module m) {
|
||||
const std::map<std::string, py::object>& attr_values_map) {
|
||||
std::map<std::string, ov::Any> any_map;
|
||||
for (const auto& it : attr_values_map) {
|
||||
any_map[it.first] = it.second;
|
||||
any_map[it.first] = py_object_to_any(it.second);
|
||||
}
|
||||
return std::make_shared<OpExtension<void>>(fw_type_name, attr_names_map, any_map);
|
||||
}), py::arg("fw_type_name"),
|
||||
@@ -65,7 +66,7 @@ void regclass_frontend_tensorflow_OpExtension(py::module m) {
|
||||
const std::map<std::string, py::object>& attr_values_map) {
|
||||
std::map<std::string, ov::Any> any_map;
|
||||
for (const auto& it : attr_values_map) {
|
||||
any_map[it.first] = it.second;
|
||||
any_map[it.first] = py_object_to_any(it.second);
|
||||
}
|
||||
return std::make_shared<OpExtension<void>>(ov_type_name, fw_type_name, attr_names_map, any_map);
|
||||
}),
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
// Copyright (C) 2018-2022 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <pybind11/pybind11.h>
|
||||
#include <openvino/core/any.hpp>
|
||||
|
||||
ov::Any py_object_to_any(const pybind11::object& py_obj) {
|
||||
if (pybind11::isinstance<pybind11::str>(py_obj)) {
|
||||
return py_obj.cast<std::string>();
|
||||
} else if (pybind11::isinstance<pybind11::bool_>(py_obj)) {
|
||||
return py_obj.cast<bool>();
|
||||
} else if (pybind11::isinstance<pybind11::float_>(py_obj)) {
|
||||
return py_obj.cast<double>();
|
||||
} else if (pybind11::isinstance<pybind11::int_>(py_obj)) {
|
||||
return py_obj.cast<int64_t>();
|
||||
} else if (pybind11::isinstance<pybind11::list>(py_obj)) {
|
||||
auto _list = py_obj.cast<pybind11::list>();
|
||||
enum class PY_TYPE : int {
|
||||
UNKNOWN = 0,
|
||||
STR,
|
||||
INT,
|
||||
FLOAT,
|
||||
BOOL
|
||||
};
|
||||
PY_TYPE detected_type = PY_TYPE::UNKNOWN;
|
||||
for (const auto &it: _list) {
|
||||
auto check_type = [&](PY_TYPE type) {
|
||||
if (detected_type == PY_TYPE::UNKNOWN || detected_type == type) {
|
||||
detected_type = type;
|
||||
return;
|
||||
}
|
||||
OPENVINO_ASSERT("Incorrect attribute. Mixed types in the list are not allowed.");
|
||||
};
|
||||
if (pybind11::isinstance<pybind11::str>(it)) {
|
||||
check_type(PY_TYPE::STR);
|
||||
} else if (pybind11::isinstance<pybind11::int_>(it)) {
|
||||
check_type(PY_TYPE::INT);
|
||||
} else if (pybind11::isinstance<pybind11::float_>(it)) {
|
||||
check_type(PY_TYPE::FLOAT);
|
||||
} else if (pybind11::isinstance<pybind11::bool_>(it)) {
|
||||
check_type(PY_TYPE::BOOL);
|
||||
}
|
||||
}
|
||||
|
||||
switch (detected_type) {
|
||||
case PY_TYPE::STR:
|
||||
return _list.cast<std::vector<std::string>>();
|
||||
case PY_TYPE::FLOAT:
|
||||
return _list.cast<std::vector<double>>();
|
||||
case PY_TYPE::INT:
|
||||
return _list.cast<std::vector<int64_t>>();
|
||||
case PY_TYPE::BOOL:
|
||||
return _list.cast<std::vector<bool>>();
|
||||
default:
|
||||
OPENVINO_ASSERT(false, "Unsupported attribute type.");
|
||||
}
|
||||
}
|
||||
OPENVINO_ASSERT(false, "Unsupported attribute type.");
|
||||
}
|
||||
@@ -91,6 +91,42 @@ def create_onnx_model_with_custom_attributes():
|
||||
return make_model(graph, producer_name="ngraph ONNX Importer")
|
||||
|
||||
|
||||
def create_onnx_model_for_op_extension():
|
||||
# operation with double attribute
|
||||
elu = onnx.helper.make_node("Elu", alpha=1.0, inputs=["x"], outputs=["elu"])
|
||||
|
||||
# operation with vector<size_t>, enum, bool attributes
|
||||
avg_pool = onnx.helper.make_node("AveragePool", kernel_shape=[2, 2], auto_pad="SAME_LOWER",
|
||||
strides=[2, 2],
|
||||
inputs=["elu"], outputs=["avg_pool"])
|
||||
|
||||
# operation with no attributes
|
||||
floor = onnx.helper.make_node("Floor", inputs=["avg_pool"], outputs=["floor"])
|
||||
|
||||
# operation with int64_t attribute
|
||||
concat = onnx.helper.make_node("Concat", axis=0, inputs=["floor", "avg_pool"], outputs=["concat"])
|
||||
|
||||
const_tensor = onnx.helper.make_tensor("const_tensor",
|
||||
onnx.TensorProto.FLOAT,
|
||||
[1],
|
||||
[0.5])
|
||||
|
||||
const_node = onnx.helper.make_node("Constant", [], outputs=["const_node"],
|
||||
value=const_tensor, name="const_node")
|
||||
# operation with enum attribute
|
||||
mul = onnx.helper.make_node("Mul", inputs=["concat", "const_node"], outputs=["mul"])
|
||||
|
||||
# operation with element::type (class) attribute
|
||||
cast = onnx.helper.make_node("Cast", to=int(onnx.TensorProto.FLOAT), inputs=["mul"], outputs=["out"])
|
||||
input_tensors = [
|
||||
make_tensor_value_info("x", onnx.TensorProto.FLOAT, (1, 3, 32, 32)),
|
||||
]
|
||||
output_tensors = [make_tensor_value_info("out", onnx.TensorProto.FLOAT, (3, 3, 32, 32))]
|
||||
graph = make_graph([const_node, elu, avg_pool, floor, concat, mul, cast], "graph",
|
||||
input_tensors, output_tensors)
|
||||
return make_model(graph, producer_name="ngraph ONNX Importer")
|
||||
|
||||
|
||||
def run_function(function, *inputs, expected):
|
||||
runtime = get_runtime()
|
||||
computation = runtime.computation(function)
|
||||
@@ -106,6 +142,7 @@ fem = FrontEndManager()
|
||||
onnx_model_filename = "model.onnx"
|
||||
onnx_model_with_custom_attributes_filename = "model_custom_attributes.onnx"
|
||||
onnx_model_with_subgraphs_filename = "model_subgraphs.onnx"
|
||||
onnx_model_for_op_extension_test = "model_op_extension.onnx"
|
||||
ONNX_FRONTEND_NAME = "onnx"
|
||||
|
||||
|
||||
@@ -114,12 +151,14 @@ def setup_module():
|
||||
onnx.save_model(create_onnx_model_with_custom_attributes(),
|
||||
onnx_model_with_custom_attributes_filename)
|
||||
onnx.save_model(create_onnx_model_with_subgraphs(), onnx_model_with_subgraphs_filename)
|
||||
onnx.save_model(create_onnx_model_for_op_extension(), onnx_model_for_op_extension_test)
|
||||
|
||||
|
||||
def teardown_module():
|
||||
os.remove(onnx_model_filename)
|
||||
os.remove(onnx_model_with_custom_attributes_filename)
|
||||
os.remove(onnx_model_with_subgraphs_filename)
|
||||
os.remove(onnx_model_for_op_extension_test)
|
||||
|
||||
|
||||
def skip_if_onnx_frontend_is_disabled():
|
||||
@@ -425,7 +464,8 @@ def test_onnx_conversion_extension():
|
||||
assert invoked
|
||||
|
||||
|
||||
def test_op_extension_via_onnx_extension():
|
||||
@pytest.mark.parametrize("opset_prefix", ["opset1.", "opset1::", "opset8.", "opset8::", ""])
|
||||
def test_op_extension_specify_opset(opset_prefix):
|
||||
skip_if_onnx_frontend_is_disabled()
|
||||
|
||||
# use specific (openvino.frontend.onnx) import here
|
||||
@@ -433,47 +473,123 @@ def test_op_extension_via_onnx_extension():
|
||||
from openvino.runtime import Core
|
||||
|
||||
ie = Core()
|
||||
ie.add_extension(OpExtension("FW_OV_OP"))
|
||||
ie.add_extension(OpExtension("OV_OP", "FW_OP_1"))
|
||||
ie.add_extension(OpExtension("OV_OP", "FW_OP_2", {"ov_attribute_1": "fw_attribute_1",
|
||||
"ov_attribute_2": "fw_attribute_2"}))
|
||||
ie.add_extension(OpExtension("OV_OP", "FW_OP_3", {"ov_attribute_1": "fw_attribute_1",
|
||||
"ov_attribute_2": "fw_attribute_2"},
|
||||
{"ov_attribute_str": "string",
|
||||
"ov_attribute_int": 4,
|
||||
"ov_attribute_bool": True,
|
||||
"ov_attribute_float": 4.,
|
||||
"ov_attribute_vec_string": ["str1", "str2", "str3"],
|
||||
"ov_attribute_vec_int": [1, 2, 3, 4, 5, 6, 7],
|
||||
"ov_attribute_vec_bool": [True, False, True],
|
||||
"ov_attribute_vec_float": [1., 2., 3., 4., 5., 6., 7.]}))
|
||||
|
||||
model = ie.read_model(onnx_model_filename)
|
||||
# check the model is valid
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
# add extensions
|
||||
fw_operation = "Floor"
|
||||
ov_operation = opset_prefix + fw_operation
|
||||
ie.add_extension(OpExtension(ov_operation, fw_operation))
|
||||
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
|
||||
def test_op_extension_via_frontend_extension():
|
||||
@pytest.mark.parametrize("opset_prefix", ["opset1..", "opset1:::", "opset.", "opset::", "wrong"])
|
||||
def test_op_extension_specify_wrong_opset(opset_prefix):
|
||||
skip_if_onnx_frontend_is_disabled()
|
||||
|
||||
# use specific (openvino.frontend) import here
|
||||
# use specific (openvino.frontend.onnx) import here
|
||||
from openvino.frontend.onnx import OpExtension
|
||||
from openvino.runtime import Core
|
||||
|
||||
ie = Core()
|
||||
|
||||
# add extensions
|
||||
fw_operation = "Floor"
|
||||
ov_operation = opset_prefix + fw_operation
|
||||
ie.add_extension(OpExtension(ov_operation, fw_operation))
|
||||
|
||||
with pytest.raises(Exception):
|
||||
ie.read_model(onnx_model_for_op_extension_test)
|
||||
|
||||
|
||||
def test_op_extension_via_onnx_extension_set_attrs_values():
|
||||
skip_if_onnx_frontend_is_disabled()
|
||||
|
||||
# use specific (openvino.frontend.onnx) import here
|
||||
from openvino.frontend.onnx import OpExtension
|
||||
from openvino.runtime import Core
|
||||
|
||||
ie = Core()
|
||||
|
||||
# check the model is valid
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
# add extensions
|
||||
ie.add_extension(OpExtension("Multiply", "Mul", {}, {"auto_broadcast": "numpy"}))
|
||||
ie.add_extension(OpExtension("Elu", {}, {"alpha": 1.}))
|
||||
ie.add_extension(OpExtension("Floor"))
|
||||
ie.add_extension(OpExtension("Concat", {}, {"axis": 0}))
|
||||
ie.add_extension(OpExtension("Convert", "Cast", {}, {"destination_type": "i64"}))
|
||||
ie.add_extension(OpExtension("AvgPool", "AveragePool", {}, {"kernel": [2, 2],
|
||||
"strides": [2, 2],
|
||||
"pads_begin": [0, 0],
|
||||
"pads_end": [1, 1],
|
||||
"exclude-pad": True,
|
||||
"auto_pad": "same_upper",
|
||||
"rounding_type": "floor"}))
|
||||
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
|
||||
def test_op_extension_via_frontend_extension_set_attrs_values():
|
||||
skip_if_onnx_frontend_is_disabled()
|
||||
|
||||
# use common (openvino.frontend) import here
|
||||
from openvino.frontend import OpExtension
|
||||
from openvino.runtime import Core
|
||||
|
||||
ie = Core()
|
||||
ie.add_extension(OpExtension("FW_OV_OP"))
|
||||
ie.add_extension(OpExtension("OV_OP", "FW_OP_1"))
|
||||
ie.add_extension(OpExtension("OV_OP", "FW_OP_2", {"ov_attribute_1": "fw_attribute_1",
|
||||
"ov_attribute_2": "fw_attribute_2"}))
|
||||
ie.add_extension(OpExtension("OV_OP", "FW_OP_3", {"ov_attribute_1": "fw_attribute_1",
|
||||
"ov_attribute_2": "fw_attribute_2"},
|
||||
{"ov_attribute_str": "string",
|
||||
"ov_attribute_int": 4,
|
||||
"ov_attribute_bool": True,
|
||||
"ov_attribute_float": 4.,
|
||||
"ov_attribute_vec_string": ["str1", "str2", "str3"],
|
||||
"ov_attribute_vec_int": [1, 2, 3, 4, 5, 6, 7],
|
||||
"ov_attribute_vec_bool": [True, False, True],
|
||||
"ov_attribute_vec_float": [1., 2., 3., 4., 5., 6., 7.]}))
|
||||
|
||||
model = ie.read_model(onnx_model_filename)
|
||||
# check the model is valid
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
# add extensions
|
||||
ie.add_extension(OpExtension("Multiply", "Mul", {}, {"auto_broadcast": "numpy"}))
|
||||
ie.add_extension(OpExtension("Elu", "Elu", {}, {"alpha": 1.}))
|
||||
ie.add_extension(OpExtension("Floor"))
|
||||
ie.add_extension(OpExtension("Concat", {}, {"axis": 0}))
|
||||
ie.add_extension(OpExtension("Convert", "Cast", {}, {"destination_type": "i64"}))
|
||||
ie.add_extension(OpExtension("AvgPool", "AveragePool", {}, {"kernel": [2, 2],
|
||||
"strides": [2, 2],
|
||||
"pads_begin": [0, 0],
|
||||
"pads_end": [1, 1],
|
||||
"exclude-pad": True,
|
||||
"auto_pad": "same_upper",
|
||||
"rounding_type": "floor"}))
|
||||
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
|
||||
def test_op_extension_via_frontend_extension_map_attributes():
|
||||
skip_if_onnx_frontend_is_disabled()
|
||||
|
||||
# use common (openvino.frontend) import here
|
||||
from openvino.frontend import OpExtension
|
||||
from openvino.runtime import Core
|
||||
|
||||
ie = Core()
|
||||
# check the model is valid
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
# add extensions
|
||||
ie.add_extension(OpExtension("Elu", "Elu", {"alpha": "alpha"}))
|
||||
ie.add_extension(OpExtension("Concat", {"axis": "axis"}, {"axis": 0}))
|
||||
|
||||
ie.add_extension(OpExtension("AvgPool", "AveragePool", {"kernel": "kernel_shape",
|
||||
"strides": "strides",
|
||||
"auto_pad": "auto_pad"},
|
||||
{"pads_begin": [0, 0],
|
||||
"pads_end": [1, 1],
|
||||
"exclude-pad": True,
|
||||
"rounding_type": "floor"}))
|
||||
|
||||
model = ie.read_model(onnx_model_for_op_extension_test)
|
||||
assert model
|
||||
|
||||
@@ -157,6 +157,14 @@ def test_reshape():
|
||||
assert net.input_info["data"].input_data.shape == [2, 3, 32, 32]
|
||||
|
||||
|
||||
def test_reshape_dynamic():
|
||||
ie = IECore()
|
||||
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
|
||||
with pytest.raises(ValueError) as e:
|
||||
net.reshape({"data": (-1, 3, 32, 32)})
|
||||
assert "Detected dynamic dimension in the shape (-1, 3, 32, 32) of the `data` input" in str(e.value)
|
||||
|
||||
|
||||
def test_net_from_buffer_valid():
|
||||
ie = IECore()
|
||||
with open(test_net_bin, 'rb') as f:
|
||||
|
||||
@@ -123,12 +123,16 @@ bool FakeQuantizeDequantization::checkElementwise(const std::shared_ptr<ngraph::
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto channelsDimension = partialShape[1];
|
||||
const auto channelsDimension = partialShape[partialShape.size() > 1ul ? 1ul : 0ul];
|
||||
if (channelsDimension.is_dynamic()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const size_t channelsShapeVal = channelsDimension.get_length();
|
||||
if (constShape.size() == 1ul) {
|
||||
return constShape[0] == channelsShapeVal;
|
||||
}
|
||||
|
||||
const size_t rank = partialShape.rank().get_length();
|
||||
if (constShape.size() == rank) {
|
||||
if ((constShape[0] != 1ul) || (constShape[1] != channelsShapeVal)) {
|
||||
|
||||
@@ -1424,6 +1424,8 @@ FakeQuantizeDequantization NetworkHelper::normalizeDequantization(FakeQuantizeDe
|
||||
if (dequantization.empty()) {
|
||||
return dequantization;
|
||||
}
|
||||
|
||||
// task: 79740
|
||||
if (dequantization.multiply != nullptr && ov::as_type_ptr<ngraph::opset1::Constant>(dequantization.multiply->get_input_node_shared_ptr(0))) {
|
||||
const auto leftParent = dequantization.multiply->input_value(0);
|
||||
const auto rightParent = dequantization.multiply->input_value(1);
|
||||
|
||||
-2
@@ -25,8 +25,6 @@ bool has_valid_pattern(const ov::Output<ov::Node>& node_out) {
|
||||
auto lb = ngraph::evaluate_lower_bound(node_out);
|
||||
if (!lb) return false;
|
||||
const auto lb_const_node = std::make_shared<ngraph::opset8::Constant>(lb);
|
||||
if (!lb_const_node) return false;
|
||||
|
||||
const auto & lb_values = lb_const_node->cast_vector<int64_t>();
|
||||
|
||||
// The pattern is valid if all lower bound values are higher than zero (not a special number)
|
||||
|
||||
@@ -214,7 +214,7 @@ onnx_size_op_single
|
||||
onnx_size_op_graph_end
|
||||
onnx_size_op_graph_middle
|
||||
|
||||
# /openvino/src/plugins/intel_cpu/mkldnn_graph.cpp:747
|
||||
# /openvino/src/plugins/intel_cpu/graph.cpp:747
|
||||
# Output blob byte size is not equal network output byte size (64!=216)." thrown in the test body.
|
||||
onnx_model_quant_conv_linear_3d
|
||||
|
||||
@@ -819,10 +819,6 @@ matmul_0x2_2x0
|
||||
matmul_3x2_2x0
|
||||
matmul_2x3_3x3_int64
|
||||
|
||||
onnx_bool_const_op
|
||||
onnx_bool_init_and
|
||||
onnx_bool_input_or
|
||||
onnx_bool_init_raw
|
||||
shape_of_scalar_v0
|
||||
shape_of_scalar_v3
|
||||
shape_of_vector_v0
|
||||
|
||||
@@ -138,10 +138,5 @@ INTERPRETER.onnx_model_instance_normalization_dyn_shape
|
||||
INTERPRETER.onnx_controlflow_loop_2d_no_identity_termination_cond_false
|
||||
|
||||
# new failures after fixing the TestCase class - 77385
|
||||
onnx_bool_const_op
|
||||
onnx_bool_init_and
|
||||
onnx_bool_input_or
|
||||
onnx_bool_init_raw
|
||||
quant_dequant_pattern_axis
|
||||
onnx_clip_no_min_no_max_int64
|
||||
onnx_constant_sparse_tensor_boolean_3x4
|
||||
|
||||
@@ -45,6 +45,12 @@
|
||||
b,
|
||||
static_cast<ov::element_type_traits<ov::element::i16>::value_type>(rtol),
|
||||
static_cast<ov::element_type_traits<ov::element::i16>::value_type>(atol));
|
||||
case ov::element::boolean:
|
||||
return all_close<ov::element_type_traits<ov::element::boolean>::value_type>(
|
||||
a,
|
||||
b,
|
||||
static_cast<ov::element_type_traits<ov::element::boolean>::value_type>(rtol),
|
||||
static_cast<ov::element_type_traits<ov::element::boolean>::value_type>(atol));
|
||||
case ov::element::i32:
|
||||
return all_close<ov::element_type_traits<ov::element::i32>::value_type>(
|
||||
a,
|
||||
|
||||
@@ -91,12 +91,22 @@ public:
|
||||
|
||||
void on_adapter(const std::string& name, ValueAccessor<void>& adapter) override {
|
||||
auto p_value = m_attr_values_map.find(name);
|
||||
|
||||
if (p_value != m_attr_values_map.end()) {
|
||||
adapter.set_as_any(p_value->second);
|
||||
} else {
|
||||
auto p_name = m_attr_names_map.find(name);
|
||||
const std::string& target_name = p_name != m_attr_names_map.end() ? p_name->second : name;
|
||||
adapter.set_as_any(m_context.get_attribute_as_any(target_name));
|
||||
try {
|
||||
adapter.set_as_any(m_context.get_attribute_as_any(target_name));
|
||||
} catch (::ov::AssertFailure ex) {
|
||||
OPENVINO_ASSERT(false,
|
||||
ex.what(),
|
||||
"\nValue for attribute \"",
|
||||
target_name,
|
||||
"\" is not set or mapping between "
|
||||
"framework and openvino node attributes is incorrect.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -142,7 +152,7 @@ OpExtensionBase<BaseConversionType, void>::OpExtensionBase(const std::string& ov
|
||||
const std::map<std::string, ov::Any>& attr_values_map)
|
||||
: BaseConversionType(fw_type_name,
|
||||
OpConversionFunction(
|
||||
[&]() -> std::shared_ptr<ov::Node> {
|
||||
[=]() -> std::shared_ptr<ov::Node> {
|
||||
auto split = [](const std::string& s, const std::string& delimiter) {
|
||||
size_t pos_start = 0, pos_end, delim_len = delimiter.length();
|
||||
std::string token;
|
||||
@@ -194,7 +204,7 @@ OpExtensionBase<BaseConversionType, void>::OpExtensionBase(const std::string& ov
|
||||
} else {
|
||||
FRONT_END_GENERAL_CHECK(
|
||||
false,
|
||||
"Invalid OpenVINO operation format, one of the next is expected:"
|
||||
"Invalid OpenVINO operation format, one of the next is expected: \n"
|
||||
"opsetN::OpName or opsetN.OpName or OpName. Provided operation format: ",
|
||||
ov_type_name);
|
||||
}
|
||||
@@ -206,7 +216,8 @@ OpExtensionBase<BaseConversionType, void>::OpExtensionBase(const std::string& ov
|
||||
"name ",
|
||||
op_name);
|
||||
}
|
||||
return opset.create(op_name)->shared_from_this();
|
||||
|
||||
return std::shared_ptr<ngraph::Node>(opset.create(op_name));
|
||||
},
|
||||
attr_names_map,
|
||||
attr_values_map)) {}
|
||||
|
||||
@@ -28,13 +28,31 @@ Subgraph Attribute::get_subgraph(const Graph* parent_graph) const {
|
||||
ov::Any Attribute::get_any() const {
|
||||
switch (get_type()) {
|
||||
case Type::float_point:
|
||||
return get_float();
|
||||
// OV has automatic downcasting of node attributes:
|
||||
// double -> float
|
||||
// but upcasting is not supported:
|
||||
// float -> double
|
||||
// so float value from protobuf leads to the issue
|
||||
// when we are trying to get an attribute of double type in ov::Node
|
||||
return static_cast<double>(get_float());
|
||||
case Type::integer:
|
||||
return get_integer();
|
||||
case Type::string:
|
||||
return get_string();
|
||||
case Type::float_point_array:
|
||||
return get_float_array();
|
||||
case Type::float_point_array: {
|
||||
auto float_array = get_float_array();
|
||||
// OV has automatic downcasting of node attributes:
|
||||
// double -> float
|
||||
// but upcasting is not supported:
|
||||
// float -> double
|
||||
// so float value from protobuf leads to the issue
|
||||
// when we are trying to get an attribute of double type in ov::Node
|
||||
std::vector<double> double_array(float_array.size());
|
||||
for (size_t i = 0; i < float_array.size(); ++i) {
|
||||
double_array[i] = static_cast<double>(float_array[i]);
|
||||
}
|
||||
return double_array;
|
||||
}
|
||||
case Type::integer_array:
|
||||
return get_integer_array();
|
||||
case Type::string_array:
|
||||
|
||||
@@ -48,7 +48,6 @@ public:
|
||||
|
||||
ov::Any get_attribute_as_any(const std::string& name) const override {
|
||||
auto res = m_decoder.get_attribute(name);
|
||||
FRONT_END_GENERAL_CHECK(!res.empty(), "Attribute with name '", name, "' does not exist");
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
@@ -165,14 +165,12 @@ const std::string& DecoderProto::get_op_name() const {
|
||||
|
||||
std::vector<::tensorflow::AttrValue> DecoderProto::decode_attribute_helper(const std::string& name) const {
|
||||
auto attr_map = m_node_def->attr();
|
||||
FRONT_END_GENERAL_CHECK(attr_map.contains(name),
|
||||
"An error occurred while parsing the ",
|
||||
name,
|
||||
" attribute of ",
|
||||
this->get_op_type(),
|
||||
"node");
|
||||
auto value = m_node_def->attr().at(name);
|
||||
return {value};
|
||||
if (attr_map.contains(name)) {
|
||||
auto value = m_node_def->attr().at(name);
|
||||
return {value};
|
||||
} else {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
} // namespace tensorflow
|
||||
} // namespace frontend
|
||||
|
||||
@@ -174,9 +174,9 @@ void values_from_const_node(const NodeContext& node, ov::Shape* const_tensor_sha
|
||||
"handle this element type";
|
||||
FRONT_END_THROW("Encountered unknown element type " + DataType_Name(dt) + " on an empty tensor_proto");
|
||||
}
|
||||
TENSORFLOW_OP_VALIDATION(node, val_size != 0, "Empty values vector");
|
||||
|
||||
if (i < val_size) {
|
||||
if (val_size == 0) {
|
||||
(*values)[i] = static_cast<T>(0);
|
||||
} else if (i < val_size) {
|
||||
(*values)[i] = val_i;
|
||||
val_lastsaved = val_i;
|
||||
} else {
|
||||
|
||||
@@ -34,13 +34,17 @@ class INFERENCE_ENGINE_API_CLASS(Core) {
|
||||
std::shared_ptr<Impl> _impl;
|
||||
|
||||
public:
|
||||
/** @brief Constructs Inference Engine Core instance using XML configuration file with
|
||||
* plugins description.
|
||||
/** @brief Constructs an OpenVINO Core instance with devices
|
||||
* and their plugins description.
|
||||
*
|
||||
* See RegisterPlugins for more details.
|
||||
* There are two ways how to configure device plugins:
|
||||
* 1. (default) Use XML configuration file in case of dynamic libraries build;
|
||||
* 2. Use strictly defined configuration in case of static libraries build.
|
||||
*
|
||||
* @param xmlConfigFile A path to .xml file with plugins to load from. If XML configuration file is not specified,
|
||||
* then default Inference Engine plugins are loaded from the default plugin.xml file.
|
||||
* @param xml_config_file Path to the .xml file with plugins to load from. If the XML configuration file is not
|
||||
* specified, default OpenVINO Runtime plugins are loaded from:
|
||||
* 1. (dynamic build) default `plugins.xml` file located in the same folder as OpenVINO runtime shared library;
|
||||
* 2. (static build) statically defined configuration. In this case path to the .xml file is ignored.
|
||||
*/
|
||||
explicit Core(const std::string& xmlConfigFile = {});
|
||||
|
||||
|
||||
@@ -43,14 +43,17 @@ class OPENVINO_RUNTIME_API Core {
|
||||
std::shared_ptr<Impl> _impl;
|
||||
|
||||
public:
|
||||
/** @brief Constructs an OpenVINO Core instance using the XML configuration file with
|
||||
* devices and their plugins description.
|
||||
/** @brief Constructs an OpenVINO Core instance with devices
|
||||
* and their plugins description.
|
||||
*
|
||||
* See Core::register_plugins for more details.
|
||||
* There are two ways how to configure device plugins:
|
||||
* 1. (default) Use XML configuration file in case of dynamic libraries build;
|
||||
* 2. Use strictly defined configuration in case of static libraries build.
|
||||
*
|
||||
* @param xml_config_file Path to the .xml file with plugins to load from. If the XML configuration file is not
|
||||
* specified, default OpenVINO Runtime plugins are loaded from the default `plugin.xml` file located in the same
|
||||
* folder as OpenVINO runtime shared library.
|
||||
* specified, default OpenVINO Runtime plugins are loaded from:
|
||||
* 1. (dynamic build) default `plugins.xml` file located in the same folder as OpenVINO runtime shared library;
|
||||
* 2. (static build) statically defined configuration. In this case path to the .xml file is ignored.
|
||||
*/
|
||||
explicit Core(const std::string& xml_config_file = {});
|
||||
|
||||
|
||||
@@ -453,9 +453,9 @@ public:
|
||||
#ifdef OPENVINO_STATIC_LIBRARY
|
||||
|
||||
/**
|
||||
* @brief Register plugins for devices which are located in .xml configuration file.
|
||||
* @brief Register plugins for devices using statically defined configuration
|
||||
* @note The function supports UNICODE path
|
||||
* @param xmlConfigFile An .xml configuraion with device / plugin information
|
||||
* @param static_registry a statically defined configuration with device / plugin information
|
||||
*/
|
||||
void RegisterPluginsInRegistry(const decltype(::getStaticPluginsRegistry())& static_registry) {
|
||||
std::lock_guard<std::mutex> lock(pluginsMutex);
|
||||
|
||||
@@ -43,16 +43,6 @@ std::string putTime(std::chrono::system_clock::time_point tp, const char* format
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string formatTimeMilli(std::chrono::system_clock::time_point tp) {
|
||||
std::stringstream ss;
|
||||
|
||||
auto milliseconds = (std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch()).count() % 1000);
|
||||
|
||||
ss << putTime(tp, "%T") << '.' << std::setfill('0') << std::setw(3) << milliseconds;
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string getCurrentTime() {
|
||||
std::stringstream ss;
|
||||
|
||||
|
||||
@@ -51,7 +51,6 @@ bool localtimeSafe(const time_t* time, struct tm* result);
|
||||
|
||||
std::string getCurrentTime();
|
||||
std::string putTime(std::chrono::system_clock::time_point tp, const char* format);
|
||||
std::string formatTimeMilli(std::chrono::system_clock::time_point tp); // format tp to HH:MM:SS.mmm
|
||||
} // namespace TimeUtils
|
||||
} // namespace MultiDevicePlugin
|
||||
|
||||
|
||||
@@ -827,7 +827,6 @@ InferenceEngine::IExecutableNetworkInternal::Ptr AutoBatchInferencePlugin::LoadN
|
||||
|
||||
if (!metaDevice.batchForDevice) {
|
||||
unsigned int requests = 0;
|
||||
unsigned int optimalBatchSize = 0;
|
||||
// batch size is not set explicitly via device name e.g. BATCH:GPU(4)
|
||||
// let's query the optimal batch size
|
||||
std::map<std::string, InferenceEngine::Parameter> options;
|
||||
@@ -839,7 +838,7 @@ InferenceEngine::IExecutableNetworkInternal::Ptr AutoBatchInferencePlugin::LoadN
|
||||
if (reqs != config.end())
|
||||
requests = static_cast<unsigned int>(PerfHintsConfig::CheckPerformanceHintRequestValue(reqs->second));
|
||||
if (requests)
|
||||
optBatchSize = std::max(1u, std::min(requests, optimalBatchSize));
|
||||
optBatchSize = std::max(1u, std::min(requests, optBatchSize));
|
||||
if (optBatchSize > 2) // batching is usually in-efficient for batch<4 (as batch1 kernels are heavily optimized)
|
||||
metaDevice.batchForDevice = optBatchSize;
|
||||
else
|
||||
|
||||
@@ -20,7 +20,7 @@ file(GLOB_RECURSE SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
|
||||
file(GLOB_RECURSE HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/src/*.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp)
|
||||
|
||||
addVersionDefines(${CMAKE_CURRENT_SOURCE_DIR}/src/mkldnn_plugin.cpp CI_BUILD_NUMBER)
|
||||
addVersionDefines(${CMAKE_CURRENT_SOURCE_DIR}/src/plugin.cpp CI_BUILD_NUMBER)
|
||||
|
||||
add_subdirectory(thirdparty)
|
||||
|
||||
|
||||
+3
-3
@@ -2,16 +2,16 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include "mkldnn_async_infer_request.h"
|
||||
#include "async_infer_request.h"
|
||||
#include <memory>
|
||||
|
||||
MKLDNNPlugin::MKLDNNAsyncInferRequest::MKLDNNAsyncInferRequest(const InferenceEngine::IInferRequestInternal::Ptr& inferRequest,
|
||||
ov::intel_cpu::MKLDNNAsyncInferRequest::MKLDNNAsyncInferRequest(const InferenceEngine::IInferRequestInternal::Ptr& inferRequest,
|
||||
const InferenceEngine::ITaskExecutor::Ptr& taskExecutor,
|
||||
const InferenceEngine::ITaskExecutor::Ptr& callbackExecutor)
|
||||
: InferenceEngine::AsyncInferRequestThreadSafeDefault(inferRequest, taskExecutor, callbackExecutor) {
|
||||
static_cast<MKLDNNInferRequestBase*>(inferRequest.get())->SetAsyncRequest(this);
|
||||
}
|
||||
|
||||
MKLDNNPlugin::MKLDNNAsyncInferRequest::~MKLDNNAsyncInferRequest() {
|
||||
ov::intel_cpu::MKLDNNAsyncInferRequest::~MKLDNNAsyncInferRequest() {
|
||||
StopAndWait();
|
||||
}
|
||||
+6
-3
@@ -7,9 +7,10 @@
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <cpp_interfaces/impl/ie_infer_async_request_thread_safe_default.hpp>
|
||||
#include "mkldnn_infer_request.h"
|
||||
#include "infer_request.h"
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
class MKLDNNAsyncInferRequest : public InferenceEngine::AsyncInferRequestThreadSafeDefault {
|
||||
public:
|
||||
@@ -19,4 +20,6 @@ public:
|
||||
~MKLDNNAsyncInferRequest();
|
||||
};
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
+5
-2
@@ -8,7 +8,8 @@
|
||||
#include <functional>
|
||||
#include "lru_cache.h"
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
class CacheEntryBase {
|
||||
public:
|
||||
@@ -68,4 +69,6 @@ public:
|
||||
public:
|
||||
ImplType _impl;
|
||||
};
|
||||
}// namespace MKLDNNPlugin
|
||||
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
+4
-2
@@ -15,7 +15,8 @@
|
||||
* @attention This cache implementation IS NOT THREAD SAFE!
|
||||
*/
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
template<typename Key, typename Value>
|
||||
class LruCache {
|
||||
@@ -103,4 +104,5 @@ private:
|
||||
size_t _capacity;
|
||||
};
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
+1
-1
@@ -4,6 +4,6 @@
|
||||
|
||||
#include "multi_cache.h"
|
||||
|
||||
using namespace MKLDNNPlugin;
|
||||
using namespace ov::intel_cpu;
|
||||
|
||||
std::atomic_size_t MultiCache::_typeIdCounter{0};
|
||||
+4
-2
@@ -9,7 +9,8 @@
|
||||
#include <atomic>
|
||||
#include "cache_entry.h"
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
/**
|
||||
* @brief Class that represent a preemptive cache for different key/value pair types.
|
||||
@@ -81,4 +82,5 @@ MultiCache::EntryPtr<KeyType, ValueType> MultiCache::getEntry() {
|
||||
using MultiCachePtr = std::shared_ptr<MultiCache>;
|
||||
using MultiCacheCPtr = std::shared_ptr<const MultiCache>;
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
@@ -18,7 +18,8 @@
|
||||
#include "openvino/runtime/properties.hpp"
|
||||
#include <cpu/x64/cpu_isa_traits.hpp>
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
using namespace InferenceEngine;
|
||||
|
||||
@@ -260,4 +261,6 @@ void Config::readDebugCapsProperties() {
|
||||
}
|
||||
#endif // CPU_DEBUG_CAPS
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
|
||||
@@ -11,7 +11,8 @@
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
struct Config {
|
||||
Config();
|
||||
@@ -71,4 +72,5 @@ struct Config {
|
||||
bool isNewApi = true;
|
||||
};
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
+6
-4
@@ -9,19 +9,20 @@
|
||||
#include <mkldnn_types.h>
|
||||
#include <dnnl_types.h>
|
||||
#include <common/memory_desc_wrapper.hpp>
|
||||
#include "mkldnn_memory.h"
|
||||
#include "cpu_memory.h"
|
||||
#include "nodes/common/cpu_memcpy.h"
|
||||
#include "nodes/common/cpu_convert.h"
|
||||
#include "mkldnn/ie_mkldnn.h"
|
||||
#include "cpu_shape.h"
|
||||
#include "memory_desc/dnnl_blocked_memory_desc.h"
|
||||
#include "nodes/mkldnn_reorder_node.h"
|
||||
#include "nodes/reorder.h"
|
||||
#include "memory_desc/cpu_memory_desc.h"
|
||||
|
||||
using namespace InferenceEngine;
|
||||
using namespace mkldnn;
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
namespace {
|
||||
inline void setSubnormalsToZero(float *data, size_t size) {
|
||||
uint32_t *u32data = reinterpret_cast<uint32_t *>(data);
|
||||
@@ -239,4 +240,5 @@ void DnnlMemoryMngr::notifyUpdate() {
|
||||
}
|
||||
}
|
||||
}
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "ie_layouts.h"
|
||||
#include "memory_desc/cpu_memory_desc.h"
|
||||
#include "mkldnn_extension_utils.h"
|
||||
#include "extension_utils.h"
|
||||
#include "memory_desc/cpu_memory_desc_utils.h"
|
||||
#include <mkldnn.hpp>
|
||||
#include <mkldnn_types.h>
|
||||
@@ -29,7 +29,8 @@
|
||||
*
|
||||
*/
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
class MKLDNNMemory;
|
||||
|
||||
@@ -268,4 +269,5 @@ private:
|
||||
using MKLDNNMemoryPtr = std::shared_ptr<MKLDNNMemory>;
|
||||
using MKLDNNMemoryCPtr = std::shared_ptr<const MKLDNNMemory>;
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
@@ -6,7 +6,7 @@
|
||||
#include "utils/general_utils.h"
|
||||
#include "memory_desc/cpu_memory_desc_utils.h"
|
||||
|
||||
using namespace MKLDNNPlugin;
|
||||
using namespace ov::intel_cpu;
|
||||
|
||||
bool Shape::isCompatible(const VectorDims &vecDims) const {
|
||||
if (getRank() != vecDims.size()) {
|
||||
|
||||
@@ -11,7 +11,8 @@
|
||||
#include <ngraph/partial_shape.hpp>
|
||||
#include "cpu_types.h"
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
class Shape {
|
||||
public:
|
||||
@@ -215,4 +216,6 @@ private:
|
||||
VectorDims maxDims;
|
||||
VectorDims dims;
|
||||
};
|
||||
} // namespace MKLDNNPlugin
|
||||
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
@@ -6,7 +6,8 @@
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
using Dim = std::size_t;
|
||||
using VectorDims = std::vector<Dim>;
|
||||
@@ -486,4 +487,6 @@ std::string algToString(const Algorithm alg) {
|
||||
return "Undefined";
|
||||
}
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
|
||||
@@ -9,7 +9,8 @@
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
using Dim = std::size_t;
|
||||
using VectorDims = std::vector<Dim>;
|
||||
@@ -240,4 +241,6 @@ Type TypeFromName(const std::string& type);
|
||||
std::string NameFromType(const Type type);
|
||||
|
||||
std::string algToString(const Algorithm alg);
|
||||
} // namespace MKLDNNPlugin
|
||||
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
+1
-1
@@ -4,7 +4,7 @@
|
||||
|
||||
#include <ie_common.h>
|
||||
|
||||
#include "mkldnn_descriptor.h"
|
||||
#include "descriptor.h"
|
||||
|
||||
mkldnn::primitive_desc_iterator MKLDNNDescriptor::createPrimitiveDescriptorIterator(const mkldnn::engine &engine,
|
||||
const mkldnn::primitive_attr &attr) const {
|
||||
@@ -66,7 +66,7 @@ Example:
|
||||
OV_CPU_BLOB_DUMP_NODE_TYPE='Convolution Reorder' binary ...
|
||||
```
|
||||
|
||||
> **NOTE**: see **enum Type** in [mkldnn_node.h](../mkldnn_node.h) for list of the types
|
||||
> **NOTE**: see **enum Type** in [node.h](../node.h) for list of the types
|
||||
|
||||
## Filter by name
|
||||
To dump blobs only for nodes with name matching specified regex:
|
||||
|
||||
@@ -2,14 +2,15 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include "mkldnn_edge.h"
|
||||
#include "mkldnn_node.h"
|
||||
#include "mkldnn_extension_utils.h"
|
||||
#include "edge.h"
|
||||
#include "node.h"
|
||||
#include "extension_utils.h"
|
||||
#include <blob_factory.hpp>
|
||||
#include <nodes/mkldnn_input_node.h>
|
||||
#include "nodes/input.h"
|
||||
|
||||
using namespace mkldnn;
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
MKLDNNEdge::MKLDNNEdge(const MKLDNNNodePtr &parent, const MKLDNNNodePtr &child, int pr_port, int ch_port) :
|
||||
parent(parent), child(child), parent_port(pr_port), child_port(ch_port) {}
|
||||
@@ -552,4 +553,5 @@ bool MKLDNNEdge::inPlace(LOOK look) {
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
@@ -8,13 +8,14 @@
|
||||
#include "cpu_shape.h"
|
||||
#include "memory_desc/cpu_memory_desc.h"
|
||||
#include "nodes/node_config.h"
|
||||
#include "mkldnn_weights_cache.hpp"
|
||||
#include "weights_cache.hpp"
|
||||
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
class MKLDNNNode;
|
||||
class MKLDNNEdge;
|
||||
@@ -106,4 +107,6 @@ private:
|
||||
friend class MKLDNNGraph;
|
||||
};
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
@@ -33,7 +33,7 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
MKLDNNPlugin::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t host_isa)
|
||||
ov::intel_cpu::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t host_isa)
|
||||
: TargetMachine(), h(new jit_snippet()), isa(host_isa) {
|
||||
// data movement
|
||||
jitters[ngraph::opset1::Parameter::get_type_info_static()] = CREATE_EMITTER(NopEmitter);
|
||||
@@ -59,65 +59,65 @@ MKLDNNPlugin::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t
|
||||
// jitters[ngraph::opset1::FakeQuantize::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
|
||||
// binary
|
||||
jitters[ngraph::opset1::Add::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_add_emitter);
|
||||
jitters[ngraph::opset1::Divide::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_divide_emitter);
|
||||
jitters[ngraph::opset1::Equal::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_equal_emitter);
|
||||
jitters[ngraph::opset1::FloorMod::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_floor_mod_emitter);
|
||||
jitters[ngraph::opset1::Greater::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_greater_emitter);
|
||||
jitters[ngraph::opset1::GreaterEqual::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_greater_equal_emitter);
|
||||
jitters[ngraph::opset1::Less::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_less_emitter);
|
||||
jitters[ngraph::opset1::LessEqual::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_less_equal_emitter);
|
||||
jitters[ngraph::opset1::LogicalAnd::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_logical_and_emitter);
|
||||
jitters[ngraph::opset1::LogicalOr::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_logical_or_emitter);
|
||||
jitters[ngraph::opset1::LogicalXor::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_logical_xor_emitter);
|
||||
jitters[ngraph::opset1::Maximum::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_maximum_emitter);
|
||||
jitters[ngraph::opset1::Minimum::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_minimum_emitter);
|
||||
jitters[ngraph::opset1::Mod::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_mod_emitter);
|
||||
jitters[ngraph::opset1::Multiply::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_multiply_emitter);
|
||||
jitters[ngraph::opset1::NotEqual::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_not_equal_emitter);
|
||||
jitters[ngraph::snippets::op::PowerStatic::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_power_static_emitter);
|
||||
jitters[ngraph::opset1::Power::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_power_dynamic_emitter);
|
||||
jitters[ngraph::opset1::PRelu::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_prelu_emitter);
|
||||
jitters[ngraph::opset1::SquaredDifference::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_squared_difference_emitter);
|
||||
jitters[ngraph::opset1::Subtract::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_subtract_emitter);
|
||||
jitters[ngraph::opset1::Xor::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_logical_xor_emitter);
|
||||
jitters[ngraph::opset1::Add::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_add_emitter);
|
||||
jitters[ngraph::opset1::Divide::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_divide_emitter);
|
||||
jitters[ngraph::opset1::Equal::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_equal_emitter);
|
||||
jitters[ngraph::opset1::FloorMod::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_floor_mod_emitter);
|
||||
jitters[ngraph::opset1::Greater::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_greater_emitter);
|
||||
jitters[ngraph::opset1::GreaterEqual::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_greater_equal_emitter);
|
||||
jitters[ngraph::opset1::Less::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_less_emitter);
|
||||
jitters[ngraph::opset1::LessEqual::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_less_equal_emitter);
|
||||
jitters[ngraph::opset1::LogicalAnd::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_and_emitter);
|
||||
jitters[ngraph::opset1::LogicalOr::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_or_emitter);
|
||||
jitters[ngraph::opset1::LogicalXor::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_xor_emitter);
|
||||
jitters[ngraph::opset1::Maximum::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_maximum_emitter);
|
||||
jitters[ngraph::opset1::Minimum::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_minimum_emitter);
|
||||
jitters[ngraph::opset1::Mod::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_mod_emitter);
|
||||
jitters[ngraph::opset1::Multiply::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_multiply_emitter);
|
||||
jitters[ngraph::opset1::NotEqual::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_not_equal_emitter);
|
||||
jitters[ngraph::snippets::op::PowerStatic::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_power_static_emitter);
|
||||
jitters[ngraph::opset1::Power::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_power_dynamic_emitter);
|
||||
jitters[ngraph::opset1::PRelu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_prelu_emitter);
|
||||
jitters[ngraph::opset1::SquaredDifference::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_squared_difference_emitter);
|
||||
jitters[ngraph::opset1::Subtract::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_subtract_emitter);
|
||||
jitters[ngraph::opset1::Xor::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_xor_emitter);
|
||||
|
||||
// unary
|
||||
jitters[ngraph::opset1::Abs::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_abs_emitter);
|
||||
jitters[ngraph::opset1::Abs::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_abs_emitter);
|
||||
// jitters[ngraph::opset1::Acos::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ngraph::opset1::Asin::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ngraph::opset1::Atan::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ngraph::opset1::Ceiling::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::opset1::Clamp::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_clamp_emitter);
|
||||
jitters[ngraph::opset1::Clamp::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_clamp_emitter);
|
||||
// jitters[ngraph::opset1::Cos::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ngraph::opset1::Cosh::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::opset1::Elu::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_elu_emitter);
|
||||
jitters[ngraph::opset1::Erf::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_erf_emitter);
|
||||
jitters[ngraph::opset1::Exp::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_exp_emitter);
|
||||
jitters[ngraph::opset1::Elu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_elu_emitter);
|
||||
jitters[ngraph::opset1::Erf::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_erf_emitter);
|
||||
jitters[ngraph::opset1::Exp::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_exp_emitter);
|
||||
// jitters[ngraph::opset1::Floor::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ngraph::opset1::Log::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::opset1::LogicalNot::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_logical_not_emitter);
|
||||
jitters[ngraph::opset1::Negative::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_negative_emitter);
|
||||
jitters[ngraph::opset1::Relu::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_relu_emitter);
|
||||
jitters[ngraph::opset1::LogicalNot::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_not_emitter);
|
||||
jitters[ngraph::opset1::Negative::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_negative_emitter);
|
||||
jitters[ngraph::opset1::Relu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_relu_emitter);
|
||||
// jitters[ngraph::opset1::Sign::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::opset1::Sigmoid::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_sigmoid_emitter);
|
||||
jitters[ngraph::opset1::Sigmoid::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_sigmoid_emitter);
|
||||
// jitters[ngraph::opset1::Sin::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ngraph::opset1::Sinh::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::opset1::Sqrt::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_sqrt_emitter);
|
||||
jitters[ngraph::opset1::Sqrt::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_sqrt_emitter);
|
||||
// jitters[ngraph::opset1::Tan::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::opset1::Tanh::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_tanh_emitter);
|
||||
jitters[ngraph::opset1::Tanh::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_tanh_emitter);
|
||||
|
||||
jitters[ngraph::op::v4::HSwish::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_hswish_emitter);
|
||||
jitters[ngraph::op::v4::HSwish::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_hswish_emitter);
|
||||
// jitters[ngraph::opset1::HardSigmoid::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ngraph::opset1::Selu::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::op::v0::Gelu::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_gelu_v0_emitter);
|
||||
jitters[ngraph::op::v7::Gelu::get_type_info_static()] = CREATE_EMITTER(MKLDNNPlugin::jit_gelu_v7_emitter);
|
||||
jitters[ngraph::op::v0::Gelu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_gelu_v0_emitter);
|
||||
jitters[ngraph::op::v7::Gelu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_gelu_v7_emitter);
|
||||
|
||||
jitters[ngraph::snippets::op::Kernel::get_type_info_static()] = CREATE_EMITTER(KernelEmitter);
|
||||
jitters[ngraph::snippets::op::Tile::get_type_info_static()] = CREATE_EMITTER(TileEmitter);
|
||||
}
|
||||
|
||||
size_t MKLDNNPlugin::CPUTargetMachine::get_lanes() const {
|
||||
size_t ov::intel_cpu::CPUTargetMachine::get_lanes() const {
|
||||
switch (isa) {
|
||||
case dnnl::impl::cpu::x64::avx2 : return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx2>::vlen / sizeof(float);
|
||||
case dnnl::impl::cpu::x64::sse41 : return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::sse41>::vlen / sizeof(float);
|
||||
@@ -126,14 +126,14 @@ size_t MKLDNNPlugin::CPUTargetMachine::get_lanes() const {
|
||||
}
|
||||
}
|
||||
|
||||
bool MKLDNNPlugin::CPUTargetMachine::is_supported() const {
|
||||
bool ov::intel_cpu::CPUTargetMachine::is_supported() const {
|
||||
return dnnl::impl::cpu::x64::mayiuse(isa);
|
||||
}
|
||||
|
||||
code MKLDNNPlugin::CPUTargetMachine::get_snippet() const {
|
||||
code ov::intel_cpu::CPUTargetMachine::get_snippet() const {
|
||||
h->create_kernel();
|
||||
return h->jit_ker();
|
||||
}
|
||||
|
||||
MKLDNNPlugin::CPUGenerator::CPUGenerator(dnnl::impl::cpu::x64::cpu_isa_t isa_) : Generator(std::make_shared<CPUTargetMachine>(isa_)) {
|
||||
ov::intel_cpu::CPUGenerator::CPUGenerator(dnnl::impl::cpu::x64::cpu_isa_t isa_) : Generator(std::make_shared<CPUTargetMachine>(isa_)) {
|
||||
}
|
||||
|
||||
@@ -9,7 +9,8 @@
|
||||
|
||||
#include "snippets/generator.hpp"
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
class CPUTargetMachine : public ngraph::snippets::TargetMachine {
|
||||
public:
|
||||
@@ -30,4 +31,5 @@ public:
|
||||
~CPUGenerator() = default;
|
||||
};
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
@@ -6,7 +6,8 @@
|
||||
|
||||
#include "jit_emitter.hpp"
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
class jit_emu_vcvtneps2bf16 : public jit_emitter {
|
||||
public:
|
||||
@@ -71,4 +72,5 @@ private:
|
||||
size_t aux_vecs_count() const override { return 2; }
|
||||
};
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
#include "jit_eltwise_emitters.hpp"
|
||||
#include <cpu/x64/jit_uni_eltwise.hpp>
|
||||
#include <ngraph/opsets/opset1.hpp>
|
||||
#include <nodes/mkldnn_eltwise_node.h>
|
||||
#include <nodes/eltwise.h>
|
||||
|
||||
using namespace InferenceEngine;
|
||||
using namespace mkldnn::impl::utils;
|
||||
@@ -13,7 +13,8 @@ using namespace mkldnn::impl;
|
||||
using namespace mkldnn::impl::cpu::x64;
|
||||
using namespace Xbyak;
|
||||
|
||||
namespace MKLDNNPlugin {
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
/// ADD ///
|
||||
jit_add_emitter::jit_add_emitter(jit_generator *host, cpu_isa_t host_isa, const std::shared_ptr<ngraph::Node>& node, Precision exec_prc)
|
||||
@@ -1776,4 +1777,5 @@ size_t jit_erf_emitter::aux_vecs_count() const {
|
||||
return 5ul;
|
||||
}
|
||||
|
||||
} // namespace MKLDNNPlugin
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user