onnxruntime-directml 1.20.0__cp313-cp313-win_amd64.whl

onnxruntime/tools/onnxruntime_test.py

@@ -0,0 +1,164 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+# --------------------------------------------------------------------------
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from timeit import default_timer as timer
+
+import numpy as np
+
+import onnxruntime as onnxrt
+
+float_dict = {
+    "tensor(float16)": "float16",
+    "tensor(float)": "float32",
+    "tensor(double)": "float64",
+}
+
+integer_dict = {
+    "tensor(int32)": "int32",
+    "tensor(int8)": "int8",
+    "tensor(uint8)": "uint8",
+    "tensor(int16)": "int16",
+    "tensor(uint16)": "uint16",
+    "tensor(int64)": "int64",
+    "tensor(uint64)": "uint64",
+}
+
+
+def generate_feeds(sess, symbolic_dims: dict | None = None):
+    feeds = {}
+    symbolic_dims = symbolic_dims or {}
+    for input_meta in sess.get_inputs():
+        # replace any symbolic dimensions
+        shape = []
+        for dim in input_meta.shape:
+            if not dim:
+                # unknown dim
+                shape.append(1)
+            elif isinstance(dim, str):
+                # symbolic dim. see if we have a value otherwise use 1
+                if dim in symbolic_dims:
+                    shape.append(int(symbolic_dims[dim]))
+                else:
+                    shape.append(1)
+            else:
+                shape.append(dim)
+
+        if input_meta.type in float_dict:
+            feeds[input_meta.name] = np.random.rand(*shape).astype(float_dict[input_meta.type])
+        elif input_meta.type in integer_dict:
+            feeds[input_meta.name] = np.random.uniform(high=1000, size=tuple(shape)).astype(
+                integer_dict[input_meta.type]
+            )
+        elif input_meta.type == "tensor(bool)":
+            feeds[input_meta.name] = np.random.randint(2, size=tuple(shape)).astype("bool")
+        else:
+            print(f"unsupported input type {input_meta.type} for input {input_meta.name}")
+            sys.exit(-1)
+    return feeds
+
+
+# simple test program for loading onnx model, feeding all inputs and running the model num_iters times.
+def run_model(
+    model_path,
+    num_iters=1,
+    debug=None,
+    profile=None,
+    symbolic_dims=None,
+    feeds=None,
+    override_initializers=True,
+):
+    symbolic_dims = symbolic_dims or {}
+    if debug:
+        print(f"Pausing execution ready for debugger to attach to pid: {os.getpid()}")
+        print("Press key to continue.")
+        sys.stdin.read(1)
+
+    sess_options = None
+    if profile:
+        sess_options = onnxrt.SessionOptions()
+        sess_options.enable_profiling = True
+        sess_options.profile_file_prefix = os.path.basename(model_path)
+
+    sess = onnxrt.InferenceSession(
+        model_path,
+        sess_options=sess_options,
+        providers=onnxrt.get_available_providers(),
+    )
+    meta = sess.get_modelmeta()
+
+    if not feeds:
+        feeds = generate_feeds(sess, symbolic_dims)
+
+    if override_initializers:
+        # Starting with IR4 some initializers provide default values
+        # and can be overridden (available in IR4). For IR < 4 models
+        # the list would be empty
+        for initializer in sess.get_overridable_initializers():
+            shape = [dim if dim else 1 for dim in initializer.shape]
+            if initializer.type in float_dict:
+                feeds[initializer.name] = np.random.rand(*shape).astype(float_dict[initializer.type])
+            elif initializer.type in integer_dict:
+                feeds[initializer.name] = np.random.uniform(high=1000, size=tuple(shape)).astype(
+                    integer_dict[initializer.type]
+                )
+            elif initializer.type == "tensor(bool)":
+                feeds[initializer.name] = np.random.randint(2, size=tuple(shape)).astype("bool")
+            else:
+                print(f"unsupported initializer type {initializer.type} for initializer {initializer.name}")
+                sys.exit(-1)
+
+    start = timer()
+    for _i in range(num_iters):
+        outputs = sess.run([], feeds)  # fetch all outputs
+    end = timer()
+
+    print(f"model: {meta.graph_name}")
+    print(f"version: {meta.version}")
+    print(f"iterations: {num_iters}")
+    print(f"avg latency: {((end - start) * 1000) / num_iters} ms")
+
+    if profile:
+        trace_file = sess.end_profiling()
+        print(f"trace file written to: {trace_file}")
+
+    return 0, feeds, num_iters > 0 and outputs
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Simple ONNX Runtime Test Tool.")
+    parser.add_argument("model_path", help="model path")
+    parser.add_argument(
+        "num_iters",
+        nargs="?",
+        type=int,
+        default=1000,
+        help="model run iterations. default=1000",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="pause execution to allow attaching a debugger.",
+    )
+    parser.add_argument("--profile", action="store_true", help="enable chrome timeline trace profiling.")
+    parser.add_argument(
+        "--symbolic_dims",
+        default={},
+        type=lambda s: dict(x.split("=") for x in s.split(",")),
+        help="Comma separated name=value pairs for any symbolic dimensions in the model input. "
+        "e.g. --symbolic_dims batch=1,seqlen=5. "
+        "If not provided, the value of 1 will be used for all symbolic dimensions.",
+    )
+
+    args = parser.parse_args()
+    exit_code, _, _ = run_model(args.model_path, args.num_iters, args.debug, args.profile, args.symbolic_dims)
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

onnxruntime/tools/optimize_onnx_model.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import argparse
+import os
+import pathlib
+
+from .onnx_model_utils import get_optimization_level, optimize_model
+
+
+def optimize_model_helper():
+    parser = argparse.ArgumentParser(
+        f"{os.path.basename(__file__)}:{optimize_model_helper.__name__}",
+        description="""
+                                     Optimize an ONNX model using ONNX Runtime to the specified level.
+                                     See https://onnxruntime.ai/docs/performance/model-optimizations/graph-optimizations.html for more
+                                     details of the optimization levels.""",
+    )
+
+    parser.add_argument(
+        "--opt_level",
+        default="basic",
+        choices=["disable", "basic", "extended", "all"],
+        help="Optimization level to use.",
+    )
+    parser.add_argument(
+        "--log_level",
+        choices=["debug", "info", "warning", "error"],
+        type=str,
+        required=False,
+        default="error",
+        help="Log level. Defaults to Error so we don't get output about unused initializers "
+        "being removed. Warning or Info may be desirable in some scenarios.",
+    )
+
+    parser.add_argument("input_model", type=pathlib.Path, help="Provide path to ONNX model to update.")
+    parser.add_argument("output_model", type=pathlib.Path, help="Provide path to write optimized ONNX model to.")
+
+    args = parser.parse_args()
+
+    if args.log_level == "error":
+        log_level = 3
+    elif args.log_level == "debug":
+        log_level = 0  # ORT verbose level
+    elif args.log_level == "info":
+        log_level = 1
+    elif args.log_level == "warning":
+        log_level = 2
+
+    optimize_model(args.input_model, args.output_model, get_optimization_level(args.opt_level), log_level)
+
+
+if __name__ == "__main__":
+    optimize_model_helper()

onnxruntime/tools/ort_format_model/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import os
+import sys
+
+# need to add the path to the ORT flatbuffers python module before we import anything else here.
+# we also auto-magically adjust to whether we're running from the ORT repo, or from within the ORT python package
+script_dir = os.path.dirname(os.path.realpath(__file__))
+fbs_py_schema_dirname = "ort_flatbuffers_py"
+if os.path.isdir(os.path.join(script_dir, fbs_py_schema_dirname)):
+    # fbs bindings are in this directory, so we're running in the ORT python package
+    ort_fbs_py_parent_dir = script_dir
+else:
+    # running directly from ORT repo, so fbs bindings are under onnxruntime/core/flatbuffers
+    ort_root = os.path.abspath(os.path.join(script_dir, "..", "..", "..", ".."))
+    ort_fbs_py_parent_dir = os.path.join(ort_root, "onnxruntime", "core", "flatbuffers")
+
+sys.path.append(ort_fbs_py_parent_dir)
+
+from .operator_type_usage_processors import GloballyAllowedTypesOpTypeImplFilter  # noqa: E402, F401
+from .operator_type_usage_processors import OperatorTypeUsageManager  # noqa: E402, F401
+from .operator_type_usage_processors import OpTypeImplFilterInterface  # noqa: E402, F401
+from .ort_model_processor import OrtFormatModelProcessor  # noqa: E402, F401
+from .utils import create_config_from_models  # noqa: E402, F401