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

मशीन लर्निंग का इस्तेमाल करने के लिए, TensorFlow Lite मॉडल.

इस एपीआई का इस्तेमाल करने के लिए, Android SDK के लेवल 16 (जैली बीन) या उसके बाद के वर्शन की ज़रूरत होती है.

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

  1. अगर आपने अब तक ऐसा नहीं किया है, तो अपने Android प्रोजेक्ट में Firebase जोड़ें.
  2. अपने मॉड्यूल में एमएल किट Android लाइब्रेरी के लिए डिपेंडेंसी जोड़ें (ऐप्लिकेशन-लेवल) Gradle फ़ाइल (आम तौर पर app/build.gradle): 
    apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

dependencies {
  // ...

  implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.3'
}
  3. आपको जिस TensorFlow मॉडल का इस्तेमाल करना है उसे TensorFlow Lite फ़ॉर्मैट में बदलें. यहां जाएं: TOCO: TensorFlow Lite का ऑप्टिमाइज़ेशन कन्वर्टर.

अपने मॉडल को होस्ट या बंडल करें

ऐप्लिकेशन में अनुमान लगाने के लिए, TensorFlow Lite मॉडल का इस्तेमाल करने से पहले, आपको एमएल किट को मॉडल उपलब्ध कराना होगा. एमएल किट, TensorFlow Lite का इस्तेमाल कर सकती है Firebase का इस्तेमाल करके, रिमोट तरीके से होस्ट किए गए मॉडल और ऐप्लिकेशन बाइनरी या दोनों के साथ बंडल किए जाते हैं.

Firebase पर मॉडल होस्ट करके, मॉडल को अपडेट किया जा सकता है. हालांकि, इसके लिए कोई हैं और आप रिमोट कॉन्फ़िगरेशन और A/B टेस्टिंग का उपयोग उपयोगकर्ताओं के अलग-अलग सेट को डाइनैमिक तौर पर अलग-अलग मॉडल दिखाते हैं.

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

मॉडल को अपने ऐप्लिकेशन के साथ बंडल करके, अपने ऐप्लिकेशन की एमएल (मशीन लर्निंग) सुविधाओं को पक्का किया जा सकता है Firebase से होस्ट किया गया मॉडल उपलब्ध न होने पर भी काम करता है.

Firebase पर मॉडल होस्ट करें

Firebase पर अपना TensorFlow Lite मॉडल होस्ट करने के लिए:

  1. Firebase कंसोल के एमएल किट सेक्शन में जाकर, कस्टम टैब पर क्लिक करें.
  2. कस्टम मॉडल जोड़ें पर क्लिक करें (या कोई दूसरा मॉडल जोड़ें) पर क्लिक करें.
  3. कोई नाम तय करें, जिसका इस्तेमाल आपके Firebase में आपके मॉडल की पहचान करने के लिए किया जाएगा प्रोजेक्ट करें, फिर TensorFlow Lite मॉडल फ़ाइल (आम तौर पर इसके अंत में खत्म होने वाली .tflite या .lite).
  4. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, यह बताएं कि इंटरनेट की अनुमति ज़रूरी है: 
    <uses-permission android:name="android.permission.INTERNET" />

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

ऐप्लिकेशन के साथ बंडल मॉडल

अपने TensorFlow Lite मॉडल को अपने ऐप्लिकेशन के साथ बंडल करने के लिए, मॉडल फ़ाइल को कॉपी करें (आम तौर पर आपके ऐप्लिकेशन के assets/ फ़ोल्डर में .tflite या .lite) से खत्म होने वाला होता है. (आपको इनकी ज़रूरत पड़ सकती है पहले app/ फ़ोल्डर पर राइट-क्लिक करके, फिर क्लिक करके फ़ोल्डर बनाने के लिए नया > फ़ोल्डर > ऐसेट फ़ोल्डर.)

इसके बाद, Gradle को पक्का करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में इन्हें जोड़ें ऐप्लिकेशन बनाते समय मॉडल को कंप्रेस नहीं करता है:

android {

    // ...

    aaptOptions {
        noCompress "tflite"  // Your model's file extension: "tflite", "lite", etc.
    }
}

मॉडल फ़ाइल, ऐप्लिकेशन के पैकेज में शामिल की जाएगी और ML किट में उपलब्ध होगी रॉ ऐसेट के तौर पर काम करता है.

मॉडल लोड करें

अपने ऐप्लिकेशन में TensorFlow Lite मॉडल का इस्तेमाल करने के लिए, पहले ML Kit को उन स्थानों पर जहां आपका मॉडल उपलब्ध है: Firebase का उपयोग करके, में या दोनों का इस्तेमाल कर सकते हैं. अगर लोकल और रिमोट मॉडल, दोनों को तय किया जाता है, तो उपलब्ध होने पर, रिमोट मॉडल का इस्तेमाल किया जा सकता है. साथ ही, रिमोट मॉडल उपलब्ध न होने पर, डिवाइस पर सेव किया गया मॉडल.

Firebase के होस्ट किए गए मॉडल को कॉन्फ़िगर करना

अगर आपने मॉडल को Firebase की मदद से होस्ट किया है, तो FirebaseCustomRemoteModel बनाएं ऑब्जेक्ट है, जो उस नाम को दर्ज करता है जिसे आपने मॉडल को अपलोड करते समय असाइन किया था:

Java 

FirebaseCustomRemoteModel remoteModel =
        new FirebaseCustomRemoteModel.Builder("your_model").build();

Kotlin+KTX 

val remoteModel = FirebaseCustomRemoteModel.Builder("your_model").build()

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

Java 

FirebaseModelDownloadConditions conditions = new FirebaseModelDownloadConditions.Builder()
        .requireWifi()
        .build();
FirebaseModelManager.getInstance().download(remoteModel, conditions)
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                // Success.
            }
        });

Kotlin+KTX 

val conditions = FirebaseModelDownloadConditions.Builder()
    .requireWifi()
    .build()
FirebaseModelManager.getInstance().download(remoteModel, conditions)
    .addOnCompleteListener {
        // Success.
    }

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

लोकल मॉडल कॉन्फ़िगर करना

अगर आपने मॉडल को अपने ऐप्लिकेशन के साथ बंडल किया है, तो FirebaseCustomLocalModel बनाएं ऑब्जेक्ट है, जो TensorFlow Lite मॉडल का फ़ाइल नाम बताते हैं:

Java 

FirebaseCustomLocalModel localModel = new FirebaseCustomLocalModel.Builder()
        .setAssetFilePath("your_model.tflite")
        .build();

Kotlin+KTX 

val localModel = FirebaseCustomLocalModel.Builder()
    .setAssetFilePath("your_model.tflite")
    .build()

अपने मॉडल की मदद से अनुवादक बनाएं

अपने मॉडल सोर्स को कॉन्फ़िगर करने के बाद, FirebaseModelInterpreter बनाएं ऑब्जेक्ट को ढूंढने में मदद मिलती है.

अगर आपके पास सिर्फ़ लोकल-बंडल किया गया मॉडल है, तो अपने FirebaseCustomLocalModel ऑब्जेक्ट:

Java 

FirebaseModelInterpreter interpreter;
try {
    FirebaseModelInterpreterOptions options =
            new FirebaseModelInterpreterOptions.Builder(localModel).build();
    interpreter = FirebaseModelInterpreter.getInstance(options);
} catch (FirebaseMLException e) {
    // ...
}

Kotlin+KTX 

val options = FirebaseModelInterpreterOptions.Builder(localModel).build()
val interpreter = FirebaseModelInterpreter.getInstance(options)

अगर आपके पास रिमोट तौर पर होस्ट किया गया मॉडल है, तो आपको यह देखना होगा कि डाउनलोड करने की सुविधा देता है. मॉडल के डाउनलोड होने की स्थिति देखी जा सकती है टास्क बनाने के लिए, मॉडल मैनेजर के isModelDownloaded() तरीके का इस्तेमाल करें.

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

Java 

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
        .addOnSuccessListener(new OnSuccessListener<Boolean>() {
            @Override
            public void onSuccess(Boolean isDownloaded) {
                FirebaseModelInterpreterOptions options;
                if (isDownloaded) {
                    options = new FirebaseModelInterpreterOptions.Builder(remoteModel).build();
                } else {
                    options = new FirebaseModelInterpreterOptions.Builder(localModel).build();
                }
                FirebaseModelInterpreter interpreter = FirebaseModelInterpreter.getInstance(options);
                // ...
            }
        });

Kotlin+KTX 

FirebaseModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded -> 
    val options =
        if (isDownloaded) {
            FirebaseModelInterpreterOptions.Builder(remoteModel).build()
        } else {
            FirebaseModelInterpreterOptions.Builder(localModel).build()
        }
    val interpreter = FirebaseModelInterpreter.getInstance(options)
}

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

Java 

FirebaseModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

Kotlin+KTX 

FirebaseModelManager.getInstance().download(remoteModel, conditions)
    .addOnCompleteListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

मॉडल के इनपुट और आउटपुट की जानकारी दें

इसके बाद, मॉडल अनुवादक के इनपुट और आउटपुट फ़ॉर्मैट को कॉन्फ़िगर करें.

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

अगर आपको अपने मॉडल के इनपुट और आउटपुट का आकार और डेटा टाइप नहीं पता है, तो अपने मॉडल की जांच करने के लिए, TensorFlow Lite Python इंटरप्रेटर का इस्तेमाल करें. इसके लिए उदाहरण:

import tensorflow as tf

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

# Print input shape and type
print(interpreter.get_input_details()[0]['shape'])  # Example: [1 224 224 3]
print(interpreter.get_input_details()[0]['dtype'])  # Example: <class 'numpy.float32'>

# Print output shape and type
print(interpreter.get_output_details()[0]['shape'])  # Example: [1 1000]
print(interpreter.get_output_details()[0]['dtype'])  # Example: <class 'numpy.float32'>

अपने मॉडल के इनपुट और आउटपुट का फ़ॉर्मैट तय करने के बाद, अपने ऐप्लिकेशन के मॉडल अनुवादक को कॉन्फ़िगर करने के लिए FirebaseModelInputOutputOptions ऑब्जेक्ट.

उदाहरण के लिए, फ़्लोटिंग-पॉइंट इमेज क्लासिफ़िकेशन मॉडल float वैल्यू का Nx224x224x3 अरे, जो N 224x224 तीन चैनल वाली (आरजीबी) इमेज और आउटपुट के तौर पर, 1,000 float वैल्यू. हर वैल्यू, इस बात की संभावना बताती है कि इमेज में शामिल है या नहीं यह मॉडल, 1,000 कैटगरी का अनुमान लगाता है.

ऐसे मॉडल के लिए, आपको मॉडल इंटरप्रेटर के इनपुट और आउटपुट को कॉन्फ़िगर करना होगा जैसा कि नीचे दिखाया गया है:

Java 

FirebaseModelInputOutputOptions inputOutputOptions =
        new FirebaseModelInputOutputOptions.Builder()
                .setInputFormat(0, FirebaseModelDataType.FLOAT32, new int[]{1, 224, 224, 3})
                .setOutputFormat(0, FirebaseModelDataType.FLOAT32, new int[]{1, 5})
                .build();

Kotlin+KTX 

val inputOutputOptions = FirebaseModelInputOutputOptions.Builder()
        .setInputFormat(0, FirebaseModelDataType.FLOAT32, intArrayOf(1, 224, 224, 3))
        .setOutputFormat(0, FirebaseModelDataType.FLOAT32, intArrayOf(1, 5))
        .build()

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

आखिर में, मॉडल का इस्तेमाल करके अनुमान लगाने के लिए, इनपुट डेटा हासिल करें और डेटा में होने वाला कोई भी ट्रांसफ़ॉर्मेशन ऐक्शन, जिसकी ज़रूरत होती है आपके मॉडल के लिए सही आकार होता है.

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

Java 

Bitmap bitmap = getYourInputImage();
bitmap = Bitmap.createScaledBitmap(bitmap, 224, 224, true);

int batchNum = 0;
float[][][][] input = new float[1][224][224][3];
for (int x = 0; x < 224; x++) {
    for (int y = 0; y < 224; y++) {
        int pixel = bitmap.getPixel(x, y);
        // Normalize channel values to [-1.0, 1.0]. This requirement varies by
        // model. For example, some models might require values to be normalized
        // to the range [0.0, 1.0] instead.
        input[batchNum][x][y][0] = (Color.red(pixel) - 127) / 128.0f;
        input[batchNum][x][y][1] = (Color.green(pixel) - 127) / 128.0f;
        input[batchNum][x][y][2] = (Color.blue(pixel) - 127) / 128.0f;
    }
}

Kotlin+KTX 

val bitmap = Bitmap.createScaledBitmap(yourInputImage, 224, 224, true)

val batchNum = 0
val input = Array(1) { Array(224) { Array(224) { FloatArray(3) } } }
for (x in 0..223) {
    for (y in 0..223) {
        val pixel = bitmap.getPixel(x, y)
        // Normalize channel values to [-1.0, 1.0]. This requirement varies by
        // model. For example, some models might require values to be normalized
        // to the range [0.0, 1.0] instead.
        input[batchNum][x][y][0] = (Color.red(pixel) - 127) / 255.0f
        input[batchNum][x][y][1] = (Color.green(pixel) - 127) / 255.0f
        input[batchNum][x][y][2] = (Color.blue(pixel) - 127) / 255.0f
    }
}

इसके बाद, अपनेFirebaseModelInputs और उसे मॉडल के इनपुट और आउटपुट स्पेसिफ़िकेशन को मॉडल अनुवादक की run विधि:

Java 

FirebaseModelInputs inputs = new FirebaseModelInputs.Builder()
        .add(input)  // add() as many input arrays as your model requires
        .build();
firebaseInterpreter.run(inputs, inputOutputOptions)
        .addOnSuccessListener(
                new OnSuccessListener<FirebaseModelOutputs>() {
                    @Override
                    public void onSuccess(FirebaseModelOutputs result) {
                        // ...
                    }
                })
        .addOnFailureListener(
                new OnFailureListener() {
                    @Override
                    public void onFailure(@NonNull Exception e) {
                        // Task failed with an exception
                        // ...
                    }
                });

Kotlin+KTX 

val inputs = FirebaseModelInputs.Builder()
        .add(input) // add() as many input arrays as your model requires
        .build()
firebaseInterpreter.run(inputs, inputOutputOptions)
        .addOnSuccessListener { result ->
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }

अगर कॉल पूरा होता है, तो getOutput() तरीके को कॉल करके आउटपुट मिल सकता है एक ऑब्जेक्ट होता है जिसे सक्सेस लिसनर को दिया जाता है. उदाहरण के लिए:

Java 

float[][] output = result.getOutput(0);
float[] probabilities = output[0];

Kotlin+KTX 

val output = result.getOutput<Array<FloatArray>>(0)
val probabilities = output[0]

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

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

Java 

BufferedReader reader = new BufferedReader(
        new InputStreamReader(getAssets().open("retrained_labels.txt")));
for (int i = 0; i < probabilities.length; i++) {
    String label = reader.readLine();
    Log.i("MLKit", String.format("%s: %1.4f", label, probabilities[i]));
}

Kotlin+KTX 

val reader = BufferedReader(
        InputStreamReader(assets.open("retrained_labels.txt")))
for (i in probabilities.indices) {
    val label = reader.readLine()
    Log.i("MLKit", String.format("%s: %1.4f", label, probabilities[i]))
}

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

भले ही, आप TensorFlow Lite के मॉडल ML Kit, ML Kit, उन्हें मानक क्रमिक प्रोटोबफ़ फ़ॉर्मैट में इसमें सेव करता है: लोकल स्टोरेज.

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

Android के एपीआई लेवल 21 (Lollipop) और इसके बाद के वर्शन पर, मॉडल को डायरेक्ट्री, जो अपने-आप बैकअप लेने की सुविधा से बाहर रखा गया है.

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