API#

API Übersicht#

ONNX Runtime lädt und führt Inferenz auf einem Modell im ONNX-Graph-Format oder im ORT-Format (für speicher- und speicherbeschränkte Umgebungen) aus.

Die vom Modell verbrauchten und erzeugten Daten können so spezifiziert und abgerufen werden, wie es am besten zu Ihrem Szenario passt.

Modell laden und ausführen#

InferenceSession ist die Hauptklasse von ONNX Runtime. Sie wird verwendet, um ein ONNX-Modell zu laden und auszuführen sowie Umgebungs- und Anwendungskonfigurationsoptionen festzulegen.

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

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

ONNX- und ORT-Formatmodelle bestehen aus einem Berechnungs-Graphen, der als Operatoren modelliert und als optimierte Operator-Kernels für verschiedene Hardwareziele implementiert ist. ONNX Runtime orchestriert die Ausführung von Operator-Kernels über Execution Provider. Ein Execution Provider enthält die Menge der Kernels für ein bestimmtes Ausführungsziel (CPU, GPU, IoT etc.). Execution Provider werden über den Parameter providers konfiguriert. Kernels von verschiedenen Execution Providern werden in der durch die Liste der Provider gegebenen Reihenfolge der Priorität ausgewählt. Im folgenden Beispiel, wenn ein Kernel im CUDA Execution Provider vorhanden ist, führt ONNX Runtime diesen auf der GPU aus. Wenn nicht, wird der Kernel auf der CPU ausgeführt.

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

Die Liste der verfügbaren Execution Provider finden Sie hier: Execution Provider.

Seit ONNX Runtime 1.10 müssen Sie den Execution Provider für Ihr Ziel explizit angeben. Die Ausführung auf der CPU ist der einzige Fall, in dem die API keine explizite Einstellung des Parameters provider zulässt. In den folgenden Beispielen werden der CUDAExecutionProvider und der CPUExecutionProvider verwendet, wobei davon ausgegangen wird, dass die Anwendung auf NVIDIA GPUs läuft. Ersetzen Sie diese durch den für Ihre Umgebung spezifischen Execution Provider.

Sie können weitere Sitzungskonfigurationen über den Parameter session options bereitstellen. Zum Beispiel, um Profiling für die Sitzung zu aktivieren

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

Daten-Inputs und -Outputs#

Die ONNX Runtime Inference Session verbraucht und erzeugt Daten mit ihrer OrtValue-Klasse.

Daten auf der CPU#

Auf der CPU (Standard) können OrtValues auf native Python-Datenstrukturen abgebildet werden: NumPy-Arrays, Dictionaries und Listen von NumPy-Arrays.

# 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})

Standardmäßig platziert ONNX Runtime Eingaben und Ausgaben immer auf der CPU. Die Daten auf der CPU sind möglicherweise nicht optimal, wenn die Eingabe oder Ausgabe auf einem anderen Gerät als der CPU verbraucht und erzeugt wird, da dies Datenkopien zwischen CPU und Gerät verursacht.

Daten auf dem Gerät#

ONNX Runtime unterstützt eine benutzerdefinierte Datenstruktur, die alle ONNX-Datenformate unterstützt und es Benutzern ermöglicht, die Daten auf einem Gerät zu platzieren, z. B. auf einem CUDA-fähigen Gerät. In ONNX Runtime wird dies als IOBinding bezeichnet.

Um die IOBinding-Funktion zu nutzen, ersetzen Sie InferenceSession.run() durch InferenceSession.run_with_iobinding().

Ein Graph wird auf einem anderen Gerät als der CPU ausgeführt, z. B. CUDA. Benutzer können IOBinding verwenden, um die Daten auf die GPU zu kopieren.

# 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]

Die Eingabedaten befinden sich auf einem Gerät, Benutzer verwenden die Eingabe direkt. Die Ausgabedaten befinden sich auf der 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]

Die Eingabedaten und Ausgabedaten befinden sich beide auf einem Gerät, Benutzer verwenden die Eingabe direkt und platzieren auch die Ausgabe auf dem Gerät.

#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)

Benutzer können ONNX Runtime anweisen, eine Ausgabe auf einem Gerät zu allozieren. Dies ist besonders nützlich für dynamisch geformte Ausgaben. Benutzer können die API get_outputs() verwenden, um Zugriff auf die OrtValue(s) zu erhalten, die den allozierten Ausgaben entsprechen. Benutzer können so den von ONNX Runtime allozierten Speicher für die Ausgabe als OrtValue nutzen.

#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]

Darüber hinaus unterstützt ONNX Runtime die direkte Arbeit mit OrtValue(s) während der Inferenz eines Modells, wenn diese als Teil des Eingabefutters bereitgestellt werden.

Benutzer können OrtValue(s) direkt binden.

#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)

Sie können auch Eingaben und Ausgaben direkt an einen PyTorch-Tensor binden.

# 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)

Sie können Codebeispiele für diese API auch in den ONNX Runtime Inferenzbeispielen finden.

Einige ONNX-Datentypen (wie TensorProto.BFLOAT16, TensorProto.FLOAT8E4M3FN und TensorProto.FLOAT8E5M2) werden von Numpy nicht unterstützt. Sie können Eingaben oder Ausgaben direkt mit Torch-Tensoren des entsprechenden Datentyps (wie torch.bfloat16, torch.float8_e4m3fn und torch.float8_e5m2) im GPU-Speicher binden.

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-Details#

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]#

Dies ist die Hauptklasse, die zum Ausführen eines Modells verwendet wird.

Parameter:

  • path_or_bytes – Dateiname oder serialisiertes ONNX- oder ORT-Formatmodell in einem Byte-String.

  • sess_options – Sitzungsoptionen.

  • providers – Optionale Sequenz von Providern in absteigender Prioritätsreihenfolge. Werte können entweder Providernamen oder Tupel aus (Providername, Options-Dictionary) sein. Wenn nicht angegeben, werden alle verfügbaren Provider mit der Standardpriorität verwendet.

  • provider_options – Optionale Sequenz von Options-Dictionaries, die den in 'providers' aufgeführten Providern entsprechen.

Der Modelltyp wird abgeleitet, es sei denn, er wird explizit in SessionOptions festgelegt. Zum expliziten Festlegen

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

Eine Dateierweiterung von '.ort' wird als ORT-Formatmodell abgeleitet. Alle anderen Dateinamen werden als ONNX-Formatmodelle angenommen.

'providers' kann entweder Namen oder Namen und Optionen enthalten. Wenn in 'providers' Optionen angegeben sind, sollte 'provider_options' nicht verwendet werden.

Die Liste der Provider ist nach Priorität geordnet. Zum Beispiel bedeutet ['CUDAExecutionProvider', 'CPUExecutionProvider'], dass ein Knoten mit CUDAExecutionProvider ausgeführt wird, wenn möglich, andernfalls wird er mit CPUExecutionProvider ausgeführt.

disable_fallback()#

Deaktiviert den Fallback-Mechanismus von session.run().

enable_fallback()#

Aktiviert den Fallback-Mechanismus von session.Run(). Wenn session.Run() aufgrund eines internen Fehlers eines Execution Providers fehlschlägt, werden die für diese Sitzung aktivierten Execution Provider zurückgesetzt. Wenn GPU aktiviert ist, wird auf CUDAExecutionProvider zurückgefallen. Andernfalls wird auf CPUExecutionProvider zurückgefallen.

end_profiling()#

Beendet das Profiling und gibt die Ergebnisse in einer Datei zurück.

Die Ergebnisse werden in einem Dateinamen gespeichert, wenn die Option onnxruntime.SessionOptions.enable_profiling() aktiviert ist.

get_inputs()#

Gibt die Metadaten der Eingaben als Liste von onnxruntime.NodeArg zurück.

get_modelmeta()#

Gibt die Metadaten zurück. Siehe onnxruntime.ModelMetadata.

get_outputs()#

Gibt die Metadaten der Ausgaben als Liste von onnxruntime.NodeArg zurück.

get_overridable_initializers()#

Gibt die Eingaben (einschließlich Initialisierer) Metadaten als Liste von onnxruntime.NodeArg zurück.

get_profiling_start_time_ns()#

Gibt die Nanosekunden der Startzeit des Profilings zurück. Vergleichbar mit time.monotonic_ns() ab Python 3.3. Auf einigen Plattformen ist dieser Timer möglicherweise nicht so präzise wie Nanosekunden. Zum Beispiel unter Windows und MacOS beträgt die Präzision ca. 100 ns.

get_provider_options()#

Gibt die Konfigurationen der registrierten Execution Provider zurück.

get_providers()#

Gibt die Liste der registrierten Execution Provider zurück.

get_session_options()#

Gibt die Sitzungsoptionen zurück. Siehe onnxruntime.SessionOptions.

io_binding()#

Gibt ein onnxruntime.IOBinding-Objekt zurück.

run(output_names, input_feed, run_options=None)#

Berechnet die Vorhersagen.

Parameter:

  • output_names – Name der Ausgaben

  • input_feed – Dictionary { input_name: input_value }

  • run_options – Siehe onnxruntime.RunOptions.

Rückgabe:

Liste der Ergebnisse, wobei jedes Ergebnis entweder ein NumPy-Array, ein Sparse-Tensor, eine Liste oder ein Dictionary ist.

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

Berechnet die Vorhersagen asynchron in einem separaten cxx-Thread aus dem ort-Intra-Op-Threadpool.

Parameter:

  • output_names – Name der Ausgaben

  • input_feed – Dictionary { input_name: input_value }

  • callback – Python-Funktion, die ein Array von Ergebnissen und einen Status-String bei Fehlern akzeptiert. Der Callback wird von einem cxx-Thread aus dem ort-Intra-Op-Threadpool aufgerufen.

  • run_options – Siehe 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

# save results to user_data

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

run_with_iobinding(iobinding, run_options=None)#

Berechnet die Vorhersagen.

Parameter:

  • iobinding – das iobinding-Objekt, das die Bindungen der Graphen-Inputs/Outputs enthält.

  • run_options – Siehe onnxruntime.RunOptions.

run_with_ort_values(output_names, input_dict_ort_values, run_options=None)#

Berechnet die Vorhersagen.

Parameter:

  • output_names – Name der Ausgaben

  • input_dict_ort_values – Dictionary { input_name: input_ort_value } Siehe die Klasse OrtValue, wie man OrtValue aus einem Numpy-Array oder einem SparseTensor erstellt.

  • run_options – Siehe onnxruntime.RunOptions.

Rückgabe:

Ein Array von OrtValue.

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

Berechnet die Vorhersagen ähnlich wie andere run_*()-Methoden, aber mit minimalem C++/Python-Konvertierungsaufwand.

Parameter:

  • run_options – Siehe onnxruntime.RunOptions.

  • feed_names – Liste der Input-Namen.

  • feeds – Liste der Input-OrtValue.

  • fetch_names – Liste der Output-Namen.

  • fetches – Liste der Output-OrtValue.

  • fetch_devices – Liste der Output-Geräte.

set_providers(providers=None, provider_options=None)#

Registriert die eingegebene Liste von Execution Providern. Die zugrunde liegende Sitzung wird neu erstellt.

Parameter:

  • providers – Optionale Sequenz von Providern in absteigender Prioritätsreihenfolge. Werte können entweder Providernamen oder Tupel aus (Providername, Options-Dictionary) sein. Wenn nicht angegeben, werden alle verfügbaren Provider mit der Standardpriorität verwendet.

  • provider_options – Optionale Sequenz von Options-Dictionaries, die den in 'providers' aufgeführten Providern entsprechen.

'providers' kann entweder Namen oder Namen und Optionen enthalten. Wenn in 'providers' Optionen angegeben sind, sollte 'provider_options' nicht verwendet werden.

Die Liste der Provider ist nach Priorität geordnet. Zum Beispiel bedeutet ['CUDAExecutionProvider', 'CPUExecutionProvider'], dass ein Knoten mit CUDAExecutionProvider ausgeführt wird, wenn möglich, andernfalls wird er mit CPUExecutionProvider ausgeführt.

Optionen#

RunOptions#

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

Konfigurationsinformationen für einen einzelnen Lauf.

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

Setzt einen einzelnen Konfigurationseintrag für den Lauf als Paar von Strings.

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

Ruft einen einzelnen Konfigurationswert für den Lauf anhand des angegebenen Konfigurationsschlüssels ab.

property log_severity_level#

Info, 2:Warnung. 3:Fehler, 4:Fatal. Standard ist 2.

Typ:

Log-Schweregrad für eine bestimmte Run()-Aufruf. 0

Typ:

Verbose, 1

property log_verbosity_level#

VLOG-Level bei DEBUG-Build und run_log_severity_level ist 0. Gilt für einen bestimmten Run()-Aufruf. Standard ist 0.

property logid#

Zur Identifizierung von Logs, die von einem bestimmten Run()-Aufruf generiert wurden.

property only_execute_path_to_fetches#

Nur die für die Fetch-Liste benötigten Knoten ausführen.

property terminate#

Auf True setzen, um alle aktuell ausgeführten Aufrufe, die diese RunOptions-Instanz verwenden, zu beenden. Die einzelnen Aufrufe werden ordnungsgemäß beendet und geben einen Fehlerstatus zurück.

property training_mode#

Wählen Sie zwischen Trainings- oder Inferenzmodus.

SessionOptions#

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

Konfigurationsinformationen für eine Sitzung.

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#

Gibt die Dimensiongröße für jede Denotation an, die mit der freien Dimension einer Eingabe verbunden ist.

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

Gibt Werte von benannten Dimensionen innerhalb von Modell-Inputs an.

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#

Set a single session configuration entry as a pair of strings.

property enable_cpu_mem_arena#

Enables the memory arena on CPU. Arena may pre-allocate memory for future usage. Set this option to false if you don’t want it. Default is True.

property enable_mem_pattern#

Enable the memory pattern optimization. Default is true.

property enable_mem_reuse#

Enable the memory reuse optimization. Default is true.

property enable_profiling#

Enable profiling for this session. Default is false.

property execution_mode#

Sets the execution mode. Default is sequential.

property execution_order#

Sets the execution order. Default is basic topological order.

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

Get a single session configuration value using the given configuration key.

property graph_optimization_level#

Graph optimization level for this session.

property inter_op_num_threads#

Sets the number of threads used to parallelize the execution of the graph (across nodes). Default is 0 to let onnxruntime choose.

property intra_op_num_threads#

Sets the number of threads used to parallelize the execution within nodes. Default is 0 to let onnxruntime choose.

property log_severity_level#

Log severity level. Applies to session load, initialization, etc. 0:Verbose, 1:Info, 2:Warning. 3:Error, 4:Fatal. Default is 2.

property log_verbosity_level#

VLOG level if DEBUG build and session_log_severity_level is 0. Applies to session load, initialization, etc. Default is 0.

property logid#

Logger id to use for session output.

property optimized_model_filepath#

File path to serialize optimized model to. Optimized model is not serialized unless optimized_model_filepath is set. Serialized model format will default to ONNX unless: - add_session_config_entry is used to set ‘session.save_model_format’ to ‘ORT’, or - there is no ‘session.save_model_format’ config entry and optimized_model_filepath ends in ‘.ort’ (case insensitive)

property profile_file_prefix#

The prefix of the profile file. The current time will be appended to the file name.

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

Specify the path to the shared library containing the custom op kernels required to run a model.

property use_deterministic_compute#

Whether to use deterministic compute. Default is false.

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

Mitglieder

ORT_SEQUENTIAL

ORT_PARALLEL

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

Mitglieder

DEFAULT

PRIORITY_BASED

MEMORY_EFFICIENT

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

Mitglieder

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)#

Mitglieder

INVALID

ORT_DEVICE_ALLOCATOR

ORT_ARENA_ALLOCATOR

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

Überladene Funktion.

  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)#

Mitglieder

CPU_INPUT

CPU_OUTPUT

CPU

DEFAULT

property name#

Funktionen#

Allocators#

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#

Telemetrie-Ereignisse#

onnxruntime.disable_telemetry_events() → None#

Deaktiviert die plattformspezifische Telemetriesammlung.

onnxruntime.enable_telemetry_events() → None#

Aktiviert die plattformspezifische Telemetriesammlung, wo zutreffend.

Provider#

onnxruntime.get_all_providers() → list[str]#

Gibt eine Liste der Ausführungsanbieter (Execution Providers) zurück, die diese Version von Onnxruntime unterstützt. Die Reihenfolge der Elemente stellt die Standardprioritätsreihenfolge der Ausführungsanbieter von höchster zu niedrigster dar.

onnxruntime.get_available_providers() → list[str]#

Gibt eine Liste der verfügbaren Ausführungsanbieter (Execution Providers) in dieser installierten Version von Onnxruntime zurück. Die Reihenfolge der Elemente stellt die Standardprioritätsreihenfolge der Ausführungsanbieter von höchster zu niedrigster dar.

Build, Version#

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

Gerät#

onnxruntime.get_device() → str#

Gibt das Gerät zurück, das zur Berechnung der Vorhersage verwendet wird (CPU, MKL, ...).

Protokollierung#

onnxruntime.set_default_logger_severity(arg0: int) → None#

Legt die Standard-Protokollschwere fest. 0: Ausführlich, 1: Info, 2: Warnung, 3: Fehler, 4: Kritisch.

onnxruntime.set_default_logger_verbosity(arg0: int) → None#

Legt die Standardprotokollierungsstufenebene fest. Um die ausführliche Protokollierung zu aktivieren, müssen Sie die Standardprotokollschwere auf 0: Ausführlich setzen.

Zufällig#

onnxruntime.set_seed(arg0: int) → None#

Legt den für die Zufallszahlengenerierung in Onnxruntime verwendeten Seed fest.

Daten#

OrtWert#

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

Eine Datenstruktur, die alle ONNX-Datenformate (Tensoren und Nicht-Tensoren) unterstützt und es Benutzern ermöglicht, die Daten auf einem Gerät zu platzieren, z. B. auf einem CUDA-fähigen Gerät. Diese Klasse bietet APIs zum Erstellen und Verwalten von OrtValues.

as_sparse_tensor()[source]#

Die Funktion gibt den SparseTensor zurück, der in diesem OrtValue enthalten ist.

data_ptr()[source]#

Gibt die Adresse des ersten Elements im Datenpuffer des OrtValue zurück.

data_type()[source]#

Gibt den Datentyp der Daten im OrtValue zurück.

device_name()[source]#

Gibt den Namen des Geräts zurück, auf dem sich der Datenpuffer des OrtValue befindet, z. B. cpu, cuda, cann.

element_type()[source]#

Gibt den Proto-Typ der Daten im OrtValue zurück, wenn der OrtValue ein Tensor ist.

has_value()[source]#

Gibt True zurück, wenn der OrtValue, der einem optionalen Typ entspricht, Daten enthält, andernfalls False.

is_sparse_tensor()[source]#

Gibt True zurück, wenn der OrtValue einen SparseTensor enthält, andernfalls False.

is_tensor()[source]#

Gibt True zurück, wenn der OrtValue einen Tensor enthält, andernfalls False.

is_tensor_sequence()[source]#

Gibt True zurück, wenn der OrtValue eine Tensorsequenz enthält, andernfalls False.

numpy()[source]#

Gibt ein Numpy-Objekt aus dem OrtValue zurück. Nur gültig für OrtValues, die Tensoren enthalten. Löst einen Fehler aus für OrtValues, die Nicht-Tensoren enthalten. Verwenden Sie Accessoren, um eine Referenz auf Nicht-Tensor-Objekte wie SparseTensor zu erhalten.

static ort_value_from_sparse_tensor(sparse_tensor)[source]#

Die Funktion konstruiert eine OrtValue-Instanz aus einem gültigen SparseTensor. Die neue Instanz von OrtValue übernimmt den Besitz des SparseTensors.

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

Factory-Methode zum Erstellen eines OrtValue (der einen Tensor enthält) aus einem gegebenen Numpy-Objekt. Eine Kopie der Daten im Numpy-Objekt wird vom OrtValue gehalten, es sei denn, das Gerät ist NICHT CPU.

Parameter:

  • numpy_obj – Das Numpy-Objekt, aus dem der OrtValue erstellt werden soll.

  • device_type – z. B. cpu, cuda, cann, standardmäßig cpu.

  • device_id – Geräte-ID, z. B. 0.

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

Factory-Methode zum Erstellen eines OrtValue (der einen Tensor enthält) aus einer gegebenen Form und Elementtyp.

Parameter:

  • shape – Liste von Ganzzahlen, die die Form des OrtValue angeben.

  • element_type – Der Datentyp der Elemente im OrtValue (Numpy-Typ).

  • device_type – z. B. cpu, cuda, cann, standardmäßig cpu.

  • device_id – Geräte-ID, z. B. 0.

shape()[source]#

Gibt die Form der Daten im OrtValue zurück.

update_inplace(np_arr)[source]#

Aktualisiert den OrtValue in-place mit einem neuen Numpy-Array. Der Numpy-Inhalt wird in den Gerätespeicher kopiert, der den OrtValue unterstützt. Er kann verwendet werden, um die Eingabewerte für eine InferenceSession mit aktivierten CUDA-Graphen oder in anderen Szenarien zu aktualisieren, in denen der OrtValue aktualisiert werden muss, die Speicheradresse aber nicht geändert werden kann.

SparseTensor#

class onnxruntime.SparseTensor(sparse_tensor)[Quelle]#

Eine Datenstruktur, die das C++ SparseTensor-Objekt projiziert. Die Klasse bietet eine API für die Arbeit mit dem Objekt. Abhängig vom Format enthält die Klasse mehr als einen Puffer, abhängig vom Format.

Interner Konstruktor

as_blocksparse_view()[Quelle]#

Die Methode gibt eine COO-Darstellung des Sparse-Tensors zurück, die das Abfragen von BlockSparse-Indizes ermöglicht. Wenn die Instanz kein BlockSparse-Format enthält, wird eine Ausnahme ausgelöst. Sie können COO-Indizes abfragen wie:

block_sparse_indices = sparse_tensor.as_blocksparse_view().indices()

was ein Numpy-Array zurückgibt, das vom nativen Speicher unterstützt wird.

as_coo_view()[Quelle]#

Die Methode gibt eine COO-Darstellung des Sparse-Tensors zurück, die das Abfragen von COO-Indizes ermöglicht. Wenn die Instanz kein COO-Format enthält, wird eine Ausnahme ausgelöst. Sie können COO-Indizes abfragen wie:

coo_indices = sparse_tensor.as_coo_view().indices()

was ein Numpy-Array zurückgibt, das vom nativen Speicher unterstützt wird.

as_csrc_view()[Quelle]#

Die Methode gibt eine CSR(C)-Darstellung des Sparse-Tensors zurück, die das Abfragen von CRS(C)-Indizes ermöglicht. Wenn die Instanz kein CSR(C)-Format enthält, wird eine Ausnahme ausgelöst. Sie können Indizes abfragen wie:

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

gibt Numpy-Arrays zurück, die vom nativen Speicher unterstützt werden.

data_type()[Quelle]#

Gibt den Datentyp der Daten im OrtValue als String zurück.

dense_shape()[Quelle]#

Gibt ein Numpy-Array (int64) zurück, das die dichte Form eines Sparse-Tensors enthält.

device_name()[Quelle]#

Gibt den Namen des Geräts zurück, auf dem sich die SparseTensor-Datenpuffer befinden, z. B. CPU, CUDA.

format()[Quelle]#

Gibt eine OrtSparseFormat-Enumeration zurück.

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

Factory-Methode zur Erstellung eines SparseTensor im COO-Format aus gegebenen Argumenten.

Parameter:

  • dense_shape – 1D-Numpy-Array (int64) oder eine Python-Liste, die die dichte Form des Sparse-Tensors enthält. Muss sich im CPU-Speicher befinden.

  • values – ein homogenes, zusammenhängendes 1D-Numpy-Array, das die Nicht-Null-Elemente des Tensors eines bestimmten Typs enthält.

  • coo_indices – zusammenhängendes Numpy-Array (int64), das die COO-Indizes für den Tensor enthält. coo_indices kann eine 1D-Form haben, wenn es einen linearen Index von Nicht-Null-Werten enthält und seine Länge gleich der von values sein muss. Es kann auch eine 2D-Form haben, in der es Paare von Koordinaten für jeden der nnz-Werte enthält und seine Länge genau doppelt so lang wie die von values sein muss.

  • ort_device –

    • beschreibt den zugrunde liegenden Speicher, der von den bereitgestellten Numpy-Arrays gehalten wird. Nur CPU-Speicher wird

    für nicht-numerische Datentypen unterstützt.

Für primitive Typen ordnet die Methode die Arrays values und coo_indices dem nativen Speicher zu und verwendet sie als Backing-Speicher. Sie erhöht die Referenzanzahl für Numpy-Arrays und dekrementiert sie bei der Garbage Collection. Die Puffer können in jedem Speicher, sei es CPU oder GPU, liegen. Für Zeichenketten und Objekte werden Kopien der Arrays im CPU-Speicher erstellt, da ORT diese auf anderen Geräten nicht unterstützt und ihr Speicher nicht abgebildet werden kann.

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

Factory-Methode zur Erstellung eines SparseTensor im CSR-Format aus gegebenen Argumenten.

Parameter:

  • dense_shape – 1D-Numpy-Array (int64) oder eine Python-Liste, die die dichte Form des Sparse-Tensors enthält (Zeilen, Spalten). Muss sich im CPU-Speicher befinden.

  • values – ein zusammenhängendes, homogenes 1D-Numpy-Array, das die Nicht-Null-Elemente des Tensors eines bestimmten Typs enthält.

  • inner_indices – zusammenhängendes 1D-Numpy-Array (int64), das die CSR-Inner-Indizes für den Tensor enthält. Seine Länge muss gleich der von values sein.

  • outer_indices – zusammenhängendes 1D-Numpy-Array (int64), das die CSR-Outer-Indizes für den Tensor enthält. Seine Länge muss gleich der Anzahl der Zeilen + 1 sein.

  • ort_device –

    • beschreibt den zugrunde liegenden Speicher, der von den bereitgestellten Numpy-Arrays gehalten wird. Nur CPU-Speicher wird

    für nicht-numerische Datentypen unterstützt.

Für primitive Typen ordnet die Methode die Arrays values und indices dem nativen Speicher zu und verwendet sie als Backing-Speicher. Sie erhöht die Referenzanzahl und dekrementiert sie, wenn sie GC-verwaltet wird. Die Puffer können in jedem Speicher, sei es CPU oder GPU, liegen. Für Zeichenketten und Objekte werden Kopien der Arrays im CPU-Speicher erstellt, da ORT diese auf anderen Geräten nicht unterstützt und ihr Speicher nicht abgebildet werden kann.

to_cuda(ort_device)[Quelle]#

Gibt eine Kopie dieser Instanz auf dem angegebenen CUDA-Gerät zurück.

Parameter:

ort_device – mit dem Namen 'cuda' und einer gültigen GPU-Geräte-ID.

Die Methode löst eine Ausnahme aus, wenn

  • diese Instanz Zeichenketten enthält.

  • diese Instanz sich bereits auf der GPU befindet. Cross-GPU-Kopien werden nicht unterstützt.

  • CUDA in diesem Build nicht vorhanden ist.

  • das angegebene Gerät ungültig ist.

values()[Quelle]#

Die Methode gibt ein Numpy-Array zurück, das vom nativen Speicher unterstützt wird, wenn der Datentyp numerisch ist. Andernfalls enthält das zurückgegebene Numpy-Array Kopien der Zeichenketten.

Geräte#

IOBinding#

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

Diese Klasse bietet eine API zum Binden von Ein- und Ausgaben an ein bestimmtes Gerät, z. B. eine GPU.

bind_cpu_input(name, arr_on_cpu)[Quelle]#

Bindet eine Eingabe an ein Array auf der CPU. :param name: Eingabename :param arr_on_cpu: Eingabewerte als Python-Array auf der CPU.

bind_input(name, device_type, device_id, element_type, shape, buffer_ptr)[Quelle]#
Parameter:

  • name – Eingabename

  • device_type – z. B. cpu, cuda, cann

  • device_id – Geräte-ID, z. B. 0.

  • element_type – Eingabeelementtyp

  • shape – Eingabeform

  • buffer_ptr – Speicherzeiger auf Eingabedaten

bind_ortvalue_input(name, ortvalue)[Quelle]#
Parameter:

  • name – Eingabename

  • ortvalue – Zu bindende OrtValue-Instanz

bind_ortvalue_output(name, ortvalue)[Quelle]#
Parameter:

  • name – Ausgabename

  • ortvalue – Zu bindende OrtValue-Instanz

bind_output(name, device_type='cpu', device_id=0, element_type=None, shape=None, buffer_ptr=None)[Quelle]#
Parameter:

  • name – Ausgabename

  • device_type – z. B. cpu, cuda, cann, standardmäßig cpu.

  • device_id – Geräte-ID, z. B. 0.

  • element_type – Ausgabeelementtyp

  • shape – Ausgabeform

  • buffer_ptr – Speicherzeiger auf Ausgabedaten

copy_outputs_to_cpu()[Quelle]#

Kopiert die Ausgaben auf die CPU.

get_outputs()[Quelle]#

Gibt die Ausgabe-OrtValues vom Run() zurück, der dem Aufruf vorausging. Der Datenpuffer der erhaltenen OrtValues befindet sich möglicherweise nicht im CPU-Speicher.

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

Überladene Funktion.

  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)#

Überladene Funktion.

  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)[Quelle]#

Eine Datenstruktur, die das zugrunde liegende C++ OrtDevice freilegt.

Interner Konstruktor

Interne Klassen#

Diese Klassen können nicht von Benutzern instanziiert werden, werden aber von Methoden oder Funktionen dieser Bibliothek zurückgegeben.

ModelMetadata#

class onnxruntime.ModelMetadata#

Vordefinierte und benutzerdefinierte Metadaten zum Modell. Sie werden normalerweise verwendet, um das zur Vorhersageausführung verwendete Modell zu identifizieren und den Vergleich zu erleichtern.

property custom_metadata_map#

zusätzliche Metadaten

property description#

Beschreibung des Modells

property domain#

ONNX-Domäne

property graph_description#

Beschreibung des im Modell gehosteten Graphen

property graph_name#

Graph-Name

property producer_name#

Herstellername

property version#

Version des Modells

NodeArg#

class onnxruntime.NodeArg#

Knotenargumentdefinition, sowohl für Ein- als auch für Ausgaben, einschließlich Argumentname, Argumenttyp (enthält sowohl Typ als auch Form).

property name#

Knotenname

property shape#

Knotenform (unter der Annahme, dass der Knoten einen Tensor enthält)

property type#

Knotentyp

Backend#

Zusätzlich zur regulären API, die für Leistung und Benutzerfreundlichkeit optimiert ist, implementiert ONNX Runtime auch die ONNX Backend API zur Überprüfung der Konformität mit der ONNX-Spezifikation. Die folgenden Funktionen werden unterstützt:

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

Gibt zurück, ob das Modell mit dem Backend kompatibel ist.

Parameter:

  • model – ungenutzt

  • device – None zur Verwendung des Standardgeräts oder ein String (z. B. 'CPU')

Rückgabe:

boolean

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

Lädt das Modell und erstellt eine onnxruntime.InferenceSession, die als Backend verwendet werden kann.

Parameter:

  • model – ModelProto (zurückgegeben von onnx.load), String für einen Dateinamen oder Bytes für ein serialisiertes Modell

  • device – angefordertes Gerät für die Berechnung, None bedeutet das Standardgerät, das von den Kompilierungseinstellungen abhängt

  • kwargs – siehe onnxruntime.SessionOptions

Rückgabe:

onnxruntime.InferenceSession

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

Berechnet die Vorhersage.

Parameter:

  • model – onnxruntime.InferenceSession zurückgegeben von der Funktion prepare

  • inputs – Eingaben

  • device – angefordertes Gerät für die Berechnung, None bedeutet das Standardgerät, das von den Kompilierungseinstellungen abhängt

  • kwargs – siehe onnxruntime.RunOptions

Rückgabe:

Vorhersagen

onnxruntime.backend.supports_device(device)#

Prüft, ob das Backend mit einer bestimmten Geräteunterstützung kompiliert wurde. Dies wird insbesondere in der Testsuite verwendet.