onnx-diagnostic 0.4.3__py3-none-any.whl → 0.4.4__py3-none-any.whl

onnx_diagnostic/__init__.py

@@ -3,5 +3,5 @@ Investigates onnx models.
 Functions, classes to dig into a model when this one is right, slow, wrong...
 """
 
-__version__ = "0.4.3"
+__version__ = "0.4.4"
 __author__ = "Xavier Dupré"

onnx_diagnostic/_command_lines_parser.py

@@ -336,6 +336,10 @@ def get_parser_validate() -> ArgumentParser:
         help="drops the following inputs names, it should be a list "
         "with comma separated values",
     )
+    parser.add_argument(
+        "--subfolder",
+        help="subfolder where to find the model and the configuration",
+    )
     parser.add_argument(
         "--ortfusiontype",
         required=False,
@@ -413,6 +417,7 @@ def _cmd_validate(argv: List[Any]):
             ortfusiontype=args.ortfusiontype,
             input_options=args.iop,
             model_options=args.mop,
+            subfolder=args.subfolder,
         )
         print("")
         print("-- summary --")

onnx_diagnostic/tasks/__init__.py

@@ -6,6 +6,7 @@ from . import (
     image_classification,
     image_text_to_text,
     mixture_of_expert,
+    object_detection,
     sentence_similarity,
     text_classification,
     text_generation,
@@ -20,6 +21,7 @@ __TASKS__ = [
     image_classification,
     image_text_to_text,
     mixture_of_expert,
+    object_detection,
     sentence_similarity,
     text_classification,
     text_generation,

onnx_diagnostic/tasks/image_classification.py

@@ -7,6 +7,13 @@ __TASK__ = "image-classification"
 
 def reduce_model_config(config: Any) -> Dict[str, Any]:
     """Reduces a model size."""
+    if (
+        hasattr(config, "model_type")
+        and config.model_type == "timm_wrapper"
+        and not hasattr(config, "num_hidden_layers")
+    ):
+        # We cannot reduce.
+        return {}
     check_hasattr(config, ("num_hidden_layers", "hidden_sizes"))
     kwargs = dict(
         num_hidden_layers=(
@@ -82,6 +89,20 @@ def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
     If the configuration is None, the function selects typical dimensions.
     """
     if config is not None:
+        if (
+            hasattr(config, "model_type")
+            and config.model_type == "timm_wrapper"
+            and not hasattr(config, "num_hidden_layers")
+        ):
+            input_size = config.pretrained_cfg["input_size"]
+            kwargs = dict(
+                batch_size=2,
+                input_width=input_size[-2],
+                input_height=input_size[-1],
+                input_channels=input_size[-3],
+            )
+            return kwargs, get_inputs
+
         check_hasattr(config, ("image_size", "architectures"), "num_channels")
     if config is not None:
         if hasattr(config, "image_size"):

onnx_diagnostic/tasks/object_detection.py

@@ -0,0 +1,123 @@
+from typing import Any, Callable, Dict, Optional, Tuple
+import torch
+from ..helpers.config_helper import update_config, check_hasattr
+
+__TASK__ = "object-detection"
+
+
+def reduce_model_config(config: Any) -> Dict[str, Any]:
+    """Reduces a model size."""
+    check_hasattr(config, ("num_hidden_layers", "hidden_sizes"))
+    kwargs = dict(
+        num_hidden_layers=(
+            min(config.num_hidden_layers, 2)
+            if hasattr(config, "num_hidden_layers")
+            else len(config.hidden_sizes)
+        )
+    )
+    update_config(config, kwargs)
+    return kwargs
+
+
+def get_inputs(
+    model: torch.nn.Module,
+    config: Optional[Any],
+    input_width: int,
+    input_height: int,
+    input_channels: int,
+    batch_size: int = 2,
+    dynamic_rope: bool = False,
+    add_second_input: bool = False,
+    **kwargs,  # unused
+):
+    """
+    Generates inputs for task ``object-detection``.
+
+    :param model: model to get the missing information
+    :param config: configuration used to generate the model
+    :param batch_size: batch size
+    :param input_channels: input channel
+    :param input_width: input width
+    :param input_height: input height
+    :return: dictionary
+    """
+    assert isinstance(
+        input_width, int
+    ), f"Unexpected type for input_width {type(input_width)}{config}"
+    assert isinstance(
+        input_width, int
+    ), f"Unexpected type for input_height {type(input_height)}{config}"
+
+    shapes = {
+        "pixel_values": {
+            0: torch.export.Dim("batch", min=1, max=1024),
+            2: "width",
+            3: "height",
+        }
+    }
+    inputs = dict(
+        pixel_values=torch.randn(batch_size, input_channels, input_width, input_height).clamp(
+            -1, 1
+        ),
+    )
+    res = dict(inputs=inputs, dynamic_shapes=shapes)
+    if add_second_input:
+        res["inputs2"] = get_inputs(
+            model=model,
+            config=config,
+            input_width=input_width + 1,
+            input_height=input_height + 1,
+            input_channels=input_channels,
+            batch_size=batch_size + 1,
+            dynamic_rope=dynamic_rope,
+            **kwargs,
+        )["inputs"]
+    return res
+
+
+def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
+    """
+    Inputs kwargs.
+
+    If the configuration is None, the function selects typical dimensions.
+    """
+    if config is not None:
+        if (
+            hasattr(config, "model_type")
+            and config.model_type == "timm_wrapper"
+            and not hasattr(config, "num_hidden_layers")
+        ):
+            input_size = config.pretrained_cfg["input_size"]
+            kwargs = dict(
+                batch_size=2,
+                input_width=input_size[-2],
+                input_height=input_size[-1],
+                input_channels=input_size[-3],
+            )
+            return kwargs, get_inputs
+
+        check_hasattr(config, ("image_size", "architectures"), "num_channels")
+    if config is not None:
+        if hasattr(config, "image_size"):
+            image_size = config.image_size
+        else:
+            assert config.architectures, f"empty architecture in {config}"
+            from ..torch_models.hghub.hub_api import get_architecture_default_values
+
+            default_values = get_architecture_default_values(config.architectures[0])
+            image_size = default_values["image_size"]
+    if config is None or isinstance(image_size, int):
+        kwargs = dict(
+            batch_size=2,
+            input_width=224 if config is None else image_size,
+            input_height=224 if config is None else image_size,
+            input_channels=3 if config is None else config.num_channels,
+        )
+    else:
+        kwargs = dict(
+            batch_size=2,
+            input_width=config.image_size[0],
+            input_height=config.image_size[1],
+            input_channels=config.num_channels,
+        )
+    return kwargs, get_inputs

onnx_diagnostic/tasks/text_generation.py

@@ -19,12 +19,11 @@ def reduce_model_config(config: Any) -> Dict[str, Any]:
         ("head_dim", ("hidden_size", "num_attention_heads"), "use_mambapy"),
         "num_hidden_layers",
         ("num_key_value_heads", "num_attention_heads", "use_mambapy"),
-        "intermediate_size",
         "hidden_size",
         "vocab_size",
     )
     if config.__class__.__name__ == "FalconMambaConfig":
-        check_hasattr(config, "conv_kernel", "state_size")  # 4 and 8
+        check_hasattr(config, "conv_kernel", "state_size", "intermediate_size")  # 4 and 8
         kwargs = dict(
             num_hidden_layers=min(config.num_hidden_layers, 2),
             intermediate_size=256 if config is None else min(512, config.intermediate_size),
@@ -44,17 +43,18 @@ def reduce_model_config(config: Any) -> Dict[str, Any]:
                 if hasattr(config, "num_key_value_heads")
                 else config.num_attention_heads
             ),
-            intermediate_size=(
-                min(config.intermediate_size, 24576 // 4)
-                if config.intermediate_size % 4 == 0
-                else config.intermediate_size
-            ),
             hidden_size=(
                 min(config.hidden_size, 3072 // 4)
                 if config.hidden_size % 4 == 0
                 else config.hidden_size
             ),
         )
+        if config is None or hasattr(config, "intermediate_size"):
+            kwargs["intermediate_size"] = (
+                min(config.intermediate_size, 24576 // 4)
+                if config.intermediate_size % 4 == 0
+                else config.intermediate_size
+            )
     update_config(config, kwargs)
     return kwargs
 
@@ -228,11 +228,10 @@ def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
             "vocab_size",
             ("num_attention_heads", "use_mambapy"),
             ("num_key_value_heads", "num_attention_heads", "use_mambapy"),
-            "intermediate_size",
             "hidden_size",
         )
     if config.__class__.__name__ == "FalconMambaConfig":
-        check_hasattr(config, "conv_kernel", "state_size")  # 4 and 8
+        check_hasattr(config, "conv_kernel", "state_size", "intermediate_size")  # 4 and 8
         kwargs = dict(
             batch_size=2,
             sequence_length=30,
@@ -263,7 +262,11 @@ def random_input_kwargs(config: Any) -> Tuple[Dict[str, Any], Callable]:
                 if config is None
                 else _pick(config, "num_key_value_heads", "num_attention_heads")
             ),
-            intermediate_size=1024 if config is None else config.intermediate_size,
             hidden_size=512 if config is None else config.hidden_size,
         )
+        if config is None or hasattr(config, "intermediate_size"):
+            kwargs["intermediate_size"] = (
+                1024 if config is None else config.intermediate_size,
+            )
+
     return kwargs, get_inputs

onnx_diagnostic/torch_export_patches/__init__.py

@@ -6,3 +6,15 @@ from .onnx_export_errors import (
 
 # bypass_export_some_errors is the first name given to the patches.
 bypass_export_some_errors = torch_export_patches  # type: ignore
+
+
+def register_flattening_functions(verbose: int = 0):
+    """
+    Registers functions to serialize deserialize cache or other classes
+    implemented in :epkg:`transformers` and used as inputs.
+    This is needed whenever a model must be exported through
+    :func:`torch.export.export`.
+    """
+    from .onnx_export_serialization import _register_cache_serialization
+
+    return _register_cache_serialization(verbose=verbose)

onnx_diagnostic/torch_export_patches/patch_module.py

@@ -0,0 +1,304 @@
+import ast
+import inspect
+import types
+import textwrap
+from typing import Callable, Dict
+import torch
+
+NODE_TYPES = tuple(
+    getattr(ast, k)
+    for k in dir(ast)
+    if "A" <= k[0] <= "Z" and isinstance(getattr(ast, k), type)
+)
+
+
+def _settl(node, lineno, level=0):
+    if isinstance(node, (str, int, float)):
+        return node
+    if isinstance(node, list):
+        for n in node:
+            _settl(n, lineno, level=level + 1)
+        return node
+    if isinstance(node, NODE_TYPES):
+        if not hasattr(node, "lineno") or node.lineno is None:
+            node.lineno = lineno
+        for k in dir(node):
+            if k in {"s", "n"}:
+                continue
+            if k[0] == "_":
+                continue
+            v = getattr(node, k)
+            _settl(v, max(lineno, node.lineno), level=level + 1)
+    return node
+
+
+class RewriteControlFlow(ast.NodeTransformer):
+    def __init__(self, wrapper_name):
+        self.wrapper_name = wrapper_name
+        self.counter = 0
+        self.current_func_args = None
+
+    def visit_FunctionDef(self, node):
+        # Capture argument names for branch functions
+        old_args = self.current_func_args
+        self.current_func_args = [arg.arg for arg in node.args.args]
+        node.body = [self.visit(n) for n in node.body]
+        self.current_func_args = old_args
+        return node
+
+    def visit_If(self, node):
+        # First recurse into subnodes
+        node = self.generic_visit(node)
+        test_node = node.test
+
+        # Case 1: simple assignment in both branches
+        if (
+            len(node.body) == 1
+            and isinstance(node.body[0], ast.Assign)
+            and len(node.orelse) == 1
+            and isinstance(node.orelse[0], ast.Assign)
+            and self.current_func_args is not None
+        ):
+            then_assign = node.body[0]
+            else_assign = node.orelse[0]
+            tgt = then_assign.targets[0]
+            if (
+                isinstance(tgt, ast.Name)
+                and isinstance(else_assign.targets[0], ast.Name)
+                and tgt.id == else_assign.targets[0].id
+            ):
+                self.counter += 1
+                then_name = f"{self.wrapper_name}_then_{self.counter}"
+                else_name = f"{self.wrapper_name}_else_{self.counter}"
+                then_expr = then_assign.value
+                else_expr = else_assign.value
+                # extract free variables
+                then_vars = sorted(
+                    {
+                        n.id
+                        for n in ast.walk(then_expr)
+                        if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load)
+                    }
+                )
+                else_vars = sorted(
+                    {
+                        n.id
+                        for n in ast.walk(else_expr)
+                        if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load)
+                    }
+                )
+                # build local funcs
+                then_args = [ast.arg(arg=v, annotation=None) for v in then_vars]
+                then_def = ast.FunctionDef(
+                    name=then_name,
+                    args=ast.arguments(
+                        posonlyargs=[],
+                        args=then_args,
+                        kwonlyargs=[],
+                        kw_defaults=[],
+                        defaults=[],
+                    ),
+                    body=[ast.Return(then_expr)],
+                    decorator_list=[],
+                    returns=None,
+                )
+                else_args = [ast.arg(arg=v, annotation=None) for v in else_vars]
+                else_def = ast.FunctionDef(
+                    name=else_name,
+                    args=ast.arguments(
+                        posonlyargs=[],
+                        args=else_args,
+                        kwonlyargs=[],
+                        kw_defaults=[],
+                        defaults=[],
+                    ),
+                    body=[ast.Return(else_expr)],
+                    decorator_list=[],
+                    returns=None,
+                )
+                # fix locations
+                for n in (then_def, else_def):
+                    ast.copy_location(n, node)
+                    ast.fix_missing_locations(n)
+                    assert hasattr(n, "lineno")
+                # wrapper call and assignment
+                then_args_tuple = ast.Tuple(
+                    [ast.Name(id=v, ctx=ast.Load()) for v in then_vars],
+                    ctx=ast.Load(),
+                )
+                else_args_tuple = ast.Tuple(
+                    [ast.Name(id=v, ctx=ast.Load()) for v in else_vars],
+                    ctx=ast.Load(),
+                )
+                call = ast.Call(
+                    func=ast.Name(id=self.wrapper_name, ctx=ast.Load()),
+                    args=[
+                        test_node,
+                        ast.Name(id=then_name, ctx=ast.Load()),
+                        ast.Name(id=else_name, ctx=ast.Load()),
+                        then_args_tuple,
+                        else_args_tuple,
+                    ],
+                    keywords=[],
+                )
+                assign = ast.Assign(targets=[tgt], value=call)
+                ast.copy_location(assign, node)
+                ast.fix_missing_locations(assign)
+                return [then_def, else_def, assign]
+
+        # Case 2: simple return in both branches
+        if (
+            len(node.body) == 1
+            and isinstance(node.body[0], ast.Return)
+            and len(node.orelse) == 1
+            and isinstance(node.orelse[0], ast.Return)
+            and self.current_func_args is not None
+        ):
+            then_ret = node.body[0]
+            else_ret = node.orelse[0]
+            then_expr = then_ret.value
+            else_expr = else_ret.value
+            self.counter += 1
+            then_name = f"{self.wrapper_name}_then_{self.counter}"
+            else_name = f"{self.wrapper_name}_else_{self.counter}"
+            # extract free variables
+            then_vars = sorted(
+                {
+                    n.id
+                    for n in ast.walk(then_expr)
+                    if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load)
+                }
+            )
+            else_vars = sorted(
+                {
+                    n.id
+                    for n in ast.walk(else_expr)
+                    if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load)
+                }
+            )
+
+            then_else_vars = set(_ for _ in [*then_vars, *else_vars] if _ != "torch")
+
+            # build local funcs
+            then_args = [ast.arg(arg=v, annotation=None) for v in then_else_vars]
+            then_def = ast.FunctionDef(
+                name=then_name,
+                args=ast.arguments(
+                    posonlyargs=[],
+                    args=then_args,
+                    kwonlyargs=[],
+                    kw_defaults=[],
+                    defaults=[],
+                ),
+                body=[ast.Return(then_expr)],
+                decorator_list=[],
+                returns=None,
+            )
+            else_args = [ast.arg(arg=v, annotation=None) for v in then_else_vars]
+            else_def = ast.FunctionDef(
+                name=else_name,
+                args=ast.arguments(
+                    posonlyargs=[],
+                    args=else_args,
+                    kwonlyargs=[],
+                    kw_defaults=[],
+                    defaults=[],
+                ),
+                body=[ast.Return(else_expr)],
+                decorator_list=[],
+                returns=None,
+            )
+            for n in (then_def, else_def):
+                ast.copy_location(n, node)
+                ast.fix_missing_locations(n)
+            # wrapper call and return
+            then_else_args_list = ast.List(
+                [ast.Name(id=v, ctx=ast.Load()) for v in then_else_vars],
+                ctx=ast.Load(),
+            )
+
+            call = ast.Call(
+                func=ast.Name(id=self.wrapper_name, ctx=ast.Load()),
+                args=[
+                    test_node,
+                    ast.Name(id=then_name, ctx=ast.Load()),
+                    ast.Name(id=else_name, ctx=ast.Load()),
+                    then_else_args_list,
+                ],
+                keywords=[],
+            )
+            ret = ast.Return(call)
+            ast.copy_location(ret, node)
+            ast.fix_missing_locations(ret)
+            return [then_def, else_def, ret]
+        return node
+
+    def generic_visit(self, node):
+        return super().generic_visit(node)
+
+
+class RewrittenMethod:
+    """
+    Stores a rewritten method using
+    :func:`onnx_diagnostic.torch_export_patches.patch_module.transform_method`.
+
+    :param tree: ast tree
+    :param func: callable compiled from the tree
+    """
+
+    def __init__(self, tree, func):
+        self.tree = tree
+        self.func = func
+
+    @property
+    def code(self) -> str:
+        """Returns the source."""
+        return ast.unparse(self.tree)
+
+    def __repr__(self):
+        "usual"
+        return f"{self.__class__.__name__}({self.func})"
+
+
+def transform_method(func: Callable, if_name="torch_cond") -> RewrittenMethod:
+    """
+    Returns a new function based on `func` where every test (if)
+    is replaced by a call to :func:`torch.cond`.
+
+    :param func: method or function to rewrite
+    :param if_name: function calling the test
+    :return: rewritten method
+    """
+    # Retrieve source of the function
+    src = inspect.getsource(func)
+    # Parse into AST
+    tree = ast.parse(textwrap.dedent(src))
+    # Apply transformation
+    transformer = RewriteControlFlow(if_name)
+    new_tree = transformer.visit(tree)
+    ast.fix_missing_locations(new_tree)
+    _settl(new_tree, 0)
+    try:
+        mod = compile(new_tree, filename="<ast>", mode="exec")
+    except TypeError as e:
+        if 'required field "lineno" missing from stmt' in str(e):
+            # Could not find a way to avoid compilng a string.
+            # The error message still pops up without indicating which node is not
+            # properly set.
+            code = ast.unparse(new_tree)
+            mod = compile(code, filename="<source>", mode="exec")
+        else:
+            kws = dict(include_attributes=True, annotate_fields=True, indent=4)
+            raise RuntimeError(
+                f"Unable to compile code\n--CODE--\n"
+                f"{ast.unparse(new_tree)}\n--TREE--\n"
+                f"{ast.dump(new_tree, **kws)}"
+            ) from e
+    namespace: Dict[str, type] = {}
+    globs = func.__globals__.copy()
+    globs[if_name] = torch.cond
+    exec(mod, globs, namespace)
+    new_func = namespace.get(func.__name__)
+    if not isinstance(new_func, types.FunctionType):
+        raise RuntimeError("Transformed function not found")
+    return RewrittenMethod(new_tree, new_func)

onnx_diagnostic/torch_models/hghub/hub_api.py

@@ -1,9 +1,10 @@
 import copy
 import functools
+import json
 import os
 from typing import Any, Dict, List, Optional, Union
 import transformers
-from huggingface_hub import HfApi, model_info
+from huggingface_hub import HfApi, model_info, hf_hub_download
 from ...helpers.config_helper import update_config
 from . import hub_data_cached_configs
 from .hub_data import __date__, __data_tasks__, load_architecture_task, __data_arch_values__
@@ -59,7 +60,11 @@ def get_cached_configuration(name: str, **kwargs) -> Optional[transformers.Pretr
 
 
 def get_pretrained_config(
-    model_id: str, trust_remote_code: bool = True, use_preinstalled: bool = True, **kwargs
+    model_id: str,
+    trust_remote_code: bool = True,
+    use_preinstalled: bool = True,
+    subfolder: Optional[str] = None,
+    **kwargs,
 ) -> Any:
     """
     Returns the config for a model_id.
@@ -71,13 +76,32 @@ def get_pretrained_config(
         accessing the network, if available, it is returned by
         :func:`get_cached_configuration`, the cached list is mostly for
         unit tests
+    :param subfolder: subfolder for the given model id
     :param kwargs: additional kwargs
     :return: a configuration
     """
     if use_preinstalled:
-        conf = get_cached_configuration(model_id, **kwargs)
+        conf = get_cached_configuration(model_id, subfolder=subfolder, **kwargs)
         if conf is not None:
             return conf
+    if subfolder:
+        try:
+            return transformers.AutoConfig.from_pretrained(
+                model_id, trust_remote_code=trust_remote_code, subfolder=subfolder, **kwargs
+            )
+        except ValueError:
+            # Then we try to download it.
+            config = hf_hub_download(
+                model_id, filename="config.json", subfolder=subfolder, **kwargs
+            )
+            try:
+                return transformers.AutoConfig.from_pretrained(
+                    config, trust_remote_code=trust_remote_code, **kwargs
+                )
+            except ValueError:
+                # Diffusers uses a dictionayr.
+                with open(config, "r") as f:
+                    return json.load(f)
     return transformers.AutoConfig.from_pretrained(
         model_id, trust_remote_code=trust_remote_code, **kwargs
     )
@@ -88,6 +112,15 @@ def get_model_info(model_id) -> Any:
     return model_info(model_id)
 
 
+def _guess_task_from_config(config: Any) -> Optional[str]:
+    """Tries to infer a task from the configuration."""
+    if hasattr(config, "bbox_loss_coefficient") and hasattr(config, "giou_loss_coefficient"):
+        return "object-detection"
+    if hasattr(config, "architecture") and config.architecture:
+        return task_from_arch(config.architecture)
+    return None
+
+
 @functools.cache
 def task_from_arch(arch: str, default_value: Optional[str] = None) -> str:
     """
@@ -126,7 +159,7 @@ def task_from_id(
     :param default_value: if specified, the function returns this value
         if the task cannot be determined
     :param pretrained: uses the config
-    :param fall_back_to_pretrained: balls back to pretrained config
+    :param fall_back_to_pretrained: falls back to pretrained config
     :return: task
     """
     if not pretrained:
@@ -139,6 +172,9 @@ def task_from_id(
     try:
         return config.pipeline_tag
     except AttributeError:
+        guess = _guess_task_from_config(config)
+        if guess is not None:
+            return guess
         assert config.architectures is not None and len(config.architectures) == 1, (
             f"Cannot return the task of {model_id!r}, pipeline_tag is not setup, "
             f"architectures={config.architectures} in config={config}"

onnx_diagnostic/torch_models/hghub/hub_data.py

@@ -78,6 +78,7 @@ __data_arch__ = textwrap.dedent(
     MobileBertModel,feature-extraction
     MobileNetV1Model,image-feature-extraction
     MobileNetV2Model,image-feature-extraction
+    mobilenetv3_small_100,image-classification
     MobileViTForImageClassification,image-classification
     ModernBertForMaskedLM,fill-mask
     Phi4MMForCausalLM,MoE
@@ -124,6 +125,7 @@ __data_arch__ = textwrap.dedent(
     T5ForConditionalGeneration,text2text-generation
     TableTransformerModel,image-feature-extraction
     TableTransformerForObjectDetection,object-detection
+    UNet2DConditionModel,text-to-image
     UniSpeechForSequenceClassification,audio-classification
     ViTForImageClassification,image-classification
     ViTMAEModel,image-feature-extraction
@@ -162,6 +164,7 @@ __data_tasks__ = [
     "sentence-similarity",
     "text-classification",
     "text-generation",
+    "text-to-image",
     "text-to-audio",
     "text2text-generation",
     "zero-shot-image-classification",
@@ -202,7 +205,7 @@ def load_models_testing() -> List[str]:
 @functools.cache
 def load_architecture_task() -> Dict[str, str]:
     """
-    Returns a dictionary mapping architecture to task.
+    Returns a dictionary mapping architectures to tasks.
 
     import pprint
     from onnx_diagnostic.torch_models.hghub.hub_data import load_architecture_task

onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py

@@ -3640,3 +3640,213 @@ def _ccached_facebook_bart_base():
             "vocab_size": 50265,
         }
     )
+
+
+def _ccached_hustvl_yolos_tiny():
+    "hustvl/yolos-tiny"
+    return transformers.YolosConfig(
+        **{
+            "architectures": ["YolosForObjectDetection"],
+            "attention_probs_dropout_prob": 0.0,
+            "auxiliary_loss": false,
+            "bbox_cost": 5,
+            "bbox_loss_coefficient": 5,
+            "class_cost": 1,
+            "eos_coefficient": 0.1,
+            "giou_cost": 2,
+            "giou_loss_coefficient": 2,
+            "hidden_act": "gelu",
+            "hidden_dropout_prob": 0.0,
+            "hidden_size": 192,
+            "id2label": {
+                "0": "N/A",
+                "1": "person",
+                "2": "bicycle",
+                "3": "car",
+                "4": "motorcycle",
+                "5": "airplane",
+                "6": "bus",
+                "7": "train",
+                "8": "truck",
+                "9": "boat",
+                "10": "traffic light",
+                "11": "fire hydrant",
+                "12": "N/A",
+                "13": "stop sign",
+                "14": "parking meter",
+                "15": "bench",
+                "16": "bird",
+                "17": "cat",
+                "18": "dog",
+                "19": "horse",
+                "20": "sheep",
+                "21": "cow",
+                "22": "elephant",
+                "23": "bear",
+                "24": "zebra",
+                "25": "giraffe",
+                "26": "N/A",
+                "27": "backpack",
+                "28": "umbrella",
+                "29": "N/A",
+                "30": "N/A",
+                "31": "handbag",
+                "32": "tie",
+                "33": "suitcase",
+                "34": "frisbee",
+                "35": "skis",
+                "36": "snowboard",
+                "37": "sports ball",
+                "38": "kite",
+                "39": "baseball bat",
+                "40": "baseball glove",
+                "41": "skateboard",
+                "42": "surfboard",
+                "43": "tennis racket",
+                "44": "bottle",
+                "45": "N/A",
+                "46": "wine glass",
+                "47": "cup",
+                "48": "fork",
+                "49": "knife",
+                "50": "spoon",
+                "51": "bowl",
+                "52": "banana",
+                "53": "apple",
+                "54": "sandwich",
+                "55": "orange",
+                "56": "broccoli",
+                "57": "carrot",
+                "58": "hot dog",
+                "59": "pizza",
+                "60": "donut",
+                "61": "cake",
+                "62": "chair",
+                "63": "couch",
+                "64": "potted plant",
+                "65": "bed",
+                "66": "N/A",
+                "67": "dining table",
+                "68": "N/A",
+                "69": "N/A",
+                "70": "toilet",
+                "71": "N/A",
+                "72": "tv",
+                "73": "laptop",
+                "74": "mouse",
+                "75": "remote",
+                "76": "keyboard",
+                "77": "cell phone",
+                "78": "microwave",
+                "79": "oven",
+                "80": "toaster",
+                "81": "sink",
+                "82": "refrigerator",
+                "83": "N/A",
+                "84": "book",
+                "85": "clock",
+                "86": "vase",
+                "87": "scissors",
+                "88": "teddy bear",
+                "89": "hair drier",
+                "90": "toothbrush",
+            },
+            "image_size": [800, 1333],
+            "initializer_range": 0.02,
+            "intermediate_size": 768,
+            "label2id": {
+                "N/A": 83,
+                "airplane": 5,
+                "apple": 53,
+                "backpack": 27,
+                "banana": 52,
+                "baseball bat": 39,
+                "baseball glove": 40,
+                "bear": 23,
+                "bed": 65,
+                "bench": 15,
+                "bicycle": 2,
+                "bird": 16,
+                "boat": 9,
+                "book": 84,
+                "bottle": 44,
+                "bowl": 51,
+                "broccoli": 56,
+                "bus": 6,
+                "cake": 61,
+                "car": 3,
+                "carrot": 57,
+                "cat": 17,
+                "cell phone": 77,
+                "chair": 62,
+                "clock": 85,
+                "couch": 63,
+                "cow": 21,
+                "cup": 47,
+                "dining table": 67,
+                "dog": 18,
+                "donut": 60,
+                "elephant": 22,
+                "fire hydrant": 11,
+                "fork": 48,
+                "frisbee": 34,
+                "giraffe": 25,
+                "hair drier": 89,
+                "handbag": 31,
+                "horse": 19,
+                "hot dog": 58,
+                "keyboard": 76,
+                "kite": 38,
+                "knife": 49,
+                "laptop": 73,
+                "microwave": 78,
+                "motorcycle": 4,
+                "mouse": 74,
+                "orange": 55,
+                "oven": 79,
+                "parking meter": 14,
+                "person": 1,
+                "pizza": 59,
+                "potted plant": 64,
+                "refrigerator": 82,
+                "remote": 75,
+                "sandwich": 54,
+                "scissors": 87,
+                "sheep": 20,
+                "sink": 81,
+                "skateboard": 41,
+                "skis": 35,
+                "snowboard": 36,
+                "spoon": 50,
+                "sports ball": 37,
+                "stop sign": 13,
+                "suitcase": 33,
+                "surfboard": 42,
+                "teddy bear": 88,
+                "tennis racket": 43,
+                "tie": 32,
+                "toaster": 80,
+                "toilet": 70,
+                "toothbrush": 90,
+                "traffic light": 10,
+                "train": 7,
+                "truck": 8,
+                "tv": 72,
+                "umbrella": 28,
+                "vase": 86,
+                "wine glass": 46,
+                "zebra": 24,
+            },
+            "layer_norm_eps": 1e-12,
+            "model_type": "yolos",
+            "num_attention_heads": 3,
+            "num_channels": 3,
+            "num_detection_tokens": 100,
+            "num_hidden_layers": 12,
+            "patch_size": 16,
+            "qkv_bias": true,
+            "torch_dtype": "float32",
+            "transformers_version": "4.19.0.dev0",
+            "use_mid_position_embeddings": false,
+        }
+    )

onnx_diagnostic/torch_models/hghub/model_inputs.py

@@ -4,7 +4,7 @@ import torch
 import transformers
 from ...helpers.config_helper import update_config
 from ...tasks import reduce_model_config, random_input_kwargs
-from .hub_api import task_from_arch, get_pretrained_config
+from .hub_api import task_from_arch, task_from_id, get_pretrained_config
 
 
 def get_untrained_model_with_inputs(
@@ -18,6 +18,7 @@ def get_untrained_model_with_inputs(
     same_as_pretrained: bool = False,
     use_preinstalled: bool = True,
     add_second_input: bool = False,
+    subfolder: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     Gets a non initialized model similar to the original model
@@ -37,6 +38,7 @@ def get_untrained_model_with_inputs(
     :param use_preinstalled: use preinstalled configurations
     :param add_second_input: provides a second inputs to check a model
         supports different shapes
+    :param subfolder: subfolder to use for this model id
     :return: dictionary with a model, inputs, dynamic shapes, and the configuration
 
     Example:
@@ -62,24 +64,39 @@ def get_untrained_model_with_inputs(
             print(f"[get_untrained_model_with_inputs] use preinstalled {model_id!r}")
     if config is None:
         config = get_pretrained_config(
-            model_id, use_preinstalled=use_preinstalled, **(model_kwargs or {})
+            model_id,
+            use_preinstalled=use_preinstalled,
+            subfolder=subfolder,
+            **(model_kwargs or {}),
         )
-    archs = config.architectures  # type: ignore
-    assert archs is not None and len(archs) == 1, (
+    if hasattr(config, "architecture") and config.architecture:
+        archs = [config.architecture]
+    if type(config) is dict:
+        assert "_class_name" in config, f"Unable to get the architecture from config={config}"
+        archs = [config["_class_name"]]
+    else:
+        archs = config.architectures  # type: ignore
+    task = None
+    if archs is None:
+        task = task_from_id(model_id)
+    assert task is not None or (archs is not None and len(archs) == 1), (
         f"Unable to determine the architecture for model {model_id!r}, "
         f"architectures={archs!r}, conf={config}"
     )
-    arch = archs[0]
-    if verbose:
-        print(f"[get_untrained_model_with_inputs] architecture={arch!r}")
     if verbose:
+        print(f"[get_untrained_model_with_inputs] architectures={archs!r}")
         print(f"[get_untrained_model_with_inputs] cls={config.__class__.__name__!r}")
-    task = task_from_arch(arch)
+    if task is None:
+        task = task_from_arch(archs[0])
     if verbose:
         print(f"[get_untrained_model_with_inputs] task={task!r}")
 
     # model kwagrs
     if dynamic_rope is not None:
+        assert (
+            type(config) is not dict
+        ), f"Unable to set dynamic_rope if the configuration is a dictionary\n{config}"
+        assert hasattr(config, "rope_scaling"), f"Missing 'rope_scaling' in\n{config}"
         config.rope_scaling = (
             {"rope_type": "dynamic", "factor": 10.0} if dynamic_rope else None
         )
@@ -106,7 +123,15 @@ def get_untrained_model_with_inputs(
     if inputs_kwargs:
         kwargs.update(inputs_kwargs)
 
-    model = getattr(transformers, arch)(config)
+    if archs is not None:
+        model = getattr(transformers, archs[0])(config)
+    else:
+        assert same_as_pretrained, (
+            f"Model {model_id!r} cannot be built, the model cannot be built. "
+            f"It must be downloaded. Use same_as_pretrained=True."
+        )
+        model = None
+
     # This line is important. Some models may produce different
     # outputs even with the same inputs in training mode.
     model.eval()

onnx_diagnostic/torch_models/test_helper.py

@@ -4,6 +4,8 @@ import os
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import time
 import onnx
+import onnxscript
+import onnxscript.rewriter.ort_fusions as ort_fusions
 import torch
 from ..export import CoupleInputsDynamicShapes
 from ..helpers import max_diff, string_type, string_diff
@@ -107,9 +109,12 @@ def _make_folder_name(
     optimization: Optional[str] = None,
     dtype: Optional[Union[str, torch.dtype]] = None,
     device: Optional[Union[str, torch.device]] = None,
+    subfolder: Optional[str] = None,
 ) -> str:
     "Creates a filename unique based on the given options."
     els = [model_id.replace("/", "_")]
+    if subfolder:
+        els.append(subfolder.replace("/", "_"))
     if exporter:
         els.append(exporter)
     if optimization:
@@ -222,6 +227,7 @@ def validate_model(
     ortfusiontype: Optional[str] = None,
     input_options: Optional[Dict[str, Any]] = None,
     model_options: Optional[Dict[str, Any]] = None,
+    subfolder: Optional[str] = None,
 ) -> Tuple[Dict[str, Union[int, float, str]], Dict[str, Any]]:
     """
     Validates a model.
@@ -254,11 +260,11 @@ def validate_model(
         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
     :return: two dictionaries, one with some metrics,
         another one with whatever the function produces
     """
     summary = version_summary()
-
     summary.update(
         dict(
             version_model_id=model_id,
@@ -280,7 +286,7 @@ def validate_model(
     folder_name = None
     if dump_folder:
         folder_name = _make_folder_name(
-            model_id, exporter, optimization, dtype=dtype, device=device
+            model_id, exporter, optimization, dtype=dtype, device=device, subfolder=subfolder
         )
         dump_folder = os.path.join(dump_folder, folder_name)
         if not os.path.exists(dump_folder):
@@ -291,11 +297,15 @@ def validate_model(
             print(f"[validate_model] dump into {folder_name!r}")
 
     if verbose:
-        print(f"[validate_model] validate model id {model_id!r}")
+        if subfolder:
+            print(f"[validate_model] validate model id {model_id!r}, subfolder={subfolder!r}")
+        else:
+            print(f"[validate_model] validate model id {model_id!r}")
         if model_options:
             print(f"[validate_model] model_options={model_options!r}")
         print(f"[validate_model] get dummy inputs with input_options={input_options}...")
         summary["model_id"] = model_id
+        summary["model_subfolder"] = subfolder or ""
 
     iop = input_options or {}
     mop = model_options or {}
@@ -305,7 +315,7 @@ def validate_model(
         summary,
         None,
         (
-            lambda mid=model_id, v=verbose, task=task, tr=trained, iop=iop: (
+            lambda mid=model_id, v=verbose, task=task, tr=trained, iop=iop, sub=subfolder: (
                 get_untrained_model_with_inputs(
                     mid,
                     verbose=v,
@@ -313,6 +323,7 @@ def validate_model(
                     same_as_pretrained=tr,
                     inputs_kwargs=iop,
                     model_kwargs=mop,
+                    subfolder=sub,
                 )
             )
         ),
@@ -917,11 +928,10 @@ def call_torch_export_onnx(
     :return: two dictionaries, one with some metrics,
         another one with whatever the function produces
     """
-    assert optimization in {
-        "",
-        "ir",
-        None,
-    }, f"unexpected value for optimization={optimization}"
+    available = {"", "ir", "os_ort"}
+    assert (
+        optimization in available
+    ), f"unexpected value for optimization={optimization}, available={available}"
     assert exporter in {
         "onnx-dynamo",
         "onnx-script",
@@ -1001,16 +1011,25 @@ def call_torch_export_onnx(
         print(epo)
         print("[call_torch_export_onnx] -- End of ONNXProgram")
 
-    if optimization == "ir":
+    if optimization in {"ir", "os_ort"}:
         if verbose:
             print(f"[call_torch_export_onnx] starts optimization={optimization!r}...")
-        _quiet_or_not_quiet(
-            quiet,
-            "export_onnx_opt_ir",
-            summary,
-            data,
-            (lambda epo=epo: epo.optimize()),
-        )
+        if optimization == "ir":
+            label, f_optim = "export_onnx_opt_ir", (lambda epo=epo: epo.optimize())
+        else:
+
+            def _os_ort_optim(epo):
+                onnxscript.optimizer.optimize_ir(epo.model)
+                optimized = ort_fusions.optimize_for_ort(epo.model)
+                if isinstance(optimized, tuple):
+                    for k, v in optimized[1].items():
+                        summary[f"op_opt_fused_{k}"] = v
+                    epo.model = optimized[0]
+                else:
+                    epo.model = optimized
+
+            label, f_optim = "export_onnx_opt_os_ort", (lambda epo=epo: _os_ort_optim(epo))
+        _quiet_or_not_quiet(quiet, label, summary, data, f_optim)
         if "ERR_export_onnx_opt_ir" in summary:
             return summary, data
         if verbose:
@@ -1039,21 +1058,27 @@ def call_torch_export_custom(
     :return: two dictionaries, one with some metrics,
         another one with whatever the function produces
     """
-    assert optimization in {
+    available = {
         "",
         "default",
         "default+onnxruntime",
+        "default+os_ort",
+        "default+onnxruntime+os_ort",
         None,
-    }, f"unexpected value for optimization={optimization}"
-    assert exporter in {
+    }
+    assert (
+        optimization in available
+    ), f"unexpected value for optimization={optimization}, available={available}"
+    available = {
         "custom",
         "custom-strict",
-        "custom-strict-dec",
+        "custom-strict-default",
         "custom-strict-all",
         "custom-nostrict",
-        "custom-nostrict-dec",
+        "custom-nostrict-default",
         "custom-nostrict-all",
-    }, f"Unexpected value for exporter={exporter!r}"
+    }
+    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)}"
     assert "inputs_export" in data, f"inputs_export is missing from data: {sorted(data)}"
     summary: Dict[str, Union[str, int, float]] = {}
@@ -1078,10 +1103,14 @@ def call_torch_export_custom(
     from experimental_experiment.torch_interpreter import to_onnx, ExportOptions
     from experimental_experiment.xbuilder import OptimizationOptions
 
+    spl = optimization.split("+") if optimization else []
+    os_ort = "os_ort" in spl
+    optimization = "+".join(_ for _ in spl if _ != "os_ort")
+
     export_options = ExportOptions(
         strict=strict,
         decomposition_table=(
-            "dec" if "-dec" in exporter else ("all" if "-all" in exporter else None)
+            "default" if "-default" in exporter else ("all" if "-all" in exporter else None)
         ),
     )
     options = OptimizationOptions(patterns=optimization) if optimization else None
@@ -1181,6 +1210,31 @@ def call_torch_export_custom(
     assert epo is not None, "no onnx export was found"
     if verbose:
         print("[call_torch_export_custom] done (export)")
+
+    if os_ort:
+        if verbose:
+            print("[call_torch_export_custom] conversion to IR...")
+        begin = time.perf_counter()
+        ir_model = epo.to_ir()
+        duration = time.perf_counter() - begin
+        summary["time_optim_to_ir"] = duration
+        if verbose:
+            print(f"[call_torch_export_custom] done in {duration}")
+            print("[call_torch_export_custom] start optimization...")
+        begin = time.perf_counter()
+        onnxscript.optimizer.optimize_ir(ir_model)
+        ir_optimized = ort_fusions.optimize_for_ort(ir_model)
+        if isinstance(ir_optimized, tuple):
+            report = ir_optimized[1]
+            for k, v in report.items():
+                summary[f"op_opt_fused_{k}"] = v
+            ir_optimized = ir_optimized[0]
+            epo.model = ir_optimized
+        duration = time.perf_counter() - begin
+        summary["time_optim_os_ort"] = duration
+        if verbose:
+            print(f"[call_torch_export_custom] done in {duration}")
+
     data["onnx_program"] = epo
     return summary, data
 

{onnx_diagnostic-0.4.3.dist-info → onnx_diagnostic-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.4.3
+Version: 0.4.4
 Summary: Investigate ONNX models
 Home-page: https://github.com/sdpython/onnx-diagnostic
 Author: Xavier Dupré
@@ -93,6 +93,11 @@ or
 Enlightening Examples
 +++++++++++++++++++++
 
+**Where to start to export a model**
+
+* `Export microsoft/phi-2
+  <https://sdpython.github.io/doc/onnx-diagnostic/dev/auto_examples/plot_export_tiny_phi2.html>`_
+
 **Torch Export**
 
 * `Use DYNAMIC or AUTO when exporting if dynamic shapes has constraints

{onnx_diagnostic-0.4.3.dist-info → onnx_diagnostic-0.4.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-onnx_diagnostic/__init__.py,sha256=opPQ2jwxhWOe2Y2oDiKVTmNL4w0H1Gl0G921alsi0NM,164
+onnx_diagnostic/__init__.py,sha256=VQWqNIBvo3L_1EFs9AQFHV8psqXB7jqUazJt4CrKt04,164
 onnx_diagnostic/__main__.py,sha256=YmyV_Aq_ianDlHyKLHMa6h8YK3ZmFPpLVHLKjM91aCk,79
-onnx_diagnostic/_command_lines_parser.py,sha256=kOECT1BccZc38vmVc3jF3xvXGDpcocvLuUGoPkzte08,14753
+onnx_diagnostic/_command_lines_parser.py,sha256=hwh-o6DfkO9Oj1TNqC2RGgfO_lXnZlyobH16Kzffyx4,14917
 onnx_diagnostic/doc.py,sha256=MTuT7Kxyvn7KEy84liQeFeqhugJrUQhjjpx21F72Uxw,926
 onnx_diagnostic/ext_test_case.py,sha256=JTKlAXZL0EIzRCNUjP2VWHq7g9ueFSFd18JVrJY9SFM,41404
 onnx_diagnostic/export/__init__.py,sha256=yEIoWiOeTwBsDhyYt2fTKuhtA0Ya1J9u9ZzMTOTWaWs,101
@@ -49,40 +49,42 @@ onnx_diagnostic/reference/ops/op_skip_layer_normalization.py,sha256=oJ7fQNx2iQh9
 onnx_diagnostic/reference/ops/op_slice.py,sha256=yRxfYBs8b7QezyyG9JHCD8MIJHij2qR2NNDpBmD3FJI,705
 onnx_diagnostic/reference/ops/op_transpose_cast.py,sha256=ifef74rvh0Yvq1Zx51B4mfnISbxV9uRg9DFjkdL1_68,361
 onnx_diagnostic/reference/ops/op_tri_matrix.py,sha256=Yn2gxAyygcwtF5Hjau9ihXDAzul0BAkdqVimVahtFBU,519
-onnx_diagnostic/tasks/__init__.py,sha256=AkZDewmxKmLN86obwTIcPhpMWX2nOTPwKCSLwoJhXTM,1566
+onnx_diagnostic/tasks/__init__.py,sha256=G9q-yZf-bU8udb7YtwPXf4bkfZh0lEXXzSKcG2HKvEU,1610
 onnx_diagnostic/tasks/automatic_speech_recognition.py,sha256=oRoYy56M0Yv_WOcn1hJXv-R9wgHkJ8rbym7j7y8oslw,6851
 onnx_diagnostic/tasks/feature_extraction.py,sha256=V-T5NpZ6EimOz00weWWxGfksZ9jQ5ZQyaP-mxuCEuJo,2223
 onnx_diagnostic/tasks/fill_mask.py,sha256=POUtgvOWv8wTOVLqxPNsj_C2WBiBWkmM72Z9mNlNqxI,2341
-onnx_diagnostic/tasks/image_classification.py,sha256=hxbvjSNLtewfY2PCkFhjxfBu0yHcTeRSRd79WSzBe2k,3527
+onnx_diagnostic/tasks/image_classification.py,sha256=qgT9tbXby3dACZyXXjvfpm0a7-ey2-vxMCXtjoDusJw,4210
 onnx_diagnostic/tasks/image_text_to_text.py,sha256=6rKbts_p05VZL8wufJa6NP-MhxUOU-fuTAks5QfUVVQ,6037
 onnx_diagnostic/tasks/mixture_of_expert.py,sha256=orMx8Ly4DO0Po0tEmme4gi2flPIGip4TaAyxVik4Zgg,2685
+onnx_diagnostic/tasks/object_detection.py,sha256=o1T8NMztjdFAFA-Z5efx-8nd9W7YZZcbE8Ag5wKVxZA,3930
 onnx_diagnostic/tasks/sentence_similarity.py,sha256=okQ-TQR8j1a92_N-eT6xN56rjtu26CdlU_pk88gdbGs,2356
 onnx_diagnostic/tasks/text2text_generation.py,sha256=jaJLQqKk38mAop7O3zCFQjUvmYmFTYWDVgzT7dSJPOw,7032
 onnx_diagnostic/tasks/text_classification.py,sha256=OgC_G9iumzTjTNUEvMoFFNTHCD8_BkdvdYC4jUsfpHM,2412
-onnx_diagnostic/tasks/text_generation.py,sha256=fTasu-igW-f9dyhYN4qXYkTWZU1ppgK37cmpvXV3i08,10215
+onnx_diagnostic/tasks/text_generation.py,sha256=Wv8DamBHte355wXe_tAeVxG4EL20y86fu7JEmUM75to,10385
 onnx_diagnostic/tasks/zero_shot_image_classification.py,sha256=N3cEG1Lq95wS1N_CWUUUCU5j-4Tp5eR8Ce68U8THYAk,4380
-onnx_diagnostic/torch_export_patches/__init__.py,sha256=uRqg0-KSs_DhDnzrVp-TG2vfcDBO4HlsNkEg7RomQL0,246
+onnx_diagnostic/torch_export_patches/__init__.py,sha256=SGR2aCWfxl8--rBF3_Zm0h6ovGyp8HknhkUsS1NyVNM,675
 onnx_diagnostic/torch_export_patches/onnx_export_errors.py,sha256=9WQUBAp5okQL9aJJKyp23ZumBnKt-qahcr94a9MYWxA,16083
 onnx_diagnostic/torch_export_patches/onnx_export_serialization.py,sha256=1s1LqgqOL_hV6yqT7sgxzTKSDAL267CcZgNq8K4oTZM,14898
 onnx_diagnostic/torch_export_patches/patch_inputs.py,sha256=FQrMjwvEgPqvYY7ptfULzfexW5yJHo6Pzq_p1HDkNrY,7680
+onnx_diagnostic/torch_export_patches/patch_module.py,sha256=66DXLeblDw5oLFJ-tGJYJzso4V2_q-96pQXR3L9nsvM,10891
 onnx_diagnostic/torch_export_patches/patches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_export_patches/patches/patch_torch.py,sha256=TKLxrIJUrQsy0mbQwFcvn5e2l_s4OGKu5jnwWDHC6LE,15670
 onnx_diagnostic/torch_export_patches/patches/patch_transformers.py,sha256=exiIq8zNZsY6QTzZVDMgU2ywGzs6-54Ic4vzTQ-26YQ,21863
 onnx_diagnostic/torch_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_models/llms.py,sha256=soyg4yC87ptGoeulJhKqw5opGmuLvH1pn_ZDXZ4Jr8E,90
-onnx_diagnostic/torch_models/test_helper.py,sha256=ad4C1vpnYkLMTrPMBdyk0OuUIUIAa7wP-zgCzPH88zc,46604
+onnx_diagnostic/torch_models/test_helper.py,sha256=odRN3eIrK3kkvJCWTnZruUZGqGZrKR6r_Dp0dXQRDbw,49091
 onnx_diagnostic/torch_models/hghub/__init__.py,sha256=vi1Q7YHdddj1soiBN42MSvJdFqe2_KUoWafHISjwOu8,58
-onnx_diagnostic/torch_models/hghub/hub_api.py,sha256=EjwsmdHhf9ub1K5UCQPxsKiTMZy1dsdcRvNmxoZrc98,8621
-onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=K9fu3NA530QEqYJcFTwACfsoRAIUrJoJLNtxDrUzM3c,7863
-onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=IYinZGm6-Ob7fQHg7rE1OE0t5muCsEq5TpQiMgEsrgs,245009
-onnx_diagnostic/torch_models/hghub/model_inputs.py,sha256=B5c_-T_Ub9Mxs_DxpP4_yb4im-85ftVvAcUBgsISp1o,5743
+onnx_diagnostic/torch_models/hghub/hub_api.py,sha256=BgM_p57Q0gT9GOhdrmOYcnbuTTzCWp80jS4OQqWwFhs,9990
+onnx_diagnostic/torch_models/hghub/hub_data.py,sha256=LLXq4KIYdz80JpRTV_liHNkJu6qBjdC2cH6E4v98yGg,7972
+onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py,sha256=dYL4E7-12JwhZQKuNhoDT1avb7V3Go5nZyaoPCGR92o,251610
+onnx_diagnostic/torch_models/hghub/model_inputs.py,sha256=XIFyadFg2cbDSqOCFMm7aimh15PVp7kxOnZ_oVhnjps,6770
 onnx_diagnostic/torch_models/untrained/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_models/untrained/llm_phi2.py,sha256=ynBTDHJHCk44NjLT_t6OiFDBdPP0rFGPteiONDxvztw,3708
 onnx_diagnostic/torch_models/untrained/llm_tiny_llm.py,sha256=7N3fGvT_4Mn4NbIo0Qk57c6DMc3OXGWyvj_P41rjwSY,3513
 onnx_diagnostic/torch_onnx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 onnx_diagnostic/torch_onnx/sbs.py,sha256=HEGDHhV9pfXxpBQrpOWPNWGMsNfOebWewyAazi9poV8,16872
-onnx_diagnostic-0.4.3.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
-onnx_diagnostic-0.4.3.dist-info/METADATA,sha256=AI3BrV-xYBj8qVBlnpPOMsKnIAtERv1fsjx7sA6hD-A,5496
-onnx_diagnostic-0.4.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-onnx_diagnostic-0.4.3.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
-onnx_diagnostic-0.4.3.dist-info/RECORD,,
+onnx_diagnostic-0.4.4.dist-info/licenses/LICENSE.txt,sha256=Vv6TXglX6Rc0d-f8aREhayhT-6PMQXEyOmI2NKlUCMc,1045
+onnx_diagnostic-0.4.4.dist-info/METADATA,sha256=9c5HUQruT58E_auU0qmqSKxoJMCEKz_MU3dGvhIi_G8,5659
+onnx_diagnostic-0.4.4.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+onnx_diagnostic-0.4.4.dist-info/top_level.txt,sha256=KwNkXewmcobM3ZT1DJLVWH6ebJzA5qKg7cWqKfpGNT4,16
+onnx_diagnostic-0.4.4.dist-info/RECORD,,

{onnx_diagnostic-0.4.3.dist-info → onnx_diagnostic-0.4.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any