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

1 अवलोकन

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

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

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

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

  • उपयोगकर्ता व्यवहार डेटा एकत्र करने के लिए फायरबेस एनालिटिक्स को एक एंड्रॉइड ऐप में एकीकृत करें
  • उस डेटा को 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-recommendations-android/start)।

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

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

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

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

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

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

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

पैकेज का नाम जोड़ने और रजिस्टर का चयन करने के बाद, अपनी फ़ायरबेस एंड्रॉइड कॉन्फ़िगरेशन फ़ाइल प्राप्त करने के लिए google-services.json डाउनलोड करें पर क्लिक करें, फिर google-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'

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

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

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

अब जब आपने प्रोजेक्ट को एंड्रॉइड स्टूडियो में आयात कर लिया है और अपनी JSON फ़ाइल के साथ google-services प्लगइन को कॉन्फ़िगर कर लिया है, तो आप पहली बार ऐप चलाने के लिए तैयार हैं। अपने 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. फायरबेस कंसोल पर जाएं।
  2. Analytics के अंतर्गत DebugView चुनें
  3. एंड्रॉइड स्टूडियो में, ऐप लॉन्च करने के लिए रन चुनें और अपनी पसंद की सूची में कुछ फिल्में जोड़ें।
  4. Firebase कंसोल के DebugView में, सत्यापित करें कि जब आप ऐप में मूवी जोड़ते हैं तो ये ईवेंट लॉग किए जा रहे हैं।

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

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

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

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

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

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

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

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

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

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

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

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

  1. इसमें शामिल तालिकाओं का विस्तार करने के लिए बाएं मेनू में फायरबेस-सिफारिशें-डेटासेट का चयन करें।
  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

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

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 दुभाषिया प्रारंभ किया। इस चरण में, हम पहले अपने मॉडल के साथ अनुमान चरण में एक शब्दकोश और लेबल लोड करेंगे, फिर हम अपने मॉडल और पोस्ट-प्रोसेसिंग में इनपुट उत्पन्न करने के लिए प्री-प्रोसेसिंग जोड़ देंगे जहां हम अपने अनुमान से परिणाम निकालेंगे .

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

अनुशंसा मॉडल द्वारा अनुशंसा उम्मीदवारों को उत्पन्न करने के लिए उपयोग किए जाने वाले लेबल res/assets फ़ोल्डर में 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 अनुशंसाएं लागू करें.

और अधिक जानें

एक सवाल है?

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