Google Play सेवाओं में TensorFlow Lite

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

TensorFlow Lite, Play सेवाओं के वर्तमान संस्करण को चलाने वाले सभी Android उपकरणों के लिए Google Play सेवाओं के रनटाइम में उपलब्ध है। यह रनटाइम आपको अपने ऐप में TensorFlow Lite लाइब्रेरी को स्थिर रूप से बंडल किए बिना मशीन लर्निंग (ML) मॉडल चलाने की अनुमति देता है।

Google Play सेवाएं API के साथ, आप अपने ऐप्स के आकार को कम कर सकते हैं और पुस्तकालयों के नवीनतम स्थिर संस्करण से बेहतर प्रदर्शन प्राप्त कर सकते हैं। Google Play सेवाओं में TensorFlow Lite Android पर TensorFlow Lite का उपयोग करने का अनुशंसित तरीका है।

आप क्विकस्टार्ट के साथ Play services रनटाइम के साथ शुरुआत कर सकते हैं, जो नमूना एप्लिकेशन को लागू करने के लिए चरण-दर-चरण मार्गदर्शिका प्रदान करता है। यदि आप अपने ऐप में पहले से ही स्टैंड-अलोन TensorFlow Lite का उपयोग कर रहे हैं, तो Play सेवाओं के रनटाइम का उपयोग करने के लिए किसी मौजूदा ऐप को अपडेट करने के लिए स्टैंड-अलोन TensorFlow लाइट अनुभाग से माइग्रेट करना देखें। Google Play सेवाओं के बारे में अधिक जानकारी के लिए, Google Play सेवाएं वेबसाइट देखें।

Play सेवाओं के रनटाइम का उपयोग करना

Google Play सेवाओं में TensorFlow Lite, TensorFlow Lite Task API और TensorFlow Lite Interpreter API के माध्यम से उपलब्ध है। टास्क लाइब्रेरी दृश्य, ऑडियो और टेक्स्ट डेटा का उपयोग करके सामान्य मशीन सीखने के कार्यों के लिए अनुकूलित आउट-ऑफ-बॉक्स मॉडल इंटरफेस प्रदान करती है। TensorFlow लाइट इंटरप्रेटर API, TensorFlow रनटाइम और सपोर्ट लाइब्रेरी द्वारा प्रदान किया गया है, जो ML मॉडल बनाने और चलाने के लिए अधिक सामान्य-उद्देश्य वाला इंटरफ़ेस प्रदान करता है।

निम्नलिखित अनुभाग Google Play सेवाओं में दुभाषिया और कार्य लाइब्रेरी API को कार्यान्वित करने के तरीके के बारे में निर्देश प्रदान करते हैं। हालांकि एक ऐप के लिए इंटरप्रेटर एपीआई और टास्क लाइब्रेरी एपीआई दोनों का उपयोग करना संभव है, अधिकांश ऐप को एपीआई के केवल एक सेट का उपयोग करना चाहिए।

टास्क लाइब्रेरी एपीआई का उपयोग करना

TensorFlow लाइट टास्क एपीआई इंटरप्रेटर एपीआई को लपेटता है और सामान्य मशीन लर्निंग कार्यों के लिए एक उच्च-स्तरीय प्रोग्रामिंग इंटरफ़ेस प्रदान करता है जो दृश्य, ऑडियो और टेक्स्ट डेटा का उपयोग करते हैं। यदि आपके एप्लिकेशन को समर्थित कार्यों में से एक की आवश्यकता है, तो आपको कार्य API का उपयोग करना चाहिए।

1. परियोजना निर्भरता जोड़ें

आपकी परियोजना निर्भरता आपके मशीन सीखने के उपयोग के मामले पर निर्भर करती है। टास्क एपीआई में निम्नलिखित पुस्तकालय होते हैं:

  • विज़न लाइब्रेरी: org.tensorflow:tensorflow-lite-task-vision-play-services
  • ऑडियो लाइब्रेरी: org.tensorflow:tensorflow-lite-task-audio-play-services
  • टेक्स्ट लाइब्रेरी: org.tensorflow:tensorflow-lite-task-text-play-services

TensorFlow Lite के लिए Play सेवाएं API एक्सेस करने के लिए अपने ऐप प्रोजेक्ट कोड में एक निर्भरता जोड़ें। उदाहरण के लिए, एक विज़न कार्य को लागू करने के लिए निम्नलिखित का उपयोग करें:

dependencies {
...
    implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
...
}

2. TensorFlow Lite का इनिशियलाइज़ेशन जोड़ें

TensorFlow Lite API का उपयोग करने से पहले Google Play सेवा API के TensorFlow Lite घटक को प्रारंभ करें। निम्न उदाहरण विज़न लाइब्रेरी को इनिशियलाइज़ करता है:

Kotlin

init {
  TfLiteVision.initialize(context)
    }
  }

3. रन निष्कर्ष

TensorFlow Lite घटक को इनिशियलाइज़ करने के बाद, इंफ़ेक्शन जनरेट करने के लिए detect() मेथड को कॉल करें। detect() विधि के भीतर सटीक कोड पुस्तकालय और उपयोग के मामले के आधार पर भिन्न होता है। TfLiteVision लाइब्रेरी के साथ एक साधारण ऑब्जेक्ट डिटेक्शन यूज केस के लिए निम्नलिखित है:

Kotlin

fun detect(...) {
  if (!TfLiteVision.isInitialized()) {
    Log.e(TAG, "detect: TfLiteVision is not initialized yet")
    return
  }

  if (objectDetector == null) {
    setupObjectDetector()
  }

  ...

}

डेटा प्रारूप के आधार पर, आपको अनुमान उत्पन्न करने से पहले अपने डेटा को detect() विधि के भीतर प्रीप्रोसेस और कनवर्ट करने की भी आवश्यकता हो सकती है। उदाहरण के लिए, किसी ऑब्जेक्ट डिटेक्टर के लिए छवि डेटा के लिए निम्नलिखित की आवश्यकता होती है:

val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
val results = objectDetector?.detect(tensorImage)

दुभाषिया एपीआई का उपयोग करना

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

1. परियोजना निर्भरता जोड़ें

TensorFlow Lite के लिए Play सेवाएं API एक्सेस करने के लिए अपने ऐप प्रोजेक्ट कोड में निम्नलिखित निर्भरताएँ जोड़ें:

dependencies {
...
    // Tensorflow Lite dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.0.0'
    // Optional: include Tensorflow Lite Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.0.0'
...
}

2. TensorFlow Lite का इनिशियलाइज़ेशन जोड़ें

TensorFlow Lite API का उपयोग करने से पहले Google Play सेवा API के TensorFlow Lite घटक को प्रारंभ करें:

Kotlin

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

जावा

Task<Void> initializeTask = TfLite.initialize(context);

3. एक दुभाषिया बनाएं और रनटाइम विकल्प सेट करें

InterpreterApi.create() InterpreterApi.Options.setRuntime() कॉल करके Google Play सेवाओं के रनटाइम का उपयोग करने के लिए इसे कॉन्फ़िगर करें, जैसा कि निम्नलिखित उदाहरण कोड में दिखाया गया है:

Kotlin

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private lateinit var interpreter: InterpreterApi
...
initializeTask.addOnSuccessListener {
  val interpreterOption =
    InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  interpreter = InterpreterApi.create(
    modelBuffer,
    interpreterOption
  )}
  .addOnFailureListener { e ->
    Log.e("Interpreter", "Cannot initialize interpreter", e)
  }

जावा

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private InterpreterApi interpreter;
...
initializeTask.addOnSuccessListener(a -> {
    interpreter = InterpreterApi.create(modelBuffer,
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY));
  })
  .addOnFailureListener(e -> {
    Log.e("Interpreter", String.format("Cannot initialize interpreter: %s",
          e.getMessage()));
  });

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

Kotlin

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

जावा

@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

4. संदर्भ चलाएँ

आपके द्वारा बनाए गए interpreter ऑब्जेक्ट का उपयोग करके, एक अनुमान उत्पन्न करने के लिए run() विधि को कॉल करें।

Kotlin

interpreter.run(inputBuffer, outputBuffer)

जावा

interpreter.run(inputBuffer, outputBuffer);

हार्डवेयर एक्सिलरेशन

TensorFlow Lite आपको विशेष हार्डवेयर प्रोसेसर, जैसे कि ग्राफिक्स प्रोसेसिंग यूनिट (GPU) का उपयोग करके अपने मॉडल के प्रदर्शन को तेज करने की अनुमति देता है। आप डेलिगेट कहे जाने वाले हार्डवेयर ड्राइवरों का उपयोग करके इन विशेष प्रोसेसर का लाभ उठा सकते हैं। आप Google Play सेवाओं में TensorFlow Lite के साथ निम्नलिखित हार्डवेयर त्वरण प्रतिनिधियों का उपयोग कर सकते हैं:

  • GPU प्रतिनिधि (अनुशंसित) - यह प्रतिनिधि Google Play सेवाओं के माध्यम से प्रदान किया जाता है और कार्य API और Interpreter API के Play सेवाओं संस्करणों की तरह ही गतिशील रूप से लोड किया जाता है।

  • एनएनएपीआई प्रतिनिधि - यह प्रतिनिधि आपके एंड्रॉइड डेवलपमेंट प्रोजेक्ट में शामिल लाइब्रेरी निर्भरता के रूप में उपलब्ध है, और आपके ऐप में बंडल किया गया है।

TensorFlow Lite के साथ हार्डवेयर त्वरण के बारे में अधिक जानकारी के लिए, TensorFlow Lite प्रतिनिधि पृष्ठ देखें।

डिवाइस संगतता की जाँच करना

सभी डिवाइस TFlite के साथ GPU हार्डवेयर एक्सेलेरेशन का समर्थन नहीं करते हैं। त्रुटियों और संभावित क्रैश को कम करने के लिए, यह जांचने के लिए TfLiteGpu.isGpuDelegateAvailable विधि का उपयोग करें कि कोई उपकरण GPU प्रतिनिधि के साथ संगत है या नहीं।

इस विधि का उपयोग यह पुष्टि करने के लिए करें कि कोई उपकरण GPU के साथ संगत है या नहीं, और जब GPU समर्थित नहीं है तो CPU या NNAPI प्रतिनिधि को फ़ॉलबैक के रूप में उपयोग करें।

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

एक बार जब आपके पास useGpuTask जैसा वैरिएबल हो, तो आप इसका उपयोग यह निर्धारित करने के लिए कर सकते हैं कि डिवाइस GPU प्रतिनिधि का उपयोग करते हैं या नहीं। निम्नलिखित उदाहरण दिखाते हैं कि यह टास्क लाइब्रेरी और इंटरप्रेटर एपीआई दोनों के साथ कैसे किया जा सकता है।

टास्क एपि के साथ

Kotlin

lateinit val optionsTask = useGpuTask.continueWith { task ->
  val baseOptionsBuilder = BaseOptions.builder()
  if (task.result) {
    baseOptionsBuilder.useGpu()
  }
 ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
}
    

जावा

Task<ObjectDetectorOptions> optionsTask = useGpuTask.continueWith({ task ->
  BaseOptions baseOptionsBuilder = BaseOptions.builder();
  if (task.getResult()) {
    baseOptionsBuilder.useGpu();
  }
  return ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
});
    

दुभाषिया एपीआई के साथ

Kotlin

val interpreterTask = useGpuTask.continueWith { task ->
  val interpreterOptions = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  if (task.result) {
      interpreterOptions.addDelegateFactory(GpuDelegateFactory())
  }
  InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions)
}
    

जावा

Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  InterpreterApi.Options options =
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY);
  if (task.getResult()) {
     options.addDelegateFactory(new GpuDelegateFactory());
  }
  return options;
});
    

टास्क लाइब्रेरी एपीआई के साथ जीपीयू

कार्य API के साथ GPU प्रतिनिधि का उपयोग करने के लिए:

  1. Play सेवाओं से GPU प्रतिनिधि का उपयोग करने के लिए प्रोजेक्ट निर्भरता को अपडेट करें:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.0.0'
    
  2. GPU प्रतिनिधि को setEnableGpuDelegateSupport के साथ प्रारंभ करें। उदाहरण के लिए, आप निम्नलिखित के साथ TfLiteVision के लिए GPU प्रतिनिधि को इनिशियलाइज़ कर सकते हैं:

    Kotlin

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())
        

    जावा

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());
        
  3. BaseOptions के साथ GPU प्रतिनिधि विकल्प को सक्षम करें:

    Kotlin

        val baseOptions = BaseOptions.builder().useGpu().build()
        

    जावा

        BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
        
  4. .setBaseOptions का उपयोग करके विकल्पों को कॉन्फ़िगर करें। उदाहरण के लिए, आप निम्न के साथ ObjectDetector में GPU सेट कर सकते हैं:

    Kotlin

        val options =
            ObjectDetectorOptions.builder()
                .setBaseOptions(baseOptions)
                .setMaxResults(1)
                .build()
        

    जावा

        ObjectDetectorOptions options =
            ObjectDetectorOptions.builder()
                .setBaseOptions(baseOptions)
                .setMaxResults(1)
                .build();
        

दुभाषिया एपीआई के साथ जीपीयू

दुभाषिया एपीआई के साथ GPU प्रतिनिधि का उपयोग करने के लिए:

  1. Play सेवाओं से GPU प्रतिनिधि का उपयोग करने के लिए प्रोजेक्ट निर्भरता को अपडेट करें:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.0.0'
    
  2. TFlite आरंभीकरण में GPU प्रतिनिधि विकल्प सक्षम करें:

    Kotlin

        TfLite.initialize(context,
          TfLiteInitializationOptions.builder()
           .setEnableGpuDelegateSupport(true)
           .build())
        

    जावा

        TfLite.initialize(context,
          TfLiteInitializationOptions.builder()
           .setEnableGpuDelegateSupport(true)
           .build());
        
  3. InterpreterApi.Options() ) के भीतर addDelegateFactory() को कॉल करके DelegateFactory का उपयोग करने के लिए दुभाषिया विकल्पों में GPU प्रतिनिधि सेट करें:

    Kotlin

        val interpreterOption = InterpreterApi.Options()
         .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
         .addDelegateFactory(GpuDelegateFactory())
        

    जावा

        Options interpreterOption = InterpreterApi.Options()
          .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
          .addDelegateFactory(new GpuDelegateFactory());
        

स्टैंड-अलोन TensorFlow Lite से माइग्रेट करना

यदि आप अपने ऐप को स्टैंड-अलोन TensorFlow Lite से Play services API में माइग्रेट करने की योजना बना रहे हैं, तो अपने ऐप प्रोजेक्ट कोड को अपडेट करने के लिए निम्नलिखित अतिरिक्त मार्गदर्शन की समीक्षा करें:

  1. यह सुनिश्चित करने के लिए कि आपका उपयोग मामला समर्थित है, इस पृष्ठ के सीमाएं अनुभाग की समीक्षा करें।
  2. अपना कोड अपडेट करने से पहले, अपने मॉडलों के लिए प्रदर्शन और सटीकता की जांच करें, खासकर यदि आप संस्करण 2.1 से पहले TensorFlow Lite के संस्करणों का उपयोग कर रहे हैं, तो आपके पास नए कार्यान्वयन के साथ तुलना करने के लिए एक आधार रेखा है।
  3. यदि आपने TensorFlow Lite के लिए Play सेवाएं API का उपयोग करने के लिए अपने सभी कोड को माइग्रेट किया है, तो आपको अपनी बिल्ड.ग्रेड फ़ाइल से मौजूदा TensorFlow लाइट रनटाइम लाइब्रेरी निर्भरता ( org.tensorflow: tensorflow-lite :* साथ प्रविष्टियां) को हटा देना चाहिए ताकि आप आपके ऐप का आकार कम कर सकता है।
  4. अपने कोड में new Interpreter ऑब्जेक्ट निर्माण की सभी घटनाओं की पहचान करें, और इसे संशोधित करें ताकि यह InterpreterApi.create() कॉल का उपयोग करे। यह नया एपीआई एसिंक्रोनस है, जिसका अर्थ है कि ज्यादातर मामलों में यह ड्रॉप-इन प्रतिस्थापन नहीं है, और कॉल पूर्ण होने पर आपको श्रोता को पंजीकृत करना होगा। चरण 3 कोड में कोड स्निपेट देखें।
  5. import org.tensorflow.lite.InterpreterApi; और import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; org.tensorflow.lite.Interpreter या org.tensorflow.lite.InterpreterApi कक्षाओं का उपयोग करके किसी भी स्रोत फ़ाइल के लिए।
  6. यदि InterpreterApi.create() को परिणामी कॉल में से केवल एक ही तर्क है, तो तर्क सूची में new InterpreterApi.Options() जोड़ें।
  7. InterpreterApi.create() पर किसी भी कॉल के अंतिम तर्क में .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) जोड़ें।
  8. org.tensorflow.lite.Interpreter वर्ग की अन्य सभी घटनाओं को org.tensorflow.lite.InterpreterApi से बदलें।

यदि आप स्टैंड-अलोन TensorFlow Lite और Play सेवाओं API का साथ-साथ उपयोग करना चाहते हैं, तो आपको TensorFlow Lite 2.9 (या बाद के संस्करण) का उपयोग करना चाहिए। TensorFlow Lite 2.8 और पुराने संस्करण Play सेवाएं API संस्करण के साथ संगत नहीं हैं।

सीमाओं

Google Play सेवाओं में TensorFlow Lite की निम्नलिखित सीमाएँ हैं:

  • हार्डवेयर त्वरण प्रतिनिधियों के लिए समर्थन हार्डवेयर त्वरण खंड में सूचीबद्ध प्रतिनिधियों तक सीमित है। कोई अन्य त्वरण प्रतिनिधि समर्थित नहीं हैं।
  • देशी API के माध्यम से TensorFlow Lite तक पहुंच समर्थित नहीं है। Google Play सेवाओं के माध्यम से केवल TensorFlow Lite Java API उपलब्ध हैं।
  • कस्टम ऑप्स सहित प्रायोगिक या बहिष्कृत TensorFlow Lite API समर्थित नहीं हैं।

समर्थन और प्रतिक्रिया

आप प्रतिक्रिया दे सकते हैं और TensorFlow इश्यू ट्रैकर के माध्यम से सहायता प्राप्त कर सकते हैं। कृपया Google Play सेवाओं में TensorFlow Lite के लिए समस्या टेम्पलेट का उपयोग करके समस्याओं और समर्थन अनुरोधों की रिपोर्ट करें।

सेवा की शर्तें

Google Play सेवाओं API में TensorFlow Lite का उपयोग Google API की सेवा की शर्तों के अधीन है।

गोपनीयता और डेटा संग्रह

जब आप Google Play सेवाओं API में TensorFlow Lite का उपयोग करते हैं, तो इनपुट डेटा की प्रोसेसिंग, जैसे कि चित्र, वीडियो, टेक्स्ट, पूरी तरह से डिवाइस पर होता है, और Google Play सेवाओं में TensorFlow Lite API उस डेटा को Google सर्वर पर नहीं भेजता है। नतीजतन, आप हमारे एपीआई का उपयोग डेटा को संसाधित करने के लिए कर सकते हैं जो डिवाइस को नहीं छोड़ना चाहिए।

Google Play सेवाओं में TensorFlow Lite API समय-समय पर बग फिक्स, अपडेट किए गए मॉडल और हार्डवेयर त्वरक संगतता जानकारी जैसी चीजें प्राप्त करने के लिए Google सर्वर से संपर्क कर सकते हैं। Google Play सेवाओं API में TensorFlow Lite Google को आपके ऐप में API के प्रदर्शन और उपयोग के बारे में मीट्रिक भी भेजता है। Google इस मीट्रिक डेटा का उपयोग प्रदर्शन को मापने, डीबग करने, बनाए रखने और API में सुधार करने और दुरुपयोग या दुरुपयोग का पता लगाने के लिए करता है, जैसा कि आगे हमारी गोपनीयता नीति में वर्णित है।

आप अपने ऐप के उपयोगकर्ताओं को Google Play सेवाओं में Google द्वारा TensorFlow Lite के प्रसंस्करण के बारे में सूचित करने के लिए जिम्मेदार हैं, जैसा कि लागू कानून द्वारा आवश्यक है।

हमारे द्वारा एकत्र किए गए डेटा में निम्नलिखित शामिल हैं:

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

अगले कदम

TensorFlow Lite के साथ अपने मोबाइल एप्लिकेशन में मशीन लर्निंग को लागू करने के बारे में अधिक जानकारी के लिए, TensorFlow Lite डेवलपर गाइड देखें। आप छवि वर्गीकरण, ऑब्जेक्ट डिटेक्शन और अन्य अनुप्रयोगों के लिए TensorFlow हब पर अतिरिक्त TensorFlow Lite मॉडल पा सकते हैं।