IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Python API] Add InputInfo and PreProcessInfo (#637)

Browse Source
This commit is contained in:
Anastasia Kuporosova
2020-05-28 10:55:11 +03:00
committed by GitHub
parent 125dd89c01
commit e025f1464b
23 changed files with 832 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
inference-engine/ie_bridges/python/sample/classification_sample/classification_sample.py
View File

@@ -73,16 +73,16 @@ def main():
"or --cpu_extension command line argument")
sys.exit(1)
assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(net.input_info.keys()) == 1, "Sample supports only single input topologies"
assert len(net.outputs) == 1, "Sample supports only single output topologies"
log.info("Preparing input blobs")
input_blob = next(iter(net.inputs))
input_blob = next(iter(net.input_info))
out_blob = next(iter(net.outputs))
net.batch_size = len(args.input)
# Read and pre-process input images
n, c, h, w = net.inputs[input_blob].shape
n, c, h, w = net.input_info[input_blob].input_data.shape
images = np.ndarray(shape=(n, c, h, w))
for i in range(n):
image = cv2.imread(args.input[i])

8
inference-engine/ie_bridges/python/sample/classification_sample_async/classification_sample_async.py
View File

@@ -117,16 +117,16 @@ def main():
log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
"or --cpu_extension command line argument")
sys.exit(1)
assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(net.input_info.keys()) == 1, "Sample supports only single input topologies"
assert len(net.outputs) == 1, "Sample supports only single output topologies"
log.info("Preparing input blobs")
input_blob = next(iter(net.inputs))
input_blob = next(iter(net.input_info))
out_blob = next(iter(net.outputs))
net.batch_size = len(args.input)
# Read and pre-process input images
n, c, h, w = net.inputs[input_blob].shape
n, c, h, w = net.input_info[input_blob].input_data.shape
images = np.ndarray(shape=(n, c, h, w))
for i in range(n):
image = cv2.imread(args.input[i])
@@ -143,7 +143,7 @@ def main():
# create one inference request for asynchronous execution
request_id = 0
infer_request = exec_net.requests[request_id];
infer_request = exec_net.requests[request_id]
num_iter = 10
request_wrap = InferReqWrap(infer_request, request_id, num_iter)

28
inference-engine/ie_bridges/python/sample/object_detection_sample_ssd/object_detection_sample_ssd.py
View File

@@ -84,13 +84,13 @@ def main():
# --------------------------- 3. Read and preprocess input --------------------------------------------
print("inputs number: " + str(len(net.inputs.keys())))
print("inputs number: " + str(len(net.input_info.keys())))
for input_key in net.inputs:
print("input shape: " + str(net.inputs[input_key].shape))
for input_key in net.input_info:
print("input shape: " + str(net.input_info[input_key].input_data.shape))
print("input key: " + input_key)
if len(net.inputs[input_key].layout) == 4:
n, c, h, w = net.inputs[input_key].shape
if len(net.input_info[input_key].input_data.layout) == 4:
n, c, h, w = net.input_info[input_key].input_data.shape
images = np.ndarray(shape=(n, c, h, w))
images_hw = []
@@ -111,21 +111,21 @@ def main():
# --------------------------- 4. Configure input & output ---------------------------------------------
# --------------------------- Prepare input blobs -----------------------------------------------------
log.info("Preparing input blobs")
assert (len(net.inputs.keys()) == 1 or len(
net.inputs.keys()) == 2), "Sample supports topologies only with 1 or 2 inputs"
assert (len(net.input_info.keys()) == 1 or len(
net.input_info.keys()) == 2), "Sample supports topologies only with 1 or 2 inputs"
out_blob = next(iter(net.outputs))
input_name, input_info_name = "", ""
for input_key in net.inputs:
if len(net.inputs[input_key].layout) == 4:
for input_key in net.input_info:
if len(net.input_info[input_key].layout) == 4:
input_name = input_key
log.info("Batch size is {}".format(net.batch_size))
net.inputs[input_key].precision = 'U8'
elif len(net.inputs[input_key].layout) == 2:
net.input_info[input_key].precision = 'U8'
elif len(net.input_info[input_key].layout) == 2:
input_info_name = input_key
net.inputs[input_key].precision = 'FP32'
if net.inputs[input_key].shape[1] != 3 and net.inputs[input_key].shape[1] != 6 or \
net.inputs[input_key].shape[0] != 1:
net.input_info[input_key].precision = 'FP32'
if net.input_info[input_key].input_data.shape[1] != 3 and net.input_info[input_key].input_data.shape[1] != 6 or \
net.input_info[input_key].input_data.shape[0] != 1:
log.error('Invalid input info. Should be 3 or 6 values length.')
data = {}

6
inference-engine/ie_bridges/python/sample/style_transfer_sample/style_transfer_sample.py
View File

@@ -77,16 +77,16 @@ def main():
"or --cpu_extension command line argument")
sys.exit(1)
assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
assert len(net.input_info.keys()) == 1, "Sample supports only single input topologies"
assert len(net.outputs) == 1, "Sample supports only single output topologies"
log.info("Preparing input blobs")
input_blob = next(iter(net.inputs))
input_blob = next(iter(net.input_info))
out_blob = next(iter(net.outputs))
net.batch_size = len(args.input)
# Read and pre-process input images
n, c, h, w = net.inputs[input_blob].shape
n, c, h, w = net.input_info[input_blob].input_data.shape
images = np.ndarray(shape=(n, c, h, w))
for i in range(n):
image = cv2.imread(args.input[i])

2
inference-engine/ie_bridges/python/src/openvino/inference_engine/__init__.py
View File

@@ -1,4 +1,4 @@
from .ie_api import *
__all__ = ['IENetwork', "IETensorDesc", "IECore", "IEBlob", "get_version"]
__all__ = ['IENetwork', "TensorDesc", "IECore", "Blob", "get_version"]
__version__ = get_version()

24
inference-engine/ie_bridges/python/src/openvino/inference_engine/constants.pyx
View File

@@ -16,6 +16,7 @@
from .cimport ie_api_impl_defs as C
import numpy as np
from enum import Enum
supported_precisions = ["FP32", "FP16", "I64", "U64", "I32", "I16", "I8", "U16", "U8"]
@@ -54,6 +55,28 @@ layout_str_to_enum = {'ANY': C.Layout.ANY,
}
class MeanVariant(Enum):
MEAN_IMAGE = 0
MEAN_VALUE = 1
NONE = 2
class ResizeAlgorithm(Enum):
NO_RESIZE = 0
RESIZE_BILINEAR = 1
RESIZE_AREA = 2
class ColorFormat(Enum):
RAW = 0
RGB = 1
BGR = 2
RGBX = 3
BGRX = 4
NV12 = 5
I420 = 6
cpdef enum StatusCode:
OK = 0
GENERAL_ERROR = -1
@@ -69,6 +92,7 @@ cpdef enum StatusCode:
INFER_NOT_STARTED = -11
NETWORK_NOT_READ = -12
cpdef enum WaitMode:
RESULT_READY = -1
STATUS_ONLY = 0

28
inference-engine/ie_bridges/python/src/openvino/inference_engine/ie_api.pxd
View File

@@ -1,5 +1,5 @@
from .cimport ie_api_impl_defs as C
from .ie_api_impl_defs cimport Blob, TensorDesc
from .ie_api_impl_defs cimport CBlob, CTensorDesc, InputInfo, CPreProcessChannel, CPreProcessInfo
from pathlib import Path
@@ -8,18 +8,18 @@ from libcpp.vector cimport vector
from libcpp cimport bool
from libcpp.memory cimport unique_ptr, shared_ptr
cdef class IEBlob:
cdef Blob.Ptr _ptr
cdef class Blob:
cdef CBlob.Ptr _ptr
cdef public object _array_data
cdef public object _initial_shape
cdef class BlobBuffer:
cdef Blob.Ptr ptr
cdef CBlob.Ptr ptr
cdef char*format
cdef vector[Py_ssize_t] shape
cdef vector[Py_ssize_t] strides
cdef reset(self, Blob.Ptr &, vector[size_t] representation_shape = ?)
cdef char*_get_blob_format(self, const TensorDesc & desc)
cdef reset(self, CBlob.Ptr &, vector[size_t] representation_shape = ?)
cdef char*_get_blob_format(self, const CTensorDesc & desc)
cdef public:
total_stride, item_size
@@ -76,5 +76,17 @@ cdef class CDataPtr:
cdef class IENetLayer:
cdef C.CNNLayerPtr _ptr
cdef class IETensorDesc:
cdef C.TensorDesc impl
cdef class TensorDesc:
cdef C.CTensorDesc impl
cdef class InputInfoPtr:
cdef InputInfo.Ptr _ptr
cdef class InputInfoCPtr:
cdef InputInfo.CPtr _ptr
cdef class PreProcessInfo:
cdef CPreProcessInfo* _ptr
cdef class PreProcessChannel:
cdef CPreProcessChannel.Ptr _ptr

333
inference-engine/ie_bridges/python/src/openvino/inference_engine/ie_api.pyx
View File

@@ -8,6 +8,7 @@ from libcpp.map cimport map
from libcpp.memory cimport unique_ptr
from libc.stdlib cimport malloc, free
from libc.stdint cimport int64_t, uint8_t, int8_t, int32_t, uint16_t, int16_t
from libc.stddef cimport size_t
from libc.string cimport memcpy
import os
@@ -20,8 +21,8 @@ from collections import OrderedDict, namedtuple
from .cimport ie_api_impl_defs as C
from .ie_api_impl_defs cimport SizeVector, Precision
from .constants import supported_precisions, known_plugins, layout_int_to_str_map, \
format_map, layout_str_to_enum, StatusCode, WaitMode
from .constants import WaitMode, StatusCode, MeanVariant, layout_str_to_enum, format_map, layout_int_to_str_map,\
known_plugins, supported_precisions, ResizeAlgorithm, ColorFormat
import numpy as np
@@ -53,13 +54,13 @@ def get_version():
return C.get_version().decode()
## This class defines Tensor description
cdef class IETensorDesc:
def __eq__(self, other : IETensorDesc):
cdef class TensorDesc:
def __eq__(self, other : TensorDesc):
return self.layout == other.layout and self.precision == other.precision and self.dims == other.dims
def __ne__(self, other : IETensorDesc):
def __ne__(self, other : TensorDesc):
return self.layout != other.layout or self.precision != other.precision or self.dims != other.dims
def __deepcopy__(self, memodict={}):
return IETensorDesc(deepcopy(self.precision, memodict), deepcopy(self.dims, memodict), deepcopy(self.layout, memodict))
return TensorDesc(deepcopy(self.precision, memodict), deepcopy(self.dims, memodict), deepcopy(self.layout, memodict))
## Class constructor
# @param precision: target memory precision
# @param dims: target memory dimensions
@@ -69,15 +70,15 @@ cdef class IETensorDesc:
if precision not in supported_precisions:
raise ValueError("Unsupported precision {}! List of supported precisions: {}".format(precision,
supported_precisions))
self.impl = C.TensorDesc(C.Precision.FromStr(precision.encode()), dims, layout_str_to_enum[layout])
## Shape (dimensions) of the IETensorDesc object
self.impl = C.CTensorDesc(C.Precision.FromStr(precision.encode()), dims, layout_str_to_enum[layout])
## Shape (dimensions) of the TensorDesc object
@property
def dims(self):
return self.impl.getDims()
@dims.setter
def dims(self, dims_array : [list, tuple]):
self.impl.setDims(dims_array)
## Precision of the IETensorDesc object
## Precision of the TensorDesc object
@property
def precision(self):
return self.impl.getPrecision().name().decode()
@@ -87,7 +88,7 @@ cdef class IETensorDesc:
raise ValueError("Unsupported precision {}! List of supported precisions: {}".format(precision,
supported_precisions))
self.impl.setPrecision(C.Precision.FromStr(precision.encode()))
## Layout of the IETensorDesc object
## Layout of the TensorDesc object
@property
def layout(self):
return layout_int_to_str_map[self.impl.getLayout()]
@@ -99,16 +100,16 @@ cdef class IETensorDesc:
self.impl.setLayout(layout_str_to_enum[layout])
## This class represents Blob
cdef class IEBlob:
cdef class Blob:
## Class constructor
# @param tensor_desc: IETensorDesc object describing creating IEBlob object.
# @param tensor_desc: TensorDesc object describing creating Blob object.
# @param array: numpy.ndarray with data to fill blob memory, The array have to have same elements count
# as specified in tensor_desc.dims attribute and same elements precision corresponding to
# tensor_desc.precision. If array isn't provided empty numpy.ndarray will be created accorsing
# to parameters of tensor_desc
# @return Instance of IEBlob class
def __cinit__(self, IETensorDesc tensor_desc = None, array : np.ndarray = None):
cdef TensorDesc c_tensor_desc
# @return Instance of Blob class
def __cinit__(self, TensorDesc tensor_desc = None, array : np.ndarray = None):
cdef CTensorDesc c_tensor_desc
cdef float[::1] fp32_array_memview
cdef int16_t[::1] I16_array_memview
cdef uint16_t[::1] U16_array_memview
@@ -188,11 +189,11 @@ cdef class IEBlob:
raise AttributeError("Unsupported precision {} for blob".format(precision))
def __deepcopy__(self, memodict):
res = IEBlob(deepcopy(self.tensor_desc, memodict), deepcopy(self._array_data, memodict))
res = Blob(deepcopy(self.tensor_desc, memodict), deepcopy(self._array_data, memodict))
res.buffer[:] = deepcopy(self.buffer[:], memodict)
return res
## IEBlob's memory as numpy.ndarray representation
## Blob's memory as numpy.ndarray representation
@property
def buffer(self):
representation_shape = self._initial_shape if self._initial_shape is not None else []
@@ -200,14 +201,14 @@ cdef class IEBlob:
buffer.reset(self._ptr, representation_shape)
return buffer.to_numpy()
## IETensorDesc of created IEBlob
## TensorDesc of created Blob
@property
def tensor_desc(self):
cdef TensorDesc c_tensor_desc = deref(self._ptr).getTensorDesc()
cdef CTensorDesc c_tensor_desc = deref(self._ptr).getTensorDesc()
precision = c_tensor_desc.getPrecision().name().decode()
layout = c_tensor_desc.getLayout()
dims = c_tensor_desc.getDims()
tensor_desc = IETensorDesc(precision, dims, layout_int_to_str_map[layout])
tensor_desc = TensorDesc(precision, dims, layout_int_to_str_map[layout])
return tensor_desc
## This class represents an Inference Engine entity and allows you to manipulate with plugins using unified interfaces.
@@ -331,7 +332,7 @@ cdef class IECore:
# ```python
# ie = IECore()
# net = ie.read_network(model=path_to_xml_file, weights=path_to_bin_file)
# exec_net = ie.load_network(network=net, device_name="MYRIAD", num_requsts=2)
# exec_net = ie.load_network(network=net, device_name="MYRIAD", num_requests=2)
# # export executable network
# exec_net.export(path_to_file_to_save)
# # import previously exported executable network
@@ -477,40 +478,240 @@ cdef class IECore:
cdef vector[string] c_devices = self.impl.getAvailableDevices()
return [d.decode() for d in c_devices]
## This structure stores info about pre-processing of network inputs (scale, mean image, ...)
cdef class PreProcessChannel:
property mean_value:
def __get__(self):
return deref(self._ptr).meanValue
def __set__(self, float mean_value):
deref(self._ptr).meanValue = mean_value
property std_scale:
def __get__(self):
return deref(self._ptr).stdScale
def __set__(self, float std_scale):
deref(self._ptr).stdScale = std_scale
property mean_data:
def __get__(self):
blob = Blob()
blob._ptr = deref(self._ptr).meanData
return blob
def __set__(self, Blob mean_data):
deref(self._ptr).meanData = mean_data._ptr
## This class stores pre-process information for the input
cdef class PreProcessInfo:
def __getitem__(self, size_t index):
cdef CPreProcessChannel.Ptr c_channel = deref(self._ptr)[index]
channel = PreProcessChannel()
channel._ptr = c_channel
return channel
## Returns a number of channels to preprocess
def get_number_of_channels(self):
return deref(self._ptr).getNumberOfChannels()
## Initializes with given number of channels
def init(self, const size_t number_of_channels):
deref(self._ptr).init(number_of_channels)
## Sets mean image values if operation is applicable.
# Also sets the mean type to MEAN_IMAGE for all channels
def set_mean_image(self, Blob mean_image):
deref(self._ptr).setMeanImage(mean_image._ptr)
## Sets mean image values if operation is applicable.
# Also sets the mean type to MEAN_IMAGE for a particular channel
def set_mean_image_for_channel(self, Blob mean_image, size_t channel):
deref(self._ptr).setMeanImageForChannel(mean_image._ptr, channel)
## Mean Variant to be applied for input before inference if needed.
#
# Usage example:\n
# ```python
# net = ie_core.read_network(model=path_to_xml_file, weights=path_to_bin_file)
# net.input_info['data'].preprocess_info.mean_variant = MeanVariant.MEAN_IMAGE
# ```
@property
def mean_variant(self):
return MeanVariant(deref(self._ptr).getMeanVariant())
@mean_variant.setter
def mean_variant(self, variant : MeanVariant):
deref(self._ptr).setVariant(variant.value)
## Resize Algorithm to be applied for input before inference if needed.
#
# Usage example:\n
# ```python
# net = ie_core.read_network(model=path_to_xml_file, weights=path_to_bin_file)
# net.input_info['data'].preprocess_info.resize_algorithm = ResizeAlgorithm.RESIZE_BILINEAR
# ```
@property
def resize_algorithm(self):
return ResizeAlgorithm(deref(self._ptr).getResizeAlgorithm())
@resize_algorithm.setter
def resize_algorithm(self, alg : ResizeAlgorithm):
deref(self._ptr).setResizeAlgorithm(alg.value)
## Color format to be used in on-demand color conversions applied to input before inference
#
# Usage example:\n
# ```python
# net = ie_core.read_network(model=path_to_xml_file, weights=path_to_bin_file)
# net.input_info['data'].preprocess_info.color_format = ColorFormat.BGR
# ```
@property
def color_format(self):
return ColorFormat(deref(self._ptr).getColorFormat())
@color_format.setter
def color_format(self, fmt : ColorFormat):
deref(self._ptr).setColorFormat(fmt.value)
## This class contains information about each input of the network
cdef class InputInfoPtr:
## Name of this input
@property
def name(self):
return deref(self._ptr).name().decode()
## Precision of this input
@property
def precision(self):
return deref(self._ptr).getPrecision().name().decode()
@precision.setter
def precision(self, precision : str):
if precision not in supported_precisions:
raise ValueError("Unsupported precision {}! List of supported precisions: {}".format(precision,
supported_precisions))
deref(self._ptr).setPrecision(C.Precision.FromStr(precision.encode()))
## Layout of this input
@property
def layout(self):
return layout_int_to_str_map[deref(self._ptr).getLayout()]
@layout.setter
def layout(self, layout : str):
if layout not in layout_str_to_enum.keys():
raise ValueError("Unsupported layout {}! "
"List of supported layouts: {}".format(layout, list(layout_str_to_enum.keys())))
deref(self._ptr).setLayout(layout_str_to_enum[layout])
## Gets pre-process info for the input
#
# Usage example:\n
# ```python
# net = ie_core.read_network(model=path_to_xml_file, weights=path_to_bin_file)
# net.input_info['data'].preprocess_info.color_format = ColorFormat.BGR
# ```
@property
def preprocess_info(self):
cdef CPreProcessInfo* c_preprocess_info = &deref(self._ptr).getPreProcess()
preprocess_info = PreProcessInfo()
preprocess_info._ptr = c_preprocess_info
return preprocess_info
@property
def tensor_desc(self):
cdef CTensorDesc c_tensor_desc = deref(self._ptr).getTensorDesc()
precision = c_tensor_desc.getPrecision().name().decode()
layout = c_tensor_desc.getLayout()
dims = c_tensor_desc.getDims()
tensor_desc = TensorDesc(precision, dims, layout_int_to_str_map[layout])
tensor_desc.impl = c_tensor_desc
return tensor_desc
## Get access to DataPtr object
@property
def input_data(self):
cdef C.DataPtr c_data_ptr = deref(self._ptr).getInputData()
data_ptr = DataPtr()
data_ptr._ptr = c_data_ptr
return data_ptr
@input_data.setter
def input_data(self, input_ptr : DataPtr):
deref(self._ptr).setInputData(input_ptr._ptr)
## This class contains const information about each input of the network.
# Provides same interface as InputInfoPtr object except properties setters
cdef class InputInfoCPtr:
## Name of this input
@property
def name(self):
return deref(self._ptr).name().decode()
## Precision of this input
@property
def precision(self):
return deref(self._ptr).getPrecision().name().decode()
## Get access to DataPtr object
@property
def input_data(self):
cdef C.DataPtr c_data_ptr = deref(self._ptr).getInputData()
data_ptr = DataPtr()
data_ptr._ptr = c_data_ptr
return data_ptr
## tensor_desc of this input
@property
def tensor_desc(self):
cdef CTensorDesc c_tensor_desc = deref(self._ptr).getTensorDesc()
precision = c_tensor_desc.getPrecision().name().decode()
layout = c_tensor_desc.getLayout()
dims = c_tensor_desc.getDims()
tensor_desc = TensorDesc(precision, dims, layout_int_to_str_map[layout])
tensor_desc.impl = c_tensor_desc
return tensor_desc
## This class is the layer data representation.
cdef class DataPtr:
## Name of the data object
@property
def name(self):
return deref(self._ptr).getName().decode()
## Precision of the data object
@property
def precision(self):
return deref(self._ptr).getPrecision().name().decode()
@precision.setter
def precision(self, precision):
if precision not in supported_precisions:
raise ValueError("Unsupported precision {}! List of supported precisions: {}".format(precision,
supported_precisions))
deref(self._ptr).setPrecision(C.Precision.FromStr(precision.encode()))
## Shape (dimensions) of the data object
@property
def shape(self):
return deref(self._ptr).getDims()
## Layout of the data object
@property
def layout(self):
return layout_int_to_str_map[deref(self._ptr).getLayout()]
@layout.setter
def layout(self, layout):
if layout not in layout_str_to_enum.keys():
raise ValueError("Unsupported layout {}! "
"List of supported layouts: {}".format(layout, list(layout_str_to_enum.keys())))
deref(self._ptr).setLayout(layout_str_to_enum[layout])
## Checks if the current data object is resolved
@property
def initialized(self):
return deref(self._ptr).isInitialized()
@property
def creator_layer(self):
cdef C.CNNLayerWeakPtr _l_ptr = deref(self._ptr).getCreatorLayer()
@@ -521,6 +722,7 @@ cdef class DataPtr:
else:
raise RuntimeError("Creator IENetLayer of DataPtr object with name {} already released!".format(self.name))
return creator_layer
@property
def input_to(self):
cdef map[string, C.CNNLayerPtr] _l_ptr_map = deref(self._ptr).getInputTo()
@@ -641,7 +843,7 @@ cdef class ExecutableNetwork:
for i in range(deref(self.impl).infer_requests.size()):
infer_request = InferRequest()
infer_request.impl = &(deref(self.impl).infer_requests[i])
infer_request._inputs_list = list(self.inputs.keys())
infer_request._inputs_list = list(self.input_info.keys())
infer_request._outputs_list = list(self.outputs.keys())
self._infer_requests.append(infer_request)
@@ -649,9 +851,30 @@ cdef class ExecutableNetwork:
raise Exception("Mismatch of infer requests number!")
return self._infer_requests
## A dictionary that maps input layer names to InputInfoCPtr objects
@property
def input_info(self):
cdef map[string, C.InputInfo.CPtr] c_inputs = deref(self.impl).getInputsInfo()
inputs = {}
cdef InputInfoCPtr input_info_ptr
for in_ in c_inputs:
input_info_ptr = InputInfoCPtr()
input_info_ptr._ptr = in_.second
inputs[in_.first.decode()] = input_info_ptr
return inputs
## \note The property is deprecated. Please use the input_info property
# to get the map of inputs
#
## A dictionary that maps input layer names to DataPtr objects
@property
def inputs(self):
warnings.filterwarnings("always", category=DeprecationWarning)
warnings.warn("'inputs' property of ExecutableNetwork class is deprecated. "
"To access DataPtrs user need to use 'input_data' property "
"of InputInfoCPtr objects which can be acessed by 'input_info' property.",
DeprecationWarning)
cdef map[string, C.DataPtr] c_inputs = deref(self.impl).getInputs()
inputs = {}
cdef DataPtr data_ptr
@@ -723,7 +946,7 @@ cdef class ExecutableNetwork:
# ```python
# ie = IECore()
# net = ie.read_network(model=path_to_xml_file, weights=path_to_bin_file)
# exec_net = ie.load_network(network=net, device_name="MYRIAD", num_requsts=2)
# exec_net = ie.load_network(network=net, device_name="MYRIAD", num_requests=2)
# exec_net.export(path_to_file_to_save)
# ```
def export(self, model_file: str):
@@ -796,12 +1019,12 @@ cdef class InferRequest:
cpdef BlobBuffer _get_blob_buffer(self, const string & blob_name):
cdef BlobBuffer buffer = BlobBuffer()
cdef Blob.Ptr blob_ptr
cdef CBlob.Ptr blob_ptr
deref(self.impl).getBlobPtr(blob_name, blob_ptr)
buffer.reset(blob_ptr)
return buffer
## Dictionary that maps input layer names to corresponding IEBlobs
## Dictionary that maps input layer names to corresponding Blobs
@property
def input_blobs(self):
input_blobs = {}
@@ -810,24 +1033,24 @@ cdef class InferRequest:
if input in self._user_blobs:
input_blobs[input] = self._user_blobs[input]
else:
blob = IEBlob()
blob = Blob()
deref(self.impl).getBlobPtr(input.encode(), blob._ptr)
input_blobs[input] = blob
return input_blobs
## Dictionary that maps output layer names to corresponding IEBlobs
## Dictionary that maps output layer names to corresponding Blobs
@property
def output_blobs(self):
output_blobs = {}
for output in self._outputs_list:
blob = IEBlob()
blob = Blob()
deref(self.impl).getBlobPtr(output.encode(), blob._ptr)
output_blobs[output] = deepcopy(blob)
return output_blobs
## Sets user defined IEBlob for the infer request
## Sets user defined Blob for the infer request
# @param blob_name: A name of input blob
# @param blob: IEBlob object to set for the infer request
# @param blob: Blob object to set for the infer request
# @return None
#
# Usage example:\n
@@ -835,12 +1058,12 @@ cdef class InferRequest:
# ie = IECore()
# net = IENetwork("./model.xml", "./model.bin")
# exec_net = ie.load_network(net, "CPU", num_requests=2)
# td = IETensorDesc("FP32", (1, 3, 224, 224), "NCHW")
# td = TensorDesc("FP32", (1, 3, 224, 224), "NCHW")
# blob_data = np.ones(shape=(1, 3, 224, 224), dtype=np.float32)
# blob = IEBlob(td, blob_data)
# blob = Blob(td, blob_data)
# exec_net.requests[0].set_blob(blob_name="input_blob_name", blob=blob),
# ```
def set_blob(self, blob_name : str, blob : IEBlob):
def set_blob(self, blob_name : str, blob : Blob):
deref(self.impl).setBlob(blob_name.encode(), blob._ptr)
self._user_blobs[blob_name] = blob
## Starts synchronous inference of the infer request and fill outputs array
@@ -1192,7 +1415,7 @@ cdef class IENetLayer:
## Dictionary with layer arbitrary layer blobs including weights and biases as any.
@property
def blobs(self):
cdef map[string, Blob.Ptr] c_blobs_map
cdef map[string, CBlob.Ptr] c_blobs_map
c_blobs_map = deref(self._ptr).blobs
blobs_map = {}
cdef BlobBuffer weights_buffer
@@ -1201,6 +1424,7 @@ cdef class IENetLayer:
weights_buffer.reset(blob.second)
blobs_map[blob.first.decode()] = weights_buffer.to_numpy()
return blobs_map
## \note This property is deprecated.
# Please use blobs property instead.
#
@@ -1292,9 +1516,29 @@ cdef class IENetwork:
name = bytes(self.impl.name)
return name.decode()
## A dictionary that maps input layer names to DataPtr objects.
## A dictionary that maps input layer names to InputInfoPtr objects.
@property
def input_info(self):
cdef map[string, C.InputInfo.Ptr] c_inputs = self.impl.getInputsInfo()
inputs = {}
cdef InputInfoPtr input_info_ptr
for input in c_inputs:
input_info_ptr = InputInfoPtr()
input_info_ptr._ptr = input.second
inputs[input.first.decode()] = input_info_ptr
return inputs
## \note The property is deprecated. Please use the input_info property
# to get the map of inputs
#
## A dictionary that maps input layer names to DataPtr objects
@property
def inputs(self):
warnings.filterwarnings("always", category=DeprecationWarning)
warnings.warn("'inputs' property of IENetwork class is deprecated. "
"To access DataPtrs user need to use 'input_data' property "
"of InputInfoPtr objects which can be acessed by 'input_info' property.",
DeprecationWarning)
cdef map[string, C.DataPtr] c_inputs = self.impl.getInputs()
inputs = {}
cdef DataPtr data_ptr
@@ -1324,11 +1568,12 @@ cdef class IENetwork:
# print(net.batch_size)
# net.batch_size = 4
# print(net.batch_size)
# print(net.inputs['data'].shape)
# print(net.input_info['data'].input_data.shape)
# ```
@property
def batch_size(self):
return self.impl.getBatch()
## \note This property is deprecated:
# network precision does not make sense, use precision on edges.
#
@@ -1441,14 +1686,14 @@ cdef class IENetwork:
# ```python
# ie = IECore()
# net = ie.read_network(model=path_to_xml_file, weights=path_to_bin_file)
# input_layer = next(iter(net.inputs))
# n, c, h, w = net.inputs[input_layer]
# input_layer = next(iter(net.input_info))
# n, c, h, w = net.input_info[input_layer].input_data.shape
# net.reshape({input_layer: (n, c, h*2, w*2)})
# ```
def reshape(self, input_shapes: dict):
cdef map[string, vector[size_t]] c_input_shapes;
cdef vector[size_t] c_shape
net_inputs = self.inputs
net_inputs = self.input_info
for input, shape in input_shapes.items():
c_shape = []
if input not in net_inputs:
@@ -1465,7 +1710,7 @@ cdef class IENetwork:
## This class is the main plugin interface and serves to initialize and configure the plugin.
#
#\note This class is deprecated: Use IECore instead
# \note This class is deprecated: Use IECore instead
#
cdef class IEPlugin:
## Class constructor
@@ -1512,7 +1757,7 @@ cdef class IEPlugin:
# ```python
# net = IENetwork(model=path_to_xml_file, weights=path_to_bin_file)
# ie = IECore()
# exec_net = ie.load_network(network=net, device_name="CPU", num_requsts=2)
# exec_net = ie.load_network(network=net, device_name="CPU", num_requests=2)
# ```
cpdef ExecutableNetwork load(self, IENetwork network, int num_requests=1, config=None):
cdef ExecutableNetwork exec_net = ExecutableNetwork()
@@ -1580,9 +1825,9 @@ cdef class IEPlugin:
cdef class BlobBuffer:
"""Copy-less accessor for Inference Engine Blob"""
cdef reset(self, Blob.Ptr & ptr, vector[size_t] representation_shape = []):
cdef reset(self, CBlob.Ptr & ptr, vector[size_t] representation_shape = []):
self.ptr = ptr
cdef TensorDesc desc = deref(ptr).getTensorDesc()
cdef CTensorDesc desc = deref(ptr).getTensorDesc()
cdef SizeVector shape
if len(representation_shape) == 0:
shape = desc.getDims()
@@ -1617,7 +1862,7 @@ cdef class BlobBuffer:
buffer.strides = self.strides.data()
buffer.suboffsets = NULL
cdef char*_get_blob_format(self, const TensorDesc & desc):
cdef char*_get_blob_format(self, const CTensorDesc & desc):
cdef Precision precision = desc.getPrecision()
name = bytes(precision.name()).decode()
# todo: half floats

20
inference-engine/ie_bridges/python/src/openvino/inference_engine/ie_api_impl.cpp
View File

@@ -261,6 +261,15 @@ PyObject* InferenceEnginePython::IENetwork::getFunction() {
}
}
const std::map <std::string, InferenceEngine::InputInfo::Ptr> InferenceEnginePython::IENetwork::getInputsInfo() {
std::map <std::string, InferenceEngine::InputInfo::Ptr> inputs;
const InferenceEngine::InputsDataMap &inputsInfo = actual->getInputsInfo();
for (auto &in : inputsInfo) {
inputs[in.first] = in.second;
}
return inputs;
}
const std::map <std::string, InferenceEngine::DataPtr> InferenceEnginePython::IENetwork::getInputs() {
std::map <std::string, InferenceEngine::DataPtr> inputs;
const InferenceEngine::InputsDataMap &inputsInfo = actual->getInputsInfo();
@@ -461,6 +470,17 @@ std::map <std::string, InferenceEngine::DataPtr> InferenceEnginePython::IEExecNe
return pyInputs;
}
std::map <std::string, InferenceEngine::InputInfo::CPtr> InferenceEnginePython::IEExecNetwork::getInputsInfo() {
InferenceEngine::ConstInputsDataMap inputsDataMap;
InferenceEngine::ResponseDesc response;
IE_CHECK_CALL(actual->GetInputsInfo(inputsDataMap, &response));
std::map <std::string, InferenceEngine::InputInfo::CPtr> pyInputs;
for (const auto &item : inputsDataMap) {
pyInputs[item.first] = item.second;
}
return pyInputs;
}
std::map <std::string, InferenceEngine::CDataPtr> InferenceEnginePython::IEExecNetwork::getOutputs() {
InferenceEngine::ConstOutputsDataMap outputsDataMap;
InferenceEngine::ResponseDesc response;

3
inference-engine/ie_bridges/python/src/openvino/inference_engine/ie_api_impl.hpp
View File

@@ -52,6 +52,8 @@ struct IENetwork {
const std::vector <InferenceEngine::CNNLayerPtr> getLayers();
const std::map<std::string, InferenceEngine::InputInfo::Ptr> getInputsInfo();
const std::map<std::string, InferenceEngine::DataPtr> getInputs();
const std::map<std::string, InferenceEngine::DataPtr> getOutputs();
@@ -134,6 +136,7 @@ struct IEExecNetwork {
void infer();
void exportNetwork(const std::string & model_file);
std::map<std::string, InferenceEngine::InputInfo::CPtr> getInputsInfo();
std::map<std::string, InferenceEngine::DataPtr> getInputs();
std::map<std::string, InferenceEngine::CDataPtr> getOutputs();

79
inference-engine/ie_bridges/python/src/openvino/inference_engine/ie_api_impl_defs.pxd
View File

@@ -15,19 +15,19 @@ cdef extern from "<inference_engine.hpp>" namespace "InferenceEngine":
cdef cppclass TBlob[T]:
ctypedef shared_ptr[TBlob[T]] Ptr
cdef cppclass Blob:
ctypedef shared_ptr[Blob] Ptr
const TensorDesc& getTensorDesc() except +
cdef cppclass CBlob "InferenceEngine::Blob":
ctypedef shared_ptr[CBlob] Ptr
const CTensorDesc& getTensorDesc() except +
size_t element_size() except +
void allocate()
cdef TBlob[Type].Ptr make_shared_blob[Type](const TensorDesc& tensorDesc)
cdef TBlob[Type].Ptr make_shared_blob[Type](const CTensorDesc& tensorDesc)
cdef TBlob[Type].Ptr make_shared_blob[Type](const TensorDesc& tensorDesc, Type* ptr, size_t size)
cdef TBlob[Type].Ptr make_shared_blob[Type](const CTensorDesc& tensorDesc, Type* ptr, size_t size)
cdef cppclass TensorDesc:
TensorDesc() except +
TensorDesc(const Precision& precision, SizeVector dims, Layout layout) except +
cdef cppclass CTensorDesc "InferenceEngine::TensorDesc":
CTensorDesc() except +
CTensorDesc(const Precision& precision, SizeVector dims, Layout layout) except +
SizeVector& getDims() except +
void setDims(const SizeVector& dims) except +
Layout getLayout() except +
@@ -52,6 +52,42 @@ cdef extern from "<inference_engine.hpp>" namespace "InferenceEngine":
ctypedef shared_ptr[const Data] CDataPtr
cdef cppclass InputInfo:
ctypedef shared_ptr[InputInfo] Ptr
ctypedef shared_ptr[const InputInfo] CPtr
Precision getPrecision() const
void setPrecision(Precision p)
Layout getLayout()
void setLayout(Layout l)
const string& name() const
DataPtr getInputData() const
CPreProcessInfo& getPreProcess()
const CTensorDesc& getTensorDesc() const
void setInputData(DataPtr inputPtr)
cdef cppclass CPreProcessChannel "InferenceEngine::PreProcessChannel":
ctypedef shared_ptr[CPreProcessChannel] Ptr
CBlob.Ptr meanData
float stdScale
float meanValue
cdef cppclass CPreProcessInfo "InferenceEngine::PreProcessInfo":
CPreProcessChannel.Ptr& operator[](size_t index)
size_t getNumberOfChannels() const
void init(const size_t numberOfChannels)
void setMeanImage(const CBlob.Ptr& meanImage)
void setMeanImageForChannel(const CBlob.Ptr& meanImage, const size_t channel)
vector[CPreProcessChannel.Ptr] _channelsInfo
ColorFormat getColorFormat() const
void setColorFormat(ColorFormat fmt)
ResizeAlgorithm getResizeAlgorithm() const
void setResizeAlgorithm(const ResizeAlgorithm& alg)
MeanVariant getMeanVariant() const
void setVariant(const MeanVariant& variant)
ctypedef map[string, InputInfo.CPtr] InputsDataMap
cdef cppclass Precision:
const char*name() const
@staticmethod
@@ -65,7 +101,7 @@ cdef extern from "<inference_engine.hpp>" namespace "InferenceEngine":
vector[DataWeakPtr] insData
string affinity
map[string, string] params
map[string, Blob.Ptr] blobs
map[string, CBlob.Ptr] blobs
ctypedef weak_ptr[CNNLayer] CNNLayerWeakPtr
ctypedef shared_ptr[CNNLayer] CNNLayerPtr
@@ -80,6 +116,15 @@ cdef extern from "<inference_engine.hpp>" namespace "InferenceEngine":
const char *description
apiVersion apiVersion
cpdef enum MeanVariant:
pass
cpdef enum ResizeAlgorithm:
pass
cpdef enum ColorFormat:
pass
cdef enum Layout:
ANY
NCHW
@@ -109,15 +154,16 @@ cdef extern from "ie_api_impl.hpp" namespace "InferenceEnginePython":
unsigned int execution_index
cdef cppclass WeightsInfo:
Blob.Ptr & weights;
Blob.Ptr & biases;
map[string, Blob.Ptr] custom_blobs;
CBlob.Ptr & weights;
CBlob.Ptr & biases;
map[string, CBlob.Ptr] custom_blobs;
cdef cppclass IEExecNetwork:
vector[InferRequestWrap] infer_requests
IENetwork GetExecGraphInfo() except +
map[string, DataPtr] getInputs() except +
map[string, CDataPtr] getOutputs() except +
map[string, InputInfo.CPtr] getInputsInfo()
void exportNetwork(const string & model_file) except +
object getMetric(const string & metric_name) except +
object getConfig(const string & metric_name) except +
@@ -133,7 +179,8 @@ cdef extern from "ie_api_impl.hpp" namespace "InferenceEnginePython":
string precision
map[string, vector[size_t]] inputs
const vector[CNNLayerPtr] getLayers() except +
map[string, DataPtr] getInputs() except +
const map[string, InputInfo.Ptr] getInputsInfo() except +
const map[string, DataPtr] getInputs() except +
map[string, DataPtr] getOutputs() except +
void addOutput(string &, size_t) except +
void setAffinity(map[string, string] & types_affinity_map, map[string, string] & layers_affinity_map) except +
@@ -161,8 +208,8 @@ cdef extern from "ie_api_impl.hpp" namespace "InferenceEnginePython":
cdef cppclass InferRequestWrap:
double exec_time;
int index;
void getBlobPtr(const string & blob_name, Blob.Ptr & blob_ptr) except +
void setBlob(const string & blob_name, const Blob.Ptr & blob_ptr) except +
void getBlobPtr(const string & blob_name, CBlob.Ptr & blob_ptr) except +
void setBlob(const string & blob_name, const CBlob.Ptr & blob_ptr) except +
map[string, ProfileInfo] getPerformanceCounts() except +
void infer() except +
void infer_async() except +
@@ -191,6 +238,6 @@ cdef extern from "ie_api_impl.hpp" namespace "InferenceEnginePython":
object getMetric(const string & deviceName, const string & name) except +
object getConfig(const string & deviceName, const string & name) except +
cdef T*get_buffer[T](Blob &)
cdef T*get_buffer[T](CBlob &)
cdef string get_version()

87
inference-engine/ie_bridges/python/tests/test_IEBlob.py → inference-engine/ie_bridges/python/tests/test_Blob.py
View File

@@ -2,112 +2,123 @@ import pytest
import numpy as np
from openvino.inference_engine import IETensorDesc, IEBlob
from openvino.inference_engine import TensorDesc, Blob
from conftest import image_path
path_to_image = image_path()
def test_init_with_tensor_desc():
tensor_desc = IETensorDesc("FP32", [1, 3, 127, 127], "NHWC")
blob = IEBlob(tensor_desc)
tensor_desc = TensorDesc("FP32", [1, 3, 127, 127], "NHWC")
blob = Blob(tensor_desc)
assert isinstance(blob.buffer, np.ndarray)
assert blob.tensor_desc == tensor_desc
def test_init_with_numpy():
tensor_desc = IETensorDesc("FP32", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("FP32", [1, 3, 127, 127], "NCHW")
array = np.ones(shape=(1, 3, 127, 127), dtype=np.float32)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
assert isinstance(blob.buffer, np.ndarray)
assert blob.tensor_desc == tensor_desc
def test_get_tensor_desc():
tensor_desc = IETensorDesc("FP32", [1, 127, 127, 3], "NHWC")
blob = IEBlob(tensor_desc)
tensor_desc = TensorDesc("FP32", [1, 127, 127, 3], "NHWC")
blob = Blob(tensor_desc)
assert blob.tensor_desc == tensor_desc
def test_get_buffer():
tensor_desc = IETensorDesc("FP32", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("FP32", [1, 3, 127, 127], "NCHW")
array = np.ones(shape=(1, 3, 127, 127), dtype=np.float32)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
assert np.array_equal(blob.buffer, array)
def test_write_to_buffer_fp32():
tensor_desc = IETensorDesc("FP32", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("FP32", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.float32)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.float32)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
@pytest.mark.skip(reason="Need to figure out how to implement right conversion")
def test_write_to_buffer_fp16():
tensor_desc = IETensorDesc("FP16", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("FP16", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.float16)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.float16)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
def test_write_to_buffer_int8():
tensor_desc = IETensorDesc("I8", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("I8", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.int8)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.int8)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
def test_write_to_buffer_uint8():
tensor_desc = IETensorDesc("U8", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("U8", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.uint8)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.uint8)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
def test_write_to_buffer_int32():
tensor_desc = IETensorDesc("I32", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("I32", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.int32)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.int32)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
def test_write_to_buffer_int16():
tensor_desc = IETensorDesc("I16", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("I16", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.int16)
blob = IEBlob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype= np.int16)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.int16)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
def test_write_to_buffer_uint16():
tensor_desc = IETensorDesc("U16", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("U16", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.uint16)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.uint16)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
def test_write_to_buffer_int64():
tensor_desc = IETensorDesc("I64", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("I64", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 3, 127, 127), dtype=np.int64)
blob = IEBlob(tensor_desc, array)
blob = Blob(tensor_desc, array)
ones_arr = np.ones(shape=(1, 3, 127, 127), dtype=np.int64)
blob.buffer[:] = ones_arr
assert np.array_equal(blob.buffer, ones_arr)
assert np.array_equal(blob.buffer, ones_arr)
def test_incompatible_array_and_td():
tensor_desc = IETensorDesc("FP32", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("FP32", [1, 3, 127, 127], "NCHW")
array = np.zeros(shape=(1, 2, 3, 4), dtype=np.float32)
with pytest.raises(AttributeError) as e:
IEBlob(tensor_desc, array)
Blob(tensor_desc, array)
assert "Number of elements in provided numpy array 24 and " \
"required by TensorDesc 48387 are not equal" in str(e.value)
def test_incompatible_input_precision():
import cv2
n, c, h, w = (1, 3, 32, 32)
@@ -118,8 +129,8 @@ def test_incompatible_input_precision():
image = cv2.resize(image, (h, w))
image = image.transpose((2, 0, 1))
image = image.reshape((n, c, h, w))
tensor_desc = IETensorDesc("FP32", [1, 3, 32, 32], "NCHW")
tensor_desc = TensorDesc("FP32", [1, 3, 32, 32], "NCHW")
with pytest.raises(ValueError) as e:
IEBlob(tensor_desc, image)
Blob(tensor_desc, image)
assert "Data type float64 of provided numpy array " \
"doesn't match to TensorDesc precision FP32" in str(e.value)

1
inference-engine/ie_bridges/python/tests/test_CDataPtr.py
View File

@@ -6,6 +6,7 @@ from conftest import model_path
test_net_xml, test_net_bin = model_path()
def test_name(device):
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)

1
inference-engine/ie_bridges/python/tests/test_DataPtr.py
View File

@@ -6,6 +6,7 @@ from conftest import model_path
test_net_xml, test_net_bin = model_path()
def layer_out_data():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)

35
inference-engine/ie_bridges/python/tests/test_ExecutableNetwork.py
View File

@@ -1,6 +1,7 @@
import numpy as np
import os
import pytest
import warnings
from openvino.inference_engine import ie_api as ie
from conftest import model_path, image_path
@@ -48,9 +49,9 @@ def test_infer_net_from_buffer(device):
img = read_image()
res = exec_net.infer({'data': img})
res2 = exec_net2.infer({'data': img})
del ie_core
del exec_net
del exec_net2
del ie_core
assert np.allclose(res['fc_out'], res2['fc_out'], atol=1E-4, rtol=1E-4)
@@ -66,13 +67,32 @@ def test_infer_wrong_input_name(device):
del ie_core
def test_inputs(device):
def test_input_info(device):
ie_core = ie.IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie_core.load_network(net, device, num_requests=5)
assert len(exec_net.inputs) == 1
assert "data" in exec_net.inputs
assert isinstance(exec_net.inputs['data'], ie.DataPtr)
assert isinstance(exec_net.input_info['data'], ie.InputInfoCPtr)
assert exec_net.input_info['data'].name == "data"
assert exec_net.input_info['data'].precision == "FP32"
assert isinstance(exec_net.input_info['data'].input_data, ie.DataPtr)
del exec_net
del ie_core
def test_inputs_deprecated(device):
ie_core = ie.IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie_core.load_network(net, device, num_requests=5)
with warnings.catch_warnings(record=True) as w:
assert len(exec_net.inputs) == 1
assert "data" in exec_net.inputs
assert isinstance(exec_net.inputs['data'], ie.DataPtr)
assert len(w) == 3
for i in range (len(w)):
assert "'inputs' property of ExecutableNetwork class is deprecated. " \
"To access DataPtrs user need to use 'input_data' property " \
"of InputInfoCPtr objects which " \
"can be acessed by 'input_info' property." in str(w[i].message)
del exec_net
del ie_core
@@ -202,11 +222,11 @@ def test_plugin_accessible_after_deletion(device):
ie_core = ie.IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie_core.load_network(net, device)
del ie_core
img = read_image()
res = exec_net.infer({'data': img})
assert np.argmax(res['fc_out'][0]) == 2
del exec_net
del ie_core
def test_exec_graph(device):
@@ -258,8 +278,7 @@ def test_multi_out_data(device):
del ie_core
pass
# TODO: return when cvs-29487 will be fixed
@pytest.mark.skip(reason="get_metric('NETWORK_NAME') returns wrong name, problem somewhere in ngraph")
def test_get_metric(device):
ie_core = ie.IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)

5
inference-engine/ie_bridges/python/tests/test_IENetLayer.py
View File

@@ -7,6 +7,7 @@ from conftest import model_path
test_net_xml, test_net_bin = model_path()
def test_name():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
@@ -27,6 +28,7 @@ def test_precision_getter(recwarn):
assert len(recwarn) == 1
assert recwarn.pop(DeprecationWarning)
def test_precision_setter(recwarn):
warnings.simplefilter("always")
ie = IECore()
@@ -36,6 +38,7 @@ def test_precision_setter(recwarn):
assert len(recwarn) == 1
assert recwarn.pop(DeprecationWarning)
def test_affinuty_getter():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
@@ -57,6 +60,7 @@ def test_blobs():
assert net.layers['19/Fused_Add_'].blobs["biases"].size != 0
assert net.layers['19/Fused_Add_'].blobs["weights"].size != 0
def test_weights(recwarn):
warnings.simplefilter("always")
ie = IECore()
@@ -124,6 +128,7 @@ def test_out_data():
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
assert isinstance(net.layers['27'].out_data[0], DataPtr)
def test_in_data():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)

70
inference-engine/ie_bridges/python/tests/test_IENetwork.py
View File

@@ -3,11 +3,14 @@ import pytest
import warnings
import numpy as np
from openvino.inference_engine import IENetwork, IENetLayer, DataPtr, LayersStatsMap, LayerStats, IECore
from openvino.inference_engine import IECore, IENetwork, IENetLayer, DataPtr, \
LayersStatsMap, LayerStats, InputInfoPtr, PreProcessInfo
from conftest import model_path
test_net_xml, test_net_bin = model_path()
def test_create_ie_network_deprecated():
with warnings.catch_warnings(record=True) as w:
net = IENetwork(model=test_net_xml, weights=test_net_bin)
@@ -40,43 +43,59 @@ def test_incorrect_bin_deprecated():
"Please, use IECore.read_network() method instead" in str(w[0].message)
@pytest.mark.skip(reason="name) returns wrong name, problem somewhere in ngraph")
def test_name():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
assert net.name == "model"
assert net.name == "test_model"
def test_inputs():
def test_inputs_deprecated():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
assert isinstance(net.inputs['data'], DataPtr)
assert net.inputs['data'].layout == "NCHW"
assert net.inputs['data'].precision == "FP32"
assert net.inputs['data'].shape == [1, 3, 32, 32]
with warnings.catch_warnings(record=True) as w:
inp = net.inputs
assert isinstance(inp['data'], DataPtr)
assert inp['data'].layout == "NCHW"
assert inp['data'].precision == "FP32"
assert inp['data'].shape == [1, 3, 32, 32]
assert len(w) == 1
assert "'inputs' property of IENetwork class is deprecated. " \
"To access DataPtrs user need to use 'input_data' property " \
"of InputInfoPtr objects which " \
"can be acessed by 'input_info' property." in str(w[-1].message)
def test_input_precision_setter():
def test_input_info():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
assert net.inputs['data'].layout == "NCHW"
net.inputs['data'].layout = "NHWC"
assert net.inputs['data'].layout == "NHWC"
assert isinstance(net.input_info['data'], InputInfoPtr)
assert net.input_info['data'].layout == "NCHW"
assert net.input_info['data'].precision == "FP32"
assert isinstance(net.input_info['data'].input_data, DataPtr)
assert isinstance(net.input_info['data'].preprocess_info, PreProcessInfo)
def test_input_layout_setter():
def test_input_info_precision_setter():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
assert net.inputs['data'].precision == "FP32"
net.inputs['data'].precision = "I8"
assert net.inputs['data'].precision == "I8"
assert net.input_info['data'].layout == "NCHW"
net.input_info['data'].layout = "NHWC"
assert net.input_info['data'].layout == "NHWC"
def test_input_input_info_layout_setter():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
assert net.input_info['data'].precision == "FP32"
net.input_info['data'].precision = "I8"
assert net.input_info['data'].precision == "I8"
def test_input_unsupported_precision_setter():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
with pytest.raises(ValueError) as e:
net.inputs['data'].precision = "BLA"
net.input_info['data'].precision = "BLA"
assert "Unsupported precision BLA! List of supported precisions: " in str(e.value)
@@ -84,7 +103,7 @@ def test_input_unsupported_layout_setter():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
with pytest.raises(ValueError) as e:
net.inputs['data'].layout = "BLA"
net.input_info['data'].layout = "BLA"
assert "Unsupported layout BLA! List of supported layouts: " in str(e.value)
@@ -148,23 +167,26 @@ def test_batch_size_setter():
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
net.batch_size = 4
assert net.batch_size == 4
assert net.inputs['data'].shape == [4, 3, 32, 32]
assert net.input_info['data'].input_data.shape == [4, 3, 32, 32]
def test_batch_size_after_reshape():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
net.reshape({'data' : [4, 3, 32, 32]})
net.reshape({'data': [4, 3, 32, 32]})
assert net.batch_size == 4
assert net.inputs['data'].shape == [4, 3, 32, 32]
net.reshape({'data' : [8, 3, 32, 32]})
assert net.input_info['data'].input_data.shape == [4, 3, 32, 32]
net.reshape({'data': [8, 3, 32, 32]})
assert net.batch_size == 8
assert net.inputs['data'].shape == [8, 3, 32, 32]
assert net.input_info['data'].input_data.shape == [8, 3, 32, 32]
def test_layers():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
layers_name = [key for key in net.layers]
assert sorted(layers_name) == ['19/Fused_Add_', '21', '22', '23', '24/Fused_Add_', '26', '27', '29', 'data', 'fc_out']
assert sorted(layers_name) == ['19/Fused_Add_', '21', '22', '23', '24/Fused_Add_',
'26', '27', '29', 'data', 'fc_out']
assert isinstance(net.layers['19/Fused_Add_'], IENetLayer)

1
inference-engine/ie_bridges/python/tests/test_IEPlugin.py
View File

@@ -7,6 +7,7 @@ from conftest import model_path
test_net_xml, test_net_bin = model_path()
def test_init_plugin(device):
with warnings.catch_warnings(record=True) as w:
plugin = IEPlugin(device, None)

19
inference-engine/ie_bridges/python/tests/test_InferRequest.py
View File

@@ -12,6 +12,7 @@ is_myriad = os.environ.get("TEST_DEVICE") == "MYRIAD"
test_net_xml, test_net_bin = model_path(is_myriad)
path_to_img = image_path()
def read_image():
import cv2
n, c, h, w = (1, 3, 32, 32)
@@ -36,7 +37,7 @@ def test_input_blobs(device):
ie_core = ie.IECore()
net = ie_core.read_network(test_net_xml, test_net_bin)
executable_network = ie_core.load_network(net, device, num_requests=2)
td = ie.IETensorDesc("FP32", (1, 3, 32, 32), "NCHW")
td = ie.TensorDesc("FP32", (1, 3, 32, 32), "NCHW")
assert executable_network.requests[0].input_blobs['data'].tensor_desc == td
@@ -44,7 +45,7 @@ def test_output_blobs(device):
ie_core = ie.IECore()
net = ie_core.read_network(test_net_xml, test_net_bin)
executable_network = ie_core.load_network(net, device, num_requests=2)
td = ie.IETensorDesc("FP32", (1, 10), "NC")
td = ie.TensorDesc("FP32", (1, 10), "NC")
assert executable_network.requests[0].output_blobs['fc_out'].tensor_desc == td
@@ -54,8 +55,8 @@ def test_inputs_deprecated(device):
executable_network = ie_core.load_network(net, device, num_requests=2)
with warnings.catch_warnings(record=True) as w:
inputs = executable_network.requests[0].inputs
assert "'inputs' property of InferRequest is deprecated. Please instead use 'input_blobs' property." in str(
w[-1].message)
assert "'inputs' property of InferRequest is deprecated. " \
"Please instead use 'input_blobs' property." in str(w[-1].message)
del executable_network
del ie_core
del net
@@ -394,7 +395,7 @@ def test_set_batch_size(device):
ie_core.set_config({"DYN_BATCH_ENABLED": "YES"}, device)
net = ie_core.read_network(test_net_xml, test_net_bin)
net.batch_size = 10
data = np.zeros(shape=net.inputs['data'].shape)
data = np.zeros(shape=net.input_info['data'].input_data.shape)
exec_net = ie_core.load_network(net, device)
data[0] = read_image()[0]
request = exec_net.requests[0]
@@ -422,7 +423,7 @@ def test_set_zero_batch_size(device):
def test_set_negative_batch_size(device):
ie_core = ie.IECore()
net = ie_core.read_network(test_net_xml, test_net_bin)
exec_net = ie_core.load_network(net, device, num_requests=1)
exec_net = ie_core.load_network(net, device, num_requests=1)
request = exec_net.requests[0]
with pytest.raises(ValueError) as e:
request.set_batch(-1)
@@ -437,15 +438,15 @@ def test_blob_setter(device):
net = ie_core.read_network(test_net_xml, test_net_bin)
exec_net_1 = ie_core.load_network(network=net, device_name=device, num_requests=1)
net.inputs['data'].layout = "NHWC"
net.input_info['data'].layout = "NHWC"
exec_net_2 = ie_core.load_network(network=net, device_name=device, num_requests=1)
img = read_image()
res_1 = np.sort(exec_net_1.infer({"data": img})['fc_out'])
img = np.transpose(img, axes=(0, 2, 3, 1)).astype(np.float32)
tensor_desc = ie.IETensorDesc("FP32", [1, 3, 32, 32], "NHWC")
img_blob = ie.IEBlob(tensor_desc, img)
tensor_desc = ie.TensorDesc("FP32", [1, 3, 32, 32], "NHWC")
img_blob = ie.Blob(tensor_desc, img)
request = exec_net_2.requests[0]
request.set_blob('data', img_blob)
request.infer()

54
inference-engine/ie_bridges/python/tests/test_InputInfoCPtr.py Normal file
View File

@@ -0,0 +1,54 @@
import pytest
from openvino.inference_engine import InputInfoCPtr, DataPtr, IECore, TensorDesc
from conftest import model_path
test_net_xml, test_net_bin = model_path()
def test_name(device):
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie.load_network(net, device, num_requests=5)
assert isinstance(exec_net.input_info['data'], InputInfoCPtr)
assert exec_net.input_info['data'].name == "data", "Incorrect name"
del exec_net
def test_precision(device):
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie.load_network(net, device, num_requests=5)
assert isinstance(exec_net.input_info['data'], InputInfoCPtr)
assert exec_net.input_info['data'].precision == "FP32", "Incorrect precision"
del exec_net
def test_no_precision_setter(device):
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie.load_network(net, device, num_requests=5)
with pytest.raises(AttributeError) as e:
exec_net.input_info['data'].precision = "I8"
assert "attribute 'precision' of 'openvino.inference_engine.ie_api.InputInfoCPtr' " \
"objects is not writable" in str(e.value)
del exec_net
def test_input_data(device):
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie.load_network(net, device, num_requests=5)
assert isinstance(exec_net.input_info['data'], InputInfoCPtr)
assert isinstance(exec_net.input_info['data'].input_data, DataPtr), "Incorrect precision for layer 'fc_out'"
del exec_net
def test_tensor_desc(device):
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
exec_net = ie.load_network(net, device, num_requests=5)
tensor_desc = exec_net.input_info['data'].tensor_desc
assert isinstance(tensor_desc, TensorDesc)
assert tensor_desc.layout == "NCHW"

84
inference-engine/ie_bridges/python/tests/test_InputInfoPtr.py Normal file
View File

@@ -0,0 +1,84 @@
import pytest
from openvino.inference_engine import InputInfoPtr, PreProcessInfo, DataPtr, IECore, TensorDesc, ColorFormat
from conftest import model_path
test_net_xml, test_net_bin = model_path()
def get_input_info():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
return net.input_info["data"]
def test_input_info():
assert isinstance(get_input_info(), InputInfoPtr)
def test_input_data():
assert isinstance(get_input_info().input_data, DataPtr)
def test_input_data_setter():
ie = IECore()
net = ie.read_network(model=test_net_xml, weights=test_net_bin)
input_info = net.input_info["data"]
other_input_data = net.outputs["fc_out"]
input_info.input_data = other_input_data
assert input_info.input_data.name == "fc_out"
def test_incorrect_input_info_setter():
with pytest.raises(TypeError) as e:
get_input_info().input_data = "dfds"
assert "Argument 'input_ptr' has incorrect type" in str(e.value)
def test_name():
assert get_input_info().name == "data"
def test_precision():
assert get_input_info().precision == "FP32"
def test_precision_setter():
input_info = get_input_info()
input_info.precision = "I8"
assert input_info.precision == "I8", "Incorrect precision"
def test_incorrect_precision_setter():
with pytest.raises(ValueError) as e:
get_input_info().precision = "123"
assert "Unsupported precision 123! List of supported precisions:" in str(e.value)
def test_layout():
assert get_input_info().layout == "NCHW"
def test_layout_setter():
input_info = get_input_info()
input_info.layout = "NHWC"
assert input_info.layout == "NHWC", "Incorrect layout"
def test_incorrect_layout_setter():
with pytest.raises(ValueError) as e:
get_input_info().layout = "123"
assert "Unsupported layout 123! List of supported layouts:" in str(e.value)
def test_preprocess_info():
preprocess_info = get_input_info().preprocess_info
assert isinstance(preprocess_info, PreProcessInfo)
assert preprocess_info.color_format == ColorFormat.RAW
def test_tensor_desc():
tensor_desc = get_input_info().tensor_desc
assert isinstance(tensor_desc, TensorDesc)
assert tensor_desc.layout == "NCHW"

97
inference-engine/ie_bridges/python/tests/test_PreProcessInfo.py Normal file
View File

@@ -0,0 +1,97 @@
import pytest
from openvino.inference_engine import PreProcessInfo, IECore, TensorDesc, Blob, PreProcessChannel,\
MeanVariant, ResizeAlgorithm, ColorFormat
from conftest import model_path
test_net_xml, test_net_bin = model_path()
def get_preprocess_info():
ie_core = IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
return net.input_info["data"].preprocess_info
def test_preprocess_info():
assert isinstance(get_preprocess_info(), PreProcessInfo)
def test_color_format():
preprocess_info = get_preprocess_info()
assert preprocess_info.color_format == ColorFormat.RAW
def test_color_format_setter():
preprocess_info = get_preprocess_info()
preprocess_info.color_format = ColorFormat.BGR
assert preprocess_info.color_format == ColorFormat.BGR
def test_resize_algorithm():
preprocess_info = get_preprocess_info()
assert preprocess_info.resize_algorithm == ResizeAlgorithm.NO_RESIZE
def test_resize_algorithm_setter():
preprocess_info = get_preprocess_info()
preprocess_info.resize_algorithm = ResizeAlgorithm.RESIZE_BILINEAR
assert preprocess_info.resize_algorithm == ResizeAlgorithm.RESIZE_BILINEAR
def test_mean_variant():
preprocess_info = get_preprocess_info()
assert preprocess_info.mean_variant == MeanVariant.NONE
def test_mean_variant_setter():
preprocess_info = get_preprocess_info()
preprocess_info.mean_variant = MeanVariant.MEAN_IMAGE
assert preprocess_info.mean_variant == MeanVariant.MEAN_IMAGE
def test_get_number_of_channels():
ie_core = IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
assert net.input_info["data"].preprocess_info.get_number_of_channels() == 0
def test_init():
ie_core = IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
net.input_info['data'].preprocess_info.init(5)
assert net.input_info["data"].preprocess_info.get_number_of_channels() == 5
def test_set_mean_image():
ie_core = IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
tensor_desc = TensorDesc("FP32", [0, 127, 127], "CHW")
mean_image_blob = Blob(tensor_desc)
preprocess_info = net.input_info["data"].preprocess_info
preprocess_info.set_mean_image(mean_image_blob)
assert preprocess_info.mean_variant == MeanVariant.MEAN_IMAGE
def test_get_pre_process_channel():
ie_core = IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
preprocess_info = net.input_info["data"].preprocess_info
preprocess_info.init(1)
pre_process_channel = preprocess_info[0]
assert isinstance(pre_process_channel, PreProcessChannel)
def test_set_mean_image_for_channel():
ie_core = IECore()
net = ie_core.read_network(model=test_net_xml, weights=test_net_bin)
tensor_desc = TensorDesc("FP32", [127, 127], "HW")
mean_image_blob = Blob(tensor_desc)
preprocess_info = net.input_info["data"].preprocess_info
preprocess_info.init(1)
preprocess_info.set_mean_image_for_channel(mean_image_blob, 0)
pre_process_channel = preprocess_info[0]
assert isinstance(pre_process_channel.mean_data, Blob)
assert pre_process_channel.mean_data.tensor_desc.dims == [127, 127]
assert preprocess_info.mean_variant == MeanVariant.MEAN_IMAGE

26
inference-engine/ie_bridges/python/tests/test_IETensorDesk.py → inference-engine/ie_bridges/python/tests/test_TensorDesk.py
View File

@@ -1,37 +1,37 @@
import pytest
from openvino.inference_engine import IETensorDesc
from openvino.inference_engine import TensorDesc
def test_init():
tensor_desc = IETensorDesc("FP32", [1, 127, 127, 3], "NHWC")
assert isinstance(tensor_desc, IETensorDesc)
tensor_desc = TensorDesc("FP32", [1, 127, 127, 3], "NHWC")
assert isinstance(tensor_desc, TensorDesc)
def test_precision():
tensor_desc = IETensorDesc("FP32", [1, 127, 127, 3], "NHWC")
tensor_desc = TensorDesc("FP32", [1, 127, 127, 3], "NHWC")
assert tensor_desc.precision == "FP32"
def test_layout():
tensor_desc = IETensorDesc("FP32", [1, 127, 127, 3], "NHWC")
tensor_desc = TensorDesc("FP32", [1, 127, 127, 3], "NHWC")
assert tensor_desc.layout == "NHWC"
def test_dims():
tensor_desc = IETensorDesc("FP32", [1, 127, 127, 3], "NHWC")
tensor_desc = TensorDesc("FP32", [1, 127, 127, 3], "NHWC")
assert tensor_desc.dims == [1, 127, 127, 3]
def test_incorrect_precision_setter():
tensor_desc = IETensorDesc("FP32", [1, 127, 127, 3], "NHWC")
tensor_desc = TensorDesc("FP32", [1, 127, 127, 3], "NHWC")
with pytest.raises(ValueError) as e:
tensor_desc.precision = "123"
assert "Unsupported precision 123! List of supported precisions:" in str(e.value)
def test_incorrect_layout_setter():
tensor_desc = IETensorDesc("FP32", [1, 127, 127, 3], "NHWC")
tensor_desc = TensorDesc("FP32", [1, 127, 127, 3], "NHWC")
with pytest.raises(ValueError) as e:
tensor_desc.layout = "123"
assert "Unsupported layout 123! List of supported layouts: " in str(e.value)
@@ -39,17 +39,17 @@ def test_incorrect_layout_setter():
def test_init_incorrect_precision():
with pytest.raises(ValueError) as e:
IETensorDesc("123", [1, 127, 127, 3], "NHWC")
TensorDesc("123", [1, 127, 127, 3], "NHWC")
assert "Unsupported precision 123! List of supported precisions: " in str(e.value)
def test_eq_operator():
tensor_desc = IETensorDesc("FP32", [1, 3, 127, 127], "NHWC")
tensor_desc_2 = IETensorDesc("FP32", [1, 3, 127, 127], "NHWC")
tensor_desc = TensorDesc("FP32", [1, 3, 127, 127], "NHWC")
tensor_desc_2 = TensorDesc("FP32", [1, 3, 127, 127], "NHWC")
assert tensor_desc == tensor_desc_2
def test_ne_operator():
tensor_desc = IETensorDesc("FP32", [1, 3, 127, 127], "NHWC")
tensor_desc_2 = IETensorDesc("FP32", [1, 3, 127, 127], "NCHW")
tensor_desc = TensorDesc("FP32", [1, 3, 127, 127], "NHWC")
tensor_desc_2 = TensorDesc("FP32", [1, 3, 127, 127], "NCHW")
assert tensor_desc != tensor_desc_2