7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें

मेटाडेटा का उपयोग करके मॉडल इंटरफेस उत्पन्न करें

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

Android Studio ML मॉडल बाइंडिंग का उपयोग करें

मेटाडेटा के साथ उन्नत TensorFlow लाइट मॉडल के लिए, डेवलपर्स प्रोजेक्ट के लिए सेटिंग्स को स्वचालित रूप से कॉन्फ़िगर करने और मॉडल मेटाडेटा के आधार पर रैपर वर्ग उत्पन्न करने के लिए Android Studio ML मॉडल बाइंडिंग का उपयोग कर सकते हैं। रैपर कोड ByteBuffer के साथ सीधे बातचीत करने की आवश्यकता को हटा देता है। इसके बजाय, डेवलपर्स टेंसरफ्लो लाइट मॉडल के साथ Bitmap और Rect जैसी टाइप की गई वस्तुओं के साथ बातचीत कर सकते हैं।

Android Studio में TensorFlow Lite मॉडल आयात करें

  1. उस मॉड्यूल पर राइट-क्लिक करें जिसे आप TFLite मॉडल का उपयोग करना चाहते हैं या File पर क्लिक करें, फिर New > Other > TensorFlow Lite Model पर क्लिक करें। TensorFlow Lite आयात कार्यक्षमता तक पहुँचने के लिए मेनू पर राइट-क्लिक करें

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

    वैकल्पिक: यदि आप GPU त्वरण का उपयोग करना चाहते हैं तो TensorFlow GPU आयात करने के लिए दूसरा चेकबॉक्स चुनें। TFlite मॉडल के लिए आयात संवाद

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

  4. आयात सफल होने के बाद निम्न स्क्रीन दिखाई देगी। मॉडल का उपयोग शुरू करने के लिए, कोटलिन या जावा का चयन करें, Sample Code अनुभाग के तहत कोड को कॉपी और पेस्ट करें। आप एंड्रॉइड स्टूडियो में ml डायरेक्टरी के तहत टीएफलाइट मॉडल पर डबल क्लिक करके इस स्क्रीन पर वापस आ सकते हैं। Android Studio में मॉडल विवरण पृष्ठ

मॉडल अनुमान को तेज करना

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

चरण 1. मॉड्यूल build.gradle फ़ाइल की जाँच करें कि इसमें निम्न निर्भरता है:

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

चरण 2. पता लगाएँ कि क्या डिवाइस पर चल रहा GPU TensorFlow GPU प्रतिनिधि के साथ संगत है, यदि एकाधिक CPU थ्रेड्स का उपयोग करके मॉडल नहीं चलाया जाता है:

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
      

जावा

    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 Lite कोड जनरेटर के साथ मॉडल इंटरफेस जेनरेट करें

मेटाडेटा के साथ उन्नत TensorFlow Lite मॉडल के लिए, डेवलपर्स प्लेटफ़ॉर्म विशिष्ट रैपर कोड बनाने के लिए TensorFlow Lite एंड्रॉइड रैपर कोड जनरेटर का उपयोग कर सकते हैं। रैपर कोड ByteBuffer के साथ सीधे बातचीत करने की आवश्यकता को हटा देता है। इसके बजाय, डेवलपर्स टेंसरफ्लो लाइट मॉडल के साथ Bitmap और Rect जैसी टाइप की गई वस्तुओं के साथ बातचीत कर सकते हैं।

कोड जनरेटर की उपयोगिता TensorFlow Lite मॉडल की मेटाडेटा प्रविष्टि की पूर्णता पर निर्भर करती है। यह देखने के लिए कि कैसे कोडजन टूल प्रत्येक फ़ील्ड को पार्स करता है, मेटाडेटा_स्कीमा .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')

जेनरेट कोड का उपयोग करना

चरण 1: जनरेट किया गया कोड आयात करें

यदि आवश्यक हो तो निर्देशिका संरचना में उत्पन्न कोड को अनज़िप करें। उत्पन्न कोड की जड़ SRC_ROOT है।

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

उपरोक्त उदाहरण का उपयोग करते हुए, आयातित निर्देशिका और मॉड्यूल को classify_wrapper कहा जाएगा।

चरण 2: ऐप की build.gradle फ़ाइल को अपडेट करें

ऐप मॉड्यूल में जो जेनरेटेड लाइब्रेरी मॉड्यूल का उपभोग करेगा:

Android अनुभाग के अंतर्गत, निम्नलिखित जोड़ें:

aaptOptions {
   noCompress "tflite"
}

निर्भरता अनुभाग के अंतर्गत, निम्नलिखित जोड़ें:

implementation project(":classify_wrapper")

चरण 3: मॉडल का उपयोग करना

// 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 या NNAPIDelegate
  • (वैकल्पिक) numThreads : मॉडल को चलाने के लिए उपयोग किए जाने वाले थ्रेड्स की संख्या - डिफ़ॉल्ट एक है।

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

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

समस्या निवारण

यदि आपको 'java.io.FileNotFoundException' मिलता है: यह फ़ाइल फ़ाइल डिस्क्रिप्टर के रूप में नहीं खोली जा सकती; यह शायद संकुचित है' त्रुटि, ऐप मॉड्यूल के एंड्रॉइड सेक्शन के तहत निम्न पंक्तियां डालें जो लाइब्रेरी मॉड्यूल का उपयोग करेगा:

aaptOptions {
   noCompress "tflite"
}