onnx-diagnostic 0.6.2__py3-none-any.whl → 0.6.3__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.2"
+__version__ = "0.6.3"
 __author__ = "Xavier Dupré"

onnx_diagnostic/_command_lines_parser.py

@@ -191,24 +191,45 @@ def get_parser_find() -> ArgumentParser:
         "--names",
         type=str,
         required=False,
-        help="names to look at comma separated values",
+        help="names to look at comma separated values, if 'SHADOW', "
+        "search for shadowing names",
     )
     parser.add_argument(
         "-v",
         "--verbose",
         default=0,
+        type=int,
         required=False,
         help="verbosity",
     )
+    parser.add_argument(
+        "--v2",
+        default=False,
+        action=BooleanOptionalAction,
+        help="use enumerate_results instead of onnx_find",
+    )
     return parser
 
 
 def _cmd_find(argv: List[Any]):
-    from .helpers.onnx_helper import onnx_find
+    from .helpers.onnx_helper import onnx_find, enumerate_results, shadowing_names
 
     parser = get_parser_find()
     args = parser.parse_args(argv[1:])
-    onnx_find(args.input, verbose=args.verbose, watch=set(args.names.split(",")))
+    if args.names == "SHADOW":
+        onx = onnx.load(args.input, load_external_data=False)
+        s, ps = shadowing_names(onx)[:2]
+        print(f"shadowing names: {s}")
+        print(f"post-shadowing names: {ps}")
+    elif args.v2:
+        onx = onnx.load(args.input, load_external_data=False)
+        res = list(
+            enumerate_results(onx, name=set(args.names.split(",")), verbose=args.verbose)
+        )
+        if not args.verbose:
+            print("\n".join(map(str, res)))
+    else:
+        onnx_find(args.input, verbose=args.verbose, watch=set(args.names.split(",")))
 
 
 def get_parser_config() -> ArgumentParser:

onnx_diagnostic/doc.py

@@ -1,3 +1,7 @@
+from typing import Optional
+import numpy as np
+
+
 def reset_torch_transformers(gallery_conf, fname):
     "Resets torch dynamo for :epkg:`sphinx-gallery`."
     import matplotlib.pyplot as plt
@@ -30,3 +34,45 @@ def plot_legend(
     ax.grid(False)
     ax.set_axis_off()
     return ax
+
+
+def rotate_align(ax, angle=15, align="right"):
+    """Rotates x-label and align them to thr right. Returns ax."""
+    for label in ax.get_xticklabels():
+        label.set_rotation(angle)
+        label.set_horizontalalignment(align)
+    return ax
+
+
+def save_fig(ax, name: str):
+    """Applies ``tight_layout`` and saves the figures. Returns ax."""
+    import matplotlib.pyplot as plt
+
+    plt.tight_layout()
+    fig = ax.get_figure()
+    fig.savefig(name)
+    return ax
+
+
+def title(ax: "plt.axes", title: str) -> "plt.axes":  # noqa: F821
+    "Adds a title to axes and returns them."
+    ax.set_title(title)
+    return ax
+
+
+def plot_histogram(
+    tensor: np.ndarray,
+    ax: Optional["plt.axes"] = None,  # noqa: F821
+    bins: int = 30,
+    color: str = "orange",
+    alpha: float = 0.7,
+) -> "plt.axes":  # noqa: F821
+    "Computes the distribution for a tensor."
+    if ax is None:
+        import matplotlib.pyplot as plt
+
+        ax = plt.gca()
+        ax.cla()
+    ax.hist(tensor, bins=30, color="orange", alpha=0.7)
+    ax.set_yscale("log")
+    return ax

onnx_diagnostic/helpers/doc_helper.py

@@ -1,4 +1,5 @@
-from typing import Dict, Optional, Tuple
+import os
+from typing import Dict, List, Optional, Tuple
 import onnx
 import onnx.helper as oh
 import torch
@@ -6,6 +7,17 @@ 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
 
+_SAVED: List[str] = []
+_SAVE_OPTIMIZED_MODEL_ = int(os.environ.get("DUMP_ONNX", "0"))
+
+
+def _get_model_name(op_name: str, provider: str) -> Optional[str]:
+    if _SAVE_OPTIMIZED_MODEL_:
+        name = f"dump_doc_layer_norm_{provider}_{len(_SAVED)}.onnx"
+        _SAVED.append(name)
+        return name
+    return None
+
 
 class LayerNormalizationOrt(OpRunKernel):
     "LayerNormalization with onnxruntime"
@@ -13,14 +25,14 @@ class LayerNormalizationOrt(OpRunKernel):
     @classmethod
     def device_dependent(cls) -> bool:
         "Needs device."
-        return False
+        return True
 
     def __init__(
         self,
         node: onnx.NodeProto,
         version=None,
         device: Optional[torch.device] = None,
-        verbose=0,
+        verbose: int = 0,
     ):
         super().__init__(node, version, verbose=verbose)
         self.axis = self.get_attribute_int(node, "axis", -1)
@@ -70,7 +82,11 @@ class LayerNormalizationOrt(OpRunKernel):
         )
         provider = "CPUExecutionProvider" if self.is_cpu else "CUDAExecutionProvider"
         self._provider = provider
-        return InferenceSessionForTorch(layer_model, providers=[provider])
+        return InferenceSessionForTorch(
+            layer_model,
+            optimized_model_filepath=_get_model_name("layer_norm", provider),
+            providers=[provider],
+        )
 
     def run(self, x, scale, bias=None):
         itype = torch_dtype_to_onnx_dtype(x.dtype)
@@ -94,14 +110,14 @@ class MatMulOrt(OpRunKernel):
     @classmethod
     def device_dependent(cls) -> bool:
         "Needs device."
-        return False
+        return True
 
     def __init__(
         self,
         node: onnx.NodeProto,
         version=None,
         device: Optional[torch.device] = None,
-        verbose=0,
+        verbose: int = 0,
     ):
         super().__init__(node, version, verbose=verbose)
         self.device = device
@@ -127,7 +143,11 @@ class MatMulOrt(OpRunKernel):
         )
         provider = "CPUExecutionProvider" if self.is_cpu else "CUDAExecutionProvider"
         self._provider = provider
-        return InferenceSessionForTorch(model, providers=[provider])
+        return InferenceSessionForTorch(
+            model,
+            optimized_model_filepath=_get_model_name("matmul", provider),
+            providers=[provider],
+        )
 
     def run(self, a, b):
         itype = torch_dtype_to_onnx_dtype(a.dtype)

onnx_diagnostic/helpers/model_builder_helper.py

@@ -220,6 +220,9 @@ def create_model_builder(
     """
     assert cache_dir, "create_model_builder does not work without cache_dir."
     assert os.path.exists(cache_dir), f"cache_dir={cache_dir!r} does not exists"
+    precision = {"float32": "fp32", "float16": "fp16", "bfloat16": "bfp16"}.get(
+        precision, precision
+    )
     download_model_builder_to_cache()
     builder = import_model_builder()
     io_dtype = builder.set_io_dtype(precision, execution_provider, extra_options)

onnx_diagnostic/helpers/onnx_helper.py

@@ -316,7 +316,7 @@ def check_model_ort(
 
 
 @functools.cache
-def onnx_dtype_name(itype: int) -> str:
+def onnx_dtype_name(itype: int, exc: bool = True) -> str:
     """
     Returns the ONNX name for a specific element type.
 
@@ -335,7 +335,11 @@ def onnx_dtype_name(itype: int) -> str:
             v = getattr(TensorProto, k)
             if v == itype:
                 return k
-    raise ValueError(f"Unexpected value itype: {itype}")
+    if exc:
+        raise ValueError(f"Unexpected value itype: {itype}")
+    if itype == 0:
+        return "UNDEFINED"
+    return "UNEXPECTED"
 
 
 def pretty_onnx(
@@ -365,7 +369,7 @@ def pretty_onnx(
         itype = onx.type.tensor_type.elem_type
         shape = tuple((d.dim_param or d.dim_value) for d in onx.type.tensor_type.shape.dim)
         shape_str = ",".join(map(str, shape))
-        return f"{onnx_dtype_name(itype)}[{shape_str}] {name}"
+        return f"{onnx_dtype_name(itype, exc=False)}[{shape_str}] {name}"
 
     if isinstance(onx, AttributeProto):
         att = onx
@@ -767,7 +771,7 @@ def tensor_dtype_to_np_dtype(tensor_dtype: int) -> np.dtype:
 
 
 def iterator_initializer_constant(
-    model: Union[onnx.FunctionProto, onnx.GraphProto, onnx.ModelProto],
+    model: Union[FunctionProto, GraphProto, ModelProto],
     use_numpy: bool = True,
     prefix: str = "",
 ) -> Iterator[Tuple[str, Union["torch.Tensor", np.ndarray]]]:  # noqa: F821
@@ -779,8 +783,8 @@ def iterator_initializer_constant(
     :param prefix: for subgraph
     :return: iterator
     """
-    if not isinstance(model, onnx.FunctionProto):
-        graph = model if isinstance(model, onnx.GraphProto) else model.graph
+    if not isinstance(model, FunctionProto):
+        graph = model if isinstance(model, GraphProto) else model.graph
         if not use_numpy:
             from .torch_helper import to_tensor
         if prefix:
@@ -791,7 +795,7 @@ def iterator_initializer_constant(
             )
         nodes = graph.node
         name = graph.name
-        if isinstance(model, onnx.ModelProto):
+        if isinstance(model, ModelProto):
             for f in model.functions:
                 yield from iterator_initializer_constant(
                     f, use_numpy=use_numpy, prefix=f"{prefix}{f.name}"
@@ -908,3 +912,283 @@ def tensor_statistics(tensor: Union[np.ndarray, TensorProto]) -> Dict[str, Union
     qu = np.quantile(tensor, ii)
     stat.update({f"q{i}": float(q) for i, q in zip(ii, qu)})
     return stat
+
+
+class NodeCoordinates:
+    """
+    A way to localize a node,
+    path is a tuple of three information, node index, node type, node name.
+    """
+
+    __slots__ = ("node", "path")
+
+    def __init__(
+        self,
+        node: Union[onnx.TensorProto, NodeProto, str],
+        path: Tuple[Tuple[int, str, str], ...],
+    ):
+        assert isinstance(path, tuple), f"Unexpected type {type(path)} for path"
+        assert all(isinstance(t, tuple) for t in path), f"Unexpected type in path={path}"
+        self.node = node
+        self.path = path
+
+    def __str__(self) -> str:
+        "usual"
+        if isinstance(self.node, str):
+            return f"{self.path_to_str()} :: {self.node!r}"
+        return f"{self.path_to_str()} :: {pretty_onnx(self.node)}"
+
+    def path_to_str(self) -> str:
+        "Strings representing coordinates."
+        return "x".join(f"({':'.join(map(str, t))})" for t in self.path)
+
+
+class ResultFound:
+    """
+    Class returned by :func:`enumerate_results`.
+    """
+
+    __slots__ = ("consumer", "name", "producer")
+
+    def __init__(
+        self,
+        name: str,
+        producer: Optional[NodeCoordinates],
+        consumer: Optional[NodeCoordinates],
+    ):
+        assert isinstance(name, str), f"unexpected type {type(name)} for name"
+        self.name = name
+        self.producer = producer
+        self.consumer = consumer
+
+    def __str__(self) -> str:
+        "usuals"
+        return (
+            f"<< {self.name} - {self.consumer}"
+            if self.producer is None
+            else f">> {self.name} - {self.producer}"
+        )
+
+
+def enumerate_results(
+    proto: Union[FunctionProto, GraphProto, ModelProto, Sequence[NodeProto]],
+    name: Union[Set[str], str],
+    verbose: int = 0,
+    coordinates: Optional[List[Tuple[int, str, str]]] = None,
+) -> Iterator[ResultFound]:
+    """
+    Iterates on all nodes, attributes to find where a name is used.
+
+    :param proto: a proto
+    :param name: name or names to find
+    :param verbose: verbosity
+    :param coordinates: coordinates of a node
+    :return: iterator on :class:`ResultFound`
+    """
+    if not isinstance(name, set):
+        name = {name}
+    coordinates = coordinates or []
+    assert all(
+        isinstance(c, tuple) for c in coordinates
+    ), f"Unexpected type in coordinates={coordinates}"
+    indent = "  " * len(coordinates)
+    if isinstance(proto, ModelProto):
+        if verbose:
+            print(f"[enumerate_results] {indent}searching for {name!r} into ModelProto...")
+        yield from enumerate_results(proto.graph, name, verbose=verbose)
+    elif isinstance(proto, FunctionProto):
+        if verbose:
+            print(f"[enumerate_results] {indent}searching for {name!r} into FunctionProto...")
+        for i in proto.input:
+            if i in name:
+                r = ResultFound(
+                    i,
+                    NodeCoordinates(i, tuple([*coordinates, (-1, "INPUT", "")])),  # noqa: C409
+                    None,
+                )
+                if verbose > 1:
+                    print(f"[enumerate_results] {indent}-- {r}")
+                yield r
+        yield from enumerate_results(proto.node, name, verbose=verbose)
+        for i in proto.output:
+            if i in name:
+                r = ResultFound(
+                    i,
+                    None,
+                    NodeCoordinates(
+                        i, tuple([*coordinates, (len(proto.node), "OUTPUT", "")])  # noqa: C409
+                    ),
+                )
+                if verbose > 1:
+                    print(f"[enumerate_results] {indent}-- {r}")
+                yield r
+    elif isinstance(proto, GraphProto):
+        if verbose:
+            print(f"[enumerate_results] {indent}searching for {name!r} into GraphProto...")
+        for i in proto.initializer:
+            if i.name in name:
+                r = ResultFound(
+                    i.name,
+                    NodeCoordinates(i, tuple([*coordinates, (-1, "INIT", "")])),  # noqa: C409
+                    None,
+                )
+                if verbose > 1:
+                    print(f"[enumerate_results] {indent}-- {r}")
+                yield r
+        for i in proto.sparse_initializer:
+            if i.name in name:
+                r = ResultFound(
+                    i.name,
+                    NodeCoordinates(i, tuple([*coordinates, (-1, "INIT", "")])),  # noqa: C409
+                    None,
+                )
+                if verbose > 1:
+                    print(f"[enumerate_results] {indent}-- {r}")
+                yield r
+        for i in proto.input:
+            if i.name in name:
+                r = ResultFound(
+                    i.name,
+                    NodeCoordinates(i, tuple([*coordinates, (-1, "INPUT", "")])),  # noqa: C409
+                    None,
+                )
+                if verbose > 1:
+                    print(f"[enumerate_results] {indent}-- {r}")
+                yield r
+        yield from enumerate_results(
+            proto.node, name, verbose=verbose, coordinates=coordinates
+        )
+        for i in proto.output:
+            if i.name in name:
+                r = ResultFound(
+                    i.name,
+                    None,
+                    NodeCoordinates(
+                        i, tuple([*coordinates, (len(proto.node), "OUTPUT", "")])  # noqa: C409
+                    ),
+                )
+                if verbose > 1:
+                    print(f"[enumerate_results] {indent}-- {r}")
+                yield r
+    else:
+        if verbose:
+            print(
+                f"[enumerate_results] {indent}searching for {name!r} into List[NodeProto]..."
+            )
+        for node_i, node in enumerate(proto):
+            if set(node.input) & name:
+                for n in node.input:
+                    if n in name:
+                        r = ResultFound(
+                            n,
+                            NodeCoordinates(
+                                node,
+                                tuple(  # noqa: C409
+                                    [*coordinates, (node_i, node.op_type, node.name)]
+                                ),
+                            ),
+                            None,
+                        )
+                        if verbose > 1:
+                            print(f"[enumerate_results] {indent}-- {r}")
+                        yield r
+            if node.op_type in {"If", "Scan", "Loop", "SequenceMap"}:
+                for att in node.attribute:
+                    if att.type == onnx.AttributeProto.GRAPH:
+                        yield from enumerate_results(
+                            att.g,
+                            name,
+                            verbose=verbose,
+                            coordinates=[*coordinates, (node_i, node.op_type, node.name)],
+                        )
+            if set(node.output) & name:
+                for n in node.output:
+                    if n in name:
+                        r = ResultFound(
+                            n,
+                            None,
+                            NodeCoordinates(
+                                node,
+                                tuple(  # noqa: C409
+                                    [*coordinates, (node_i, node.op_type, node.name)]
+                                ),
+                            ),
+                        )
+                        if verbose > 1:
+                            print(f"[enumerate_results] {indent}-- {r}")
+                        yield r
+    if verbose:
+        print(f"[enumerate_results] {indent}done")
+
+
+def shadowing_names(
+    proto: Union[FunctionProto, GraphProto, ModelProto, Sequence[NodeProto]],
+    verbose: int = 0,
+    existing: Optional[Set[str]] = None,
+    shadow_context: Optional[Set[str]] = None,
+    post_shadow_context: Optional[Set[str]] = None,
+) -> Tuple[Set[str], Set[str], Set[str]]:
+    """
+    Returns the shadowing names, the names created in the main graph
+    after they were created in a subgraphs and the names created by the nodes.
+    """
+    if isinstance(proto, ModelProto):
+        return shadowing_names(proto.graph)
+    if isinstance(proto, GraphProto):
+        assert (
+            existing is None and shadow_context is None
+        ), "existing must be None if nodes is None"
+        return shadowing_names(
+            proto.node,
+            verbose=verbose,
+            existing=set(i.name for i in proto.initializer)
+            | set(i.name for i in proto.sparse_initializer)
+            | set(i.name for i in proto.input if i.name),
+            shadow_context=set(),
+            post_shadow_context=set(),
+        )
+    if isinstance(proto, FunctionProto):
+        assert (
+            existing is None and shadow_context is None
+        ), "existing must be None if nodes is None"
+        return shadowing_names(
+            proto.node,
+            verbose=verbose,
+            existing=set(i for i in proto.input if i),
+            shadow_context=set(),
+            post_shadow_context=set(),
+        )
+
+    assert (
+        existing is not None and shadow_context is not None
+    ), "existing must not be None if nodes is not None"
+    shadow = set()
+    shadow_context = shadow_context.copy()
+    existing = existing.copy()
+    created = set()
+    post_shadow = set()
+    for node in proto:
+        not_empty = set(n for n in node.input if n)
+        intersection = not_empty & existing
+        assert len(intersection) == len(not_empty), (
+            f"One input in {not_empty}, node={pretty_onnx(node)} "
+            f"was not found in {existing}"
+        )
+        for att in node.attribute:
+            if att.type == AttributeProto.GRAPH:
+                g = att.g
+                shadow |= set(i.name for i in g.input) & shadow_context
+                shadow |= set(i.name for i in g.initializer) & shadow_context
+                shadow |= set(i.name for i in g.sparse_initializer) & shadow_context
+                s, ps, c = shadowing_names(
+                    g.node, verbose=verbose, existing=existing, shadow_context=existing
+                )
+                shadow |= s
+                created |= c
+
+        not_empty = set(n for n in node.output if n)
+        post_shadow |= not_empty & created
+        shadow |= not_empty & shadow_context
+        existing |= not_empty
+        created |= not_empty
+    return shadow, post_shadow, created

onnx_diagnostic/reference/torch_evaluator.py

@@ -168,8 +168,8 @@ class TorchOnnxEvaluator:
         class LayerNormalizationOrt(OpRunKernel):
             "LayerNormalization based on onnxruntime"
 
-            def __init__(self, node: onnx.NodeProto, version=None):
-                super().__init__(node, version)
+            def __init__(self, node: onnx.NodeProto, version=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.stash_type = onnx_dtype_to_torch_dtype(

onnx_diagnostic/torch_export_patches/patch_module_helper.py

@@ -80,6 +80,7 @@ def known_transformers_rewritings_clamp_float16() -> Dict[str, str]:
         "AutoformerModel": "AutoformerEncoderLayer",
         "BartEncoderLayer": "BartEncoderLayer",
         "BartForConditionalGeneration": "BartEncoderLayer",
+        "BartModel": "BartEncoderLayer",
         "BigBirdPegasusForConditionalGeneration": "BigBirdPegasusEncoderLayer",
         "BigBirdPegasusForQuestionAnswering": "BigBirdPegasusEncoderLayer",
         "BigBirdPegasusForCausalLM": "BigBirdPegasusEncoderLayer",

onnx_diagnostic/torch_models/test_helper.py

@@ -387,6 +387,12 @@ def validate_model(
         if model_options:
             print(f"[validate_model] model_options={model_options!r}")
         print(f"[validate_model] get dummy inputs with input_options={input_options}...")
+        print(
+            f"[validate_model] rewrite={rewrite}, patch={patch}, "
+            f"stop_if_static={stop_if_static}"
+        )
+        print(f"[validate_model] exporter={exporter!r}, optimization={optimization!r}")
+        print(f"[validate_model] dump_folder={dump_folder!r}")
         summary["model_id"] = model_id
         summary["model_subfolder"] = subfolder or ""
 
@@ -446,6 +452,8 @@ def validate_model(
                 print(f"[validate_model] model_rewrite={summary['model_rewrite']}")
         else:
             del data["rewrite"]
+            if verbose:
+                print("[validate_model] no rewrite")
     if os.environ.get("PRINT_CONFIG", "0") in (1, "1"):
         print("[validate_model] -- PRINT CONFIG")
         print("-- type(config)", type(data["configuration"]))
@@ -1334,13 +1342,13 @@ def call_torch_export_custom(
         "custom-nostrict",
         "custom-nostrict-default",
         "custom-nostrict-all",
-        "custom-inline",
-        "custom-strict-inline",
-        "custom-strict-default-inline",
-        "custom-strict-all-inline",
-        "custom-nostrict-inline",
-        "custom-nostrict-default-inline",
-        "custom-nostrict-all-inline",
+        "custom-noinline",
+        "custom-strict-noinline",
+        "custom-strict-default-noinline",
+        "custom-strict-all-noinline",
+        "custom-nostrict-noinline",
+        "custom-nostrict-default-noinline",
+        "custom-nostrict-all-noinline",
     }
     assert exporter in available, f"Unexpected value for exporter={exporter!r} in {available}"
     assert "model" in data, f"model is missing from data: {sorted(data)}"
@@ -1381,10 +1389,7 @@ def call_torch_export_custom(
         ),
         save_ep=(os.path.join(dump_folder, f"{exporter}.ep") if dump_folder else None),
     )
-    inline = "-inline" in exporter
-    if inline:
-        export_options.aten_as_function = set()
-
+    inline = "-noinline" not in exporter
     options = OptimizationOptions(patterns=optimization) if optimization else None
     model = data["model"]
     kws = dict(

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

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

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

@@ -1,8 +1,8 @@
-onnx_diagnostic/__init__.py,sha256=P1AdnI_jw7SIojX7zxqBeAy83xQePX59KApD_RBNnOY,173
+onnx_diagnostic/__init__.py,sha256=mRkq5dlSo05GQMct7d6mMZLb6s5T24eG_3mD5O3wBo0,173
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
-onnx_diagnostic/_command_lines_parser.py,sha256=WSoopSHjXWEgFvzyfGe3_c-hZoStuQPQc_k08siFuf4,19211
+onnx_diagnostic/_command_lines_parser.py,sha256=pxG3dYpTTpRCjBRzFGEZm4ewb7xprZihP7fG08kWL04,19989
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
-onnx_diagnostic/doc.py,sha256=MTuT7Kxyvn7KEy84liQeFeqhugJrUQhjjpx21F72Uxw,926
+onnx_diagnostic/doc.py,sha256=O_ncetL0G4-oHIxLv8ofTIIxCT_5ESSkKxfYvgccJEc,2038
 onnx_diagnostic/ext_test_case.py,sha256=nhWz75caudvKn-svH1ppUY8uw8MoTD4cEdqMdj6PiPc,42399
 onnx_diagnostic/export/__init__.py,sha256=yEIoWiOeTwBsDhyYt2fTKuhtA0Ya1J9u9ZzMTOTWaWs,101
 onnx_diagnostic/export/dynamic_shapes.py,sha256=EHB7VoWNx8sVetvOgE1vgC7wHtIjWDLjanhbEJNpK88,39892
@@ -12,13 +12,13 @@ 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/doc_helper.py,sha256=pl5MZd3_FaE8BqQnqoBuSBxoNCFcd2OJd3eITUSku5c,5897
 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
 onnx_diagnostic/helpers/mini_onnx_builder.py,sha256=R1Vu4zHzN7GIUnbMVQzpkaXj8cCyyOweWOI9-TSgAHM,20966
-onnx_diagnostic/helpers/model_builder_helper.py,sha256=cQuC7wbl8UcU_IaSBnX_CsydKTABN6lABCWEthmpmDA,13386
-onnx_diagnostic/helpers/onnx_helper.py,sha256=chw-HB4iqGCD_16d0_BaCnreEgWYW4KeH78nh-3t2Uw,29213
+onnx_diagnostic/helpers/model_builder_helper.py,sha256=xIZmsVMFHfdtYeZHVEffBtxYObAaRPiaSmwwSKkmLwY,13502
+onnx_diagnostic/helpers/onnx_helper.py,sha256=pXXQjfyNTSUF-Kt72U4fnBDkYAnWYMxdSw8m0qk3xmE,39670
 onnx_diagnostic/helpers/ort_session.py,sha256=UgUUeUslDxEFBc6w6f3HMq_a7bn4TBlItmojqWquSj4,29281
 onnx_diagnostic/helpers/rt_helper.py,sha256=BXU_u1syk2RyM0HTFHKEiO6rHHhZW2UFPyUTVdeq8BU,4251
 onnx_diagnostic/helpers/torch_helper.py,sha256=mrmn4mBeRvMRJ9cEu7BbNG-AHq2OJfSm8dxgtzh-yQQ,31631
@@ -26,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=ekQTYo0YPVdcM6TGRnEk0mDmGHUOwi0OpcMOWJsRvT8,26572
+onnx_diagnostic/reference/torch_evaluator.py,sha256=qAeYvSFwOCMDctc39evBEle_2bX8kuJW2QSLksofzn8,26600
 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
@@ -88,7 +88,7 @@ onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=l5HvE_F
 onnx_diagnostic/torch_export_patches/patch_expressions.py,sha256=vr4tt61cbDnaaaduzMj4UBZ8OUtr6GfDpIWwOYqjWzs,3213
 onnx_diagnostic/torch_export_patches/patch_inputs.py,sha256=9b4pmyT00BwLqi7WG-gliep1RUy3gXEgW6BDnlSSA-M,7689
 onnx_diagnostic/torch_export_patches/patch_module.py,sha256=R2d9IHM-RwsBKDsxuBIJnEqMoxbS9gd4YWFGG2wwV5A,39881
-onnx_diagnostic/torch_export_patches/patch_module_helper.py,sha256=sIvu4E9BsCB8f-KlM4xykR19mflDfLGaiel6nb9ZGx8,6926
+onnx_diagnostic/torch_export_patches/patch_module_helper.py,sha256=2U0AdyZuU0W54QTdE7tY7imVzMnpQ5091ADNtTCkT8Y,6967
 onnx_diagnostic/torch_export_patches/eval/__init__.py,sha256=VtkQB1o3Q2Fh99OOF6vQ2dynkhwzx2Wx6oB-rRbvTI0,23954
 onnx_diagnostic/torch_export_patches/eval/model_cases.py,sha256=DTvdHPtNQh25Akv5o3D4Jxf1L1-SJ7w14tgvj8AAns8,26577
 onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -96,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=32uFEZwILyOWHrj-qaNfIv4P2ySe7A0lN2WQ4eVEudA,59604
+onnx_diagnostic/torch_models/test_helper.py,sha256=tt6bgLjGRayzvkXrTelKHTjr7XU9BvhX7uE4XJq6H6o,59927
 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
@@ -108,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.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,,
+onnx_diagnostic-0.6.3.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.6.3.dist-info/METADATA,sha256=eJxj0KTPv1rXf-3T9KImWIF-u8g7wHXBGZm5zvXM7V8,6643
+onnx_diagnostic-0.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.6.3.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.6.3.dist-info/RECORD,,