TF Lite Delegate: यह क्या है, GPU और NNAPI डेलीगेट

TF Lite Delegate क्या है: आर्किटेक्चर और कार्य सिद्धांत

TF Lite Delegate TensorFlow Lite Runtime और डिवाइस के हार्डवेयर एक्सेलेरेटर के बीच एक सॉफ़्टवेयर एडॉप्टर है। डेलीगेट मॉडल ग्राफ़ संचालन (कन्वोल्यूशन, पूलिंग, मैट्रिक्स गुणा) को इंटरसेप्ट करता है और उन्हें CPU के बजाय एक विशेष कंप्यूट यूनिट पर निष्पादित करता है। यदि डेलीगेट किसी विशेष संचालन का समर्थन नहीं करता है, तो यह CPU पर चलता है — इसे आंशिक डेलीगेशन कहा जाता है।

TF Lite Delegate आर्किटेक्चर SimpleDelegate API इंटरफ़ेस और C++ में TfLiteDelegate संरचना के आसपास बनाया गया है। प्रत्येक डेलीगेट ग्राफ़ नोड्स के डेलीगेशन, मेमोरी आवंटन और लक्ष्य डिवाइस पर निष्पादन के तरीकों को लागू करता है। डेवलपर Invoke को कॉल करने से पहले Interpreter::ModifyGraphWithDelegate के माध्यम से डेलीगेट को कनेक्ट करता है। TensorFlow Guide के अनुसार, डेलीगेट मॉडल के सभी समर्थित संचालनों पर स्वचालित रूप से लागू होता है।

संगतता जाँच एक अनिवार्य कदम है। सभी संचालन प्रत्येक डेलीगेट द्वारा समर्थित नहीं हैं। TensorFlow Lite Delegation Compatibility Check टूल प्रदान करता है: मॉडल को डेलीगेट के साथ चलाएँ और जाँचें कि कितने संचालन (ops) डेलीगेट हुए। यदि 80% से कम डेलीगेट हैं, तो दूसरा डेलीगेट चुनने या CPU पर रहने पर विचार करें। TensorFlow (2025) के अनुसार, GPU Delegate 45 संचालन का समर्थन करता है, NNAPI — 60+।

IT Sectr प्रोजेक्ट्स में, हम iOS के लिए GPU डेलीगेट और Android के लिए XNNPACK का उपयोग अंतर्निहित संगतता सत्यापन के साथ करते हैं: मॉडल का सभी डेलीगेट पर परीक्षण किया जाता है, कम से कम 90% डेलीगेशन पूर्णता वाला सबसे तेज़ चुना जाता है।

// Android पर GPU Delegate कनेक्शन
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

डेलीगेटेड संचालन की जाँच — Interpreter के माध्यम से संगतता नियंत्रण। डिफ़ॉल्ट रूप से, डेलीगेट उन सभी संचालनों को स्वीकार करता है जिनका वह समर्थन करता है। डिबगिंग के लिए, डेलीगेटेड नोड्स की संख्या की लॉगिंग का उपयोग करें। यदि मॉडल में कस्टम संचालन (custom ops) हैं, तो डेलीगेट उन्हें तेज़ नहीं करता लेकिन तोड़ता भी नहीं — वे CPU पर चलते हैं।

// डेलीगेटेड संचालनों की संख्या जाँचें
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "डेलीगेटेड: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // 80% सीमा — दूसरा डेलीगेट चुनें
}

GPU Delegate: ग्राफ़िक्स प्रोसेसर पर त्वरण

GPU Delegate OpenGL ES 3.1+ (Android) या Metal (iOS) के माध्यम से GPU पर मॉडल चलाने के लिए TensorFlow Lite डेलीगेट है। ग्राफ़िक्स प्रोसेसर समानांतर मैट्रिक्स संचालन के लिए अनुकूलित हैं — Core ML और कन्वोल्यूशनल न्यूरल नेटवर्क (CNN) को सबसे अधिक लाभ मिलता है। GPU Delegate MobileNet, EfficientNet, Inception जैसे मॉडलों के लिए इन्फ़रेंस लेटेंसी को 4–8 गुना कम करता है।

GPU Delegate सीमाएँ: सभी संचालनों का समर्थन नहीं करता (TF Lite में ~120 में से केवल 45), OpenGL ES 3.1 या Metal की आवश्यकता है, CPU से अधिक ऊर्जा消耗 करता है। मोबाइल परिदृश्यों में batch size > 1 के लिए GPU अकुशल है। TensorFlow बेंचमार्क (2025) के अनुसार, Adreno 740 GPU वाले Pixel 8 पर, MobileNetV2 GPU पर 4.2 ms बनाम CPU पर 18.7 ms में चलता है — 4.4x त्वरण।

GPU Delegate कॉन्फ़िगरेशन में सटीकता चयन शामिल है: float16 सटीकता कम करता है लेकिन इन्फ़रेंस को 30–40% तेज़ करता है बिना गुणवत्ता में ध्यान देने योग्य कमी के (अधिकांश कार्यों के लिए)। अधिकतम GPU प्रदर्शन के लिए allow_precision_loss=true सक्षम करें। उच्च सटीकता वाले कार्यों (चिकित्सा, वित्त) के लिए float32 का उपयोग करें।

// सटीकता अनुकूलन के साथ GPU Delegate
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

iOS पर GPU Delegate Metal Delegate के माध्यम से Metal Performance Shaders का उपयोग करता है। iOS में, डेलीगेट Apple Neural Engine के लिए Core ML डेलीगेट या सीधे Metal के माध्यम से काम करता है। Apple A17 Pro MobileNetV2 को 1.3 ms में चलाता है — CPU से 6 गुना तेज़। Metal delegate iOS 12 से उपलब्ध है और A7+ चिप वाले सभी उपकरणों का समर्थन करता है।

NNAPI Delegate: Neural Networks API के माध्यम से Android पर न्यूरल नेटवर्क

NNAPI Delegate (Android Neural Networks API) एक TF Lite डेलीगेट है जो Android NN HAL (Hardware Abstraction Layer) के माध्यम से हार्डवेयर त्वरण का उपयोग करता है। NNAPI उपलब्ध डिवाइस ड्राइवरों के आधार पर मॉडल संचालन को NPU, DSP या GPU पर रीडायरेक्ट करता है। Android 8.1+ (API 27+) पर समर्थित है और Android के लिए डिफ़ॉल्ट अनुशंसित डेलीगेट है।

NNAPI लाभ — स्वचालित एक्सेलेरेटर चयन। यदि डिवाइस में NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU) है, तो NNAPI उस पर संचालन डेलीगेट करता है। यदि NPU नहीं है — OpenCL के माध्यम से GPU पर। यदि GPU भी समर्थित नहीं है — DSP अनुकूलन के साथ CPU पर। डेवलपर कोई विशिष्ट एक्सेलेरेटर निर्दिष्ट नहीं करता — NNAPI इष्टतम चुनता है। Google I/O 2024 के अनुसार, Snapdragon 8 Gen 3 पर NNAPI डेलीगेट LLM मॉडल को 12 गुना तेज़ करता है।

NNAPI सीमाएँ: विभिन्न उपकरणों पर असमान समर्थन। पुराने उपकरणों (Android 8.1) में ड्राइवरों का सीमित सेट होता है। Kirin वाला Huawei Google Services के माध्यम से NNAPI का समर्थन नहीं करता — GPU Delegate का उपयोग करें। गारंटीकृत संगतता के लिए, Google पहली पसंद के रूप में NNAPI Delegate की सिफारिश करता है, जिसमें GPU या XNNPACK पर फ़ॉलबैक हो।

// CPU फ़ॉलबैक के साथ NNAPI Delegate
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = ऑटो-चयन
    allowFp16 = true
    executionPreference = NnApiDelegate.ExecutionPreference.SUSTAINED_SPEED
}
val delegate = NnApiDelegate(nnApiOptions)
val interpreter = Interpreter(model, Interpreter.Options().apply {
    addDelegate(delegate)
    setNumThreads(4)
})

NNAPI एक्सेलेरेटर नाम — स्पष्ट एक्सेलेरेटर चयन के लिए एक पैरामीटर। यदि null पास किया जाता है, तो NNAPI स्वचालित रूप से चुनता है। परीक्षण के लिए, एक विशिष्ट निर्दिष्ट करें: "qti", "google-edgetpu", "mediatek"। उपलब्ध एक्सेलेरेटर की सूची NnApiDelegate.getAvailableAccelerators() के माध्यम से आउटपुट होती है। प्रोडक्शन में, संगतता सीमा के साथ ऑटो-चयन का उपयोग करें।

XNNPACK Delegate: SIMD के माध्यम से CPU अनुकूलन

XNNPACK Delegate SIMD निर्देशों (ARM NEON, SSE, AVX) के माध्यम से अनुकूलित CPU निष्पादन के लिए TensorFlow Lite डेलीगेट है। XNNPACK को GPU या NPU की आवश्यकता नहीं है — यह एक शुद्ध CPU डेलीगेट है, लेकिन SIMD, ऑपरेटर फ़्यूज़न, मेमोरी प्री-फ़ेचिंग और क्वांटाइज़्ड इन्फ़रेंस (INT8) के माध्यम से 2–4 गुना त्वरण के साथ। समर्पित NPU के बिना उपकरणों के लिए या जब गारंटीकृत संगतता की आवश्यकता हो तो आदर्श।

XNNPACK Google द्वारा CPU के लिए डिफ़ॉल्ट TF Lite डेलीगेट के रूप में विकसित किया गया था (डिफ़ॉल्ट रूप से TFLite Runtime में शामिल)। यह 90+ संचालन का समर्थन करता है — GPU या NNAPI से अधिक। XNNPACK क्वांटाइज़्ड मॉडल (INT8, INT16) के लिए विशेष रूप से प्रभावी है: संचालन float32 संस्करण की तुलना में 2–3 गुना तेज़ चलते हैं। Google बेंचमार्क (2025) के अनुसार, XNNPACK INT8 MobileNetV2 को बेसलाइन CPU की तुलना में 2.8x तेज़ करता है।

XNNPACK बनाम GPU: NPU के बिना उपकरणों पर, XNNPACK छोटे बैच (1–4) के लिए GPU Delegate से अक्सर तेज़ होता है — GPU में CPU और GPU के बीच डेटा स्थानांतरण पर ओवरहेड होता है। XNNPACK उसी CPU एड्रेस स्पेस में काम करता है — कोई मेमोरी कॉपी नहीं। 5MB तक के मॉडल के लिए, XNNPACK GPU से तेज़ हो सकता है। बड़े CNN मॉडल के लिए, GPU समानांतरता के कारण जीतता है।

// TFLite 2.18+ में डिफ़ॉल्ट रूप से XNNPACK Delegate सक्षम
// XnnpackDelegate के माध्यम से स्पष्ट उपयोग
val xnnpackOptions = XnnpackDelegate.Options().apply {
    numThreads = 4
    flags = XnnpackDelegate.Flags.USE_XNNPACK
}
val delegate = XnnpackDelegate(xnnpackOptions)
val interpreter = Interpreter(modelBuffer, Interpreter.Options().apply {
    addDelegate(delegate)
})

XNNPACK फ़्लैग्स: USE_XNNPACK — डेलीगेट को बलपूर्वक सक्षम करता है, FLUSH_TO_ZERO — त्वरण के लिए डीनॉर्मलाइज़्ड संख्याओं को संभालता है, ENABLE_XNNPACK_SHAPES — डायनामिक इनपुट आकार। अधिकतम संगतता के लिए, डिफ़ॉल्ट विकल्पों का उपयोग करें। पुराने उपकरणों पर त्रुटियाँ होने पर, XNNPACK को अक्षम करें — मॉडल अभी भी CPU पर चलता है लेकिन धीमा।

Core ML और Metal Delegate: iOS पर त्वरण

Core ML Delegate iOS के लिए TensorFlow Lite डेलीगेट है जो Apple Core ML Framework का उपयोग करता है। Core ML TF Lite मॉडल को .mlmodel फ़ॉर्मेट में बदलता है और इसे Apple Neural Engine (ANE), GPU (Metal) या CPU पर निष्पादित करता है। Apple A17 Pro और M3 में समर्पित Neural Engine है जिसका Core ML स्वचालित रूप से उपयोग करता है। Core ML Delegate आधुनिक iOS उपकरणों पर CPU की तुलना में इन्फ़रेंस को 5–10 गुना तेज़ करता है।

iOS पर Core ML flex delegate (Core ML के लिए उपलब्ध संचालन का गतिशील डेलीगेशन) और पूर्ण मॉडल रूपांतरण (पूरे मॉडल को .mlmodel में बदलना) का समर्थन करता है। Apple flex delegate की सिफारिश करता है — यह तेज़ है क्योंकि यह बिना पूर्व रूपांतरण के रनटाइम पर काम करता है। Core ML Delegate float32, float16 और क्वांटाइज़्ड मॉडल (INT8) का समर्थन करता है।

Metal Delegate एक निचले स्तर का डेलीगेट है जो सीधे Metal Performance Shaders के साथ काम करता है। जब Core ML विशिष्ट संचालन का समर्थन नहीं करता है तब Metal का उपयोग करें। Metal Delegate GPU पर अधिकतम नियंत्रण प्रदान करता है लेकिन अधिक कोड की आवश्यकता होती है। Apple (WWDC 2024) के अनुसार, मूल Swift मॉडल के लिए Metal Delegate रूपांतरण ओवरहेड की अनुपस्थिति के कारण Core ML से 15–20% तेज़ हो सकता है।

// TFLite Swift API के माध्यम से iOS पर Core ML Delegate
import TensorFlowLite

let coreMLDelegate = CoreMLDelegate()
var options = InterpreterOptions()
options.addDelegate(coreMLDelegate)

let interpreter = try Interpreter(modelPath: modelPath, options: options)
try interpreter.invoke(at: 0)

Core ML और Metal के बीच चयन: प्रोडक्शन के लिए Core ML, एज केस के लिए Metal। Core ML स्वचालित रूप से NE मेमोरी प्रबंधित करता है, CPU फ़ॉलबैक का समर्थन करता है और मैन्युअल रूपांतरण की आवश्यकता नहीं है। Metal बफ़र नियंत्रण प्रदान करता है और कस्टम संचालन के लिए उपयुक्त है। IT Sectr प्रोजेक्ट्स में, हम सभी iOS मॉडल के लिए Core ML Delegate और केवल रीयल-टाइम वीडियो एनालिटिक्स कार्यों के लिए Metal का उपयोग करते हैं।

अपने प्रोजेक्ट के लिए डेलीगेट कैसे चुनें

TF Lite Delegate चुनना लक्ष्य प्लेटफ़ॉर्म, मॉडल और लेटेंसी आवश्यकताओं पर निर्भर करता है। कोई सार्वभौमिक सर्वश्रेष्ठ डेलीगेट नहीं है — प्रत्येक की ताकत और कमज़ोरियाँ हैं। इष्टतम रणनीति: लक्ष्य डिवाइस पर सभी उपलब्ध डेलीगेट का परीक्षण करें और न्यूनतम तेज़ चुनें — सबसे तेज़ नहीं, बल्कि न्यूनतम पर्याप्त।

चयन के लिए सिफ़ारिशें: NPU वाले Android (Snapdragon 8 Gen 2+, Dimensity 9000+) के लिए — NNAPI Delegate। NPU के बिना Android के लिए — XNNPACK Delegate (डिफ़ॉल्ट)। iOS के लिए — Core ML Delegate। क्रॉस-प्लेटफ़ॉर्म प्रोजेक्ट के लिए, रणनीति का उपयोग करें: Android पर NNAPI, iOS पर Core ML, XNNPACK फ़ॉलबैक के रूप में। GPU Delegate — जब NNAPI उपलब्ध न हो और XNNPACK पर्याप्त तेज़ न हो।

लेटेंसी परीक्षण चयन का एक अनिवार्य कदम है। न्यूनतम तापमान (ठंडा डिवाइस) और 5 मिनट के निरंतर संचालन (थर्मल थ्रॉटलिंग) के बाद इन्फ़रेंस मापें। GPU और NNAPI गर्म होने पर प्रदर्शन कम कर सकते हैं। XNNPACK (CPU) कम प्रभावित होता है। अपने डिवाइस पर सभी डेलीगेट के स्वचालित परीक्षण के लिए TensorFlow Lite Benchmark Tool का उपयोग करें।

// डेलीगेट चयन रणनीति
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

फ़ॉलबैक रणनीति — मॉडल को बिना अपवादों के लोड करें: यदि डेलीगेट समर्थित नहीं है, तो CPU पर चलाएँ। TensorFlow Lite डेलीगेट निर्माण त्रुटि पर IllegalArgumentException फेंकता है। डेलीगेट निर्माण को try-catch में लपेटें और त्रुटि पर मॉडल को बिना डेलीगेट के चलाएँ। धीमा लेकिन काम करने वाला AI उपयोगकर्ता के लिए त्रुटि से बेहतर है।