def test_cannot_set_shape_on_preallocated_memory(ref_shape):
ones_arr = np.ones(shape=(1, 3, 32, 32), dtype=np.float32)
ov_tensor = Tensor(ones_arr)
with pytest.raises(RuntimeError) as e:
ov_tensor.shape = ref_shape
assert "Cannot call setShape for Blobs created on top of preallocated memory" in str(
e.value)
def test_init_with_roi_tensor():
array = np.random.normal(size=[1, 3, 48, 48])
ov_tensor1 = Tensor(array)
ov_tensor2 = Tensor(ov_tensor1, [0, 0, 24, 24], [1, 3, 48, 48])
assert list(ov_tensor2.shape) == [1, 3, 24, 24]
assert ov_tensor2.element_type == ov_tensor2.element_type
assert np.shares_memory(ov_tensor1.data, ov_tensor2.data)
assert np.array_equal(ov_tensor1.data[0:1, :, 24:, 24:], ov_tensor2.data)
def test_init_with_ngraph(ov_type, numpy_dtype):
ov_tensors = []
ov_tensors.append(Tensor(type=ov_type, shape=ov.impl.Shape([1, 3, 32, 32])))
ov_tensors.append(Tensor(type=ov_type, shape=[1, 3, 32, 32]))
assert np.all([list(ov_tensor.shape) == [1, 3, 32, 32] for ov_tensor in ov_tensors])
assert np.all(ov_tensor.element_type == ov_type for ov_tensor in ov_tensors)
assert np.all(ov_tensor.data.dtype == numpy_dtype for ov_tensor in ov_tensors)
assert np.all(ov_tensor.data.shape == (1, 3, 32, 32) for ov_tensor in ov_tensors)
def test_evaluate():
param1 = ops.parameter(Shape([2, 1]), dtype=np.float32, name="data1")
param2 = ops.parameter(Shape([2, 1]), dtype=np.float32, name="data2")
add = ops.add(param1, param2)
func = Function(add, [param1, param2], "TestFunction")
input1 = np.array([2, 1], dtype=np.float32).reshape(2, 1)
input2 = np.array([3, 7], dtype=np.float32).reshape(2, 1)
out_tensor = Tensor("float32", Shape([2, 1]))
assert func.evaluate([out_tensor], [Tensor(input1), Tensor(input2)])
assert np.allclose(out_tensor.data, np.array([5, 8]).reshape(2, 1))
def test_set_tensors(device):
core = Core()
func = core.read_model(test_net_xml, test_net_bin)
exec_net = core.compile_model(func, device)
data1 = read_image()
tensor1 = Tensor(data1)
data2 = np.ones(shape=(1, 10), dtype=np.float32)
tensor2 = Tensor(data2)
data3 = np.ones(shape=(1, 3, 32, 32), dtype=np.float32)
tensor3 = Tensor(data3)
data4 = np.zeros(shape=(1, 10), dtype=np.float32)
tensor4 = Tensor(data4)
request = exec_net.create_infer_request()
request.set_tensors({"data": tensor1, "fc_out": tensor2})
t1 = request.get_tensor("data")
t2 = request.get_tensor("fc_out")
assert np.allclose(tensor1.data, t1.data, atol=1e-2, rtol=1e-2)
assert np.allclose(tensor2.data, t2.data, atol=1e-2, rtol=1e-2)
request.set_output_tensors({0: tensor2})
output_node = exec_net.outputs[0]
t3 = request.get_tensor(output_node)
assert np.allclose(tensor2.data, t3.data, atol=1e-2, rtol=1e-2)
request.set_input_tensors({0: tensor1})
output_node = exec_net.inputs[0]
t4 = request.get_tensor(output_node)
assert np.allclose(tensor1.data, t4.data, atol=1e-2, rtol=1e-2)
output_node = exec_net.inputs[0]
request.set_tensor(output_node, tensor3)
t5 = request.get_tensor(output_node)
assert np.allclose(tensor3.data, t5.data, atol=1e-2, rtol=1e-2)
request.set_input_tensor(tensor3)
t6 = request.get_tensor(request.inputs[0])
assert np.allclose(tensor3.data, t6.data, atol=1e-2, rtol=1e-2)
request.set_input_tensor(0, tensor1)
t7 = request.get_tensor(request.inputs[0])
assert np.allclose(tensor1.data, t7.data, atol=1e-2, rtol=1e-2)
request.set_output_tensor(tensor2)
t8 = request.get_tensor(request.outputs[0])
assert np.allclose(tensor2.data, t8.data, atol=1e-2, rtol=1e-2)
request.set_output_tensor(0, tensor4)
t9 = request.get_tensor(request.outputs[0])
assert np.allclose(tensor4.data, t9.data, atol=1e-2, rtol=1e-2)
def test_init_with_numpy_dtype(ov_type, numpy_dtype):
shape = (1, 3, 127, 127)
ov_shape = ov.impl.Shape(shape)
ov_tensors = []
ov_tensors.append(Tensor(type=numpy_dtype, shape=shape))
ov_tensors.append(Tensor(type=np.dtype(numpy_dtype), shape=shape))
ov_tensors.append(Tensor(type=np.dtype(numpy_dtype), shape=np.array(shape)))
ov_tensors.append(Tensor(type=numpy_dtype, shape=ov_shape))
ov_tensors.append(Tensor(type=np.dtype(numpy_dtype), shape=ov_shape))
assert np.all(tuple(ov_tensor.shape) == shape for ov_tensor in ov_tensors)
assert np.all(ov_tensor.element_type == ov_type for ov_tensor in ov_tensors)
assert np.all(isinstance(ov_tensor.data, np.ndarray) for ov_tensor in ov_tensors)
assert np.all(ov_tensor.data.dtype == numpy_dtype for ov_tensor in ov_tensors)
assert np.all(ov_tensor.data.shape == shape for ov_tensor in ov_tensors)
def test_infer_mixed_keys(device):
core = Core()
func = core.read_model(test_net_xml, test_net_bin)
core.set_config({"PERF_COUNT": "YES"}, device)
model = core.compile_model(func, device)
img = read_image()
tensor = Tensor(img)
data2 = np.ones(shape=img.shape, dtype=np.float32)
tensor2 = Tensor(data2)
request = model.create_infer_request()
res = request.infer({0: tensor2, "data": tensor})
assert np.argmax(res) == 2
def test_evaluate_invalid_input_shape():
param1 = ops.parameter(Shape([2, 1]), dtype=np.float32, name="data1")
param2 = ops.parameter(Shape([2, 1]), dtype=np.float32, name="data2")
add = ops.add(param1, param2)
func = Function(add, [param1, param2], "TestFunction")
with pytest.raises(RuntimeError) as e:
assert func.evaluate(
[Tensor("float32", Shape([2, 1]))],
[
Tensor("float32", Shape([3, 1])),
Tensor("float32", Shape([3, 1]))
],
)
assert "must be compatible with the partial shape: {2,1}" in str(e.value)
def test_infer_mixed_keys(device):
core = Core()
func = core.read_model(test_net_xml, test_net_bin)
core.set_config({"PERF_COUNT": "YES"}, device)
exec_net = core.compile_model(func, device)
img = read_image()
tensor = Tensor(img)
data2 = np.ones(shape=(1, 10), dtype=np.float32)
tensor2 = Tensor(data2)
request = exec_net.create_infer_request()
with pytest.raises(TypeError) as e:
request.infer({0: tensor, "fc_out": tensor2})
assert "incompatible function arguments!" in str(e.value)
def test_tensor_setter(device):
core = Core()
func = core.read_model(test_net_xml, test_net_bin)
exec_net_1 = core.compile_model(model=func, device_name=device)
exec_net_2 = core.compile_model(model=func, device_name=device)
img = read_image()
tensor = Tensor(img)
request1 = exec_net_1.create_infer_request()
request1.set_tensor("data", tensor)
t1 = request1.get_tensor("data")
assert np.allclose(tensor.data, t1.data, atol=1e-2, rtol=1e-2)
res = request1.infer({0: tensor})
res_1 = np.sort(res[0])
t2 = request1.get_tensor("fc_out")
assert np.allclose(t2.data, res[0].data, atol=1e-2, rtol=1e-2)
request = exec_net_2.create_infer_request()
res = request.infer({"data": tensor})
res_2 = np.sort(request.get_tensor("fc_out").data)
assert np.allclose(res_1, res_2, atol=1e-2, rtol=1e-2)
request.set_tensor("data", tensor)
t3 = request.get_tensor("data")
assert np.allclose(t3.data, t1.data, atol=1e-2, rtol=1e-2)
def import_onnx_model(model: onnx.ModelProto) -> Function:
onnx.checker.check_model(model)
model_byte_string = model.SerializeToString()
ie = Core()
func = ie.read_model(bytes(model_byte_string),
Tensor(type=np.uint8, shape=[]))
return func
def test_infer_new_request_wrong_port_name(device):
ie = Core()
func = ie.read_model(model=test_net_xml, weights=test_net_bin)
img = read_image()
tensor = Tensor(img)
exec_net = ie.compile_model(func, device)
with pytest.raises(RuntimeError) as e:
exec_net.infer_new_request({"_data_": tensor})
assert "Port for tensor name _data_ was not found." in str(e.value)
def test_infer_tensor_wrong_input_data(device):
ie = Core()
func = ie.read_model(model=test_net_xml, weights=test_net_bin)
img = read_image()
img = np.ascontiguousarray(img)
tensor = Tensor(img, shared_memory=True)
exec_net = ie.compile_model(func, device)
with pytest.raises(TypeError) as e:
exec_net.infer_new_request({4.5: tensor})
assert "Incompatible key type!" in str(e.value)
def test_infer_new_request_tensor_numpy_copy(device):
ie = Core()
func = ie.read_model(model=test_net_xml, weights=test_net_bin)
img = read_image()
tensor = Tensor(img)
exec_net = ie.compile_model(func, device)
res_tensor = exec_net.infer_new_request({"data": tensor})
res_img = exec_net.infer_new_request({"data": tensor})
assert np.argmax(res_tensor) == 2
assert np.argmax(res_tensor) == np.argmax(res_img)
def test_infer_tensor_numpy_shared_memory(device):
ie = Core()
func = ie.read_model(model=test_net_xml, weights=test_net_bin)
img = read_image()
img = np.ascontiguousarray(img)
tensor = Tensor(img, shared_memory=True)
exec_net = ie.compile_model(func, device)
res_tensor = exec_net.infer_new_request({"data": tensor})
res_img = exec_net.infer_new_request({"data": tensor})
assert np.argmax(res_tensor) == 2
assert np.argmax(res_tensor) == np.argmax(res_img)
def test_infer_tensor_model_from_buffer(device):
core = Core()
with open(test_net_bin, "rb") as f:
bin = f.read()
with open(test_net_xml, "rb") as f:
xml = f.read()
func = core.read_model(model=xml, weights=bin)
img = read_image()
tensor = Tensor(img)
exec_net = core.compile_model(func, device)
res = exec_net.infer_new_request({"data": tensor})
assert np.argmax(res) == 2
def test_init_with_numpy(ov_type, numpy_dtype):
shape = (1, 3, 127, 127)
ov_shape = ng.impl.Shape(shape)
ones_arr = np.ones(shape, numpy_dtype)
ones_ov_tensor = Tensor(array=ones_arr)
ov_tensors = []
ov_tensors.append(Tensor(dtype=numpy_dtype, shape=shape))
ov_tensors.append(Tensor(dtype=np.dtype(numpy_dtype), shape=shape))
ov_tensors.append(
Tensor(dtype=np.dtype(numpy_dtype), shape=np.array(shape)))
ov_tensors.append(ones_ov_tensor)
ov_tensors.append(Tensor(dtype=numpy_dtype, shape=ov_shape))
ov_tensors.append(Tensor(dtype=np.dtype(numpy_dtype), shape=ov_shape))
assert np.all(tuple(ov_tensor.shape) == shape for ov_tensor in ov_tensors)
assert np.all(ov_tensor.element_type == ov_type
for ov_tensor in ov_tensors)
assert np.all(
isinstance(ov_tensor.data, np.ndarray) for ov_tensor in ov_tensors)
assert np.all(ov_tensor.data.dtype == numpy_dtype
for ov_tensor in ov_tensors)
assert np.all(ov_tensor.data.shape == shape for ov_tensor in ov_tensors)
assert np.shares_memory(ones_arr, ones_ov_tensor.data)
assert np.array_equal(ones_ov_tensor.data, ones_arr)
assert ones_ov_tensor.size == ones_arr.size
assert ones_ov_tensor.byte_size == ones_arr.nbytes
def test_init_with_numpy_copy_memory(ov_type, numpy_dtype):
arr = read_image().astype(numpy_dtype)
shape = arr.shape
ov_tensor = Tensor(array=arr, shared_memory=False)
assert tuple(ov_tensor.shape) == shape
assert ov_tensor.element_type == ov_type
assert isinstance(ov_tensor.data, np.ndarray)
assert ov_tensor.data.dtype == numpy_dtype
assert ov_tensor.data.shape == shape
assert not (np.shares_memory(arr, ov_tensor.data))
assert np.array_equal(ov_tensor.data, arr)
assert ov_tensor.size == arr.size
assert ov_tensor.byte_size == arr.nbytes
def test_query_state_write_buffer(device, input_shape, data_type, mode):
core = Core()
if device == "CPU":
if core.get_metric(device, "FULL_DEVICE_NAME") == "arm_compute::NEON":
pytest.skip("Can't run on ARM plugin")
from openvino import Tensor
from openvino.utils.types import get_dtype
function = create_function_with_memory(input_shape, data_type)
exec_net = core.compile_model(model=function, device_name=device)
request = exec_net.create_infer_request()
mem_states = request.query_state()
mem_state = mem_states[0]
assert mem_state.name == "var_id_667"
# todo: Uncomment after fix 45611,
# CPU plugin returns outputs and memory state in FP32 in case of FP16 original precision
# assert mem_state.state.tensor_desc.precision == data_type
for i in range(1, 10):
if mode == "set_init_memory_state":
# create initial value
const_init = 5
init_array = np.full(input_shape,
const_init,
dtype=get_dtype(mem_state.state.element_type))
tensor = Tensor(init_array)
mem_state.state = tensor
res = request.infer({0: np.full(input_shape, 1, dtype=data_type)})
expected_res = np.full(input_shape,
1 + const_init,
dtype=data_type)
elif mode == "reset_memory_state":
# reset initial state of ReadValue to zero
mem_state.reset()
res = request.infer({0: np.full(input_shape, 1, dtype=data_type)})
# always ones
expected_res = np.full(input_shape, 1, dtype=data_type)
else:
res = request.infer({0: np.full(input_shape, 1, dtype=data_type)})
expected_res = np.full(input_shape, i, dtype=data_type)
assert np.allclose(res[0], expected_res, atol=1e-6), \
"Expected values: {} \n Actual values: {} \n".format(expected_res, res)
def test_core_class():
input_shape = [1, 3, 4, 4]
param = ov.parameter(input_shape, np.float32, name="parameter")
relu = ov.relu(param, name="relu")
func = Function([relu], [param], "test")
func.get_ordered_ops()[2].friendly_name = "friendly"
core = Core()
model = core.compile_model(func, "CPU", {})
request = model.create_infer_request()
input_data = np.random.rand(*input_shape).astype(np.float32) - 0.5
expected_output = np.maximum(0.0, input_data)
input_tensor = Tensor(input_data)
results = request.infer({"parameter": input_tensor})
assert np.allclose(results, expected_output)
def test_set_shape(ov_type, numpy_dtype):
shape = ng.impl.Shape([1, 3, 32, 32])
ref_shape = ng.impl.Shape([1, 3, 48, 48])
ref_shape_np = [1, 3, 28, 28]
ov_tensor = Tensor(ov_type, shape)
ov_tensor.shape = ref_shape
assert list(ov_tensor.shape) == list(ref_shape)
ones_arr = np.ones(list(ov_tensor.shape), numpy_dtype)
ov_tensor.data[:] = ones_arr
assert np.array_equal(ov_tensor.data, ones_arr)
ov_tensor.shape = ref_shape_np
assert list(ov_tensor.shape) == ref_shape_np
zeros = np.zeros(ref_shape_np, numpy_dtype)
ov_tensor.data[:] = zeros
assert np.array_equal(ov_tensor.data, zeros)
def test_init_with_numpy_fail():
arr = read_image()
with pytest.raises(RuntimeError) as e:
_ = Tensor(array=arr, shared_memory=True)
assert "Tensor with shared memory must be C contiguous" in str(e.value)
def test_cannot_set_shape_incorrect_dims():
ov_tensor = Tensor(np.float32, [1, 3, 48, 48])
with pytest.raises(RuntimeError) as e:
ov_tensor.shape = [3, 28, 28]
assert "Dims and format are inconsistent" in str(e.value)
def test_write_to_buffer(ov_type, numpy_dtype):
ov_tensor = Tensor(ov_type, ng.impl.Shape([1, 3, 32, 32]))
ones_arr = np.ones([1, 3, 32, 32], numpy_dtype)
ov_tensor.data[:] = ones_arr
assert np.array_equal(ov_tensor.data, ones_arr)
