Catch up on highlights from Firebase at Google I/O 2023. Learn more

Android पर ML किट के अनुमान के लिए TensorFlow Lite मॉडल का उपयोग करें

आप TensorFlow Lite मॉडल के साथ ऑन-डिवाइस अनुमान लगाने के लिए एमएल किट का उपयोग कर सकते हैं।

इस एपीआई के लिए एंड्रॉइड एसडीके स्तर 16 (जेली बीन) या नए की आवश्यकता है।

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

  1. यदि आपने पहले से नहीं किया है, तो अपने Android प्रोजेक्ट में Firebase जोड़ें ।
  2. अपने मॉड्यूल (ऐप-लेवल) ग्रैडल फ़ाइल (आमतौर पर 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 मॉडल का उपयोग कर सकें, आपको मॉडल को ML Kit को उपलब्ध कराना होगा। एमएल किट ऐप बाइनरी या दोनों के साथ बंडल किए गए फायरबेस का उपयोग करके दूरस्थ रूप से होस्ट किए गए TensorFlow Lite मॉडल का उपयोग कर सकता है।

फायरबेस पर एक मॉडल को होस्ट करके, आप एक नया ऐप संस्करण जारी किए बिना मॉडल को अपडेट कर सकते हैं, और आप उपयोगकर्ताओं के विभिन्न सेटों को विभिन्न मॉडलों को गतिशील रूप से सेवा देने के लिए रिमोट कॉन्फिग और ए / बी परीक्षण का उपयोग कर सकते हैं।

यदि आप मॉडल को केवल Firebase के साथ होस्ट करके प्रदान करना चुनते हैं, और इसे अपने ऐप के साथ बंडल नहीं करते हैं, तो आप अपने ऐप के प्रारंभिक डाउनलोड आकार को कम कर सकते हैं। हालांकि, ध्यान रखें कि यदि मॉडल को आपके ऐप के साथ बंडल नहीं किया गया है, तो मॉडल से संबंधित कोई भी कार्यक्षमता तब तक उपलब्ध नहीं होगी जब तक कि आपका ऐप पहली बार मॉडल को डाउनलोड नहीं कर लेता।

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

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

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

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

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

एक ऐप के साथ बंडल मॉडल

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

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

android {

    // ...

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

मॉडल फ़ाइल को ऐप पैकेज में शामिल किया जाएगा और एमएल किट के लिए रॉ एसेट के रूप में उपलब्ध होगा।

मॉडल लोड करें

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

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.
    }

कई ऐप्स अपने प्रारंभिक कोड में डाउनलोड कार्य प्रारंभ करते हैं, लेकिन आप मॉडल का उपयोग करने से पहले किसी भी समय ऐसा कर सकते हैं।

एक स्थानीय मॉडल कॉन्फ़िगर करें

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

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)
}

यदि आपके पास केवल दूरस्थ रूप से होस्ट किया गया मॉडल है, तो आपको मॉडल से संबंधित कार्यात्मकता को अक्षम कर देना चाहिए—उदाहरण के लिए, ग्रे-आउट करना या अपने UI के भाग को छिपाना—जब तक कि आप यह पुष्टि नहीं कर लेते कि मॉडल डाउनलोड हो गया है। आप एक श्रोता को मॉडल प्रबंधक के 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 ऑब्जेक्ट बनाकर अपने ऐप के मॉडल दुभाषिया को कॉन्फ़िगर कर सकते हैं।

उदाहरण के लिए, एक फ़्लोटिंग-पॉइंट छवि वर्गीकरण मॉडल इनपुट के रूप में N x224x224x3 float मानों की सरणी ले सकता है, जो N 224x224 तीन-चैनल (RGB) छवियों के एक बैच का प्रतिनिधित्व करता है, और आउटपुट के रूप में 1000 float मानों की एक सूची प्रस्तुत करता है, प्रत्येक प्रतिनिधित्व करता है संभावना है कि छवि मॉडल द्वारा भविष्यवाणी की गई 1000 श्रेणियों में से एक का सदस्य है।

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

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 मॉडल को एमएल किट के लिए कैसे उपलब्ध कराते हैं, एमएल किट उन्हें स्थानीय भंडारण में मानक क्रमबद्ध प्रोटोबॉफ़ प्रारूप में संग्रहीत करता है।

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

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

Android API स्तर 20 और पुराने पर, मॉडल को ऐप-निजी आंतरिक संग्रहण में com.google.firebase.ml.custom.models नामक निर्देशिका में डाउनलोड किया जाता है। यदि आपने BackupAgent का उपयोग करके फ़ाइल बैकअप सक्षम किया है, तो आप इस निर्देशिका को बाहर करना चुन सकते हैं।