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

1 अवलोकन

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Android Studio से, codelab-recommendations-android निर्देशिका चुनें ( android_studio_folder.png ) सैंपल कोड डाउनलोड से ( File > Open > .../codelab-recommendations-android/start)।

अब आपके पास Android Studio में स्टार्ट प्रोजेक्ट खुला होना चाहिए।

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 प्लगइन जोड़ें

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

ऐप/बिल्ड.ग्रेड.केटीएस

plugins {
    id("com.google.gms.google-services")
}

बिल्ड.ग्रेड.केटीएस

plugins {
    id("com.google.gms.google-services") version "4.3.15" apply false
}

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

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

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

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

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

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

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

सामग्री और विश्लेषिकी निर्भरता का फायरबेस बिल जोड़ें

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

ऐप/बिल्ड.ग्रेड.केटीएस

implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")

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

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

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

पसंद किया गया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())
    }
       
}

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

पसंद किया गया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. अपने विश्लेषिकी एकीकरण का परीक्षण करें

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

एनालिटिक्स डीबग लॉगिंग सक्षम करें

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

टर्मिनल

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

सत्यापित करें कि एनालिटिक्स ईवेंट उत्पन्न होते हैं

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

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

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

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

9. एनालिटिक्स डेटा को बिग क्वेरी में निर्यात करें

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

Big Query निर्यात सक्षम करें

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

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

अनुशंसा मॉडल को प्रशिक्षित करने के लिए बहुत अधिक डेटा की आवश्यकता होती है। चूंकि हमारे पास पहले से बड़ी मात्रा में डेटा जनरेट करने वाला ऐप नहीं है, इसलिए अगले चरण में हम इस ट्यूटोरियल के बाकी हिस्सों में उपयोग करने के लिए 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. तालिका नाम के लिए 'सिफारिशें_टेबल' दर्ज करें।
  12. स्कीमा> ऑटो डिटेक्ट> स्कीमा और इनपुट पैरामीटर के तहत बॉक्स को चेक करें
  13. तालिका बनाएं चुनें

नमूना डेटासेट एक्सप्लोर करें

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

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

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

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

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

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

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

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

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

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

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

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

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

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

19517c0d6d2aa14d.png

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

Google क्लाउड कंसोल पर फायरबेस एमएल एपीआई पेज पर जाएं और सक्षम करें पर क्लिक करें।

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

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

कोलाब में खोलें

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

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

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

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

ऐप/बिल्ड.ग्रेड.केटीएस

implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")

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

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

सिफारिशClient.kt

    private fun downloadModel(modelName: String) {
        val conditions = CustomModelDownloadConditions.Builder()
            .requireWifi()
            .build()
        FirebaseModelDownloader.getInstance()
            .getModel(modelName, DownloadType.LOCAL_MODEL, conditions)
            .addOnCompleteListener {
                if (!it.isSuccessful) {
                    showToast(context, "Failed to get model file.")
                } else {
                    showToast(context, "Downloaded remote model: $modelName")
                    GlobalScope.launch { initializeInterpreter(it.result) }
                }
            }
            .addOnFailureListener {
                showToast(context, "Model download failed for recommendations, please check your connection.")
            }
    }

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

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

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

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

सिफारिशClient.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.")
        }
    }

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

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

सिफारिशClient.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
        }
    }

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

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

सिफारिशClient.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()
            }
        }
    }

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

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

सिफारिशClient.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 सुझावों को लागू करें।

और अधिक जानें

एक सवाल है?

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