1. 🏁 परिचय और सीएलआई की खास जानकारी
LiteRT CLI 101 के इस कोडलैब में आपका स्वागत है! इस गाइड में, एनवायरमेंट सेटअप करने से लेकर ऑप्टिमाइज़ की गई एज इंटेलिजेंस को डिप्लॉय करने तक, हर चरण के बारे में बताया गया है.
🌟 बैकग्राउंड
एज एआई के लिए, जटिल न्यूरल मॉडल को सीधे तौर पर मोबाइल फ़ोन, पहनने लायक डिवाइसों, और एम्बेड किए गए हार्डवेयर पर लाना ज़रूरी होता है.
- LiteRT (पहले इसे TensorFlow लाइट / TFLite कहा जाता था) Google का एक ऐसा फ़्रेमवर्क है जो उपयोगकर्ता के डिवाइस पर मौजूद होता है. यह एज प्लैटफ़ॉर्म पर हाई-परफ़ॉर्मेंस वाले एमएल और जेन एआई को डिप्लॉय करने के लिए बनाया गया है. इसके लिए, यह फ़्रेमवर्क बेहतर कन्वर्ज़न, रनटाइम, और ऑप्टिमाइज़ेशन की सुविधा देता है.
- LiteRT CLI, Google AI Edge स्टैक को एक स्टैंडअलोन शेल कमांड (
litert) में इंटिग्रेट करता है. इससे LiteRT से जुड़े डेवलपमेंट वर्कफ़्लो को आसान बनाया जा सकता है. जैसे, अलग-अलग प्लैटफ़ॉर्म (डेस्कटॉप, मोबाइल या क्लाउड) पर अलग-अलग हार्डवेयर (सीपीयू / जीपीयू / एनपीयू) पर LiteRT (TFLite) मॉडल को बदलना, क्वांटाइज़ करना, कंपाइल करना, चलाना, बेंचमार्क करना, और विज़ुअलाइज़ करना.
2. 🔄 बुनियादी वर्कफ़्लो: कन्वर्ज़न, क्वांटाइज़, और रन
इस सेक्शन में, LiteRT CLI की मदद से Edge AI मॉडलिंग के पूरे लाइफ़साइकल को लागू करते हैं: PyTorch मॉडल रैपर ➔ ट्रेसिंग कन्वर्ज़न ➔ मॉडल क्वांटाइज़ेशन ➔ डेस्कटॉप इन्फ़रेंस ➔ परफ़ॉर्मेंस बेंचमार्क.
📝 पहला चरण: PyTorch मॉडल रैपर स्क्रिप्ट तैयार करना
अपनी मौजूदा डायरेक्ट्री में resnet18.py बनाएं. यह डाइनैमिक ट्रेसिंग हुक दिखाता है, ताकि ग्राफ़ बिल्डर शेप कैप्चर कर सके:
import torch
import torchvision
def get_model(batch_size: int = 1) -> torch.nn.Module:
model = torchvision.models.resnet18(
weights=torchvision.models.ResNet18_Weights.IMAGENET1K_V1
)
model.eval()
return model
def get_args(batch_size: int = 1) -> tuple[torch.Tensor, ...]:
return (torch.randn(batch_size, 3, 224, 224),)
🔄 दूसरा चरण: LiteRT Torch का इस्तेमाल करके, PyTorch मॉडल को LiteRT में बदलना
स्टैंडर्ड Float32 .tflite टारगेट मॉडल बनाने के लिए, LiteRT Torch कनवर्टर को शुरू करें:
# Convert PyTorch source to LiteRT
litert convert resnet18.py --output resnet18
# Verify target was exported
ls -lh resnet18/resnet18.tflite
📉 तीसरा चरण: वज़न को INT8 में बदलना
साइज़ को ~4 गुना तक कम करने के लिए, डाइनैमिक और सिर्फ़ वज़न वाले रेसिपी कार्ड लागू करें:
# 1. Dynamic Range Quantization (Dynamic activations + static INT8 weights)
litert quantize resnet18/resnet18.tflite \
--recipe dynamic_wi8_afp32 \
--output resnet18/resnet18_int8_dynamic.tflite
# 2. Weight-Only Quantization (Float32 activations + static INT8 weights)
litert quantize resnet18/resnet18.tflite \
--recipe weight_only_wi8_afp32 \
--output resnet18/resnet18_int8_weight_only.tflite
🚀 चौथा चरण: अनुमान लगाने की प्रोसेस को स्थानीय तौर पर चलाना
परफ़ॉर्मेंस ब्लॉक की पुष्टि करने के लिए, डमी इनपुट पैरामीटर के साथ टेस्ट ऑपरेशन चलाएं:
# Run original Float32 model inference
litert run resnet18/resnet18.tflite --desktop --cpu
# Run optimized Dynamic INT8 model inference
litert run resnet18/resnet18_int8_dynamic.tflite --cpu --iterations 1
📊 पांचवां चरण: मॉडल की परफ़ॉर्मेंस की तुलना करना
ज़्यादा सटीक मेट्रिक मेज़र करें. इनमें औसत लेटेंसी, शुरुआत में आने वाली लागत, सीपीयू एक्ज़ीक्यूशन थ्रूपुट, और डाइनैमिक ऐक्टिव मेमोरी फ़ुटप्रिंट शामिल हैं:
# Benchmark original Float32 model
litert benchmark resnet18/resnet18.tflite --desktop --cpu
# Benchmark optimized Dynamic range INT8 model
litert benchmark resnet18/resnet18_int8_dynamic.tflite --desktop --cpu
3. 🔌 लोकल एनवायरमेंट सेटअप करना और उसकी पुष्टि करना
चलिए, आपके वर्कस्टेशन (macOS या Linux) पर एक अलग और साफ़ सैंडबॉक्स बनाते हैं
🔌 पहला विकल्प: बहुत कम समय में सेटअप करना (uv)
uv का इस्तेमाल करके, लाइब्रेरी को कुछ ही सेकंड में अलग किया जा सकता है. इससे एनवायरमेंट कैश मेमोरी से जुड़े टकराव ठीक हो जाते हैं.
# Create active workspace sandbox
uv venv --clear --python=3.13 --seed
source .venv/bin/activate
# Install litert-cli from pypi
uv pip install litert-cli-nightly
🐍 दूसरा विकल्प: स्टैंडर्ड सेटअप (पीआईपी)
अगर uv मौजूद नहीं है, तो स्टैंडर्ड Python वर्चुअल एनवायरमेंट कॉन्फ़िगरेशन का इस्तेमाल करें:
# Create active workspace sandbox
python3 -m venv .venv
source .venv/bin/activate
# Install litert-cli from pypi
pip install --upgrade pip setuptools wheel
pip install litert-cli-nightly
🛠️ विकल्प C: बदलाव किया जा सकने वाला लोकल सेटअप
अगर आपको सीधे तौर पर रिपॉज़िटरी सोर्स डायरेक्ट्री क्लोन में डेवलपमेंट या टेस्टिंग करनी है, तो:
# Create active workspace sandbox
uv venv --clear --python=3.13 --seed
source .venv/bin/activate
# Install from local directory root
uv pip install -e .
🔍 पुष्टि करने की सुविधा को सेटअप करना
पुष्टि करें कि आपका पाथ, litert कमांड को सही तरीके से रूट करता है:
litert --help
💡 मॉडल रेफ़रंस कैटलॉग (model-ref)
स्क्रिप्ट और डेवलपमेंट को बेहतर बनाने के लिए, LiteRT CLI एक मॉडल कैटलॉग लागू करता है:
- फ़ॉर्मैट: डाउनलोड किए गए या इंपोर्ट किए गए मॉडल को कोई यूनीक नाम (उर्फ़) असाइन करें. जैसे,
mobilenet. - वैरिएंट: ऑप्टिमाइज़ किए गए वैरिएशन को रेफ़र करने के लिए, टारगेट कोलन का इस्तेमाल करें. जैसे,
mobilenet:int8याmobilenet:gpu. - आसान तरीका: सभी सीएलआई कमांड, बिना पाथ वाले इस
4. 📲 डिवाइस डिप्लॉयमेंट और प्रोफ़ाइलिंग
हम ऑप्टिमाइज़ेशन को और बेहतर बना सकते हैं. इसके लिए, हम सटीक लोकल बेंचमार्क चलाएंगे, असली यूएसबी हार्डवेयर टारगेट डिप्लॉय करेंगे, हार्डवेयर डेलिगेट लागू करेंगे, कंपाइलिंग अहेड-ऑफ़-टाइम और क्लाउड बेंचमार्किंग करेंगे.
📊 लोकल प्रोफ़ाइलिंग मेट्रिक
EfficientNet-B1 डाउनलोड करें और अपने डेस्कटॉप होस्ट पर परफ़ॉर्मेंस के आंकड़े देखें:
# Download and register model alias in central catalog
litert download litert-community/efficientnet_b1 --file "*.tflite" --output efficientnet
litert import efficientnet/efficientnet_b1.tflite --model-ref efficientnet_b1
# Run high-precision benchmark on desktop CPU
litert benchmark efficientnet_b1 --desktop --cpu
बेंचमार्क लॉग में, परफ़ॉर्मेंस के मुख्य हेडर देखें:
Model initialization: स्ट्रक्चरल नेटवर्क को बूट करने में लगने वाला समय.Warmup (avg): कंपाइलेशन में लगने वाला समय.Inference (avg): यह गणितीय प्रोसेसिंग में लगने वाला समय है.Overall footprint: स्क्रिप्ट चलाने के दौरान इस्तेमाल की गई सबसे ज़्यादा रैम.
📲 टारगेट A: मोबाइल सीपीयू (यूएसबी से कनेक्ट किया गया)
यूएसबी डीबगिंग की सुविधा चालू करके, Android डिवाइस को कनेक्ट करें और इसे डिप्लॉय करें:
# 1. Confirm device connection
adb devices
# 2. Push and execute model on mobile CPU
litert run efficientnet_b1 --android --cpu
सीएलआई, मॉडल को टारगेट डिवाइस पर अपने-आप पुश करता है. साथ ही, अनुमान लगाने वाले लूप को एक्ज़ीक्यूट करता है और आउटपुट को वापस पाइप करता है!
🎮 टारगेट B: मोबाइल जीपीयू
OpenCL या WebGPU का इस्तेमाल करके, ज़्यादा लोड वाले वर्कलोड को डाइनैमिक तरीके से जीपीयू पर ऑफ़लोड करें:
# Benchmark model performance on mobile GPU
litert benchmark efficientnet_b1 --android --gpu
# Run inference with GPU acceleration and CPU fallback
litert run efficientnet_b1 --android --accelerator gpu,cpu
⚙️ टारगेट C: Android NPU के लिए JIT
मॉडर्न चिपसेट पर, सीधे तौर पर एनपीयू को एक्ज़ीक्यूशन पैरामीटर ऑफ़लोड करें:
# Run with on-device JIT NPU acceleration
litert run efficientnet_b1 --android --accelerator npu,cpu
- चेतावनी: उपयोगकर्ता के डिवाइस पर रनटाइम के दौरान बनाए गए डाइनैमिक ग्राफ़ को शुरू होने में काफ़ी समय लगता है.
🚀 टारगेट D: एओटी कंपाइल किया गया एनपीयू
रंटाइम JIT ओवरहेड को बायपास करने और ज़्यादा से ज़्यादा तेज़ी से काम करने के लिए, ऑफ़लाइन प्री-कंपाइल करें:
# 1. Offline compile for Qualcomm SM8750 NPU (Linux host)
litert compile efficientnet/efficientnet_b1.tflite --target sm8750
# 2. Execute compiled AOT binary with zero JIT warmup latency
litert run efficientnet_b1_Qualcomm_SM8750.tflite --android --npu
☁️ क्लाउड प्रोफ़ाइलिंग (Google AI Edge Portal)
Google Cloud के डिवाइस फ़ार्म में मौजूद रिमोट हार्डवेयर प्रोफ़ाइलों पर टेस्ट पुश करें.
# Log in to your Google Cloud project
gcloud auth login
# Push benchmark metrics to Pixel 7 CPU
litert benchmark efficientnet_b1 --gcp --device "pixel 7" --cpu --gcp-project "your-project-id"
# Push benchmark metrics to Snapdragon GPU targets
litert benchmark efficientnet_b1 --gcp --devices "pixel 7, sm-s931u1" --gpu --gcp-project "your-project-id"
5. 🧠 ऐडवांस विषय: एलएलएम और बोली की पहचान
लार्ज लैंग्वेज मॉडल (एलएलएम) और ऑटोमैटिक स्पीच रिकॉग्निशन (एएसआर) मॉडल को बदलकर और चलाकर, ऐडवांस मॉडल के बारे में जानें.
💬 जनरेटिव एआई (एलएलएम)
Edge LLM में मेमोरी की सीमा होती है. हम इस समस्या को हल करने के लिए, Weight-Only INT4/INT8 क्वांटाइज़ेशन लागू करते हैं. इससे, फ़्लोट32 में एक्ज़ीक्यूशन चैनल बनाए रखते हुए, वज़न को कंप्रेस किया जाता है:
# 1. Automated download & conversion from Hugging Face
litert convert Qwen/Qwen1.5-0.5B-Chat --output models/qwen
# 2. Quantize model weights to INT4
litert convert Qwen/Qwen1.5-0.5B-Chat \
--quantize-recipe weight_only_wi4_afp32 \
--output models/qwen_w4
# 3. Generation once
litert lm run models/qwen/model.litertlm --prompt "Introduce San Francisco."
# 4. Interactive chat
litert lm run models/qwen/model.litertlm
🎙️ स्पीच प्रोसेसिंग (एएसआर)
Whisper या Parakeet जैसे एएसआर मॉडल में, एन्कोडर और डिकोडर, दोनों मॉड्यूल होते हैं. हम सिग्नेचर कुंजियों का इस्तेमाल करके, कुछ खास मॉड्यूल के लिए बेंचमार्क तय कर सकते हैं:
# 1. Download prepackaged Whisper-Tiny
litert download litert-community/whisper-tiny --file "whisper_tiny_30s_f32.tflite" --output "models/whisper_tiny"
# 2. Profile audio encoding
litert benchmark models/whisper_tiny/whisper_tiny_30s_f32.tflite --android --gpu --signature-key "encode"
# 3. Profile text token decoding loop
litert benchmark models/whisper_tiny/whisper_tiny_30s_f32.tflite --android --cpu --signature-key "decode"
6. 🤖 एजेंटिक कोडिंग में इस्तेमाल करें
LiteRT CLI, एजेंट के साथ आसानी से काम करता है. इसे सीधे तौर पर कोडिंग एजेंट के साथ इंटिग्रेट किया जा सकता है.
यहां कुछ उदाहरण दिए गए हैं. अपने कोडिंग एजेंट (जैसे, Google Antigravity) में LiteRT CLI की स्किल SKILL.md जोड़ें और इस तरह के प्रॉम्प्ट आज़माएं.
7. 🚀 बधाई हो और अगले चरण
🎉 बहुत बढ़िया! आपने LiteRT CLI 101 कोडलैब पूरा कर लिया है!
अब आपके पास एज एमएल डेवलपमेंट में महारत हासिल करने के लिए ये कौशल हैं:
- PyTorch मॉडल को LiteRT मॉडल में बदलें.
- मॉडल के वेट को INT4/INT8 में बदलें.
- मोबाइल सीपीयू/जीपीयू/एनपीयू पर मॉडल चलाएं.
- एनपीयू के लिए कंपाइल करें.
- डेस्कटॉप, मोबाइल, और क्लाउड पर बेंचमार्क करें.
- एलएलएम मॉडल को बदला जा सकता है और उन्हें चलाया जा सकता है.
- एजेंटिक कोडिंग में इस्तेमाल करें.
🔗 संसाधन
- LiteRT CLI: https://github.com/google-ai-edge/LiteRT-CLI
- LiteRT: https://ai.google.dev/edge/litert
- उदाहरण: https://github.com/google-ai-edge/LiteRT-CLI/tree/main/examples