API#

API 概述#

ONNX Runtime 加载 ONNX 图格式或 ORT 格式（用于内存和磁盘受限环境）的模型并运行推理。

模型消耗和产生的数据可以以最适合您场景的方式指定和访问。

加载并运行模型#

InferenceSession 是 ONNX Runtime 的主要类。它用于加载和运行 ONNX 模型，以及指定环境和应用程序配置选项。

session = onnxruntime.InferenceSession('model.onnx')

outputs = session.run([output names], inputs)

ONNX 和 ORT 格式模型由计算图组成，建模为运算符，并实现为针对不同硬件目标的优化运算符内核。ONNX Runtime 通过执行提供程序协调运算符内核的执行。执行提供程序包含特定执行目标（CPU、GPU、IoT 等）的内核集。执行提供程序使用 providers 参数进行配置。来自不同执行提供程序的内核按照提供程序列表给出的优先级顺序选择。在下面的示例中，如果 CUDA 执行提供程序中存在内核，则 ONNX Runtime 在 GPU 上执行该内核。否则，内核在 CPU 上执行。

session = onnxruntime.InferenceSession(
        model, providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)

可用执行提供程序的列表可以在这里找到： 执行提供程序。

从 ONNX Runtime 1.10 开始，您必须显式指定目标的执行提供程序。在 CPU 上运行时，API 仅允许不显式设置 provider 参数。在以下示例中，使用了 CUDAExecutionProvider 和 CPUExecutionProvider，假设应用程序在 NVIDIA GPU 上运行。请将这些替换为特定于您环境的执行提供程序。

您可以通过 session options 参数提供其他会话配置。例如，要在会话上启用性能分析

options = onnxruntime.SessionOptions()
options.enable_profiling=True
session = onnxruntime.InferenceSession(
        'model.onnx',
        sess_options=options,
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
)

数据输入和输出#

ONNX Runtime 推理会话使用其 OrtValue 类消耗和产生数据。

CPU 上的数据#

在 CPU 上（默认），OrtValue 可以映射到原生 Python 数据结构以及从原生 Python 数据结构映射而来：numpy 数组、字典和 numpy 数组列表。

# X is numpy array on cpu
ortvalue = onnxruntime.OrtValue.ortvalue_from_numpy(X)
ortvalue.device_name()  # 'cpu'
ortvalue.shape()        # shape of the numpy array X
ortvalue.data_type()    # 'tensor(float)'
ortvalue.is_tensor()    # 'True'
np.array_equal(ortvalue.numpy(), X)  # 'True'

# ortvalue can be provided as part of the input feed to a model
session = onnxruntime.InferenceSession(
        'model.onnx',
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
)
results = session.run(["Y"], {"X": ortvalue})

默认情况下，ONNX Runtime 始终将输入和输出放置在 CPU 上。如果输入或输出在 CPU 以外的设备上消耗和产生，则将数据放在 CPU 上可能不是最佳选择，因为它会在 CPU 和设备之间引入数据复制。

设备上的数据#

ONNX Runtime 支持自定义数据结构，该结构支持所有 ONNX 数据格式，允许用户将这些数据结构的支持数据放置在设备上，例如，在 CUDA 支持的设备上。在 ONNX Runtime 中，这称为 IOBinding。

要使用 IOBinding 功能，请将 InferenceSession.run() 替换为 InferenceSession.run_with_iobinding()。

图在 CPU 以外的设备（例如 CUDA）上执行。用户可以使用 IOBinding 将数据复制到 GPU 上。

# X is numpy array on cpu
session = onnxruntime.InferenceSession(
        'model.onnx',
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
)
io_binding = session.io_binding()
# OnnxRuntime will copy the data over to the CUDA device if 'input' is consumed by nodes on the CUDA device
io_binding.bind_cpu_input('input', X)
io_binding.bind_output('output')
session.run_with_iobinding(io_binding)
Y = io_binding.copy_outputs_to_cpu()[0]

输入数据在设备上，用户直接使用输入。输出数据在 CPU 上。

# X is numpy array on cpu
X_ortvalue = onnxruntime.OrtValue.ortvalue_from_numpy(X, 'cuda', 0)
session = onnxruntime.InferenceSession(
        'model.onnx',
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
)
io_binding = session.io_binding()
io_binding.bind_input(name='input', device_type=X_ortvalue.device_name(), device_id=0, element_type=np.float32, shape=X_ortvalue.shape(), buffer_ptr=X_ortvalue.data_ptr())
io_binding.bind_output('output')
session.run_with_iobinding(io_binding)
Y = io_binding.copy_outputs_to_cpu()[0]

输入数据和输出数据都在设备上，用户直接使用输入，并将输出也放置在设备上。

#X is numpy array on cpu
X_ortvalue = onnxruntime.OrtValue.ortvalue_from_numpy(X, 'cuda', 0)
Y_ortvalue = onnxruntime.OrtValue.ortvalue_from_shape_and_type([3, 2], np.float32, 'cuda', 0)  # Change the shape to the actual shape of the output being bound
session = onnxruntime.InferenceSession(
        'model.onnx',
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
)
io_binding = session.io_binding()
io_binding.bind_input(
        name='input',
        device_type=X_ortvalue.device_name(),
        device_id=0,
        element_type=np.float32,
        shape=X_ortvalue.shape(),
        buffer_ptr=X_ortvalue.data_ptr()
)
io_binding.bind_output(
        name='output',
        device_type=Y_ortvalue.device_name(),
        device_id=0,
        element_type=np.float32,
        shape=Y_ortvalue.shape(),
        buffer_ptr=Y_ortvalue.data_ptr()
)
session.run_with_iobinding(io_binding)

用户可以请求 ONNX Runtime 在设备上分配输出。这对于动态形状的输出特别有用。用户可以使用 get_outputs() API 来访问与已分配输出对应的 OrtValue。因此，用户可以将 ONNX Runtime 为输出分配的内存作为 OrtValue 消耗。

#X is numpy array on cpu
X_ortvalue = onnxruntime.OrtValue.ortvalue_from_numpy(X, 'cuda', 0)
session = onnxruntime.InferenceSession(
        'model.onnx',
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
)
io_binding = session.io_binding()
io_binding.bind_input(
        name='input',
        device_type=X_ortvalue.device_name(),
        device_id=0,
        element_type=np.float32,
        shape=X_ortvalue.shape(),
        buffer_ptr=X_ortvalue.data_ptr()
)
#Request ONNX Runtime to bind and allocate memory on CUDA for 'output'
io_binding.bind_output('output', 'cuda')
session.run_with_iobinding(io_binding)
# The following call returns an OrtValue which has data allocated by ONNX Runtime on CUDA
ort_output = io_binding.get_outputs()[0]

此外，如果 OrtValue 作为输入馈送的一部分提供，则 ONNX Runtime 支持在推理模型时直接使用 OrtValue。

用户可以直接绑定 OrtValue。

#X is numpy array on cpu
#X is numpy array on cpu
X_ortvalue = onnxruntime.OrtValue.ortvalue_from_numpy(X, 'cuda', 0)
Y_ortvalue = onnxruntime.OrtValue.ortvalue_from_shape_and_type([3, 2], np.float32, 'cuda', 0)  # Change the shape to the actual shape of the output being bound
session = onnxruntime.InferenceSession(
        'model.onnx',
        providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
)
io_binding = session.io_binding()
io_binding.bind_ortvalue_input('input', X_ortvalue)
io_binding.bind_ortvalue_output('output', Y_ortvalue)
session.run_with_iobinding(io_binding)

您还可以将输入和输出直接绑定到 PyTorch 张量。

# X is a PyTorch tensor on device
session = onnxruntime.InferenceSession('model.onnx', providers=['CUDAExecutionProvider', 'CPUExecutionProvider']))
binding = session.io_binding()

X_tensor = X.contiguous()

binding.bind_input(
    name='X',
    device_type='cuda',
    device_id=0,
    element_type=np.float32,
    shape=tuple(x_tensor.shape),
    buffer_ptr=x_tensor.data_ptr(),
    )

## Allocate the PyTorch tensor for the model output
Y_shape = ... # You need to specify the output PyTorch tensor shape
Y_tensor = torch.empty(Y_shape, dtype=torch.float32, device='cuda:0').contiguous()
binding.bind_output(
    name='Y',
    device_type='cuda',
    device_id=0,
    element_type=np.float32,
    shape=tuple(Y_tensor.shape),
    buffer_ptr=Y_tensor.data_ptr(),
)

session.run_with_iobinding(binding)

您还可以在 ONNX Runtime 推理示例中查看此 API 的代码示例。

某些 onnx 数据类型（例如 TensorProto.BFLOAT16、TensorProto.FLOAT8E4M3FN 和 TensorProto.FLOAT8E5M2）Numpy 不支持。您可以直接将输入或输出与 GPU 内存中相应数据类型（例如 torch.bfloat16、torch.float8_e4m3fn 和 torch.float8_e5m2）的 Torch 张量绑定。

x = torch.ones([3], dtype=torch.float8_e5m2, device='cuda:0')
y = torch.empty([3], dtype=torch.bfloat16, device='cuda:0')

binding = session.io_binding()
binding.bind_input(
    name='X',
    device_type='cuda',
    device_id=0,
    element_type=TensorProto.FLOAT8E5M2,
    shape=tuple(x.shape),
    buffer_ptr=x.data_ptr(),
    )
binding.bind_output(
    name='Y',
    device_type='cuda',
    device_id=0,
    element_type=TensorProto.BFLOAT16,
    shape=tuple(y.shape),
    buffer_ptr=y.data_ptr(),
    )
    session.run_with_iobinding(binding)

API 详细信息#

InferenceSession#

class onnxruntime.InferenceSession(path_or_bytes: str | bytes | os.PathLike, sess_options: onnxruntime.SessionOptions | None = None, providers: Sequence[str | tuple[str, dict[Any, Any]]] | None = None, provider_options: Sequence[dict[Any, Any]] | None = None, **kwargs)[source]#

这是用于运行模型的主类。

参数:

  • path_or_bytes – 字节字符串中的文件名或序列化的 ONNX 或 ORT 格式模型。

  • sess_options – 会话选项。

  • providers – 优先级递减的可选提供程序序列。值可以是提供程序名称，也可以是（提供程序名称、选项字典）的元组。如果未提供，则所有可用的提供程序都将使用默认优先级。

  • provider_options – 与“providers”中列出的提供程序对应的可选选项字典序列。

模型类型将被推断，除非在 SessionOptions 中显式设置。要显式设置

so = onnxruntime.SessionOptions()
# so.add_session_config_entry('session.load_model_format', 'ONNX') or
so.add_session_config_entry('session.load_model_format', 'ORT')

“.ort”的文件扩展名将被推断为 ORT 格式模型。所有其他文件名均假定为 ONNX 格式模型。

“providers”可以包含名称，也可以包含名称和选项。当“providers”中给出任何选项时，不应使用“provider_options”。

提供程序列表按优先级排序。例如 [‘CUDAExecutionProvider’, ‘CPUExecutionProvider’] 表示如果 CUDAExecutionProvider 有能力，则使用它执行节点，否则使用 CPUExecutionProvider 执行。

disable_fallback()#

禁用 session.run() 回退机制。

enable_fallback()#

启用 session.Run() 回退机制。如果 session.Run() 由于内部执行提供程序故障而失败，请重置为此会话启用的执行提供程序。如果启用了 GPU，则回退到 CUDAExecutionProvider。否则，回退到 CPUExecutionProvider。

end_profiling()#

结束性能分析并将结果返回到文件中。

如果选项 onnxruntime.SessionOptions.enable_profiling()，结果将存储在文件名中。

get_inputs()#

将输入元数据作为 onnxruntime.NodeArg 的列表返回。

get_modelmeta()#

返回元数据。请参阅 onnxruntime.ModelMetadata。

get_outputs()#

将输出元数据作为 onnxruntime.NodeArg 的列表返回。

get_overridable_initializers()#

将输入（包括初始值设定项）元数据作为 onnxruntime.NodeArg 的列表返回。

get_profiling_start_time_ns()#

返回性能分析开始时间的纳秒数。与 Python 3.3 之后的 time.monotonic_ns() 相当。在某些平台上，此计时器可能没有纳秒那么精确。例如，在 Windows 和 MacOS 上，精度约为 100 纳秒

get_provider_options()#

返回已注册的执行提供程序的配置。

get_providers()#

返回已注册的执行提供程序的列表。

get_session_options()#

返回会话选项。请参阅 onnxruntime.SessionOptions。

io_binding()#

返回 onnxruntime.IOBinding 对象。

run(output_names, input_feed, run_options=None)#

计算预测。

参数:

  • output_names – 输出的名称

  • input_feed – 字典 { input_name: input_value }

  • run_options – 请参阅 onnxruntime.RunOptions。

返回值:

结果列表，每个结果可以是 numpy 数组、稀疏张量、列表或字典。

sess.run([output_name], {input_name: x})
run_async(output_names, input_feed, callback, user_data, run_options=None)#

在与 ort 内部操作线程池分离的 cxx 线程中异步计算预测。

参数:

  • output_names – 输出的名称

  • input_feed – 字典 { input_name: input_value }

  • callback – python 函数，接受结果数组和错误状态字符串。回调将由来自 ort 内部操作线程池的 cxx 线程调用。

  • run_options – 请参阅 onnxruntime.RunOptions。

::
class MyData
def __init__(self)

# …

def save_results(self, results)

# …

def callback(results: np.ndarray, user_data: MyData, err: str) -> None
if err

print (err)

else

# 将结果保存到 user_data

sess.run_async([output_name], {input_name: x}, callback)

run_with_iobinding(iobinding, run_options=None)#

计算预测。

参数:

  • iobinding – 已绑定图输入/输出的 iobinding 对象。

  • run_options – 请参阅 onnxruntime.RunOptions。

run_with_ort_values(output_names, input_dict_ort_values, run_options=None)#

计算预测。

参数:

  • output_names – 输出的名称

  • input_dict_ort_values – 字典 { input_name: input_ort_value } 请参阅 OrtValue 类，了解如何从 numpy 数组或 SparseTensor 创建 OrtValue

  • run_options – 请参阅 onnxruntime.RunOptions。

返回值:

一个 OrtValue 数组

sess.run([output_name], {input_name: x})
run_with_ortvaluevector(run_options, feed_names, feeds, fetch_names, fetches, fetch_devices)#

计算预测，类似于其他 run_*() 方法，但 C++/Python 转换开销最小。

参数:

  • run_options – 请参阅 onnxruntime.RunOptions。

  • feed_names – 输入名称列表。

  • feeds – 输入 OrtValue 列表。

  • fetch_names – 输出名称列表。

  • fetches – 输出 OrtValue 列表。

  • fetch_devices – 输出设备列表。

set_providers(providers=None, provider_options=None)#

注册执行提供程序的输入列表。将重新创建底层会话。

参数:

  • providers – 优先级递减的可选提供程序序列。值可以是提供程序名称，也可以是（提供程序名称、选项字典）的元组。如果未提供，则所有可用的提供程序都将使用默认优先级。

  • provider_options – 与“providers”中列出的提供程序对应的可选选项字典序列。

“providers”可以包含名称，也可以包含名称和选项。当“providers”中给出任何选项时，不应使用“provider_options”。

提供程序列表按优先级排序。例如 [‘CUDAExecutionProvider’, ‘CPUExecutionProvider’] 表示如果 CUDAExecutionProvider 有能力，则使用它执行节点，否则使用 CPUExecutionProvider 执行。

选项#

RunOptions#

class onnxruntime.RunOptions(self: onnxruntime.capi.onnxruntime_pybind11_state.RunOptions)#

单个 Run 的配置信息。

add_run_config_entry(self: onnxruntime.capi.onnxruntime_pybind11_state.RunOptions, arg0: str, arg1: str) → None#

将单个运行配置条目设置为一对字符串。

get_run_config_entry(self: onnxruntime.capi.onnxruntime_pybind11_state.RunOptions, arg0: str) → str#

使用给定的配置键获取单个运行配置值。

property log_severity_level#

信息 (Info)，2:警告 (Warning)，3:错误 (Error)，4:致命 (Fatal)。默认为 2。

类型:

特定 Run() 调用的日志严重性级别。0

类型:

详细 (Verbose)，1

property log_verbosity_level#

如果为 DEBUG 构建且 run_log_severity_level 为 0，则为 VLOG 级别。适用于特定的 Run() 调用。默认为 0。

property logid#

用于标识特定 Run() 调用生成的日志。

property only_execute_path_to_fetches#

仅执行提取列表所需的节点

property terminate#

设置为 True 以终止任何当前正在使用此 RunOptions 实例的执行调用。各个调用将正常退出并返回错误状态。

property training_mode#

选择在训练或推理模式下运行

SessionOptions#

class onnxruntime.SessionOptions(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions)#

会话的配置信息。

add_external_initializers(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions, arg0: list, arg1: list) → None#
add_free_dimension_override_by_denotation(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions, arg0: str, arg1: int) → None#

为与输入自由维度关联的每个指示符指定维度大小。

add_free_dimension_override_by_name(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions, arg0: str, arg1: int) → None#

指定模型输入中命名维度的值。

add_initializer(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions, arg0: str, arg1: object) → None#
add_session_config_entry(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions, arg0: str, arg1: str) → None#

将单个会话配置条目设置为字符串对。

property enable_cpu_mem_arena#

在 CPU 上启用内存 Arena。Arena 可能会为未来使用预先分配内存。如果您不希望这样做，请将此选项设置为 false。默认为 True。

property enable_mem_pattern#

启用内存模式优化。默认为 true。

property enable_mem_reuse#

启用内存重用优化。默认为 true。

property enable_profiling#

为此会话启用性能分析。默认为 false。

property execution_mode#

设置执行模式。默认为 sequential（顺序执行）。

property execution_order#

设置执行顺序。默认为 basic topological order（基本拓扑顺序）。

get_session_config_entry(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions, arg0: str) → str#

使用给定的配置键获取单个会话配置值。

property graph_optimization_level#

此会话的图优化级别。

property inter_op_num_threads#

设置用于并行化图执行（跨节点）的线程数。默认为 0，让 onnxruntime 选择。

property intra_op_num_threads#

设置用于并行化节点内执行的线程数。默认为 0，让 onnxruntime 选择。

property log_severity_level#

日志严重性级别。适用于会话加载、初始化等。0:Verbose（详细）, 1:Info（信息）, 2:Warning（警告）. 3:Error（错误）, 4:Fatal（致命）。默认为 2。

property log_verbosity_level#

VLOG 级别（如果为 DEBUG 构建且 session_log_severity_level 为 0）。适用于会话加载、初始化等。默认为 0。

property logid#

用于会话输出的 Logger ID。

property optimized_model_filepath#

序列化优化模型的文件的路径。除非设置 optimized_model_filepath，否则不会序列化优化模型。序列化模型格式将默认为 ONNX，除非： - 使用 add_session_config_entry 将 ‘session.save_model_format’ 设置为 ‘ORT’，或者 - 没有 ‘session.save_model_format’ 配置条目且 optimized_model_filepath 以 ‘.ort’ 结尾（不区分大小写）

property profile_file_prefix#

性能分析文件的前缀。当前时间将附加到文件名。

register_custom_ops_library(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionOptions, arg0: str) → None#

指定包含运行模型所需的自定义 op 内核的共享库的路径。

property use_deterministic_compute#

是否使用确定性计算。默认为 false。

class onnxruntime.ExecutionMode(self: onnxruntime.capi.onnxruntime_pybind11_state.ExecutionMode, value: int)#

成员

ORT_SEQUENTIAL （顺序执行）

ORT_PARALLEL （并行执行）

property name#
class onnxruntime.ExecutionOrder(self: onnxruntime.capi.onnxruntime_pybind11_state.ExecutionOrder, value: int)#

成员

DEFAULT （默认）

PRIORITY_BASED （基于优先级）

MEMORY_EFFICIENT （内存高效）

property name#
class onnxruntime.GraphOptimizationLevel(self: onnxruntime.capi.onnxruntime_pybind11_state.GraphOptimizationLevel, value: int)#

成员

ORT_DISABLE_ALL （禁用所有优化）

ORT_ENABLE_BASIC （启用基本优化）

ORT_ENABLE_EXTENDED （启用扩展优化）

ORT_ENABLE_ALL （启用所有优化）

property name#
class onnxruntime.OrtAllocatorType(self: onnxruntime.capi.onnxruntime_pybind11_state.OrtAllocatorType, value: int)#

成员

INVALID （无效）

ORT_DEVICE_ALLOCATOR （设备分配器）

ORT_ARENA_ALLOCATOR （Arena 分配器）

property name#
class onnxruntime.OrtArenaCfg(*args, **kwargs)#

重载函数。

  1. __init__(self: onnxruntime.capi.onnxruntime_pybind11_state.OrtArenaCfg, arg0: int, arg1: int, arg2: int, arg3: int) -> None

  2. __init__(self: onnxruntime.capi.onnxruntime_pybind11_state.OrtArenaCfg, arg0: dict) -> None

class onnxruntime.OrtMemoryInfo(self: onnxruntime.capi.onnxruntime_pybind11_state.OrtMemoryInfo, arg0: str, arg1: onnxruntime.capi.onnxruntime_pybind11_state.OrtAllocatorType, arg2: int, arg3: onnxruntime.capi.onnxruntime_pybind11_state.OrtMemType)#
class onnxruntime.OrtMemType(self: onnxruntime.capi.onnxruntime_pybind11_state.OrtMemType, value: int)#

成员

CPU_INPUT （CPU 输入）

CPU_OUTPUT （CPU 输出）

CPU

DEFAULT （默认）

property name#

函数#

分配器#

onnxruntime.create_and_register_allocator(arg0: OrtMemoryInfo, arg1: OrtArenaCfg) → None#
onnxruntime.create_and_register_allocator_v2(arg0: str, arg1: OrtMemoryInfo, arg2: dict[str, str], arg3: OrtArenaCfg) → None#

遥测事件#

onnxruntime.disable_telemetry_events() → None#

禁用特定于平台的遥测数据收集。

onnxruntime.enable_telemetry_events() → None#

在适用的情况下启用特定于平台的遥测数据收集。

提供程序#

onnxruntime.get_all_providers() → list[str]#

返回此 Onnxruntime 版本可以支持的执行提供程序的列表。元素的顺序表示执行提供程序的默认优先级顺序，从高到低。

onnxruntime.get_available_providers() → list[str]#

返回此已安装的 Onnxruntime 版本中可用的执行提供程序的列表。元素的顺序表示执行提供程序的默认优先级顺序，从高到低。

构建，版本#

onnxruntime.get_build_info() → str#
onnxruntime.get_version_string() → str#
onnxruntime.has_collective_ops() → bool#

设备#

onnxruntime.get_device() → str#

返回用于计算预测的设备 (CPU, MKL, …)

日志记录#

onnxruntime.set_default_logger_severity(arg0: int) → None#

设置默认日志严重性。0:Verbose（详细）, 1:Info（信息）, 2:Warning（警告）, 3:Error（错误）, 4:Fatal（致命）

onnxruntime.set_default_logger_verbosity(arg0: int) → None#

设置默认日志详细级别。要激活详细日志，您需要将默认日志严重性设置为 0:Verbose 级别。

随机数#

onnxruntime.set_seed(arg0: int) → None#

设置 Onnxruntime 中用于随机数生成的种子。

数据#

OrtValue#

class onnxruntime.OrtValue(ortvalue, numpy_obj=None)[source]#

一种数据结构，支持所有 ONNX 数据格式（张量和非张量），允许用户将这些数据放置在设备上，例如，在 CUDA 支持的设备上。此类提供用于构造和处理 OrtValue 的 API。

as_sparse_tensor()[source]#

此函数将返回此 OrtValue 中包含的 SparseTensor（稀疏张量）

data_ptr()[source]#

返回 OrtValue 数据缓冲区中第一个元素的地址

data_type()[source]#

返回 OrtValue 中数据的的数据类型

device_name()[source]#

返回 OrtValue 的数据缓冲区所在的设备的名称，例如 cpu、cuda、cann

element_type()[source]#

如果 OrtValue 是张量，则返回 OrtValue 中数据的 proto 类型。

has_value()[source]#

如果与可选类型对应的 OrtValue 包含数据，则返回 True，否则返回 False

is_sparse_tensor()[source]#

如果 OrtValue 包含 SparseTensor，则返回 True，否则返回 False

is_tensor()[source]#

如果 OrtValue 包含 Tensor（张量），则返回 True，否则返回 False

is_tensor_sequence()[source]#

如果 OrtValue 包含 Tensor Sequence（张量序列），则返回 True，否则返回 False

numpy()[source]#

从 OrtValue 返回一个 Numpy 对象。仅对保存张量的 OrtValue 有效。对于保存非张量的 OrtValue 会抛出异常。使用访问器来获取对非张量对象（如 SparseTensor）的引用

static ort_value_from_sparse_tensor(sparse_tensor)[source]#

此函数将从有效的 SparseTensor 构造一个 OrtValue 实例。OrtValue 的新实例将承担 sparse_tensor 的所有权

static ortvalue_from_numpy(numpy_obj, device_type='cpu', device_id=0)[source]#

工厂方法，用于从给定的 Numpy 对象构造 OrtValue（其中包含张量）。仅当设备不是 cpu 时，OrtValue 才持有 Numpy 对象中数据的副本

参数:

  • numpy_obj – 要从中构造 OrtValue 的 Numpy 对象

  • device_type – 例如 cpu、cuda、cann，默认为 cpu

  • device_id – 设备 ID，例如 0

static ortvalue_from_shape_and_type(shape=None, element_type=None, device_type='cpu', device_id=0)[source]#

工厂方法，用于从给定的形状和 element_type 构造 OrtValue（其中包含张量）

参数:

  • shape – 指示 OrtValue 形状的整数列表

  • element_type – OrtValue 中元素的数据类型（numpy 类型）

  • device_type – 例如 cpu、cuda、cann，默认为 cpu

  • device_id – 设备 ID，例如 0

shape()[source]#

返回 OrtValue 中数据的形状

update_inplace(np_arr)[source]#

使用新的 Numpy 数组就地更新 OrtValue。numpy 内容被复制到支持 OrtValue 的设备内存中。它可用于在使用 CUDA 图时更新 InferenceSession 的输入值，或在其他需要更新 OrtValue 但内存地址不能更改的情况下使用。

SparseTensor#

class onnxruntime.SparseTensor(sparse_tensor)[source]#

一种数据结构，用于投影 C++ SparseTensor 对象。该类提供了与该对象交互的 API。根据格式，该类将保存多个缓冲区，具体取决于格式

内部构造函数

as_blocksparse_view()[source]#

此方法将返回稀疏张量的 coo 表示形式，这将允许查询 BlockSparse 索引。如果实例不包含 BlockSparse 格式，则会抛出异常。您可以按如下方式查询 coo 索引

block_sparse_indices = sparse_tensor.as_blocksparse_view().indices()

这将返回一个由本机内存支持的 numpy 数组

as_coo_view()[source]#

此方法将返回稀疏张量的 coo 表示形式，这将允许查询 COO 索引。如果实例不包含 COO 格式，则会抛出异常。您可以按如下方式查询 coo 索引

coo_indices = sparse_tensor.as_coo_view().indices()

这将返回一个由本机内存支持的 numpy 数组。

as_csrc_view()[source]#

此方法将返回稀疏张量的 CSR(C) 表示形式，这将允许查询 CRS(C) 索引。如果实例不包含 CSR(C) 格式，则会抛出异常。您可以按如下方式查询索引

inner_ndices = sparse_tensor.as_csrc_view().inner()
outer_ndices = sparse_tensor.as_csrc_view().outer()

返回由本机内存支持的 numpy 数组。

data_type()[source]#

返回 OrtValue 中数据的字符串数据类型

dense_shape()[source]#

返回一个包含稀疏张量密集形状的 numpy 数组 (int64)

device_name()[source]#

返回 SparseTensor 数据缓冲区所在的设备名称，例如 cpu、cuda

format()[source]#

返回 OrtSparseFormat 枚举

static sparse_coo_from_numpy(dense_shape, values, coo_indices, ort_device)[source]#

用于从给定参数构造 COO 格式的 SparseTensor 的工厂方法

参数:

  • dense_shape – 1-D numpy 数组 (int64) 或 python 列表，其中包含稀疏张量的 dense_shape，必须位于 cpu 内存中

  • values – 同质的、连续的 1-D numpy 数组，其中包含张量的非零元素，类型为。

  • coo_indices – 连续的 numpy 数组 (int64)，其中包含张量的 COO 索引。当 coo_indices 包含非零值的线性索引时，它可能具有 1-D 形状，并且其长度必须等于值的长度。它也可以是 2-D 形状，在这种形状中，它包含每个非零值的坐标对，并且其长度必须正好是值长度的两倍。

  • ort_device –

    • 描述由提供的 numpy 数组拥有的后备内存。仅 CPU 内存是

    非数字数据类型支持。

对于原始类型，该方法会将 values 和 coo_indices 数组映射到本机内存中，并将它们用作后备存储。它将增加 numpy 数组的引用计数，并在 GC 时减少它。缓冲区可能驻留在任何存储中，无论是 CPU 还是 GPU。对于字符串和对象，它将在 CPU 内存中创建数组的副本，因为 ORT 不支持其他设备上的字符串和对象，并且它们的内存无法映射。

static sparse_csr_from_numpy(dense_shape, values, inner_indices, outer_indices, ort_device)[source]#

用于从给定参数构造 CSR 格式的 SparseTensor 的工厂方法

参数:

  • dense_shape – 1-D numpy 数组 (int64) 或 python 列表，其中包含稀疏张量的 dense_shape（行，列），必须位于 cpu 内存中

  • values – 连续的、同质的 1-D numpy 数组，其中包含张量的非零元素，类型为。

  • inner_indices – 连续的 1-D numpy 数组 (int64)，其中包含张量的 CSR 内部索引。其长度必须等于值的长度。

  • outer_indices – 连续的 1-D numpy 数组 (int64)，其中包含张量的 CSR 外部索引。其长度必须等于行数 + 1。

  • ort_device –

    • 描述由提供的 numpy 数组拥有的后备内存。仅 CPU 内存是

    非数字数据类型支持。

对于原始类型，该方法会将 values 和 indices 数组映射到本机内存中，并将它们用作后备存储。它将增加引用计数，并在 GC 时减少计数。缓冲区可能驻留在任何存储中，无论是 CPU 还是 GPU。对于字符串和对象，它将在 CPU 内存中创建数组的副本，因为 ORT 不支持其他设备上的字符串和对象，并且它们的内存无法映射。

to_cuda(ort_device)[source]#

返回此实例在指定 cuda 设备上的副本

参数:

ort_device – 名称为 ‘cuda’ 且具有有效 gpu 设备 ID

如果以下情况，该方法将抛出异常

  • 此实例包含字符串

  • 此实例已在 GPU 上。不支持跨 GPU 复制

  • 此构建中不存在 CUDA

  • 如果指定的设备无效

values()[source]#

如果数据类型为数字，则该方法返回由本机内存支持的 numpy 数组。否则，返回的 numpy 数组包含字符串的副本。

Devices#

IOBinding#

class onnxruntime.IOBinding(session: Session)[source]#

此类提供 API 以将输入/输出绑定到指定的设备，例如 GPU。

bind_cpu_input(name, arr_on_cpu)[source]#

将输入绑定到 CPU 上的数组 :param name: 输入名称 :param arr_on_cpu: CPU 上的 python 数组形式的输入值

bind_input(name, device_type, device_id, element_type, shape, buffer_ptr)[source]#
参数:

  • name – 输入名称

  • device_type – 例如 cpu、cuda、cann

  • device_id – 设备 ID，例如 0

  • element_type – 输入元素类型

  • shape – 输入形状

  • buffer_ptr – 指向输入数据的内存指针

bind_ortvalue_input(name, ortvalue)[source]#
参数:

  • name – 输入名称

  • ortvalue – 要绑定的 OrtValue 实例

bind_ortvalue_output(name, ortvalue)[source]#
参数:

  • name – 输出名称

  • ortvalue – 要绑定的 OrtValue 实例

bind_output(name, device_type='cpu', device_id=0, element_type=None, shape=None, buffer_ptr=None)[source]#
参数:

  • name – 输出名称

  • device_type – 例如 cpu、cuda、cann，默认为 cpu

  • device_id – 设备 ID，例如 0

  • element_type – 输出元素类型

  • shape – 输出形状

  • buffer_ptr – 指向输出数据的内存指针

copy_outputs_to_cpu()[source]#

将输出内容复制到 CPU。

get_outputs()[source]#

返回在调用之前 Run() 的输出 OrtValue。获得的 OrtValue 的数据缓冲区可能不在 CPU 内存中

class onnxruntime.SessionIOBinding(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding, arg0: onnxruntime.capi.onnxruntime_pybind11_state.InferenceSession)#
bind_input(*args, **kwargs)#

重载函数。

  1. bind_input(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding, arg0: str, arg1: object) -> None

  2. bind_input(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding, arg0: str, arg1: onnxruntime.capi.onnxruntime_pybind11_state.OrtDevice, arg2: object, arg3: list[int], arg4: int) -> None

bind_ortvalue_input(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding, arg0: str, arg1: onnxruntime.capi.onnxruntime_pybind11_state.OrtValue) → None#
bind_ortvalue_output(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding, arg0: str, arg1: onnxruntime.capi.onnxruntime_pybind11_state.OrtValue) → None#
bind_output(*args, **kwargs)#

重载函数。

  1. bind_output(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding, arg0: str, arg1: onnxruntime.capi.onnxruntime_pybind11_state.OrtDevice, arg2: object, arg3: list[int], arg4: int) -> None

  2. bind_output(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding, arg0: str, arg1: onnxruntime.capi.onnxruntime_pybind11_state.OrtDevice) -> None

clear_binding_inputs(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding) → None#
clear_binding_outputs(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding) → None#
copy_outputs_to_cpu(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding) → list#
get_outputs(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding) → onnxruntime.capi.onnxruntime_pybind11_state.OrtValueVector#
synchronize_inputs(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding) → None#
synchronize_outputs(self: onnxruntime.capi.onnxruntime_pybind11_state.SessionIOBinding) → None#

OrtDevice#

class onnxruntime.OrtDevice(c_ort_device)[source]#

一种数据结构，用于公开底层的 C++ OrtDevice

内部构造函数

Internal classes#

这些类不能由用户实例化，但它们由该库的方法或函数返回。

ModelMetadata#

class onnxruntime.ModelMetadata#

关于模型的预定义和自定义元数据。它通常用于标识用于运行预测的模型，并有助于比较。

property custom_metadata_map#

附加元数据

property description#

模型的描述

property domain#

ONNX 域

property graph_description#

模型中托管的图的描述

property graph_name#

图名称

property producer_name#

生产者名称

property version#

模型版本

NodeArg#

class onnxruntime.NodeArg#

节点参数定义，包括输入和输出，包括参数名称、参数类型（包含类型和形状）。

property name#

节点名称

property shape#

节点形状（假设节点包含张量）

property type#

节点类型

Backend#

除了针对性能和可用性优化的常规 API 之外，ONNX Runtime 还实现了 ONNX 后端 API，用于验证 ONNX 规范的符合性。支持以下功能

onnxruntime.backend.is_compatible(model, device=None, **kwargs)#

返回模型是否与后端兼容。

参数:

  • model – 未使用

  • device – None 以使用默认设备，或使用字符串（例如：‘CPU’）

返回值:

boolean

onnxruntime.backend.prepare(model, device=None, **kwargs)#

加载模型并创建一个 onnxruntime.InferenceSession，准备用作后端。

参数:

  • model – ModelProto（由 onnx.load 返回）、用于文件名的字符串或用于序列化模型的字节

  • device – 请求的计算设备，None 表示默认设备，具体取决于编译设置

  • kwargs – 请参阅 onnxruntime.SessionOptions

返回值:

onnxruntime.InferenceSession

onnxruntime.backend.run(model, inputs, device=None, **kwargs)#

计算预测。

参数:
返回值:

预测

onnxruntime.backend.supports_device(device)#

检查后端是否编译了特定的设备支持。特别是，它在测试套件中使用。