onnx-diagnostic 0.8.7__py3-none-any.whl → 0.8.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.8.7"
+__version__ = "0.8.8"
 __author__ = "Xavier Dupré"

onnx_diagnostic/ci_models/export_phi4_mm.py

@@ -973,7 +973,7 @@ def main(
                     kwargs=export_inputs,
                     dynamic_shapes=use_dyn_not_str(dynamic_shapes),
                 )
-                patches = details.patches_involded_in_graph(ep.graph)
+                patches = details.patches_involved_in_graph(ep.graph)
                 report = details.make_report(patches, format="rst")
                 with open(f"{basename}.patches_details.rst", "w") as f:
                     f.write(report)

onnx_diagnostic/export/api.py

@@ -1,6 +1,11 @@
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+import inspect
+import os
+import textwrap
+from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Union
 import torch
+from .dynamic_shapes import ModelInputs
 from .onnx_plug import EagerDirectReplacementWithOnnx
+from ..helpers import string_type
 
 
 def get_main_dispatcher(
@@ -70,6 +75,7 @@ def to_onnx(
     inline: bool = True,
 ) -> Any:
     """
+    Exports one model into ONNX.
     Common API for exporters. By default, the models are optimized to use the
     most efficient kernels implemented in :epkg:`onnxruntime`.
 
@@ -126,8 +132,12 @@ def to_onnx(
         from experimental_experiment.xbuilder import OptimizationOptions
 
         options = None
+        export_options = None
         if exporter_kwargs is not None:
             options = exporter_kwargs.pop("options", None)
+            export_options = exporter_kwargs.pop("export_options", None)
+        if export_options is None:
+            export_options = ExportOptions(save_ep=save_ep)
         if options is None and optimize:
             options = OptimizationOptions(
                 patterns="default+onnxruntime" if optimizer_for_ort else "default"
@@ -138,7 +148,7 @@ def to_onnx(
             else None
         )
 
-        return _to_onnx(
+        proto, opt_stats = _to_onnx(
             mod,
             args=args,
             kwargs=kwargs,
@@ -150,16 +160,52 @@ def to_onnx(
             dynamic_shapes=dynamic_shapes,
             large_model=True,
             output_dynamic_shapes=output_dynamic_shapes,
-            export_options=ExportOptions(save_ep=save_ep),
+            export_options=export_options,
             options=options,
             inline=inline,
             dispatcher=main_dispatcher,
             optimize=optimize,
+            return_optimize_report=True,
             **(exporter_kwargs or {}),
         )
+        if opt_stats and filename and os.path.exists(filename):
+            import pandas
+
+            stat_filename = f"{os.path.splitext(filename)[0]}.opt.xlsx"
+            pattern_stats = []
+            for k, v in opt_stats.items():
+                if "time" in k:
+                    pattern_stats.append(dict(level="main", pattern=k, time_in=v))
+            pattern_stats.extend(
+                [{**obs, "level": "detailed"} for obs in opt_stats["optimization"]]
+            )
+            df = pandas.DataFrame(pattern_stats)
+            df.to_excel(stat_filename, index=False)
+            cols = [
+                c
+                for c in [
+                    "level",
+                    "pattern",
+                    "time_in",
+                    "iteration",
+                    "inlined",
+                    "removed",
+                    "added",
+                    "instances",
+                    "changed",
+                    "scale",
+                ]
+                if c in df.columns
+            ]
+            agg = {k: "sum" for k in cols if k not in ("level", "pattern")}
+            agg.update(dict(iteration="max", instances="mean"))
+            agg = {k: v for k, v in agg.items() if k in df.columns}
+            stat_filename = f"{os.path.splitext(filename)[0]}.opt.agg.xlsx"
+            df[cols].groupby(["level", "pattern"]).agg(agg).to_excel(stat_filename)
+
+        return proto
 
     if exporter in ("dynamo", "onnx-dynamo"):
-        import os
         from ..helpers import flatten_object
         import onnxscript.rewriter.ort_fusions as ort_fusions
 
@@ -226,7 +272,6 @@ def to_onnx(
         return epo
 
     if exporter == "modelbuilder":
-        import os
         from ..helpers import flatten_object, string_type
         from ..helpers.model_builder_helper import create_model_builder, save_model_builder
 
@@ -267,3 +312,247 @@ def to_onnx(
         return onx
 
     raise ValueError(f"Unknown exporter={exporter!r}")
+
+
+class _WrapperToExportMethodToOnnx(torch.nn.Module):
+    """
+    Wraps an existing models in order to spy on inputs.
+    This is used by :func:`onnx_diagnostic.export.api.method_to_onnx`.
+    """
+
+    def __init__(
+        self,
+        mod: "torch.nn.Module",
+        method_name: str = "forward",
+        input_names: Optional[Sequence[str]] = None,
+        target_opset: Optional[Union[int, Dict[str, int]]] = None,
+        verbose: int = 0,
+        filename: Optional[str] = None,
+        output_names: Optional[List[str]] = None,
+        output_dynamic_shapes: Optional[Union[Dict[str, Any], Tuple[Any]]] = None,
+        exporter: str = "onnx-dynamo",
+        exporter_kwargs: Optional[Dict[str, Any]] = None,
+        save_ep: Optional[str] = None,
+        optimize: bool = True,
+        optimizer_for_ort: bool = True,
+        use_control_flow_dispatcher: bool = False,
+        onnx_plugs: Optional[List[EagerDirectReplacementWithOnnx]] = None,
+        inline: bool = True,
+        convert_after_n_calls: int = 2,
+        patch_kwargs: Optional[Dict[str, Any]] = None,
+        skip_kwargs_names: Optional[Set[str]] = None,
+        dynamic_shapes: Optional[Union[Dict[str, Any], Tuple[Any]]] = None,
+    ):
+        super().__init__()
+        self._model_to_call = mod
+        self._method_name = method_name
+        self._method_call = (
+            self._model_to_call.forward
+            if method_name == "forward"
+            else getattr(mod, method_name)
+        )
+        self._inputs: List[Tuple[Tuple[Any, ...], Dict[str, Any]]] = []
+        self._convert_after_n_calls = convert_after_n_calls
+        self._patch_kwargs = patch_kwargs
+        self._method_src = None
+        self.verbose = verbose
+        self.skip_kwargs_names = skip_kwargs_names
+        self.dynamic_shapes = dynamic_shapes
+        self._to_onnx_kwargs = dict(
+            input_names=input_names,
+            target_opset=target_opset,
+            verbose=verbose,
+            filename=filename,
+            output_names=output_names,
+            output_dynamic_shapes=output_dynamic_shapes,
+            exporter=exporter,
+            exporter_kwargs=exporter_kwargs,
+            save_ep=save_ep,
+            optimize=optimize,
+            optimizer_for_ort=optimizer_for_ort,
+            use_control_flow_dispatcher=use_control_flow_dispatcher,
+            onnx_plugs=onnx_plugs,
+            inline=inline,
+        )
+        self._export_done = False
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}({self._model_to_call.__class__.__name__}."
+            f"{self._method_name})"
+        )
+
+    def forward(self, *args, **kwargs):
+        if not self._export_done:
+            self._inputs.append(
+                (
+                    args,
+                    (
+                        kwargs
+                        if not kwargs or not self.skip_kwargs_names
+                        else {
+                            k: v for k, v in kwargs.items() if k not in self.skip_kwargs_names
+                        }
+                    ),
+                )
+            )
+            if self.verbose:
+                print(
+                    f"[method_to_onnx] input[{len(self._inputs)-1}]: "
+                    f"{string_type(self._inputs[-1], with_shape=True)}"
+                )
+            if len(self._inputs) >= self._convert_after_n_calls:
+                self._convert_method_to_onnx()
+                del self._inputs[:]
+                self._export_done = True
+        return self._method_call(*args, **kwargs)
+
+    def _convert_method_to_onnx(self):
+
+        def make_method(self):
+            inner_sig = inspect.signature(self._method_call)
+            params = [
+                p.replace(annotation=inspect._empty) for p in inner_sig.parameters.values()
+            ]
+            simple_sig = inspect.Signature(params, return_annotation=inspect._empty)
+            args = str(simple_sig)[1:-1]
+            calls_args = ", ".join(f"{p}={p}" for p in simple_sig.parameters)
+            src = textwrap.dedent(
+                f"""
+                def f(self, {args}):
+                    return self._method_call({calls_args})
+                """
+            )
+            self._method_src = src
+            ns = {}
+            try:
+                exec(src, ns)
+            except NameError as e:
+                raise NameError(f"Unable to compile due to {e}\n{src}") from e
+            return ns["f"]
+
+        class WrapWithExactSignature(torch.nn.Module):
+            def __init__(self, parent):
+                super().__init__()
+                self._model_to_call = parent._model_to_call
+                self._method_call = parent._method_call
+
+            forward = make_method(self)
+
+        compiled_model = WrapWithExactSignature(self)
+
+        if self.dynamic_shapes is None:
+            mi = ModelInputs(compiled_model, self._inputs)
+            ds = mi.guess_dynamic_shapes()
+            if self.verbose:
+                print(f"[method_to_onnx] guess_dynamic_shapes={string_type(ds)}")
+            a, kw, nds = mi.move_to_kwargs(*self._inputs[-1], ds)
+        else:
+            a, kw = self._inputs[-1]
+            nds = [self.dynamic_shapes]
+        if self.verbose:
+            print(f"[method_to_onnx] export args={string_type(a, with_shape=True)}")
+            print(f"[method_to_onnx] export kwargs={string_type(kw, with_shape=True)}")
+            print(f"[method_to_onnx] dynamic_shapes={string_type(nds)}")
+        if self._patch_kwargs is None:
+            to_onnx(
+                compiled_model,
+                args=a,
+                kwargs=kw,
+                dynamic_shapes=nds[-1],
+                **self._to_onnx_kwargs,
+            )
+            return
+        from ..torch_export_patches import torch_export_patches
+
+        with torch_export_patches(**self._patch_kwargs):
+            to_onnx(
+                compiled_model,
+                args=a,
+                kwargs=kw,
+                dynamic_shapes=nds[-1],
+                **self._to_onnx_kwargs,
+            )
+
+
+def method_to_onnx(
+    mod: "torch.nn.Module",
+    method_name: str = "forward",
+    input_names: Optional[Sequence[str]] = None,
+    target_opset: Optional[Union[int, Dict[str, int]]] = None,
+    verbose: int = 0,
+    filename: Optional[str] = None,
+    output_names: Optional[List[str]] = None,
+    output_dynamic_shapes: Optional[Union[Dict[str, Any], Tuple[Any]]] = None,
+    exporter: str = "onnx-dynamo",
+    exporter_kwargs: Optional[Dict[str, Any]] = None,
+    save_ep: Optional[str] = None,
+    optimize: bool = True,
+    optimizer_for_ort: bool = True,
+    use_control_flow_dispatcher: bool = False,
+    onnx_plugs: Optional[List[EagerDirectReplacementWithOnnx]] = None,
+    inline: bool = True,
+    convert_after_n_calls: int = 2,
+    patch_kwargs: Optional[Dict[str, Any]] = None,
+    skip_kwargs_names: Optional[Set[str]] = None,
+    dynamic_shapes: Optional[Union[Dict[str, Any], Tuple[Any]]] = None,
+) -> Callable:
+    """
+    Exports one method into ONNX for a module into ONNX.
+    It returns a new method which must be called by the user
+    at least twice with different values for the dynamic dimension
+    between triggering the conversion into ONNX.
+
+    :param mod_meth: function to export into ONNX
+    :param input_names: input names for the onnx model (optional)
+    :param target_opset: opset to target, if not specified, each converter
+        keeps its default value
+    :param verbose: verbosity level
+    :param filename: output filename, mandatory, the onnx model is saved on disk
+    :param output_names: to change the output of the onnx model
+    :param output_dynamic_shapes: to overwrite the dynamic shapes names
+    :param exporter: exporter to use (``onnx-dynamo``, ``modelbuilder``, ``custom``)
+    :param exporter_kwargs: additional parameters sent to the exporter
+    :param save_ep: saves the exported program
+    :param optimize: optimizes the model
+    :param optimizer_for_ort: optimizes the model for onnxruntime
+    :param use_control_flow_dispatcher: use the dispatcher created to supported
+        custom loops (see :func:`onnx_diagnostic.export.control_flow_onnx.loop_for_onnx`)
+    :param onnx_plugs: the code was modified to replace some parts with onnx translation
+    :param inline: inline local functions
+    :param convert_after_n_calls: converts the model after this number of calls.
+    :param patch_kwargs: patch arguments
+    :param skip_kwargs_names: use default values for these parameters part of
+        the signature of the method to export
+    :param dynamic_shapes: dynamic shapes to use if the guessed ones are not right
+    :return: the output of the selected exporter, usually a structure including
+        an onnx model
+
+    See :ref:`l-plot-tiny-llm-export-method-generate` for an example.
+    """
+    wrapped_model = _WrapperToExportMethodToOnnx(
+        mod=mod,
+        method_name=method_name,
+        input_names=input_names,
+        target_opset=target_opset,
+        verbose=verbose,
+        filename=filename,
+        output_names=output_names,
+        output_dynamic_shapes=output_dynamic_shapes,
+        exporter=exporter,
+        exporter_kwargs=exporter_kwargs,
+        save_ep=save_ep,
+        optimize=optimize,
+        optimizer_for_ort=optimizer_for_ort,
+        use_control_flow_dispatcher=use_control_flow_dispatcher,
+        onnx_plugs=onnx_plugs,
+        inline=inline,
+        convert_after_n_calls=convert_after_n_calls,
+        patch_kwargs=patch_kwargs,
+        skip_kwargs_names=skip_kwargs_names,
+        dynamic_shapes=dynamic_shapes,
+    )
+    return wrapped_model

onnx_diagnostic/export/dynamic_shapes.py

@@ -352,6 +352,19 @@ class CoupleInputsDynamicShapes:
                     else None
                 )
             assert type(inputs) is dict, f"Unexpected type for inputs {type(inputs)}"
+            if set(inputs) != set(ds):
+                not_in_ds = {k for k in inputs if k not in ds}
+                not_in_inputs = {k for k in ds if k not in inputs}
+                assert not_in_inputs == {"kwargs"} and set(ds["kwargs"]) == not_in_ds, (
+                    f"Keys mismatch between inputs {set(inputs)} and ds={set(ds)}, "
+                    f"inputs={string_type(inputs, with_shape=True)}, ds={ds}, "
+                    f"not_in_ds={not_in_ds}, not_in_inputs={not_in_inputs}"
+                )
+                # Tweak...
+                kws = ds["kwargs"]
+                del ds["kwargs"]
+                ds.update(kws)
+
             assert set(inputs) == set(ds), (
                 f"Keys mismatch between inputs {set(inputs)} and ds={set(ds)}, "
                 f"inputs={string_type(inputs, with_shape=True)}, ds={ds}"
@@ -366,13 +379,15 @@ class CoupleInputsDynamicShapes:
             return dvalue if dvalue else None
 
         # A custom class.
-        assert inputs.__class__ in torch.utils._pytree.SUPPORTED_NODES, (
+        assert inputs is None or inputs.__class__ in torch.utils._pytree.SUPPORTED_NODES, (
             f"Class {inputs.__class__.__name__!r} was not registered using "
             f"torch.utils._pytree.register_pytree_node, it is not possible to "
             f"map this class with the given dynamic shapes."
         )
         if flatten_unflatten:
             flatunflat = flatten_unflatten_for_dynamic_shapes(inputs)
+            if isinstance(flatunflat, (list, tuple, dict)) and len(flatunflat) == 0:
+                return flatunflat
             res = cls._generic_walker_step(
                 processor, flatunflat, ds, flatten_unflatten=flatten_unflatten
             )
@@ -667,6 +682,11 @@ class ModelInputs:
             if self.signature
             else None
         )
+        self.forward_parameters_kinds = (
+            {p.name: p.kind for p in self.signature.parameters.values()}
+            if self.signature
+            else None
+        )
         self.forward_ordered_parameter_names = (
             list(self.signature.parameters) if self.signature else None
         )
@@ -973,7 +993,13 @@ class ModelInputs:
             len(s1) == 1
         ), f"Different numbers of positional arguments {s1} for {self.full_name}"
         s2 = set(tuple(sorted(set(i[1]))) for i in self.inputs)
-        assert len(s2) == 1, f"Different named arguments {s2} for {self.full_name}"
+        assert len(s2) > 0, f"empty {s2} for {self.full_name}"
+        if len(s2) > 1:
+            # We need to keep the largest set of inputs, the one including all the others.
+            sum_s2 = set()
+            for s in s2:
+                sum_s2 |= set(s)
+            s2 = {tuple(sum_s2)}
         args = []
         kwargs = {}
         for i in range(s1.pop()):
@@ -993,12 +1019,18 @@ class ModelInputs:
                 f"\ninputs[1]={string_type(self.inputs[1], with_shape=True)}"
             )
 
-            objs = [_[1][name] for _ in self.inputs]
+            objs = [_[1][name] for _ in self.inputs if name in _[1]]
             kwargs[name] = self.guess_dynamic_shape_object(
                 *objs,
                 auto=auto if isinstance(auto, bool) else f"{auto}_{i}I",
                 msg=lambda name=name: f" failing input {name!r}",
             )
+        # reordering
+        if kwargs is not None and self.forward_ordered_parameter_names:
+            kwargs1 = {
+                p: kwargs[p] for p in self.forward_ordered_parameter_names if p in kwargs
+            }
+            kwargs = {**kwargs1, **{k: v for k, v in kwargs.items() if k not in kwargs1}}
         return tuple(args), kwargs
 
     def move_to_kwargs(
@@ -1061,6 +1093,16 @@ class ModelInputs:
                 f"and kwargs={set(kwargs)}, "
                 f"forward_ordered_parameter_names={self.forward_ordered_parameter_names}"
             )
+        if kwargs is not None and self.forward_ordered_parameter_names:
+            kwargs1 = {
+                p: kwargs[p] for p in self.forward_ordered_parameter_names if p in kwargs
+            }
+            kwargs = {**kwargs1, **{k: v for k, v in kwargs.items() if k not in kwargs1}}
+        if kw_dyn is not None and self.forward_ordered_parameter_names:
+            kw_dyn1 = {
+                p: kw_dyn[p] for p in self.forward_ordered_parameter_names if p in kw_dyn
+            }
+            kw_dyn = {**kw_dyn1, **{k: v for k, v in kw_dyn.items() if k not in kw_dyn1}}
         return args, kwargs, (tuple(), kw_dyn)
 
     def validate_inputs_for_export(

onnx_diagnostic/export/shape_helper.py

@@ -210,6 +210,7 @@ def make_fake_with_dynamic_dimensions(
     This uses function :func:`onnx_diagnostic.helpers.fake_tensor_helper.make_fake`.
     Parameter ``existing`` is used to reused the same object when the dynamic
     dimension is given the same name as another one.
+    This function works with caches only if ``transformers>=4.57``.
 
     A simple tensor:
 

onnx_diagnostic/helpers/cache_helper.py

@@ -28,14 +28,6 @@ class CacheKeyValue:
             ]
             self.key_cache = [layer.keys for layer in layers]
             self.value_cache = [layer.values for layer in layers]
-            if None in self.key_cache or None in self.value_cache:
-                from .helper import string_type
-
-                raise AssertionError(
-                    f"issue with key_cache={string_type(self.key_cache)}, "
-                    f"or value_cache={string_type(self.value_cache)}, "
-                    f"cache.layers={string_type(cache.layers)}"
-                )
         elif cache is not None and hasattr(cache, "key_cache"):
             self.key_cache = cache.key_cache
             self.value_cache = cache.value_cache

onnx_diagnostic/helpers/fake_tensor_helper.py

@@ -105,6 +105,8 @@ class FakeTensorContext:
         reduced_tensor = self.from_tensor(true_tensor, static_shapes=True).sum(
             axis=tuple(sorted(sh)), keepdim=True
         )
+        if len(reduced_tensor.shape) == 0 == len(new_shape):
+            return reduced_tensor
         return reduced_tensor.expand(*new_shape)
 
     def make_fake(self, x: Any) -> Optional["FakeTensor"]:  # noqa: F821
@@ -144,19 +146,22 @@ class FakeTensorContext:
         """
         See
         :func:`onnx_diagnostic.export.shape_helper.make_fake_with_dynamic_dimensions`.
+        If caches are used, it requires ``transformers>=4.57``.
         """
         if x is None:
             return None, None
-        if isinstance(x, (list, tuple)):
+        if type(x) in (list, tuple):
             return x.__class__(
                 [
                     self.make_fake_with_dynamic_dimensions(i, dynamic_shapes=ds)
                     for i, ds in zip(x, dynamic_shapes)
                 ]
             )
-        if isinstance(x, dict):
+        if type(x) is dict:
             return {
-                k: self.make_fake_with_dynamic_dimensions(v, dynamic_shapes=dynamic_shapes[k])
+                k: self.make_fake_with_dynamic_dimensions(
+                    v, dynamic_shapes=dynamic_shapes[k] if dynamic_shapes else None
+                )
                 for k, v in x.items()
             }
         if x.__class__.__name__ in {"DynamicCache", "StaticCache", "HybridCache"}:
@@ -187,6 +192,17 @@ class FakeTensorContext:
                 x.cross_attention_cache, dynamic_shapes=dynamic_shapes[1]
             )
             return x
+        if x.__class__.__name__ == "BaseModelOutput":
+            assert (
+                list(x.keys()) == ["last_hidden_state"] and x.last_hidden_state is not None
+            ), (
+                f"Field 'last_hidden_state' is empty for {type(x)} or other fields "
+                f"{list(x.keys())} are used."
+            )
+            x.last_hidden_state = self.make_fake_with_dynamic_dimensions(
+                x.last_hidden_state, dynamic_shapes=dynamic_shapes[0]
+            )
+            return x
         if hasattr(x, "shape"):
             assert dynamic_shapes is None or isinstance(dynamic_shapes, dict), (
                 f"dynamic_shapes must be a dictionary at this stage but "
@@ -197,9 +213,11 @@ class FakeTensorContext:
             for idim, dim in enumerate(x.shape):
                 if dynamic_shapes is not None and idim in dynamic_shapes:
                     s = dynamic_shapes[idim]
+                    if s.__class__.__name__ == "Dim":
+                        s = s.__name__
                     assert isinstance(s, str), (
                         f"Unexpected type {type(s)} in dynamic_shapes={dynamic_shapes} "
-                        f"at index {idim}"
+                        f"at index {idim}, self._mapping_str={self._mapping_str}"
                     )
                     if s in self._mapping_str:
                         dim = self._mapping_str[s]
@@ -217,10 +235,13 @@ class FakeTensorContext:
 
                 x = torch.empty(tuple(new_shape), dtype=x.dtype, device=x.device)
 
-            t = self.fake_reshape(x, dynamic_shapes)  # type: ignore[arg-type]
+            t = self.fake_reshape(x, dynamic_shapes) if dynamic_shapes else x  # type: ignore[arg-type]
             assert t.device == x.device, f"device mismatch {x.device} -> {t.device}"
             assert t.dtype == x.dtype, f"dtype mismatch {x.dtype} -> {t.dtype}"
             return t
+        if isinstance(x, (int, bool, float)):
+            # It is a constant, we don't change that.
+            return x
         from ..helpers import string_type
 
         raise TypeError(

onnx_diagnostic/helpers/helper.py

@@ -704,9 +704,35 @@ def string_type(
     if obj.__class__.__name__ == "VirtualTensor":
         if verbose:
             print(f"[string_type] TT4:{type(obj)}")
+
+        def _torch_sym_int_to_str(value: "torch.SymInt") -> Union[int, str]:  #  noqa: F821
+            if isinstance(value, str):
+                return value
+            if hasattr(value, "node") and isinstance(value.node, str):
+                return f"{value.node}"
+
+            from torch.fx.experimental.sym_node import SymNode
+
+            if hasattr(value, "node") and isinstance(value.node, SymNode):
+                # '_expr' is safer than expr
+                return str(value.node._expr).replace(" ", "")
+
+            try:
+                val_int = int(value)
+                return val_int
+            except (
+                TypeError,
+                ValueError,
+                AttributeError,
+                torch.fx.experimental.symbolic_shapes.GuardOnDataDependentSymNode,
+            ):
+                pass
+
+            raise AssertionError(f"Unable to convert {value!r} into string")
+
         return (
             f"{obj.__class__.__name__}(name={obj.name!r}, "
-            f"dtype={obj.dtype}, shape={obj.shape})"
+            f"dtype={obj.dtype}, shape={tuple(_torch_sym_int_to_str(_) for _ in obj.shape)})"
         )
 
     if obj.__class__.__name__ == "KeyValuesWrapper":
@@ -775,6 +801,9 @@ def string_type(
             print(f"[string_type] TT8:{type(obj)}")
         return repr(obj).replace(" ", "").replace("\n", " ")
 
+    if isinstance(obj, torch.fx.proxy.Proxy):
+        return repr(obj)
+
     if ignore:
         if verbose:
             print(f"[string_type] CACHE4:{type(obj)}")

onnx_diagnostic/helpers/ort_session.py

@@ -1,3 +1,4 @@
+import os
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import onnx
 import numpy as np
@@ -76,6 +77,10 @@ class _InferenceSession:
                     session_options.enable_profiling = enable_profiling
                 if optimized_model_filepath:
                     session_options.optimized_model_filepath = optimized_model_filepath
+                    session_options.add_session_config_entry(
+                        "session.optimized_model_external_initializers_file_name",
+                        f"{os.path.splitext(os.path.split(optimized_model_filepath)[-1])[0]}.data",
+                    )
                 if log_severity_level is not None:
                     session_options.log_severity_level = log_severity_level
                 if log_verbosity_level is not None:

onnx_diagnostic/tasks/image_text_to_text.py

@@ -172,10 +172,10 @@ def _get_inputs_gemma3(
         assert expected & set(
             dummies
         ), f"Unable to find expected inputs {expected} in loaded inputs {set(dummies)}"
-        assert sequence_length == dummies["input_ids"].shape[-1], (
-            f"sequence_length={sequence_length} != {dummies['input_ids'].shape[-1]} for "
-            f"model class {model.__class__.__name__}"
-        )
+        # assert sequence_length == dummies["input_ids"].shape[-1], (
+        #    f"sequence_length={sequence_length} != {dummies['input_ids'].shape[-1]} for "
+        #    f"model class {model.__class__.__name__}"
+        # )
         assert batch_size == dummies["input_ids"].shape[0], (
             f"batch_size={batch_size} != {dummies['input_ids'].shape[0]} for "
             f"model class {model.__class__.__name__}"

onnx_diagnostic/torch_export_patches/patch_details.py

@@ -191,7 +191,7 @@ class PatchDetails:
             ep = torch.export.export(
                 model, (), kwargs=inputs, dynamic_shapes=use_dyn_not_str(ds)
             )
-        patches = details.patches_involded_in_graph(ep.graph)
+        patches = details.patches_involved_in_graph(ep.graph)
         report = details.make_report(patches, format="rst")
         print(report)
     """
@@ -235,7 +235,7 @@ class PatchDetails:
         """Returns the data for a dataframe."""
         return [p.to_dict() for p in self.patched]
 
-    def patches_involded_in_graph(
+    def patches_involved_in_graph(
         self, graph: "torch.fx.Graph"  # noqa: F821
     ) -> List[Tuple[PatchInfo, List["torch.fx.Node"]]]:  # noqa: F821
         """
@@ -322,7 +322,7 @@ class PatchDetails:
         """
         Creates a report based on the involved patches.
 
-        :param patches: from method :meth:`patches_involded_in_graph`
+        :param patches: from method :meth:`patches_involved_in_graph`
         :param format: format of the report
         :return: report
         """

onnx_diagnostic/torch_export_patches/patches/_patch_transformers_dynamic_cache.py

@@ -22,13 +22,22 @@ if patch_DynamicLayer:
         _PATCHES_ = ["lazy_initialization"]
         _PATCHED_CLASS_ = DynamicLayer
 
-        def lazy_initialization(self, key_states: torch.Tensor):
+        def lazy_initialization(
+            self, key_states: torch.Tensor, value_states: torch.Tensor = None
+        ):
             self.dtype, self.device = key_states.dtype, key_states.device
-            new_shape = list(key_states.shape)
-            new_shape[-2] = 0
+            assert (
+                hasattr(key_states, "shape") and key_states is not None
+            ), f"Attribute 'shape' is wrong for type {type(key_states)}"
+            like = torch.narrow(key_states, dim=-2, start=0, length=0)
             # PATCHED: used a tensor with an empty shape and not en empty list to initialize
-            self.keys = torch.empty(new_shape, dtype=self.dtype, device=self.device)
-            self.values = torch.empty(new_shape, dtype=self.dtype, device=self.device)
+            if isinstance(key_states, torch._subclasses.fake_tensor.FakeTensor):
+                with key_states.fake_mode:
+                    self.keys = torch.empty_like(like, dtype=self.dtype, device=self.device)
+                    self.values = torch.empty_like(like, dtype=self.dtype, device=self.device)
+            else:
+                self.keys = torch.empty_like(like, dtype=self.dtype, device=self.device)
+                self.values = torch.empty_like(like, dtype=self.dtype, device=self.device)
             if patch_is_initialized:
                 self.is_initialized = True
 

onnx_diagnostic/torch_export_patches/patches/_patch_transformers_rotary_embedding.py

@@ -214,7 +214,7 @@ def patched_dynamic_rope_update(rope_forward):
             cond,
             (lambda x, y: x.clone()),
             (lambda x, y: y.clone()),
-            [long_inv_freq, original_inv_freq],
+            [long_inv_freq.to(original_inv_freq.dtype), original_inv_freq],
         )
         setattr(self, f"{prefix}inv_freq", inv_freq)
         # if seq_len > original_max_position_embeddings:
@@ -293,7 +293,7 @@ def patched_dynamic_rope_update(rope_forward):
             cond,
             (lambda x, y: x.clone()),
             (lambda x, y: y.clone()),
-            [long_inv_freq, original_inv_freq],
+            [long_inv_freq.to(original_inv_freq.dtype), original_inv_freq],
         )
         setattr(self, f"{prefix}inv_freq", inv_freq)
 

onnx_diagnostic/torch_models/validate.py

@@ -1771,6 +1771,10 @@ def validate_onnx_model(
         if os.environ.get("DUMPORTOPT", "") in ("1", "true", "True"):
             opts = onnxruntime.SessionOptions()
             opts.optimized_model_filepath = f"{data['onnx_filename']}.rtopt.onnx"
+            opts.add_session_config_entry(
+                "session.optimized_model_external_initializers_file_name",
+                f"{os.path.split(data['onnx_filename'])[0]}.rtopt.data",
+            )
             if verbose:
                 print(
                     f"[validate_onnx_model] saved optimized onnxruntime "
@@ -2326,6 +2330,7 @@ def call_torch_export_custom(
         "custom-dec",
         "custom-decall",
         "custom-fake",
+        "custom-tracing",
     }
     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)}"
@@ -2338,11 +2343,16 @@ def call_torch_export_custom(
         f"Options strict cannot be specified in the exporter name {exporter!r} "
         f"and in the options {exporter_options}"
     )
+    assert ("-tracing" not in exporter) or ("tracing" not in exporter_options), (
+        f"Options tracing cannot be specified in the exporter name {exporter!r} "
+        f"and in the options {exporter_options}"
+    )
     summary: Dict[str, Union[str, int, float]] = {}
     strict = "-strict" in exporter or exporter_options.pop("strict", False)
     args, kwargs = split_args_kwargs(data["inputs_export"])
     ds = data.get("dynamic_shapes", None)
     fake = "-fake" in exporter or exporter_options.pop("fake", False)
+    tracing = "-tracing" in exporter or exporter_options.pop("tracing", False)
     if fake:
         from onnx_diagnostic.export.shape_helper import make_fake_with_dynamic_dimensions
 
@@ -2366,6 +2376,7 @@ def call_torch_export_custom(
     summary["export_exporter"] = exporter
     summary["export_optimization"] = optimization or ""
     summary["export_strict"] = strict
+    summary["export_tracing"] = tracing
     summary["export_fake"] = fake
     summary["export_args"] = string_type(args, with_shape=True)
     summary["export_kwargs"] = string_type(kwargs, with_shape=True)
@@ -2388,6 +2399,7 @@ def call_torch_export_custom(
         )
     )
     large_model = bool(exporter_options.pop("large_model", True))
+    exporter_options.pop("tracing", False)
     return_optimize_report = bool(exporter_options.pop("return_optimize_report", True))
     export_modules_as_functions = bool(
         exporter_options.pop("export_modules_as_functions", False)
@@ -2401,6 +2413,7 @@ def call_torch_export_custom(
     summary["export_external_threshold"] = str(external_threshold)
 
     export_options = ExportOptions(
+        tracing=tracing,
         strict=strict,
         decomposition_table=decomposition_table,
         save_ep=(
@@ -2445,6 +2458,41 @@ def call_torch_export_custom(
             )
         ),
     )
+    if "optimization" in opt_stats and dump_folder:
+        import pandas
+
+        pattern_stats = []
+        for k, v in opt_stats.items():
+            if "time" in k:
+                pattern_stats.append(dict(level="main", pattern=k, time_in=v))
+        pattern_stats.extend(
+            [{**obs, "level": "detailed"} for obs in opt_stats["optimization"]]
+        )
+        stat_filename = os.path.join(dump_folder, "optimization_stats.xlsx")
+        df = pandas.DataFrame(pattern_stats)
+        df.to_excel(stat_filename, index=False)
+        cols = [
+            c
+            for c in [
+                "level",
+                "pattern",
+                "time_in",
+                "iteration",
+                "inlined",
+                "removed",
+                "added",
+                "instances",
+                "changed",
+                "scale",
+            ]
+            if c in df.columns
+        ]
+        agg = {k: "sum" for k in cols if k not in ("level", "pattern")}
+        agg.update(dict(iteration="max", instances="mean"))
+        agg = {k: v for k, v in agg.items() if k in df.columns}
+        stat_filename = os.path.join(dump_folder, "optimization_stats.agg.xlsx")
+        df[cols].groupby(["level", "pattern"]).agg(agg).to_excel(stat_filename)
+
     if "ERR_export_onnx_c" in summary:
         return summary, data
 

{onnx_diagnostic-0.8.7.dist-info → onnx_diagnostic-0.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.8.7
+Version: 0.8.8
 Summary: Tools to help converting pytorch models into ONNX.
 Home-page: https://github.com/sdpython/onnx-diagnostic
 Author: Xavier Dupré
@@ -90,6 +90,8 @@ Enlightening Examples
 
 * `Export microsoft/phi-2
   <https://sdpython.github.io/doc/onnx-diagnostic/dev/auto_examples/plot_export_tiny_phi2.html>`_
+* `Export a model through method generate (with Tiny-LLM)
+  <https://sdpython.github.io/doc/onnx-diagnostic/dev/auto_examples/plot_export_tiny_llm_method_generate.html>`_
 
 **Torch Export**
 

{onnx_diagnostic-0.8.7.dist-info → onnx_diagnostic-0.8.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onnx_diagnostic/__init__.py,sha256=4PdbZ6FK0yyAhH9AUn7XujsN3PJ3vNr0EsPuwV8XoWc,173
+onnx_diagnostic/__init__.py,sha256=Is5g4yyLoruIq2F94HTISS_8sTf8w9AHzf6qlhhytZ0,173
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
 onnx_diagnostic/_command_lines_parser.py,sha256=g_udwHBHmY6X_d41Qby_DqMpEHL1p9GfUhJGBCihl8c,57784
 onnx_diagnostic/api.py,sha256=BhCl_yCd78N7TlVtPOHjeYv1QBEy39TjZ647rcHqLh0,345
@@ -6,34 +6,34 @@ onnx_diagnostic/doc.py,sha256=t3RELgfooYnVMAi0JSpggWkQEgUsREz8NmRvn0TnLI8,2829
 onnx_diagnostic/ext_test_case.py,sha256=A6BkrRm-QbvM8A-qRRMLt9o9ZO6wMXE9jrotggjpGfE,50460
 onnx_diagnostic/ci_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/ci_models/ci_helpers.py,sha256=lblOF7z2kLcCRAwMOdqp-Tz1EL1oBywHfVokhqiTQRg,15592
-onnx_diagnostic/ci_models/export_phi4_mm.py,sha256=FZik8jN0GdQ7sAo_a9PiuulUpbgG_4BrZugWQ7YbuaU,41668
+onnx_diagnostic/ci_models/export_phi4_mm.py,sha256=DH225jXhOG_S8KZE9Kn7FGNE4VqFyc9ZDnG-qxZn-hk,41668
 onnx_diagnostic/ci_models/export_qwen25_vl.py,sha256=_rYPr8PPraWizr2MPcGuYjrJ55ilJOyKl8kg0wq4L90,20405
 onnx_diagnostic/export/__init__.py,sha256=yEIoWiOeTwBsDhyYt2fTKuhtA0Ya1J9u9ZzMTOTWaWs,101
-onnx_diagnostic/export/api.py,sha256=5ESg0rcK0EFGMNl76_K2O0rvCC8hVi7Nfj0O3OI7tQA,10657
+onnx_diagnostic/export/api.py,sha256=V-2IhcxfMRFIh-CBb3c7QUUTcd_11FjRLHXLhIOy4Fk,22111
 onnx_diagnostic/export/cf_simple_loop_for.py,sha256=OHPGQc9AC-0TBtCYpP6cm-iHP9gmNt8WYRrPlO9ewlc,21158
 onnx_diagnostic/export/control_flow_onnx.py,sha256=izGlctqQANrHzSxPMbT7hoauNbnIBdx6hb8ry7HtVmM,18263
-onnx_diagnostic/export/dynamic_shapes.py,sha256=M2hlpHSTbkzZwGKAbrpQXng5HQrwjF5Z6wGGxEgnp74,42061
+onnx_diagnostic/export/dynamic_shapes.py,sha256=z6BgCAHyrB6SLcCdjy5CMr8lOy-dm-CUQgJc_GyQVTw,44138
 onnx_diagnostic/export/onnx_plug.py,sha256=U13fL0BjnhMzcDGxaAOqM4TQte5Z4zKDg4ESS0iktjM,22704
-onnx_diagnostic/export/shape_helper.py,sha256=m628y0oRCQbeZkeh8JDHIfWMsSjoJoeX-IPiPGDHT-w,11273
+onnx_diagnostic/export/shape_helper.py,sha256=L0RKUufLQDM5PqDMYk-9L3YZMnv4Zpz2t18KL_37RUU,11341
 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=Vvzb7Wy0baIT5O0dx4RKQTx-5V08PiHxPJh6XPkY-lU,16544
-onnx_diagnostic/helpers/cache_helper.py,sha256=OLghsSUuZ8cWGkua8eH75KBF-mbVqejnNUYfFo5lRf0,28498
+onnx_diagnostic/helpers/cache_helper.py,sha256=RsPuYRQ_RiA4I-J2loD-gXnmLsvxskp_nqv_C9hQlrU,28114
 onnx_diagnostic/helpers/config_helper.py,sha256=cWRETgFhZ7tayIZPnMqF8BF5AvTU64G2BMqyzgO7lzs,5670
 onnx_diagnostic/helpers/doc_helper.py,sha256=pl5MZd3_FaE8BqQnqoBuSBxoNCFcd2OJd3eITUSku5c,5897
 onnx_diagnostic/helpers/dot_helper.py,sha256=hwgTJsbsUv0qq7euyPDnc1NsBZDGOwv32JXSZxIHJkE,8118
-onnx_diagnostic/helpers/fake_tensor_helper.py,sha256=J7wnK3WTuVKnYiMzLVTAPkdJr3hQfIfMC9ZlOu7oGmI,11024
+onnx_diagnostic/helpers/fake_tensor_helper.py,sha256=59046wDIw84or6PJxLaa2CFqaWT7Y3mpYr-BB2shcBE,12027
 onnx_diagnostic/helpers/graph_helper.py,sha256=hevQT5a7_QuriVPQcbT5qe18n99Doyl5h3-qshx1-uk,14093
-onnx_diagnostic/helpers/helper.py,sha256=x8EYQmgrz_G5QS_IsbeFIoDcN_sUs-CslJMHseBj1Fw,65482
+onnx_diagnostic/helpers/helper.py,sha256=Fa5wB0CAva2d82RDjCoJxbf1AafYWPZEHKlyz7PZLg0,66505
 onnx_diagnostic/helpers/log_helper.py,sha256=3mWQd-nLKCctKZt9N8SpoWgLC8O7YdNQ2pfW5QXYWDQ,93232
 onnx_diagnostic/helpers/memory_peak.py,sha256=M3m4_thWFIwP5HytbJYEqaijXIv5v5BW_vlcJowIYI4,6434
 onnx_diagnostic/helpers/mini_onnx_builder.py,sha256=jR2lkRZEQ0N30H0FqeBwaxJd_w_6kyxFagrnulqFjhE,23883
 onnx_diagnostic/helpers/model_builder_helper.py,sha256=qKIq4Naqq03gk6NfqXLQjSDiKL5FFNc1AEyVX0R8GmA,18540
 onnx_diagnostic/helpers/onnx_helper.py,sha256=MshvqMSTNUUZIpkkRYGDymdW2t2KtB2BgYtOPHIDwvQ,57508
 onnx_diagnostic/helpers/optim_helper.py,sha256=0NiYRwV9GLTub4SEny0dqEhLcajRjEhcgkeBDVr9bGQ,4424
-onnx_diagnostic/helpers/ort_session.py,sha256=XvRazj7yyepaQwYHpPkKKi9v8u_h9A4ZiFH6IxjqPKs,30502
+onnx_diagnostic/helpers/ort_session.py,sha256=Y6iJojJcQtPesy9dRaaxRSeRTLXk0Pdh6-_fzdiPDm0,30779
 onnx_diagnostic/helpers/rt_helper.py,sha256=OOxHSCKZup2u7zTvVJxPkRHb4jQZ03KpkiDGrfwibMM,38135
 onnx_diagnostic/helpers/torch_fx_graph_helper.py,sha256=7xFe4svdbr4gV3OTNcx8eJejjDyHAv4hD_RNNKSxL0c,6571
 onnx_diagnostic/helpers/torch_helper.py,sha256=ADV81WWCskQ-jmzn1GI_LU8GqBtufCHS3oeLG-3Uw0E,38954
@@ -89,7 +89,7 @@ onnx_diagnostic/tasks/automatic_speech_recognition.py,sha256=aMufLDGW005f7aLMZ9a
 onnx_diagnostic/tasks/feature_extraction.py,sha256=IS9z9fPNE0hhGUebBfmNZl0twdXobMc7MFKpQB9qZI0,5388
 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=21gbNU8ZZCSzWWmNpwlUmROD_5pC_u74GgnzTLELzd8,22136
+onnx_diagnostic/tasks/image_text_to_text.py,sha256=A3mg3t7zh2Z_kAJ4cQBrW9x6O1knMPjL_LwMlH78m-k,22142
 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
@@ -106,7 +106,7 @@ onnx_diagnostic/tasks/data/dummies_imagetext2text_generation_gemma3.onnx,sha256=
 onnx_diagnostic/torch_export_patches/__init__.py,sha256=0SaZedwznm1hQUCvXZsGZORV5vby954wEExr5faepGg,720
 onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=XHYtU7w3vsaTMCuF5X1YtOKxgwL8eEuktXzVZpRz55o,43431
 onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=0HdubI06EGpxOICqDWZoVmZkVO9gAaFADEmby197EyM,11935
-onnx_diagnostic/torch_export_patches/patch_details.py,sha256=MSraVo5ngBhihi8ssPMXSY9B4fJ17J-GAADaw3dT-rc,11794
+onnx_diagnostic/torch_export_patches/patch_details.py,sha256=UHBo4QTLF3ZgQ4951yYHIQqxOeRYNaG7x56XFcRTtg4,11794
 onnx_diagnostic/torch_export_patches/patch_expressions.py,sha256=VOsv71FsR_UZtxz4-5_VKL2sHQhOkHy9RkPJME2h7UU,3271
 onnx_diagnostic/torch_export_patches/patch_inputs.py,sha256=-TgcyjVzxTb5Y-_ibssTeaA5PFz6FJrV6q84HMUAsJw,8075
 onnx_diagnostic/torch_export_patches/patch_module.py,sha256=1Mn3xdpK1jSdRs6z1C-mJGkfGmD2TNRwLNoPaOW_EFI,40061
@@ -117,7 +117,7 @@ onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TI
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_attention.py,sha256=5JOyT95BNwHIuxaSFJDSEGsoI-6IwbgNnFwg2q3UM-Q,7731
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_cache_utils.py,sha256=UdxLii-od2OpQmUJbmXmZinXeLBItVFrr75BVT1Y0zw,2041
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_causal_mask.py,sha256=h37DPVxsq8iAWECnTlKW5tVqSBgPBF52xr3uxsjdi2k,3113
-onnx_diagnostic/torch_export_patches/patches/_patch_transformers_dynamic_cache.py,sha256=lEdYqX60pyi_w6PrbCTk7NC96nB8FFcFRf_JMjXSAZE,7961
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_dynamic_cache.py,sha256=aiRtT1SUTrH7wYpBF7YjPEgb-fRYXlnilims4Y5a0JA,8516
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_funnel.py,sha256=QAMFiA8MGQgbowZzpfLsh7gXTuzXc3eGmZ7hLKF1i78,3352
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_gemma3.py,sha256=nVgYQk0xXpHiictN1wOHVMN2lTH9b0vfIJ4ie-uKopg,1999
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_generation_mixin.py,sha256=VIZsVHgR8NmAcBQalPl5I6ZzNgcBxjGb6ars31m9gRg,21936
@@ -126,7 +126,7 @@ onnx_diagnostic/torch_export_patches/patches/_patch_transformers_masking_utils.p
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_qwen2.py,sha256=OxYdlLrwtd_KGHt3E17poduxvWFg-CfGS57-yN1i6gI,3827
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_qwen2_5.py,sha256=oYz0tr-6KH0DabpgaISytnXAGxQosoA8gV5LpksO4yI,34834
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_qwen3.py,sha256=cND9Iqo1aKdlX-BXGr9Qlq_Y4EW1L5VWSwZfqYTVazU,4888
-onnx_diagnostic/torch_export_patches/patches/_patch_transformers_rotary_embedding.py,sha256=4bJ_z2gizZQla_fcCVt0dmuhzO9Vu-D7CCMWdxMlrKM,16893
+onnx_diagnostic/torch_export_patches/patches/_patch_transformers_rotary_embedding.py,sha256=LAqoL5SWISekZO15G1HIcCkN1JlBxGqb9XbK_eLzalA,16949
 onnx_diagnostic/torch_export_patches/patches/_patch_transformers_sam_mask_decoder.py,sha256=-6TuBm3sLAFEGuW3vRfOTtE5uP6aINFfu7xMnl27Dws,5703
 onnx_diagnostic/torch_export_patches/patches/patch_helper.py,sha256=kK_CGW643iVXxa-m6pttDBS7HTyMQaPypza7iqIInn4,721
 onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=VCs3uZHcuzosCqn9sSEskEWHJym_RrDJM6-G6FcTC08,45117
@@ -137,7 +137,7 @@ onnx_diagnostic/torch_export_patches/serialization/transformers_impl.py,sha256=s
 onnx_diagnostic/torch_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_models/code_sample.py,sha256=rCDZY64pkn6uIbJJSBuC5TlU_-uleI73I9GlbXtJd54,12923
 onnx_diagnostic/torch_models/llms.py,sha256=soyg4yC87ptGoeulJhKqw5opGmuLvH1pn_ZDXZ4Jr8E,90
-onnx_diagnostic/torch_models/validate.py,sha256=fnbTl5v1n5nM2MpmCgCMaWa6c7DGpb5mZYSuHXXCJEs,94829
+onnx_diagnostic/torch_models/validate.py,sha256=JsEMv7aeg9tGGriKZ_CJeqGDfNUmZNdGtPu5jQN9TWY,96739
 onnx_diagnostic/torch_models/hghub/__init__.py,sha256=vi1Q7YHdddj1soiBN42MSvJdFqe2_KUoWafHISjwOu8,58
 onnx_diagnostic/torch_models/hghub/hub_api.py,sha256=V3azxUqb7mkmHQ8m5DCgg1WUU2NYBK12USEUy_sfYIA,14709
 onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=6jR8A83cGP4Xw1Wg-q1zzKFpqzoVrybqm0Fm3yurkrE,9030
@@ -152,8 +152,8 @@ onnx_diagnostic/torch_onnx/compare.py,sha256=O0lws4kzn8WAXr8-x-YMPr7oyBC9DtSIs4O
 onnx_diagnostic/torch_onnx/runtime_info.py,sha256=u1bD6VXqzBCRmqmbzQtDswaPs1PH_ygr1r-CrcfXpNU,8562
 onnx_diagnostic/torch_onnx/sbs.py,sha256=8okBEIupMgw7TtKc80YFimMtwnY3GchdY05FsA9ooa0,40749
 onnx_diagnostic/torch_onnx/sbs_dataclasses.py,sha256=UctdBjzoPTQG1LS0tZ8A6E9hpoq5HWUYaJLPOPJc9FI,20299
-onnx_diagnostic-0.8.7.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.8.7.dist-info/METADATA,sha256=H6o_1MWw2N8hO2BYh499xYb0Mm_KjgxkwirLXxiHQHI,6734
-onnx_diagnostic-0.8.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_diagnostic-0.8.7.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.8.7.dist-info/RECORD,,
+onnx_diagnostic-0.8.8.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.8.8.dist-info/METADATA,sha256=sxPBIjOSLqQITi527dnl_3gk3RxT9kNCu47gPPyrg7Q,6905
+onnx_diagnostic-0.8.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_diagnostic-0.8.8.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.8.8.dist-info/RECORD,,