Diese Seite wurde von der Cloud Translation API übersetzt.

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

1. Übersicht

Willkommen beim Codelab zur Optimierung von In-App-Käufen auf dem Gerät in Echtzeit. In diesem Codelab erfahren Sie, wie Sie mit TensorFlow Lite und Firebase ein benutzerdefiniertes Personalisierungsmodell trainieren und in Ihrer App bereitstellen.

In dieser Anleitung wird gezeigt, wie Sie ein Modell für maschinelles Lernen zur Personalisierung erstellen, insbesondere eines, das das optimale In-App-Angebot (IAP) für den aktuellen Nutzerstatus vorhersagt. Dies ist ein Beispiel für ein bedingtes Banditenproblem, eine wichtige und weithin anwendbare Art von Problem im Bereich maschinelles Lernen. Weitere Informationen finden Sie in diesem Codelab.

Lerninhalte

Analysedaten über Firebase Analytics erheben
Analysedaten mit BigQuery vorverarbeiten
Ein einfaches ML-Modell für die On-Device-Optimierung von In-App-Käufen (IAPs) trainieren
TFLite-Modelle in Firebase ML bereitstellen und von Ihrer App aus darauf zugreifen
Mit Firebase A/B Testing verschiedene Modelle messen und testen
Neue Modelle mit den neuesten Daten in regelmäßigen Abständen trainieren und bereitstellen

Voraussetzungen

Android Studio Version 3.4 oder höher
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
Bei Verwendung eines physischen Testgeräts: Verbindungskabel
Keine Vorkenntnisse in ML

Wie möchten Sie diese Anleitung verwenden?

Nur durchlesen

Durchlesen und die Übungen absolvieren

Wie würden Sie Ihre Erfahrung mit der Entwicklung von Android-Apps bewerten?

Anfänger

Fortgeschritten

Erfahren

2. Problembeschreibung

Angenommen, Sie sind Spieleentwickler und möchten am Ende jedes Levels personalisierte Vorschläge für In-App-Käufe anzeigen lassen. Sie können jeweils nur eine begrenzte Anzahl von In-App-Kaufoptionen anzeigen und wissen nicht, welche die beste Conversion erzielen. Da jeder Nutzer und jede Sitzung anders ist, wie finden wir das In-App-Angebot mit der höchsten erwarteten Prämie?

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:

Ein Jupyter-Notebook (.ipynb), mit dem das Personalisierungsmodell trainiert und in ein TFLite-Modell verpackt wird
Eine Beispiel-Kotlin-App, die das TFLite-Modell zum Erstellen von Vorhersagen auf dem Gerät verwendet

4. App mit Firebase ausführen

In diesem Codelab optimieren wir die In-App-Produkte unserer fiktiven Game-App Flappy Sparky. Das Spiel ist ein Side-Scroller, in dem der Spieler einen Sparky steuert und versucht, zwischen Säulen von Wänden zu fliegen, ohne sie zu berühren. Zu Beginn des Levels wird dem Nutzer ein In-App-Angebot angezeigt, mit dem er ein Powerup erhält. In diesem Codelab implementieren wir nur den Teil der App, der für die Optimierung von In-App-Produkten zuständig ist.

Sie können das Gelernte auf Ihre eigene App anwenden, die mit einem Firebase-Projekt verbunden ist. Alternativ können Sie für dieses Codelab ein neues Firebase-Projekt erstellen. Wenn Sie Hilfe beim Einstieg in Firebase benötigen, sehen Sie sich unsere Anleitungen zu diesem Thema an ( Android und iOS).

5. Analytics-Ereignisse in Ihrer App erfassen

Analytics-Ereignisse liefern Einblicke in das Nutzerverhalten und werden zum Trainieren des ML-Modells verwendet. Das Modell kann beispielsweise lernen, dass Nutzer, die länger spielen, mit größerer Wahrscheinlichkeit In-App-Produkte kaufen, um zusätzliche Leben zu erhalten. Das ML-Modell benötigt Analyseereignisse als Eingabe, um diese Informationen zu lernen.

Beispiele für Analyseereignisse, die Sie erfassen können:

Wie lange der Nutzer das Spiel spielt
Welche Stufe der Nutzer erreicht
Wie viele Münzen der Nutzer ausgibt
Welche Artikel der Nutzer kauft

Beispieldaten herunterladen (optional)

In den folgenden Schritten erfassen wir mit Firebase Analytics Analyseereignisse, die wir in unserem Modell verwenden. Wenn Sie bereits Analysedaten haben, die Sie verwenden möchten, springen Sie in diesem Codelab zum Abschnitt „Optimierungsmodell trainieren“ und folgen Sie der Anleitung mit unseren Beispieldaten.

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 erfassen, die für Ihre App einzigartig sind.

Firebase Analytics SDK installieren

Wenn Sie Firebase Analytics in Ihrer App verwenden möchten, folgen Sie der Anleitung zum Einstieg in Google Analytics. Das firebase-iap-optimization-Repository, das zu Beginn 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 die Ereignisse protokollieren, die wir zum Trainieren unseres Modells benötigen.

Bevor wir das tun, ist es wichtig, im Analytics-Ereignis eine Nutzer-ID festzulegen, damit wir 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 Spielerereignisse erfassen. Zur Optimierung von In-App-Produkten möchten wir jedes In-App-Angebot erfassen, das dem Nutzer präsentiert wird, und ob der Nutzer darauf klickt. Dadurch erhalten wir zwei Analyseereignisse: offer_iap und offer_accepted. Außerdem wird eine eindeutige offer_id erfasst, damit wir diese Daten später kombinieren können, um zu sehen, ob ein Angebot angenommen wurde.

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 Erfassen benutzerdefinierter Ereignisse finden Sie in der Dokumentation zu Firebase Analytics-Ereignisprotokollen.

6. Daten in BigQuery vorverarbeiten

Im letzten Schritt haben wir Ereignisse erfasst, die Aufschluss darüber geben, welches In-App-Angebot dem Nutzer präsentiert wird und auf welches er 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:

Melden Sie sich in Firebase an.
Klicken Sie auf und wählen Sie „Projekteinstellungen“ aus.
Klicken Sie auf der Seite „Projekteinstellungen“ auf den Tab „Integrationen“.
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 nach BigQuery zu exportieren, um das Modell zu trainieren. Wenn Sie diesen Schritt vorerst überspringen möchten, springen Sie in diesem Codelab zum Abschnitt „Daten in BigQuery vorbereiten“. Dort können Sie den im letzten Schritt protokollierten Firebase Analytics-Ereignissen folgen.

In Firestore haben Sie möglicherweise das Anmeldedatum der Nutzer, getätigte In-App-Käufe, Level im Spiel, Guthaben an Münzen oder andere Attribute gespeichert, die für das Training des Modells nützlich sein könnten.

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

Daten in BigQuery vorbereiten

In den nächsten Schritten verwenden wir BigQuery, um unsere Rohanalysedaten in Daten umzuwandeln, die für das Training unseres Modells verwendet werden können.

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

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

Alle diese Daten müssen in einer einzelnen Zeile in einer Tabelle organisiert werden, damit unser Modell sie verarbeiten kann. Glücklicherweise ist BigQuery so konzipiert, dass wir genau das tun können.

In BigQuery können Sie „Ansichten“ erstellen, um Ihre Abfrage übersichtlich zu gestalten. 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. So können wir unsere Analysedaten zuerst bereinigen.

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

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

Zum Schluss können wir das BigQuery-Dataset nach 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 zum Download verfügbaren Beispieldaten, um den Rest dieses Codelabs auszuführen.

Problem definition

Bevor wir mit dem Training des Modells beginnen, sollten wir unser bedingtes Banditenproblem genauer definieren.

Kontextbezogene Banditen

Zu Beginn jedes Levels in Flappy Sparky wird dem Nutzer ein In-App-Angebot angezeigt, mit dem er ein Powerup erhält. Wir können jeweils nur eine In-App-Kaufoption anzeigen und wissen nicht, welche die beste Conversion erzielt. Da jeder Nutzer und jede Sitzung unterschiedlich ist, wie finden wir das In-App-Angebot mit der höchsten erwarteten Prämie?

In diesem Fall setzen wir die Prämie auf 0, wenn der Nutzer das In-App-Angebot nicht annimmt, und auf den In-App-Wert, wenn er es annimmt. Um die Prämie zu maximieren, können wir anhand unserer bisherigen Daten ein Modell trainieren, das die erwartete Prämie für jede Aktion eines Nutzers vorhersagt und die Aktion mit der höchsten Prämie ermittelt.

Für die Vorhersage verwenden wir Folgendes:

Status: Informationen zum Nutzer und zur aktuellen Sitzung
Aktion: In-App-Angebote, die wir präsentieren können
Prämie: Wert des In-App-Angebots

Exploitation vs. Exploration

Bei allen Problemen mit mehreren Banditen muss der Algorithmus zwischen Exploration (Erhebung weiterer Daten, um herauszufinden, welche Aktion das optimale Ergebnis liefert) und Exploitation (Nutzung des optimalen Ergebnisses, um die höchste Belohnung zu erhalten) einen Ausgleich finden.

In unserer Version des Problems vereinfachen wir dies, indem wir das Modell nur regelmäßig in der Cloud trainieren und nur Vorhersagen machen, 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 genügend Trainingsdaten haben, müssen wir unseren App-Nutzern manchmal zufällige Ergebnisse anzeigen (z.B. 30%). Diese Strategie, Exploration und Exploitation in Einklang zu bringen, wird als Epsilon-Greedy bezeichnet.

Modell trainieren

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

Lokales Training

Am einfachsten können Sie mit dem Trainieren Ihres eigenen Modells beginnen, 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 einen leistungsstärkeren Computer benötigen, um Ihre eigenen Daten zu untersuchen und ein eigenes Modell zu trainieren, können Sie eine Notebook-Instanz der AI Platform verwenden, um das Training zu beschleunigen.

Im bereitgestellten Trainingsskript haben wir einen Iterationsmechanismus erstellt, der Trainingsdaten aus den CSV-Dateien generiert, die wir aus BigQuery exportiert haben. Anschließend haben wir mit den Daten begonnen, 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 vergleichen wir das Modell mit einem zufälligen Kundenservicemitarbeiter, 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 die 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 eine Überanpassung zurückzuführen ist. In diesem Fall ist das Modell 28% leistungsfähiger als der zufällige Agent.

TFLite-Modell exportieren

Jetzt haben wir ein trainiertes Modell, das einsatzbereit ist, 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.

Optional können Sie das Modell für eine Produktions-App in Firebase ML bereitstellen und es von Firebase hosten lassen. Das ist aus zwei Hauptgründen nützlich:

Wir können die Installationsgröße der App klein halten und das Modell nur bei Bedarf herunterladen.
Das Modell kann regelmäßig und mit einem anderen Release-Zyklus als die gesamte App aktualisiert werden.

Informationen zum Bereitstellen des Modells in Firebase ML finden Sie im Codelab Firebase zu Ihrer TFLite-basierten Android-App hinzufügen. Sie haben die Möglichkeit, die Bereitstellung über die Firebase Console oder die Python API vorzunehmen.

8. Vorhersagen auf dem Gerät treffen

Im nächsten Schritt werden Vorhersagen mit dem Modell auf dem Gerät getroffen. Im Ordner app des heruntergeladenen Beispielcodes finden Sie eine Beispiel-App, die ein Modell aus Firebase ML herunterlädt und damit Inferenzen mit einigen clientseitigen Daten durchführt.

Da wir während des Modelltrainings eine Vorverarbeitung angewendet haben, müssen wir dieselbe Vorverarbeitung auf die Modelleingabe anwenden, wenn wir sie auf dem Gerät ausführen. Eine einfache Möglichkeit dazu ist die Verwendung eines plattform- und sprachunabhängigen Formats wie einer JSON-Datei, die eine Zuordnung aller 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 vor, dass sparky_armor das beste In-App-Kauf-Powerup für diesen Nutzer ist.

Modellgenauigkeit messen

Um die Genauigkeit unseres Modells zu messen, können wir einfach mit Firebase Analytics nachverfolgen, welche In-App-Angebote von unserem Modell vorhergesagt wurden und ob sie angeklickt wurden. Sie können dies in Kombination mit Firebase A/B-Tests 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 finden Sie in der Dokumentation Firebase Remote Config-Tests mit A/B Testing erstellen.

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 zum Trainieren mit der oben genannten Epsilon-Greedy-Strategie haben. (z.B. 70% der Zeit das Modellergebnis und 30% der Zeit zufällige Ergebnisse verwenden).

Die Konfiguration einer Pipeline für das Training und die Bereitstellung mit neuen Daten geht über den Rahmen dieses Codelabs hinaus. Weitere Informationen finden Sie unter Google Cloud AI Platform und TFX.

10. Glückwunsch!

In diesem Codelab haben Sie gelernt, wie Sie ein On-Device-TFLite-Modell zur Optimierung von In-App-Käufen mit Firebase trainieren und bereitstellen. Weitere Informationen zu TFLite und Firebase finden Sie in anderen TFLite-Beispielen und in den Firebase-Einstiegsanleitungen.

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