इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी
1. परिचय
ध्यान दें: इस कोडलैब को टेस्ट करने के लिए, किसी फ़िज़िकल डिवाइस की ज़रूरत होती है
TensorFlow, एक मल्टीपर्पस मशीन लर्निंग फ़्रेमवर्क है. TensorFlow का इस्तेमाल, क्लाउड में क्लस्टर के ज़रिए बड़े मॉडल को ट्रेन करने से लेकर, आपके फ़ोन जैसे एम्बेडेड सिस्टम पर स्थानीय तौर पर मॉडल चलाने तक, कहीं भी किया जा सकता है.
इस कोडलैब में, Android डिवाइस पर इमेज की पहचान करने वाला मॉडल चलाने के लिए, TensorFlow Lite का इस्तेमाल किया गया है.
Android Studio 4.1 या इसके बाद का वर्शन इंस्टॉल करें
अगर आपने इसे पहले से इंस्टॉल नहीं किया है, तो TensorFlow Lite मॉडल को ट्रेनिंग देते समय Android Studio 4.1 या इसके बाद के वर्शन को डाउनलोड और इंस्टॉल करें.
आपको क्या सीखने को मिलेगा
- TensorFlow Lite मॉडल मेकर का इस्तेमाल करके, अपनी पसंद के मुताबिक इमेज क्लासिफ़ायर को ट्रेन करने का तरीका.
- CameraX का इस्तेमाल करके, Android ऐप्लिकेशन में कस्टम मॉडल को इंटिग्रेट करने के लिए, TensorFlow Lite मॉडल को इंपोर्ट करने के लिए Android Studio का इस्तेमाल करने का तरीका.
- अपने मॉडल को तेज़ करने के लिए, फ़ोन पर जीपीयू का इस्तेमाल करने का तरीका.
आपको क्या बनाना है
यह एक आसान कैमरा ऐप्लिकेशन है, जो फूलों की पहचान करने के लिए TensorFlow इमेज पहचानने वाले प्रोग्राम का इस्तेमाल करता है.
2. Colab का इस्तेमाल करके, फूलों की पहचान करने वाले एआई को ट्रेन करना
मॉडल की ट्रेनिंग शुरू करने से पहले, Android Studio 4.1 या इसके बाद के वर्शन को डाउनलोड और इंस्टॉल करें.
Colab खोलें. इसमें, TensorFlow Lite ट्रांसफ़र लर्निंग का इस्तेमाल करके, फूलों को पहचानने के लिए, Keras की मदद से क्लासिफ़ायर को ट्रेनिंग देने का तरीका बताया गया है.
3. वर्किंग डायरेक्ट्री सेट अप करना
Git डेटा स्टोर करने की जगह को क्लोन करना
यह कमांड, उस Git डेटा स्टोर करने की जगह को क्लोन करेगा जिसमें इस कोडलैब के लिए ज़रूरी फ़ाइलें मौजूद हैं:
git clone https://github.com/hoitab/TFLClassify.git
इसके बाद, उस डायरेक्ट्री पर जाएं जिसमें आपने अभी-अभी डेटा स्टोरेज की जगह को क्लोन किया है. इस कोडलैब के बाकी हिस्से में, आपको यहां काम करना होगा:
cd TFLClassify
4. Android स्केलेटन ऐप्लिकेशन सेट अप करना
Android Studio 4.1 या इसके बाद का वर्शन इंस्टॉल करें
अगर आपने इसे पहले से इंस्टॉल नहीं किया है, तो Android Studio 4.1 या इसके बाद का वर्शन इंस्टॉल करें.
Android Studio में प्रोजेक्ट खोलना
Android Studio में कोई प्रोजेक्ट खोलने के लिए, यह तरीका अपनाएं:
- Android Studio
खोलें. लोड होने के बाद, इस पॉप-अप से "मौजूदा प्रोजेक्ट खोलें" चुनें:
- फ़ाइल सिलेक्टर में, अपनी वर्किंग डायरेक्ट्री से
TFLClassify/build.gradle
चुनें.
- पहली बार प्रोजेक्ट खोलने पर, आपको "Gradle सिंक" पॉप-अप दिखेगा. इसमें, gradle wrapper का इस्तेमाल करने के बारे में पूछा जाएगा. "ठीक है" पर क्लिक करें.
- अगर आपने पहले से ही अपने फ़ोन पर डेवलपर मोड और यूएसबी डीबगिंग की सुविधा चालू नहीं की है, तो उसे चालू करें. इसे सिर्फ़ एक बार सेट अप करना होगा. इन निर्देशों का पालन करें.
- प्रोजेक्ट और फ़ोन, दोनों तैयार होने के बाद, इसे किसी रीयल डिवाइस पर चलाया जा सकता है. इसके लिए, टूलबार में
TFL_Classify.start
को चुनें और 'चालू करें' बटनको दबाएं:
- अब Tensorflow Demo को अपना कैमरा ऐक्सेस करने की अनुमति दें:
- आपको अपने फ़ोन पर नीचे दी गई स्क्रीन दिखेगी. इसमें असल नतीजों की जगह पर, रैंडम नंबर दिखेंगे.
5. Android ऐप्लिकेशन में TensorFlow Lite जोड़ना
- बाईं ओर मौजूद प्रोजेक्ट एक्सप्लोरर में,
start
मॉड्यूल चुनें:
start
मॉड्यूल पर राइट क्लिक करें याFile
पर क्लिक करें. इसके बाद,New
>Other
>TensorFlow Lite Model
पर क्लिक करें
- मॉडल की वह जगह चुनें जहां आपने पहले कस्टम ट्रेनिंग वाला
FlowerModel.tflite
डाउनलोड किया था.
Finish
पर क्लिक करें.- आपको आखिर में यह जानकारी दिखेगी. FlowerModel.tflite को इंपोर्ट कर लिया गया है. इसमें मॉडल के बारे में ज़्यादा जानकारी दिखती है. इसमें इनपुट / आउटपुट के साथ-साथ, शुरुआत करने के लिए कुछ सैंपल कोड भी शामिल हैं.
6. ज़रूरी नहीं: सभी 'क्या-क्या करें' सूची देखना
'बचे हुए काम' सूची की मदद से, उस जगह पर आसानी से पहुंचा जा सकता है जहां आपको कोडलैब को अपडेट करना है. आने वाले समय में किए जाने वाले कामों की याद दिलाने के लिए, इसका इस्तेमाल अपने Android प्रोजेक्ट में भी किया जा सकता है. कोड की टिप्पणियों का इस्तेमाल करके, 'क्या-क्या करें' सूची में आइटम जोड़े जा सकते हैं. इसके लिए, TODO
कीवर्ड टाइप करें. 'बचे हुए काम' की सूची ऐक्सेस करने के लिए, ये काम किए जा सकते हैं:
- हम आगे क्या करने वाले हैं, यह जानने के लिए 'क्या-क्या करना है' सूची देखें. ऐसा करने के लिए, सबसे ऊपर मौजूद मेन्यू बार में जाकर,
View
>Tool Windows
>TODO
को चुनें
- डिफ़ॉल्ट रूप से, यह सभी मॉड्यूल में सभी 'क्या-क्या करें' की सूची दिखाता है. इससे यह थोड़ा भ्रमित करने वाला हो जाता है. हम सिर्फ़ शुरू किए गए 'क्या-क्या करें' को क्रम से लगा सकते हैं. इसके लिए, 'क्या-क्या करें' पैनल के बगल में मौजूद, 'इसके हिसाब से ग्रुप करें' बटन पर क्लिक करें और
Modules
को चुनें
- शुरू करने के मॉड्यूल में मौजूद सभी आइटम को बड़ा करें:
7. TensorFlow Lite की मदद से कस्टम मॉडल चलाना
- 'बचे हुए काम' सूची में, 'बचे हुए काम 1' पर क्लिक करें या MainActivity.kt फ़ाइल खोलें और 'बचे हुए काम 1' ढूंढें. इसके बाद, यह लाइन जोड़कर मॉडल को शुरू करें:
private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
ImageAnalysis.Analyzer {
...
// TODO 1: Add class variable TensorFlow Lite Model
private val flowerModel = FlowerModel.newInstance(ctx)
...
}
- CameraX Analyzer के analyze तरीके में, हमें कैमरे के इनपुट
ImageProxy
कोBitmap
में बदलना होगा. साथ ही, अनुमान लगाने की प्रोसेस के लिएTensorImage
ऑब्जेक्ट बनाना होगा.
override fun analyze(imageProxy: ImageProxy) {
...
// TODO 2: Convert Image to Bitmap then to TensorImage
val tfImage = TensorImage.fromBitmap(toBitmap(imageProxy))
...
}
- इमेज को प्रोसेस करें और नतीजे पर ये कार्रवाइयां करें:
score
एट्रिब्यूट के तहत, नतीजों को संभावना के हिसाब से घटते क्रम में लगाएं. सबसे पहले, सबसे ज़्यादा संभावना वाले नतीजे दिखाएं.MAX_RESULT_DISPLAY
के हिसाब से, सबसे अच्छे k नतीजे चुनें. ज़्यादा या कम नतीजे पाने के लिए, आपके पास इस वैरिएबल की वैल्यू में बदलाव करने का विकल्प है.
override fun analyze(imageProxy: ImageProxy) {
...
// TODO 3: Process the image using the trained model, sort and pick out the top results
val outputs = flowerModel.process(tfImage)
.probabilityAsCategoryList.apply {
sortByDescending { it.score } // Sort with highest confidence first
}.take(MAX_RESULT_DISPLAY) // take the top results
...
}
- डेटा बाइंडिंग की मदद से, क्रम से लगाए गए और फ़िल्टर किए गए नतीजों को डेटा ऑब्जेक्ट में बदलें. ये ऑब्जेक्ट,
Recognition
के लिए इस्तेमाल किए जा सकते हैं:RecyclerView
override fun analyze(imageProxy: ImageProxy) {
...
// TODO 4: Converting the top probability items into a list of recognitions
for (output in outputs) {
items.add(Recognition(output.label, output.score))
}
...
}
- यहां दी गई लाइनों को हटाएं या उन पर टिप्पणी करें. इन लाइनों की मदद से, हमें पहले नकली नतीजे दिखते हैं:
// START - Placeholder code at the start of the codelab. Comment this block of code out.
for (i in 0..MAX_RESULT_DISPLAY-1){
items.add(Recognition("Fake label $i", Random.nextFloat()))
}
// END - Placeholder code at the start of the codelab. Comment this block of code out.
TFL_Classify.start
को चुनकर, ऐप्लिकेशन को असली डिवाइस पर चलाएं. इसके बाद, टूलबार पर मौजूद 'चलाएं' बटनको दबाएं:
- आपको अपने फ़ोन पर यह स्क्रीन दिखेगी. इसमें असली नतीजों की जगह पर, रैंडम नंबर दिखेंगे:
8. ज़रूरी नहीं: जीपीयू डेलिगेट की मदद से, अनुमान लगाने की प्रोसेस को तेज़ करना
TensorFlow Lite, आपके मोबाइल डिवाइस पर अनुमान लगाने की प्रोसेस को तेज़ करने के लिए, कई हार्डवेयर ऐक्सेलरेटर के साथ काम करता है. GPU, एक ऐसा ऐक्सेलरेटर है जिसका इस्तेमाल TensorFlow Lite, डेलिगेट करने की सुविधा की मदद से कर सकता है. साथ ही, इसका इस्तेमाल करना काफ़ी आसान है.
start
मॉड्यूल में जाकर, build.gradle खोलें. इसके अलावा, 'क्या-क्या करना है' सूची में जाकर, 'क्या-क्या करना है 5' पर क्लिक करके, यह डिपेंडेंसी जोड़ी जा सकती है:
// TODO 5: Optional GPU Delegates
implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
- MainActivity.kt फ़ाइल पर वापस जाएं या 'क्या-क्या करना है' सूची में, 'क्या-क्या करना है 6' पर क्लिक करें. flowerModel को शुरू करने का आसान तरीका, इस तरीके से बदलें: जीपीयू के साथ काम करने वाले डिवाइसों की सूची का एक इंस्टेंस पाएं और जीपीयू को इस आधार पर शुरू करें कि यह सूची में शामिल काम करने वाले जीपीयू में से एक है या नहीं. इसके अलावा, मॉडल को चलाने के लिए चार सीपीयू थ्रेड शुरू करें:
private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
ImageAnalysis.Analyzer {
...
// TODO 1: Add class variable TensorFlow Lite Model
// Initializing the flowerModel by lazy so that it runs in the same thread when the process
// method is called.
private val flowerModel: FlowerModel by lazy{
// TODO 6. Optional GPU acceleration
val compatList = CompatibilityList()
val options = if(compatList.isDelegateSupportedOnThisDevice){
Log.d(TAG, "This device is GPU Compatible ")
Model.Options.Builder().setDevice(Model.Device.GPU).build()
} else {
Log.d(TAG, "This device is GPU Incompatible ")
Model.Options.Builder().setNumThreads(4).build()
}
...
}
- इसका इस्तेमाल करने के लिए, मॉडल को शुरू करने वाले फ़ंक्शन को बदलें. इसके लिए, तरीके के इनपुट में
options
जोड़ें:
private class ImageAnalyzer(ctx: Context, private val listener: RecognitionListener) :
ImageAnalysis.Analyzer {
private val flowerModel: FlowerModel by lazy{
...
// Initialize the Flower Model
FlowerModel.newInstance(ctx, options)
}
}
TFL_Classify.start
को चुनकर, ऐप्लिकेशन को असली डिवाइस पर चलाएं. इसके बाद, टूलबार पर मौजूद 'चलाएं' बटनको दबाएं:
9. आगे क्या करें?
ज़्यादा जानकारी के लिए यहां कुछ लिंक दिए गए हैं:
- tfhub.dev से ML मॉडल बाइंडिंग के साथ काम करने वाले अन्य TFLite मॉडल आज़माएं.
- tensorflow.org और कोड रेपो पर मौजूद दस्तावेज़ों से, TFLite के बारे में ज़्यादा जानें.
- TFLite के पहले से ट्रेन किए गए कुछ अन्य मॉडल आज़माएं. इनमें बोली के लिए हॉटवर्ड डिटेक्टर और स्मार्ट-रिप्लाई का डिवाइस पर मौजूद वर्शन शामिल है.
- शुरू करने से जुड़े दस्तावेज़ों की मदद से, TensorFlow के बारे में ज़्यादा जानें.