‫LiteRT CLI 101: ייעול תהליכי עבודה של Edge AI

1. ‫🏁 מבוא וסקירה כללית על ה-CLI

ברוכים הבאים ל-LiteRT CLI 101 – שיעור Codelab מעשי! המדריך הזה נועד להסביר לכם שלב אחר שלב איך להגדיר סביבה מאפס ולפרוס בינה מלאכותית אופטימלית בקצה הרשת.

🌟 רקע

כדי להשתמש ב-Edge AI, צריך להעביר מודלים עצביים מורכבים ישירות לטלפונים ניידים, למכשירים לבישים ולחומרה מוטמעת.

  • ‫LiteRT (לשעבר TensorFlow Lite / TFLite) היא מסגרת הפעלה במכשיר של Google לשימוש ב-ML וב-GenAI בביצועים גבוהים בפלטפורמות קצה, באמצעות המרה, זמן ריצה ואופטימיזציה יעילים.
  • ‫LiteRT CLI משלב מחסניות של Google AI Edge בפקודת מעטפת עצמאית (litert) כדי לייעל את תהליכי העבודה של פיתוח שקשורים ל-LiteRT, כולל המרה, כימות, קומפילציה, הפעלה, השוואה ויזואלית של מודלים של LiteRT ‏ (TFLite) בחומרה שונה (CPU / GPU / NPU) בפלטפורמות שונות (מחשב, נייד או ענן).

2. ‫🔄 תהליכי עבודה בסיסיים: המרה, קוונטיזציה והפעלה

בקטע הזה נבצע מחזור חיים מלא של בניית מודלים של Edge AI באמצעות LiteRT CLI: עטיפת מודל PyTorch ➔ מעקב המרות ➔ כימות מודל ➔ הסקת מסקנות במחשב ➔ מדדי ביצועים.

תהליך עבודה ב-LiteRT CLI 101

‫📝 שלב 1: הכנת סקריפט של עטיפת מודל 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),)

‫🔄 שלב 2: המרת מודל PyTorch ל-LiteRT באמצעות LiteRT Torch

מפעילים את כלי ההמרה LiteRT Torch כדי ליצור מודל יעד רגיל מסוג Float32‏ .tflite:

# Convert PyTorch source to LiteRT
litert convert resnet18.py --output resnet18

# Verify target was exported
ls -lh resnet18/resnet18.tflite

‫📉 שלב 3: כימות המשקלים ל-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

🚀 שלב 4: הפעלת הסקה באופן מקומי

מריצים פעולות בדיקה עם פרמטרים של קלט פיקטיבי כדי לוודא שאין גורמים שמפריעים לביצועים:

# 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

‫📊 שלב 5: השוואת ביצועי המודל לביצועים של מודלים אחרים

מדידת מדדים ברמת דיוק גבוהה, כולל זמן אחזור ממוצע, עלויות אתחול, תפוקת ביצוע של CPU וטביעות רגל דינמיות של זיכרון פעיל:

# 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

🛠️ אפשרות ג': הגדרה מקומית שניתנת לעריכה

אם אתם מפתחים או בודקים ישירות בשיבוט של ספריית קובצי המקור של המאגר:

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

כדי לשמור על סקריפטים ופיתוח חזקים, ה-CLI של LiteRT מיישם קטלוג מודלים מרכזי:

תרשים ניתוב של קטלוג המודלים

  • פורמט: מקצים שם ייחודי (כינוי) למודל שהורד או יובא, כמו mobilenet.
  • וריאציות: משתמשים בנקודתיים כדי להתייחס לווריאציות שעברו אופטימיזציה, כמו mobilenet:int8 או mobilenet:gpu.
  • פשטות: כל פקודות ה-CLI מקבלות את הכינוי הזה ללא נתיב ישירות, ופותרות באופן אוטומטי את בעיית האחסון הפיזי של הקובץ תוך כדי תנועה.

4. 📲 פריסה של מכשירים ויצירת פרופילים

אנחנו יכולים לבצע אופטימיזציה מתקדמת יותר על ידי הפעלת מדדים מקומיים ברמת דיוק גבוהה, פריסה ליעדי חומרה אמיתיים של USB, הטמעה של רכיבי חומרה, קומפילציה מראש (Ahead-of-Time) ובדיקת ביצועים בענן.

אפשרויות לפריסה ולשיפור הביצועים של יעדים

📊 מדדים של פרופילים מקומיים

מורידים את 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: שיא צריכת ה-RAM במהלך ההרצה.

‫📲 יעד א': יחידת עיבוד מרכזית (CPU) בנייד (חיבור USB)

מחברים מכשיר Android עם ניפוי באגים ב-USB מופעל, ומבצעים פריסה:

# 1. Confirm device connection
adb devices

# 2. Push and execute model on mobile CPU
litert run efficientnet_b1 --android --cpu

ה-CLI מעביר את המודל באופן אוטומטי למכשיר היעד, מריץ את לולאת ההסקה ומעביר את הפלט בחזרה!

‫🎮 יעד ב': מעבד גרפי (GPU) לנייד

העברת עומסי עבודה כבדים באופן דינמי אל ה-GPU באמצעות 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

‫⚙️ Target C: JIT Android NPU

הפחתת עומס של פרמטרים של הרצה ישירות ל-NPU בערכות שבבים מודרניות:

# Run with on-device JIT NPU acceleration
litert run efficientnet_b1 --android --accelerator npu,cpu
  • אזהרה: בניית גרפים דינמיים בתוך זמן ריצה במכשיר סובלת מעיכובים משמעותיים בהפעלה הראשונית של JIT.

🚀 יעד ד': יחידת עיבוד עצבי (NPU) שעברה קומפילציה של AOT

הידור מראש במצב אופליין כדי לעקוף את התקורה של 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. 🧠 נושאים מתקדמים: מודלים גדולים של שפה (LLM) וזיהוי דיבור

בואו נבדוק מודלים מתקדמים על ידי המרה והרצה של מודלים גדולים של שפה (LLM) ומודלים של זיהוי אוטומטי של דיבור (ASR).

💬 AI גנרטיבי (מודלים גדולים של שפה)

מודלים גדולים של שפה (LLM) ב-Edge מוגבלים בזיכרון. כדי לפתור את הבעיה הזו, אנחנו משתמשים בכימות Weight-Only INT4/INT8, שדוחס את המשקלים תוך שמירה על ערוצי הביצוע ב-Float32:

# 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

🎙️ עיבוד דיבור (ASR)

למודלים של ASR כמו 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 הוא ידידותי לסוכנים, ואפשר לשלב אותו ישירות עם סוכני קידוד.

הנה מספר דוגמאות. מוסיפים את מיומנות LiteRT CLI‏ SKILL.md לסוכן התכנות (לדוגמה, Google Antigravity) ומנסים הנחיות כמו אלה שבהמשך.

7. 🚀 מזל טוב והשלבים הבאים

🎉 מצוין! סיימתם את ה-Codelab בנושא LiteRT CLI 101.

עכשיו יש לכם את הכישורים הדרושים כדי לשלוט בפיתוח של ML ב-Edge:

  • המרת מודלים של PyTorch למודלים של LiteRT.
  • כמותית של משקלי המודל ל-INT4/INT8.
  • הפעלת מודלים במעבד (CPU), במעבד גרפי (GPU) או במעבד עצבי (NPU) בנייד.
  • לקמפל עבור NPU.
  • השוואה למדד במחשב, בנייד ובענן.
  • המרת מודלים של LLM והרצה שלהם.
  • שימוש בתכנות מבוסס-סוכנים.

🔗 מקורות מידע

  • ‫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