Si mai has intentat accelerar la inferència d’IA en hardware quotidià i t’has sentit encallat entre execucions lentes amb CPU i la complexitat de l’GPU, OpenVINO podria ser la peça que falta. Creat per Intel, converteix els models comuns d’aprenentatge profund en aplicacions ràpides i portables que s’executen en CPUs, GPUs integrades i fins i tot NPUs, sense que hagis de reescriure tot el teu stack.
En aquesta guia pràctica i orientada a solucions, aprendràs exactament com utilitzar OpenVINO, des de la instal·lació fins a la conversió de models, optimització i desplegament. Cobrirem els fluxos de treball més comuns, compartirem codi d’exemple i destacarem consells de rendiment que realment importen.
Què aprendràs d’un cop d’ull:
- Instal·la OpenVINO en minuts amb pip
- Converteix models (exportació ONNX/TF/PyTorch) amb el Model Optimizer
- Executa inferència amb l’OpenVINO Runtime en Python
- Optimitza amb quantificació i eines de benchmarking
- Desplega a CPU, iGPU i NPU amb canvis mínims al codi
Què és OpenVINO i per què usar-lo?
OpenVINO és un conjunt d’eines de codi obert per optimitzar i desplegar models d’IA en hardware Intel i més enllà. És especialment potent per a inferència en producció quan vols un rendiment previsible, baixa latència i portabilitat, sense necessitat d’una configuració pesada de CUDA si no ho necessites. Suporta formats populars de models com ONNX i s’integra bé amb frameworks habituals.
Avantatges clau:
- Velocitat: Nuclis optimitzats i transformacions de gràfics acceleren la inferència en CPUs i GPUs.
- Portabilitat: La mateixa aplicació pot utilitzar CPU, iGPU o NPU canviant només una línia de dispositiu.
- Eficiència: Quantificació, compressió de models i optimitzacions d’execució redueixen latència i memòria.
- Simplicitat: API neta en Python i eines CLI que faciliten la corba d’aprenentatge.
Pas 1: Instal·la OpenVINO
Per a la majoria d’usuaris, la manera més ràpida és via pip:
- Assegura’t de tenir Python 3.9–3.12 (64 bits) instal·lat.
- Crea i activa un entorn virtual (recomanat).
- Instal·la:
pip install -U openvino openvino-dev
- Verifica:
python -c "import openvino; print(openvino.version)"
Si prefereixes recursos oficials detallats o vols seguir notes específiques de versions i suport de plataformes, comença amb la documentació Get Started d’OpenVINO i el hub oficial. Per una referència ràpida de la instal·lació de pip i compatibilitat, consulta la pàgina de PyPI.
Pas 2: Prepara el teu model (es recomana ONNX)
OpenVINO funciona millor amb models en IR (Intermediate Representation) (.xml/.bin). La majoria dels usuaris exporten primer a ONNX i després converteixen a IR amb el Model Optimizer.
Rutes populars:
- PyTorch: torch.onnx.export → ONNX → OpenVINO IR
- TensorFlow/Keras: SavedModel → ONNX (amb tf2onnx) → OpenVINO IR
- ONNX existent: Converteix directament a OpenVINO IR
Exemple ràpid (PyTorch → ONNX):
- Exporta el teu model a ONNX dins Python:
torch.onnx.export(model, dummy_input, "model.onnx", opset_version=17, do_constant_folding=True)
- Valida l’ONNX amb onnx.checker.check_model o executa’l una vegada amb onnxruntime.
Pas 3: Converteix a OpenVINO IR amb Model Optimizer
El Model Optimizer converteix models de frameworks a IR d’OpenVINO i aplica optimitzacions a nivell de gràfic. Després d’instal·lar openvino-dev, pots executar:
- mo --input_model model.onnx --output_dir ov_model
Això genera model.xml i model.bin.
Opcions útils:
- --input_shape: Força les dimensions d’entrada si el model és dinàmic.
- --mean_values/--scale_values: Normalitza entrades durant la preprocés.
- --compress_to_fp16: Redueix la precisió i mida del model per guanyar velocitat/memòria.
Consell: Si vols inferència de baixa latència en CPU, FP16 sovint ofereix un bon equilibri entre velocitat i precisió. Conserva una versió IR FP32 com a baseline per a proves A/B.
Pas 4: Executa inferència amb OpenVINO Runtime (Python)
El flux de treball principal és senzill.
Exemple (classificació d’imatges):
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") # opcions: "CPU", "GPU", "AUTO", "NPU" (si està suportat)
input_layer = compiled_model.inputs[0]
Si vols identificar punts calents i utilització de fils en CPU, Intel VTune Profiler té una guia específica per a aplicacions OpenVINO.
Pas 6: Optimitza amb quantificació (INT8)
La quantificació post-entrenament (PTQ) pot reduir la mida del model i augmentar la velocitat amb mínima pèrdua de precisió:
- Utilitza l’eina integrat POT (Post-Training Optimization Tool) inclosa en openvino-dev.
- Proporciona un petit conjunt de dades de calibratge que s’assembli a les dades de producció.
- Exporta una IR INT8 i mesura rendiment. Si la precisió és insuficient, prova precisió mixta (INT8 + FP16) o quantificació selectiva.
Flux habitual de quantificació:
- Recull exemples representatius.
- Configura paràmetres de POT (per tensor vs per canal, simètric vs asimètric).
- Executa calibratge i validació.
- Compara indicadors clau: latència, rendiment, precisió top-1/top-5 o mètriques específiques de la tasca.
Pas 7: Gestiona la preprocés correctament
Les expectatives d’I/O del model sovint varien. Estandarditza la preprocés:
- Redimensiona/crop centrats a la mida esperada (p. ex. 224×224)
- Ordre de canals (RGB vs BGR)
- Normalització (mitjana/desviació estàndard)
Pots integrar passos de preprocés a l’IR usant la API PrePostProcessor d’OpenVINO Runtime per mantenir el codi net i portable.
Fragment d’exemple:
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")
Pas 8: Escala a vídeo i streaming
Per a anàlisi de vídeo, pots encadenar inferència OpenVINO amb OpenCV o GStreamer. Utilitza peticions d’inferència asíncrones i processament per lots per mantenir alta la taxa de fotogrames i baixa la latència.
Consells:
- Utilitza API asíncrona: diverses peticions simultànies milloren el rendiment en CPUs.
- Pila fotogrames si el model s’hi beneficia d’una execució vectoritzada.
- Assigna fils o ajusta streams per latència previsible en sistemes multicore.
Pas 9: Desplega intel·ligentment entre dispositius
Una de les superfórmules d’OpenVINO és el canvi transparent de dispositius:
- CPU: Opció per defecte potent; àmpliament disponible; ideal per edge i servidors.
- GPU (integrada): Bona acceleració sense GPU discreta; la qualitat del controlador importa.
- AUTO: Permet que l’entorn d’execució esculli; ideal per aplicacions portables.
- Execució heterogènia: distribueix capes entre dispositius on convé.
Comença amb AUTO per portabilitat. Si necessites control més precís, compara rendiment CPU vs GPU i decideix per model.
Exemples pràctics per tasca
- Classificació (ResNet/ViT):
- Converteix ONNX → IR; usa FP16; dispositiu AUTO; inferència asíncrona.
- Preprocés: redimensiona, crop centrada, normalitza.
- Quantifica si necessites >2× taxa amb una petita pèrdua de precisió.
- Detecció d’objectes (YOLO/SSD):
- Assegura que les formes dinàmiques estiguin gestionades o fixa mida d’entrada.
- Analitza resultats: decodifica caixes i aplica NMS client-side.
- Fes servir INT8 per desplegaments edge per assolir temps real en CPUs.
- Utilitza tessel·lació per a imatges grans.
- Optimitza postprocés (argmax, mapatge de colors) amb NumPy vectoritzat.
- Fes servir OpenVINO-text quan sigui disponible.
- Emmagatzema en caché pipelines de tokenització; considera INT8 per transformers.
- Stable Diffusion / Generativa:
- Apunta a FP16; optimitza scheduler i bucles d’inferència.
- El perfilat ajuda: els pipelines de difusió són multi-etapa.
Llista de comprovació per a testatge i validació
- Compara sortides amb baseline (PyTorch/TF/ONNXRuntime) en un conjunt de prova petit.
- Valida diferències numèriques després de conversió FP16/INT8.
- Mesura latència p50/p95 i rendiment sota càrrega prevista.
- Fes test d’estrès: execucions llargues per detectar problemes de memòria o fils.
Respostes ràpides a problemes comuns
- Error en conversió amb Model Optimizer:
- Actualitza openvino-dev; prova opset més recent; simplifica gràfic ONNX (onnxsim).
- Proporciona --input_shape; confirma suport a entrades dinàmiques.
- Usa FP16/INT8, API asíncrona, ajusta fils/streams; executa benchmark_app.
- Actualitza drivers; prova device="AUTO"; consulta docs per GPUs suportades.
Recursos d’aprenentatge i documentació oficial
- Comença aquí per tutorials pràctics, notebooks i guies d’instal·lació: OpenVINO Get Started
- Portal complet per a APIs, Model Optimizer, POT, exemples: OpenVINO Docs
- Referència d’instal·lació amb pip per instal·lacions ràpides i compatibilitat: PyPI openvino
- Perfilat i anàlisi de rendiment per apps OpenVINO: Guia Intel VTune
Per cert, si estàs escrivint contingut tècnic, tutorials o manuals interns sobre optimització i desplegament, eines com l’espai de treball de Sider.AI t’ajuden a combinar codi, benchmarks i narrativa ràpidament — molt útil per documentar experiments complexos d’OpenVINO o comparacions multi-dispositiu. Passos següents recomanats
- Instal·la OpenVINO amb pip i executa benchmark_app sobre un IR d’exemple.
- Converteix un model ONNX conegut (p. ex., ResNet50) i valida la precisió.
- Prova FP16 i després INT8 amb POT; mesura latència i rendiment.
- Canvia device_name entre CPU, GPU i AUTO; tria el millor segons el teu hardware.
- Perfila amb VTune si necessites extreure més rendiment.
Punts clau
- OpenVINO accelera l’inferència d’IA de manera ràpida, portable i adaptada a l’hardware.
- La conversió a IR i la preprocés intel·ligent generen millores fiables.
- La quantificació i l’execució asíncrona són els teus aliats per rendiment en temps real.
- La flexibilitat de dispositius (CPU/iGPU/NPU/AUTO) significa un sol codi, múltiples objectius.
Preguntes freqüents
Q1:Com instal·lar OpenVINO de manera més fàcil?
Utilitza un entorn virtual i executa: pip install -U openvino openvino-dev. Verifica amb una importació ràpida i consulta la documentació oficial Get Started per detalls de plataforma.
Q2:Com convertir el meu model a OpenVINO IR?
Exporta el model a ONNX i després executa el Model Optimizer (mo) per obtenir els fitxers .xml/.bin IR. Indica mides d’entrada i considera FP16 per guanyar velocitat i memòria.
Q3:OpenVINO pot executar-se en CPU i GPU integrada sense canviar codi?
Sí, compila el model amb device_name="AUTO", "CPU" o "GPU". Pots canviar el dispositiu amb un sol paràmetre mantenint la resta del codi igual.
Q4:Com puc accelerar la inferència amb OpenVINO?
Utilitza quantificació FP16 o INT8, l’API d’inferència asíncrona i benchmark_app per ajustar fils i streams. Perfila amb VTune per analitzar colls d’ampolla més a fons.
Q5:OpenVINO suporta models de NLP i generatius?
Sí, suporta una varietat de models NLP i difusió; utilitza FP16 i considera INT8 per transformers. Valida la precisió després de l’optimització i mesura la latència sota càrrega.
