def test_ngraph_function_api():
shape = [2, 2]
parameter_a = ops.parameter(shape, dtype=np.float32, name="A")
parameter_b = ops.parameter(shape, dtype=np.float32, name="B")
parameter_c = ops.parameter(shape, dtype=np.float32, name="C")
model = (parameter_a + parameter_b) * parameter_c
function = Function(model, [parameter_a, parameter_b, parameter_c],
"TestFunction")
function.get_parameters()[1].set_partial_shape(PartialShape([3, 4, 5]))
ordered_ops = function.get_ordered_ops()
op_types = [op.get_type_name() for op in ordered_ops]
assert op_types == [
"Parameter", "Parameter", "Parameter", "Add", "Multiply", "Result"
]
assert len(function.get_ops()) == 6
assert function.get_output_size() == 1
assert function.get_output_op(0).get_type_name() == "Result"
assert function.get_output_element_type(
0) == parameter_a.get_element_type()
assert list(function.get_output_shape(0)) == [2, 2]
assert (function.get_parameters()[1].get_partial_shape()) == PartialShape(
[3, 4, 5])
assert len(function.get_parameters()) == 3
assert len(function.get_results()) == 1
assert function.get_friendly_name() == "TestFunction"
def test_parameter_index_invalid():
shape1 = PartialShape([1])
param1 = ops.parameter(shape1, dtype=np.float32, name="data1")
relu = ops.relu(param1, name="relu")
function = Function(relu, [param1], "TestFunction")
shape2 = PartialShape([2])
param2 = ops.parameter(shape2, dtype=np.float32, name="data2")
assert function.get_parameter_index(param2) == -1
def test_tensor_descriptor_api():
td = Tensor(Type.f32, PartialShape([1, 1, 1, 1]), "tensor_name")
td.names = {"tensor_name"}
assert "tensor_name" in td.names
assert isinstance(td, Tensor)
assert td.element_type == Type.f32
assert td.partial_shape == PartialShape([1, 1, 1, 1])
assert repr(td.shape) == "<Shape: {1, 1, 1, 1}>"
assert td.size == 4
assert td.any_name == "tensor_name"
def __call__(self, *input_values: NumericData) -> List[NumericData]:
"""Run computation on input values and return result."""
# Input validation
if len(input_values) < len(self.parameters):
raise UserInputError(
"Expected %s params, received not enough %s values.",
len(self.parameters), len(input_values))
param_names = [param.friendly_name for param in self.parameters]
input_shapes = [get_shape(input_value) for input_value in input_values]
if self.network_cache.get(str(input_shapes)) is None:
function = self.function
if self.function.is_dynamic():
function.reshape(
dict(
zip(param_names,
[PartialShape(i) for i in input_shapes])))
self.network_cache[str(input_shapes)] = function
else:
function = self.network_cache[str(input_shapes)]
executable_network = self.runtime.backend.compile_model(
function, self.runtime.backend_name)
for parameter, input in zip(self.parameters, input_values):
parameter_shape = parameter.get_output_partial_shape(0)
input_shape = PartialShape([]) if isinstance(
input, (int, float)) else PartialShape(input.shape)
if not parameter_shape.compatible(input_shape):
raise UserInputError(
"Provided tensor's shape: %s does not match the expected: %s.",
input_shape,
parameter_shape,
)
request = executable_network.create_infer_request()
result_buffers = request.infer(dict(zip(param_names, input_values)))
# # Note: other methods to get result_buffers from request
# # First call infer with no return value:
# request.infer(dict(zip(param_names, input_values)))
# # Now use any of following options:
# result_buffers = [request.get_tensor(n).data for n in request.outputs]
# result_buffers = [request.get_output_tensor(i).data for i in range(len(request.outputs))]
# result_buffers = [t.data for t in request.output_tensors]
# # Since OV overwrite result data type we have to convert results to the original one.
original_dtypes = [
get_dtype(result.get_output_element_type(0))
for result in self.results
]
converted_buffers = self.convert_buffers(result_buffers,
original_dtypes)
return converted_buffers
def test_replace_parameter():
shape1 = PartialShape([1])
param1 = ops.parameter(shape1, dtype=np.float32, name="data")
shape2 = PartialShape([2])
param2 = ops.parameter(shape2, dtype=np.float32, name="data")
relu = ops.relu(param1, name="relu")
function = Function(relu, [param1], "TestFunction")
param_index = function.get_parameter_index(param1)
function.replace_parameter(param_index, param2)
assert function.get_parameter_index(param2) == param_index
assert function.get_parameter_index(param1) == -1
def test_get_result_index_invalid():
shape1 = PartialShape([1])
param1 = ops.parameter(shape1, dtype=np.float32, name="data1")
relu1 = ops.relu(param1, name="relu1")
function = Function(relu1, [param1], "TestFunction")
shape2 = PartialShape([2])
param2 = ops.parameter(shape2, dtype=np.float32, name="data2")
relu2 = ops.relu(param2, name="relu2")
invalid_output = relu2.outputs()[0]
assert len(function.outputs) == 1
assert function.get_result_index(invalid_output) == -1
def test_partial_shape_equals():
ps1 = PartialShape.dynamic()
ps2 = PartialShape.dynamic()
assert ps1 == ps2
ps1 = PartialShape([1, 2, 3])
ps2 = PartialShape([1, 2, 3])
assert ps1 == ps2
shape = Shape([1, 2, 3])
ps = PartialShape([1, 2, 3])
assert shape == ps
def test_get_result_index():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu = ops.relu(param, name="relu")
function = Function(relu, [param], "TestFunction")
assert len(function.outputs) == 1
assert function.get_result_index(function.outputs[0]) == 0
def test_node_output():
input_array = np.array([0, 1, 2, 3, 4, 5])
splits = 3
expected_shape = len(input_array) // splits
input_tensor = ops.constant(input_array, dtype=np.int32)
axis = ops.constant(0, dtype=np.int64)
split_node = ops.split(input_tensor, axis, splits)
split_node_outputs = split_node.outputs()
assert len(split_node_outputs) == splits
assert [output_node.get_index() for output_node in split_node_outputs] == [0, 1, 2]
assert np.equal(
[output_node.get_element_type() for output_node in split_node_outputs],
input_tensor.get_element_type(),
).all()
assert np.equal(
[output_node.get_shape() for output_node in split_node_outputs],
Shape([expected_shape]),
).all()
assert np.equal(
[output_node.get_partial_shape() for output_node in split_node_outputs],
PartialShape([expected_shape]),
).all()
output0 = split_node.output(0)
output1 = split_node.output(1)
output2 = split_node.output(2)
assert [output0.get_index(), output1.get_index(), output2.get_index()] == [0, 1, 2]
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_partial_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_partial_shape = PartialShape([1, 3, 32, 32])
assert node.get_partial_shape() == expected_partial_shape
def test_info_update():
info1 = VariableInfo()
info1.data_shape = PartialShape([1])
info1.data_type = Type.f32
info1.variable_id = "test_id"
variable = Variable(info1)
info2 = VariableInfo()
info2.data_shape = PartialShape([2, 1])
info2.data_type = Type.i64
info2.variable_id = "test_id2"
variable.update(info2)
assert variable.info.data_shape == info2.data_shape
assert variable.info.data_type == info2.data_type
assert variable.info.variable_id == info2.variable_id
def test_info_as_property():
info = VariableInfo()
info.data_shape = PartialShape([1])
info.data_type = Type.f32
info.variable_id = "test_id"
variable = Variable(info)
assert variable.info.data_shape == info.data_shape
assert variable.info.data_type == info.data_type
assert variable.info.variable_id == info.variable_id
def test_function_add_output_port():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu1 = ops.relu(param, name="relu1")
relu1.get_output_tensor(0).set_names({"relu_t1"})
relu2 = ops.relu(relu1, name="relu2")
function = Function(relu2, [param], "TestFunction")
assert len(function.get_results()) == 1
function.add_outputs(relu1.output(0))
assert len(function.get_results()) == 2
def test_function_add_output_incorrect_tensor_name():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu1 = ops.relu(param, name="relu1")
relu1.get_output_tensor(0).set_names({"relu_t1"})
relu2 = ops.relu(relu1, name="relu2")
function = Function(relu2, [param], "TestFunction")
assert len(function.get_results()) == 1
with pytest.raises(RuntimeError) as e:
function.add_outputs("relu_t")
assert "Tensor name relu_t was not found." in str(e.value)
def test_add_outputs_incorrect_outputs_list():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu1 = ops.relu(param, name="relu1")
relu1.get_output_tensor(0).set_names({"relu_t1"})
function = Function(relu1, [param], "TestFunction")
assert len(function.get_results()) == 1
with pytest.raises(TypeError) as e:
function.add_outputs([0, 0])
assert "Incorrect type of a value to add as output at index 0" in str(
e.value)
def test_runtime_info():
test_shape = PartialShape([1, 1, 1, 1])
test_type = Type.f32
test_param = Parameter(test_type, test_shape)
relu_node = ops.relu(test_param)
runtime_info = relu_node.get_rt_info()
runtime_info["affinity"] = "test_affinity"
relu_node.set_friendly_name("testReLU")
runtime_info_after = relu_node.get_rt_info()
assert runtime_info_after["affinity"] == "test_affinity"
def test_add_outputs_several_tensors():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu1 = ops.relu(param, name="relu1")
relu1.get_output_tensor(0).set_names({"relu_t1"})
relu2 = ops.relu(relu1, name="relu2")
relu2.get_output_tensor(0).set_names({"relu_t2"})
relu3 = ops.relu(relu2, name="relu3")
function = Function(relu3, [param], "TestFunction")
assert len(function.get_results()) == 1
function.add_outputs(["relu_t1", "relu_t2"])
assert len(function.get_results()) == 3
def test_function_add_output_incorrect_idx():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu1 = ops.relu(param, name="relu1")
relu1.get_output_tensor(0).set_names({"relu_t1"})
relu2 = ops.relu(relu1, name="relu2")
function = Function(relu2, [param], "TestFunction")
assert len(function.get_results()) == 1
with pytest.raises(RuntimeError) as e:
function.add_outputs(("relu1", 10))
assert "Cannot add output to port 10 operation relu1 has only 1 outputs." in str(
e.value)
def test_function_add_outputs_tensor_name():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu1 = ops.relu(param, name="relu1")
relu1.get_output_tensor(0).set_names({"relu_t1"})
assert "relu_t1" in relu1.get_output_tensor(0).names
relu2 = ops.relu(relu1, name="relu2")
function = Function(relu2, [param], "TestFunction")
assert len(function.get_results()) == 1
function.add_outputs("relu_t1")
assert len(function.get_results()) == 2
assert isinstance(function.outputs[1].get_tensor(), Tensor)
assert "relu_t1" in function.outputs[1].get_tensor().names
def test_function_add_outputs_op_name():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu1 = ops.relu(param, name="relu1")
relu1.get_output_tensor(0).set_names({"relu_t1"})
relu2 = ops.relu(relu1, name="relu2")
function = Function(relu2, [param], "TestFunction")
assert len(function.get_results()) == 1
new_outs = function.add_outputs(("relu1", 0))
assert len(function.get_results()) == 2
assert len(new_outs) == 1
assert new_outs[0].get_node() == function.outputs[1].get_node()
assert new_outs[0].get_index() == function.outputs[1].get_index()
def test_repr_dynamic_shape():
shape = PartialShape([-1, 2])
parameter_a = ov.parameter(shape, dtype=np.float32, name="A")
parameter_b = ov.parameter(shape, dtype=np.float32, name="B")
model = parameter_a + parameter_b
function = Function(model, [parameter_a, parameter_b],
"simple_dyn_shapes_graph")
assert repr(function) == "<Function: 'simple_dyn_shapes_graph' ({?,2})>"
ops = function.get_ordered_ops()
for op in ops:
assert "{?,2}" in repr(op)
def test_ngraph_function_api():
shape = [2, 2]
parameter_a = ops.parameter(shape, dtype=np.float32, name="A")
parameter_b = ops.parameter(shape, dtype=np.float32, name="B")
parameter_c = ops.parameter(shape, dtype=np.float32, name="C")
model = (parameter_a + parameter_b) * parameter_c
assert parameter_a.element_type == Type.f32
assert parameter_a.partial_shape == PartialShape([2, 2])
parameter_a.layout = ov.Layout("NCWH")
assert parameter_a.layout == ov.Layout("NCWH")
function = Function(model, [parameter_a, parameter_b, parameter_c], "TestFunction")
function.get_parameters()[1].set_partial_shape(PartialShape([3, 4, 5]))
ordered_ops = function.get_ordered_ops()
op_types = [op.get_type_name() for op in ordered_ops]
assert op_types == ["Parameter", "Parameter", "Parameter", "Add", "Multiply", "Result"]
assert len(function.get_ops()) == 6
assert function.get_output_size() == 1
assert ["A", "B", "C"] == [input.get_node().friendly_name for input in function.inputs]
assert ["Result"] == [output.get_node().get_type_name() for output in function.outputs]
assert function.input(0).get_node().friendly_name == "A"
assert function.output(0).get_node().get_type_name() == "Result"
assert function.input(tensor_name="A").get_node().friendly_name == "A"
assert function.output().get_node().get_type_name() == "Result"
assert function.get_output_op(0).get_type_name() == "Result"
assert function.get_output_element_type(0) == parameter_a.get_element_type()
assert list(function.get_output_shape(0)) == [2, 2]
assert (function.get_parameters()[1].get_partial_shape()) == PartialShape([3, 4, 5])
assert len(function.get_parameters()) == 3
results = function.get_results()
assert len(results) == 1
assert results[0].get_output_element_type(0) == Type.f32
assert results[0].get_output_partial_shape(0) == PartialShape([2, 2])
results[0].layout = ov.Layout("NC")
assert results[0].layout.to_string() == ov.Layout("NC")
assert function.get_friendly_name() == "TestFunction"
def test_sink_function_ctor():
input_data = ops.parameter([2, 2], name="input_data", dtype=np.float32)
rv = ops.read_value(input_data, "var_id_667")
add = ops.add(rv, input_data, name="MemoryAdd")
node = ops.assign(add, "var_id_667")
res = ops.result(add, "res")
function = Function(results=[res], sinks=[node], parameters=[input_data], name="TestFunction")
ordered_ops = function.get_ordered_ops()
op_types = [op.get_type_name() for op in ordered_ops]
assert op_types == ["Parameter", "ReadValue", "Add", "Assign", "Result"]
assert len(function.get_ops()) == 5
assert function.get_output_size() == 1
assert function.get_output_op(0).get_type_name() == "Result"
assert function.get_output_element_type(0) == input_data.get_element_type()
assert list(function.get_output_shape(0)) == [2, 2]
assert (function.get_parameters()[0].get_partial_shape()) == PartialShape([2, 2])
assert len(function.get_parameters()) == 1
assert len(function.get_results()) == 1
assert function.get_friendly_name() == "TestFunction"
def test_parameter_index():
input_shape = PartialShape([1])
param = ops.parameter(input_shape, dtype=np.float32, name="data")
relu = ops.relu(param, name="relu")
function = Function(relu, [param], "TestFunction")
assert function.get_parameter_index(param) == 0
def test_partial_shape():
ps = PartialShape([1, 2, 3, 4])
assert ps.is_static
assert not ps.is_dynamic
assert ps.rank == 4
assert repr(ps) == "<PartialShape: {1,2,3,4}>"
assert ps.get_dimension(0) == Dimension(1)
assert ps.get_dimension(1) == Dimension(2)
assert ps.get_dimension(2) == Dimension(3)
assert ps.get_dimension(3) == Dimension(4)
shape = Shape([1, 2, 3])
ps = PartialShape(shape)
assert ps.is_static
assert not ps.is_dynamic
assert ps.all_non_negative
assert ps.rank == 3
assert list(ps.get_shape()) == [1, 2, 3]
assert list(ps.get_max_shape()) == [1, 2, 3]
assert list(ps.get_min_shape()) == [1, 2, 3]
assert list(ps.to_shape()) == [1, 2, 3]
assert repr(shape) == "<Shape: {1, 2, 3}>"
assert repr(ps) == "<PartialShape: {1,2,3}>"
ps = PartialShape(
[Dimension(1),
Dimension(2),
Dimension(3),
Dimension.dynamic()])
assert not ps.is_static
assert ps.is_dynamic
assert ps.all_non_negative
assert ps.rank == 4
assert list(ps.get_min_shape()) == [1, 2, 3, 0]
assert list(ps.get_max_shape())[3] > 1000000000
assert repr(ps) == "<PartialShape: {1,2,3,?}>"
assert ps.get_dimension(0) == Dimension(1)
assert ps.get_dimension(1) == Dimension(2)
assert ps.get_dimension(2) == Dimension(3)
assert ps.get_dimension(3) == Dimension.dynamic()
ps = PartialShape([1, 2, 3, -1])
assert not ps.is_static
assert ps.is_dynamic
assert ps.all_non_negative
assert ps.rank == 4
assert list(ps.get_min_shape()) == [1, 2, 3, 0]
assert list(ps.get_max_shape())[3] > 1000000000
assert repr(ps) == "<PartialShape: {1,2,3,?}>"
ps = PartialShape.dynamic()
assert not ps.is_static
assert ps.is_dynamic
assert ps.rank == Dimension.dynamic()
assert list(ps.get_min_shape()) == []
assert list(ps.get_max_shape()) == []
assert repr(ps) == "<PartialShape: ?>"
ps = PartialShape.dynamic(r=Dimension(2))
assert not ps.is_static
assert ps.is_dynamic
assert ps.rank == 2
assert 2 == ps.rank
assert list(ps.get_min_shape()) == [0, 0]
assert list(ps.get_max_shape())[0] > 1000000000
assert repr(ps) == "<PartialShape: {?,?}>"
def test_partial_shape_same_scheme():
ps1 = PartialShape([1, 2, -1])
ps2 = PartialShape([1, 3, -1])
assert not ps1.same_scheme(ps2)
ps1 = PartialShape([1, 2, -1])
ps2 = PartialShape([1, 2, -1])
assert ps1.same_scheme(ps2)
ps1 = PartialShape([1, 2, 3])
ps2 = PartialShape([1, 2, 3])
assert ps1.same_scheme(ps2)
ps1 = PartialShape([-1, 2, 3])
ps2 = PartialShape([1, -1, 3])
assert not ps1.same_scheme(ps2)
ps1 = PartialShape.dynamic()
ps2 = PartialShape.dynamic()
assert ps1.same_scheme(ps2)
def test_partial_shape_refinement():
ps1 = PartialShape.dynamic()
ps2 = PartialShape.dynamic()
assert ps1.refines(ps2)
assert ps1.relaxes(ps2)
assert ps2.refines(ps1)
assert ps2.relaxes(ps1)
ps1 = PartialShape.dynamic()
ps2 = PartialShape([3, -1, 7, 9])
assert not ps1.refines(ps2)
assert ps1.relaxes(ps2)
assert ps2.refines(ps1)
assert not ps2.relaxes(ps1)
ps1 = PartialShape.dynamic()
ps2 = PartialShape([3, 5, 7, 9])
assert not ps1.refines(ps2)
assert ps1.relaxes(ps2)
assert ps2.refines(ps1)
assert not ps2.relaxes(ps1)
def __call__(self, *input_values: NumericData) -> List[NumericData]:
"""Run computation on input values and return result."""
# Input validation
if len(input_values) < len(self.parameters):
raise UserInputError(
"Expected %s params, received not enough %s values.",
len(self.parameters), len(input_values))
# ignore not needed input values
input_values = input_values[:len(self.parameters)]
input_values = [
_convert_val(input_value) for input_value in input_values
]
input_shapes = [get_shape(input_value) for input_value in input_values]
param_names = [param.friendly_name for param in self.parameters]
if self.network_cache.get(str(input_shapes)) is None:
cnn_network = IENetwork(self.function)
if self.function.is_dynamic():
cnn_network.reshape(dict(zip(param_names, input_shapes)))
# Convert unsupported inputs of the network
_convert_inputs(cnn_network)
self.network_cache[str(input_shapes)] = cnn_network
else:
cnn_network = self.network_cache[str(input_shapes)]
# set output blobs precission based on nG results
for ng_result in self.results:
ie_out_name = self._get_ie_output_blob_name(
cnn_network.outputs, ng_result)
apply_ng_type(cnn_network.outputs[ie_out_name],
ng_result.get_output_element_type(0))
executable_network = self.runtime.backend.load_network(
cnn_network, self.runtime.backend_name)
for parameter, input in zip(self.parameters, input_values):
parameter_shape = parameter.get_output_partial_shape(0)
input_shape = PartialShape(input.shape)
if len(input.shape) > 0 and not parameter_shape.compatible(
input_shape):
raise UserInputError(
"Provided tensor's shape: %s does not match the expected: %s.",
input_shape,
parameter_shape,
)
request = executable_network.create_infer_request()
request.infer(dict(zip(param_names, input_values)))
# Set order of output blobs compatible with nG Function
result_buffers = [
self._get_ie_output_blob_buffer(request.output_blobs, result)
for result in self.results
]
# Since OV overwrite result data type we have to convert results to the original one.
original_dtypes = [
get_dtype(result.get_output_element_type(0))
for result in self.results
]
converted_buffers = self.convert_buffers(result_buffers,
original_dtypes)
return converted_buffers
def test_partial_shape_compatible():
ps1 = PartialShape.dynamic()
ps2 = PartialShape.dynamic()
assert ps1.compatible(ps2)
ps1 = PartialShape([3])
ps2 = PartialShape.dynamic()
assert ps1.compatible(ps2)
ps1 = PartialShape.dynamic()
ps2 = PartialShape([4])
assert ps1.compatible(ps2)
ps1 = PartialShape([2, -1, 3, -1, 5])
ps2 = PartialShape([2, -1, -1, 4, 5])
assert ps1.compatible(ps2)
ps1 = PartialShape([2, -1, 3, -1, 5])
ps2 = PartialShape([1, -1, -1, 4, 5])
assert not ps1.compatible(ps2)
