def test_attributed(self): graph = build_graph(nodes_attributes, [ ('placeholder', 'attr_split', { 'in': 0, 'out': 0 }), ('attr_split', 'concat', { 'in': 0, 'out': 0 }), ('attr_split', 'concat', { 'in': 1, 'out': 1 }), ('concat', 'result', { 'in': 0, 'out': 0 }), ], nodes_with_edges_only=True) graph_ref = build_graph(nodes_attributes, [ ('placeholder', 'attr_split', { 'in': 0, 'out': 0 }), ('attr_split', 'squeeze1', { 'in': 0, 'out': 0 }), ('squeeze1_axis', 'squeeze1', { 'in': 1, 'out': 0 }), ('attr_split', 'squeeze2', { 'in': 0, 'out': 1 }), ('squeeze2_axis', 'squeeze2', { 'in': 1, 'out': 0 }), ('squeeze1', 'concat', { 'in': 0, 'out': 0 }), ('squeeze2', 'concat', { 'in': 1, 'out': 0 }), ('concat', 'result', { 'in': 0, 'out': 0 }), ], nodes_with_edges_only=True) graph.graph['layout'] = 'NCHW' graph.stage = 'front' SqueezeAxis().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result', check_op_attrs=True) self.assertTrue(flag, resp)
def test_embedding_replace1(self): graph = build_graph( { 'placeholder_1': { 'shape': None, 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'embedding_const': { 'value': None, 'shape': None, 'kind': 'op', 'op': 'Const' }, 'embedding': { 'type': None, 'kind': 'op', 'op': 'Embedding' }, 'last': { 'type': None, 'kind': 'op', 'op': None }, }, [('placeholder_1', 'embedding', { 'out': 0, 'in': 0 }), ('embedding_const', 'embedding', { 'out': 0, 'in': 1 }), ('embedding', 'last')], { 'placeholder_1': { 'shape': np.array([32, 35]) }, 'embedding_const': { 'shape': np.array([2000, 650]), 'bias': np.array(np.random.randint(0, 225, (2000, 650))) }, }, nodes_with_edges_only=True) graph_ref = build_graph( { 'placeholder_1': { 'shape': None, 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'embedding_const': { 'value': None, 'kind': 'op', 'op': 'Const' }, 'axis_const': { 'value': 0, 'kind': 'op', 'data_type': None, 'type': 'Const', 'op': 'Const' }, 'embedding': { 'kind': 'op', 'op': 'Gather' }, 'last': { 'type': None, 'kind': 'op', 'op': None }, }, [('embedding_const', 'embedding', { 'in': 1 }), ('axis_const', 'embedding', { 'in': 2 }), ('placeholder_1', 'embedding', { 'in': 0 }), ('embedding', 'last')], { 'placeholder_1': { 'shape': np.array([32, 35]) }, 'embedding_const': { 'shape': np.array([2000, 650]), 'bias': np.array(np.random.randint(0, 225, (2000, 650))) }, }, nodes_with_edges_only=True) graph.graph['layout'] = 'NCHW' graph.stage = 'front' replacer = GatherFrontReplacer() replacer.find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'last') self.assertTrue(flag, resp)
def test_insert_select_1(self): graph = build_graph( { 'in_node': { 'kind': 'data', 'shape': [1, 13] }, 'placeholder_1': { 'kind': 'op', 'op': None }, 'placeholder_data_1': { 'kind': 'data', 'shape': [1, 13] }, 'splice_1': { 'kind': 'op', 'op': 'Splice', 'context': np.array([-2, -1, 0, 1, 2]) }, 'splice_data_1': { 'kind': 'data', 'shape': [1, 13] }, 'placeholder_2': { 'kind': 'op', 'op': None }, 'placeholder_data_2': { 'kind': 'data', 'shape': [1, 26] }, 'memory': { 'kind': 'op', 'op': 'Memory', 'index': 0 }, }, [('in_node', 'placeholder_1'), ('placeholder_1', 'placeholder_data_1'), ('placeholder_data_1', 'splice_1'), ('splice_1', 'splice_data_1'), ('splice_data_1', 'placeholder_2'), ('placeholder_2', 'placeholder_data_2'), ('placeholder_data_2', 'memory')], nodes_with_edges_only=True) AddSelectBeforeMemoryNodePattern().find_and_replace_pattern(graph) ref_graph = build_graph( { 'in_node': { 'kind': 'data', 'shape': [1, 13] }, 'placeholder_1': { 'kind': 'op', 'op': None }, 'placeholder_data_1': { 'kind': 'data', 'shape': [1, 13] }, 'splice_1': { 'kind': 'op', 'op': 'Splice', 'context': np.array([-2, -1, 0, 1, 2]) }, 'splice_data_1': { 'kind': 'data', 'shape': [1, 13] }, 'placeholder_2': { 'kind': 'op', 'op': None }, 'memory_in': { 'kind': 'op', 'op': 'Memory', 'shape': int64_array([5]) }, 'memory_in_data': { 'kind': 'data' }, 'memory_out': { 'kind': 'op', 'op': 'Memory', 'shape': int64_array([5]) }, 'memory_out_data': { 'kind': 'data' }, 'result': { 'kind': 'op', 'op': 'Result' }, 'crop_in': { 'kind': 'op', 'op': 'Crop', 'axis': 1, 'offset': 1, 'dim': 4 }, 'crop_in_data': { 'kind': 'data' }, 'crop_out': { 'kind': 'op', 'op': 'Crop', 'axis': 1, 'offset': 0, 'dim': 1 }, 'crop_out_data': { 'kind': 'data' }, 'select': { 'kind': 'op', 'op': 'Select' }, 'select_out_data': { 'kind': 'data', 'shape': [1, 26] }, 'const_0': { 'kind': 'op', 'op': 'Const' }, 'const_0_data': { 'kind': 'data' }, 'const_1': { 'kind': 'op', 'op': 'Const' }, 'const_1_data': { 'kind': 'data' }, 'concat': { 'kind': 'op', 'op': 'Concat' }, 'concat_data': { 'kind': 'data' }, 'placeholder_data_2': { 'kind': 'data', 'shape': [1, 26] }, 'memory': { 'kind': 'op', 'op': 'Memory', 'index': 0 }, }, [('in_node', 'placeholder_1'), ('placeholder_1', 'placeholder_data_1'), ('placeholder_data_1', 'splice_1'), ('splice_1', 'splice_data_1'), ('splice_data_1', 'placeholder_2'), ('placeholder_2', 'placeholder_data_2'), ('placeholder_data_2', 'select', { 'in': 1 }), ('memory_in', 'memory_in_data'), ('memory_in_data', 'crop_in'), ('crop_in', 'crop_in_data'), ('crop_in_data', 'concat', { 'in': 0 }), ('const_1', 'const_1_data'), ('const_1_data', 'concat', { 'in': 1 }), ('concat', 'concat_data'), ('concat_data', 'memory_out'), ('memory_out', 'memory_out_data'), ('memory_out_data', 'result'), ('concat_data', 'crop_out'), ('crop_out', 'crop_out_data'), ('crop_out_data', 'select', { 'in': 0 }), ('const_0', 'const_0_data'), ('const_0_data', 'select', { 'in': 2 }), ('select', 'select_out_data'), ('select_out_data', 'memory')], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, ref_graph, 'memory') self.assertTrue(flag, resp)
def test(self): pattern_matcher = SmartInputMatcher() pattern = pattern_matcher.pattern() graph = build_graph_with_attrs( nodes_with_attrs=pattern['nodes'], edges_with_attrs=pattern['edges'], update_edge_attrs={ ('range_data', 'TensorArrayScatter', 0): { 'in': 1 }, ('TensorArray_handle', 'TensorArrayScatter', 0): { 'in': 0 }, ('TensorArray_flow', 'TensorArrayScatter', 0): { 'in': 3 } }, new_nodes_with_attrs=[ ('ta_size', { 'kind': 'data' }), ('ta_size_op', { 'kind': 'op' }), ('value', { 'kind': 'data' }), ], new_edges_with_attrs=[ ('ta_size_op', 'ta_size'), ('ta_size', 'TensorArray'), ('value', 'TensorArrayScatter', { 'in': 2 }), ], update_nodes_attributes=[('Enter_data', { 'value': np.array([1]) }), ('stack_data', { 'value': np.array([0]) }), ('stack_1_data', { 'value': np.array([1]) }), ('stack_2_data', { 'value': np.array([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=[('condition_data', { 'kind': 'data' }), ('TensorIteratorInput', { 'kind': 'op', 'op': 'TensorIteratorInput' }), ('TensorArrayRead_data', { 'kind': 'data' }), ('condition_data', { 'kind': 'data' }), ('value', { 'kind': 'data' }), ('ta_size', { 'kind': 'data' }), ('ta_size_op', { 'kind': 'op' })], edges_with_attrs=[('ta_size', 'TensorIteratorInput', { 'in': 0 }), ('condition_data', 'TensorIteratorInput', { 'in': 2 }), ('value', 'TensorIteratorInput', { 'in': 1 }), ('TensorIteratorInput', 'TensorArrayRead_data'), ('ta_size_op', 'ta_size')], update_edge_attrs=None, new_nodes_with_attrs=[], new_edges_with_attrs=[], ) (flag, resp) = compare_graphs(graph, graph_ref, 'TensorArrayRead_data', check_op_attrs=True) self.assertTrue(flag, resp)
def test_add_input_with_output_port_after_infer(self): shape = np.array([1, 2, 3, 4]) inputs = {'conv_1': [{'shape': shape, 'out': 0}]} nodes = { 'old_input': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'inp_data': { 'kind': 'data', 'shape': shape + 1 }, 'conv_1': { 'type': 'Convolution', 'kind': 'op', 'op': 'NotPlaceholder' }, 'conv_data': { 'kind': 'data', 'shape': shape, 'value': None }, 'relu_1': { 'type': 'ReLU', 'kind': 'op', 'op': 'NotPlaceholder' }, } edges = [ ('old_input', 'inp_data'), ('inp_data', 'conv_1'), ('conv_1', 'conv_data'), ('conv_data', 'relu_1'), ] graph = build_graph(nodes, edges) add_input_ops(graph=graph, user_defined_inputs=inputs, before_infer=False) graph_ref = build_graph( nodes_attrs={ 'new_input': { 'kind': 'op', 'op': 'Parameter', 'shape': shape }, **nodes }, edges=[ ('old_input', 'inp_data'), ('inp_data', 'conv_1'), ('new_input', 'conv_data'), ('conv_data', 'relu_1'), ], ) # Check that new input is added right (with right ports !) (flag, resp) = compare_graphs(graph, graph_ref, last_node='relu_1') self.assertTrue(flag, resp) # Check that other graph is not damaged (flag, resp) = compare_graphs(graph, graph_ref, last_node='conv_1') self.assertTrue(flag, resp) # Checks for new input and edges self.assertTrue('conv_1/placeholder_out_port_0' in graph.nodes()) new_input = 'conv_1/placeholder_out_port_0' self.assertTrue(graph.node[new_input]['is_input']) self.assertTrue((new_input, 'conv_data') in graph.edges()) self.assertTrue(('conv_1', 'conv_data') not in graph.edges())
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_mega_hardcore(self): # ORIGINAL GRAPH # # data1(1,3,64,64)---,->Eltwise1->data(1,3,64,64)-----,->Eltwise2->data(1,3,64,64)---,->Eltwise4->data(1,3,64,64) # /\ /\ /\ # data2(64,1)-----,-'--------------------------------'------------------------------' # \/ / # data3(64,1)----`-->Eltwise3->data(64,1)----------' # # REFERENCE GRAPH AFTER TRANSFORMATION # # data1(1,3,64,64)---------------------,->Eltwise1->data(1,3,64,64)-----,->Eltwise2->data(1,3,64,64)---,->Eltwise4->data(1,3,64,64) # /\ /\ /\ # data2(64,1)-,- Reshape1(1,1,64,64)--'--------------------------------o-------------------------------' # | | # | Reshape(1,1,64,1) # \/ | # data3(64,1)----------->Eltwise3->data(64,1)--------------------------' # graph = build_graph(nodes_attributes, [ ('placeholder_1', 'placeholder_1_data'), ('placeholder_2', 'placeholder_2_data'), ('placeholder_3', 'placeholder_3_data'), ('placeholder_1_data', 'eltwise_1'), ('placeholder_2_data', 'eltwise_1'), ('eltwise_1', 'eltwise_1_data'), ('eltwise_1_data', 'eltwise_2'), ('placeholder_2_data', 'eltwise_3'), ('placeholder_3_data', 'eltwise_3'), ('eltwise_3', 'eltwise_3_data'), ('eltwise_3_data', 'eltwise_2'), ('eltwise_2', 'eltwise_2_data'), ('eltwise_2_data', 'eltwise_4'), ('placeholder_2_data', 'eltwise_4'), ('eltwise_4', 'eltwise_4_data'), ], { 'placeholder_1_data': { 'shape': np.array([1, 3, 64, 64]) }, 'placeholder_2_data': { 'shape': np.array([64, 1]), 'value': np.ones([64, 1]) }, 'placeholder_3_data': { 'shape': np.array([64, 1]) }, 'eltwise_1_data': { 'shape': np.array([1, 3, 64, 64]) }, 'eltwise_2_data': { 'shape': np.array([1, 3, 64, 64]) }, 'eltwise_3_data': { 'shape': np.array([64, 1]) }, 'eltwise_4_data': { 'shape': np.array([1, 3, 64, 64]) } }, nodes_with_edges_only=True) graph_ref = build_graph(nodes_attributes, [ ('placeholder_1', 'placeholder_1_data'), ('placeholder_2', 'placeholder_2_data'), ('placeholder_3', 'placeholder_3_data'), ('placeholder_1_data', 'eltwise_1'), ('placeholder_2_data', 'reshape_1'), ('reshape_1_const', 'reshape_1_const_data'), ('reshape_1_const_data', 'reshape_1'), ('reshape_1', 'reshape_1_data'), ('reshape_1_data', 'eltwise_1'), ('eltwise_1', 'eltwise_1_data'), ('eltwise_1_data', 'eltwise_2'), ('placeholder_2_data', 'eltwise_3'), ('placeholder_3_data', 'eltwise_3'), ('eltwise_3', 'eltwise_3_data'), ('eltwise_3_data', 'reshape_2'), ('reshape_2_const', 'reshape_2_const_data'), ('reshape_2_const_data', 'reshape_2'), ('reshape_2', 'reshape_2_data'), ('reshape_2_data', 'eltwise_2'), ('eltwise_2', 'eltwise_2_data'), ('eltwise_2_data', 'eltwise_4'), ('reshape_1_data', 'eltwise_4'), ('eltwise_4', 'eltwise_4_data'), ], { 'placeholder_1_data': { 'shape': np.array([1, 3, 64, 64]) }, 'placeholder_2_data': { 'shape': np.array([64, 1]), 'value': np.ones([64, 1]) }, 'placeholder_3_data': { 'shape': np.array([64, 1]) }, 'reshape_1_const': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_1_const_data': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_1_data': { 'shape': np.array([1, 1, 64, 1]) }, 'reshape_2_const': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_2_const_data': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_2_data': { 'shape': np.array([1, 1, 64, 1]) }, 'eltwise_1_data': { 'shape': np.array([1, 3, 64, 64]) }, 'eltwise_2_data': { 'shape': np.array([1, 3, 64, 64]) }, 'eltwise_3_data': { 'shape': np.array([64, 1]) }, 'eltwise_4_data': { 'shape': np.array([1, 3, 64, 64]) } }, nodes_with_edges_only=True) normalize_eltwise_inputs(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'eltwise_4', check_op_attrs=True) self.assertTrue(flag, resp)
def test1(self): nodes_attributes = { # nodes from original graph 'logits': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'seq_len': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoder' }, 'cast': { 'kind': 'op', 'op': 'Cast' }, 'sparse_to_dense': { 'kind': 'op', 'op': 'SparseToDense' }, 'last': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, # new nodes 'new_decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoder', 'use_mask_format': True }, **const('squeeze_axes', int64_array([2, 3])), 'squeeze_dec_seq': { 'kind': 'op', 'op': 'Squeeze' }, 'cast_to_int': { 'kind': 'op', 'op': 'Cast' }, } graph = build_graph(nodes_attributes, [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('decoder', 'cast', { 'out': 1, 'in': 0 }), ('cast', 'sparse_to_dense', { 'out': 0 }), ('sparse_to_dense', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [ ('logits', 'decoder', { 'out': 0, 'in': 0 }), ('seq_len', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'squeeze_dec_seq', { 'out': 0, 'in': 0 }), ('squeeze_axes', 'squeeze_dec_seq', { 'out': 0, 'in': 1 }), ('squeeze_dec_seq', 'cast_to_int', { 'out': 0, 'in': 0 }), ('cast_to_int', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertEqual( len(graph.get_op_nodes(op='Cast')) == 1 and graph.get_op_nodes(op='Cast')[0]['name'] == 'sparse_to_dense', True, 'Name is not inherited from original node for CTCGreedyDecoderReplacement' ) self.assertTrue(flag, resp)
def test_resnet_optimization_6(self): graph = build_graph(nodes_attributes, [('placeholder_1', 'placeholder_1_data'), ('placeholder_1_data', 'conv_1'), ('conv_1_w', 'conv_1'), ('conv_1_b', 'conv_1'), ('conv_1', 'conv_1_data'), ('conv_1_data', 'conv_2'), ('conv_2_w', 'conv_2'), ('conv_2_b', 'conv_2'), ('conv_2', 'conv_2_data'), ('conv_2_data', 'conv_3'), ('conv_3_w', 'conv_3'), ('conv_3_b', 'conv_3'), ('conv_3', 'conv_3_data'), ('conv_3_data', 'conv_4'), ('conv_4_w', 'conv_4'), ('conv_4_b', 'conv_4'), ('conv_4', 'conv_4_data'), ], {'placeholder_1_data': {'shape': np.array([1, 3, 224, 224])}, 'conv_1_w': {'value': np.zeros([3, 3, 1, 1]), 'shape': np.array([3, 3, 1, 1])}, 'conv_1': {'kernel_spatial': np.array([1, 1]), 'stride': np.array([1, 1, 1, 1]), 'output': np.array([3]), }, 'conv_1_data': {'shape': np.array([1, 3, 224, 224])}, 'conv_2_w': {'value': np.zeros([3, 3, 1, 1]), 'shape': np.array([3, 3, 1, 1])}, 'conv_2': {'kernel_spatial': np.array([1, 1]), 'stride': np.array([1, 1, 2, 2]), 'output': np.array([3]), }, 'conv_2_data': {'shape': np.array([1, 3, 112, 112])}, 'conv_3_w': {'value': np.zeros([3, 3, 3, 3]), 'shape': np.array([3, 3, 3, 3])}, 'conv_3': {'kernel_spatial': np.array([3, 3]), 'stride': np.array([1, 1, 1, 1]), 'output': np.array([3]), }, 'conv_3_data': {'shape': np.array([1, 3, 110, 110])}, 'conv_4_w': {'value': np.zeros([3, 3, 1, 1]), 'shape': np.array([3, 3, 1, 1])}, 'conv_4': {'kernel_spatial': np.array([1, 1]), 'stride': np.array([1, 1, 2, 2]), 'output': np.array([3]), }, 'conv_4_data': {'shape': np.array([1, 3, 55, 55])}, }, nodes_with_edges_only=True) graph_ref = build_graph(nodes_attributes, [('placeholder_1', 'placeholder_1_data'), ('placeholder_1_data', 'conv_1'), ('conv_1_w', 'conv_1'), ('conv_1_b', 'conv_1'), ('conv_1', 'conv_1_data'), ('conv_1_data', 'conv_2'), ('conv_2_w', 'conv_2'), ('conv_2_b', 'conv_2'), ('conv_2', 'conv_2_data'), ('conv_2_data', 'conv_3'), ('conv_3_w', 'conv_3'), ('conv_3_b', 'conv_3'), ('conv_3', 'conv_3_data'), ('conv_3_data', 'conv_4'), ('conv_4_w', 'conv_4'), ('conv_4_b', 'conv_4'), ('conv_4', 'conv_4_data'), ], {'placeholder_1_data': {'shape': np.array([1, 3, 224, 224])}, 'conv_1_w': {'value': np.zeros([3, 3, 1, 1]), 'shape': np.array([3, 3, 1, 1])}, 'conv_1': {'kernel_spatial': np.array([1, 1]), 'stride': np.array([1, 1, 2, 2]), 'output': np.array([3])}, 'conv_1_data': {'shape': np.array([1, 3, 112, 112])}, 'conv_2_w': {'value': np.zeros([3, 3, 1, 1]), 'shape': np.array([3, 3, 1, 1])}, 'conv_2': {'kernel_spatial': np.array([1, 1]), 'stride': np.array([1, 1, 1, 1]), 'output': np.array([3])}, 'conv_2_data': {'shape': np.array([1, 3, 112, 112])}, 'conv_3_w': {'value': np.zeros([3, 3, 3, 3]), 'shape': np.array([3, 3, 3, 3])}, 'conv_3': {'kernel_spatial': np.array([3, 3]), 'stride': np.array([1, 1, 2, 2]), 'output': np.array([3])}, 'conv_3_data': {'shape': np.array([1, 3, 55, 55])}, 'conv_4_w': {'value': np.zeros([3, 3, 1, 1]), 'shape': np.array([3, 3, 1, 1])}, 'conv_4': {'kernel_spatial': np.array([1, 1]), 'stride': np.array([1, 1, 1, 1]), 'output': np.array([3])}, 'conv_4_data': {'shape': np.array([1, 3, 55, 55])}, }, nodes_with_edges_only=True) graph.graph['layout'] = 'NCHW' graph_ref.graph['layout'] = 'NCHW' stride_optimization(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'conv_4_data', check_op_attrs=True) self.assertTrue(flag, resp)
def test_groupconv_to_conv(self, shape, weights_shape, reshape_shape, group): weights_const = np.random.randn(*weights_shape).astype(np.float32) nodes_attributes = { 'input': { 'kind': 'op', 'type': 'Parameter' }, 'input_data': { 'shape': shape, 'kind': 'data' }, 'group_conv': { 'kind': 'op', 'type': 'GroupConvolution' }, 'group_conv_data': { 'shape': shape, 'kind': 'data' }, 'conv': { 'kind': 'op', 'type': 'Convolution', 'group': group }, 'conv_data': { 'shape': shape, 'kind': 'data' }, 'weights': { 'kind': 'op', 'type': 'Const', 'value': weights_const }, 'weights_data': { 'shape': weights_shape, 'kind': 'data' }, 'reshape': { 'kind': 'op', 'type': 'Reshape' }, 'reshape_data': { 'shape': reshape_shape, 'kind': 'data' }, 'reshape_const': { 'kind': 'op', 'type': 'Const' }, 'reshape_const_data': { 'shape': len(reshape_shape) if reshape_shape is not None else None, 'kind': 'data' }, 'add': { 'kind': 'op', 'type': 'Add' }, 'add_data': { 'shape': shape, 'kind': 'data' }, 'add_const': { 'kind': 'op', 'type': 'Const' }, 'add_const_data': { 'shape': [1, 32, 1, 1], 'kind': 'data' }, 'result': { 'kind': 'op', 'type': 'Result' } } edges = [ ('input', 'input_data'), ('input_data', 'group_conv'), ('weights', 'weights_data'), ('group_conv', 'group_conv_data'), ('group_conv_data', 'add'), ('add_const', 'add_const_data'), ('add_const_data', 'add'), ('add', 'add_data'), ('add_data', 'result'), ] if reshape_shape is not None: edges += [('weights_data', 'reshape'), ('reshape_const', 'reshape_const_data'), ('reshape_const_data', 'reshape'), ('reshape', 'reshape_data'), ('reshape_data', 'group_conv')] else: edges.append(('weights_data', 'group_conv')) graph = build_graph(nodes_attributes, edges, nodes_with_edges_only=True) graph_ref = build_graph(nodes_attributes, [ ('input', 'input_data'), ('input_data', 'conv'), ('weights', 'weights_data'), ('weights_data', 'conv'), ('conv', 'conv_data'), ('conv_data', 'add'), ('add_const', 'add_const_data'), ('add_const_data', 'add'), ('add', 'add_data'), ('add_data', 'result'), ], nodes_with_edges_only=True) for op in graph.get_op_nodes(type='GroupConvolution'): groupconv_to_conv(op) if reshape_shape is None: new_shape = [weights_shape[1] * group, *weights_shape[2:]] weights_const = np.reshape(weights_const, new_shape) node = Node(graph_ref, 'weights') node.value = weights_const (flag, resp) = compare_graphs(graph, graph_ref, 'result', check_op_attrs=True) self.assertTrue(flag, resp)
def test2(self): nodes_attributes = { # nodes from original graph 'logits': { 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'transpose': { 'kind': 'op', 'op': 'Transpose' }, 'shape': { 'kind': 'op', 'op': 'ShapeOf' }, 'shape_1': { 'kind': 'op', 'op': 'ShapeOf' }, 'strided_slice': { 'kind': 'op', 'op': 'StridedSlice' }, **const('stack', int64_array([1])), **const('stack1', int64_array([2])), **const('stack2', int64_array([1])), 'strided_slice_1': { 'kind': 'op', 'op': 'StridedSlice' }, **const('stack_1', int64_array([0])), **const('stack1_1', int64_array([1])), **const('stack2_1', int64_array([1])), 'dims': { 'kind': 'op', 'op': 'Pack' }, 'fill': { 'kind': 'op', 'op': 'Fill' }, 'decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoder' }, 'cast': { 'kind': 'op', 'op': 'Cast' }, 'sparse_to_dense': { 'kind': 'op', 'op': 'SparseToDense' }, # new nodes **const('unsqueeze_batch_size_axis', int64_array(0)), 'unsqueeze_batch_size': { 'kind': 'op', 'op': 'Unsqueeze' }, **const('unsqueeze_time_size_axis', int64_array(0)), 'unsqueeze_time_size': { 'kind': 'op', 'op': 'Unsqueeze' }, 'seq_mask_shape': { 'kind': 'op', 'op': 'Concat' }, 'sequence_mask': { 'kind': 'op', 'op': 'Broadcast' }, **const('one', np.array([1.0], dtype=np.float)), **const('squeeze_axes', int64_array([2, 3])), 'squeeze_dec_seq': { 'kind': 'op', 'op': 'Squeeze' }, 'cast_to_int': { 'kind': 'op', 'op': 'Cast' }, 'last': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, } graph = build_graph(nodes_attributes, [ ('logits', 'transpose', { 'out': 0 }), ('transpose', 'shape', { 'out': 0 }), ('transpose', 'shape_1', { 'out': 0 }), ('transpose', 'decoder', { 'out': 0, 'in': 0 }), ('shape', 'strided_slice', { 'out': 0, 'in': 0 }), ('stack', 'strided_slice', { 'out': 0, 'in': 1 }), ('stack1', 'strided_slice', { 'out': 0, 'in': 2 }), ('stack2', 'strided_slice', { 'out': 0, 'in': 3 }), ('shape_1', 'strided_slice_1', { 'out': 0, 'in': 0 }), ('stack_1', 'strided_slice_1', { 'out': 0, 'in': 1 }), ('stack1_1', 'strided_slice_1', { 'out': 0, 'in': 2 }), ('stack2_1', 'strided_slice_1', { 'out': 0, 'in': 3 }), ('strided_slice', 'dims', { 'out': 0, 'in': 0 }), ('dims', 'fill', { 'out': 0, 'in': 0 }), ('strided_slice_1', 'fill', { 'out': 0, 'in': 1 }), ('fill', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('decoder', 'cast', { 'out': 1, 'in': 0 }), ('cast', 'sparse_to_dense', { 'out': 0 }), ('sparse_to_dense', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) graph.stage = 'front' CTCGreedyDecoderReplacement2().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [ ('logits', 'transpose', { 'out': 0 }), ('transpose', 'shape', { 'out': 0 }), ('transpose', 'shape_1', { 'out': 0 }), ('transpose', 'decoder', { 'out': 0, 'in': 0 }), ('shape', 'strided_slice', { 'out': 0, 'in': 0 }), ('stack', 'strided_slice', { 'out': 0, 'in': 1 }), ('stack1', 'strided_slice', { 'out': 0, 'in': 2 }), ('stack2', 'strided_slice', { 'out': 0, 'in': 3 }), ('shape_1', 'strided_slice_1', { 'out': 0, 'in': 0 }), ('stack_1', 'strided_slice_1', { 'out': 0, 'in': 1 }), ('stack1_1', 'strided_slice_1', { 'out': 0, 'in': 2 }), ('stack2_1', 'strided_slice_1', { 'out': 0, 'in': 3 }), ('strided_slice', 'unsqueeze_batch_size', { 'out': 0, 'in': 0 }), ('unsqueeze_batch_size_axis', 'unsqueeze_batch_size', { 'out': 0, 'in': 1 }), ('strided_slice_1', 'unsqueeze_time_size', { 'out': 0, 'in': 0 }), ('unsqueeze_time_size_axis', 'unsqueeze_time_size', { 'out': 0, 'in': 1 }), ('unsqueeze_batch_size', 'seq_mask_shape', { 'out': 0, 'in': 1 }), ('unsqueeze_time_size', 'seq_mask_shape', { 'out': 0, 'in': 0 }), ('one', 'sequence_mask', { 'out': 0, 'in': 0 }), ('seq_mask_shape', 'sequence_mask', { 'out': 0, 'in': 1 }), ('sequence_mask', 'decoder', { 'out': 0, 'in': 1 }), ('decoder', 'squeeze_dec_seq', { 'out': 0, 'in': 0 }), ('squeeze_axes', 'squeeze_dec_seq', { 'out': 0, 'in': 1 }), ('squeeze_dec_seq', 'cast_to_int', { 'out': 0, 'in': 0 }), ('cast_to_int', 'last', { 'out': 0, 'in': 0 }), ], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertEqual( len(graph.get_op_nodes(op='Cast')) == 1 and graph.get_op_nodes(op='Cast')[0]['name'] == 'sparse_to_dense', True, 'Name is not inherited from original node for CTCGreedyDecoderReplacement2' ) 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': 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 test2(self): nodes_attributes = { 'logits': { 'shape': int64_array([2, 6, 100]), 'type': 'Parameter', 'kind': 'op', 'op': 'Parameter' }, 'seq_mask': { 'shape': int64_array([2]), 'data_type': np.int32, 'kind': 'op', 'op': 'Parameter' }, 'transpose': { 'kind': 'op', 'op': 'Transpose' }, 'ctc_greedy_decoder': { 'kind': 'op', 'op': 'CTCGreedyDecoderSeqLen', 'merge_repeated': True }, 'cast': { 'kind': 'op', 'op': 'Cast' }, 'sparse_to_dense': { 'kind': 'op', 'op': 'SparseToDense' }, 'tf_ctc_loss': { 'kind': 'op', 'op': 'CTCLoss', 'preprocess_collapse_repeated': False, 'ctc_merge_repeated': True, 'unique': False, 'logits_time_major': False }, 'ctc_loss': { 'kind': 'op', 'op': 'CTCLoss', 'preprocess_collapse_repeated': False, 'ctc_merge_repeated': True, 'unique': False }, **const('default_value', int64_array(-1)), 'last': { 'type': None, 'value': None, 'kind': 'op', 'op': 'Result' }, 'transpose2': { 'kind': 'op', 'op': 'Transpose' }, **const('transpose2_axis', int64_array([1, 0, 2])), } graph = build_graph(nodes_attributes, [('logits', 'transpose', { 'out': 0, 'in': 0 }), ('transpose', 'ctc_greedy_decoder', { 'out': 0, 'in': 0 }), ('seq_mask', 'ctc_greedy_decoder', { 'out': 0, 'in': 1 }), ('transpose', 'tf_ctc_loss', { 'out': 0, 'in': 0 }), ('seq_mask', 'tf_ctc_loss', { 'out': 0, 'in': 3 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 0, 'in': 0 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 2, 'in': 1 }), ('ctc_greedy_decoder', 'sparse_to_dense', { 'out': 1, 'in': 2 }), ('default_value', 'sparse_to_dense', { 'out': 0, 'in': 3 }), ('ctc_greedy_decoder', 'cast', { 'out': 1, 'in': 0 }), ('ctc_greedy_decoder', 'tf_ctc_loss', { 'out': 0, 'in': 1 }), ('cast', 'tf_ctc_loss', { 'out': 0, 'in': 2 }), ('tf_ctc_loss', 'last', { 'out': 0, 'in': 0 })], nodes_with_edges_only=True) graph.graph['cmd_params'] = Namespace(data_type='FP32') graph.stage = 'front' CTCLossReplacement().find_and_replace_pattern(graph) graph_ref = build_graph(nodes_attributes, [('logits', 'transpose', { 'out': 0, 'in': 0 }), ('transpose', 'transpose2', { 'out': 0, 'in': 0 }), ('transpose2_axis', 'transpose2', { 'out': 0, 'in': 1 }), ('transpose2', 'ctc_greedy_decoder', { 'out': 0, 'in': 0 }), ('seq_mask', 'ctc_greedy_decoder', { 'out': 0, 'in': 1 }), ('transpose', 'ctc_loss', { 'out': 0, 'in': 0 }), ('ctc_greedy_decoder', 'ctc_loss', { 'out': 0, 'in': 2 }), ('ctc_greedy_decoder', 'ctc_loss', { 'out': 1, 'in': 3 }), ('seq_mask', 'ctc_loss', { 'out': 0, 'in': 1 }), ('ctc_loss', 'last', { 'out': 0, 'in': 0 })], nodes_with_edges_only=True) (flag, resp) = compare_graphs(graph, graph_ref, 'last', check_op_attrs=True) self.assertTrue(flag, resp)
def test2(self): """ Case with non-constant input to init. Nothing should happen with graph. """ pattern_matcher = BackEdgeSimpleInputMatcher() pattern = pattern_matcher.pattern() graph = build_graph_with_attrs(nodes_with_attrs=pattern['nodes'], edges_with_attrs=pattern['edges'], new_nodes_with_attrs=[ ('cycle_data', { 'kind': 'data' }), ('condition', { 'kind': 'data' }), ('init', { 'kind': 'data', 'shape': np.array([1, 3]) }), ('Enter', { 'kind': 'op', 'op': 'Enter' }), ], new_edges_with_attrs=[ ('Enter', 'init'), ('condition', 'BackEdge', { 'in': 2 }), ('init', 'BackEdge', { 'in': 0 }), ('cycle_data', 'BackEdge', { 'in': 1 }) ]) pattern_matcher.find_and_replace_pattern(graph) graph_ref = build_graph_with_attrs( nodes_with_attrs=pattern['nodes'], edges_with_attrs=pattern['edges'], new_nodes_with_attrs=[ ('cycle_data', { 'kind': 'data' }), ('condition', { 'kind': 'data' }), ('init', { 'kind': 'data', 'shape': np.array([1, 3]) }), ('Enter', { 'kind': 'op', 'op': 'Enter' }), ], new_edges_with_attrs=[('Enter', 'init'), ('condition', 'BackEdge', { 'in': 2 }), ('init', 'BackEdge', { 'in': 0 }), ('cycle_data', 'BackEdge', { 'in': 1 })], ) (flag, resp) = compare_graphs(graph, graph_ref, 'BackEdge', check_op_attrs=True) self.assertTrue(flag, resp)
def test_tf_all_ports(self): graph = build_graph( nodes_attributes, [ ('placeholder_1', 'placeholder_1_data'), ('placeholder_2', 'placeholder_2_data'), ('placeholder_1_data', 'gathernd'), ('placeholder_2_data', 'gathernd'), ('gathernd', 'gathernd_data'), ('gathernd_data', 'result'), ], { 'placeholder_1_data': { 'shape': np.array([1, 3, 224, 224]) }, 'placeholder_2_data': { 'shape': np.array([1, 3, 224, 224]) }, 'gathernd_data': { 'shape': np.array([1, 3, 224, 224]) }, }) graph.graph['fw'] = 'tf' graph_ref = build_graph( nodes_attributes, [ ('placeholder_1', 'placeholder_1_data'), ('placeholder_2', 'placeholder_2_data'), ('placeholder_1_data', 'transpose_1'), ('axis_1_const', 'axis_1_const_data'), ('axis_1_const_data', 'transpose_1'), ('transpose_1', 'transpose_1_data'), ('placeholder_2_data', 'transpose_2'), ('axis_2_const', 'axis_2_const_data'), ('axis_2_const_data', 'transpose_2'), ('transpose_2', 'transpose_2_data'), ('transpose_1_data', 'gathernd'), ('transpose_2_data', 'gathernd'), ('gathernd', 'gathernd_data'), ('gathernd_data', 'transpose_3'), ('axis_3_const', 'axis_3_const_data'), ('axis_3_const_data', 'transpose_3'), ('transpose_3', 'transpose_3_data'), ('transpose_3_data', 'result'), ], { 'placeholder_1_data': { 'shape': np.array([1, 3, 224, 224]) }, 'placeholder_2_data': { 'shape': np.array([1, 3, 224, 224]) }, 'axis_1_const_data': { 'value': int64_array([0, 2, 3, 1]) }, 'axis_2_const_data': { 'value': int64_array([0, 2, 3, 1]) }, 'gathernd_data': { 'shape': np.array([1, 3, 224, 224]) }, 'axis_3_const_data': { 'value': int64_array([0, 3, 1, 2]) }, }) pattern = LayoutChangeForGatherND() pattern.find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'result', check_op_attrs=True) self.assertTrue(flag, resp)
def test_spatial_2d_split_concat_2(self): graph = build_graph(nodes_attrs=graph_node_attrs_for_2d_spatial_case, edges=graph_edges, update_attributes={ 'split': { 'type': 'Split', 'kind': 'op', 'op': 'Split', 'num_splits': 3 }, 'split_axis_const': { 'kind': 'op', 'value': np.array(2, dtype=np.int64), 'op': 'Const', 'type': 'Const' }, 'split_axis_const_data': { 'value': np.array(2, dtype=np.int64), 'shape': np.array(2, dtype=np.int64).shape, 'kind': 'data' }, 'concat': { 'type': 'Concat', 'kind': 'op', 'axis': 2 }, 'split_data_0': { 'value': None, 'shape': int64_array([1, 100, 40, 150]), 'kind': 'data' }, 'split_data_1': { 'value': None, 'shape': int64_array([1, 100, 40, 150]), 'kind': 'data' }, 'split_data_2': { 'value': None, 'shape': int64_array([1, 100, 40, 150]), 'kind': 'data' }, 'concat_data': { 'value': None, 'shape': int64_array([1, 100, 240, 150]), 'kind': 'data' }, 'abs_data': { 'value': None, 'shape': int64_array([1, 100, 240, 150]), 'kind': 'data' }, }) ref_graph = build_graph( nodes_attrs=ref_graph_node_attrs_for_2d_spatial_case_2, edges=ref_graph_edges_opset4, update_attributes={ 'axes': { 'shape': int64_array([1]), 'value': int64_array([2]) } }) SplitConcatPairToInterpolate().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, ref_graph, 'output') self.assertTrue(flag, resp)
def test_remove_memory(self): """Memory should be replaced by input and output""" graph = build_graph(nodes_attrs={ 'input': { 'kind': 'op' }, 'data_in': { 'kind': 'data', 'shape': None, 'value': None }, 'memory_in': { 'kind': 'op', 'op': 'Memory', 'index': 1, 'id': 'memory_', 'in_ports_count': 1 }, 'data_mem': { 'kind': 'data', 'shape': None, 'value': None }, 'concat': { 'kind': 'op', 'op': 'Concat', 'axis': 0 }, 'concat_data': { 'kind': 'data', 'shape': None, 'value': None }, 'some_op': { 'kind': 'op' }, 'some_op_data': { 'kind': 'data', 'shape': None, 'value': None }, 'memory_out': { 'kind': 'op', 'op': 'Memory', 'index': 0, 'id': 'memory_' }, 'data_mem_out': { 'kind': 'data', 'shape': None, 'value': None }, 'mem_out_result': { 'kind': 'op', 'op': 'Result' } }, edges=[('input', 'data_in'), ('memory_in', 'data_mem'), ('data_in', 'concat', { 'in': 0 }), ('data_mem', 'concat', { 'in': 1 }), ('concat', 'concat_data'), ('concat_data', 'some_op'), ('some_op', 'some_op_data'), ('some_op_data', 'memory_out'), ('memory_out', 'data_mem_out'), ('data_mem_out', 'mem_out_result')]) graph_ref = build_graph( nodes_attrs={ 'input': { 'kind': 'op' }, 'data_in': { 'kind': 'data', 'shape': None, 'value': None }, 'new_input': { 'kind': 'op', 'op': 'Parameter' }, 'new_in_data': { 'kind': 'data', 'shape': None, 'value': None }, 'concat': { 'kind': 'op', 'op': 'Concat', 'axis': 0 }, 'concat_data': { 'kind': 'data', 'shape': None, 'value': None }, 'some_op': { 'kind': 'op' }, 'some_op_data': { 'kind': 'data', 'shape': None, 'value': None }, 'crop': { 'kind': 'op', 'op': 'Crop', 'axis': np.array([0]) }, 'crop_data': { 'kind': 'data', 'shape': None, 'value': None }, 'mem_out_result': { 'kind': 'op', 'op': 'Result' }, }, edges=[('input', 'data_in'), ('new_input', 'new_in_data'), ('data_in', 'concat', { 'in': 0 }), ('new_in_data', 'concat', { 'in': 1 }), ('concat', 'concat_data'), ('concat_data', 'some_op'), ('some_op', 'some_op_data'), ('some_op_data', 'crop'), ('crop', 'crop_data'), ('crop_data', 'mem_out_result')], ) CutMemory().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, last_node='mem_out_result', check_op_attrs=True) self.assertTrue(flag, resp)
def test_memoryoffset_neg_0(self): graph = build_graph(self.nodes_attributes, [('in_placeholder', 'in_node'), ('in_node', 'memoryoffset'), ('memoryoffset', 'memoryoffset_data'), ('memoryoffset_data', 'opoutput'), ('memoryoffset_2', 'memoryoffset_2_data'), ('memoryoffset_2_data', 'out_placeholder'), ('in_node', 'out_placeholder')]) memoryoffset_node = Node(graph, 'memoryoffset') memoryoffset_node['t'] = -5 ReplaceMemoryOffsetNodePattern().find_and_replace_pattern(graph) ref_graph = build_graph( { 'in_placeholder': { 'kind': 'op', 'op': 'placeholder' }, 'in_node': { 'kind': 'data', 'shape': [1, 13] }, 'splice': { 'kind': 'op', 'op': 'Splice', 'context': range(-5, 1) }, 'splice_data': { 'kind': 'data', 'shape': [1, 78] }, 'crop': { 'kind': 'op', 'op': 'Crop', 'offset': 0, 'dim': 13 }, 'crop_input': { 'kind': 'op', 'op': 'Crop', 'offset': 65, 'dim': 13 }, 'crop_input_data': { 'kind': 'data', 'shape': [1, 13] }, 'memoryoffset_2_data': { 'kind': 'data', 'shape': [1, 13] }, 'out_placeholder': { 'kind': 'op', 'op': 'placeholder' }, }, [('in_placeholder', 'in_node'), ('in_node', 'splice'), ('splice', 'splice_data'), ('splice_data', 'crop'), ('crop', 'memoryoffset_2_data'), ('splice_data', 'crop_input'), ('crop_input', 'crop_input_data'), ('memoryoffset_2_data', 'out_placeholder'), ('crop_input_data', 'out_placeholder')]) (flag, resp) = compare_graphs(graph, ref_graph, 'out_placeholder') self.assertTrue(flag, resp)
def test1_not_constant(self): # # data1(1,3,64,64)----. data(1,3,64,64)-------. # data2(1,64,1)-------->Eltwise-->data(1,3,64,64) => data(1,64,1)->Reshape->data(1,1,64,1)-->Eltwise->... # data3(64,1)------' data(64,1)->Reshape->data(1,1,64,1)-' # graph = build_graph(nodes_attributes, [('placeholder_1', 'placeholder_1_data'), ('placeholder_1', 'placeholder_2_data'), ('placeholder_1', 'placeholder_3_data'), ('placeholder_1_data', 'eltwise_1'), ('placeholder_2_data', 'eltwise_1'), ('placeholder_3_data', 'eltwise_1'), ('eltwise_1', 'eltwise_1_data')], { 'placeholder_1_data': { 'shape': np.array([1, 3, 64, 64]) }, 'placeholder_2_data': { 'shape': np.array([1, 64, 1]) }, 'placeholder_3_data': { 'shape': np.array([64, 1]) }, 'eltwise_1_data': { 'shape': np.array([1, 3, 64, 64]) } }, nodes_with_edges_only=True) graph_ref = build_graph(nodes_attributes, [('placeholder_1', 'placeholder_1_data'), ('placeholder_1', 'placeholder_2_data'), ('placeholder_1', 'placeholder_3_data'), ('placeholder_1_data', 'eltwise_1'), ('placeholder_2_data', 'reshape_1'), ('reshape_1_const', 'reshape_1_const_data'), ('reshape_1_const_data', 'reshape_1'), ('placeholder_3_data', 'reshape_2'), ('reshape_2_const', 'reshape_2_const_data'), ('reshape_2_const_data', 'reshape_2'), ('reshape_1', 'reshape_1_data'), ('reshape_2', 'reshape_2_data'), ('reshape_1_data', 'eltwise_1'), ('reshape_2_data', 'eltwise_1'), ('eltwise_1', 'eltwise_1_data')], { 'placeholder_1_data': { 'shape': np.array([1, 3, 64, 64]) }, 'reshape_1_const': { 'value': int64_array([0]), 'shape': int64_array([1]) }, 'reshape_1_const_data': { 'value': int64_array([0]), 'shape': int64_array([1]) }, 'reshape_1_data': { 'shape': np.array([1, 1, 64, 1]) }, 'reshape_2_const': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_2_const_data': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_2_data': { 'shape': np.array([1, 1, 64, 1]) }, 'eltwise_1_data': { 'shape': np.array([1, 3, 64, 64]) } }, nodes_with_edges_only=True) normalize_eltwise_inputs(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'eltwise_1', check_op_attrs=True) self.assertTrue(flag, resp)
def test_quantize_uint8(self): graph = build_graph(nodes1_attributes, [ ('input', 'quantize'), ('scale_param_q', 'quantize'), ('zerop_param_q', 'quantize'), ('quantize', 'out'), ], { 'scale_param_q': { 'shape': np.array([]), 'value': np.float32(1.0 / 255) }, 'zerop_param_q': { 'shape': np.array([]), 'value': np.uint8(128) }, }, nodes_with_edges_only=True) graph_ref = build_graph(nodes_ref_attributes, [ ('input', 'f_quantize'), ('scale_param_q', 'mul1', { 'out': 0 }), ('in_low', 'mul1'), ('mul1', 'f_quantize'), ('scale_param_q', 'mul2', { 'out': 0 }), ('in_high', 'mul2'), ('mul2', 'f_quantize'), ('out_low', 'f_quantize'), ('out_high', 'f_quantize'), ('f_quantize', 'cast'), ('cast', 'out'), ], { 'in_low': { 'shape': np.array([]), 'value': -128 }, 'in_high': { 'shape': np.array([]), 'value': 127 }, 'out_low': { 'shape': np.array([]), 'value': 0 }, 'out_high': { 'shape': np.array([]), 'value': 255 }, 'cast': { 'dst_type': np.uint8 } }, nodes_with_edges_only=True) graph.stage = 'front' QuantizeLinearResolver().find_and_replace_pattern(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'out', check_op_attrs=True) self.assertTrue(flag, resp)
def test4_constant(self): # ,--------------->consumer3 ,------------>consumer3 # data---(new_shape1)-->consumer1 => data--->reshape1-->consumer1 # `-(new_shape2)-->consumer2 `->reshape2-->consumer2 # graph = build_graph(nodes_attributes, [ ('placeholder_1', 'placeholder_1_data'), ('placeholder_1_data', 'eltwise_1'), ('placeholder_1_data', 'eltwise_2'), ('placeholder_1_data', 'eltwise_3'), ('eltwise_1', 'eltwise_1_data'), ('eltwise_2', 'eltwise_2_data'), ('eltwise_3', 'eltwise_3_data'), ('eltwise_1_data', 'concat'), ('eltwise_2_data', 'concat'), ('eltwise_3_data', 'concat'), ], { 'placeholder_1_data': { 'shape': int64_array([1, 3]), 'value': np.ones([1, 3]) }, 'eltwise_1_data': { 'shape': int64_array([1, 1, 1, 3]) }, 'eltwise_2_data': { 'shape': int64_array([1, 1, 3]) }, 'eltwise_3_data': { 'shape': int64_array([1, 3]) }, }, nodes_with_edges_only=True) graph_ref = build_graph(nodes_attributes, [ ('placeholder_1', 'placeholder_1_data'), ('placeholder_1_data', 'reshape_1'), ('reshape_1_const', 'reshape_1_const_data'), ('reshape_1_const_data', 'reshape_1'), ('reshape_1', 'reshape_1_data'), ('reshape_1_data', 'eltwise_1'), ('placeholder_1_data', 'reshape_2'), ('reshape_2_const', 'reshape_2_const_data'), ('reshape_2_const_data', 'reshape_2'), ('reshape_2', 'reshape_2_data'), ('reshape_2_data', 'eltwise_2'), ('placeholder_1_data', 'eltwise_3'), ('eltwise_1', 'eltwise_1_data'), ('eltwise_2', 'eltwise_2_data'), ('eltwise_3', 'eltwise_3_data'), ('eltwise_1_data', 'concat'), ('eltwise_2_data', 'concat'), ('eltwise_3_data', 'concat'), ], { 'placeholder_1_data': { 'shape': int64_array([1, 3]), 'value': np.ones([1, 3]) }, 'reshape_1_const': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_1_const_data': { 'value': int64_array([0, 1]), 'shape': int64_array([2]) }, 'reshape_1_data': { 'shape': int64_array([1, 1, 1, 3]) }, 'reshape_2_const': { 'value': int64_array([0]), 'shape': int64_array([1]) }, 'reshape_2_const_data': { 'value': int64_array([0]), 'shape': int64_array([1]) }, 'reshape_2_data': { 'shape': int64_array([1, 1, 3]) }, }, nodes_with_edges_only=True) normalize_eltwise_inputs(graph) (flag, resp) = compare_graphs(graph, graph_ref, 'concat', check_op_attrs=True) self.assertTrue(flag, resp)
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)