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

onnx_diagnostic/helpers/cache_helper.py

@@ -270,7 +270,7 @@ def make_static_cache(
             self.num_attention_heads = key_value_pairs[0][0].shape[1]
             self.num_hidden_layers = len(key_value_pairs)
 
-        def get_text_config(self):
+        def get_text_config(self, *args, **kwargs):
             return self
 
     assert max_cache_len is not None, (
@@ -366,7 +366,7 @@ def make_mamba_cache(key_value_pairs: List[Tuple[torch.Tensor, torch.Tensor]]) -
             self.num_hidden_layers = len(key_value_pairs)
             self.dtype = dtype
 
-        def get_text_config(self):
+        def get_text_config(self, *args, **kwargs):
             return self
 
     cache = MambaCache(
@@ -409,7 +409,7 @@ def make_sliding_window_cache(
             self.num_hidden_layers = len(key_value_pairs)
             self.sliding_window = key_value_pairs[0][0].shape[2]
 
-        def get_text_config(self):
+        def get_text_config(self, *args, **kwargs):
             return self
 
     cache = transformers.cache_utils.SlidingWindowCache(
@@ -577,7 +577,7 @@ def make_hybrid_cache(
         sliding_window = _sliding_window
         num_key_value_heads = key_value_pairs[0][1].shape[1]  # transformers 4.48.3
 
-        def get_text_config(self):
+        def get_text_config(self, *args, **kwargs):
             return self
 
     if layer_types:

onnx_diagnostic/helpers/helper.py

@@ -774,6 +774,14 @@ def string_type(
             return f"{obj.__class__.__name__}(**{s})"
     if obj.__class__.__name__ in {"TorchModelContainer", "InferenceSession"}:
         return f"{obj.__class__.__name__}(...)"
+    if obj.__class__.__name__ == "Results":
+        import ultralytics
+
+        assert isinstance(
+            obj, ultralytics.engine.results.Results
+        ), f"Unexpected type={type(obj)}"
+        return f"ultralytics.{obj.__class__.__name__}(...)"
+
     if verbose:
         print(f"[string_type] END:{type(obj)}")
     raise AssertionError(f"Unsupported type {type(obj).__name__!r} - {type(obj)}")

onnx_diagnostic/helpers/onnx_helper.py

@@ -1186,7 +1186,7 @@ def shadowing_names(
                 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(
+                s, _ps, c = shadowing_names(
                     g.node, verbose=verbose, existing=existing, shadow_context=existing
                 )
                 shadow |= s

onnx_diagnostic/helpers/torch_helper.py

@@ -543,7 +543,7 @@ def dummy_llm(
             )
 
         def forward(self, x):
-            B, T, C = x.shape
+            _B, T, C = x.shape
 
             query = self.query(x)
             key = self.key(x)
@@ -721,9 +721,10 @@ def to_any(value: Any, to_value: Union[torch.dtype, torch.device, str]) -> Any:
         return {to_any(t, to_value) for t in value}
     if type(value) is dict:
         return {k: to_any(t, to_value) for k, t in value.items()}
-    if value.__class__.__name__ == "DynamicCache":
+    if value.__class__.__name__ in {"DynamicCache", "HybridCache"}:
+        make = dict(DynamicCache=make_dynamic_cache, HybridCache=make_hybrid_cache)
         cc = CacheKeyValue(value)
-        return make_dynamic_cache(
+        return make[value.__class__.__name__](  # type: ignore[operator]
             list(
                 zip(
                     [t.to(to_value) if t is not None else t for t in cc.key_cache],
@@ -822,6 +823,15 @@ def torch_deepcopy(value: Any) -> Any:
         new_args = torch_deepcopy(args)
         return torch.utils._pytree.tree_unflatten(new_args, spec)
 
+    if value.__class__.__name__ == "Results":
+        import copy
+        import ultralytics
+
+        assert isinstance(
+            value, ultralytics.engine.results.Results
+        ), f"Unexpected type={type(value)}"
+        return copy.deepcopy(value)
+
     # We should have a code using serialization, deserialization assuming a model
     # cannot be exported without them.
     raise NotImplementedError(f"torch_deepcopy not implemented for type {type(value)}")
@@ -856,7 +866,7 @@ def torch_tensor_size(value: Any) -> Any:
     if value.__class__.__name__ == "MambaCache":
         return torch_tensor_size(value.conv_states) + torch_tensor_size(value.ssm_states)
     if value.__class__ in torch.utils._pytree.SUPPORTED_NODES:
-        args, spec = torch.utils._pytree.tree_flatten(value)
+        args, _spec = torch.utils._pytree.tree_flatten(value)
         return sum(torch_tensor_size(a) for a in args)
 
     # We should have a code using serialization, deserialization assuming a model

onnx_diagnostic/reference/ops/op_scan.py

@@ -26,11 +26,11 @@ class Scan(_Scan):
     ):
         (
             num_loop_state_vars,
-            num_scan_outputs,
-            output_directions,
-            max_dir_out,
-            output_axes,
-            max_axe_out,
+            _num_scan_outputs,
+            _output_directions,
+            _max_dir_out,
+            _output_axes,
+            _max_axe_out,
             state_names_in,
             state_names_out,
             scan_names_in,

onnx_diagnostic/reference/ort_evaluator.py

@@ -562,7 +562,7 @@ class OnnxruntimeEvaluator:
         if key in self._cache:
             sess = self._cache[key][1]
         else:
-            self._cache[key] = onx, sess = self._get_sess_if(node, name, inputs, results)
+            self._cache[key] = _onx, sess = self._get_sess_if(node, name, inputs, results)
 
         assert hasattr(sess, "run"), f"Missing method run for type {type(sess)}"
         feeds = {name: results[name] for name in sess.input_names}
@@ -616,7 +616,7 @@ class OnnxruntimeEvaluator:
         if key in self._cache:
             sess = self._cache[key][1]
         else:
-            self._cache[key] = onx, sess = self._get_sess_scan(node, name, inputs, results)
+            self._cache[key] = _onx, sess = self._get_sess_scan(node, name, inputs, results)
 
         assert hasattr(sess, "run"), f"Missing method run for type {type(sess)}"
         feeds = {name: results[name] for name in sess.input_names}

onnx_diagnostic/torch_export_patches/eval/model_cases.py

@@ -384,7 +384,7 @@ class ControlFlowScan(torch.nn.Module):
 
     def forward(self, x):
         init = torch.zeros_like(x[0])
-        carry, out = torch.ops.higher_order.scan(
+        carry, _out = torch.ops.higher_order.scan(
             ControlFlowScan.add, [init], [x], additional_inputs=[]
         )
         return carry
@@ -429,7 +429,7 @@ class ControlFlowScanCDist(torch.nn.Module):
         return [carry.clone(), rd]
 
     def forward(self, x):
-        carry, out = torch.ops.higher_order.scan(
+        _carry, out = torch.ops.higher_order.scan(
             ControlFlowScanCDist.dist,
             [x],
             [x],
@@ -483,7 +483,7 @@ class ControlFlowScanCDistXY(torch.nn.Module):
         return [y.clone(), rd]
 
     def forward(self, x, y):
-        carry, out = torch.ops.higher_order.scan(
+        _carry, out = torch.ops.higher_order.scan(
             ControlFlowScanCDistXY.dist,
             [y],
             [x],

onnx_diagnostic/torch_export_patches/onnx_export_errors.py

@@ -439,6 +439,28 @@ def torch_export_patches(
                 f_transformers__vmap_for_bhqkv = masking_utils._vmap_for_bhqkv
                 masking_utils._vmap_for_bhqkv = patch_transformers_list.patched__vmap_for_bhqkv
 
+                if verbose:
+                    print(
+                        "[torch_export_patches] patches "
+                        "transformers.masking_utils.sdpa_mask_recent_torch"
+                    )
+                f_transformers_sdpa_mask_recent_torch = masking_utils.sdpa_mask_recent_torch
+                masking_utils.sdpa_mask_recent_torch = (
+                    patch_transformers_list.patched_sdpa_mask_recent_torch
+                )
+                if masking_utils.sdpa_mask == f_transformers_sdpa_mask_recent_torch:
+                    if verbose:
+                        print(
+                            "[torch_export_patches] patches "
+                            "transformers.masking_utils.sdpa_mask"
+                        )
+                    f_transformers_sdpa_mask = masking_utils.sdpa_mask
+                    masking_utils.sdpa_mask = (
+                        patch_transformers_list.patched_sdpa_mask_recent_torch
+                    )
+                else:
+                    f_transformers_sdpa_mask = None
+
             if (
                 masking_utils
                 and patch_transformers_list.patch_masking_utils
@@ -456,10 +478,37 @@ def torch_export_patches(
                     and masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["eager"]
                     == f_transformers_eager_mask
                 ):
+                    if verbose:
+                        print(
+                            "[torch_export_patches] patches "
+                            "transformers.masking_utils.eager_mask "
+                            "in ALL_MASK_ATTENTION_FUNCTIONS"
+                        )
                     masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["eager"] = (
                         patch_transformers_list.patched_eager_mask
                     )
 
+            if (
+                masking_utils
+                and patch_transformers_list.patch_masking_utils
+                and hasattr(masking_utils, "sdpa_mask")
+                and f_transformers_sdpa_mask is not None
+            ):
+                if verbose:
+                    print(
+                        "[torch_export_patches] patches "
+                        "transformers.masking_utils.sdpa_mask "
+                        "in ALL_MASK_ATTENTION_FUNCTIONS"
+                    )
+                if (
+                    "sdpa" in masking_utils.ALL_MASK_ATTENTION_FUNCTIONS
+                    and masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["sdpa"]
+                    == f_transformers_sdpa_mask
+                ):
+                    masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["sdpa"] = (
+                        patch_transformers_list.patched_sdpa_mask_recent_torch
+                    )
+
         if custom_patches:
             if verbose:
                 print("[torch_export_patches] applies custom patches")
@@ -568,12 +617,31 @@ def torch_export_patches(
                     and hasattr(masking_utils, "_vmap_for_bhqkv")
                 ):
                     masking_utils._vmap_for_bhqkv = f_transformers__vmap_for_bhqkv
+
                     if verbose:
                         print(
                             "[torch_export_patches] restored "
                             "transformers.masking_utils._vmap_for_bhqkv"
                         )
 
+                    masking_utils.sdpa_mask_recent_torch = (
+                        f_transformers_sdpa_mask_recent_torch
+                    )
+
+                    if verbose:
+                        print(
+                            "[torch_export_patches] restored "
+                            "transformers.masking_utils.sdpa_mask_recent_torch"
+                        )
+
+                    if f_transformers_sdpa_mask is not None:
+                        masking_utils.sdpa_mask = f_transformers_sdpa_mask
+                        if verbose:
+                            print(
+                                "[torch_export_patches] restored "
+                                "transformers.masking_utils.sdpa_mask"
+                            )
+
                 if (
                     masking_utils
                     and patch_transformers_list.patch_masking_utils
@@ -581,6 +649,11 @@ def torch_export_patches(
                 ):
                     f_transformers_eager_mask = masking_utils.eager_mask
                     masking_utils.eager_mask = f_transformers_eager_mask
+                    if verbose:
+                        print(
+                            "[torch_export_patches] restored "
+                            "transformers.masking_utils.eager_mask"
+                        )
                     if (
                         "eager" in masking_utils.ALL_MASK_ATTENTION_FUNCTIONS
                         and masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["eager"]
@@ -589,11 +662,32 @@ def torch_export_patches(
                         masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["eager"] = (
                             f_transformers_eager_mask
                         )
-                    if verbose:
-                        print(
-                            "[torch_export_patches] restored "
-                            "transformers.masking_utils.eager_mask"
+                        if verbose:
+                            print(
+                                "[torch_export_patches] restored "
+                                "transformers.masking_utils.eager_mask "
+                                "in ALL_MASK_ATTENTION_FUNCTIONS"
+                            )
+
+                if (
+                    masking_utils
+                    and patch_transformers_list.patch_masking_utils
+                    and hasattr(masking_utils, "sdpa_mask")
+                ):
+                    if (
+                        "sdpa" in masking_utils.ALL_MASK_ATTENTION_FUNCTIONS
+                        and masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["sdpa"]
+                        == patch_transformers_list.patched_sdpa_mask_recent_torch
+                    ):
+                        masking_utils.ALL_MASK_ATTENTION_FUNCTIONS["sdpa"] = (
+                            f_transformers_sdpa_mask
                         )
+                        if verbose:
+                            print(
+                                "[torch_export_patches] restored "
+                                "transformers.masking_utils.sdpa_mask "
+                                "in ALL_MASK_ATTENTION_FUNCTIONS"
+                            )
 
             ########
             # caches

onnx_diagnostic/torch_export_patches/patches/patch_transformers.py

@@ -37,7 +37,13 @@ from ...helpers.torch_helper import is_torchdynamo_exporting
 
 if patch_masking_utils:
     # Introduced in 4.52
-    from transformers.masking_utils import causal_mask_function, sdpa_mask
+    from transformers.masking_utils import (
+        causal_mask_function,
+        padding_mask_function,
+        and_masks,
+        _ignore_causal_mask_sdpa,
+        prepare_padding_mask,
+    )
 
     def patched__vmap_for_bhqkv(mask_function: Callable, bh_indices: bool = True) -> Callable:
         """manual patch for function ``transformers.masking_utils._vmap_for_bhqkv``."""
@@ -105,7 +111,7 @@ if patch_masking_utils:
         """manual patch for function ``transformers.masking_utils.eager_mask``."""
         # The masks for eager attention are simply boolean mask from sdpa, casted to 0 and -inf
         _ = kwargs.pop("allow_is_causal_skip", None)
-        mask = sdpa_mask(
+        mask = patched_sdpa_mask_recent_torch(
             batch_size=batch_size,
             cache_position=cache_position,
             kv_length=kv_length,
@@ -125,6 +131,35 @@ if patch_masking_utils:
         mask = (~mask).to(dtype) * min_dtype
         return mask
 
+    def patched_sdpa_mask_recent_torch(
+        batch_size: int,
+        cache_position: torch.Tensor,
+        kv_length: int,
+        kv_offset: int = 0,
+        mask_function: Callable = causal_mask_function,
+        attention_mask: Optional[torch.Tensor] = None,
+        local_size: Optional[int] = None,
+        allow_is_causal_skip: bool = True,
+        **kwargs,
+    ) -> Optional[torch.Tensor]:
+        """manual patch for function ``transformers.masking_utils.sdpa_mask_recent_torch``."""
+        q_length = cache_position.shape[0]
+        padding_mask = prepare_padding_mask(attention_mask, kv_length, kv_offset, _slice=False)
+        if allow_is_causal_skip and _ignore_causal_mask_sdpa(
+            padding_mask, q_length, kv_length, kv_offset, local_size
+        ):
+            return None
+        kv_arange = torch.arange(kv_length, device=cache_position.device)
+        kv_arange += kv_offset
+        if padding_mask is not None:
+            mask_function = and_masks(mask_function, padding_mask_function(padding_mask))
+        batch_arange = torch.arange(batch_size, device=cache_position.device)
+        head_arange = torch.arange(1, device=cache_position.device)
+        causal_mask = patched__vmap_for_bhqkv(mask_function)(
+            batch_arange, head_arange, cache_position, kv_arange
+        )
+        return causal_mask
+
 
 if patch_parse_processor_args:
 

onnx_diagnostic/torch_export_patches/serialization/transformers_impl.py

@@ -218,7 +218,6 @@ def unflatten_sliding_window_cache(
     values: List[Any], context: torch.utils._pytree.Context, output_type=None
 ) -> SlidingWindowCache:
     """Restores a :class:`transformers.cache_utils.SlidingWindowCache` from python objects."""
-    key_cache, value_cache = values
     return make_sliding_window_cache(list(zip(values[0], values[1])))
 
 

onnx_diagnostic/torch_models/hghub/hub_data.py

@@ -11,6 +11,7 @@ __data_arch__ = textwrap.dedent(
     """
     architecture,task
     ASTModel,feature-extraction
+    AutoencoderKL,image-to-image
     AlbertModel,feature-extraction
     BeitForImageClassification,image-classification
     BartForConditionalGeneration,summarization
@@ -154,6 +155,7 @@ __data_arch__ = textwrap.dedent(
     Wav2Vec2ForCTC,automatic-speech-recognition
     YolosForObjectDetection,object-detection
     YolosModel,image-feature-extraction
+    Alibaba-NLP/gte-large-en-v1.5,sentence-similarity
     emilyalsentzer/Bio_ClinicalBERT,fill-mask"""
 )
 

onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py

@@ -4687,3 +4687,145 @@ def _ccached_zai_glm_45():
             },
         }
     )
+
+
+def _ccached_microsoft_phi3_mini_128k_instruct():
+    "microsoft/Phi-3-mini-128k-instruct"
+    return transformers.Phi3Config(
+        **{
+            "_name_or_path": "Phi-3-mini-128k-instruct",
+            "architectures": ["Phi3ForCausalLM"],
+            "attention_dropout": 0.0,
+            "auto_map": {
+                "AutoConfig": "configuration_phi3.Phi3Config",
+                "AutoModelForCausalLM": "modeling_phi3.Phi3ForCausalLM",
+            },
+            "bos_token_id": 1,
+            "embd_pdrop": 0.0,
+            "eos_token_id": 32000,
+            "hidden_act": "silu",
+            "hidden_size": 3072,
+            "initializer_range": 0.02,
+            "intermediate_size": 8192,
+            "max_position_embeddings": 131072,
+            "model_type": "phi3",
+            "num_attention_heads": 32,
+            "num_hidden_layers": 32,
+            "num_key_value_heads": 32,
+            "original_max_position_embeddings": 4096,
+            "pad_token_id": 32000,
+            "resid_pdrop": 0.0,
+            "rms_norm_eps": 1e-05,
+            "rope_scaling": {
+                "long_factor": [
+                    1.0700000524520874,
+                    1.1200000047683716,
+                    1.149999976158142,
+                    1.4199999570846558,
+                    1.5699999332427979,
+                    1.7999999523162842,
+                    2.129999876022339,
+                    2.129999876022339,
+                    3.009999990463257,
+                    5.910000324249268,
+                    6.950000286102295,
+                    9.070000648498535,
+                    9.930000305175781,
+                    10.710000038146973,
+                    11.130000114440918,
+                    14.609999656677246,
+                    15.409998893737793,
+                    19.809999465942383,
+                    37.279998779296875,
+                    38.279998779296875,
+                    38.599998474121094,
+                    40.12000274658203,
+                    46.20000457763672,
+                    50.940006256103516,
+                    53.66000747680664,
+                    54.9373893737793,
+                    56.89738845825195,
+                    57.28738784790039,
+                    59.98738479614258,
+                    60.86738586425781,
+                    60.887386322021484,
+                    61.71739196777344,
+                    62.91739273071289,
+                    62.957393646240234,
+                    63.41739273071289,
+                    63.8173942565918,
+                    63.83739471435547,
+                    63.897396087646484,
+                    63.93739700317383,
+                    64.06739807128906,
+                    64.11434936523438,
+                    64.12435150146484,
+                    64.15435028076172,
+                    64.19435119628906,
+                    64.24435424804688,
+                    64.57435607910156,
+                    64.69000244140625,
+                    64.76000213623047,
+                ],
+                "short_factor": [
+                    1.1,
+                    1.1,
+                    1.1,
+                    1.3000000000000003,
+                    1.3500000000000003,
+                    1.3500000000000003,
+                    1.4000000000000004,
+                    1.5500000000000005,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.1000000000000005,
+                    2.1000000000000005,
+                    2.1500000000000004,
+                    2.25,
+                    2.25,
+                    2.25,
+                    2.25,
+                    2.25,
+                    2.3999999999999995,
+                    2.4499999999999993,
+                    2.499999999999999,
+                    2.6999999999999984,
+                    2.6999999999999984,
+                    2.7499999999999982,
+                    2.799999999999998,
+                    2.8999999999999977,
+                    3.049999999999997,
+                ],
+                "type": "longrope",
+            },
+            "rope_theta": 10000.0,
+            "sliding_window": 262144,
+            "tie_word_embeddings": false,
+            "torch_dtype": "bfloat16",
+            "transformers_version": "4.40.2",
+            "use_cache": true,
+            "attention_bias": false,
+            "vocab_size": 32064,
+        }
+    )

onnx_diagnostic/torch_models/hghub/model_inputs.py

@@ -8,6 +8,7 @@ import transformers
 from ...helpers.config_helper import update_config, build_diff_config
 from ...tasks import reduce_model_config, random_input_kwargs
 from .hub_api import task_from_arch, task_from_id, get_pretrained_config, download_code_modelid
+from .model_specific import HANDLED_MODELS, load_specific_model
 
 
 def _code_needing_rewriting(model: Any) -> Any:
@@ -73,7 +74,7 @@ def get_untrained_model_with_inputs(
         print("-- configuration:", pprint.pformat(data['configuration']))
     """
     assert not use_preinstalled or not use_only_preinstalled, (
-        f"model_id={model_id!r}, pretinstalled model is only available "
+        f"model_id={model_id!r}, preinstalled model is only available "
         f"if use_only_preinstalled is False."
     )
     if verbose:
@@ -89,145 +90,156 @@ def get_untrained_model_with_inputs(
             **(model_kwargs or {}),
         )
 
-    if hasattr(config, "architecture") and config.architecture:
-        archs = [config.architecture]
-    if type(config) is dict:
-        assert "_class_name" in config, f"Unable to get the architecture from config={config}"
-        archs = [config["_class_name"]]
-    else:
-        archs = config.architectures  # type: ignore
-    task = None
-    if archs is None:
-        task = task_from_id(model_id)
-    assert task is not None or (archs is not None and len(archs) == 1), (
-        f"Unable to determine the architecture for model {model_id!r}, "
-        f"architectures={archs!r}, conf={config}"
-    )
-    if verbose:
-        print(f"[get_untrained_model_with_inputs] architectures={archs!r}")
-        print(f"[get_untrained_model_with_inputs] cls={config.__class__.__name__!r}")
-    if task is None:
-        task = task_from_arch(archs[0], model_id=model_id, subfolder=subfolder)
-    if verbose:
-        print(f"[get_untrained_model_with_inputs] task={task!r}")
+    model, task, mkwargs, diff_config = None, None, {}, None
+    if use_pretrained and same_as_pretrained:
+        if model_id in HANDLED_MODELS:
+            model, task, config = load_specific_model(model_id, verbose=verbose)
 
-    # model kwagrs
-    if dynamic_rope is not None:
-        assert (
-            type(config) is not dict
-        ), f"Unable to set dynamic_rope if the configuration is a dictionary\n{config}"
-        assert hasattr(config, "rope_scaling"), f"Missing 'rope_scaling' in\n{config}"
-        config.rope_scaling = (
-            {"rope_type": "dynamic", "factor": 10.0} if dynamic_rope else None
+    if model is None:
+        if hasattr(config, "architecture") and config.architecture:
+            archs = [config.architecture]
+        if type(config) is dict:
+            assert (
+                "_class_name" in config
+            ), f"Unable to get the architecture from config={config}"
+            archs = [config["_class_name"]]
+        else:
+            archs = config.architectures  # type: ignore
+        task = None
+        if archs is None:
+            task = task_from_id(model_id)
+        assert task is not None or (archs is not None and len(archs) == 1), (
+            f"Unable to determine the architecture for model {model_id!r}, "
+            f"architectures={archs!r}, conf={config}"
         )
+        if verbose:
+            print(f"[get_untrained_model_with_inputs] architectures={archs!r}")
+            print(f"[get_untrained_model_with_inputs] cls={config.__class__.__name__!r}")
+        if task is None:
+            task = task_from_arch(archs[0], model_id=model_id, subfolder=subfolder)
+        if verbose:
+            print(f"[get_untrained_model_with_inputs] task={task!r}")
+
+        # model kwagrs
+        if dynamic_rope is not None:
+            assert (
+                type(config) is not dict
+            ), f"Unable to set dynamic_rope if the configuration is a dictionary\n{config}"
+            assert hasattr(config, "rope_scaling"), f"Missing 'rope_scaling' in\n{config}"
+            config.rope_scaling = (
+                {"rope_type": "dynamic", "factor": 10.0} if dynamic_rope else None
+            )
 
-    # updating the configuration
-    config0 = copy.deepcopy(config)
-    mkwargs = reduce_model_config(config, task) if not same_as_pretrained else {}
-    if model_kwargs:
-        for k, v in model_kwargs.items():
-            if isinstance(v, dict):
-                if k in mkwargs:
-                    mkwargs[k].update(v)
+        # updating the configuration
+        config0 = copy.deepcopy(config)
+        mkwargs = reduce_model_config(config, task) if not same_as_pretrained else {}
+        if model_kwargs:
+            for k, v in model_kwargs.items():
+                if isinstance(v, dict):
+                    if k in mkwargs:
+                        mkwargs[k].update(v)
+                    else:
+                        mkwargs[k] = v
                 else:
                     mkwargs[k] = v
-            else:
-                mkwargs[k] = v
-    if mkwargs:
-        update_config(config, mkwargs)
-    try:
-        diff_config = build_diff_config(config0, config)
-    except (ValueError, AttributeError, TypeError) as e:
-        diff_config = f"DIFF CONFIG ERROR {e}"
-    if verbose:
-        if diff_config:
-            print("[get_untrained_model_with_inputs] -- updated config")
-            pprint.pprint(diff_config)
-            print("[get_untrained_model_with_inputs] --")
-
-    # SDPA
-    if model_kwargs and "attn_implementation" in model_kwargs:
-        if hasattr(config, "_attn_implementation_autoset"):
-            config._attn_implementation_autoset = False
-        config._attn_implementation = model_kwargs["attn_implementation"]  # type: ignore[union-attr]
+        if mkwargs:
+            update_config(config, mkwargs)
+        try:
+            diff_config = build_diff_config(config0, config)
+        except (ValueError, AttributeError, TypeError) as e:
+            diff_config = f"DIFF CONFIG ERROR {e}"
         if verbose:
+            if diff_config:
+                print("[get_untrained_model_with_inputs] -- updated config")
+                pprint.pprint(diff_config)
+                print("[get_untrained_model_with_inputs] --")
+
+        # SDPA
+        if model_kwargs and "attn_implementation" in model_kwargs:
+            if hasattr(config, "_attn_implementation_autoset"):
+                config._attn_implementation_autoset = False
+            config._attn_implementation = model_kwargs["attn_implementation"]  # type: ignore[union-attr]
+            if verbose:
+                print(
+                    f"[get_untrained_model_with_inputs] config._attn_implementation="
+                    f"{config._attn_implementation!r}"  # type: ignore[union-attr]
+                )
+        elif verbose:
             print(
-                f"[get_untrained_model_with_inputs] config._attn_implementation="
-                f"{config._attn_implementation!r}"  # type: ignore[union-attr]
+                f"[get_untrained_model_with_inputs] default config._attn_implementation="
+                f"{getattr(config, '_attn_implementation', '?')!r}"  # type: ignore[union-attr]
             )
-    elif verbose:
-        print(
-            f"[get_untrained_model_with_inputs] default config._attn_implementation="
-            f"{getattr(config, '_attn_implementation', '?')!r}"  # type: ignore[union-attr]
-        )
-
-    if type(config) is dict and "_diffusers_version" in config:
-        import diffusers
 
-        package_source = diffusers
-    else:
-        package_source = transformers
+        if type(config) is dict and "_diffusers_version" in config:
+            import diffusers
 
-    if use_pretrained:
-        model = transformers.AutoModel.from_pretrained(model_id, **mkwargs)
-    else:
-        if archs is not None:
-            try:
-                cls_model = getattr(package_source, archs[0])
-            except AttributeError as e:
-                # The code of the models is not in transformers but in the
-                # repository of the model. We need to download it.
-                pyfiles = download_code_modelid(model_id, verbose=verbose)
-                if pyfiles:
-                    if "." in archs[0]:
-                        cls_name = archs[0]
-                    else:
-                        modeling = [_ for _ in pyfiles if "/modeling_" in _]
-                        assert len(modeling) == 1, (
-                            f"Unable to guess the main file implemented class {archs[0]!r} "
-                            f"from {pyfiles}, found={modeling}."
-                        )
-                        last_name = os.path.splitext(os.path.split(modeling[0])[-1])[0]
-                        cls_name = f"{last_name}.{archs[0]}"
-                    if verbose:
-                        print(
-                            f"[get_untrained_model_with_inputs] custom code for {cls_name!r}"
-                        )
-                        print(
-                            f"[get_untrained_model_with_inputs] from folder "
-                            f"{os.path.split(pyfiles[0])[0]!r}"
-                        )
-                    cls_model = (
-                        transformers.dynamic_module_utils.get_class_from_dynamic_module(
-                            cls_name,
-                            pretrained_model_name_or_path=os.path.split(pyfiles[0])[0],
-                        )
-                    )
-                else:
-                    raise AttributeError(
-                        f"Unable to find class 'tranformers.{archs[0]}'. "
-                        f"The code needs to be downloaded, config="
-                        f"\n{pprint.pformat(config)}."
-                    ) from e
+            package_source = diffusers
         else:
-            assert same_as_pretrained and use_pretrained, (
-                f"Model {model_id!r} cannot be built, the model cannot be built. "
-                f"It must be downloaded. Use same_as_pretrained=True "
-                f"and use_pretrained=True."
-            )
+            package_source = transformers
 
-        try:
-            if type(config) is dict:
-                model = cls_model(**config)
+        if use_pretrained:
+            model = transformers.AutoModel.from_pretrained(
+                model_id, trust_remote_code=True, **mkwargs
+            )
+        else:
+            if archs is not None:
+                try:
+                    cls_model = getattr(package_source, archs[0])
+                except AttributeError as e:
+                    # The code of the models is not in transformers but in the
+                    # repository of the model. We need to download it.
+                    pyfiles = download_code_modelid(model_id, verbose=verbose)
+                    if pyfiles:
+                        if "." in archs[0]:
+                            cls_name = archs[0]
+                        else:
+                            modeling = [_ for _ in pyfiles if "/modeling_" in _]
+                            assert len(modeling) == 1, (
+                                f"Unable to guess the main file implemented class "
+                                f"{archs[0]!r} from {pyfiles}, found={modeling}."
+                            )
+                            last_name = os.path.splitext(os.path.split(modeling[0])[-1])[0]
+                            cls_name = f"{last_name}.{archs[0]}"
+                        if verbose:
+                            print(
+                                f"[get_untrained_model_with_inputs] "
+                                f"custom code for {cls_name!r}"
+                            )
+                            print(
+                                f"[get_untrained_model_with_inputs] from folder "
+                                f"{os.path.split(pyfiles[0])[0]!r}"
+                            )
+                        cls_model = (
+                            transformers.dynamic_module_utils.get_class_from_dynamic_module(
+                                cls_name,
+                                pretrained_model_name_or_path=os.path.split(pyfiles[0])[0],
+                            )
+                        )
+                    else:
+                        raise AttributeError(
+                            f"Unable to find class 'tranformers.{archs[0]}'. "
+                            f"The code needs to be downloaded, config="
+                            f"\n{pprint.pformat(config)}."
+                        ) from e
             else:
-                model = cls_model(config)
-        except RuntimeError as e:
-            raise RuntimeError(
-                f"Unable to instantiate class {cls_model.__name__} with\n{config}"
-            ) from e
+                assert same_as_pretrained and use_pretrained, (
+                    f"Model {model_id!r} cannot be built, the model cannot be built. "
+                    f"It must be downloaded. Use same_as_pretrained=True "
+                    f"and use_pretrained=True."
+                )
+
+            try:
+                if type(config) is dict:
+                    model = cls_model(**config)
+                else:
+                    model = cls_model(config)
+            except RuntimeError as e:
+                raise RuntimeError(
+                    f"Unable to instantiate class {cls_model.__name__} with\n{config}"
+                ) from e
 
     # input kwargs
-    kwargs, fct = random_input_kwargs(config, task)
+    kwargs, fct = random_input_kwargs(config, task)  # type: ignore[arg-type]
     if verbose:
         print(f"[get_untrained_model_with_inputs] use fct={fct}")
         if os.environ.get("PRINT_CONFIG") in (1, "1"):
@@ -243,7 +255,8 @@ def get_untrained_model_with_inputs(
 
     res["input_kwargs"] = kwargs
     res["model_kwargs"] = mkwargs
-    res["dump_info"] = dict(config_diff=diff_config)
+    if diff_config is not None:
+        res["dump_info"] = dict(config_diff=diff_config)
 
     sizes = compute_model_size(model)
     res["model"] = model

onnx_diagnostic/torch_models/hghub/model_specific.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, Tuple
+
+
+class SpecificConfig:
+    """Creates a specific configuration for the loaded model."""
+
+    def __init__(self, **kwargs):
+        self._atts = set(kwargs)
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: getattr(self, k) for k in self._atts if k != "_atts"}
+
+
+def load_specific_model(
+    model_id: str, verbose: int = 0, **kwargs
+) -> Tuple[Any, str, SpecificConfig]:
+    """
+    Some models do not have any generic to be loaded.
+    This functions
+
+    :param model_id: model id
+    :param verbose: verbosiy
+    :param kwargs: additional parameters
+    :return: the model, the task associated to it, a configuration
+    """
+    assert model_id in HANDLED_MODELS, (
+        f"Unable to load model_id={model_id!r}, "
+        f"no function is mapped to this id in {sorted(HANDLED_MODELS)}"
+    )
+    return HANDLED_MODELS[model_id](model_id, verbose=verbose, **kwargs)
+
+
+def _load_bingsu_adetailer(model_id: str, verbose: int = 0) -> Tuple[Any, str, SpecificConfig]:
+    """See `Bingsu/adetailer <https://huggingface.co/Bingsu/adetailer>`_."""
+    from huggingface_hub import hf_hub_download
+    from ultralytics import YOLO
+
+    path = hf_hub_download("Bingsu/adetailer", "face_yolov8n.pt")
+    model = YOLO(path)
+    return (
+        model,
+        "object-detection",
+        SpecificConfig(architecture=type(model), image_size=224, num_channels=3),
+    )
+
+
+HANDLED_MODELS = {"Bingsu/adetailer": _load_bingsu_adetailer}

onnx_diagnostic/torch_models/untrained/llm_phi2.py

@@ -9,6 +9,7 @@ def get_phi2(
     sequence_length: int = 30,
     sequence_length2: int = 3,
     dynamic_rope: bool = False,
+    use_dim_not_dynamic: bool = False,
     **kwargs,
 ) -> Dict[str, Any]:
     """
@@ -18,6 +19,8 @@ def get_phi2(
     :param sequence_length: sequence length
     :param sequence_length2: new sequence length
     :param dynamic_rope: use dynamic rope (see :class:`transformers.LlamaConfig`)
+    :param use_dim_not_dynamic: uses ``torch.export.Dim`` and not a string for the batch size,
+        the sequence length and the cache length
     :param kwargs: to overwrite the configuration, example ``num_hidden_layers=1``
     :return: dictionary
 
@@ -62,9 +65,14 @@ def get_phi2(
     n_layers = config["num_hidden_layers"]
     num_key_value_heads = config["num_key_value_heads"]
 
-    batch = torch.export.Dim("batch", min=1, max=1024)
-    seq_length = torch.export.Dim("seq_length", min=1, max=4096)
-    cache_length = torch.export.Dim("cache_length", min=1, max=4096)
+    if use_dim_not_dynamic:
+        batch = torch.export.Dim("batch", min=1, max=1024)
+        seq_length = torch.export.Dim("seq_length", min=1, max=4096)
+        cache_length = torch.export.Dim("cache_length", min=1, max=4096)
+    else:
+        batch = "batch"
+        seq_length = "seq_length"
+        cache_length = "cache_length"
 
     shapes = {
         "input_ids": {0: batch, 1: seq_length},

onnx_diagnostic/torch_models/validate.py

@@ -352,7 +352,7 @@ def validate_model(
     The following exporters are available:
 
     * ``export-nostrict``: run :func:`torch.export.export` (..., strict=False)
-    * ``onnx-dynamo``: run :func:`torch.onnx.export` (..., dynamo=True),
+    * ``onnx-dynamo``: run :func:`torch.onnx.export` (...),
       models can be optimized with ``optimization`` in ``("ir", "os_ort")``
     * ``modelbuilder``: use :epkg:`ModelBuilder` to builds the onnx model
     * ``custom``: custom exporter (see :epkg:`experimental-experiment`),
@@ -712,6 +712,7 @@ def validate_model(
                 print(f"[validate_model] done (dump onnx) in {duration}")
             data["onnx_filename"] = onnx_filename
             summary["time_onnx_save"] = duration
+            summary.update(compute_statistics(onnx_filename))
         if verbose:
             print(f"[validate_model] dumps statistics in {dump_folder!r}...")
         dump_stats = os.path.join(dump_folder, f"{folder_name}.stats")
@@ -815,6 +816,39 @@ def validate_model(
     return summary, data
 
 
+def compute_statistics(onnx_filename: str) -> Dict[str, Union[float, int]]:
+    """Computes some statistics on the model itself."""
+    onx = onnx.load(onnx_filename, load_external_data=False)
+
+    def node_iter(proto):
+        if isinstance(proto, onnx.ModelProto):
+            yield from node_iter(proto.graph)
+            for f in proto.functions:
+                yield from node_iter(f)
+        elif isinstance(proto, (onnx.FunctionProto, onnx.GraphProto)):
+            for node in proto.node:
+                yield node
+                for att in node.attribute:
+                    if att.type == onnx.AttributeProto.GRAPH:
+                        yield from node_iter(att.g)
+            if hasattr(proto, "initializer"):
+                yield from proto.initializer
+        else:
+            raise NotImplementedError(f"Unexpected type={type(proto)}")
+
+    counts: Dict[str, Union[float, int]] = {}
+    for proto in node_iter(onx):
+        if isinstance(proto, onnx.NodeProto):
+            key = f"n_node_{proto.op_type}"
+        else:
+            key = f"n_node_initializer_{proto.data_type}"
+
+        if key not in counts:
+            counts[key] = 0
+        counts[key] += 1
+    return counts
+
+
 def _validate_do_run_model(
     data, summary, key, tag, expected_tag, verbose, repeat, warmup, quiet
 ):

onnx_diagnostic/torch_onnx/sbs.py

@@ -205,7 +205,7 @@ def run_aligned(
             Model(), (x,), dynamic_shapes=({0: torch.export.Dim("batch")},)
         )
         onx = torch.onnx.export(
-            Model(), (x,), dynamic_shapes=({0: torch.export.Dim("batch")},), dynamo=True
+            Model(), (x,), dynamic_shapes=({0: torch.export.Dim("batch")},)
         ).model_proto
         results = list(
             map(

{onnx_diagnostic-0.7.9.dist-info → onnx_diagnostic-0.7.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.7.9
+Version: 0.7.10
 Summary: Investigate ONNX models
 Home-page: https://github.com/sdpython/onnx-diagnostic
 Author: Xavier Dupré
@@ -95,7 +95,7 @@ Getting started
 
     git clone https://github.com/sdpython/onnx-diagnostic.git
     cd onnx-diagnostic
-    pip install -e .
+    pip install -e . -v
 
 or
 

{onnx_diagnostic-0.7.9.dist-info → onnx_diagnostic-0.7.10.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onnx_diagnostic/__init__.py,sha256=kVcl-JnGE4IT1aVApD12HyIKRM7Rq6QRFtmH09JgMwY,173
+onnx_diagnostic/__init__.py,sha256=zdvFsRTL3vL-gFelvSYnpPCXNbg8EPwbC3qQ47KhLbw,174
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
 onnx_diagnostic/_command_lines_parser.py,sha256=TVPlDjsWZd_Zb9DzN3zj0OGxd8nz_nUsjQyGkmyMNsA,32939
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
@@ -12,22 +12,22 @@ onnx_diagnostic/helpers/__init__.py,sha256=GJ2GT7cgnlIveVUwMZhuvUwidbTJaKv8CsSIO
 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=dFiKPnD3qT_rel9C7Az9AEnbV2drfSMSdXBRotJJUU4,24686
+onnx_diagnostic/helpers/cache_helper.py,sha256=-2H4hMO5ZIINsaJS7mK9ETgv-kA_d-dlwT1TDp2Yjbo,24754
 onnx_diagnostic/helpers/config_helper.py,sha256=H2mOcMXfrcolFnt8EuqmRFkpQ3YdNRDfvm9ToI1vNH0,5618
 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=OsQz2um10DgGiX3fgOulTDFQop0wCMX6shPonQgN71w,62940
+onnx_diagnostic/helpers/helper.py,sha256=mRQ-wo9P30m0Z0_v3EfEDwK_dZFTUhIVKo-5ut9DPW8,63194
 onnx_diagnostic/helpers/log_helper.py,sha256=ODtMLFfJvkyss9PJwEZFd5_8bLcliaMq0A17t0dSIFA,82771
 onnx_diagnostic/helpers/memory_peak.py,sha256=OT6mz0muBbBZY0pjgW2_eCk_lOtFRo-5w4jFo2Z6Kok,6380
 onnx_diagnostic/helpers/mini_onnx_builder.py,sha256=FgK-Kws1WpSYdYJCPyONwQYY3AjbgUHimZlaYyiNUfE,21286
 onnx_diagnostic/helpers/model_builder_helper.py,sha256=tJi4VkP0TS2yyDSxQPNu9WRoSnPCAjr6L0J49X2LdXk,12810
-onnx_diagnostic/helpers/onnx_helper.py,sha256=GApd3fmweLZ85GjEqo49ZCiOUSJ7vtXCBs-Tp3WlydI,39825
+onnx_diagnostic/helpers/onnx_helper.py,sha256=oxl3x0EQowGP9kfz8aKDqnJZcvYY8FeZLsfoLJDiSUg,39826
 onnx_diagnostic/helpers/ort_session.py,sha256=UgUUeUslDxEFBc6w6f3HMq_a7bn4TBlItmojqWquSj4,29281
 onnx_diagnostic/helpers/rt_helper.py,sha256=qbV6zyMs-iH6H65WHC2tu4h0psnHg0TX5fwfO_k-glg,4623
-onnx_diagnostic/helpers/torch_helper.py,sha256=r7uvT5Pmf4lvVf1LfzdoIFJeFVvnwXLayipgHmOK9SY,33081
+onnx_diagnostic/helpers/torch_helper.py,sha256=e0KkSTdoZthc5Yuf9e8XVGAx-lqOYy4DeRRe-N4QUYQ,33478
 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=1O7dHj8Aspolidg6rB2Nm7hT3HaGb4TxAgjCCD0XVcQ,26159
+onnx_diagnostic/reference/ort_evaluator.py,sha256=nituItsP3IKDDWF9z-iGX_iAubrTcdk8pb1GVBp9sCU,26161
 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=gf8EPoX4C4yGgQ-DqxXxaGU26WdEhn8Gd6iesDLqAV0,27692
@@ -52,7 +52,7 @@ onnx_diagnostic/reference/ops/op_qlinear_conv.py,sha256=DgiUwoj-gW5xv9CVFXPPRJbK
 onnx_diagnostic/reference/ops/op_quick_gelu.py,sha256=43QNWbOK88-h7qqe0ubMTbVt3Qo4YmNZPfrbu5kIefM,631
 onnx_diagnostic/reference/ops/op_replace_zero.py,sha256=Fe8yFJeg33_5e1RGtv6fqBZOY-qpOCv7PukjdubzChA,323
 onnx_diagnostic/reference/ops/op_rotary.py,sha256=GbJhk6id6rSelEK1VuD-LBPM6xDckpmsmJuydSJbMws,628
-onnx_diagnostic/reference/ops/op_scan.py,sha256=1dGjcmwhSk9VJWAOrvAks9es71Qug5e3NcGkUH-bKSw,2072
+onnx_diagnostic/reference/ops/op_scan.py,sha256=qmPdrUrhOrxzjiwlOYAyyl-Ztxc_rkAU4oweJgOlbZ8,2077
 onnx_diagnostic/reference/ops/op_scatter_elements.py,sha256=D8fkrNlk22C-o3MddLpaex7vS2NT4KXDzqhYvK250zA,3775
 onnx_diagnostic/reference/ops/op_scatternd_of_shape.py,sha256=PUSRHd_CugWkEMiy9SeKApk26edTXVjDUNC8fLRRvwA,812
 onnx_diagnostic/reference/ops/op_simplified_layer_normalization.py,sha256=1ChLxn_1kYbbN6KTa0uJAHEyJlutBo-B1CY8YVs7EaM,280
@@ -89,36 +89,37 @@ onnx_diagnostic/tasks/text_generation.py,sha256=hV-oK1bWjtepxkA491Va_0CWrELZbfP4
 onnx_diagnostic/tasks/text_to_image.py,sha256=mOS3Ruosi3hzRMxXLDN7ZkAbi7NnQb7MWwQP_okGVHs,2962
 onnx_diagnostic/tasks/zero_shot_image_classification.py,sha256=jJCMWuOqGv5ahCfjrcqxuYCJFhTgHV5KUf2yyv2yxYA,4624
 onnx_diagnostic/torch_export_patches/__init__.py,sha256=0SaZedwznm1hQUCvXZsGZORV5vby954wEExr5faepGg,720
-onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=Nx3HLII-KIemfMydraTRlwK9O0kgVug57SiLT9y9KOY,23749
+onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=KYux1-Ea3zCxffxc-17DVfO0G_XCU1flPw_XUc_Fcmg,28008
 onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=klvqiMjccwGhiRnLRVbwTi5WWkMfvtnOV5ycirPcAdA,11354
 onnx_diagnostic/torch_export_patches/patch_expressions.py,sha256=vr4tt61cbDnaaaduzMj4UBZ8OUtr6GfDpIWwOYqjWzs,3213
 onnx_diagnostic/torch_export_patches/patch_inputs.py,sha256=3ySY1nAzINSS1hAzTycwfdbPas8G5CDL2MjnaAHBkMU,7825
 onnx_diagnostic/torch_export_patches/patch_module.py,sha256=R2d9IHM-RwsBKDsxuBIJnEqMoxbS9gd4YWFGG2wwV5A,39881
 onnx_diagnostic/torch_export_patches/patch_module_helper.py,sha256=2U0AdyZuU0W54QTdE7tY7imVzMnpQ5091ADNtTCkT8Y,6967
 onnx_diagnostic/torch_export_patches/eval/__init__.py,sha256=57x62uZNA80XiWgkG8Fe0_8YJcIVrvKLPqvwLDPJwgc,24008
-onnx_diagnostic/torch_export_patches/eval/model_cases.py,sha256=DTvdHPtNQh25Akv5o3D4Jxf1L1-SJ7w14tgvj8AAns8,26577
+onnx_diagnostic/torch_export_patches/eval/model_cases.py,sha256=OU8-63VDhiWtQV3scBV9JyGXn8ds74OzY2-IOZkwg0A,26580
 onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=TFjuw--sTYPCoVEaYlYLJuElx_CUynJR6s6ypoZtRWw,18956
-onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=tcDNJzOIivyOM6XbTm4munHKHAmVrOKE6nbqIdl-4dg,66290
+onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=wXopyo0-6KmATOfqXMLEvxpe_jDRRIY8fWRjUjMlSkI,67776
 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=dAKi4zujlBxDvxvaVI_qH4qW9AlpVFMtCkvGTNCJCUY,9353
+onnx_diagnostic/torch_export_patches/serialization/transformers_impl.py,sha256=mcmZGekzQlLgE_o3SdKlRgCx4ewwyyAuNWZ9CaN_zrI,9317
 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/validate.py,sha256=IkWyuwKmIqetMN5ziD9jPwSgRAMzJnQqPElIQFJiJwc,65907
+onnx_diagnostic/torch_models/validate.py,sha256=Qu9gW1AatgpmsWzXN3s-vVCKnKDYTV1wPO3wnUU44wU,67161
 onnx_diagnostic/torch_models/hghub/__init__.py,sha256=vi1Q7YHdddj1soiBN42MSvJdFqe2_KUoWafHISjwOu8,58
 onnx_diagnostic/torch_models/hghub/hub_api.py,sha256=Bvr-sTAhS6s6UCkt-KsY_7Mdai08-AQzvHrzbYCSuvk,13186
-onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=W05mciqUqhaYEfYNHtUeuwOMOZoQTuDidRLEIx4z1CE,8523
-onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=mboN04WTZMPgfw_JOP01aINWjmq6qmOKQhDE28Fc_zY,282283
-onnx_diagnostic/torch_models/hghub/model_inputs.py,sha256=h6Pi0dkUFXpDGudJ5mQQ9NSQCOjpF6Pm-J6_shsWiH4,11546
+onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=jN2Y-96DRmj3hBCQT4ugCT6Q5rKv5y5TUi80G-95Zko,8610
+onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=3yH1pQbCYNDmRMNUCwMFf5ELnAa35ubTKD2JRF5y9Ls,287515
+onnx_diagnostic/torch_models/hghub/model_inputs.py,sha256=-YX0guKGqj14cc8ZTco3QjCNXXBtf8inzwrsQdvQr6w,12559
+onnx_diagnostic/torch_models/hghub/model_specific.py,sha256=ZFajyL9MPZp7N6rveKB0IEAYeNKesbo0ItYoZIz90wc,1540
 onnx_diagnostic/torch_models/untrained/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onnx_diagnostic/torch_models/untrained/llm_phi2.py,sha256=ynBTDHJHCk44NjLT_t6OiFDBdPP0rFGPteiONDxvztw,3708
+onnx_diagnostic/torch_models/untrained/llm_phi2.py,sha256=JbGZmW41MPJcQgqaJc9R2G00nI79nI-lABN-ffA1lmY,4037
 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=1EL25DeYFzlBSiFG_XjePBLvsiItRXbdDrr5-QZW2mA,16878
-onnx_diagnostic-0.7.9.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.7.9.dist-info/METADATA,sha256=UIT85yMNIqhtCArUezpyfFnbkz1KY4Q11EjKCBKZVWs,7431
-onnx_diagnostic-0.7.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_diagnostic-0.7.9.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.7.9.dist-info/RECORD,,
+onnx_diagnostic/torch_onnx/sbs.py,sha256=fN799L_G1c2RKEuNcKt_MnQri5dwD4OzeCkBBFFoUBI,16865
+onnx_diagnostic-0.7.10.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.7.10.dist-info/METADATA,sha256=5FswMlBjyOZNZ-pxujgExFBAiJ3rNd9DfPwWL0f9edw,7435
+onnx_diagnostic-0.7.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.7.10.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.7.10.dist-info/RECORD,,