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_value():
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(TypeError) as e:
function.add_outputs(0)
assert "Incorrect type of a value to add as output." in str(e.value)
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_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_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_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_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_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_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"
cnn_network = IENetwork(func)
core = Core()
core.set_config({}, device_name="CPU")
executable_network = core.compile_model(cnn_network, "CPU", {})
td = TensorDesc("FP32", input_shape, "NCHW")
# from IPython import embed; embed()
request = executable_network.create_infer_request()
input_data = np.random.rand(*input_shape) - 0.5
expected_output = np.maximum(0.0, input_data)
input_blob = Blob(td, input_data)
request.set_input({"parameter": input_blob})
request.infer()
result = request.get_blob("relu").buffer
assert np.allclose(result, expected_output)
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_create_IENetwork_from_nGraph():
element_type = Type.f32
param = Parameter(element_type, Shape([1, 3, 22, 22]))
relu = ov.relu(param)
func = Function([relu], [param], "test")
cnnNetwork = IENetwork(func)
assert cnnNetwork is not None
func2 = cnnNetwork.get_function()
assert func2 is not None
assert len(func2.get_ops()) == 3
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_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_multiple_outputs():
input_shape = [4, 4]
input_data = np.arange(-8, 8).reshape(input_shape).astype(np.float32)
expected_output = np.split(input_data, 2, axis=1)[0]
expected_output[expected_output < 0] = 0
test_param = ops.parameter(input_shape, dtype=np.float32, name="A")
split = ops.split(test_param, axis=1, num_splits=2)
split_first_output = split.output(0)
relu = ops.relu(split_first_output)
runtime = get_runtime()
computation = runtime.computation(relu, test_param)
output = computation(input_data)
assert np.equal(output, expected_output).all()
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_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
