onnx-diagnostic 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

onnx_diagnostic/__init__.py

@@ -3,5 +3,5 @@ Patches, Investigates onnx models.
 Functions, classes to dig into a model when this one is right, slow, wrong...
 """
 
-__version__ = "0.6.1"
+__version__ = "0.6.2"
 __author__ = "Xavier Dupré"

onnx_diagnostic/helpers/doc_helper.py

@@ -0,0 +1,143 @@
+from typing import Dict, Optional, Tuple
+import onnx
+import onnx.helper as oh
+import torch
+from ..reference.torch_ops import OpRunKernel, OpRunTensor
+from .torch_helper import onnx_dtype_to_torch_dtype, torch_dtype_to_onnx_dtype
+from .ort_session import InferenceSessionForTorch
+
+
+class LayerNormalizationOrt(OpRunKernel):
+    "LayerNormalization with onnxruntime"
+
+    @classmethod
+    def device_dependent(cls) -> bool:
+        "Needs device."
+        return False
+
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version=None,
+        device: Optional[torch.device] = None,
+        verbose=0,
+    ):
+        super().__init__(node, version, verbose=verbose)
+        self.axis = self.get_attribute_int(node, "axis", -1)
+        self.epsilon = self.get_attribute_float(node, "epsilon", 1e-5)
+        self.device = device
+        self.stash_type = onnx_dtype_to_torch_dtype(
+            self.get_attribute_int(node, "stash_type", onnx.TensorProto.FLOAT)  # type: ignore[arg-type]
+        )
+        self.compute_std = len(node.output) > 1
+        assert not self.compute_std, (
+            f"This kernel implementation only work when only one output "
+            f"is required but {node.output} were."
+        )
+        self._cache: Dict[Tuple[int, int], onnx.ModelProto] = {}
+        self.is_cpu = torch.device("cpu") == self.device
+
+    def _make_model(self, itype: int, rank: int, has_bias: bool) -> onnx.ModelProto:
+        shape = [*["d{i}" for i in range(rank - 1)], "last"]
+        layer_model = oh.make_model(
+            oh.make_graph(
+                [
+                    oh.make_node(
+                        "LayerNormalization",
+                        ["X", "W", "B"] if has_bias else ["X", "W"],
+                        ["Z"],
+                        axis=self.axis,
+                        epsilon=self.epsilon,
+                    )
+                ],
+                "dummy",
+                (
+                    [
+                        oh.make_tensor_value_info("X", itype, shape),
+                        oh.make_tensor_value_info("W", itype, ["last"]),
+                        oh.make_tensor_value_info("B", itype, ["last"]),
+                    ]
+                    if has_bias
+                    else [
+                        oh.make_tensor_value_info("X", itype, shape),
+                        oh.make_tensor_value_info("W", itype, ["last"]),
+                    ]
+                ),
+                [oh.make_tensor_value_info("Z", itype, shape)],
+            ),
+            ir_version=9,
+            opset_imports=[oh.make_opsetid("", 18)],
+        )
+        provider = "CPUExecutionProvider" if self.is_cpu else "CUDAExecutionProvider"
+        self._provider = provider
+        return InferenceSessionForTorch(layer_model, providers=[provider])
+
+    def run(self, x, scale, bias=None):
+        itype = torch_dtype_to_onnx_dtype(x.dtype)
+        rank = len(x.shape)
+        key = itype, rank
+        if key not in self._cache:
+            self._cache[key] = self._make_model(itype, rank, bias is not None)
+        sess = self._cache[key]
+        if self.verbose:
+            print(f"[LayerNormalizationOrt] running on {self._provider!r}")
+        feeds = dict(X=x.tensor, W=scale.tensor)
+        if bias is not None:
+            feeds["B"] = bias.tensor
+        got = sess.run(None, feeds)[0]
+        return OpRunTensor(got)
+
+
+class MatMulOrt(OpRunKernel):
+    "MatMul with onnxruntime"
+
+    @classmethod
+    def device_dependent(cls) -> bool:
+        "Needs device."
+        return False
+
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version=None,
+        device: Optional[torch.device] = None,
+        verbose=0,
+    ):
+        super().__init__(node, version, verbose=verbose)
+        self.device = device
+        self._cache: Dict[Tuple[int, int, int], onnx.ModelProto] = {}
+        self.is_cpu = torch.device("cpu") == self.device
+
+    def _make_model(self, itype: int, ranka: int, rankb: int) -> onnx.ModelProto:
+        shapea = ["a{i}" for i in range(ranka)]
+        shapeb = ["b{i}" for i in range(rankb)]
+        shapec = ["c{i}" for i in range(max(ranka, rankb))]
+        model = oh.make_model(
+            oh.make_graph(
+                [oh.make_node("MatMul", ["A", "B"], ["C"])],
+                "dummy",
+                [
+                    oh.make_tensor_value_info("A", itype, shapea),
+                    oh.make_tensor_value_info("B", itype, shapeb),
+                ],
+                [oh.make_tensor_value_info("C", itype, shapec)],
+            ),
+            ir_version=9,
+            opset_imports=[oh.make_opsetid("", 18)],
+        )
+        provider = "CPUExecutionProvider" if self.is_cpu else "CUDAExecutionProvider"
+        self._provider = provider
+        return InferenceSessionForTorch(model, providers=[provider])
+
+    def run(self, a, b):
+        itype = torch_dtype_to_onnx_dtype(a.dtype)
+        ranka, rankb = len(a.shape), len(b.shape)
+        key = itype, ranka, rankb
+        if key not in self._cache:
+            self._cache[key] = self._make_model(itype, ranka, rankb)
+        sess = self._cache[key]
+        if self.verbose:
+            print(f"[MatMulOrt] running on {self._provider!r}")
+        feeds = dict(A=a.tensor, B=b.tensor)
+        got = sess.run(None, feeds)[0]
+        return OpRunTensor(got)

onnx_diagnostic/reference/torch_evaluator.py

@@ -9,7 +9,7 @@ from . import torch_ops
 
 
 @functools.lru_cache
-def get_kernels() -> Dict[Tuple[str, str, int], type[torch_ops.OpRun]]:
+def get_kernels() -> Dict[Tuple[str, str, int], type[torch_ops.OpRunKernel]]:
     """
     Retrieves all the available kernels class :class:`TorchOnnxEvaluator`
     can use. The full list is the following.
@@ -28,7 +28,7 @@ def get_kernels() -> Dict[Tuple[str, str, int], type[torch_ops.OpRun]]:
     """
     res = {}
     for _k, v in torch_ops.__dict__.items():
-        if isinstance(v, type) and issubclass(v, torch_ops.OpRun) and "_" in v.__name__:
+        if isinstance(v, type) and issubclass(v, torch_ops.OpRunKernel) and "_" in v.__name__:
             name, version = v.__name__.split("_")
             domain = getattr(v, "domain", "")
             res[domain, name, int(version)] = v
@@ -45,6 +45,8 @@ class TorchOnnxEvaluator:
     :param opsets: needed if proto is a graph
     :param functions: known local functions
     :param verbose: verbosity level
+    :param custom_kernels: dictionary of kernels the user can defined to overwrite
+        a specific implementation: ``("", "LayerNormalization"): CustomKernel``
 
     The class holds the following attributes:
 
@@ -98,7 +100,10 @@ class TorchOnnxEvaluator:
         result = sess.run(None, feeds)
         print(string_type(result, with_shape=True, with_min_max=True))
 
-    Adding ``verbose=1`` shows which kernels is executed:
+    With ``verbose=1``, the class prints out every kernel run and
+    and every result deleted along the run.
+    It shows when a result is not needed anymore. In that case,
+    it is deleted to free the memory it takes.
 
     .. runpython::
         :showcode:
@@ -134,8 +139,6 @@ class TorchOnnxEvaluator:
         result = sess.run(None, feeds)
         print(string_type(result, with_shape=True, with_min_max=True))
 
-    It also shows when a result is not needed anymore. In that case,
-    it is deleted to free the memory it takes.
     The runtime can also execute the kernel the onnx model on CUDA.
     It follows the same logic as :class:`onnxruntime.InferenceSession`:
     ``providers=["CUDAExecutionProvider"]``.
@@ -144,6 +147,115 @@ class TorchOnnxEvaluator:
     identified as a shape in CPU. Some bugs may remain as torch
     raises an exception when devices are expected to be the same.
     The runtime was validated with model :epkg:`arnir0/Tiny-LLM`.
+    Next example shows how to replace a kernel with a different
+    one based on :epkg:`onnxruntime`.
+
+    .. runpython::
+        :showcode:
+
+        import numpy as np
+        import onnx
+        import onnx.helper as oh
+        import onnxruntime
+        import torch
+        from onnx_diagnostic.helpers import string_type
+        from onnx_diagnostic.helpers.torch_helper import onnx_dtype_to_torch_dtype
+        from onnx_diagnostic.reference import TorchOnnxEvaluator
+        from onnx_diagnostic.reference.torch_ops import OpRunKernel, OpRunTensor
+
+        TFLOAT16 = onnx.TensorProto.FLOAT16
+
+        class LayerNormalizationOrt(OpRunKernel):
+            "LayerNormalization based on onnxruntime"
+
+            def __init__(self, node: onnx.NodeProto, version=None):
+                super().__init__(node, version)
+                self.axis = self.get_attribute_int(node, "axis", -1)
+                self.epsilon = self.get_attribute_float(node, "epsilon", 1e-5)
+                self.stash_type = onnx_dtype_to_torch_dtype(
+                    self.get_attribute_int(node, "stash_type", onnx.TensorProto.FLOAT)
+                )
+                self.compute_std = len(node.output) > 1
+                assert not self.compute_std, "The keren only computes the first output."
+                layer_model = oh.make_model(
+                    oh.make_graph(
+                        [
+                            oh.make_node(
+                                "LayerNormalization",
+                                ["X", "W", "B"],
+                                ["Z"],
+                                axis=-1,
+                                epsilon=9.999999974752427e-7,
+                            )
+                        ],
+                        "dummy",
+                        [
+                            oh.make_tensor_value_info("X", TFLOAT16, ["b", "c", "d"]),
+                            oh.make_tensor_value_info("W", TFLOAT16, ["d"]),
+                            oh.make_tensor_value_info("B", TFLOAT16, ["d"]),
+                        ],
+                        [oh.make_tensor_value_info("Z", TFLOAT16, ["b", "c", "d"])],
+                    ),
+                    ir_version=9,
+                    opset_imports=[oh.make_opsetid("", 17)],
+                )
+                self.ort_sess = onnxruntime.InferenceSession(
+                    layer_model.SerializeToString(), providers=["CUDAExecutionProvider"]
+                )
+
+            def run(self, x, scale, bias=None):
+                print(f"-- running {self.__class__.__name__}")
+                feeds = dict(X=x, W=scale)
+                if bias is not None:
+                    feeds["B"] = bias
+                feeds = {k: v.tensor.detach().cpu().numpy() for k, v in feeds.items()}
+                got = self.ort_sess.run(None, feeds)[0]
+                return OpRunTensor(torch.from_numpy(got).to(x.dtype).to(x.device))
+
+        # This kernel is tested on this model.
+        model = oh.make_model(
+            oh.make_graph(
+                [
+                    oh.make_node(
+                        "LayerNormalization",
+                        ["X", "W", "B"],
+                        ["ln"],
+                        axis=-1,
+                        epsilon=9.999999974752427e-7,
+                    ),
+                    oh.make_node(
+                        "Add", ["ln", "W"], ["Z"], axis=-1, epsilon=9.999999974752427e-7
+                    ),
+                ],
+                "dummy",
+                [
+                    oh.make_tensor_value_info("X", TFLOAT16, ["b", "c", "d"]),
+                    oh.make_tensor_value_info("W", TFLOAT16, ["d"]),
+                    oh.make_tensor_value_info("B", TFLOAT16, ["d"]),
+                ],
+                [oh.make_tensor_value_info("Z", TFLOAT16, ["b", "c", "d"])],
+            ),
+            ir_version=9,
+            opset_imports=[oh.make_opsetid("", 17)],
+        )
+
+        torch_sess = TorchOnnxEvaluator(
+            model,
+            custom_kernels={("", "LayerNormalization"): LayerNormalizationOrt},
+            verbose=1,
+        )
+        feeds = dict(
+            zip(
+                torch_sess.input_names,
+                [
+                    torch.rand(3, 4, 5, dtype=torch.float16),
+                    torch.abs(torch.rand(5, dtype=torch.float16)),
+                    torch.rand(5, dtype=torch.float16),
+                ],
+            )
+        )
+        res = torch_sess.run(None, feeds)
+        print(string_type(res, with_shape=True, with_min_max=True))
     """
 
     class IO:
@@ -172,13 +284,15 @@ class TorchOnnxEvaluator:
         opsets: Optional[Dict[str, int]] = None,
         local_functions: Optional[Dict[Tuple[str, str], "TorchOnnxEvaluator"]] = None,
         verbose: int = 0,
+        custom_kernels: Optional[Dict[Tuple[str, str], type[torch_ops.OpRunKernel]]] = None,
     ):
         self.providers = providers
         self.constants: Dict[str, torch.Tensor] = {}
-        self.kernels: List[Optional[torch_ops.OpRun]] = []
+        self.kernels: List[Optional[torch_ops.OpRunKernel]] = []
         self.functions = local_functions.copy() if local_functions else {}
         self.CPU = torch.tensor([0]).to("cpu").device
         self.verbose = verbose
+        self.custom_kernels = custom_kernels or {}
         dev = self._on_cuda(providers)
         if dev < 0:
             self.default_device = self.CPU
@@ -296,9 +410,24 @@ class TorchOnnxEvaluator:
         kernels = get_kernels()
         self.kernels.clear()
         for node in nodes:
+            kernel_kwargs = dict(verbose=max(0, self.verbose - 1))
+            opset = self.opsets[node.domain]
+            key = node.domain, node.op_type, opset
+            if key[:2] in self.custom_kernels:
+                cls = self.custom_kernels[key[:2]]
+                ags = [self.default_device] if cls.device_dependent() else []
+                kws = dict(parent=self) if cls.has_subgraphs() else {}
+                kws.update(kernel_kwargs)  # type: ignore[arg-type]
+                kernel2 = cls(node, opset, *ags, **kws)  # type: ignore[arg-type]
+                self.kernels.append(kernel2)
+                continue
+
             if (node.domain, node.op_type) in self.functions:
                 kernel = torch_ops.OpRunFunction(
-                    self.functions[node.domain, node.op_type], node, self.opsets[node.domain]
+                    self.functions[node.domain, node.op_type],
+                    node,
+                    self.opsets[node.domain],
+                    **kernel_kwargs,
                 )
                 self.kernels.append(kernel)
                 continue
@@ -308,8 +437,6 @@ class TorchOnnxEvaluator:
                 self.kernels.append(None)
                 continue
 
-            opset = self.opsets[node.domain]
-            key = node.domain, node.op_type, opset
             while key not in kernels and opset > 0:
                 opset -= 1
                 key = node.domain, node.op_type, opset
@@ -320,7 +447,8 @@ class TorchOnnxEvaluator:
             cls = kernels[key]
             ags = [self.default_device] if cls.device_dependent() else []
             kws = dict(parent=self) if cls.has_subgraphs() else {}
-            kernel2 = cls(node, opset, *ags, **kws)
+            kws.update(kernel_kwargs)  # type: ignore[arg-type]
+            kernel2 = cls(node, opset, *ags, **kws)  # type: ignore[arg-type]
             self.kernels.append(kernel2)
 
     def run(
@@ -438,7 +566,9 @@ class TorchOnnxEvaluator:
         context: Optional[Dict[str, RuntimeValue]] = None,
     ) -> Union[torch_ops.OpRunValue, Tuple[torch_ops.OpRunValue, ...]]:
         """
-        Runs the ONNX model.
+        Runs the ONNX model. The signature is different.
+        This method is called by every kernel hokding a subgraph.
+        The local variables are stored in `context`.
 
         :param args: inputs
         :param context: local context for the execution of subgraphs

onnx_diagnostic/reference/torch_ops/__init__.py

@@ -1,4 +1,4 @@
-from ._op_run import OpRun, OpRunFunction, OpRunSequence, OpRunTensor, OpRunValue
+from ._op_run import OpRunKernel, OpRunFunction, OpRunSequence, OpRunTensor, OpRunValue
 from .access_ops import Gather_1, ScatterND_16, Slice_13
 from .binary_ops import (
     And_1,

onnx_diagnostic/reference/torch_ops/_op_run.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional, Union, Tuple
+from typing import Any, Dict, List, Optional, Union, Tuple
 import onnx
 import torch
 from ...api import TensorLike
@@ -167,7 +167,7 @@ class OpRunSequence(OpRunValue):
         return string_type(self.sequence, with_shape=True)
 
 
-class OpRun:
+class OpRunKernel:
     """
     Main class. Every kernel should inherit from it.
     It does not copy the proto.
@@ -185,7 +185,13 @@ class OpRun:
         """Returns True if the kernel has subgraphs."""
         return False
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version: Optional[int] = None,
+        verbose: int = 0,
+        custom_kernels: Optional[Dict[Tuple[str, str], type]] = None,
+    ):
         assert isinstance(
             node, onnx.NodeProto
         ), f"node must be a NodeProto but node is {type(node)}"
@@ -193,6 +199,8 @@ class OpRun:
         self.domain = node.domain
         self.input = node.input
         self.output = node.output
+        self.verbose = verbose
+        self.custom_kernels = custom_kernels
         if version is None:
             name = self.__class__.__name__.split("_")
             assert (
@@ -305,7 +313,7 @@ class OpRun:
         return tuple(t.to(device) for t in tensors)
 
 
-class OpRunFunction(OpRun):
+class OpRunFunction(OpRunKernel):
     """
     Defines a kernel based on a local functions.
     """
@@ -315,8 +323,9 @@ class OpRunFunction(OpRun):
         runtime: "onnx_diagnostic.reference.TorchOnnxEvaluator",  # noqa: F821
         node: onnx.NodeProto,
         version: Optional[int] = None,
+        verbose: int = 0,
     ):
-        super().__init__(node, version)
+        super().__init__(node, version, verbose=verbose)
         self.runtime = runtime
         self.input_names = runtime.input_names
 

onnx_diagnostic/reference/torch_ops/access_ops.py

@@ -1,14 +1,19 @@
 from typing import Optional
 import onnx
 import torch
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class Gather_1(OpRun):
+class Gather_1(OpRunKernel):
     "Gather"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version: Optional[int] = None,
+        verbose: int = 0,
+    ):
+        super().__init__(node, version, verbose=verbose)
         axis = self.get_attribute_int(node, "axis", 0)
         assert isinstance(axis, int), f"Unexpected value for attribute axis={axis!r}"
         self.axis = axis
@@ -21,11 +26,16 @@ class Gather_1(OpRun):
         return OpRunTensor(x.tensor[tuple(ind)])
 
 
-class ScatterND_16(OpRun):
+class ScatterND_16(OpRunKernel):
     "ScatterND"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version: Optional[int] = None,
+        verbose: int = 0,
+    ):
+        super().__init__(node, version, verbose=verbose)
         self.reduction = self.get_attribute_string(node, "reduction", "none")
 
     def run(
@@ -54,7 +64,7 @@ class ScatterND_16(OpRun):
         return OpRunTensor(output)
 
 
-class Slice_13(OpRun):
+class Slice_13(OpRunKernel):
     "Slice"
 
     def run(

onnx_diagnostic/reference/torch_ops/binary_ops.py

@@ -1,8 +1,8 @@
 import torch
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class OpRunBinary(OpRun):
+class OpRunBinary(OpRunKernel):
     "Binary Op"
 
     def run(self, x: OpRunTensor, y: OpRunTensor) -> OpRunTensor:

onnx_diagnostic/reference/torch_ops/controlflow_ops.py

@@ -1,10 +1,10 @@
 from typing import Any, Dict, Optional
 import onnx
 import torch
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class OpRunControlFlow(OpRun):
+class OpRunControlFlow(OpRunKernel):
     """Common ancestor for control flows."""
 
     @classmethod
@@ -17,8 +17,9 @@ class OpRunControlFlow(OpRun):
         node: onnx.NodeProto,
         version: Optional[int] = None,
         parent: Optional["onnx_diagnostic.reference.TorchOnnxEvaluator"] = None,  # noqa: F821
+        verbose: int = 0,
     ):
-        super().__init__(node, version)
+        super().__init__(node, version, verbose=verbose)
         assert (
             parent is not None
         ), f"parent must be specified for operator {self.__class__.__name__!r}"
@@ -30,6 +31,7 @@ class OpRunControlFlow(OpRun):
                     opsets=parent.opsets,
                     local_functions=parent.functions,
                     verbose=parent.verbose,
+                    custom_kernels=parent.custom_kernels,
                 )
                 setattr(self, att.name, rt)
 
@@ -50,8 +52,9 @@ class Loop_16(OpRunControlFlow):
         node: onnx.NodeProto,
         version: Optional[int] = None,
         parent: Optional["onnx_diagnostic.reference.TorchOnnxEvaluator"] = None,  # noqa: F821
+        verbose: int = 0,
     ):
-        super().__init__(node, version, parent)
+        super().__init__(node, version, parent, verbose=verbose)
         self.output_index = {n: i for i, n in enumerate(self.body.output_names)}
         self.N = len(self.body.input_names) - 2
         self.K = len(self.body.output_names) - self.N - 1

onnx_diagnostic/reference/torch_ops/generator_ops.py

@@ -1,10 +1,10 @@
 from typing import Optional
 import onnx
 import torch
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class Range_11(OpRun):
+class Range_11(OpRunKernel):
     """Range"""
 
     @classmethod
@@ -19,8 +19,9 @@ class Range_11(OpRun):
         node: onnx.NodeProto,
         version: Optional[int] = None,
         device: Optional[torch.device] = None,
+        verbose: int = 0,
     ):
-        super().__init__(node, version)
+        super().__init__(node, version, verbose=verbose)
         self.device = device
 
     def run(self, starts: OpRunTensor, limit: OpRunTensor, delta: OpRunTensor) -> OpRunTensor:

onnx_diagnostic/reference/torch_ops/nn_ops.py

@@ -2,14 +2,19 @@ from typing import Optional, Tuple
 import onnx
 import torch
 from ...helpers.torch_helper import onnx_dtype_to_torch_dtype
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class AveragePool_11(OpRun):
+class AveragePool_11(OpRunKernel):
     "AveragePool"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version: Optional[int] = None,
+        verbose: int = 0,
+    ):
+        super().__init__(node, version, verbose=verbose)
         self.auto_pad = self.get_attribute_string(node, "auto_pad", "NOTSET")
         self.ceil_mode = bool(self.get_attribute_int(node, "ceil_mode", 0))
         self.count_include_pad = bool(self.get_attribute_int(node, "count_include_pad", 0))
@@ -44,11 +49,16 @@ class AveragePool_11(OpRun):
         )
 
 
-class Conv_11(OpRun):
+class Conv_11(OpRunKernel):
     "Conv"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version: Optional[int] = None,
+        verbose: int = 0,
+    ):
+        super().__init__(node, version, verbose=verbose)
         self.auto_pad = self.get_attribute_string(node, "auto_pad", "NOTSET")
         self.dilations = self.get_attribute_ints(node, "dilations", None)
         self.group = self.get_attribute_int(node, "group", 1)
@@ -108,11 +118,16 @@ class Conv_11(OpRun):
         )
 
 
-class LayerNormalization_17(OpRun):
+class LayerNormalization_17(OpRunKernel):
     "LayerNormalization"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version: Optional[int] = None,
+        verbose: int = 0,
+    ):
+        super().__init__(node, version, verbose=verbose)
         self.axis = self.get_attribute_int(node, "axis", -1)
         self.epsilon = self.get_attribute_float(node, "epsilon", 1e-5)
         self.stash_type = onnx_dtype_to_torch_dtype(
@@ -152,11 +167,16 @@ class LayerNormalization_17(OpRun):
         )
 
 
-class Softmax_13(OpRun):
+class Softmax_13(OpRunKernel):
     "Softmax"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(
+        self,
+        node: onnx.NodeProto,
+        version: Optional[int] = None,
+        verbose: int = 0,
+    ):
+        super().__init__(node, version, verbose=verbose)
         self.axis = self.get_attribute_int(node, "axis", -1)
         assert isinstance(self.axis, int), f"Unexpected value for attribute axis={self.axis!r}"
         # this is out of spec
@@ -169,7 +189,7 @@ class Softmax_13(OpRun):
         )
 
 
-class Tanh_6(OpRun):
+class Tanh_6(OpRunKernel):
     "Tanh"
 
     def run(self, data: OpRunTensor) -> OpRunTensor:

onnx_diagnostic/reference/torch_ops/other_ops.py

@@ -2,14 +2,14 @@ from typing import Optional
 import onnx
 import torch
 from ...helpers.torch_helper import onnx_dtype_to_torch_dtype
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class Cast_6(OpRun):
+class Cast_6(OpRunKernel):
     "Cast"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         to = self.get_attribute_int(node, "to", 0)
         assert isinstance(to, int), f"Unexpected value for attribute to={to!r}"
         self.to = onnx_dtype_to_torch_dtype(to)
@@ -20,11 +20,11 @@ class Cast_6(OpRun):
         return OpRunTensor(data.tensor.to(self.to))
 
 
-class CastLike_15(OpRun):
+class CastLike_15(OpRunKernel):
     "Cast"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.saturate = self.get_attribute_int(node, "saturate", 1)
         assert self.saturate == 1, f"saturate={self.saturate} not implemented for CastLike"
 
@@ -32,11 +32,11 @@ class CastLike_15(OpRun):
         return OpRunTensor(data.tensor.to(like.tensor.dtype))
 
 
-class Concat_1(OpRun):
+class Concat_1(OpRunKernel):
     "Concat"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         axis = self.get_attribute_int(node, "axis", 0)
         assert isinstance(axis, int), f"Unexpected value for attribute axis={axis!r}"
         self.axis = axis
@@ -59,36 +59,36 @@ class Concat_1(OpRun):
         return OpRunTensor(torch.cat([t.tensor.to(device) for t in data], axis=self.axis))
 
 
-class NonZero_13(OpRun):
+class NonZero_13(OpRunKernel):
     "NonZero"
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(torch.nonzero(x.tensor).T)
 
 
-class Tile_6(OpRun):
+class Tile_6(OpRunKernel):
     "Tile"
 
     def run(self, x: OpRunTensor, repeat: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(torch.tile(x.tensor, repeat.as_tuple_int))
 
 
-class Transpose_1(OpRun):
+class Transpose_1(OpRunKernel):
     "Transpose"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.perm = self.get_attribute_ints(node, "perm", None)
 
     def run(self, data: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(torch.permute(data.tensor, self.perm))
 
 
-class Trilu_14(OpRun):
+class Trilu_14(OpRunKernel):
     "Trilu"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.upper = self.get_attribute_int(node, "upper", 1)
 
     def run(self, data: OpRunTensor, k: Optional[OpRunTensor] = None) -> OpRunTensor:
@@ -98,7 +98,7 @@ class Trilu_14(OpRun):
         return OpRunTensor(torch.tril(data.tensor, diagonal=diagonal))
 
 
-class Where_9(OpRun):
+class Where_9(OpRunKernel):
     "Where"
 
     def run(self, cond: OpRunTensor, x: OpRunTensor, y: OpRunTensor) -> OpRunTensor:

onnx_diagnostic/reference/torch_ops/reduce_ops.py

@@ -2,12 +2,12 @@ from typing import Optional, Tuple
 import onnx
 import torch
 from ...helpers.torch_helper import onnx_dtype_to_torch_dtype
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class ReduceOp(OpRun):
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+class ReduceOp(OpRunKernel):
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.keepdims = bool(self.get_attribute_int(node, "keepdims", 1))
         self.noop_with_empty_axes = bool(
             self.get_attribute_int(node, "noop_with_empty_axes", 0)
@@ -28,8 +28,8 @@ class ReduceOp(OpRun):
 
 
 class ReduceOpAxes(ReduceOp):
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.axes: Tuple[int, ...] = self.get_attribute_ints(node, "axes") or tuple()
 
 

onnx_diagnostic/reference/torch_ops/sequence_ops.py

@@ -2,18 +2,18 @@ from typing import Optional
 import onnx
 import torch
 from ...helpers.torch_helper import onnx_dtype_to_torch_dtype
-from . import OpRun, OpRunSequence, OpRunTensor
+from . import OpRunKernel, OpRunSequence, OpRunTensor
 
 
-class OpRunOpSequence(OpRun):
+class OpRunOpSequence(OpRunKernel):
     "Ancestor for kernel using sequences."
 
 
 class ConcatFromSequence_11(OpRunOpSequence):
     "ConcatFromSequence"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         axis = self.get_attribute_int(node, "axis", None)
         assert isinstance(axis, int), f"Unexpected value for attribute axis={axis!r}"
         self.axis = axis
@@ -39,8 +39,8 @@ class ConcatFromSequence_11(OpRunOpSequence):
 class SequenceEmpty_11(OpRunOpSequence):
     "SqeuenceEmpty"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.dtype = onnx_dtype_to_torch_dtype(
             self.get_attribute_int(node, "dtype", onnx.TensorProto.FLOAT)  # type: ignore[arg-type]
         )

onnx_diagnostic/reference/torch_ops/shape_ops.py

@@ -1,10 +1,10 @@
 from typing import Optional, Tuple
 import onnx
 import torch
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class ConstantOfShape_9(OpRun):
+class ConstantOfShape_9(OpRunKernel):
     "ConstantOfShape"
 
     @classmethod
@@ -19,8 +19,9 @@ class ConstantOfShape_9(OpRun):
         node: onnx.NodeProto,
         version: Optional[int] = None,
         device: Optional[torch.device] = None,
+        verbose: int = 0,
     ):
-        super().__init__(node, version)
+        super().__init__(node, version, verbose=verbose)
         value = self.get_attribute_tensor(node, "value")
         if value is None:
             value = torch.tensor([0], dtype=torch.float32)
@@ -37,7 +38,7 @@ class ConstantOfShape_9(OpRun):
         )
 
 
-class Expand_8(OpRun):
+class Expand_8(OpRunKernel):
     "Expand"
 
     def run(self, data: OpRunTensor, shape: OpRunTensor) -> OpRunTensor:
@@ -45,11 +46,11 @@ class Expand_8(OpRun):
         return OpRunTensor(data.tensor.expand(ishape))
 
 
-class Reshape_14(OpRun):
+class Reshape_14(OpRunKernel):
     "Reshape"
 
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.allowzero = self.get_attribute_int(node, "allowzero", 0)
 
     def run(self, data: OpRunTensor, shape: OpRunTensor) -> OpRunTensor:
@@ -64,9 +65,9 @@ class Reshape_14(OpRun):
         return OpRunTensor(data.tensor.reshape(ishape))
 
 
-class Shape_15(OpRun):
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+class Shape_15(OpRunKernel):
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.start = self.get_attribute_int(node, "start", 0)
         self.end = self.get_attribute_int(node, "end", None)
 
@@ -76,9 +77,9 @@ class Shape_15(OpRun):
         return OpRunTensor(torch.tensor(sh, dtype=torch.int64), is_constant=True)
 
 
-class Split_18(OpRun):
-    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None):
-        super().__init__(node, version)
+class Split_18(OpRunKernel):
+    def __init__(self, node: onnx.NodeProto, version: Optional[int] = None, verbose: int = 0):
+        super().__init__(node, version, verbose=verbose)
         self.axis = self.get_attribute_int(node, "axis", 0)
         self.num_outputs = self.get_attribute_int(node, "num_outputs", None)
 
@@ -101,7 +102,7 @@ class Split_18(OpRun):
         return tuple(OpRunTensor(t) for t in spl)
 
 
-class Squeeze_13(OpRun):
+class Squeeze_13(OpRunKernel):
     "Squeeze"
 
     def run(self, data: OpRunTensor, axes: Optional[OpRunTensor] = None) -> OpRunTensor:
@@ -110,7 +111,7 @@ class Squeeze_13(OpRun):
         return OpRunTensor(data.tensor.squeeze(axes.as_tuple_int))
 
 
-class Unsqueeze_13(OpRun):
+class Unsqueeze_13(OpRunKernel):
     "Unsqueeze"
 
     def run(self, data: OpRunTensor, axes: OpRunTensor) -> OpRunTensor:

onnx_diagnostic/reference/torch_ops/unary_ops.py

@@ -1,85 +1,85 @@
 import torch
-from . import OpRun, OpRunTensor
+from . import OpRunKernel, OpRunTensor
 
 
-class Abs_1(OpRun):
+class Abs_1(OpRunKernel):
     """Abs"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(torch.abs(x.tensor))
 
 
-class Cos_1(OpRun):
+class Cos_1(OpRunKernel):
     """Cos"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(x.tensor.cos())
 
 
-class Erf_9(OpRun):
+class Erf_9(OpRunKernel):
     """Erf"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(x.tensor.erf())
 
 
-class Exp_1(OpRun):
+class Exp_1(OpRunKernel):
     """Exp"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(x.tensor.exp())
 
 
-class Identity_1(OpRun):
+class Identity_1(OpRunKernel):
     "Identity"
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(x.tensor)
 
 
-class Log_1(OpRun):
+class Log_1(OpRunKernel):
     """Log"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(x.tensor.log())
 
 
-class Neg_1(OpRun):
+class Neg_1(OpRunKernel):
     """Neg"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(-x.tensor)
 
 
-class Not_1(OpRun):
+class Not_1(OpRunKernel):
     """Not"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(~x.tensor)
 
 
-class Reciprocal_1(OpRun):
+class Reciprocal_1(OpRunKernel):
     """REciprocal"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(1 / x.tensor)
 
 
-class Sigmoid_6(OpRun):
+class Sigmoid_6(OpRunKernel):
     """Sqrt"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(torch.sigmoid(x.tensor))
 
 
-class Sin_1(OpRun):
+class Sin_1(OpRunKernel):
     """Sin"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:
         return OpRunTensor(x.tensor.sin())
 
 
-class Sqrt_1(OpRun):
+class Sqrt_1(OpRunKernel):
     """Sqrt"""
 
     def run(self, x: OpRunTensor) -> OpRunTensor:

onnx_diagnostic/torch_models/test_helper.py

@@ -278,6 +278,8 @@ def validate_model(
 ) -> Tuple[Dict[str, Union[int, float, str]], Dict[str, Any]]:
     """
     Validates a model.
+    The function can also be called through the command line
+    :ref:`l-cmd-validate`.
 
     :param model_id: model id to validate
     :param task: task used to generate the necessary inputs,
@@ -285,7 +287,8 @@ def validate_model(
         if it can be determined
     :param do_run: checks the model works with the defined inputs
     :param exporter: exporter the model using this exporter,
-        available list: ``export-strict``, ``export-nostrict``, ``onnx``
+        available list: ``export-strict``, ``export-nostrict``, ...
+        see below
     :param do_same: checks the discrepancies of the exported model
     :param verbose: verbosity level
     :param dtype: uses this dtype to check the model
@@ -322,6 +325,20 @@ def validate_model(
     information:
 
     * ``PRINT_CONFIG``: prints the model configuration
+
+    The following exporters are available:
+
+    * ``export-nostrict``: run :func:`torch.export.export` (..., strict=False)
+    * ``onnx-dynamo``: run :func:`torch.onnx.export` (..., dynamo=True),
+      models can be optimized with ``optimization`` in ``("ir", "os_ort")``
+    * ``modelbuilder``: use :epkg:`ModelBuilder` to builds the onnx model
+    * ``custom``: custom exporter (see :epkg:`experimental-experiment`),
+      models can be optimized with ``optimization`` in
+      ``("default", "default+onnxruntime", "default+os_ort", "default+onnxruntime+os_ort")``
+
+    The default runtime, :epkg:`onnxruntime` is used to validate a model and check the
+    exported model returns the same outputs as the original one, otherwise,
+    :class:`onnx_diagnostic.reference.TorchOnnxEvaluator` is used.
     """
     assert (
         not rewrite or patch

{onnx_diagnostic-0.6.1.dist-info → onnx_diagnostic-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.6.1
+Version: 0.6.2
 Summary: Investigate ONNX models
 Home-page: https://github.com/sdpython/onnx-diagnostic
 Author: Xavier Dupré

{onnx_diagnostic-0.6.1.dist-info → onnx_diagnostic-0.6.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onnx_diagnostic/__init__.py,sha256=yCtQh931_2K3SHqvkJ_EVFSKxjtdNDc21rdCxdemDBM,173
+onnx_diagnostic/__init__.py,sha256=P1AdnI_jw7SIojX7zxqBeAy83xQePX59KApD_RBNnOY,173
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
 onnx_diagnostic/_command_lines_parser.py,sha256=WSoopSHjXWEgFvzyfGe3_c-hZoStuQPQc_k08siFuf4,19211
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
@@ -12,6 +12,7 @@ onnx_diagnostic/helpers/args_helper.py,sha256=SRWnqC7EENg09RZlA50B_PcdiIhdbgA4C3
 onnx_diagnostic/helpers/bench_run.py,sha256=CGA6VMJZMH2gDhVueT9ypNm4PMcjGrrGFYp08nhWj9k,16539
 onnx_diagnostic/helpers/cache_helper.py,sha256=soKjyIXa7EQgALd9PAUGIKYzXlJGoLevYiQDsxoqkQ4,8349
 onnx_diagnostic/helpers/config_helper.py,sha256=aZATKVbZuw8L56KQpwMNcqJ3Qi5OplzS_N3ETR3hmj0,3351
+onnx_diagnostic/helpers/doc_helper.py,sha256=RLNqNrZx9NxwaryVu8NcImV9l9azEoK9OpQn3gqBxds,5328
 onnx_diagnostic/helpers/graph_helper.py,sha256=hevQT5a7_QuriVPQcbT5qe18n99Doyl5h3-qshx1-uk,14093
 onnx_diagnostic/helpers/helper.py,sha256=oPybQruFcVLqvqLDhjphOZ8zZU1HHJWAlABMuTkAO8A,57090
 onnx_diagnostic/helpers/memory_peak.py,sha256=OT6mz0muBbBZY0pjgW2_eCk_lOtFRo-5w4jFo2Z6Kok,6380
@@ -25,7 +26,7 @@ onnx_diagnostic/reference/__init__.py,sha256=nrd09rRuwMDBCPTSZ6kSKZXp1W9W_ExO1t9
 onnx_diagnostic/reference/evaluator.py,sha256=RzNzjFDeMe-4X51Tb22N6aagazY5ktNq-mRmPcfY5EU,8848
 onnx_diagnostic/reference/ort_evaluator.py,sha256=OaWMREF8fuJwimmONpIjQ6WxQT1X2roDsdJsgR8H_Cg,24853
 onnx_diagnostic/reference/quantized_tensor.py,sha256=5u67uS2uGacdMD5VYCbpojNjiesDlV_kO0fAJ0vUWGE,1098
-onnx_diagnostic/reference/torch_evaluator.py,sha256=uvcpDROoCDd8Rln_kieNRfraNg9j1FD39n1xiGNh3LA,20825
+onnx_diagnostic/reference/torch_evaluator.py,sha256=ekQTYo0YPVdcM6TGRnEk0mDmGHUOwi0OpcMOWJsRvT8,26572
 onnx_diagnostic/reference/ops/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 onnx_diagnostic/reference/ops/op_add_add_mul_mul.py,sha256=CXQVtgVrT066gDJFwxL4nDSY4G8r08XNu3EwhWqMapU,1521
 onnx_diagnostic/reference/ops/op_attention.py,sha256=ThALMDF53v3QeG1bohi0bvX2o90HZhGJbbAFOtwEHPE,2027
@@ -55,18 +56,18 @@ onnx_diagnostic/reference/ops/op_skip_layer_normalization.py,sha256=oJ7fQNx2iQh9
 onnx_diagnostic/reference/ops/op_slice.py,sha256=yRxfYBs8b7QezyyG9JHCD8MIJHij2qR2NNDpBmD3FJI,705
 onnx_diagnostic/reference/ops/op_transpose_cast.py,sha256=ifef74rvh0Yvq1Zx51B4mfnISbxV9uRg9DFjkdL1_68,361
 onnx_diagnostic/reference/ops/op_tri_matrix.py,sha256=Yn2gxAyygcwtF5Hjau9ihXDAzul0BAkdqVimVahtFBU,519
-onnx_diagnostic/reference/torch_ops/__init__.py,sha256=DzuCaiKbzJnkXprJVbVJwA7A29w6T_W1_plB_ZXDQsk,1144
-onnx_diagnostic/reference/torch_ops/_op_run.py,sha256=1nnW6Ub3jWkS-HI3--dhYNXRLqy9Ppe7F9kOeGGYRhw,10253
-onnx_diagnostic/reference/torch_ops/access_ops.py,sha256=sLiTbZUfNbATQxVpq2Rv8n6cbV4jJmQlWHUVIds_GlY,3102
-onnx_diagnostic/reference/torch_ops/binary_ops.py,sha256=774QlWFPvNtNhwxtLb-d28jhTO8U0cthoJKHjM89WrA,2641
-onnx_diagnostic/reference/torch_ops/controlflow_ops.py,sha256=EsiMFmLHxFHprCSz9OLlYxo3sMaF9czj-4NOFkHZH5c,4362
-onnx_diagnostic/reference/torch_ops/generator_ops.py,sha256=oxoeg7YxQiEaC20qOFI-BwQuBtkxN7y9XD9o3gPjPkI,871
-onnx_diagnostic/reference/torch_ops/nn_ops.py,sha256=wzXuBfMsA1aQPQDi4qAv0oZ8kB1qwt4reQ8LiWg1ulo,6906
-onnx_diagnostic/reference/torch_ops/other_ops.py,sha256=bIZsyqrRfTI1xiC4WvV5LcQawsy4gqqci9EgOO9rk9c,3766
-onnx_diagnostic/reference/torch_ops/reduce_ops.py,sha256=oeA-NNJ1MFQD7xG5RD61_3SQhXvpJpNXKZ-_0rFikjE,5020
-onnx_diagnostic/reference/torch_ops/sequence_ops.py,sha256=q1bwFI1zUO69KrOOAbNFqBhz1s9YkqxV1kCaBmgIoYI,2215
-onnx_diagnostic/reference/torch_ops/shape_ops.py,sha256=1pR-3EwhuMpAE-B2TUJs83GxDGITaLBHKxExJ-Ie1EE,4095
-onnx_diagnostic/reference/torch_ops/unary_ops.py,sha256=T3EtQW0p_kNN-OhjVsk1STZ0uWxXyB-rYO-lIp3gXuU,1630
+onnx_diagnostic/reference/torch_ops/__init__.py,sha256=eZ7FBYH9Ta3BC0f7BJQAnIqiebqRkCt2_T3ktpVV6iQ,1150
+onnx_diagnostic/reference/torch_ops/_op_run.py,sha256=EEUIwfbRldEFDhULquYhk9x5ZDa9t6f2mKJ1sM__D6A,10517
+onnx_diagnostic/reference/torch_ops/access_ops.py,sha256=Zfs5OF03PV1CqlCqKI5VV-c4MY3KyQxmO7QZksxQjX8,3274
+onnx_diagnostic/reference/torch_ops/binary_ops.py,sha256=-KxMcCYGDTcZyOss9qU1nU0rmdyg9SdVHJQohseSTcQ,2653
+onnx_diagnostic/reference/torch_ops/controlflow_ops.py,sha256=uOEmzbM4nR2FwZQ8UikwEaHih3yw6T24D_VLYkr5RSU,4518
+onnx_diagnostic/reference/torch_ops/generator_ops.py,sha256=dqqFvhkazVxRUDYhO2t-Z1etqoUt30LeX-8Pb9ZcbaM,926
+onnx_diagnostic/reference/torch_ops/nn_ops.py,sha256=TeFxQEiTezx9UUzu82ToCLUnUOU56kKv6X81RdZ8UC8,7238
+onnx_diagnostic/reference/torch_ops/other_ops.py,sha256=FnCY60mhdrzrsiHgvN-XpFRHYUpI0gIRqxgVK5J_na0,3995
+onnx_diagnostic/reference/torch_ops/reduce_ops.py,sha256=9gFfraPTQbe_ZEUNCUis1JSmA5dj4tSzjAOpZPJKG4Y,5102
+onnx_diagnostic/reference/torch_ops/sequence_ops.py,sha256=3EiVKpGfN4d1Iry4hgnr3MIJyEEKUrAIDgmRGsUXXa0,2297
+onnx_diagnostic/reference/torch_ops/shape_ops.py,sha256=pJrNR2UB4PlWl6cv4EDl1uGl8YTBUUMQkhJcsh5K4sA,4291
+onnx_diagnostic/reference/torch_ops/unary_ops.py,sha256=E8Ys1eZsOTsucBKoXb1_Kl5LbBDygniDvW2BvN4IPMo,1708
 onnx_diagnostic/tasks/__init__.py,sha256=5XXM-rv-Hk2gSHvqsww9DzVd9mcRifacgcPgvPCjnDM,2412
 onnx_diagnostic/tasks/automatic_speech_recognition.py,sha256=oRoYy56M0Yv_WOcn1hJXv-R9wgHkJ8rbym7j7y8oslw,6851
 onnx_diagnostic/tasks/feature_extraction.py,sha256=V-T5NpZ6EimOz00weWWxGfksZ9jQ5ZQyaP-mxuCEuJo,2223
@@ -95,7 +96,7 @@ onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=KaZ8TjDa9ATgT
 onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=Hf-U50vzgzJ4iUjS2LAYkbfmzCEwX80Dzvdrr-Rhlp0,26456
 onnx_diagnostic/torch_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_models/llms.py,sha256=soyg4yC87ptGoeulJhKqw5opGmuLvH1pn_ZDXZ4Jr8E,90
-onnx_diagnostic/torch_models/test_helper.py,sha256=72HE_fY0m9TNly1w_b2dD-P67eSLJreOMYtT6W6CLfQ,58704
+onnx_diagnostic/torch_models/test_helper.py,sha256=32uFEZwILyOWHrj-qaNfIv4P2ySe7A0lN2WQ4eVEudA,59604
 onnx_diagnostic/torch_models/hghub/__init__.py,sha256=vi1Q7YHdddj1soiBN42MSvJdFqe2_KUoWafHISjwOu8,58
 onnx_diagnostic/torch_models/hghub/hub_api.py,sha256=BgM_p57Q0gT9GOhdrmOYcnbuTTzCWp80jS4OQqWwFhs,9990
 onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=885wKyZkdM-Qp5Sg6C9Ol1dxigmA8FYAko-Ys08sppo,8096
@@ -107,8 +108,8 @@ onnx_diagnostic/torch_models/untrained/llm_tiny_llm.py,sha256=7N3fGvT_4Mn4NbIo0Q
 onnx_diagnostic/torch_onnx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_onnx/runtime_info.py,sha256=1g9F_Jf9AAgYQU4stbsrFXwQl-30mWlQrFbQ7val8Ps,9268
 onnx_diagnostic/torch_onnx/sbs.py,sha256=1EL25DeYFzlBSiFG_XjePBLvsiItRXbdDrr5-QZW2mA,16878
-onnx_diagnostic-0.6.1.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.6.1.dist-info/METADATA,sha256=j0i2pgpY_6bD7IFlqqdmIZSVSvv67Q-7X4N4fih-2JQ,6643
-onnx_diagnostic-0.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_diagnostic-0.6.1.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.6.1.dist-info/RECORD,,
+onnx_diagnostic-0.6.2.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.6.2.dist-info/METADATA,sha256=GwbmPUz9oOj_KKA_164p9H-RxNtpGz1Smn-eTJm4sGA,6643
+onnx_diagnostic-0.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.6.2.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.6.2.dist-info/RECORD,,