वाईएमएल संगोष्ठी 2023 7 दिसंबर को लौटेगी! सुबह 9:30 बजे पीएसटी रजिस्टर पर लाइवस्ट्रीम में शामिल हों

इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

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

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

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

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

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 Services API तक पहुंचने के लिए अपने ऐप प्रोजेक्ट कोड में निर्भरताओं में से एक जोड़ें। उदाहरण के लिए, किसी विज़न कार्य को लागू करने के लिए निम्नलिखित का उपयोग करें:

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

2. TensorFlow Lite का आरंभीकरण जोड़ें

TensorFlow Lite API का उपयोग करने से पहले Google Play Services 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.1'
    // Optional: include Tensorflow Lite Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.0.1'
...
}

2. TensorFlow Lite का आरंभीकरण जोड़ें

TensorFlow Lite API का उपयोग करने से पहले Google Play Services 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 आपको ग्राफिक्स प्रोसेसिंग यूनिट (GPUs) जैसे विशेष हार्डवेयर प्रोसेसर का उपयोग करके अपने मॉडल के प्रदर्शन को तेज करने की अनुमति देता है। आप डेलीगेट्स नामक हार्डवेयर ड्राइवर का उपयोग करके इन विशेष प्रोसेसर का लाभ उठा सकते हैं। आप Google Play सेवाओं में TensorFlow Lite के साथ निम्नलिखित हार्डवेयर त्वरण प्रतिनिधियों का उपयोग कर सकते हैं:

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

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

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

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

यह पुष्टि करने के लिए इस विधि का उपयोग करें कि कोई डिवाइस GPU के साथ संगत है या नहीं, और जब GPU समर्थित नहीं है तो सीपीयू या 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 प्रतिनिधि का उपयोग करने के लिए:

Play सेवाओं से GPU प्रतिनिधि का उपयोग करने के लिए प्रोजेक्ट निर्भरताएँ अपडेट करें:
```
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
```
GPU प्रतिनिधि को setEnableGpuDelegateSupport के साथ प्रारंभ करें। उदाहरण के लिए, आप निम्नलिखित के साथ TfLiteVision के लिए GPU प्रतिनिधि को प्रारंभ कर सकते हैं:
Kotlin
```
    TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())
    
```
जावा
```
    TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());
    
```

BaseOptions के साथ GPU प्रतिनिधि विकल्प सक्षम करें:

Kotlin

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

जावा

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

.setBaseOptions का उपयोग करके विकल्पों को कॉन्फ़िगर करें। उदाहरण के लिए, आप निम्नलिखित के साथ ObjectDetector में जीपीयू सेट कर सकते हैं:

Kotlin

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

जावा

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

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

इंटरप्रेटर एपीआई के साथ GPU प्रतिनिधि का उपयोग करने के लिए:

Play सेवाओं से GPU प्रतिनिधि का उपयोग करने के लिए प्रोजेक्ट निर्भरताएँ अपडेट करें:
```
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
```

TFlite आरंभीकरण में GPU प्रतिनिधि विकल्प सक्षम करें:

Kotlin

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

जावा

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

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 में स्थानांतरित करने की योजना बना रहे हैं, तो अपने ऐप प्रोजेक्ट कोड को अपडेट करने के लिए निम्नलिखित अतिरिक्त मार्गदर्शन की समीक्षा करें:

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

यदि आप स्टैंड-अलोन TensorFlow Lite और Play Services API को एक साथ उपयोग करना चाहते हैं, तो आपको TensorFlow Lite 2.9 (या बाद का संस्करण) का उपयोग करना होगा। TensorFlow Lite 2.8 और पुराने संस्करण Play Services 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 Services API में TensorFlow Lite का उपयोग करते हैं, तो इनपुट डेटा, जैसे कि चित्र, वीडियो, टेक्स्ट, की प्रोसेसिंग पूरी तरह से डिवाइस पर होती है, और Google Play Services API में TensorFlow Lite उस डेटा को Google सर्वर पर नहीं भेजता है। परिणामस्वरूप, आप डेटा को संसाधित करने के लिए हमारे एपीआई का उपयोग कर सकते हैं जो डिवाइस को नहीं छोड़ना चाहिए।

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

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

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

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

अगले कदम

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