Neural Networks API

Android Neural Networks API (NNAPI) एक Android C API है. इसे चलाने के लिए डिज़ाइन किया गया है इसमें Android डिवाइसों पर मशीन लर्निंग के लिए कंप्यूटेशनल रूप से ज़्यादा इस्तेमाल किया जाता है. NNAPI को उच्च-लेवल के फ़ंक्शन की बुनियादी लेयर देने के लिए डिज़ाइन किया गया है मशीन लर्निंग फ़्रेमवर्क, जैसे कि TensorFlow Lite और Caffe2, जो न्यूरल नेटवर्क बनाते और उन्हें ट्रेनिंग देते हैं. एपीआई उपलब्ध है Android 8.1 (एपीआई लेवल 27) या उसके बाद के वर्शन वाले सभी Android डिवाइसों पर इस्तेमाल किया जा सकता है.

NNAPI, Android डिवाइसों के डेटा को पहले के डेटा पर लागू करके अनुमान लगाने की सुविधा देता है ट्रेन किए गए, डेवलपर के बनाए हुए मॉडल. अनुमान के उदाहरणों में कैटगरी तय करना उपयोगकर्ता के व्यवहार का अनुमान लगाना, और किसी खोज क्वेरी.

डिवाइस पर मौजूद अनुमान के कई फ़ायदे हैं:

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

डेवलपर को इन बातों का भी ध्यान रखना चाहिए:

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

NNAPI का इस्तेमाल करने का एक उदाहरण देखने के लिए, Android Neural Networks API का सैंपल देखें.

Neural Networks API के रनटाइम को समझना

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

Android डिवाइस पर मौजूद ऐप्लिकेशन की ज़रूरतों और हार्डवेयर की क्षमताओं के आधार पर, Android का न्यूरल नेटवर्क रनटाइम, डिवाइस पर मौजूद प्रोसेसर के बीच, कैलकुलेशन का वर्कलोड बेहतर तरीके से बांट सकता है. इनमें, खास तौर पर डिज़ाइन किए गए न्यूरल नेटवर्क हार्डवेयर, ग्राफ़िक प्रोसेसिंग यूनिट (GPU), और डिजिटल सिग्नल प्रोसेसर (DSP) शामिल हैं.

जिन Android डिवाइसों में खास वेंडर ड्राइवर की कमी होती है उनके लिए NNAPI रनटाइम सीपीयू पर अनुरोधों को एक्ज़ीक्यूट करता है.

पहली इमेज में, NNAPI के लिए सिस्टम का हाई-लेवल आर्किटेक्चर दिखाया गया है.

पहली इमेज. Android Neural Networks API के लिए सिस्टम आर्किटेक्चर

Neural Networks API का प्रोग्रामिंग मॉडल

NNAPI का इस्तेमाल करके कैलकुलेशन करने के लिए, आपको सबसे पहले एक डायरेक्टेड ग्राफ़ बनाना होगा. इससे, आपको यह तय करने में मदद मिलेगी कि कौनसी कैलकुलेशन करनी है. यह कैलकुलेशन ग्राफ़, आपके इनपुट डेटा (उदाहरण के लिए, मशीन लर्निंग फ़्रेमवर्क से मिले वेट और बायस) के साथ मिलकर, NNAPI के रनटाइम आकलन के लिए मॉडल बनाता है.

NNAPI, चार मुख्य एब्स्ट्रैक्शन का इस्तेमाल करता है:

  • मॉडल: यह गणितीय ऑपरेशन और ट्रेनिंग प्रोसेस से सीखी गई स्थिर वैल्यू का कंप्यूटेशन ग्राफ़ होता है. ये ऑपरेशन, न्यूरल नेटवर्क के लिए खास तौर पर होते हैं. इनमें दो डाइमेंशन (2D) वाला कन्वोल्यूशन, लॉजिस्टिक (सिग्मॉइड) ऐक्टिवेशन, रेक्टिफ़ाइड लीनियर (ReLU) ऐक्टिवेशन वगैरह शामिल हैं. मॉडल बनाना एक सिंक्रोनस कार्रवाई है. टैग बनाने के बाद, उसका इस्तेमाल सभी थ्रेड और कलेक्शन में किया जा सकता है. NNAPI में, मॉडल को ANeuralNetworksModel इंस्टेंस.
  • कंपाइलेशन: यह, NNAPI मॉडल को कंपाइल करने के लिए कॉन्फ़िगरेशन को दिखाता है निचले लेवल के कोड का इस्तेमाल करें. कंपाइलेशन एक सिंक्रोनस कार्रवाई है. इसे बनाने के बाद, इसे सभी थ्रेड और एक्सीक्यूशन में फिर से इस्तेमाल किया जा सकता है. तय सीमा में NNAPI, हर कंपाइलेशन को ANeuralNetworksCompilation इंस्टेंस.
  • मेमोरी: शेयर की गई मेमोरी, मैप की गई मेमोरी की गई फ़ाइलों, और उससे मिलती-जुलती मेमोरी को दिखाता है बफ़र. मेमोरी बफ़र का इस्तेमाल करने से, NNAPI रनटाइम, ड्राइवर को डेटा को ज़्यादा बेहतर तरीके से ट्रांसफ़र कर पाता है. ऐप्लिकेशन आम तौर पर एक शेयर किया गया मेमोरी बफ़र बनाता है, जो इसमें मॉडल तय करने के लिए ज़रूरी हर टेंसर होता है. इसके लिए, एक्ज़ीक्यूशन के इंस्टेंस के इनपुट और आउटपुट को स्टोर करने के लिए बफ़र. एनएनएपीआई में, हर मेमोरी बफ़र को ANeuralNetworksMemory इंस्टेंस.

  • एक्सीक्यूशन: इनपुट के सेट पर NNAPI मॉडल लागू करने और नतीजे इकट्ठा करने के लिए इंटरफ़ेस. एक्ज़ीक्यूशन, सिंक्रोनस या एसिंक्रोनस तरीके से किया जा सकता है.

    असाइनमेंट को एक साथ लागू करने के लिए, एक ही असाइनमेंट पर कई थ्रेड इंतज़ार कर सकते हैं. यह प्रोग्राम पूरा होने के बाद, सभी थ्रेड को रिलीज़ किया गया.

    NNAPI में, हर एक्सीक्यूशन को ANeuralNetworksExecution के तौर पर दिखाया जाता है.

दूसरी इमेज में, प्रोग्रामिंग का बुनियादी फ़्लो दिखाया गया है.

दूसरी इमेज. Android Neural Networks API के लिए प्रोग्रामिंग फ़्लो

इस सेक्शन के बाकी हिस्से में, NNAPI मॉडल को सेट अप करने का तरीका बताया गया है कंप्यूटेशन (हिसाब लगाना), मॉडल को कंपाइल करना, और कंपाइल किए गए मॉडल को एक्ज़ीक्यूट करना.

ट्रेनिंग डेटा का ऐक्सेस देना

आपके ट्रेन किए गए वज़न और पूर्वाग्रह के डेटा को शायद फ़ाइल में सेव किया जाता है. NNAPI रनटाइम को इस डेटा का बेहतर तरीके से ऐक्सेस देने के लिए, ANeuralNetworksMemory_createFromFd() फ़ंक्शन को कॉल करके ANeuralNetworksMemory इंस्टेंस बनाएं और खोली गई डेटा फ़ाइल का फ़ाइल डिस्क्रिप्टर पास करें. साथ ही, आपको मेमोरी सुरक्षा फ़्लैग और फ़ाइल में शेयर की गई मेमोरी का वह हिस्सा भी बताना होगा जहां से मेमोरी का इस्तेमाल शुरू होता है.

// Create a memory buffer from the file that contains the trained data
ANeuralNetworksMemory* mem1 = NULL;
int fd = open("training_data", O_RDONLY);
ANeuralNetworksMemory_createFromFd(file_size, PROT_READ, fd, 0, &mem1);

हालांकि, इस उदाहरण में हम सिर्फ़ एक ANeuralNetworksMemory का उदाहरण लेते हैं, तो एक से ज़्यादा वज़न उठाने के लिए एक से ज़्यादा एक से ज़्यादा फ़ाइलों के लिए ANeuralNetworksMemory इंस्टेंस.

स्थानीय हार्डवेयर बफ़र का इस्तेमाल करें

मॉडल के इनपुट, आउटपुट, और ऑपरेंड की स्थिर वैल्यू के लिए, नेटिव हार्डवेयर बफ़र का इस्तेमाल किया जा सकता है. कुछ मामलों में, ड्राइवर के डेटा को कॉपी किए बिना, NNAPI accelerator, AHardwareBuffer ऑब्जेक्ट को ऐक्सेस कर सकता है. AHardwareBuffer में कई अलग-अलग कॉन्फ़िगरेशन होते हैं, और हर NNAPI एक्सेलरेटर सभी ब्राउज़र पर काम नहीं करता ये कॉन्फ़िगरेशन. इस सीमा की वजह से, ANeuralNetworksMemory_createFromAHardwareBuffer रेफ़रंस दस्तावेज़ में बताई गई पाबंदियों को देखें. साथ ही, टारगेट डिवाइसों पर पहले से जांच करें, ताकि यह पक्का किया जा सके कि AHardwareBuffer का इस्तेमाल करने वाले कंपाइलेशन और एक्सीक्यूशन, उम्मीद के मुताबिक काम करते हैं. इसके लिए, ऐक्सेलरेटर की जानकारी देने के लिए, डिवाइस असाइनमेंट का इस्तेमाल करें.

NNAPI रनटाइम को AHardwareBuffer ऑब्जेक्ट ऐक्सेस करने की अनुमति देने के लिए, ANeuralNetworksMemory_createFromAHardwareBuffer फ़ंक्शन को कॉल करके और AHardwareBuffer ऑब्जेक्ट को पास करके, ANeuralNetworksMemory इंस्टेंस बनाएं. इसका उदाहरण नीचे दिए गए कोड सैंपल में दिया गया है:

// Configure and create AHardwareBuffer object
AHardwareBuffer_Desc desc = ...
AHardwareBuffer* ahwb = nullptr;
AHardwareBuffer_allocate(&desc, &ahwb);

// Create ANeuralNetworksMemory from AHardwareBuffer
ANeuralNetworksMemory* mem2 = NULL;
ANeuralNetworksMemory_createFromAHardwareBuffer(ahwb, &mem2);

जब NNAPI को AHardwareBuffer ऑब्जेक्ट को ऐक्सेस करने की ज़रूरत न हो, तो उसे खाली करें संबंधित ANeuralNetworksMemory इंस्टेंस:

ANeuralNetworksMemory_free(mem2);

ध्यान दें:

  • इस्तेमाल करने के लिए AHardwareBuffer सिर्फ़ पूरे बफ़र के लिए; आप इसे इसके साथ इस्तेमाल नहीं कर सकते एक ARect पैरामीटर.
  • NNAPI रनटाइम, बफ़र को फ़्लश नहीं करेगा. आपको यह पक्का करना होगा कि इनपुट और आउटपुट बफ़र इसे एक्ज़िक्यूशन शेड्यूल करने से पहले ऐक्सेस किया जा सकता है.
  • इसके लिए कोई सहायता उपलब्ध नहीं है फ़ेंस फ़ाइल डिस्क्रिप्टर सिंक करें.
  • अगर AHardwareBuffer में, वेंडर के हिसाब से फ़ॉर्मैट और इस्तेमाल के बिट हैं, तो यह तय करना वेंडर के लिए ज़रूरी है कि कैश मेमोरी को फ़्लश करने की ज़िम्मेदारी क्लाइंट की है या ड्राइवर की.

मॉडल

मॉडल, NNAPI में कंप्यूटेशन की बुनियादी इकाई है. हर मॉडल को एक या एक से ज़्यादा ऑपरेंड और ऑपरेशन से तय किया जाता है.

ऑपरेंड

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

एनएनएपीआई मॉडल में दो तरह के ऑपरेंड जोड़े जा सकते हैं: स्केलर और टेंसर.

स्केलर एक वैल्यू दिखाता है. NNAPI, स्केलर वैल्यू को बूलियन, 16-बिट फ़्लोटिंग पॉइंट, 32-बिट फ़्लोटिंग पॉइंट, 32-बिट पूर्णांक, और बिना साइन वाले 32-बिट पूर्णांक फ़ॉर्मैट में इस्तेमाल करता है.

एनएनएपीआई की ज़्यादातर कार्रवाइयों में टेंसर शामिल होते हैं. टेन्सर, एन-डाइमेंशन वाले सरण होते हैं. NNAPI, 16-बिट फ़्लोटिंग पॉइंट, 32-बिट फ़्लोटिंग पॉइंट वाले टेंसर के साथ काम करता है क्वांटाइज़्ड, 16-बिट क्वांटाइज़्ड, 32-बिट इंटीजर, और 8-बिट बूलियन वैल्यू.

उदाहरण के लिए, तीसरी इमेज में दो संक्रियाओं वाला मॉडल दिखाया गया है: जोड़ इसके बाद गुणा करें. यह मॉडल, इनपुट टेंसर लेकर, एक इनपुट टेंसर बनाता है आउटपुट टेंसर.

तीसरी इमेज. NNAPI मॉडल के लिए ऑपरेंड का उदाहरण

ऊपर दिए गए मॉडल में सात ऑपरेंड हैं. इन ऑपरेंड की पहचान सीधे तौर पर इससे की जाती है उस ऑर्डर का इंडेक्स जिसमें उन्हें मॉडल में जोड़ा जाता है. पहला ऑपरेंड जोड़ा गया इंडेक्स 0 है और दूसरा इंडेक्स 1 है. इसी तरह दूसरे का इंडेक्स है. ओपेरैंड 1, 2, 3, और 5 कॉन्सटैंट ऑपरेंड हैं.

आप जिस क्रम में ऑपरेंड जोड़ते हैं वह इस पर कोई असर नहीं पड़ता. उदाहरण के लिए, मॉडल के आउटपुट ऑपरेंड को पहले जोड़ा जा सकता है. सबसे अहम बात यह है कि सही इंडेक्स मान का इस्तेमाल करें.

ऑपरेंड के टाइप होते हैं. इनका इस्तेमाल तब किया जाता है, जब इन्हें मॉडल में जोड़ा जाता है.

ऑपरेंड का इस्तेमाल, मॉडल के इनपुट और आउटपुट, दोनों के तौर पर नहीं किया जा सकता.

हर ऑपरेंड, मॉडल इनपुट, कॉन्सटेंट या ठीक एक ऑपरेशन का आउटपुट ऑपरेंड होना चाहिए.

ऑपरेंड इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, ऑपरेंड के बारे में ज़्यादा जानें लेख पढ़ें.

ऑपरेशंस

ऑपरेशन से पता चलता है कि कौनसे कैलकुलेशन करने हैं. हर ऑपरेशन में ये एलिमेंट होते हैं:

  • कार्रवाई का टाइप (उदाहरण के लिए, जोड़ना, गुणा करना, और कन्वर्ज़न वैल्यू),
  • उन ऑपरेंड के इंडेक्स की सूची जिनका इस्तेमाल ऑपरेशन, इनपुट के लिए करता है, और
  • ऑपरेंड के इंडेक्स की सूची, जिसका इस्तेमाल ऑपरेशन, आउटपुट के लिए करता है.

इन सूचियों में ऑर्डर का फ़र्क़ पड़ता है. हर तरह के ऑपरेशन के अनुमानित इनपुट और आउटपुट के लिए, NNAPI API का रेफ़रंस देखें.

ऑपरेशन जोड़ने से पहले, आपको मॉडल में ऐसे ऑपरेंड जोड़ने होंगे जिन्हें ऑपरेशन इस्तेमाल करता है या जिनका इस्तेमाल करके ऑपरेशन करता है.

ऑपरेशन जिस क्रम में जोड़े जाते हैं उससे कोई फ़र्क़ नहीं पड़ता. NNAPI, ऑपरेंड और ऑपरेशन के कैलकुलेशन ग्राफ़ से तय की गई डिपेंडेंसी पर निर्भर करता है. इससे यह तय होता है कि ऑपरेशन किस क्रम में लागू किए जाएं.

NNAPI के साथ काम करने वाली कार्रवाइयों की खास जानकारी नीचे टेबल में दी गई है:

कैटगरी ऑपरेशंस
एलिमेंट के हिसाब से गणितीय ऑपरेशन
टेंसर मैनिप्युलेशन
इमेज से जुड़ी कार्रवाइयां
लुकअप कार्रवाइयां
नॉर्मलाइज़ेशन ऑपरेशन
कॉन्वोल्यूशन ऑपरेशंस
पूलिंग से जुड़ी कार्रवाइयां
ऐक्टिवेशन ऑपरेशन
अन्य कार्रवाइयां

एपीआई लेवल 28 में एक समस्या: Android 9 (एपीआई लेवल 28) और उसके बाद के वर्शन पर उपलब्ध ANEURALNETWORKS_PAD ऑपरेशन में ANEURALNETWORKS_TENSOR_QUANT8_ASYMM टेन्सर पास करने पर, हो सकता है कि NNAPI का आउटपुट, TensorFlow Lite जैसे बेहतर मशीन लर्निंग फ़्रेमवर्क के आउटपुट से मेल न खाए. इसके बजाय, आपको सिर्फ़ ANEURALNETWORKS_TENSOR_FLOAT32 को पास करना चाहिए. यह समस्या, Android 10 (एपीआई लेवल 29) और उसके बाद के वर्शन में हल हो गई है.

मॉडल बनाएं

नीचे दिए गए उदाहरण में, हमने दो-ऑपरेशन मॉडल बनाया है. यह मॉडल तीसरी इमेज.

मॉडल बनाने के लिए, यह तरीका अपनाएं:

  1. कॉल करें ANeuralNetworksModel_create() फ़ंक्शन का इस्तेमाल करें.

    ANeuralNetworksModel* model = NULL;
ANeuralNetworksModel_create(&model);

  2. कॉल करके अपने मॉडल में ऑपरेंड जोड़ें ANeuralNetworks_addOperand(). उनका डेटा टाइप, ANeuralNetworksOperandType का इस्तेमाल किया जा सकता है.

    // In our example, all our tensors are matrices of dimension [3][4]
ANeuralNetworksOperandType tensor3x4Type;
tensor3x4Type.type = ANEURALNETWORKS_TENSOR_FLOAT32;
tensor3x4Type.scale = 0.f;    // These fields are used for quantized tensors
tensor3x4Type.zeroPoint = 0;  // These fields are used for quantized tensors
tensor3x4Type.dimensionCount = 2;
uint32_t dims[2] = {3, 4};
tensor3x4Type.dimensions = dims;

    
// We also specify operands that are activation function specifiers
ANeuralNetworksOperandType activationType;
activationType.type = ANEURALNETWORKS_INT32;
activationType.scale = 0.f;
activationType.zeroPoint = 0;
activationType.dimensionCount = 0;
activationType.dimensions = NULL;

    
// Now we add the seven operands, in the same order defined in the diagram
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 0
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 1
ANeuralNetworksModel_addOperand(model, &activationType); // operand 2
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 3
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 4
ANeuralNetworksModel_addOperand(model, &activationType); // operand 5
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 6

  3. जिन ऑपरेंड की वैल्यू एक जैसी होती है उनके लिए, ANeuralNetworksModel_setOperandValue() और ANeuralNetworksModel_setOperandValueFromMemory() फ़ंक्शन का इस्तेमाल करें. जैसे, वेट और बायस, जिन्हें आपका ऐप्लिकेशन ट्रेनिंग प्रोसेस से हासिल करता है.

    नीचे दिए गए उदाहरण में, हमने ट्रेनिंग डेटा का ऐक्सेस दें में बनाए गए मेमोरी बफ़र के हिसाब से, ट्रेनिंग डेटा फ़ाइल से कॉन्स्टेंट वैल्यू सेट की हैं.

    // In our example, operands 1 and 3 are constant tensors whose values were
// established during the training process
const int sizeOfTensor = 3 * 4 * 4;    // The formula for size calculation is dim0 * dim1 * elementSize
ANeuralNetworksModel_setOperandValueFromMemory(model, 1, mem1, 0, sizeOfTensor);
ANeuralNetworksModel_setOperandValueFromMemory(model, 3, mem1, sizeOfTensor, sizeOfTensor);

    
// We set the values of the activation operands, in our example operands 2 and 5
int32_t noneValue = ANEURALNETWORKS_FUSED_NONE;
ANeuralNetworksModel_setOperandValue(model, 2, &noneValue, sizeof(noneValue));
ANeuralNetworksModel_setOperandValue(model, 5, &noneValue, sizeof(noneValue));

  4. डायरेक्टेड ग्राफ़ में हर उस ऑपरेशन के लिए जिसका आपको हिसाब लगाना है, ANeuralNetworksModel_addOperation() फ़ंक्शन को कॉल करके, अपने मॉडल में ऑपरेशन जोड़ें.

    इस कॉल के पैरामीटर के तौर पर, आपके ऐप्लिकेशन को ये जानकारी देनी होगी:

    • ऑपरेशन का टाइप
    • इनपुट वैल्यू की संख्या
    • इनपुट ऑपरेंड के इंडेक्स का कलेक्शन
    • आउटपुट वैल्यू की संख्या
    • आउटपुट ऑपरेंड के लिए इंडेक्स का अरे

    ध्यान दें कि एक ही ऑपरेंड को एक ही इनपुट और आउटपुट दोनों के लिए इस्तेमाल नहीं किया जा सकता कार्रवाई.

    // We have two operations in our example
// The first consumes operands 1, 0, 2, and produces operand 4
uint32_t addInputIndexes[3] = {1, 0, 2};
uint32_t addOutputIndexes[1] = {4};
ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, addInputIndexes, 1, addOutputIndexes);

    
// The second consumes operands 3, 4, 5, and produces operand 6
uint32_t multInputIndexes[3] = {3, 4, 5};
uint32_t multOutputIndexes[1] = {6};
ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_MUL, 3, multInputIndexes, 1, multOutputIndexes);

  5. ANeuralNetworksModel_identifyInputsAndOutputs() फ़ंक्शन को कॉल करके, यह पता लगाएं कि मॉडल को किन ऑपरेंड को इनपुट और आउटपुट के तौर पर इस्तेमाल करना चाहिए.

    // Our model has one input (0) and one output (6)
uint32_t modelInputIndexes[1] = {0};
uint32_t modelOutputIndexes[1] = {6};
ANeuralNetworksModel_identifyInputsAndOutputs(model, 1, modelInputIndexes, 1 modelOutputIndexes);

  6. इसके अलावा, ANeuralNetworksModel_relaxComputationFloat32toFloat16() को कॉल करके यह भी तय किया जा सकता है कि ANEURALNETWORKS_TENSOR_FLOAT32 की गिनती, रेंज या सटीक वैल्यू के साथ की जाए या नहीं. यह वैल्यू, आईईईई 754 16-बिट फ़्लोटिंग-पॉइंट फ़ॉर्मैट के बराबर या उससे कम होनी चाहिए.

  7. ANeuralNetworksModel_finish() पर कॉल करें की मदद से, अपने मॉडल की परिभाषा को फ़ाइनल किया जा सकता है. अगर कोई गड़बड़ी नहीं है, तो यह फ़ंक्शन ANEURALNETWORKS_NO_ERROR वाला नतीजा कोड दिखाता है.

    ANeuralNetworksModel_finish(model);

मॉडल बनाने के बाद, उसे कई बार कंपाइल किया जा सकता है और हर बार एक्ज़ीक्यूट किया जा सकता है कितनी बार भी कंपाइल किया जा सकता है.

कंट्रोल फ़्लो

NNAPI मॉडल में कंट्रोल फ़्लो शामिल करने के लिए, यह तरीका अपनाएं:

  1. संबंधित एक्ज़ीक्यूशन सबग्राफ़ (then और else सबग्राफ़) बनाएं IF स्टेटमेंट के लिए, WHILE लूप के लिए condition और body सबग्राफ़) स्टैंडअलोन ANeuralNetworksModel* मॉडल के रूप में:

    ANeuralNetworksModel* thenModel = makeThenModel();
ANeuralNetworksModel* elseModel = makeElseModel();

  2. ऐसे ऑपरेंड बनाएं, जिनमें उन मॉडल का संदर्भ हो जिसमें नियंत्रण फ़्लो:

    ANeuralNetworksOperandType modelType = {
    .type = ANEURALNETWORKS_MODEL,
};
ANeuralNetworksModel_addOperand(model, &modelType);  // kThenOperandIndex
ANeuralNetworksModel_addOperand(model, &modelType);  // kElseOperandIndex
ANeuralNetworksModel_setOperandValueFromModel(model, kThenOperandIndex, &thenModel);
ANeuralNetworksModel_setOperandValueFromModel(model, kElseOperandIndex, &elseModel);

  3. कंट्रोल फ़्लो ऑपरेशन जोड़ें: 

    uint32_t inputs[] = {kConditionOperandIndex,
                     kThenOperandIndex,
                     kElseOperandIndex,
                     kInput1, kInput2, kInput3};
uint32_t outputs[] = {kOutput1, kOutput2};
ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_IF,
                                  std::size(inputs), inputs,
                                  std::size(output), outputs);

कंपाइलेशन

कंपाइल करने के चरण से यह तय होता है कि आपका मॉडल किन प्रोसेसर पर चलाया जाएगा और उनसे इसके लिए तैयार होने के लिए कहा जाता है. इसमें, उन प्रोसेसर के लिए मशीन कोड जनरेट करना शामिल हो सकता है जिन पर आपका मॉडल चलेगा.

मॉडल कंपाइल करने के लिए, इन चरणों का पालन करें:

  1. कॉल करें ANeuralNetworksCompilation_create() नया कंपाइलेशन इंस्टेंस बनाने के लिए इस्तेमाल किया जा सकता है.

    // Compile the model
ANeuralNetworksCompilation* compilation;
ANeuralNetworksCompilation_create(model, &compilation);

    इसके अलावा, डिवाइस असाइनमेंट का इस्तेमाल करके, यह साफ़ तौर पर चुना जा सकता है कि किस डिवाइस पर कार्रवाई की जाए.

  2. आपके पास यह तय करने का विकल्प होता है कि रनटाइम, बैटरी की खपत और प्रोग्राम को लागू करने की स्पीड के बीच किस तरह का समझौता करे. इसके लिए, ANeuralNetworksCompilation_setPreference() को कॉल करें.

    // Ask to optimize for low power consumption
ANeuralNetworksCompilation_setPreference(compilation, ANEURALNETWORKS_PREFER_LOW_POWER);

    आपके पास ये प्राथमिकताएं तय करने का विकल्प होता है:

    • ANEURALNETWORKS_PREFER_LOW_POWER: फ़ाइल को इस तरह से एक्ज़ीक्यूट करें कि बैटरी कम खर्च हो. यह उन कंपाइलेशन के लिए ज़रूरी है जिन्हें अक्सर चलाया जाता है.
    • ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER: ज्यादा से ज़्यादा तेज़ी से एक जवाब दें. भले ही, इससे ज़्यादा बिजली खर्च हो. यह डिफ़ॉल्ट विकल्प है.
    • ANEURALNETWORKS_PREFER_SUSTAINED_SPEED: लगातार फ़्रेम के थ्रूपुट को बढ़ाना चाहते हैं, जैसे कि जब जो कैमरे से लगातार फ़्रेम आ रही हैं.

  3. आपके पास वैकल्पिक तौर पर, ANeuralNetworksCompilation_setCaching को कॉल करके कंपाइलेशन कैश मेमोरी सेट अप करने का विकल्प है.

    // Set up compilation caching
ANeuralNetworksCompilation_setCaching(compilation, cacheDir, token);

    cacheDir के लिए, getCodeCacheDir() का इस्तेमाल करें. ऐप्लिकेशन में मौजूद हर मॉडल के लिए, token यूनीक होना चाहिए.

  4. ANeuralNetworksCompilation_finish() को कॉल करके, कंपाइलेशन डेफ़िनिशन को फ़ाइनल करें. अगर कोई गड़बड़ी नहीं है, तो यह फ़ंक्शन इस नतीजे का कोड दिखाता है ANEURALNETWORKS_NO_ERROR.

    ANeuralNetworksCompilation_finish(compilation);

डिवाइस ढूंढना और असाइन करना

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

कास्ट की सुविधा वाले डिवाइस खोजना

उपलब्ध डिवाइसों की संख्या जानने के लिए, ANeuralNetworks_getDeviceCount का इस्तेमाल करें. हर डिवाइस के लिए, ANeuralNetworksDevice इंस्टेंस को उस डिवाइस के रेफ़रंस पर सेट करने के लिए, ANeuralNetworks_getDevice का इस्तेमाल करें.

डिवाइस का रेफ़रंस मिलने के बाद, इन फ़ंक्शन का इस्तेमाल करके उस डिवाइस के बारे में ज़्यादा जानकारी पाई जा सकती है:

डिवाइस असाइनमेंट

इस्तेमाल की जाने वाली चीज़ें ANeuralNetworksModel_getSupportedOperationsForDevices का इस्तेमाल करके यह पता लगाया जा सकता है कि किसी मॉडल की कौनसी कार्रवाइयां खास डिवाइसों पर चलाई जा सकती हैं.

यह कंट्रोल करने के लिए कि एक्ज़ीक्यूट करने के लिए कौनसे एक्सेलरेटर का इस्तेमाल किया जाए, ANeuralNetworksCompilation_createForDevices ANeuralNetworksCompilation_create के स् थान पर. इससे मिलने वाले ANeuralNetworksCompilation ऑब्जेक्ट का सामान्य तरीके से इस्तेमाल करें. अगर दिए गए मॉडल में ऐसे ऑपरेशन शामिल हैं जो चुने गए डिवाइसों पर काम नहीं करते, तो फ़ंक्शन गड़बड़ी का मैसेज दिखाता है.

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

अन्य डिवाइसों की तरह ही, NNAPI सीपीयू को लागू करने के लिए, nnapi-reference नाम और ANEURALNETWORKS_DEVICE_TYPE_CPU टाइप वाले ANeuralNetworksDevice का इस्तेमाल किया जाता है. कॉल करते समय ANeuralNetworksCompilation_createForDevices, सीपीयू को लागू करने की प्रोसेस पूरी नहीं की गई है इसका इस्तेमाल, मॉडल कंपाइलेशन और उसे लागू करने में होने वाली गड़बड़ी के मामलों को हैंडल करने के लिए किया जाता है.

किसी मॉडल को उप-मॉडल में विभाजित करने की ज़िम्मेदारी ऐप्लिकेशन की होती है तय डिवाइस पर काम कर सकता है. ऐसे ऐप्लिकेशन जिनके लिए मैन्युअल तरीके से काम करने की ज़रूरत नहीं है सेगमेंट में बांटने का काम ANeuralNetworksCompilation_create सभी उपलब्ध डिवाइसों (सीपीयू समेत) का इस्तेमाल करने के लिए मॉडल. अगर ANeuralNetworksCompilation_createForDevices का इस्तेमाल करके बताए गए डिवाइसों पर, मॉडल पूरी तरह से काम नहीं करता है, तो ANEURALNETWORKS_BAD_DATA दिखाया जाता है.

मॉडल का बंटवारा

जब मॉडल के लिए एक से ज़्यादा डिवाइस उपलब्ध होते हैं, तो NNAPI रनटाइम, काम को सभी डिवाइसों पर बांट देता है. उदाहरण के लिए, अगर ANeuralNetworksCompilation_createForDevices को एक से ज़्यादा डिवाइस दिए गए थे, तो काम को असाइन करते समय उन सभी डिवाइसों को ध्यान में रखा जाएगा. ध्यान दें कि, अगर सीपीयू डिवाइस सूची में नहीं है, इसलिए सीपीयू चलाने की सुविधा बंद हो जाएगी. ANeuralNetworksCompilation_create का इस्तेमाल करते समय, सभी उपलब्ध डिवाइसों को ध्यान में रखा जाएगा. इनमें सीपीयू भी शामिल है.

डिस्ट्रिब्यूशन करने के लिए, उपलब्ध डिवाइसों की सूची में से हर डिवाइस को चुनें मॉडल की कार्रवाइयों के बारे में बताने के लिए, और उस कार्रवाई को सपोर्ट करने वाला डिवाइस सबसे बेहतर परफ़ॉर्मेंस की घोषणा करना, जैसे कि सबसे तेज़ एक्ज़ीक्यूशन का समय या इससे ऊर्जा की सबसे कम खपत होती है. यह इस बात पर निर्भर करता है कि एक्ज़ीक्यूशन के लिए कौनसा विकल्प दिया जाए से संपर्क करने के लिए प्रोत्साहित करें. बंटवारे का यह एल्गोरिदम मुमकिन नहीं है अलग-अलग प्रोसेसर के बीच IO के कारण अक्षमता होती है, इसलिए जब एक से ज़्यादा प्रोसेसर का इस्तेमाल करके (या तो इस्तेमाल करते समय साफ़ तौर पर ANeuralNetworksCompilation_createForDevices या अनुमान से ANeuralNetworksCompilation_create) से शुरू होने वाले नतीजे को शामिल करना ज़रूरी है का इस्तेमाल करें.

यह समझने के लिए कि NNAPI ने आपके मॉडल को कैसे बांटा है, मैसेज के लिए Android लॉग देखें (ExecutionPlan टैग के साथ INFO लेवल पर):

ModelBuilder::findBestDeviceForEachOperation(op-name): device-index

op-name, ग्राफ़ में किसी कार्रवाई की जानकारी देने वाला नाम है और device-index, डिवाइसों की सूची में कैंडिडेट डिवाइस का इंडेक्स है. यह सूची ANeuralNetworksCompilation_createForDevices को दिया गया इनपुट है या अगर ANeuralNetworksCompilation_createForDevices का इस्तेमाल किया जा रहा है, तो डिवाइसों की सूची ANeuralNetworks_getDeviceCount का इस्तेमाल करके सभी डिवाइसों पर दोहराने पर और ANeuralNetworks_getDevice.

मैसेज (ExecutionPlan टैग के साथ जानकारी के स्तर पर):

ModelBuilder::partitionTheWork: only one best device: device-name

यह मैसेज बताता है कि डिवाइस पर पूरे ग्राफ़ को एक्सेलरेट कर दिया गया है device-name.

प्लान लागू करना

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

कंपाइल किए गए मॉडल को चलाने के लिए, यह तरीका अपनाएं:

  1. कॉल करें ANeuralNetworksExecution_create() फ़ंक्शन का इस्तेमाल करें.

    // Run the compiled model against a set of inputs
ANeuralNetworksExecution* run1 = NULL;
ANeuralNetworksExecution_create(compilation, &run1);

  2. बताएं कि आपका ऐप्लिकेशन, कैलकुलेशन के लिए इनपुट वैल्यू कहां से पढ़ता है. आपका ऐप्लिकेशन उपयोगकर्ता के बफ़र या असाइन किए गए मेमोरी स्पेस से इनपुट वैल्यू पढ़ सकता है कॉल करके ANeuralNetworksExecution_setInput() या ANeuralNetworksExecution_setInputFromMemory() क्रम से.

    // Set the single input to our sample model. Since it is small, we won't use a memory buffer
float32 myInput[3][4] = { ...the data... };
ANeuralNetworksExecution_setInput(run1, 0, NULL, myInput, sizeof(myInput));

  3. बताएं कि आपका ऐप्लिकेशन आउटपुट वैल्यू कहां लिखता है. आपका ऐप्लिकेशन, आउटपुट वैल्यू को इनमें से किसी एक कॉल करके, उपयोगकर्ता बफ़र या तय मेमोरी स्पेस ANeuralNetworksExecution_setOutput() या ANeuralNetworksExecution_setOutputFromMemory() क्रम से.

    // Set the output
float32 myOutput[3][4];
ANeuralNetworksExecution_setOutput(run1, 0, NULL, myOutput, sizeof(myOutput));

  4. ANeuralNetworksExecution_startCompute() फ़ंक्शन को कॉल करके, प्रोसेस शुरू होने का समय शेड्यूल करें. अगर कोई गड़बड़ी नहीं है, तो यह फ़ंक्शन इस नतीजे का कोड दिखाता है ANEURALNETWORKS_NO_ERROR.

    // Starts the work. The work proceeds asynchronously
ANeuralNetworksEvent* run1_end = NULL;
ANeuralNetworksExecution_startCompute(run1, &run1_end);

  5. एक्ज़ीक्यूशन पूरा होने का इंतज़ार करने के लिए, ANeuralNetworksEvent_wait() फ़ंक्शन को कॉल करें. अगर प्रोग्राम को सफल है, तो यह फ़ंक्शन ANEURALNETWORKS_NO_ERROR. इंतज़ार करने की कार्रवाई, उस थ्रेड से अलग थ्रेड पर की जा सकती है जिससे एक्ज़ीक्यूशन शुरू किया गया है.

    // For our example, we have no other work to do and will just wait for the completion
ANeuralNetworksEvent_wait(run1_end);
ANeuralNetworksEvent_free(run1_end);
ANeuralNetworksExecution_free(run1);

  6. इसके अलावा, कंपाइल किए गए मॉडल में इनपुट का कोई दूसरा सेट लागू करने के लिए नया कोड बनाने के लिए उसी कंपाइलेशन इंस्टेंस का इस्तेमाल करना ANeuralNetworksExecution इंस्टेंस.

    // Apply the compiled model to a different set of inputs
ANeuralNetworksExecution* run2;
ANeuralNetworksExecution_create(compilation, &run2);
ANeuralNetworksExecution_setInput(run2, ...);
ANeuralNetworksExecution_setOutput(run2, ...);
ANeuralNetworksEvent* run2_end = NULL;
ANeuralNetworksExecution_startCompute(run2, &run2_end);
ANeuralNetworksEvent_wait(run2_end);
ANeuralNetworksEvent_free(run2_end);
ANeuralNetworksExecution_free(run2);

सिंक्रोनस एक्ज़ीक्यूशन

एसिंक्रोनस एक्ज़ीक्यूशन, थ्रेड को पैदा करने और उन्हें सिंक करने में समय लगाता है. इसके अलावा, इंतज़ार का समय बहुत अलग हो सकता है. साथ ही, थ्रेड के बारे में सूचना मिलने के बीच 500 माइक्रोसेकंड तक की देरी या प्रोसेस करना शुरू कर देता है और वह समय तय होता है जब इसे सीपीयू कोर से जोड़ा जाता है.

इंतज़ार का समय कम करने के लिए, किसी ऐप्लिकेशन को रनटाइम पर सिंक किए गए अनुमान के कॉल करने के लिए निर्देश दिया जा सकता है. वह कॉल सिर्फ़ तब वापस आएगा, जब अनुमान में किसी अनुमान के शुरू होने के बाद वापस लौटने के बजाय पूरा कर दिया जाता है. ऐप्लिकेशन, रनटाइम पर एसिंक्रोनस अनुमान कॉल के लिए, ANeuralNetworksExecution_startCompute को कॉल करने के बजाय, रनटाइम पर सिंक्रोनस कॉल करने के लिए, ANeuralNetworksExecution_compute को कॉल करता है. इन्हें कॉल किया गया ANeuralNetworksExecution_compute कोई ANeuralNetworksEvent नहीं लेता और ANeuralNetworksEvent_wait को किए गए कॉल के साथ जुड़ा नहीं है.

एक क्लिक में कई फ़ोटो (बर्स्ट) लेने की सुविधा

NNAPI, Android 10 (एपीआई लेवल 29) और इसके बाद के वर्शन वाले Android डिवाइसों पर, ANeuralNetworksBurst ऑब्जेक्ट की मदद से एक साथ कई निर्देशों को लागू करने की सुविधा देता है. बर्स्ट एक्सीक्यूशन, एक ही कलेक्शन को एक के बाद एक तेज़ी से चलाने का क्रम होता है. जैसे, कैमरे से कैप्चर किए गए फ़्रेम या एक के बाद एक ऑडियो सैंपल पर काम करना. ANeuralNetworksBurst ऑब्जेक्ट का इस्तेमाल करने पर हो सकता है के नतीजे तेज़ी से लागू होते हैं, क्योंकि इनसे एक्सेलरेटर को पता चलता है कि रिसॉर्स एक्ज़िक्यूशन के बीच फिर से इस्तेमाल किया जा सके और एक्सेलरेटर को बर्स्ट के समय की उच्च-परफ़ॉर्मेंस स्थिति.

ANeuralNetworksBurst सामान्य एक्ज़ीक्यूशन में सिर्फ़ एक छोटा बदलाव करता है पाथ. ANeuralNetworksBurst_create का इस्तेमाल करके, बर्स्ट ऑब्जेक्ट बनाया जाता है, जैसा कि नीचे दिए गए कोड स्निपेट में दिखाया गया है:

// Create burst object to be reused across a sequence of executions
ANeuralNetworksBurst* burst = NULL;
ANeuralNetworksBurst_create(compilation, &burst);

एक साथ कई बर्स्ट प्रोग्राम सिंक होते हैं. हालांकि, डाइग्नोस्टिक टूल का इस्तेमाल करके ANeuralNetworksExecution_compute हर अनुमान को पूरा करने के लिए, आप अलग-अलग ANeuralNetworksExecution फ़ंक्शन को कॉल में एक जैसे ANeuralNetworksBurst वाले ऑब्जेक्ट ANeuralNetworksExecution_burstCompute.

// Create and configure first execution object
// ...

// Execute using the burst object
ANeuralNetworksExecution_burstCompute(execution1, burst);

// Use results of first execution and free the execution object
// ...

// Create and configure second execution object
// ...

// Execute using the same burst object
ANeuralNetworksExecution_burstCompute(execution2, burst);

// Use results of second execution and free the execution object
// ...

जब ANeuralNetworksBurst ऑब्जेक्ट की ज़रूरत न हो, तो ANeuralNetworksBurst_free का इस्तेमाल करके उसे खाली करें.

// Cleanup
ANeuralNetworksBurst_free(burst);

एसिंक्रोनस कमांड क्यू और फ़ेंस किया गया एक्ज़ीक्यूशन

Android 11 और उसके बाद के वर्शन में, NNAPI, ANeuralNetworksExecution_startComputeWithDependencies() के ज़रिए, एक साथ कई टास्क को शेड्यूल करने के लिए एक और तरीका उपलब्ध कराता है. इस तरीके का इस्तेमाल करने पर, सभी आकलन शुरू करने से पहले, सिग्नल दिए जाने वाले इवेंट. एक्सीक्यूशन पूरा होने और आउटपुट इस्तेमाल के लिए तैयार होने के बाद, रिटर्न किए गए इवेंट को सिग्नल दिया जाता है.

इवेंट का बैक अप इस आधार पर लिया जा सकता है कि एक्ज़ीक्यूशन का इस्तेमाल कौनसे डिवाइस करते हैं सिंक फ़ेंस होना चाहिए. इवेंट के पूरा होने का इंतज़ार करने और एक्ज़ीक्यूशन के लिए इस्तेमाल किए गए संसाधनों को वापस पाने के लिए, आपको ANeuralNetworksEvent_wait() को कॉल करना होगा. आपने लोगों तक पहुंचाया मुफ़्त में किसी इवेंट ऑब्जेक्ट में सिंक फ़ेंस इंपोर्ट कर सकते हैं ANeuralNetworksEvent_createFromSyncFenceFd(), साथ ही, किसी इवेंट ऑब्जेक्ट से सिंक बाड़ों को एक्सपोर्ट किया जा सकता है. इसके लिए, ANeuralNetworksEvent_getSyncFenceFd().

डाइनैमिक साइज़ वाले आउटपुट

जिन मॉडल में आउटपुट का साइज़, इनपुट डेटा पर निर्भर करता है, उन मॉडल के लिए ANeuralNetworksExecution_getOutputOperandRank और ANeuralNetworksExecution_getOutputOperandDimensions का इस्तेमाल करें. इसका मतलब है कि जिन मॉडल को लागू करने के समय, उनका साइज़ तय नहीं किया जा सकता.

नीचे दिए गए कोड सैंपल में, ऐसा करने का तरीका बताया गया है:

// Get the rank of the output
uint32_t myOutputRank = 0;
ANeuralNetworksExecution_getOutputOperandRank(run1, 0, &myOutputRank);

// Get the dimensions of the output
std::vector<uint32_t> myOutputDimensions(myOutputRank);
ANeuralNetworksExecution_getOutputOperandDimensions(run1, 0, myOutputDimensions.data());

क्लीनअप करें

क्लीनअप चरण में उन आंतरिक संसाधनों को हटाया जाता है जिनका इस्तेमाल आपके ऐप्लिकेशन के लिए किया जाता है कंप्यूटेशन.

// Cleanup
ANeuralNetworksCompilation_free(compilation);
ANeuralNetworksModel_free(model);
ANeuralNetworksMemory_free(mem1);

गड़बड़ी को मैनेज करना और सीपीयू फ़ॉलबैक

अगर पार्टीशन के दौरान कोई गड़बड़ी होती है, अगर ड्राइवर (एक) मॉडल का एक हिस्सा या अगर कोई ड्राइवर कंपाइल किए गए मॉडल (एक) का हिस्सा नहीं चला पाता है, ऐसा हो सकता है कि NNAPI एक या एक से ज़्यादा एपीआई को लागू करने के लिए, अपने खुद के सीपीयू पर काम करे कार्रवाइयां.

अगर NNAPI क्लाइंट पर ऑपरेशन के ऑप्टिमाइज़ किए गए वर्शन मौजूद हैं (जैसे, उदाहरण के लिए, TFLite) तो सीपीयू फ़ॉलबैक को बंद करना फ़ायदेमंद हो सकता है और क्लाइंट के ऑप्टिमाइज़ किए गए ऑपरेशन लागू करने की वजह से होने वाली गड़बड़ियों को हैंडल कर सकता है.

Android 10 में, अगर ANeuralNetworksCompilation_createForDevices का इस्तेमाल करके कंपाइल किया जाता है, तो सीपीयू फ़ॉलबैक बंद हो जाएगा.

Android P में, अगर ड्राइवर पर NNAPI को लागू करने में समस्या आती है, तो इसे सीपीयू पर लागू किया जाता है. यह बात Android 10 पर भी तब लागू होती है, जब ANeuralNetworksCompilation_create ANeuralNetworksCompilation_createForDevices का इस्तेमाल किया गया है.

पहले एक्सीक्यूशन में, उस एक ही पार्टीशन के लिए फ़ॉलबैक होता है. अगर फिर भी वह काम नहीं करता है, तो सीपीयू पर पूरे मॉडल को फिर से आज़माया जाता है.

अगर किसी हिस्से को बांटा या कंपाइल नहीं किया जाता है, तो पूरे मॉडल को सीपीयू पर इस्तेमाल करने की कोशिश की जाएगी.

कुछ मामलों में, सीपीयू पर कुछ कार्रवाइयां काम नहीं करतीं. ऐसे में, फ़ॉलबैक के बजाय, कंपाइलेशन या एक्सीक्यूशन पूरा नहीं हो पाएगा.

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

यह पक्का करने के लिए कि कोई सीपीयू न प्रोसेस हो, ANeuralNetworksCompilation_createForDevices का इस्तेमाल करें डिवाइसों की सूची से nnapi-reference को हटा रही है. Android P की शुरुआत से, एक्ज़ीक्यूशन के समय फ़ॉलबैक को बंद किया जा सकता है. डीबग, debug.nn.partition प्रॉपर्टी को 2 पर सेट करके बनाया जाता है.

मेमोरी डोमेन

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

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

ओपेक मेमोरी को असाइन करने के लिए, नीचे दिया गया तरीका अपनाएं:

  1. नई यादें सेव करने के लिए, ANeuralNetworksMemoryDesc_create() फ़ंक्शन को कॉल करें:

    // Create a memory descriptor
ANeuralNetworksMemoryDesc* desc;
ANeuralNetworksMemoryDesc_create(&desc);

  2. ANeuralNetworksMemoryDesc_addInputRole() और ANeuralNetworksMemoryDesc_addOutputRole() को कॉल करके, सभी इनपुट और आउटपुट भूमिकाओं की जानकारी दें.

    // Specify that the memory may be used as the first input and the first output
// of the compilation
ANeuralNetworksMemoryDesc_addInputRole(desc, compilation, 0, 1.0f);
ANeuralNetworksMemoryDesc_addOutputRole(desc, compilation, 0, 1.0f);

  3. विकल्प के तौर पर, कॉल करके मेमोरी के डाइमेंशन की जानकारी दें ANeuralNetworksMemoryDesc_setDimensions().

    // Specify the memory dimensions
uint32_t dims[] = {3, 4};
ANeuralNetworksMemoryDesc_setDimensions(desc, 2, dims);

  4. कॉल करके, डिस्क्रिप्टर की परिभाषा तय करें ANeuralNetworksMemoryDesc_finish().

    ANeuralNetworksMemoryDesc_finish(desc);

  5. जितनी ज़रूरत हो उतनी मेमोरी असाइन करने के लिए, डिस्क्रिप्टर को ANeuralNetworksMemory_createFromDesc() में पास करें.

    // Allocate two opaque memories with the descriptor
ANeuralNetworksMemory* opaqueMem;
ANeuralNetworksMemory_createFromDesc(desc, &opaqueMem);

  6. जब आपको मेमोरी डिस्क्रिप्टर की ज़रूरत न हो, तब उसे खाली कर दें.

    ANeuralNetworksMemoryDesc_free(desc);

क्लाइंट, बनाए गए ANeuralNetworksMemory ऑब्जेक्ट का इस्तेमाल सिर्फ़ ANeuralNetworksExecution_setInputFromMemory() या ANeuralNetworksExecution_setOutputFromMemory() के साथ कर सकता है. ऐसा, ANeuralNetworksMemoryDesc ऑब्जेक्ट में बताई गई भूमिकाओं के हिसाब से किया जाता है. ऑफ़सेट और लंबाई के आर्ग्युमेंट को 0 पर सेट किया जाना चाहिए. इससे पता चलता है कि पूरी मेमोरी का इस्तेमाल किया गया है. क्लाइंट साफ़ तौर पर मेमोरी के कॉन्टेंट को सेट या एक्सट्रैक्ट भी कर सकता है. ऐसा करने के लिए, ANeuralNetworksMemory_copy().

आपके पास ऐसे डाइमेंशन या रैंक तय करने के लिए, जिनके बारे में कोई जानकारी नहीं दी गई है. ऐसे में, हो सकता है कि मेमोरी की सुविधा, ANEURALNETWORKS_OP_FAILED स्टेटस, अगर दी गई ऐसेट के साथ काम नहीं करता है ड्राइवर. क्लाइंट को फ़ॉलबैक लॉजिक लागू करने का सुझाव दिया जाता है. इसके लिए, Ashmem या BLOB-mode AHardwareBuffer की मदद से, ज़रूरत के मुताबिक बड़ा बफ़र तय करें.

जब NNAPI को अब ऑपैक मेमोरी ऑब्जेक्ट को ऐक्सेस करने की ज़रूरत न हो, तो उससे जुड़े ANeuralNetworksMemory इंस्टेंस को खाली करें:

ANeuralNetworksMemory_free(opaqueMem);

परफ़ॉर्मेंस का आकलन करना

अपने ऐप्लिकेशन की परफ़ॉर्मेंस का आकलन करने के लिए, समय-समय पर या प्रोफ़ाइल बनाना.

लागू होने में लगने वाला समय

अगर आपको रनटाइम के ज़रिए, एक्ज़ीक्यूशन का कुल समय तय करना है, तो सिंक्रोनस एक्ज़ीक्यूशन एपीआई का इस्तेमाल करें और कॉल में लगने वाले समय को मेज़र करें. आसानी से अपने कैलेंडर में जोड़ें. सॉफ़्टवेयर के निचले लेवल के ज़रिए, एक्ज़ीक्यूशन का कुल समय तय करना हो करने के लिए, ANeuralNetworksExecution_setMeasureTiming और ANeuralNetworksExecution_getDuration पाने के लिए:

  • ऐक्सेलरेटर पर एक्सिलरेटर पर लगने वाला समय (ड्राइवर में नहीं, जो होस्ट पर चलता है प्रोसेसर).
  • ड्राइवर में एक्सिलरेटर पर लगने वाला समय.

ड्राइवर में प्रोग्राम को लागू करने में लगने वाले समय में, ओवरहेड शामिल नहीं होता. जैसे, रनटाइम का समय और रनटाइम के लिए ड्राइवर से संपर्क करने के लिए ज़रूरी आईपीसी.

ये एपीआई, सबमिट किए गए काम और पूरे हो चुके काम के बीच का समय मापते हैं नहीं, बल्कि इवेंट की परफ़ॉर्मेंस को बेहतर बनाने में लगने वाले समय से ज़्यादा इस्तेमाल करने में परेशानी हो सकती है.

उदाहरण के लिए, अगर पहला अनुमान लगाने की प्रोसेस शुरू होती है, तो ड्राइवर दूसरा अनुमान लगाने के लिए काम करना बंद कर देता है. इसके बाद, वह पहला अनुमान लगाने की प्रोसेस फिर से शुरू करता है और उसे पूरा करता है. पहला अनुमान लगाने में लगने वाले समय में, वह समय भी शामिल होगा जब दूसरा अनुमान लगाने के लिए काम रोका गया था.

समय की यह जानकारी, ऐसे ऐप्लिकेशन के प्रोडक्शन डिप्लॉयमेंट के लिए काम की हो सकती है जिसमें ताकि ऑफ़लाइन इस्तेमाल के लिए टेलीमेट्री इकट्ठा करने की सुविधा मिल सके. समय की जानकारी देने वाले डेटा का इस्तेमाल, इन कामों के लिए किया जा सकता है बेहतर परफ़ॉर्मेंस के लिए ऐप्लिकेशन में बदलाव करें.

इस सुविधा का इस्तेमाल करते समय, इन बातों का ध्यान रखें:

  • समय की जानकारी इकट्ठा करने से, परफ़ॉर्मेंस पर असर पड़ सकता है.
  • केवल एक ड्राइवर ही अपने आप में या एक्सेलरेटर, NNAPI रनटाइम और IPC में लगने वाले समय को छोड़कर.
  • इन एपीआई का इस्तेमाल सिर्फ़ उस ANeuralNetworksExecution के साथ किया जा सकता है जिसे ANeuralNetworksCompilation_createForDevices के साथ numDevices = 1 का इस्तेमाल करके बनाया गया था.
  • किसी भी ड्राइवर को समय की जानकारी देने की ज़रूरत नहीं है.

Android Systrace की मदद से अपने ऐप्लिकेशन की प्रोफ़ाइल बनाना

Android 10 से, NNAPI अपने-आप systrace इवेंट जनरेट करता है. इनका इस्तेमाल, अपने ऐप्लिकेशन की प्रोफ़ाइल बनाने के लिए किया जा सकता है.

NNAPI सोर्स, parse_systrace यूटिलिटी के साथ आता है, ताकि आपके ऐप्लिकेशन से जनरेट किए गए systrace इवेंट और टेबल व्यू जनरेट करके मॉडल के लाइफ़साइकल के अलग-अलग फ़ेज़ में बिताया गया समय (इंस्टेंसेशन, तैयारी करना, कंपाइल करना, और उसे खत्म करना) और का इस्तेमाल करें. वे परतें जिनमें आपका ऐप्लिकेशन विभाजित होता है:

  • Application: मुख्य ऐप्लिकेशन कोड
  • Runtime: NNAPI रनटाइम
  • IPC: NNAPI रनटाइम और ड्राइवर के बीच इंटर प्रोसेस कम्यूनिकेशन कोड
  • Driver: एक्सीलेरेटर ड्राइवर प्रोसेस.

प्रोफ़ाइलिंग विश्लेषण का डेटा जनरेट करना

मान लें कि आपने $ANDROID_BUILD_TOP पर AOSP सोर्स ट्री को चेक आउट किया है और टारगेट ऐप्लिकेशन के तौर पर TFLite इमेज क्लासिफ़िकेशन के उदाहरण का इस्तेमाल किया है. ऐसे में, यहां दिए गए तरीके से NNAPI प्रोफ़ाइलिंग डेटा जनरेट किया जा सकता है:

  1. इस निर्देश की मदद से, Android systrace शुरू करें:
$ANDROID_BUILD_TOP/external/chromium-trace/systrace.py  -o trace.html -a org.tensorflow.lite.examples.classification nnapi hal freq sched idle load binder_driver

-o trace.html पैरामीटर से पता चलता है कि ट्रेस, trace.html में लिखे जाएंगे. अपने ऐप्लिकेशन की प्रोफ़ाइल बनाते समय, आपको org.tensorflow.lite.examples.classification को अपने ऐप्लिकेशन मेनिफ़ेस्ट में बताई गई प्रोसेस के नाम से बदलना होगा.

इससे आपके एक शेल कंसोल को व्यस्त रखा जाएगा. किसी भी शेल कंसोल को बैकग्राउंड, क्योंकि यह enter के खत्म होने का इंतज़ार कर रहा है.

  1. systrace कलेक्टर शुरू होने के बाद, अपना ऐप्लिकेशन शुरू करें और अपना बेंचमार्क टेस्ट चलाएं.

हमारे मामले में, Android Studio से इमेज क्लासिफ़िकेशन ऐप्लिकेशन शुरू किया जा सकता है या अगर ऐप्लिकेशन पहले से इंस्टॉल है, तो सीधे अपने टेस्ट फ़ोन के यूज़र इंटरफ़ेस (यूआई) से. NNAPI का कुछ डेटा जनरेट करने के लिए, आपको ऐप्लिकेशन को NNAPI का इस्तेमाल करने के लिए कॉन्फ़िगर करना होगा. इसके लिए, ऐप्लिकेशन कॉन्फ़िगरेशन डायलॉग में, टारगेट डिवाइस के तौर पर NNAPI चुनें.

  1. जांच पूरी होने के बाद, पहले चरण से चालू console टर्मिनल पर enter दबाकर, systrace को बंद करें.

  2. systrace_parser टूल चलाकर, कुल आंकड़े जनरेट करें:

$ANDROID_BUILD_TOP/frameworks/ml/nn/tools/systrace_parser/parse_systrace.py --total-times trace.html

पार्सर इन पैरामीटर को स्वीकार करता है: - --total-times: किसी लेयर में बिताए गए कुल समय को दिखाता है. इसमें समय भी शामिल होता है किसी मौजूदा लेयर को कॉल एक्ज़ीक्यूट करने के लिए इंतज़ार करना पड़ा - --print-detail: systrace से इकट्ठा किए गए सभी इवेंट को प्रिंट करता है - --per-execution: सिर्फ़ एक्ज़ीक्यूशन और उसके सबफ़ेज़ प्रिंट करता है (हर कार्रवाई के समय के हिसाब से) पर क्लिक करें. - --json: JSON फ़ॉर्मैट में आउटपुट जनरेट करता है

आउटपुट का उदाहरण यहां दिया गया है:

===========================================================================================================================================
NNAPI timing summary (total time, ms wall-clock)                                                      Execution
                                                           ----------------------------------------------------
              Initialization   Preparation   Compilation           I/O       Compute      Results     Ex. total   Termination        Total
              --------------   -----------   -----------   -----------  ------------  -----------   -----------   -----------   ----------
Application              n/a         19.06       1789.25           n/a           n/a         6.70         21.37           n/a      1831.17*
Runtime                    -         18.60       1787.48          2.93         11.37         0.12         14.42          1.32      1821.81
IPC                     1.77             -       1781.36          0.02          8.86            -          8.88             -      1792.01
Driver                  1.04             -       1779.21           n/a           n/a          n/a          7.70             -      1787.95

Total                   1.77*        19.06*      1789.25*         2.93*        11.74*        6.70*        21.37*         1.32*     1831.17*
===========================================================================================================================================
* This total ignores missing (n/a) values and thus is not necessarily consistent with the rest of the numbers

अगर इकट्ठा किए गए इवेंट से ऐप्लिकेशन का पूरा ट्रेस नहीं दिखता है, तो हो सकता है कि पार्स करने की प्रोसेस पूरी न हो पाए. खास तौर पर, यह तब फ़ेल हो सकता है, जब systrace इवेंट जनरेट किए हों सेक्शन के आखिर में मार्क करने के लिए, वे ट्रेस में मौजूद हैं. सेक्शन शुरू होने का इवेंट चुनें. आम तौर पर ऐसा तब होता है, जब पहले के कुछ इवेंट सिस्टम कलेक्टर शुरू करने पर, प्रोफ़ाइलिंग सेशन जनरेट होता है. ऐसा होने पर, आपको फिर से अपनी प्रोफ़ाइल बनानी होगी.

systrace_parser आउटपुट में अपने ऐप्लिकेशन कोड के आंकड़े जोड़ें

parse_systrace ऐप्लिकेशन, Android में पहले से मौजूद systrace की सुविधा पर आधारित है. आप इनका इस्तेमाल करके अपने ऐप्लिकेशन में खास कार्रवाइयों के लिए ट्रेस जोड़ सकते हैं systrace API (Java के लिए , नेटिव ऐप्लिकेशन के लिए ) का इस्तेमाल करें.

अपने कस्टम इवेंट को ऐप्लिकेशन लाइफ़साइकल के चरणों से जोड़ने के लिए, अपने इवेंट के नाम के आगे, इनमें से किसी एक स्ट्रिंग का इस्तेमाल करें:

  • [NN_LA_PI]: शुरू करने के लिए ऐप्लिकेशन लेवल इवेंट
  • [NN_LA_PP]: तैयारी के लिए ऐप्लिकेशन लेवल इवेंट
  • [NN_LA_PC]: कंपाइलेशन के लिए ऐप्लिकेशन लेवल इवेंट
  • [NN_LA_PE]: ऐप्लिकेशन लेवल पर, एक्सीक्यूशन के लिए इवेंट

यहां दिए गए उदाहरण में बताया गया है कि TFLite की इमेज की कैटगरी तय करने के उदाहरण में बदलाव कैसे किया जा सकता है कोड जोड़ने के लिए, Execution फ़ेज़ के लिए runInferenceModel सेक्शन जोड़ें और Application लेयर में अन्य सेक्शन preprocessBitmap शामिल हैं को NNAPI ट्रेस में नहीं माना जाएगा. runInferenceModel सेक्शन को napi systrace पार्सर के ज़रिए प्रोसेस किए गए systrace इवेंट का हिस्सा है:

Kotlin

/** Runs inference and returns the classification results. */
fun recognizeImage(bitmap: Bitmap): List {
   // This section won’t appear in the NNAPI systrace analysis
   Trace.beginSection("preprocessBitmap")
   convertBitmapToByteBuffer(bitmap)
   Trace.endSection()

   // Run the inference call.
   // Add this method in to NNAPI systrace analysis.
   Trace.beginSection("[NN_LA_PE]runInferenceModel")
   long startTime = SystemClock.uptimeMillis()
   runInference()
   long endTime = SystemClock.uptimeMillis()
   Trace.endSection()
    ...
   return recognitions
}

Java

/** Runs inference and returns the classification results. */
public List recognizeImage(final Bitmap bitmap) {

 // This section won’t appear in the NNAPI systrace analysis
 Trace.beginSection("preprocessBitmap");
 convertBitmapToByteBuffer(bitmap);
 Trace.endSection();

 // Run the inference call.
 // Add this method in to NNAPI systrace analysis.
 Trace.beginSection("[NN_LA_PE]runInferenceModel");
 long startTime = SystemClock.uptimeMillis();
 runInference();
 long endTime = SystemClock.uptimeMillis();
 Trace.endSection();
  ...
 Trace.endSection();
 return recognitions;
}

सेवा की क्वालिटी

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

किसी वर्कलोड की प्राथमिकता सेट करना

NNAPI वर्कलोड की प्राथमिकता सेट करने के लिए, कॉल करें ANeuralNetworksCompilation_setPriority() ANeuralNetworksCompilation_finish() पर कॉल करने से पहले

समयसीमाएं सेट करना

ऐप्लिकेशन, मॉडल कंपाइल करने और अनुमान लगाने, दोनों के लिए समयसीमा सेट कर सकते हैं.

ऑपरेंड के बारे में ज़्यादा जानकारी

इस सेक्शन में, ऑपरेंड इस्तेमाल करने के बारे में ऐडवांस विषयों के बारे में बताया गया है.

क्वांटाइज़ किए गए टेंसर

क्वांटाइज़ किया गया टेंसर, फ़्लोटिंग पॉइंट वैल्यू के n-डाइमेंशन वाले ऐरे को दिखाने का एक छोटा तरीका है.

NNAPI, 8-बिट एसिमेट्रिक क्वांटाइज़्ड टेंसर का समर्थन करता है. इन टेंसर के लिए, हर सेल की वैल्यू को 8-बिट वाले पूर्णांक से दिखाया जाता है. टेंसर के साथ एक स्केल और शून्य पॉइंट की वैल्यू होती है. इनका इस्तेमाल, 8-बिट वाले पूर्णांकों को फ़्लोटिंग पॉइंट वैल्यू में बदलने के लिए किया जाता है.

फ़ॉर्मूला यह है:

(cellValue - zeroPoint) * scale

जहां ज़ीरोपॉइंट वैल्यू, 32-बिट पूर्णांक और 32-बिट फ़्लोट करने वाला स्केल है अंक मान.

32-बिट फ़्लोटिंग पॉइंट वैल्यू वाले टेंसर की तुलना में, 8-बिट क्वांटाइज़ किए गए टेंसर के ये दो फ़ायदे हैं:

  • आपका ऐप्लिकेशन छोटा है, क्योंकि ट्रेनिंग पा चुके वज़न को 32-बिट टेंसर की ज़रूरत होती है.
  • कंप्यूटेशन को अक्सर तेज़ी से एक्ज़ीक्यूट किया जा सकता है. ऐसा कम रकम की वजह से होता है का डेटा जिसे मेमोरी और प्रोसेसर की क्षमता से फ़ेच करने की ज़रूरत होती है जैसे कि पूर्णांकों की गिनती करने में डीएसपी.

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

NNAPI में, ANeuralNetworksOperandType डेटा स्ट्रक्चर के टाइप फ़ील्ड को ANEURALNETWORKS_TENSOR_QUANT8_ASYMM पर सेट करके, क्वांटाइज़ किए गए टेंसर टाइप तय किए जाते हैं. उस डेटा में, टेंसर का स्केल और ज़ीरोपॉइंट वैल्यू भी तय की जाती है स्ट्रक्चर.

NNAPI, 8-बिट असिमेट्रिक क्वांटाइज़ किए गए टेंसर के अलावा, इनके साथ भी काम करता है:

वैकल्पिक ऑपरेंड

कुछ ऑपरेशन, जैसे कि ANEURALNETWORKS_LSH_PROJECTION, ऑपरेंड के तौर पर वैल्यू नहीं लेते. मॉडल में यह बताने के लिए कि वैकल्पिक ऑपरेंड को छोड़ा गया है, ANeuralNetworksModel_setOperandValue() फ़ंक्शन को कॉल करें. इसके लिए, बफ़र के लिए NULL और लंबाई के लिए 0 पास करें.

ऑपरेंड मौजूद है या नहीं, यह फ़ैसला हर सदस्य के लिए अलग-अलग होता है है, तो आप बताते हैं कि ऑपरेंड को ANeuralNetworksExecution_setInput() या ANeuralNetworksExecution_setOutput() फ़ंक्शन, बफ़र के लिए NULL और लंबाई के लिए 0 पास करते हैं.

अज्ञात रैंक के टेन्सर

Android 9 (एपीआई लेवल 28) ने अज्ञात डाइमेंशन के मॉडल ऑपरेंड को लॉन्च किया, लेकिन ज्ञात रैंक (डाइमेंशन की संख्या). Android 10 (एपीआई लेवल 29) में, रैंक के बारे में जानकारी नहीं देने वाले टेंसर का इस्तेमाल शुरू किया गया है. इस बारे में ANeuralNetworksOperandType में बताया गया है.

NNAPI बेंचमार्क

NNAPI बेंचमार्क, AOSP पर platform/test/mlts/benchmark (बेंचमार्क ऐप्लिकेशन) और platform/test/mlts/models (मॉडल और डेटासेट) में उपलब्ध है.

बेंचमार्क, इंतज़ार के समय और सटीक होने का आकलन करता है. साथ ही, ड्राइवर की तुलना, एक ही मॉडल और डेटासेट के लिए, सीपीयू पर चलने वाले Tensorflow Lite का इस्तेमाल करके किए गए काम से करता है.

बेंचमार्क का इस्तेमाल करने के लिए, यह तरीका अपनाएं:

  1. टारगेट Android डिवाइस को अपने कंप्यूटर से कनेक्ट करें. इसके बाद, एक टर्मिनल विंडो खोलें और यह पक्का करें कि डिवाइस को adb से ऐक्सेस किया जा सकता है.

  2. एक से ज़्यादा Android डिवाइस कनेक्ट होने पर, टारगेट किए गए डिवाइस को एक्सपोर्ट करें ANDROID_SERIAL एनवायरमेंट वैरिएबल.

  3. Android की टॉप-लेवल सोर्स डायरेक्ट्री पर जाएं.

  4. ये कमांड चलाएं:

    lunch aosp_arm-userdebug # Or aosp_arm64-userdebug if available
./test/mlts/benchmark/build_and_run_benchmark.sh

    बेंचमार्क रन के अंत में, इसके परिणाम एक HTML पेज के रूप में प्रस्तुत किए जाएंगे xdg-open को पास किया गया.

NNAPI लॉग

NNAPI, सिस्टम लॉग में गड़बड़ी की उपयोगी जानकारी जनरेट करता है. लॉग का विश्लेषण करने के लिए, logcat उपयोगिता का इस्तेमाल करें.

खास फ़ेज़ या कॉम्पोनेंट के लिए, ज़्यादा जानकारी वाली NNAPI लॉगिंग चालू करें. इसके लिए, adb shell का इस्तेमाल करके प्रॉपर्टी debug.nn.vlog को वैल्यू की इस सूची पर सेट करें. वैल्यू को स्पेस, कोलन या कॉमा से अलग किया गया है:

  • model: मॉडल बिल्डिंग
  • compilation: मॉडल को लागू करने का प्लान बनाना और उसे कंपाइल करना
  • execution: मॉडल निष्पादन
  • cpuexe: NNAPI सीपीयू प्रोसेस को लागू करके, काम करना
  • manager: NNAPI एक्सटेंशन, उपलब्ध इंटरफ़ेस, और सुविधाओं से जुड़ी जानकारी
  • all या 1: ऊपर दिए गए सभी एलिमेंट

उदाहरण के लिए, पूरी वर्बोस लॉगिंग चालू करने के लिए, कमांड का इस्तेमाल करें adb shell setprop debug.nn.vlog all. ज़्यादा जानकारी वाली लॉगिंग बंद करने के लिए, कमांड का इस्तेमाल करेंadb shell setprop debug.nn.vlog '""'.

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

debug.nn.vlog कंट्रोल किए गए मैसेज के अलावा, NNAPI API कॉम्पोनेंट अलग-अलग लेवल पर अन्य लॉग एंट्री उपलब्ध कराते हैं. हर एंट्री में एक खास लॉग टैग का इस्तेमाल किया जाता है.

कॉम्पोनेंट की सूची पाने के लिए, इनका इस्तेमाल करके सोर्स ट्री खोजें ये एक्सप्रेशन:

grep -R 'define LOG_TAG' | awk -F '"' '{print $2}' | sort -u | egrep -v "Sample|FileTag|test"

यह एक्सप्रेशन फ़िलहाल नीचे दिए गए टैग दिखाता है:

  • बर्स्टबिल्डर
  • कॉलबैक
  • CompilationBuilder
  • CpuExecutor
  • एक्ज़ीक्यूशनबिल्डर
  • ExecutionBurstController
  • ExecutionBurstServer
  • प्लान लागू करना
  • FibonacciDriver
  • GraphDump
  • IndexedShapeWrapper
  • आयनवॉचर
  • मैनेजर
  • मेमोरी
  • मेमोरी यूटिल्स
  • MetaModel
  • ModelArgumentInfo
  • ModelBuilder
  • न्यूरल नेटवर्क
  • OperationResolver
  • ऑपरेशंस
  • OperationsUtils
  • पैकेज की जानकारी
  • टोकनहैशर
  • TypeManager
  • उपयोगिताएं
  • ValidateHal
  • वर्शन वाले इंटरफ़ेस

logcat से दिखाए जाने वाले लॉग मैसेज के लेवल को कंट्रोल करने के लिए, एनवायरमेंट वैरिएबल ANDROID_LOG_TAGS का इस्तेमाल करें.

NNAPI लॉग मैसेज का पूरा सेट दिखाने और अन्य सभी मैसेज बंद करने के लिए, ANDROID_LOG_TAGS को इन पर सेट करें:

BurstBuilder:V Callbacks:V CompilationBuilder:V CpuExecutor:V ExecutionBuilder:V ExecutionBurstController:V ExecutionBurstServer:V ExecutionPlan:V FibonacciDriver:V GraphDump:V IndexedShapeWrapper:V IonWatcher:V Manager:V MemoryUtils:V Memory:V MetaModel:V ModelArgumentInfo:V ModelBuilder:V NeuralNetworks:V OperationResolver:V OperationsUtils:V Operations:V PackageInfo:V TokenHasher:V TypeManager:V Utils:V ValidateHal:V VersionedInterfaces:V *:S.

यहां दिए गए निर्देश का इस्तेमाल करके, ANDROID_LOG_TAGS को सेट किया जा सकता है:

export ANDROID_LOG_TAGS=$(grep -R 'define LOG_TAG' | awk -F '"' '{ print $2 ":V" }' | sort -u | egrep -v "Sample|FileTag|test" | xargs echo -n; echo ' *:S')

ध्यान दें कि यह सिर्फ़ एक फ़िल्टर है, जो logcat पर लागू होता है. ज़्यादा जानकारी वाली लॉग जानकारी जनरेट करने के लिए, आपको अब भी प्रॉपर्टी debug.nn.vlog को all पर सेट करना होगा.