onnx_graphsurgeon.GraphPattern()：The order in which the nodes are added affects the success of the match.

[peanutPod]

`

def get_plugin_pattern(self):

    pattern = gs.GraphPattern()
    input0=pattern.variable()
    

    def check_clip_node(node):
        if "min" in node.attrs or "max" in node.attrs:
            return True
        if len(node.inputs) >1:
            return True
        return False

    clip01_min=pattern.constant()
    clip01_max=pattern.variable()
    clip01=pattern.add(
        "clip01",
        op="Clip",
        inputs=[input0,clip01_min,clip01_max],
        check_func=check_clip_node,
        num_output_tensors=1)
    
    clip02_min=pattern.variable()
    clip02_max=pattern.constant()
    clip02=pattern.add(
        "clip02",
        op="Clip",
        inputs=[clip01,clip02_min,clip02_max],
        check_func=check_clip_node,
        num_output_tensors=1)
    
    clip04_min=pattern.constant()
    clip04_max=pattern.variable()
    clip04=pattern.add(
        "clip04",
        op="Clip",
        inputs=[clip02,clip04_min,clip04_max],
        check_func=check_clip_node,
        num_output_tensors=1)
    
    sub01_constant=pattern.constant()
    sub01=pattern.add(
        "sub01",
        op="Sub",
        inputs=[sub01_constant,clip02])
    
    clip03_min=pattern.constant()
    clip03_max=pattern.variable()
    clip03=pattern.add(
        "clip03",
        op="Clip",
        inputs=[sub01,clip03_min,clip03_max],
        check_func=check_clip_node,
        num_output_tensors=1)
    
    # clip04_min=pattern.constant()  #Putting the pattern here will match fail
    # clip04_max=pattern.variable()
    # clip04=pattern.add(
    #     "clip04",
    #     op="Clip",
    #     inputs=[clip02,clip04_min,clip04_max],
    #     check_func=check_clip_node,
    #     num_output_tensors=1)

    
    div01=pattern.add(
        "div01",
        op="Div",
        inputs=[clip04,clip03])
    
    log01=pattern.add(
        "log01",
        op="Log",
        inputs=[div01])        

    pattern.set_output_tensors([log01])

    return pattern`

if I move "clip04" to # clip04_min,I can not find pattern,else i will find pattern,who can tell me why?

onnx graph:

[somtri]

The behaviour here has changed since this was filed. On current versions it no longer depends on order: the pattern never matches at all.

I rebuilt a graph with the same shape and ran the pattern above in all four combinations of pattern add order and graph consumer order:

• 0.5.5 and 0.5.8: it matches only when the pattern adds clip04 and sub01 in the same order as clip02's consumers appear in the graph. That is the order dependence reported here.
• 0.6.1 (latest on PyPI) and main (0.6.2): 0 matches in all four.

It is not specific to this pattern. A diamond inside the pattern is enough:

import numpy as np
import onnx_graphsurgeon as gs

# Graph: x -> Relu -> (Neg, Abs) -> Add -> y
x = gs.Variable("x", dtype=np.float32, shape=(1, 4))
t = gs.Variable("t", dtype=np.float32)
a = gs.Variable("a", dtype=np.float32)
b = gs.Variable("b", dtype=np.float32)
y = gs.Variable("y", dtype=np.float32)
graph = gs.Graph(
    nodes=[
        gs.Node("Relu", "relu", inputs=[x], outputs=[t]),
        gs.Node("Neg", "neg", inputs=[t], outputs=[a]),
        gs.Node("Abs", "abs", inputs=[t], outputs=[b]),
        gs.Node("Add", "add", inputs=[a, b], outputs=[y]),
    ],
    inputs=[x],
    outputs=[y],
)

# The same shape as a pattern.
pattern = gs.GraphPattern()
inp = pattern.variable()
relu = pattern.add("relu", "Relu", inputs=[inp])
neg = pattern.add("neg", "Neg", inputs=[relu])
abs_ = pattern.add("abs", "Abs", inputs=[relu])
add = pattern.add("add", "Add", inputs=[neg, abs_])
pattern.set_output_tensors([add])

print("matches:", len(pattern.match_all(graph)))

This prints matches: 1 on 0.5.8 and matches: 0 on 0.6.1 and main. 0.5.8 and 0.6.1 disagree under the same onnx 1.17.0, so it is not an onnx change.

The cause is in onnx_graphsurgeon/graph_pattern/graph_pattern.py, lines 578-581 on main. After the consumers of an intermediate tensor are matched, that check rejects the match if any ONNX consumer is missing from used_candidate_ids. The loop above it skips a consumer that is already in mapping without adding it to that set. In a diamond, the second branch gets mapped while the matcher walks back from the node where the branches meet, so it is skipped and the match is rejected as if it had an extra external consumer.

It broke somewhere between 0.5.8 and 0.6.1. Two changelog entries in that range are about pattern matching: 0.5.9 (false positives with extra external consumers) and 0.6.1 (removed deep copies in GraphPattern). 0.5.9 and 0.6.0 are not on PyPI, so I could not narrow it further.

Counting the already-mapped consumers before that check fixes it in a local copy. The snippet gives 1, the pattern above matches in all four orders, and tests/test_graph_pattern.py still passes (10 tests). A PR would add a test for the diamond, plus one where a real extra consumer on a tensor inside a diamond is still rejected, so the 0.5.9 fix keeps working.

Is this a fix you would take? If you would rather record consumers at the point where they get mapped, I can do it that way instead.