def test_in_port_with_data(self):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges)
graph.stage = 'middle'
new_input_shape = np.array([1, 2, 3, 4])
graph_ref = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges[1:],
new_nodes_with_attrs=[
('input_node', {
'kind': 'op',
'op': 'Parameter',
'shape': new_input_shape
}),
('input_data', {
'kind': 'data'
})
],
new_edges_with_attrs=[
('input_node', 'input_data', {
'in': 0,
'out': 0
}),
('input_data', 'op_node', {
'in': 1,
'out': 0
})
])
add_input_op(graph, 'op_node', 1, data=True, shape=new_input_shape)
graph.remove_edge('future_input', 'op_node')
(flag, resp) = compare_graphs(graph, graph_ref, last_node='op_node')
self.assertTrue(flag, resp)
def test_out_port_no_data(self):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes_out,
edges_with_attrs=self.edges_out)
new_input_shape = np.array([1, 2, 3, 4])
graph_ref = build_graph_with_attrs(nodes_with_attrs=self.nodes_out,
edges_with_attrs=self.edges_out[1:],
new_nodes_with_attrs=[
('input_node', {
'kind': 'op',
'op': 'Parameter',
'shape': new_input_shape
})
],
new_edges_with_attrs=[
('input_node', 'future_input', {
'in': 0,
'out': 0
})
])
add_input_op(graph,
'op_node',
1,
data=False,
shape=new_input_shape,
is_out_port=True)
graph.remove_edge('op_node', 'future_input')
(flag, resp) = compare_graphs(graph,
graph_ref,
last_node='another_node')
self.assertTrue(flag, resp)
(flag, resp) = compare_graphs(graph,
graph_ref,
last_node='future_input')
self.assertTrue(flag, resp)
def test_merge_infer_only_second_executable(self):
graph = build_graph_with_attrs(
nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('first', {'executable': False, 'value': np.ones([2, 2]), 'shape': int64_array([2, 2])}),
('second', {'executable': True, 'value': np.zeros([4, 4]), 'shape': int64_array([4, 4])})
]
)
ref_graph = build_graph_with_attrs(
nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('first', {'executable': False, 'value': np.ones([2, 2]), 'shape': int64_array([2, 2])}),
('second', {'executable': True, 'value': np.zeros([4, 4]), 'shape': int64_array([4, 4])}),
('merge', {'is_not_fully_inferred': False}),
('merge_output', {'shape': int64_array([4, 4]), 'value': np.zeros([4, 4])})
]
)
tested_class = Merge(graph=graph, attrs={})
node = Node(graph, 'merge')
tested_class.merge_infer(node)
(flag, resp) = compare_graphs(graph, ref_graph, 'merge_output', check_op_attrs=True)
self.assertTrue(flag, resp)
def test_two_nodes_one_bin(self):
"""Test case for two output nodes, one with 'bin' parameter, other without."""
shape = np.array([2, 3, 4])
data = np.zeros(shape)
graph = build_graph_with_attrs(
nodes_with_attrs=self.nodes + [('next_node_2', {
'kind': 'op'
})],
edges_with_attrs=self.edges + [('data_node', 'next_node_2')],
update_nodes_attributes=[('data_node', {
'shape': shape,
'value': data
})],
update_edge_attrs={('data_node', 'next_node', 0): {
'bin': 0
}},
)
graph_ref = build_graph_with_attrs(
nodes_with_attrs=self.nodes + self.new_nodes + [('next_node_2', {
'kind': 'op'
})],
edges_with_attrs=self.edges + self.new_edges +
[('data_node', 'next_node_2')],
update_nodes_attributes=[('data_node', {
'shape': shape,
'value': data
}), ('const_data', {
'shape': shape,
'value': data
})])
tested_pattern = CreateConstNodesReplacement()
tested_pattern.find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph, graph_ref, last_node='next_node')
self.assertTrue(flag, resp)
def test_no_exit(self):
pattern_matcher = BackEdgesMatching()
pattern = pattern_matcher.pattern()
graph = build_graph_with_attrs(nodes_with_attrs=pattern['nodes'], edges_with_attrs=pattern['edges'], update_edge_attrs=None,
new_nodes_with_attrs=[('from_body_data', {'kind':'data'})],
new_edges_with_attrs=[('from_body_data', 'NextIteration')])
pattern_matcher.find_and_replace_pattern(graph)
graph_ref = build_graph_with_attrs(nodes_with_attrs=[('condition', {'kind': 'op', 'op':'TensorIteratorCondition'}),
('condition_data', {'kind': 'data'}),
('back_edge', {'kind': 'op', 'op': 'TensorIteratorBackEdge'}),
('enter_data', {'kind': 'data'}),
('from_body_data', {'kind': 'data'}),
('Identity_1_data', {'kind': 'data'}),],
edges_with_attrs=[('condition', 'condition_data'),
('enter_data', 'back_edge', {'in': 0}),
('condition_data', 'back_edge', {'in': 2}), # {in:2}
('from_body_data', 'back_edge', {'in': 1}),
('back_edge', 'Identity_1_data')],
update_edge_attrs=None,
new_nodes_with_attrs=[],
new_edges_with_attrs=[],
)
(flag, resp) = compare_graphs(graph, graph_ref, 'Identity_1_data', check_op_attrs=True)
self.assertTrue(flag, resp)
def test_select_infer_condition_true(self):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('condition', {
'value': np.array([True])
}),
('select_output', {
'shape': np.array([2, 2]),
'value': np.ones((2, 2))
})
])
# We should propagate shapes and values
graph_ref = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('select_output', {
'shape': np.array([2, 2]),
'value': np.ones((2, 2))
})
])
tested_class = Select(graph=graph, attrs={})
node = Node(graph, 'select')
tested_class.infer(node)
(flag, resp) = compare_graphs(graph,
graph_ref,
'select_output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_merge_infer_simple_case_one_executable(self):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges)
# We should propagate value of the first input since only this input is executable
graph_ref = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('merge_output', {
'shape': np.array([2, 2]),
'value': np.ones((2, 2))
}),
('merge', {
'is_not_fully_inferred':
False
})
])
tested_class = Merge(graph=graph, attrs={})
node = Node(graph, 'merge')
tested_class.merge_infer(node)
(flag, resp) = compare_graphs(graph,
graph_ref,
'merge_output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_switch_infer_no_condition(self):
nodes = [('tensor', {
'value': None,
'kind': 'data',
'executable': True,
'shape': np.array([1, 2, 1])
}), ('pred_id', {
'value': None,
'kind': 'data',
'executable': True
}), ('switch', {
'type': 'Switch',
'kind': 'op',
'op': 'Switch'
}),
('switch_data_0', {
'value': None,
'kind': 'data',
'executable': True
}),
('switch_data_1', {
'value': None,
'kind': 'data',
'executable': True
})]
edges = [('tensor', 'switch', {
'in': 0
}), ('pred_id', 'switch', {
'in': 1
}), ('switch', 'switch_data_0', {
'out': 0
}), ('switch', 'switch_data_1', {
'out': 1
})]
graph = build_graph_with_attrs(nodes_with_attrs=nodes,
edges_with_attrs=edges)
# We should propagate only shapes
graph_ref = build_graph_with_attrs(nodes_with_attrs=nodes,
edges_with_attrs=edges,
update_nodes_attributes=[
('switch_data_0', {
'shape': np.array([1, 2, 1])
}),
('switch_data_1', {
'shape': np.array([1, 2, 1])
})
])
tested_class = Switch(graph=graph, attrs={})
node = Node(graph, 'switch')
tested_class.infer(node)
(flag, resp) = compare_graphs(graph,
graph_ref,
'switch_data_0',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_select_infer_condition_shapes_broadcast(self, else_data_shape,
than_data_shape,
select_output_shape):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('else_data', {
'shape':
np.array(else_data_shape),
'value':
np.zeros(else_data_shape,
dtype=np.float)
}),
('than_data', {
'shape':
np.array(than_data_shape),
'value':
np.zeros(than_data_shape,
dtype=np.float)
}),
('select_output', {
'shape': None,
'value': None
})
])
node = Node(graph, 'select')
node.infer(node)
self.assertTrue(
np.array_equal(graph.nodes['select_output']['shape'],
np.array(select_output_shape)))
def test_positive_matmul_infer(self, A_shape, B_shape, C_shape,
transpose_a, transpose_b):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('A_d', {
'shape': int64_array(A_shape)
}),
('B_d', {
'shape': int64_array(B_shape)
}),
('mat_mul', {
'transpose_a': transpose_a,
'transpose_b': transpose_b
}),
])
node = Node(graph, 'mat_mul')
MatMul.infer(node)
msg = "MatMul infer failed for case: A_shape={}, B_shape={}, transpose_a={}, transpose_b={} " \
"expected_shape={}, actual_shape={}"
self.assertTrue(
np.array_equal(graph.node['mat_mul_d']['shape'],
int64_array(C_shape)),
msg.format(A_shape, B_shape, transpose_a, transpose_b, C_shape,
graph.node['mat_mul_d']['shape']))
def test_two_nodes_with_bin(self):
"""Test case for data node with 2 consumers with bin edge attr.
Nothing should happened."""
shape = np.array([2, 3, 4])
data = np.zeros(shape)
graph = build_graph_with_attrs(
nodes_with_attrs=self.nodes + [('next_node_2', {
'kind': 'op'
})],
edges_with_attrs=self.edges + [('data_node', 'next_node_2')],
update_nodes_attributes=[('data_node', {
'shape': shape,
'value': data
})],
update_edge_attrs={
('data_node', 'next_node', 0): {
'bin': 0
},
('data_node', 'next_node_2', 0): {
'bin': 0
}
},
)
tested_pattern = CreateConstNodesReplacement()
tested_pattern.find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph, graph, last_node='next_node')
self.assertTrue(flag, resp)
def test_negative_matmul_infer(self, A_shape, B_shape):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes, edges_with_attrs=self.edges,
update_nodes_attributes=[
('A_d', {'shape': np.array(A_shape)}),
('B_d', {'shape': int64_array(B_shape)}),
])
node = Node(graph, 'mat_mul')
self.assertRaises(AssertionError, MatMul.infer, node)
def test_one_node(self):
"""We should add Const node and data node."""
shape = np.array([2, 3, 4])
data = np.zeros(shape)
graph = build_graph_with_attrs(
nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[('data_node', {'shape': shape, 'value': data})]
)
graph_ref = build_graph_with_attrs(
nodes_with_attrs=self.nodes + self.new_nodes,
edges_with_attrs=self.edges + self.new_edges,
update_nodes_attributes=[('data_node', {'shape': shape, 'value': data}),
('const_data', {'shape': shape, 'value': data})]
)
tested_pattern = CreateConstNodesReplacement()
tested_pattern.find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph, graph_ref, last_node='next_node')
self.assertTrue(flag, resp)
def test_merge_infer_complex_case(self):
"""
Case as in cycles when in first visit only one input are inferred and in the second -- both.
"""
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes, edges_with_attrs=self.edges,
update_nodes_attributes=[('first', {'is_partial_inferred': False,
'value': None}),
('second', {'executable': True})])
# In first visit we should propagate only shapes
graph_ref = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[('second', {'executable': True}),
('first', {'is_partial_inferred': False,
'value': None}),
('merge_output', {'shape': np.array([2, 2]),
'value': None}),
('merge', {'is_not_fully_inferred': True})])
tested_class = Merge(graph=graph, attrs={})
node = Node(graph, 'merge')
tested_class.merge_infer(node)
(flag, resp) = compare_graphs(graph, graph_ref, 'merge_output', check_op_attrs=True)
self.assertTrue(flag, resp)
# Imitate that inputs nodes now is inferred
graph.node['first']['is_partial_inferred'] = True
# Run infer second time
tested_class = Merge(graph=graph, attrs={})
node = Node(graph, 'merge')
tested_class.merge_infer(node)
graph_ref = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[('second', {'executable': True}),
('first', {'is_partial_inferred': True,
'value': None}),
('merge_output', {'shape': np.array([2, 2]),
'value': None}),
('merge', {'is_not_fully_inferred': False})])
(flag, resp) = compare_graphs(graph, graph_ref, 'merge_output', check_op_attrs=True)
self.assertTrue(flag, resp)
def test_two_consumers_keep_outputs(self):
"""Const data node has two consumers: Result and ReLu"""
nodes = [
('const_node', {
'type': 'Const',
'kind': 'op'
}),
('const_data', {
'kind': 'data',
'value': np.array(5)
}),
('result_node', {
'type': 'Result',
'kind': 'op',
'keep_output_port': True
}),
('relu_1', {
'type': 'ReLU',
'kind': 'op',
'op': 'ReLU'
}),
('relu_1_data', {
'kind': 'data'
}),
]
edges = [('const_node', 'const_data'), ('const_data', 'result_node'),
('const_data', 'relu_1'), ('relu_1', 'relu_1_data')]
graph = build_graph_with_attrs(
nodes_with_attrs=nodes,
edges_with_attrs=edges,
)
graph_ref = build_graph_with_attrs(
nodes_with_attrs=nodes,
edges_with_attrs=edges,
)
tested_pattern = RemoveConstToResult()
tested_pattern.find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph,
graph_ref,
last_node='relu_1_data')
self.assertTrue(flag, resp)
self.assertIn('result_node', graph.node)
def test_1(self):
"""
Acyclic case => graph.graph['is_cyclic'] should be False.
"""
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges)
tested_pass = AddIsCyclicAttribute()
tested_pass.find_and_replace_pattern(graph)
assert graph.graph['is_cyclic'] is False
def test_negative(self, input_shape, axes, layout):
graph = build_graph_with_attrs(nodes + [
('input', dict(kind='op', shape=input_shape, op='Parameter', data_type=np.float32)),
('input_data', dict(kind='data', shape=input_shape, data_type=np.float32)),
('square_data', dict(kind='data', shape=input_shape)),
('sum_axes_data', dict(kind='data', value=axes, shape=None)),
], edges, nodes_with_edges_only=True)
graph.stage = 'middle'
graph.graph['layout'] = layout
L2NormToNorm().find_and_replace_pattern(graph)
graph_ref = build_graph_with_attrs(nodes + [
('input', dict(kind='op', shape=input_shape, op='Parameter', data_type=np.float32)),
('input_data', dict(kind='data', shape=input_shape, data_type=np.float32)),
('square_data', dict(kind='data', shape=input_shape)),
('sum_axes_data', dict(kind='data', value=axes, shape=None)),
], edges, nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph, graph_ref, 'result', check_op_attrs=True)
self.assertTrue(flag, resp)
def test_select_infer_no_condition(self):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges)
# We should propagate only shapes
graph_ref = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('select_output', {
'shape': np.array([2, 2])
})
])
node = Node(graph, 'select')
node.infer(node)
(flag, resp) = compare_graphs(graph,
graph_ref,
'select_output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_2(self):
"""
Cyclic case => graph.graph['is_cyclic'] should be True.
:return:
"""
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
new_edges_with_attrs=[('node_2', 'node_1')])
tested_pass = AddIsCyclicAttribute()
tested_pass.find_and_replace_pattern(graph)
assert graph.graph['is_cyclic'] is True
def test_positive(self, input_shape, axes, layout):
graph = build_graph_with_attrs(nodes + [
('input', dict(kind='op', shape=input_shape, op='Parameter', data_type=np.float32)),
('input_data', dict(kind='data', shape=input_shape, data_type=np.float32)),
('square_data', dict(kind='data', shape=input_shape)),
('sum_axes_data', dict(kind='data', value=axes, shape=None)),
], edges, nodes_with_edges_only=True)
graph.stage = 'middle'
graph.graph['layout'] = layout
L2NormToNorm().find_and_replace_pattern(graph)
graph_ref = build_graph_with_attrs(nodes + [
('input', dict(kind='op', shape=input_shape, op='Parameter', data_type=np.float32)),
('input_data', dict(kind='data', shape=input_shape, data_type=np.float32)),
('weights_node_data', dict(kind='data', value=axes.sort())),
], edges_after_replacement, nodes_with_edges_only=True)
(flag, resp) = compare_graphs(graph, graph_ref, 'result', check_op_attrs=True)
self.assertTrue(graph.node[graph.get_nodes_with_attributes(type='NormalizeL2')[0]]['name'] == 'l2_norm_name')
self.assertTrue(flag, resp)
def test_one_bin_node(self):
"""Nothing should happen."""
shape = np.array([2, 3, 4])
data = np.zeros(shape)
graph = build_graph_with_attrs(
nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[('data_node', {'shape': shape, 'value': data})],
update_edge_attrs={('data_node', 'next_node', 0): {'bin': 0}},
)
tested_pattern = CreateConstNodesReplacement()
tested_pattern.find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph, graph, last_node='next_node')
self.assertTrue(flag, resp)
def test(self):
pattern_matcher = SimpleInputMatcher()
pattern = pattern_matcher.pattern()
graph = build_graph_with_attrs(nodes_with_attrs=pattern['nodes'],
edges_with_attrs=pattern['edges'],
update_edge_attrs=None,
new_nodes_with_attrs=[('in_node', {
'kind': 'data'
}), ('Enter_data', {
'kind': 'data'
})],
new_edges_with_attrs=[
('in_node', 'Enter'),
('Enter', 'Enter_data')
],
update_nodes_attributes=[])
pattern_matcher.find_and_replace_pattern(graph)
graph_ref = build_graph_with_attrs(
nodes_with_attrs=[('TensorIteratorInput', {
'kind': 'op',
'op': 'TensorIteratorInput'
}), ('in_node', {
'kind': 'data'
}), ('Enter_data', {
'kind': 'data'
})],
edges_with_attrs=[('in_node', 'TensorIteratorInput'),
('TensorIteratorInput', 'Enter_data')],
)
(flag, resp) = compare_graphs(graph,
graph_ref,
'Enter_data',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_select_infer_assert_shapes(self):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[('else_data', {
'shape':
np.array([3, 3]),
'value':
np.zeros((3, 3))
})])
tested_class = Select(graph=graph, attrs={})
node = Node(graph, 'select')
with self.assertRaisesRegex(AssertionError,
"Input shape do not broadcast"):
tested_class.infer(node)
def test_select_infer_condition_with_value(self, condition_shape,
else_data_shape,
than_data_shape,
select_output_shape,
condition_value, else_value,
than_value, output_value):
"""
Unit tests generator can sporadic throw exception if we try
to run generator with call numpy array generation functions.
So we need to use lambda function for escape the problem.
"""
condition_value = condition_value(condition_shape)
else_value = else_value(else_data_shape)
than_value = than_value(than_data_shape)
output_value = output_value(select_output_shape)
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('condition_data', {
'shape':
np.array(condition_shape),
'value': condition_value
}),
('else_data', {
'shape':
np.array(else_data_shape),
'value': else_value
}),
('than_data', {
'shape':
np.array(than_data_shape),
'value': than_value
}),
('select_output', {
'shape':
np.array(select_output_shape),
'value':
None
})
])
node = Node(graph, 'select')
node.infer(node)
self.assertTrue(
np.array_equal(graph.nodes['select_output']['value'],
output_value))
def test(self):
pattern_matcher = SmartOutputMatcher()
pattern = pattern_matcher.pattern()
graph = build_graph_with_attrs(
nodes_with_attrs=pattern['nodes'],
edges_with_attrs=pattern['edges'],
# update_edge_attrs=None,
new_nodes_with_attrs=[
('index', {
'kind': 'data'
}),
('value', {
'kind': 'data'
}),
('ta_size', {
'kind': 'data'
}),
],
new_edges_with_attrs=[('index', 'TensorArrayWrite', {
'in': 1
}), ('value', 'TensorArrayWrite', {
'in': 2
}), ('ta_size', 'TensorArray')],
update_nodes_attributes=[
('WriteEnter_data', {
'value': np.array([1, 1])
}),
('start_data', {
'value': np.array([0])
}),
('delta_data', {
'value': np.array([1])
}),
])
pattern_matcher.find_and_replace_pattern(graph)
graph_ref = build_graph_with_attrs(
nodes_with_attrs=[
('TensorIteratorOutput', {
'kind': 'op',
'op': 'TensorIteratorOutput'
}),
('TensorArrayGather_data', {
'kind': 'data'
}),
('index', {
'kind': 'data'
}),
('value', {
'kind': 'data'
}),
('ta_size', {
'kind': 'data'
}),
],
edges_with_attrs=[('ta_size', 'TensorIteratorOutput', {
'in': 0
}), ('index', 'TensorIteratorOutput', {
'in': 2
}), ('value', 'TensorIteratorOutput', {
'in': 1
}), ('TensorIteratorOutput', 'TensorArrayGather_data')],
update_edge_attrs=None,
new_nodes_with_attrs=[],
new_edges_with_attrs=[],
)
(flag, resp) = compare_graphs(graph,
graph_ref,
'TensorArrayGather_data',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_only_consumer_keep_result(self):
"""Result node is only consumer of Const data node"""
nodes = [
('placeholder_1', {
'type': 'Parameter',
'kind': 'op',
'op': 'Parameter'
}),
('placeholder_1_data', {
'kind': 'data'
}),
('placeholder_2', {
'type': 'Parameter',
'kind': 'op',
'op': 'Parameter'
}),
('placeholder_2_data', {
'kind': 'data'
}),
('shape_of', {
'type': 'ShapeOf',
'kind': 'op',
'op': 'ShapeOf'
}),
('shape_of_data', {
'kind': 'data'
}),
('split', {
'type': 'Split',
'kind': 'op',
'op': 'Split'
}),
('split_data1', {
'kind': 'data'
}),
('split_data2', {
'kind': 'data'
}),
('result_node1', {
'type': 'Result',
'kind': 'op',
'keep_output_port': True
}),
('mul', {
'type': 'Mul',
'kind': 'op',
'op': 'Mul'
}),
('mul_data', {
'kind': 'data'
}),
('result_node2', {
'type': 'Result',
'kind': 'op'
}),
]
edges = [
('placeholder_1', 'placeholder_1_data'),
('placeholder_2', 'placeholder_2_data'),
('placeholder_1_data', 'shape_of'),
('shape_of', 'shape_of_data'),
('shape_of_data', 'split'),
('split', 'split_data1', {
'in': 0
}),
('split', 'split_data2', {
'in': 1
}),
('split_data1', 'result_node1'),
('split_data2', 'mul'),
('placeholder_2_data', 'mul'),
('mul', 'mul_data'),
('mul_data', 'result_node2'),
]
graph = build_graph_with_attrs(
nodes_with_attrs=nodes,
edges_with_attrs=edges,
)
graph_ref = build_graph_with_attrs(
nodes_with_attrs=nodes,
edges_with_attrs=edges,
)
tested_pattern = RemoveConstToResult()
tested_pattern.find_and_replace_pattern(graph)
(flag, resp) = compare_graphs(graph, graph_ref, last_node='mul_data')
self.assertTrue(flag, resp)
self.assertIn('split_data1', graph.node)
self.assertIn('split_data2', graph.node)
self.assertIn('result_node1', graph.node)
def test_select_infer_condition_shapes_broadcast(self, else_data_shape,
than_data_shape,
select_output_shape):
graph = build_graph_with_attrs(nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[
('else_data', {
'shape':
np.array(else_data_shape),
'value':
np.zeros(else_data_shape,
dtype=np.float)
}),
('than_data', {
'shape':
np.array(than_data_shape),
'value':
np.zeros(than_data_shape,
dtype=np.float)
}),
('select_output', {
'shape':
np.array(select_output_shape),
'value':
np.zeros(select_output_shape,
dtype=np.float)
})
])
# We should propagate shapes and values
graph_ref = build_graph_with_attrs(
nodes_with_attrs=self.nodes,
edges_with_attrs=self.edges,
update_nodes_attributes=[('else_data', {
'shape':
np.array(else_data_shape),
'value':
np.zeros(else_data_shape, dtype=np.float)
}),
('than_data', {
'shape':
np.array(than_data_shape),
'value':
np.zeros(than_data_shape,
dtype=np.float)
}),
('select_output', {
'shape':
np.array(select_output_shape),
'value': np.zeros(select_output_shape)
})])
tested_class = Select(graph=graph, attrs={})
node = Node(graph, 'select')
tested_class.infer(node)
(flag, resp) = compare_graphs(graph,
graph_ref,
'select_output',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_bn(self):
bn_pb = FakeBNProtoLayer(FakeParam('eps', 0.0001))
mean = [1, 2.5, 3]
var = [0.5, 0.1, 1.2]
scale = [2.3, 3.4, 4.5]
shift = [0.8, 0.6, 0.4]
bn_bin = FakeBNBinLayer([
FakeParam('data', mean),
FakeParam('data', var),
FakeParam('data', scale),
FakeParam('data', shift)
])
nodes = [
('input', {
'kind': 'op',
'type': 'Identity',
'op': 'Identity'
}),
('bn', {
'type': None,
'kind': 'op',
'op': 'BN',
'pb': bn_pb,
'model_pb': bn_bin
}),
('output', {
'kind': 'op',
'type': 'Identity',
'op': 'Identity'
}),
]
edges = [
('input', 'bn', {
'in': 0,
'out': 0
}),
('bn', 'output', {
'in': 0,
'out': 0
}),
]
graph = build_graph_with_attrs(nodes, edges)
node = Node(graph, 'bn')
graph.stage = 'front'
BNToScaleShift().find_and_replace_pattern(graph)
ref_nodes = {
'input': {
'kind': 'op',
'type': 'Identity',
'op': 'Identity'
},
'scale': {
'kind': 'op',
'type': 'Const',
'op': 'Const',
'value': np.array([1.11796412, 3.2272172, 4.74282367])
},
'shift': {
'kind': 'op',
'type': 'Const',
'op': 'Const',
'value': np.array([-2.07131747, -10.87253847, -20.14270653])
},
'ss': {
'type': 'ScaleShift',
'kind': 'op',
'op': 'ScaleShift'
},
'output': {
'kind': 'op',
'type': 'Identity',
'op': 'Identity'
},
}
ref_edges = [
('input', 'ss', {
'in': 0,
'out': 0
}),
('scale', 'ss', {
'in': 1,
'out': 0
}),
('shift', 'ss', {
'in': 2,
'out': 0
}),
('ss', 'output', {
'in': 0,
'out': 0
}),
]
ref_graph = build_graph_with_edge_attrs(ref_nodes, ref_edges)
(flag, resp) = compare_graphs(graph,
ref_graph,
'input',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_not_dynamic(self):
pattern_matcher = LoopConditionMatcher()
pattern = pattern_matcher.pattern()
graph = build_graph_with_attrs(
nodes_with_attrs=pattern['nodes'],
edges_with_attrs=pattern['edges'],
new_nodes_with_attrs=[('maximum', {
'kind': 'op',
'op': 'Maximum'
}), ('maximum_data', {
'kind': 'data'
}),
('TensorIteratorInput', {
'kind': 'op',
'op': 'TensorIteratorInput'
})],
new_edges_with_attrs=[('maximum', 'maximum_data'),
('Identity_1_data', 'TensorIteratorInput')],
update_nodes_attributes=[
('init_1_data', {
'value': np.array([0])
}),
('init_2_data', {
'value': np.array([0])
}),
('add_1_y_data', {
'value': np.array(1)
}),
('add_2_y_data', {
'value': np.array(1)
}),
('loop_cond_data', {
'value': None
}),
(
'Identity_2_data',
{
'value': None
},
),
(
'Enter_1_less_data',
{
'value': None
},
),
(
'Enter_2_less_data',
{
'value': None
},
),
])
pattern_matcher.find_and_replace_pattern(graph)
graph_ref = build_graph_with_attrs(
nodes_with_attrs=[('TensorIteratorCondition', {
'kind': 'op',
'op': 'TensorIteratorCondition'
}), ('loop_cond_data', {
'kind': 'data'
}), ('identity_data', {
'kind': 'data'
}), ('StridedSlice', {
'kind': 'op',
'op': 'StridedSlice'
}), ('StridedSlice_data', {
'kind': 'data'
}), ('Maximum', {
'kind': 'op',
'op': 'Maximum'
}), ('Maximum_data', {
'kind': 'data'
}), ('minimum_data', {
'kind': 'data'
}),
('TensorIteratorInput', {
'kind': 'op',
'op': 'TensorIteratorInput'
})],
edges_with_attrs=[
('Maximum', 'Maximum_data'),
('StridedSlice', 'StridedSlice_data'),
('StridedSlice_data', 'TensorIteratorCondition', {
'in': 0
}),
('minimum_data', 'TensorIteratorCondition', {
'in': 1
}),
('TensorIteratorCondition', 'loop_cond_data'),
('TensorIteratorCondition', 'identity_data'),
('identity_data', 'TensorIteratorInput'),
],
update_edge_attrs=None,
new_nodes_with_attrs=[],
new_edges_with_attrs=[],
)
(flag, resp) = compare_graphs(graph,
graph_ref,
'loop_cond_data',
check_op_attrs=True)
self.assertTrue(flag, resp)
def test_switch_infer_with_condition(self):
nodes = [
('tensor', {
'value': np.zeros((3, 3)),
'kind': 'data',
'executable': True,
'shape': np.array([3, 3])
}),
('pred_id', {
'value': True,
'kind': 'data',
'executable': True
}),
('switch', {
'type': 'Switch',
'kind': 'op',
'op': 'Switch',
'infer': Switch.infer
}),
('switch_data_0', {
'value': None,
'kind': 'data',
'executable': True,
'shape': None
}),
('switch_data_1', {
'value': None,
'kind': 'data',
'executable': True,
'shape': None
}),
('result_0', {
'value': None,
'kind': 'op',
'executable': True,
'type': 'Result',
'op': 'Result'
}),
('result_1', {
'value': None,
'kind': 'op',
'executable': True,
'type': 'Result',
'op': 'Result'
}),
]
edges = [
('tensor', 'switch', {
'in': 0
}),
('pred_id', 'switch', {
'in': 1
}),
('switch', 'switch_data_0', {
'out': 0
}),
('switch', 'switch_data_1', {
'out': 1
}),
('switch_data_0', 'result_0'),
('switch_data_1', 'result_1'),
]
graph = build_graph_with_attrs(nodes_with_attrs=nodes,
edges_with_attrs=edges)
# We should propagate shapes and values
graph_ref = build_graph_with_attrs(nodes_with_attrs=nodes,
edges_with_attrs=edges,
update_nodes_attributes=[
('switch_data_0', {
'shape': np.array([3, 3]),
'value': np.zeros((3, 3))
}),
('switch_data_1', {
'shape': np.array([3, 3]),
'value': np.zeros((3, 3))
})
])
node = Node(graph, 'switch')
node.infer(node)
(flag, resp) = compare_graphs(graph,
graph_ref,
'switch_data_0',
check_op_attrs=True)
self.assertTrue(flag, resp)
