Google 致力于为黑人社区推动种族平等。查看具体举措
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

Android पर एमएल किट के साथ इंजेक्शन के लिए एक TensorFlow Lite मॉडल का उपयोग करें

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

इस API के लिए Android SDK स्तर 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 किट में उपलब्ध कराना होगा। ML किट TensorFlow Lite मॉडल को फायरबेस के उपयोग से दूरस्थ रूप से होस्ट कर सकते हैं, ऐप बाइनरी या दोनों के साथ बंडल किया जा सकता है।

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

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

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

फायरबेस पर होस्ट मॉडल

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

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

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

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

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

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

android {

    // ...

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

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

मॉडल लोड करें

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

फायरबेस-होस्टेड मॉडल को कॉन्फ़िगर करें

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

जावा

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

Kotlin + KTX

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

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

जावा

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 मॉडल के फ़ाइल नाम को निर्दिष्ट करता है:

जावा

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

Kotlin + KTX

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

अपने मॉडल से एक दुभाषिया बनाएं

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

यदि आपके पास केवल स्थानीय रूप से बंडल मॉडल है, तो अपने FirebaseCustomLocalModel ऑब्जेक्ट से एक दुभाषिया बनाएं:

जावा

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() पद्धति का उपयोग करके मॉडल डाउनलोड कार्य की स्थिति की जांच कर सकते हैं।

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

जावा

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() विधि के लिए एक श्रोता को संलग्न करके ऐसा कर सकते हैं:

जावा

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 आउटपुट के रूप में (RGB) छवियों, 224x224 तीन चैनल और उत्पादन 1000 की एक सूची float मूल्यों, प्रत्येक का प्रतिनिधित्व संभावना यह है कि चित्र उन 1000 श्रेणियों में से एक है जो मॉडल की भविष्यवाणी करता है।

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

जावा

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 ऑब्जेक्ट से इनपुट सरणी उत्पन्न कर सकते हैं जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

जावा

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 विधि के लिए मॉडल के इनपुट और आउटपुट स्पेसिफिकेशन:

जावा

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() विधि को कॉल करके प्राप्त कर सकते हैं जो कि सफलता श्रोता के पास है। उदाहरण के लिए:

जावा

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

Kotlin + KTX

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

आप आउटपुट का उपयोग कैसे करते हैं यह उस मॉडल पर निर्भर करता है जिसका आप उपयोग कर रहे हैं।

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

जावा

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

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

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

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