Exemple #1
0
    def test_case2(self):
        graph = build_graph(
            nodes, [('Parameter1', 'Op1'),
                    ('Op1', 'FakeOutput1', {
                        'in': 1,
                        'out': 1,
                        'fw_tensor_debug_info': [('Op1', 'Op1_tensor_name')]
                    }), ('Parameter1', 'Op2'),
                    ('Op2', 'FakeOutput2', {
                        'in': 2,
                        'out': 3,
                        'fw_tensor_debug_info': [('Op2', 'Op2_tensor_name')]
                    })])
        graph.graph['packed_outputs'] = None
        graph.graph['user_shapes'] = None

        graph.stage = 'front'
        OutputCut().find_and_replace_pattern(graph)

        op1 = Node(graph, 'Op1')
        op2 = Node(graph, 'Op2')
        self.assertTrue(op1.out_node(1)['type'] == 'Result')
        self.assertTrue(op2.out_node(3)['type'] == 'Result')
        self.assertTrue(
            op1.out_edge(1)['fw_tensor_debug_info'] == [('Op1',
                                                         'Op1_tensor_name')])
        self.assertTrue(
            op2.out_edge(3)['fw_tensor_debug_info'] == [('Op2',
                                                         'Op2_tensor_name')])
        self.assertTrue(graph.get_op_nodes(name='FakeOutput1') == [])
        self.assertTrue(graph.get_op_nodes(name='FakeOutput2') == [])
Exemple #2
0
    def find_and_replace_pattern(self, graph: Graph):
        graph.stage = 'front'
        for node_id in graph.nodes(data=False):
            node = Node(graph, node_id)
            inputs = node.get_sorted_inputs()
            outputs = node.get_sorted_outputs()

            in_ports_count = node.in_ports_count if node.has_valid(
                'in_ports_count') else len(inputs)
            out_ports_count = node.out_ports_count if node.has_valid(
                'out_ports_count') else len(outputs)

            if len(outputs) > out_ports_count > 1:
                raise Error("Node {} has more children than it should: " +
                            "should be {} but there is {}".format(
                                node_id, out_ports_count, len(outputs)))

            node['_in_ports'] = {}
            node['_out_ports'] = {}
            if in_ports_count is not None:
                for idx in range(in_ports_count):
                    node.add_input_port(idx=idx)

            if out_ports_count is not None:
                for idx in range(out_ports_count):
                    node.add_output_port(idx=idx)
            idx = 0
            for in_node_id, edge_attrs in inputs:
                graph.remove_edge(in_node_id, node_id)
                if len(Node(graph, in_node_id).out_ports()) == 0:
                    Node(graph, in_node_id).add_output_port(0)
                in_node = Node(graph, in_node_id)
                in_node.out_port(edge_attrs['out']).connect(node.in_port(idx))
                # need to keep this attribute in edge for correct .mapping file generation and
                # for generation of "names" field in IR
                in_node.out_edge(
                    edge_attrs['out']
                )['fw_tensor_debug_info'] = edge_attrs['fw_tensor_debug_info']
                if idx < in_ports_count - 1:
                    idx = idx + 1

            idx = 0
            for out_node_id, edge_attrs in outputs:
                graph.remove_edge(node_id, out_node_id)
                if len(Node(graph, out_node_id).in_ports()) == 0:
                    Node(graph, out_node_id).add_input_port(0)
                node.out_port(idx).connect(
                    Node(graph, out_node_id).in_port(edge_attrs['in']))
                # need to keep this attribute in edge for correct .mapping file generation and
                # for generation of "names" field in IR
                node.out_edge(idx)['fw_tensor_debug_info'] = edge_attrs[
                    'fw_tensor_debug_info']
                if idx < out_ports_count - 1:
                    idx = idx + 1
Exemple #3
0
    def test_create_node(self):
        graph = build_graph(nodes, [('Op1', 'Op3', {'in': 0, 'out': 0, 'fw_tensor_debug_info': [('Op1', 'Op1')]}),
                                    ('Op2', 'Op3', {'in': 1, 'out': 0, 'fw_tensor_debug_info': [('Op2', 'Op2')]})])
        graph.stage = 'front'
        input1 = Node(graph, 'Op1')
        input2 = Node(graph, 'Op2')
        inputs = [(input1, 0), (input2, 0)]

        lstm_op = LSTMCell(graph, dict(name='LSTMCell'))
        _ = lstm_op.create_node(inputs)

        self.assertTrue(input1.out_edge(0)['fw_tensor_debug_info'] == [('Op1', 'Op1')])
        self.assertTrue(input2.out_edge(0)['fw_tensor_debug_info'] == [('Op2', 'Op2')])
Exemple #4
0
    def create_graph():
        sub_graph_2 = build_graph(nodes_attrs=ti_sub_graph_2_nodes,
                                  edges=[
                                      *connect('cond_2_int', 'cond_2_int_out'),
                                      *connect('in_2_int', 'OUT_2'),
                                      *connect('ones', 'OUT_2'),
                                      *connect('OUT_2', 'OUT_2_out'),
                                      *connect('in_2_int', 'in_2_int_out')
                                  ],
                                  nodes_with_edges_only=True)

        sub_graph_1 = build_graph(nodes_attrs=ti_sub_graph_1_nodes,
                                  edges=[
                                      *connect('cond_2', '1:Loop_2'),
                                      *connect('IN_2', '0:Loop_2'),
                                      *connect('Loop_2:0', 'Loop_2_out'),
                                      *connect('in_1_int', 'in_1_int_out'),
                                      *connect('cond_1_int', 'cond_1_int_out')
                                  ],
                                  nodes_with_edges_only=True)
        loop_node_1 = Node(sub_graph_1, 'Loop_2')
        loop_node_1.body = sub_graph_2
        loop_node_1.in_edge(0)['external_port_id'] = 0
        loop_node_1.in_edge(1)['external_port_id'] = 1
        loop_node_1.out_edge(0)['external_port_id'] = 2

        main_graph = ti_create_main_graph(sub_graph_1)
        main_graph.graph['additional_outputs'] = ['Loop', 'Loop_2']

        return main_graph, sub_graph_1
    def test_case1(self):
        graph = build_graph(nodes, [('Parameter1', 'FakeOutput1',
                                     {'in': 0, 'out': 0, 'fw_tensor_debug_info':
                                         [('Parameter1', 'Parameter1_tensor_name')]})])
        graph.graph['packed_outputs'] = None
        graph.graph['user_shapes'] = None

        graph.stage = 'front'
        OutputCut().find_and_replace_pattern(graph)

        param1 = Node(graph, 'Parameter1')
        self.assertTrue(param1.out_node()['type'] == 'Result')
        self.assertTrue(param1.out_edge()['fw_tensor_debug_info'] == [('Parameter1', 'Parameter1_tensor_name')])
        self.assertTrue(graph.get_op_nodes(name='FakeOutput1') == [])
Exemple #6
0
def ti_create_main_graph(body):
    main_graph = build_graph(nodes_attrs=ti_main_graph_nodes,
                             edges=[
                                 *connect('M', '0:Loop'),
                                 *connect('cond', '1:Loop'),
                                 *connect('IN_2', '2:Loop'),
                                 *connect('IN_1', "3:Loop"),
                                 *connect('Loop:0', 'OUT_1')
                             ],
                             nodes_with_edges_only=True)
    loop_node = Node(main_graph, 'Loop')
    loop_node.body = body
    loop_node.in_edge(0)['external_port_id'] = 0
    loop_node.in_edge(1)['external_port_id'] = 1
    loop_node.in_edge(2)['external_port_id'] = 2
    loop_node.in_edge(3)['external_port_id'] = 3
    loop_node.out_edge(0)['external_port_id'] = 4

    return main_graph
    def test_global_pooling_to_reduce(self):
        graph = build_graph_with_edge_attrs(nodes, edges)

        graph_ref = build_graph(nodes, ref_edges)
        graph.stage = 'front'
        graph.graph['layout'] = 'NCHW'
        node = Node(graph, 'relu')
        node.out_edge(0)['fw_tensor_debug_info'] = [('Relu_0', 'Relu_tensor')]

        GlobalPoolingToReduce().find_and_replace_pattern(graph)
        graph.clean_up()

        (flag, resp) = compare_graphs(graph, graph_ref, 'result')
        self.assertTrue(flag, resp)

        node = Node(graph, 'relu')
        edge_attrs = node.out_port(0).get_destinations()[0].get_in_edge_attrs()
        self.assertTrue('fw_tensor_debug_info' in edge_attrs)
        self.assertTrue(
            edge_attrs['fw_tensor_debug_info'] == [('Relu_0', 'Relu_tensor')])
Exemple #8
0
 def create_node_on_port(self,
                         node: Node,
                         out_port: int,
                         attrs: dict = None,
                         edge_attrs: dict = None):
     """
     Removes an edge, that is connected to nodes out_port. Creates new_node with attrs attributes and
     connects it to node by edge that stores the same information as cutted edge.
     :param node: Input node, to cut the edge from
     :param out_port: output port of edge to cut
     :param attrs: attributes of new node
     :param edge_attrs: attributes to be changed/added to new edge
     :return: Node instance of created new_node
     """
     if edge_attrs is None:
         edge_attrs = {'in': 0}
     prev_edge_attrs = copy.deepcopy(node.out_edge(out_port))
     prev_edge_attrs.update(edge_attrs)
     new_edge_attrs = prev_edge_attrs
     if attrs is None:
         attrs = dict()
     new_node = self.add_node(attrs)
     self.graph.add_edge(node.id, new_node.id, **new_edge_attrs)
     return new_node
Exemple #9
0
def get_node_top(graph: Graph, name: str):
    node = Node(graph, name)
    return node.out_edge()['name'] if node else None