onnx-diagnostic 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

onnx_diagnostic/tasks/text2text_generation.py

@@ -6,7 +6,7 @@ from ..helpers.config_helper import update_config, check_hasattr, _pick
 __TASK__ = "text2text-generation"
 
 
-def reduce_model_config(config: Any, task: str) -> Dict[str, Any]:
+def reduce_model_config(config: Any) -> Dict[str, Any]:
     """Reduces a model size."""
     kwargs: Dict[str, Any] = {}
     if hasattr(config, "num_decoder_layers"):
@@ -28,6 +28,7 @@ def get_inputs(
     batch_size: int = 2,
     sequence_length: int = 30,
     sequence_length2: int = 3,
+    add_second_input: bool = False,
     **kwargs,  # unused
 ):
     """
@@ -125,10 +126,25 @@ def get_inputs(
         # encoder_last_hidden_state=torch.randn(batch_size, sequence_length2, encoder_dim),
         # encoder_outputs=torch.randn(batch_size, sequence_length2, encoder_dim),
     )
-    return dict(inputs=inputs, dynamic_shapes=shapes)
+    res = dict(inputs=inputs, dynamic_shapes=shapes)
+    if add_second_input:
+        res["inputs2"] = get_inputs(
+            model=model,
+            config=config,
+            dummy_max_token_id=dummy_max_token_id,
+            num_key_value_heads=num_key_value_heads,
+            num_hidden_layers=num_hidden_layers,
+            head_dim=head_dim,
+            encoder_dim=encoder_dim,
+            batch_size=batch_size + 1,
+            sequence_length=sequence_length + 1,
+            sequence_length2=sequence_length2 + 1,
+            **kwargs,
+        )["inputs"]
+    return res
 
 
-def random_input_kwargs(config: Any, task: str) -> Tuple[Dict[str, Any], Callable]:
+def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
     """
     Inputs kwargs.
 

onnx_diagnostic/tasks/text_classification.py

@@ -5,7 +5,7 @@ from ..helpers.config_helper import update_config, check_hasattr
 __TASK__ = "text-classification"
 
 
-def reduce_model_config(config: Any, task: str) -> Dict[str, Any]:
+def reduce_model_config(config: Any) -> Dict[str, Any]:
     """Reduces a model size."""
     check_hasattr(config, "num_attention_heads", "num_hidden_layers")
     kwargs = dict(
@@ -22,6 +22,7 @@ def get_inputs(
     batch_size: int,
     sequence_length: int,
     dummy_max_token_id: int,
+    add_second_input: bool = False,
     **kwargs,  # unused
 ):
     """
@@ -48,10 +49,20 @@ def get_inputs(
         token_type_ids=torch.zeros((batch_size, sequence_length)).to(torch.int64),
         attention_mask=torch.ones((batch_size, sequence_length)).to(torch.int64),
     )
-    return dict(inputs=inputs, dynamic_shapes=shapes)
+    res = dict(inputs=inputs, dynamic_shapes=shapes)
+    if add_second_input:
+        res["inputs2"] = get_inputs(
+            model=model,
+            config=config,
+            batch_size=batch_size + 1,
+            sequence_length=sequence_length + 1,
+            dummy_max_token_id=dummy_max_token_id,
+            **kwargs,
+        )["inputs"]
+    return res
 
 
-def random_input_kwargs(config: Any, task: str) -> Tuple[Dict[str, Any], Callable]:
+def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
     """
     Inputs kwargs.
 

onnx_diagnostic/tasks/text_generation.py

@@ -11,7 +11,7 @@ from ..helpers.config_helper import update_config, check_hasattr, _pick
 __TASK__ = "text-generation"
 
 
-def reduce_model_config(config: Any, task: str) -> Dict[str, Any]:
+def reduce_model_config(config: Any) -> Dict[str, Any]:
     """Reduces a model size."""
     # FalconMambaConfig: use_mambapy
     check_hasattr(
@@ -71,6 +71,7 @@ def get_inputs(
     num_key_value_heads: Optional[int] = None,
     head_dim: Optional[int] = None,
     cls_cache: Optional[Union[type, str]] = None,
+    add_second_input: bool = False,
     **kwargs,  # unused
 ):
     """
@@ -144,58 +145,78 @@ def get_inputs(
                 ]
             ),
         )
-        return dict(inputs=inputs, dynamic_shapes=shapes)
-
-    if head_dim is None:
-        assert config, "head_dim is None, the value cannot be set without a configuration"
-        head_dim = config.hidden_size // config.num_attention_heads
+        res = dict(inputs=inputs, dynamic_shapes=shapes)
+    else:
+        if head_dim is None:
+            assert config, "head_dim is None, the value cannot be set without a configuration"
+            head_dim = config.hidden_size // config.num_attention_heads
 
-    shapes = {
-        "input_ids": {0: batch, 1: seq_length},
-        "attention_mask": {
-            0: batch,
-            1: "cache+seq",  # cache_length + seq_length
-        },
-        "position_ids": {
-            0: batch,
-            1: "cache+seq",  # cache_length + seq_length
-        },
-        "past_key_values": [
-            [{0: batch, 2: cache_length} for _ in range(num_hidden_layers)],
-            [{0: batch, 2: cache_length} for _ in range(num_hidden_layers)],
-        ],
-    }
+        shapes = {
+            "input_ids": {0: batch, 1: seq_length},
+            "attention_mask": {
+                0: batch,
+                1: "cache+seq",  # cache_length + seq_length
+            },
+            "position_ids": {
+                0: batch,
+                1: "cache+seq",  # cache_length + seq_length
+            },
+            "past_key_values": [
+                [{0: batch, 2: cache_length} for _ in range(num_hidden_layers)],
+                [{0: batch, 2: cache_length} for _ in range(num_hidden_layers)],
+            ],
+        }
 
-    make_cache = (
-        make_sliding_window_cache
-        if cls_cache in ("SlidingWindowCache", transformers.cache_utils.SlidingWindowCache)
-        else make_dynamic_cache
-    )
+        make_cache = (
+            make_sliding_window_cache
+            if cls_cache in ("SlidingWindowCache", transformers.cache_utils.SlidingWindowCache)
+            else make_dynamic_cache
+        )
 
-    inputs = dict(
-        input_ids=torch.randint(0, dummy_max_token_id, (batch_size, sequence_length2)).to(
-            torch.int64
-        ),
-        attention_mask=torch.ones((batch_size, sequence_length + sequence_length2)).to(
-            torch.int64
-        ),
-        position_ids=torch.arange(sequence_length, sequence_length + sequence_length2)
-        .to(torch.int64)
-        .expand((batch_size, -1)),
-        past_key_values=make_cache(
-            [
-                (
-                    torch.randn(batch_size, num_key_value_heads, sequence_length, head_dim),
-                    torch.randn(batch_size, num_key_value_heads, sequence_length, head_dim),
-                )
-                for i in range(num_hidden_layers)
-            ]
-        ),
-    )
-    return dict(inputs=inputs, dynamic_shapes=shapes)
+        inputs = dict(
+            input_ids=torch.randint(0, dummy_max_token_id, (batch_size, sequence_length2)).to(
+                torch.int64
+            ),
+            attention_mask=torch.ones((batch_size, sequence_length + sequence_length2)).to(
+                torch.int64
+            ),
+            position_ids=torch.arange(sequence_length, sequence_length + sequence_length2)
+            .to(torch.int64)
+            .expand((batch_size, -1)),
+            past_key_values=make_cache(
+                [
+                    (
+                        torch.randn(
+                            batch_size, num_key_value_heads, sequence_length, head_dim
+                        ),
+                        torch.randn(
+                            batch_size, num_key_value_heads, sequence_length, head_dim
+                        ),
+                    )
+                    for i in range(num_hidden_layers)
+                ]
+            ),
+        )
+        res = dict(inputs=inputs, dynamic_shapes=shapes)
+    if add_second_input:
+        res["inputs2"] = get_inputs(
+            model=model,
+            config=config,
+            dummy_max_token_id=dummy_max_token_id,
+            num_hidden_layers=num_hidden_layers,
+            batch_size=batch_size + 1,
+            sequence_length=sequence_length + 1,
+            sequence_length2=sequence_length2 + 1,
+            dynamic_rope=dynamic_rope,
+            num_key_value_heads=num_key_value_heads,
+            head_dim=head_dim,
+            cls_cache=cls_cache,
+            **kwargs,
+        )["inputs"]
+    return res
 
 
-def random_input_kwargs(config: Any, task: str) -> Tuple[Dict[str, Any], Callable]:
+def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
     """
     Inputs kwargs.
 

onnx_diagnostic/tasks/zero_shot_image_classification.py

@@ -5,7 +5,7 @@ from ..helpers.config_helper import update_config, check_hasattr
 __TASK__ = "zero-shot-image-classification"
 
 
-def reduce_model_config(config: Any, task: str) -> Dict[str, Any]:
+def reduce_model_config(config: Any) -> Dict[str, Any]:
     """Reduces a model size."""
     check_hasattr(config, "vision_config", "text_config")
     check_hasattr(config.vision_config, "num_hidden_layers", "num_attention_heads")
@@ -34,6 +34,7 @@ def get_inputs(
     input_height: int = 224,
     input_channels: int = 3,
     batch_size_image=3,
+    add_second_input: bool = False,
     **kwargs,  # unused
 ):
     """
@@ -81,10 +82,24 @@ def get_inputs(
             batch_size_image, input_channels, input_width, input_height
         ).clamp(-1, 1),
     )
-    return dict(inputs=inputs, dynamic_shapes=shapes)
+    res = dict(inputs=inputs, dynamic_shapes=shapes)
+    if add_second_input:
+        res["inputs2"] = get_inputs(
+            model=model,
+            config=config,
+            dummy_max_token_id=dummy_max_token_id,
+            batch_size=batch_size + 1,
+            sequence_length=sequence_length + 1,
+            input_width=input_width,
+            input_height=input_height,
+            input_channels=input_channels,
+            batch_size_image=batch_size_image + 1,
+            **kwargs,
+        )["inputs"]
+    return res
 
 
-def random_input_kwargs(config: Any, task: str) -> Tuple[Dict[str, Any], Callable]:
+def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
     """
     Inputs kwargs.
 

onnx_diagnostic/torch_export_patches/patches/patch_torch.py

@@ -44,7 +44,7 @@ def _catch_produce_guards_and_solve_constraints(
             raise
         if verbose:
             print(
-                f"[_catch_produce_guards_and_solve_constraints] ERROR"
+                f"[_catch_produce_guards_and_solve_constraints] ERROR: "
                 f"produce_guards_and_solve_constraints failed, "
                 f"use SKIP_SOLVE_CONSTRAINTS=0 to avoid skipping\n"
                 f"fake_mode={fake_mode}\n"
@@ -54,6 +54,7 @@ def _catch_produce_guards_and_solve_constraints(
                 f"_is_torch_jit_trace={_is_torch_jit_trace}\n"
                 f"exc={e}\ngm={gm}"
             )
+        torch._dynamo.reset()
 
 
 def patch__check_input_constraints_for_graph(
@@ -70,13 +71,14 @@ def patch__check_input_constraints_for_graph(
             raise
         if verbose:
             print(
-                f"[_check_input_constraints_for_graph] ERROR"
+                f"[_check_input_constraints_for_graph] ERROR: "
                 f"_check_input_constraints_for_graph failed, "
                 f"use SKIP_SOLVE_CONSTRAINTS=0 to avoid skipping\n"
                 f"input_placeholders={input_placeholders}\n"
                 f"range_constraints={range_constraints}\n"
                 f"exc={e}"
             )
+        torch._dynamo.reset()
 
 
 def patched_infer_size(a, b):

onnx_diagnostic/torch_export_patches/patches/patch_transformers.py

@@ -5,6 +5,7 @@ import torch
 import transformers
 from transformers.modeling_attn_mask_utils import AttentionMaskConverter
 from transformers.cache_utils import StaticCache, Cache, DynamicCache
+from ...ext_test_case import has_transformers
 from ...helpers.torch_test_helper import is_torchdynamo_exporting
 
 
@@ -50,7 +51,8 @@ class patched_AttentionMaskConverter:
     ``transformers.modeling_attn_mask_utils.AttentionMaskConverter._make_causal_mask``.
     """
 
-    _PATCHES_ = ["_make_causal_mask"]
+    # This method was fixed in 4.51 at least.
+    _PATCHES_ = ["_make_causal_mask"] if not has_transformers("4.48.3") else []
     _PATCHED_CLASS_ = AttentionMaskConverter
 
     @staticmethod
@@ -69,6 +71,9 @@ class patched_AttentionMaskConverter:
         This static method may be called with ``AttentionMaskConverter._make_causal_mask``
         or ``self._make_causal_mask``. That changes this argument is receives.
         That should not matter but...
+        The patch should be implemented in another way. static methods do not play well
+        with a simple replacement.
+        Fortunately, this patch does not seem to be needed anymore with transformers>=4.48.3.
         """
         if args:
             index = 0 if isinstance(args[0], (tuple, torch.Size)) else 1

onnx_diagnostic/torch_models/hghub/hub_api.py

@@ -1,8 +1,10 @@
+import copy
 import functools
 import os
 from typing import Any, Dict, List, Optional, Union
 import transformers
 from huggingface_hub import HfApi, model_info
+from ...helpers.config_helper import update_config
 from . import hub_data_cached_configs
 from .hub_data import __date__, __data_tasks__, load_architecture_task, __data_arch_values__
 
@@ -30,7 +32,7 @@ def _retrieve_cached_configurations() -> Dict[str, transformers.PretrainedConfig
     return res
 
 
-def get_cached_configuration(name: str) -> Optional[transformers.PretrainedConfig]:
+def get_cached_configuration(name: str, **kwargs) -> Optional[transformers.PretrainedConfig]:
     """
     Returns cached configuration to avoid having to many accesses to internet.
     It returns None if not Cache. The list of cached models follows.
@@ -46,14 +48,18 @@ def get_cached_configuration(name: str) -> Optional[transformers.PretrainedConfi
     cached = _retrieve_cached_configurations()
     assert cached, "no cached configuration, which is weird"
     if name in cached:
-        return cached[name]()
+        conf = cached[name]()
+        if kwargs:
+            conf = copy.deepcopy(conf)
+            update_config(conf, kwargs)
+        return conf
     if os.environ.get("NOHTTP", ""):
         raise AssertionError(f"Unable to find {name!r} in {sorted(cached)}")
     return None
 
 
 def get_pretrained_config(
-    model_id: str, trust_remote_code: bool = True, use_preinstalled: bool = True
+    model_id: str, trust_remote_code: bool = True, use_preinstalled: bool = True, **kwargs
 ) -> Any:
     """
     Returns the config for a model_id.
@@ -65,14 +71,15 @@ def get_pretrained_config(
         accessing the network, if available, it is returned by
         :func:`get_cached_configuration`, the cached list is mostly for
         unit tests
+    :param kwargs: additional kwargs
     :return: a configuration
     """
     if use_preinstalled:
-        conf = get_cached_configuration(model_id)
+        conf = get_cached_configuration(model_id, **kwargs)
         if conf is not None:
             return conf
     return transformers.AutoConfig.from_pretrained(
-        model_id, trust_remote_code=trust_remote_code
+        model_id, trust_remote_code=trust_remote_code, **kwargs
     )
 
 

onnx_diagnostic/torch_models/hghub/hub_data.py

@@ -13,6 +13,7 @@ __data_arch__ = textwrap.dedent(
     ASTModel,feature-extraction
     AlbertModel,feature-extraction
     BeitForImageClassification,image-classification
+    BartModel,feature-extraction
     BertForMaskedLM,fill-mask
     BertForSequenceClassification,text-classification
     BertModel,sentence-similarity
@@ -76,6 +77,7 @@ __data_arch__ = textwrap.dedent(
     MobileNetV2Model,image-feature-extraction
     MobileViTForImageClassification,image-classification
     ModernBertForMaskedLM,fill-mask
+    Phi4MMForCausalLM,MoE
     MoonshineForConditionalGeneration,automatic-speech-recognition
     MptForCausalLM,text-generation
     MusicgenForConditionalGeneration,text-to-audio

onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py

@@ -3569,3 +3569,74 @@ def _ccached_tiiuae_falcon_mamba_tiny_dev():
             "vocab_size": 65024,
         }
     )
+
+
+def _ccached_facebook_bart_base():
+    "facebook/bart-base"
+    return transformers.BartConfig(
+        **{
+            "_name_or_path": "bart-base",
+            "activation_dropout": 0.1,
+            "activation_function": "gelu",
+            "add_bias_logits": false,
+            "add_final_layer_norm": false,
+            "architectures": ["BartModel"],
+            "attention_dropout": 0.1,
+            "bos_token_id": 0,
+            "classif_dropout": 0.1,
+            "classifier_dropout": 0.0,
+            "d_model": 768,
+            "decoder_attention_heads": 12,
+            "decoder_ffn_dim": 3072,
+            "decoder_layerdrop": 0.0,
+            "decoder_layers": 6,
+            "decoder_start_token_id": 2,
+            "dropout": 0.1,
+            "early_stopping": true,
+            "encoder_attention_heads": 12,
+            "encoder_ffn_dim": 3072,
+            "encoder_layerdrop": 0.0,
+            "encoder_layers": 6,
+            "eos_token_id": 2,
+            "forced_eos_token_id": 2,
+            "forced_bos_token_id": 0,
+            "gradient_checkpointing": false,
+            "id2label": {"0": "LABEL_0", "1": "LABEL_1", "2": "LABEL_2"},
+            "init_std": 0.02,
+            "is_encoder_decoder": true,
+            "label2id": {"LABEL_0": 0, "LABEL_1": 1, "LABEL_2": 2},
+            "max_position_embeddings": 1024,
+            "model_type": "bart",
+            "no_repeat_ngram_size": 3,
+            "normalize_before": false,
+            "normalize_embedding": true,
+            "num_beams": 4,
+            "num_hidden_layers": 6,
+            "pad_token_id": 1,
+            "scale_embedding": false,
+            "task_specific_params": {
+                "summarization": {
+                    "length_penalty": 1.0,
+                    "max_length": 128,
+                    "min_length": 12,
+                    "num_beams": 4,
+                },
+                "summarization_cnn": {
+                    "length_penalty": 2.0,
+                    "max_length": 142,
+                    "min_length": 56,
+                    "num_beams": 4,
+                },
+                "summarization_xsum": {
+                    "length_penalty": 1.0,
+                    "max_length": 62,
+                    "min_length": 11,
+                    "num_beams": 6,
+                },
+            },
+            "torch_dtype": "float32",
+            "transformers_version": "4.12.0.dev0",
+            "use_cache": true,
+            "vocab_size": 50265,
+        }
+    )

onnx_diagnostic/torch_models/hghub/model_inputs.py

@@ -17,6 +17,7 @@ def get_untrained_model_with_inputs(
     dynamic_rope: Optional[bool] = None,
     same_as_pretrained: bool = False,
     use_preinstalled: bool = True,
+    add_second_input: bool = False,
 ) -> Dict[str, Any]:
     """
     Gets a non initialized model similar to the original model
@@ -34,6 +35,8 @@ def get_untrained_model_with_inputs(
     :param same_as_pretrained: if True, do not change the default values
         to get a smaller model
     :param use_preinstalled: use preinstalled configurations
+    :param add_second_input: provides a second inputs to check a model
+        supports different shapes
     :return: dictionary with a model, inputs, dynamic shapes, and the configuration
 
     Example:
@@ -58,7 +61,9 @@ def get_untrained_model_with_inputs(
         if use_preinstalled:
             print(f"[get_untrained_model_with_inputs] use preinstalled {model_id!r}")
     if config is None:
-        config = get_pretrained_config(model_id, use_preinstalled=use_preinstalled)
+        config = get_pretrained_config(
+            model_id, use_preinstalled=use_preinstalled, **(model_kwargs or {})
+        )
     archs = config.architectures  # type: ignore
     assert archs is not None and len(archs) == 1, (
         f"Unable to determine the architecture for model {model_id!r}, "
@@ -67,7 +72,6 @@ def get_untrained_model_with_inputs(
     arch = archs[0]
     if verbose:
         print(f"[get_untrained_model_with_inputs] architecture={arch!r}")
-    config = get_pretrained_config(model_id)
     if verbose:
         print(f"[get_untrained_model_with_inputs] cls={config.__class__.__name__!r}")
     task = task_from_arch(arch)
@@ -106,7 +110,7 @@ def get_untrained_model_with_inputs(
     # This line is important. Some models may produce different
     # outputs even with the same inputs in training mode.
     model.eval()
-    res = fct(model, config, **kwargs)
+    res = fct(model, config, add_second_input=add_second_input, **kwargs)
 
     res["input_kwargs"] = kwargs
     res["model_kwargs"] = mkwargs

onnx_diagnostic/torch_models/test_helper.py

@@ -11,10 +11,10 @@ from ..helpers.helper import flatten_object
 from ..helpers.rt_helper import make_feeds
 from ..helpers.torch_test_helper import to_any, torch_deepcopy
 from ..helpers.cache_helper import flatten_unflatten_for_dynamic_shapes
+from ..tasks import random_input_kwargs
 from ..torch_export_patches import bypass_export_some_errors
 from ..torch_export_patches.patch_inputs import use_dyn_not_str
 from .hghub import get_untrained_model_with_inputs
-from .hghub.model_inputs import random_input_kwargs
 
 
 def empty(value: Any) -> bool:
@@ -221,6 +221,7 @@ def validate_model(
     drop_inputs: Optional[List[str]] = None,
     ortfusiontype: Optional[str] = None,
     input_options: Optional[Dict[str, Any]] = None,
+    model_options: Optional[Dict[str, Any]] = None,
 ) -> Tuple[Dict[str, Union[int, float, str]], Dict[str, Any]]:
     """
     Validates a model.
@@ -251,6 +252,8 @@ def validate_model(
         see :func:`onnx_diagnostic.torch_models.test_helper.run_ort_fusion`
     :param input_options: additional options to define the dummy inputs
         used to export
+    :param model_options: additional options when creating the model such as
+        ``num_hidden_layers`` or ``attn_implementation``
     :return: two dictionaries, one with some metrics,
         another one with whatever the function produces
     """
@@ -289,10 +292,13 @@ def validate_model(
 
     if verbose:
         print(f"[validate_model] validate model id {model_id!r}")
+        if model_options:
+            print(f"[validate_model] model_options={model_options!r}")
         print(f"[validate_model] get dummy inputs with input_options={input_options}...")
         summary["model_id"] = model_id
 
     iop = input_options or {}
+    mop = model_options or {}
     data = _quiet_or_not_quiet(
         quiet,
         "create",
@@ -301,18 +307,28 @@ def validate_model(
         (
             lambda mid=model_id, v=verbose, task=task, tr=trained, iop=iop: (
                 get_untrained_model_with_inputs(
-                    mid, verbose=v, task=task, same_as_pretrained=tr, inputs_kwargs=iop
+                    mid,
+                    verbose=v,
+                    task=task,
+                    same_as_pretrained=tr,
+                    inputs_kwargs=iop,
+                    model_kwargs=mop,
                 )
             )
         ),
     )
-    data["input_options"] = input_options
+    data["input_options"] = iop
+    data["model_options"] = mop
+    if iop:
+        summary["input_options"] = str(iop)
+    if mop:
+        summary["model_options"] = str(mop)
     if "ERR_create" in summary:
         return summary, data
 
     if drop_inputs:
         if verbose:
-            print(f"[validate_model] -- drop inputs {drop_inputs!r}")
+            print(f"[validate_model] -- drop inputs: {drop_inputs!r}")
             print(f"[validate_model] current inputs: {string_type(data['inputs'])}")
             print(
                 f"[validate_model] current dynnamic_shapes: "
@@ -505,7 +521,9 @@ def validate_model(
         if verbose:
             print("[validate_model] done (dump)")
 
-    if not exporter or not exporter.startswith(("onnx-", "custom-")):
+    if not exporter or (
+        not exporter.startswith(("onnx-", "custom-")) and exporter != "custom"
+    ):
         if verbose:
             print("[validate_model] -- done (final)")
         if dump_stats:

{onnx_diagnostic-0.4.0.dist-info → onnx_diagnostic-0.4.2.dist-info}/METADATA

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