def test_mvn_normalizer_across_channels(self):
graph = build_graph(nodes, [('input', 'mvn_caffe'),
('mvn_caffe', 'output')],
{'mvn_caffe': {
'across_channels': 1
}},
nodes_with_edges_only=True)
graph.stage = 'front'
MVNCaffeToMVN().find_and_replace_pattern(graph)
graph_ref = build_graph(nodes, [('input', 'mvn', {
'out': 0
}), ('input', 'rank', {
'out': 0
}), *connect_front('start_1', '0:range'),
*connect_front('rank', '1:range'),
*connect_front('step', '2:range'),
*connect_front('range', '1:mvn'),
('mvn', 'output')],
nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def build_main_graph(self, pre_processing: str):
def build_body_graph(pre_processing: str):
nodes = {
**regular_op('input', {'type': 'Parameter'}),
**regular_op('mul', {'op': 'Mul', 'type': 'Multiply', 'name': 'my_body_mul'}),
**regular_op('sub', {'op': 'Sub', 'type': 'Subtract', 'name': 'my_body_sub'}),
**const('body_mul_const', self.mul_const),
**const('body_sub_const', self.sub_const),
**regular_op(self.loop_start_node_name, {'op': 'Identity'}),
**regular_op(self.loop_end_node_name, {'op': 'Identity'}),
**regular_op('resize', {'type': 'Interpolate'}),
**result('result'),
}
edges = None
if pre_processing == 'no':
edges = [*connect_front('input', self.loop_start_node_name),
*connect_front(self.loop_start_node_name, 'resize'),
*connect_front('resize', self.loop_end_node_name),
*connect_front(self.loop_end_node_name, 'result'),
]
elif pre_processing == 'trailing':
edges = [*connect_front('input', self.loop_start_node_name),
*connect_front(self.loop_start_node_name, 'resize'),
*connect_front('resize', self.loop_end_node_name),
*connect_front(self.loop_end_node_name, '0:mul'),
*connect_front('body_mul_const', '1:mul'),
*connect_front('body_sub_const', '0:sub'),
*connect_front('mul', '1:sub'),
*connect_front('sub', 'result'),
]
else:
edges = [*connect_front('input', '0:mul'),
*connect_front('body_mul_const', '1:mul'),
*connect_front('body_sub_const', '0:sub'),
*connect_front('mul', '1:sub'),
*connect_front('sub', self.loop_start_node_name),
*connect_front(self.loop_start_node_name, 'resize'),
*connect_front('resize', self.loop_end_node_name),
*connect_front(self.loop_end_node_name, 'result'),
]
graph = build_graph(nodes, edges, nodes_with_edges_only=True)
graph.stage = 'front'
return graph
edges = [*connect_front('input', self.start_node_name),
*connect_front(self.start_node_name, 'loop'),
*connect_front('loop:0', self.end_node_name),
*connect_front('loop:1', self.end_node_name2),
*connect_front(self.end_node_name, 'result'),
]
graph = build_graph(self.nodes, edges, {'loop': {'body': build_body_graph(pre_processing)}},
nodes_with_edges_only=True)
graph.stage = 'front'
return graph
def test_case_3(self, update_parameter_shape_mock):
# test for case #3 described in the ObjectDetectionAPIPreprocessor2Replacement
update_parameter_shape_mock.return_value = None
edges = [*connect_front('input', self.start_node_name),
*connect_front(self.start_node_name, 'resize'),
*connect_front('resize', self.end_node_name),
*connect_front(self.end_node_name, 'result'),
]
graph = build_graph(self.nodes, edges)
graph.stage = 'front'
ObjectDetectionAPIPreprocessor2Replacement().transform_graph(graph, self.replacement_desc)
(flag, resp) = compare_graphs(graph, self.build_ref_graph(False), 'result', check_op_attrs=True)
self.assertTrue(flag, resp)
def test_attributed_slice_replacer(self, attributed_slice_attrs):
nodes = {
**regular_op_with_empty_data('input', {'type': 'Parameter'}),
**regular_op_with_empty_data('attributed_slice', attributed_slice_attrs),
**result(),
# nodes after replacement
**const('start', np.array([0, 0])),
**const('end', np.array([1, -1])),
**const('axis', np.array(np.array([0, 1]))),
**regular_op_with_empty_data('slice', {
'op': 'Slice',
'type': None
}),
}
graph = build_graph(nodes_attrs=nodes,
edges=[
('input', 'attributed_slice'),
('attributed_slice', 'output'),
],
nodes_with_edges_only=True)
graph.stage = 'front'
AttributedSliceToSliceReplacer().find_and_replace_pattern(graph)
graph_ref = build_graph(nodes_attrs=nodes,
edges=[
('input', 'slice'),
*connect_front('start', '1:slice'),
*connect_front('end', '2:slice'),
*connect_front('axis', '3:slice'),
('slice', 'output'),
],
nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_reduce_axis_is_None(self):
graph = build_graph(nodes, edges, nodes_with_edges_only=True)
graph.stage = 'front'
ReduceAxisNormalizer().find_and_replace_pattern(graph)
ref_nodes = nodes.copy()
ref_nodes.update({
**regular_op('rank', {
'op': 'Rank',
'type': None
}),
**regular_op('range', {
'op': 'Range',
'type': 'Range'
}),
**regular_op('begin', {
'type': 'Const',
'value': int64_array([0])
}),
**regular_op('step', {
'type': 'Const',
'value': int64_array([1])
}),
})
graph_ref = build_graph(ref_nodes, [
*edges,
*connect_front('parameter:0', 'rank'),
*connect_front('begin:0', '0:range'),
*connect_front('rank:0', '1:range'),
*connect_front('step:0', '2:range'),
*connect_front('range:0', '1:reduce'),
],
nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_mvn_normalize(self):
graph = build_graph(nodes, [('input', 'mvn_onnx'),
('mvn_onnx', 'output')],
nodes_with_edges_only=True)
graph.stage = 'front'
MvnOnnxToMvn().find_and_replace_pattern(graph)
graph_ref = build_graph(
nodes, [('input', 'mvn'), *connect_front('axes', '1:mvn'),
('mvn', 'output')],
nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def build_ref_graph(self, preprocessing: bool):
if preprocessing:
ref_edges = [*connect_front('input', '0:mul'),
*connect_front('mul_const', '1:mul'),
*connect_front('sub_const', '0:sub'),
*connect_front('mul', '1:sub'),
*connect_front('sub', 'result'),
]
else:
ref_edges = [*connect_front('input', 'result')]
ref_graph = build_graph(self.nodes, ref_edges, nodes_with_edges_only=True)
ref_graph.stage = 'front'
return ref_graph
def test_reduce_axis_is_const(self):
graph = build_graph(nodes,
edges, {'reduce': {
'axis': 1
}},
nodes_with_edges_only=True)
graph.stage = 'front'
graph_ref = build_graph(nodes, [
*edges,
*connect_front('axis', '1:reduce'),
], {'axis': {
'value': np.int64(1)
}},
nodes_with_edges_only=True)
ReduceAxisNormalizer().find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_slice_replacer_begin_with_2_inputs(self):
graph = build_graph(nodes_attrs=nodes,
edges=[
('input', 'tfslice'),
*connect_front('begin:0', '1:tfslice'),
*connect_front('begin:0', '0:john_doe'),
*connect_front('size:0', '2:tfslice'),
*connect_front('tfslice:0', 'output'),
],
nodes_with_edges_only=True)
graph.stage = 'front'
TFSliceToSliceReplacer().find_and_replace_pattern(graph)
graph_ref = build_graph(nodes_attrs=nodes,
edges=[
*connect_front('input:0', 'slice'),
*connect_front('input:0', 'shapeof'),
*connect_front('begin:0', 'slice:1'),
*connect_front('begin:0', 'john_doe:1'),
*connect_front('begin:0', 'end_const:0'),
*connect_front('size:0', 'end_const:1'),
*connect_front('size:0', 'equal:0'),
*connect_front('shapeof:0', 'select:1'),
*connect_front('minus_one:0', 'equal:1'),
*connect_front('equal:0', 'select:0'),
*connect_front('end_const:0', 'cast:0'),
*connect_front('cast:0', 'select:2'),
*connect_front('select:0', 'slice:2'),
*connect_front('slice:0', 'output'),
],
nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_slice_replacer(self):
graph = build_graph(nodes_attrs=nodes,
edges=[
*connect_front('input:0', 'tfslice'),
*connect_front('begin:0', '1:tfslice'),
*connect_front('size:0', '2:tfslice'),
*connect_front('tfslice:0', 'output'),
],
nodes_with_edges_only=True)
graph.stage = 'front'
TFSliceToSliceReplacer().find_and_replace_pattern(graph)
graph_ref = build_graph(nodes_attrs=nodes,
edges=[
*connect_front('input:0', 'slice'),
*connect_front('begin:0', '1:slice'),
*connect_front('begin:0', '0:end_const'),
*connect_front('size:0', '1:end_const'),
*connect_front('size:0', '0:equal'),
*connect_front('int32_max:0', '1:select'),
*connect_front('minus_one:0', '1:equal'),
*connect_front('equal:0', '0:select'),
*connect_front('end_const:0', '0:cast'),
*connect_front('cast:0', '2:select'),
*connect_front('select:0', '2:slice'),
*connect_front('slice:0', 'output'),
],
nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph,
graph_ref,
'output',
check_op_attrs=True)
self.assertTrue(flag, resp)
nodes = {
**regular_op('parameter', {'type': 'Parameter'}),
**regular_op('reduce', {
'op': 'ReduceSum',
'axis': None
}),
**regular_op('axis', {
'op': 'Const',
'type': 'Const',
'value': int64_array([1])
}),
**result(),
}
edges = [
*connect_front('parameter:0', '0:reduce'),
*connect_front('reduce', 'output'),
]
class ReduceAxisNormalizerTest(unittest.TestCase):
def test_reduce_axis_is_None(self):
graph = build_graph(nodes, edges, nodes_with_edges_only=True)
graph.stage = 'front'
ReduceAxisNormalizer().find_and_replace_pattern(graph)
ref_nodes = nodes.copy()
ref_nodes.update({
**regular_op('rank', {
'op': 'Rank',
def test_tdnnreplacer(self, weights, biases, time_offsets):
def generate_offsets():
offset_edges = []
offset_nodes = {}
for i, t in enumerate(time_offsets):
offset_nodes.update(**regular_op('memoryoffset_' +
str(i), {'type': None}))
if t != 0:
offset_edges.append(
('placeholder', 'memoryoffset_' + str(i), {
'out': 0,
'in': 0
}))
offset_edges.append(('memoryoffset_' + str(i), 'concat', {
'out': 0,
'in': i
}))
else:
offset_edges.append(('placeholder', 'concat', {
'out': 0,
'in': i
}))
return offset_nodes, offset_edges
offset_nodes, ref_offset_edges = generate_offsets()
nodes = {
**offset_nodes,
**regular_op('placeholder', {'type': 'Parameter'}),
**regular_op(
'tdnncomponent', {
'op': 'tdnncomponent',
'weights': np.array(weights),
'biases': np.array(biases),
'time_offsets': np.array(time_offsets)
}),
**const('weights', np.array(weights)),
**const('biases', np.array(biases)),
**regular_op('concat', {
'type': 'Concat',
'axis': 1
}),
**regular_op('memoryoffset_0', {'type': None}),
**regular_op('memoryoffset_1', {'type': None}),
**regular_op('memoryoffset_2', {'type': None}),
**regular_op('fully_connected', {'type': 'FullyConnected'}),
**result('result'),
}
graph = build_graph(nodes, [
*connect_front('placeholder', 'tdnncomponent'),
*connect_front('tdnncomponent', 'result')
],
nodes_with_edges_only=True)
graph.stage = 'front'
ref_graph = build_graph(nodes, [
*ref_offset_edges, *connect_front('concat', '0:fully_connected'),
*connect_front('weights', '1:fully_connected'),
*connect_front('biases', '2:fully_connected'),
*connect_front('fully_connected', 'result')
],
nodes_with_edges_only=True)
TdnnComponentReplacer().find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph,
ref_graph,
'result',
check_op_attrs=True)
self.assertTrue(flag, resp)
