自動デバイス選択

自動デバイス選択モード (略して AUTO) は、“仮想” または “プロキシー” デバイスを使用します。これは、特定の種類のハードウェアにバインドされず、推論用の処理ユニットを自動的に選択します。利用可能なデバイスを検出し、タスクに最適なデバイスを選択し、その最適化設定を構成します。これにより、アプリケーションを一度作成することで、どこにでもデプロイできます。

プロセスから一部のハードウェアを除外することを選択すると、選択は “ヒント” 構成 API で定義されたパフォーマンス要件や、デバイスの優先順位リストの制限にも依存します。

選択の論理は次のとおりです。

1. サポートされているデバイスを確認します。

2. 入力モデルの精度を確認します (精度の詳細については、ov::device::capabilities を参照してください)。

3. 以下の表に示されるように、特定のモデルをサポートする最も優先度の高いデバイスを選択します。

4. モデルの精度が FP32 であり、それをサポートできるデバイスがない場合は、モデルを FP16 をサポートするデバイスにオフロードします。

デバイスの優先順位	サポートされるデバイス	サポートされるモデル制度
1	dGPU (例: インテル® Iris® Xe MAX)	FP32、FP16、INT8、BIN
2	iGPU (例: インテル® UHD グラフィックス 620 (iGPU))	FP32、FP16、BIN
3	インテル® CPU (例: インテル® Core™ i7-1165G7)	FP32、FP16、INT8、BIN
4	インテル® NPU (例: インテル® Core™ Ultra)

注

現在、NPU はデフォルトの優先順位リストから除外されていることに注意してください。推論に使用するには、明示的に指定する必要があります。

AUTO の仕組み

リストの最初のデバイスへのモデルのロードが失敗すると、AUTO はいずれかのデバイスが成功するまで、そのラインにある次のデバイスへのロードを試行します。重要なことは、AUTO はデフォルトでシステムの CPU を使用して推論を開始することです。これは、待ち時間が非常に短く、追加のレイテンシーなしで推論を開始できるためです。CPU が推論を実行している間、AUTO は最適なデバイスにモデルをロードし続け、準備ができたらタスクをデバイスに転送します。これにより、モデルのコンパイルがはるかに遅いデバイス (GPU がその例) は、初期ステージでは推論に影響を与えません。例えば、CPU と GPU を使用する場合、AUTO の最初の推論レイテンシーは、GPU を単独で使用する場合よりも向上します。

優先リストから CPU を除外するか、ov::intel_auto::enable_startup_fallback によって初期の CPU アクセラレーション機能を無効にした場合、初期のモデル・コンパイル・ステージをサポートできなくなることに注意してください。動的入出力またはステートフル操作を備えたモデル候補リストにある場合は、CPU にロードされます。それ以外の場合、これらのモデルは通常のフローに従い、優先順位に基づいてデバイスにロードされます。

このメカニズムは、ベンチマーク・アプリで AUTO を使用のサンプルセクションで観察でき、AUTO を使用したときに最初の推論のレイテンシー (モデルのコンパイルと最初の推論の実行にかかる時間) がどのように短縮されるかを示しています。
例:

benchmark_app -m ../public/alexnet/FP32/alexnet.xml -d GPU -niter 128

benchmark_app -m ../public/alexnet/FP32/alexnet.xml -d AUTO -niter 128

注

プロセスの実行時間が長ければ長いほど、リアルタイム・パフォーマンスは最適なデバイスのパフォーマンスに近づきます。

AUTO を使用

OpenVINO™ 命名規則に従って、自動デバイス選択モードには “AUTO” ラベルが割り当てられます。追加のパラメーターを指定せずに定義してデフォルトを使用することも、次のセットアップ・オプションを使用してさらに構成することもできます。

プロパティー (C++ バ―ション)	値と説明
<デバイス候補リスト>	値: 空 AUTO AUTO: <device names> (スペースなしのカンマ区切り) 選択可能なデバイスをリスト。デバイスの順序は、高から低の順に優先されます。指定しない場合、デフォルトとして AUTO が使用され、すべてのデバイスが候補として “表示” されます。
ov::device::priorities	値: <device names> (スペースなしのカンマ区切り) AUTO で選択するデバイスを指定します。デバイスの順序は、高から低の順に優先されます。この構成はオプションです。
ov::hint::performance_mode	値: ov::hint::PerformanceMode::LATENCY ov::hint::PerformanceMode::THROUGHPUT ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT アプリケーションが優先するパフォーマンス・オプションを指定します。
ov::hint::model_priority	値: ov::hint::Priority::HIGH ov::hint::Priority::MEDIUM ov::hint::Priority::LOW モデルの優先度を示します。 重要: このプロパティーはまだ完全にはサポートされていません。
ov::execution_devices	推論が実行されているランタイム・ターゲット・デバイスをリストします。 返される結果の例としては、(CPU) (CPU は一時的なデバイスであり、CPU がモデルのコンパイル段階での高速化に使用されることを示します)、CPU、GPU、CPU GPU、GPU.0 などがあります。
ov::intel_auto::enable_startup_fallback	値: true false 最初に CPU をアクセラレーション (またはヘルパーデバイス) として有効/無効にします。デフォルト値は true で、デフォルトで CPU がアクセラレーションとして使用されることを示します。
ov::intel_auto::enable_runtime_fallback	値: true false 現在選択されているデバイスで推論要求が失敗した場合、他のデバイスへのランタイム・フォールバックを有効または無効にし、失敗した推論要求を再度実行します。 デフォルト値は true です。
ov::intel_auto::schedule_policy	値: ROUND_ROBIN DEVICE_PRIORITY AUTO 累積モード (MULTI) のハードウェア・プラグインに割り当てる推論要求のスケジュール・ポリシーを指定します。 デフォルト値は DEVICE_PRIORITY です。

AUTO による推論は、デバイスプラグインが使用される場合と同様に構成されます。構成を使用してプラグイン上でモデルをコンパイルし、推論を実行します。

ここのサンプルコードでは、コードの先頭に次の import (Python)/using (C++) が含まれていることを前提としています。

Python

import openvino as ov
import openvino.properties as properties
import openvino.properties.device as device
import openvino.properties.hint as hints
import openvino.properties.streams as streams
import openvino.properties.intel_auto as intel_auto

C++

#include <openvino/openvino.hpp>

デバイスの候補と優先順位

デバイス候補リストを使用すると、優先順位をカスタマイズし、AUTO で使用できるデバイスの選択を制限できます。

• <デバイス候補リスト>が指定されていない場合、AUTO はシステム内に存在するすべてのデバイスが使用できると想定します。

• デバイス名なしの AUTO を指定した場合、AUTO はシステム内に存在するすべてのデバイスが使用可能であると想定し、ネットワークをすべてのデバイスにロードし、デフォルトの優先順位 (高から低) に基づいて推論を実行します。

デバイスの優先順位を指定するには、AUTO: <device names> にデバイス名を優先順位 (高から低) で入力するか、ov::device::priorities プロパティーを使用します。

AUTO の使用とデバイスの指定については、次のコードを参照してください。

Python

    core = ov.Core()

    #  compile a model on AUTO using the default list of device candidates.
    #  The following lines are equivalent:
    compiled_model = core.compile_model(model=model)
    compiled_model = core.compile_model(model=model, device_name="AUTO")

    # Optional
    # You can also specify the devices to be used by AUTO.
    # The following lines are equivalent:
    compiled_model = core.compile_model(model=model, device_name="AUTO:GPU,CPU")
    compiled_model = core.compile_model(
    model=model,
    device_name="AUTO",
    config={device.priorities: "GPU,CPU"},
    )

    # Optional
    # the AUTO plugin is pre-configured (globally) with the explicit option:
    core.set_property(
    device_name="AUTO", properties={device.priorities: "GPU,CPU"}
    )

C++

ov::Core core;

// Read a network in IR, PaddlePaddle, or ONNX format:
std::shared_ptr<ov::Model> model = core.read_model("sample.xml");

// compile a model on AUTO using the default list of device candidates.
// The following lines are equivalent:
ov::CompiledModel model0 = core.compile_model(model);
ov::CompiledModel model1 = core.compile_model(model, "AUTO");

// Optional
// You can also specify the devices to be used by AUTO.
// The following lines are equivalent:
ov::CompiledModel model3 = core.compile_model(model, "AUTO:GPU,CPU");
ov::CompiledModel model4 = core.compile_model(model, "AUTO", ov::device::priorities("GPU,CPU"));

//Optional
// the AUTO plugin is pre-configured (globally) with the explicit option:
core.set_property("AUTO", ov::device::priorities("GPU,CPU"));

OpenVINO ランタイムでは、関数呼び出しで “GPU.0” のエイリアスとして “GPU” を使用できることに注意してください。デバイスの列挙の詳細については、推論デバイスとモードを参照してください。

利用可能なデバイスを確認

システムにあるデバイスを確認するには、以下に示すデバイス API を使用できます。使用方法については、デバイスのプロパティーと構成の照会を参照してください。

Python

openvino.runtime.Core.available_devices

「Hello デバイス照会 Python サンプル」を参照してください。

C++

ov::runtime::Core::get_available_devices()

「Hello デバイス照会 C++ サンプル」を参照してください。

デバイス候補リストからデバイスを除外

例えば、他のジョブの実行に CPU を予約するため、ハードウェア・デバイスを AUTO から除外することもできます。その場合、AUTO は推論にデバイスを使用しません。これを行うには、次の例のように、AUTO: <device names> で CPU の前にマイナス記号 (-) を追加します。

Python

compiled_model = core.compile_model(model=model, device_name="AUTO:-CPU")

C++

ov::CompiledModel compiled_model = core.compile_model(model, "AUTO:-CPU");

次に、AUTO は利用可能なすべてのデバイスを照会し、CPU を候補リストから削除します。

デバイス候補リストから CPU すると、CPU はモデルの初期コンパイルステージをサポートできなくなることに注意してください。詳細は、AUTO の仕組みを参照してください。

AUTO のパフォーマンス・ヒント

ov::hint::performance_mode プロパティーを使用すると、AUTO のパフォーマンス・オプションをより効率的に指定できます。AUTO のデフォルトのヒントは LATENCY です。

以下の THROUGHPUT と CUMULATIVE_THROUGHPUT ヒントは、非同期推論パイプラインのパフォーマンスのみを向上させます。非同期推論の詳細については、Async API documentation を参照してください。次のノートブックでは、非同期パイプラインを設定する例を示します。

• 非同期画像分類のサンプル

• ノートブック - OpenVINO™ による非同期推論

• ノートブック - OpenVINO による自動デバイス選択

LATENCY

このオプションでは低レイテンシーが優先され、各推論ジョブの応答時間が短くなります。単一の入力画像で推論が必要なタスクに最適なパフォーマンスを発揮します (例: 超音波スキャン画像の医学的分析)。また、環境内で動作する産業用ロボットの反応、または自律走行車の障害物回避などのリアルタイムのアプリケーション・タスクにも適合します。

注

パフォーマンスのヒントが設定されていない場合、AUTO は ov::device::properties を設定していないデバイスに LATENCY を設定します。例えば、ov::device::properties(<DEVICE_NAME>, ov::hint::performance_mode(ov::hint::LATENCY)))。

THROUGHPUT

このオプションは、高スループットを目標とし、レイテンシーと電力のバランスを優先します。ビデオフィードや大量の画像の推論など、複数のジョブを伴うタスクに最適です。

CUMULATIVE_THROUGHPUT

LATENCY と THROUGHPUT では、パフォーマンス・オプションを使用して 1 つのターゲットデバイスを選択できますが、CUMULATIVE_THROUGHPUT オプションを使用すると、複数のデバイスで推論を実行することでスループットを向上できます。CUMULATIVE_THROUGHPUT を使用すると、AUTO は候補リスト内の利用可能なデバイスにネットワーク・モデルをロードし、デフォルトまたは指定された優先順位に基づいてそれらのデバイスで推論を実行します。

CUMULATIVE_THROUGHPUT は、マルチデバイス実行モード (MULTI) と同様の動作をします。唯一の違いは、CUMULATIVE_THROUGHPUT は AUTO で指定されたデバイスを使用しますが (つまり、手動でデバイスを追加する必要はありませんが)、MULTI では推論前にデバイスを指定する必要があります。

CUMULATIVE_THROUGHPUT でデバイスの優先順位が指定されている場合、AUTO は優先順位に基づいてデバイス上で推論要求を実行します。次の例では、AUTO は常に最初に GPU を使用し、GPU がビジーな場合は次に CPU を使用します。

Python

compiled_model = core.compile_model(model, "AUTO:GPU,CPU", {hints.performance_mode: hints.PerformanceMode.CUMULATIVE_THROUGHPUT})

C++

ov::CompiledModel compiled_model = core.compile_model(model, "AUTO:GPU,CPU", ov::hint::performance_mode(ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT));

デバイス名を指定せずに AUTO が使用され、システム内に複数の GPU がある場合、CUMULATIVE_THROUGHPUT モードはデフォルトですべての GPU を使用します。システムに 3 つ以上の GPU デバイスがある場合、AUTO はデバイス候補リストから CPU を削除し、すべての GPU で実行し続けます。システムデバイスとその一意の識別子の完全なリストは、ov::Core::get_available_devices を使用して照会できます (詳細については、デバイス・プロパティーの照会を参照してください)。GPU を明示的に指定するには、AUTO でコンパイルする際に優先順位を設定します。

Python

compiled_model = core.compile_model(model, "AUTO:GPU.1,GPU.0", {hints.performance_mode: hints.PerformanceMode.CUMULATIVE_THROUGHPUT})

C++

ov::CompiledModel compiled_model = core.compile_model(model, "AUTO:GPU.1,GPU.0", ov::hint::performance_mode(ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT));

サンプルコード

アプリケーションのパフォーマンス・ヒントを有効にするには、次のコードを使用します。

Python

    core = ov.Core()

    # Compile a model on AUTO with Performance Hints enabled:
    # To use the “THROUGHPUT” mode:
    compiled_model = core.compile_model(
        model=model,
        device_name="AUTO",
        config={
            hints.performance_mode: hints.PerformanceMode.THROUGHPUT
        },
    )
    # To use the “LATENCY” mode:
    compiled_model = core.compile_model(
        model=model,
        device_name="AUTO",
        config={
            hints.performance_mode: hints.PerformanceMode.LATENCY
        },
    )
    # To use the “CUMULATIVE_THROUGHPUT” mode:
    # To use the ROUND_ROBIN schedule policy:
    compiled_model = core.compile_model(
        model=model,
        device_name="AUTO",
        config={
            hints.performance_mode: hints.PerformanceMode.CUMULATIVE_THROUGHPUT,
            intel_auto.schedule_policy: intel_auto.SchedulePolicy.ROUND_ROBIN
        },
    )

C++

ov::Core core;

// Read a network in IR, PaddlePaddle, or ONNX format:
std::shared_ptr<ov::Model> model = core.read_model("sample.xml");

// Compile a model on AUTO with Performance Hint enabled:
// To use the “THROUGHPUT” option:
ov::CompiledModel compiled_model = core.compile_model(model, "AUTO",
    ov::hint::performance_mode(ov::hint::PerformanceMode::THROUGHPUT));
// To use the “LATENCY” option:
ov::CompiledModel compiled_mode2 = core.compile_model(model, "AUTO",
    ov::hint::performance_mode(ov::hint::PerformanceMode::LATENCY));
// To use the “CUMULATIVE_THROUGHPUT” option:
ov::CompiledModel compiled_mode3 = core.compile_model(model, "AUTO",
    ov::hint::performance_mode(ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT));    

THROUGHPUT および CUMULATIVE_THROUGHPUT の自動バッチ処理の無効化

ov::hint::PerformanceMode::THROUGHPUT モードと ov::hint::PerformanceMode::CUMULATIVE_THROUGHPUT モードは、デフォルトで自動バッチ処理 (GPU デバイスなど) をトリガーします。ov::hint::allow_auto_batching(false) を設定するか、デフォルトのタイムアウト値を大きな数値 (例: ov::auto_batch_timeout(1000)) に変更することでこれを無効にできます。自動バッチ処理を参照してください。

モデルの優先順位を構成

ov::hint::model_priority プロパティーを使用すると、Auto-Device プラグイン内のモデルの優先順位を制御できます。高い優先度のモデルは、サポートされている高優先度デバイスにロードされます。優先度の低いモデルは、優先度の高いモデルが占有するデバイスにはロードされません。

Python

    core = ov.Core()

    # Example 1
    compiled_model0 = core.compile_model(
        model=model,
        device_name="AUTO",
        config={hints.model_priority: hints.Priority.HIGH},
    )
    compiled_model1 = core.compile_model(
        model=model,
        device_name="AUTO",
        config={
            hints.model_priority: hints.Priority.MEDIUM
        },
    )
    compiled_model2 = core.compile_model(
        model=model,
        device_name="AUTO",
        config={hints.model_priority: hints.Priority.LOW},
    )
    # Assume that all the devices (CPU and GPUs) can support all the networks.
    # Result: compiled_model0 will use GPU.1, compiled_model1 will use GPU.0, compiled_model2 will use CPU.

    # Example 2
    compiled_model3 = core.compile_model(
        model=model,
        device_name="AUTO",
        config={hints.model_priority: hints.Priority.HIGH},
    )
    compiled_model4 = core.compile_model(
        model=model,
        device_name="AUTO",
        config={
            hints.model_priority: hints.Priority.MEDIUM
        },
    )
    compiled_model5 = core.compile_model(
        model=model,
        device_name="AUTO",
        config={hints.model_priority: hints.Priority.LOW},
    )
    # Assume that all the devices (CPU ang GPUs) can support all the networks.
    # Result: compiled_model3 will use GPU.1, compiled_model4 will use GPU.1, compiled_model5 will use GPU.0.

C++

// Example 1
ov::CompiledModel compiled_model0 = core.compile_model(model, "AUTO",
    ov::hint::model_priority(ov::hint::Priority::HIGH));
ov::CompiledModel compiled_model1 = core.compile_model(model, "AUTO",
    ov::hint::model_priority(ov::hint::Priority::MEDIUM));
ov::CompiledModel compiled_model2 = core.compile_model(model, "AUTO",
    ov::hint::model_priority(ov::hint::Priority::LOW));
/************
  Assume that all the devices (CPU and GPUs) can support all the models.
  Result: compiled_model0 will use GPU.1, compiled_model1 will use GPU.0, compiled_model2 will use CPU.
 ************/

// Example 2
ov::CompiledModel compiled_model3 = core.compile_model(model, "AUTO",
    ov::hint::model_priority(ov::hint::Priority::LOW));
ov::CompiledModel compiled_model4 = core.compile_model(model, "AUTO",
    ov::hint::model_priority(ov::hint::Priority::MEDIUM));
ov::CompiledModel compiled_model5 = core.compile_model(model, "AUTO",
    ov::hint::model_priority(ov::hint::Priority::LOW));
/************
  Assume that all the devices (CPU and GPUs) can support all the models.
  Result: compiled_model3 will use GPU.1, compiled_model4 will use GPU.1, compiled_model5 will use GPU.0.
 ************/

ターゲット・ランタイム・デバイスの確認

AUTO で推論が実行されているランタイム・ターゲット・デバイスを照会するには、ov::execution_devices プロパティーを使用できます。これは get_property とともに使用する必要があります。
例:

Python

    core = ov.Core()

    # compile a model on AUTO and set log level to debug
    compiled_model = core.compile_model(model=model, device_name="AUTO")
    # query the runtime target devices on which the inferences are being executed
    execution_devices = compiled_model.get_property(properties.execution_devices)

C++

ov::Core core;

// read a network in IR, PaddlePaddle, or ONNX format
std::shared_ptr<ov::Model> model = core.read_model("sample.xml");

// compile a model on AUTO and set log level to debug
ov::CompiledModel compiled_model = core.compile_model(model, "AUTO");
// query the runtime target devices on which the inferences are being executed
ov::Any execution_devices = compiled_model.get_property(ov::execution_devices);

個々のデバイスの構成と自動デバイスプラグインの作成

現時点では、上記の方法が AUTO 推論実行の推奨方法ですが、次の手順を代替手段として使用することもできます。現在、これは従来の機能として利用可能であり、AUTO がパフォーマンス・ヒント・オプションを利用できない場合に使用されます。

Python

    core = ov.Core()

    # gpu_config and cpu_config will load during compile_model()
    gpu_config = {
        hints.performance_mode: hints.PerformanceMode.THROUGHPUT,
        streams.num: 4
    }
    cpu_config = {
        hints.performance_mode: hints.PerformanceMode.LATENCY,
        streams.num: 8,
        properties.enable_profiling: True
    }
    compiled_model = core.compile_model(
        model=model,
        device_name="AUTO",
        config={
            device.priorities: "GPU,CPU",
            device.properties: {'CPU': cpu_config, 'GPU': gpu_config}
        }
    )

C++

ov::Core core;

// Read a network in IR, TensorFlow, TensorFlow Lite, PaddlePaddle, or ONNX format:
std::shared_ptr<ov::Model> model = core.read_model("sample.xml");

// Configure the CPU and the GPU devices when compiling model
ov::CompiledModel compiled_model = core.compile_model(model, "AUTO",
    ov::device::properties("CPU", cpu_config),
    ov::device::properties("GPU", gpu_config));

OpenVINO サンプルおよびベンチマーク・アプリで AUTO を使用

Auto-Device プラグインがどのように使用されているかを確認し、パフォーマンスをテストするには、OpenVINO™ サンプルをご覧ください。“-d” コマンドライン・オプション (“デバイス” の略) をサポートするすべてのサンプルは、そのままプラグインを受け入れます。ベンチマーク・アプリケーションは始めるのに最適です - リクエストや CPU スレッドの数などを追加設定することなく、プラグインの最適なパフォーマンスを示します。AUTO のパフォーマンスを評価するには、次のコマンドを使用できます。

無制限にデバイスを選択できる場合:

benchmark_app –d AUTO –m <model> -i <input> -niter 1000

デバイスの選択肢が限られている場合:

benchmark_app –d AUTO:CPU,GPU –m <model> -i <input> -niter 1000

詳細については、ベンチマーク・ツールを参照してください。

注

“-d AUTO” を使用する場合、デフォルトの CPU ストリームは 1 です。

FP16 IR を使用して自動デバイスを操作できます。

最適なデバイスの選択、GPU ストリーム/スロットルの使用などによって、AUTO 向けに完全に最適化されたデモはまだありません。

関連情報

• AUTO 実行をデバッグ

• 複数のデバイスで同時に実行する

• 推論デバイスとモード