Android Neural Networks API (NNAPI) एक Android C API है. इसे चलाने के लिए डिज़ाइन किया गया है इसमें Android डिवाइसों पर मशीन लर्निंग के लिए कंप्यूटेशनल रूप से ज़्यादा इस्तेमाल किया जाता है. NNAPI को उच्च-लेवल के फ़ंक्शन की बुनियादी लेयर देने के लिए डिज़ाइन किया गया है मशीन लर्निंग फ़्रेमवर्क, जैसे कि TensorFlow Lite और Caffe2, जो न्यूरल नेटवर्क बनाते और उन्हें ट्रेनिंग देते हैं. एपीआई उपलब्ध है Android 8.1 (एपीआई लेवल 27) या उसके बाद के वर्शन वाले सभी Android डिवाइसों पर इस्तेमाल किया जा सकता है.
NNAPI, Android डिवाइसों के डेटा को पहले के डेटा पर लागू करके अनुमान लगाने की सुविधा देता है ट्रेन किए गए, डेवलपर के बनाए हुए मॉडल. अनुमान के उदाहरणों में कैटगरी तय करना शामिल है उपयोगकर्ता के व्यवहार का अनुमान लगाना, और किसी खोज क्वेरी.
डिवाइस पर मौजूद अनुमान के कई फ़ायदे हैं:
- इंतज़ार का समय: आपको इंटरनेट पर अनुरोध भेजने की ज़रूरत नहीं है और जवाब का इंतज़ार करें. उदाहरण के लिए, वीडियो ऐप्लिकेशन के लिए यह अहम हो सकता है जो कैमरे से लगातार फ़्रेम आ रही हैं.
- उपलब्धता: ऐप्लिकेशन, नेटवर्क कवरेज से बाहर होने पर भी चलता है.
- स्पीड: न्यूरल नेटवर्क प्रोसेसिंग के लिए खास तौर पर बनाया गया नया हार्डवेयर यह सुविधा, अलग-अलग कामों के लिए इस्तेमाल किए जाने वाले सीपीयू के मुकाबले तेज़ी से कंप्यूटेशन (कंप्यूटेशन) की सुविधा देती है.
- निजता: डेटा, Android डिवाइस में ही रहता है.
- लागत: सभी कंप्यूटेशन की परफ़ॉर्मेंस Android डिवाइस.
डेवलपर को कुछ ऐसी बातों का भी ध्यान रखना चाहिए:
- सिस्टम का इस्तेमाल: न्यूरल नेटवर्क का आकलन करने में कंप्यूटेशन होता है. इससे बैटरी ज़्यादा खर्च हो सकती है. आपको इन बातों पर ध्यान देना चाहिए अगर इसकी वजह से आपके ऐप्लिकेशन को नुकसान पहुंचता है, तो बैटरी की परफ़ॉर्मेंस पर नज़र रखी जा सकती है. खास तौर पर, का इस्तेमाल किया जा सकता है.
- ऐप्लिकेशन का साइज़: अपने मॉडल के साइज़ पर ध्यान दें. मॉडल हो सकते हैं ये स्टोरेज में कई मेगाबाइट जगह लेते हैं. अगर आपके APK में बड़े मॉडल को बंडल किया जा रहा है, तो आपके उपयोगकर्ताओं पर अनुचित प्रभाव पड़ेगा, तो हो सकता है कि आप ऐप्लिकेशन इंस्टॉल करने के बाद मिलने वाले मॉडल, छोटे मॉडल का इस्तेमाल करना या अपने ऐप्लिकेशन को कंप्यूटेशन इन क्लाउड पर सेव किए जाते हैं. NNAPI चलाने के लिए फ़ंक्शनलिटी नहीं देता है क्लाउड पर मॉडल के रूप में दिखाई देता है.
ज़्यादा जानकारी के लिए, Android Neural Networks एपीआई का सैंपल पर जाएं.
Neural Networks API के रनटाइम को समझना
एनएनएपीआई को मशीन लर्निंग लाइब्रेरी, फ़्रेमवर्क, और टूल के लिए इस्तेमाल किया जा सकता है इससे डेवलपर, डिवाइस से बाहर अपने मॉडल को ट्रेनिंग दे सकते हैं और उन्हें Android पर डिप्लॉय कर सकते हैं डिवाइस. आम तौर पर, ऐप्लिकेशन सीधे तौर पर NNAPI का इस्तेमाल नहीं करते, बल्कि मशीन लर्निंग फ़्रेमवर्क का इस्तेमाल करना चाहिए. इन फ़्रेमवर्क के तहत, NNAPI, काम करने वाले डिवाइसों पर हार्डवेयर की मदद से तेज़ी से अनुमान लगाने से जुड़ी कार्रवाइयां करता है.
ये सुझाव, किसी ऐप्लिकेशन की ज़रूरी शर्तों और Android पर मौजूद हार्डवेयर की क्षमताओं के आधार पर दिए जाते हैं डिवाइस, Android का न्यूरल नेटवर्क रनटाइम उपयोगकर्ता के डिवाइस पर मौजूद प्रोसेसर पर, कंप्यूटेशन का वर्कलोड न्यूरल नेटवर्क हार्डवेयर, ग्राफ़िक्स प्रोसेसिंग यूनिट (जीपीयू), और डिजिटल सिग्नल प्रोसेसर (DSP).
जिन Android डिवाइसों में खास वेंडर ड्राइवर की कमी होती है उनके लिए NNAPI रनटाइम सीपीयू पर अनुरोधों को एक्ज़ीक्यूट करता है.
पहली इमेज में, एनएनएपीआई का हाई-लेवल सिस्टम आर्किटेक्चर दिखाया गया है.
Neural Networks API का प्रोग्रामिंग मॉडल
NNAPI का इस्तेमाल करके कंप्यूटेशन करने के लिए, आपको सबसे पहले एक डायरेक्टेड ऐसा ग्राफ़ जो काम करने के लिए कंप्यूटेशन की जानकारी देता है. इस कंप्यूटेशन ग्राफ़ को, आपके इनपुट डेटा के साथ (उदाहरण के लिए, मशीन लर्निंग फ़्रेमवर्क), एनएनएपीआई रनटाइम इवैलुएशन के लिए मॉडल बनाता है.
NNAPI चार मुख्य ऐब्स्ट्रैक्ट का इस्तेमाल करता है:
- मॉडल: गणितीय संक्रियाओं और कॉन्स्टेंट (कॉन्सटेंट) का कंप्यूटेशन ग्राफ़
मूल्य. ये कार्रवाइयां खास तौर पर इन कामों के लिए हैं
न्यूरल नेटवर्क होते हैं. इनमें 2-डाइमेंशन (2D) शामिल है
बातचीत,
लॉजिस्टिक
(सिगमॉइड)
चालू करना,
रेक्टिफ़ाइड लीनियर
(ReLU) ऐक्टिवेशन वगैरह. मॉडल बनाना एक सिंक्रोनस कार्रवाई है.
एक बार बन जाने के बाद, थ्रेड और कंपाइलेशन में फिर से इस्तेमाल किया जा सकता है.
NNAPI में, मॉडल को
ANeuralNetworksModelइंस्टेंस. - कंपाइलेशन: यह, NNAPI मॉडल को कंपाइल करने के लिए कॉन्फ़िगरेशन को दिखाता है
निचले लेवल के कोड का इस्तेमाल करें. कंपाइलेशन एक सिंक्रोनस कार्रवाई है. एक बार
बनाया है, तो उसे थ्रेड और एक्ज़ीक्यूशन में फिर से इस्तेमाल किया जा सकता है. तय सीमा में
NNAPI, हर कंपाइलेशन को
ANeuralNetworksCompilationइंस्टेंस. - मेमोरी: शेयर की गई मेमोरी, मैप की गई मेमोरी की गई फ़ाइलों, और उससे मिलती-जुलती मेमोरी को दिखाता है
बफ़र. मेमोरी बफ़र का इस्तेमाल करने से NNAPI रनटाइम, ड्राइवर को डेटा ट्रांसफ़र कर पाता है
का इस्तेमाल ज़्यादा बेहतर तरीके से किया जा सकता है. ऐप्लिकेशन आम तौर पर एक शेयर किया गया मेमोरी बफ़र बनाता है, जो
इसमें मॉडल तय करने के लिए ज़रूरी हर टेंसर होता है. इसके लिए,
एक्ज़ीक्यूशन के इंस्टेंस के इनपुट और आउटपुट को स्टोर करने के लिए बफ़र. एनएनएपीआई में,
हर मेमोरी बफ़र को
ANeuralNetworksMemoryइंस्टेंस. लागू करना: इनपुट के सेट और उन पर NNAPI मॉडल लागू करने के लिए इंटरफ़ेस इससे आपको नतीजे मिल सकते हैं. एक्ज़ीक्यूशन, सिंक्रोनस या एसिंक्रोनस तरीके से किया जा सकता है.
एसिंक्रोनस एक्ज़ीक्यूशन के लिए, एक से ज़्यादा थ्रेड उसी एक्ज़ीक्यूशन के लिए इंतज़ार कर सकते हैं. यह प्रोग्राम पूरा होने के बाद, सभी थ्रेड को रिलीज़ किया गया.
NNAPI में, हर एक्ज़ीक्यूशन को
ANeuralNetworksExecutionइंस्टेंस.
दूसरी इमेज में बेसिक प्रोग्रामिंग फ़्लो दिखाया गया है.
इस सेक्शन के बाकी हिस्से में, NNAPI मॉडल को सेट अप करने का तरीका बताया गया है कंप्यूटेशन (हिसाब लगाना), मॉडल को कंपाइल करना, और कंपाइल किए गए मॉडल को एक्ज़ीक्यूट करना.
ट्रेनिंग डेटा का ऐक्सेस देना
आपके ट्रेन किए गए वज़न और पूर्वाग्रह के डेटा को शायद फ़ाइल में सेव किया जाता है. यह जानकारी देने के लिए
इस डेटा के बेहतर ऐक्सेस के साथ NNAPI रनटाइम,
ANeuralNetworksMemory
कॉल करके देखें
ANeuralNetworksMemory_createFromFd()
फ़ंक्शन और खुली हुई डेटा फ़ाइल के फ़ाइल डिस्क्रिप्टर में पास करना शामिल है. आपको यह भी
मेमोरी की सुरक्षा से जुड़े फ़्लैग और ऑफ़सेट बताएं जहां शेयर की गई मेमोरी का क्षेत्र
फ़ाइल से शुरू होता है.
// 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 एक्सेलरेटर ऐक्सेस कर सकता है
AHardwareBuffer
ऐसे ऑब्जेक्ट होते हैं जिन्हें ड्राइवर को डेटा कॉपी करने की ज़रूरत नहीं होती. AHardwareBuffer में कई
अलग-अलग कॉन्फ़िगरेशन होते हैं, और हर NNAPI एक्सेलरेटर सभी ब्राउज़र पर काम नहीं करता
ये कॉन्फ़िगरेशन. इस सीमा की वजह से, पाबंदियों का ध्यान रखें
इसमें सूचीबद्ध
ANeuralNetworksMemory_createFromAHardwareBuffer के रेफ़रंस के लिए दस्तावेज़
और कंपाइलेशन और एक्ज़ीक्यूशन पक्का करने के लिए, टारगेट किए गए डिवाइसों पर समय से पहले उनकी जांच कर लें
जो AHardwareBuffer का इस्तेमाल करती हैं, तो उम्मीद के मुताबिक काम करती हैं.
एक्सीलेरेटर सेट करने के लिए, डिवाइस असाइनमेंट.
NNAPI रनटाइम को AHardwareBuffer ऑब्जेक्ट ऐक्सेस करने की अनुमति देने के लिए, कोई
ANeuralNetworksMemory
कॉल करके देखें
ANeuralNetworksMemory_createFromAHardwareBuffer फ़ंक्शन और पासिंग
AHardwareBuffer ऑब्जेक्ट, जैसा कि इस कोड सैंपल में दिखाया गया है:
// 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-बिट बूलियन वैल्यू.
उदाहरण के लिए, तीसरी इमेज में दो संक्रियाओं वाला मॉडल दिखाया गया है: जोड़ इसके बाद गुणा करें. यह मॉडल एक इनपुट टेंसर लेकर, एक इनपुट टेंसर बनाता है आउटपुट टेंसर.
ऊपर दिए गए मॉडल में सात ऑपरेंड हैं. इन ऑपरेंड की पहचान सीधे तौर पर इससे की जाती है उस ऑर्डर का इंडेक्स जिसमें उन्हें मॉडल में जोड़ा जाता है. पहला ऑपरेंड जोड़ा गया इंडेक्स 0 है और दूसरा इंडेक्स 1 है. इसी तरह दूसरे का इंडेक्स है. ओपेरैंड 1, 2, 3, और 5 कॉन्सटैंट ऑपरेंड हैं.
आप जिस क्रम में ऑपरेंड जोड़ते हैं वह इस पर कोई असर नहीं पड़ता. उदाहरण के लिए, मॉडल आउटपुट ऑपरेंड पहला जोड़ा गया हो सकता है. सबसे अहम बात यह है कि सही इंडेक्स मान का इस्तेमाल करें.
ओपेरैंड के कई टाइप हैं. इनका इस्तेमाल तब किया जाता है, जब इन्हें मॉडल में जोड़ा जाता है.
ऑपरेंड का इस्तेमाल किसी मॉडल के इनपुट और आउटपुट, दोनों के तौर पर नहीं किया जा सकता.
हर ऑपरेंड या तो एक मॉडल इनपुट, स्थिरांक या आउटपुट ऑपरेंड होना चाहिए सिर्फ़ एक कार्रवाई.
ऑपरेंड का इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, यहां देखें ऑपरेंड के बारे में ज़्यादा जानकारी.
ऑपरेशंस
कोई कार्रवाई, की जाने वाली कंप्यूटेशन की जानकारी देती है. हर कार्रवाई में शामिल है इनमें ये एलिमेंट शामिल हैं:
- कार्रवाई का टाइप (उदाहरण के लिए, जोड़ना, गुणा करना, और कॉन्फ़िगर करना),
- ऑपरेशन के ज़रिए इनपुट के लिए इस्तेमाल किए जाने वाले ऑपरेंड के इंडेक्स की सूची और
- ऑपरेंड के इंडेक्स की एक सूची, जिसका इस्तेमाल ऑपरेशन आउटपुट के लिए करता है.
इन सूचियों का क्रम अहम है; देखें अनुमानित इनपुट के लिए, NNAPI API का रेफ़रंस और हर तरह की कार्रवाई के आउटपुट.
आपको ऐसे ऑपरेंड जोड़ने होंगे जो किसी कार्रवाई के ज़रिए मॉडल में इस्तेमाल किए जाते हैं या बनाए जाते हैं कार्रवाई जोड़ने से पहले.
ऑपरेशन जिस क्रम में जोड़े जाते हैं उससे कोई फ़र्क़ नहीं पड़ता. NNAPI ऑपरेंड और ऑपरेशन के कंप्यूटेशन ग्राफ़ से तय की गई डिपेंडेंसी कार्रवाइयों का क्रम तय करते हैं.
NNAPI के साथ काम करने वाली कार्रवाइयों की खास जानकारी नीचे टेबल में दी गई है:
एपीआई लेवल 28 में सामान्य समस्या: पास करते समय
ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
टेंसर से
ANEURALNETWORKS_PAD
ऑपरेशन, जो Android 9 (एपीआई लेवल 28) और उसके बाद वाले वर्शन पर उपलब्ध है,
ऐसा हो सकता है कि NNAPI से मिला आउटपुट, हाई-लेवल मशीन लर्निंग के आउटपुट से मैच न करे
फ़्रेमवर्क शामिल हैं, जैसे कि
TensorFlow Lite. आपने लोगों तक पहुंचाया मुफ़्त में
को इसके बजाय केवल
ANEURALNETWORKS_TENSOR_FLOAT32.
यह समस्या Android 10 (एपीआई लेवल 29) और उसके बाद वाले वर्शन में ठीक कर दी गई है.
मॉडल बनाएं
नीचे दिए गए उदाहरण में, हमने दो-ऑपरेशन मॉडल बनाया है. यह मॉडल तीसरी इमेज.
मॉडल बनाने के लिए, यह तरीका अपनाएं:
कॉल करें
ANeuralNetworksModel_create()फ़ंक्शन का इस्तेमाल करें.ANeuralNetworksModel* model = NULL; ANeuralNetworksModel_create(&model);
कॉल करके अपने मॉडल में ऑपरेंड जोड़ें
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उन ऑपरेंड के लिए जिनकी वैल्यू स्थिर होती हैं. जैसे, वे ऑपरेंड जो ऐप्लिकेशन को ट्रेनिंग प्रोसेस से पाने के लिए, इसका इस्तेमाल करें
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));आप जिस निर्देशित ग्राफ़ की गणना करना चाहते हैं उसमें प्रत्येक कार्रवाई के लिए, कार्रवाई करने के लिए
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);पता लगाएं कि मॉडल को किस ऑपरेंड को इनपुट और आउटपुट माना जाना चाहिए. इसके लिए, कॉल करो
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);वैकल्पिक रूप से, यह बताएं कि
ANEURALNETWORKS_TENSOR_FLOAT32की गणना सीमा या शुद्धता के साथ की जा सकती है, जितनी कम है आईईईई 754 16-बिट फ़्लोटिंग-पॉइंट फ़ॉर्मैट पर कॉल करकेANeuralNetworksModel_relaxComputationFloat32toFloat16().ANeuralNetworksModel_finish()पर कॉल करें की मदद से, अपने मॉडल की परिभाषा को फ़ाइनल किया जा सकता है. अगर कोई गड़बड़ी नहीं है, तो यह फ़ंक्शन इसका नतीजा कोड दिखाता हैANEURALNETWORKS_NO_ERROR.ANeuralNetworksModel_finish(model);
मॉडल बनाने के बाद, उसे कई बार कंपाइल किया जा सकता है और हर बार एक्ज़ीक्यूट किया जा सकता है कितनी बार भी कंपाइल किया जा सकता है.
कंट्रोल फ़्लो
किसी एनएनएपीआई मॉडल में कंट्रोल फ़्लो शामिल करने के लिए, यह तरीका अपनाएं:
संबंधित एक्ज़ीक्यूशन सबग्राफ़ (
thenऔरelseसबग्राफ़) बनाएंIFस्टेटमेंट के लिए,WHILEलूप के लिएconditionऔरbodyसबग्राफ़) स्टैंडअलोनANeuralNetworksModel*मॉडल के रूप में:ANeuralNetworksModel* thenModel = makeThenModel(); ANeuralNetworksModel* elseModel = makeElseModel();
ऐसे ऑपरेंड बनाएं, जिनमें उन मॉडल का संदर्भ हो जिसमें नियंत्रण फ़्लो:
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);कंट्रोल फ़्लो ऑपरेशन जोड़ें:
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);अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
कंपाइलेशन
कंपाइलेशन चरण से यह तय होता है कि आपका मॉडल किन प्रोसेसर पर लागू होगा और संबंधित ड्राइवरों को इसके निष्पादन की तैयारी करने के लिए कहता है. यह काम कर सका आपके मॉडल के प्रोसेसर के लिए खास तौर पर मशीन कोड जनरेट करने की प्रोसेस शामिल करता है पर चलेगा.
मॉडल कंपाइल करने के लिए, इन चरणों का पालन करें:
कॉल करें
ANeuralNetworksCompilation_create()नया कंपाइलेशन इंस्टेंस बनाने के लिए इस्तेमाल किया जा सकता है.// Compile the model ANeuralNetworksCompilation* compilation; ANeuralNetworksCompilation_create(model, &compilation);
इसके अलावा, डिवाइस असाइनमेंट का इस्तेमाल करके, साफ़ तौर पर चुनें कि किन डिवाइसों पर काम करना है.
इसके अलावा, यह भी तय किया जा सकता है कि रनटाइम, बैटरी पावर के बीच किस तरह बदलाव करे इस्तेमाल और एक्ज़ीक्यूट करने की स्पीड. इसके लिए, इस नंबर पर कॉल करें:
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: लगातार फ़्रेम के थ्रूपुट को बढ़ाना चाहते हैं, जैसे कि जो कैमरे से लगातार फ़्रेम आ रही हैं.
वैकल्पिक रूप से, 'कॉल करके' कंपाइलेशन कैश मेमोरी सेट अप की जा सकती है
ANeuralNetworksCompilation_setCaching.// Set up compilation caching ANeuralNetworksCompilation_setCaching(compilation, cacheDir, token);
getCodeCacheDir()का इस्तेमाल करेंcacheDirके लिए. तय किया गयाtoken, इसमें मौजूद हर मॉडल के लिए यूनीक होना चाहिए ऐप्लिकेशन खोलें.कंपाइलेशन की परिभाषा देखने के लिए, काॅल करें
ANeuralNetworksCompilation_finish(). अगर कोई गड़बड़ी नहीं है, तो यह फ़ंक्शन इस नतीजे का कोड दिखाता हैANEURALNETWORKS_NO_ERROR.ANeuralNetworksCompilation_finish(compilation);
डिवाइस खोजने और असाइन करने की सुविधा
Android 10 (एपीआई लेवल 29) और उसके बाद के वर्शन वाले Android डिवाइसों पर, NNAPI ऐसे फ़ंक्शन जो मशीन लर्निंग फ़्रेमवर्क लाइब्रेरी और ऐप्लिकेशन को उपलब्ध डिवाइसों के बारे में जानकारी और बताएं कि किन डिवाइसों का इस्तेमाल करना है लागू करता है. उपलब्ध डिवाइसों के बारे में जानकारी देने से, ऐप्लिकेशन को ड्राइवर के सटीक वर्शन की जानकारी साथ काम नहीं कर रहा है. ऐप्लिकेशन को यह तय करने की सुविधा देकर कि कौनसे डिवाइस ऐप्लिकेशन के अलग-अलग सेक्शन पर काम करते हैं, तो ऐप्लिकेशन को Android के हिसाब से ऑप्टिमाइज़ किया जा सकता है किस डिवाइस पर डिप्लॉय किए जाते हैं.
कास्ट की सुविधा वाले डिवाइस खोजना
इस्तेमाल की जाने वाली चीज़ें
ANeuralNetworks_getDeviceCount
देखें कि कितने डिवाइस उपलब्ध हैं. हर डिवाइस के लिए, इसका इस्तेमाल करें
ANeuralNetworks_getDevice
ताकि उस डिवाइस के रेफ़रंस के लिए ANeuralNetworksDevice इंस्टेंस सेट किया जा सके.
एक बार आपके पास डिवाइस रेफ़रंस उपलब्ध होने के बाद, आपको उस डिवाइस पर ये सुविधाएं मिलेंगी:
ANeuralNetworksDevice_getFeatureLevelANeuralNetworksDevice_getNameANeuralNetworksDevice_getTypeANeuralNetworksDevice_getVersion
डिवाइस असाइनमेंट
इस्तेमाल की जाने वाली चीज़ें
ANeuralNetworksModel_getSupportedOperationsForDevices
का इस्तेमाल करके यह पता लगाया जा सकता है कि किसी मॉडल की कौनसी कार्रवाइयां खास डिवाइसों पर चलाई जा सकती हैं.
यह कंट्रोल करने के लिए कि एक्ज़ीक्यूट करने के लिए कौनसे एक्सेलरेटर का इस्तेमाल किया जाए,
ANeuralNetworksCompilation_createForDevices
ANeuralNetworksCompilation_create के स् थान पर.
इससे मिलने वाले ANeuralNetworksCompilation ऑब्जेक्ट का सामान्य तरीके से इस्तेमाल करें.
अगर दिए गए मॉडल में ऐसे ऑपरेशन हैं जो
यह सुविधा चुने गए डिवाइसों पर काम नहीं करती है.
अगर एक से ज़्यादा डिवाइस चुने गए हैं, तो ऐप्लिकेशन इस्तेमाल करने के लिए रनटाइम की ज़रूरत होती है का काम आसान बना देते हैं.
अन्य डिवाइसों की तरह, एनएनएपीआई सीपीयू को लागू करने के तरीके को
nnapi-reference नाम वाला ANeuralNetworksDevice और टाइप
ANEURALNETWORKS_DEVICE_TYPE_CPU. कॉल करते समय
ANeuralNetworksCompilation_createForDevices, सीपीयू को लागू करने की प्रोसेस पूरी नहीं की गई है
इसका इस्तेमाल, मॉडल कंपाइलेशन और उसे लागू करने में होने वाली गड़बड़ी के मामलों को हैंडल करने के लिए किया जाता है.
किसी मॉडल को उप-मॉडल में विभाजित करने की ज़िम्मेदारी ऐप्लिकेशन की होती है
तय डिवाइस पर काम कर सकता है. ऐसे ऐप्लिकेशन जिनके लिए मैन्युअल तरीके से काम करने की ज़रूरत नहीं है
सेगमेंट में बांटने का काम
ANeuralNetworksCompilation_create
सभी उपलब्ध डिवाइसों (सीपीयू समेत) का इस्तेमाल करने के लिए
मॉडल. अगर मॉडल, आपके बताए गए डिवाइसों पर पूरी तरह काम नहीं करता है
ANeuralNetworksCompilation_createForDevices का इस्तेमाल करके,
ANEURALNETWORKS_BAD_DATA
वापस किया जाता है.
मॉडल विभाजन
किसी मॉडल के लिए कई डिवाइस उपलब्ध होने पर, NNAPI रनटाइम
काम को सभी डिवाइसों पर डिस्ट्रिब्यूट करता है. उदाहरण के लिए, अगर
ANeuralNetworksCompilation_createForDevices को दिया गया, सभी बताए गए
काम का बंटवारा करते समय, उन पर ध्यान दिया जाएगा. ध्यान दें कि, अगर सीपीयू डिवाइस
सूची में नहीं है, इसलिए सीपीयू चलाने की सुविधा बंद हो जाएगी. ANeuralNetworksCompilation_create का इस्तेमाल करते समय
इसके लिए, सभी उपलब्ध डिवाइसों को ध्यान में रखा जाएगा. इनमें सीपीयू भी शामिल है.
डिस्ट्रिब्यूशन करने के लिए, उपलब्ध डिवाइसों की सूची में से हर डिवाइस को चुनें
मॉडल की कार्रवाइयों के बारे में बताने के लिए, और उस कार्रवाई को सपोर्ट करने वाला डिवाइस
सबसे बेहतर परफ़ॉर्मेंस की घोषणा करना, जैसे कि सबसे तेज़ एक्ज़ीक्यूशन का समय या
इससे ऊर्जा की सबसे कम खपत होती है. यह इस बात पर निर्भर करता है कि एक्ज़ीक्यूशन के लिए कौनसा विकल्प दिया जाए
से संपर्क करने के लिए प्रोत्साहित करें. बंटवारे का यह एल्गोरिदम मुमकिन नहीं है
अलग-अलग प्रोसेसर के बीच IO के कारण अक्षमता होती है, इसलिए जब
एक से ज़्यादा प्रोसेसर का इस्तेमाल करके (या तो इस्तेमाल करते समय साफ़ तौर पर
ANeuralNetworksCompilation_createForDevices या अनुमान से
ANeuralNetworksCompilation_create) से शुरू होने वाले नतीजे को शामिल करना ज़रूरी है
का इस्तेमाल करें.
एनएनएपीआई ने आपके मॉडल को किस तरह बांटा है, यह समझने के लिए
मैसेज के लिए Android लॉग (ExecutionPlan टैग वाले जानकारी स्तर पर):
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.
प्लान लागू करना
एक्ज़ीक्यूशन चरण, मॉडल को इनपुट के सेट पर लागू करता है और आपके ऐप्लिकेशन के एक या उससे ज़्यादा उपयोगकर्ता बफ़र या मेमोरी स्पेस पर कंप्यूटेशन आउटपुट देता है तय किया गया है.
कंपाइल किए गए मॉडल को चलाने के लिए, यह तरीका अपनाएं:
कॉल करें
ANeuralNetworksExecution_create()फ़ंक्शन का इस्तेमाल करें.// Run the compiled model against a set of inputs ANeuralNetworksExecution* run1 = NULL; ANeuralNetworksExecution_create(compilation, &run1);
तय करें कि आपका ऐप्लिकेशन, कंप्यूटेशन की इनपुट वैल्यू को कहां पढ़ता है. आपका ऐप्लिकेशन उपयोगकर्ता के बफ़र या असाइन किए गए मेमोरी स्पेस से इनपुट वैल्यू पढ़ सकता है कॉल करके
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));अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया हैबताएं कि आपका ऐप्लिकेशन, आउटपुट वैल्यू कहां लिखता है. आपका ऐप्लिकेशन, आउटपुट वैल्यू को इनमें से किसी एक कॉल करके, उपयोगकर्ता बफ़र या तय मेमोरी स्पेस
ANeuralNetworksExecution_setOutput()याANeuralNetworksExecution_setOutputFromMemory()क्रम से.// Set the output float32 myOutput[3][4]; ANeuralNetworksExecution_setOutput(run1, 0, NULL, myOutput, sizeof(myOutput));
विश्लेषण की प्रक्रिया शुरू करने के लिए,
ANeuralNetworksExecution_startCompute()फ़ंक्शन का इस्तेमाल करना होगा. अगर कोई गड़बड़ी नहीं है, तो यह फ़ंक्शन इस नतीजे का कोड दिखाता हैANEURALNETWORKS_NO_ERROR.// Starts the work. The work proceeds asynchronously ANeuralNetworksEvent* run1_end = NULL; ANeuralNetworksExecution_startCompute(run1, &run1_end);
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);
इसके अलावा, कंपाइल किए गए मॉडल में इनपुट का कोई दूसरा सेट लागू करने के लिए नया कोड बनाने के लिए उसी कंपाइलेशन इंस्टेंस का इस्तेमाल करना
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 को किए गए कॉल के साथ जुड़ा नहीं है.
बर्स्ट निष्पादन
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 में, अगर ड्राइवर पर एक्ज़ीक्यूशन नहीं हो पाता है, तो एनएनएपीआई कोड सीपीयू पर वापस चला जाता है.
यह बात Android 10 पर भी तब लागू होती है, जब ANeuralNetworksCompilation_create
ANeuralNetworksCompilation_createForDevices का इस्तेमाल किया गया है.
पहला एक्ज़ीक्यूशन उस सेगमेंट पर वापस चला जाता है और अगर वह अब भी अगर यह प्रोसेस पूरी नहीं होती है, तो यह पूरे मॉडल को सीपीयू पर फिर से इस्तेमाल करने की कोशिश करता है.
अगर किसी हिस्से को सेगमेंट में बांटने या उसे कंपाइल करने में कोई गड़बड़ी होती है, तो पूरे मॉडल को सीपीयू पर इस्तेमाल करने की कोशिश की जाएगी.
ऐसे कई मामले हैं जिनमें कुछ कार्रवाइयां सीपीयू पर काम नहीं करतीं. साथ ही, स्थितियों का कंपाइलेशन या निष्पादन, पीछे जाने के बजाय विफल हो जाएगा.
सीपीयू फ़ॉलबैक बंद करने के बाद भी, मॉडल में अब भी कार्रवाइयां हो सकती हैं
जो सीपीयू पर शेड्यूल होते हैं. अगर सीपीयू, सप्लाई किए गए प्रोसेसर की सूची में है
ANeuralNetworksCompilation_createForDevices तक पहुंच गया है और या तो अकेली है
उन कार्रवाइयों में मदद करने वाला प्रोसेसर या सबसे सही दावा करने वाला प्रोसेसर
नहीं होगा, तो इसे प्राथमिक (नॉन-फ़ॉलबैक) के रूप में चुना जाएगा
मैनेजर के तौर पर काम करता है.
यह पक्का करने के लिए कि कोई सीपीयू न प्रोसेस हो, ANeuralNetworksCompilation_createForDevices का इस्तेमाल करें
डिवाइसों की सूची से nnapi-reference को हटा रही है.
Android P की शुरुआत से, एक्ज़ीक्यूशन के समय फ़ॉलबैक को बंद किया जा सकता है.
डीबग, debug.nn.partition प्रॉपर्टी को 2 पर सेट करके बनाया जाता है.
मेमोरी डोमेन
Android 11 और उसके बाद के वर्शन में, NNAPI उन मेमोरी डोमेन के साथ काम करता है जो ऐलोकेटर उपलब्ध कराते हैं ओपेक मेमोरी के लिए इंटरफ़ेस. इससे ऐप्लिकेशन को डिवाइस-नेटिव की अनुमति मिलती है मेमोरी को एक्ज़ीक्यूट करने की सुविधा देती है, ताकि एनएनएपीआई डेटा को कॉपी न करे या उसमें बदलाव न करे बिना किसी वजह के, एक ही ड्राइवर को बार-बार लागू करते समय ऐसा करना ज़रूरी नहीं है.
मेमोरी डोमेन की सुविधा उन टेंसर के लिए है जो ज़्यादातर इससे उन्हें बार-बार क्लाइंट साइड ऐक्सेस करने की ज़रूरत नहीं होती. के उदाहरण ऐसे टेंसर में, सीक्वेंस मॉडल में स्टेट टेंसर शामिल होते हैं. उन टेंसर के लिए जिन्हें इसकी ज़रूरत है क्लाइंट-साइड पर सीपीयू का बार-बार ऐक्सेस होने पर, शेयर किए गए मेमोरी पूल का इस्तेमाल करें.
ओपेक मेमोरी को असाइन करने के लिए, नीचे दिया गया तरीका अपनाएं:
कॉल करें
ANeuralNetworksMemoryDesc_create()फ़ंक्शन का इस्तेमाल करें:// Create a memory descriptor ANeuralNetworksMemoryDesc* desc; ANeuralNetworksMemoryDesc_create(&desc);
कॉल करके, इनपुट और आउटपुट में काम की सभी भूमिकाओं के बारे में बताएं
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);
विकल्प के तौर पर, कॉल करके मेमोरी के डाइमेंशन की जानकारी दें
ANeuralNetworksMemoryDesc_setDimensions().// Specify the memory dimensions uint32_t dims[] = {3, 4}; ANeuralNetworksMemoryDesc_setDimensions(desc, 2, dims);कॉल करके, डिस्क्रिप्टर की परिभाषा तय करें
ANeuralNetworksMemoryDesc_finish().ANeuralNetworksMemoryDesc_finish(desc);
डिस्क्रिप्टर को पास करके, जितनी चाहें उतनी यादों को
ANeuralNetworksMemory_createFromDesc().// Allocate two opaque memories with the descriptor ANeuralNetworksMemory* opaqueMem; ANeuralNetworksMemory_createFromDesc(desc, &opaqueMem);
जब आपको मेमोरी डिस्क्रिप्टर की ज़रूरत न हो, तब उसे खाली कर दें.
ANeuralNetworksMemoryDesc_free(desc);
क्लाइंट बनाए गए ANeuralNetworksMemory ऑब्जेक्ट का इस्तेमाल सिर्फ़ इसके साथ कर सकता है
ANeuralNetworksExecution_setInputFromMemory() या
भूमिकाओं के हिसाब से ANeuralNetworksExecution_setOutputFromMemory()
ANeuralNetworksMemoryDesc ऑब्जेक्ट में बताया गया है. ऑफ़सेट और लंबाई
आर्ग्युमेंट की वैल्यू 0 पर सेट होनी चाहिए. इससे पता चलता है कि पूरी मेमोरी का इस्तेमाल किया गया है. क्लाइंट
साफ़ तौर पर मेमोरी के कॉन्टेंट को सेट या एक्सट्रैक्ट भी कर सकता है. ऐसा करने के लिए,
ANeuralNetworksMemory_copy().
आपके पास ऐसे डाइमेंशन या रैंक तय करने के लिए, जिनके बारे में कोई जानकारी नहीं दी गई है.
ऐसे में, हो सकता है कि मेमोरी की सुविधा,
ANEURALNETWORKS_OP_FAILED स्टेटस, अगर दी गई ऐसेट के साथ काम नहीं करता है
ड्राइवर. क्लाइंट को
काफ़ी बड़ा बफ़र, Asmem या BLOB-mode AHardwareBuffer का इस्तेमाल कर रहा है.
जब NNAPI को ओपेक मेमोरी ऑब्जेक्ट ऐक्सेस करने की ज़रूरत नहीं हो, तो उसे खाली करें
संबंधित ANeuralNetworksMemory इंस्टेंस:
ANeuralNetworksMemory_free(opaqueMem);
परफ़ॉर्मेंस का आकलन करना
अपने ऐप्लिकेशन की परफ़ॉर्मेंस का आकलन करने के लिए, समय-समय पर या प्रोफ़ाइल बनाना.
एक्ज़ीक्यूशन का समय
जब आपको रनटाइम के दौरान एक्ज़ीक्यूशन का कुल समय तय करना हो, तो
सिंक्रोनस एक्ज़ीक्यूशन API का इस्तेमाल कर सकते हैं और कॉल में लगने वाले समय को माप सकते हैं. आसानी से अपने कैलेंडर में जोड़ें.
सॉफ़्टवेयर के निचले लेवल के ज़रिए, एक्ज़ीक्यूशन का कुल समय तय करना हो
करने के लिए,
ANeuralNetworksExecution_setMeasureTiming
और
ANeuralNetworksExecution_getDuration
पाने के लिए:
- ऐक्सेलरेटर पर एक्सिलरेटर पर लगने वाला समय (ड्राइवर में नहीं, जो होस्ट पर चलता है प्रोसेसर).
- ड्राइवर में एक्सिलरेटर पर लगने वाला समय.
ड्राइवर को एक्ज़ीक्यूशन के समय में ओवरहेड शामिल नहीं होता, जैसे कि रनटाइम ड्राइवर से संपर्क करने के लिए रनटाइम के लिए ज़रूरी आईपीसी को भी शामिल किया जाता है.
ये एपीआई, सबमिट किए गए काम और पूरे हो चुके काम के बीच का समय मापते हैं नहीं, बल्कि इवेंट की परफ़ॉर्मेंस को बेहतर बनाने में लगने वाले समय से ज़्यादा इस्तेमाल करने में परेशानी हो सकती है.
उदाहरण के लिए, अगर अनुमान 1 शुरू होता है, तो ड्राइवर काम करने के लिए काम करना बंद कर देता है अनुमान 2 का इस्तेमाल किया जाता है, तो यह फिर से शुरू होता है और अनुमान 1 को पूरा करता है. पहले अनुमान में वह समय शामिल होगा जब अनुमान 2 के लिए काम को रोका गया था.
समय की यह जानकारी, ऐसे ऐप्लिकेशन के प्रोडक्शन डिप्लॉयमेंट के लिए काम की हो सकती है जिसमें ताकि ऑफ़लाइन इस्तेमाल के लिए टेलीमेट्री इकट्ठा करने की सुविधा मिल सके. समय की जानकारी देने वाले डेटा का इस्तेमाल, इन कामों के लिए किया जा सकता है बेहतर परफ़ॉर्मेंस के लिए ऐप्लिकेशन में बदलाव करें.
इस सुविधा का इस्तेमाल करते समय, इन बातों का ध्यान रखें:
- समय की जानकारी इकट्ठा करने के लिए, परफ़ॉर्मेंस की लागत पर असर पड़ सकता है.
- केवल एक ड्राइवर ही अपने आप में या एक्सेलरेटर, NNAPI रनटाइम और IPC में लगने वाले समय को छोड़कर.
- आप इन एपीआई का इस्तेमाल सिर्फ़ उस
ANeuralNetworksExecutionके साथ कर सकते हैं जोnumDevices = 1के साथANeuralNetworksCompilation_createForDevicesकी मदद से बनाया गया. - समय की जानकारी की रिपोर्ट करने के लिए किसी ड्राइवर की आवश्यकता नहीं है.
Android Systrace की मदद से अपने ऐप्लिकेशन की प्रोफ़ाइल बनाएं
Android 10 और इसके बाद के वर्शन में, NNAPI अपने-आप जनरेट होता है systrace ऐसे इवेंट जो का इस्तेमाल अपने ऐप्लिकेशन को प्रोफ़ाइल बनाने के लिए किया जा सकता है.
NNAPI सोर्स, parse_systrace यूटिलिटी के साथ आता है, ताकि
आपके ऐप्लिकेशन से जनरेट किए गए systrace इवेंट और टेबल व्यू जनरेट करके
मॉडल के लाइफ़साइकल के अलग-अलग फ़ेज़ में बिताया गया समय (इंस्टेंसेशन,
तैयारी करना, कंपाइल करना, और उसे खत्म करना) और
का इस्तेमाल करें. वे परतें जिनमें आपका ऐप्लिकेशन विभाजित होता है:
Application: मुख्य ऐप्लिकेशन कोडRuntime: NNAPI रनटाइमIPC: NNAPI रनटाइम और ड्राइवर के बीच इंटर प्रोसेस कम्यूनिकेशन कोडDriver: एक्सीलेरेटर ड्राइवर प्रोसेस.
प्रोफ़ाइलिंग विश्लेषण डेटा जनरेट करना
यह मानते हुए कि आपने $ANDROID_BUILD_TOP पर AOSP सोर्स ट्री देखा है, और TFLite की इमेज की कैटगरी तय करने के उदाहरण का इस्तेमाल करके टारगेट ऐप्लिकेशन के तौर पर, NNAPI प्रोफ़ाइलिंग डेटा जनरेट किया जा सकता है. इसके लिए, नीचे दिया गया तरीका अपनाएं:
- Android सिस्टम को इस निर्देश से शुरू करें:
$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 के खत्म होने का इंतज़ार कर रहा है.
- सिस्टम कलेक्टर चालू होने के बाद, अपना ऐप्लिकेशन चालू करें और अपने मानदंड टेस्ट.
हमारे मामले में, Android Studio से इमेज क्लासिफ़िकेशन ऐप्लिकेशन शुरू किया जा सकता है या अगर ऐप्लिकेशन पहले से इंस्टॉल है, तो सीधे अपने टेस्ट फ़ोन के यूज़र इंटरफ़ेस (यूआई) से. कुछ NNAPI डेटा जनरेट करने के लिए, आपको ऐप्लिकेशन कॉन्फ़िगर करना होगा, ताकि NNAPI का इस्तेमाल किया जा सके ऐप्लिकेशन के कॉन्फ़िगरेशन डायलॉग में, NNAPI को टारगेट डिवाइस के तौर पर चुनकर.
जांच पूरी होने पर,
enterको दबाकर सिसट्रेस को खत्म करें कंसोल टर्मिनल, पहले चरण से चालू है.कुल आंकड़े जनरेट करने के लिए,
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 आउटपुट में अपने ऐप्लिकेशन कोड के आंकड़े जोड़ें
Pars_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 ListrecognizeImage(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() पर कॉल करने से पहले
आखिरी तारीख सेट करें
ऐप्लिकेशन, मॉडल को कंपाइल करने और अनुमान लगाने, दोनों के लिए समयसीमा तय कर सकते हैं.
- कंपाइलेशन का टाइम आउट सेट करने के लिए,
ANeuralNetworksCompilation_setTimeout()ANeuralNetworksCompilation_finish()पर कॉल करने से पहले - अनुमान टाइमआउट सेट करने के लिए, कॉल करें
ANeuralNetworksExecution_setTimeout()संकलन शुरू करने से पहले ध्यान देना ज़रूरी है.
ऑपरेंड के बारे में ज़्यादा जानकारी
नीचे दिए गए सेक्शन में ऑपरेंड के इस्तेमाल से जुड़े बेहतर विषयों के बारे में बताया गया है.
क्वांटाइज़्ड टेंसर
क्वांटाइज़्ड टेंसर, इसकी n-आयामी श्रेणी को दिखाने का एक छोटा तरीका है फ़्लोटिंग पॉइंट वैल्यू.
NNAPI, 8-बिट एसिमेट्रिक क्वांटाइज़्ड टेंसर का समर्थन करता है. इन टेंसर के लिए, हर सेल की वैल्यू को 8-बिट वाले पूर्णांक से दिखाया जाता है. इससे संबद्ध टेंसर एक स्केल और ज़ीरो पॉइंट वैल्यू होता है. इनका इस्तेमाल 8-बिट में बदलाव करने के लिए किया जाता है पूर्णांकों को फ़्लोटिंग पॉइंट वैल्यू में शामिल करना चाहिए.
इसका फ़ॉर्मूला है:
(cellValue - zeroPoint) * scale
जहां ज़ीरोपॉइंट वैल्यू, 32-बिट पूर्णांक और 32-बिट फ़्लोट करने वाला स्केल है अंक मान.
32-बिट फ़्लोटिंग पॉइंट वैल्यू के टेंसर की तुलना में, 8-बिट क्वांटाइज़ किए गए टेंसर दो फ़ायदे हैं:
- आपका ऐप्लिकेशन छोटा है, क्योंकि ट्रेनिंग पा चुके वज़न को 32-बिट टेंसर की ज़रूरत होती है.
- कंप्यूटेशन को अक्सर तेज़ी से एक्ज़ीक्यूट किया जा सकता है. ऐसा कम रकम की वजह से होता है का डेटा जिसे मेमोरी और प्रोसेसर की क्षमता से फ़ेच करने की ज़रूरत होती है जैसे कि डीएसपी की मदद से पूर्णांक की गिनती करना.
किसी फ़्लोटिंग पॉइंट मॉडल को क्वांटाइज़्ड मॉडल में बदला जा सकता है. हालांकि, हमारा अनुभव से पता चलता है कि बेहतर नतीजे पाने के लिए, मॉडल को आज़माएं. इस तरह न्यूरल नेटवर्क, हर वैल्यू की जानकारी का लेवल बढ़ाया गया. हर क्वांटाइज़्ड टेंसर के लिए, स्केल और ट्रेनिंग प्रोसेस के दौरान, ज़ीरोपॉइंट की वैल्यू तय की जाती हैं.
NNAPI में, आप
ANeuralNetworksOperandType
डेटा स्ट्रक्चर
ANEURALNETWORKS_TENSOR_QUANT8_ASYMM.
उस डेटा में, टेंसर का स्केल और ज़ीरोपॉइंट वैल्यू भी तय की जाती है
स्ट्रक्चर.
8-बिट एसिमेट्रिक क्वांटाइज़्ड टेंसर के अलावा, NNAPI इनके साथ काम करता है:
ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNELइसका इस्तेमाल, अहमियत को दिखाने के लिए किया जा सकता हैCONV/DEPTHWISE_CONV/TRANSPOSED_CONVकार्रवाइयां.ANEURALNETWORKS_TENSOR_QUANT16_ASYMMजिसका इस्तेमाल करके, इंटरनल स्टेटस की पुष्टि की जा सकती हैQUANTIZED_16BIT_LSTM.ANEURALNETWORKS_TENSOR_QUANT8_SYMMयहाँ एक इनपुट दिया जा सकता है.ANEURALNETWORKS_DEQUANTIZE.
वैकल्पिक ऑपरेंड
कुछ कार्रवाइयां, जैसे
ANEURALNETWORKS_LSH_PROJECTION,
वैकल्पिक संकार्य ले सकते हैं. मॉडल में यह बताने के लिए कि वैकल्पिक ऑपरेंड है
छोड़ दिया गया है, तो
ANeuralNetworksModel_setOperandValue()
फ़ंक्शन, बफ़र के लिए NULL और लंबाई के लिए 0 पास करता है.
ऑपरेंड मौजूद है या नहीं, यह फ़ैसला हर सदस्य के लिए अलग-अलग होता है
है, तो आप बताते हैं कि ऑपरेंड को
ANeuralNetworksExecution_setInput()
या
ANeuralNetworksExecution_setOutput()
फ़ंक्शन, बफ़र के लिए NULL और लंबाई के लिए 0 पास करते हैं.
अज्ञात रैंक के टेन्सर
Android 9 (एपीआई लेवल 28) ने अज्ञात डाइमेंशन के मॉडल ऑपरेंड को लॉन्च किया, लेकिन ज्ञात रैंक (डाइमेंशन की संख्या). Android 10 (एपीआई लेवल 29) पेश किया गया अज्ञात रैंक के टेंसर, जैसा कि दिखाया गया है ANeuralNetworkOperandType.
NNAPI मानदंड
NNAPI मानदंड, platform/test/mlts/benchmark में एओएसपी पर उपलब्ध है
(मानदंड ऐप्लिकेशन) और platform/test/mlts/models (मॉडल और डेटासेट) को ऐक्सेस कर सकते हैं.
मानदंड, इंतज़ार के समय और सटीक होने का आकलन करता है और ड्राइवर की तुलना एक जैसा करता है काम को उसी मॉडल के लिए करते हैं जो सीपीयू पर चल रहे Tensorflow Lite का इस्तेमाल करके किया जाता है और डेटासेट.
मानदंड का इस्तेमाल करने के लिए, ये काम करें:
टारगेट Android डिवाइस को अपने कंप्यूटर से कनेक्ट करें. इसके बाद, एक टर्मिनल विंडो खोलें और यह पक्का करें कि डिवाइस को adb से ऐक्सेस किया जा सकता है.
एक से ज़्यादा Android डिवाइस कनेक्ट होने पर, टारगेट किए गए डिवाइस को एक्सपोर्ट करें
ANDROID_SERIALएनवायरमेंट वैरिएबल.Android की टॉप-लेवल की सोर्स डायरेक्ट्री पर जाएं.
इन कमांड को चलाएं:
lunch aosp_arm-userdebug # Or aosp_arm64-userdebug if available ./test/mlts/benchmark/build_and_run_benchmark.sh
बेंचमार्क रन के अंत में, इसके परिणाम एक HTML पेज के रूप में प्रस्तुत किए जाएंगे
xdg-openको पास किया गया.
NNAPI लॉग
NNAPI, सिस्टम लॉग में गड़बड़ी की उपयोगी जानकारी जनरेट करता है. लॉग का विश्लेषण करने के लिए, logcat का इस्तेमाल करें उपयोगिता.
खास फ़ेज़ या कॉम्पोनेंट के लिए, verbose NNAPI लॉगिंग चालू करें.
प्रॉपर्टी debug.nn.vlog (adb shell का इस्तेमाल करके) को, नीचे दी गई वैल्यू की सूची में शामिल करें,
इन्हें स्पेस, कोलन या कॉमा लगाकर अलग किया जा सकता है:
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 एपीआई कॉम्पोनेंट
अलग-अलग लेवल पर अन्य लॉग एंट्री होती हैं. हर एंट्री, एक खास लॉग टैग का इस्तेमाल करके की जाती है.
कॉम्पोनेंट की सूची पाने के लिए, इनका इस्तेमाल करके सोर्स ट्री खोजें ये एक्सप्रेशन:
grep -R 'define LOG_TAG' | awk -F '"' '{print $2}' | sort -u | egrep -v "Sample|FileTag|test"
यह एक्सप्रेशन फ़िलहाल नीचे दिए गए टैग दिखाता है:
- बर्स्टबिल्डर
- कॉलबैक
- कंपाइलेशनबिल्डर
- Cpu एक्ज़िक्यूटर
- एक्ज़ीक्यूशन बिल्डर
- एक्ज़ीक्यूशन बर्स्टकंट्रोलर
- एक्ज़ीक्यूशन बर्स्टसर्वर
- प्लान लागू करना
- फ़ाइबोनाशी ड्राइवर
- ग्राफ़डंप
- इंडेक्स किया गया शेपरैपर
- आयनवॉचर
- मैनेजर
- मेमोरी
- मेमोरी यूटिल्स
- मेटामॉडल
- मॉडलArgumentInfo
- मॉडलबिल्डर
- न्यूरल नेटवर्क
- ऑपरेशन रिज़ॉल्वर
- ऑपरेशंस
- ऑपरेशंस यूटिल्स
- पैकेज की जानकारी
- टोकनहैशर
- टाइपमैनेजर
- उपयोगिताएं
- वैलिडेटहॉल
- वर्शन वाले इंटरफ़ेस
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 पर सेट करें.