Ana içeriğe geç

ONNX: İstediğiniz Çatıda Eğitin, İstediğiniz Donanımda Dağıtın

Modelleri ONNX formatına dönüştürmeyi, niceleme ile optimize etmeyi ve tedarikçi bağımlılığı olmadan uç cihazlardan bulut sunucularına kadar her platformda dağıtmayı öğrenin.
· 15 dk. oku

Yapay Zeka ile Keşfedin

Diyelim ki modelinizi PyTorch ile eğittiniz, ancak üretim sisteminiz TensorFlow çalıştırıyor. Her şeyi baştan yazmanız gerekir mi?

Hayır, gerekmez.

Model birlikte çalışabilirliği, makine öğrenimi mühendisleri için baş ağrısı olabilir. Farklı çatılar farklı formatlar kullanır ve aralarında dönüştürme yapmak modelinizi bozabilir veya beklenmedik davranışlara neden olabilir. Bunu istemezsiniz, ama aynı modelin birden fazla sürümünü de yönetmek istemezsiniz.

ONNX (Open Neural Network Exchange), makine öğrenimi modelleri için evrensel bir format sağlayarak bu sorunu çözer. Bir çatı altında eğitip başka birinde yeniden yazmadan veya hatalarla uğraşmadan dağıtmanıza olanak tanır.

Bu yazıda, modelleri ONNX formatına nasıl dönüştüreceğinizi, ONNX Runtime ile nasıl çıkarım yapacağınızı, modelleri üretim için nasıl optimize edeceğinizi ve uç cihazlardan bulut sunucularına kadar çeşitli platformlarda nasıl dağıtacağınızı göstereceğim.

ONNX ile Başlarken

Önce geliştirme ortamınızı kurmadan ONNX kullanamazsınız.

Bu bölümde, yazılım gereksinimlerinden temiz ve tekrarlanabilir bir çalışma alanı oluşturmaya kadar ihtiyacınız olan her şeyi adım adım anlatacağım. Windows, Linux ve macOS'ta ONNX ve ONNX Runtime'ı nasıl kuracağınızı göstereceğim.

Önkoşullar

ONNX tüm ana işletim sistemlerinde çalışır.

Makinenizde Python 3.8 veya üzeri yüklü olmalı. Temel olarak bu kadar. ONNX, Python'un ABI3 (Uygulama İkili Arabirimi) desteğini kullanır; bu da kaynak koddan derleme yapmadan hazır ikili paketleri kullanabileceğiniz anlamına gelir.

Yükleyecekleriniz şunlar:

  • uv (astral.sh/uv adresinden edinin)

  • Python 3.8+ (uv sizin için halleder)

  • pip (uv ile birlikte gelir)

uv'nin nasıl çalıştığını ve neden ilk tercihiniz olması gerektiğini öğrenmek isterseniz, en hızlı Python paket yöneticisi rehberimizi okuyun.

Windows kullanıcıları, uv'yi PowerShell ile kurabilir:

powershell -c "irm <https://astral.sh/uv/install.ps1> | iex"

Bir yürütme ilkesi hatası alırsanız, önce PowerShell'i yönetici olarak çalıştırın.

Linux kullanıcıları uv'yi şu kabuk komutuyla kurabilir:

curl -LsSf <https://astral.sh/uv/install.sh> | sh

Bu, tüm Linux dağıtımlarında çalışır.

Son olarak, macOS kullanıcıları uv'yi Homebrew ile veya bir curl komutuyla kurabilir:

brew install uv

# or

curl -LsSf <https://astral.sh/uv/install.sh> | sh

Ortamı kurma

uv ile bir proje nasıl kurulur:

mkdir onnx-project
cd onnx-project

# Initialize a uv project with Python 3.10
uv init --python 3.13

uv, bir .venv dizini ve bir pyproject.toml dosyası oluşturur. Sanal ortam, komutları uv üzerinden çalıştırdığınızda otomatik olarak etkinleşir.

Resim 1 - uv proje kurulumu

Şimdi ONNX ve ONNX Runtime'ı kurun:

uv add onnx onnxruntime

# Verify the installation
uv run python -c "import onnx; print(onnx.__version__)"
uv run python -c "import onnxruntime; print(onnxruntime.__version__)"

Doğrulama komutları sürüm numaralarını yazdırmalıdır:

Resim 2 - ONNX ve ONNX Runtime. sürümler

Bağımlılıklarınız zaten sabitlendi. uv, tüm paket sürümlerini otomatik olarak uv.lock dosyasına yazar. Bu, derlemelerinizi tekrarlanabilir yapar — herkes uv sync komutunu çalıştırarak sizinle birebir aynı ortamı oluşturabilir.

İşte pyproject.toml dosyanızın nasıl göründüğü:

[project]
name = "onnx-project"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.13"
dependencies = [
    "onnx>=1.19.1",
    "onnxruntime>=1.23.2",
]

Ve hepsi bu, ortam yapılandırıldı! Şimdi temellere geçelim.

ONNX Temellerini Anlamak

Modelleri dönüştürmeye başlamadan önce ONNX'in nasıl çalıştığını anlamanız gerekir.

Bu bölümde ONNX formatını parçalarına ayırarak grafik tabanlı mimarisini açıklayacağım. Bir ONNX dosyasının içinde neler olduğunu ve verinin içinden nasıl aktığını göstereceğim.

ONNX model formatı

Bir ONNX modeli, sinir ağınızın yapısını ve ağırlıklarını içeren bir dosyadır.

Bunu bir plan olarak düşünün. Dosya hangi işlemlerin hangi sırayla ve hangi parametrelerle yapılacağını tanımlar. Eğitilmiş ağırlıklar bu planla birlikte saklanır, böylece model ek dosyalara gerek kalmadan çalışmaya hazırdır.

ONNX, 2017'de Microsoft ve Facebook (şimdi Meta) iş birliğiyle piyasaya çıktı. Hedef basitti — her çatı değişiminde modelleri yeniden yazmayı bırakmak. PyTorch, TensorFlow ve diğer çatılar gelişiyordu, ancak modeller manuel dönüştürme olmadan aralarında taşınamıyordu.

ONNX bunu değiştirdi. Sürüm 1.0, bilgisayarlı görü ve basit sinir ağları için temel işlemleri destekliyordu. Bugünün ONNX'i, 2017'de var olmayan dönüştürücüleri, büyük dil modellerini ve karmaşık mimarileri destekliyor.

Bu veriyi serileştirmek için Protocol Buffers (protobuf) kullanır. Protobuf, Google tarafından verimli veri depolama ve iletimi için geliştirilen ikili bir formattır. JSON veya XML'den çok daha hızlı okunur ve yazılır ve dosyalar daha küçüktür. Çifte kazanç.

Bir ONNX modelinin içinde şunlar bulunur:

  • Graf: Ağ mimarisi
  • Ağırlıklar: Eğitilmiş model parametreleri
  • Meta veriler: Sürüm bilgisi, üretici adı ve model dokümantasyonu
  • Opset sürümü: Hangi işlemlerin mevcut olduğu

Opset sürümü önemlidir. ONNX zamanla evrilir; yeni işlemler eklemeye ve mevcutları iyileştirmeye devam eder. Model dosyanız hangi opset sürümünü kullandığını belirtir, böylece çalışma zamanı nasıl çalıştıracağını bilir.

Temel kavramlar ve mimari

ONNX modelinizi hesaplama grafiği olarak temsil eder.

Bir graf düğümler ve kenarlardan oluşur. Düğünler işlemlerdir (matris çarpımı veya aktivasyon fonksiyonları gibi), kenarlar ise bu işlemler arasında akan tensörlerdir (veriniz). ONNX, "bu matrisleri çarp, sonra ReLU uygula, sonra tekrar çarp" ifadesini bu şekilde tanımlar.

Basit bir örnek:

import onnx
from onnx import helper, TensorProto

# Create input and output tensors
input_tensor = helper.make_tensor_value_info(
    "input", TensorProto.FLOAT, [1, 3, 224, 224]
)
output_tensor = helper.make_tensor_value_info("output", TensorProto.FLOAT, [1, 1000])

# Create a node (operation)
node = helper.make_node(
    "Relu",  # Operation type
    ["input"],  # Input edges 
    ["output"],  # Output edges
)

# Create the graph
graph = helper.make_graph(
    [node],  # List of nodes
    "simple_model",  # Graph name
    [input_tensor],  # Inputs
    [output_tensor],  # Outputs
)

# Create the model
model = helper.make_model(graph)
onnx.save(model, "simple_model.onnx")

Resim 3 - Basit ONNX örneği

Her düğüm bir işlem yapar. İşlem türü (Relu, Conv veya MatMul gibi) ONNX işlemci setinden gelir. Kafanıza göre işlem adı uyduramazsınız — kullandığınız opset sürümünde var olmalıdır.

Kenarlar düğümleri birbirine bağlar ve tensörleri taşır. Bir tensörün bir şekli ve veri türü vardır. [1, 3, 224, 224] tanımladığınızda, "bu tensör bu boyutlarda 4 boyuta sahip" diyorsunuz. Çalışma zamanı bu bilgiyi belleği tahsis etmek ve grafı doğrulamak için kullanır.

Graf tek yönde akar. Veri giriş düğümlerinden girer, işlemlerden geçer ve çıkış düğümlerinden çıkar. Döngülere izin verilmez — ONNX yinelemeli bağlantıları doğrudan desteklemez. Döngüleri açmanız veya diziler için tasarlanmış belirli işlemleri kullanmanız gerekir.

Bu grafik yapısı, çatı bağımsızlığını mümkün kılar. PyTorch anında yürütmeyi düşünür, TensorFlow statik grafikleri kullanır ve scikit-learn bambaşka bir soyutlamaya sahiptir. Ancak hepsi aynı grafik formatına dışa aktarım yapabilir.

Graf aynı zamanda ortak optimizasyonu da mümkün kılar. Bir ONNX optimize edici, işlemleri birleştirebilir (birden çok düğümü tek düğümde füzyonlar), ölü kodu ortadan kaldırabilir (kullanılmayan düğümleri çıkarır) veya yavaş işlemleri daha hızlı eşdeğerleriyle değiştirebilir. Bu optimizasyonlar, modeli hangi çatının oluşturduğundan bağımsız çalışır.

Sırada, modelleri ONNX formatına dönüştürmenin inceliklerini göstereyim.

Modelleri ONNX Formatına Dönüştürme

Bu bölümde, PyTorch, TensorFlow ve scikit-learn'den modelleri nasıl dışa aktaracağınızı göstereceğim. Dönüştürme sürecini adım adım anlatacak ve modelinizin dönüşümden sonra doğru çalıştığını nasıl doğrulayacağınızı göstereceğim.

Çatı desteği ve araçlar

ONNX, en popüler makine öğrenimi çatılarının çoğunu destekler.

PyTorch, torch.onnx.export() ile yerleşik ONNX dışa aktarımına sahiptir. PyTorch ve ONNX'in her ikisi de Meta tarafından yürütüldüğü için en olgun dönüştürücüdür.

TensorFlow dönüştürme için tf2onnx kullanır. TensorFlow grafikleri ONNX formatına dönüştüren ayrı bir kütüphanedir. uv add tf2onnx ile kurun ve hazırsınız.

scikit-learn skl2onnx üzerinden dönüştürür. Bu kütüphane rastgele ormanlar, doğrusal regresyon ve SVM gibi geleneksel makine öğrenimi modellerini ele alır. Derin öğrenim çatıları daha çok ilgi görse de scikit-learn modelleri de gayet iyi çalışır.

En popülerleri bu üçüdür, ancak şu diğer desteklenen çatılardan herhangi birini de kullanabilirsiniz — yalnızca bağımlılığı uv add <name>: ile kurun:

  • Keras: tf2onnx kullanın (Keras, TensorFlow'un bir parçasıdır)

  • XGBoost: onnxmltools kullanın

  • LightGBM: onnxmltools kullanın

  • MATLAB: Yerleşik ONNX dışa aktarımı

  • Paddle: paddle2onnx kullanın

Her çatı kendi dönüştürücüsüne sahiptir çünkü modelleri farklı şekilde temsil ederler. PyTorch dinamik hesaplama grafikleri kullanır, TensorFlow statik grafikleri kullanır ve scikit-learn hiç grafik kullanmaz. Dönüştürücüler bu temsilleri ONNX'in grafik formatına çevirir.

Başka kişiler tarafından eğitilmiş modelleri de kullanabilirsiniz. ONNX Model Zoo, kullanıma hazır önceden eğitilmiş modeller barındırır. Bilgisayarlı görü (ResNet, YOLO, EfficientNet), NLP (BERT, GPT-2) ve daha fazlasını bulabilirsiniz. Resmi GitHub deposundan indirin.

Hugging Face de ONNX modelleri barındırır. Adında "onnx" geçen modelleri arayın veya ONNX formata göre filtreleyin. Birçok popüler dönüştürücü model, çıkarım için zaten optimize edilmiş ONNX formatında mevcuttur.

Devam etmeden önce, uv ile gerekli tüm kütüphaneleri almak için bu komutu çalıştırın:

uv add torch torchvision tensorflow tf2onnx scikit-learn skl2onnx onnxscript

Adım adım dönüştürme süreci

Bir PyTorch modelini ONNX'e böyle dönüştürürsünüz:

import torch
import torch.nn as nn

# Define a simple model
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(10, 5)

    def forward(self, x):
        return self.fc(x)

# Create and prepare the model
model = SimpleModel()
model.eval()  # Set to evaluation mode

# Create dummy input with the same shape as your real data
dummy_input = torch.randn(1, 10)

# Export to ONNX
torch.onnx.export(
    model,  # Model to export
    dummy_input,  # Example input
    "simple_model.onnx",  # Output file
    input_names=["input"],  # Name for the input
    output_names=["output"],  # Name for the output
    dynamic_shapes={"x": {0: "batch_size"}},  # Allow variable batch size
)

PyTorch'a yeni misiniz? Bu sizi durdurmasın. PyTorch ile Derin Öğrenme kursumuz, temelleri birkaç saat içinde kapsar.

Sahte girdi önemlidir. ONNX, grafiği inşa etmek için girdi şeklini bilmek zorundadır. Modeliniz değişken uzunlukta dizileri veya farklı yığın boyutlarını kabul ediyorsa, bu boyutları dinamik olarak işaretlemek için dynamic_shapes kullanın.

Modelinizi her zaman değerlendirme moduna alın — dışa aktarmadan önce model.eval() ile. Bu, dropout ve batch normalization eğitim davranışını devre dışı bırakır. Bu adımı unutursanız dönüştürülmüş modeliniz orijinaliyle uyuşmayacaktır.

Dinamik şekiller sorun çıkarabilir. Dönüştürücünüz bilinmeyen boyutlar hakkında şikayet ediyorsa, dynamic_shapes değerini doğru belirttiğinizden veya somut şekiller sağladığınızdan emin olun.

Şimdi TensorFlow'a geçerek çalıştırabileceğiniz bir alternatif kod:

import numpy as np
# Temporary compatibility fixes for tf2onnx
if not hasattr(np, "object"):
    np.object = object
if not hasattr(np, "cast"):
    np.cast = lambda dtype: np.asarray

import tensorflow as tf
import tf2onnx

# Define a simple Keras model (same spirit as your PyTorch one)
inputs = tf.keras.Input(shape=(10,), name="input")
outputs = tf.keras.layers.Dense(5, name="output")(inputs)
model = tf.keras.Model(inputs, outputs)

# Save the model (optional, if you want a .h5 file)
model.save("simple_tf_model.h5")

# Define a dynamic input spec (None = dynamic batch dimension)
spec = (tf.TensorSpec((None, 10), tf.float32, name="input"),)

# Convert to ONNX
model_proto, _ = tf2onnx.convert.from_keras(
    model, input_signature=spec, output_path="simple_tf_model.onnx"
)

TensorFlow ile hiç çalışmadıysanız, Python'da TensorFlow'a Giriş kursumuzu öneririz.

Ne yazık ki, Numpy'ın en son sürümüyle biraz çakışma var, bu yüzden geçici bir düzeltme ekledim. Bu satırları okuduğunuz tarihte umarım ilk altı satır olmadan da kodu çalıştırabilirsiniz.

Ve son olarak, scikit-learn modelleri için ONNX dönüşümüne bakalım:

from sklearn.ensemble import RandomForestClassifier
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

# Train a simple model
model = RandomForestClassifier(n_estimators=10)
model.fit(X_train, y_train)

# Define input type and shape
initial_type = [('float_input', FloatTensorType([None, 4]))]

# Convert to ONNX
onnx_model = convert_sklearn(model, initial_types=initial_type)

# Save the model
with open("sklearn_model.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

TensorFlow'a benzer şekilde, DataCamp’in ücretsiz scikit-learn ile Denetimli Öğrenme kursu da var — yukarıdaki kod size karışık geldiyse göz atın.

Ve hepsi bu kadar!

Dönüştürdüğünüz modeli doğrulamak için şu kodu çalıştırabilirsiniz:

import onnx
import onnxruntime as ort
import numpy as np

# Load and check the ONNX model
onnx_model = onnx.load("simple_model.onnx")
onnx.checker.check_model(onnx_model)

# Run inference with ONNX Runtime
session = ort.InferenceSession("simple_model.onnx")
input_name = session.get_inputs()[0].name

# Create test input
test_input = np.random.randn(1, 10).astype(np.float32)

# Get prediction
onnx_output = session.run(None, {input_name: test_input})

# Compare with original model
with torch.no_grad():
    original_output = model(torch.from_numpy(test_input))

# Check if outputs match (within floating point tolerance)
np.testing.assert_allclose(
    original_output.numpy(),
    onnx_output[0],
    rtol=1e-3,
    atol=1e-5
)
print("Model conversion successful - outputs match!")

Resim 4 - ONNX model doğrulaması

Bir modeli her dönüştürdüğünüzde bu doğrulamayı çalıştırın. Küçük sayısal farklılıklar normaldir (kayan nokta aritmetiği tam değildir), ancak büyük farklılıklar dönüştürme sırasında bir şeylerin ters gittiğini gösterir.

Kapanış için, bilmeniz gereken iki önemli uyarı:

  • Özel işlemler dönüştürülmez: Özel PyTorch işlemleri veya TensorFlow katmanları yazdıysanız, dönüştürücü bunları nasıl çevireceğini bilmez. Ya standart işlemlerle yeniden yazmanız ya da özel ONNX operatörleri kaydetmeniz gerekir.
  • Sürüm uyumsuzlukları işleri bozar: Çatınızın sürümü, dönüştürücünün sürümü ve ONNX sürümü uyumlu olmalıdır. Desteklenen sürüm kombinasyonları için dönüştürücünün dokümantasyonunu kontrol edin.

Sırada ONNX Runtime var.

ONNX Runtime ile Çıkarım Çalıştırma

Bu bölümde, ONNX Runtime'ı kullanarak modelleri nasıl yükleyip tahmin yapacağınızı göstereceğim. Donanım hızlandırma seçeneklerini anlatacak ve ONNX Runtime'ın üretimde nerede parladığını göstereceğim.

ONNX Runtime'a giriş

ONNX Runtime, çapraz platform bir çıkarım motorudur. Microsoft, ONNX modellerini herhangi bir donanımda — CPU'lar, GPU'lar, mobil yongalar ve özel yapay zekâ hızlandırıcılarında — hızlı çalıştırmak için geliştirdi.

Nasıl çalışır: Bir ONNX modeli yüklersiniz ve ONNX Runtime bir yürütme planı oluşturur. Hesaplama grafiğini analiz eder, optimizasyonlar uygular ve işlemleri donanımınızda çalıştırmanın en iyi yolunu belirler. Ardından çıkarımı bu optimize edilmiş planla çalıştırır.

Mimari, yürütme mantığını donanım‑özel koddan ayırır. Yürütme sağlayıcıları donanım arayüzünü ele alır. NVIDIA GPU'larda mı çalıştırmak istiyorsunuz? CUDA yürütme sağlayıcısını kullanın. Apple Silicon mu istiyorsunuz? Alttaki kodunuz aynı kalır.

ONNX Runtime'ın şu yürütme sağlayıcıları vardır:

  • CPUExecutionProvider: Varsayılan sağlayıcı, her yerde çalışır

  • CUDAExecutionProvider: CUDA'lı NVIDIA GPU'lar

  • TensorRTExecutionProvider: TensorRT optimizasyonlu NVIDIA GPU'lar

  • CoreMLExecutionProvider: Apple cihazları (macOS, iOS)

  • DmlExecutionProvider: Windows için DirectML (her GPU ile çalışır)

  • OpenVINOExecutionProvider: Intel CPU ve GPU'lar

  • ROCMExecutionProvider: AMD GPU'lar

Her sağlayıcı, ONNX işlemlerini donanım‑özel talimatlara çevirir. CPU sağlayıcısı standart CPU işlemlerini kullanır. CUDA sağlayıcısı cuDNN ve cuBLAS kullanır. TensorRT sağlayıcısı modelinizi optimize edilmiş GPU çekirdeklerine derler, vb.

Bir modeli kurma ve çalıştırma

Bir ONNX modelini üç satır kodla yükleyebilirsiniz:

import onnxruntime as ort

# Create an inference session
session = ort.InferenceSession("simple_model.onnx")

# Get input and output names
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name

InferenceSession tüm ağır işi yapar. Modeli yükler, grafiği doğrular ve çıkarıma hazırlar. Varsayılan olarak CPU yürütme sağlayıcısını kullanır.

Şimdi çıkarımı çalıştırın:

import numpy as np
import onnxruntime as ort

# Create an inference session
session = ort.InferenceSession("simple_model.onnx")

# Get input and output names
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name

# Prepare input data
input_data = np.random.randn(1, 10).astype(np.float32)

# Run inference
outputs = session.run(
    [output_name],
    {input_name: input_data},
)

# Get predictions
predictions = outputs[0]
print(predictions.shape)

Resim 5 - ONNX ile bir PyTorch modelini çalıştırma

run() yöntemi iki argüman alır. İlki, çıkış adlarının bir listesi (veya tüm çıkışlar için None). İkincisi, girdi adlarını numpy dizilerine eşleyen bir sözlüktür.

Girdi şekilleri eşleşmelidir. Modeliniz [1, 10] beklerken siz [1, 10, 3] verirseniz çıkarım başarısız olur.

GPU hızlandırma istiyorsanız, oturumu oluştururken yürütme sağlayıcılarını belirtmeniz yeterlidir:

# For NVIDIA GPUs with CUDA
session = ort.InferenceSession(
    "model.onnx",
    providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)

# For Apple Silicon
session = ort.InferenceSession(
    "model.onnx",
    providers=['CoreMLExecutionProvider', 'CPUExecutionProvider']
)

# For Intel hardware
session = ort.InferenceSession(
    "model.onnx",
    providers=['OpenVINOExecutionProvider', 'CPUExecutionProvider']
)

Sağlayıcıları öncelik sırasına göre listeleyin. ONNX Runtime ilk sağlayıcıyı dener, uygun değilse bir sonrakine geri döner. Her zaman son yedek olarak CPUExecutionProvider ekleyin.

Hangi sağlayıcının gerçekten kullanıldığını kontrol edebilirsiniz:

import numpy as np
import onnxruntime as ort

# Create an inference session
session = ort.InferenceSession(
    "simple_model.onnx", providers=["CoreMLExecutionProvider", "CPUExecutionProvider"]
)

# Get input and output names
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name

# Prepare input data
input_data = np.random.randn(1, 10).astype(np.float32)

# Run inference
outputs = session.run(
    [output_name],
    {input_name: input_data},
)

# Get predictions
predictions = outputs[0]
print(predictions.shape)
print("Providers:")
print(session.get_providers())

Resim 6 - Sağlayıcı değiştirme

Bir GPU beklerken ["CPUExecutionProvider"] görürseniz, GPU sağlayıcısı kullanılamıyordur. Yaygın nedenler eksik sürücüler, yanlış ONNX Runtime paketi veya uyumsuz GPU olabilir.

Yapılandırma burada bitmiyor. Daha iyi performans için yürütme sağlayıcısını daha da optimize edebilirsiniz:

providers = [
    (
        "TensorRTExecutionProvider",
        {
            "device_id": 0,
            "trt_max_workspace_size": 2147483648,  # 2GB
            "trt_fp16_enable": True,  # Use FP16 precision
        },
    ),
    "CUDAExecutionProvider",
    "CPUExecutionProvider",
]

session = ort.InferenceSession("simple_model.onnx", providers=providers)

Tercih ettiğiniz sağlayıcı için mevcut tüm seçeneklerin listesini almak üzere resmi ONNX Runtime dokümantasyonuna bakabilirsiniz.

ONNX Runtime uygulamaları

ONNX Runtime'ın etkileyici yanı her yerde çalışmasıdır — sunucular, tarayıcılar ve mobil cihazlar.

ONNX Runtime Web, WebAssembly ve WebGL kullanarak çıkarımı tarayıcılara getirir. Modeliniz verileri sunuculara göndermeden istemci tarafında çalışır. Bu, tıbbi görüntü analizi veya doküman işleme gibi mahremiyet hassasiyeti olan uygulamalar için harikadır.

Basit bir HTML dosyasında ONNX Runtime'ı nasıl kullanabileceğinize dair basit bir örnek:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>ONNXRuntime Web Demo</title>
</head>
<body>
  <h1>ONNXRuntime Web Demo</h1>

  <!-- Load ONNXRuntime-Web from CDN -->
  <script src="<https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js>"></script>

  <script>
    async function runModel() {
      // Create inference session
      const session = await ort.InferenceSession.create('./simple_model.onnx');

      // Prepare input
      const inputData = new Float32Array(10).fill(0).map(() => Math.random());
      const tensor = new ort.Tensor('float32', inputData, [1, 10]);

      // Run inference
      const results = await session.run({ input: tensor });

      const output = results.output;
      console.log('Output shape:', output.dims);
      console.log('Output values:', output.data);
    }

    runModel();
  </script>
</body>
</html>

Resim 7 - JavaScript ile ONNX Runtime

Mobil dağıtım için ONNX Runtime Mobile'ı kullanabilirsiniz — iOS ve Android için optimize edilmiş, hafifletilmiş bir sürüm. Gereksiz özellikleri çıkarır ve ikili dosya boyutunu azaltır.

İşte bir iOS yapılandırma örneği:

import onnxruntime_objc

let modelPath = Bundle.main.path(forResource: "simple_model", ofType: "onnx")!
let session = try ORTSession(modelPath: modelPath)

let inputData = // Your input as Data
let inputTensor = try ORTValue(tensorData: inputData,
                               elementType: .float,
                               shape: [1, 10])

let outputs = try session.run(withInputs: ["input": inputTensor])

Veya bir REST API'si oluşturmak için Python kullanıyorsanız, şu yaklaşımı izleyerek ONNX Runtime'ı uç noktalarınızdan birine dahil edebilirsiniz:

from fastapi import FastAPI
import onnxruntime as ort
import numpy as np

app = FastAPI()
session = ort.InferenceSession("simple_model.onnx")

@app.post("/predict")
async def predict(data: dict):
    input_data = np.array(data["input"]).astype(np.float32)
    outputs = session.run(None, {"input": input_data})
    return {"prediction": outputs[0].tolist()}

Ve hepsi bu! Diğer ortamlar da benzer bir yaklaşım kullanır, ancak fikir net — ONNX Runtime kullanımı kolaydır. Sırada optimizasyon var.

ONNX Modellerini Optimize Etme

Bu bölümde, ONNX modellerini niceleme ve grafik optimizasyonlarıyla nasıl daha hızlı ve daha küçük hale getireceğinizi göstereceğim. Gerçek dünya dağıtımları için en önemli teknikleri adım adım anlatacağım.

Niceleme teknikleri

Niceleme, modelinizin duyarlılığını azaltarak onu daha hızlı ve daha küçük hale getirir.

Ağırlıkları 32 bit kayan nokta yerine 8 bit tamsayılar olarak saklarsınız. Bu, bellek kullanımını %75 azaltır ve çıkarımı hızlandırır; çünkü çoğu donanımda tamsayı aritmetiği kayan noktaya göre daha hızlıdır.

Dinamik niceleme ağırlıkları daha düşük duyarlılığa dönüştürür ancak aktivasyonları (çıkarım sırasında ara değerler) tam duyarlılıkta tutar. Kalibrasyon verisi gerektirmediği için en kolay niceleme yöntemidir.

Dinamik nicelemeyi böyle uygularsınız:

from onnxruntime.quantization import quantize_dynamic, QuantType

# Quantize the model
quantize_dynamic(
    model_input="model.onnx",
    model_output="model_quantized.onnx",
    weight_type=QuantType.QUInt8  # 8-bit unsigned integers
)

Hepsi bu. Nicelemiş modeliniz artık 8 bit işaretsiz tamsayılar kullanır ve kullanıma hazırdır.

Statik niceleme hem ağırlıkları hem de aktivasyonları daha düşük duyarlılığa dönüştürür. Dinamik nicelemeden daha saldırgandır ve daha hızlıdır, ancak aktivasyon aralıklarını ölçmek için temsil edici kalibrasyon verisine ihtiyaç duyar.

Statik niceleme uygulamak için genel bir strateji:

from onnxruntime.quantization import quantize_static, CalibrationDataReader
import numpy as np

# Create a calibration data reader
class DataReader(CalibrationDataReader):
    def __init__(self, calibration_data):
        self.data = calibration_data
        self.index = 0

    def get_next(self):
        if self.index >= len(self.data):
            return None
        batch = {"input": self.data[self.index]}
        self.index += 1
        return batch

# Load calibration data (100-1000 samples from your dataset)
calibration_data = [np.random.randn(1, 10).astype(np.float32)
                    for _ in range(100)]
data_reader = DataReader(calibration_data)

# Quantize
quantize_static(
    model_input="model.onnx",
    model_output="model_static_quantized.onnx",
    calibration_data_reader=data_reader
)

Kalibrasyon verileri, gerçek çıkarım iş yükünüzü temsil etmelidir; bu yüzden yukarıda gösterdiğim gibi rastgele veri kullanmayın. Veri kümenizden gerçek örnekler kullanın.

Genel olarak, niceleme bir makine öğrenimi mühendisi olarak bilmeniz gereken bazı fayda ve ödünleşimlere sahiptir. İşte faydalar:

  • 4 kat daha küçük modeller: INT8, FP32'nin dörtte biri kadar bellek kullanır
  • 2–4 kat daha hızlı çıkarım: Tamsayı işlemleri CPU'larda daha hızlı çalışır
  • Daha düşük güç tüketimi: Daha az hesaplama, daha az enerji demektir
  • Daha iyi önbellek kullanımı: Daha küçük modeller CPU önbelleğine sığar

Ve işte ödünleşimler:

  • Hafif doğruluk kaybı: Genellikle INT8 için %1–2, çoğu uygulama için kabul edilebilir
  • Tüm işlemler iyi nicelemez: Batch normalization ve softmax zordur
  • Donanım bağımlılığı: GPU hızlanmaları değişkendir, bazı GPU'lar INT8'i hızlandırmaz

Niceleme, büyük dil modelleri ve üretken yapay zekâ için de parıldar. 7B parametreli bir model FP32'de 28GB bellek ister. INT8'e nicelediğinizde 7GB'a düşer. INT4'e nicelediğinizde 3.5GB — tüketici donanımında çalışacak kadar küçük.

Grafik optimizasyonları

Grafik optimizasyonları, modelinizin hesaplama grafiğini daha hızlı olacak şekilde yeniden yazar.

Düğüm füzyonu kavramı, birden çok işlemi tek bir işlemde birleştirir. Modelinizde Conv katmanını BatchNorm ve ardından ReLU takip ediyorsa, optimize edici bunları tek bir ConvBnRelu düğümünde birleştirir. Bu, bellek trafiğini azaltır ve yürütmeyi hızlandırır.

Füzyondan önce graf böyle görünür:

Input -> Conv -> BatchNorm -> ReLU -> Output

Füzyondan sonra sadeleşir:

Input -> ConvBnRelu -> Output

Grafik optimizasyonu söz konusu olduğunda bilmeniz gereken iki kavram daha var:

  • Sabit katlama, girdi verisine bağlı olmayan işlemleri önceden hesaplar. Modeliniz bir ağırlık matrisini sabit bir sayıyla çarpıyorsa, optimize edici bu çarpımı her çıkarımda değil, optimizasyon sırasında bir kez yapar.
  • Ölü kod silme, kullanılmayan işlemleri kaldırır. Modelinizde asla çalışmayan dallar veya hiç kullanmadığınız çıktılar varsa, optimize edici bunları keser.

ONNX Runtime'da grafik optimizasyonlarını böyle etkinleştirirsiniz:

import onnxruntime as ort

# Set optimization level
sess_options = ort.SessionOptions()
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

# Create session with optimizations
session = ort.InferenceSession(
    "simple_model.onnx",
    sess_options,
    providers=["CPUExecutionProvider"]
)

ONNX Runtime şu optimizasyon seviyelerine sahiptir:

  • ORT_DISABLE_ALL: Hiçbir optimizasyon (hata ayıklama için yararlı)

  • ORT_ENABLE_BASIC: Sayısal sonuçları değiştirmeyen güvenli optimizasyonlar

  • ORT_ENABLE_EXTENDED: Küçük sayısal farklılıklar yaratabilecek saldırgan optimizasyonlar

  • ORT_ENABLE_ALL: Düzen dönüşümleri dâhil tüm optimizasyonlar

Üretimde ORT_ENABLE_ALL kullanın. Ufak sayısal farklılıklara değecek bir hızlanma sağlar.

Yeniden kullanım için optimize edilmiş modelleri kaydetmek üzere bu kodu çalıştırabilirsiniz:

sess_options = ort.SessionOptions()
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
sess_options.optimized_model_filepath = "model_optimized.onnx"

# This creates and saves the optimized model
session = ort.InferenceSession("simple_model.onnx", sess_options)

Grafik optimizasyonları, modelinizi hangi çatının oluşturduğundan bağımsız çalışır. Bir PyTorch Conv-BN-ReLU deseni de bir TensorFlow Conv-BN-ReLU deseni de aynı şekilde birleştirilir. Bu, ortak optimizasyonun faydasıdır — optimizasyonu bir kez yazarsınız, herhangi bir çatıdan gelen modellere uygularsınız.

Sırada dağıtım var.

Dağıtım Senaryoları

Bu bölümde üç dağıtım senaryosunu ele alacağım — uç cihazlar, bulut altyapısı ve web tarayıcıları. Her ortam için zorlukları ve çözümleri göstereceğim.

Uç cihazlarda dağıtım

Uç cihazların temel zorluğu sınırlı kaynaklara sahip olmalarıdır.

Akıllı telefonunuzda 4–16GB RAM vardır. Bir Raspberry Pi'da daha da az. IoT cihazları 512MB veya daha az olabilir. 7B parametreli bir modeli bu cihazlara atıp çalışmasını bekleyemezsiniz.

Nicelemeyle başlayın. INT8 modelleri temeliniz olmalı. Doğruluk kaybını tolere edebiliyorsanız INT4'e bile inin. Bu, modelinizi belleğe sığacak kadar küçültür.

Uç cihazlara dağıtım söz konusu olduğunda ONNX Runtime Mobile en iyi yardımcınızdır. Sunucu tarafı özelliklerini çıkartır ve pil ömrü için optimize eder. İkili dosya daha küçüktür, başlatma daha hızlıdır ve güç tüketimi daha düşüktür.

Mobil uygulama projenize böyle ekleyebilirsiniz:

# iOS
pod 'onnxruntime-mobile-objc'

# Android
implementation 'com.microsoft.onnxruntime:onnxruntime-android:latest.version'

Yürütme sağlayıcıları donanım farklarını yönetir. Android cihazlar ARM CPU'lar kullanır, bazıları farklı üreticilerden GPU'lara sahiptir ve yeni telefonlarda NPU'lar (Sinir İşleme Birimleri) vardır. Her çip için kod yazmak istemezsiniz.

Doğru yürütme sağlayıcısını seçmek için bu kodu referans alın:

# iOS - use CoreML for Apple Silicon optimization
session = ort.InferenceSession(
    "simple_model.onnx",
    providers=["CoreMLExecutionProvider", "CPUExecutionProvider"]
)

# Android - use NNAPI for hardware acceleration
session = ort.InferenceSession(
    "simple_model.onnx",
    providers=["NnapiExecutionProvider", "CPUExecutionProvider"]
)

iOS'ta CoreML, Neural Engine'ı (Apple'ın NPU'su) kullanır. Android'de NNAPI, cihazınızda bulunan hızlandırıcıyı — GPU, DSP veya NPU — kullanır. Sağlayıcı donanımı soyutlar, böylece kodunuz aynı kalır. Daha iyi performanslı yeni bir çip çıktığında yalnızca yürütme sağlayıcısını güncellersiniz ve uygulamanız kod değişikliği olmadan daha hızlı çalışır.

Bulutta dağıtım

Bulut dağıtımı size sınırsız ölçek ve en yeni donanımı sunar.

ONNX modellerini herhangi bir bulut platformunda — AWS, Azure, GCP veya kendi sunucularınızda — dağıtabilirsiniz. Örüntü aynıdır — çıkarım servisinizi kapsülle (container) alın ve bir yük dengeleyicinin arkasına yerleştirin.

Küçük bir Python FastAPI örneği:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import onnxruntime as ort
import numpy as np
import logging

app = FastAPI()
logger = logging.getLogger(__name__)

# Load model at startup
session = None

@app.on_event("startup")
async def load_model():
    global session
    session = ort.InferenceSession(
        "simple_model.onnx",
        providers=[
            "CUDAExecutionProvider",
            "CoreMLExecutionProvider",
            "CPUExecutionProvider",
        ],
    )
    logger.info("Model loaded successfully")

class PredictionRequest(BaseModel):
    input: list

class PredictionResponse(BaseModel):
    prediction: list
    inference_time_ms: float

@app.post("/predict", response_model=PredictionResponse)
async def predict(request: PredictionRequest):
    try:
        import time

        start = time.time()

        # Input shape: (1, 10)
        input_data = np.array(request.input, dtype=np.float32).reshape(1, 10)
        input_name = session.get_inputs()[0].name
        outputs = session.run(None, {input_name: input_data})

        inference_time = (time.time() - start) * 1000

        return PredictionResponse(
            prediction=outputs[0].tolist(), inference_time_ms=inference_time
        )
    except Exception as e:
        logger.error(f"Prediction failed: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health():
    return {"status": "healthy", "model_loaded": session is not None}

Bu FastAPI örneği küçük olsa da, makine öğrenimi mühendisleri için anlaşılması en kolay olanı değildir. Temelleri ücretsiz FastAPI'ye Giriş kursumuzla ustalaşabilirsiniz.

Sonrasında Docker ile kapsülleştirebilirsiniz:

FROM python:3.13-slim

WORKDIR /app

# Install dependencies
RUN pip install onnx onnxruntime onnxscript fastapi pydantic numpy uvicorn

# Copy model and code
COPY simple_model.onnx .
COPY main.py .

# Expose port
EXPOSE 8000

# Run the service
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Her makine öğrenimi meraklısı Docker'ın temellerini bilmelidir. Docker'a Giriş kursumuzu alarak bir makine öğrenimi modelini nasıl dağıtacağınızı öğrenin.

8000 portunda çalışan bir uygulama elde edeceksiniz; dokümanlarını doğrudan açıp tahmin uç noktasını deneyebilirsiniz:

Resim 8 - FastAPI ile dağıtılmış ONNX modeli

Azure Machine Learning kullanıyorsanız, ONNX ile doğrudan entegre olduğunu bilmek sizi memnun edecektir. Modelinizi üç adımda dağıtabilirsiniz:

from azureml.core import Workspace, Model
from azureml.core.webservice import AciWebservice, Webservice

# Register model
ws = Workspace.from_config()
model = Model.register(
    workspace=ws, model_path="simple_model.onnx", model_name="my-onnx-model"
)

# Deploy
deployment_config = AciWebservice.deploy_configuration(cpu_cores=1, memory_gb=1)

service = Model.deploy(
    workspace=ws,
    name="onnx-service",
    models=[model],
    deployment_config=deployment_config,
)

Azure ölçekleme, izleme ve güncellemeleri yönetir. Otomatik günlükleme, istek izleme ve sağlık kontrolleri elde edersiniz.

Azure Machine Learning'e yeniyseniz, hızla temelleri öğrenmek için Yeni Başlayanlar Rehberi yazımızı okuyun.

Eğer MLOps iş akışları diyorsak, şu bileşenler gerekir:

  • Sürüm kontrolü: DVC veya MLflow ile model sürümlerini izleyin
  • CI/CD: GitHub Actions veya Azure Pipelines ile test ve dağıtımı otomatikleştirin
  • İzleme: Çıkarım gecikmesi, verim ve hata oranlarını takip edin
  • A/B testleri: Üretimde model sürümlerini karşılaştırın
  • Geri alma: Sorun çıktığında önceki sürümlere dönün

Kullanabileceğiniz bir örnek kod parçası:

import prometheus_client as prom
import onnxruntime as ort
import numpy as np

# Define metrics
inference_duration = prom.Histogram(
    "model_inference_duration_seconds", "Time spent processing inference"
)

inference_count = prom.Counter("model_inference_total", "Total number of inferences")

# Load model
session = ort.InferenceSession("simple_model.onnx")

@app.post("/predict")
@inference_duration.time()
async def predict(request: PredictionRequest):
    inference_count.inc()
    # Input shape: (1, 10)
    input_data = np.array(request.input, dtype=np.float32).reshape(1, 10)
    input_name = session.get_inputs()[0].name
    outputs = session.run(None, {input_name: input_data})
    return {"prediction": outputs[0].tolist()}

Buradan, bir yük dengeleyicinin arkasında birden çok servis örneği çalıştırarak yatayda ölçekleyebilirsiniz. ONNX Runtime durumsuzdur, bu yüzden herhangi bir örnek herhangi bir isteği ele alabilir.

Tarayıcı tabanlı çıkarım

ONNX Runtime Web, modelleri doğrudan tarayıcılarda WebAssembly ve WebGL kullanarak çalıştırır.

Verileri bir sunucuya göndermek yerine, modeli bir kez tarayıcıya gönderir ve çıkarımı yerelde çalıştırırsınız. Kullanıcılar ağ gecikmesi olmadan anında yanıt alır.

Başlamak için, satır içi JS betiği kullanan bir HTML dosyası oluşturmanız yeterlidir:

<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <script src="<https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/ort.min.js>"></script>
  </head>
  <body>
    <script>
      async function run() {
        try {
          const session = await ort.InferenceSession.create("simple_model.onnx", {
            executionProviders: ["wasm"]
          });
          console.log("Session loaded:", session);

          // Inspect names
          console.log("Inputs:", session.inputNames);
          console.log("Outputs:", session.outputNames);

          const inputName = session.inputNames[0];

          const inputData = new Float32Array(10).fill(0).map(() => Math.random());
          const tensor = new ort.Tensor("float32", inputData, [1, 10]);

          const feeds = {};
          feeds[inputName] = tensor;

          const results = await session.run(feeds);

          const outputName = session.outputNames[0];
          console.log("Prediction:", results[outputName].data);

        } catch (err) {
          console.error("ERROR:", err);
        }
      }

      run();
    </script>
  </body>
</html>

Canlı sunucu ile dosyayı açar açmaz çıktıyı konsolda görebilirsiniz:

Resim 9 - JavaScript ile ONNX runtime

Ve son olarak, birkaç ileri konuyu tartışalım.

İleri Konular

Standart ONNX işlemleri çoğu kullanım senaryosunu kapsar, ancak daha fazlasına ihtiyacınız varsa bu bölüm size göre.

Özel operatörleri ve büyük dil modeli dağıtımını ele alacağım. Bu ileri özelliklere ne zaman ihtiyaç duyduğunuzu ve getirdikleri ödünleşimleri açıklayacağım.

Özel operatörler

ONNX yüzlerce işlemi beraberinde getirir, ancak modelinizin benzersiz bir şeye ihtiyacı olabilir.

Özel operatörler, standart ONNX operatör setinde bulunmayan işlemleri tanımlamanıza olanak tanır. İşlem mantığını kendiniz yazarsınız ve ONNX Runtime'a bunu nasıl çalıştıracağını söylersiniz. Bu, ONNX'in yerleşik yeteneklerinin ötesine geçmesini sağlar.

Özel operatörlere ne zaman ihtiyaç duyarsınız? ONNX'in henüz desteklemediği en yeni araştırmaları kullanıyorsanız. Ya da alanınıza özgü tescilli işlemler oluşturduysanız. Ya da standart işlemlerin sağlayamayacağı donanım‑özel optimizasyonlara ihtiyaç duyduğunuzda.

Ancak işin püf noktası şu ki — özel operatörler taşınabilirliği bozar. Modeliniz, özel operatör uygulamanız olmayan sistemlerde çalışmaz. Özel işlemler içeren bir PyTorch modelini ONNX'e dışa aktarırseniz, bu işlemleri ayrıca paketleyip ONNX Runtime ile kaydetmeniz gerekir.

Dağıtım zorlaşır. Her ortamın özel operatör kitaplığınıza ihtiyacı vardır. Uç cihazlar, bulut sunucuları ve tarayıcıların hepsinin aynı uygulamaya ihtiyacı olur. ONNX'in en büyük avantajını kaybedersiniz: bir kez yaz, her yerde çalıştır.

Özel operatörlerin nasıl çalıştığını görmeniz için küçük bir çalışma örneği:

import numpy as np
import onnxruntime as ort
from onnxruntime import InferenceSession, SessionOptions

# Define the custom operation
def custom_square(x):
    return x * x

# Register the custom op with ONNX Runtime
# This tells ONNX Runtime how to execute "CustomSquare" operations
class CustomSquareOp:
    @staticmethod
    def forward(x):
        return np.square(x).astype(np.float32)

# Create a simple ONNX model with a custom op using the helper
from onnx import helper, TensorProto
import onnx

# Create a graph with custom operator
node = helper.make_node(
    "CustomSquare",  # Custom operation name
    ["input"],
    ["output"],
    domain="custom.ops",  # Custom domain
)

graph = helper.make_graph(
    [node],
    "custom_op_model",
    [helper.make_tensor_value_info("input", TensorProto.FLOAT, [1, 10])],
    [helper.make_tensor_value_info("output", TensorProto.FLOAT, [1, 10])],
)

model = helper.make_model(graph)
onnx.save(model, "custom_op_model.onnx")

# To use this model, you'd need to implement the custom op in C++
# and register it with ONNX Runtime - Python-only custom ops aren't supported
print("Custom operator model created - requires C++ implementation to run")

Çoğu ekip mümkün olduğunda özel operatörlerden kaçınır. Önce standart işlemlerin kombinasyonlarını kullanmayı deneyin. Yalnızca standart işlemlerle ifade edemediğinizde veya performans bunu zorunlu kıldığında özellere gidin.

Büyük dil modellerini yönetme

LLM'lerde sorun bellek. 7B parametreli bir model FP32'de 28GB, FP16'da 14GB ve INT8'de 7GB ister. Çoğu tüketici donanımı bunu taşıyamaz. Niceleme gerekir ve çoğu zaman INT4 veya INT3'e kadar saldırgan niceleme gerekir.

LLM'lere yeniyseniz ve daha fazla öğrenmek istiyorsanız, Büyük Dil Modelleri (LLM) Kavramları kursumuz harika bir başlangıçtır.

KV önbellek yönetimi otoregresif üretim için önemlidir. Ürettiğiniz her belirteç önceki tüm belirteçlere referans vermek zorundadır. Önbellek, dizi uzunluğuyla büyür. Uzun konuşmalar belleği hızla tüketir. ONNX Runtime GenAI, belleği yeniden kullanan ve ek yükü azaltan optimize edilmiş KV önbellek işleme içerir.

Çıkarım hızı donanımınıza ve model boyutuna bağlıdır. Daha küçük modeller (3B parametrenin altı) tüketici GPU'larında iyi çalışır. Daha büyük modeller çoklu GPU veya özel çıkarım hızlandırıcıları gerektirir. ONNX Runtime, yürütme sağlayıcıları aracılığıyla çoklu GPU çıkarımı destekler, ancak modeli cihazlar arasında manuel olarak bölmeniz gerekir.

Flash Attention, dönüştürücülerdeki dikkat mekanizmasını hızlandırır. Standart dikkat, dizi uzunluğunda O(n²)'dir — hızla yavaşlar. Flash Attention, bellek hareketini azaltır ve sonuçları değiştirmeden hızı artırır. ONNX Runtime, desteklenen donanımlar için Flash Attention optimizasyonlarını içerir.

ONNX Runtime ile LLM eğitimi mümkündür ancak nadirdir. Çoğu ekip PyTorch veya JAX ile eğitir, sonra yalnızca çıkarım için ONNX'e dışa aktarır. ONNX Runtime Training, ince ayar ve devam eden ön eğitim için vardır, ancak PyTorch eğitim ekosistemi daha olgundur.

Üretken yapay zekâ iş yükleri ONNX Runtime'da özel muamele görür. GenAI uzantıları, metin üretimi, çağrılar arasında durumu koruma ve ışın araması veya örnekleme stratejilerini yönetme için üst düzey API'ler sağlar. Bu, üretim mantığını kendiniz uygulama zahmetinden kurtarır.

LLM ortamı hızla değişiyor ve ONNX Runtime güncellemeleri de yetişmeye çalışıyor. Operatör seti ve optimizasyonlar düzenli olarak güncellenir, ancak araştırma ile üretime hazır destek arasında her zaman bir gecikme vardır.

Sonuç

Artık modelleri herhangi bir çatıdan nasıl dönüştüreceğinizi, üretim için nasıl optimize edeceğinizi ve her yere nasıl dağıtacağınızı biliyorsunuz.

ONNX, eğitim ve dağıtım arasındaki sürtünmeyi ortadan kaldırır. Araştırma için harika olduğu için PyTorch ile eğitin. Hızlı ve her yerde çalıştığı için ONNX Runtime ile dağıtın. INT8'e niceleyin ve çıkarım maliyetinizi yarıya indirin. Kodu değiştirmeden CPU'dan GPU'ya geçin. Tedarikçi bağımlılığı olmadan bulut sağlayıcıları arasında modelleri taşıyın.

Bunu mümkün kılan ONNX'tir.

Ekosistem gelişmeye devam ediyor. Üretken yapay zekâ desteği her sürümde daha iyi hâle geliyor — daha hızlı LLM çıkarımı, daha iyi bellek yönetimi ve yeni optimizasyon teknikleri. Donanım desteği daha fazla hızlandırıcı ve uç cihaza genişliyor. Topluluk, ONNX'i daha kolay kullanılabilir kılan araçlar inşa ediyor. GitHub depoları üzerinden yeni özellikleri test ederek, sorun bildirerek veya kod katkısı yaparak siz de katılabilirsiniz.

Bir sonraki seviyeye hazır mısınız? Modelleri artık kara kutu olarak görmeyi bırakmak için Açıklanabilir Yapay Zekâ (XAI) Kavramları üzerinde ustalaşın.

Dario Radečić

Yazar

Dario Radečić

Hırvatistan merkezli Kıdemli Veri Bilimci. 700’ün üzerinde yayımlanmış makaleyle 10 M+ görüntüleme elde eden, önde gelen bir teknoloji yazarı. TPOT ile Makine Öğrenimi Otomasyonu kitabının yazarı.

SSS

ONNX nedir ve neden kullanmalıyım?

ONNX (Open Neural Network Exchange), farklı çatılar arasında çalışan makine öğrenimi modelleri için evrensel bir formattır. Bir modeli PyTorch veya TensorFlow ile eğitip kodu yeniden yazmadan her yerde dağıtmanıza olanak tanır. Çatı bağımsızlığı, optimizasyonlar yoluyla daha iyi performans ve uç cihazlardan bulut sunucularına kadar her donanımda model çalıştırma olanağı elde edersiniz.

ONNX model performansını nasıl iyileştirir?

ONNX Runtime, düğüm füzyonu ve sabit katlama gibi grafik optimizasyonları uygulayarak çıkarımı hızlandırır. Niceleme, ağırlıkları 32 bit kayan noktadan 8 bit tamsayıya dönüştürerek model boyutunu %75'e kadar azaltır ve çıkarımı 2–4 kat hızlandırır. Bu optimizasyonlar otomatik çalışır ve modelinizi elle ayarlamanızı gerektirmez.

ONNX mobil cihazlarda ve tarayıcılarda çalışabilir mi?

Evet. ONNX Runtime Mobile, pil ömrü ve bellek kullanımı için optimizasyonlarla iOS ve Android cihazlarda çalışır. ONNX Runtime Web, WebAssembly ve WebGL kullanarak modelleri doğrudan tarayıcılarda çalıştırır; böylece istemci tarafında, verileri sunuculara göndermeden çıkarım yapabilirsiniz. Her iki seçenek de Apple cihazları için CoreML ve Android için NNAPI gibi yürütme sağlayıcıları aracılığıyla donanım hızlandırmayı destekler.

Dinamik ve statik niceleme arasındaki fark nedir?

Dinamik niceleme ağırlıkları daha düşük duyarlılığa dönüştürür ancak aktivasyonları tam duyarlılıkta tutar ve kalibrasyon verisi gerektirmez. Statik niceleme hem ağırlıkları hem de aktivasyonları daha düşük duyarlılığa dönüştürür; daha hızlıdır ancak aktivasyon aralıklarını ölçmek için temsil edici kalibrasyon verisi gerektirir. Statik niceleme daha iyi performans sağlar ancak daha fazla kurulum gerektirir.

Modelleri ONNX'e dönüştürürken özel işlemlerle nasıl başa çıkarım?

Özel işlemler için ONNX Runtime ile kaydedilmiş C++ uygulamaları gerekir — yalnızca Python ile yazılmış özel işlemler üretim için desteklenmez. Özel operatörü C++ ile uygulamalı, paylaşımlı bir kütüphane olarak derlemeli ve dağıtım yaptığınız her ortamda ONNX Runtime ile kaydetmelisiniz. Çoğu ekip mümkün olduğunda özel operatörlerden kaçınır ve bunun yerine standart ONNX işlemlerinin kombinasyonlarını kullanır; çünkü özel işlemler farklı platformlar arasında taşınabilirliği bozar.

Konular

İlgili