Ausführen von ONNX-Inference in WebAssembly (WASM)-Datenflussdiagrammen

In diesem Artikel wird gezeigt, wie Sie kleine Open Neural Network Exchange (ONNX)Modelle in Ihre WebAssembly-Module einbetten und ausführen, um im Rahmen von Azure IoT Einsatz Datenflussdiagrammen eine In-Band-Ableitung durchzuführen. Verwenden Sie diesen Ansatz für die Anreicherung und Klassifizierung mit geringer Latenz direkt auf Streamingdaten, ohne externe Vorhersagedienste aufzurufen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie über die folgenden Elemente verfügen:

• Eine Azure IoT Einsatz Bereitstellung mit Datenflussdiagrammfunktionen.
• Eine Containerregistrierung wie Azure Container Registry und ein konfigurierter Containerregistrierungsendpunkt. Weitere Informationen finden Sie unter Konfigurieren von Registrierungsendpunkten.
• Eine Entwicklungsumgebung, die für die WebAssembly-Modulentwicklung eingerichtet ist. Optionen und detaillierte Anweisungen zum Einrichten der Umgebung finden Sie unter WebAssembly-Module entwickeln.

Vorteile der In-Band-ONNX-Inferenz

Mit Azure IoT Einsatz Datenflussdiagrammen können Sie die Inferenz kleiner ONNX-Modelle direkt in die Pipeline einbetten, anstatt einen externen Vorhersagedienst aufzurufen. Dieser Ansatz bietet die folgenden Vorteile:

• Geringe Latenz: Durchführen einer Echtzeitanreicherung oder -klassifizierung im selben Operatorpfad, in dem Daten eingehen. Jede Nachricht erfordert nur eine lokale CPU-Ableitung, die Netzwerk-Roundtrips vermeidet.
• Inline mit Stream-Verarbeitung: Führen Sie die Ableitung parallel zur Multi-Source-Stream-Verarbeitung aus, bei der die Funktionen bereits im Graph angeordnet sind, und passen Sie sie an die Semantik der Ereigniszeit an, damit die Ableitung dieselben Zeitstempel verwendet wie andere Operatoren.
• Einfache Updates: Versenden Sie ein neues Modul mit WASM und eingebettetem Modell, und aktualisieren Sie dann den Diagrammdefinitionsverweis. Sie benötigen keine separate Modellregistrierung oder externe Endpunktänderung.
• Horizontale Skalierung: Die Ableitung wird skaliert, wenn das Datenflussdiagramm skaliert wird. Wenn das Laufzeitsystem weitere Worker zur Verbesserung der Durchsatzleistung hinzufügt, lädt jeder Worker das eingebettete Modell und nimmt am Lastenausgleich teil.

Inference wird über die WASI-n-Schnittstelle (WebAssembly System Interface, WASI) auf einer CPU ausgeführt. Informationen zu unterstützten Modellformaten und Hardwareeinschränkungen finden Sie unter Einschränkungen der ONNX-Ableitung in WASM-Datenflussdiagrammen.

Wann sollten Sie In-Band-ONNX-Inferenz verwenden?

Verwenden Sie die In-Band-ONNX-Ableitung in Datenflussdiagrammen, wenn Sie die folgenden Funktionen benötigen:

• Geringe Latenz zur Anreicherung oder Klassifizierung von Nachrichten inline zur Einbindungszeit.
• Kleine, effiziente Modelle wie z. B. Visionsmodelle der MobileNet-Klasse.
• Ableitung, die mit der Ereigniszeitverarbeitung übereinstimmt und die gleichen Zeitstempel wie andere Operatoren verwendet.
• Einfache Modellupdates durch Versand einer neuen Modulversion.

Verwenden Sie keine In-Band-ONNX-Ableitung, wenn Sie die folgenden Funktionen benötigen:

• Große Transformatormodelle, GPU- oder TPU-Beschleunigung oder anspruchsvolle A/B-Rollouts.
• Modelle, die mehrere Tensoreingaben, die Zwischenspeicherung von Schlüsselwerten oder nicht unterstützte ONNX-Operatoren erfordern.

Architekturmuster für ONNX-Ableitung in Datenflussdiagrammen

Das gängige Muster für die ONNX-Inferenz in Datenflussgraphen umfasst die folgenden Phasen:

1. Vorverarbeitungsdaten: Transformieren Sie rohe Eingabedaten so, dass sie dem erwarteten Format Ihres Modells entsprechen. Bei Bildmodellen umfasst dieser Vorgang in der Regel Folgendes:
   • Decodieren von Bilddaten.
   • Skalierung auf eine Zieldimension (z. B. 224×224).
   • Konvertieren des Farbraums (z. B. RGB in BGR).
   • Normalisieren von Pixelwerten in den erwarteten Bereich (0 bis 1 oder -1 bis 1).
   • Anordnen von Daten im richtigen Tensorlayout: NCHW (Batch, Kanäle, Höhe, Breite) oder NHWC (Batch, Höhe, Breite, Kanäle).
2. Ausführen von Rückschlüssen: Konvertieren von vorverarbeiteten Daten in Tensoren mithilfe der wasi-nn Schnittstelle, Laden Des eingebetteten ONNX-Modells mit dem CPU-Back-End, Festlegen von Eingabe-Tensoren im Ausführungskontext, Aufrufen des Vorwärtsdurchlaufs des Modells und Abrufen von Ausgabe-Tensoren mit Rohvorhersagen.
3. Postprozess-Ausgaben: Transformieren Sie rohe Modellergebnisse in aussagekräftige Resultate. Allgemeine Vorgänge:
   • Wenden Sie Softmax an, um Klassifizierungswahrscheinlichkeiten zu erzeugen.
   • Wählen Sie die top-K-Vorhersagen aus.
   • Wenden Sie einen Konfidenzschwellenwert an, um Ergebnisse mit niedriger Konfidenz zu filtern.
   • Ordnen Sie Vorhersageindizes zu menschenlesbaren Bezeichnungen zu.
   • Formatieren Sie Ergebnisse für die nachgelagerte Nutzung.

In den IoT-Proben für Rust WASM Operatoren finden Sie zwei Beispiele, die diesem Muster folgen:

• Datentransformation "Format"-Beispiel: Decodiert und skaliert Bilder zu RGB24 224×224.
• Beispiel zur Bild-/Videobearbeitung "Schnappschuss": Betten Sie ein MobileNet v2 ONNX-Modell ein, führen Sie eine CPU-Inferenz aus und berechnen Sie Softmax.

Konfigurieren der Graphdefinition

Um die ONNX-Ableitung in Ihrem Datenflussdiagramm zu aktivieren, konfigurieren Sie sowohl die Diagrammstruktur als auch die Modulparameter. Die Diagrammdefinition gibt den Pipelinefluss an, während Modulkonfigurationen die Laufzeitanpassung des Vorverarbeitungs- und Ableitungsverhaltens ermöglichen.

Aktivieren Sie die wasi-nn-Funktion

Um die WebAssembly Neural Network (wasi-nn)-Schnittstelle für ONNX-Inference zu aktivieren, fügen Sie das wasi-nn Feature zu Ihrer Diagrammdefinition hinzu:

moduleRequirements:
  apiVersion: "1.1.0"
  runtimeVersion: "1.1.0"
  features:
    - name: "wasi-nn"

Vorgänge für die Inferenzpipeline definieren

Konfigurieren Sie die Vorgänge, die Ihre ONNX-Ableitungspipeline bilden. Dieses Beispiel zeigt einen typischen Bildklassifizierungsworkflow:

operations:
  - operationType: "source"
    name: "camera-input"
  - operationType: "map"
    name: "module-format/map"
    module: "format:1.0.0"
  - operationType: "map"
    name: "module-snapshot/map"
    module: "snapshot:1.0.0"
  - operationType: "sink"
    name: "results-output"

connections:
  - from: { name: "camera-input" }
    to: { name: "module-format/map" }
  - from: { name: "module-format/map" }
    to: { name: "module-snapshot/map" }
  - from: { name: "module-snapshot/map" }
    to: { name: "results-output" }

Diese Konfiguration erstellt eine Pipeline, in der:

• camera-input Empfängt rohe Bilddaten aus einer Quelle
• module-format/map Vorverarbeitung von Bildern (Decodieren, Ändern der Größe, Formatkonvertierung)
• module-snapshot/map führt ONNX-Inferenz und Nachbearbeitung aus.
• results-output gibt Klassifizierungsergebnisse an eine Senke aus

Konfigurieren von Modulparametern

Definieren Sie Laufzeitparameter zum Anpassen des WASM-Modulverhaltens ohne Neuerstellung. Diese Parameter werden bei der Initialisierung an Ihre WASM-Module übergeben.

Ausführliche Informationen finden Sie unter Modulkonfigurationsparameter.

Packen des Modells

Durch das direkte Einbetten von ONNX-Modellen in Ihre WASM-Komponente wird eine nahtlose Bereitstellung und Versionskonsistenz gewährleistet. Dieser Ansatz vereinfacht die Verteilung und entfernt Laufzeitabhängigkeiten von externen Modelldateien oder Registrierungen.

ONNX-Modellvorbereitungsanforderungen

Stellen Sie vor dem Einbetten des Modells sicher, dass es die Anforderungen für die WASM-Bereitstellung erfüllt:

• Halten Sie Modelle unter 50 MB für praktische WASM Ladezeiten und Arbeitsspeichereinschränkungen.
• Überprüfen Sie, ob Ihr Modell eine einzelne Tensoreingabe in einem gängigen Format akzeptiert (float32 oder uint8).
• Überprüfen Sie, ob das WASM ONNX-Runtime-Back-End jeden vom Modell verwendeten Operator unterstützt.
• Verwenden Sie ONNX-Optimierungstools, um die Modellgröße zu reduzieren und die Rückschlussgeschwindigkeit zu verbessern.

Schritte zum Einbetten eines ONNX-Modells in ein WASM-Modul

Führen Sie die folgenden Schritte aus, um Ihr ONNX-Modell und die zugehörigen Ressourcen in ein WASM-Modul einzubetten:

1. Organisieren Sie Modellressourcen: Platzieren Sie die .onnx Modelldatei und optional labels.txt in Ihrem Quellverzeichnis. Verwenden Sie eine dedizierte Verzeichnisstruktur wie src/fixture/models/ und src/fixture/labels/ für eine klare Organisation.
2. Beim Kompilieren einbetten: Verwenden Sie sprachspezifische Tools, um die Modellbytes in Ihre Binärdatei einzubinden. Verwenden Sie in Rust include_bytes! für Binärdaten und include_str! für Textdateien.
3. Initialisieren Sie das wasi-nn-Diagramm: Erstellen Sie in der Funktion des Operators init ein wasi-nn Diagramm aus den eingebetteten Bytes, und geben Sie das ONNX-Codierungs- und CPU-Ausführungsziel an.
4. Implementieren Sie eine Ableitungsschleife: Für jede eingehende Nachricht werden Eingaben vorverarbeitet, um den Modellanforderungen zu entsprechen, Eingabe-Tensoren festzulegen, Ableitungen auszuführen, Ausgaben abzurufen und Postverarbeitung anzuwenden.
5. Behandeln Sie Fehler ordnungsgemäß: Implementieren Sie die ordnungsgemäße Fehlerbehandlung für Modellladefehler, nicht unterstützte Operatoren und Laufzeitableitungsfehler.

Ein vollständiges Implementierungsmuster finden Sie im Beispiel "snapshot".

Empfohlene WASM-Projektstruktur

Organisieren Sie Ihr WASM-Modulprojekt mit einer klaren Trennung von Bedenken:

src/
├── lib.rs                 # Main module implementation
├── model/
│   ├── mod.rs            # Model management module
│   └── inference.rs      # Inference logic
└── fixture/
    ├── models/
    │   ├── mobilenet.onnx      # Primary model
    │   └── mobilenet_opt.onnx  # Optimized variant
    └── labels/
        ├── imagenet.txt        # ImageNet class labels
        └── custom.txt          # Custom label mappings

Beispiel-Dateilayout aus dem Snapshot-Beispiel

Verwenden Sie das folgende Dateilayout aus dem Beispiel "snapshot" als Referenz:

• Labels-Verzeichnis – Enthält verschiedene Bezeichnungszuordnungsdateien.
• Models directory - Enthält ONNX-Modelldateien und Metadaten

Minimales Rust-Beispiel zum Einbetten eines ONNX-Modells

Das folgende Rust-Beispiel zeigt den minimalen Code, der zum Einbetten eines ONNX-Modells in ein WASM-Modul erforderlich ist. Die Pfade sind relativ zur Quelldatei, die das Makro enthält:

// src/lib.rs (example)
// Embed ONNX model and label map into the component
static MODEL: &[u8] = include_bytes!("fixture/models/mobilenet.onnx");
static LABEL_MAP: &[u8] = include_bytes!("fixture/labels/synset.txt");

fn init_model() -> Result<(), anyhow::Error> {
  // Create wasi-nn graph from embedded ONNX bytes using the CPU backend
  // Pseudocode – refer to the snapshot sample for the full implementation
  // use wasi_nn::{graph::{load, GraphEncoding, ExecutionTarget}, Graph};
  // let graph = load(&[MODEL.to_vec()], GraphEncoding::Onnx, ExecutionTarget::Cpu)?;
  // let exec_ctx = Graph::init_execution_context(&graph)?;
  Ok(())
}

Wiederverwendung des ONNX-Graphen und des Ausführungskontexts über mehrere Nachrichten hinweg

Um zu vermeiden, dass der ONNX-Diagramm- und Ausführungskontext für jede Nachricht neu festgelegt wird, initialisieren Sie sie einmal, und verwenden Sie sie wieder. Das öffentliche Snapshot-Beispiel verwendet ein statisches LazyLock, um den Graph und den Ausführungskontext einmal pro Worker zu initialisieren:

use crate::wasi::nn::{
    graph::{load, ExecutionTarget, Graph, GraphEncoding, GraphExecutionContext},
    tensor::{Tensor, TensorData, TensorDimensions, TensorType},
};

static mut CONTEXT: LazyLock<GraphExecutionContext> = LazyLock::new(|| {
    let graph = load(&[MODEL.to_vec()], GraphEncoding::Onnx, ExecutionTarget::Cpu).unwrap();
    Graph::init_execution_context(&graph).unwrap()
});

fn run_inference(/* input tensors, etc. */) {
    unsafe {
        // (*CONTEXT).compute()?;
    }
}

Lokales Debuggen und Testen des ONNX-Moduls

Testen Sie vor der Bereitstellung für Azure IoT Einsatz das ONNX-Rückschlussmodul lokal, um Die Funktionalität und Leistung zu überprüfen. Weitere Informationen finden Sie unter:

• Debuggen von WASM-Modulen in VS Code
• TESTEN VON WASM-Modulen

Konfigurieren und Bereitstellen Ihres ONNX-Moduls

Wenn Sie bereit sind, Ihr ONNX-Inferenzmodul in einem Datenfluss oder Connector in Azure IoT Einsatz zu verwenden, führen Sie die folgenden Schritte aus:

• Konfigurieren von WebAssembly(WASM)-Graphdefinitionen für Datenflussgraphs und Konnektoren
• Bereitstellen von WebAssembly(WASM)-Modulen und Diagrammdefinitionen

Beispiel: MobileNet-Bildklassifizierung

Die öffentlichen IoT-Beispiele enthalten zwei Beispiele, die in ein Diagramm für die Bildklassifizierung verkabelt sind:

• Das "format"-Beispiel bietet Funktionen zur Bilddekodierung und Größenanpassung.
• Das "snapshot"-Beispiel bietet ONNX-Ableitung und Softmax-Verarbeitung.

Weitere Informationen zu und Ausführen des Beispiels, das diese Module verwendet, finden Sie unter Beispiel 2: Bereitstellen eines komplexen Diagramms.

Einschränkungen der ONNX-Ableitung in WASM-Datenflussdiagrammen

Die Ableitung in WASM-Datenflussdiagrammen hat die folgenden Einschränkungen:

• Modellformat: Nur ONNX. Datenflussdiagramme unterstützen keine anderen Formate wie TFLite.
• Hardware: Nur CPU. GPU- und TPU-Beschleunigung werden nicht unterstützt.
• Modellgröße: Große Modelle und speicherintensive Rückschlüsse werden nicht unterstützt. Verwenden Sie kleine Modelle wie MobileNet-Klassenarchitekturen.
• Modelleingaben: Es werden nur Ein-Tensor-Eingabemodelle unterstützt. Multieingabemodelle, Zwischenspeicherung von Schlüsselwerten und erweiterte Sequenz- oder generative Szenarien werden nicht unterstützt.
• Operatorunterstützung: Das ONNX-Back-End in der WASM-Laufzeit muss jeden operator unterstützen, den Ihr Modell verwendet. Wenn ein Operator nicht unterstützt wird, schlägt die Ableitung zur Lade- oder Ausführungszeit fehl.

Verwandte Inhalte

• Entwickeln von WebAssembly-Modulen
• Konfigurieren von WebAssembly(WASM)-Graphdefinitionen für Datenflussgraphs und Konnektoren
• Bereitstellen von WebAssembly(WASM)-Modulen und Diagrammdefinitionen