onnx-diagnostic 0.7.3__py3-none-any.whl → 0.7.5__py3-none-any.whl

onnx_diagnostic/__init__.py

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

onnx_diagnostic/_command_lines_parser.py

@@ -349,6 +349,15 @@ def get_parser_validate() -> ArgumentParser:
             python -m onnx_diagnostic validate -m microsoft/Phi-4-mini-reasoning \\
                 --run -v 1 -o dump_test --no-quiet --repeat 2 --warmup 2 \\
                 --dtype float16 --device cuda --export modelbuilder
+
+            position_ids is usually not needed, they can be removed by adding:
+
+            --drop position_ids
+
+            The behaviour may be modified compare the original configuration,
+            the following argument can be rope_scaling to dynamic:
+
+            --mop \"rope_scaling={'rope_type': 'dynamic', 'factor': 10.0}\""
             """
         ),
         formatter_class=RawTextHelpFormatter,
@@ -403,10 +412,12 @@ def get_parser_validate() -> ArgumentParser:
     )
     parser.add_argument(
         "--inputs2",
-        default=True,
-        action=BooleanOptionalAction,
+        default=1,
+        type=int,
         help="Validates the model on a second set of inputs\n"
-        "to check the exported model supports dynamism.",
+        "to check the exported model supports dynamism. The values is used "
+        "as an increment to the first set of inputs. A high value may trick "
+        "a different behavior in the model and missed by the exporter.",
     )
     parser.add_argument(
         "--runtime",
@@ -422,7 +433,8 @@ def get_parser_validate() -> ArgumentParser:
     parser.add_argument(
         "--drop",
         help="Drops the following inputs names, it should be a list\n"
-        "with comma separated values.",
+        "with comma separated values, example:\n"
+        "--drop position_ids",
     )
     parser.add_argument(
         "--opset",
@@ -471,6 +483,12 @@ def get_parser_validate() -> ArgumentParser:
     parser.add_argument(
         "--warmup", default=0, type=int, help="number of times to run the model to do warmup"
     )
+    parser.add_argument(
+        "--outnames",
+        help="This comma separated list defines the output names "
+        "the onnx exporter should use.",
+        default="",
+    )
     return parser
 
 
@@ -530,6 +548,9 @@ def _cmd_validate(argv: List[Any]):
             repeat=args.repeat,
             warmup=args.warmup,
             inputs2=args.inputs2,
+            output_names=(
+                None if len(args.outnames.strip()) < 2 else args.outnames.strip().split(",")
+            ),
         )
         print("")
         print("-- summary --")
@@ -633,6 +654,27 @@ def _cmd_stats(argv: List[Any]):
         print("done.")
 
 
+class _ParseNamedDict(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        assert ":" in values, f"':' missing from {values!r}"
+        namespace_key, rest = values.split(":", 1)
+        pairs = rest.split(",")
+        inner_dict = {}
+
+        for pair in pairs:
+            if "=" not in pair:
+                raise argparse.ArgumentError(self, f"Expected '=' in pair '{pair}'")
+            key, value = pair.split("=", 1)
+            inner_dict[key] = value
+        assert inner_dict, f"Unable to parse {rest!r} into a dictionary"
+        if not hasattr(namespace, self.dest) or getattr(namespace, self.dest) is None:
+            setattr(namespace, self.dest, {})
+        assert isinstance(
+            getattr(namespace, self.dest), dict
+        ), f"Unexpected type for namespace.{self.dest}={getattr(namespace, self.dest)}"
+        getattr(namespace, self.dest).update({namespace_key: inner_dict})
+
+
 def get_parser_agg() -> ArgumentParser:
     parser = ArgumentParser(
         prog="agg",
@@ -641,13 +683,23 @@ def get_parser_agg() -> ArgumentParser:
             Aggregates statistics coming from benchmarks.
             Every run is a row. Every row is indexed by some keys,
             and produces values. Every row has a date.
+            The data can come any csv files produces by benchmarks,
+            it can concatenates many csv files, or csv files inside zip files.
+            It produces an excel file with many tabs, one per view.
             """
         ),
         epilog=textwrap.dedent(
             """
-            examples:\n
+            examples:
 
                 python -m onnx_diagnostic agg test_agg.xlsx raw/*.zip -v 1
+                python -m onnx_diagnostic agg agg.xlsx raw/*.zip raw/*.csv -v 1 \\
+                    --no-raw  --keep-last-date --filter-out "exporter:test-exporter"
+
+            Another to create timeseries:
+
+                python -m onnx_diagnostic agg history.xlsx raw/*.csv -v 1 --no-raw \\
+                    --no-recent
             """
         ),
         formatter_class=RawTextHelpFormatter,
@@ -725,7 +777,15 @@ def get_parser_agg() -> ArgumentParser:
         "--views",
         default="agg-suite,agg-all,disc,speedup,time,time_export,err,cmd,"
         "bucket-speedup,raw-short,counts,peak-gpu,onnx",
-        help="Views to add to the output files.",
+        help=textwrap.dedent(
+            """
+            Views to add to the output files. Each view becomes a tab.
+            A view is defined by its name, among
+            agg-suite, agg-all, disc, speedup, time, time_export, err,
+            cmd, bucket-speedup, raw-short, counts, peak-gpu, onnx.
+            Their definition is part of class CubeLogsPerformance.
+            """
+        ),
     )
     parser.add_argument(
         "--csv",
@@ -745,16 +805,24 @@ def get_parser_agg() -> ArgumentParser:
         help="adds a filter to filter out data, syntax is\n"
         '``"<column1>:<value1>;<value2>/<column2>:<value3>"`` ...',
     )
+    parser.add_argument(
+        "--sbs",
+        help=textwrap.dedent(
+            """
+            Defines an exporter to compare to another, there must be at least
+            two arguments defined with --sbs. Example:
+                --sbs dynamo:exporter=onnx-dynamo,opt=ir,attn_impl=eager
+                --sbs custom:exporter=custom,opt=default,attn_impl=eager
+            """
+        ),
+        action=_ParseNamedDict,
+    )
     return parser
 
 
 def _cmd_agg(argv: List[Any]):
-    from .helpers.log_helper import (
-        CubeLogsPerformance,
-        open_dataframe,
-        enumerate_csv_files,
-        filter_data,
-    )
+    from .helpers._log_helper import open_dataframe, enumerate_csv_files, filter_data
+    from .helpers.log_helper import CubeLogsPerformance
 
     parser = get_parser_agg()
     args = parser.parse_args(argv[1:])
@@ -800,6 +868,8 @@ def _cmd_agg(argv: List[Any]):
         verbose=args.verbose,
         csv=args.csv.split(","),
         raw=args.raw,
+        time_mask=True,
+        sbs=args.sbs,
     )
     if args.verbose:
         print(f"Wrote {args.output!r}")

onnx_diagnostic/export/shape_helper.py

@@ -30,6 +30,77 @@ def all_dynamic_shape_from_inputs(inputs: Any, dim_prefix: Any = "d") -> Any:
         )
         ds = all_dynamic_shape_from_inputs(inputs)
         pprint.pprint(ds)
+
+    For this function to work, patches must be enabled if :epkg:`transformers`
+    does not implement the serialization functions.
+
+    .. runpython::
+        :showcode:
+
+        import pprint
+        import torch
+        from onnx_diagnostic.helpers.cache_helper import (
+            make_dynamic_cache,
+            make_encoder_decoder_cache,
+            make_mamba_cache,
+            make_sliding_window_cache,
+            make_static_cache,
+        )
+        from onnx_diagnostic.export.shape_helper import all_dynamic_shape_from_inputs
+        from onnx_diagnostic.torch_export_patches import torch_export_patches
+
+        caches = [
+            make_dynamic_cache(
+                [
+                    (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                    (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                    (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                ]
+            ),
+            make_encoder_decoder_cache(
+                make_dynamic_cache(
+                    [
+                        (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                        (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                        (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                    ]
+                ),
+                make_dynamic_cache(
+                    [
+                        (torch.rand((5, 5, 5)), torch.rand((5, 5, 5))),
+                        (torch.rand((5, 5, 5)), torch.rand((5, 5, 5))),
+                        (torch.rand((5, 5, 5)), torch.rand((5, 5, 5))),
+                    ]
+                ),
+            ),
+            make_sliding_window_cache(
+                [
+                    (torch.rand((4, 5, 6, 7)), torch.rand((4, 5, 6, 7))),
+                    (torch.rand((4, 5, 6, 7)), torch.rand((4, 5, 6, 7))),
+                    (torch.rand((4, 5, 6, 7)), torch.rand((4, 5, 6, 7))),
+                ]
+            ),
+            make_static_cache(
+                [
+                    (torch.rand((4, 5, 6, 7)), torch.rand((4, 5, 6, 7))),
+                    (torch.rand((4, 5, 6, 7)), torch.rand((4, 5, 6, 7))),
+                    (torch.rand((4, 5, 6, 7)), torch.rand((4, 5, 6, 7))),
+                ],
+                max_cache_len=15,
+            ),
+            make_mamba_cache(
+                [
+                    (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                    (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                    (torch.rand((4, 4, 4)), torch.rand((4, 4, 4))),
+                ]
+            ),
+        ]
+
+        with torch_export_patches(patch_transformers=True):
+            for cache in caches:
+                print(f"-- {cache.__class__.__name__}")
+                pprint.pprint(all_dynamic_shape_from_inputs(cache))
     """
     if isinstance(dim_prefix, str):
         prefixes: Set[str] = set()