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)