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 અને અહીં સુધી કે NPUs પર ચાલતી ઝડપી, પોર્ટેબલ એપ્લિકેશન્સમાં ફેરવે છે—તમારા આખા સ્ટેકને ફરીથી લખ્યા વિના.

આ વ્યવહારુ, સોલ્યુશન-ઓરિએન્ટેડ માર્ગદર્શિકામાં, તમે OpenVINO નો ઉપયોગ કેવી રીતે કરવો તે બરાબર શીખી શકશો—ઇન્સ્ટોલેશનથી લઈને મોડેલ કન્વર્ઝન, ઓપ્ટિમાઇઝેશન અને ડિપ્લોયમેન્ટ સુધી. અમે સૌથી સામાન્ય વર્કફ્લોને આવરી લઈશું, ઉદાહરણ કોડ શેર કરીશું અને મહત્વપૂર્ણ પરફોર્મન્સ ટિપ્સને હાઇલાઇટ કરીશું.

તમે એક નજરમાં શું શીખશો:

pip વડે મિનિટોમાં OpenVINO ઇન્સ્ટોલ કરો

મોડેલ ઓપ્ટિમાઇઝરનો ઉપયોગ કરીને મોડેલ્સ (ONNX/TF/PyTorch એક્સપોર્ટ) કન્વર્ટ કરો

Python માં OpenVINO રનટાઇમ સાથે અનુમાન ચલાવો

ક્વોન્ટિઝેશન અને બેન્ચમાર્કિંગ ટૂલ્સ સાથે ઑપ્ટિમાઇઝ કરો

ન્યૂનતમ કોડ ફેરફારો સાથે CPU, iGPU અને NPU માં ડિપ્લોય કરો

OpenVINO શું છે અને તેનો ઉપયોગ શા માટે કરવો? OpenVINO એ Intel હાર્ડવેર અને તેનાથી આગળ AI મોડેલ્સને ઑપ્ટિમાઇઝ અને ડિપ્લોય કરવા માટેનું ઓપન-સોર્સ ટૂલકીટ છે. તે ખાસ કરીને પ્રોડક્શન અનુમાન માટે મજબૂત છે જ્યારે તમને અનુમાનિત પરફોર્મન્સ, ઓછી લેટન્સી અને પોર્ટેબિલિટી જોઈતી હોય—જો તમને તેની જરૂર ન હોય તો કોઈ ભારે CUDA સેટઅપની જરૂર નથી. તે ONNX જેવા લોકપ્રિય મોડેલ ફોર્મેટને સપોર્ટ કરે છે અને સામાન્ય ફ્રેમવર્ક સાથે સુઘડ રીતે સંકલિત થાય છે.

મુખ્ય ફાયદાઓ:

ઝડપ: ઑપ્ટિમાઇઝ્ડ કર્નલો અને ગ્રાફ ટ્રાન્સફોર્મેશન CPU અને GPU પર અનુમાનને ઝડપી બનાવે છે.

પોર્ટેબિલિટી: એક જ એપ્લિકેશન CPU, iGPU, NPU ને એક-લાઇન ડિવાઇસ ફેરફાર સાથે ટાર્ગેટ કરી શકે છે.

કાર્યક્ષમતા: ક્વોન્ટિઝેશન, મોડેલ કમ્પ્રેશન અને રનટાઇમ ઓપ્ટિમાઇઝેશન લેટન્સી અને મેમરી ઘટાડે છે.

સરળતા: ક્લીન Python API અને CLI ટૂલ્સ તેને શિખાઉ માણસ માટે અનુકૂળ બનાવે છે.

પગલું 1: OpenVINO ઇન્સ્ટોલ કરો મોટાભાગના વપરાશકર્તાઓ માટે, pip દ્વારા સૌથી ઝડપી રસ્તો છે:

ખાતરી કરો કે Python 3.9–3.12 ઇન્સ્ટોલ કરેલું છે (64-bit).

વર્ચ્યુઅલ એન્વાયર્નમેન્ટ બનાવો અને સક્રિય કરો (ભલામણ કરેલ).

ઇન્સ્ટોલ કરો: pip install -U openvino openvino-dev

ચકાસો: python -c "import openvino; print(openvino.version)"

જો તમે સત્તાવાર સ્ટેપ-બાય-સ્ટેપ સંસાધનો પસંદ કરો છો અથવા સંસ્કરણ-વિશિષ્ટ નોંધો અને પ્લેટફોર્મ સપોર્ટને ટ્રેક કરવા માંગો છો, તો OpenVINO Get Started ડોક્સ અને વર્તમાન ડોક્યુમેન્ટેશન હબથી શરૂઆત કરો. ઝડપી 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" (જ્યાં સપોર્ટેડ હોય ત્યાં)

input_layer = compiled_model.inputs. જો તમે CPU હોટસ્પોટ્સ અને થ્રેડ યુટિલાઇઝેશનને પ્રોફાઇલ કરવા માંગતા હો, તો Intel VTune Profiler પાસે ખાસ કરીને OpenVINO એપ્સ માટે રેસીપી છે.

પગલું 6: ક્વોન્ટિઝેશન (INT8) સાથે ઑપ્ટિમાઇઝ કરો પોસ્ટ-ટ્રેનિંગ ક્વોન્ટિઝેશન (PTQ) મોડેલનું કદ ઘટાડી શકે છે અને ન્યૂનતમ ચોકસાઈ નુકસાન સાથે ઝડપ વધારી શકે છે:

openvino-dev સાથે સમાવિષ્ટ બિલ્ટ-ઇન POT (પોસ્ટ-ટ્રેનિંગ ઓપ્ટિમાઇઝેશન ટૂલ) નો ઉપયોગ કરો.

તમારા પ્રોડક્શન ડેટાને મળતો નાનો કેલિબ્રેશન ડેટાસેટ પ્રદાન કરો.

INT8 IR ને એક્સપોર્ટ કરો અને તેનું બેન્ચમાર્ક કરો. જો ચોકસાઈ અપૂરતી હોય, તો મિશ્ર ચોકસાઈ (INT8 + FP16) અથવા પસંદગીયુક્ત ક્વોન્ટિઝેશનનો પ્રયાસ કરો.

સામાન્ય ક્વોન્ટિઝેશન ફ્લો:

પ્રતિનિધિત્વ નમૂનાઓ એકત્રિત કરો.

POT ક્વોન્ટિઝેશન પરિમાણોને ગોઠવો (પર-ટેન્સર વિરુદ્ધ પર-ચેનલ, સમપ્રમાણ વિરુદ્ધ અસમપ્રમાણ).

કેલિબ્રેશન અને વેલિડેશન ચલાવો.

KPI ની તુલના કરો: લેટન્સી, થ્રુપુટ, ટોપ-1/ટોપ-5 ચોકસાઈ અથવા કાર્ય-વિશિષ્ટ મેટ્રિક્સ.

પગલું 7: પ્રીપ્રોસેસિંગને યોગ્ય રીતે હેન્ડલ કરો મોડેલ I/O અપેક્ષાઓ ઘણીવાર અલગ હોય છે. તમારા પ્રીપ્રોસેસિંગને પ્રમાણિત કરો:

અપેક્ષિત કદમાં રિસાઇઝ/સેન્ટર-ક્રોપ કરો (દા.ત., 224×224)

ચેનલ ઓર્ડર (RGB વિરુદ્ધ BGR)

સામાન્યકરણ (સરેરાશ/std)

લેઆઉટ (NCHW વિરુદ્ધ 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 વિરુદ્ધ GPU નું બેન્ચમાર્ક કરો અને મોડેલ દીઠ નક્કી કરો.

કાર્ય દ્વારા વ્યવહારુ ઉદાહરણો

વર્ગીકરણ (ResNet/ViT):

ONNX → IR કન્વર્ટ કરો; FP16 નો ઉપયોગ કરો; AUTO ડિવાઇસ; એસિંક અનુમાન.

પ્રીપ્રોસેસિંગ: રિસાઇઝ, સેન્ટર-ક્રોપ, સામાન્ય કરો.

જો તમને નાના ચોકસાઈ ડ્રોપ સાથે >2× થ્રુપુટની જરૂર હોય તો ક્વોન્ટાઇઝ કરો.

ઑબ્જેક્ટ ડિટેક્શન (YOLO/SSD):

ખાતરી કરો કે ડાયનેમિક આકાર હેન્ડલ કરવામાં આવે છે અથવા ઇનપુટ કદને ઠીક કરો.

આઉટપુટને પાર્સ કરો: બોક્સને ડીકોડ કરો, ક્લાયંટ-સાઇડ પર NMS લાગુ કરો.

CPU પર રીઅલ-ટાઇમ હિટ કરવા માટે એજ ડિપ્લોયમેન્ટ માટે INT8 નો ઉપયોગ કરો.

સિમેન્ટિક સેગમેન્ટેશન:

મોટી છબીઓ માટે ટાઇલિંગનો ઉપયોગ કરો.

વેક્ટરરાઇઝ્ડ NumPy સાથે પોસ્ટ-પ્રોસેસિંગ (argmax, કલર મેપિંગ) ને ઑપ્ટિમાઇઝ કરો.

NLP (BERT-જેવા):

જ્યારે ઉપલબ્ધ હોય ત્યારે OpenVINO-text ઓપ્ટિમાઇઝેશનનો ઉપયોગ કરો.

ટોકનાઇઝેશન પાઇપલાઇન્સને કેશ કરો; ટ્રાન્સફોર્મર્સ માટે 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" અજમાવો; સપોર્ટેડ GPUs માટે ડોક્સ તપાસો.

શીખવાના સંસાધનો અને સત્તાવાર ડોક્સ

હેન્ડ્સ-ઓન ટ્યુટોરિયલ્સ, નોટબુક્સ અને સેટઅપ માર્ગદર્શિકાઓ માટે અહીંથી પ્રારંભ કરો: OpenVINO Get Started

APIs, મોડેલ ઓપ્ટિમાઇઝર, POT, નમૂનાઓ માટે સંપૂર્ણ ડોક્યુમેન્ટેશન પોર્ટલ: OpenVINO Docs

ઝડપી ઇન્સ્ટોલેશન અને સુસંગતતા માટે Pip ઇન્સ્ટોલેશન સંદર્ભ: PyPI openvino

OpenVINO એપ્સ માટે પ્રોફાઇલિંગ અને પરફોર્મન્સ એનાલિસિસ: Intel VTune guide

માર્ગ દ્વારા, જો તમે ઑપ્ટિમાઇઝેશન અને ડિપ્લોયમેન્ટની આસપાસ તકનીકી સામગ્રી, ટ્યુટોરિયલ્સ અથવા આંતરિક પ્લેબુકનો મુસદ્દો તૈયાર કરી રહ્યાં છો, તો Sider.AI જેવી સાધનોની લેખન કાર્યસ્થળ તમને કોડ, બેંચમાર્ક્સ અને વર્ણનને ઝડપથી એકસાથે જોડવામાં મદદ કરી શકે છે—જટિલ OpenVINO પરફોર્મન્સ પ્રયોગો અથવા મલ્ટી-ડિવાઇસ સરખામણીઓનું દસ્તાવેજીકરણ કરતી વખતે ઉપયોગી.

અમલમાં મૂકવા યોગ્ય આગલા પગલાં

pip સાથે OpenVINO ઇન્સ્ટોલ કરો અને નમૂના IR પર benchmark_app ચલાવો.

જાણીતા-સારા ONNX મોડેલ (દા.ત., ResNet50) કન્વર્ટ કરો અને ચોકસાઈને વેલિડેટ કરો.

FP16, પછી POT સાથે INT8 અજમાવો; લેટન્સી અને થ્રુપુટને માપો.

CPU, GPU અને AUTO વચ્ચે device_name સ્વિચ કરો; તમારા લક્ષ્ય હાર્ડવેર માટે શ્રેષ્ઠ પસંદ કરો.

જો તમારે વધારાની કામગીરીને સ્ક્વિઝ કરવાની જરૂર હોય તો VTune સાથે પ્રોફાઇલ કરો.

મુખ્ય ટેકઅવેઝ

OpenVINO AI અનુમાનને ઝડપી, પોર્ટેબલ અને હાર્ડવેર-જાગૃત બનાવે છે.

IR માં રૂપાંતરણ વત્તા સ્માર્ટ પ્રીપ્રોસેસિંગ વિશ્વસનીય સ્પીડઅપ્સ આપે છે.

ક્વોન્ટિઝેશન અને એસિંક એક્ઝેક્યુશન એ રીઅલ-ટાઇમ કામગીરી માટે તમારા શ્રેષ્ઠ મિત્રો છે.

ઉપકરણની સુગમતા (CPU/iGPU/NPU/AUTO) એટલે એક કોડબેઝ, ઘણા લક્ષ્યો.

FAQ

Q1: OpenVINO ને સૌથી સરળ રીતે કેવી રીતે ઇન્સ્ટોલ કરવું? વર્ચ્યુઅલ એન્વાયર્નમેન્ટનો ઉપયોગ કરો અને ચલાવો: pip install -U openvino openvino-dev. ઝડપી આયાત તપાસ સાથે ચકાસો અને પ્લેટફોર્મ વિશિષ્ટતાઓ માટે સત્તાવાર Get Started ડોક્સની સલાહ લો.

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 નો વિચાર કરો. ઑપ્ટિમાઇઝેશન પછી ચોકસાઈને વેલિડેટ કરો અને ભાર હેઠળ લેટન્સીને માપો.