Belajar YOLO - Export Model (ONNX, TensorRT, CoreML, OpenVINO)

#Pendahuluan

Model best.pt kalian bekerja sempurna — tapi hanya di mesin dengan Python dan PyTorch penuh (ratusan MB dependency). Dunia produksi tidak begitu baik: app iOS tidak menjalankan PyTorch, Jetson di lapangan tidak boleh bergantung pip, dan server CPU murah jauh lebih umum daripada GPU mahal.

Jawabannya export: menerjemahkan graf model ke format runtime spesifik yang lebih cepat, lebih ringan, dan bebas dependency Python. Ultralytics mendukung 20+ format dengan satu perintah. Episode ini memandu format mana untuk platform mana, dan cara memastikan hasil export tetap identik dengan asalnya.

#Peta Format Export

Cara pandang yang tepat: ONNX adalah bahasa perantara, sisanya format akhir per-platform. Bahkan beberapa jalur (seperti OpenVINO/TensorRT modern) melalui representasi ONNX di tengah jalan.

#Praktik: Export Dasar

Satu perintah, format apa pun:

CLIexport_api.py

yolo export model=best.pt format=onnx imgsz=640
yolo export model=best.pt format=openvino imgsz=640

from ultralytics import YOLO
 
model = YOLO("runs/detect/train/weights/best.pt")
path = model.export(format="onnx", imgsz=640, dynamic=False, simplify=True)
print("Hasil export:", path) # best.onnx

Parameter penting yang sering dilupakan konsekuensinya:

• imgsz — ukuran input dikunci saat export. Model ONNX statis menerima persis resolusi ini selamanya; inference nanti wajib konsisten.
• half=True — presisi FP16; lebih cepat & hemat memori di hardware pendukung (bahasan penuh episode 21).
• dynamic=True — izinkan batch/resolusi fleksibel; praktis tapi sedikit mengorbankan optimasi.
• device — untuk TensorRT, engine dibangun di GPU tempat export dijalankan.

#Catatan Kritis TensorRT: Engine Tidak Portable

Ini jebakan nomor satu pemula deployment NVIDIA: file .engine dikompilasi khusus untuk arsitektur GPU spesifik. Engine yang dibangun di RTX 3090 tidak bisa dimuat di Jetson Orin — bahkan antar generasi GPU desktop sekalipun sering gagal.

Alurnya yang benar:

1. Transfer best.pt ke device target (Jetson/server GPU)
2. Jalankan yolo export format=engine DI DEVICE ITU
3. Simpan engine hasil build device tsb
4. Ulangi langkah 1-3 untuk tiap jenis device berbeda

Anggap .pt seperti source code dan .engine seperti binary hasil compile — kalian tidak menjalankan binary macOS di Linux, sama prinsipnya.

#Verifikasi: Hasil Export Harus Identik

Export tanpa verifikasi adalah bom waktu. Selalu bandingkan output model asli vs hasil export pada input yang sama:

from ultralytics import YOLO
 
IMG = "samples/street.jpg"
 
pt = YOLO("best.pt")(IMG, verbose=False)[0]
onnx = YOLO("best.onnx")(IMG, verbose=False)[0]
 
def ringkas(r):
    return sorted((int(b.cls.item()), round(float(b.conf.item()), 3))
                  for b in r.boxes)
 
print("PT  :", ringkas(pt))
print("ONNX:", ringkas(onnx))
assert ringkas(pt) == ringkas(onnx), "HASIL BERBEDA!"
print("OK: hasil identik")

Selisih confidence desimal kecil (±0.001–0.01) masih normal karena perbedaan aritmetika presisi. Yang fatal: jumlah box beda, class beda, atau box hilang — biasanya penyebabnya imgsz mismatch atau normalisasi input.

#Inference Setelah Export

Keindahan ekosistem Ultralytics: API-nya tidak berubah. Ganti nama file, sisanya sama:

from ultralytics import YOLO
 
# tanpa PyTorch penuh — cukup onnxruntime sebagai backend
model = YOLO("best.onnx") # butuh: pip install onnxruntime (atau onnxruntime-gpu)
results = model.predict(source="samples/street.jpg", conf=0.25)

Untuk aplikasi non-Python (C++, Rust, mobile native), gunakan runtime langsung: ONNX Runtime C++ API, TensorFlow Lite interpreter Android, atau CoreML framework Swift — struktur output-nya mengikuti format head YOLO (box + class + score) yang sudah kita kenal sejak episode 4.

#Checklist Pra-Rilis Export

[x] Export dijalankan di device/arsitektur target (khusus TensorRT)
[x] imgsz & batch konsisten dengan rencana serving
[x] Verifikasi identitas PT vs hasil export lolos assert
[x] Benchmark latency di device target (bukan laptop dev)
[x] Artefak .pt + hasil export + bukti verifikasi tersimpan versioned
[x] Ukuran file & dependency runtime dicatat untuk release notes

#Penutup

Rangkuman episode ini:

• Export menerjemahkan PyTorch ke format runtime per-platform: ONNX universal, TensorRT NVIDIA, CoreML Apple, OpenVINO Intel, TFLite mobile.
• ONNX adalah perantara de facto; imgsz terkunci saat export dan harus konsisten selamanya.
• TensorRT .engine tidak portable antar GPU — build di device target, selalu.
• Verifikasi identitas PT vs exported adalah langkah wajib, bukan opsional.
• API inference Ultralytics tetap sama — cukup ganti path model.

Di episode 19 kita turun ke medan tempur sesungguhnya: edge deployment — Jetson dengan studi kasus speedup TensorRT, OpenVINO di CPU, dan mobile — plus alasan strategis kenapa inferensi di device sering mengalahkan cloud. Sampai jumpa!