def test_compress_model_transformation():
node_constant = ov.opset8.constant(np.array([[0.0, 0.1, -0.1], [-2.5, 2.5, 3.0]], dtype=np.float32))
node_ceil = ov.opset8.ceiling(node_constant)
func = Model(node_ceil, [], "TestFunction")
assert func.get_ordered_ops()[0].get_element_type().get_type_name() == "f32"
compress_model_transformation(func)
assert func is not None
assert func.get_ordered_ops()[0].get_element_type().get_type_name() == "f16"
def test_default_version_IR_V11_seperate_paths():
core = Core()
xml_path = "./serialized_function.xml"
bin_path = "./serialized_function.bin"
shape = [100, 100, 2]
parameter_a = ov.parameter(shape, dtype=np.float32, name="A")
parameter_b = ov.parameter(shape, dtype=np.float32, name="B")
parameter_c = ov.parameter(shape, dtype=np.float32, name="C")
parameter_d = ov.parameter(shape, dtype=np.float32, name="D")
model = ov.floor(
ov.minimum(ov.abs(parameter_a), ov.multiply(parameter_b, parameter_c)))
func = Model(model, [parameter_a, parameter_b, parameter_c], "Model")
pass_manager = Manager()
pass_manager.register_pass("Serialize",
xml_path=xml_path,
bin_path=bin_path,
version="IR_V11")
pass_manager.run_passes(func)
res_func = core.read_model(model=xml_path, weights=bin_path)
assert func.get_parameters() == res_func.get_parameters()
assert func.get_ordered_ops() == res_func.get_ordered_ops()
os.remove(xml_path)
os.remove(bin_path)
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 = Model(model, [parameter_a, parameter_b],
"simple_dyn_shapes_graph")
assert repr(function) == "<Model: 'simple_dyn_shapes_graph' ({?,2})>"
ops = function.get_ordered_ops()
for op in ops:
assert "{?,2}" in repr(op)
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 = Model(model, [parameter_a, parameter_b],
"simple_dyn_shapes_graph")
assert repr(function) == "<Model: 'simple_dyn_shapes_graph'\ninputs[" + \
"\n<ConstOutput: names[A] shape{?,2} type: f32>," +\
"\n<ConstOutput: names[B] shape{?,2} type: f32>\n]" + \
"\noutputs[\n<ConstOutput: names[] shape{?,2} type: f32>\n]>"
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=Type.f32, 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_b.element_type == Type.f32
assert parameter_a.partial_shape == PartialShape([2, 2])
parameter_a.layout = ov.Layout("NC")
assert parameter_a.layout == ov.Layout("NC")
function = Model(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_core_class():
input_shape = [1, 3, 4, 4]
param = ov.parameter(input_shape, np.float32, name="parameter")
relu = ov.relu(param, name="relu")
func = Model([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[list(results)[0]], expected_output)
def test_Version_ir_v11():
core = Core()
xml_path = "./serialized_function.xml"
bin_path = "./serialized_function.bin"
shape = [100, 100, 2]
parameter_a = ov.opset8.parameter(shape, dtype=np.float32, name="A")
parameter_b = ov.opset8.parameter(shape, dtype=np.float32, name="B")
model = ov.opset8.floor(ov.opset8.minimum(ov.opset8.abs(parameter_a), parameter_b))
func = Model(model, [parameter_a, parameter_b], "Model")
serialize(func, xml_path, bin_path, "IR_V11")
res_func = core.read_model(model=xml_path, weights=bin_path)
assert func.get_parameters() == res_func.get_parameters()
assert func.get_ordered_ops() == res_func.get_ordered_ops()
os.remove(xml_path)
os.remove(bin_path)
def test_serialize_pass_mixed_args_kwargs():
core = Core()
xml_path = "serialized_function.xml"
bin_path = "serialized_function.bin"
shape = [3, 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
func = Model(model, [parameter_a, parameter_b], "Model")
pass_manager = Manager()
pass_manager.register_pass("Serialize", xml_path, bin_path=bin_path)
pass_manager.run_passes(func)
res_func = core.read_model(model=xml_path, weights=bin_path)
assert func.get_parameters() == res_func.get_parameters()
assert func.get_ordered_ops() == res_func.get_ordered_ops()
os.remove(xml_path)
os.remove(bin_path)
def json_model_analysis_dump(framework_model: Model):
def dump_partial_shape(shape: PartialShape):
if shape.rank.is_dynamic:
return 'None'
return [dim.get_length() if dim.is_static else 0 for dim in shape]
def dump_element_type(ov_type: Type):
try:
return str(get_dtype(ov_type))
except:
return 'None'
json_dump = {}
json_dump['inputs'] = {}
for param in framework_model.get_parameters():
param_name = param.get_friendly_name()
json_dump['inputs'][param_name] = {}
json_dump['inputs'][param_name]['shape'] = dump_partial_shape(
param.get_partial_shape())
json_dump['inputs'][param_name]['data_type'] = dump_element_type(
param.get_element_type())
json_dump['inputs'][param_name][
'value'] = 'None' # not supported in 22.1
json_dump['intermediate'] = {}
#TODO: extend model analysis dump for operations with body graphs (If, Loop, and TensorIterator)
for op in filter(lambda node: node.type_info.name != "NullNode",
framework_model.get_ordered_ops()):
for out_idx in range(op.get_output_size()):
output = op.output(out_idx)
tensor_name = output.get_any_name()
json_dump['intermediate'][tensor_name] = {}
json_dump['intermediate'][tensor_name][
'shape'] = dump_partial_shape(output.get_partial_shape())
json_dump['intermediate'][tensor_name][
'data_type'] = dump_element_type(output.get_element_type())
json_dump['intermediate'][tensor_name][
'value'] = 'None' # not supported in 22.1
json_model_analysis_print(json_dump)
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 = Model(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_serialize_seperate_paths_args():
core = Core()
xml_path = "serialized_function.xml"
bin_path = "serialized_function.bin"
shape = [2, 2]
parameter_a = ov.parameter(shape, dtype=np.float32, name="A")
parameter_b = ov.parameter(shape, dtype=np.float32, name="B")
parameter_c = ov.parameter(shape, dtype=np.float32, name="C")
parameter_d = ov.parameter(shape, dtype=np.float32, name="D")
model = ((parameter_a + parameter_b) * parameter_c) / parameter_d
func = Model(model, [parameter_a, parameter_b, parameter_c, parameter_d],
"Model")
pass_manager = Manager()
pass_manager.register_pass("Serialize", xml_path, bin_path)
pass_manager.run_passes(func)
res_func = core.read_model(model=xml_path, weights=bin_path)
assert func.get_parameters() == res_func.get_parameters()
assert func.get_ordered_ops() == res_func.get_ordered_ops()
os.remove(xml_path)
os.remove(bin_path)
def get_model_info(model: Model):
return model.get_ordered_ops(), model.inputs, model.outputs
