Android पर, अपनी पसंद के मुताबिक TensorFlow Lite मॉडल का इस्तेमाल करना

अगर आपका ऐप्लिकेशन कस्टम TensorFlow Lite मॉडल का इस्तेमाल करता है, तो अपने मॉडल को डिप्लॉय करने के लिए Firebase ML का इस्तेमाल किया जा सकता है. Firebase की मदद से मॉडल डिप्लॉय करके, अपने ऐप्लिकेशन के शुरुआती डाउनलोड साइज़ को कम किया जा सकता है. साथ ही, ऐप्लिकेशन का नया वर्शन रिलीज़ किए बिना, ऐप्लिकेशन के एमएल मॉडल को अपडेट किया जा सकता है. इसके अलावा, Remote Config और A/B Testing की मदद से, उपयोगकर्ताओं के अलग-अलग ग्रुप को डाइनैमिक तौर पर अलग-अलग मॉडल दिखाए जा सकते हैं.

TensorFlow Lite मॉडल

TensorFlow Lite मॉडल, एमएल मॉडल होते हैं. इन्हें मोबाइल डिवाइसों पर चलाने के लिए ऑप्टिमाइज़ किया जाता है. TensorFlow Lite मॉडल पाने के लिए:

• पहले से बने मॉडल का इस्तेमाल करें. जैसे, TensorFlow Lite के आधिकारिक मॉडल में से किसी एक का इस्तेमाल करें.
• TensorFlow मॉडल, Keras मॉडल या कॉन्क्रीट फ़ंक्शन को TensorFlow Lite में बदलें.

शुरू करने से पहले

1. अगर आपने पहले से ऐसा नहीं किया है, तो अपने Android प्रोजेक्ट में Firebase जोड़ें.
2. अपनी मॉड्यूल (ऐप्लिकेशन-लेवल) की Gradle फ़ाइल में, Android के लिए Firebase ML मॉडल डाउनलोडर लाइब्रेरी की डिपेंडेंसी जोड़ें. यह फ़ाइल आम तौर पर <project>/<app-module>/build.gradle.kts या <project>/<app-module>/build.gradle होती है. हमारा सुझाव है कि लाइब्रेरी के वर्शन को कंट्रोल करने के लिए, Firebase Android BoM का इस्तेमाल करें.

   साथ ही, Firebase ML मॉडल डाउनलोडर को सेट अप करने के लिए, आपको अपने ऐप्लिकेशन में TensorFlow Lite SDK टूल जोड़ना होगा.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:34.0.0"))
   
       // Add the dependency for the Firebase ML model downloader library
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-ml-modeldownloader")
   
       // Also add the dependency for the TensorFlow Lite library and specify its version
       implementation("org.tensorflow:tensorflow-lite:2.3.0")
   }

   Firebase Android BoM का इस्तेमाल करने पर, आपका ऐप्लिकेशन हमेशा Firebase Android लाइब्रेरी के साथ काम करने वाले वर्शन का इस्तेमाल करेगा.

   (वैकल्पिक)  BoM का इस्तेमाल किए बिना, Firebase लाइब्रेरी की डिपेंडेंसी जोड़ें

   अगर आपको Firebase BoM का इस्तेमाल नहीं करना है, तो आपको डिपेंडेंसी लाइन में Firebase की हर लाइब्रेरी के वर्शन की जानकारी देनी होगी.

   ध्यान दें कि अगर आपके ऐप्लिकेशन में Firebase की एक से ज़्यादा लाइब्रेरी का इस्तेमाल किया जाता है, तो हमारा सुझाव है कि लाइब्रेरी के वर्शन मैनेज करने के लिए BoM का इस्तेमाल करें. इससे यह पक्का किया जा सकता है कि सभी वर्शन एक-दूसरे के साथ काम करते हों.

   dependencies {
       // Add the dependency for the Firebase ML model downloader library
       // When NOT using the BoM, you must specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-ml-modeldownloader:26.0.0")
   
       // Also add the dependency for the TensorFlow Lite library and specify its version
       implementation("org.tensorflow:tensorflow-lite:2.3.0")
   }

3. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में यह एलान करें कि INTERNET की अनुमति ज़रूरी है:

   <uses-permission android:name="android.permission.INTERNET" />

1. मॉडल डिप्लॉय करना

Firebase कंसोल या Firebase Admin Python और Node.js SDK टूल का इस्तेमाल करके, अपने कस्टम TensorFlow मॉडल डिप्लॉय करें. कस्टम मॉडल डिप्लॉय और मैनेज करना लेख पढ़ें.

अपने Firebase प्रोजेक्ट में कस्टम मॉडल जोड़ने के बाद, अपने ऐप्लिकेशन में मॉडल का रेफ़रंस दिया जा सकता है. इसके लिए, आपको वही नाम इस्तेमाल करना होगा जो आपने मॉडल को दिया था. किसी भी समय, नया TensorFlow Lite मॉडल डिप्लॉय किया जा सकता है. साथ ही, getModel() को कॉल करके, उपयोगकर्ताओं के डिवाइसों पर नया मॉडल डाउनलोड किया जा सकता है. इसके बारे में यहां बताया गया है.

2. मॉडल को डिवाइस पर डाउनलोड करें और TensorFlow Lite इंटरप्रेटर को शुरू करें

मॉडल डाउनलोड करने के लिए, मॉडल डाउनलोडर के getModel() तरीके को कॉल करें. इसमें, मॉडल को अपलोड करते समय दिया गया नाम, यह जानकारी कि आपको हमेशा नया मॉडल डाउनलोड करना है या नहीं, और वे शर्तें बताएं जिनके तहत आपको डाउनलोड करने की अनुमति देनी है.

डाउनलोड करने के तीन तरीके उपलब्ध हैं:

आपको मॉडल से जुड़ी सुविधा बंद कर देनी चाहिए. उदाहरण के लिए, जब तक मॉडल डाउनलोड होने की पुष्टि नहीं हो जाती, तब तक अपने यूज़र इंटरफ़ेस (यूआई) के कुछ हिस्से को धूसर कर दें या छिपा दें.

val conditions = CustomModelDownloadConditions.Builder()
        .requireWifi()  // Also possible: .requireCharging() and .requireDeviceIdle()
        .build()
FirebaseModelDownloader.getInstance()
        .getModel("your_model", DownloadType.LOCAL_MODEL_UPDATE_IN_BACKGROUND,
            conditions)
        .addOnSuccessListener { model: CustomModel? ->
            // Download complete. Depending on your app, you could enable the ML
            // feature, or switch from the local model to the remote model, etc.

            // The CustomModel object contains the local path of the model file,
            // which you can use to instantiate a TensorFlow Lite interpreter.
            val modelFile = model?.file
            if (modelFile != null) {
                interpreter = Interpreter(modelFile)
            }
        }

CustomModelDownloadConditions conditions = new CustomModelDownloadConditions.Builder()
    .requireWifi()  // Also possible: .requireCharging() and .requireDeviceIdle()
    .build();
FirebaseModelDownloader.getInstance()
    .getModel("your_model", DownloadType.LOCAL_MODEL_UPDATE_IN_BACKGROUND, conditions)
    .addOnSuccessListener(new OnSuccessListener<CustomModel>() {
      @Override
      public void onSuccess(CustomModel model) {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.

        // The CustomModel object contains the local path of the model file,
        // which you can use to instantiate a TensorFlow Lite interpreter.
        File modelFile = model.getFile();
        if (modelFile != null) {
            interpreter = new Interpreter(modelFile);
        }
      }
    });

कई ऐप्लिकेशन, डाउनलोड करने का टास्क अपने इनिशियलाइज़ेशन कोड में शुरू करते हैं. हालांकि, मॉडल का इस्तेमाल करने से पहले, इसे किसी भी समय शुरू किया जा सकता है.

3. इनपुट डेटा के आधार पर अनुमान लगाना

अपने मॉडल के इनपुट और आउटपुट शेप पाना

TensorFlow Lite मॉडल इंटरप्रेटर, इनपुट के तौर पर एक या उससे ज़्यादा मल्टीडाइमेंशनल ऐरे लेता है और आउटपुट के तौर पर भी एक या उससे ज़्यादा मल्टीडाइमेंशनल ऐरे देता है. इन ऐरे में byte, int, long या float वैल्यू होती हैं. किसी मॉडल को डेटा पास करने या उसके नतीजे का इस्तेमाल करने से पहले, आपको यह पता होना चाहिए कि आपका मॉडल कितनी और किस डाइमेंशन ("शेप") की ऐरे का इस्तेमाल करता है.

अगर आपने मॉडल खुद बनाया है या मॉडल के इनपुट और आउटपुट फ़ॉर्मैट के बारे में जानकारी दी गई है, तो हो सकता है कि आपके पास यह जानकारी पहले से मौजूद हो. अगर आपको अपने मॉडल के इनपुट और आउटपुट के शेप और डेटा टाइप के बारे में नहीं पता है, तो अपने मॉडल की जांच करने के लिए, TensorFlow Lite इंटरप्रेटर का इस्तेमाल करें. उदाहरण के लिए:

import tensorflow as tf

interpreter = tf.lite.Interpreter(model_path="your_model.tflite")
interpreter.allocate_tensors()

# Print input shape and type
inputs = interpreter.get_input_details()
print('{} input(s):'.format(len(inputs)))
for i in range(0, len(inputs)):
    print('{} {}'.format(inputs[i]['shape'], inputs[i]['dtype']))

# Print output shape and type
outputs = interpreter.get_output_details()
print('\n{} output(s):'.format(len(outputs)))
for i in range(0, len(outputs)):
    print('{} {}'.format(outputs[i]['shape'], outputs[i]['dtype']))

1 input(s):
[  1 224 224   3] <class 'numpy.float32'>

1 output(s):
[1 1000] <class 'numpy.float32'>

अनुवादक मोड चालू करना

उदाहरण के लिए, अगर आपके पास इमेज क्लासिफ़िकेशन मॉडल है और उसका इनपुट शेप [1 224 224 3] फ़्लोटिंग-पॉइंट वैल्यू है, तो Bitmap ऑब्जेक्ट से इनपुट ByteBuffer जनरेट किया जा सकता है. इसका उदाहरण यहां दिया गया है:

val bitmap = Bitmap.createScaledBitmap(yourInputImage, 224, 224, true)
val input = ByteBuffer.allocateDirect(224*224*3*4).order(ByteOrder.nativeOrder())
for (y in 0 until 224) {
    for (x in 0 until 224) {
        val px = bitmap.getPixel(x, y)

        // Get channel values from the pixel value.
        val r = Color.red(px)
        val g = Color.green(px)
        val b = Color.blue(px)

        // Normalize channel values to [-1.0, 1.0]. This requirement depends on the model.
        // For example, some models might require values to be normalized to the range
        // [0.0, 1.0] instead.
        val rf = (r - 127) / 255f
        val gf = (g - 127) / 255f
        val bf = (b - 127) / 255f

        input.putFloat(rf)
        input.putFloat(gf)
        input.putFloat(bf)
    }
}

Bitmap bitmap = Bitmap.createScaledBitmap(yourInputImage, 224, 224, true);
ByteBuffer input = ByteBuffer.allocateDirect(224 * 224 * 3 * 4).order(ByteOrder.nativeOrder());
for (int y = 0; y < 224; y++) {
    for (int x = 0; x < 224; x++) {
        int px = bitmap.getPixel(x, y);

        // Get channel values from the pixel value.
        int r = Color.red(px);
        int g = Color.green(px);
        int b = Color.blue(px);

        // Normalize channel values to [-1.0, 1.0]. This requirement depends
        // on the model. For example, some models might require values to be
        // normalized to the range [0.0, 1.0] instead.
        float rf = (r - 127) / 255.0f;
        float gf = (g - 127) / 255.0f;
        float bf = (b - 127) / 255.0f;

        input.putFloat(rf);
        input.putFloat(gf);
        input.putFloat(bf);
    }
}

इसके बाद, मॉडल के आउटपुट को शामिल करने के लिए, ByteBuffer को काफ़ी जगह दें. साथ ही, इनपुट बफ़र और आउटपुट बफ़र को TensorFlow Lite इंटरप्रेटर के run() तरीके पर पास करें. उदाहरण के लिए, [1 1000] फ़्लोटिंग-पॉइंट वैल्यू के आउटपुट शेप के लिए:

val bufferSize = 1000 * java.lang.Float.SIZE / java.lang.Byte.SIZE
val modelOutput = ByteBuffer.allocateDirect(bufferSize).order(ByteOrder.nativeOrder())
interpreter?.run(input, modelOutput)

int bufferSize = 1000 * java.lang.Float.SIZE / java.lang.Byte.SIZE;
ByteBuffer modelOutput = ByteBuffer.allocateDirect(bufferSize).order(ByteOrder.nativeOrder());
interpreter.run(input, modelOutput);

आउटपुट का इस्तेमाल कैसे किया जाए, यह इस बात पर निर्भर करता है कि आपने कौनसा मॉडल इस्तेमाल किया है.

उदाहरण के लिए, अगर आपको क्लासिफ़िकेशन करना है, तो अगले चरण के तौर पर, आपको नतीजे के इंडेक्स को उन लेबल पर मैप करना होगा जो उन्हें दिखाते हैं:

modelOutput.rewind()
val probabilities = modelOutput.asFloatBuffer()
try {
    val reader = BufferedReader(
            InputStreamReader(assets.open("custom_labels.txt")))
    for (i in probabilities.capacity()) {
        val label: String = reader.readLine()
        val probability = probabilities.get(i)
        println("$label: $probability")
    }
} catch (e: IOException) {
    // File not found?
}

modelOutput.rewind();
FloatBuffer probabilities = modelOutput.asFloatBuffer();
try {
    BufferedReader reader = new BufferedReader(
            new InputStreamReader(getAssets().open("custom_labels.txt")));
    for (int i = 0; i < probabilities.capacity(); i++) {
        String label = reader.readLine();
        float probability = probabilities.get(i);
        Log.i(TAG, String.format("%s: %1.4f", label, probability));
    }
} catch (IOException e) {
    // File not found?
}

अपेंडिक्स: मॉडल की सुरक्षा

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

सैद्धांतिक तौर पर, इसका मतलब है कि कोई भी आपके मॉडल को कॉपी कर सकता है. हालांकि, व्यवहार में ज़्यादातर मॉडल, ऐप्लिकेशन के हिसाब से बनाए जाते हैं और ऑप्टिमाइज़ेशन की वजह से उन्हें समझना मुश्किल होता है. इसलिए, जोखिम उतना ही होता है जितना कि प्रतिस्पर्धियों के आपके कोड को अलग-अलग हिस्सों में बांटकर फिर से इस्तेमाल करने से होता है. हालांकि, आपको अपने ऐप्लिकेशन में कस्टम मॉडल का इस्तेमाल करने से पहले, इस जोखिम के बारे में पता होना चाहिए.

Android API लेवल 21 (Lollipop) और इसके बाद के वर्शन पर, मॉडल को ऐसी डायरेक्ट्री में डाउनलोड किया जाता है जिसे अपने-आप होने वाले बैकअप से बाहर रखा जाता है.

Android के एपीआई लेवल 20 और इससे पुराने वर्शन पर, मॉडल को com.google.firebase.ml.custom.models नाम की डायरेक्ट्री में डाउनलोड किया जाता है. यह डायरेक्ट्री, ऐप्लिकेशन के प्राइवेट इंटरनल स्टोरेज में होती है. अगर आपने BackupAgent का इस्तेमाल करके फ़ाइल बैकअप लेने की सुविधा चालू की है, तो आपके पास इस डायरेक्ट्री को शामिल न करने का विकल्प होता है.