Google is committed to advancing racial equity for Black communities. See how.
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

Android पर एक कस्टम TensorFlow Lite मॉडल का उपयोग करें

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

TensorFlow Lite मॉडल

TensorFlow Lite मॉडल एमएल मॉडल हैं जो मोबाइल उपकरणों पर चलने के लिए अनुकूलित हैं। TensorFlow Lite मॉडल पाने के लिए:

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

  1. यदि आप पहले से नहीं हैं, तो अपने Android प्रोजेक्ट में Firebase जोड़ें
  2. Firebase Android BoM का उपयोग करते हुए, अपने मॉड्यूल (ऐप-स्तरीय) ग्रेड फ़ाइल (आमतौर पर app/build.gradle ) में Firebase ML कस्टम मॉडल Android लाइब्रेरी के लिए निर्भरता की घोषणा करें।

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

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:26.6.0')
    
        // Declare the dependency for the Firebase ML Custom Models library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-ml-model-interpreter'
    // Also declare 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 लाइब्रेरी संस्करण को उसकी निर्भरता लाइन में निर्दिष्ट करना होगा।

    ध्यान दें कि यदि आप अपने ऐप में कई फायरबेस लाइब्रेरी का उपयोग करते हैं , तो हम लाइब्रेरी संस्करणों को प्रबंधित करने के लिए BoM का उपयोग करने की अत्यधिक अनुशंसा करते हैं, जो यह सुनिश्चित करता है कि सभी संस्करण संगत हैं।

    dependencies {
        // Declare the dependency for the Firebase ML Custom Models library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.4'
    // Also declare the dependency for the TensorFlow Lite library and specify its version implementation 'org.tensorflow:tensorflow-lite:2.3.0'
    }
  3. अपने ऐप के प्रदर्शन में, घोषित करें कि इंटरनेट की अनुमति आवश्यक है:
    <uses-permission android:name="android.permission.INTERNET" />

1. अपने मॉडल को तैनात करें

अपने कस्टम TensorFlow मॉडल को या तो Firebase कंसोल या Firebase Admin Python और Node.js SDKs का उपयोग करके नियत करें। कस्टम मॉडल देखें और प्रबंधित करें

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

2. मॉडल को डिवाइस पर डाउनलोड करें

अपने ऐप में अपने TensorFlow Lite मॉडल का उपयोग करने के लिए, डिवाइस में मॉडल के नवीनतम संस्करण को डाउनलोड करने के लिए सबसे पहले Firebase ML SDK का उपयोग करें।

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

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

जावा

FirebaseCustomRemoteModel remoteModel =
      new FirebaseCustomRemoteModel.Builder("your_model").build();
FirebaseModelDownloadConditions conditions = new FirebaseModelDownloadConditions.Builder()
        .requireWifi()
        .build();
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.
            }
        });

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

055828230

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

3. एक TensorFlow Lite दुभाषिया प्रारंभ करें

मॉडल को डिवाइस पर डाउनलोड करने के बाद, आप मॉडल प्रबंधक के getLatestModelFile() विधि को कॉल करके मॉडल फ़ाइल स्थान प्राप्त कर सकते हैं। एक TensorFlow Lite दुभाषिया तत्काल करने के लिए इस मूल्य का उपयोग करें:

जावा

FirebaseCustomRemoteModel remoteModel = new FirebaseCustomRemoteModel.Builder("your_model").build();
FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnCompleteListener(new OnCompleteListener<File>() {
            @Override
            public void onComplete(@NonNull Task<File> task) {
                File modelFile = task.getResult();
                if (modelFile != null) {
                    interpreter = new Interpreter(modelFile);
                }
            }
        });

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

val remoteModel = FirebaseCustomRemoteModel.Builder("your_model").build()
FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
    .addOnCompleteListener { task ->
        val modelFile = task.result
        if (modelFile != null) {
            interpreter = Interpreter(modelFile)
        }
    }

4. इनपुट डेटा पर निष्कर्ष प्रदर्शन

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

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 उत्पन्न कर सकते हैं:

जावा

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);
    }
}
है

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

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

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

जावा

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

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

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

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

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

जावा

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

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

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

परिशिष्ट: स्थानीय रूप से बंडल मॉडल पर वापस जाएं

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

अपने ऐप के साथ अपने TensorFlow Lite मॉडल को बंडल करने के लिए:

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

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

    android {
    
        // ...
    
        aaptOptions {
            noCompress "tflite", "lite"
        }
    }
    

तब, होस्टेड मॉडल उपलब्ध नहीं होने पर स्थानीय रूप से बंडल मॉडल का उपयोग करें:

जावा

FirebaseCustomRemoteModel remoteModel =
        new FirebaseCustomRemoteModel.Builder("your_model").build();
FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
        .addOnCompleteListener(new OnCompleteListener<File>() {
            @Override
            public void onComplete(@NonNull Task<File> task) {
                File modelFile = task.getResult();
                if (modelFile != null) {
                    interpreter = new Interpreter(modelFile);
                } else {
                    try {
                        InputStream inputStream = getAssets().open("your_fallback_model.tflite");
                        byte[] model = new byte[inputStream.available()];
                        inputStream.read(model);
                        ByteBuffer buffer = ByteBuffer.allocateDirect(model.length)
                                .order(ByteOrder.nativeOrder());
                        buffer.put(model);
                        interpreter = new Interpreter(buffer);
                    } catch (IOException e) {
                        // File not found?
                    }
                }
            }
        });

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

val remoteModel = FirebaseCustomRemoteModel.Builder("your_model").build()
FirebaseModelManager.getInstance().getLatestModelFile(remoteModel)
    .addOnCompleteListener { task ->
        val modelFile = task.result
        if (modelFile != null) {
            interpreter = Interpreter(modelFile)
        } else {
            val model = assets.open("your_fallback_model.tflite").readBytes()
            val buffer = ByteBuffer.allocateDirect(model.size).order(ByteOrder.nativeOrder())
            buffer.put(model)
            interpreter = Interpreter(buffer)
        }
    }

परिशिष्ट: मॉडल सुरक्षा

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

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

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

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