onnx 1.15.0__cp311-cp311-win_amd64.whl → 1.16.1__cp311-cp311-win_amd64.whl

onnx/test/version_converter/automatic_upgrade_test.py

@@ -14,12 +14,14 @@ from onnx import TensorProto, helper
 # to the most recent version and runs checker and shape inference on the final upgraded model.
 ####################################################################################
 
-tested_ops = []
-
 
 class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversion):
+    @classmethod
+    def setUpClass(cls):
+        cls.tested_ops = []
+
     def _test_op_upgrade(self, op, *args, **kwargs):
-        tested_ops.append(op)
+        self.tested_ops.append(op)
         self._test_op_conversion(op, *args, **kwargs, is_upgrade=True)
 
     def test_Abs(self) -> None:
@@ -1739,9 +1741,10 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
         )
 
     def test_ops_tested(self) -> None:
+        # NOTE: This test is order dependent and needs to run last in this class
         all_schemas = onnx.defs.get_all_schemas()
-        all_op_names = [schema.name for schema in all_schemas if schema.domain == ""]
-        excluded_ops = [
+        all_op_names = {schema.name for schema in all_schemas if schema.domain == ""}
+        excluded_ops = {
             # Sequence-based and Optional-based ops disabled because
             # the version converter doesn't play nicely with sequences
             "ConcatFromSequence",
@@ -1757,12 +1760,11 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
             "OptionalGetElement",
             "OptionalHasElement",
             "StringSplit",
-        ]
-        all_op_names = [op for op in all_op_names if op not in excluded_ops]
+        }
+        expected_tested_ops = all_op_names - excluded_ops
 
-        untested_ops = set(all_op_names) - set(tested_ops)
-        print(untested_ops)
-        assert len(untested_ops) == 0
+        untested_ops = expected_tested_ops - set(self.tested_ops)
+        self.assertEqual(untested_ops, set())
 
 
 if __name__ == "__main__":

onnx/test/version_converter_test.py

@@ -2,10 +2,13 @@
 
 # SPDX-License-Identifier: Apache-2.0
 
+import contextlib
 import struct
 import unittest
+from typing import Optional, Tuple
 
 import numpy as np
+import parameterized
 
 import onnx.version_converter
 from onnx import (
@@ -1984,6 +1987,169 @@ class TestVersionConverter(unittest.TestCase):
         assert converted_model.graph.node[3].op_type == "Reshape"
         assert converted_model.opset_import[0].version == 13
 
+    @parameterized.parameterized.expand(
+        [
+            ("per_tensor", (16, 3), (1,), None, None, None, TensorProto.INT8, True),
+            (
+                "per_axis_none_block_shape",
+                (16, 3),
+                (16,),
+                1,
+                None,
+                None,
+                TensorProto.INT8,
+                True,
+            ),
+            (
+                "per_axis_zero_block_shape",
+                (16, 3),
+                (16,),
+                1,
+                0,
+                None,
+                TensorProto.INT8,
+                True,
+            ),
+            (
+                "per_tensor_positive_block_shape",
+                (16, 3),
+                (1,),
+                1,
+                2,
+                None,
+                TensorProto.INT8,
+                False,
+            ),
+            (
+                "per_axis_positive_block_shape",
+                (16, 3),
+                (16,),
+                1,
+                2,
+                None,
+                TensorProto.INT8,
+                False,
+            ),
+            ("blocked_2d", (16, 3), (4, 3), 0, 4, None, TensorProto.INT8, False),
+            ("blocked_3d", (4, 3, 32), (4, 3, 8), 2, 4, None, TensorProto.INT8, False),
+            (
+                "per_axis_output_dtype",
+                (16, 3),
+                (16,),
+                1,
+                None,
+                TensorProto.FLOAT8E4M3FN,
+                None,
+                False,
+            ),
+            (
+                "per_axis_unsupported_type",
+                (16, 3),
+                (16,),
+                1,
+                None,
+                None,
+                TensorProto.UINT16,
+                False,
+            ),
+        ]
+    )
+    def test_quantize_21_20(
+        self,
+        _: str,
+        x_shape: Tuple[int, ...],
+        scale_shape: Tuple[int, ...],
+        axis: int,
+        block_size: int,
+        output_dtype: Optional[int],
+        zero_point_dtype: Optional[int],
+        compatible: bool,
+    ) -> None:
+        def test(
+            input_shape, scale_shape, axis, block_size, output_dtype, zero_point_dtype
+        ) -> None:
+            nodes = [
+                helper.make_node(
+                    "QuantizeLinear",
+                    ["X", "S"],
+                    ["Y"],
+                    axis=axis,
+                    block_size=block_size,
+                    output_dtype=output_dtype,
+                )
+            ]
+            inputs = [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, input_shape),
+                helper.make_tensor_value_info("S", TensorProto.FLOAT, scale_shape),
+            ]
+            if zero_point_dtype:
+                inputs.append(
+                    helper.make_tensor_value_info("ZP", zero_point_dtype, scale_shape)
+                )
+                nodes[0].input.append("ZP")
+            output_type_ = output_dtype or zero_point_dtype
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                inputs,
+                [helper.make_tensor_value_info("Y", output_type_, input_shape)],
+            )
+            _ = self._converted(graph, helper.make_operatorsetid("", 21), 20)
+
+        context_manager = (
+            contextlib.nullcontext() if compatible else self.assertRaises(RuntimeError)
+        )
+        with context_manager:  # type: ignore[attr-defined]
+            test(x_shape, scale_shape, axis, block_size, output_dtype, zero_point_dtype)
+
+    @parameterized.parameterized.expand(
+        [
+            ("per_tensor", (16, 3), (1,), None, None, True),
+            ("per_axis_none_block_shape", (16, 3), (16,), 1, None, True),
+            ("per_axis_zero_block_shape", (16, 3), (16,), 1, 0, True),
+            ("per_tensor_positive_block_shape", (16, 3), (1,), 1, 2, False),
+            ("per_axis_positive_block_shape", (16, 3), (16,), 1, 2, False),
+            ("blocked_2d", (16, 3), (4, 3), 0, 4, False),
+            ("blocked_3d", (4, 3, 32), (4, 3, 8), 2, 4, False),
+        ]
+    )
+    def test_dequantize_21_20(
+        self,
+        _: str,
+        y_shape: Tuple[int, ...],
+        scale_shape: Tuple[int, ...],
+        axis: int,
+        block_size: int,
+        compatible: bool,
+    ) -> None:
+        def test(input_shape, scale_shape, axis, block_size) -> None:
+            nodes = [
+                helper.make_node(
+                    "DequantizeLinear",
+                    ["X", "S", "ZP"],
+                    ["Y"],
+                    axis=axis,
+                    block_size=block_size,
+                )
+            ]
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                [
+                    helper.make_tensor_value_info("X", TensorProto.INT8, input_shape),
+                    helper.make_tensor_value_info("S", TensorProto.FLOAT, scale_shape),
+                    helper.make_tensor_value_info("ZP", TensorProto.INT8, scale_shape),
+                ],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, input_shape)],
+            )
+            _ = self._converted(graph, helper.make_operatorsetid("", 21), 20)
+
+        context_manager = (
+            contextlib.nullcontext() if compatible else self.assertRaises(RuntimeError)
+        )
+        with context_manager:  # type: ignore[attr-defined]
+            test(y_shape, scale_shape, axis, block_size)
+
 
 if __name__ == "__main__":
     unittest.main()

onnx/tools/replace_constants.py

@@ -31,10 +31,7 @@ from onnx.numpy_helper import from_array
 def _replace_constant(
     node: NodeProto, threshold: int, value_constant_of_shape: float
 ) -> List[NodeProto]:
-    """
-    Replaces a Constant node with a large tensor (with more than threshold elements)
-    by a sequence of nodes that produces a dummy constant of same shape as original tensor.
-    """
+    """Replaces a Constant node with a large tensor (with more than threshold elements) by a sequence of nodes that produces a dummy constant of same shape as original tensor."""
     if node.op_type != "Constant":
         raise TypeError(f"Node type must be 'Constant' not {node.op_type!r}.")
     for att in node.attribute:
@@ -74,12 +71,11 @@ def _replace_constant(
 def _replace_constant_of_shape_with_range(
     onx: Union[GraphProto, FunctionProto]
 ) -> Union[GraphProto, FunctionProto]:
-    """
-    Replaces all *ConstantOfShape* by node *Range* to avoid constant tensors.
+    """Replaces all *ConstantOfShape* by node *Range* to avoid constant tensors.
+
     The function is not recursive. The recursivity is done by
     *replace_initializer_by_constant_of_shape*.
     """
-
     if isinstance(onx, GraphProto):
         nodes = list(onx.node)
     elif isinstance(onx, FunctionProto):
@@ -163,11 +159,7 @@ def _replace_constant_of_shape_with_range(
 def _replace_constant_of_shape_value(
     onx: Union[GraphProto, FunctionProto], value_constant_of_shape: float
 ) -> Union[GraphProto, FunctionProto]:
-    """
-    Replaces all fill value of all nodes *ConstantOfShape*.
-    *replace_initializer_by_constant_of_shape*.
-    """
-
+    """Replaces all fill value of all nodes *ConstantOfShape*."""
     if isinstance(onx, GraphProto):
         nodes = list(onx.node)
     elif isinstance(onx, FunctionProto):
@@ -226,20 +218,25 @@ def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
     use_range: bool = False,
     value_constant_of_shape: float = 0.5,
 ):
-    """
-    Replace initializers or constant node by nodes *ConstantOfShape* to reduce
-    the size. This reduce the cost to write a unit test about
-    a specific graph structure.
-
-    :param onx: ModelProto
-    :param threshold: every initializer under this threshold is not impacted
-    :param ir_version: initializer must be specified as input for `ir_version <= 3`,
-        this must be specified if onx is :class:`FunctionProto` or :class:`GraphProto`
-    :param use_range: if uses operator *Range* instead of *ConstantOfShape* to avoid
-        constant tensors
-    :param value_constant_of_shape: value to use as a value for all nodes *ConstantOfShape*,
-        a high value may produce nan or inf predictions
-    :return: onx, modified ModelProto
+    """Replace initializers or constant node by nodes *ConstantOfShape* to reduce the size.
+
+    This reduce the cost to write a unit test about a specific graph structure.
+
+    Args:
+        onx: ModelProto
+        threshold: every initializer under this threshold is not
+            impacted
+        ir_version: initializer must be specified as input for
+            `ir_version <= 3`, this must be specified if onx is
+            :class:`FunctionProto` or :class:`GraphProto`
+        use_range: if uses operator *Range* instead of *ConstantOfShape*
+            to avoid constant tensors
+        value_constant_of_shape: value to use as a value for all nodes
+            *ConstantOfShape*, a high value may produce nan or inf
+            predictions
+
+    Returns:
+        onx, modified ModelProto
 
     The function is designed so that the function can be reapplied on a modified model
     and either replace *ConstantOfShape* with *Range* operators, either replace the fill value

onnx/tools/update_model_dims.py

@@ -13,8 +13,7 @@ def update_inputs_outputs_dims(
     input_dims: Dict[str, List[Any]],
     output_dims: Dict[str, List[Any]],
 ) -> ModelProto:
-    """
-    This function updates the dimension sizes of the model's inputs and outputs to the values
+    """This function updates the dimension sizes of the model's inputs and outputs to the values
     provided in input_dims and output_dims. if the dim value provided is negative, a unique dim_param
     will be set for that dimension.
 

onnx/version.py

@@ -1,5 +1,5 @@
 # This file is generated by setup.py. DO NOT EDIT!
 
 
-version = "1.15.0"
-git_version = "b86cc54efce19530fb953e4b21f57e6b3888534c"
+version = "1.16.1"
+git_version = "595228d99e3977ac27cb79d5963adda262af99ad"

onnx/version_converter/adapters/group_normalization_20_21.h

@@ -0,0 +1,128 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Adapter for GroupNormalization in default domain from version 20 to 21
+
+#pragma once
+
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class GroupNormalization_20_21 final : public Adapter {
+ public:
+  explicit GroupNormalization_20_21() : Adapter("GroupNormalization", OpSetID(20), OpSetID(21)) {}
+
+  void transform_input(
+      std::shared_ptr<Graph> graph,
+      Node* node,
+      int64_t input_id,
+      Value* reshape0_shape,
+      Value* reshape1_shape,
+      Value* expand_shape) const {
+    Node* reshape0 = graph->create(kReshape);
+    reshape0->addInput(node->inputs()[input_id]);
+    reshape0->addInput(reshape0_shape);
+    reshape0->insertBefore(node);
+
+    Node* expand = graph->create(kExpand);
+    expand->addInput(reshape0->output());
+    expand->addInput(expand_shape);
+    expand->insertBefore(node);
+
+    Node* reshape1 = graph->create(kReshape);
+    reshape1->addInput(expand->output());
+    reshape1->addInput(reshape1_shape);
+    reshape1->insertBefore(node);
+
+    node->replaceInput(input_id, reshape1->output());
+  }
+
+  void adapt_group_normalization_20_21(std::shared_ptr<Graph> graph, Node* node) const {
+    // Perform following sequence of ops on scale/bias, effect is similar to numpy.repeat()
+    //
+    //   Shape<start=1,end=2>(input0) -- Div(Shape_out (C), num_groups)
+    //                                                           |
+    // Reshape(input1/2, [-1, 1]) ----------- Expand(Reshape_out, [1, Div_out]) -- Reshape(Expand_out, [-1])
+    //
+    // The helper function transform_input() implements the bottom row of the diagram
+
+    // Get number of channels: C
+    Symbol kShape("Shape");
+    Node* C = graph->create(kShape);
+    C->i_(kstart, 1);
+    C->i_(kend, 2);
+    C->addInput(node->inputs()[0]);
+    C->insertBefore(node);
+
+    // Get number of channels per group
+    Tensor tensor_num_groups;
+    tensor_num_groups.elem_type() = TensorProto_DataType_INT64;
+    int64_t num_groups = node->i(knum_groups);
+    tensor_num_groups.sizes() = {1};
+    tensor_num_groups.int64s() = {num_groups};
+    Node* constant_num_groups = graph->create(kConstant);
+    constant_num_groups->t_(kvalue, tensor_num_groups);
+    constant_num_groups->insertBefore(node);
+
+    Node* div = graph->create(kDiv);
+    div->addInput(C->output());
+    div->addInput(constant_num_groups->output());
+    div->insertBefore(node);
+
+    // Get Expand shape: [1, Div_out]
+    Tensor tensor_one;
+    tensor_one.elem_type() = TensorProto_DataType_INT64;
+    tensor_one.sizes() = {1};
+    tensor_one.int64s() = {1};
+    Node* constant_one = graph->create(kConstant);
+    constant_one->t_(kvalue, tensor_one);
+    constant_one->insertBefore(node);
+    Node* concat = graph->create(kConcat);
+    concat->i_(kaxis, 0);
+    concat->addInput(constant_one->output());
+    concat->addInput(div->output());
+    concat->insertBefore(node);
+
+    // Get shape of first reshape: [-1, 1]
+    Tensor tensor_reshape0_shape;
+    tensor_reshape0_shape.elem_type() = TensorProto_DataType_INT64;
+    tensor_reshape0_shape.sizes() = {2};
+    tensor_reshape0_shape.int64s() = {-1, 1};
+    Node* constant_reshape0_shape = graph->create(kConstant);
+    constant_reshape0_shape->t_(kvalue, tensor_reshape0_shape);
+    constant_reshape0_shape->insertBefore(node);
+
+    // Get shape of last reshape: [-1]
+    Tensor tensor_reshape1_shape;
+    tensor_reshape1_shape.elem_type() = TensorProto_DataType_INT64;
+    tensor_reshape1_shape.sizes() = {1};
+    tensor_reshape1_shape.int64s() = {-1};
+    Node* constant_reshape1_shape = graph->create(kConstant);
+    constant_reshape1_shape->t_(kvalue, tensor_reshape1_shape);
+    constant_reshape1_shape->insertBefore(node);
+
+    // transform scale and bias
+    transform_input(
+        graph, node, 1, constant_reshape0_shape->output(), constant_reshape1_shape->output(), concat->output());
+    transform_input(
+        graph, node, 2, constant_reshape0_shape->output(), constant_reshape1_shape->output(), concat->output());
+
+    // Set stash_type
+    node->i_(kstash_type, node->inputs()[0]->elemType());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_group_normalization_20_21(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE

onnx/version_converter/adapters/q_dq_21_20.h

@@ -0,0 +1,77 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Adapter for Cast in default domain from version 9 to 8
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/type_restriction.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+static const std::vector<TensorProto_DataType> q_dq_20_unallowed_types = {
+    TensorProto_DataType_UINT16,
+    TensorProto_DataType_INT16,
+    TensorProto_DataType_UINT4,
+    TensorProto_DataType_INT4};
+
+class QuantizeLinear_21_20 final : public TypeRestriction {
+ public:
+  explicit QuantizeLinear_21_20()
+      : TypeRestriction("QuantizeLinear", OpSetID(21), OpSetID(20), q_dq_20_unallowed_types) {}
+
+  void adapt_quantize_linear_21_20(std::shared_ptr<Graph>, Node* node) const {
+    if (node->hasAttribute(kblock_size)) {
+      if ((node->i(kblock_size) != 0)) {
+        ONNX_ASSERTM(false, "Blocked quantization is not supported for Opset Version %d.", target_version().version())
+      }
+      node->removeAttribute(kblock_size);
+    }
+    if (node->hasAttribute(koutput_dtype)) {
+      if (node->i(koutput_dtype) != TensorProto_DataType_UINT8 && node->inputs().size() < 3) {
+        ONNX_ASSERTM(
+            false,
+            "Attribute output_dtype is not supported for Opset Version %d, supply a zero-point tensor instead",
+            target_version().version())
+      }
+      node->removeAttribute(koutput_dtype);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_type_restriction(graph, node);
+    adapt_quantize_linear_21_20(graph, node);
+    return node;
+  }
+};
+
+class DequantizeLinear_21_20 final : public TypeRestriction {
+ public:
+  explicit DequantizeLinear_21_20()
+      : TypeRestriction("DequantizeLinear", OpSetID(21), OpSetID(20), q_dq_20_unallowed_types) {}
+
+  void adapt_dequantize_linear_21_20(std::shared_ptr<Graph>, Node* node) const {
+    if (node->hasAttribute(kblock_size)) {
+      if ((node->i(kblock_size) != 0)) {
+        ONNX_ASSERTM(false, "Blocked quantization is not supported for Opset Version %d.", target_version().version())
+      }
+      node->removeAttribute(kblock_size);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_type_restriction(graph, node);
+    adapt_dequantize_linear_21_20(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE

onnx/version_converter/convert.h

@@ -32,9 +32,11 @@
 #include "onnx/version_converter/adapters/gemm_6_7.h"
 #include "onnx/version_converter/adapters/gemm_7_6.h"
 #include "onnx/version_converter/adapters/gridsample_19_20.h"
+#include "onnx/version_converter/adapters/group_normalization_20_21.h"
 #include "onnx/version_converter/adapters/maxpool_8_7.h"
 #include "onnx/version_converter/adapters/no_previous_version.h"
 #include "onnx/version_converter/adapters/pad_10_11.h"
+#include "onnx/version_converter/adapters/q_dq_21_20.h"
 #include "onnx/version_converter/adapters/reshape_4_5.h"
 #include "onnx/version_converter/adapters/reshape_5_4.h"
 #include "onnx/version_converter/adapters/resize_10_11.h"
@@ -591,7 +593,7 @@ class DefaultVersionConverter : public BaseVersionConverter {
         TensorProto_DataType_FLOAT8E4M3FNUZ,
         TensorProto_DataType_FLOAT8E5M2,
         TensorProto_DataType_FLOAT8E5M2FNUZ};
-    registerAdapter(std::make_unique<TypeRestriction>("IsNaN", OpSetID(19), OpSetID(20), is_nan_13_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("IsNaN", OpSetID(20), OpSetID(19), is_nan_13_unallowed_types));
     const std::vector<TensorProto_DataType> is_inf_10_unallowed_types = {
         TensorProto_DataType_FLOAT16,
         TensorProto_DataType_BFLOAT16,
@@ -599,13 +601,76 @@ class DefaultVersionConverter : public BaseVersionConverter {
         TensorProto_DataType_FLOAT8E4M3FNUZ,
         TensorProto_DataType_FLOAT8E5M2,
         TensorProto_DataType_FLOAT8E5M2FNUZ};
-    registerAdapter(std::make_unique<TypeRestriction>("IsInf", OpSetID(19), OpSetID(20), is_inf_10_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("IsInf", OpSetID(20), OpSetID(19), is_inf_10_unallowed_types));
     registerAdapter(std::make_unique<AxisInputToAttribute>("DFT", OpSetID(20), OpSetID(19), 2, -2));
     const std::vector<TensorProto_DataType> reduce_min_max_18_unallowed_types = {TensorProto_DataType_BOOL};
     registerAdapter(
         std::make_unique<TypeRestriction>("ReduceMax", OpSetID(20), OpSetID(19), reduce_min_max_18_unallowed_types));
     registerAdapter(
         std::make_unique<TypeRestriction>("ReduceMin", OpSetID(20), OpSetID(19), reduce_min_max_18_unallowed_types));
+
+    /******** 20 -> 21 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<GroupNormalization_20_21>());
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QLinearMatMul", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GroupNormalization", OpSetID(20), OpSetID(21)));
+
+    /******** 21 -> 20 ********/
+    const std::vector<TensorProto_DataType> q_dq_20_unallowed_types = {
+        TensorProto_DataType_UINT16, TensorProto_DataType_INT16, TensorProto_DataType_UINT4, TensorProto_DataType_INT4};
+    const std::vector<TensorProto_DataType> q_dqmm_20_unallowed_types = {
+        TensorProto_DataType_BFLOAT16,
+        TensorProto_DataType_FLOAT16,
+        TensorProto_DataType_UINT4,
+        TensorProto_DataType_INT4};
+    const std::vector<TensorProto_DataType> ir10_types_not_in_ir9 = {
+        TensorProto_DataType_UINT4, TensorProto_DataType_INT4};
+    const std::vector<TensorProto_DataType> ir10_types_not_in_ir4 = {
+        TensorProto_DataType_FLOAT8E4M3FN,
+        TensorProto_DataType_FLOAT8E4M3FNUZ,
+        TensorProto_DataType_FLOAT8E5M2,
+        TensorProto_DataType_FLOAT8E5M2FNUZ,
+        TensorProto_DataType_UINT4,
+        TensorProto_DataType_INT4};
+
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<DequantizeLinear_21_20>());
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QLinearMatMul", OpSetID(21), OpSetID(20), q_dqmm_20_unallowed_types));
+    registerAdapter(std::make_unique<QuantizeLinear_21_20>());
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
   }
 
   ModelProto convert_version(const ModelProto& mp_in, const OpSetID& initial_version, const OpSetID& target_version)