Android के साथ प्रश्नों का उत्तर देना

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

यदि आप किसी मौजूदा प्रोजेक्ट को अपडेट कर रहे हैं, तो आप उदाहरण एप्लिकेशन को संदर्भ या टेम्पलेट के रूप में उपयोग कर सकते हैं। किसी मौजूदा एप्लिकेशन में प्रश्न उत्तर जोड़ने के निर्देशों के लिए, अपने एप्लिकेशन को अपडेट करना और संशोधित करना देखें।

प्रश्न उत्तर का अवलोकन

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

एक प्रश्न उत्तर देने वाले मॉडल को एक प्रश्न उत्तर देने वाले डेटासेट पर प्रशिक्षित किया जाता है, जिसमें पाठ के विभिन्न खंडों के आधार पर प्रश्न-उत्तर जोड़े के साथ-साथ पढ़ने की समझ वाला डेटासेट भी शामिल होता है।

इस ट्यूटोरियल में मॉडल कैसे तैयार किए जाते हैं, इस बारे में अधिक जानकारी के लिए, TensorFlow Lite मॉडल मेकर ट्यूटोरियल के साथ BERT प्रश्न उत्तर देखें।

मॉडल और डेटासेट

उदाहरण ऐप मोबाइल BERT Q&A ( mobilebert ) मॉडल का उपयोग करता है, जो BERT (ट्रांसफॉर्मर्स से द्विदिश एनकोडर रिप्रेजेंटेशन) का हल्का और तेज़ संस्करण है। mobilebert के बारे में अधिक जानकारी के लिए, मोबाइलबर्ट देखें: रिसोर्स-लिमिटेड डिवाइसेस के लिए एक कॉम्पैक्ट टास्क-एग्नोस्टिक बीईआरटी शोध पत्र।

mobilebert मॉडल को स्टैनफोर्ड क्वेश्चन आंसरिंग डेटासेट ( एसक्यूएडी ) डेटासेट का उपयोग करके प्रशिक्षित किया गया था, एक रीडिंग कॉम्प्रिहेंशन डेटासेट जिसमें विकिपीडिया के लेख और प्रत्येक लेख के लिए प्रश्न-उत्तर जोड़े का एक सेट शामिल है।

उदाहरण ऐप सेटअप करें और चलाएं

प्रश्न उत्तर एप्लिकेशन सेटअप करने के लिए, GitHub से उदाहरण ऐप डाउनलोड करें और इसे Android Studio का उपयोग करके चलाएं।

सिस्टम आवश्यकताएं

• एंड्रॉइड स्टूडियो संस्करण 2021.1.1 (भौंरा) या उच्चतर।
• एंड्रॉइड एसडीके संस्करण 31 या उच्चतर
• डेवलपर मोड सक्षम या एंड्रॉइड एमुलेटर के साथ एसडीके 21 (एंड्रॉइड 7.0 - नूगट) के न्यूनतम ओएस संस्करण वाला एंड्रॉइड डिवाइस।

उदाहरण कोड प्राप्त करें

उदाहरण कोड की एक स्थानीय प्रतिलिपि बनाएँ। आप एंड्रॉइड स्टूडियो में एक प्रोजेक्ट बनाने और उदाहरण एप्लिकेशन चलाने के लिए इस कोड का उपयोग करेंगे।

उदाहरण कोड को क्लोन और सेटअप करने के लिए:

1. Git रिपॉजिटरी

   git clone https://github.com/tensorflow/examples.git
   

   क्लोन करें
2. वैकल्पिक रूप से, अपने git इंस्टेंस को विरल चेकआउट का उपयोग करने के लिए कॉन्फ़िगर करें, ताकि आपके पास केवल प्रश्न उत्तर देने वाले उदाहरण ऐप की फ़ाइलें हों:

   cd examples
   git sparse-checkout init --cone
   git sparse-checkout set lite/examples/bert_qa/android
   

प्रोजेक्ट आयात करें और चलाएं

डाउनलोड किए गए उदाहरण कोड से एक प्रोजेक्ट बनाएं, प्रोजेक्ट बनाएं और फिर उसे चलाएं।

उदाहरण कोड प्रोजेक्ट आयात करने और बनाने के लिए:

1. एंड्रॉइड स्टूडियो प्रारंभ करें।
2. एंड्रॉइड स्टूडियो से, फ़ाइल > नया > प्रोजेक्ट आयात करें चुनें।
3. बिल्ड.ग्रेडल फ़ाइल ( .../examples/lite/examples/bert_qa/android/build.gradle ) वाली उदाहरण कोड निर्देशिका पर नेविगेट करें और उस निर्देशिका का चयन करें।
4. यदि एंड्रॉइड स्टूडियो ग्रैडल सिंक का अनुरोध करता है, तो ठीक चुनें।
5. सुनिश्चित करें कि आपका एंड्रॉइड डिवाइस आपके कंप्यूटर से कनेक्ट है और डेवलपर मोड सक्षम है। हरे Run तीर पर क्लिक करें।

यदि आप सही निर्देशिका का चयन करते हैं, तो एंड्रॉइड स्टूडियो एक नया प्रोजेक्ट बनाता है और उसे बनाता है। आपके कंप्यूटर की गति और यदि आपने अन्य परियोजनाओं के लिए एंड्रॉइड स्टूडियो का उपयोग किया है, तो इस प्रक्रिया में कुछ मिनट लग सकते हैं। जब निर्माण पूरा हो जाता है, तो एंड्रॉइड स्टूडियो बिल्ड आउटपुट स्थिति पैनल में एक BUILD SUCCESSFUL संदेश प्रदर्शित करता है।

प्रोजेक्ट चलाने के लिए:

1. एंड्रॉइड स्टूडियो से, रन > रन… का चयन करके प्रोजेक्ट चलाएं।
2. ऐप का परीक्षण करने के लिए एक संलग्न एंड्रॉइड डिवाइस (या एमुलेटर) का चयन करें।

एप्लिकेशन का उपयोग करना

एंड्रॉइड स्टूडियो में प्रोजेक्ट चलाने के बाद, एप्लिकेशन स्वचालित रूप से कनेक्टेड डिवाइस या डिवाइस एमुलेटर पर खुल जाता है।

प्रश्न उत्तरकर्ता उदाहरण ऐप का उपयोग करने के लिए:

1. विषयों की सूची में से एक विषय चुनें.
2. कोई सुझाया गया प्रश्न चुनें या टेक्स्ट बॉक्स में अपना प्रश्न दर्ज करें।
3. मॉडल को चलाने के लिए नारंगी तीर को टॉगल करें।

एप्लिकेशन गद्यांश पाठ से प्रश्न के उत्तर की पहचान करने का प्रयास करता है। यदि मॉडल अनुच्छेद के भीतर एक उत्तर का पता लगाता है, तो एप्लिकेशन उपयोगकर्ता के लिए पाठ की प्रासंगिक अवधि को हाइलाइट करता है।

अब आपके पास एक कार्यशील प्रश्न उत्तर देने वाला एप्लिकेशन है। उदाहरण एप्लिकेशन कैसे काम करता है, और अपने उत्पादन अनुप्रयोगों में प्रश्न उत्तर सुविधाओं को कैसे कार्यान्वित करें, इसे बेहतर ढंग से समझने के लिए निम्नलिखित अनुभागों का उपयोग करें:

• एप्लिकेशन कैसे काम करता है - उदाहरण एप्लिकेशन की संरचना और मुख्य फ़ाइलों का पूर्वाभ्यास।

• अपने एप्लिकेशन को संशोधित करें - मौजूदा एप्लिकेशन में प्रश्न उत्तर जोड़ने पर निर्देश।

उदाहरण ऐप कैसे काम करता है

एप्लिकेशन प्राकृतिक भाषा (एनएल) पैकेज के लिए टास्क लाइब्रेरी के भीतर BertQuestionAnswerer API का उपयोग करता है। MobileBERT मॉडल को TensorFlow Lite मॉडल मेकर का उपयोग करके प्रशिक्षित किया गया था। एप्लिकेशन GPU या NNAPI प्रतिनिधि का उपयोग करके हार्डवेयर त्वरण के विकल्प के साथ, डिफ़ॉल्ट रूप से CPU पर चलता है।

निम्नलिखित फ़ाइलों और निर्देशिकाओं में इस एप्लिकेशन के लिए महत्वपूर्ण कोड हैं:

• BertQaHelper.kt - प्रश्न उत्तरकर्ता को आरंभ करता है और मॉडल और प्रतिनिधि चयन को संभालता है।
• QaFragment.kt - परिणामों को संभालता है और प्रारूपित करता है।
• MainActivity.kt - ऐप का आयोजन तर्क प्रदान करता है।

अपना आवेदन संशोधित करें

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

एक Android प्रोजेक्ट खोलें या बनाएं

आपको इन बाकी निर्देशों के साथ पालन करने के लिए एंड्रॉइड स्टूडियो में एक एंड्रॉइड डेवलपमेंट प्रोजेक्ट की आवश्यकता है। किसी मौजूदा प्रोजेक्ट को खोलने या नया प्रोजेक्ट बनाने के लिए नीचे दिए गए निर्देशों का पालन करें।

मौजूदा Android विकास प्रोजेक्ट खोलने के लिए:

• एंड्रॉइड स्टूडियो में, फ़ाइल > खोलें चुनें और एक मौजूदा प्रोजेक्ट चुनें।

एक बुनियादी Android विकास प्रोजेक्ट बनाने के लिए:

• एक बुनियादी प्रोजेक्ट बनाने के लिए एंड्रॉइड स्टूडियो में दिए गए निर्देशों का पालन करें।

एंड्रॉइड स्टूडियो का उपयोग करने के बारे में अधिक जानकारी के लिए, एंड्रॉइड स्टूडियो दस्तावेज़ देखें।

प्रोजेक्ट निर्भरताएँ जोड़ें

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

मॉड्यूल निर्भरताएँ जोड़ने के लिए:

1. TensorFlow Lite का उपयोग करने वाले मॉड्यूल में, निम्नलिखित निर्भरताओं को शामिल करने के लिए मॉड्यूल की build.gradle फ़ाइल को अपडेट करें।

   उदाहरण एप्लिकेशन में, निर्भरताएं ऐप/बिल्ड.ग्रेडल में स्थित हैं:

   dependencies {
     ...
     // Import tensorflow library
     implementation 'org.tensorflow:tensorflow-lite-task-text:0.3.0'
   
     // Import the GPU delegate plugin Library for GPU inference
     implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin:0.4.0'
     implementation 'org.tensorflow:tensorflow-lite-gpu:2.9.0'
   }
   

   प्रोजेक्ट में टेक्स्ट टास्क लाइब्रेरी ( tensorflow-lite-task-text ) शामिल होनी चाहिए।

   यदि आप ग्राफिक्स प्रोसेसिंग यूनिट (जीपीयू) पर चलाने के लिए इस ऐप को संशोधित करना चाहते हैं, तो जीपीयू लाइब्रेरी ( tensorflow-lite-gpu-delegate-plugin ) ऐप को जीपीयू पर चलाने के लिए बुनियादी ढांचा प्रदान करती है, और डेलीगेट ( tensorflow-lite-gpu ) अनुकूलता सूची प्रदान करता है।

2. एंड्रॉइड स्टूडियो में, चयन करके प्रोजेक्ट निर्भरता को सिंक करें: फ़ाइल > ग्रैडल फ़ाइलों के साथ प्रोजेक्ट सिंक करें ।

एमएल मॉडल प्रारंभ करें

अपने एंड्रॉइड ऐप में, आपको मॉडल के साथ पूर्वानुमान चलाने से पहले मापदंडों के साथ TensorFlow Lite मशीन लर्निंग मॉडल को आरंभ करना होगा।

TensorFlow Lite मॉडल को *.tflite फ़ाइल के रूप में संग्रहीत किया जाता है। मॉडल फ़ाइल में भविष्यवाणी तर्क होता है और आम तौर पर भविष्यवाणी परिणामों की व्याख्या करने के तरीके के बारे में मेटाडेटा शामिल होता है। आमतौर पर, मॉडल फ़ाइलें आपके विकास प्रोजेक्ट की src/main/assets निर्देशिका में संग्रहीत की जाती हैं, जैसा कि कोड उदाहरण में है:

• <project>/src/main/assets/mobilebert_qa.tflite

सुविधा और कोड पठनीयता के लिए, उदाहरण एक साथी ऑब्जेक्ट घोषित करता है जो मॉडल के लिए सेटिंग्स को परिभाषित करता है।

अपने ऐप में मॉडल आरंभ करने के लिए:

1. मॉडल के लिए सेटिंग्स परिभाषित करने के लिए एक सहयोगी ऑब्जेक्ट बनाएं। उदाहरण एप्लिकेशन में, यह ऑब्जेक्ट BertQaHelper.kt में स्थित है:

   companion object {
       private const val BERT_QA_MODEL = "mobilebert.tflite"
       private const val TAG = "BertQaHelper"
       const val DELEGATE_CPU = 0
       const val DELEGATE_GPU = 1
       const val DELEGATE_NNAPI = 2
   }
   

2. BertQaHelper ऑब्जेक्ट बनाकर मॉडल के लिए सेटिंग्स बनाएं, और bertQuestionAnswerer के साथ TensorFlow Lite ऑब्जेक्ट बनाएं।

   उदाहरण एप्लिकेशन में, यह BertQaHelper.kt के भीतर setupBertQuestionAnswerer() फ़ंक्शन में स्थित है:

   class BertQaHelper(
       ...
   ) {
       ...
       init {
           setupBertQuestionAnswerer()
       }
   
       fun clearBertQuestionAnswerer() {
           bertQuestionAnswerer = null
       }
   
       private fun setupBertQuestionAnswerer() {
           val baseOptionsBuilder = BaseOptions.builder().setNumThreads(numThreads)
           ...
           val options = BertQuestionAnswererOptions.builder()
               .setBaseOptions(baseOptionsBuilder.build())
               .build()
   
           try {
               bertQuestionAnswerer =
                   BertQuestionAnswerer.createFromFileAndOptions(context, BERT_QA_MODEL, options)
           } catch (e: IllegalStateException) {
               answererListener
                   ?.onError("Bert Question Answerer failed to initialize. See error logs for details")
               Log.e(TAG, "TFLite failed to load model with error: " + e.message)
           }
       }
       ...
       }
   

हार्डवेयर त्वरण सक्षम करें (वैकल्पिक)

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

अपने ऐप में हार्डवेयर त्वरण सक्षम करने के लिए:

1. एप्लिकेशन द्वारा उपयोग किए जाने वाले प्रतिनिधि को परिभाषित करने के लिए एक वेरिएबल बनाएं। उदाहरण एप्लिकेशन में, यह वेरिएबल BertQaHelper.kt के आरंभ में स्थित है:

   var currentDelegate: Int = 0
   

2. एक प्रतिनिधि चयनकर्ता बनाएँ. उदाहरण एप्लिकेशन में, प्रतिनिधि चयनकर्ता BertQaHelper.kt के भीतर setupBertQuestionAnswerer फ़ंक्शन में स्थित है:

   when (currentDelegate) {
       DELEGATE_CPU -> {
           // Default
       }
       DELEGATE_GPU -> {
           if (CompatibilityList().isDelegateSupportedOnThisDevice) {
               baseOptionsBuilder.useGpu()
           } else {
               answererListener?.onError("GPU is not supported on this device")
           }
       }
       DELEGATE_NNAPI -> {
           baseOptionsBuilder.useNnapi()
       }
   }
   

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

मॉडल के लिए डेटा तैयार करें

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

मॉडल को पैसेज टेक्स्ट डेटा प्रदान करने के लिए:

1. ऐप में पैसेज टेक्स्ट डेटा लोड करने के लिए LoadDataSetClient ऑब्जेक्ट का उपयोग करें। उदाहरण एप्लिकेशन में, यह LoadDataSetClient.kt में स्थित है

   fun loadJson(): DataSet? {
       var dataSet: DataSet? = null
       try {
           val inputStream: InputStream = context.assets.open(JSON_DIR)
           val bufferReader = inputStream.bufferedReader()
           val stringJson: String = bufferReader.use { it.readText() }
           val datasetType = object : TypeToken<DataSet>() {}.type
           dataSet = Gson().fromJson(stringJson, datasetType)
       } catch (e: IOException) {
           Log.e(TAG, e.message.toString())
       }
       return dataSet
   }
   

2. पाठ के प्रत्येक अंश के शीर्षकों को सूचीबद्ध करने और टीएफएल प्रश्न और उत्तर स्क्रीन शुरू करने के लिए DatasetFragment ऑब्जेक्ट का उपयोग करें। उदाहरण एप्लिकेशन में, यह DatasetFragment.kt में स्थित है:

   class DatasetFragment : Fragment() {
       ...
       override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
           super.onViewCreated(view, savedInstanceState)
           val client = LoadDataSetClient(requireActivity())
           client.loadJson()?.let {
               titles = it.getTitles()
           }
           ...
       }
      ...
   }
   

3. पाठ के प्रत्येक अंश के लिए शीर्षक प्रस्तुत करने के लिए DatasetAdapter ऑब्जेक्ट के भीतर onCreateViewHolder फ़ंक्शन का उपयोग करें। उदाहरण एप्लिकेशन में, यह DatasetAdapter.kt में स्थित है:

   override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
       val binding = ItemDatasetBinding.inflate(
           LayoutInflater.from(parent.context),
           parent,
           false
       )
       return ViewHolder(binding)
   }
   

मॉडल को उपयोगकर्ता प्रश्न प्रदान करने के लिए:

1. मॉडल को प्रश्न प्रदान करने के लिए QaAdapter ऑब्जेक्ट का उपयोग करें। उदाहरण एप्लिकेशन में, यह QaAdapter.kt में स्थित है:

   class QaAdapter(private val question: List<String>, private val select: (Int) -> Unit) :
     RecyclerView.Adapter<QaAdapter.ViewHolder>() {
   
     inner class ViewHolder(private val binding: ItemQuestionBinding) :
         RecyclerView.ViewHolder(binding.root) {
         init {
             binding.tvQuestionSuggestion.setOnClickListener {
                 select.invoke(adapterPosition)
             }
         }
   
         fun bind(question: String) {
             binding.tvQuestionSuggestion.text = question
         }
     }
     ...
   }
   

पूर्वानुमान चलाएँ

अपने एंड्रॉइड ऐप में, एक बार जब आप BertQuestionAnswerer ऑब्जेक्ट को इनिशियलाइज़ कर लेते हैं, तो आप मॉडल में प्राकृतिक भाषा टेक्स्ट के रूप में प्रश्न इनपुट करना शुरू कर सकते हैं। मॉडल पाठ्यांश के भीतर उत्तर की पहचान करने का प्रयास करता है।

पूर्वानुमान चलाने के लिए:

1. एक answer फ़ंक्शन बनाएं, जो मॉडल चलाता है और उत्तर की पहचान करने में लगने वाले समय ( inferenceTime ) को मापता है। उदाहरण एप्लिकेशन में, answer फ़ंक्शन BertQaHelper.kt में स्थित है:

   fun answer(contextOfQuestion: String, question: String) {
       if (bertQuestionAnswerer == null) {
           setupBertQuestionAnswerer()
       }
   
       var inferenceTime = SystemClock.uptimeMillis()
   
       val answers = bertQuestionAnswerer?.answer(contextOfQuestion, question)
       inferenceTime = SystemClock.uptimeMillis() - inferenceTime
       answererListener?.onResults(answers, inferenceTime)
   }
   

2. answer से परिणाम को श्रोता ऑब्जेक्ट तक पास करें।

   interface AnswererListener {
       fun onError(error: String)
       fun onResults(
           results: List<QaAnswer>?,
           inferenceTime: Long
       )
   }
   

मॉडल आउटपुट संभालें

आपके द्वारा एक प्रश्न इनपुट करने के बाद, मॉडल अनुच्छेद के भीतर अधिकतम पांच संभावित उत्तर प्रदान करता है।

मॉडल से परिणाम प्राप्त करने के लिए:

1. आउटपुट को संभालने के लिए श्रोता ऑब्जेक्ट के लिए एक onResult फ़ंक्शन बनाएं। उदाहरण एप्लिकेशन में, श्रोता ऑब्जेक्ट BertQaHelper.kt में स्थित है

   interface AnswererListener {
       fun onError(error: String)
       fun onResults(
           results: List<QaAnswer>?,
           inferenceTime: Long
       )
   }
   

2. परिणामों के आधार पर गद्यांश के अनुभागों को हाइलाइट करें। उदाहरण एप्लिकेशन में, यह QaFragment.kt में स्थित है:

   override fun onResults(results: List<QaAnswer>?, inferenceTime: Long) {
       results?.first()?.let {
           highlightAnswer(it.text)
       }
   
       fragmentQaBinding.tvInferenceTime.text = String.format(
           requireActivity().getString(R.string.bottom_view_inference_time),
           inferenceTime
       )
   }
   

एक बार जब मॉडल परिणामों का एक सेट लौटा देता है, तो आपका एप्लिकेशन आपके उपयोगकर्ता को परिणाम प्रस्तुत करके या अतिरिक्त तर्क निष्पादित करके उन भविष्यवाणियों पर कार्य कर सकता है।

अगले कदम

• TensorFlow Lite मॉडल मेकर ट्यूटोरियल के साथ प्रश्न उत्तर के साथ मॉडलों को शुरू से ही प्रशिक्षित और कार्यान्वित करें।
• TensorFlow के लिए और अधिक टेक्स्ट प्रोसेसिंग टूल खोजें।
• TensorFlow हब पर अन्य BERT मॉडल डाउनलोड करें।
• उदाहरणों में TensorFlow Lite के विभिन्न उपयोगों का अन्वेषण करें।