[Bugfix] Support tree-like subgraph matching

[chhzh123]

Description

For the following tree-like subgraph with multiple inputs, if we use the pattern to match the +, -, and * operators, only + and * will be returned. This is because the current implementation of subgraph matching starts from the first instruction of the original subgraph and target subgraph, and test if users of the instruction are the same. The process is iterative and basically is a DFS. However, this process may ignore instruction b since b is not the user of a.

class Model(nn.Module):
    def forward(self, x, y, z):
        a = x + y
        b = y - z
        c = a * b
        return c

def pattern(x, y, z):
    return (x + y) * (y - z)

To solve this problem, we can simply traverse the graph node from top to bottom following the order of the link list (i.e., visiting the successors in a topological order), and compare the nodes in the original and target subgraph, so that all the +, -, and * operators will be matched. Notice this fix still cannot support commutativity between operands, so pattern (y - z) * (x + y) cannot match any subgraphs. This feature may need more engineering efforts in the future.

Also, this PR adds concrete_args to .replace_module() for the case that the user-defined module has different numbers of arguments with the arguments in the original subgraph.

Checklist

• PR's title starts with a category (e.g. [Bugfix], [Model], [Tutorial], etc)
• Changes are complete (i.e. I finished coding on this PR)
• All changes have test coverage
• Code is well-documented

[comaniac]

LGTM

[chhzh123]

Thanks @comaniac