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 அனுமானத்திற்கான ஒரு நடைமுறை வழிகாட்டி

ஒவ்வொரு நாளும் பயன்படுத்தக்கூடிய வன்பொருளில் (Hardware) AI அனுமானத்தை (Inference) விரைவுபடுத்த முயற்சி செய்து, மெதுவான CPU இயக்கங்கள் மற்றும் GPU சிக்கல்களுக்கு இடையே சிக்கிக்கொண்டது போல் நீங்கள் எப்போதாவது உணர்ந்திருந்தால், OpenVINO ஒரு தீர்வாக இருக்கலாம். இன்டெல் (Intel) மூலம் கட்டமைக்கப்பட்ட இது, உங்களுடைய முழு ஸ்டாக்கையும் மீண்டும் எழுதாமல், CPU, ஒருங்கிணைந்த GPUகள் மற்றும் NPUகள் ஆகியவற்றில் இயங்கும் பொதுவான டீப் லேர்னிங் (Deep Learning) மாடல்களை விரைவான, பெயர்வுத்திறன் பயன்பாடுகளாக மாற்றுகிறது.

இந்த நடைமுறை மற்றும் தீர்வு சார்ந்த வழிகாட்டியில், OpenVINO-வை நிறுவுவது முதல் மாடல் மாற்றங்கள், மேம்படுத்தல் மற்றும் பயன்படுத்துதல் வரை எப்படி பயன்படுத்துவது என்பதைப் பற்றி நீங்கள் கற்றுக் கொள்வீர்கள். மேலும், பொதுவான வேலை முறைகளை உள்ளடக்கி, மாதிரி குறியீட்டைப் பகிர்ந்து கொள்வதுடன் முக்கியமான செயல்திறன் குறிப்புகளை எடுத்துக்காட்டுவோம்.

நீங்கள் ஒரு பார்வைக்கு கற்றுக்கொள்வது:

சில நிமிடங்களில் pip மூலம் OpenVINO-வை நிறுவவும்

Model Optimizer-ஐப் பயன்படுத்தி மாடல்களை மாற்றவும் (ONNX/TF/PyTorch export)

Python-ல் OpenVINO Runtime மூலம் அனுமானத்தை இயக்கவும்

Quantization மற்றும் பெஞ்ச்மார்க்கிங் (Benchmarking) கருவிகளைக் கொண்டு மேம்படுத்தவும்

குறைந்தபட்ச குறியீடு மாற்றங்களுடன் CPU, iGPU மற்றும் NPU முழுவதும் பயன்படுத்தவும்

OpenVINO என்றால் என்ன மற்றும் அதை ஏன் பயன்படுத்த வேண்டும்? OpenVINO என்பது இன்டெல் (Intel) வன்பொருள் மற்றும் அதற்கு அப்பால் AI மாடல்களை மேம்படுத்துவதற்கும் பயன்படுத்துவதற்கும் ஒரு திறந்த மூலக் கருவித்தொகுப்பாகும். நீங்கள் கணிக்கக்கூடிய செயல்திறன், குறைந்த தாமதம் மற்றும் பெயர்வுத்திறன் ஆகியவற்றை விரும்பும் போது இது உற்பத்தி அனுமானத்திற்கு மிகவும் சிறந்தது - உங்களுக்குத் தேவையில்லை என்றால் கனமான CUDA அமைப்பு தேவையில்லை. இது ONNX போன்ற பிரபலமான மாடல் வடிவங்களை ஆதரிக்கிறது மற்றும் பொதுவான கட்டமைப்புகளுடன் அழகாக ஒருங்கிணைக்கிறது.

முக்கிய நன்மைகள்:

வேகம்: மேம்படுத்தப்பட்ட கர்னல்கள் (Kernels) மற்றும் வரைபட மாற்றங்கள் CPUகள் மற்றும் GPUகளில் அனுமானத்தை விரைவுபடுத்துகின்றன.

பெயர்வுத்திறன்: ஒரே ஒரு வரி சாதனம் மாற்றத்துடன் CPU, iGPU, NPU ஆகியவற்றை ஒரே செயலி மூலம் இயக்க முடியும்.

திறன்: Quantization, மாடல் சுருக்கம் மற்றும் இயக்க நேர மேம்படுத்தல்கள் குறைந்த தாமதம் மற்றும் நினைவகத்தை வழங்குகின்றன.

எளிமை: சுத்தமான 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 Get Started ஆவணங்கள் மற்றும் தற்போதைய ஆவண மையத்துடன் தொடங்கவும். விரைவான pip நிறுவல் குறிப்பு மற்றும் இணக்கத்தன்மைக்கு, PyPI பக்கத்தைப் பார்க்கவும்.

படி 2: உங்கள் மாடலைத் தயார் செய்யவும் (ONNX பரிந்துரைக்கப்படுகிறது) OpenVINO, IR (Intermediate Representation) மாடல்களுடன் (.xml/.bin) சிறப்பாக இயங்குகிறது. பெரும்பாலான பயனர்கள் முதலில் ONNX-க்கு ஏற்றுமதி செய்கிறார்கள், பின்னர் Model Optimizer-ஐப் பயன்படுத்தி 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: Model Optimizer மூலம் OpenVINO IR ஆக மாற்றவும் Model Optimizer கட்டமைக்கப்பட்ட மாடல்களை 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 Runtime மூலம் அனுமானத்தை இயக்கவும் (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") # விருப்பங்கள்: "CPU", "GPU", "AUTO", "NPU" (ஆதரிக்கப்படும் இடத்தில்)

input_layer = compiled_model.inputs. நீங்கள் CPU ஹாட்ஸ்பாட்கள் (Hotspots) மற்றும் த்ரெட் பயன்பாட்டைப் (Thread utilization) பற்றி தெரிந்து கொள்ள விரும்பினால், Intel VTune Profiler OpenVINO பயன்பாடுகளுக்கு குறிப்பாக ஒரு செய்முறையைக் கொண்டுள்ளது.

படி 6: குவாண்டிசேஷன் (Quantization) மூலம் மேம்படுத்தவும் (INT8) பயிற்சிக்குப் பிந்தைய குவாண்டிசேஷன் (PTQ) மாடல் அளவைக் குறைத்து, குறைந்தபட்ச துல்லிய இழப்புடன் வேகத்தை அதிகரிக்கும்:

openvino-dev உடன் சேர்க்கப்பட்டுள்ள உள்ளமைக்கப்பட்ட POTஐப் (Post-Training Optimization Tool) பயன்படுத்தவும்.

உங்களின் உற்பத்தி தரவை ஒத்த ஒரு சிறிய அளவுத்திருத்தத் தரவுத்தொகுப்பை வழங்கவும்.

ஒரு INT8 IR-ஐ ஏற்றுமதி செய்து அதை பெஞ்ச்மார்க் (Benchmark) செய்யவும். துல்லியம் போதுமானதாக இல்லை என்றால், கலப்பு துல்லியம் (INT8 + FP16) அல்லது தேர்ந்தெடுக்கப்பட்ட குவாண்டிசேஷனை முயற்சிக்கவும்.

பொதுவான குவாண்டிசேஷன் செயல்முறை:

பிரதிநிதித்துவ மாதிரிகளை சேகரிக்கவும்.

POT குவாண்டிசேஷன் அளவுருக்களை உள்ளமைக்கவும் (ஒரு டென்சார் (Per-tensor) vs ஒரு சேனல், சமச்சீர் vs சமச்சீரற்ற).

அளவுத்திருத்தம் மற்றும் சரிபார்ப்பை இயக்கவும்.

KPIகளை ஒப்பிடுக: தாமதம், செயல்திறன், டாப்-1/டாப்-5 துல்லியம் அல்லது பணி சார்ந்த அளவீடுகள்.

படி 7: சரியான வழியில் முன்தயாரிப்பை கையாளவும் மாடல் I/O எதிர்பார்ப்புகள் பெரும்பாலும் வேறுபடுகின்றன. உங்கள் முன்தயாரிப்பை தரப்படுத்தவும்:

எதிர்பார்க்கப்படும் அளவிற்கு மறுஅளவிடுதல்/மையப்பகுதி-பயிர் செய்தல் (எ.கா., 224×224)

சேனல் வரிசை (RGB vs BGR)

இயல்பாக்கம் (சராசரி/திட்ட விலகல்)

அமைப்பு (NCHW vs NHWC)

OpenVINO Runtime-ல் 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 அனுமானத்தை பைப்லைன் (Pipeline) செய்யலாம். அதிக FPS மற்றும் குறைந்த தாமதத்தை பராமரிக்க ஒத்திசைவற்ற அனுமானக் கோரிக்கைகள் மற்றும் தொகுதி செயலாக்கத்தைப் பயன்படுத்தவும்.

உதவிக்குறிப்புகள்:

ஒத்திசைவற்ற API ஐப் பயன்படுத்தவும்: பல பறக்கும் கோரிக்கைகள் CPUகளின் செயல்திறனை மேம்படுத்துகின்றன.

உங்கள் மாடல் வெக்டரைஸ்டு (Vectorized) செயலாக்கத்திலிருந்து பயனடைந்தால் பிரேம்களை தொகுக்கவும்.

மல்டி-கோர் (Multi-core) அமைப்புகளில் கணிக்கக்கூடிய தாமதத்திற்கு த்ரெட்களை பின் (Pin) செய்யவும் அல்லது ஸ்ட்ரீம்களை சரிசெய்யவும்.

படி 9: சாதனங்களில் புத்திசாலித்தனமாக பயன்படுத்தவும் OpenVINOவின் சூப்பர் பவர்களில் ஒன்று தடையற்ற சாதனம் இலக்கு:

CPU: வலுவான இயல்புநிலை; பரவலாகக் கிடைக்கிறது; எட்ஜ் (Edge) மற்றும் சர்வர் (Server)க்கு சிறந்தது.

GPU (ஒருங்கிணைக்கப்பட்டது): தனித்துவமான GPU இல்லாமல் நல்ல முடுக்கம்; டிரைவர் தரம் முக்கியமானது.

AUTO: இயக்க நேரம் தேர்வு செய்யட்டும்; பெயர்வுத்திறன் பயன்பாடுகளுக்கு சிறந்தது.

ஹெட்டிரோ (Hetero) செயலாக்கம்: நன்மை பயக்கும் இடங்களில் அடுக்குகளை சாதனங்களில் பிரிக்கவும்.

பெயர்வுத்திறனுக்காக AUTO உடன் தொடங்கவும். உங்களுக்கு இறுக்கமான கட்டுப்பாடு தேவைப்பட்டால், CPU vs GPU-வை பெஞ்ச்மார்க் செய்து, மாடலுக்கு ஏற்ப முடிவு செய்யுங்கள்.

பணி வாரியாக நடைமுறை எடுத்துக்காட்டுகள்

வகைப்பாடு (ResNet/ViT):

ONNX → IR ஐ மாற்றவும்; FP16 ஐப் பயன்படுத்தவும்; AUTO சாதனம்; ஒத்திசைவற்ற அனுமானம்.

முன்தயாரிப்பு: மறுஅளவிடுதல், மையப்பகுதி-பயிர் செய்தல், இயல்பாக்கு.

சிறிய துல்லிய குறைப்புடன் >2× செயல்திறன் உங்களுக்குத் தேவைப்பட்டால் குவாண்டிஸ் (Quantize) செய்யவும்.

பொருள் கண்டறிதல் (YOLO/SSD):

டைனமிக் (Dynamic) வடிவங்கள் கையாளப்படுவதை உறுதிசெய்யவும் அல்லது உள்ளீட்டு அளவை சரிசெய்யவும்.

வெளியீடுகளைப் பார்ஸ் (Parse) செய்யவும்: பெட்டிகளை டிகோட் (Decode) செய்யவும், NMS கிளையன்ட்-பக்கத்தைப் பயன்படுத்தவும்.

CPUகளில் நிகழ்நேரத்தை இயக்க எட்ஜ் (Edge) பயன்பாடுகளுக்கு INT8 ஐப் பயன்படுத்தவும்.

சொற்பொருள் பிரிவு:

பெரிய படங்களுக்கு டைலிங் பயன்படுத்தவும்.

வெக்டரைஸ்டு (Vectorized) NumPy உடன் பிந்தைய செயலாக்கத்தை மேம்படுத்தவும் (argmax, வண்ண மேப்பிங்).

NLP (BERT-போன்றது):

கிடைக்கும்போது OpenVINO-text மேம்படுத்தல்களைப் பயன்படுத்தவும்.

டோக்கனைசேஷன் (Tokenization) பைப்லைன்களை தற்காலிக சேமிப்பில் வைக்கவும்; டிரான்ஸ்ஃபார்மர்களுக்கு INT8 ஐக் கவனியுங்கள்.

நிலையான பரவல் / ஜெனரேட்டிவ்:

FP16 ஐ இலக்காகக் கொள்ளவும்; திட்டமிடல்/அனுமான சுழல்களை மேம்படுத்தவும்.

புரோஃபைலிங் (Profiling) உதவுகிறது - பரவல் பைப்லைன்கள் பல-நிலை.

சோதனை மற்றும் சரிபார்ப்பு சரிபார்ப்பு பட்டியல்

ஒரு சிறிய சோதனைத் தொகுப்பிற்கான அடிப்படை வெளியீடுகளுடன் (PyTorch/TF/ONNXRuntime) வெளியீடுகளை ஒப்பிடுக.

FP16/INT8 மாற்றங்களுக்குப் பிறகு எண் வேறுபாடுகளைச் சரிபார்க்கவும்.

எதிர்பார்க்கப்படும் சுமையின் கீழ் தாமதம் p50/p95 மற்றும் செயல்திறனை அளவிடவும்.

அழுத்த சோதனை: நினைவகம் அல்லது த்ரெடிங் சிக்கல்களைப் பிடிக்க நீண்ட நேரம் இயக்கவும்.

சரிசெய்தல் விரைவான பதில்கள்

Model Optimizer உடன் மாற்ற பிழைகள்:

openvino-dev ஐப் புதுப்பிக்கவும்; புதிய opset ஐ முயற்சிக்கவும்; ONNX வரைபடத்தை எளிதாக்கவும் (onnxsim).

பொருந்தாத வடிவங்கள்:

--input_shape ஐ வழங்கவும்; டைனமிக் உள்ளீட்டு ஆதரவை உறுதிப்படுத்தவும்.

மெதுவான CPU செயல்திறன்:

FP16/INT8, ஒத்திசைவற்ற API, ட்யூன் (Tune) த்ரெட்கள்/ஸ்ட்ரீம்களைப் பயன்படுத்தவும்; benchmark_app ஐ இயக்கவும்.

GPU கண்டறியப்படவில்லை:

டிரைவர்களைப் புதுப்பிக்கவும்; device="AUTO" ஐ முயற்சிக்கவும்; ஆதரிக்கப்படும் GPUகளுக்கான ஆவணங்களைச் சரிபார்க்கவும்.

கற்றல் வளங்கள் மற்றும் அதிகாரப்பூர்வ ஆவணங்கள்

கையடக்கப் பயிற்சிகள், நோட்புக்குகள் மற்றும் அமைவு வழிகாட்டிகளுக்கு இங்கே தொடங்கவும்: OpenVINO Get Started

APIகள், Model Optimizer, POT, மாதிரிகளுக்கான முழு ஆவண போர்டல்: OpenVINO Docs

விரைவான நிறுவல்கள் மற்றும் இணக்கத்தன்மைக்கான Pip நிறுவல் குறிப்பு: PyPI openvino

OpenVINO பயன்பாடுகளுக்கான புரோஃபைலிங் (Profiling) மற்றும் செயல்திறன் பகுப்பாய்வு: Intel VTune guide

மேலும், நீங்கள் தொழில்நுட்ப உள்ளடக்கம், பயிற்சிகள் அல்லது மேம்படுத்தல் மற்றும் பயன்படுத்துதல் குறித்த உள் விளையாட்டுப் புத்தகங்களை உருவாக்குகிறீர்கள் என்றால், Sider.AI இன் எழுதும் பணி இடம் போன்ற கருவிகள் குறியீடு, பெஞ்ச்மார்க்குகள் (Benchmarks) மற்றும் விவரணைகளை ஒன்றாக இணைக்க உதவும்—சிக்கலான OpenVINO செயல்திறன் சோதனைகள் அல்லது பல சாதன ஒப்பீடுகளை ஆவணப்படுத்தும்போது பயனுள்ளதாக இருக்கும்.

செயல்படுத்தக்கூடிய அடுத்த நடவடிக்கைகள்

pip உடன் OpenVINO ஐ நிறுவி, மாதிரி IR இல் benchmark_app ஐ இயக்கவும்.

தெரிந்த-நல்ல ONNX மாடலை (எ.கா., ResNet50) மாற்றி, துல்லியத்தை சரிபார்க்கவும்.

FP16 ஐ முயற்சிக்கவும், பின்னர் POT உடன் INT8; தாமதம் மற்றும் செயல்திறனை அளவிடவும்.

CPU, GPU மற்றும் AUTO இடையே device_name ஐ மாற்றவும்; உங்கள் இலக்கு வன்பொருளுக்கு சிறந்ததைத் தேர்ந்தெடுக்கவும்.

கூடுதல் செயல்திறனைப் பெற VTune உடன் புரோஃபைல் (Profile) செய்யவும்.

முக்கிய குறிப்புகள்

OpenVINO AI அனுமானத்தை வேகமாகவும், பெயர்வுத்திறன் மற்றும் வன்பொருள்-அறிவோடு உருவாக்குகிறது.

IR ஆக மாற்றுதல் மற்றும் சிறந்த முன்தயாரிப்பு நம்பகமான வேகத்தை அளிக்கிறது.

நிகழ்நேர செயல்திறனுக்கான குவாண்டிசேஷன் (Quantization) மற்றும் ஒத்திசைவற்ற செயலாக்கம் உங்கள் சிறந்த நண்பர்கள்.

சாதன நெகிழ்வுத்தன்மை (CPU/iGPU/NPU/AUTO) ஒரு குறியீடு தளம், பல இலக்குகள் என்று பொருள்.

FAQ

Q1:OpenVINO வை எளிதாக நிறுவுவது எப்படி? மெய்நிகர் சூழலைப் பயன்படுத்தி இயக்கவும்: pip install -U openvino openvino-dev. விரைவான இறக்குமதி சோதனையுடன் சரிபார்த்து, இயங்குதள விவரக்குறிப்புகளுக்கு அதிகாரப்பூர்வ Get Started ஆவணங்களைப் பார்க்கவும்.

Q2:OpenVINO IR க்கு எனது மாடலை எவ்வாறு மாற்றுவது? உங்கள் மாடலை ONNX க்கு ஏற்றுமதி செய்யவும், பின்னர் .xml/.bin IR கோப்புகளை உருவாக்க Model Optimizer (mo) ஐ இயக்கவும். உள்ளீட்டு வடிவங்களை வழங்கி வேகம் மற்றும் நினைவக ஆதாயங்களுக்காக FP16 ஐக் கவனியுங்கள்.

Q3:குறியீடு மாற்றங்கள் இல்லாமல் OpenVINO CPU மற்றும் ஒருங்கிணைந்த GPU இல் இயங்க முடியுமா? ஆம். device_name="AUTO", "CPU" அல்லது "GPU" உடன் மாடலை கம்பைல் (Compile) செய்யவும். உங்கள் குறியீட்டின் எஞ்சிய பகுதியை அப்படியே வைத்திருக்கும்போது, ஒற்றை அளவுருவுடன் சாதனங்களை மாற்றலாம்.

Q4:OpenVINO உடன் அனுமானத்தை எவ்வாறு விரைவுபடுத்துவது? FP16 அல்லது INT8 குவாண்டிசேஷன், ஒத்திசைவற்ற அனுமான API மற்றும் த்ரெட்கள் மற்றும் ஸ்ட்ரீம்களை ட்யூன் (Tune) செய்ய benchmark_app ஐப் பயன்படுத்தவும். ஆழமான நெரிசல் பகுப்பாய்விற்கு VTune உடன் புரோஃபைல் (Profile) செய்யவும்.

Q5:OpenVINO NLP மற்றும் ஜெனரேட்டிவ் (Generative) மாடல்களை ஆதரிக்கிறதா? ஆம். இது NLP மற்றும் டிஃப்யூஷன் (Diffusion) மாடல்களின் வரம்பை ஆதரிக்கிறது; FP16 ஐப் பயன்படுத்தவும் மற்றும் டிரான்ஸ்ஃபார்மர்களுக்கு INT8 ஐக் கவனியுங்கள். மேம்படுத்தலுக்குப் பிறகு துல்லியத்தை சரிபார்த்து, சுமையின் கீழ் தாமதத்தை அளவிடவும்.