Jika Anda pernah mencoba mempercepat inferensi AI pada perangkat keras sehari-hari dan merasa terjebak antara proses CPU yang lambat dan kompleksitas GPU, OpenVINO mungkin adalah solusi yang Anda cari. Dibuat oleh Intel, alat ini mengubah model pembelajaran mendalam umum menjadi aplikasi portabel yang cepat dan berjalan pada CPU, GPU terintegrasi, dan bahkan NPU—tanpa Anda harus menulis ulang seluruh tumpukan Anda.
Dalam panduan praktis dan berorientasi solusi ini, Anda akan mempelajari secara tepat cara menggunakan OpenVINO—mulai dari instalasi hingga konversi model, optimasi, dan penerapan. Kami akan membahas alur kerja yang paling umum, berbagi contoh kode, dan menyoroti tips kinerja yang penting.
Apa yang akan Anda pelajari secara singkat:
- Instal OpenVINO dalam hitungan menit dengan pip
- Konversi model (ekspor ONNX/TF/PyTorch) menggunakan Model Optimizer
- Jalankan inferensi dengan OpenVINO Runtime di Python
- Optimalkan dengan kuantisasi dan alat benchmarking
- Terapkan di seluruh CPU, iGPU, dan NPU dengan perubahan kode minimal
Apa itu OpenVINO dan mengapa menggunakannya?
OpenVINO adalah toolkit sumber terbuka untuk mengoptimalkan dan menerapkan model AI di seluruh perangkat keras Intel dan lainnya. Ini sangat kuat untuk inferensi produksi ketika Anda menginginkan kinerja yang dapat diprediksi, latensi rendah, dan portabilitas—tidak diperlukan pengaturan CUDA yang berat jika Anda tidak membutuhkannya. Ini mendukung format model populer seperti ONNX dan terintegrasi dengan baik dengan kerangka kerja umum.
Keunggulan utama:
- Kecepatan: Kernel yang dioptimalkan dan transformasi grafik mempercepat inferensi pada CPU dan GPU.
- Portabilitas: Aplikasi yang sama dapat menargetkan CPU, iGPU, NPU dengan perubahan perangkat satu baris.
- Efisiensi: Kuantisasi, kompresi model, dan optimasi runtime menurunkan latensi dan memori.
- Kesederhanaan: API Python yang bersih dan alat CLI membuatnya ramah bagi pemula.
Langkah 1: Instal OpenVINO
Bagi sebagian besar pengguna, cara tercepat adalah melalui pip:
- Pastikan Python 3.9–3.12 terinstal (64-bit).
- Buat dan aktifkan lingkungan virtual (disarankan).
- Instal:
pip install -U openvino openvino-dev
- Verifikasi:
python -c "import openvino; print(openvino.version)"
Jika Anda lebih suka sumber daya langkah demi langkah resmi atau ingin melacak catatan khusus versi dan dukungan platform, mulailah dengan dokumentasi Memulai OpenVINO dan pusat dokumentasi saat ini. Untuk referensi instalasi pip cepat dan kompatibilitas, lihat halaman PyPI.
Langkah 2: Siapkan model Anda (disarankan ONNX)
OpenVINO berjalan paling baik dengan model IR (Representasi Menengah) (.xml/.bin). Sebagian besar pengguna mengekspor ke ONNX terlebih dahulu, kemudian mengonversi ke IR menggunakan Model Optimizer.
Alur populer:
- PyTorch: torch.onnx.export → ONNX → OpenVINO IR
- TensorFlow/Keras: SavedModel → ONNX (melalui tf2onnx) → OpenVINO IR
- ONNX yang Ada: Langsung konversi ke OpenVINO IR
Contoh cepat (PyTorch → ONNX):
- Ekspor model Anda ke ONNX di dalam Python:
torch.onnx.export(model, dummy_input, "model.onnx", opset_version=17, do_constant_folding=True)
- Validasi ONNX dengan onnx.checker.check_model atau jalankan sekali di onnxruntime.
Langkah 3: Konversi ke OpenVINO IR dengan Model Optimizer
Model Optimizer mengonversi model kerangka kerja ke OpenVINO IR dan menerapkan optimasi tingkat grafik. Setelah menginstal openvino-dev, Anda dapat menjalankan:
- mo --input_model model.onnx --output_dir ov_model
Ini menghasilkan model.xml dan model.bin.
Bendera yang berguna:
- --input_shape: Paksa dimensi input jika model Anda dinamis.
- --mean_values/--scale_values: Normalisasi input selama prapemrosesan.
- --compress_to_fp16: Kurangi presisi dan ukuran model untuk peningkatan kecepatan/memori.
Tip: Jika Anda menargetkan inferensi CPU latensi rendah, FP16 sering kali menghasilkan keseimbangan kecepatan dan akurasi yang bagus. Simpan FP32 IR dasar untuk pengujian A/B.
Langkah 4: Jalankan inferensi dengan OpenVINO Runtime (Python)
Alur kerja runtime inti sangat mudah.
Contoh (klasifikasi gambar):
from openvino.runtime import Core
import numpy as np
import cv2
core = Core
model = core.read_model("ov_model/model.xml")
compiled_model = core.compile_model(model, device_name="CPU") # options: "CPU", "GPU", "AUTO", "NPU" (where supported)
input_layer = compiled_model.inputs. Jika Anda ingin membuat profil CPU hotspots dan pemanfaatan thread, Intel VTune Profiler memiliki resep khusus untuk aplikasi OpenVINO.
Langkah 6: Optimalkan dengan kuantisasi (INT8)
Kuantisasi pasca-pelatihan (PTQ) dapat mengurangi ukuran model dan meningkatkan kecepatan dengan kehilangan akurasi minimal:
- Gunakan POT (Post-Training Optimization Tool) bawaan yang disertakan dengan openvino-dev.
- Sediakan dataset kalibrasi kecil yang menyerupai data produksi Anda.
- Ekspor INT8 IR dan lakukan benchmark. Jika akurasi tidak mencukupi, coba presisi campuran (INT8 + FP16) atau kuantisasi selektif.
Alur kuantisasi umum:
- Kumpulkan sampel representatif.
- Konfigurasi parameter kuantisasi POT (per-tensor vs per-channel, simetris vs asimetris).
- Jalankan kalibrasi dan validasi.
- Bandingkan KPI: latensi, throughput, akurasi top-1/top-5 atau metrik khusus tugas.
Langkah 7: Tangani prapemrosesan dengan benar
Ekspektasi I/O model sering kali berbeda. Standarkan prapemrosesan Anda:
- Ubah ukuran/potong tengah ke ukuran yang diharapkan (mis., 224×224)
- Urutan saluran (RGB vs BGR)
- Tata letak (NCHW vs NHWC)
Anda dapat menyematkan langkah-langkah prapemrosesan ke dalam IR menggunakan API PrePostProcessor di OpenVINO Runtime sehingga kode aplikasi Anda tetap bersih dan portabel.
Contoh cuplikan:
from openvino.runtime import Core, Layout, Type
from openvino.preprocess import PrePostProcessor
core = Core
model = core.read_model("ov_model/model.xml")
ppp = PrePostProcessor(model)
ppp.input.tensor.set_layout(Layout("NHWC"))
ppp.input.preprocess.convert_element_type(Type.f32)
ppp.output.tensor
model = ppp.build
compiled_model = core.compile_model(model, "AUTO")
Langkah 8: Skala ke video dan streaming
Untuk analitik video, Anda dapat menyalurkan inferensi OpenVINO dengan OpenCV atau GStreamer. Gunakan permintaan inferensi asinkron dan pemrosesan batch untuk menjaga FPS tetap tinggi dan latensi tetap rendah.
Tips:
- Gunakan API async: Beberapa permintaan yang sedang berlangsung meningkatkan throughput pada CPU.
- Batch frame jika model Anda mendapat manfaat dari eksekusi vektorisasi.
- Sematkan thread atau sesuaikan stream untuk latensi yang dapat diprediksi pada sistem multi-core.
Langkah 9: Terapkan dengan cerdas di seluruh perangkat
Salah satu kekuatan super OpenVINO adalah penargetan perangkat yang mulus:
- CPU: Standar default yang kuat; tersedia secara luas; bagus untuk edge dan server.
- GPU (terintegrasi): Akselerasi yang baik tanpa GPU diskrit; kualitas driver penting.
- AUTO: Biarkan runtime memilih; bagus untuk aplikasi portabel.
- Eksekusi Hetero: Pisahkan lapisan di seluruh perangkat di mana bermanfaat.
Mulailah dengan AUTO untuk portabilitas. Jika Anda membutuhkan kontrol yang lebih ketat, lakukan benchmark CPU vs GPU dan putuskan per model.
Contoh praktis berdasarkan tugas
- Klasifikasi (ResNet/ViT):
- Konversi ONNX → IR; gunakan FP16; perangkat AUTO; inferensi async.
- Prapemrosesan: ubah ukuran, potong tengah, normalisasi.
- Kuantisasi jika Anda membutuhkan >2× throughput dengan penurunan akurasi kecil.
- Deteksi objek (YOLO/SSD):
- Pastikan bentuk dinamis ditangani atau perbaiki ukuran input.
- Parse output: dekode kotak, terapkan NMS sisi klien.
- Gunakan INT8 untuk penerapan edge untuk mencapai real-time pada CPU.
- Gunakan tiling untuk gambar besar.
- Optimalkan pasca-pemrosesan (argmax, pemetaan warna) dengan NumPy vektorisasi.
- Gunakan optimasi OpenVINO-text jika tersedia.
- Cache alur tokenisasi; pertimbangkan INT8 untuk transformer.
- Stable Diffusion / Generatif:
- Target FP16; optimalkan scheduler/inference loops.
- Profiling membantu—alur difusi multi-tahap.
Daftar periksa pengujian dan validasi
- Bandingkan output vs baseline (PyTorch/TF/ONNXRuntime) untuk set pengujian kecil.
- Validasi perbedaan numerik setelah konversi FP16/INT8.
- Ukur latensi p50/p95 dan throughput di bawah beban yang diharapkan.
- Uji stres: jalankan lama untuk menangkap masalah memori atau threading.
Jawaban cepat pemecahan masalah
- Kesalahan konversi dengan Model Optimizer:
- Perbarui openvino-dev; coba opset yang lebih baru; sederhanakan grafik ONNX (onnxsim).
- Sediakan --input_shape; konfirmasi dukungan input dinamis.
- Gunakan FP16/INT8, API async, sesuaikan thread/stream; jalankan benchmark_app.
- Perbarui driver; coba device="AUTO"; periksa dokumentasi untuk GPU yang didukung.
Sumber daya pembelajaran dan dokumentasi resmi
- Mulai di sini untuk tutorial langsung, notebook, dan panduan pengaturan: OpenVINO Get Started
- Portal dokumentasi lengkap untuk API, Model Optimizer, POT, sampel: OpenVINO Docs
- Referensi instalasi Pip untuk instalasi cepat dan kompatibilitas: PyPI openvino
- Profiling dan analisis kinerja untuk aplikasi OpenVINO: Panduan Intel VTune
Ngomong-ngomong, jika Anda menyusun konten teknis, tutorial, atau buku pedoman internal seputar optimasi dan penerapan, alat seperti ruang kerja penulisan Sider.AI dapat membantu Anda menggabungkan kode, benchmark, dan narasi dengan cepat—berguna saat mendokumentasikan eksperimen kinerja OpenVINO yang kompleks atau perbandingan multi-perangkat. Langkah selanjutnya yang dapat ditindaklanjuti
- Instal OpenVINO dengan pip dan jalankan benchmark_app pada sampel IR.
- Konversi model ONNX yang dikenal baik (mis., ResNet50) dan validasi akurasi.
- Coba FP16, lalu INT8 dengan POT; ukur latensi dan throughput.
- Alihkan device_name antara CPU, GPU, dan AUTO; pilih yang terbaik untuk perangkat keras target Anda.
- Profil dengan VTune jika Anda perlu memeras kinerja ekstra.
Poin-poin penting
- OpenVINO membuat inferensi AI cepat, portabel, dan sadar perangkat keras.
- Konversi ke IR ditambah prapemrosesan cerdas menghasilkan peningkatan kecepatan yang andal.
- Kuantisasi dan eksekusi async adalah teman terbaik Anda untuk kinerja real-time.
- Fleksibilitas perangkat (CPU/iGPU/NPU/AUTO) berarti satu basis kode, banyak target.
FAQ
Q1:Bagaimana cara menginstal OpenVINO dengan cara termudah?
Gunakan lingkungan virtual dan jalankan: pip install -U openvino openvino-dev. Verifikasi dengan pemeriksaan impor cepat dan konsultasikan dokumentasi Memulai resmi untuk spesifikasi platform.
Q2:Bagaimana cara mengonversi model saya ke OpenVINO IR?
Ekspor model Anda ke ONNX, lalu jalankan Model Optimizer (mo) untuk menghasilkan file IR .xml/.bin. Sediakan bentuk input dan pertimbangkan FP16 untuk peningkatan kecepatan dan memori.
Q3:Dapatkah OpenVINO berjalan di CPU dan GPU terintegrasi tanpa perubahan kode?
Ya. Kompilasi model dengan device_name="AUTO", "CPU", atau "GPU". Anda dapat mengalihkan perangkat dengan satu parameter sambil menjaga kode Anda tetap utuh.
Q4:Bagaimana cara mempercepat inferensi dengan OpenVINO?
Gunakan kuantisasi FP16 atau INT8, API inferensi async, dan benchmark_app untuk menyesuaikan thread dan stream. Profil dengan VTune untuk analisis kemacetan yang lebih dalam.
Q5:Apakah OpenVINO mendukung NLP dan model generatif?
Ya. Ini mendukung berbagai model NLP dan difusi; gunakan FP16 dan pertimbangkan INT8 untuk transformer. Validasi akurasi setelah optimasi dan ukur latensi di bawah beban.
