Wat is ONNX Runtime, hoe het werkt en een voorbeeld op Windows

De zich ontwikkelende trendy vraag van IA toegepast is welke rol ONNX Runtime speelt bij het in productie brengen van modellen. Kortom, ONNX Runtime is de inferentie-engine die is geoptimaliseerd voor ONNX-formaatmodellen., ontworpen om op verschillende systemen te werken en te profiteren van de hardware beschikbaar (CPU, GPU of NPU). In dit artikel leest u waar het voor dient, hoe het wordt gebruikt in Python en .NET, en een stapsgewijs voorbeeld met WinUI 3 op Windows versneld met DirectML.

Als u net bent begonnen met een training met PyTorch of TensorFlow en een snelle en efficiënte implementatie wenst, kunt u met ONNX uw model exporteren. ONNX Runtime zorgt er vervolgens voor dat het snel en met weinig geheugengebruik wordt uitgevoerd. Privacy, lage latentie en lage kosten Dit zijn duidelijke voordelen als u lokaal of aan de edge inferentie uitvoert, zonder afhankelijk te zijn van de cloud.

Wat is ONNX Runtime?

ONNX-looptijd is een cross-platform Machine Learning-modelversneller, met API's in C, C++, Python, C#, Java en JavaScript (inclusief Node.js). Het is klaar voor Linux, Windows en macOS, en integreert ook met web-, mobiele en edge-omgevingen. Het ontwerp ondersteunt beide neurale netwerken ondiep zoals traditionele ML-modellen en kan worden uitgebreid met hardwarespecifieke Execution Providers.

Tot deze aanbieders behoren: TensorRT op GPU NVIDIA, OpenVINO in hardware Intel y DirectML op WindowsDeze abstractielaag stelt het ONNX-model zelf in staat om te profiteren van de beschikbare apparaatversnelling, terwijl een stabiele interface behouden blijft. Grootschalige services zoals Bing, Office en Azure AI maken er al gebruik van, met verbeteringen in tot 2x op CPU in bepaalde scenario's, dankzij grafiekoptimalisatie, operatormerging en efficiënt geheugenbeheer.

ONNX: Het standaardmodelformaat

ONNX (Open Neural Network Exchange) is een open standaard om getrainde modellen te representeren. Maakt export mogelijk van PyTorch, TensorFlow/Keras, scikit-learn, TFLite, MXNet, Chainer of MATLAB en overal draaien met engines zoals ONNX Runtime. Een ONNX-model bevat de netwerkstructuur, pesos getraind en de beschrijving van inputs/outputs, wat interoperabiliteit tussen frameworks en hardware mogelijk maakt.

Deze aanpak versnelt het traject van onderzoek naar productie: u traint waar u wilt en implementeert waar het u het beste uitkomt (cloud, on-premise, edge). ONNX faciliteert ook optimaliseer grootte en prestaties door middel van technieken zoals post-trainingskwantificering, wat erg nuttig is in ingebedde apparaten of IoT.

Als u een model moet inspecteren, kunt u gebruikmaken van hulpmiddelen zoals netron helpen de grafiek en de lagen te visualiseren. En als je met objectdetectie werkt, kunnen modellen zoals YOLO van Ultralytics Ze zijn goed te exporteren naar ONNX, waar ze vervolgens met ONNX Runtime, OpenVINO of andere engines kunnen worden uitgevoerd. Zo zijn ze draagbaar zonder dat ze aan één enkel ecosysteem gebonden zijn.

ONNX Runtime-pakketten en gebruik in Python

Voor Python biedt ONNX Runtime pakketten in PyPI Voor zowel CPU als GPU. Controleer vóór de installatie de systeemvereisten om de juiste build te kiezen. Met pip is de installatie eenvoudig en kunt u snel opstarten met lokale of externe inferentie.

Snelle installatie:

pip install onnxruntime        # build para CPU
pip install onnxruntime-gpu    # build con aceleración GPU (según plataforma)

Na de installatie is het laden van het model en het opvragen van metadata eenvoudig. De inferentiesessie maakt methoden beschikbaar voor het lezen van in- en uitgangen verwacht, evenals metagegevens van het model zelf, wat helpt bij het valideren van vormen en typen voordat ze worden aangeroepen sessie.run.

Voorbeeldsessie:

import onnxruntime as ort
session = ort.InferenceSession("ruta/al/modelo.onnx")

# Metadatos y firmas
meta = session.get_modelmeta()
first_input_name = session.get_inputs().name
first_output_name = session.get_outputs().name

# Inferencia (todas las salidas o sólo algunas)
results_all = session.run([], {first_input_name: indata})
results_some = session.run(, {first_input_name: indata})

In de documentatie die bij het model wordt geleverd, wordt doorgaans de voorbewerkt Vereiste en invoerformaten. Zorg ervoor dat u rekening houdt met tensorschaling, normalisatie en dimensies, anders mislukt de inferentie of levert deze inconsistente resultaten op.

Volledig stroomvoorbeeld:

// Selección y visualización
FileOpenPicker picker = new() { ViewMode = PickerViewMode.Thumbnail };
picker.FileTypeFilter.Add(".jpg");
picker.FileTypeFilter.Add(".jpeg");
picker.FileTypeFilter.Add(".png");
picker.FileTypeFilter.Add(".gif");
InitializeWithWindow.Initialize(picker, WinRT.Interop.WindowNative.GetWindowHandle(this));
StorageFile file = await picker.PickSingleFileAsync();
if (file == null) return;

var bitmap = new BitmapImage();
bitmap.SetSource(await file.OpenAsync(Windows.Storage.FileAccessMode.Read));
myImage.Source = bitmap;

// Preprocesado con ImageSharp
using var fileStream = await file.OpenStreamForReadAsync();
IImageFormat format = SixLabors.ImageSharp.Image.DetectFormat(fileStream);
using Image<Rgb24> image = SixLabors.ImageSharp.Image.Load<Rgb24>(fileStream);

image.Mutate(x => x.Resize(new ResizeOptions
{
    Size = new SixLabors.ImageSharp.Size(224, 224),
    Mode = ResizeMode.Crop
}));

var mean = new[] { 0.485f, 0.456f, 0.406f };
var std = new[]  { 0.229f, 0.224f, 0.225f };
DenseTensor<float> input = new(new[] { 1, 3, 224, 224 });

image.ProcessPixelRows(accessor =>
{
    for (int y = 0; y < accessor.Height; y++)
    {
        Span<Rgb24> row = accessor.GetRowSpan(y);
        for (int x = 0; x < accessor.Width; x++)
        {
            input = ((row.R / 255f) - mean) / std;
            input = ((row.G / 255f) - mean) / std;
            input = ((row.B / 255f) - mean) / std;
        }
    }
});

// OrtValue desde memoria (evita copias)
using var inputOrt = OrtValue.CreateTensorValueFromMemory(
    OrtMemoryInfo.DefaultInstance, input.Buffer, new long[] { 1, 3, 224, 224 });
var inputs = new Dictionary<string, OrtValue> { { "data", inputOrt } };

if (_inferenceSession == null) InitModel();
using var runOptions = new RunOptions();
using var results = _inferenceSession.Run(runOptions, inputs, _inferenceSession.OutputNames);

// Postprocesado: softmax y Top-10
var logits = results.GetTensorDataAsSpan<float>().ToArray();
float sum = logits.Sum(v => (float)Math.Exp(v));
var softmax = logits.Select(v => (float)Math.Exp(v) / sum).ToArray();

De uitvoerindices komen overeen met labels uit de trainingsset (bijv. ImageNet). U kunt ze toewijzen aan een LabelMap (een reeks strings in dezelfde volgorde als de modelklassen) en extraheer de Top 10 met een groter vertrouwen in het TextBlock weergeven.

Nabewerking en etiketten:

var top10 = softmax
    .Select((score, idx) => new Prediction { Label = LabelMap.Labels, Confidence = score })
    .OrderByDescending(p => p.Confidence)
    .Take(10);

featuresTextBlock.Text = "Top 10 predictions for ResNet50 v2..." + Environment.NewLine;
featuresTextBlock.Text += "-------------------------------------" + Environment.NewLine;
foreach (var p in top10)
{
    featuresTextBlock.Text += $"Label: {p.Label}, Confidence: {p.Confidence}" + Environment.NewLine;
}

internal class Prediction
{
    public object Label { get; set; }
    public float Confidence { get; set; }
}

public static class LabelMap
{
    public static readonly string[] Labels = new[]
    {
        // Lista completa de etiquetas (p.ej., ImageNet) en orden; omitada por brevedad
        "tench", "goldfish", "great white shark", /* ... */ "toilet paper"
    };
}

Hiermee wordt, wanneer u op "Foto selecteren" drukt, het model geïnitialiseerd (als dat nog niet het geval was), wordt de afbeelding verwerkt en de meest waarschijnlijke voorspellingen met hun vertrouwenU kunt dit patroon aanpassen aan andere ONNX-modellen en taken (detectie, segmentatie, tekst, enz.).

Draait op Azure en MLOps

Als u moet schalen, biedt Azure Machine Learning de mogelijkheid ONNX-modellen implementeren als REST-eindpunten, versiebeheer, monitoring en de MLOps-levenscyclus. Zo kunt u wat u lokaal uitvoert naar de cloud brengen met behoud van dezelfde model artefact en profiteren van serverversnellers.

De typische stroom is om inferentie met ONNX Runtime in een container te verpakken, een eindpunt bloot te stellen en te orkestreren updates, statistieken y alertasDeze aanpak combineert de ontwikkeling en het gebruik van het grootschalige model.

Hardwareversnelling en compatibiliteit

ONNX Runtime onderscheidt zich door zijn architectuur Uitvoeringsaanbieders: met TensorRT knijpt NVIDIA GPU; met OpenVINO optimaliseert Intel CPU's/VPU's; en met DirectML Versnelt Windows op GPU's en NPU's van verschillende fabrikanten. Er zijn ook integraties met Vitis AI om modellen uit te voeren op Xilinx FPGA's (bijv. U250), waardoor het bereik wordt uitgebreid naar gespecialiseerde configuraties.

Deze flexibiliteit maakt het gemakkelijk voor hetzelfde ONNX-model om goed te presteren in cloud, edge, web en mobiel, waarbij de engine de operators en het geheugen aanpast aan elk platform. Het resultaat is een lagere latentie en verbeterde doorvoer zonder uw high-level code te wijzigen.

On-premises AI: privacy, kosten en controle

Het lokaal uitvoeren van AI met ONNX Runtime brengt privacy (je deelt geen gegevens), minimale latentie y voorspelbare kosten (zonder cloud-API-gebruik). Het is vooral waardevol in de gezondheidszorg, de industrie of in scenario's met beperkte connectiviteit, en integreert goed met .NET (zelfs VB.NET) of Python, afhankelijk van uw stack.

Voor geavanceerde modellen is een GPU versnelt enorm, maar ONNX Runtime is ook geoptimaliseerd voor CPU. De sleutel is om de modelvoorbewerking te respecteren en, indien van toepassing, kwantificering om de grootte en het geheugen te verkleinen en toch voldoende precisie te behouden.

Conversie en goede praktijken

Het converteren van modellen naar ONNX vanuit PyTorch gebeurt meestal met torch.onnx.export en van TensorFlow met tf2onnx. Vraag me af wat de voorbeeldtensor (dummy input) de juiste vorm heeft en dat de grafiekbewerkingen worden ondersteund door de doelopset.

Valideer het model na het converteren door middel van query's in-/uitgangen met ONNX Runtime en voer testcases uit. Als er aangepaste lagen zijn, moet u deze mogelijk aanpassen of vervangen door ondersteunde operators; compatibiliteit tussen opsets en versies is belangrijk om verrassingen te voorkomen.

Toepassingen en gebruiksscenario's

Op het gebied van computer vision faciliteert ONNX classificatie, detectie en segmentatie op diverse apparaten, van servers tot edge en IoT. De Vermindering van de grootte door kwantificering en inferentie-optimalisaties is het ideaal voor real-time (bijv. robots fabrieks- of kwaliteitsinspectie).

In de gezondheidszorg kunnen ONNX-modellen in wearables en monitoringsystemen signalen voorverwerken (zoals ECG) en extraheert kenmerken lokaal, met behoud van privacy. Voor slimme steden identificeren ONNX-camera's voertuigen in real time zonder afhankelijk te zijn van de cloud, en door verkeer en middelen te optimaliseren.

Aanbevolen bronnen en inhoud

ONNX Runtime maakt AI mogelijk in Windows, Office, Azure Cognitive Services en Bing, en in duizenden wereldwijde projecten. Er is educatief materiaal dat dieper ingaat op ONNX, de relatie met opsets, hardwareversnelling en echte gevallen zoals de semantische afbeeldingzoekfunctie van Bing.

Een voorbeeld van een outreach-programma markeert de volgende mijlpalen: Presentatie van ONNX, Inleiding tot ONNX, Demo: Converteren vanuit CoreML, ONNX-looptijd, Versies en opsets, Hardware acceleratie, Case studyDit type content illustreert hoe u van een model naar een geoptimaliseerde implementatie kunt overstappen.

Om kant-en-klare sjablonen te downloaden, ONNX Model Zoo biedt beeldclassificatoren, detectoren en NLP-modellen. Als iets niet meteen werkt, is het vaak nuttig om incident in de converter repository overeenkomstige en beoordeling van niet-ondersteunde bewerkingen.

Als laatste opmerking zijn er ook specifieke integraties zoals Vitis AI (Xilinx) met ONNX Runtime voor U250 FPGA's, waarmee het implementatiebereik op programmeerbare hardware wordt uitgebreid voor toepassingen met hoge prestaties en lage latentie.

ONNX Runtime heeft zichzelf gepositioneerd als een belangrijk onderdeel voor het uitvoeren van AI-modellen met snelheid, veelzijdigheid en efficiëntie in vrijwel elke omgeving. Of u nu met Python of .NET werkt, on-premises of in Azure, en ondersteuning nodig hebt voor CPU's, GPU's, NPU's of zelfs FPGA's, met de combinatie ONNX + ONNX Runtime kunt u trainen waar u maar wilt en implementeren waar het u het beste uitkomt, met een in productie bewezen optimalisatiepijplijn en een actieve community die de evolutie ervan stimuleert.

Gerelateerd artikel:

DirectML: Alles over de revolutie van kunstmatige intelligentie in Windows en gaming

Isaac

Gepassioneerd schrijver over de wereld van bytes en technologie in het algemeen. Ik deel mijn kennis graag door te schrijven, en dat is wat ik in deze blog ga doen: je de meest interessante dingen laten zien over gadgets, software, hardware, technologische trends en meer. Mijn doel is om u te helpen op een eenvoudige en onderhoudende manier door de digitale wereld te navigeren.