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

onnx_diagnostic/helpers/cache_helper.py

@@ -96,13 +96,16 @@ def flatten_unflatten_for_dynamic_shapes(
             return tuple(subtrees)
         if spec.type is list:
             return list(subtrees)
+        if spec.type is None and not subtrees:
+            return None
         if spec.context:
             # This is a custom class with attributes.
             # It is returned as a list.
             return list(subtrees)
         raise ValueError(
             f"Unable to interpret spec type {spec.type} "
-            f"(type is {type(spec.type)}, context is {spec.context})."
+            f"(type is {type(spec.type)}, context is {spec.context}), "
+            f"spec={spec}, subtrees={subtrees}"
         )
     # This is a list.
     return subtrees

onnx_diagnostic/helpers/config_helper.py

@@ -119,4 +119,51 @@ def default_num_hidden_layers():
     It is lower when the unit tests are running
     when ``UNITTEST_GOING=1``.
     """
+    import torch
+
+    if torch.cuda.is_available():
+        capa = torch.cuda.get_device_capability(0)
+        if capa[0] < 9:
+            return 2
     return 2 if os.environ.get("UNITTEST_GOING", "0") == "1" else 4
+
+
+def build_diff_config(config0, config1):
+    """
+    Returns all the modified values between two configuration
+    """
+    import torch
+
+    diff = {}
+    for k in config0:
+        assert isinstance(k, str), f"k={k!r}, wrong type in {config0}"
+        if k not in config1:
+            v0 = getattr(config0, k) if hasattr(config0, k) else config0[k]
+            diff[k] = f"-{v0}"
+    for k in config1:
+        assert isinstance(k, str), f"k={k!r}, wrong type in {config1}"
+        if k not in config0:
+            v1 = getattr(config1, k) if hasattr(config1, k) else config1[k]
+            diff[k] = f"+{v1}"
+    for k in config0:
+        if k not in config1:
+            continue
+        v0 = getattr(config0, k) if hasattr(config0, k) else config0[k]
+        v1 = getattr(config1, k) if hasattr(config1, k) else config1[k]
+        if (
+            v0 is None
+            or v1 is None
+            or isinstance(v1, (float, int, bool, str, list, tuple, torch.dtype))
+            or (
+                isinstance(v0, dict)
+                and isinstance(v1, dict)
+                and all(isinstance(k, int) for k in v1)
+            )
+        ):
+            if v1 != v0:
+                diff[k] = f"{v0} -> {v1}"
+        else:
+            d = build_diff_config(v0, v1)
+            if d:
+                diff[k] = d
+    return diff

onnx_diagnostic/tasks/image_text_to_text.py

@@ -23,14 +23,20 @@ def reduce_model_config(config: Any) -> Dict[str, Any]:
             config.vision_config.num_hidden_layers = min(
                 config.vision_config.num_hidden_layers, 2
             )
+        if hasattr(config.vision_config, "num_heads"):
+            config.vision_config.num_heads = min(config.vision_config.num_heads, 4)
         if hasattr(config.vision_config, "image_size"):
-            config.vision_config.image_size = min(config.vision_config.image_size, 96)
+            config.vision_config.image_size = min(config.vision_config.image_size, 168 // 2)
         if hasattr(config.vision_config, "intermediate_size"):
             config.vision_config.intermediate_size = min(
                 config.vision_config.intermediate_size, 1076
             )
         if hasattr(config.vision_config, "patch_size"):
-            config.vision_config.patch_size = min(config.vision_config.patch_size, 2)
+            config.vision_config.patch_size = min(config.vision_config.patch_size, 1)
+        if hasattr(config.vision_config, "temporal_patch_size"):
+            config.vision_config.temporal_patch_size = min(
+                config.vision_config.temporal_patch_size, 8
+            )
         if hasattr(config.vision_config, "hidden_size"):
             config.vision_config.hidden_size = min(config.vision_config.hidden_size, 16)
     if hasattr(config, "text_config"):
@@ -245,6 +251,7 @@ def get_inputs(
                 else {0: batch_img}
             ),
             "image_attention_mask": {0: batch, 1: seq_length, 2: images},
+            "image_grid_thw": {0: batch},
             "use_cache": None,
         }
 
@@ -256,6 +263,11 @@ def get_inputs(
         # input_ids[input_ids == image_token_index] = pad_token_id
         token_type_ids = torch.zeros_like(input_ids)
         token_type_ids[input_ids == image_token_index] = 1
+        image_grid_thw = torch.zeros((n_images, 3), dtype=torch.int64)
+        image_grid_thw[:, 1] = height
+        image_grid_thw[:, 2] = width
+        image_grid_thw[0, :] //= 2
+        image_grid_thw[:, 0] = torch.arange(n_images, dtype=image_grid_thw.dtype)
 
         inputs = dict(
             input_ids=input_ids,
@@ -291,6 +303,7 @@ def get_inputs(
                 torch.int64
             ),
             token_type_ids=token_type_ids,
+            image_grid_thw=image_grid_thw,
             use_cache=True,  # Gemma3 does not set this value to true when a cache is provided
         )
         res = dict(inputs=inputs, dynamic_shapes=shapes)

onnx_diagnostic/torch_export_patches/patches/patch_transformers.py

@@ -1032,7 +1032,8 @@ def patched_modeling_marian_eager_attention_forward(
 
 
 class common_RotaryEmbedding(torch.nn.Module):
-    @torch.no_grad()
+    # This may cause some issues.
+    # @torch.no_grad()
     @patched_dynamic_rope_update
     def forward(self, x, position_ids):
         inv_freq_expanded = (
@@ -1482,3 +1483,109 @@ class patched_VisionAttention(torch.nn.Module):
         attn_output = attn_output.reshape(seq_length, -1)
         attn_output = self.proj(attn_output)
         return attn_output
+
+
+try:
+    import transformers.models.qwen3_moe
+
+    patch_qwen3 = True
+except ImportError:
+    patch_qwen3 = False
+
+if patch_qwen3:
+
+    class patched_Qwen3MoeSparseMoeBlock(torch.nn.Module):
+        _PATCHES_ = ["forward", "_forward_expert_loop"]
+        _PATCHED_CLASS_ = (
+            transformers.models.qwen3_moe.modeling_qwen3_moe.Qwen3MoeSparseMoeBlock
+        )
+
+        def _forward_expert_loop(
+            self,
+            final_hidden_states,
+            expert_mask_idx,
+            hidden_states,
+            routing_weights,
+            expert_idx: int,
+        ):
+            # idx, top_x = torch.where(expert_mask_idx.squeeze(0))
+            idx, top_x = torch.nonzero(expert_mask_idx, as_tuple=True)
+            hidden_dim = hidden_states.shape[-1]
+            current_state = hidden_states[None, top_x].reshape(-1, hidden_dim)
+            expert_current_state = self.experts[expert_idx](current_state)
+            current_hidden_states = expert_current_state * routing_weights[top_x, idx, None]
+            return final_hidden_states.index_add(
+                0, top_x, current_hidden_states.to(hidden_states.dtype)
+            )
+
+        def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+            """ """
+            batch_size, sequence_length, hidden_dim = hidden_states.shape
+            hidden_states = hidden_states.view(-1, hidden_dim)
+            # router_logits: (batch * sequence_length, n_experts)
+            router_logits = self.gate(hidden_states)
+
+            routing_weights = torch.nn.functional.softmax(
+                router_logits, dim=1, dtype=torch.float
+            )
+            routing_weights, selected_experts = torch.topk(routing_weights, self.top_k, dim=-1)
+            if self.norm_topk_prob:  # only diff with mixtral sparse moe block!
+                routing_weights /= routing_weights.sum(dim=-1, keepdim=True)
+            # we cast back to the input dtype
+            routing_weights = routing_weights.to(hidden_states.dtype)
+
+            final_hidden_states = torch.zeros(
+                (batch_size * sequence_length, hidden_dim),
+                dtype=hidden_states.dtype,
+                device=hidden_states.device,
+            )
+
+            # One hot encode the selected experts to create an expert mask
+            # this will be used to easily index which expert is going to be sollicitated
+            expert_mask = torch.nn.functional.one_hot(
+                selected_experts, num_classes=self.num_experts
+            ).permute(2, 1, 0)
+
+            # Loop over all available experts in the model
+            # and perform the computation on each expert
+            expert_sum = expert_mask.sum(dim=(-1, -2))
+            # expert_hit = torch.greater(expert_sum, 0).nonzero()
+            # for expert_idx in expert_hit:
+            for expert_idx in range(self.num_experts):
+                # initial code has a squeeze but it is not possible to do that.
+                # expert_mask_idx = expert_mask[expert_idx].squeeze(0)
+                expert_mask_idx = expert_mask[expert_idx]
+                final_hidden_states = torch.cond(
+                    (expert_sum[expert_idx] > 0).item(),
+                    lambda final_hidden_states, expert_mask, hidden_states, routing_weights, _i=expert_idx: self._forward_expert_loop(  # noqa: E501
+                        final_hidden_states,
+                        expert_mask,
+                        hidden_states,
+                        routing_weights,
+                        expert_idx=_i,
+                    ),
+                    lambda final_hidden_states, *args: final_hidden_states.clone(),
+                    [final_hidden_states, expert_mask_idx, hidden_states, routing_weights],
+                )
+
+                # if expert_sum[expert_idx] > 0:
+                #    idx, top_x = torch.where(expert_mask[expert_idx].squeeze(0))
+
+                # Index the correct hidden states and compute the expert hidden state for
+                # the current expert. We need to make sure to multiply the output hidden
+                # states by `routing_weights` on the corresponding tokens (top-1 and top-2)
+                #    current_state = hidden_states[None, top_x].reshape(-1, hidden_dim)
+                #    current_hidden_states = (
+                #        expert_layer(current_state) * routing_weights[top_x, idx, None]
+                #    )
+
+                # However `index_add_` only support torch tensors for indexing so we'll use
+                # the `top_x` tensor here.
+                #    final_hidden_states.index_add_(
+                #        0, top_x, current_hidden_states.to(hidden_states.dtype)
+                #    )
+
+            final_hidden_states = final_hidden_states.reshape(
+                batch_size, sequence_length, hidden_dim
+            )
+            return final_hidden_states, router_logits

onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py

@@ -4562,7 +4562,7 @@ def _ccached_diffusers_tiny_torch_full_checker_unet():
     }
 
 
-def _ccached_riny_random_gemma_3():
+def _ccached_tiny_random_gemma_3():
     "tiny-random/gemma-3"
     return transformers.Gemma3Config(
         **{
@@ -4618,3 +4618,72 @@ def _ccached_riny_random_gemma_3():
             },
         }
     )
+
+
+def _ccached_zai_glm_45():
+    "zai-org/GLM-4.5V"
+    return transformers.Glm4vMoeConfig(
+        **{
+            "architectures": ["Glm4vMoeForConditionalGeneration"],
+            "model_type": "glm4v_moe",
+            "text_config": {
+                "pad_token_id": 151329,
+                "vocab_size": 151552,
+                "eos_token_id": [151329, 151336, 151338],
+                "image_end_token_id": 151340,
+                "image_start_token_id": 151339,
+                "image_token_id": 151363,
+                "head_dim": 128,
+                "attention_bias": true,
+                "attention_dropout": 0.0,
+                "first_k_dense_replace": 1,
+                "hidden_act": "silu",
+                "hidden_size": 4096,
+                "initializer_range": 0.02,
+                "intermediate_size": 10944,
+                "max_position_embeddings": 65536,
+                "model_type": "glm4v_moe_text",
+                "moe_intermediate_size": 1408,
+                "n_group": 1,
+                "n_routed_experts": 128,
+                "n_shared_experts": 1,
+                "norm_topk_prob": true,
+                "num_attention_heads": 96,
+                "num_experts_per_tok": 8,
+                "num_hidden_layers": 46,
+                "num_key_value_heads": 8,
+                "partial_rotary_factor": 0.5,
+                "rms_norm_eps": 1e-05,
+                "torch_dtype": "bfloat16",
+                "rope_scaling": {"rope_type": "default", "mrope_section": [8, 12, 12]},
+                "rope_theta": 10000.0,
+                "routed_scaling_factor": 1.0,
+                "topk_group": 1,
+                "use_cache": true,
+                "use_qk_norm": false,
+            },
+            "torch_dtype": "bfloat16",
+            "transformers_version": "4.55.0.dev0",
+            "video_end_token_id": 151342,
+            "video_start_token_id": 151341,
+            "video_token_id": 151364,
+            "vision_config": {
+                "attention_bias": false,
+                "attention_dropout": 0.0,
+                "depth": 24,
+                "hidden_act": "silu",
+                "hidden_size": 1536,
+                "image_size": 336,
+                "in_channels": 3,
+                "initializer_range": 0.02,
+                "intermediate_size": 10944,
+                "model_type": "glm4v_moe",
+                "num_heads": 12,
+                "out_hidden_size": 4096,
+                "patch_size": 14,
+                "rms_norm_eps": 1e-05,
+                "spatial_merge_size": 2,
+                "temporal_patch_size": 2,
+            },
+        }
+    )

onnx_diagnostic/torch_models/hghub/model_inputs.py

@@ -1,10 +1,11 @@
+import copy
 import inspect
 import os
 import pprint
 from typing import Any, Dict, Optional, Tuple
 import torch
 import transformers
-from ...helpers.config_helper import update_config
+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
 
@@ -121,6 +122,7 @@ def get_untrained_model_with_inputs(
         )
 
     # 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():
@@ -133,6 +135,15 @@ def get_untrained_model_with_inputs(
                 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:
@@ -232,6 +243,7 @@ def get_untrained_model_with_inputs(
 
     res["input_kwargs"] = kwargs
     res["model_kwargs"] = mkwargs
+    res["dump_info"] = dict(config_diff=diff_config)
 
     sizes = compute_model_size(model)
     res["model"] = model

onnx_diagnostic/torch_models/validate.py

@@ -1,6 +1,7 @@
 import datetime
 import inspect
 import os
+import pprint
 import sys
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import time
@@ -467,6 +468,21 @@ def validate_model(
         f"inputs2 is True but second set is missing in data for "
         f"model id {model_id!r}: {sorted(data)}"
     )
+    if dump_folder:
+        with open(os.path.join(dump_folder, "model_config.txt"), "w") as f:
+            f.write(f"model_id: {model_id}\n------\n")
+            f.write(
+                pprint.pformat(
+                    data["configuration"]
+                    if type(data["configuration"]) is dict
+                    else data["configuration"].to_dict()
+                )
+            )
+        dump_info = data.get("dump_info", None)
+        if dump_info:
+            with open(os.path.join(dump_folder, "model_dump_info.txt"), "w") as f:
+                f.write(f"model_id: {model_id}\n------\n")
+                f.write(pprint.pformat(dump_info))
 
     if exporter == "modelbuilder":
         # Models used with ModelBuilder do not like batch size > 1.

{onnx_diagnostic-0.7.7.dist-info → onnx_diagnostic-0.7.8.dist-info}/METADATA

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

{onnx_diagnostic-0.7.7.dist-info → onnx_diagnostic-0.7.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onnx_diagnostic/__init__.py,sha256=JdBGK1KI9-G1MdBmNPIE7pLfaEHkMhgCq6h_YPJEYdw,173
+onnx_diagnostic/__init__.py,sha256=atIZhOUaWoHQQ1pUnGu6Qn-uTq_KocBvIG5yInBKI04,173
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
 onnx_diagnostic/_command_lines_parser.py,sha256=8JlT1vzyGztkJT2v6lpQx5itLKY4FYlpFng3z8n3TAU,32937
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
@@ -12,8 +12,8 @@ onnx_diagnostic/helpers/__init__.py,sha256=GJ2GT7cgnlIveVUwMZhuvUwidbTJaKv8CsSIO
 onnx_diagnostic/helpers/_log_helper.py,sha256=zZ7AqGpiF3O2-9N8fLuPeB5VfJpbg3tQ20ccDRdQPVE,16753
 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=sd9hnOW8uCU3yqvIB8tnxANRYEl1V_Ej8WDZMMI9VR8,24566
-onnx_diagnostic/helpers/config_helper.py,sha256=ZrwdQwG3atXzto1VLUzCVOzyBIWkih_EGc3qKHuluZw,4139
+onnx_diagnostic/helpers/cache_helper.py,sha256=dFiKPnD3qT_rel9C7Az9AEnbV2drfSMSdXBRotJJUU4,24686
+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
@@ -77,7 +77,7 @@ onnx_diagnostic/tasks/automatic_speech_recognition.py,sha256=tguoQO77okXo8vcJrN2
 onnx_diagnostic/tasks/feature_extraction.py,sha256=pcFON5uGKoykjg52bMsvpYG7KJvXd8JDC43rAjXIzB0,5572
 onnx_diagnostic/tasks/fill_mask.py,sha256=Z0OyDs3pcnjJLzZBbS52d6pa6jh6m2Uy8-h3nF5wbDA,2675
 onnx_diagnostic/tasks/image_classification.py,sha256=nLpBBB1Gkog3Fk6pu2waiHcuQr4ILPptc9FhQ-pn460,4682
-onnx_diagnostic/tasks/image_text_to_text.py,sha256=syi7MzOKnHlWfqsfQsbmY6zcwtj8flg5_jVqodmIKcY,16806
+onnx_diagnostic/tasks/image_text_to_text.py,sha256=XlikpvAdB2q4sQ9U17JZWLUZ77_rGsbICM-xxcgqfQc,17498
 onnx_diagnostic/tasks/mask_generation.py,sha256=fjdD3rd-O-mFL0hQy3la3JXKth_0bH2HL7Eelq-3Dbs,5057
 onnx_diagnostic/tasks/mixture_of_expert.py,sha256=al4tk1BrHidtRiHlAaiflWiJaAte0d5M8WcBioANG9k,2808
 onnx_diagnostic/tasks/object_detection.py,sha256=3FiT8ya5FCd9lwjQCRXhAwXspNwYTlAD3Gpk8aAcG5w,4279
@@ -99,26 +99,26 @@ onnx_diagnostic/torch_export_patches/eval/__init__.py,sha256=57x62uZNA80XiWgkG8F
 onnx_diagnostic/torch_export_patches/eval/model_cases.py,sha256=DTvdHPtNQh25Akv5o3D4Jxf1L1-SJ7w14tgvj8AAns8,26577
 onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=g1UjL6A6iB7Qh2Cs1efuKk5377IvsSnZXUk3jNeRu_E,18830
-onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=3pAm3cPDq_HxpKCJNLLyrO53ZAnByjg7uKzpUPhz7nc,61378
+onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=tcDNJzOIivyOM6XbTm4munHKHAmVrOKE6nbqIdl-4dg,66290
 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_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=hMe4fbRDubSLfWc3XguRl_fjqQBa7-2zVKxhge9iaqc,64917
+onnx_diagnostic/torch_models/validate.py,sha256=fFDe68M5-1W67UEkLLFqKbaUNjN1qyehyBMxrlZTs90,65588
 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=XZ_PsMUmMooJw5pBqEtDMOWbbLYxDcJdRWf-FNz2cYg,279674
-onnx_diagnostic/torch_models/hghub/model_inputs.py,sha256=SDRLCA2zivEHIKr2RRRP-dZNiNUcpYS3EgP0unLExxY,11046
+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/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_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.7.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.7.7.dist-info/METADATA,sha256=zus-hHQ_QtzpPCf--m_YA8MnWvfb8rmwbCGEy-ZlLro,7431
-onnx_diagnostic-0.7.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_diagnostic-0.7.7.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.7.7.dist-info/RECORD,,
+onnx_diagnostic-0.7.8.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.7.8.dist-info/METADATA,sha256=6szG1djw7CRRO3FOrgBWGW3hZ3hNL6zwIOlcWrmtl9k,7431
+onnx_diagnostic-0.7.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.7.8.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.7.8.dist-info/RECORD,,