Add files using upload-large-folder tool

pythonProject/.venv/Lib/site-packages/onnxscript/_framework_apis/torch_2_5.py

@@ -0,0 +1,117 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""Stable APIs for PyTorch 2.5."""
+
+from __future__ import annotations
+
+__all__ = [
+    "check_model",
+    "convert_version",
+    "get_torchlib_ops",
+    "optimize",
+    "save_model_with_external_data",
+]
+
+import dataclasses
+import os
+import pathlib
+from typing import Callable
+
+from onnxscript import ir, optimizer, version_converter
+from onnxscript.function_libs.torch_lib import registration
+
+
+@dataclasses.dataclass(frozen=True)
+class _OnnxFunctionMeta:
+    """A wrapper of onnx-script function with additional metadata.
+
+    qualified_name: The qualified name of the aten operator.
+    function: The onnx-script function.
+    domain: The domain of the function.
+    name: The name of the function.
+    is_complex: Whether the function is a complex function.
+    """
+
+    qualified_name: str
+    function: Callable
+    domain: str
+    name: str
+    is_complex: bool = False
+
+
+def optimize(model: ir.Model) -> ir.Model:
+    """Optimize the model."""
+    # Internal flag. Will go away.
+    enabled = os.getenv("TORCH_ONNX_ENABLE_OPTIMIZATION") == "1"
+    if enabled:
+        optimizer.optimize_ir(model)
+    return model
+
+
+def convert_version(model: ir.Model, target_version: int) -> ir.Model:
+    """Convert the model to the specified ONNX opset version."""
+    # Internal flag. Will go away.
+    enabled = os.getenv("TORCH_ONNX_ENABLE_VERSION_CONVERSION") == "1"
+    if enabled:
+        version_converter.convert_version(model, target_version)
+    return model
+
+
+def check_model(model: ir.Model) -> None:
+    """Check the model."""
+
+    del model  # Unused yet
+
+
+def save_model_with_external_data(model: ir.Model, model_path: str | os.PathLike) -> None:
+    """Save the model with external data. The model is unchanged after saving."""
+
+    # TODO(#1835): Decide if we want to externalize large attributes as well
+    for value in model.graph.initializers.values():
+        if value.const_value is None:
+            raise ValueError(
+                "The model contains uninitialized initializer values. "
+                "Please make sure all initializer values are initialized."
+            )
+    destination_path = pathlib.Path(model_path)
+    data_path = f"{destination_path.name}.data"
+
+    ir.save(model, model_path, external_data=data_path)
+
+
+def get_torchlib_ops() -> list[_OnnxFunctionMeta]:
+    # Trigger op registration
+    from onnxscript.function_libs.torch_lib import (  # pylint: disable=import-outside-toplevel
+        ops,
+    )
+
+    del ops  # Unused
+
+    torchlib_registry = registration.default_registry
+    function_metas = []
+
+    for qualified_name, aten_overloads_func in torchlib_registry.items():
+        if qualified_name.startswith("internal::"):
+            # Skip the custom defined internal functions
+            continue
+
+        for overload_func in aten_overloads_func.overloads:
+            function_meta = _OnnxFunctionMeta(
+                qualified_name=qualified_name,
+                function=overload_func,
+                domain=overload_func.function_ir.domain,
+                name=overload_func.name,
+                is_complex=False,
+            )
+            function_metas.append(function_meta)
+        for complex_func in aten_overloads_func.complex:
+            function_meta = _OnnxFunctionMeta(
+                qualified_name=qualified_name,
+                function=complex_func,
+                domain=complex_func.function_ir.domain,
+                name=complex_func.name,
+                is_complex=True,
+            )
+            function_metas.append(function_meta)
+
+    return function_metas

pythonProject/.venv/Lib/site-packages/onnxscript/rewriter/basic_rules.py

@@ -0,0 +1,321 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""Basic rewrite rules for general optimization patterns.
+
+This module contains fundamental optimization rules that are generally applicable
+to most ONNX models, including cast elimination, transpose simplification,
+shape operation fusion, and other common patterns.
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar, Sequence
+
+from onnxscript import ir
+from onnxscript.rewriter import _ir_utils as ir_utils
+from onnxscript.rewriter._basics import MatchResult
+from onnxscript.rewriter._rewrite_rule import RewriteRuleClassBase, RewriteRuleSet
+
+
+class SqueezeReshape(RewriteRuleClassBase):
+    """Replaces ``Reshape(Squeeze(x), [-1]])`` with ``Identity(x)`` for 1D x.
+
+    This pattern arises from the translation of pytorch symints.
+    """
+
+    def __init__(self):
+        super().__init__("SqueezeReshape1d", remove_nodes=False)
+
+    def pattern(self, op, x):
+        return op.Reshape(op.Squeeze(x), [-1])
+
+    def rewrite(self, op, x: ir.Value):
+        return op.Identity(x)
+
+    def check(self, context, x) -> MatchResult:
+        del context  # Unused
+        check_result = MatchResult()
+        if not ir_utils.has_rank(x, 1):
+            return check_result.fail("Input is not 1D")
+        return check_result
+
+
+class CastIdentity(RewriteRuleClassBase):
+    """Replaces ``Cast(., to=to)`` by ``Identity`` if possible."""
+
+    def pattern(self, op, x, to):
+        return op.Cast(x, to=to)
+
+    def rewrite(self, op, x: ir.Value, to: ir.Attr):
+        return op.Identity(x)
+
+    def check(self, context, x, to) -> MatchResult:
+        check_result = MatchResult()
+        if x.dtype != to.as_int():
+            return check_result.fail("Input and output types are not the same")
+        return check_result
+
+
+class CastCast(RewriteRuleClassBase):
+    """Replaces ``Cast(Cast(X, ...), to=to)`` by ``Cast(X, to=to)``."""
+
+    # Simplify "cast type1 => type2 => type3" to "cast type1 => type3".
+    # This rule is not valid for all combinations of types: e.g.,
+    # it is not valid for float32 => float16 => float32 or float32 => int32 => string.
+    # TODO: fill out the list of allowed combinations: the following is just a couple
+    # that shows up in practice where it is valid
+    _allowed_type2_type3: ClassVar = frozenset(
+        {
+            (ir.DataType.FLOAT, ir.DataType.FLOAT16),
+            (ir.DataType.FLOAT, ir.DataType.BFLOAT16),
+        }
+    )
+
+    def pattern(self, op, x, to, to_ignored):
+        return op.Cast(op.Cast(x, to=to_ignored), to=to)
+
+    def check(self, context, x: ir.Value, to: ir.Attr, to_ignored: ir.Attr) -> MatchResult:
+        check_result = MatchResult()
+        type2 = to_ignored.as_int()
+        type3 = to.as_int()
+        if (type2, type3) not in self._allowed_type2_type3:
+            return check_result.fail(
+                f"Intermediate cast elimination not recognized as valid from {type2} to {type3}. "
+                f"Cast-Cast rule may be incomplete for this combination."
+            )
+        return check_result
+
+    def rewrite(self, op, x: ir.Value, to: ir.Attr, to_ignored: ir.Attr):
+        return op.Cast(x, to=to)
+
+
+class ExpandIdentity(RewriteRuleClassBase):
+    """Replaces ``Expand(..., shape)`` by ``Identity`` if possible."""
+
+    def pattern(self, op, x, shape):
+        return op.Expand(x, shape)
+
+    def rewrite(self, op, x: ir.Value, shape: ir.Value):
+        return op.Identity(x)
+
+    def check(self, context, x, shape) -> MatchResult:
+        check_result = MatchResult()
+        if shape.const_value is None:
+            # Shape is not a constant and cannot be guessed.
+            return check_result.fail("Shape is not a constant and cannot be guessed.")
+        if (x_shape := x.shape) is None:
+            # We don't know the shape of the input
+            return check_result.fail("Input shape is not known.")
+        if x_shape.dims != tuple(shape.const_value.numpy().tolist()):
+            return check_result.fail(
+                f"Input shape {x_shape.dims} does not match the shape {shape.const_value.numpy().tolist()}."
+            )
+        return check_result
+
+
+class ReshapeReshape(RewriteRuleClassBase):
+    """Replaces ``Reshape(Reshape(X, ...), shape)`` by ``Reshape(X, shape)``.
+    The pattern matches only if second reshape reshapes into a shape
+    with positive values.
+    """
+
+    def pattern(self, op, x, shape_ignored, shape):
+        return op.Reshape(op.Reshape(x, shape_ignored), shape)
+
+    def rewrite(self, op, x: ir.Value, shape_ignored: ir.Value, shape: ir.Value):
+        return op.Reshape(x, shape)
+
+    def check(self, context, x, shape_ignored, shape) -> MatchResult:
+        check_result = MatchResult()
+        if shape_ignored.const_value is None:
+            return check_result.fail("Shape ignored is not a constant.")
+        if shape.const_value is None:
+            return check_result.fail("Shape is not a constant.")
+        if shape.const_value.numpy().min() <= 0:
+            return check_result.fail("Shape has non-positive values.")
+        return check_result
+
+
+class SlicesSplit(RewriteRuleClassBase):
+    """Replaces ``Slice(x, ...), Slice(x, ...)``
+    by ``Split(x, ...)`` if possible.
+    """
+
+    def pattern(self, op, x, begin0, end0, axes0, begin1, end1, axes1):
+        return op.Slice(x, begin0, end0, axes0), op.Slice(x, begin1, end1, axes1)
+
+    def check(self, context, x, begin0, end0, axes0, begin1, end1, axes1) -> MatchResult:
+        check_result = MatchResult()
+        if (
+            axes0.const_value is None
+            or axes1.const_value is None
+            or axes0.const_value.numpy().tolist() != axes1.const_value.numpy().tolist()
+        ):
+            return check_result.fail("Axes are not equal or not constant.")
+        axes = axes0.const_value.numpy().tolist()
+        if len(axes) != 1:
+            return check_result.fail("Axes has more than one dimension.")
+        if x.shape:
+            rk = len(x.shape)
+        else:
+            rk = x.rank
+        if axes[0] != -1 and axes[0] != rk - 1:
+            return check_result.fail("Axes is not -1 or last dimension.")
+        if (
+            begin0.const_value is None
+            or end0.const_value is None
+            or begin1.const_value is None
+            or end1.const_value is None
+        ):
+            return check_result.fail("Begin or end are not constant values.")
+        if begin0.const_value.numpy().tolist() != [0]:
+            return check_result.fail("First begin value is not 0.")
+        e0, b1, e1 = (
+            end0.const_value.numpy().tolist(),
+            begin1.const_value.numpy().tolist(),
+            end1.const_value.numpy().tolist(),
+        )
+        if e0[0] != b1[0]:
+            return check_result.fail("End0 is not equal to Begin1.")
+        shape = x.shape
+        if shape is None:
+            return check_result.fail("Shape is not known.")
+        last_dim = shape[-1]
+        if not isinstance(last_dim, int):
+            return check_result.fail("Last dimension is not known.")
+        if last_dim != e1[0]:
+            return check_result.fail("Last dimension is not equal to End1.")
+        if last_dim // 2 != b1[0]:
+            return check_result.fail("Last dimension is not equal to Begin1.")
+        return check_result
+
+    def rewrite(self, op, x, begin0, end0, axes0, begin1, end1, axes1):
+        return op.Split(x, num_outputs=2, axis=-1, _outputs=2)
+
+
+class TransposeIdentity(RewriteRuleClassBase):
+    """Replaces ``Transpose(. perm=perm)``
+    when the permutation is identity.
+    """
+
+    def pattern(self, op, x, perm):
+        return op.Transpose(x, perm=perm)
+
+    def check(self, context, x: ir.Value, perm: ir.Attr) -> MatchResult:
+        check_result = MatchResult()
+        if perm.is_ref():
+            return check_result.fail("Permutation is a reference attribute.")
+        if perm.type == ir.AttributeType.INTS:
+            perm_ints = tuple(perm.as_ints())
+            if perm_ints == tuple(range(len(perm_ints))):
+                return check_result
+        return check_result.fail("Permutation is not identity.")
+
+    def rewrite(self, op, x: ir.Value, perm: ir.Attr):
+        return op.Identity(x)
+
+
+class TransposeTranspose(RewriteRuleClassBase):
+    """Replaces ``Transpose(Transpose(., perm=perm1), perm=perm2)``
+    when both permutations are inverse.
+    """
+
+    def pattern(self, op, x, perm1, perm2):
+        return op.Transpose(op.Transpose(x, perm=perm1), perm=perm2)
+
+    def check(self, context, x: ir.Value, perm1: ir.Attr, perm2: ir.Attr) -> MatchResult:
+        check_result = MatchResult()
+        if perm1.is_ref() or perm2.is_ref():
+            return check_result.fail("Permutation is a reference attribute.")
+        return check_result
+
+    def _apply_transpose(self, perm: Sequence[int], on: list[int]) -> list[int]:
+        assert len(perm) == len(on), "length mismatch"
+        res = [-1 for i in on]
+        for i, p in enumerate(perm):
+            res[i] = on[p]
+        return res
+
+    def _apply_transposes(
+        self, perms: list[Sequence[int]], on: list[int] | None = None
+    ) -> list[int]:
+        if on is None:
+            on = list(range(len(perms[0])))
+        for p in perms:
+            on = self._apply_transpose(p, on)
+        return on
+
+    def rewrite(self, op, x: ir.Value, perm1: ir.Attr, perm2: ir.Attr):
+        first = list(range(len(perm1.as_ints())))
+        last = self._apply_transposes([perm1.as_ints(), perm2.as_ints()])
+        if first == last:
+            return op.Identity(x)
+        return op.Transpose(x, perm=last)
+
+
+class UnsqueezeUnsqueeze(RewriteRuleClassBase):
+    """Replaces ``Unsqueeze(Unsqueeze(., axes1), axes2)`` with one Unsqueeze."""
+
+    def pattern(self, op, x, axes1, axes2):
+        return op.Unsqueeze(op.Unsqueeze(x, axes1), axes2)
+
+    def rewrite(self, op, x: ir.Value, axes1: ir.Value, axes2: ir.Value):
+        v1 = ir_utils.get_singleton_value(axes1)
+        v2 = ir_utils.get_singleton_value(axes2)
+        axes = [v1, v2] if v1 < v2 else [v2, v1 + 1]
+        return op.Unsqueeze(x, op.Constant(value=ir.tensor(axes, dtype=ir.DataType.INT64)))
+
+    def check(self, context, x, axes1, axes2) -> MatchResult:
+        check_result = MatchResult()
+        del context  # Unused
+        del x  # Unused
+        # Currently restricted to single element positive axis
+        v1 = ir_utils.get_singleton_value(axes1)
+        v2 = ir_utils.get_singleton_value(axes2)
+        if v1 is None or v2 is None:
+            return check_result.fail("Axes are not constant.")
+        if (v1 < 0) or (v2 < 0):
+            return check_result.fail("Axes are negative.")
+        return check_result
+
+
+# Create rule instances
+cast_cast_rule = CastCast.rule()
+cast_identity_rule = CastIdentity.rule()
+expand_identity_rule = ExpandIdentity.rule()
+reshape_reshape_rule = ReshapeReshape.rule()
+slice_split_rule = SlicesSplit.rule()
+transpose_identity_rule = TransposeIdentity.rule()
+transpose_transpose_rule = TransposeTranspose.rule()
+unsqueeze_unsqueeze_rule = UnsqueezeUnsqueeze.rule()
+squeeze_reshape_1d_rule = SqueezeReshape.rule()
+
+
+def basic_optimization_rules() -> RewriteRuleSet:
+    """Returns a set of basic optimization rules.
+
+    These rules perform fundamental optimizations such as:
+    - Eliminating redundant cast operations
+    - Simplifying consecutive operations of the same type
+    - Removing identity operations
+    - Optimizing shape manipulation operations
+
+    These rules are generally safe to apply as a first optimization pass
+    before other more specialized optimizations.
+
+    Returns:
+        RewriteRuleSet: A collection of basic optimization rules
+    """
+    return RewriteRuleSet(
+        [
+            cast_cast_rule,
+            cast_identity_rule,
+            expand_identity_rule,
+            reshape_reshape_rule,
+            slice_split_rule,
+            transpose_identity_rule,
+            transpose_transpose_rule,
+            unsqueeze_unsqueeze_rule,
+            squeeze_reshape_1d_rule,
+        ]
+    )

pythonProject/.venv/Lib/site-packages/onnxscript/rewriter/broadcast_to_matmul.py

@@ -0,0 +1,178 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+import logging
+
+from onnxscript import ir
+from onnxscript.rewriter._rewrite_rule import RewriteRule, RewriteRuleSet
+
+logger = logging.getLogger(__name__)
+
+
+def check_if_not_need_reshape(
+    context, input_a: ir.Value, input_b: ir.Value, shape_c: ir.Value, **_
+) -> bool:
+    """Condition to check if we need to replace the pattern.
+
+    If matmul broadcasting is enough, then we don't need the reshapes.
+
+    To validate this, we need to check the following:
+    1. Input shapes check: input_a and input_b should be broadcastable
+    2. Output shape check: shape_c should be the same as the output shape from the matmul(input_a, input_b)
+
+    If the above are true, then we don't need the reshapes.
+
+    Returns:
+        True if we need to replace the pattern, False otherwise.
+    """
+    del context  # Reserved for future extensions
+
+    input_a_shape = input_a.shape
+    input_b_shape = input_b.shape
+    shape_c_tensor = shape_c.const_value
+    if shape_c_tensor is None:
+        logger.info("The value 'shape_c' is not statically known.")
+        return False
+
+    if len(shape_c_tensor.shape) != 1:
+        logger.info(
+            "Unexpected final shape. The shape of 'shape' value is %s",
+            shape_c_tensor.shape,
+        )
+        return False
+
+    # NOTE: When there is a subset match with a pattern. The MatchResult won't have the shape
+    # information. So, we need to check if the shape is None and return False.
+    if input_a_shape is None or input_b_shape is None:
+        logger.info("Shape information is not available for the inputs and outputs.")
+        return False
+    if any(isinstance(dim, ir.SymbolicDim) for dim in input_a_shape):
+        logger.info("Symbolic dimensions are not yet supported.")
+        return False
+    if any(isinstance(dim, ir.SymbolicDim) for dim in input_b_shape):
+        logger.info("Symbolic dimensions are not yet supported.")
+        return False
+    input_a_shape = input_a_shape.numpy()  # type: ignore[assignment]
+    input_b_shape = input_b_shape.numpy()  # type: ignore[assignment]
+    shape_c = shape_c_tensor.numpy().tolist()  # type: ignore[assignment]
+
+    a_rank = len(input_a_shape)
+    b_rank = len(input_b_shape)
+
+    # 1. Check if input shapes are broadcastable
+    # 1.a. If the first input is 1-D, check whether
+    # the dim matches the last second dim of the second input.
+    mimic_matmul_broadcast_behavior_a = False
+    mimic_matmul_broadcast_behavior_b = False
+    if a_rank < 2:
+        if b_rank < 2:
+            logger.info("Optimization of dot product is not supported yet.")
+            return False
+        if input_a_shape[-1] != input_b_shape[-2]:
+            logger.info("Original shape is not MatMul compatible.")
+            return False
+        else:
+            input_a_shape = [1, *input_a_shape]  # type: ignore[assignment]
+            a_rank = len(input_a_shape)
+            mimic_matmul_broadcast_behavior_a = True
+    # 1.b. If the second input is 1-D, check whether
+    # the dim matches the last dim of the first input.
+    if b_rank < 2:
+        if input_b_shape[-1] != input_a_shape[-1]:
+            logger.info("Original shape is not MatMul compatible.")
+            return False
+        else:
+            input_b_shape = [*input_b_shape, 1]  # type: ignore[assignment]
+            b_rank = len(input_b_shape)
+            mimic_matmul_broadcast_behavior_b = True
+    # 1.c. If both inputs are at least 2-D, check whether
+    # the last dimension of the first input matches the second
+    # last dimension of the second input, and shape[:-2] are
+    # broadcastable.
+    input_a_shape_except_second_last_dim = [*input_a_shape[:-2], *[input_a_shape[-1]]]
+    input_b_shape_except_last_dim = input_b_shape[:-1]
+    broadcast_matmul_output_shape = [input_a_shape[-2], input_b_shape[-1]]
+    for idx, (dim_from_a, dim_from_b) in enumerate(
+        zip(
+            reversed(input_a_shape_except_second_last_dim),
+            reversed(input_b_shape_except_last_dim),
+        )
+    ):
+        if dim_from_a not in {1, dim_from_b}:
+            logger.info("Original shape is not broadcastable.")
+            return False
+        elif idx > 0:
+            broadcast_matmul_output_shape = [
+                max(dim_from_a, dim_from_b),  # type: ignore[type-var]
+                *broadcast_matmul_output_shape,
+            ]
+
+    # 2. Check if output shape is the same as the output shape from the matmul(input_a, input_b)
+    # Prepend the broadcast_matmul_output_shape with the longer shape of input
+    if a_rank > b_rank:
+        longer_shape = input_a_shape
+        shorter_shape = input_b_shape
+    else:
+        longer_shape = input_b_shape
+        shorter_shape = input_a_shape
+    broadcast_matmul_output_shape = [
+        *longer_shape[: -len(shorter_shape)],
+        *broadcast_matmul_output_shape,
+    ]
+    if mimic_matmul_broadcast_behavior_b and b_rank == 2 and input_b_shape[-1] == 1:
+        # If input_b is expanded to 2-D, then we need to remove the last dimension
+        broadcast_matmul_output_shape = broadcast_matmul_output_shape[:-1]
+    if mimic_matmul_broadcast_behavior_a and a_rank == 2 and input_a_shape[0] == 1:
+        # If input_a is expanded to 2-D, then we need to remove the first dimension
+        # of input_a, which would be the -2nd dimension of the output shape.
+        broadcast_matmul_output_shape.pop(-2)
+    if shape_c != broadcast_matmul_output_shape:
+        logger.info(
+            "Final output shape is not the same. Expected %s vs actual %s",
+            shape_c,
+            broadcast_matmul_output_shape,
+        )
+        return False
+
+    return True
+
+
+def _two_reshapes_matmul_reshape_pattern(op, input_a, input_b, shape_a, shape_b, shape_c):
+    # TODO: Modified from `value_ints` to `value` to match pattern in benchmark models.
+    # This implementation misses pattern of Constants with `value_ints` attribute.
+    # See more at https://github.com/microsoft/onnx-rewriter/issues/191.
+    # A better solution is to improve pattern matching and avoid depending on writing
+    # Constants in pattern. See https://github.com/microsoft/onnx-rewriter/issues/192.
+    reshape_a = op.Reshape(input_a, shape_a)
+    reshape_b = op.Reshape(input_b, shape_b)
+    matmul = op.MatMul(reshape_a, reshape_b)
+    return op.Reshape(matmul, shape_c)
+
+
+def _matmul(op, input_a, input_b, **_):
+    return op.MatMul(input_a, input_b)
+
+
+def _one_reshape_matmul_reshape_pattern(op, input_a, input_b, shape_a, shape_c):
+    reshape_a = op.Reshape(input_a, shape_a)
+    matmul = op.MatMul(reshape_a, input_b)
+    return op.Reshape(matmul, shape_c)
+
+
+# Register the rewrite rules
+two_reshapes_matmul_reshape_rule = RewriteRule(
+    _two_reshapes_matmul_reshape_pattern,
+    _matmul,
+    check_if_not_need_reshape,
+)
+one_reshape_matmul_reshape_rule = RewriteRule(
+    _one_reshape_matmul_reshape_pattern,
+    _matmul,
+    # We can use the same check_if_not_need_reshape function for both the rules,
+    # as one_reshape_matmul_reshape_pattern is a subset of _two_reshapes_matmul_reshape_pattern.
+    check_if_not_need_reshape,
+)
+
+# NOTE: The order of the rules is important. Larger pattern should be checked first.
+rules = RewriteRuleSet([two_reshapes_matmul_reshape_rule, one_reshape_matmul_reshape_rule])

pythonProject/.venv/Lib/site-packages/onnxscript/rewriter/cast_constant_of_shape.py

@@ -0,0 +1,46 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+import logging
+
+from onnxscript import ir
+from onnxscript.rewriter._rewrite_rule import RewriteRule, RewriteRuleSet
+
+logger = logging.getLogger(__name__)
+
+
+def cast_constant_of_shape(op, shape, scalar, dtype):
+    constant = op.ConstantOfShape(shape, value=scalar)
+    return op.Cast(constant, to=dtype)
+
+
+def fused_cast_constant_of_shape(op, shape: ir.Value, scalar: ir.Attr, dtype: ir.Attr, **_):
+    # Cast scalar (a TensorProto attribute) to the specified dtype
+    scalar_value = scalar.value.numpy().item()
+    cast_value = ir.tensor([scalar_value], dtype=ir.DataType(dtype.as_int()))
+    return op.ConstantOfShape(shape, value=cast_value)
+
+
+def cast_constant_of_shape_without_value(op, shape, dtype):
+    constant = op.ConstantOfShape(shape)
+    return op.Cast(constant, to=dtype)
+
+
+def fused_cast_constant_of_shape_without_value(op, shape, dtype, **_):
+    zero = ir.tensor([0], dtype=ir.DataType(dtype.as_int()))
+    return op.ConstantOfShape(shape, value=zero)
+
+
+cast_constant_of_shape_rule = RewriteRule(cast_constant_of_shape, fused_cast_constant_of_shape)
+
+cast_constant_of_shape_without_value_rule = RewriteRule(
+    cast_constant_of_shape_without_value, fused_cast_constant_of_shape_without_value
+)
+
+rules = RewriteRuleSet(
+    [
+        cast_constant_of_shape_rule,
+        cast_constant_of_shape_without_value_rule,
+    ]
+)

pythonProject/.venv/Lib/site-packages/onnxscript/rewriter/collapse_slices.py

@@ -0,0 +1,107 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+import logging
+
+from onnxscript import ir
+from onnxscript.rewriter._ir_utils import is_singleton_value
+from onnxscript.rewriter._rewrite_rule import RewriteRule, RewriteRuleSet
+
+logger = logging.getLogger(__name__)
+_INT64_MAX = 9223372036854775807
+
+
+def _check_if_redundant_slice(
+    context,
+    data: ir.Value,
+    starts: ir.Value,
+    ends: ir.Value,
+    axes: ir.Value,
+    steps: ir.Value,
+    **_,
+) -> bool:
+    """If the starts is 0, and the ends is equal to or grater than the shape of the specified axis, then the slice is redundant."""
+    del context  # Reserved for future extensions
+
+    starts_const = starts.const_value
+    ends_const = ends.const_value
+    axes_const = axes.const_value
+    steps_const = steps.const_value
+
+    if starts_const is None or ends_const is None or axes_const is None or steps_const is None:
+        logger.info("The value 'start', 'end', 'axis', 'step' is not statically known.")
+        return False
+
+    # Check if the values are scalar
+    if starts_const.numpy().size != 1:  # type: ignore[union-attr]
+        logger.info("The value 'start' is not a scalar.")
+        return False
+    if ends_const.numpy().size != 1:  # type: ignore[union-attr]
+        logger.info("The value 'end' is not a scalar.")
+        return False
+    if axes_const.numpy().size != 1:  # type: ignore[union-attr]
+        logger.info("The value 'axis' is not a scalar.")
+        return False
+    if steps_const.numpy().size != 1:  # type: ignore[union-attr]
+        logger.info("The value 'step' is not a scalar.")
+        return False
+
+    if steps_const.numpy().item() != 1:
+        logger.info("The value 'step' is not 1.")
+        return False
+    # starts is 0
+    if starts_const.numpy().item() != 0:
+        logger.info("The value 'start' is not 0.")
+        return False
+    # In case data.shape is not statically known, we still can tell the slice is redundant if ends is sys.maxsize
+    if ends_const.numpy().item() == _INT64_MAX:
+        return True
+    if data.shape is None or data.shape.is_dynamic(axes_const.numpy().item()):
+        logger.info("The value 'data' shape is not statically known.")
+        return False
+    if ends_const.numpy().item() < data.shape[axes_const.numpy().item()]:
+        logger.info("The value 'end' is less than the shape of the specified axis.")
+        return False
+
+    return True
+
+
+def _identity_to_itself(op, data, **_):
+    """Return the input data as the output."""
+    return op.Identity(data)
+
+
+def _potential_redundant_slice(op, data, starts, ends, axes, steps):
+    """To identify a slice op"""
+    return op.Slice(data, starts, ends, axes, steps, _outputs=["slice_output"])
+
+
+def _same_shape(op, data: ir.Value, slice_output: ir.Value, steps: ir.Value, **_):
+    """Check if the shape of the slice output is the same as the data."""
+    if data.shape is None or slice_output.shape is None:
+        return False
+
+    if not is_singleton_value(steps, 1):
+        return False
+
+    return data.shape == slice_output.shape
+
+
+# Register the rewrite rules
+remove_redundant_slice = RewriteRule(
+    _potential_redundant_slice,
+    _identity_to_itself,
+    _check_if_redundant_slice,
+)
+
+remove_redundant_slice2 = RewriteRule(
+    _potential_redundant_slice,
+    _identity_to_itself,
+    _same_shape,
+)
+
+# NOTE: The second rule subsumes the first one. So, we may be able to remove the first one,
+# provided shape-inference is run before the rewriter and computes the shape of the slice output.
+
+rules = RewriteRuleSet([remove_redundant_slice, remove_redundant_slice2])

pythonProject/.venv/Lib/site-packages/onnxscript/utils/timing_utils.py

@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+import time
+
+import onnx
+
+from onnxscript import optimizer
+
+
+def timeit(f, message):
+    def timed(*args, **kw):
+        ts = time.time()
+        result = f(*args, **kw)
+        te = time.time()
+        print(f"{message} time: {te - ts}")
+        return result
+
+    return timed
+
+
+load = timeit(onnx.load, "Load")
+
+save = timeit(onnx.save, "Save")
+
+infer = timeit(onnx.shape_inference.infer_shapes, "Infer")
+
+fold_constants = timeit(optimizer.fold_constants, "Fold Constants")
+
+remove_unused = timeit(optimizer.remove_unused_nodes, "Remove Unused")
+
+optimize = timeit(optimizer.optimize, "Optimize")
+
+# rewrite = timeit(all_rules.apply_to_model, "Rewrite")

pythonProject/.venv/Lib/site-packages/onnxscript/utils/utils.py

@@ -0,0 +1,84 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+from typing import Any
+
+import onnx
+
+
+def normalize_domain(d: str) -> str:
+    return "" if d == "ai.onnx" else d
+
+
+def is_onnx_domain(d: str) -> bool:
+    return normalize_domain(d) == ""
+
+
+def is_onnx_op(node: onnx.NodeProto, op_type: str) -> bool:
+    return is_onnx_domain(node.domain) and node.op_type == op_type
+
+
+def is_control_flow_op(node: onnx.NodeProto) -> bool:
+    return any(attr.HasField("g") or len(attr.graphs) > 0 for attr in node.attribute)
+
+
+def get_node_attr_value(node: onnx.NodeProto, attr_name: str, default: Any) -> Any:
+    matching = [x for x in node.attribute if x.name == attr_name]
+    if len(matching) > 1:
+        raise ValueError(f"Node has multiple attributes with name {attr_name}")
+    if len(matching) < 1:
+        return default
+    return onnx.helper.get_attribute_value(matching[0])
+
+
+def get_initializer_type(initializer: onnx.TensorProto) -> onnx.TypeProto:
+    type = onnx.TypeProto()
+    type.tensor_type.elem_type = initializer.data_type
+    dims = type.tensor_type.shape.dim
+    for dim in initializer.dims:
+        dims.add().dim_value = dim
+    return type
+
+
+def get_constant_node_value(node: onnx.NodeProto, name: str) -> onnx.TensorProto | None:
+    if (
+        node.op_type != "Constant"
+        or node.domain not in {"", "ai.onnx"}
+        or len(node.attribute) != 1
+    ):
+        return None
+    attr = node.attribute[0]
+    if attr.ref_attr_name:
+        return None
+    attr_name = attr.name
+    value = onnx.helper.get_attribute_value(attr)
+
+    if isinstance(value, onnx.TensorProto):
+        # Two names exist in this case: we use tensorproto as is (with original name)
+        return value
+    shape: list[int]
+    if attr_name == "value_int":
+        dtype = onnx.TensorProto.INT64
+        shape = []
+        value = [value]
+    elif attr_name == "value_float":
+        dtype = onnx.TensorProto.FLOAT
+        shape = []
+        value = [value]
+    elif attr_name == "value_string":
+        dtype = onnx.TensorProto.STRING
+        shape = []
+        value = [value]
+    elif attr_name == "value_ints":
+        dtype = onnx.TensorProto.INT64
+        shape = [len(value)]
+    elif attr_name == "value_floats":
+        dtype = onnx.TensorProto.FLOAT
+        shape = [len(value)]
+    elif attr_name == "value_strings":
+        dtype = onnx.TensorProto.STRING
+        shape = [len(value)]
+    else:
+        return None  # sparse tensors not handled
+    return onnx.helper.make_tensor(name, dtype, shape, value)

pythonProject/.venv/Lib/site-packages/onnxscript/version_converter/__init__.py

@@ -0,0 +1,179 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from __future__ import annotations
+
+__all__ = [
+    "ConvertVersionPass",
+    "convert_version",
+]
+
+import logging
+
+import onnx
+import onnx_ir.passes.common as common_passes
+
+from onnxscript import ir
+from onnxscript.version_converter import _c_api_utils, _version_converter
+
+logger = logging.getLogger(__name__)
+
+
+class ConvertVersionPass(ir.passes.InPlacePass):
+    """Convert the model to the specified ONNX opset version.
+
+    This pass leverages the onnxscript version converter to convert the model. If
+    the conversion is not supported, it falls back to the onnx C API to convert
+    the model. This pass is in-place.
+
+    The pass is an no-op if the c-api fails.
+
+    Attributes:
+        target_version: The target ONNX opset version to convert the model to.
+        fallback: Whether to fallback to the onnx version converter if the
+            target version is not supported. Default is False.
+    """
+
+    def __init__(self, target_version: int, fallback: bool = False) -> None:
+        super().__init__()
+        self.target_version = target_version
+        self.fallback = fallback
+        self.convert_pass = ir.passes.Sequential(
+            common_passes.InlinePass(),
+            _ConvertVersionPassRequiresInline(
+                target_version=target_version,
+                fallback=fallback,
+            ),
+            common_passes.RemoveUnusedNodesPass(),
+            common_passes.RemoveUnusedFunctionsPass(),
+            common_passes.RemoveUnusedOpsetsPass(),
+        )
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        return self.convert_pass(model)
+
+
+class _ConvertVersionPassRequiresInline(ir.passes.InPlacePass):
+    """Convert the model to the specified ONNX opset version.
+
+    This pass leverages the onnxscript version converter to convert the model. If
+    the conversion is not supported, it falls back to the onnx C API to convert
+    the model. This pass is in-place.
+
+    The pass is an no-op if the c-api fails.
+
+    Attributes:
+        target_version: The target ONNX opset version to convert the model to.
+        fallback: Whether to fallback to the onnx version converter if the
+            target version is not supported.
+    """
+
+    def __init__(self, target_version: int, fallback: bool) -> None:
+        super().__init__()
+        self.target_version = target_version
+        self.fallback = fallback
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        if model.functions:
+            raise ValueError(
+                "The model contains functions. The version conversion pass does not support "
+                "functions. Please use `common_passes.InlinePass` to inline the "
+                f"functions before applying this pass ({self.__class__.__name__})."
+            )
+        if "" in model.graph.opset_imports:
+            onnx_opset_version = model.graph.opset_imports[""]
+            if onnx_opset_version == self.target_version:
+                # No need to convert the version
+                return ir.passes.PassResult(model, False)
+
+        # When fallback is disabled, always use the onnxscript version converter;
+        # When fallback is enabled, use the onnxscript version converter
+        # if the target version is supported. Otherwise, use the onnx C API
+        # to convert the model.
+        if not self.fallback or _version_converter.version_supported(
+            model, self.target_version
+        ):
+            _version_converter.convert_version(
+                model,
+                target_version=self.target_version,
+            )
+            return ir.passes.PassResult(model, True)
+
+        if not self.fallback:
+            logger.warning(
+                "The model version conversion is not supported by the onnxscript version converter "
+                "and fallback is disabled. The model was not modified"
+                " (target version: %d). "
+                "Set fallback=True to enable fallback to the onnx c-api version converter.",
+                self.target_version,
+            )
+            return ir.passes.PassResult(model, False)
+        else:
+            logger.warning(
+                "The model version conversion is not supported by the onnxscript version converter "
+                "and fallback is enabled. The model will be converted using the onnx C API "
+                "(target version: %d).",
+                self.target_version,
+            )
+
+        # If the onnxscript version converter does not support the conversion,
+        # we can use the onnx C API to convert the model
+        def _partial_convert_version(proto: onnx.ModelProto) -> onnx.ModelProto:
+            """Partial function to check the model."""
+            return onnx.version_converter.convert_version(
+                proto, target_version=self.target_version
+            )
+
+        try:
+            converted_proto = _c_api_utils.call_onnx_api(
+                func=_partial_convert_version, model=model
+            )
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.warning(
+                "Failed to convert the model to the target version %d using the ONNX C API. "
+                "The model was not modified",
+                self.target_version,
+                exc_info=e,
+            )
+            return ir.passes.PassResult(model, False)
+
+        converted_model = ir.from_proto(converted_proto)
+
+        # Recover the initializers in the converted model
+        for input in converted_model.graph.inputs:
+            if input.name in model.graph.initializers:
+                input.const_value = model.graph.initializers[input.name].const_value
+                converted_model.graph.register_initializer(input)
+        user_inputs = converted_model.graph.inputs[: len(model.graph.inputs)]
+        converted_model.graph.inputs.clear()
+        converted_model.graph.inputs.extend(user_inputs)
+
+        # Return the converted graph to the original model to keep the pass in-place
+        model.graph = converted_model.graph
+        return ir.passes.PassResult(model, True)
+
+
+def convert_version(
+    model: ir.Model | onnx.ModelProto, target_version: int, fallback=None
+) -> None:
+    """Convert the model to the specified ONNX opset version.
+
+    Args:
+        model: The model to convert.
+        target_version: The target ONNX opset version.
+        fallback: Whether to fallback to the onnx version converter if the
+            target version is not supported. Default is False.
+    """
+    if isinstance(model, onnx.ModelProto):
+        model_proto = model
+        model = ir.from_proto(model)
+    else:
+        model_proto = None
+
+    assert isinstance(model, ir.Model)
+    ConvertVersionPass(target_version=target_version, fallback=fallback)(model)
+
+    if model_proto is not None:
+        # Update the model proto in-place
+        model_proto.graph.Clear()
+        del model_proto.functions[:]
+        model_proto.graph.CopyFrom(ir.to_proto(model.graph))

pythonProject/.venv/Lib/site-packages/onnxscript/version_converter/_c_api_utils.py

@@ -0,0 +1,77 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""Utilities for interfacing with onnx C APIs."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Callable, TypeVar
+
+from onnxscript import ir
+
+if TYPE_CHECKING:
+    import onnx
+
+
+logger = logging.getLogger(__name__)
+# Temporarily remove initializers larger than this size to keep model size down
+# for the onnx.shape_inference call because it needs to serialize the model
+_BIG_TENSOR_SIZE_LIMIT = 1000  # 1KB
+_R = TypeVar("_R")
+
+
+def call_onnx_api(func: Callable[[onnx.ModelProto], _R], model: ir.Model) -> _R:
+    """Call an ONNX C API function by temporarily removing initializers.
+
+    This is necessary because the ONNX C API does not support large models
+    with initializers that have large tensor values. The input model is left
+    unchanged no matter the call succeeds or not.
+
+    Args:
+        func: Partially applied function that takes a model proto and returns anything.
+        model: The IR model to pass to the API function.
+
+    Returns:
+        The resulting ModelProto that contains the result of the API call.
+    """
+
+    # Store the original initializer values so they can be restored
+    initializer_values = tuple(model.graph.initializers.values())
+    tensors = {v.name: v.const_value for v in initializer_values}
+    original_inputs_len = len(model.graph.inputs)
+
+    # Turn the initializers into inputs and clear the initializers
+    # to limit the model size
+    for initializer in initializer_values:
+        # Make sure the initializer has its shape/type set
+        assert initializer.const_value is not None
+        if initializer.shape is None:
+            initializer.shape = initializer.const_value.shape  # type: ignore[assignment]
+        if initializer.dtype is None:
+            initializer.dtype = initializer.const_value.dtype
+        if initializer not in model.graph.inputs:
+            model.graph.inputs.append(initializer)
+        if initializer.const_value.size > _BIG_TENSOR_SIZE_LIMIT:
+            # Temporarily remove the initializer value to reduce model size
+            # for onnx.shape_inference
+            initializer.const_value = None
+            assert initializer.name is not None
+            model.graph.initializers.pop(initializer.name)
+
+    proto = ir.serde.serialize_model(model)
+
+    try:
+        # Call the ONNX C API function
+        result = func(proto)
+    finally:
+        # Restore the original initializer values so the model is unchanged
+        for initializer in initializer_values:
+            initializer.const_value = tensors[initializer.name]
+            model.graph.register_initializer(initializer)
+
+        # Restore the original inputs
+        inputs = model.graph.inputs[:original_inputs_len]
+        model.graph.inputs.clear()
+        model.graph.inputs.extend(inputs)
+
+    return result

pythonProject/.venv/Lib/site-packages/onnxscript/version_converter/_version_converter.py

@@ -0,0 +1,339 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+"""Convert the model to the specified ONNX opset version."""
+
+from __future__ import annotations
+
+import dataclasses
+import functools
+import logging
+from typing import Callable, Sequence, Union
+
+import onnx_ir.convenience as ir_convenience
+
+import onnxscript.ir._tape as _tape
+from onnxscript import ir
+
+logger = logging.getLogger(__name__)
+
+
+SUPPORTED_MAX_ONNX_OPSET = 23
+SUPPORTED_MIN_ONNX_OPSET = 18
+
+
+def _get_onnx_opset_version(model: ir.Model) -> int | None:
+    """Get the ONNX opset version imported by the model."""
+    model_version1 = model.opset_imports.get("")
+    model_version2 = model.opset_imports.get("ai.onnx")
+    if model_version1 is not None and model_version2 is not None:
+        if model_version1 != model_version2:
+            raise ValueError(
+                f"Model imports multiple onnx opsets: {model_version1} and {model_version2}."
+            )
+    return model_version1 or model_version2
+
+
+def _set_onnx_opset_version(model: ir.Model, version: int) -> None:
+    """Set the ONNX opset version imported by the model."""
+    if "ai.onnx" in model.opset_imports:
+        del model.opset_imports["ai.onnx"]
+    model.opset_imports[""] = version
+
+
+class VersionConverterError(RuntimeError):
+    """Raised when an node's version cannot be upgraded/downgraded successfully."""
+
+
+@dataclasses.dataclass
+class Replacement:
+    """A replacement for a node in the graph."""
+
+    new_outputs: Sequence[ir.Value]
+    new_nodes: Sequence[ir.Node]
+
+
+# A version-adapter function takes a node, a RewriterContext and returns
+# a Replacement for the node or None (if no replacement is needed).
+
+RewriterContext = _tape.Builder
+ReturnValue = Union[Sequence[ir.Value], ir.Value, None]
+AdapterFunction = Callable[[ir.Node, RewriterContext], ReturnValue]
+
+
+def version_supported(model: ir.Model, target_version: int) -> bool:
+    """Check if the target version is supported by the current version."""
+    if "" in model.graph.opset_imports:
+        current_version = model.graph.opset_imports[""]
+    else:
+        return True
+    return (
+        SUPPORTED_MIN_ONNX_OPSET
+        <= current_version
+        <= target_version
+        <= SUPPORTED_MAX_ONNX_OPSET
+    )
+
+
+class AdapterRegistry:
+    """A class that maintains a registry of adapters for ops."""
+
+    def __init__(self):
+        self.op_adapters: dict[tuple[str, str, int, bool], AdapterFunction] = {}
+
+    def lookup_adapters(
+        self,
+        domain: str,
+        opname: str,
+        original_version: int,
+        up_conversion: bool = True,
+    ) -> AdapterFunction | None:
+        adapter_func = self.op_adapters.get((domain, opname, original_version, up_conversion))
+        if adapter_func is not None:
+            return adapter_func
+        return None
+
+    def register(
+        self, opname: str, domain: str = "", node_version=None, up_conversion=True
+    ) -> Callable[[AdapterFunction], AdapterFunction]:
+        """Register an adapter based on the domain, operator type, node version and whether to upgrade/downgrade node version"""
+
+        def decorator(function: AdapterFunction) -> AdapterFunction:
+            @functools.wraps(function)
+            def wrapped_function(*args, **kwargs):
+                return function(*args, **kwargs)
+
+            self.op_adapters[(domain, opname, node_version, up_conversion)] = function
+            return wrapped_function
+
+        return decorator
+
+
+registry: AdapterRegistry = AdapterRegistry()
+
+register = registry.register
+
+
+def _get_input(node: ir.Node, index: int) -> ir.Value | None:
+    if index < len(node.inputs):
+        return node.inputs[index]
+    return None
+
+
+def _get_int_attribute(node: ir.Node, name: str, default: int | None = None) -> int | None:
+    if name in node.attributes:
+        attr = node.attributes[name]
+        if not isinstance(attr, ir.Attr):
+            return None
+        attr_val = attr.value
+        if isinstance(attr_val, int):
+            return attr_val
+        # This is an invalid model: attribute has invalid/unexpected type.
+        # For now, we just return None. We could raise an error too.
+        return None
+    return default
+
+
+def _get_str_attribute(node: ir.Node, name: str, default: str | None = None) -> str | None:
+    if name in node.attributes:
+        attr = node.attributes[name]
+        if not isinstance(attr, ir.Attr):
+            return None
+        attr_val = attr.value
+        if isinstance(attr_val, str):
+            return attr_val
+        # This is an invalid model: attribute has invalid/unexpected type.
+        # For now, we just return None. We could raise an error too.
+        return None
+    return default
+
+
+## Op-specific adapters
+
+# Opset 19 -> 20
+
+
+@register("DFT", node_version=19, up_conversion=True)
+def dft_19_20(node: ir.Node, op):
+    input = node.inputs[0]
+    inverse = _get_int_attribute(node, "inverse", 0)
+    onesided = _get_int_attribute(node, "onesided", 0)
+    axis = _get_int_attribute(node, "axis", None)
+    if axis is not None:
+        axis_value = op.Constant(value_int=axis)
+        return op.DFT(input, axis_value, inverse=inverse, onesided=onesided)
+    return None
+
+
+@register("GridSample", node_version=19, up_conversion=True)
+def gridsample_19_20(node: ir.Node, op):
+    x = node.inputs[0]
+    grid = node.inputs[1]
+    align_corners = _get_int_attribute(node, "align_corners", 0)
+    mode = _get_str_attribute(node, "mode", "linear")
+    padding_mode = _get_str_attribute(node, "padding_mode", "zeros")
+    if mode == "bilinear":
+        return op.GridSample(
+            x, grid, align_corners=align_corners, mode="linear", padding_mode=padding_mode
+        )
+    elif mode == "bicubic":
+        return op.GridSample(
+            x, grid, align_corners=align_corners, mode="cubic", padding_mode=padding_mode
+        )
+    return None
+
+
+# Opset 20 -> 21
+
+
+@register("GroupNormalization", node_version=20, up_conversion=True)
+def groupnormalization_20_21(node: ir.Node, op):
+    x = _get_input(node, 0)
+    scale = _get_input(node, 1)
+    bias = _get_input(node, 2)
+    if x is None or scale is None or bias is None:
+        raise VersionConverterError(f"Missing input for {node}")
+
+    x_shape = x.shape
+    if x_shape is None:
+        raise VersionConverterError(f"Missing required shape for {x}")
+    num_channels = x_shape[1]
+    if not isinstance(num_channels, int):
+        return None
+
+    scale_shape = scale.shape
+    bias_shape = bias.shape
+    if scale_shape is None or bias_shape is None:
+        return None
+    if not isinstance(scale_shape[0], int) or not isinstance(bias_shape[0], int):
+        return None
+
+    num_groups = _get_int_attribute(node, "num_groups", None)
+    if num_groups is None:
+        raise VersionConverterError("Missing required attribute: num_groups")
+    if (
+        num_groups != num_channels
+        and num_groups == scale_shape[0]
+        and num_groups == bias_shape[0]
+    ):
+        reshape_1_sizes = op.Constant(value_ints=[-1, 1])
+        reshape_2_sizes = op.Constant(value_ints=[-1])
+        c_div = int(num_channels / num_groups)
+        expand_sizes = op.Constant(value_ints=[1, c_div])
+
+        # Modify scale input
+        scale_reshape_1 = op.Reshape(scale, reshape_1_sizes)
+        scale_expand = op.Expand(scale_reshape_1, expand_sizes)
+        scale_reshape_2 = op.Reshape(scale_expand, reshape_2_sizes)
+
+        # Modify bias input
+        bias_reshape_1 = op.Reshape(bias, reshape_1_sizes)
+        bias_expand = op.Expand(bias_reshape_1, expand_sizes)
+        bias_reshape_2 = op.Reshape(bias_expand, reshape_2_sizes)
+
+        return op.GroupNormalization(x, scale_reshape_2, bias_reshape_2, num_groups=num_groups)
+    return None
+
+
+class _VersionConverter:
+    def __init__(self, target_version: int):
+        self._target_version = target_version
+
+    def process_node(
+        self, node: ir.Node, from_version: int, up_conversion: bool = True
+    ) -> Replacement | None:
+        assert node.domain == ""
+        adapter = registry.lookup_adapters(
+            node.domain, node.op_type, from_version, up_conversion
+        )
+        if adapter is None:
+            return None
+        context = RewriterContext()
+        output = adapter(node, context)
+        if output is not None:
+            if isinstance(output, ir.Value):
+                output = [output]
+            return Replacement(output, context.nodes)
+        return None
+
+    def replace_node(self, node: ir.Node, replacement, root: ir.Graph | ir.Function) -> None:
+        logger.debug("Replacing node: %s::%s %s", node.domain, node.op_type, node.name)
+
+        ir_convenience.replace_nodes_and_values(
+            root, node, [node], replacement.new_nodes, node.outputs, replacement.new_outputs
+        )
+
+    def visit_attribute(self, attr: ir.Attr) -> None:
+        if attr.is_ref():
+            return
+        if attr.type == ir.AttributeType.GRAPH:
+            self.visit_graph(attr.as_graph())
+        elif attr.type == ir.AttributeType.GRAPHS:
+            for graph in attr.as_graphs():
+                self.visit_graph(graph)
+
+    def visit_node(
+        self,
+        node: ir.Node,
+        root: ir.Graph | ir.Function,
+        from_version: int,
+        up_conversion: bool = True,
+    ) -> None:
+        if up_conversion:
+            to_version = from_version + 1
+        else:
+            to_version = from_version - 1
+        replacement = self.process_node(node, from_version, up_conversion)
+        if replacement is None:
+            # No change. Process attributes.
+            for attr in node.attributes.values():
+                self.visit_attribute(attr)
+            node.version = to_version
+        else:
+            for new_node in replacement.new_nodes:
+                # TODO: control-flow
+                new_node.version = to_version
+            self.replace_node(node, replacement, root)
+
+    def visit_graph(self, graph: ir.Graph) -> None:
+        for node in graph:
+            if node.domain != "":
+                continue
+            node_version = node.version or self._default_onnx_opset
+            if node_version is None:
+                raise VersionConverterError(f"Node {node} has no version.")
+            # Iterate each node from current node version -> target version
+            # and updating node based on the correct adapter
+            # Up-conversion [ver->ver+1] or down-conversion [ver->ver-1]
+            # TODO(shubhambhokare1): Remove once down-conversion adapters are supoorted
+            if self._target_version < node_version:
+                raise VersionConverterError(
+                    f"Target opset: {self._target_version} less than node version: {node.version}, "
+                    "downstream version conversion not currently handled."
+                )
+            for from_version in range(node_version, self._target_version):
+                try:
+                    self.visit_node(node, graph, from_version, up_conversion=True)
+                except VersionConverterError as e:
+                    logger.warning(
+                        "Skipping version conversion for node %s due to exception: %s",
+                        node.op_type,
+                        e,
+                    )
+
+    def visit_model(self, model: ir.Model) -> None:
+        self._default_onnx_opset = _get_onnx_opset_version(model)
+        self.visit_graph(model.graph)
+        _set_onnx_opset_version(model, self._target_version)
+
+
+def convert_version(model: ir.Model, target_version: int) -> None:
+    """Convert the model to the specified ONNX opset version."""
+    if (target_version > SUPPORTED_MAX_ONNX_OPSET) or (
+        target_version < SUPPORTED_MIN_ONNX_OPSET
+    ):
+        raise ValueError(
+            f"Target opset version {target_version} is not supported. "
+            f"Supported range: {SUPPORTED_MIN_ONNX_OPSET} to {SUPPORTED_MAX_ONNX_OPSET}."
+        )
+    version_converter = _VersionConverter(target_version=target_version)
+    version_converter.visit_model(model)