def analyze(self, graph: Graph):
pattern_instance_counter.counter = 0
apply_pattern(graph, **YOLO_PATTERN, action=pattern_instance_counter)
flavor = None
if pattern_instance_counter.counter > 0:
if pattern_instance_counter.counter == 22:
flavor = 'YOLOV2Full'
elif pattern_instance_counter.counter == 8:
flavor = 'YOLOV2Tiny'
if flavor is not None:
message = "Your model looks like YOLOv1 or YOLOv2 Model.\n" \
"To generate the IR, provide TensorFlow YOLOv1 or YOLOv2 Model to the Model Optimizer with the following parameters:\n" \
"\t--input_model <path_to_model>/<model_name>.pb\n" \
"\t--batch 1\n" \
"\t--tensorflow_use_custom_operations_config <PYTHON_SITE_PACKAGES>/openvino/tools/mo/front/tf/<yolo_config>.json\n" \
"All detailed information about conversion of this model can be found at\n" \
"https://docs.openvino.ai/latest/_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_YOLO_From_Tensorflow.html"
return {
'model_type': {
'YOLO': get_YOLO_params_by_flavor(flavor)
}
}, message
else:
return None, None
def batch_norm_fuse(graph: Graph):
apply_pattern(
graph,
nodes=[('kernel', dict(kind='data')),
('conv', dict(kind='op', op='Conv2D')),
('conv_output', dict(kind='data')), ('norm', dict(kind='data')),
('mul', dict(kind='op', op='Mul')),
('mul_output', dict(kind='data'))],
edges=[
('kernel', 'conv', {
'in': 1
}),
('conv', 'conv_output'),
(
'conv_output', 'mul', {
'in': 0
}
), # TODO get rid of explicit input port number, mul is a commutative op
(
'norm', 'mul', {
'in': 1
}
), # TODO get rig of explicit input port number, mul is a commutative op
('mul', 'mul_output')
],
action=batch_norm_fuse_action)
return graph
def rename_fqs_in_the_end(self, graph: Graph):
def change_names(_, match):
fq_node = match['fq']
input_node = get_node_input(fq_node, 0)
new_fq_name = copy(input_node.name)
if 'orig_node_name' in input_node:
new_fq_name = copy(input_node['orig_node_name'])
input_node_outputs = get_all_node_outputs(input_node)
if len(input_node_outputs) > 1 and all(
[op.type == 'FakeQuantize' for op in input_node_outputs]):
new_fq_name += '.{}'.format(
fq_node.in_port(0).get_source().idx)
fq_node['orig_fq_name'] = copy(fq_node.name)
if 'orig_node_name' not in input_node:
input_node['orig_node_name'] = copy(input_node.name)
rename_node(input_node, f'{input_node.name}/pre_fq_input')
rename_node(fq_node, new_fq_name)
pattern = get_fq_result_pattern()
apply_pattern(graph,
nodes=pattern['nodes'],
edges=pattern['edges'],
action=change_names)
def fuse_pad(graph: Graph):
for op_type in ['Convolution', 'Pooling', 'Deconvolution']:
apply_pattern(graph,
nodes=[('pad_op', dict(kind='op', op='Pad')),
('pad_output', dict(kind='data')),
('op', dict(kind='op', type=op_type))],
edges=[('pad_op', 'pad_output'),
('pad_output', 'op', {
'in': 0
})],
action=pad_op_transform)
def mark_ignored_blocks_(patterns):
for types_list in patterns:
for pattern in patterns[types_list]:
if isinstance(pattern, tuple):
pattern, check_pattern_fn = pattern
mark_fn = partial(self.mark_block_nodes,
check_pattern_fn)
else:
mark_fn = partial(self.mark_block_nodes, None)
apply_pattern(graph,
nodes=pattern['nodes'],
edges=pattern['edges'],
action=mark_fn)
def analyze(self, graph: Graph):
pattern_instance_counter.counter = 0
apply_pattern(graph, **RETINANET_PATTERN, action=pattern_instance_counter)
if pattern_instance_counter.counter > 0:
result = dict()
result['mandatory_parameters'] = {'tensorflow_use_custom_operations_config':
'openvino/tools/mo/front/tf/retinanet.json'}
message = "Your model looks like TensorFlow RetinaNet Model.\n" \
"To generate the IR, provide model to the Model Optimizer with the following parameters:\n" \
"\t--input_model <path_to_model>/<model>.pb\n" \
"\t--input_shape [1,600,600,3]\n" \
"\t--tensorflow_use_custom_operations_config <OPENVINO_INSTALL_DIR>/tools/model_optimizer/openvino/tools/mo/front/tf/retinanet.json\n" \
"\t--reverse_input_channels"
return {'model_type': {'TF_RetinaNet': result}}, message
return None, None
def find_and_replace_pattern(self, graph: Graph):
apply_pattern(graph, **self.pattern1(), action=self.replace_pattern) # pylint: disable=no-member
apply_pattern(graph, **self.pattern2(), action=self.replace_pattern) # pylint: disable=no-member
def find_and_replace_pattern(self, graph: Graph):
log.info('Enabled GeLU Merger replacement for approximation with Erf')
apply_pattern(graph, **self.pattern1(), action=self.replace_gelu)
apply_pattern(graph, **self.pattern2(), action=self.replace_gelu)
apply_pattern(graph, **self.pattern3(), action=self.replace_gelu)
def find_and_replace_pattern(self, graph: Graph):
log.info('Enabled LayerNorm pattern recognition')
apply_pattern(graph, **self.pattern1(), action=self.replace_layer_norm)
apply_pattern(graph, **self.pattern2(), action=self.replace_layer_norm)
def find_and_replace_pattern(self, graph: Graph):
apply_pattern(graph, action=self.replace_sub_graph, **self.pattern())
