def create_function_with_memory(input_shape, data_type):
input_data = ops.parameter(input_shape, name="input_data", dtype=data_type)
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")
func = Function(results=[res], sinks=[node], parameters=[input_data], name="name")
return func
def test_node_factory_wrapper_add():
shape = [2, 2]
dtype = np.int8
parameter_a = ov.parameter(shape, dtype=dtype, name="A")
parameter_b = ov.parameter(shape, dtype=dtype, name="B")
node = ov.add(parameter_a, parameter_b, name="TestNode")
assert node.get_type_name() == "Add"
assert node.get_output_size() == 1
assert list(node.get_output_shape(0)) == [2, 2]
assert node.friendly_name == "TestNode"
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_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 = Function(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_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_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_set_argument():
runtime = get_runtime()
data1 = np.array([1, 2, 3])
data2 = np.array([4, 5, 6])
data3 = np.array([7, 8, 9])
node1 = ops.constant(data1, dtype=np.float32)
node2 = ops.constant(data2, dtype=np.float32)
node3 = ops.constant(data3, dtype=np.float32)
node_add = ops.add(node1, node2)
# Original arguments
computation = runtime.computation(node_add)
output = computation()
assert np.allclose(data1 + data2, output)
# Arguments changed by set_argument
node_add.set_argument(1, node3.output(0))
output = computation()
assert np.allclose(data1 + data3, output)
# Arguments changed by set_argument
node_add.set_argument(0, node3.output(0))
output = computation()
assert np.allclose(data3 + data3, output)
# Arguments changed by set_argument(OutputVector)
node_add.set_arguments([node2.output(0), node3.output(0)])
output = computation()
assert np.allclose(data2 + data3, output)
# Arguments changed by set_arguments(NodeVector)
node_add.set_arguments([node1, node2])
output = computation()
assert np.allclose(data1 + data2, output)
def test_add_with_mul():
element_type = Type.f32
shape = Shape([4])
A = Parameter(element_type, shape)
B = Parameter(element_type, shape)
C = Parameter(element_type, shape)
parameter_list = [A, B, C]
function = Function([ov.multiply(ov.add(A, B), C)], parameter_list, "test")
runtime = get_runtime()
computation = runtime.computation(function, A, B, C)
result = computation(
np.array([1, 2, 3, 4], dtype=np.float32),
np.array([5, 6, 7, 8], dtype=np.float32),
np.array([9, 10, 11, 12], dtype=np.float32),
)[0]
a_arr = np.array([1, 2, 3, 4], dtype=np.float32)
b_arr = np.array([5, 6, 7, 8], dtype=np.float32)
c_arr = np.array([9, 10, 11, 12], dtype=np.float32)
result_arr_ref = (a_arr + b_arr) * c_arr
assert np.allclose(result, result_arr_ref)
def binary_op(op_str, a, b):
if op_str == "+":
return a + b
elif op_str == "Add":
return ov.add(a, b)
elif op_str == "-":
return a - b
elif op_str == "Sub":
return ov.subtract(a, b)
elif op_str == "*":
return a * b
elif op_str == "Mul":
return ov.multiply(a, b)
elif op_str == "/":
return a / b
elif op_str == "Div":
return ov.divide(a, b)
elif op_str == "Equal":
return ov.equal(a, b)
elif op_str == "Greater":
return ov.greater(a, b)
elif op_str == "GreaterEq":
return ov.greater_equal(a, b)
elif op_str == "Less":
return ov.less(a, b)
elif op_str == "LessEq":
return ov.less_equal(a, b)
elif op_str == "Maximum":
return ov.maximum(a, b)
elif op_str == "Minimum":
return ov.minimum(a, b)
elif op_str == "NotEqual":
return ov.not_equal(a, b)
elif op_str == "Power":
return ov.power(a, b)
def test_node_version():
node = ops.add([1], [2])
assert node.get_version() == 1
assert node.version == 1
from openvino import opset1 from openvino import opset2 from openvino import opset3 from openvino import opset4 from openvino import opset5 from openvino import opset6 from openvino import opset7 from openvino import opset8 # Helper functions for openvino module from openvino.ie_api import tensor_from_file from openvino.ie_api import compile_model # Extend Node class to support binary operators Node.__add__ = opset8.add Node.__sub__ = opset8.subtract Node.__mul__ = opset8.multiply Node.__div__ = opset8.divide Node.__truediv__ = opset8.divide Node.__radd__ = lambda left, right: opset8.add(right, left) Node.__rsub__ = lambda left, right: opset8.subtract(right, left) Node.__rmul__ = lambda left, right: opset8.multiply(right, left) Node.__rdiv__ = lambda left, right: opset8.divide(right, left) Node.__rtruediv__ = lambda left, right: opset8.divide(right, left) Node.__eq__ = opset8.equal Node.__ne__ = opset8.not_equal Node.__lt__ = opset8.less Node.__le__ = opset8.less_equal Node.__gt__ = opset8.greater Node.__ge__ = opset8.greater_equal
