Ano ang ONNX Runtime, kung paano ito gumagana, at isang halimbawa sa Windows

Ang umuusbong na tanong ng IA inilapat ay kung ano ang papel na ginagampanan ng ONNX Runtime sa pagdadala ng mga modelo sa produksyon. Sa madaling sabi, Ang ONNX Runtime ay ang inference engine na na-optimize para sa mga modelong format ng ONNX., na idinisenyo upang gumana sa iba't ibang mga sistema at samantalahin ang hardware magagamit (CPU, GPU, o NPU). Sa buong artikulong ito, makikita mo kung para saan ito, kung paano ito ginagamit sa Python at .NET, at isang hakbang-hakbang na halimbawa na may Ang WinUI 3 sa Windows ay pinabilis gamit ang DirectML.

Kung galing ka sa pagsasanay gamit ang PyTorch o TensorFlow at gusto mo ng mabilis at mahusay na deployment, hinahayaan ka ng ONNX na i-export ang iyong modelo, at ang ONNX Runtime ang nangangasiwa sa pagpapatakbo nito nang mabilis at may mababang paggamit ng memory. Privacy, mababang latency at mababang gastos Ang mga ito ay malinaw na mga pakinabang kapag gumawa ka ng hinuha nang lokal o sa gilid nang hindi umaasa sa cloud.

Ano ang ONNX Runtime?

Runtime ng ONNX ay isang cross-platform Machine Learning model accelerator, na may mga API sa C, C++, Python, C#, Java, at JavaScript (kabilang ang Node.js). Ito ay handa na para sa Linux, Windows at macOS, at isinasama rin sa mga web, mobile at edge na kapaligiran. Ang disenyo nito ay sumusuporta sa pareho mga neural network malalim bilang mga tradisyunal na modelo ng ML at maaaring palawigin gamit ang Mga Provider ng Pagpapatupad na partikular sa hardware.

Kabilang sa mga provider na iyon ay TensorRT sa GPU NVIDIA, OpenVINO sa hardware Intel y DirectML sa WindowsAng abstraction layer na ito ay nagbibigay-daan sa mismong modelo ng ONNX na samantalahin ang available na acceleration ng device habang pinapanatili ang isang stable na interface. Ginagamit na ito ng mga malalaking serbisyo tulad ng Bing, Office, at Azure AI, na may nakikitang mga pagpapahusay sa hanggang 2x sa CPU sa ilang partikular na sitwasyon, salamat sa graph optimizations, operator merge, at mahusay na pamamahala ng memory.

ONNX: Ang Karaniwang Format ng Modelo

Ang ONNX (Open Neural Network Exchange) ay isang bukas na pamantayan upang kumatawan sa mga sinanay na modelo. Pinapayagan ang pag-export mula sa PyTorch, TensorFlow/Keras, scikit-learn, TFLite, MXNet, Chainer o MATLAB at tumakbo kahit saan gamit ang mga makina tulad ng ONNX Runtime. Kasama sa modelong ONNX ang istraktura ng network, Ang piso sinanay at ang paglalarawan ng mga input/output, na nagbibigay-daan sa interoperability sa pagitan ng mga frameworks at hardware.

Pinapabilis ng diskarteng ito ang landas mula sa pananaliksik patungo sa produksyon: nagsasanay ka kung saan mo gusto at i-deploy kung saan ito pinaka-maginhawa (cloud, on-prem, edge). Pinapadali din ng ONNX i-optimize ang laki at pagganap sa pamamagitan ng mga diskarte tulad ng post-training quantification, na lubhang kapaki-pakinabang sa naka-embed na mga aparato o IoT.

Kung kailangan mong suriin ang isang modelo, tulad ng mga tool netron tumulong na mailarawan ang graph at ang mga layer. At kung nagtatrabaho ka sa pagtuklas ng bagay, tulad ng mga modelo YOLO ng Ultralytics Ang mga ito ay mahusay na na-export sa ONNX upang pagkatapos ay tumakbo kasama ang ONNX Runtime, OpenVINO o iba pang mga makina, na nakakakuha ng portability nang hindi nakatali sa isang solong ecosystem.

Mga ONNX Runtime Package at Paggamit sa Python

Para sa Python, ang ONNX Runtime ay nag-aalok ng mga pakete sa PyPI para sa parehong CPU at GPU. Bago i-install, suriin ang mga kinakailangan ng system upang piliin ang tamang build. Sa pip, ang pag-install ay diretso at nagbibigay-daan sa iyong mag-boot nang mabilis gamit ang lokal o malayong hinuha.

Mabilis na Pag-install:

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

Kapag na-install na, ang pag-load ng modelo at pag-query ng metadata ay simple. Ang sesyon ng hinuha ay naglalantad ng mga pamamaraan para sa pagbabasa mga input at output inaasahan, pati na rin ang metadata mula sa mismong modelo, na tumutulong sa pagpapatunay ng mga hugis at uri bago i-invoke session.run.

Halimbawang session:

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

Ang dokumentasyong kasama ng modelo ay karaniwang nagpapahiwatig ng preprocessed kinakailangan at mga format ng pag-input. Siguraduhing respetuhin ang tensor scaling, normalization, at mga dimensyon, kung hindi, ang hinuha ay mabibigo o magbubunga ng hindi tugmang mga resulta.

Kumpletong halimbawa ng daloy:

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

Ang mga indeks ng output ay tumutugma sa mga label mula sa set ng pagsasanay (hal., ImageNet). Maaari mong imapa ang mga ito sa a LabelMap (isang hanay ng mga string sa parehong pagkakasunud-sunod ng mga klase ng modelo) at i-extract ang Nangungunang 10 na may higit na kumpiyansa na ipakita ang mga ito sa TextBlock.

Postprocessing at mga label:

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

Sa pamamagitan nito, kapag pinindot mo ang "Pumili ng larawan", ang modelo ay sinisimulan (kung hindi pa), ang imahe ay pinoproseso at ang malamang na mga hula sa kanilang mga kumpiyansa. Maaari mong iakma ang pattern na ito sa iba pang mga modelo at gawain ng ONNX (detection, segmentation, text, atbp.).

Tumatakbo sa Azure at MLOps

Kung kailangan mong mag-scale, pinapayagan ng Azure Machine Learning mag-deploy ng mga modelong ONNX bilang REST endpoints, pamamahala ng mga bersyon, pagsubaybay, at MLOps lifecycle. Sa ganitong paraan, maaari mong dalhin ang iyong pinapatakbo nang lokal sa cloud habang pinapanatili ang pareho modelong artifact at nakikinabang sa mga server accelerators.

Ang karaniwang daloy ay ang pag-package ng inference na may ONNX Runtime sa loob ng isang container, ilantad ang isang endpoint, at orchestrate mga update, sukatan y mga alertoPinagsasama ng diskarteng ito ang pag-unlad at pagpapatakbo ng malakihang modelo.

Pagpapabilis at pagiging tugma ng hardware

Namumukod-tangi ang ONNX Runtime para sa arkitektura nito Mga Tagabigay ng Pagpapatupad: kasama TensorRT pinipiga ang NVIDIA GPU; kasama OpenWINE ino-optimize ang mga Intel CPU/VPU; at kasama DirectML pinapabilis ang Windows sa mga GPU at NPU mula sa iba't ibang mga tagagawa. Mayroon ding mga pagsasanib sa Vitis AI upang magpatakbo ng mga modelo sa mga Xilinx FPGA (hal., U250), na nagpapalawak ng saklaw sa mga espesyal na pagsasaayos.

Pinapadali ng flexibility na ito para sa parehong modelo ng ONNX na gumanap nang maayos cloud, edge, web at mobile, na may engine na nag-aayos ng mga operator at memory sa bawat platform. Ang resulta ay mas mababang latency at pinahusay na throughput nang hindi binabago ang iyong high-level na code.

On-premises AI: privacy, gastos, at kontrol

Lokal na pagpapatakbo ng AI kasama ang ONNX Runtime Palihim (hindi ka nagbabahagi ng data), minimal latency y predictable na gastos (nang walang pagkonsumo ng cloud API). Ito ay lalong mahalaga sa pangangalagang pangkalusugan, pang-industriya, o mga sitwasyong may limitadong koneksyon, at mahusay na pinagsama sa .NET (kahit na VB.NET) o Python depende sa iyong stack.

Para sa mga advanced na modelo, a Napakabilis ng GPU, ngunit ang ONNX Runtime ay na-optimize din para sa CPU. Ang susi ay igalang ang modelong preprocessing at, kung naaangkop, ilapat quantification upang bawasan ang laki at memorya habang pinapanatili ang sapat na katumpakan.

Pagbabalik-loob at mabubuting gawi

Karaniwang ginagawa ang pag-convert ng mga modelo sa ONNX mula sa PyTorch torch.onnx.export at mula sa TensorFlow kasama ang tf2onnx. Asegura que el halimbawa tensor (dummy input) ay may tamang anyo at ang mga pagpapatakbo ng graph ay sinusuportahan ng target na opset.

Pagkatapos mag-convert, patunayan ang modelo sa pamamagitan ng pag-query mga input/output na may ONNX Runtime at magpatakbo ng mga test case. Kung may mga custom na layer, maaaring kailanganin mong iakma ang mga ito o palitan ng mga sinusuportahang operator; pagiging tugma sa pagitan ng opset at ang mga bersyon ay mahalaga upang maiwasan ang mga sorpresa.

Mga aplikasyon at kaso ng paggamit

Sa computer vision, pinapadali ng ONNX ang pag-uuri, pagtuklas at pagse-segment sa magkakaibang device, mula sa mga server hanggang gilid at IoT. Ang Pagbawas ng laki sa pamamagitan ng quantization at inference optimization ay ginagawa itong perpekto para sa real-time (hal., robots pabrika o inspeksyon ng kalidad).

Sa pangangalagang pangkalusugan, ang mga modelo ng ONNX sa mga wearable at monitoring system ay maaari mga signal ng preprocess (tulad ng ECG) at mga feature ng extract nang lokal, na pinapanatili ang privacy. Para sa mga matalinong lungsod, tinutukoy ng mga camera na pinapagana ng ONNX ang mga sasakyan sa loob tunay na oras nang hindi umaasa sa cloud, nag-o-optimize ng trapiko at mga mapagkukunan.

Mga Tampok na Mapagkukunan at Nilalaman

Pinapatakbo ng ONNX Runtime ang AI Windows, Office, Azure Cognitive Services at Bing, at sa libu-libong pandaigdigang proyekto. May mga materyal na pang-edukasyon na sumasaklaw sa ONNX, ang kaugnayan nito sa opset, hardware acceleration at totoong kaso tulad ng semantic image search ni Bing.

Ang isang halimbawa ng isang outreach program ay nagmamarka ng mga milestone na ito: Pagtatanghal ng ONNX, Panimula sa ONNX, Demo: Nagko-convert mula sa CoreML, Runtime ng ONNX, Mga bersyon at opset, Pagpapabilis ng hardware, Kasing praktikalAng ganitong uri ng nilalaman ay naglalarawan kung paano lumipat mula sa isang modelo patungo sa isang naka-optimize na deployment.

Upang mag-download ng mga nakahandang template, ang ONNX Model Zoo nag-aalok ng mga classifier ng imahe, detector, at mga modelo ng NLP. Kung ang isang bagay ay hindi nagko-convert sa unang pagkakataon, kadalasan ay nakakatulong na magbukas insidente sa converter repository naaayon at suriin ang mga hindi sinusuportahang operasyon.

Bilang panghuling tala, mayroon ding mga tiyak na pagsasama gaya ng Vitis AI (Xilinx) na may ONNX Runtime para sa mga U250 na FPGA, na pinapalawak ang hanay ng deployment sa programmable na hardware para sa mataas na pagganap at mababang latency na mga application.

Ang ONNX Runtime ay inilagay ang sarili bilang isang mahalagang piraso upang patakbuhin ang mga modelo ng AI bilis, versatility at kahusayan sa halos anumang kapaligiran. Gumagamit ka man sa Python o .NET, on-premises o sa Azure, at kailangan mo ng suporta para sa mga CPU, GPU, NPU, o kahit na mga FPGA, hinahayaan ka ng kumbinasyong ONNX + ONNX Runtime na magsanay kahit saan mo gusto at mag-deploy saanman ito pinaka-kombenyente, na may napatunayang produksyon na pipeline ng pag-optimize at aktibong komunidad na nagtutulak sa ebolusyon nito.

Kaugnay na artikulo:

DirectML: Lahat tungkol sa rebolusyon ng Artificial Intelligence sa Windows at gaming

Isaac

Masigasig na manunulat tungkol sa mundo ng mga byte at teknolohiya sa pangkalahatan. Gustung-gusto kong ibahagi ang aking kaalaman sa pamamagitan ng pagsusulat, at iyon ang gagawin ko sa blog na ito, ipakita sa iyo ang lahat ng mga pinaka-kagiliw-giliw na bagay tungkol sa mga gadget, software, hardware, teknolohikal na uso, at higit pa. Ang layunin ko ay tulungan kang mag-navigate sa digital na mundo sa simple at nakakaaliw na paraan.