ONNX: Latih di Kerangka Apa Pun, Deploy di Perangkat Keras Apa Pun

Jadi Anda telah melatih model di PyTorch, tetapi sistem produksi Anda menjalankan TensorFlow. Apakah Anda perlu menulis ulang semuanya dari nol?

Tidak, Anda tidak perlu.

Interoperabilitas model dapat menjadi sakit kepala bagi engineer machine learning. Setiap kerangka kerja menggunakan format berbeda, dan konversi antarformat dapat merusak model Anda atau menimbulkan perilaku tak terduga. Anda tidak menginginkan itu, dan Anda juga tidak ingin memelihara banyak versi dari model yang sama.

ONNX (Open Neural Network Exchange) menyelesaikan masalah ini dengan menyediakan format universal untuk model machine learning. Ia memungkinkan Anda melatih di satu kerangka kerja dan melakukan deploy di kerangka lain tanpa menulis ulang kode atau berurusan dengan bug.

Dalam artikel ini, saya akan menunjukkan cara mengonversi model ke format ONNX, menjalankan inferensi dengan ONNX Runtime, mengoptimalkan model untuk produksi, dan melakukan deploy di berbagai platform, dari perangkat edge hingga server cloud.

Memulai dengan ONNX

Anda tidak bisa menggunakan ONNX tanpa menyiapkan lingkungan pengembangan terlebih dahulu.

Di bagian ini, saya akan memandu Anda melalui semua yang diperlukan—dari persyaratan perangkat lunak hingga membuat ruang kerja yang bersih dan dapat direproduksi. Saya akan menunjukkan cara memasang ONNX dan ONNX Runtime di Windows, Linux, dan macOS.

Prasyarat

ONNX berfungsi di semua sistem operasi utama.

Anda memerlukan Python 3.8 atau lebih tinggi yang terpasang di mesin Anda. Itu saja untuk dasar-dasarnya. ONNX mendukung ABI3 (Application Binary Interface) Python, yang berarti Anda dapat menggunakan paket biner prabangun tanpa perlu kompilasi dari sumber.

Berikut yang akan Anda pasang:

• uv (ambil dari astral.sh/uv)

• Python 3.8+ (uv menanganinya untuk Anda)

• pip (terikut dalam uv)

Jika Anda ingin mempelajari lebih lanjut cara kerja uv dan mengapa ini seharusnya menjadi pilihan utama Anda, baca panduan kami tentang manajer paket Python tercepat.

Untuk pengguna Windows, Anda dapat memasang uv menggunakan PowerShell:

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

Jika Anda mendapat error execution policy, jalankan PowerShell sebagai administrator terlebih dahulu.

Pengguna Linux dapat memasang uv dengan perintah shell ini:

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

Ini berfungsi di distribusi Linux apa pun.

Terakhir, pengguna macOS dapat memasang uv menggunakan Homebrew, atau dengan perintah curl:

brew install uv

# or

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

Menyiapkan environment

Berikut cara menyiapkan proyek dengan uv:

mkdir onnx-project
cd onnx-project

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

uv membuat direktori .venv dan berkas pyproject.toml. Virtual environment diaktifkan secara otomatis saat Anda menjalankan perintah melalui uv.

Sekarang pasang ONNX dan ONNX Runtime:

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__)"Didukung oleh

Perintah verifikasi akan menampilkan nomor versi:

Dependensi Anda sudah terpaku. uv secara otomatis menuliskan semua versi paket ke uv.lock. Ini membuat build Anda dapat direproduksi—siapa pun dapat menciptakan ulang environment persis Anda dengan menjalankan uv sync.

Beginilah tampilan pyproject.toml Anda:

[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",
]Didukung oleh

Dan selesai, environment sudah dikonfigurasi! Mari lanjut ke dasar-dasarnya.

Memahami Dasar-dasar ONNX

Anda perlu memahami cara kerja ONNX sebelum mulai mengonversi model.

Di bagian ini, saya akan menguraikan format ONNX dan menjelaskan arsitektur berbasis grafnya. Saya akan menunjukkan isi berkas ONNX dan bagaimana aliran data di dalamnya.

Format model ONNX

Model ONNX adalah berkas yang berisi struktur dan bobot jaringan saraf Anda.

Anggap saja sebagai cetak biru. Berkas ini menjelaskan operasi apa yang dilakukan, dalam urutan apa, dan dengan parameter apa. Bobot terlatih disimpan bersama cetak biru ini, jadi model siap dijalankan tanpa berkas tambahan.

ONNX diluncurkan pada 2017 sebagai kolaborasi antara Microsoft dan Facebook (kini Meta). Tujuannya sederhana—berhenti menulis ulang model setiap kali Anda berpindah kerangka kerja. PyTorch, TensorFlow, dan kerangka lainnya terus berkembang, tetapi model tidak bisa berpindah antarplatform tanpa konversi manual.

ONNX mengubah itu. Versi 1.0 mendukung operasi dasar untuk visi komputer dan jaringan saraf sederhana. ONNX saat ini mendukung transformer, model bahasa besar, dan arsitektur kompleks yang belum ada pada 2017.

ONNX menggunakan Protocol Buffers (protobuf) untuk melakukan serialisasi data ini. Protobuf adalah format biner yang dikembangkan Google untuk penyimpanan dan transmisi data yang efisien. Membaca dan menulisnya jauh lebih cepat dibanding JSON atau XML, dan ukuran berkasnya lebih kecil. Saling menguntungkan.

Berikut isi dalam sebuah model ONNX:

• Graf: Arsitektur jaringan
• Bobot: Parameter model terlatih
• Metadata: Info versi, nama pembuat, dan dokumentasi model
• Versi opset: Operasi apa saja yang tersedia

Versi opset penting. ONNX berkembang seiring waktu, dan terus menambahkan operasi baru serta meningkatkan yang sudah ada. Berkas model Anda menentukan versi opset yang digunakan, sehingga runtime tahu cara mengeksekusinya.

Konsep kunci dan arsitektur

ONNX merepresentasikan model Anda sebagai graf komputasional.

Graf memiliki simpul (node) dan sisi (edge). Node adalah operasi (seperti perkalian matriks atau fungsi aktivasi), dan edge adalah tensor (data Anda) yang mengalir di antara operasi tersebut. Inilah cara ONNX mendeskripsikan "kalikan matriks ini, lalu terapkan ReLU, lalu kalikan lagi."

Berikut contoh sederhana:

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")Didukung oleh

Setiap node melakukan satu operasi. Jenis operasi (seperti Relu, Conv, atau MatMul) berasal dari himpunan operator ONNX. Anda tidak bisa sembarang membuat nama operasi—namanya harus ada dalam versi opset yang Anda gunakan.

Edge menghubungkan node dan membawa tensor. Tensor memiliki bentuk (shape) dan tipe data. Saat Anda mendefinisikan [1, 3, 224, 224], Anda mengatakan "tensor ini memiliki 4 dimensi dengan ukuran tersebut." Runtime menggunakan informasi ini untuk mengalokasikan memori dan memvalidasi graf.

Graf mengalir satu arah. Data masuk melalui node input, melewati operasi, dan keluar melalui node output. Tidak ada siklus—ONNX tidak mendukung koneksi rekuren secara langsung. Anda perlu melakukan unroll loop atau menggunakan operasi khusus untuk sekuens.

Struktur graf ini memungkinkan interoperabilitas kerangka kerja. PyTorch berpikir dalam eksekusi eager, TensorFlow menggunakan graf statis, dan scikit-learn memiliki abstraksi yang sama sekali berbeda. Namun semuanya bisa mengekspor ke format graf yang sama.

Graf juga memungkinkan optimasi bersama. Optimizer ONNX dapat melakukan fusi operasi (menggabungkan beberapa node menjadi satu), menghapus kode mati (menghapus node yang tidak terpakai), atau mengganti operasi lambat dengan yang lebih cepat. Optimasi ini bekerja terlepas dari kerangka kerja yang membuat model.

Berikutnya, saya akan menunjukkan seluk-beluk mengonversi model ke format ONNX.

Mengonversi Model ke Format ONNX

Di bagian ini, saya akan menunjukkan cara mengekspor model dari PyTorch, TensorFlow, dan scikit-learn. Saya akan memandu proses konversi dan menunjukkan cara memvalidasi bahwa model Anda berfungsi dengan benar setelah konversi.

Dukungan kerangka kerja dan alat

ONNX mendukung kerangka kerja machine learning paling populer.

PyTorch memiliki ekspor ONNX bawaan melalui torch.onnx.export(). Ini adalah konverter yang paling matang karena PyTorch dan ONNX sama-sama dikelola oleh Meta.

TensorFlow menggunakan tf2onnx untuk konversi. Ini adalah pustaka terpisah yang mengonversi graf TensorFlow ke format ONNX. Instal dengan uv add tf2onnx, dan Anda siap.

scikit-learn melakukan konversi melalui skl2onnx. Pustaka ini menangani model machine learning tradisional seperti random forest, regresi linear, dan SVM. Kerangka deep learning mendapat lebih banyak perhatian, tetapi model scikit-learn juga berfungsi dengan baik.

Tiga ini yang paling populer, tetapi Anda dapat menggunakan kerangka lain yang didukung—cukup pasang dependensinya melalui uv add <name>:

• Keras: Gunakan tf2onnx (Keras adalah bagian dari TensorFlow)

• XGBoost: Gunakan onnxmltools

• LightGBM: Gunakan onnxmltools

• MATLAB: Ekspor ONNX bawaan

• Paddle: Gunakan paddle2onnx

Setiap kerangka memiliki konverternya sendiri karena mereka merepresentasikan model secara berbeda. PyTorch menggunakan graf komputasi dinamis, TensorFlow menggunakan graf statis, dan scikit-learn bahkan tidak menggunakan graf. Konverter menerjemahkan representasi ini ke format graf ONNX.

Anda juga dapat menggunakan model yang dilatih orang lain. ONNX Model Zoo menampung model pralatih yang siap digunakan. Anda akan menemukan model visi komputer (ResNet, YOLO, EfficientNet), model NLP (BERT, GPT-2), dan banyak lagi. Unduh dari repositori GitHub resmi.

Hugging Face juga menampung model ONNX. Cari model dengan "onnx" di namanya atau saring berdasarkan format ONNX. Banyak model transformer populer tersedia dalam format ONNX yang sudah dioptimalkan untuk inferensi.

Sebelum melanjutkan, jalankan perintah ini untuk mengambil semua pustaka yang diperlukan dengan uv:

uv add torch torchvision tensorflow tf2onnx scikit-learn skl2onnx onnxscriptDidukung oleh

Proses konversi langkah demi langkah

Berikut cara mengonversi model PyTorch ke ONNX:

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
)Didukung oleh

Baru di PyTorch? Jangan biarkan itu menahan Anda. Kursus Deep Learning with PyTorch kami membahas dasar-dasarnya dalam hitungan jam.

Dummy input penting. ONNX perlu mengetahui bentuk input untuk membangun graf. Jika model Anda menerima sekuens berdurasi variabel atau ukuran batch yang berbeda, gunakan dynamic_shapes untuk menandai dimensi tersebut sebagai dinamis.

Selalu setel model ke mode evaluasi dengan model.eval() sebelum ekspor. Ini menonaktifkan perilaku pelatihan pada dropout dan batch normalization. Jika Anda melewatkan langkah ini, model yang dikonversi tidak akan cocok dengan aslinya.

Bentuk dinamis bisa menimbulkan masalah. Jika konverter mengeluh tentang dimensi yang tidak diketahui, pastikan Anda menentukan dynamic_shapes dengan benar atau sediakan bentuk konkret.

Sekarang beralih ke TensorFlow, berikut kode alternatif yang dapat Anda jalankan:

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"
)Didukung oleh

Jika Anda belum pernah bekerja dengan TensorFlow, kami menyarankan Anda mengikuti kursus Introduction to TensorFlow in Python.

Sayangnya, ada sedikit konflik dengan versi Numpy terbaru, jadi saya menambahkan perbaikan sementara. Saat Anda membaca ini, semoga Anda bisa menjalankan cuplikan tanpa enam baris pertama.

Terakhir, berikut konversi ONNX untuk model scikit-learn:

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())Didukung oleh

Sama seperti TensorFlow, DataCamp juga memiliki kursus Supervised Learning with scikit-learn gratis—cek jika cuplikan di atas terasa membingungkan.

Dan itu saja!

Sekarang Anda dapat menjalankan cuplikan ini untuk memvalidasi model yang dikonversi:

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!")Didukung oleh

Jalankan validasi ini setiap kali Anda mengonversi model. Perbedaan numerik kecil adalah hal yang normal (aritmetika floating point tidak eksak), tetapi perbedaan besar berarti ada yang salah saat konversi.

Sebagai penutup bagian ini, berikut dua hal penting yang harus Anda ketahui:

• Operasi kustom tidak akan terkonversi: Jika Anda menulis operasi PyTorch kustom atau layer TensorFlow kustom, konverter tidak tahu cara menerjemahkannya. Anda harus menulis ulang menggunakan operasi standar atau mendaftarkan operator ONNX kustom.
• Ketidaksesuaian versi merusak segalanya: Versi kerangka kerja, versi konverter, dan versi ONNX harus kompatibel. Periksa dokumentasi konverter untuk kombinasi versi yang didukung.

Berikutnya, mari bahas ONNX Runtime.

Menjalankan Inferensi dengan ONNX Runtime

Di bagian ini, saya akan menunjukkan cara menggunakan ONNX Runtime untuk memuat model dan membuat prediksi. Saya akan memandu opsi akselerasi perangkat keras dan menunjukkan di mana ONNX Runtime unggul di produksi.

Pengenalan ONNX Runtime

ONNX Runtime adalah mesin inferensi lintas platform. Microsoft mengembangkannya untuk menjalankan model ONNX dengan cepat di perangkat keras apa pun—CPU, GPU, chip seluler, dan akselerator AI khusus.

Cara kerjanya: Anda memuat model ONNX, dan ONNX Runtime membangun rencana eksekusi. Ia menganalisis graf komputasional, menerapkan optimasi, dan menentukan cara terbaik mengeksekusi operasi di perangkat keras Anda. Lalu ia menjalankan inferensi menggunakan rencana yang telah dioptimalkan.

Arsitekturnya memisahkan logika eksekusi dari kode spesifik perangkat keras. Execution provider menangani antarmuka perangkat keras. Ingin berjalan di GPU NVIDIA? Gunakan CUDA execution provider. Ingin Apple Silicon? Kode dasar Anda tetap sama.

ONNX Runtime memiliki execution provider berikut:

• CPUExecutionProvider: Provider default, bekerja di mana saja

• CUDAExecutionProvider: GPU NVIDIA dengan CUDA

• TensorRTExecutionProvider: GPU NVIDIA dengan optimasi TensorRT

• CoreMLExecutionProvider: Perangkat Apple (macOS, iOS)

• DmlExecutionProvider: DirectML untuk Windows (bekerja dengan GPU apa pun)

• OpenVINOExecutionProvider: CPU dan GPU Intel

• ROCMExecutionProvider: GPU AMD

Setiap provider menerjemahkan operasi ONNX menjadi instruksi spesifik perangkat keras. Provider CPU menggunakan operasi CPU standar. Provider CUDA menggunakan cuDNN dan cuBLAS. Provider TensorRT mengompilasi model Anda menjadi kernel GPU yang dioptimalkan, dan seterusnya.

Menyiapkan dan mengeksekusi model

Anda dapat memuat model ONNX dengan tiga baris kode:

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].nameDidukung oleh

InferenceSession melakukan semua pekerjaan berat. Ia memuat model, memvalidasi graf, dan bersiap untuk inferensi. Secara default, ia menggunakan provider eksekusi CPU.

Sekarang jalankan inferensi:

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)Didukung oleh

Metode run() menerima dua argumen. Pertama, daftar nama output (atau None untuk semua output). Kedua, kamus yang memetakan nama input ke array numpy.

Bentuk input harus cocok. Jika model Anda mengharapkan [1, 10] dan Anda memberi [1, 10, 3], inferensi akan gagal.

Jika Anda menginginkan akselerasi GPU, cukup tentukan execution provider saat membuat sesi:

# 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']
)Didukung oleh

Daftarkan provider berdasarkan prioritas. ONNX Runtime mencoba provider pertama, lalu jatuh ke berikutnya jika tidak tersedia. Selalu sertakan CPUExecutionProvider sebagai fallback terakhir.

Anda dapat memeriksa provider mana yang benar-benar digunakan:

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())Didukung oleh

Jika Anda melihat ["CPUExecutionProvider"] saat Anda mengharapkan GPU, berarti provider GPU tidak tersedia. Alasan umum bisa berupa driver yang hilang, paket ONNX Runtime yang salah, atau GPU yang tidak kompatibel.

Konfigurasi tidak berhenti di sini. Anda dapat mengoptimalkan execution provider lebih lanjut untuk kinerja yang lebih baik:

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)Didukung oleh

Lihat dokumentasi resmi ONNX Runtime untuk daftar semua opsi yang tersedia bagi provider pilihan Anda.

Aplikasi ONNX Runtime

Hal yang mengesankan dari ONNX Runtime adalah bisa berjalan di mana saja—server, peramban, dan perangkat seluler.

ONNX Runtime Web menghadirkan inferensi ke peramban menggunakan WebAssembly dan WebGL. Model Anda berjalan di sisi klien tanpa mengirim data ke server. Ini sangat cocok untuk aplikasi yang sensitif terhadap privasi seperti analisis citra medis atau pemrosesan dokumen.

Berikut contoh sederhana cara menggunakan ONNX Runtime dalam berkas HTML sederhana:

<!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>Didukung oleh

Untuk deploy di perangkat seluler, Anda dapat menggunakan ONNX Runtime Mobile—versi ringan yang dioptimalkan untuk iOS dan Android. Ia menghapus fitur server yang tidak diperlukan dan mengurangi ukuran biner.

Ini contoh konfigurasi iOS:

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])Didukung oleh

Atau, jika Anda menggunakan Python untuk membangun REST API, Anda dapat menyertakan ONNX Runtime ke salah satu endpoint dengan pendekatan berikut:

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()}Didukung oleh

Dan itu saja! Lingkungan lainnya akan menggunakan pendekatan serupa, tetapi intinya—ONNX Runtime mudah digunakan. Berikutnya, mari bahas optimasi.

Mengoptimalkan Model ONNX

Di bagian ini, saya akan mendemonstrasikan cara membuat model ONNX lebih cepat dan lebih kecil melalui kuantisasi dan optimasi graf. Saya akan memandu teknik yang paling penting untuk deployment dunia nyata.

Teknik kuantisasi

Kuantisasi mengurangi presisi model Anda agar lebih cepat dan lebih kecil.

Alih-alih menyimpan bobot sebagai float 32-bit, Anda menyimpannya sebagai integer 8-bit. Ini memangkas penggunaan memori sebesar 75% dan mempercepat inferensi karena operasi integer lebih cepat daripada floating point di sebagian besar perangkat keras.

Kuantisasi dinamis mengonversi bobot ke presisi lebih rendah tetapi mempertahankan aktivasi (nilai perantara selama inferensi) dalam presisi penuh. Ini adalah metode kuantisasi termudah karena Anda tidak memerlukan data kalibrasi.

Berikut cara menerapkan kuantisasi dinamis:

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
)Didukung oleh

Itu saja. Model yang dikuantisasi sekarang menggunakan integer tak bertanda 8-bit dan siap digunakan.

Kuantisasi statis mengonversi bobot dan aktivasi ke presisi lebih rendah. Ini lebih agresif dan lebih cepat daripada kuantisasi dinamis, tetapi Anda memerlukan data kalibrasi yang representatif untuk mengukur rentang aktivasi.

Berikut strategi umum menerapkan kuantisasi statis:

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
)Didukung oleh

Data kalibrasi harus mewakili beban kerja inferensi Anda yang sebenarnya, jadi jangan gunakan data acak seperti yang saya tunjukkan di atas. Gunakan sampel nyata dari dataset Anda.

Secara umum, kuantisasi memiliki beberapa manfaat dan trade-off yang perlu Anda ketahui sebagai engineer machine learning. Berikut manfaatnya:

• Model 4x lebih kecil: INT8 menggunakan seperempat memori FP32
• Inferensi 2-4x lebih cepat: Operasi integer berjalan lebih cepat di CPU
• Konsumsi daya lebih rendah: Lebih sedikit komputasi berarti lebih sedikit energi
• Pemanfaatan cache lebih baik: Model yang lebih kecil muat di cache CPU

Dan berikut trade-off-nya:

• Penurunan akurasi kecil: Biasanya 1–2% untuk INT8, dapat diterima untuk sebagian besar aplikasi
• Tidak semua operasi cocok dikuantisasi: Batch normalization dan softmax lebih rumit
• Ketergantungan perangkat keras: Percepatan GPU bervariasi, beberapa GPU tidak mempercepat INT8

Kuantisasi juga sangat berguna untuk model bahasa besar dan AI generatif. Model 7B parameter dalam FP32 membutuhkan 28GB memori. Jika dikuantisasi ke INT8, turun menjadi 7GB. Jika ke INT4, menjadi 3,5GB—cukup kecil untuk dijalankan di perangkat konsumen.

Optimasi graf

Optimasi graf menulis ulang graf komputasional model Anda agar lebih cepat.

Konsep fusi node menggabungkan beberapa operasi menjadi satu operasi. Jika model Anda memiliki layer Conv diikuti BatchNorm lalu ReLU, optimizer akan menggabungkannya menjadi satu node ConvBnRelu. Ini mengurangi lalu lintas memori dan mempercepat eksekusi.

Beginilah tampilan graf sebelum fusi:

Input -> Conv -> BatchNorm -> ReLU -> OutputDidukung oleh

Graf disederhanakan setelah fusi:

Input -> ConvBnRelu -> OutputDidukung oleh

Ada dua konsep lagi yang perlu Anda ketahui terkait optimasi graf:

• Constant folding menghitung di muka operasi yang tidak bergantung pada data input. Jika model Anda mengalikan matriks bobot dengan konstanta, optimizer melakukan perkalian itu sekali saat optimasi, bukan setiap kali inferensi.
• Dead code elimination menghapus operasi yang tidak digunakan. Jika model Anda memiliki cabang yang tidak pernah dieksekusi atau output yang tidak pernah digunakan, optimizer akan memotongnya.

Berikut cara mengaktifkan optimasi graf di ONNX Runtime:

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"]
)Didukung oleh

ONNX Runtime memiliki level optimasi berikut:

• ORT_DISABLE_ALL: Tanpa optimasi (berguna untuk debug)

• ORT_ENABLE_BASIC: Optimasi aman yang tidak mengubah hasil numerik

• ORT_ENABLE_EXTENDED: Optimasi agresif yang mungkin memiliki perbedaan numerik kecil

• ORT_ENABLE_ALL: Semua optimasi, termasuk transformasi layout

Gunakan ORT_ENABLE_ALL untuk produksi. Peningkatan kecepatannya sepadan dengan perbedaan numerik yang sangat kecil.

Anda dapat menjalankan cuplikan ini untuk menyimpan model yang telah dioptimalkan agar dapat digunakan kembali:

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)Didukung oleh

Optimasi graf bekerja terlepas dari kerangka kerja yang membuat model Anda. Pola Conv-BN-ReLU dari PyTorch dan TensorFlow sama-sama akan difusi dengan cara yang sama. Inilah manfaat optimasi bersama—Anda menulis optimasi sekali, dan menerapkannya ke model dari kerangka apa pun.

Berikutnya, mari bahas deployment.

Skenario Deployment

Di bagian ini, saya akan membahas tiga skenario deployment—perangkat edge, infrastruktur cloud, dan peramban web. Saya akan menunjukkan tantangan dan solusinya untuk setiap lingkungan.

Deployment perangkat edge

Tantangan utama perangkat edge adalah sumber daya yang terbatas.

Ponsel cerdas Anda memiliki RAM 4–16GB. Raspberry Pi bahkan lebih sedikit. Perangkat IoT mungkin hanya memiliki 512MB atau kurang. Anda tidak bisa begitu saja melempar model 7B parameter ke perangkat ini dan berharap bekerja.

Mulailah dengan kuantisasi. Model INT8 seharusnya menjadi baseline Anda. Turun ke INT4 jika Anda bisa menoleransi penurunan akurasi. Ini membuat model cukup kecil untuk muat di memori.

Untuk deployment di perangkat edge, ONNX Runtime Mobile adalah teman Anda. Ia menghapus fitur server yang tidak Anda perlukan dan dioptimalkan untuk konsumsi daya. Biner lebih kecil, waktu mulai lebih cepat, dan konsumsi daya lebih rendah.

Berikut cara menambahkannya ke proyek aplikasi seluler Anda:

# iOS
pod 'onnxruntime-mobile-objc'

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

Execution provider menangani perbedaan perangkat keras. Perangkat Android menggunakan CPU ARM, beberapa memiliki GPU dari vendor berbeda, dan ponsel terbaru memiliki NPU (Neural Processing Unit). Anda tidak ingin menulis kode untuk setiap chip.

Lihat cuplikan ini untuk memilih execution provider yang tepat:

# 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"]
)Didukung oleh

CoreML di iOS menggunakan Neural Engine (NPU milik Apple). NNAPI di Android menggunakan akselerator apa pun yang dimiliki perangkat Anda—GPU, DSP, atau NPU. Provider mengabstraksikan perangkat keras sehingga kode Anda tetap sama. Ketika chip baru hadir dengan kinerja lebih baik, cukup perbarui execution provider, dan aplikasi Anda berjalan lebih cepat tanpa perubahan kode.

Deployment cloud

Deployment di cloud memberi Anda skala tak terbatas dan perangkat keras terbaru.

Anda dapat melakukan deploy model ONNX di platform cloud mana pun—AWS, Azure, GCP, atau server Anda sendiri. Polanya sama—kontainerisasi layanan inferensi Anda dan deploy di belakang load balancer.

Berikut contoh kecil Python FastAPI:

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}Didukung oleh

Contoh FastAPI ini, meski kecil, tidak selalu mudah dipahami bagi engineer machine learning. Anda dapat menguasai dasarnya dengan kursus Introduction to FastAPI kami yang gratis.

Anda kemudian dapat mengontainerkannya dengan Docker:

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"]Didukung oleh

Setiap penggiat machine learning harus mengetahui dasar-dasar Docker. Ikuti kursus Introduction to Docker kami untuk akhirnya mempelajari cara melakukan deploy model machine learning.

Anda akan mendapatkan aplikasi yang berjalan di port 8000, di mana Anda bisa membuka dokumentasinya langsung dan mencoba endpoint prediksi:

Jika Anda menggunakan Azure Machine Learning, Anda akan senang mengetahui bahwa layanan ini terintegrasi langsung dengan ONNX. Anda dapat melakukan deploy model Anda dalam tiga langkah:

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,
)Didukung oleh

Azure menangani penskalaan, pemantauan, dan pembaruan. Anda mendapatkan pencatatan otomatis, pelacakan permintaan, dan pemeriksaan kesehatan.

Jika Anda baru di Azure Machine Learning, bacalah Panduan Pemula kami untuk cepat mempelajari dasarnya.

Jika kita berbicara tentang workflow MLOps, Anda memerlukan komponen ini:

• Kontrol versi: Lacak versi model dengan DVC atau MLflow
• CI/CD: Otomatiskan pengujian dan deployment dengan GitHub Actions atau Azure Pipelines
• Pemantauan: Lacak latensi inferensi, throughput, dan tingkat error
• A/B testing: Bandingkan versi model di produksi
• Rollback: Kembali ke versi sebelumnya saat terjadi masalah

Berikut cuplikan contoh yang dapat Anda gunakan:

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()}Didukung oleh

Dari sana, Anda dapat melakukan penskalaan horizontal dengan menjalankan beberapa instance layanan di belakang load balancer. ONNX Runtime bersifat stateless, jadi instance mana pun dapat menangani permintaan apa pun.

Inferensi berbasis peramban

ONNX Runtime Web menjalankan model langsung di peramban menggunakan WebAssembly dan WebGL.

Alih-alih mengirim data ke server, Anda mengirim model ke peramban sekali dan menjalankan inferensi secara lokal. Pengguna mendapatkan respons instan tanpa latensi jaringan.

Untuk memulai, cukup buat berkas HTML yang menggunakan skrip JS inline:

<!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>Didukung oleh

Anda dapat melihat output di konsol segera setelah Anda membuka berkas dengan live server:

Dan terakhir, mari bahas beberapa topik lanjutan.

Topik Lanjutan

Operasi ONNX standar mencakup sebagian besar kasus penggunaan, tetapi jika Anda membutuhkan lebih, bagian ini untuk Anda.

Saya akan membahas operator kustom dan deployment model bahasa besar. Saya akan menjelaskan kapan Anda membutuhkan fitur lanjutan ini dan trade-off yang menyertainya.

Operator kustom

ONNX hadir dengan ratusan operasi, tetapi model Anda mungkin menggunakan sesuatu yang unik.

Operator kustom memungkinkan Anda mendefinisikan operasi yang tidak ada di himpunan operator ONNX standar. Anda menulis sendiri logika operasi dan memberi tahu ONNX Runtime cara mengeksekusinya. Ini memperluas kemampuan ONNX di luar yang bawaan.

Kapan Anda memerlukan operator kustom? Saat Anda menggunakan riset mutakhir yang belum didukung ONNX. Atau saat Anda membangun operasi proprietary khusus domain Anda. Atau ketika Anda butuh optimasi spesifik perangkat keras yang tidak dapat diberikan oleh operasi standar.

Namun ada catatan penting—operator kustom merusak portabilitas. Model Anda tidak akan berjalan di sistem yang tidak memiliki implementasi operator kustom Anda. Jika Anda mengekspor model PyTorch dengan operasi kustom ke ONNX, Anda perlu mengemas operasi tersebut secara terpisah dan mendaftarkannya ke ONNX Runtime.

Deployment menjadi lebih sulit. Setiap lingkungan memerlukan pustaka operator kustom Anda. Perangkat edge, server cloud, dan peramban semuanya perlu implementasi yang sama. Anda kehilangan keunggulan terbesar ONNX: tulis sekali, jalankan di mana saja.

Berikut contoh kecil operator kustom yang berfungsi, agar Anda bisa melihat cara kerjanya:

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")Didukung oleh

Sebagian besar tim menghindari operator kustom jika memungkinkan. Cobalah terlebih dahulu menggunakan kombinasi operasi standar. Hanya gunakan kustom saat operasi standar tidak dapat mengekspresikan operasi Anda atau saat kinerja menuntutnya.

Menangani model bahasa besar

Memori adalah masalah saat berurusan dengan LLM. Model 7B parameter membutuhkan 28GB pada FP32, 14GB pada FP16, dan 7GB pada INT8. Sebagian besar perangkat konsumen tidak bisa menampungnya. Anda memerlukan kuantisasi, dan sering kali kuantisasi agresif ke INT4 atau INT3.

Jika Anda baru dalam LLM dan ingin belajar lebih lanjut, kursus Large Language Models (LLMs) Concepts kami adalah tempat yang tepat untuk memulai.

Manajemen KV cache penting untuk generasi autoregresif. Setiap token yang Anda hasilkan perlu merujuk semua token sebelumnya. Cache tumbuh seiring panjang sekuens. Percakapan panjang cepat memakan memori. ONNX Runtime GenAI menyertakan penanganan KV cache yang dioptimalkan yang menggunakan ulang memori dan mengurangi overhead.

Kecepatan inferensi bergantung pada perangkat keras dan ukuran model Anda. Model yang lebih kecil (di bawah 3B parameter) berjalan baik di GPU konsumen. Model yang lebih besar memerlukan banyak GPU atau akselerator inferensi khusus. ONNX Runtime mendukung inferensi multi-GPU melalui execution provider, tetapi Anda perlu membagi model di antara perangkat secara manual.

Flash Attention mempercepat mekanisme attention pada transformer. Attention standar adalah O(n²) terhadap panjang sekuens—menjadi lambat dengan cepat. Flash Attention mengurangi perpindahan memori dan meningkatkan kecepatan tanpa mengubah hasil. ONNX Runtime menyertakan optimasi Flash Attention untuk perangkat keras yang didukung.

Melatih LLM dengan ONNX Runtime memungkinkan tetapi jarang. Sebagian besar tim melatih dengan PyTorch atau JAX, lalu mengekspor ke ONNX untuk inferensi saja. ONNX Runtime Training ada untuk fine-tuning dan continued pre-training, tetapi ekosistem pelatihan di sekitar PyTorch lebih matang.

Beban kerja AI generatif mendapat perlakuan khusus di ONNX Runtime. Ekstensi GenAI menyediakan API tingkat tinggi untuk generasi teks, mempertahankan state antar panggilan, dan mengelola strategi beam search atau sampling. Ini menyelamatkan Anda dari implementasi logika generasi sendiri.

Lanskap LLM berubah cepat, dan pembaruan ONNX Runtime berusaha mengikuti. Himpunan operator dan optimasi diperbarui secara berkala, tetapi selalu ada jeda antara riset dan dukungan siap produksi.

Kesimpulan

Sekarang Anda tahu cara mengonversi model dari kerangka kerja apa pun, mengoptimalkannya untuk produksi, dan melakukan deploy ke mana saja.

ONNX menghilangkan friksi antara pelatihan dan deployment. Latih di PyTorch karena bagus untuk riset. Deploy dengan ONNX Runtime karena cepat dan berjalan di mana saja. Kuantisasi ke INT8 dan pangkas biaya inferensi Anda hingga setengahnya. Beralih dari CPU ke GPU tanpa mengubah kode. Pindahkan model antar penyedia cloud tanpa terikat vendor.

ONNX yang membuatnya menjadi mungkin.

Ekosistemnya terus membaik. Dukungan AI generatif semakin baik di setiap rilis—inferensi LLM lebih cepat, manajemen memori lebih baik, dan teknik optimasi baru. Dukungan perangkat keras meluas ke lebih banyak akselerator dan perangkat edge. Komunitas membangun alat yang membuat ONNX lebih mudah digunakan. Anda dapat berpartisipasi dengan menguji fitur baru, melaporkan isu, atau berkontribusi kode melalui repositori GitHub.

Siap ke level berikutnya? Kuasai Konsep Explainable Artificial Intelligence (XAI) untuk berhenti menganggap model sebagai kotak hitam.