TensorFlow Lite और Firebase के साथ अपने ऐप में अनुशंसाएं जोड़ें - Android Codelab

1 अवलोकन

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

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

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

आप क्या सीखेंगे

  • उपयोगकर्ता व्यवहार डेटा एकत्र करने के लिए फायरबेस एनालिटिक्स को एक एंड्रॉइड ऐप में एकीकृत करें
  • उस डेटा को Google Big Query में निर्यात करें
  • डेटा को प्री-प्रोसेस करें और TF लाइट अनुशंसा मॉडल को प्रशिक्षित करें
  • TF लाइट मॉडल को Firebase ML में परिनियोजित करें और इसे अपने ऐप से एक्सेस करें
  • उपयोगकर्ताओं को अनुशंसाएं सुझाने के लिए मॉडल का उपयोग करके डिवाइस अनुमान पर चलाएं

आपको किस चीज़ की ज़रूरत पड़ेगी

  • एंड्रॉइड स्टूडियो संस्करण 3.4+।
  • नमूना कोड।
  • एंड्रॉइड 2.3+ और Google Play सेवाओं के साथ एक परीक्षण उपकरण 9.8 या बाद में, या Google Play सेवाओं के साथ एक एमुलेटर 9.8 या बाद में
  • यदि डिवाइस का उपयोग कर रहे हैं, तो एक कनेक्शन केबल।

आप इस ट्यूटोरियल का उपयोग कैसे करेंगे?

इसके माध्यम से ही पढ़ें इसे पढ़ें और अभ्यास पूरा करें

Android ऐप्स बनाने के आपके अनुभव का मूल्यांकन कैसे करेंगे?

नौसिखिए मध्यम प्रवीण

2. नमूना कोड प्राप्त करें

कमांड लाइन से GitHub रिपॉजिटरी को क्लोन करें।

$ git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-android.git

3. स्टार्टर ऐप आयात करें

से एंड्रॉयड स्टूडियो, चयन codelab-recommendations-android निर्देशिका ( android_studio_folder.png ) नमूना कोड डाउनलोड (फ़ाइल से> ओपन> ... / codelab-सिफारिशों-एंड्रॉयड / शुरू)।

अब आपके पास एंड्रॉइड स्टूडियो में स्टार्ट प्रोजेक्ट खुला होना चाहिए।

4. फायरबेस कंसोल प्रोजेक्ट बनाएं

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

  1. पर जाएं Firebase कंसोल
  2. परियोजना जोड़ें का चयन करें (या एक प्रोजेक्ट बना अगर यह पहले एक है)।
  3. का चयन करें या एक परियोजना नाम दर्ज करें और जारी रखें क्लिक करें।
  4. सुनिश्चित करें कि "इस प्रोजेक्ट के लिए Google Analytics सक्षम करें" सक्षम है।
  5. फायरबेस कंसोल में शेष सेटअप चरणों का पालन करें, फिर प्रोजेक्ट बनाएं (या फायरबेस जोड़ें, यदि आप किसी मौजूदा Google प्रोजेक्ट का उपयोग कर रहे हैं) पर क्लिक करें।

5. फायरबेस जोड़ें

  1. अपने नए प्रोजेक्ट की ओवरव्यू स्क्रीन से, सेटअप वर्कफ़्लो लॉन्च करने के लिए Android आइकन पर क्लिक करें।
  2. Codelab का पैकेज नाम डालें: com.google.firebase.codelabs.recommendations
  3. रजिस्टर ऐप्स चुनें।

अपने ऐप में google-services.json फ़ाइल जोड़ें

पैकेज का नाम जोड़ने और रजिस्टर चयन करने के बाद, अपने Firebase एंड्रॉयड कॉन्फ़िग फ़ाइल प्राप्त करने के लिए क्लिक करें डाउनलोड गूगल-services.json तो में गूगल-services.json फ़ाइल की प्रतिलिपि app अपनी परियोजना में निर्देशिका। बाद फ़ाइल डाउनलोड किया जाता है आप (वे पहले से ही निर्माण एंड्रॉयड शुरू परियोजना में आप के लिए किया गया है) कंसोल में दिखाया गया है अगले चरणों के छोड़ सकते हैं।

अपने ऐप में google-services प्लगइन जोड़ें

google-services प्लगइन Firebase का उपयोग करने के लिए आपके एप्लिकेशन को कॉन्फ़िगर करने के लिए google-services.json फ़ाइल का उपयोग करता है। निम्नलिखित पंक्तियों को पहले से ही प्रोजेक्ट में बिल्ड.ग्रेडल फाइलों में जोड़ा जाना चाहिए (पुष्टि करने के लिए जांचें):

ऐप/बिल्ड ग्रेड

apply plugin: 'com.google.gms.google-services'

बिल्ड.ग्रेड

classpath 'com.google.gms:google-services:4.3.4'

अपने प्रोजेक्ट को ग्रेडल फाइलों के साथ सिंक करें

यह सुनिश्चित करने के लिए कि आपके ऐप के लिए सभी निर्भरताएं उपलब्ध हैं, आपको इस बिंदु पर अपनी परियोजना को ग्रेडल फाइलों के साथ सिंक करना चाहिए। फ़ाइल> एंड्रॉयड स्टूडियो उपकरण पट्टी से Gradle फ़ाइलें के साथ सिंक परियोजना।

6. स्टार्टर ऐप चलाएं

अब जब कि तुम एंड्रॉयड स्टूडियो में परियोजना आयातित और कॉन्फ़िगर किया google-services अपने JSON फ़ाइल के साथ प्लगइन, आप पहली बार इस एप्लिकेशन को चलाने के लिए तैयार हैं। अपने Android डिवाइस से कनेक्ट करें, और चलाएं क्लिक करें ( निष्पादित.png ) एंड्रॉइड स्टूडियो टूलबार में।

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

7. ऐप में फायरबेस एनालिटिक्स जोड़ें

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

Firebase Analytics निर्भरता जोड़ें

अपने ऐप्लिकेशन में Firebase Analytics जोड़ने के लिए निम्न निर्भरता आवश्यक है. इसे पहले से ही ऐप/बिल्ड.ग्रेड फ़ाइल (सत्यापित) में शामिल किया जाना चाहिए।

ऐप/बिल्ड ग्रेड

implementation 'com.google.firebase:firebase-analytics-ktx:17.6.0'

ऐप में फायरबेस एनालिटिक्स सेट करें

LikedMoviesViewModel फिल्में उपयोगकर्ता पसंद करती है स्टोर करने के लिए कार्यों में शामिल है। हर बार जब उपयोगकर्ता कोई नई फिल्म पसंद करता है, तो हम उसे रिकॉर्ड करने के लिए एक एनालिटिक्स लॉग इवेंट भी भेजना चाहते हैं।

जब उपयोगकर्ता किसी मूवी की तरह क्लिक करता है तो एक एनालिटिक्स ईवेंट पंजीकृत करने के लिए नीचे दिए गए कोड के साथ onMovieLiked फ़ंक्शन जोड़ें।

पसंद की गई MoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {

    ...

    fun onMovieLiked(movie: Movie) {
        movies.setLike(movie, true)
        logAnalyticsEvent(movie.id.toString())
    }
       
}

जब उपयोगकर्ता की पसंद की सूची में कोई मूवी जोड़ी जाती है, तो Analytics ईवेंट लॉग करने के लिए निम्न फ़ील्ड और फ़ंक्शन जोड़ें।

पसंद की गई MoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {
    ...
    private val firebaseAnalytics = Firebase.analytics

    ...

    /**
     * Logs an event in Firebase Analytics that is used in aggregate to train the recommendations
     * model.
     */
    private fun logAnalyticsEvent(id: String) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.SELECT_ITEM) {
            param(FirebaseAnalytics.Param.ITEM_ID, id)
        }
    }

8. अपने Analytics एकीकरण का परीक्षण करें

इस चरण में, हम ऐप्लिकेशन में Analytics ईवेंट जेनरेट करेंगे और सत्यापित करेंगे कि उन्हें Firebase कंसोल पर भेजा जा रहा है।

Analytics डीबग लॉगिंग सक्षम करें

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

टर्मिनल

adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations

सत्यापित करें कि Analytics ईवेंट जेनरेट किए गए हैं

  1. एंड्रॉइड स्टूडियो में, अपने ऐप से लॉगिंग की जांच करने के लिए लॉगकैट विंडो खोलें।
  2. लॉगकैट फ़िल्टर को "लॉगिंग इवेंट" स्ट्रिंग पर सेट करें।
  3. सत्यापित करें कि "select_item" Analytics ईवेंट हर बार जब आप ऐप में कोई फिल्म पसंद करते हैं तो उत्सर्जित होते हैं।

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

वैकल्पिक: Firebase कंसोल में पुष्टि Analytics ईवेंट

  1. पर जाएं Firebase कंसोल
  2. एनालिटिक्स के तहत DebugView का चयन करें
  3. एंड्रॉयड स्टूडियो में, एप्लिकेशन को लॉन्च करने भागो का चयन करें और अपने पसंद आया सूची में कुछ फिल्मों में जोड़ें।
  4. Firebase कंसोल के DebugView में, सत्यापित करें कि जब आप ऐप में मूवी जोड़ते हैं तो ये ईवेंट लॉग किए जा रहे हैं।

9. Analytics डेटा को बड़ी क्वेरी में निर्यात करें

Big Query एक Google क्लाउड उत्पाद है जो आपको बड़ी मात्रा में डेटा की जांच करने और संसाधित करने की अनुमति देता है। इस चरण में, आप अपने Firebase कंसोल प्रोजेक्ट को Big Query से कनेक्ट करेंगे, ताकि आपके ऐप्लिकेशन द्वारा जेनरेट किया गया Analytics डेटा स्वचालित रूप से Big Query में निर्यात हो जाए।

बड़ी क्वेरी निर्यात सक्षम करें

  1. पर जाएं Firebase कंसोल
  2. परियोजना अवलोकन के आगे सेटिंग गियर आइकन चुनें, और उसके बाद परियोजना सेटिंग्स का चयन
  3. एकीकरण टैब चुनें।
  4. लिंक का चयन करें (या प्रबंधित) BigQuery ब्लॉक के अंदर।
  5. BigQuery कदम के आगे में लिंकिंग Firebase बारे में का चयन करें।
  6. कॉन्फ़िगर एकीकरण अनुभाग के अंतर्गत, Google Analytics डेटा भेजना सक्षम और BigQuery के लिए लिंक का चयन करने के लिए स्विच पर क्लिक करें।

अब आपने अपने Firebase कंसोल प्रोजेक्ट को Big Query को Firebase Analytics इवेंट डेटा अपने आप भेजने के लिए सक्षम कर दिया है। यह बिना किसी और इंटरैक्शन के अपने आप हो जाता है, हालांकि, हो सकता है कि BigQuery में एनालिटिक्स डेटासेट बनाने वाला पहला निर्यात 24 घंटों तक न हो. डेटासेट बनने के बाद, Firebase लगातार नए Analytics इवेंट को Big Query में इंट्राडे टेबल में एक्सपोर्ट करता है, और पिछले दिनों के इवेंट्स को इवेंट टेबल में ग्रुप करता है।

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

10. मॉडल प्रशिक्षण डेटा प्राप्त करने के लिए BigQuery का उपयोग करें

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

नमूना डेटासेट को BigQuery में आयात करें

  1. पर जाएं BigQuery Google क्लाउड कंसोल में डैशबोर्ड।
  2. मेनू में अपने प्रोजेक्ट का नाम चुनें।
  3. विवरण देखने के लिए BigQuery बाएं नेविगेशन के निचले भाग में अपना प्रोजेक्ट नाम चुनें.
  4. डाटासेट बनाएं डाटासेट निर्माण पैनल खोलने के लिए का चयन करें।
  5. डेटासेट आईडी के लिए 'firebase_recommendations_dataset' दर्ज करें और डाटासेट बनाएं चुनें।
  6. नया डेटासेट प्रोजेक्ट नाम के तहत बाएं मेनू में दिखाई देगा। इसे क्लिक करें।
  7. तालिका बनाएं तालिका बनाने पैनल खोलने के लिए का चयन करें।
  8. चुनिंदा 'Google क्लाउड मेमोरी' से तालिका बनाएं लिए।
  9. GCS बाल्टी क्षेत्र से फ़ाइल का चयन में, ': //firebase-recommendations/recommendations-test/formatted_data_filtered.txt gs' दर्ज करें।
  10. फ़ाइल प्रारूप में 'JSONL' का चयन करें ड्रॉप डाउन।
  11. तालिका नाम के लिए 'recommendations_table' दर्ज करें।
  12. स्कीमा के तहत बॉक्स को चेक करें> ऑटो का पता लगाने> स्कीमा और इनपुट पैरामीटर
  13. तालिका बनाएँ का चयन करें

नमूना डेटासेट का अन्वेषण करें

इस बिंदु पर, आप वैकल्पिक रूप से स्कीमा को एक्सप्लोर कर सकते हैं और इस डेटासेट का पूर्वावलोकन कर सकते हैं।

  1. चुनें firebase-सिफारिशों-डाटासेट बाएं मेनू में टेबल इसमें विस्तार करने के लिए।
  2. तालिका स्कीमा देखने पर सिफारिशें की मेज तालिका का चयन करें।
  3. वास्तविक Analytics ईवेंट डेटा इस तालिका में शामिल है देखने के लिए पूर्वावलोकन का चयन करें।

सेवा खाता क्रेडेंशियल बनाएं

अब, हम अपने Google क्लाउड कंसोल प्रोजेक्ट में सेवा खाता क्रेडेंशियल बनाएंगे जिसका उपयोग हम अपने BigQuery डेटा तक पहुंचने और लोड करने के लिए निम्नलिखित चरण में Colab परिवेश में कर सकते हैं।

  1. सुनिश्चित करें कि आपके Google क्लाउड प्रोजेक्ट के लिए बिलिंग सक्षम है।
  2. BigQuery और BigQuery संग्रहण API API सक्षम करें. < यहां क्लिक करें >
  3. पर जाएं सेवा खाता कुंजी बनाएं पेज
  4. सेवा खाते सूची से, नई सेवा खाते का चयन करें।
  5. सेवा खाता नाम फ़ील्ड में, कोई नाम दर्ज करें।
  6. भूमिका सूची से, परियोजना> स्वामी का चयन करें।
  7. बनाएँ क्लिक करें। एक JSON फ़ाइल जिसमें आपकी कुंजी आपके कंप्यूटर पर डाउनलोड होती है।

अगले चरण में, हम इस डेटा को प्रीप्रोसेस करने और अपने अनुशंसा मॉडल को प्रशिक्षित करने के लिए Google Colab का उपयोग करेंगे।

11. प्रीप्रोसेस डेटा और ट्रेन अनुशंसा मॉडल

इस चरण में, हम निम्नलिखित चरणों को करने के लिए Colab नोटबुक का उपयोग करेंगे:

  1. Colab नोटबुक में BigQuery डेटा आयात करें
  2. मॉडल प्रशिक्षण के लिए इसे तैयार करने के लिए डेटा को प्रीप्रोसेस करें
  3. एनालिटिक्स डेटा पर अनुशंसा मॉडल को प्रशिक्षित करें
  4. मॉडल को TF लाइट मॉडल के रूप में निर्यात करें
  5. मॉडल को फायरबेस कंसोल में तैनात करें ताकि हम इसे अपने ऐप में उपयोग कर सकें

Colab प्रशिक्षण नोटबुक लॉन्च करने से पहले, हम सबसे पहले Firebase मॉडल प्रबंधन API को सक्षम करेंगे, ताकि Colab हमारे Firebase कंसोल पर प्रशिक्षित मॉडल को परिनियोजित कर सके।

Firebase मॉडल प्रबंधन API सक्षम करें

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

अपने फायरबेस कंसोल में, स्टोरेज पर जाएं और गेट स्टार्ट पर क्लिक करें। fbbea78f0eb3dc9f.png

अपनी बाल्टी सेट करने के लिए संवाद का पालन करें।

19517c0d6d2aa14d.png

फायरबेस एमएल एपीआई सक्षम करें

पर जाएं Firebase एमएल API पृष्ठ Google क्लाउड कंसोल पर और सक्षम करें क्लिक करें।

मॉडल को प्रशिक्षित और परिनियोजित करने के लिए Colab नोटबुक का उपयोग करें

निम्नलिखित लिंक का उपयोग करके कोलाब नोटबुक खोलें और चरणों को पूरा करें। Colab नोटबुक में चरणों को पूरा करने के बाद, आपके पास Firebase कंसोल पर तैनात एक TF लाइट मॉडल फ़ाइल होगी जिसे हम अपने ऐप में सिंक कर सकते हैं।

Colab . में खुला

12. अपने ऐप में मॉडल डाउनलोड करें

इस चरण में, हम अपने ऐप को उस मॉडल को डाउनलोड करने के लिए संशोधित करेंगे जिसे हमने अभी-अभी फायरबेस मशीन लर्निंग से प्रशिक्षित किया है।

फायरबेस एमएल निर्भरता जोड़ें

आपके ऐप में फायरबेस मशीन लर्निंग मॉडल का उपयोग करने के लिए निम्नलिखित निर्भरता की आवश्यकता है। इसे पहले ही जोड़ा जाना चाहिए (सत्यापित करें)।

ऐप/बिल्ड ग्रेड

implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.4'

फायरबेस मॉडल मैनेजर एपीआई के साथ मॉडल डाउनलोड करें

जिसके तहत मॉडल डाउनलोड होता है की स्थापना की और हमारे अनुप्रयोग के लिए दूरदराज के मॉडल को सिंक करने में डाउनलोड कार्य बनाने के लिए नीचे दिए गए कोड को कॉपी RecommendationClient.kt में।

सिफारिशक्लाइंट.kt

    private fun downloadModel(modelName: String) {
        val remoteModel = FirebaseCustomRemoteModel.Builder(modelName).build()
        val firebaseModelManager = FirebaseModelManager.getInstance()
        firebaseModelManager
            .isModelDownloaded(remoteModel)
            .continueWithTask { task ->
                // Create update condition if model is already downloaded, otherwise create download
                // condition.
                val conditions = if (task.result != null && task.result == true) {
                    FirebaseModelDownloadConditions.Builder()
                        .requireWifi()
                        .build() // Update condition that requires wifi.
                } else {
                    FirebaseModelDownloadConditions.Builder().build(); // Download condition.
                }
                firebaseModelManager.download(remoteModel, conditions)
            }
            .addOnSuccessListener {
                firebaseModelManager.getLatestModelFile(remoteModel)
                    .addOnCompleteListener {
                        val model = it.result
                        if (model == null) {
                            showToast(context, "Failed to get model file.")
                        } else {
                            showToast(context, "Downloaded remote model")
                            GlobalScope.launch { initializeInterpreter(model) }
                        }
                    }
            }
            .addOnFailureListener {
                showToast(context, "Model download failed for recommendations, please check your connection.")
            }
    }



13. अपने ऐप में Tensorflow Lite अनुशंसा मॉडल को एकीकृत करें

Tensorflow Lite रनटाइम आपको अनुशंसाएँ उत्पन्न करने के लिए ऐप में अपने मॉडल का उपयोग करने देगा। पिछले चरण में हमने डाउनलोड की गई मॉडल फ़ाइल के साथ एक TFlite दुभाषिया प्रारंभ किया। इस चरण में, हम पहले अपने मॉडल के साथ अनुमान चरण में एक शब्दकोश और लेबल लोड करेंगे, फिर हम अपने मॉडल और पोस्ट-प्रोसेसिंग में इनपुट उत्पन्न करने के लिए प्री-प्रोसेसिंग जोड़ देंगे जहां हम अपने अनुमान से परिणाम निकालेंगे .

लोड शब्दकोश और लेबल

सिफारिशों मॉडल के आधार पर सिफारिश उम्मीदवारों उत्पन्न करने के लिए इस्तेमाल किया लेबल रेस में फ़ाइल sorted_movie_vocab.json में सूचीबद्ध हैं / संपत्ति फ़ोल्डर। इन उम्मीदवारों को लोड करने के लिए निम्नलिखित कोड को कॉपी करें।

सिफारिशक्लाइंट.kt

    /** Load recommendation candidate list.  */
    private suspend fun loadCandidateList() {
        return withContext(Dispatchers.IO) {
            val collection = MovieRepository.getInstance(context).getContent()
            for (item in collection) {
                candidates[item.id] = item
            }
            Log.v(TAG, "Candidate list loaded.")
        }
    }

प्री-प्रोसेसिंग लागू करें

प्री-प्रोसेसिंग चरण में, हम अपने मॉडल की अपेक्षा से मेल खाने के लिए इनपुट डेटा के रूप को बदलते हैं। यहां, हम इनपुट लंबाई को प्लेसहोल्डर मान के साथ पैड करते हैं यदि हमने पहले से ही बहुत सारे उपयोगकर्ता पसंद उत्पन्न नहीं किए हैं। नीचे दिए गए कोड को कॉपी करें:

सिफारिशक्लाइंट.kt

    /** Given a list of selected items, preprocess to get tflite input.  */
    @Synchronized
    private suspend fun preprocess(selectedMovies: List<Movie>): IntArray {
        return withContext(Dispatchers.Default) {
            val inputContext = IntArray(config.inputLength)
            for (i in 0 until config.inputLength) {
                if (i < selectedMovies.size) {
                    val (id) = selectedMovies[i]
                    inputContext[i] = id
                } else {
                    // Padding input.
                    inputContext[i] = config.pad
                }
            }
            inputContext
        }
    }


अनुशंसाएँ उत्पन्न करने के लिए दुभाषिया चलाएँ

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

सिफारिशक्लाइंट.kt

    /** Given a list of selected items, and returns the recommendation results.  */
    @Synchronized
    suspend fun recommend(selectedMovies: List<Movie>): List<Result> {
        return withContext(Dispatchers.Default) {
            val inputs = arrayOf<Any>(preprocess(selectedMovies))

            // Run inference.
            val outputIds = IntArray(config.outputLength)
            val confidences = FloatArray(config.outputLength)
            val outputs: MutableMap<Int, Any> = HashMap()
            outputs[config.outputIdsIndex] = outputIds
            outputs[config.outputScoresIndex] = confidences
            tflite?.let {
                it.runForMultipleInputsOutputs(inputs, outputs)
                postprocess(outputIds, confidences, selectedMovies)
            } ?: run {
                Log.e(TAG, "No tflite interpreter loaded")
                emptyList()
            }
        }
    }



पोस्ट-प्रोसेसिंग लागू करें

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

सिफारिशक्लाइंट.kt

    /** Postprocess to gets results from tflite inference.  */
    @Synchronized
    private suspend fun postprocess(
        outputIds: IntArray, confidences: FloatArray, selectedMovies: List<Movie>
    ): List<Result> {
        return withContext(Dispatchers.Default) {
            val results = ArrayList<Result>()

            // Add recommendation results. Filter null or contained items.
            for (i in outputIds.indices) {
                if (results.size >= config.topK) {
                    Log.v(TAG, String.format("Selected top K: %d. Ignore the rest.", config.topK))
                    break
                }
                val id = outputIds[i]
                val item = candidates[id]
                if (item == null) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is null", i, id))
                    continue
                }
                if (selectedMovies.contains(item)) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is contained", i, id))
                    continue
                }
                val result = Result(
                    id, item,
                    confidences[i]
                )
                results.add(result)
                Log.v(TAG, String.format("Inference output[%d]. Result: %s", i, result))
            }
            results
        }
    }


अपने ऐप का परीक्षण करें!

अपने ऐप को फिर से चलाएँ। जैसे ही आप कुछ फिल्मों का चयन करते हैं, इसे स्वचालित रूप से नया मॉडल डाउनलोड करना चाहिए और सिफारिशें उत्पन्न करना शुरू कर देना चाहिए!

14. बधाई!

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

हमने क्या कवर किया है

  • फायरबेस एमएल
  • फायरबेस एनालिटिक्स
  • Analytics ईवेंट को BigQuery में निर्यात करें
  • प्रीप्रोसेस एनालिटिक्स इवेंट
  • ट्रेन की सिफारिशें TensorFlow मॉडल
  • मॉडल निर्यात करें और Firebase कंसोल में परिनियोजित करें
  • एक ऐप में मूवी अनुशंसाओं की सेवा करें

अगला कदम

  • अपने ऐप्लिकेशन में Firebase ML अनुशंसाएं लागू करें.

और अधिक जानें

एक सवाल है?

रिपोर्ट के मुद्दे