def type_infer(if_node: Node):
from mo.middle.passes.infer import type_infer
If.update_body_parameters_type(if_node, True)
If.update_body_parameters_type(if_node, False)
type_infer(if_node.then_graph)
type_infer(if_node.else_graph)
If.update_if_output_ports_type(if_node)
def ti_type_infer(node):
from mo.middle.passes.infer import type_infer
ti_graph = node.body
for record in node.input_port_map:
internal_node = get_internal_node_by_layer_id(node, record['internal_layer_id'])
assert internal_node.soft_get('type') == 'Parameter', internal_node.soft_get('type')
real_external_port_idx = TensorIterator.special_port_to_real_port(node, record['external_port_id'])
external_data_type = node.in_port(real_external_port_idx).get_connection().get_source().get_data_type()
internal_node.data_type = external_data_type
fake_input_const_nodes = []
# create fake const node to make type inference work correctly for all TI input nodes
for data_node in ti_graph.get_data_nodes(has_value=True):
if len(data_node.in_nodes()) == 0:
const_node = Const(ti_graph, {'name': 'const_', 'value': data_node.value}).create_node()
fake_input_const_nodes.append(const_node)
ti_graph.create_edge(const_node, data_node)
type_infer(ti_graph)
# propagate data types to the TI output ports
for record in node.output_port_map:
internal_node = get_internal_node_by_layer_id(node, record['internal_layer_id'])
assert internal_node.soft_get('type') == 'Result', internal_node.soft_get('type')
internal_data_type = internal_node.in_port(0).get_data_type()
real_external_port_idx = TensorIterator.special_port_to_real_port(node, record['external_port_id'], 'out')
node.out_port(real_external_port_idx).set_data_type(internal_data_type)
ti_graph.remove_nodes_from([node.id for node in fake_input_const_nodes])
def test_not_raises(self):
edges = [
*connect('input_1', '0:add'),
*connect('input_2', '1:add'),
*connect('add', 'result')
]
graph = self.build_graph_to_test_type_alignment(edges, input_1_type=np.float32, input_2_type=np.float32)
type_infer(graph)
add_node = Node(graph, 'add')
self.assertEquals(add_node.out_port(0).get_data_type(), np.float32)
def test_second_input_const(self):
edges = [
*connect('input_1', '0:add'),
*connect('const', '1:add'),
*connect('add', 'result')
]
graph = self.build_graph_to_test_type_alignment(edges, input_1_type=np.float32, const_type=np.float16)
type_infer(graph)
const_node = Node(graph, 'const')
self.assertEquals(const_node.out_port(0).get_data_type(), np.float32)
def delete_fq_non_quantizable_node_precision(self, graph):
type_infer(graph)
fq_removal = RemoveFakeQuantize()
fq_removal.quantize_agnostic_operations = self.quantize_agnostic_operations
fq_removal.quantize_operations = self.quantize_operations
node_int_fq = []
fq_queue = deque(sorted(graph.get_op_nodes(type='FakeQuantize'), key=lambda x: x.name))
while fq_queue:
fq = fq_queue.popleft()
if fq.in_port(0).get_source() is not None and fq.in_port(0).get_source().is_data_type_defined():
type_node = fq.in_port(0).get_source().get_data_type()
if type_node in (np.int32, np.int64, bool):
node_int_fq.append(fq.name)
fq_removal.find_and_remove_node(graph, fq.name)
def prepare_emit_ir(graph: Graph, data_type: str, output_dir: str, output_model_name: str,
mean_data: [list, None] = None, input_names: list = None, meta_info: dict = None):
if input_names is None:
input_names = []
if meta_info is None:
meta_info = {}
graph.strict_mode = False
# convert Parameter data types
convert_data_type.convert_parameters_data_type(graph, data_type)
# convert blobs (usually weights and biases)
for sub_graph in [graph] + collect_sub_graphs(graph):
convert_data_type.convert_blobs(sub_graph, data_type)
# restore data type for specific inputs/outputs of specific ops to the data types required by nGraph
if not graph.graph['cmd_params'].generate_deprecated_IR_V7:
for_graph_and_each_sub_graph_recursively(graph, convert_inputs_of_specific_ops)
if graph.graph['cmd_params'].generate_experimental_IR_V10:
for_graph_and_each_sub_graph_recursively(graph, OpVersioning().find_and_replace_pattern)
# do not run the type inference in sub-graphs. It will be called automatically as part of the type inference of
# the TensorIterator nodes
type_infer(graph)
RemoveUselessConvert().find_and_replace_pattern(graph)
for sub_graph in [graph] + collect_sub_graphs(graph):
op_order, data_order = determined_sort(get_sorted_outputs(sub_graph))
mapping = {v: u for u, v in enumerate(op_order)}
mapping.update({v: u for u, v in enumerate(data_order, start=len(sub_graph))})
relabel_nodes_inplace_safe(sub_graph, mapping)
port_renumber(sub_graph)
tensor_names.propagate_op_name_to_tensor(graph)
bin_file = os.path.join(output_dir, '{}.bin'.format(output_model_name))
serialize_constants(graph, bin_file)
mean_offset = None
mean_size = None
if mean_data:
mean_offset, mean_size = serialize_mean_image(bin_file, mean_data=mean_data)
generate_ie_ir(graph=graph,
file_name=os.path.join(output_dir, '{}.xml'.format(output_model_name)),
input_names=input_names,
mean_offset=mean_offset,
mean_size=mean_size,
meta_info=meta_info)
tensor_names.output_tensor_names_map(graph, os.path.join(output_dir, '{}.mapping'.format(output_model_name)))
def _ti_type_infer(node):
from mo.middle.passes.infer import type_infer
ti_graph = node.body
# create fake const node to make type inference work correctly for all TI input nodes
fake_input_const_nodes = []
for port_map in __class__.generate_port_map(node, node.input_port_map):
internal_input_data = Node(ti_graph,
port_map['internal_layer_id']).in_node(
port_map['internal_port_id'])
if len(internal_input_data.in_nodes()) == 0:
input_producer_port = node.in_port(
port_map['external_port_id']).get_connection().get_source(
)
input_type = input_producer_port.get_data_type()
const_node = Const(ti_graph, {
'name': 'fake_const_',
'value': np.ones([1], dtype=input_type)
}).create_node()
fake_input_const_nodes.append(const_node)
ti_graph.create_edge(const_node, internal_input_data)
# create const Op node for constant data nodes inside the TI
for data_node in ti_graph.get_data_nodes(has_value=True):
if len(data_node.in_nodes()) == 0:
const_node = Const(ti_graph, {
'name': 'const_',
'value': data_node.value
}).create_node()
fake_input_const_nodes.append(const_node)
ti_graph.create_edge(const_node, data_node)
type_infer(ti_graph)
# propagate data types to the TI output ports
output_port_map = __class__.generate_port_map(node,
node.output_port_map)
for port_map in output_port_map:
internal_output_port = Node(
ti_graph, port_map['internal_layer_id']).out_port(
port_map['internal_port_id'])
ti_output_port = node.out_port(port_map['external_port_id'])
ti_output_port.set_data_type(internal_output_port.get_data_type())
ti_graph.remove_nodes_from(
[node.id for node in fake_input_const_nodes])
def type_infer(loop_node: Node):
from mo.middle.passes.infer import type_infer
Loop.update_body_parameters_type(loop_node)
type_infer(loop_node.body)
Loop.update_loop_output_ports_type(loop_node)
