How do I install OpenVINO the easiest way?

Use a virtual environment and run: pip install -U openvino openvino-dev. Verify with a quick import check and consult official Get Started docs for platform specifics.

How do I convert my model to OpenVINO IR?

Export your model to ONNX, then run the Model Optimizer (mo) to produce .xml/.bin IR files. Provide input shapes and consider FP16 for speed and memory gains.

Can OpenVINO run on CPU and integrated GPU without code changes?

Yes. Compile the model with device_name="AUTO", "CPU", or "GPU". You can switch devices with a single parameter while keeping the rest of your code intact.

How can I speed up inference with OpenVINO?

Use FP16 or INT8 quantization, the async inference API, and benchmark_app to tune threads and streams. Profile with VTune for deeper bottleneck analysis.

Does OpenVINO support NLP and generative models?

Yes. It supports a range of NLP and diffusion models; use FP16 and consider INT8 for transformers. Validate accuracy after optimization and measure latency under load.

OpenVINO ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು: ವೇಗದ, ಹೊಂದಿಕೊಳ್ಳುವ AI ಅನುಮಾನಕ್ಕೆ ಒಂದು ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗದರ್ಶಿ

ನೀವು ಎಂದಾದರೂ ಸಾಮಾನ್ಯ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ AI ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ವೇಗಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ನಿಧಾನ CPU ರನ್ ಮತ್ತು GPU ಸಂಕೀರ್ಣತೆಯ ನಡುವೆ ಸಿಲುಕಿಕೊಂಡರೆ, OpenVINO ಕಾಣೆಯಾಗಿರುವ ಭಾಗವಾಗಿರಬಹುದು. Intel ನಿಂದ ನಿರ್ಮಿಸಲ್ಪಟ್ಟ ಇದು, ಸಾಮಾನ್ಯ ಡೀಪ್ ಲರ್ನಿಂಗ್ ಮಾದರಿಗಳನ್ನು ವೇಗವಾದ, ಪೋರ್ಟಬಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಅದು CPU ಗಳು, ಇಂಟಿಗ್ರೇಟೆಡ್ GPU ಗಳು ಮತ್ತು NPU ಗಳಲ್ಲಿಯೂ ಸಹ ರನ್ ಆಗುತ್ತದೆ - ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಸ್ಟಾಕ್ ಅನ್ನು ಪುನಃ ಬರೆಯದೆಯೇ.

ಈ ಪ್ರಾಯೋಗಿಕ, ಪರಿಹಾರ-ಆಧಾರಿತ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, OpenVINO ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ನೀವು ಕಲಿಯುವಿರಿ - ಅನುಸ್ಥಾಪನೆಯಿಂದ ಮಾದರಿ ಪರಿವರ್ತನೆ, ಆಪ್ಟಿಮೈಸೇಶನ್ ಮತ್ತು ನಿಯೋಜನೆವರೆಗೆ. ನಾವು ಸಾಮಾನ್ಯ ವರ್ಕ್‌ಫ್ಲೋಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇವೆ, ಉದಾಹರಣೆ ಕೋಡ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಮುಖ್ಯವಾದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಲಹೆಗಳನ್ನು ಹೈಲೈಟ್ ಮಾಡುತ್ತೇವೆ.

ನೀವು ಒಂದು ನೋಟದಲ್ಲಿ ಏನು ಕಲಿಯುತ್ತೀರಿ:

pip ನೊಂದಿಗೆ ನಿಮಿಷಗಳಲ್ಲಿ OpenVINO ಅನ್ನು ಸ್ಥಾಪಿಸಿ

ಮಾದರಿ ಆಪ್ಟಿಮೈಜರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮಾದರಿಗಳನ್ನು ಪರಿವರ್ತಿಸಿ (ONNX/TF/PyTorch ರಫ್ತು)

Python ನಲ್ಲಿ OpenVINO ರನ್‌ಟೈಮ್‌ನೊಂದಿಗೆ ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ರನ್ ಮಾಡಿ

ಕ್ವಾಂಟೈಸೇಶನ್ ಮತ್ತು ಬೆಂಚ್‌ಮಾರ್ಕಿಂಗ್ ಪರಿಕರಗಳೊಂದಿಗೆ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿ

ಕನಿಷ್ಠ ಕೋಡ್ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ CPU, iGPU ಮತ್ತು NPU ಉದ್ದಕ್ಕೂ ನಿಯೋಜಿಸಿ

OpenVINO ಎಂದರೇನು ಮತ್ತು ಅದನ್ನು ಏಕೆ ಬಳಸಬೇಕು? OpenVINO ಇಂಟೆಲ್ ಹಾರ್ಡ್‌ವೇರ್ ಮತ್ತು ಅದರಾಚೆ AI ಮಾದರಿಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಒಂದು ಮುಕ್ತ-ಮೂಲ ಟೂಲ್‌ಕಿಟ್ ಆಗಿದೆ. ನೀವು ಊಹಿಸಬಹುದಾದ ಕಾರ್ಯಕ್ಷಮತೆ, ಕಡಿಮೆ ಲೇಟೆನ್ಸಿ ಮತ್ತು ಪೋರ್ಟಬಿಲಿಟಿಯನ್ನು ಬಯಸಿದಾಗ ಇದು ಉತ್ಪಾದನಾ ಇನ್ಫರೆನ್ಸ್‌ಗೆ ವಿಶೇಷವಾಗಿ ಪ್ರಬಲವಾಗಿದೆ - ನಿಮಗೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ ಭಾರೀ CUDA ಸೆಟಪ್ ಅಗತ್ಯವಿಲ್ಲ. ಇದು ONNX ನಂತಹ ಜನಪ್ರಿಯ ಮಾದರಿ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯ ಚೌಕಟ್ಟುಗಳೊಂದಿಗೆ ಅಚ್ಚುಕಟ್ಟಾಗಿ ಸಂಯೋಜಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಅನುಕೂಲಗಳು:

ವೇಗ: ಆಪ್ಟಿಮೈಸ್ಡ್ ಕರ್ನಲ್‌ಗಳು ಮತ್ತು ಗ್ರಾಫ್ ರೂಪಾಂತರಗಳು CPU ಗಳು ಮತ್ತು GPU ಗಳಲ್ಲಿ ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ವೇಗಗೊಳಿಸುತ್ತವೆ.

ಪೋರ್ಟಬಿಲಿಟಿ: ಒಂದು-ಸಾಲಿನ ಸಾಧನದ ಬದಲಾವಣೆಯೊಂದಿಗೆ ಅದೇ ಅಪ್ಲಿಕೇಶನ್ CPU, iGPU, NPU ಅನ್ನು ಗುರಿಯಾಗಿಸಬಹುದು.

ದಕ್ಷತೆ: ಕ್ವಾಂಟೈಸೇಶನ್, ಮಾದರಿ ಸಂಕೋಚನ ಮತ್ತು ರನ್‌ಟೈಮ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳು ಲೇಟೆನ್ಸಿ ಮತ್ತು ಮೆಮೊರಿಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಸರಳತೆ: ಕ್ಲೀನ್ Python API ಮತ್ತು CLI ಪರಿಕರಗಳು ಇದನ್ನು ಆರಂಭಿಕರಿಗಾಗಿ ಸ್ನೇಹಿಯನ್ನಾಗಿಸುತ್ತದೆ.

ಹಂತ 1: OpenVINO ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರಿಗೆ, ವೇಗವಾದ ಮಾರ್ಗವೆಂದರೆ pip ಮೂಲಕ:

Python 3.9–3.12 ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ (64-ಬಿಟ್).

ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಿ ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸಿ (ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ).

ಸ್ಥಾಪಿಸಿ: pip install -U openvino openvino-dev

ಪರಿಶೀಲಿಸಿ: python -c "import openvino; print(openvino.version)"

ನೀವು ಅಧಿಕೃತ ಹಂತ-ಹಂತದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಯಸಿದರೆ ಅಥವಾ ಆವೃತ್ತಿ-ನಿರ್ದಿಷ್ಟ ಟಿಪ್ಪಣಿಗಳು ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಬೆಂಬಲವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಯಸಿದರೆ, OpenVINO ಗೆಟ್ ಸ್ಟಾರ್ಟೆಡ್ ಡಾಕ್ಸ್ ಮತ್ತು ಪ್ರಸ್ತುತ ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಹಬ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ. ತ್ವರಿತ pip ಅನುಸ್ಥಾಪನಾ ಉಲ್ಲೇಖ ಮತ್ತು ಹೊಂದಾಣಿಕೆಗಾಗಿ, PyPI ಪುಟವನ್ನು ನೋಡಿ.

ಹಂತ 2: ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ತಯಾರಿಸಿ (ONNX ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ) OpenVINO IR (ಇಂಟರ್ಮೀಡಿಯೇಟ್ ರೆಪ್ರೆಸೆಂಟೇಶನ್) ಮಾದರಿಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ (.xml/.bin). ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರು ಮೊದಲು ONNX ಗೆ ರಫ್ತು ಮಾಡುತ್ತಾರೆ, ನಂತರ ಮಾದರಿ ಆಪ್ಟಿಮೈಜರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು IR ಗೆ ಪರಿವರ್ತಿಸುತ್ತಾರೆ.

ಜನಪ್ರಿಯ ಮಾರ್ಗಗಳು:

PyTorch: torch.onnx.export → ONNX → OpenVINO IR

TensorFlow/Keras: SavedModel → ONNX (tf2onnx ಮೂಲಕ) → OpenVINO IR

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ONNX: ನೇರವಾಗಿ OpenVINO IR ಗೆ ಪರಿವರ್ತಿಸಿ

ತ್ವರಿತ ಉದಾಹರಣೆ (PyTorch → ONNX):

Python ನ ಒಳಗೆ ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ONNX ಗೆ ರಫ್ತು ಮಾಡಿ: torch.onnx.export(model, dummy_input, "model.onnx", opset_version=17, do_constant_folding=True)

onnx.checker.check_model ನೊಂದಿಗೆ ONNX ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ ಅಥವಾ ಅದನ್ನು onnxruntime ನಲ್ಲಿ ಒಮ್ಮೆ ರನ್ ಮಾಡಿ.

ಹಂತ 3: ಮಾದರಿ ಆಪ್ಟಿಮೈಜರ್‌ನೊಂದಿಗೆ OpenVINO IR ಗೆ ಪರಿವರ್ತಿಸಿ ಮಾದರಿ ಆಪ್ಟಿಮೈಜರ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಮಾದರಿಗಳನ್ನು OpenVINO IR ಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ಗ್ರಾಫ್-ಹಂತದ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ಅನ್ವಯಿಸುತ್ತದೆ. openvino-dev ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ, ನೀವು ರನ್ ಮಾಡಬಹುದು:

mo --input_model model.onnx --output_dir ov_model ಇದು model.xml ಮತ್ತು model.bin ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಉಪಯುಕ್ತ ಫ್ಲ್ಯಾಗ್‌ಗಳು:

--input_shape: ನಿಮ್ಮ ಮಾದರಿ ಡೈನಾಮಿಕ್ ಆಗಿದ್ದರೆ ಇನ್‌ಪುಟ್ ಆಯಾಮಗಳನ್ನು ಬಲವಂತವಾಗಿ ನಮೂದಿಸಿ.

--mean_values/--scale_values: ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ಸಮಯದಲ್ಲಿ ಇನ್‌ಪುಟ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸಿ.

--compress_to_fp16: ವೇಗ/ಮೆಮೊರಿ ಲಾಭಗಳಿಗಾಗಿ ನಿಖರತೆ ಮತ್ತು ಮಾದರಿ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಿ.

ಸಲಹೆ: ನೀವು ಕಡಿಮೆ-ಲೇಟೆನ್ಸಿ CPU ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ಗುರಿಯಾಗಿಸಿಕೊಂಡಿದ್ದರೆ, FP16 ಸಾಮಾನ್ಯವಾಗಿ ವೇಗ ಮತ್ತು ನಿಖರತೆಯ ಉತ್ತಮ ಸಮತೋಲನವನ್ನು ನೀಡುತ್ತದೆ. A/B ಪರೀಕ್ಷೆಗಾಗಿ ಬೇಸ್‌ಲೈನ್ FP32 IR ಅನ್ನು ಇರಿಸಿ.

ಹಂತ 4: OpenVINO ರನ್‌ಟೈಮ್‌ನೊಂದಿಗೆ ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ರನ್ ಮಾಡಿ (Python) ಕೋರ್ ರನ್‌ಟೈಮ್ ವರ್ಕ್‌ಫ್ಲೋ ನೇರವಾಗಿರುತ್ತದೆ.

ಉದಾಹರಣೆ (ಚಿತ್ರ ವರ್ಗೀಕರಣ):

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. ನೀವು CPU ಹಾಟ್‌ಸ್ಪಾಟ್‌ಗಳು ಮತ್ತು ಥ್ರೆಡ್ ಬಳಕೆಯನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಲು ಬಯಸಿದರೆ, Intel VTune Profiler ನಿರ್ದಿಷ್ಟವಾಗಿ OpenVINO ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಒಂದು ರೆಸಿಪಿಯನ್ನು ಹೊಂದಿದೆ.

ಹಂತ 6: ಕ್ವಾಂಟೈಸೇಶನ್‌ನೊಂದಿಗೆ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ (INT8) ಪೋಸ್ಟ್-ಟ್ರೈನಿಂಗ್ ಕ್ವಾಂಟೈಸೇಶನ್ (PTQ) ಮಾದರಿ ಗಾತ್ರವನ್ನು ಕುಗ್ಗಿಸಬಹುದು ಮತ್ತು ಕನಿಷ್ಠ ನಿಖರತೆಯ ನಷ್ಟದೊಂದಿಗೆ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸಬಹುದು:

openvino-dev ನೊಂದಿಗೆ ಸೇರಿಸಲಾದ ಅಂತರ್ನಿರ್ಮಿತ POT (ಪೋಸ್ಟ್-ಟ್ರೈನಿಂಗ್ ಆಪ್ಟಿಮೈಸೇಶನ್ ಟೂಲ್) ಅನ್ನು ಬಳಸಿ.

ನಿಮ್ಮ ಉತ್ಪಾದನಾ ಡೇಟಾವನ್ನು ಹೋಲುವ ಸಣ್ಣ ಮಾಪನಾಂಕ ನಿರ್ಣಯ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಒದಗಿಸಿ.

INT8 IR ಅನ್ನು ರಫ್ತು ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಬೆಂಚ್‌ಮಾರ್ಕ್ ಮಾಡಿ. ನಿಖರತೆ ಸಾಕಾಗದಿದ್ದರೆ, ಮಿಶ್ರ ನಿಖರತೆ (INT8 + FP16) ಅಥವಾ ಆಯ್ದ ಕ್ವಾಂಟೈಸೇಶನ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ.

ಸಾಮಾನ್ಯ ಕ್ವಾಂಟೈಸೇಶನ್ ಫ್ಲೋ:

ಪ್ರತಿನಿಧಿ ಮಾದರಿಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ.

POT ಕ್ವಾಂಟೈಸೇಶನ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ (ಪ್ರತಿ-ಟೆನ್ಸರ್ vs ಪ್ರತಿ-ಚಾನೆಲ್, ಸಮ್ಮಿತೀಯ vs ಅಸಮ್ಮಿತೀಯ).

ಮಾಪನಾಂಕ ನಿರ್ಣಯ ಮತ್ತು ಮೌಲ್ಯೀಕರಣವನ್ನು ರನ್ ಮಾಡಿ.

KPI ಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ: ಲೇಟೆನ್ಸಿ, ಥ್ರೋಪುಟ್, ಟಾಪ್-1/ಟಾಪ್-5 ನಿಖರತೆ ಅಥವಾ ಕಾರ್ಯ-ನಿರ್ದಿಷ್ಟ ಮೆಟ್ರಿಕ್‌ಗಳು.

ಹಂತ 7: ಸರಿಯಾದ ರೀತಿಯಲ್ಲಿ ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ನಿರ್ವಹಿಸಿ ಮಾದರಿ I/O ನಿರೀಕ್ಷೆಗಳು ಹೆಚ್ಚಾಗಿ ಭಿನ್ನವಾಗಿರುತ್ತವೆ. ನಿಮ್ಮ ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಪ್ರಮಾಣೀಕರಿಸಿ:

ನಿರೀಕ್ಷಿತ ಗಾತ್ರಕ್ಕೆ ಮರುಗಾತ್ರಗೊಳಿಸಿ/ಕೇಂದ್ರ-ಬೆಳೆ (ಉದಾಹರಣೆಗೆ, 224×224)

ಚಾನೆಲ್ ಆರ್ಡರ್ (RGB vs BGR)

ಸಾಮಾನ್ಯೀಕರಣ (ಸರಾಸರಿ/std)

ಲೇಔಟ್ (NCHW vs NHWC)

OpenVINO ರನ್‌ಟೈಮ್‌ನಲ್ಲಿರುವ PrePostProcessor API ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ಹಂತಗಳನ್ನು IR ನಲ್ಲಿ ಎಂಬೆಡ್ ಮಾಡಬಹುದು ಆದ್ದರಿಂದ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಸ್ವಚ್ಛ ಮತ್ತು ಪೋರ್ಟಬಲ್ ಆಗಿರುತ್ತದೆ.

ಉದಾಹರಣೆ ತುಣುಕು:

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

ಹಂತ 8: ವೀಡಿಯೊ ಮತ್ತು ಸ್ಟ್ರೀಮಿಂಗ್‌ಗೆ ಸ್ಕೇಲ್ ಮಾಡಿ ವೀಡಿಯೊ ಅನಾಲಿಟಿಕ್ಸ್‌ಗಾಗಿ, ನೀವು OpenCV ಅಥವಾ GStreamer ನೊಂದಿಗೆ OpenVINO ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ಪೈಪ್‌ಲೈನ್ ಮಾಡಬಹುದು. FPS ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಇರಿಸಿಕೊಳ್ಳಲು ಮತ್ತು ಲೇಟೆನ್ಸಿಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅಸಮಕಾಲಿಕ ಇನ್ಫರೆನ್ಸ್ ವಿನಂತಿಗಳು ಮತ್ತು ಬ್ಯಾಚ್ಡ್ ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಬಳಸಿ.

ಸಲಹೆಗಳು:

async API ಬಳಸಿ: ಬಹು ಇನ್-ಫ್ಲೈಟ್ ವಿನಂತಿಗಳು CPU ಗಳಲ್ಲಿ ಥ್ರೋಪುಟ್ ಅನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.

ನಿಮ್ಮ ಮಾದರಿಯು ವೆಕ್ಟರೈಸ್ಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್‌ನಿಂದ ಪ್ರಯೋಜನ ಪಡೆದರೆ ಫ್ರೇಮ್‌ಗಳನ್ನು ಬ್ಯಾಚ್ ಮಾಡಿ.

ಮಲ್ಟಿ-ಕೋರ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಊಹಿಸಬಹುದಾದ ಲೇಟೆನ್ಸಿಗಾಗಿ ಥ್ರೆಡ್‌ಗಳನ್ನು ಪಿನ್ ಮಾಡಿ ಅಥವಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಹೊಂದಿಸಿ.

ಹಂತ 9: ಸಾಧನಗಳಾದ್ಯಂತ ಚುರುಕಾಗಿ ನಿಯೋಜಿಸಿ OpenVINO ನ ಸೂಪರ್ ಪವರ್‌ಗಳಲ್ಲಿ ಒಂದು ತಡೆರಹಿತ ಸಾಧನ ಗುರಿಯಾಗಿದೆ:

CPU: ಪ್ರಬಲ ಡೀಫಾಲ್ಟ್; ವ್ಯಾಪಕವಾಗಿ ಲಭ್ಯವಿದೆ; ಎಡ್ಜ್ ಮತ್ತು ಸರ್ವರ್‌ಗೆ ಉತ್ತಮವಾಗಿದೆ.

GPU (ಇಂಟಿಗ್ರೇಟೆಡ್): ಡಿಸ್ಕ್ರೀಟ್ GPU ಇಲ್ಲದೆ ಉತ್ತಮ ವೇಗವರ್ಧನೆ; ಡ್ರೈವರ್ ಗುಣಮಟ್ಟ ಮುಖ್ಯ.

AUTO: ರನ್‌ಟೈಮ್ ಆಯ್ಕೆ ಮಾಡಲು ಬಿಡಿ; ಪೋರ್ಟಬಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಉತ್ತಮವಾಗಿದೆ.

ಹೆಟೆರೊ ಎಕ್ಸಿಕ್ಯೂಶನ್: ಪ್ರಯೋಜನಕಾರಿಯಾದ ಸಾಧನಗಳಾದ್ಯಂತ ಲೇಯರ್‌ಗಳನ್ನು ವಿಭಜಿಸಿ.

ಪೋರ್ಟಬಿಲಿಟಿಗಾಗಿ AUTO ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ. ನಿಮಗೆ ಬಿಗಿಯಾದ ನಿಯಂತ್ರಣ ಅಗತ್ಯವಿದ್ದರೆ, CPU vs GPU ಅನ್ನು ಬೆಂಚ್‌ಮಾರ್ಕ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿ ಮಾದರಿಗೆ ನಿರ್ಧರಿಸಿ.

ಕಾರ್ಯದ ಪ್ರಕಾರ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು

ವರ್ಗೀಕರಣ (ResNet/ViT):

ONNX → IR ಅನ್ನು ಪರಿವರ್ತಿಸಿ; FP16 ಬಳಸಿ; AUTO ಸಾಧನ; ಅಸಮಕಾಲಿಕ ಇನ್ಫರೆನ್ಸ್.

ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್: ಮರುಗಾತ್ರಗೊಳಿಸಿ, ಕೇಂದ್ರ-ಬೆಳೆ, ಸಾಮಾನ್ಯೀಕರಿಸಿ.

ನಿಮಗೆ ಸಣ್ಣ ನಿಖರತೆಯ ಡ್ರಾಪ್‌ನೊಂದಿಗೆ >2× ಥ್ರೋಪುಟ್ ಅಗತ್ಯವಿದ್ದರೆ ಕ್ವಾಂಟೈಜ್ ಮಾಡಿ.

ಆಬ್ಜೆಕ್ಟ್ ಡಿಟೆಕ್ಷನ್ (YOLO/SSD):

ಡೈನಾಮಿಕ್ ಆಕಾರಗಳನ್ನು ನಿರ್ವಹಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಥವಾ ಇನ್‌ಪುಟ್ ಗಾತ್ರವನ್ನು ಸರಿಪಡಿಸಿ.

ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಿ: ಬಾಕ್ಸ್‌ಗಳನ್ನು ಡಿಕೋಡ್ ಮಾಡಿ, NMS ಕ್ಲೈಂಟ್-ಸೈಡ್ ಅನ್ನು ಅನ್ವಯಿಸಿ.

CPU ಗಳಲ್ಲಿ ನೈಜ-ಸಮಯವನ್ನು ತಲುಪಲು ಎಡ್ಜ್ ನಿಯೋಜನೆಗಳಿಗಾಗಿ INT8 ಅನ್ನು ಬಳಸಿ.

ಸೆಮ್ಯಾಂಟಿಕ್ ವಿಭಾಗ:

ದೊಡ್ಡ ಚಿತ್ರಗಳಿಗಾಗಿ ಟೈಲಿಂಗ್ ಬಳಸಿ.

ವೆಕ್ಟರೈಸ್ಡ್ NumPy ನೊಂದಿಗೆ ಪೋಸ್ಟ್-ಪ್ರೊಸೆಸಿಂಗ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ (argmax, ಕಲರ್ ಮ್ಯಾಪಿಂಗ್).

NLP (BERT-ತರಹದ):

ಲಭ್ಯವಿದ್ದಾಗ OpenVINO-ಪಠ್ಯ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ಬಳಸಿ.

ಟೋಕನೈಸೇಶನ್ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ; ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳಿಗಾಗಿ INT8 ಅನ್ನು ಪರಿಗಣಿಸಿ.

ಸ್ಥಿರ ಪ್ರಸರಣ / ಉತ್ಪಾದಕ:

FP16 ಅನ್ನು ಗುರಿಯಾಗಿಸಿ; ಶೆಡ್ಯೂಲರ್/ಇನ್ಫರೆನ್ಸ್ ಲೂಪ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ.

ಪ್ರೊಫೈಲಿಂಗ್ ಸಹಾಯ ಮಾಡುತ್ತದೆ - ಪ್ರಸರಣ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಬಹು-ಹಂತವಾಗಿವೆ.

ಪರೀಕ್ಷೆ ಮತ್ತು ಮೌಲ್ಯೀಕರಣ ಪರಿಶೀಲನಾಪಟ್ಟಿ

ಸಣ್ಣ ಪರೀಕ್ಷಾ ಸೆಟ್‌ಗಾಗಿ ಬೇಸ್‌ಲೈನ್ (PyTorch/TF/ONNXRuntime) ವಿರುದ್ಧ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ.

FP16/INT8 ಪರಿವರ್ತನೆಗಳ ನಂತರ ಸಂಖ್ಯಾತ್ಮಕ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ.

ನಿರೀಕ್ಷಿತ ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಲೇಟೆನ್ಸಿ p50/p95 ಮತ್ತು ಥ್ರೋಪುಟ್ ಅನ್ನು ಅಳೆಯಿರಿ.

ಒತ್ತಡ ಪರೀಕ್ಷೆ: ಮೆಮೊರಿ ಅಥವಾ ಥ್ರೆಡಿಂಗ್ ಸಮಸ್ಯೆಗಳನ್ನು ಸೆರೆಹಿಡಿಯಲು ದೀರ್ಘ ರನ್‌ಗಳು.

ನಿವಾರಣೆ ತ್ವರಿತ ಉತ್ತರಗಳು

ಮಾದರಿ ಆಪ್ಟಿಮೈಜರ್‌ನೊಂದಿಗೆ ಪರಿವರ್ತನೆ ದೋಷಗಳು:

openvino-dev ಅನ್ನು ನವೀಕರಿಸಿ; ಹೊಸ opset ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ; ONNX ಗ್ರಾಫ್ ಅನ್ನು ಸರಳಗೊಳಿಸಿ (onnxsim).

ಹೊಂದಾಣಿಕೆಯಾಗದ ಆಕಾರಗಳು:

--input_shape ಅನ್ನು ಒದಗಿಸಿ; ಡೈನಾಮಿಕ್ ಇನ್‌ಪುಟ್ ಬೆಂಬಲವನ್ನು ಖಚಿತಪಡಿಸಿ.

ನಿಧಾನ CPU ಕಾರ್ಯಕ್ಷಮತೆ:

FP16/INT8, async API ಬಳಸಿ, ಥ್ರೆಡ್‌ಗಳು/ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಟ್ಯೂನ್ ಮಾಡಿ; benchmark_app ಅನ್ನು ರನ್ ಮಾಡಿ.

GPU ಪತ್ತೆಯಾಗಲಿಲ್ಲ:

ಡ್ರೈವರ್‌ಗಳನ್ನು ನವೀಕರಿಸಿ; device="AUTO" ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ; ಬೆಂಬಲಿತ GPU ಗಳಿಗಾಗಿ ಡಾಕ್ಸ್ ಪರಿಶೀಲಿಸಿ.

ಕಲಿಕೆಯ ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಅಧಿಕೃತ ಡಾಕ್ಸ್

ಕೈಗೆಟುಕುವ ಟ್ಯುಟೋರಿಯಲ್‌ಗಳು, ನೋಟ್‌ಬುಕ್‌ಗಳು ಮತ್ತು ಸೆಟಪ್ ಗೈಡ್‌ಗಳಿಗಾಗಿ ಇಲ್ಲಿಂದ ಪ್ರಾರಂಭಿಸಿ: OpenVINO ಗೆಟ್ ಸ್ಟಾರ್ಟೆಡ್

API ಗಳು, ಮಾದರಿ ಆಪ್ಟಿಮೈಜರ್, POT, ಮಾದರಿಗಳಿಗಾಗಿ ಪೂರ್ಣ ದಸ್ತಾವೇಜು ಪೋರ್ಟಲ್: OpenVINO ಡಾಕ್ಸ್

ತ್ವರಿತ ಸ್ಥಾಪನೆಗಳು ಮತ್ತು ಹೊಂದಾಣಿಕೆಗಾಗಿ Pip ಅನುಸ್ಥಾಪನಾ ಉಲ್ಲೇಖ: PyPI openvino

OpenVINO ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಪ್ರೊಫೈಲಿಂಗ್ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ವಿಶ್ಲೇಷಣೆ: Intel VTune guide

ಅಂದಹಾಗೆ, ನೀವು ಆಪ್ಟಿಮೈಸೇಶನ್ ಮತ್ತು ನಿಯೋಜನೆಯ ಸುತ್ತ ತಾಂತ್ರಿಕ ವಿಷಯ, ಟ್ಯುಟೋರಿಯಲ್‌ಗಳು ಅಥವಾ ಆಂತರಿಕ ಪ್ಲೇಬುಕ್‌ಗಳನ್ನು ರಚಿಸುತ್ತಿದ್ದರೆ, Sider.AI ನಂತಹ ಪರಿಕರಗಳು ಕೋಡ್, ಬೆಂಚ್‌ಮಾರ್ಕ್‌ಗಳು ಮತ್ತು ನಿರೂಪಣೆಯನ್ನು ತ್ವರಿತವಾಗಿ ಒಟ್ಟಿಗೆ ಸೇರಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ - ಸಂಕೀರ್ಣ OpenVINO ಕಾರ್ಯಕ್ಷಮತೆ ಪ್ರಯೋಗಗಳು ಅಥವಾ ಬಹು-ಸಾಧನ ಹೋಲಿಕೆಗಳನ್ನು ದಾಖಲಿಸುವಾಗ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಮುಂದಿನ ಹಂತಗಳು

pip ನೊಂದಿಗೆ OpenVINO ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಮಾದರಿ IR ನಲ್ಲಿ benchmark_app ಅನ್ನು ರನ್ ಮಾಡಿ.

ತಿಳಿದಿರುವ ಉತ್ತಮ ONNX ಮಾದರಿಯನ್ನು ಪರಿವರ್ತಿಸಿ (ಉದಾಹರಣೆಗೆ, ResNet50) ಮತ್ತು ನಿಖರತೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ.

FP16 ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ, ನಂತರ POT ನೊಂದಿಗೆ INT8; ಲೇಟೆನ್ಸಿ ಮತ್ತು ಥ್ರೋಪುಟ್ ಅನ್ನು ಅಳೆಯಿರಿ.

device_name ಅನ್ನು CPU, GPU ಮತ್ತು AUTO ನಡುವೆ ಬದಲಾಯಿಸಿ; ನಿಮ್ಮ ಗುರಿ ಹಾರ್ಡ್‌ವೇರ್‌ಗೆ ಉತ್ತಮವಾದದ್ದನ್ನು ಆರಿಸಿ.

ನೀವು ಹೆಚ್ಚುವರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹಿಂಡಬೇಕಾದರೆ VTune ನೊಂದಿಗೆ ಪ್ರೊಫೈಲ್ ಮಾಡಿ.

ಪ್ರಮುಖ ಮುಖ್ಯಾಂಶಗಳು

OpenVINO AI ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ವೇಗವಾಗಿ, ಪೋರ್ಟಬಲ್ ಮತ್ತು ಹಾರ್ಡ್‌ವೇರ್-ಅರಿವು ಮಾಡಿಸುತ್ತದೆ.

IR ಗೆ ಪರಿವರ್ತನೆ ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ವಿಶ್ವಾಸಾರ್ಹ ವೇಗವರ್ಧನೆಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಕ್ವಾಂಟೈಸೇಶನ್ ಮತ್ತು ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ನೈಜ-ಸಮಯದ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ನಿಮ್ಮ ಉತ್ತಮ ಸ್ನೇಹಿತರು.

ಸಾಧನದ ನಮ್ಯತೆ (CPU/iGPU/NPU/AUTO) ಎಂದರೆ ಒಂದು ಕೋಡ್‌ಬೇಸ್, ಅನೇಕ ಗುರಿಗಳು.

FAQ

Q1: OpenVINO ಅನ್ನು ಸುಲಭವಾಗಿ ಸ್ಥಾಪಿಸುವುದು ಹೇಗೆ? ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ಬಳಸಿ ಮತ್ತು ರನ್ ಮಾಡಿ: pip install -U openvino openvino-dev. ತ್ವರಿತ ಇಂಪೋರ್ಟ್ ಚೆಕ್‌ನೊಂದಿಗೆ ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ನಿರ್ದಿಷ್ಟತೆಗಳಿಗಾಗಿ ಅಧಿಕೃತ ಗೆಟ್ ಸ್ಟಾರ್ಟೆಡ್ ಡಾಕ್ಸ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಿ.

Q2: ನನ್ನ ಮಾದರಿಯನ್ನು OpenVINO IR ಗೆ ಪರಿವರ್ತಿಸುವುದು ಹೇಗೆ? ನಿಮ್ಮ ಮಾದರಿಯನ್ನು ONNX ಗೆ ರಫ್ತು ಮಾಡಿ, ನಂತರ .xml/.bin IR ಫೈಲ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸಲು ಮಾದರಿ ಆಪ್ಟಿಮೈಜರ್ (mo) ಅನ್ನು ರನ್ ಮಾಡಿ. ಇನ್‌ಪುಟ್ ಆಕಾರಗಳನ್ನು ಒದಗಿಸಿ ಮತ್ತು ವೇಗ ಮತ್ತು ಮೆಮೊರಿ ಲಾಭಗಳಿಗಾಗಿ FP16 ಅನ್ನು ಪರಿಗಣಿಸಿ.

Q3: ಕೋಡ್ ಬದಲಾವಣೆಗಳಿಲ್ಲದೆ OpenVINO CPU ಮತ್ತು ಇಂಟಿಗ್ರೇಟೆಡ್ GPU ನಲ್ಲಿ ರನ್ ಆಗಬಹುದೇ? ಹೌದು. device_name="AUTO", "CPU" ಅಥವಾ "GPU" ನೊಂದಿಗೆ ಮಾದರಿಯನ್ನು ಕಂಪೈಲ್ ಮಾಡಿ. ನಿಮ್ಮ ಉಳಿದ ಕೋಡ್ ಅನ್ನು ಹಾಗೆಯೇ ಇಟ್ಟುಕೊಂಡು ನೀವು ಒಂದೇ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಸಾಧನಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು.

Q4: OpenVINO ನೊಂದಿಗೆ ಇನ್ಫರೆನ್ಸ್ ಅನ್ನು ನಾನು ಹೇಗೆ ವೇಗಗೊಳಿಸಬಹುದು? FP16 ಅಥವಾ INT8 ಕ್ವಾಂಟೈಸೇಶನ್, ಅಸಮಕಾಲಿಕ ಇನ್ಫರೆನ್ಸ್ API ಮತ್ತು ಥ್ರೆಡ್‌ಗಳು ಮತ್ತು ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಟ್ಯೂನ್ ಮಾಡಲು benchmark_app ಬಳಸಿ. ಆಳವಾದ ಬಾಟಲ್ನೆಕ್ ವಿಶ್ಲೇಷಣೆಗಾಗಿ VTune ನೊಂದಿಗೆ ಪ್ರೊಫೈಲ್ ಮಾಡಿ.

Q5: OpenVINO NLP ಮತ್ತು ಉತ್ಪಾದಕ ಮಾದರಿಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆಯೇ? ಹೌದು. ಇದು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ NLP ಮತ್ತು ಪ್ರಸರಣ ಮಾದರಿಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ; FP16 ಬಳಸಿ ಮತ್ತು ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳಿಗಾಗಿ INT8 ಅನ್ನು ಪರಿಗಣಿಸಿ. ಆಪ್ಟಿಮೈಸೇಶನ್ ನಂತರ ನಿಖರತೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ ಮತ್ತು ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಲೇಟೆನ್ಸಿಯನ್ನು ಅಳೆಯಿರಿ.