def test_node_input_values():
shapes = [Shape([3]), Shape([3])]
data1 = np.array([1, 2, 3])
data2 = np.array([3, 2, 1])
node = ops.add(data1, data2)
assert node.get_input_size() == 2
assert np.equal(
[input_node.get_shape() for input_node in node.input_values()],
shapes).all()
assert np.equal([
node.input_value(i).get_shape() for i in range(node.get_input_size())
], shapes).all()
assert np.allclose([
input_node.get_node().get_vector()
for input_node in node.input_values()
], [data1, data2])
assert np.allclose([
node.input_value(i).get_node().get_vector()
for i in range(node.get_input_size())
], [data1, data2])
def test_convolution_with_non_zero_padding():
element_type = Type.f32
image_shape = Shape([1, 1, 10, 10])
filter_shape = Shape([1, 1, 3, 3])
data = Parameter(element_type, image_shape)
filters = Parameter(element_type, filter_shape)
parameter_list = [data, filters]
image_arr = np.arange(100, dtype=np.float32).reshape(1, 1, 10, 10)
filter_arr = (np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3)) * -1
filter_arr[0][0][1][1] = 1
strides = [1, 1]
dilations = [2, 2]
pads_begin = [2, 1]
pads_end = [1, 2]
model = ov.convolution(data, filters, strides, pads_begin, pads_end,
dilations)
function = Model([model], parameter_list, "test")
runtime = get_runtime()
computation = runtime.computation(function, *parameter_list)
result = computation(image_arr, filter_arr)[0]
expected = convolution2d(image_arr[0][0], filter_arr[0][0], strides,
dilations, pads_begin,
pads_end).reshape([1, 1, 9, 9])
assert np.allclose(result, expected)
def test_convolution_simple():
element_type = Type.f32
image_shape = Shape([1, 1, 16, 16])
filter_shape = Shape([1, 1, 3, 3])
data = Parameter(element_type, image_shape)
filters = Parameter(element_type, filter_shape)
parameter_list = [data, filters]
image_arr = np.arange(-128, 128, 1, dtype=np.float32).reshape(1, 1, 16, 16)
filter_arr = np.ones(9, dtype=np.float32).reshape(1, 1, 3, 3)
filter_arr[0][0][0][0] = -1
filter_arr[0][0][1][1] = -1
filter_arr[0][0][2][2] = -1
filter_arr[0][0][0][2] = -1
filter_arr[0][0][2][0] = -1
strides = [1, 1]
pads_begin = [0, 0]
pads_end = [0, 0]
dilations = [1, 1]
model = ov.convolution(data, filters, strides, pads_begin, pads_end,
dilations)
function = Model([model], parameter_list, "test")
runtime = get_runtime()
computation = runtime.computation(function, *parameter_list)
result = computation(image_arr, filter_arr)[0]
expected = convolution2d(image_arr[0][0],
filter_arr[0][0]).reshape(1, 1, 14, 14)
assert np.allclose(result, expected)
def test_proposal_props():
float_dtype = np.float32
batch_size = 1
post_nms_topn = 20
probs = ov.parameter(Shape([batch_size, 8, 255, 255]), dtype=float_dtype, name="probs")
deltas = ov.parameter(Shape([batch_size, 16, 255, 255]), dtype=float_dtype, name="bbox_deltas")
im_info = ov.parameter(Shape([4]), dtype=float_dtype, name="im_info")
attrs = {
"base_size": np.uint32(85),
"pre_nms_topn": np.uint32(10),
"post_nms_topn": np.uint32(post_nms_topn),
"nms_thresh": np.float32(0.34),
"feat_stride": np.uint32(16),
"min_size": np.uint32(32),
"ratio": np.array([0.1, 1.5, 2.0, 2.5], dtype=np.float32),
"scale": np.array([2, 3, 3, 4], dtype=np.float32),
}
node = ov.proposal(probs, deltas, im_info, attrs)
assert node.get_type_name() == "Proposal"
assert node.get_output_size() == 2
assert list(node.get_output_shape(0)) == [batch_size * post_nms_topn, 5]
assert list(node.get_output_shape(1)) == [batch_size * post_nms_topn]
assert node.get_output_element_type(0) == Type.f32
assert node.get_output_element_type(1) == Type.f32
def test_get_constant_from_source_failed():
dtype = np.int
input1 = ov.opset8.parameter(Shape([5, 5]), dtype=dtype, name="input_1")
input2 = ov.opset8.parameter(Shape([1]), dtype=dtype, name="input_2")
reshape = ov.opset8.reshape(input1, input2, special_zero=True)
folded_const = ov.utils.get_constant_from_source(reshape.input(1).get_source_output())
assert folded_const is None
def test_evaluate_invalid_input_shape():
model = create_test_model()
with pytest.raises(RuntimeError) as e:
assert model.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_get_batch():
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 = Model(add, [param1, param2], "TestFunction")
param = func.get_parameters()[0]
param.set_layout(Layout("NC"))
assert get_batch(func) == 2
def test_batched_tensors(device):
batch = 4
one_shape = Shape([1, 2, 2, 2])
batch_shape = Shape([batch, 2, 2, 2])
one_shape_size = np.prod(one_shape)
core = Core()
core.register_plugin("openvino_template_plugin", "TEMPLATE")
data1 = ops.parameter(batch_shape, np.float32)
data1.set_friendly_name("input0")
data1.get_output_tensor(0).set_names({"tensor_input0"})
data1.set_layout(Layout("N..."))
constant = ops.constant([1], np.float32)
op1 = ops.add(data1, constant)
op1.set_friendly_name("Add0")
res1 = ops.result(op1)
res1.set_friendly_name("Result0")
res1.get_output_tensor(0).set_names({"tensor_output0"})
model = Model([res1], [data1])
compiled = core.compile_model(model, "TEMPLATE")
buffer = np.zeros([one_shape_size * batch * 2], dtype=np.float32)
req = compiled.create_infer_request()
tensors = []
for i in range(0, batch):
_start = i * one_shape_size * 2
# Use of special constructor for Tensor.
# It creates a Tensor from pointer, thus it requires only
# one element from original buffer, and shape to "crop".
tensor = Tensor(buffer[_start:(_start + 1)], one_shape)
tensors.append(tensor)
req.set_input_tensors(tensors) # using list overload!
actual_tensor = req.get_tensor("tensor_output0")
actual = actual_tensor.data
for test_num in range(0, 5):
for i in range(0, batch):
tensors[i].data[:] = test_num + 10
req.infer() # Adds '1' to each element
# Reference values for each batch:
_tmp = np.array([test_num + 11] * one_shape_size,
dtype=np.float32).reshape([2, 2, 2])
for j in range(0, batch):
assert np.array_equal(actual[j], _tmp)
def test_set_batch_default_batch_size():
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 = Model(add, [param1, param2], "TestFunction")
func_param1 = func.get_parameters()[0]
func_param1.set_layout(Layout("NC"))
set_batch(func)
assert func.is_dynamic()
def test_swish_props_with_beta():
float_dtype = np.float32
data = ov.parameter(Shape([3, 10]), dtype=float_dtype, name="data")
beta = ov.parameter(Shape([]), dtype=float_dtype, name="beta")
node = ov.swish(data, beta)
assert node.get_type_name() == "Swish"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [3, 10]
assert node.get_output_element_type(0) == Type.f32
def test_get_constant_from_source_success():
dtype = np.int
input1 = ov.opset8.parameter(Shape([5, 5]), dtype=dtype, name="input_1")
input2 = ov.opset8.parameter(Shape([25]), dtype=dtype, name="input_2")
shape_of = ov.opset8.shape_of(input2, name="shape_of")
reshape = ov.opset8.reshape(input1, shape_of, special_zero=True)
folded_const = ov.utils.get_constant_from_source(reshape.input(1).get_source_output())
assert folded_const is not None
assert folded_const.get_vector() == [25]
def test_get_batch_CHWN():
param1 = ops.parameter(Shape([3, 1, 3, 4]), dtype=np.float32, name="data1")
param2 = ops.parameter(Shape([3, 1, 3, 4]), dtype=np.float32, name="data2")
param3 = ops.parameter(Shape([3, 1, 3, 4]), dtype=np.float32, name="data3")
add = ops.add(param1, param2)
add2 = ops.add(add, param3)
func = Model(add2, [param1, param2, param3], "TestFunction")
param = func.get_parameters()[0]
param.set_layout(Layout("CHWN"))
assert get_batch(func) == 4
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 = Model(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 _fill_input(self, model, image_batch):
"""Matches network input name with corresponding input batch
:param model: IENetwork instance
:param image_batch: list of ndarray images or list with a dictionary of inputs mapping
"""
input_info = model.inputs
if isinstance(image_batch[0], dict):
feed_dict = {}
input_blobs = {get_clean_name(in_node.get_node().friendly_name): in_node for in_node in input_info}
for input_name in image_batch[0].keys():
input_blob = input_blobs[input_name]
input_blob_name = self._get_input_any_name(input_blob)
feed_dict[input_blob_name] = np.reshape(image_batch[0][input_name], input_blob.shape)
return feed_dict
if len(input_info) == 1:
input_blob = next(iter(input_info))
input_blob_name = self._get_input_any_name(input_blob)
image_batch = {input_blob_name: np.reshape(image_batch, input_blob.shape)}
if Shape(image_batch[input_blob_name].shape) != input_info[0].shape:
raise ValueError(f"Incompatible input shapes. "
f"Cannot infer {Shape(image_batch[input_blob_name].shape)} into {input_info[0].shape}."
f"Try to specify the layout of the model.")
return image_batch
if len(input_info) == 2:
image_info_nodes = list(filter(
lambda x: len(x.shape) == 2, input_info))
if len(image_info_nodes) != 1:
raise Exception('Two inputs networks must contain exactly one ImageInfo node')
image_info_node = image_info_nodes[0]
image_info_name = self._get_input_any_name(image_info_node)
image_tensor_node = next(iter(filter(
lambda x: x.get_any_name() != image_info_name, input_info)))
image_tensor_name = image_tensor_node.get_any_name()
image_tensor = (image_tensor_name, np.reshape(image_batch, input_blob.shape))
if Shape(image_tensor[1].shape) != image_tensor_node.shape:
raise ValueError(f"Incompatible input shapes. "
f"Cannot infer {Shape(image_tensor[1].shape)} into {image_tensor_node.shape}."
f"Try to specify the layout of the model.")
ch, height, width = image_batch[0].shape
image_info = (image_info_name,
np.stack(np.array([(height, width, ch)] * len(image_batch)), axis=0))
return dict((k, v) for k, v in [image_tensor, image_info])
raise Exception('Unsupported number of inputs')
def test_validate_nodes_and_infer_types():
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 = Model(add, [param1, param2], "TestFunction")
invalid_shape = Shape([3, 7])
param3 = ops.parameter(invalid_shape, dtype=np.float32, name="data3")
func.replace_parameter(0, param3)
with pytest.raises(RuntimeError) as e:
func.validate_nodes_and_infer_types()
assert "Argument shapes are inconsistent" in str(e.value)
def test_gather_elements():
indices_type = np.int32
data_dtype = np.float32
data = ov.parameter(Shape([2, 5]), dtype=data_dtype, name="data")
indices = ov.parameter(Shape([2, 100]), dtype=indices_type, name="indices")
axis = 1
expected_shape = [2, 100]
node = ov.gather_elements(data, indices, axis)
assert node.get_type_name() == "GatherElements"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == expected_shape
assert node.get_output_element_type(0) == Type.f32
def test_reshape():
element_type = Type.f32
shape = Shape([2, 3])
A = Parameter(element_type, shape)
parameter_list = [A]
function = Model([ov.reshape(A, Shape([3, 2]), special_zero=False)], parameter_list, "test")
runtime = get_runtime()
computation = runtime.computation(function, *parameter_list)
result = computation(np.array(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32), dtype=np.float32))[0]
expected = np.reshape(np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32), (3, 2))
assert np.allclose(result, expected)
def test_simple_loop():
X = ov.parameter(Shape([32, 1, 10]), np.float32, "X")
Y = ov.parameter(Shape([32, 1, 10]), np.float32, "Y")
M = ov.parameter(Shape([32, 1, 10]), np.float32, "M")
input_shape = Shape([])
current_iteration = ov.parameter(Shape([1]), np.int64)
X_i = ov.parameter(input_shape, np.float32)
Y_i = ov.parameter(input_shape, np.float32)
M_body = ov.parameter(input_shape, np.float32)
bool_val = np.array([1], dtype=np.bool)
bool_val[0] = True
body_condition = ov.constant(bool_val)
trip_count = ov.constant(10, dtype=np.int64)
exec_condition = ov.constant(True, dtype=np.bool)
sum = ov.add(X_i, Y_i)
Zo = ov.multiply(sum, M_body)
body = Model([body_condition, Zo], [current_iteration, X_i, Y_i, M_body],
"body_function")
loop = ov.loop(trip_count, exec_condition)
loop.set_function(body)
loop.set_invariant_input(X_i, X.output(0))
loop.set_invariant_input(Y_i, Y.output(0))
loop.set_merged_input(M_body, M.output(0), Zo.output(0))
loop.set_special_body_ports([-1, 0])
out0 = loop.get_iter_value(body_condition.output(0), -1)
out1 = loop.get_iter_value(Zo.output(0), -1)
out2 = loop.get_concatenated_slices(Zo.output(0), 0, 1, 1, -1, 1)
result0 = ov.result(out0)
result1 = ov.result(out1)
result2 = ov.result(out2)
out0_shape = [1]
out1_shape = [32, 1, 10]
out2_shape = [32, 10, 10]
assert list(result0.get_output_shape(0)) == out0_shape
assert list(result1.get_output_shape(0)) == out1_shape
assert list(result2.get_output_shape(0)) == out2_shape
assert list(loop.get_output_shape(0)) == out0_shape
assert list(loop.get_output_shape(1)) == out1_shape
assert list(loop.get_output_shape(2)) == out2_shape
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 = Model(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_dynamic_model(device):
core = Core()
param = ops.parameter(PartialShape([-1, -1]))
model = Model(ops.relu(param), [param])
compiled = core.compile_model(model, device)
assert compiled.input().partial_shape.is_dynamic
request = compiled.create_infer_request()
shape1 = [1, 28]
request.infer([np.random.normal(size=shape1)])
assert request.get_input_tensor().shape == Shape(shape1)
shape2 = [1, 32]
request.infer([np.random.normal(size=shape2)])
assert request.get_input_tensor().shape == Shape(shape2)
def test_input_get_shape(device):
core = Core()
func = core.read_model(model=test_net_xml, weights=test_net_bin)
exec_net = core.compile_model(func, device)
input = exec_net.output(0)
input_node = input.get_node().inputs()[0]
assert str(input_node.get_shape()) == str(Shape([1, 10]))
def test_output_shape(device):
core = Core()
func = core.read_model(model=test_net_xml, weights=test_net_bin)
exec_net = core.compile_model(func, device)
output = exec_net.output(0)
expected_shape = Shape([1, 10])
assert str(output.get_shape()) == str(expected_shape)
def get_test_function():
element_type = Type.f32
param = Parameter(element_type, Shape([1, 3, 22, 22]))
relu = ops.relu(param)
func = Model([relu], [param], "test")
assert func is not None
return func
def roi_pooling(
input: NodeInput,
coords: NodeInput,
output_size: TensorShape,
spatial_scale: NumericData,
method: str,
name: Optional[str] = None,
) -> Node:
"""Return a node which produces an ROIPooling operation.
@param input: Input feature map {N, C, ...}
@param coords: Coordinates of bounding boxes
@param output_size: Height/Width of ROI output features (shape)
@param spatial_scale: Ratio of input feature map over input image size (float)
@param method: Method of pooling - string: "max" or "bilinear"
@return ROIPooling node
"""
method = method.lower()
return _get_node_factory_opset2().create(
"ROIPooling",
as_nodes(input, coords),
{
"output_size": Shape(output_size),
"spatial_scale": spatial_scale,
"method": method
},
)
def test_input_shape_read_only():
shape = Shape([1, 10])
param = ov.parameter(shape, dtype=np.float32)
model = Model(ov.relu(param), [param])
ref_shape = model.input().shape
ref_shape[0] = Dimension(3)
assert model.input().shape == shape
def test_node_input():
shape = [2, 2]
parameter_a = ops.parameter(shape, dtype=np.float32, name="A")
parameter_b = ops.parameter(shape, dtype=np.float32, name="B")
model = parameter_a + parameter_b
model_inputs = model.inputs()
assert len(model_inputs) == 2
assert [input_node.get_index() for input_node in model_inputs] == [0, 1]
assert np.equal(
[input_node.get_element_type() for input_node in model_inputs],
model.get_element_type(),
).all()
assert np.equal([input_node.get_shape() for input_node in model_inputs],
Shape(shape)).all()
assert np.equal(
[input_node.get_partial_shape() for input_node in model_inputs],
PartialShape(shape),
).all()
input0 = model.input(0)
input1 = model.input(1)
assert [input0.get_index(), input1.get_index()] == [0, 1]
def test_const_output_get_shape(device):
core = Core()
func = core.read_model(model=test_net_xml, weights=test_net_bin)
exec_net = core.compile_model(func, device)
node = exec_net.input("data")
expected_shape = Shape([1, 3, 32, 32])
assert str(node.get_shape()) == str(expected_shape)
assert str(node.shape) == str(expected_shape)
def test_set_batch_int():
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 = Model(add, [param1, param2], "TestFunction")
func_param1 = func.get_parameters()[0]
func_param2 = func.get_parameters()[1]
# batch == 2
func_param1.set_layout(Layout("NC"))
assert get_batch(func) == 2
# set batch to 1
set_batch(func, 1)
assert get_batch(func) == 1
# check if shape of param 1 has changed
assert str(func_param1.get_output_shape(0) == {1, 1})
# check if shape of param 2 has not changed
assert str(func_param2.get_output_shape(0) == {2, 1})
def test_evaluate():
model = create_test_model()
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 model.evaluate([out_tensor], [Tensor(input1), Tensor(input2)])
assert np.allclose(out_tensor.data, np.array([5, 8]).reshape(2, 1))
def test_hsigmoid():
float_dtype = np.float32
data = ov.parameter(Shape([3, 10]), dtype=float_dtype, name="data")
node = ov.hsigmoid(data)
assert node.get_type_name() == "HSigmoid"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [3, 10]
assert node.get_output_element_type(0) == Type.f32
