Codelab zur Optimierung von In-App-Käufen auf dem Gerät

1. Übersicht

Hinweis:In diesem Codelab wird die TensorFlow Lite-Bibliothek verwendet. Es wird empfohlen, dass für neuen Code die Google AI Edge LiteRT-Bibliothek verwendet wird.

Willkommen beim Codelab zur In-App-Kaufoptimierung in Echtzeit auf dem Gerät. In diesem Codelab erfahren Sie, wie Sie mit TensorFlow Lite und Firebase ein benutzerdefiniertes Personalisierungsmodell für Ihre App trainieren und bereitstellen.

In dieser Anleitung wird gezeigt, wie Sie ein Modell für maschinelles Lernen zur Personalisierung erstellen, insbesondere ein Modell, das das optimale Angebot für In-App-Käufe (IAP) für den aktuellen Nutzer vorhersagt. Dies ist ein Beispiel für ein kontextbezogenes Bandit-Problem, eine wichtige und weit verbreitete Art von Machine-Learning-Problem, über die Sie in diesem Codelab mehr erfahren.

Lerninhalte

• Analysedaten über Firebase Analytics erheben
• Analysedaten mit BigQuery vorverarbeiten
• Einfaches ML-Modell für die Optimierung von In-App-Käufen auf dem Gerät trainieren
• TFLite-Modelle in Firebase ML bereitstellen und über Ihre App darauf zugreifen
• Verschiedene Modelle mit Firebase A/B Testing analysieren und testen
• Neue Modelle regelmäßig mit den neuesten Daten trainieren und bereitstellen

Voraussetzungen

• Android Studio ab Version 3.4
• Ein physisches Testgerät mit Android 2.3 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 physisches Testgerät verwenden, ein Verbindungskabel
• Grundlegende ML-Kenntnisse

Wie werden Sie diese Anleitung verwenden?

Nur lesen Lesen und Übungen durchführen

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

Anfänger Mittelstufe Fortgeschritten

2. Problembeschreibung

Angenommen, Sie sind Spieleentwickler und möchten am Ende jedes Levels personalisierte Vorschläge für In-App-Käufe (IAP) anzeigen. Sie können jeweils nur eine begrenzte Anzahl von IAP-Optionen präsentieren und wissen nicht, welche die beste Conversion-Rate erzielen. Da jeder Nutzer und jede Sitzung anders ist, wie finden wir das IAP-Angebot, das die höchste erwartete Belohnung bietet?

3. Beispielcode abrufen

Klonen Sie das GitHub-Repository über die Befehlszeile.

git clone https://github.com/googlecodelabs/firebase-iap-optimization.git

Dieses Repository enthält:

1. Ein Jupyter-Notebook (.ipynb), in dem das Personalisierungsmodell trainiert und in ein TFLite-Modell verpackt wird
2. Eine Kotlin-Beispiel-App, die das TFLite-Modell verwendet, um Vorhersagen auf dem Gerät zu treffen

4. App mit Firebase ausführen

In diesem Codelab optimieren wir die In-App-Produkte unserer fiktiven Spiele-App Flappy Sparky. Das Spiel ist ein Side-Scroller, bei dem der Spieler einen Sparky steuert, der versucht, zwischen Mauerspalten hindurchzufliegen, ohne sie zu berühren. Zu Beginn des Levels wird dem Nutzer ein IAP-Angebot präsentiert, mit dem er ein Power-up erhält. In diesem Codelab implementieren wir nur den Teil der App, der für die IAP-Optimierung zuständig ist.

Das hier Gelernte können Sie auf Ihre eigene App anwenden, die mit einem Firebase-Projekt verbunden ist. Alternativ können Sie ein neues Firebase-Projekt für dieses Codelab erstellen. Wenn Sie Hilfe bei den ersten Schritten mit Firebase benötigen, sehen Sie sich unsere Tutorials zu diesem Thema an ( Android und iOS).

5. Analytics-Ereignisse in Ihrer App erfassen

Analyseereignisse geben Aufschluss über das Nutzerverhalten und werden zum Trainieren des ML-Modells verwendet. Das Modell kann beispielsweise lernen, dass Nutzer, die länger spielen, eher In-App-Käufe tätigen, um Extraleben zu erhalten. Das ML-Modell benötigt Analytics-Ereignisse als Eingabe, um diese Informationen zu lernen.

Einige Analyseereignisse, die wir möglicherweise protokollieren möchten, sind:

• Wie lange der Nutzer das Spiel spielt
• Welche Stufe der Nutzer erreicht
• Wie viele Coins der Nutzer ausgibt
• Welche Artikel der Nutzer kauft

Beispieldaten herunterladen (optional)

In den folgenden Schritten verwenden wir Firebase Analytics, um Analytics-Ereignisse zu protokollieren, die in unserem Modell verwendet werden sollen. Wenn Sie bereits Analysedaten haben, die Sie verwenden möchten, können Sie zum Abschnitt „Optimierungsmodell trainieren“ dieses Codelabs springen und unsere Beispieldaten verwenden.

Daten mit dem Firebase Analytics SDK erheben

Wir verwenden Firebase Analytics, um diese Analyseereignisse zu erfassen. Mit dem Firebase Analytics SDK werden automatisch eine Reihe von Ereignissen und Nutzereigenschaften erfasst. Außerdem können Sie eigene benutzerdefinierte Ereignisse definieren, um die Ereignisse zu messen, die für Ihre App spezifisch sind.

Firebase Analytics SDK installieren

Hier finden Sie eine Anleitung für den Einstieg in Firebase Analytics in Ihrer App. Das firebase-iap-optimization-Repository, das am Anfang dieses Codelabs geklont wurde, enthält bereits das Firebase Analytics SDK.

Benutzerdefinierte Ereignisse erfassen

Nachdem wir das Firebase Analytics SDK eingerichtet haben, können wir mit dem Protokollieren der Ereignisse beginnen, die wir zum Trainieren unseres Modells benötigen.

Dazu müssen wir aber zuerst eine User-ID im Analytics-Ereignis festlegen, damit wir die Analytics-Daten für diesen Nutzer mit seinen vorhandenen Daten in der App verknüpfen können.

MainActivity.kt

firebaseAnalytics.setUserId("player1")

Als Nächstes können wir Player-Ereignisse protokollieren. Zur Optimierung von In-App-Produkten möchten wir jedes dem Nutzer präsentierte Angebot für In-App-Produkte protokollieren und erfassen, ob der Nutzer auf das Angebot klickt. Dadurch erhalten wir zwei Analyseereignisse: offer_iap und offer_accepted. Wir erfassen auch eine eindeutige „offer_id“, damit wir diese Daten später kombinieren können, um zu sehen, ob ein Angebot angenommen wird.

MainActivity.kt

predictButton?.setOnClickListener {
  predictionResult = iapOptimizer.predict()

  firebaseAnalytics.logEvent("offer_iap"){
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

acceptButton?.setOnClickListener {
  firebaseAnalytics.logEvent("offer_accepted") {
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

Weitere Informationen zum Protokollieren benutzerdefinierter Ereignisse

6. Daten in BigQuery vorverarbeiten

Im letzten Schritt haben wir Ereignisse dazu erfasst, welches IAP-Angebot dem Nutzer präsentiert wird und auf welches IAP-Angebot der Nutzer klickt. In diesem Schritt kombinieren wir diese Ereignisdaten mit Nutzerdaten, damit unser Modell aus einem vollständigen Bild lernen kann.

Dazu müssen wir zuerst die Analyseereignisse nach BigQuery exportieren.

Firebase-Projekt mit BigQuery verknüpfen

So verknüpfen Sie ein Firebase-Projekt und zugehörige Apps mit BigQuery:

1. Melden Sie sich in Firebase an.
2. Klicken Sie auf  und wählen Sie „Projekteinstellungen“ aus.
3. Klicken Sie auf der Seite „Projekteinstellungen“ auf den Tab „Integrationen“.
4. Klicken Sie auf der BigQuery-Karte auf „Verknüpfen“.

(Optional) Firestore-Sammlungen nach BigQuery exportieren

In diesem Schritt haben Sie die Möglichkeit, zusätzliche Nutzerdaten aus Firestore in BigQuery zu exportieren, um das Modell zu trainieren. Wenn Sie diesen Schritt jetzt überspringen möchten, können Sie zum Abschnitt „Daten in BigQuery vorbereiten“ dieses Codelabs springen und die Firebase Analytics-Ereignisse verwenden, die im letzten Schritt protokolliert wurden.

In Firestore haben Sie möglicherweise das Anmeldedatum von Nutzern, In-App-Käufe, Level im Spiel, Guthaben oder andere Attribute gespeichert, die für das Trainieren des Modells nützlich sein könnten.

Wenn Sie Ihre Firestore-Sammlungen nach BigQuery exportieren möchten, können Sie die Firestore BigQuery Export Extension installieren. Verknüpfen Sie dann Tabellen in BigQuery, um diese Daten mit den Daten aus Google Analytics zu kombinieren. So können Sie sie in Ihrem Personalisierungsmodell und im restlichen Codelab verwenden.

Daten in BigQuery vorbereiten

In den nächsten Schritten verwenden wir BigQuery, um unsere Analytics-Rohdaten in Daten umzuwandeln, die zum Trainieren unseres Modells verwendet werden können.

Damit unser Modell lernen kann, welches IAP-Angebot basierend auf dem Nutzer und dem Spielstatus präsentiert werden soll, müssen wir Daten zu Folgendem organisieren:

• den Nutzer
• Spielstatus
• das präsentierte Angebot
• ob auf das präsentierte Angebot geklickt wird

Alle diese Daten müssen in einer einzelnen Zeile in einer Tabelle organisiert werden, damit unser Modell sie verarbeiten kann. Glücklicherweise ist BigQuery genau dafür konzipiert.

In BigQuery können Sie „Ansichten“ erstellen, um Ihre Abfragen zu organisieren. Eine Ansicht ist eine virtuelle Tabelle, die durch eine SQL-Abfrage definiert wird. Wenn Sie eine Ansicht erstellen, fragen Sie diese genauso wie eine Tabelle ab. Damit können wir zuerst unsere Analysedaten bereinigen.

Um zu sehen, ob auf jedes In-App-Kaufangebot geklickt wird, müssen wir die Ereignisse offer_iap und offer_accepted, die wir im vorherigen Schritt protokolliert haben, zusammenführen.

all_offers_joined – BigQuery-Ansicht

SELECT
  iap_offers.*,
  CASE
    WHEN accepted_offers.accepted IS NULL THEN FALSE ELSE TRUE
  END
  is_clicked,
FROM
  `iap-optimization.ml_sample.accepted_offers` AS accepted_offers
RIGHT JOIN
  `iap-optimization.ml_sample.iap_offers` AS iap_offers
ON
 accepted_offers.offer_id =iap_offers.offer_id;

all_offers_with_user_data – BigQuery-Ansicht

SELECT
  offers.is_clicked,
  offers.presented_powerup,
  offers.last_run_end_reason,
  offers.event_timestamp,
  users.*
FROM
  `iap-optimization.ml_sample.all_offers_joined` AS offers
LEFT JOIN
  `iap-optimization.ml_sample.all_users` AS users
ON
  users.user_id = offers.user_id;

BigQuery-Dataset in Google Cloud Storage exportieren

Schließlich können wir das BigQuery-Dataset in GCS exportieren, damit wir es für das Modelltraining verwenden können.

7. Optimierungsmodell trainieren

Beispieldaten

Verwenden Sie entweder Ihre Daten aus dem vorherigen Schritt „Daten in BigQuery vorverarbeiten“ oder die hier bereitgestellten herunterladbaren Beispieldaten, um den Rest dieses Codelabs nachzuvollziehen.

Problem definition

Bevor wir mit dem Training des Modells beginnen, definieren wir das Problem mit kontextbezogenen Banditen.

Kontextbezogene Banditenalgorithmen

Zu Beginn jedes Levels in Flappy Sparky wird dem Nutzer ein Angebot für In-App-Produkte präsentiert, mit dem er ein Power-up erhält. Wir können jeweils nur eine IAP-Option präsentieren und wissen nicht, welche die beste Conversion-Rate erzielt. Da jeder Nutzer und jede Sitzung anders ist, wie finden wir das IAP-Angebot, das die höchste erwartete Belohnung bietet?

In diesem Fall legen wir die Prämie auf 0 fest, wenn der Nutzer das IAP-Angebot nicht annimmt, und auf den IAP-Wert, wenn er es annimmt. Um die Prämie zu maximieren, können wir unsere Verlaufsdaten verwenden, um ein Modell zu trainieren, das die erwartete Prämie für jede Aktion für einen bestimmten Nutzer vorhersagt, und die Aktion mit der höchsten Prämie ermitteln.

Folgendes wird für die Vorhersage verwendet:

• Status: Informationen zum Nutzer und seiner aktuellen Sitzung
• Aktion: IAP-Angebote, die wir anzeigen können
• Prämie: Wert des IAP-Angebots

Ausnutzung vs. Exploration

Bei allen Multi-Armed Bandit-Problemen muss der Algorithmus ein Gleichgewicht zwischen Exploration (mehr Daten erfassen, um herauszufinden, welche Aktion das optimale Ergebnis liefert) und Exploitation (das optimale Ergebnis nutzen, um die höchste Belohnung zu erzielen) finden.

In unserer Version des Problems vereinfachen wir dies, indem wir das Modell nur regelmäßig in der Cloud trainieren und Vorhersagen nur dann treffen, wenn das Modell auf dem Gerät des Nutzers verwendet wird (im Gegensatz zum Training auch auf dem Gerät des Nutzers). Damit wir nach der Verwendung des Modells über genügend Trainingsdaten verfügen, müssen wir unseren App-Nutzern manchmal (z.B. in 30 % der Fälle) zufällige Ergebnisse präsentieren. Diese Strategie, bei der Exploration und Exploitation ausgeglichen werden, wird als Epsilon-greedy bezeichnet.

Modell trainieren

Sie können das mit dem Codelab bereitgestellte Trainingsskript (training.ipynb) verwenden, um loszulegen. Unser Ziel ist es, ein Modell zu trainieren, das die erwarteten Belohnungen für jede Aktion in einem bestimmten Zustand vorhersagt. Anschließend suchen wir nach der Aktion, die die höchsten erwarteten Belohnungen bietet.

Lokales Training

Am einfachsten beginnen Sie mit dem Training Ihres eigenen Modells, indem Sie eine Kopie des Notebooks im Codebeispiel für dieses Codelab erstellen.

Für dieses Codelab benötigen Sie keine GPU. Wenn Sie jedoch eine leistungsstärkere Maschine benötigen, um Ihre eigenen Daten zu untersuchen und Ihr eigenes Modell zu trainieren, können Sie eine AI Platform Notebook-Instanz verwenden, um das Training zu beschleunigen.

Im bereitgestellten Trainingsskript haben wir einen Iterator erstellt, der Trainingsdaten aus den CSV-Dateien generiert, die wir aus BigQuery exportiert haben. Anschließend haben wir die Daten verwendet, um unser Modell mit Keras zu trainieren. Details zum Trainieren des Modells finden Sie in den Kommentaren des Python-Notebooks.

Modellleistung messen

Während des Trainings des Modells vergleichen wir es mit einem zufälligen Agenten, der IAP-Angebote zufällig auswählt, um zu sehen, ob unser Modell tatsächlich lernt. Diese Logik befindet sich unter ValidationCallback..

Am Ende des Trainings verwenden wir Daten in test.csv, um unser Modell noch einmal zu testen. Das Modell hat diese Daten noch nie gesehen. Wir können also davon ausgehen, dass das Ergebnis nicht auf Überanpassung beruht. In diesem Fall ist das Modell 28% besser als der zufällige Agent.

TFLite-Modell exportieren

Jetzt haben wir ein trainiertes Modell, das wir verwenden können. Es ist jedoch derzeit in einem TensorFlow-Format. Wir müssen das Modell im TFLite-Format exportieren, damit es auf Mobilgeräten ausgeführt werden kann.

train.ipynb

converter = tflite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with tf.io.gfile.GFile('iap-optimizer.tflite', 'wb') as f:
  f.write(tflite_model)

Hier können Sie das Modell herunterladen und mit Ihrer App bündeln.

Für eine Produktions-App empfehlen wir optional, das Modell in Firebase ML bereitzustellen und von Firebase hosten zu lassen. Das ist aus zwei Hauptgründen nützlich:

1. Wir können die Installationsgröße der App gering halten und das Modell nur bei Bedarf herunterladen.
2. Das Modell kann regelmäßig und mit einem anderen Releasezyklus als die gesamte App aktualisiert werden.

Im Codelab Firebase zu meiner TFLite-basierten Android-App hinzufügen erfahren Sie, wie Sie das Modell in Firebase ML bereitstellen. Sie können die Bereitstellung über die Firebase Console oder die Python API vornehmen.

8. Vorhersagen auf dem Gerät treffen

Im nächsten Schritt treffen Sie mit dem Modell Vorhersagen auf dem Gerät. Eine Beispiel-App, die ein Modell aus Firebase ML herunterlädt, finden Sie im Ordner app des heruntergeladenen Beispielcodes. Mit dieser App können Sie Rückschlüsse aus einigen clientseitigen Daten ziehen.

Da wir während des Modelltrainings eine Vorverarbeitung angewendet haben, müssen wir dieselbe Vorverarbeitung auf die Modelleingabe anwenden, wenn das Modell auf dem Gerät ausgeführt wird. Eine einfache Möglichkeit hierfür ist die Verwendung eines plattform- und sprachunabhängigen Formats wie einer JSON-Datei, die eine Zuordnung jedes Features zu Metadaten zur Vorverarbeitung enthält. Weitere Informationen dazu finden Sie in der Beispiel-App.

Als Nächstes geben wir dem Modell eine Testeingabe:

IapOptimzer.kt

  val testInput = mapOf(
    "coins_spent" to                       2048f,
    "distance_avg" to                      1234f,
    "device_os" to                         "ANDROID",
    "game_day" to                          10f,
    "geo_country" to                       "Canada",
    "last_run_end_reason" to               "laser"
  )

Das Modell schlägt sparky_armor als bestes IAP-Power-up für diesen Nutzer vor.

Modellgenauigkeit messen

Um die Genauigkeit unseres Modells zu messen, können wir einfach mit Firebase Analytics erfassen, welche IAP-Angebote von unserem Modell vorhergesagt werden und ob sie angeklickt werden. Sie können diese Funktion zusammen mit Firebase A/B Testing verwenden, um die tatsächliche Leistung des Modells zu messen. Sie können auch A/B-Tests für verschiedene Iterationen des Modells durchführen. Weitere Informationen zu A/B-Tests mit Firebase

9. (Optional): Modell regelmäßig mit neuen Daten aktualisieren

Wenn Sie Ihr Modell aktualisieren müssen, sobald neue Daten eingehen, können Sie eine Pipeline einrichten, um Ihr Modell regelmäßig neu zu trainieren. Dazu müssen Sie zuerst dafür sorgen, dass Sie neue Daten für das Training mit der oben erwähnten Epsilon-Greedy-Strategie haben. Beispiel: Das Ergebnis der Modellvorhersage wird zu 70% der Zeit verwendet und zufällige Ergebnisse zu 30% der Zeit.

Das Konfigurieren einer Pipeline für das Training und die Bereitstellung mit neuen Daten geht über den Rahmen dieses Codelabs hinaus. Informationen zu den ersten Schritten finden Sie unter Google Cloud AI Platform und TFX.

10. Glückwunsch!

In diesem Codelab haben Sie gelernt, wie Sie ein TFLite-Modell auf dem Gerät trainieren und bereitstellen, um In-App-Käufe mit Firebase zu optimieren. Weitere Informationen zu TFLite und Firebase finden Sie in den anderen TFLite-Beispielen und den Firebase-Anleitungen für den Einstieg.

Wenn Sie Fragen haben, können Sie sie auf Stack Overflow #firebase-machine-learning stellen.

Behandelte Themen

• TensorFlow Lite
• Firebase ML
• Firebase Analytics
• BigQuery

Nächste Schritte

• Optimierermodell für Ihre App trainieren und bereitstellen

Weitere Informationen

• Dokumentation zu Firebase Machine Learning
• TensorFlow Lite-Dokumentation
• Modelle mit Firebase A/B Testing testen