onnx-diagnostic 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

onnx_diagnostic/torch_export_patches/onnx_export_errors.py

@@ -107,7 +107,7 @@ def torch_export_patches(
 ) -> Callable:
     """
     Tries to bypass some situations :func:`torch.export.export` does not support.
-    See also :ref:`l-patches-explained`.
+    See also :ref:`l-patches-explained` and :ref:`l-patch-coverage`.
 
     :param patch_sympy: fix missing method ``name`` for IntegerConstant
     :param patch_torch: patches :epkg:`torch` with supported implementation
@@ -140,6 +140,7 @@ def torch_export_patches(
     * ``torch.jit.isinstance``
     * ``torch._dynamo.mark_static_address``
     * ``torch._subclasses.fake_impls.infer_size``
+    * ``torch.vmap``
     * fix missing method ``name`` for ``sympy.S.IntegerConstant``
     * ``AttentionMaskConverter._make_causal_mask``
     * Serialization of ``MambaCache`` (in :epkg:`transformers`)
@@ -251,6 +252,7 @@ def torch_export_patches(
         if patch_torch:
             from .patches.patch_torch import (
                 patched_infer_size,
+                patched_vmap,
                 patched__broadcast_shapes,
                 _catch_produce_guards_and_solve_constraints,
                 patch__check_input_constraints_for_graph,
@@ -261,6 +263,10 @@ def torch_export_patches(
                 print(f"[torch_export_patches] stop_if_static={stop_if_static!r}")
                 print("[torch_export_patches] patch pytorch")
 
+            # torch.vmap
+            f_vmap = torch.vmap
+            torch.vmap = patched_vmap
+
             # torch.jit.isinstance
             f_jit_isinstance = torch.jit.isinstance
             torch.jit.isinstance = isinstance
@@ -328,6 +334,11 @@ def torch_export_patches(
         ####################
 
         if patch_transformers:
+            try:
+                import transformers.masking_utils as masking_utils
+            except ImportError:
+                masking_utils = None
+
             if verbose:
                 import transformers
 
@@ -339,6 +350,15 @@ def torch_export_patches(
                 patch_transformers_list, verbose=verbose
             )
 
+            if masking_utils and hasattr(masking_utils, "_vmap_for_bhqkv"):
+                if verbose:
+                    print(
+                        "[torch_export_patches] patches "
+                        "transformers.masking_utils._vmap_for_bhqkv"
+                    )
+                f_transformers__vmap_for_bhqkv = masking_utils._vmap_for_bhqkv
+                masking_utils._vmap_for_bhqkv = patch_transformers_list.patched__vmap_for_bhqkv
+
         if custom_patches:
             if verbose:
                 print("[torch_export_patches] applies custom patches")
@@ -381,6 +401,7 @@ def torch_export_patches(
 
             if patch_torch:
                 # this should disappear when torch.jit is removed
+                torch.vmap = f_vmap
                 torch.jit.isinstance = f_jit_isinstance
                 torch._dynamo.mark_static_address = f_mark_static_address
                 # tracked by https://github.com/pytorch/pytorch/issues/143495
@@ -430,12 +451,24 @@ def torch_export_patches(
             ##############
 
             if patch_transformers:
+                try:
+                    import transformers.masking_utils as masking_utils
+                except ImportError:
+                    masking_utils = None
                 if verbose:
                     print("[torch_export_patches] unpatch transformers")
                 unpatch_module_or_classes(
                     patch_transformers_list, revert_patches_info, verbose=verbose
                 )
 
+                if masking_utils and hasattr(masking_utils, "_vmap_for_bhqkv"):
+                    if verbose:
+                        print(
+                            "[torch_export_patches] unpatch "
+                            "transformers.masking_utils._vmap_for_bhqkv"
+                        )
+                    masking_utils._vmap_for_bhqkv = f_transformers__vmap_for_bhqkv
+
             ########
             # caches
             ########

onnx_diagnostic/torch_export_patches/onnx_export_serialization.py

@@ -1,5 +1,5 @@
 import pprint
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
 import packaging.version as pv
 import optree
 import torch
@@ -133,6 +133,11 @@ def register_cache_serialization(verbose: int = 0) -> Dict[str, bool]:
         # To avoid doing it multiple times.
         PATCH_OF_PATCHES.add(BaseModelOutput)
 
+    return serialization_functions(verbose=verbose)
+
+
+def serialization_functions(verbose: int = 0) -> Dict[str, Union[Callable, int]]:
+    """Returns the list of serialization functions."""
     return dict(
         DynamicCache=register_class_serialization(
             DynamicCache,

onnx_diagnostic/torch_export_patches/patch_module_helper.py

@@ -19,6 +19,28 @@ def ast_or_into_bitor(node: "ast.Node") -> "ast.Node":
     return new_node
 
 
+def _rewrite_bart_encoder_layer():
+    "BartEncoderLayer, PLBartEncoderLayer"
+    import transformers
+
+    bd = dict(
+        filter_node=(
+            lambda node: isinstance(node, ast.If) and not isinstance(node.test, ast.Name)
+        ),
+        pre_rewriter=ast_or_into_bitor,
+    )
+
+    def _add(f):
+        g = bd.copy()
+        g["function"] = f
+        return g
+
+    return [
+        _add(transformers.models.bart.modeling_bart.BartEncoderLayer.forward),
+        _add(transformers.models.plbart.modeling_plbart.PLBartEncoderLayer.forward),
+    ]
+
+
 def code_needing_rewriting(cls_name: str) -> Optional[List[Any]]:
     """
     Returns a known list of methods or functions to rewrite because of control flow
@@ -30,11 +52,12 @@ def code_needing_rewriting(cls_name: str) -> Optional[List[Any]]:
     .. runpython::
         :showcode:
 
+        import pprint
         from onnx_diagnostic.torch_export_patches.patch_module_helper import (
             code_needing_rewriting,
         )
 
-        print(code_needing_rewriting("BartForConditionalGeneration"))
+        pprint.pprint(code_needing_rewriting("BartForConditionalGeneration"))
     """
     if cls_name in {
         "BartEncoderLayer",
@@ -42,22 +65,5 @@ def code_needing_rewriting(cls_name: str) -> Optional[List[Any]]:
         "PLBartEncoderLayer",
         "PLBartForConditionalGeneration",
     }:
-        import transformers
-
-        bd = dict(
-            filter_node=(
-                lambda node: isinstance(node, ast.If) and not isinstance(node.test, ast.Name)
-            ),
-            pre_rewriter=ast_or_into_bitor,
-        )
-
-        def _add(f):
-            g = bd.copy()
-            g["function"] = f
-            return g
-
-        return [
-            _add(transformers.models.bart.modeling_bart.BartEncoderLayer.forward),
-            _add(transformers.models.plbart.modeling_plbart.PLBartEncoderLayer.forward),
-        ]
+        return _rewrite_bart_encoder_layer()
     return None

onnx_diagnostic/torch_export_patches/patches/patch_torch.py

@@ -370,3 +370,94 @@ class patched_ShapeEnv:
         #     RuntimeWarning,
         #     stacklevel=0,
         # )
+
+
+def patched_vmap(func, in_dims=0, out_dims=0):
+    """
+    Python implementation of :func:`torch.vmap`.
+    The implementation raises an issue when it is being exported with
+    :func:`torch.export.export` when the function is called with
+    non tensors arguments and the batch size is dynamic.
+    """
+    from ...helpers import string_type
+
+    def wrapped(*args):
+        assert all(not isinstance(a, dict) for a in args), (
+            f"dictionaries are not implemented in "
+            f"args={string_type(args, with_shape=True)}"
+        )
+
+        in_dims_ = (
+            ([in_dims] * len(args))
+            if not isinstance(in_dims, (list, tuple))
+            else list(in_dims)
+        )
+        assert len(in_dims_) == len(args), (
+            f"Mismtch between in_dims={in_dims_} and "
+            f"args={string_type(args, with_shape=True)}"
+        )
+
+        batch_size = None
+        batched_args = []
+        for arg, in_dim in zip(args, in_dims_):
+            if in_dim is None:
+                batched_args.append(arg)
+                continue
+
+            assert batch_size is None or batch_size == arg.size(in_dim), (
+                f"Unable to continue, batch_size={batch_size}, in_dim={in_dim}, "
+                f"arg.size(in_dim)={arg.size(in_dim)}"
+            )
+            if batch_size is None:
+                batch_size = arg.size(in_dim)
+            arg = arg.movedim(in_dim, 0)
+            batched_args.append(arg)
+
+        if all(isinstance(a, torch.Tensor) for a in args) and isinstance(
+            batch_size, torch.SymInt
+        ):
+            batched_tensors = [
+                (
+                    arg
+                    if (isinstance(arg, torch.Tensor) and in_dim is not None)
+                    else arg.unsqueeze(0).expand((batch_size, *arg.shape))
+                )
+                for arg, in_dim in zip(batched_args, in_dims_)
+            ]
+            results = torch.ops.higher_order.scan(func, [], batched_tensors, [])
+            stacked = results[0]
+            if out_dims != 0:
+                return stacked.movedim(0, out_dims)
+            return stacked
+
+        else:
+            torch._check(
+                not isinstance(batch_size, torch.SymInt),
+                lambda: (
+                    f"patched_vmap supports dynamic batch_size only if all argument "
+                    f"are tensors but types are {[type(a) for a in args]}"
+                ),
+            )
+            batched_tensors = [
+                (
+                    (None, arg)
+                    if (isinstance(arg, torch.Tensor) and in_dim is not None)
+                    else (arg, arg)
+                )
+                for arg, in_dim in zip(batched_args, in_dims_)
+            ]
+
+            results = []
+            for i in range(batch_size):
+                input_slice = [v if v is not None else arg[i] for v, arg in batched_tensors]
+                result = func(*input_slice)
+                results.append(result)
+
+            if isinstance(results[0], torch.Tensor):
+                stacked = torch.stack(results)
+                if out_dims != 0:
+                    return stacked.movedim(0, out_dims)
+                return stacked
+            return results
+
+    return wrapped

onnx_diagnostic/torch_export_patches/patches/patch_transformers.py

@@ -1,6 +1,6 @@
 import inspect
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 import torch
 import transformers
 from transformers.modeling_attn_mask_utils import AttentionMaskConverter
@@ -9,6 +9,34 @@ from ...ext_test_case import has_transformers
 from ...helpers.torch_helper import is_torchdynamo_exporting
 
 
+def patched__vmap_for_bhqkv(mask_function: Callable, bh_indices: bool = True) -> Callable:
+    """Patch for function ``transformers.masking_utils._vmap_for_bhqkv``."""
+    from ...helpers import string_type
+
+    dimensions: List[Tuple[Optional[int], ...]] = [
+        (None, None, None, 0),
+        (None, None, 0, None),
+    ]
+    if bh_indices:
+        dimensions.extend([(None, 0, None, None), (0, None, None, None)])
+    dimensions = [tuple(1 if d is None else -1 for d in shape) for shape in dimensions]
+    dimensions = tuple(reversed(dimensions))
+    indices = tuple(shape.index(-1) for shape in dimensions)
+
+    def vector_mask_function(
+        *args, mask_function=mask_function, dimensions=dimensions, indices=indices
+    ):
+        assert len(args) == len(
+            dimensions
+        ), f"Mismatch between args={string_type(args)} and dimensions={dimensions}"
+        new_args = [a.reshape(shape) for a, shape in zip(args, dimensions)]
+        max_shape = tuple(args[i].shape[0] for i in indices)
+        expanded_args = [a.expand(max_shape) for a in new_args]
+        return mask_function(*expanded_args)
+
+    return vector_mask_function
+
+
 def _patch_make_causal_mask(
     input_ids_shape: torch.Size,
     dtype: torch.dtype,

onnx_diagnostic/torch_models/test_helper.py

@@ -345,8 +345,32 @@ def validate_model(
             )
         ),
     )
+
+    if exporter == "modelbuilder":
+        # Models used with ModelBuilder do not like batch size > 1.
+        # Let's change that.
+        for k in ["inputs", "inputs2"]:
+            if k not in data:
+                continue
+            if verbose:
+                print(f"[validate_model] set batch=1 for data[{k!r}]")
+                print(f"[validate_model] batch=1 === {string_type(data[k], with_shape=True)}")
+            cpl = CoupleInputsDynamicShapes(
+                tuple(), data[k], dynamic_shapes=data["dynamic_shapes"]
+            )
+            data[k] = cpl.change_dynamic_dimensions(
+                desired_values=dict(batch=1), only_desired=True
+            )
+            if verbose:
+                print(f"[validate_model] batch=1 --> {string_type(data[k], with_shape=True)}")
+
     data["input_options"] = iop
     data["model_options"] = mop
+    data["model_dump_folder"] = dump_folder
+    if dtype:
+        data["model_dtype"] = dtype if isinstance(dtype, str) else str(dtype)
+    if device:
+        data["model_device"] = str(device)
     if opset:
         data["model_opset"] = opset
     if "rewrite" in data:
@@ -555,6 +579,16 @@ def validate_model(
             begin = time.perf_counter()
             if isinstance(epo, onnx.model_container.ModelContainer):
                 epo.save(onnx_filename, all_tensors_to_one_file=True)
+            elif isinstance(epo, onnx.ModelProto):
+                if os.path.exists(f"{onnx_filename}.data"):
+                    os.remove(f"{onnx_filename}.data")
+                onnx.save(
+                    epo,
+                    onnx_filename,
+                    save_as_external_data=True,
+                    all_tensors_to_one_file=True,
+                    location=f"{os.path.split(onnx_filename)[-1]}.data",
+                )
             else:
                 epo.save(onnx_filename, external_data=True)
             duration = time.perf_counter() - begin
@@ -572,7 +606,8 @@ def validate_model(
             print("[validate_model] done (dump)")
 
     if not exporter or (
-        not exporter.startswith(("onnx-", "custom-")) and exporter != "custom"
+        not exporter.startswith(("onnx-", "custom-"))
+        and exporter not in ("custom", "modelbuilder")
     ):
         if verbose:
             print("[validate_model] -- done (final)")
@@ -704,6 +739,16 @@ def call_exporter(
             dump_folder=dump_folder,
         )
         return summary, data
+    if exporter == "modelbuilder":
+        # torch export
+        summary, data = call_torch_export_model_builder(
+            exporter=exporter,
+            data=data,
+            quiet=quiet,
+            verbose=verbose,
+            optimization=optimization,
+        )
+        return summary, data
     raise NotImplementedError(
         f"export with {exporter!r} and optimization={optimization!r} not implemented yet"
     )
@@ -871,6 +916,8 @@ def validate_onnx_model(
     if input_data_key in data:
         source = data[input_data_key]
         if not os.path.exists(source):
+            if verbose:
+                print(f"[validate_onnx_model] missing {source!r}")
             summary[_mk("ERR_onnx_missing")] = f"FileNotFoundError({source!r})"
             return summary, data
         summary[input_data_key] = source
@@ -911,12 +958,7 @@ def validate_onnx_model(
     if verbose:
         print("[validate_onnx_model] -- make_feeds...")
         print(f"[validate_onnx_model] inputs={string_type(data['inputs'], with_shape=True)}")
-    feeds = make_feeds(
-        [i.name for i in sess.get_inputs()],
-        data["inputs"],
-        use_numpy=True,
-        check_flatten=False,
-    )
+    feeds = make_feeds(sess, data["inputs"], use_numpy=True, check_flatten=False)
     if verbose:
         print(f"[validate_onnx_model] ort inputs={string_type(feeds, with_shape=True)}")
     summary[_mk("onnx_ort_inputs")] = string_type(feeds, with_shape=True)
@@ -1085,6 +1127,67 @@ def call_torch_export_onnx(
     return summary, data
 
 
+def call_torch_export_model_builder(
+    data: Dict[str, Any],
+    exporter: str,
+    quiet: bool = False,
+    verbose: int = 0,
+    optimization: Optional[str] = None,
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """
+    Exports a model into onnx with :epkg:`ModelBuilder`.
+
+    :param data: dictionary with all the necessary inputs, the dictionary must
+        contains keys ``model`` and ``inputs_export``
+    :param exporter: exporter to call
+    :param quiet: catch exception or not
+    :param verbose: verbosity
+    :param optimization: optimization to do
+    :return: two dictionaries, one with some metrics,
+        another one with whatever the function produces
+    """
+    from ..helpers.model_builder_helper import create_model_builder, save_model_builder
+
+    assert optimization in (
+        None,
+        "",
+    ), f"unexpected value for optimization={optimization}, none is available"
+    precision = data.get("model_dtype", "fp32")
+    provider = data.get("model_device", "cpu")
+    dump_folder = data.get("model_dump_folder", "")
+    assert dump_folder, "dump_folder cannot be empty with ModelBuilder"
+    cache_dir = os.path.join(dump_folder, "cache_mb")
+    if not os.path.exists(cache_dir):
+        os.makedirs(cache_dir)
+    summary: Dict[str, Any] = {}
+
+    epo = _quiet_or_not_quiet(
+        quiet,
+        "export_model_builder",
+        summary,
+        data,
+        (
+            lambda m=data["model"], c=data[
+                "configuration"
+            ], p=precision, pr=provider, cd=cache_dir: (
+                save_model_builder(
+                    create_model_builder(
+                        c, m, precision=p, execution_provider=pr, cache_dir=cd
+                    )
+                )
+            )
+        ),
+    )
+    if "ERR_export_model_builder" in summary:
+        return summary, data
+
+    assert epo is not None, "no onnx export was found"
+    if verbose:
+        print("[call_torch_export_model_builder] done (export)")
+    data["onnx_program"] = epo
+    return summary, data
+
+
 def call_torch_export_custom(
     data: Dict[str, Any],
     exporter: str,

{onnx_diagnostic-0.5.0.dist-info → onnx_diagnostic-0.6.0.dist-info}/METADATA

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

{onnx_diagnostic-0.5.0.dist-info → onnx_diagnostic-0.6.0.dist-info}/RECORD

@@ -1,22 +1,24 @@
-onnx_diagnostic/__init__.py,sha256=lDfOrSD2Bv1b6j4KDsd3Heq63qHqQlw80bVqy04eXtE,164
+onnx_diagnostic/__init__.py,sha256=5S8PigU8f0RN8fU9ddmGimcrAr1kUtpUORdZRi96mHw,173
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
-onnx_diagnostic/_command_lines_parser.py,sha256=MnkDlgrj-66ewEDiuBmQVDdt6T1b2e8wS2GTnaRLfiU,17997
+onnx_diagnostic/_command_lines_parser.py,sha256=yy4upYkizwu-8M6ErGKhzwiX5fW8dWT_34EBOT7CPPQ,18632
 onnx_diagnostic/doc.py,sha256=MTuT7Kxyvn7KEy84liQeFeqhugJrUQhjjpx21F72Uxw,926
-onnx_diagnostic/ext_test_case.py,sha256=EdKAqzK1jTJQJr2mBKy7wKzweAJ_a4pU6qulpO_Jnd8,41856
+onnx_diagnostic/ext_test_case.py,sha256=PVkneWhs-jt_nkfH06hv12WjtaBX0Rim1r_dxGPXjq0,42256
 onnx_diagnostic/export/__init__.py,sha256=yEIoWiOeTwBsDhyYt2fTKuhtA0Ya1J9u9ZzMTOTWaWs,101
-onnx_diagnostic/export/dynamic_shapes.py,sha256=gyXUihSup1yHWOeIlT7Ky8EAjpSQXu5FATHbbURGDrw,39537
+onnx_diagnostic/export/dynamic_shapes.py,sha256=EHB7VoWNx8sVetvOgE1vgC7wHtIjWDLjanhbEJNpK88,39892
 onnx_diagnostic/export/validate.py,sha256=_PGUql2DJhIgGKo0WjTGUc5AgsZUx8fEs00MePy-w98,6043
 onnx_diagnostic/helpers/__init__.py,sha256=GJ2GT7cgnlIveVUwMZhuvUwidbTJaKv8CsSIOpZDsJg,83
 onnx_diagnostic/helpers/args_helper.py,sha256=7pTrw1A1wuNvLdXJdpda5spPI140FylwSmxxZTGu_4E,4389
 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/helper.py,sha256=FuBb6OvdPpKGDrxSWevxJwWlNlRWycfwV4ann58y9xg,56081
+onnx_diagnostic/helpers/graph_helper.py,sha256=hevQT5a7_QuriVPQcbT5qe18n99Doyl5h3-qshx1-uk,14093
+onnx_diagnostic/helpers/helper.py,sha256=h7nuAUWBvLgOq95AY9xIer4rcXhLxkAM1-u-QliAx5A,56929
 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=wHd2qqfGNvdgjGBmXyyZhfikjyM_-ijPkLbMRkqW0Pg,12963
 onnx_diagnostic/helpers/onnx_helper.py,sha256=chw-HB4iqGCD_16d0_BaCnreEgWYW4KeH78nh-3t2Uw,29213
 onnx_diagnostic/helpers/ort_session.py,sha256=UgUUeUslDxEFBc6w6f3HMq_a7bn4TBlItmojqWquSj4,29281
-onnx_diagnostic/helpers/rt_helper.py,sha256=zFIA3HTvogok6EUjWfTAXUd-BfP_Sh4pwEmLcdqPbl0,1774
+onnx_diagnostic/helpers/rt_helper.py,sha256=PbMRp0AQGKxj9B8_-oIMYPG5o86jTXJalkoBTmg4VZs,4147
 onnx_diagnostic/helpers/torch_helper.py,sha256=83HnFGcOX8YmPDAikhxFpBydxfI3gyWPDiRHYidrH6A,31531
 onnx_diagnostic/reference/__init__.py,sha256=0Al5kins8LlBICAsszEZ59thMwmaARBO6fMwtYpKOOQ,98
 onnx_diagnostic/reference/evaluator.py,sha256=RzNzjFDeMe-4X51Tb22N6aagazY5ktNq-mRmPcfY5EU,8848
@@ -66,18 +68,20 @@ onnx_diagnostic/tasks/text_classification.py,sha256=OgC_G9iumzTjTNUEvMoFFNTHCD8_
 onnx_diagnostic/tasks/text_generation.py,sha256=Wv8DamBHte355wXe_tAeVxG4EL20y86fu7JEmUM75to,10385
 onnx_diagnostic/tasks/zero_shot_image_classification.py,sha256=N3cEG1Lq95wS1N_CWUUUCU5j-4Tp5eR8Ce68U8THYAk,4380
 onnx_diagnostic/torch_export_patches/__init__.py,sha256=0SaZedwznm1hQUCvXZsGZORV5vby954wEExr5faepGg,720
-onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=xMwrrQ9CF4fWgkZsrbVK_KBjl_stAUe7tBX_OgPyRoI,17432
-onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=YCOA6O7IwtRMHgK_4oYqqqcNBKSEOfvqG3xH96nUYvU,15565
+onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=MgOQwgLf6-uCGQaiUrhVNfZQ43dCp1iWGbzLbKEVyc8,18810
+onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=l5HvE_FfdCtgLJBmJczH6nA8jZY1725AggiHwoAa-o0,15763
 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=VrwMb8v-OWLWJko5TohC5Pw91jtWD8zsnraGC5ZfHNA,1851
+onnx_diagnostic/torch_export_patches/patch_module_helper.py,sha256=-sFpuBnwPl61Y0KKENniMfQkL-0-3SaLn5mzgF-fP6g,1946
+onnx_diagnostic/torch_export_patches/eval/__init__.py,sha256=V8gbjsbYJHyjLo4WyzhsDx-noBQn6bsK1lhgm8IQlzQ,20890
+onnx_diagnostic/torch_export_patches/eval/model_cases.py,sha256=KtK4AgrFE2Mm8wo15O7x4deTGubOU9MFp3QCuac6WkM,26471
 onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=TKLxrIJUrQsy0mbQwFcvn5e2l_s4OGKu5jnwWDHC6LE,15670
-onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=Cwb-D_9xX4FKK_Uzr3qUcakhN8Vfueqw3c3yifxKMTo,21858
+onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=KaZ8TjDa9ATgT4HllYzzoNf_51q_yOj_GuF5NYjPCrU,18913
+onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=QGuZ_j8juG9dlSUBSpc2T1nYwkoeFz3iP2kONx2Hmrc,23025
 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=WD1GwnE8GOr-lnePHMmfBKd95-YWXiRLCRhf-zI2Q6A,51490
+onnx_diagnostic/torch_models/test_helper.py,sha256=SU8HwQtfUEicCpukp_prqX0ol5fu2rA06lc1GROxW38,55309
 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
@@ -88,8 +92,8 @@ onnx_diagnostic/torch_models/untrained/llm_phi2.py,sha256=ynBTDHJHCk44NjLT_t6OiF
 onnx_diagnostic/torch_models/untrained/llm_tiny_llm.py,sha256=7N3fGvT_4Mn4NbIo0Qk57c6DMc3OXGWyvj_P41rjwSY,3513
 onnx_diagnostic/torch_onnx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_onnx/sbs.py,sha256=1EL25DeYFzlBSiFG_XjePBLvsiItRXbdDrr5-QZW2mA,16878
-onnx_diagnostic-0.5.0.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.5.0.dist-info/METADATA,sha256=c1-VMC0PvnCziqGOy1-3GmjoepT5U35aPwSMKpOl-d8,6643
-onnx_diagnostic-0.5.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-onnx_diagnostic-0.5.0.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.5.0.dist-info/RECORD,,
+onnx_diagnostic-0.6.0.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.6.0.dist-info/METADATA,sha256=jqrQEqFmrlycVGKW_zlSrxhzMoeV-X-H4eSeGBZyK1o,6643
+onnx_diagnostic-0.6.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+onnx_diagnostic-0.6.0.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.6.0.dist-info/RECORD,,

{onnx_diagnostic-0.5.0.dist-info → onnx_diagnostic-0.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any