Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

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

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

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

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

  1. आप पहले से ही नहीं है, तो अपने Android परियोजना के लिए Firebase जोड़ने
  2. एमएल किट एंड्रॉयड पुस्तकालयों के लिए निर्भरता अपने मॉड्यूल (एप्लिकेशन-स्तरीय) 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 प्रारूप में। देखें TensorFlow लाइट अनुकूलन कनवर्टर: Toco

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

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

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

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

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

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

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

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

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

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

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

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

android {

    // ...

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

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

मॉडल लोड करें

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

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

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

जावा

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

कोटलिन + केटीएक्स

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

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

जावा

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

कोटलिन + केटीएक्स

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

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

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

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

जावा

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

कोटलिन + केटीएक्स

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) {
    // ...
}

कोटलिन + केटीएक्स

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);
                // ...
            }
        });

कोटलिन + केटीएक्स

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

कोटलिन + केटीएक्स

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 लाइट मॉडल इनपुट के रूप में लेता है और आउटपुट के रूप में एक या अधिक बहुआयामी सरणियों का उत्पादन करता है। इन सरणियों या तो शामिल 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();

कोटलिन + केटीएक्स

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

कोटलिन + केटीएक्स

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 अपने इनपुट डेटा के साथ वस्तु, और इसे पारित और मॉडल के लिए इनपुट और आउटपुट विनिर्देश मॉडल दुभाषिया s ' 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
                        // ...
                    }
                });

कोटलिन + केटीएक्स

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];

कोटलिन + केटीएक्स

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

कोटलिन + केटीएक्स

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 किट उन्हें स्थानीय स्टोरेज में मानक क्रमबद्ध प्रोटोबफ प्रारूप में संग्रहीत करता है।

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

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

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