onnx-diagnostic 0.7.8__py3-none-any.whl → 0.7.10__py3-none-any.whl

onnx_diagnostic/torch_models/hghub/hub_data_cached_configs.py

@@ -4687,3 +4687,145 @@ def _ccached_zai_glm_45():
             },
         }
     )
+
+
+def _ccached_microsoft_phi3_mini_128k_instruct():
+    "microsoft/Phi-3-mini-128k-instruct"
+    return transformers.Phi3Config(
+        **{
+            "_name_or_path": "Phi-3-mini-128k-instruct",
+            "architectures": ["Phi3ForCausalLM"],
+            "attention_dropout": 0.0,
+            "auto_map": {
+                "AutoConfig": "configuration_phi3.Phi3Config",
+                "AutoModelForCausalLM": "modeling_phi3.Phi3ForCausalLM",
+            },
+            "bos_token_id": 1,
+            "embd_pdrop": 0.0,
+            "eos_token_id": 32000,
+            "hidden_act": "silu",
+            "hidden_size": 3072,
+            "initializer_range": 0.02,
+            "intermediate_size": 8192,
+            "max_position_embeddings": 131072,
+            "model_type": "phi3",
+            "num_attention_heads": 32,
+            "num_hidden_layers": 32,
+            "num_key_value_heads": 32,
+            "original_max_position_embeddings": 4096,
+            "pad_token_id": 32000,
+            "resid_pdrop": 0.0,
+            "rms_norm_eps": 1e-05,
+            "rope_scaling": {
+                "long_factor": [
+                    1.0700000524520874,
+                    1.1200000047683716,
+                    1.149999976158142,
+                    1.4199999570846558,
+                    1.5699999332427979,
+                    1.7999999523162842,
+                    2.129999876022339,
+                    2.129999876022339,
+                    3.009999990463257,
+                    5.910000324249268,
+                    6.950000286102295,
+                    9.070000648498535,
+                    9.930000305175781,
+                    10.710000038146973,
+                    11.130000114440918,
+                    14.609999656677246,
+                    15.409998893737793,
+                    19.809999465942383,
+                    37.279998779296875,
+                    38.279998779296875,
+                    38.599998474121094,
+                    40.12000274658203,
+                    46.20000457763672,
+                    50.940006256103516,
+                    53.66000747680664,
+                    54.9373893737793,
+                    56.89738845825195,
+                    57.28738784790039,
+                    59.98738479614258,
+                    60.86738586425781,
+                    60.887386322021484,
+                    61.71739196777344,
+                    62.91739273071289,
+                    62.957393646240234,
+                    63.41739273071289,
+                    63.8173942565918,
+                    63.83739471435547,
+                    63.897396087646484,
+                    63.93739700317383,
+                    64.06739807128906,
+                    64.11434936523438,
+                    64.12435150146484,
+                    64.15435028076172,
+                    64.19435119628906,
+                    64.24435424804688,
+                    64.57435607910156,
+                    64.69000244140625,
+                    64.76000213623047,
+                ],
+                "short_factor": [
+                    1.1,
+                    1.1,
+                    1.1,
+                    1.3000000000000003,
+                    1.3500000000000003,
+                    1.3500000000000003,
+                    1.4000000000000004,
+                    1.5500000000000005,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.000000000000001,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.0500000000000007,
+                    2.1000000000000005,
+                    2.1000000000000005,
+                    2.1500000000000004,
+                    2.25,
+                    2.25,
+                    2.25,
+                    2.25,
+                    2.25,
+                    2.3999999999999995,
+                    2.4499999999999993,
+                    2.499999999999999,
+                    2.6999999999999984,
+                    2.6999999999999984,
+                    2.7499999999999982,
+                    2.799999999999998,
+                    2.8999999999999977,
+                    3.049999999999997,
+                ],
+                "type": "longrope",
+            },
+            "rope_theta": 10000.0,
+            "sliding_window": 262144,
+            "tie_word_embeddings": false,
+            "torch_dtype": "bfloat16",
+            "transformers_version": "4.40.2",
+            "use_cache": true,
+            "attention_bias": false,
+            "vocab_size": 32064,
+        }
+    )

onnx_diagnostic/torch_models/hghub/model_inputs.py

@@ -8,6 +8,7 @@ import transformers
 from ...helpers.config_helper import update_config, build_diff_config
 from ...tasks import reduce_model_config, random_input_kwargs
 from .hub_api import task_from_arch, task_from_id, get_pretrained_config, download_code_modelid
+from .model_specific import HANDLED_MODELS, load_specific_model
 
 
 def _code_needing_rewriting(model: Any) -> Any:
@@ -73,7 +74,7 @@ def get_untrained_model_with_inputs(
         print("-- configuration:", pprint.pformat(data['configuration']))
     """
     assert not use_preinstalled or not use_only_preinstalled, (
-        f"model_id={model_id!r}, pretinstalled model is only available "
+        f"model_id={model_id!r}, preinstalled model is only available "
         f"if use_only_preinstalled is False."
     )
     if verbose:
@@ -89,145 +90,156 @@ def get_untrained_model_with_inputs(
             **(model_kwargs or {}),
         )
 
-    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}"
-    )
-    if verbose:
-        print(f"[get_untrained_model_with_inputs] architectures={archs!r}")
-        print(f"[get_untrained_model_with_inputs] cls={config.__class__.__name__!r}")
-    if task is None:
-        task = task_from_arch(archs[0], model_id=model_id, subfolder=subfolder)
-    if verbose:
-        print(f"[get_untrained_model_with_inputs] task={task!r}")
+    model, task, mkwargs, diff_config = None, None, {}, None
+    if use_pretrained and same_as_pretrained:
+        if model_id in HANDLED_MODELS:
+            model, task, config = load_specific_model(model_id, verbose=verbose)
 
-    # 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
+    if model is None:
+        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}"
         )
+        if verbose:
+            print(f"[get_untrained_model_with_inputs] architectures={archs!r}")
+            print(f"[get_untrained_model_with_inputs] cls={config.__class__.__name__!r}")
+        if task is None:
+            task = task_from_arch(archs[0], model_id=model_id, subfolder=subfolder)
+        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
+            )
 
-    # updating the configuration
-    config0 = copy.deepcopy(config)
-    mkwargs = reduce_model_config(config, task) if not same_as_pretrained else {}
-    if model_kwargs:
-        for k, v in model_kwargs.items():
-            if isinstance(v, dict):
-                if k in mkwargs:
-                    mkwargs[k].update(v)
+        # updating the configuration
+        config0 = copy.deepcopy(config)
+        mkwargs = reduce_model_config(config, task) if not same_as_pretrained else {}
+        if model_kwargs:
+            for k, v in model_kwargs.items():
+                if isinstance(v, dict):
+                    if k in mkwargs:
+                        mkwargs[k].update(v)
+                    else:
+                        mkwargs[k] = v
                 else:
                     mkwargs[k] = v
-            else:
-                mkwargs[k] = v
-    if mkwargs:
-        update_config(config, mkwargs)
-    try:
-        diff_config = build_diff_config(config0, config)
-    except (ValueError, AttributeError, TypeError) as e:
-        diff_config = f"DIFF CONFIG ERROR {e}"
-    if verbose:
-        if diff_config:
-            print("[get_untrained_model_with_inputs] -- updated config")
-            pprint.pprint(diff_config)
-            print("[get_untrained_model_with_inputs] --")
-
-    # SDPA
-    if model_kwargs and "attn_implementation" in model_kwargs:
-        if hasattr(config, "_attn_implementation_autoset"):
-            config._attn_implementation_autoset = False
-        config._attn_implementation = model_kwargs["attn_implementation"]  # type: ignore[union-attr]
+        if mkwargs:
+            update_config(config, mkwargs)
+        try:
+            diff_config = build_diff_config(config0, config)
+        except (ValueError, AttributeError, TypeError) as e:
+            diff_config = f"DIFF CONFIG ERROR {e}"
         if verbose:
+            if diff_config:
+                print("[get_untrained_model_with_inputs] -- updated config")
+                pprint.pprint(diff_config)
+                print("[get_untrained_model_with_inputs] --")
+
+        # SDPA
+        if model_kwargs and "attn_implementation" in model_kwargs:
+            if hasattr(config, "_attn_implementation_autoset"):
+                config._attn_implementation_autoset = False
+            config._attn_implementation = model_kwargs["attn_implementation"]  # type: ignore[union-attr]
+            if verbose:
+                print(
+                    f"[get_untrained_model_with_inputs] config._attn_implementation="
+                    f"{config._attn_implementation!r}"  # type: ignore[union-attr]
+                )
+        elif verbose:
             print(
-                f"[get_untrained_model_with_inputs] config._attn_implementation="
-                f"{config._attn_implementation!r}"  # type: ignore[union-attr]
+                f"[get_untrained_model_with_inputs] default config._attn_implementation="
+                f"{getattr(config, '_attn_implementation', '?')!r}"  # type: ignore[union-attr]
             )
-    elif verbose:
-        print(
-            f"[get_untrained_model_with_inputs] default config._attn_implementation="
-            f"{getattr(config, '_attn_implementation', '?')!r}"  # type: ignore[union-attr]
-        )
-
-    if type(config) is dict and "_diffusers_version" in config:
-        import diffusers
 
-        package_source = diffusers
-    else:
-        package_source = transformers
+        if type(config) is dict and "_diffusers_version" in config:
+            import diffusers
 
-    if use_pretrained:
-        model = transformers.AutoModel.from_pretrained(model_id, **mkwargs)
-    else:
-        if archs is not None:
-            try:
-                cls_model = getattr(package_source, archs[0])
-            except AttributeError as e:
-                # The code of the models is not in transformers but in the
-                # repository of the model. We need to download it.
-                pyfiles = download_code_modelid(model_id, verbose=verbose)
-                if pyfiles:
-                    if "." in archs[0]:
-                        cls_name = archs[0]
-                    else:
-                        modeling = [_ for _ in pyfiles if "/modeling_" in _]
-                        assert len(modeling) == 1, (
-                            f"Unable to guess the main file implemented class {archs[0]!r} "
-                            f"from {pyfiles}, found={modeling}."
-                        )
-                        last_name = os.path.splitext(os.path.split(modeling[0])[-1])[0]
-                        cls_name = f"{last_name}.{archs[0]}"
-                    if verbose:
-                        print(
-                            f"[get_untrained_model_with_inputs] custom code for {cls_name!r}"
-                        )
-                        print(
-                            f"[get_untrained_model_with_inputs] from folder "
-                            f"{os.path.split(pyfiles[0])[0]!r}"
-                        )
-                    cls_model = (
-                        transformers.dynamic_module_utils.get_class_from_dynamic_module(
-                            cls_name,
-                            pretrained_model_name_or_path=os.path.split(pyfiles[0])[0],
-                        )
-                    )
-                else:
-                    raise AttributeError(
-                        f"Unable to find class 'tranformers.{archs[0]}'. "
-                        f"The code needs to be downloaded, config="
-                        f"\n{pprint.pformat(config)}."
-                    ) from e
+            package_source = diffusers
         else:
-            assert same_as_pretrained and use_pretrained, (
-                f"Model {model_id!r} cannot be built, the model cannot be built. "
-                f"It must be downloaded. Use same_as_pretrained=True "
-                f"and use_pretrained=True."
-            )
+            package_source = transformers
 
-        try:
-            if type(config) is dict:
-                model = cls_model(**config)
+        if use_pretrained:
+            model = transformers.AutoModel.from_pretrained(
+                model_id, trust_remote_code=True, **mkwargs
+            )
+        else:
+            if archs is not None:
+                try:
+                    cls_model = getattr(package_source, archs[0])
+                except AttributeError as e:
+                    # The code of the models is not in transformers but in the
+                    # repository of the model. We need to download it.
+                    pyfiles = download_code_modelid(model_id, verbose=verbose)
+                    if pyfiles:
+                        if "." in archs[0]:
+                            cls_name = archs[0]
+                        else:
+                            modeling = [_ for _ in pyfiles if "/modeling_" in _]
+                            assert len(modeling) == 1, (
+                                f"Unable to guess the main file implemented class "
+                                f"{archs[0]!r} from {pyfiles}, found={modeling}."
+                            )
+                            last_name = os.path.splitext(os.path.split(modeling[0])[-1])[0]
+                            cls_name = f"{last_name}.{archs[0]}"
+                        if verbose:
+                            print(
+                                f"[get_untrained_model_with_inputs] "
+                                f"custom code for {cls_name!r}"
+                            )
+                            print(
+                                f"[get_untrained_model_with_inputs] from folder "
+                                f"{os.path.split(pyfiles[0])[0]!r}"
+                            )
+                        cls_model = (
+                            transformers.dynamic_module_utils.get_class_from_dynamic_module(
+                                cls_name,
+                                pretrained_model_name_or_path=os.path.split(pyfiles[0])[0],
+                            )
+                        )
+                    else:
+                        raise AttributeError(
+                            f"Unable to find class 'tranformers.{archs[0]}'. "
+                            f"The code needs to be downloaded, config="
+                            f"\n{pprint.pformat(config)}."
+                        ) from e
             else:
-                model = cls_model(config)
-        except RuntimeError as e:
-            raise RuntimeError(
-                f"Unable to instantiate class {cls_model.__name__} with\n{config}"
-            ) from e
+                assert same_as_pretrained and use_pretrained, (
+                    f"Model {model_id!r} cannot be built, the model cannot be built. "
+                    f"It must be downloaded. Use same_as_pretrained=True "
+                    f"and use_pretrained=True."
+                )
+
+            try:
+                if type(config) is dict:
+                    model = cls_model(**config)
+                else:
+                    model = cls_model(config)
+            except RuntimeError as e:
+                raise RuntimeError(
+                    f"Unable to instantiate class {cls_model.__name__} with\n{config}"
+                ) from e
 
     # input kwargs
-    kwargs, fct = random_input_kwargs(config, task)
+    kwargs, fct = random_input_kwargs(config, task)  # type: ignore[arg-type]
     if verbose:
         print(f"[get_untrained_model_with_inputs] use fct={fct}")
         if os.environ.get("PRINT_CONFIG") in (1, "1"):
@@ -243,7 +255,8 @@ def get_untrained_model_with_inputs(
 
     res["input_kwargs"] = kwargs
     res["model_kwargs"] = mkwargs
-    res["dump_info"] = dict(config_diff=diff_config)
+    if diff_config is not None:
+        res["dump_info"] = dict(config_diff=diff_config)
 
     sizes = compute_model_size(model)
     res["model"] = model

onnx_diagnostic/torch_models/hghub/model_specific.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, Tuple
+
+
+class SpecificConfig:
+    """Creates a specific configuration for the loaded model."""
+
+    def __init__(self, **kwargs):
+        self._atts = set(kwargs)
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: getattr(self, k) for k in self._atts if k != "_atts"}
+
+
+def load_specific_model(
+    model_id: str, verbose: int = 0, **kwargs
+) -> Tuple[Any, str, SpecificConfig]:
+    """
+    Some models do not have any generic to be loaded.
+    This functions
+
+    :param model_id: model id
+    :param verbose: verbosiy
+    :param kwargs: additional parameters
+    :return: the model, the task associated to it, a configuration
+    """
+    assert model_id in HANDLED_MODELS, (
+        f"Unable to load model_id={model_id!r}, "
+        f"no function is mapped to this id in {sorted(HANDLED_MODELS)}"
+    )
+    return HANDLED_MODELS[model_id](model_id, verbose=verbose, **kwargs)
+
+
+def _load_bingsu_adetailer(model_id: str, verbose: int = 0) -> Tuple[Any, str, SpecificConfig]:
+    """See `Bingsu/adetailer <https://huggingface.co/Bingsu/adetailer>`_."""
+    from huggingface_hub import hf_hub_download
+    from ultralytics import YOLO
+
+    path = hf_hub_download("Bingsu/adetailer", "face_yolov8n.pt")
+    model = YOLO(path)
+    return (
+        model,
+        "object-detection",
+        SpecificConfig(architecture=type(model), image_size=224, num_channels=3),
+    )
+
+
+HANDLED_MODELS = {"Bingsu/adetailer": _load_bingsu_adetailer}

onnx_diagnostic/torch_models/untrained/llm_phi2.py

@@ -9,6 +9,7 @@ def get_phi2(
     sequence_length: int = 30,
     sequence_length2: int = 3,
     dynamic_rope: bool = False,
+    use_dim_not_dynamic: bool = False,
     **kwargs,
 ) -> Dict[str, Any]:
     """
@@ -18,6 +19,8 @@ def get_phi2(
     :param sequence_length: sequence length
     :param sequence_length2: new sequence length
     :param dynamic_rope: use dynamic rope (see :class:`transformers.LlamaConfig`)
+    :param use_dim_not_dynamic: uses ``torch.export.Dim`` and not a string for the batch size,
+        the sequence length and the cache length
     :param kwargs: to overwrite the configuration, example ``num_hidden_layers=1``
     :return: dictionary
 
@@ -62,9 +65,14 @@ def get_phi2(
     n_layers = config["num_hidden_layers"]
     num_key_value_heads = config["num_key_value_heads"]
 
-    batch = torch.export.Dim("batch", min=1, max=1024)
-    seq_length = torch.export.Dim("seq_length", min=1, max=4096)
-    cache_length = torch.export.Dim("cache_length", min=1, max=4096)
+    if use_dim_not_dynamic:
+        batch = torch.export.Dim("batch", min=1, max=1024)
+        seq_length = torch.export.Dim("seq_length", min=1, max=4096)
+        cache_length = torch.export.Dim("cache_length", min=1, max=4096)
+    else:
+        batch = "batch"
+        seq_length = "seq_length"
+        cache_length = "cache_length"
 
     shapes = {
         "input_ids": {0: batch, 1: seq_length},

onnx_diagnostic/torch_models/validate.py

@@ -352,7 +352,7 @@ def validate_model(
     The following exporters are available:
 
     * ``export-nostrict``: run :func:`torch.export.export` (..., strict=False)
-    * ``onnx-dynamo``: run :func:`torch.onnx.export` (..., dynamo=True),
+    * ``onnx-dynamo``: run :func:`torch.onnx.export` (...),
       models can be optimized with ``optimization`` in ``("ir", "os_ort")``
     * ``modelbuilder``: use :epkg:`ModelBuilder` to builds the onnx model
     * ``custom``: custom exporter (see :epkg:`experimental-experiment`),
@@ -496,9 +496,15 @@ def validate_model(
             cpl = CoupleInputsDynamicShapes(
                 tuple(), data[k], dynamic_shapes=data["dynamic_shapes"]
             )
-            data[k] = cpl.change_dynamic_dimensions(
-                desired_values=dict(batch=1), only_desired=True
-            )
+            if patch_kwargs.get("patch", False):
+                with torch_export_patches(**patch_kwargs):  # type: ignore[arg-type]
+                    data[k] = cpl.change_dynamic_dimensions(
+                        desired_values=dict(batch=1), only_desired=True
+                    )
+            else:
+                data[k] = cpl.change_dynamic_dimensions(
+                    desired_values=dict(batch=1), only_desired=True
+                )
             if verbose:
                 print(f"[validate_model] batch=1 --> {string_type(data[k], with_shape=True)}")
 
@@ -706,6 +712,7 @@ def validate_model(
                 print(f"[validate_model] done (dump onnx) in {duration}")
             data["onnx_filename"] = onnx_filename
             summary["time_onnx_save"] = duration
+            summary.update(compute_statistics(onnx_filename))
         if verbose:
             print(f"[validate_model] dumps statistics in {dump_folder!r}...")
         dump_stats = os.path.join(dump_folder, f"{folder_name}.stats")
@@ -809,6 +816,39 @@ def validate_model(
     return summary, data
 
 
+def compute_statistics(onnx_filename: str) -> Dict[str, Union[float, int]]:
+    """Computes some statistics on the model itself."""
+    onx = onnx.load(onnx_filename, load_external_data=False)
+
+    def node_iter(proto):
+        if isinstance(proto, onnx.ModelProto):
+            yield from node_iter(proto.graph)
+            for f in proto.functions:
+                yield from node_iter(f)
+        elif isinstance(proto, (onnx.FunctionProto, onnx.GraphProto)):
+            for node in proto.node:
+                yield node
+                for att in node.attribute:
+                    if att.type == onnx.AttributeProto.GRAPH:
+                        yield from node_iter(att.g)
+            if hasattr(proto, "initializer"):
+                yield from proto.initializer
+        else:
+            raise NotImplementedError(f"Unexpected type={type(proto)}")
+
+    counts: Dict[str, Union[float, int]] = {}
+    for proto in node_iter(onx):
+        if isinstance(proto, onnx.NodeProto):
+            key = f"n_node_{proto.op_type}"
+        else:
+            key = f"n_node_initializer_{proto.data_type}"
+
+        if key not in counts:
+            counts[key] = 0
+        counts[key] += 1
+    return counts
+
+
 def _validate_do_run_model(
     data, summary, key, tag, expected_tag, verbose, repeat, warmup, quiet
 ):

onnx_diagnostic/torch_onnx/sbs.py

@@ -205,7 +205,7 @@ def run_aligned(
             Model(), (x,), dynamic_shapes=({0: torch.export.Dim("batch")},)
         )
         onx = torch.onnx.export(
-            Model(), (x,), dynamic_shapes=({0: torch.export.Dim("batch")},), dynamo=True
+            Model(), (x,), dynamic_shapes=({0: torch.export.Dim("batch")},)
         ).model_proto
         results = list(
             map(

{onnx_diagnostic-0.7.8.dist-info → onnx_diagnostic-0.7.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-diagnostic
-Version: 0.7.8
+Version: 0.7.10
 Summary: Investigate ONNX models
 Home-page: https://github.com/sdpython/onnx-diagnostic
 Author: Xavier Dupré
@@ -95,7 +95,7 @@ Getting started
 
     git clone https://github.com/sdpython/onnx-diagnostic.git
     cd onnx-diagnostic
-    pip install -e .
+    pip install -e . -v
 
 or