onnx-diagnostic 0.7.15__py3-none-any.whl → 0.7.16__py3-none-any.whl

onnx_diagnostic/torch_models/code_sample.py

@@ -0,0 +1,343 @@
+import os
+import textwrap
+import torch
+from typing import Any, Dict, List, Optional, Tuple, Union
+from ..helpers import flatten_object
+from ..helpers.torch_helper import to_any
+from .hghub.model_inputs import _preprocess_model_id
+from .hghub import get_untrained_model_with_inputs
+from .validate import filter_inputs, make_patch_kwargs
+
+
+CODE_SAMPLES = {
+    "imports": "from typing import Any\nimport torch",
+    "get_model_with_inputs": textwrap.dedent(
+        """
+    def get_model_with_inputs(
+        model_id:str,
+        subfolder: str | None = None,
+        dtype: str | torch.dtype | None = None,
+        device: str | torch.device | None = None,
+        same_as_pretrained: bool = False,
+        use_pretrained: bool = False,
+        input_options: dict[str, Any] | None = None,
+        model_options: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        if use_pretrained:
+            import transformers
+            assert same_as_pretrained, (
+                "same_as_pretrained must be True if use_pretrained is True"
+            )
+            # tokenizer = AutoTokenizer.from_pretrained(model_path)
+            model = transformers.AutoModel.from_pretrained(
+                model_id,
+                trust_remote_code=True,
+                subfolder=subfolder,
+                dtype=dtype,
+                device=device,
+            )
+            data = {"model": model}
+            assert not input_options, "Not implemented yet with input_options{input_options}"
+            assert not model_options, "Not implemented yet with input_options{model_options}"
+        else:
+            from onnx_diagnostic.torch_models.hghub import get_untrained_model_with_inputs
+            data = get_untrained_model_with_inputs(
+                model_id,
+                use_pretrained=use_pretrained,
+                same_as_pretrained=same_as_pretrained,
+                inputs_kwargs=input_options,
+                model_kwargs=model_options,
+                subfolder=subfolder,
+                add_second_input=False,
+            )
+            if dtype:
+                data["model"] = data["model"].to(
+                    getattr(torch, dtype) if isinstance(dtype, str) else dtype
+                )
+            if device:
+                data["model"] = data["model"].to(device)
+        return data["model"]
+    """
+    ),
+}
+
+
+def make_code_for_inputs(inputs: Dict[str, torch.Tensor]) -> str:
+    """
+    Creates a code to generate random inputs.
+
+    :param inputs: dictionary
+    :return: code
+    """
+    codes = []
+    for k, v in inputs.items():
+        if isinstance(v, (int, bool, float)):
+            code = f"{k}={v}"
+        elif isinstance(v, torch.Tensor):
+            shape = tuple(map(int, v.shape))
+            if v.dtype in (torch.int32, torch.int64):
+                code = f"{k}=torch.randint({v.max()}, size={shape}, dtype={v.dtype})"
+            elif v.dtype in (torch.float32, torch.float16, torch.bfloat16):
+                code = f"{k}=torch.rand({shape}, dtype={v.dtype})"
+            else:
+                raise ValueError(f"Unexpected dtype = {v.dtype} for k={k!r}")
+        elif v.__class__.__name__ == "DynamicCache":
+            obj = flatten_object(v)
+            cc = [f"torch.rand({tuple(map(int,_.shape))}, dtype={_.dtype})" for _ in obj]
+            va = [f"({a},{b})" for a, b in zip(cc[: len(cc) // 2], cc[len(cc) // 2 :])]
+            va2 = ", ".join(va)
+            code = f"{k}=make_dynamic_cache([{va2}])"
+        else:
+            raise ValueError(f"Unexpected type {type(v)} for k={k!r}")
+        codes.append(code)
+    st = ", ".join(codes)
+    return f"dict({st})"
+
+
+def make_export_code(
+    exporter: str,
+    optimization: Optional[str] = None,
+    patch_kwargs: Optional[Dict[str, Any]] = None,
+    stop_if_static: int = 0,
+    dump_folder: Optional[str] = None,
+    opset: Optional[int] = None,
+    dynamic_shapes: Optional[Dict[str, Any]] = None,
+    output_names: Optional[List[str]] = None,
+    verbose: int = 0,
+) -> Tuple[str, str]:
+    args = [f"dynamic_shapes={dynamic_shapes}"]
+    if output_names:
+        args.append(f"output_names={output_names}")
+    code = []
+    imports = []
+    if dump_folder:
+        code.append(f"os.makedirs({dump_folder!r})")
+        imports.append("import os")
+        filename = os.path.join(dump_folder, "model.onnx")
+    if exporter == "custom":
+        if opset:
+            args.append(f"target_opset={opset}")
+        if optimization:
+            args.append(f"options=OptimizationOptions(patterns={optimization!r})")
+            args.append(f"large_model=True, filename={filename!r}")
+        sargs = ", ".join(args)
+        imports.extend(
+            [
+                "from experimental_experiment.torch_interpreter import to_onnx",
+                "from experimental_experiment.xbuilder import OptimizationOptions",
+            ]
+        )
+        code.extend([f"onx = to_onnx(model, inputs, {sargs})"])
+    elif exporter == "onnx-dynamo":
+        if opset:
+            args.append(f"opset_version={opset}")
+        sargs = ", ".join(args)
+        code.extend([f"epo = torch.onnx.export(model, args=(), kwargs=inputs, {sargs})"])
+        if optimization:
+            imports.append("import onnxscript")
+            code.extend(["onnxscript.optimizer.optimize_ir(epo.model)"])
+            if "os_ort" in optimization:
+                imports.append("import onnxscript.rewriter.ort_fusions as ort_fusions")
+                code.extend(["ort_fusions.optimize_for_ort(epo.model)"])
+        if dump_folder:
+            code.extend([f"epo.save({filename!r})"])
+    else:
+        raise ValueError(f"Unexpected exporter {exporter!r}")
+    if not patch_kwargs:
+        return "\n".join(imports), "\n".join(code)
+
+    imports.append("from onnx_diagnostic.torch_export_patches import torch_export_patches")
+    if stop_if_static:
+        patch_kwargs["stop_if_static"] = stop_if_static
+    sargs = ", ".join(f"{k}={v}" for k, v in patch_kwargs.items())
+    code = [f"with torch_export_patches({sargs}):", *["    " + _ for _ in code]]
+    return "\n".join(imports), "\n".join(code)
+
+
+def code_sample(
+    model_id: str,
+    task: Optional[str] = None,
+    do_run: bool = False,
+    exporter: Optional[str] = None,
+    do_same: bool = False,
+    verbose: int = 0,
+    dtype: Optional[Union[str, torch.dtype]] = None,
+    device: Optional[Union[str, torch.device]] = None,
+    same_as_pretrained: bool = False,
+    use_pretrained: bool = False,
+    optimization: Optional[str] = None,
+    quiet: bool = False,
+    patch: Union[bool, str, Dict[str, bool]] = False,
+    rewrite: bool = False,
+    stop_if_static: int = 1,
+    dump_folder: Optional[str] = None,
+    drop_inputs: Optional[List[str]] = None,
+    input_options: Optional[Dict[str, Any]] = None,
+    model_options: Optional[Dict[str, Any]] = None,
+    subfolder: Optional[str] = None,
+    opset: Optional[int] = None,
+    runtime: str = "onnxruntime",
+    output_names: Optional[List[str]] = None,
+) -> str:
+    """
+    This generates a code to export a model with the proper settings.
+
+    :param model_id: model id to validate
+    :param task: task used to generate the necessary inputs,
+        can be left empty to use the default task for this model
+        if it can be determined
+    :param do_run: checks the model works with the defined inputs
+    :param exporter: exporter the model using this exporter,
+        available list: ``export-strict``, ``export-nostrict``, ...
+        see below
+    :param do_same: checks the discrepancies of the exported model
+    :param verbose: verbosity level
+    :param dtype: uses this dtype to check the model
+    :param device: do the verification on this device
+    :param same_as_pretrained: use a model equivalent to the trained,
+        this is not always possible
+    :param use_pretrained: use the trained model, not the untrained one
+    :param optimization: optimization to apply to the exported model,
+        depend on the the exporter
+    :param quiet: if quiet, catches exception if any issue
+    :param patch: applies patches (``patch_transformers=True, path_diffusers=True``)
+        if True before exporting
+        see :func:`onnx_diagnostic.torch_export_patches.torch_export_patches`,
+        a string can be used to specify only one of them
+    :param rewrite: applies known rewriting (``patch_transformers=True``) before exporting,
+        see :func:`onnx_diagnostic.torch_export_patches.torch_export_patches`
+    :param stop_if_static: stops if a dynamic dimension becomes static,
+        see :func:`onnx_diagnostic.torch_export_patches.torch_export_patches`
+    :param dump_folder: dumps everything in a subfolder of this one
+    :param drop_inputs: drops this list of inputs (given their names)
+    :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``
+    :param subfolder: version or subfolders to uses when retrieving a model id
+    :param opset: onnx opset to use for the conversion
+    :param runtime: onnx runtime to use to check about discrepancies,
+        possible values ``onnxruntime``, ``torch``, ``orteval``,
+        ``orteval10``, ``ref`` only if `do_run` is true
+    :param output_names: output names the onnx exporter should use
+    :return: a code
+
+    .. runpython::
+        :showcode:
+
+        from onnx_diagnostic.torch_models.code_sample import code_sample
+
+        print(
+            code_sample(
+                "arnir0/Tiny-LLM",
+                exporter="onnx-dynamo",
+                optimization="ir",
+                patch=True,
+            )
+        )
+    """
+    model_id, subfolder, same_as_pretrained, use_pretrained = _preprocess_model_id(
+        model_id,
+        subfolder,
+        same_as_pretrained=same_as_pretrained,
+        use_pretrained=use_pretrained,
+    )
+    patch_kwargs = make_patch_kwargs(patch=patch, rewrite=rewrite)
+
+    iop = input_options or {}
+    mop = model_options or {}
+    data = get_untrained_model_with_inputs(
+        model_id,
+        verbose=verbose,
+        task=task,
+        use_pretrained=use_pretrained,
+        same_as_pretrained=same_as_pretrained,
+        inputs_kwargs=iop,
+        model_kwargs=mop,
+        subfolder=subfolder,
+        add_second_input=False,
+    )
+    if drop_inputs:
+        update = {}
+        for k in data:
+            if k.startswith("inputs"):
+                update[k], ds = filter_inputs(
+                    data[k],
+                    drop_names=drop_inputs,
+                    model=data["model"],
+                    dynamic_shapes=data["dynamic_shapes"],
+                )
+        update["dynamic_shapes"] = ds
+        data.update(update)
+
+    update = {}
+    for k in data:
+        if k.startswith("inputs"):
+            v = data[k]
+            if dtype:
+                update[k] = v = to_any(
+                    v, getattr(torch, dtype) if isinstance(dtype, str) else dtype
+                )
+            if device:
+                update[k] = v = to_any(v, device)
+    if update:
+        data.update(update)
+
+    args = [f"{model_id!r}"]
+    if subfolder:
+        args.append(f"subfolder={subfolder!r}")
+    if dtype:
+        args.append(f"dtype={dtype!r}")
+    if device:
+        args.append(f"device={device!r}")
+    if same_as_pretrained:
+        args.append(f"same_as_pretrained={same_as_pretrained!r}")
+    if use_pretrained:
+        args.append(f"use_pretrained={use_pretrained!r}")
+    if input_options:
+        args.append(f"input_options={input_options!r}")
+    if model_options:
+        args.append(f"model_options={model_options!r}")
+    model_args = ", ".join(args)
+    imports, exporter_code = (
+        make_export_code(
+            exporter=exporter,
+            patch_kwargs=patch_kwargs,
+            verbose=verbose,
+            optimization=optimization,
+            stop_if_static=stop_if_static,
+            dump_folder=dump_folder,
+            opset=opset,
+            dynamic_shapes=data["dynamic_shapes"],
+        )
+        if exporter is not None
+        else ([], [])
+    )
+    input_code = make_code_for_inputs(data["inputs"])
+    cache_import = (
+        "from onnx_diagnostic.helpers.cache_helper import make_dynamic_cache"
+        if "dynamic_cache" in input_code
+        else ""
+    )
+
+    pieces = [
+        CODE_SAMPLES["imports"],
+        imports,
+        cache_import,
+        CODE_SAMPLES["get_model_with_inputs"],
+        textwrap.dedent(
+            f"""
+            model = get_model_with_inputs({model_args})
+                        """
+        ),
+        f"inputs = {input_code}",
+        exporter_code,
+    ]
+    code = "\n".join(pieces)  # type: ignore[arg-type]
+    try:
+        import black
+    except ImportError:
+        # No black formatting.
+        return code
+
+    return black.format_str(code, mode=black.Mode())

onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py

@@ -4865,3 +4865,41 @@ def _ccached_google_gemma_3_4b_it_like():
             },
         }
     )
+
+
+def _ccached_hf_internal_testing_tiny_random_gemma3_for_causal_lm():
+    "hf-internal-testing/tiny-random-Gemma3ForCausalLM"
+    return transformers.Gemma3TextConfig(
+        **{
+            "architectures": ["Gemma3ForCausalLM"],
+            "attention_bias": false,
+            "attention_dropout": 0.0,
+            "attn_logit_softcapping": null,
+            "bos_token_id": 2,
+            "cache_implementation": "hybrid",
+            "eos_token_id": [1, 106],
+            "final_logit_softcapping": null,
+            "head_dim": 8,
+            "hidden_activation": "gelu_pytorch_tanh",
+            "hidden_size": 16,
+            "initializer_range": 0.02,
+            "intermediate_size": 32,
+            "max_position_embeddings": 32768,
+            "model_type": "gemma3_text",
+            "num_attention_heads": 2,
+            "num_hidden_layers": 2,
+            "num_key_value_heads": 1,
+            "pad_token_id": 0,
+            "query_pre_attn_scalar": 256,
+            "rms_norm_eps": 1e-06,
+            "rope_local_base_freq": 10000,
+            "rope_scaling": null,
+            "rope_theta": 1000000,
+            "sliding_window": 512,
+            "sliding_window_pattern": 6,
+            "torch_dtype": "float32",
+            "transformers_version": "4.52.0.dev0",
+            "use_cache": true,
+            "vocab_size": 262144,
+        }
+    )

onnx_diagnostic/torch_models/validate.py

@@ -123,8 +123,8 @@ def _make_folder_name(
     els = [model_id.replace("/", "_")]
     if subfolder:
         els.append(subfolder.replace("/", "_"))
-    if not task:
-        els.append(task)  # type: ignore[arg-type]
+    if task:
+        els.append(task)
     if drop_inputs:
         ii = "-".join(f"{s[0]}{s[-1]}" for s in drop_inputs)
         els.append(f"I-{ii.upper()}")
@@ -293,6 +293,33 @@ def shrink_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
     return new_cfg
 
 
+def make_patch_kwargs(
+    patch: Union[bool, str, Dict[str, bool]] = False,
+    rewrite: bool = False,
+) -> Dict[str, Any]:
+    """Creates patch arguments."""
+    default_patch = dict(patch_transformers=True, patch_diffusers=True, patch=True)
+    if isinstance(patch, bool):
+        patch_kwargs = default_patch if patch else dict(patch=False)
+    elif isinstance(patch, str):
+        patch_kwargs = {"patch": True, **{p: True for p in patch.split(",")}}  # noqa: C420
+    else:
+        assert isinstance(patch, dict), f"Unable to interpret patch={patch!r}"
+        patch_kwargs = patch.copy()
+        if "patch" not in patch_kwargs:
+            if any(patch_kwargs.values()):
+                patch_kwargs["patch"] = True
+        elif len(patch) == 1 and patch.get("patch", False):
+            patch_kwargs.update(default_patch)
+
+    assert not rewrite or patch_kwargs.get("patch", False), (
+        f"rewrite={rewrite}, patch={patch}, patch_kwargs={patch_kwargs} "
+        f"patch must be True to enable rewriting, "
+        f"if --patch=0 was specified on the command line, rewrites are disabled."
+    )
+    return patch_kwargs
+
+
 def validate_model(
     model_id: str,
     task: Optional[str] = None,
@@ -420,25 +447,8 @@ def validate_model(
         use_pretrained=use_pretrained,
     )
     time_preprocess_model_id = time.perf_counter() - main_validation_begin
-    default_patch = dict(patch_transformers=True, patch_diffusers=True, patch=True)
-    if isinstance(patch, bool):
-        patch_kwargs = default_patch if patch else dict(patch=False)
-    elif isinstance(patch, str):
-        patch_kwargs = {"patch": True, **{p: True for p in patch.split(",")}}  # noqa: C420
-    else:
-        assert isinstance(patch, dict), f"Unable to interpret patch={patch!r}"
-        patch_kwargs = patch.copy()
-        if "patch" not in patch_kwargs:
-            if any(patch_kwargs.values()):
-                patch_kwargs["patch"] = True
-        elif len(patch) == 1 and patch.get("patch", False):
-            patch_kwargs.update(default_patch)
+    patch_kwargs = make_patch_kwargs(patch=patch, rewrite=rewrite)
 
-    assert not rewrite or patch_kwargs.get("patch", False), (
-        f"rewrite={rewrite}, patch={patch}, patch_kwargs={patch_kwargs} "
-        f"patch must be True to enable rewriting, "
-        f"if --patch=0 was specified on the command line, rewrites are disabled."
-    )
     summary = version_summary()
     summary.update(
         dict(
@@ -1890,6 +1900,7 @@ def call_torch_export_custom(
         "custom-nostrict-all-noinline",
         "custom-dec",
         "custom-decall",
+        "custom-fake",
     }
     assert exporter in available, f"Unexpected value for exporter={exporter!r} in {available}"
     assert "model" in data, f"model is missing from data: {sorted(data)}"
@@ -1898,6 +1909,14 @@ def call_torch_export_custom(
     strict = "-strict" in exporter
     args, kwargs = split_args_kwargs(data["inputs_export"])
     ds = data.get("dynamic_shapes", None)
+    if "-fake" in exporter:
+        from onnx_diagnostic.export.shape_helper import make_fake_with_dynamic_dimensions
+
+        if verbose:
+            print("[call_torch_export_custom] switching to FakeTensor")
+        assert not args, f"Exporter {exporter!r} not implemented with fake tensors."
+        kwargs = torch_deepcopy(kwargs)
+        kwargs, _ = make_fake_with_dynamic_dimensions(kwargs, dynamic_shapes=ds)
     opset = data.get("model_opset", None)
     if opset:
         summary["export_opset"] = opset

{onnx_diagnostic-0.7.15.dist-info → onnx_diagnostic-0.7.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.7.15
+Version: 0.7.16
 Summary: Tools to help converting pytorch models into ONNX.
 Home-page: https://github.com/sdpython/onnx-diagnostic
 Author: Xavier Dupré
@@ -60,9 +60,9 @@ You need then to remove those which are not dynamic in your model.
 
 .. code-block:: python
 
-  from onnx_diagnostic.export.shape_helper import all_dynamic_shape_from_inputs
+  from onnx_diagnostic.export.shape_helper import all_dynamic_shapes_from_inputs
 
-  dynamic_shapes = all_dynamic_shape_from_inputs(cache)
+  dynamic_shapes = all_dynamic_shapes_from_inputs(cache)
 
 It also implements tools to investigate, validate exported models (ExportedProgramm, ONNXProgram, ...).
 See `documentation of onnx-diagnostic <https://sdpython.github.io/doc/onnx-diagnostic/dev/>`_ and
@@ -126,13 +126,13 @@ Snapshot of usefuls tools
       ep = torch.export.export(model, args, kwargs=kwargs, dynamic_shapes=dynamic_shapes)
       # ...
 
-**all_dynamic_shape_from_inputs**
+**all_dynamic_shapes_from_inputs**
 
 .. code-block:: python
 
-  from onnx_diagnostic.export.shape_helper import all_dynamic_shape_from_inputs
+  from onnx_diagnostic.export.shape_helper import all_dynamic_shapes_from_inputs
 
-  dynamic_shapes = all_dynamic_shape_from_inputs(cache)
+  dynamic_shapes = all_dynamic_shapes_from_inputs(cache)
 
 **torch_export_rewrite**
 

{onnx_diagnostic-0.7.15.dist-info → onnx_diagnostic-0.7.16.dist-info}/RECORD

@@ -1,22 +1,23 @@
-onnx_diagnostic/__init__.py,sha256=rsSRl1QPe3XLEW8cPAdFVV6eLYgcRFg37pNNVTw5FAc,174
+onnx_diagnostic/__init__.py,sha256=eanCPlr_TSrwLKPl2uQn0CJzW015D7ORk2T08gXZg2o,174
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
-onnx_diagnostic/_command_lines_parser.py,sha256=bl6lorcodFk14dm2lgeCjr4OkRziUrKXn3GGkbxIuVA,33987
+onnx_diagnostic/_command_lines_parser.py,sha256=WjnVLqxMQ1sOo18dU4C-2nEZ40vkCy4MnlGBJAEuUOk,38173
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
 onnx_diagnostic/doc.py,sha256=t3RELgfooYnVMAi0JSpggWkQEgUsREz8NmRvn0TnLI8,2829
-onnx_diagnostic/ext_test_case.py,sha256=emfQGiQSz5FVDhyJ1Acsv_Tast7tWl426TjtpNqxDBU,43558
+onnx_diagnostic/ext_test_case.py,sha256=f0bVfN0vqeeQy1mSb4YOThvJA5sCH3e0h9-u5x9hmrs,43620
 onnx_diagnostic/export/__init__.py,sha256=yEIoWiOeTwBsDhyYt2fTKuhtA0Ya1J9u9ZzMTOTWaWs,101
-onnx_diagnostic/export/dynamic_shapes.py,sha256=80yvtxYNsRCplUNiyL7acb9qhl4-HXIes8C62yuQ8JE,41976
-onnx_diagnostic/export/shape_helper.py,sha256=PI_SgE1MNRKSrQ414eYoBZ54QGZbYisHSvqi9tstL2s,7795
+onnx_diagnostic/export/dynamic_shapes.py,sha256=dvpIafK-DgalLMhVudmJkgn316UVerAyMMnvwQCNK5g,42004
+onnx_diagnostic/export/shape_helper.py,sha256=Qr5pZeVuRahYza5hRAVDGkhshArysdJ1UhNJ603UI9w,12632
 onnx_diagnostic/export/validate.py,sha256=_PGUql2DJhIgGKo0WjTGUc5AgsZUx8fEs00MePy-w98,6043
 onnx_diagnostic/helpers/__init__.py,sha256=GJ2GT7cgnlIveVUwMZhuvUwidbTJaKv8CsSIOpZDsJg,83
 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=4fkPKLG590l1Gbqaw_QubXeJqY17X2Z6CBmLp23-BYI,24849
+onnx_diagnostic/helpers/cache_helper.py,sha256=pvtx__UCBi367p6pD_-juIUgIyzEC_zfgmsYZdKzXSk,25899
 onnx_diagnostic/helpers/config_helper.py,sha256=cWRETgFhZ7tayIZPnMqF8BF5AvTU64G2BMqyzgO7lzs,5670
 onnx_diagnostic/helpers/doc_helper.py,sha256=pl5MZd3_FaE8BqQnqoBuSBxoNCFcd2OJd3eITUSku5c,5897
+onnx_diagnostic/helpers/fake_tensor_helper.py,sha256=5KDX_bWbrenyYpBQUk7MNkpu28apn-qnshavmf22Uh8,5353
 onnx_diagnostic/helpers/graph_helper.py,sha256=hevQT5a7_QuriVPQcbT5qe18n99Doyl5h3-qshx1-uk,14093
-onnx_diagnostic/helpers/helper.py,sha256=zl7vG6G4ueq931Z9iT8OlKfmtFxvRJD2WJQh_qsMiBs,63401
+onnx_diagnostic/helpers/helper.py,sha256=ut8upptmarQp2bVivnFmOTokMKslTRC6u0qooTNvSPA,63477
 onnx_diagnostic/helpers/log_helper.py,sha256=xBKz5rj2-jEtN_tFKsOV4RpBGermrv7CWqG3KUm2psI,87335
 onnx_diagnostic/helpers/memory_peak.py,sha256=OT6mz0muBbBZY0pjgW2_eCk_lOtFRo-5w4jFo2Z6Kok,6380
 onnx_diagnostic/helpers/mini_onnx_builder.py,sha256=Cgx1ojmV0S_JpZ_UqwsNxeULMMDvMInXslhkE34fwec,22051
@@ -77,7 +78,7 @@ onnx_diagnostic/tasks/automatic_speech_recognition.py,sha256=umZmjGW1gDUFkqvBJnQ
 onnx_diagnostic/tasks/feature_extraction.py,sha256=Zh9p_Q8FqEO2_aqI0cCiq8OXuM3WUZbwItlLOmLnNl8,5537
 onnx_diagnostic/tasks/fill_mask.py,sha256=5Gt6zlj0p6vuifox7Wmj-TpHXJvPS0CEH8evgdBHDNA,2640
 onnx_diagnostic/tasks/image_classification.py,sha256=nLpBBB1Gkog3Fk6pu2waiHcuQr4ILPptc9FhQ-pn460,4682
-onnx_diagnostic/tasks/image_text_to_text.py,sha256=HDXuk1bEE3qTR0mUR_6rw-5RAXSyUvGY-dMNamIpvn0,21577
+onnx_diagnostic/tasks/image_text_to_text.py,sha256=OdgyoT8FEZi-0HpWhFHWa8ySP9s_Tf3YsW46sbHPd-I,21576
 onnx_diagnostic/tasks/image_to_video.py,sha256=SoF2cVIJr6P30Abp-FCuixFDh5RvTuNEOL36QthGY6U,3860
 onnx_diagnostic/tasks/mask_generation.py,sha256=fjdD3rd-O-mFL0hQy3la3JXKth_0bH2HL7Eelq-3Dbs,5057
 onnx_diagnostic/tasks/mixture_of_expert.py,sha256=al4tk1BrHidtRiHlAaiflWiJaAte0d5M8WcBioANG9k,2808
@@ -86,13 +87,13 @@ onnx_diagnostic/tasks/sentence_similarity.py,sha256=vPqNZgAnIvY0rKWPUTs0IlU3RFQD
 onnx_diagnostic/tasks/summarization.py,sha256=8vB_JiRzDEacIvr8CYTuVQTH73xG_jNkndoS9RHJTSs,8292
 onnx_diagnostic/tasks/text2text_generation.py,sha256=35eF_RlSeMdLTZPooLMAnszs-z0bkKZ34Iej3JgA96A,8602
 onnx_diagnostic/tasks/text_classification.py,sha256=CGc72SpXFzTUyzAHEMPgyy_s187DaYGsRdrosxG80_Q,2711
-onnx_diagnostic/tasks/text_generation.py,sha256=FwpmI4c_cO9uYQwJFfsHRMArPdwaeU5TBan2lisoHZk,14205
+onnx_diagnostic/tasks/text_generation.py,sha256=BVt8cBStUa-dwTdVwlIMUuxsz6NQTQU1a3i6CjyWl8A,14116
 onnx_diagnostic/tasks/text_to_image.py,sha256=mOS3Ruosi3hzRMxXLDN7ZkAbi7NnQb7MWwQP_okGVHs,2962
 onnx_diagnostic/tasks/zero_shot_image_classification.py,sha256=jJCMWuOqGv5ahCfjrcqxuYCJFhTgHV5KUf2yyv2yxYA,4624
 onnx_diagnostic/tasks/data/__init__.py,sha256=uJoemrWgEjI6oA-tMX7r3__x-b3siPmkgqaY7bgIles,401
 onnx_diagnostic/tasks/data/dummies_imagetext2text_generation_gemma3.onnx,sha256=UbtvmWMqcZOKJ-I-HXWI1A6YR6QDaFS5u_yXm5C3ZBw,10299
 onnx_diagnostic/torch_export_patches/__init__.py,sha256=0SaZedwznm1hQUCvXZsGZORV5vby954wEExr5faepGg,720
-onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=T2FaIBSU3NfUyt54whwBmRHPuAzmZKFVHuwu-mikNz4,30475
+onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=WgoyNI9ueqDGNmkcIotCXLJFHKjSdoPywEym0m9X2KA,33206
 onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=K78uX5EHTuu0ah3mkZWNcGow4775GKH-EnDs3ZlIEhE,11778
 onnx_diagnostic/torch_export_patches/patch_expressions.py,sha256=vr4tt61cbDnaaaduzMj4UBZ8OUtr6GfDpIWwOYqjWzs,3213
 onnx_diagnostic/torch_export_patches/patch_inputs.py,sha256=2HQZKQV6TM5430RIvKiMPe4cfGvFdx1UnP1w76CeGE4,8110
@@ -101,18 +102,19 @@ onnx_diagnostic/torch_export_patches/patch_module_helper.py,sha256=2U0AdyZuU0W54
 onnx_diagnostic/torch_export_patches/eval/__init__.py,sha256=YQoOGt9XQLWqnJ15NnT7ri_jDevfvpuQwEJo38E-VRU,25056
 onnx_diagnostic/torch_export_patches/eval/model_cases.py,sha256=joDJV1YfrhYBR_6eXYvNO1jbiJM8Whb47NWZxo8SBwg,27172
 onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=QIm3GabPnoJDIM1HJl0reyUKf7fg7h57TsHkWfDWjF4,41408
-onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=aVYEhrn48YUGn0rim5o2oygWFkwm3-HsGRpS1rGySeQ,81496
+onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=p6JOcDX1zXdYoTThqZP7oeKr67nJ1ZJJcvWobz9RjI4,44435
+onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=D6fE427n68j-YjvPyvU9obumDPgyIK7AWRkOukraEdM,83525
 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=mcmZGekzQlLgE_o3SdKlRgCx4ewwyyAuNWZ9CaN_zrI,9317
 onnx_diagnostic/torch_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onnx_diagnostic/torch_models/code_sample.py,sha256=PWf7piGx7Eiv7BOTpL2bLUtWwaVcw7SMBvkSpEzZDPs,12883
 onnx_diagnostic/torch_models/llms.py,sha256=soyg4yC87ptGoeulJhKqw5opGmuLvH1pn_ZDXZ4Jr8E,90
-onnx_diagnostic/torch_models/validate.py,sha256=0KL1vQmB9DTFuJqc8_CyddIztuwFx9qpRRPULHd-C04,80434
+onnx_diagnostic/torch_models/validate.py,sha256=ErpdXa8Gh9NAUsUsaf5JcvQVscBa3ZUkQ82PEZSawRc,81098
 onnx_diagnostic/torch_models/hghub/__init__.py,sha256=vi1Q7YHdddj1soiBN42MSvJdFqe2_KUoWafHISjwOu8,58
 onnx_diagnostic/torch_models/hghub/hub_api.py,sha256=rFbiPNLET-KdBpnv-p0nKgwHX6d7C_Z0s9zZ86_92kQ,14307
 onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=8V_pAgACPLPsLRYUododg7MSL6str-T3tBEGY4OaeYQ,8724
-onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=aSa_7Rjider6ruqQ2-fXQMyyDS8VhB1xKxcPNk8qUeU,288776
+onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=VdLMPQ_ZpPg6cGMy00R2bGjSLWhvjkx8awY7kFD03I8,290141
 onnx_diagnostic/torch_models/hghub/model_inputs.py,sha256=xIY_CWOp3m5-cJUvDLTZiH9GwiXi6xTYwONgFY4o45g,15593
 onnx_diagnostic/torch_models/hghub/model_specific.py,sha256=j50Nu7wddJMoqmD4QzMbNdFDUUgUmSBKRzPDH55TlUQ,2498
 onnx_diagnostic/torch_models/untrained/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -121,8 +123,8 @@ onnx_diagnostic/torch_models/untrained/llm_tiny_llm.py,sha256=QXw_Bs2SzfeiQMf-tm
 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=IoKLA5UwS6kY8g4OOf_bdQwCziIsQfBczZ3w8wo4wZM,16905
-onnx_diagnostic-0.7.15.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.7.15.dist-info/METADATA,sha256=8PCb8jeG1AwC10iaBQRqNBE_JF7huNn2o-l_7BnwzzE,6730
-onnx_diagnostic-0.7.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_diagnostic-0.7.15.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.7.15.dist-info/RECORD,,
+onnx_diagnostic-0.7.16.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.7.16.dist-info/METADATA,sha256=k9xWoY46lqN9fhGpujHDnGFZ4WB3kpSc8XHtWZ63sNg,6735
+onnx_diagnostic-0.7.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.7.16.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.7.16.dist-info/RECORD,,