Vitis AI Execution Provider

Vitis AI ist AMDs Entwicklungsstapel für hardwarebeschleunigte KI-Inferenz auf AMD-Plattformen, einschließlich Ryzen AI, AMD Adaptable SoCs und Alveo Data Center Acceleration Cards.

Inhalt

• Voraussetzungen
• Installation
• Erstellen
• Quantisierung
• Runtime-Optionen
• Ryzen AI API Beispiele

Voraussetzungen

Die folgende Tabelle listet die AMD-Ziele auf, die vom Vitis AI ONNX Runtime Execution Provider unterstützt werden.

Architektur	Familie	Unterstützte Ziele	Unterstützte Betriebssysteme
AMD64	Ryzen AI	AMD Ryzen Prozessoren mit NPUs	Windows
Arm® Cortex®-A53	Zynq UltraScale+ MPSoC	ZCU102, ZCU104, KV260	Linux
Arm® Cortex®-A72	Versal AI Core / Premium	VCK190	Linux
Arm® Cortex®-A72	Versal AI Edge	VEK280	Linux

Eine vollständige Liste der AMD Ryzen Prozessoren mit NPUs finden Sie auf der Seite mit den Prozessorspezifikationen (suchen Sie nach der Spalte „AMD Ryzen AI“ auf der rechten Seite der Tabelle und wählen Sie „Verfügbar“ aus dem Dropdown-Menü).

AMD Adaptable SoC-Entwickler können auch den Vitis AI ONNX Runtime Execution Provider nutzen, um benutzerdefinierte (Chip-Down-)Designs zu unterstützen.

Installation

Installation für AMD Ryzen AI Prozessoren

Um den Vitis AI ONNX Runtime Execution Provider unter Microsoft Windows für AMD Ryzen AI Prozessoren zu aktivieren, müssen Entwickler die Ryzen AI Software installieren. Detaillierte Anweisungen zum Herunterladen und Installieren der Ryzen AI Software finden Sie hier: https://ryzenai.docs.amd.com/en/latest/inst.html

Für vollständige Beispiele, die auf AMD Ryzen AI Prozessoren abzielen, sollten Entwickler das RyzenAI-SW Github-Repository konsultieren.

Installation für AMD Adaptable SoCs

Für AMD Adaptable SoC-Ziele wird ein vorcompiliertes Paket zur Bereitstellung von ONNX-Modellen auf Embedded Linux bereitgestellt. Benutzer sollten die Standard-Vitis-AI Ziel-Setup-Anweisungen konsultieren, um Vitis AI auf dem Ziel zu aktivieren. Sobald Vitis AI auf dem Ziel aktiviert wurde, kann sich der Entwickler für Installations- und API-Details auf diesen Abschnitt der Vitis AI-Dokumentation beziehen.

Für vollständige Beispiele, die auf AMD Adaptable SoCs abzielen, sollten Entwickler die ONNX Runtime Vitis AI Execution Provider Beispiele konsultieren.

Build

Um den Ryzen AI Vitis AI ONNX Runtime Execution Provider aus dem Quellcode zu erstellen, beachten Sie bitte die Build-Anweisungen.

Quantisierung

Quantisierung ist der Prozess der Abbildung von hochpräzisen Gewichten/Aktivierungen auf ein niedrigpräziseres Format unter Beibehaltung der Modellgenauigkeit. Diese Technik verbessert die rechnerische und speicherseitige Effizienz des Modells für die Bereitstellung auf NPU-Geräten. Sie kann nach dem Training angewendet werden, sodass bestehende Modelle ohne erneutes Training optimiert werden können.

Der Vitis AI EP unterstützt Eingangsmodelle, die entweder im INT8- oder BF16-Format quantisiert sind.

Die Quantisierung von Ryzen AI Modellen kann entweder mit dem AMD Quark Quantizer, dem Vitis AI Quantizer oder Olive erfolgen.

AMD Quark

AMD Quark ist ein umfassendes plattformübergreifendes Deep-Learning-Toolkit, das entwickelt wurde, um die Quantisierung von Deep-Learning-Modellen zu vereinfachen und zu verbessern. Quark unterstützt sowohl PyTorch- als auch ONNX-Modelle und ermöglicht Entwicklern, ihre Modelle für die Bereitstellung auf einer Vielzahl von Hardware-Backends zu optimieren und so erhebliche Leistungssteigerungen zu erzielen, ohne die Genauigkeit zu beeinträchtigen.

Vollständige Details finden Sie in der AMD Quark Dokumentation für Ryzen AI.

Vitis AI Quantizer

Der Vitis AI Quantizer unterstützt die Quantisierung von PyTorch-, TensorFlow- und ONNX-Modellen.

Pytorch, Tensorflow 2.x und Tensorflow 1.x Docker-Images sind verfügbar, um die Quantisierung von PyTorch- und TensorFlow-Modellen zu unterstützen. Zur Unterstützung des Vitis AI ONNX Runtime Execution Providers gibt es im Vitis AI Quantizer eine Option, ein quantisiertes Modell im ONNX-Format zu exportieren, nach der Quantisierung.

Vollständige Details finden Sie in der Vitis AI Dokumentation zur Quantisierung von Modellen.

Olive

Experimentelle Unterstützung für Microsoft Olive ist ebenfalls aktiviert. Der Vitis AI Quantizer wurde als Plugin in Olive integriert und wird in den Hauptzweig überführt. Sobald dies abgeschlossen ist, können Benutzer die im Olive Vitis AI Beispielverzeichnis bereitgestellten Beispiele konsultieren.

Runtime-Optionen

Der Vitis AI ONNX Runtime integriert einen Compiler, der den Modellgraphen und die Gewichte als mikrocodierte ausführbare Datei kompiliert. Diese ausführbare Datei wird auf dem Zielbeschleuniger (Ryzen AI NPU oder Vitis AI DPU) bereitgestellt.

Das Modell wird kompiliert, wenn die ONNX Runtime-Sitzung gestartet wird, und die Kompilierung muss vor dem ersten Inferenzdurchlauf abgeschlossen sein. Die Kompilierungsdauer variiert, kann aber einige Minuten dauern. Sobald das Modell kompiliert ist, wird die ausführbare Modelldatei zwischengespeichert, und für nachfolgende Inferenzläufe kann optional die zwischengespeicherte ausführbare Modelldatei verwendet werden (Details siehe unten).

Die folgenden Tabellen geben einen Überblick über die Provider-Optionen und Umgebungsvariablen, die zur Konfiguration der Inferenzsitzung verwendet werden können.

Für detaillierte Anweisungen zur Konfiguration der Inferenzsitzung für BF16- und INT8-Modelle auf AMD Ryzen AI Prozessoren beachten Sie bitte die Ryzen AI Software-Dokumentation

Provider-Option	Standardwert	Details
cache_dir	Linux: „/tmp/{user}/vaip/.cache/“ Windows: „C:\temp\{user}\vaip\.cache“	optional, Cache-Verzeichnis
cache_key	{onnx_model_md5}	optional, Cache-Schlüssel, wird verwendet, um zwischen verschiedenen Modellen zu unterscheiden.
log_level	„error“	Gültige Werte sind info, warning, error und fatal

Das endgültige Cache-Verzeichnis ist {cache_dir}/{cache_key}. Bitte beachten Sie das folgende C++-Beispiel für die Verwendung.

Ryzen AI API Beispiele

Um die C++-APIs zu nutzen, verwenden Sie das folgende Beispiel als Referenz

// ...
#include <onnxruntime_cxx_api.h>
// include user header files
// ...

std::basic_string<ORTCHAR_T> model_file = "resnet50.onnx" // Replace resnet50.onnx with your model name
Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "resnet50_pt");
auto session_options = Ort::SessionOptions();

auto options = std::unorderd_map<std::string,std::string>({});
// optional, eg: cache path : /tmp/my_cache/abcdefg // Replace abcdefg with your model name, eg. onnx_model_md5
options["cache_dir"] = "/tmp/my_cache";
options["cache_key"] = "abcdefg"; // Replace abcdefg with your model name, eg. onnx_model_md5
options["log_level"] = "info";

// Create an inference session using the Vitis AI execution provider
session_options.AppendExecutionProvider_VitisAI(options);

auto session = Ort::Session(env, model_file.c_str(), session_options);

// get inputs and outputs
Ort::AllocatorWithDefaultOptions allocator;
std::vector<std::string> input_names;
std::vector<std::int64_t> input_shapes;
auto input_count = session.GetInputCount();
for (std::size_t i = 0; i < input_count; i++) {
    input_names.emplace_back(session.GetInputNameAllocated(i, allocator).get());
    input_shapes = session.GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
}
std::vector<std::string> output_names;
auto output_count = session.GetOutputCount();
for (std::size_t i = 0; i < output_count; i++) {
   output_names.emplace_back(session.GetOutputNameAllocated(i, allocator).get());
}
// Create input tensors and populate input data
std::vector<Ort::Value> input_tensors;
...

auto output_tensors = session.Run(Ort::RunOptions(), input_names.data(), input_tensors.data(),
                    input_count, output_names.data(), output_count);
// postprocess output data
// ...

Um die Python-APIs zu nutzen, verwenden Sie das folgende Beispiel als Referenz

import onnxruntime

# Add user imports
# ...

# Load inputs and do preprocessing
# ...

# Create an inference session using the Vitis AI execution provider
session = onnxruntime.InferenceSession(
    '[model_file].onnx',
    providers=["VitisAIExecutionProvider"],
    provider_options=[{"log_level": "info"}])

input_shape = session.get_inputs()[0].shape
input_name = session.get_inputs()[0].name

# Load inputs and do preprocessing by input_shape
input_data = [...]
result = session.run([], {input_name: input_data})

Für vollständige Beispiele, die auf AMD Ryzen AI Prozessoren abzielen, sollten Entwickler das RyzenAI-SW Github-Repository konsultieren.

Für vollständige Beispiele, die auf AMD Adaptable SoCs abzielen, sollten Entwickler die ONNX Runtime Vitis AI Execution Provider Beispiele konsultieren.