Update optimizer opset version checks for latest ONNX opset 26

[yuslepukhin]

This pull request expands support for additional ONNX opset versions in the attention fusion optimization code, making the optimizer compatible with newer and more diverse ONNX models. The changes primarily update the accepted opset versions for various operators such as Transpose, Reshape, Squeeze, Unsqueeze, Shape, and others across multiple functions. This ensures broader model compatibility and improves the robustness of the fusion logic.

Expanded opset version support for attention fusion:

• Updated accepted opset versions for key operators (Transpose, Reshape, Squeeze, Unsqueeze, Shape, Add, Mul, Sub, Div, Cast, etc.) in the main attention fusion logic (attention_fusion.cc), allowing matching and fusion of newer ONNX models using these operators at opsets up to 25. [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12]

Helper and mask subgraph matching improvements:

• Broadened opset version checks for subgraph matching in helper functions, including those for Gemm subgraphs, unidirectional mask subgraphs, input mask subgraphs, and past subgraph matching, to support additional opset versions and operator variants. [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11]

These changes collectively future-proof the attention fusion optimizer for a wider range of ONNX models and operator versions, reducing the likelihood of unsupported patterns during optimization.

[Copilot]

Pull request overview

This PR expands ONNX Runtime optimizer pattern matching and unit tests to recognize newer ONNX operator schema versions (opset 23–25), aiming to keep attention fusions and reshape fusion behavior compatible with opset 25 models.

Changes:

• Broadened supported operator-version allowlists in optimizer fusions (e.g., Transpose/Reshape/Squeeze/Unsqueeze/Shape) to include newer schema versions up to opset 25.
• Added opset 25 coverage for MobileCLIP attention fusion and GroupQueryAttentionPreNorm fusion unit tests.
• Extended ReshapeFusionOpsetTest to iterate additional opsets (19/21/23/24/25).

Reviewed changes

Copilot reviewed 6 out of 6 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
onnxruntime/core/optimizer/attention_fusion.cc	Updates MobileCLIP attention fusion pattern version checks for newer ONNX schemas.
onnxruntime/core/optimizer/attention_fusion_helper.h	Extends supported Transpose versions in GPT attention helper logic.
onnxruntime/core/optimizer/group_query_attention_pre_norm_fusion.cc	Expands supported Reshape versions in the GQA pre-norm fusion matcher.
onnxruntime/core/optimizer/reshape_fusion.cc	Updates Shape/Unsqueeze schema version handling in reshape fusion logic.
onnxruntime/test/optimizer/graph_transform_test.cc	Adds opset coverage (incl. 25) for attention and reshape fusion tests.
onnxruntime/test/optimizer/group_query_attention_pre_norm_fusion_test.cc	Adds opset 25 test for Qwen GQA pre-norm fusion.

Comments suppressed due to low confidence (1)

onnxruntime/test/optimizer/graph_transform_test.cc:8241

• ReshapeFusionOpsetTest now iterates opsets 19/21/23/24/25, but the shape_test_for_opset15 flag is mutated inside build_test_case and then reused across iterations. After the first opset>=15 run, subsequent iterations build a Shape with start=1,end=2 and also switch to the (pre,pre) checker branch, so the newly added opsets are not actually validating the fusion path this test is meant to cover.

  const std::vector<int> opsets{11, 12, 13, 14, 15, 18, 19, 21, 23, 24, 25};
  bool shape_test_for_opset15 = false;

  for (auto& opset : opsets) {
    auto build_test_case = [&](ModelTestBuilder& builder) {

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 4 comments.

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated 2 comments.

Comments suppressed due to low confidence (1)

onnxruntime/core/optimizer/reshape_fusion.cc:181

• The Shape(start/end) guard rejects any explicit end attribute, even if it is set to the default "no slicing" value (e.g., INT64_MAX). That can unnecessarily block reshape-fusion for graphs that redundantly set end to the default. Consider treating an end attribute with a very large value (i.e., equivalent to full-shape) as acceptable, and only rejecting when start/end imply an actual slice.

    // Opset 15+ added start/end attributes to Shape. Reject partial-shape queries.
    if (shape.SinceVersion() >= 15) {
      const ONNX_NAMESPACE::AttributeProto* start_attr = graph_utils::GetNodeAttribute(shape, "start");
      const ONNX_NAMESPACE::AttributeProto* end_attr = graph_utils::GetNodeAttribute(shape, "end");
      if (!((!start_attr || static_cast<int>(start_attr->i()) == 0) && (!end_attr))) {
        return false;
      }

[hariharans29]

Verdict: Approve, but attention_fusion_helper.h has an internal inconsistency worth fixing before merge

The mechanical opset-list expansions are fine, and two of the changes are actually meaningful correctness fixes hiding inside the "version bump" framing. One change in attention_fusion_helper.h is half-done in a way that defeats its own purpose — Copilot's second comment is accurate and worth acting on.

---

The two real fixes hiding in here

1. Shape SinceVersion check in reshape_fusion.cc — correctness fix

Pre-PR:

if (graph_utils::MatchesOpSinceVersion(shape, {15})) {
  // check start/end attributes that, if set, would block fusion
  ...
}

MatchesOpSinceVersion(shape, {15}) returns true only when shape.SinceVersion() == 15. For a model at opset 19 or 21 (where Shape has SinceVersion 19/21 respectively), this returned false, skipped the start/end attribute check, and would fuse a partial-Shape pattern that should not be fused. This is a latent correctness bug being silently fixed.

Post-PR:

if (shape.SinceVersion() >= 15) { ... }

is the right shape — once the schema added the attribute, every later version inherits it. This deserves a callout in the PR description because the framing "extend opset version checks" undersells it; "fix partial-Shape detection on opset ≥ 19" would be more accurate.

The test side does pick this up — ReshapeFusionOpsetTest was previously contorted into a one-shot state machine (shape_test_for_opset15) so that the partial-shape path ran exactly once across all opsets, and the new test now runs the partial-shape negative case for every opset ≥ 15. That's the right refactor.

2. Unsqueeze axes-from-input in reshape_fusion.cc — same class of fix

Pre-PR:

} else if (graph_utils::MatchesOpSinceVersion(unsqueeze, {13})) {
  const NodeArg* axes_node_arg = unsqueeze.InputDefs()[1];
  ...
}

Same issue: only matched SinceVersion() == 13. For opset 21+ where Unsqueeze has SinceVersion 21 (or whichever version it was bumped to), this returned false → reshape fusion failed silently on those models. The new structural check InputDefs().size() > 1 fixes it.

Copilot suggested gating on SinceVersion() >= 13 instead. Two reasonable opinions:

• Pro SinceVersion() >= 13: schema-aligned, matches the comment, defends against a hypothetical malformed Unsqueeze that has the wrong arity for its version.
• Pro InputDefs().size() > 1: future-proof against any later opset bump (no need to revisit), and the "malformed Unsqueeze with wrong arity" case would fail schema validation before reaching this code anyway.

I'd take the structural check as you have it. The defensiveness Copilot is asking for is downstream of schema validation, and you'd otherwise need to update this site on every Unsqueeze bump going forward. Author's call — not blocking either way.

---

The one thing worth addressing before merge

FuseGptAttention in attention_fusion_helper.h is internally inconsistent

The PR updates one line in this function:

// line 1450
if (graph_utils::IsSupportedOptypeVersionAndDomain(*k_concat, "Transpose",
                                                   {1, 13, 21, 23, 24, 25}, kOnnxDomain)) {
  transpose_optimized_pattern = true;
  ...
}

But everything downstream of that gate is still locked to the old opsets:

// ~line 1468
if (!graph_utils::IsSupportedOptypeVersionAndDomain(*k_concat, "Concat",
                                                    {4, 11, 13}, kOnnxDomain)) {
  return false;
}

// ~line 1474
std::vector<graph_utils::EdgeEndToMatch> k_path{
    {0, 1, "Transpose", {1, 13},     kOnnxDomain},
    {0, 0, "Reshape",   {5, 13},     kOnnxDomain},
    {1, 0, "Split",     {2, 11, 13}, kOnnxDomain}};

Consequence: on an opset 23/24/25 GPT model the precheck succeeds, then FindPath fails because the Transpose has SinceVersion 21 (or whichever) and isn't in {1, 13}. Net result of the one-line change in this function: nothing. Either:

• (a) Update the q/k/v path matchers, Reshape {5, 13} → {5, 13, 14, 19, 21, 23}, Split {2, 11, 13} → {2, 11, 13, 18, ...}, Concat {4, 11, 13} → matching set, and the inner Transpose {1, 13} → {1, 13, 21, 23, 24, 25} — consistent with the stated PR intent. Plus an opset-25 test for the GPT path the same way you did for MobileCLIP and the GQA pre-norm fusion.
• (b) Or revert the line 1450 change and explicitly scope the PR to "opset 25 for MobileCLIP / GQA pre-norm / reshape fusion" only, since FuseGptAttention won't actually work end-to-end at opset 25 without the rest.

Either is fine. The current state is the one option that doesn't make sense.

Copilot's second comment captured this. Acting on it would close the gap.

---

Pattern-level observations on the version list extensions

Adding 24 and 25 to every list

Reshape {5, 13, 14, 19, 21, 23, 24, 25}, Transpose {1, 13, 21, 23, 24, 25}, etc.

IsSupportedOptypeVersionAndDomain checks SinceVersion(), which is the version the operator's schema was last changed, not the model's opset. So the entries that actually do anything are the versions where the operator was bumped. If Reshape was last bumped at v23, then {24, 25} in its list are no-ops (a model declared at opset 25 will still report Reshape.SinceVersion() == 23).

This is harmless future-proofing, and consistent with how similar extensions have been done in the repo before — I'd just flag in the PR description what was actually bumped at 24/25 vs. what was added defensively. Helps the next person doing the same exercise understand which entries are load-bearing.

Hot-spot to harmonize as follow-up (out of scope here)

This file (attention_fusion.cc) has the same set of operator version lists repeated 9 times for Reshape and 6 times for Transpose. Every opset bump now triggers a search-and-replace across the file, with the FuseGptAttention mistake above being a natural consequence. A small refactor into named constants (kReshapeOpsetVersions, kTransposeOpsetVersions) would have made this PR a 4-line change and made the next one trivial. Not for this PR — file as a cleanup.

---

Tests look right

• AttentionFusionMobileClipMhaOpset25Test is the parallel form of the existing AttentionFusionMobileClipMhaTest (opset 14 → 25), reusing the same helper and checker. Minimal and correct.
• GroupQueryAttentionPreNormFusionFusesQwenPatternOpset25 likewise parallels the existing test.
• ReshapeFusionOpsetTest refactor (drop the state machine, run the positive case always and the partial-Shape negative case for every opset ≥ 15) is cleaner and increases coverage. Good.

One small note: ReshapeFusionOpsetTest now iterates {11, 12, 13, 14, 15, 18, 19, 21, 23, 24, 25} but skips 16, 17, 20, 22. If those gaps are intentional (Reshape unchanged at those opsets so they collapse to the previous SinceVersion), fine. If not, adding them is one character each. Minor.

---

Bottom line

The two reshape_fusion.cc corrections are nice quiet wins. The mechanical version-list extensions in attention_fusion.cc are fine. The attention_fusion_helper.h change is currently a no-op due to the unchanged downstream matchers — either complete it (preferred, with a matching test) or drop it. Recommend addressing that one point and then this is good to land.

[Copilot]

Pull request overview

Copilot reviewed 8 out of 8 changed files in this pull request and generated 2 comments.

[Copilot]

Pull request overview

Copilot reviewed 8 out of 8 changed files in this pull request and generated 5 comments.

[Copilot]

Pull request overview

Copilot reviewed 8 out of 8 changed files in this pull request and generated 3 comments.

Comments suppressed due to low confidence (1)

onnxruntime/core/optimizer/reshape_fusion.cc:181

• The new Shape start/end-attribute guard rejects any node that has an "end" attribute, even when end is the default full-range value. ORT’s Shape kernel treats end==std::numeric_limits<int64_t>::max() as the default (full shape), so this check can incorrectly block ReshapeFusion matching for models/exporters that explicitly set end to INT64_MAX.

    // Opset 15+ added start/end attributes to Shape. Reject partial-shape queries.
    if (shape.SinceVersion() >= 15) {
      const ONNX_NAMESPACE::AttributeProto* start_attr = graph_utils::GetNodeAttribute(shape, "start");
      const ONNX_NAMESPACE::AttributeProto* end_attr = graph_utils::GetNodeAttribute(shape, "end");
      if (!((!start_attr || static_cast<int>(start_attr->i()) == 0) && (!end_attr))) {
        return false;
      }

[hariharans29]

Verdict: Approve

Five new commits since the prior review. The substantive concern (FuseGptAttention internal inconsistency) is fixed, and the PR has grown two additional correctness fixes and a genuinely useful piece of test infrastructure. Ready to land.

---

Prior observations — status

1. FuseGptAttention precheck-vs-matcher gap — fixed

All three path matchers in attention_fusion_helper.h::FuseGptAttention are now extended to match the precheck:

// path1 (line ~1357)
{0, 0, "Reshape",   {5, 13, 14, 19, 21, 23, 24, 25}, kOnnxDomain},
{0, 0, "Transpose", {1, 13, 21, 23, 24, 25},         kOnnxDomain},
{0, 0, "MatMul",    {1, 9, 13},                       kOnnxDomain}};

// path2 (line ~1379) and q_path (line ~1431)
{2, 0, "Split", {2, 11, 13, 18}, kOnnxDomain}

// k_path (line ~1489)
{0, 1, "Transpose", {1, 13, 21, 23, 24, 25},         kOnnxDomain},
{0, 0, "Reshape",   {5, 13, 14, 19, 21, 23, 24, 25}, kOnnxDomain},
{1, 0, "Split",     {2, 11, 13, 18},                  kOnnxDomain}};

End-to-end coherent now. Bonus: Split {2, 11, 13, 18} also picks up the Split-18 bump (the num_outputs attribute change) that I flagged as a possible gap in the prior review.

2. GetAxesFromUnsqueezeNode — gating choice

reshape_fusion.cc still uses InputDefs().size() > 1. Fine — that was author's call and both forms are defensible. Not blocking.

3. Shape (!end_attr) guard — fixed and tightened

The original guard at reshape_fusion.cc:175 was:

if (!((!start_attr || static_cast<int>(start_attr->i()) == 0) && (!end_attr))) { ... }

which rejected any model that explicitly set end = INT64_MAX (the documented default) — a false negative for legitimate full-shape calls. The new form accepts both forms equivalently:

if (!((!start_attr || start_attr->i() == 0) &&
      (!end_attr   || end_attr->i()   == std::numeric_limits<int64_t>::max()))) { ... }

Correct. The commit message ("Fix Shape end-attr guard to accept INT64_MAX as full-shape default") is accurate.

---

New material since prior review

A. Two more partial-Shape correctness guards

Same fix pattern (SinceVersion() >= 15 + start/end attribute check + INT64_MAX-default handling) added in two more places:

• attention_fusion_helper.h::MatchGemmSubgraph (line ~101) — guards the GPT subgraph where Shape → Slice → Squeeze → Unsqueeze → Concat → Reshape → Gemm assumed full-shape semantics.
• embed_layer_norm_fusion.cc::MatchInputToConcatSubgraph (lines ~143, ~188) — guards the two Shape → Gather paths feeding embed-layer-norm position-id construction.

Each carries a clear "why this guard exists" comment. These were latent correctness bugs on any opset-15+ model that used start/end to emit a partial shape. Quietly worth more than the headline opset bump.

B. Forward-proof test infrastructure — GetCurrentOnnxOpset()

static int GetCurrentOnnxOpset() {
  const auto& map = ONNX_NAMESPACE::OpSchemaRegistry::DomainToVersionRange::Instance().Map();
  auto it = map.find(ONNX_NAMESPACE::ONNX_DOMAIN);
  EXPECT_TRUE(it != map.end()) << "ONNX domain not found in OpSchemaRegistry";
  return it != map.end() ? it->second.second : 0;
}

Used by:

• LayerNormFusionCurrentOpsetTest, SkipLayerNormFusionCurrentOpsetTest
• EmbedLayerNormFusionFormat{1,2,3}CurrentOpset
• GroupQueryAttentionPreNormFusionFusesQwenPatternCurrentOpset

This is the right approach. The next time someone bumps the bundled ONNX submodule, these tests will start failing on opset drift and tell you exactly which optimizer's version lists need updating. The failure messages even point at the offending file ("Update version lists in onnxruntime/core/optimizer/embed_layer_norm_fusion.cc"). Strictly better than hard-coded opset numbers.

C. LoadModelAtCurrentOpset model rewriting

Loads an existing .onnx test model and rewrites the proto in place:

1. Bumps the ai.onnx opset_import to current opset.
2. Converts attribute-form axes to input-form for Squeeze/Unsqueeze (opset 13+) and ReduceSum/ReduceMean/ReduceMax/ReduceMin/ReduceProd (opset 18+).

This works for the three embed_layer_norm_format*.onnx fixtures because they only use those operators with attribute-form axes. A few notes for future readers:

• The conversion list is exhaustive for the fixtures it's used against. If anyone reuses LoadModelAtCurrentOpset for a model that also has, say, attribute-form axes on a Slice (was input from opset 10) or any other op that migrated attributes to inputs, it will silently fail to convert and produce an invalid graph at the bumped opset. A one-line comment on the helper noting "currently handles only Squeeze/Unsqueeze/Reduce*; extend as needed" would help.
• Bumping opset_import does not re-validate the existing nodes against the new schemas. For operators that were bumped without input changes (e.g., Add at v14), the node-level SinceVersion() reported by the loader will adjust to the imported opset. CI confirms the rewritten models load and the tests pass (86/86 checks OK on 992c85e), so this is empirically fine.

Not blocking — useful infrastructure, just worth a comment.

D. Title vs scope

The PR title says "opset 25" but the version lists include {24, 25} and the third commit message references "opset 26". The actual entries are fine (defensive future-proofing past the last-bumped versions). Worth updating the PR title to match if 26 is the real target.

---

Minor observations on the new code

• The SinceVersion() >= 15 + start/end attribute check is now duplicated five times (reshape_fusion.cc, attention_fusion_helper.h × 1, embed_layer_norm_fusion.cc × 2). A small helper —

  // Returns true if shape_node represents the full tensor shape (no start/end slicing).
  static bool IsFullShape(const Node& shape_node);

  — would dedupe nicely. Out of scope here; file as a follow-up alongside the attention_fusion.cc named-constants refactor.

• LayerNormFusionCurrentOpsetTest builds the LayerNorm pattern with Pow. Pow was last bumped at opset 15 (pow.SinceVersion() == 15 for any model at opset ≥ 15). Fine.

• LayerNormFusionCurrentOpsetTest runs at TransformerLevel::Level1, but the standard LayerNormFusion registration is at Level2 with fuse_in_level_1=true in some pipelines. The test explicitly constructs LayerNormFusion(no_limit_empty_ep_list, TransformerLevel::Level1) to force the Level1 path, which is the right call for a unit test. Just noting it's intentional, not a bug.

• The post-graph checker pattern in the new tests:

  if (op_to_count["LayerNormalization"] == 1) { ...checks...; return Status::OK(); }
  return ORT_MAKE_STATUS(ONNXRUNTIME, FAIL, "...failed at opset ", current_opset, "...");

  produces a much more useful failure message than TEST_RETURN_IF_NOT alone. Nice pattern — worth adopting for other current-opset tests in the codebase.

---

Bottom line

The substantive concern from the prior review is fixed, the partial-Shape correctness fix has been generalized to two more sites, and the new GetCurrentOnnxOpset()-based tests are a genuinely useful piece of regression infrastructure that will catch the next opset drift automatically. Approve.

The follow-up cleanups (dedupe the five copies of the partial-Shape guard into an IsFullShape helper; pull attention_fusion.cc opset lists into named constants; broaden LoadModelAtCurrentOpset's attribute-to-input table if it gets reused) are all worth filing as separate issues but should not hold this PR.