onnx-diagnostic 0.8.2__py3-none-any.whl → 0.8.3__py3-none-any.whl

onnx_diagnostic/torch_onnx/sbs_dataclasses.py

@@ -0,0 +1,491 @@
+import os
+import textwrap
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+try:
+    from typing import Self
+except ImportError:
+    # python <= 3.10
+    Self = "Self"  # type: ignore[assignment]
+import onnx
+import numpy as np
+import torch
+from ..helpers.onnx_helper import extract_subset_of_nodes, make_submodel, from_array_extended
+from ..helpers.torch_helper import torch_dtype_to_onnx_dtype
+
+
+def make_torch_inputs(
+    input_names: List[str],
+    onnx_name_to_ep_name: Dict[str, str],
+    onnx_results: Dict[str, torch.Tensor],
+    torch_results: Dict[str, torch.Tensor],
+    submodel: Optional[onnx.ModelProto],
+) -> Tuple[Dict[str, torch.Tensor], Set[str]]:
+    """
+    Gathers torch tensors instead of onnx tensors (tensors produced by the onnx model)
+
+    :param input_names: tensors to gather
+    :param onnx_name_to_ep_name: mapping between onnx name to names in the exported program
+    :param onnx_results: all onnx results (produced by the onnx model)
+    :param torch_results: all tensors produced by the exported program
+    :param submodel: onnx model, any tensor missing in `torch_results` is
+        add as an initializer to this model
+    :return: the list of tensors, the set of inputs for which there was no tensor coming
+        from the exported program
+    """
+    torch_inputs = {}
+    removed_inputs = set()
+    for n in input_names:
+        if n in onnx_name_to_ep_name:
+            torch_inputs[n] = torch_results[onnx_name_to_ep_name[n]]
+        else:
+            removed_inputs.add(n)
+            if submodel is not None:
+                # We add that input as an initializer because it is probably a constant.
+                submodel.graph.initializer.append(from_array_extended(onnx_results[n], name=n))
+            else:
+                torch_inputs[n] = onnx_results[n]
+    return torch_inputs, removed_inputs
+
+
+@dataclass
+class ReplayConfiguration:
+    """
+    Configuration specifying how to replay or dump pieces of
+    onnx graph in order to replay them later and investigate
+    later possible sources of discrepancies.
+
+    :param dump_folder: where to dump the onnx model corresponding to the
+        pieces to investigate
+    :param selected_names: list of results names to dump
+    :param selected_op_types: list of onnx operators to dump
+    :param threshold: only keep those whose discrepancies is greater than that threshold
+    """
+
+    dump_folder: str
+    selected_names: Optional[Set[str]] = None
+    selected_op_types: Optional[Set[str]] = None
+    threshold: float = 0.1
+
+    def __post_init__(self):
+        assert self.dump_folder, "dump_folder is empty and this is not allowed for the replay"
+
+    def select(
+        self,
+        name: Optional[str] = None,
+        op_type: Optional[str] = None,
+        err_abs: Optional[float] = None,
+    ) -> bool:
+        """
+        Returns true or false whether or not a piece of the onnx model should be dumped,
+        around a particular node. The results is True if one of the condition is true:
+
+        * ``name in self.selected_names``
+        * ``op_type in self.selected_op_types``
+        * ``err_abs >= self.threshold``
+
+        :param name: result name
+        :param op_type: operator type
+        :param err_abs: measured discrepancy
+        :return: True if this should be dumped
+        """
+        if name and self.selected_names and name in self.selected_names:
+            return True
+        if op_type and self.selected_op_types and op_type in self.selected_op_types:
+            return True
+        if err_abs is not None and self.threshold is not None and err_abs >= self.threshold:
+            return True
+        return False
+
+    def get_replay_code(self) -> str:
+        """
+        Returns a code letting the user replay the onnx model.
+        It looks like the following. It may have to be adapted.
+
+        .. runpython::
+            :showcode:
+
+            from onnx_diagnostic.torch_onnx.sbs_dataclasses import ReplayConfiguration
+
+            rc = ReplayConfiguration(dump_folder="unused")
+            print(rc.get_replay_code())
+        """
+        return textwrap.dedent(
+            """
+            import onnx
+            import torch
+            from onnx_diagnostic.helpers import max_diff, string_diff, string_type
+            from onnx_diagnostic.helpers.torch_helper import study_discrepancies
+            from onnx_diagnostic.helpers.onnx_helper import pretty_onnx
+            from onnx_diagnostic.reference import OnnxruntimeEvaluator
+
+            skws = dict(with_shape=True, with_device=True)
+
+            torch_inputs = torch.load("torch_inputs.pt")
+            onnx_inputs = torch.load("onnx_inputs.pt")
+            expected_outputs_and_mapping = torch.load("torch_outputs_and_mapping.pt")
+            expected = expected_outputs_and_mapping["expected"]
+            mapping = expected_outputs_and_mapping["mapping"]
+
+            print(f"-- torch_inputs={string_type(torch_inputs, **skws)}")
+            print(f"-- onnx_inputs={string_type(onnx_inputs, **skws)}")
+            print(f"-- expected={string_type(expected, **skws)}")
+            print(f"-- mapping={mapping}")
+
+            print()
+            print("-- model.onnx")
+            print()
+
+            model = onnx.load("model.onnx")
+            print(pretty_onnx(model))
+
+            print()
+            print("-- range of inputs --")
+            print()
+
+            for k, v in onnx_inputs.items():
+                print(f"--   {k}: {string_type(v, **skws, with_min_max=True)}")
+
+            print()
+            print("-- discrepancies of inputs --")
+            print()
+
+            ep_feeds = {}
+            for k, v in onnx_inputs.items():
+                tk = mapping.get(k, k)
+                tkv = torch_inputs[k] if k in torch_inputs else torch_inputs[tk]
+                ep_feeds[k] = tkv
+                diff = max_diff(v, tkv)
+                print(
+                    f"--   {k} -> {tk} ep:{string_type(tkv, **skws)} "
+                    f"nx:{string_type(v, **skws)} / diff {string_diff(diff)}"
+                )
+
+            print()
+            print("-- SVD --")
+            print()
+
+            for k, v in onnx_inputs.items():
+                if len(v.shape) == 2:
+                    U, S, Vt = torch.linalg.svd(v.to(torch.float32))
+                    print(f" -- {k}: {S[:5]}")
+
+            print()
+            print("-- run with onnx_inputs --")
+            print()
+
+            sess = OnnxruntimeEvaluator(model, whole=True)
+            feeds = onnx_inputs
+            obtained = sess.run(None, feeds)
+            print(f"-- obtained={string_type(obtained, **skws)}")
+            diff = max_diff(expected, tuple(obtained), hist=[0.1, 0.01])
+            print(f"-- diff: {string_diff(diff)}")
+            print()
+            print("-- plots --")
+
+            for i in range(len(expected)):
+                study_discrepancies(
+                    expected[i],
+                    obtained[i],
+                    title=f"study output {i}",
+                    name=f"disc{i}.png",
+                    bins=50,
+                )
+
+            print()
+            print("-- run with torch_inputs --")
+            print()
+
+            obtained = sess.run(None, ep_feeds)
+            print(f"-- obtained={string_type(obtained, **skws)}")
+            diff = max_diff(expected, tuple(obtained), hist=[0.1, 0.01])
+            print(f"-- diff: {string_diff(diff)}")
+
+            print()
+            print("-- end --")
+            print()
+
+            if False:
+                # CUDA profiling
+                with torch.profiler.profile(
+                    activities=[torch.profiler.ProfilerActivity.CUDA],
+                    record_shapes=True,
+                    with_stack=True,
+                ) as prof:
+                    sess.run(None, ep_feeds)
+                obj = prof.key_averages()
+                print(obj.table())
+            """
+        )
+
+    def dump(
+        self,
+        name: str,
+        onnx_id_node: int,
+        model: onnx.ModelProto,
+        onnx_results: Dict[str, Any],
+        torch_results: Dict[str, torch.Tensor],
+        onnx_name_to_ep_name: Dict[str, str],
+        verbose: int = 0,
+    ) -> Optional[str]:
+        """
+        Dumps the minimal graph which can be replayed outside the model.
+
+        :param name: name of the result to look into
+        :param onnx_id_node: index of the node which produces it model `model`
+        :param model: onnx model
+        :param onnx_results: all known onnx results
+        :param torch_results: all known torch results
+        :param onnx_name_to_ep_name: correspondence between onnx_node name
+            and exported program name
+        :param verbose: verbosity level
+        :return: the folder created to dump everything
+        """
+        if verbose:
+            print(f"[ReplayConfiguration.dump] extract subset of node for {name!r}")
+        nodes = extract_subset_of_nodes(
+            model=model,
+            name=name,
+            node_index=onnx_id_node,
+            cut_points=set(onnx_name_to_ep_name),
+        )
+        if not nodes:
+            if verbose:
+                print(
+                    f"[ReplayConfiguration.dump] could not extract subset of node for {name!r}"
+                )
+            return None
+        if verbose:
+            print(f"[ReplayConfiguration.dump] make model with {len(nodes)} nodes")
+        submodel = make_submodel(
+            nodes,
+            ir_version=model.ir_version,
+            opset_imports=model.opset_import,
+            output_names=[name],
+            type_rank_fn=lambda name: (
+                torch_dtype_to_onnx_dtype(onnx_results[name].dtype),
+                len(onnx_results[name].shape),
+            ),
+        )
+        input_names = [n.name for n in submodel.graph.input]
+        if verbose:
+            print(f"[ReplayConfiguration.dump] model inputs {input_names}")
+        folder = os.path.join(self.dump_folder, name.replace(":", "_").replace("/", "_"))
+        os.makedirs(folder, exist_ok=True)
+        if verbose:
+            print(f"[ReplayConfiguration.dump] dumps into folder {folder!r}")
+
+        torch_inputs, removed_inputs = make_torch_inputs(
+            input_names, onnx_name_to_ep_name, onnx_results, torch_results, submodel
+        )
+
+        if removed_inputs:
+            input_names = [i for i in input_names if i not in removed_inputs]
+            new_inputs = [i for i in submodel.graph.input if i.name not in removed_inputs]
+            del submodel.graph.input[:]
+            submodel.graph.input.extend(new_inputs)
+            if verbose:
+                print(f"[ReplayConfiguration.dump] removed input {removed_inputs}")
+                print(f"[ReplayConfiguration.dump] final model inputs {input_names}")
+
+        onnx.save(submodel, os.path.join(folder, "model.onnx"))
+        onnx_inputs = {n: onnx_results[n] for n in input_names}
+        assert (
+            name in onnx_name_to_ep_name
+        ), f"Unable to find {name!r} in {onnx_name_to_ep_name}"
+        expected_outputs_and_mapping = dict(
+            expected=(torch_results[onnx_name_to_ep_name[name]],),
+            mapping={
+                k: onnx_name_to_ep_name[k] for k in input_names if k in onnx_name_to_ep_name
+            },
+        )
+        torch.save(torch_inputs, os.path.join(folder, "torch_inputs.pt"))
+        torch.save(onnx_inputs, os.path.join(folder, "onnx_inputs.pt"))
+        torch.save(
+            expected_outputs_and_mapping, os.path.join(folder, "torch_outputs_and_mapping.pt")
+        )
+        with open(os.path.join(folder, "replay.py"), "w") as f:
+            f.write(self.get_replay_code())
+        if verbose:
+            print(f"[ReplayConfiguration.dump] done {folder!r}")
+        return folder
+
+
+@dataclass
+class RunAlignedRecord:
+    """
+    The side-by-side ran by function :func:`run_aligned
+    <onnx_diagnostic.torch_onnx.sbs.run_aligned>`
+    yields instances of this type. If both `ep_name`
+    and `onnx_name` are specified, then both results
+    appear in the exported program (torch) and the onnx model.
+
+    :param ep_id_node: node index in the exported program
+    :param onnx_id_node: node index in the onnx model, -1 for an initializer
+    :param ep_name: result name in the exported program
+    :param onnx_name: result name in the onnx model, usually same as `ep_name`
+        except for initializer
+    :param ep_target: target name in the exported program producing the result
+    :param onnx_op_type: operator type in the onnx model producing the result
+    :param onnx_id_output: usually 0 unless this node has multiple output,
+        in that case, it is the output index
+    :param ep_shape_type: shape and type of the results in the exported program
+    :param onnx_shape_type: shape and type of the results in the onnx mode,
+        it should be the same as `ep_shape_type`, anything different probably
+        means a bug
+    :param err_abs: maximum absolute error for the considered result
+        between the exported program and the onnx model
+    :param err_rel: maximum relative error
+    :param err_dev: 0 if the device is the same, 1 if not
+    :param err_nan: number of nan values disagreeing
+    :param err_h01: number of values for which the discrepancy is above 0.1
+    :param err_h001: number of values for which the discrepancy is above 0.01
+    :param ep_time_run: execution time for the exported program
+    :param onnx_time_run: execution time for the onnx model, that includes
+        the creation of the onnx model so that's probably not very usable
+    :param err_abs2: same as `err_abs` if onnx kernel is run with torch results
+    :param err_rel2: same as `err_rel` if onnx kernel is run with torch results
+    :param err_dev2: same as `err_dev` if onnx kernel is run with torch results
+    :param err_nan2: same as `err_nan` if onnx kernel is run with torch results
+    :param err_h012: same as `err_h01` if onnx kernel is run with torch results
+    :param err_h0012: same as `err_h001` if onnx kernel is run with torch results
+    :param comment: any additional information
+    """
+
+    ep_id_node: Optional[int] = None
+    onnx_id_node: Optional[int] = None
+    ep_name: Optional[str] = None
+    onnx_name: Optional[str] = None
+    ep_target: Optional[str] = None
+    onnx_op_type: Optional[str] = None
+    onnx_id_output: Optional[int] = None
+    ep_shape_type: Optional[str] = None
+    onnx_shape_type: Optional[str] = None
+    err_abs: Optional[float] = None
+    err_rel: Optional[float] = None
+    err_dev: Optional[float] = None
+    err_nan: Optional[float] = None
+    err_h01: Optional[float] = None
+    err_h001: Optional[float] = None
+    ep_time_run: Optional[float] = None
+    onnx_time_run: Optional[float] = None
+    err_abs2: Optional[float] = None
+    err_rel2: Optional[float] = None
+    err_dev2: Optional[float] = None
+    err_nan2: Optional[float] = None
+    err_h012: Optional[float] = None
+    err_h0012: Optional[float] = None
+    comment: Optional[str] = None
+
+    def __post_init__(self):
+        "Validation."
+        assert self.ep_id_node is None or self.ep_id_node >= 0, (
+            f"Node id are always positive in the exported program but "
+            f"ep_id_node={self.ep_id_node}"
+        )
+
+    def set_diff(self, diff: Dict[str, Any]) -> Self:
+        """Sets error."""
+        if diff is None:
+            return
+        if "abs" in diff:
+            self.err_abs = diff["abs"]
+        if "rel" in diff:
+            self.err_rel = diff["rel"]
+        if "dev" in diff:
+            self.err_dev = diff["dev"]
+        if "nan" in diff:
+            self.err_nan = diff["nan"]
+        if "rep" in diff:
+            self.err_h01 = diff["rep"][">0.1"]
+            self.err_h001 = diff["rep"][">0.01"]
+        return self
+
+    def set_diff2(self, diff: Dict[str, Any]) -> Self:
+        """Sets error."""
+        if diff is None:
+            return
+        if "abs" in diff:
+            self.err_abs2 = diff["abs"]
+        if "rel" in diff:
+            self.err_rel2 = diff["rel"]
+        if "dev" in diff:
+            self.err_dev2 = diff["dev"]
+        if "nan" in diff:
+            self.err_nan2 = diff["nan"]
+        if "rep" in diff:
+            self.err_h012 = diff["rep"][">0.1"]
+            self.err_h0012 = diff["rep"][">0.01"]
+        return self
+
+    @property
+    def key(
+        self,
+    ) -> Tuple[Optional[int], Optional[int], Optional[int], Optional[str], Optional[str]]:
+        "Creates a unique identifier."
+        return (
+            self.ep_id_node,
+            self.onnx_id_node,
+            self.onnx_id_output,
+            self.ep_name,
+            self.onnx_name,
+        )
+
+    def check(
+        self,
+        already_yielded: Dict[
+            Tuple[Optional[int], Optional[int], Optional[int], Optional[str], Optional[str]],
+            int,
+        ],
+    ) -> Self:
+        "Checks a record was not already yielded."
+        if self.onnx_op_type == "reset":
+            # no record for this one
+            return self
+        key = self.key
+        assert key not in already_yielded, (
+            f"Record with key={key} was already yielded, "
+            f"number of records={len(already_yielded)} and previous "
+            f"record at position {already_yielded[key]} (self={self})"
+        )
+        already_yielded[key] = len(already_yielded)
+        return self
+
+
+@dataclass
+class StatusRunAligned:
+    """
+    Information to display while running the side-by-side
+
+    :param max_abs: maximum absolute seen so far
+    :param n_inf: number of infinite values seen so far
+    :param n_nan: number of nan values seen so for
+    :param yielded_nodes: number of yielded pair of nodes seen so far
+    :param last_replay: last result dumped on disk for later replay
+    """
+
+    max_abs: float = 0.0
+    n_inf: int = 0
+    n_nan: int = 0
+    yielded_nodes: int = 0
+    last_replay: str = ""
+
+    def to_str(self) -> str:
+        "Nice display."
+        s = (
+            f"yielded={self.yielded_nodes} maxabs={self.max_abs:1.3f} "
+            f"#inf={self.n_inf} #nan={self.n_nan}"
+        )
+        if self.last_replay:
+            return f"{s} -PLAY({self.last_replay})"
+        return s
+
+    def update(self, err_abs: float):
+        "Updates all attributes with the latest measure."
+        if np.isinf(err_abs) or np.isnan(err_abs):
+            self.n_inf += 1
+        elif err_abs > 1e6:
+            self.n_nan += 1
+        else:
+            self.max_abs = max(self.max_abs, err_abs)

{onnx_diagnostic-0.8.2.dist-info → onnx_diagnostic-0.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.8.2
+Version: 0.8.3
 Summary: Tools to help converting pytorch models into ONNX.
 Home-page: https://github.com/sdpython/onnx-diagnostic
 Author: Xavier Dupré

{onnx_diagnostic-0.8.2.dist-info → onnx_diagnostic-0.8.3.dist-info}/RECORD

@@ -1,37 +1,41 @@
-onnx_diagnostic/__init__.py,sha256=V-Rg-8wiAAhPPRxZNTkkCAlGh_v3sDrFDlTo1Ptqi00,173
+onnx_diagnostic/__init__.py,sha256=q-JGXWdB5HIHrAPUbiGuZ3aflvcrMyhNffVzOd5xO-8,173
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
-onnx_diagnostic/_command_lines_parser.py,sha256=uDn91eWmiz9i7KEaB2vTsR06kkrM0VCkUq9kaBDiPA0,39384
+onnx_diagnostic/_command_lines_parser.py,sha256=KFKyH254F7FdcKKc2QrtAjpGLpLwnduflPvqm3FM0UI,51441
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
 onnx_diagnostic/doc.py,sha256=t3RELgfooYnVMAi0JSpggWkQEgUsREz8NmRvn0TnLI8,2829
-onnx_diagnostic/ext_test_case.py,sha256=RU1WQi2UJNla9vcgz2XrL3q1_YN4v7rB9WnF4_58kko,44867
+onnx_diagnostic/ext_test_case.py,sha256=bA4oK1mnccbt5Ien24I9nhiDgay0IjCxOeH1lPU5E-g,47798
 onnx_diagnostic/export/__init__.py,sha256=yEIoWiOeTwBsDhyYt2fTKuhtA0Ya1J9u9ZzMTOTWaWs,101
-onnx_diagnostic/export/api.py,sha256=gj0rhXjJRchrQhuBdyljA8DlxSNjO7S0dGV4qfoa040,6058
-onnx_diagnostic/export/control_flow.py,sha256=mJQHqnvf8RQ9hI69Ghnl-tJrSrWz2fK_STcbpSUZ02M,17351
-onnx_diagnostic/export/control_flow_research.py,sha256=qO4X52Lp_grMx0wXOEfwOpXMiRd-VFeMibfJ4VigBcU,5200
+onnx_diagnostic/export/api.py,sha256=xivxtvjFAIbKquAsGLjVp9J_CZl6KWeO8IT4wii9FOI,9649
+onnx_diagnostic/export/control_flow.py,sha256=zU5n_QYhNcBllyMsl1_i6ohZt2CshqG2MokJghrvA60,7751
+onnx_diagnostic/export/control_flow_onnx.py,sha256=sODOD4v7EJj6LWhrfcdCW68r9nYKsRM4SRnqDw4TrSI,18049
+onnx_diagnostic/export/control_flow_research.py,sha256=UMAlriHKBLoYJzdq3kCmsUIKOlYQE0OjFbJ8zkuvuwI,5220
 onnx_diagnostic/export/dynamic_shapes.py,sha256=M2hlpHSTbkzZwGKAbrpQXng5HQrwjF5Z6wGGxEgnp74,42061
+onnx_diagnostic/export/onnx_plug.py,sha256=vwUyOtF5aihAO-98QSmY_sD9w0hNMnGKaSxG0cF0ZCo,14660
 onnx_diagnostic/export/shape_helper.py,sha256=m628y0oRCQbeZkeh8JDHIfWMsSjoJoeX-IPiPGDHT-w,11273
 onnx_diagnostic/export/validate.py,sha256=_PGUql2DJhIgGKo0WjTGUc5AgsZUx8fEs00MePy-w98,6043
 onnx_diagnostic/helpers/__init__.py,sha256=GJ2GT7cgnlIveVUwMZhuvUwidbTJaKv8CsSIOpZDsJg,83
 onnx_diagnostic/helpers/_log_helper.py,sha256=OTwQH0OIxs9B6nrSvR7MoxMimSw_8mU0mj133NvLk5o,16832
 onnx_diagnostic/helpers/args_helper.py,sha256=SRWnqC7EENg09RZlA50B_PcdiIhdbgA4C3ACfzl5nMs,4419
 onnx_diagnostic/helpers/bench_run.py,sha256=CGA6VMJZMH2gDhVueT9ypNm4PMcjGrrGFYp08nhWj9k,16539
-onnx_diagnostic/helpers/cache_helper.py,sha256=JcpRNvwNY6CRjjaZApShhdw8hCZNHS2xUhce5ZaWVtU,28446
+onnx_diagnostic/helpers/cache_helper.py,sha256=OLghsSUuZ8cWGkua8eH75KBF-mbVqejnNUYfFo5lRf0,28498
 onnx_diagnostic/helpers/config_helper.py,sha256=cWRETgFhZ7tayIZPnMqF8BF5AvTU64G2BMqyzgO7lzs,5670
 onnx_diagnostic/helpers/doc_helper.py,sha256=pl5MZd3_FaE8BqQnqoBuSBxoNCFcd2OJd3eITUSku5c,5897
+onnx_diagnostic/helpers/dot_helper.py,sha256=Ii6jg-1YUJPI6cPhhTeD8rc5PJR0GIiGa2PLOdWJyA8,7798
 onnx_diagnostic/helpers/fake_tensor_helper.py,sha256=J7wnK3WTuVKnYiMzLVTAPkdJr3hQfIfMC9ZlOu7oGmI,11024
 onnx_diagnostic/helpers/graph_helper.py,sha256=hevQT5a7_QuriVPQcbT5qe18n99Doyl5h3-qshx1-uk,14093
-onnx_diagnostic/helpers/helper.py,sha256=xzq3iBiasWy6qH1_-ydn8QzRKaBgOy4Cs3f9O5PU-3M,63027
+onnx_diagnostic/helpers/helper.py,sha256=aCPkAU6iNmHA3Glt_uehEiBOIIZtXDgq9hjhdG5Ol3Y,65568
 onnx_diagnostic/helpers/log_helper.py,sha256=0lJiTF87lliI-LmgpUH_V2N8NuzJ0LryH0mSYpkRaL8,93272
 onnx_diagnostic/helpers/memory_peak.py,sha256=M3m4_thWFIwP5HytbJYEqaijXIv5v5BW_vlcJowIYI4,6434
-onnx_diagnostic/helpers/mini_onnx_builder.py,sha256=hGAh5pLmXMwx8vx8MUjPmvWak86nCc3pJOvdfX-mqcE,23828
-onnx_diagnostic/helpers/model_builder_helper.py,sha256=5V-SlOVQaGPZov6aSJ0IvYcwpDo2hsCBJpqadRUdnrk,17875
-onnx_diagnostic/helpers/onnx_helper.py,sha256=NC3dD1mKCjzkj5YS6rrBwo5zgfot2Lz71c2ARq-lLpI,39641
-onnx_diagnostic/helpers/ort_session.py,sha256=wjQ1pwzUHuOFxK8Q8Ve3Ph6CUBBC_udK7FcwuDyDMzA,29541
+onnx_diagnostic/helpers/mini_onnx_builder.py,sha256=jR2lkRZEQ0N30H0FqeBwaxJd_w_6kyxFagrnulqFjhE,23883
+onnx_diagnostic/helpers/model_builder_helper.py,sha256=qKIq4Naqq03gk6NfqXLQjSDiKL5FFNc1AEyVX0R8GmA,18540
+onnx_diagnostic/helpers/onnx_helper.py,sha256=BCf1djXB--eY_FJv9ldD85bQ--OMI_uPDJN6SumdbdM,43057
+onnx_diagnostic/helpers/ort_session.py,sha256=TFCDgcG3Nvj_1S0xTIUqDw0WTSeav0NMJFYCfT_W-dw,30505
 onnx_diagnostic/helpers/rt_helper.py,sha256=OOxHSCKZup2u7zTvVJxPkRHb4jQZ03KpkiDGrfwibMM,38135
-onnx_diagnostic/helpers/torch_helper.py,sha256=_-5ecz0D8CAEzkH0uW9MTRywH-NDPNCx0qVmWzTa6do,35180
+onnx_diagnostic/helpers/torch_fx_graph_helper.py,sha256=7xFe4svdbr4gV3OTNcx8eJejjDyHAv4hD_RNNKSxL0c,6571
+onnx_diagnostic/helpers/torch_helper.py,sha256=gtkk31BptY5JvNOvbx_1Bfyuns_mQu9gEO0upoUTdy4,38294
 onnx_diagnostic/reference/__init__.py,sha256=rLZsxOlnb7-81F2CzepGnZLejaROg4JvgFaGR9FwVQA,208
 onnx_diagnostic/reference/evaluator.py,sha256=RzNzjFDeMe-4X51Tb22N6aagazY5ktNq-mRmPcfY5EU,8848
-onnx_diagnostic/reference/ort_evaluator.py,sha256=nituItsP3IKDDWF9z-iGX_iAubrTcdk8pb1GVBp9sCU,26161
+onnx_diagnostic/reference/ort_evaluator.py,sha256=RsTboIAL1QqudV6X3P3VxBPxLtJJF8TsxNdyy0L5epE,34773
 onnx_diagnostic/reference/quantized_tensor.py,sha256=5u67uS2uGacdMD5VYCbpojNjiesDlV_kO0fAJ0vUWGE,1098
 onnx_diagnostic/reference/report_results_comparison.py,sha256=OsyQN8EHZZoj97u74RQP-7WFpebPOso5GEDpdkLWu6M,3645
 onnx_diagnostic/reference/torch_evaluator.py,sha256=Tx1teWvfGEX5RmkDnI83UiOlo5eBOC72vPhgTWdFUF0,27689
@@ -78,7 +82,7 @@ onnx_diagnostic/reference/torch_ops/shape_ops.py,sha256=pJrNR2UB4PlWl6cv4EDl1uGl
 onnx_diagnostic/reference/torch_ops/unary_ops.py,sha256=dwu6HPr4V_roxu85U3VLTtDLx5bfxKalT_-zlQxZ5wc,1850
 onnx_diagnostic/tasks/__init__.py,sha256=kk-I2tgtb32A_ANh6Ux_u982mA2SrQKO_MDp0KsRi28,2774
 onnx_diagnostic/tasks/automatic_speech_recognition.py,sha256=aMufLDGW005f7aLMZ9alIQtg2s_WIUk5Rd9udS_BZ38,6964
-onnx_diagnostic/tasks/feature_extraction.py,sha256=Bt5meYvVqOFd_v8NgLKAfyqtjoEsEi6oQcQLn1vcwG4,5316
+onnx_diagnostic/tasks/feature_extraction.py,sha256=IS9z9fPNE0hhGUebBfmNZl0twdXobMc7MFKpQB9qZI0,5388
 onnx_diagnostic/tasks/fill_mask.py,sha256=5Gt6zlj0p6vuifox7Wmj-TpHXJvPS0CEH8evgdBHDNA,2640
 onnx_diagnostic/tasks/image_classification.py,sha256=nLpBBB1Gkog3Fk6pu2waiHcuQr4ILPptc9FhQ-pn460,4682
 onnx_diagnostic/tasks/image_text_to_text.py,sha256=g-xRRTVUiT6mBvYYbOxgzlHNfu9SnEgUcvTeSoqf7gE,21765
@@ -87,7 +91,7 @@ onnx_diagnostic/tasks/mask_generation.py,sha256=fjdD3rd-O-mFL0hQy3la3JXKth_0bH2H
 onnx_diagnostic/tasks/mixture_of_expert.py,sha256=al4tk1BrHidtRiHlAaiflWiJaAte0d5M8WcBioANG9k,2808
 onnx_diagnostic/tasks/object_detection.py,sha256=3FiT8ya5FCd9lwjQCRXhAwXspNwYTlAD3Gpk8aAcG5w,4279
 onnx_diagnostic/tasks/sentence_similarity.py,sha256=vPqNZgAnIvY0rKWPUTs0IlU3RFQDkXAHL7IVfRFmilY,2655
-onnx_diagnostic/tasks/summarization.py,sha256=nc0pUCBxQgOLbW9kCIfP361XwUy9HTeaT8lrbVNTPw0,8071
+onnx_diagnostic/tasks/summarization.py,sha256=AyDUHLjEymn4waIFf_ZgLAUJT6xqiGFKdaYAikK3wVA,5382
 onnx_diagnostic/tasks/text2text_generation.py,sha256=KUN7XSumftAy3cr2zYLR59RQ3wWYOTTTQkDuwjVm-HI,8464
 onnx_diagnostic/tasks/text_classification.py,sha256=CGc72SpXFzTUyzAHEMPgyy_s187DaYGsRdrosxG80_Q,2711
 onnx_diagnostic/tasks/text_generation.py,sha256=80K4RzjCLPpzizxz_TGz6hFxLyGSGn6B2yaWnNa8WWk,14502
@@ -106,15 +110,29 @@ onnx_diagnostic/torch_export_patches/patch_module_helper.py,sha256=2U0AdyZuU0W54
 onnx_diagnostic/torch_export_patches/eval/__init__.py,sha256=YQoOGt9XQLWqnJ15NnT7ri_jDevfvpuQwEJo38E-VRU,25056
 onnx_diagnostic/torch_export_patches/eval/model_cases.py,sha256=9h4yo9vKiK-E6zaXyAsxXGM-lCjd88ONybA1F3YcTI4,27988
 onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_attention.py,sha256=kI0qgAGFxkyvx8wikQtPcik_zpPpTAQypQ1cMQsjetw,7730
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_cache_utils.py,sha256=UdxLii-od2OpQmUJbmXmZinXeLBItVFrr75BVT1Y0zw,2041
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_causal_mask.py,sha256=h37DPVxsq8iAWECnTlKW5tVqSBgPBF52xr3uxsjdi2k,3113
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_dynamic_cache.py,sha256=lEdYqX60pyi_w6PrbCTk7NC96nB8FFcFRf_JMjXSAZE,7961
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_gemma3.py,sha256=nVgYQk0xXpHiictN1wOHVMN2lTH9b0vfIJ4ie-uKopg,1999
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_generation_mixin.py,sha256=VIZsVHgR8NmAcBQalPl5I6ZzNgcBxjGb6ars31m9gRg,21936
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_idefics.py,sha256=kTjuTRsfkGGGhspJnMxAMQSchZgGC_IruJzpHh_FmI8,6348
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_masking_utils.py,sha256=R4YwnN9ktxjjImiJtLRxiKtKLr9LuFlwkPXkTJ6BTIo,6895
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_qwen2.py,sha256=OxYdlLrwtd_KGHt3E17poduxvWFg-CfGS57-yN1i6gI,3827
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_qwen2_5.py,sha256=-THcoMvJ1MhLZFQP6c2IEGqpkY7sTg_xYyAwCE7_91o,29511
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_qwen3.py,sha256=cND9Iqo1aKdlX-BXGr9Qlq_Y4EW1L5VWSwZfqYTVazU,4888
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_rotary_embedding.py,sha256=4bJ_z2gizZQla_fcCVt0dmuhzO9Vu-D7CCMWdxMlrKM,16893
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_sam_mask_decoder.py,sha256=-6TuBm3sLAFEGuW3vRfOTtE5uP6aINFfu7xMnl27Dws,5703
+onnx_diagnostic/torch_export_patches/patches/patch_helper.py,sha256=kK_CGW643iVXxa-m6pttDBS7HTyMQaPypza7iqIInn4,721
 onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=FfES0WWiWxmuQbGTlQ7IJS0YBG7km3IQbnMYwk_lPPU,44667
-onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=8r5NQxVfwPi9YVHmeGS5xN52wsa5IgUKzFxls3xuX4Y,109850
+onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=VAfZj0xu3D4CG71SWv-9sYPUK4ZQTSz2-x4qxP4DxGE,3079
 onnx_diagnostic/torch_export_patches/serialization/__init__.py,sha256=BHLdRPtNAtNPAS-bPKEj3-foGSPvwAbZXrHzGGPDLEw,1876
 onnx_diagnostic/torch_export_patches/serialization/diffusers_impl.py,sha256=drq3EH_yjcSuIWYsVeUWm8Cx6YCZFU6bP_1PLtPfY5I,945
 onnx_diagnostic/torch_export_patches/serialization/transformers_impl.py,sha256=sIHFvUQoMK8ytXQYB-k7OL62z8A3f5uDaq-S5R5uN-M,10034
 onnx_diagnostic/torch_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_models/code_sample.py,sha256=PWf7piGx7Eiv7BOTpL2bLUtWwaVcw7SMBvkSpEzZDPs,12883
 onnx_diagnostic/torch_models/llms.py,sha256=soyg4yC87ptGoeulJhKqw5opGmuLvH1pn_ZDXZ4Jr8E,90
-onnx_diagnostic/torch_models/validate.py,sha256=jzBgZRKCzpWH25rCoc6b0QsLQlmQXSzLzAntgXzIdWc,92569
+onnx_diagnostic/torch_models/validate.py,sha256=yhcCjZJ7pgjeHQBV-rCbQJ-ot_tngEwSYoonyNhEH5g,94426
 onnx_diagnostic/torch_models/hghub/__init__.py,sha256=vi1Q7YHdddj1soiBN42MSvJdFqe2_KUoWafHISjwOu8,58
 onnx_diagnostic/torch_models/hghub/hub_api.py,sha256=rFbiPNLET-KdBpnv-p0nKgwHX6d7C_Z0s9zZ86_92kQ,14307
 onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=8V_pAgACPLPsLRYUododg7MSL6str-T3tBEGY4OaeYQ,8724
@@ -126,9 +144,10 @@ onnx_diagnostic/torch_models/untrained/llm_phi2.py,sha256=y_akbdApi136qHcEQgykwI
 onnx_diagnostic/torch_models/untrained/llm_tiny_llm.py,sha256=QXw_Bs2SzfeiQMf-tmtVl83SmVOL4-Um7Qy-f0E48QI,2507
 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=IoKLA5UwS6kY8g4OOf_bdQwCziIsQfBczZ3w8wo4wZM,16905
-onnx_diagnostic-0.8.2.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.8.2.dist-info/METADATA,sha256=JbEdP7KIm9D1xwdr9Hot2BNxC2ZX9_YeBkdo6oy6UvQ,6734
-onnx_diagnostic-0.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_diagnostic-0.8.2.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.8.2.dist-info/RECORD,,
+onnx_diagnostic/torch_onnx/sbs.py,sha256=Q2nbj1Ovasf_HDFc5_tNVH8taJhzhgUXPY6N1uajayk,40615
+onnx_diagnostic/torch_onnx/sbs_dataclasses.py,sha256=ctJitdW09gLhg900yjT-Zqbx8SU2n4ZdgyVZ47dmlvQ,18475
+onnx_diagnostic-0.8.3.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.8.3.dist-info/METADATA,sha256=MsLK613cwgCcvJ4JkLvP2ysF48KEgTmzqm83IBUO5JM,6734
+onnx_diagnostic-0.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.8.3.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.8.3.dist-info/RECORD,,