Ta strona została przetłumaczona przez Cloud Translation API.

Ćwiczenie z programowania dotyczące optymalizacji zakupów w aplikacji w czasie rzeczywistym na urządzeniu

1. Omówienie

1cbf855eda62c306

Witamy na szkoleniu z programowania poświęconym optymalizacji zakupów w aplikacji w czasie rzeczywistym na urządzeniu. Z tego ćwiczenia w Codelabs dowiesz się, jak za pomocą TensorFlow Lite i Firebase wytrenować i wdrożyć w aplikacji niestandardowy model personalizacji.

Z tego samouczka dowiesz się, jak utworzyć model systemów uczących się pod kątem personalizacji, a zwłaszcza taki, który prognozuje optymalną ofertę zakupów w aplikacji w danym stanie, w którym znajduje się obecny użytkownik. To jest przykład kontekstuowego bandyty – ważnego i powszechnie stosowanego rodzaju problemu związanego z systemami uczącymi się, o którym dowiesz się więcej z tego ćwiczenia z programowania

Czego się nauczysz

Zbieranie danych analitycznych za pomocą Firebase Analytics
Wstępne przetwarzanie danych analitycznych za pomocą BigQuery
Wytrenuj prosty model ML do optymalizacji zakupów w aplikacji na urządzeniu
Wdrażaj modele TFLite w Firebase ML i uzyskuj do nich dostęp ze swojej aplikacji
Wykonuj pomiary i eksperymentuj z różnymi modelami za pomocą Testów A/B Firebase
Trenuj i wdrażaj nowe modele z użyciem najnowszych danych w cyklu cyklicznym

Czego potrzebujesz

Android Studio w wersji 3.4 lub nowszej
Fizyczne urządzenie testowe z Androidem 2.3 lub nowszym i Usługami Google Play w wersji 9.8 lub nowszej albo emulator z Usługami Google Play w wersji 9.8 lub nowszej
w przypadku fizycznego urządzenia testowego – kabel do łączenia
Wiedza o systemach uczących się dla początkujących

Jak wykorzystasz ten samouczek?

Tylko do przeczytania

Przeczytaj go i wykonaj ćwiczenia

Jak oceniasz swoje doświadczenia z tworzeniem aplikacji na Androida?

Początkujący

Poziom średnio zaawansowany

Biegły

2. Określanie problemu

Załóżmy, że tworzysz gry i chcesz na końcu każdego etapu wyświetlać spersonalizowane sugestie zakupów w aplikacji. Za każdym razem możesz wyświetlać tylko ograniczoną liczbę opcji zakupów w aplikacji i nie wiesz, które z nich przyniosą największą liczbę konwersji. Każdy użytkownik i każda sesja jest inna. Jak znaleźć ofertę zakupów w aplikacji, która zapewni najwyższą oczekiwaną nagrodę?

3. Pobieranie przykładowego kodu

Skopiuj repozytorium GitHub z wiersza poleceń.

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

To repozytorium zawiera:

Notatnik Jupyter (.ipynb), który trenuje model personalizacji i pakuje go do modelu TFLite
Przykładowa aplikacja Kotlin, która wykorzystuje model TFLite do tworzenia prognoz na urządzeniu

4. Uruchamianie aplikacji za pomocą Firebase

W ramach tego ćwiczenia w programie zajmiemy się optymalizacją zakupów w aplikacji w naszej fikcyjnej grze – Flappy Sparky. Jest to gra side-scrollowa, w której gracz steruje pędzlem Sparky, próbując przelatać między kolumnami ścian, nie uderzając w nie. Na początku poziomu użytkownik otrzymuje ofertę zakupów w aplikacji z ulepszeniem. W ramach tego ćwiczenia z programowania wdrożymy tylko część aplikacji służącą do optymalizacji zakupów w aplikacji.

Uzyskane tu informacje możesz wykorzystać we własnej aplikacji połączonej z projektem Firebase. Możesz też utworzyć nowy projekt Firebase na potrzeby tego ćwiczenia w Codelabs. Jeśli potrzebujesz pomocy w rozpoczęciu korzystania z Firebase, zapoznaj się z naszymi samouczkami na ten temat ( Android i iOS).

5. Rejestrowanie zdarzeń analitycznych w aplikacji

Zdarzenia Analytics zapewniają wgląd w zachowania użytkowników i służą do trenowania modelu systemów uczących się. Model może na przykład dowiedzieć się, że użytkownicy, którzy grają dłużej, z większym prawdopodobieństwem dokonają zakupu w aplikacji, aby uzyskać dodatkowe życie. Aby poznać te informacje, model ML potrzebuje zdarzeń analitycznych jako danych wejściowych.

Niektóre zdarzenia analityczne, które warto rejestrować:

Jak długo użytkownik gra w grę
na jakim poziomie znajduje się użytkownik,
Ile monet wydaje użytkownik
jakie produkty kupuje użytkownik;

Pobierz przykładowe dane (opcjonalnie)

W kolejnych krokach użyjemy Firebase Analytics do zarejestrowania zdarzeń analitycznych, których użyjemy w naszym modelu. Jeśli masz już dane analityczne, których chcesz użyć, przejdź do sekcji „Wytrenuj model optymalizacji”. tego ćwiczenia z programowania. Możesz skorzystać z naszych przykładowych danych.

Zbieranie danych za pomocą pakietu SDK Firebase Analytics

Będziemy używać Firebase Analytics, aby zbierać te zdarzenia analityczne. Pakiet SDK Firebase Analytics automatycznie rejestruje szereg zdarzeń i właściwości użytkowników. Umożliwia też definiowanie własnych zdarzeń niestandardowych na potrzeby pomiaru zdarzeń występujących w Twojej aplikacji.

Instalowanie pakietu SDK Firebase Analytics

Aby zacząć korzystać z Firebase Analytics w aplikacji, zapoznaj się z dokumentacją „Pierwsze kroki z Google Analytics”. Repozytorium firebase-iap-optimization skopiowane na początku tego ćwiczenia z programowania zawiera już pakiet SDK Firebase Analytics.

Rejestruj zdarzenia niestandardowe

Po skonfigurowaniu pakietu SDK Firebase Analytics możemy zacząć rejestrować zdarzenia potrzebne do trenowania naszego modelu.

Zanim to zrobimy, musisz ustawić w zdarzeniu analitycznym identyfikator User-ID, abyśmy mogli powiązać dane Analytics dotyczące tego użytkownika z jego danymi w aplikacji.

MainActivity.kt

firebaseAnalytics.setUserId("player1")

Teraz możemy zarejestrować zdarzenia związane z odtwarzaczem. W przypadku optymalizacji zakupów w aplikacji chcemy zapisać każdą ofertę zakupów w aplikacji przedstawioną użytkownikowi i sprawdzić, czy została ona kliknięta. Zostaną wyświetlone 2 zdarzenia analityczne: offer_iap i offer_accepted. Będziemy też śledzić niepowtarzalny identyfikator offer_id, który będzie można później wykorzystać do połączenia tych danych i sprawdzenia, czy oferta zostanie zaakceptowana.

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)
  }
}

Więcej informacji o rejestrowaniu zdarzeń niestandardowych znajdziesz w dokumentacji zdarzeń z dziennika Firebase Analytics.

6. Wstępne przetwarzanie danych w BigQuery

W ostatnim kroku gromadziliśmy zdarzenia dotyczące tego, która oferta zakupów w aplikacji jest prezentowana użytkownikowi i która została kliknięta przez użytkownika. W tym kroku połączymy te dane o zdarzeniach z danymi użytkowników, aby nasz model mógł uczyć się na podstawie pełnego obrazu.

W tym celu musimy zacząć od wyeksportowania zdarzeń analitycznych do BigQuery.

Łączenie projektu Firebase z BigQuery

Aby połączyć z BigQuery projekt Firebase i wchodzące w jego skład aplikacje:

Zaloguj się w Firebase.
Kliknij i wybierz Ustawienia projektu.
Na stronie Ustawień projektu kliknij kartę Integracje.
Na karcie BigQuery kliknij Połącz.

(Opcjonalnie) Wyeksportuj kolekcje Firestore do BigQuery

W tym kroku możesz wyeksportować dodatkowe dane użytkownika z Firestore do BigQuery, aby ułatwić trenowanie modelu. Jeśli chcesz na razie pominąć ten krok, przejdź do sekcji „Przygotowywanie danych w BigQuery” tego ćwiczenia z programowania. Możesz śledzić zdarzenia Firebase Analytics zarejestrowane w ostatnim kroku.

W Firestore mogą być przechowywane dane użytkowników daty rejestracji, zakupów w aplikacji, poziomów w grze, dostępnych monet oraz innych atrybutów, które mogą być przydatne przy trenowaniu modelu.

Aby wyeksportować kolekcje Firestore do BigQuery, możesz zainstalować rozszerzenie Firestore BigQuery Export. Następnie połącz tabele w BigQuery, aby połączyć te dane z danymi z Google Analytics, aby wykorzystać je w modelu personalizacji i w innej części tego ćwiczenia z programowania.

Przygotowywanie danych w BigQuery

W kilku następnych krokach użyjemy BigQuery do przekształcenia nieprzetworzonych danych analitycznych w dane nadające się do trenowania naszego modelu.

Aby nasz model mógł nauczyć się, które oferty zakupów w aplikacji wyświetlić na podstawie użytkownika i stanu gry, musimy uporządkować dane dotyczące tych elementów:

użytkownik
stan gry
oferta przedstawiona
kliknięcie lub niezastosowanie przedstawionej oferty;

Aby nasz model mógł je przetworzyć, wszystkie te dane muszą zostać zebrane w jednym wierszu tabeli. Na szczęście mamy w tym celu skonfigurowane narzędzie BigQuery.

BigQuery umożliwia tworzenie „widoków” aby zachować porządek w zapytaniu. Widok to tabela wirtualna zdefiniowana przez zapytanie SQL. Gdy tworzysz widok danych, tworzysz do niego zapytania tak samo jak w przypadku tabeli. W ten sposób możemy najpierw wyczyścić dane analityczne.

Aby sprawdzić, czy użytkownicy kliknęli każdą ofertę zakupu w aplikacji, musimy połączyć zdarzenia offer_iap i offer_accepted zarejestrowane w poprzednim kroku.

all_offers_joined – widok BigQuery

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 – widok BigQuery

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;

Eksportowanie zbioru danych bigQuery do Google Cloud Storage

Możemy też wyeksportować zbiór danych BigQuery do GCS, aby wykorzystać go do trenowania modelu.

7. Wytrenuj model optymalizacji

Przykładowe dane

Użyj danych z poprzedniego kroku: „Wstępne przetwarzanie danych w BigQuery”, lub przykładowe dane do pobrania dostępne tutaj.

Definicja problemu

Zanim zaczniemy trenować model, poświęćmy trochę czasu na zdefiniowanie naszego problemu typu bandyci kontekstowi.

Czym są bandyci kontekstowi

Na początku każdego poziomu w Flanppy Sparky użytkownik otrzymuje ofertę zakupów w aplikacji z ulepszeniami. Za każdym razem możemy wyświetlać tylko jedną opcję zakupów w aplikacji i nie wiemy, która z nich zapewni największą liczbę konwersji. Każdy użytkownik i każda sesja jest inna. Jak znaleźć ofertę zakupów w aplikacji, która zapewni najwyższą oczekiwaną nagrodę?

W tym przypadku przypiszmy nagrodę 0, jeśli użytkownik nie zaakceptuje oferty IAP, i wartość IAP, jeśli zaakceptuje ofertę. Aby zmaksymalizować Twoją nagrodę, możemy wykorzystać nasze dane historyczne do wytrenowania modelu, który przewiduje oczekiwaną nagrodę za każde działanie danego użytkownika i znajduje działanie zapewniające najwyższą nagrodę.

W prognozie wykorzystamy to:

Stan: informacje o użytkowniku i jego bieżącej sesji.
Działanie: oferty zakupów w aplikacji, które możemy wyświetlać
Nagroda: wartość oferty zakupów w aplikacji

Eksploracja a wykorzystanie

W przypadku wszystkich problemów typu wieloręki bandyta algorytm musi znaleźć równowagę między eksploracją (uzyskanie większej ilości danych, aby określić, które działanie zapewnia optymalny wynik) a wykorzystaniem (wykorzystanie optymalnego wyniku w celu uzyskania najwyższej nagrody).

W naszej wersji problemu uprościmy to, aby trenować model tylko okresowo w chmurze i wykonywać prognozy tylko wtedy, gdy używany jest model na urządzeniu użytkownika (a nie na urządzeniu użytkownika). Aby upewnić się, że po użyciu modelu mamy wystarczającą ilość danych treningowych, musimy czasami pokazywać użytkownikom aplikacji wyniki losowe (np. 30%). Ta strategia równoważenia eksploracji i eksploracji nosi nazwę Epsilon-aughdy (Zachłanność Epsilon).

Trenowanie modelu

Aby rozpocząć, możesz użyć skryptu treningowego (training.ipynb) udostępnionego w ramach ćwiczeń z programowania. Naszym celem jest wytrenowanie modelu, który przewiduje oczekiwane nagrody za każde działanie w danym stanie, a następnie znajduje działanie, które zapewnia najwyższe oczekiwane nagrody.

Trenowanie lokalnie

Najłatwiejszym sposobem na rozpoczęcie trenowania własnego modelu jest utworzenie kopii notatnika w przykładowym kodzie powiązanym z tym ćwiczeniem w Codelabs.

Do tego ćwiczenia nie potrzebujesz GPU, ale jeśli potrzebujesz wydajniejszej maszyny do eksploracji własnych danych i trenowania własnego modelu, możesz uzyskać instancję notatnika w AI Platform, aby przyspieszyć trenowanie.

W udostępnionym skrypcie treningowym utworzyliśmy iterator, który generuje dane do trenowania z plików CSV wyeksportowanych z BigQuery. Następnie użyliśmy tych danych do trenowania naszego modelu w Keras. Szczegółowe informacje o tym, jak trenować model, znajdziesz w komentarzach do notatnika w języku Python.

Pomiar skuteczności modelu

Podczas trenowania modelu porównamy go z losowym agentem, który losowo wybiera oferty IAP, aby sprawdzić, czy model faktycznie się uczy. Ta logika jest stosowana w ramach ValidationCallback.

Po zakończeniu trenowania wykorzystujemy dane w tabeli test.csv, aby ponownie przetestować nasz model. Model nigdy nie miał dostępu do tych danych, więc mamy pewność, że wynik nie jest wynikiem nadmiernego dopasowania. W tym przypadku model ma o 28% lepsze wyniki niż agent losowy.

Eksportowanie modelu TFLite

Teraz mamy wytrenowany model gotowy do użycia, ale obecnie jest w formacie TensorFlow. Musimy wyeksportować model w formacie TFLite, aby można go było uruchomić na urządzeniach mobilnych.

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)

Stąd możesz pobrać model i załączyć go z aplikacją.

Opcjonalnie w przypadku aplikacji produkcyjnej zalecamy wdrożenie modelu w Firebase ML i jego hostowanie w Firebase. Jest to przydatne z dwóch głównych powodów:

Rozmiar instalowany aplikacji może być niewielki i pobieramy model tylko w razie potrzeby.
Model może być regularnie aktualizowany i zawierać inny cykl wydawania wersji niż cała aplikacja.

Aby dowiedzieć się, jak wdrożyć model w Firebase ML, wykonaj ćwiczenia z programowania w sekcji Dodawanie Firebase do aplikacji na Androida opartej na TFLite. Możesz je wdrożyć za pomocą konsoli Firebase lub interfejsu API języka Python.

8. Generowanie prognoz na urządzeniu

Następnym krokiem jest stworzenie prognoz przy użyciu modelu działającego na urządzeniu. Przykładowa aplikacja, która pobiera model z Firebase ML, znajduje się w folderze app pobranego przykładowego kodu i używa jej do wnioskowania na podstawie niektórych danych po stronie klienta.

Ponieważ podczas trenowania modelu zastosowaliśmy wstępne przetwarzanie, będziemy musieli zastosować to samo wstępne przetwarzanie do danych wejściowych modelu, gdy będziemy go uruchamiać na urządzeniu. Prosty sposób to użycie formatu niezależnego od platformy i języka, np. pliku JSON zawierającego mapę każdej funkcji do metadanych dotyczących wstępnego przetwarzania danych. Więcej informacji o tym, jak to zrobić, znajdziesz w przykładowej aplikacji.

Następnie przekazujemy modelowi testowe dane wejściowe w ten sposób:

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"
  )

Model sugeruje, że w przypadku tego konkretnego użytkownika najlepszym rozwiązaniem IAP będzie sparky_armor.

Pomiar dokładności modelu

Aby zmierzyć dokładność modelu, możemy po prostu śledzić oferty zakupów w aplikacji prognozowane przez nasz model oraz to, czy są one klikane za pomocą Firebase Analytics. Możesz ich używać razem z Testami A/B Firebase do pomiaru rzeczywistej skuteczności modelu. Pójdź o krok dalej i możesz też przeprowadzać testy A/B na różnych iteracjach modelu. Więcej informacji o testach A/B w Firebase znajdziesz w artykule Tworzenie eksperymentów Zdalnej konfiguracji Firebase z testami A/B.

9. (Opcjonalnie): regularne aktualizowanie modelu o nowe dane

Jeśli musisz aktualizować model w miarę napływania nowych danych, możesz skonfigurować potok, który będzie regularnie trenować model. Aby to zrobić, musisz najpierw upewnić się, że masz nowe dane do wykorzystania do trenowania z użyciem wspomnianej powyżej strategii zachłanności epsilon. (np. z wykorzystaniem wyników prognozy modelu w 70% przypadków i z wykorzystaniem wyników losowych w 30% przypadków).

Konfigurowanie potoku do trenowania i wdrażania z wykorzystaniem nowych danych wykracza poza zakres tego ćwiczenia z programowania. Zacznij od zapoznania się z Google Cloud AI Platform i TFX.

10. Gratulacje!

Dzięki tym ćwiczeniom w programie wiesz, jak wytrenować i wdrożyć model TFLite na urządzeniu, aby zoptymalizować zakupy w aplikacji za pomocą Firebase. Aby dowiedzieć się więcej o TFLite i Firebase, zapoznaj się z innymi przykładami TFLite i przewodnikami dla początkujących użytkowników Firebase.

Jeśli masz pytania, możesz je zadać na stronie Stack Overflow #firebase-machine-learning.