परफ़ॉर्मेंस मेज़रमेंट

मानदंड तय करने वाले टूल

फ़िलहाल, LiteRT के बेंचमार्क टूल इन अहम परफ़ॉर्मेंस मेट्रिक के आंकड़े मेज़र और कैलकुलेट करते हैं:

• डेटा लेयर में इवेंट बनाने की प्रोसेस में लगने वाला समय
• वॉर्मअप की स्थिति में अनुमान लगाने में लगने वाला समय
• स्थिर स्थिति का अनुमान लगाने में लगने वाला समय
• शुरू होने के दौरान मेमोरी का इस्तेमाल
• मेमोरी के इस्तेमाल का कुल डेटा

बेंचमार्क टूल, Android और iOS के लिए बेंचमार्क ऐप्लिकेशन के तौर पर उपलब्ध हैं. साथ ही, ये पहले से बने कमांड-लाइन बाइनरी के तौर पर भी उपलब्ध हैं. इन सभी में, परफ़ॉर्मेंस मेज़रमेंट का एक ही लॉजिक इस्तेमाल किया जाता है. ध्यान दें कि रनटाइम एनवायरमेंट में अंतर होने की वजह से, उपलब्ध विकल्प और आउटपुट फ़ॉर्मैट थोड़े अलग होते हैं.

पहले से बनाया गया बेंचमार्क बाइनरी (CompiledModel API का इस्तेमाल करके)

Android पर मानदंड टूल का इस्तेमाल करने के दो विकल्प हैं. इनमें से एक, नेटिव बेंचमार्क बाइनरी (CompiledModel API पर आधारित) है और दूसरा, Android बेंचमार्क ऐप्लिकेशन (Interpreter API पर आधारित) है. LiteRT Benchmark टूल, पहले से मौजूद बाइनरी benchmark_model के तौर पर उपलब्ध कराया जाता है. इस टूल को Linux, macOS, Windows, Raspberry Pi, एम्बेड किए गए डिवाइसों, और जीपीयू ऐक्सेलरेट करने की सुविधा वाले Android डिवाइसों पर, शेल कमांड लाइन से चलाया जा सकता है.

बाइनरी डाउनलोड करना या बनाना

यहां दिए गए लिंक पर जाकर, कमांड-लाइन के लिए पहले से बनाए गए Nightly बाइनरी डाउनलोड करें:

• linux_x86_64
• linux_arm64
• android_arm64
• macos_arm64
• windows_x86_64

अपने कंप्यूटर पर, सोर्स से भी बेंचमार्क बाइनरी बनाई जा सकती है.

bazel build -c opt //litert/tools:benchmark_model

Android NDK टूलचेन की मदद से बनाने के लिए, आपको सबसे पहले बिल्ड एनवायरमेंट सेट अप करना होगा. इसके लिए, इस गाइड में दिया गया तरीका अपनाएं. इसके अलावा, इस गाइड में बताए गए तरीके से, डॉकर इमेज का इस्तेमाल करें.

bazel build -c opt --config=android_arm64 \
  //litert/tools:benchmark_model

बेंचमार्क चलाना

अपने कंप्यूटर पर बेंचमार्क चलाने के लिए, शेल से बाइनरी को एक्ज़ीक्यूट करें.

path/to/downloaded_or_built/benchmark_model \
  --graph=your_model.tflite \
  --num_threads=4

प्रीबिल्ट कमांड-लाइन बाइनरी के साथ, पहले बताए गए पैरामीटर के उसी सेट का इस्तेमाल किया जा सकता है.

GPU ऐक्सेलरेटर

इन प्रीबिल्ट बाइनरी में, नया LiteRT GPU ऐक्सेलरेटर शामिल है. यह OpenCL और WebGPU के साथ काम करता है. WebGPU, Vulkan (Linux), Metal (MacOS), और Direct3D (Windows) पर काम करता है.

GPU ऐक्सेलरेटर का इस्तेमाल करने के लिए, --use_gpu=true फ़्लैग पास करें.

प्रोफ़ाइल मॉडल के ऑपरेशन

बेंचमार्क मॉडल बाइनरी की मदद से, मॉडल ऑप्स को प्रोफ़ाइल किया जा सकता है. साथ ही, हर ऑपरेटर के एक्ज़ीक्यूशन टाइम की जानकारी भी पाई जा सकती है. ऐसा करने के लिए, इनवॉकेशन के दौरान फ़्लैग --use_profiler=true को benchmark_model पर पास करें.

Android बेंचमार्क ऐप्लिकेशन (Interpreter API का इस्तेमाल करके)

v1 Interpreter API पर आधारित Android का एक बेंचमार्क ऐप्लिकेशन भी उपलब्ध कराया गया है. इससे यह बेहतर तरीके से पता चलता है कि मॉडल, Android ऐप्लिकेशन में कैसा परफ़ॉर्म करेगा. हालांकि, बेंचमार्क टूल से मिले नंबर, ऐप्लिकेशन में मॉडल के साथ इन्फ़रेंस चलाने पर मिलने वाले नंबरों से थोड़े अलग होंगे.

इस Android बेंचमार्क ऐप्लिकेशन में कोई यूज़र इंटरफ़ेस (यूआई) नहीं है. adb कमांड का इस्तेमाल करके इसे इंस्टॉल और रन करें. इसके बाद, adb logcat कमांड का इस्तेमाल करके नतीजे पाएं.

ऐप्लिकेशन डाउनलोड करना या बनाना

यहां दिए गए लिंक का इस्तेमाल करके, Android के बेंचमार्क ऐप्लिकेशन के Nightly प्रीबिल्ट वर्शन डाउनलोड करें:

• android_aarch64
• android_arm

Flex delegate के ज़रिए TF ops को सपोर्ट करने वाले Android बेंचमार्क ऐप्लिकेशन के लिए, यहां दिए गए लिंक का इस्तेमाल करें:

• android_aarch64
• android_arm

इन निर्देशों का पालन करके, सोर्स से भी ऐप्लिकेशन बनाया जा सकता है.

बेंचमार्क तैयार करना

बेंचमार्क ऐप्लिकेशन चलाने से पहले, ऐप्लिकेशन इंस्टॉल करें और मॉडल फ़ाइल को डिवाइस पर इस तरह पुश करें:

adb install -r -d -g android_aarch64_benchmark_model.apk
adb push your_model.tflite /data/local/tmp

बेंचमार्क चलाएं

adb shell am start -S \
  -n org.tensorflow.lite.benchmark/.BenchmarkModelActivity \
  --es args '"--graph=/data/local/tmp/your_model.tflite \
              --num_threads=4"'

graph एक ज़रूरी पैरामीटर है.

• graph: string
  TFLite मॉडल फ़ाइल का पाथ.

बेंचमार्क चलाने के लिए, ज़्यादा वैकल्पिक पैरामीटर तय किए जा सकते हैं.

• num_threads: int (default=1)
  TFLite इंटरप्रेटर को चलाने के लिए इस्तेमाल किए जाने वाले थ्रेड की संख्या.
• use_gpu: bool (default=false)
  GPU डेलिगेट का इस्तेमाल करें.
• use_xnnpack: bool (default=false)
  Use XNNPACK delegate.

इस्तेमाल किए जा रहे डिवाइस के हिसाब से, हो सकता है कि इनमें से कुछ विकल्प उपलब्ध न हों या उनका कोई असर न हो. बेंचमार्क ऐप्लिकेशन के साथ इस्तेमाल किए जा सकने वाले अन्य परफ़ॉर्मेंस पैरामीटर के लिए, पैरामीटर देखें.

logcat कमांड का इस्तेमाल करके नतीजे देखें:

adb logcat | grep "Inference timings"

बेंचमार्क के नतीजों को इस तरह रिपोर्ट किया जाता है:

... tflite  : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2

iOS के लिए बेंचमार्क ऐप्लिकेशन

iOS डिवाइस पर बेंचमार्क चलाने के लिए, आपको ऐप्लिकेशन को सोर्स से बनाना होगा. LiteRT मॉडल फ़ाइल को सोर्स ट्री की benchmark_data डायरेक्ट्री में रखें और benchmark_params.json फ़ाइल में बदलाव करें. इन फ़ाइलों को ऐप्लिकेशन में पैकेज किया जाता है. साथ ही, ऐप्लिकेशन डायरेक्ट्री से डेटा पढ़ता है. ज़्यादा जानकारी के लिए, iOS बेंचमार्क ऐप्लिकेशन पर जाएं.

मशहूर मॉडल के लिए परफ़ॉर्मेंस बेंचमार्क

इस सेक्शन में, कुछ Android और iOS डिवाइसों पर जाने-माने मॉडल चलाने के दौरान, LiteRT की परफ़ॉर्मेंस के बेंचमार्क दिए गए हैं.

Android की परफ़ॉर्मेंस के बेंचमार्क

परफ़ॉर्मेंस के इन बेंचमार्क नंबर को नेटिव बेंचमार्क बाइनरी की मदद से जनरेट किया गया था.

Android के बेंचमार्क के लिए, सीपीयू अफ़िनिटी को डिवाइस पर बड़े कोर का इस्तेमाल करने के लिए सेट किया जाता है, ताकि अंतर को कम किया जा सके. इसके बारे में ज़्यादा जानकारी देखें.

इसमें यह माना जाता है कि मॉडल, /data/local/tmp/tflite_models डायरेक्ट्री में डाउनलोड और अनज़िप किए गए थे. बेंचमार्क बाइनरी को इन निर्देशों का इस्तेमाल करके बनाया जाता है. साथ ही, यह माना जाता है कि यह /data/local/tmp डायरेक्ट्री में है.

मानदंड की जांच करने के लिए:

adb shell /data/local/tmp/benchmark_model \
  --num_threads=4 \
  --graph=/data/local/tmp/tflite_models/${GRAPH} \
  --warmup_runs=1 \
  --num_runs=50

जीपीयू डेलिगेट के साथ चलाने के लिए, --use_gpu=true सेट करें.

यहां दी गई परफ़ॉर्मेंस वैल्यू, Android 10 पर मेज़र की गई हैं.

iOS पर परफ़ॉर्मेंस के बेंचमार्क

परफ़ॉर्मेंस के इन बेंचमार्क नंबर को iOS बेंचमार्क ऐप्लिकेशन की मदद से जनरेट किया गया था.

iOS बेंचमार्क चलाने के लिए, बेंचमार्क ऐप्लिकेशन में बदलाव किया गया, ताकि इसमें सही मॉडल शामिल किया जा सके. साथ ही, benchmark_params.json में बदलाव किया गया, ताकि num_threads को 2 पर सेट किया जा सके. जीपीयू डेलिगेट का इस्तेमाल करने के लिए, "use_gpu" : "1" और "gpu_wait_type" : "aggressive" विकल्पों को benchmark_params.json में भी जोड़ा गया था.

LiteRT के इंटरनल को ट्रेस करना

Android में LiteRT के इंटरनल को ट्रेस करना

Android ऐप्लिकेशन के LiteRT इंटरप्रेटर से मिलने वाले इंटरनल इवेंट को Android ट्रेसिंग टूल की मदद से कैप्चर किया जा सकता है. ये Android Trace API वाले इवेंट ही हैं. इसलिए, Java/Kotlin कोड से कैप्चर किए गए इवेंट, LiteRT के इंटरनल इवेंट के साथ दिखते हैं.

यहां इवेंट के कुछ उदाहरण दिए गए हैं:

• ऑपरेटर को चालू करना
• प्रतिनिधि ने ग्राफ़ में बदलाव किया
• टेंसर ऐलोकेशन

ट्रेस कैप्चर करने के अलग-अलग विकल्पों में से, इस गाइड में Android Studio CPU Profiler और System Tracing ऐप्लिकेशन के बारे में बताया गया है. अन्य विकल्पों के लिए, Perfetto कमांड-लाइन टूल या Systrace कमांड-लाइन टूल देखें.

Java कोड में ट्रेस इवेंट जोड़ना

यह इमेज क्लासिफ़िकेशन के उदाहरण वाले ऐप्लिकेशन का कोड स्निपेट है. LiteRT इंटरप्रेटर, recognizeImage/runInference सेक्शन में चलता है. यह चरण ज़रूरी नहीं है, लेकिन इससे यह पता लगाने में मदद मिलती है कि अनुमान लगाने के लिए कॉल कहां किया गया है.

  Trace.beginSection("recognizeImage");
  ...
  // Runs the inference call.
  Trace.beginSection("runInference");
  tflite.run(inputImageBuffer.getBuffer(), outputProbabilityBuffer.getBuffer().rewind());
  Trace.endSection();
  ...
  Trace.endSection();

LiteRT ट्रेसिंग की सुविधा चालू करना

LiteRT ट्रेसिंग को चालू करने के लिए, Android ऐप्लिकेशन शुरू करने से पहले Android सिस्टम प्रॉपर्टी debug.tflite.trace को 1 पर सेट करें.

adb shell setprop debug.tflite.trace 1

अगर LiteRT इंटरप्रेटर के शुरू होने पर यह प्रॉपर्टी सेट की गई है, तो इंटरप्रेटर से मुख्य इवेंट (जैसे, ऑपरेटर इनवोकेशन) को ट्रैक किया जाएगा.

सभी ट्रेस कैप्चर करने के बाद, प्रॉपर्टी की वैल्यू को 0 पर सेट करके ट्रेसिंग बंद करें.

adb shell setprop debug.tflite.trace 0

Android Studio का सीपीयू प्रोफ़ाइलर

नीचे दिया गया तरीका अपनाकर, Android Studio CPU Profiler की मदद से ट्रेस कैप्चर करें:

1. सबसे ऊपर मौजूद मेन्यू में जाकर, Run > Profile 'app' को चुनें.

2. जब Profiler विंडो दिखे, तब सीपीयू टाइमलाइन में कहीं भी क्लिक करें.

3. सीपीयू प्रोफ़ाइलिंग मोड में से, 'सिस्टम कॉल ट्रेस करें' चुनें.

   

4. 'रिकॉर्ड करें' बटन दबाएं.

5. 'रोकें' बटन दबाएं.

6. ट्रेस के नतीजे की जांच करें.

   

इस उदाहरण में, थ्रेड में इवेंट का क्रम और हर ऑपरेटर के समय के आंकड़े देखे जा सकते हैं. साथ ही, थ्रेड के बीच पूरे ऐप्लिकेशन का डेटा फ़्लो भी देखा जा सकता है.

सिस्टम ट्रेसिंग ऐप्लिकेशन

Android Studio के बिना ट्रेस कैप्चर करने के लिए, सिस्टम ट्रेसिंग ऐप्लिकेशन में बताया गया तरीका अपनाएं.

इस उदाहरण में, Android डिवाइस के वर्शन के आधार पर, एक ही TFLite इवेंट को Perfetto या Systrace फ़ॉर्मैट में कैप्चर और सेव किया गया है. कैप्चर की गई ट्रेस फ़ाइलों को Perfetto यूज़र इंटरफ़ेस (यूआई) में खोला जा सकता है.

iOS में LiteRT के इंटरनल को ट्रेस करना

iOS ऐप्लिकेशन के LiteRT इंटरप्रेटर से मिलने वाले इंटरनल इवेंट को Xcode में शामिल Instruments टूल की मदद से कैप्चर किया जा सकता है. ये iOS signpost इवेंट हैं. इसलिए, Swift/Objective-C कोड से कैप्चर किए गए इवेंट, LiteRT के इंटरनल इवेंट के साथ दिखते हैं.

यहां इवेंट के कुछ उदाहरण दिए गए हैं:

• ऑपरेटर को चालू करना
• प्रतिनिधि ने ग्राफ़ में बदलाव किया
• टेंसर ऐलोकेशन

LiteRT ट्रेसिंग की सुविधा चालू करना

नीचे दिया गया तरीका अपनाकर, एनवायरमेंट वैरिएबल debug.tflite.trace सेट करें:

1. Xcode के सबसे ऊपर मौजूद मेन्यू में जाकर, Product > Scheme > Edit Scheme... को चुनें.

2. बाएं पैनल में मौजूद, 'प्रोफ़ाइल' पर क्लिक करें.

3. 'Run ऐक्शन के आर्ग्युमेंट और एनवायरमेंट वैरिएबल का इस्तेमाल करें' चेकबॉक्स से सही का निशान हटाएं.

4. 'Environment Variables' सेक्शन में जाकर, debug.tflite.trace जोड़ें.

   

अगर आपको iOS ऐप्लिकेशन की प्रोफ़ाइल बनाते समय, LiteRT इवेंट शामिल नहीं करने हैं, तो एनवायरमेंट वैरिएबल हटाकर ट्रेसिंग बंद करें.

XCode Instruments

नीचे दिया गया तरीका अपनाकर ट्रेस कैप्चर करें:

1. Xcode के सबसे ऊपर मौजूद मेन्यू में जाकर, Product > Profile को चुनें.

2. Instruments टूल लॉन्च होने पर, प्रोफ़ाइलिंग टेंप्लेट में जाकर Logging पर क्लिक करें.

3. 'शुरू करें' बटन दबाएं.

4. 'रोकें' बटन दबाएं.

5. 'os_signpost' पर क्लिक करके, ओएस लॉगिंग सबसिस्टम आइटम को बड़ा करें.

6. 'org.tensorflow.lite' ओएस लॉगिंग सबसिस्टम पर क्लिक करें.

7. ट्रेस के नतीजे की जांच करें.

   

इस उदाहरण में, हर ऑपरेटर के लिए इवेंट और आंकड़ों की क्रमिक व्यवस्था देखी जा सकती है.

ट्रेसिंग डेटा का इस्तेमाल करना

ट्रेसिंग डेटा की मदद से, परफ़ॉर्मेंस से जुड़ी समस्याओं की पहचान की जा सकती है.

प्रोफ़ाइलर से मिलने वाली अहम जानकारी के कुछ उदाहरण यहां दिए गए हैं. साथ ही, परफ़ॉर्मेंस को बेहतर बनाने के संभावित समाधान भी दिए गए हैं:

• अगर उपलब्ध सीपीयू कोर की संख्या, अनुमान लगाने वाले थ्रेड की संख्या से कम है, तो सीपीयू शेड्यूलिंग ओवरहेड की वजह से परफ़ॉर्मेंस खराब हो सकती है. अपने ऐप्लिकेशन में सीपीयू का ज़्यादा इस्तेमाल करने वाले अन्य टास्क को फिर से शेड्यूल किया जा सकता है, ताकि वे मॉडल इन्फ़रेंस के साथ ओवरलैप न हों. इसके अलावा, इंटरप्रेटर थ्रेड की संख्या में बदलाव किया जा सकता है.
• अगर ऑपरेटर पूरी तरह से डेलिगेट नहीं किए जाते हैं, तो मॉडल ग्राफ़ के कुछ हिस्सों को सीपीयू पर एक्ज़ीक्यूट किया जाता है. ऐसा हार्डवेयर ऐक्सलरेटर पर एक्ज़ीक्यूट करने के बजाय किया जाता है. इस्तेमाल न किए जा सकने वाले ऑपरेटर की जगह, मिलते-जुलते ऑपरेटर इस्तेमाल किए जा सकते हैं.