onnx-diagnostic 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

onnx_diagnostic/tasks/image_text_to_text.py

@@ -1,7 +1,7 @@
 import itertools
 from typing import Any, Callable, Dict, Optional, Tuple
 import torch
-from ..helpers.cache_helper import make_dynamic_cache, make_hybrid_cache
+from ..helpers.cache_helper import make_dynamic_cache, get_make_hybrid_cache
 from ..helpers.config_helper import (
     update_config,
     check_hasattr,
@@ -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__}"
@@ -200,6 +200,9 @@ def _get_inputs_gemma3(
 
     _check_()
 
+    make_hybrid_cache = get_make_hybrid_cache()
+    assert make_hybrid_cache is not None, "not implemented when make_hybrid_cache is missing"
+
     inputs = dict(
         input_ids=dummies["input_ids"],
         token_type_ids=dummies["token_type_ids"],

onnx_diagnostic/tasks/text_generation.py

@@ -1,11 +1,6 @@
 from typing import Any, Callable, Dict, Optional, Tuple, Union
 import torch
-from ..helpers.cache_helper import (
-    make_dynamic_cache,
-    make_mamba_cache,
-    make_sliding_window_cache,
-    make_static_cache,
-)
+from ..helpers.cache_helper import make_dynamic_cache, make_mamba_cache, make_static_cache
 from ..helpers.config_helper import (
     update_config,
     check_hasattr,
@@ -187,17 +182,22 @@ def get_inputs(
             if cls_cache is None or isinstance(cls_cache, str)
             else cls_cache.__name__
         )
-        make_caches = {
-            "DynamicCache": make_dynamic_cache,
-            "SlidingWindowCache": make_sliding_window_cache,
-            "StaticCache": make_static_cache,
-        }
-        assert cache_name is None or cache_name in make_caches, (
-            f"Unable to handle cls_cache={cache_name!r}, it should be in "
-            f"{sorted(make_caches)}"
-        )
-        make_cache = make_dynamic_cache if cache_name is None else make_caches[cache_name]
-        is_static = cache_name == "StaticCache"
+        if cache_name == "DynamicSlidingWindowCache":
+            from ..helpers.cache_helper import make_sliding_window_cache
+
+            make_cache = make_sliding_window_cache
+            is_static = False
+        else:
+            make_caches = {
+                "DynamicCache": make_dynamic_cache,
+                "StaticCache": make_static_cache,
+            }
+            assert cache_name is None or cache_name in make_caches, (
+                f"Unable to handle cls_cache={cache_name!r}, it should be in "
+                f"{sorted(make_caches)}"
+            )
+            make_cache = make_dynamic_cache if cache_name is None else make_caches[cache_name]  # type: ignore[assignment]
+            is_static = cache_name == "StaticCache"
 
         if is_static:
             # static

onnx_diagnostic/torch_export_patches/eval/__init__.py

@@ -521,7 +521,7 @@ def run_exporter(
     :param exporter: exporter
     :param cls_model: model class to create
     :param inputs: list of inputs to try
-    :param dynamic: use dynamic shape or not
+    :param dynamic: use dynamic shapes or not
     :param quiet: raise exception or not
     :param verbose: verbosity
     :return: results

onnx_diagnostic/torch_export_patches/onnx_export_serialization.py

@@ -7,15 +7,9 @@ import transformers
 from transformers.cache_utils import DynamicCache, StaticCache
 
 try:
-    from transformers.cache_utils import (
-        EncoderDecoderCache,
-        HybridCache,
-        SlidingWindowCache,
-    )
+    from transformers.cache_utils import EncoderDecoderCache
 except ImportError:
     EncoderDecoderCache = None
-    HybridCache = None
-    SlidingWindowCache = None
 from ..helpers import string_type
 from .serialization import _lower_name_with_
 
@@ -36,6 +30,24 @@ def get_mamba_cache_cls() -> type:
             return None
 
 
+def get_hybrid_cache_cls() -> type:
+    try:
+        from transformers.cache_utils import HybridCache
+
+        return HybridCache
+    except ImportError:
+        return None
+
+
+def get_sliding_window_cache_cls() -> type:
+    try:
+        from transformers.cache_utils import SlidingWindowCache
+
+        return SlidingWindowCache
+    except ImportError:
+        return None
+
+
 def register_class_serialization(
     cls,
     f_flatten: Callable,
@@ -179,18 +191,9 @@ def serialization_functions(
             flatten_dynamic_cache,
             unflatten_dynamic_cache,
             flatten_with_keys_dynamic_cache,
-            flatten_hybrid_cache,
-            unflatten_hybrid_cache,
-            flatten_with_keys_hybrid_cache,
-            flatten_mamba_cache,
-            unflatten_mamba_cache,
-            flatten_with_keys_mamba_cache,
             flatten_encoder_decoder_cache,
             unflatten_encoder_decoder_cache,
             flatten_with_keys_encoder_decoder_cache,
-            flatten_sliding_window_cache,
-            unflatten_sliding_window_cache,
-            flatten_with_keys_sliding_window_cache,
             flatten_static_cache,
             unflatten_static_cache,
             flatten_with_keys_static_cache,
@@ -208,14 +211,6 @@ def serialization_functions(
                 # f_check=make_dynamic_cache([(torch.rand((4, 4, 4)), torch.rand((4, 4, 4)))]),
                 verbose=verbose,
             ),
-            HybridCache: lambda verbose=verbose: register_class_serialization(
-                HybridCache,
-                flatten_hybrid_cache,
-                unflatten_hybrid_cache,
-                flatten_with_keys_hybrid_cache,
-                # f_check=make_dynamic_cache([(torch.rand((4, 4, 4)), torch.rand((4, 4, 4)))]),
-                verbose=verbose,
-            ),
             EncoderDecoderCache: lambda verbose=verbose: register_class_serialization(
                 EncoderDecoderCache,
                 flatten_encoder_decoder_cache,
@@ -223,13 +218,6 @@ def serialization_functions(
                 flatten_with_keys_encoder_decoder_cache,
                 verbose=verbose,
             ),
-            SlidingWindowCache: lambda verbose=verbose: register_class_serialization(
-                SlidingWindowCache,
-                flatten_sliding_window_cache,
-                unflatten_sliding_window_cache,
-                flatten_with_keys_sliding_window_cache,
-                verbose=verbose,
-            ),
             StaticCache: lambda verbose=verbose: register_class_serialization(
                 StaticCache,
                 flatten_static_cache,
@@ -240,6 +228,12 @@ def serialization_functions(
         }
         MambaCache = get_mamba_cache_cls()
         if MambaCache:
+            from .serialization.transformers_impl import (
+                flatten_mamba_cache,
+                unflatten_mamba_cache,
+                flatten_with_keys_mamba_cache,
+            )
+
             transformers_classes[MambaCache] = (
                 lambda verbose=verbose: register_class_serialization(
                     MambaCache,
@@ -249,6 +243,42 @@ def serialization_functions(
                     verbose=verbose,
                 )
             )
+        HybridCache = get_hybrid_cache_cls()
+        if HybridCache:
+            from .serialization.transformers_impl import (
+                flatten_hybrid_cache,
+                unflatten_hybrid_cache,
+                flatten_with_keys_hybrid_cache,
+            )
+
+            transformers_classes[HybridCache] = (
+                lambda verbose=verbose: register_class_serialization(
+                    HybridCache,
+                    flatten_hybrid_cache,
+                    unflatten_hybrid_cache,
+                    flatten_with_keys_hybrid_cache,
+                    verbose=verbose,
+                )
+            )
+
+        SlidingWindowCache = get_sliding_window_cache_cls()
+        if SlidingWindowCache:
+            from .serialization.transformers_impl import (
+                flatten_sliding_window_cache,
+                unflatten_sliding_window_cache,
+                flatten_with_keys_sliding_window_cache,
+            )
+
+            transformers_classes[SlidingWindowCache] = (
+                lambda verbose=verbose: register_class_serialization(
+                    SlidingWindowCache,
+                    flatten_sliding_window_cache,
+                    unflatten_sliding_window_cache,
+                    flatten_with_keys_sliding_window_cache,
+                    verbose=verbose,
+                )
+            )
+
         classes.update(transformers_classes)
 
     if patch_diffusers:
@@ -303,13 +333,7 @@ def unregister_class_serialization(cls: type, verbose: int = 0):
 
 
 def unregister_cache_serialization(undo: Dict[str, bool], verbose: int = 0):
-    """Undo all registrations."""
-    MambaCache = get_mamba_cache_cls()
-    cls_ensemble = (
-        {DynamicCache, EncoderDecoderCache}
-        | set(undo)
-        | ({MambaCache} if MambaCache else set())
-    )
+    cls_ensemble = {DynamicCache, EncoderDecoderCache} | set(undo)
     for cls in cls_ensemble:
         if undo.get(cls.__name__, False):
             unregister_class_serialization(cls, verbose)

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_export_patches/patches/patch_torch.py

@@ -541,14 +541,17 @@ class patched_ShapeEnv:
                     # oblivious_var_to_val will be defined iff we have sizes
                     # with DimDynamic.OBLIVIOUS_SIZE type.
                     # See https://github.com/pytorch/pytorch/issues/137100#issuecomment-2495778113
+                    var_to_val = getattr(
+                        self,
+                        "unbacked_var_to_val",
+                        getattr(self, "oblivious_var_to_val", False),
+                    )
                     if (
-                        self.oblivious_var_to_val
-                        and not (
-                            correct_hint := orig_expr.xreplace(self.oblivious_var_to_val)
-                        ).free_symbols
+                        var_to_val
+                        and not (correct_hint := orig_expr.xreplace(var_to_val)).free_symbols
                         and not (
                             counterfactual_hint := orig_expr.xreplace(
-                                {k: max(2, v) for k, v in self.oblivious_var_to_val.items()}
+                                {k: max(2, v) for k, v in var_to_val.items()}
                             )
                         ).free_symbols
                         and correct_hint == counterfactual_hint
@@ -571,11 +574,11 @@ class patched_ShapeEnv:
                     # and if they pass we add a runtime assertions and continue.
                     if (
                         not ok
-                        and self.unbacked_var_to_val
+                        and var_to_val
                         and not (
-                            unsound_result := orig_expr.xreplace(
-                                self.unbacked_var_to_val
-                            ).xreplace(self.var_to_val)
+                            unsound_result := orig_expr.xreplace(var_to_val).xreplace(
+                                var_to_val
+                            )
                         ).free_symbols
                     ):
                         # pyrefly: ignore  # unbound-name

onnx_diagnostic/torch_export_patches/serialization/transformers_impl.py

@@ -1,13 +1,7 @@
 import itertools
 from typing import Any, Callable, List, Set, Tuple
 import torch
-from transformers.cache_utils import (
-    Cache,
-    DynamicCache,
-    EncoderDecoderCache,
-    HybridCache,
-    StaticCache,
-)
+from transformers.cache_utils import Cache, DynamicCache, EncoderDecoderCache, StaticCache
 
 try:
     from transformers.cache_utils import SlidingWindowCache
@@ -15,18 +9,17 @@ except ImportError:
     SlidingWindowCache = None
 
 
+try:
+    from transformers.cache_utils import HybridCache
+except ImportError:
+    HybridCache = None
+
 try:
     from transformers.models.mamba.modeling_mamba import MambaCache
 except ImportError:
     from transformers.cache_utils import MambaCache
 from transformers.modeling_outputs import BaseModelOutput
-from ...helpers.cache_helper import (
-    make_dynamic_cache,
-    make_hybrid_cache,
-    make_sliding_window_cache,
-    make_static_cache,
-    CacheKeyValue,
-)
+from ...helpers.cache_helper import make_dynamic_cache, make_static_cache, CacheKeyValue
 from . import make_serialization_function_for_dataclass
 
 
@@ -78,6 +71,14 @@ def flatten_dynamic_cache(
     dynamic_cache: DynamicCache,
 ) -> Tuple[List[Any], torch.utils._pytree.Context]:
     """Serializes a :class:`transformers.cache_utils.DynamicCache` with python objects."""
+    assert (
+        not hasattr(dynamic_cache, "layers")
+        or not dynamic_cache.layers
+        or all(lay.__class__.__name__ == "DynamicLayer" for lay in dynamic_cache.layers)
+    ), (
+        f"The serialization does not work yet on other layers "
+        f"than DynamicLayer, but layers={[lay.__class__ for lay in dynamic_cache.layers]}"
+    )
     return _flatten_key_value_cache(dynamic_cache)
 
 
@@ -85,6 +86,14 @@ def flatten_with_keys_dynamic_cache(
     dynamic_cache: DynamicCache,
 ) -> Tuple[List[Tuple[torch.utils._pytree.KeyEntry, Any]], torch.utils._pytree.Context]:
     """Serializes a :class:`transformers.cache_utils.DynamicCache` with python objects."""
+    assert (
+        not hasattr(dynamic_cache, "layers")
+        or not dynamic_cache.layers
+        or all(lay.__class__.__name__ == "DynamicLayer" for lay in dynamic_cache.layers)
+    ), (
+        f"The serialization does not work yet on other layers "
+        f"than DynamicLayer, but layers={[lay.__class__ for lay in dynamic_cache.layers]}"
+    )
     return _flatten_with_keys_cache(dynamic_cache)
 
 
@@ -99,26 +108,27 @@ def unflatten_dynamic_cache(
 # HybridCache
 #############
 
+if HybridCache:
 
-def flatten_hybrid_cache(
-    cache: HybridCache,
-) -> Tuple[List[Any], torch.utils._pytree.Context]:
-    """Serializes a :class:`transformers.cache_utils.HybridCache` with python objects."""
-    return _flatten_key_value_cache(cache)
-
+    def flatten_hybrid_cache(
+        cache: HybridCache,
+    ) -> Tuple[List[Any], torch.utils._pytree.Context]:
+        """Serializes a :class:`transformers.cache_utils.HybridCache` with python objects."""
+        return _flatten_key_value_cache(cache)
 
-def flatten_with_keys_hybrid_cache(
-    cache: HybridCache,
-) -> Tuple[List[Tuple[torch.utils._pytree.KeyEntry, Any]], torch.utils._pytree.Context]:
-    """Serializes a :class:`transformers.cache_utils.HybridCache` with python objects."""
-    return _flatten_with_keys_cache(cache)
+    def flatten_with_keys_hybrid_cache(
+        cache: HybridCache,
+    ) -> Tuple[List[Tuple[torch.utils._pytree.KeyEntry, Any]], torch.utils._pytree.Context]:
+        """Serializes a :class:`transformers.cache_utils.HybridCache` with python objects."""
+        return _flatten_with_keys_cache(cache)
 
+    def unflatten_hybrid_cache(
+        values: List[Any], context: torch.utils._pytree.Context, output_type=None
+    ) -> HybridCache:
+        """Restores a :class:`transformers.cache_utils.HybridCache` from python objects."""
+        from ...helpers.cache_helper import make_hybrid_cache
 
-def unflatten_hybrid_cache(
-    values: List[Any], context: torch.utils._pytree.Context, output_type=None
-) -> HybridCache:
-    """Restores a :class:`transformers.cache_utils.HybridCache` from python objects."""
-    return _unflatten_cache(make_hybrid_cache, values, context, output_type=output_type)
+        return _unflatten_cache(make_hybrid_cache, values, context, output_type=output_type)
 
 
 #############
@@ -190,6 +200,8 @@ if SlidingWindowCache:
         Restores a :class:`transformers.cache_utils.SlidingWindowCache`
         from python objects.
         """
+        from ...helpers.cache_helper import make_sliding_window_cache
+
         return _unflatten_cache(
             make_sliding_window_cache, values, context, output_type=output_type
         )

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.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.8.7
+Version: 0.8.9
 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 LLM 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**