Op versioning for new registry system

src/qonnx/core/execute_custom_node.py

@@ -27,10 +27,9 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import qonnx.custom_op.registry as registry
-from qonnx.util.basic import get_preferred_onnx_opset
 
 
-def execute_custom_node(node, context, graph, onnx_opset_version=get_preferred_onnx_opset()):
+def execute_custom_node(node, context, graph, onnx_opset_version):
     """Call custom implementation to execute a single custom node.
     Input/output provided via context."""
     op_type = node.op_type

src/qonnx/core/onnx_exec.py

@@ -36,15 +36,10 @@
 import qonnx.analysis.topology as ta
 import qonnx.core.execute_custom_node as ex_cu_node
 from qonnx.custom_op.registry import is_custom_op
-from qonnx.util.basic import (
-    get_preferred_onnx_opset,
-    get_sanitize_quant_tensors,
-    qonnx_make_model,
-    sanitize_quant_values,
-)
+from qonnx.util.basic import get_preferred_qonnx_opset, get_sanitize_quant_tensors, qonnx_make_model, sanitize_quant_values
 
 
-def execute_node(node, context, graph, return_full_exec_context=False, opset_version=get_preferred_onnx_opset()):
+def execute_node(node, context, graph, opset_version, return_full_exec_context=False):
     """Executes a single node by using onnxruntime or with a custom function.
 
     Input/output provided via context."""
@@ -158,7 +153,7 @@ def execute_onnx(model, input_dict, return_full_exec_context=False, start_node=N
     model_exec_mode = model.get_metadata_prop("exec_mode")
     if (model_exec_mode is None) or (model_exec_mode == ""):
         # extract opset version for node-by-node execution
-        opset_version = model.model.opset_import[0].version
+        opset_imports = model.get_opset_imports()
         # execute the model node by node
         # we can simply walk down the list since the ONNX spec guarantees that it is
         # topologically sorted
@@ -176,7 +171,11 @@ def execute_onnx(model, input_dict, return_full_exec_context=False, start_node=N
             if get_sanitize_quant_tensors() != 0:
                 # round input values to match quantization annotation
                 execution_context = sanitize_quant_values(model, node.input, execution_context)
-            execute_node(node, execution_context, graph, return_full_exec_context, opset_version)
+            if node.domain in opset_imports:
+                opset_version = opset_imports[node.domain]
+            else:
+                opset_version = get_preferred_qonnx_opset()
+            execute_node(node, execution_context, graph, opset_version, return_full_exec_context)
             if get_sanitize_quant_tensors() != 0:
                 # round output values to quantization annotation
                 execution_context = sanitize_quant_values(model, node.output, execution_context)

src/qonnx/custom_op/base.py

@@ -30,15 +30,35 @@
 import onnx.numpy_helper as np_helper
 from abc import ABC, abstractmethod
 
-from qonnx.util.basic import get_by_name, get_preferred_onnx_opset
+from qonnx.util.basic import get_by_name, get_preferred_qonnx_opset
 
 
 class CustomOp(ABC):
     """CustomOp class all custom op nodes are based on. Contains different functions
     every custom node should have. Some as abstract methods, these have to be
-    filled when writing a new custom op node."""
+    filled when writing a new custom op node.
 
-    def __init__(self, onnx_node, onnx_opset_version=get_preferred_onnx_opset()):
+    Opset Version Support:
+        CustomOp classes use "since version" semantics matching ONNX operators.
+        Version is determined by the class name using _vN suffix convention:
+
+        - No suffix (e.g., IntQuant): Version 1 (default)
+        - _vN suffix (e.g., IntQuant_v2): Version N
+
+        The registry automatically selects the highest version <= requested opset.
+
+        Example:
+            class IntQuant(CustomOp):
+                pass  # Version 1 (no suffix)
+
+            class IntQuant_v2(CustomOp):
+                pass  # Version 2, covers opset v2-v3 (if no v3 exists)
+
+            class IntQuant_v4(CustomOp):
+                pass  # Version 4, covers opset v4+
+    """
+
+    def __init__(self, onnx_node, onnx_opset_version=get_preferred_qonnx_opset()):
         super().__init__()
         self.onnx_node = onnx_node
         self.onnx_opset_version = onnx_opset_version

src/qonnx/custom_op/channels_last/__init__.py

@@ -1,11 +1,17 @@
 # Importing registers CustomOps in qonnx.custom_op.channels_last domain
-from qonnx.custom_op.channels_last.batch_normalization import BatchNormalization
-from qonnx.custom_op.channels_last.conv import Conv
-from qonnx.custom_op.channels_last.max_pool import MaxPool
+from qonnx.custom_op.channels_last.batch_normalization import (
+    BatchNormalization_v1,
+    BatchNormalization_v9,
+    BatchNormalization_v14,
+)
+from qonnx.custom_op.channels_last.conv import Conv_v1
+from qonnx.custom_op.channels_last.max_pool import MaxPool_v1, MaxPool_v10
 
-# Legacy dictionary for backward compatibility
-custom_op = {
-    "Conv": Conv,
-    "MaxPool": MaxPool,
-    "BatchNormalization": BatchNormalization,
-}
+__all__ = [
+    "Conv_v1",
+    "MaxPool_v1",
+    "MaxPool_v10",
+    "BatchNormalization_v1",
+    "BatchNormalization_v9",
+    "BatchNormalization_v14",
+]

src/qonnx/custom_op/channels_last/batch_normalization.py

@@ -32,7 +32,7 @@
 from qonnx.custom_op.channels_last.base_wrapped_op import ChannelsLastWrappedOp
 
 
-class BatchNormalization(ChannelsLastWrappedOp):
+class BatchNormalization_v1(ChannelsLastWrappedOp):
     def get_nodeattr_types(self):
         """Returns a dict of permitted attributes for node, where:
         ret_dict[attribute_name] = (dtype, require, default_value, <allowed_values>)
@@ -133,3 +133,13 @@ def verify_node(self):
             )
 
         return info_messages
+
+
+class BatchNormalization_v9(BatchNormalization_v1):
+    # no relevant changes for channels-last wrapper
+    pass
+
+
+class BatchNormalization_v14(BatchNormalization_v9):
+    # no relevant changes for channels-last wrapper
+    pass

src/qonnx/custom_op/channels_last/conv.py

@@ -33,7 +33,7 @@
 from qonnx.custom_op.general.im2col import compute_conv_output_dim
 
 
-class Conv(ChannelsLastWrappedOp):
+class Conv_v1(ChannelsLastWrappedOp):
     def get_nodeattr_types(self):
         """Returns a dict of permitted attributes for node, where:
         ret_dict[attribute_name] = (dtype, require, default_value, <allowed_values>)

src/qonnx/custom_op/channels_last/max_pool.py

@@ -33,7 +33,7 @@
 from qonnx.custom_op.general.maxpoolnhwc import compute_pool_output_dim
 
 
-class MaxPool(ChannelsLastWrappedOp):
+class MaxPool_v1(ChannelsLastWrappedOp):
     def get_nodeattr_types(self):
         """Returns a dict of permitted attributes for node, where:
         ret_dict[attribute_name] = (dtype, require, default_value, <allowed_values>)
@@ -171,3 +171,8 @@ def verify_node(self):
             )
 
         return info_messages
+
+
+class MaxPool_v10(MaxPool_v1):
+    # no relevant changes for channels-last wrapper
+    pass

src/qonnx/custom_op/general/__init__.py

@@ -35,23 +35,22 @@
 from qonnx.custom_op.general.intquant import IntQuant
 from qonnx.custom_op.general.maxpoolnhwc import MaxPoolNHWC
 from qonnx.custom_op.general.multithreshold import MultiThreshold
-from qonnx.custom_op.general.quantavgpool2d import QuantAvgPool2d
 from qonnx.custom_op.general.quant import Quant
+from qonnx.custom_op.general.quantavgpool2d import QuantAvgPool2d
 from qonnx.custom_op.general.trunc import Trunc
 from qonnx.custom_op.general.xnorpopcount import XnorPopcountMatMul
 
-# Legacy dictionary for backward compatibility
-custom_op = {
-    "DebugMarker": DebugMarker,
-    "QuantAvgPool2d": QuantAvgPool2d,
-    "MaxPoolNHWC": MaxPoolNHWC,
-    "GenericPartition": GenericPartition,
-    "MultiThreshold": MultiThreshold,
-    "XnorPopcountMatMul": XnorPopcountMatMul,
-    "Im2Col": Im2Col,
-    "IntQuant": IntQuant,
-    "Quant": IntQuant,  # Alias
-    "Trunc": Trunc,
-    "BipolarQuant": BipolarQuant,
-    "FloatQuant": FloatQuant,
-}
+__all__ = [
+    "BipolarQuant",
+    "DebugMarker",
+    "FloatQuant",
+    "GenericPartition",
+    "Im2Col",
+    "IntQuant",
+    "MaxPoolNHWC",
+    "MultiThreshold",
+    "Quant",
+    "QuantAvgPool2d",
+    "Trunc",
+    "XnorPopcountMatMul",
+]

src/qonnx/custom_op/general/maxpoolnhwc.py

@@ -97,10 +97,7 @@ def execute_node(self, context, graph):
         inp_vi = helper.make_tensor_value_info(inp_name, TensorProto.FLOAT, inp.shape)
         out_vi = helper.make_tensor_value_info(out_name, TensorProto.FLOAT, dummy_out.shape)
         tmp_graph = helper.make_graph(nodes=[node], name="tmp_graph", inputs=[inp_vi], outputs=[out_vi])
-        opset_version = self.onnx_opset_version
-        opset_imports = [helper.make_opsetid("", opset_version)]
-        onnx_kwargs = {"opset_imports": opset_imports}
-        tmp_model = qonnx_make_model(tmp_graph, producer_name="finn", **onnx_kwargs)
+        tmp_model = qonnx_make_model(tmp_graph, producer_name="finn")
         tmp_model = ModelWrapper(tmp_model)
         new_ctx = {inp_name: inp}
         from qonnx.core.onnx_exec import execute_onnx

src/qonnx/custom_op/general/quantavgpool2d.py

@@ -33,7 +33,7 @@
 from qonnx.core.datatype import DataType
 from qonnx.custom_op.base import CustomOp
 from qonnx.custom_op.general.maxpoolnhwc import compute_pool_output_dim
-from qonnx.util.basic import qonnx_make_model
+from qonnx.util.basic import get_preferred_onnx_opset, qonnx_make_model
 
 
 class QuantAvgPool2d(CustomOp):
@@ -132,7 +132,7 @@ def execute_node(self, context, graph):
             outputs=[outp],
         )
 
-        opset_version = self.onnx_opset_version
+        opset_version = get_preferred_onnx_opset()
         opset_imports = [helper.make_opsetid("", opset_version)]
         onnx_kwargs = {"opset_imports": opset_imports}
         model_avgpool = qonnx_make_model(graph_avgpool, **onnx_kwargs)