मेटाडेटा का इस्तेमाल करके, मॉडल इंटरफ़ेस जनरेट करें

TensorFlow Lite Metadata का इस्तेमाल करके डेवलपर, Android पर इंटिग्रेशन चालू करने के लिए रैपर कोड जनरेट कर सकते हैं. ज़्यादातर डेवलपर के लिए, Android Studio ML मॉडल बाइंडिंग का ग्राफ़िकल इंटरफ़ेस इस्तेमाल करना सबसे आसान है. अगर आपको अपनी पसंद के मुताबिक ज़्यादा टूल की ज़रूरत है या कमांड लाइन टूल का इस्तेमाल किया जा रहा है, तो TensorFlow Lite Codegen भी उपलब्ध होगा.

Android Studio ML मॉडल बाइंडिंग का इस्तेमाल करें

मेटाडेटा की मदद से बेहतर बनाए गए TensorFlow Lite मॉडल के लिए, डेवलपर Android Studio ML मॉडल बाइंडिंग का इस्तेमाल कर सकते हैं. इससे प्रोजेक्ट की सेटिंग अपने-आप कॉन्फ़िगर हो जाएंगी और मॉडल मेटाडेटा के आधार पर रैपर क्लास भी जनरेट हो जाएंगी. रैपर कोड, ByteBuffer के साथ सीधे इंटरैक्ट करने की ज़रूरत को हटा देता है. इसके बजाय, डेवलपर Bitmap और Rect जैसे टाइप किए गए ऑब्जेक्ट से TensorFlow Lite मॉडल से इंटरैक्ट कर सकते हैं.

Android Studio में TensorFlow Lite मॉडल इंपोर्ट करना

  1. उस मॉड्यूल पर राइट क्लिक करें जिसमें आपको TFLite मॉडल का इस्तेमाल करना है या File पर क्लिक करें. इसके बाद, New > Other > TensorFlow Lite Model पर क्लिक करें

  2. अपनी TFLite फ़ाइल की जगह चुनें. ध्यान दें कि टूलिंग, एमएल मॉडल बाइंडिंग के साथ आपकी ओर से मॉड्यूल की डिपेंडेंसी को कॉन्फ़िगर करेगी. साथ ही, सभी डिपेंडेंसी आपके Android मॉड्यूल की build.gradle फ़ाइल में अपने-आप शामिल हो जाएंगी.

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

  3. Finish पर क्लिक करें.

  4. इंपोर्ट पूरा होने के बाद, आपको यह स्क्रीन दिखेगी. इस मॉडल का इस्तेमाल करने के लिए, Kotlin या Java चुनें. इसके बाद, कोड को कॉपी करके Sample Code सेक्शन में चिपकाएं. Android Studio में ml डायरेक्ट्री में TFLite मॉडल पर दो बार क्लिक करके, इस स्क्रीन पर वापस आया जा सकता है.

मॉडल के अनुमान में तेज़ी लाना

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

पहला चरण. मॉड्यूल build.gradle फ़ाइल की जांच करें, जिसमें यह शामिल है:

    dependencies {
        ...
        // TFLite GPU delegate 2.3.0 or above is required.
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
    }

दूसरा चरण. यह पता करें कि डिवाइस पर चल रहा जीपीयू, TensorFlow जीपीयू डेलिगेट के साथ काम करता है या नहीं. अगर एक से ज़्यादा सीपीयू थ्रेड का इस्तेमाल करके मॉडल नहीं चलाया जा रहा है, तो:

Kotlin

    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = if(compatList.isDelegateSupportedOnThisDevice) {
        // if the device has a supported GPU, add the GPU delegate
        Model.Options.Builder().setDevice(Model.Device.GPU).build()
    } else {
        // if the GPU is not supported, run on 4 threads
        Model.Options.Builder().setNumThreads(4).build()
    }

    // Initialize the model as usual feeding in the options object
    val myModel = MyModel.newInstance(context, options)

    // Run inference per sample code

Java

    import org.tensorflow.lite.support.model.Model
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Model.Options options;
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        options = Model.Options.Builder().setDevice(Model.Device.GPU).build();
    } else {
        // if the GPU is not supported, run on 4 threads
        options = Model.Options.Builder().setNumThreads(4).build();
    }

    MyModel myModel = new MyModel.newInstance(context, options);

    // Run inference per sample code

TensorFlow लाइट कोड जनरेटर की मदद से मॉडल इंटरफ़ेस जनरेट करें

मेटाडेटा की मदद से बेहतर बनाए गए TensorFlow Lite मॉडल के लिए, डेवलपर TensorFlow Lite के Android रैपर कोड जनरेटर का इस्तेमाल कर सकते हैं, ताकि प्लैटफ़ॉर्म के हिसाब से रैपर कोड बनाया जा सके. रैपर कोड, ByteBuffer से सीधे इंटरैक्ट करने की ज़रूरत को हटा देता है. इसके बजाय, डेवलपर Bitmap और Rect जैसे टाइप किए गए ऑब्जेक्ट की मदद से, TensorFlow लाइट मॉडल से इंटरैक्ट कर सकते हैं.

कोड जनरेटर कितने काम का है, यह इस बात पर निर्भर करता है कि TensorFlow Lite के मॉडल का मेटाडेटा एंट्री पूरी है या नहीं. कोडजन टूल हर फ़ील्ड को कैसे पार्स करता है, यह देखने के लिए metadata_schema.fbs में काम के फ़ील्ड में जाकर, <Codegen usage> सेक्शन देखें.

रैपर कोड जनरेट करें

आपको अपने टर्मिनल में नीचे दिए गए टूल को इंस्टॉल करना होगा:

pip install tflite-support

पूरा होने के बाद, कोड जनरेटर का इस्तेमाल इस सिंटैक्स का इस्तेमाल करके किया जा सकता है:

tflite_codegen --model=./model_with_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --package_name=org.tensorflow.lite.classify \
    --model_class_name=MyClassifierModel \
    --destination=./classify_wrapper

इससे मिलने वाला कोड, डेस्टिनेशन डायरेक्ट्री में दिखेगा. अगर Google Colab या अन्य रिमोट एनवायरमेंट का इस्तेमाल किया जा रहा है, तो इन्हें ZIP फ़ॉर्मैट में ज़िप अप करके, अपने Android Studio प्रोजेक्ट में डाउनलोड करना आसान हो सकता है:

# Zip up the generated code
!zip -r classify_wrapper.zip classify_wrapper/

# Download the archive
from google.colab import files
files.download('classify_wrapper.zip')

जनरेट किए गए कोड का इस्तेमाल करना

पहला चरण: जनरेट किया गया कोड इंपोर्ट करना

अगर ज़रूरी हो, तो जनरेट किए गए कोड को डायरेक्ट्री स्ट्रक्चर में अनज़िप करें. जनरेट किए गए कोड का रूट, SRC_ROOT माना जाता है.

वह Android Studio प्रोजेक्ट खोलें जिसमें आपको TensorFlow लाइट मॉडल इस्तेमाल करना है और जनरेट किए गए मॉड्यूल को इनमें से इंपोर्ट करना है: Android फ़ाइल -> नया -> इंपोर्ट मॉड्यूल -> SRC_ROOT चुनें

ऊपर दिए गए उदाहरण का इस्तेमाल करने पर, इंपोर्ट की गई डायरेक्ट्री और मॉड्यूल को classify_wrapper कहा जाएगा.

दूसरा चरण: ऐप्लिकेशन की build.gradle फ़ाइल अपडेट करें

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

Android सेक्शन में, इन्हें जोड़ें:

aaptOptions {
   noCompress "tflite"
}

डिपेंडेंसी सेक्शन में, यह जानकारी जोड़ें:

implementation project(":classify_wrapper")

तीसरा चरण: मॉडल का इस्तेमाल करना

// 1. Initialize the model
MyClassifierModel myImageClassifier = null;

try {
    myImageClassifier = new MyClassifierModel(this);
} catch (IOException io){
    // Error reading the model
}

if(null != myImageClassifier) {

    // 2. Set the input with a Bitmap called inputBitmap
    MyClassifierModel.Inputs inputs = myImageClassifier.createInputs();
    inputs.loadImage(inputBitmap));

    // 3. Run the model
    MyClassifierModel.Outputs outputs = myImageClassifier.run(inputs);

    // 4. Retrieve the result
    Map<String, Float> labeledProbability = outputs.getProbability();
}

मॉडल के अनुमान में तेज़ी लाना

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

  • Context: Android पर की गई गतिविधि या सेवा से मिली जानकारी
  • (ज़रूरी नहीं) Device: TFLite से तेज़ी लाने का डेलिगेट. उदाहरण के लिए: GPUDelegate
  • (ज़रूरी नहीं) numThreads: मॉडल को चलाने के लिए इस्तेमाल किए गए थ्रेड की संख्या - डिफ़ॉल्ट थ्रेड एक होती है.

उदाहरण के लिए, जीपीयू डेलिगेट और ज़्यादा से ज़्यादा तीन थ्रेड का इस्तेमाल करने के लिए, मॉडल को इस तरह से शुरू किया जा सकता है:

try {
    myImageClassifier = new MyClassifierModel(this, Model.Device.GPU, 3);
} catch (IOException io){
    // Error reading the model
}

समस्या हल करना

अगर आपको 'java.io.FileNotFound कैप्शन: इस फ़ाइल को फ़ाइल डिस्क्रिप्टर के तौर पर नहीं खोला जा सकता, यह कंप्रेस की गई गड़बड़ी की वजह से हो सकता है, तो ऐप्लिकेशन मॉड्यूल के Android सेक्शन में नीचे दी गई लाइनें डालें, जो लाइब्रेरी मॉड्यूल का इस्तेमाल करेगी:

aaptOptions {
   noCompress "tflite"
}