Fügen Sie Ihrer App mit TensorFlow Lite und Firebase - Android Codelab Empfehlungen hinzu

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

1. Übersicht

Willkommen beim Codelab „Empfehlungen mit TensorFlow Lite und Firebase“. In diesem Codelab erfahren Sie, wie Sie mit TensorFlow Lite und Firebase ein Empfehlungsmodell für Ihre App bereitstellen. Dieses Codelab basiert auf diesem TensorFlow Lite- Beispiel .

Empfehlungen ermöglichen es Apps, maschinelles Lernen zu nutzen, um auf intelligente Weise die relevantesten Inhalte für jeden Benutzer bereitzustellen. Sie berücksichtigen das vergangene Benutzerverhalten, um App-Inhalte vorzuschlagen, mit denen der Benutzer möglicherweise in Zukunft interagieren möchte, indem sie ein Modell verwenden, das auf das Gesamtverhalten einer großen Anzahl anderer Benutzer trainiert wurde.

In dieser Anleitung erfahren Sie, wie Sie mit Firebase Analytics Daten von den Benutzern Ihrer App abrufen, ein maschinelles Lernmodell für Empfehlungen aus diesen Daten erstellen und dieses Modell dann in einer Android-App verwenden, um Inferenzen auszuführen und Empfehlungen zu erhalten. Insbesondere schlagen unsere Empfehlungen vor, welche Filme ein Benutzer angesichts der Liste der Filme, die dem Benutzer zuvor gefallen haben, am wahrscheinlichsten ansehen würde.

Was Sie lernen werden

  • Integrieren Sie Firebase Analytics in eine Android-App, um Daten zum Benutzerverhalten zu sammeln
  • Exportieren Sie diese Daten in Google Big Query
  • Vorverarbeiten der Daten und Trainieren eines TF Lite-Empfehlungsmodells
  • Stellen Sie das TF Lite-Modell in Firebase ML bereit und greifen Sie über Ihre App darauf zu
  • Ausführung auf Geräteinferenz mithilfe des Modells, um Benutzern Empfehlungen vorzuschlagen

Was du brauchen wirst

  • Android Studio-Version 3.4+.
  • Beispielcode.
  • Ein Testgerät mit Android 2.3+ und Google Play-Diensten 9.8 oder höher oder ein Emulator mit Google Play-Diensten 9.8 oder höher
  • Bei Verwendung eines Geräts ein Verbindungskabel.

Wie werden Sie dieses Tutorial verwenden?

Nur durchlesen Lies es und vervollständige die Übungen

Wie würden Sie Ihre Erfahrung beim Erstellen von Android-Apps bewerten?

Anfänger Dazwischenliegend Kompetent

2. Holen Sie sich den Beispielcode

Klonen Sie das GitHub-Repository über die Befehlszeile.

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

3. Importieren Sie die Starter-App

Wählen Sie in Android Studio das codelab-recommendations-android ( android_studio_folder.png ) aus dem Beispielcode-Download ( Datei > Öffnen > .../codelab-recommendations-android/start).

Sie sollten nun das Startprojekt in Android Studio geöffnet haben.

4. Erstellen Sie ein Firebase-Konsolenprojekt

Erstellen Sie ein neues Projekt

  1. Gehen Sie zur Firebase-Konsole .
  2. Wählen Sie Projekt hinzufügen (oder Projekt erstellen, wenn es das erste ist).
  3. Wählen Sie einen Projektnamen aus oder geben Sie ihn ein und klicken Sie auf Weiter .
  4. Stellen Sie sicher, dass „Google Analytics für dieses Projekt aktivieren“ aktiviert ist.
  5. Befolgen Sie die verbleibenden Einrichtungsschritte in der Firebase-Konsole und klicken Sie dann auf Projekt erstellen (oder Firebase hinzufügen, wenn Sie ein vorhandenes Google-Projekt verwenden).

5. Fügen Sie Firebase hinzu

  1. Klicken Sie auf dem Übersichtsbildschirm Ihres neuen Projekts auf das Android-Symbol, um den Einrichtungsablauf zu starten.
  2. Geben Sie den Paketnamen des Codelabs ein: com.google.firebase.codelabs.recommendations
  3. Wählen Sie App registrieren aus .

Fügen Sie Ihrer App die Datei google-services.json hinzu

Nachdem Sie den Paketnamen hinzugefügt und Registrieren ausgewählt haben, klicken Sie auf Download google-services.json , um Ihre Firebase-Android-Konfigurationsdatei abzurufen, und kopieren Sie dann die Datei google-services.json in das app -Verzeichnis in Ihrem Projekt. Nachdem die Datei heruntergeladen wurde, können Sie die nächsten in der Konsole angezeigten Schritte überspringen (sie wurden bereits im build-android-start-Projekt für Sie erledigt).

Fügen Sie Ihrer App das Plug-in für Google-Dienste hinzu

Das Google-Services-Plug-in verwendet die Datei „google-services.json“, um Ihre Anwendung für die Verwendung von Firebase zu konfigurieren. Die folgenden Zeilen sollten bereits zu den build.gradle-Dateien im Projekt hinzugefügt werden (zur Bestätigung überprüfen):

app/build.grade

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

build.grade

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

Synchronisieren Sie Ihr Projekt mit Gradle-Dateien

Um sicherzustellen, dass alle Abhängigkeiten für Ihre App verfügbar sind, sollten Sie Ihr Projekt an dieser Stelle mit Gradle-Dateien synchronisieren. Wählen Sie in der Symbolleiste von Android Studio Datei > Projekt mit Gradle-Dateien synchronisieren.

6. Führen Sie die Starter-App aus

Nachdem Sie das Projekt in Android Studio importiert und das google-services Plugin mit Ihrer JSON-Datei konfiguriert haben, können Sie die App zum ersten Mal ausführen. Verbinden Sie Ihr Android-Gerät und klicken Sie auf Ausführen ( ausführen.png ) in der Symbolleiste von Android Studio.

Die App sollte auf Ihrem Gerät starten. An diesem Punkt können Sie eine funktionierende Anwendung sehen, die eine Registerkarte mit einer Liste von Filmen, eine Registerkarte „Gefällt mir“-Filme und eine Registerkarte „Empfehlungen“ anzeigt. Sie können auf einen Film in der Liste der Filme klicken, um ihn zu Ihrer Liste mit „Gefällt mir“ hinzuzufügen. Nachdem Sie die verbleibenden Schritte des Codelabs abgeschlossen haben, können wir Filmempfehlungen auf der Registerkarte „Empfehlungen“ generieren.

7. Fügen Sie der App Firebase Analytics hinzu

In diesem Schritt fügen Sie der App Firebase Analytics hinzu, um Daten zum Benutzerverhalten zu protokollieren (in diesem Fall, welche Filme einem Benutzer gefallen). Diese Daten werden in zukünftigen Schritten aggregiert verwendet, um das Empfehlungsmodell zu trainieren.

Fügen Sie eine Firebase Analytics-Abhängigkeit hinzu

Die folgende Abhängigkeit ist erforderlich, um Ihrer App Firebase Analytics hinzuzufügen. Es sollte bereits in der Datei app/build.gradle enthalten sein (überprüfen).

app/build.grade

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

Richten Sie Firebase Analytics in der App ein

Das LikedMoviesViewModel enthält Funktionen zum Speichern der Filme, die dem Benutzer gefallen. Jedes Mal, wenn dem Benutzer ein neuer Film gefällt, möchten wir auch ein Analyseprotokollereignis senden, um dieses Like aufzuzeichnen.

Fügen Sie die onMovieLiked-Funktion mit dem folgenden Code hinzu, um ein Analyseereignis zu registrieren, wenn der Benutzer auf „Gefällt mir“ auf einen Film klickt.

Gefällt mirMoviesViewModel.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())
    }
       
}

Fügen Sie das folgende Feld und die folgende Funktion hinzu, um ein Analytics-Ereignis zu protokollieren, wenn ein Film zur „Gefällt mir“-Liste des Benutzers hinzugefügt wird.

Gefällt mirMoviesViewModel.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. Testen Sie Ihre Analytics-Integration

In diesem Schritt generieren wir Analytics-Ereignisse in der App und überprüfen, ob sie an die Firebase-Konsole gesendet werden.

Aktivieren Sie die Analytics-Debug-Protokollierung

Firebase Analytics wurde entwickelt, um die Akkulaufzeit des Benutzers zu maximieren, und sammelt Ereignisse auf dem Gerät und sendet sie nur gelegentlich an Firebase. Zu Debugging-Zwecken können wir dieses Verhalten deaktivieren, um Ereignisse so zu sehen, wie sie in Echtzeit protokolliert werden, indem wir den folgenden Befehl in der Shell ausführen.

Terminal

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

Stellen Sie sicher, dass Analytics-Ereignisse generiert werden

  1. Öffnen Sie in Android Studio das Logcat-Fenster, um die Protokollierung von Ihrer App zu untersuchen.
  2. Setzen Sie den Logcat-Filter auf die Zeichenfolge „Logging event“.
  3. Vergewissern Sie sich, dass „select_item“-Analytics-Ereignisse jedes Mal ausgegeben werden, wenn Ihnen ein Film in der App gefällt.

An diesem Punkt haben Sie Firebase Analytics erfolgreich in Ihre App integriert. Wenn Benutzer Ihre App verwenden und Filme mögen, werden ihre Likes aggregiert protokolliert. Wir werden diese aggregierten Daten im Rest dieses Codelabs verwenden, um unser Empfehlungsmodell zu trainieren. Der folgende Schritt ist optional, um zu sehen, dass dieselben Analytics-Ereignisse, die Sie in Logcat gesehen haben, auch in die Firebase-Konsole gestreamt werden. Fühlen Sie sich frei, zur nächsten Seite zu springen.

Optional: Bestätigen Sie Analytics-Ereignisse in der Firebase Console

  1. Gehen Sie zur Firebase-Konsole .
  2. Wählen Sie DebugView unter Analytics aus
  3. Wählen Sie in Android Studio Ausführen aus, um die App zu starten und einige Filme zu Ihrer „Gefällt mir“-Liste hinzuzufügen.
  4. Überprüfen Sie in der DebugView der Firebase-Konsole, ob diese Ereignisse protokolliert werden, wenn Sie Filme in der App hinzufügen.

9. Exportieren Sie Analytics-Daten nach Big Query

Big Query ist ein Google Cloud-Produkt, mit dem Sie große Datenmengen untersuchen und verarbeiten können. In diesem Schritt verbinden Sie Ihr Firebase Console-Projekt mit Big Query, sodass die von Ihrer App generierten Analytics-Daten automatisch nach Big Query exportiert werden.

Big Query-Export aktivieren

  1. Gehen Sie zur Firebase-Konsole .
  2. Wählen Sie das Zahnradsymbol Einstellungen neben Projektübersicht und dann Projekteinstellungen aus
  3. Wählen Sie die Registerkarte Integrationen aus.
  4. Wählen Sie im BigQuery- Block Link (oder Manage ) aus.
  5. Wählen Sie im Schritt Über das Verknüpfen von Firebase mit BigQuery die Option Weiter aus .
  6. Klicken Sie im Abschnitt Integration konfigurieren auf den Schalter, um das Senden von Google Analytics-Daten zu aktivieren, und wählen Sie Mit BigQuery verknüpfen aus .

Sie haben Ihr Firebase-Konsolenprojekt jetzt aktiviert, um Firebase Analytics-Ereignisdaten automatisch an Big Query zu senden. Dies geschieht automatisch ohne weitere Interaktion, der erste Export, der das Analyse-Dataset in BigQuery erstellt, erfolgt jedoch möglicherweise erst nach 24 Stunden. Nachdem das Dataset erstellt wurde, exportiert Firebase kontinuierlich neue Analytics-Ereignisse nach Big Query in die Intraday-Tabelle und gruppiert Ereignisse vergangener Tage in der Ereignistabelle.

Für das Training eines Empfehlungsmodells sind viele Daten erforderlich. Da wir noch keine App haben, die große Datenmengen generiert, importieren wir im nächsten Schritt ein Beispiel-Dataset in BigQuery, um es für den Rest dieser Anleitung zu verwenden.

10. Verwenden Sie BigQuery, um Modelltrainingsdaten abzurufen

Nachdem wir unsere Firebase-Konsole für den Export nach BigQuery verbunden haben, werden unsere Anwendungsanalyse-Ereignisdaten nach einiger Zeit automatisch in der BigQuery-Konsole angezeigt. Um einige Anfangsdaten für die Zwecke dieser Anleitung zu erhalten, importieren wir in diesem Schritt ein vorhandenes Beispiel-Dataset in Ihre BigQuery-Konsole, um es zum Trainieren unseres Empfehlungsmodells zu verwenden.

Beispiel-Dataset in BigQuery importieren

  1. Rufen Sie das BigQuery- Dashboard in der Google Cloud-Konsole auf.
  2. Wählen Sie im Menü Ihren Projektnamen aus.
  3. Wählen Sie Ihren Projektnamen unten in der linken BigQuery-Navigation aus, um Details anzuzeigen.
  4. Wählen Sie Datensatz erstellen aus, um das Fenster zur Datensatzerstellung zu öffnen.
  5. Geben Sie als Datensatz- ID „firebase_recommendations_dataset“ ein und wählen Sie Datensatz erstellen aus.
  6. Der neue Datensatz wird im linken Menü unter dem Projektnamen angezeigt. Klick es.
  7. Wählen Sie Tabelle erstellen aus, um das Tabellenerstellungsfenster zu öffnen.
  8. Wählen Sie für Tabelle erstellen aus „Google Cloud Storage“ aus.
  9. Geben Sie im Feld Datei aus GCS-Bucket auswählen „gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt“ ein.
  10. Wählen Sie „JSONL“ im Dropdown-Menü „ Dateiformat “ aus.
  11. Geben Sie „recommendations_table“ als Tabellennamen ein .
  12. Aktivieren Sie das Kontrollkästchen unter Schema > Automatische Erkennung > Schema und Eingabeparameter
  13. Wählen Sie Tabelle erstellen aus

Erkunden Sie den Beispieldatensatz

An dieser Stelle können Sie optional das Schema untersuchen und dieses Dataset in der Vorschau anzeigen.

  1. Wählen Sie im linken Menü firebase-recommendations-dataset aus, um die darin enthaltenen Tabellen zu erweitern.
  2. Wählen Sie die Tabelle Recommendations-Table aus, um das Tabellenschema anzuzeigen.
  3. Wählen Sie Vorschau aus, um die tatsächlichen Analytics-Ereignisdaten anzuzeigen, die diese Tabelle enthält.

Anmeldedaten für das Dienstkonto erstellen

Jetzt erstellen wir in unserem Google Cloud-Konsolenprojekt Anmeldeinformationen für Dienstkonten, die wir im folgenden Schritt in der Colab-Umgebung verwenden können, um auf unsere BigQuery-Daten zuzugreifen und sie zu laden.

  1. Stellen Sie sicher, dass die Abrechnung für Ihr Google Cloud-Projekt aktiviert ist.
  2. Aktivieren Sie die APIs BigQuery und BigQuery Storage API. < hier klicken >
  3. Rufen Sie die Seite Dienstkontoschlüssel erstellen auf.
  4. Wählen Sie in der Liste Dienstkonto die Option Neues Dienstkonto aus .
  5. Geben Sie im Feld Dienstkontoname einen Namen ein.
  6. Wählen Sie in der Rollenliste Projekt > Eigentümer aus.
  7. Klicken Sie auf Erstellen . Eine JSON-Datei, die Ihre Schlüsseldownloads auf Ihren Computer enthält.

Im nächsten Schritt werden wir Google Colab verwenden, um diese Daten vorzuverarbeiten und unser Empfehlungsmodell zu trainieren.

11. Daten vorverarbeiten und Empfehlungsmodell trainieren

In diesem Schritt verwenden wir ein Colab-Notebook, um die folgenden Schritte auszuführen:

  1. Importieren Sie die BigQuery-Daten in das Colab-Notebook
  2. die Daten vorverarbeiten, um sie für das Modelltraining vorzubereiten
  3. Trainieren Sie das Empfehlungsmodell anhand der Analysedaten
  4. Exportieren Sie das Modell als TF-Lite-Modell
  5. Stellen Sie das Modell in der Firebase-Konsole bereit, damit wir es in unserer App verwenden können

Bevor wir das Colab-Schulungsnotebook starten, aktivieren wir zunächst die Firebase Model Management API, damit Colab das trainierte Modell auf unserer Firebase-Konsole bereitstellen kann.

Aktivieren Sie die Firebase Model Management API

Erstellen Sie einen Bucket zum Speichern Ihrer ML-Modelle

Gehen Sie in Ihrer Firebase-Konsole zu Speicher und klicken Sie auf Erste Schritte. fbbea78f0eb3dc9f.png

Folgen Sie dem Dialog, um Ihren Bucket einzurichten.

19517c0d6d2aa14d.png

Aktivieren Sie die Firebase ML-API

Gehen Sie in der Google Cloud Console zur Firebase ML API-Seite und klicken Sie auf Aktivieren.

Verwenden Sie das Colab-Notebook, um das Modell zu trainieren und bereitzustellen

Öffnen Sie das Colab-Notebook über den folgenden Link und führen Sie die darin enthaltenen Schritte aus. Nachdem Sie die Schritte im Colab-Notizbuch abgeschlossen haben, wird eine TF-Lite-Modelldatei auf der Firebase-Konsole bereitgestellt, die wir mit unserer App synchronisieren können.

In Colab öffnen

12. Laden Sie das Modell in Ihrer App herunter

In diesem Schritt ändern wir unsere App, um das Modell herunterzuladen, das wir gerade von Firebase Machine Learning trainiert haben.

Firebase ML-Abhängigkeit hinzufügen

Die folgende Abhängigkeit ist erforderlich, um Firebase Machine Learning-Modelle in Ihrer App zu verwenden. Es sollte bereits hinzugefügt werden (überprüfen).

app/build.grade

implementation 'com.google.firebase:firebase-ml-modeldownloader:24.0.4'

Laden Sie das Modell mit der Firebase Model Manager API herunter

Kopieren Sie den folgenden Code in RecommendationClient.kt , um die Bedingungen festzulegen, unter denen das Herunterladen des Modells erfolgt, und erstellen Sie eine Download-Aufgabe, um das Remote-Modell mit unserer App zu synchronisieren.

EmpfehlungKunde.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. Integrieren Sie das Empfehlungsmodell von Tensorflow Lite in Ihre App

Mit der Tensorflow Lite-Laufzeit können Sie Ihr Modell in der App verwenden, um Empfehlungen zu generieren. Im vorherigen Schritt haben wir einen TFlite-Interpreter mit der heruntergeladenen Modelldatei initialisiert. In diesem Schritt laden wir zuerst ein Wörterbuch und Beschriftungen, um unser Modell im Inferenzschritt zu begleiten, dann fügen wir eine Vorverarbeitung hinzu, um die Eingaben für unser Modell zu generieren, und eine Nachverarbeitung, bei der wir die Ergebnisse aus unserer Inferenz extrahieren .

Wörterbuch und Labels laden

Die Bezeichnungen, die zum Generieren der Empfehlungskandidaten durch das Empfehlungsmodell verwendet werden, sind in der Datei sorted_movie_vocab.json im Ordner „res/assets“ aufgeführt. Kopieren Sie den folgenden Code, um diese Kandidaten zu laden.

EmpfehlungKunde.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.")
        }
    }

Implementieren Sie die Vorverarbeitung

Im Vorverarbeitungsschritt ändern wir die Form der Eingabedaten, damit sie mit den Erwartungen unseres Modells übereinstimmen. Hier füllen wir die Eingabelänge mit einem Platzhalterwert auf, falls wir noch nicht viele User-Likes generiert haben. Kopieren Sie den folgenden Code:

EmpfehlungKunde.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
        }
    }


Führen Sie den Interpreter aus, um Empfehlungen zu generieren

Hier verwenden wir das Modell, das wir in einem vorherigen Schritt heruntergeladen haben, um Rückschlüsse auf unsere vorverarbeitete Eingabe zu ziehen. Wir legen die Art der Ein- und Ausgabe für unser Modell fest und führen Inferenzen aus, um unsere Filmempfehlungen zu generieren. Kopieren Sie den folgenden Code in Ihre App.

EmpfehlungKunde.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()
            }
        }
    }



Implementieren Sie die Nachbearbeitung

Schließlich verarbeiten wir in diesem Schritt die Ausgabe unseres Modells nach, wählen die Ergebnisse mit der höchsten Zuverlässigkeit aus und entfernen enthaltene Werte (Filme, die dem Benutzer bereits gefallen haben). Kopieren Sie den folgenden Code in Ihre App.

EmpfehlungKunde.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
        }
    }


Testen Sie Ihre App!

Führen Sie Ihre App erneut aus. Wenn Sie einige Filme auswählen, sollte das neue Modell automatisch heruntergeladen und Empfehlungen generiert werden!

14. Herzlichen Glückwunsch!

Sie haben mithilfe von TensorFlow Lite und Firebase eine Empfehlungsfunktion in Ihre App integriert. Beachten Sie, dass die in diesem Codelab gezeigten Techniken und Pipelines verallgemeinert und auch für andere Arten von Empfehlungen verwendet werden können.

Was wir abgedeckt haben

  • Firebase ML
  • Firebase-Analytics
  • Exportieren Sie Analyseereignisse nach BigQuery
  • Analyseereignisse vorverarbeiten
  • Zugempfehlungen TensorFlow-Modell
  • Modell exportieren und in Firebase Console bereitstellen
  • Servieren Sie Filmempfehlungen in einer App

Nächste Schritte

  • Implementieren Sie Firebase ML-Empfehlungen in Ihrer App.

Lern mehr

Eine Frage haben?

Probleme melden