Class GraphPattern

ppq/IR/search.py:166–276

class GraphPattern():

    def __init__(self, node_patterns: List[Callable], edges: List[List[int]]) -> None:
        """Pattern Tree 是一个用来表示图模式的结构体 这将在图中检索任意一个子图.

        你将使用 Graph Pattern 定义你的子图结构
        使用 patterns 确定每一个节点需要满足的条件
        使用 edges 将节点们彼此相连从而构成图结构
        
        构成的图必须可以进行拓扑排序，不可以检索有环结构，不可以检索不连通结构
        例子：
            pattern = ['Conv', 'Conv', 'Conv'],
            edges = [[0, 1], [1, 2], [0, 2]]

        描述了一个类似这样的树形结构:
        
            Conv -+- Conv -+- Conv
                  |        |
                  ----------

        第二个例子:
        pt = PatternTree(
                patterns = [lambda x: x.is_computing_op, 'Softplus', 'Tanh', 'Mul']
                edges = [[0, 1], [1, 2], [2, 3], [0, 3]])

            pt create an abstract tree pattern of:
                                            --- 'Softplus'   ---   'Tanh' --
            lambda x: x.is_computing_op --- +                              + --- 'Mul'
                                            ---     ---     ---    ---    --

        错误的例子:
            pattern = ['Conv', 'Conv', 'Conv'],
            edges = [[0, 1], [1, 2], [2, 0]]
        因为图中存在循环结构而无法检索
        """
        for idx, node_pattern in enumerate(node_patterns):
            if isinstance(node_pattern, str):
                node_patterns[idx] = TypeExpr(node_pattern)
            elif not isinstance(node_pattern, Callable):
                raise TypeError(f'Can not create Pattern with node pattern {str(node_pattern)} it is not callable.')

        for edge in edges:
            if not isinstance(edge, tuple) and not isinstance(edge, list):
                raise TypeError(f'Can not create Pattern with edge {str(edge)} it is not tuple or list.')
            if len(edge) != 2:
                raise ValueError(f'Can not create Pattern with edge {str(edge)} '
                                 f'it should contains exact 2 elements, however {len(edge)} was given.')
            sp, ep = edge
            if not isinstance(sp, int) or not isinstance(ep, int):
                raise TypeError(f'Can not create Pattern was given edge {[str(sp), str(ep)]}, '
                                'expect int value here.')
        
        self.order, self.output_table, self.input_table = self.compile(node_patterns=node_patterns, edges=edges)
        self.argsort_order = sorted([(_, idx) for idx, _ in enumerate(self.order)])
        self.argsort_order = [idx for _, idx in self.argsort_order]
        self.node_patterns = node_patterns