Wybieranie dostawców wykonywania przy użyciu środowiska uruchomieniowego ONNX uwzględnionego w usłudze Windows ML

using Microsoft.ML.OnnxRuntime;
using System;
using System.Linq;
using System.Collections.Generic;

// Assuming you've created an OrtEnv named 'ortEnv'
// 1. Enumerate devices
var epDevices = ortEnv.GetEpDevices();

// 2. Filter to your desired execution provider and device type
var selectedEpDevices = epDevices
    .Where(d =>
        d.EpName == "ReplaceWithExecutionProvider"
        && d.HardwareDevice.Type == OrtHardwareDeviceType.NPU)
    .ToList();

if (selectedEpDevices.Count == 0)
{
    throw new InvalidOperationException("ReplaceWithExecutionProvider is not available on this system.");
}

// 3. Configure provider-specific options (varies based on EP)
// and append the EP with the correct devices (varies based on EP)
var sessionOptions = new SessionOptions();
var epOptions = new Dictionary<string,string>{ ["provider_specific_option"] = "4" };
sessionOptions.AppendExecutionProvider(ortEnv, new[] { selectedEpDevices.First() }, epOptions);

#include <iostream>
#include <iomanip>
#include <vector>
#include <stdexcept>
#include <winml/onnxruntime_cxx_api.h>

// Assuming you have an Ort::Env named 'env'
// 1. Enumerate EP devices
std::vector<Ort::ConstEpDevice> ep_devices = env.GetEpDevices();

// 2. Collect only ReplaceWithExecutionProvider NPU devices
std::vector<Ort::ConstEpDevice> selected_ep_devices;
for (const auto& d : ep_devices) {
    if (std::string(d.EpName()) == "ReplaceWithExecutionProvider"
        && d.HardwareDevice().Type() == OrtHardwareDeviceType_NPU) {
        selected_ep_devices.push_back(d);
    }
}
if (selected_ep_devices.empty()) {
    throw std::runtime_error("ReplaceWithExecutionProvider is not available on this system.");
}

// 3. Configure provider-specific options (varies based on EP)
// and append the EP with the correct devices (varies based on EP)
Ort::SessionOptions session_options;
Ort::KeyValuePairs ep_options;
ep_options.Add("provider_specific_option", "4");
session_options.AppendExecutionProvider_V2(env, { selected_ep_devices.front() }, ep_options);

# 1. Enumerate and filter EP devices
ep_devices = ort.get_ep_devices()
selected_ep_devices = [
    d for d in ep_devices 
    if d.ep_name == "ReplaceWithExecutionProvider" 
    and d.hardware_device.type == ort.OrtHardwareDeviceType.NPU
]
if not selected_ep_devices:
    raise RuntimeError("ReplaceWithExecutionProvider is not available on this system.")

# 2. Configure provider-specific options (varies based on EP)
# and append the EP with the correct devices (varies based on EP)
options = ort.SessionOptions()
provider_options = {"provider_specific_option": "4"}
options.add_provider_for_devices([selected_ep_devices[0]], provider_options)

// Configure the session to select an EP and device for MAX_EFFICIENCY which typically
// will choose an NPU if available with a CPU fallback.
var sessionOptions = new SessionOptions();
sessionOptions.SetEpSelectionPolicy(ExecutionProviderDevicePolicy.MAX_EFFICIENCY);

// Configure the session to select an EP and device for MAX_EFFICIENCY which typically
// will choose an NPU if available with a CPU fallback.
Ort::SessionOptions sessionOptions;
sessionOptions.SetEpSelectionPolicy(OrtExecutionProviderDevicePolicy_MAX_EFFICIENCY);

# Configure the session to select an EP and device for MAX_EFFICIENCY which typically
# will choose an NPU if available with a CPU fallback.
options = ort.SessionOptions()
options.set_provider_selection_policy(ort.OrtExecutionProviderDevicePolicy.MAX_EFFICIENCY)
assert options.has_providers()