onnx-diagnostic 0.8.5__py3-none-any.whl → 0.8.6__py3-none-any.whl

onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py

@@ -55,6 +55,7 @@ Automatically generated:
 import base64
 import json
 import textwrap
+from typing import Any
 import transformers
 
 null = None
@@ -62,6 +63,22 @@ true = True
 false = False
 
 
+def _enforce_default(config_type: type, **kwargs) -> Any:
+    config = config_type(**kwargs)
+    for name in [
+        *[k for k in kwargs if k.endswith("_token_id")],
+        "attention_dropout",
+        "hidden_size",
+        "hidden_act",
+        "intermediate_size",
+        "max_position_embeddings",
+        "vocab_size",
+    ]:
+        if name in kwargs and (not hasattr(config, name) or getattr(config, name) is None):
+            setattr(config, name, kwargs[name])
+    return config
+
+
 def _ccached_arnir0_tiny_LLM():
     "arnir0/Tiny-LLM"
     return transformers.LlamaConfig(
@@ -4691,7 +4708,8 @@ def _ccached_zai_glm_45():
 
 def _ccached_microsoft_phi3_mini_128k_instruct():
     "microsoft/Phi-3-mini-128k-instruct"
-    return transformers.Phi3Config(
+    return _enforce_default(
+        transformers.Phi3Config,
         **{
             "_name_or_path": "Phi-3-mini-128k-instruct",
             "architectures": ["Phi3ForCausalLM"],
@@ -4827,13 +4845,14 @@ def _ccached_microsoft_phi3_mini_128k_instruct():
             "use_cache": true,
             "attention_bias": false,
             "vocab_size": 32064,
-        }
+        },
     )
 
 
 def _ccached_google_gemma_3_4b_it_like():
     "google/gemma-3-4b-it"
-    return transformers.Gemma3Config(
+    return _enforce_default(
+        transformers.Gemma3Config,
         **{
             "architectures": ["Gemma3ForConditionalGeneration"],
             "boi_token_index": 255999,
@@ -4863,13 +4882,14 @@ def _ccached_google_gemma_3_4b_it_like():
                 "patch_size": 14,
                 "vision_use_head": false,
             },
-        }
+        },
     )
 
 
 def _ccached_hf_internal_testing_tiny_random_gemma3_for_causal_lm():
     "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
-    return transformers.Gemma3TextConfig(
+    return _enforce_default(
+        transformers.Gemma3TextConfig,
         **{
             "architectures": ["Gemma3ForCausalLM"],
             "attention_bias": false,
@@ -4901,13 +4921,14 @@ def _ccached_hf_internal_testing_tiny_random_gemma3_for_causal_lm():
             "transformers_version": "4.52.0.dev0",
             "use_cache": true,
             "vocab_size": 262144,
-        }
+        },
     )
 
 
 def _ccached_qwen_qwen2_5_vl_7b_instruct():
     "Qwen/Qwen2.5-VL-7B-Instruct"
-    return transformers.Qwen2_5_VLConfig(
+    return _enforce_default(
+        transformers.Qwen2_5_VLConfig,
         **{
             "architectures": ["Qwen2_5_VLForConditionalGeneration"],
             "attention_dropout": 0.0,
@@ -4954,5 +4975,5 @@ def _ccached_qwen_qwen2_5_vl_7b_instruct():
             },
             "rope_scaling": {"type": "mrope", "mrope_section": [16, 24, 24]},
             "vocab_size": 152064,
-        }
+        },
     )

onnx_diagnostic/torch_onnx/compare.py

@@ -0,0 +1,357 @@
+import enum
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union
+import numpy as np
+import onnx
+from ..helpers.onnx_helper import onnx_dtype_name
+
+
+_NOT_SO_FAR_OPS = [
+    {"MatMul", "Gemm", "FusedMatMul"},
+    {"Conv", "FusedConv"},
+    {"MaxPool"},
+]
+
+
+def _sum_sets(sets):
+    t = set()
+    for s in sets:
+        t |= s
+    return t
+
+
+_ALL_NOT_SO_FAR_OPS = _sum_sets(_NOT_SO_FAR_OPS)
+
+
+def _align(res: str, limit: int) -> str:
+    if len(res) == limit:
+        return res
+    if len(res) > limit:
+        return res[:limit]
+    return res + " " * (limit - len(res))
+
+
+class ObsType(enum.IntEnum):
+    """Observation kind."""
+
+    RESULT = 1
+    INITIALIZER = 2
+    SPARSE_INITIALIZER = 4
+    INPUT = 8
+    OUTPUT = 16
+    NODE = 32
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}.{self._name_}"
+
+
+@dataclass
+class ObsCompare:
+    """
+    The description of an observation, a node, an input, an output, an initializer.
+
+    :param position: index of this observation in the original model
+    :param kind: node type, see :class:`ObsType`
+    :param name_or_outputs: name of an initializer or the outputs of a node
+    :param itype: onnx type
+    :param index: index of an input or output
+    :param shape: shape
+    :param op_type: node op_type
+    :param comment: comment, unused
+    """
+
+    position: int
+    kind: ObsType
+    name_or_outputs: Tuple[str]
+    itype: int = 0
+    index: int = 0
+    shape: Optional[Tuple[Tuple[Union[int, str], ...]]] = None
+    op_type: str = ""
+    comment: str = ""
+
+    def __str__(self) -> str:
+        "usual"
+        els = [
+            _align(f"{self.position:04d}", 4),
+            _align(self.kind._name_, 6),
+            _align(onnx_dtype_name(self.itype) if self.itype else "?", 8),
+            _align("?" if self.shape is None else "x".join(map(str, self.shape)), 18),
+            _align(self.op_type or "", 15),
+            _align(", ".join(self.name_or_outputs), 35),
+        ]
+        return " ".join(els)
+
+    @classmethod
+    def to_str(cls, obs: Optional["ObsCompare"]) -> str:
+        assert not obs or isinstance(obs, ObsCompare), f"unexpected type {type(obs)}"
+        if obs:
+            return str(obs)
+        return " " * (4 + 6 + 8 + 18 + 15 + 35 + 5)
+
+    def distance(self, obs: "ObsCompare") -> float:
+        """Computes a cost between two observations."""
+        if self.kind != obs.kind:
+            return 1e6
+        d: float = 0
+        if self.itype != obs.itype:
+            d += 1e5
+        if self.kind == ObsType.NODE:
+            cost = 9997
+            d = 0
+            if self.op_type != obs.op_type:
+                if self.op_type in _ALL_NOT_SO_FAR_OPS or obs.op_type in _ALL_NOT_SO_FAR_OPS:
+                    d += 1e2
+                    for aset in _NOT_SO_FAR_OPS:
+                        if self.op_type in aset and obs.op_type in aset:
+                            cost = 97
+                        elif self.op_type in aset or obs.op_type in aset:
+                            d += 5e4
+                else:
+                    d += 9e2
+            if len(self.name_or_outputs) == 1 and len(obs.name_or_outputs) == 1:
+                if self.name_or_outputs[0] != obs.name_or_outputs[0]:
+                    n1 = self.name_or_outputs[0]
+                    n2 = obs.name_or_outputs[0]
+                    n1 = n1.replace("_", "")
+                    n2 = n2.replace("_", "")
+                    if n1 == n2:
+                        d += 1
+                    elif (n1.startswith(("val_", "_onx_")) or "::" in n1 or "--" in n1) and (
+                        n2.startswith(("val_", "_onx_")) or "::" in n2 or "--" in n2
+                    ):
+                        # These are name given the exporter
+                        # and not inspired from the model itself.
+                        d += cost / 100
+                    else:
+                        d += cost
+            else:
+                a = set(self.name_or_outputs) & set(obs.name_or_outputs)
+                b = set(self.name_or_outputs) | set(obs.name_or_outputs)
+                d += cost * (len(b) - len(a))
+            return d
+        if self.kind == ObsType.INPUT:
+            return (
+                999.7
+                if self.itype != obs.itype
+                or self.shape != obs.shape
+                or self.index != obs.index
+                else 0
+            )
+        if self.kind == ObsType.INITIALIZER or self.kind == ObsType.SPARSE_INITIALIZER:
+            return 1e3 if self.itype != obs.itype or self.shape != obs.shape else 0
+        if self.kind == ObsType.OUTPUT:
+            return (
+                999.1
+                if self.itype != obs.itype
+                or self.shape != obs.shape
+                or self.index != obs.index
+                else 0
+            )
+        return 1e8
+
+    @classmethod
+    def obs_sequence_from_model(
+        cls,
+        model: Union[onnx.ModelProto, onnx.GraphProto],
+    ) -> List["ObsCompare"]:
+        """
+        Creates a sequence of observations bases on a model.
+
+        :param model: model
+        :return: sequence of observations
+        """
+        graph = model if isinstance(model, onnx.GraphProto) else model.graph
+
+        shapes = {}
+        types = {}
+        for info in [*graph.value_info, *graph.input, *graph.output]:
+            if info.type.tensor_type:
+                t = info.type.tensor_type
+                shapes[info.name] = tuple((d.dim_param or d.dim_value) for d in t.shape.dim)
+                types[info.name] = t.elem_type
+
+        seq: List[ObsCompare] = []
+        for init in graph.initializer:
+            obs = ObsCompare(
+                position=len(seq),
+                kind=ObsType.INITIALIZER,
+                itype=init.data_type,
+                shape=tuple(init.dims),
+                name_or_outputs=(init.name,),
+            )
+            seq.append(obs)
+        for i, inp in enumerate(graph.input):
+            obs = ObsCompare(
+                position=len(seq),
+                kind=ObsType.INPUT,
+                itype=inp.type.tensor_type.elem_type,
+                index=i,
+                shape=tuple(
+                    (d.dim_param or d.dim_value) for d in inp.type.tensor_type.shape.dim
+                ),
+                name_or_outputs=(inp.name,),
+            )
+            seq.append(obs)
+        for node in graph.node:
+            obs = ObsCompare(
+                position=len(seq),
+                kind=ObsType.NODE,
+                itype=types.get(node.output[0], 0),
+                index=i,
+                shape=shapes.get(node.output[0], None),
+                name_or_outputs=tuple(node.output),
+                op_type=node.op_type,
+            )
+            seq.append(obs)
+        for i, inp in enumerate(graph.output):
+            obs = ObsCompare(
+                position=len(seq),
+                kind=ObsType.OUTPUT,
+                itype=inp.type.tensor_type.elem_type,
+                index=i,
+                shape=tuple(
+                    (d.dim_param or d.dim_value) for d in inp.type.tensor_type.shape.dim
+                ),
+                name_or_outputs=(inp.name,),
+            )
+            seq.append(obs)
+        return seq
+
+
+@dataclass
+class ObsComparePair:
+    """
+    Defines a pair of comparison objects
+
+    :param side1: object from first side
+    :param side2: object from first side
+    :param distance: distance
+    """
+
+    side1: Optional[ObsCompare]
+    side2: Optional[ObsCompare]
+    distance: float
+
+    def __str__(self) -> str:
+        "nice display"
+        return (
+            f"{self.distance:.4e} | "
+            f"{ObsCompare.to_str(self.side1)} | {ObsCompare.to_str(self.side2)}"
+        )
+
+    @classmethod
+    def to_str(cls, seq: List["ObsComparePair"]) -> str:
+        """Displays every pair in text."""
+        return "\n".join([f"{str(pair)}" for pair in seq])
+
+    @classmethod
+    def distance_sequence(cls, s1: List["ObsCompare"], s2: List["ObsCompare"]) -> Tuple[
+        float,
+        List[Tuple[int, int]],
+        List["ObsComparePair"],
+    ]:
+        """
+        Computes the distance between two sequences of results.
+
+        :param s1: first sequence
+        :param s2: second sequence
+        :return: distance and alignment
+
+        An example:
+
+        .. runpython::
+            :showcode:
+
+            import torch
+            from onnx_diagnostic.export.api import to_onnx
+            from onnx_diagnostic.torch_onnx.compare import ObsComparePair, ObsCompare
+
+
+            class Model(torch.nn.Module):
+                def __init__(self):
+                    super().__init__()
+                    self.conv1 = torch.nn.Conv2d(3, 16, 5)
+                    self.fc1 = torch.nn.Linear(144, 64)
+                    self.fc2 = torch.nn.Linear(64, 128)
+                    self.fc3 = torch.nn.Linear(128, 10)
+
+                def forward(self, x):
+                    x = torch.nn.functional.max_pool2d(
+                        torch.nn.functional.relu(self.conv1(x)),
+                        (4, 4),
+                    )
+                    # x = F.max_pool2d(F.relu(self.conv2(x)), 2)
+                    x = torch.flatten(x, 1)
+                    x = torch.nn.functional.relu(self.fc1(x))
+                    x = torch.nn.functional.relu(self.fc2(x))
+                    y = self.fc3(x)
+                    return y
+
+
+            model = Model()
+            x = torch.randn((2, 3, 16, 17), dtype=torch.float32)
+            dynamic_shapes = ({0: "batch", 3: "dim"},)
+            onnx_optimized = to_onnx(
+                model, (x,), dynamic_shapes=dynamic_shapes, exporter="custom", optimize=True
+            ).model_proto
+            onnx_not_optimized = to_onnx(
+                model, (x,), dynamic_shapes=dynamic_shapes, exporter="custom", optimize=False
+            ).model_proto
+            seq1 = ObsCompare.obs_sequence_from_model(onnx_not_optimized)
+            seq2 = ObsCompare.obs_sequence_from_model(onnx_optimized)
+            _dist, _path, pair_cmp = ObsComparePair.distance_sequence(seq1, seq2)
+            text = ObsComparePair.to_str(pair_cmp)
+            print(text)
+        """
+        delay = max(50, abs(len(s2) - len(s1)) + 1)
+        distance: Dict[Tuple[int, int], Union[int, float]] = {(-1, -1): 0}
+        predecessor: Dict[Tuple[int, int], Optional[Tuple[int, int]]] = {(-1, -1): None}
+        insert_cost = 1e3
+        for i in range(len(s1)):
+            for j in range(max(0, i - delay), min(len(s2), i + delay)):
+                best = distance.get((i, j), 1e100)
+                pred = None
+                ki, kj = i - 1, j - 1
+                if (ki, kj) in distance:
+                    d = distance[ki, kj] + s1[i].distance(s2[j])
+                    if d < best:
+                        best = d
+                        pred = (ki, kj)
+                ki, kj = i - 1, j
+                if (ki, kj) in distance:
+                    d = distance[ki, kj] + insert_cost + 1
+                    if d < best:
+                        best = d
+                        pred = (ki, kj)
+                ki, kj = i, j - 1
+                if (ki, kj) in distance:
+                    d = distance[ki, kj] + insert_cost + 0.1
+                    if d < best:
+                        best = d
+                        pred = (ki, kj)
+                distance[i, j] = best
+                predecessor[i, j] = pred
+
+        # reverse
+        way = []
+        last: Optional[Tuple[int, int]] = len(s1) - 1, len(s2) - 1
+        while last is not None:
+            way.append(last)
+            last = predecessor[last]
+        indices = list(reversed(way))[1:]
+        obs_path: List[ObsComparePair] = []
+        last = -1, -1
+        for i, j in indices:
+            di = i - last[0]
+            dj = j - last[1]
+            cost = distance.get((i, j), np.nan)
+            if di == dj == 1:
+                obs_path.append(ObsComparePair(s1[i], s2[j], distance=cost))
+            elif di == 0:
+                obs_path.append(ObsComparePair(None, s2[j], distance=cost))
+            elif dj == 0:
+                obs_path.append(ObsComparePair(s1[i], None, distance=cost))
+            else:
+                raise RuntimeError(f"issue with di={di}, dj={dj}")
+            last = i, j
+        return distance[len(s1) - 1, len(s2) - 1], indices, obs_path

{onnx_diagnostic-0.8.5.dist-info → onnx_diagnostic-0.8.6.dist-info}/METADATA

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

{onnx_diagnostic-0.8.5.dist-info → onnx_diagnostic-0.8.6.dist-info}/RECORD

@@ -1,14 +1,16 @@
-onnx_diagnostic/__init__.py,sha256=dCiBK_S7EOo_rAsmsgv-laLhtKzE2uny0XIR5aO4eDk,173
+onnx_diagnostic/__init__.py,sha256=YQit5D2idhb9-wNQZzvWLT_qwRrKWBoTqMpNlBaWsGw,173
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
-onnx_diagnostic/_command_lines_parser.py,sha256=ZFJdQP1Ee8D5a_xUch-0CHaYbbILztejTjVdyc9KrMw,52667
+onnx_diagnostic/_command_lines_parser.py,sha256=AWT6XrphbR0C0w9J846jPcRWkoUtnSSAX7gdR-JavQ4,54258
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
 onnx_diagnostic/doc.py,sha256=t3RELgfooYnVMAi0JSpggWkQEgUsREz8NmRvn0TnLI8,2829
-onnx_diagnostic/ext_test_case.py,sha256=rVZWqFEfnvwnsD3wF4jeDblh5uj5ckZ8C6DZQ0RGb_E,49599
+onnx_diagnostic/ext_test_case.py,sha256=KxRC6s9107hYvNgU9x2B85rj8_EhAtymPIlMpmkUNu8,50154
+onnx_diagnostic/ci_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onnx_diagnostic/ci_models/ci_helpers.py,sha256=6CKQ4dVHBHeF6rN_Q3Y_0ZFeLYbYQbGQO3YyW3PQyAc,15341
+onnx_diagnostic/ci_models/export_qwen25_vl.py,sha256=pyxmMIps9aDNkXzDAFrG8Q9DDOsEyKRHjoVvAggjFdU,20050
 onnx_diagnostic/export/__init__.py,sha256=yEIoWiOeTwBsDhyYt2fTKuhtA0Ya1J9u9ZzMTOTWaWs,101
 onnx_diagnostic/export/api.py,sha256=BX4c99gMlRYsBWk3P15FMRogArxjP4dXYXP5gILjgIk,10626
-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=RuYz9_eM42Bk6TKSiPV6dS68LIMZu-6WBCFCKoSvjrk,5422
+onnx_diagnostic/export/cf_simple_loop_for.py,sha256=0I1tRAwhmmqA-6Qaq8AiUL0Ci-HODuRAVcI9azNcxAQ,13345
+onnx_diagnostic/export/control_flow_onnx.py,sha256=izGlctqQANrHzSxPMbT7hoauNbnIBdx6hb8ry7HtVmM,18263
 onnx_diagnostic/export/dynamic_shapes.py,sha256=M2hlpHSTbkzZwGKAbrpQXng5HQrwjF5Z6wGGxEgnp74,42061
 onnx_diagnostic/export/onnx_plug.py,sha256=U13fL0BjnhMzcDGxaAOqM4TQte5Z4zKDg4ESS0iktjM,22704
 onnx_diagnostic/export/shape_helper.py,sha256=m628y0oRCQbeZkeh8JDHIfWMsSjoJoeX-IPiPGDHT-w,11273
@@ -100,7 +102,7 @@ onnx_diagnostic/tasks/zero_shot_image_classification.py,sha256=jJCMWuOqGv5ahCfjr
 onnx_diagnostic/tasks/data/__init__.py,sha256=uJoemrWgEjI6oA-tMX7r3__x-b3siPmkgqaY7bgIles,401
 onnx_diagnostic/tasks/data/dummies_imagetext2text_generation_gemma3.onnx,sha256=UbtvmWMqcZOKJ-I-HXWI1A6YR6QDaFS5u_yXm5C3ZBw,10299
 onnx_diagnostic/torch_export_patches/__init__.py,sha256=0SaZedwznm1hQUCvXZsGZORV5vby954wEExr5faepGg,720
-onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=WPb8Ku643UIV8kDyt9JUpaJBIVXth9UbteCNctd_yis,41863
+onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=OpZHNWiA0iU-6WCFZcVCj06_MopYiZQ6c6CbAuSQ8Ms,42357
 onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=0HdubI06EGpxOICqDWZoVmZkVO9gAaFADEmby197EyM,11935
 onnx_diagnostic/torch_export_patches/patch_details.py,sha256=MSraVo5ngBhihi8ssPMXSY9B4fJ17J-GAADaw3dT-rc,11794
 onnx_diagnostic/torch_export_patches/patch_expressions.py,sha256=vr4tt61cbDnaaaduzMj4UBZ8OUtr6GfDpIWwOYqjWzs,3213
@@ -119,13 +121,13 @@ onnx_diagnostic/torch_export_patches/patches/_patch_transformers_generation_mixi
 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=HE3fovyvMiYe9EPz1UjdD9AWopX3H188SMwPb8w5mzM,7111
 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=GS7IDHyRaLAsbZE5k7KN-ZT5-ezbmEUzXPJ_xG4SulA,31601
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_qwen2_5.py,sha256=yALbXWi3ysJ6nzQD-rxTdxdNJiBsTbYEBIj4TdksDOA,34598
 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=VAfZj0xu3D4CG71SWv-9sYPUK4ZQTSz2-x4qxP4DxGE,3079
+onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=Mvq8q1Lz3l3GyCD6j8WQjbrPk_V2dnc4iKm3cC_o1OA,3112
 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
@@ -136,18 +138,19 @@ onnx_diagnostic/torch_models/validate.py,sha256=fnbTl5v1n5nM2MpmCgCMaWa6c7DGpb5m
 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
-onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=GimzkI8W3guATkDx7RQ-w2xNGVaFDVegfTnnmNxf4iE,292068
+onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=Dxa13rsnTQ8eH_BcQvbY2bp1AYFtzuFrJ-J_urrSmeQ,292694
 onnx_diagnostic/torch_models/hghub/model_inputs.py,sha256=tCGqigRyY1omxm2rczRUvCTsweZGbF1MccWI3MmCH20,17423
 onnx_diagnostic/torch_models/hghub/model_specific.py,sha256=j50Nu7wddJMoqmD4QzMbNdFDUUgUmSBKRzPDH55TlUQ,2498
 onnx_diagnostic/torch_models/untrained/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_models/untrained/llm_phi2.py,sha256=y_akbdApi136qHcEQgykwIAYVw0Yfi0lbjb3DNuafaU,3948
 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/compare.py,sha256=O0lws4kzn8WAXr8-x-YMPr7oyBC9DtSIs4OfOr4S5-E,12305
 onnx_diagnostic/torch_onnx/runtime_info.py,sha256=u1bD6VXqzBCRmqmbzQtDswaPs1PH_ygr1r-CrcfXpNU,8562
 onnx_diagnostic/torch_onnx/sbs.py,sha256=8okBEIupMgw7TtKc80YFimMtwnY3GchdY05FsA9ooa0,40749
 onnx_diagnostic/torch_onnx/sbs_dataclasses.py,sha256=UctdBjzoPTQG1LS0tZ8A6E9hpoq5HWUYaJLPOPJc9FI,20299
-onnx_diagnostic-0.8.5.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.8.5.dist-info/METADATA,sha256=A54IonPIcnualwiRJhvjRMfhF3p3jdXhEH1vTtZBgyE,6734
-onnx_diagnostic-0.8.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_diagnostic-0.8.5.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.8.5.dist-info/RECORD,,
+onnx_diagnostic-0.8.6.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.8.6.dist-info/METADATA,sha256=9xPlJ9UHYSSIyEMqxN14mqZg31Rq9jqzHaczfqWhu-4,6734
+onnx_diagnostic-0.8.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.8.6.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.8.6.dist-info/RECORD,,