Android में तंत्रिका नेटवर्क, Google एमएल किट और न केवल

तो, आपने अपने तंत्रिका नेटवर्क को कुछ प्रकार के कार्य (उदाहरण के लिए, कैमरे के माध्यम से एक ही वस्तु की पहचान) करने के लिए विकसित और प्रशिक्षित किया है और इसे अपने एंड्रॉइड एप्लिकेशन में लागू करना चाहते हैं? फिर कैट में आपका स्वागत है!

शुरू करने के लिए, यह समझा जाना चाहिए कि एंड्रॉइड वर्तमान में केवल TensorFlowLite- प्रारूप नेटवर्क के साथ काम करना जानता है, जिसका अर्थ है कि हमें स्रोत नेटवर्क के साथ कुछ हेरफेर करने की आवश्यकता है। मान लीजिए कि आपके पास केरस या टेन्सरफ्लो फ्रेमवर्क पर पहले से ही प्रशिक्षित नेटवर्क है। आपको ग्रिड को pb फॉर्मेट में सेव करना होगा।

चलो मामले से शुरू करते हैं जब आप टेंसरफ़्लो पर लिखते हैं, तो सब कुछ थोड़ा आसान होता है।

saver = tf.train.Saver() tf.train.write_graph(session.graph_def, path_to_folder, "net.pb", False) tf.train.write_graph(session.graph_def, path_to_folder, "net.pbtxt", True) saver.save(session,path_to_folder+"model.ckpt") 

यदि आप केरस में लिखते हैं, तो आपको एक नया सत्र ऑब्जेक्ट बनाने की आवश्यकता है, जहां आप नेटवर्क को प्रशिक्षित करते हैं, उस फाइल की शुरुआत में एक लिंक सहेजें और इसे set_session फ़ंक्शन में पास करें

 import keras.backend as K session = K.get_session() K.set_session(session) 

ठीक है, आपने नेटवर्क को सहेज लिया है, अब आपको इसे tflite प्रारूप में बदलने की आवश्यकता है। ऐसा करने के लिए, हमें दो छोटी स्क्रिप्ट चलाने की ज़रूरत है, पहला "फ्रीज़" नेटवर्क, दूसरा पहले से ही वांछित प्रारूप में अनुवाद होगा। "फ्रीज" का सार यह है कि tf सहेजी गई pb फ़ाइल में परतों के वजन को संग्रहीत नहीं करता है, लेकिन उन्हें विशेष चौकियों में बचाता है। Tflite में बाद के रूपांतरण के लिए, आपको एक फ़ाइल में तंत्रिका नेटवर्क के बारे में सभी जानकारी चाहिए।

 freeze_graph --input_binary=false --input_graph=net.pbtxt --output_node_names=result/Softmax --output_graph=frozen_graph.pb --input_checkpoint=model.ckpt 

ध्यान दें कि आपको आउटपुट टेंसर का नाम जानने की आवश्यकता है। टेनसफ़्लो में आप केरस का उपयोग करने के मामले में खुद को सेट कर सकते हैं - लेयर कंस्ट्रक्टर में नाम सेट करें

 model.add(Dense(10,activation="softmax",name="result")) 

इस मामले में, टेंसर का नाम आमतौर पर "परिणाम / सॉफ्टमैक्स" जैसा दिखता है

यदि आपके मामले में ऐसा नहीं है, तो आप नाम निम्नानुसार पा सकते हैं

 [print(n.name) for n in session.graph.as_graph_def().node] 

यह दूसरी स्क्रिप्ट को चलाने के लिए बनी हुई है

 toco --graph_def_file=frozen-graph.pb --output_file=model.tflite --output_format=TFLITE --inference_type=FLOAT --input_arrays=input_input --output_arrays=result/Softmax --input_shapes=1,784 

हुर्रे! अब आपके पास अपने फ़ोल्डर में एक TensorFlowLite मॉडल है, यह आपके एंड्रॉइड एप्लिकेशन में इसे सही ढंग से एकीकृत करने के लिए आपके ऊपर है। आप इसे newfangled Firebase ML Kit के साथ कर सकते हैं, लेकिन एक और तरीका है, इसके बारे में थोड़ा बाद में। हमारी श्रेणी फ़ाइल में निर्भरता जोड़ें

 dependencies { // ... implementation 'com.google.firebase:firebase-ml-model-interpreter:16.2.0' } 

अब आपको यह तय करने की आवश्यकता है कि क्या आप मॉडल को अपने सर्वर पर कहीं रखेंगे, या एप्लिकेशन के साथ शिप करेंगे।

पहले मामले पर विचार करें: सर्वर पर एक मॉडल। सबसे पहले, प्रकट में जोड़ना न भूलें

 <uses-permission android:name="android.permission.INTERNET" /> 

  //      ,   /  FirebaseModelDownloadConditions.Builder conditionsBuilder = new FirebaseModelDownloadConditions.Builder().requireWifi(); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { conditionsBuilder = conditionsBuilder .requireCharging(); } FirebaseModelDownloadConditions conditions = conditionsBuilder.build(); //   FirebaseCloudModelSource ,   (    ,  //   Firebase) FirebaseCloudModelSource cloudSource = new FirebaseCloudModelSource.Builder("my_cloud_model") .enableModelUpdates(true) .setInitialDownloadConditions(conditions) .setUpdatesDownloadConditions(conditions) .build(); FirebaseModelManager.getInstance().registerCloudModelSource(cloudSource); 

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

 android { // ... aaptOptions { noCompress "tflite" } } 

जिसके बाद, क्लाउड में मॉडल के अनुरूप, हमारे स्थानीय न्यूरॉन को पंजीकृत होने की आवश्यकता होती है।

 FirebaseLocalModelSource localSource = new FirebaseLocalModelSource.Builder("my_local_model") .setAssetFilePath("mymodel.tflite") .build(); FirebaseModelManager.getInstance().registerLocalModelSource(localSource); 

आपके मॉडल के ऊपर कोड मान संपत्ति फ़ोल्डर में है, यदि नहीं, तो इसके बजाय

  .setAssetFilePath("mymodel.tflite") 

उपयोग

  .seFilePath(filePath) 

फिर हम नए ऑब्जेक्ट्स बनाते हैं FirebaseModelOptions और FirebaseModelInterpreter

 FirebaseModelOptions options = new FirebaseModelOptions.Builder() .setCloudModelName("my_cloud_model") .setLocalModelName("my_local_model") .build(); FirebaseModelInterpreter firebaseInterpreter = FirebaseModelInterpreter.getInstance(options); 

आप एक ही समय में स्थानीय और सर्वर-आधारित दोनों मॉडल का उपयोग कर सकते हैं। इस स्थिति में, डिफ़ॉल्ट रूप से क्लाउड का उपयोग किया जाएगा, यदि उपलब्ध हो, अन्यथा स्थानीय।

लगभग सब कुछ, यह इनपुट / आउटपुट डेटा के लिए सरणियाँ बनाने के लिए रहता है, और चलता है!

 FirebaseModelInputOutputOptions inputOutputOptions = new FirebaseModelInputOutputOptions.Builder() .setInputFormat(0, FirebaseModelDataType.BYTE, new int[]{1, 640, 480, 3}) .setOutputFormat(0, FirebaseModelDataType.FLOAT32, new int[]{1, 784}) .build(); byte[][][][] input = new byte[1][640][480][3]; input = getYourInputData(); FirebaseModelInputs inputs = new FirebaseModelInputs.Builder() .add(input) // add() as many input arrays as your model requires .build(); Task<FirebaseModelOutputs> result = firebaseInterpreter.run(inputs, inputOutputOptions) .addOnSuccessListener( new OnSuccessListener<FirebaseModelOutputs>() { @Override public void onSuccess(FirebaseModelOutputs result) { // ... } }) .addOnFailureListener( new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // Task failed with an exception // ... } }); float[][] output = result.<float[][]>getOutput(0); float[] probabilities = output[0]; 

यदि किसी कारण से आप फायरबेस का उपयोग नहीं करना चाहते हैं, तो एक और तरीका है, टैफलाइट दुभाषिया को कॉल करना और इसे सीधे डेटा खिलाना।

निर्माण / श्रेणीबद्ध करने के लिए एक पंक्ति जोड़ें

  implementation 'org.tensorflow:tensorflow-lite:+' 

एक दुभाषिया और सरणियाँ बनाएँ

  Interpreter tflite = new Interpreter(loadModelFile(getContext(), "model.tflite")); //     inputs tflite.run(inputs,outputs) 

इस मामले में कोड बहुत कम है, जैसा कि आप देख सकते हैं।

बस आपको Android में अपने तंत्रिका नेटवर्क का उपयोग करने की आवश्यकता है।

उपयोगी लिंक:

एमएल किट द्वारा बंद डॉक
Tensorflow Lite