ONNX-deductie uitvoeren in gegevensstroomgrafieken van WebAssembly (WASM)

In dit artikel wordt beschreven hoe u kleine Open Neural Network Exchange (ONNX) modellen in uw WebAssembly-modules kunt insluiten en uitvoeren om in-banddeductie uit te voeren als onderdeel van Azure IoT-bewerkingen gegevensstroomgrafieken. Gebruik deze methode voor verrijking met lage latentie en classificatie rechtstreeks op streaminggegevens zonder externe voorspellingsservices aan te roepen.

Vereiste voorwaarden

Zorg ervoor dat u de volgende items hebt voordat u begint:

• Een Azure IoT-bewerkingen implementatie met de mogelijkheid voor gegevensstroomgrafieken.
• Een containerregister zoals Azure Container Registry en een containerregistereindpunt geconfigureerd. Zie Registereindpunten configureren voor meer informatie.
• Een ontwikkelomgeving die is ingesteld voor webassembly-moduleontwikkeling. Zie De modules WebAssembly ontwikkelen voor opties en gedetailleerde instructies voor het instellen van de omgeving.

Voordelen van in-band ONNX-inferentie

Met Azure IoT-bewerkingen gegevensstroomgrafieken kunt u kleine ONNX-modeldeductie rechtstreeks in de pijplijn insluiten in plaats van een externe voorspellingsservice aan te roepen. Deze aanpak biedt de volgende voordelen:

• Lage latentie: Voer realtimeverrijking of -classificatie uit in hetzelfde operatorpad waar gegevens binnenkomen. Elk bericht vereist alleen lokale CPU-deductie, waardoor netwerkrondes worden vermeden.
• Geïntegreerd met streamverwerking: Voer inferentie uit naast multi-source-streamverwerking, waarbij kenmerken al in de graaf zijn samengebracht, en stem dit af op gebeurtenistijdsemantiek zodat inferentie dezelfde tijdstempels gebruikt als andere operators.
• Eenvoudige updates: Verzend een nieuwe module met WASM en een ingesloten model en werk vervolgens de verwijzing naar de grafiekdefinitie bij. U hebt geen afzonderlijk modelregister of wijziging van een extern eindpunt nodig.
• Horizontaal schalen: inferentie schaalt met de schaal van de gegevensstroomgrafiek. Wanneer de runtime meer workers toevoegt voor doorvoer, laadt elke worker het ingesloten model en neemt deel aan load balancing.

Inferentie wordt op een CPU uitgevoerd via de WebAssembly System Interface (WASI) wasi-nn-interface. Zie Beperkingen van ONNX-deductie in WASM-gegevensstroomgrafieken voor ondersteunde modelindelingen en hardwarebeperkingen.

Wanneer moet u in-band ONNX-inferentie gebruiken?

Gebruik in-band ONNX-deductie in gegevensstroomgrafieken wanneer u de volgende mogelijkheden nodig hebt:

• Lage latentie voor het verrijken of classificeren van berichten inline tijdens opnametijd.
• Kleine, efficiënte modellen zoals MobileNet-class vision-modellen.
• Deductie die overeenkomt met gebeurtenistijdverwerking en dezelfde tijdstempels gebruikt als andere operators.
• Eenvoudige modelupdates door een nieuwe moduleversie te verzenden.

Gebruik geen in-band ONNX-deductie wanneer u de volgende mogelijkheden nodig hebt:

• Grote transformermodellen, GPU- of TPU-versnelling, of geavanceerde A/B-uitrols.
• Modellen die meerdere tensorinvoeren, een key-value-cache of niet-ondersteunde ONNX-operators vereisen.

Architectuurpatroon voor ONNX-deductie in gegevensstroomgrafieken

Het algemene patroon voor ONNX-deductie in gegevensstroomgrafieken omvat de volgende fasen:

1. Gegevens vooraf verwerken: onbewerkte invoergegevens transformeren zodat deze overeenkomen met de verwachte indeling van uw model. Voor afbeeldingsmodellen omvat dit proces meestal het volgende:
   • Afbeeldingsbytes decoderen.
   • Het formaat wijzigen naar doelafmetingen (bijvoorbeeld 224×224).
   • De kleurruimte converteren (bijvoorbeeld RGB naar BGR).
   • Pixelwaarden normaliseren naar het verwachte bereik (0-1 of -1 tot 1).
   • Gegevens rangschikken in de juiste tensorindeling: NCHW (batch, kanalen, hoogte, breedte) of NHWC (batch, hoogte, breedte, kanalen).
2. Deductie uitvoeren: converteer vooraf verwerkte gegevens naar tensors met behulp van de wasi-nn interface, laad uw ingesloten ONNX-model met de CPU-back-end, stel invoertenors in de uitvoeringscontext in, roep de forward pass van het model aan en haal uitvoertenors op met onbewerkte voorspellingen.
3. Postproces-uitvoer: Transformeer onbewerkte modeluitvoer naar zinvolle resultaten. Algemene bewerkingen:
   • Pas softmax toe om classificatiekansen te produceren.
   • Selecteer top-K-voorspellingen.
   • Pas een betrouwbaarheidsdrempel toe om resultaten met een lage betrouwbaarheid te filteren.
   • Voorspellingsindexen toewijzen aan door mensen leesbare labels.
   • Maak resultaten op voor downstreamverbruik.

In de IoT-voorbeelden voor Rust WASM-operators vindt u twee voorbeelden die dit patroon volgen:

• Gegevenstransformatie 'format'-voorbeeld: afbeeldingen decoderen en het formaat ervan wijzigen in RGB24 224×224.
• Image/Video processing "snapshot" sample: integreert een MobileNet v2 ONNX-model, voert CPU-inferentie uit en berekent softmax.

Grafiekdefinitie configureren

Als u ONNX-deductie in uw gegevensstroomgrafiek wilt inschakelen, configureert u zowel de grafiekstructuur als de moduleparameters. De grafiekdefinitie geeft de pijplijnstroom op, terwijl moduleconfiguraties runtime-aanpassing van voorverwerkings- en deductiegedrag toestaan.

Schakel de functie wasi-nn in

Als u de WebAssembly Neural Network(wasi-nn)-interface voor ONNX-deductie wilt inschakelen, voegt u de wasi-nn functie toe aan uw grafiekdefinitie:

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

Bewerkingen definiëren voor de deductiepijplijn

Configureer de bewerkingen die uw ONNX-deductiepijplijn vormen. In dit voorbeeld ziet u een typische werkstroom voor afbeeldingsclassificatie:

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" }

Met deze configuratie maakt u een pijplijn waarin:

• camera-input ontvangt onbewerkte afbeeldingsgegevens van een bron
• module-format/map afbeeldingen vooraf verwerken (decoderen, resizen, formaatconversie)
• module-snapshot/map voert ONNX-deductie en postverwerking uit
• results-output verzendt classificatieresultaten naar een sink

De moduleparameters configureren

Definieer runtimeparameters om het gedrag van DE WASM-module aan te passen zonder opnieuw te bouwen. Deze parameters worden tijdens de initialisatie doorgegeven aan uw WASM-modules.

Zie Moduleconfiguratieparameters voor meer informatie.

Het model verpakken

Het rechtstreeks insluiten van ONNX-modellen in uw WASM-onderdeel zorgt voor atomische implementatie en versieconsistentie. Deze aanpak vereenvoudigt de distributie en verwijdert runtime-afhankelijkheden van externe modelbestanden of registers.

Voorbereidingsvereisten voor ONNX-modellen

Voordat u uw model insluit, moet u ervoor zorgen dat het voldoet aan de vereisten voor WASM-implementatie:

• Houd modellen onder de 50 MB voor praktische WASM-laadtijden en geheugenbeperkingen.
• Controleer of uw model één tensor-invoer accepteert in een gemeenschappelijke indeling (float32 of uint8).
• Controleer of de WASM ONNX Runtime-back-end elke operator ondersteunt die door uw model wordt gebruikt.
• Gebruik ONNX-optimalisatiehulpprogramma's om de modelgrootte te verkleinen en de deductiesnelheid te verbeteren.

Stappen voor het insluiten van een ONNX-model in een WASM-module

Volg deze stappen om uw ONNX-model en de bijbehorende resources in te sluiten in een WASM-module:

1. Model assets organiseren: plaats het .onnx modelbestand en optioneel labels.txt in je bronstructuur. Gebruik een toegewezen mapstructuur, zoals src/fixture/models/ en src/fixture/labels/ voor een duidelijke organisatie.
2. Insluiten tijdens het compileren: taalspecifieke hulpprogramma's gebruiken om modelbytes in uw binaire bestand op te nemen. Gebruik in Rust include_bytes! voor binaire gegevens en include_str! voor tekstbestanden.
3. Initialiseer de wasi-nn-grafiek: Maak in de init-functie van uw operator een wasi-nn-grafiek van de ingebedde bytes, waarbij u de ONNX-codering en het CPU-uitvoeringsdoel opgeeft.
4. Inferentielus implementeren: Voor elk binnenkomend bericht worden inputgegevens verwerkt om aan de modelvereisten te voldoen, inputtensors ingesteld, inferentie uitgevoerd, uitvoer opgehaald en postverwerking toegepast.
5. Fouten probleemloos verwerken: implementeer de juiste foutafhandeling voor fouten bij het laden van modellen, niet-ondersteunde operators en runtimedeductiefouten.

Zie het voorbeeld 'snapshot' voor een volledig implementatiepatroon.

Aanbevolen WASM-projectstructuur

Organiseer uw WASM-moduleproject met duidelijke scheiding van problemen:

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

Voorbeeldbestandsindeling uit het voorbeeld van een momentopname

Gebruik de volgende bestandsindeling uit het voorbeeld 'momentopname' als referentie:

• Labeldirectory - Bevat verschillende labelmappingbestanden
• Models directory - Bevat ONNX-modelbestanden en metagegevens

Minimaal Rust-voorbeeld voor het insluiten van een ONNX-model

In het volgende Rust-voorbeeld ziet u de minimale code die nodig is om een ONNX-model in te sluiten in een WASM-module. De paden zijn relatief ten opzichte van het bronbestand dat de macro bevat:

// 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(())
}

De ONNX-grafiek en uitvoeringscontext opnieuw gebruiken in berichten

Om te voorkomen dat u de ONNX-grafiek en uitvoeringscontext voor elk bericht opnieuw wilt maken, initialiseert u deze eenmaal en gebruikt u deze opnieuw. Het voorbeeld voor openbare momentopname gebruikt een statische LazyLock om de grafiek en uitvoeringscontext eenmaal per worker te initialiseren:

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()?;
    }
}

Fouten opsporen en uw ONNX-module lokaal testen

Voordat u in Azure IoT-bewerkingen implementeert, test u de ONNX-deductiemodule lokaal om de functionaliteit en prestaties te valideren. Zie voor meer informatie:

• Fouten opsporen in WASM-modules in VS Code
• WASM-modules testen

Uw ONNX-module configureren en implementeren

Wanneer u klaar bent om uw ONNX-deductiemodule te gebruiken in een Azure IoT-bewerkingen gegevensstroom of connector, voert u de volgende stappen uit:

• Grafiekdefinities van WebAssembly (WASM) configureren voor gegevensstroomgrafieken en -connectors
• WASM-modules (WebAssembly) en grafiekdefinities implementeren

Voorbeeld: MobileNet-beeldclassificatie

De openbare IoT-voorbeelden bieden twee voorbeelden die zijn bekabeld in een grafiek voor afbeeldingsclassificatie:

• Het voorbeeld format biedt functionaliteit voor het decoderen en wijzigen van de grootte van afbeeldingen.
• Het voorbeeld 'snapshot' biedt ONNX-deductie en softmax-verwerking.

Zie voorbeeld 2: Een complexe grafiek implementeren voor meer informatie over en het uitvoeren van het voorbeeld dat gebruikmaakt van deze modules.

Beperkingen van ONNX-deductie in WASM-gegevensstroomgrafieken

Deductie in WASM-gegevensstroomgrafieken heeft de volgende beperkingen:

• Modelindeling: alleen ONNX. Gegevensstroomgrafieken bieden geen ondersteuning voor andere indelingen, zoals TFLite.
• Hardware: alleen CPU. GPU- en TPU-versnelling worden niet ondersteund.
• Modelgrootte: Grote modellen en geheugenintensieve deductie worden niet ondersteund. Gebruik kleine modellen zoals MobileNet-klasse architecturen.
• Modelinvoer: Alleen invoermodellen met één tensor worden ondersteund. Modellen met meerdere invoer, sleutel-waardecaching en geavanceerde reeks- of generatieve scenario's worden niet ondersteund.
• Operatorondersteuning: De ONNX-back-end in de WASM-runtime moet elke operator ondersteunen die door uw model wordt gebruikt. Als een operator niet wordt ondersteund, mislukt deductie tijdens de laad- of uitvoeringstijd.

Verwante inhoud

• WebAssembly-modules ontwikkelen
• Grafiekdefinities van WebAssembly (WASM) configureren voor gegevensstroomgrafieken en -connectors
• WASM-modules (WebAssembly) en grafiekdefinities implementeren