1. Übersicht
|
|
Willkommen beim Codelab „Empfehlungen mit TensorFlow Lite und Firebase“. In diesem Codelab erfahren Sie, wie Sie TensorFlow Lite und Firebase verwenden, um ein Empfehlungsmodell in Ihrer App bereitzustellen. Dieses Codelab basiert auf diesem TensorFlow Lite-Beispiel.
Mit Empfehlungen können Apps maschinelles Lernen nutzen, um jedem Nutzer die relevantesten Inhalte zu präsentieren. Dabei wird das bisherige Nutzerverhalten berücksichtigt, um Inhalte der App vorzuschlagen, mit denen der Nutzer in Zukunft interagieren könnte. Dazu wird ein Modell verwendet, das auf dem aggregierten Verhalten einer großen Anzahl anderer Nutzer trainiert wurde.
In dieser Anleitung wird gezeigt, wie Sie mit Firebase Analytics Daten von den Nutzern Ihrer App erfassen, aus diesen Daten ein Machine-Learning-Modell für Empfehlungen erstellen und dieses Modell dann in einer Android-App verwenden, um Inferenz auszuführen und Empfehlungen zu erhalten. Insbesondere schlagen wir Filme vor, die sich ein Nutzer höchstwahrscheinlich ansehen würde, wenn man die Liste der Filme betrachtet, die er zuvor mit „Mag ich“ bewertet hat.
Lerninhalte
- Firebase Analytics in eine Android-App einbinden, um Daten zum Nutzerverhalten zu erheben
- Diese Daten in Google BigQuery exportieren
- Daten vorverarbeiten und ein TF Lite-Empfehlungsmodell trainieren
- TF Lite-Modell in Firebase ML bereitstellen und über Ihre App darauf zugreifen
- On-Device-Inferenz mit dem Modell ausführen, um Nutzern Empfehlungen zu geben
Voraussetzungen
- Die neueste Version von Android Studio.
- Beispielcode.
- Ein Testgerät mit Android 7 oder höher und Google Play-Dienste 9.8 oder höher oder ein Emulator mit Google Play-Dienste 9.8 oder höher
- Wenn Sie ein Gerät verwenden, ein Verbindungskabel.
Wie werden Sie diese Anleitung verwenden?
Wie würden Sie Ihre Erfahrung beim Erstellen von Android-Apps bewerten?
2. Beispielcode abrufen
Klonen Sie das GitHub-Repository über die Befehlszeile.
$ git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-android.git
3. Start-App importieren
Wählen Sie in Android Studio das Verzeichnis codelab-recommendations-android ( 
) aus dem Download des Beispielcodes aus (File > Open > .../codelab-recommendations-android/start).
Das Startprojekt sollte jetzt in Android Studio geöffnet sein.
4. Firebase Console-Projekt erstellen
Neues Projekt erstellen
- Rufen Sie die Firebase Console auf.
- Wählen Sie Projekt hinzufügen oder Projekt erstellen aus, wenn es das erste Projekt ist.
- Wählen Sie einen Projektnamen aus oder geben Sie einen ein und klicken Sie auf Weiter.
- Achten Sie darauf, dass „Google Analytics für dieses Projekt aktivieren“ aktiviert ist.
- Folgen Sie den verbleibenden Einrichtungsschritten in der Firebase Console und klicken Sie dann auf „Projekt erstellen“ (oder „Firebase hinzufügen“, wenn Sie ein vorhandenes Google-Projekt verwenden).
5. Firebase hinzufügen
- Klicken Sie auf dem Übersichtsbildschirm Ihres neuen Projekts auf das Android-Symbol, um den Einrichtungsworkflow zu starten.
- Geben Sie den Paketnamen des Codelabs ein:
com.google.firebase.codelabs.recommendations - Wählen Sie App registrieren aus.
Datei „google-services.json“ Ihrer App hinzufügen
Klicken Sie nach dem Hinzufügen des Paketnamens und der Auswahl von „Registrieren“ auf google-services.json herunterladen, um Ihre Firebase-Konfigurationsdatei für Android zu erhalten. Kopieren Sie dann die Datei „google-services.json“ in das Verzeichnis app in Ihrem Projekt. Nachdem die Datei heruntergeladen wurde, können Sie die nächsten Schritte in der Konsole überspringen, da sie bereits im Projekt „build-android-start“ ausgeführt wurden.
google-services-Plug-in zu Ihrer App hinzufügen
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 den Dateien „build.gradle.kts“ im Projekt hinzugefügt worden sein. Prüfen Sie das zur Sicherheit:
app/build.grade.kts
plugins {
id("com.google.gms.google-services")
}
build.grade.kts
plugins {
id("com.google.gms.google-services") version "4.3.15" apply false
}
Projekt mit Gradle-Dateien synchronisieren
Damit alle Abhängigkeiten für Ihre App verfügbar sind, sollten Sie Ihr Projekt jetzt mit Gradle-Dateien synchronisieren. Wählen Sie in der Android Studio-Symbolleiste File > Sync Project with Gradle Files aus.
6. Start-App ausführen
Nachdem Sie das Projekt in Android Studio importiert und das google-services-Plug-in 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 in der Android Studio-Symbolleiste auf Ausführen ( 
).
Die App sollte auf Ihrem Gerät gestartet werden. An diesem Punkt sehen Sie eine funktionierende Anwendung mit einem Tab mit einer Liste von Filmen, einem Tab „Gelikete Filme“ und einem Tab „Empfehlungen“. Wenn Sie einen Film in der Liste anklicken, wird er Ihrer Liste mit gelikten Filmen hinzugefügt. Nachdem Sie die restlichen Schritte des Codelabs abgeschlossen haben, können wir auf dem Tab „Empfehlungen“ Filmempfehlungen generieren.
7. Firebase Analytics zur App hinzufügen
In diesem Schritt fügen Sie Firebase Analytics der App hinzu, um Daten zum Nutzerverhalten zu protokollieren (in diesem Fall, welche Filme ein Nutzer mag). Diese Daten werden in den nächsten Schritten aggregiert verwendet, um das Empfehlungsmodell zu trainieren.
Firebase-Stückliste und Analytics-Abhängigkeit hinzufügen
Die folgenden Abhängigkeiten sind erforderlich, um Firebase Analytics in Ihre App einzubinden. Sie sollten bereits in der Datei „app/build.gradle.kts“ enthalten sein (bitte prüfen).
app/build.grade.kts
implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")
Firebase Analytics in der App einrichten
Das LikedMoviesViewModel enthält Funktionen zum Speichern der Filme, die dem Nutzer gefallen. Jedes Mal, wenn der Nutzer einen neuen Film liked, möchten wir auch ein Analyseprotokollereignis senden, um dieses Like zu erfassen.
Fügen Sie die Funktion „onMovieLiked“ mit dem folgenden Code hinzu, um ein Analytics-Ereignis zu registrieren, wenn der Nutzer auf „Gefällt mir“ klickt.
LikedMoviesViewModel.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 der Liste „Gefällt mir“ des Nutzers hinzugefügt wird.
LikedMoviesViewModel.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-Integration testen
In diesem Schritt generieren wir Analytics-Ereignisse in der App und prüfen, ob sie an die Firebase Console gesendet werden.
Debug-Logging für Analytics aktivieren
Firebase Analytics ist so konzipiert, dass die Akkulaufzeit der Nutzer maximiert wird. Ereignisse werden auf dem Gerät gebündelt und nur gelegentlich an Firebase gesendet. Zu Debugging-Zwecken können wir dieses Verhalten deaktivieren, um Ereignisse in Echtzeit zu sehen, während sie protokolliert werden. Führen Sie dazu den folgenden Befehl in der Shell aus.
Terminal
adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations
Prüfen, ob Analytics-Ereignisse generiert werden
- Öffnen Sie in Android Studio das Logcat-Fenster, um die Protokollierung Ihrer App zu prüfen.
- Stellen Sie den Logcat-Filter auf den String „Logging event“ ein.
- Prüfen Sie, ob jedes Mal, wenn Sie einen Film in der App liken, Analytics-Ereignisse vom Typ „select_item“ gesendet werden.
Sie haben Firebase Analytics jetzt erfolgreich in Ihre App eingebunden. Wenn Nutzer Ihre App verwenden und Filme liken, werden ihre Likes aggregiert protokolliert. Wir verwenden diese aggregierten Daten im Rest dieses Codelabs, um unser Empfehlungsmodell zu trainieren. Im folgenden optionalen Schritt wird beschrieben, wie Sie dafür sorgen, dass dieselben Analytics-Ereignisse, die Sie in Logcat gesehen haben, auch in die Firebase Console übertragen werden. Sie können mit der nächsten Seite fortfahren.
Optional: Analytics-Ereignisse in der Firebase Console bestätigen
- Rufen Sie die Firebase Console auf.
- Wählen Sie unter „Analytics“ die Option DebugView aus.
- Wählen Sie in Android Studio Run (Ausführen) aus, um die App zu starten und einige Filme zur Liste „Gefällt mir“ hinzuzufügen.
- Prüfen Sie in DebugView in der Firebase Console, ob diese Ereignisse protokolliert werden, wenn Sie Filme in der App hinzufügen.
9. Analytics-Daten in BigQuery exportieren
BigQuery 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 BigQuery, damit die von Ihrer App generierten Analytics-Daten automatisch nach BigQuery exportiert werden.
BigQuery-Export aktivieren
- Rufen Sie die Firebase Console auf.
- Klicken Sie neben Projektübersicht auf das Zahnradsymbol für die Einstellungen und wählen Sie dann Projekteinstellungen aus.
- Wählen Sie den Tab Integrationen aus.
- Wählen Sie im Block BigQuery die Option Verknüpfen (oder Verwalten) aus.
- Wählen Sie im Schritt Informationen zum Verknüpfen von Firebase mit BigQuery die Option Weiter aus.
- Klicken Sie im Bereich 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 jetzt in Ihrem Firebase Console-Projekt die automatische Übertragung von Firebase Analytics-Ereignisdaten an BigQuery aktiviert. Das geschieht automatisch, ohne dass Sie etwas tun müssen. Allerdings kann es bis zu 24 Stunden dauern, bis das Analytics-Dataset in BigQuery erstellt wird. Nachdem das Dataset erstellt wurde, exportiert Firebase kontinuierlich neue Analytics-Ereignisse in die BigQuery-Tagesverlaufstabelle und gruppiert Ereignisse aus den vergangenen Tagen 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 Beispieldataset in BigQuery, das wir für den Rest dieser Anleitung verwenden.
10. BigQuery zum Abrufen von Trainingsdaten für Modelle verwenden
Nachdem wir die Firebase Console für den Export nach BigQuery verbunden haben, werden die Ereignisdaten der App-Analyse nach einiger Zeit automatisch in der BigQuery Console angezeigt. Um für diese Anleitung einige erste Daten zu erhalten, importieren wir in diesem Schritt ein vorhandenes Beispieldataset in Ihre BigQuery-Konsole, mit dem wir unser Empfehlungsmodell trainieren können.
Beispieldatensatz in BigQuery importieren
- Rufen Sie in der Google Cloud Console das BigQuery-Dashboard auf.
- Wählen Sie im Menü den Namen Ihres Projekts aus.
- Wählen Sie unten in der linken BigQuery-Navigation Ihren Projektnamen aus, um Details aufzurufen.
- Wählen Sie Dataset erstellen aus, um den Bereich zum Erstellen von Datasets zu öffnen.
- Geben Sie „firebase_recommendations_dataset“ für die Dataset-ID ein und wählen Sie Dataset erstellen aus.
- Das neue Dataset wird im Menü auf der linken Seite unter dem Projektnamen angezeigt. Klicken Sie darauf.
- Wählen Sie Tabelle erstellen aus, um den Bereich zum Erstellen von Tabellen zu öffnen.
- Wählen Sie unter Tabelle erstellen aus die Option „Google Cloud Storage“ aus.
- Geben Sie im Feld Datei aus GCS-Bucket auswählen „gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt“ ein.
- Wählen Sie im Drop-down-Menü Dateiformat die Option „JSONL“ aus.
- Geben Sie „recommendations_table“ als Tabellenname ein.
- Klicken Sie auf das Kästchen unter Schema > Automatisch erkennen > Schema und Eingabeparameter.
- Wählen Sie Tabelle erstellen aus.
Beispiel-Dataset ansehen
An dieser Stelle können Sie optional das Schema untersuchen und eine Vorschau dieses Datensatzes aufrufen.
- Wählen Sie im linken Menü firebase-recommendations-dataset aus, um die darin enthaltenen Tabellen zu maximieren.
- Wählen Sie die Tabelle recommendations-table aus, um das Tabellenschema aufzurufen.
- Wählen Sie Vorschau aus, um die tatsächlichen Analytics-Ereignisdaten zu sehen, die in dieser Tabelle enthalten sind.
Anmeldedaten für ein Dienstkonto erstellen
Als Nächstes erstellen wir Dienstkontoanmeldedaten in unserem Google Cloud Console-Projekt, die wir im nächsten Schritt in der Colab-Umgebung verwenden können, um auf unsere BigQuery-Daten zuzugreifen und sie zu laden.
- Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.
- Aktivieren Sie die BigQuery API und die BigQuery Storage API. < click here>
- Rufen Sie die Seite Dienstkontoschlüssel erstellen auf.
- Wählen Sie aus der Liste Dienstkonto die Option Neues Dienstkonto aus.
- Geben Sie im Feld Dienstkontoname einen Namen ein.
- Wählen Sie in der Liste Rolle die Option Projekt > Inhaber aus.
- Klicken Sie auf Erstellen. Eine JSON-Datei mit Ihrem Schlüssel wird auf Ihren Computer heruntergeladen.
Im nächsten Schritt verwenden wir Google Colab, 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:
- BigQuery-Daten in das Colab-Notebook importieren
- Daten vorverarbeiten, um sie für das Modelltraining vorzubereiten
- Empfehlungsmodell mit den Analysedaten trainieren
- Exportieren Sie das Modell als TF Lite-Modell.
- Das Modell in der Firebase Console bereitstellen, damit wir es in unserer App verwenden können
Bevor wir das Colab-Trainings-Notebook starten, aktivieren wir zuerst die Firebase Model Management API, damit Colab das trainierte Modell in unserer Firebase Console bereitstellen kann.
Firebase Model Management API aktivieren
Bucket zum Speichern Ihrer ML-Modelle erstellen
Rufen Sie in der Firebase Console „Storage“ auf und klicken Sie auf „Jetzt starten“. 
Folgen Sie dem Dialogfeld, um den Bucket einzurichten.
Firebase ML API aktivieren
Rufen Sie in der Google Cloud Console die Firebase ML API-Seite auf und klicken Sie auf „Aktivieren“.
Colab-Notebook zum Trainieren und Bereitstellen des Modells verwenden
Öffnen Sie das Colab-Notebook über den folgenden Link und führen Sie die Schritte darin aus. Nachdem Sie die Schritte im Colab-Notebook ausgeführt haben, wird eine TF Lite-Modelldatei in der Firebase Console bereitgestellt, die wir mit unserer App synchronisieren können.
In Colab öffnen
12. Modell in Ihrer App herunterladen
In diesem Schritt ändern wir unsere App so, dass das gerade trainierte Modell aus Firebase Machine Learning heruntergeladen wird.
Firebase ML-Abhängigkeit hinzufügen
Die folgende Abhängigkeit ist erforderlich, um Firebase Machine Learning-Modelle in Ihrer App zu verwenden. Sie sollte bereits hinzugefügt sein (bitte prüfen).
app/build.grade.kts
implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")
Modell mit der Firebase Model Manager API herunterladen
Kopieren Sie den folgenden Code in RecommendationClient.kt, um die Bedingungen für den Modelldownload festzulegen und eine Downloadaufgabe zu erstellen, mit der das Remote-Modell mit unserer App synchronisiert wird.
RecommendationClient.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-Empfehlungsmodell in Ihre App einbinden
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 Dictionary und Labels, die unser Modell im Inferenzschritt begleiten. Dann fügen wir die Vorverarbeitung hinzu, um die Eingaben für unser Modell zu generieren, und die Nachbearbeitung, um die Ergebnisse aus unserer Inferenz zu extrahieren.
Wörterbuch und Labels laden
Die Labels, 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.
RecommendationClient.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.")
}
}
Vorverarbeitung implementieren
Im Vorverarbeitungsschritt ändern wir die Form der Eingabedaten, damit sie den Erwartungen unseres Modells entsprechen. Hier füllen wir die Eingabelänge mit einem Platzhalterwert auf, wenn wir noch nicht viele Nutzer-Likes generiert haben. Kopieren Sie den folgenden Code:
RecommendationClient.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
}
}
Interpreter ausführen, um Empfehlungen zu generieren
Hier verwenden wir das Modell, das wir in einem vorherigen Schritt heruntergeladen haben, um die Inferenz für unsere vorverarbeitete Eingabe auszuführen. Wir legen den Typ der Ein- und Ausgabe für unser Modell fest und führen die Inferenz aus, um unsere Filmempfehlungen zu generieren. Kopieren Sie den folgenden Code in Ihre App.
RecommendationClient.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()
}
}
}
Nachbearbeitung implementieren
Schließlich verarbeiten wir in diesem Schritt die Ausgabe unseres Modells nach, indem wir die Ergebnisse mit der höchsten Konfidenz auswählen und enthaltene Werte (Filme, die dem Nutzer bereits gefallen haben) entfernen. Kopieren Sie den folgenden Code in Ihre App.
RecommendationClient.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
}
}
App testen
Führen Sie die App noch einmal aus. Wenn Sie einige Filme auswählen, sollte das neue Modell automatisch heruntergeladen und mit der Generierung von Empfehlungen begonnen werden.
14. Glückwunsch!
Sie haben mit TensorFlow Lite und Firebase eine Empfehlungsfunktion in Ihre App eingebaut. Die in diesem Codelab gezeigten Techniken und Pipelines können verallgemeinert und auch für andere Arten von Empfehlungen verwendet werden.
Behandelte Themen
- Firebase ML
- Firebase Analytics
- Analytics-Ereignisse nach BigQuery exportieren
- Analyseereignisse vorverarbeiten
- TensorFlow-Modell für Empfehlungen trainieren
- Modell exportieren und in der Firebase Console bereitstellen
- Filme in einer App empfehlen
Nächste Schritte
- Firebase ML-Empfehlungen in Ihrer App implementieren