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

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

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

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

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

  1. उस मॉड्यूल पर राइट क्लिक करें जिसमें आपको TFLite मॉडल इस्तेमाल करना है या फिर उस मॉड्यूल पर क्लिक करें File, फिर New > Other > LiteRT 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 'com.google.ai.edge.litert:litert-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

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

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

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

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

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

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.FileNotFoundFound: इस फ़ाइल को नहीं खोला जा सकता? फ़ाइल डिस्क्रिप्टर; शायद यह कंप्रेस किया हुआ है' गड़बड़ी होने पर, ये लाइनें डालें जो लाइब्रेरी मॉड्यूल का इस्तेमाल करेगा:

aaptOptions {
   noCompress "tflite"
}