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

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

Android Studio ML Model Binding का इस्तेमाल करना

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

ज़रूरी है

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

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

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

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

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

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

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

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

गड़बड़ी हो सकती है.

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

    dependencies {
        ...
        // For the LiteRT GPU delegate, we need
        // 'com.google.ai.edge.litert:litert-gpu' version 1.*.
        implementation 'com.google.ai.edge.litert:litert-gpu:1.4.1'
    }

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

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

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

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

कोड जनरेट करने वाले टूल का सही तरीके से काम करना, LiteRT मॉडल के मेटाडेटा की एंट्री पूरी होने पर निर्भर करता है. कोड जनरेट करने वाला टूल, हर फ़ील्ड को कैसे पार्स करता है, यह देखने के लिए 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 या किसी अन्य रिमोट एनवायरमेंट का इस्तेमाल किया जा रहा है, तो नतीजे को ज़िप फ़ाइल में सेव करना और उसे अपने 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 का वह प्रोजेक्ट खोलें जिसमें आपको LiteRT मॉडल का इस्तेमाल करना है. इसके बाद, जनरेट किए गए मॉड्यूल को इंपोर्ट करें. इसके लिए, फ़ाइल -> नया -> मॉड्यूल इंपोर्ट करें -> 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.FileNotFoundException: This file can not be opened as a file descriptor; it is probably compressed' गड़बड़ी का मैसेज मिलता है, तो ऐप्लिकेशन मॉड्यूल के android सेक्शन में यहां दी गई लाइनें डालें. यह ऐप्लिकेशन मॉड्यूल, लाइब्रेरी मॉड्यूल का इस्तेमाल करेगा:

aaptOptions {
   noCompress "tflite"
}